Skip to content

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

Rust

reuse codex stream continuations

Raine Virta697df7714d97
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8965feb..2cfd099 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,9 +8,9 @@
- Codex WebSocket streaming requests return structured JSON for upstream errors
that arrive before any downstream SSE chunk, preserving diagnostics such as
context-window failures.
-- Codex WebSocket live streaming sends full requests on fresh WebSocket
- connections, avoiding invalid `previous_response_id` references from earlier
- connections.
+- Codex WebSocket live streaming reuses pooled session sockets and applies
+ `previous_response_id` continuations on append-only turns, reducing repeated
+ upstream input for streaming sessions.
## v0.1.2 (2026-06-30)
diff --git a/src/providers/codex/client.rs b/src/providers/codex/client.rs
index 7f0a3c7..6ed2c04 100644
--- a/src/providers/codex/client.rs
+++ b/src/providers/codex/client.rs
@@ -497,7 +497,7 @@ impl CodexHttpClient {
let ws_headers = super::websocket::codex_websocket_headers(&ws_headers);
let ws_body = build_websocket_request(body, continuation);
- super::websocket::codex_websocket_event_stream(
+ let first_stream = super::websocket::codex_websocket_event_stream(
&self.base_url,
&ws_headers,
&ws_body,
@@ -508,7 +508,66 @@ impl CodexHttpClient {
super::websocket::WEBSOCKET_IDLE_TIMEOUT_MS,
continuation,
)
- .await
+ .await?;
+
+ let can_retry_without_continuation = continuation
+ .and_then(|c| c.previous_response_id.as_deref())
+ .is_some();
+ if !can_retry_without_continuation {
+ return Ok(first_stream);
+ }
+
+ let retry_body = build_websocket_request(body, None);
+ let base_url = self.base_url.clone();
+ let ctx = ctx.clone();
+ let pool_key = pool_key.map(str::to_string);
+ let (tx, rx) = tokio::sync::mpsc::channel(64);
+
+ tokio::spawn(async move {
+ let mut stream = first_stream;
+ let mut retry_available = true;
+ loop {
+ match stream.recv().await {
+ Some(Err(err)) if retry_available && is_continuation_retry_error(&err) => {
+ retry_available = false;
+ super::continuation::clear_continuation(ctx.session_id.as_deref());
+ if let Some(key) = pool_key.as_deref() {
+ super::websocket::invalidate_codex_websocket_pool_key(key);
+ }
+ match super::websocket::codex_websocket_event_stream(
+ &base_url,
+ &ws_headers,
+ &retry_body,
+ &ctx,
+ ctx.traffic.clone(),
+ pool_key.as_deref(),
+ super::websocket::WEBSOCKET_CONNECT_TIMEOUT_MS,
+ super::websocket::WEBSOCKET_IDLE_TIMEOUT_MS,
+ None,
+ )
+ .await
+ {
+ Ok(retry_stream) => {
+ stream = retry_stream;
+ continue;
+ }
+ Err(retry_err) => {
+ let _ = tx.send(Err(retry_err)).await;
+ return;
+ }
+ }
+ }
+ Some(item) => {
+ if tx.send(item).await.is_err() {
+ return;
+ }
+ }
+ None => return,
+ }
+ }
+ });
+
+ Ok(rx)
}
async fn attempt_post_http(
@@ -759,6 +818,10 @@ fn should_retry_without_continuation(
return false;
}
+ is_continuation_retry_error(err)
+}
+
+fn is_continuation_retry_error(err: &CodexError) -> bool {
matches!(
err.detail.as_deref(),
Some("previous_response_not_found")
diff --git a/src/providers/codex/mod.rs b/src/providers/codex/mod.rs
index 63d4871..89c55a8 100644
--- a/src/providers/codex/mod.rs
+++ b/src/providers/codex/mod.rs
@@ -125,8 +125,9 @@ impl Provider for CodexProvider {
monitor.upstream_started(&ctx.req_id);
}
if want_stream && matches!(config::codex_transport(), config::CodexTransport::WebSocket) {
+ let stream_request = translated.clone();
let upstream_events = match client
- .stream_codex_websocket_events(&translated, &ctx, None)
+ .stream_codex_websocket_events(&translated, &ctx, Some(&continuation))
.await
{
Ok(events) => events,
@@ -135,7 +136,8 @@ impl Provider for CodexProvider {
return map_codex_error_to_response(&e);
}
};
- return live_stream_response(upstream_events, message_id, model, ctx).await;
+ return live_stream_response(upstream_events, message_id, model, ctx, stream_request)
+ .await;
}
let upstream = match client
@@ -278,8 +280,10 @@ async fn live_stream_response(
message_id: String,
model: &str,
ctx: RequestContext,
+ request_body: translate::request::ResponsesRequest,
) -> Response {
let mut translator = LiveStreamTranslator::new(message_id, model.to_string());
+ let mut upstream_sse_body = Vec::new();
while let Some(item) = upstream_events.recv().await {
let payload = match item {
@@ -289,6 +293,7 @@ async fn live_stream_response(
return map_codex_error_to_response(&err);
}
};
+ append_upstream_sse_payload(&mut upstream_sse_body, &payload);
let (chunk, terminal) = match translate_live_stream_payload(&mut translator, &payload, &ctx)
{
Ok(result) => result,
@@ -300,13 +305,28 @@ async fn live_stream_response(
if !chunk.is_empty() {
record_live_stream_progress(&ctx, &chunk);
if terminal {
- clear_continuation(ctx.session_id.as_deref());
+ update_continuation_from_upstream(
+ ctx.session_id.as_deref(),
+ &request_body,
+ &upstream_sse_body,
+ );
return single_live_stream_response(chunk);
}
- return remaining_live_stream_response(upstream_events, translator, chunk, ctx);
+ return remaining_live_stream_response(
+ upstream_events,
+ translator,
+ chunk,
+ ctx,
+ request_body,
+ upstream_sse_body,
+ );
}
if terminal {
- clear_continuation(ctx.session_id.as_deref());
+ update_continuation_from_upstream(
+ ctx.session_id.as_deref(),
+ &request_body,
+ &upstream_sse_body,
+ );
return empty_live_stream_response();
}
}
@@ -356,15 +376,19 @@ fn remaining_live_stream_response(
mut translator: LiveStreamTranslator,
first_chunk: Vec<u8>,
ctx: RequestContext,
+ request_body: translate::request::ResponsesRequest,
+ mut upstream_sse_body: Vec<u8>,
) -> Response {
let (tx, rx) = tokio::sync::mpsc::channel::<Result<Bytes, std::io::Error>>(64);
tokio::spawn(async move {
if tx.send(Ok(Bytes::from(first_chunk))).await.is_err() {
+ clear_continuation(ctx.session_id.as_deref());
return;
}
while let Some(item) = upstream_events.recv().await {
match item {
Ok(payload) => {
+ append_upstream_sse_payload(&mut upstream_sse_body, &payload);
let (chunk, terminal) =
match translate_live_stream_payload(&mut translator, &payload, &ctx) {
Ok(result) => result,
@@ -377,11 +401,16 @@ fn remaining_live_stream_response(
if !chunk.is_empty() {
record_live_stream_progress(&ctx, &chunk);
if tx.send(Ok(Bytes::from(chunk))).await.is_err() {
+ clear_continuation(ctx.session_id.as_deref());
return;
}
}
if terminal {
- clear_continuation(ctx.session_id.as_deref());
+ update_continuation_from_upstream(
+ ctx.session_id.as_deref(),
+ &request_body,
+ &upstream_sse_body,
+ );
return;
}
}
@@ -407,6 +436,16 @@ fn remaining_live_stream_response(
event_stream_response(stream)
}
+fn append_upstream_sse_payload(buffer: &mut Vec<u8>, payload: &serde_json::Value) {
+ let text = payload.to_string();
+ for line in text.lines() {
+ buffer.extend_from_slice(b"data: ");
+ buffer.extend_from_slice(line.as_bytes());
+ buffer.push(b'\n');
+ }
+ buffer.push(b'\n');
+}
+
fn event_stream_response<S>(stream: S) -> Response
where
S: futures_util::Stream<Item = Result<Bytes, std::io::Error>> + Send + 'static,
diff --git a/src/providers/codex/websocket.rs b/src/providers/codex/websocket.rs
index 9cf242a..f02c8d1 100644
--- a/src/providers/codex/websocket.rs
+++ b/src/providers/codex/websocket.rs
@@ -86,7 +86,7 @@ impl std::fmt::Display for CodexWebSocketError {
// ---------------------------------------------------------------------------
struct PoolEntry {
- ws: AsyncMutex<WebSocketStream<MaybeTlsStream<TcpStream>>>,
+ ws: Arc<AsyncMutex<WebSocketStream<MaybeTlsStream<TcpStream>>>>,
created_at: u64,
}
@@ -370,7 +370,7 @@ pub async fn codex_websocket_request(
// New connection path (not pooled or pool miss)
let entry = Arc::new(PoolEntry {
- ws: AsyncMutex::new(ws_stream),
+ ws: Arc::new(AsyncMutex::new(ws_stream)),
created_at: now_ms(),
});
@@ -475,32 +475,81 @@ pub async fn codex_websocket_event_stream(
},
}),
);
- write_websocket_metadata_capture(tc, &ws_url, pool_key, continuation, false);
}
- let (mut ws_stream, _) = connect_with_timeout(&ws_url, headers, connect_timeout_ms).await?;
- ws_stream
- .send(Message::Text(body_json))
- .await
- .map_err(|e| CodexError {
- status: 0,
- message: format!("WebSocket send error: {e}"),
- detail: None,
- retry_after: None,
- origin: CodexErrorOrigin::WebSocket,
- })?;
+ let pooled = pool_key.and_then(|key| {
+ let guard = WS_POOL.lock().ok()?;
+ guard.get(key).cloned()
+ });
+ let used_pooled = pooled.is_some();
+ let entry = if let Some(entry) = pooled {
+ entry
+ } else {
+ let (ws_stream, _) = connect_with_timeout(&ws_url, headers, connect_timeout_ms).await?;
+ Arc::new(PoolEntry {
+ ws: Arc::new(AsyncMutex::new(ws_stream)),
+ created_at: now_ms(),
+ })
+ };
+
+ if let Some(tc) = traffic.as_deref() {
+ write_websocket_metadata_capture(tc, &ws_url, pool_key, continuation, used_pooled);
+ }
let (tx, rx) = mpsc::channel(64);
let pool_key = pool_key.map(str::to_string);
+ let ws = entry.ws.clone();
tokio::spawn(async move {
- stream_ws_events(
- &mut ws_stream,
+ let mut ws_guard = ws.lock_owned().await;
+ if used_pooled && ws_guard.send(Message::Ping(vec![])).await.is_err() {
+ if let Some(key) = pool_key.as_deref() {
+ invalidate_codex_websocket_pool_key(key);
+ }
+ let _ = tx
+ .send(Err(CodexError {
+ status: 0,
+ message: "WebSocket send error: failed to ping pooled connection".to_string(),
+ detail: None,
+ retry_after: None,
+ origin: CodexErrorOrigin::WebSocket,
+ }))
+ .await;
+ return;
+ }
+ if let Err(e) = ws_guard.send(Message::Text(body_json)).await {
+ if let Some(key) = pool_key.as_deref() {
+ invalidate_codex_websocket_pool_key(key);
+ }
+ let _ = tx
+ .send(Err(CodexError {
+ status: 0,
+ message: format!("WebSocket send error: {e}"),
+ detail: None,
+ retry_after: None,
+ origin: CodexErrorOrigin::WebSocket,
+ }))
+ .await;
+ return;
+ }
+
+ let reusable = stream_ws_events(
+ &mut ws_guard,
idle_timeout_ms,
pool_key.as_deref(),
traffic,
tx,
)
.await;
+
+ if let Some(key) = pool_key.as_deref() {
+ if reusable {
+ if !used_pooled {
+ pool_insert(key.to_string(), entry.clone());
+ }
+ } else {
+ invalidate_codex_websocket_pool_key(key);
+ }
+ }
});
Ok(rx)
}
@@ -853,7 +902,7 @@ async fn stream_ws_events(
pool_key: Option<&str>,
traffic: Option<Arc<TrafficCapture>>,
tx: mpsc::Sender<Result<serde_json::Value, CodexError>>,
-) {
+) -> bool {
let started_at = Instant::now();
let mut sse_body: Vec<u8> = Vec::new();
let response_event_budget = Duration::from_millis(idle_timeout_ms);
@@ -861,6 +910,7 @@ async fn stream_ws_events(
let mut last_response_event_at = response_wait_started;
let mut response_started = false;
let mut status = 200u16;
+ let mut reusable = false;
loop {
let response_deadline_started = if response_started {
@@ -946,10 +996,34 @@ async fn stream_ws_events(
status = extract_status_from_error(&parsed).unwrap_or(500);
}
let terminal = is_terminal_event(&parsed);
+ if terminal && is_previous_response_missing(&parsed) {
+ if let Some(key) = pool_key {
+ invalidate_codex_websocket_pool_key(key);
+ }
+ let _ = tx
+ .send(Err(CodexError {
+ status: 0,
+ message: "Previous response not found".to_string(),
+ detail: Some("previous_response_not_found".to_string()),
+ retry_after: None,
+ origin: CodexErrorOrigin::WebSocket,
+ }))
+ .await;
+ break;
+ }
+ let event_type = parsed
+ .get("type")
+ .and_then(|v| v.as_str())
+ .unwrap_or("unknown")
+ .to_string();
if tx.send(Ok(parsed)).await.is_err() {
+ if let Some(key) = pool_key {
+ invalidate_codex_websocket_pool_key(key);
+ }
break;
}
if terminal {
+ reusable = event_type == "response.completed";
break;
}
}
@@ -1000,6 +1074,7 @@ async fn stream_ws_events(
if let Some(tc) = traffic.as_deref() {
write_websocket_response_capture(tc, status, started_at.elapsed(), &sse_body);
}
+ reusable
}
fn headers_to_json(headers: &HeaderMap) -> serde_json::Value {
@@ -1160,7 +1235,7 @@ mod tests {
guard.insert(
"test-session".to_string(),
Arc::new(PoolEntry {
- ws: AsyncMutex::new(create_dummy_stream()),
+ ws: Arc::new(AsyncMutex::new(create_dummy_stream())),
created_at: now_ms(),
}),
);
@@ -1213,7 +1288,7 @@ mod tests {
guard.insert(
"binary-session".to_string(),
Arc::new(PoolEntry {
- ws: AsyncMutex::new(pooled_stream),
+ ws: Arc::new(AsyncMutex::new(pooled_stream)),
created_at: now_ms(),
}),
);
@@ -1248,7 +1323,7 @@ mod tests {
guard.insert(
"start-timeout-session".to_string(),
Arc::new(PoolEntry {
- ws: AsyncMutex::new(pooled_stream),
+ ws: Arc::new(AsyncMutex::new(pooled_stream)),
created_at: now_ms(),
}),
);
@@ -1301,7 +1376,7 @@ mod tests {
guard.insert(
"response-idle-session".to_string(),
Arc::new(PoolEntry {
- ws: AsyncMutex::new(pooled_stream),
+ ws: Arc::new(AsyncMutex::new(pooled_stream)),
created_at: now_ms(),
}),
);
diff --git a/tests/smoke_cutover.rs b/tests/smoke_cutover.rs
index b5ffa6b..b9b6451 100644
--- a/tests/smoke_cutover.rs
+++ b/tests/smoke_cutover.rs
@@ -342,6 +342,91 @@ async fn spawn_websocket_sequence_upstream(captured: Arc<Mutex<Vec<Value>>>) ->
addr_str
}
+async fn spawn_websocket_previous_missing_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 {
+ let event = json!({
+ "type": "error",
+ "error": {
+ "code": "previous_response_not_found",
+ "message": "previous response not found",
+ "status": 400
+ }
+ });
+ let _ = sender.send(Message::Text(event.to_string())).await;
+ handled += 1;
+ 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_up_{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)
// ---------------------------------------------------------------------------
@@ -762,7 +847,7 @@ async fn smoke_codex_websocket_stream_returns_json_for_early_error() {
#[allow(clippy::await_holding_lock)]
#[tokio::test(flavor = "multi_thread")]
-async fn smoke_codex_websocket_stream_omits_previous_response_id() {
+async fn smoke_codex_websocket_stream_uses_previous_response_id() {
let _guard = env_lock();
let config = TempDir::new().unwrap();
write_auth(config.path(), "codex");
@@ -813,7 +898,79 @@ async fn smoke_codex_websocket_stream_omits_previous_response_id() {
let guard = captured.lock().unwrap();
assert_eq!(guard.len(), 2, "expected two upstream websocket requests");
assert!(guard[0].get("previous_response_id").is_none());
- assert!(guard[1].get("previous_response_id").is_none());
+ assert_eq!(guard[1]["previous_response_id"], "resp_1");
+ assert_eq!(
+ guard[1]["input"].as_array().map(Vec::len),
+ Some(1),
+ "second request should send only the appended input delta"
+ );
+ assert_eq!(guard[1]["input"][0]["role"], "user");
+ assert_eq!(guard[1]["input"][0]["content"][0]["text"], "two");
+
+ 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_stream_retries_missing_previous_response_id() {
+ 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_previous_missing_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 retry websocket 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();