Skip to content

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.rs
index 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.rs
index 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.rs
index 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>, Upstream
let 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>, Upstream
kind: 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>, Upstream
kind,
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>, Upstream
Ok(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.rs
index 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.rs
index 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.