Skip to content

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.lock
index 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.toml
index c0b0cfb..90d0875 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -29,6 +29,7 @@ reqwest = { version = "0.12", default-features = false, features = ["json", "str
base64 = "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.rs
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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]