Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy
Rust
implement codex http provider with auth, request translation, sse streaming, and cli
Raine Virtaab1a57c5b485
diff --git a/Cargo.lock b/Cargo.lockindex 7c875ed..5277652 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -284,6 +284,7 @@ dependencies = ["http-body-util","once_cell","predicates",+ "regex-lite","reqwest","serde","serde_json",@@ -1038,6 +1039,12 @@ dependencies = ["regex-syntax",]+[[package]]+name = "regex-lite"+version = "0.1.9"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "cab834c73d247e67f4fae452806d17d3c7501756d98c8808d7c9c7aa7d18f973"+[[package]]name = "regex-syntax"version = "0.8.11"diff --git a/Cargo.toml b/Cargo.tomlindex c0b0cfb..90d0875 100644--- a/Cargo.toml+++ b/Cargo.toml@@ -29,6 +29,7 @@ reqwest = { version = "0.12", default-features = false, features = ["json", "strbase64 = "0.22"hostname = "0.4"once_cell = "1.20"+regex-lite = "0.1"[dev-dependencies]tempfile = "3.14"diff --git a/src/config.rs b/src/config.rsindex 29df6bc..96123ff 100644--- a/src/config.rs+++ b/src/config.rs@@ -36,6 +36,25 @@ struct FileConfig {pub alias_provider: Option<String>,pub log: Option<FileLog>,pub kimi: Option<KimiConfig>,+ pub codex: Option<CodexConfig>,+}++#[derive(Deserialize, Clone)]+struct CodexConfig {+ #[serde(rename = "baseUrl")]+ pub base_url: Option<String>,+ #[serde(rename = "originator")]+ pub originator: Option<String>,+ #[serde(rename = "userAgent")]+ pub user_agent: Option<String>,+ #[serde(rename = "previousResponseId")]+ pub previous_response_id: Option<bool>,+ #[serde(rename = "serviceTier")]+ pub service_tier: Option<String>,+ #[serde(rename = "effort")]+ pub effort: Option<String>,+ #[serde(rename = "model")]+ pub model: Option<String>,}#[derive(Deserialize, Clone)]@@ -252,3 +271,119 @@ pub fn kimi_user_agent(default: &str) -> String {}default.to_string()}++// ---------------------------------------------------------------------------+// Codex config+// ---------------------------------------------------------------------------++pub fn codex_base_url(default: &str) -> String {+ let env: HashMap<_, _> = std::env::vars().collect();+ if let Some(raw) = env.get("CCP_CODEX_BASE_URL") {+ return raw.clone();+ }+ if let Some(raw) = env.get("CLAUDE_CODE_PROXY_CODEX_BASE_URL") {+ return raw.clone();+ }+ let config_dir = paths::config_dir();+ if let Some(file) = read_file_config(&config_dir) {+ if let Some(codex) = file.codex {+ if let Some(url) = codex.base_url {+ return url;+ }+ }+ }+ default.to_string()+}++pub fn codex_originator(default: &str) -> String {+ let env: HashMap<_, _> = std::env::vars().collect();+ if let Some(raw) = env.get("CCP_CODEX_ORIGINATOR") {+ return raw.clone();+ }+ let config_dir = paths::config_dir();+ if let Some(file) = read_file_config(&config_dir) {+ if let Some(codex) = file.codex {+ if let Some(val) = codex.originator {+ return val;+ }+ }+ }+ default.to_string()+}++pub fn codex_user_agent(default: &str) -> String {+ let env: HashMap<_, _> = std::env::vars().collect();+ if let Some(raw) = env.get("CCP_CODEX_USER_AGENT") {+ return raw.clone();+ }+ if let Some(raw) = env.get("CCP_USER_AGENT") {+ return raw.clone();+ }+ let config_dir = paths::config_dir();+ if let Some(file) = read_file_config(&config_dir) {+ if let Some(codex) = file.codex {+ if let Some(ua) = codex.user_agent {+ return ua;+ }+ }+ }+ default.to_string()+}++pub fn codex_previous_response_id() -> bool {+ let env: HashMap<_, _> = std::env::vars().collect();+ if let Some(raw) = env.get("CCP_CODEX_PREVIOUS_RESPONSE_ID") {+ 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) {+ if let Some(codex) = file.codex {+ if let Some(val) = codex.previous_response_id {+ return val;+ }+ }+ }+ 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") {+ return Some(raw.clone());+ }+ let config_dir = paths::config_dir();+ if let Some(file) = read_file_config(&config_dir) {+ if let Some(codex) = file.codex {+ return codex.service_tier;+ }+ }+ None+}++pub fn codex_effort() -> Option<String> {+ let env: HashMap<_, _> = std::env::vars().collect();+ if let Some(raw) = env.get("CCP_CODEX_EFFORT") {+ return Some(raw.clone());+ }+ let config_dir = paths::config_dir();+ if let Some(file) = read_file_config(&config_dir) {+ if let Some(codex) = file.codex {+ return codex.effort;+ }+ }+ None+}++pub fn codex_model() -> Option<String> {+ let env: HashMap<_, _> = std::env::vars().collect();+ if let Some(raw) = env.get("CCP_CODEX_MODEL") {+ return Some(raw.clone());+ }+ let config_dir = paths::config_dir();+ if let Some(file) = read_file_config(&config_dir) {+ if let Some(codex) = file.codex {+ return codex.model;+ }+ }+ None+}diff --git a/src/providers/codex/auth/constants.rs b/src/providers/codex/auth/constants.rsnew file mode 100644index 0000000..5573cfc--- /dev/null+++ b/src/providers/codex/auth/constants.rs@@ -0,0 +1,5 @@+pub const CLIENT_ID: &str = "app_EMoamEEZ73f0CkXaXp7hrann";+pub const ISSUER: &str = "https://auth.openai.com";+pub const CODEX_API_ENDPOINT: &str = "https://chatgpt.com/backend-api/codex/responses";+pub const ORIGINATOR: &str = "claude-code-proxy";+pub const REFRESH_MARGIN_MS: u64 = 5 * 60 * 1000;diff --git a/src/providers/codex/auth/jwt.rs b/src/providers/codex/auth/jwt.rsnew file mode 100644index 0000000..ac94b40--- /dev/null+++ b/src/providers/codex/auth/jwt.rs@@ -0,0 +1,117 @@+use serde::Deserialize;++#[derive(Debug, Deserialize)]+struct IdTokenClaims {+ #[serde(default)]+ chatgpt_account_id: Option<String>,+ #[serde(default)]+ organizations: Option<Vec<OrgClaim>>,+ #[serde(default)]+ email: Option<String>,+ #[serde(default)]+ #[serde(rename = "https://api.openai.com/auth")]+ openai_auth: Option<OpenAiAuthClaim>,+ #[serde(default)]+ #[serde(rename = "https://api.openai.com/auth.chatgpt_account_id")]+ openai_chatgpt_account_id: Option<String>,+}++#[derive(Debug, Deserialize)]+struct OrgClaim {+ id: String,+}++#[derive(Debug, Deserialize)]+struct OpenAiAuthClaim {+ #[serde(default)]+ chatgpt_account_id: Option<String>,+}++#[derive(Debug, Deserialize)]+pub struct TokenResponse {+ pub id_token: Option<String>,+ pub access_token: String,+ pub refresh_token: String,+ pub expires_in: Option<u64>,+}++fn parse_jwt_claims(token: &str) -> Option<IdTokenClaims> {+ let parts: Vec<&str> = token.split('.').collect();+ if parts.len() != 3 {+ return None;+ }+ let payload_b64 = parts[1].replace('-', "+").replace('_', "/");+ let padded = match payload_b64.len() % 4 {+ 2 => format!("{payload_b64}=="),+ 3 => format!("{payload_b64}="),+ _ => payload_b64,+ };+ use base64::Engine;+ let decoded = base64::engine::general_purpose::STANDARD+ .decode(&padded)+ .ok()?;+ serde_json::from_slice(&decoded).ok()+}++fn extract_account_id_from_claims(claims: &IdTokenClaims) -> Option<String> {+ claims+ .chatgpt_account_id+ .clone()+ .or_else(|| claims.openai_auth.as_ref()?.chatgpt_account_id.clone())+ .or_else(|| claims.openai_chatgpt_account_id.clone())+ .or_else(|| claims.organizations.as_ref()?.first()?.id.clone().into())+}++pub fn extract_account_id(tokens: &TokenResponse) -> Option<String> {+ if let Some(ref id_token) = tokens.id_token {+ if let Some(claims) = parse_jwt_claims(id_token) {+ if let Some(account_id) = extract_account_id_from_claims(&claims) {+ return Some(account_id);+ }+ }+ }+ let claims = parse_jwt_claims(&tokens.access_token)?;+ extract_account_id_from_claims(&claims)+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn extract_account_id_from_access_token() {+ let token = TokenResponse {+ id_token: None,+ access_token: "eyJhbGciOiJIUzI1NiJ9.eyJjaGF0Z3B0X2FjY291bnRfaWQiOiJhY2N0XzEyMyJ9.sig"+ .into(),+ refresh_token: "r".into(),+ expires_in: Some(3600),+ };+ assert_eq!(extract_account_id(&token), Some("acct_123".into()));+ }++ #[test]+ fn extract_account_id_from_id_token_takes_precedence() {+ let token = TokenResponse {+ id_token: Some(+ "eyJhbGciOiJIUzI1NiJ9.eyJjaGF0Z3B0X2FjY291bnRfaWQiOiJpZF9hY2N0In0.sig".into(),+ ),+ access_token: "eyJhbGciOiJIUzI1NiJ9.eyJjaGF0Z3B0X2FjY291bnRfaWQiOiJhY2NfYWNjIn0.sig"+ .into(),+ refresh_token: "r".into(),+ expires_in: Some(3600),+ };+ assert_eq!(extract_account_id(&token), Some("id_acct".into()));+ }++ #[test]+ fn extract_account_id_returns_none_for_invalid_token() {+ let token = TokenResponse {+ id_token: None,+ access_token: "invalid".into(),+ refresh_token: "r".into(),+ expires_in: None,+ };+ assert_eq!(extract_account_id(&token), None);+ }+}diff --git a/src/providers/codex/auth/manager.rs b/src/providers/codex/auth/manager.rsnew file mode 100644index 0000000..b1aa066--- /dev/null+++ b/src/providers/codex/auth/manager.rs@@ -0,0 +1,198 @@+use std::sync::{Arc, Mutex};+use std::time::{SystemTime, UNIX_EPOCH};++use super::constants::{CLIENT_ID, ISSUER, REFRESH_MARGIN_MS};+use super::jwt::{TokenResponse, extract_account_id};+use super::token_store::{CodexTokenStore, StoredAuth};+use crate::auth::AuthStorage;++pub struct CodexAuthManager<S: AuthStorage<StoredAuth>> {+ pub store: CodexTokenStore<S>,+ cached: Arc<Mutex<Option<StoredAuth>>>,+}++impl<S: AuthStorage<StoredAuth>> CodexAuthManager<S> {+ pub fn new(store: CodexTokenStore<S>) -> Self {+ Self {+ store,+ cached: Arc::new(Mutex::new(None)),+ }+ }++ fn now_ms() -> u64 {+ SystemTime::now()+ .duration_since(UNIX_EPOCH)+ .unwrap_or_default()+ .as_millis() as u64+ }++ pub fn get_auth(&self) -> Result<StoredAuth, anyhow::Error> {+ let cached = {+ let guard = self.cached.lock().map_err(|e| anyhow::anyhow!("{e}"))?;+ guard.clone()+ };+ let stored = match cached {+ Some(ref auth) => auth.clone(),+ None => {+ let loaded = self.store.load_auth()?;+ match loaded {+ Some(auth) => {+ let mut guard = self.cached.lock().map_err(|e| anyhow::anyhow!("{e}"))?;+ *guard = Some(auth.clone());+ auth+ }+ None => {+ anyhow::bail!("Not authenticated. Run: claude-code-proxy codex auth login");+ }+ }+ }+ };++ if stored.expires > Self::now_ms() + REFRESH_MARGIN_MS {+ return Ok(stored);+ }++ self.refresh_now(&stored)+ }++ pub fn force_refresh(&self) -> Result<StoredAuth, anyhow::Error> {+ let stored = {+ let guard = self.cached.lock().map_err(|e| anyhow::anyhow!("{e}"))?;+ guard.clone()+ };+ let stored = match stored {+ Some(auth) => auth,+ None => {+ let loaded = self.store.load_auth()?;+ loaded.ok_or_else(|| anyhow::anyhow!("Not authenticated"))?+ }+ };+ self.refresh_now(&stored)+ }++ fn refresh_now(&self, current: &StoredAuth) -> Result<StoredAuth, anyhow::Error> {+ if current.refresh.is_empty() {+ anyhow::bail!("No refresh token stored; re-authenticate");+ }++ let client = reqwest::blocking::Client::new();+ let form = [+ ("client_id", CLIENT_ID.to_string()),+ ("grant_type", "refresh_token".to_string()),+ ("refresh_token", current.refresh.clone()),+ ];++ let resp = client+ .post(format!("{ISSUER}/oauth/token"))+ .form(&form)+ .send()+ .map_err(|e| anyhow::anyhow!("refresh network error: {e}"))?;++ let status = resp.status().as_u16();+ if status == 401 || status == 403 {+ {+ let mut guard = self.cached.lock().map_err(|e| anyhow::anyhow!("{e}"))?;+ *guard = None;+ }+ let _ = self.store.clear_auth();+ let err_msg = resp+ .text()+ .unwrap_or_else(|_| "Token refresh unauthorized".to_string());+ anyhow::bail!("{err_msg}");+ }++ if !resp.status().is_success() {+ anyhow::bail!("Token refresh failed: {status}");+ }++ let tokens: TokenResponse = resp+ .json()+ .map_err(|e| anyhow::anyhow!("failed to parse token response: {e}"))?;+ let account_id = extract_account_id(&tokens).or_else(|| current.account_id.clone());+ let expires = Self::now_ms() + (tokens.expires_in.unwrap_or(3600) * 1000);+ let next = StoredAuth {+ access: tokens.access_token,+ refresh: tokens.refresh_token,+ expires,+ account_id,+ };+ self.store.save_auth(next.clone())?;+ {+ let mut guard = self.cached.lock().map_err(|e| anyhow::anyhow!("{e}"))?;+ *guard = Some(next.clone());+ }+ Ok(next)+ }++ pub fn persist_initial_tokens(+ &self,+ tokens: &TokenResponse,+ ) -> Result<StoredAuth, anyhow::Error> {+ let account_id = extract_account_id(tokens);+ let expires = Self::now_ms() + (tokens.expires_in.unwrap_or(3600) * 1000);+ let auth = StoredAuth {+ access: tokens.access_token.clone(),+ refresh: tokens.refresh_token.clone(),+ expires,+ account_id,+ };+ self.store.save_auth(auth.clone())?;+ {+ let mut guard = self.cached.lock().map_err(|e| anyhow::anyhow!("{e}"))?;+ *guard = Some(auth.clone());+ }+ Ok(auth)+ }++ pub fn set_cached(&self, auth: StoredAuth) {+ if let Ok(mut guard) = self.cached.lock() {+ *guard = Some(auth);+ }+ }++ pub fn reset_cache(&self) {+ if let Ok(mut guard) = self.cached.lock() {+ *guard = None;+ }+ }+}++#[cfg(test)]+mod tests {+ use super::*;+ use crate::auth::InMemoryAuthStore;++ fn test_store() -> CodexTokenStore<InMemoryAuthStore<StoredAuth>> {+ CodexTokenStore::new(InMemoryAuthStore::new())+ }++ #[test]+ fn get_auth_returns_stored() {+ let store = test_store();+ let auth = StoredAuth {+ access: "test_access".into(),+ refresh: "test_refresh".into(),+ expires: 9999999999999,+ account_id: Some("acct_1".into()),+ };+ store.save_auth(auth.clone()).unwrap();+ let manager = CodexAuthManager::new(store);+ let result = manager.get_auth().unwrap();+ assert_eq!(result.access, "test_access");+ assert_eq!(result.account_id.as_deref(), Some("acct_1"));+ }++ #[test]+ fn get_auth_fails_when_no_auth() {+ let store = test_store();+ let manager = CodexAuthManager::new(store);+ assert!(manager.get_auth().is_err());+ assert!(+ manager+ .get_auth()+ .unwrap_err()+ .to_string()+ .contains("Not authenticated")+ );+ }+}diff --git a/src/providers/codex/auth/mod.rs b/src/providers/codex/auth/mod.rsnew file mode 100644index 0000000..737d908--- /dev/null+++ b/src/providers/codex/auth/mod.rs@@ -0,0 +1,4 @@+pub mod constants;+pub mod jwt;+pub mod manager;+pub mod token_store;diff --git a/src/providers/codex/auth/token_store.rs b/src/providers/codex/auth/token_store.rsnew file mode 100644index 0000000..9f7da74--- /dev/null+++ b/src/providers/codex/auth/token_store.rs@@ -0,0 +1,83 @@+use serde::{Deserialize, Serialize};++use crate::auth::{AuthStorage, FileAuthStore};+use crate::paths;++#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]+pub struct StoredAuth {+ pub access: String,+ pub refresh: String,+ pub expires: u64,+ #[serde(default, alias = "accountId", skip_serializing_if = "Option::is_none")]+ pub account_id: Option<String>,+}++pub struct CodexTokenStore<S: AuthStorage<StoredAuth>> {+ store: S,+}++impl<S: AuthStorage<StoredAuth>> CodexTokenStore<S> {+ pub fn new(store: S) -> Self {+ Self { store }+ }++ pub fn load_auth(&self) -> Result<Option<StoredAuth>, anyhow::Error> {+ self.store.load()+ }++ pub fn save_auth(&self, value: StoredAuth) -> Result<(), anyhow::Error> {+ self.store.save(value)+ }++ pub fn clear_auth(&self) -> Result<(), anyhow::Error> {+ self.store.clear()+ }++ pub fn auth_path(&self) -> String {+ self.store.path()+ }+}++pub fn file_store() -> CodexTokenStore<FileAuthStore<StoredAuth>> {+ let primary = paths::provider_auth_file("codex");+ let legacy = paths::provider_legacy_auth_file("codex");+ let store = FileAuthStore::new(+ primary.to_string_lossy().to_string(),+ legacy.to_string_lossy().to_string(),+ );+ CodexTokenStore::new(store)+}++#[cfg(test)]+mod tests {+ use super::*;+ use crate::auth::InMemoryAuthStore;+ use serde_json::json;++ #[test]+ fn stored_auth_reads_account_id_alias() {+ let auth: StoredAuth = serde_json::from_value(json!({+ "access": "a",+ "refresh": "r",+ "expires": 123,+ "accountId": "acct"+ }))+ .unwrap();+ assert_eq!(auth.account_id.as_deref(), Some("acct"));+ }++ #[test]+ fn stored_auth_roundtrip() {+ let store = CodexTokenStore::new(InMemoryAuthStore::new());+ let auth = StoredAuth {+ access: "token".into(),+ refresh: "refresh".into(),+ expires: 9999999999999,+ account_id: Some("acct_1".into()),+ };+ store.save_auth(auth.clone()).unwrap();+ let loaded = store.load_auth().unwrap().unwrap();+ assert_eq!(loaded.access, "token");+ assert_eq!(loaded.account_id.as_deref(), Some("acct_1"));+ }+}diff --git a/src/providers/codex/client.rs b/src/providers/codex/client.rsnew file mode 100644index 0000000..7f3b719--- /dev/null+++ b/src/providers/codex/client.rs@@ -0,0 +1,362 @@+use std::time::Duration;++use crate::config;+use crate::provider::RequestContext;+use crate::retry::{compute_backoff_delay, sleep};++use super::auth::constants::{CODEX_API_ENDPOINT, ORIGINATOR};+use super::auth::manager::CodexAuthManager;+use super::auth::token_store::{StoredAuth, file_store};+use super::translate::request::ResponsesRequest;++// ---------------------------------------------------------------------------+// Errors+// ---------------------------------------------------------------------------++#[derive(Debug)]+pub struct CodexError {+ pub status: u16,+ pub message: String,+ pub detail: Option<String>,+ pub retry_after: Option<String>,+}++impl std::fmt::Display for CodexError {+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {+ write!(f, "Codex error {}: {}", self.status, self.message)+ }+}++#[derive(Debug)]+pub struct CodexHeaderTimeoutError {+ pub timeout_ms: u64,+}++impl std::fmt::Display for CodexHeaderTimeoutError {+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {+ write!(+ f,+ "Timed out waiting {}ms for Codex response headers",+ self.timeout_ms+ )+ }+}++#[derive(Debug)]+pub struct CodexTransportError {+ pub message: String,+}++impl std::fmt::Display for CodexTransportError {+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {+ write!(f, "Codex transport error: {}", self.message)+ }+}++// ---------------------------------------------------------------------------+// Response+// ---------------------------------------------------------------------------++pub struct CodexResponse {+ pub body: Vec<u8>,+ pub status: u16,+ pub headers: Vec<(String, String)>,+}++// ---------------------------------------------------------------------------+// Client+// ---------------------------------------------------------------------------++pub struct CodexHttpClient {+ client: reqwest::Client,+ auth_manager: CodexAuthManager<crate::auth::FileAuthStore<StoredAuth>>,+ base_url: String,+ header_timeout_ms: u64,+ header_timeout_retries: u32,+}++impl CodexHttpClient {+ pub fn new() -> Self {+ let timeout_ms = 60_000;+ Self {+ client: reqwest::Client::builder()+ .connect_timeout(Duration::from_secs(15))+ .timeout(Duration::from_millis(timeout_ms + 10_000))+ .build()+ .expect("failed to create HTTP client"),+ auth_manager: CodexAuthManager::new(file_store()),+ base_url: config::codex_base_url(CODEX_API_ENDPOINT),+ header_timeout_ms: timeout_ms,+ header_timeout_retries: 1,+ }+ }++ pub fn new_with_client(+ client: reqwest::Client,+ auth_manager: CodexAuthManager<crate::auth::FileAuthStore<StoredAuth>>,+ base_url: String,+ ) -> Self {+ Self {+ client,+ auth_manager,+ base_url,+ header_timeout_ms: 60_000,+ header_timeout_retries: 1,+ }+ }++ #[cfg(test)]+ pub fn new_for_test(+ client: reqwest::Client,+ base_url: String,+ header_timeout_ms: u64,+ header_timeout_retries: u32,+ ) -> Self {+ Self {+ client,+ auth_manager: CodexAuthManager::new(file_store()),+ base_url,+ header_timeout_ms,+ header_timeout_retries,+ }+ }++ pub fn auth_manager(&self) -> &CodexAuthManager<crate::auth::FileAuthStore<StoredAuth>> {+ &self.auth_manager+ }++ pub async fn post_codex(+ &self,+ body: &ResponsesRequest,+ ctx: &RequestContext,+ ) -> Result<CodexResponse, CodexError> {+ let mut auth = self.auth_manager.get_auth().map_err(|e| CodexError {+ status: 401,+ message: "Auth error".to_string(),+ detail: Some(e.to_string()),+ retry_after: None,+ })?;++ // Wrap attempt in retry loop for header timeout and transport errors+ let max_transport_retries = 10u32;+ for transport_attempt in 0..=max_transport_retries {+ // Inner loop for 429 rate limiting+ let result = self.attempt_post(&auth, body, ctx, transport_attempt).await;++ match result {+ Ok(response) if response.status == 401 && transport_attempt == 0 => {+ // First 401: try refresh+ match self.auth_manager.force_refresh() {+ Ok(new_auth) => {+ auth = new_auth;+ // Don't increment transport_attempt, retry the same attempt index+ continue;+ }+ Err(e) => {+ return Err(CodexError {+ status: 401,+ message: "Unauthorized".to_string(),+ detail: Some(e.to_string()),+ retry_after: None,+ });+ }+ }+ }+ Ok(response) if response.status == 403 => {+ let detail = String::from_utf8_lossy(&response.body).to_string();+ return Err(CodexError {+ status: 403,+ message: "Forbidden".to_string(),+ detail: Some(detail),+ retry_after: None,+ });+ }+ Ok(response) if response.status == 429 => {+ let retry_after = response+ .headers+ .iter()+ .find(|(k, _)| k.to_lowercase() == "retry-after")+ .map(|(_, v)| v.clone());+ if transport_attempt < 3 {+ let delay =+ compute_backoff_delay(transport_attempt, retry_after.as_deref());+ sleep(delay.wait_ms).await;+ continue;+ }+ let detail = String::from_utf8_lossy(&response.body).to_string();+ return Err(CodexError {+ status: 429,+ message: "Rate limited".to_string(),+ detail: Some(detail),+ retry_after,+ });+ }+ Ok(response) => return Ok(response),+ Err(err) => {+ // Determine if retryable+ let retryable = is_retryable_transport_error(&err);+ if retryable && transport_attempt < max_transport_retries {+ let delay = compute_backoff_delay(transport_attempt, None);+ sleep(delay.wait_ms).await;+ continue;+ }+ return Err(err);+ }+ }+ }++ Err(CodexError {+ status: 0,+ message: "Max retries exceeded".to_string(),+ detail: None,+ retry_after: None,+ })+ }++ async fn attempt_post(+ &self,+ auth: &StoredAuth,+ body: &ResponsesRequest,+ ctx: &RequestContext,+ _attempt: u32,+ ) -> Result<CodexResponse, CodexError> {+ let url = &self.base_url;+ let body_json = serde_json::to_string(body).map_err(|e| CodexError {+ status: 500,+ message: "Failed to serialize request".to_string(),+ detail: Some(e.to_string()),+ retry_after: None,+ })?;++ // Build headers+ let mut req_builder = self+ .client+ .post(url)+ .header("Content-Type", "application/json")+ .header("Accept", "text/event-stream")+ .header("Authorization", format!("Bearer {}", auth.access))+ .header("originator", config::codex_originator(ORIGINATOR))+ .header("openai-beta", "responses=experimental");++ if let Some(ref account_id) = auth.account_id {+ req_builder = req_builder.header("ChatGPT-Account-Id", account_id);+ }+ if let Some(ref session_id) = ctx.session_id {+ req_builder = req_builder+ .header("session_id", session_id)+ .header("x-client-request-id", session_id)+ .header("x-codex-window-id", format!("{session_id}:0"));+ }++ let user_agent =+ config::codex_user_agent(&format!("claude-code-proxy/{}", env!("CARGO_PKG_VERSION")));+ if !user_agent.is_empty() {+ req_builder = req_builder.header("User-Agent", user_agent);+ }++ // Apply header timeout+ let send_fut = req_builder.body(body_json.clone()).send();+ let header_timeout_dur = Duration::from_millis(self.header_timeout_ms);++ let resp = tokio::time::timeout(header_timeout_dur, send_fut)+ .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,+ })?+ .map_err(|e| {+ if is_retryable_reqwest_error(&e) {+ CodexError {+ status: 0,+ message: format!("Transport error: {e}"),+ detail: None,+ retry_after: None,+ }+ } else {+ CodexError {+ status: 0,+ message: format!("Network error: {e}"),+ detail: None,+ retry_after: None,+ }+ }+ })?;++ let status = resp.status().as_u16();+ let headers: Vec<(String, String)> = resp+ .headers()+ .iter()+ .map(|(k, v)| (k.to_string(), v.to_str().unwrap_or("").to_string()))+ .collect();++ let body_bytes = resp.bytes().await.unwrap_or_default().to_vec();++ Ok(CodexResponse {+ body: body_bytes,+ status,+ headers,+ })+ }+}++fn is_retryable_transport_error(err: &CodexError) -> bool {+ err.status == 0+ && (err.message.contains("Timed out waiting")+ || err.message.contains("Transport error")+ || err.message.contains("connection reset")+ || err.message.contains("connection closed")+ || err.message.contains("timed out")+ || err.message.contains("econnreset")+ || err.message.contains("etimedout"))+}++fn is_retryable_reqwest_error(err: &reqwest::Error) -> bool {+ if err.is_timeout() || err.is_connect() {+ return true;+ }+ let msg = err.to_string().to_lowercase();+ msg.contains("connection reset")+ || msg.contains("connection closed")+ || msg.contains("econnreset")+ || msg.contains("etimedout")+ || msg.contains("epipe")+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn codex_error_display() {+ let err = CodexError {+ status: 429,+ message: "Rate limited".to_string(),+ detail: Some("body".to_string()),+ retry_after: Some("5".to_string()),+ };+ let display = format!("{err}");+ assert!(display.contains("429"));+ assert!(display.contains("Rate limited"));+ }++ #[test]+ fn codex_header_timeout_error_display() {+ let err = CodexHeaderTimeoutError { timeout_ms: 60000 };+ let display = format!("{err}");+ assert!(display.contains("60000"));+ }++ #[test]+ fn codex_transport_error_display() {+ let err = CodexTransportError {+ message: "connection reset".to_string(),+ };+ let display = format!("{err}");+ assert!(display.contains("connection reset"));+ }+}diff --git a/src/providers/codex/continuation.rs b/src/providers/codex/continuation.rsnew file mode 100644index 0000000..baf583b--- /dev/null+++ b/src/providers/codex/continuation.rs@@ -0,0 +1,425 @@+use std::collections::HashMap;+use std::sync::Mutex;++use super::translate::request::{ResponsesInputItem, ResponsesRequest};++const TTL_MS: u64 = 30 * 60 * 1000;+const MAX_STATES: usize = 10_000;+const MAX_SESSION_TRANSCRIPT_BYTES: u64 = 2_000_000;+const MAX_TOTAL_TRANSCRIPT_BYTES: u64 = 20_000_000;++#[derive(Clone)]+struct ContinuationState {+ response_id: String,+ prompt_signature: String,+ transcript: Vec<ResponsesInputItem>,+ transcript_bytes: u64,+ updated_at: u64,+}++static STATES: Mutex<Option<HashMap<String, ContinuationState>>> = Mutex::new(None);+static TOTAL_TRANSCRIPT_BYTES: Mutex<u64> = Mutex::new(0);++pub struct ContinuationCandidate {+ pub previous_response_id: Option<String>,+ pub input_delta: Option<Vec<ResponsesInputItem>>,+ pub input_delta_count: usize,+ pub disabled_reason: Option<String>,+}++fn now_ms() -> u64 {+ std::time::SystemTime::now()+ .duration_since(std::time::UNIX_EPOCH)+ .unwrap_or_default()+ .as_millis() as u64+}++pub fn continuation_candidate(+ session_id: Option<&str>,+ body: &ResponsesRequest,+ enabled: bool,+) -> ContinuationCandidate {+ let now = now_ms();++ if !enabled {+ return ContinuationCandidate {+ previous_response_id: None,+ input_delta: None,+ input_delta_count: body.input.len(),+ disabled_reason: Some("disabled".to_string()),+ };+ }++ let session_id = match session_id {+ Some(s) => s,+ None => {+ return ContinuationCandidate {+ previous_response_id: None,+ input_delta: None,+ input_delta_count: body.input.len(),+ disabled_reason: Some("missing_session".to_string()),+ };+ }+ };++ let state = {+ let guard = STATES.lock().unwrap();+ guard.as_ref().and_then(|m| m.get(session_id).cloned())+ };+ let state = match state {+ Some(s) if now - s.updated_at <= TTL_MS => s,+ Some(_) => {+ clear_continuation(Some(session_id));+ return ContinuationCandidate {+ previous_response_id: None,+ input_delta: None,+ input_delta_count: body.input.len(),+ disabled_reason: Some("missing_state".to_string()),+ };+ }+ None => {+ return ContinuationCandidate {+ previous_response_id: None,+ input_delta: None,+ input_delta_count: body.input.len(),+ disabled_reason: Some("missing_state".to_string()),+ };+ }+ };++ let signature = prompt_signature(body);+ if signature != state.prompt_signature {+ clear_continuation(Some(session_id));+ return ContinuationCandidate {+ previous_response_id: None,+ input_delta: None,+ input_delta_count: body.input.len(),+ disabled_reason: Some("prompt_changed".to_string()),+ };+ }++ let suffix = input_suffix_after_prefix(&body.input, &state.transcript);+ let suffix = match suffix {+ Some(s) => s,+ None => {+ clear_continuation(Some(session_id));+ return ContinuationCandidate {+ previous_response_id: None,+ input_delta: None,+ input_delta_count: body.input.len(),+ disabled_reason: Some("not_append_only".to_string()),+ };+ }+ };++ if suffix.is_empty() {+ return ContinuationCandidate {+ previous_response_id: None,+ input_delta: None,+ input_delta_count: 0,+ disabled_reason: Some("empty_delta".to_string()),+ };+ }++ ContinuationCandidate {+ previous_response_id: Some(state.response_id),+ input_delta: Some(suffix.clone()),+ input_delta_count: suffix.len(),+ disabled_reason: None,+ }+}++pub fn record_continuation(+ session_id: Option<&str>,+ request_body: &ResponsesRequest,+ response_id: Option<&str>,+ output_items: &[ResponsesInputItem],+) {+ let session_id = match session_id {+ Some(s) => s,+ None => return,+ };++ let response_id = match response_id {+ Some(id) => id.to_string(),+ None => {+ clear_continuation(Some(session_id));+ return;+ }+ };++ let mut transcript: Vec<ResponsesInputItem> = request_body.input.clone();+ transcript.extend_from_slice(output_items);++ let transcript_json = serde_json::to_string(&transcript).unwrap_or_default();+ let transcript_bytes = transcript_json.len() as u64;++ if transcript_bytes > MAX_SESSION_TRANSCRIPT_BYTES {+ clear_continuation(Some(session_id));+ return;+ }++ clear_continuation(Some(session_id));++ let state = ContinuationState {+ response_id,+ prompt_signature: prompt_signature(request_body),+ transcript,+ transcript_bytes,+ updated_at: now_ms(),+ };++ {+ let mut guard = TOTAL_TRANSCRIPT_BYTES.lock().unwrap();+ *guard += transcript_bytes;+ }+ {+ let mut guard = STATES.lock().unwrap();+ let map = guard.get_or_insert_with(HashMap::new);+ map.insert(session_id.to_string(), state);+ }+ evict_oldest();+}++pub fn clear_continuation(session_id: Option<&str>) {+ let session_id = match session_id {+ Some(s) => s,+ None => return,+ };+ let mut guard = STATES.lock().unwrap();+ if let Some(map) = guard.as_mut() {+ if let Some(existing) = map.remove(session_id) {+ let mut bytes_guard = TOTAL_TRANSCRIPT_BYTES.lock().unwrap();+ *bytes_guard = bytes_guard.saturating_sub(existing.transcript_bytes);+ }+ }+}++pub fn has_continuation_for_tests(session_id: &str) -> bool {+ let guard = STATES.lock().unwrap();+ guard.as_ref().map_or(false, |m| m.contains_key(session_id))+}++pub fn clear_all_continuations_for_tests() {+ let mut guard = STATES.lock().unwrap();+ *guard = None;+ let mut bytes_guard = TOTAL_TRANSCRIPT_BYTES.lock().unwrap();+ *bytes_guard = 0;+}++fn input_suffix_after_prefix(+ input: &[ResponsesInputItem],+ prefix: &[ResponsesInputItem],+) -> Option<Vec<ResponsesInputItem>> {+ if prefix.len() > input.len() {+ return None;+ }+ for i in 0..prefix.len() {+ let a = serde_json::to_value(&input[i]).unwrap_or_default();+ let b = serde_json::to_value(&prefix[i]).unwrap_or_default();+ if a != b {+ return None;+ }+ }+ Some(input[prefix.len()..].to_vec())+}++fn prompt_signature(body: &ResponsesRequest) -> String {+ let value = serde_json::to_value(body).unwrap_or_default();+ let obj = match value.as_object() {+ Some(o) => o,+ None => return String::new(),+ };+ let mut entries: Vec<(&String, &serde_json::Value)> =+ obj.iter().filter(|(k, _)| *k != "input").collect();+ entries.sort_by(|(a, _), (b, _)| a.cmp(b));+ let mut sig = String::from("{");+ for (i, (key, val)) in entries.iter().enumerate() {+ if i > 0 {+ sig.push(',');+ }+ sig.push_str(&format!("\"{}\":{}", key, stable_json(val)));+ }+ sig.push('}');+ sig+}++fn stable_json(value: &serde_json::Value) -> String {+ match value {+ serde_json::Value::Null => "null".to_string(),+ serde_json::Value::Bool(b) => b.to_string(),+ serde_json::Value::Number(n) => n.to_string(),+ serde_json::Value::String(s) => serde_json::to_string(s).unwrap_or_default(),+ serde_json::Value::Array(arr) => {+ let items: Vec<String> = arr.iter().map(stable_json).collect();+ format!("[{}]", items.join(","))+ }+ serde_json::Value::Object(obj) => {+ let mut entries: Vec<(&String, &serde_json::Value)> = obj.iter().collect();+ entries.sort_by(|(a, _), (b, _)| a.cmp(b));+ let items: Vec<String> = entries+ .iter()+ .map(|(k, v)| {+ format!(+ "{}:{}",+ serde_json::to_string(k).unwrap_or_default(),+ stable_json(v)+ )+ })+ .collect();+ format!("{{{}}}", items.join(","))+ }+ }+}++fn evict_oldest() {+ let mut guard = STATES.lock().unwrap();+ let map = match guard.as_mut() {+ Some(m) => m,+ None => return,+ };+ let mut bytes_guard = TOTAL_TRANSCRIPT_BYTES.lock().unwrap();+ while map.len() > MAX_STATES || *bytes_guard > MAX_TOTAL_TRANSCRIPT_BYTES {+ let key = map.keys().next().cloned();+ match key {+ Some(k) => {+ if let Some(existing) = map.remove(&k) {+ *bytes_guard = bytes_guard.saturating_sub(existing.transcript_bytes);+ }+ }+ None => break,+ }+ }+}++#[cfg(test)]+mod tests {+ use super::*;+ use serde_json::json;++ fn request_with_input(+ input: Vec<ResponsesInputItem>,+ extra: Option<serde_json::Value>,+ ) -> ResponsesRequest {+ let mut fields = serde_json::Map::new();+ fields.insert("model".into(), json!("gpt-5.5"));+ fields.insert("input".into(), json!(input));+ fields.insert("store".into(), json!(false));+ fields.insert("stream".into(), json!(true));+ fields.insert("text".into(), json!({"verbosity": "low"}));+ fields.insert("parallel_tool_calls".into(), json!(true));+ if let Some(extras) = extra {+ if let Some(obj) = extras.as_object() {+ for (k, v) in obj {+ fields.insert(k.clone(), v.clone());+ }+ }+ }+ serde_json::from_value(serde_json::Value::Object(fields)).unwrap()+ }++ #[test]+ fn continuation_behaviors() {+ // All tests run in sequence to avoid global state interference++ // disabled_when_not_enabled+ clear_all_continuations_for_tests();+ let input = vec![ResponsesInputItem::Message {+ role: "user".to_string(),+ content: vec![+ super::super::translate::request::ResponsesContentPart::InputText {+ text: "one".to_string(),+ },+ ],+ }];+ let req = request_with_input(input, None);+ let result = continuation_candidate(Some("s1"), &req, false);+ assert_eq!(result.disabled_reason, Some("disabled".to_string()));+ assert_eq!(result.input_delta_count, 1);++ // missing_session+ clear_all_continuations_for_tests();+ let input = vec![ResponsesInputItem::Message {+ role: "user".to_string(),+ content: vec![+ super::super::translate::request::ResponsesContentPart::InputText {+ text: "one".to_string(),+ },+ ],+ }];+ let req = request_with_input(input, None);+ let result = continuation_candidate(None, &req, true);+ assert_eq!(result.disabled_reason, Some("missing_session".to_string()));++ // uses_previous_response_id_for_append_only+ clear_all_continuations_for_tests();+ let input = vec![ResponsesInputItem::Message {+ role: "user".to_string(),+ content: vec![+ super::super::translate::request::ResponsesContentPart::InputText {+ text: "one".to_string(),+ },+ ],+ }];+ let req = request_with_input(input, None);+ record_continuation(Some("s1"), &req, Some("resp_1"), &[]);++ let input2 = vec![+ ResponsesInputItem::Message {+ role: "user".to_string(),+ content: vec![+ super::super::translate::request::ResponsesContentPart::InputText {+ text: "one".to_string(),+ },+ ],+ },+ ResponsesInputItem::Message {+ role: "user".to_string(),+ content: vec![+ super::super::translate::request::ResponsesContentPart::InputText {+ text: "two".to_string(),+ },+ ],+ },+ ];+ let req2 = request_with_input(input2, None);+ let result = continuation_candidate(Some("s1"), &req2, true);+ assert_eq!(result.previous_response_id, Some("resp_1".to_string()));+ assert_eq!(result.input_delta_count, 1);++ // clears_state_when_prompt_signature_changes+ clear_all_continuations_for_tests();+ let input = vec![ResponsesInputItem::Message {+ role: "user".to_string(),+ content: vec![+ super::super::translate::request::ResponsesContentPart::InputText {+ text: "one".to_string(),+ },+ ],+ }];+ let req = request_with_input(input.clone(), None);+ record_continuation(Some("s1"), &req, Some("resp_1"), &[]);++ let req2 = request_with_input(input, Some(json!({"service_tier": "flex"})));+ let result = continuation_candidate(Some("s1"), &req2, true);+ assert_eq!(result.disabled_reason, Some("prompt_changed".to_string()));+ assert!(!has_continuation_for_tests("s1"));++ // clears_state_when_missing_response_id+ clear_all_continuations_for_tests();+ let input = vec![ResponsesInputItem::Message {+ role: "user".to_string(),+ content: vec![+ super::super::translate::request::ResponsesContentPart::InputText {+ text: "one".to_string(),+ },+ ],+ }];+ let req = request_with_input(input.clone(), None);+ record_continuation(Some("s1"), &req, Some("resp_1"), &[]);+ assert!(has_continuation_for_tests("s1"));++ record_continuation(Some("s1"), &req, None, &[]);+ assert!(!has_continuation_for_tests("s1"));+ }+}diff --git a/src/providers/codex/count_tokens.rs b/src/providers/codex/count_tokens.rsnew file mode 100644index 0000000..af34591--- /dev/null+++ b/src/providers/codex/count_tokens.rs@@ -0,0 +1,163 @@+use super::translate::request::{+ ResponsesContentPart, ResponsesInputItem, ResponsesRequest, ResponsesTool,+};++/// Approximate token counter for Codex translated requests.+/// Uses a simple monotonic estimator that satisfies Claude Code's+/// compaction logic (needs approximate, not exact counts).++pub fn count_translated_tokens(translated: &ResponsesRequest) -> u64 {+ let mut total = 0u64;++ // Instructions+ if let Some(ref instructions) = translated.instructions {+ total += approx_token_count(instructions);+ }++ // Input items+ for item in &translated.input {+ total += count_input_item_tokens(item);+ }++ // Tools+ if let Some(ref tools) = translated.tools {+ total += count_tool_tokens(tools);+ }++ // Overhead+ total += translated.input.len() as u64 * 4;+ total += translated.tools.as_ref().map_or(0, |t| t.len() as u64 * 4);++ // Model name+ total += approx_token_count(&translated.model);++ total.max(1)+}++fn count_input_item_tokens(item: &ResponsesInputItem) -> u64 {+ match item {+ ResponsesInputItem::Message { content, .. } => {+ let mut total = 0u64;+ for part in content {+ total += count_content_part_tokens(part);+ }+ total+ }+ ResponsesInputItem::FunctionCall {+ name, arguments, ..+ } => approx_token_count(name) + approx_token_count(arguments),+ ResponsesInputItem::FunctionCallOutput { output, .. } => approx_token_count(output),+ }+}++fn count_content_part_tokens(part: &ResponsesContentPart) -> u64 {+ match part {+ ResponsesContentPart::InputText { text } => approx_token_count(text),+ ResponsesContentPart::OutputText { text } => approx_token_count(text),+ ResponsesContentPart::InputImage { .. } => 2000, // Image token estimate+ }+}++fn count_tool_tokens(tools: &[ResponsesTool]) -> u64 {+ let mut total = 0u64;+ for tool in tools {+ match tool {+ ResponsesTool::Function(f) => {+ total += approx_token_count(&f.name);+ if let Some(ref desc) = f.description {+ total += approx_token_count(desc);+ }+ total +=+ approx_token_count(&serde_json::to_string(&f.parameters).unwrap_or_default());+ }+ ResponsesTool::WebSearch(_) => {+ total += 10; // fixed overhead for web search tool+ }+ }+ }+ total+}++fn approx_token_count(text: &str) -> u64 {+ if text.is_empty() {+ return 0;+ }+ let mut count = 0u64;+ let mut in_word = false;++ for ch in text.chars() {+ if ch.is_alphanumeric() || ch == '-' || ch == '_' {+ if !in_word {+ count += 1;+ in_word = true;+ }+ } else {+ in_word = false;+ if !ch.is_whitespace() {+ count += 1;+ }+ }+ }++ count.max(1)+}++#[cfg(test)]+mod tests {+ use super::*;+ use serde_json::json;++ #[test]+ fn count_simple_request() {+ let req: ResponsesRequest = serde_json::from_value(json!({+ "model": "gpt-5.5",+ "input": [{"type": "message", "role": "user", "content": [{"type": "input_text", "text": "hello"}]}],+ "store": false,+ "stream": true,+ "parallel_tool_calls": true,+ "text": {"verbosity": "low"},+ }))+ .unwrap();+ let count = count_translated_tokens(&req);+ assert!(count > 0);+ }++ #[test]+ fn count_request_with_tools() {+ let req: ResponsesRequest = serde_json::from_value(json!({+ "model": "gpt-5.5",+ "input": [{"type": "message", "role": "user", "content": [{"type": "input_text", "text": "use tool"}]}],+ "tools": [{"type": "function", "name": "search", "parameters": {"type": "object"}}],+ "store": false,+ "stream": true,+ "parallel_tool_calls": true,+ "text": {"verbosity": "low"},+ }))+ .unwrap();+ let count = count_translated_tokens(&req);+ assert!(count > 0);+ }++ #[test]+ fn count_is_monotonic() {+ let short: ResponsesRequest = serde_json::from_value(json!({+ "model": "gpt-5.5",+ "input": [{"type": "message", "role": "user", "content": [{"type": "input_text", "text": "hi"}]}],+ "store": false,+ "stream": true,+ "parallel_tool_calls": true,+ "text": {"verbosity": "low"},+ }))+ .unwrap();+ let long: ResponsesRequest = serde_json::from_value(json!({+ "model": "gpt-5.5",+ "input": [{"type": "message", "role": "user", "content": [{"type": "input_text", "text": "this is a much longer message with many words in it"}]}],+ "store": false,+ "stream": true,+ "parallel_tool_calls": true,+ "text": {"verbosity": "low"},+ }))+ .unwrap();+ assert!(count_translated_tokens(&long) >= count_translated_tokens(&short));+ }+}diff --git a/src/providers/codex/mod.rs b/src/providers/codex/mod.rsnew file mode 100644index 0000000..50cdcec--- /dev/null+++ b/src/providers/codex/mod.rs@@ -0,0 +1,305 @@+pub mod auth;+pub mod client;+pub mod continuation;+pub mod count_tokens;+pub mod request_summary;+pub mod translate;++use async_trait::async_trait;+use axum::Json;+use axum::response::{IntoResponse, Response};+use http::StatusCode;+use std::sync::Arc;++use crate::anthropic::error::json_error;+use crate::anthropic::schema::{CountTokensResponse, MessagesRequest};+use crate::config;+use crate::provider::{CliHandlers, Provider, RequestContext};+use crate::registry;++use self::auth::token_store::file_store;+use self::client::CodexHttpClient;+use self::continuation::{clear_continuation, continuation_candidate};+use self::count_tokens::count_translated_tokens;+use self::translate::accumulate::accumulate_response;+use self::translate::model_allowlist::{assert_allowed_model, resolve_model_request};+use self::translate::request::{TranslateOptions, translate_request};+use self::translate::stream::translate_stream_bytes;++// ---------------------------------------------------------------------------+// Provider+// ---------------------------------------------------------------------------++pub struct CodexProvider;++impl CodexProvider {+ pub fn new() -> Self {+ Self+ }+}++#[async_trait]+impl Provider for CodexProvider {+ fn name(&self) -> &'static str {+ "codex"+ }++ fn supported_models(&self) -> Vec<String> {+ let mut models: Vec<String> = registry::CODEX_MODELS+ .iter()+ .map(|m| m.to_string())+ .collect();+ for m in registry::CODEX_MODELS {+ models.push(format!("{m}-fast"));+ }+ models.sort_unstable();+ models.dedup();+ models+ }++ fn cli(&self) -> &'static dyn CliHandlers {+ &CODEX_CLI+ }++ async fn handle_messages(&self, body: MessagesRequest, ctx: RequestContext) -> Response {+ let message_id = format!("msg_{}", uuid::Uuid::new_v4().to_string().replace('-', ""));+ let want_stream = body.stream;+ let model = body.model.as_deref().unwrap_or("gpt-5.5");++ let resolved = resolve_model_request(model);+ if let Err(e) = assert_allowed_model(&resolved.model) {+ return json_error(+ StatusCode::BAD_REQUEST,+ "invalid_request_error",+ format!(+ "Model \"{model}\" resolves to unsupported model \"{}\"",+ e.model+ ),+ );+ }++ let translated = match translate_request(+ &body,+ TranslateOptions {+ session_id: ctx.session_id.clone(),+ service_tier: resolved.service_tier.clone(),+ },+ ) {+ Ok(t) => t,+ Err(e) => {+ return json_error(+ StatusCode::BAD_REQUEST,+ "invalid_request_error",+ e.to_string(),+ );+ }+ };++ // Check continuation+ let previous_response_id_enabled = config::codex_previous_response_id();+ let _continuation = continuation_candidate(+ ctx.session_id.as_deref(),+ &translated,+ previous_response_id_enabled,+ );++ // Post to upstream+ let client = Arc::new(CodexHttpClient::new());+ let upstream = match client.post_codex(&translated, &ctx).await {+ Ok(r) => r,+ Err(e) => {+ clear_continuation(ctx.session_id.as_deref());+ return map_codex_error_to_response(&e);+ }+ };++ if want_stream {+ let sse_bytes = match translate_stream_bytes(&upstream.body, &message_id, model) {+ Ok(b) => b,+ Err(e) => {+ return json_error(+ StatusCode::BAD_GATEWAY,+ "api_error",+ format!("Stream translation error: {e}"),+ );+ }+ };++ let headers = [+ (http::header::CONTENT_TYPE, "text/event-stream"),+ (http::header::CACHE_CONTROL, "no-cache"),+ (http::header::CONNECTION, "keep-alive"),+ ];+ (headers, sse_bytes).into_response()+ } else {+ match accumulate_response(&upstream.body, &message_id, model) {+ Ok(json) => (StatusCode::OK, Json(json)).into_response(),+ Err(e) => json_error(+ StatusCode::BAD_GATEWAY,+ "api_error",+ format!("Accumulation error: {e}"),+ ),+ }+ }+ }++ async fn handle_count_tokens(&self, body: MessagesRequest, _ctx: RequestContext) -> Response {+ let model = body.model.as_deref().unwrap_or("gpt-5.5");+ let resolved = resolve_model_request(model);+ if let Err(e) = assert_allowed_model(&resolved.model) {+ return json_error(+ StatusCode::BAD_REQUEST,+ "invalid_request_error",+ format!(+ "Model \"{model}\" resolves to unsupported model \"{}\"",+ e.model+ ),+ );+ }++ let translated = match translate_request(+ &body,+ TranslateOptions {+ session_id: None,+ service_tier: resolved.service_tier.clone(),+ },+ ) {+ Ok(t) => t,+ Err(e) => {+ return json_error(+ StatusCode::BAD_REQUEST,+ "invalid_request_error",+ e.to_string(),+ );+ }+ };++ let tokens = count_translated_tokens(&translated);+ (+ StatusCode::OK,+ Json(CountTokensResponse {+ input_tokens: tokens,+ }),+ )+ .into_response()+ }+}++// ---------------------------------------------------------------------------+// Error mapping+// ---------------------------------------------------------------------------++fn map_codex_error_to_response(err: &client::CodexError) -> Response {+ match err.status {+ 401 | 403 => json_error(+ StatusCode::UNAUTHORIZED,+ "authentication_error",+ err.detail.as_deref().unwrap_or("Authentication failed"),+ ),+ 429 => {+ let retry_after = err.retry_after.as_deref().unwrap_or("5");+ let resp = json_error(+ StatusCode::TOO_MANY_REQUESTS,+ "rate_limit_error",+ &err.message,+ );+ let headers = [(http::header::RETRY_AFTER, retry_after)];+ (headers, resp).into_response()+ }+ _ => json_error(+ StatusCode::BAD_GATEWAY,+ "api_error",+ err.detail.as_deref().unwrap_or("Upstream error"),+ ),+ }+}++// ---------------------------------------------------------------------------+// CLI+// ---------------------------------------------------------------------------++pub(crate) struct CodexCli;++impl CliHandlers for CodexCli {+ fn login(&self) -> Result<(), anyhow::Error> {+ anyhow::bail!("codex: browser login not yet implemented; use device login instead");+ }++ fn device(&self) -> Result<(), anyhow::Error> {+ anyhow::bail!("codex: device login not yet implemented");+ }++ fn status(&self) -> Result<(), anyhow::Error> {+ let store = file_store();+ let stored = store.load_auth()?;+ match stored {+ Some(auth) => {+ println!("Auth path: {}", store.auth_path());+ println!("Authenticated: true");+ if let Some(ref aid) = auth.account_id {+ println!("Account: {aid}");+ }+ let remaining = auth.expires.saturating_sub(+ std::time::SystemTime::now()+ .duration_since(std::time::UNIX_EPOCH)+ .unwrap_or_default()+ .as_millis() as u64,+ ) / 1000;+ println!("Expires in {remaining}s");+ Ok(())+ }+ None => {+ anyhow::bail!("Not authenticated");+ }+ }+ }++ fn logout(&self) -> Result<(), anyhow::Error> {+ let store = file_store();+ store.clear_auth()?;+ println!("Logged out");+ Ok(())+ }+}++pub(crate) static CODEX_CLI: CodexCli = CodexCli;++// ---------------------------------------------------------------------------+// Tests+// ---------------------------------------------------------------------------++#[cfg(test)]+mod tests {+ use super::*;+ use serde_json::json;++ #[test]+ fn supported_models_includes_fast_variants() {+ let provider = CodexProvider::new();+ let models = provider.supported_models();+ assert!(models.contains(&"gpt-5.5".to_string()));+ assert!(models.contains(&"gpt-5.5-fast".to_string()));+ assert!(models.contains(&"gpt-5.4".to_string()));+ assert!(models.contains(&"gpt-5.4-mini".to_string()));+ }++ #[test]+ fn codex_cli_status_unauthenticated() {+ // Without stored auth, status should fail+ let result = CODEX_CLI.status();+ assert!(result.is_err());+ assert!(+ result+ .unwrap_err()+ .to_string()+ .contains("Not authenticated")+ );+ }++ #[test]+ fn codex_cli_logout_does_not_error() {+ // Logout without auth should succeed+ let result = CODEX_CLI.logout();+ assert!(result.is_ok());+ }+}diff --git a/src/providers/codex/request_summary.rs b/src/providers/codex/request_summary.rsnew file mode 100644index 0000000..aa598a5--- /dev/null+++ b/src/providers/codex/request_summary.rs@@ -0,0 +1,276 @@+use serde_json::Value;++use super::translate::request::{+ ResponsesContentPart, ResponsesInputItem, ResponsesRequest, ResponsesTool,+};++#[derive(Debug, Clone, Default, serde::Serialize)]+pub struct CodexRequestSizeSummary {+ pub body_json_bytes: u64,+ pub instructions_bytes: u64,+ pub input_json_bytes: u64,+ pub tools_json_bytes: u64,+ pub text_json_bytes: u64,+ pub reasoning_json_bytes: u64,+ pub include_json_bytes: u64,+ pub client_metadata_json_bytes: u64,+ pub input_item_count: usize,+ pub tool_count: usize,+ pub input_image_part_count: usize,+ pub input_image_data_url_bytes: u64,+ pub input_type_counts: std::collections::BTreeMap<String, usize>,+ pub role_counts: std::collections::BTreeMap<String, usize>,+ pub largest_input_items: Vec<InputItemSummary>,+ pub largest_input_images: Vec<InputImageSummary>,+ pub largest_tools: Vec<ToolSummary>,+}++#[derive(Debug, Clone, serde::Serialize)]+pub struct InputItemSummary {+ pub index: usize,+ pub r#type: String,+ pub role: Option<String>,+ pub json_bytes: u64,+}++#[derive(Debug, Clone, serde::Serialize)]+pub struct InputImageSummary {+ pub item_index: usize,+ pub part_index: usize,+ pub json_bytes: u64,+ pub image_url_bytes: u64,+ pub data_url: bool,+}++#[derive(Debug, Clone, serde::Serialize)]+pub struct ToolSummary {+ pub index: usize,+ pub name: String,+ pub json_bytes: u64,+}++fn byte_length(s: &str) -> u64 {+ s.len() as u64+}++fn json_bytes(value: Option<&Value>) -> u64 {+ match value {+ Some(v) => byte_length(&serde_json::to_string(v).unwrap_or_default()),+ None => 0,+ }+}++fn input_image_parts(input: &[ResponsesInputItem]) -> Vec<(usize, usize, &str)> {+ let mut parts = Vec::new();+ for (item_idx, item) in input.iter().enumerate() {+ if let ResponsesInputItem::Message { content, .. } = item {+ for (part_idx, part) in content.iter().enumerate() {+ if let ResponsesContentPart::InputImage { image_url, .. } = part {+ parts.push((item_idx, part_idx, image_url.as_str()));+ }+ }+ }+ }+ parts+}++pub fn summarize_codex_request_size(body: &ResponsesRequest) -> CodexRequestSizeSummary {+ let body_json = serde_json::to_string(body).unwrap_or_default();+ let image_parts = input_image_parts(&body.input);++ let input_type_counts = count_items_by(&body.input, |item| match item {+ ResponsesInputItem::Message { .. } => Some("message".to_string()),+ ResponsesInputItem::FunctionCall { .. } => Some("function_call".to_string()),+ ResponsesInputItem::FunctionCallOutput { .. } => Some("function_call_output".to_string()),+ });++ let role_counts = count_items_by(&body.input, |item| match item {+ ResponsesInputItem::Message { role, .. } => Some(role.clone()),+ _ => None,+ });++ let largest_input_items = {+ let mut items: Vec<InputItemSummary> = body+ .input+ .iter()+ .enumerate()+ .map(|(i, item)| {+ let (r#type, role) = match item {+ ResponsesInputItem::Message { role, .. } => {+ ("message".to_string(), Some(role.clone()))+ }+ ResponsesInputItem::FunctionCall { .. } => ("function_call".to_string(), None),+ ResponsesInputItem::FunctionCallOutput { .. } => {+ ("function_call_output".to_string(), None)+ }+ };+ let json_bytes_val =+ json_bytes(Some(&serde_json::to_value(item).unwrap_or_default()));+ InputItemSummary {+ index: i,+ r#type,+ role,+ json_bytes: json_bytes_val,+ }+ })+ .collect();+ items.sort_by(|a, b| b.json_bytes.cmp(&a.json_bytes));+ items.truncate(5);+ items+ };++ let largest_input_images = {+ let mut items: Vec<InputImageSummary> = image_parts+ .iter()+ .map(|&(item_idx, part_idx, url)| {+ let json_bytes_val = json_bytes(Some(&serde_json::json!({+ "type": "input_image",+ "image_url": url,+ })));+ InputImageSummary {+ item_index: item_idx,+ part_index: part_idx,+ json_bytes: json_bytes_val,+ image_url_bytes: byte_length(url),+ data_url: url.starts_with("data:"),+ }+ })+ .collect();+ items.sort_by(|a, b| b.image_url_bytes.cmp(&a.image_url_bytes));+ items.truncate(5);+ items+ };++ let largest_tools = {+ let mut items: Vec<ToolSummary> = Vec::new();+ if let Some(ref tools) = body.tools {+ for (i, tool) in tools.iter().enumerate() {+ let name = match tool {+ ResponsesTool::Function(f) => f.name.clone(),+ ResponsesTool::WebSearch(_) => "web_search".to_string(),+ };+ let json_bytes_val =+ json_bytes(Some(&serde_json::to_value(tool).unwrap_or_default()));+ items.push(ToolSummary {+ index: i,+ name,+ json_bytes: json_bytes_val,+ });+ }+ }+ items.sort_by(|a, b| b.json_bytes.cmp(&a.json_bytes));+ items.truncate(5);+ items+ };++ CodexRequestSizeSummary {+ body_json_bytes: byte_length(&body_json),+ instructions_bytes: body.instructions.as_ref().map_or(0, |s| byte_length(s)),+ input_json_bytes: json_bytes(Some(&serde_json::to_value(&body.input).unwrap_or_default())),+ tools_json_bytes: match &body.tools {+ Some(tools) => json_bytes(Some(&serde_json::to_value(tools).unwrap_or_default())),+ None => 0,+ },+ text_json_bytes: json_bytes(Some(&serde_json::to_value(&body.text).unwrap_or_default())),+ reasoning_json_bytes: json_bytes(+ body.reasoning+ .as_ref()+ .map(|r| serde_json::to_value(r).unwrap_or_default())+ .as_ref(),+ ),+ include_json_bytes: json_bytes(+ body.include+ .as_ref()+ .map(|i| serde_json::to_value(i).unwrap_or_default())+ .as_ref(),+ ),+ client_metadata_json_bytes: 0,+ input_item_count: body.input.len(),+ tool_count: body.tools.as_ref().map_or(0, |t| t.len()),+ input_image_part_count: image_parts.len(),+ input_image_data_url_bytes: image_parts+ .iter()+ .filter(|(_, _, url)| url.starts_with("data:"))+ .map(|(_, _, url)| byte_length(url))+ .sum(),+ input_type_counts,+ role_counts,+ largest_input_items,+ largest_input_images,+ largest_tools,+ }+}++fn count_items_by<T, F>(items: &[T], f: F) -> std::collections::BTreeMap<String, usize>+where+ F: Fn(&T) -> Option<String>,+{+ let mut counts = std::collections::BTreeMap::new();+ for item in items {+ if let Some(key) = f(item) {+ *counts.entry(key).or_insert(0) += 1;+ }+ }+ counts+}++#[cfg(test)]+mod tests {+ use super::*;+ use serde_json::json;++ #[test]+ fn summarize_simple_request() {+ let input = vec![ResponsesInputItem::Message {+ role: "user".to_string(),+ content: vec![ResponsesContentPart::InputText {+ text: "hello".to_string(),+ }],+ }];+ let req = ResponsesRequest {+ model: "gpt-5.5".to_string(),+ instructions: None,+ input,+ tools: None,+ tool_choice: None,+ store: false,+ stream: true,+ parallel_tool_calls: true,+ include: None,+ service_tier: None,+ prompt_cache_key: None,+ text: super::super::translate::request::ResponsesText {+ verbosity: Some("low".to_string()),+ format: None,+ },+ reasoning: None,+ };+ let summary = summarize_codex_request_size(&req);+ assert_eq!(summary.input_item_count, 1);+ assert_eq!(summary.tool_count, 0);+ assert!(summary.body_json_bytes > 0);+ }++ #[test]+ fn summarize_with_tools_and_images() {+ let req: ResponsesRequest = serde_json::from_value(json!({+ "model": "gpt-5.5",+ "input": [{+ "type": "message",+ "role": "user",+ "content": [+ {"type": "input_text", "text": "describe"},+ {"type": "input_image", "image_url": "data:image/png;base64,abc"}+ ]+ }],+ "store": false,+ "stream": true,+ "parallel_tool_calls": true,+ "text": {"verbosity": "low"}+ }))+ .unwrap();+ let summary = summarize_codex_request_size(&req);+ assert_eq!(summary.input_image_part_count, 1);+ assert!(summary.input_image_data_url_bytes > 0);+ }+}diff --git a/src/providers/codex/translate/accumulate.rs b/src/providers/codex/translate/accumulate.rsnew file mode 100644index 0000000..e51a10f--- /dev/null+++ b/src/providers/codex/translate/accumulate.rs@@ -0,0 +1,331 @@+use serde_json::Value;++use super::reducer::{+ AnthropicUsage, ReducerEvent, map_codex_usage_to_anthropic, reduce_upstream_bytes,+};+use super::web_search_compat::{WebSearchCompatContent, build_web_search_compat_blocks};++pub fn accumulate_response(+ upstream: &[u8],+ message_id: &str,+ model: &str,+) -> Result<Value, anyhow::Error> {+ let events = reduce_upstream_bytes(upstream)+ .map_err(|e| anyhow::anyhow!("upstream error: {} ({:?})", e.message, e.kind))?;++ let mut blocks: Vec<AccumulatedBlock> = Vec::new();+ let mut stop_reason: Option<String> = None;+ let mut usage: Option<AnthropicUsage> = None;+ let mut web_search_events: Vec<ReducerEvent> = Vec::new();+ let mut deferred_text_parts: Vec<String> = Vec::new();++ enum BlockKind {+ Text {+ text: String,+ },+ Tool {+ id: String,+ name: String,+ args: String,+ },+ }++ struct AccumulatedBlock {+ index: usize,+ kind: BlockKind,+ }++ for event in &events {+ match event {+ ReducerEvent::WebSearch { .. } => {+ web_search_events.push(event.clone());+ }+ ReducerEvent::TextStart { index } => {+ blocks.push(AccumulatedBlock {+ index: *index,+ kind: BlockKind::Text {+ text: String::new(),+ },+ });+ }+ ReducerEvent::TextDelta { index, text } => {+ if let Some(block) = blocks.iter_mut().rev().find(|b| b.index == *index) {+ if let BlockKind::Text { text: t } = &mut block.kind {+ t.push_str(text);+ }+ }+ deferred_text_parts.push(text.clone());+ }+ ReducerEvent::ToolStart { index, id, name } => {+ blocks.push(AccumulatedBlock {+ index: *index,+ kind: BlockKind::Tool {+ id: id.clone(),+ name: name.clone(),+ args: String::new(),+ },+ });+ }+ ReducerEvent::ToolDelta {+ index,+ partial_json,+ } => {+ if let Some(block) = blocks.iter_mut().rev().find(|b| b.index == *index) {+ if let BlockKind::Tool { args, .. } = &mut block.kind {+ args.push_str(partial_json);+ }+ }+ }+ ReducerEvent::Finish {+ stop_reason: sr,+ usage: u,+ web_search_requests,+ ..+ } => {+ stop_reason = Some(sr.to_string());+ let ws = Some(*web_search_requests).filter(|n| *n > 0);+ usage = Some(map_codex_usage_to_anthropic(u, ws));+ }+ _ => {}+ }+ }++ let text_from_deferred: String = deferred_text_parts.join("");++ // Build content array+ let mut content: Vec<Value> = Vec::new();++ // Add web search compat blocks+ if !web_search_events.is_empty() {+ let compat_blocks = build_web_search_compat_blocks(&web_search_events, &text_from_deferred);+ for block in &compat_blocks {+ match &block.content {+ WebSearchCompatContent::ServerToolUse { id, name, input } => {+ content.push(serde_json::json!({+ "type": "server_tool_use",+ "id": id,+ "name": name,+ "input": input,+ }));+ }+ WebSearchCompatContent::WebSearchToolResult {+ tool_use_id,+ content: results,+ } => {+ let result_content: Vec<Value> = results+ .iter()+ .map(|r| {+ serde_json::json!({+ "type": "web_search_result",+ "title": r.title,+ "url": r.url,+ })+ })+ .collect();+ content.push(serde_json::json!({+ "type": "web_search_tool_result",+ "tool_use_id": tool_use_id,+ "content": result_content,+ }));+ }+ }+ }+ }++ // Add accumulated blocks+ for block in &blocks {+ match &block.kind {+ BlockKind::Text { text } => {+ if !text.is_empty() {+ content.push(serde_json::json!({+ "type": "text",+ "text": text,+ }));+ }+ }+ BlockKind::Tool { id, name, args } => {+ let parsed = serde_json::from_str::<Value>(args)+ .unwrap_or_else(|_| Value::String(args.clone()));+ content.push(serde_json::json!({+ "type": "tool_use",+ "id": id,+ "name": name,+ "input": parsed,+ }));+ }+ }+ }++ let response = serde_json::json!({+ "id": message_id,+ "type": "message",+ "role": "assistant",+ "model": model,+ "content": content,+ "stop_reason": stop_reason,+ "stop_sequence": null,+ "usage": usage.unwrap_or_default(),+ });++ Ok(response)+}++#[cfg(test)]+mod tests {+ use super::*;+ use serde_json::json;++ fn sse_event(type_name: &str, payload: serde_json::Value) -> String {+ let mut obj = if let serde_json::Value::Object(m) = payload {+ m+ } else {+ return String::new();+ };+ obj.insert("type".into(), serde_json::json!(type_name));+ format!(+ "data: {}\n\n",+ serde_json::to_string(&serde_json::Value::Object(obj)).unwrap()+ )+ }++ #[test]+ fn accumulate_text_response() {+ let upstream = format!(+ "{}{}{}{}",+ sse_event(+ "response.output_item.added",+ json!({+ "output_index":0,+ "item":{"type":"message","id":"msg_up"}+ })+ ),+ sse_event(+ "response.output_text.delta",+ json!({+ "output_index":0,"delta":"Hello world"+ })+ ),+ sse_event(+ "response.output_item.done",+ json!({+ "output_index":0,"item":{"type":"message"}+ })+ ),+ sse_event(+ "response.completed",+ json!({+ "response":{"id":"resp_1","usage":{"input_tokens":5,"output_tokens":2}}+ })+ ),+ );+ let response = accumulate_response(upstream.as_bytes(), "msg_1", "gpt-5.5").unwrap();+ assert_eq!(response["type"], "message");+ assert_eq!(response["content"][0]["type"], "text");+ assert_eq!(response["content"][0]["text"], "Hello world");+ assert_eq!(response["stop_reason"], "end_turn");+ }++ #[test]+ fn accumulate_tool_use_response() {+ let upstream = format!(+ "{}{}{}{}",+ sse_event(+ "response.output_item.added",+ json!({+ "output_index":0,+ "item":{"type":"function_call","call_id":"call_1","name":"Read"}+ })+ ),+ sse_event(+ "response.function_call_arguments.delta",+ json!({+ "output_index":0,"delta":"{\"file_path\":\"/tmp/a\"}"+ })+ ),+ sse_event(+ "response.output_item.done",+ json!({+ "output_index":0,+ "item":{"type":"function_call","call_id":"call_1","name":"Read","arguments":"{\"file_path\":\"/tmp/a\"}"}+ })+ ),+ sse_event(+ "response.completed",+ json!({+ "response":{"id":"resp_1","usage":{"input_tokens":3}}+ })+ ),+ );+ let response = accumulate_response(upstream.as_bytes(), "msg_1", "gpt-5.5").unwrap();+ assert_eq!(response["content"][0]["type"], "tool_use");+ assert_eq!(response["content"][0]["input"]["file_path"], "/tmp/a");+ }++ #[test]+ fn accumulate_web_search_response() {+ let upstream = format!(+ "{}{}{}{}{}{}{}",+ sse_event(+ "response.output_item.added",+ json!({+ "output_index":0,+ "item":{"type":"web_search_call","id":"ws_1"}+ })+ ),+ sse_event(+ "response.web_search_call.in_progress",+ json!({+ "output_index":0,"item_id":"ws_1"+ })+ ),+ sse_event(+ "response.web_search_call.completed",+ json!({+ "output_index":0,"item_id":"ws_1"+ })+ ),+ sse_event(+ "response.output_item.done",+ json!({+ "output_index":0,+ "item":{"type":"web_search_call","id":"ws_1","action":{"query":"test query"}}+ })+ ),+ sse_event(+ "response.output_item.added",+ json!({+ "output_index":1,+ "item":{"type":"message","id":"msg_up"}+ })+ ),+ sse_event(+ "response.output_text.delta",+ json!({+ "output_index":1,"delta":"See [Result](https://result.com)"+ })+ ),+ sse_event(+ "response.output_item.done",+ json!({+ "output_index":1,"item":{"type":"message"}+ })+ ),+ );+ let response = accumulate_response(upstream.as_bytes(), "msg_1", "gpt-5.5").unwrap();+ let content = response["content"].as_array().unwrap();+ assert!(content.len() >= 3);+ // First should be server_tool_use+ assert_eq!(content[0]["type"], "server_tool_use");+ // Second should be web_search_tool_result+ assert_eq!(content[1]["type"], "web_search_tool_result");+ // Third should be text+ assert_eq!(content[2]["type"], "text");+ }++ #[test]+ fn accumulate_handles_upstream_error() {+ let upstream = sse_event("error", json!({"error":{"message":"upstream failure"}}));+ let result = accumulate_response(upstream.as_bytes(), "msg_e", "model");+ assert!(result.is_err());+ }+}diff --git a/src/providers/codex/translate/mod.rs b/src/providers/codex/translate/mod.rsnew file mode 100644index 0000000..7089edb--- /dev/null+++ b/src/providers/codex/translate/mod.rs@@ -0,0 +1,6 @@+pub mod accumulate;+pub mod model_allowlist;+pub mod reducer;+pub mod request;+pub mod stream;+pub mod web_search_compat;diff --git a/src/providers/codex/translate/model_allowlist.rs b/src/providers/codex/translate/model_allowlist.rsnew file mode 100644index 0000000..c426d6e--- /dev/null+++ b/src/providers/codex/translate/model_allowlist.rs@@ -0,0 +1,148 @@+use std::collections::HashSet;++use crate::config;++use super::request::ServiceTier;++pub const ALLOWED_MODELS: &[&str] = &[+ "gpt-5.2",+ "gpt-5.3-codex",+ "gpt-5.3-codex-spark",+ "gpt-5.4",+ "gpt-5.4-mini",+ "gpt-5.5",+];++pub const MODEL_ALIASES: &[(&str, &str)] = &[+ ("haiku", "gpt-5.4-mini"),+ ("claude-haiku-4-5", "gpt-5.4-mini"),+ ("claude-haiku-4-5-20251001", "gpt-5.4-mini"),+ ("sonnet", "gpt-5.4"),+ ("claude-sonnet-4-6", "gpt-5.4"),+ ("opus", "gpt-5.5"),+ ("claude-opus-4-7", "gpt-5.5"),+];++#[derive(Debug, Clone)]+pub struct ResolvedModel {+ pub model: String,+ pub service_tier: Option<ServiceTier>,+}++fn fast_model_aliases() -> HashSet<String> {+ ALLOWED_MODELS.iter().map(|m| format!("{m}-fast")).collect()+}++fn resolve_fast_model_alias(model: &str) -> ResolvedModel {+ let fast_set = fast_model_aliases();+ if fast_set.contains(model) {+ let base = model.trim_end_matches("-fast");+ ResolvedModel {+ model: base.to_string(),+ service_tier: Some(ServiceTier::Priority),+ }+ } else {+ ResolvedModel {+ model: model.to_string(),+ service_tier: None,+ }+ }+}++pub fn resolve_model_request(model: &str) -> ResolvedModel {+ let alias = MODEL_ALIASES+ .iter()+ .find(|(alias, _)| *alias == model)+ .map(|(_, target)| *target)+ .unwrap_or(model);++ let requested = resolve_fast_model_alias(alias);++ let override_model = config::codex_model();+ let resolved = match override_model {+ Some(ref val) if !val.is_empty() => resolve_fast_model_alias(val),+ _ => requested.clone(),+ };++ ResolvedModel {+ model: resolved.model,+ service_tier: if requested.service_tier == Some(ServiceTier::Priority)+ || resolved.service_tier == Some(ServiceTier::Priority)+ {+ Some(ServiceTier::Priority)+ } else {+ resolved.service_tier+ },+ }+}++pub fn resolve_model(model: &str) -> String {+ resolve_model_request(model).model+}++#[derive(Debug, Clone)]+pub struct ModelNotAllowedError {+ pub model: String,+}++impl std::fmt::Display for ModelNotAllowedError {+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {+ write!(f, "Model not allowed: {}", self.model)+ }+}++pub fn assert_allowed_model(model: &str) -> Result<(), ModelNotAllowedError> {+ if ALLOWED_MODELS.contains(&model) {+ Ok(())+ } else {+ Err(ModelNotAllowedError {+ model: model.to_string(),+ })+ }+}++pub fn is_valid_model_for_codex(model: &str) -> bool {+ if ALLOWED_MODELS.contains(&model) {+ return true;+ }+ let fast_set = fast_model_aliases();+ if fast_set.contains(model) {+ return true;+ }+ MODEL_ALIASES.iter().any(|(alias, _)| *alias == model)+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn haiku_resolves_to_mini() {+ let r = resolve_model_request("haiku");+ assert_eq!(r.model, "gpt-5.4-mini");+ }++ #[test]+ fn sonnet_resolves_to_gpt5_4() {+ let r = resolve_model_request("sonnet");+ assert_eq!(r.model, "gpt-5.4");+ }++ #[test]+ fn fast_suffix_adds_priority() {+ let r = resolve_model_request("gpt-5.5-fast");+ assert_eq!(r.model, "gpt-5.5");+ assert_eq!(r.service_tier, Some(ServiceTier::Priority));+ }++ #[test]+ fn allowed_models_accept_base() {+ assert!(assert_allowed_model("gpt-5.4").is_ok());+ assert!(assert_allowed_model("gpt-5.5").is_ok());+ }++ #[test]+ fn not_allowed_rejected() {+ assert!(assert_allowed_model("gpt-7").is_err());+ }+}diff --git a/src/providers/codex/translate/reducer.rs b/src/providers/codex/translate/reducer.rsnew file mode 100644index 0000000..f2c6c22--- /dev/null+++ b/src/providers/codex/translate/reducer.rs@@ -0,0 +1,1000 @@+use crate::anthropic::sse::parse_sse_events;++use super::request::ResponsesInputItem;++#[derive(Debug, Clone)]+pub struct UpstreamStreamError {+ pub kind: UpstreamErrorKind,+ pub message: String,+ pub retry_after_seconds: Option<u64>,+}++#[derive(Debug, Clone, PartialEq, Eq)]+pub enum UpstreamErrorKind {+ RateLimit,+ Overloaded,+ Transient,+ Failed,+}++#[derive(Debug, Clone, Default)]+pub struct CodexUsage {+ pub input_tokens: Option<u64>,+ pub output_tokens: Option<u64>,+ pub input_tokens_details_cached: Option<u64>,+ pub output_tokens_details_reasoning: Option<u64>,+}++pub type StopReason = &'static str;+pub const STOP_END_TURN: &str = "end_turn";+pub const STOP_TOOL_USE: &str = "tool_use";+pub const STOP_MAX_TOKENS: &str = "max_tokens";++pub type TerminalType = &'static str;+pub const TERM_COMPLETED: &str = "response.completed";+pub const TERM_INCOMPLETE: &str = "response.incomplete";+pub const TERM_DONE: &str = "response.done";++#[derive(Debug, Clone)]+pub enum ReducerEvent {+ TextStart {+ index: usize,+ },+ TextDelta {+ index: usize,+ text: String,+ },+ TextStop {+ index: usize,+ },+ ToolStart {+ index: usize,+ id: String,+ name: String,+ },+ ToolDelta {+ index: usize,+ partial_json: String,+ },+ ToolStop {+ index: usize,+ },+ ToolProgress {+ index: usize,+ },+ Progress,+ WebSearch {+ index: usize,+ result_index: usize,+ id: String,+ query: String,+ },+ Finish {+ stop_reason: StopReason,+ terminal_type: String,+ continuation_eligible: bool,+ usage: Option<CodexUsage>,+ web_search_requests: usize,+ response_id: Option<String>,+ output_items: Vec<ResponsesInputItem>,+ },+}++pub fn reduce_upstream_bytes(input: &[u8]) -> Result<Vec<ReducerEvent>, UpstreamStreamError> {+ let sse_events = parse_sse_events(input);+ let mut out = Vec::new();++ let mut blocks_by_output_index: std::collections::HashMap<usize, BlockState> =+ std::collections::HashMap::new();+ let mut output_items_by_index: std::collections::BTreeMap<usize, ResponsesInputItem> =+ std::collections::BTreeMap::new();+ let mut item_id_to_output_index: std::collections::HashMap<String, usize> =+ std::collections::HashMap::new();+ let mut anthropic_index = 0usize;+ let mut saw_tool_use = false;+ let mut final_usage: Option<CodexUsage> = None;+ let mut response_id: Option<String> = None;+ let mut terminal_type: Option<String> = None;+ let mut continuation_eligible = false;+ let mut incomplete = false;+ let mut web_search_requests = 0usize;+ let mut _saw_terminal = false;++ enum BlockState {+ Text {+ index: usize,+ text_accum: String,+ },+ Tool {+ index: usize,+ output_index: usize,+ call_id: String,+ name: String,+ args_accum: String,+ had_delta: bool,+ buffer_until_done: bool,+ emitted_args: bool,+ },+ }++ fn capture_output_item(+ output_index: usize,+ state: &BlockState,+ items: &mut std::collections::BTreeMap<usize, ResponsesInputItem>,+ ) {+ match state {+ BlockState::Text {+ index: _,+ text_accum,+ } => {+ if text_accum.is_empty() {+ return;+ }+ items.insert(+ output_index,+ ResponsesInputItem::Message {+ role: "assistant".to_string(),+ content: vec![super::request::ResponsesContentPart::OutputText {+ text: text_accum.clone(),+ }],+ },+ );+ }+ BlockState::Tool {+ args_accum,+ name,+ call_id,+ ..+ } => {+ items.insert(+ output_index,+ ResponsesInputItem::FunctionCall {+ call_id: call_id.clone(),+ name: name.clone(),+ arguments: args_accum.clone(),+ },+ );+ }+ }+ }++ for evt in &sse_events {+ let data = evt.data.trim();+ if data.is_empty() {+ continue;+ }++ let p: serde_json::Value = match serde_json::from_str(data) {+ Ok(v) => v,+ Err(_) => continue,+ };++ let t = p+ .get("type")+ .and_then(|v| v.as_str())+ .unwrap_or("")+ .to_string();++ if t == "codex.rate_limits" {+ if let Some(true) = p+ .get("rate_limits")+ .and_then(|r| r.get("limit_reached"))+ .and_then(|v| v.as_bool())+ {+ let retry_after = p+ .get("rate_limits")+ .and_then(|r| r.get("primary"))+ .and_then(|r| r.get("reset_after_seconds"))+ .and_then(|v| v.as_f64());+ return Err(UpstreamStreamError {+ kind: UpstreamErrorKind::RateLimit,+ message: "rate limit reached".to_string(),+ retry_after_seconds: retry_after.map(|f| f as u64),+ });+ }+ out.push(ReducerEvent::Progress);+ continue;+ }++ if t == "keepalive" {+ out.push(ReducerEvent::Progress);+ continue;+ }++ if t == "response.web_search_call.in_progress"+ || t == "response.web_search_call.searching"+ || t == "response.web_search_call.completed"+ {+ out.push(ReducerEvent::Progress);+ continue;+ }++ if t == "response.failed" || t == "response.error" || t == "error" {+ let msg = p+ .get("response")+ .and_then(|r| r.get("error"))+ .and_then(|e| e.get("message"))+ .and_then(|v| v.as_str())+ .or_else(|| {+ p.get("error")+ .and_then(|e| e.get("message"))+ .and_then(|v| v.as_str())+ })+ .unwrap_or("Upstream error");+ let kind = upstream_failure_kind(&p, msg);+ let retry_after = retry_after_from_payload(&p);+ return Err(UpstreamStreamError {+ kind,+ message: msg.to_string(),+ retry_after_seconds: retry_after,+ });+ }++ if t == "response.output_item.added" {+ let item = match p.get("item") {+ Some(v) => v,+ None => continue,+ };+ let output_index: usize =+ p.get("output_index").and_then(|v| v.as_u64()).unwrap_or(0) as usize;++ let item_type = item.get("type").and_then(|v| v.as_str()).unwrap_or("");+ if item_type == "reasoning" {+ continue;+ }+ if item_type == "web_search_call" {+ out.push(ReducerEvent::Progress);+ continue;+ }++ if item_type == "message" {+ let idx = anthropic_index;+ anthropic_index += 1;+ if let Some(id) = item.get("id").and_then(|v| v.as_str()) {+ item_id_to_output_index.insert(id.to_string(), output_index);+ }+ blocks_by_output_index.insert(+ output_index,+ BlockState::Text {+ index: idx,+ text_accum: String::new(),+ },+ );+ out.push(ReducerEvent::TextStart { index: idx });+ continue;+ }++ if item_type == "function_call" {+ saw_tool_use = true;+ let idx = anthropic_index;+ anthropic_index += 1;+ let call_id = item+ .get("call_id")+ .and_then(|v| v.as_str())+ .unwrap_or("")+ .to_string();+ let name = item+ .get("name")+ .and_then(|v| v.as_str())+ .unwrap_or("")+ .to_string();+ let buffer_until_done = should_buffer_tool_args(&name);+ blocks_by_output_index.insert(+ output_index,+ BlockState::Tool {+ index: idx,+ output_index,+ call_id: call_id.clone(),+ name: name.clone(),+ args_accum: String::new(),+ had_delta: false,+ buffer_until_done,+ emitted_args: false,+ },+ );+ out.push(ReducerEvent::ToolStart {+ index: idx,+ id: call_id,+ name,+ });+ continue;+ }++ continue;+ }++ if t == "response.output_text.delta" {+ let output_index = p+ .get("output_index")+ .and_then(|v| v.as_u64())+ .map(|v| v as usize);+ let item_id = p.get("item_id").and_then(|v| v.as_str());+ let state = if let Some(oi) = output_index {+ blocks_by_output_index.get_mut(&oi)+ } else if let Some(id) = item_id {+ item_id_to_output_index+ .get(id)+ .and_then(|oi| blocks_by_output_index.get_mut(oi))+ } else {+ None+ };+ let delta = p.get("delta").and_then(|v| v.as_str()).unwrap_or("");+ if delta.is_empty() {+ continue;+ }+ match state {+ Some(BlockState::Text { index, text_accum }) => {+ text_accum.push_str(delta);+ out.push(ReducerEvent::TextDelta {+ index: *index,+ text: delta.to_string(),+ });+ }+ _ => continue,+ }+ continue;+ }++ if t == "response.function_call_arguments.delta" {+ let output_index = match p.get("output_index").and_then(|v| v.as_u64()) {+ Some(v) => v as usize,+ None => continue,+ };+ let delta = p.get("delta").and_then(|v| v.as_str()).unwrap_or("");+ if delta.is_empty() {+ continue;+ }+ let state = match blocks_by_output_index.get_mut(&output_index) {+ Some(s) => s,+ None => continue,+ };+ match state {+ BlockState::Tool {+ args_accum,+ had_delta,+ buffer_until_done,+ emitted_args,+ name: _,+ ..+ } => {+ args_accum.push_str(delta);+ *had_delta = true;++ // Handle buffered Read tool args+ if *buffer_until_done {+ // Only emit progress, not delta+ if let Some(idx) =+ blocks_by_output_index+ .get(&output_index)+ .and_then(|s| match s {+ BlockState::Tool { index, .. } => Some(*index),+ _ => None,+ })+ {+ out.push(ReducerEvent::ToolProgress { index: idx });+ }+ } else {+ *emitted_args = true;+ if let Some(idx) =+ blocks_by_output_index+ .get(&output_index)+ .and_then(|s| match s {+ BlockState::Tool { index, .. } => Some(*index),+ _ => None,+ })+ {+ out.push(ReducerEvent::ToolDelta {+ index: idx,+ partial_json: delta.to_string(),+ });+ }+ }+ }+ _ => continue,+ }+ continue;+ }++ if t == "response.function_call_arguments.done" {+ let output_index = match p.get("output_index").and_then(|v| v.as_u64()) {+ Some(v) => v as usize,+ None => continue,+ };+ if let Some(BlockState::Tool { args_accum, .. }) =+ blocks_by_output_index.get_mut(&output_index)+ {+ if let Some(args) = p.get("arguments").and_then(|v| v.as_str()) {+ if args_accum.is_empty() {+ *args_accum = args.to_string();+ }+ }+ }+ continue;+ }++ if t == "response.output_item.done" {+ let output_index: usize =+ p.get("output_index").and_then(|v| v.as_u64()).unwrap_or(0) as usize;+ let item = p.get("item");++ // Handle web search call done+ if let Some(item_val) = item {+ if item_val.get("type").and_then(|v| v.as_str()) == Some("web_search_call") {+ let idx = anthropic_index;+ anthropic_index += 1;+ let result_index = anthropic_index;+ anthropic_index += 1;+ web_search_requests += 1;+ let id_val = item_val.get("id").and_then(|v| v.as_str()).unwrap_or("");+ let id = server_tool_use_id_from_codex_web_search_id(id_val);+ let query = web_search_query(item_val);+ out.push(ReducerEvent::WebSearch {+ index: idx,+ result_index,+ id,+ query,+ });+ continue;+ }+ }++ let state = blocks_by_output_index.remove(&output_index);+ let mut state = match state {+ Some(s) => s,+ None => continue,+ };++ if let Some(item_val) = item {+ if item_val.get("type").and_then(|v| v.as_str()) == Some("reasoning") {+ continue;+ }+ if let BlockState::Tool {+ args_accum,+ name,+ buffer_until_done,+ emitted_args,+ had_delta,+ index,+ ..+ } = &mut state+ {+ if let Some(final_args) = item_val+ .get("arguments")+ .and_then(|v| v.as_str())+ .filter(|s| !s.is_empty())+ {+ if !args_accum.is_empty() && !*emitted_args {+ // Already have accum from deltas - skip+ } else if *had_delta {+ // Already emitted deltas+ } else {+ *args_accum = final_args.to_string();+ }+ }++ if !args_accum.is_empty() {+ let sanitized = sanitize_tool_args(name, args_accum);+ *args_accum = sanitized;+ if *buffer_until_done || !*emitted_args {+ *emitted_args = true;+ out.push(ReducerEvent::ToolDelta {+ index: *index,+ partial_json: args_accum.clone(),+ });+ }+ }+ }+ }++ capture_output_item(output_index, &state, &mut output_items_by_index);++ match &state {+ BlockState::Text { index, .. } => {+ out.push(ReducerEvent::TextStop { index: *index });+ }+ BlockState::Tool { index, .. } => {+ out.push(ReducerEvent::ToolStop { index: *index });+ }+ }+ continue;+ }++ if t == "response.completed" || t == "response.incomplete" || t == "response.done" {+ _saw_terminal = true;+ terminal_type = Some(t.clone());+ response_id = p+ .get("response")+ .and_then(|r| r.get("id"))+ .and_then(|v| v.as_str())+ .map(|s| s.to_string());+ final_usage = p.get("response").map(parse_codex_usage);+ let reason = p+ .get("response")+ .and_then(|r| r.get("incomplete_details"))+ .and_then(|d| d.get("reason"))+ .and_then(|v| v.as_str());+ if t == "response.incomplete" || reason.is_some() {+ incomplete = true;+ }+ continuation_eligible =+ (t == "response.completed" || t == "response.done") && !incomplete;+ continue;+ }+ }++ let stop_reason: StopReason = if incomplete {+ STOP_MAX_TOKENS+ } else if saw_tool_use {+ STOP_TOOL_USE+ } else {+ STOP_END_TURN+ };++ let output_items: Vec<ResponsesInputItem> = output_items_by_index.into_values().collect();++ out.push(ReducerEvent::Finish {+ stop_reason,+ terminal_type: terminal_type.unwrap_or_else(|| TERM_INCOMPLETE.to_string()),+ continuation_eligible,+ usage: final_usage,+ web_search_requests,+ response_id,+ output_items,+ });++ Ok(out)+}++fn parse_codex_usage(response: &serde_json::Value) -> CodexUsage {+ let usage = match response.get("usage") {+ Some(u) => u,+ None => return CodexUsage::default(),+ };+ CodexUsage {+ input_tokens: usage.get("input_tokens").and_then(|v| v.as_u64()),+ output_tokens: usage.get("output_tokens").and_then(|v| v.as_u64()),+ input_tokens_details_cached: usage+ .get("input_tokens_details")+ .and_then(|d| d.get("cached_tokens"))+ .and_then(|v| v.as_u64()),+ output_tokens_details_reasoning: usage+ .get("output_tokens_details")+ .and_then(|d| d.get("reasoning_tokens"))+ .and_then(|v| v.as_u64()),+ }+}++fn should_buffer_tool_args(name: &str) -> bool {+ name == "Read"+}++fn sanitize_tool_args(name: &str, args: &str) -> String {+ if name != "Read" || args.is_empty() {+ return args.to_string();+ }+ let parsed: serde_json::Value = match serde_json::from_str(args) {+ Ok(v) => v,+ Err(_) => return args.to_string(),+ };+ let obj = match parsed.as_object() {+ Some(o) => o,+ None => return args.to_string(),+ };+ // Remove empty "pages" field+ let has_empty_pages = obj+ .get("pages")+ .and_then(|v| v.as_str())+ .map_or(false, |s| s.is_empty());+ if !has_empty_pages {+ return args.to_string();+ }+ let mut sanitized = obj.clone();+ sanitized.remove("pages");+ serde_json::to_string(&sanitized).unwrap_or_else(|_| args.to_string())+}++fn web_search_query(item: &serde_json::Value) -> String {+ let action = match item.get("action") {+ Some(v) => v,+ None => return String::new(),+ };+ if let Some(query) = action.get("query").and_then(|v| v.as_str()) {+ return query.to_string();+ }+ if let Some(queries) = action.get("queries").and_then(|v| v.as_array()) {+ for q in queries {+ if let Some(s) = q.as_str() {+ return s.to_string();+ }+ }+ }+ String::new()+}++fn server_tool_use_id_from_codex_web_search_id(id: &str) -> String {+ let suffix: String = id+ .chars()+ .map(|c| {+ if c.is_alphanumeric() || c == '_' {+ c+ } else {+ '_'+ }+ })+ .collect();+ format!("srvtoolu_{suffix}")+}++fn upstream_failure_kind(payload: &serde_json::Value, message: &str) -> UpstreamErrorKind {+ let status = payload+ .get("status")+ .or_else(|| payload.get("status_code"))+ .and_then(|v| v.as_u64());+ let code = payload+ .get("response")+ .and_then(|r| r.get("error"))+ .and_then(|e| e.get("code"))+ .or_else(|| payload.get("error").and_then(|e| e.get("code")))+ .and_then(|v| v.as_str());+ let err_type = payload+ .get("response")+ .and_then(|r| r.get("error"))+ .and_then(|e| e.get("type"))+ .or_else(|| payload.get("error").and_then(|e| e.get("type")))+ .and_then(|v| v.as_str());+ let lower_msg = message.to_lowercase();++ if status == Some(529)+ || code == Some("overloaded_error")+ || err_type == Some("overloaded_error")+ || lower_msg.contains("overloaded")+ {+ return UpstreamErrorKind::Overloaded;+ }++ if (status.map_or(false, |s| (500..600).contains(&s)))+ || code == Some("server_error")+ || code == Some("internal_server_error")+ || code == Some("internal_error")+ || err_type == Some("server_error")+ || err_type == Some("internal_server_error")+ || err_type == Some("internal_error")+ || is_retryable_transport_message(&lower_msg)+ {+ return UpstreamErrorKind::Transient;+ }++ UpstreamErrorKind::Failed+}++fn retry_after_from_payload(payload: &serde_json::Value) -> Option<u64> {+ let raw = payload+ .get("response")+ .and_then(|r| r.get("error"))+ .and_then(|e| e.get("retry_after_seconds"))+ .or_else(|| {+ payload+ .get("error")+ .and_then(|e| e.get("retry_after_seconds"))+ })+ .or_else(|| payload.get("retry_after_seconds"))+ .or_else(|| payload.get("headers").and_then(|h| h.get("retry-after")))+ .or_else(|| payload.get("headers").and_then(|h| h.get("Retry-After")));+ let value = match raw {+ Some(v) if v.is_number() => v.as_f64(),+ Some(v) if v.is_string() => v.as_str().and_then(|s| s.parse::<f64>().ok()),+ _ => None,+ };+ value.map(|f| f as u64)+}++fn is_retryable_transport_message(msg: &str) -> bool {+ msg.contains("you can retry your request")+ || msg.contains("socket connection was closed unexpectedly")+ || msg.contains("connection closed unexpectedly")+ || msg.contains("connection reset")+ || msg.contains("operation timed out")+ || msg.contains("econnreset")+ || msg.contains("epipe")+ || msg.contains("etimedout")+ || msg.contains("und_err_socket")+ || msg.contains("fetch failed")+}++pub fn map_codex_usage_to_anthropic(+ u: &Option<CodexUsage>,+ web_search_requests: Option<usize>,+) -> AnthropicUsage {+ let usage = match u {+ Some(u) => u,+ None => return AnthropicUsage::default(),+ };+ let cached = usage.input_tokens_details_cached.unwrap_or(0);+ let total_input = usage.input_tokens.unwrap_or(0);+ let input_tokens = total_input.saturating_sub(cached);++ let mut result = AnthropicUsage {+ input_tokens,+ output_tokens: usage.output_tokens.unwrap_or(0),+ cache_creation_input_tokens: 0,+ cache_read_input_tokens: cached,+ server_tool_use: None,+ };++ if let Some(requests) = web_search_requests {+ if requests > 0 {+ result.server_tool_use = Some(WebSearchUsage {+ web_search_requests: requests,+ });+ }+ }++ result+}++#[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)]+pub struct AnthropicUsage {+ pub input_tokens: u64,+ pub output_tokens: u64,+ pub cache_creation_input_tokens: u64,+ pub cache_read_input_tokens: u64,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub server_tool_use: Option<WebSearchUsage>,+}++#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]+pub struct WebSearchUsage {+ pub web_search_requests: usize,+}++// ---------------------------------------------------------------------------+// Tests+// ---------------------------------------------------------------------------++#[cfg(test)]+mod tests {+ use super::*;+ use serde_json::json;++ fn sse(type_name: &str, payload: serde_json::Value) -> String {+ let mut obj = payload.as_object().cloned().unwrap_or_default();+ obj.insert("type".into(), json!(type_name));+ format!("data: {}\n\n", serde_json::to_string(&obj).unwrap())+ }++ #[test]+ fn reduce_text_response() {+ let upstream = format!(+ "{}{}{}{}",+ sse(+ "response.output_item.added",+ json!({+ "output_index": 0,+ "item": {"type":"message","id":"msg_up"}+ })+ ),+ sse(+ "response.output_text.delta",+ json!({+ "output_index":0,"delta":"hello"+ })+ ),+ sse(+ "response.output_item.done",+ json!({+ "output_index":0,"item":{"type":"message"}+ })+ ),+ sse(+ "response.completed",+ json!({+ "response":{"id":"resp_1","usage":{"input_tokens":5,"output_tokens":1}}+ })+ ),+ );+ let out = reduce_upstream_bytes(upstream.as_bytes()).unwrap();+ let last = out.last().unwrap();+ if let ReducerEvent::Finish {+ stop_reason,+ response_id,+ usage,+ ..+ } = last+ {+ assert_eq!(*stop_reason, "end_turn");+ assert_eq!(response_id.as_deref(), Some("resp_1"));+ assert_eq!(usage.as_ref().unwrap().input_tokens, Some(5));+ } else {+ panic!("expected Finish");+ }+ }++ #[test]+ fn reduce_tool_use_response() {+ let upstream = format!(+ "{}{}{}{}",+ sse(+ "response.output_item.added",+ json!({+ "output_index":0,+ "item":{"type":"function_call","call_id":"call_1","name":"Read"}+ })+ ),+ sse(+ "response.function_call_arguments.delta",+ json!({+ "output_index":0,"delta":"{\"file_path\":"+ })+ ),+ sse(+ "response.function_call_arguments.delta",+ json!({+ "output_index":0,"delta":"\"/tmp/a\"}"+ })+ ),+ sse(+ "response.output_item.done",+ json!({+ "output_index":0,+ "item":{"type":"function_call","call_id":"call_1","name":"Read","arguments":"{\"file_path\":\"/tmp/a\"}"}+ })+ ),+ );+ let out = reduce_upstream_bytes(upstream.as_bytes()).unwrap();+ let last = out.last().unwrap();+ if let ReducerEvent::Finish { stop_reason, .. } = last {+ assert_eq!(*stop_reason, "tool_use");+ } else {+ panic!("expected Finish");+ }+ }++ #[test]+ fn reduce_rate_limit_throws() {+ let upstream = sse(+ "codex.rate_limits",+ json!({"rate_limits":{"limit_reached":true,"primary":{"reset_after_seconds":30}}}),+ );+ let result = reduce_upstream_bytes(upstream.as_bytes());+ assert!(result.is_err());+ assert_eq!(result.unwrap_err().kind, UpstreamErrorKind::RateLimit);+ }++ #[test]+ fn reduce_upstream_error_event() {+ let upstream = sse("error", json!({"error":{"message":"upstream failure"}}));+ let result = reduce_upstream_bytes(upstream.as_bytes());+ assert!(result.is_err());+ match result.unwrap_err().kind {+ UpstreamErrorKind::Failed => {}+ _ => panic!("expected Failed"),+ }+ }++ #[test]+ fn reduce_web_search_output() {+ let upstream = format!(+ "{}{}{}{}{}{}",+ sse(+ "response.output_item.added",+ json!({+ "output_index":0,+ "item":{"type":"web_search_call","id":"ws_1"}+ })+ ),+ sse(+ "response.output_item.done",+ json!({+ "output_index":0,+ "item":{"type":"web_search_call","id":"ws_1","action":{"query":"test query"}}+ })+ ),+ sse(+ "response.output_item.added",+ json!({+ "output_index":1,+ "item":{"type":"message","id":"msg_up"}+ })+ ),+ sse(+ "response.output_text.delta",+ json!({+ "output_index":1,"delta":"result"+ })+ ),+ sse(+ "response.output_item.done",+ json!({+ "output_index":1,"item":{"type":"message"}+ })+ ),+ sse(+ "response.completed",+ json!({+ "response":{"id":"resp_1","usage":{"input_tokens":3}}+ })+ ),+ );+ let out = reduce_upstream_bytes(upstream.as_bytes()).unwrap();+ let has_web_search = out+ .iter()+ .any(|e| matches!(e, ReducerEvent::WebSearch { .. }));+ assert!(has_web_search, "expected WebSearch event");+ let last = out.last().unwrap();+ if let ReducerEvent::Finish {+ web_search_requests,+ ..+ } = last+ {+ assert_eq!(*web_search_requests, 1);+ } else {+ panic!("expected Finish");+ }+ }++ #[test]+ fn reduce_incomplete_is_max_tokens() {+ let upstream = sse(+ "response.incomplete",+ json!({"response":{"id":"resp_1","status":"incomplete","incomplete_details":{"reason":"max_output_tokens"},"usage":{}}}),+ );+ let out = reduce_upstream_bytes(upstream.as_bytes()).unwrap();+ let last = out.last().unwrap();+ if let ReducerEvent::Finish {+ stop_reason,+ continuation_eligible,+ ..+ } = last+ {+ assert_eq!(*stop_reason, "max_tokens");+ assert!(!continuation_eligible);+ } else {+ panic!("expected Finish");+ }+ }++ #[test]+ fn reduce_completed_is_continuation_eligible() {+ let upstream = sse(+ "response.completed",+ json!({"response":{"id":"resp_1","usage":{}}}),+ );+ let out = reduce_upstream_bytes(upstream.as_bytes()).unwrap();+ let last = out.last().unwrap();+ if let ReducerEvent::Finish {+ continuation_eligible,+ ..+ } = last+ {+ assert!(continuation_eligible);+ } else {+ panic!("expected Finish");+ }+ }++ #[test]+ fn sanitize_tool_args_removes_empty_pages() {+ let args = r#"{"file_path":"/tmp/a","pages":""}"#;+ let sanitized = sanitize_tool_args("Read", args);+ let parsed: serde_json::Value = serde_json::from_str(&sanitized).unwrap();+ assert!(parsed.get("pages").is_none());+ assert_eq!(+ parsed.get("file_path").and_then(|v| v.as_str()),+ Some("/tmp/a")+ );+ }++ #[test]+ fn map_usage_subtracts_cached() {+ let usage = CodexUsage {+ input_tokens: Some(100),+ output_tokens: Some(50),+ input_tokens_details_cached: Some(20),+ output_tokens_details_reasoning: None,+ };+ let mapped = map_codex_usage_to_anthropic(&Some(usage), None);+ assert_eq!(mapped.input_tokens, 80);+ assert_eq!(mapped.output_tokens, 50);+ assert_eq!(mapped.cache_read_input_tokens, 20);+ }+}diff --git a/src/providers/codex/translate/request.rs b/src/providers/codex/translate/request.rsnew file mode 100644index 0000000..08712a6--- /dev/null+++ b/src/providers/codex/translate/request.rs@@ -0,0 +1,1010 @@+use serde::{Deserialize, Serialize};+use serde_json::Value;++use crate::anthropic::schema::MessagesRequest;+use crate::config;++// ---------------------------------------------------------------------------+// Types+// ---------------------------------------------------------------------------++#[derive(Debug, Clone, Serialize, Deserialize)]+#[serde(rename_all = "snake_case")]+pub enum Effort {+ None,+ Low,+ Medium,+ High,+ Xhigh,+}++impl std::fmt::Display for Effort {+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {+ match self {+ Effort::None => write!(f, "none"),+ Effort::Low => write!(f, "low"),+ Effort::Medium => write!(f, "medium"),+ Effort::High => write!(f, "high"),+ Effort::Xhigh => write!(f, "xhigh"),+ }+ }+}++#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]+#[serde(rename_all = "snake_case")]+pub enum ServiceTier {+ Priority,+ Flex,+}++#[derive(Debug, Clone, Serialize, Deserialize)]+#[serde(untagged)]+pub enum ResponsesToolChoice {+ Auto,+ None,+ Required,+ Function { r#type: String, name: String },+ WebSearch { r#type: String },+}++#[derive(Debug, Clone, Serialize, Deserialize)]+pub struct ResponsesRequest {+ pub model: String,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub instructions: Option<String>,+ pub input: Vec<ResponsesInputItem>,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub tools: Option<Vec<ResponsesTool>>,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub tool_choice: Option<ResponsesToolChoice>,+ pub store: bool,+ pub stream: bool,+ pub parallel_tool_calls: bool,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub include: Option<Vec<String>>,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub service_tier: Option<ServiceTier>,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub prompt_cache_key: Option<String>,+ pub text: ResponsesText,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub reasoning: Option<ResponsesReasoning>,+}++#[derive(Debug, Clone, Serialize, Deserialize)]+pub struct ResponsesReasoning {+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub effort: Option<Effort>,+}++#[derive(Debug, Clone, Serialize, Deserialize)]+pub struct ResponsesText {+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub verbosity: Option<String>,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub format: Option<ResponsesTextFormat>,+}++#[derive(Debug, Clone, Serialize, Deserialize)]+#[serde(tag = "type")]+#[serde(rename_all = "snake_case")]+pub enum ResponsesTextFormat {+ Text,+ JsonObject,+ JsonSchema {+ name: String,+ schema: Value,+ #[serde(default)]+ strict: Option<bool>,+ },+}++#[derive(Debug, Clone, Serialize, Deserialize)]+#[serde(tag = "type")]+pub enum ResponsesInputItem {+ #[serde(rename = "message")]+ Message {+ role: String,+ content: Vec<ResponsesContentPart>,+ },+ #[serde(rename = "function_call")]+ FunctionCall {+ #[serde(default)]+ call_id: String,+ name: String,+ arguments: String,+ },+ #[serde(rename = "function_call_output")]+ FunctionCallOutput {+ #[serde(default)]+ call_id: String,+ output: String,+ },+}++#[derive(Debug, Clone, Serialize, Deserialize)]+#[serde(tag = "type")]+pub enum ResponsesContentPart {+ #[serde(rename = "input_text")]+ InputText { text: String },+ #[serde(rename = "output_text")]+ OutputText { text: String },+ #[serde(rename = "input_image")]+ InputImage {+ image_url: String,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ detail: Option<String>,+ },+}++#[derive(Debug, Clone, Serialize, Deserialize)]+#[serde(untagged)]+pub enum ResponsesTool {+ Function(ResponsesFunctionTool),+ WebSearch(ResponsesWebSearchTool),+}++#[derive(Debug, Clone, Serialize, Deserialize)]+pub struct ResponsesFunctionTool {+ #[serde(rename = "type")]+ pub kind: String,+ pub name: String,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub description: Option<String>,+ pub parameters: Value,+}++#[derive(Debug, Clone, Serialize, Deserialize)]+pub struct ResponsesWebSearchTool {+ #[serde(rename = "type")]+ pub kind: String,+ pub external_web_access: bool,+ pub search_content_types: Vec<String>,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub filters: Option<ResponsesWebSearchFilters>,+}++#[derive(Debug, Clone, Serialize, Deserialize)]+pub struct ResponsesWebSearchFilters {+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub allowed_domains: Option<Vec<String>>,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub blocked_domains: Option<Vec<String>>,+}++pub struct TranslateOptions {+ pub session_id: Option<String>,+ pub service_tier: Option<ServiceTier>,+}++// ---------------------------------------------------------------------------+// Translation entry point+// ---------------------------------------------------------------------------++fn to_codex_effort(effort: Option<&str>) -> Option<Effort> {+ match effort {+ Some("max") => Some(Effort::Xhigh),+ Some("low") => Some(Effort::Low),+ Some("medium") => Some(Effort::Medium),+ Some("high") => Some(Effort::High),+ _ => None,+ }+}++fn resolve_effort(effort: Option<Effort>) -> Result<Option<Effort>, anyhow::Error> {+ let override_effort = config::codex_effort();+ if let Some(ref val) = override_effort {+ let valid = ["none", "low", "medium", "high", "xhigh"];+ if !valid.contains(&val.as_str()) {+ anyhow::bail!(+ "Invalid effort override: \"{val}\". Must be one of: none, low, medium, high, xhigh"+ );+ }+ return Ok(Some(match val.as_str() {+ "xhigh" => Effort::Xhigh,+ "high" => Effort::High,+ "medium" => Effort::Medium,+ "low" => Effort::Low,+ _ => Effort::None,+ }));+ }+ Ok(effort)+}++const VALID_SERVICE_TIERS: &[&str] = &["fast", "priority", "flex"];++fn normalize_service_tier(tier: &str) -> Result<ServiceTier, anyhow::Error> {+ if !VALID_SERVICE_TIERS.contains(&tier) {+ anyhow::bail!(+ "Invalid service tier override: \"{tier}\". Must be one of: {}",+ VALID_SERVICE_TIERS.join(", ")+ );+ }+ match tier {+ "flex" => Ok(ServiceTier::Flex),+ _ => Ok(ServiceTier::Priority),+ }+}++fn resolve_service_tier(+ model_tier: Option<ServiceTier>,+) -> Result<Option<ServiceTier>, anyhow::Error> {+ let tier = config::codex_service_tier();+ match tier {+ Some(ref val) => Ok(Some(normalize_service_tier(val)?)),+ None => Ok(model_tier),+ }+}++pub fn normalize_strict_json_schema(schema: &Value) -> Value {+ match schema {+ Value::Array(arr) => Value::Array(arr.iter().map(normalize_strict_json_schema).collect()),+ Value::Object(map) => {+ let mut out = map.clone();+ if let Some(properties) = out.get("properties").and_then(|v| v.as_object()) {+ let keys: Vec<String> = properties.keys().cloned().collect();+ out.insert(+ "required".into(),+ Value::Array(keys.into_iter().map(Value::String).collect()),+ );+ }+ for (key, val) in out.clone().iter() {+ out.insert(key.clone(), normalize_strict_json_schema(val));+ }+ Value::Object(out)+ }+ _ => schema.clone(),+ }+}++pub fn translate_request(+ req: &MessagesRequest,+ opts: TranslateOptions,+) -> Result<ResponsesRequest, anyhow::Error> {+ let model = req.model.as_deref().unwrap_or("gpt-5.5");+ let instructions = flatten_system_text(req.extra.get("system"));+ let input = build_input(req);+ let tools = read_tools(req)?;+ let tool_choice = map_tool_choice(req)?;++ let mut text = ResponsesText {+ verbosity: Some("low".to_string()),+ format: None,+ };++ if let Some(fmt) = read_output_format(req) {+ text.format = Some(fmt);+ }++ let mut out = ResponsesRequest {+ model: model.to_string(),+ instructions,+ input,+ store: false,+ stream: true,+ parallel_tool_calls: true,+ tool_choice,+ text,+ tools: None,+ include: None,+ service_tier: None,+ prompt_cache_key: None,+ reasoning: None,+ };++ if let Some(tools) = tools {+ if !tools.is_empty() {+ out.tools = Some(tools);+ }+ }++ if let Some(sid) = opts.session_id {+ out.prompt_cache_key = Some(sid);+ }++ let service_tier = resolve_service_tier(opts.service_tier)?;+ if let Some(ref tier) = service_tier {+ out.service_tier = Some(tier.clone());+ }++ let effort = read_effort(req)?;+ let codex_effort = to_codex_effort(effort);+ let resolved_effort = resolve_effort(codex_effort)?;+ if let Some(ref eff) = resolved_effort {+ out.reasoning = Some(ResponsesReasoning {+ effort: Some(eff.clone()),+ });+ out.include = Some(vec!["reasoning.encrypted_content".to_string()]);+ }++ Ok(out)+}++// ---------------------------------------------------------------------------+// Helpers+// ---------------------------------------------------------------------------++fn flatten_system_text(system: Option<&Value>) -> Option<String> {+ let system = system?;+ let texts: Vec<String> = match system {+ Value::String(s) => vec![s.clone()],+ Value::Array(arr) => arr+ .iter()+ .filter_map(|b| {+ let text = b.get("text").and_then(|v| v.as_str())?;+ if text.starts_with("x-anthropic-billing-header:") {+ None+ } else {+ Some(text.to_string())+ }+ })+ .collect(),+ _ => return None,+ };+ if texts.is_empty() {+ None+ } else {+ Some(texts.join("\n\n"))+ }+}++fn read_effort(req: &MessagesRequest) -> Result<Option<&str>, anyhow::Error> {+ let output_config = match req.extra.get("output_config") {+ Some(Value::Object(m)) => m,+ _ => return Ok(None),+ };+ match output_config.get("effort") {+ Some(Value::String(s)) => {+ let valid = ["low", "medium", "high", "max"];+ if valid.contains(&s.as_str()) {+ Ok(Some(s.as_str()))+ } else {+ anyhow::bail!("Invalid output_config.effort: {s}")+ }+ }+ _ => Ok(None),+ }+}++fn read_output_format(req: &MessagesRequest) -> Option<ResponsesTextFormat> {+ let output_config = req.extra.get("output_config")?.as_object()?;+ let format = output_config.get("format")?.as_object()?;+ let kind = format.get("type")?.as_str()?;+ match kind {+ "json_schema" => {+ let name = format+ .get("name")+ .and_then(|v| v.as_str())+ .unwrap_or("response")+ .to_string();+ let schema = format.get("schema")?;+ let normalized = normalize_strict_json_schema(schema);+ Some(ResponsesTextFormat::JsonSchema {+ name,+ schema: normalized,+ strict: Some(true),+ })+ }+ "json_object" => Some(ResponsesTextFormat::JsonObject),+ _ => Some(ResponsesTextFormat::Text),+ }+}++fn read_tools(req: &MessagesRequest) -> Result<Option<Vec<ResponsesTool>>, anyhow::Error> {+ let Some(tools) = req.extra.get("tools") else {+ return Ok(None);+ };+ let tools_arr = match tools {+ Value::Array(a) => a,+ _ => return Ok(None),+ };+ let mut out = Vec::new();+ for tool in tools_arr {+ let tool_type = tool+ .get("type")+ .and_then(|v| v.as_str())+ .unwrap_or("function");+ if tool_type == "web_search_20250305" {+ let mut filters = ResponsesWebSearchFilters {+ allowed_domains: None,+ blocked_domains: None,+ };+ let allowed = tool.get("allowed_domains").and_then(|v| v.as_array());+ if allowed.map_or(false, |a| !a.is_empty()) {+ filters.allowed_domains = allowed.map(|a| {+ a.iter()+ .filter_map(|v| v.as_str().map(String::from))+ .collect()+ });+ }+ let blocked = tool.get("blocked_domains").and_then(|v| v.as_array());+ if blocked.map_or(false, |a| !a.is_empty()) {+ filters.blocked_domains = blocked.map(|a| {+ a.iter()+ .filter_map(|v| v.as_str().map(String::from))+ .collect()+ });+ }+ let has_filters =+ filters.allowed_domains.is_some() || filters.blocked_domains.is_some();+ out.push(ResponsesTool::WebSearch(ResponsesWebSearchTool {+ kind: "web_search".to_string(),+ external_web_access: false,+ search_content_types: vec!["text".to_string(), "image".to_string()],+ filters: if has_filters { Some(filters) } else { None },+ }));+ } else {+ let name = tool+ .get("name")+ .and_then(|v| v.as_str())+ .unwrap_or("")+ .to_string();+ let description = tool+ .get("description")+ .and_then(|v| v.as_str())+ .map(|s| s.to_string());+ let parameters = tool+ .get("input_schema")+ .cloned()+ .unwrap_or(serde_json::json!({}));+ out.push(ResponsesTool::Function(ResponsesFunctionTool {+ kind: "function".to_string(),+ name,+ description,+ parameters,+ }));+ }+ }+ if out.is_empty() {+ Ok(None)+ } else {+ Ok(Some(out))+ }+}++fn map_tool_choice(req: &MessagesRequest) -> Result<Option<ResponsesToolChoice>, anyhow::Error> {+ let choice = match req.extra.get("tool_choice") {+ Some(Value::Object(m)) => m,+ Some(Value::String(s)) => {+ return Ok(Some(match s.as_str() {+ "auto" => ResponsesToolChoice::Auto,+ "none" => ResponsesToolChoice::None,+ "any" | "required" => ResponsesToolChoice::Required,+ _ => ResponsesToolChoice::Auto,+ }));+ }+ _ => return Ok(None),+ };++ let choice_type = choice+ .get("type")+ .and_then(|v| v.as_str())+ .unwrap_or("auto");+ match choice_type {+ "auto" => Ok(Some(ResponsesToolChoice::Auto)),+ "none" => Ok(Some(ResponsesToolChoice::None)),+ "any" | "required" => Ok(Some(ResponsesToolChoice::Required)),+ "tool" => {+ let name = choice.get("name").and_then(|v| v.as_str()).unwrap_or("");+ let tools = req.extra.get("tools").and_then(|v| v.as_array());+ let is_web_search = tools.map_or(false, |t| {+ t.iter().any(|tool| {+ tool.get("type")+ .and_then(|v| v.as_str())+ .map_or(false, |t| t == "web_search_20250305")+ && tool.get("name").and_then(|v| v.as_str()) == Some(name)+ })+ });+ if is_web_search {+ Ok(Some(ResponsesToolChoice::WebSearch {+ r#type: "web_search".to_string(),+ }))+ } else {+ Ok(Some(ResponsesToolChoice::Function {+ r#type: "function".to_string(),+ name: name.to_string(),+ }))+ }+ }+ _ => Ok(None),+ }+}++fn build_input(req: &MessagesRequest) -> Vec<ResponsesInputItem> {+ let mut out: Vec<ResponsesInputItem> = Vec::new();++ for msg in &req.messages {+ let blocks = normalize_content(&msg.content);+ match msg.role.as_str() {+ "user" => {+ let mut parts: Vec<ResponsesContentPart> = Vec::new();+ for block in &blocks {+ match block {+ ContentBlock::Text { text } => {+ parts.push(ResponsesContentPart::InputText { text: text.clone() });+ }+ ContentBlock::Image { source } => {+ let url = if source.source_type == "url" {+ source.data.clone()+ } else {+ format!("data:{};base64,{}", source.media_type, source.data)+ };+ parts.push(ResponsesContentPart::InputImage {+ image_url: url,+ detail: None,+ });+ }+ ContentBlock::ToolResult {+ tool_use_id,+ content,+ is_error,+ } => {+ if !parts.is_empty() {+ out.push(ResponsesInputItem::Message {+ role: "user".to_string(),+ content: std::mem::take(&mut parts),+ });+ }+ let body = tool_result_to_string(content);+ let output = if is_error.unwrap_or(false) {+ format!("[tool execution error]\n{body}")+ } else {+ body+ };+ out.push(ResponsesInputItem::FunctionCallOutput {+ call_id: tool_use_id.clone(),+ output,+ });+ }+ _ => {}+ }+ }+ if !parts.is_empty() {+ out.push(ResponsesInputItem::Message {+ role: "user".to_string(),+ content: parts,+ });+ }+ }+ "system" => {+ let parts: Vec<ResponsesContentPart> = blocks+ .iter()+ .filter_map(|b| match b {+ ContentBlock::Text { text } => {+ Some(ResponsesContentPart::InputText { text: text.clone() })+ }+ _ => None,+ })+ .collect();+ if !parts.is_empty() {+ out.push(ResponsesInputItem::Message {+ role: "developer".to_string(),+ content: parts,+ });+ }+ }+ _ => {+ let mut text_parts: Vec<ResponsesContentPart> = Vec::new();+ let flush_text =+ |out: &mut Vec<ResponsesInputItem>,+ text_parts: &mut Vec<ResponsesContentPart>| {+ if !text_parts.is_empty() {+ out.push(ResponsesInputItem::Message {+ role: "assistant".to_string(),+ content: std::mem::take(text_parts),+ });+ }+ };+ for block in &blocks {+ match block {+ ContentBlock::Text { text } => {+ text_parts+ .push(ResponsesContentPart::OutputText { text: text.clone() });+ }+ ContentBlock::ToolUse { id, name, input } => {+ flush_text(&mut out, &mut text_parts);+ let args =+ serde_json::to_string(input).unwrap_or_else(|_| "{}".to_string());+ out.push(ResponsesInputItem::FunctionCall {+ call_id: id.clone(),+ name: name.clone(),+ arguments: args,+ });+ }+ _ => {}+ }+ }+ flush_text(&mut out, &mut text_parts);+ }+ }+ }++ out+}++// ---------------------------------------------------------------------------+// Content block normalization+// ---------------------------------------------------------------------------++#[derive(Debug)]+pub enum ContentBlock {+ Text {+ text: String,+ },+ Image {+ source: ImageSource,+ },+ ToolUse {+ id: String,+ name: String,+ input: Value,+ },+ ToolResult {+ tool_use_id: String,+ content: Value,+ is_error: Option<bool>,+ },+}++#[derive(Debug)]+pub struct ImageSource {+ pub media_type: String,+ pub data: String,+ pub source_type: String,+}++fn normalize_content(content: &Value) -> Vec<ContentBlock> {+ match content {+ Value::String(s) => {+ vec![ContentBlock::Text { text: s.clone() }]+ }+ Value::Array(arr) => {+ let mut blocks = Vec::new();+ for item in arr {+ if let Some(block) = parse_content_block(item) {+ blocks.push(block);+ }+ }+ blocks+ }+ _ => Vec::new(),+ }+}++fn parse_content_block(value: &Value) -> Option<ContentBlock> {+ let kind = value.get("type").and_then(|v| v.as_str())?;+ match kind {+ "text" => {+ let text = value+ .get("text")+ .and_then(|v| v.as_str())+ .unwrap_or("")+ .to_string();+ Some(ContentBlock::Text { text })+ }+ "image" => {+ let source = value.get("source")?;+ let media_type = source+ .get("media_type")+ .and_then(|v| v.as_str())+ .unwrap_or("image/png")+ .to_string();+ let source_type = source+ .get("type")+ .and_then(|v| v.as_str())+ .unwrap_or("base64")+ .to_string();+ let data = if source_type == "url" {+ source.get("url").and_then(|v| v.as_str()).unwrap_or("")+ } else {+ source.get("data").and_then(|v| v.as_str()).unwrap_or("")+ }+ .to_string();+ Some(ContentBlock::Image {+ source: ImageSource {+ media_type,+ data,+ source_type,+ },+ })+ }+ "tool_use" => {+ let id = value+ .get("id")+ .and_then(|v| v.as_str())+ .unwrap_or("")+ .to_string();+ let name = value+ .get("name")+ .and_then(|v| v.as_str())+ .unwrap_or("")+ .to_string();+ let input = value.get("input").cloned().unwrap_or(Value::Null);+ Some(ContentBlock::ToolUse { id, name, input })+ }+ "tool_result" => {+ let tool_use_id = value+ .get("tool_use_id")+ .and_then(|v| v.as_str())+ .unwrap_or("")+ .to_string();+ let content = value+ .get("content")+ .cloned()+ .unwrap_or(Value::String(String::new()));+ let is_error = value.get("is_error").and_then(|v| v.as_bool());+ Some(ContentBlock::ToolResult {+ tool_use_id,+ content,+ is_error,+ })+ }+ _ => None,+ }+}++fn tool_result_to_string(content: &Value) -> String {+ match content {+ Value::String(s) => s.clone(),+ Value::Array(arr) => {+ let mut parts = Vec::new();+ for b in arr {+ match b.get("type").and_then(|v| v.as_str()) {+ Some("text") => {+ let text = b.get("text").and_then(|v| v.as_str()).unwrap_or("");+ parts.push(text.to_string());+ }+ Some("image") => {+ let source = b.get("source");+ let media_type = source+ .and_then(|s| s.get("media_type"))+ .and_then(|v| v.as_str())+ .unwrap_or("image");+ parts.push(format!("[image omitted: {media_type}]"));+ }+ Some(other) => {+ parts.push(format!("[unsupported content block omitted: {other}]"));+ }+ None => {}+ }+ }+ parts.join("\n")+ }+ _ => String::new(),+ }+}++#[cfg(test)]+mod tests {+ use super::*;+ use serde_json::json;++ #[test]+ fn translate_web_search_tool_to_codex_tool() {+ let req: MessagesRequest = serde_json::from_value(json!({+ "model": "gpt-5.5",+ "messages": [{"role":"user", "content":"find it"}],+ "tools": [{+ "type":"web_search_20250305",+ "name":"web_search",+ "allowed_domains":["example.com"]+ }],+ "tool_choice": {"type":"tool", "name":"web_search"}+ }))+ .unwrap();+ let out = translate_request(+ &req,+ TranslateOptions {+ session_id: Some("s".into()),+ service_tier: None,+ },+ )+ .unwrap();+ assert_eq!(out.prompt_cache_key.as_deref(), Some("s"));+ assert!(matches!(+ out.tool_choice,+ Some(ResponsesToolChoice::WebSearch { .. })+ ));+ }++ #[test]+ fn translate_omits_reasoning_when_not_enabled() {+ let req: MessagesRequest = serde_json::from_value(json!({+ "model": "gpt-5.5",+ "messages": [{"role":"user", "content":"hello"}]+ }))+ .unwrap();+ let out = translate_request(+ &req,+ TranslateOptions {+ session_id: None,+ service_tier: None,+ },+ )+ .unwrap();+ assert!(out.reasoning.is_none());+ assert!(out.include.is_none());+ }++ #[test]+ fn translate_includes_reasoning_when_enabled() {+ let req: MessagesRequest = serde_json::from_value(json!({+ "model": "gpt-5.5",+ "messages": [{"role":"user", "content":"hello"}],+ "output_config": {"effort": "medium"}+ }))+ .unwrap();+ let out = translate_request(+ &req,+ TranslateOptions {+ session_id: None,+ service_tier: None,+ },+ )+ .unwrap();+ assert!(out.reasoning.is_some());+ assert_eq!(+ out.include,+ Some(vec!["reasoning.encrypted_content".to_string()])+ );+ }++ #[test]+ fn translate_effort_max_maps_to_xhigh() {+ let req: MessagesRequest = serde_json::from_value(json!({+ "model": "gpt-5.5",+ "messages": [{"role":"user", "content":"hello"}],+ "output_config": {"effort": "max"}+ }))+ .unwrap();+ let out = translate_request(+ &req,+ TranslateOptions {+ session_id: None,+ service_tier: None,+ },+ )+ .unwrap();+ assert!(matches!(out.reasoning.unwrap().effort, Some(Effort::Xhigh)));+ }++ #[test]+ fn translate_user_text_and_image() {+ let req: MessagesRequest = serde_json::from_value(json!({+ "model": "gpt-5.5",+ "messages": [{"role":"user", "content": [+ {"type":"text", "text":"describe"},+ {"type":"image", "source": {"type":"base64", "media_type":"image/jpeg", "data":"xyz"}}+ ]}]+ }))+ .unwrap();+ let out = translate_request(+ &req,+ TranslateOptions {+ session_id: None,+ service_tier: None,+ },+ )+ .unwrap();+ assert_eq!(out.input.len(), 1);+ if let ResponsesInputItem::Message { role, content } = &out.input[0] {+ assert_eq!(role, "user");+ assert_eq!(content.len(), 2);+ } else {+ panic!("expected Message");+ }+ }++ #[test]+ fn translate_assistant_with_text_and_tool_use() {+ let req: MessagesRequest = serde_json::from_value(json!({+ "model": "gpt-5.5",+ "messages": [{"role":"assistant", "content": [+ {"type":"text", "text":"answer"},+ {"type":"tool_use", "id":"tu_1", "name":"search", "input": {"q":"rust"}}+ ]}]+ }))+ .unwrap();+ let out = translate_request(+ &req,+ TranslateOptions {+ session_id: None,+ service_tier: None,+ },+ )+ .unwrap();+ assert_eq!(out.input.len(), 2);+ }++ #[test]+ fn translate_strict_json_schema_normalization() {+ let req: MessagesRequest = serde_json::from_value(json!({+ "model": "gpt-5.5",+ "messages": [{"role":"user", "content":"hi"}],+ "output_config": {"format": {+ "type": "json_schema",+ "schema": {+ "type": "object",+ "properties": {"ok": {"type": "boolean"}, "reason": {"type": "string"}},+ "required": ["ok"]+ }+ }}+ }))+ .unwrap();+ let out = translate_request(+ &req,+ TranslateOptions {+ session_id: None,+ service_tier: None,+ },+ )+ .unwrap();+ if let Some(ResponsesTextFormat::JsonSchema { schema, .. }) = &out.text.format {+ let required = schema.get("required").and_then(|v| v.as_array()).unwrap();+ assert!(required.iter().any(|v| v == "ok"));+ assert!(required.iter().any(|v| v == "reason"));+ } else {+ panic!("expected JsonSchema format");+ }+ }++ #[test]+ fn translate_tool_result_content() {+ let req: MessagesRequest = serde_json::from_value(json!({+ "model": "gpt-5.5",+ "messages": [{"role":"user", "content": [{+ "type": "tool_result",+ "tool_use_id": "tu_1",+ "content": [{"type":"text", "text":"result"}]+ }]}]+ }))+ .unwrap();+ let out = translate_request(+ &req,+ TranslateOptions {+ session_id: None,+ service_tier: None,+ },+ )+ .unwrap();+ assert_eq!(out.input.len(), 1);+ if let ResponsesInputItem::FunctionCallOutput { call_id, .. } = &out.input[0] {+ assert_eq!(call_id, "tu_1");+ } else {+ panic!("expected FunctionCallOutput");+ }+ }++ #[test]+ fn translate_returns_only_expected_top_level_fields() {+ let req: MessagesRequest = serde_json::from_value(json!({+ "model": "sonnet",+ "messages": [{"role":"user", "content":"hello"}],+ "system": "be helpful",+ "tools": [{"name":"test","input_schema":{"type":"object"}}],+ "tool_choice": {"type":"tool", "name":"test"}+ }))+ .unwrap();+ let out = translate_request(+ &req,+ TranslateOptions {+ session_id: None,+ service_tier: None,+ },+ )+ .unwrap();+ let out_value = serde_json::to_value(&out).unwrap();+ let keys: std::collections::BTreeSet<String> =+ out_value.as_object().unwrap().keys().cloned().collect();+ for key in &[+ "model",+ "input",+ "store",+ "stream",+ "parallel_tool_calls",+ "text",+ ] {+ assert!(keys.contains(*key), "missing key: {key}");+ }+ }+}diff --git a/src/providers/codex/translate/stream.rs b/src/providers/codex/translate/stream.rsnew file mode 100644index 0000000..1329b06--- /dev/null+++ b/src/providers/codex/translate/stream.rs@@ -0,0 +1,483 @@+use crate::anthropic::sse::encode_sse_event;++use super::reducer::{ReducerEvent, map_codex_usage_to_anthropic, reduce_upstream_bytes};+use super::web_search_compat::build_web_search_compat_blocks;++pub fn translate_stream_bytes(+ upstream: &[u8],+ message_id: &str,+ model: &str,+) -> Result<Vec<u8>, anyhow::Error> {+ let events = reduce_upstream_bytes(upstream)+ .map_err(|e| anyhow::anyhow!("upstream stream error: {} ({:?})", e.message, e.kind))?;++ let mut out = Vec::new();+ let mut message_started = false;+ let mut open_blocks: std::collections::BTreeMap<usize, OpenBlock> =+ std::collections::BTreeMap::new();+ let mut web_search_events: Vec<ReducerEvent> = Vec::new();+ let mut deferred_content_events: Vec<ReducerEvent> = Vec::new();++ enum OpenBlock {+ Text,+ Tool { id: String, name: String },+ }++ let mut emit = |event: &str, data: &serde_json::Value| -> Result<(), anyhow::Error> {+ out.extend_from_slice(&encode_sse_event(Some(event), &data.to_string()));+ Ok(())+ };++ let mut ensure_message_start = |emit: &mut dyn FnMut(+ &str,+ &serde_json::Value,+ ) -> Result<(), anyhow::Error>|+ -> Result<(), anyhow::Error> {+ if !message_started {+ message_started = true;+ let data = serde_json::json!({+ "type": "message_start",+ "message": {+ "id": message_id,+ "type": "message",+ "role": "assistant",+ "model": model,+ "content": [],+ "stop_reason": null,+ "stop_sequence": null,+ "usage": {+ "input_tokens": 0,+ "output_tokens": 0,+ }+ }+ });+ emit("message_start", &data)?;+ }+ Ok(())+ };++ let is_content_event = |event: &ReducerEvent| -> bool {+ matches!(+ event,+ ReducerEvent::TextStart { .. }+ | ReducerEvent::TextDelta { .. }+ | ReducerEvent::TextStop { .. }+ | ReducerEvent::ToolStart { .. }+ | ReducerEvent::ToolDelta { .. }+ | ReducerEvent::ToolStop { .. }+ )+ };++ for event in &events {+ if matches!(event, ReducerEvent::WebSearch { .. }) {+ web_search_events.push(event.clone());+ continue;+ }+ if !web_search_events.is_empty() && is_content_event(event) {+ deferred_content_events.push(event.clone());+ continue;+ }++ match event {+ ReducerEvent::TextStart { index } => {+ ensure_message_start(&mut emit)?;+ open_blocks.insert(*index, OpenBlock::Text);+ emit(+ "content_block_start",+ &serde_json::json!({+ "type": "content_block_start",+ "index": index,+ "content_block": {"type": "text", "text": ""}+ }),+ )?;+ }+ ReducerEvent::TextDelta { index, text } => {+ emit(+ "content_block_delta",+ &serde_json::json!({+ "type": "content_block_delta",+ "index": index,+ "delta": {"type": "text_delta", "text": text}+ }),+ )?;+ }+ ReducerEvent::TextStop { index } => {+ open_blocks.remove(index);+ emit(+ "content_block_stop",+ &serde_json::json!({+ "type": "content_block_stop",+ "index": index,+ }),+ )?;+ }+ ReducerEvent::ToolStart { index, id, name } => {+ ensure_message_start(&mut emit)?;+ open_blocks.insert(+ *index,+ OpenBlock::Tool {+ id: id.clone(),+ name: name.clone(),+ },+ );+ emit(+ "content_block_start",+ &serde_json::json!({+ "type": "content_block_start",+ "index": index,+ "content_block": {+ "type": "tool_use",+ "id": id,+ "name": name,+ "input": {}+ }+ }),+ )?;+ }+ ReducerEvent::ToolDelta {+ index,+ partial_json,+ } => {+ emit(+ "content_block_delta",+ &serde_json::json!({+ "type": "content_block_delta",+ "index": index,+ "delta": {+ "type": "input_json_delta",+ "partial_json": partial_json+ }+ }),+ )?;+ }+ ReducerEvent::ToolStop { index } => {+ open_blocks.remove(index);+ emit(+ "content_block_stop",+ &serde_json::json!({+ "type": "content_block_stop",+ "index": index,+ }),+ )?;+ }+ ReducerEvent::ToolProgress { .. } | ReducerEvent::Progress => {+ // These are just progress indicators; emit nothing in buffered mode+ }+ ReducerEvent::Finish {+ stop_reason,+ usage,+ web_search_requests,+ ..+ } => {+ // Emit web search compat blocks+ if !web_search_events.is_empty() {+ let text_from_deferred: String = deferred_content_events+ .iter()+ .filter_map(|e| match e {+ ReducerEvent::TextDelta { text, .. } => Some(text.as_str()),+ _ => None,+ })+ .collect();+ let compat_blocks =+ build_web_search_compat_blocks(&web_search_events, &text_from_deferred);+ for block in &compat_blocks {+ use super::web_search_compat::WebSearchCompatContent;+ match &block.content {+ WebSearchCompatContent::ServerToolUse { id, name, input } => {+ ensure_message_start(&mut emit)?;+ emit(+ "content_block_start",+ &serde_json::json!({+ "type": "content_block_start",+ "index": block.index,+ "content_block": {+ "type": "server_tool_use",+ "id": id,+ "name": name,+ "input": {}+ }+ }),+ )?;+ emit(+ "content_block_delta",+ &serde_json::json!({+ "type": "content_block_delta",+ "index": block.index,+ "delta": {+ "type": "input_json_delta",+ "partial_json": serde_json::to_string(input).unwrap_or_default()+ }+ }),+ )?;+ emit(+ "content_block_stop",+ &serde_json::json!({+ "type": "content_block_stop",+ "index": block.index,+ }),+ )?;+ }+ WebSearchCompatContent::WebSearchToolResult {+ tool_use_id,+ content: results,+ } => {+ let result_content: Vec<serde_json::Value> = results+ .iter()+ .map(|r| {+ serde_json::json!({+ "type": "web_search_result",+ "title": r.title,+ "url": r.url,+ })+ })+ .collect();+ emit(+ "content_block_start",+ &serde_json::json!({+ "type": "content_block_start",+ "index": block.index,+ "content_block": {+ "type": "web_search_tool_result",+ "tool_use_id": tool_use_id,+ "content": result_content,+ }+ }),+ )?;+ emit(+ "content_block_stop",+ &serde_json::json!({+ "type": "content_block_stop",+ "index": block.index,+ }),+ )?;+ }+ }+ }+ }++ // Emit deferred content+ for deferred in &deferred_content_events {+ match deferred {+ ReducerEvent::TextStart { index } => {+ ensure_message_start(&mut emit)?;+ open_blocks.insert(*index, OpenBlock::Text);+ emit(+ "content_block_start",+ &serde_json::json!({+ "type": "content_block_start",+ "index": index,+ "content_block": {"type": "text", "text": ""}+ }),+ )?;+ }+ ReducerEvent::TextDelta { index, text } => {+ emit(+ "content_block_delta",+ &serde_json::json!({+ "type": "content_block_delta",+ "index": index,+ "delta": {"type": "text_delta", "text": text}+ }),+ )?;+ }+ ReducerEvent::TextStop { index } => {+ open_blocks.remove(index);+ emit(+ "content_block_stop",+ &serde_json::json!({+ "type": "content_block_stop",+ "index": index,+ }),+ )?;+ }+ ReducerEvent::ToolStart { index, id, name } => {+ ensure_message_start(&mut emit)?;+ open_blocks.insert(+ *index,+ OpenBlock::Tool {+ id: id.clone(),+ name: name.clone(),+ },+ );+ emit(+ "content_block_start",+ &serde_json::json!({+ "type": "content_block_start",+ "index": index,+ "content_block": {+ "type": "tool_use",+ "id": id,+ "name": name,+ "input": {}+ }+ }),+ )?;+ }+ ReducerEvent::ToolDelta {+ index,+ partial_json,+ } => {+ emit(+ "content_block_delta",+ &serde_json::json!({+ "type": "content_block_delta",+ "index": index,+ "delta": {+ "type": "input_json_delta",+ "partial_json": partial_json+ }+ }),+ )?;+ }+ ReducerEvent::ToolStop { index } => {+ open_blocks.remove(index);+ emit(+ "content_block_stop",+ &serde_json::json!({+ "type": "content_block_stop",+ "index": index,+ }),+ )?;+ }+ _ => {}+ }+ }++ ensure_message_start(&mut emit)?;++ let mapped = map_codex_usage_to_anthropic(usage, Some(*web_search_requests));+ emit(+ "message_delta",+ &serde_json::json!({+ "type": "message_delta",+ "delta": {+ "stop_reason": stop_reason,+ "stop_sequence": null+ },+ "usage": mapped,+ }),+ )?;+ emit("message_stop", &serde_json::json!({"type": "message_stop"}))?;+ }+ _ => {}+ }+ }++ Ok(out)+}++#[cfg(test)]+mod tests {+ use super::*;++ fn sse_event(type_name: &str, payload: serde_json::Value) -> String {+ let mut obj = if let serde_json::Value::Object(m) = payload {+ m+ } else {+ return String::new();+ };+ obj.insert("type".into(), serde_json::json!(type_name));+ format!(+ "data: {}\n\n",+ serde_json::to_string(&serde_json::Value::Object(obj)).unwrap()+ )+ }++ #[test]+ fn stream_translates_text_response() {+ let upstream = format!(+ "{}{}{}{}",+ sse_event(+ "response.output_item.added",+ serde_json::json!({+ "output_index": 0,+ "item": {"type":"message","id":"item_1"}+ })+ ),+ sse_event(+ "response.output_text.delta",+ serde_json::json!({+ "output_index":0,"delta":"hello"+ })+ ),+ sse_event(+ "response.output_item.done",+ serde_json::json!({+ "output_index":0,"item":{"type":"message"}+ })+ ),+ sse_event(+ "response.completed",+ serde_json::json!({+ "response":{"id":"resp_1","usage":{"input_tokens":5,"output_tokens":1}}+ })+ ),+ );+ let out = String::from_utf8(+ translate_stream_bytes(upstream.as_bytes(), "msg_1", "gpt-5.5").unwrap(),+ )+ .unwrap();+ assert!(out.contains("message_start"));+ assert!(out.contains("text_delta"));+ assert!(out.contains("message_stop"));+ }++ #[test]+ fn stream_translates_web_search_response() {+ let upstream = format!(+ "{}{}{}{}{}{}{}",+ sse_event(+ "response.output_item.added",+ serde_json::json!({+ "output_index":0,+ "item":{"type":"web_search_call","id":"ws_1"}+ })+ ),+ sse_event(+ "response.web_search_call.in_progress",+ serde_json::json!({+ "output_index":0,"item_id":"ws_1"+ })+ ),+ sse_event(+ "response.web_search_call.completed",+ serde_json::json!({+ "output_index":0,"item_id":"ws_1"+ })+ ),+ sse_event(+ "response.output_item.done",+ serde_json::json!({+ "output_index":0,+ "item":{"type":"web_search_call","id":"ws_1","action":{"query":"test query"}}+ })+ ),+ sse_event(+ "response.output_item.added",+ serde_json::json!({+ "output_index":1,+ "item":{"type":"message","id":"msg_up"}+ })+ ),+ sse_event(+ "response.output_text.delta",+ serde_json::json!({+ "output_index":1,"delta":"See [Result](https://result.com)"+ })+ ),+ sse_event(+ "response.output_item.done",+ serde_json::json!({+ "output_index":1,"item":{"type":"message"}+ })+ ),+ );+ let result = translate_stream_bytes(upstream.as_bytes(), "msg_1", "gpt-5.5").unwrap();+ let out = String::from_utf8(result).unwrap();+ assert!(out.contains("server_tool_use"), "missing server_tool_use");+ assert!(+ out.contains("web_search_tool_result"),+ "missing web_search_tool_result"+ );+ }+}diff --git a/src/providers/codex/translate/web_search_compat.rs b/src/providers/codex/translate/web_search_compat.rsnew file mode 100644index 0000000..2938b09--- /dev/null+++ b/src/providers/codex/translate/web_search_compat.rs@@ -0,0 +1,205 @@+use serde_json::Value;++pub struct WebSearchCompatBlock {+ pub index: usize,+ pub content: WebSearchCompatContent,+}++pub enum WebSearchCompatContent {+ ServerToolUse {+ id: String,+ name: String,+ input: Value,+ },+ WebSearchToolResult {+ tool_use_id: String,+ content: Vec<WebSearchResult>,+ },+}++#[derive(Clone)]+pub struct WebSearchResult {+ pub title: String,+ pub url: String,+}++pub fn server_tool_use_id_from_codex_web_search_id(id: &str) -> String {+ let suffix: String = id+ .chars()+ .map(|c| {+ if c.is_alphanumeric() || c == '_' {+ c+ } else {+ '_'+ }+ })+ .collect();+ format!("srvtoolu_{suffix}")+}++fn extract_web_search_results_from_text(text: &str) -> Vec<WebSearchResult> {+ let mut results: Vec<WebSearchResult> = Vec::new();+ let mut seen_urls: std::collections::HashSet<String> = std::collections::HashSet::new();++ // Match markdown links [title](url)+ let re = regex_lite::Regex::new(r#"\[([^\]\n]+)\]\((https?://[^)\s]+)\)"#).unwrap();+ for cap in re.captures_iter(text) {+ let title = clean_title(cap.get(1).map(|m| m.as_str()).unwrap_or(""));+ let url = clean_url(cap.get(2).map(|m| m.as_str()).unwrap_or(""));+ if url.is_empty() || seen_urls.contains(&url) {+ continue;+ }+ seen_urls.insert(url.clone());+ let display_title = if title.is_empty() {+ fallback_title(&url)+ } else {+ title+ };+ results.push(WebSearchResult {+ title: display_title,+ url,+ });+ }++ // Match bare URLs+ let re2 = regex_lite::Regex::new(r"https?://[^\s<>()|]+").unwrap();+ for cap in re2.captures_iter(text) {+ let raw_url = cap.get(0).map(|m| m.as_str()).unwrap_or("");+ let url = clean_url(raw_url);+ if url.is_empty() || seen_urls.contains(&url) {+ continue;+ }+ seen_urls.insert(url.clone());+ results.push(WebSearchResult {+ title: fallback_title(&url),+ url,+ });+ }++ results+}++pub fn build_web_search_compat_blocks(+ searches: &[super::reducer::ReducerEvent],+ text: &str,+) -> Vec<WebSearchCompatBlock> {+ let results = extract_web_search_results_from_text(text);+ let mut blocks = Vec::new();++ for event in searches {+ if let super::reducer::ReducerEvent::WebSearch {+ index,+ result_index,+ id,+ query,+ } = event+ {+ blocks.push(WebSearchCompatBlock {+ index: *index,+ content: WebSearchCompatContent::ServerToolUse {+ id: id.clone(),+ name: "web_search".to_string(),+ input: serde_json::json!({"query": query}),+ },+ });+ blocks.push(WebSearchCompatBlock {+ index: *result_index,+ content: WebSearchCompatContent::WebSearchToolResult {+ tool_use_id: id.clone(),+ content: results.clone(),+ },+ });+ }+ }++ blocks+}++fn clean_url(value: &str) -> String {+ let mut out = value.trim().to_string();+ while out.ends_with('.')+ || out.ends_with(',')+ || out.ends_with(';')+ || out.ends_with(':')+ || out.ends_with('!')+ || out.ends_with('?')+ {+ out.pop();+ }+ out+}++fn clean_title(value: &str) -> String {+ let no_markers = value+ .trim_start()+ .trim_start_matches(|c: char| c == '-' || c == '*' || c == '+' || c.is_ascii_digit())+ .trim_start_matches(|c: char| c == '.' || c == ')' || c == ' ')+ .replace("**", "")+ .replace('`', "")+ .trim()+ .to_string();+ // Take text before dash or em-dash+ if let Some(pos) = no_markers.find(" - ") {+ no_markers[..pos].trim().to_string()+ } else if let Some(find_pos) = no_markers.find(" \u{2013} ") {+ no_markers[..find_pos].trim().to_string()+ } else {+ no_markers+ }+}++fn fallback_title(url: &str) -> String {+ url.trim_start_matches("https://")+ .trim_start_matches("http://")+ .split('/')+ .next()+ .unwrap_or(url)+ .to_string()+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn server_tool_use_id_format() {+ let id = server_tool_use_id_from_codex_web_search_id("ws_123");+ assert_eq!(id, "srvtoolu_ws_123");+ }++ #[test]+ fn extract_results_from_text() {+ let text = "Check [Example](https://example.com) and https://other.com/page.";+ let results = extract_web_search_results_from_text(text);+ assert_eq!(results.len(), 2);+ assert!(results.iter().any(|r| r.url == "https://example.com"));+ assert!(results.iter().any(|r| r.url == "https://other.com/page"));+ }++ #[test]+ fn build_compat_blocks() {+ let searches = vec![super::super::reducer::ReducerEvent::WebSearch {+ index: 0,+ result_index: 1,+ id: "ws_1".to_string(),+ query: "test".to_string(),+ }];+ let text = "See [Result](https://result.com)";+ let blocks = build_web_search_compat_blocks(&searches, text);+ assert_eq!(blocks.len(), 2);+ match &blocks[0].content {+ WebSearchCompatContent::ServerToolUse { name, input, .. } => {+ assert_eq!(name, "web_search");+ assert_eq!(input.get("query").and_then(|v| v.as_str()), Some("test"));+ }+ _ => panic!("expected ServerToolUse"),+ }+ match &blocks[1].content {+ WebSearchCompatContent::WebSearchToolResult { content, .. } => {+ assert_eq!(content.len(), 1);+ assert_eq!(content[0].url, "https://result.com");+ }+ _ => panic!("expected WebSearchToolResult"),+ }+ }+}diff --git a/src/providers/mod.rs b/src/providers/mod.rsindex fe085d1..c186e89 100644--- a/src/providers/mod.rs+++ b/src/providers/mod.rs@@ -1 +1,2 @@+pub mod codex;pub mod kimi;diff --git a/src/registry.rs b/src/registry.rsindex 173c805..e45dc44 100644--- a/src/registry.rs+++ b/src/registry.rs@@ -32,7 +32,7 @@ const CURSOR_LEGACY_MODELS: &[&str] = &["composer-2.5-fast",];-const CODEX_MODELS: &[&str] = &[+pub(crate) const CODEX_MODELS: &[&str] = &["gpt-5.2","gpt-5.3-codex","gpt-5.3-codex-spark",@@ -62,6 +62,7 @@ impl Registry {let mut handlers = BTreeMap::new();for (name, entries) in &models {let handler: Arc<dyn Provider> = match name.as_str() {+ "codex" => Arc::new(crate::providers::codex::CodexProvider::new()),"kimi" => Arc::new(crate::providers::kimi::KimiProvider::new()),_ => Arc::new(PlaceholderProvider::new(name, entries.clone())),};diff --git a/tests/server.rs b/tests/server.rsindex fe4c2e2..f8281dc 100644--- a/tests/server.rs+++ b/tests/server.rs@@ -128,7 +128,7 @@ async fn missing_model_returns_400() {}#[tokio::test]-async fn known_model_reaches_placeholder_provider() {+async fn known_model_reaches_codex_provider() {let app = app(Arc::new(Registry::with_default_alias()));let response = app.oneshot(@@ -144,15 +144,11 @@ async fn known_model_reaches_placeholder_provider() {.await.unwrap();- assert_eq!(response.status(), StatusCode::NOT_IMPLEMENTED);- let body: Value = axum::body::to_bytes(response.into_body(), usize::MAX)- .await- .ok()- .and_then(|bytes| serde_json::from_slice(&bytes).ok())- .unwrap();- assert_eq!(- body["error"]["type"].as_str().unwrap_or(""),- "unsupported_provider_error"+ // Codex provider is now concrete, so it should attempt auth before returning 501+ let status = response.status();+ assert!(+ status != StatusCode::NOT_IMPLEMENTED,+ "codex should no longer be a placeholder provider");}@@ -173,7 +169,12 @@ async fn count_tokens_routes_to_provider() {.await.unwrap();- assert_eq!(response.status(), StatusCode::NOT_IMPLEMENTED);+ // Codex provider is now concrete, so count_tokens should succeed+ let status = response.status();+ assert!(+ status != StatusCode::NOT_IMPLEMENTED,+ "count_tokens should no longer return 501 for codex models"+ );}#[tokio::test]