Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy
Rust
fall back after Codex WebSocket handshake failures
Brock Tice3de4cf02d537
diff --git a/README.md b/README.mdindex e7dccaf..96ecea8 100644--- a/README.md+++ b/README.md@@ -713,7 +713,7 @@ Windows, and at| `CCP_CODEX_REASONING_SUMMARY` | `codex.reasoningSummary` | unset | Request Codex reasoning summaries when reasoning effort is enabled; `off` and `none` suppress summaries || `CCP_CODEX_SERVICE_TIER` | `codex.serviceTier` | unset | Force all Codex requests to this service tier (`fast`/`priority`, `flex`; `fast` is sent upstream as `priority`) || `CCP_CODEX_BASE_URL` | `codex.baseUrl` | `https://chatgpt.com/backend-api/codex/responses` | Override the Codex Responses endpoint |-| `CCP_CODEX_TRANSPORT` | `codex.transport` | `websocket` | Codex transport: `websocket`, `http`, or `auto` |+| `CCP_CODEX_TRANSPORT` | `codex.transport` | `auto` | Codex transport: `websocket`, `http`, or `auto` || `CCP_CODEX_PREVIOUS_RESPONSE_ID` | `codex.previousResponseId` | `false` | Enable WebSocket continuation with `previous_response_id` when the request is append-only || `CCP_CODEX_ORIGINATOR` | `codex.originator` | `claude-code-proxy` | Override the `originator` header sent to Codex || `CCP_CODEX_USER_AGENT` | `codex.userAgent` | `claude-code-proxy/<version>` | Override the `User-Agent` header sent to Codex |@@ -731,10 +731,10 @@ A malformed `config.json` is reported on stderr and ignored; defaults are usedin its place. Invalid types for individual keys are warned and skipped withoutaffecting other keys.-Codex uses the WebSocket Responses transport by default. Set-`CCP_CODEX_TRANSPORT=http` to use the older HTTP SSE transport for debugging or-compatibility, or `CCP_CODEX_TRANSPORT=auto` to try WebSocket with HTTP fallback-only when setup fails before a request is sent upstream.+Codex tries the WebSocket Responses transport by default and falls back to HTTP+SSE when the WebSocket handshake fails before a request is sent upstream. Set+`CCP_CODEX_TRANSPORT=http` to force HTTP for debugging or compatibility, or+`CCP_CODEX_TRANSPORT=websocket` to require WebSocket without fallback.`CCP_CODEX_PREVIOUS_RESPONSE_ID=1` enables opt-in WebSocket continuation forappend-only turns. Continuation keeps in-memory state keyed by Claude Codesession id, reuses a session WebSocket while it remains open, and sendsdiff --git a/src/config.rs b/src/config.rsindex 65023ab..545ab2b 100644--- a/src/config.rs+++ b/src/config.rs@@ -504,7 +504,7 @@ pub fn codex_transport() -> CodexTransport {{return transport;}- CodexTransport::WebSocket+ CodexTransport::Auto}// ---------------------------------------------------------------------------@@ -601,11 +601,11 @@ mod tests {}#[test]- fn codex_transport_defaults_to_websocket() {+ fn codex_transport_defaults_to_auto() {let _guard = ENV_LOCK.lock().unwrap();clear_env();let result = codex_transport();- assert_eq!(result, CodexTransport::WebSocket);+ assert_eq!(result, CodexTransport::Auto);}#[test]@@ -629,23 +629,23 @@ mod tests {}#[test]- fn codex_transport_invalid_env_falls_back_to_websocket() {+ fn codex_transport_invalid_env_falls_back_to_auto() {let _guard = ENV_LOCK.lock().unwrap();clear_env();unsafe {std::env::set_var("CCP_CODEX_TRANSPORT", "invalid");}- assert_eq!(codex_transport(), CodexTransport::WebSocket);+ assert_eq!(codex_transport(), CodexTransport::Auto);}#[test]- fn codex_transport_empty_env_falls_back_to_websocket() {+ fn codex_transport_empty_env_falls_back_to_auto() {let _guard = ENV_LOCK.lock().unwrap();clear_env();unsafe {std::env::set_var("CCP_CODEX_TRANSPORT", "");}- assert_eq!(codex_transport(), CodexTransport::WebSocket);+ assert_eq!(codex_transport(), CodexTransport::Auto);}#[test]diff --git a/src/providers/codex/client.rs b/src/providers/codex/client.rsindex ea9f273..73be78a 100644--- a/src/providers/codex/client.rs+++ b/src/providers/codex/client.rs@@ -30,6 +30,7 @@ pub struct CodexError {pub enum CodexErrorOrigin {Http,WebSocket,+ WebSocketHandshake,Auth,BufferedHttp,BufferedWebSocket,@@ -371,10 +372,7 @@ impl CodexHttpClient {match ws_result {Ok(response) => Ok(response),- Err(err)- if err.status == 0- && err.detail.as_deref() == Some("websocket_pre_request") =>- {+ Err(err) if should_fallback_to_http(&err) => {// Fall back to HTTP only if WebSocket failed before sendinglet body_json =serde_json::to_string(body).map_err(|e| CodexError {@@ -397,7 +395,7 @@ impl CodexHttpClient {}};- if should_refresh_after_unauthorized(&result, auth_refresh_attempted) {+ if should_refresh_after_unauthorized(&result, auth_refresh_attempted, transport) {auth_refresh_attempted = true;match self.auth_manager.force_refresh(&auth.access).await {Ok(new_auth) => {@@ -1098,6 +1096,7 @@ fn codex_error_origin_name(origin: CodexErrorOrigin) -> &'static str {match origin {CodexErrorOrigin::Http => "http",CodexErrorOrigin::WebSocket => "websocket",+ CodexErrorOrigin::WebSocketHandshake => "websocket_handshake",CodexErrorOrigin::Auth => "auth",CodexErrorOrigin::BufferedHttp => "buffered_http",CodexErrorOrigin::BufferedWebSocket => "buffered_websocket",@@ -1150,6 +1149,9 @@ fn log_buffered_retry_exhausted(}fn is_retryable_transport_error(err: &CodexError) -> bool {+ if err.origin == CodexErrorOrigin::WebSocketHandshake {+ return err.status == 0 || should_retry_codex_status(err.status);+ }if err.detail.as_deref() == Some("websocket_pre_request") {return err.status == 0 || should_retry_codex_status(err.status);}@@ -1182,16 +1184,25 @@ fn is_retryable_reqwest_error(err: &reqwest::Error) -> bool {fn should_refresh_after_unauthorized(result: &Result<CodexResponse, CodexError>,auth_refresh_attempted: bool,+ transport: crate::config::CodexTransport,) -> bool {if auth_refresh_attempted {return false;}match result {Ok(response) => response.status == 401,- Err(err) => err.status == 401,+ Err(err) => {+ err.status == 401+ && (err.origin != CodexErrorOrigin::WebSocketHandshake+ || transport == crate::config::CodexTransport::WebSocket)+ }}}+fn should_fallback_to_http(err: &CodexError) -> bool {+ err.origin == CodexErrorOrigin::WebSocketHandshake+}+fn should_retry_without_continuation(err: &CodexError,continuation: Option<&super::continuation::ContinuationCandidate>,@@ -1337,6 +1348,52 @@ mod tests {assert_eq!(response.body, b"data: keep\n\n");}+ #[tokio::test]+ async fn auto_falls_back_to_http_after_statusful_websocket_handshake_failure() {+ let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();+ let addr = listener.local_addr().unwrap();+ let server = tokio::spawn(async move {+ let (mut websocket, _) = listener.accept().await.unwrap();+ let mut request = [0_u8; 16 * 1024];+ let read = websocket.read(&mut request).await.unwrap();+ assert!(read > 0);+ assert!(String::from_utf8_lossy(&request[..read]).contains("Upgrade: websocket"));+ websocket+ .write_all(+ b"HTTP/1.1 401 Unauthorized\r\ncontent-length: 13\r\nconnection: close\r\n\r\npolicy denied",+ )+ .await+ .unwrap();+ drop(websocket);++ let (mut http, _) = listener.accept().await.unwrap();+ let read = http.read(&mut request).await.unwrap();+ assert!(read > 0);+ assert!(String::from_utf8_lossy(&request[..read]).starts_with("POST "));+ let body = b"data: keep\n\n";+ let response = format!(+ "HTTP/1.1 200 OK\r\ncontent-length: {}\r\nconnection: close\r\n\r\n",+ body.len()+ );+ http.write_all(response.as_bytes()).await.unwrap();+ http.write_all(body).await.unwrap();+ });++ let response = authenticated_http_test_client(format!("http://{addr}/responses"))+ .post_codex_with_transport(+ &buffered_test_request(),+ &http_test_context(),+ None,+ crate::config::CodexTransport::Auto,+ )+ .await+ .unwrap();+ server.await.unwrap();++ assert_eq!(response.status, 200);+ assert_eq!(response.body, b"data: keep\n\n");+ }+#[tokio::test]async fn over_budget_retry_after_stops_without_replay() {let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();@@ -1810,7 +1867,7 @@ mod tests {}#[test]- fn unauthorized_retry_check_covers_http_and_websocket_results() {+ fn unauthorized_retry_distinguishes_auto_and_strict_websocket_handshakes() {let http_unauthorized = Ok(CodexResponse {body: Vec::new(),status: 401,@@ -1830,14 +1887,49 @@ mod tests {retry_after: None,origin: CodexErrorOrigin::WebSocket,});+ let rejected_handshake = Err(CodexError {+ status: 401,+ message: "WebSocket connect error".to_string(),+ detail: Some("policy denied".to_string()),+ retry_after: None,+ origin: CodexErrorOrigin::WebSocketHandshake,+ });+ let rejected_handshake_err = match &rejected_handshake {+ Err(error) => error,+ Ok(_) => panic!("expected rejected handshake"),+ };- assert!(should_refresh_after_unauthorized(&http_unauthorized, false));+ assert!(should_refresh_after_unauthorized(+ &http_unauthorized,+ false,+ crate::config::CodexTransport::Auto+ ));assert!(should_refresh_after_unauthorized(&websocket_unauthorized,- false+ false,+ crate::config::CodexTransport::Auto+ ));+ assert!(!should_refresh_after_unauthorized(+ &forbidden,+ false,+ crate::config::CodexTransport::Auto+ ));+ assert!(!should_refresh_after_unauthorized(+ &rejected_handshake,+ false,+ crate::config::CodexTransport::Auto+ ));+ assert!(should_refresh_after_unauthorized(+ &rejected_handshake,+ false,+ crate::config::CodexTransport::WebSocket+ ));+ assert!(!should_refresh_after_unauthorized(+ &http_unauthorized,+ true,+ crate::config::CodexTransport::Auto));- assert!(!should_refresh_after_unauthorized(&forbidden, false));- assert!(!should_refresh_after_unauthorized(&http_unauthorized, true));+ assert!(should_fallback_to_http(rejected_handshake_err));}#[test]diff --git a/src/providers/codex/websocket.rs b/src/providers/codex/websocket.rsindex 3ccd563..cf89dcd 100644--- a/src/providers/codex/websocket.rs+++ b/src/providers/codex/websocket.rs@@ -266,7 +266,7 @@ pub async fn codex_websocket_request(message: e.message,detail: None,retry_after: None,- origin: CodexErrorOrigin::WebSocket,+ origin: CodexErrorOrigin::WebSocketHandshake,})?;let body_json = serde_json::to_string(body_value).unwrap_or_default();if let Some(tc) = traffic {@@ -678,31 +678,36 @@ async fn connect_with_timeout(.map_err(|_| CodexError {status: 0,message: format!("WebSocket connect timeout after {connect_timeout_ms}ms"),- detail: Some("websocket_pre_request".to_string()),+ detail: None,retry_after: None,- origin: CodexErrorOrigin::WebSocket,+ origin: CodexErrorOrigin::WebSocketHandshake,})?.map_err(|e| {- let (status, retry_after) = match &e {- tungstenite::Error::Http(response) => (- Some(response.status().as_u16()),- response- .headers()- .get(http::header::RETRY_AFTER)- .and_then(|value| value.to_str().ok())- .map(str::to_string),- ),- _ => (None, None),+ let (status, retry_after, detail) = match &e {+ tungstenite::Error::Http(response) => {+ let detail = response+ .body()+ .as_ref()+ .and_then(|body| String::from_utf8(body.clone()).ok())+ .filter(|body| !body.trim().is_empty());+ (+ Some(response.status().as_u16()),+ response+ .headers()+ .get(http::header::RETRY_AFTER)+ .and_then(|value| value.to_str().ok())+ .map(str::to_string),+ detail,+ )+ }+ _ => (None, None, None),};CodexError {status: status.unwrap_or(0),message: format!("WebSocket connect error: {e}"),- detail: match status {- Some(401 | 403) => None,- _ => Some("websocket_pre_request".to_string()),- },+ detail,retry_after,- origin: CodexErrorOrigin::WebSocket,+ origin: CodexErrorOrigin::WebSocketHandshake,}})}@@ -1269,7 +1274,7 @@ mod tests {}#[tokio::test]- async fn websocket_connect_401_is_statusful_auth_error() {+ async fn websocket_connect_401_is_pre_request_handshake_error() {use tokio::io::{AsyncReadExt, AsyncWriteExt};use tokio::net::TcpListener;@@ -1280,7 +1285,7 @@ mod tests {let mut buf = [0_u8; 2048];let _ = socket.read(&mut buf).await;socket- .write_all(b"HTTP/1.1 401 Unauthorized\r\nContent-Length: 0\r\n\r\n")+ .write_all(b"HTTP/1.1 401 Unauthorized\r\nContent-Length: 13\r\n\r\npolicy denied").await.unwrap();});@@ -1297,8 +1302,8 @@ mod tests {};assert_eq!(err.status, 401);- assert_eq!(err.detail, None);- assert_eq!(err.origin, CodexErrorOrigin::WebSocket);+ assert_eq!(err.detail.as_deref(), Some("policy denied"));+ assert_eq!(err.origin, CodexErrorOrigin::WebSocketHandshake);}#[tokio::test]@@ -1332,9 +1337,9 @@ mod tests {};assert_eq!(err.status, 502);- assert_eq!(err.detail.as_deref(), Some("websocket_pre_request"));+ assert_eq!(err.detail, None);assert_eq!(err.retry_after.as_deref(), Some("3"));- assert_eq!(err.origin, CodexErrorOrigin::WebSocket);+ assert_eq!(err.origin, CodexErrorOrigin::WebSocketHandshake);}#[tokio::test]