Skip to content

The fastest, cheapest, most efficient open-source agent harness. Run more than 500 agents on a $10 VPS.

fix(agent_runs): include error source chain in prompt-size report failures

Steven Enamakelc525c7a8d098
diff --git a/crates/openhuman-core/src/agent_runs/context_breakdown.rs b/crates/openhuman-core/src/agent_runs/context_breakdown.rs
index 63626a1d52..77effc147d 100644
--- a/crates/openhuman-core/src/agent_runs/context_breakdown.rs
+++ b/crates/openhuman-core/src/agent_runs/context_breakdown.rs
@@ -141,7 +141,7 @@ async fn cached_report(
};
let report = PromptSizeReport::build(options)
.await
- .map_err(|e| format!("failed to build prompt-size report for {agent_id}: {e}"))?;
+ .map_err(|e| format!("failed to build prompt-size report for {agent_id}: {e:#}"))?;
REPORT_CACHE
.lock()
diff --git a/crates/openhuman-embed/tests/isolation_state.rs b/crates/openhuman-embed/tests/isolation_state.rs
index 987e915392..2c2e2629ff 100644
--- a/crates/openhuman-embed/tests/isolation_state.rs
+++ b/crates/openhuman-embed/tests/isolation_state.rs
@@ -47,18 +47,21 @@ fn skill_tools() -> AgentDefinitionSpec {
}
async fn send(agent: &Agent, message: &str) {
+ eprintln!("isolation-state: {} turn starting", agent.id());
agent
.turn(message)
.session(SESSION)
.send()
.await
.unwrap_or_else(|error| panic!("{}'s turn: {error}", agent.id()));
+ eprintln!("isolation-state: {} turn finished", agent.id());
}
#[test]
fn agents_on_one_workspace_keep_their_own_state() {
let _ = env_logger::builder().is_test(true).try_init();
runtime().block_on(async {
+ eprintln!("isolation-state: starting backend/runtime");
tokio::spawn(async move {
let backend = stub_backend().await;
let session_store = std::sync::Arc::new(InMemorySessionStores::new());
@@ -71,6 +74,7 @@ fn agents_on_one_workspace_keep_their_own_state() {
.build()
.await
.expect("runtime builds");
+ eprintln!("isolation-state: runtime built");
let name = skill_name();
let a_provider = scripted_provider(
@@ -98,11 +102,29 @@ fn agents_on_one_workspace_keep_their_own_state() {
.definition(skill_tools()),
)
.expect("b instantiates");
+ eprintln!("isolation-state: agents instantiated");
assert_eq!(a.workspace_dir(), b.workspace_dir());
// ── the same session id, concurrently, on both agents ──
- tokio::join!(send(&a, "alpha-secret-one"), send(&b, "beta-secret-one"));
+ let first_pair = tokio::time::timeout(
+ std::time::Duration::from_secs(10),
+ async {
+ tokio::join!(send(&a, "alpha-secret-one"), send(&b, "beta-secret-one"))
+ },
+ )
+ .await;
+ if first_pair.is_err() {
+ let a_requests = chat_requests(&a_provider).await;
+ let b_requests = chat_requests(&b_provider).await;
+ panic!(
+ "first turn pair stalled: a_requests={}, b_requests={}",
+ a_requests.len(),
+ b_requests.len()
+ );
+ }
+ eprintln!("isolation-state: first pair sent");
tokio::join!(send(&a, "alpha-secret-two"), send(&b, "beta-secret-two"));
+ eprintln!("isolation-state: second pair sent");
let a_requests = chat_requests(&a_provider).await;
let b_requests = chat_requests(&b_provider).await;
diff --git a/crates/openhuman-embed/tests/route_headers.rs b/crates/openhuman-embed/tests/route_headers.rs
index b479520898..cc3662ea0d 100644
--- a/crates/openhuman-embed/tests/route_headers.rs
+++ b/crates/openhuman-embed/tests/route_headers.rs
@@ -11,6 +11,7 @@ fn attribution_headers_are_scoped_to_each_agent_and_turn_route() {
}
async fn scenario() {
+ eprintln!("route-headers: starting backend/runtime");
let backend = stub_backend().await;
let (a_provider, b_provider) = tokio::join!(provider("a"), provider("b"));
let runtime = Runtime::builder()
@@ -20,6 +21,7 @@ async fn scenario() {
.build()
.await
.unwrap();
+ eprintln!("route-headers: runtime built");
let a_route = Route::openai_compatible(format!("{}/v1", a_provider.uri()), "a-key")
.header("x-medulla-agent-id", "worker-a")
.header("x-medulla-run-id", "a-run")
@@ -35,6 +37,7 @@ async fn scenario() {
let a = runtime
.agent(AgentSpec::new("worker-a").provider(route(&a_provider, "fixture")))
.unwrap();
+ eprintln!("route-headers: agents instantiated");
let b = runtime
.agent(
AgentSpec::new("worker-b").provider(
@@ -55,8 +58,10 @@ async fn scenario() {
);
a_result.unwrap();
b_result.unwrap();
+ eprintln!("route-headers: first pair sent");
// The next turn inherits the agent provider, not the previous turn's headers.
a.run("next a").await.unwrap();
+ eprintln!("route-headers: final turn sent");
let a_requests = chat_requests(&a_provider).await;
let b_requests = chat_requests(&b_provider).await;
assert_eq!(a_requests.len(), 2);
diff --git a/tests/json_rpc_agent_team_e2e.rs b/tests/json_rpc_agent_team_e2e.rs
index c08605ac8a..9644b751f8 100644
--- a/tests/json_rpc_agent_team_e2e.rs
+++ b/tests/json_rpc_agent_team_e2e.rs
@@ -17,6 +17,7 @@ async fn json_rpc_agent_registry_manages_defaults_and_custom_agents() {
let _vite_backend_guard = EnvVarGuard::unset("VITE_BACKEND_URL");
write_min_config(&openhuman_home, "http://127.0.0.1:9");
+ store_local_profile_api_key(&openhuman_home, "http://127.0.0.1:9");
let (rpc_addr, rpc_join) = serve_on_ephemeral(build_core_http_router(false)).await;
let rpc_base = format!("http://{rpc_addr}");
@@ -59,33 +60,33 @@ async fn json_rpc_agent_registry_manages_defaults_and_custom_agents() {
.and_then(Value::as_array)
.expect("agent_list_definitions should return definitions array");
// The v1 `agent_memory` built-in was removed with the v1 memory system
- // (Memory v2 is one `memory` tool, not a sub-agent); `critic` is the
- // stand-in safe-library entry.
+ // (Memory v2 is one `memory` tool, not a sub-agent). `summarizer` is the
+ // shipped safe-library entry used to verify definition projection.
assert!(
!definitions
.iter()
.any(|definition| definition.get("id").and_then(Value::as_str) == Some("agent_memory")),
"the v1 memory agent must stay removed"
);
- let memory_agent = definitions
+ let summarizer = definitions
.iter()
- .find(|definition| definition.get("id").and_then(Value::as_str) == Some("critic"))
- .expect("safe agent library should include critic");
- assert!(memory_agent
+ .find(|definition| definition.get("id").and_then(Value::as_str) == Some("summarizer"))
+ .expect("safe agent library should include summarizer");
+ assert!(summarizer
.get("display_name")
.and_then(Value::as_str)
.is_some());
- assert!(memory_agent
+ assert!(summarizer
.get("when_to_use")
.and_then(Value::as_str)
.is_some());
- assert!(memory_agent.get("system_prompt").is_none());
- assert!(memory_agent.get("tools").is_some());
- assert!(memory_agent
+ assert!(summarizer.get("system_prompt").is_none());
+ assert!(summarizer.get("tools").is_some());
+ assert!(summarizer
.get("direct_tool_count")
.and_then(Value::as_u64)
.is_some());
- assert!(memory_agent
+ assert!(summarizer
.get("can_run_as_user_facing_worker")
.and_then(Value::as_bool)
.is_some());
@@ -107,7 +108,7 @@ async fn json_rpc_agent_registry_manages_defaults_and_custom_agents() {
286_211,
"openhuman.agent_registry_update",
json!({
- "id": "critic",
+ "id": "summarizer",
"name": "Review Specialist",
"description": "Workspace-specific review specialist.",
"model": "hint:reasoning",
@@ -522,7 +523,7 @@ async fn json_rpc_agent_registry_manages_defaults_and_custom_agents() {
&rpc_base,
286_221,
"openhuman.agent_registry_remove",
- json!({ "id": "critic" }),
+ json!({ "id": "summarizer" }),
)
.await;
assert_eq!(
@@ -756,454 +757,30 @@ async fn json_rpc_protocol_auth_and_agent_hello_inner() {
}
#[tokio::test]
-async fn json_rpc_agent_work_list_groups_runs_by_bucket() {
+async fn removed_agent_work_and_team_methods_are_not_registered() {
let _env_lock = json_rpc_e2e_env_lock_async().await;
let tmp = tempdir().expect("tempdir");
let home = tmp.path();
- let openhuman_home = home.join(".openhuman");
-
- let _home_guard = EnvVarGuard::set_to_path("HOME", home);
- let _workspace_guard = EnvVarGuard::unset("OPENHUMAN_WORKSPACE");
- let _backend_url_guard = EnvVarGuard::unset("BACKEND_URL");
- let _vite_backend_url_guard = EnvVarGuard::unset("VITE_BACKEND_URL");
- let _api_url_guard = EnvVarGuard::unset("OPENHUMAN_API_URL");
-
- let (api_addr, api_join) = serve_on_ephemeral(mock_upstream_router()).await;
- let api_origin = format!("http://{api_addr}");
- write_min_config(openhuman_home.as_path(), &api_origin);
-
- let (rpc_addr, rpc_join) = serve_on_ephemeral(build_core_http_router(false)).await;
- let rpc_base = format!("http://{rpc_addr}");
-
- let config = openhuman_core::config::Config::load_or_init()
- .await
- .expect("load config");
-
- use tinyagents_session::run_ledger::{AgentRunKind, AgentRunStatus, AgentRunUpsert};
- let seed = |id: &str, status: AgentRunStatus| AgentRunUpsert {
- id: id.to_string(),
- kind: AgentRunKind::Subagent,
- parent_run_id: None,
- parent_thread_id: Some("thread-work-1".to_string()),
- agent_id: Some("task_manager_agent".to_string()),
- status,
- prompt_ref: None,
- worker_thread_id: None,
- checkpoint_path: None,
- checkpoint: None,
- summary: None,
- error: None,
- metadata: json!({ "source": "json_rpc_e2e" }),
- started_at: None,
- completed_at: None,
- };
- // Two awaiting-user (needs_input), one running (working), one completed.
- openhuman_core::storage::sessions::with_ledger(&config.workspace_dir, |ledger| {
- let ledger_arg_0 = seed("work-a", AgentRunStatus::AwaitingUser);
- async move { ledger.upsert_agent_run(ledger_arg_0).await }
- })
- .expect("seed a");
- openhuman_core::storage::sessions::with_ledger(&config.workspace_dir, |ledger| {
- let ledger_arg_0 = seed("work-b", AgentRunStatus::AwaitingUser);
- async move { ledger.upsert_agent_run(ledger_arg_0).await }
- })
- .expect("seed b");
- openhuman_core::storage::sessions::with_ledger(&config.workspace_dir, |ledger| {
- let ledger_arg_0 = seed("work-c", AgentRunStatus::Running);
- async move { ledger.upsert_agent_run(ledger_arg_0).await }
- })
- .expect("seed c");
- openhuman_core::storage::sessions::with_ledger(&config.workspace_dir, |ledger| {
- let ledger_arg_0 = seed("work-d", AgentRunStatus::Completed);
- async move { ledger.upsert_agent_run(ledger_arg_0).await }
- })
- .expect("seed d");
-
- let list = post_json_rpc(&rpc_base, 9131, "openhuman.agent_work_list", json!({})).await;
- let outer = assert_no_jsonrpc_error(&list, "agent_work_list");
-
- assert_eq!(
- outer.get("total").and_then(serde_json::Value::as_u64),
- Some(4)
- );
-
- let groups = outer
- .get("groups")
- .and_then(serde_json::Value::as_array)
- .expect("groups array");
- // Always five buckets, in display order.
- let buckets: Vec<&str> = groups
- .iter()
- .filter_map(|g| g.get("bucket").and_then(serde_json::Value::as_str))
- .collect();
- assert_eq!(
- buckets,
- vec!["needs_input", "working", "completed", "failed", "stopped"]
- );
-
- let count_of = |bucket: &str| -> u64 {
- groups
- .iter()
- .find(|g| g.get("bucket").and_then(serde_json::Value::as_str) == Some(bucket))
- .and_then(|g| g.get("count"))
- .and_then(serde_json::Value::as_u64)
- .unwrap_or(0)
- };
- assert_eq!(count_of("needs_input"), 2);
- assert_eq!(count_of("working"), 1);
- assert_eq!(count_of("completed"), 1);
- assert_eq!(count_of("failed"), 0);
- assert_eq!(count_of("stopped"), 0);
-
- api_join.abort();
- rpc_join.abort();
-}
-
-#[tokio::test]
-async fn json_rpc_agent_team_coordination_roundtrip() {
- let _env_lock = json_rpc_e2e_env_lock_async().await;
- let tmp = tempdir().expect("tempdir");
- let home = tmp.path();
- let openhuman_home = home.join(".openhuman");
-
let _home_guard = EnvVarGuard::set_to_path("HOME", home);
let _workspace_guard = EnvVarGuard::unset("OPENHUMAN_WORKSPACE");
let _backend_url_guard = EnvVarGuard::unset("BACKEND_URL");
- let _vite_backend_url_guard = EnvVarGuard::unset("VITE_BACKEND_URL");
- let _api_url_guard = EnvVarGuard::unset("OPENHUMAN_API_URL");
-
- let (api_addr, api_join) = serve_on_ephemeral(mock_upstream_router()).await;
- let api_origin = format!("http://{api_addr}");
- write_min_config(openhuman_home.as_path(), &api_origin);
let (rpc_addr, rpc_join) = serve_on_ephemeral(build_core_http_router(false)).await;
let rpc_base = format!("http://{rpc_addr}");
- let config = openhuman_core::config::Config::load_or_init()
- .await
- .expect("load config");
-
- // Create a team with two members.
- let created = post_json_rpc(
- &rpc_base,
- 9341,
- "openhuman.agent_team_create",
- json!({
- "leadAgentId": "lead",
- "parentThreadId": "thread-team-e2e",
- "summary": "ship feature",
- "members": [
- { "name": "alice", "agentId": "orchestrator" },
- { "name": "bob", "agentId": "orchestrator" }
- ]
- }),
- )
- .await;
- let created_outer = assert_no_jsonrpc_error(&created, "agent_team_create");
- let team_id = created_outer
- .get("team")
- .and_then(|t| t.get("id"))
- .and_then(serde_json::Value::as_str)
- .expect("team id")
- .to_string();
- let members = created_outer
- .get("members")
- .and_then(serde_json::Value::as_array)
- .expect("members array");
- assert_eq!(members.len(), 2);
- let alice_id = members[0]
- .get("id")
- .and_then(serde_json::Value::as_str)
- .expect("alice id")
- .to_string();
- let bob_id = members[1]
- .get("id")
- .and_then(serde_json::Value::as_str)
- .expect("bob id")
- .to_string();
-
- // Assign task A, then task B that depends on A.
- let assign_a = post_json_rpc(
- &rpc_base,
- 9342,
- "openhuman.agent_team_assign_task",
- json!({ "teamId": team_id, "title": "Task A", "dependsOn": [] }),
- )
- .await;
- let assign_a_outer = assert_no_jsonrpc_error(&assign_a, "agent_team_assign_task A");
- let task_a_id = assign_a_outer
- .get("task")
- .and_then(|t| t.get("id"))
- .and_then(serde_json::Value::as_str)
- .expect("task A id")
- .to_string();
-
- let assign_b = post_json_rpc(
- &rpc_base,
- 9343,
- "openhuman.agent_team_assign_task",
- json!({ "teamId": team_id, "title": "Task B", "dependsOn": [task_a_id.clone()] }),
- )
- .await;
- let assign_b_outer = assert_no_jsonrpc_error(&assign_b, "agent_team_assign_task B");
- let task_b_id = assign_b_outer
- .get("task")
- .and_then(|t| t.get("id"))
- .and_then(serde_json::Value::as_str)
- .expect("task B id")
- .to_string();
-
- // Claim B while A is still todo → blocked on A.
- let claim_b_blocked = post_json_rpc(
- &rpc_base,
- 9344,
- "openhuman.agent_team_claim_task",
- json!({
- "teamId": team_id,
- "taskId": task_b_id,
- "memberId": bob_id,
- "claimToken": "tok-b"
- }),
- )
- .await;
- let claim_b_blocked_outer =
- assert_no_jsonrpc_error(&claim_b_blocked, "agent_team_claim_task B blocked");
- assert_eq!(
- claim_b_blocked_outer
- .get("result")
- .and_then(|r| r.get("kind"))
- .and_then(serde_json::Value::as_str),
- Some("blocked")
- );
-
- // Claim A → ok.
- let claim_a = post_json_rpc(
- &rpc_base,
- 9345,
- "openhuman.agent_team_claim_task",
- json!({
- "teamId": team_id,
- "taskId": task_a_id,
- "memberId": alice_id,
- "claimToken": "tok-a"
- }),
- )
- .await;
- let claim_a_outer = assert_no_jsonrpc_error(&claim_a, "agent_team_claim_task A");
- assert_eq!(
- claim_a_outer
- .get("result")
- .and_then(|r| r.get("kind"))
- .and_then(serde_json::Value::as_str),
- Some("claimed")
- );
-
- // Mark A done directly via the run ledger, then B claims fine.
- let task_a = openhuman_core::storage::sessions::with_ledger(&config.workspace_dir, |ledger| {
- let ledger_arg_0 = task_a_id.to_string();
- async move { ledger.get_agent_team_task(&ledger_arg_0).await }
- })
- .expect("get task A")
- .expect("task A present");
- openhuman_core::storage::sessions::with_ledger(&config.workspace_dir, |ledger| {
- let ledger_arg_0 = tinyagents_session::run_ledger::AgentTeamTaskUpsert {
- id: task_a.id.clone(),
- team_id: task_a.team_id.clone(),
- title: task_a.title.clone(),
- objective: task_a.objective.clone(),
- status: tinyagents_session::run_ledger::AgentTeamTaskStatus::Done,
- owner_member_id: task_a.owner_member_id.clone(),
- depends_on: task_a.depends_on.clone(),
- gate_status: Some(task_a.gate_status.clone()),
- gate_reason: task_a.gate_reason.clone(),
- evidence: task_a.evidence.clone(),
- source_run_id: task_a.source_run_id.clone(),
- order_index: task_a.order_index,
- created_at: Some(task_a.created_at),
- };
- async move { ledger.upsert_agent_team_task(ledger_arg_0).await }
- })
- .expect("mark A done");
-
- let claim_b_ok = post_json_rpc(
- &rpc_base,
- 9346,
- "openhuman.agent_team_claim_task",
- json!({
- "teamId": team_id,
- "taskId": task_b_id,
- "memberId": bob_id,
- "claimToken": "tok-b2"
- }),
- )
- .await;
- let claim_b_ok_outer = assert_no_jsonrpc_error(&claim_b_ok, "agent_team_claim_task B ok");
- assert_eq!(
- claim_b_ok_outer
- .get("result")
- .and_then(|r| r.get("kind"))
- .and_then(serde_json::Value::as_str),
- Some("claimed")
- );
-
- // Complete B with no evidence but requireEvidence → quality gate fails.
- let complete_b_blocked = post_json_rpc(
- &rpc_base,
- 9360,
- "openhuman.agent_team_complete_task",
- json!({
- "teamId": team_id,
- "taskId": task_b_id,
- "memberId": bob_id,
- "evidence": [],
- "requireEvidence": true
- }),
- )
- .await;
- let complete_b_blocked_outer =
- assert_no_jsonrpc_error(&complete_b_blocked, "agent_team_complete_task B gate-fail");
- assert_eq!(
- complete_b_blocked_outer
- .get("result")
- .and_then(|r| r.get("kind"))
- .and_then(serde_json::Value::as_str),
- Some("gateFailed")
- );
-
- // Complete B again with evidence → passes the gate, task is now done.
- let complete_b_ok = post_json_rpc(
- &rpc_base,
- 9361,
- "openhuman.agent_team_complete_task",
- json!({
- "teamId": team_id,
- "taskId": task_b_id,
- "memberId": bob_id,
- "evidence": ["https://ci/run/42"],
- "requireEvidence": true
- }),
- )
- .await;
- let complete_b_ok_outer =
- assert_no_jsonrpc_error(&complete_b_ok, "agent_team_complete_task B done");
- assert_eq!(
- complete_b_ok_outer
- .get("result")
- .and_then(|r| r.get("kind"))
- .and_then(serde_json::Value::as_str),
- Some("completed")
- );
-
- // Message bob from alice (still live), then list messages. The shutdown
- // below must come after: a stopped member cannot send or receive.
- let message = post_json_rpc(
- &rpc_base,
- 9347,
- "openhuman.agent_team_message_member",
- json!({
- "teamId": team_id,
- "fromMemberId": alice_id,
- "toMemberId": bob_id,
- "content": "task A done, you are unblocked"
- }),
- )
- .await;
- assert_no_jsonrpc_error(&message, "agent_team_message_member");
-
- let messages = post_json_rpc(
- &rpc_base,
- 9348,
- "openhuman.agent_team_list_messages",
- json!({ "teamId": team_id }),
- )
- .await;
- let messages_outer = assert_no_jsonrpc_error(&messages, "agent_team_list_messages");
- assert_eq!(
- messages_outer
- .get("messages")
- .and_then(serde_json::Value::as_array)
- .map(|m| m.len()),
- Some(1)
- );
-
- // Shut alice down → member stopped (her task A is already done, so nothing
- // is released back to the queue).
- let shutdown_alice = post_json_rpc(
- &rpc_base,
- 9362,
- "openhuman.agent_team_shutdown_member",
- json!({ "teamId": team_id, "memberId": alice_id }),
- )
- .await;
- let shutdown_alice_outer =
- assert_no_jsonrpc_error(&shutdown_alice, "agent_team_shutdown_member alice");
- assert_eq!(
- shutdown_alice_outer
- .get("result")
- .and_then(|r| r.get("member"))
- .and_then(|m| m.get("memberStatus"))
- .and_then(serde_json::Value::as_str),
- Some("stopped")
- );
- assert_eq!(
- shutdown_alice_outer
- .get("result")
- .and_then(|r| r.get("releasedTaskIds"))
- .and_then(serde_json::Value::as_array)
- .map(|ids| ids.len()),
- Some(0)
- );
-
- // A stopped member is no longer part of the live roster, so it can neither
- // send nor receive team messages (`TeamService::ensure_member`).
- let message_from_stopped = post_json_rpc(
- &rpc_base,
- 9363,
- "openhuman.agent_team_message_member",
- json!({
- "teamId": team_id,
- "fromMemberId": alice_id,
- "toMemberId": bob_id,
- "content": "sent after shutdown"
- }),
- )
- .await;
- let stopped_err = assert_jsonrpc_error(
- &message_from_stopped,
- "agent_team_message_member from stopped member",
- );
- assert!(
- stopped_err.to_string().contains("unknown member"),
- "stopped member must be rejected: {stopped_err}"
- );
-
- // Get the team — 2 members, 2 tasks.
- let get = post_json_rpc(
- &rpc_base,
- 9349,
- "openhuman.agent_team_get",
- json!({ "teamId": team_id }),
- )
- .await;
- let get_outer = assert_no_jsonrpc_error(&get, "agent_team_get");
- assert_eq!(
- get_outer
- .get("team")
- .and_then(|t| t.get("members"))
- .and_then(serde_json::Value::as_array)
- .map(|m| m.len()),
- Some(2)
- );
- assert_eq!(
- get_outer
- .get("team")
- .and_then(|t| t.get("tasks"))
- .and_then(serde_json::Value::as_array)
- .map(|t| t.len()),
- Some(2)
- );
+ for (id, method) in [
+ (1, "openhuman.agent_work_list"),
+ (2, "openhuman.agent_team_create"),
+ ] {
+ let response = post_json_rpc(&rpc_base, id, method, json!({})).await;
+ let error = assert_jsonrpc_error(&response, method);
+ assert_eq!(error.get("code").and_then(Value::as_i64), Some(-32000));
+ assert!(
+ error.get("message").and_then(Value::as_str).unwrap_or_default().contains("unknown method"),
+ "retired method should remain unavailable: {error}"
+ );
+ }
- api_join.abort();
rpc_join.abort();
}
@@ -1489,331 +1066,12 @@ async fn team_rpc_e2e() {
rpc_join.abort();
}
-#[test]
-fn json_rpc_agent_team_live_member_run_roundtrip() {
- run_json_rpc_e2e_on_agent_stack(
- "json_rpc_agent_team_live_member_run_roundtrip",
- json_rpc_agent_team_live_member_run_roundtrip_inner,
- );
-}
-
-/// End-to-end proof that a teammate actually *runs* (#3374 PR4): the lead creates
-/// two teammate tasks (B depends on A), messages a named teammate, then starts
-/// each member live. Each member's worker drives a real sub-agent against the
-/// mock backend (pinned via `modelOverride`), completes its task through the
-/// quality gate with the worker output as evidence, and returns to idle —
-/// surfaced by polling `agent_team_get`.
-async fn json_rpc_agent_team_live_member_run_roundtrip_inner() {
- let _env_lock = json_rpc_e2e_env_lock_async().await;
- let tmp = tempdir().expect("tempdir");
- let home = tmp.path();
- let openhuman_home = home.join(".openhuman");
-
- let _home_guard = EnvVarGuard::set_to_path("HOME", home);
- let _workspace_guard = EnvVarGuard::unset("OPENHUMAN_WORKSPACE");
- let _backend_url_guard = EnvVarGuard::unset("BACKEND_URL");
- let _vite_backend_guard = EnvVarGuard::unset("VITE_BACKEND_URL");
-
- let (mock_addr, mock_join) = serve_on_ephemeral(mock_upstream_router()).await;
- let mock_origin = format!("http://{}", mock_addr);
-
- write_min_config(&openhuman_home, &mock_origin);
- let user_scoped_dir = openhuman_home.join("users").join("e2e-user");
- write_min_config(&user_scoped_dir, &mock_origin);
-
- let (rpc_addr, rpc_join) = serve_on_ephemeral(build_core_http_router(false)).await;
- let rpc_base = format!("http://{}", rpc_addr);
-
- tokio::time::sleep(Duration::from_millis(100)).await;
-
- // Authenticate so the spawned workers' provider has a backend session.
- let store = post_json_rpc(
- &rpc_base,
- 380_001,
- "openhuman.auth_store_session",
- json!({ "token": "e2e-test-jwt", "user_id": "e2e-user" }),
- )
- .await;
- assert_no_jsonrpc_error(&store, "store_session");
-
- // Lead creates a team with two named teammates.
- let created = post_json_rpc(
- &rpc_base,
- 380_002,
- "openhuman.agent_team_create",
- json!({
- "leadAgentId": "lead",
- "summary": "live run e2e",
- "members": [
- { "name": "alice", "agentId": "critic" },
- { "name": "bob", "agentId": "critic" }
- ]
- }),
- )
- .await;
- let created_body = assert_no_jsonrpc_error(&created, "agent_team_create");
- let team_id = created_body
- .get("team")
- .and_then(|t| t.get("id"))
- .and_then(Value::as_str)
- .expect("team id")
- .to_string();
- let members = created_body
- .get("members")
- .and_then(Value::as_array)
- .expect("members");
- let alice_id = members[0]
- .get("id")
- .and_then(Value::as_str)
- .unwrap()
- .to_string();
- let bob_id = members[1]
- .get("id")
- .and_then(Value::as_str)
- .unwrap()
- .to_string();
-
- // Task A (no deps) owned by alice; Task B depends on A, owned by bob.
- let assign_a = post_json_rpc(
- &rpc_base,
- 380_003,
- "openhuman.agent_team_assign_task",
- json!({ "teamId": team_id, "title": "Task A", "ownerMemberId": alice_id, "dependsOn": [] }),
- )
- .await;
- let task_a_id = assert_no_jsonrpc_error(&assign_a, "assign A")
- .get("task")
- .and_then(|t| t.get("id"))
- .and_then(Value::as_str)
- .unwrap()
- .to_string();
- let assign_b = post_json_rpc(
- &rpc_base,
- 380_004,
- "openhuman.agent_team_assign_task",
- json!({ "teamId": team_id, "title": "Task B", "ownerMemberId": bob_id, "dependsOn": [task_a_id.clone()] }),
- )
- .await;
- let task_b_id = assert_no_jsonrpc_error(&assign_b, "assign B")
- .get("task")
- .and_then(|t| t.get("id"))
- .and_then(Value::as_str)
- .unwrap()
- .to_string();
-
- // Lead messages a named teammate (fromMemberId omitted → lead origin).
- let msg = post_json_rpc(
- &rpc_base,
- 380_005,
- "openhuman.agent_team_message_member",
- json!({ "teamId": team_id, "toMemberId": alice_id, "content": "please start Task A" }),
- )
- .await;
- assert_no_jsonrpc_error(&msg, "message_member");
-
- // Start alice live on Task A → kind "started".
- let start_a = post_json_rpc(
- &rpc_base,
- 380_006,
- "openhuman.agent_team_start_member",
- json!({ "teamId": team_id, "memberId": alice_id, "taskId": task_a_id, "modelOverride": "e2e-mock-model" }),
- )
- .await;
- assert_eq!(
- assert_no_jsonrpc_error(&start_a, "start alice")
- .get("result")
- .and_then(|r| r.get("kind"))
- .and_then(Value::as_str),
- Some("started"),
- "alice start should dispatch a worker: {start_a}"
- );
-
- // Poll until Task A is done.
- assert!(
- poll_team_task_status(&rpc_base, &team_id, &task_a_id, "done").await,
- "Task A must reach done"
- );
-
- // With A done, start bob live on Task B.
- let start_b = post_json_rpc(
- &rpc_base,
- 380_007,
- "openhuman.agent_team_start_member",
- json!({ "teamId": team_id, "memberId": bob_id, "taskId": task_b_id, "modelOverride": "e2e-mock-model" }),
- )
- .await;
- assert_eq!(
- assert_no_jsonrpc_error(&start_b, "start bob")
- .get("result")
- .and_then(|r| r.get("kind"))
- .and_then(Value::as_str),
- Some("started"),
- "bob start should dispatch a worker: {start_b}"
- );
- assert!(
- poll_team_task_status(&rpc_base, &team_id, &task_b_id, "done").await,
- "Task B must reach done"
- );
- assert!(
- poll_team_members_status(
- &rpc_base,
- &team_id,
- &[alice_id.as_str(), bob_id.as_str()],
- "idle",
- )
- .await,
- "team members must return to idle"
- );
-
- // Final state: both tasks done with evidence, both members idle, and the
- // lead message is in the team timeline.
- let got = post_json_rpc(
- &rpc_base,
- 380_008,
- "openhuman.agent_team_get",
- json!({ "teamId": team_id }),
- )
- .await;
- let team_view = assert_no_jsonrpc_error(&got, "agent_team_get")
- .get("team")
- .cloned()
- .expect("team view");
- let tasks = team_view
- .get("tasks")
- .and_then(Value::as_array)
- .expect("tasks");
- for task in tasks {
- assert_eq!(
- task.get("status").and_then(Value::as_str),
- Some("done"),
- "every task done: {task}"
- );
- assert!(
- task.get("evidence")
- .and_then(Value::as_array)
- .map(|e| !e.is_empty())
- .unwrap_or(false),
- "completed task carries worker-output evidence: {task}"
- );
- }
- let view_members = team_view
- .get("members")
- .and_then(Value::as_array)
- .expect("members");
- for m in view_members {
- assert_eq!(
- m.get("memberStatus").and_then(Value::as_str),
- Some("idle"),
- "members return to idle: {m}"
- );
- }
-
- let messages = post_json_rpc(
- &rpc_base,
- 380_009,
- "openhuman.agent_team_list_messages",
- json!({ "teamId": team_id }),
- )
- .await;
- let msgs = assert_no_jsonrpc_error(&messages, "list_messages")
- .get("messages")
- .and_then(Value::as_array)
- .expect("messages");
- assert!(
- msgs.iter().any(|m| m
- .get("payload")
- .and_then(|p| p.get("from"))
- .and_then(Value::as_str)
- == Some("lead")),
- "lead message present in timeline: {msgs:?}"
- );
-
- rpc_join.abort();
- mock_join.abort();
-}
-
-/// Poll `agent_team_get` until the named task reaches `want` status (or time out).
-async fn poll_team_task_status(rpc_base: &str, team_id: &str, task_id: &str, want: &str) -> bool {
- for attempt in 0..160 {
- tokio::time::sleep(Duration::from_millis(250)).await;
- let got = post_json_rpc(
- rpc_base,
- 38_100_000 + attempt,
- "openhuman.agent_team_get",
- json!({ "teamId": team_id }),
- )
- .await;
- let view = assert_no_jsonrpc_error(&got, "agent_team_get poll");
- // `agent_team_get` answers `{ team: TeamView }`, and TeamView itself nests
- // `{ team, members, tasks }`.
- let tasks = view
- .get("team")
- .and_then(|tv| tv.get("tasks"))
- .and_then(Value::as_array);
- if let Some(tasks) = tasks {
- if let Some(task) = tasks
- .iter()
- .find(|t| t.get("id").and_then(Value::as_str) == Some(task_id))
- {
- if task.get("status").and_then(Value::as_str) == Some(want) {
- return true;
- }
- }
- }
- }
- false
-}
-
-/// Poll `agent_team_get` until every team member reaches `want` (or time out).
-/// Task completion and the worker's transition back to idle are separate
-/// durable operations, so observing a done task does not yet imply idle.
-async fn poll_team_members_status(
- rpc_base: &str,
- team_id: &str,
- expected_member_ids: &[&str],
- want: &str,
-) -> bool {
- for attempt in 0..160 {
- tokio::time::sleep(Duration::from_millis(250)).await;
- let got = post_json_rpc(
- rpc_base,
- 38_200_000 + attempt,
- "openhuman.agent_team_get",
- json!({ "teamId": team_id }),
- )
- .await;
- let members = assert_no_jsonrpc_error(&got, "agent_team_get member poll")
- .get("team")
- .and_then(|tv| tv.get("members"))
- .and_then(Value::as_array);
- if members.is_some_and(|members| {
- members.len() == expected_member_ids.len()
- && expected_member_ids.iter().all(|expected_id| {
- members.iter().any(|member| {
- member.get("id").and_then(Value::as_str) == Some(*expected_id)
- })
- })
- && members
- .iter()
- .all(|member| member.get("memberStatus").and_then(Value::as_str) == Some(want))
- }) {
- return true;
- }
- }
- false
-}
-
-/// End-to-end: plant a thread's session transcript on disk, then verify the
-/// `openhuman.threads_token_usage` RPC reads back the correct cumulative token
-/// totals, cost, last-turn usage, model, and inferred context window — the data
-/// the composer footer seeds itself from when a thread is selected.
-
#[tokio::test]
async fn json_rpc_agent_run_mode_set_and_get_round_trip() {
// `agent.set_run_mode` / `agent.get_run_mode` flip and read back a
// thread's Plan/Build mode through the per-thread `RunModeHandle`
- // registry (`agent::tinyagents::run_mode`) — no thread/session bootstrap
- // needed since the registry is a bare thread_id-keyed map.
+ // registry (`agent::tinyagents::run_mode`). The RPC verifies ownership,
+ // so first create a real thread in the caller's workspace.
let _env_lock = json_rpc_e2e_env_lock_async().await;
let tmp = tempdir().expect("tempdir");
let home = tmp.path();
@@ -1832,7 +1090,13 @@ async fn json_rpc_agent_run_mode_set_and_get_round_trip() {
let (rpc_addr, rpc_join) = serve_on_ephemeral(build_core_http_router(false)).await;
let rpc_base = format!("http://{rpc_addr}");
- let thread_id = "thread-run-mode-e2e";
+ let create = post_json_rpc(&rpc_base, 9400, "openhuman.threads_create_new", json!({})).await;
+ let thread_id = assert_no_jsonrpc_error(&create, "threads_create_new for run mode")
+ .get("data")
+ .and_then(|data| data.get("id"))
+ .and_then(Value::as_str)
+ .expect("created thread should have an id")
+ .to_string();
// Defaults to build.
let initial = post_json_rpc(
@@ -1913,6 +1177,7 @@ async fn json_rpc_agent_context_breakdown_default_agent_returns_sections() {
let (api_addr, api_join) = serve_on_ephemeral(mock_upstream_router()).await;
let api_origin = format!("http://{api_addr}");
write_min_config(openhuman_home.as_path(), &api_origin);
+ store_local_profile_api_key(openhuman_home.as_path(), &api_origin);
let (rpc_addr, rpc_join) = serve_on_ephemeral(build_core_http_router(false)).await;
let rpc_base = format!("http://{rpc_addr}");
diff --git a/tests/support/rpc_e2e_harness.rs b/tests/support/rpc_e2e_harness.rs
index a415294b61..c7f68f973c 100644
--- a/tests/support/rpc_e2e_harness.rs
+++ b/tests/support/rpc_e2e_harness.rs
@@ -1124,6 +1124,26 @@ encrypt = false
toml::from_str(&cfg).expect("config toml must match Config schema");
}
+/// Seed a backend API key in the pre-login profile used by the RPC host.
+/// `write_min_config` writes both root and `users/local` config files, but the
+/// runtime resolves credentials from the latter before a user signs in.
+pub(crate) fn store_local_profile_api_key(openhuman_dir: &Path, api_origin: &str) {
+ let user_scoped_dir = openhuman_dir.join("users").join("local");
+ let mut config = openhuman_core::config::Config {
+ config_path: user_scoped_dir.join("config.toml"),
+ workspace_dir: user_scoped_dir.join("workspace"),
+ api_url: Some(api_origin.to_owned()),
+ ..Default::default()
+ };
+ config.secrets.encrypt = false;
+ std::fs::create_dir_all(&config.workspace_dir).expect("create test workspace");
+ openhuman_core::security::credentials::api_key::store_api_key(
+ &config,
+ "th_live_rpc_e2e_test_key",
+ )
+ .expect("store test backend API key");
+}
+
pub(crate) fn write_min_config_with_local_ai_disabled(openhuman_dir: &Path, api_origin: &str) {
let cfg = format!(
r#"api_url = "{api_origin}"