Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy
Rust
fast-fail codex quota errors across anthropic transports
Raine Virta73855526840c
diff --git a/src/providers/codex/chat_completions/mod.rs b/src/providers/codex/chat_completions/mod.rsindex eb816c3..b50a36f 100644--- a/src/providers/codex/chat_completions/mod.rs+++ b/src/providers/codex/chat_completions/mod.rs@@ -453,6 +453,7 @@ mod tests {message: "Rate limited".into(),detail: Some("Try later".into()),retry_after: Some("7".into()),+ usage_limit: None,origin: super::super::client::CodexErrorOrigin::Http,});assert_eq!(response.status(), StatusCode::TOO_MANY_REQUESTS);@@ -463,6 +464,7 @@ mod tests {message: "Auth error".into(),detail: None,retry_after: None,+ usage_limit: None,origin: super::super::client::CodexErrorOrigin::Auth,});assert_eq!(auth.status, StatusCode::UNAUTHORIZED);diff --git a/src/providers/codex/client.rs b/src/providers/codex/client.rsindex 8f37ab8..e3a0d8e 100644--- a/src/providers/codex/client.rs+++ b/src/providers/codex/client.rs@@ -12,6 +12,7 @@ use crate::traffic::TrafficCapture;use super::auth::constants::{CODEX_API_ENDPOINT, ORIGINATOR, RESPONSES_LITE_ORIGINATOR};use super::auth::manager::CodexAuthManager;use super::auth::token_store::{DefaultCodexAuthStore, StoredAuth, file_store};+pub use super::events::{CodexLimitWindow, CodexUsageLimit};use super::search::{SearchRequest, SearchResponse};use super::translate::request::ResponsesRequest;@@ -25,6 +26,7 @@ pub struct CodexError {pub message: String,pub detail: Option<String>,pub retry_after: Option<String>,+ pub usage_limit: Option<Box<CodexUsageLimit>>,pub origin: CodexErrorOrigin,}@@ -45,6 +47,7 @@ impl CodexError {message,detail: None,retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::Http,}}@@ -288,6 +291,7 @@ fn header_value(name: &str, value: &str) -> Result<http::HeaderValue, CodexErrormessage: format!("Failed to parse {name} header"),detail: Some(e.to_string()),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::Http,})}@@ -476,6 +480,7 @@ fn http_sse_error(message: &str) -> CodexError {message: message.to_string(),detail: Some("http_response_sse".to_string()),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::Http,}}@@ -787,6 +792,7 @@ impl CodexHttpClient {message: "Auth error".to_string(),detail: Some(error.to_string()),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::Auth,})?;let mut refresh_attempted = false;@@ -822,6 +828,7 @@ impl CodexHttpClient {message: "Invalid audio content type".to_string(),detail: Some(error.to_string()),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::Http,})?;let mut form = reqwest::multipart::Form::new().part("file", part);@@ -845,6 +852,7 @@ impl CodexHttpClient {),detail: None,retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::Http,})?.map_err(|error| CodexError {@@ -852,6 +860,7 @@ impl CodexHttpClient {message: format!("Codex transcription transport error: {error}"),detail: None,retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::Http,})}@@ -868,6 +877,7 @@ impl CodexHttpClient {message: "Failed to serialize image request".to_string(),detail: Some(error.to_string()),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::Http,})?;let url = format!(@@ -884,6 +894,7 @@ impl CodexHttpClient {message: "Auth error".to_string(),detail: Some(error.to_string()),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::Auth,})?;let mut refresh_attempted = false;@@ -930,6 +941,7 @@ impl CodexHttpClient {),detail: None,retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::Http,})?.map_err(|error| CodexError {@@ -937,6 +949,7 @@ impl CodexHttpClient {message: format!("Codex image transport error: {error}"),detail: None,retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::Http,})}@@ -953,6 +966,7 @@ impl CodexHttpClient {message: "Failed to serialize native Responses request".to_string(),detail: Some(err.to_string()),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::Http,})?;let mut auth = self@@ -964,6 +978,7 @@ impl CodexHttpClient {message: "Auth error".to_string(),detail: Some(err.to_string()),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::Auth,})?;let mut refresh_attempted = false;@@ -1020,6 +1035,7 @@ impl CodexHttpClient {),detail: None,retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::Http,})?.map_err(|err| CodexError {@@ -1027,6 +1043,7 @@ impl CodexHttpClient {message: format!("Native Responses transport error: {err}"),detail: None,retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::Http,})}@@ -1069,6 +1086,7 @@ impl CodexHttpClient {message: "Auth error".to_string(),detail: Some(e.to_string()),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::Auth,})?;let body_json = serde_json::to_string(body).map_err(|e| CodexError {@@ -1076,6 +1094,7 @@ impl CodexHttpClient {message: "Failed to serialize search request".to_string(),detail: Some(e.to_string()),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::Http,})?;let mut auth_refresh_attempted = false;@@ -1116,6 +1135,7 @@ impl CodexHttpClient {message: "Failed to decode Codex search response".to_string(),detail: Some(e.to_string()),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::Http,});}@@ -1131,6 +1151,7 @@ impl CodexHttpClient {message: "Auth error".to_string(),detail: Some(e.to_string()),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::Auth,})?;let body_json = serde_json::to_string(body).map_err(|e| CodexError {@@ -1138,6 +1159,7 @@ impl CodexHttpClient {message: "Failed to serialize request".to_string(),detail: Some(e.to_string()),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::Http,})?;let mut auth_refresh_attempted = false;@@ -1279,6 +1301,7 @@ impl CodexHttpClient {message: "WebSocket connection closed before the first Codex event".to_string(),detail: Some(super::websocket::WEBSOCKET_MISSING_TERMINAL_DETAIL.to_string()),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocket,}),}@@ -1380,6 +1403,7 @@ impl CodexHttpClient {),detail: Some("http_response_body".to_string()),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::Http,};log_http_stream_end(@@ -1406,6 +1430,7 @@ impl CodexHttpClient {),detail: Some("http_response_body".to_string()),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::Http,};log_http_stream_end(@@ -1464,12 +1489,23 @@ impl CodexHttpClient {let event_kind = super::events::classify_stream_event(&payload);let failure = super::events::classify_event_failure(&payload);- if !semantic_output_forwarded- && let Some(failure) = failure.as_ref()- && failure.retryable()- {- pending_events.clear();- break 'read_attempt codex_event_failure_error(failure.clone());+ if !semantic_output_forwarded {+ if let Some(limit) = super::events::usage_limit_from_event(&payload) {+ pending_events.clear();+ let _ = tx+ .send(Err(codex_usage_limit_error(+ limit,+ CodexErrorOrigin::Http,+ )))+ .await;+ return;+ }+ if let Some(failure) = failure.as_ref()+ && failure.retryable()+ {+ pending_events.clear();+ break 'read_attempt codex_event_failure_error(failure.clone());+ }}let terminal = super::events::event_is_terminal(&payload);@@ -1598,6 +1634,7 @@ impl CodexHttpClient {message: "Auth error".to_string(),detail: Some(e.to_string()),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::Auth,})?;@@ -1622,6 +1659,7 @@ impl CodexHttpClient {message: "Failed to serialize request".to_string(),detail: Some(e.to_string()),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::Http,})?;self.attempt_post_http(&auth, &body_json, ctx, body.client_metadata.is_some())@@ -1701,6 +1739,7 @@ impl CodexHttpClient {message: "Failed to serialize request".to_string(),detail: Some(e.to_string()),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::Http,})?;self.attempt_post_http(@@ -1733,12 +1772,24 @@ impl CodexHttpClient {message: "Unauthorized".to_string(),detail: Some(e.to_string()),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::Http,});}}}+ if let Ok(response) = &result+ && let Some(limit) =+ super::events::usage_limit_from_response(&response.body, &response.headers)+ {+ let origin = match response.transport {+ ActualTransport::Http => CodexErrorOrigin::BufferedHttp,+ ActualTransport::WebSocket => CodexErrorOrigin::BufferedWebSocket,+ };+ return Err(codex_usage_limit_error(limit, origin));+ }+if let Ok(response) = &result&& (200..300).contains(&response.status)&& let Some(failure) = super::events::first_retryable_failure(&response.body)@@ -1752,6 +1803,7 @@ impl CodexHttpClient {message: failure.message.clone(),detail: Some(failure.message),retry_after: failure.retry_after,+ usage_limit: None,origin: match response.transport {ActualTransport::Http => CodexErrorOrigin::BufferedHttp,ActualTransport::WebSocket => CodexErrorOrigin::BufferedWebSocket,@@ -1785,6 +1837,7 @@ impl CodexHttpClient {message: failure.message.clone(),detail: Some(failure.message),retry_after: failure.retry_after,+ usage_limit: None,origin: CodexErrorOrigin::Http,});}@@ -1797,6 +1850,7 @@ impl CodexHttpClient {message: "Unauthorized".to_string(),detail: Some(detail),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::Http,});}@@ -1807,6 +1861,7 @@ impl CodexHttpClient {message: "Forbidden".to_string(),detail: Some(detail),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::Http,});}@@ -1826,6 +1881,7 @@ impl CodexHttpClient {message: "Rate limited".to_string(),detail: Some(detail),retry_after,+ usage_limit: None,origin: CodexErrorOrigin::Http,});}@@ -1855,6 +1911,7 @@ impl CodexHttpClient {message: "Rate limited".to_string(),detail: Some(detail),retry_after,+ usage_limit: None,origin: CodexErrorOrigin::Http,});}@@ -1962,6 +2019,7 @@ impl CodexHttpClient {message: "Auth error".to_string(),detail: Some(e.to_string()),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::Auth,})?;@@ -2320,6 +2378,7 @@ impl CodexHttpClient {),detail: None,retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::Http,})?.map_err(|e| {@@ -2329,6 +2388,7 @@ impl CodexHttpClient {message: format!("Transport error: {e}"),detail: None,retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::Http,}} else {@@ -2337,6 +2397,7 @@ impl CodexHttpClient {message: format!("Network error: {e}"),detail: None,retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::Http,}}@@ -2374,6 +2435,7 @@ impl CodexHttpClient {),detail: Some("http_response_body".to_string()),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::Http,})?.map_err(|e| CodexError {@@ -2381,6 +2443,7 @@ impl CodexHttpClient {message: format!("Transport error reading Codex response body: {e}"),detail: Some("http_response_body".to_string()),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::Http,})?;@@ -2445,6 +2508,7 @@ impl CodexHttpClient {),detail: None,retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::Http,})?.map_err(|e| CodexError {@@ -2452,6 +2516,7 @@ impl CodexHttpClient {message: format!("Codex search network error: {e}"),detail: None,retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::Http,})?;@@ -2482,6 +2547,7 @@ impl CodexHttpClient {),detail: Some("http_response_body".to_string()),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::Http,})?.map_err(|e| CodexError {@@ -2489,6 +2555,7 @@ impl CodexHttpClient {message: format!("Transport error reading Codex search response body: {e}"),detail: Some("http_response_body".to_string()),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::Http,})?;let Some(chunk) = chunk else {@@ -2540,11 +2607,26 @@ fn codex_event_failure_error(failure: super::events::CodexEventFailure) -> Codexmessage: failure.message.clone(),detail: Some(failure.message),retry_after: failure.retry_after,+ usage_limit: None,origin: CodexErrorOrigin::Http,}}+fn codex_usage_limit_error(limit: CodexUsageLimit, origin: CodexErrorOrigin) -> CodexError {+ CodexError {+ status: 429,+ message: limit.message.clone(),+ detail: Some(limit.message.clone()),+ retry_after: None,+ usage_limit: Some(Box::new(limit)),+ origin,+ }+}+fn retryable_http_stream_error(error: &CodexError) -> bool {+ if error.usage_limit.is_some() {+ return false;+ }if should_retry_codex_status(error.status) || is_retryable_transport_error(error) {return true;}@@ -2754,11 +2836,14 @@ fn auth_refresh_error(err: anyhow::Error) -> CodexError {message: "Unauthorized".to_string(),detail: Some(err.to_string()),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::Auth,}}fn codex_status_error(response: CodexResponse) -> CodexError {+ let usage_limit =+ super::events::usage_limit_from_response(&response.body, &response.headers).map(Box::new);let retry_after = response.headers.iter()@@ -2775,6 +2860,7 @@ fn codex_status_error(response: CodexResponse) -> CodexError {message: message.clone(),detail: Some(message),retry_after,+ usage_limit,origin: match response.transport {ActualTransport::Http => CodexErrorOrigin::BufferedHttp,ActualTransport::WebSocket => CodexErrorOrigin::BufferedWebSocket,@@ -4844,6 +4930,7 @@ mod tests {message: "Rate limited".to_string(),detail: Some("body".to_string()),retry_after: Some("5".to_string()),+ usage_limit: None,origin: CodexErrorOrigin::Http,};let display = format!("{err}");@@ -4858,6 +4945,7 @@ mod tests {message: "WebSocket connect error".to_string(),detail: Some("websocket_pre_request".to_string()),retry_after: Some("3".to_string()),+ usage_limit: None,origin: CodexErrorOrigin::WebSocket,};@@ -4873,6 +4961,7 @@ mod tests {super::super::websocket::WEBSOCKET_PROXY_TUNNEL_REJECTED_DETAIL.to_string(),),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocketHandshake,};@@ -4887,6 +4976,7 @@ mod tests {message: "WebSocket connect timeout after 15000ms".to_string(),detail: Some("websocket_pre_request".to_string()),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocket,};@@ -4900,6 +4990,7 @@ mod tests {message: "WebSocket connect error".to_string(),detail: Some("websocket_pre_request".to_string()),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocket,};@@ -4914,6 +5005,7 @@ mod tests {.to_string(),detail: None,retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocket,};@@ -4927,6 +5019,7 @@ mod tests {message: "WebSocket keepalive error: test write failed".to_string(),detail: Some(super::super::websocket::WEBSOCKET_KEEPALIVE_FAILURE_DETAIL.to_string()),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocket,};@@ -4941,6 +5034,7 @@ mod tests {message: "WebSocket stream error: IO error: Broken pipe (os error 32)".to_string(),detail: None,retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocket,};@@ -5199,6 +5293,7 @@ mod tests {message: "WebSocket connect error".to_string(),detail: None,retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocket,});let forbidden = Err(CodexError {@@ -5206,6 +5301,7 @@ mod tests {message: "Forbidden".to_string(),detail: None,retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocket,});let rejected_handshake = Err(CodexError {@@ -5213,6 +5309,7 @@ mod tests {message: "WebSocket connect error".to_string(),detail: Some("policy denied".to_string()),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocketHandshake,});let rejected_handshake_err = match &rejected_handshake {@@ -5301,6 +5398,7 @@ mod tests {super::super::websocket::WEBSOCKET_RESPONSE_START_TIMEOUT_DETAIL.to_string(),),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocket,};let missing = CodexError {@@ -5308,6 +5406,7 @@ mod tests {message: "Previous response not found".to_string(),detail: Some("previous_response_not_found".to_string()),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocket,};let idle = CodexError {@@ -5315,6 +5414,7 @@ mod tests {message: "WebSocket idle timeout after 60000ms".to_string(),detail: None,retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocket,};diff --git a/src/providers/codex/events.rs b/src/providers/codex/events.rsindex f400845..0c28755 100644--- a/src/providers/codex/events.rs+++ b/src/providers/codex/events.rs@@ -267,11 +267,9 @@ pub(crate) fn classify_event_failure(payload: &Value) -> Option<CodexEventFailur})}-/// Which upstream quota window ran out. Codex reports a 300 minute primary-/// window and a 10080 minute secondary one, which line up with the session and-/// weekly windows the Anthropic rate limit headers describe.+/// Which known upstream quota window ran out.#[derive(Debug, Clone, Copy, PartialEq, Eq)]-pub(crate) enum CodexLimitWindow {+pub enum CodexLimitWindow {FiveHour,SevenDay,}@@ -289,7 +287,7 @@ impl CodexLimitWindow {/// sends alongside it. Unlike a transient rate limit this does not clear on a/// backoff, so the reset time is the only useful thing to report.#[derive(Debug, Clone, PartialEq, Eq)]-pub(crate) struct CodexUsageLimit {+pub struct CodexUsageLimit {pub message: String,pub resets_at: Option<u64>,pub window: Option<CodexLimitWindow>,@@ -306,22 +304,46 @@ pub(crate) fn usage_limit_from_event(payload: &Value) -> Option<CodexUsageLimit>) {return None;}- let error = event_error(payload)?;+ usage_limit_from_payload(payload)+}- let resets_at = numeric_value(error.get("resets_at"));- let resets_in_seconds = numeric_value(error.get("resets_in_seconds"));- let is_usage_limit = error.get("type").and_then(Value::as_str) == Some("usage_limit_reached")- || (numeric_status(payload) == Some(429)- && (resets_at.is_some() || resets_in_seconds.is_some()));- if !is_usage_limit {+/// Read quota exhaustion from either a JSON error response or an SSE event+/// body. HTTP response headers are included because Codex does not always+/// mirror its quota clocks into the error payload.+pub(crate) fn usage_limit_from_response(+ body: &[u8],+ headers: &[(String, String)],+) -> Option<CodexUsageLimit> {+ let direct = serde_json::from_slice::<Value>(body).ok().into_iter();+ let events = crate::anthropic::sse::parse_sse_events(body)+ .into_iter()+ .filter_map(|event| serde_json::from_str::<Value>(&event.data).ok());+ direct.chain(events).find_map(|mut payload| {+ attach_response_headers(&mut payload, headers);+ usage_limit_from_payload(&payload)+ })+}++fn usage_limit_from_payload(payload: &Value) -> Option<CodexUsageLimit> {+ let error = event_error(payload)?;+ if error.get("type").and_then(Value::as_str) != Some("usage_limit_reached") {return None;}- let limiting = limiting_window(payload, resets_in_seconds);+ let resets_at = numeric_value(error.get("resets_at"));+ let resets_in_seconds = numeric_value(error.get("resets_in_seconds"));+ let limiting_prefix = limiting_window_prefix(payload, resets_in_seconds);let resets_at = resets_at.or_else(|| {- let (prefix, _) = limiting?;+ let prefix = limiting_prefix?;header_number(payload, &format!("X-Codex-{prefix}-Reset-At"))});+ let window = limiting_prefix.and_then(|prefix| {+ match header_number(payload, &format!("X-Codex-{prefix}-Window-Minutes")) {+ Some(300) => Some(CodexLimitWindow::FiveHour),+ Some(10_080) => Some(CodexLimitWindow::SevenDay),+ _ => None,+ }+ });Some(CodexUsageLimit {message: error@@ -330,40 +352,47 @@ pub(crate) fn usage_limit_from_event(payload: &Value) -> Option<CodexUsageLimit>.unwrap_or("Usage limit reached").to_string(),resets_at,- window: limiting.map(|(_, window)| window),+ window,})}/// Codex sends the clock for both windows on every limit error, so the one that-/// actually ran out is the one whose countdown matches the error's own. Returns-/// the header prefix naming that window along with the window itself.-fn limiting_window(- payload: &Value,- resets_in_seconds: Option<u64>,-) -> Option<(&'static str, CodexLimitWindow)> {+/// actually ran out is the one whose countdown matches the error's own.+fn limiting_window_prefix(payload: &Value, resets_in_seconds: Option<u64>) -> Option<&'static str> {let primary = header_number(payload, "X-Codex-Primary-Reset-After-Seconds");let secondary = header_number(payload, "X-Codex-Secondary-Reset-After-Seconds");- let secondary_is_limiting = match (resets_in_seconds, primary, secondary) {+ match (resets_in_seconds, primary, secondary) {(Some(actual), Some(primary), Some(secondary)) => {- actual.abs_diff(secondary) < actual.abs_diff(primary)+ Some(if actual.abs_diff(secondary) < actual.abs_diff(primary) {+ "Secondary"+ } else {+ "Primary"+ })}- (_, None, Some(_)) => true,- _ => false,- };- let prefix = if secondary_is_limiting {- "Secondary"- } else {- "Primary"- };+ (_, Some(_), _) => Some("Primary"),+ (_, None, Some(_)) => Some("Secondary"),+ _ => None,+ }+}- // A 300 minute window is the five hour one; anything longer is the weekly.- let minutes = header_number(payload, &format!("X-Codex-{prefix}-Window-Minutes"))?;- let window = if minutes <= 360 {- CodexLimitWindow::FiveHour- } else {- CodexLimitWindow::SevenDay+fn attach_response_headers(payload: &mut Value, headers: &[(String, String)]) {+ let Some(payload) = payload.as_object_mut() else {+ return;+ };+ let header_values = payload+ .entry("headers")+ .or_insert_with(|| Value::Object(serde_json::Map::new()));+ let Some(header_values) = header_values.as_object_mut() else {+ return;};- Some((prefix, window))+ for (name, value) in headers {+ if !header_values+ .keys()+ .any(|present| present.eq_ignore_ascii_case(name))+ {+ header_values.insert(name.clone(), Value::String(value.clone()));+ }+ }}fn header_number(payload: &Value, name: &str) -> Option<u64> {@@ -514,7 +543,12 @@ mod tests {usage_limit_from_event(&serde_json::json!({"type": "error","status_code": 429,- "error": {"type": "rate_limit_exceeded", "message": "slow down"}+ "error": {+ "type": "rate_limit_exceeded",+ "message": "slow down",+ "resets_at": 1788879437u64,+ "resets_in_seconds": 60+ }})).is_none());@@ -527,6 +561,45 @@ mod tests {);}+ #[test]+ fn omits_claim_for_unknown_window_duration() {+ let mut payload = spent_five_hour_window();+ payload["headers"]["X-Codex-Primary-Window-Minutes"] = serde_json::json!(60);+ let limit = usage_limit_from_event(&payload).expect("usage limit");+ assert_eq!(limit.resets_at, Some(1788879437));+ assert_eq!(limit.window, None);+ }++ #[test]+ fn reads_usage_limit_from_http_body_and_headers() {+ let body = serde_json::to_vec(&serde_json::json!({+ "error": {+ "type": "usage_limit_reached",+ "message": "weekly limit reached",+ "resets_in_seconds": 90+ }+ }))+ .unwrap();+ let headers = vec![+ (+ "x-codex-secondary-reset-after-seconds".to_string(),+ "90".to_string(),+ ),+ (+ "x-codex-secondary-reset-at".to_string(),+ "1789466238".to_string(),+ ),+ (+ "x-codex-secondary-window-minutes".to_string(),+ "10080".to_string(),+ ),+ ];+ let limit = usage_limit_from_response(&body, &headers).expect("usage limit");+ assert_eq!(limit.message, "weekly limit reached");+ assert_eq!(limit.resets_at, Some(1789466238));+ assert_eq!(limit.window, Some(CodexLimitWindow::SevenDay));+ }+#[test]fn classifies_retryable_failure_kinds() {let overload = classify_event_failure(&serde_json::json!({diff --git a/src/providers/codex/mod.rs b/src/providers/codex/mod.rsindex 435757f..ccaadc5 100644--- a/src/providers/codex/mod.rs+++ b/src/providers/codex/mod.rs@@ -987,6 +987,7 @@ async fn live_stream_response_once(message: "WebSocket connection closed before terminal Codex response event".to_string(),detail: Some(websocket::WEBSOCKET_MISSING_TERMINAL_DETAIL.to_string()),retry_after: None,+ usage_limit: None,origin: client::CodexErrorOrigin::WebSocket,},)@@ -998,6 +999,7 @@ fn empty_live_completion_error() -> client::CodexError {message: "Codex completed without producing output".to_string(),detail: Some(EMPTY_CODEX_COMPLETION_DETAIL.to_string()),retry_after: None,+ usage_limit: None,origin: client::CodexErrorOrigin::WebSocket,}}@@ -1259,6 +1261,7 @@ fn empty_buffered_completion_error() -> client::CodexError {message: "Codex completed without producing output".to_string(),detail: Some(EMPTY_CODEX_COMPLETION_DETAIL.to_string()),retry_after: None,+ usage_limit: None,origin: match config::codex_transport() {config::CodexTransport::Http => client::CodexErrorOrigin::BufferedHttp,_ => client::CodexErrorOrigin::BufferedWebSocket,@@ -1359,6 +1362,7 @@ fn codex_event_failure_error(message: failure.message.clone(),detail: Some(failure.message.clone()),retry_after: failure.retry_after.clone(),+ usage_limit: None,origin,}}@@ -1459,6 +1463,9 @@ fn usage_limit_response(limit: &events::CodexUsageLimit) -> Response {}fn map_codex_error_to_response(err: &client::CodexError) -> Response {+ if let Some(limit) = err.usage_limit.as_ref() {+ return usage_limit_response(limit);+ }let message = codex_error_message(err);if is_context_window_overflow(message) {return map_codex_failure_to_response(message);@@ -2096,6 +2103,7 @@ mod tests {message: "invalid request".to_string(),detail: Some("invalid request".to_string()),retry_after: Some("7".to_string()),+ usage_limit: None,origin: client::CodexErrorOrigin::WebSocketHandshake,};let response = map_codex_error_to_response(&err);@@ -2113,6 +2121,7 @@ mod tests {message: "WebSocket connect error: HTTP error: 502 Bad Gateway".to_string(),detail: None,retry_after: None,+ usage_limit: None,origin: client::CodexErrorOrigin::WebSocket,};@@ -2148,6 +2157,7 @@ mod tests {message: "WebSocket connect timeout after 15000ms".to_string(),detail: None,retry_after: None,+ usage_limit: None,origin: client::CodexErrorOrigin::WebSocketHandshake,};@@ -2161,6 +2171,7 @@ mod tests {message: "WebSocket proxy tunnel was rejected".to_string(),detail: Some(websocket::WEBSOCKET_PROXY_TUNNEL_REJECTED_DETAIL.to_string()),retry_after: None,+ usage_limit: None,origin: client::CodexErrorOrigin::WebSocketHandshake,};@@ -2174,6 +2185,7 @@ mod tests {message: "WebSocket keepalive error: test write failed".to_string(),detail: Some(websocket::WEBSOCKET_KEEPALIVE_FAILURE_DETAIL.to_string()),retry_after: None,+ usage_limit: None,origin: client::CodexErrorOrigin::WebSocket,};@@ -2209,7 +2221,7 @@ mod tests {session_id: &str,event: serde_json::Value,expected_attempts: usize,- ) -> StatusCode {+ ) -> Response {let owner = ConversationIdentity::Main(session_id.to_string());continuation::clear_continuation_for_owner(Some(&owner));websocket::invalidate_codex_websocket_pool_owner(&owner);@@ -2259,7 +2271,54 @@ mod tests {Vec::new()));websocket::invalidate_codex_websocket_pool_owner(&owner);- response.status()+ response+ }++ #[tokio::test]+ async fn usage_limit_fast_fails_websocket_and_aborts_request_state() {+ let _registry_guard = continuation::lock_continuation_registry_for_async_tests().await;+ let _pool_guard = websocket::lock_codex_websocket_pool_for_tests().await;+ let response = run_live_failure_case(+ "live-usage-limit-cleanup",+ serde_json::json!({+ "type": "error",+ "status_code": 429,+ "error": {+ "type": "usage_limit_reached",+ "message": "The usage limit has been reached",+ "resets_at": 1788879437u64,+ "resets_in_seconds": 9568+ },+ "headers": {+ "X-Codex-Primary-Window-Minutes": "300",+ "X-Codex-Primary-Reset-After-Seconds": "9569",+ "X-Codex-Secondary-Window-Minutes": "10080",+ "X-Codex-Secondary-Reset-After-Seconds": "596369"+ }+ }),+ 1,+ )+ .await;++ assert_eq!(response.status(), StatusCode::TOO_MANY_REQUESTS);+ assert_eq!(response.headers()["x-should-retry"], "false");+ assert_eq!(+ response.headers()["anthropic-ratelimit-unified-status"],+ "rejected"+ );+ assert_eq!(+ response.headers()["anthropic-ratelimit-unified-reset"],+ "1788879437"+ );+ assert_eq!(+ response.headers()["anthropic-ratelimit-unified-representative-claim"],+ "five_hour"+ );+ assert!(!response.headers().contains_key(http::header::RETRY_AFTER));+ let body = response.into_body().collect().await.unwrap().to_bytes();+ let body: serde_json::Value = serde_json::from_slice(&body).unwrap();+ assert_eq!(body["error"]["type"], "rate_limit_error");+ assert_eq!(body["error"]["message"], "The usage limit has been reached");}#[tokio::test]@@ -2470,7 +2529,8 @@ mod tests {}),11,)- .await;+ .await+ .status();assert_eq!(status, StatusCode::TOO_MANY_REQUESTS);}@@ -2494,7 +2554,8 @@ mod tests {}),1,)- .await;+ .await+ .status();assert_eq!(status, StatusCode::TOO_MANY_REQUESTS);}@@ -2517,7 +2578,8 @@ mod tests {}),1,)- .await;+ .await+ .status();assert_eq!(status, StatusCode::BAD_REQUEST);}diff --git a/src/providers/codex/websocket.rs b/src/providers/codex/websocket.rsindex 9e0d33f..3e36941 100644--- a/src/providers/codex/websocket.rs+++ b/src/providers/codex/websocket.rs@@ -210,6 +210,7 @@ impl WebSocketProxyConfig {message: error.message,detail: None,retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocketHandshake,})?;if !http_url.starts_with("https://") {@@ -749,6 +750,7 @@ pub(super) async fn codex_websocket_request(message: e.message,detail: None,retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocketHandshake,})?;let body_json = serde_json::to_string(body_value).unwrap_or_default();@@ -836,6 +838,7 @@ pub(super) async fn codex_websocket_request(message: format!("WebSocket send error: {error}"),detail: None,retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocket,}})?;@@ -874,6 +877,7 @@ pub(super) async fn codex_websocket_request(message: "Previous response not found".to_string(),detail: Some("previous_response_not_found".to_string()),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocket,});}@@ -974,6 +978,7 @@ pub(super) async fn prepare_codex_websocket(message: error.message,detail: None,retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocketHandshake,})?;let requires_origin = continuation@@ -1025,6 +1030,7 @@ fn pooled_validation_error(detail: String) -> CodexError {message: format!("WebSocket pooled connection validation failed: {detail}"),detail: None,retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocketHandshake,}}@@ -1074,6 +1080,7 @@ pub(super) fn start_codex_websocket_events(message: format!("WebSocket send error: {error}"),detail: None,retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocket,})).await;@@ -1123,6 +1130,7 @@ pub(super) async fn codex_websocket_event_stream(message: "Failed to serialize WebSocket request".to_string(),detail: Some(error.to_string()),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocketHandshake,})?;let ready = prepare_codex_websocket(@@ -1151,6 +1159,7 @@ fn continuation_socket_missing_error() -> CodexError {message: "Previous response socket is no longer available".to_string(),detail: Some(WEBSOCKET_CONTINUATION_SOCKET_MISSING_DETAIL.to_string()),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocketHandshake,}}@@ -1161,6 +1170,7 @@ fn missing_terminal_error() -> CodexError {message: "WebSocket connection closed before terminal Codex response event".to_string(),detail: Some(WEBSOCKET_MISSING_TERMINAL_DETAIL.to_string()),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocket,}}@@ -1171,6 +1181,7 @@ fn response_start_timeout_error(timeout_ms: u64) -> CodexError {message: format!("WebSocket response start timeout after {timeout_ms}ms"),detail: Some(WEBSOCKET_RESPONSE_START_TIMEOUT_DETAIL.to_string()),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocket,}}@@ -1288,6 +1299,7 @@ fn websocket_protocol_error(message: &str) -> CodexError {message: message.to_string(),detail: None,retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocketHandshake,}}@@ -1420,6 +1432,7 @@ fn reqwest_handshake_error(error: reqwest::Error) -> CodexError {message: message.to_string(),detail: proxy_tunnel_rejected.then(|| WEBSOCKET_PROXY_TUNNEL_REJECTED_DETAIL.to_string()),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocketHandshake,}}@@ -1516,6 +1529,7 @@ fn tunnel_error(status: u16, retry_after: Option<String>) -> CodexError {Some(WEBSOCKET_PROXY_TUNNEL_REJECTED_DETAIL.to_string())},retry_after,+ usage_limit: None,origin: CodexErrorOrigin::WebSocketHandshake,}}@@ -1526,6 +1540,7 @@ fn invalid_tunnel_response(message: &str) -> CodexError {message: message.to_string(),detail: Some(WEBSOCKET_PROXY_TUNNEL_REJECTED_DETAIL.to_string()),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocketHandshake,}}@@ -1591,6 +1606,7 @@ async fn establish_connect_tunnel(message: "WebSocket proxy tunnel request failed".to_string(),detail: None,retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocketHandshake,})?;@@ -1649,6 +1665,7 @@ async fn tls_connect(message: format!("WebSocket TLS connection to {peer} failed"),detail: None,retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocketHandshake,})?;Ok(Box::new(stream))@@ -1675,6 +1692,7 @@ async fn connect_to_http_proxy(message: "WebSocket proxy connection failed".to_string(),detail: None,retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocketHandshake,})?;let stream: BoxedWebSocketIo = Box::new(stream);@@ -1719,6 +1737,7 @@ fn tungstenite_handshake_error(error: tokio_tungstenite::tungstenite::Error) ->message: format!("WebSocket upgrade rejected with status {status}"),detail: Some(GENERIC_HANDSHAKE_ERROR_DETAIL.to_string()),retry_after,+ usage_limit: None,origin: CodexErrorOrigin::WebSocketHandshake,};}@@ -1727,6 +1746,7 @@ fn tungstenite_handshake_error(error: tokio_tungstenite::tungstenite::Error) ->message: "WebSocket upgrade request failed".to_string(),detail: None,retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocketHandshake,}}@@ -1800,6 +1820,7 @@ async fn connect_via_http_upgrade(message: error.message,detail: None,retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocketHandshake,})?;let websocket_key = generate_key();@@ -1838,6 +1859,7 @@ async fn connect_via_http_upgrade(message: format!("WebSocket upgrade rejected with status {status}"),detail: Some(detail),retry_after,+ usage_limit: None,origin: CodexErrorOrigin::WebSocketHandshake,});}@@ -2046,6 +2068,7 @@ wheremessage: format!("WebSocket idle timeout after {idle_timeout_ms}ms"),detail: None,retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocket,});}@@ -2070,6 +2093,7 @@ wheremessage: format!("WebSocket idle timeout after {idle_timeout_ms}ms"),detail: None,retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocket,}} else {@@ -2083,6 +2107,7 @@ wheremessage: format!("WebSocket keepalive error: {error}"),detail: Some(WEBSOCKET_KEEPALIVE_FAILURE_DETAIL.to_string()),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocket,});}@@ -2141,6 +2166,7 @@ wheremessage: "WebSocket binary frames not supported".to_string(),detail: None,retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocket,});}@@ -2169,6 +2195,7 @@ wheremessage: format!("WebSocket stream error: {e}"),detail: None,retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocket,});}@@ -2218,6 +2245,7 @@ wheremessage: format!("WebSocket idle timeout after {idle_timeout_ms}ms"),detail: None,retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocket,}} else {@@ -2243,6 +2271,7 @@ wheremessage: format!("WebSocket idle timeout after {idle_timeout_ms}ms"),detail: None,retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocket,}} else {@@ -2256,6 +2285,7 @@ wheremessage: format!("WebSocket keepalive error: {error}"),detail: None,retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocket,}));break;@@ -2302,6 +2332,7 @@ wheremessage: "Previous response not found".to_string(),detail: Some("previous_response_not_found".to_string()),retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocket,}));} else {@@ -2322,6 +2353,7 @@ wheremessage: "WebSocket binary frames not supported".to_string(),detail: None,retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocket,}));break;@@ -2340,6 +2372,7 @@ wheremessage: format!("WebSocket stream error: {error}"),detail: None,retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocket,}));break;@@ -2466,6 +2499,7 @@ mod tests {message: format!("handshake failed with status {status}"),detail: None,retry_after: None,+ usage_limit: None,origin: CodexErrorOrigin::WebSocketHandshake,}}@@ -2752,6 +2786,7 @@ mod tests {message: "second forbidden".to_string(),detail: Some("second-detail".to_string()),retry_after: Some("7".to_string()),+ usage_limit: None,origin: CodexErrorOrigin::WebSocketHandshake,}))}diff --git a/tests/smoke_cutover.rs b/tests/smoke_cutover.rsindex d32aae1..a07f970 100644--- a/tests/smoke_cutover.rs+++ b/tests/smoke_cutover.rs@@ -197,6 +197,38 @@ whereaddr_str}+async fn spawn_auto_fallback_usage_limit_upstream(+ websocket_attempts: Arc<AtomicUsize>,+ http_attempts: Arc<AtomicUsize>,+) -> String {+ let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();+ let addr = listener.local_addr().unwrap();+ let app = axum::Router::new().fallback(move |request: axum::extract::Request| {+ let websocket_attempts = websocket_attempts.clone();+ let http_attempts = http_attempts.clone();+ async move {+ if request.headers().contains_key(http::header::UPGRADE) {+ websocket_attempts.fetch_add(1, Ordering::SeqCst);+ http::Response::builder()+ .status(StatusCode::BAD_REQUEST)+ .body(Body::empty())+ .unwrap()+ } else {+ http_attempts.fetch_add(1, Ordering::SeqCst);+ http::Response::builder()+ .status(StatusCode::OK)+ .header("content-type", "text/event-stream")+ .body(Body::from(codex_usage_limit_sse("usage_limit_reached")))+ .unwrap()+ }+ }+ });+ tokio::spawn(async move {+ axum::serve(listener, app).await.ok();+ });+ format!("http://{addr}")+}+async fn spawn_truncated_http_upstream(body: &'static [u8]) -> String {let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();let addr = listener.local_addr().unwrap();@@ -399,6 +431,22 @@ async fn spawn_websocket_upstream(captured: Arc<Mutex<Option<Value>>>) -> Stringaddr_str}+async fn spawn_websocket_usage_limit_upstream(attempts: Arc<AtomicUsize>) -> String {+ let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();+ let addr = listener.local_addr().unwrap();+ tokio::spawn(async move {+ if let Ok((stream, _)) = listener.accept().await+ && let Ok(mut websocket) = tokio_tungstenite::accept_async(stream).await+ {+ let _ = websocket.next().await;+ attempts.fetch_add(1, Ordering::SeqCst);+ let event = codex_usage_limit_event("usage_limit_reached");+ let _ = websocket.send(Message::Text(event.to_string())).await;+ }+ });+ format!("http://{addr}")+}+/// Reproduce the Codex subscription-credit response observed in production:/// the included window is exhausted, but usable credits remain and the model/// still completes the response after the rate-limit snapshot.@@ -1106,6 +1154,53 @@ fn empty_message_completion_sse() -> Vec<u8> {.to_vec()}+fn codex_usage_limit_event(error_type: &str) -> Value {+ json!({+ "type": "error",+ "status_code": 429,+ "error": {+ "type": error_type,+ "message": "The usage limit has been reached",+ "resets_at": 1788879437u64,+ "resets_in_seconds": 9568+ },+ "headers": {+ "X-Codex-Primary-Window-Minutes": "300",+ "X-Codex-Primary-Reset-After-Seconds": "9569",+ "X-Codex-Secondary-Window-Minutes": "10080",+ "X-Codex-Secondary-Reset-After-Seconds": "596369"+ }+ })+}++fn codex_usage_limit_sse(error_type: &str) -> Vec<u8> {+ format!("data: {}\n\n", codex_usage_limit_event(error_type)).into_bytes()+}++async fn assert_usage_limit_response(response: Response) {+ assert_eq!(response.status(), StatusCode::TOO_MANY_REQUESTS);+ assert_eq!(response.headers()["x-should-retry"], "false");+ assert_eq!(+ response.headers()["anthropic-ratelimit-unified-status"],+ "rejected"+ );+ assert_eq!(+ response.headers()["anthropic-ratelimit-unified-reset"],+ "1788879437"+ );+ assert_eq!(+ response.headers()["anthropic-ratelimit-unified-representative-claim"],+ "five_hour"+ );+ assert!(!response.headers().contains_key(http::header::RETRY_AFTER));+ let body = axum::body::to_bytes(response.into_body(), usize::MAX)+ .await+ .unwrap();+ let body: Value = serde_json::from_slice(&body).unwrap();+ assert_eq!(body["error"]["type"], "rate_limit_error");+ assert_eq!(body["error"]["message"], "The usage limit has been reached");+}+fn buffered_success_sse(text: &str) -> Vec<u8> {format!(concat!(@@ -1119,6 +1214,66 @@ fn buffered_success_sse(text: &str) -> Vec<u8> {.into_bytes()}+#[allow(clippy::await_holding_lock)]+#[tokio::test]+async fn smoke_codex_http_usage_limit_event_fast_fails_live_request() {+ let _guard = env_lock();+ clear_all_continuations_for_tests();+ let config = TempDir::new().unwrap();+ write_auth(config.path(), "codex");++ let attempts = Arc::new(AtomicUsize::new(0));+ let upstream = spawn_http_upstream({+ let attempts = attempts.clone();+ move |_body: Value| {+ attempts.fetch_add(1, Ordering::SeqCst);+ codex_usage_limit_sse("usage_limit_reached")+ }+ })+ .await;++ let _config_env = EnvGuard::set("CCP_CONFIG_DIR", config.path());+ let _base_url_env = EnvGuard::set("CCP_CODEX_BASE_URL", &upstream);+ let _transport_env = EnvGuard::set("CCP_CODEX_TRANSPORT", "http");+ let response = call_messages_body(json!({+ "model": "gpt-5.5",+ "max_tokens": 64,+ "stream": true,+ "messages": [{"role":"user","content":"hello"}]+ }))+ .await;++ assert_eq!(attempts.load(Ordering::SeqCst), 1);+ assert_usage_limit_response(response).await;+}++#[allow(clippy::await_holding_lock)]+#[tokio::test]+async fn smoke_codex_http_usage_limit_event_fast_fails_buffered_request() {+ let _guard = env_lock();+ clear_all_continuations_for_tests();+ let config = TempDir::new().unwrap();+ write_auth(config.path(), "codex");++ let attempts = Arc::new(AtomicUsize::new(0));+ let upstream = spawn_http_upstream({+ let attempts = attempts.clone();+ move |_body: Value| {+ attempts.fetch_add(1, Ordering::SeqCst);+ codex_usage_limit_sse("usage_limit_reached")+ }+ })+ .await;++ let _config_env = EnvGuard::set("CCP_CONFIG_DIR", config.path());+ let _base_url_env = EnvGuard::set("CCP_CODEX_BASE_URL", &upstream);+ let _transport_env = EnvGuard::set("CCP_CODEX_TRANSPORT", "http");+ let response = call_messages("gpt-5.5").await;++ assert_eq!(attempts.load(Ordering::SeqCst), 1);+ assert_usage_limit_response(response).await;+}+#[allow(clippy::await_holding_lock)]#[tokio::test]async fn smoke_codex_http_retries_empty_completion() {@@ -1794,6 +1949,12 @@ async fn smoke_codex_http_retries_rate_limit_after_control_events() {.await;}+#[allow(clippy::await_holding_lock)]+#[tokio::test]+async fn smoke_codex_http_retries_transient_rate_limit_with_reset_clock() {+ assert_codex_http_presemantic_retry(codex_usage_limit_sse("rate_limit_exceeded")).await;+}+#[allow(clippy::await_holding_lock)]#[tokio::test]async fn smoke_codex_http_retries_transient_failure_after_control_events() {@@ -1979,6 +2140,63 @@ async fn smoke_codex_http_rate_limit_snapshot_does_not_end_response() {assert!(!text.contains("event: error"), "stream body: {text}");}+#[allow(clippy::await_holding_lock)]+#[tokio::test]+async fn smoke_codex_http_usage_limit_status_fast_fails_live_request() {+ let _guard = env_lock();+ clear_all_continuations_for_tests();+ let config = TempDir::new().unwrap();+ write_auth(config.path(), "codex");++ let attempts = Arc::new(AtomicUsize::new(0));+ let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();+ let addr = listener.local_addr().unwrap();+ let upstream = format!("http://{addr}");+ let mock = axum::Router::new().fallback({+ let attempts = attempts.clone();+ move || {+ let attempts = attempts.clone();+ async move {+ attempts.fetch_add(1, Ordering::SeqCst);+ http::Response::builder()+ .status(StatusCode::TOO_MANY_REQUESTS)+ .header("content-type", "application/json")+ .header("x-codex-primary-window-minutes", "300")+ .header("x-codex-primary-reset-after-seconds", "9568")+ .body(Body::from(+ json!({+ "error": {+ "type": "usage_limit_reached",+ "message": "The usage limit has been reached",+ "resets_at": 1788879437u64,+ "resets_in_seconds": 9568+ }+ })+ .to_string(),+ ))+ .unwrap()+ }+ }+ });+ tokio::spawn(async move {+ axum::serve(listener, mock).await.ok();+ });++ let _config_env = EnvGuard::set("CCP_CONFIG_DIR", config.path());+ let _base_url_env = EnvGuard::set("CCP_CODEX_BASE_URL", &upstream);+ let _transport_env = EnvGuard::set("CCP_CODEX_TRANSPORT", "http");+ let response = call_messages_body(json!({+ "model": "gpt-5.5",+ "max_tokens": 64,+ "stream": true,+ "messages": [{"role":"user","content":"hello"}]+ }))+ .await;++ assert_eq!(attempts.load(Ordering::SeqCst), 1);+ assert_usage_limit_response(response).await;+}+#[allow(clippy::await_holding_lock)]#[tokio::test]async fn smoke_codex_http_bounds_initial_status_retries() {@@ -2319,6 +2537,38 @@ async fn smoke_codex_http_truncated_upstream_writes_reducer_diagnostic() {);}+#[allow(clippy::await_holding_lock)]+#[tokio::test(flavor = "multi_thread")]+async fn smoke_codex_auto_fallback_usage_limit_fast_fails_live_request() {+ let _guard = env_lock();+ clear_all_continuations_for_tests();+ clear_codex_websocket_pool_for_tests();+ let config = TempDir::new().unwrap();+ write_auth(config.path(), "codex");++ let websocket_attempts = Arc::new(AtomicUsize::new(0));+ let http_attempts = Arc::new(AtomicUsize::new(0));+ let upstream =+ spawn_auto_fallback_usage_limit_upstream(websocket_attempts.clone(), http_attempts.clone())+ .await;++ let _config_env = EnvGuard::set("CCP_CONFIG_DIR", config.path());+ let _base_url_env = EnvGuard::set("CCP_CODEX_BASE_URL", &upstream);+ let _transport_env = EnvGuard::set("CCP_CODEX_TRANSPORT", "auto");+ let response = call_messages_body(json!({+ "model": "gpt-5.5",+ "max_tokens": 64,+ "stream": true,+ "messages": [{"role":"user","content":"hello"}]+ }))+ .await;++ assert_eq!(websocket_attempts.load(Ordering::SeqCst), 1);+ assert_eq!(http_attempts.load(Ordering::SeqCst), 1);+ assert_usage_limit_response(response).await;+ clear_codex_websocket_pool_for_tests();+}+// ---------------------------------------------------------------------------// Codex WebSocket smoke: mock upstream verifies request shape and returns// Responses events over WebSocket.@@ -2371,6 +2621,34 @@ async fn smoke_codex_websocket_messages_uses_mock_upstream() {assert!(sent.get("stream").is_none());}+#[allow(clippy::await_holding_lock)]+#[tokio::test(flavor = "multi_thread")]+async fn smoke_codex_websocket_usage_limit_fast_fails_request() {+ let _guard = env_lock();+ clear_all_continuations_for_tests();+ clear_codex_websocket_pool_for_tests();+ let config = TempDir::new().unwrap();+ write_auth(config.path(), "codex");++ let attempts = Arc::new(AtomicUsize::new(0));+ let upstream = spawn_websocket_usage_limit_upstream(attempts.clone()).await;+ let _config_env = EnvGuard::set("CCP_CONFIG_DIR", config.path());+ let _base_url_env = EnvGuard::set("CCP_CODEX_BASE_URL", &upstream);+ let _transport_env = EnvGuard::set("CCP_CODEX_TRANSPORT", "websocket");++ let response = call_messages_body(json!({+ "model": "gpt-5.5",+ "max_tokens": 64,+ "stream": true,+ "messages": [{"role":"user","content":"hello"}]+ }))+ .await;++ assert_eq!(attempts.load(Ordering::SeqCst), 1);+ assert_usage_limit_response(response).await;+ clear_codex_websocket_pool_for_tests();+}+#[allow(clippy::await_holding_lock)]#[tokio::test(flavor = "multi_thread")]async fn smoke_codex_websocket_uses_credits_after_included_limit() {