Lightweight coding agent that runs in your terminal
Rust
Fix first-turn model switching and rollback (#37260)
jifa17da5e6e4a5
diff --git a/codex-rs/core/src/context_manager/history.rs b/codex-rs/core/src/context_manager/history.rsindex a3cf288ee5..d900ec9813 100644--- a/codex-rs/core/src/context_manager/history.rs+++ b/codex-rs/core/src/context_manager/history.rs@@ -1,4 +1,5 @@use crate::context::ContextualUserFragment;+use crate::context::ModelSwitchInstructions;use crate::context::world_state::WorldState;use crate::context::world_state::WorldStateSnapshot;use crate::context_manager::normalize;@@ -245,7 +246,30 @@ impl ContextManager {cut_idx =self.trim_pre_turn_context_updates(&snapshot, first_instruction_turn_idx, cut_idx);- self.replace(snapshot[..cut_idx].to_vec());+ let mut retained_items = snapshot[..cut_idx].to_vec();+ if cut_idx == first_instruction_turn_idx+ && let Some(first_turn_id) = snapshot[first_instruction_turn_idx].turn_id()+ {+ retained_items.retain_mut(|item| {+ if item.turn_id() == Some(first_turn_id)+ && let ResponseItem::Message { role, content, .. } = item+ && role == "developer"+ {+ content.retain(|content| {+ !matches!(+ content,+ ContentItem::InputText { text }+ if ModelSwitchInstructions::matches_text(text)+ )+ });+ !content.is_empty()+ } else {+ true+ }+ });+ }++ self.replace(retained_items);}pub(crate) fn update_token_info(diff --git a/codex-rs/core/src/session/mod.rs b/codex-rs/core/src/session/mod.rsindex 96021f37a3..f69ff50476 100644--- a/codex-rs/core/src/session/mod.rs+++ b/codex-rs/core/src/session/mod.rs@@ -729,6 +729,7 @@ impl Session {installation_id,auth_manager.clone(),models_manager.clone(),+ model_info,exec_policy,tx_event.clone(),agent_status_tx.clone(),diff --git a/codex-rs/core/src/session/session.rs b/codex-rs/core/src/session/session.rsindex e5de254b07..522055b7b2 100644--- a/codex-rs/core/src/session/session.rs+++ b/codex-rs/core/src/session/session.rs@@ -515,6 +515,7 @@ impl Session {installation_id: String,auth_manager: Arc<AuthManager>,models_manager: SharedModelsManager,+ model_info: ModelInfo,exec_policy: Arc<ExecPolicyManager>,tx_event: Sender<Event>,agent_status: watch::Sender<AgentStatus>,@@ -999,10 +1000,14 @@ impl Session {session_configuration.thread_name = thread_name.clone();validate_config_lock_if_configured(&session_configuration).await?;export_config_lock_if_configured(&session_configuration, thread_id).await?;- let state = SessionState::new_with_auto_compact_window_ids(+ let mut state = SessionState::new_with_auto_compact_window_ids(session_configuration.clone(),initial_auto_compact_window_ids,);+ state.base_instructions_model = (config.base_instructions.is_none()+ && session_configuration.base_instructions+ == model_info.get_model_instructions(config.personality))+ .then(|| model_info.slug.clone());let managed_network_requirements_configured = config.config_layer_stack.requirements_toml()diff --git a/codex-rs/core/src/session/tests.rs b/codex-rs/core/src/session/tests.rsindex be87b859c7..3a0ae6850a 100644--- a/codex-rs/core/src/session/tests.rs+++ b/codex-rs/core/src/session/tests.rs@@ -5581,6 +5581,7 @@ async fn session_new_fails_when_zsh_fork_enabled_without_packaged_zsh() {"11111111-1111-4111-8111-111111111111".to_string(),auth_manager,models_manager,+ model_info,Arc::new(ExecPolicyManager::default()),tx_event,agent_status_tx,@@ -5995,6 +5996,7 @@ async fn make_session_with_config_and_rx("11111111-1111-4111-8111-111111111111".to_string(),auth_manager,models_manager,+ model_info,Arc::new(ExecPolicyManager::default()),tx_event,agent_status_tx,@@ -6108,6 +6110,7 @@ async fn make_session_with_history_source_and_agent_control_and_rx("11111111-1111-4111-8111-111111111111".to_string(),auth_manager,models_manager,+ model_info,Arc::new(ExecPolicyManager::default()),tx_event,agent_status_tx,diff --git a/codex-rs/core/src/session/world_state.rs b/codex-rs/core/src/session/world_state.rsindex a61a545d0e..14ac8fc656 100644--- a/codex-rs/core/src/session/world_state.rs+++ b/codex-rs/core/src/session/world_state.rs@@ -37,19 +37,27 @@ impl Session {selected_capability_root_count = step_context.selected_capability_roots.len(),"building step world state");+ let model_instructions = turn_context+ .model_info+ .get_model_instructions(turn_context.personality);let (previous_model, previous_context, base_instructions) = {let state = self.state.lock().await;+ let base_instructions = state.session_configuration.base_instructions.clone();(state.previous_turn_settings()- .map(|previous| previous.model),+ .map(|previous| previous.model)+ .or_else(|| {+ state+ .base_instructions_model+ .as_ref()+ .filter(|_| base_instructions != model_instructions)+ .cloned()+ }),state.reference_context_item(),- state.session_configuration.base_instructions.clone(),+ base_instructions,)};- let model_instructions = turn_context- .model_info- .get_model_instructions(turn_context.personality);let personality_is_baked = turn_context.model_info.supports_personality()&& base_instructions == model_instructions;let environment_subagents = if turn_context.config.include_environment_context {@@ -80,7 +88,8 @@ impl Session {turn_context.personality,previous_context.as_ref()- .map(|previous| previous.model.as_str()),+ .map(|previous| previous.model.as_str())+ .or(previous_model.as_deref()),previous_context.as_ref().and_then(|previous| previous.personality),diff --git a/codex-rs/core/src/state/session.rs b/codex-rs/core/src/state/session.rsindex 28a08ef4d6..f0b4e9ccc6 100644--- a/codex-rs/core/src/state/session.rs+++ b/codex-rs/core/src/state/session.rs@@ -25,6 +25,8 @@ use codex_utils_output_truncation::TruncationPolicy;/// Persistent, session-scoped state previously stored directly on `Session`.pub(crate) struct SessionState {pub(crate) session_configuration: SessionConfiguration,+ /// Model that generated the base instructions, when their provenance is known.+ pub(crate) base_instructions_model: Option<String>,pub(crate) history: ContextManager,pub(crate) latest_rate_limits: Option<RateLimitSnapshot>,pub(crate) server_reasoning_included: bool,@@ -62,6 +64,7 @@ impl SessionState {let history = ContextManager::new();Self {session_configuration,+ base_instructions_model: None,history,latest_rate_limits: None,server_reasoning_included: false,diff --git a/codex-rs/core/tests/suite/model_switching.rs b/codex-rs/core/tests/suite/model_switching.rsindex ce5f8fc9ba..4155f253ac 100644--- a/codex-rs/core/tests/suite/model_switching.rs+++ b/codex-rs/core/tests/suite/model_switching.rs@@ -1,7 +1,10 @@use anyhow::Result;use codex_config::types::Personality;+use codex_core::CodexThread;+use codex_core::ForkSnapshot;use codex_features::Feature;use codex_login::CodexAuth;+use codex_models_manager::bundled_models_response;use codex_models_manager::manager::RefreshStrategy;use codex_protocol::config_types::ReasoningSummary;use codex_protocol::config_types::SERVICE_TIER_DEFAULT_REQUEST_VALUE;@@ -22,6 +25,7 @@ use codex_protocol::protocol::EventMsg;use codex_protocol::protocol::Op;use codex_protocol::protocol::RolloutItem;use codex_protocol::protocol::RolloutLine;+use codex_protocol::protocol::ThreadSettingsOverrides;use codex_protocol::user_input::UserInput;use core_test_support::responses::ev_completed_with_tokens;use core_test_support::responses::ev_image_generation_call;@@ -39,6 +43,7 @@ use core_test_support::test_codex::test_codex;use core_test_support::test_codex::turn_permission_fields;use core_test_support::wait_for_event;use pretty_assertions::assert_eq;+use test_case::test_case;use wiremock::MockServer;fn read_only_user_turn(test: &TestCodex, items: Vec<UserInput>, model: String) -> Op {@@ -67,6 +72,28 @@ fn read_only_user_turn(test: &TestCodex, items: Vec<UserInput>, model: String) -}}+async fn submit_model_turn(+ thread: &CodexThread,+ model: &str,+ mut thread_settings: ThreadSettingsOverrides,+) -> Result<()> {+ thread_settings.model = Some(model.to_string());+ thread+ .submit(Op::UserInput {+ items: vec![UserInput::Text {+ text: "switch models".into(),+ text_elements: Vec::new(),+ }],+ final_output_json_schema: None,+ responsesapi_client_metadata: None,+ additional_context: Default::default(),+ thread_settings,+ })+ .await?;+ wait_for_event(thread, |event| matches!(event, EventMsg::TurnComplete(_))).await;+ Ok(())+}+fn test_model_info(slug: &str,display_name: &str,@@ -121,6 +148,194 @@ fn test_model_info(}}+#[test_case(None; "model only")]+#[test_case(Some(Personality::Pragmatic); "model and personality")]+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn first_turn_model_change_appends_model_instructions_developer_message(+ personality: Option<Personality>,+) -> Result<()> {+ skip_if_no_network!(Ok(()));++ let server = MockServer::start().await;+ let resp_mock = mount_sse_once(&server, sse_completed("resp-1")).await;++ let mut builder = test_codex().with_model("gpt-5.2").with_config(|config| {+ config+ .features+ .enable(Feature::Personality)+ .expect("test config should allow feature update");+ });+ let test = builder.build_with_auto_env(&server).await?;+ let next_model = "gpt-5.4";++ submit_model_turn(+ &test.codex,+ next_model,+ ThreadSettingsOverrides {+ personality,+ ..Default::default()+ },+ )+ .await?;++ let request = resp_mock.single_request();+ assert_eq!(request.body_json()["model"], next_model);+ let developer_texts = request.message_input_texts("developer");+ let expected_instructions = bundled_models_response()?+ .models+ .into_iter()+ .find(|model| model.slug == next_model)+ .expect("expected target model in bundled catalog")+ .get_model_instructions(personality.or(test.config.personality));+ assert!(+ developer_texts.iter().any(|text| {+ text.contains("<model_switch>") && text.contains(&expected_instructions)+ })+ );+ assert!(+ developer_texts+ .iter()+ .all(|text| !text.contains("<personality_spec>")),+ "model instructions already include the selected personality"+ );++ Ok(())+}++#[test_case(None; "model-generated base instructions")]+#[test_case(Some("inherited custom base instructions"); "custom base instructions")]+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn first_turn_after_empty_prefix_fork_preserves_inherited_base_instructions(+ custom_base_instructions: Option<&'static str>,+) -> Result<()> {+ skip_if_no_network!(Ok(()));++ let server = MockServer::start().await;+ let resp_mock = mount_sse_once(&server, sse_completed("resp-fork")).await;++ let initial_model = "gpt-5.2";+ let mut builder = test_codex()+ .with_model(initial_model)+ .with_config(move |config| {+ config.base_instructions = custom_base_instructions.map(str::to_string);+ });+ let test = builder.build_with_auto_env(&server).await?;+ test.codex.ensure_rollout_materialized().await;+ test.codex.flush_rollout().await?;++ let mut fork_config = test.config.clone();+ fork_config.model = Some("gpt-5.4".to_string());+ fork_config.base_instructions = None;+ let fork = test+ .thread_manager+ .fork_thread(+ ForkSnapshot::TruncateBeforeNthUserMessage(0),+ fork_config,+ test.codex.rollout_path().expect("rollout path"),+ /*thread_source*/ None,+ /*parent_trace*/ None,+ )+ .await?;+ submit_model_turn(+ &fork.thread,+ initial_model,+ ThreadSettingsOverrides::default(),+ )+ .await?;++ let request = resp_mock.single_request();+ assert_eq!(request.body_json()["model"], initial_model);+ if let Some(instructions) = custom_base_instructions {+ assert_eq!(request.instructions_text(), instructions);+ }+ assert!(+ request+ .message_input_texts("developer")+ .iter()+ .all(|text| !text.contains("<model_switch>")),+ "the inherited base instructions must not be replaced by catalog instructions"+ );++ Ok(())+}++#[derive(Clone, Copy)]+enum RollbackFollowup {+ StartupModel,+ SwitchedModel,+ ColdResume,+}++#[test_case(RollbackFollowup::StartupModel; "return to startup model")]+#[test_case(RollbackFollowup::SwitchedModel; "retry switched model")]+#[test_case(RollbackFollowup::ColdResume; "retry switched model after cold resume")]+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn rollback_first_turn_model_change_removes_its_instructions(+ followup: RollbackFollowup,+) -> Result<()> {+ skip_if_no_network!(Ok(()));++ let server = MockServer::start().await;+ let response_mock = mount_sse_sequence(+ &server,+ vec![sse_completed("resp-first"), sse_completed("resp-followup")],+ )+ .await;++ let initial_model = "gpt-5.2";+ let switched_model = "gpt-5.4";+ let mut builder = test_codex().with_model(initial_model);+ let test = builder.build_with_auto_env(&server).await?;++ submit_model_turn(+ &test.codex,+ switched_model,+ ThreadSettingsOverrides::default(),+ )+ .await?;++ test.codex+ .submit(Op::ThreadRollback { num_turns: 1 })+ .await?;+ wait_for_event(&test.codex, |ev| {+ matches!(ev, EventMsg::ThreadRolledBack(_))+ })+ .await;++ let test = match followup {+ RollbackFollowup::ColdResume => {+ let mut resume_builder = test_codex().with_model(initial_model);+ resume_builder.restart(&server, &test).await?+ }+ RollbackFollowup::StartupModel | RollbackFollowup::SwitchedModel => test,+ };+ let followup_model = match followup {+ RollbackFollowup::StartupModel => initial_model,+ RollbackFollowup::SwitchedModel | RollbackFollowup::ColdResume => switched_model,+ };+ submit_model_turn(+ &test.codex,+ followup_model,+ ThreadSettingsOverrides::default(),+ )+ .await?;++ let request = &response_mock.requests()[1];+ assert_eq!(request.body_json()["model"], followup_model);+ let model_switch_count = request+ .message_input_texts("developer")+ .iter()+ .filter(|text| text.contains("<model_switch>"))+ .count();+ assert_eq!(+ model_switch_count,+ usize::from(followup_model == switched_model),+ "rolled-back model instructions must not survive or be duplicated"+ );++ Ok(())+}+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]async fn model_change_appends_model_instructions_developer_message() -> Result<()> {skip_if_no_network!(Ok(()));