Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy
Rust
stabilize codex live streams
Raine Virta785ddc260966
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex 27f147c..8965feb 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -5,6 +5,12 @@- Codex WebSocket streaming requests forward Anthropic SSE chunks as upstreamevents arrive, so long compaction responses show progress before the terminalCodex event.+- 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.## v0.1.2 (2026-06-30)diff --git a/src/providers/codex/mod.rs b/src/providers/codex/mod.rsindex 4d02436..63d4871 100644--- a/src/providers/codex/mod.rs+++ b/src/providers/codex/mod.rs@@ -16,7 +16,6 @@ use std::sync::Arc;use crate::anthropic::error::json_error;use crate::anthropic::schema::{CountTokensResponse, MessagesRequest};-use crate::anthropic::sse::encode_sse_event;use crate::config;use crate::monitor::usage_from_anthropic_sse;use crate::provider::{CliHandlers, Provider, RequestContext};@@ -127,7 +126,7 @@ impl Provider for CodexProvider {}if want_stream && matches!(config::codex_transport(), config::CodexTransport::WebSocket) {let upstream_events = match client- .stream_codex_websocket_events(&translated, &ctx, Some(&continuation))+ .stream_codex_websocket_events(&translated, &ctx, None).await{Ok(events) => events,@@ -136,7 +135,7 @@ impl Provider for CodexProvider {return map_codex_error_to_response(&e);}};- return live_stream_response(upstream_events, message_id, model, ctx, translated);+ return live_stream_response(upstream_events, message_id, model, ctx).await;}let upstream = match client@@ -274,69 +273,127 @@ fn count_sse_events(bytes: &[u8]) -> u64 {String::from_utf8_lossy(bytes).matches("event:").count() as u64}-fn live_stream_response(+async fn live_stream_response(mut upstream_events: websocket::CodexWebSocketEventReceiver,message_id: String,model: &str,ctx: RequestContext,- request_body: translate::request::ResponsesRequest,) -> Response {- let (tx, rx) = tokio::sync::mpsc::channel::<Result<Bytes, std::io::Error>>(64);- let req_id = ctx.req_id.clone();- let session_id = ctx.session_id.clone();- let traffic = ctx.traffic.clone();- let monitor = ctx.monitor.clone();- let model = model.to_string();+ let mut translator = LiveStreamTranslator::new(message_id, model.to_string());- tokio::spawn(async move {- let mut translator = LiveStreamTranslator::new(message_id, model);- let mut upstream_body = Vec::new();+ while let Some(item) = upstream_events.recv().await {+ let payload = match item {+ Ok(payload) => payload,+ Err(err) => {+ clear_continuation(ctx.session_id.as_deref());+ return map_codex_error_to_response(&err);+ }+ };+ let (chunk, terminal) = match translate_live_stream_payload(&mut translator, &payload, &ctx)+ {+ Ok(result) => result,+ Err(message) => {+ clear_continuation(ctx.session_id.as_deref());+ return json_error(StatusCode::BAD_GATEWAY, "api_error", message);+ }+ };+ if !chunk.is_empty() {+ record_live_stream_progress(&ctx, &chunk);+ if terminal {+ clear_continuation(ctx.session_id.as_deref());+ return single_live_stream_response(chunk);+ }+ return remaining_live_stream_response(upstream_events, translator, chunk, ctx);+ }+ if terminal {+ clear_continuation(ctx.session_id.as_deref());+ return empty_live_stream_response();+ }+ }++ clear_continuation(ctx.session_id.as_deref());+ json_error(+ StatusCode::BAD_GATEWAY,+ "api_error",+ "WebSocket connection closed before terminal Codex response event",+ )+}++fn translate_live_stream_payload(+ translator: &mut LiveStreamTranslator,+ payload: &serde_json::Value,+ ctx: &RequestContext,+) -> Result<(Vec<u8>, bool), String> {+ let terminal = is_codex_terminal_event(payload);+ let chunk = translator.accept(payload, ctx.traffic.as_deref())?;+ Ok((chunk, terminal))+}++fn record_live_stream_progress(ctx: &RequestContext, chunk: &[u8]) {+ if let Some(monitor) = ctx.monitor.as_ref() {+ monitor.stream_progress(+ &ctx.req_id,+ chunk.len() as u64,+ count_sse_events(chunk),+ None,+ None,+ );+ }+}++fn single_live_stream_response(chunk: Vec<u8>) -> Response {+ event_stream_response(futures_util::stream::once(async move {+ Ok::<Bytes, std::io::Error>(Bytes::from(chunk))+ }))+}+fn empty_live_stream_response() -> Response {+ event_stream_response(futures_util::stream::empty::<Result<Bytes, std::io::Error>>())+}++fn remaining_live_stream_response(+ mut upstream_events: websocket::CodexWebSocketEventReceiver,+ mut translator: LiveStreamTranslator,+ first_chunk: Vec<u8>,+ ctx: RequestContext,+) -> 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() {+ return;+ }while let Some(item) = upstream_events.recv().await {match item {Ok(payload) => {- upstream_body.extend_from_slice(&encode_sse_event(None, &payload.to_string()));- let terminal = is_codex_terminal_event(&payload);- let chunk = match translator.accept(&payload, traffic.as_deref()) {- Ok(chunk) => chunk,- Err(message) => {- clear_continuation(session_id.as_deref());- let _ = tx.send(Err(stream_error(message))).await;- return;- }- };+ let (chunk, terminal) =+ match translate_live_stream_payload(&mut translator, &payload, &ctx) {+ Ok(result) => result,+ Err(message) => {+ clear_continuation(ctx.session_id.as_deref());+ let _ = tx.send(Err(stream_error(message))).await;+ return;+ }+ };if !chunk.is_empty() {- if let Some(monitor) = monitor.as_ref() {- monitor.stream_progress(- &req_id,- chunk.len() as u64,- count_sse_events(&chunk),- None,- None,- );- }+ record_live_stream_progress(&ctx, &chunk);if tx.send(Ok(Bytes::from(chunk))).await.is_err() {return;}}if terminal {- update_continuation_from_upstream(- session_id.as_deref(),- &request_body,- &upstream_body,- );+ clear_continuation(ctx.session_id.as_deref());return;}}Err(err) => {- clear_continuation(session_id.as_deref());+ clear_continuation(ctx.session_id.as_deref());let _ = tx.send(Err(stream_error(codex_error_message(&err)))).await;return;}}}- clear_continuation(session_id.as_deref());+ clear_continuation(ctx.session_id.as_deref());let _ = tx.send(Err(stream_error("WebSocket connection closed before terminal Codex response event",@@ -347,6 +404,13 @@ fn live_stream_response(let stream = futures_util::stream::unfold(rx, |mut rx| async {rx.recv().await.map(|item| (item, rx))});+ event_stream_response(stream)+}++fn event_stream_response<S>(stream: S) -> Response+where+ S: futures_util::Stream<Item = Result<Bytes, std::io::Error>> + Send + 'static,+{let headers = [(http::header::CONTENT_TYPE, "text/event-stream"),(http::header::CACHE_CONTROL, "no-cache"),diff --git a/src/providers/codex/translate/reducer.rs b/src/providers/codex/translate/reducer.rsindex 4f4b5c5..63af88c 100644--- a/src/providers/codex/translate/reducer.rs+++ b/src/providers/codex/translate/reducer.rs@@ -1223,7 +1223,7 @@ mod tests {}#[test]- fn map_usage_subtracts_cached() {+ fn map_usage_reports_cached_prompt_tokens() {let usage = CodexUsage {input_tokens: Some(100),output_tokens: Some(50),diff --git a/src/providers/codex/websocket.rs b/src/providers/codex/websocket.rsindex c6be6a2..9cf242a 100644--- a/src/providers/codex/websocket.rs+++ b/src/providers/codex/websocket.rs@@ -209,7 +209,6 @@ fn is_response_event(payload: &serde_json::Value) -> bool {}fn is_previous_response_missing(payload: &serde_json::Value) -> bool {- // Check error.code == "previous_response_not_found"if let Some(code) = payload.get("error").and_then(|e| e.get("code"))diff --git a/tests/smoke_cutover.rs b/tests/smoke_cutover.rsindex a1be75f..b5ffa6b 100644--- a/tests/smoke_cutover.rs+++ b/tests/smoke_cutover.rs@@ -245,6 +245,32 @@ async fn spawn_websocket_delayed_terminal_upstream() -> String {addr_str}+async fn spawn_websocket_error_upstream(message: &'static str) -> 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 {+ if let Ok((stream, _)) = listener.accept().await+ && let Ok(mut ws) = tokio_tungstenite::accept_async(stream).await+ {+ let _ = ws.next().await;+ let event = json!({+ "type": "error",+ "status": 400,+ "error": {+ "type": "invalid_request_error",+ "param": "input",+ "message": message+ }+ });+ let _ = ws.send(Message::Text(event.to_string())).await;+ }+ });++ addr_str+}+async fn spawn_websocket_sequence_upstream(captured: Arc<Mutex<Vec<Value>>>) -> String {let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();let addr = listener.local_addr().unwrap();@@ -698,6 +724,101 @@ async fn smoke_codex_websocket_stream_returns_delta_before_terminal() {);}+#[allow(clippy::await_holding_lock)]+#[tokio::test(flavor = "multi_thread")]+async fn smoke_codex_websocket_stream_returns_json_for_early_error() {+ let _guard = env_lock();+ let config = TempDir::new().unwrap();+ write_auth(config.path(), "codex");+ clear_codex_websocket_pool_for_tests();++ let upstream = spawn_websocket_error_upstream("input exceeds context window").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 response = call_messages_body(json!({+ "model": "gpt-5.5",+ "max_tokens": 64,+ "stream": true,+ "messages": [{"role":"user","content":"hello"}]+ }))+ .await;+ let status = response.status();+ let body = axum::body::to_bytes(response.into_body(), usize::MAX)+ .await+ .unwrap();++ assert_eq!(+ status,+ StatusCode::BAD_GATEWAY,+ "response body: {}",+ String::from_utf8_lossy(&body)+ );+ let value: Value = serde_json::from_slice(&body).unwrap();+ assert_eq!(value["error"]["message"], "input exceeds context window");+}++#[allow(clippy::await_holding_lock)]+#[tokio::test(flavor = "multi_thread")]+async fn smoke_codex_websocket_stream_omits_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_sequence_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("second"),+ "second response body: {}",+ String::from_utf8_lossy(&second_body)+ );++ 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());++ 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() {