Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Preserve reasoning effort through compaction and reset it on success (#43796)

felixxia-oai35d9e4bc4d7a
diff --git a/codex-rs/core/src/compact.rs b/codex-rs/core/src/compact.rs
index 4aacc97d10..7c5b114283 100644
--- a/codex-rs/core/src/compact.rs
+++ b/codex-rs/core/src/compact.rs
@@ -17,6 +17,7 @@ use crate::responses_metadata::CodexResponsesRequestKind;
use crate::responses_metadata::CompactionTurnMetadata;
#[cfg(test)]
use crate::session::PreviousTurnSettings;
+use crate::session::RequestEffortUsage;
use crate::session::session::Session;
use crate::session::step_context::StepContext;
use crate::session::turn::get_last_assistant_message_from_turn;
@@ -771,7 +772,11 @@ async fn drain_to_completed(
prompt,
turn_context.model_info(),
&turn_context.session_telemetry,
- turn_context.reasoning_effort().cloned(),
+ sess.reasoning_effort_for_request(
+ &turn_context.initial_settings,
+ RequestEffortUsage::Compaction,
+ )
+ .await,
turn_context.reasoning_summary(),
turn_context.config.service_tier.clone(),
responses_metadata,
diff --git a/codex-rs/core/src/compact_remote_request.rs b/codex-rs/core/src/compact_remote_request.rs
index b6b418c7d0..faabcfb00d 100644
--- a/codex-rs/core/src/compact_remote_request.rs
+++ b/codex-rs/core/src/compact_remote_request.rs
@@ -7,6 +7,7 @@ use crate::client::CompactConversationRequestSettings;
use crate::compact::CompactionAnalyticsDetails;
use crate::responses_metadata::CodexResponsesRequestKind;
use crate::responses_metadata::CompactionTurnMetadata;
+use crate::session::RequestEffortUsage;
use crate::session::session::Session;
use crate::session::step_context::StepContext;
use codex_protocol::auth::AuthMode;
@@ -83,7 +84,12 @@ pub(super) async fn run_remote_compact_attempt(
turn_context.model_info(),
turn_state,
CompactConversationRequestSettings {
- effort: turn_context.reasoning_effort().cloned(),
+ effort: sess
+ .reasoning_effort_for_request(
+ &turn_context.initial_settings,
+ RequestEffortUsage::Compaction,
+ )
+ .await,
summary: turn_context.reasoning_summary(),
service_tier: if sess.services.auth_manager.auth_mode() == Some(AuthMode::ApiKey) {
None
diff --git a/codex-rs/core/src/compact_remote_v2.rs b/codex-rs/core/src/compact_remote_v2.rs
index f02e2db678..f68b8d47cc 100644
--- a/codex-rs/core/src/compact_remote_v2.rs
+++ b/codex-rs/core/src/compact_remote_v2.rs
@@ -26,6 +26,7 @@ use crate::responses_metadata::CompactionTurnMetadata;
use crate::responses_retry::ResponsesStreamRequest;
use crate::responses_retry::ResponsesStreamRetryState;
use crate::responses_retry::handle_retryable_response_stream_error;
+use crate::session::RequestEffortUsage;
use crate::session::session::Session;
use crate::session::step_context::StepContext;
use crate::session::turn_context::TurnContext;
@@ -388,7 +389,11 @@ async fn run_remote_compaction_request_v2(
prompt,
turn_context.model_info(),
&turn_context.session_telemetry,
- turn_context.reasoning_effort().cloned(),
+ sess.reasoning_effort_for_request(
+ &turn_context.initial_settings,
+ RequestEffortUsage::Compaction,
+ )
+ .await,
turn_context.reasoning_summary(),
step_context.settings.service_tier.clone(),
responses_metadata,
diff --git a/codex-rs/core/src/session/mod.rs b/codex-rs/core/src/session/mod.rs
index 5922f61e61..816f84ae0b 100644
--- a/codex-rs/core/src/session/mod.rs
+++ b/codex-rs/core/src/session/mod.rs
@@ -224,6 +224,8 @@ mod environment;
pub(crate) mod extension_metrics;
mod handlers;
mod inject;
+mod reasoning_effort;
+pub(crate) use reasoning_effort::RequestEffortUsage;
mod input_queue;
mod mcp;
mod mcp_prewarm;
@@ -231,7 +233,6 @@ mod mcp_refresh;
mod mcp_runtime;
pub(crate) mod multi_agents;
mod realtime_history;
-mod reasoning_effort;
mod retained_context;
mod review;
mod rollout_budget;
@@ -3831,6 +3832,7 @@ impl Session {
);
compacted_item.guardian_history = state.history.guardian_history_checkpoint();
compacted_item.retained_context = Some(state.history.retained_context().clone());
+ state.reasoning_effort_pin = ReasoningEffortPin::Compacted;
if let Some(world_state) = world_state_baseline {
let snapshot = world_state.snapshot();
world_state_item = Some(WorldStateItem::full(snapshot.clone().into_object()));
diff --git a/codex-rs/core/src/session/reasoning_effort.rs b/codex-rs/core/src/session/reasoning_effort.rs
index 568b7a14ad..9e61936063 100644
--- a/codex-rs/core/src/session/reasoning_effort.rs
+++ b/codex-rs/core/src/session/reasoning_effort.rs
@@ -1,7 +1,7 @@
-//! Cache-preserving effort updates and the original sampling request effort.
+//! Cache-preserving effort updates and the request-effort baseline for a context window.
//!
-//! Only trusted harness items establish overrides. Replay invalidates the runtime
-//! pin so the next send re-establishes the currently selected effort.
+//! Only trusted harness items establish overrides. Replay invalidates the runtime pin;
+//! successful compaction retires the overrides and allows a fresh request baseline.
use super::session::Session;
use super::step_context::StepContext;
@@ -14,6 +14,13 @@ use codex_protocol::models::ConfigurationReasoning;
use codex_protocol::models::ResponseItem;
use codex_protocol::openai_models::ReasoningEffort;
+/// Sampling can establish a pin; compaction must not change live state before it succeeds.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum RequestEffortUsage {
+ Sampling,
+ Compaction,
+}
+
impl Session {
/// Establishes the selected effort in surviving history, independent of replayed settings.
pub(crate) async fn record_reasoning_effort_override(&self, step_context: &StepContext) {
@@ -22,7 +29,14 @@ impl Session {
return;
};
let should_skip = {
- let state = self.state.lock().await;
+ 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.
+ state
+ .reasoning_effort_pin
+ .pin(&settings.model_info.slug, effort.clone());
+ }
let established_effort =
state
.history
@@ -68,26 +82,41 @@ impl Session {
.await;
}
- /// Reuses the original request effort while updates carry the selected effort.
+ /// Sampling and compaction share the original request effort for this context window.
pub(crate) async fn reasoning_effort_for_request(
&self,
settings: &ResolvedStepSettings,
+ usage: RequestEffortUsage,
) -> Option<ReasoningEffort> {
let selected_effort = settings.reasoning_effort().cloned();
if !self.enabled(Feature::ReasoningEffortOverride) {
return selected_effort;
}
+ if usage == RequestEffortUsage::Compaction
+ && let Some(pinned) = self
+ .state
+ .lock()
+ .await
+ .reasoning_effort_pin
+ .get(&settings.model_info.slug)
+ {
+ return Some(pinned);
+ }
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;
+ if usage == RequestEffortUsage::Sampling {
+ state.reasoning_effort_pin = ReasoningEffortPin::Unset;
+ }
return selected_effort;
};
- Some(
- state
+ Some(match usage {
+ RequestEffortUsage::Sampling => state
.reasoning_effort_pin
.pin(&settings.model_info.slug, effort),
- )
+ // Failed compaction and fallback-model lookups must not mutate the live pin.
+ RequestEffortUsage::Compaction => effort,
+ })
}
async fn effort_for_configuration_update(
@@ -111,3 +140,7 @@ impl Session {
Some(effort)
}
}
+
+#[cfg(test)]
+#[path = "reasoning_effort_tests.rs"]
+mod tests;
diff --git a/codex-rs/core/src/session/reasoning_effort_tests.rs b/codex-rs/core/src/session/reasoning_effort_tests.rs
new file mode 100644
index 0000000000..18c976e54a
--- /dev/null
+++ b/codex-rs/core/src/session/reasoning_effort_tests.rs
@@ -0,0 +1,45 @@
+//! Request-effort lookup must leave live state untouched during compaction.
+
+use super::RequestEffortUsage;
+use crate::session::tests::make_session_and_context;
+use codex_features::Feature;
+use codex_protocol::openai_models::ReasoningEffort;
+use pretty_assertions::assert_eq;
+use std::sync::Arc;
+
+#[tokio::test]
+async fn compaction_effort_lookup_preserves_pin_for_fallback_models() {
+ let (mut session, turn_context) = make_session_and_context().await;
+ session
+ .features
+ .enable(Feature::ReasoningEffortOverride)
+ .unwrap();
+ session
+ .state
+ .lock()
+ .await
+ .reasoning_effort_pin
+ .pin("original", ReasoningEffort::Low);
+ let mut settings = (*turn_context.initial_settings).clone();
+ let effort = ReasoningEffort::Medium;
+ let model = Arc::make_mut(&mut settings.model_info);
+ model.slug = "fallback".to_string();
+ model.use_responses_lite = true;
+ model.default_reasoning_level = Some(effort.clone());
+
+ assert_eq!(
+ session
+ .reasoning_effort_for_request(&settings, RequestEffortUsage::Compaction)
+ .await,
+ Some(effort)
+ );
+ assert_eq!(
+ session
+ .state
+ .lock()
+ .await
+ .reasoning_effort_pin
+ .get("original"),
+ Some(ReasoningEffort::Low)
+ );
+}
diff --git a/codex-rs/core/src/session/turn.rs b/codex-rs/core/src/session/turn.rs
index 93216d7c83..f9bac7c153 100644
--- a/codex-rs/core/src/session/turn.rs
+++ b/codex-rs/core/src/session/turn.rs
@@ -2313,8 +2313,11 @@ async fn try_run_sampling_request(
prompt,
&step_context.settings.model_info,
&step_context.session_telemetry,
- sess.reasoning_effort_for_request(&step_context.settings)
- .await,
+ sess.reasoning_effort_for_request(
+ &step_context.settings,
+ super::RequestEffortUsage::Sampling,
+ )
+ .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.rs
index 02ce6abf1e..e0dff00a6f 100644
--- a/codex-rs/core/src/session_startup_prewarm.rs
+++ b/codex-rs/core/src/session_startup_prewarm.rs
@@ -15,6 +15,7 @@ use crate::client::ModelClientSession;
use crate::guardian::routes_approval_to_guardian;
use crate::responses_metadata::CodexResponsesRequestKind;
use crate::session::INITIAL_SUBMIT_ID;
+use crate::session::RequestEffortUsage;
use crate::session::session::Session;
use crate::session::turn::build_prompt;
use codex_features::Feature;
@@ -325,7 +326,7 @@ async fn schedule_startup_prewarm_inner(
&step_context.settings.model_info,
&step_context.session_telemetry,
session
- .reasoning_effort_for_request(&step_context.settings)
+ .reasoning_effort_for_request(&step_context.settings, RequestEffortUsage::Sampling)
.await,
step_context.settings.reasoning_summary,
step_context.settings.service_tier.clone(),
diff --git a/codex-rs/core/src/state/session.rs b/codex-rs/core/src/state/session.rs
index 901a5a5aca..175c1149ff 100644
--- a/codex-rs/core/src/state/session.rs
+++ b/codex-rs/core/src/state/session.rs
@@ -30,9 +30,11 @@ 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.
+/// 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.
pub(crate) enum ReasoningEffortPin {
Unset,
+ Compacted,
Active {
model: String,
effort: ReasoningEffort,
@@ -46,7 +48,7 @@ impl ReasoningEffortPin {
model: pinned_model,
effort,
} if pinned_model == model => Some(effort.clone()),
- Self::Unset | Self::Active { .. } => None,
+ Self::Unset | Self::Compacted | Self::Active { .. } => None,
}
}
diff --git a/codex-rs/core/tests/suite/compact.rs b/codex-rs/core/tests/suite/compact.rs
index 09ae3e2cdd..d244368d4f 100644
--- a/codex-rs/core/tests/suite/compact.rs
+++ b/codex-rs/core/tests/suite/compact.rs
@@ -987,6 +987,129 @@ async fn manual_compact_uses_custom_prompt() {
}
}
+#[test_case::test_case(false; "success")]
+#[test_case::test_case(true; "failure")]
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn reasoning_effort_override_remote_v2_compaction_resets_pinned_effort(
+ fail_compaction: bool,
+) -> Result<()> {
+ use codex_protocol::openai_models::ReasoningEffort;
+
+ skip_if_no_network!(Ok(()));
+
+ let server = start_mock_server().await;
+ let request_log = mount_sse_sequence(
+ &server,
+ vec![
+ sse(vec![
+ ev_assistant_message("m1", "first reply"),
+ ev_completed("r1"),
+ ]),
+ sse(vec![
+ ev_assistant_message("m2", "second reply"),
+ ev_completed("r2"),
+ ]),
+ if fail_compaction {
+ sse_failed("r3", "server_error", "compaction failed")
+ } else {
+ remote_v2_compaction_response()
+ },
+ sse(vec![
+ ev_assistant_message("m4", "third reply"),
+ ev_completed("r4"),
+ ]),
+ ],
+ )
+ .await;
+
+ let test = test_codex()
+ .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
+ .with_model_info_override("gpt-5.4", |model| {
+ model.use_responses_lite = true;
+ })
+ .with_config(move |config| {
+ config
+ .features
+ .enable(Feature::RemoteCompactionV2)
+ .expect("enable remote compaction v2");
+ config.model_provider.stream_max_retries = Some(0);
+ config.model_reasoning_effort = Some(ReasoningEffort::Medium);
+ config
+ .features
+ .enable(Feature::ReasoningEffortOverride)
+ .expect("test config should allow feature update");
+ set_test_compact_prompt(config);
+ })
+ .build_with_auto_env(&server)
+ .await?;
+
+ test.submit_text_turn("first message").await?;
+ core_test_support::submit_thread_settings(
+ &test.codex,
+ ThreadSettingsOverrides {
+ effort: Some(Some(ReasoningEffort::High)),
+ ..Default::default()
+ },
+ )
+ .await?;
+ test.submit_text_turn("second message").await?;
+ test.codex.submit(Op::Compact).await?;
+ if fail_compaction {
+ wait_for_event(&test.codex, |event| matches!(event, EventMsg::Error(_))).await;
+ }
+ wait_for_event(&test.codex, |event| {
+ matches!(event, EventMsg::TurnComplete(_))
+ })
+ .await;
+ test.submit_text_turn("after compaction").await?;
+
+ let requests = request_log.requests();
+ assert_eq!(requests.len(), 4);
+ let first_body = requests[0].body_json();
+ let second_body = requests[1].body_json();
+ let post_compaction_body = requests[3].body_json();
+ assert_eq!(first_body["reasoning"]["effort"], "medium");
+ assert_eq!(second_body["reasoning"]["effort"], "medium");
+ assert_eq!(requests[2].body_json()["reasoning"]["effort"], "medium");
+ assert_eq!(
+ post_compaction_body["reasoning"]["effort"],
+ if fail_compaction { "medium" } else { "high" }
+ );
+ let updates = requests
+ .iter()
+ .map(|request| {
+ request
+ .input()
+ .into_iter()
+ .filter(|item| item["type"] == "configuration_update")
+ .collect::<Vec<_>>()
+ })
+ .collect::<Vec<_>>();
+ let medium = json!({
+ "type": "configuration_update",
+ "reasoning": {"effort": "medium"},
+ });
+ let high = json!({
+ "type": "configuration_update",
+ "reasoning": {"effort": "high"},
+ });
+ assert_eq!(
+ updates,
+ [
+ vec![medium.clone()],
+ vec![medium.clone(), high.clone()],
+ vec![medium.clone(), high.clone()],
+ if fail_compaction {
+ vec![medium, high]
+ } else {
+ vec![]
+ },
+ ]
+ );
+
+ Ok(())
+}
+
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn manual_compact_records_durable_and_local_token_usage() {
skip_if_no_network!();
diff --git a/codex-rs/core/tests/suite/reasoning_effort_override.rs b/codex-rs/core/tests/suite/reasoning_effort_override.rs
index fc834a9356..172d420230 100644
--- a/codex-rs/core/tests/suite/reasoning_effort_override.rs
+++ b/codex-rs/core/tests/suite/reasoning_effort_override.rs
@@ -6,6 +6,7 @@ use codex_extension_api::ExtensionRegistryBuilder;
use codex_extension_api::ThreadIdleInput;
use codex_extension_api::ThreadLifecycleContributor;
use codex_features::Feature;
+use codex_login::CodexAuth;
use codex_protocol::openai_models::ReasoningEffort;
use codex_protocol::openai_models::ReasoningEffortPreset;
use codex_protocol::protocol::EventMsg;
@@ -25,6 +26,7 @@ use std::time::Duration;
use test_case::test_case;
use tokio::sync::Notify;
use tokio::time::timeout;
+use wiremock::ResponseTemplate;
fn override_builder() -> TestCodexBuilder {
test_codex()
@@ -495,6 +497,101 @@ async fn reasoning_effort_override_unavailable_uses_request_effort(
Ok(())
}
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn reasoning_effort_override_disabled_on_resume_retires_update_at_compaction()
+-> anyhow::Result<()> {
+ skip_if_no_network!(Ok(()));
+ let server = responses::start_mock_server().await;
+ let mut mocks = Vec::new();
+ for (id, reply) in [
+ ("initial", "initial reply"),
+ ("resumed", "resumed reply"),
+ ("after", "after compaction reply"),
+ ] {
+ mocks.push(
+ responses::mount_sse_once(
+ &server,
+ responses::sse(vec![
+ responses::ev_assistant_message(id, reply),
+ responses::ev_completed(id),
+ ]),
+ )
+ .await,
+ );
+ }
+ let compact = responses::mount_compact_json_once(
+ &server,
+ serde_json::json!({
+ "output": [{"type": "compaction", "encrypted_content": "compacted-history"}]
+ }),
+ )
+ .await;
+ let initial = override_builder().build_with_auto_env(&server).await?;
+ initial.submit_text_turn("before resume").await?;
+ let chatgpt_base_url = format!("{}/backend-api", server.uri());
+ let resumed = override_builder()
+ .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
+ .with_config(move |config| {
+ config
+ .features
+ .disable(Feature::ReasoningEffortOverride)
+ .expect("disable overrides");
+ config
+ .features
+ .disable(Feature::RemoteCompactionV2)
+ .expect("disable remote compaction v2");
+ config.model_reasoning_effort = Some(ReasoningEffort::High);
+ config.chatgpt_base_url = chatgpt_base_url;
+ })
+ .restart(&server, &initial)
+ .await?;
+ resumed.submit_text_turn("after resume").await?;
+ resumed.codex.submit(Op::Compact).await?;
+ wait_for_event(&resumed.codex, |event| {
+ matches!(event, EventMsg::TurnComplete(_))
+ })
+ .await;
+ resumed.submit_text_turn("after compaction").await?;
+
+ let requests = [
+ mocks[0].single_request(),
+ mocks[1].single_request(),
+ compact.single_request(),
+ mocks[2].single_request(),
+ ];
+ assert_eq!(
+ requests
+ .iter()
+ .map(|request| (
+ request.body_json()["reasoning"]["effort"].clone(),
+ effort_updates(request),
+ ))
+ .collect::<Vec<_>>(),
+ [
+ (
+ Value::from("medium"),
+ vec![effort_update(ReasoningEffort::Medium)]
+ ),
+ (
+ Value::from("high"),
+ vec![effort_update(ReasoningEffort::Medium)]
+ ),
+ (
+ Value::from("high"),
+ vec![effort_update(ReasoningEffort::Medium)]
+ ),
+ (Value::from("high"), Vec::new()),
+ ],
+ );
+ assert!(
+ requests[3]
+ .input()
+ .iter()
+ .any(|item| item["type"] == "compaction")
+ );
+ 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")]
@@ -734,3 +831,261 @@ async fn reasoning_effort_override_resume_refreshes_selected_effort(
);
Ok(())
}
+
+#[test_case(false; "success")]
+#[test_case(true; "failure")]
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn reasoning_effort_override_remote_v1_compaction_uses_pin(
+ fail_compaction: bool,
+) -> 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 after = responses::mount_sse_once(
+ &server,
+ responses::sse(vec![responses::ev_completed("after")]),
+ )
+ .await;
+ let unchanged = responses::mount_sse_once(
+ &server,
+ responses::sse(vec![responses::ev_completed("unchanged")]),
+ )
+ .await;
+ let changed = responses::mount_sse_once(
+ &server,
+ responses::sse(vec![responses::ev_completed("changed")]),
+ )
+ .await;
+ let compact = responses::mount_compact_response_once(
+ &server,
+ if fail_compaction {
+ ResponseTemplate::new(400).set_body_json(serde_json::json!({
+ "error": {"code": "invalid_request_error", "message": "compaction failed"}
+ }))
+ } else {
+ ResponseTemplate::new(200).set_body_json(serde_json::json!({
+ "output": [{"type": "compaction", "encrypted_content": "compacted-history"}]
+ }))
+ },
+ )
+ .await;
+ let chatgpt_base_url = format!("{}/backend-api", server.uri());
+ let test = override_builder()
+ .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
+ .with_config(move |config| {
+ config.chatgpt_base_url = chatgpt_base_url;
+ config
+ .features
+ .disable(Feature::RemoteCompactionV2)
+ .expect("disable remote compaction v2");
+ })
+ .build_with_auto_env(&server)
+ .await?;
+ test.submit_text_turn("first").await?;
+ submit_thread_settings(
+ &test.codex,
+ ThreadSettingsOverrides {
+ effort: Some(Some(ReasoningEffort::High)),
+ ..Default::default()
+ },
+ )
+ .await?;
+ test.codex.submit(Op::Compact).await?;
+ if fail_compaction {
+ wait_for_event(&test.codex, |event| matches!(event, EventMsg::Error(_))).await;
+ }
+ wait_for_event(&test.codex, |event| {
+ matches!(event, EventMsg::TurnComplete(_))
+ })
+ .await;
+ test.submit_text_turn("after compaction").await?;
+ test.submit_text_turn("unchanged effort").await?;
+ submit_thread_settings(
+ &test.codex,
+ ThreadSettingsOverrides {
+ effort: Some(Some(ReasoningEffort::Low)),
+ ..Default::default()
+ },
+ )
+ .await?;
+ test.submit_text_turn("changed effort").await?;
+ let medium = effort_update(ReasoningEffort::Medium);
+ let after_updates = if fail_compaction {
+ vec![medium.clone(), effort_update(ReasoningEffort::High)]
+ } else {
+ Vec::new()
+ };
+ let mut changed_updates = after_updates.clone();
+ changed_updates.push(effort_update(ReasoningEffort::Low));
+ let after_effort = Value::from(if fail_compaction { "medium" } else { "high" });
+ assert_eq!(
+ [
+ first.single_request(),
+ compact.single_request(),
+ after.single_request(),
+ unchanged.single_request(),
+ changed.single_request(),
+ ]
+ .map(|request| (
+ request.body_json()["reasoning"]["effort"].clone(),
+ effort_updates(&request),
+ )),
+ [
+ (Value::from("medium"), vec![medium.clone()]),
+ (Value::from("medium"), vec![medium]),
+ (after_effort.clone(), after_updates.clone()),
+ (after_effort.clone(), after_updates),
+ (after_effort, changed_updates),
+ ],
+ );
+ Ok(())
+}
+
+#[test_case(false; "remote v1")]
+#[test_case(true; "remote v2")]
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn reasoning_effort_override_compaction_fallback_uses_each_models_effort(
+ remote_v2: bool,
+) -> 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 compaction = serde_json::json!({
+ "type": "compaction", "encrypted_content": "fallback-summary"
+ });
+ let failure = ResponseTemplate::new(/*s*/ 400).set_body_json(serde_json::json!({
+ "error": {"message": "previous model cannot compact this history"}
+ }));
+ let compactions = if remote_v2 {
+ responses::mount_response_sequence(
+ &server,
+ vec![
+ failure,
+ responses::sse_response(responses::sse(vec![
+ serde_json::json!({"type": "response.output_item.done", "item": compaction}),
+ responses::ev_completed("fallback"),
+ ])),
+ ],
+ )
+ .await
+ } else {
+ responses::mount_compact_response_sequence(
+ &server,
+ vec![
+ failure,
+ ResponseTemplate::new(/*s*/ 200).set_body_json(serde_json::json!({
+ "output": [compaction]
+ })),
+ ],
+ )
+ .await
+ };
+ let after = responses::mount_sse_once(
+ &server,
+ responses::sse(vec![responses::ev_completed("after")]),
+ )
+ .await;
+ let chatgpt_base_url = format!("{}/backend-api", server.uri());
+ let test = override_builder()
+ .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
+ .with_model_info_override("gpt-5.4", |model| {
+ model.comp_hash = Some("original".to_string());
+ })
+ .with_model_info_override("gpt-5.2", |model| {
+ model.comp_hash = Some("fallback".to_string());
+ model.use_responses_lite = true;
+ })
+ .with_model("gpt-5.4")
+ .with_config(move |config| {
+ config.chatgpt_base_url = chatgpt_base_url;
+ config.model_provider.stream_max_retries = Some(0);
+ if remote_v2 {
+ config
+ .features
+ .enable(Feature::RemoteCompactionV2)
+ .expect("enable remote compaction v2");
+ } else {
+ config
+ .features
+ .disable(Feature::RemoteCompactionV2)
+ .expect("disable remote compaction v2");
+ }
+ })
+ .build_with_auto_env(&server)
+ .await?;
+ test.submit_text_turn("first").await?;
+ submit_thread_settings(
+ &test.codex,
+ ThreadSettingsOverrides {
+ effort: Some(Some(ReasoningEffort::High)),
+ ..Default::default()
+ },
+ )
+ .await?;
+ test.submit_text_turn("second").await?;
+ submit_thread_settings(
+ &test.codex,
+ ThreadSettingsOverrides {
+ model: Some("gpt-5.2".to_string()),
+ ..Default::default()
+ },
+ )
+ .await?;
+ test.submit_text_turn("switch model").await?;
+
+ let compaction_requests = compactions.requests();
+ assert_eq!(compaction_requests.len(), 2);
+ let requests = [
+ first.single_request(),
+ second.single_request(),
+ compaction_requests[0].clone(),
+ compaction_requests[1].clone(),
+ after.single_request(),
+ ];
+ assert_eq!(
+ requests.each_ref().map(|request| {
+ let body = request.body_json();
+ serde_json::json!([body["model"], body["reasoning"]["effort"]])
+ }),
+ [
+ serde_json::json!(["gpt-5.4", "medium"]),
+ serde_json::json!(["gpt-5.4", "medium"]),
+ serde_json::json!(["gpt-5.4", "medium"]),
+ serde_json::json!(["gpt-5.2", "high"]),
+ serde_json::json!(["gpt-5.2", "high"]),
+ ]
+ );
+ assert_eq!(
+ requests.each_ref().map(effort_updates),
+ [
+ vec![effort_update(ReasoningEffort::Medium)],
+ vec![
+ effort_update(ReasoningEffort::Medium),
+ effort_update(ReasoningEffort::High)
+ ],
+ vec![
+ effort_update(ReasoningEffort::Medium),
+ effort_update(ReasoningEffort::High)
+ ],
+ vec![
+ effort_update(ReasoningEffort::Medium),
+ effort_update(ReasoningEffort::High)
+ ],
+ vec![],
+ ]
+ );
+ Ok(())
+}