Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy
Rust
retry closed codex continuations with full context
Raine Virta6ebdf26055ed
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex 33746f8..2229ee4 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -1,5 +1,10 @@# Changelog+## Unreleased++- Codex WebSocket streams retry continued turns with full context when a pooled+ upstream socket closes before any terminal response event.+## v0.1.3 (2026-07-01)- Codex WebSocket streams deliver live text and reasoning progress while reusingdiff --git a/src/providers/codex/client.rs b/src/providers/codex/client.rsindex 6ed2c04..bf390cc 100644--- a/src/providers/codex/client.rs+++ b/src/providers/codex/client.rs@@ -826,6 +826,7 @@ fn is_continuation_retry_error(err: &CodexError) -> bool {err.detail.as_deref(),Some("previous_response_not_found")| Some(super::websocket::WEBSOCKET_RESPONSE_START_TIMEOUT_DETAIL)+ | Some(super::websocket::WEBSOCKET_MISSING_TERMINAL_DETAIL))}diff --git a/src/providers/codex/mod.rs b/src/providers/codex/mod.rsindex 35b0f05..03ee4cd 100644--- a/src/providers/codex/mod.rs+++ b/src/providers/codex/mod.rs@@ -282,6 +282,7 @@ enum LiveStreamStart {Retry {message: String,retry_after: Option<String>,+ full_context: bool,},}@@ -295,14 +296,21 @@ async fn live_stream_response() -> Response {let model = model.to_string();let mut attempt = 0_u32;+ let mut continuation = Some(continuation);loop {let upstream_events = match client- .stream_codex_websocket_events(&request_body, &ctx, Some(&continuation))+ .stream_codex_websocket_events(&request_body, &ctx, continuation.as_ref()).await{Ok(events) => events,Err(err) if retryable_live_start_codex_error(&err) => {+ if retry_with_full_context_for_live_error(&err)+ && drop_live_continuation_for_retry(&mut continuation, &ctx)+ {+ attempt += 1;+ continue;+ }if attempt >= MAX_RETRYABLE_LIVE_STREAM_RETRIES {clear_continuation(ctx.session_id.as_deref());return map_codex_error_to_response(&err);@@ -335,7 +343,12 @@ async fn live_stream_response(LiveStreamStart::Retry {message,retry_after,+ full_context,} => {+ if full_context && drop_live_continuation_for_retry(&mut continuation, &ctx) {+ attempt += 1;+ continue;+ }if attempt >= MAX_RETRYABLE_LIVE_STREAM_RETRIES {clear_continuation(ctx.session_id.as_deref());return json_error(StatusCode::BAD_GATEWAY, "api_error", message);@@ -367,9 +380,11 @@ async fn live_stream_response_once(Ok(payload) => payload,Err(err) => {if retryable_live_start_codex_error(&err) {+ let full_context = retry_with_full_context_for_live_error(&err);return LiveStreamStart::Retry {message: codex_error_message(&err).to_string(),retry_after: err.retry_after,+ full_context,};}clear_continuation(ctx.session_id.as_deref());@@ -385,6 +400,7 @@ async fn live_stream_response_once(return LiveStreamStart::Retry {message,retry_after: retry_after_from_live_payload(&payload),+ full_context: false,};}clear_continuation(ctx.session_id.as_deref());@@ -427,6 +443,7 @@ async fn live_stream_response_once(LiveStreamStart::Retry {message: "WebSocket connection closed before terminal Codex response event".to_string(),retry_after: None,+ full_context: true,}}@@ -600,6 +617,32 @@ fn retryable_live_start_codex_error(err: &client::CodexError) -> bool {|| (err.status == 0 && retryable_live_message(codex_error_message(err)))}+fn retry_with_full_context_for_live_error(err: &client::CodexError) -> bool {+ matches!(+ err.detail.as_deref(),+ Some("previous_response_not_found")+ | Some(websocket::WEBSOCKET_RESPONSE_START_TIMEOUT_DETAIL)+ | Some(websocket::WEBSOCKET_MISSING_TERMINAL_DETAIL)+ )+}++fn drop_live_continuation_for_retry(+ continuation: &mut Option<ContinuationCandidate>,+ ctx: &RequestContext,+) -> bool {+ if continuation+ .as_ref()+ .and_then(|candidate| candidate.previous_response_id.as_deref())+ .is_none()+ {+ return false;+ }++ clear_continuation(ctx.session_id.as_deref());+ *continuation = None;+ true+}+fn retryable_live_start_payload(payload: &serde_json::Value, message: &str) -> bool {if payload.get("type").and_then(|v| v.as_str()) == Some("codex.rate_limits")&& payloaddiff --git a/src/providers/codex/websocket.rs b/src/providers/codex/websocket.rsindex 702b133..3c58bb0 100644--- a/src/providers/codex/websocket.rs+++ b/src/providers/codex/websocket.rs@@ -26,6 +26,7 @@ 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 = 300_000;pub const WEBSOCKET_RESPONSE_START_TIMEOUT_DETAIL: &str = "websocket_response_start_timeout";+pub const WEBSOCKET_MISSING_TERMINAL_DETAIL: &str = "websocket_missing_terminal";const POOL_IDLE_TTL_MS: u64 = 30 * 60 * 1000;const MAX_POOL_ENTRIES: usize = 10_000;@@ -558,7 +559,7 @@ fn missing_terminal_error() -> CodexError {CodexError {status: 0,message: "WebSocket connection closed before terminal Codex response event".to_string(),- detail: None,+ detail: Some(WEBSOCKET_MISSING_TERMINAL_DETAIL.to_string()),retry_after: None,origin: CodexErrorOrigin::WebSocket,}diff --git a/tests/smoke_cutover.rs b/tests/smoke_cutover.rsindex bdc5bbd..7bfa167 100644--- a/tests/smoke_cutover.rs+++ b/tests/smoke_cutover.rs@@ -427,6 +427,81 @@ async fn spawn_websocket_previous_missing_then_retry_upstream(addr_str}+async fn spawn_websocket_close_then_retry_upstream(captured: Arc<Mutex<Vec<Value>>>) -> String {+ let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();+ let addr = listener.local_addr().unwrap();+ let addr_str = format!("http://{addr}");++ tokio::spawn(async move {+ let mut handled = 0usize;+ while handled < 3 {+ let Ok((stream, _)) = listener.accept().await else {+ return;+ };+ let Ok(ws) = tokio_tungstenite::accept_async(stream).await else {+ return;+ };+ let (mut sender, mut receiver) = ws.split();++ while handled < 3 {+ let Some(text) = (loop {+ match receiver.next().await {+ Some(Ok(Message::Text(text))) => break Some(text),+ Some(Ok(Message::Ping(data))) => {+ let _ = sender.send(Message::Pong(data)).await;+ }+ Some(Ok(Message::Pong(_))) => {}+ Some(Ok(_)) => {}+ Some(Err(_)) | None => break None,+ }+ }) else {+ break;+ };+ if let Ok(json) = serde_json::from_str::<Value>(&text) {+ let _ = captured.lock().map(|mut g| g.push(json));+ }++ if handled == 1 {+ handled += 1;+ let _ = sender.close().await;+ break;+ }++ let response_text = if handled == 0 { "first" } else { "retry" };+ let response_id = if handled == 0 { "resp_1" } else { "resp_retry" };+ let events = [+ json!({+ "type":"response.output_item.added",+ "output_index":0,+ "item":{"type":"message","id":format!("msg_close_{handled}")}+ }),+ json!({+ "type":"response.output_text.delta",+ "output_index":0,+ "delta":response_text+ }),+ json!({+ "type":"response.output_item.done",+ "output_index":0,+ "item":{"type":"message"}+ }),+ json!({+ "type":"response.completed",+ "response":{"id":response_id,"usage":{"input_tokens":5,"output_tokens":2}}+ }),+ ];++ for event in &events {+ let _ = sender.send(Message::Text(event.to_string())).await;+ }+ handled += 1;+ }+ }+ });++ addr_str+}+// ---------------------------------------------------------------------------// Health and routing smoke tests (no env var mutation needed)// ---------------------------------------------------------------------------@@ -977,6 +1052,71 @@ async fn smoke_codex_websocket_stream_retries_missing_previous_response_id() {clear_codex_websocket_pool_for_tests();}+#[allow(clippy::await_holding_lock)]+#[tokio::test(flavor = "multi_thread")]+async fn smoke_codex_websocket_stream_retries_empty_close_with_full_context() {+ let _guard = env_lock();+ let config = TempDir::new().unwrap();+ write_auth(config.path(), "codex");+ clear_codex_websocket_pool_for_tests();+ clear_all_continuations_for_tests();++ let captured = Arc::new(Mutex::new(Vec::new()));+ let upstream = spawn_websocket_close_then_retry_upstream(captured.clone()).await;++ let _config_env = EnvGuard::set("CCP_CONFIG_DIR", config.path());+ let _base_url_env = EnvGuard::set("CCP_CODEX_BASE_URL", &upstream);+ let _transport_env = EnvGuard::set("CCP_CODEX_TRANSPORT", "websocket");+ let _previous_response_env = EnvGuard::set("CCP_CODEX_PREVIOUS_RESPONSE_ID", "1");++ let first = call_messages_body(json!({+ "model": "gpt-5.5",+ "max_tokens": 64,+ "stream": true,+ "messages": [{"role":"user","content":"one"}]+ }))+ .await;+ assert_eq!(first.status(), StatusCode::OK);+ let _ = axum::body::to_bytes(first.into_body(), usize::MAX)+ .await+ .unwrap();++ let second = call_messages_body(json!({+ "model": "gpt-5.5",+ "max_tokens": 64,+ "stream": true,+ "messages": [+ {"role":"user","content":"one"},+ {"role":"assistant","content":"first"},+ {"role":"user","content":"two"}+ ]+ }))+ .await;+ assert_eq!(second.status(), StatusCode::OK);+ let second_body = axum::body::to_bytes(second.into_body(), usize::MAX)+ .await+ .unwrap();+ assert!(+ String::from_utf8_lossy(&second_body).contains("retry"),+ "second response body: {}",+ String::from_utf8_lossy(&second_body)+ );++ let guard = captured.lock().unwrap();+ assert_eq!(guard.len(), 3, "expected full-context retry request");+ assert!(guard[0].get("previous_response_id").is_none());+ assert_eq!(guard[1]["previous_response_id"], "resp_1");+ assert!(guard[2].get("previous_response_id").is_none());+ assert_eq!(+ guard[2]["input"].as_array().map(Vec::len),+ Some(3),+ "retry request should send the full input"+ );++ clear_all_continuations_for_tests();+ clear_codex_websocket_pool_for_tests();+}+#[allow(clippy::await_holding_lock)]#[tokio::test(flavor = "multi_thread")]async fn smoke_codex_websocket_previous_response_id_sends_delta_on_second_turn() {