Lightweight coding agent that runs in your terminal
Rust
Capture host-supplied extension data for each turn (#49846)
sayan-oai408f48ce0c87
diff --git a/codex-rs/app-server/src/request_processors/thread_processor_tests.rs b/codex-rs/app-server/src/request_processors/thread_processor_tests.rsindex 237c58e031..102696601d 100644--- a/codex-rs/app-server/src/request_processors/thread_processor_tests.rs+++ b/codex-rs/app-server/src/request_processors/thread_processor_tests.rs@@ -682,6 +682,7 @@ mod thread_processor_behavior_tests {initial_turns_page: None,};let config_snapshot = ThreadConfigSnapshot {+ turn_extension_init: Default::default(),disabled_plugin_ids: Vec::new(),model: "gpt-5".to_string(),model_provider_id: "openai".to_string(),diff --git a/codex-rs/app-server/src/request_processors/turn_processor.rs b/codex-rs/app-server/src/request_processors/turn_processor.rsindex e42e53de1f..ab37525c5d 100644--- a/codex-rs/app-server/src/request_processors/turn_processor.rs+++ b/codex-rs/app-server/src/request_processors/turn_processor.rs@@ -874,6 +874,7 @@ impl TurnRequestProcessor {if has_any_overrides {thread.preview_thread_settings_overrides(CodexThreadSettingsOverrides {+ turn_extension_init: None,disabled_plugin_ids: disabled_plugin_ids.clone(),environments: environments.clone(),runtime_workspace_roots: runtime_workspace_roots.clone(),diff --git a/codex-rs/core-api/src/lib.rs b/codex-rs/core-api/src/lib.rsindex 8ac16704a7..3e0392f2ed 100644--- a/codex-rs/core-api/src/lib.rs+++ b/codex-rs/core-api/src/lib.rs@@ -58,6 +58,7 @@ pub use codex_core::TurnInputRequest;pub use codex_core::TurnInputSubmission;pub use codex_core::TurnStartOptions;pub use codex_core::WaitForEnvironmentToolConfig;+pub use codex_core::WithTurnExtensionData;pub use codex_core::build_models_manager;pub use codex_core::config::Config;pub use codex_core::config::Constrained;diff --git a/codex-rs/core/src/codex_delegate.rs b/codex-rs/core/src/codex_delegate.rsindex 04e5d14e00..8b109f9da4 100644--- a/codex-rs/core/src/codex_delegate.rs+++ b/codex-rs/core/src/codex_delegate.rs@@ -133,6 +133,7 @@ pub(crate) async fn run_codex_thread_interactive(parent_trace: None,environment_selections: parent_environments.to_selections(),thread_extension_init,+ turn_extension_init: Default::default(),client_mcp_extensions: parent_session.services.client_mcp_extensions.clone(),reserved_thread_id: None,analytics_events_client: Some(parent_session.services.analytics_events_client.clone()),@@ -280,6 +281,7 @@ pub(crate) async fn run_codex_thread_one_shot(.send(Submission {id: "shutdown".to_string(),op: Op::Shutdown {},+ turn_extension_init: None,trace: None,parent_turn_id: None,root_turn_id: None,diff --git a/codex-rs/core/src/codex_delegate_tests.rs b/codex-rs/core/src/codex_delegate_tests.rsindex 3923eb4fd5..d382a26362 100644--- a/codex-rs/core/src/codex_delegate_tests.rs+++ b/codex-rs/core/src/codex_delegate_tests.rs@@ -148,6 +148,7 @@ async fn forward_ops_preserves_submission_trace_context() {let submission = Submission {id: "sub-1".to_string(),op: Op::Interrupt,+ turn_extension_init: None,trace: Some(codex_protocol::protocol::W3cTraceContext {traceparent: Some("00-1234567890abcdef1234567890abcdef-1234567890abcdef-01".to_string(),diff --git a/codex-rs/core/src/codex_thread.rs b/codex-rs/core/src/codex_thread.rsindex 7a00247221..c0483af508 100644--- a/codex-rs/core/src/codex_thread.rs+++ b/codex-rs/core/src/codex_thread.rs@@ -1,3 +1,4 @@+use crate::WithTurnExtensionData;use crate::agent::AgentStatus;use crate::agent::api::AgentControl;use crate::config::ConstraintResult;@@ -71,6 +72,7 @@ use codex_utils_absolute_path::AbsolutePathBuf;use codex_utils_path_uri::LegacyAppPathString;use codex_utils_path_uri::PathUri;use rmcp::model::ReadResourceRequestParams;+use std::any::Any;use std::path::PathBuf;use std::sync::Arc;use tokio::sync::Mutex;@@ -85,6 +87,8 @@ static LIVE_THREADS: Gauge = Gauge::new("core.threads.live");#[derive(Clone, Debug)]pub struct ThreadConfigSnapshot {+ /// Host data inherited by future turns; not included in persisted settings.+ pub turn_extension_init: codex_extension_api::ExtensionDataInit,pub model: String,pub model_provider_id: String,pub service_tier: Option<String>,@@ -143,6 +147,8 @@ impl ThreadConfigSnapshot {/// Thread settings overrides that app-server validates before starting a turn.#[derive(Clone, Default)]pub struct CodexThreadSettingsOverrides {+ /// Replaces the data captured by future turns. Omission preserves it.+ pub turn_extension_init: Option<codex_extension_api::ExtensionDataInit>,pub environments: Option<TurnEnvironmentSelections>,pub runtime_workspace_roots: Option<Vec<AbsolutePathBuf>>,pub profile_workspace_roots: Option<Vec<ProfileWorkspaceRoot>>,@@ -285,6 +291,19 @@ impl CodexThread {&self.session.services.thread_extension_data}+ /// Returns data captured by the named running turn, not newer thread settings.+ pub async fn current_turn_extension_data<T>(&self, expected_turn_id: &str) -> Option<Arc<T>>+ where+ T: Any + Send + Sync,+ {+ let active = self.session.active_turn.lock().await;+ let task = active.as_ref()?.task.as_ref()?;+ if task.turn_context.sub_id != expected_turn_id || task.cancellation_token.is_cancelled() {+ return None;+ }+ task.turn_context.extension_data.get::<T>()+ }+pub async fn shutdown_and_wait(&self) -> CodexResult<()> {self.io.shutdown_and_wait().await}@@ -377,7 +396,7 @@ impl CodexThread {/// User input and named standalone function-call outputs are accepted.pub async fn start_or_steer_turn(&self,- request: TurnInputRequest,+ request: impl Into<WithTurnExtensionData<TurnInputRequest>>,) -> CodexResult<TurnInputSubmission> {self.submit_turn_input_with_mode(request, TurnInputMode::StartOrSteer).await@@ -389,7 +408,7 @@ impl CodexThread {/// work cannot start.pub async fn start_turn_if_idle(&self,- request: TurnInputRequest,+ request: impl Into<WithTurnExtensionData<TurnInputRequest>>,) -> CodexResult<StartIfIdleSubmission> {match self.submit_turn_input_with_mode(request, TurnInputMode::StartIfIdle)@@ -412,7 +431,7 @@ impl CodexThread {/// The input must be a response item; it is never treated as user authorization.pub async fn continue_turn_if_idle(&self,- request: TurnInputRequest,+ request: impl Into<WithTurnExtensionData<TurnInputRequest>>,expected_previous_turn_id: String,) -> CodexResult<TurnInputSubmission> {self.submit_turn_input_with_mode(@@ -430,10 +449,14 @@ impl CodexThread {/// already recorded for the interrupted turn.pub async fn recover_turn_if_idle(&self,- request: RecoverTurnRequest,+ request: impl Into<WithTurnExtensionData<RecoverTurnRequest>>,) -> CodexResult<StartIfIdleSubmission> {self.ensure_execution_capacity_for_turn_start(self.session.services.agent_control.as_ref()).await?;+ let WithTurnExtensionData {+ request,+ turn_extension_init,+ } = request.into();let RecoverTurnRequest {turn_id,thread_settings,@@ -453,7 +476,13 @@ impl CodexThread {};match self.io- .submit_recover_turn(thread_settings, start_options, trace, turn_id)+ .submit_recover_turn(+ thread_settings,+ start_options,+ trace,+ turn_id,+ turn_extension_init,+ ).await?{TurnInputSubmission::Started { turn_id } => {@@ -494,6 +523,7 @@ impl CodexThread {.send(Submission {id: new_submission_id(),op: Op::SuspendTurnAndShutdown { reply },+ turn_extension_init: None,trace: current_span_w3c_trace_context(),parent_turn_id: None,root_turn_id: None,@@ -513,7 +543,7 @@ impl CodexThread {/// Steers only if `expected_turn_id` is still the active regular turn.pub async fn steer_turn(&self,- request: TurnInputRequest,+ request: impl Into<WithTurnExtensionData<TurnInputRequest>>,expected_turn_id: String,) -> CodexResult<SteerSubmission> {match self@@ -532,7 +562,7 @@ impl CodexThread {async fn submit_turn_input_with_mode(&self,- request: TurnInputRequest,+ request: impl Into<WithTurnExtensionData<TurnInputRequest>>,mode: TurnInputMode,) -> CodexResult<TurnInputSubmission> {if !matches!(mode, TurnInputMode::Steer { .. }) {@@ -631,14 +661,22 @@ impl CodexThread {/// Rejections are returned to the caller instead of emitted as thread errors.pub async fn update_thread_settings(&self,- thread_settings: ThreadSettingsOverrides,+ thread_settings: impl Into<WithTurnExtensionData<ThreadSettingsOverrides>>,) -> CodexResult<()> {let (reply, result) = oneshot::channel();- self.submit(Op::ThreadSettings {- thread_settings,- reply: Some(reply),- })- .await?;+ let WithTurnExtensionData {+ request: thread_settings,+ turn_extension_init,+ } = thread_settings.into();+ self.io+ .submit(WithTurnExtensionData {+ request: Op::ThreadSettings {+ thread_settings,+ reply: Some(reply),+ },+ turn_extension_init,+ })+ .await?;result.await.unwrap_or(Err(CodexErr::InternalAgentDied))}@@ -663,6 +701,7 @@ impl CodexThread {fn thread_settings_update(overrides: CodexThreadSettingsOverrides) -> SessionSettingsUpdate {let CodexThreadSettingsOverrides {+ turn_extension_init,environments,runtime_workspace_roots,profile_workspace_roots,@@ -681,6 +720,7 @@ impl CodexThread {disabled_plugin_ids,} = overrides;SessionSettingsUpdate {+ turn_extension_init,step_settings: StepSettingsUpdate {model,effort,diff --git a/codex-rs/core/src/lib.rs b/codex-rs/core/src/lib.rsindex 25edb95267..e7753db4e5 100644--- a/codex-rs/core/src/lib.rs+++ b/codex-rs/core/src/lib.rs@@ -31,6 +31,8 @@ pub use codex_protocol::turn_input::TurnStartOptions;pub use responses_metadata::CodexResponsesMetadata;pub use turn_metadata::detached_memory_responses_metadata;mod codex_thread;+mod turn_extension_data;+pub use turn_extension_data::WithTurnExtensionData;mod compact_model_fallback;mod compact_remote_history;mod compact_remote_v2;diff --git a/codex-rs/core/src/session/handlers.rs b/codex-rs/core/src/session/handlers.rsindex a30c195427..17af075cdf 100644--- a/codex-rs/core/src/session/handlers.rs+++ b/codex-rs/core/src/session/handlers.rs@@ -1,4 +1,5 @@use super::Submission;+use crate::WithTurnExtensionData;use crate::realtime_conversation::handle_audio as handle_realtime_conversation_audio;use crate::realtime_conversation::handle_close as handle_realtime_conversation_close;use crate::realtime_conversation::handle_speech as handle_realtime_conversation_speech;@@ -500,7 +501,11 @@ pub(super) async fn submission_loop(mode,reply,} => {- let result = turn_input::handle(&sess, *request, mode, sub.id.clone()).await;+ let request = WithTurnExtensionData {+ request: *request,+ turn_extension_init: sub.turn_extension_init,+ };+ let result = turn_input::handle(&sess, request, mode, sub.id.clone()).await;let _ = reply.send(result);false}@@ -511,7 +516,10 @@ pub(super) async fn submission_loop(} => {let result = turn_input::handle_recovery(&sess,- thread_settings,+ WithTurnExtensionData {+ request: thread_settings,+ turn_extension_init: sub.turn_extension_init,+ },start_options,sub.id.clone(),)@@ -537,6 +545,10 @@ pub(super) async fn submission_loop(reply,} => {let _settings_guard = thread_settings::acquire_persistence_lock(&sess).await;+ let thread_settings = WithTurnExtensionData {+ request: thread_settings,+ turn_extension_init: sub.turn_extension_init,+ };match thread_settings::update(&sess, thread_settings).await {Ok(snapshot) => {// Reply first: the caller may hold a lock its event consumer needs.diff --git a/codex-rs/core/src/session/mod.rs b/codex-rs/core/src/session/mod.rsindex 1d1944095a..0fedcdd4b7 100644--- a/codex-rs/core/src/session/mod.rs+++ b/codex-rs/core/src/session/mod.rs@@ -1,5 +1,6 @@pub(crate) mod startup;+use crate::WithTurnExtensionData;use std::borrow::Cow;use std::collections::HashMap;use std::collections::HashSet;@@ -469,6 +470,7 @@ pub(crate) struct SessionSpawnArgs {pub(crate) parent_trace: Option<W3cTraceContext>,pub(crate) environment_selections: Vec<TurnEnvironmentSelection>,pub(crate) thread_extension_init: ExtensionDataInit,+ pub(crate) turn_extension_init: ExtensionDataInit,pub(crate) client_mcp_extensions: ClientMcpExtensions,pub(crate) reserved_thread_id: Option<ThreadId>,pub(crate) analytics_events_client: Option<AnalyticsEventsClient>,@@ -577,6 +579,7 @@ impl Session {parent_trace: _,environment_selections,thread_extension_init,+ turn_extension_init,client_mcp_extensions,reserved_thread_id,analytics_events_client,@@ -830,6 +833,7 @@ impl Session {get_service_tier(config.service_tier.clone(), fast_mode_enabled, &model_info);let storage_originator = AuthStorageOriginator::from_client_name(&originator);let session_configuration = SessionConfiguration {+ turn_extension_init,provider: create_model_provider(config.model_provider.clone(),Some(Arc::clone(&auth_manager)),@@ -965,7 +969,10 @@ impl Session {impl SessionIo {/// Submit the `op` wrapped in a `Submission` with a unique ID.- pub(crate) async fn submit(&self, op: Op) -> CodexResult<String> {+ pub(crate) async fn submit(+ &self,+ op: impl Into<WithTurnExtensionData<Op>>,+ ) -> CodexResult<String> {self.submit_with_trace(op, /*trace*/ None, /*parent_turn_id*/ None, /*root_turn_id*/ None,/*residency_guard*/ None,@@ -975,16 +982,21 @@ impl SessionIo {pub(crate) async fn submit_with_trace(&self,- op: Op,+ op: impl Into<WithTurnExtensionData<Op>>,trace: Option<W3cTraceContext>,parent_turn_id: Option<String>,root_turn_id: Option<String>,residency_guard: Option<tokio::sync::OwnedRwLockReadGuard<()>>,) -> CodexResult<String> {let id = new_submission_id();+ let WithTurnExtensionData {+ request: op,+ turn_extension_init,+ } = op.into();let sub = Submission {id: id.clone(),op,+ turn_extension_init,trace,parent_turn_id,root_turn_id,@@ -1012,11 +1024,15 @@ impl SessionIo {/// session loop exits before replying, the caller gets `InternalAgentDied`.pub(crate) async fn submit_turn_input(&self,- mut request: TurnInputRequest,+ request: impl Into<WithTurnExtensionData<TurnInputRequest>>,mode: TurnInputMode,) -> CodexResult<TurnInputSubmission> {let id = new_submission_id();let (reply_tx, reply_rx) = oneshot::channel();+ let WithTurnExtensionData {+ mut request,+ turn_extension_init,+ } = request.into();let trace = request.trace.take();self.submit_with_id(Submission {id,@@ -1026,6 +1042,7 @@ impl SessionIo {reply: reply_tx,},trace,+ turn_extension_init,parent_turn_id: None,root_turn_id: None,residency_guard: None,@@ -1040,6 +1057,7 @@ impl SessionIo {start_options: TurnStartOptions,trace: Option<W3cTraceContext>,turn_id: String,+ turn_extension_init: Option<ExtensionDataInit>,) -> CodexResult<TurnInputSubmission> {let (reply_tx, reply_rx) = oneshot::channel();self.submit_with_id(Submission {@@ -1050,6 +1068,7 @@ impl SessionIo {reply: reply_tx,},trace,+ turn_extension_init,parent_turn_id: None,root_turn_id: None,residency_guard: None,diff --git a/codex-rs/core/src/session/session.rs b/codex-rs/core/src/session/session.rsindex 878bffa8f2..07ecc2f1db 100644--- a/codex-rs/core/src/session/session.rs+++ b/codex-rs/core/src/session/session.rs@@ -106,6 +106,8 @@ pub(crate) struct SessionConfiguration {/// Desired configured inputs inherited by future turns.pub(super) step_settings: Arc<StepSettings>,+ /// Host-supplied extension data inherited by future turns.+ pub(super) turn_extension_init: ExtensionDataInit,/// Ordered environments inherited by future turns.pub(super) environments: Vec<TurnEnvironmentSelection>,/// Explicit startup overrides used when resolving effective model metadata.@@ -306,6 +308,7 @@ impl SessionConfiguration {thread_source: self.thread_source.clone(),originator: self.originator.clone(),disabled_plugin_ids: self.disabled_plugin_ids.clone(),+ turn_extension_init: self.turn_extension_init.clone(),}}@@ -358,6 +361,7 @@ impl SessionConfiguration {collaboration_mode: Some(self.step_settings.collaboration_mode.clone()),personality: self.step_settings.personality,disabled_plugin_ids: Some(self.disabled_plugin_ids.clone()),+ turn_extension_init: Some(self.turn_extension_init.clone()),..Default::default()}}@@ -398,6 +402,9 @@ impl SessionConfiguration {current_environments: &[TurnEnvironmentSelection],) -> ConstraintResult<Self> {let mut next_configuration = self.clone();+ if let Some(turn_extension_init) = &updates.turn_extension_init {+ next_configuration.turn_extension_init = turn_extension_init.clone();+ }if let Some(disabled_plugin_ids) = &updates.disabled_plugin_ids {next_configuration.disabled_plugin_ids = disabled_plugin_ids.clone();}@@ -595,6 +602,8 @@ pub(crate) struct SessionSettingsCommit {#[derive(Default, Clone)]pub(crate) struct SessionSettingsUpdate {pub(crate) step_settings: StepSettingsUpdate,+ /// Omission preserves the current data; an empty initializer clears it.+ pub(crate) turn_extension_init: Option<ExtensionDataInit>,pub(crate) environments: Option<TurnEnvironmentSelections>,pub(crate) runtime_workspace_roots: Option<Vec<AbsolutePathBuf>>,pub(crate) profile_workspace_roots: Option<Vec<ProfileWorkspaceRoot>>,diff --git a/codex-rs/core/src/session/step_activation_tests.rs b/codex-rs/core/src/session/step_activation_tests.rsindex 8ab26dc96f..0202c02075 100644--- a/codex-rs/core/src/session/step_activation_tests.rs+++ b/codex-rs/core/src/session/step_activation_tests.rs@@ -489,6 +489,7 @@ fn settings_submission((Submission {id: id.to_string(),+ turn_extension_init: None,op: Op::TurnSettings {turn_id: turn_id.to_string(),update,diff --git a/codex-rs/core/src/session/submission.rs b/codex-rs/core/src/session/submission.rsindex 9bd9162354..413e1874b1 100644--- a/codex-rs/core/src/session/submission.rs+++ b/codex-rs/core/src/session/submission.rs@@ -1,5 +1,6 @@//! Core-owned queue metadata; forwarding transfers the residency guard with the operation.+use codex_extension_api::ExtensionDataInit;use codex_protocol::protocol::Op;use codex_protocol::protocol::W3cTraceContext;use tokio::sync::OwnedRwLockReadGuard;@@ -9,6 +10,8 @@ use tokio::sync::OwnedRwLockReadGuard;pub(crate) struct Submission {pub id: String,pub op: Op,+ /// Accepted with settings, never separately from the request that supplied them.+ pub turn_extension_init: Option<ExtensionDataInit>,/// Optional W3C trace carrier propagated across async submission handoffs.pub trace: Option<W3cTraceContext>,pub parent_turn_id: Option<String>,diff --git a/codex-rs/core/src/session/tests.rs b/codex-rs/core/src/session/tests.rsindex 62c16bec9e..c61c012db4 100644--- a/codex-rs/core/src/session/tests.rs+++ b/codex-rs/core/src/session/tests.rs@@ -4396,6 +4396,7 @@ async fn set_rate_limits_retains_previous_credits() {},};let session_configuration = SessionConfiguration {+ turn_extension_init: Default::default(),provider: create_model_provider(config.model_provider.clone(), /*auth_manager*/ None),environments: Vec::new(),step_settings: Arc::new(StepSettings {@@ -4518,6 +4519,7 @@ async fn set_rate_limits_updates_plan_type_when_present() {},};let session_configuration = SessionConfiguration {+ turn_extension_init: Default::default(),provider: create_model_provider(config.model_provider.clone(), /*auth_manager*/ None),environments: Vec::new(),step_settings: Arc::new(StepSettings {@@ -5139,6 +5141,7 @@ pub(crate) async fn make_session_configuration_for_tests() -> SessionConfigurati};SessionConfiguration {+ turn_extension_init: Default::default(),provider: create_model_provider(config.model_provider.clone(), /*auth_manager*/ None),environments: Vec::new(),step_settings: Arc::new(StepSettings {@@ -6070,6 +6073,7 @@ async fn standalone_settings_invalidate_continuation_before_delivering_acceptanctx_sub.send(Submission {id: "settings".into(),+ turn_extension_init: None,op: Op::ThreadSettings {thread_settings: codex_protocol::protocol::ThreadSettingsOverrides::default(),reply: Some(reply),@@ -6530,6 +6534,7 @@ async fn session_new_fails_when_zsh_fork_enabled_without_packaged_zsh() {},};let session_configuration = SessionConfiguration {+ turn_extension_init: Default::default(),provider: create_model_provider(config.model_provider.clone(),Some(Arc::clone(&auth_manager)),@@ -6756,6 +6761,7 @@ pub(crate) async fn make_session_and_context() -> (Session, TurnContext) {};let default_environments = vec![local(config.cwd.clone())];let session_configuration = SessionConfiguration {+ turn_extension_init: Default::default(),environments: default_environments.clone(),provider: create_model_provider(config.model_provider.clone(),@@ -7079,6 +7085,7 @@ async fn make_session_with_config_and_rx(};let default_environments = vec![local(config.cwd.clone())];let session_configuration = SessionConfiguration {+ turn_extension_init: Default::default(),environments: default_environments.clone(),provider: create_model_provider(config.model_provider.clone(),@@ -7211,6 +7218,7 @@ async fn make_session_with_history_source_and_agent_control_and_rx(};let default_environments = vec![local(config.cwd.clone())];let session_configuration = SessionConfiguration {+ turn_extension_init: Default::default(),environments: default_environments.clone(),provider: create_model_provider(config.model_provider.clone(),@@ -8179,6 +8187,7 @@ fn submission_dispatch_span_prefers_submission_trace_context() {};let dispatch_span = ambient_span.in_scope(|| {submission_dispatch_span(&Submission {+ turn_extension_init: None,id: "sub-1".into(),op: Op::Interrupt,parent_turn_id: None,@@ -8200,6 +8209,7 @@ fn submission_dispatch_span_uses_debug_for_realtime_audio() {let _trace_test_context = install_test_tracing("codex-core-tests");let dispatch_span = submission_dispatch_span(&Submission {+ turn_extension_init: None,id: "sub-1".into(),op: Op::RealtimeConversationAudio(ConversationAudioParams {frame: RealtimeAudioFrame {@@ -8566,6 +8576,7 @@ async fn spawn_task_turn_span_inherits_dispatch_trace_context() {.await;let dispatch_span = submission_dispatch_span(&Submission {+ turn_extension_init: None,id: "sub-1".into(),op: Op::Interrupt,parent_turn_id: None,@@ -9036,6 +9047,7 @@ where};let default_environments = vec![local(config.cwd.clone())];let session_configuration = SessionConfiguration {+ turn_extension_init: Default::default(),environments: default_environments.clone(),provider: create_model_provider(config.model_provider.clone(),diff --git a/codex-rs/core/src/session/tests/guardian_tests.rs b/codex-rs/core/src/session/tests/guardian_tests.rsindex 2d78c4af2a..00c6d882b4 100644--- a/codex-rs/core/src/session/tests/guardian_tests.rs+++ b/codex-rs/core/src/session/tests/guardian_tests.rs@@ -1335,6 +1335,7 @@ async fn guardian_subagent_does_not_inherit_parent_exec_policy_rules() {parent_trace: None,environment_selections: Vec::new(),thread_extension_init,+ turn_extension_init: Default::default(),client_mcp_extensions: ClientMcpExtensions::default(),reserved_thread_id: None,analytics_events_client: None,diff --git a/codex-rs/core/src/session/thread_settings.rs b/codex-rs/core/src/session/thread_settings.rsindex 21059048fb..66296ae302 100644--- a/codex-rs/core/src/session/thread_settings.rs+++ b/codex-rs/core/src/session/thread_settings.rs@@ -4,6 +4,7 @@use super::session::Session;use super::session::SessionSettingsUpdate;use super::step_settings::StepSettingsUpdate;+use crate::WithTurnExtensionData;use crate::config::ConstraintResult;use codex_history::RolloutItem;use codex_protocol::protocol::Event;@@ -31,7 +32,7 @@ impl Session {/// Applies standalone thread settings. The caller holds the persistence permit through notification.pub(super) async fn update(session: &Session,- overrides: ThreadSettingsOverrides,+ overrides: impl Into<WithTurnExtensionData<ThreadSettingsOverrides>>,) -> ConstraintResult<ThreadSettingsSnapshot> {let updates = prepare_update(overrides);let commit = session.update_settings(updates).await?;@@ -41,7 +42,13 @@ pub(super) async fn update(}/// Converts protocol overrides into the internal settings update shape.-pub(super) fn prepare_update(overrides: ThreadSettingsOverrides) -> SessionSettingsUpdate {+pub(super) fn prepare_update(+ overrides: impl Into<WithTurnExtensionData<ThreadSettingsOverrides>>,+) -> SessionSettingsUpdate {+ let WithTurnExtensionData {+ request: overrides,+ turn_extension_init,+ } = overrides.into();let ThreadSettingsOverrides {environments,runtime_workspace_roots,@@ -61,6 +68,7 @@ pub(super) fn prepare_update(overrides: ThreadSettingsOverrides) -> SessionSettidisabled_plugin_ids,} = overrides;SessionSettingsUpdate {+ turn_extension_init,step_settings: StepSettingsUpdate {model,effort,diff --git a/codex-rs/core/src/session/turn_context.rs b/codex-rs/core/src/session/turn_context.rsindex 777da7411b..652da73c3c 100644--- a/codex-rs/core/src/session/turn_context.rs+++ b/codex-rs/core/src/session/turn_context.rs@@ -997,7 +997,10 @@ impl Session {turn_metadata_state.set_responses_api_metadata(per_turn_config.responses_api_metadata.clone());let (current_date, timezone) = local_time_context();- let extension_data = Arc::new(codex_extension_api::ExtensionData::new(sub_id.clone()));+ let extension_data = Arc::new(codex_extension_api::ExtensionData::new_with_init(+ sub_id.clone(),+ session_configuration.turn_extension_init.clone(),+ ));extension_data.insert(skills_snapshot);TurnContext {sub_id,diff --git a/codex-rs/core/src/session/turn_input.rs b/codex-rs/core/src/session/turn_input.rsindex 4fc90cac0a..f6e5c4895d 100644--- a/codex-rs/core/src/session/turn_input.rs+++ b/codex-rs/core/src/session/turn_input.rs@@ -18,6 +18,7 @@ use super::session::SessionSettingsUpdate;use super::thread_settings;use super::turn_context::NewTurnContextOptions;use super::turn_context::TurnContext;+use crate::WithTurnExtensionData;use crate::state::ActiveTurn;use crate::state::TurnState;use crate::tasks::RegularTask;@@ -96,10 +97,14 @@ impl PreparedTurnInputSettings {/// leaves the thread unchanged.async fn prepare(session: &Session,- thread_settings: ThreadSettingsOverrides,+ thread_settings: impl Into<WithTurnExtensionData<ThreadSettingsOverrides>>,start_options: TurnStartOptions,) -> CodexResult<Self> {- let thread_settings_update = if thread_settings == ThreadSettingsOverrides::default() {+ let thread_settings = thread_settings.into();+ let thread_settings_update = if thread_settings.request+ == ThreadSettingsOverrides::default()+ && thread_settings.turn_extension_init.is_none()+ {None} else {let updates = thread_settings::prepare_update(thread_settings);@@ -210,14 +215,15 @@ impl PreparedTurnInputSettings {)]pub(super) async fn handle(session: &Arc<Session>,- request: TurnInputRequest,+ request: impl Into<WithTurnExtensionData<TurnInputRequest>>,mode: TurnInputMode,submission_id: String,) -> CodexResult<TurnInputSubmission> {+ let request = request.into();let result = match mode {TurnInputMode::StartOrSteer => start_or_steer(session, request, submission_id).await,TurnInputMode::StartIfIdle => {- let kind = match &request.input {+ let kind = match &request.request.input {SubmittedTurnInput::UserInput { content, .. } if !content.is_empty() => {TurnStartKind::User}@@ -237,7 +243,7 @@ pub(super) async fn handle(TurnInputMode::ContinueIfIdle {expected_previous_turn_id,} => {- if !matches!(&request.input, SubmittedTurnInput::ResponseItem(_)) {+ if !matches!(&request.request.input, SubmittedTurnInput::ResponseItem(_)) {return Err(CodexErr::InvalidRequest("continuation requires internal response input".to_string(),));@@ -272,10 +278,14 @@ pub(super) async fn handle()]pub(super) async fn handle_recovery(session: &Arc<Session>,- thread_settings: ThreadSettingsOverrides,+ thread_settings: impl Into<WithTurnExtensionData<ThreadSettingsOverrides>>,start_options: TurnStartOptions,submission_id: String,) -> CodexResult<TurnInputSubmission> {+ let WithTurnExtensionData {+ request: thread_settings,+ turn_extension_init,+ } = thread_settings.into();let request = TurnInputRequest::user_input(Vec::new()).with_thread_settings(thread_settings).on_start(TurnStartOptions {@@ -284,7 +294,10 @@ pub(super) async fn handle_recovery(});let result = start_if_idle(session,- request,+ WithTurnExtensionData {+ request,+ turn_extension_init,+ },submission_id,TurnStartKind::Recovery,/*expected_previous_turn_id*/ None,@@ -298,9 +311,13 @@ pub(super) async fn handle_recovery(async fn start_or_steer(session: &Arc<Session>,- request: TurnInputRequest,+ request: WithTurnExtensionData<TurnInputRequest>,submission_id: String,) -> CodexResult<TurnInputSubmission> {+ let WithTurnExtensionData {+ request,+ turn_extension_init,+ } = request;let TurnInputRequest {mut input,thread_settings,@@ -323,7 +340,15 @@ async fn start_or_steer());}};- let settings = PreparedTurnInputSettings::prepare(session, thread_settings, start).await?;+ let settings = PreparedTurnInputSettings::prepare(+ session,+ WithTurnExtensionData {+ request: thread_settings,+ turn_extension_init,+ },+ start,+ )+ .await?;match session.steer_input(&mut input,@@ -401,11 +426,15 @@ async fn start_or_steer()]async fn start_if_idle(session: &Arc<Session>,- request: TurnInputRequest,+ request: WithTurnExtensionData<TurnInputRequest>,submission_id: String,kind: TurnStartKind,expected_previous_turn_id: Option<String>,) -> CodexResult<TurnInputSubmission> {+ let WithTurnExtensionData {+ request,+ turn_extension_init,+ } = request;let TurnInputRequest {input,thread_settings,@@ -477,7 +506,16 @@ async fn start_if_idle(});}- let settings = match PreparedTurnInputSettings::prepare(session, thread_settings, start).await {+ let settings = match PreparedTurnInputSettings::prepare(+ session,+ WithTurnExtensionData {+ request: thread_settings,+ turn_extension_init,+ },+ start,+ )+ .await+ {Ok(settings) => settings,Err(error) => {session.clear_reserved_idle_turn(&turn_state).await;@@ -543,10 +581,14 @@ async fn start_if_idle(async fn steer(session: &Arc<Session>,- request: TurnInputRequest,+ request: WithTurnExtensionData<TurnInputRequest>,expected_turn_id: String,submission_id: String,) -> CodexResult<TurnInputSubmission> {+ let WithTurnExtensionData {+ request,+ turn_extension_init,+ } = request;let TurnInputRequest {mut input,thread_settings,@@ -561,7 +603,15 @@ async fn steer("only user input can steer a turn".to_string(),));}- let settings = PreparedTurnInputSettings::prepare(session, thread_settings, start).await?;+ let settings = PreparedTurnInputSettings::prepare(+ session,+ WithTurnExtensionData {+ request: thread_settings,+ turn_extension_init,+ },+ start,+ )+ .await?;match session.steer_input(&mut input,diff --git a/codex-rs/core/src/thread_manager.rs b/codex-rs/core/src/thread_manager.rsindex 9b6ec56ff8..bd99b98141 100644--- a/codex-rs/core/src/thread_manager.rs+++ b/codex-rs/core/src/thread_manager.rs@@ -288,6 +288,8 @@ pub struct StartThreadOptions {/// Explicit global instructions carried by an internal caller instead of loading them again.pub user_instructions: Option<LoadedUserInstructions>,pub thread_extension_init: ExtensionDataInit,+ /// Host-supplied data captured by each new turn. This is not persisted.+ pub turn_extension_init: ExtensionDataInit,pub client_mcp_extensions: ClientMcpExtensions,/// Thread ID reserved before startup so the caller can associate host-owned state with it.pub reserved_thread_id: Option<ThreadId>,@@ -313,6 +315,7 @@ impl StartThreadOptions {inherited_environments: None,user_instructions: None,thread_extension_init: ExtensionDataInit::default(),+ turn_extension_init: ExtensionDataInit::default(),client_mcp_extensions: ClientMcpExtensions::default(),reserved_thread_id: None,disabled_plugin_ids: None,@@ -2085,6 +2088,7 @@ impl ThreadManagerState {inherited_environments: captured_environments,user_instructions: supplied_user_instructions,mut thread_extension_init,+ turn_extension_init,client_mcp_extensions,mut reserved_thread_id,disabled_plugin_ids,@@ -2330,6 +2334,7 @@ impl ThreadManagerState {parent_trace,environment_selections: environments,thread_extension_init,+ turn_extension_init,client_mcp_extensions,reserved_thread_id,analytics_events_client: self.analytics_events_client.clone(),diff --git a/codex-rs/core/src/turn_extension_data.rs b/codex-rs/core/src/turn_extension_data.rsnew file mode 100644index 0000000000..89f112709b--- /dev/null+++ b/codex-rs/core/src/turn_extension_data.rs@@ -0,0 +1,33 @@+//! Carries host-owned data through settings acceptance and into each new turn.++use codex_extension_api::ExtensionDataInit;++/// A request that also replaces the host data inherited by future turns.+///+/// Core accepts or rejects both together. Steering leaves the running turn's+/// data unchanged. Plain requests preserve the saved data; an empty initializer+/// clears it. Values should be immutable: initializers share their values by `Arc`.+/// This data is not persisted, so hosts must supply it again on cold resume.+#[derive(Debug)]+pub struct WithTurnExtensionData<T> {+ pub(crate) request: T,+ pub(crate) turn_extension_init: Option<ExtensionDataInit>,+}++impl<T> WithTurnExtensionData<T> {+ pub fn new(request: T, turn_extension_init: ExtensionDataInit) -> Self {+ Self {+ request,+ turn_extension_init: Some(turn_extension_init),+ }+ }+}++impl<T> From<T> for WithTurnExtensionData<T> {+ fn from(request: T) -> Self {+ Self {+ request,+ turn_extension_init: None,+ }+ }+}diff --git a/codex-rs/core/tests/suite/turn_input_submission.rs b/codex-rs/core/tests/suite/turn_input_submission.rsindex 393cf8a536..a81e68f6ab 100644--- a/codex-rs/core/tests/suite/turn_input_submission.rs+++ b/codex-rs/core/tests/suite/turn_input_submission.rs@@ -7,10 +7,12 @@ use codex_core::TurnInput;use codex_core::TurnInputRequest;use codex_core::TurnInputSubmission;use codex_core::TurnStartOptions;+use codex_core::WithTurnExtensionData;use codex_core::config::Constrained;use codex_core::context::ContextualUserFragment;use codex_core::context::InternalContextSource;use codex_core::context::InternalModelContextFragment;+use codex_extension_api::ExtensionDataInit;use codex_extension_api::ExtensionRegistryBuilder;use codex_extension_api::TurnStartAdmission;use codex_features::Feature;@@ -36,6 +38,7 @@ use core_test_support::submit_thread_settings;use core_test_support::test_codex::local;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::Value;use std::sync::Arc;@@ -47,6 +50,153 @@ use tokio::sync::Barrier;use tokio::sync::oneshot;use tokio::time::timeout;+/// Accepted steering changes future captures, while rejected input and automatic starts+/// preserve the policy belonging to each turn.+#[tokio::test]+async fn turn_extension_data_is_captured_for_automatic_turns() -> anyhow::Result<()> {+ let (release_initial, initial_gate) = oneshot::channel();+ let (release_automatic, automatic_gate) = oneshot::channel();+ let (server, _completions) = start_streaming_sse_server(vec![+ vec![StreamingSseChunk {+ gate: Some(initial_gate),+ body: responses::sse_completed("initial"),+ }],+ vec![StreamingSseChunk {+ gate: None,+ body: responses::sse_completed("steered"),+ }],+ vec![StreamingSseChunk {+ gate: Some(automatic_gate),+ body: responses::sse_completed("automatic"),+ }],+ ])+ .await;+ let mock = responses::start_mock_server().await;+ let test = test_codex().build_with_auto_env(&mock).await?;+ let mut config = test.config.clone();+ config.model_provider.base_url = Some(format!("{}/v1", server.uri()));+ let mut initial = ExtensionDataInit::new();+ initial.insert("original".to_owned());+ let thread = test+ .thread_manager+ .start_thread(StartThreadOptions {+ turn_extension_init: initial,+ environments: Some(vec![test.executor_environment().selection().clone()]),+ ..StartThreadOptions::new(config)+ })+ .await?+ .thread;+ let TurnInputSubmission::Started { turn_id } = submit_user_message(&thread, "start").await?+ else {+ anyhow::bail!("first input must start a turn");+ };+ server.wait_for_request_count(/*count*/ 1).await;+ assert_eq!(+ thread.current_turn_extension_data::<String>(&turn_id).await,+ Some(Arc::new("original".to_owned()))+ );+ let mut next = ExtensionDataInit::new();+ next.insert("next".to_owned());+ assert_eq!(+ thread+ .start_or_steer_turn(WithTurnExtensionData::new(+ user_message_request("steer"),+ next+ ))+ .await?,+ TurnInputSubmission::Steered {+ turn_id: turn_id.clone()+ }+ );+ let mut rejected = ExtensionDataInit::new();+ rejected.insert("rejected".to_owned());+ assert_eq!(+ thread+ .steer_turn(+ WithTurnExtensionData::new(user_message_request("wrong turn"), rejected),+ "another-turn".to_owned(),+ )+ .await?,+ SteerSubmission::NotSubmitted {+ reason: NotSubmittedReason::ExpectedTurnMismatch {+ expected: "another-turn".to_owned(),+ actual: turn_id.clone(),+ },+ }+ );+ assert_eq!(+ thread.current_turn_extension_data::<String>(&turn_id).await,+ Some(Arc::new("original".to_owned()))+ );+ assert_eq!(+ thread+ .config_snapshot()+ .await+ .turn_extension_init+ .get::<String>(),+ Some(Arc::new("next".to_owned()))+ );+ release_initial+ .send(())+ .expect("initial response is waiting");+ wait_for_event(&thread, |event| matches!(event, EventMsg::TurnComplete(_))).await;+ thread+ .submit(Op::InterAgentCommunication {+ communication: InterAgentCommunication::new(+ AgentPath::try_from("/root/worker").expect("valid sender path"),+ AgentPath::root(),+ Vec::new(),+ "automatic wake".to_owned(),+ /*trigger_turn*/ true,+ ),+ start_options: Default::default(),+ })+ .await?;+ let automatic_id = wait_for_event_match(&thread, |event| match event {+ EventMsg::TurnStarted(started) => Some(started.turn_id.clone()),+ _ => None,+ })+ .await;+ server.wait_for_request_count(/*count*/ 3).await;+ let captured = thread+ .current_turn_extension_data::<String>(&automatic_id)+ .await;+ assert_ne!(automatic_id, turn_id);+ assert_eq!(captured, Some(Arc::new("next".to_owned())));+ assert_eq!(+ thread.current_turn_extension_data::<String>(&turn_id).await,+ None+ );+ // Clearing future data must not change the automatic turn that already captured it.+ thread+ .update_thread_settings(WithTurnExtensionData::new(+ ThreadSettingsOverrides::default(),+ ExtensionDataInit::new(),+ ))+ .await?;+ assert_eq!(+ thread+ .config_snapshot()+ .await+ .turn_extension_init+ .get::<String>(),+ None+ );+ assert_eq!(+ thread+ .current_turn_extension_data::<String>(&automatic_id)+ .await,+ captured+ );+ release_automatic+ .send(())+ .expect("automatic response is waiting");+ wait_for_event(&thread, |event| matches!(event, EventMsg::TurnComplete(_))).await;+ assert_eq!(server.requests().await.len(), 3);+ server.shutdown().await;+ Ok(())+}+#[derive(Debug)]struct TestAdmission(AtomicBool);