Skip to content

armgit / codex

Public Imported from GitHub
0

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.json
index 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.rs
index 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.rs
index 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.rs
index 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
.control
diff --git a/codex-rs/core/src/session/session.rs b/codex-rs/core/src/session/session.rs
index 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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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.snap
index 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: 50
expression: "normalize_snapshot_paths(render_bottom_popup(&chat, 80))"
---
› \!echo partial
+
+ > Which way?
+
answer
GPT-5.6-Sol default · /tmp/project