Skip to content

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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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 connection
let 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 events
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?;
// Record continuation on success
if let Some(terminal) = &terminal_event
@@ -326,14 +351,8 @@ pub async fn codex_websocket_request(
// Write traffic metadata
if 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 metadata
if 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-is
sse_body.extend_from_slice(&encode_sse(&text));
continue;
@@ -556,6 +633,9 @@ async fn collect_ws_events(
// Convert to SSE bytes
sse_body.extend_from_slice(&encode_sse(&text));
+ if let Some(tc) = traffic {
+ tc.write_json_event("040-upstream-event", &parsed);
+ }
// Check for terminal events
if 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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>>>) -> String
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();
+ 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");
+}