Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy
Rust
fix(codex): retry terminal-only live completions (#70)
Kunaii31fefce47961
diff --git a/src/providers/codex/mod.rs b/src/providers/codex/mod.rsindex 13f7125..0717421 100644--- a/src/providers/codex/mod.rs+++ b/src/providers/codex/mod.rs@@ -20,6 +20,7 @@ use std::sync::Arc;use crate::anthropic::error::json_error;use crate::anthropic::schema::{CountTokensResponse, MessagesRequest};+use crate::anthropic::sse::parse_sse_events;use crate::config;use crate::logging::create_logger;use crate::monitor::usage_from_anthropic_sse;@@ -567,6 +568,9 @@ async fn live_stream_response_once() -> LiveStreamStart {let mut translator = LiveStreamTranslator::new(message_id, model.to_string());let mut upstream_sse_body = Vec::new();+ // Keep protocol framing private until real output makes a transparent retry unsafe.+ // Every branch that consumes pending_chunk returns, so it is never flushed twice.+ let mut pending_chunk = Vec::new();let mut generation_started = false;while let Some(item) = upstream_events.recv().await {@@ -592,7 +596,7 @@ async fn live_stream_response_once(generation_started = true;}append_upstream_sse_payload(&mut upstream_sse_body, &payload);- let (chunk, terminal) = match translate_live_stream_payload(&mut translator, &payload, &ctx)+ let (chunk, terminal) = match translate_live_stream_payload(&mut translator, &payload, None){Ok(result) => result,Err(message) => {@@ -638,8 +642,18 @@ async fn live_stream_response_once(return LiveStreamStart::Response(map_codex_failure_to_response(&message));}};- if !chunk.is_empty() {- record_live_stream_progress(&ctx, &chunk);+ pending_chunk.extend_from_slice(&chunk);+ if terminal+ && is_codex_success_terminal_event(&payload)+ && !translator.has_semantic_output()+ {+ return LiveStreamStart::Retry {+ error: empty_live_completion_error(),+ };+ }+ if translator.has_semantic_output() && !pending_chunk.is_empty() {+ record_live_stream_downstream_capture(&ctx, &pending_chunk);+ record_live_stream_progress(&ctx, &pending_chunk);if terminal {update_continuation_from_upstream(ctx.session_id.as_deref(),@@ -648,12 +662,12 @@ async fn live_stream_response_once(&upstream_sse_body,compact_boundary,);- return LiveStreamStart::Response(single_live_stream_response(chunk));+ return LiveStreamStart::Response(single_live_stream_response(pending_chunk));}return LiveStreamStart::Response(remaining_live_stream_response(upstream_events,translator,- chunk,+ pending_chunk,ctx,turn_id,request_body,@@ -669,7 +683,12 @@ async fn live_stream_response_once(&upstream_sse_body,compact_boundary,);- return LiveStreamStart::Response(empty_live_stream_response());+ if pending_chunk.is_empty() {+ return LiveStreamStart::Response(empty_live_stream_response());+ }+ record_live_stream_downstream_capture(&ctx, &pending_chunk);+ record_live_stream_progress(&ctx, &pending_chunk);+ return LiveStreamStart::Response(single_live_stream_response(pending_chunk));}}@@ -684,6 +703,16 @@ async fn live_stream_response_once(}}+fn empty_live_completion_error() -> client::CodexError {+ client::CodexError {+ status: 503,+ message: "Codex completed without producing output".to_string(),+ detail: Some(EMPTY_CODEX_COMPLETION_DETAIL.to_string()),+ retry_after: None,+ origin: client::CodexErrorOrigin::WebSocket,+ }+}+fn codex_generation_event(payload: &serde_json::Value) -> bool {!matches!(payload.get("type").and_then(|value| value.as_str()),@@ -694,13 +723,31 @@ fn codex_generation_event(payload: &serde_json::Value) -> bool {fn translate_live_stream_payload(translator: &mut LiveStreamTranslator,payload: &serde_json::Value,- ctx: &RequestContext,+ traffic: Option<&crate::traffic::TrafficCapture>,) -> Result<(Vec<u8>, bool), String> {- let chunk = translator.accept(payload, ctx.traffic.as_deref())?;+ let chunk = translator.accept(payload, traffic)?;let terminal = is_codex_terminal_event(payload) || translator.is_finished();Ok((chunk, terminal))}+fn record_live_stream_downstream_capture(ctx: &RequestContext, chunk: &[u8]) {+ let Some(traffic) = ctx.traffic.as_ref() else {+ return;+ };+ for event in parse_sse_events(chunk) {+ let Ok(data) = serde_json::from_str::<serde_json::Value>(&event.data) else {+ continue;+ };+ traffic.write_json_event(+ "050-downstream-event",+ &serde_json::json!({+ "event": event.event.as_deref().unwrap_or("message"),+ "data": data,+ }),+ );+ }+}+fn record_live_stream_progress(ctx: &RequestContext, chunk: &[u8]) {if let Some(monitor) = ctx.monitor.as_ref() {let (input_tokens, output_tokens) = usage_from_anthropic_sse(chunk);@@ -750,28 +797,31 @@ fn remaining_live_stream_response(match item {Ok(payload) => {append_upstream_sse_payload(&mut upstream_sse_body, &payload);- let (chunk, terminal) =- match translate_live_stream_payload(&mut translator, &payload, &ctx) {- Ok(result) => result,- Err(message) => {- abort_request_state(- ctx.session_id.as_deref(),- turn_id,- compact_boundary,- &request_body,- );- let chunk = translator.error_chunk(- &message,- "api_error",- ctx.traffic.as_deref(),- );- if !chunk.is_empty() {- record_live_stream_progress(&ctx, &chunk);- let _ = tx.send(Ok(Bytes::from(chunk))).await;- }- return;+ let (chunk, terminal) = match translate_live_stream_payload(+ &mut translator,+ &payload,+ ctx.traffic.as_deref(),+ ) {+ Ok(result) => result,+ Err(message) => {+ abort_request_state(+ ctx.session_id.as_deref(),+ turn_id,+ compact_boundary,+ &request_body,+ );+ let chunk = translator.error_chunk(+ &message,+ "api_error",+ ctx.traffic.as_deref(),+ );+ if !chunk.is_empty() {+ record_live_stream_progress(&ctx, &chunk);+ let _ = tx.send(Ok(Bytes::from(chunk))).await;}- };+ return;+ }+ };if !chunk.is_empty() {record_live_stream_progress(&ctx, &chunk);if tx.send(Ok(Bytes::from(chunk))).await.is_err() {@@ -926,6 +976,13 @@ fn is_codex_terminal_event(payload: &serde_json::Value) -> bool {)}+fn is_codex_success_terminal_event(payload: &serde_json::Value) -> bool {+ matches!(+ payload.get("type").and_then(|v| v.as_str()),+ Some("response.completed") | Some("response.done")+ )+}+fn retryable_live_start_codex_error(err: &client::CodexError) -> bool {if err.origin == client::CodexErrorOrigin::WebSocketHandshake {return err.status == 0 || matches!(err.status, 429 | 500 | 502 | 503 | 504 | 529);@@ -1481,6 +1538,18 @@ mod tests {);}+ #[tokio::test]+ async fn empty_live_completion_maps_to_explicit_service_unavailable() {+ let err = empty_live_completion_error();++ assert_eq!(err.status, 503);+ assert_eq!(err.detail.as_deref(), Some(EMPTY_CODEX_COMPLETION_DETAIL));+ assert_eq!(+ map_codex_error_to_response(&err).status(),+ StatusCode::SERVICE_UNAVAILABLE+ );+ }+#[test]fn live_start_statusless_websocket_handshake_error_is_retryable() {let err = client::CodexError {diff --git a/src/providers/codex/translate/live_stream.rs b/src/providers/codex/translate/live_stream.rsindex 3ae5d34..de79e16 100644--- a/src/providers/codex/translate/live_stream.rs+++ b/src/providers/codex/translate/live_stream.rs@@ -63,6 +63,7 @@ pub struct LiveStreamTranslator {web_searches: Vec<LiveWebSearch>,web_search_results: Vec<LiveWebSearchResult>,deferred_text: Vec<(usize, String)>,+ semantic_output_started: bool,finished: bool,}@@ -82,6 +83,7 @@ impl LiveStreamTranslator {web_searches: Vec::new(),web_search_results: Vec::new(),deferred_text: Vec::new(),+ semantic_output_started: false,finished: false,}}@@ -163,6 +165,10 @@ impl LiveStreamTranslator {self.finished}+ pub fn has_semantic_output(&self) -> bool {+ self.semantic_output_started+ }+pub fn finish_after_closed_completed_tool_call(&mut self,traffic: Option<&TrafficCapture>,@@ -305,6 +311,7 @@ impl LiveStreamTranslator {"function_call" => {self.close_thinking(traffic, out);self.saw_tool_use = true;+ self.semantic_output_started = true;let index = self.anthropic_index;self.anthropic_index += 1;let call_id = item@@ -364,6 +371,7 @@ impl LiveStreamTranslator {if delta.is_empty() {return;}+ self.semantic_output_started = true;if self.thinking.map(|thinking| thinking.output_index) != Some(output_index) {self.close_thinking(traffic, out);let index = self.anthropic_index;@@ -411,6 +419,7 @@ impl LiveStreamTranslator {if delta.is_empty() {return;}+ self.semantic_output_started = true;let output_index = payload.get("output_index")@@ -626,6 +635,7 @@ impl LiveStreamTranslator {== Some("web_search_call"){self.close_thinking(traffic, out);+ self.semantic_output_started = true;let item = &payload["item"];let index = self.anthropic_index;self.anthropic_index += 1;@@ -946,6 +956,7 @@ impl LiveStreamTranslator {let Some(signature) = encode_reasoning_signature(&replay) else {return;};+ self.semantic_output_started = true;let index = self.anthropic_index;self.anthropic_index += 1;self.ensure_message_start(traffic, out);@@ -1188,6 +1199,7 @@ mod tests {assert!(out.contains("text_delta"));assert!(out.contains("hello"));assert!(!out.contains("message_stop"));+ assert!(translator.has_semantic_output());}#[test]@@ -1220,13 +1232,77 @@ mod tests {}#[test]- fn completed_response_with_null_incomplete_details_is_end_turn() {- let out = render(vec![json!({- "type": "response.completed",- "response": {"id": "resp_1", "status": "completed", "incomplete_details": null, "usage": {}}- })]);+ fn terminal_only_completion_remains_non_semantic() {+ let mut translator = LiveStreamTranslator::new("msg_1", "gpt-5.5");+ let out = translator+ .accept(+ &json!({+ "type": "response.completed",+ "response": {"id": "resp_1", "status": "completed", "incomplete_details": null, "usage": {}}+ }),+ None,+ )+ .unwrap();+ let out = String::from_utf8(out).unwrap();assert!(out.contains(r#""stop_reason":"end_turn""#));assert!(!out.contains(r#""stop_reason":"max_tokens""#));+ assert!(!translator.has_semantic_output());+ }++ #[test]+ fn tool_thinking_and_web_search_events_are_semantic() {+ let mut tool = LiveStreamTranslator::new("msg_tool", "gpt-5.5");+ tool.accept(+ &json!({+ "type": "response.output_item.added",+ "output_index": 0,+ "item": {"type": "function_call", "call_id": "call_1", "name": "Read"}+ }),+ None,+ )+ .unwrap();+ assert!(tool.has_semantic_output());++ let mut thinking = LiveStreamTranslator::new("msg_thinking", "gpt-5.5");+ thinking+ .accept(+ &json!({+ "type": "response.reasoning_summary_text.delta",+ "output_index": 0,+ "delta": "plan"+ }),+ None,+ )+ .unwrap();+ assert!(thinking.has_semantic_output());++ let mut web_search = LiveStreamTranslator::new("msg_search", "gpt-5.5");+ web_search+ .accept(+ &json!({+ "type": "response.output_item.added",+ "output_index": 0,+ "item": {"type": "web_search_call", "id": "ws_1"}+ }),+ None,+ )+ .unwrap();+ assert!(!web_search.has_semantic_output());+ web_search+ .accept(+ &json!({+ "type": "response.output_item.done",+ "output_index": 0,+ "item": {+ "type": "web_search_call",+ "id": "ws_1",+ "action": {"query": "claude-code-proxy"}+ }+ }),+ None,+ )+ .unwrap();+ assert!(web_search.has_semantic_output());}#[test]@@ -1437,4 +1513,28 @@ mod tests {assert!(signature_delta < thinking_stop);assert!(out.contains("ccp:codex:v1:"));}++ #[test]+ fn signature_only_reasoning_is_semantic_output() {+ let mut translator = LiveStreamTranslator::new("msg_1", "gpt-5.5");+ let mut out = Vec::new();+ for event in [+ json!({+ "type":"response.output_item.added",+ "output_index":0,+ "item":{"type":"reasoning","id":"rs_1","encrypted_content":"opaque"}+ }),+ json!({+ "type":"response.output_item.done",+ "output_index":0,+ "item":{"type":"reasoning","id":"rs_1"}+ }),+ ] {+ out.extend(translator.accept(&event, None).unwrap());+ }++ let out = String::from_utf8(out).unwrap();+ assert!(out.contains(r#""type":"signature_delta""#));+ assert!(translator.has_semantic_output());+ }}diff --git a/tests/smoke_cutover.rs b/tests/smoke_cutover.rsindex df700b2..35b91da 100644--- a/tests/smoke_cutover.rs+++ b/tests/smoke_cutover.rs@@ -538,6 +538,144 @@ async fn spawn_websocket_close_then_retry_upstream(captured: Arc<Mutex<Vec<Valueaddr_str}+async fn spawn_websocket_empty_completion_then_retry_upstream(+ captured: Arc<Mutex<Vec<Value>>>,+) -> String {+ let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();+ let addr = listener.local_addr().unwrap();+ let addr_str = format!("http://{addr}");++ tokio::spawn(async move {+ let mut handled = 0usize;+ while handled < 3 {+ let Ok((stream, _)) = listener.accept().await else {+ return;+ };+ let Ok(ws) = tokio_tungstenite::accept_async(stream).await else {+ return;+ };+ let (mut sender, mut receiver) = ws.split();++ while handled < 3 {+ let Some(text) = (loop {+ match receiver.next().await {+ Some(Ok(Message::Text(text))) => break Some(text),+ Some(Ok(Message::Ping(data))) => {+ let _ = sender.send(Message::Pong(data)).await;+ }+ Some(Ok(Message::Pong(_))) => {}+ Some(Ok(_)) => {}+ Some(Err(_)) | None => break None,+ }+ }) else {+ break;+ };+ if let Ok(json) = serde_json::from_str::<Value>(&text) {+ let _ = captured.lock().map(|mut g| g.push(json));+ }++ if handled == 1 {+ let event = json!({+ "type": "response.completed",+ "response": {+ "id": "resp_empty",+ "status": "completed",+ "incomplete_details": null,+ "usage": {"input_tokens": 5, "output_tokens": 0}+ }+ });+ let _ = sender.send(Message::Text(event.to_string())).await;+ handled += 1;+ continue;+ }++ let response_text = if handled == 0 { "first" } else { "retry" };+ let response_id = if handled == 0 { "resp_1" } else { "resp_retry" };+ let events = [+ json!({+ "type":"response.output_item.added",+ "output_index":0,+ "item":{"type":"message","id":format!("msg_empty_{handled}")}+ }),+ json!({+ "type":"response.output_text.delta",+ "output_index":0,+ "delta":response_text+ }),+ json!({+ "type":"response.output_item.done",+ "output_index":0,+ "item":{"type":"message"}+ }),+ json!({+ "type":"response.completed",+ "response":{"id":response_id,"usage":{"input_tokens":5,"output_tokens":2}}+ }),+ ];++ for event in &events {+ let _ = sender.send(Message::Text(event.to_string())).await;+ }+ handled += 1;+ }+ }+ });++ addr_str+}++/// Upstream that answers every request with a terminal-only completion,+/// so the proxy's bounded retry loop always exhausts.+async fn spawn_websocket_always_empty_completion_upstream(+ request_count: Arc<std::sync::atomic::AtomicUsize>,+) -> 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 {+ loop {+ let Ok((stream, _)) = listener.accept().await else {+ return;+ };+ let Ok(ws) = tokio_tungstenite::accept_async(stream).await else {+ return;+ };+ let (mut sender, mut receiver) = ws.split();+ let request_count = request_count.clone();++ tokio::spawn(async move {+ while let Some(message) = receiver.next().await {+ match message {+ Ok(Message::Text(_)) => {+ request_count.fetch_add(1, std::sync::atomic::Ordering::SeqCst);+ let event = json!({+ "type": "response.completed",+ "response": {+ "id": "resp_empty",+ "status": "completed",+ "incomplete_details": null,+ "usage": {"input_tokens": 5, "output_tokens": 0}+ }+ });+ if sender.send(Message::Text(event.to_string())).await.is_err() {+ return;+ }+ }+ Ok(Message::Ping(data)) => {+ let _ = sender.send(Message::Pong(data)).await;+ }+ Ok(_) => {}+ Err(_) => return,+ }+ }+ });+ }+ });++ addr_str+}+// ---------------------------------------------------------------------------// Health and routing smoke tests (no env var mutation needed)// ---------------------------------------------------------------------------@@ -1736,6 +1874,140 @@ async fn smoke_codex_websocket_stream_retries_empty_close_with_full_context() {clear_codex_websocket_pool_for_tests();}+#[allow(clippy::await_holding_lock)]+#[tokio::test(flavor = "multi_thread")]+async fn smoke_codex_websocket_stream_retries_terminal_only_completion_with_full_context() {+ let _guard = env_lock();+ let config = TempDir::new().unwrap();+ let state = 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_empty_completion_then_retry_upstream(captured.clone()).await;++ let _traffic_env = EnvGuard::set("CCP_TRAFFIC_LOG", "1");+ let _state_env = EnvGuard::set("XDG_STATE_HOME", state.path());+ let _config_env = EnvGuard::set("CCP_CONFIG_DIR", config.path());+ let _base_url_env = EnvGuard::set("CCP_CODEX_BASE_URL", &upstream);+ let _transport_env = EnvGuard::set("CCP_CODEX_TRANSPORT", "websocket");+ let _previous_response_env = EnvGuard::set("CCP_CODEX_PREVIOUS_RESPONSE_ID", "1");++ let first = call_messages_body(json!({+ "model": "gpt-5.5",+ "max_tokens": 64,+ "stream": true,+ "messages": [{"role":"user","content":"one"}]+ }))+ .await;+ assert_eq!(first.status(), StatusCode::OK);+ let _ = axum::body::to_bytes(first.into_body(), usize::MAX)+ .await+ .unwrap();++ let second = call_messages_body(json!({+ "model": "gpt-5.5",+ "max_tokens": 64,+ "stream": true,+ "messages": [+ {"role":"user","content":"one"},+ {"role":"assistant","content":"first"},+ {"role":"user","content":"two"}+ ]+ }))+ .await;+ assert_eq!(second.status(), StatusCode::OK);+ let second_body = axum::body::to_bytes(second.into_body(), usize::MAX)+ .await+ .unwrap();+ assert!(+ String::from_utf8_lossy(&second_body).contains("retry"),+ "second response body: {}",+ String::from_utf8_lossy(&second_body)+ );++ let downstream_end_turns = traffic_files(state.path())+ .into_iter()+ .filter(|path| {+ path.file_name()+ .and_then(|name| name.to_str())+ .is_some_and(|name| name.ends_with("050-downstream-event.json"))+ })+ .filter_map(|path| std::fs::read(path).ok())+ .filter_map(|bytes| serde_json::from_slice::<Value>(&bytes).ok())+ .filter(|event| event["data"]["delta"]["stop_reason"] == "end_turn")+ .count();+ assert_eq!(+ downstream_end_turns, 2,+ "discarded empty attempts must not be captured as downstream events"+ );++ let guard = captured.lock().unwrap();+ assert_eq!(guard.len(), 3, "expected full-context retry request");+ assert!(guard[0].get("previous_response_id").is_none());+ assert_eq!(guard[1]["previous_response_id"], "resp_1");+ assert!(guard[2].get("previous_response_id").is_none());+ assert_eq!(+ guard[2]["input"].as_array().map(Vec::len),+ Some(3),+ "retry request should send the full input"+ );++ clear_all_continuations_for_tests();+ clear_codex_websocket_pool_for_tests();+}++#[allow(clippy::await_holding_lock)]+#[tokio::test(flavor = "multi_thread")]+async fn smoke_codex_websocket_empty_completions_exhaust_to_service_unavailable() {+ let _guard = env_lock();+ let _delay_guard = ZeroRetryDelayGuard::enable();+ let config = TempDir::new().unwrap();+ write_auth(config.path(), "codex");+ clear_codex_websocket_pool_for_tests();+ clear_all_continuations_for_tests();++ let request_count = Arc::new(std::sync::atomic::AtomicUsize::new(0));+ let upstream = spawn_websocket_always_empty_completion_upstream(request_count.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 response = call_messages_body(json!({+ "model": "gpt-5.5",+ "max_tokens": 64,+ "stream": true,+ "messages": [{"role":"user","content":"one"}]+ }))+ .await;+ let status = response.status();+ let body = axum::body::to_bytes(response.into_body(), usize::MAX)+ .await+ .unwrap();+ let body_text = String::from_utf8_lossy(&body);++ assert_eq!(+ status,+ StatusCode::SERVICE_UNAVAILABLE,+ "exhausted empty completions must surface an explicit error: {body_text}"+ );+ assert!(+ body_text.contains("Codex completed without producing output"),+ "unexpected exhaustion body: {body_text}"+ );+ // Initial attempt plus MAX_RETRYABLE_LIVE_STREAM_RETRIES full-context retries.+ assert_eq!(+ request_count.load(std::sync::atomic::Ordering::SeqCst),+ 11,+ "retry loop must stay bounded"+ );++ 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() {