Skip to content

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

Rust

stream codex websocket responses

Raine Virtae83e257a8b64
diff --git a/CHANGELOG.md b/CHANGELOG.md
index ea11001..27f147c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,11 @@
# Changelog
+## Unreleased
+
+- Codex WebSocket streaming requests forward Anthropic SSE chunks as upstream
+ events arrive, so long compaction responses show progress before the terminal
+ Codex event.
+
## v0.1.2 (2026-06-30)
- Codex WebSocket continuations recover from streams that only deliver rate
diff --git a/src/providers/codex/client.rs b/src/providers/codex/client.rs
index c817e60..7f0a3c7 100644
--- a/src/providers/codex/client.rs
+++ b/src/providers/codex/client.rs
@@ -472,6 +472,45 @@ impl CodexHttpClient {
})
}
+ pub async fn stream_codex_websocket_events(
+ &self,
+ body: &ResponsesRequest,
+ ctx: &RequestContext,
+ continuation: Option<&super::continuation::ContinuationCandidate>,
+ ) -> Result<super::websocket::CodexWebSocketEventReceiver, CodexError> {
+ let auth = self.auth_manager.get_auth().map_err(|e| CodexError {
+ status: 401,
+ message: "Auth error".to_string(),
+ detail: Some(e.to_string()),
+ retry_after: None,
+ origin: CodexErrorOrigin::Auth,
+ })?;
+
+ let pool_key = websocket_pool_key(ctx, continuation);
+ if should_reset_websocket_pool(continuation)
+ && let Some(key) = pool_key
+ {
+ super::websocket::invalidate_codex_websocket_pool_key(key);
+ }
+
+ let ws_headers = build_codex_headers(&auth, ctx)?;
+ let ws_headers = super::websocket::codex_websocket_headers(&ws_headers);
+ let ws_body = build_websocket_request(body, continuation);
+
+ super::websocket::codex_websocket_event_stream(
+ &self.base_url,
+ &ws_headers,
+ &ws_body,
+ ctx,
+ ctx.traffic.clone(),
+ pool_key,
+ super::websocket::WEBSOCKET_CONNECT_TIMEOUT_MS,
+ super::websocket::WEBSOCKET_IDLE_TIMEOUT_MS,
+ continuation,
+ )
+ .await
+ }
+
async fn attempt_post_http(
&self,
auth: &StoredAuth,
diff --git a/src/providers/codex/mod.rs b/src/providers/codex/mod.rs
index b139261..4d02436 100644
--- a/src/providers/codex/mod.rs
+++ b/src/providers/codex/mod.rs
@@ -8,12 +8,15 @@ pub mod websocket;
use async_trait::async_trait;
use axum::Json;
+use axum::body::Body;
use axum::response::{IntoResponse, Response};
+use bytes::Bytes;
use http::StatusCode;
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};
@@ -27,6 +30,7 @@ use self::client::CodexHttpClient;
use self::continuation::{clear_continuation, continuation_candidate, record_continuation};
use self::count_tokens::count_translated_tokens;
use self::translate::accumulate::accumulate_response_with_traffic;
+use self::translate::live_stream::LiveStreamTranslator;
use self::translate::model_allowlist::{assert_allowed_model, resolve_model_request};
use self::translate::reducer::finish_metadata_from_upstream;
use self::translate::request::{TranslateOptions, translate_request};
@@ -121,6 +125,20 @@ impl Provider for CodexProvider {
if let Some(monitor) = ctx.monitor.as_ref() {
monitor.upstream_started(&ctx.req_id);
}
+ if want_stream && matches!(config::codex_transport(), config::CodexTransport::WebSocket) {
+ let upstream_events = match client
+ .stream_codex_websocket_events(&translated, &ctx, Some(&continuation))
+ .await
+ {
+ Ok(events) => events,
+ Err(e) => {
+ clear_continuation(ctx.session_id.as_deref());
+ return map_codex_error_to_response(&e);
+ }
+ };
+ return live_stream_response(upstream_events, message_id, model, ctx, translated);
+ }
+
let upstream = match client
.post_codex(&translated, &ctx, Some(&continuation))
.await
@@ -256,6 +274,103 @@ fn count_sse_events(bytes: &[u8]) -> u64 {
String::from_utf8_lossy(bytes).matches("event:").count() as u64
}
+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();
+
+ 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 {
+ 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;
+ }
+ };
+ 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,
+ );
+ }
+ 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,
+ );
+ return;
+ }
+ }
+ Err(err) => {
+ clear_continuation(session_id.as_deref());
+ let _ = tx.send(Err(stream_error(codex_error_message(&err)))).await;
+ return;
+ }
+ }
+ }
+
+ clear_continuation(session_id.as_deref());
+ let _ = tx
+ .send(Err(stream_error(
+ "WebSocket connection closed before terminal Codex response event",
+ )))
+ .await;
+ });
+
+ let stream = futures_util::stream::unfold(rx, |mut rx| async {
+ rx.recv().await.map(|item| (item, rx))
+ });
+ let headers = [
+ (http::header::CONTENT_TYPE, "text/event-stream"),
+ (http::header::CACHE_CONTROL, "no-cache"),
+ (http::header::CONNECTION, "keep-alive"),
+ ];
+ (headers, Body::from_stream(stream)).into_response()
+}
+
+fn stream_error(message: impl Into<String>) -> std::io::Error {
+ std::io::Error::other(message.into())
+}
+
+fn is_codex_terminal_event(payload: &serde_json::Value) -> bool {
+ matches!(
+ payload.get("type").and_then(|v| v.as_str()),
+ Some("response.completed")
+ | Some("response.incomplete")
+ | Some("response.done")
+ | Some("response.failed")
+ | Some("response.error")
+ | Some("error")
+ )
+}
+
fn update_continuation_from_upstream(
session_id: Option<&str>,
request_body: &translate::request::ResponsesRequest,
@@ -304,7 +419,7 @@ fn map_codex_error_to_response(err: &client::CodexError) -> Response {
}
fn codex_error_message(err: &client::CodexError) -> &str {
- err.detail.as_deref().unwrap_or_else(|| {
+ err.detail.as_deref().unwrap_or({
if err.status == 0 {
err.message.as_str()
} else {
diff --git a/src/providers/codex/translate/live_stream.rs b/src/providers/codex/translate/live_stream.rs
new file mode 100644
index 0000000..b63b2bf
--- /dev/null
+++ b/src/providers/codex/translate/live_stream.rs
@@ -0,0 +1,739 @@
+use std::collections::HashMap;
+
+use crate::anthropic::sse::encode_sse_event;
+use crate::traffic::TrafficCapture;
+
+use super::reducer::{
+ CodexUsage, STOP_END_TURN, STOP_MAX_TOKENS, STOP_TOOL_USE, map_codex_usage_to_anthropic,
+};
+
+enum LiveBlock {
+ Text {
+ index: usize,
+ },
+ Tool {
+ index: usize,
+ name: String,
+ args_accum: String,
+ had_delta: bool,
+ buffer_until_done: bool,
+ emitted_args: bool,
+ },
+}
+
+pub struct LiveStreamTranslator {
+ message_id: String,
+ model: String,
+ message_started: bool,
+ blocks_by_output_index: HashMap<usize, LiveBlock>,
+ item_id_to_output_index: HashMap<String, usize>,
+ anthropic_index: usize,
+ thinking_index: Option<usize>,
+ saw_tool_use: bool,
+ web_search_requests: usize,
+ finished: bool,
+}
+
+impl LiveStreamTranslator {
+ pub fn new(message_id: impl Into<String>, model: impl Into<String>) -> Self {
+ Self {
+ message_id: message_id.into(),
+ model: model.into(),
+ message_started: false,
+ blocks_by_output_index: HashMap::new(),
+ item_id_to_output_index: HashMap::new(),
+ anthropic_index: 0,
+ thinking_index: None,
+ saw_tool_use: false,
+ web_search_requests: 0,
+ finished: false,
+ }
+ }
+
+ pub fn accept(
+ &mut self,
+ payload: &serde_json::Value,
+ traffic: Option<&TrafficCapture>,
+ ) -> Result<Vec<u8>, String> {
+ if self.finished {
+ return Ok(Vec::new());
+ }
+
+ let kind = payload.get("type").and_then(|v| v.as_str()).unwrap_or("");
+ let mut out = Vec::new();
+
+ match kind {
+ "codex.rate_limits" | "keepalive" => {}
+ "response.failed" | "response.error" | "error" => {
+ return Err(error_message(payload));
+ }
+ "response.web_search_call.in_progress"
+ | "response.web_search_call.searching"
+ | "response.web_search_call.completed" => {}
+ "response.output_item.added" => {
+ self.output_item_added(payload, traffic, &mut out);
+ }
+ "response.reasoning_summary_part.added" => {
+ if let Some(index) = self.thinking_index {
+ self.emit(
+ traffic,
+ &mut out,
+ "content_block_delta",
+ &serde_json::json!({
+ "type": "content_block_delta",
+ "index": index,
+ "delta": {"type": "thinking_delta", "thinking": "\n\n"}
+ }),
+ );
+ }
+ }
+ "response.reasoning_summary_text.delta" => {
+ self.reasoning_delta(payload, traffic, &mut out);
+ }
+ "response.output_text.delta" => {
+ self.text_delta(payload, traffic, &mut out);
+ }
+ "response.function_call_arguments.delta" => {
+ self.tool_delta(payload, traffic, &mut out);
+ }
+ "response.function_call_arguments.done" => {
+ self.tool_arguments_done(payload);
+ }
+ "response.output_item.done" => {
+ self.output_item_done(payload, traffic, &mut out);
+ }
+ "response.completed" | "response.incomplete" | "response.done" => {
+ self.finish(payload, traffic, &mut out);
+ }
+ _ => {}
+ }
+
+ Ok(out)
+ }
+
+ fn ensure_message_start(&mut self, traffic: Option<&TrafficCapture>, out: &mut Vec<u8>) {
+ if self.message_started {
+ return;
+ }
+ self.message_started = true;
+ self.emit(
+ traffic,
+ out,
+ "message_start",
+ &serde_json::json!({
+ "type": "message_start",
+ "message": {
+ "id": self.message_id,
+ "type": "message",
+ "role": "assistant",
+ "model": self.model,
+ "content": [],
+ "stop_reason": null,
+ "stop_sequence": null,
+ "usage": {
+ "input_tokens": 0,
+ "output_tokens": 0
+ }
+ }
+ }),
+ );
+ }
+
+ fn emit(
+ &self,
+ traffic: Option<&TrafficCapture>,
+ out: &mut Vec<u8>,
+ event: &str,
+ data: &serde_json::Value,
+ ) {
+ if let Some(traffic) = traffic {
+ traffic.write_json_event(
+ "050-downstream-event",
+ &serde_json::json!({
+ "event": event,
+ "data": data,
+ }),
+ );
+ }
+ out.extend_from_slice(&encode_sse_event(Some(event), &data.to_string()));
+ }
+
+ fn output_item_added(
+ &mut self,
+ payload: &serde_json::Value,
+ traffic: Option<&TrafficCapture>,
+ out: &mut Vec<u8>,
+ ) {
+ let Some(item) = payload.get("item") else {
+ return;
+ };
+ let output_index = output_index(payload);
+ let item_type = item.get("type").and_then(|v| v.as_str()).unwrap_or("");
+
+ match item_type {
+ "message" => {
+ self.close_thinking(traffic, out);
+ let index = self.anthropic_index;
+ self.anthropic_index += 1;
+ if let Some(id) = item.get("id").and_then(|v| v.as_str()) {
+ self.item_id_to_output_index
+ .insert(id.to_string(), output_index);
+ }
+ self.blocks_by_output_index
+ .insert(output_index, LiveBlock::Text { index });
+ self.ensure_message_start(traffic, out);
+ self.emit(
+ traffic,
+ out,
+ "content_block_start",
+ &serde_json::json!({
+ "type": "content_block_start",
+ "index": index,
+ "content_block": {"type": "text", "text": ""}
+ }),
+ );
+ }
+ "function_call" => {
+ self.close_thinking(traffic, out);
+ self.saw_tool_use = true;
+ let index = self.anthropic_index;
+ self.anthropic_index += 1;
+ let call_id = item
+ .get("call_id")
+ .and_then(|v| v.as_str())
+ .unwrap_or("")
+ .to_string();
+ let name = item
+ .get("name")
+ .and_then(|v| v.as_str())
+ .unwrap_or("")
+ .to_string();
+ self.blocks_by_output_index.insert(
+ output_index,
+ LiveBlock::Tool {
+ index,
+ name: name.clone(),
+ args_accum: String::new(),
+ had_delta: false,
+ buffer_until_done: name == "Read",
+ emitted_args: false,
+ },
+ );
+ self.ensure_message_start(traffic, out);
+ self.emit(
+ traffic,
+ out,
+ "content_block_start",
+ &serde_json::json!({
+ "type": "content_block_start",
+ "index": index,
+ "content_block": {
+ "type": "tool_use",
+ "id": call_id,
+ "name": name,
+ "input": {}
+ }
+ }),
+ );
+ }
+ "web_search_call" => {
+ self.web_search_requests += 1;
+ }
+ _ => {}
+ }
+ }
+
+ fn reasoning_delta(
+ &mut self,
+ payload: &serde_json::Value,
+ traffic: Option<&TrafficCapture>,
+ out: &mut Vec<u8>,
+ ) {
+ let delta = payload.get("delta").and_then(|v| v.as_str()).unwrap_or("");
+ if delta.is_empty() {
+ return;
+ }
+ if self.thinking_index.is_none() {
+ let index = self.anthropic_index;
+ self.anthropic_index += 1;
+ self.thinking_index = Some(index);
+ self.ensure_message_start(traffic, out);
+ self.emit(
+ traffic,
+ out,
+ "content_block_start",
+ &serde_json::json!({
+ "type": "content_block_start",
+ "index": index,
+ "content_block": {"type": "thinking", "thinking": "", "signature": ""}
+ }),
+ );
+ }
+ let index = self.thinking_index.unwrap();
+ self.emit(
+ traffic,
+ out,
+ "content_block_delta",
+ &serde_json::json!({
+ "type": "content_block_delta",
+ "index": index,
+ "delta": {"type": "thinking_delta", "thinking": delta}
+ }),
+ );
+ }
+
+ fn text_delta(
+ &mut self,
+ payload: &serde_json::Value,
+ traffic: Option<&TrafficCapture>,
+ out: &mut Vec<u8>,
+ ) {
+ self.close_thinking(traffic, out);
+ let delta = payload.get("delta").and_then(|v| v.as_str()).unwrap_or("");
+ if delta.is_empty() {
+ return;
+ }
+
+ let output_index = payload
+ .get("output_index")
+ .and_then(|v| v.as_u64())
+ .map(|v| v as usize)
+ .or_else(|| {
+ payload
+ .get("item_id")
+ .and_then(|v| v.as_str())
+ .and_then(|id| self.item_id_to_output_index.get(id).copied())
+ })
+ .unwrap_or(0);
+
+ if !self.blocks_by_output_index.contains_key(&output_index) {
+ let index = self.anthropic_index;
+ self.anthropic_index += 1;
+ self.blocks_by_output_index
+ .insert(output_index, LiveBlock::Text { index });
+ self.ensure_message_start(traffic, out);
+ self.emit(
+ traffic,
+ out,
+ "content_block_start",
+ &serde_json::json!({
+ "type": "content_block_start",
+ "index": index,
+ "content_block": {"type": "text", "text": ""}
+ }),
+ );
+ }
+
+ let Some(LiveBlock::Text { index }) = self.blocks_by_output_index.get(&output_index) else {
+ return;
+ };
+ let index = *index;
+ self.emit(
+ traffic,
+ out,
+ "content_block_delta",
+ &serde_json::json!({
+ "type": "content_block_delta",
+ "index": index,
+ "delta": {"type": "text_delta", "text": delta}
+ }),
+ );
+ }
+
+ fn tool_delta(
+ &mut self,
+ payload: &serde_json::Value,
+ traffic: Option<&TrafficCapture>,
+ out: &mut Vec<u8>,
+ ) {
+ let Some(output_index) = payload
+ .get("output_index")
+ .and_then(|v| v.as_u64())
+ .map(|v| v as usize)
+ else {
+ return;
+ };
+ let delta = payload.get("delta").and_then(|v| v.as_str()).unwrap_or("");
+ if delta.is_empty() {
+ return;
+ }
+ let Some(LiveBlock::Tool {
+ index,
+ args_accum,
+ had_delta,
+ buffer_until_done,
+ emitted_args,
+ ..
+ }) = self.blocks_by_output_index.get_mut(&output_index)
+ else {
+ return;
+ };
+ args_accum.push_str(delta);
+ *had_delta = true;
+ if *buffer_until_done {
+ return;
+ }
+ *emitted_args = true;
+ let index = *index;
+ self.emit(
+ traffic,
+ out,
+ "content_block_delta",
+ &serde_json::json!({
+ "type": "content_block_delta",
+ "index": index,
+ "delta": {
+ "type": "input_json_delta",
+ "partial_json": delta
+ }
+ }),
+ );
+ }
+
+ fn tool_arguments_done(&mut self, payload: &serde_json::Value) {
+ let Some(output_index) = payload
+ .get("output_index")
+ .and_then(|v| v.as_u64())
+ .map(|v| v as usize)
+ else {
+ return;
+ };
+ let Some(args) = payload.get("arguments").and_then(|v| v.as_str()) else {
+ return;
+ };
+ let Some(LiveBlock::Tool { args_accum, .. }) =
+ self.blocks_by_output_index.get_mut(&output_index)
+ else {
+ return;
+ };
+ if args_accum.is_empty() {
+ *args_accum = args.to_string();
+ }
+ }
+
+ fn output_item_done(
+ &mut self,
+ payload: &serde_json::Value,
+ traffic: Option<&TrafficCapture>,
+ out: &mut Vec<u8>,
+ ) {
+ let output_index = output_index(payload);
+ if payload
+ .get("item")
+ .and_then(|item| item.get("type"))
+ .and_then(|v| v.as_str())
+ == Some("reasoning")
+ {
+ self.close_thinking(traffic, out);
+ return;
+ }
+
+ let Some(mut state) = self.blocks_by_output_index.remove(&output_index) else {
+ return;
+ };
+
+ match &mut state {
+ LiveBlock::Text { index } => {
+ self.emit(
+ traffic,
+ out,
+ "content_block_stop",
+ &serde_json::json!({
+ "type": "content_block_stop",
+ "index": index,
+ }),
+ );
+ }
+ LiveBlock::Tool {
+ index,
+ name,
+ args_accum,
+ had_delta,
+ buffer_until_done,
+ emitted_args,
+ ..
+ } => {
+ if let Some(final_args) = payload
+ .get("item")
+ .and_then(|item| item.get("arguments"))
+ .and_then(|v| v.as_str())
+ .filter(|s| !s.is_empty())
+ && (args_accum.is_empty() || (!*had_delta && !*emitted_args))
+ {
+ *args_accum = final_args.to_string();
+ }
+ if !args_accum.is_empty() {
+ *args_accum = sanitize_tool_args(name, args_accum);
+ if *buffer_until_done || !*emitted_args {
+ *emitted_args = true;
+ self.emit(
+ traffic,
+ out,
+ "content_block_delta",
+ &serde_json::json!({
+ "type": "content_block_delta",
+ "index": index,
+ "delta": {
+ "type": "input_json_delta",
+ "partial_json": args_accum
+ }
+ }),
+ );
+ }
+ }
+ self.emit(
+ traffic,
+ out,
+ "content_block_stop",
+ &serde_json::json!({
+ "type": "content_block_stop",
+ "index": index,
+ }),
+ );
+ }
+ }
+ }
+
+ fn finish(
+ &mut self,
+ payload: &serde_json::Value,
+ traffic: Option<&TrafficCapture>,
+ out: &mut Vec<u8>,
+ ) {
+ self.close_thinking(traffic, out);
+ let open: Vec<usize> = self.blocks_by_output_index.keys().copied().collect();
+ for output_index in open {
+ let Some(state) = self.blocks_by_output_index.remove(&output_index) else {
+ continue;
+ };
+ let index = match state {
+ LiveBlock::Text { index } => index,
+ LiveBlock::Tool { index, .. } => index,
+ };
+ self.emit(
+ traffic,
+ out,
+ "content_block_stop",
+ &serde_json::json!({
+ "type": "content_block_stop",
+ "index": index,
+ }),
+ );
+ }
+ self.ensure_message_start(traffic, out);
+ let usage = payload.get("response").map(parse_codex_usage);
+ let incomplete = payload.get("type").and_then(|v| v.as_str())
+ == Some("response.incomplete")
+ || payload
+ .get("response")
+ .and_then(|r| r.get("incomplete_details"))
+ .is_some();
+ let stop_reason = if incomplete {
+ STOP_MAX_TOKENS
+ } else if self.saw_tool_use {
+ STOP_TOOL_USE
+ } else {
+ STOP_END_TURN
+ };
+ let mapped = map_codex_usage_to_anthropic(&usage, Some(self.web_search_requests));
+ self.emit(
+ traffic,
+ out,
+ "message_delta",
+ &serde_json::json!({
+ "type": "message_delta",
+ "delta": {
+ "stop_reason": stop_reason,
+ "stop_sequence": null
+ },
+ "usage": mapped,
+ }),
+ );
+ self.emit(
+ traffic,
+ out,
+ "message_stop",
+ &serde_json::json!({"type": "message_stop"}),
+ );
+ self.finished = true;
+ }
+
+ fn close_thinking(&mut self, traffic: Option<&TrafficCapture>, out: &mut Vec<u8>) {
+ let Some(index) = self.thinking_index.take() else {
+ return;
+ };
+ self.emit(
+ traffic,
+ out,
+ "content_block_stop",
+ &serde_json::json!({
+ "type": "content_block_stop",
+ "index": index,
+ }),
+ );
+ }
+}
+
+fn output_index(payload: &serde_json::Value) -> usize {
+ payload
+ .get("output_index")
+ .and_then(|v| v.as_u64())
+ .unwrap_or(0) as usize
+}
+
+fn parse_codex_usage(response: &serde_json::Value) -> CodexUsage {
+ let usage = match response.get("usage") {
+ Some(u) => u,
+ None => return CodexUsage::default(),
+ };
+ CodexUsage {
+ input_tokens: usage.get("input_tokens").and_then(|v| v.as_u64()),
+ output_tokens: usage.get("output_tokens").and_then(|v| v.as_u64()),
+ input_tokens_details_cached: usage
+ .get("input_tokens_details")
+ .and_then(|d| d.get("cached_tokens"))
+ .and_then(|v| v.as_u64()),
+ output_tokens_details_reasoning: usage
+ .get("output_tokens_details")
+ .and_then(|d| d.get("reasoning_tokens"))
+ .and_then(|v| v.as_u64()),
+ }
+}
+
+fn sanitize_tool_args(name: &str, args: &str) -> String {
+ if name != "Read" || args.is_empty() {
+ return args.to_string();
+ }
+ let parsed: serde_json::Value = match serde_json::from_str(args) {
+ Ok(v) => v,
+ Err(_) => return args.to_string(),
+ };
+ let obj = match parsed.as_object() {
+ Some(o) => o,
+ None => return args.to_string(),
+ };
+ let has_empty_pages = obj
+ .get("pages")
+ .and_then(|v| v.as_str())
+ .is_some_and(|s| s.is_empty());
+ if !has_empty_pages {
+ return args.to_string();
+ }
+ let mut sanitized = obj.clone();
+ sanitized.remove("pages");
+ serde_json::to_string(&sanitized).unwrap_or_else(|_| args.to_string())
+}
+
+fn error_message(payload: &serde_json::Value) -> String {
+ payload
+ .get("response")
+ .and_then(|r| r.get("error"))
+ .and_then(|e| e.get("message"))
+ .and_then(|v| v.as_str())
+ .or_else(|| {
+ payload
+ .get("error")
+ .and_then(|e| e.get("message"))
+ .and_then(|v| v.as_str())
+ })
+ .unwrap_or("Upstream error")
+ .to_string()
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use serde_json::json;
+
+ fn render(events: Vec<serde_json::Value>) -> String {
+ let mut translator = LiveStreamTranslator::new("msg_1", "gpt-5.5");
+ let mut out = Vec::new();
+ for event in events {
+ out.extend(translator.accept(&event, None).unwrap());
+ }
+ String::from_utf8(out).unwrap()
+ }
+
+ #[test]
+ fn emits_text_delta_before_terminal_event() {
+ let mut translator = LiveStreamTranslator::new("msg_1", "gpt-5.5");
+ let out = translator
+ .accept(
+ &json!({
+ "type": "response.output_text.delta",
+ "output_index": 0,
+ "delta": "hello"
+ }),
+ None,
+ )
+ .unwrap();
+ let out = String::from_utf8(out).unwrap();
+ assert!(out.contains("message_start"));
+ assert!(out.contains("content_block_start"));
+ assert!(out.contains("text_delta"));
+ assert!(out.contains("hello"));
+ assert!(!out.contains("message_stop"));
+ }
+
+ #[test]
+ fn finishes_text_stream() {
+ let out = render(vec![
+ json!({
+ "type": "response.output_item.added",
+ "output_index": 0,
+ "item": {"type": "message", "id": "msg_up"}
+ }),
+ json!({
+ "type": "response.output_text.delta",
+ "output_index": 0,
+ "delta": "hello"
+ }),
+ json!({
+ "type": "response.output_item.done",
+ "output_index": 0,
+ "item": {"type": "message"}
+ }),
+ json!({
+ "type": "response.completed",
+ "response": {"id": "resp_1", "usage": {"input_tokens": 2, "output_tokens": 1}}
+ }),
+ ]);
+ assert!(out.contains("content_block_stop"));
+ assert!(out.contains("message_delta"));
+ assert!(out.contains("message_stop"));
+ }
+
+ #[test]
+ fn buffers_read_tool_args_until_done() {
+ let out = render(vec![
+ json!({
+ "type": "response.output_item.added",
+ "output_index": 0,
+ "item": {"type": "function_call", "call_id": "call_1", "name": "Read"}
+ }),
+ json!({
+ "type": "response.function_call_arguments.delta",
+ "output_index": 0,
+ "delta": "{\"file_path\":\"/tmp/a\",\"pages\":\"\"}"
+ }),
+ json!({
+ "type": "response.output_item.done",
+ "output_index": 0,
+ "item": {
+ "type": "function_call",
+ "call_id": "call_1",
+ "name": "Read",
+ "arguments": "{\"file_path\":\"/tmp/a\",\"pages\":\"\"}"
+ }
+ }),
+ json!({
+ "type": "response.completed",
+ "response": {"id": "resp_1", "usage": {}}
+ }),
+ ]);
+ assert!(out.contains("tool_use"));
+ assert!(out.contains("input_json_delta"));
+ assert!(out.contains("/tmp/a"));
+ assert!(!out.contains("pages"));
+ }
+}
diff --git a/src/providers/codex/translate/mod.rs b/src/providers/codex/translate/mod.rs
index 7089edb..b102d79 100644
--- a/src/providers/codex/translate/mod.rs
+++ b/src/providers/codex/translate/mod.rs
@@ -1,4 +1,5 @@
pub mod accumulate;
+pub mod live_stream;
pub mod model_allowlist;
pub mod reducer;
pub mod request;
diff --git a/src/providers/codex/websocket.rs b/src/providers/codex/websocket.rs
index c536230..c6be6a2 100644
--- a/src/providers/codex/websocket.rs
+++ b/src/providers/codex/websocket.rs
@@ -6,6 +6,7 @@ use futures_util::{SinkExt, StreamExt};
use http::HeaderMap;
use tokio::net::TcpStream;
use tokio::sync::Mutex as AsyncMutex;
+use tokio::sync::mpsc;
use tokio_tungstenite::{
MaybeTlsStream, WebSocketStream, connect_async,
tungstenite::{self, Message, handshake::client::generate_key},
@@ -37,6 +38,8 @@ const TERMINAL_EVENTS: &[&str] = &[
"error",
];
+pub type CodexWebSocketEventReceiver = mpsc::Receiver<Result<serde_json::Value, CodexError>>;
+
// ---------------------------------------------------------------------------
// Errors
// ---------------------------------------------------------------------------
@@ -431,6 +434,78 @@ pub async fn codex_websocket_request(
}
}
+#[allow(clippy::too_many_arguments)]
+pub async fn codex_websocket_event_stream(
+ url: &str,
+ headers: &HeaderMap,
+ body_value: &serde_json::Value,
+ _ctx: &RequestContext,
+ traffic: Option<Arc<TrafficCapture>>,
+ pool_key: Option<&str>,
+ connect_timeout_ms: u64,
+ idle_timeout_ms: u64,
+ continuation: Option<&ContinuationCandidate>,
+) -> Result<CodexWebSocketEventReceiver, CodexError> {
+ let ws_url = to_websocket_url(url).map_err(|e| CodexError {
+ status: 0,
+ message: e.message,
+ detail: None,
+ retry_after: None,
+ origin: CodexErrorOrigin::WebSocket,
+ })?;
+ let body_json = serde_json::to_string(body_value).unwrap_or_default();
+ if let Some(tc) = traffic.as_deref() {
+ tc.write_json("020-upstream-request", body_value);
+ tc.write_json(
+ "021-upstream-request-metadata",
+ &serde_json::json!({
+ "provider": "codex",
+ "transport": "websocket",
+ "url": ws_url,
+ "method": "GET",
+ "headers": headers_to_json(headers),
+ "size": summarize_json_request_size(body_value, &body_json),
+ "continuation": {
+ "previousResponseId": continuation
+ .and_then(|c| c.previous_response_id.as_deref()),
+ "inputDeltaCount": continuation
+ .and_then(|c| c.input_delta.as_ref())
+ .map(|items| items.len()),
+ "disabledReason": continuation
+ .and_then(|c| c.disabled_reason.as_deref()),
+ },
+ }),
+ );
+ 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 (tx, rx) = mpsc::channel(64);
+ let pool_key = pool_key.map(str::to_string);
+ tokio::spawn(async move {
+ stream_ws_events(
+ &mut ws_stream,
+ idle_timeout_ms,
+ pool_key.as_deref(),
+ traffic,
+ tx,
+ )
+ .await;
+ });
+ Ok(rx)
+}
+
fn missing_terminal_error() -> CodexError {
CodexError {
status: 0,
@@ -773,6 +848,161 @@ async fn collect_ws_events(
Ok((sse_body, terminal_event))
}
+async fn stream_ws_events(
+ ws: &mut WebSocketStream<MaybeTlsStream<TcpStream>>,
+ idle_timeout_ms: u64,
+ pool_key: Option<&str>,
+ traffic: Option<Arc<TrafficCapture>>,
+ tx: mpsc::Sender<Result<serde_json::Value, CodexError>>,
+) {
+ let started_at = Instant::now();
+ let mut sse_body: Vec<u8> = Vec::new();
+ let response_event_budget = Duration::from_millis(idle_timeout_ms);
+ let response_wait_started = Instant::now();
+ let mut last_response_event_at = response_wait_started;
+ let mut response_started = false;
+ let mut status = 200u16;
+
+ loop {
+ let response_deadline_started = if response_started {
+ last_response_event_at
+ } else {
+ response_wait_started
+ };
+ let read_timeout =
+ match response_event_budget.checked_sub(response_deadline_started.elapsed()) {
+ Some(remaining) if !remaining.is_zero() => remaining,
+ _ => {
+ if let Some(key) = pool_key {
+ invalidate_codex_websocket_pool_key(key);
+ }
+ let err = if response_started {
+ CodexError {
+ status: 0,
+ message: format!("WebSocket idle timeout after {idle_timeout_ms}ms"),
+ detail: None,
+ retry_after: None,
+ origin: CodexErrorOrigin::WebSocket,
+ }
+ } else {
+ response_start_timeout_error(idle_timeout_ms)
+ };
+ let _ = tx.send(Err(err)).await;
+ break;
+ }
+ };
+
+ let frame = match tokio::time::timeout(read_timeout, ws.next()).await {
+ Ok(frame) => frame,
+ Err(_) => {
+ if let Some(key) = pool_key {
+ invalidate_codex_websocket_pool_key(key);
+ }
+ let err = if response_started {
+ CodexError {
+ status: 0,
+ message: format!("WebSocket idle timeout after {idle_timeout_ms}ms"),
+ detail: None,
+ retry_after: None,
+ origin: CodexErrorOrigin::WebSocket,
+ }
+ } else {
+ response_start_timeout_error(idle_timeout_ms)
+ };
+ let _ = tx.send(Err(err)).await;
+ break;
+ }
+ };
+
+ match frame {
+ Some(Ok(Message::Text(text))) => {
+ let parsed: serde_json::Value = match serde_json::from_str(&text) {
+ Ok(v) => v,
+ Err(_) => {
+ if let Some(tc) = traffic.as_deref() {
+ tc.write_json_event(
+ "040-upstream-event",
+ &serde_json::json!({
+ "unparseable": true,
+ "data": text,
+ }),
+ );
+ }
+ sse_body.extend_from_slice(&encode_sse(&text));
+ continue;
+ }
+ };
+
+ sse_body.extend_from_slice(&encode_sse(&text));
+ if let Some(tc) = traffic.as_deref() {
+ tc.write_json_event("040-upstream-event", &parsed);
+ }
+
+ if is_response_event(&parsed) {
+ response_started = true;
+ last_response_event_at = Instant::now();
+ }
+
+ if parsed.get("type").and_then(|v| v.as_str()) == Some("error") {
+ status = extract_status_from_error(&parsed).unwrap_or(500);
+ }
+ let terminal = is_terminal_event(&parsed);
+ if tx.send(Ok(parsed)).await.is_err() {
+ break;
+ }
+ if terminal {
+ break;
+ }
+ }
+ Some(Ok(Message::Binary(_))) => {
+ if let Some(key) = pool_key {
+ invalidate_codex_websocket_pool_key(key);
+ }
+ let _ = tx
+ .send(Err(CodexError {
+ status: 0,
+ message: "WebSocket binary frames not supported".to_string(),
+ detail: None,
+ retry_after: None,
+ origin: CodexErrorOrigin::WebSocket,
+ }))
+ .await;
+ break;
+ }
+ Some(Ok(Message::Ping(data))) => {
+ let _ = ws.send(Message::Pong(data)).await;
+ }
+ Some(Ok(Message::Pong(_))) | Some(Ok(Message::Frame(_))) => {}
+ Some(Ok(Message::Close(_))) | None => {
+ if let Some(key) = pool_key {
+ invalidate_codex_websocket_pool_key(key);
+ }
+ let _ = tx.send(Err(missing_terminal_error())).await;
+ break;
+ }
+ Some(Err(e)) => {
+ if let Some(key) = pool_key {
+ invalidate_codex_websocket_pool_key(key);
+ }
+ let _ = tx
+ .send(Err(CodexError {
+ status: 0,
+ message: format!("WebSocket stream error: {e}"),
+ detail: None,
+ retry_after: None,
+ origin: CodexErrorOrigin::WebSocket,
+ }))
+ .await;
+ break;
+ }
+ }
+ }
+
+ if let Some(tc) = traffic.as_deref() {
+ write_websocket_response_capture(tc, status, started_at.elapsed(), &sse_body);
+ }
+}
+
fn headers_to_json(headers: &HeaderMap) -> serde_json::Value {
let mut out = serde_json::Map::new();
for (key, value) in headers.iter() {
diff --git a/tests/smoke_cutover.rs b/tests/smoke_cutover.rs
index 47b8b1c..a1be75f 100644
--- a/tests/smoke_cutover.rs
+++ b/tests/smoke_cutover.rs
@@ -8,9 +8,11 @@ use claude_code_proxy::providers::codex::continuation::clear_all_continuations_f
use claude_code_proxy::providers::codex::websocket::clear_codex_websocket_pool_for_tests;
use claude_code_proxy::{registry::Registry, server::app};
use futures_util::{SinkExt, StreamExt};
+use http_body_util::BodyExt;
use serde_json::{Value, json};
use std::path::{Path, PathBuf};
use std::sync::{Arc, Mutex, OnceLock};
+use std::time::Duration;
use tempfile::TempDir;
use tokio::net::TcpListener;
use tokio_tungstenite::tungstenite::Message;
@@ -210,6 +212,39 @@ async fn spawn_websocket_upstream(captured: Arc<Mutex<Option<Value>>>) -> String
addr_str
}
+async fn spawn_websocket_delayed_terminal_upstream() -> 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 early_events = [
+ r#"{"type":"response.output_item.added","output_index":0,"item":{"type":"message","id":"msg_up"}}"#,
+ r#"{"type":"response.output_text.delta","output_index":0,"delta":"early chunk"}"#,
+ ];
+ for event in &early_events {
+ let _ = ws.send(Message::Text(event.to_string())).await;
+ }
+
+ tokio::time::sleep(Duration::from_secs(2)).await;
+
+ let terminal_events = [
+ r#"{"type":"response.output_item.done","output_index":0,"item":{"type":"message"}}"#,
+ r#"{"type":"response.completed","response":{"id":"resp_1","usage":{"input_tokens":5,"output_tokens":2}}}"#,
+ ];
+ for event in &terminal_events {
+ 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();
@@ -613,6 +648,56 @@ async fn smoke_codex_websocket_messages_uses_mock_upstream() {
assert!(sent.get("stream").is_none());
}
+#[allow(clippy::await_holding_lock)]
+#[tokio::test(flavor = "multi_thread")]
+async fn smoke_codex_websocket_stream_returns_delta_before_terminal() {
+ let _guard = env_lock();
+ let config = TempDir::new().unwrap();
+ write_auth(config.path(), "codex");
+ clear_codex_websocket_pool_for_tests();
+
+ let upstream = spawn_websocket_delayed_terminal_upstream().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 = tokio::time::timeout(
+ Duration::from_millis(500),
+ call_messages_body(json!({
+ "model": "gpt-5.5",
+ "max_tokens": 64,
+ "stream": true,
+ "messages": [{"role":"user","content":"hello"}]
+ })),
+ )
+ .await
+ .expect("streaming response should start before terminal upstream event");
+ assert_eq!(response.status(), StatusCode::OK);
+
+ let mut body = response.into_body();
+ let mut collected = Vec::new();
+ let read = tokio::time::timeout(Duration::from_millis(500), async {
+ while !String::from_utf8_lossy(&collected).contains("text_delta") {
+ let Some(frame) = body.frame().await else {
+ break;
+ };
+ let frame = frame.unwrap();
+ if let Ok(data) = frame.into_data() {
+ collected.extend_from_slice(&data);
+ }
+ }
+ })
+ .await;
+ assert!(read.is_ok(), "stream did not yield an early text delta");
+ let text = String::from_utf8_lossy(&collected);
+ assert!(text.contains("early chunk"), "stream body: {text}");
+ assert!(
+ !text.contains("message_stop"),
+ "stream finished too early: {text}"
+ );
+}
+
#[allow(clippy::await_holding_lock)]
#[tokio::test(flavor = "multi_thread")]
async fn smoke_codex_websocket_previous_response_id_sends_delta_on_second_turn() {