Skip to content

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

test: remove redundant subagent and workspace owner tests

Steven Enamakelbcdeb0a6cc72
diff --git a/crates/openhuman-core/src/agent/orchestration/tools/spawn_subagent_async_tests.rs b/crates/openhuman-core/src/agent/orchestration/tools/spawn_subagent_async_tests.rs
index 19e781f75c..0ffb5b4dcb 100644
--- a/crates/openhuman-core/src/agent/orchestration/tools/spawn_subagent_async_tests.rs
+++ b/crates/openhuman-core/src/agent/orchestration/tools/spawn_subagent_async_tests.rs
@@ -280,7 +280,8 @@ async fn headless_spawn_is_async_and_reports_its_result_to_the_run_log() {
}),
None,
live.data.child(),
- Some(&live),
+ crate::agent::subagent_host::detached_subagent_parent(&live, "headless-child")
+ .expect("detached parent"),
)
.await
.unwrap();
@@ -304,7 +305,14 @@ async fn headless_spawn_is_async_and_reports_its_result_to_the_run_log() {
.expect("headless child is registered");
let finished = tokio::time::timeout(
std::time::Duration::from_secs(5),
- jobs.wait_owned(job.id.as_str(), job.owner.clone()),
+ jobs.wait_owned(
+ job.id.as_str(),
+ crate::agent::tinyagents::tool_registration::subagent_owner_key(
+ workspace.path(),
+ "headless-spawn-session",
+ None,
+ ),
+ ),
)
.await
.expect("headless child completes")
diff --git a/crates/openhuman-core/src/agent/orchestration/tools/spawn_subagent_tests.rs b/crates/openhuman-core/src/agent/orchestration/tools/spawn_subagent_tests.rs
index c5400e5da6..7b8523cf66 100644
--- a/crates/openhuman-core/src/agent/orchestration/tools/spawn_subagent_tests.rs
+++ b/crates/openhuman-core/src/agent/orchestration/tools/spawn_subagent_tests.rs
@@ -1,41 +1,4 @@
use super::*;
-use crate::agent::subagent_host::SubagentMode;
-use std::time::Duration;
-use tempfile::TempDir;
-
-fn sample_outcome(output: &str) -> SubagentRunOutcome {
- SubagentRunOutcome {
- agent_id: "task_manager_agent".into(),
- task_id: "sub-test-1".into(),
- output: output.to_string(),
- elapsed: Duration::from_millis(120),
- iterations: 3,
- failure_cause: None,
- mode: SubagentMode::Typed,
- status: SubagentRunStatus::Completed,
- final_history: Vec::new(),
- usage: Default::default(),
- artifact_paths: Vec::new(),
- persistence_disposition:
- tinyagents_orchestration::subagent::SubagentPersistenceDisposition::TerminalInserted,
- }
-}
-
-#[test]
-fn build_worker_thread_title_collapses_whitespace_and_caps_length() {
- let prompt =
- " draft\n a very long\tplan that\nrambles ".to_string() + "x".repeat(200).as_str();
- let title = build_worker_thread_title(&prompt);
- assert!(title.starts_with("draft a very long plan"));
- assert!(title.chars().count() <= WORKER_THREAD_TITLE_MAX_CHARS + 1);
- assert!(title.ends_with('…'));
-}
-
-#[test]
-fn build_worker_thread_title_falls_back_when_empty() {
- assert_eq!(build_worker_thread_title(" \n\t "), "Worker task");
-}
-
#[test]
fn parameters_schema_hides_legacy_mode_flags_and_keeps_required_agent_id() {
let tool = SpawnSubagentTool::new();
@@ -63,67 +26,6 @@ fn parameters_schema_advertises_optional_model_override() {
.unwrap_or(true));
}
-#[test]
-fn render_worker_thread_result_carries_machine_readable_envelope() {
- let outcome = sample_outcome("done");
- let rendered = render_worker_thread_result("worker-abc", "task_manager_agent", &outcome);
- assert!(rendered.contains("Spawned worker thread `worker-abc`"));
- assert!(rendered.contains("[worker_thread_ref]"));
- assert!(rendered.contains("[/worker_thread_ref]"));
- // The JSON payload between the markers must round-trip.
- let start = rendered.find("[worker_thread_ref]\n").unwrap() + "[worker_thread_ref]\n".len();
- let end = rendered.find("\n[/worker_thread_ref]").unwrap();
- let payload: serde_json::Value =
- serde_json::from_str(&rendered[start..end]).expect("valid json envelope");
- assert_eq!(payload["thread_id"], "worker-abc");
- assert_eq!(payload["label"], "worker");
- assert_eq!(payload["agent_id"], "task_manager_agent");
- assert_eq!(payload["task_id"], "sub-test-1");
- assert_eq!(payload["iterations"], 3);
-}
-
-#[test]
-fn persist_worker_thread_creates_thread_with_tasks_label_and_messages() {
- let temp = TempDir::new().expect("tempdir");
- let outcome = sample_outcome("the answer is 42");
- let thread_id = persist_worker_thread(
- &crate::core::runtime::DispatchCtx::ambient(),
- temp.path(),
- "task_manager_agent",
- "draft a long research plan",
- &outcome,
- )
- .expect("worker thread persisted");
-
- assert!(thread_id.starts_with("worker-"));
-
- let threads = conversations::list_threads(
- &crate::core::runtime::DispatchCtx::ambient(),
- temp.path().to_path_buf(),
- )
- .expect("list threads");
- let worker = threads
- .iter()
- .find(|t| t.id == thread_id)
- .expect("worker thread present");
- assert!(worker.labels.contains(&"tasks".to_string()));
- assert!(worker.title.starts_with("draft a long research plan"));
-
- let messages = conversations::get_messages(
- &crate::core::runtime::DispatchCtx::ambient(),
- temp.path().to_path_buf(),
- &thread_id,
- )
- .expect("messages");
- assert_eq!(messages.len(), 2);
- assert_eq!(messages[0].sender, "user");
- assert_eq!(messages[0].content, "draft a long research plan");
- assert_eq!(messages[1].sender, "agent");
- assert_eq!(messages[1].content, "the answer is 42");
- assert_eq!(messages[1].extra_metadata["iterations"], 3);
- assert_eq!(messages[1].extra_metadata["scope"], "worker_thread");
-}
-
#[tokio::test]
async fn missing_agent_id_returns_error() {
let tool = SpawnSubagentTool::new();
@@ -186,15 +88,6 @@ async fn unknown_agent_id_lists_available() {
assert!(out.contains("task_manager_agent"));
}
-#[test]
-fn classify_subagent_failure_reframes_upstream_provider_outages() {
- let msg = SpawnSubagentTool::classify_subagent_failure(
- "provider call failed: all providers/models failed: upstream unavailable",
- );
- assert!(msg.contains("upstream inference unavailable"));
- assert!(msg.contains("NOT a Composio/integration auth issue"));
-}
-
#[test]
fn frozen_legacy_mode_arguments_are_accepted_but_ignored() {
let args = json!({
diff --git a/crates/openhuman-core/src/agent/orchestration/tools/tools_e2e_continuation_tests.rs b/crates/openhuman-core/src/agent/orchestration/tools/tools_e2e_continuation_tests.rs
index c82b5e183a..b8510ca014 100644
--- a/crates/openhuman-core/src/agent/orchestration/tools/tools_e2e_continuation_tests.rs
+++ b/crates/openhuman-core/src/agent/orchestration/tools/tools_e2e_continuation_tests.rs
@@ -41,7 +41,8 @@ async fn spawn_subagent_with_same_task_key_resumes_paused_job_through_shared_dri
}),
None,
live.data.child(),
- Some(&live),
+ crate::agent::subagent_host::detached_subagent_parent(&live, "pause-resume-child")
+ .expect("detached parent"),
)
.await
.expect("initial spawn");
@@ -67,7 +68,14 @@ async fn spawn_subagent_with_same_task_key_resumes_paused_job_through_shared_dri
.expect("initial child is registered in shared Jobs");
let paused_job = tokio::time::timeout(
std::time::Duration::from_secs(5),
- jobs.wait_owned(running_job.id.as_str(), running_job.owner.clone()),
+ jobs.wait_owned(
+ running_job.id.as_str(),
+ crate::agent::tinyagents::tool_registration::subagent_owner_key(
+ workspace.path(),
+ "continue-paused-e2e",
+ None,
+ ),
+ ),
)
.await
.expect("child reaches its clarification checkpoint")
@@ -94,7 +102,8 @@ async fn spawn_subagent_with_same_task_key_resumes_paused_job_through_shared_dri
}),
None,
live.data.child(),
- Some(&live),
+ crate::agent::subagent_host::detached_subagent_parent(&live, "pause-resume-child")
+ .expect("detached parent"),
)
.await
.expect("continue");
@@ -217,7 +226,8 @@ async fn cancelling_a_paused_driver_through_rpc_settles_once_with_its_reason() {
}),
None,
live.data.child(),
- Some(&live),
+ crate::agent::subagent_host::detached_subagent_parent(&live, "paused-cancel-child")
+ .expect("detached parent"),
)
.await
.expect("initial spawn");
diff --git a/crates/openhuman-core/src/agent/orchestration/tools/tools_e2e_tests.rs b/crates/openhuman-core/src/agent/orchestration/tools/tools_e2e_tests.rs
index 5aa328e428..390736a9f8 100644
--- a/crates/openhuman-core/src/agent/orchestration/tools/tools_e2e_tests.rs
+++ b/crates/openhuman-core/src/agent/orchestration/tools/tools_e2e_tests.rs
@@ -299,5 +299,3 @@ mod driver_tests;
#[path = "tools_e2e_continuation_tests.rs"]
mod continuation_tests;
-#[path = "tools_e2e_workspace_owner_tests.rs"]
-mod workspace_owner_tests;
diff --git a/crates/openhuman-core/src/agent/orchestration/tools/tools_e2e_workspace_owner_tests.rs b/crates/openhuman-core/src/agent/orchestration/tools/tools_e2e_workspace_owner_tests.rs
deleted file mode 100644
index b38c738d2d..0000000000
--- a/crates/openhuman-core/src/agent/orchestration/tools/tools_e2e_workspace_owner_tests.rs
+++ /dev/null
@@ -1,410 +0,0 @@
-use super::*;
-
-#[tokio::test]
-async fn driver_job_controls_are_isolated_by_workspace_with_shared_runtime_state() {
- use crate::agent::orchestration::subagent_sessions::{
- DurableSubagentSession, DurableSubagentStatus, SubagentSessionStore,
- };
- use crate::agent::subagent_host::{run_subagent_via_driver_tool, SubagentRunOptions};
- use crate::core::runtime::{ContextOverlay, CoreContext, DomainSet};
- use crate::tools::toolpacks::ToolGroups;
- use tinyagents_harness::agent_loop::phases::execute_tool_batch;
- use tinyagents_harness_tools::subagents::SubAgentJobRegistry;
- use tinyagents_runtime::turn_driver::SharedToolSet;
-
- struct PausedModel {
- started: tokio::sync::mpsc::UnboundedSender<()>,
- release: Arc<tokio::sync::Notify>,
- }
-
- #[async_trait]
- impl ChatModel<()> for PausedModel {
- async fn invoke(
- &self,
- _state: &(),
- _request: ModelRequest,
- ) -> tinyinference_llm::Result<ModelResponse> {
- let _ = self.started.send(());
- self.release.notified().await;
- Ok(ModelResponse::assistant("workspace child finished"))
- }
- }
-
- let scratch = tempfile::tempdir().expect("workspace owner isolation fixture");
- let workspace_a = scratch.path().join("workspace-a");
- let workspace_b = scratch.path().join("workspace-b");
- std::fs::create_dir_all(&workspace_a).expect("create workspace A");
- std::fs::create_dir_all(&workspace_b).expect("create workspace B");
- let mut base_config = crate::config::Config::default();
- base_config.workspace_dir = workspace_a.clone();
- base_config.components.juice = false;
- let base = CoreContext::for_test_with_config(DomainSet::full(), base_config.clone());
- let definitions = Arc::new(AgentDefinitionRegistry::builtins_only());
- let mut config_a = base_config.clone();
- config_a.workspace_dir = workspace_a.clone();
- let mut config_b = base_config;
- config_b.workspace_dir = workspace_b.clone();
- let core_a = base.derive_with(
- ContextOverlay::new(config_a, DomainSet::full(), ToolGroups::none())
- .definitions(definitions.clone()),
- );
- let core_b = base.derive_with(
- ContextOverlay::new(config_b, DomainSet::full(), ToolGroups::none())
- .definitions(definitions),
- );
-
- let (started_tx, mut started_rx) = tokio::sync::mpsc::unbounded_channel();
- let release = Arc::new(tokio::sync::Notify::new());
- let model: Arc<dyn ChatModel<()>> = Arc::new(PausedModel {
- started: started_tx,
- release: release.clone(),
- });
- let build_parent = |workspace: &std::path::Path, core: &Arc<CoreContext>| {
- let mut product_parent = parent_context(workspace, model.clone(), vec![]);
- product_parent.workspace_dir = workspace.to_path_buf();
- product_parent.session_id = "same-parent-session".into();
- let mut options = SubagentRunOptions::default();
- options.run_context.parent = Some(product_parent);
- options.task_id = Some("same-raw-task-id".into());
- options.thread_id = Some("same-parent-thread".into());
- options.run_context.thread_id = Some("same-parent-thread".into());
- options.run_context = options.run_context.with_core(Some(Arc::clone(core)));
- let run_id = workspace
- .file_name()
- .and_then(std::ffi::OsStr::to_str)
- .unwrap_or("workspace");
- let run = options.run_context.clone().into_tinyagents(
- tinyagents_harness::context::RunConfig::new(format!("parent-{run_id}"))
- .with_thread("same-parent-thread"),
- );
- (options, run)
- };
- let (options_a, parent_a) = build_parent(&workspace_a, &core_a);
- let (options_b, parent_b) = build_parent(&workspace_b, &core_b);
- let parent_cancel_a = options_a.run_context.cancellation.clone();
- let parent_cancel_b = options_b.run_context.cancellation.clone();
- // Control aliases run in a fresh turn context, as they do after a parent
- // turn resumes. Keep the original parents intact for their spawned child
- // futures; RunContext is intentionally not Clone.
- let mut run_a = options_a.run_context.clone().into_tinyagents(
- tinyagents_harness::context::RunConfig::new("workspace-a-control")
- .with_thread("same-parent-thread"),
- );
- let mut run_b = options_b.run_context.clone().into_tinyagents(
- tinyagents_harness::context::RunConfig::new("workspace-b-control")
- .with_thread("same-parent-thread"),
- );
- let jobs_a =
- crate::core::runtime::slot_for::<SubAgentJobRegistry>(&parent_a.data.dispatch_ctx());
- let jobs_b =
- crate::core::runtime::slot_for::<SubAgentJobRegistry>(&parent_b.data.dispatch_ctx());
- assert!(
- Arc::ptr_eq(&jobs_a, &jobs_b),
- "the two workspace overlays must exercise one shared registry"
- );
- let key_a = tinyagents_orchestration::subagent::SubagentTaskKey::from_context(
- &parent_a,
- "same-raw-task-id",
- Some("same-parent-thread".into()),
- );
- let key_b = tinyagents_orchestration::subagent::SubagentTaskKey::from_context(
- &parent_b,
- "same-raw-task-id",
- Some("same-parent-thread".into()),
- );
-
- let mut definition_a = AgentDefinitionRegistry::builtins_only()
- .get("task_manager_agent")
- .expect("task manager definition")
- .clone();
- definition_a.id = "workspace-a-worker".into();
- definition_a.model = tinyagents_definition::ModelSpec::Inherit;
- let mut definition_b = definition_a.clone();
- definition_b.id = "workspace-b-worker".into();
- let mut child_a = tokio::spawn(async move {
- run_subagent_via_driver_tool(
- &parent_a,
- definition_a,
- "run in workspace A".into(),
- options_a,
- )
- .await
- });
- let mut child_b = tokio::spawn(async move {
- run_subagent_via_driver_tool(
- &parent_b,
- definition_b,
- "run in workspace B".into(),
- options_b,
- )
- .await
- });
- let both_started = tokio::time::timeout(std::time::Duration::from_secs(5), async {
- for _ in 0..2 {
- tokio::select! {
- notification = started_rx.recv() => {
- notification.expect("model start notification");
- }
- result = &mut child_a => match result {
- Ok(Ok((outcome, output))) => panic!(
- "workspace A child returned before entering the gated model: {:?}, {output}",
- outcome.status,
- ),
- Ok(Err(error)) => panic!("workspace A child failed before model start: {error:?}"),
- Err(error) => panic!("workspace A child task panicked before model start: {error}"),
- },
- result = &mut child_b => match result {
- Ok(Ok((outcome, output))) => panic!(
- "workspace B child returned before entering the gated model: {:?}, {output}",
- outcome.status,
- ),
- Ok(Err(error)) => panic!("workspace B child failed before model start: {error:?}"),
- Err(error) => panic!("workspace B child task panicked before model start: {error}"),
- },
- }
- }
- })
- .await;
- if both_started.is_err() {
- let jobs = jobs_a
- .list()
- .into_iter()
- .map(|job| format!("{}:{}:{:?}", job.id, job.agent, job.status))
- .collect::<Vec<_>>();
- panic!(
- "both driver children enter the gated model; jobs={jobs:?}, child_finished=({}, {})",
- child_a.is_finished(),
- child_b.is_finished()
- );
- }
-
- let job_a = jobs_a
- .list()
- .into_iter()
- .find(|job| job.agent == "workspace-a-worker")
- .expect("workspace A child is registered");
- let job_b = jobs_b
- .list()
- .into_iter()
- .find(|job| job.agent == "workspace-b-worker")
- .expect("workspace B child is registered");
- let id_a = job_a.id.as_str().to_owned();
- let id_b = job_b.id.as_str().to_owned();
- assert_ne!(
- id_a, id_b,
- "full lifecycle scope keeps raw-ID reuse distinct"
- );
-
- let now = chrono::Utc::now().to_rfc3339();
- let save_running_session =
- |workspace: &std::path::Path,
- session_id: &str,
- task_key: tinyagents_orchestration::subagent::SubagentTaskKey| {
- SubagentSessionStore::new(workspace.to_path_buf()).save(&[DurableSubagentSession {
- subagent_session_id: session_id.to_owned(),
- parent_session: "same-parent-session".into(),
- parent_thread_id: Some("same-parent-thread".into()),
- worker_thread_id: None,
- agent_id: "task_manager_agent".into(),
- display_name: None,
- model: Some("test-model".into()),
- sandbox_mode: "workspace".into(),
- action_root: None,
- task_key: "same task in another workspace".into(),
- task_title: "Workspace scoped task".into(),
- current_task_id: Some("same-raw-task-id".into()),
- lifecycle_key: Some(task_key),
- parent_epoch: None,
- status: DurableSubagentStatus::Running,
- reusable: true,
- latest_history: None,
- latest_error: None,
- created_at: now.clone(),
- updated_at: now.clone(),
- last_used_at: now.clone(),
- }])
- };
- save_running_session(&workspace_a, "workspace-a-session", key_a)
- .expect("persist A session for native close alias");
- save_running_session(&workspace_b, "workspace-b-session", key_b)
- .expect("persist B session for native close alias");
-
- let tools: SharedToolSet = Arc::new(vec![
- Box::new(crate::agent::orchestration::tools::ListSubagentsTool::new()),
- Box::new(crate::agent::orchestration::tools::WaitSubagentTool::new()),
- Box::new(crate::agent::orchestration::tools::SteerSubagentTool::new()),
- Box::new(crate::agent::orchestration::tools::CloseSubagentTool::new()),
- ]);
- let sets = vec![tools];
- let mut harness: tinyagents_harness::runtime::AgentHarness<
- (),
- crate::agent::tinyagents::host::OpenHumanRunContext,
- > = tinyagents_harness::runtime::AgentHarness::new();
- crate::agent::tinyagents::tool_registration::host_tool_set_builder(
- &sets,
- &None,
- true,
- &std::collections::HashSet::new(),
- )
- .register(&mut harness, None);
- let mut status_a = tinyagents_harness::events::HarnessRunStatus::new(
- run_a.run_id().clone(),
- tinyagents_harness::ComponentId::new("workspace-a-control"),
- );
- let mut status_b = tinyagents_harness::events::HarnessRunStatus::new(
- run_b.run_id().clone(),
- tinyagents_harness::ComponentId::new("workspace-b-control"),
- );
- let mut agent_run_a = tinyagents_harness::middleware::AgentRun::new();
- let mut agent_run_b = tinyagents_harness::middleware::AgentRun::new();
- let mut messages_a = Vec::new();
- let mut messages_b = Vec::new();
- let listed_a = execute_tool_batch(
- &harness,
- &(),
- &mut run_a,
- &mut agent_run_a,
- &mut status_a,
- &mut messages_a,
- vec![tinyinference_llm::tool::ToolCall::new(
- "workspace-a-list",
- "list_subagents",
- serde_json::json!({}),
- )],
- )
- .await
- .expect("native list alias works for A");
- assert!(listed_a.results[0].text().contains("workspace-a-session"));
- assert!(
- !listed_a.results[0].text().contains("workspace-b-session"),
- "A must not see B's durable session: {}",
- listed_a.results[0].text()
- );
- let listed_b = execute_tool_batch(
- &harness,
- &(),
- &mut run_b,
- &mut agent_run_b,
- &mut status_b,
- &mut messages_b,
- vec![tinyinference_llm::tool::ToolCall::new(
- "workspace-b-list",
- "list_subagents",
- serde_json::json!({}),
- )],
- )
- .await
- .expect("native list alias works for B");
- assert!(listed_b.results[0].text().contains("workspace-b-session"));
- assert!(!listed_b.results[0].text().contains("workspace-a-session"));
-
- let foreign_wait = execute_tool_batch(
- &harness,
- &(),
- &mut run_a,
- &mut agent_run_a,
- &mut status_a,
- &mut messages_a,
- vec![tinyinference_llm::tool::ToolCall::new(
- "workspace-a-wait-b",
- "wait_subagent",
- serde_json::json!({"task_id":id_b,"timeout_secs":1}),
- )],
- )
- .await
- .expect("foreign wait returns a recoverable selector denial");
- assert_eq!(foreign_wait.results.len(), 1);
- let foreign_wait_text = foreign_wait.results[0].text();
- assert!(
- foreign_wait_text.contains("selected subagent job or session is unavailable"),
- "A must receive a selector denial for B's generic job id, got: {foreign_wait_text}"
- );
- assert_eq!(
- jobs_b
- .get(&id_b)
- .expect("B child remains registered")
- .status,
- tinyagents_orchestration::subagent::SubAgentJobStatus::Running,
- "a foreign wait must not settle or mutate B's child"
- );
-
- let foreign_close = execute_tool_batch(
- &harness,
- &(),
- &mut run_a,
- &mut agent_run_a,
- &mut status_a,
- &mut messages_a,
- vec![tinyinference_llm::tool::ToolCall::new(
- "workspace-a-close-b",
- "close_subagent",
- serde_json::json!({"subagent_session_id":"workspace-b-session"}),
- )],
- )
- .await
- .expect("foreign close is a recoverable model-facing selector error");
- assert!(!foreign_close.results[0].text().contains("\"closed\":true"));
- let job_b = jobs_b.get(&id_b).expect("B's child remains registered");
- assert_eq!(
- job_b.status,
- tinyagents_orchestration::subagent::SubAgentJobStatus::Running
- );
-
- let owned_close = execute_tool_batch(
- &harness,
- &(),
- &mut run_b,
- &mut agent_run_b,
- &mut status_b,
- &mut messages_b,
- vec![tinyinference_llm::tool::ToolCall::new(
- "workspace-b-close-own",
- "close_subagent",
- serde_json::json!({"subagent_session_id":"workspace-b-session"}),
- )],
- )
- .await
- .expect("B can close its own durable child");
- assert_eq!(owned_close.results.len(), 1);
- assert_eq!(
- SubagentSessionStore::new(workspace_b.clone())
- .load()
- .unwrap()[0]
- .status,
- DurableSubagentStatus::Closed
- );
- release.notify_waiters();
- let result_a = tokio::time::timeout(std::time::Duration::from_secs(5), child_a)
- .await
- .expect("A child settles")
- .expect("A task join")
- .expect("A child succeeds");
- let result_b = tokio::time::timeout(std::time::Duration::from_secs(5), child_b)
- .await
- .expect("B child settles")
- .expect("B task join");
- assert!(matches!(
- result_a.0.status,
- crate::agent::subagent_host::SubagentRunStatus::Completed
- ));
- match result_b {
- Ok((outcome, _)) => assert!(matches!(
- outcome.status,
- crate::agent::subagent_host::SubagentRunStatus::Cancelled
- )),
- Err(error) => assert_eq!(
- error.to_string(),
- "provider call failed: tinyagents harness run failed: run cancelled"
- ),
- }
- assert_eq!(
- jobs_b
- .get(&id_b)
- .expect("B driver job remains inspectable")
- .status,
- tinyagents_orchestration::subagent::SubAgentJobStatus::Cancelled,
- "the shared driver registry is authoritative for B's cancellation"
- );
- assert!(!parent_cancel_a.is_cancelled());
- assert!(!parent_cancel_b.is_cancelled());
-}
diff --git a/crates/openhuman-core/src/agent/subagent_host/ops_tests_driver_bridge_tests.rs b/crates/openhuman-core/src/agent/subagent_host/ops_tests_driver_bridge_tests.rs
index 5574250231..8e871e1325 100644
--- a/crates/openhuman-core/src/agent/subagent_host/ops_tests_driver_bridge_tests.rs
+++ b/crates/openhuman-core/src/agent/subagent_host/ops_tests_driver_bridge_tests.rs
@@ -379,47 +379,6 @@ async fn closing_a_durable_driver_session_cancels_only_its_registered_child() {
Some("close-driver-thread".into()),
)
.with_jobs(jobs.clone());
- let owner = crate::agent::tinyagents::tool_registration::subagent_owner_key(
- &workspace,
- "test-session",
- Some("close-driver-thread"),
- );
- let owner_scope: std::sync::Arc<dyn Fn(u64) -> String + Send + Sync> =
- std::sync::Arc::new(move |_| owner.clone());
- let message_store: std::sync::Arc<dyn TinySessionStore> = std::sync::Arc::new(port.clone());
- let message_dispatch: crate::agent::tinyagents::tool_registration::RegisteredToolDispatch =
- std::sync::Arc::new(
- tinyagents_harness_tools::subagents::SubAgentMessageTool::new(jobs.clone())
- .with_tool_name("steer_subagent")
- .with_argument_fields("task_id", "subagent_session_id", "message", "__request_id")
- .with_lane_field("mode")
- .with_owner_scope(owner_scope.clone())
- .with_sessions(message_store, |_| "test-session".to_owned()),
- );
- let message_dispatch =
- crate::agent::tinyagents::tool_registration::TaskFirstSessionMessageDispatch::new(
- message_dispatch,
- );
- let steered = tinyagents_harness::tool::ToolDispatch::execute(
- &message_dispatch,
- &(),
- tinyagents_harness::CallId::new("steer-raw-task-id"),
- serde_json::json!({
- "task_id": "close-driver-task",
- "subagent_session_id": "foreign-session-must-not-win",
- "message": "please continue after this note",
- "mode": "collect"
- }),
- tinytools::ToolCallOptions::default(),
- &parent,
- )
- .await
- .expect("TaskFirst host adapter resolves raw task ID via the owned session port");
- let steered_payload: serde_json::Value =
- serde_json::from_str(&steered.output()).expect("message dispatch returns JSON");
- assert_eq!(steered_payload["job_id"].as_str(), Some(job_id.as_str()));
- assert_eq!(steered_payload["status"], "message_queued");
-
assert!(port
.close("close-driver-session")
.await
diff --git a/crates/openhuman-core/src/agent/tinyagents/middleware_tool_policy_tests.rs b/crates/openhuman-core/src/agent/tinyagents/middleware_tool_policy_tests.rs
index 74129e776c..158b636ac2 100644
--- a/crates/openhuman-core/src/agent/tinyagents/middleware_tool_policy_tests.rs
+++ b/crates/openhuman-core/src/agent/tinyagents/middleware_tool_policy_tests.rs
@@ -10,7 +10,6 @@ use crate::agent::tinyagents::middleware::tool_policy::ToolPolicyMiddleware;
// these pin that the middleware feeds it the *session's* answer and resolves
// the route out of the session's own delegation tools.
-use crate::agent::orchestration::tools::{ArchetypeDelegationTool, DelegationTarget};
use crate::tools::toolpacks::{append_pack_tools, bind_pack_registry};
use tinyagents_harness_tools::skills::USE_SKILL;
use tinytools::{PermissionLevel, ToolResult};
@@ -53,7 +52,7 @@ fn allow(name: &str) -> (String, ToolPolicyDecision) {
}
/// A non-owner session: it holds the whole `workflows` pack in its registry and
-/// a `build_workflow` delegate, but may only call the delegate and the pack
+/// a `build_workflow` route, but may only call that route and the pack
/// tool — exactly the orchestrator's shape. Anything not named here is denied,
/// because `decision_for` defaults to `Deny`.
fn non_owner_middleware() -> ToolPolicyMiddleware {
@@ -67,11 +66,6 @@ fn non_owner_middleware_at(allowed: PermissionLevel) -> ToolPolicyMiddleware {
let mut tools: Vec<Box<dyn tinytools::Tool>> = vec![
Box::new(RoutingFakeTool("build_workflow")),
Box::new(RoutingFakeTool("propose_workflow")),
- Box::new(ArchetypeDelegationTool {
- tool_name: "build_workflow".to_string(),
- agent_id: DelegationTarget("workflow_builder".to_string()),
- tool_description: "Build a workflow".to_string(),
- }),
];
append_pack_tools(&mut tools);
let tools = Arc::new(tools);