diff --git a/codex-rs/core/src/client.rs b/codex-rs/core/src/client.rs index 6d7d343f63..66d8338993 100644 --- a/codex-rs/core/src/client.rs +++ b/codex-rs/core/src/client.rs @@ -2112,6 +2112,18 @@ impl ModelClientSession { websocket_telemetry } + /// Whether a previous request prepared a connection that is not known to be closed. + /// The next request still validates provider, auth, and headers before reuse. + pub(crate) async fn is_websocket_prewarmed(&self) -> bool { + if self.websocket_session.last_request.is_some() + && let Some(connection) = self.websocket_session.connection.as_ref() + { + !connection.is_closed().await + } else { + false + } + } + #[allow(clippy::too_many_arguments)] pub async fn prewarm_websocket( &mut self, @@ -2126,12 +2138,7 @@ impl ModelClientSession { if !self.client.responses_websocket_enabled() { return Ok(()); } - // A previous request only makes prewarm unnecessary while its socket is - // still alive. Reconnecting below resets the old continuation normally. - if self.websocket_session.last_request.is_some() - && let Some(connection) = self.websocket_session.connection.as_ref() - && !connection.is_closed().await - { + if self.is_websocket_prewarmed().await { return Ok(()); } diff --git a/codex-rs/core/src/session/startup_prewarm.rs b/codex-rs/core/src/session/startup_prewarm.rs index 78929e0754..5e538c87aa 100644 --- a/codex-rs/core/src/session/startup_prewarm.rs +++ b/codex-rs/core/src/session/startup_prewarm.rs @@ -287,6 +287,24 @@ impl Session { async fn schedule_startup_prewarm_inner(session: Arc) -> CodexResult { let prewarm_started_at = Instant::now(); + let mut client_session = session.services.model_client.new_session(); + let websocket_ready = client_session.is_websocket_prewarmed().await; + // Count the decision before preparation can fail; fresh clients also need prewarm. + session.services.session_telemetry.counter( + "codex.startup_prewarm.websocket_check", + /*inc*/ 1, + &[( + "outcome", + if websocket_ready { + "ready" + } else { + "needs_prewarm" + }, + )], + ); + if websocket_ready { + return Ok(client_session); + } let base_instructions = session.get_prompt_base_instructions().await.text; let startup_turn_context = session .new_startup_prewarm_turn_with_sub_id(INITIAL_SUBMIT_ID.to_owned()) @@ -329,7 +347,6 @@ async fn schedule_startup_prewarm_inner(session: Arc) -> CodexResult a .await; let mut extensions = ExtensionRegistryBuilder::new(); extensions.thread_lifecycle_contributor(Arc::new(ThreadIdle)); + let instructions = Arc::new(RecordingUserInstructionsProvider::new(Arc::new( + EmptyUserInstructionsProvider, + ))); let test = test_codex() .with_extensions(Arc::new(extensions.build())) + .with_user_instructions_provider(instructions.clone()) .build_with_websocket_server(&server) .await?; test.submit_text_turn("hello").await?; ThreadIdle::wait(&test.codex).await; - // A healthy warm resume preserves the existing response baseline. + // A healthy warm resume skips preparation; only the user turn reloads instructions. + let instruction_loads = instructions.load_count(); test.codex.prewarm().await; test.codex.prewarm().await; test.submit_text_turn("continue").await?; + assert_eq!(instructions.load_count(), instruction_loads + 1); assert_eq!(server.handshakes().len(), 1); assert_eq!( server.single_handshake().header(USER_AGENT_HEADER), @@ -663,6 +671,7 @@ async fn responses_websocket_resume_prewarm_reuses_and_repairs_connection() -> a // Turn idle does not synchronize with the reader observing the server's close. // Retry resume until it sees the close; pending attempts must still share one socket. ThreadIdle::wait(&test.codex).await; + let instruction_loads = instructions.load_count(); let warmup = tokio::time::timeout(Duration::from_secs(10), async { loop { test.codex.prewarm().await; @@ -674,6 +683,7 @@ async fn responses_websocket_resume_prewarm_reuses_and_repairs_connection() -> a } }) .await?; + assert!(instructions.load_count() > instruction_loads); assert_eq!(warmup.body_json()["generate"], false); assert!(warmup.body_json().get("previous_response_id").is_none());