diff --git a/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-experimental.json.zst b/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-experimental.json.zst index df8d6223cd..bb869b0c38 100644 Binary files a/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-experimental.json.zst and b/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-experimental.json.zst differ diff --git a/codex-rs/app-server-protocol/src/protocol/v2/thread_sample.rs b/codex-rs/app-server-protocol/src/protocol/v2/thread_sample.rs index a1d325a82b..2a6d5f70f3 100644 --- a/codex-rs/app-server-protocol/src/protocol/v2/thread_sample.rs +++ b/codex-rs/app-server-protocol/src/protocol/v2/thread_sample.rs @@ -20,6 +20,10 @@ pub struct ThreadSampleParams { #[serde(default, skip_serializing_if = "std::ops::Not::not")] pub allow_in_progress_turn: bool, pub prompt: String, + /// Override the model for this sample. + /// Omit or pass `null` to inherit the source thread's model. + #[ts(optional = nullable)] + pub model: Option, /// Applied only when the provider and model support cache-preserving reasoning-effort updates. #[ts(optional = nullable)] pub effort: Option, diff --git a/codex-rs/app-server/src/thread_sample.rs b/codex-rs/app-server/src/thread_sample.rs index a170ede9d3..d0cb2e6c9c 100644 --- a/codex-rs/app-server/src/thread_sample.rs +++ b/codex-rs/app-server/src/thread_sample.rs @@ -179,7 +179,11 @@ impl SampleTask { .map_err(|error| internal_error(error.to_string()))?; let model = parent .model_info( - options.config.model.as_deref().unwrap_or(&snapshot.model), + params + .model + .as_deref() + .or(options.config.model.as_deref()) + .unwrap_or(&snapshot.model), &options.config.to_models_manager_config(), ) .await; @@ -263,6 +267,7 @@ impl SampleTask { text_elements: Vec::new(), }]) .with_thread_settings(ThreadSettingsOverrides { + model: params.model, effort: effort.map(Some), ..Default::default() }) diff --git a/codex-rs/app-server/tests/suite/v2/thread_sample.rs b/codex-rs/app-server/tests/suite/v2/thread_sample.rs index b62fd44d6d..58016777ea 100644 --- a/codex-rs/app-server/tests/suite/v2/thread_sample.rs +++ b/codex-rs/app-server/tests/suite/v2/thread_sample.rs @@ -55,6 +55,7 @@ use tokio::time::timeout; use wiremock::ResponseTemplate; const WAIT: Duration = Duration::from_secs(40); +const SAMPLE_MODEL: &str = "gpt-5.4-mini"; async fn client( home: &TempDir, @@ -89,10 +90,13 @@ async fn client_with_effort_updates( name: "Fast".to_string(), description: "Priority processing.".to_string(), }]; + let mut sample_model = model.clone(); + sample_model.slug = SAMPLE_MODEL.to_string(); + sample_model.supports_reasoning_effort_updates = false; let catalog = home.path().join("catalog.json"); std::fs::write( &catalog, - serde_json::to_string(&json!({"models": [model]}))?, + serde_json::to_string(&json!({"models": [model, sample_model]}))?, )?; let mut config = MockResponsesConfig::new(&server.uri()).with_model("gpt-5.4").with_provider_name("OpenAI") .with_root_config(&format!("model_catalog_json = {}\nmodel_reasoning_effort = \"high\"\nmodel_post_turn_compact_threshold_percent = 0", serde_json::to_string(&catalog)?)); @@ -173,6 +177,92 @@ async fn prediction_fork(client: &mut TestAppServer, parent: &str) -> Result Result<()> { + let server = responses::start_mock_server().await; + let mock = responses::mount_sse_sequence( + &server, + ["parent", "override", "inherited", "follow-up"] + .map(|id| { + responses::sse(vec![ + responses::ev_assistant_message(id, "Ready."), + responses::ev_completed(id), + ]) + }) + .to_vec(), + ) + .await; + let home = TempDir::new()?; + let mut client = client(&home, &server, /*overrides*/ true).await?; + let (thread_id, turn_id) = ready_parent(&mut client, ThreadStartParams::default()).await?; + + let result = sample( + &mut client, + ThreadSampleParams { + thread_id: thread_id.clone(), + expected_turn_id: turn_id.clone(), + prompt: "Predict the next message.".to_string(), + model: Some(SAMPLE_MODEL.to_string()), + effort: Some(ReasoningEffort::Medium), + ..Default::default() + }, + ) + .await?; + assert_eq!(result.text.as_deref(), Some("Ready.")); + + let request_id = client + .send_raw_request( + "thread/sample", + Some(json!({ + "threadId": thread_id, + "expectedTurnId": turn_id, + "prompt": "Predict with inherited settings.", + })), + ) + .await?; + let _: ThreadSampleResponse = timeout(WAIT, client.read_response(request_id)).await??; + client + .start_turn_and_wait_for_completion(TurnStartParams { + thread_id, + input: input("Follow-up"), + ..Default::default() + }) + .await?; + + let requests = mock.requests(); + let models: Vec<_> = requests + .iter() + .map(|request| request.body_json()["model"].clone()) + .collect(); + assert_eq!( + models, + ["gpt-5.4", SAMPLE_MODEL, "gpt-5.4", "gpt-5.4"].map(|model| json!(model)), + ); + assert_eq!( + requests[1].body_json()["reasoning"]["effort"], + json!("high") + ); + let announcement = requests[1] + .message_input_texts("developer") + .into_iter() + .find(|text| text.starts_with("")) + .expect("sample model announcement"); + insta::assert_snapshot!(announcement, @" + + The current model is gpt-5.4-mini. + + "); + assert!( + !requests[2].body_contains_text("") + && !requests[2].body_contains_text(""), + "sample without a model override should not announce a model switch" + ); + assert!(requests[1].body_contains_text("Initial turn")); + assert!(requests[1].body_contains_text("Predict the next message.")); + assert!(!requests[3].body_contains_text("Predict the next message.")); + Ok(()) +} + #[test_matrix( [ThreadHistoryMode::Legacy, ThreadHistoryMode::Paginated], [TurnStatus::Completed, TurnStatus::Failed, TurnStatus::Interrupted],