Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy
Rust
codex: capture stream diagnostics
Raine Virta7d521dfbb564
diff --git a/src/providers/codex/mod.rs b/src/providers/codex/mod.rsindex c12ef4c..0a0db80 100644--- a/src/providers/codex/mod.rs+++ b/src/providers/codex/mod.rs@@ -25,11 +25,11 @@ use self::auth::token_store::file_store;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;+use self::translate::accumulate::accumulate_response_with_traffic;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};-use self::translate::stream::translate_stream_bytes;+use self::translate::stream::translate_stream_bytes_with_traffic;// ---------------------------------------------------------------------------// Provider@@ -128,7 +128,12 @@ impl Provider for CodexProvider {};if want_stream {- let sse_bytes = match translate_stream_bytes(&upstream.body, &message_id, model) {+ let sse_bytes = match translate_stream_bytes_with_traffic(+ &upstream.body,+ &message_id,+ model,+ ctx.traffic.as_deref(),+ ) {Ok(b) => b,Err(e) => {clear_continuation(ctx.session_id.as_deref());@@ -152,7 +157,12 @@ impl Provider for CodexProvider {];(headers, sse_bytes).into_response()} else {- match accumulate_response(&upstream.body, &message_id, model) {+ match accumulate_response_with_traffic(+ &upstream.body,+ &message_id,+ model,+ ctx.traffic.as_deref(),+ ) {Ok(json) => {update_continuation_from_upstream(ctx.session_id.as_deref(),diff --git a/src/providers/codex/translate/accumulate.rs b/src/providers/codex/translate/accumulate.rsindex 497862f..afb25c7 100644--- a/src/providers/codex/translate/accumulate.rs+++ b/src/providers/codex/translate/accumulate.rs@@ -1,7 +1,10 @@use serde_json::Value;+use crate::traffic::TrafficCapture;+use super::reducer::{- AnthropicUsage, ReducerEvent, map_codex_usage_to_anthropic, reduce_upstream_bytes,+ AnthropicUsage, ReducerEvent, UpstreamStreamError, map_codex_usage_to_anthropic,+ reduce_upstream_bytes,};use super::web_search_compat::{WebSearchCompatContent, build_web_search_compat_blocks};@@ -10,8 +13,26 @@ pub fn accumulate_response(message_id: &str,model: &str,) -> Result<Value, anyhow::Error> {- let events = reduce_upstream_bytes(upstream)- .map_err(|e| anyhow::anyhow!("upstream error: {} ({:?})", e.message, e.kind))?;+ accumulate_response_with_traffic(upstream, message_id, model, None)+}++pub fn accumulate_response_with_traffic(+ upstream: &[u8],+ message_id: &str,+ model: &str,+ traffic: Option<&TrafficCapture>,+) -> Result<Value, anyhow::Error> {+ let events = match reduce_upstream_bytes(upstream) {+ Ok(events) => events,+ Err(err) => {+ write_reducer_error_capture(traffic, &err);+ return Err(anyhow::anyhow!(+ "upstream error: {} ({:?})",+ err.message,+ err.kind+ ));+ }+ };let mut blocks: Vec<AccumulatedBlock> = Vec::new();let mut stop_reason: Option<String> = None;@@ -170,6 +191,21 @@ pub fn accumulate_response(Ok(response)}+fn write_reducer_error_capture(traffic: Option<&TrafficCapture>, err: &UpstreamStreamError) {+ let Some(traffic) = traffic else {+ return;+ };+ traffic.write_json(+ "060-codex-reducer-error",+ &serde_json::json!({+ "kind": format!("{:?}", err.kind),+ "message": err.message,+ "retryAfterSeconds": err.retry_after_seconds,+ "diagnostics": err.diagnostics,+ }),+ );+}+#[cfg(test)]mod tests {use super::*;@@ -264,7 +300,7 @@ mod tests {#[test]fn accumulate_web_search_response() {let upstream = format!(- "{}{}{}{}{}{}{}",+ "{}{}{}{}{}{}{}{}",sse_event("response.output_item.added",json!({@@ -310,6 +346,12 @@ mod tests {"output_index":1,"item":{"type":"message"}})),+ sse_event(+ "response.completed",+ json!({+ "response":{"id":"resp_1","usage":{"input_tokens":3,"output_tokens":1}}+ })+ ),);let response = accumulate_response(upstream.as_bytes(), "msg_1", "gpt-5.5").unwrap();let content = response["content"].as_array().unwrap();diff --git a/src/providers/codex/translate/reducer.rs b/src/providers/codex/translate/reducer.rsindex 0bc1541..3caa572 100644--- a/src/providers/codex/translate/reducer.rs+++ b/src/providers/codex/translate/reducer.rs@@ -7,6 +7,7 @@ pub struct UpstreamStreamError {pub kind: UpstreamErrorKind,pub message: String,pub retry_after_seconds: Option<u64>,+ pub diagnostics: Option<UpstreamStreamDiagnostics>,}#[derive(Debug, Clone, PartialEq, Eq)]@@ -17,6 +18,29 @@ pub enum UpstreamErrorKind {Failed,}+#[derive(Debug, Clone, Default, serde::Serialize)]+pub struct UpstreamStreamDiagnostics {+ pub event_count: usize,+ pub last_event_type: Option<String>,+ pub saw_terminal_event: bool,+ pub open_blocks: Vec<OpenBlockDiagnostic>,+}++#[derive(Debug, Clone, serde::Serialize)]+pub struct OpenBlockDiagnostic {+ pub output_index: usize,+ pub anthropic_index: usize,+ pub kind: String,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub name: Option<String>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub call_id: Option<String>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub text_bytes: Option<usize>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub argument_bytes: Option<usize>,+}+#[derive(Debug, Clone, Default)]pub struct CodexUsage {pub input_tokens: Option<u64>,@@ -87,6 +111,24 @@ pub struct FinishMetadata {pub output_items: Vec<ResponsesInputItem>,}+enum BlockState {+ Text {+ index: usize,+ text_accum: String,+ },+ Tool {+ index: usize,+ #[allow(dead_code)]+ output_index: usize,+ call_id: String,+ name: String,+ args_accum: String,+ had_delta: bool,+ buffer_until_done: bool,+ emitted_args: bool,+ },+}+pub fn finish_metadata_from_upstream(input: &[u8],) -> Result<Option<FinishMetadata>, UpstreamStreamError> {@@ -125,24 +167,8 @@ pub fn reduce_upstream_bytes(input: &[u8]) -> Result<Vec<ReducerEvent>, Upstreamlet mut incomplete = false;let mut web_search_requests = 0usize;let mut _saw_terminal = false;-- enum BlockState {- Text {- index: usize,- text_accum: String,- },- Tool {- index: usize,- #[allow(dead_code)]- output_index: usize,- call_id: String,- name: String,- args_accum: String,- had_delta: bool,- buffer_until_done: bool,- emitted_args: bool,- },- }+ let mut event_count = 0usize;+ let mut last_event_type: Option<String> = None;fn capture_output_item(output_index: usize,@@ -201,6 +227,8 @@ pub fn reduce_upstream_bytes(input: &[u8]) -> Result<Vec<ReducerEvent>, Upstream.and_then(|v| v.as_str()).unwrap_or("").to_string();+ event_count += 1;+ last_event_type = Some(t.clone());if t == "codex.rate_limits" {if let Some(true) = p@@ -217,6 +245,7 @@ pub fn reduce_upstream_bytes(input: &[u8]) -> Result<Vec<ReducerEvent>, Upstreamkind: UpstreamErrorKind::RateLimit,message: "rate limit reached".to_string(),retry_after_seconds: retry_after.map(|f| f as u64),+ diagnostics: None,});}out.push(ReducerEvent::Progress);@@ -254,6 +283,7 @@ pub fn reduce_upstream_bytes(input: &[u8]) -> Result<Vec<ReducerEvent>, Upstreamkind,message: msg.to_string(),retry_after_seconds: retry_after,+ diagnostics: None,});}@@ -547,6 +577,26 @@ pub fn reduce_upstream_bytes(input: &[u8]) -> Result<Vec<ReducerEvent>, Upstream}}+ let open_blocks = describe_open_blocks(&blocks_by_output_index);+ if !_saw_terminal || !open_blocks.is_empty() {+ let diagnostics = UpstreamStreamDiagnostics {+ event_count,+ last_event_type,+ saw_terminal_event: _saw_terminal,+ open_blocks,+ };+ return Err(UpstreamStreamError {+ kind: UpstreamErrorKind::Transient,+ message: if diagnostics.saw_terminal_event {+ "upstream stream ended with open Codex output blocks".to_string()+ } else {+ "upstream stream ended before terminal Codex response event".to_string()+ },+ retry_after_seconds: None,+ diagnostics: Some(diagnostics),+ });+ }+let stop_reason: StopReason = if incomplete {STOP_MAX_TOKENS} else if saw_tool_use {@@ -570,6 +620,42 @@ pub fn reduce_upstream_bytes(input: &[u8]) -> Result<Vec<ReducerEvent>, UpstreamOk(out)}+fn describe_open_blocks(+ blocks: &std::collections::HashMap<usize, BlockState>,+) -> Vec<OpenBlockDiagnostic> {+ let mut out: Vec<_> = blocks+ .iter()+ .map(|(output_index, state)| match state {+ BlockState::Text { index, text_accum } => OpenBlockDiagnostic {+ output_index: *output_index,+ anthropic_index: *index,+ kind: "text".to_string(),+ name: None,+ call_id: None,+ text_bytes: Some(text_accum.len()),+ argument_bytes: None,+ },+ BlockState::Tool {+ index,+ call_id,+ name,+ args_accum,+ ..+ } => OpenBlockDiagnostic {+ output_index: *output_index,+ anthropic_index: *index,+ kind: "tool".to_string(),+ name: Some(name.clone()),+ call_id: Some(call_id.clone()),+ text_bytes: None,+ argument_bytes: Some(args_accum.len()),+ },+ })+ .collect();+ out.sort_by_key(|block| block.output_index);+ out+}+fn parse_codex_usage(response: &serde_json::Value) -> CodexUsage {let usage = match response.get("usage") {Some(u) => u,@@ -837,7 +923,7 @@ mod tests {#[test]fn reduce_tool_use_response() {let upstream = format!(- "{}{}{}{}",+ "{}{}{}{}{}",sse("response.output_item.added",json!({@@ -864,6 +950,12 @@ mod tests {"item":{"type":"function_call","call_id":"call_1","name":"Read","arguments":"{\"file_path\":\"/tmp/a\"}"}})),+ sse(+ "response.completed",+ json!({+ "response":{"id":"resp_1","usage":{}}+ })+ ),);let out = reduce_upstream_bytes(upstream.as_bytes()).unwrap();let last = out.last().unwrap();@@ -957,6 +1049,35 @@ mod tests {}}+ #[test]+ fn reduce_missing_terminal_is_error() {+ let upstream = format!(+ "{}{}{}",+ sse(+ "response.output_item.added",+ json!({+ "output_index": 0,+ "item": {"type":"message","id":"msg_up"}+ })+ ),+ sse(+ "response.output_text.delta",+ json!({+ "output_index":0,"delta":"partial"+ })+ ),+ sse(+ "response.output_item.done",+ json!({+ "output_index":0,"item":{"type":"message"}+ })+ ),+ );+ let err = reduce_upstream_bytes(upstream.as_bytes()).unwrap_err();+ assert_eq!(err.kind, UpstreamErrorKind::Transient);+ assert!(err.message.contains("terminal"));+ }+#[test]fn reduce_incomplete_is_max_tokens() {let upstream = sse(diff --git a/src/providers/codex/translate/stream.rs b/src/providers/codex/translate/stream.rsindex 76952ee..01b5862 100644--- a/src/providers/codex/translate/stream.rs+++ b/src/providers/codex/translate/stream.rs@@ -1,6 +1,9 @@use crate::anthropic::sse::encode_sse_event;+use crate::traffic::TrafficCapture;-use super::reducer::{ReducerEvent, map_codex_usage_to_anthropic, reduce_upstream_bytes};+use super::reducer::{+ ReducerEvent, UpstreamStreamError, map_codex_usage_to_anthropic, reduce_upstream_bytes,+};use super::web_search_compat::build_web_search_compat_blocks;pub fn translate_stream_bytes(@@ -8,8 +11,26 @@ pub fn translate_stream_bytes(message_id: &str,model: &str,) -> Result<Vec<u8>, anyhow::Error> {- let events = reduce_upstream_bytes(upstream)- .map_err(|e| anyhow::anyhow!("upstream stream error: {} ({:?})", e.message, e.kind))?;+ translate_stream_bytes_with_traffic(upstream, message_id, model, None)+}++pub fn translate_stream_bytes_with_traffic(+ upstream: &[u8],+ message_id: &str,+ model: &str,+ traffic: Option<&TrafficCapture>,+) -> Result<Vec<u8>, anyhow::Error> {+ let events = match reduce_upstream_bytes(upstream) {+ Ok(events) => events,+ Err(err) => {+ write_reducer_error_capture(traffic, &err);+ return Err(anyhow::anyhow!(+ "upstream stream error: {} ({:?})",+ err.message,+ err.kind+ ));+ }+ };let mut out = Vec::new();let mut message_started = false;@@ -25,6 +46,15 @@ pub fn translate_stream_bytes(}let mut emit = |event: &str, data: &serde_json::Value| -> Result<(), anyhow::Error> {+ 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()));Ok(())};@@ -367,6 +397,21 @@ pub fn translate_stream_bytes(Ok(out)}+fn write_reducer_error_capture(traffic: Option<&TrafficCapture>, err: &UpstreamStreamError) {+ let Some(traffic) = traffic else {+ return;+ };+ traffic.write_json(+ "060-codex-stream-reducer-error",+ &serde_json::json!({+ "kind": format!("{:?}", err.kind),+ "message": err.message,+ "retryAfterSeconds": err.retry_after_seconds,+ "diagnostics": err.diagnostics,+ }),+ );+}+#[cfg(test)]mod tests {use super::*;@@ -426,7 +471,7 @@ mod tests {#[test]fn stream_translates_web_search_response() {let upstream = format!(- "{}{}{}{}{}{}{}",+ "{}{}{}{}{}{}{}{}",sse_event("response.output_item.added",serde_json::json!({@@ -472,6 +517,12 @@ mod tests {"output_index":1,"item":{"type":"message"}})),+ sse_event(+ "response.completed",+ serde_json::json!({+ "response":{"id":"resp_1","usage":{"input_tokens":3,"output_tokens":1}}+ })+ ),);let result = translate_stream_bytes(upstream.as_bytes(), "msg_1", "gpt-5.5").unwrap();let out = String::from_utf8(result).unwrap();diff --git a/tests/smoke_cutover.rs b/tests/smoke_cutover.rsindex 511de47..e771ffc 100644--- a/tests/smoke_cutover.rs+++ b/tests/smoke_cutover.rs@@ -443,6 +443,7 @@ async fn smoke_codex_http_traffic_capture_writes_upstream_artifacts() {concat!("data: {\"type\":\"response.output_item.added\",\"output_index\":0,\"item\":{\"type\":\"message\",\"id\":\"msg_up\"}}\n\n","data: {\"type\":\"response.output_text.delta\",\"output_index\":0,\"delta\":\"codex http ok\"}\n\n",+ "data: {\"type\":\"response.output_item.done\",\"output_index\":0,\"item\":{\"type\":\"message\"}}\n\n","data: {\"type\":\"response.completed\",\"response\":{\"id\":\"resp_1\",\"usage\":{\"input_tokens\":5,\"output_tokens\":2}}}\n\n").as_bytes()@@ -478,6 +479,88 @@ async fn smoke_codex_http_traffic_capture_writes_upstream_artifacts() {traffic_file(&files, "040-upstream-event.json");}+#[allow(clippy::await_holding_lock)]+#[tokio::test]+async fn smoke_codex_http_stream_traffic_captures_downstream_events() {+ let _guard = env_lock();+ let config = TempDir::new().unwrap();+ let state = TempDir::new().unwrap();+ write_auth(config.path(), "codex");++ let upstream = spawn_http_upstream(|_body: Value| {+ concat!(+ "data: {\"type\":\"response.output_item.added\",\"output_index\":0,\"item\":{\"type\":\"message\",\"id\":\"msg_up\"}}\n\n",+ "data: {\"type\":\"response.output_text.delta\",\"output_index\":0,\"delta\":\"codex stream ok\"}\n\n",+ "data: {\"type\":\"response.output_item.done\",\"output_index\":0,\"item\":{\"type\":\"message\"}}\n\n",+ "data: {\"type\":\"response.completed\",\"response\":{\"id\":\"resp_1\",\"usage\":{\"input_tokens\":5,\"output_tokens\":2}}}\n\n"+ )+ .as_bytes()+ .to_vec()+ })+ .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", "http");+ let response = call_messages_body(json!({+ "model": "gpt-5.5",+ "max_tokens": 64,+ "stream": true,+ "messages": [{"role":"user","content":"hello"}]+ }))+ .await;++ assert_eq!(response.status(), StatusCode::OK);+ let body = axum::body::to_bytes(response.into_body(), usize::MAX)+ .await+ .unwrap();+ let text = String::from_utf8_lossy(&body);+ assert!(text.contains("message_stop"), "stream body: {text}");++ let files = traffic_files(state.path());+ let downstream = traffic_json(&files, "050-downstream-event.json");+ assert!(downstream.get("event").is_some());+ assert!(downstream.get("data").is_some());+}++#[allow(clippy::await_holding_lock)]+#[tokio::test]+async fn smoke_codex_http_truncated_upstream_writes_reducer_diagnostic() {+ let _guard = env_lock();+ let config = TempDir::new().unwrap();+ let state = TempDir::new().unwrap();+ write_auth(config.path(), "codex");++ let upstream = spawn_http_upstream(|_body: Value| {+ concat!(+ "data: {\"type\":\"response.output_item.added\",\"output_index\":0,\"item\":{\"type\":\"message\",\"id\":\"msg_up\"}}\n\n",+ "data: {\"type\":\"response.output_text.delta\",\"output_index\":0,\"delta\":\"partial\"}\n\n",+ "data: {\"type\":\"response.output_item.done\",\"output_index\":0,\"item\":{\"type\":\"message\"}}\n\n"+ )+ .as_bytes()+ .to_vec()+ })+ .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", "http");+ let response = call_messages("gpt-5.5").await;++ assert_eq!(response.status(), StatusCode::BAD_GATEWAY);+ let files = traffic_files(state.path());+ let diagnostic = traffic_json(&files, "060-codex-reducer-error.json");+ assert_eq!(diagnostic["kind"], "Transient");+ assert_eq!(+ diagnostic["diagnostics"]["saw_terminal_event"],+ Value::Bool(false)+ );+}+// ---------------------------------------------------------------------------// Codex WebSocket smoke: mock upstream verifies request shape and returns// Responses events over WebSocket.