Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Use captured step settings when spawning subagents (#46075)

rhan-oai800d183e2d0a
diff --git a/codex-rs/core/src/agent/child_config.rs b/codex-rs/core/src/agent/child_config.rs
index 1493378590..ca2f7d9175 100644
--- a/codex-rs/core/src/agent/child_config.rs
+++ b/codex-rs/core/src/agent/child_config.rs
@@ -1,4 +1,4 @@
-//! Prepares child configuration from the invoking turn and requested overrides.
+//! Prepares child configuration from captured step settings and requested overrides.
//!
//! Spawn and reload share live runtime policy; role and model precedence, full-history
//! inheritance, and validation messages remain the same for each multi-agent version.
@@ -7,6 +7,7 @@ use crate::agent::role::DEFAULT_ROLE_NAME;
use crate::agent::role::apply_role_to_config;
use crate::config::Config;
use crate::session::session::Session;
+use crate::session::step_context::StepContext;
use crate::session::turn_context::TurnContext;
use codex_models_manager::manager::RefreshStrategy;
use codex_protocol::config_types::SERVICE_TIER_DEFAULT_REQUEST_VALUE;
@@ -49,16 +50,18 @@ pub(crate) struct PreparedSpawnConfig {
/// Resolves child settings before starting the thread, retaining the invoking tool's precedence.
pub(crate) async fn prepare_agent_spawn_config(
session: &Session,
- turn: &TurnContext,
+ step_context: &StepContext,
options: SpawnConfigOptions<'_>,
) -> Result<PreparedSpawnConfig, String> {
- let mut config = build_agent_spawn_config(&session.get_base_instructions().await, turn)?;
+ let turn = step_context.turn.as_ref();
+ let mut config =
+ build_agent_spawn_config(&session.get_base_instructions().await, step_context)?;
if options.version == SpawnConfigVersion::V1 && options.full_history_fork {
reject_full_fork_agent_type_override(options.role_name)?;
}
apply_requested_spawn_agent_model_overrides(
session,
- turn,
+ step_context,
&mut config,
options.model,
options.reasoning_effort,
@@ -99,15 +102,19 @@ pub(crate) async fn prepare_agent_spawn_config(
/// Builds the base config snapshot for a newly spawned sub-agent.
///
/// The returned config starts from the parent's effective config and then refreshes the
-/// runtime-owned fields carried by the turn, including model selection, reasoning settings,
-/// approval policy, sandbox, and cwd. Role-specific overrides are layered
+/// model selection and reasoning settings captured for the invoking step, plus the turn's
+/// runtime approval policy, sandbox, and cwd. Role-specific overrides are layered
/// after this step; skipping this helper and cloning stale config state directly can send the child
/// agent out with the wrong provider or runtime policy.
pub(crate) fn build_agent_spawn_config(
base_instructions: &BaseInstructions,
- turn: &TurnContext,
+ step_context: &StepContext,
) -> Result<Config, String> {
- let mut config = build_agent_shared_config(turn)?;
+ let mut config = build_agent_shared_config(step_context.turn.as_ref())?;
+ let settings = &step_context.settings;
+ config.model = Some(settings.model_info.slug.clone());
+ config.model_reasoning_effort = settings.effective_reasoning_effort();
+ config.model_reasoning_summary = Some(settings.reasoning_summary);
config.base_instructions = Some(base_instructions.text.clone());
config.base_instructions_provenance = base_instructions.provenance.clone();
Ok(config)
@@ -188,11 +195,12 @@ fn apply_spawn_agent_runtime_overrides(
async fn apply_requested_spawn_agent_model_overrides(
session: &Session,
- turn: &TurnContext,
+ step_context: &StepContext,
config: &mut Config,
requested_model: Option<&str>,
requested_reasoning_effort: Option<ReasoningEffort>,
) -> Result<(), String> {
+ let turn = step_context.turn.as_ref();
let requested_model = requested_model.or(turn.config.agent_default_subagent_model.as_deref());
let requested_reasoning_effort = requested_reasoning_effort
.or_else(|| turn.config.agent_default_subagent_reasoning_effort.clone());
@@ -234,8 +242,8 @@ async fn apply_requested_spawn_agent_model_overrides(
if let Some(reasoning_effort) = requested_reasoning_effort {
validate_spawn_agent_reasoning_effort(
- &turn.model_info().slug,
- &turn.model_info().supported_reasoning_levels,
+ &step_context.settings.model_info.slug,
+ &step_context.settings.model_info.supported_reasoning_levels,
&reasoning_effort,
)?;
config.model_reasoning_effort = Some(reasoning_effort);
diff --git a/codex-rs/core/src/session/multi_agents.rs b/codex-rs/core/src/session/multi_agents.rs
index 4f6a594348..51e43a4dc6 100644
--- a/codex-rs/core/src/session/multi_agents.rs
+++ b/codex-rs/core/src/session/multi_agents.rs
@@ -16,10 +16,7 @@ pub(crate) struct ResolvedMultiAgentV2UsageHints {
pub(crate) subagent: Option<MultiAgentRoleInstructions>,
}
-pub(super) fn usage_hint_text(
- step_context: &StepContext,
- session_source: &SessionSource,
-) -> Option<MultiAgentRoleInstructions> {
+pub(super) fn usage_hint_text(step_context: &StepContext) -> Option<MultiAgentRoleInstructions> {
let turn_context = step_context.turn.as_ref();
if turn_context.multi_agent_version != MultiAgentVersion::V2 {
return None;
@@ -32,7 +29,7 @@ pub(super) fn usage_hint_text(
multi_agent_messages,
!turn_context.config.update_plan_enabled && turn_context.config.model_catalog.is_none(),
);
- match session_source {
+ match &turn_context.session_source {
SessionSource::SubAgent(SubAgentSource::ThreadSpawn { .. }) => snapshot.subagent,
SessionSource::Cli
| SessionSource::VSCode
diff --git a/codex-rs/core/src/session/world_state.rs b/codex-rs/core/src/session/world_state.rs
index 8ea7a66d84..3b3015b6a3 100644
--- a/codex-rs/core/src/session/world_state.rs
+++ b/codex-rs/core/src/session/world_state.rs
@@ -275,9 +275,7 @@ impl Session {
let mut multi_agent_mode = MultiAgentModeState::new(
super::multi_agents::effective_multi_agent_mode(step_context),
);
- if let Some(usage_hint_text) =
- super::multi_agents::usage_hint_text(step_context, &turn_context.session_source)
- {
+ if let Some(usage_hint_text) = super::multi_agents::usage_hint_text(step_context) {
let usage_hint = MultiAgentUsageHintState::new(usage_hint_text);
multi_agent_mode = multi_agent_mode.with_usage_hint(&usage_hint);
world_state.add_section(usage_hint);
diff --git a/codex-rs/core/src/tools/handlers/multi_agents/spawn.rs b/codex-rs/core/src/tools/handlers/multi_agents/spawn.rs
index 73d63fab42..d5fccaa57a 100644
--- a/codex-rs/core/src/tools/handlers/multi_agents/spawn.rs
+++ b/codex-rs/core/src/tools/handlers/multi_agents/spawn.rs
@@ -94,7 +94,7 @@ async fn handle_spawn_agent(
.await;
let prepared = prepare_agent_spawn_config(
&session,
- turn.as_ref(),
+ step_context.as_ref(),
SpawnConfigOptions {
version: SpawnConfigVersion::V1,
full_history_fork: args.fork_context,
diff --git a/codex-rs/core/src/tools/handlers/multi_agents_tests.rs b/codex-rs/core/src/tools/handlers/multi_agents_tests.rs
index 75b57dfe1e..86d80ee720 100644
--- a/codex-rs/core/src/tools/handlers/multi_agents_tests.rs
+++ b/codex-rs/core/src/tools/handlers/multi_agents_tests.rs
@@ -14,6 +14,8 @@ use crate::init_state_db;
use crate::local_agent_graph_store_from_state_db;
use crate::session::step_context::StepContext;
use crate::session::tests::make_session_and_context;
+use crate::session::tests::update_selected_settings_for_test;
+use crate::session::tests::update_turn_settings_for_test;
use crate::session::turn_context::TurnContext;
use crate::session_prefix::format_inter_agent_completion_message;
use crate::thread_manager::thread_store_from_config;
@@ -37,6 +39,7 @@ use codex_models_manager::manager::StaticModelsManager;
use codex_protocol::AgentPath;
use codex_protocol::ThreadId;
use codex_protocol::config_types::ApprovalsReviewer;
+use codex_protocol::config_types::ReasoningSummary;
use codex_protocol::config_types::ServiceTier;
use codex_protocol::config_types::ShellEnvironmentPolicy;
use codex_protocol::items::TurnItem;
@@ -4405,7 +4408,9 @@ async fn tool_handlers_cascade_close_and_resume_and_keep_explicitly_closed_subtr
#[test_case::test_case(false; "inactive_parent")]
#[test_case::test_case(true; "active_parent")]
#[tokio::test]
-async fn build_agent_spawn_config_uses_turn_context_values(parent_enabled: bool) {
+async fn build_agent_spawn_config_uses_captured_step_settings_and_turn_context_values(
+ parent_enabled: bool,
+) {
fn pick_allowed_sandbox_policy(
permissions: &crate::config::Permissions,
base: SandboxPolicy,
@@ -4430,10 +4435,18 @@ async fn build_agent_spawn_config_uses_turn_context_values(parent_enabled: bool)
}
let (_session, mut turn) = make_session_and_context().await;
+ update_turn_settings_for_test(&mut turn, |settings| {
+ update_selected_settings_for_test(settings, |selected| {
+ selected.collaboration_mode.settings.model = "stale-turn-model".to_string();
+ selected.collaboration_mode.settings.reasoning_effort = Some(ReasoningEffort::Low);
+ });
+ Arc::make_mut(&mut settings.model_info).slug = "stale-turn-model".to_string();
+ settings.reasoning_summary = ReasoningSummary::Concise;
+ });
let base_instructions = BaseInstructions {
text: "base".to_string(),
provenance: Some(BaseInstructionsProvenance::Model {
- model: turn.model_info().slug.clone(),
+ model: "captured-step-model".to_string(),
}),
};
turn.developer_instructions = Some("dev".to_string());
@@ -4495,13 +4508,30 @@ async fn build_agent_spawn_config_uses_turn_context_values(parent_enabled: bool)
.get_or_insert_default()
.guidance_message = Some("Parent model's resolved guidance.".to_string());
- let config = build_agent_spawn_config(&base_instructions, &turn).expect("spawn config");
+ let mut step_context = StepContext::for_test(Arc::new(turn));
+ let settings = Arc::make_mut(
+ &mut Arc::get_mut(&mut step_context)
+ .expect("step context should not be shared")
+ .settings,
+ );
+ update_selected_settings_for_test(settings, |selected| {
+ selected.collaboration_mode.settings.model = "captured-step-model".to_string();
+ selected.collaboration_mode.settings.reasoning_effort = None;
+ });
+ let model_info = Arc::make_mut(&mut settings.model_info);
+ model_info.slug = "captured-step-model".to_string();
+ model_info.default_reasoning_level = Some(ReasoningEffort::High);
+ settings.reasoning_summary = ReasoningSummary::Detailed;
+
+ let turn = step_context.turn.as_ref();
+ let config =
+ build_agent_spawn_config(&base_instructions, step_context.as_ref()).expect("spawn config");
expected.base_instructions_provenance = base_instructions.provenance.clone();
expected.base_instructions = Some(base_instructions.text);
- expected.model = Some(turn.model_info().slug.clone());
+ expected.model = Some("captured-step-model".to_string());
expected.model_provider = turn.provider.info().clone();
- expected.model_reasoning_effort = turn.reasoning_effort().cloned();
- expected.model_reasoning_summary = Some(turn.reasoning_summary());
+ expected.model_reasoning_effort = Some(ReasoningEffort::High);
+ expected.model_reasoning_summary = Some(ReasoningSummary::Detailed);
expected.developer_instructions = turn.developer_instructions.clone();
#[allow(deprecated)]
{
diff --git a/codex-rs/core/src/tools/handlers/multi_agents_v2/spawn.rs b/codex-rs/core/src/tools/handlers/multi_agents_v2/spawn.rs
index d7be23ce58..72c5ccd527 100644
--- a/codex-rs/core/src/tools/handlers/multi_agents_v2/spawn.rs
+++ b/codex-rs/core/src/tools/handlers/multi_agents_v2/spawn.rs
@@ -129,7 +129,7 @@ async fn handle_spawn_agent(
let child_depth = next_thread_spawn_depth(&session_source);
let prepared = prepare_agent_spawn_config(
&session,
- turn.as_ref(),
+ step_context.as_ref(),
SpawnConfigOptions {
version: SpawnConfigVersion::V2,
full_history_fork: matches!(fork_mode, Some(SpawnAgentForkMode::FullHistory)),
diff --git a/codex-rs/core/tests/suite/step_settings.rs b/codex-rs/core/tests/suite/step_settings.rs
index afda72bf8f..04938cd41a 100644
--- a/codex-rs/core/tests/suite/step_settings.rs
+++ b/codex-rs/core/tests/suite/step_settings.rs
@@ -109,6 +109,8 @@ use test_case::test_case;
use super::rmcp_client::remote_aware_environment_id;
use super::rmcp_client::remote_aware_stdio_server_bin;
+#[path = "step_settings/agent_spawn_tests.rs"]
+mod agent_spawn;
mod code_mode_notifications;
const MODEL_A: &str = "step-settings-a";
diff --git a/codex-rs/core/tests/suite/step_settings/agent_spawn_tests.rs b/codex-rs/core/tests/suite/step_settings/agent_spawn_tests.rs
new file mode 100644
index 0000000000..db87497641
--- /dev/null
+++ b/codex-rs/core/tests/suite/step_settings/agent_spawn_tests.rs
@@ -0,0 +1,128 @@
+//! Spawned agents inherit the invoking step's model settings after active-turn updates.
+
+use super::*;
+use pretty_assertions::assert_eq;
+use test_case::test_case;
+
+#[test_case(false, None; "v1 inherits captured settings")]
+#[test_case(true, None; "v2 inherits captured settings")]
+#[test_case(false, Some(ReasoningEffort::Medium); "v1 validates effort against captured model")]
+#[test_case(true, Some(ReasoningEffort::Medium); "v2 validates effort against captured model")]
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn spawn_inherits_captured_settings_after_a_turn_update(
+ multi_agent_v2: bool,
+ requested_effort: Option<ReasoningEffort>,
+) -> Result<()> {
+ skip_if_no_network!(Ok(()));
+
+ let server = start_mock_server().await;
+ let mut spawn_arguments = json!({ "message": "Complete the delegated task." });
+ let namespace = if multi_agent_v2 {
+ spawn_arguments["task_name"] = json!("worker");
+ spawn_arguments["fork_turns"] = json!("none");
+ "collaboration"
+ } else {
+ "multi_agent_v1"
+ };
+ if let Some(effort) = &requested_effort {
+ spawn_arguments["reasoning_effort"] = json!(effort);
+ }
+ let response_mock = mount_sse_sequence(
+ &server,
+ vec![
+ paused_response("resp-original", "pause-before-spawn"),
+ sse(vec![
+ ev_response_created("resp-spawn"),
+ ev_function_call_with_namespace(
+ "spawn-worker",
+ namespace,
+ "spawn_agent",
+ &spawn_arguments.to_string(),
+ ),
+ ev_completed("resp-spawn"),
+ ]),
+ sse_completed("resp-first-completion"),
+ sse_completed("resp-second-completion"),
+ ],
+ )
+ .await;
+ // Child completion can trigger another parent request after the parent finishes.
+ mount_sse_once(&server, sse_completed("resp-child-notification")).await;
+ let test = step_settings_test()
+ .with_config(move |config| {
+ config
+ .features
+ .enable(Feature::Collab)
+ .expect("enable collab");
+ if multi_agent_v2 {
+ config
+ .features
+ .enable(Feature::MultiAgentV2)
+ .expect("enable V2");
+ } else {
+ config
+ .features
+ .disable(Feature::MultiAgentV2)
+ .expect("disable V2");
+ }
+ for model in &mut config.model_catalog.as_mut().expect("model catalog").models {
+ // An effort-only override must be validated against B, not the turn's initial A.
+ model.supported_reasoning_levels = if model.slug == MODEL_B {
+ vec![ReasoningEffort::Medium, ReasoningEffort::High]
+ } else {
+ vec![ReasoningEffort::Low]
+ }
+ .into_iter()
+ .map(|effort| ReasoningEffortPreset {
+ description: effort.to_string(),
+ effort,
+ })
+ .collect();
+ model.supports_reasoning_summary_parameter = true;
+ model.use_responses_lite = false;
+ }
+ })
+ .build_with_auto_env(&server)
+ .await?;
+ let mut created_threads = test.thread_manager.subscribe_thread_created();
+ let request = start_paused_turn(&test.codex).await?;
+ apply_turn_settings(
+ &test.codex,
+ &request.turn_id,
+ TurnSettingsUpdate {
+ model: Some(MODEL_B.to_string()),
+ effort: Some(Some(ReasoningEffort::High)),
+ summary: Some(ReasoningSummary::Detailed),
+ ..Default::default()
+ },
+ )
+ .await?;
+ answer_paused_turn(&test.codex, &request.turn_id).await?;
+
+ let child_thread_id = tokio::time::timeout(
+ std::time::Duration::from_secs(/*secs*/ 10),
+ created_threads.recv(),
+ )
+ .await??;
+ let child_thread = test.thread_manager.get_thread(child_thread_id).await?;
+ for thread in [child_thread.as_ref(), test.codex.as_ref()] {
+ wait_for_event(thread, |event| matches!(event, EventMsg::TurnComplete(_))).await;
+ }
+
+ let expected_effort = requested_effort.unwrap_or(ReasoningEffort::High);
+ let requests = response_mock.requests();
+ let child_request = requests
+ .iter()
+ .find(|request| request.header("thread-id") == Some(child_thread_id.to_string()))
+ .expect("child should make a model request");
+ assert_eq!(
+ request_settings(child_request),
+ json!({
+ "model": MODEL_B,
+ "reasoning": { "effort": expected_effort, "summary": "detailed" },
+ "service_tier": null,
+ })
+ );
+
+ Ok(())
+}
diff --git a/codex-rs/core/tests/suite/subagent_notifications.rs b/codex-rs/core/tests/suite/subagent_notifications.rs
index bbd7113cf0..2139d75882 100644
--- a/codex-rs/core/tests/suite/subagent_notifications.rs
+++ b/codex-rs/core/tests/suite/subagent_notifications.rs
@@ -67,6 +67,7 @@ use tokio::time::Instant;
use tokio::time::sleep;
use tokio::time::timeout;
use tracing::Level;
+use tracing_subscriber::layer::SubscriberExt;
use tracing_test::internal::MockWriter;
use wiremock::Mock;
use wiremock::MockServer;
@@ -2212,6 +2213,11 @@ async fn multi_agent_v2_spawn_sends_agent_message_to_child(
.with_writer(MockWriter::new(output))
.finish();
let _guard = tracing::subscriber::set_default(subscriber);
+ // Keep two dispatchers alive so a parallel test that first registers a communication
+ // callsite without a subscriber cannot globally disable it for our capturing subscriber.
+ let _parallel_dispatch = tracing::Dispatch::new(
+ tracing_subscriber::registry().with(tracing_subscriber::filter::LevelFilter::OFF),
+ );
let server = start_mock_server().await;
let message = if plaintext {