Lightweight coding agent that runs in your terminal
Rust
Avoid duplicate reasoning effort updates during turn recovery (#44276)
felixxia-oaif5c5d9b2b093
diff --git a/codex-rs/core/src/session/reasoning_effort.rs b/codex-rs/core/src/session/reasoning_effort.rsindex ec945f94a3..fa585a51e8 100644--- a/codex-rs/core/src/session/reasoning_effort.rs+++ b/codex-rs/core/src/session/reasoning_effort.rs@@ -37,31 +37,36 @@ impl Session {.reasoning_effort_pin.pin(&settings.model_info.slug, effort.clone());}- let established_effort =- state- .history- .annotated_items()- .iter()- .rev()- .find_map(|envelope| {- if !envelope- .metadata- .as_ref()- .is_some_and(|metadata| metadata.harness_authored_configuration)- {- return None;- }- match &envelope.item {- ResponseItem::ConfigurationUpdate { reasoning } => {- Some(&reasoning.effort)- }- _ => None,+ let latest_override = state+ .history+ .annotated_items()+ .iter()+ .rev()+ .enumerate()+ .find_map(|(index, envelope)| {+ if !envelope+ .metadata+ .as_ref()+ .is_some_and(|metadata| metadata.harness_authored_configuration)+ {+ return None;+ }+ match &envelope.item {+ ResponseItem::ConfigurationUpdate { reasoning } => {+ Some((index, &reasoning.effort))}- });- state- .reasoning_effort_pin- .get(&settings.model_info.slug)- .is_some_and(|pinned| established_effort.unwrap_or(&pinned) == &effort)+ _ => None,+ }+ });+ // Recovery adds no user message. Reuse a matching trusted tail update even+ // before this runtime establishes its pin, rather than append adjacent updates.+ latest_override.is_some_and(|(index, established)| index == 0 && established == &effort)+ || state+ .reasoning_effort_pin+ .get(&settings.model_info.slug)+ .is_some_and(|pinned| {+ latest_override.map_or(&pinned, |(_, established)| established) == &effort+ })};if should_skip {return;diff --git a/codex-rs/core/tests/suite/reasoning_effort_override.rs b/codex-rs/core/tests/suite/reasoning_effort_override.rsindex 3d0a966e9f..8a895c7130 100644--- a/codex-rs/core/tests/suite/reasoning_effort_override.rs+++ b/codex-rs/core/tests/suite/reasoning_effort_override.rs@@ -1,5 +1,10 @@//! Trusted reasoning-effort updates follow surviving history and the next turn's selected settings.+use codex_core::RecoverTurnRequest;+use codex_core::StartIfIdleSubmission;+use codex_core::SuspendTurnOutcome;+use codex_core::TurnInputRequest;+use codex_core::TurnInputSubmission;use codex_core::config::Config;use codex_extension_api::ExtensionFuture;use codex_extension_api::ExtensionRegistryBuilder;@@ -7,11 +12,13 @@ use codex_extension_api::ThreadIdleInput;use codex_extension_api::ThreadLifecycleContributor;use codex_features::Feature;use codex_login::CodexAuth;+use codex_protocol::models::ResponseItem;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 codex_protocol::user_input::UserInput;use core_test_support::responses;use core_test_support::responses::ResponsesRequest;use core_test_support::skip_if_no_network;@@ -65,6 +72,101 @@ fn message(role: &str, text: &str) -> Value {})}+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn reasoning_effort_override_recovery_reuses_trusted_tail_update() -> anyhow::Result<()> {+ skip_if_no_network!(Ok(()));+ let server = responses::start_mock_server().await;+ // Keep the turn active without allowing any model output after the update.+ responses::mount_response_once(+ &server,+ responses::sse_response(responses::sse(vec![responses::ev_completed("suspended")]))+ .set_delay(Duration::from_secs(/*secs*/ 60)),+ )+ .await;+ let builder = || {+ override_builder().with_config(|config| {+ config.model_reasoning_effort = Some(ReasoningEffort::High);+ // Recovery must work without a prewarm establishing a runtime pin.+ config.model_provider.supports_websockets = false;+ })+ };+ let test = builder().build_with_auto_env(&server).await?;+ let submission = test+ .codex+ .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {+ text: "recover this turn".to_string(),+ text_elements: Vec::new(),+ }]))+ .await?;+ let TurnInputSubmission::Started { turn_id } = submission else {+ panic!("expected a new turn");+ };+ wait_for_event(&test.codex, |event| {+ matches!(event, EventMsg::RawResponseItem(raw)+ if matches!(&raw.item, ResponseItem::ConfigurationUpdate { .. }))+ })+ .await;+ let thread_settings = test.codex.restorable_thread_settings().await;+ assert_eq!(+ test.codex.suspend_turn_and_shutdown().await?,+ SuspendTurnOutcome::Suspended {+ turn_id: turn_id.clone(),+ },+ );+ let rollout_path = test.codex.rollout_path().expect("rollout path");+ test.thread_manager+ .remove_thread(&test.session_configured.thread_id)+ .await+ .expect("unload suspended thread");++ let recovery_server = responses::start_mock_server().await;+ let mock = responses::mount_sse_once(+ &recovery_server,+ responses::sse(vec![responses::ev_completed("recovered")]),+ )+ .await;+ let cwd = test.config.cwd.clone();+ let mut resume_builder = builder().with_config(move |config| config.cwd = cwd);+ if let Some(url) = test.executor_environment().exec_server_url() {+ resume_builder = resume_builder.with_exec_server_url(url);+ }+ let resumed = resume_builder+ .resume(&recovery_server, Arc::clone(&test.home), rollout_path)+ .await?;+ resumed+ .codex+ .restore_thread_settings(thread_settings)+ .await?;+ assert_eq!(+ resumed+ .codex+ .recover_turn_if_idle(RecoverTurnRequest {+ turn_id: turn_id.clone(),+ thread_settings: Default::default(),+ trace: None,+ cyber_access_program: None,+ })+ .await?,+ StartIfIdleSubmission::Started { turn_id },+ );+ wait_for_event(&resumed.codex, |event| {+ matches!(event, EventMsg::TurnComplete(_))+ })+ .await;++ let request = mock.single_request();+ assert_eq!(+ effort_updates(&request),+ vec![effort_update(ReasoningEffort::High)]+ );+ assert_eq!(+ request.input().last(),+ Some(&effort_update(ReasoningEffort::High))+ );+ assert_eq!(request.body_json()["reasoning"]["effort"], "high");+ Ok(())+}+#[test_case(ReasoningEffort::High; "high to persistent and back")]#[test_case(ReasoningEffort::Persistent; "persistent to high and back")]#[tokio::test(flavor = "multi_thread", worker_threads = 2)]