Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy
Rust
add codex transport parity coverage
Raine Virta15c96f4306be
diff --git a/src/provider.rs b/src/provider.rsindex 3a92882..4b8a939 100644--- a/src/provider.rs+++ b/src/provider.rs@@ -1,8 +1,10 @@use crate::anthropic::schema::MessagesRequest;+use crate::traffic::TrafficCapture;use anyhow::Result;use async_trait::async_trait;use axum::response::Response;use clap::Subcommand;+use std::sync::Arc;#[derive(Debug, Clone, Subcommand)]pub enum AuthCommand {@@ -34,4 +36,5 @@ pub struct RequestContext {pub session_id: Option<String>,pub session_seq: Option<u64>,pub provider: String,+ pub traffic: Option<Arc<TrafficCapture>>,}diff --git a/src/providers/codex/client.rs b/src/providers/codex/client.rsindex 16ee556..19049f3 100644--- a/src/providers/codex/client.rs+++ b/src/providers/codex/client.rs@@ -1,8 +1,10 @@-use std::time::Duration;+use std::time::{Duration, Instant};+use crate::anthropic::sse::parse_sse_events;use crate::config;use crate::provider::RequestContext;use crate::retry::{compute_backoff_delay, sleep};+use crate::traffic::TrafficCapture;use super::auth::constants::{CODEX_API_ENDPOINT, ORIGINATOR};use super::auth::manager::CodexAuthManager;@@ -301,7 +303,7 @@ impl CodexHttpClient {&ws_headers,&ws_body,ctx,- None, // traffic capture+ ctx.traffic.as_deref(),pool_key,super::websocket::WEBSOCKET_CONNECT_TIMEOUT_MS,super::websocket::WEBSOCKET_IDLE_TIMEOUT_MS,@@ -325,7 +327,7 @@ impl CodexHttpClient {&ws_headers,&ws_body,ctx,- None,+ ctx.traffic.as_deref(),pool_key,super::websocket::WEBSOCKET_CONNECT_TIMEOUT_MS,super::websocket::WEBSOCKET_IDLE_TIMEOUT_MS,@@ -436,7 +438,7 @@ impl CodexHttpClient {&ws_retry_headers,&ws_retry_body,ctx,- None,+ ctx.traffic.as_deref(),None,super::websocket::WEBSOCKET_CONNECT_TIMEOUT_MS,super::websocket::WEBSOCKET_IDLE_TIMEOUT_MS,@@ -475,34 +477,20 @@ impl CodexHttpClient {ctx: &RequestContext,) -> Result<CodexResponse, CodexError> {let url = &self.base_url;+ let headers = build_codex_headers(auth, ctx)?;- // Build headers- let mut req_builder = self- .client- .post(url)- .header("Content-Type", "application/json")- .header("Accept", "text/event-stream")- .header("Authorization", format!("Bearer {}", auth.access))- .header("originator", config::codex_originator(ORIGINATOR))- .header("openai-beta", "responses=experimental");-- if let Some(ref account_id) = auth.account_id {- req_builder = req_builder.header("ChatGPT-Account-Id", account_id);- }- if let Some(ref session_id) = ctx.session_id {- req_builder = req_builder- .header("session_id", session_id)- .header("x-client-request-id", session_id)- .header("x-codex-window-id", format!("{session_id}:0"));+ if let Some(traffic) = ctx.traffic.as_deref() {+ write_codex_http_request_capture(traffic, url, &headers, body_json);}- let user_agent =- config::codex_user_agent(&format!("claude-code-proxy/{}", env!("CARGO_PKG_VERSION")));- if !user_agent.is_empty() {- req_builder = req_builder.header("User-Agent", user_agent);+ // Build headers+ let mut req_builder = self.client.post(url);+ for (key, value) in headers.iter() {+ req_builder = req_builder.header(key.as_str(), value.as_bytes());}// Apply header timeout+ let started_at = Instant::now();let send_fut = req_builder.body(body_json.to_string()).send();let header_timeout_dur = Duration::from_millis(self.header_timeout_ms);@@ -547,6 +535,16 @@ impl CodexHttpClient {let body_bytes = resp.bytes().await.unwrap_or_default().to_vec();+ if let Some(traffic) = ctx.traffic.as_deref() {+ write_upstream_response_capture(+ traffic,+ status,+ started_at.elapsed(),+ &headers,+ &body_bytes,+ );+ }+Ok(CodexResponse {body: body_bytes,status,@@ -555,6 +553,124 @@ impl CodexHttpClient {}}+fn write_codex_http_request_capture(+ traffic: &TrafficCapture,+ url: &str,+ headers: &http::HeaderMap,+ body_json: &str,+) {+ let body = serde_json::from_str(body_json).unwrap_or_else(|_| {+ serde_json::json!({+ "unparseable": true,+ "bytes": body_json.len(),+ })+ });+ traffic.write_json("020-upstream-request", &body);+ traffic.write_json(+ "021-upstream-request-metadata",+ &serde_json::json!({+ "provider": "codex",+ "transport": "http",+ "url": url,+ "method": "POST",+ "headers": headers_to_json(headers),+ "size": summarize_json_request_size(&body, body_json),+ }),+ );+}++fn write_upstream_response_capture(+ traffic: &TrafficCapture,+ status: u16,+ elapsed: Duration,+ headers: &[(String, String)],+ body: &[u8],+) {+ traffic.write_json(+ "030-upstream-response-headers",+ &serde_json::json!({+ "status": status,+ "elapsedMs": elapsed.as_millis(),+ "headers": headers_to_json_from_pairs(headers),+ }),+ );+ if status >= 400 {+ traffic.write_text("031-upstream-error-body", &String::from_utf8_lossy(body));+ } else {+ traffic.write_bytes("032-upstream-response-body.sse", body);+ write_codex_sse_event_capture(traffic, body);+ }+}++fn write_codex_sse_event_capture(traffic: &TrafficCapture, body: &[u8]) {+ for event in parse_sse_events(body) {+ if event.data == "[DONE]" {+ traffic.write_json_event(+ "040-upstream-event",+ &serde_json::json!({+ "event": event.event,+ "data": "[DONE]",+ }),+ );+ continue;+ }++ match serde_json::from_str::<serde_json::Value>(&event.data) {+ Ok(mut value) => {+ if let Some(name) = event.event+ && let Some(obj) = value.as_object_mut()+ {+ obj.entry("_sse_event").or_insert(serde_json::json!(name));+ }+ traffic.write_json_event("040-upstream-event", &value);+ }+ Err(_) => {+ traffic.write_json_event(+ "040-upstream-event",+ &serde_json::json!({+ "event": event.event,+ "unparseable": true,+ "data": event.data,+ }),+ );+ }+ }+ }+}++fn headers_to_json(headers: &http::HeaderMap) -> serde_json::Value {+ let mut out = serde_json::Map::new();+ for (key, value) in headers.iter() {+ out.insert(+ key.to_string(),+ serde_json::Value::String(value.to_str().unwrap_or("").to_string()),+ );+ }+ serde_json::Value::Object(out)+}++fn headers_to_json_from_pairs(headers: &[(String, String)]) -> serde_json::Value {+ let mut out = serde_json::Map::new();+ for (key, value) in headers {+ out.insert(key.clone(), serde_json::Value::String(value.clone()));+ }+ serde_json::Value::Object(out)+}++fn summarize_json_request_size(body: &serde_json::Value, body_json: &str) -> serde_json::Value {+ serde_json::json!({+ "bytes": body_json.len(),+ "inputCount": body+ .get("input")+ .and_then(|v| v.as_array())+ .map(|items| items.len()),+ "toolCount": body+ .get("tools")+ .and_then(|v| v.as_array())+ .map(|items| items.len()),+ })+}+fn is_retryable_transport_error(err: &CodexError) -> bool {err.status == 0&& (err.message.contains("Timed out waiting")@@ -609,6 +725,7 @@ mod tests {session_id: Some("s".into()),session_seq: None,provider: "codex".into(),+ traffic: None,};let headers = build_codex_headers(&auth, &ctx).unwrap();assert_eq!(@@ -631,6 +748,7 @@ mod tests {session_id: None,session_seq: None,provider: "codex".into(),+ traffic: None,};let headers = build_codex_headers(&auth, &ctx).unwrap();assert!(headers.get("session_id").is_none());@@ -689,6 +807,7 @@ mod tests {session_id: None,session_seq: None,provider: "codex".into(),+ traffic: None,};let result = build_codex_headers(&auth, &ctx);assert!(diff --git a/src/providers/codex/mod.rs b/src/providers/codex/mod.rsindex ff6137e..7f1a2d7 100644--- a/src/providers/codex/mod.rs+++ b/src/providers/codex/mod.rs@@ -23,10 +23,11 @@ use self::auth::device::DeviceAuthClient;use self::auth::manager::CodexAuthManager;use self::auth::token_store::file_store;use self::client::CodexHttpClient;-use self::continuation::{clear_continuation, continuation_candidate};+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::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;@@ -130,6 +131,7 @@ impl Provider for CodexProvider {let sse_bytes = match translate_stream_bytes(&upstream.body, &message_id, model) {Ok(b) => b,Err(e) => {+ clear_continuation(ctx.session_id.as_deref());return json_error(StatusCode::BAD_GATEWAY,"api_error",@@ -137,6 +139,11 @@ impl Provider for CodexProvider {);}};+ update_continuation_from_upstream(+ ctx.session_id.as_deref(),+ &translated,+ &upstream.body,+ );let headers = [(http::header::CONTENT_TYPE, "text/event-stream"),@@ -146,12 +153,22 @@ impl Provider for CodexProvider {(headers, sse_bytes).into_response()} else {match accumulate_response(&upstream.body, &message_id, model) {- Ok(json) => (StatusCode::OK, Json(json)).into_response(),- Err(e) => json_error(- StatusCode::BAD_GATEWAY,- "api_error",- format!("Accumulation error: {e}"),- ),+ Ok(json) => {+ update_continuation_from_upstream(+ ctx.session_id.as_deref(),+ &translated,+ &upstream.body,+ );+ (StatusCode::OK, Json(json)).into_response()+ }+ Err(e) => {+ clear_continuation(ctx.session_id.as_deref());+ json_error(+ StatusCode::BAD_GATEWAY,+ "api_error",+ format!("Accumulation error: {e}"),+ )+ }}}}@@ -198,6 +215,24 @@ impl Provider for CodexProvider {}}+fn update_continuation_from_upstream(+ session_id: Option<&str>,+ request_body: &translate::request::ResponsesRequest,+ upstream_body: &[u8],+) {+ match finish_metadata_from_upstream(upstream_body) {+ Ok(Some(finish)) if finish.continuation_eligible => {+ record_continuation(+ session_id,+ request_body,+ finish.response_id.as_deref(),+ &finish.output_items,+ );+ }+ _ => clear_continuation(session_id),+ }+}+// ---------------------------------------------------------------------------// Error mapping// ---------------------------------------------------------------------------diff --git a/src/providers/codex/translate/reducer.rs b/src/providers/codex/translate/reducer.rsindex 02a0e83..0bc1541 100644--- a/src/providers/codex/translate/reducer.rs+++ b/src/providers/codex/translate/reducer.rs@@ -80,6 +80,32 @@ pub enum ReducerEvent {},}+#[derive(Debug, Clone)]+pub struct FinishMetadata {+ pub continuation_eligible: bool,+ pub response_id: Option<String>,+ pub output_items: Vec<ResponsesInputItem>,+}++pub fn finish_metadata_from_upstream(+ input: &[u8],+) -> Result<Option<FinishMetadata>, UpstreamStreamError> {+ let events = reduce_upstream_bytes(input)?;+ Ok(events.into_iter().rev().find_map(|event| match event {+ ReducerEvent::Finish {+ continuation_eligible,+ response_id,+ output_items,+ ..+ } => Some(FinishMetadata {+ continuation_eligible,+ response_id,+ output_items,+ }),+ _ => None,+ }))+}+pub fn reduce_upstream_bytes(input: &[u8]) -> Result<Vec<ReducerEvent>, UpstreamStreamError> {let sse_events = parse_sse_events(input);let mut out = Vec::new();@@ -971,6 +997,44 @@ mod tests {}}+ #[test]+ fn finish_metadata_extracts_continuation_state() {+ 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":"hello"+ })+ ),+ sse(+ "response.output_item.done",+ json!({+ "output_index":0,"item":{"type":"message"}+ })+ ),+ sse(+ "response.completed",+ json!({+ "response":{"id":"resp_1","usage":{}}+ })+ ),+ );+ let metadata = finish_metadata_from_upstream(upstream.as_bytes())+ .unwrap()+ .unwrap();+ assert!(metadata.continuation_eligible);+ assert_eq!(metadata.response_id.as_deref(), Some("resp_1"));+ assert_eq!(metadata.output_items.len(), 1);+ }+#[test]fn sanitize_tool_args_removes_empty_pages() {let args = r#"{"file_path":"/tmp/a","pages":""}"#;diff --git a/src/providers/codex/websocket.rs b/src/providers/codex/websocket.rsindex c28145f..88dbdd1 100644--- a/src/providers/codex/websocket.rs+++ b/src/providers/codex/websocket.rs@@ -1,6 +1,6 @@use std::collections::HashMap;use std::sync::{Arc, Mutex};-use std::time::Duration;+use std::time::{Duration, Instant};use futures_util::{SinkExt, StreamExt};use http::HeaderMap;@@ -260,6 +260,31 @@ pub async fn codex_websocket_request(retry_after: None,origin: CodexErrorOrigin::WebSocket,})?;+ let body_json = serde_json::to_string(body_value).unwrap_or_default();+ if let Some(tc) = traffic {+ 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()),+ },+ }),+ );+ }+ let started_at = Instant::now();// Check pool for existing connectionlet pooled = pool_key.and_then(|key| {@@ -277,7 +302,7 @@ pub async fn codex_websocket_request(connect_with_timeout(&ws_url, headers, connect_timeout_ms).await?} else {// Connection is alive, send the request through it- let ws_msg = Message::Text(serde_json::to_string(body_value).unwrap_or_default());+ let ws_msg = Message::Text(body_json.clone());ws_guard.send(ws_msg).await.map_err(|e| CodexError {status: 0,message: format!("WebSocket send error: {e}"),@@ -288,7 +313,7 @@ pub async fn codex_websocket_request(// Collect eventslet (sse_body, terminal_event) =- collect_ws_events(&mut ws_guard, idle_timeout_ms, pool_key).await?;+ collect_ws_events(&mut ws_guard, idle_timeout_ms, pool_key, traffic).await?;// Record continuation on successif let Some(terminal) = &terminal_event@@ -326,14 +351,8 @@ pub async fn codex_websocket_request(// Write traffic metadataif let Some(tc) = traffic {- let meta = serde_json::json!({- "provider": "codex",- "transport": "websocket",- "url": ws_url,- "poolKey": pool_key,- "continuation": continuation.map(|c| c.previous_response_id.is_some()),- });- tc.write_json("022-upstream-websocket-metadata", &meta);+ write_websocket_metadata_capture(tc, &ws_url, pool_key, continuation, true);+ write_websocket_response_capture(tc, status, started_at.elapsed(), &sse_body);}return Ok(CodexResponse {@@ -353,7 +372,7 @@ pub async fn codex_websocket_request(});// Send the request- let msg = Message::Text(serde_json::to_string(body_value).unwrap_or_default());+ let msg = Message::Text(body_json);{let mut ws_guard = entry.ws.lock().await;ws_guard.send(msg).await.map_err(|e| CodexError {@@ -365,7 +384,7 @@ pub async fn codex_websocket_request(})?;let (sse_body, terminal_event) =- collect_ws_events(&mut ws_guard, idle_timeout_ms, pool_key).await?;+ collect_ws_events(&mut ws_guard, idle_timeout_ms, pool_key, traffic).await?;if let Some(terminal) = &terminal_event&& is_previous_response_missing(&terminal.payload)@@ -405,14 +424,8 @@ pub async fn codex_websocket_request(// Write traffic metadataif let Some(tc) = traffic {- let meta = serde_json::json!({- "provider": "codex",- "transport": "websocket",- "url": ws_url,- "poolKey": pool_key,- "continuation": continuation.map(|c| c.previous_response_id.is_some()),- });- tc.write_json("022-upstream-websocket-metadata", &meta);+ write_websocket_metadata_capture(tc, &ws_url, pool_key, continuation, false);+ write_websocket_response_capture(tc, status, started_at.elapsed(), &sse_body);}Ok(CodexResponse {@@ -423,6 +436,60 @@ pub async fn codex_websocket_request(}}+fn write_websocket_metadata_capture(+ traffic: &TrafficCapture,+ ws_url: &str,+ pool_key: Option<&str>,+ continuation: Option<&ContinuationCandidate>,+ pooled: bool,+) {+ traffic.write_json(+ "022-upstream-websocket-metadata",+ &serde_json::json!({+ "provider": "codex",+ "transport": "websocket",+ "url": ws_url,+ "poolKey": pool_key,+ "pooled": pooled,+ "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()),+ },+ }),+ );+}++fn write_websocket_response_capture(+ traffic: &TrafficCapture,+ status: u16,+ elapsed: Duration,+ sse_body: &[u8],+) {+ traffic.write_json(+ "030-upstream-response-headers",+ &serde_json::json!({+ "status": status,+ "elapsedMs": elapsed.as_millis(),+ "headers": {+ "content-type": "text/event-stream",+ },+ }),+ );+ if status >= 400 {+ traffic.write_text(+ "031-upstream-error-body",+ &String::from_utf8_lossy(sse_body),+ );+ } else {+ traffic.write_bytes("032-upstream-response-body.sse", sse_body);+ }+}+// ---------------------------------------------------------------------------// Connection helper// ---------------------------------------------------------------------------@@ -521,6 +588,7 @@ async fn collect_ws_events(ws: &mut WebSocketStream<MaybeTlsStream<TcpStream>>,idle_timeout_ms: u64,pool_key: Option<&str>,+ traffic: Option<&TrafficCapture>,) -> Result<(Vec<u8>, Option<WsEvent>), CodexError> {let mut sse_body: Vec<u8> = Vec::new();let mut terminal_event: Option<WsEvent> = None;@@ -548,6 +616,15 @@ async fn collect_ws_events(let parsed: serde_json::Value = match serde_json::from_str(&text) {Ok(v) => v,Err(_) => {+ if let Some(tc) = traffic {+ tc.write_json_event(+ "040-upstream-event",+ &serde_json::json!({+ "unparseable": true,+ "data": text,+ }),+ );+ }// Write invalid JSON as-issse_body.extend_from_slice(&encode_sse(&text));continue;@@ -556,6 +633,9 @@ async fn collect_ws_events(// Convert to SSE bytessse_body.extend_from_slice(&encode_sse(&text));+ if let Some(tc) = traffic {+ tc.write_json_event("040-upstream-event", &parsed);+ }// Check for terminal eventsif is_terminal_event(&parsed) {@@ -625,6 +705,31 @@ async fn collect_ws_events(Ok((sse_body, terminal_event))}+fn headers_to_json(headers: &HeaderMap) -> serde_json::Value {+ let mut out = serde_json::Map::new();+ for (key, value) in headers.iter() {+ out.insert(+ key.to_string(),+ serde_json::Value::String(value.to_str().unwrap_or("").to_string()),+ );+ }+ serde_json::Value::Object(out)+}++fn summarize_json_request_size(body: &serde_json::Value, body_json: &str) -> serde_json::Value {+ serde_json::json!({+ "bytes": body_json.len(),+ "inputCount": body+ .get("input")+ .and_then(|v| v.as_array())+ .map(|items| items.len()),+ "toolCount": body+ .get("tools")+ .and_then(|v| v.as_array())+ .map(|items| items.len()),+ })+}+// ---------------------------------------------------------------------------// Tests// ---------------------------------------------------------------------------diff --git a/src/server.rs b/src/server.rsindex 9b5f537..8bf57c1 100644--- a/src/server.rs+++ b/src/server.rs@@ -132,13 +132,16 @@ async fn dispatch_request(now,);- if let Some(capture) = create_traffic_capture(TrafficCaptureOptions {+ let traffic = create_traffic_capture(TrafficCaptureOptions {req_id: req_id.clone(),session_id: session_id.clone(),session_seq: current.as_ref().map(|s| s.seq),provider: Some(provider.name().to_string()),state_dir_override: None,- }) {+ })+ .map(Arc::new);++ if let Some(capture) = traffic.as_ref() {capture.write_json("000-metadata",&json!({@@ -160,6 +163,7 @@ async fn dispatch_request(session_id,session_seq: current.map(|s| s.seq),provider: provider.name().to_string(),+ traffic,};if count_tokens {diff --git a/src/traffic.rs b/src/traffic.rsindex dd9fdb6..7b875cd 100644--- a/src/traffic.rs+++ b/src/traffic.rs@@ -76,7 +76,7 @@ impl TrafficCapture {}pub fn write_bytes(&self, name: &str, value: &[u8]) {- let path = self.next_artifact_path(name, true);+ let path = self.next_artifact_path(name, false);let _ = write_bytes(path, value);}diff --git a/tests/cursor_native.rs b/tests/cursor_native.rsindex 8074be9..9c79385 100644--- a/tests/cursor_native.rs+++ b/tests/cursor_native.rs@@ -682,6 +682,7 @@ async fn cursor_provider_handle_messages_returns_anthropic_json() {session_id: None,session_seq: None,provider: "cursor".into(),+ traffic: None,};let response = provider.handle_messages(body, ctx).await;diff --git a/tests/smoke_cutover.rs b/tests/smoke_cutover.rsindex 1d12cf4..0870a8e 100644--- a/tests/smoke_cutover.rs+++ b/tests/smoke_cutover.rs@@ -4,10 +4,12 @@use axum::body::Body;use axum::http::{Method, Request, StatusCode};use axum::response::Response;+use claude_code_proxy::providers::codex::continuation::clear_all_continuations_for_tests;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 serde_json::{Value, json};+use std::path::{Path, PathBuf};use std::sync::{Arc, Mutex, OnceLock};use tempfile::TempDir;use tokio::net::TcpListener;@@ -71,6 +73,15 @@ impl Drop for EnvGuard {/// Send a minimal `POST /v1/messages` through the in-process app.async fn call_messages(model: &str) -> Response {+ call_messages_body(json!({+ "model": model,+ "max_tokens": 64,+ "messages": [{"role":"user","content":"hello"}]+ }))+ .await+}++async fn call_messages_body(body: Value) -> Response {app(Arc::new(Registry::with_default_alias())).oneshot(Request::builder()@@ -78,20 +89,54 @@ async fn call_messages(model: &str) -> Response {.uri("/v1/messages").header("content-type", "application/json").header("x-claude-code-session-id", "smoke-session")- .body(Body::from(- json!({- "model": model,- "max_tokens": 64,- "messages": [{"role":"user","content":"hello"}]- })- .to_string(),- ))+ .body(Body::from(body.to_string())).unwrap(),).await.unwrap()}+fn collect_files(root: &Path) -> Vec<PathBuf> {+ let mut out = Vec::new();+ let Ok(entries) = std::fs::read_dir(root) else {+ return out;+ };+ for entry in entries.flatten() {+ let path = entry.path();+ if path.is_dir() {+ out.extend(collect_files(&path));+ } else {+ out.push(path);+ }+ }+ out+}++fn traffic_files(state_dir: &Path) -> Vec<PathBuf> {+ collect_files(+ &state_dir+ .join("claude-code-proxy")+ .join("traffic")+ .join("smoke-session"),+ )+}++fn traffic_file<'a>(files: &'a [PathBuf], suffix: &str) -> &'a Path {+ files+ .iter()+ .find(|path| {+ path.file_name()+ .and_then(|name| name.to_str())+ .is_some_and(|name| name.ends_with(suffix))+ })+ .map(PathBuf::as_path)+ .unwrap_or_else(|| panic!("missing traffic artifact ending in {suffix}; files={files:?}"))+}++fn traffic_json(files: &[PathBuf], suffix: &str) -> Value {+ serde_json::from_slice(&std::fs::read(traffic_file(files, suffix)).unwrap()).unwrap()+}+/// Spawn a mock axum HTTP server that accepts requests at any path, calls/// `handler(request_json)` and returns the handler's response body as a 200/// with `content-type: text/event-stream`.@@ -165,6 +210,59 @@ async fn spawn_websocket_upstream(captured: Arc<Mutex<Option<Value>>>) -> Stringaddr_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();+ let addr_str = format!("http://{addr}");++ tokio::spawn(async move {+ for (idx, text) in ["first", "second"].iter().enumerate() {+ 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();++ if let Some(Ok(Message::Text(text))) = receiver.next().await+ && let Ok(json) = serde_json::from_str::<Value>(&text)+ {+ let _ = captured.lock().map(|mut g| g.push(json));+ }++ let response_id = format!("resp_{}", idx + 1);+ let events = [+ json!({+ "type":"response.output_item.added",+ "output_index":0,+ "item":{"type":"message","id":format!("msg_up_{idx}")}+ }),+ json!({+ "type":"response.output_text.delta",+ "output_index":0,+ "delta":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;+ }+ }+ });++ addr_str+}+// ---------------------------------------------------------------------------// Health and routing smoke tests (no env var mutation needed)// ---------------------------------------------------------------------------@@ -315,6 +413,53 @@ async fn smoke_codex_http_messages_uses_mock_upstream() {assert_eq!(sent["stream"], true);}+#[allow(clippy::await_holding_lock)]+#[tokio::test]+async fn smoke_codex_http_traffic_capture_writes_upstream_artifacts() {+ 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 http ok\"}\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("gpt-5.5").await;++ assert_eq!(response.status(), StatusCode::OK);+ let files = traffic_files(state.path());+ let request = traffic_json(&files, "020-upstream-request.json");+ assert_eq!(request["model"], "gpt-5.5");++ let metadata = traffic_json(&files, "021-upstream-request-metadata.json");+ assert_eq!(metadata["transport"], "http");+ assert!(+ metadata["headers"]["authorization"]+ .as_str()+ .unwrap()+ .contains("redacted")+ );+ assert_eq!(+ traffic_json(&files, "030-upstream-response-headers.json")["status"],+ 200+ );+ traffic_file(&files, "032-upstream-response-body.sse");+ traffic_file(&files, "040-upstream-event.json");+}+// ---------------------------------------------------------------------------// Codex WebSocket smoke: mock upstream verifies request shape and returns// Responses events over WebSocket.@@ -365,3 +510,105 @@ async fn smoke_codex_websocket_messages_uses_mock_upstream() {assert_eq!(sent["model"], "gpt-5.5");assert!(sent.get("stream").is_none());}++#[allow(clippy::await_holding_lock)]+#[tokio::test(flavor = "multi_thread")]+async fn smoke_codex_websocket_previous_response_id_sends_delta_on_second_turn() {+ let _guard = env_lock();+ let config = 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_sequence_upstream(captured.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 _previous_response_env = EnvGuard::set("CCP_CODEX_PREVIOUS_RESPONSE_ID", "1");++ let first = call_messages_body(json!({+ "model": "gpt-5.5",+ "max_tokens": 64,+ "messages": [{"role":"user","content":"one"}]+ }))+ .await;+ assert_eq!(first.status(), StatusCode::OK);++ let second = call_messages_body(json!({+ "model": "gpt-5.5",+ "max_tokens": 64,+ "messages": [+ {"role":"user","content":"one"},+ {"role":"assistant","content":"first"},+ {"role":"user","content":"two"}+ ]+ }))+ .await;+ assert_eq!(second.status(), StatusCode::OK);+ let value: Value = serde_json::from_slice(+ &axum::body::to_bytes(second.into_body(), usize::MAX)+ .await+ .unwrap(),+ )+ .unwrap();+ assert_eq!(value["content"][0]["text"], "second");++ let guard = captured.lock().unwrap();+ assert_eq!(guard.len(), 2, "expected two upstream websocket requests");+ assert!(guard[0].get("previous_response_id").is_none());+ assert_eq!(guard[1]["previous_response_id"], "resp_1");+ assert_eq!(+ guard[1]["input"].as_array().map(Vec::len),+ Some(1),+ "second request should send only the appended input delta"+ );+ assert_eq!(guard[1]["input"][0]["role"], "user");+ assert_eq!(guard[1]["input"][0]["content"][0]["text"], "two");++ 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_traffic_capture_writes_upstream_artifacts() {+ 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();++ let captured = Arc::new(Mutex::new(None));+ let upstream = spawn_websocket_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 response = call_messages("gpt-5.5").await;++ assert_eq!(response.status(), StatusCode::OK);+ let files = traffic_files(state.path());+ let request = traffic_json(&files, "020-upstream-request.json");+ assert_eq!(request["type"], "response.create");+ assert!(request.get("stream").is_none());++ let metadata = traffic_json(&files, "021-upstream-request-metadata.json");+ assert_eq!(metadata["transport"], "websocket");+ assert!(+ metadata["headers"]["authorization"]+ .as_str()+ .unwrap()+ .contains("redacted")+ );+ traffic_file(&files, "022-upstream-websocket-metadata.json");+ assert_eq!(+ traffic_json(&files, "030-upstream-response-headers.json")["status"],+ 200+ );+ traffic_file(&files, "032-upstream-response-body.sse");+ traffic_file(&files, "040-upstream-event.json");+}