Skip to content

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.md
index 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 reusing
diff --git a/src/providers/codex/client.rs b/src/providers/codex/client.rs
index 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.rs
index 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")
&& payload
diff --git a/src/providers/codex/websocket.rs b/src/providers/codex/websocket.rs
index 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.rs
index 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() {