Skip to content

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.rs
index 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.rs
index 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, CodexError
message: 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) -> Codex
message: 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.rs
index 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.rs
index 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.rs
index 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 @@ where
message: format!("WebSocket idle timeout after {idle_timeout_ms}ms"),
detail: None,
retry_after: None,
+ usage_limit: None,
origin: CodexErrorOrigin::WebSocket,
});
}
@@ -2070,6 +2093,7 @@ where
message: 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 @@ where
message: 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 @@ where
message: "WebSocket binary frames not supported".to_string(),
detail: None,
retry_after: None,
+ usage_limit: None,
origin: CodexErrorOrigin::WebSocket,
});
}
@@ -2169,6 +2195,7 @@ where
message: format!("WebSocket stream error: {e}"),
detail: None,
retry_after: None,
+ usage_limit: None,
origin: CodexErrorOrigin::WebSocket,
});
}
@@ -2218,6 +2245,7 @@ where
message: 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 @@ where
message: 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 @@ where
message: format!("WebSocket keepalive error: {error}"),
detail: None,
retry_after: None,
+ usage_limit: None,
origin: CodexErrorOrigin::WebSocket,
}));
break;
@@ -2302,6 +2332,7 @@ where
message: "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 @@ where
message: "WebSocket binary frames not supported".to_string(),
detail: None,
retry_after: None,
+ usage_limit: None,
origin: CodexErrorOrigin::WebSocket,
}));
break;
@@ -2340,6 +2372,7 @@ where
message: 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.rs
index d32aae1..a07f970 100644
--- a/tests/smoke_cutover.rs
+++ b/tests/smoke_cutover.rs
@@ -197,6 +197,38 @@ where
addr_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>>>) -> String
addr_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() {