Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Preserve prewarmed reasoning effort across replay and early rollback (#44285)

felixxia-oai5d3f8752fc49
diff --git a/codex-rs/core/src/session/handlers.rs b/codex-rs/core/src/session/handlers.rs
index 33adc834c2..cf173b4688 100644
--- a/codex-rs/core/src/session/handlers.rs
+++ b/codex-rs/core/src/session/handlers.rs
@@ -20,6 +20,7 @@ use crate::context::GuardianApprovedAction;
use crate::context::NodeReplReviewEvidence;
use crate::review_prompts::resolve_review_request;
use crate::session::spawn_review_thread;
+use crate::state::ReasoningEffortPin;
use crate::tasks::CompactTask;
use crate::tasks::UserShellCommandMode;
use crate::tasks::UserShellCommandTask;
@@ -335,6 +336,14 @@ pub async fn thread_rollback(sess: &Arc<Session>, sub_id: String, num_turns: u32
.collect::<Vec<_>>();
sess.apply_rollout_reconstruction(turn_context.as_ref(), replay_items.as_slice())
.await;
+ {
+ let mut state = sess.state.lock().await;
+ // Keep the baseline while startup prewarm is retained for the first turn,
+ // including when its task has not established the pin yet.
+ if state.startup_prewarm.is_none() {
+ state.reasoning_effort_pin = ReasoningEffortPin::Unset;
+ }
+ }
sess.services
.thread_extension_data
.remove::<NodeReplReviewEvidence>();
diff --git a/codex-rs/core/src/session/mod.rs b/codex-rs/core/src/session/mod.rs
index 62f8766329..d813225a80 100644
--- a/codex-rs/core/src/session/mod.rs
+++ b/codex-rs/core/src/session/mod.rs
@@ -1636,8 +1636,6 @@ 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.rs
index fa585a51e8..5529a0d43f 100644
--- a/codex-rs/core/src/session/reasoning_effort.rs
+++ b/codex-rs/core/src/session/reasoning_effort.rs
@@ -1,7 +1,8 @@
//! Cache-preserving effort updates and the request-effort baseline for a context window.
//!
-//! Only trusted harness items establish overrides. Replay invalidates the runtime pin;
-//! successful compaction retires the overrides and allows a fresh request baseline.
+//! Only trusted harness items establish overrides. Replay and rollback preserve startup
+//! prewarm's baseline while it is retained; later rollback invalidates the runtime pin.
+//! Successful compaction retires the overrides and allows a fresh request baseline.
use super::session::Session;
use super::step_context::StepContext;
@@ -31,8 +32,8 @@ impl Session {
let should_skip = {
let mut state = self.state.lock().await;
if matches!(state.reasoning_effort_pin, ReasoningEffortPin::Compacted) {
- // Replay leaves the pin Unset. Only successful compaction allows the
- // request baseline to establish the selection without another update.
+ // Only successful compaction allows the request baseline to establish
+ // the selection without another update.
state
.reasoning_effort_pin
.pin(&settings.model_info.slug, effort.clone());
diff --git a/codex-rs/core/src/session/reasoning_effort_tests.rs b/codex-rs/core/src/session/reasoning_effort_tests.rs
index 18c976e54a..3ce2739c65 100644
--- a/codex-rs/core/src/session/reasoning_effort_tests.rs
+++ b/codex-rs/core/src/session/reasoning_effort_tests.rs
@@ -1,11 +1,61 @@
-//! Request-effort lookup must leave live state untouched during compaction.
+//! Request-effort pins across initial replay and compaction lookups.
use super::RequestEffortUsage;
+use crate::session::step_settings::ResolvedStepSettings;
use crate::session::tests::make_session_and_context;
use codex_features::Feature;
+use codex_history::InitialHistory;
+use codex_history::ResumedHistory;
+use codex_protocol::ThreadId;
use codex_protocol::openai_models::ReasoningEffort;
use pretty_assertions::assert_eq;
use std::sync::Arc;
+use test_case::test_case;
+
+#[test_case(InitialHistory::Forked(Vec::new()); "fork")]
+#[test_case(InitialHistory::Resumed(ResumedHistory {
+ conversation_id: ThreadId::default(),
+ history: Arc::new(Vec::new()),
+ rollout_path: None,
+}); "resume")]
+#[tokio::test]
+async fn initial_replay_preserves_prewarmed_effort(history: InitialHistory) {
+ let (mut session, turn_context) = make_session_and_context().await;
+ session
+ .features
+ .enable(Feature::ReasoningEffortOverride)
+ .unwrap();
+ let mut model_info = Arc::clone(&turn_context.initial_settings.model_info);
+ Arc::make_mut(&mut model_info).use_responses_lite = true;
+ let mut selected = turn_context.initial_settings.selected().clone();
+ selected.collaboration_mode.settings.reasoning_effort = Some(ReasoningEffort::Medium);
+ let prewarm_settings = ResolvedStepSettings::new(
+ Arc::new(selected.clone()),
+ Arc::clone(&model_info),
+ /*fast_mode_enabled*/ false,
+ );
+ // Force the ordering where prewarm pins its request before initial replay finishes.
+ assert_eq!(
+ session
+ .reasoning_effort_for_request(&prewarm_settings, RequestEffortUsage::Sampling)
+ .await,
+ Some(ReasoningEffort::Medium),
+ );
+ session.record_initial_history(history).await;
+
+ selected.collaboration_mode.settings.reasoning_effort = Some(ReasoningEffort::High);
+ let turn_settings = ResolvedStepSettings::new(
+ Arc::new(selected),
+ model_info,
+ /*fast_mode_enabled*/ false,
+ );
+ assert_eq!(
+ session
+ .reasoning_effort_for_request(&turn_settings, RequestEffortUsage::Sampling)
+ .await,
+ Some(ReasoningEffort::Medium),
+ );
+}
#[tokio::test]
async fn compaction_effort_lookup_preserves_pin_for_fallback_models() {
diff --git a/codex-rs/core/src/state/session.rs b/codex-rs/core/src/state/session.rs
index 175c1149ff..fa14b1da0f 100644
--- a/codex-rs/core/src/state/session.rs
+++ b/codex-rs/core/src/state/session.rs
@@ -30,8 +30,9 @@ use codex_protocol::protocol::TurnContextItem;
use codex_utils_output_truncation::TruncationPolicy;
use tokio_util::task::AbortOnDropHandle;
-/// Runtime request effort. A successful compaction can establish a fresh baseline, while
-/// startup and replay must explicitly re-establish the selected effort in surviving history.
+/// Runtime request effort, initially unset and established by prewarm or sampling.
+/// Rollback clears it after startup prewarm is consumed; successful compaction allows
+/// a fresh baseline without an override.
pub(crate) enum ReasoningEffortPin {
Unset,
Compacted,
diff --git a/codex-rs/core/tests/suite/reasoning_effort_override.rs b/codex-rs/core/tests/suite/reasoning_effort_override.rs
index 8a895c7130..e6420e0a14 100644
--- a/codex-rs/core/tests/suite/reasoning_effort_override.rs
+++ b/codex-rs/core/tests/suite/reasoning_effort_override.rs
@@ -1,5 +1,6 @@
//! Trusted reasoning-effort updates follow surviving history and the next turn's selected settings.
+use codex_core::ForkSnapshot;
use codex_core::RecoverTurnRequest;
use codex_core::StartIfIdleSubmission;
use codex_core::SuspendTurnOutcome;
@@ -372,11 +373,27 @@ async fn reasoning_effort_override_normalizes_ultra_before_comparing_updates(
Ok(())
}
-#[test_case(true; "feature enabled")]
-#[test_case(false; "feature disabled")]
+#[derive(Clone, Copy)]
+enum PrewarmStartup {
+ New,
+ Resume,
+ Fork,
+ ResumeThenRollback,
+ ForkThenRollback,
+}
+
+#[test_case(true, PrewarmStartup::New; "new thread feature enabled")]
+#[test_case(false, PrewarmStartup::New; "new thread feature disabled")]
+#[test_case(true, PrewarmStartup::Resume; "resumed thread feature enabled")]
+#[test_case(false, PrewarmStartup::Resume; "resumed thread feature disabled")]
+#[test_case(true, PrewarmStartup::Fork; "forked thread feature enabled")]
+#[test_case(false, PrewarmStartup::Fork; "forked thread feature disabled")]
+#[test_case(true, PrewarmStartup::ResumeThenRollback; "resumed thread rollback before first turn")]
+#[test_case(true, PrewarmStartup::ForkThenRollback; "forked thread rollback before first turn")]
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn reasoning_effort_override_websocket_prewarm_preserves_baseline(
feature_enabled: bool,
+ startup: PrewarmStartup,
) -> anyhow::Result<()> {
skip_if_no_network!(Ok(()));
let server = responses::start_mock_server().await;
@@ -392,17 +409,65 @@ async fn reasoning_effort_override_websocket_prewarm_preserves_baseline(
]])
.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 configure_prewarm = move |config: &mut Config| {
+ config.model_provider.base_url = Some(base_url.clone());
+ config.model_provider.supports_websockets = true;
+ config
+ .features
+ .set_enabled(Feature::ReasoningEffortOverride, feature_enabled)
+ .expect("configure reasoning effort overrides");
+ };
+ let mut builder = override_builder().with_config(configure_prewarm.clone());
+ let test = if !matches!(startup, PrewarmStartup::New) {
+ let previous_mock = responses::mount_sse_once(
+ &server,
+ responses::sse(vec![responses::ev_completed("previous")]),
+ )
+ .await;
+ let mut previous = override_builder()
+ .with_config(|config| {
+ config
+ .features
+ .disable(Feature::ReasoningEffortOverride)
+ .expect("disable reasoning effort overrides for source history");
+ config.model_provider.supports_websockets = false;
+ })
+ .build_with_auto_env(&server)
+ .await?;
+ previous.submit_text_turn("previous turn").await?;
+ assert_eq!(
+ previous_mock
+ .single_request()
+ .message_input_texts("user")
+ .last()
+ .map(String::as_str),
+ Some("previous turn"),
+ );
+ if matches!(
+ startup,
+ PrewarmStartup::Fork | PrewarmStartup::ForkThenRollback
+ ) {
+ previous.codex.shutdown_and_wait().await?;
+ let mut config = previous.config.clone();
+ configure_prewarm(&mut config);
+ let forked = previous
+ .thread_manager
+ .fork_thread(
+ ForkSnapshot::Interrupted,
+ codex_core::StartThreadOptions::new(config.clone()),
+ previous.codex.rollout_path().expect("rollout path"),
+ )
+ .await?;
+ previous.codex = forked.thread;
+ previous.session_configured = forked.session_configured;
+ previous.config = config;
+ previous
+ } else {
+ builder.restart(&server, &previous).await?
+ }
+ } else {
+ builder.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),
@@ -410,6 +475,23 @@ async fn reasoning_effort_override_websocket_prewarm_preserves_baseline(
.await?;
assert_eq!(warmup.body_json()["generate"], false);
assert_eq!(warmup.body_json()["reasoning"]["effort"], "medium");
+ if matches!(
+ startup,
+ PrewarmStartup::ResumeThenRollback | PrewarmStartup::ForkThenRollback
+ ) {
+ // Observing the warmup request guarantees that Medium is pinned before rollback.
+ test.codex
+ .submit(Op::ThreadRollback { num_turns: 1 })
+ .await?;
+ let rollback = wait_for_event(&test.codex, |event| {
+ matches!(event, EventMsg::ThreadRolledBack(_) | EventMsg::Error(_))
+ })
+ .await;
+ assert!(
+ matches!(rollback, EventMsg::ThreadRolledBack(_)),
+ "rollback failed: {rollback:?}",
+ );
+ }
submit_thread_settings(
&test.codex,
ThreadSettingsOverrides {