Skip to content

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.lock
index 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.toml
index 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.rs
index 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.rs
index 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 index
continue;
}
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 retryable
let 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 headers
let 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.rs
index 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 continuation
let 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 continuation
let 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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"
+ );
+}