Lightweight coding agent that runs in your terminal
Rust
Add direct replies for thread settings updates (#47937)
sayan-oaifbd0c0d96ca0
diff --git a/codex-rs/app-server/src/request_processors/turn_processor.rs b/codex-rs/app-server/src/request_processors/turn_processor.rsindex 0594e8114e..e42e53de1f 100644--- a/codex-rs/app-server/src/request_processors/turn_processor.rs+++ b/codex-rs/app-server/src/request_processors/turn_processor.rs@@ -959,7 +959,10 @@ impl TurnRequestProcessor {self.submit_core_op(request_id,thread.as_ref(),- Op::ThreadSettings { thread_settings },+ Op::ThreadSettings {+ thread_settings,+ reply: None,+ },).await.map_err(|err| internal_error(format!("failed to update thread settings: {err}")))?;diff --git a/codex-rs/core-api/src/lib.rs b/codex-rs/core-api/src/lib.rsindex a8facc3ae1..4a4047dd4e 100644--- a/codex-rs/core-api/src/lib.rs+++ b/codex-rs/core-api/src/lib.rs@@ -130,6 +130,7 @@ pub use codex_protocol::protocol::EventMsg;pub use codex_protocol::protocol::Op;pub use codex_protocol::protocol::SessionConfiguredEvent;pub use codex_protocol::protocol::SessionSource;+pub use codex_protocol::protocol::ThreadSettingsOverrides;pub use codex_protocol::protocol::TurnEnvironmentSelection;pub use codex_protocol::protocol::W3cTraceContext;pub use codex_protocol::user_input::UserInput;diff --git a/codex-rs/core/src/codex_thread.rs b/codex-rs/core/src/codex_thread.rsindex ccbb5d54c8..9d2c3adb43 100644--- a/codex-rs/core/src/codex_thread.rs+++ b/codex-rs/core/src/codex_thread.rs@@ -45,6 +45,7 @@ use codex_protocol::protocol::SandboxPolicy;use codex_protocol::protocol::SessionSource;use codex_protocol::protocol::ThreadHistoryMode;use codex_protocol::protocol::ThreadMemoryMode;+use codex_protocol::protocol::ThreadSettingsOverrides;use codex_protocol::protocol::ThreadSettingsSnapshot;use codex_protocol::protocol::ThreadSource;use codex_protocol::protocol::TokenUsageInfo;@@ -586,6 +587,21 @@ impl CodexThread {self.session.preview_settings(&updates).await}+ /// Queues settings for future turns and waits for Core to accept or reject them.+ /// Rejections are returned to the caller instead of emitted as thread errors.+ pub async fn update_thread_settings(+ &self,+ thread_settings: ThreadSettingsOverrides,+ ) -> CodexResult<()> {+ let (reply, result) = oneshot::channel();+ self.submit(Op::ThreadSettings {+ thread_settings,+ reply: Some(reply),+ })+ .await?;+ result.await.unwrap_or(Err(CodexErr::InternalAgentDied))+ }+/// Restores thread-owned mutable settings captured from another loaded runtime.////// Runtime replacement uses this after resume so clients keep their current thread settingsdiff --git a/codex-rs/core/src/session/handlers.rs b/codex-rs/core/src/session/handlers.rsindex c6648e3df6..cc8413a653 100644--- a/codex-rs/core/src/session/handlers.rs+++ b/codex-rs/core/src/session/handlers.rs@@ -23,6 +23,7 @@ use crate::tasks::CompactTask;use crate::tasks::UserShellCommandMode;use crate::tasks::UserShellCommandTask;use crate::tasks::execute_user_shell_command;+use codex_protocol::error::CodexErr;use codex_protocol::protocol::CodexErrorInfo;use codex_protocol::protocol::ErrorEvent;use codex_protocol::protocol::Event;@@ -516,8 +517,36 @@ pub(super) async fn submission_loop(let _ = reply.send(result);should_exit}- Op::ThreadSettings { thread_settings } => {- thread_settings::update(&sess, sub.id.clone(), thread_settings).await;+ Op::ThreadSettings {+ thread_settings,+ reply,+ } => {+ let _settings_guard = thread_settings::acquire_persistence_lock(&sess).await;+ match thread_settings::update(&sess, thread_settings).await {+ Ok(snapshot) => {+ // Reply first: the caller may hold a lock its event consumer needs.+ if let Some(reply) = reply {+ let _ = reply.send(Ok(()));+ }+ thread_settings::emit_applied(&sess, sub.id.clone(), snapshot).await;+ }+ Err(error) => {+ let message = format!("invalid thread settings override: {error}");+ if let Some(reply) = reply {+ let _ = reply.send(Err(CodexErr::InvalidRequest(message)));+ } else {+ sess.send_event_raw(Event {+ id: sub.id.clone(),+ msg: EventMsg::Error(ErrorEvent {+ misalignment: None,+ message,+ codex_error_info: Some(CodexErrorInfo::BadRequest),+ }),+ })+ .await;+ }+ }+ }false}Op::TurnSettings {diff --git a/codex-rs/core/src/session/tests.rs b/codex-rs/core/src/session/tests.rsindex 42e14804ee..1b43d3932c 100644--- a/codex-rs/core/src/session/tests.rs+++ b/codex-rs/core/src/session/tests.rs@@ -5718,7 +5718,7 @@ async fn mcp_attribution_checkpoints_cover_batch_prefixes_compaction_and_restore#[tokio::test]async fn standalone_settings_invalidate_continuation_before_delivering_acceptance() {- let (mut session, _) = make_session_and_context().await;+ let (mut session, turn_context) = make_session_and_context().await;let (tx, rx) = async_channel::bounded(1);session.tx_event = tx;session.state.lock().await.last_started_turn_id = Some("superseded-turn".into());@@ -5736,18 +5736,44 @@ async fn standalone_settings_invalidate_continuation_before_delivering_acceptanc.await.expect("fill event channel");let session = Arc::new(session);- let mut update = Box::pin(tokio::task::unconstrained(thread_settings::update(- &session,- "settings".into(),- codex_protocol::protocol::ThreadSettingsOverrides::default(),+ let (reply, mut accepted) = tokio::sync::oneshot::channel();+ let (tx_sub, rx_sub) = async_channel::bounded(1);+ tx_sub+ .send(Submission {+ id: "settings".into(),+ op: Op::ThreadSettings {+ thread_settings: codex_protocol::protocol::ThreadSettingsOverrides::default(),+ reply: Some(reply),+ },+ trace: None,+ parent_turn_id: None,+ root_turn_id: None,+ residency_guard: None,+ })+ .await+ .expect("submit settings");+ let mut submissions = Box::pin(tokio::task::unconstrained(submission_loop(+ Arc::clone(&session),+ turn_context.config,+ rx_sub,)));- assert!(futures::poll!(update.as_mut()).is_pending());+ assert!(futures::poll!(submissions.as_mut()).is_pending());assert_eq!(session.state.lock().await.last_started_turn_id, None);+ accepted+ .try_recv()+ .expect("receive acceptance before the event is delivered")+ .expect("settings accepted");let mut checkpoint = Box::pin(session.checkpoint_thread_settings());assert!(futures::poll!(checkpoint.as_mut()).is_pending());rx.recv().await.expect("release event delivery");- update.await;+ assert!(futures::poll!(submissions.as_mut()).is_pending());checkpoint.await.expect("checkpoint after settings update");+ assert!(matches!(+ rx.recv().await.expect("receive settings event").msg,+ EventMsg::ThreadSettingsApplied(_)+ ));+ drop(tx_sub);+ submissions.await;}#[tokio::test]diff --git a/codex-rs/core/src/session/thread_settings.rs b/codex-rs/core/src/session/thread_settings.rsindex 36d6b86e9d..21059048fb 100644--- a/codex-rs/core/src/session/thread_settings.rs+++ b/codex-rs/core/src/session/thread_settings.rs@@ -6,15 +6,12 @@ use super::session::SessionSettingsUpdate;use super::step_settings::StepSettingsUpdate;use crate::config::ConstraintResult;use codex_history::RolloutItem;-use codex_protocol::protocol::CodexErrorInfo;-use codex_protocol::protocol::ErrorEvent;use codex_protocol::protocol::Event;use codex_protocol::protocol::EventMsg;use codex_protocol::protocol::ThreadSettingsAppliedEvent;use codex_protocol::protocol::ThreadSettingsOverrides;use codex_protocol::protocol::ThreadSettingsSnapshot;use codex_thread_store::ThreadStoreResult;-use std::sync::Arc;use tokio::sync::SemaphorePermit;impl Session {@@ -31,34 +28,16 @@ impl Session {}}-/// Applies standalone thread settings and reports invalid overrides through the-/// normal event stream.+/// Applies standalone thread settings. The caller holds the persistence permit through notification.pub(super) async fn update(- session: &Arc<Session>,- submission_id: String,+ session: &Session,overrides: ThreadSettingsOverrides,-) {+) -> ConstraintResult<ThreadSettingsSnapshot> {let updates = prepare_update(overrides);- let _settings_guard = acquire_persistence_lock(session).await;- match session.update_settings(updates).await {- Ok(commit) => {- // Standalone settings changes supersede a pending automatic continuation.- session.state.lock().await.last_started_turn_id = None;- emit_applied(session, submission_id, commit.snapshot).await;- }- Err(error) => {- session- .send_event_raw(Event {- id: submission_id,- msg: EventMsg::Error(ErrorEvent {- misalignment: None,- message: format!("invalid thread settings override: {error}"),- codex_error_info: Some(CodexErrorInfo::BadRequest),- }),- })- .await;- }- }+ let commit = session.update_settings(updates).await?;+ // Standalone settings changes supersede a pending automatic continuation.+ session.state.lock().await.last_started_turn_id = None;+ Ok(commit.snapshot)}/// Converts protocol overrides into the internal settings update shape.diff --git a/codex-rs/core/tests/common/lib.rs b/codex-rs/core/tests/common/lib.rsindex 424cdb0f9c..0b05675541 100644--- a/codex-rs/core/tests/common/lib.rs+++ b/codex-rs/core/tests/common/lib.rs@@ -313,7 +313,12 @@ pub async fn submit_thread_settings(use tokio::time::Duration;use tokio::time::timeout;- let submission_id = codex.submit(Op::ThreadSettings { thread_settings }).await?;+ let submission_id = codex+ .submit(Op::ThreadSettings {+ thread_settings,+ reply: None,+ })+ .await?;loop {let ev = timeout(Duration::from_secs(10), codex.next_event()).awaitdiff --git a/codex-rs/core/tests/suite/agent_eviction_tests.rs b/codex-rs/core/tests/suite/agent_eviction_tests.rsindex 8e2d12ced9..ae7c6e282d 100644--- a/codex-rs/core/tests/suite/agent_eviction_tests.rs+++ b/codex-rs/core/tests/suite/agent_eviction_tests.rs@@ -129,6 +129,7 @@ async fn queued_mail_and_cancelled_eviction_keep_worker_ownership() -> Result<()model: Some(COMMITTED_MODEL.to_string()),..Default::default()},+ reply: None,}).await?;timeout(Duration::from_secs(10), entered_rx).await??;diff --git a/codex-rs/core/tests/suite/remote_env.rs b/codex-rs/core/tests/suite/remote_env.rsindex 6ad3d66c3e..1b21ec0e1b 100644--- a/codex-rs/core/tests/suite/remote_env.rs+++ b/codex-rs/core/tests/suite/remote_env.rs@@ -624,6 +624,7 @@ async fn environment_permissions_follow_configuration_ownership() -> Result<()>permission_profile: Some(PermissionProfile::workspace_write()),..Default::default()},+ reply: None,}).await?;let persisted_settings = wait_for_event_match(&test.codex, |event| match event {diff --git a/codex-rs/core/tests/suite/scenarios_indirect_namespace_prefixes.rs b/codex-rs/core/tests/suite/scenarios_indirect_namespace_prefixes.rsindex f1b96caa31..aeb1b0c197 100644--- a/codex-rs/core/tests/suite/scenarios_indirect_namespace_prefixes.rs+++ b/codex-rs/core/tests/suite/scenarios_indirect_namespace_prefixes.rs@@ -145,6 +145,7 @@ text({descriptions, echo: report.structuredContent.echo, agent: agents.agents[0]model: Some("prefixes-cleared".to_string()),..Default::default()},+ reply: None,}).await?;test.submit_text_turn("Find echo again, call it, and list the agents.")diff --git a/codex-rs/core/tests/suite/settings_commits.rs b/codex-rs/core/tests/suite/settings_commits.rsindex 9c8a9db591..ea368e2c03 100644--- a/codex-rs/core/tests/suite/settings_commits.rs+++ b/codex-rs/core/tests/suite/settings_commits.rs@@ -226,7 +226,12 @@ async fn settings_notifications_keep_their_commit_across_postcommit_work(Ok(turn_id)}SettingsOperation::Standalone => {- codex.submit(Op::ThreadSettings { thread_settings }).await+ codex+ .submit(Op::ThreadSettings {+ thread_settings,+ reply: None,+ })+ .await}}}diff --git a/codex-rs/core/tests/suite/settings_constraints.rs b/codex-rs/core/tests/suite/settings_constraints.rsindex ecdca6461c..e85d9a2351 100644--- a/codex-rs/core/tests/suite/settings_constraints.rs+++ b/codex-rs/core/tests/suite/settings_constraints.rs@@ -7,6 +7,7 @@ use codex_core::config::Constrained;use codex_features::Feature;use codex_models_manager::model_info::model_info_from_slug;use codex_protocol::config_types::ApprovalsReviewer;+use codex_protocol::error::CodexErrorDetails;use codex_protocol::models::PermissionProfile;use codex_protocol::openai_models::ApprovalMessages;use codex_protocol::openai_models::ModelsResponse;@@ -35,6 +36,7 @@ const PERMISSION_INSTRUCTIONS: &str = "Protected-model read-only instructions.";#[derive(Clone, Copy)]enum SettingsOperation {Standalone,+ StandaloneWithReply,TurnStart,}@@ -45,7 +47,35 @@ impl SettingsOperation {thread_settings: ThreadSettingsOverrides,) -> Result<ThreadSettingsSnapshot> {let id = match self {- Self::Standalone => codex.submit(Op::ThreadSettings { thread_settings }).await?,+ Self::Standalone => {+ codex+ .submit(Op::ThreadSettings {+ thread_settings,+ reply: None,+ })+ .await?+ }+ Self::StandaloneWithReply => {+ if let Err(error) = codex.update_thread_settings(thread_settings).await {+ assert!(matches!(+ error.details(),+ CodexErrorDetails::InvalidRequest(_)+ ));+ return Err(error.into());+ }+ // A successful update still notifies subscribers. A prior direct rejection must not.+ return match wait_for_event(codex, |event| {+ matches!(+ event,+ EventMsg::ThreadSettingsApplied(_) | EventMsg::Error(_)+ )+ })+ .await+ {+ EventMsg::ThreadSettingsApplied(applied) => Ok(applied.thread_settings),+ event => anyhow::bail!("unexpected settings event: {event:?}"),+ };+ }Self::TurnStart => {let result = codex.start_or_steer_turn(@@ -83,6 +113,7 @@ impl SettingsOperation {}#[test_case(SettingsOperation::Standalone; "standalone settings")]+#[test_case(SettingsOperation::StandaloneWithReply; "standalone settings with reply")]#[test_case(SettingsOperation::TurnStart; "turn-start settings")]#[tokio::test]async fn protected_model_settings_use_the_proposed_permissions(@@ -202,7 +233,10 @@ async fn protected_model_settings_use_the_proposed_permissions();assert_eq!(test.codex.thread_settings_snapshot().await, expected);- if let SettingsOperation::Standalone = operation {+ if matches!(+ operation,+ SettingsOperation::Standalone | SettingsOperation::StandaloneWithReply+ ) {test.submit_text_turn("use the committed settings").await?;}let request = response.single_request();diff --git a/codex-rs/core/tests/suite/step_settings.rs b/codex-rs/core/tests/suite/step_settings.rsindex 9006687a29..c532200b1c 100644--- a/codex-rs/core/tests/suite/step_settings.rs+++ b/codex-rs/core/tests/suite/step_settings.rs@@ -491,6 +491,7 @@ async fn tool_result_history_keeps_originating_model_across_switch_and_replay()model: Some(model.to_string()),..Default::default()},+ reply: None,}).await?;test.submit_text_turn("review previous diagnostics").await?;@@ -601,6 +602,7 @@ async fn tool_result_history_keeps_originating_model_across_switch_and_replay()model: Some(model.to_string()),..Default::default()},+ reply: None,}).await?;thread@@ -781,6 +783,7 @@ async fn settings_updates_preserve_turn_identity_and_target(target: SettingsTargservice_tier: Some(Some(ServiceTier::Fast.request_value().to_string())),..Default::default()},+ reply: None,}).await?;}@@ -1979,6 +1982,7 @@ async fn sparse_updates_preserve_divergent_active_and_future_models() -> Result<service_tier: Some(Some(ServiceTier::Fast.request_value().to_string())),..Default::default()},+ reply: None,}).await?;apply_turn_settings(diff --git a/codex-rs/protocol/src/protocol.rs b/codex-rs/protocol/src/protocol.rsindex a025b0bd29..3c2f05ac2b 100644--- a/codex-rs/protocol/src/protocol.rs+++ b/codex-rs/protocol/src/protocol.rs@@ -647,6 +647,9 @@ pub enum Op {ThreadSettings {/// Sparse thread-settings overrides to apply.thread_settings: ThreadSettingsOverrides,+ /// When present, report validation errors here instead of emitting an error event.+ /// Successful updates still emit `ThreadSettingsApplied` for all callers.+ reply: Option<oneshot::Sender<CodexResult<()>>>,},/// Update only the named running turn, without changing future settings.