Lightweight coding agent that runs in your terminal
Rust
Enable dynamic tool inheritance for fresh V2 subagents (#50082)
ke-oaie4e33a56b073
diff --git a/codex-rs/core/config.schema.json b/codex-rs/core/config.schema.jsonindex 570f0319bd..6f6a95837a 100644--- a/codex-rs/core/config.schema.json+++ b/codex-rs/core/config.schema.json@@ -1001,6 +1001,9 @@"multi_agent_v2": {"$ref": "#/definitions/FeatureToml_for_MultiAgentV2ConfigToml"},+ "multi_agent_v2_dynamic_tools": {+ "type": "boolean"+ },"network_proxy": {"$ref": "#/definitions/FeatureToml_for_NetworkProxyConfigToml"},@@ -7094,6 +7097,9 @@"multi_agent_v2": {"$ref": "#/definitions/FeatureToml_for_MultiAgentV2ConfigToml"},+ "multi_agent_v2_dynamic_tools": {+ "type": "boolean"+ },"network_proxy": {"$ref": "#/definitions/FeatureToml_for_NetworkProxyConfigToml"},diff --git a/codex-rs/core/src/agent/control/residency_tests.rs b/codex-rs/core/src/agent/control/residency_tests.rsindex 9c850dc601..b23f02ff71 100644--- a/codex-rs/core/src/agent/control/residency_tests.rs+++ b/codex-rs/core/src/agent/control/residency_tests.rs@@ -174,6 +174,7 @@ async fn spawn_v2_subagent(control.clone(),SessionSource::SubAgent(SubAgentSource::Other(label.to_string())),/*history_mode*/ None,+ /*dynamic_tools*/ Vec::new(),Some(parent_thread_id),/*forked_from_thread_id*/ None,Some(ThreadSource::Subagent),diff --git a/codex-rs/core/src/agent/control/spawn.rs b/codex-rs/core/src/agent/control/spawn.rsindex e832dbddf7..404845d757 100644--- a/codex-rs/core/src/agent/control/spawn.rs+++ b/codex-rs/core/src/agent/control/spawn.rs@@ -25,6 +25,7 @@ use crate::session::multi_agents::resolve_usage_hints;use codex_context_fragments::set_annotated_content;use codex_context_fragments::to_annotated_content;use codex_extension_api::ExtensionDataInit;+use codex_features::Feature;use codex_history::ResponseItemEnvelope;use codex_prompts::ResolvedModelMessages;use codex_protocol::intersect_effective_permission_profiles;@@ -739,16 +740,25 @@ impl LocalAgentControl {.await?}(Some(session_source), None, inheritance) => {- let history_mode = if let Some(parent_thread_id) = options.parent_thread_id+ let (history_mode, dynamic_tools) = if let Some(parent_thread_id) =+ options.parent_thread_id&& let Ok(parent_thread) = state.get_thread(parent_thread_id).await{- matches!(+ let history_mode = matches!(parent_thread.config_snapshot().await.history_mode,ThreadHistoryMode::Paginated)- .then_some(ThreadHistoryMode::Paginated)+ .then_some(ThreadHistoryMode::Paginated);+ let dynamic_tools = if multi_agent_version == MultiAgentVersion::V2+ && config.features.enabled(Feature::MultiAgentV2DynamicTools)+ {+ parent_thread.session.dynamic_tools().await+ } else {+ Vec::new()+ };+ (history_mode, dynamic_tools)} else {- None+ (None, Vec::new())};let environments = options.environments@@ -760,6 +770,7 @@ impl LocalAgentControl {self.clone(),session_source,history_mode,+ dynamic_tools,options.parent_thread_id,/*forked_from_thread_id*/ None,/*thread_source*/ Some(ThreadSource::Subagent),diff --git a/codex-rs/core/src/agent/control_tests.rs b/codex-rs/core/src/agent/control_tests.rsindex 669236dc02..de1291c91e 100644--- a/codex-rs/core/src/agent/control_tests.rs+++ b/codex-rs/core/src/agent/control_tests.rs@@ -1928,10 +1928,52 @@ async fn spawn_agent_fork_from_paginated_parent_uses_model_context_prefix() {.expect("parent shutdown should submit");}+#[test_case::test_case(MultiAgentVersion::V1, true, false; "v1_gate_enabled")]+#[test_case::test_case(MultiAgentVersion::V2, false, false; "v2_gate_disabled")]+#[test_case::test_case(MultiAgentVersion::V2, true, true; "v2_gate_enabled")]#[tokio::test]-async fn spawn_agent_without_fork_from_paginated_parent_stays_fresh_and_paginated() {- let harness = AgentControlHarness::new().await;- let (parent_thread_id, parent_thread) = harness.start_paginated_thread().await;+async fn spawn_agent_without_fork_from_paginated_parent_stays_fresh_and_paginated(+ multi_agent_version: MultiAgentVersion,+ dynamic_tools_enabled: bool,+ inherits_dynamic_tools: bool,+) {+ let mut harness = AgentControlHarness::new().await;+ let features = &mut harness.config.features;+ features+ .disable(Feature::MultiAgentV2)+ .expect("disable raw v2 feature");+ if dynamic_tools_enabled {+ features.enable(Feature::MultiAgentV2DynamicTools)+ } else {+ features.disable(Feature::MultiAgentV2DynamicTools)+ }+ .expect("configure dynamic tool inheritance");+ let dynamic_tools = vec![codex_protocol::dynamic_tools::DynamicToolSpec::Function(+ codex_protocol::dynamic_tools::DynamicToolFunctionSpec {+ name: "echo".to_string(),+ description: "Return the supplied message.".to_string(),+ input_schema: serde_json::json!({"type": "object", "properties": {"message": {"type": "string"}}}),+ defer_loading: false,+ },+ )];+ let parent = harness+ .manager+ .start_thread(StartThreadOptions {+ history_mode: Some(ThreadHistoryMode::Paginated),+ environments: Some(Vec::new()),+ dynamic_tools: dynamic_tools.clone(),+ ..StartThreadOptions::new(harness.config.clone())+ })+ .await+ .expect("start parent with dynamic tools");+ let parent_thread_id = parent.thread_id;+ let parent_thread = parent.thread;+ assert_eq!(+ parent_thread+ .session+ .set_multi_agent_version_if_unset(multi_agent_version),+ multi_agent_version+ );parent_thread.inject_response_items(vec![user_message("parent-only context")]).await@@ -1951,6 +1993,15 @@ async fn spawn_agent_without_fork_from_paginated_parent_stays_fresh_and_paginate.get_thread(child_thread_id).await.expect("child thread should be registered");+ let expected_dynamic_tools = if inherits_dynamic_tools {+ dynamic_tools+ } else {+ Vec::new()+ };+ assert_eq!(+ child_thread.session.dynamic_tools().await,+ expected_dynamic_tools+ );assert!(!history_contains_text(child_thread.session.clone_history().await.raw_items(),@@ -1972,6 +2023,10 @@ async fn spawn_agent_without_fork_from_paginated_parent_stays_fresh_and_paginate.expect("read child session metadata");assert_eq!(meta.meta.history_mode, ThreadHistoryMode::Paginated);assert_eq!(meta.meta.subagent_history_start_ordinal, None);+ assert_eq!(+ meta.meta.dynamic_tools.unwrap_or_default(),+ expected_dynamic_tools+ );let _ = harness.controldiff --git a/codex-rs/core/src/session/session.rs b/codex-rs/core/src/session/session.rsindex 9452040178..d4e6b96bc8 100644--- a/codex-rs/core/src/session/session.rs+++ b/codex-rs/core/src/session/session.rs@@ -671,6 +671,11 @@ impl Session {state.session_configuration.originator.clone()}+ pub(crate) async fn dynamic_tools(&self) -> Vec<DynamicToolSpec> {+ let state = self.state.lock().await;+ state.session_configuration.dynamic_tools.clone()+ }+pub(crate) async fn responses_metadata(&self,step_context: &StepContext,diff --git a/codex-rs/core/src/thread_manager.rs b/codex-rs/core/src/thread_manager.rsindex bd99b98141..b7d3318e28 100644--- a/codex-rs/core/src/thread_manager.rs+++ b/codex-rs/core/src/thread_manager.rs@@ -1912,6 +1912,7 @@ impl ThreadManagerState {agent_control,self.session_source.clone(),/*history_mode*/ None,+ /*dynamic_tools*/ Vec::new(),/*parent_thread_id*/ None,/*forked_from_thread_id*/ None,/*thread_source*/ None,@@ -1930,6 +1931,7 @@ impl ThreadManagerState {agent_control: LocalAgentControl,session_source: SessionSource,history_mode: Option<ThreadHistoryMode>,+ dynamic_tools: Vec<codex_protocol::dynamic_tools::DynamicToolSpec>,parent_thread_id: Option<ThreadId>,forked_from_thread_id: Option<ThreadId>,thread_source: Option<ThreadSource>,@@ -1946,6 +1948,7 @@ impl ThreadManagerState {metrics_service_name,environments,client_mcp_extensions,+ dynamic_tools,..StartThreadOptions::new(config)};let mut request =diff --git a/codex-rs/core/tests/suite/mod.rs b/codex-rs/core/tests/suite/mod.rsindex aedd5de7ed..d0f0f0c8a8 100644--- a/codex-rs/core/tests/suite/mod.rs+++ b/codex-rs/core/tests/suite/mod.rs@@ -209,6 +209,7 @@ mod step_settings;mod step_settings_snapshots;mod stream_error_allows_next_turn;mod stream_no_completed;+mod subagent_dynamic_tools;mod subagent_notifications;mod subagent_service_tier;mod token_budget;diff --git a/codex-rs/core/tests/suite/subagent_dynamic_tools.rs b/codex-rs/core/tests/suite/subagent_dynamic_tools.rsnew file mode 100644index 0000000000..48cfbebba5--- /dev/null+++ b/codex-rs/core/tests/suite/subagent_dynamic_tools.rs@@ -0,0 +1,211 @@+//! Verifies fresh V2 subagents can use inherited client tools when enabled.++use anyhow::Result;+use codex_core::StartThreadOptions;+use codex_features::Feature;+use codex_protocol::dynamic_tools::DynamicToolCallOutputContentItem;+use codex_protocol::dynamic_tools::DynamicToolFunctionSpec;+use codex_protocol::dynamic_tools::DynamicToolResponse;+use codex_protocol::dynamic_tools::DynamicToolSpec;+use codex_protocol::protocol::EventMsg;+use codex_protocol::protocol::Op;+use core_test_support::responses::ev_assistant_message;+use core_test_support::responses::ev_completed;+use core_test_support::responses::ev_function_call;+use core_test_support::responses::ev_function_call_with_namespace;+use core_test_support::responses::ev_response_created;+use core_test_support::responses::mount_sse_once_match;+use core_test_support::responses::sse;+use core_test_support::responses::start_mock_server;+use core_test_support::skip_if_no_network;+use core_test_support::test_codex::test_codex;+use core_test_support::wait_for_event;+use core_test_support::wait_for_event_match;+use pretty_assertions::assert_eq;+use serde_json::json;+use std::time::Duration;++const ROOT_PROMPT: &str = "Spawn the echo worker.";+const CHILD_PROMPT: &str = "Call client_echo with the message child-input.";+const SPAWN_CALL_ID: &str = "spawn-echo-worker";+const ECHO_CALL_ID: &str = "child-echo-call";+const ECHO_RESULT: &str = "distinctive-client-echo-result-7391";++fn body_contains(request: &wiremock::Request, text: &str) -> bool {+ String::from_utf8_lossy(&request.body).contains(text)+}++#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn fresh_v2_subagent_can_call_parent_dynamic_tool_when_enabled() -> Result<()> {+ skip_if_no_network!(Ok(()));++ let server = start_mock_server().await;+ let spawn_args =+ json!({"message": CHILD_PROMPT, "task_name": "echo_worker", "fork_turns": "none"});+ mount_sse_once_match(+ &server,+ |request: &wiremock::Request| {+ body_contains(request, ROOT_PROMPT) && !body_contains(request, SPAWN_CALL_ID)+ },+ sse(vec![+ ev_response_created("root-spawn"),+ ev_function_call_with_namespace(+ SPAWN_CALL_ID,+ "collaboration",+ "spawn_agent",+ &spawn_args.to_string(),+ ),+ ev_completed("root-spawn"),+ ]),+ )+ .await;+ mount_sse_once_match(+ &server,+ |request: &wiremock::Request| body_contains(request, SPAWN_CALL_ID),+ sse(vec![+ ev_response_created("root-finished"),+ ev_assistant_message("root-message", "The echo worker has started."),+ ev_completed("root-finished"),+ ]),+ )+ .await;+ let child_request = mount_sse_once_match(+ &server,+ |request: &wiremock::Request| {+ body_contains(request, CHILD_PROMPT)+ && !body_contains(request, SPAWN_CALL_ID)+ && !body_contains(request, ECHO_CALL_ID)+ },+ sse(vec![+ ev_response_created("child-call"),+ ev_function_call(+ ECHO_CALL_ID,+ "client_echo",+ &json!({"message": "child-input"}).to_string(),+ ),+ ev_completed("child-call"),+ ]),+ )+ .await;+ let child_continuation = mount_sse_once_match(+ &server,+ |request: &wiremock::Request| body_contains(request, ECHO_CALL_ID),+ sse(vec![+ ev_response_created("child-finished"),+ ev_assistant_message("child-message", "The client echo result was received."),+ ev_completed("child-finished"),+ ]),+ )+ .await;++ let mut test = test_codex()+ .with_config(|config| {+ for feature in [+ Feature::Collab,+ Feature::MultiAgentV2,+ Feature::MultiAgentV2DynamicTools,+ ] {+ config.features.enable(feature).expect("enable multi-agent");+ }+ config+ .features+ .disable(Feature::EnableRequestCompression)+ .expect("disable request compression for mock matching");+ })+ .build_with_auto_env(&server)+ .await?;+ let tool = DynamicToolFunctionSpec {+ name: "client_echo".to_string(),+ description: "Echo the supplied message through the client.".to_string(),+ input_schema: json!({+ "type": "object",+ "properties": {"message": {"type": "string"}},+ "required": ["message"],+ "additionalProperties": false,+ }),+ defer_loading: false,+ };+ test.codex.shutdown_and_wait().await?;+ let root = test+ .thread_manager+ .start_thread(StartThreadOptions {+ dynamic_tools: vec![DynamicToolSpec::Function(tool.clone())],+ environments: Some(vec![test.executor_environment().selection().clone()]),+ ..StartThreadOptions::new(test.config.clone())+ })+ .await?;+ test.codex = root.thread;+ test.session_configured = root.session_configured;+ let mut created_threads = test.thread_manager.subscribe_thread_created();+ test.submit_turn(ROOT_PROMPT).await?;+ let child_id = tokio::time::timeout(Duration::from_secs(10), created_threads.recv()).await??;+ let child = test.thread_manager.get_thread(child_id).await?;+ let call = wait_for_event_match(&child, |event| match event {+ EventMsg::DynamicToolCallRequest(call) => Some(call.clone()),+ EventMsg::Error(error) => panic!("child failed before calling echo: {}", error.message),+ EventMsg::TurnComplete(completed) => {+ panic!("child completed without calling echo: {completed:?}")+ }+ _ => None,+ })+ .await;+ assert_eq!(+ (+ call.call_id.as_str(),+ call.namespace.as_deref(),+ call.tool.as_str(),+ &call.arguments+ ),+ (+ ECHO_CALL_ID,+ None,+ "client_echo",+ &json!({"message": "child-input"})+ )+ );++ let expected_tool = json!({+ "type": "function",+ "name": tool.name,+ "description": tool.description,+ "parameters": tool.input_schema,+ "strict": false,+ });+ let child_request = child_request.single_request();+ assert!(+ !child_request+ .message_input_texts("user")+ .iter()+ .any(|text| text.contains(ROOT_PROMPT))+ );+ let body = child_request.body_json();+ let echo_tools: Vec<_> = body["tools"]+ .as_array()+ .expect("model tools")+ .iter()+ .filter(|tool| tool["name"] == "client_echo")+ .collect();+ assert_eq!(echo_tools, vec![&expected_tool]);++ child+ .submit(Op::DynamicToolResponse {+ id: call.call_id,+ response: DynamicToolResponse {+ content_items: vec![DynamicToolCallOutputContentItem::InputText {+ text: ECHO_RESULT.to_string(),+ }],+ success: true,+ },+ })+ .await?;+ wait_for_event(&child, |event| matches!(event, EventMsg::TurnComplete(_))).await;+ assert_eq!(+ child_continuation+ .single_request()+ .function_call_output_content_and_success(ECHO_CALL_ID),+ Some((Some(ECHO_RESULT.to_string()), None))+ );+ child.shutdown_and_wait().await?;+ test.codex.shutdown_and_wait().await?;+ Ok(())+}diff --git a/codex-rs/features/src/lib.rs b/codex-rs/features/src/lib.rsindex 519df967a8..620a118037 100644--- a/codex-rs/features/src/lib.rs+++ b/codex-rs/features/src/lib.rs@@ -213,6 +213,8 @@ pub enum Feature {MultiAgentV2,/// Keep spawn model choices in append-only context instead of tool descriptions.ModelCatalogInContext,+ /// Inherit client-defined dynamic tools in fresh V2 subagents.+ MultiAgentV2DynamicTools,/// Keep sampling through reasoning and commentary boundaries when agent mail arrives./// Pending mail is delivered at the next normal input boundary instead.DeferMailboxPreemption,@@ -1378,6 +1380,12 @@ pub const FEATURES: &[FeatureSpec] = &[stage: Stage::UnderDevelopment,default_enabled: false,},+ FeatureSpec {+ id: Feature::MultiAgentV2DynamicTools,+ key: "multi_agent_v2_dynamic_tools",+ stage: Stage::UnderDevelopment,+ default_enabled: false,+ },FeatureSpec {id: Feature::DeferMailboxPreemption,key: "defer_mailbox_preemption",diff --git a/codex-rs/tui/src/bottom_pane/chat_composer/vim_history_tests.rs b/codex-rs/tui/src/bottom_pane/chat_composer/vim_history_tests.rsindex f3a47b6754..6ab2ea930b 100644--- a/codex-rs/tui/src/bottom_pane/chat_composer/vim_history_tests.rs+++ b/codex-rs/tui/src/bottom_pane/chat_composer/vim_history_tests.rs@@ -163,7 +163,7 @@ fn recovered_answers_undo_as_one_vim_edit() {let mut composer = vim_composer(command);let before = composer.draft_snapshot();composer.append_recovered_drafts("answer");- assert_eq!(composer.current_text(), format!("\\{command}\nanswer"));+ assert_eq!(composer.current_text(), format!("\\{command}\n\nanswer"));keys(&mut composer, "u");assert_eq!(composer.draft_snapshot(), before);}@@ -171,7 +171,7 @@ fn recovered_answers_undo_as_one_vim_edit() {composer.draft.is_bash_mode = true;let before = composer.draft_snapshot();composer.append_recovered_drafts("answer");- assert_eq!(composer.current_text(), "\\!echo\nanswer");+ assert_eq!(composer.current_text(), "\\!echo\n\nanswer");keys(&mut composer, "u");assert_eq!(composer.draft_snapshot(), before);snapshot_composer_state_with_width(diff --git a/codex-rs/tui/src/chatwidget/tests/question_turn_end_tests.rs b/codex-rs/tui/src/chatwidget/tests/question_turn_end_tests.rsindex 660a76a2fc..074aca193a 100644--- a/codex-rs/tui/src/chatwidget/tests/question_turn_end_tests.rs+++ b/codex-rs/tui/src/chatwidget/tests/question_turn_end_tests.rs@@ -36,14 +36,14 @@ async fn question_turn_end_escapes_command_drafts_before_submission() {chat.thread_id = Some(ThreadId::new());chat.show_welcome_banner = false;handle_turn_started(&mut chat, "turn");- questions(&mut chat, "question");+ questions(&mut chat, "question", "Which way?");chat.handle_key_event(KeyEvent::new(KeyCode::Up, KeyModifiers::ALT));chat.bottom_pane.handle_paste("answer".into());chat.bottom_pane.set_composer_text(draft.into(), Vec::new(), Vec::new());handle_turn_completed(&mut chat, "turn", /*duration_ms*/ None);- let expected = format!("{escaped}\nanswer");+ let expected = format!("{escaped}\n\n> Which way?\n\nanswer");let submitted_text = expected.trim().to_string();assert_eq!(chat.bottom_pane.composer_text(), expected);if draft == "!echo partial" && !queued {diff --git a/codex-rs/tui/src/chatwidget/tests/snapshots/codex_tui__chatwidget__tests__question_turn_end_tests__question_turn_end_escaped_shell_command.snap b/codex-rs/tui/src/chatwidget/tests/snapshots/codex_tui__chatwidget__tests__question_turn_end_tests__question_turn_end_escaped_shell_command.snapindex a44057e781..4361995b47 100644--- a/codex-rs/tui/src/chatwidget/tests/snapshots/codex_tui__chatwidget__tests__question_turn_end_tests__question_turn_end_escaped_shell_command.snap+++ b/codex-rs/tui/src/chatwidget/tests/snapshots/codex_tui__chatwidget__tests__question_turn_end_tests__question_turn_end_escaped_shell_command.snap@@ -1,8 +1,12 @@---source: tui/src/chatwidget/tests/question_turn_end_tests.rs+assertion_line: 50expression: "normalize_snapshot_paths(render_bottom_popup(&chat, 80))"---› \!echo partial++ > Which way?+answerGPT-5.6-Sol default · /tmp/project