Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy
Rust
add OpenAI Chat Completions compatibility
Raine Virta7088be5b3fa1
diff --git a/docs/src/content/docs/providers/codex.md b/docs/src/content/docs/providers/codex.mdindex 13d95c4..a2734b5 100644--- a/docs/src/content/docs/providers/codex.md+++ b/docs/src/content/docs/providers/codex.md@@ -1,6 +1,6 @@---title: Codex-description: Configure ChatGPT Codex authentication, models, reasoning, tools, images, transports, continuation, compaction, and native Responses passthrough.+description: Configure ChatGPT Codex authentication, models, reasoning, tools, images, transports, continuation, compaction, and OpenAI-compatible APIs.---Codex uses the ChatGPT subscription Responses endpoint at `https://chatgpt.com/backend-api/codex/responses`.@@ -89,8 +89,12 @@ Replay requires the same Claude Code session and Codex model with append-only hiWhile the native request is active, the monitor shows `compacting`. Structured log events named `server_compaction_triggered`, `server_compaction_completed`, and `server_compaction_failed` report each attempt and outcome.-## Native Responses API+## OpenAI-compatible APIs-`CCP_CODEX_RESPONSES_API=1` enables `POST /v1/responses`. The proxy replaces incoming credentials with stored Codex auth and preserves native JSON or SSE response bodies. This route covers registered Codex models. Images API, response retrieval or deletion, and WebSocket ingress are outside its scope.+`CCP_CODEX_RESPONSES_API=1` enables both `POST /v1/responses` and `POST /v1/chat/completions`.++The Responses route preserves native JSON or SSE response bodies for registered Codex models. The Chat Completions route translates standard text messages, reasoning effort, JSON object or JSON Schema output, and buffered or streaming responses. Its omitted reasoning effort defaults to `medium`; the proxy-wide Codex effort override still takes precedence.++The proxy replaces incoming credentials with stored Codex auth for both routes. Images API, response retrieval or deletion, function calling through Chat Completions, and WebSocket ingress are outside their scope. See [HTTP API](/reference/http-api/) for supported Chat Completions fields and error behavior.See [Configuration](/reference/configuration/) for every Codex setting and [Troubleshooting](/using/troubleshooting/) for auth, model, and transport failures.diff --git a/docs/src/content/docs/reference/configuration.md b/docs/src/content/docs/reference/configuration.mdindex 66cdb8c..c37988e 100644--- a/docs/src/content/docs/reference/configuration.md+++ b/docs/src/content/docs/reference/configuration.md@@ -78,7 +78,7 @@ All keys are optional. An unreadable file, malformed JSON, or incompatible field| `CCP_CODEX_TRANSPORT` | `codex.transport` | `websocket` | Selects `websocket`, `http`, or `auto`. || `CCP_CODEX_PREVIOUS_RESPONSE_ID` | `codex.previousResponseId` | `false` | Enables append-only WebSocket continuation for `1`, `true`, or `yes`. || `CCP_CODEX_SERVER_COMPACTION` | `codex.serverCompaction` | `false` | Enables or disables native compaction for standard boolean words. |-| `CCP_CODEX_RESPONSES_API` | `codex.responsesApi` | `false` | Enables `/v1/responses` for `1`, `true`, or `yes`. |+| `CCP_CODEX_RESPONSES_API` | `codex.responsesApi` | `false` | Enables `/v1/responses` and `/v1/chat/completions` for `1`, `true`, or `yes`. || `CCP_CODEX_ORIGINATOR` | `codex.originator` | `claude-code-proxy` | Changes the Codex `originator` header. || `CCP_CODEX_USER_AGENT` | `codex.userAgent` | `claude-code-proxy/<version>` | Changes the Codex user-agent. |diff --git a/docs/src/content/docs/reference/http-api.md b/docs/src/content/docs/reference/http-api.mdindex 4fd7bc0..b49fea9 100644--- a/docs/src/content/docs/reference/http-api.md+++ b/docs/src/content/docs/reference/http-api.md@@ -1,9 +1,9 @@---title: HTTP API-description: Canonical local HTTP routes for liveness, Anthropic Messages, token counting, model discovery, and optional native Codex Responses passthrough.+description: Canonical local HTTP routes for liveness, Anthropic Messages, token counting, model discovery, and optional Codex-backed OpenAI APIs.----The server speaks the subset of Anthropic and OpenAI protocols needed by Claude Code and the optional Codex native passthrough.+The server speaks the Anthropic and OpenAI protocol subsets needed by Claude Code and Codex-backed OpenAI-compatible clients.<div class="security-callout"><strong>No client authentication.</strong> The listener accepts requests without validating `Authorization` or `x-api-key`. Loopback is the default. Protect every non-loopback listener with a firewall or authenticating reverse proxy.@@ -62,6 +62,26 @@ An optional `limit` query truncates `data` and sets `has_more`. The route does nClaude Code gateway discovery filters IDs according to its own model rules. See [Models and routing](/using/models-and-routing/).+## `POST /v1/chat/completions`++This route exists only when `CCP_CODEX_RESPONSES_API=1` or `codex.responsesApi` is true. It translates OpenAI Chat Completions requests into Codex Responses Lite requests. Incoming bearer credentials are accepted and replaced with the proxy's stored Codex authentication.++The compatibility surface supports:++- text messages with `system`, `developer`, `user`, and `assistant` roles+- streaming and buffered responses+- `reasoning_effort` values `none`, `low`, `medium`, `high`, `xhigh`, and `max`+- `response_format` values `text`, `json_object`, and strict `json_schema`+- `stream_options.include_usage`+- `temperature` and `top_p` on Codex models that use the full Responses lane+- `user` as a Responses safety identifier++Omitted reasoning effort defaults to `medium`. `CCP_CODEX_EFFORT` or `codex.effort` takes precedence over the request. Every translated request uses `store: false`, upstream streaming, and `reasoning.context: "all_turns"`.++A buffered response uses the standard `chat.completion` object. A streaming response emits `chat.completion.chunk` events and ends with `data: [DONE]`.++Function calls, hosted tools, images, audio, log probabilities, multiple choices, storage, and output token limits are outside this compatibility surface. Unsupported fields, including `max_tokens` and `max_completion_tokens`, return an OpenAI `invalid_request_error` with the field in `error.param`.+## `POST /v1/responses`This route exists only when `CCP_CODEX_RESPONSES_API=1` or `codex.responsesApi` is true. It accepts a native OpenAI Responses request for a registered Codex model.diff --git a/src/monitor.rs b/src/monitor.rsindex eaa2f22..b87b373 100644--- a/src/monitor.rs+++ b/src/monitor.rs@@ -17,6 +17,7 @@ pub enum EndpointKind {Messages,CountTokens,Responses,+ ChatCompletions,}impl EndpointKind {@@ -25,6 +26,7 @@ impl EndpointKind {Self::Messages => "messages",Self::CountTokens => "count_tokens",Self::Responses => "responses",+ Self::ChatCompletions => "chat_completions",}}}diff --git a/src/providers/codex/chat_completions/mod.rs b/src/providers/codex/chat_completions/mod.rsnew file mode 100644index 0000000..eb816c3--- /dev/null+++ b/src/providers/codex/chat_completions/mod.rs@@ -0,0 +1,471 @@+pub mod request;+pub mod response;+pub mod stream;++use std::{sync::Arc, time::Duration};++use axum::{+ Json,+ response::{IntoResponse, Response},+};+use futures_util::StreamExt;+use http::StatusCode;+use serde_json::{Value, json};++use crate::provider::RequestContext;++use super::client::{CodexError, CodexHttpClient};+use request::TranslatedRequest;++pub struct ChatCompletionsBackend {+ client: Arc<CodexHttpClient>,+}++impl Default for ChatCompletionsBackend {+ fn default() -> Self {+ Self::new()+ }+}++impl ChatCompletionsBackend {+ pub fn new() -> Self {+ Self {+ client: Arc::new(CodexHttpClient::new()),+ }+ }++ #[cfg(test)]+ fn with_client(client: CodexHttpClient) -> Self {+ Self {+ client: Arc::new(client),+ }+ }++ pub async fn handle(&self, request: TranslatedRequest, ctx: RequestContext) -> Response {+ if let Some(monitor) = ctx.monitor.as_ref() {+ monitor.model_resolved(&ctx.req_id, &request.model);+ monitor.upstream_started(&ctx.req_id);+ }+ let upstream = match self+ .client+ .post_native_responses(&request.upstream, &ctx, request.use_responses_lite, true)+ .await+ {+ Ok(upstream) => upstream,+ Err(error) => return codex_error_response(error),+ };++ if !upstream.status().is_success() {+ return upstream_error_response(upstream, self.client.body_idle_timeout_ms()).await;+ }+ if request.stream {+ return stream::streaming_response(+ upstream,+ ctx,+ request.model,+ request.include_usage,+ self.client.body_idle_timeout_ms(),+ );+ }++ let headers = stream::response_headers(upstream.headers());+ let bytes =+ match collect_body(upstream, self.client.body_idle_timeout_ms(), Some(&ctx)).await {+ Ok(bytes) => bytes,+ Err(error) => return error.response(),+ };+ if let Some(traffic) = ctx.traffic.as_deref() {+ traffic.write_bytes("032-upstream-response-body.sse", &bytes);+ }+ let completion = match response::aggregate_sse(&bytes, &request.model) {+ Ok(completion) => completion,+ Err(error) => return error.response(),+ };+ if let Some(usage) = completion.get("usage")+ && let Some(monitor) = ctx.monitor.as_ref()+ {+ monitor.usage_updated(+ &ctx.req_id,+ usage.get("prompt_tokens").and_then(Value::as_u64),+ usage.get("completion_tokens").and_then(Value::as_u64),+ );+ }+ if let Some(traffic) = ctx.traffic.as_deref() {+ traffic.write_json("050-openai-chat-completion-response", &completion);+ }+ let mut downstream = Json(completion).into_response();+ *downstream.headers_mut() = headers;+ downstream.headers_mut().insert(+ http::header::CONTENT_TYPE,+ http::HeaderValue::from_static("application/json"),+ );+ downstream+ }+}++async fn collect_body(+ upstream: reqwest::Response,+ idle_timeout_ms: u64,+ ctx: Option<&RequestContext>,+) -> Result<Vec<u8>, ChatError> {+ let mut stream = upstream.bytes_stream();+ let mut bytes = Vec::new();+ let mut started = false;+ loop {+ match tokio::time::timeout(Duration::from_millis(idle_timeout_ms), stream.next()).await {+ Ok(Some(Ok(chunk))) => {+ if !started {+ if let Some(ctx) = ctx+ && let Some(monitor) = ctx.monitor.as_ref()+ {+ monitor.generation_started(&ctx.req_id);+ }+ started = true;+ }+ bytes.extend_from_slice(&chunk);+ if let Some(ctx) = ctx+ && let Some(monitor) = ctx.monitor.as_ref()+ {+ monitor.stream_progress(&ctx.req_id, chunk.len() as u64, 0, None, None);+ }+ }+ Ok(Some(Err(error))) => {+ return Err(ChatError::upstream(format!(+ "Codex response body read failed: {error}"+ )));+ }+ Ok(None) => return Ok(bytes),+ Err(_) => {+ return Err(ChatError::timeout(format!(+ "Timed out waiting {idle_timeout_ms}ms for the next Codex response body chunk"+ )));+ }+ }+ }+}++fn codex_error_response(error: CodexError) -> Response {+ let retry_after = error.retry_after.clone();+ let response = ChatError::from_codex(error).response();+ if let Some(retry_after) = 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);+ Response::from_parts(parts, body)+ } else {+ response+ }+}++async fn upstream_error_response(upstream: reqwest::Response, idle_timeout_ms: u64) -> Response {+ let status = upstream.status();+ let retry_after = upstream.headers().get(http::header::RETRY_AFTER).cloned();+ let bytes = match collect_body(upstream, idle_timeout_ms, None).await {+ Ok(bytes) => bytes,+ Err(error) => return error.response(),+ };+ let message = serde_json::from_slice::<Value>(&bytes)+ .ok()+ .and_then(|value| {+ value+ .pointer("/error/message")+ .or_else(|| value.get("message"))+ .or_else(|| value.get("detail"))+ .and_then(Value::as_str)+ .map(str::to_string)+ })+ .filter(|message| !message.is_empty())+ .unwrap_or_else(|| format!("Codex request failed with status {}", status.as_u16()));+ let kind = match status {+ StatusCode::UNAUTHORIZED => "authentication_error",+ StatusCode::FORBIDDEN => "permission_error",+ StatusCode::TOO_MANY_REQUESTS => "rate_limit_error",+ _ => "api_error",+ };+ let response = ChatError::new(status, kind, message, None, None).response();+ if let Some(retry_after) = retry_after {+ let (mut parts, body) = response.into_parts();+ parts.headers.insert(http::header::RETRY_AFTER, retry_after);+ Response::from_parts(parts, body)+ } else {+ response+ }+}++#[derive(Debug, Clone)]+pub struct ChatError {+ pub status: StatusCode,+ pub kind: &'static str,+ pub message: String,+ pub param: Option<String>,+ pub code: Option<String>,+}++impl ChatError {+ pub fn new(+ status: StatusCode,+ kind: &'static str,+ message: impl Into<String>,+ param: Option<&str>,+ code: Option<&str>,+ ) -> Self {+ Self {+ status,+ kind,+ message: message.into(),+ param: param.map(str::to_string),+ code: code.map(str::to_string),+ }+ }++ pub fn invalid(message: impl Into<String>, param: Option<&str>, code: Option<&str>) -> Self {+ Self::new(+ StatusCode::BAD_REQUEST,+ "invalid_request_error",+ message,+ param,+ code,+ )+ }++ pub fn unsupported(param: impl Into<String>) -> Self {+ let param = param.into();+ Self::invalid(+ format!("Unsupported parameter: {param}"),+ Some(¶m),+ Some("unsupported_parameter"),+ )+ }++ pub fn upstream(message: impl Into<String>) -> Self {+ Self::new(StatusCode::BAD_GATEWAY, "api_error", message, None, None)+ }++ pub fn timeout(message: impl Into<String>) -> Self {+ Self::new(+ StatusCode::GATEWAY_TIMEOUT,+ "api_error",+ message,+ None,+ None,+ )+ }++ fn from_codex(error: CodexError) -> Self {+ let status = match error.status {+ 401 => StatusCode::UNAUTHORIZED,+ 403 => StatusCode::FORBIDDEN,+ 429 => StatusCode::TOO_MANY_REQUESTS,+ _ if error.message.contains("Timed out waiting") => StatusCode::GATEWAY_TIMEOUT,+ _ => StatusCode::BAD_GATEWAY,+ };+ let kind = match status {+ StatusCode::UNAUTHORIZED => "authentication_error",+ StatusCode::FORBIDDEN => "permission_error",+ StatusCode::TOO_MANY_REQUESTS => "rate_limit_error",+ _ => "api_error",+ };+ Self::new(+ status,+ kind,+ error.detail.unwrap_or(error.message),+ None,+ None,+ )+ }++ pub fn value(&self) -> Value {+ json!({"error":{"message":self.message,"type":self.kind,"param":self.param,"code":self.code}})+ }++ pub fn response(self) -> Response {+ (self.status, Json(self.value())).into_response()+ }+}++#[cfg(test)]+mod tests {+ use super::*;+ use crate::{+ monitor::{EndpointKind, MonitorHandle},+ providers::codex::auth::token_store::StoredAuth,+ };+ use tokio::{+ io::{AsyncReadExt, AsyncWriteExt},+ net::TcpListener,+ };++ fn context(monitor: MonitorHandle) -> RequestContext {+ monitor.request_started(+ "chat-test",+ Some("session".into()),+ None,+ EndpointKind::ChatCompletions,+ );+ RequestContext {+ req_id: "chat-test".into(),+ session_id: Some("session".into()),+ session_seq: None,+ provider: "codex".into(),+ traffic: None,+ monitor: Some(monitor),+ }+ }++ async fn mock_backend(+ sse_body: &'static [u8],+ ) -> (ChatCompletionsBackend, tokio::task::JoinHandle<Value>) {+ let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();+ let address = listener.local_addr().unwrap();+ let server = tokio::spawn(async move {+ let (mut socket, _) = listener.accept().await.unwrap();+ let mut request = Vec::new();+ let mut buffer = [0_u8; 4096];+ loop {+ let read = socket.read(&mut buffer).await.unwrap();+ if read == 0 {+ break;+ }+ request.extend_from_slice(&buffer[..read]);+ let Some(header_end) = request.windows(4).position(|window| window == b"\r\n\r\n")+ else {+ continue;+ };+ let headers = String::from_utf8_lossy(&request[..header_end]);+ let length = headers+ .lines()+ .find_map(|line| {+ line.to_ascii_lowercase()+ .strip_prefix("content-length:")?+ .trim()+ .parse::<usize>()+ .ok()+ })+ .unwrap_or(0);+ if request.len() >= header_end + 4 + length {+ break;+ }+ }+ let header_end = request+ .windows(4)+ .position(|window| window == b"\r\n\r\n")+ .unwrap();+ let body: Value = serde_json::from_slice(&request[header_end + 4..]).unwrap();+ let response = format!(+ "HTTP/1.1 200 OK\r\ncontent-type: text/event-stream\r\ncontent-length: {}\r\nx-request-id: upstream-1\r\nconnection: close\r\n\r\n",+ sse_body.len()+ );+ socket.write_all(response.as_bytes()).await.unwrap();+ socket.write_all(sse_body).await.unwrap();+ body+ });+ let client = CodexHttpClient::new_for_test(+ reqwest::Client::new(),+ format!("http://{address}/v1/responses"),+ 1_000,+ 1_000,+ 0,+ );+ client.auth_manager().set_test_auth(StoredAuth {+ access: "test-token".into(),+ refresh: String::new(),+ account_id: Some("account".into()),+ expires: u64::MAX,+ });+ (ChatCompletionsBackend::with_client(client), server)+ }++ #[tokio::test]+ async fn buffered_request_translates_upstream_and_downstream() {+ const SSE: &[u8] = b"data: {\"type\":\"response.output_text.delta\",\"delta\":\"{\\\"answer\\\":\\\"yes\\\"}\"}\n\ndata: {\"type\":\"response.completed\",\"response\":{\"id\":\"resp_buffered\",\"model\":\"gpt-5.6-sol\",\"status\":\"completed\",\"usage\":{\"input_tokens\":8,\"output_tokens\":4}}}\n\n";+ let (backend, server) = mock_backend(SSE).await;+ let request = request::translate_request(json!({+ "model":"gpt-5.6-sol",+ "messages":[{"role":"system","content":"JSON only"},{"role":"user","content":"answer"}],+ "reasoning_effort":"low",+ "response_format":{"type":"json_schema","json_schema":{"name":"answer","strict":true,"schema":{"type":"object"}}}+ })).unwrap();+ let monitor = MonitorHandle::new(10);+ let response = backend.handle(request, context(monitor.clone())).await;+ assert_eq!(response.status(), StatusCode::OK);+ assert_eq!(response.headers()["x-request-id"], "upstream-1");+ let value: Value = serde_json::from_slice(+ &axum::body::to_bytes(response.into_body(), usize::MAX)+ .await+ .unwrap(),+ )+ .unwrap();+ assert_eq!(value["object"], "chat.completion");+ assert_eq!(+ value["choices"][0]["message"]["content"],+ r#"{"answer":"yes"}"#+ );+ assert_eq!(value["usage"]["total_tokens"], 12);++ let upstream = server.await.unwrap();+ assert_eq!(upstream["store"], false);+ assert_eq!(upstream["stream"], true);+ assert_eq!(upstream["input"][0]["role"], "developer");+ assert_eq!(upstream["reasoning"]["effort"], "low");+ assert_eq!(upstream["reasoning"]["context"], "all_turns");+ assert_eq!(upstream["text"]["format"]["name"], "answer");+ let snapshot = monitor.snapshot();+ assert_eq!(snapshot.active[0].input_tokens, Some(8));+ assert_eq!(snapshot.active[0].output_tokens, Some(4));+ }++ #[tokio::test]+ async fn streaming_request_emits_chat_chunks_usage_and_done() {+ const SSE: &[u8] = b"data: {\"type\":\"response.created\",\"response\":{\"id\":\"resp_stream\",\"model\":\"gpt-5.6-sol\"}}\n\ndata: {\"type\":\"response.output_text.delta\",\"delta\":\"hello\"}\n\ndata: {\"type\":\"response.completed\",\"response\":{\"id\":\"resp_stream\",\"status\":\"completed\",\"usage\":{\"input_tokens\":3,\"output_tokens\":1}}}\n\n";+ let (backend, server) = mock_backend(SSE).await;+ let request = request::translate_request(json!({+ "model":"gpt-5.6-sol",+ "messages":[{"role":"user","content":"hello"}],+ "stream":true,+ "stream_options":{"include_usage":true}+ }))+ .unwrap();+ let response = backend+ .handle(request, context(MonitorHandle::new(10)))+ .await;+ assert_eq!(response.status(), StatusCode::OK);+ assert_eq!(response.headers()["content-type"], "text/event-stream");+ let body = String::from_utf8(+ axum::body::to_bytes(response.into_body(), usize::MAX)+ .await+ .unwrap()+ .to_vec(),+ )+ .unwrap();+ assert!(body.contains(r#""delta":{"role":"assistant"}"#));+ assert!(body.contains(r#""delta":{"content":"hello"}"#));+ assert!(body.contains(r#""finish_reason":"stop""#));+ assert!(body.contains(r#""prompt_tokens":3"#));+ assert!(body.ends_with("data: [DONE]\n\n"));+ server.await.unwrap();+ }++ #[test]+ fn codex_errors_map_status_and_preserve_retry_metadata() {+ let response = codex_error_response(CodexError {+ status: 429,+ message: "Rate limited".into(),+ detail: Some("Try later".into()),+ retry_after: Some("7".into()),+ origin: super::super::client::CodexErrorOrigin::Http,+ });+ assert_eq!(response.status(), StatusCode::TOO_MANY_REQUESTS);+ assert_eq!(response.headers()[http::header::RETRY_AFTER], "7");++ let auth = ChatError::from_codex(CodexError {+ status: 401,+ message: "Auth error".into(),+ detail: None,+ retry_after: None,+ origin: super::super::client::CodexErrorOrigin::Auth,+ });+ assert_eq!(auth.status, StatusCode::UNAUTHORIZED);+ assert_eq!(auth.kind, "authentication_error");+ }+}diff --git a/src/providers/codex/chat_completions/request.rs b/src/providers/codex/chat_completions/request.rsnew file mode 100644index 0000000..eeb2062--- /dev/null+++ b/src/providers/codex/chat_completions/request.rs@@ -0,0 +1,549 @@+use http::StatusCode;+use serde_json::{Map, Value, json};++use crate::providers::codex::translate::{+ model_allowlist::{+ ALLOWED_MODELS, assert_allowed_model, resolve_model_request, uses_responses_lite,+ },+ request::{Effort, resolve_effort_override, to_codex_effort},+};+use crate::{config, registry::normalize_incoming_model};++use super::ChatError;++const SUPPORTED_FIELDS: &[&str] = &[+ "model",+ "messages",+ "stream",+ "stream_options",+ "reasoning_effort",+ "response_format",+ "temperature",+ "top_p",+ "user",+];++#[derive(Debug, Clone)]+pub struct TranslatedRequest {+ pub upstream: Value,+ pub requested_model: String,+ pub model: String,+ pub effort: Option<String>,+ pub stream: bool,+ pub include_usage: bool,+ pub use_responses_lite: bool,+}++pub fn translate_request(body: Value) -> Result<TranslatedRequest, ChatError> {+ translate_request_with_override(body, config::codex_effort().as_deref())+}++fn translate_request_with_override(+ body: Value,+ effort_override: Option<&str>,+) -> Result<TranslatedRequest, ChatError> {+ let object = body+ .as_object()+ .ok_or_else(|| ChatError::invalid("Request body must be a JSON object", None, None))?;+ reject_unsupported_fields(object)?;++ let requested_model = required_string(object, "model")?;+ let normalized = normalize_incoming_model(&requested_model);+ let resolved = resolve_model_request(&normalized);+ assert_allowed_model(&resolved.model).map_err(|error| {+ ChatError::invalid(+ format!(+ "Model '{requested_model}' resolves to unsupported model '{}'. Supported: {}",+ error.model,+ ALLOWED_MODELS.join(", ")+ ),+ Some("model"),+ Some("model_not_supported"),+ )+ })?;+ let use_responses_lite = uses_responses_lite(&resolved.model);++ let messages = object+ .get("messages")+ .and_then(Value::as_array)+ .ok_or_else(|| {+ ChatError::invalid("Missing or invalid 'messages'", Some("messages"), None)+ })?;+ if messages.is_empty() {+ return Err(ChatError::invalid(+ "'messages' must contain at least one message",+ Some("messages"),+ None,+ ));+ }+ let input = messages+ .iter()+ .enumerate()+ .map(translate_message)+ .collect::<Result<Vec<_>, _>>()?;++ let stream = optional_bool(object, "stream")?.unwrap_or(false);+ let include_usage = translate_stream_options(object.get("stream_options"))?;+ if include_usage && !stream {+ return Err(ChatError::invalid(+ "'stream_options' is only supported when 'stream' is true",+ Some("stream_options"),+ None,+ ));+ }++ let request_effort = match object.get("reasoning_effort") {+ None | Some(Value::Null) => Some(Effort::Medium),+ Some(Value::String(value)) => parse_effort(value)?,+ Some(_) => {+ return Err(ChatError::invalid(+ "'reasoning_effort' must be a string",+ Some("reasoning_effort"),+ None,+ ));+ }+ };+ let effort = resolve_effort_override(request_effort, effort_override).map_err(|error| {+ ChatError::new(+ StatusCode::INTERNAL_SERVER_ERROR,+ "api_error",+ error.to_string(),+ None,+ None,+ )+ })?;++ let mut text = Map::from_iter([("verbosity".to_string(), json!("low"))]);+ if let Some(format) = translate_response_format(object.get("response_format"))? {+ text.insert("format".to_string(), format);+ }++ let mut upstream = Map::from_iter([+ ("model".to_string(), json!(&resolved.model)),+ ("input".to_string(), Value::Array(input)),+ ("store".to_string(), json!(false)),+ ("stream".to_string(), json!(true)),+ ("parallel_tool_calls".to_string(), json!(false)),+ ("client_metadata".to_string(), json!({"lite":"true"})),+ ("text".to_string(), Value::Object(text)),+ ]);+ if let Some(tier) = resolved.service_tier {+ upstream.insert(+ "service_tier".to_string(),+ serde_json::to_value(tier).unwrap(),+ );+ }+ let mut reasoning = Map::from_iter([("context".to_string(), json!("all_turns"))]);+ if let Some(effort) = effort.as_ref().filter(|effort| **effort != Effort::None) {+ reasoning.insert("effort".to_string(), json!(effort));+ }+ upstream.insert("reasoning".to_string(), Value::Object(reasoning));++ for param in ["temperature", "top_p"] {+ if let Some(value) = object.get(param).filter(|value| !value.is_null()) {+ if use_responses_lite {+ return Err(ChatError::unsupported(param));+ }+ validate_sampling_value(param, value)?;+ upstream.insert(param.to_string(), value.clone());+ }+ }+ if let Some(user) = object.get("user").filter(|value| !value.is_null()) {+ let user = user+ .as_str()+ .filter(|value| !value.is_empty() && value.len() <= 64)+ .ok_or_else(|| {+ ChatError::invalid(+ "'user' must be a non-empty string of at most 64 bytes",+ Some("user"),+ None,+ )+ })?;+ upstream.insert("safety_identifier".to_string(), json!(user));+ }++ Ok(TranslatedRequest {+ upstream: Value::Object(upstream),+ requested_model,+ model: resolved.model,+ effort: effort+ .map(|effort| effort.to_string())+ .filter(|effort| effort != "none"),+ stream,+ include_usage,+ use_responses_lite,+ })+}++fn reject_unsupported_fields(object: &Map<String, Value>) -> Result<(), ChatError> {+ for key in object.keys() {+ if !SUPPORTED_FIELDS.contains(&key.as_str()) {+ return Err(ChatError::unsupported(key));+ }+ }+ Ok(())+}++fn required_string(object: &Map<String, Value>, key: &'static str) -> Result<String, ChatError> {+ object+ .get(key)+ .and_then(Value::as_str)+ .filter(|value| !value.is_empty())+ .map(str::to_string)+ .ok_or_else(|| ChatError::invalid(format!("Missing or invalid '{key}'"), Some(key), None))+}++fn optional_bool(+ object: &Map<String, Value>,+ key: &'static str,+) -> Result<Option<bool>, ChatError> {+ match object.get(key) {+ None | Some(Value::Null) => Ok(None),+ Some(Value::Bool(value)) => Ok(Some(*value)),+ Some(_) => Err(ChatError::invalid(+ format!("'{key}' must be a boolean"),+ Some(key),+ None,+ )),+ }+}++fn translate_message((index, message): (usize, &Value)) -> Result<Value, ChatError> {+ let param = format!("messages[{index}]");+ let object = message+ .as_object()+ .ok_or_else(|| ChatError::invalid("Each message must be an object", Some(¶m), None))?;+ for key in object.keys() {+ if !matches!(key.as_str(), "role" | "content" | "name") {+ return Err(ChatError::unsupported(format!("{param}.{key}")));+ }+ }+ let role = object.get("role").and_then(Value::as_str).ok_or_else(|| {+ ChatError::invalid(+ "Each message requires a role",+ Some(&format!("{param}.role")),+ None,+ )+ })?;+ let role = match role {+ "system" | "developer" => "developer",+ "user" => "user",+ "assistant" => "assistant",+ _ => {+ return Err(ChatError::invalid(+ format!("Unsupported message role: {role}"),+ Some(&format!("{param}.role")),+ Some("unsupported_value"),+ ));+ }+ };+ let parts = translate_content(object.get("content"), index)?;+ Ok(json!({"type":"message", "role":role, "content":parts}))+}++fn translate_content(content: Option<&Value>, index: usize) -> Result<Vec<Value>, ChatError> {+ let param = format!("messages[{index}].content");+ let parts = match content {+ Some(Value::String(text)) if !text.is_empty() => {+ vec![json!({"type":"input_text", "text":text})]+ }+ Some(Value::Array(parts)) if !parts.is_empty() => parts+ .iter()+ .enumerate()+ .map(|(part_index, part)| {+ let part_param = format!("{param}[{part_index}]");+ let object = part.as_object().ok_or_else(|| {+ ChatError::invalid(+ "Message content parts must be objects",+ Some(&part_param),+ None,+ )+ })?;+ if object.get("type").and_then(Value::as_str) != Some("text") {+ return Err(ChatError::invalid(+ "Only text message content is supported",+ Some(&format!("{part_param}.type")),+ Some("unsupported_value"),+ ));+ }+ let text = object+ .get("text")+ .and_then(Value::as_str)+ .filter(|text| !text.is_empty())+ .ok_or_else(|| {+ ChatError::invalid(+ "Text content must not be empty",+ Some(&format!("{part_param}.text")),+ None,+ )+ })?;+ Ok(json!({"type":"input_text", "text":text}))+ })+ .collect::<Result<Vec<_>, _>>()?,+ _ => {+ return Err(ChatError::invalid(+ "Message content must contain text",+ Some(¶m),+ None,+ ));+ }+ };+ Ok(parts)+}++fn parse_effort(value: &str) -> Result<Option<Effort>, ChatError> {+ if value == "none" {+ return Ok(Some(Effort::None));+ }+ to_codex_effort(Some(value)).map(Some).ok_or_else(|| {+ ChatError::invalid(+ format!(+ "Invalid reasoning effort '{value}'. Supported: none, low, medium, high, xhigh, max"+ ),+ Some("reasoning_effort"),+ Some("unsupported_value"),+ )+ })+}++fn translate_response_format(value: Option<&Value>) -> Result<Option<Value>, ChatError> {+ let Some(value) = value.filter(|value| !value.is_null()) else {+ return Ok(None);+ };+ let object = value.as_object().ok_or_else(|| {+ ChatError::invalid(+ "'response_format' must be an object",+ Some("response_format"),+ None,+ )+ })?;+ match object.get("type").and_then(Value::as_str) {+ Some("text") => Ok(None),+ Some("json_object") => Ok(Some(json!({"type":"json_object"}))),+ Some("json_schema") => {+ let format = object+ .get("json_schema")+ .and_then(Value::as_object)+ .ok_or_else(|| {+ ChatError::invalid(+ "'response_format.json_schema' must be an object",+ Some("response_format.json_schema"),+ None,+ )+ })?;+ let name = format+ .get("name")+ .and_then(Value::as_str)+ .filter(|name| !name.is_empty())+ .ok_or_else(|| {+ ChatError::invalid(+ "JSON Schema output requires a name",+ Some("response_format.json_schema.name"),+ None,+ )+ })?;+ let schema = format+ .get("schema")+ .filter(|schema| schema.is_object())+ .ok_or_else(|| {+ ChatError::invalid(+ "JSON Schema output requires an object schema",+ Some("response_format.json_schema.schema"),+ None,+ )+ })?;+ let strict = match format.get("strict") {+ None | Some(Value::Null) => None,+ Some(Value::Bool(value)) => Some(*value),+ Some(_) => {+ return Err(ChatError::invalid(+ "JSON Schema strict must be a boolean",+ Some("response_format.json_schema.strict"),+ None,+ ));+ }+ };+ let mut translated = Map::from_iter([+ ("type".to_string(), json!("json_schema")),+ ("name".to_string(), json!(name)),+ ("schema".to_string(), schema.clone()),+ ]);+ if let Some(strict) = strict {+ translated.insert("strict".to_string(), json!(strict));+ }+ Ok(Some(Value::Object(translated)))+ }+ Some(kind) => Err(ChatError::invalid(+ format!("Unsupported response format: {kind}"),+ Some("response_format.type"),+ Some("unsupported_value"),+ )),+ None => Err(ChatError::invalid(+ "'response_format.type' is required",+ Some("response_format.type"),+ None,+ )),+ }+}++fn translate_stream_options(value: Option<&Value>) -> Result<bool, ChatError> {+ let Some(value) = value.filter(|value| !value.is_null()) else {+ return Ok(false);+ };+ let object = value.as_object().ok_or_else(|| {+ ChatError::invalid(+ "'stream_options' must be an object",+ Some("stream_options"),+ None,+ )+ })?;+ for key in object.keys() {+ if key != "include_usage" {+ return Err(ChatError::unsupported(format!("stream_options.{key}")));+ }+ }+ match object.get("include_usage") {+ None | Some(Value::Null) => Ok(false),+ Some(Value::Bool(value)) => Ok(*value),+ Some(_) => Err(ChatError::invalid(+ "'stream_options.include_usage' must be a boolean",+ Some("stream_options.include_usage"),+ None,+ )),+ }+}++fn validate_sampling_value(param: &'static str, value: &Value) -> Result<(), ChatError> {+ let number = value+ .as_f64()+ .filter(|value| value.is_finite())+ .ok_or_else(|| {+ ChatError::invalid(format!("'{param}' must be a number"), Some(param), None)+ })?;+ let valid = match param {+ "temperature" => (0.0..=2.0).contains(&number),+ _ => (0.0..=1.0).contains(&number),+ };+ if valid {+ Ok(())+ } else {+ Err(ChatError::invalid(+ format!("'{param}' is out of range"),+ Some(param),+ Some("invalid_value"),+ ))+ }+}++#[cfg(test)]+mod tests {+ use super::*;++ fn base() -> Value {+ json!({"model":"gpt-5.6-sol","messages":[{"role":"system","content":"rules"},{"role":"user","content":[{"type":"text","text":"hello"}]}]})+ }++ #[test]+ fn translates_messages_and_responses_lite_fields() {+ let translated = translate_request(base()).unwrap();+ assert_eq!(translated.upstream["input"][0]["role"], "developer");+ assert_eq!(+ translated.upstream["input"][1]["content"][0]["text"],+ "hello"+ );+ assert_eq!(translated.upstream["store"], false);+ assert_eq!(translated.upstream["stream"], true);+ assert_eq!(translated.upstream["reasoning"]["effort"], "medium");+ assert_eq!(translated.upstream["reasoning"]["context"], "all_turns");+ }++ #[test]+ fn none_effort_retains_context() {+ let mut body = base();+ body["reasoning_effort"] = json!("none");+ let translated = translate_request(body).unwrap();+ assert!(translated.upstream["reasoning"].get("effort").is_none());+ assert_eq!(translated.upstream["reasoning"]["context"], "all_turns");+ }++ #[test]+ fn translates_strict_json_schema() {+ let mut body = base();+ body["response_format"] = json!({"type":"json_schema","json_schema":{"name":"answer","strict":true,"schema":{"type":"object"}}});+ let translated = translate_request(body).unwrap();+ assert_eq!(translated.upstream["text"]["format"]["name"], "answer");+ assert_eq!(translated.upstream["text"]["format"]["strict"], true);+ }++ #[test]+ fn rejects_empty_content_and_unsupported_controls() {+ let mut empty = base();+ empty["messages"][0]["content"] = json!("");+ assert_eq!(+ translate_request(empty).unwrap_err().param.as_deref(),+ Some("messages[0].content")+ );+ let mut tokens = base();+ tokens["max_tokens"] = json!(100);+ let error = translate_request(tokens).unwrap_err();+ assert_eq!(error.code.as_deref(), Some("unsupported_parameter"));+ assert_eq!(error.param.as_deref(), Some("max_tokens"));+ }++ #[test]+ fn requires_model_and_nonempty_messages() {+ assert_eq!(+ translate_request(json!({"messages":[{"role":"user","content":"hello"}]}))+ .unwrap_err()+ .param+ .as_deref(),+ Some("model")+ );+ assert_eq!(+ translate_request(json!({"model":"gpt-5.6-sol","messages":[]}))+ .unwrap_err()+ .param+ .as_deref(),+ Some("messages")+ );+ }++ #[test]+ fn accepts_all_efforts_and_forced_override_wins() {+ for effort in ["none", "low", "medium", "high", "xhigh", "max"] {+ let mut body = base();+ body["reasoning_effort"] = json!(effort);+ assert!(translate_request_with_override(body, None).is_ok());+ }+ let mut body = base();+ body["reasoning_effort"] = json!("low");+ let translated = translate_request_with_override(body, Some("high")).unwrap();+ assert_eq!(translated.upstream["reasoning"]["effort"], "high");+ assert_eq!(translated.effort.as_deref(), Some("high"));+ }++ #[test]+ fn validates_stream_options_and_sampling_controls() {+ let mut options = base();+ options["stream_options"] = json!({"include_usage":true});+ assert_eq!(+ translate_request(options).unwrap_err().param.as_deref(),+ Some("stream_options")+ );++ let mut lite = base();+ lite["temperature"] = json!(0.2);+ assert_eq!(+ translate_request(lite).unwrap_err().code.as_deref(),+ Some("unsupported_parameter")+ );++ let mut full = base();+ full["model"] = json!("gpt-5.4");+ full["temperature"] = json!(0.2);+ full["top_p"] = json!(0.9);+ let translated = translate_request(full).unwrap();+ assert_eq!(translated.upstream["temperature"], 0.2);+ assert_eq!(translated.upstream["top_p"], 0.9);+ }+}diff --git a/src/providers/codex/chat_completions/response.rs b/src/providers/codex/chat_completions/response.rsnew file mode 100644index 0000000..a865cdb--- /dev/null+++ b/src/providers/codex/chat_completions/response.rs@@ -0,0 +1,226 @@+use serde_json::{Value, json};++use crate::anthropic::sse::parse_sse_events;++use super::ChatError;++#[derive(Debug, Clone, Default)]+pub struct Usage {+ pub prompt_tokens: u64,+ pub completion_tokens: u64,+}++impl Usage {+ pub fn value(&self) -> Value {+ json!({+ "prompt_tokens": self.prompt_tokens,+ "completion_tokens": self.completion_tokens,+ "total_tokens": self.prompt_tokens.saturating_add(self.completion_tokens),+ })+ }+}++#[derive(Debug, Clone)]+pub struct CompletionState {+ pub id: String,+ pub created: u64,+ pub model: String,+ pub text: String,+ pub usage: Usage,+ pub finish_reason: &'static str,+ pub completed: bool,+}++impl CompletionState {+ pub fn new(model: &str) -> Self {+ Self {+ id: format!("chatcmpl-{}", uuid::Uuid::new_v4().simple()),+ created: unix_seconds(),+ model: model.to_string(),+ text: String::new(),+ usage: Usage::default(),+ finish_reason: "stop",+ completed: false,+ }+ }++ pub fn observe(&mut self, event: &Value) -> Result<Option<String>, ChatError> {+ let kind = event.get("type").and_then(Value::as_str);+ if matches!(kind, Some("response.failed" | "response.error" | "error")) {+ return Err(event_error(event));+ }+ match kind {+ Some("response.created" | "response.in_progress") => {+ if let Some(response) = event.get("response") {+ self.update_metadata(response);+ }+ }+ Some("response.output_text.delta") => {+ let delta = event.get("delta").and_then(Value::as_str).ok_or_else(|| {+ ChatError::upstream("Codex output-text delta did not contain text")+ })?;+ self.text.push_str(delta);+ return Ok(Some(delta.to_string()));+ }+ Some("response.completed" | "response.incomplete") => {+ let response = event.get("response").ok_or_else(|| {+ ChatError::upstream("Codex completion event did not contain a response")+ })?;+ self.update_metadata(response);+ if response.get("status").and_then(Value::as_str) == Some("failed") {+ return Err(event_error(event));+ }+ if kind == Some("response.incomplete")+ || response.get("status").and_then(Value::as_str) == Some("incomplete")+ {+ self.finish_reason = "length";+ }+ self.completed = true;+ }+ _ => {+ if event.get("error").is_some_and(|error| !error.is_null()) {+ return Err(event_error(event));+ }+ }+ }+ Ok(None)+ }++ fn update_metadata(&mut self, response: &Value) {+ if let Some(id) = response.get("id").and_then(Value::as_str) {+ self.id = chat_completion_id(id);+ }+ if let Some(model) = response.get("model").and_then(Value::as_str) {+ self.model = model.to_string();+ }+ if let Some(created) = response+ .get("created_at")+ .or_else(|| response.get("created"))+ .and_then(Value::as_f64)+ .filter(|created| *created >= 0.0)+ {+ self.created = created as u64;+ }+ if let Some(usage) = response.get("usage") {+ self.usage.prompt_tokens = usage+ .get("input_tokens")+ .and_then(Value::as_u64)+ .unwrap_or(self.usage.prompt_tokens);+ self.usage.completion_tokens = usage+ .get("output_tokens")+ .and_then(Value::as_u64)+ .unwrap_or(self.usage.completion_tokens);+ }+ }+}++pub fn aggregate_sse(body: &[u8], requested_model: &str) -> Result<Value, ChatError> {+ let events = parse_sse_events(body);+ if events.is_empty() {+ return Err(ChatError::upstream(+ "Codex returned an empty or malformed event stream",+ ));+ }+ let mut state = CompletionState::new(requested_model);+ for event in events {+ if event.data == "[DONE]" {+ continue;+ }+ let value: Value = serde_json::from_str(&event.data).map_err(|_| {+ ChatError::upstream("Codex returned malformed JSON in its event stream")+ })?;+ state.observe(&value)?;+ }+ if !state.completed {+ return Err(ChatError::upstream(+ "Codex event stream ended before completion",+ ));+ }+ if state.text.is_empty() {+ return Err(ChatError::upstream("Codex completed without output text"));+ }+ Ok(completion_value(&state))+}++pub fn completion_value(state: &CompletionState) -> Value {+ json!({+ "id": state.id,+ "object": "chat.completion",+ "created": state.created,+ "model": state.model,+ "choices": [{+ "index": 0,+ "message": {"role":"assistant", "content":state.text},+ "finish_reason": state.finish_reason,+ }],+ "usage": state.usage.value(),+ })+}++pub fn event_error(event: &Value) -> ChatError {+ let message = event+ .pointer("/response/error/message")+ .or_else(|| event.pointer("/error/message"))+ .or_else(|| event.get("message"))+ .and_then(Value::as_str)+ .unwrap_or("Codex response generation failed");+ ChatError::upstream(message)+}++pub fn chat_completion_id(response_id: &str) -> String {+ if response_id.starts_with("chatcmpl-") {+ response_id.to_string()+ } else if let Some(suffix) = response_id.strip_prefix("resp_") {+ format!("chatcmpl-{suffix}")+ } else {+ format!("chatcmpl-{response_id}")+ }+}++fn unix_seconds() -> u64 {+ use std::time::{SystemTime, UNIX_EPOCH};+ SystemTime::now()+ .duration_since(UNIX_EPOCH)+ .unwrap_or_default()+ .as_secs()+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn aggregates_ordered_deltas_and_usage() {+ let body = b"data: {\"type\":\"response.output_text.delta\",\"delta\":\"hel\"}\n\ndata: {\"type\":\"response.output_text.delta\",\"delta\":\"lo\"}\n\ndata: {\"type\":\"response.completed\",\"response\":{\"id\":\"resp_123\",\"model\":\"gpt-5.6-sol\",\"status\":\"completed\",\"usage\":{\"input_tokens\":4,\"output_tokens\":2}}}\n\n";+ let value = aggregate_sse(body, "requested").unwrap();+ assert_eq!(value["id"], "chatcmpl-123");+ assert_eq!(value["choices"][0]["message"]["content"], "hello");+ assert_eq!(value["usage"]["total_tokens"], 6);+ }++ #[test]+ fn incomplete_maps_to_length() {+ let body = b"data: {\"type\":\"response.output_text.delta\",\"delta\":\"partial\"}\n\ndata: {\"type\":\"response.incomplete\",\"response\":{\"status\":\"incomplete\"}}\n\n";+ let value = aggregate_sse(body, "model").unwrap();+ assert_eq!(value["choices"][0]["finish_reason"], "length");+ }++ #[test]+ fn rejects_failed_and_truncated_streams() {+ let failed = b"data: {\"type\":\"response.failed\",\"response\":{\"error\":{\"message\":\"bad generation\"}}}\n\n";+ assert!(+ aggregate_sse(failed, "model")+ .unwrap_err()+ .message+ .contains("bad generation")+ );+ let truncated =+ b"data: {\"type\":\"response.output_text.delta\",\"delta\":\"partial\"}\n\n";+ assert!(+ aggregate_sse(truncated, "model")+ .unwrap_err()+ .message+ .contains("before completion")+ );+ }+}diff --git a/src/providers/codex/chat_completions/stream.rs b/src/providers/codex/chat_completions/stream.rsnew file mode 100644index 0000000..32a4660--- /dev/null+++ b/src/providers/codex/chat_completions/stream.rs@@ -0,0 +1,325 @@+use std::{collections::VecDeque, io, pin::Pin, time::Duration};++use axum::{body::Body, response::Response};+use bytes::Bytes;+use futures_util::{Stream, StreamExt};+use http::{HeaderMap, StatusCode};+use serde_json::{Value, json};++use crate::providers::codex::native::NativeResponseOutcome;+use crate::{provider::RequestContext, traffic::MAX_SSE_CAPTURE_BYTES};++use super::{ChatError, response::CompletionState};++type UpstreamStream = Pin<Box<dyn Stream<Item = Result<Bytes, reqwest::Error>> + Send>>;++pub fn streaming_response(+ upstream: reqwest::Response,+ ctx: RequestContext,+ model: String,+ include_usage: bool,+ body_idle_timeout_ms: u64,+) -> Response {+ let outcome = NativeResponseOutcome::default();+ let state = StreamState {+ upstream: Box::pin(upstream.bytes_stream()),+ pending: Vec::new(),+ output: VecDeque::new(),+ completion: CompletionState::new(&model),+ role_sent: false,+ include_usage,+ ended: false,+ generation_started: false,+ ctx,+ outcome: outcome.clone(),+ body_idle_timeout_ms,+ raw: Vec::new(),+ raw_truncated: 0,+ };+ let stream =+ futures_util::stream::unfold(Some(state), |state| async move { next_frame(state).await });+ let mut response = Response::new(Body::from_stream(stream));+ *response.status_mut() = StatusCode::OK;+ response.headers_mut().insert(+ http::header::CONTENT_TYPE,+ http::HeaderValue::from_static("text/event-stream"),+ );+ response.headers_mut().insert(+ http::header::CACHE_CONTROL,+ http::HeaderValue::from_static("no-cache"),+ );+ response.extensions_mut().insert(outcome);+ response+}++async fn next_frame(+ state: Option<StreamState>,+) -> Option<(Result<Bytes, io::Error>, Option<StreamState>)> {+ let mut state = state?;+ loop {+ if let Some(frame) = state.output.pop_front() {+ let next = if state.ended && state.output.is_empty() {+ state.finish_capture("complete");+ None+ } else {+ Some(state)+ };+ return Some((Ok(frame), next));+ }+ if state.ended {+ state.finish_capture("complete");+ return None;+ }+ match tokio::time::timeout(+ Duration::from_millis(state.body_idle_timeout_ms),+ state.upstream.next(),+ )+ .await+ {+ Ok(Some(Ok(chunk))) => state.observe_chunk(&chunk),+ Ok(Some(Err(error))) => {+ state.fail(ChatError::upstream(format!(+ "Codex response body read failed: {error}"+ )));+ }+ Ok(None) => {+ if !state.completion.completed {+ state.fail(ChatError::upstream(+ "Codex event stream ended before completion",+ ));+ } else {+ state.finish_success();+ }+ }+ Err(_) => {+ state.fail(ChatError::timeout(format!(+ "Timed out waiting {}ms for the next Codex response body chunk",+ state.body_idle_timeout_ms+ )));+ }+ }+ }+}++struct StreamState {+ upstream: UpstreamStream,+ pending: Vec<u8>,+ output: VecDeque<Bytes>,+ completion: CompletionState,+ role_sent: bool,+ include_usage: bool,+ ended: bool,+ generation_started: bool,+ ctx: RequestContext,+ outcome: NativeResponseOutcome,+ body_idle_timeout_ms: u64,+ raw: Vec<u8>,+ raw_truncated: u64,+}++impl StreamState {+ fn observe_chunk(&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;+ }+ let remaining = MAX_SSE_CAPTURE_BYTES.saturating_sub(self.raw.len());+ let captured = remaining.min(chunk.len());+ self.raw.extend_from_slice(&chunk[..captured]);+ self.raw_truncated = self+ .raw_truncated+ .saturating_add((chunk.len() - captured) as u64);+ self.pending.extend_from_slice(chunk);++ let mut event_count = 0;+ while let Some((end, separator_len)) = find_boundary(&self.pending) {+ let frame = self+ .pending+ .drain(..end + separator_len)+ .collect::<Vec<_>>();+ for event in crate::anthropic::sse::parse_sse_events(&frame) {+ event_count += 1;+ self.observe_event(&event.data);+ if self.ended {+ break;+ }+ }+ if self.ended {+ break;+ }+ }+ if let Some(monitor) = self.ctx.monitor.as_ref() {+ monitor.stream_progress(+ &self.ctx.req_id,+ chunk.len() as u64,+ event_count,+ Some(self.completion.usage.prompt_tokens),+ Some(self.completion.usage.completion_tokens),+ );+ }+ }++ fn observe_event(&mut self, data: &str) {+ if data == "[DONE]" {+ return;+ }+ let event: Value = match serde_json::from_str(data) {+ Ok(event) => event,+ Err(_) => {+ self.fail(ChatError::upstream(+ "Codex returned malformed JSON in its event stream",+ ));+ return;+ }+ };+ if let Some(traffic) = self.ctx.traffic.as_deref() {+ traffic.write_json_event("040-upstream-event", &event);+ }+ match self.completion.observe(&event) {+ Ok(Some(delta)) => {+ if !self.role_sent {+ self.role_sent = true;+ self.output.push_back(sse(json!({+ "id": self.completion.id,+ "object": "chat.completion.chunk",+ "created": self.completion.created,+ "model": self.completion.model,+ "choices": [{"index":0,"delta":{"role":"assistant"},"finish_reason":null}],+ })));+ }+ self.output.push_back(sse(json!({+ "id": self.completion.id,+ "object": "chat.completion.chunk",+ "created": self.completion.created,+ "model": self.completion.model,+ "choices": [{"index":0,"delta":{"content":delta},"finish_reason":null}],+ })));+ }+ Ok(None) if self.completion.completed => self.finish_success(),+ Ok(None) => {}+ Err(error) => self.fail(error),+ }+ }++ fn finish_success(&mut self) {+ if self.ended {+ return;+ }+ if self.completion.text.is_empty() {+ self.fail(ChatError::upstream("Codex completed without output text"));+ return;+ }+ let mut terminal = json!({+ "id": self.completion.id,+ "object": "chat.completion.chunk",+ "created": self.completion.created,+ "model": self.completion.model,+ "choices": [{"index":0,"delta":{},"finish_reason":self.completion.finish_reason}],+ });+ if self.include_usage {+ terminal["usage"] = self.completion.usage.value();+ }+ if let Some(monitor) = self.ctx.monitor.as_ref() {+ monitor.usage_updated(+ &self.ctx.req_id,+ Some(self.completion.usage.prompt_tokens),+ Some(self.completion.usage.completion_tokens),+ );+ }+ self.output.push_back(sse(terminal));+ self.output+ .push_back(Bytes::from_static(b"data: [DONE]\n\n"));+ self.ended = true;+ }++ fn fail(&mut self, error: ChatError) {+ if self.ended {+ return;+ }+ self.outcome.fail(error.message.clone());+ self.output.push_back(sse(error.value()));+ self.output+ .push_back(Bytes::from_static(b"data: [DONE]\n\n"));+ self.ended = true;+ }++ fn finish_capture(&mut self, capture_outcome: &str) {+ let Some(traffic) = self.ctx.traffic.as_deref() else {+ return;+ };+ if !self.raw.is_empty() {+ traffic.write_bytes("032-upstream-response-body.sse", &self.raw);+ }+ traffic.write_json(+ "033-chat-completions-response-capture",+ &json!({+ "outcome": capture_outcome,+ "capturedBytes": self.raw.len(),+ "truncatedBytes": self.raw_truncated,+ "inputTokens": self.completion.usage.prompt_tokens,+ "outputTokens": self.completion.usage.completion_tokens,+ }),+ );+ }+}++impl Drop for StreamState {+ fn drop(&mut self) {+ if !self.ended {+ self.finish_capture("downstream_cancelled");+ }+ }+}++fn sse(value: Value) -> Bytes {+ Bytes::from(format!(+ "data: {}\n\n",+ serde_json::to_string(&value).unwrap()+ ))+}++fn find_boundary(bytes: &[u8]) -> Option<(usize, usize)> {+ for index in 0..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+}++pub fn response_headers(upstream: &HeaderMap) -> HeaderMap {+ let mut headers = HeaderMap::new();+ for name in [+ "retry-after",+ "x-request-id",+ "openai-processing-ms",+ "openai-version",+ ] {+ if let Some(value) = upstream.get(name) {+ headers.insert(name, value.clone());+ }+ }+ for (name, value) in upstream {+ if name.as_str().starts_with("x-ratelimit-") {+ headers.append(name.clone(), value.clone());+ }+ }+ headers+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn boundary_supports_split_safe_delimiters() {+ assert_eq!(find_boundary(b"data: {}\n\nnext"), Some((8, 2)));+ assert_eq!(find_boundary(b"data: {}\r\n\r\nnext"), Some((8, 4)));+ assert_eq!(find_boundary(b"data: {}"), None);+ }+}diff --git a/src/providers/codex/mod.rs b/src/providers/codex/mod.rsindex 107628b..fdf1580 100644--- a/src/providers/codex/mod.rs+++ b/src/providers/codex/mod.rs@@ -1,4 +1,5 @@pub mod auth;+pub mod chat_completions;pub mod client;pub mod compaction;pub mod continuation;diff --git a/src/providers/codex/native.rs b/src/providers/codex/native.rsindex d9be868..d392422 100644--- a/src/providers/codex/native.rs+++ b/src/providers/codex/native.rs@@ -223,7 +223,7 @@ impl NativeResponseOutcome {self.failure.lock().ok().and_then(|failure| failure.clone())}- fn fail(&self, message: String) {+ pub(crate) fn fail(&self, message: String) {if let Ok(mut failure) = self.failure.lock()&& failure.is_none(){diff --git a/src/providers/codex/translate/request.rs b/src/providers/codex/translate/request.rsindex ec81894..44b2ce6 100644--- a/src/providers/codex/translate/request.rs+++ b/src/providers/codex/translate/request.rs@@ -259,7 +259,7 @@ pub struct TranslateOptions {// Translation entry point// ----------------------------------------------------------------------------fn to_codex_effort(effort: Option<&str>) -> Option<Effort> {+pub(crate) fn to_codex_effort(effort: Option<&str>) -> Option<Effort> {match effort {Some("max") => Some(Effort::Max),Some("xhigh") => Some(Effort::Xhigh),@@ -274,7 +274,7 @@ fn resolve_effort(effort: Option<Effort>) -> Result<Option<Effort>, anyhow::Erroresolve_effort_override(effort, config::codex_effort().as_deref())}-fn resolve_effort_override(+pub(crate) fn resolve_effort_override(effort: Option<Effort>,override_effort: Option<&str>,) -> Result<Option<Effort>, anyhow::Error> {diff --git a/src/server.rs b/src/server.rsindex d521980..4caf4f6 100644--- a/src/server.rs+++ b/src/server.rs@@ -4,8 +4,11 @@ use crate::{monitor::{EndpointKind, MonitorHandle},project,provider::RequestContext,- providers::codex::native::{- CodexNativeBackend, NativeResponseOutcome, openai_error, validate_native_request_model,+ providers::codex::{+ chat_completions::{ChatCompletionsBackend, request::translate_request},+ native::{+ CodexNativeBackend, NativeResponseOutcome, openai_error, validate_native_request_model,+ },},registry::{Registry, normalize_incoming_model},session::{self, SessionState},@@ -112,10 +115,12 @@ pub fn app_with_options(responses_api: bool,) -> Router {let native_responses = responses_api.then(|| Arc::new(CodexNativeBackend::new()));+ let chat_completions = responses_api.then(|| Arc::new(ChatCompletionsBackend::new()));let state = Arc::new(AppState {registry,monitor,native_responses,+ chat_completions,});let router = Router::new().route("/healthz", get(healthz))@@ -123,7 +128,9 @@ pub fn app_with_options(.route("/v1/messages/count_tokens", post(handler_count_tokens)).route("/v1/models", get(handler_models));let router = if responses_api {- router.route("/v1/responses", post(handler_responses))+ router+ .route("/v1/responses", post(handler_responses))+ .route("/v1/chat/completions", post(handler_chat_completions))} else {router};@@ -135,6 +142,7 @@ struct AppState {registry: Arc<Registry>,monitor: Option<MonitorHandle>,native_responses: Option<Arc<CodexNativeBackend>>,+ chat_completions: Option<Arc<ChatCompletionsBackend>>,}async fn healthz() -> Json<serde_json::Value> {@@ -221,19 +229,40 @@ async fn handler_responses(State(state): State<Arc<AppState>>, req: Request<BodyNone,Some("invalid_json"),);- log_native_request_completed(&log, &req_id, None, response.status(), started_at);+ log_native_request_completed(+ &log,+ &req_id,+ "responses",+ 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);+ log_native_request_completed(+ &log,+ &req_id,+ "responses",+ 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);+ log_native_request_completed(+ &log,+ &req_id,+ "responses",+ None,+ response.status(),+ started_at,+ );return monitor_response_body(response, request_guard);}let model = body@@ -319,6 +348,7 @@ async fn handler_responses(State(state): State<Arc<AppState>>, req: Request<Bodylog_native_request_completed(&log,&req_id,+ "responses",model.as_deref(),response.status(),started_at,@@ -326,6 +356,174 @@ async fn handler_responses(State(state): State<Arc<AppState>>, req: Request<Bodymonitor_response_body(response, request_guard)}+async fn handler_chat_completions(+ 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::ChatCompletions,+ );+ }+ 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,+ "chat_completions",+ None,+ response.status(),+ started_at,+ );+ return monitor_response_body(response, request_guard);+ }+ };+ let body = match parse_native_json_body(&body_bytes) {+ Ok(body) => body,+ Err(response) => {+ log_native_request_completed(+ &log,+ &req_id,+ "chat_completions",+ None,+ response.status(),+ started_at,+ );+ return monitor_response_body(response, request_guard);+ }+ };+ let translated = match translate_request(body.clone()) {+ Ok(translated) => translated,+ Err(error) => {+ let response = error.response();+ log_native_request_completed(+ &log,+ &req_id,+ "chat_completions",+ None,+ response.status(),+ started_at,+ );+ return monitor_response_body(response, request_guard);+ }+ };++ let now = current_millis();+ let session_state = session_id+ .as_deref()+ .and_then(|session_id| session::existing_session(Some(session_id), now));+ let current = session::record_session_request(+ session_id.as_deref(),+ session_state.as_ref(),+ "codex",+ &translated.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);+ }+ monitor.provider_selected(+ &req_id,+ "codex",+ &translated.model,+ translated.effort.clone(),+ );+ }++ 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": "chat_completions",+ "provider": "codex",+ "model": &translated.model,+ "requestedModel": &translated.requested_model,+ "effort": &translated.effort,+ "method": method.as_str(),+ "path": &path,+ "query": &query,+ "headers": headers_to_record(&headers),+ }),+ );+ capture.write_json("010-openai-chat-completions-request", &body);+ capture.write_json("020-upstream-request", &translated.upstream);+ }++ 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.chat_completions.as_ref() {+ Some(backend) => backend.handle(translated.clone(), context).await,+ None => openai_error(+ StatusCode::NOT_FOUND,+ "not_found_error",+ "Chat Completions API is disabled",+ None,+ None,+ ),+ };+ log_native_request_completed(+ &log,+ &req_id,+ "chat_completions",+ Some(&translated.model),+ response.status(),+ started_at,+ );+ monitor_response_body(response, request_guard)+}+fn native_session_id(headers: &http::HeaderMap) -> Option<String> {["x-claude-code-session-id",@@ -367,6 +565,7 @@ fn parse_native_json_body(body: &[u8]) -> Result<Value, Response> {fn log_native_request_completed(log: &Logger,req_id: &str,+ endpoint: &str,model: Option<&str>,status: StatusCode,started_at: Instant,@@ -375,7 +574,7 @@ fn log_native_request_completed("request_completed",Some(serde_json::Map::from_iter([("reqId".to_string(), json!(req_id)),- ("endpoint".to_string(), json!("responses")),+ ("endpoint".to_string(), json!(endpoint)),("provider".to_string(), json!("codex")),("model".to_string(), json!(model)),("countTokens".to_string(), json!(false)),diff --git a/tests/server.rs b/tests/server.rsindex 89c1afe..cb86954 100644--- a/tests/server.rs+++ b/tests/server.rs@@ -295,6 +295,74 @@ async fn enabled_native_responses_route_uses_openai_errors() {assert_eq!(body["error"]["code"], "invalid_json");}+#[tokio::test]+async fn chat_completions_route_uses_responses_api_gate() {+ let disabled = app_with_options(Arc::new(Registry::with_default_alias()), None, false);+ let response = disabled+ .oneshot(+ Request::builder()+ .method(Method::POST)+ .uri("/v1/chat/completions")+ .header("content-type", "application/json")+ .body(body_string(+ r#"{"model":"gpt-5.6-sol","messages":[{"role":"user","content":"hello"}]}"#,+ ))+ .unwrap(),+ )+ .await+ .unwrap();+ assert_eq!(response.status(), StatusCode::NOT_FOUND);++ let enabled = app_with_options(Arc::new(Registry::with_default_alias()), None, true);+ let response = enabled+ .oneshot(+ Request::builder()+ .method(Method::POST)+ .uri("/v1/chat/completions")+ .header("content-type", "application/json")+ .body(body_string("{"))+ .unwrap(),+ )+ .await+ .unwrap();+ assert_eq!(response.status(), StatusCode::BAD_REQUEST);+ let body: Value = serde_json::from_slice(+ &axum::body::to_bytes(response.into_body(), usize::MAX)+ .await+ .unwrap(),+ )+ .unwrap();+ assert_eq!(body["error"]["type"], "invalid_request_error");+ assert_eq!(body["error"]["code"], "invalid_json");+}++#[tokio::test]+async fn chat_completions_validation_returns_openai_parameter_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/chat/completions")+ .header("content-type", "application/json")+ .body(body_string(+ r#"{"model":"gpt-5.6-sol","messages":[{"role":"user","content":"hello"}],"max_tokens":100}"#,+ ))+ .unwrap(),+ )+ .await+ .unwrap();+ assert_eq!(response.status(), StatusCode::BAD_REQUEST);+ let body: Value = serde_json::from_slice(+ &axum::body::to_bytes(response.into_body(), usize::MAX)+ .await+ .unwrap(),+ )+ .unwrap();+ assert_eq!(body["error"]["param"], "max_tokens");+ assert_eq!(body["error"]["code"], "unsupported_parameter");+}+#[tokio::test]async fn unknown_routes_use_anthropic_not_found_error() {let app = app(Arc::new(Registry::with_default_alias()));