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 { - 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 { - 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, ) -> 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, } -pub(super) fn usage_hint_text( - step_context: &StepContext, - session_source: &SessionSource, -) -> Option { +pub(super) fn usage_hint_text(step_context: &StepContext) -> Option { 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, +) -> 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 {