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.mdindex 298ca30..26da024 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -5,6 +5,10 @@- Codex optionally preserves conversation continuity across Claude Codecompaction boundaries with native encrypted compaction artifacts. Enable itwith `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.mdindex 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 usedin its place. Invalid types for individual keys are warned and skipped withoutaffecting 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 orcompatibility, or `CCP_CODEX_TRANSPORT=auto` to try WebSocket with HTTP fallbackdiff --git a/src/config.rs b/src/config.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsnew file mode 100644index 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.rsindex 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<Bdispatch_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.rsindex 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()));