Lightweight coding agent that runs in your terminal
Rust
Route resume prewarm through the cached WebSocket session (#47709)
vkg-oaif5f08c54cb7a
diff --git a/codex-rs/core/src/client.rs b/codex-rs/core/src/client.rsindex f69e28bd7b..6d7d343f63 100644--- a/codex-rs/core/src/client.rs+++ b/codex-rs/core/src/client.rs@@ -100,7 +100,6 @@ use codex_tools::create_tools_json_for_responses_lite;use codex_tools::create_tools_raw_json_for_responses_api;use eventsource_stream::Event;use eventsource_stream::EventStreamError;-use futures::FutureExt;use futures::StreamExt;use http::HeaderMap as ApiHeaderMap;use http::HeaderValue;@@ -418,17 +417,6 @@ fn is_internal_metadata_destination(provider: &ApiProvider) -> bool {}impl WebsocketSession {- /// A nonblocking resume check. A busy stream is already in use, so resume- /// leaves it alone. The next request still validates provider, auth, and headers.- fn is_prewarmed(&self, auth_owner_generation: Option<u64>) -> bool {- self.auth_owner_generation == auth_owner_generation- && self.last_request.is_some()- && self- .connection- .as_ref()- .is_some_and(|connection| connection.is_closed().now_or_never() != Some(true))- }-fn reset(&mut self, reason: Option<&'static str>) {// Per-socket backend metrics call a resend after reconnect "initial".// Retain the loss reason across reconnects/turns until the next send.@@ -630,15 +618,6 @@ impl ModelClient {self.state.provider.auth_manager()}- pub(crate) fn is_websocket_prewarmed(&self) -> bool {- let auth_owner_generation = self.auth_owner_generation();- self.state- .cached_websocket_session- .lock()- .unwrap_or_else(std::sync::PoisonError::into_inner)- .is_prewarmed(auth_owner_generation)- }-fn auth_owner_generation(&self) -> Option<u64> {self.auth_manager().map(|manager| {manager@@ -1361,11 +1340,6 @@ impl Drop for ModelClientSession {}impl ModelClientSession {- pub(crate) fn is_websocket_prewarmed(&self) -> bool {- self.websocket_session- .is_prewarmed(self.client.auth_owner_generation())- }-#[allow(clippy::too_many_arguments)]/// Builds shared Responses API transport options and request-body options.///diff --git a/codex-rs/core/src/session/startup_prewarm.rs b/codex-rs/core/src/session/startup_prewarm.rsindex 7b8d5978b2..78929e0754 100644--- a/codex-rs/core/src/session/startup_prewarm.rs+++ b/codex-rs/core/src/session/startup_prewarm.rs@@ -32,16 +32,11 @@ use codex_protocol::protocol::SessionSource;use codex_protocol::protocol::SubAgentSource;pub(crate) struct SessionStartupPrewarmHandle {- task: SessionStartupPrewarmTask,+ task: AbortOnDropHandle<CodexResult<ModelClientSession>>,started_at: Instant,timeout: Duration,}-enum SessionStartupPrewarmTask {- Running(AbortOnDropHandle<CodexResult<ModelClientSession>>),- Completed(SessionStartupPrewarmResolution),-}-pub(crate) enum SessionStartupPrewarmResolution {Cancelled,Ready(Box<ModelClientSession>),@@ -58,17 +53,15 @@ impl SessionStartupPrewarmHandle {timeout: Duration,) -> Self {Self {- task: SessionStartupPrewarmTask::Running(AbortOnDropHandle::new(task)),+ task: AbortOnDropHandle::new(task),started_at,timeout,}}pub(crate) async fn abort(self) {- if let SessionStartupPrewarmTask::Running(task) = self.task {- task.abort();- let _ = task.await;- }+ self.task.abort();+ let _ = self.task.await;}#[instrument(name = "startup_prewarm.resolve", level = "trace", skip_all)]@@ -79,55 +72,48 @@ impl SessionStartupPrewarmHandle {) -> SessionStartupPrewarmResolution {let resolve_started_at = Instant::now();let Self {- task,+ mut task,started_at,timeout,} = self;let age_at_first_turn = started_at.elapsed();let remaining = timeout.saturating_sub(age_at_first_turn);- let resolution = match task {- SessionStartupPrewarmTask::Completed(resolution) => resolution,- SessionStartupPrewarmTask::Running(mut task) => {- if task.is_finished() {- Self::resolution_from_join_result(task.await, started_at)- } else {- match tokio::select! {- _ = cancellation_token.cancelled() => None,- result = tokio::time::timeout(remaining, &mut task) => Some(result),- } {- Some(Ok(result)) => Self::resolution_from_join_result(result, started_at),- Some(Err(_elapsed)) => {- task.abort();- info!(- "startup websocket prewarm timed out before the first turn could use it"- );- SessionStartupPrewarmResolution::Unavailable {- status: "timed_out",- prewarm_duration: Some(started_at.elapsed()),- }- }- None => {- task.abort();- session_telemetry.record_startup_phase(- "startup_prewarm_resolve",- resolve_started_at.elapsed(),- Some("cancelled"),- );- session_telemetry.record_duration(- STARTUP_PREWARM_AGE_AT_FIRST_TURN_METRIC,- age_at_first_turn,- &[("status", "cancelled")],- );- session_telemetry.record_duration(- STARTUP_PREWARM_DURATION_METRIC,- started_at.elapsed(),- &[("status", "cancelled")],- );- return SessionStartupPrewarmResolution::Cancelled;- }+ let resolution = if task.is_finished() {+ Self::resolution_from_join_result(task.await, started_at)+ } else {+ match tokio::select! {+ _ = cancellation_token.cancelled() => None,+ result = tokio::time::timeout(remaining, &mut task) => Some(result),+ } {+ Some(Ok(result)) => Self::resolution_from_join_result(result, started_at),+ Some(Err(_elapsed)) => {+ task.abort();+ info!("startup websocket prewarm timed out before the first turn could use it");+ SessionStartupPrewarmResolution::Unavailable {+ status: "timed_out",+ prewarm_duration: Some(started_at.elapsed()),}}+ None => {+ task.abort();+ session_telemetry.record_startup_phase(+ "startup_prewarm_resolve",+ resolve_started_at.elapsed(),+ Some("cancelled"),+ );+ session_telemetry.record_duration(+ STARTUP_PREWARM_AGE_AT_FIRST_TURN_METRIC,+ age_at_first_turn,+ &[("status", "cancelled")],+ );+ session_telemetry.record_duration(+ STARTUP_PREWARM_DURATION_METRIC,+ started_at.elapsed(),+ &[("status", "cancelled")],+ );+ return SessionStartupPrewarmResolution::Cancelled;+ }}};let status = match &resolution {@@ -219,43 +205,15 @@ impl Session {return;}if let Some(prewarm) = state.startup_prewarm.as_mut() {- if let SessionStartupPrewarmTask::Running(task) = &mut prewarm.task {- let Some(completed) = task.now_or_never() else {- return;- };- prewarm.task = SessionStartupPrewarmTask::Completed(- SessionStartupPrewarmHandle::resolution_from_join_result(- completed,- prewarm.started_at,- ),- );- }- if let SessionStartupPrewarmTask::Completed(SessionStartupPrewarmResolution::Ready(- client_session,- )) = &prewarm.task- && client_session.is_websocket_prewarmed()- {+ let Some(completed) = (&mut prewarm.task).now_or_never() else {return;- }- } else if self.services.model_client.is_websocket_prewarmed() {- return;+ };+ // Return a completed warmup's client to the existing cache before+ // rechecking its socket: it may have closed since the last resume.+ drop(completed);+ state.startup_prewarm = None;}- // Keep ownership explicit when repairing a completed warmup's connection.- let client_session = match state.startup_prewarm.take() {- Some(prewarm) => match prewarm.task {- SessionStartupPrewarmTask::Completed(SessionStartupPrewarmResolution::Ready(- client_session,- )) => Some(*client_session),- SessionStartupPrewarmTask::Completed(_) => None,- SessionStartupPrewarmTask::Running(_) => {- state.startup_prewarm = Some(prewarm);- return;- }- },- None => None,- };-if self.features().enabled(Feature::CodeModePrewarm)&& self.services.code_mode_service.is_available(){@@ -284,8 +242,7 @@ impl Session {let startup_prewarm_session = Arc::clone(self);let startup_prewarm = tokio::spawn(async move {- let result =- schedule_startup_prewarm_inner(startup_prewarm_session, client_session).await;+ let result = schedule_startup_prewarm_inner(startup_prewarm_session).await;let status = if result.is_ok() { "ready" } else { "failed" };session_telemetry.record_startup_phase("startup_prewarm_total",@@ -328,10 +285,7 @@ impl Session {}}-async fn schedule_startup_prewarm_inner(- session: Arc<Session>,- client_session: Option<ModelClientSession>,-) -> CodexResult<ModelClientSession> {+async fn schedule_startup_prewarm_inner(session: Arc<Session>) -> CodexResult<ModelClientSession> {let prewarm_started_at = Instant::now();let base_instructions = session.get_prompt_base_instructions().await.text;let startup_turn_context = session@@ -375,8 +329,7 @@ async fn schedule_startup_prewarm_inner(window_number,context_window_id,);- let mut client_session =- client_session.unwrap_or_else(|| session.services.model_client.new_session());+ let mut client_session = session.services.model_client.new_session();// Start the handshake with the expected route while capturing tools for generate=false.let (step_context, ()) = tokio::try_join!(async {diff --git a/codex-rs/core/tests/suite/client_websockets.rs b/codex-rs/core/tests/suite/client_websockets.rsindex d57c3b67fb..d97b564867 100755--- a/codex-rs/core/tests/suite/client_websockets.rs+++ b/codex-rs/core/tests/suite/client_websockets.rs@@ -9,7 +9,6 @@ use codex_core::ResponseEvent;use codex_core::TurnInputRequest;use codex_core::X_CODEX_ROUTING_HINT_HEADER;use codex_core::X_RESPONSESAPI_INCLUDE_TIMING_METRICS_HEADER;-use codex_core::test_support::EmptyUserInstructionsProvider;use codex_core::test_support::with_parent_turn;use codex_extension_api::ExtensionRegistryBuilder;use codex_features::Feature;@@ -63,7 +62,6 @@ use core_test_support::responses::start_websocket_server;use core_test_support::responses::start_websocket_server_with_headers;use core_test_support::responses_metadata as test_responses_metadata;use core_test_support::skip_if_no_network;-use core_test_support::test_codex::RecordingUserInstructionsProvider;use core_test_support::test_codex::test_codex;use core_test_support::tracing::install_test_tracing;use core_test_support::wait_for_event;@@ -637,25 +635,27 @@ async fn responses_websocket_resume_prewarm_reuses_and_repairs_connection() -> 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 response baseline and skips preparation.- let instruction_loads = instructions.load_count();+ // A healthy warm resume preserves the existing response baseline.test.codex.prewarm().await;test.codex.prewarm().await;test.submit_text_turn("continue").await?;assert_eq!(server.handshakes().len(), 1);- assert_eq!(instructions.load_count(), instruction_loads + 1);+ assert_eq!(+ server.single_handshake().header(USER_AGENT_HEADER),+ Some(codex_login::default_client::get_codex_user_agent())+ );+ assert_eq!(+ server.single_handshake().header("x-codex-window-id"),+ Some(format!("{}:0", test.session_configured.thread_id))+ );let connection = server.single_connection();assert_eq!(connection.len(), 3);assert_eq!(connection[2].body_json()["previous_response_id"], "resp-1");