Skip to content

armgit / codex

Public Imported from GitHub
0

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.lock
index 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.rs
index 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.rs
new file mode 100644
index 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.toml
index 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.rs
index 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.rs
index 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.rs
index 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)
.await
diff --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.rs
index 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.rs
index 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_classifications
assert_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());