Skip to content

Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy

Rust

bound codex websocket continuation stalls

Raine Virta660459e37f1a
diff --git a/src/providers/codex/client.rs b/src/providers/codex/client.rs
index b21247c..c817e60 100644
--- a/src/providers/codex/client.rs
+++ b/src/providers/codex/client.rs
@@ -412,14 +412,12 @@ impl CodexHttpClient {
});
}
Ok(response) => return Ok(response),
- Err(err) if err.detail.as_deref() == Some("previous_response_not_found") => {
- // Previous response missing: clear continuation and retry once with full request
+ Err(err) if should_retry_without_continuation(&err, continuation) => {
clear_continuation(ctx.session_id.as_deref());
if let Some(key) = pool_key {
super::websocket::invalidate_codex_websocket_pool_key(key);
}
- // Retry with the full body (no continuation) through the relevant transport
let retry_headers = build_codex_headers(&auth, ctx)?;
let full_body_json = serde_json::to_string(body).map_err(|e| CodexError {
status: 500,
@@ -711,6 +709,24 @@ fn should_refresh_after_unauthorized(
}
}
+fn should_retry_without_continuation(
+ err: &CodexError,
+ continuation: Option<&super::continuation::ContinuationCandidate>,
+) -> bool {
+ if continuation
+ .and_then(|c| c.previous_response_id.as_deref())
+ .is_none()
+ {
+ return false;
+ }
+
+ matches!(
+ err.detail.as_deref(),
+ Some("previous_response_not_found")
+ | Some(super::websocket::WEBSOCKET_RESPONSE_START_TIMEOUT_DETAIL)
+ )
+}
+
fn websocket_pool_key<'a>(
ctx: &'a RequestContext,
continuation: Option<&super::continuation::ContinuationCandidate>,
@@ -987,4 +1003,49 @@ mod tests {
assert!(!should_refresh_after_unauthorized(&forbidden, 0));
assert!(!should_refresh_after_unauthorized(&http_unauthorized, 1));
}
+
+ #[test]
+ fn continuation_retry_requires_previous_response_id() {
+ let append = super::super::continuation::ContinuationCandidate {
+ previous_response_id: Some("resp_1".into()),
+ input_delta: None,
+ input_delta_count: 1,
+ disabled_reason: None,
+ };
+ let initial = super::super::continuation::ContinuationCandidate {
+ previous_response_id: None,
+ input_delta: None,
+ input_delta_count: 1,
+ disabled_reason: Some("missing_state".into()),
+ };
+ let timeout = CodexError {
+ status: 0,
+ message: "WebSocket response start timeout after 60000ms".to_string(),
+ detail: Some(
+ super::super::websocket::WEBSOCKET_RESPONSE_START_TIMEOUT_DETAIL.to_string(),
+ ),
+ retry_after: None,
+ origin: CodexErrorOrigin::WebSocket,
+ };
+ let missing = CodexError {
+ status: 0,
+ message: "Previous response not found".to_string(),
+ detail: Some("previous_response_not_found".to_string()),
+ retry_after: None,
+ origin: CodexErrorOrigin::WebSocket,
+ };
+ let idle = CodexError {
+ status: 0,
+ message: "WebSocket idle timeout after 60000ms".to_string(),
+ detail: None,
+ retry_after: None,
+ origin: CodexErrorOrigin::WebSocket,
+ };
+
+ assert!(should_retry_without_continuation(&timeout, Some(&append)));
+ assert!(should_retry_without_continuation(&missing, Some(&append)));
+ assert!(!should_retry_without_continuation(&idle, Some(&append)));
+ assert!(!should_retry_without_continuation(&timeout, Some(&initial)));
+ assert!(!should_retry_without_continuation(&timeout, None));
+ }
}
diff --git a/src/providers/codex/websocket.rs b/src/providers/codex/websocket.rs
index ce2a68a..c536230 100644
--- a/src/providers/codex/websocket.rs
+++ b/src/providers/codex/websocket.rs
@@ -24,6 +24,7 @@ use super::continuation::ContinuationCandidate;
pub const WEBSOCKET_PROTOCOL_HEADER: &str = "responses_websockets=2026-02-06";
pub const WEBSOCKET_CONNECT_TIMEOUT_MS: u64 = 15_000;
pub const WEBSOCKET_IDLE_TIMEOUT_MS: u64 = 60_000;
+pub const WEBSOCKET_RESPONSE_START_TIMEOUT_DETAIL: &str = "websocket_response_start_timeout";
const POOL_IDLE_TTL_MS: u64 = 30 * 60 * 1000;
const MAX_POOL_ENTRIES: usize = 10_000;
@@ -196,6 +197,14 @@ fn is_terminal_event(payload: &serde_json::Value) -> bool {
}
}
+fn is_response_event(payload: &serde_json::Value) -> bool {
+ match payload.get("type").and_then(|v| v.as_str()) {
+ Some("error") => true,
+ Some(t) => t.starts_with("response."),
+ None => false,
+ }
+}
+
fn is_previous_response_missing(payload: &serde_json::Value) -> bool {
// Check error.code == "previous_response_not_found"
if let Some(code) = payload
@@ -432,6 +441,16 @@ fn missing_terminal_error() -> CodexError {
}
}
+fn response_start_timeout_error(timeout_ms: u64) -> CodexError {
+ CodexError {
+ status: 0,
+ message: format!("WebSocket response start timeout after {timeout_ms}ms"),
+ detail: Some(WEBSOCKET_RESPONSE_START_TIMEOUT_DETAIL.to_string()),
+ retry_after: None,
+ origin: CodexErrorOrigin::WebSocket,
+ }
+}
+
fn write_websocket_metadata_capture(
traffic: &TrafficCapture,
ws_url: &str,
@@ -593,21 +612,61 @@ async fn collect_ws_events(
) -> Result<(Vec<u8>, Option<WsEvent>), CodexError> {
let mut sse_body: Vec<u8> = Vec::new();
let mut terminal_event: Option<WsEvent> = None;
+ let response_event_budget = Duration::from_millis(idle_timeout_ms);
+ let response_wait_started = Instant::now();
+ let mut last_response_event_at = response_wait_started;
+ let mut response_started = false;
loop {
- let timeout = tokio::time::timeout(Duration::from_millis(idle_timeout_ms), ws.next());
+ let response_deadline_started = if response_started {
+ last_response_event_at
+ } else {
+ response_wait_started
+ };
+ let read_timeout = if response_started {
+ match response_event_budget.checked_sub(response_deadline_started.elapsed()) {
+ Some(remaining) if !remaining.is_zero() => remaining,
+ _ => {
+ if let Some(key) = pool_key {
+ invalidate_codex_websocket_pool_key(key);
+ }
+ return Err(CodexError {
+ status: 0,
+ message: format!("WebSocket idle timeout after {idle_timeout_ms}ms"),
+ detail: None,
+ retry_after: None,
+ origin: CodexErrorOrigin::WebSocket,
+ });
+ }
+ }
+ } else {
+ match response_event_budget.checked_sub(response_deadline_started.elapsed()) {
+ Some(remaining) if !remaining.is_zero() => remaining,
+ _ => {
+ if let Some(key) = pool_key {
+ invalidate_codex_websocket_pool_key(key);
+ }
+ return Err(response_start_timeout_error(idle_timeout_ms));
+ }
+ }
+ };
+
+ let timeout = tokio::time::timeout(read_timeout, ws.next());
let frame = timeout.await.map_err(|_| {
- // Idle timeout - invalidate pool
if let Some(key) = pool_key {
invalidate_codex_websocket_pool_key(key);
}
- CodexError {
- status: 0,
- message: format!("WebSocket idle timeout after {idle_timeout_ms}ms"),
- detail: None,
- retry_after: None,
- origin: CodexErrorOrigin::WebSocket,
+ if response_started {
+ CodexError {
+ status: 0,
+ message: format!("WebSocket idle timeout after {idle_timeout_ms}ms"),
+ detail: None,
+ retry_after: None,
+ origin: CodexErrorOrigin::WebSocket,
+ }
+ } else {
+ response_start_timeout_error(idle_timeout_ms)
}
})?;
@@ -638,6 +697,11 @@ async fn collect_ws_events(
tc.write_json_event("040-upstream-event", &parsed);
}
+ if is_response_event(&parsed) {
+ response_started = true;
+ last_response_event_at = Instant::now();
+ }
+
// Check for terminal events
if is_terminal_event(&parsed) {
terminal_event = Some(WsEvent {
@@ -827,6 +891,18 @@ mod tests {
assert!(is_terminal_event(&error));
}
+ #[test]
+ fn is_response_event_detection() {
+ let rate_limits = serde_json::json!({"type": "codex.rate_limits"});
+ assert!(!is_response_event(&rate_limits));
+
+ let output = serde_json::json!({"type": "response.output_text.delta"});
+ assert!(is_response_event(&output));
+
+ let error = serde_json::json!({"type": "error", "error": {"message": "fail"}});
+ assert!(is_response_event(&error));
+ }
+
#[test]
fn is_previous_response_missing_detection() {
let by_code = serde_json::json!({
@@ -934,6 +1010,111 @@ mod tests {
assert!(!WS_POOL.lock().unwrap().contains_key("binary-session"));
}
+ #[tokio::test]
+ async fn response_start_timeout_ignores_rate_limits_and_pings() {
+ clear_codex_websocket_pool_for_tests();
+ let pooled_stream = create_dummy_stream_async().await;
+ {
+ let mut guard = WS_POOL.lock().unwrap();
+ guard.insert(
+ "start-timeout-session".to_string(),
+ Arc::new(PoolEntry {
+ ws: AsyncMutex::new(pooled_stream),
+ created_at: now_ms(),
+ }),
+ );
+ }
+
+ let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+ let addr = listener.local_addr().unwrap();
+ tokio::spawn(async move {
+ let (stream, _) = listener.accept().await.unwrap();
+ let mut ws = tokio_tungstenite::accept_async(stream).await.unwrap();
+ ws.send(Message::Text(
+ r#"{"type":"codex.rate_limits","rate_limits":{"allowed":true}}"#.into(),
+ ))
+ .await
+ .unwrap();
+ loop {
+ if ws.send(Message::Ping(Vec::new())).await.is_err() {
+ break;
+ }
+ tokio::time::sleep(Duration::from_millis(10)).await;
+ }
+ });
+
+ let (mut ws, _) = tokio_tungstenite::connect_async(format!("ws://{addr}/"))
+ .await
+ .unwrap();
+ let err = match collect_ws_events(&mut ws, 50, Some("start-timeout-session"), None).await {
+ Ok(_) => panic!("expected response start timeout"),
+ Err(err) => err,
+ };
+
+ assert_eq!(
+ err.detail.as_deref(),
+ Some(WEBSOCKET_RESPONSE_START_TIMEOUT_DETAIL)
+ );
+ assert!(
+ !WS_POOL
+ .lock()
+ .unwrap()
+ .contains_key("start-timeout-session")
+ );
+ }
+
+ #[tokio::test]
+ async fn response_idle_timeout_ignores_pings_after_response_event() {
+ clear_codex_websocket_pool_for_tests();
+ let pooled_stream = create_dummy_stream_async().await;
+ {
+ let mut guard = WS_POOL.lock().unwrap();
+ guard.insert(
+ "response-idle-session".to_string(),
+ Arc::new(PoolEntry {
+ ws: AsyncMutex::new(pooled_stream),
+ created_at: now_ms(),
+ }),
+ );
+ }
+
+ let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+ let addr = listener.local_addr().unwrap();
+ tokio::spawn(async move {
+ let (stream, _) = listener.accept().await.unwrap();
+ let mut ws = tokio_tungstenite::accept_async(stream).await.unwrap();
+ ws.send(Message::Text(
+ r#"{"type":"response.output_item.added","output_index":0,"item":{"type":"message"}}"#
+ .into(),
+ ))
+ .await
+ .unwrap();
+ loop {
+ if ws.send(Message::Ping(Vec::new())).await.is_err() {
+ break;
+ }
+ tokio::time::sleep(Duration::from_millis(10)).await;
+ }
+ });
+
+ let (mut ws, _) = tokio_tungstenite::connect_async(format!("ws://{addr}/"))
+ .await
+ .unwrap();
+ let err = match collect_ws_events(&mut ws, 50, Some("response-idle-session"), None).await {
+ Ok(_) => panic!("expected response idle timeout"),
+ Err(err) => err,
+ };
+
+ assert!(err.message.contains("idle timeout"));
+ assert_eq!(err.detail, None);
+ assert!(
+ !WS_POOL
+ .lock()
+ .unwrap()
+ .contains_key("response-idle-session")
+ );
+ }
+
async fn create_dummy_stream_async() -> WebSocketStream<MaybeTlsStream<TcpStream>> {
use tokio::net::TcpListener;
diff --git a/tests/smoke_cutover.rs b/tests/smoke_cutover.rs
index e771ffc..47b8b1c 100644
--- a/tests/smoke_cutover.rs
+++ b/tests/smoke_cutover.rs
@@ -310,6 +310,7 @@ async fn smoke_healthz_returns_ok() {
#[tokio::test]
async fn smoke_codex_model_routes_to_real_provider() {
+ let _guard = env_lock();
let response = call_messages("gpt-5.5").await;
// Should attempt auth (not return 501 placeholder)
assert!(