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.rsindex 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 transportlet 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.rsindex 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 poolif 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 eventsif 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.rsindex 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!(