Skip to content

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.md
index 27f147c..8965feb 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,12 @@
- Codex WebSocket streaming requests forward Anthropic SSE chunks as upstream
events arrive, so long compaction responses show progress before the terminal
Codex 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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() {