Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy
Rust
// End-to-end tests for local server health, provider routing, Kimi, Codex HTTP,
// and Codex WebSocket through in-process mock upstreams with isolated auth.
use axum::body::Body;
use axum::http::{Method, Request, StatusCode};
use axum::response::Response;
use claude_code_proxy::providers::codex::compaction::clear_all_compactions_for_tests;
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, app_with_options},
};
use futures_util::{SinkExt, StreamExt};
use http_body_util::BodyExt;
use serde_json::{Value, json};
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::{Arc, Mutex, OnceLock};
use std::time::Duration;
use tempfile::TempDir;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpListener;
use tokio_tungstenite::tungstenite::Message;
use tower::util::ServiceExt;
// ---------------------------------------------------------------------------
// Helpers
// ---------------------------------------------------------------------------
static ENV_LOCK: OnceLock<Mutex<()>> = OnceLock::new();
/// Serialize all env-var-mutating tests so they never run concurrently.
fn env_lock() -> std::sync::MutexGuard<'static, ()> {
// Recover from a poisoned mutex so a failing test doesn't cascade
let m = ENV_LOCK.get_or_init(|| Mutex::new(()));
match m.lock() {
Ok(guard) => guard,
Err(poisoned) => poisoned.into_inner(),
}
}
/// Write a valid auth.json for `provider` under `config_dir`.
fn write_auth(config_dir: &std::path::Path, provider: &str) {
let dir = config_dir.join(provider);
std::fs::create_dir_all(&dir).unwrap();
let expires: i64 = 4102444800000;
let auth = if provider == "codex" {
json!({"access":"test-access","refresh":"test-refresh","expires":expires,"account_id":"acct_test"})
} else {
json!({"access":"test-access","refresh":"test-refresh","expires":expires,"scope":"openid","userId":"user_test"})
};
std::fs::write(dir.join("auth.json"), serde_json::to_vec(&auth).unwrap()).unwrap();
}
struct EnvGuard {
key: &'static str,
previous: Option<std::ffi::OsString>,
}
impl EnvGuard {
fn set(key: &'static str, value: impl AsRef<std::ffi::OsStr>) -> Self {
let previous = std::env::var_os(key);
unsafe {
std::env::set_var(key, value);
}
Self { key, previous }
}
}
impl Drop for EnvGuard {
fn drop(&mut self) {
unsafe {
match self.previous.take() {
Some(value) => std::env::set_var(self.key, value),
None => std::env::remove_var(self.key),
}
}
}
}
/// 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 {
let _no_proxy_env = EnvGuard::set("NO_PROXY", "127.0.0.1,localhost");
app(Arc::new(Registry::with_default_alias()))
.oneshot(
Request::builder()
.method(Method::POST)
.uri("/v1/messages")
.header("content-type", "application/json")
.header("x-claude-code-session-id", "smoke-session")
.body(Body::from(body.to_string()))
.unwrap(),
)
.await
.unwrap()
}
async fn call_responses_body(body: Value) -> Response {
let _no_proxy_env = EnvGuard::set("NO_PROXY", "127.0.0.1,localhost");
app_with_options(Arc::new(Registry::with_default_alias()), None, true)
.oneshot(
Request::builder()
.method(Method::POST)
.uri("/v1/responses")
.header("content-type", "application/json")
.header("x-claude-code-session-id", "smoke-session")
.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`.
async fn spawn_http_upstream<F>(handler: F) -> String
where
F: Fn(Value) -> Vec<u8> + Send + Sync + 'static,
{
let handler = Arc::new(handler);
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
let addr_str = format!("http://{addr}");
let app = axum::Router::new().fallback({
let handler = handler.clone();
move |body: String| {
let handler = handler.clone();
async move {
let json: Value = serde_json::from_str(&body).unwrap_or_default();
let response_bytes = handler(json);
http::Response::builder()
.status(StatusCode::OK)
.header("content-type", "text/event-stream")
.body(Body::from(response_bytes))
.unwrap()
}
}
});
tokio::spawn(async move {
axum::serve(listener, app).await.ok();
});
addr_str
}
async fn spawn_auto_fallback_usage_limit_upstream(
websocket_attempts: Arc<AtomicUsize>,
http_attempts: Arc<AtomicUsize>,
) -> String {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
let app = axum::Router::new().fallback(move |request: axum::extract::Request| {
let websocket_attempts = websocket_attempts.clone();
let http_attempts = http_attempts.clone();
async move {
if request.headers().contains_key(http::header::UPGRADE) {
websocket_attempts.fetch_add(1, Ordering::SeqCst);
http::Response::builder()
.status(StatusCode::BAD_REQUEST)
.body(Body::empty())
.unwrap()
} else {
http_attempts.fetch_add(1, Ordering::SeqCst);
http::Response::builder()
.status(StatusCode::OK)
.header("content-type", "text/event-stream")
.header("x-codex-primary-reset-after-seconds", "90")
.header("x-codex-primary-reset-at", "1788879437")
.header("x-codex-primary-window-minutes", "300")
.body(Body::from(codex_header_only_usage_limit_sse()))
.unwrap()
}
}
});
tokio::spawn(async move {
axum::serve(listener, app).await.ok();
});
format!("http://{addr}")
}
async fn spawn_truncated_http_upstream(body: &'static [u8]) -> String {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
tokio::spawn(async move {
let Ok((mut stream, _)) = listener.accept().await else {
return;
};
let mut request = [0_u8; 8192];
let _ = stream.read(&mut request).await;
let headers = format!(
"HTTP/1.1 200 OK\r\ncontent-type: text/event-stream\r\ncontent-length: {}\r\nconnection: close\r\n\r\n",
body.len() + 4096
);
let _ = stream.write_all(headers.as_bytes()).await;
let _ = stream.write_all(body).await;
let _ = stream.shutdown().await;
});
format!("http://{addr}")
}
async fn spawn_retrying_truncated_http_upstream(
first_body: Vec<u8>,
success_body: Vec<u8>,
attempts: Arc<AtomicUsize>,
) -> String {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
tokio::spawn(async move {
for attempt in 0..2 {
let Ok((mut stream, _)) = listener.accept().await else {
return;
};
let mut request = [0_u8; 8192];
let _ = stream.read(&mut request).await;
attempts.fetch_add(1, Ordering::SeqCst);
let body = if attempt == 0 {
first_body.as_slice()
} else {
success_body.as_slice()
};
let content_length = if attempt == 0 {
body.len() + 4096
} else {
body.len()
};
let headers = format!(
"HTTP/1.1 200 OK\r\ncontent-type: text/event-stream\r\ncontent-length: {content_length}\r\nconnection: close\r\n\r\n"
);
let _ = stream.write_all(headers.as_bytes()).await;
let _ = stream.write_all(body).await;
let _ = stream.shutdown().await;
}
});
format!("http://{addr}")
}
#[allow(clippy::await_holding_lock)]
async fn assert_codex_http_retries_structural_body_error(first_body: Vec<u8>) {
let _guard = env_lock();
clear_all_continuations_for_tests();
let config = TempDir::new().unwrap();
write_auth(config.path(), "codex");
let attempts = Arc::new(AtomicUsize::new(0));
let success_body = concat!(
"data: {\"type\":\"response.created\",\"response\":{\"id\":\"resp_retry\"}}\n\n",
"data: {\"type\":\"response.output_item.added\",\"output_index\":0,\"item\":{\"type\":\"message\",\"id\":\"msg_retry\"}}\n\n",
"data: {\"type\":\"response.output_text.delta\",\"output_index\":0,\"delta\":\"retry succeeded\"}\n\n",
"data: {\"type\":\"response.output_item.done\",\"output_index\":0,\"item\":{\"type\":\"message\"}}\n\n",
"data: {\"type\":\"response.completed\",\"response\":{\"id\":\"resp_retry\",\"status\":\"completed\",\"usage\":{\"input_tokens\":5,\"output_tokens\":2}}}\n\n"
)
.as_bytes()
.to_vec();
let upstream =
spawn_retrying_truncated_http_upstream(first_body, success_body, attempts.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", "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 = tokio::time::timeout(
Duration::from_secs(2),
axum::body::to_bytes(response.into_body(), usize::MAX),
)
.await
.expect("retried stream must finish")
.unwrap();
let text = String::from_utf8_lossy(&body);
assert_eq!(attempts.load(Ordering::SeqCst), 2, "stream body: {text}");
assert!(text.contains("retry succeeded"), "stream body: {text}");
assert!(!text.contains("event: error"), "stream body: {text}");
assert_eq!(text.matches("event: message_start").count(), 1);
assert_eq!(text.matches("event: message_stop").count(), 1);
}
#[allow(clippy::await_holding_lock)]
async fn assert_codex_http_presemantic_retry(first_response: Vec<u8>) {
let _guard = env_lock();
clear_all_continuations_for_tests();
let config = TempDir::new().unwrap();
write_auth(config.path(), "codex");
let attempts = Arc::new(AtomicUsize::new(0));
let first_response = Arc::new(first_response);
let upstream = spawn_http_upstream({
let attempts = attempts.clone();
let first_response = first_response.clone();
move |_body: Value| {
if attempts.fetch_add(1, Ordering::SeqCst) == 0 {
first_response.as_ref().clone()
} else {
concat!(
"data: {\"type\":\"response.created\",\"response\":{\"id\":\"resp_retry\"}}\n\n",
"data: {\"type\":\"response.output_item.added\",\"output_index\":0,\"item\":{\"type\":\"message\",\"id\":\"msg_retry\"}}\n\n",
"data: {\"type\":\"response.output_text.delta\",\"output_index\":0,\"delta\":\"retry succeeded\"}\n\n",
"data: {\"type\":\"response.output_item.done\",\"output_index\":0,\"item\":{\"type\":\"message\"}}\n\n",
"data: {\"type\":\"response.completed\",\"response\":{\"id\":\"resp_retry\",\"status\":\"completed\",\"usage\":{\"input_tokens\":5,\"output_tokens\":2}}}\n\n"
)
.as_bytes()
.to_vec()
}
}
})
.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", "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 = tokio::time::timeout(
Duration::from_secs(2),
axum::body::to_bytes(response.into_body(), usize::MAX),
)
.await
.expect("retried stream must finish")
.unwrap();
let text = String::from_utf8_lossy(&body);
assert_eq!(attempts.load(Ordering::SeqCst), 2, "stream body: {text}");
assert!(text.contains("retry succeeded"), "stream body: {text}");
assert!(!text.contains("event: error"), "stream body: {text}");
assert_eq!(text.matches("event: message_start").count(), 1);
assert_eq!(text.matches("event: message_stop").count(), 1);
}
/// Spawn a mock WebSocket server that accepts one connection, captures the
/// first text message, and responds with Codex WebSocket events that
/// accumulate to `"codex websocket ok"`.
async fn spawn_websocket_upstream(captured: Arc<Mutex<Option<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 {
if let Ok((stream, _)) = listener.accept().await
&& let Ok(ws) = tokio_tungstenite::accept_async(stream).await
{
let (mut sender, mut receiver) = ws.split();
// Read the incoming response.create message
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 = Some(json));
}
// Send Codex Responses events as WebSocket text messages
let events = [
r#"{"type":"response.output_item.added","output_index":0,"item":{"type":"message","id":"msg_up"}}"#,
r#"{"type":"response.output_text.delta","output_index":0,"delta":"codex websocket ok"}"#,
r#"{"type":"response.output_item.done","output_index":0,"item":{"type":"message"}}"#,
r#"{"type":"response.completed","response":{"id":"resp_1","usage":{"input_tokens":5,"output_tokens":2}}}"#,
];
for event in &events {
let _ = sender.send(Message::Text(event.to_string())).await;
}
}
});
addr_str
}
async fn spawn_websocket_usage_limit_upstream(attempts: Arc<AtomicUsize>) -> String {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
tokio::spawn(async move {
if let Ok((stream, _)) = listener.accept().await
&& let Ok(mut websocket) = tokio_tungstenite::accept_async(stream).await
{
let _ = websocket.next().await;
attempts.fetch_add(1, Ordering::SeqCst);
let event = codex_usage_limit_event("usage_limit_reached");
let _ = websocket.send(Message::Text(event.to_string())).await;
}
});
format!("http://{addr}")
}
/// Reproduce the Codex subscription-credit response observed in production:
/// the included window is exhausted, but usable credits remain and the model
/// still completes the response after the rate-limit snapshot.
async fn spawn_websocket_credited_rate_limit_upstream() -> 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 {
if let Ok((stream, _)) = listener.accept().await
&& let Ok(mut ws) = tokio_tungstenite::accept_async(stream).await
{
let _ = ws.next().await;
let events = [
r#"{"type":"codex.rate_limits","rate_limits":{"allowed":false,"limit_reached":true,"primary":{"used_percent":100,"window_minutes":10080,"reset_after_seconds":509821}},"credits":{"has_credits":true,"unlimited":false,"balance":null}}"#,
r#"{"type":"response.output_item.added","output_index":0,"item":{"type":"message","id":"msg_up"}}"#,
r#"{"type":"response.output_text.delta","output_index":0,"delta":"credited codex ok"}"#,
r#"{"type":"response.output_item.done","output_index":0,"item":{"type":"message"}}"#,
r#"{"type":"response.completed","response":{"id":"resp_1","usage":{"input_tokens":5,"output_tokens":2}}}"#,
];
for event in &events {
let _ = ws.send(Message::Text(event.to_string())).await;
}
}
});
addr_str
}
async fn spawn_websocket_delayed_terminal_upstream() -> 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 {
if let Ok((stream, _)) = listener.accept().await
&& let Ok(mut ws) = tokio_tungstenite::accept_async(stream).await
{
let _ = ws.next().await;
let early_events = [
r#"{"type":"response.output_item.added","output_index":0,"item":{"type":"message","id":"msg_up"}}"#,
r#"{"type":"response.output_text.delta","output_index":0,"delta":"early chunk"}"#,
];
for event in &early_events {
let _ = ws.send(Message::Text(event.to_string())).await;
}
tokio::time::sleep(Duration::from_secs(2)).await;
let terminal_events = [
r#"{"type":"response.output_item.done","output_index":0,"item":{"type":"message"}}"#,
r#"{"type":"response.completed","response":{"id":"resp_1","usage":{"input_tokens":5,"output_tokens":2}}}"#,
];
for event in &terminal_events {
let _ = ws.send(Message::Text(event.to_string())).await;
}
}
});
addr_str
}
async fn spawn_websocket_error_upstream(message: &'static str) -> 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 {
if let Ok((stream, _)) = listener.accept().await
&& let Ok(mut ws) = tokio_tungstenite::accept_async(stream).await
{
let _ = ws.next().await;
let event = json!({
"type": "error",
"status": 400,
"error": {
"type": "invalid_request_error",
"param": "input",
"message": message
}
});
let _ = ws.send(Message::Text(event.to_string())).await;
}
});
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 {
let texts = ["first", "second", "third"];
let mut handled = 0usize;
while handled < texts.len() {
let Ok((stream, _)) = listener.accept().await else {
return;
};
let Ok(ws) = tokio_tungstenite::accept_async(stream).await else {
return;
};
let (mut sender, mut receiver) = ws.split();
while handled < texts.len() {
let Some(text) = (loop {
match receiver.next().await {
Some(Ok(Message::Text(text))) => break Some(text),
Some(Ok(Message::Ping(data))) => {
let _ = sender.send(Message::Pong(data)).await;
}
Some(Ok(Message::Pong(_))) => {}
Some(Ok(_)) => {}
Some(Err(_)) | None => break None,
}
}) else {
break;
};
if let Ok(json) = serde_json::from_str::<Value>(&text) {
let _ = captured.lock().map(|mut g| g.push(json));
}
let idx = handled;
let response_text = texts[idx];
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":response_text
}),
json!({
"type":"response.output_item.done",
"output_index":0,
"item":{"type":"message"}
}),
json!({
"type":"response.completed",
"response":{"id":response_id,"usage":{"input_tokens":5,"output_tokens":2}}
}),
];
for event in &events {
let _ = sender.send(Message::Text(event.to_string())).await;
}
handled += 1;
}
}
});
addr_str
}
async fn spawn_websocket_previous_missing_then_retry_upstream(
captured: Arc<Mutex<Vec<Value>>>,
) -> String {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
let addr_str = format!("http://{addr}");
tokio::spawn(async move {
let mut handled = 0usize;
while handled < 3 {
let Ok((stream, _)) = listener.accept().await else {
return;
};
let Ok(ws) = tokio_tungstenite::accept_async(stream).await else {
return;
};
let (mut sender, mut receiver) = ws.split();
while handled < 3 {
let Some(text) = (loop {
match receiver.next().await {
Some(Ok(Message::Text(text))) => break Some(text),
Some(Ok(Message::Ping(data))) => {
let _ = sender.send(Message::Pong(data)).await;
}
Some(Ok(Message::Pong(_))) => {}
Some(Ok(_)) => {}
Some(Err(_)) | None => break None,
}
}) else {
break;
};
if let Ok(json) = serde_json::from_str::<Value>(&text) {
let _ = captured.lock().map(|mut g| g.push(json));
}
if handled == 1 {
let rate_limits = json!({
"type": "codex.rate_limits",
"rate_limits": {"limit_reached": false}
});
let _ = sender.send(Message::Text(rate_limits.to_string())).await;
let event = json!({
"type": "error",
"error": {
"code": "previous_response_not_found",
"message": "previous response not found",
"status": 400
}
});
let _ = sender.send(Message::Text(event.to_string())).await;
handled += 1;
break;
}
let response_text = if handled == 0 { "first" } else { "retry" };
let response_id = if handled == 0 { "resp_1" } else { "resp_retry" };
let events = [
json!({
"type":"response.output_item.added",
"output_index":0,
"item":{"type":"message","id":format!("msg_up_{handled}")}
}),
json!({
"type":"response.output_text.delta",
"output_index":0,
"delta":response_text
}),
json!({
"type":"response.output_item.done",
"output_index":0,
"item":{"type":"message"}
}),
json!({
"type":"response.completed",
"response":{"id":response_id,"usage":{"input_tokens":5,"output_tokens":2}}
}),
];
for event in &events {
let _ = sender.send(Message::Text(event.to_string())).await;
}
handled += 1;
}
}
});
addr_str
}
async fn spawn_websocket_close_then_retry_upstream(captured: Arc<Mutex<Vec<Value>>>) -> String {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
let addr_str = format!("http://{addr}");
tokio::spawn(async move {
let mut handled = 0usize;
while handled < 3 {
let Ok((stream, _)) = listener.accept().await else {
return;
};
let Ok(ws) = tokio_tungstenite::accept_async(stream).await else {
return;
};
let (mut sender, mut receiver) = ws.split();
while handled < 3 {
let Some(text) = (loop {
match receiver.next().await {
Some(Ok(Message::Text(text))) => break Some(text),
Some(Ok(Message::Ping(data))) => {
let _ = sender.send(Message::Pong(data)).await;
}
Some(Ok(Message::Pong(_))) => {}
Some(Ok(_)) => {}
Some(Err(_)) | None => break None,
}
}) else {
break;
};
if let Ok(json) = serde_json::from_str::<Value>(&text) {
let _ = captured.lock().map(|mut g| g.push(json));
}
if handled == 1 {
for event in [
json!({
"type": "response.created",
"response": {"id": "resp_aborted"}
}),
json!({
"type": "response.output_item.added",
"output_index": 0,
"item": {
"type": "function_call",
"call_id": "call_aborted",
"name": "Read"
}
}),
] {
let _ = sender.send(Message::Text(event.to_string())).await;
}
handled += 1;
let _ = sender.close().await;
break;
}
let response_text = if handled == 0 { "first" } else { "retry" };
let response_id = if handled == 0 { "resp_1" } else { "resp_retry" };
let events = [
json!({
"type":"response.output_item.added",
"output_index":0,
"item":{"type":"message","id":format!("msg_close_{handled}")}
}),
json!({
"type":"response.output_text.delta",
"output_index":0,
"delta":response_text
}),
json!({
"type":"response.output_item.done",
"output_index":0,
"item":{"type":"message"}
}),
json!({
"type":"response.completed",
"response":{"id":response_id,"usage":{"input_tokens":5,"output_tokens":2}}
}),
];
for event in &events {
let _ = sender.send(Message::Text(event.to_string())).await;
}
handled += 1;
}
}
});
addr_str
}
async fn spawn_websocket_empty_completion_then_retry_upstream(
captured: Arc<Mutex<Vec<Value>>>,
) -> String {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
let addr_str = format!("http://{addr}");
tokio::spawn(async move {
let mut handled = 0usize;
while handled < 3 {
let Ok((stream, _)) = listener.accept().await else {
return;
};
let Ok(ws) = tokio_tungstenite::accept_async(stream).await else {
return;
};
let (mut sender, mut receiver) = ws.split();
while handled < 3 {
let Some(text) = (loop {
match receiver.next().await {
Some(Ok(Message::Text(text))) => break Some(text),
Some(Ok(Message::Ping(data))) => {
let _ = sender.send(Message::Pong(data)).await;
}
Some(Ok(Message::Pong(_))) => {}
Some(Ok(_)) => {}
Some(Err(_)) | None => break None,
}
}) else {
break;
};
if let Ok(json) = serde_json::from_str::<Value>(&text) {
let _ = captured.lock().map(|mut g| g.push(json));
}
if handled == 1 {
let event = json!({
"type": "response.completed",
"response": {
"id": "resp_empty",
"status": "completed",
"incomplete_details": null,
"usage": {"input_tokens": 5, "output_tokens": 0}
}
});
let _ = sender.send(Message::Text(event.to_string())).await;
handled += 1;
continue;
}
let response_text = if handled == 0 { "first" } else { "retry" };
let response_id = if handled == 0 { "resp_1" } else { "resp_retry" };
let events = [
json!({
"type":"response.output_item.added",
"output_index":0,
"item":{"type":"message","id":format!("msg_empty_{handled}")}
}),
json!({
"type":"response.output_text.delta",
"output_index":0,
"delta":response_text
}),
json!({
"type":"response.output_item.done",
"output_index":0,
"item":{"type":"message"}
}),
json!({
"type":"response.completed",
"response":{"id":response_id,"usage":{"input_tokens":5,"output_tokens":2}}
}),
];
for event in &events {
let _ = sender.send(Message::Text(event.to_string())).await;
}
handled += 1;
}
}
});
addr_str
}
/// Upstream that answers every request with a terminal-only completion,
/// so the proxy's bounded retry loop always exhausts.
async fn spawn_websocket_always_empty_completion_upstream(
request_count: Arc<std::sync::atomic::AtomicUsize>,
) -> String {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
let addr_str = format!("http://{addr}");
tokio::spawn(async move {
loop {
let Ok((stream, _)) = listener.accept().await else {
return;
};
let Ok(ws) = tokio_tungstenite::accept_async(stream).await else {
return;
};
let (mut sender, mut receiver) = ws.split();
let request_count = request_count.clone();
tokio::spawn(async move {
while let Some(message) = receiver.next().await {
match message {
Ok(Message::Text(_)) => {
request_count.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
let event = json!({
"type": "response.completed",
"response": {
"id": "resp_empty",
"status": "completed",
"incomplete_details": null,
"usage": {"input_tokens": 5, "output_tokens": 0}
}
});
if sender.send(Message::Text(event.to_string())).await.is_err() {
return;
}
}
Ok(Message::Ping(data)) => {
let _ = sender.send(Message::Pong(data)).await;
}
Ok(_) => {}
Err(_) => return,
}
}
});
}
});
addr_str
}
// ---------------------------------------------------------------------------
// Health and routing smoke tests (no env var mutation needed)
// ---------------------------------------------------------------------------
#[tokio::test]
async fn smoke_healthz_returns_ok() {
let app = app(Arc::new(Registry::with_default_alias()));
let response = app
.oneshot(
Request::builder()
.method(Method::GET)
.uri("/healthz")
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(response.status(), StatusCode::OK);
let body: Value = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.ok()
.and_then(|bytes| serde_json::from_slice(&bytes).ok())
.unwrap();
assert_eq!(body, json!({"ok": true}));
}
#[tokio::test]
#[allow(clippy::await_holding_lock)]
async fn smoke_codex_model_routes_to_real_provider() {
let _guard = env_lock();
let response = call_messages("gpt-5.5").await;
// Should attempt auth (not return 501 placeholder)
assert!(
response.status() != StatusCode::NOT_IMPLEMENTED,
"codex models must resolve to the real provider, not a placeholder"
);
}
#[test]
fn smoke_kimi_model_is_registered() {
// Kimi uses reqwest::blocking::Client internally, which panics when
// dropped from an async context (it joins a dedicated runtime thread).
// Test routing at the Registry level instead of through the HTTP stack.
let registry = Registry::with_default_alias();
let provider = registry.provider_for_model("kimi-for-coding", None);
assert!(
provider.is_some(),
"kimi-for-coding must resolve to a registered provider"
);
assert_eq!(
provider.unwrap().name(),
"kimi",
"kimi-for-coding must route to the kimi provider"
);
}
// ---------------------------------------------------------------------------
// Kimi smoke: mock upstream verifies request shape and returns a valid
// streaming response. Uses multi-thread runtime because KimiHttpClient uses
// reqwest::blocking::Client internally.
// ---------------------------------------------------------------------------
#[allow(clippy::await_holding_lock)]
#[tokio::test(flavor = "multi_thread")]
async fn smoke_kimi_messages_uses_mock_upstream() {
let _guard = env_lock();
let config = TempDir::new().unwrap();
write_auth(config.path(), "kimi");
let captured = Arc::new(Mutex::new(None));
let upstream = spawn_http_upstream({
let captured = captured.clone();
move |body: Value| {
let _ = captured.lock().map(|mut g| *g = Some(body));
concat!(
"data: {\"choices\":[{\"delta\":{\"content\":\"kimi ok\"}}]}\n\n",
"data: {\"choices\":[{\"finish_reason\":\"stop\"}],\"usage\":{\"prompt_tokens\":5,\"completion_tokens\":2}}\n\n",
"data: [DONE]\n\n"
)
.as_bytes()
.to_vec()
}
})
.await;
let _config_env = EnvGuard::set("CCP_CONFIG_DIR", config.path());
let _base_url_env = EnvGuard::set("CCP_KIMI_BASE_URL", &upstream);
let _compaction_env = EnvGuard::set("CCP_CODEX_SERVER_COMPACTION", "1");
let response = call_messages("kimi-for-coding").await;
assert_eq!(response.status(), StatusCode::OK);
let value: Value = serde_json::from_slice(
&axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap(),
)
.unwrap();
assert_eq!(value["content"][0]["text"], "kimi ok");
let sent = captured.lock().unwrap().clone().unwrap();
assert_eq!(sent["model"], "kimi-for-coding");
assert_eq!(sent["stream"], true);
assert!(sent.get("input").is_none());
assert!(!sent.to_string().contains("compaction_trigger"));
}
// ---------------------------------------------------------------------------
// Codex HTTP smoke: mock upstream verifies request shape and returns
// Responses SSE events.
// ---------------------------------------------------------------------------
#[allow(clippy::await_holding_lock)]
#[tokio::test]
async fn smoke_codex_http_messages_uses_mock_upstream() {
let _guard = env_lock();
let config = TempDir::new().unwrap();
write_auth(config.path(), "codex");
let captured = Arc::new(Mutex::new(None));
let upstream = spawn_http_upstream({
let captured = captured.clone();
move |body: Value| {
let _ = captured.lock().map(|mut g| *g = Some(body));
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()
.to_vec()
}
})
.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", "http");
let response = call_messages("gpt-5.5").await;
assert_eq!(response.status(), StatusCode::OK);
let value: Value = serde_json::from_slice(
&axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap(),
)
.unwrap();
assert_eq!(value["content"][0]["text"], "codex http ok");
let sent = captured.lock().unwrap().clone().unwrap();
assert_eq!(sent["model"], "gpt-5.5");
assert_eq!(sent["stream"], true);
}
#[allow(clippy::await_holding_lock)]
#[tokio::test]
async fn smoke_codex_native_responses_preserves_parallel_tool_calls() {
let _guard = env_lock();
let config = TempDir::new().unwrap();
write_auth(config.path(), "codex");
let captured = Arc::new(Mutex::new(None));
let upstream = spawn_http_upstream({
let captured = captured.clone();
move |body: Value| {
let _ = captured.lock().map(|mut guard| *guard = Some(body));
br#"{"id":"resp_1","object":"response","status":"completed","output":[],"usage":{"input_tokens":1,"output_tokens":1}}"#.to_vec()
}
})
.await;
let _config_env = EnvGuard::set("CCP_CONFIG_DIR", config.path());
let _base_url_env = EnvGuard::set("CCP_CODEX_BASE_URL", &upstream);
let response = call_responses_body(json!({
"model":"gpt-5.4",
"input":"hello",
"parallel_tool_calls":false
}))
.await;
assert_eq!(response.status(), StatusCode::OK);
let sent = captured.lock().unwrap().clone().unwrap();
assert_eq!(sent["parallel_tool_calls"], false);
}
/// Resets the retry-delay override even when the test panics, so later tests
/// in this process keep real backoff behavior.
struct ZeroRetryDelayGuard;
impl ZeroRetryDelayGuard {
fn enable() -> Self {
claude_code_proxy::retry::set_zero_retry_delay_for_tests(true);
ZeroRetryDelayGuard
}
}
impl Drop for ZeroRetryDelayGuard {
fn drop(&mut self) {
claude_code_proxy::retry::set_zero_retry_delay_for_tests(false);
}
}
fn empty_completion_sse() -> Vec<u8> {
concat!(
"data: {\"type\":\"response.completed\",\"response\":{\"id\":\"resp_empty\",",
"\"status\":\"completed\",\"incomplete_details\":null,",
"\"usage\":{\"input_tokens\":5,\"output_tokens\":0}}}\n\n"
)
.as_bytes()
.to_vec()
}
fn empty_message_completion_sse() -> Vec<u8> {
concat!(
"data: {\"type\":\"response.output_item.added\",\"output_index\":0,",
"\"item\":{\"type\":\"message\",\"id\":\"msg_empty\"}}\n\n",
"data: {\"type\":\"response.output_item.done\",\"output_index\":0,",
"\"item\":{\"type\":\"message\"}}\n\n",
"data: {\"type\":\"response.completed\",\"response\":{\"id\":\"resp_empty\",",
"\"status\":\"completed\",\"incomplete_details\":null,",
"\"usage\":{\"input_tokens\":5,\"output_tokens\":0}}}\n\n"
)
.as_bytes()
.to_vec()
}
fn codex_usage_limit_event(error_type: &str) -> Value {
json!({
"type": "error",
"status_code": 429,
"error": {
"type": error_type,
"message": "The usage limit has been reached",
"resets_at": 1788879437u64,
"resets_in_seconds": 9568
},
"headers": {
"X-Codex-Primary-Window-Minutes": "300",
"X-Codex-Primary-Reset-After-Seconds": "9569",
"X-Codex-Secondary-Window-Minutes": "10080",
"X-Codex-Secondary-Reset-After-Seconds": "596369"
}
})
}
fn codex_usage_limit_sse(error_type: &str) -> Vec<u8> {
format!("data: {}\n\n", codex_usage_limit_event(error_type)).into_bytes()
}
fn codex_header_only_usage_limit_sse() -> Vec<u8> {
format!(
"data: {}\n\n",
json!({
"type": "error",
"status_code": 429,
"error": {
"type": "usage_limit_reached",
"message": "The usage limit has been reached",
"resets_in_seconds": 90
}
})
)
.into_bytes()
}
async fn assert_usage_limit_response(response: Response) {
assert_eq!(response.status(), StatusCode::TOO_MANY_REQUESTS);
assert_eq!(response.headers()["x-should-retry"], "false");
assert_eq!(
response.headers()["anthropic-ratelimit-unified-status"],
"rejected"
);
assert_eq!(
response.headers()["anthropic-ratelimit-unified-reset"],
"1788879437"
);
assert_eq!(
response.headers()["anthropic-ratelimit-unified-representative-claim"],
"five_hour"
);
assert!(!response.headers().contains_key(http::header::RETRY_AFTER));
let body = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let body: Value = serde_json::from_slice(&body).unwrap();
assert_eq!(body["error"]["type"], "rate_limit_error");
assert_eq!(body["error"]["message"], "The usage limit has been reached");
}
fn buffered_success_sse(text: &str) -> Vec<u8> {
format!(
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\":\"{text}\"}}\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"
),
text = text
)
.into_bytes()
}
#[allow(clippy::await_holding_lock)]
#[tokio::test]
async fn smoke_codex_http_usage_limit_event_fast_fails_live_request() {
let _guard = env_lock();
clear_all_continuations_for_tests();
let config = TempDir::new().unwrap();
write_auth(config.path(), "codex");
let attempts = Arc::new(AtomicUsize::new(0));
let upstream = spawn_http_upstream({
let attempts = attempts.clone();
move |_body: Value| {
attempts.fetch_add(1, Ordering::SeqCst);
codex_usage_limit_sse("usage_limit_reached")
}
})
.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", "http");
let response = call_messages_body(json!({
"model": "gpt-5.5",
"max_tokens": 64,
"stream": true,
"messages": [{"role":"user","content":"hello"}]
}))
.await;
assert_eq!(attempts.load(Ordering::SeqCst), 1);
assert_usage_limit_response(response).await;
}
#[allow(clippy::await_holding_lock)]
#[tokio::test]
async fn smoke_codex_http_header_only_usage_limit_event_fast_fails_live_request() {
let _guard = env_lock();
clear_all_continuations_for_tests();
let config = TempDir::new().unwrap();
write_auth(config.path(), "codex");
let attempts = Arc::new(AtomicUsize::new(0));
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
let mock = axum::Router::new().fallback({
let attempts = attempts.clone();
move || {
let attempts = attempts.clone();
async move {
attempts.fetch_add(1, Ordering::SeqCst);
http::Response::builder()
.status(StatusCode::OK)
.header("content-type", "text/event-stream")
.header("x-codex-primary-reset-after-seconds", "90")
.header("x-codex-primary-reset-at", "1788879437")
.header("x-codex-primary-window-minutes", "300")
.body(Body::from(codex_header_only_usage_limit_sse()))
.unwrap()
}
}
});
tokio::spawn(async move {
axum::serve(listener, mock).await.ok();
});
let _config_env = EnvGuard::set("CCP_CONFIG_DIR", config.path());
let _base_url_env = EnvGuard::set("CCP_CODEX_BASE_URL", format!("http://{addr}"));
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!(attempts.load(Ordering::SeqCst), 1);
assert_usage_limit_response(response).await;
}
#[allow(clippy::await_holding_lock)]
#[tokio::test]
async fn smoke_codex_http_usage_limit_event_fast_fails_buffered_request() {
let _guard = env_lock();
clear_all_continuations_for_tests();
let config = TempDir::new().unwrap();
write_auth(config.path(), "codex");
let attempts = Arc::new(AtomicUsize::new(0));
let upstream = spawn_http_upstream({
let attempts = attempts.clone();
move |_body: Value| {
attempts.fetch_add(1, Ordering::SeqCst);
codex_usage_limit_sse("usage_limit_reached")
}
})
.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", "http");
let response = call_messages("gpt-5.5").await;
assert_eq!(attempts.load(Ordering::SeqCst), 1);
assert_usage_limit_response(response).await;
}
#[allow(clippy::await_holding_lock)]
#[tokio::test]
async fn smoke_codex_http_retries_empty_completion() {
let _guard = env_lock();
let _delay_guard = ZeroRetryDelayGuard::enable();
let config = TempDir::new().unwrap();
write_auth(config.path(), "codex");
let attempts = Arc::new(std::sync::atomic::AtomicUsize::new(0));
let upstream = spawn_http_upstream({
let attempts = attempts.clone();
move |_body: Value| {
let attempt = attempts.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
if attempt == 0 {
empty_completion_sse()
} else {
buffered_success_sse("buffered retry ok")
}
}
})
.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", "http");
let response = call_messages("gpt-5.5").await;
let status = response.status();
let body = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let body_text = String::from_utf8_lossy(&body);
assert_eq!(status, StatusCode::OK, "body: {body_text}");
let value: Value = serde_json::from_slice(&body).unwrap();
assert_eq!(value["content"][0]["text"], "buffered retry ok");
assert_eq!(
attempts.load(std::sync::atomic::Ordering::SeqCst),
2,
"empty completion must trigger one retry"
);
}
#[allow(clippy::await_holding_lock)]
#[tokio::test]
async fn smoke_codex_http_retries_empty_message_completion() {
let _guard = env_lock();
let _delay_guard = ZeroRetryDelayGuard::enable();
let config = TempDir::new().unwrap();
write_auth(config.path(), "codex");
let attempts = Arc::new(std::sync::atomic::AtomicUsize::new(0));
let upstream = spawn_http_upstream({
let attempts = attempts.clone();
move |_body: Value| {
let attempt = attempts.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
if attempt == 0 {
empty_message_completion_sse()
} else {
buffered_success_sse("empty message retry ok")
}
}
})
.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", "http");
let response = call_messages("gpt-5.5").await;
let status = response.status();
let body = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let body_text = String::from_utf8_lossy(&body);
assert_eq!(status, StatusCode::OK, "body: {body_text}");
let value: Value = serde_json::from_slice(&body).unwrap();
assert_eq!(value["content"][0]["text"], "empty message retry ok");
assert_eq!(attempts.load(std::sync::atomic::Ordering::SeqCst), 2);
}
#[allow(clippy::await_holding_lock)]
#[tokio::test]
async fn smoke_codex_http_stream_retries_empty_completion() {
let _guard = env_lock();
let _delay_guard = ZeroRetryDelayGuard::enable();
let config = TempDir::new().unwrap();
write_auth(config.path(), "codex");
let attempts = Arc::new(std::sync::atomic::AtomicUsize::new(0));
let upstream = spawn_http_upstream({
let attempts = attempts.clone();
move |_body: Value| {
let attempt = attempts.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
if attempt == 0 {
empty_completion_sse()
} else {
buffered_success_sse("buffered stream retry ok")
}
}
})
.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", "http");
let response = call_messages_body(json!({
"model": "gpt-5.5",
"max_tokens": 64,
"stream": true,
"messages": [{"role":"user","content":"one"}]
}))
.await;
let status = response.status();
let body = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let body_text = String::from_utf8_lossy(&body);
assert_eq!(status, StatusCode::OK, "body: {body_text}");
assert!(
body_text.contains("buffered stream retry ok"),
"expected retried text in SSE body: {body_text}"
);
assert!(
!body_text.contains(r#""input_tokens":0"#),
"message_start should expose the request token estimate: {body_text}"
);
assert_eq!(attempts.load(std::sync::atomic::Ordering::SeqCst), 2);
}
#[allow(clippy::await_holding_lock)]
#[tokio::test]
async fn smoke_codex_http_empty_completions_exhaust_to_service_unavailable() {
let _guard = env_lock();
let _delay_guard = ZeroRetryDelayGuard::enable();
let config = TempDir::new().unwrap();
write_auth(config.path(), "codex");
let attempts = Arc::new(std::sync::atomic::AtomicUsize::new(0));
let upstream = spawn_http_upstream({
let attempts = attempts.clone();
move |_body: Value| {
attempts.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
empty_completion_sse()
}
})
.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", "http");
let response = call_messages("gpt-5.5").await;
let status = response.status();
let should_retry = response.headers().get("x-should-retry").cloned();
let body = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let body_text = String::from_utf8_lossy(&body);
assert_eq!(
status,
StatusCode::SERVICE_UNAVAILABLE,
"exhausted empty completions must surface an explicit error: {body_text}"
);
assert_eq!(
should_retry.as_ref().and_then(|v| v.to_str().ok()),
Some("false"),
"the proxy already retried; the client must not multiply it"
);
assert!(
body_text.contains("Codex completed without producing output"),
"unexpected exhaustion body: {body_text}"
);
// Initial attempt plus MAX_EMPTY_COMPLETION_RETRIES retries.
assert_eq!(
attempts.load(std::sync::atomic::Ordering::SeqCst),
11,
"retry loop must stay bounded"
);
}
#[allow(clippy::await_holding_lock)]
#[tokio::test]
async fn smoke_auto_review_uses_codex_default_and_configured_override() {
let _guard = env_lock();
let config = TempDir::new().unwrap();
write_auth(config.path(), "codex");
let captured = Arc::new(Mutex::new(Vec::new()));
let upstream = spawn_http_upstream({
let captured = captured.clone();
move |body: Value| {
captured.lock().unwrap().push(body);
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\":\"review 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 _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 _codex_model_env = EnvGuard::set("CCP_CODEX_MODEL", "gpt-5.6-sol");
let classifier_body = || {
json!({
"model": "gpt-5.6-sol",
"max_tokens": 64,
"stream": false,
"system": [{
"type": "text",
"text": "You are a security monitor for autonomous AI coding agents.\n\n## Context"
}],
"messages": [{"role":"user","content":"review this Bash command"}],
"tools": []
})
};
let classifier = call_messages_body(classifier_body()).await;
assert_eq!(classifier.status(), StatusCode::OK);
let _ = axum::body::to_bytes(classifier.into_body(), usize::MAX)
.await
.unwrap();
{
let _review_model_env = EnvGuard::set("CCP_AUTO_REVIEW_MODEL", "gpt-5.6-terra");
let classifier = call_messages_body(classifier_body()).await;
assert_eq!(classifier.status(), StatusCode::OK);
let _ = axum::body::to_bytes(classifier.into_body(), usize::MAX)
.await
.unwrap();
}
let normal = call_messages("gpt-5.6-sol").await;
assert_eq!(normal.status(), StatusCode::OK);
let _ = axum::body::to_bytes(normal.into_body(), usize::MAX)
.await
.unwrap();
let sent = captured.lock().unwrap();
assert_eq!(sent.len(), 3);
assert_eq!(sent[0]["model"], "gpt-6-luna");
assert_eq!(sent[1]["model"], "gpt-5.6-terra");
assert_eq!(sent[2]["model"], "gpt-5.6-sol");
}
#[allow(clippy::await_holding_lock)]
#[tokio::test]
async fn smoke_codex_http_server_compaction_fast_fails_usage_limit() {
let _guard = env_lock();
clear_all_compactions_for_tests();
let config = TempDir::new().unwrap();
write_auth(config.path(), "codex");
let attempts = Arc::new(AtomicUsize::new(0));
let upstream = spawn_http_upstream({
let attempts = attempts.clone();
move |body: Value| {
attempts.fetch_add(1, Ordering::SeqCst);
assert_eq!(
body["input"].as_array().unwrap().last().unwrap()["type"],
"compaction_trigger"
);
codex_usage_limit_sse("usage_limit_reached")
}
})
.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", "http");
let _compaction_env = EnvGuard::set("CCP_CODEX_SERVER_COMPACTION", "1");
let response = call_messages_body(json!({
"model": "gpt-5.6-sol",
"max_tokens": 64,
"system": "You are Claude Code.",
"messages": [
{"role":"user","content":"old conversation"},
{"role":"assistant","content":[
{"type":"tool_use","id":"tool-1","name":"Read","input":{}}
]},
{"role":"user","content":[
{"type":"tool_result","tool_use_id":"tool-1","content":"result"},
{"type":"text","text":"CRITICAL: Respond with TEXT ONLY. Do NOT call any tools.\n\nYour task is to create a detailed summary of the conversation so far, paying close attention to the user's explicit requests."}
]}
]
}))
.await;
assert_eq!(attempts.load(Ordering::SeqCst), 1);
assert_usage_limit_response(response).await;
clear_all_compactions_for_tests();
}
#[allow(clippy::await_holding_lock)]
#[tokio::test]
async fn smoke_codex_http_server_compaction_replays_native_history() {
let _guard = env_lock();
clear_all_compactions_for_tests();
let config = TempDir::new().unwrap();
write_auth(config.path(), "codex");
let captured = Arc::new(Mutex::new(Vec::new()));
let upstream = spawn_http_upstream({
let captured = captured.clone();
move |body: Value| {
let is_compaction = body["input"].as_array().is_some_and(|input| {
input.last().and_then(|item| item["type"].as_str())
== Some("compaction_trigger")
});
let request_number = {
let mut requests = captured.lock().unwrap();
requests.push(body);
requests.len()
};
if is_compaction {
concat!(
"data: {\"type\":\"response.output_item.done\",\"output_index\":0,\"item\":{\"type\":\"compaction\",\"encrypted_content\":\"opaque-history\"}}\n\n",
"data: {\"type\":\"response.completed\",\"response\":{\"id\":\"resp_compact\",\"usage\":{\"input_tokens\":100,\"output_tokens\":1}}}\n\n"
)
.as_bytes()
.to_vec()
} else {
let text = if request_number == 2 {
"portable summary with enough detail to anchor the compacted conversation"
} else {
"compacted ok"
};
format!(
"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\":\"{text}\"}}\n\n\
data: {{\"type\":\"response.output_item.done\",\"output_index\":0,\"item\":{{\"type\":\"message\"}}}}\n\n\
data: {{\"type\":\"response.completed\",\"response\":{{\"id\":\"resp_{request_number}\",\"usage\":{{\"input_tokens\":5,\"output_tokens\":2}}}}}}\n\n"
)
.into_bytes()
}
}
})
.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", "http");
let _compaction_env = EnvGuard::set("CCP_CODEX_SERVER_COMPACTION", "1");
let compact_response = call_messages_body(json!({
"model": "gpt-5.6-sol",
"max_tokens": 64,
"system": "You are Claude Code.",
"messages": [
{"role":"user","content":"old conversation"},
{"role":"assistant","content":[{"type":"tool_use","id":"tool-1","name":"Read","input":{}}]},
{"role":"user","content":[
{"type":"tool_result","tool_use_id":"tool-1","content":"result"},
{"type":"text","text":"CRITICAL: Respond with TEXT ONLY. Do NOT call any tools.\n\nYour task is to create a detailed summary of the conversation so far, paying close attention to the user's explicit requests."}
]}
]
}))
.await;
assert_eq!(compact_response.status(), StatusCode::OK);
let response = call_messages_body(json!({
"model": "gpt-5.6-sol",
"max_tokens": 64,
"system": "current instructions",
"messages": [
{"role":"user","content":"<summary>portable summary with enough detail to anchor the compacted conversation</summary>"},
{"role":"user","content":"continue"}
]
}))
.await;
assert_eq!(response.status(), StatusCode::OK);
let value: Value = serde_json::from_slice(
&axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap(),
)
.unwrap();
assert_eq!(value["content"][0]["text"], "compacted ok");
let requests = captured.lock().unwrap();
assert_eq!(requests.len(), 3);
assert_eq!(requests[0]["model"], "gpt-5.6-sol");
assert!(requests[0].get("client_metadata").is_some());
assert_eq!(
requests[0]["input"].as_array().unwrap().last().unwrap()["type"],
"compaction_trigger"
);
assert!(
!requests[0]
.to_string()
.contains("Your task is to create a detailed summary")
);
assert!(
requests[1]
.to_string()
.contains("Your task is to create a detailed summary")
);
assert!(!requests[1].to_string().contains("opaque-history"));
let replay = requests[2]["input"].as_array().unwrap();
assert!(requests[2].get("client_metadata").is_some());
assert!(requests[2].to_string().contains("current instructions"));
let compaction = replay
.iter()
.find(|item| item["type"] == "compaction")
.unwrap();
assert_eq!(compaction["encrypted_content"], "opaque-history");
assert!(replay.iter().any(|item| item["role"] == "user"));
clear_all_compactions_for_tests();
}
#[allow(clippy::await_holding_lock)]
#[tokio::test]
async fn smoke_codex_http_compaction_failure_preserves_portable_summary() {
let _guard = env_lock();
clear_all_compactions_for_tests();
let config = TempDir::new().unwrap();
write_auth(config.path(), "codex");
let captured = Arc::new(Mutex::new(Vec::new()));
let upstream = spawn_http_upstream({
let captured = captured.clone();
move |body: Value| {
let is_compaction = body["input"].as_array().is_some_and(|input| {
input.last().and_then(|item| item["type"].as_str())
== Some("compaction_trigger")
});
captured.lock().unwrap().push(body);
if is_compaction {
b"data: {\"type\":\"response.completed\",\"response\":{}}\n\n".to_vec()
} else {
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\":\"portable fallback\"}\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 _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 _compaction_env = EnvGuard::set("CCP_CODEX_SERVER_COMPACTION", "1");
let response = call_messages_body(json!({
"model": "gpt-5.5",
"max_tokens": 64,
"system": "You are a helpful AI assistant tasked with summarizing conversations.",
"messages": [{"role":"user","content":"old conversation"}]
}))
.await;
assert_eq!(response.status(), StatusCode::OK);
let value: Value = serde_json::from_slice(
&axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap(),
)
.unwrap();
assert_eq!(value["content"][0]["text"], "portable fallback");
let requests = captured.lock().unwrap();
assert_eq!(requests.len(), 2);
assert!(requests[1].to_string().contains("old conversation"));
assert!(!requests[1].to_string().contains("opaque-history"));
}
#[allow(clippy::await_holding_lock)]
#[tokio::test]
async fn smoke_codex_http_context_window_error_requests_compaction() {
let _guard = env_lock();
let config = TempDir::new().unwrap();
write_auth(config.path(), "codex");
let upstream = spawn_http_upstream(|_body: Value| {
"data: {\"type\":\"response.failed\",\"response\":{\"error\":{\"message\":\"input exceeds context window\"}}}\n\n"
.as_bytes()
.to_vec()
})
.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", "http");
let response = call_messages("gpt-5.5").await;
let status = response.status();
let body = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
assert_eq!(status, StatusCode::PAYLOAD_TOO_LARGE);
let value: Value = serde_json::from_slice(&body).unwrap();
assert_eq!(value["type"], "error");
assert_eq!(value["error"]["type"], "request_too_large");
assert!(
value["error"]["message"]
.as_str()
.is_some_and(|message| message.contains("input exceeds context window")),
"response body: {}",
String::from_utf8_lossy(&body)
);
}
#[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.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("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");
}
#[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_stream_returns_before_upstream_completion() {
let _guard = env_lock();
let config = TempDir::new().unwrap();
write_auth(config.path(), "codex");
let release = Arc::new(tokio::sync::Notify::new());
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
let upstream = format!("http://{addr}");
let mock = axum::Router::new().fallback({
let release = release.clone();
move |_body: String| {
let release = release.clone();
async move {
let stream = futures_util::stream::unfold(0_u8, move |state| {
let release = release.clone();
async move {
match state {
0 => Some((
Ok::<_, std::convert::Infallible>(bytes::Bytes::from_static(
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\":\"incremental ok\"}\n\n"
)
.as_bytes(),
)),
1,
)),
1 => {
release.notified().await;
Some((
Ok(bytes::Bytes::from_static(concat!(
"data: {\"type\":\"response.output_item.done\",\"output_index\":0,\"item\":{\"type\":\"message\"}}\n\n",
"data: {\"type\":\"response.completed\",\"response\":{\"id\":\"resp_1\",\"status\":\"completed\",\"usage\":{\"input_tokens\":5,\"output_tokens\":2}}}\n\n"
).as_bytes())),
2,
))
}
_ => None,
}
}
});
http::Response::builder()
.status(StatusCode::OK)
.header("content-type", "text/event-stream")
.body(Body::from_stream(stream))
.unwrap()
}
}
});
tokio::spawn(async move {
axum::serve(listener, mock).await.ok();
});
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 = tokio::time::timeout(
Duration::from_secs(3),
call_messages_body(json!({
"model": "gpt-5.5",
"max_tokens": 64,
"stream": true,
"messages": [{"role":"user","content":"hello"}]
})),
)
.await
.expect("CCP must return streaming headers before upstream completion");
assert_eq!(response.status(), StatusCode::OK);
let mut body = response.into_body();
let first = tokio::time::timeout(Duration::from_millis(200), body.frame())
.await
.expect("initial Anthropic heartbeat must arrive before upstream completion")
.unwrap()
.unwrap()
.into_data()
.unwrap();
let first = String::from_utf8(first.to_vec()).unwrap();
assert!(first.contains("event: message_start"));
assert!(first.contains("event: ping"));
assert!(first.contains("incremental ok"));
release.notify_one();
let rest = axum::body::to_bytes(body, usize::MAX).await.unwrap();
let rest = String::from_utf8(rest.to_vec()).unwrap();
assert!(rest.contains("event: message_stop"), "stream body: {rest}");
}
#[allow(clippy::await_holding_lock)]
#[tokio::test]
async fn smoke_codex_http_retries_overload_after_control_events() {
assert_codex_http_presemantic_retry(
concat!(
"data: {\"type\":\"response.created\",\"response\":{\"id\":\"resp_failed\"}}\n\n",
"data: {\"type\":\"response.in_progress\",\"response\":{\"id\":\"resp_failed\"}}\n\n",
"data: {\"type\":\"response.failed\",\"response\":{\"error\":{\"type\":\"overloaded_error\",\"message\":\"Our servers are currently overloaded. Please try again later.\",\"retry_after\":0}}}\n\n"
)
.as_bytes()
.to_vec(),
)
.await;
}
#[allow(clippy::await_holding_lock)]
#[tokio::test]
async fn smoke_codex_http_retries_rate_limit_after_control_events() {
assert_codex_http_presemantic_retry(
concat!(
"data: {\"type\":\"response.created\",\"response\":{\"id\":\"resp_limited\"}}\n\n",
"data: {\"type\":\"codex.rate_limits\",\"rate_limits\":{\"limit_reached\":true,\"primary\":{\"reset_after_seconds\":0}}}\n\n"
)
.as_bytes()
.to_vec(),
)
.await;
}
#[allow(clippy::await_holding_lock)]
#[tokio::test]
async fn smoke_codex_http_retries_transient_rate_limit_with_reset_clock() {
assert_codex_http_presemantic_retry(codex_usage_limit_sse("rate_limit_exceeded")).await;
}
#[allow(clippy::await_holding_lock)]
#[tokio::test]
async fn smoke_codex_http_retries_transient_failure_after_control_events() {
assert_codex_http_presemantic_retry(
concat!(
"data: {\"type\":\"response.created\",\"response\":{\"id\":\"resp_transient\"}}\n\n",
"data: {\"type\":\"response.failed\",\"response\":{\"error\":{\"type\":\"server_error\",\"status\":503,\"message\":\"temporarily unavailable\",\"retry_after\":0}}}\n\n"
)
.as_bytes()
.to_vec(),
)
.await;
}
#[allow(clippy::await_holding_lock)]
#[tokio::test]
async fn smoke_codex_http_retries_presemantic_eof() {
assert_codex_http_presemantic_retry(
"data: {\"type\":\"response.created\",\"response\":{\"id\":\"resp_truncated\"}}\n\n"
.as_bytes()
.to_vec(),
)
.await;
}
#[allow(clippy::await_holding_lock)]
#[tokio::test]
async fn smoke_codex_http_retries_body_error_after_structural_message() {
assert_codex_http_retries_structural_body_error(
concat!(
"data: {\"type\":\"response.created\",\"response\":{\"id\":\"resp_structural\"}}\n\n",
"data: {\"type\":\"response.output_item.added\",\"output_index\":0,\"item\":{\"type\":\"message\",\"id\":\"msg_structural\"}}\n\n"
)
.as_bytes()
.to_vec(),
)
.await;
}
#[allow(clippy::await_holding_lock)]
#[tokio::test]
async fn smoke_codex_http_retries_body_error_after_structural_tool() {
assert_codex_http_retries_structural_body_error(
concat!(
"data: {\"type\":\"response.created\",\"response\":{\"id\":\"resp_structural\"}}\n\n",
"data: {\"type\":\"response.output_item.added\",\"output_index\":0,\"item\":{\"type\":\"function_call\",\"call_id\":\"call_structural\",\"name\":\"Read\"}}\n\n"
)
.as_bytes()
.to_vec(),
)
.await;
}
#[allow(clippy::await_holding_lock)]
#[tokio::test]
async fn smoke_codex_http_incomplete_after_text_is_an_error() {
let _guard = env_lock();
clear_all_continuations_for_tests();
let config = 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_partial\"}}\n\n",
"data: {\"type\":\"response.output_text.delta\",\"output_index\":0,\"delta\":\"partial output\"}\n\n",
"data: {\"type\":\"response.output_item.done\",\"output_index\":0,\"item\":{\"type\":\"message\"}}\n\n",
"data: {\"type\":\"response.incomplete\",\"response\":{\"status\":\"incomplete\",\"incomplete_details\":{\"reason\":\"content_filter\"}}}\n\n"
)
.as_bytes()
.to_vec()
})
.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", "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("partial output"), "stream body: {text}");
assert!(text.contains("event: error"), "stream body: {text}");
assert!(text.contains("content_filter"), "stream body: {text}");
assert!(!text.contains("event: message_stop"), "stream body: {text}");
assert!(
!text.contains("\"stop_reason\":\"max_tokens\""),
"stream body: {text}"
);
}
#[allow(clippy::await_holding_lock)]
#[tokio::test]
async fn smoke_codex_http_preserves_permanent_policy_failure() {
let _guard = env_lock();
clear_all_continuations_for_tests();
let config = TempDir::new().unwrap();
write_auth(config.path(), "codex");
let attempts = Arc::new(AtomicUsize::new(0));
let upstream = spawn_http_upstream({
let attempts = attempts.clone();
move |_body: Value| {
attempts.fetch_add(1, Ordering::SeqCst);
"data: {\"type\":\"response.failed\",\"response\":{\"status\":\"failed\",\"error\":{\"code\":\"cyber_policy\",\"message\":\"request rejected by policy\"}}}\n\n"
.as_bytes()
.to_vec()
}
})
.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", "http");
let response = call_messages("gpt-5.5").await;
assert_eq!(attempts.load(Ordering::SeqCst), 1);
assert_eq!(response.status(), StatusCode::BAD_REQUEST);
let body = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let value: Value = serde_json::from_slice(&body).unwrap();
assert_eq!(value["error"]["type"], "invalid_request_error");
assert_eq!(value["error"]["message"], "request rejected by policy");
}
#[allow(clippy::await_holding_lock)]
#[tokio::test]
async fn smoke_codex_http_rate_limit_snapshot_does_not_end_response() {
let _guard = env_lock();
clear_all_continuations_for_tests();
let config = TempDir::new().unwrap();
write_auth(config.path(), "codex");
let attempts = Arc::new(AtomicUsize::new(0));
let upstream = spawn_http_upstream({
let attempts = attempts.clone();
move |_body: Value| {
attempts.fetch_add(1, Ordering::SeqCst);
concat!(
"data: {\"type\":\"codex.rate_limits\",\"rate_limits\":{\"limit_reached\":true,\"primary\":{\"reset_after_seconds\":60}}}\n\n",
"data: {\"type\":\"response.output_item.added\",\"output_index\":0,\"item\":{\"type\":\"message\",\"id\":\"msg_after_rate\"}}\n\n",
"data: {\"type\":\"response.output_text.delta\",\"output_index\":0,\"delta\":\"completed after telemetry\"}\n\n",
"data: {\"type\":\"response.output_item.done\",\"output_index\":0,\"item\":{\"type\":\"message\"}}\n\n",
"data: {\"type\":\"response.completed\",\"response\":{\"id\":\"resp_after_rate\",\"status\":\"completed\"}}\n\n"
)
.as_bytes()
.to_vec()
}
})
.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", "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_eq!(attempts.load(Ordering::SeqCst), 1, "stream body: {text}");
assert!(
text.contains("completed after telemetry"),
"stream body: {text}"
);
assert!(text.contains("event: message_stop"), "stream body: {text}");
assert!(!text.contains("event: error"), "stream body: {text}");
}
#[allow(clippy::await_holding_lock)]
#[tokio::test]
async fn smoke_codex_http_usage_limit_status_fast_fails_live_request() {
let _guard = env_lock();
clear_all_continuations_for_tests();
let config = TempDir::new().unwrap();
write_auth(config.path(), "codex");
let attempts = Arc::new(AtomicUsize::new(0));
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
let upstream = format!("http://{addr}");
let mock = axum::Router::new().fallback({
let attempts = attempts.clone();
move || {
let attempts = attempts.clone();
async move {
attempts.fetch_add(1, Ordering::SeqCst);
http::Response::builder()
.status(StatusCode::TOO_MANY_REQUESTS)
.header("content-type", "application/json")
.header("x-codex-primary-window-minutes", "300")
.header("x-codex-primary-reset-after-seconds", "9568")
.body(Body::from(
json!({
"error": {
"type": "usage_limit_reached",
"message": "The usage limit has been reached",
"resets_at": 1788879437u64,
"resets_in_seconds": 9568
}
})
.to_string(),
))
.unwrap()
}
}
});
tokio::spawn(async move {
axum::serve(listener, mock).await.ok();
});
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!(attempts.load(Ordering::SeqCst), 1);
assert_usage_limit_response(response).await;
}
#[allow(clippy::await_holding_lock)]
#[tokio::test]
async fn smoke_codex_http_bounds_initial_status_retries() {
let _guard = env_lock();
clear_all_continuations_for_tests();
let config = TempDir::new().unwrap();
write_auth(config.path(), "codex");
let attempts = Arc::new(AtomicUsize::new(0));
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
let upstream = format!("http://{addr}");
let mock = axum::Router::new().fallback({
let attempts = attempts.clone();
move || {
let attempts = attempts.clone();
async move {
attempts.fetch_add(1, Ordering::SeqCst);
http::Response::builder()
.status(StatusCode::SERVICE_UNAVAILABLE)
.header("retry-after", "0")
.body(Body::empty())
.unwrap()
}
}
});
tokio::spawn(async move {
axum::serve(listener, mock).await.ok();
});
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::SERVICE_UNAVAILABLE);
assert_eq!(attempts.load(Ordering::SeqCst), 4);
}
#[allow(clippy::await_holding_lock)]
#[tokio::test]
async fn smoke_codex_http_retries_presemantic_invalid_json() {
assert_codex_http_presemantic_retry(b"data: not-json\n\n".to_vec()).await;
}
#[allow(clippy::await_holding_lock)]
#[tokio::test]
async fn smoke_codex_http_retries_presemantic_invalid_utf8() {
assert_codex_http_presemantic_retry(b"data: \xff\n\n".to_vec()).await;
}
#[allow(clippy::await_holding_lock)]
#[tokio::test]
async fn smoke_codex_http_does_not_retry_overload_after_semantic_output() {
let _guard = env_lock();
let config = TempDir::new().unwrap();
write_auth(config.path(), "codex");
let attempts = Arc::new(AtomicUsize::new(0));
let upstream = spawn_http_upstream({
let attempts = attempts.clone();
move |_body: Value| {
let attempt = attempts.fetch_add(1, Ordering::SeqCst);
if attempt == 0 {
concat!(
"data: {\"type\":\"response.created\",\"response\":{\"id\":\"resp_partial\"}}\n\n",
"data: {\"type\":\"response.output_item.added\",\"output_index\":0,\"item\":{\"type\":\"message\",\"id\":\"msg_partial\"}}\n\n",
"data: {\"type\":\"response.output_text.delta\",\"output_index\":0,\"delta\":\"partial output\"}\n\n",
"data: {\"type\":\"response.failed\",\"response\":{\"error\":{\"type\":\"overloaded_error\",\"message\":\"overloaded after output\",\"retry_after\":0}}}\n\n"
)
.as_bytes()
.to_vec()
} else {
panic!("semantic output must close the full-request retry window");
}
}
})
.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", "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 = tokio::time::timeout(
Duration::from_secs(2),
axum::body::to_bytes(response.into_body(), usize::MAX),
)
.await
.expect("failed semantic stream must terminate")
.unwrap();
let text = String::from_utf8_lossy(&body);
assert_eq!(attempts.load(Ordering::SeqCst), 1, "stream body: {text}");
assert!(text.contains("partial output"), "stream body: {text}");
assert!(
text.contains("overloaded after output"),
"stream body: {text}"
);
}
#[allow(clippy::await_holding_lock)]
#[tokio::test]
async fn smoke_codex_http_stops_after_retry_limit() {
let _guard = env_lock();
clear_all_continuations_for_tests();
let config = TempDir::new().unwrap();
write_auth(config.path(), "codex");
let attempts = Arc::new(AtomicUsize::new(0));
let upstream = spawn_http_upstream({
let attempts = attempts.clone();
move |_body: Value| {
attempts.fetch_add(1, Ordering::SeqCst);
concat!(
"data: {\"type\":\"response.created\",\"response\":{\"id\":\"resp_exhausted\"}}\n\n",
"data: {\"type\":\"response.failed\",\"response\":{\"error\":{\"type\":\"overloaded_error\",\"message\":\"overloaded until retry limit\",\"retry_after\":0}}}\n\n"
)
.as_bytes()
.to_vec()
}
})
.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", "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().as_u16(), 529);
let body = tokio::time::timeout(
Duration::from_secs(2),
axum::body::to_bytes(response.into_body(), usize::MAX),
)
.await
.expect("exhausted stream must terminate")
.unwrap();
let text = String::from_utf8_lossy(&body);
assert_eq!(attempts.load(Ordering::SeqCst), 4, "stream body: {text}");
assert!(
text.contains("overloaded until retry limit"),
"stream body: {text}"
);
}
#[allow(clippy::await_holding_lock)]
#[tokio::test]
async fn smoke_codex_http_cancels_retry_backoff_when_request_drops() {
let _guard = env_lock();
clear_all_continuations_for_tests();
let config = TempDir::new().unwrap();
write_auth(config.path(), "codex");
let attempts = Arc::new(AtomicUsize::new(0));
let upstream = spawn_http_upstream({
let attempts = attempts.clone();
move |_body: Value| {
let attempt = attempts.fetch_add(1, Ordering::SeqCst);
if attempt == 0 {
concat!(
"data: {\"type\":\"response.created\",\"response\":{\"id\":\"resp_cancel\"}}\n\n",
"data: {\"type\":\"response.failed\",\"response\":{\"error\":{\"type\":\"overloaded_error\",\"message\":\"cancel during retry backoff\",\"retry_after\":0.1}}}\n\n"
)
.as_bytes()
.to_vec()
} else {
panic!("request cancellation must prevent another upstream attempt");
}
}
})
.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", "http");
let request = tokio::spawn(call_messages_body(json!({
"model": "gpt-5.5",
"max_tokens": 64,
"stream": true,
"messages": [{"role":"user","content":"hello"}]
})));
tokio::time::timeout(Duration::from_secs(5), async {
while attempts.load(Ordering::SeqCst) == 0 {
tokio::task::yield_now().await;
}
})
.await
.expect("first upstream attempt must start");
request.abort();
let _ = request.await;
tokio::time::sleep(Duration::from_millis(300)).await;
assert_eq!(attempts.load(Ordering::SeqCst), 1);
}
#[allow(clippy::await_holding_lock)]
#[tokio::test]
async fn smoke_codex_http_body_error_after_semantic_output_preserves_message() {
let _guard = env_lock();
clear_all_continuations_for_tests();
let config = TempDir::new().unwrap();
write_auth(config.path(), "codex");
let upstream = spawn_truncated_http_upstream(concat!(
"data: {\"type\":\"response.created\",\"response\":{\"id\":\"resp_partial\"}}\n\n",
"data: {\"type\":\"response.output_item.added\",\"output_index\":0,\"item\":{\"type\":\"message\",\"id\":\"msg_partial\"}}\n\n",
"data: {\"type\":\"response.output_text.delta\",\"output_index\":0,\"delta\":\"partial before body error\"}\n\n"
).as_bytes())
.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", "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 = tokio::time::timeout(
Duration::from_secs(2),
axum::body::to_bytes(response.into_body(), usize::MAX),
)
.await
.expect("failed semantic stream must terminate")
.unwrap();
let text = String::from_utf8_lossy(&body);
assert!(
text.contains("partial before body error"),
"stream body: {text}"
);
assert!(text.contains("event: error"), "stream body: {text}");
assert!(
text.contains("Transport error reading Codex response body"),
"stream body: {text}"
);
assert!(
!text.contains("\"message\":\"http_response_body\""),
"stream body: {text}"
);
}
#[allow(clippy::await_holding_lock)]
#[tokio::test]
async fn smoke_codex_http_body_error_after_closed_tool_is_not_success() {
let _guard = env_lock();
clear_all_continuations_for_tests();
let config = TempDir::new().unwrap();
write_auth(config.path(), "codex");
let upstream = spawn_truncated_http_upstream(concat!(
"data: {\"type\":\"response.created\",\"response\":{\"id\":\"resp_tool_partial\"}}\n\n",
"data: {\"type\":\"response.output_item.added\",\"output_index\":0,\"item\":{\"type\":\"function_call\",\"call_id\":\"call_partial\",\"name\":\"Read\"}}\n\n",
"data: {\"type\":\"response.function_call_arguments.delta\",\"output_index\":0,\"delta\":\"{\\\"file_path\\\":\\\"/tmp/example\\\"}\"}\n\n",
"data: {\"type\":\"response.output_item.done\",\"output_index\":0,\"item\":{\"type\":\"function_call\",\"call_id\":\"call_partial\",\"name\":\"Read\",\"arguments\":\"{\\\"file_path\\\":\\\"/tmp/example\\\"}\"}}\n\n"
).as_bytes())
.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", "http");
let response = call_messages_body(json!({
"model": "gpt-5.5",
"max_tokens": 64,
"stream": true,
"messages": [{"role":"user","content":"read a file"}]
}))
.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("\"name\":\"Read\""), "stream body: {text}");
assert!(text.contains("event: error"), "stream body: {text}");
assert!(
text.contains("Transport error reading Codex response body"),
"stream body: {text}"
);
assert!(!text.contains("event: message_stop"), "stream body: {text}");
}
#[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)
);
}
#[allow(clippy::await_holding_lock)]
#[tokio::test(flavor = "multi_thread")]
async fn smoke_codex_auto_fallback_usage_limit_fast_fails_live_request() {
let _guard = env_lock();
clear_all_continuations_for_tests();
clear_codex_websocket_pool_for_tests();
let config = TempDir::new().unwrap();
write_auth(config.path(), "codex");
let websocket_attempts = Arc::new(AtomicUsize::new(0));
let http_attempts = Arc::new(AtomicUsize::new(0));
let upstream =
spawn_auto_fallback_usage_limit_upstream(websocket_attempts.clone(), http_attempts.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", "auto");
let response = call_messages_body(json!({
"model": "gpt-5.5",
"max_tokens": 64,
"stream": true,
"messages": [{"role":"user","content":"hello"}]
}))
.await;
assert_eq!(websocket_attempts.load(Ordering::SeqCst), 1);
assert_eq!(http_attempts.load(Ordering::SeqCst), 1);
assert_usage_limit_response(response).await;
clear_codex_websocket_pool_for_tests();
}
// ---------------------------------------------------------------------------
// Codex WebSocket smoke: mock upstream verifies request shape and returns
// Responses events over WebSocket.
// ---------------------------------------------------------------------------
// Multi-threaded runtime so the spawned accept task runs independently and
// the listener is registered with the I/O driver before connect_async starts.
// A single-threaded runtime risks the root task (connect_async) outpacing the
// spawned accept task, causing connection-refused races.
#[allow(clippy::await_holding_lock)]
#[tokio::test(flavor = "multi_thread")]
async fn smoke_codex_websocket_messages_uses_mock_upstream() {
let _guard = env_lock();
let config = 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 _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;
let ws_status = response.status();
let ws_body_bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
if ws_status != StatusCode::OK {
panic!(
"WS: expected 200, got {}: {}",
ws_status,
String::from_utf8_lossy(&ws_body_bytes)
);
}
let value: Value = serde_json::from_slice(&ws_body_bytes).unwrap();
assert_eq!(value["content"][0]["text"], "codex websocket ok");
let guard = captured.lock().unwrap();
let sent = guard.clone().unwrap_or_else(|| {
panic!(
"WS mock did not capture a request. Response body: {}",
String::from_utf8_lossy(&ws_body_bytes)
);
});
assert_eq!(sent["type"], "response.create");
assert_eq!(sent["model"], "gpt-5.5");
assert!(sent.get("max_output_tokens").is_none());
assert!(sent.get("stream").is_none());
}
#[allow(clippy::await_holding_lock)]
#[tokio::test(flavor = "multi_thread")]
async fn smoke_codex_websocket_usage_limit_fast_fails_request() {
let _guard = env_lock();
clear_all_continuations_for_tests();
clear_codex_websocket_pool_for_tests();
let config = TempDir::new().unwrap();
write_auth(config.path(), "codex");
let attempts = Arc::new(AtomicUsize::new(0));
let upstream = spawn_websocket_usage_limit_upstream(attempts.clone()).await;
let _config_env = EnvGuard::set("CCP_CONFIG_DIR", config.path());
let _base_url_env = EnvGuard::set("CCP_CODEX_BASE_URL", &upstream);
let _transport_env = EnvGuard::set("CCP_CODEX_TRANSPORT", "websocket");
let response = call_messages_body(json!({
"model": "gpt-5.5",
"max_tokens": 64,
"stream": true,
"messages": [{"role":"user","content":"hello"}]
}))
.await;
assert_eq!(attempts.load(Ordering::SeqCst), 1);
assert_usage_limit_response(response).await;
clear_codex_websocket_pool_for_tests();
}
#[allow(clippy::await_holding_lock)]
#[tokio::test(flavor = "multi_thread")]
async fn smoke_codex_websocket_uses_credits_after_included_limit() {
let _guard = env_lock();
let config = TempDir::new().unwrap();
write_auth(config.path(), "codex");
clear_codex_websocket_pool_for_tests();
let upstream = spawn_websocket_credited_rate_limit_upstream().await;
let _config_env = EnvGuard::set("CCP_CONFIG_DIR", config.path());
let _base_url_env = EnvGuard::set("CCP_CODEX_BASE_URL", &upstream);
let _transport_env = EnvGuard::set("CCP_CODEX_TRANSPORT", "websocket");
let response = call_messages("gpt-5.5").await;
let status = response.status();
let body = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
assert_eq!(
status,
StatusCode::OK,
"credited Codex response must not be discarded: {}",
String::from_utf8_lossy(&body)
);
let value: Value = serde_json::from_slice(&body).unwrap();
assert_eq!(value["content"][0]["text"], "credited codex ok");
}
#[allow(clippy::await_holding_lock)]
#[tokio::test(flavor = "multi_thread")]
async fn smoke_codex_websocket_stream_uses_credits_after_included_limit() {
let _guard = env_lock();
let config = TempDir::new().unwrap();
write_auth(config.path(), "codex");
clear_codex_websocket_pool_for_tests();
let upstream = spawn_websocket_credited_rate_limit_upstream().await;
let _config_env = EnvGuard::set("CCP_CONFIG_DIR", config.path());
let _base_url_env = EnvGuard::set("CCP_CODEX_BASE_URL", &upstream);
let _transport_env = EnvGuard::set("CCP_CODEX_TRANSPORT", "websocket");
let response = call_messages_body(json!({
"model": "gpt-5.5",
"max_tokens": 64,
"stream": true,
"messages": [{"role":"user","content":"hello"}]
}))
.await;
let status = response.status();
let body = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
assert_eq!(
status,
StatusCode::OK,
"credited Codex stream must not be discarded: {}",
String::from_utf8_lossy(&body)
);
let text = String::from_utf8_lossy(&body);
assert!(text.contains("credited codex ok"), "stream body: {text}");
assert!(text.contains("message_stop"), "stream body: {text}");
assert!(!text.contains("event: error"), "stream body: {text}");
}
#[allow(clippy::await_holding_lock)]
#[tokio::test(flavor = "multi_thread")]
async fn smoke_codex_websocket_stream_returns_delta_before_terminal() {
let _guard = env_lock();
let config = TempDir::new().unwrap();
write_auth(config.path(), "codex");
clear_codex_websocket_pool_for_tests();
let upstream = spawn_websocket_delayed_terminal_upstream().await;
let _config_env = EnvGuard::set("CCP_CONFIG_DIR", config.path());
let _base_url_env = EnvGuard::set("CCP_CODEX_BASE_URL", &upstream);
let _transport_env = EnvGuard::set("CCP_CODEX_TRANSPORT", "websocket");
let response = tokio::time::timeout(
Duration::from_millis(1_500),
call_messages_body(json!({
"model": "gpt-5.5",
"max_tokens": 64,
"stream": true,
"messages": [{"role":"user","content":"hello"}]
})),
)
.await
.expect("streaming response should start before terminal upstream event");
assert_eq!(response.status(), StatusCode::OK);
let mut body = response.into_body();
let mut collected = Vec::new();
let read = tokio::time::timeout(Duration::from_millis(500), async {
while !String::from_utf8_lossy(&collected).contains("text_delta") {
let Some(frame) = body.frame().await else {
break;
};
let frame = frame.unwrap();
if let Ok(data) = frame.into_data() {
collected.extend_from_slice(&data);
}
}
})
.await;
assert!(read.is_ok(), "stream did not yield an early text delta");
let text = String::from_utf8_lossy(&collected);
assert!(text.contains("early chunk"), "stream body: {text}");
assert!(
!text.contains(r#""input_tokens":0"#),
"message_start should expose the request token estimate: {text}"
);
assert!(
!text.contains("message_stop"),
"stream finished too early: {text}"
);
}
#[allow(clippy::await_holding_lock)]
#[tokio::test(flavor = "multi_thread")]
async fn smoke_codex_websocket_context_window_error_requests_compaction() {
let _guard = env_lock();
let config = TempDir::new().unwrap();
write_auth(config.path(), "codex");
clear_codex_websocket_pool_for_tests();
let upstream = spawn_websocket_error_upstream("input exceeds context window").await;
let _config_env = EnvGuard::set("CCP_CONFIG_DIR", config.path());
let _base_url_env = EnvGuard::set("CCP_CODEX_BASE_URL", &upstream);
let _transport_env = EnvGuard::set("CCP_CODEX_TRANSPORT", "websocket");
let response = call_messages_body(json!({
"model": "gpt-5.5",
"max_tokens": 64,
"stream": true,
"messages": [{"role":"user","content":"hello"}]
}))
.await;
let status = response.status();
let body = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
assert_eq!(
status,
StatusCode::PAYLOAD_TOO_LARGE,
"response body: {}",
String::from_utf8_lossy(&body)
);
let value: Value = serde_json::from_slice(&body).unwrap();
assert_eq!(value["type"], "error");
assert_eq!(value["error"]["type"], "request_too_large");
assert_eq!(value["error"]["message"], "input exceeds context window");
}
#[allow(clippy::await_holding_lock)]
#[tokio::test(flavor = "multi_thread")]
async fn smoke_codex_websocket_stream_uses_previous_response_id() {
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,
"stream": true,
"messages": [{"role":"user","content":"one"}]
}))
.await;
assert_eq!(first.status(), StatusCode::OK);
let _ = axum::body::to_bytes(first.into_body(), usize::MAX)
.await
.unwrap();
let second = call_messages_body(json!({
"model": "gpt-5.5",
"max_tokens": 64,
"stream": true,
"messages": [
{"role":"user","content":"one"},
{"role":"assistant","content":"first"},
{"role":"user","content":"two"}
]
}))
.await;
assert_eq!(second.status(), StatusCode::OK);
let second_body = axum::body::to_bytes(second.into_body(), usize::MAX)
.await
.unwrap();
assert!(
String::from_utf8_lossy(&second_body).contains("second"),
"second response body: {}",
String::from_utf8_lossy(&second_body)
);
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_stream_retries_missing_previous_response_id() {
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_previous_missing_then_retry_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,
"stream": true,
"messages": [{"role":"user","content":"one"}]
}))
.await;
assert_eq!(first.status(), StatusCode::OK);
let _ = axum::body::to_bytes(first.into_body(), usize::MAX)
.await
.unwrap();
let second = call_messages_body(json!({
"model": "gpt-5.5",
"max_tokens": 64,
"stream": true,
"messages": [
{"role":"user","content":"one"},
{"role":"assistant","content":"first"},
{"role":"user","content":"two"}
]
}))
.await;
assert_eq!(second.status(), StatusCode::OK);
let second_body = axum::body::to_bytes(second.into_body(), usize::MAX)
.await
.unwrap();
assert!(
String::from_utf8_lossy(&second_body).contains("retry"),
"second response body: {}",
String::from_utf8_lossy(&second_body)
);
let guard = captured.lock().unwrap();
assert_eq!(guard.len(), 3, "expected retry websocket request");
assert!(guard[0].get("previous_response_id").is_none());
assert_eq!(guard[1]["previous_response_id"], "resp_1");
assert!(guard[2].get("previous_response_id").is_none());
assert_eq!(
guard[2]["input"].as_array().map(Vec::len),
Some(3),
"retry request should send the full input"
);
clear_all_continuations_for_tests();
clear_codex_websocket_pool_for_tests();
}
#[allow(clippy::await_holding_lock)]
#[tokio::test(flavor = "multi_thread")]
async fn smoke_codex_websocket_stream_retries_empty_close_with_full_context() {
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_close_then_retry_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,
"stream": true,
"messages": [{"role":"user","content":"one"}]
}))
.await;
assert_eq!(first.status(), StatusCode::OK);
let _ = axum::body::to_bytes(first.into_body(), usize::MAX)
.await
.unwrap();
let second = call_messages_body(json!({
"model": "gpt-5.5",
"max_tokens": 64,
"stream": true,
"messages": [
{"role":"user","content":"one"},
{"role":"assistant","content":"first"},
{"role":"user","content":"two"}
]
}))
.await;
assert_eq!(second.status(), StatusCode::OK);
let second_body = axum::body::to_bytes(second.into_body(), usize::MAX)
.await
.unwrap();
assert!(
String::from_utf8_lossy(&second_body).contains("retry"),
"second response body: {}",
String::from_utf8_lossy(&second_body)
);
let second_text = String::from_utf8_lossy(&second_body);
assert!(
!second_text.contains("call_aborted"),
"stream body: {second_text}"
);
assert!(
!second_text.contains(r#""name":"Read""#),
"stream body: {second_text}"
);
assert!(
!second_text.contains("event: error"),
"stream body: {second_text}"
);
assert_eq!(second_text.matches("event: content_block_start").count(), 1);
let guard = captured.lock().unwrap();
assert_eq!(guard.len(), 3, "expected full-context retry request");
assert!(guard[0].get("previous_response_id").is_none());
assert_eq!(guard[1]["previous_response_id"], "resp_1");
assert!(guard[2].get("previous_response_id").is_none());
assert_eq!(
guard[2]["input"].as_array().map(Vec::len),
Some(3),
"retry request should send the full input"
);
clear_all_continuations_for_tests();
clear_codex_websocket_pool_for_tests();
}
#[allow(clippy::await_holding_lock)]
#[tokio::test(flavor = "multi_thread")]
async fn smoke_codex_websocket_stream_retries_terminal_only_completion_with_full_context() {
let _guard = env_lock();
let config = TempDir::new().unwrap();
let state = TempDir::new().unwrap();
write_auth(config.path(), "codex");
clear_codex_websocket_pool_for_tests();
clear_all_continuations_for_tests();
let captured = Arc::new(Mutex::new(Vec::new()));
let upstream = spawn_websocket_empty_completion_then_retry_upstream(captured.clone()).await;
let _traffic_env = EnvGuard::set("CCP_TRAFFIC_LOG", "1");
let _state_env = EnvGuard::set("XDG_STATE_HOME", state.path());
let _config_env = EnvGuard::set("CCP_CONFIG_DIR", config.path());
let _base_url_env = EnvGuard::set("CCP_CODEX_BASE_URL", &upstream);
let _transport_env = EnvGuard::set("CCP_CODEX_TRANSPORT", "websocket");
let _previous_response_env = EnvGuard::set("CCP_CODEX_PREVIOUS_RESPONSE_ID", "1");
let first = call_messages_body(json!({
"model": "gpt-5.5",
"max_tokens": 64,
"stream": true,
"messages": [{"role":"user","content":"one"}]
}))
.await;
assert_eq!(first.status(), StatusCode::OK);
let _ = axum::body::to_bytes(first.into_body(), usize::MAX)
.await
.unwrap();
let second = call_messages_body(json!({
"model": "gpt-5.5",
"max_tokens": 64,
"stream": true,
"messages": [
{"role":"user","content":"one"},
{"role":"assistant","content":"first"},
{"role":"user","content":"two"}
]
}))
.await;
assert_eq!(second.status(), StatusCode::OK);
let second_body = axum::body::to_bytes(second.into_body(), usize::MAX)
.await
.unwrap();
assert!(
String::from_utf8_lossy(&second_body).contains("retry"),
"second response body: {}",
String::from_utf8_lossy(&second_body)
);
let downstream_end_turns = traffic_files(state.path())
.into_iter()
.filter(|path| {
path.file_name()
.and_then(|name| name.to_str())
.is_some_and(|name| name.ends_with("050-downstream-event.json"))
})
.filter_map(|path| std::fs::read(path).ok())
.filter_map(|bytes| serde_json::from_slice::<Value>(&bytes).ok())
.filter(|event| event["data"]["delta"]["stop_reason"] == "end_turn")
.count();
assert_eq!(
downstream_end_turns, 2,
"discarded empty attempts must not be captured as downstream events"
);
let guard = captured.lock().unwrap();
assert_eq!(guard.len(), 3, "expected full-context retry request");
assert!(guard[0].get("previous_response_id").is_none());
assert_eq!(guard[1]["previous_response_id"], "resp_1");
assert!(guard[2].get("previous_response_id").is_none());
assert_eq!(
guard[2]["input"].as_array().map(Vec::len),
Some(3),
"retry request should send the full input"
);
clear_all_continuations_for_tests();
clear_codex_websocket_pool_for_tests();
}
#[allow(clippy::await_holding_lock)]
#[tokio::test(flavor = "multi_thread")]
async fn smoke_codex_websocket_empty_completions_exhaust_to_service_unavailable() {
let _guard = env_lock();
let _delay_guard = ZeroRetryDelayGuard::enable();
let config = TempDir::new().unwrap();
write_auth(config.path(), "codex");
clear_codex_websocket_pool_for_tests();
clear_all_continuations_for_tests();
let request_count = Arc::new(std::sync::atomic::AtomicUsize::new(0));
let upstream = spawn_websocket_always_empty_completion_upstream(request_count.clone()).await;
let _config_env = EnvGuard::set("CCP_CONFIG_DIR", config.path());
let _base_url_env = EnvGuard::set("CCP_CODEX_BASE_URL", &upstream);
let _transport_env = EnvGuard::set("CCP_CODEX_TRANSPORT", "websocket");
let response = call_messages_body(json!({
"model": "gpt-5.5",
"max_tokens": 64,
"stream": true,
"messages": [{"role":"user","content":"one"}]
}))
.await;
let status = response.status();
let body = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let body_text = String::from_utf8_lossy(&body);
assert_eq!(
status,
StatusCode::SERVICE_UNAVAILABLE,
"exhausted empty completions must surface an explicit error: {body_text}"
);
assert!(
body_text.contains("Codex completed without producing output"),
"unexpected exhaustion body: {body_text}"
);
// Initial attempt plus MAX_RETRYABLE_LIVE_STREAM_RETRIES full-context retries.
assert_eq!(
request_count.load(std::sync::atomic::Ordering::SeqCst),
11,
"retry loop must stay bounded"
);
clear_all_continuations_for_tests();
clear_codex_websocket_pool_for_tests();
}
#[allow(clippy::await_holding_lock)]
#[tokio::test(flavor = "multi_thread")]
async fn smoke_codex_websocket_previous_response_id_sends_delta_on_second_turn() {
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;
let second_status = second.status();
let second_body = axum::body::to_bytes(second.into_body(), usize::MAX)
.await
.unwrap();
assert_eq!(
second_status,
StatusCode::OK,
"second response body: {}",
String::from_utf8_lossy(&second_body)
);
let value: Value = serde_json::from_slice(&second_body).unwrap();
assert_eq!(value["content"][0]["text"], "second");
let third = call_messages_body(json!({
"model": "gpt-5.5",
"max_tokens": 64,
"messages": [
{"role":"user","content":"one"},
{"role":"assistant","content":"first"},
{"role":"user","content":"two"},
{"role":"assistant","content":"second"},
{"role":"user","content":"three"}
]
}))
.await;
let third_status = third.status();
let third_body = axum::body::to_bytes(third.into_body(), usize::MAX)
.await
.unwrap();
assert_eq!(
third_status,
StatusCode::OK,
"third response body: {}",
String::from_utf8_lossy(&third_body)
);
let value: Value = serde_json::from_slice(&third_body).unwrap();
assert_eq!(value["content"][0]["text"], "third");
let guard = captured.lock().unwrap();
assert_eq!(guard.len(), 3, "expected three 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");
assert_eq!(guard[2]["previous_response_id"], "resp_2");
assert_eq!(
guard[2]["input"].as_array().map(Vec::len),
Some(1),
"third request should keep reusing the pooled websocket continuation"
);
assert_eq!(guard[2]["input"][0]["role"], "user");
assert_eq!(guard[2]["input"][0]["content"][0]["text"], "three");
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");
}