Skip to content

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

Rust

track actual Codex transport and sanitize handshake errors

Raine Virta2cbeca11e8f8
diff --git a/src/providers/codex/client.rs b/src/providers/codex/client.rs
index 4995245..9d57775 100644
--- a/src/providers/codex/client.rs
+++ b/src/providers/codex/client.rs
@@ -203,10 +203,17 @@ pub fn build_websocket_request(
// Response
// ---------------------------------------------------------------------------
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ActualTransport {
+ Http,
+ WebSocket,
+}
+
pub struct CodexResponse {
pub body: Vec<u8>,
pub status: u16,
pub headers: Vec<(String, String)>,
+ pub transport: ActualTransport,
}
// ---------------------------------------------------------------------------
@@ -442,7 +449,10 @@ impl CodexHttpClient {
message: failure.message.clone(),
detail: Some(failure.message),
retry_after: failure.retry_after,
- origin: buffered_origin(transport),
+ origin: match response.transport {
+ ActualTransport::Http => CodexErrorOrigin::BufferedHttp,
+ ActualTransport::WebSocket => CodexErrorOrigin::BufferedWebSocket,
+ },
});
}
log_buffered_retry(
@@ -554,7 +564,7 @@ impl CodexHttpClient {
.map(|(_, value)| value.as_str());
let delay = compute_backoff_delay(transport_failures, retry_after);
if delay.exceeds_budget {
- return Err(codex_status_error(response, transport));
+ return Err(codex_status_error(response));
}
log_buffered_retry(
ctx,
@@ -576,10 +586,10 @@ impl CodexHttpClient {
"upstream",
"retryable upstream status",
);
- return Err(codex_status_error(response, transport));
+ return Err(codex_status_error(response));
}
Ok(response) if !(200..300).contains(&response.status) => {
- return Err(codex_status_error(response, transport));
+ return Err(codex_status_error(response));
}
Ok(response) => return Ok(response),
Err(err)
@@ -932,6 +942,7 @@ impl CodexHttpClient {
body: body_bytes,
status,
headers,
+ transport: ActualTransport::Http,
})
}
}
@@ -1064,10 +1075,7 @@ fn auth_refresh_error(err: anyhow::Error) -> CodexError {
}
}
-fn codex_status_error(
- response: CodexResponse,
- transport: crate::config::CodexTransport,
-) -> CodexError {
+fn codex_status_error(response: CodexResponse) -> CodexError {
let retry_after = response
.headers
.iter()
@@ -1084,7 +1092,10 @@ fn codex_status_error(
message: message.clone(),
detail: Some(message),
retry_after,
- origin: buffered_origin(transport),
+ origin: match response.transport {
+ ActualTransport::Http => CodexErrorOrigin::BufferedHttp,
+ ActualTransport::WebSocket => CodexErrorOrigin::BufferedWebSocket,
+ },
}
}
@@ -1107,15 +1118,6 @@ fn codex_status_error_message(body: &[u8]) -> Option<String> {
})
}
-fn buffered_origin(transport: crate::config::CodexTransport) -> CodexErrorOrigin {
- match transport {
- crate::config::CodexTransport::Http => CodexErrorOrigin::BufferedHttp,
- crate::config::CodexTransport::WebSocket | crate::config::CodexTransport::Auto => {
- CodexErrorOrigin::BufferedWebSocket
- }
- }
-}
-
fn should_retry_codex_status(status: u16) -> bool {
should_retry_status(status) || status == 529
}
@@ -1512,15 +1514,13 @@ mod tests {
#[test]
fn status_error_preserves_buffered_websocket_event_message() {
- let error = codex_status_error(
- CodexResponse {
- body: b"data: {\"type\":\"error\",\"error\":{\"status\":400,\"message\":\"bad request\"}}\n\n"
- .to_vec(),
- status: 400,
- headers: Vec::new(),
- },
- crate::config::CodexTransport::WebSocket,
- );
+ let error = codex_status_error(CodexResponse {
+ body: b"data: {\"type\":\"error\",\"error\":{\"status\":400,\"message\":\"bad request\"}}\n\n"
+ .to_vec(),
+ status: 400,
+ headers: Vec::new(),
+ transport: ActualTransport::WebSocket,
+ });
assert_eq!(error.status, 400);
assert_eq!(error.detail.as_deref(), Some("bad request"));
@@ -1926,6 +1926,7 @@ mod tests {
body: Vec::new(),
status: 401,
headers: Vec::new(),
+ transport: ActualTransport::Http,
});
let websocket_unauthorized = Err(CodexError {
status: 401,
diff --git a/src/providers/codex/mod.rs b/src/providers/codex/mod.rs
index ead8d11..6b6bfe5 100644
--- a/src/providers/codex/mod.rs
+++ b/src/providers/codex/mod.rs
@@ -771,22 +771,29 @@ fn map_codex_error_to_response(err: &client::CodexError) -> Response {
}
match err.status {
- 401 | 403 => json_error(
+ 401 => json_error(
StatusCode::UNAUTHORIZED,
"authentication_error",
err.detail.as_deref().unwrap_or("Authentication failed"),
),
+ 403 => json_error(
+ StatusCode::FORBIDDEN,
+ "permission_error",
+ err.detail.as_deref().unwrap_or("Permission denied"),
+ ),
429 => {
- let retry_after = err.retry_after.as_deref().unwrap_or("5");
- let resp = json_error(
+ let response = json_error(
StatusCode::TOO_MANY_REQUESTS,
"rate_limit_error",
&err.message,
);
- let headers = [(http::header::RETRY_AFTER, retry_after)];
- (headers, resp).into_response()
+ if let Some(retry_after) = err.retry_after.as_deref() {
+ ([(http::header::RETRY_AFTER, retry_after)], response).into_response()
+ } else {
+ response
+ }
}
- status @ (500 | 502 | 503 | 504 | 529)
+ status @ (400..=599)
if matches!(
err.origin,
client::CodexErrorOrigin::BufferedHttp
diff --git a/src/providers/codex/websocket.rs b/src/providers/codex/websocket.rs
index b31ae33..b8672e7 100644
--- a/src/providers/codex/websocket.rs
+++ b/src/providers/codex/websocket.rs
@@ -15,7 +15,7 @@ use tokio_tungstenite::{
use crate::provider::RequestContext;
use crate::traffic::TrafficCapture;
-use super::client::{CodexError, CodexErrorOrigin, CodexResponse};
+use super::client::{ActualTransport, CodexError, CodexErrorOrigin, CodexResponse};
use super::continuation::ContinuationCandidate;
// ---------------------------------------------------------------------------
@@ -403,6 +403,7 @@ pub async fn codex_websocket_request(
body: sse_body,
status,
headers: vec![],
+ transport: ActualTransport::WebSocket,
});
}
} else {
@@ -480,6 +481,7 @@ pub async fn codex_websocket_request(
body: sse_body,
status,
headers: vec![],
+ transport: ActualTransport::WebSocket,
})
}
}
@@ -684,6 +686,32 @@ fn write_websocket_response_capture(
// Connection helper
// ---------------------------------------------------------------------------
+const MAX_HANDSHAKE_ERROR_DETAIL_BYTES: usize = 1024;
+const GENERIC_HANDSHAKE_ERROR_DETAIL: &str = "WebSocket upgrade was rejected";
+
+fn handshake_error_detail(body: Option<&Vec<u8>>) -> String {
+ let Some(value) = body.and_then(|body| serde_json::from_slice::<serde_json::Value>(body).ok())
+ else {
+ return GENERIC_HANDSHAKE_ERROR_DETAIL.to_string();
+ };
+ let Some(message) = value
+ .pointer("/error/message")
+ .or_else(|| value.get("message"))
+ .and_then(|value| value.as_str())
+ else {
+ return GENERIC_HANDSHAKE_ERROR_DETAIL.to_string();
+ };
+ let sanitized: String = message
+ .chars()
+ .filter(|ch| !ch.is_control() || matches!(ch, ' '))
+ .collect();
+ let mut end = sanitized.len().min(MAX_HANDSHAKE_ERROR_DETAIL_BYTES);
+ while !sanitized.is_char_boundary(end) {
+ end -= 1;
+ }
+ sanitized[..end].to_string()
+}
+
async fn connect_with_timeout(
url: &str,
headers: &HeaderMap,
@@ -740,11 +768,7 @@ async fn connect_with_timeout(
.map_err(|e| {
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());
+ let detail = Some(handshake_error_detail(response.body().as_ref()));
(
Some(response.status().as_u16()),
response
@@ -1331,7 +1355,7 @@ mod tests {
};
assert_eq!(err.status, 401);
- assert_eq!(err.detail.as_deref(), Some("policy denied"));
+ assert_eq!(err.detail.as_deref(), Some(GENERIC_HANDSHAKE_ERROR_DETAIL));
assert_eq!(err.origin, CodexErrorOrigin::WebSocketHandshake);
}
@@ -1366,7 +1390,7 @@ mod tests {
};
assert_eq!(err.status, 502);
- assert_eq!(err.detail, None);
+ assert_eq!(err.detail.as_deref(), Some(GENERIC_HANDSHAKE_ERROR_DETAIL));
assert_eq!(err.retry_after.as_deref(), Some("3"));
assert_eq!(err.origin, CodexErrorOrigin::WebSocketHandshake);
}