Skip to content
Python
6.7 KB
Raw Blame
//! First-class teams use the same approved releases and original shared environment.
use crate::{
    http::{ApiError, App},
    management, service,
};
use anyhow::{ensure, Context, Result};
use axum::{extract::Path, http::HeaderMap, Extension, Json};
use openworker_store_postgres::service_catalog::{Profile, Release};
use serde::Deserialize;
use serde_json::{json, Value};
use std::collections::BTreeMap;
#[derive(Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub(crate) struct Create {
    coding: Option<openworker_runtime::coding_handoff::config::TeamConfig>,
    workspace_defaults: Option<openworker_runtime::team_workspace_defaults::WorktreeDefaults>,
    #[serde(default = "lead")]
    agent_id: String,
    agent_types: BTreeMap<String, String>,
    #[serde(default)]
    policy: openworker_runtime::team_coordination::Policy,
    limits: Option<openworker_runtime::budget::Limits>,
    delegation: Option<openworker_runtime::team_definition::Delegation>,
}
fn lead() -> String {
    "lead".into()
}
pub(crate) async fn create(
    Extension(app): Extension<App>,
    Path(sid): Path<String>,
    Json(body): Json<Create>,
) -> Result<Json<Value>, ApiError> {
    Ok(Json(openworker_runtime::agent_team::public_snapshot(
        create_inner(app, sid, body).await?,
    )))
}
async fn create_inner(app: App, sid: String, body: Create) -> Result<Value> {
    ensure!(
        (1..=32).contains(&body.agent_types.len()),
        "Register 1..32 team types"
    );
    app.store.authorize(
        openworker_store_postgres::auth::Action::Control,
        Some(&sid),
        None,
    )?;
    let snapshot = app.store.read_snapshot(&sid)?;
    let identity = app
        .store
        .service_session_identity(&sid)?
        .context("Team lead must be an admitted service session")?;
    let profile_id = identity["runtimeProfile"]
        .as_str()
        .context("Missing profile")?;
    let profile = app.store.catalog_get("profile", profile_id)?;
    let p: Profile = serde_json::from_value(profile.definition.clone())?;
    ensure!(
        profile.activated && p.sharing == openworker_runtime::environment::Sharing::Shared,
        "Teams require an activated shared RuntimeProfile"
    );
    let source_store_binding = if body.coding.is_some() {
        Some(
            app.config
                .artifacts
                .as_ref()
                .context("Isolated coding requires configured artifacts")?
                .build()?
                .binding()
                .clone(),
        )
    } else {
        None
    };
    let repository_access =
        app.config
            .repository_catalog(&app.store, &p, body.delegation.as_ref())?;
    let mut models = BTreeMap::new();
    if let Some(d) = &body.delegation {
        let release = app.store.catalog_get(
            "release",
            identity["releaseId"]
                .as_str()
                .context("Missing lead release")?,
        )?;
        let source = management::release_config(&app.config, &release, &profile)?;
        let bundle = source.load_bundle()?;
        crate::service_team_types::validate_delegation(d, &bundle)?;
        for choice in &d.models {
            models.insert(
                openworker_store_postgres::service_team_types::model_key(choice)?,
                app.runtime.connections.resolve(choice)?,
            );
        }
    }
    let mut templates = BTreeMap::new();
    for (kind, release_id) in &body.agent_types {
        let entry = app.store.catalog_get("release", release_id)?;
        ensure!(entry.activated, "Child release must be activated");
        let release: Release = serde_json::from_value(entry.definition.clone())?;
        let config = management::release_config(&app.config, &entry, &profile)?;
        let rt = config.api_runtime(
            &format!(
                "team-template-{}",
                &openworker_runtime::bundle::digest(kind.as_bytes())[..16]
            ),
            app.store.clone(),
        )?;
        let mut parameters = json!({"coworker":rt.coworker(),"workspace":snapshot["session"]["workspace"],"environment_id":snapshot["session"]["environment"]["environment_id"],"name":kind,"permissions":{"mode":p.approval_mode,"auto_skip_questions":p.auto_skip_questions}});
        if let Some(model) = release.default_model {
            parameters["model"] = json!(model);
        }
        if let Some(model) = release.reviewer_model {
            parameters["reviewer_model"] = json!(model);
        }
        let template = rt.prepare_session(parameters)?;
        rt.shutdown().await?;
        templates.insert(kind.clone(), (release_id.clone(), template));
    }
    let keys: Vec<_> = body.agent_types.keys().cloned().collect();
    app.store.configure_agent_team_models(&sid,json!({"agent_id":body.agent_id,"agent_types":keys,"policy":body.policy,"limits":body.limits,"delegation":body.delegation,"workspace_defaults":body.workspace_defaults,"coding":body.coding,"source_store_binding":source_store_binding,"_repository_access":repository_access}),templates,models)
}
pub(crate) async fn snapshot(
    Extension(app): Extension<App>,
    Path(sid): Path<String>,
) -> Result<Json<Value>, ApiError> {
    let mut value = app.store.agent_team_api(&sid, "snapshot", json!({}))?;
    if let Some(source) = app.store.team_source_status(&sid)? {
        value["source_setup"] = source;
    }
    Ok(Json(value))
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
pub(crate) struct Command {
    operation: String,
    arguments: Value,
}
pub(crate) async fn command(
    Extension(app): Extension<App>,
    Path(sid): Path<String>,
    headers: HeaderMap,
    Json(body): Json<Command>,
) -> Result<Json<Value>, ApiError> {
    let result = if body.operation == "team_manage" && body.arguments["action"] == "list" {
        app.store
            .agent_team_api(&sid, "team_manage", body.arguments)?
    } else if matches!(
        body.operation.as_str(),
        "team_read_board" | "team_list_submissions"
    ) {
        app.store
            .agent_team_api(&sid, &body.operation, body.arguments)?
    } else {
        let key = service::key(&app, &headers, &format!("team-{sid}"))?;
        app.store.agent_team_api(
            &sid,
            "command",
            json!({"request_id":key,"operation":body.operation,"arguments":body.arguments}),
        )?
    };
    Ok(Json(result))
}

pub(crate) async fn history(
    Extension(app): Extension<App>,
    Path(sid): Path<String>,
    axum::extract::Query(query): axum::extract::Query<
        openworker_runtime::team_coordination::HistoryQuery,
    >,
) -> Result<Json<Value>, ApiError> {
    Ok(Json(app.store.agent_team_api(
        &sid,
        "team_read_board",
        serde_json::to_value(query).map_err(anyhow::Error::from)?,
    )?))
}