Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy
Rust
retry buffered Codex upstream failures
Raine Virtaaed30311a6ea
diff --git a/src/providers/codex/client.rs b/src/providers/codex/client.rsindex 9840481..6960f7e 100644--- a/src/providers/codex/client.rs+++ b/src/providers/codex/client.rs@@ -3,6 +3,7 @@ use std::time::{Duration, Instant};use crate::anthropic::sse::parse_sse_events;use crate::config;+use crate::logging::create_logger;use crate::provider::RequestContext;use crate::retry::{compute_backoff_delay, should_retry_status, sleep};use crate::traffic::TrafficCapture;@@ -202,6 +203,8 @@ pub struct CodexResponse {// Client// ---------------------------------------------------------------------------+const MAX_BUFFERED_TRANSPORT_RETRIES: u32 = 3;+const MAX_BUFFERED_TRANSPORT_ATTEMPTS: u32 = MAX_BUFFERED_TRANSPORT_RETRIES + 1;const HTTP_RESPONSE_BODY_IDLE_TIMEOUT_MS: u64 = 300_000;pub struct CodexHttpClient {@@ -278,6 +281,17 @@ impl CodexHttpClient {body: &ResponsesRequest,ctx: &RequestContext,continuation: Option<&super::continuation::ContinuationCandidate>,+ ) -> Result<CodexResponse, CodexError> {+ self.post_codex_with_transport(body, ctx, continuation, crate::config::codex_transport())+ .await+ }++ async fn post_codex_with_transport(+ &self,+ body: &ResponsesRequest,+ ctx: &RequestContext,+ continuation: Option<&super::continuation::ContinuationCandidate>,+ transport: crate::config::CodexTransport,) -> Result<CodexResponse, CodexError> {use super::continuation::clear_continuation;use crate::config::CodexTransport;@@ -290,16 +304,18 @@ impl CodexHttpClient {origin: CodexErrorOrigin::Auth,})?;- let transport = crate::config::codex_transport();- let pool_key = websocket_pool_key(ctx, continuation);+ let initial_pool_key = websocket_pool_key(ctx, continuation);if should_reset_websocket_pool(continuation)- && let Some(key) = pool_key+ && let Some(key) = initial_pool_key{super::websocket::invalidate_codex_websocket_pool_key(key);}+ let mut active_continuation = continuation;let mut auth_refresh_attempted = false;- for transport_attempt in 0..=3u32 {+ let mut transport_failures = 0u32;+ loop {+ let pool_key = websocket_pool_key(ctx, active_continuation);let result = match transport {CodexTransport::Http => {let body_json = serde_json::to_string(body).map_err(|e| CodexError {@@ -316,7 +332,7 @@ impl CodexHttpClient {let ws_headers =build_codex_headers(&auth, ctx, body.client_metadata.is_some())?;let ws_headers = super::websocket::codex_websocket_headers(&ws_headers);- let ws_body = build_websocket_request(body, continuation);+ let ws_body = build_websocket_request(body, active_continuation);super::websocket::codex_websocket_request(&self.base_url,@@ -327,7 +343,7 @@ impl CodexHttpClient {pool_key,super::websocket::WEBSOCKET_CONNECT_TIMEOUT_MS,super::websocket::WEBSOCKET_IDLE_TIMEOUT_MS,- continuation,+ active_continuation,).await}@@ -335,7 +351,7 @@ impl CodexHttpClient {let ws_headers =build_codex_headers(&auth, ctx, body.client_metadata.is_some())?;let ws_headers = super::websocket::codex_websocket_headers(&ws_headers);- let ws_body = build_websocket_request(body, continuation);+ let ws_body = build_websocket_request(body, active_continuation);// Try WebSocket firstlet ws_result = super::websocket::codex_websocket_request(@@ -347,7 +363,7 @@ impl CodexHttpClient {pool_key,super::websocket::WEBSOCKET_CONNECT_TIMEOUT_MS,super::websocket::WEBSOCKET_IDLE_TIMEOUT_MS,- continuation,+ active_continuation,).await;@@ -401,6 +417,51 @@ impl CodexHttpClient {}}+ if let Ok(response) = &result+ && let Some(failure) = super::events::first_retryable_failure(&response.body)+ {+ if transport_failures < MAX_BUFFERED_TRANSPORT_RETRIES {+ let delay =+ compute_backoff_delay(transport_failures, failure.retry_after.as_deref());+ if delay.exceeds_budget {+ return Err(CodexError {+ status: failure.status,+ message: failure.message.clone(),+ detail: Some(failure.message),+ retry_after: failure.retry_after,+ origin: CodexErrorOrigin::Http,+ });+ }+ log_buffered_retry(+ ctx,+ transport,+ transport_failures + 1,+ delay.wait_ms,+ failure.status,+ "upstream_event",+ &failure.message,+ );+ transport_failures += 1;+ sleep(delay.wait_ms).await;+ continue;+ }++ log_buffered_retry_exhausted(+ ctx,+ transport,+ failure.status,+ "upstream_event",+ &failure.message,+ );+ return Err(CodexError {+ status: failure.status,+ message: failure.message.clone(),+ detail: Some(failure.message),+ retry_after: failure.retry_after,+ origin: CodexErrorOrigin::Http,+ });+ }+match result {Ok(response) if response.status == 401 => {let detail = String::from_utf8_lossy(&response.body).to_string();@@ -428,13 +489,40 @@ impl CodexHttpClient {.iter().find(|(k, _)| k.to_lowercase() == "retry-after").map(|(_, v)| v.clone());- if transport_attempt < 3 {+ if transport_failures < MAX_BUFFERED_TRANSPORT_RETRIES {let delay =- compute_backoff_delay(transport_attempt, retry_after.as_deref());+ compute_backoff_delay(transport_failures, retry_after.as_deref());+ if delay.exceeds_budget {+ let detail = String::from_utf8_lossy(&response.body).to_string();+ return Err(CodexError {+ status: 429,+ message: "Rate limited".to_string(),+ detail: Some(detail),+ retry_after,+ origin: CodexErrorOrigin::Http,+ });+ }+ log_buffered_retry(+ ctx,+ transport,+ transport_failures + 1,+ delay.wait_ms,+ response.status,+ "upstream",+ "rate limited",+ );+ transport_failures += 1;sleep(delay.wait_ms).await;continue;}let detail = String::from_utf8_lossy(&response.body).to_string();+ log_buffered_retry_exhausted(+ ctx,+ transport,+ response.status,+ "upstream",+ "rate limited",+ );return Err(CodexError {status: 429,message: "Rate limited".to_string(),@@ -443,74 +531,83 @@ impl CodexHttpClient {origin: CodexErrorOrigin::Http,});}+ Ok(response) if should_retry_codex_status(response.status) => {+ if transport_failures < MAX_BUFFERED_TRANSPORT_RETRIES {+ let retry_after = response+ .headers+ .iter()+ .find(|(key, _)| key.eq_ignore_ascii_case("retry-after"))+ .map(|(_, value)| value.as_str());+ let delay = compute_backoff_delay(transport_failures, retry_after);+ if delay.exceeds_budget {+ return Err(codex_status_error(response));+ }+ log_buffered_retry(+ ctx,+ transport,+ transport_failures + 1,+ delay.wait_ms,+ response.status,+ "upstream",+ "retryable upstream status",+ );+ transport_failures += 1;+ sleep(delay.wait_ms).await;+ continue;+ }+ log_buffered_retry_exhausted(+ ctx,+ transport,+ response.status,+ "upstream",+ "retryable upstream status",+ );+ return Err(codex_status_error(response));+ }Ok(response) => return Ok(response),- Err(err) if should_retry_without_continuation(&err, continuation) => {+ Err(err) if should_retry_without_continuation(&err, active_continuation) => {clear_continuation(ctx.session_id.as_deref());if let Some(key) = pool_key {super::websocket::invalidate_codex_websocket_pool_key(key);}-- let retry_headers =- build_codex_headers(&auth, ctx, body.client_metadata.is_some())?;- 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 => {- return self- .attempt_post_http(- &auth,- &full_body_json,- ctx,- body.client_metadata.is_some(),- )- .await;- }- CodexTransport::WebSocket | CodexTransport::Auto => {- 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,- ctx.traffic.as_deref(),- pool_key,- super::websocket::WEBSOCKET_CONNECT_TIMEOUT_MS,- super::websocket::WEBSOCKET_IDLE_TIMEOUT_MS,- None,- )- .await;- }- }+ active_continuation = None;+ continue;}Err(err) => {// Determine if retryablelet retryable = is_retryable_transport_error(&err);- if retryable && transport_attempt < 3 {+ if retryable && transport_failures < MAX_BUFFERED_TRANSPORT_RETRIES {let delay =- compute_backoff_delay(transport_attempt, err.retry_after.as_deref());+ compute_backoff_delay(transport_failures, err.retry_after.as_deref());+ if delay.exceeds_budget {+ return Err(err);+ }+ log_buffered_retry(+ ctx,+ transport,+ transport_failures + 1,+ delay.wait_ms,+ err.status,+ codex_error_origin_name(err.origin),+ &err.message,+ );+ transport_failures += 1;sleep(delay.wait_ms).await;continue;}+ if retryable {+ log_buffered_retry_exhausted(+ ctx,+ transport,+ err.status,+ codex_error_origin_name(err.origin),+ &err.message,+ );+ }return Err(err);}}}-- Err(CodexError {- status: 0,- message: "Max retries exceeded".to_string(),- detail: None,- retry_after: None,- origin: CodexErrorOrigin::Http,- })}pub async fn stream_codex_websocket_events(@@ -935,6 +1032,94 @@ fn auth_refresh_error(err: anyhow::Error) -> CodexError {}}+fn codex_status_error(response: CodexResponse) -> CodexError {+ let retry_after = response+ .headers+ .iter()+ .find(|(key, _)| key.eq_ignore_ascii_case("retry-after"))+ .map(|(_, value)| value.clone());+ let message = serde_json::from_slice::<serde_json::Value>(&response.body)+ .ok()+ .and_then(|value| {+ value+ .pointer("/error/message")+ .or_else(|| value.get("message"))+ .or_else(|| value.get("detail"))+ .and_then(|value| value.as_str())+ .map(str::to_string)+ })+ .unwrap_or_else(|| {+ format!(+ "Upstream Codex request failed with status {}",+ response.status+ )+ });+ CodexError {+ status: response.status,+ message: message.clone(),+ detail: Some(message),+ retry_after,+ origin: CodexErrorOrigin::Http,+ }+}++fn should_retry_codex_status(status: u16) -> bool {+ should_retry_status(status) || status == 529+}++fn codex_error_origin_name(origin: CodexErrorOrigin) -> &'static str {+ match origin {+ CodexErrorOrigin::Http => "http",+ CodexErrorOrigin::WebSocket => "websocket",+ CodexErrorOrigin::Auth => "auth",+ }+}++fn log_buffered_retry(+ ctx: &RequestContext,+ transport: crate::config::CodexTransport,+ failed_attempt: u32,+ delay_ms: u64,+ status: u16,+ origin: &str,+ reason: &str,+) {+ let mut fields = serde_json::Map::new();+ fields.insert("reqId".into(), serde_json::json!(ctx.req_id));+ fields.insert("transport".into(), serde_json::json!(transport.as_str()));+ fields.insert("failedAttempt".into(), serde_json::json!(failed_attempt));+ fields.insert("nextAttempt".into(), serde_json::json!(failed_attempt + 1));+ fields.insert(+ "maxAttempts".into(),+ serde_json::json!(MAX_BUFFERED_TRANSPORT_ATTEMPTS),+ );+ fields.insert("delayMs".into(), serde_json::json!(delay_ms));+ fields.insert("status".into(), serde_json::json!(status));+ fields.insert("origin".into(), serde_json::json!(origin));+ fields.insert("reason".into(), serde_json::json!(reason));+ create_logger("codex").warn("buffered_transport_retry", Some(fields));+}++fn log_buffered_retry_exhausted(+ ctx: &RequestContext,+ transport: crate::config::CodexTransport,+ status: u16,+ origin: &str,+ reason: &str,+) {+ let mut fields = serde_json::Map::new();+ fields.insert("reqId".into(), serde_json::json!(ctx.req_id));+ fields.insert("transport".into(), serde_json::json!(transport.as_str()));+ fields.insert(+ "attempts".into(),+ serde_json::json!(MAX_BUFFERED_TRANSPORT_ATTEMPTS),+ );+ fields.insert("status".into(), serde_json::json!(status));+ fields.insert("origin".into(), serde_json::json!(origin));+ fields.insert("reason".into(), serde_json::json!(reason));+ create_logger("codex").warn("buffered_transport_retry_exhausted", Some(fields));+}+fn is_retryable_transport_error(err: &CodexError) -> bool {if err.detail.as_deref() == Some("websocket_pre_request") {return err.status == 0 || should_retry_status(err.status);@@ -1058,6 +1243,104 @@ mod tests {)}+ fn buffered_test_request() -> ResponsesRequest {+ ResponsesRequest {+ model: "gpt-5.6-sol".into(),+ instructions: None,+ input: vec![],+ tools: None,+ tool_choice: None,+ store: false,+ stream: true,+ parallel_tool_calls: true,+ include: None,+ client_metadata: None,+ service_tier: None,+ prompt_cache_key: None,+ text: super::super::translate::request::ResponsesText {+ verbosity: None,+ format: None,+ },+ reasoning: None,+ }+ }++ fn authenticated_http_test_client(base_url: String) -> CodexHttpClient {+ let client = http_test_client(base_url, 100);+ client.auth_manager().set_test_auth(http_test_auth());+ client+ }++ #[tokio::test]+ async fn buffered_http_retries_retryable_status() {+ let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();+ let addr = listener.local_addr().unwrap();+ let server = tokio::spawn(async move {+ for attempt in 0..2 {+ let (mut stream, _) = listener.accept().await.unwrap();+ let mut request = [0_u8; 16 * 1024];+ assert!(stream.read(&mut request).await.unwrap() > 0);+ let (status, body): (&str, &[u8]) = if attempt == 0 {+ ("503 Service Unavailable", b"retry")+ } else {+ ("200 OK", b"data: keep\n\n")+ };+ let response = format!(+ "HTTP/1.1 {status}\r\ncontent-length: {}\r\nretry-after: 0\r\nconnection: close\r\n\r\n",+ body.len()+ );+ stream.write_all(response.as_bytes()).await.unwrap();+ stream.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::Http,+ )+ .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();+ let addr = listener.local_addr().unwrap();+ let server = tokio::spawn(async move {+ let (mut stream, _) = listener.accept().await.unwrap();+ let mut request = [0_u8; 16 * 1024];+ assert!(stream.read(&mut request).await.unwrap() > 0);+ stream+ .write_all(+ b"HTTP/1.1 503 Service Unavailable\r\ncontent-length: 4\r\nretry-after: 120\r\nconnection: close\r\n\r\nstop",+ )+ .await+ .unwrap();+ });++ let error = match authenticated_http_test_client(format!("http://{addr}/responses"))+ .post_codex_with_transport(+ &buffered_test_request(),+ &http_test_context(),+ None,+ crate::config::CodexTransport::Http,+ )+ .await+ {+ Ok(_) => panic!("over-budget Retry-After should propagate"),+ Err(error) => error,+ };+ server.await.unwrap();+ assert_eq!(error.status, 503);+ assert_eq!(error.retry_after.as_deref(), Some("120"));+ }+#[tokio::test]async fn active_http_body_can_exceed_header_timeout() {let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();diff --git a/src/providers/codex/events.rs b/src/providers/codex/events.rsnew file mode 100644index 0000000..76cfafb--- /dev/null+++ b/src/providers/codex/events.rs@@ -0,0 +1,214 @@+use serde_json::Value;++#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub(crate) enum CodexFailureKind {+ RateLimit,+ Overloaded,+ Transient,+ Permanent,+}++#[derive(Debug, Clone, PartialEq, Eq)]+pub(crate) struct CodexEventFailure {+ pub kind: CodexFailureKind,+ pub explicit_status: Option<u16>,+ pub status: u16,+ pub message: String,+ pub retry_after: Option<String>,+}++impl CodexEventFailure {+ pub fn retryable(&self) -> bool {+ !matches!(self.kind, CodexFailureKind::Permanent)+ }+}++pub(crate) fn classify_event_failure(payload: &Value) -> Option<CodexEventFailure> {+ let event_type = payload.get("type").and_then(Value::as_str)?;+ if event_type == "codex.rate_limits" {+ if payload+ .pointer("/rate_limits/limit_reached")+ .and_then(Value::as_bool)+ != Some(true)+ {+ return None;+ }+ return Some(CodexEventFailure {+ kind: CodexFailureKind::RateLimit,+ explicit_status: Some(429),+ status: 429,+ message: "rate limit reached".to_string(),+ retry_after: scalar_string(payload.pointer("/rate_limits/primary/reset_after_seconds")),+ });+ }+ if !matches!(event_type, "response.failed" | "response.error" | "error") {+ return None;+ }++ let error = payload+ .get("error")+ .or_else(|| payload.pointer("/response/error"));+ let explicit_status = numeric_status(payload)+ .or_else(|| {+ error+ .and_then(|value| value.get("status"))+ .and_then(Value::as_u64)+ })+ .and_then(|status| u16::try_from(status).ok());+ let message = error+ .and_then(|value| value.get("message"))+ .and_then(Value::as_str)+ .unwrap_or("Upstream error")+ .to_string();+ let code = error+ .and_then(|value| value.get("code"))+ .and_then(Value::as_str);+ let error_type = error+ .and_then(|value| value.get("type"))+ .and_then(Value::as_str);+ let lower = message.to_ascii_lowercase();++ let kind = if explicit_status == Some(429) || lower.contains("rate limit") {+ CodexFailureKind::RateLimit+ } else if explicit_status == Some(529)+ || code == Some("overloaded_error")+ || error_type == Some("overloaded_error")+ || lower.contains("overloaded")+ {+ CodexFailureKind::Overloaded+ } else if explicit_status.is_some_and(|status| matches!(status, 500 | 502 | 503 | 504))+ || matches!(+ code,+ Some("server_error" | "internal_server_error" | "internal_error")+ )+ || matches!(+ error_type,+ Some("server_error" | "internal_server_error" | "internal_error")+ )+ || retryable_message(&lower)+ {+ CodexFailureKind::Transient+ } else {+ CodexFailureKind::Permanent+ };+ let status = explicit_status.unwrap_or(match kind {+ CodexFailureKind::RateLimit => 429,+ CodexFailureKind::Overloaded => 529,+ CodexFailureKind::Transient => 503,+ CodexFailureKind::Permanent => 500,+ });+ let retry_after = error+ .and_then(|value| value.get("retry_after"))+ .and_then(scalar_string_value)+ .or_else(|| {+ error+ .and_then(|value| value.get("retry_after_seconds"))+ .and_then(scalar_string_value)+ })+ .or_else(|| scalar_string(payload.get("retry_after_seconds")))+ .or_else(|| scalar_string(payload.pointer("/headers/retry-after")))+ .or_else(|| scalar_string(payload.pointer("/headers/Retry-After")));++ Some(CodexEventFailure {+ kind,+ explicit_status,+ status,+ message,+ retry_after,+ })+}++pub(crate) fn first_retryable_failure(body: &[u8]) -> Option<CodexEventFailure> {+ for event in crate::anthropic::sse::parse_sse_events(body) {+ if event.data == "[DONE]" {+ continue;+ }+ let Ok(payload) = serde_json::from_str::<Value>(&event.data) else {+ continue;+ };+ if let Some(failure) = classify_event_failure(&payload)+ && failure.retryable()+ {+ return Some(failure);+ }+ }+ None+}++pub(crate) fn numeric_status(payload: &Value) -> Option<u64> {+ payload+ .get("status")+ .and_then(Value::as_u64)+ .or_else(|| payload.get("status_code").and_then(Value::as_u64))+}++fn scalar_string(value: Option<&Value>) -> Option<String> {+ value.and_then(scalar_string_value)+}++fn scalar_string_value(value: &Value) -> Option<String> {+ match value {+ Value::String(value) => Some(value.clone()),+ Value::Number(value) => Some(value.to_string()),+ _ => None,+ }+}++fn retryable_message(message: &str) -> bool {+ [+ "server error",+ "internal server error",+ "service unavailable",+ "bad gateway",+ "gateway timeout",+ "temporarily unavailable",+ "connection reset",+ "connection closed",+ "timed out",+ "timeout",+ "unexpected eof",+ ]+ .iter()+ .any(|needle| message.contains(needle))+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn classifies_retryable_failure_kinds() {+ let rate = classify_event_failure(&serde_json::json!({+ "type": "codex.rate_limits",+ "rate_limits": {"limit_reached": true, "primary": {"reset_after_seconds": 1.5}}+ }))+ .unwrap();+ assert_eq!(rate.kind, CodexFailureKind::RateLimit);+ assert_eq!(rate.retry_after.as_deref(), Some("1.5"));++ let overload = classify_event_failure(&serde_json::json!({+ "type": "response.failed",+ "response": {"error": {"type": "overloaded_error", "message": "busy"}}+ }))+ .unwrap();+ assert_eq!(overload.status, 529);+ assert!(overload.retryable());+ }++ #[test]+ fn ignores_informational_and_permanent_events() {+ assert!(+ classify_event_failure(&serde_json::json!({+ "type": "codex.rate_limits",+ "rate_limits": {"limit_reached": false}+ }))+ .is_none()+ );+ let failure = classify_event_failure(&serde_json::json!({+ "type": "error",+ "error": {"status": 400, "message": "bad request"}+ }))+ .unwrap();+ assert!(!failure.retryable());+ }+}diff --git a/src/providers/codex/mod.rs b/src/providers/codex/mod.rsindex 34240aa..7fb6198 100644--- a/src/providers/codex/mod.rs+++ b/src/providers/codex/mod.rs@@ -2,6 +2,7 @@ pub mod auth;pub mod client;pub mod continuation;pub mod count_tokens;+pub(crate) mod events;pub mod request_summary;pub mod translate;pub mod websocket;@@ -691,114 +692,27 @@ fn drop_live_continuation_for_retry(true}-fn retryable_live_start_payload(payload: &serde_json::Value, message: &str) -> bool {- if payload.get("type").and_then(|v| v.as_str()) == Some("codex.rate_limits")- && payload- .get("rate_limits")- .and_then(|r| r.get("limit_reached"))- .and_then(|v| v.as_bool())- == Some(true)- {- return true;- }-- let status = payload- .get("status")- .or_else(|| payload.get("status_code"))- .and_then(|v| v.as_u64())- .or_else(|| {- payload- .get("error")- .and_then(|e| e.get("status"))- .and_then(|v| v.as_u64())- })- .or_else(|| {- payload- .get("response")- .and_then(|r| r.get("error"))- .and_then(|e| e.get("status"))- .and_then(|v| v.as_u64())- });- if matches!(status, Some(429 | 500 | 502 | 503 | 504 | 529)) {- return true;- }-- let code = payload- .get("error")- .and_then(|e| e.get("code"))- .and_then(|v| v.as_str())- .or_else(|| {- payload- .get("response")- .and_then(|r| r.get("error"))- .and_then(|e| e.get("code"))- .and_then(|v| v.as_str())- });- let err_type = payload- .get("error")- .and_then(|e| e.get("type"))- .and_then(|v| v.as_str())- .or_else(|| {- payload- .get("response")- .and_then(|r| r.get("error"))- .and_then(|e| e.get("type"))- .and_then(|v| v.as_str())- });- code == Some("overloaded_error")- || err_type == Some("overloaded_error")- || retryable_live_message(message)-}--fn retry_after_from_live_payload(payload: &serde_json::Value) -> Option<String> {- payload- .get("rate_limits")- .and_then(|r| r.get("primary"))- .and_then(|r| r.get("reset_after_seconds"))- .map(json_scalar_to_string)- .or_else(|| {- payload- .get("error")- .and_then(|e| e.get("retry_after"))- .map(json_scalar_to_string)- })- .or_else(|| {- payload- .get("error")- .and_then(|e| e.get("retry_after_seconds"))- .map(json_scalar_to_string)- })- .or_else(|| {- payload- .get("response")- .and_then(|r| r.get("error"))- .and_then(|e| e.get("retry_after_seconds"))- .map(json_scalar_to_string)- })- .or_else(|| {- payload- .get("headers")- .and_then(|h| h.get("retry-after"))- .map(json_scalar_to_string)- })+fn retryable_live_message(message: &str) -> bool {+ let lower = message.to_ascii_lowercase();+ [+ "overloaded",+ "rate limit",+ "you can retry your request",+ "temporarily unavailable",+ "timed out",+ "connection closed",+ "connection reset",+ ]+ .iter()+ .any(|needle| lower.contains(needle))}-fn json_scalar_to_string(value: &serde_json::Value) -> String {- value- .as_str()- .map(str::to_string)- .unwrap_or_else(|| value.to_string())+fn retryable_live_start_payload(payload: &serde_json::Value, _message: &str) -> bool {+ events::classify_event_failure(payload).is_some_and(|failure| failure.retryable())}-fn retryable_live_message(message: &str) -> bool {- let lower = message.to_lowercase();- lower.contains("overloaded")- || lower.contains("rate limit")- || lower.contains("you can retry your request")- || lower.contains("temporarily unavailable")- || lower.contains("timed out")- || lower.contains("connection closed")- || lower.contains("connection reset")+fn retry_after_from_live_payload(payload: &serde_json::Value) -> Option<String> {+ events::classify_event_failure(payload).and_then(|failure| failure.retry_after)}fn codex_stream_error_type(err: &client::CodexError) -> &'static str {@@ -854,6 +768,22 @@ fn map_codex_error_to_response(err: &client::CodexError) -> Response {let headers = [(http::header::RETRY_AFTER, retry_after)];(headers, resp).into_response()}+ status @ (500 | 502 | 503 | 504 | 529) => {+ let response = json_error(+ StatusCode::from_u16(status).unwrap_or(StatusCode::BAD_GATEWAY),+ if status == 529 {+ "overloaded_error"+ } else {+ "api_error"+ },+ codex_error_message(err),+ );+ if let Some(retry_after) = err.retry_after.as_deref() {+ ([(http::header::RETRY_AFTER, retry_after)], response).into_response()+ } else {+ response+ }+ }_ => json_error(StatusCode::BAD_GATEWAY,"api_error",diff --git a/src/providers/codex/websocket.rs b/src/providers/codex/websocket.rsindex 74bafc7..3ccd563 100644--- a/src/providers/codex/websocket.rs+++ b/src/providers/codex/websocket.rs@@ -233,31 +233,7 @@ fn is_previous_response_missing(payload: &serde_json::Value) -> bool {}pub(super) fn event_error_status(payload: &serde_json::Value) -> Option<u16> {- if !matches!(- payload.get("type").and_then(|value| value.as_str()),- Some("error" | "response.error" | "response.failed")- ) {- return None;- }-- payload- .get("status")- .and_then(|value| value.as_u64())- .or_else(|| payload.get("status_code").and_then(|value| value.as_u64()))- .or_else(|| {- payload- .get("error")- .and_then(|error| error.get("status"))- .and_then(|value| value.as_u64())- })- .or_else(|| {- payload- .get("response")- .and_then(|response| response.get("error"))- .and_then(|error| error.get("status"))- .and_then(|value| value.as_u64())- })- .and_then(|status| u16::try_from(status).ok())+ super::events::classify_event_failure(payload).and_then(|failure| failure.explicit_status)}#[allow(dead_code)]