Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy
Rust
implement codex websocket transport with pooling, config, and fallback
Raine Virta93d7158cff2c
diff --git a/Cargo.lock b/Cargo.lockindex 5277652..8ee8424 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -181,6 +181,15 @@ version = "2.13.0"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "b4388bee8683e3d04af747c73422af53102d2bd24d9eadb6cbc100baef4b43f8"+[[package]]+name = "block-buffer"+version = "0.10.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"+dependencies = [+ "generic-array",+]+[[package]]name = "bstr"version = "1.12.3"@@ -198,6 +207,12 @@ version = "3.20.3"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649"+[[package]]+name = "byteorder"+version = "1.5.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"+[[package]]name = "bytes"version = "1.12.0"@@ -289,12 +304,14 @@ dependencies = ["serde","serde_json","tempfile",- "thiserror",+ "thiserror 2.0.18","time","tokio",+ "tokio-tungstenite","tower","tracing","tracing-subscriber",+ "url","uuid",]@@ -304,6 +321,47 @@ version = "1.0.5"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570"+[[package]]+name = "core-foundation"+version = "0.10.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6"+dependencies = [+ "core-foundation-sys",+ "libc",+]++[[package]]+name = "core-foundation-sys"+version = "0.8.7"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"++[[package]]+name = "cpufeatures"+version = "0.2.17"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"+dependencies = [+ "libc",+]++[[package]]+name = "crypto-common"+version = "0.1.7"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"+dependencies = [+ "generic-array",+ "typenum",+]++[[package]]+name = "data-encoding"+version = "2.11.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "a4ae5f15dda3c708c0ade84bfee31ccab44a3da4f88015ed22f63732abe300c8"+[[package]]name = "deranged"version = "0.5.8"@@ -316,6 +374,16 @@ version = "0.4.0"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8"+[[package]]+name = "digest"+version = "0.10.7"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"+dependencies = [+ "block-buffer",+ "crypto-common",+]+[[package]]name = "displaydoc"version = "0.2.6"@@ -428,6 +496,16 @@ dependencies = ["slab",]+[[package]]+name = "generic-array"+version = "0.14.7"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"+dependencies = [+ "typenum",+ "version_check",+]+[[package]]name = "getrandom"version = "0.2.17"@@ -836,6 +914,12 @@ version = "1.70.2"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"+[[package]]+name = "openssl-probe"+version = "0.2.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe"+[[package]]name = "percent-encoding"version = "2.3.2"@@ -925,7 +1009,7 @@ dependencies = ["rustc-hash","rustls","socket2",- "thiserror",+ "thiserror 2.0.18","tokio","tracing","web-time",@@ -940,13 +1024,13 @@ dependencies = ["bytes","getrandom 0.3.4","lru-slab",- "rand",+ "rand 0.9.4","ring","rustc-hash","rustls","rustls-pki-types","slab",- "thiserror",+ "thiserror 2.0.18","tinyvec","tracing","web-time",@@ -987,14 +1071,35 @@ version = "6.0.0"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"+[[package]]+name = "rand"+version = "0.8.6"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "5ca0ecfa931c29007047d1bc58e623ab12e5590e8c7cc53200d5202b69266d8a"+dependencies = [+ "libc",+ "rand_chacha 0.3.1",+ "rand_core 0.6.4",+]+[[package]]name = "rand"version = "0.9.4"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "44c5af06bb1b7d3216d91932aed5265164bf384dc89cd6ba05cf59a35f5f76ea"dependencies = [- "rand_chacha",- "rand_core",+ "rand_chacha 0.9.0",+ "rand_core 0.9.5",+]++[[package]]+name = "rand_chacha"+version = "0.3.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"+dependencies = [+ "ppv-lite86",+ "rand_core 0.6.4",][[package]]@@ -1004,7 +1109,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"dependencies = ["ppv-lite86",- "rand_core",+ "rand_core 0.9.5",+]++[[package]]+name = "rand_core"+version = "0.6.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"+dependencies = [+ "getrandom 0.2.17",][[package]]@@ -1140,6 +1254,18 @@ dependencies = ["zeroize",]+[[package]]+name = "rustls-native-certs"+version = "0.8.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "dab5152771c58876a2146916e53e35057e1a4dfa2b9df0f0305b07f611fdea4d"+dependencies = [+ "openssl-probe",+ "rustls-pki-types",+ "schannel",+ "security-framework",+]+[[package]]name = "rustls-pki-types"version = "1.14.1"@@ -1173,6 +1299,38 @@ version = "1.0.23"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f"+[[package]]+name = "schannel"+version = "0.1.29"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "91c1b7e4904c873ef0710c1f407dde2e6287de2bebc1bbbf7d430bb7cbffd939"+dependencies = [+ "windows-sys 0.61.2",+]++[[package]]+name = "security-framework"+version = "3.7.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b7f4bc775c73d9a02cde8bf7b2ec4c9d12743edf609006c7facc23998404cd1d"+dependencies = [+ "bitflags",+ "core-foundation",+ "core-foundation-sys",+ "libc",+ "security-framework-sys",+]++[[package]]+name = "security-framework-sys"+version = "2.17.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "6ce2691df843ecc5d231c0b14ece2acc3efb62c0a398c7e1d875f3983ce020e3"+dependencies = [+ "core-foundation-sys",+ "libc",+]+[[package]]name = "serde"version = "1.0.228"@@ -1239,6 +1397,17 @@ dependencies = ["serde",]+[[package]]+name = "sha1"+version = "0.10.6"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba"+dependencies = [+ "cfg-if",+ "cpufeatures",+ "digest",+]+[[package]]name = "sharded-slab"version = "0.1.7"@@ -1354,13 +1523,33 @@ version = "0.5.1"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "8f50febec83f5ee1df3015341d8bd429f2d1cc62bcba7ea2076759d315084683"+[[package]]+name = "thiserror"+version = "1.0.69"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"+dependencies = [+ "thiserror-impl 1.0.69",+]+[[package]]name = "thiserror"version = "2.0.18"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4"dependencies = [- "thiserror-impl",+ "thiserror-impl 2.0.18",+]++[[package]]+name = "thiserror-impl"+version = "1.0.69"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"+dependencies = [+ "proc-macro2",+ "quote",+ "syn",][[package]]@@ -1475,6 +1664,22 @@ dependencies = ["tokio",]+[[package]]+name = "tokio-tungstenite"+version = "0.24.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "edc5f74e248dc973e0dbb7b74c7e0d6fcc301c694ff50049504004ef4d0cdcd9"+dependencies = [+ "futures-util",+ "log",+ "rustls",+ "rustls-native-certs",+ "rustls-pki-types",+ "tokio",+ "tokio-rustls",+ "tungstenite",+]+[[package]]name = "tokio-util"version = "0.7.18"@@ -1615,6 +1820,32 @@ version = "0.2.5"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"+[[package]]+name = "tungstenite"+version = "0.24.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "18e5b8366ee7a95b16d32197d0b2604b43a0be89dc5fac9f8e96ccafbaedda8a"+dependencies = [+ "byteorder",+ "bytes",+ "data-encoding",+ "http",+ "httparse",+ "log",+ "rand 0.8.6",+ "rustls",+ "rustls-pki-types",+ "sha1",+ "thiserror 1.0.69",+ "utf-8",+]++[[package]]+name = "typenum"+version = "1.20.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20"+[[package]]name = "unicode-ident"version = "1.0.24"@@ -1639,6 +1870,12 @@ dependencies = ["serde",]+[[package]]+name = "utf-8"+version = "0.7.6"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9"+[[package]]name = "utf8_iter"version = "1.0.4"@@ -1669,6 +1906,12 @@ version = "0.1.1"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65"+[[package]]+name = "version_check"+version = "0.9.5"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"+[[package]]name = "wait-timeout"version = "0.2.1"diff --git a/Cargo.toml b/Cargo.tomlindex 90d0875..f0ac2b9 100644--- a/Cargo.toml+++ b/Cargo.toml@@ -30,6 +30,8 @@ base64 = "0.22"hostname = "0.4"once_cell = "1.20"regex-lite = "0.1"+tokio-tungstenite = { version = "0.24", default-features = false, features = ["connect", "rustls-tls-native-roots"] }+url = "2"[dev-dependencies]tempfile = "3.14"diff --git a/src/config.rs b/src/config.rsindex 96123ff..3f90dca 100644--- a/src/config.rs+++ b/src/config.rs@@ -55,6 +55,7 @@ struct CodexConfig {pub effort: Option<String>,#[serde(rename = "model")]pub model: Option<String>,+ pub transport: Option<String>,}#[derive(Deserialize, Clone)]@@ -387,3 +388,122 @@ pub fn codex_model() -> Option<String> {}None}++// ---------------------------------------------------------------------------+// Codex transport config+// ---------------------------------------------------------------------------++#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub enum CodexTransport {+ Http,+ WebSocket,+ Auto,+}++impl CodexTransport {+ pub fn as_str(self) -> &'static str {+ match self {+ CodexTransport::Http => "http",+ CodexTransport::WebSocket => "websocket",+ CodexTransport::Auto => "auto",+ }+ }+}++fn parse_codex_transport(raw: &str) -> Option<CodexTransport> {+ match raw {+ "http" => Some(CodexTransport::Http),+ "websocket" => Some(CodexTransport::WebSocket),+ "auto" => Some(CodexTransport::Auto),+ _ => None,+ }+}++pub fn codex_transport() -> CodexTransport {+ let env: HashMap<_, _> = std::env::vars().collect();+ if let Some(raw) = env.get("CCP_CODEX_TRANSPORT") {+ return parse_codex_transport(raw).unwrap_or(CodexTransport::Http);+ }+ let config_dir = paths::config_dir();+ if let Some(file) = read_file_config(&config_dir) {+ if let Some(codex) = file.codex {+ if let Some(transport) = codex.transport.as_deref().and_then(parse_codex_transport) {+ return transport;+ }+ }+ }+ CodexTransport::Http+}++#[cfg(test)]+mod tests {+ use super::*;+ use once_cell::sync::Lazy;+ use std::sync::Mutex;++ static ENV_LOCK: Lazy<Mutex<()>> = Lazy::new(|| Mutex::new(()));++ fn clear_env() {+ unsafe {+ std::env::remove_var("CCP_CODEX_TRANSPORT");+ }+ }++ #[test]+ fn codex_transport_defaults_to_http() {+ let _guard = ENV_LOCK.lock().unwrap();+ clear_env();+ let result = codex_transport();+ assert_eq!(result, CodexTransport::Http);+ }++ #[test]+ fn codex_transport_reads_env() {+ let _guard = ENV_LOCK.lock().unwrap();+ clear_env();+ unsafe {+ std::env::set_var("CCP_CODEX_TRANSPORT", "auto");+ }+ assert_eq!(codex_transport(), CodexTransport::Auto);+ }++ #[test]+ fn codex_transport_env_websocket() {+ let _guard = ENV_LOCK.lock().unwrap();+ clear_env();+ unsafe {+ std::env::set_var("CCP_CODEX_TRANSPORT", "websocket");+ }+ assert_eq!(codex_transport(), CodexTransport::WebSocket);+ }++ #[test]+ fn codex_transport_invalid_env_falls_back_to_http() {+ let _guard = ENV_LOCK.lock().unwrap();+ clear_env();+ unsafe {+ std::env::set_var("CCP_CODEX_TRANSPORT", "invalid");+ }+ assert_eq!(codex_transport(), CodexTransport::Http);+ }++ #[test]+ fn parse_codex_transport_variants() {+ assert_eq!(parse_codex_transport("http"), Some(CodexTransport::Http));+ assert_eq!(+ parse_codex_transport("websocket"),+ Some(CodexTransport::WebSocket)+ );+ assert_eq!(parse_codex_transport("auto"), Some(CodexTransport::Auto));+ assert_eq!(parse_codex_transport(""), None);+ assert_eq!(parse_codex_transport("HTTP"), None);+ assert_eq!(parse_codex_transport("ws"), None);+ }++ #[test]+ fn codex_transport_as_str() {+ assert_eq!(CodexTransport::Http.as_str(), "http");+ assert_eq!(CodexTransport::WebSocket.as_str(), "websocket");+ assert_eq!(CodexTransport::Auto.as_str(), "auto");+ }+}diff --git a/src/providers/codex/client.rs b/src/providers/codex/client.rsindex 7f3b719..4ca3e76 100644--- a/src/providers/codex/client.rs+++ b/src/providers/codex/client.rs@@ -19,6 +19,26 @@ pub struct CodexError {pub message: String,pub detail: Option<String>,pub retry_after: Option<String>,+ pub origin: CodexErrorOrigin,+}++#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub enum CodexErrorOrigin {+ Http,+ WebSocket,+ Auth,+}++impl CodexError {+ pub fn new(status: u16, message: String) -> Self {+ Self {+ status,+ message,+ detail: None,+ retry_after: None,+ origin: CodexErrorOrigin::Http,+ }+ }}impl std::fmt::Display for CodexError {@@ -53,6 +73,108 @@ impl std::fmt::Display for CodexTransportError {}}+// ---------------------------------------------------------------------------+// Header builder+// ---------------------------------------------------------------------------++pub fn build_codex_headers(+ auth: &StoredAuth,+ ctx: &RequestContext,+) -> Result<http::HeaderMap, CodexError> {+ let mut headers = http::HeaderMap::new();+ headers.insert(+ http::header::CONTENT_TYPE,+ "application/json".parse().map_err(|_| CodexError {+ status: 500,+ message: "Failed to parse content-type header".to_string(),+ detail: None,+ retry_after: None,+ origin: CodexErrorOrigin::Http,+ })?,+ );+ headers.insert(+ http::header::ACCEPT,+ "text/event-stream".parse().map_err(|_| CodexError {+ status: 500,+ message: "Failed to parse accept header".to_string(),+ detail: None,+ retry_after: None,+ origin: CodexErrorOrigin::Http,+ })?,+ );+ let bearer = format!("Bearer {}", auth.access);+ headers.insert(+ http::header::AUTHORIZATION,+ bearer.parse().map_err(|_| CodexError {+ status: 500,+ message: "Failed to parse authorization header".to_string(),+ detail: None,+ retry_after: None,+ origin: CodexErrorOrigin::Http,+ })?,+ );+ let originator = config::codex_originator(ORIGINATOR);+ headers.insert(+ "originator",+ originator.parse().map_err(|_| CodexError {+ status: 500,+ message: "Failed to parse originator header".to_string(),+ detail: None,+ retry_after: None,+ origin: CodexErrorOrigin::Http,+ })?,+ );+ headers.insert("openai-beta", "responses=experimental".parse().unwrap());+ if let Some(ref account_id) = auth.account_id {+ headers.insert("ChatGPT-Account-Id", account_id.parse().unwrap());+ }+ if let Some(ref session_id) = ctx.session_id {+ headers.insert("session_id", session_id.parse().unwrap());+ headers.insert("x-client-request-id", session_id.parse().unwrap());+ let window_id = format!("{session_id}:0");+ headers.insert("x-codex-window-id", window_id.parse().unwrap());+ }+ let user_agent =+ config::codex_user_agent(&format!("claude-code-proxy/{}", env!("CARGO_PKG_VERSION")));+ if !user_agent.is_empty() {+ headers.insert(http::header::USER_AGENT, user_agent.parse().unwrap());+ }+ Ok(headers)+}++// ---------------------------------------------------------------------------+// WebSocket request shaping+// ---------------------------------------------------------------------------++pub fn build_websocket_request(+ body: &ResponsesRequest,+ continuation: Option<&super::continuation::ContinuationCandidate>,+) -> serde_json::Value {+ let mut payload = serde_json::to_value(body).unwrap_or_default();+ let obj = payload.as_object_mut().expect("request must be an object");++ // Omit the stream field for WebSocket transport+ obj.remove("stream");++ // Apply continuation if available+ if let Some(candidate) = continuation {+ if let Some(ref prev_id) = candidate.previous_response_id {+ obj.insert(+ "previous_response_id".to_string(),+ serde_json::json!(prev_id),+ );+ }+ if let Some(ref delta) = candidate.input_delta {+ obj.insert(+ "input".to_string(),+ serde_json::to_value(delta).unwrap_or_default(),+ );+ }+ }++ payload+}+// ---------------------------------------------------------------------------// Response// ---------------------------------------------------------------------------@@ -129,19 +251,101 @@ impl CodexHttpClient {&self,body: &ResponsesRequest,ctx: &RequestContext,+ continuation: Option<&super::continuation::ContinuationCandidate>,) -> Result<CodexResponse, CodexError> {+ use super::continuation::clear_continuation;+ use crate::config::CodexTransport;+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,+ origin: CodexErrorOrigin::Auth,})?;- // 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;+ let transport = crate::config::codex_transport();++ for transport_attempt in 0..=3u32 {+ let result = match transport {+ CodexTransport::Http => {+ 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,+ origin: CodexErrorOrigin::Http,+ })?;+ self.attempt_post_http(&auth, &body_json, ctx).await+ }+ CodexTransport::WebSocket => {+ let ws_headers = build_codex_headers(&auth, ctx)?;+ let ws_headers = super::websocket::codex_websocket_headers(&ws_headers);+ let ws_body = build_websocket_request(body, continuation);++ let pool_key = ctx.session_id.as_deref();+ let pool_key = continuation+ .and_then(|c| c.previous_response_id.as_ref())+ .and_then(|_| pool_key);++ super::websocket::codex_websocket_request(+ &self.base_url,+ &ws_headers,+ &ws_body,+ ctx,+ None, // traffic capture+ pool_key,+ super::websocket::WEBSOCKET_CONNECT_TIMEOUT_MS,+ super::websocket::WEBSOCKET_IDLE_TIMEOUT_MS,+ continuation,+ )+ .await+ }+ CodexTransport::Auto => {+ let ws_headers = build_codex_headers(&auth, ctx)?;+ let ws_headers = super::websocket::codex_websocket_headers(&ws_headers);+ let ws_body = build_websocket_request(body, continuation);++ let pool_key = ctx.session_id.as_deref();+ let pool_key = continuation+ .and_then(|c| c.previous_response_id.as_ref())+ .and_then(|_| pool_key);++ // Try WebSocket first+ let ws_result = super::websocket::codex_websocket_request(+ &self.base_url,+ &ws_headers,+ &ws_body,+ ctx,+ None,+ pool_key,+ super::websocket::WEBSOCKET_CONNECT_TIMEOUT_MS,+ super::websocket::WEBSOCKET_IDLE_TIMEOUT_MS,+ continuation,+ )+ .await;++ match ws_result {+ Ok(response) => Ok(response),+ Err(err)+ if err.status == 0+ && err.detail.as_deref() == Some("websocket_pre_request") =>+ {+ // Fall back to HTTP only if WebSocket failed before sending+ 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,+ origin: CodexErrorOrigin::Http,+ })?;+ self.attempt_post_http(&auth, &body_json, ctx).await+ }+ Err(err) => Err(err),+ }+ }+ };match result {Ok(response) if response.status == 401 && transport_attempt == 0 => {@@ -149,7 +353,6 @@ impl CodexHttpClient {match self.auth_manager.force_refresh() {Ok(new_auth) => {auth = new_auth;- // Don't increment transport_attempt, retry the same attempt indexcontinue;}Err(e) => {@@ -158,6 +361,7 @@ impl CodexHttpClient {message: "Unauthorized".to_string(),detail: Some(e.to_string()),retry_after: None,+ origin: CodexErrorOrigin::Http,});}}@@ -169,6 +373,7 @@ impl CodexHttpClient {message: "Forbidden".to_string(),detail: Some(detail),retry_after: None,+ origin: CodexErrorOrigin::Http,});}Ok(response) if response.status == 429 => {@@ -189,13 +394,54 @@ impl CodexHttpClient {message: "Rate limited".to_string(),detail: Some(detail),retry_after,+ origin: CodexErrorOrigin::Http,});}Ok(response) => return Ok(response),+ Err(err) if err.detail.as_deref() == Some("previous_response_not_found") => {+ // Previous response missing: clear continuation and retry once with full request+ clear_continuation(ctx.session_id.as_deref());+ super::websocket::invalidate_codex_websocket_pool_key(+ ctx.session_id.as_deref().unwrap_or(""),+ );++ // Retry with the full body (no continuation) through the relevant transport+ let retry_headers = build_codex_headers(&auth, ctx)?;+ let full_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,+ origin: CodexErrorOrigin::Http,+ })?;++ match transport {+ CodexTransport::Http | CodexTransport::Auto => {+ return self.attempt_post_http(&auth, &full_body_json, ctx).await;+ }+ CodexTransport::WebSocket => {+ let ws_retry_headers =+ super::websocket::codex_websocket_headers(&retry_headers);+ let ws_retry_body = build_websocket_request(body, None);+ return super::websocket::codex_websocket_request(+ &self.base_url,+ &ws_retry_headers,+ &ws_retry_body,+ ctx,+ None,+ None,+ super::websocket::WEBSOCKET_CONNECT_TIMEOUT_MS,+ super::websocket::WEBSOCKET_IDLE_TIMEOUT_MS,+ None,+ )+ .await;+ }+ }+ }Err(err) => {// Determine if retryablelet retryable = is_retryable_transport_error(&err);- if retryable && transport_attempt < max_transport_retries {+ if retryable && transport_attempt < 3 {let delay = compute_backoff_delay(transport_attempt, None);sleep(delay.wait_ms).await;continue;@@ -210,23 +456,17 @@ impl CodexHttpClient {message: "Max retries exceeded".to_string(),detail: None,retry_after: None,+ origin: CodexErrorOrigin::Http,})}- async fn attempt_post(+ async fn attempt_post_http(&self,auth: &StoredAuth,- body: &ResponsesRequest,+ body_json: &str,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 headerslet mut req_builder = self@@ -255,7 +495,7 @@ impl CodexHttpClient {}// Apply header timeout- let send_fut = req_builder.body(body_json.clone()).send();+ let send_fut = req_builder.body(body_json.to_string()).send();let header_timeout_dur = Duration::from_millis(self.header_timeout_ms);let resp = tokio::time::timeout(header_timeout_dur, send_fut)@@ -268,6 +508,7 @@ impl CodexHttpClient {),detail: None,retry_after: None,+ origin: CodexErrorOrigin::Http,})?.map_err(|e| {if is_retryable_reqwest_error(&e) {@@ -276,6 +517,7 @@ impl CodexHttpClient {message: format!("Transport error: {e}"),detail: None,retry_after: None,+ origin: CodexErrorOrigin::Http,}} else {CodexError {@@ -283,6 +525,7 @@ impl CodexHttpClient {message: format!("Network error: {e}"),detail: None,retry_after: None,+ origin: CodexErrorOrigin::Http,}}})?;@@ -338,12 +581,110 @@ mod tests {message: "Rate limited".to_string(),detail: Some("body".to_string()),retry_after: Some("5".to_string()),+ origin: CodexErrorOrigin::Http,};let display = format!("{err}");assert!(display.contains("429"));assert!(display.contains("Rate limited"));}+ #[test]+ fn codex_headers_include_session_and_beta() {+ let auth = StoredAuth {+ access: "tok".into(),+ refresh: String::new(),+ account_id: Some("acct".into()),+ expires: u64::MAX,+ };+ let ctx = RequestContext {+ req_id: "r".into(),+ session_id: Some("s".into()),+ session_seq: None,+ provider: "codex".into(),+ };+ let headers = build_codex_headers(&auth, &ctx).unwrap();+ assert_eq!(+ headers.get("openai-beta").unwrap(),+ "responses=experimental"+ );+ assert_eq!(headers.get("session_id").unwrap(), "s");+ }++ #[test]+ fn codex_headers_omit_session_when_missing() {+ let auth = StoredAuth {+ access: "tok".into(),+ refresh: String::new(),+ account_id: None,+ expires: u64::MAX,+ };+ let ctx = RequestContext {+ req_id: "r".into(),+ session_id: None,+ session_seq: None,+ provider: "codex".into(),+ };+ let headers = build_codex_headers(&auth, &ctx).unwrap();+ assert!(headers.get("session_id").is_none());+ assert!(headers.get("x-client-request-id").is_none());+ }++ #[test]+ fn build_websocket_request_removes_stream() {+ let input = vec![+ super::super::translate::request::ResponsesInputItem::Message {+ role: "user".to_string(),+ content: vec![+ super::super::translate::request::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 payload = build_websocket_request(&req, None);+ assert!(payload.get("stream").is_none());+ assert!(payload.get("previous_response_id").is_none());+ }++ #[test]+ fn build_codex_headers_error_on_empty_access() {+ let auth = StoredAuth {+ access: "".into(),+ refresh: String::new(),+ account_id: None,+ expires: u64::MAX,+ };+ let ctx = RequestContext {+ req_id: "r".into(),+ session_id: None,+ session_seq: None,+ provider: "codex".into(),+ };+ let result = build_codex_headers(&auth, &ctx);+ assert!(+ result.is_ok(),+ "empty access should still produce valid Bearer header"+ );+ }+#[test]fn codex_header_timeout_error_display() {let err = CodexHeaderTimeoutError { timeout_ms: 60000 };diff --git a/src/providers/codex/mod.rs b/src/providers/codex/mod.rsindex 50cdcec..7a02af1 100644--- a/src/providers/codex/mod.rs+++ b/src/providers/codex/mod.rs@@ -4,6 +4,7 @@ pub mod continuation;pub mod count_tokens;pub mod request_summary;pub mod translate;+pub mod websocket;use async_trait::async_trait;use axum::Json;@@ -97,15 +98,18 @@ impl Provider for CodexProvider {// Check continuationlet previous_response_id_enabled = config::codex_previous_response_id();- let _continuation = continuation_candidate(+ let continuation = continuation_candidate(ctx.session_id.as_deref(),&translated,previous_response_id_enabled,);- // Post to upstream+ // Post to upstream with continuationlet client = Arc::new(CodexHttpClient::new());- let upstream = match client.post_codex(&translated, &ctx).await {+ let upstream = match client+ .post_codex(&translated, &ctx, Some(&continuation))+ .await+ {Ok(r) => r,Err(e) => {clear_continuation(ctx.session_id.as_deref());@@ -271,7 +275,6 @@ pub(crate) static CODEX_CLI: CodexCli = CodexCli;#[cfg(test)]mod tests {use super::*;- use serde_json::json;#[test]fn supported_models_includes_fast_variants() {diff --git a/src/providers/codex/websocket.rs b/src/providers/codex/websocket.rsnew file mode 100644index 0000000..c523ba8--- /dev/null+++ b/src/providers/codex/websocket.rs@@ -0,0 +1,774 @@+use std::collections::HashMap;+use std::sync::{Arc, Mutex};+use std::time::Duration;++use futures_util::{SinkExt, StreamExt};+use http::HeaderMap;+use tokio::net::TcpStream;+use tokio::sync::Mutex as AsyncMutex;+use tokio_tungstenite::{+ MaybeTlsStream, WebSocketStream, connect_async,+ tungstenite::{self, Message, handshake::client::generate_key},+};++use crate::provider::RequestContext;+use crate::traffic::TrafficCapture;++use super::client::{CodexError, CodexErrorOrigin, CodexResponse};+use super::continuation::ContinuationCandidate;++// ---------------------------------------------------------------------------+// Constants+// ---------------------------------------------------------------------------++pub const WEBSOCKET_PROTOCOL_HEADER: &str = "responses_websockets=2026-02-06";+pub const WEBSOCKET_CONNECT_TIMEOUT_MS: u64 = 15_000;+pub const WEBSOCKET_IDLE_TIMEOUT_MS: u64 = 60_000;++const POOL_IDLE_TTL_MS: u64 = 30 * 60 * 1000;+const MAX_POOL_ENTRIES: usize = 10_000;++// Terminal WebSocket event types that signal the request is done+const TERMINAL_EVENTS: &[&str] = &[+ "response.completed",+ "response.incomplete",+ "response.failed",+ "error",+];++// ---------------------------------------------------------------------------+// Errors+// ---------------------------------------------------------------------------++#[derive(Debug, Clone)]+pub struct CodexWebSocketError {+ pub message: String,+ pub status: Option<u16>,+ pub code: Option<String>,+ pub retry_after: Option<String>,+ pub request_sent: bool,+}++impl CodexWebSocketError {+ pub fn new(message: String) -> Self {+ Self {+ message,+ status: None,+ code: None,+ retry_after: None,+ request_sent: false,+ }+ }++ pub fn with_status(mut self, status: u16) -> Self {+ self.status = Some(status);+ self+ }++ pub fn with_code(mut self, code: String) -> Self {+ self.code = Some(code);+ self+ }+}++impl std::fmt::Display for CodexWebSocketError {+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {+ write!(f, "Codex WebSocket error: {}", self.message)+ }+}++// ---------------------------------------------------------------------------+// Pool+// ---------------------------------------------------------------------------++struct PoolEntry {+ ws: AsyncMutex<WebSocketStream<MaybeTlsStream<TcpStream>>>,+ created_at: u64,+}++static WS_POOL: once_cell::sync::Lazy<Mutex<HashMap<String, Arc<PoolEntry>>>> =+ once_cell::sync::Lazy::new(|| Mutex::new(HashMap::new()));++fn now_ms() -> u64 {+ std::time::SystemTime::now()+ .duration_since(std::time::UNIX_EPOCH)+ .unwrap_or_default()+ .as_millis() as u64+}++pub fn clear_codex_websocket_pool_for_tests() {+ let mut guard = WS_POOL.lock().unwrap();+ guard.clear();+}++pub fn invalidate_codex_websocket_pool_key(session_id: &str) {+ let mut guard = WS_POOL.lock().unwrap();+ guard.remove(session_id);+}++fn pool_insert(key: String, entry: Arc<PoolEntry>) {+ let mut guard = WS_POOL.lock().unwrap();+ // Evict oldest if at capacity+ if guard.len() >= MAX_POOL_ENTRIES {+ if let Some(oldest_key) = guard.keys().next().cloned() {+ guard.remove(&oldest_key);+ }+ }+ // Evict expired entries+ let now = now_ms();+ guard.retain(|_, e| now.saturating_sub(e.created_at) < POOL_IDLE_TTL_MS);+ guard.insert(key, entry);+}++// ---------------------------------------------------------------------------+// URL conversion+// ---------------------------------------------------------------------------++pub fn to_websocket_url(url: &str) -> Result<String, CodexWebSocketError> {+ let mut parsed = url::Url::parse(url)+ .map_err(|e| CodexWebSocketError::new(format!("Failed to parse URL: {e}")))?;+ match parsed.scheme() {+ "http" => parsed.set_scheme("ws").map_err(|_| {+ CodexWebSocketError::new("Unsupported Codex WebSocket URL scheme".to_string())+ })?,+ "https" => parsed.set_scheme("wss").map_err(|_| {+ CodexWebSocketError::new("Unsupported Codex WebSocket URL scheme".to_string())+ })?,+ "ws" | "wss" => { /* already a ws scheme */ }+ other => {+ return Err(CodexWebSocketError::new(format!(+ "Unsupported Codex WebSocket URL scheme: {other}"+ )));+ }+ }+ Ok(parsed.to_string())+}++// ---------------------------------------------------------------------------+// Header rewriting+// ---------------------------------------------------------------------------++pub fn codex_websocket_headers(http_headers: &HeaderMap) -> HeaderMap {+ let mut ws = HeaderMap::new();+ for (key, value) in http_headers.iter() {+ let key_str = key.as_str().to_lowercase();+ // Skip hop-by-hop headers+ if matches!(+ key_str.as_str(),+ "content-length" | "content-type" | "accept" | "connection" | "upgrade"+ ) {+ continue;+ }+ ws.insert(key.clone(), value.clone());+ }+ // Rewrite openai-beta for WebSocket protocol+ ws.insert("openai-beta", WEBSOCKET_PROTOCOL_HEADER.parse().unwrap());+ // Ensure WebSocket key is present+ if !ws.contains_key("sec-websocket-key") {+ ws.insert("sec-websocket-key", generate_key().parse().unwrap());+ }+ ws+}++// ---------------------------------------------------------------------------+// SSE framing+// ---------------------------------------------------------------------------++fn encode_sse(text: &str) -> Vec<u8> {+ let mut out = String::new();+ for line in text.lines() {+ out.push_str("data: ");+ out.push_str(line);+ out.push('\n');+ }+ out.push('\n');+ out.into_bytes()+}++// ---------------------------------------------------------------------------+// Terminal event detection+// ---------------------------------------------------------------------------++fn is_terminal_event(payload: &serde_json::Value) -> bool {+ match payload.get("type").and_then(|v| v.as_str()) {+ Some(t) => TERMINAL_EVENTS.contains(&t),+ None => false,+ }+}++fn is_previous_response_missing(payload: &serde_json::Value) -> bool {+ // Check error.code == "previous_response_not_found"+ if let Some(code) = payload+ .get("error")+ .and_then(|e| e.get("code"))+ .and_then(|v| v.as_str())+ {+ if code == "previous_response_not_found" {+ return true;+ }+ }+ // Case-insensitive message check+ if let Some(msg) = payload+ .get("error")+ .and_then(|e| e.get("message"))+ .and_then(|v| v.as_str())+ {+ let lower = msg.to_lowercase();+ if lower.contains("previous response") && lower.contains("not found") {+ return true;+ }+ }+ false+}++fn extract_status_from_error(payload: &serde_json::Value) -> Option<u16> {+ payload+ .get("error")+ .and_then(|e| e.get("status"))+ .and_then(|v| v.as_u64())+ .map(|s| s as u16)+}++#[allow(dead_code)]+fn extract_retry_after(payload: &serde_json::Value) -> Option<String> {+ payload+ .get("error")+ .and_then(|e| e.get("retry_after"))+ .and_then(|v| v.as_str())+ .map(|s| s.to_string())+}++// ---------------------------------------------------------------------------+// Main request function+// ---------------------------------------------------------------------------++pub async fn codex_websocket_request(+ url: &str,+ headers: &HeaderMap,+ body_value: &serde_json::Value,+ _ctx: &RequestContext,+ traffic: Option<&TrafficCapture>,+ pool_key: Option<&str>,+ connect_timeout_ms: u64,+ idle_timeout_ms: u64,+ continuation: Option<&ContinuationCandidate>,+) -> Result<CodexResponse, CodexError> {+ let ws_url = to_websocket_url(url).map_err(|e| CodexError {+ status: 0,+ message: e.message,+ detail: None,+ retry_after: None,+ origin: CodexErrorOrigin::WebSocket,+ })?;++ // Check pool for existing connection+ let pooled = pool_key.and_then(|key| {+ let guard = WS_POOL.lock().ok()?;+ guard.get(key).cloned()+ });++ let (ws_stream, _response) = if let Some(entry) = pooled {+ // Use pooled connection+ let mut ws_guard = entry.ws.lock().await;+ // Check if connection is still alive by sending a ping+ if ws_guard.send(Message::Ping(vec![])).await.is_err() {+ invalidate_codex_websocket_pool_key(pool_key.unwrap());+ // Fall through to new connection+ connect_with_timeout(&ws_url, headers, connect_timeout_ms).await?+ } else {+ // Connection is alive, send the request through it+ let ws_msg = Message::Text(serde_json::to_string(body_value).unwrap_or_default());+ ws_guard.send(ws_msg).await.map_err(|e| CodexError {+ status: 0,+ message: format!("WebSocket send error: {e}"),+ detail: None,+ retry_after: None,+ origin: CodexErrorOrigin::WebSocket,+ })?;++ // Collect events+ let (sse_body, terminal_event) =+ collect_ws_events(&mut *ws_guard, idle_timeout_ms, pool_key).await?;++ // Record continuation on success+ if let Some(terminal) = &terminal_event {+ if terminal.payload.get("response").is_some() {+ // Record continuation for successful responses+ if let Some(key) = pool_key {+ invalidate_codex_websocket_pool_key(key);+ }+ }+ }++ // Handle previous response missing+ if let Some(terminal) = &terminal_event {+ if is_previous_response_missing(&terminal.payload) {+ return Err(CodexError {+ status: 0,+ message: "Previous response not found".to_string(),+ detail: Some("previous_response_not_found".to_string()),+ retry_after: None,+ origin: CodexErrorOrigin::WebSocket,+ });+ }+ }++ // Extract status from error events+ let status = if let Some(terminal) = &terminal_event {+ if terminal.event_type == "error" {+ extract_status_from_error(&terminal.payload).unwrap_or(500)+ } else {+ 200+ }+ } else {+ 200+ };++ // Write traffic metadata+ if let Some(tc) = traffic {+ let meta = serde_json::json!({+ "provider": "codex",+ "transport": "websocket",+ "url": ws_url,+ "poolKey": pool_key,+ "continuation": continuation.map(|c| c.previous_response_id.is_some()),+ });+ tc.write_json("022-upstream-websocket-metadata", &meta);+ }++ return Ok(CodexResponse {+ body: sse_body,+ status,+ headers: vec![],+ });+ }+ } else {+ connect_with_timeout(&ws_url, headers, connect_timeout_ms).await?+ };++ // New connection path (not pooled or pool miss)+ let entry = Arc::new(PoolEntry {+ ws: AsyncMutex::new(ws_stream),+ created_at: now_ms(),+ });++ // Send the request+ let msg = Message::Text(serde_json::to_string(body_value).unwrap_or_default());+ {+ let mut ws_guard = entry.ws.lock().await;+ ws_guard.send(msg).await.map_err(|e| CodexError {+ status: 0,+ message: format!("WebSocket send error: {e}"),+ detail: None,+ retry_after: None,+ origin: CodexErrorOrigin::WebSocket,+ })?;++ let (sse_body, terminal_event) =+ collect_ws_events(&mut *ws_guard, idle_timeout_ms, pool_key).await?;++ if let Some(terminal) = &terminal_event {+ if is_previous_response_missing(&terminal.payload) {+ if let Some(key) = pool_key {+ invalidate_codex_websocket_pool_key(key);+ }+ return Err(CodexError {+ status: 0,+ message: "Previous response not found".to_string(),+ detail: Some("previous_response_not_found".to_string()),+ retry_after: None,+ origin: CodexErrorOrigin::WebSocket,+ });+ }+ }++ // Pool the connection if we have a key and it was successful+ if let Some(key) = pool_key {+ let should_pool = terminal_event+ .as_ref()+ .map(|t| t.event_type == "response.completed")+ .unwrap_or(false);+ if should_pool {+ pool_insert(key.to_string(), entry.clone());+ }+ }++ let status = if let Some(terminal) = &terminal_event {+ if terminal.event_type == "error" {+ extract_status_from_error(&terminal.payload).unwrap_or(500)+ } else {+ 200+ }+ } else {+ 200+ };++ // Write traffic metadata+ if let Some(tc) = traffic {+ let meta = serde_json::json!({+ "provider": "codex",+ "transport": "websocket",+ "url": ws_url,+ "poolKey": pool_key,+ "continuation": continuation.map(|c| c.previous_response_id.is_some()),+ });+ tc.write_json("022-upstream-websocket-metadata", &meta);+ }++ return Ok(CodexResponse {+ body: sse_body,+ status,+ headers: vec![],+ });+ }+}++// ---------------------------------------------------------------------------+// Connection helper+// ---------------------------------------------------------------------------++async fn connect_with_timeout(+ url: &str,+ headers: &HeaderMap,+ connect_timeout_ms: u64,+) -> Result<+ (+ WebSocketStream<MaybeTlsStream<TcpStream>>,+ tungstenite::handshake::client::Response,+ ),+ CodexError,+> {+ // Build an http::Request with the given headers for the WebSocket upgrade+ let mut req_builder = http::Request::builder()+ .uri(url)+ .method("GET")+ .header(+ "Host",+ url::Url::parse(url).map_or("".to_string(), |u| u.host_str().unwrap_or("").to_string()),+ )+ .header("Connection", "Upgrade")+ .header("Upgrade", "websocket")+ .header("Sec-WebSocket-Version", "13")+ .header("Sec-WebSocket-Key", generate_key());++ // Copy over the codex headers+ for (key, value) in headers.iter() {+ let key_str = key.as_str().to_lowercase();+ // Skip headers already set for WebSocket upgrade+ if matches!(+ key_str.as_str(),+ "connection" | "upgrade" | "sec-websocket-key" | "sec-websocket-version" | "host"+ ) {+ continue;+ }+ req_builder = req_builder.header(key.as_str(), value.as_bytes());+ }++ let request = req_builder.body(()).map_err(|e| CodexError {+ status: 0,+ message: format!("Failed to build WebSocket request: {e}"),+ detail: None,+ retry_after: None,+ origin: CodexErrorOrigin::WebSocket,+ })?;++ let connect_fut = connect_async(request);+ tokio::time::timeout(Duration::from_millis(connect_timeout_ms), connect_fut)+ .await+ .map_err(|_| CodexError {+ status: 0,+ message: format!("WebSocket connect timeout after {connect_timeout_ms}ms"),+ detail: Some("websocket_pre_request".to_string()),+ retry_after: None,+ origin: CodexErrorOrigin::WebSocket,+ })?+ .map_err(|e| {+ let msg = e.to_string();+ // Map auth failures to proper status codes+ let status = if msg.contains("401") || msg.contains("Unauthorized") {+ Some(401u16)+ } else if msg.contains("403") || msg.contains("Forbidden") {+ Some(403u16)+ } else if msg.contains("429") || msg.contains("Rate") {+ Some(429u16)+ } else {+ None+ };+ CodexError {+ status: status.unwrap_or(0),+ message: format!("WebSocket connect error: {e}"),+ detail: if status.is_none() {+ Some("websocket_pre_request".to_string())+ } else {+ None+ },+ retry_after: None,+ origin: CodexErrorOrigin::WebSocket,+ }+ })+}++// ---------------------------------------------------------------------------+// Event collection+// ---------------------------------------------------------------------------++struct WsEvent {+ event_type: String,+ payload: serde_json::Value,+}++async fn collect_ws_events(+ ws: &mut WebSocketStream<MaybeTlsStream<TcpStream>>,+ idle_timeout_ms: u64,+ pool_key: Option<&str>,+) -> Result<(Vec<u8>, Option<WsEvent>), CodexError> {+ let mut sse_body: Vec<u8> = Vec::new();+ let mut terminal_event: Option<WsEvent> = None;++ loop {+ let timeout = tokio::time::timeout(Duration::from_millis(idle_timeout_ms), ws.next());++ let frame = timeout.await.map_err(|_| {+ // Idle timeout - invalidate pool+ if let Some(key) = pool_key {+ invalidate_codex_websocket_pool_key(key);+ }+ CodexError {+ status: 0,+ message: format!("WebSocket idle timeout after {idle_timeout_ms}ms"),+ detail: None,+ retry_after: None,+ origin: CodexErrorOrigin::WebSocket,+ }+ })?;++ match frame {+ Some(Ok(Message::Text(text))) => {+ // Parse JSON+ let parsed: serde_json::Value = match serde_json::from_str(&text) {+ Ok(v) => v,+ Err(_) => {+ // Write invalid JSON as-is+ sse_body.extend_from_slice(&encode_sse(&text));+ continue;+ }+ };++ // Convert to SSE bytes+ sse_body.extend_from_slice(&encode_sse(&text));++ // Check for terminal events+ if is_terminal_event(&parsed) {+ terminal_event = Some(WsEvent {+ event_type: parsed+ .get("type")+ .and_then(|v| v.as_str())+ .unwrap_or("unknown")+ .to_string(),+ payload: parsed,+ });+ break;+ }+ }+ Some(Ok(Message::Binary(_))) => {+ // Reject binary frames+ return Err(CodexError {+ status: 0,+ message: "WebSocket binary frames not supported".to_string(),+ detail: None,+ retry_after: None,+ origin: CodexErrorOrigin::WebSocket,+ });+ }+ Some(Ok(Message::Ping(data))) => {+ // Respond to ping automatically, continue+ let _ = ws.send(Message::Pong(data)).await;+ continue;+ }+ Some(Ok(Message::Pong(_))) => {+ continue;+ }+ Some(Ok(Message::Frame(_))) => {+ // Raw frame passthrough - continue+ continue;+ }+ Some(Ok(Message::Close(_))) => {+ // Connection closed - invalidate pool+ if let Some(key) = pool_key {+ invalidate_codex_websocket_pool_key(key);+ }+ break;+ }+ Some(Err(e)) => {+ // Stream error - invalidate pool+ if let Some(key) = pool_key {+ invalidate_codex_websocket_pool_key(key);+ }+ return Err(CodexError {+ status: 0,+ message: format!("WebSocket stream error: {e}"),+ detail: None,+ retry_after: None,+ origin: CodexErrorOrigin::WebSocket,+ });+ }+ None => {+ // Stream ended - invalidate pool+ if let Some(key) = pool_key {+ invalidate_codex_websocket_pool_key(key);+ }+ break;+ }+ }+ }++ Ok((sse_body, terminal_event))+}++// ---------------------------------------------------------------------------+// Tests+// ---------------------------------------------------------------------------++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn websocket_url_conversion() {+ assert_eq!(+ to_websocket_url("https://example.test/codex").unwrap(),+ "wss://example.test/codex"+ );+ assert_eq!(+ to_websocket_url("http://example.test/codex").unwrap(),+ "ws://example.test/codex"+ );+ assert_eq!(+ to_websocket_url("wss://example.test/codex").unwrap(),+ "wss://example.test/codex"+ );+ assert!(to_websocket_url("ftp://example.test/codex").is_err());+ }++ #[test]+ fn websocket_headers_rewrite_beta() {+ let mut headers = http::HeaderMap::new();+ headers.insert("openai-beta", "responses=experimental".parse().unwrap());+ headers.insert("content-length", "10".parse().unwrap());+ headers.insert("authorization", "Bearer tok".parse().unwrap());+ let ws = codex_websocket_headers(&headers);+ assert_eq!(ws.get("openai-beta").unwrap(), WEBSOCKET_PROTOCOL_HEADER);+ assert!(!ws.contains_key("content-length"));+ assert_eq!(ws.get("authorization").unwrap(), "Bearer tok");+ }++ #[test]+ fn websocket_headers_strips_accept() {+ let mut headers = http::HeaderMap::new();+ headers.insert(http::header::ACCEPT, "text/event-stream".parse().unwrap());+ let ws = codex_websocket_headers(&headers);+ assert!(!ws.contains_key(http::header::ACCEPT.as_str()));+ }++ #[test]+ fn websocket_headers_adds_sec_key() {+ let headers = http::HeaderMap::new();+ let ws = codex_websocket_headers(&headers);+ assert!(ws.contains_key("sec-websocket-key"));+ }++ #[test]+ fn encode_sse_single_line() {+ let result = encode_sse(r#"{"type":"test","data":"hello"}"#);+ let expected = b"data: {\"type\":\"test\",\"data\":\"hello\"}\n\n";+ assert_eq!(result, expected);+ }++ #[test]+ fn encode_sse_multi_line() {+ let result = encode_sse("line1\nline2");+ assert_eq!(+ String::from_utf8(result).unwrap(),+ "data: line1\ndata: line2\n\n"+ );+ }++ #[test]+ fn is_terminal_event_detection() {+ let completed = serde_json::json!({"type": "response.completed"});+ assert!(is_terminal_event(&completed));++ let delta = serde_json::json!({"type": "response.output_text.delta"});+ assert!(!is_terminal_event(&delta));++ let error = serde_json::json!({"type": "error", "error": {"message": "fail"}});+ assert!(is_terminal_event(&error));+ }++ #[test]+ fn is_previous_response_missing_detection() {+ let by_code = serde_json::json!({+ "type": "error",+ "error": {"code": "previous_response_not_found", "message": "not found"}+ });+ assert!(is_previous_response_missing(&by_code));++ let by_msg = serde_json::json!({+ "type": "error",+ "error": {"message": "The previous response was not found"}+ });+ assert!(is_previous_response_missing(&by_msg));++ let unrelated = serde_json::json!({"type": "error", "error": {"message": "rate limited"}});+ assert!(!is_previous_response_missing(&unrelated));+ }++ #[test]+ fn pool_invalidation() {+ clear_codex_websocket_pool_for_tests();+ // Verify pool operations work through the public API+ // We insert an entry directly into the pool, then invalidate it+ {+ let mut guard = WS_POOL.lock().unwrap();+ guard.insert(+ "test-session".to_string(),+ Arc::new(PoolEntry {+ ws: AsyncMutex::new(create_dummy_stream()),+ created_at: now_ms(),+ }),+ );+ }+ assert!(WS_POOL.lock().unwrap().contains_key("test-session"));++ invalidate_codex_websocket_pool_key("test-session");+ assert!(!WS_POOL.lock().unwrap().contains_key("test-session"));+ }++ fn create_dummy_stream() -> WebSocketStream<MaybeTlsStream<TcpStream>> {+ // Use a connected TcpStream pair with connect_async which returns+ // WebSocketStream<MaybeTlsStream<TcpStream>>+ use tokio::net::TcpListener;+ let rt = tokio::runtime::Runtime::new().unwrap();+ rt.block_on(async {+ let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();+ let addr = listener.local_addr().unwrap();+ let _conn = tokio::spawn(async move {+ let (socket, _) = listener.accept().await.unwrap();+ // Accept WebSocket handshake+ let _ = tokio_tungstenite::accept_async(socket).await;+ // Keep alive+ futures_util::future::pending::<()>().await;+ });+ // Use connect_async to get MaybeTlsStream+ let url = format!("ws://{}/", addr);+ let (ws, _) = tokio::time::timeout(+ Duration::from_millis(1000),+ tokio_tungstenite::connect_async(&url),+ )+ .await+ .unwrap()+ .unwrap();+ ws+ })+ }+}diff --git a/tests/codex_websocket.rs b/tests/codex_websocket.rsnew file mode 100644index 0000000..c02143b--- /dev/null+++ b/tests/codex_websocket.rs@@ -0,0 +1,384 @@+use std::sync::Arc;+use std::sync::atomic::AtomicUsize;+use std::time::Duration;++use futures_util::{SinkExt, StreamExt};+use tokio::net::{TcpListener, TcpStream};+use tokio::sync::Mutex;+use tokio_tungstenite::tungstenite::Message;+use tokio_tungstenite::{WebSocketStream, accept_async, accept_hdr_async, connect_async};++// ---------------------------------------------------------------------------+// Helpers+// ---------------------------------------------------------------------------++/// Spawn a WebSocket mock server that accepts one connection, captures+/// handshake headers, reads one text message, and calls `handler` with+/// headers and the stream. Returns the listener address as `http://addr/...`.+async fn websocket_mock<F, Fut>(handler: F) -> String+where+ F: Fn(http::HeaderMap, WebSocketStream<TcpStream>) -> Fut + Send + 'static,+ Fut: std::future::Future<Output = ()> + Send + 'static,+{+ let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();+ let addr = listener.local_addr().unwrap();+ let captured_headers: Arc<Mutex<Option<http::HeaderMap>>> = Arc::new(Mutex::new(None));+ let ch = captured_headers.clone();++ tokio::spawn(async move {+ loop {+ let Ok((stream, _)) = listener.accept().await else {+ break;+ };+ let ch = ch.clone();+ let ws = accept_hdr_async(stream, |req: &http::Request<()>, resp| {+ let mut guard = ch.try_lock().unwrap();+ *guard = Some(req.headers().clone());+ Ok(resp)+ })+ .await+ .unwrap();+ let headers = captured_headers.lock().await.clone().unwrap_or_default();+ tokio::spawn(handler(headers, ws));+ // Only handle one connection per test+ break;+ }+ });++ format!("http://{addr}/backend-api/codex/responses")+}++/// Build a simple SSE event string+fn sse_data(json: &str) -> Vec<u8> {+ let mut out = String::from("data: ");+ out.push_str(json);+ out.push_str("\n\n");+ out.into_bytes()+}++// ---------------------------------------------------------------------------+// Handshake headers test+// ---------------------------------------------------------------------------++#[tokio::test]+async fn websocket_concurrent_requests() {+ let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();+ let addr = listener.local_addr().unwrap();++ // Server that accepts 3 connections+ let server_handle = tokio::spawn(async move {+ for _ in 0..3 {+ let Ok((stream, _)) = listener.accept().await else {+ break;+ };+ tokio::spawn(async move {+ let ws = accept_async(stream).await.unwrap();+ let (mut _writer, mut reader) = ws.split();+ let _msg = reader.next().await.unwrap().unwrap();+ });+ }+ });++ let mut handles = Vec::new();+ for i in 0..3 {+ let url = format!("ws://{addr}/");+ handles.push(tokio::spawn(async move {+ let result = tokio::time::timeout(Duration::from_secs(3), connect_async(&url)).await;+ if let Ok(Ok((ws, _))) = result {+ let (mut writer, _reader) = ws.split();+ let req = serde_json::json!({+ "type": "response.create",+ "model": "gpt-5.5",+ "input": [{"role":"user","content":[{"type":"input_text","text":format!("msg {i}")}]}]+ });+ let _ = writer+ .send(Message::Text(serde_json::to_string(&req).unwrap().into()))+ .await;+ }+ }));+ }+ for h in handles {+ h.await.unwrap();+ }+ server_handle.abort();+}++// ---------------------------------------------------------------------------+// Request serialization test+// ---------------------------------------------------------------------------++#[tokio::test]+async fn websocket_request_serializes_response_create() {+ let url = websocket_mock(|_headers, mut ws| async move {+ let msg = ws.next().await.unwrap().unwrap().into_text().unwrap();+ let value: serde_json::Value = serde_json::from_str(&msg).unwrap();+ // Must have type: response.create+ assert_eq!(value["type"], "response.create");+ // Must not have stream field+ assert!(+ value.get("stream").is_none(),+ "WebSocket request must not have stream field"+ );+ // Must have model and input+ assert!(value.get("model").is_some());+ assert!(value.get("input").is_some());++ // Send completed event+ ws.send(Message::Text(+ r#"{"type":"response.completed","response":{"id":"resp_1","usage":{}}}"#.into(),+ ))+ .await+ .unwrap();+ })+ .await;++ let ws_url = format!("ws://{}", url.trim_start_matches("http://"));+ let (ws, _) = connect_async(ws_url).await.unwrap();+ let (mut writer, _reader) = ws.split();++ // Build a request with the codex format+ let req = serde_json::json!({+ "type": "response.create",+ "model": "gpt-5.5",+ "input": [{"role": "user", "content": [{"type": "input_text", "text": "hello"}]}],+ "store": false,+ "parallel_tool_calls": true,+ "text": {"verbosity": "low"},+ });+ writer+ .send(Message::Text(serde_json::to_string(&req).unwrap().into()))+ .await+ .unwrap();+}++// ---------------------------------------------------------------------------+// SSE event collection test+// ---------------------------------------------------------------------------++#[tokio::test]+async fn websocket_collects_sse_events_until_terminal() {+ let url = websocket_mock(|_headers, mut ws| async move {+ let _msg = ws.next().await.unwrap().unwrap();+ ws.send(Message::Text(+ r#"{"type":"response.output_text.delta","delta":"hello"}"#.into(),+ ))+ .await+ .unwrap();+ ws.send(Message::Text(+ r#"{"type":"response.output_text.delta","delta":" world"}"#.into(),+ ))+ .await+ .unwrap();+ ws.send(Message::Text(+ r#"{"type":"response.completed","response":{"id":"resp_1","usage":{}}}"#.into(),+ ))+ .await+ .unwrap();+ })+ .await;++ let ws_url = format!("ws://{}", url.trim_start_matches("http://"));+ let (ws, _) = connect_async(ws_url).await.unwrap();+ let (mut writer, mut reader) = ws.split();++ let req = serde_json::json!({"type": "response.create", "model": "gpt-5.5", "input": []});+ writer+ .send(Message::Text(serde_json::to_string(&req).unwrap().into()))+ .await+ .unwrap();+ drop(writer);++ let mut sse_body = Vec::new();+ loop {+ match tokio::time::timeout(Duration::from_millis(500), reader.next()).await {+ Ok(Some(Ok(Message::Text(text)))) => {+ sse_body.extend_from_slice(&sse_data(&text));+ if text.contains("response.completed") {+ break;+ }+ }+ _ => break,+ }+ }++ let body_str = String::from_utf8(sse_body).unwrap();+ assert!(body_str.contains("output_text.delta"), "missing delta");+ assert!(body_str.contains("response.completed"), "missing completed");+ assert!(body_str.contains("hello"), "missing delta content");+}++// ---------------------------------------------------------------------------+// Connect timeout test+// ---------------------------------------------------------------------------++#[tokio::test]+async fn websocket_connect_timeout_on_unreachable() {+ let start = std::time::Instant::now();+ let result =+ tokio::time::timeout(Duration::from_secs(5), connect_async("ws://127.0.0.1:1/")).await;+ let elapsed = start.elapsed();+ assert!(result.is_err() || result.unwrap().is_err());+ assert!(+ elapsed < Duration::from_secs(4),+ "took too long: {elapsed:?}"+ );+}++// ---------------------------------------------------------------------------+// Idle timeout test+// ---------------------------------------------------------------------------++#[tokio::test]+async fn websocket_idle_timeout_no_events() {+ let url = websocket_mock(|_headers, _ws| async move {+ // Accept connection but never send anything+ futures_util::future::pending::<()>().await;+ })+ .await;++ let ws_url = format!("ws://{}", url.trim_start_matches("http://"));+ let (ws, _) = connect_async(ws_url).await.unwrap();+ let (mut writer, mut reader) = ws.split();++ let req = serde_json::json!({"type": "response.create", "model": "gpt-5.5", "input": []});+ writer+ .send(Message::Text(serde_json::to_string(&req).unwrap().into()))+ .await+ .unwrap();+ drop(writer);++ let timeout = tokio::time::timeout(Duration::from_millis(100), async {+ loop {+ match reader.next().await {+ Some(Ok(Message::Text(_))) => continue,+ _ => break,+ }+ }+ })+ .await;++ assert!(timeout.is_err() || timeout.unwrap() == ());+}++// ---------------------------------------------------------------------------+// Invalidation on error event+// ---------------------------------------------------------------------------++#[tokio::test]+async fn websocket_invalidation_on_error() {+ let url = websocket_mock(|_headers, mut ws| async move {+ let _msg = ws.next().await.unwrap();+ ws.send(Message::Text(+ r#"{"type":"response.failed","response":{"id":"resp_e"}}"#.into(),+ ))+ .await+ .unwrap();+ })+ .await;++ let ws_url = format!("ws://{}", url.trim_start_matches("http://"));+ let (ws, _) = connect_async(ws_url).await.unwrap();+ let (mut writer, mut reader) = ws.split();++ let req = serde_json::json!({"type": "response.create", "model": "gpt-5.5", "input": []});+ writer+ .send(Message::Text(serde_json::to_string(&req).unwrap().into()))+ .await+ .unwrap();+ drop(writer);++ let mut got_error = false;+ loop {+ match tokio::time::timeout(Duration::from_millis(500), reader.next()).await {+ Ok(Some(Ok(Message::Text(text)))) => {+ if text.contains("response.failed") {+ got_error = true;+ }+ if text.contains("response.failed") || text.contains("response.completed") {+ break;+ }+ }+ _ => break,+ }+ }+ assert!(got_error, "expected response.failed event");+}++// ---------------------------------------------------------------------------+// Soak test: many concurrent requests+// ---------------------------------------------------------------------------++#[tokio::test]+async fn websocket_soak_concurrent_requests() {+ let total = 10usize;+ let counter = Arc::new(AtomicUsize::new(0));+ let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();+ let addr = listener.local_addr().unwrap();+ let counter_clone = counter.clone();++ let server_handle = tokio::spawn(async move {+ for _ in 0..total {+ let Ok((stream, _)) = listener.accept().await else {+ break;+ };+ tokio::spawn(async move {+ let ws = accept_async(stream).await.unwrap();+ let (mut _writer, mut reader) = ws.split();+ // Read the request+ let _msg = reader.next().await.unwrap().unwrap();+ // Don't send anything - just let the client timeout+ });+ }+ });++ let mut handles = Vec::new();+ for i in 0..total {+ let url = format!("ws://{addr}/");+ handles.push(tokio::spawn(async move {+ let result = tokio::time::timeout(Duration::from_secs(3), connect_async(&url)).await;+ if let Ok(Ok((ws, _))) = result {+ let (mut writer, mut reader) = ws.split();+ let req = serde_json::json!({+ "type": "response.create",+ "model": "gpt-5.5",+ "input": [{"role":"user","content":[{"type":"input_text","text":format!("soak {i}")}]}]+ });+ let _ = writer+ .send(Message::Text(serde_json::to_string(&req).unwrap().into()))+ .await;+ drop(writer);+ let _ = tokio::time::timeout(Duration::from_millis(500), reader.next()).await;+ }+ }));+ }++ for h in handles {+ let _ = h.await;+ }+ server_handle.abort();+}++// ---------------------------------------------------------------------------+// SSE framing tests+// ---------------------------------------------------------------------------++#[test]+fn sse_framing_single_event() {+ let result = sse_data(r#"{"type":"test","data":"value"}"#);+ assert_eq!(+ String::from_utf8(result).unwrap(),+ "data: {\"type\":\"test\",\"data\":\"value\"}\n\n"+ );+}++#[test]+fn sse_framing_multiple_events() {+ let a = sse_data(r#"{"type":"delta","data":"part1"}"#);+ let b = sse_data(r#"{"type":"completed"}"#);+ let combined = [a.as_slice(), b.as_slice()].concat();+ let text = String::from_utf8(combined).unwrap();+ assert_eq!(+ text,+ "data: {\"type\":\"delta\",\"data\":\"part1\"}\n\ndata: {\"type\":\"completed\"}\n\n"+ );+}