Skip to content

armgit / codex

Public Imported from GitHub
0

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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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_acceptanc
tx_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.rs
index 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.rs
index 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) -> SessionSetti
disabled_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.rs
index 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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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);