Skip to content

Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy

Rust

add native responses api passthrough

Raine Virta567258154507
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 298ca30..26da024 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,10 @@
- Codex optionally preserves conversation continuity across Claude Code
compaction boundaries with native encrypted compaction artifacts. Enable it
with `codex.serverCompaction` or `CCP_CODEX_SERVER_COMPACTION`.
+- Native OpenAI Responses clients can use `POST /v1/responses` with existing
+ Codex authentication, including JSON responses, SSE streaming, and automatic
+ token refresh. Enable the endpoint with `codex.responsesApi` or
+ `CCP_CODEX_RESPONSES_API=1`; it is disabled by default.
## v0.1.23 (2026-07-22)
diff --git a/README.md b/README.md
index 4a289e6..69229a1 100644
--- a/README.md
+++ b/README.md
@@ -706,6 +706,9 @@ The proxy speaks enough of the Anthropic API for Claude Code:
- `POST /v1/messages?beta=true`: same (Claude Code always sends `?beta=true`)
- `POST /v1/messages/count_tokens`: local token count via `gpt-tokenizer`
(o200k_base); used by Claude Code's compaction logic
+- `POST /v1/responses`: optional native OpenAI Responses passthrough using stored
+ Codex authentication; enable with `codex.responsesApi` or
+ `CCP_CODEX_RESPONSES_API=1`
- `GET /healthz`: liveness check
## Configuration
@@ -735,7 +738,8 @@ Windows, and at
"baseUrl": "https://chatgpt.com/backend-api/codex/responses",
"transport": "websocket",
"previousResponseId": false,
- "serverCompaction": true
+ "serverCompaction": true,
+ "responsesApi": false
},
"kimi": {
"userAgent": "KimiCLI/1.37.0",
@@ -778,6 +782,7 @@ Windows, and at
| `CCP_CODEX_TRANSPORT` | `codex.transport` | `websocket` | Codex transport: `websocket`, `http`, or `auto` |
| `CCP_CODEX_PREVIOUS_RESPONSE_ID` | `codex.previousResponseId` | `false` | Enable WebSocket continuation with `previous_response_id` when the request is append-only |
| `CCP_CODEX_SERVER_COMPACTION` | `codex.serverCompaction` | `false` | Enable Codex remote compaction at Claude Code compaction boundaries with `1`, `true`, `yes`, or `on` |
+| `CCP_CODEX_RESPONSES_API` | `codex.responsesApi` | `false` | Enable `POST /v1/responses` with native OpenAI Responses request, JSON response, and SSE behavior using stored Codex authentication |
| `CCP_CODEX_ORIGINATOR` | `codex.originator` | `claude-code-proxy` | Override the `originator` header sent to Codex |
| `CCP_CODEX_USER_AGENT` | `codex.userAgent` | `claude-code-proxy/<version>` | Override the `User-Agent` header sent to Codex |
| `CCP_KIMI_USER_AGENT` | `kimi.userAgent` | `KimiCLI/1.37.0` | Override the `User-Agent` header sent to Kimi |
@@ -794,6 +799,14 @@ A malformed `config.json` is reported on stderr and ignored; defaults are used
in its place. Invalid types for individual keys are warned and skipped without
affecting other keys.
+`CCP_CODEX_RESPONSES_API=1` enables `POST /v1/responses` for clients that use
+OpenAI's native Responses protocol. The route replaces incoming credentials with
+the proxy's stored Codex authentication, refreshes rejected access tokens before
+forwarding a response, and preserves native JSON or SSE response bodies. The
+route accepts Codex models listed by `claude-code-proxy models`; Images API,
+stored response retrieval and deletion, and WebSocket ingress are outside its
+scope.
+
Codex uses the WebSocket Responses transport by default. Set
`CCP_CODEX_TRANSPORT=http` to use the older HTTP SSE transport for debugging or
compatibility, or `CCP_CODEX_TRANSPORT=auto` to try WebSocket with HTTP fallback
diff --git a/src/config.rs b/src/config.rs
index 5c0c3ae..f345d9a 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -56,6 +56,8 @@ struct CodexConfig {
pub previous_response_id: Option<bool>,
#[serde(rename = "serverCompaction")]
pub server_compaction: Option<bool>,
+ #[serde(rename = "responsesApi")]
+ pub responses_api: Option<bool>,
#[serde(rename = "serviceTier")]
pub service_tier: Option<String>,
#[serde(rename = "reasoningSummary")]
@@ -219,6 +221,9 @@ pub fn config_override_summary_lines(cfg: &LoadedConfig) -> Vec<String> {
if env.contains_key("CCP_LOG_STDERR") {
out.push("log.stderr (env)".to_string());
}
+ if env.contains_key("CCP_CODEX_RESPONSES_API") {
+ out.push("codex.responsesApi (env)".to_string());
+ }
if env.contains_key("CCP_KIMI_OAUTH_HOST") {
out.push("kimi.oauthHost (env)".to_string());
}
@@ -277,6 +282,9 @@ pub fn config_override_summary_lines(cfg: &LoadedConfig) -> Vec<String> {
if let Some(enabled) = codex.server_compaction {
out.push(format!("codex.serverCompaction: {enabled}"));
}
+ if codex.responses_api == Some(true) {
+ out.push("codex.responsesApi: true".to_string());
+ }
}
}
out
@@ -449,6 +457,21 @@ pub fn codex_server_compaction() -> bool {
false
}
+pub fn codex_responses_api() -> bool {
+ let env: HashMap<_, _> = std::env::vars().collect();
+ if let Some(raw) = env.get("CCP_CODEX_RESPONSES_API") {
+ return matches!(raw.to_ascii_lowercase().as_str(), "1" | "true" | "yes");
+ }
+ let config_dir = paths::config_dir();
+ if let Some(file) = read_file_config(&config_dir)
+ && let Some(codex) = file.codex
+ && let Some(enabled) = codex.responses_api
+ {
+ return enabled;
+ }
+ false
+}
+
pub fn codex_service_tier() -> Option<String> {
let env: HashMap<_, _> = std::env::vars().collect();
if let Some(raw) = env.get("CCP_CODEX_SERVICE_TIER") {
@@ -622,6 +645,7 @@ mod tests {
std::env::remove_var("CCP_LOG_STDERR");
std::env::remove_var("CCP_CODEX_REASONING_SUMMARY");
std::env::remove_var("CCP_CODEX_SERVER_COMPACTION");
+ std::env::remove_var("CCP_CODEX_RESPONSES_API");
}
}
@@ -777,6 +801,46 @@ mod tests {
assert!(loaded.log_stderr);
}
+ #[test]
+ fn codex_responses_api_defaults_to_disabled() {
+ let _guard = ENV_LOCK.lock().unwrap();
+ clear_env();
+ let config = tempfile::TempDir::new().unwrap();
+ let _config_env = EnvGuard::set("CCP_CONFIG_DIR", config.path());
+
+ assert!(!codex_responses_api());
+ }
+
+ #[test]
+ fn codex_responses_api_reads_config_and_env_takes_precedence() {
+ let _guard = ENV_LOCK.lock().unwrap();
+ clear_env();
+ let config = tempfile::TempDir::new().unwrap();
+ std::fs::write(
+ config.path().join("config.json"),
+ r#"{"codex":{"responsesApi":true}}"#,
+ )
+ .unwrap();
+ let _config_env = EnvGuard::set("CCP_CONFIG_DIR", config.path());
+
+ assert!(codex_responses_api());
+ let _responses_env = EnvGuard::set("CCP_CODEX_RESPONSES_API", "false");
+ assert!(!codex_responses_api());
+ }
+
+ #[test]
+ fn codex_responses_api_accepts_enabled_env_values() {
+ let _guard = ENV_LOCK.lock().unwrap();
+ clear_env();
+ let config = tempfile::TempDir::new().unwrap();
+ let _config_env = EnvGuard::set("CCP_CONFIG_DIR", config.path());
+
+ for value in ["1", "true", "TRUE", "yes"] {
+ let _responses_env = EnvGuard::set("CCP_CODEX_RESPONSES_API", value);
+ assert!(codex_responses_api(), "{value}");
+ }
+ }
+
#[test]
fn codex_reasoning_summary_reads_config() {
let _guard = ENV_LOCK.lock().unwrap();
diff --git a/src/monitor.rs b/src/monitor.rs
index 79dfecd..f9ebf00 100644
--- a/src/monitor.rs
+++ b/src/monitor.rs
@@ -16,6 +16,7 @@ pub const SESSION_TOKEN_BUCKET_SECS: u64 = 10;
pub enum EndpointKind {
Messages,
CountTokens,
+ Responses,
}
impl EndpointKind {
@@ -23,6 +24,7 @@ impl EndpointKind {
match self {
Self::Messages => "messages",
Self::CountTokens => "count_tokens",
+ Self::Responses => "responses",
}
}
}
diff --git a/src/providers/codex/auth/manager.rs b/src/providers/codex/auth/manager.rs
index 89493ac..6a8981c 100644
--- a/src/providers/codex/auth/manager.rs
+++ b/src/providers/codex/auth/manager.rs
@@ -1,4 +1,5 @@
use std::sync::Arc;
+use std::sync::LazyLock;
#[cfg(test)]
use std::sync::Mutex;
use std::time::{Duration, SystemTime, UNIX_EPOCH};
@@ -9,6 +10,9 @@ use super::jwt::{TokenResponse, extract_account_id, validate_token_response};
use super::token_store::{CodexTokenStore, StoredAuth};
use crate::auth::AuthStorage;
+static CODEX_REFRESH_LOCK: LazyLock<Arc<AsyncMutex<()>>> =
+ LazyLock::new(|| Arc::new(AsyncMutex::new(())));
+
pub struct CodexAuthManager<S: AuthStorage<StoredAuth>> {
pub store: CodexTokenStore<S>,
#[cfg(test)]
@@ -28,7 +32,7 @@ impl<S: AuthStorage<StoredAuth>> CodexAuthManager<S> {
store,
#[cfg(test)]
test_auth: Arc::new(Mutex::new(None)),
- refresh_lock: Arc::new(AsyncMutex::new(())),
+ refresh_lock: CODEX_REFRESH_LOCK.clone(),
refresh_client: reqwest::Client::builder()
.connect_timeout(Duration::from_secs(15))
.timeout(Duration::from_secs(30))
diff --git a/src/providers/codex/client.rs b/src/providers/codex/client.rs
index df08ba1..d3e7fb8 100644
--- a/src/providers/codex/client.rs
+++ b/src/providers/codex/client.rs
@@ -159,6 +159,27 @@ pub fn build_codex_headers(
Ok(headers)
}
+pub fn build_native_codex_headers(
+ auth: &StoredAuth,
+ ctx: &RequestContext,
+ use_responses_lite: bool,
+ stream: bool,
+) -> Result<http::HeaderMap, CodexError> {
+ let mut headers = build_codex_headers(auth, ctx, use_responses_lite)?;
+ headers.insert(
+ http::header::ACCEPT,
+ header_value(
+ "accept",
+ if stream {
+ "text/event-stream"
+ } else {
+ "application/json"
+ },
+ )?,
+ );
+ Ok(headers)
+}
+
fn header_value(name: &str, value: &str) -> Result<http::HeaderValue, CodexError> {
http::HeaderValue::from_str(value).map_err(|e| CodexError {
status: 500,
@@ -228,8 +249,17 @@ const MAX_BUFFERED_TRANSPORT_RETRIES: u32 = 3;
const MAX_BUFFERED_TRANSPORT_ATTEMPTS: u32 = MAX_BUFFERED_TRANSPORT_RETRIES + 1;
const HTTP_RESPONSE_BODY_IDLE_TIMEOUT_MS: u64 = 300_000;
+fn native_http_client() -> reqwest::Client {
+ reqwest::Client::builder()
+ .connect_timeout(Duration::from_secs(15))
+ .redirect(reqwest::redirect::Policy::none())
+ .build()
+ .expect("failed to create native Responses HTTP client")
+}
+
pub struct CodexHttpClient {
client: reqwest::Client,
+ native_client: reqwest::Client,
auth_manager: CodexAuthManager<DefaultCodexAuthStore>,
base_url: String,
header_timeout_ms: u64,
@@ -252,6 +282,7 @@ impl CodexHttpClient {
.connect_timeout(Duration::from_secs(15))
.build()
.expect("failed to create HTTP client"),
+ native_client: native_http_client(),
auth_manager: CodexAuthManager::new(file_store()),
base_url: config::codex_base_url(CODEX_API_ENDPOINT),
header_timeout_ms: timeout_ms,
@@ -266,6 +297,7 @@ impl CodexHttpClient {
base_url: String,
) -> Self {
Self {
+ native_client: native_http_client(),
client,
auth_manager,
base_url,
@@ -284,6 +316,7 @@ impl CodexHttpClient {
header_timeout_retries: u32,
) -> Self {
Self {
+ native_client: native_http_client(),
client,
auth_manager: CodexAuthManager::new(file_store()),
base_url,
@@ -297,6 +330,100 @@ impl CodexHttpClient {
&self.auth_manager
}
+ pub fn body_idle_timeout_ms(&self) -> u64 {
+ self.body_idle_timeout_ms
+ }
+
+ pub async fn post_native_responses(
+ &self,
+ body: &serde_json::Value,
+ ctx: &RequestContext,
+ use_responses_lite: bool,
+ stream: bool,
+ ) -> Result<reqwest::Response, CodexError> {
+ let body_json = serde_json::to_string(body).map_err(|err| CodexError {
+ status: 500,
+ message: "Failed to serialize native Responses request".to_string(),
+ detail: Some(err.to_string()),
+ retry_after: None,
+ origin: CodexErrorOrigin::Http,
+ })?;
+ let mut auth = self
+ .auth_manager
+ .get_auth()
+ .await
+ .map_err(|err| CodexError {
+ status: 401,
+ message: "Auth error".to_string(),
+ detail: Some(err.to_string()),
+ retry_after: None,
+ origin: CodexErrorOrigin::Auth,
+ })?;
+ let mut refresh_attempted = false;
+
+ loop {
+ let started_at = Instant::now();
+ let headers = build_native_codex_headers(&auth, ctx, use_responses_lite, stream)?;
+ if let Some(traffic) = ctx.traffic.as_deref() {
+ write_codex_http_request_capture(traffic, &self.base_url, &headers, &body_json);
+ }
+
+ let response = self
+ .attempt_native_responses(&headers, body_json.clone())
+ .await?;
+ let status = response.status().as_u16();
+ if status == 401 && !refresh_attempted {
+ refresh_attempted = true;
+ drop(response);
+ auth = self
+ .auth_manager
+ .force_refresh(&auth.access)
+ .await
+ .map_err(auth_refresh_error)?;
+ continue;
+ }
+
+ if let Some(traffic) = ctx.traffic.as_deref() {
+ write_live_upstream_response_headers(traffic, &response, started_at.elapsed());
+ }
+ return Ok(response);
+ }
+ }
+
+ async fn attempt_native_responses(
+ &self,
+ headers: &http::HeaderMap,
+ body_json: String,
+ ) -> Result<reqwest::Response, CodexError> {
+ let mut request = self.native_client.post(&self.base_url);
+ for (key, value) in headers {
+ request = request.header(key.as_str(), value.as_bytes());
+ }
+
+ tokio::time::timeout(
+ Duration::from_millis(self.header_timeout_ms),
+ request.body(body_json).send(),
+ )
+ .await
+ .map_err(|_| CodexError {
+ status: 0,
+ message: format!(
+ "Timed out waiting {}ms for Codex response headers",
+ self.header_timeout_ms
+ ),
+ detail: None,
+ retry_after: None,
+ origin: CodexErrorOrigin::Http,
+ })?
+ .map_err(|err| CodexError {
+ status: 0,
+ message: format!("Native Responses transport error: {err}"),
+ detail: None,
+ retry_after: None,
+ origin: CodexErrorOrigin::Http,
+ })
+ }
+
pub async fn post_codex(
&self,
body: &ResponsesRequest,
@@ -977,6 +1104,21 @@ fn write_codex_http_request_capture(
);
}
+fn write_live_upstream_response_headers(
+ traffic: &TrafficCapture,
+ response: &reqwest::Response,
+ elapsed: Duration,
+) {
+ traffic.write_json(
+ "030-upstream-response-headers",
+ &serde_json::json!({
+ "status": response.status().as_u16(),
+ "elapsedMs": elapsed.as_millis(),
+ "headers": headers_to_json(response.headers()),
+ }),
+ );
+}
+
fn write_upstream_response_capture(
traffic: &TrafficCapture,
status: u16,
@@ -1364,6 +1506,141 @@ mod tests {
client
}
+ #[tokio::test]
+ async fn native_responses_replaces_auth_and_preserves_json_body() {
+ let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+ let addr = listener.local_addr().unwrap();
+ let server = tokio::spawn(async move {
+ let (mut stream, _) = listener.accept().await.unwrap();
+ let mut request = [0_u8; 16 * 1024];
+ let read = stream.read(&mut request).await.unwrap();
+ let request = String::from_utf8_lossy(&request[..read]);
+ assert!(request.contains("authorization: Bearer test"));
+ assert!(request.contains("chatgpt-account-id: acct"));
+ assert!(request.contains("accept: application/json"));
+ assert!(request.contains(r#""extra":{"kept":true}"#));
+ let body = br#"{"id":"resp_native","object":"response"}"#;
+ let response = format!(
+ "HTTP/1.1 200 OK\r\ncontent-type: application/json\r\ncontent-length: {}\r\nconnection: close\r\n\r\n",
+ body.len()
+ );
+ stream.write_all(response.as_bytes()).await.unwrap();
+ stream.write_all(body).await.unwrap();
+ });
+
+ let client = authenticated_http_test_client(format!("http://{addr}/v1/responses"));
+ let response = client
+ .post_native_responses(
+ &serde_json::json!({
+ "model": "gpt-5.4",
+ "input": "hello",
+ "stream": false,
+ "extra": {"kept": true}
+ }),
+ &http_test_context(),
+ false,
+ false,
+ )
+ .await
+ .unwrap();
+ assert_eq!(response.status(), reqwest::StatusCode::OK);
+ assert_eq!(
+ response.bytes().await.unwrap(),
+ br#"{"id":"resp_native","object":"response"}"#.as_slice()
+ );
+ server.await.unwrap();
+ }
+
+ #[tokio::test]
+ async fn native_responses_refreshes_once_before_returning_body() {
+ let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+ let addr = listener.local_addr().unwrap();
+ let client = Arc::new(authenticated_http_test_client(format!(
+ "http://{addr}/v1/responses"
+ )));
+ let server_client = client.clone();
+ let server = tokio::spawn(async move {
+ for attempt in 0..2 {
+ let (mut stream, _) = listener.accept().await.unwrap();
+ let mut request = [0_u8; 16 * 1024];
+ let read = stream.read(&mut request).await.unwrap();
+ let request = String::from_utf8_lossy(&request[..read]);
+ if attempt == 0 {
+ assert!(request.contains("authorization: Bearer test"));
+ server_client.auth_manager().set_test_auth(StoredAuth {
+ access: "rotated".into(),
+ refresh: "rotated-refresh".into(),
+ account_id: Some("acct-rotated".into()),
+ expires: u64::MAX,
+ });
+ stream
+ .write_all(
+ b"HTTP/1.1 401 Unauthorized\r\ncontent-length: 0\r\nconnection: close\r\n\r\n",
+ )
+ .await
+ .unwrap();
+ } else {
+ assert!(request.contains("authorization: Bearer rotated"));
+ assert!(request.contains("chatgpt-account-id: acct-rotated"));
+ stream
+ .write_all(
+ b"HTTP/1.1 200 OK\r\ncontent-type: application/json\r\ncontent-length: 2\r\nconnection: close\r\n\r\n{}",
+ )
+ .await
+ .unwrap();
+ }
+ }
+ });
+
+ let response = client
+ .post_native_responses(
+ &serde_json::json!({"model":"gpt-5.4","input":"hello"}),
+ &http_test_context(),
+ false,
+ false,
+ )
+ .await
+ .unwrap();
+ assert_eq!(response.status(), reqwest::StatusCode::OK);
+ assert_eq!(response.bytes().await.unwrap(), b"{}".as_slice());
+ server.await.unwrap();
+ }
+
+ #[tokio::test]
+ async fn native_responses_does_not_follow_redirects() {
+ let source = TcpListener::bind("127.0.0.1:0").await.unwrap();
+ let source_addr = source.local_addr().unwrap();
+ let target = TcpListener::bind("127.0.0.1:0").await.unwrap();
+ let target_addr = target.local_addr().unwrap();
+ let source_server = tokio::spawn(async move {
+ let (mut stream, _) = source.accept().await.unwrap();
+ let mut request = [0_u8; 4096];
+ assert!(stream.read(&mut request).await.unwrap() > 0);
+ let response = format!(
+ "HTTP/1.1 302 Found\r\nlocation: http://{target_addr}/stolen\r\ncontent-length: 0\r\nconnection: close\r\n\r\n"
+ );
+ stream.write_all(response.as_bytes()).await.unwrap();
+ });
+
+ let client = authenticated_http_test_client(format!("http://{source_addr}/v1/responses"));
+ let response = client
+ .post_native_responses(
+ &serde_json::json!({"model":"gpt-5.4","input":"hello"}),
+ &http_test_context(),
+ false,
+ false,
+ )
+ .await
+ .unwrap();
+ assert_eq!(response.status(), reqwest::StatusCode::FOUND);
+ source_server.await.unwrap();
+ assert!(
+ tokio::time::timeout(Duration::from_millis(50), target.accept())
+ .await
+ .is_err()
+ );
+ }
+
#[tokio::test]
async fn buffered_http_retries_retryable_status() {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
diff --git a/src/providers/codex/mod.rs b/src/providers/codex/mod.rs
index 8a4d742..7cabfe4 100644
--- a/src/providers/codex/mod.rs
+++ b/src/providers/codex/mod.rs
@@ -4,6 +4,7 @@ pub mod compaction;
pub mod continuation;
pub mod count_tokens;
pub(crate) mod events;
+pub mod native;
pub mod request_summary;
pub mod translate;
pub mod websocket;
diff --git a/src/providers/codex/native.rs b/src/providers/codex/native.rs
new file mode 100644
index 0000000..a5ff3f6
--- /dev/null
+++ b/src/providers/codex/native.rs
@@ -0,0 +1,777 @@
+use std::io;
+use std::pin::Pin;
+use std::sync::{Arc, Mutex};
+use std::time::Duration;
+
+use axum::body::Body;
+use axum::response::{IntoResponse, Response};
+use bytes::Bytes;
+use futures_util::{Stream, StreamExt};
+use http::{HeaderMap, HeaderName, StatusCode};
+use serde_json::{Map, Value, json};
+
+use crate::anthropic::sse::parse_sse_events;
+use crate::provider::RequestContext;
+use crate::traffic::{
+ MAX_SSE_CAPTURE_BYTES, MAX_STREAM_CAPTURE_EVENT_BYTES, MAX_STREAM_CAPTURE_EVENTS,
+ MAX_STREAM_CAPTURE_FRAME_BYTES,
+};
+
+use super::client::{CodexError, CodexHttpClient};
+use super::translate::model_allowlist::{
+ ALLOWED_MODELS, MODEL_ALIASES, assert_allowed_model, full_lane_web_search_model,
+ uses_responses_lite,
+};
+
+pub struct CodexNativeBackend {
+ client: Arc<CodexHttpClient>,
+}
+
+impl Default for CodexNativeBackend {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+impl CodexNativeBackend {
+ pub fn new() -> Self {
+ Self {
+ client: Arc::new(CodexHttpClient::new()),
+ }
+ }
+
+ pub async fn handle(&self, mut body: Value, ctx: RequestContext) -> Response {
+ let resolved = match shape_native_request(&mut body) {
+ Ok(resolved) => resolved,
+ Err(response) => return response,
+ };
+ if let Some(monitor) = ctx.monitor.as_ref() {
+ monitor.model_resolved(&ctx.req_id, &resolved.model);
+ monitor.upstream_started(&ctx.req_id);
+ }
+
+ let upstream = match self
+ .client
+ .post_native_responses(&body, &ctx, resolved.use_responses_lite, resolved.stream)
+ .await
+ {
+ Ok(response) => response,
+ Err(error) => return local_codex_error(error),
+ };
+
+ passthrough_response(upstream, ctx, self.client.body_idle_timeout_ms())
+ }
+}
+
+struct NativeResolved {
+ model: String,
+ use_responses_lite: bool,
+ stream: bool,
+}
+
+pub fn validate_native_request_model(body: &Value) -> Result<String, Response> {
+ let object = body.as_object().ok_or_else(|| {
+ openai_error(
+ StatusCode::BAD_REQUEST,
+ "invalid_request_error",
+ "Request body must be a JSON object",
+ None,
+ None,
+ )
+ })?;
+ let requested = object
+ .get("model")
+ .and_then(Value::as_str)
+ .filter(|model| !model.is_empty())
+ .map(str::to_string)
+ .ok_or_else(|| {
+ openai_error(
+ StatusCode::BAD_REQUEST,
+ "invalid_request_error",
+ "Missing or invalid 'model' in request body",
+ Some("model"),
+ None,
+ )
+ })?;
+ let (resolved, _) = resolve_native_model(&requested);
+ if let Err(error) = assert_allowed_model(&resolved) {
+ return Err(openai_error(
+ StatusCode::BAD_REQUEST,
+ "invalid_request_error",
+ format!(
+ "Model '{requested}' resolves to unsupported model '{}'. Supported: {}",
+ error.model,
+ ALLOWED_MODELS.join(", ")
+ ),
+ Some("model"),
+ Some("model_not_supported"),
+ ));
+ }
+ Ok(requested)
+}
+
+fn shape_native_request(body: &mut Value) -> Result<NativeResolved, Response> {
+ let requested = validate_native_request_model(body)?;
+ let object = body
+ .as_object_mut()
+ .expect("validated native Responses body must be an object");
+
+ let (mut model, priority) = resolve_native_model(&requested);
+
+ let hosted_web_search = has_native_hosted_web_search(object);
+ if hosted_web_search {
+ model = full_lane_web_search_model(&model).to_string();
+ }
+ object.insert("model".to_string(), Value::String(model.clone()));
+ if priority && !object.contains_key("service_tier") {
+ object.insert("service_tier".to_string(), json!("priority"));
+ }
+
+ Ok(NativeResolved {
+ use_responses_lite: uses_responses_lite(&model) && !hosted_web_search,
+ model,
+ stream: object
+ .get("stream")
+ .and_then(Value::as_bool)
+ .unwrap_or(false),
+ })
+}
+
+fn resolve_native_model(requested: &str) -> (String, bool) {
+ let (requested, priority) = match requested.strip_suffix("-fast") {
+ Some(base) if ALLOWED_MODELS.contains(&base) => (base, true),
+ _ => (requested, false),
+ };
+ let model = MODEL_ALIASES
+ .iter()
+ .find(|(alias, _)| *alias == requested)
+ .map(|(_, target)| *target)
+ .unwrap_or(requested);
+ (model.to_string(), priority)
+}
+
+fn has_native_hosted_web_search(object: &Map<String, Value>) -> bool {
+ object
+ .get("tools")
+ .and_then(Value::as_array)
+ .is_some_and(|tools| {
+ tools.iter().any(|tool| {
+ matches!(
+ tool.get("type").and_then(Value::as_str),
+ Some("web_search" | "web_search_preview")
+ )
+ })
+ })
+}
+
+fn local_codex_error(error: CodexError) -> Response {
+ let status = match error.status {
+ 401 => StatusCode::UNAUTHORIZED,
+ 403 => StatusCode::FORBIDDEN,
+ 429 => StatusCode::TOO_MANY_REQUESTS,
+ 400..=599 => StatusCode::from_u16(error.status).unwrap_or(StatusCode::BAD_GATEWAY),
+ _ => StatusCode::BAD_GATEWAY,
+ };
+ let kind = match status {
+ StatusCode::UNAUTHORIZED => "authentication_error",
+ StatusCode::FORBIDDEN => "permission_error",
+ StatusCode::TOO_MANY_REQUESTS => "rate_limit_error",
+ _ => "api_error",
+ };
+ let message = error.detail.as_deref().unwrap_or(&error.message);
+ let response = openai_error(status, kind, message, None, None);
+ if let Some(retry_after) = error.retry_after
+ && let Ok(value) = http::HeaderValue::from_str(&retry_after)
+ {
+ let (mut parts, body) = response.into_parts();
+ parts.headers.insert(http::header::RETRY_AFTER, value);
+ return Response::from_parts(parts, body);
+ }
+ response
+}
+
+pub fn openai_error(
+ status: StatusCode,
+ kind: &str,
+ message: impl Into<String>,
+ param: Option<&str>,
+ code: Option<&str>,
+) -> Response {
+ (
+ status,
+ axum::Json(json!({
+ "error": {
+ "message": message.into(),
+ "type": kind,
+ "param": param,
+ "code": code,
+ }
+ })),
+ )
+ .into_response()
+}
+
+#[derive(Clone, Default)]
+pub struct NativeResponseOutcome {
+ failure: Arc<Mutex<Option<String>>>,
+}
+
+impl NativeResponseOutcome {
+ pub fn failure(&self) -> Option<String> {
+ self.failure.lock().ok().and_then(|failure| failure.clone())
+ }
+
+ fn fail(&self, message: String) {
+ if let Ok(mut failure) = self.failure.lock()
+ && failure.is_none()
+ {
+ *failure = Some(message);
+ }
+ }
+}
+
+fn passthrough_response(
+ upstream: reqwest::Response,
+ ctx: RequestContext,
+ body_idle_timeout_ms: u64,
+) -> Response {
+ let status = upstream.status();
+ let headers = passthrough_headers(upstream.headers());
+ let is_sse = upstream
+ .headers()
+ .get(http::header::CONTENT_TYPE)
+ .and_then(|value| value.to_str().ok())
+ .is_some_and(|value| value.starts_with("text/event-stream"));
+ let outcome = NativeResponseOutcome::default();
+ let observer = NativeResponseObserver::new(ctx, is_sse, outcome.clone());
+ let state = Some(NativeBodyState {
+ stream: Box::pin(upstream.bytes_stream()),
+ observer,
+ body_idle_timeout_ms,
+ });
+ let stream = futures_util::stream::unfold(state, |state| async move {
+ let mut state = state?;
+ match tokio::time::timeout(
+ Duration::from_millis(state.body_idle_timeout_ms),
+ state.stream.next(),
+ )
+ .await
+ {
+ Ok(Some(Ok(chunk))) => {
+ state.observer.observe(&chunk);
+ Some((Ok::<Bytes, io::Error>(chunk), Some(state)))
+ }
+ Ok(Some(Err(error))) => {
+ let message = format!("Native Responses body read failed: {error}");
+ state.observer.finish("read_error");
+ Some((Err(io::Error::other(message)), None))
+ }
+ Ok(None) => {
+ state.observer.finish("complete");
+ None
+ }
+ Err(_) => {
+ let message = format!(
+ "Timed out waiting {}ms for the next Codex response body chunk",
+ state.body_idle_timeout_ms
+ );
+ state.observer.finish("idle_timeout");
+ Some((Err(io::Error::new(io::ErrorKind::TimedOut, message)), None))
+ }
+ }
+ });
+
+ let mut response = Response::new(Body::from_stream(stream));
+ *response.status_mut() = status;
+ *response.headers_mut() = headers;
+ response.extensions_mut().insert(outcome);
+ response
+}
+
+fn passthrough_headers(upstream: &HeaderMap) -> HeaderMap {
+ let mut headers = HeaderMap::new();
+ for (name, value) in upstream {
+ if native_response_header_allowed(name) {
+ headers.append(name.clone(), value.clone());
+ }
+ }
+ headers
+}
+
+fn native_response_header_allowed(name: &HeaderName) -> bool {
+ matches!(
+ name.as_str(),
+ "content-type"
+ | "cache-control"
+ | "retry-after"
+ | "x-request-id"
+ | "openai-processing-ms"
+ | "openai-version"
+ ) || name.as_str().starts_with("x-ratelimit-")
+}
+
+type UpstreamByteStream =
+ Pin<Box<dyn Stream<Item = Result<Bytes, reqwest::Error>> + Send + 'static>>;
+
+struct NativeBodyState {
+ stream: UpstreamByteStream,
+ observer: NativeResponseObserver,
+ body_idle_timeout_ms: u64,
+}
+
+struct NativeResponseObserver {
+ ctx: RequestContext,
+ is_sse: bool,
+ generation_started: bool,
+ raw: Vec<u8>,
+ raw_truncated: u64,
+ pending: Vec<u8>,
+ pending_scan: usize,
+ discarding_oversized_frame: bool,
+ pending_truncated: bool,
+ captured_events: Vec<Value>,
+ captured_event_bytes: usize,
+ captured_events_truncated: u64,
+ input_tokens: Option<u64>,
+ output_tokens: Option<u64>,
+ outcome: NativeResponseOutcome,
+ finished: bool,
+}
+
+impl NativeResponseObserver {
+ fn new(ctx: RequestContext, is_sse: bool, outcome: NativeResponseOutcome) -> Self {
+ Self {
+ ctx,
+ is_sse,
+ generation_started: false,
+ raw: Vec::with_capacity(64 * 1024),
+ raw_truncated: 0,
+ pending: Vec::new(),
+ pending_scan: 0,
+ discarding_oversized_frame: false,
+ pending_truncated: false,
+ captured_events: Vec::new(),
+ captured_event_bytes: 0,
+ captured_events_truncated: 0,
+ input_tokens: None,
+ output_tokens: None,
+ outcome,
+ finished: false,
+ }
+ }
+
+ fn observe(&mut self, chunk: &[u8]) {
+ if !chunk.is_empty() && !self.generation_started {
+ if let Some(monitor) = self.ctx.monitor.as_ref() {
+ monitor.generation_started(&self.ctx.req_id);
+ }
+ self.generation_started = true;
+ }
+ self.capture_raw(chunk);
+
+ let events = if self.is_sse {
+ self.pending.extend_from_slice(chunk);
+ self.drain_sse_events()
+ } else {
+ 0
+ };
+ if let Some(monitor) = self.ctx.monitor.as_ref() {
+ monitor.stream_progress(
+ &self.ctx.req_id,
+ chunk.len() as u64,
+ events,
+ self.input_tokens,
+ self.output_tokens,
+ );
+ }
+ }
+
+ fn capture_raw(&mut self, chunk: &[u8]) {
+ let remaining = MAX_SSE_CAPTURE_BYTES.saturating_sub(self.raw.len());
+ let captured = remaining.min(chunk.len());
+ self.raw.extend_from_slice(&chunk[..captured]);
+ if captured < chunk.len() {
+ self.raw_truncated = self
+ .raw_truncated
+ .saturating_add((chunk.len() - captured) as u64);
+ }
+ }
+
+ fn drain_sse_events(&mut self) -> u64 {
+ if self.discarding_oversized_frame {
+ let Some((end, separator_len)) = find_sse_boundary(&self.pending) else {
+ retain_boundary_prefix(&mut self.pending);
+ return 0;
+ };
+ self.pending.drain(..end + separator_len);
+ self.discarding_oversized_frame = false;
+ self.pending_scan = 0;
+ }
+
+ let mut consumed = 0;
+ let mut parsed = Vec::new();
+ while let Some((relative_end, separator_len)) =
+ find_sse_boundary_from(&self.pending, self.pending_scan)
+ {
+ let end = relative_end + separator_len;
+ parsed.extend(parse_sse_events(&self.pending[consumed..end]));
+ consumed = end;
+ self.pending_scan = consumed;
+ }
+ if consumed > 0 {
+ self.pending.drain(..consumed);
+ self.pending_scan = 0;
+ } else {
+ self.pending_scan = self.pending.len().saturating_sub(3);
+ }
+
+ let mut count = 0_u64;
+ for event in parsed {
+ count += 1;
+ if event.data == "[DONE]" {
+ continue;
+ }
+ match serde_json::from_str::<Value>(&event.data) {
+ Ok(value) => self.record_event(event.event.as_deref(), value),
+ Err(_) => self.capture_event(json!({
+ "event": event.event,
+ "unparseable": true,
+ "bytes": event.data.len(),
+ })),
+ }
+ }
+
+ if self.pending.len() > MAX_STREAM_CAPTURE_FRAME_BYTES {
+ self.pending_truncated = true;
+ self.discarding_oversized_frame = true;
+ retain_boundary_prefix(&mut self.pending);
+ self.pending_scan = 0;
+ }
+ count
+ }
+
+ fn record_event(&mut self, event: Option<&str>, value: Value) {
+ self.update_usage(&value);
+ self.update_outcome(&value);
+ let mut captured = value;
+ if let Some(event) = event
+ && let Some(object) = captured.as_object_mut()
+ {
+ object
+ .entry("_sse_event")
+ .or_insert_with(|| Value::String(event.to_string()));
+ }
+ self.capture_event(captured);
+ }
+
+ fn capture_event(&mut self, value: Value) {
+ if self.ctx.traffic.is_none() {
+ return;
+ }
+ let bytes = serde_json::to_vec(&value).map_or(0, |value| value.len());
+ if self.captured_events.len() < MAX_STREAM_CAPTURE_EVENTS
+ && self.captured_event_bytes.saturating_add(bytes) <= MAX_STREAM_CAPTURE_EVENT_BYTES
+ {
+ self.captured_event_bytes += bytes;
+ self.captured_events.push(value);
+ } else {
+ self.captured_events_truncated = self.captured_events_truncated.saturating_add(1);
+ }
+ }
+
+ fn update_outcome(&self, value: &Value) {
+ let event_type = value.get("type").and_then(Value::as_str);
+ let has_error = value.get("error").is_some_and(|error| !error.is_null());
+ let failed_status = value.get("status").and_then(Value::as_str) == Some("failed");
+ if matches!(
+ event_type,
+ Some("response.failed" | "response.error" | "error")
+ ) || has_error
+ || failed_status
+ {
+ let message = value
+ .pointer("/response/error/message")
+ .or_else(|| value.pointer("/error/message"))
+ .or_else(|| value.get("message"))
+ .and_then(Value::as_str)
+ .unwrap_or("Native Responses stream failed");
+ self.outcome.fail(message.to_string());
+ }
+ }
+
+ fn update_usage(&mut self, value: &Value) {
+ let usage = value
+ .pointer("/response/usage")
+ .or_else(|| value.get("usage"));
+ if let Some(usage) = usage {
+ self.input_tokens = usage
+ .get("input_tokens")
+ .and_then(Value::as_u64)
+ .or(self.input_tokens);
+ self.output_tokens = usage
+ .get("output_tokens")
+ .and_then(Value::as_u64)
+ .or(self.output_tokens);
+ }
+ }
+
+ fn finish(&mut self, outcome: &str) {
+ if self.finished {
+ return;
+ }
+ self.finished = true;
+ if !self.is_sse
+ && let Ok(value) = serde_json::from_slice::<Value>(&self.raw)
+ {
+ self.update_usage(&value);
+ self.update_outcome(&value);
+ self.capture_event(value);
+ if let Some(monitor) = self.ctx.monitor.as_ref() {
+ monitor.usage_updated(&self.ctx.req_id, self.input_tokens, self.output_tokens);
+ }
+ }
+ self.write_capture(outcome);
+ }
+
+ fn write_capture(&self, outcome: &str) {
+ let Some(traffic) = self.ctx.traffic.as_deref() else {
+ return;
+ };
+ if !self.raw.is_empty() {
+ traffic.write_bytes(
+ if self.is_sse {
+ "032-upstream-response-body.sse"
+ } else {
+ "032-upstream-response-body.json"
+ },
+ &self.raw,
+ );
+ }
+ for event in &self.captured_events {
+ traffic.write_json_event("040-upstream-event", event);
+ }
+ traffic.write_json(
+ "033-native-response-capture",
+ &json!({
+ "outcome": outcome,
+ "capturedBytes": self.raw.len(),
+ "truncatedBytes": self.raw_truncated,
+ "pendingFrameTruncated": self.pending_truncated,
+ "capturedEvents": self.captured_events.len(),
+ "capturedEventBytes": self.captured_event_bytes,
+ "truncatedEvents": self.captured_events_truncated,
+ "inputTokens": self.input_tokens,
+ "outputTokens": self.output_tokens,
+ }),
+ );
+ }
+}
+
+impl Drop for NativeResponseObserver {
+ fn drop(&mut self) {
+ if !self.finished {
+ self.finish("downstream_cancelled");
+ }
+ }
+}
+
+fn find_sse_boundary(bytes: &[u8]) -> Option<(usize, usize)> {
+ find_sse_boundary_from(bytes, 0)
+}
+
+fn find_sse_boundary_from(bytes: &[u8], start: usize) -> Option<(usize, usize)> {
+ for index in start.min(bytes.len())..bytes.len() {
+ if bytes[index..].starts_with(b"\r\n\r\n") {
+ return Some((index, 4));
+ }
+ if bytes[index..].starts_with(b"\n\n") || bytes[index..].starts_with(b"\r\r") {
+ return Some((index, 2));
+ }
+ }
+ None
+}
+
+fn retain_boundary_prefix(bytes: &mut Vec<u8>) {
+ let keep = bytes.len().min(3);
+ if bytes.len() > keep {
+ bytes.drain(..bytes.len() - keep);
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ fn request(body: Value) -> Value {
+ body
+ }
+
+ fn observer_context() -> RequestContext {
+ RequestContext {
+ req_id: "native-test".into(),
+ session_id: None,
+ session_seq: None,
+ provider: "codex".into(),
+ traffic: None,
+ monitor: None,
+ }
+ }
+
+ #[test]
+ fn failed_sse_event_records_native_outcome() {
+ let outcome = NativeResponseOutcome::default();
+ let mut observer = NativeResponseObserver::new(observer_context(), true, outcome.clone());
+ observer.observe(
+ b"event: response.failed\ndata: {\"type\":\"response.failed\",\"response\":{\"error\":{\"message\":\"generation failed\"}}}\n\n",
+ );
+
+ assert_eq!(outcome.failure().as_deref(), Some("generation failed"));
+ }
+
+ #[test]
+ fn completed_json_with_null_error_stays_successful() {
+ let outcome = NativeResponseOutcome::default();
+ let mut observer = NativeResponseObserver::new(observer_context(), false, outcome.clone());
+ observer
+ .observe(br#"{"id":"resp_ok","object":"response","status":"completed","error":null}"#);
+ observer.finish("complete");
+
+ assert_eq!(outcome.failure(), None);
+ }
+
+ #[test]
+ fn failed_json_records_error_message() {
+ let outcome = NativeResponseOutcome::default();
+ let mut observer = NativeResponseObserver::new(observer_context(), false, outcome.clone());
+ observer.observe(
+ br#"{"id":"resp_failed","object":"response","status":"failed","error":{"message":"request failed"}}"#,
+ );
+ observer.finish("complete");
+
+ assert_eq!(outcome.failure().as_deref(), Some("request failed"));
+ }
+
+ #[test]
+ fn response_error_event_records_failure() {
+ let outcome = NativeResponseOutcome::default();
+ let mut observer = NativeResponseObserver::new(observer_context(), true, outcome.clone());
+ observer.observe(
+ b"event: response.error\ndata: {\"type\":\"response.error\",\"response\":{\"error\":{\"message\":\"stream error\"}}}\n\n",
+ );
+
+ assert_eq!(outcome.failure().as_deref(), Some("stream error"));
+ }
+
+ #[test]
+ fn event_capture_obeys_count_limit() {
+ let temp = tempfile::TempDir::new().unwrap();
+ let outcome = NativeResponseOutcome::default();
+ let mut context = observer_context();
+ context.traffic = Some(Arc::new(crate::traffic::test_capture(
+ temp.path().to_path_buf(),
+ )));
+ let mut observer = NativeResponseObserver::new(context, true, outcome);
+ for index in 0..MAX_STREAM_CAPTURE_EVENTS + 10 {
+ observer.capture_event(json!({"index": index}));
+ }
+
+ assert_eq!(observer.captured_events.len(), MAX_STREAM_CAPTURE_EVENTS);
+ assert_eq!(observer.captured_events_truncated, 10);
+ observer.finished = true;
+ }
+
+ #[test]
+ fn native_request_requires_object_and_model() {
+ assert!(shape_native_request(&mut json!([])).is_err());
+ assert!(shape_native_request(&mut json!({})).is_err());
+ assert!(shape_native_request(&mut json!({"model": 7})).is_err());
+ }
+
+ #[test]
+ fn native_request_resolves_alias_and_fast_tier() {
+ let mut body = request(json!({"model":"claude-opus-4-8","input":[]}));
+ let resolved = shape_native_request(&mut body).unwrap();
+ assert_eq!(resolved.model, "gpt-5.6-sol");
+ assert_eq!(body["model"], "gpt-5.6-sol");
+ assert!(resolved.use_responses_lite);
+
+ let mut fast = request(json!({"model":"gpt-5.4-fast","input":[]}));
+ let resolved = shape_native_request(&mut fast).unwrap();
+ assert_eq!(resolved.model, "gpt-5.4");
+ assert_eq!(fast["service_tier"], "priority");
+ }
+
+ #[test]
+ fn explicit_service_tier_is_preserved() {
+ let mut body = request(json!({
+ "model":"gpt-5.4-fast",
+ "service_tier":"flex",
+ "input":[]
+ }));
+ shape_native_request(&mut body).unwrap();
+ assert_eq!(body["service_tier"], "flex");
+ }
+
+ #[test]
+ fn hosted_search_uses_full_lane_and_upgrades_luna() {
+ for tool_type in ["web_search", "web_search_preview"] {
+ let mut body = request(json!({
+ "model":"gpt-5.6-luna",
+ "tools":[{"type":tool_type}],
+ "input":[]
+ }));
+ let resolved = shape_native_request(&mut body).unwrap();
+ assert_eq!(resolved.model, "gpt-5.6-sol");
+ assert!(!resolved.use_responses_lite);
+ }
+ }
+
+ #[tokio::test]
+ async fn openai_error_has_native_envelope() {
+ let response = openai_error(
+ StatusCode::BAD_REQUEST,
+ "invalid_request_error",
+ "bad model",
+ Some("model"),
+ Some("invalid"),
+ );
+ let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
+ .await
+ .unwrap();
+ let value: Value = serde_json::from_slice(&bytes).unwrap();
+ assert!(value.get("type").is_none());
+ assert_eq!(value["error"]["type"], "invalid_request_error");
+ assert_eq!(value["error"]["param"], "model");
+ assert_eq!(value["error"]["code"], "invalid");
+ }
+
+ #[test]
+ fn response_headers_use_allowlist() {
+ let mut upstream = HeaderMap::new();
+ upstream.insert(
+ http::header::CONTENT_TYPE,
+ "text/event-stream".parse().unwrap(),
+ );
+ upstream.insert(http::header::SET_COOKIE, "secret=1".parse().unwrap());
+ upstream.insert(http::header::CONTENT_LENGTH, "12".parse().unwrap());
+ upstream.insert("x-request-id", "req_1".parse().unwrap());
+ upstream.insert("x-ratelimit-remaining-requests", "2".parse().unwrap());
+
+ let headers = passthrough_headers(&upstream);
+ assert_eq!(
+ headers.get(http::header::CONTENT_TYPE).unwrap(),
+ "text/event-stream"
+ );
+ assert_eq!(headers.get("x-request-id").unwrap(), "req_1");
+ assert_eq!(headers.get("x-ratelimit-remaining-requests").unwrap(), "2");
+ assert!(headers.get(http::header::SET_COOKIE).is_none());
+ assert!(headers.get(http::header::CONTENT_LENGTH).is_none());
+ }
+
+ #[test]
+ fn sse_boundary_handles_lf_and_crlf() {
+ assert_eq!(find_sse_boundary(b"data: {}\n\nnext"), Some((8, 2)));
+ assert_eq!(find_sse_boundary(b"data: {}\r\n\r\nnext"), Some((8, 4)));
+ assert_eq!(find_sse_boundary(b"data: {}"), None);
+ }
+}
diff --git a/src/server.rs b/src/server.rs
index fe259f6..cd896b6 100644
--- a/src/server.rs
+++ b/src/server.rs
@@ -4,6 +4,9 @@ use crate::{
monitor::{EndpointKind, MonitorHandle},
project,
provider::RequestContext,
+ providers::codex::native::{
+ CodexNativeBackend, NativeResponseOutcome, openai_error, validate_native_request_model,
+ },
registry::{Registry, normalize_incoming_model},
session::{self, SessionState},
traffic::{TrafficCaptureOptions, create_traffic_capture},
@@ -96,24 +99,42 @@ pub async fn serve_listener(
}
pub fn app(registry: Arc<Registry>) -> Router {
- app_with_monitor(registry, None)
+ app_with_options(registry, None, crate::config::codex_responses_api())
}
pub fn app_with_monitor(registry: Arc<Registry>, monitor: Option<MonitorHandle>) -> Router {
- let state = Arc::new(AppState { registry, monitor });
- Router::new()
+ app_with_options(registry, monitor, crate::config::codex_responses_api())
+}
+
+pub fn app_with_options(
+ registry: Arc<Registry>,
+ monitor: Option<MonitorHandle>,
+ responses_api: bool,
+) -> Router {
+ let native_responses = responses_api.then(|| Arc::new(CodexNativeBackend::new()));
+ let state = Arc::new(AppState {
+ registry,
+ monitor,
+ native_responses,
+ });
+ let router = Router::new()
.route("/healthz", get(healthz))
.route("/v1/messages", post(handler_messages))
.route("/v1/messages/count_tokens", post(handler_count_tokens))
- .route("/v1/models", get(handler_models))
- .fallback(fallback_handler)
- .with_state(state)
+ .route("/v1/models", get(handler_models));
+ let router = if responses_api {
+ router.route("/v1/responses", post(handler_responses))
+ } else {
+ router
+ };
+ router.fallback(fallback_handler).with_state(state)
}
#[derive(Clone)]
struct AppState {
registry: Arc<Registry>,
monitor: Option<MonitorHandle>,
+ native_responses: Option<Arc<CodexNativeBackend>>,
}
async fn healthz() -> Json<serde_json::Value> {
@@ -166,6 +187,203 @@ async fn handler_count_tokens(State(state): State<Arc<AppState>>, req: Request<B
dispatch_request(state, req, true).await
}
+async fn handler_responses(State(state): State<Arc<AppState>>, req: Request<Body>) -> Response {
+ let started_at = Instant::now();
+ let log = create_logger("server");
+ let req_id = Uuid::new_v4().to_string();
+ let method = req.method().clone();
+ let uri = req.uri().clone();
+ let headers = req.headers().clone();
+ let path = uri.path().to_string();
+ let query = redacted_query(&uri);
+ log.info(
+ "request",
+ Some(serde_json::Map::from_iter([
+ ("reqId".to_string(), json!(&req_id)),
+ ("method".to_string(), json!(method.as_str())),
+ ("path".to_string(), json!(&path)),
+ ("query".to_string(), json!(&query)),
+ ])),
+ );
+
+ let session_id = native_session_id(&headers);
+ if let Some(monitor) = state.monitor.as_ref() {
+ monitor.request_started(&req_id, session_id.clone(), None, EndpointKind::Responses);
+ }
+ let request_guard = RequestMonitorGuard::new(state.monitor.clone(), req_id.clone());
+ let body_bytes = match axum::body::to_bytes(req.into_body(), usize::MAX).await {
+ Ok(bytes) => bytes,
+ Err(error) => {
+ let response = openai_error(
+ StatusCode::BAD_REQUEST,
+ "invalid_request_error",
+ format!("Invalid JSON: {error}"),
+ None,
+ Some("invalid_json"),
+ );
+ log_native_request_completed(&log, &req_id, None, response.status(), started_at);
+ return monitor_response_body(response, request_guard);
+ }
+ };
+ let body: Value = match parse_native_json_body(&body_bytes) {
+ Ok(body) => body,
+ Err(response) => {
+ log_native_request_completed(&log, &req_id, None, response.status(), started_at);
+ return monitor_response_body(response, request_guard);
+ }
+ };
+ if let Err(response) = validate_native_request_model(&body) {
+ log_native_request_completed(&log, &req_id, None, response.status(), started_at);
+ return monitor_response_body(response, request_guard);
+ }
+ let model = body
+ .get("model")
+ .and_then(Value::as_str)
+ .map(normalize_incoming_model);
+ let effort = body
+ .pointer("/reasoning/effort")
+ .and_then(Value::as_str)
+ .map(str::to_string);
+ let now = current_millis();
+ let session_state = if let Some(session_id) = session_id.as_deref() {
+ session::existing_session(Some(session_id), now)
+ } else {
+ None
+ };
+ let current = model.as_deref().and_then(|model| {
+ session::record_session_request(
+ session_id.as_deref(),
+ session_state.as_ref(),
+ "codex",
+ model,
+ now,
+ )
+ });
+ if let Some(monitor) = state.monitor.as_ref() {
+ if let Some(current) = current.as_ref() {
+ monitor.session_sequence_resolved(&req_id, current.seq);
+ }
+ if let Some(model) = model.as_deref() {
+ monitor.provider_selected(&req_id, "codex", model, effort);
+ }
+ }
+
+ let traffic = create_traffic_capture(TrafficCaptureOptions {
+ req_id: req_id.clone(),
+ session_id: session_id.clone(),
+ session_seq: current.as_ref().map(|state| state.seq),
+ provider: Some("codex".to_string()),
+ state_dir_override: None,
+ })
+ .map(Arc::new);
+ if let Some(capture) = traffic.as_ref() {
+ if let Some(monitor) = state.monitor.as_ref() {
+ monitor.traffic_capture_path(&req_id, capture.root().to_path_buf());
+ }
+ capture.write_json(
+ "000-metadata",
+ &json!({
+ "reqId": &req_id,
+ "sessionId": &session_id,
+ "sessionSeq": current.as_ref().map(|state| state.seq),
+ "kind": "responses",
+ "provider": "codex",
+ "model": &model,
+ "method": method.as_str(),
+ "path": &path,
+ "query": &query,
+ "headers": headers_to_record(&headers),
+ }),
+ );
+ capture.write_json("010-openai-responses-request", &body);
+ }
+
+ let context = RequestContext {
+ req_id: req_id.clone(),
+ session_id,
+ session_seq: current.map(|state| state.seq),
+ provider: "codex".to_string(),
+ traffic,
+ monitor: state.monitor.clone(),
+ };
+ let response = match state.native_responses.as_ref() {
+ Some(backend) => backend.handle(body, context).await,
+ None => openai_error(
+ StatusCode::NOT_FOUND,
+ "not_found_error",
+ "Native Responses API is disabled",
+ None,
+ None,
+ ),
+ };
+ log_native_request_completed(
+ &log,
+ &req_id,
+ model.as_deref(),
+ response.status(),
+ started_at,
+ );
+ monitor_response_body(response, request_guard)
+}
+
+fn native_session_id(headers: &http::HeaderMap) -> Option<String> {
+ [
+ "x-claude-code-session-id",
+ "session_id",
+ "x-client-request-id",
+ ]
+ .into_iter()
+ .find_map(|name| {
+ headers
+ .get(name)
+ .and_then(|value| value.to_str().ok())
+ .filter(|value| !value.is_empty())
+ .map(str::to_string)
+ })
+}
+
+fn parse_native_json_body(body: &[u8]) -> Result<Value, Response> {
+ if body.is_empty() {
+ return Err(openai_error(
+ StatusCode::BAD_REQUEST,
+ "invalid_request_error",
+ "Invalid JSON: empty body",
+ None,
+ Some("invalid_json"),
+ ));
+ }
+ serde_json::from_slice(body).map_err(|error| {
+ openai_error(
+ StatusCode::BAD_REQUEST,
+ "invalid_request_error",
+ format!("Invalid JSON: {error}"),
+ None,
+ Some("invalid_json"),
+ )
+ })
+}
+
+fn log_native_request_completed(
+ log: &Logger,
+ req_id: &str,
+ model: Option<&str>,
+ status: StatusCode,
+ started_at: Instant,
+) {
+ log.info(
+ "request_completed",
+ Some(serde_json::Map::from_iter([
+ ("reqId".to_string(), json!(req_id)),
+ ("endpoint".to_string(), json!("responses")),
+ ("provider".to_string(), json!("codex")),
+ ("model".to_string(), json!(model)),
+ ("countTokens".to_string(), json!(false)),
+ ("status".to_string(), json!(status.as_u16())),
+ ("ms".to_string(), json!(started_at.elapsed().as_millis())),
+ ])),
+ );
+}
+
async fn dispatch_request(
state: Arc<AppState>,
req: Request<Body>,
@@ -532,21 +750,34 @@ async fn dispatch_request(
fn monitor_response_body(response: Response, guard: RequestMonitorGuard) -> Response {
let status = response.status();
+ let outcome = response
+ .extensions()
+ .get::<NativeResponseOutcome>()
+ .cloned();
let (parts, body) = response.into_parts();
- let stream =
- futures_util::stream::unfold((body, guard), move |(mut body, mut guard)| async move {
+ let stream = futures_util::stream::unfold(
+ (body, guard, outcome),
+ move |(mut body, mut guard, outcome)| async move {
match body.frame().await {
- Some(Ok(frame)) => Some((Ok(frame), (body, guard))),
+ Some(Ok(frame)) => Some((Ok(frame), (body, guard, outcome))),
Some(Err(err)) => {
guard.failed(status, err.to_string());
- Some((Err(err), (body, guard)))
+ Some((Err(err), (body, guard, outcome)))
}
None => {
- guard.completed(status);
+ if let Some(message) = outcome.as_ref().and_then(NativeResponseOutcome::failure)
+ {
+ guard.failed(status, message);
+ } else if status.is_success() {
+ guard.completed(status);
+ } else {
+ guard.failed(status, format!("HTTP {}", status.as_u16()));
+ }
None
}
}
- });
+ },
+ );
Response::from_parts(parts, Body::new(StreamBody::new(stream)))
}
diff --git a/tests/server.rs b/tests/server.rs
index f834adb..ae6d089 100644
--- a/tests/server.rs
+++ b/tests/server.rs
@@ -3,7 +3,7 @@ use axum::http::{Method, Request, StatusCode};
use claude_code_proxy::{
monitor::{MonitorHandle, RequestStatus},
registry::Registry,
- server::{app, app_with_monitor, bind_proxy_listener},
+ server::{app, app_with_monitor, app_with_options, bind_proxy_listener},
};
use serde_json::{Value, json};
use std::sync::Arc;
@@ -231,6 +231,50 @@ async fn context_window_hint_is_removed_before_provider_dispatch() {
assert_eq!(response.status(), StatusCode::OK);
}
+#[tokio::test]
+async fn native_responses_route_is_disabled_by_default_option() {
+ let app = app_with_options(Arc::new(Registry::with_default_alias()), None, false);
+ let response = app
+ .oneshot(
+ Request::builder()
+ .method(Method::POST)
+ .uri("/v1/responses")
+ .header("content-type", "application/json")
+ .body(body_string(r#"{"model":"gpt-5.4","input":"hello"}"#))
+ .unwrap(),
+ )
+ .await
+ .unwrap();
+
+ assert_eq!(response.status(), StatusCode::NOT_FOUND);
+}
+
+#[tokio::test]
+async fn enabled_native_responses_route_uses_openai_errors() {
+ let app = app_with_options(Arc::new(Registry::with_default_alias()), None, true);
+ let response = app
+ .oneshot(
+ Request::builder()
+ .method(Method::POST)
+ .uri("/v1/responses")
+ .header("content-type", "application/json")
+ .body(body_string("{"))
+ .unwrap(),
+ )
+ .await
+ .unwrap();
+
+ assert_eq!(response.status(), StatusCode::BAD_REQUEST);
+ 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!(body.get("type").is_none());
+ assert_eq!(body["error"]["type"], "invalid_request_error");
+ assert_eq!(body["error"]["code"], "invalid_json");
+}
+
#[tokio::test]
async fn unknown_routes_use_anthropic_not_found_error() {
let app = app(Arc::new(Registry::with_default_alias()));