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.mdindex 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 ratediff --git a/src/providers/codex/client.rs b/src/providers/codex/client.rsindex 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.rsindex 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.rsnew file mode 100644index 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.rsindex 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.rsindex 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.rsindex 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_fuse 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>>>) -> Stringaddr_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() {