chore: update TinyAgents, TinyInference, and TinyTools

crates/openhuman-core/src/agent/agent_tests.rs

@@ -34,7 +34,7 @@ use async_trait::async_trait;
 use std::sync::{Arc, Mutex};
 use tinyinference_llm::model::{ChatModel, ModelProfile, ModelRequest, ModelResponse};
 use tinytools::{Tool, ToolResult};
-use tinytools_agent::dialect::{NativeDialect, ToolDialect, ToolOutcome, XmlDialect};
+use tinytools_agent::dialect::{NativeDialect, ToolDialect, XmlDialect};
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Test Helpers — Mock Provider, Mock Tool, Mock Memory

crates/openhuman-core/src/agent/harness/graph_tests.rs

@@ -34,6 +34,7 @@ async fn channel_turn_runs_through_the_graph() {
                 content: Vec::new(),
                 tool_calls: vec![ToolCall::new("p", "ping", serde_json::json!({}))],
                 usage: None,
+                origin: None,
             },
             usage: None,
             finish_reason: Some("tool_calls".to_string()),
@@ -93,6 +94,7 @@ async fn channel_turn_pauses_on_ask_user_clarification() {
                     serde_json::json!({ "question": "Which three sources?" }),
                 )],
                 usage: None,
+                origin: None,
             },
             usage: None,
             finish_reason: Some("tool_calls".to_string()),

crates/openhuman-core/src/agent/message_convert.rs

@@ -171,6 +171,9 @@ pub(crate) fn chat_message_to_message(msg: &ChatMessage) -> Message {
     match msg.role.as_str() {
         "system" => Message::System(SystemMessage {
             content: vec![ContentBlock::Text(text)],
+            sections: Default::default(),
+            tools_added: Vec::new(),
+            tools_removed: Vec::new(),
         }),
         "assistant" => {
             // Restore any `reasoning_content` stashed on the persisted message so a
@@ -189,6 +192,7 @@ pub(crate) fn chat_message_to_message(msg: &ChatMessage) -> Message {
                     content,
                     tool_calls,
                     usage: None,
+                    origin: None,
                 })
             } else {
                 let mut content = vec![ContentBlock::Text(text)];
@@ -198,6 +202,7 @@ pub(crate) fn chat_message_to_message(msg: &ChatMessage) -> Message {
                     content,
                     tool_calls: Vec::new(),
                     usage: None,
+                    origin: None,
                 })
             }
         }

crates/openhuman-core/src/agent/message_convert_tests.rs

@@ -241,6 +241,7 @@ fn legacy_provider_extension_reasoning_still_round_trips() {
         ],
         tool_calls: vec![],
         usage: None,
+        origin: None,
     });
 
     let back = message_to_chat_message(&msg);
@@ -303,6 +304,7 @@ fn conversation_preserves_tool_call_structure() {
                 invalid: None,
             }],
             usage: None,
+            origin: None,
         }),
         Message::Tool(ToolMessage {
             tool_call_id: "c1".into(),
@@ -315,6 +317,7 @@ fn conversation_preserves_tool_call_structure() {
             content: vec![ContentBlock::Text("all done".into())],
             tool_calls: vec![],
             usage: None,
+            origin: None,
         }),
     ];
 

crates/openhuman-core/src/agent/orchestration/agent_teams/runtime_tests.rs

@@ -12,7 +12,6 @@ use std::collections::HashSet;
 use std::sync::Arc;
 
 use async_trait::async_trait;
-use serde_json::json;
 
 use super::*;
 use crate::agent::harness::definition::AgentDefinitionRegistry;

crates/openhuman-core/src/agent/orchestration/tools/agent_prepare_context/tool.rs

@@ -38,11 +38,12 @@ impl ToolDispatch<(), crate::agent::tinyagents::host::OpenHumanRunContext>
     async fn execute(
         &self,
         _state: &(),
+        _call_id: tinyagents_harness::CallId,
         arguments: serde_json::Value,
         _options: ToolCallOptions,
         parent: &RunContext<crate::agent::tinyagents::host::OpenHumanRunContext>,
     ) -> anyhow::Result<ToolResult> {
-        let context = ToolExecutionContext::from_run_context(parent);
+        let context = ToolExecutionContext::from_run_context(parent, _call_id.clone());
         AgentPrepareContextTool::new()
             .execute_with_live_parent_context(
                 arguments,

crates/openhuman-core/src/agent/orchestration/tools/close_subagent.rs

@@ -30,11 +30,12 @@ impl ToolDispatch<(), crate::agent::tinyagents::host::OpenHumanRunContext>
     async fn execute(
         &self,
         _state: &(),
+        _call_id: tinyagents_harness::CallId,
         arguments: serde_json::Value,
         _options: ToolCallOptions,
         parent: &RunContext<crate::agent::tinyagents::host::OpenHumanRunContext>,
     ) -> anyhow::Result<ToolResult> {
-        let context = ToolExecutionContext::from_run_context(parent);
+        let context = ToolExecutionContext::from_run_context(parent, _call_id.clone());
         CloseSubagentTool::new()
             .execute_with_parent_context(arguments, parent.data.parent.clone(), Some(&context))
             .await

crates/openhuman-core/src/agent/orchestration/tools/continue_subagent.rs

@@ -45,11 +45,12 @@ impl ToolDispatch<(), crate::agent::tinyagents::host::OpenHumanRunContext>
     async fn execute(
         &self,
         _state: &(),
+        _call_id: tinyagents_harness::CallId,
         arguments: serde_json::Value,
         _options: ToolCallOptions,
         parent: &RunContext<crate::agent::tinyagents::host::OpenHumanRunContext>,
     ) -> anyhow::Result<ToolResult> {
-        let context = ToolExecutionContext::from_run_context(parent);
+        let context = ToolExecutionContext::from_run_context(parent, _call_id.clone());
         ContinueSubagentTool::new()
             .execute_with_live_parent_context(
                 arguments,

crates/openhuman-core/src/agent/orchestration/tools/delegate_graph.rs

@@ -53,11 +53,12 @@ impl ToolDispatch<(), crate::agent::tinyagents::host::OpenHumanRunContext>
     async fn execute(
         &self,
         _state: &(),
+        _call_id: tinyagents_harness::CallId,
         arguments: serde_json::Value,
         _options: ToolCallOptions,
         parent: &RunContext<crate::agent::tinyagents::host::OpenHumanRunContext>,
     ) -> anyhow::Result<ToolResult> {
-        let context = ToolExecutionContext::from_run_context(parent);
+        let context = ToolExecutionContext::from_run_context(parent, _call_id.clone());
         let graph_parent = parent
             .child(
                 tinyagents_harness::context::RunConfig::new(format!(

crates/openhuman-core/src/agent/orchestration/tools/dispatch.rs

@@ -88,11 +88,12 @@ impl ToolDispatch<(), crate::agent::tinyagents::host::OpenHumanRunContext> for D
     async fn execute(
         &self,
         _state: &(),
+        _call_id: tinyagents_harness::CallId,
         arguments: serde_json::Value,
         _options: ToolCallOptions,
         parent: &RunContext<crate::agent::tinyagents::host::OpenHumanRunContext>,
     ) -> anyhow::Result<ToolResult> {
-        let tool_context = ToolExecutionContext::from_run_context(parent);
+        let tool_context = ToolExecutionContext::from_run_context(parent, _call_id.clone());
         let child = parent.data.child();
         match &self.kind {
             DelegationDispatchKind::Collapsed { targets } => {

crates/openhuman-core/src/agent/orchestration/tools/dispatch_tests.rs

@@ -114,6 +114,7 @@ async fn delegate_graph_dispatch_uses_its_durable_graph_argument_path() {
     let result = dispatch
         .execute(
             &(),
+            tinyagents_harness::CallId::new("test-call"),
             serde_json::json!({"task": "review this change"}),
             tinytools::ToolCallOptions::default(),
             &parent,
@@ -141,6 +142,7 @@ async fn config_delegate_dispatch_honours_the_parent_cancellation_token() {
         .into_tinyagents(RunConfig::new("config-delegate-parent").with_thread("thread-parent"));
     let execution = dispatch.execute(
         &(),
+        tinyagents_harness::CallId::new("test-call"),
         serde_json::json!({"agent": "configured", "prompt": "work"}),
         tinytools::ToolCallOptions::default(),
         &parent,

crates/openhuman-core/src/agent/orchestration/tools/list_subagents.rs

@@ -35,11 +35,12 @@ impl ToolDispatch<(), crate::agent::tinyagents::host::OpenHumanRunContext>
     async fn execute(
         &self,
         _state: &(),
+        _call_id: tinyagents_harness::CallId,
         arguments: serde_json::Value,
         _options: ToolCallOptions,
         parent: &RunContext<crate::agent::tinyagents::host::OpenHumanRunContext>,
     ) -> anyhow::Result<ToolResult> {
-        let context = ToolExecutionContext::from_run_context(parent);
+        let context = ToolExecutionContext::from_run_context(parent, _call_id.clone());
         ListSubagentsTool::new()
             .execute_with_parent_context(arguments, parent.data.parent.clone(), Some(&context))
             .await

crates/openhuman-core/src/agent/orchestration/tools/spawn_async_subagent.rs

@@ -50,11 +50,12 @@ impl ToolDispatch<(), crate::agent::tinyagents::host::OpenHumanRunContext>
     async fn execute(
         &self,
         _state: &(),
+        _call_id: tinyagents_harness::CallId,
         arguments: serde_json::Value,
         _options: ToolCallOptions,
         parent: &RunContext<crate::agent::tinyagents::host::OpenHumanRunContext>,
     ) -> anyhow::Result<ToolResult> {
-        let context = ToolExecutionContext::from_run_context(parent);
+        let context = ToolExecutionContext::from_run_context(parent, _call_id.clone());
         let detached_data = parent.data.detached_child();
         let detached_cancellation = detached_data.cancellation.clone();
         let detached_parent = parent

crates/openhuman-core/src/agent/orchestration/tools/spawn_parallel_agents.rs

@@ -62,6 +62,7 @@ impl ToolDispatch<(), crate::agent::tinyagents::host::OpenHumanRunContext>
     async fn execute(
         &self,
         _state: &(),
+        _call_id: tinyagents_harness::CallId,
         arguments: serde_json::Value,
         _options: ToolCallOptions,
         parent: &RunContext<crate::agent::tinyagents::host::OpenHumanRunContext>,

crates/openhuman-core/src/agent/orchestration/tools/spawn_parallel_agents_tests.rs

@@ -207,6 +207,7 @@ async fn typed_dispatch_uses_the_parent_token_for_fanout_cancellation() {
         dispatch
             .execute(
                 &(),
+                tinyagents_harness::CallId::new("test-call"),
                 json!({
                     "tasks": [
                         { "agent_id": "researcher", "prompt": "one" },
@@ -564,6 +565,7 @@ fn tool_response(name: &str, arguments: serde_json::Value) -> ModelResponse {
             content: Vec::new(),
             tool_calls: vec![ToolCall::new(format!("call-{name}"), name, arguments)],
             usage: None,
+            origin: None,
         },
         usage: None,
         finish_reason: Some("tool_calls".to_string()),

crates/openhuman-core/src/agent/orchestration/tools/spawn_subagent.rs

@@ -59,11 +59,12 @@ impl ToolDispatch<(), crate::agent::tinyagents::host::OpenHumanRunContext>
     async fn execute(
         &self,
         _state: &(),
+        _call_id: tinyagents_harness::CallId,
         arguments: serde_json::Value,
         _options: ToolCallOptions,
         parent: &RunContext<crate::agent::tinyagents::host::OpenHumanRunContext>,
     ) -> anyhow::Result<ToolResult> {
-        let context = ToolExecutionContext::from_run_context(parent);
+        let context = ToolExecutionContext::from_run_context(parent, _call_id.clone());
         SpawnSubagentTool::new()
             .execute_with_live_parent_context(
                 arguments,

crates/openhuman-core/src/agent/orchestration/tools/spawn_worker_thread.rs

@@ -44,11 +44,12 @@ impl ToolDispatch<(), crate::agent::tinyagents::host::OpenHumanRunContext>
     async fn execute(
         &self,
         _state: &(),
+        _call_id: tinyagents_harness::CallId,
         arguments: serde_json::Value,
         _options: ToolCallOptions,
         parent: &RunContext<crate::agent::tinyagents::host::OpenHumanRunContext>,
     ) -> anyhow::Result<ToolResult> {
-        let context = ToolExecutionContext::from_run_context(parent);
+        let context = ToolExecutionContext::from_run_context(parent, _call_id.clone());
         SpawnWorkerThreadTool::new()
             .execute_with_live_parent_context(
                 arguments,

crates/openhuman-core/src/agent/orchestration/tools/steer_subagent.rs

@@ -37,11 +37,12 @@ impl ToolDispatch<(), crate::agent::tinyagents::host::OpenHumanRunContext>
     async fn execute(
         &self,
         _state: &(),
+        _call_id: tinyagents_harness::CallId,
         arguments: serde_json::Value,
         _options: ToolCallOptions,
         parent: &RunContext<crate::agent::tinyagents::host::OpenHumanRunContext>,
     ) -> anyhow::Result<ToolResult> {
-        let context = ToolExecutionContext::from_run_context(parent);
+        let context = ToolExecutionContext::from_run_context(parent, _call_id.clone());
         SteerSubagentTool::new()
             .execute_with_parent_context(arguments, parent.data.parent.clone(), Some(&context))
             .await

crates/openhuman-core/src/agent/orchestration/tools/use_skill_dispatch.rs

@@ -63,7 +63,7 @@ impl ToolDispatch<(), crate::agent::tinyagents::host::OpenHumanRunContext> for U
             }
         }
 
-        let context = ToolExecutionContext::from_run_context(parent);
+        let context = ToolExecutionContext::from_run_context(parent, _call_id.clone());
         self.tool
             .execute_with_context(arguments, options, Some(&context))
             .await

crates/openhuman-core/src/agent/orchestration/tools/wait_subagent.rs

@@ -65,11 +65,12 @@ impl ToolDispatch<(), crate::agent::tinyagents::host::OpenHumanRunContext>
     async fn execute(
         &self,
         _state: &(),
+        _call_id: tinyagents_harness::CallId,
         arguments: serde_json::Value,
         _options: ToolCallOptions,
         parent: &RunContext<crate::agent::tinyagents::host::OpenHumanRunContext>,
     ) -> anyhow::Result<ToolResult> {
-        let context = ToolExecutionContext::from_run_context(parent);
+        let context = ToolExecutionContext::from_run_context(parent, _call_id.clone());
         WaitSubagentTool::new()
             .execute_with_parent_context(arguments, parent.data.parent.clone(), Some(&context))
             .await

crates/openhuman-core/src/agent/orchestration/workflow_runs/ops_tests.rs

@@ -1,5 +1,4 @@
 use super::*;
-use std::collections::BTreeMap;
 use tinyagents_orchestration::workflow::{
     validate_agents, validate_structure, DefinitionError, WorkflowDefinition, WorkflowPhase,
 };