Lightweight coding agent that runs in your terminal
Rust
Pin request reasoning effort while configuration overrides are active (#43795)
felixxia-oai31ccaf40c229
diff --git a/codex-rs/core/src/session/mod.rs b/codex-rs/core/src/session/mod.rsindex b4e98168fa..5922f61e61 100644--- a/codex-rs/core/src/session/mod.rs+++ b/codex-rs/core/src/session/mod.rs@@ -299,6 +299,7 @@ use crate::state::AcceptedUserInputResponse;use crate::state::AutoCompactWindowIds;use crate::state::AutoCompactWindowSnapshot;use crate::state::PendingRequestPermissions;+use crate::state::ReasoningEffortPin;use crate::state::SessionServices;use crate::state::SessionState;#[cfg(test)]@@ -1605,6 +1606,8 @@ impl Session {state.history.restore_review_context(Some(&retained_context), guardian_history.as_ref());+ // The next send supplies the selected effort. Refresh its trusted override too.+ state.reasoning_effort_pin = ReasoningEffortPin::Unset;if let Some(world_state) = world_state_baseline {state.history.set_world_state_baseline(world_state);}diff --git a/codex-rs/core/src/session/reasoning_effort.rs b/codex-rs/core/src/session/reasoning_effort.rsindex c11d010fa7..568b7a14ad 100644--- a/codex-rs/core/src/session/reasoning_effort.rs+++ b/codex-rs/core/src/session/reasoning_effort.rs@@ -1,11 +1,12 @@-//! Gated reasoning-effort updates appended after accepted input.+//! Cache-preserving effort updates and the original sampling request effort.//!-//! Only trusted harness items establish an effort. Updates append to surviving-//! history without replacing the request-level reasoning effort.+//! Only trusted harness items establish overrides. Replay invalidates the runtime+//! pin so the next send re-establishes the currently selected effort.use super::session::Session;use super::step_context::StepContext;use super::step_settings::ResolvedStepSettings;+use crate::state::ReasoningEffortPin;use codex_features::Feature;use codex_history::CodexHarnessMetadata;use codex_history::ResponseItemEnvelope;@@ -43,7 +44,10 @@ impl Session {_ => None,}});- established_effort == Some(&effort)+ state+ .reasoning_effort_pin+ .get(&settings.model_info.slug)+ .is_some_and(|pinned| established_effort.unwrap_or(&pinned) == &effort)};if should_skip {return;@@ -64,6 +68,28 @@ impl Session {.await;}+ /// Reuses the original request effort while updates carry the selected effort.+ pub(crate) async fn reasoning_effort_for_request(+ &self,+ settings: &ResolvedStepSettings,+ ) -> Option<ReasoningEffort> {+ let selected_effort = settings.reasoning_effort().cloned();+ if !self.enabled(Feature::ReasoningEffortOverride) {+ return selected_effort;+ }+ let effort = self.effort_for_configuration_update(settings).await;+ let mut state = self.state.lock().await;+ let Some(effort) = effort else {+ state.reasoning_effort_pin = ReasoningEffortPin::Unset;+ return selected_effort;+ };+ Some(+ state+ .reasoning_effort_pin+ .pin(&settings.model_info.slug, effort),+ )+ }+async fn effort_for_configuration_update(&self,settings: &ResolvedStepSettings,diff --git a/codex-rs/core/src/session/turn.rs b/codex-rs/core/src/session/turn.rsindex 7f31667988..93216d7c83 100644--- a/codex-rs/core/src/session/turn.rs+++ b/codex-rs/core/src/session/turn.rs@@ -2313,7 +2313,8 @@ async fn try_run_sampling_request(prompt,&step_context.settings.model_info,&step_context.session_telemetry,- step_context.settings.reasoning_effort().cloned(),+ sess.reasoning_effort_for_request(&step_context.settings)+ .await,step_context.settings.reasoning_summary,step_context.settings.service_tier.clone(),responses_metadata,diff --git a/codex-rs/core/src/session_startup_prewarm.rs b/codex-rs/core/src/session_startup_prewarm.rsindex 546962fea1..02ce6abf1e 100644--- a/codex-rs/core/src/session_startup_prewarm.rs+++ b/codex-rs/core/src/session_startup_prewarm.rs@@ -318,12 +318,15 @@ async fn schedule_startup_prewarm_inner(.await;let mut client_session = session.services.model_client.new_session();let websocket_warmup_started_at = Instant::now();+ // Prewarm establishes the request baseline before the first turn can change effort.client_session.prewarm_websocket(&startup_prompt,&step_context.settings.model_info,&step_context.session_telemetry,- step_context.settings.reasoning_effort().cloned(),+ session+ .reasoning_effort_for_request(&step_context.settings)+ .await,step_context.settings.reasoning_summary,step_context.settings.service_tier.clone(),&responses_metadata,diff --git a/codex-rs/core/src/state/mod.rs b/codex-rs/core/src/state/mod.rsindex 218b25ba92..71d9616e52 100644--- a/codex-rs/core/src/state/mod.rs+++ b/codex-rs/core/src/state/mod.rs@@ -9,6 +9,7 @@ pub(crate) use additional_context::AdditionalContextStore;pub(crate) use auto_compact_window::AutoCompactWindowIds;pub(crate) use auto_compact_window::AutoCompactWindowSnapshot;pub(crate) use service::SessionServices;+pub(crate) use session::ReasoningEffortPin;pub(crate) use session::SessionState;pub(crate) use turn::AcceptedUserInputResponse;pub(crate) use turn::ActiveTurn;diff --git a/codex-rs/core/src/state/session.rs b/codex-rs/core/src/state/session.rsindex 5333661a6f..901a5a5aca 100644--- a/codex-rs/core/src/state/session.rs+++ b/codex-rs/core/src/state/session.rs@@ -3,6 +3,7 @@use codex_protocol::models::AdditionalPermissionProfile;use codex_protocol::models::BaseInstructionsProvenance;use codex_protocol::models::ResponseItem;+use codex_protocol::openai_models::ReasoningEffort;use codex_sandboxing::policy_transforms::merge_permission_profiles;use std::collections::HashMap;use std::collections::HashSet;@@ -29,6 +30,38 @@ use codex_protocol::protocol::TurnContextItem;use codex_utils_output_truncation::TruncationPolicy;use tokio_util::task::AbortOnDropHandle;+/// Runtime request effort; startup and replay must re-establish the selected effort.+pub(crate) enum ReasoningEffortPin {+ Unset,+ Active {+ model: String,+ effort: ReasoningEffort,+ },+}++impl ReasoningEffortPin {+ pub(crate) fn get(&self, model: &str) -> Option<ReasoningEffort> {+ match self {+ Self::Active {+ model: pinned_model,+ effort,+ } if pinned_model == model => Some(effort.clone()),+ Self::Unset | Self::Active { .. } => None,+ }+ }++ pub(crate) fn pin(&mut self, model: &str, effort: ReasoningEffort) -> ReasoningEffort {+ if let Some(pinned) = self.get(model) {+ return pinned;+ }+ *self = Self::Active {+ model: model.to_owned(),+ effort: effort.clone(),+ };+ effort+ }+}+/// Persistent, session-scoped state previously stored directly on `Session`.pub(crate) struct SessionState {pub(crate) session_configuration: SessionConfiguration,@@ -46,6 +79,8 @@ pub(crate) struct SessionState {previous_turn_settings: Option<PreviousTurnSettings>,/// Runtime accounting state for the active auto-compaction window.auto_compact_window: AutoCompactWindow,+ /// Original request effort for the current model while configuration updates remain active.+ pub(crate) reasoning_effort_pin: ReasoningEffortPin,/// Startup prewarmed session prepared during session initialization.pub(crate) startup_prewarm: Option<SessionStartupPrewarmHandle>,/// Retained after completion so later turns do not repeat speculative captures.@@ -84,6 +119,7 @@ impl SessionState {additional_context: AdditionalContextStore::default(),previous_turn_settings: None,auto_compact_window: AutoCompactWindow::new_with_ids(auto_compact_window_ids),+ reasoning_effort_pin: ReasoningEffortPin::Unset,startup_prewarm: None,shell_snapshot_prewarm: None,current_time_reminder: CurrentTimeReminderState::default(),diff --git a/codex-rs/core/tests/suite/reasoning_effort_override.rs b/codex-rs/core/tests/suite/reasoning_effort_override.rsindex 8fa7be8dcf..fc834a9356 100644--- a/codex-rs/core/tests/suite/reasoning_effort_override.rs+++ b/codex-rs/core/tests/suite/reasoning_effort_override.rs@@ -1,8 +1,15 @@//! Trusted reasoning-effort updates follow surviving history and the next turn's selected settings.+use codex_core::config::Config;+use codex_extension_api::ExtensionFuture;+use codex_extension_api::ExtensionRegistryBuilder;+use codex_extension_api::ThreadIdleInput;+use codex_extension_api::ThreadLifecycleContributor;use codex_features::Feature;use codex_protocol::openai_models::ReasoningEffort;use codex_protocol::openai_models::ReasoningEffortPreset;+use codex_protocol::protocol::EventMsg;+use codex_protocol::protocol::Op;use codex_protocol::protocol::ThreadSettingsOverrides;use core_test_support::responses;use core_test_support::responses::ResponsesRequest;@@ -10,9 +17,14 @@ use core_test_support::skip_if_no_network;use core_test_support::submit_thread_settings;use core_test_support::test_codex::TestCodexBuilder;use core_test_support::test_codex::test_codex;+use core_test_support::wait_for_event;use pretty_assertions::assert_eq;use serde_json::Value;+use std::sync::Arc;+use std::time::Duration;use test_case::test_case;+use tokio::sync::Notify;+use tokio::time::timeout;fn override_builder() -> TestCodexBuilder {test_codex()@@ -91,11 +103,19 @@ async fn reasoning_effort_override_persistent_transitions(.await?;test.submit_text_turn("continue").await?;}+ let requests = mocks+ .iter()+ .map(responses::ResponseMock::single_request)+ .collect::<Vec<_>>();assert_eq!(- mocks+ requests.iter()- .map(|mock| effort_updates(&mock.single_request()))+ .map(|request| request.body_json()["reasoning"]["effort"].clone()).collect::<Vec<_>>(),+ vec![initial_update["reasoning"]["effort"].clone(); requests.len()],+ );+ assert_eq!(+ requests.iter().map(effort_updates).collect::<Vec<_>>(),vec![vec![initial_update.clone()],vec![initial_update.clone(), changed_update.clone()],@@ -160,12 +180,7 @@ async fn reasoning_effort_override_preserves_prefix_and_only_appends_on_change().iter().map(|request| request.body_json()["reasoning"]["effort"].clone()).collect::<Vec<_>>(),- vec![- Value::from("medium"),- Value::from("high"),- Value::from("high"),- Value::from("low"),- ],+ vec![Value::from("medium"); requests.len()],);let cache_keys = requests.iter()@@ -253,6 +268,171 @@ async fn reasoning_effort_override_normalizes_ultra_before_comparing_updates(Ok(())}+#[test_case(true; "feature enabled")]+#[test_case(false; "feature disabled")]+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn reasoning_effort_override_websocket_prewarm_preserves_baseline(+ feature_enabled: bool,+) -> anyhow::Result<()> {+ skip_if_no_network!(Ok(()));+ let server = responses::start_mock_server().await;+ let websocket = responses::start_websocket_server(vec![vec![+ vec![+ responses::ev_response_created("warmup"),+ responses::ev_completed("warmup"),+ ],+ vec![+ responses::ev_response_created("first"),+ responses::ev_completed("first"),+ ],+ ]])+ .await;+ let base_url = format!("{}/v1", websocket.uri());+ let test = override_builder()+ .with_config(move |config| {+ config.model_provider.base_url = Some(base_url);+ config.model_provider.supports_websockets = true;+ config+ .features+ .set_enabled(Feature::ReasoningEffortOverride, feature_enabled)+ .expect("configure reasoning effort overrides");+ })+ .build_with_auto_env(&server)+ .await?;+ let warmup = tokio::time::timeout(+ std::time::Duration::from_secs(/*secs*/ 10),+ websocket.wait_for_request(/*connection_index*/ 0, /*request_index*/ 0),+ )+ .await?;+ assert_eq!(warmup.body_json()["generate"], false);+ assert_eq!(warmup.body_json()["reasoning"]["effort"], "medium");+ submit_thread_settings(+ &test.codex,+ ThreadSettingsOverrides {+ effort: Some(Some(ReasoningEffort::High)),+ ..Default::default()+ },+ )+ .await?;+ test.submit_text_turn("first message after changing effort")+ .await?;++ let connection = websocket.single_connection();+ assert_eq!(connection.len(), 2);+ let first = connection[1].body_json();+ let updates = first["input"]+ .as_array()+ .expect("first turn input")+ .iter()+ .filter(|item| item["type"] == "configuration_update")+ .cloned()+ .collect::<Vec<_>>();+ assert_eq!(+ (first["reasoning"]["effort"].clone(), updates),+ if feature_enabled {+ (+ Value::from("medium"),+ vec![effort_update(ReasoningEffort::High)],+ )+ } else {+ (Value::from("high"), Vec::new())+ },+ );+ websocket.shutdown().await;+ Ok(())+}++#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn reasoning_effort_override_websocket_appends_then_replays_after_reconnect()+-> anyhow::Result<()> {+ skip_if_no_network!(Ok(()));+ let server = responses::start_mock_server().await;+ let websocket = responses::start_websocket_server(vec![+ vec![+ vec![+ responses::ev_response_created("warmup"),+ responses::ev_completed("warmup"),+ ],+ vec![+ responses::ev_response_created("first"),+ responses::ev_completed("first"),+ ],+ vec![+ responses::ev_response_created("changed"),+ responses::ev_completed("changed"),+ ],+ ],+ vec![vec![+ responses::ev_response_created("replayed"),+ responses::ev_completed("replayed"),+ ]],+ ])+ .await;+ let base_url = format!("{}/v1", websocket.uri());+ let test = override_builder()+ .with_config(move |config| {+ config.model_provider.base_url = Some(base_url);+ config.model_provider.supports_websockets = true;+ })+ .build_with_auto_env(&server)+ .await?;+ let warmup = tokio::time::timeout(+ std::time::Duration::from_secs(/*secs*/ 10),+ websocket.wait_for_request(/*connection_index*/ 0, /*request_index*/ 0),+ )+ .await?;+ assert_eq!(warmup.body_json()["generate"], false);+ test.submit_text_turn("first message").await?;+ submit_thread_settings(+ &test.codex,+ ThreadSettingsOverrides {+ effort: Some(Some(ReasoningEffort::High)),+ ..Default::default()+ },+ )+ .await?;+ test.submit_text_turn("changed effort").await?;+ test.submit_text_turn("unchanged effort after reconnect")+ .await?;++ let connections = websocket.connections();+ assert_eq!(connections.iter().map(Vec::len).collect::<Vec<_>>(), [3, 1]);+ let first = connections[0][1].body_json();+ let changed = connections[0][2].body_json();+ let replayed = connections[1][0].body_json();+ assert_eq!(changed["previous_response_id"], "first");+ assert_eq!(replayed.get("previous_response_id"), None);+ assert_eq!(+ responses::strip_response_item_ids_from_json(responses::strip_metadata_from_json(+ changed["input"].clone()+ )),+ serde_json::json!([+ message("user", "changed effort"),+ effort_update(ReasoningEffort::High),+ ])+ );+ assert_eq!(+ replayed["input"]+ .as_array()+ .expect("replayed input")+ .iter()+ .filter(|item| item["type"] == "configuration_update")+ .cloned()+ .collect::<Vec<_>>(),+ [effort_update(ReasoningEffort::High)]+ );+ assert_eq!(+ [&first, &changed, &replayed].map(|body| body["reasoning"]["effort"].clone()),+ [+ Value::from("medium"),+ Value::from("medium"),+ Value::from("medium")+ ]+ );+ websocket.shutdown().await;+ Ok(())+}+#[derive(Clone, Copy)]enum OverrideUnavailable {FeatureDisabled,@@ -314,3 +494,243 @@ async fn reasoning_effort_override_unavailable_uses_request_effort();Ok(())}++#[test_case(1, ReasoningEffort::High; "later turn keep changed selection")]+#[test_case(1, ReasoningEffort::Medium; "later turn match restored settings")]+#[test_case(2, ReasoningEffort::High; "through first turn")]+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn reasoning_effort_override_rollback_reestablishes_selected_effort(+ num_turns: u32,+ effort: ReasoningEffort,+) -> anyhow::Result<()> {+ skip_if_no_network!(Ok(()));+ #[derive(Default)]+ struct ThreadIdle {+ ready: Notify,+ }++ impl ThreadLifecycleContributor<Config> for ThreadIdle {+ fn on_thread_idle<'a>(&'a self, _input: ThreadIdleInput<'a>) -> ExtensionFuture<'a, ()> {+ Box::pin(async move {+ self.ready.notify_one();+ })+ }+ }++ let idle = Arc::new(ThreadIdle::default());+ let mut extensions = ExtensionRegistryBuilder::new();+ extensions.thread_lifecycle_contributor(idle.clone());+ let server = responses::start_mock_server().await;+ let first = responses::mount_sse_once(+ &server,+ responses::sse(vec![responses::ev_completed("first")]),+ )+ .await;+ let removed = responses::mount_sse_once(+ &server,+ responses::sse(vec![responses::ev_completed("removed")]),+ )+ .await;+ let replacement = responses::mount_sse_once(+ &server,+ responses::sse(vec![responses::ev_completed("replacement")]),+ )+ .await;+ let test = override_builder()+ .with_extensions(Arc::new(extensions.build()))+ .build_with_auto_env(&server)+ .await?;+ test.submit_text_turn("first turn").await?;+ timeout(Duration::from_secs(/*secs*/ 10), idle.ready.notified()).await?;+ submit_thread_settings(+ &test.codex,+ ThreadSettingsOverrides {+ effort: Some(Some(ReasoningEffort::High)),+ ..Default::default()+ },+ )+ .await?;+ test.submit_text_turn("removed turn").await?;+ // Completion can be delivered before the active slot is cleared. Wait for+ // actual idle so this test exercises effort replay, not rollback admission.+ timeout(Duration::from_secs(/*secs*/ 10), idle.ready.notified()).await?;+ test.codex.submit(Op::ThreadRollback { num_turns }).await?;+ let rollback = wait_for_event(&test.codex, |event| {+ matches!(event, EventMsg::ThreadRolledBack(_) | EventMsg::Error(_))+ })+ .await;+ let EventMsg::ThreadRolledBack(rollback) = rollback else {+ panic!("rollback failed: {rollback:?}");+ };+ assert_eq!(rollback.num_turns, num_turns);+ submit_thread_settings(+ &test.codex,+ ThreadSettingsOverrides {+ effort: Some(Some(effort.clone())),+ ..Default::default()+ },+ )+ .await?;+ test.submit_text_turn("replacement turn").await?;+ timeout(Duration::from_secs(/*secs*/ 10), idle.ready.notified()).await?;++ assert_eq!(+ effort_updates(&first.single_request()),+ [effort_update(ReasoningEffort::Medium)]+ );+ assert_eq!(+ effort_updates(&removed.single_request()),+ [+ effort_update(ReasoningEffort::Medium),+ effort_update(ReasoningEffort::High)+ ]+ );+ let request = replacement.single_request();+ assert_eq!(request.body_json()["reasoning"]["effort"], effort.as_str());+ let mut expected = if num_turns == 1 {+ vec![effort_update(ReasoningEffort::Medium)]+ } else {+ Vec::new()+ };+ expected.push(effort_update(effort.clone()));+ assert_eq!(effort_updates(&request), expected);+ let input = request.input();+ assert!(+ !input+ .iter()+ .any(|item| item["content"][0]["text"] == "removed turn")+ );+ let tail = responses::strip_response_item_ids_from_json(responses::strip_metadata_from_json(+ Value::Array(input[input.len() - 2..].to_vec()),+ ));+ assert_eq!(+ tail,+ serde_json::json!([+ message("user", "replacement turn"),+ effort_update(effort.clone()),+ ])+ );+ Ok(())+}++#[test_case(ReasoningEffort::Medium; "same selection")]+#[test_case(ReasoningEffort::High; "changed selection")]+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn reasoning_effort_override_model_switch_reestablishes_selected_effort(+ effort: ReasoningEffort,+) -> anyhow::Result<()> {+ skip_if_no_network!(Ok(()));+ let server = responses::start_mock_server().await;+ let first = responses::mount_sse_once(+ &server,+ responses::sse(vec![responses::ev_completed("first")]),+ )+ .await;+ let second = responses::mount_sse_once(+ &server,+ responses::sse(vec![responses::ev_completed("second")]),+ )+ .await;+ let test = override_builder()+ .with_model_info_override("gpt-5.4", |model| model.comp_hash = None)+ .with_model_info_override("gpt-5.5", |model| {+ model.comp_hash = None;+ model.use_responses_lite = true;+ })+ .with_model("gpt-5.4")+ .build_with_auto_env(&server)+ .await?;+ test.submit_text_turn("first model").await?;+ submit_thread_settings(+ &test.codex,+ ThreadSettingsOverrides {+ model: Some("gpt-5.5".to_string()),+ effort: Some(Some(effort.clone())),+ ..Default::default()+ },+ )+ .await?;+ test.submit_text_turn("second model").await?;+ assert_eq!(+ effort_updates(&first.single_request()),+ [effort_update(ReasoningEffort::Medium)]+ );+ let request = second.single_request();+ assert_eq!(+ effort_updates(&request),+ [+ effort_update(ReasoningEffort::Medium),+ effort_update(effort.clone())+ ]+ );+ assert_eq!(+ serde_json::json!([+ request.body_json()["model"],+ request.body_json()["reasoning"]["effort"]+ ]),+ serde_json::json!(["gpt-5.5", effort])+ );+ Ok(())+}++#[test_case(ReasoningEffort::High; "unchanged effort")]+#[test_case(ReasoningEffort::Medium; "changed effort")]+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn reasoning_effort_override_resume_refreshes_selected_effort(+ effort: ReasoningEffort,+) -> anyhow::Result<()> {+ skip_if_no_network!(Ok(()));+ let server = responses::start_mock_server().await;+ let first = responses::mount_sse_once(+ &server,+ responses::sse(vec![responses::ev_completed("first")]),+ )+ .await;+ let second = responses::mount_sse_once(+ &server,+ responses::sse(vec![responses::ev_completed("second")]),+ )+ .await;+ let resumed = responses::mount_sse_once(+ &server,+ responses::sse(vec![responses::ev_completed("resumed")]),+ )+ .await;+ let test = override_builder().build_with_auto_env(&server).await?;+ test.submit_text_turn("medium turn").await?;+ submit_thread_settings(+ &test.codex,+ ThreadSettingsOverrides {+ effort: Some(Some(ReasoningEffort::High)),+ ..Default::default()+ },+ )+ .await?;+ test.submit_text_turn("high turn").await?;+ let selected = effort.clone();+ let restarted = override_builder()+ .with_config(move |config| {+ config.model_reasoning_effort = Some(selected);+ })+ .restart(&server, &test)+ .await?;+ restarted.submit_text_turn("after resume").await?;++ assert_eq!(+ [first.single_request(), second.single_request()]+ .map(|request| request.body_json()["reasoning"]["effort"].clone()),+ [Value::from("medium"), Value::from("medium")]+ );+ let request = resumed.single_request();+ assert_eq!(request.body_json()["reasoning"]["effort"], effort.as_str());+ // Even an unchanged selection must refresh the override when replay invalidates the pin.+ assert_eq!(+ effort_updates(&request),+ [+ effort_update(ReasoningEffort::Medium),+ effort_update(ReasoningEffort::High),+ effort_update(effort.clone())+ ]+ );+ Ok(())+}