The fastest, cheapest, most efficient open-source agent harness. Run more than 500 agents on a $10 VPS.
Rust agent-orchestrationai-agentsai-assistantdesktopllmlocal-firstmcppersonal-aiprivacyrustsecond-braintauri
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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsdeleted file mode 100644index 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.rsindex 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").awaitdiff --git a/crates/openhuman-core/src/agent/tinyagents/middleware_tool_policy_tests.rs b/crates/openhuman-core/src/agent/tinyagents/middleware_tool_policy_tests.rsindex 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);