Skip to content

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.md
index 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 used
in its place. Invalid types for individual keys are warned and skipped without
affecting 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 for
append-only turns. Continuation keeps in-memory state keyed by Claude Code
session id, reuses a session WebSocket while it remains open, and sends
diff --git a/src/config.rs b/src/config.rs
index 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.rs
index 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 sending
let 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.rs
index 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]