Skip to content

Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy

Rust

retry websocket handshake failures

Raine Virta5e45fd30a42d
diff --git a/src/providers/codex/client.rs b/src/providers/codex/client.rs
index a4d081a..b67bd1a 100644
--- a/src/providers/codex/client.rs
+++ b/src/providers/codex/client.rs
@@ -3,7 +3,7 @@ use std::time::{Duration, Instant};
use crate::anthropic::sse::parse_sse_events;
use crate::config;
use crate::provider::RequestContext;
-use crate::retry::{compute_backoff_delay, sleep};
+use crate::retry::{compute_backoff_delay, should_retry_status, sleep};
use crate::traffic::TrafficCapture;
use super::auth::constants::{CODEX_API_ENDPOINT, ORIGINATOR, RESPONSES_LITE_ORIGINATOR};
@@ -482,7 +482,8 @@ impl CodexHttpClient {
// Determine if retryable
let retryable = is_retryable_transport_error(&err);
if retryable && transport_attempt < 3 {
- let delay = compute_backoff_delay(transport_attempt, None);
+ let delay =
+ compute_backoff_delay(transport_attempt, err.retry_after.as_deref());
sleep(delay.wait_ms).await;
continue;
}
@@ -801,14 +802,15 @@ fn summarize_json_request_size(body: &serde_json::Value, body_json: &str) -> ser
}
fn is_retryable_transport_error(err: &CodexError) -> bool {
- err.status == 0
- && (err.message.contains("Timed out waiting")
- || err.message.contains("Transport error")
- || err.message.contains("connection reset")
- || err.message.contains("connection closed")
- || err.message.contains("timed out")
- || err.message.contains("econnreset")
- || err.message.contains("etimedout"))
+ (err.detail.as_deref() == Some("websocket_pre_request") && should_retry_status(err.status))
+ || (err.status == 0
+ && (err.message.contains("Timed out waiting")
+ || err.message.contains("Transport error")
+ || err.message.contains("connection reset")
+ || err.message.contains("connection closed")
+ || err.message.contains("timed out")
+ || err.message.contains("econnreset")
+ || err.message.contains("etimedout")))
}
fn is_retryable_reqwest_error(err: &reqwest::Error) -> bool {
@@ -898,6 +900,32 @@ mod tests {
assert!(display.contains("Rate limited"));
}
+ #[test]
+ fn websocket_pre_request_502_is_retryable() {
+ let err = CodexError {
+ status: 502,
+ message: "WebSocket connect error".to_string(),
+ detail: Some("websocket_pre_request".to_string()),
+ retry_after: Some("3".to_string()),
+ origin: CodexErrorOrigin::WebSocket,
+ };
+
+ assert!(is_retryable_transport_error(&err));
+ }
+
+ #[test]
+ fn websocket_pre_request_400_is_not_retryable() {
+ let err = CodexError {
+ status: 400,
+ message: "WebSocket connect error".to_string(),
+ detail: Some("websocket_pre_request".to_string()),
+ retry_after: None,
+ origin: CodexErrorOrigin::WebSocket,
+ };
+
+ assert!(!is_retryable_transport_error(&err));
+ }
+
#[test]
fn codex_headers_include_session_and_beta() {
let auth = StoredAuth {
diff --git a/src/providers/codex/websocket.rs b/src/providers/codex/websocket.rs
index 3c58bb0..e65a3c8 100644
--- a/src/providers/codex/websocket.rs
+++ b/src/providers/codex/websocket.rs
@@ -687,26 +687,25 @@ async fn connect_with_timeout(
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
+ 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),
};
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
+ detail: match status {
+ Some(401 | 403) => None,
+ _ => Some("websocket_pre_request".to_string()),
},
- retry_after: None,
+ retry_after,
origin: CodexErrorOrigin::WebSocket,
}
})
@@ -1280,6 +1279,42 @@ mod tests {
assert_eq!(err.origin, CodexErrorOrigin::WebSocket);
}
+ #[tokio::test]
+ async fn websocket_connect_502_preserves_retry_metadata() {
+ use tokio::io::{AsyncReadExt, AsyncWriteExt};
+ use tokio::net::TcpListener;
+
+ let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+ let addr = listener.local_addr().unwrap();
+ tokio::spawn(async move {
+ let (mut socket, _) = listener.accept().await.unwrap();
+ let mut buf = [0_u8; 2048];
+ let _ = socket.read(&mut buf).await;
+ socket
+ .write_all(
+ b"HTTP/1.1 502 Bad Gateway\r\nRetry-After: 3\r\nContent-Length: 0\r\n\r\n",
+ )
+ .await
+ .unwrap();
+ });
+
+ let err = match connect_with_timeout(
+ &format!("ws://{addr}/backend-api/codex/responses"),
+ &HeaderMap::new(),
+ 1_000,
+ )
+ .await
+ {
+ Ok(_) => panic!("expected websocket handshake to fail"),
+ Err(err) => err,
+ };
+
+ assert_eq!(err.status, 502);
+ assert_eq!(err.detail.as_deref(), Some("websocket_pre_request"));
+ assert_eq!(err.retry_after.as_deref(), Some("3"));
+ assert_eq!(err.origin, CodexErrorOrigin::WebSocket);
+ }
+
#[tokio::test]
async fn binary_frame_invalidates_pool_key() {
clear_codex_websocket_pool_for_tests();