Skip to content
Python
15.0 KB
Raw Blame
#[path = "../../tests/agent_team_contract.rs"]
mod contract;
use openworker_runtime::store::Store;
use serde_json::json;
#[test]
fn sqlite_contract() {
    contract::exercise(&mut Store::memory().unwrap());
}
#[test]
fn sqlite_workspace_defaults_contract() {
    contract::exercise_workspace_defaults(&mut Store::memory().unwrap());
}
#[test]
fn sqlite_sandbox_selection_contract() {
    contract::exercise_sandbox_selection(&mut Store::memory().unwrap());
}
#[test]
fn sqlite_child_briefing_contract() {
    contract::exercise_briefing(&mut Store::memory().unwrap());
}
#[test]
fn restart_preserves_inbox_receipts_and_waits() {
    let root = tempfile::tempdir().unwrap();
    let mut db = Store::open(root.path()).unwrap();
    contract::create(&mut db);
    let child = contract::child(&mut db, "builder-ui");
    db.agent_team(
        "lead",
        "team_post_board",
        &json!({"message":"@builder-ui original"}),
        None,
    )
    .unwrap();
    db.agent_team(
        "lead",
        "team_wait_agent",
        &json!({"agent_ids":["builder-ui"],"timeout_ms":60000}),
        None,
    )
    .unwrap();
    drop(db);
    let mut db = Store::open(root.path()).unwrap();
    assert!(db
        .get("lead")
        .unwrap()
        .agent_team
        .unwrap()
        .waiting
        .is_some());
    db.agent_team(&child, "deliver", &json!({}), None).unwrap();
    drop(db);
    let mut db = Store::open(root.path()).unwrap();
    db.recover().unwrap();
    assert_eq!(
        db.agent_team(&child, "deliver", &json!({}), None).unwrap()["messages"],
        json!([])
    );
    assert_eq!(db.get(&child).unwrap().history.len(), 1);
}
#[test]
fn transaction_failure_rolls_back_board_fanout_result_and_inbox_cursor() {
    let root = tempfile::tempdir().unwrap();
    let mut db = Store::open(root.path()).unwrap();
    contract::create(&mut db);
    let child = contract::child(&mut db, "builder-ui");
    let connection = rusqlite::Connection::open(root.path().join("runtime.sqlite3")).unwrap();
    connection.execute_batch("CREATE TRIGGER fail_agent_team_event BEFORE INSERT ON events WHEN NEW.kind='agent_team' BEGIN SELECT RAISE(ABORT,'injected failure'); END;").unwrap();
    assert!(db
        .agent_team(
            "lead",
            "team_post_board",
            &json!({"message":"@builder-ui must rollback"}),
            None
        )
        .is_err());
    connection
        .execute_batch("DROP TRIGGER fail_agent_team_event")
        .unwrap();
    assert_eq!(
        db.agent_team(&child, "deliver", &json!({}), None).unwrap()["messages"],
        json!([])
    );
    db.agent_team(
        "lead",
        "team_post_board",
        &json!({"message":"@builder-ui retained"}),
        None,
    )
    .unwrap();
    connection.execute_batch("CREATE TRIGGER fail_agent_team_event BEFORE INSERT ON events WHEN NEW.kind='agent_team' BEGIN SELECT RAISE(ABORT,'injected failure'); END;").unwrap();
    assert!(db.agent_team(&child, "deliver", &json!({}), None).is_err());
    assert!(db.get(&child).unwrap().history.is_empty());
    assert_eq!(db.get(&child).unwrap().agent_team.unwrap().inbox_cursor, 0);
    connection
        .execute_batch("DROP TRIGGER fail_agent_team_event")
        .unwrap();
    assert_eq!(
        db.agent_team(&child, "deliver", &json!({}), None).unwrap()["messages"]
            .as_array()
            .unwrap()
            .len(),
        1
    );
}
#[test]
fn team_tool_result_and_effect_commit_once_and_disabled_channels_cannot_dispatch() {
    let mut db = Store::memory().unwrap();
    contract::create(&mut db);
    let child = contract::child(&mut db, "builder-ui");
    let (mut s, _, _) = db.accept("lead", "task", "Coordinate").unwrap();
    let t = s.turn.as_mut().unwrap();
    t.status = "running".into();
    let tid = t.id.clone();
    let args = json!({"message":"@builder-ui exact effect"});
    let call = json!({"type":"function_call","call_id":"post","name":"team_post_board","arguments":args.to_string()});
    s.history.push(call.clone());
    s.turn.as_mut().unwrap().queue = vec![call.clone()];
    db.save(&s, "assistant_message", json!({})).unwrap();
    db.agent_team("lead", "team_post_board", &args, Some((&tid, &call)))
        .unwrap();
    assert!(db
        .agent_team("lead", "team_post_board", &args, Some((&tid, &call)))
        .is_err());
    assert_eq!(
        db.get("lead")
            .unwrap()
            .history
            .iter()
            .filter(|v| v["type"] == "function_call_output")
            .count(),
        1
    );
    assert_eq!(
        db.agent_team(&child, "deliver", &json!({}), None).unwrap()["messages"]
            .as_array()
            .unwrap()
            .len(),
        1
    );
    for (board, direct) in [(false, false), (false, true), (true, false), (true, true)] {
        let mut db = Store::memory().unwrap();
        db.save(&contract::session("lead", "lead"), "created", json!({}))
            .unwrap();
        db.agent_team("lead","create",&json!({"agent_id":"lead","agent_types":["builder"],"policy":{"communication":{"board":board,"directMessages":direct},"max_instances":32}}),None).unwrap();
        let child = contract::child(&mut db, "builder-ui");
        assert_eq!(
            db.agent_team(
                "lead",
                "team_post_board",
                &json!({"message":"@builder-ui notice"}),
                None
            )
            .is_ok(),
            board
        );
        assert_eq!(
            db.agent_team(
                "lead",
                "team_send_message",
                &json!({"agent_id":"builder-ui","message":"Private"}),
                None
            )
            .is_ok(),
            direct
        );
        let doc =
            serde_json::from_value(db.agent_team("lead", "snapshot", &json!({}), None).unwrap())
                .unwrap();
        let schemas = openworker_runtime::agent_team::schemas(&doc, "builder-ui");
        assert_eq!(
            schemas.iter().any(|v| v["name"] == "team_send_message"),
            direct
        );
        assert_eq!(
            schemas.iter().any(|v| v["name"] == "team_post_board"),
            board
        );
        assert!(!schemas.iter().any(|v| v["name"] == "team_spawn"));
        assert_eq!(
            db.agent_team(&child, "deliver", &json!({}), None).unwrap()["messages"]
                .as_array()
                .unwrap()
                .len(),
            usize::from(board) + usize::from(direct)
        );
    }
}
#[test]
fn waits_handle_completion_message_timeout_and_keep_cancelled_sessions_stopped() {
    let mut db = Store::memory().unwrap();
    contract::create(&mut db);
    let child = contract::child(&mut db, "builder-ui");
    let (mut lead, _, _) = db.accept("lead", "lead-task", "Coordinate").unwrap();
    lead.turn.as_mut().unwrap().status = "waiting_agents".into();
    db.save(&lead, "park", json!({})).unwrap();
    db.agent_team(
        "lead",
        "team_wait_agent",
        &json!({"agent_ids":["builder-ui"],"timeout_ms":60000}),
        None,
    )
    .unwrap();
    assert_eq!(
        db.agent_team("lead", "wake", &json!({}), None).unwrap()["wake"],
        false
    );
    db.agent_team(
        &child,
        "team_post_board",
        &json!({"message":"@lead update while waiting"}),
        None,
    )
    .unwrap();
    assert_eq!(
        db.agent_team("lead", "wake", &json!({}), None).unwrap()["resume"],
        true
    );
    let mut s = db.get("lead").unwrap();
    s.turn.as_mut().unwrap().status = "cancelled".into();
    db.save(&s, "cancel", json!({})).unwrap();
    db.agent_team(
        "lead",
        "team_wait_agent",
        &json!({"agent_ids":["builder-ui"],"timeout_ms":1}),
        None,
    )
    .unwrap();
    std::thread::sleep(std::time::Duration::from_millis(2));
    assert_eq!(
        db.agent_team("lead", "wake", &json!({}), None).unwrap()["wake"],
        false
    );
    let mut s = db.get("lead").unwrap();
    s.turn.as_mut().unwrap().status = "waiting_agents".into();
    s.agent_team.as_mut().unwrap().inbox_cursor = 100;
    db.save(&s, "park", json!({})).unwrap();
    assert_eq!(
        db.agent_team("lead", "wake", &json!({}), None).unwrap()["resume"],
        true
    );
}
#[test]
fn aggregate_model_budget_counts_all_instances_and_settles_conservatively() {
    let mut db = Store::memory().unwrap();
    db.save(&contract::session("lead", "lead"), "created", json!({}))
        .unwrap();
    db.agent_team("lead","create",&json!({"agent_id":"lead","agent_types":["builder"],"limits":{"maxModelCalls":2,"maxOutputTokens":20000}}),None).unwrap();
    let child = contract::child(&mut db, "builder-ui");
    for (sid, id) in [("lead", "a"), (child.as_str(), "b")] {
        assert_eq!(
            db.agent_team(
                sid,
                "reserve_model",
                &json!({"attempt_id":id,"output_tokens":1000}),
                None
            )
            .unwrap()["allowed"],
            true
        );
    }
    assert_eq!(
        db.agent_team(
            "lead",
            "reserve_model",
            &json!({"attempt_id":"c","output_tokens":1000}),
            None
        )
        .unwrap()["allowed"],
        false
    );
    db.agent_team(
        "lead",
        "settle_model",
        &json!({"attempt_id":"a","output_tokens":10}),
        None,
    )
    .unwrap();
    db.agent_team(
        "lead",
        "settle_model",
        &json!({"attempt_id":"a","output_tokens":10}),
        None,
    )
    .unwrap();
    db.agent_team(
        &child,
        "settle_model",
        &json!({"attempt_id":"b","output_tokens":null}),
        None,
    )
    .unwrap();
    let doc = db.agent_team("lead", "snapshot", &json!({}), None).unwrap();
    assert_eq!(doc["budget"]["charged_output_tokens"], 1010);
    assert_eq!(doc["budget"]["model_calls"], 2);
}
#[test]
fn command_identity_is_author_scoped_and_public_snapshots_hide_private_receipts() {
    let mut db = Store::memory().unwrap();
    contract::create(&mut db);
    let child = contract::child(&mut db, "builder-ui");
    let command = json!({"request_id":"same-id","operation":"team_send_message","arguments":{"agent_id":"builder-ui","message":"private-credential-free-note"}});
    let lead = db.agent_team("lead", "command", &command, None).unwrap();
    let child_own = db.agent_team(&child, "command", &command, None).unwrap();
    assert_ne!(lead["id"], child_own["id"]);
    assert_eq!(child_own["sender"], "builder-ui");
    let private = db.agent_team("lead", "snapshot", &json!({}), None).unwrap();
    assert!(private["limited"].as_bool().unwrap());
    assert_eq!(private["budget"]["limits"]["maxModelCalls"], 100);
    let public = openworker_runtime::agent_team::public_snapshot(private);
    assert!(!public.to_string().contains("private-credential-free-note"));
    assert!(public.get("commands").is_none());
    assert!(public["roster"].get("requests").is_none());
}
#[test]
fn wake_checkpoint_survives_restart_and_wait_notices_follow_parallel_tool_results() {
    let root = tempfile::tempdir().unwrap();
    let mut db = Store::open(root.path()).unwrap();
    contract::create(&mut db);
    contract::child(&mut db, "builder-ui");
    let (mut s, _, _) = db.accept("lead", "parallel", "Coordinate").unwrap();
    let tid = s.turn.as_ref().unwrap().id.clone();
    let wait_args = json!({"agent_ids":["builder-ui"],"timeout_ms":1});
    let wait = json!({"type":"function_call","call_id":"wait","name":"team_wait_agent","arguments":wait_args.to_string()});
    let post_args = json!({"message":"Passive parallel post"});
    let post = json!({"type":"function_call","call_id":"post","name":"team_post_board","arguments":post_args.to_string()});
    s.turn.as_mut().unwrap().status = "running".into();
    s.turn.as_mut().unwrap().queue = vec![wait.clone(), post.clone()];
    s.history.extend([wait.clone(), post.clone()]);
    db.save(&s, "assistant_message", json!({})).unwrap();
    db.agent_team("lead", "team_wait_agent", &wait_args, Some((&tid, &wait)))
        .unwrap();
    std::thread::sleep(std::time::Duration::from_millis(2));
    assert_eq!(
        db.agent_team("lead", "wake", &json!({}), None).unwrap()["resume"],
        true
    );
    assert_eq!(
        db.get("lead").unwrap().history.len(),
        4,
        "Wake must not insert user input between pending parallel tool results"
    );
    assert!(db.agent_team("lead", "deliver", &json!({}), None).is_err());
    drop(db);
    let mut db = Store::open(root.path()).unwrap();
    db.recover().unwrap();
    let mut s = db.get("lead").unwrap();
    assert_eq!(s.turn.as_ref().unwrap().status, "resuming_agents");
    assert_eq!(s.agent_team.as_ref().unwrap().notices.len(), 1);
    s.turn.as_mut().unwrap().status = "running".into();
    db.save(&s, "turn_started", json!({})).unwrap();
    db.agent_team("lead", "team_post_board", &post_args, Some((&tid, &post)))
        .unwrap();
    db.agent_team("lead", "deliver", &json!({}), None).unwrap();
    let s = db.get("lead").unwrap();
    assert_eq!(s.history[4]["type"], "function_call_output");
    assert_eq!(s.history[5]["_runtime_notice"], "agent_wait");
    assert!(s.agent_team.as_ref().unwrap().notices.is_empty());
    openworker_runtime::anthropic::body("fixture", "Coordinate", &s.history, &[], 8192, None)
        .expect("Parallel tool ordering must remain valid for Anthropic");
    openworker_runtime::chat_completions::body(
        "fixture",
        "Coordinate",
        &s.history,
        &[],
        8192,
        None,
    )
    .expect("Parallel tool ordering must remain valid for Chat Completions");
}
#[test]
fn sqlite_workspace_intent_contract() {
    contract::exercise_workspace_intent(&mut Store::memory().unwrap());
}
#[test]
fn workspace_dispatch_survives_reopen_without_mutation_permission() {
    let tmp = tempfile::tempdir().unwrap();
    let mut db = Store::open(tmp.path()).unwrap();
    db.save(&contract::session("lead", "lead"), "created", json!({}))
        .unwrap();
    db.agent_team(
        "lead",
        "create",
        &json!({"agent_id":"lead","agent_types":["builder"],"workspace_selection":true}),
        None,
    )
    .unwrap();
    db.agent_team("lead","team_spawn",&json!({"agent_id":"builder-one","agent_type":"builder","message":"Build","workspace":{"mode":"directory","path":"ui"}}),None).unwrap();
    let first = db
        .agent_team(
            "lead",
            "workspace_dispatch",
            &json!({"agent_id":"builder-one"}),
            None,
        )
        .unwrap();
    drop(db);
    let mut db = Store::open(tmp.path()).unwrap();
    let recovered = db
        .agent_team(
            "lead",
            "workspace_dispatch",
            &json!({"agent_id":"builder-one"}),
            None,
        )
        .unwrap();
    assert_eq!(recovered["dispatch"], false);
    assert_eq!(first["intent"], recovered["intent"]);
}
#[test]
fn sqlite_retirement_contract() {
    contract::exercise_retirement(&mut Store::memory().unwrap());
}
#[test]
fn sqlite_child_model_selection_contract() {
    contract::exercise_child_model_selection(&mut Store::memory().unwrap());
}

#[test]
fn sqlite_coding_default_reservation_contract() {
    contract::exercise_coding_defaults(&mut Store::memory().unwrap());
}