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.mdindex 8965feb..2cfd099 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -8,9 +8,9 @@- Codex WebSocket streaming requests return structured JSON for upstream errorsthat arrive before any downstream SSE chunk, preserving diagnostics such ascontext-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.rsindex 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.rsindex 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) -> ResponsewhereS: futures_util::Stream<Item = Result<Bytes, std::io::Error>> + Send + 'static,diff --git a/src/providers/codex/websocket.rs b/src/providers/codex/websocket.rsindex 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.rsindex 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();