diff --git a/codex-rs/core/src/codex_thread.rs b/codex-rs/core/src/codex_thread.rs index 5daec52cef..8e878b8bfe 100644 --- a/codex-rs/core/src/codex_thread.rs +++ b/codex-rs/core/src/codex_thread.rs @@ -274,18 +274,6 @@ impl CodexThread { Ok(()) } - /// Apply persistent turn context overrides directly and return the effective state. - /// - /// This bypasses the submission queue; callers that need ordering relative - /// to turns should submit `Op::TurnContext`. - pub async fn update_turn_context_overrides( - &self, - overrides: CodexThreadTurnContextOverrides, - ) -> ConstraintResult<()> { - let updates = self.turn_context_settings_update(overrides).await; - self.codex.session.update_settings(updates).await - } - async fn turn_context_settings_update( &self, overrides: CodexThreadTurnContextOverrides, diff --git a/codex-rs/core/tests/common/lib.rs b/codex-rs/core/tests/common/lib.rs index ad7858f804..29bcd0fd3a 100644 --- a/codex-rs/core/tests/common/lib.rs +++ b/codex-rs/core/tests/common/lib.rs @@ -248,6 +248,31 @@ where wait_for_event_with_timeout(codex, predicate, Duration::from_secs(1)).await } +pub async fn submit_turn_context( + codex: &CodexThread, + turn_context: codex_protocol::protocol::TurnContextOverrides, +) -> anyhow::Result<()> { + use codex_protocol::protocol::EventMsg; + use codex_protocol::protocol::Op; + use tokio::time::Duration; + use tokio::time::timeout; + + let submission_id = codex.submit(Op::TurnContext { turn_context }).await?; + loop { + let ev = timeout(Duration::from_secs(10), codex.next_event()) + .await + .expect("timeout waiting for turn context update") + .expect("stream ended unexpectedly"); + if ev.id == submission_id { + match ev.msg { + EventMsg::TurnContextApplied(_) => return Ok(()), + EventMsg::Error(err) => panic!("turn context update failed: {}", err.message), + other => panic!("unexpected turn context update event: {other:?}"), + } + } + } +} + pub async fn wait_for_event_match(codex: &CodexThread, matcher: F) -> T where F: Fn(&codex_protocol::protocol::EventMsg) -> Option, diff --git a/codex-rs/core/tests/suite/collaboration_instructions.rs b/codex-rs/core/tests/suite/collaboration_instructions.rs index 11ba27fb5b..9215930f4c 100644 --- a/codex-rs/core/tests/suite/collaboration_instructions.rs +++ b/codex-rs/core/tests/suite/collaboration_instructions.rs @@ -123,12 +123,14 @@ async fn user_input_includes_collaboration_instructions_after_override() -> Resu let collab_text = "collab instructions"; let collaboration_mode = collab_mode_with_instructions(Some(collab_text)); - test.codex - .update_turn_context_overrides(codex_core::CodexThreadTurnContextOverrides { + core_test_support::submit_turn_context( + &test.codex, + codex_protocol::protocol::TurnContextOverrides { collaboration_mode: Some(collaboration_mode), ..Default::default() - }) - .await?; + }, + ) + .await?; test.codex .submit(Op::UserInput { @@ -267,12 +269,14 @@ async fn override_then_next_turn_uses_updated_collaboration_instructions() -> Re let collab_text = "override instructions"; let collaboration_mode = collab_mode_with_instructions(Some(collab_text)); - test.codex - .update_turn_context_overrides(codex_core::CodexThreadTurnContextOverrides { + core_test_support::submit_turn_context( + &test.codex, + codex_protocol::protocol::TurnContextOverrides { collaboration_mode: Some(collaboration_mode), ..Default::default() - }) - .await?; + }, + ) + .await?; test.codex .submit(Op::UserInput { @@ -313,12 +317,14 @@ async fn user_turn_overrides_collaboration_instructions_after_override() -> Resu let turn_text = "turn override"; let turn_mode = collab_mode_with_instructions(Some(turn_text)); - test.codex - .update_turn_context_overrides(codex_core::CodexThreadTurnContextOverrides { + core_test_support::submit_turn_context( + &test.codex, + codex_protocol::protocol::TurnContextOverrides { collaboration_mode: Some(base_mode), ..Default::default() - }) - .await?; + }, + ) + .await?; test.codex .submit(Op::UserInput { @@ -375,12 +381,14 @@ async fn collaboration_mode_update_emits_new_instruction_message() -> Result<()> let first_text = "first instructions"; let second_text = "second instructions"; - test.codex - .update_turn_context_overrides(codex_core::CodexThreadTurnContextOverrides { + core_test_support::submit_turn_context( + &test.codex, + codex_protocol::protocol::TurnContextOverrides { collaboration_mode: Some(collab_mode_with_instructions(Some(first_text))), ..Default::default() - }) - .await?; + }, + ) + .await?; test.codex .submit(Op::UserInput { @@ -396,12 +404,14 @@ async fn collaboration_mode_update_emits_new_instruction_message() -> Result<()> .await?; wait_for_event(&test.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await; - test.codex - .update_turn_context_overrides(codex_core::CodexThreadTurnContextOverrides { + core_test_support::submit_turn_context( + &test.codex, + codex_protocol::protocol::TurnContextOverrides { collaboration_mode: Some(collab_mode_with_instructions(Some(second_text))), ..Default::default() - }) - .await?; + }, + ) + .await?; test.codex .submit(Op::UserInput { @@ -446,12 +456,14 @@ async fn collaboration_mode_update_noop_does_not_append() -> Result<()> { let test = test_codex().build(&server).await?; let collab_text = "same instructions"; - test.codex - .update_turn_context_overrides(codex_core::CodexThreadTurnContextOverrides { + core_test_support::submit_turn_context( + &test.codex, + codex_protocol::protocol::TurnContextOverrides { collaboration_mode: Some(collab_mode_with_instructions(Some(collab_text))), ..Default::default() - }) - .await?; + }, + ) + .await?; test.codex .submit(Op::UserInput { @@ -467,12 +479,14 @@ async fn collaboration_mode_update_noop_does_not_append() -> Result<()> { .await?; wait_for_event(&test.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await; - test.codex - .update_turn_context_overrides(codex_core::CodexThreadTurnContextOverrides { + core_test_support::submit_turn_context( + &test.codex, + codex_protocol::protocol::TurnContextOverrides { collaboration_mode: Some(collab_mode_with_instructions(Some(collab_text))), ..Default::default() - }) - .await?; + }, + ) + .await?; test.codex .submit(Op::UserInput { @@ -516,15 +530,17 @@ async fn collaboration_mode_update_emits_new_instruction_message_when_mode_chang let default_text = "default mode instructions"; let plan_text = "plan mode instructions"; - test.codex - .update_turn_context_overrides(codex_core::CodexThreadTurnContextOverrides { + core_test_support::submit_turn_context( + &test.codex, + codex_protocol::protocol::TurnContextOverrides { collaboration_mode: Some(collab_mode_with_mode_and_instructions( ModeKind::Default, Some(default_text), )), ..Default::default() - }) - .await?; + }, + ) + .await?; test.codex .submit(Op::UserInput { @@ -540,15 +556,17 @@ async fn collaboration_mode_update_emits_new_instruction_message_when_mode_chang .await?; wait_for_event(&test.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await; - test.codex - .update_turn_context_overrides(codex_core::CodexThreadTurnContextOverrides { + core_test_support::submit_turn_context( + &test.codex, + codex_protocol::protocol::TurnContextOverrides { collaboration_mode: Some(collab_mode_with_mode_and_instructions( ModeKind::Plan, Some(plan_text), )), ..Default::default() - }) - .await?; + }, + ) + .await?; test.codex .submit(Op::UserInput { @@ -593,15 +611,17 @@ async fn collaboration_mode_update_noop_does_not_append_when_mode_is_unchanged() let test = test_codex().build(&server).await?; let collab_text = "mode-stable instructions"; - test.codex - .update_turn_context_overrides(codex_core::CodexThreadTurnContextOverrides { + core_test_support::submit_turn_context( + &test.codex, + codex_protocol::protocol::TurnContextOverrides { collaboration_mode: Some(collab_mode_with_mode_and_instructions( ModeKind::Default, Some(collab_text), )), ..Default::default() - }) - .await?; + }, + ) + .await?; test.codex .submit(Op::UserInput { @@ -617,15 +637,17 @@ async fn collaboration_mode_update_noop_does_not_append_when_mode_is_unchanged() .await?; wait_for_event(&test.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await; - test.codex - .update_turn_context_overrides(codex_core::CodexThreadTurnContextOverrides { + core_test_support::submit_turn_context( + &test.codex, + codex_protocol::protocol::TurnContextOverrides { collaboration_mode: Some(collab_mode_with_mode_and_instructions( ModeKind::Default, Some(collab_text), )), ..Default::default() - }) - .await?; + }, + ) + .await?; test.codex .submit(Op::UserInput { @@ -675,13 +697,14 @@ async fn resume_replays_collaboration_instructions() -> Result<()> { let home = initial.home.clone(); let collab_text = "resume instructions"; - initial - .codex - .update_turn_context_overrides(codex_core::CodexThreadTurnContextOverrides { + core_test_support::submit_turn_context( + &initial.codex, + codex_protocol::protocol::TurnContextOverrides { collaboration_mode: Some(collab_mode_with_instructions(Some(collab_text))), ..Default::default() - }) - .await?; + }, + ) + .await?; initial .codex @@ -736,8 +759,9 @@ async fn empty_collaboration_instructions_are_ignored() -> Result<()> { let test = test_codex().build(&server).await?; let current_model = test.session_configured.model.clone(); - test.codex - .update_turn_context_overrides(codex_core::CodexThreadTurnContextOverrides { + core_test_support::submit_turn_context( + &test.codex, + codex_protocol::protocol::TurnContextOverrides { collaboration_mode: Some(CollaborationMode { mode: ModeKind::Default, settings: Settings { @@ -747,8 +771,9 @@ async fn empty_collaboration_instructions_are_ignored() -> Result<()> { }, }), ..Default::default() - }) - .await?; + }, + ) + .await?; test.codex .submit(Op::UserInput { diff --git a/codex-rs/core/tests/suite/compact.rs b/codex-rs/core/tests/suite/compact.rs index 17f743d095..40f97dbeee 100644 --- a/codex-rs/core/tests/suite/compact.rs +++ b/codex-rs/core/tests/suite/compact.rs @@ -3279,13 +3279,15 @@ async fn snapshot_request_shape_pre_turn_compaction_including_incoming_user_mess .expect("submit user input"); wait_for_event(&codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await; } - codex - .update_turn_context_overrides(codex_core::CodexThreadTurnContextOverrides { + core_test_support::submit_turn_context( + &codex, + codex_protocol::protocol::TurnContextOverrides { cwd: Some(PathBuf::from(PRETURN_CONTEXT_DIFF_CWD)), ..Default::default() - }) - .await - .expect("override turn context"); + }, + ) + .await + .expect("override turn context"); let image_url = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR4nGNgYAAAAAMAASsJTYQAAAAASUVORK5CYII=" .to_string(); codex diff --git a/codex-rs/core/tests/suite/compact_remote.rs b/codex-rs/core/tests/suite/compact_remote.rs index a0c2f0b50f..8cc8a5fcee 100644 --- a/codex-rs/core/tests/suite/compact_remote.rs +++ b/codex-rs/core/tests/suite/compact_remote.rs @@ -2773,12 +2773,14 @@ async fn snapshot_request_shape_remote_pre_turn_compaction_including_incoming_us for user in ["USER_ONE", "USER_TWO", "USER_THREE"] { if user == "USER_THREE" { - codex - .update_turn_context_overrides(codex_core::CodexThreadTurnContextOverrides { + core_test_support::submit_turn_context( + &codex, + codex_protocol::protocol::TurnContextOverrides { cwd: Some(PathBuf::from(PRETURN_CONTEXT_DIFF_CWD)), ..Default::default() - }) - .await?; + }, + ) + .await?; } codex .submit(Op::UserInput { @@ -2881,12 +2883,14 @@ async fn snapshot_request_shape_remote_pre_turn_compaction_strips_incoming_model .await?; wait_for_event(&codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await; - codex - .update_turn_context_overrides(codex_core::CodexThreadTurnContextOverrides { + core_test_support::submit_turn_context( + &codex, + codex_protocol::protocol::TurnContextOverrides { model: Some(next_model.to_string()), ..Default::default() - }) - .await?; + }, + ) + .await?; codex .submit(Op::UserInput { environments: None, diff --git a/codex-rs/core/tests/suite/compact_resume_fork.rs b/codex-rs/core/tests/suite/compact_resume_fork.rs index d01be5d695..758c43fea5 100644 --- a/codex-rs/core/tests/suite/compact_resume_fork.rs +++ b/codex-rs/core/tests/suite/compact_resume_fork.rs @@ -548,8 +548,9 @@ async fn snapshot_rollback_followup_turn_trims_context_updates() -> Result<()> { let override_cwd = config.cwd.join(PRETURN_CONTEXT_DIFF_CWD); std::fs::create_dir_all(&override_cwd)?; - conversation - .update_turn_context_overrides(codex_core::CodexThreadTurnContextOverrides { + core_test_support::submit_turn_context( + &conversation, + codex_protocol::protocol::TurnContextOverrides { cwd: Some(override_cwd.to_path_buf()), collaboration_mode: Some(CollaborationMode { mode: ModeKind::Default, @@ -560,8 +561,9 @@ async fn snapshot_rollback_followup_turn_trims_context_updates() -> Result<()> { }, }), ..Default::default() - }) - .await?; + }, + ) + .await?; user_turn(&conversation, TURN_TWO_USER).await; diff --git a/codex-rs/core/tests/suite/model_overrides.rs b/codex-rs/core/tests/suite/model_overrides.rs index a8d46dd32b..c3bf54ad18 100644 --- a/codex-rs/core/tests/suite/model_overrides.rs +++ b/codex-rs/core/tests/suite/model_overrides.rs @@ -24,14 +24,16 @@ async fn turn_context_update_does_not_persist_when_config_exists() { let codex = test.codex.clone(); let config_path = test.home.path().join(CONFIG_TOML); - codex - .update_turn_context_overrides(codex_core::CodexThreadTurnContextOverrides { + core_test_support::submit_turn_context( + &codex, + codex_protocol::protocol::TurnContextOverrides { model: Some("o3".to_string()), effort: Some(Some(ReasoningEffort::High)), ..Default::default() - }) - .await - .expect("submit override"); + }, + ) + .await + .expect("submit override"); codex.submit(Op::Shutdown).await.expect("request shutdown"); wait_for_event(&codex, |ev| matches!(ev, EventMsg::ShutdownComplete)).await; @@ -54,14 +56,16 @@ async fn turn_context_update_does_not_create_config_file() { "test setup should start without config" ); - codex - .update_turn_context_overrides(codex_core::CodexThreadTurnContextOverrides { + core_test_support::submit_turn_context( + &codex, + codex_protocol::protocol::TurnContextOverrides { model: Some("o3".to_string()), effort: Some(Some(ReasoningEffort::Medium)), ..Default::default() - }) - .await - .expect("submit override"); + }, + ) + .await + .expect("submit override"); codex.submit(Op::Shutdown).await.expect("request shutdown"); wait_for_event(&codex, |ev| matches!(ev, EventMsg::ShutdownComplete)).await; diff --git a/codex-rs/core/tests/suite/model_switching.rs b/codex-rs/core/tests/suite/model_switching.rs index 40cad40204..5ae99de101 100644 --- a/codex-rs/core/tests/suite/model_switching.rs +++ b/codex-rs/core/tests/suite/model_switching.rs @@ -161,12 +161,14 @@ async fn model_change_appends_model_instructions_developer_message() -> Result<( .await?; wait_for_event(&test.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await; - test.codex - .update_turn_context_overrides(codex_core::CodexThreadTurnContextOverrides { + core_test_support::submit_turn_context( + &test.codex, + codex_protocol::protocol::TurnContextOverrides { model: Some(next_model.to_string()), ..Default::default() - }) - .await?; + }, + ) + .await?; test.codex .submit(read_only_user_turn( @@ -231,13 +233,15 @@ async fn model_and_personality_change_only_appends_model_instructions() -> Resul .await?; wait_for_event(&test.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await; - test.codex - .update_turn_context_overrides(codex_core::CodexThreadTurnContextOverrides { + core_test_support::submit_turn_context( + &test.codex, + codex_protocol::protocol::TurnContextOverrides { model: Some(next_model.to_string()), personality: Some(Personality::Pragmatic), ..Default::default() - }) - .await?; + }, + ) + .await?; test.codex .submit(read_only_user_turn( @@ -969,12 +973,14 @@ async fn model_switch_to_smaller_model_updates_token_context_window() -> Result< ); wait_for_event(&test.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await; - test.codex - .update_turn_context_overrides(codex_core::CodexThreadTurnContextOverrides { + core_test_support::submit_turn_context( + &test.codex, + codex_protocol::protocol::TurnContextOverrides { model: Some(smaller_model_slug.to_string()), ..Default::default() - }) - .await?; + }, + ) + .await?; test.codex .submit(read_only_user_turn( diff --git a/codex-rs/core/tests/suite/model_visible_layout.rs b/codex-rs/core/tests/suite/model_visible_layout.rs index adef99ce02..33c32997f6 100644 --- a/codex-rs/core/tests/suite/model_visible_layout.rs +++ b/codex-rs/core/tests/suite/model_visible_layout.rs @@ -501,14 +501,15 @@ async fn snapshot_model_visible_layout_resume_override_matches_rollout_model() - let resumed = resume_builder.resume(&server, home, rollout_path).await?; let resume_override_cwd = resumed.cwd_path().join(PRETURN_CONTEXT_DIFF_CWD); fs::create_dir_all(&resume_override_cwd)?; - resumed - .codex - .update_turn_context_overrides(codex_core::CodexThreadTurnContextOverrides { + core_test_support::submit_turn_context( + &resumed.codex, + codex_protocol::protocol::TurnContextOverrides { cwd: Some(resume_override_cwd), model: Some("gpt-5.2".to_string()), ..Default::default() - }) - .await?; + }, + ) + .await?; resumed .codex .submit(Op::UserInput { diff --git a/codex-rs/core/tests/suite/override_updates.rs b/codex-rs/core/tests/suite/override_updates.rs index b3cec800ab..39e2dd103e 100644 --- a/codex-rs/core/tests/suite/override_updates.rs +++ b/codex-rs/core/tests/suite/override_updates.rs @@ -33,12 +33,14 @@ async fn turn_context_update_without_user_turn_does_not_record_permissions_updat }); let test = builder.build(&server).await?; - test.codex - .update_turn_context_overrides(codex_core::CodexThreadTurnContextOverrides { + core_test_support::submit_turn_context( + &test.codex, + codex_protocol::protocol::TurnContextOverrides { approval_policy: Some(AskForApproval::Never), ..Default::default() - }) - .await?; + }, + ) + .await?; test.codex.submit(Op::Shutdown).await?; wait_for_event(&test.codex, |ev| matches!(ev, EventMsg::ShutdownComplete)).await; @@ -60,12 +62,14 @@ async fn turn_context_update_without_user_turn_does_not_record_environment_updat let test = test_codex().build(&server).await?; let new_cwd = TempDir::new()?; - test.codex - .update_turn_context_overrides(codex_core::CodexThreadTurnContextOverrides { + core_test_support::submit_turn_context( + &test.codex, + codex_protocol::protocol::TurnContextOverrides { cwd: Some(new_cwd.path().to_path_buf()), ..Default::default() - }) - .await?; + }, + ) + .await?; test.codex.submit(Op::Shutdown).await?; wait_for_event(&test.codex, |ev| matches!(ev, EventMsg::ShutdownComplete)).await; @@ -89,12 +93,14 @@ async fn turn_context_update_without_user_turn_does_not_record_collaboration_upd let collab_text = "override collaboration instructions"; let collaboration_mode = collab_mode_with_instructions(Some(collab_text)); - test.codex - .update_turn_context_overrides(codex_core::CodexThreadTurnContextOverrides { + core_test_support::submit_turn_context( + &test.codex, + codex_protocol::protocol::TurnContextOverrides { collaboration_mode: Some(collaboration_mode), ..Default::default() - }) - .await?; + }, + ) + .await?; test.codex.submit(Op::Shutdown).await?; wait_for_event(&test.codex, |ev| matches!(ev, EventMsg::ShutdownComplete)).await; diff --git a/codex-rs/core/tests/suite/permissions_messages.rs b/codex-rs/core/tests/suite/permissions_messages.rs index 94b983be51..8035698ec3 100644 --- a/codex-rs/core/tests/suite/permissions_messages.rs +++ b/codex-rs/core/tests/suite/permissions_messages.rs @@ -103,12 +103,14 @@ async fn permissions_message_added_on_override_change() -> Result<()> { .await?; wait_for_event(&test.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await; - test.codex - .update_turn_context_overrides(codex_core::CodexThreadTurnContextOverrides { + core_test_support::submit_turn_context( + &test.codex, + codex_protocol::protocol::TurnContextOverrides { approval_policy: Some(AskForApproval::Never), ..Default::default() - }) - .await?; + }, + ) + .await?; test.codex .submit(Op::UserInput { @@ -230,12 +232,14 @@ async fn permissions_message_omitted_when_disabled() -> Result<()> { .await?; wait_for_event(&test.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await; - test.codex - .update_turn_context_overrides(codex_core::CodexThreadTurnContextOverrides { + core_test_support::submit_turn_context( + &test.codex, + codex_protocol::protocol::TurnContextOverrides { approval_policy: Some(AskForApproval::Never), ..Default::default() - }) - .await?; + }, + ) + .await?; test.codex .submit(Op::UserInput { @@ -310,13 +314,14 @@ async fn resume_replays_permissions_messages() -> Result<()> { .await?; wait_for_event(&initial.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await; - initial - .codex - .update_turn_context_overrides(codex_core::CodexThreadTurnContextOverrides { + core_test_support::submit_turn_context( + &initial.codex, + codex_protocol::protocol::TurnContextOverrides { approval_policy: Some(AskForApproval::Never), ..Default::default() - }) - .await?; + }, + ) + .await?; initial .codex @@ -409,13 +414,14 @@ async fn resume_and_fork_append_permissions_messages() -> Result<()> { .await?; wait_for_event(&initial.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await; - initial - .codex - .update_turn_context_overrides(codex_core::CodexThreadTurnContextOverrides { + core_test_support::submit_turn_context( + &initial.codex, + codex_protocol::protocol::TurnContextOverrides { approval_policy: Some(AskForApproval::Never), ..Default::default() - }) - .await?; + }, + ) + .await?; initial .codex diff --git a/codex-rs/core/tests/suite/personality.rs b/codex-rs/core/tests/suite/personality.rs index 187334f352..f3eb785fdb 100644 --- a/codex-rs/core/tests/suite/personality.rs +++ b/codex-rs/core/tests/suite/personality.rs @@ -333,12 +333,14 @@ async fn user_turn_personality_some_adds_update_message() -> anyhow::Result<()> wait_for_event(&test.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await; - test.codex - .update_turn_context_overrides(codex_core::CodexThreadTurnContextOverrides { + core_test_support::submit_turn_context( + &test.codex, + codex_protocol::protocol::TurnContextOverrides { personality: Some(Personality::Friendly), ..Default::default() - }) - .await?; + }, + ) + .await?; test.codex .submit(read_only_text_turn( @@ -407,12 +409,14 @@ async fn user_turn_personality_same_value_does_not_add_update_message() -> anyho wait_for_event(&test.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await; - test.codex - .update_turn_context_overrides(codex_core::CodexThreadTurnContextOverrides { + core_test_support::submit_turn_context( + &test.codex, + codex_protocol::protocol::TurnContextOverrides { personality: Some(Personality::Pragmatic), ..Default::default() - }) - .await?; + }, + ) + .await?; test.codex .submit(read_only_text_turn( @@ -494,12 +498,14 @@ async fn user_turn_personality_skips_if_feature_disabled() -> anyhow::Result<()> wait_for_event(&test.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await; - test.codex - .update_turn_context_overrides(codex_core::CodexThreadTurnContextOverrides { + core_test_support::submit_turn_context( + &test.codex, + codex_protocol::protocol::TurnContextOverrides { personality: Some(Personality::Pragmatic), ..Default::default() - }) - .await?; + }, + ) + .await?; test.codex .submit(read_only_text_turn( @@ -733,12 +739,14 @@ async fn user_turn_personality_remote_model_template_includes_update_message() - wait_for_event(&test.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await; - test.codex - .update_turn_context_overrides(codex_core::CodexThreadTurnContextOverrides { + core_test_support::submit_turn_context( + &test.codex, + codex_protocol::protocol::TurnContextOverrides { personality: Some(Personality::Friendly), ..Default::default() - }) - .await?; + }, + ) + .await?; test.codex .submit(read_only_text_turn( diff --git a/codex-rs/core/tests/suite/prompt_caching.rs b/codex-rs/core/tests/suite/prompt_caching.rs index 608bcb74b1..7464e4c394 100644 --- a/codex-rs/core/tests/suite/prompt_caching.rs +++ b/codex-rs/core/tests/suite/prompt_caching.rs @@ -442,16 +442,18 @@ async fn overrides_turn_context_but_keeps_cached_prefix_and_key_constant() -> an let sandbox_policy = permission_profile .to_legacy_sandbox_policy(config.cwd.as_path()) .expect("workspace profile should have legacy projection"); - codex - .update_turn_context_overrides(codex_core::CodexThreadTurnContextOverrides { + core_test_support::submit_turn_context( + &codex, + codex_protocol::protocol::TurnContextOverrides { approval_policy: Some(AskForApproval::Never), sandbox_policy: Some(sandbox_policy), permission_profile: Some(permission_profile), effort: Some(Some(ReasoningEffort::High)), summary: Some(ReasoningSummary::Detailed), ..Default::default() - }) - .await?; + }, + ) + .await?; // Second turn after overrides codex @@ -523,15 +525,17 @@ async fn override_before_first_turn_emits_environment_context() -> anyhow::Resul }, }; - codex - .update_turn_context_overrides(codex_core::CodexThreadTurnContextOverrides { + core_test_support::submit_turn_context( + &codex, + codex_protocol::protocol::TurnContextOverrides { approval_policy: Some(AskForApproval::Never), model: Some("gpt-5.4".to_string()), effort: Some(Some(ReasoningEffort::Low)), collaboration_mode: Some(collaboration_mode), ..Default::default() - }) - .await?; + }, + ) + .await?; codex .submit(Op::UserInput { diff --git a/codex-rs/core/tests/suite/remote_models.rs b/codex-rs/core/tests/suite/remote_models.rs index 8ec5c51e49..eb8d792a74 100644 --- a/codex-rs/core/tests/suite/remote_models.rs +++ b/codex-rs/core/tests/suite/remote_models.rs @@ -614,12 +614,14 @@ async fn remote_models_remote_model_uses_unified_exec() -> Result<()> { .await; assert_eq!(model_info.shell_type, ConfigShellToolType::UnifiedExec); - codex - .update_turn_context_overrides(codex_core::CodexThreadTurnContextOverrides { + core_test_support::submit_turn_context( + &codex, + codex_protocol::protocol::TurnContextOverrides { model: Some(REMOTE_MODEL_SLUG.to_string()), ..Default::default() - }) - .await?; + }, + ) + .await?; let call_id = "call"; let args = json!({ @@ -861,12 +863,14 @@ async fn remote_models_apply_remote_base_instructions() -> Result<()> { let models_manager = thread_manager.get_models_manager(); wait_for_model_available(&models_manager, model).await; - codex - .update_turn_context_overrides(codex_core::CodexThreadTurnContextOverrides { + core_test_support::submit_turn_context( + &codex, + codex_protocol::protocol::TurnContextOverrides { model: Some(model.to_string()), ..Default::default() - }) - .await?; + }, + ) + .await?; let cwd_path = cwd.path().to_path_buf(); let (sandbox_policy, permission_profile) = diff --git a/codex-rs/core/tests/suite/resume.rs b/codex-rs/core/tests/suite/resume.rs index fc5a82d5b8..12e99b5219 100644 --- a/codex-rs/core/tests/suite/resume.rs +++ b/codex-rs/core/tests/suite/resume.rs @@ -423,13 +423,14 @@ async fn resume_model_switch_is_not_duplicated_after_pre_turn_override() -> Resu config.model = Some("gpt-5.3-codex".to_string()); }); let resumed = resume_builder.resume(&server, home, rollout_path).await?; - resumed - .codex - .update_turn_context_overrides(codex_core::CodexThreadTurnContextOverrides { + core_test_support::submit_turn_context( + &resumed.codex, + codex_protocol::protocol::TurnContextOverrides { model: Some("gpt-5.4".to_string()), ..Default::default() - }) - .await?; + }, + ) + .await?; resumed .codex .submit(Op::UserInput { diff --git a/codex-rs/core/tests/suite/review.rs b/codex-rs/core/tests/suite/review.rs index 55e1d1dc61..696a6b8221 100644 --- a/codex-rs/core/tests/suite/review.rs +++ b/codex-rs/core/tests/suite/review.rs @@ -789,13 +789,15 @@ async fn review_uses_overridden_cwd_for_base_branch_merge_base() { }) .await; - codex - .update_turn_context_overrides(codex_core::CodexThreadTurnContextOverrides { + core_test_support::submit_turn_context( + &codex, + codex_protocol::protocol::TurnContextOverrides { cwd: Some(repo_path.to_path_buf()), ..Default::default() - }) - .await - .unwrap(); + }, + ) + .await + .unwrap(); codex .submit(Op::Review { diff --git a/codex-rs/memories/write/src/startup_tests.rs b/codex-rs/memories/write/src/startup_tests.rs index f5a75ed10e..e88e3a26b3 100644 --- a/codex-rs/memories/write/src/startup_tests.rs +++ b/codex-rs/memories/write/src/startup_tests.rs @@ -242,12 +242,14 @@ async fn memories_startup_phase1_uses_live_thread_service_tier() -> anyhow::Resu let test = build_test_codex(&server, home).await?; assert_eq!(test.config.service_tier, None); - test.codex - .update_turn_context_overrides(codex_core::CodexThreadTurnContextOverrides { + core_test_support::submit_turn_context( + &test.codex, + codex_protocol::protocol::TurnContextOverrides { service_tier: Some(Some(ServiceTier::Fast.request_value().to_string())), ..Default::default() - }) - .await?; + }, + ) + .await?; let config_snapshot = wait_for_service_tier(&test, Some(ServiceTier::Fast.request_value().to_string())).await?;