Lightweight coding agent that runs in your terminal
Rust
Keep Guardian v2 WebSocket pools warm with concurrent replenishment (#51378)
jif73178e7ca60f
diff --git a/codex-rs/Cargo.lock b/codex-rs/Cargo.lockindex 295d1f826b..95b790c8ad 100644--- a/codex-rs/Cargo.lock+++ b/codex-rs/Cargo.lock@@ -3610,6 +3610,7 @@ dependencies = ["codex-prompts","codex-protocol","codex-utils-cargo-bin",+ "codex-websocket-client","core_test_support","dirs","http 1.4.0",diff --git a/codex-rs/codex-api/src/endpoint/responses_websocket.rs b/codex-rs/codex-api/src/endpoint/responses_websocket.rsindex 9e79edda92..af7fca9c41 100644--- a/codex-rs/codex-api/src/endpoint/responses_websocket.rs+++ b/codex-rs/codex-api/src/endpoint/responses_websocket.rs@@ -349,6 +349,8 @@ impl ResponsesWebsocketConnection {}}+mod connector;+/// Client for connecting to the Responses WebSocket endpoint for one provider.pub struct ResponsesWebsocketClient {provider: Provider,@@ -385,12 +387,6 @@ impl ResponsesWebsocketClient {Self { provider, auth }}- #[instrument(- name = "responses_websocket.connect",- level = "info",- skip_all,- fields(transport = "responses_websocket", api.path = "/responses")- )]pub async fn connect(&self,http_client_factory: &HttpClientFactory,@@ -399,24 +395,16 @@ impl ResponsesWebsocketClient {turn_state: Option<Arc<OnceLock<String>>>,telemetry: Option<Arc<dyn WebsocketTelemetry>>,) -> Result<ResponsesWebsocketConnection, ApiError> {- let ws_url = self- .provider- .websocket_url_for_path("/responses")- .map_err(|err| ApiError::Stream(format!("failed to build websocket URL: {err}")))?;-- let mut headers =- merge_request_headers(&self.provider.headers, extra_headers, default_headers);- self.auth.add_auth_headers(&mut headers);-- let (stream, _status, server_reasoning_included, server_model) =- connect_websocket(ws_url, headers, http_client_factory, turn_state.clone()).await?;- Ok(ResponsesWebsocketConnection::new(- stream,- self.provider.stream_idle_timeout,- server_reasoning_included,- server_model,+ let connector = WebSocketConnector::new(http_client_factory)+ .map_err(|err| ApiError::Stream(format!("failed to configure websocket TLS: {err}")))?;+ self.connect_with_connector(+ &connector,+ extra_headers,+ default_headers,+ turn_state,telemetry,- ))+ )+ .await}/// Opens a WebSocket connection long enough to validate the upgrade response.@@ -442,10 +430,12 @@ impl ResponsesWebsocketClient {merge_request_headers(&self.provider.headers, extra_headers, default_headers);self.auth.add_auth_headers(&mut headers);+ let connector = WebSocketConnector::new(http_client_factory)+ .map_err(|err| ApiError::Stream(format!("failed to configure websocket TLS: {err}")))?;let (mut stream, status, reasoning_included, server_model) = connect_websocket(ws_url.clone(),headers,- http_client_factory,+ &connector,/*turn_state*/ None,).await?;@@ -499,7 +489,7 @@ fn merge_request_headers(async fn connect_websocket(url: Url,headers: HeaderMap,- http_client_factory: &HttpClientFactory,+ connector: &WebSocketConnector,turn_state: Option<Arc<OnceLock<String>>>,) -> Result<(WsStream, StatusCode, bool, Option<String>), ApiError> {info!("connecting to websocket: {url}");@@ -510,8 +500,6 @@ async fn connect_websocket(.map_err(|err| ApiError::Stream(format!("failed to build websocket request: {err}")))?;request.headers_mut().extend(headers);- let connector = WebSocketConnector::new(http_client_factory)- .map_err(|err| ApiError::Stream(format!("failed to configure websocket TLS: {err}")))?;let response = connector.connect(request, websocket_config()).await;let (stream, response) = match response {diff --git a/codex-rs/codex-api/src/endpoint/responses_websocket/connector.rs b/codex-rs/codex-api/src/endpoint/responses_websocket/connector.rsnew file mode 100644index 0000000000..e305ca3a4a--- /dev/null+++ b/codex-rs/codex-api/src/endpoint/responses_websocket/connector.rs@@ -0,0 +1,49 @@+//! Establishes Responses sockets with caller-owned TLS and proxy configuration.+//! Connector reuse never caches authentication or bypasses per-connection destination policy.++use super::ResponsesWebsocketClient;+use super::ResponsesWebsocketConnection;+use super::connect_websocket;+use super::merge_request_headers;+use crate::ApiError;+use crate::WebsocketTelemetry;+use codex_websocket_client::WebSocketConnector;+use http::HeaderMap;+use std::sync::Arc;+use std::sync::OnceLock;++impl ResponsesWebsocketClient {+ /// Opens a socket using the caller's reusable connector and this client's current auth.+ /// The caller owns the lifetime of the connector's TLS configuration snapshot.+ #[tracing::instrument(+ name = "responses_websocket.connect",+ level = "info",+ skip_all,+ fields(transport = "responses_websocket", api.path = "/responses")+ )]+ pub async fn connect_with_connector(+ &self,+ connector: &WebSocketConnector,+ extra_headers: HeaderMap,+ default_headers: HeaderMap,+ turn_state: Option<Arc<OnceLock<String>>>,+ telemetry: Option<Arc<dyn WebsocketTelemetry>>,+ ) -> Result<ResponsesWebsocketConnection, ApiError> {+ let ws_url = self+ .provider+ .websocket_url_for_path("/responses")+ .map_err(|err| ApiError::Stream(format!("failed to build websocket URL: {err}")))?;+ let mut headers =+ merge_request_headers(&self.provider.headers, extra_headers, default_headers);+ self.auth.add_auth_headers(&mut headers);+ let (stream, _status, server_reasoning_included, server_model) =+ connect_websocket(ws_url, headers, connector, turn_state).await?;+ Ok(ResponsesWebsocketConnection::new(+ stream,+ self.provider.stream_idle_timeout,+ server_reasoning_included,+ server_model,+ telemetry,+ ))+ }+}diff --git a/codex-rs/ext/guardian-v2/Cargo.toml b/codex-rs/ext/guardian-v2/Cargo.tomlindex 02e69106b5..d192013a5e 100644--- a/codex-rs/ext/guardian-v2/Cargo.toml+++ b/codex-rs/ext/guardian-v2/Cargo.toml@@ -29,6 +29,7 @@ codex-login = { workspace = true }codex-model-provider = { workspace = true }codex-protocol = { workspace = true }codex-prompts = { workspace = true }+codex-websocket-client = { workspace = true }dirs = { workspace = true }http = { workspace = true }serde_json = { workspace = true }diff --git a/codex-rs/ext/guardian-v2/src/async_scorer/extension_tests.rs b/codex-rs/ext/guardian-v2/src/async_scorer/extension_tests.rsindex 70b5f18a73..772e7189e2 100644--- a/codex-rs/ext/guardian-v2/src/async_scorer/extension_tests.rs+++ b/codex-rs/ext/guardian-v2/src/async_scorer/extension_tests.rs@@ -380,7 +380,7 @@ struct RecordingMetrics(Mutex<Vec<RecordedMetric>>);impl RecordingMetrics {fn classification_samples(&self) -> Vec<RecordedMetric> {self.0.lock().unwrap().iter().filter(|sample| {- !matches!(sample, RecordedMetric::Histogram(name, _, _) if name == codex_guardian_context::SECTION_COST_METRIC || name == codex_guardian_context::REQUEST_TOKENS_METRIC)+ !matches!(sample, RecordedMetric::Histogram(name, _, _) if name == codex_guardian_context::SECTION_COST_METRIC || name == codex_guardian_context::REQUEST_TOKENS_METRIC || name.starts_with("codex.guardian_v2.connection."))}).cloned().collect()}}diff --git a/codex-rs/ext/guardian-v2/src/async_scorer/sampler.rs b/codex-rs/ext/guardian-v2/src/async_scorer/sampler.rsindex 1ac369f551..13111d0a46 100644--- a/codex-rs/ext/guardian-v2/src/async_scorer/sampler.rs+++ b/codex-rs/ext/guardian-v2/src/async_scorer/sampler.rs@@ -152,9 +152,7 @@ impl LunaSampler {}pub(super) async fn prewarm(&self) {- if let Some(refill) = self.connections.replenish() {- let _ = refill.await;- }+ self.connections.prewarm().await;}fn auth_owner_generation(&self) -> Option<u64> {diff --git a/codex-rs/ext/guardian-v2/src/async_scorer/sampler/connection_pool.rs b/codex-rs/ext/guardian-v2/src/async_scorer/sampler/connection_pool.rsindex 70817b00cd..c561f94e95 100644--- a/codex-rs/ext/guardian-v2/src/async_scorer/sampler/connection_pool.rs+++ b/codex-rs/ext/guardian-v2/src/async_scorer/sampler/connection_pool.rs@@ -1,8 +1,10 @@//! Keeps WebSocket establishment off the classification path.-//! One background worker fills the pool. Opening timeouts pause replenishment;+//! One background worker fills the pool with bounded concurrent opens before it empties.+//! Opening timeouts pause replenishment without discarding healthy in-flight opens;//! requests with no healthy idle socket use HTTP under the same concurrency limit.//! Each lease resolves workspace routing before reusing a socket or starting HTTP.//! Constrained HTTP clients reject redirects, including after a cache policy change.+//! TLS roots are loaded once per sampler, like the pooled HTTP transport configuration.use super::super::metrics::sampler_failure_reason;use super::INITIAL_WEBSOCKET_CONNECTIONS;@@ -34,19 +36,24 @@ use codex_model_provider::ProviderAuthScope;use codex_model_provider::ResolvedResponsesProvider;use codex_model_provider::ResponsesConnectionKey;use codex_protocol::ThreadId;+use codex_websocket_client::WebSocketConnector;use http::HeaderMap;use http::HeaderValue;use std::sync::Arc;use std::sync::Mutex;use std::time::Duration;use tokio::sync::OnceCell;+use tokio::sync::OwnedMutexGuard;use tokio::sync::OwnedSemaphorePermit;use tokio::sync::Semaphore;use tokio::task::JoinHandle;+use tokio::task::JoinSet;use tokio::time::Instant;const CONNECT_COOLDOWN: Duration = Duration::from_secs(5 * 60);const MAX_WEBSOCKET_AGE: Duration = Duration::from_secs(55 * 60);+const MAX_CONCURRENT_OPENS: usize = 4;+const REFILL_LOW_WATERMARK: usize = INITIAL_WEBSOCKET_CONNECTIONS / 2;const RESPONSES_WEBSOCKETS_BETA: &str = "responses_websockets=2026-02-06";#[derive(Clone, Copy, PartialEq, Eq)]@@ -64,6 +71,7 @@ pub(super) struct ConnectionPool {replenishing: Arc<tokio::sync::Mutex<()>>,retry_after: Mutex<Option<Instant>>,http_transport: Mutex<Option<Arc<HttpTransport>>>,+ websocket_connector: OnceCell<WebSocketConnector>,}struct HttpTransport {@@ -76,7 +84,7 @@ pub(super) struct PooledConnection {connection: ResponsesWebsocketConnection,request_kind: RequestMode,// The bridge routes by thread ID, so each socket needs its own identity.- thread_id: String,+ pub(super) thread_id: String,pub(super) expires_at: Instant,auth_changes: Option<tokio::sync::watch::Receiver<u64>>,key: ResponsesConnectionKey,@@ -114,6 +122,7 @@ impl ConnectionPool {replenishing: Arc::new(tokio::sync::Mutex::new(())),retry_after: Mutex::new(None),http_transport: Mutex::new(None),+ websocket_connector: OnceCell::new(),})}@@ -127,42 +136,64 @@ impl ConnectionPool {/// Never waits for another opener or sleeps through the cooldown.pub(super) fn replenish(self: &Arc<Self>) -> Option<JoinHandle<()>> {let guard = Arc::clone(&self.replenishing).try_lock_owned().ok()?;- if self+ self.start_refill(guard)+ }++ pub(super) async fn prewarm(self: &Arc<Self>) {+ // Explicit prewarming waits for any existing refill before checking readiness.+ let guard = Arc::clone(&self.replenishing).lock_owned().await;+ if let Some(refill) = self.start_refill(guard) {+ let _ = refill.await;+ }+ }++ fn start_refill(self: &Arc<Self>, guard: OwnedMutexGuard<()>) -> Option<JoinHandle<()>> {+ let mut retry_after = self.retry_after.lock()- .unwrap_or_else(std::sync::PoisonError::into_inner)- .is_some_and(|deadline| Instant::now() < deadline)- {+ .unwrap_or_else(std::sync::PoisonError::into_inner);+ if retry_after.is_some_and(|deadline| Instant::now() < deadline) {return None;}+ *retry_after = None;+ drop(retry_after);let pool = Arc::clone(self);Some(tokio::spawn(async move {let _guard = guard;+ let mut opening = JoinSet::new();+ let mut failed = false;loop {- if pool+ let idle = pool.idle_connections.lock().unwrap_or_else(std::sync::PoisonError::into_inner)- .len()- >= INITIAL_WEBSOCKET_CONNECTIONS+ .len();+ while !failed+ && idle + opening.len() < INITIAL_WEBSOCKET_CONNECTIONS+ && opening.len() < MAX_CONCURRENT_OPENS{- break;+ let Ok(permit) = Arc::clone(&pool.sockets).try_acquire_owned() else {+ break;+ };+ let pool = Arc::clone(&pool);+ opening.spawn(async move { pool.open_connection(permit).await });}- let Ok(permit) = Arc::clone(&pool.sockets).try_acquire_owned() else {+ let Some(result) = opening.join_next().await else {break;};- match pool.open_connection(permit).await {- Ok(connection) => {- *pool- .retry_after+ match result {+ Ok(Ok(connection)) => {+ let mut idle = pool+ .idle_connections.lock()- .unwrap_or_else(std::sync::PoisonError::into_inner) = None;- pool.idle_connections- .lock()- .unwrap_or_else(std::sync::PoisonError::into_inner)- .push(connection);+ .unwrap_or_else(std::sync::PoisonError::into_inner);+ // Returned leases may have refilled the pool while we opened.+ if idle.len() < INITIAL_WEBSOCKET_CONNECTIONS {+ idle.push(connection);+ }}- Err(error) => {+ Ok(Err(error)) => {+ failed = true;if matches!(error, LunaSamplerError::ConnectionTimeout) {*pool.retry_after@@ -170,18 +201,20 @@ impl ConnectionPool {.unwrap_or_else(std::sync::PoisonError::into_inner) =Some(Instant::now() + CONNECT_COOLDOWN);}- break;}+ Err(_) => failed = true,}}}))}pub(super) async fn lease(self: &Arc<Self>) -> Result<ConnectionLease, LunaSamplerError> {+ let started = Instant::now();let permit = Arc::clone(&self.classifications).acquire_owned().await.map_err(|error| LunaSamplerError::Api(ApiError::Stream(error.to_string())))?;+ let admitted = Instant::now();let ClientSetup {mut provider,auth,@@ -189,6 +222,7 @@ impl ConnectionPool {key,auth_changes,} = self.client_setup().await?;+ let setup_finished = Instant::now();let connection = loop {let idle = self.idle_connections@@ -213,6 +247,15 @@ impl ConnectionPool {};let (connection, thread_id, request_kind) = match connection {Some(connection) => {+ if self+ .idle_connections+ .lock()+ .unwrap_or_else(std::sync::PoisonError::into_inner)+ .len()+ <= REFILL_LOW_WATERMARK+ {+ self.replenish();+ }let thread_id = connection.thread_id.clone();let request_kind = connection.request_kind;(Connection::Websocket(connection), thread_id, request_kind)@@ -283,6 +326,23 @@ impl ConnectionPool {"authentication changed while leasing".into(),)));}+ if let Some(metrics) = self.config.metrics.as_deref() {+ let transport = match &connection {+ Connection::Websocket(_) => "websocket",+ Connection::Http(_) => "http",+ };+ for (stage, duration) in [+ ("admission", admitted.duration_since(started)),+ ("setup", setup_finished.duration_since(admitted)),+ ("total", started.elapsed()),+ ] {+ metrics.histogram(+ "codex.guardian_v2.connection.lease.duration_ms",+ i64::try_from(duration.as_millis()).unwrap_or(i64::MAX),+ &[("stage", stage), ("transport", transport)],+ );+ }+ }Ok(ConnectionLease {thread_id,request_kind,@@ -413,13 +473,31 @@ impl ConnectionPool {let provider_info = self.config.provider.info();let client = ResponsesWebsocketClient::new(provider, auth);- let connect = client.connect(- &self.config.http_client_factory,- headers,- default_headers(),- /*turn_state*/ None,- /*telemetry*/ None,- );+ let connect = async {+ let connector = self+ .websocket_connector+ .get_or_try_init(|| async {+ let factory = self.config.http_client_factory.clone();+ tokio::task::spawn_blocking(move || WebSocketConnector::new(&factory))+ .await+ .map_err(|error| {+ ApiError::Stream(format!("websocket TLS setup task failed: {error}"))+ })?+ .map_err(|error| {+ ApiError::Stream(format!("failed to configure websocket TLS: {error}"))+ })+ })+ .await?;+ client+ .connect_with_connector(+ connector,+ headers,+ default_headers(),+ /*turn_state*/ None,+ /*telemetry*/ None,+ )+ .await+ };let started_at = Instant::now();let result = tokio::time::timeout(provider_info.websocket_connect_timeout(), connect).awaitdiff --git a/codex-rs/ext/guardian-v2/src/async_scorer/sampler/connection_pool_tests.rs b/codex-rs/ext/guardian-v2/src/async_scorer/sampler/connection_pool_tests.rsindex 6cf716de8d..eff1d7e27b 100644--- a/codex-rs/ext/guardian-v2/src/async_scorer/sampler/connection_pool_tests.rs+++ b/codex-rs/ext/guardian-v2/src/async_scorer/sampler/connection_pool_tests.rs@@ -1,6 +1,8 @@//! Exercises classifier fallback, cooldown, and cancellation against local servers.use super::super::LunaSampler;+use super::super::tests::ProxyPrewarmLimit;+use super::super::tests::proxy_websocket_servers_with_http;use super::super::tests::sample_request;use super::super::tests::sampler_config;use super::*;@@ -82,6 +84,99 @@ impl Drop for Gateway {}}+#[tokio::test]+async fn stalled_handshake_does_not_delay_other_warm_sockets() -> Result<()> {+ skip_if_no_network!(Ok(()));+ let stalled = responses::start_websocket_server_with_headers(vec![+ responses::WebSocketConnectionConfig {+ requests: Vec::new(),+ response_headers: Vec::new(),+ accept_delay: Some(Duration::from_secs(/*secs*/ 10)),+ close_after_requests: false,+ },+ ])+ .await;+ let healthy = responses::start_websocket_server(vec![vec![vec![+ responses::ev_output_text_delta("low"),+ responses::ev_completed("score"),+ ]]])+ .await;+ let url = proxy_websocket_servers_with_http(+ &[&stalled, &healthy],+ ProxyPrewarmLimit::AllConnections,+ /*http_url*/ None,+ )+ .await?;+ let sampler = LunaSampler::new(sampler_config(url));+ let opener = sampler.connections.replenish().unwrap();+ tokio::time::timeout(Duration::from_secs(2), async {+ while sampler+ .connections+ .idle_connections+ .lock()+ .unwrap()+ .is_empty()+ {+ tokio::task::yield_now().await;+ }+ })+ .await?;+ assert!(!opener.is_finished());+ assert_eq!(+ sampler.sample(sample_request("healthy-socket")).await?,+ "low"+ );+ assert_eq!(healthy.single_connection().len(), 1);+ opener.abort();+ let _ = opener.await;+ drop(stalled);+ healthy.shutdown().await;+ Ok(())+}++#[tokio::test]+async fn replenishes_before_last_idle_socket_is_leased() -> Result<()> {+ skip_if_no_network!(Ok(()));+ let mut servers = Vec::new();+ for _ in 0..INITIAL_WEBSOCKET_CONNECTIONS + 1 {+ servers.push(+ responses::start_websocket_server_with_headers(vec![+ responses::WebSocketConnectionConfig {+ requests: Vec::new(),+ response_headers: Vec::new(),+ accept_delay: None,+ close_after_requests: false,+ },+ ])+ .await,+ );+ }+ let url = proxy_websocket_servers_with_http(+ &servers.iter().collect::<Vec<_>>(),+ ProxyPrewarmLimit::AllConnections,+ /*http_url*/ None,+ )+ .await?;+ let sampler = LunaSampler::new(sampler_config(url));+ sampler.prewarm().await;+ let held = sampler.connections.lease().await?;+ assert!(matches!(held.connection, Connection::Websocket(_)));+ // A healthy socket remains available, but the next burst needs the reserve restored.+ sampler.wait_for_prewarm(Duration::from_secs(2)).await?;+ let mut burst = Vec::new();+ for _ in 0..INITIAL_WEBSOCKET_CONNECTIONS {+ let lease = sampler.connections.lease().await?;+ assert!(matches!(lease.connection, Connection::Websocket(_)));+ burst.push(lease);+ }+ drop(burst);+ drop(held);+ for server in servers {+ server.shutdown().await;+ }+ Ok(())+}+#[tokio::test]async fn cold_pool_uses_http_during_open_timeout_then_recovers_after_cooldown() -> Result<()> {skip_if_no_network!(Ok(()));@@ -131,7 +226,10 @@ async fn cold_pool_uses_http_during_open_timeout_then_recovers_after_cooldown()sampler.sample(sample_request("parent-turn-2")).await?,"low");- assert_eq!(gateway.opens.load(Ordering::SeqCst), 1);+ assert_eq!(+ gateway.opens.load(Ordering::SeqCst),+ INITIAL_WEBSOCKET_CONNECTIONS+ );assert!(!opener.is_finished());assert!(sampler.connections.replenish().is_none());@@ -144,7 +242,10 @@ async fn cold_pool_uses_http_during_open_timeout_then_recovers_after_cooldown()sampler.sample(sample_request("during-cooldown")).await?,"low");- assert_eq!(gateway.opens.load(Ordering::SeqCst), 1);+ assert_eq!(+ gateway.opens.load(Ordering::SeqCst),+ INITIAL_WEBSOCKET_CONNECTIONS+ );let requests = http_mock.requests();let first = &requests[0];@@ -178,15 +279,15 @@ async fn cold_pool_uses_http_during_open_timeout_then_recovers_after_cooldown()tokio::time::advance(CONNECT_COOLDOWN).await;tokio::time::resume();sampler.connections.replenish().unwrap().await?;+ assert_eq!(+ gateway.opens.load(Ordering::SeqCst),+ 2 * INITIAL_WEBSOCKET_CONNECTIONS+ );assert_eq!(sampler.sample(sample_request("after-cooldown")).await?,"low");assert_eq!(http_mock.requests().len(), 3);- assert_eq!(- gateway.opens.load(Ordering::SeqCst),- 1 + INITIAL_WEBSOCKET_CONNECTIONS- );}Ok(())}@@ -209,7 +310,14 @@ async fn cooldown_preserves_healthy_sockets_and_both_transports_share_capacity()let sampler = LunaSampler::new(sampler_config(format!("{}/v1", gateway.url)));let opener = sampler.connections.replenish().unwrap();tokio::time::timeout(Duration::from_secs(5), async {- while gateway.opens.load(Ordering::SeqCst) < 2 {+ while gateway.opens.load(Ordering::SeqCst) < 2+ || sampler+ .connections+ .idle_connections+ .lock()+ .unwrap()+ .is_empty()+ {tokio::task::yield_now().await;}})diff --git a/codex-rs/ext/guardian-v2/src/async_scorer/sampler_tests.rs b/codex-rs/ext/guardian-v2/src/async_scorer/sampler_tests.rsindex 4fee4370bd..87a6c15892 100644--- a/codex-rs/ext/guardian-v2/src/async_scorer/sampler_tests.rs+++ b/codex-rs/ext/guardian-v2/src/async_scorer/sampler_tests.rs@@ -172,7 +172,6 @@ pub(in crate::async_scorer) async fn proxy_websocket_servers_with_http(}let target = if &method == b"GET " {if let ProxyPrewarmLimit::StopAfter { ready_connections } = prewarm_limit- && ready_connections < INITIAL_WEBSOCKET_CONNECTIONS&& index == ready_connections&& !failed_prewarm{@@ -599,6 +598,8 @@ async fn preconnected_sampler_reuses_authenticated_websocket_for_classifications}}).await?;+ // Finish the opportunistic refill (rejected by the proxy) before rotating auth.+ sampler.prewarm().await;manager.refresh_token_from_authority().await?;sampler.connections.clear();sampler.prewarm().await;@@ -621,7 +622,13 @@ async fn preconnected_sampler_reuses_authenticated_websocket_for_classificationsassert_eq!(second, "high");// Reuse the same socket after a nested owner, now with unknown root lineage.assert_eq!(sampler.sample(sample_request("turn-3")).await?, "low");- let mut requests = server.single_connection();+ // Concurrent handshakes may finish in either order.+ let (used, unused) = if server.single_connection().is_empty() {+ (&idle_server, &server)+ } else {+ (&server, &idle_server)+ };+ let mut requests = used.single_connection();assert_eq!(requests.len(), 1);assert_eq!(refreshed.single_handshake().header("authorization"),@@ -629,7 +636,7 @@ async fn preconnected_sampler_reuses_authenticated_websocket_for_classifications);requests.extend(refreshed.single_connection());assert_eq!(requests.len(), 3);- let thread_id = assert_connection_metadata(&server, &[("turn-1", Some("turn-1"))])?;+ let thread_id = assert_connection_metadata(used, &[("turn-1", Some("turn-1"))])?;assert_connection_metadata(&refreshed, &[("turn-2", Some("root-2")), ("turn-3", None)])?;assert_ne!(requests[1].body_json()["client_metadata"]["turn_id"],@@ -637,7 +644,7 @@ async fn preconnected_sampler_reuses_authenticated_websocket_for_classifications);assert_ne!(Some(thread_id),- idle_server.single_handshake().header("thread-id")+ unused.single_handshake().header("thread-id"));assert_eq!(requests[0].body_json()["input"][2]["content"],@@ -910,6 +917,15 @@ async fn sampler_replaces_scored_drains_before_unfinished_classifications() -> R.await?,);+ // Select the stalled socket first independently of handshake completion order.+ let stalled_id = servers[1].single_handshake().header("thread-id").unwrap();+ sampler+ .connections+ .idle_connections+ .lock()+ .unwrap()+ .sort_by_key(|connection| connection.thread_id == stalled_id);+let oldest_sampler = Arc::clone(&sampler);let oldest = tokio::spawn(async move { oldest_sampler.sample(sample_request("oldest")).await });tokio::time::timeout(@@ -918,6 +934,15 @@ async fn sampler_replaces_scored_drains_before_unfinished_classifications() -> R).await?;+ // Finish the refill before selecting a socket; it must not append after sorting.+ sampler.prewarm().await;+ let scored_id = servers[0].single_handshake().header("thread-id").unwrap();+ sampler+ .connections+ .idle_connections+ .lock()+ .unwrap()+ .sort_by_key(|connection| connection.thread_id == scored_id);let scored_sampler = Arc::clone(&sampler);let scored_request =tokio::spawn(async move { scored_sampler.sample(sample_request("scored")).await });@@ -994,6 +1019,15 @@ async fn sampler_retries_expired_websockets_on_another_warm_connection() -> Resu)).await?;+ // Start on the expired socket so this exercises recovery in either open order.+ let expired_id = expired.single_handshake().header("thread-id").unwrap();+ sampler+ .connections+ .idle_connections+ .lock()+ .unwrap()+ .sort_by_key(|connection| connection.thread_id == expired_id);+let mut request = sample_request("turn-1");request.input.insert(/*index*/ 0,@@ -1082,15 +1116,20 @@ async fn sampler_uses_http_with_a_fresh_identity_when_warm_connections_expire().header("thread-id").expect("HTTP classifier thread ID");ThreadId::from_string(&http_thread_id)?;+ let (used, unused) = if first.single_connection().is_empty() {+ (&second, &first)+ } else {+ (&first, &second)+ };let thread_ids = HashSet::from([- assert_connection_metadata(&first, &[])?,- assert_connection_metadata(&second, &[("turn-1", None)])?,+ assert_connection_metadata(unused, &[])?,+ assert_connection_metadata(used, &[("turn-1", None)])?,http_thread_id,]);assert_eq!(thread_ids.len(), 3);responses::assert_parent_turn(&request.body_json(), Some("turn-2"))?;assert_classifier_instructions(&request.body_json());- assert_eq!(second.single_connection().len(), 1);+ assert_eq!(used.single_connection().len(), 1);Ok(())}@@ -1232,6 +1271,13 @@ async fn parent_response_id_survives_classifier_transport_retry() -> Result<()>);}let sampler = connect_sampler(config).await?;+ let expired_id = expired.single_handshake().header("thread-id").unwrap();+ sampler+ .connections+ .idle_connections+ .lock()+ .unwrap()+ .sort_by_key(|connection| connection.thread_id == expired_id);let parent_response_id = "resp-parent";let mut request = sample_request("turn-1");request.parent_response_id = Some(parent_response_id.to_owned());