Skip to content
Python
10.7 KB
Raw Blame
//! Identical durable coordination contract for SQLite and PostgreSQL.
#[path = "agent_team_contract.rs"]
#[allow(dead_code)]
mod fixture;
use openworker_runtime::{
    agent_team::{Document, Membership},
    store::StateStore,
};
use serde_json::{json, Value};
pub fn create(db: &mut dyn StateStore) {
    let mut parent = fixture::session("parent-session", "assistant");
    parent.schema_digest = Some("schema".into());
    parent.package.standalone_subagents = Some(Default::default());
    db.save(&parent, "created", json!({})).unwrap();
    let options = json!({"agent_id":"parent","agent_types":["standalone-placeholder"],"policy":{"communication":{"board":false,"directMessages":true},"max_instances":33},"delegation":{"tools":["coding.read_file"],"placements":["team"]},"limits":{"maxModelCalls":10,"maxOutputTokens":20000}});
    assert!(db
        .agent_team(&parent.id, "standalone_init", &options, None)
        .is_err());
    parent = db.get(&parent.id).unwrap();
    parent.package.standalone_subagents = Some(openworker_runtime::subagents::Config::enabled());
    db.save(&parent, "enabled", json!({})).unwrap();
    db.agent_team(&parent.id, "standalone_init", &options, None)
        .unwrap();
    assert!(db.agent_team(&parent.id, "create", &options, None).is_err());
}
pub fn snapshot(db: &mut dyn StateStore) -> Document {
    serde_json::from_value(
        db.agent_team("parent-session", "snapshot", &json!({}), None)
            .unwrap(),
    )
    .unwrap()
}
pub fn request(id: &str, mode: &str) -> Value {
    json!({"agent_id":id,"system_prompt":"Only inspect the supplied evidence.","context":"A fresh child briefing","tools":[],"execution":mode})
}
pub fn spawn(db: &mut dyn StateStore, args: &Value, approval: &str) -> Value {
    let (mut p, _, _) = db
        .accept(
            "parent-session",
            &format!("spawn-{}", args["agent_id"].as_str().unwrap()),
            "PARENT_PRIVATE_SENTINEL",
        )
        .unwrap();
    let call = json!({"type":"function_call","call_id":"spawn-call","name":"create_sub_agent","arguments":args.to_string()});
    p.turn.as_mut().unwrap().status = "running".into();
    p.turn.as_mut().unwrap().queue = vec![call.clone()];
    p.history.push(call.clone());
    let tid = p.turn.as_ref().unwrap().id.clone();
    db.save(&p, "assistant_message", json!({})).unwrap();
    db.agent_team(&p.id, "subagent_prepare", args, None)
        .unwrap();
    p = db.get(&p.id).unwrap();
    p.interactions.push(serde_json::from_value(json!({"id":"definition-approval","turn_id":tid,"kind":"approval","call":call,"bundle_digest":p.bundle_digest,"schema_digest":p.schema_digest,"response":approval,"origin":"human","server":null,"remote_tool":null,"policy_digest":p.tool_policy.digest,"resource_policy_digest":p.resource_policy.digest})).unwrap());
    db.save(&p, "interaction_resolved", json!({})).unwrap();
    db.agent_team(&p.id, "create_sub_agent", args, Some((&tid, &call)))
        .unwrap()
}
pub fn attach(db: &mut dyn StateStore, id: &str) -> String {
    let doc = snapshot(db);
    let instance = doc.roster.instance(id).unwrap();
    let mut child = fixture::session(
        &instance.session_id,
        &openworker_runtime::agent_team::runtime_type(&doc, instance).unwrap(),
    );
    child.agent_team = Some(Membership {
        team_id: doc.id.clone(),
        agent_id: id.into(),
        inbox_cursor: 0,
        last_output: None,
        notices: vec![],
        waiting: None,
    });
    db.save(
        &child,
        "team_instance_created",
        json!({"parent_session_id":"parent-session","agent_id":id}),
    )
    .unwrap();
    db.agent_team("parent-session", "ready", &json!({"agent_id":id}), None)
        .unwrap();
    child.id
}
pub fn finish(db: &mut dyn StateStore, sid: &str, status: &str) {
    let mut s = db.get(sid).unwrap();
    s.turn.as_mut().unwrap().status = status.into();
    s.turn.as_mut().unwrap().queue.clear();
    s.agent_team.as_mut().unwrap().last_output = Some("Child result".into());
    db.save(&s, "turn_completed", json!({"status":status}))
        .unwrap();
}
pub fn exercise(db: &mut dyn StateStore) {
    create(db);
    let args = request("reader", "async");
    let spawned = spawn(db, &args, "once");
    assert_eq!(spawned["status"], "queued");
    let child = attach(db, "reader");
    assert_eq!(
        db.agent_team("parent-session", "create_sub_agent", &args, None)
            .unwrap()["session_id"],
        child
    );
    let mut conflict = args.clone();
    conflict["context"] = json!("Different");
    assert!(db
        .agent_team("parent-session", "subagent_prepare", &conflict, None)
        .is_err());
    assert!(db
        .agent_team(
            &child,
            "create_sub_agent",
            &request("grandchild", "async"),
            None
        )
        .is_err());
    assert!(db
        .agent_team(
            &child,
            "send_message",
            &json!({"agent_id":"reader","message":"sibling spoof"}),
            None
        )
        .is_err());
    assert!(db.get(&child).unwrap().history.is_empty());
    let (s, _, _) = db.accept(&child, "initial-reader", "Fresh task").unwrap();
    assert!(!json!(s.history)
        .to_string()
        .contains("PARENT_PRIVATE_SENTINEL"));
    // Busy delivery does not require the parent turn to finish.
    db.agent_team(
        "parent-session",
        "send_message",
        &json!({"agent_id":"reader","message":"Check authentication too"}),
        None,
    )
    .unwrap();
    assert_eq!(
        db.agent_team(&child, "deliver", &json!({}), None).unwrap()["messages"]
            .as_array()
            .unwrap()
            .len(),
        1
    );
    assert!(
        db.agent_team(&child, "deliver", &json!({}), None).unwrap()["messages"]
            .as_array()
            .unwrap()
            .is_empty()
    );
    db.agent_team(
        &child,
        "send_message",
        &json!({"agent_id":"parent","message":"Found evidence"}),
        None,
    )
    .unwrap();
    finish(db, &child, "completed");
    let sequence = snapshot(db).sequence;
    finish(db, &child, "completed");
    db.agent_team("parent-session", "subagent_reconcile", &json!({}), None)
        .unwrap();
    assert_eq!(
        snapshot(db).sequence,
        sequence,
        "completion notification must not duplicate"
    );
    let delivered = db
        .agent_team("parent-session", "deliver", &json!({}), None)
        .unwrap();
    assert_eq!(delivered["messages"].as_array().unwrap().len(), 2);
    assert!(delivered.to_string().contains("Child task finished"));
    assert!(snapshot(db).standalone.as_ref().unwrap().active.is_empty());
    db.agent_team(
        "parent-session",
        "send_message",
        &json!({"agent_id":"reader","message":"Follow-up"}),
        None,
    )
    .unwrap();
    assert_eq!(
        db.agent_team(&child, "wake", &json!({}), None).unwrap()["wake"],
        true
    );
    assert!(snapshot(db)
        .standalone
        .as_ref()
        .unwrap()
        .active
        .contains("reader"));
    db.agent_team(&child, "deliver", &json!({}), None).unwrap();
    db.accept(&child, "follow-up", "Continue").unwrap();
    let cancelled = db
        .agent_team(
            "parent-session",
            "cancel_agent",
            &json!({"agent_id":"reader"}),
            None,
        )
        .unwrap();
    assert_eq!(cancelled["status"], "cancellation_requested");
    let old_turn = db.get(&child).unwrap().turn.unwrap().id;
    assert_eq!(
        snapshot(db).standalone.unwrap().cancellations["reader"],
        old_turn
    );
    finish(db, &child, "cancelled");
    assert!(
        db.agent_team("parent-session", "create_sub_agent", &args, None)
            .unwrap()["result"]
            .is_null(),
        "Cancelled follow-up must not surface a previous result"
    );
    assert!(snapshot(db).standalone.unwrap().cancellations.is_empty());
    db.agent_team(
        "parent-session",
        "send_message",
        &json!({"agent_id":"reader","message":"Do not undo explicit cancellation"}),
        None,
    )
    .unwrap();
    assert_eq!(
        db.agent_team(&child, "wake", &json!({}), None).unwrap()["wake"],
        false
    );
    db.agent_team(
        "parent-session",
        "close_agent",
        &json!({"agent_id":"reader"}),
        None,
    )
    .unwrap();
    assert!(db
        .agent_team(
            "parent-session",
            "send_message",
            &json!({"agent_id":"reader","message":"Late"}),
            None
        )
        .is_err());
    let public = openworker_runtime::agent_team::public_snapshot(json!(snapshot(db)));
    assert!(public.get("standalone").is_none());
}
pub fn sync_and_budget(db: &mut dyn StateStore) {
    create(db);
    let args = request("verifier", "sync");
    let result = spawn(db, &args, "once");
    assert_eq!(result["parked"], true);
    let child = attach(db, "verifier");
    assert_eq!(
        db.agent_team("parent-session", "wake", &json!({}), None)
            .unwrap()["wake"],
        false
    );
    db.accept(&child, "initial", "Verify").unwrap();
    // Both parent and child reserve from one durable allowance.
    for (sid, id) in [
        ("parent-session", "parent-attempt"),
        (child.as_str(), "child-attempt"),
    ] {
        assert_eq!(
            db.agent_team(
                sid,
                "reserve_model",
                &json!({"attempt_id":id,"output_tokens":8000}),
                None
            )
            .unwrap()["allowed"],
            true
        );
        db.agent_team(
            sid,
            "settle_model",
            &json!({"attempt_id":id,"output_tokens":10}),
            None,
        )
        .unwrap();
        db.agent_team(
            sid,
            "settle_model",
            &json!({"attempt_id":id,"output_tokens":10}),
            None,
        )
        .unwrap();
    }
    assert_eq!(snapshot(db).budget.model_calls, 2);
    assert_eq!(snapshot(db).budget.reported_output_tokens, 20);
    finish(db, &child, "completed");
    assert_eq!(
        snapshot(db).sequence,
        0,
        "sync result should not also wake a second parent turn"
    );
    assert_eq!(
        db.agent_team("parent-session", "wake", &json!({}), None)
            .unwrap()["resume"],
        true
    );
    let mut p = db.get("parent-session").unwrap();
    p.turn.as_mut().unwrap().status = "running".into();
    db.save(&p, "resumed", json!({})).unwrap();
    let t = p.turn.unwrap();
    let call = t.queue[0].clone();
    assert_eq!(
        db.agent_team(
            "parent-session",
            "create_sub_agent",
            &args,
            Some((&t.id, &call))
        )
        .unwrap()["status"],
        "completed"
    );
    assert!(db
        .get("parent-session")
        .unwrap()
        .turn
        .unwrap()
        .queue
        .is_empty());
}