Skip to content

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

Rust

preserve quota metadata across http sse paths

Raine Virtae1af6be16c4c
diff --git a/src/providers/codex/client.rs b/src/providers/codex/client.rs
index e3a0d8e..e8f2aa0 100644
--- a/src/providers/codex/client.rs
+++ b/src/providers/codex/client.rs
@@ -374,6 +374,7 @@ struct DecodedHttpSseEvent {
struct HttpEventStreamState {
resp: reqwest::Response,
+ response_headers: Vec<(String, String)>,
started_at: Instant,
body_json: String,
auth: StoredAuth,
@@ -1165,7 +1166,7 @@ impl CodexHttpClient {
let mut auth_refresh_attempted = false;
let use_responses_lite = body.client_metadata.is_some();
let mut retries = 0_u32;
- let (resp, started_at) = loop {
+ let (resp, response_headers, started_at) = loop {
match self
.start_http_event_attempt(
&mut auth,
@@ -1195,6 +1196,7 @@ impl CodexHttpClient {
Ok(self.spawn_http_event_stream(
HttpEventStreamState {
resp,
+ response_headers,
started_at,
body_json,
auth,
@@ -1223,7 +1225,7 @@ impl CodexHttpClient {
ctx: &RequestContext,
use_responses_lite: bool,
auth_refresh_attempted: &mut bool,
- ) -> Result<(reqwest::Response, Instant), CodexError> {
+ ) -> Result<(reqwest::Response, Vec<(String, String)>, Instant), CodexError> {
loop {
let (resp, started_at) = self
.start_post_http(auth, body_json, ctx, use_responses_lite)
@@ -1256,7 +1258,7 @@ impl CodexHttpClient {
&headers,
);
}
- return Ok((resp, started_at));
+ return Ok((resp, headers, started_at));
}
}
@@ -1314,6 +1316,7 @@ impl CodexHttpClient {
) -> CodexHttpEventReceiver {
let HttpEventStreamState {
mut resp,
+ mut response_headers,
mut started_at,
body_json,
mut auth,
@@ -1490,7 +1493,10 @@ impl CodexHttpClient {
let event_kind = super::events::classify_stream_event(&payload);
let failure = super::events::classify_event_failure(&payload);
if !semantic_output_forwarded {
- if let Some(limit) = super::events::usage_limit_from_event(&payload) {
+ if let Some(limit) = super::events::usage_limit_from_event_with_headers(
+ &payload,
+ &response_headers,
+ ) {
pending_events.clear();
let _ = tx
.send(Err(codex_usage_limit_error(
@@ -1600,8 +1606,9 @@ impl CodexHttpClient {
) => result
};
match next_attempt {
- Ok((next_resp, next_started_at)) => {
+ Ok((next_resp, next_response_headers, next_started_at)) => {
resp = next_resp;
+ response_headers = next_response_headers;
started_at = next_started_at;
continue 'attempts;
}
@@ -3578,6 +3585,90 @@ mod tests {
server.await.unwrap();
}
+ #[tokio::test]
+ async fn http_stream_header_only_usage_limit_uses_response_headers() {
+ let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+ let addr = listener.local_addr().unwrap();
+ let server = tokio::spawn(async move {
+ let (mut stream, _) = listener.accept().await.unwrap();
+ read_http_request(&mut stream).await;
+ let body = br#"data: {"type":"error","status_code":429,"error":{"type":"usage_limit_reached","message":"weekly \"limit\" reached","resets_in_seconds":90}}
+
+"#;
+ let head = format!(
+ "HTTP/1.1 200 OK\r\ncontent-type: text/event-stream\r\nx-codex-secondary-reset-after-seconds: 90\r\nx-codex-secondary-reset-at: 1789466238\r\nx-codex-secondary-window-minutes: 10080\r\ncontent-length: {}\r\nconnection: close\r\n\r\n",
+ body.len()
+ );
+ stream.write_all(head.as_bytes()).await.unwrap();
+ stream.write_all(body).await.unwrap();
+ });
+
+ let client = Arc::new(http_test_client(format!("http://{addr}/responses"), 1_000));
+ client.auth_manager().set_test_auth(http_test_auth());
+ let mut events = client
+ .stream_codex_http_events(&buffered_test_request(), &http_test_context())
+ .await
+ .unwrap();
+
+ assert_eq!(
+ events.recv().await.unwrap().unwrap().get("type"),
+ Some(&serde_json::json!("keepalive"))
+ );
+ let error = events.recv().await.unwrap().unwrap_err();
+ assert_eq!(error.status, 429);
+ let limit = error.usage_limit.expect("usage limit");
+ assert_eq!(limit.message, "weekly \"limit\" reached");
+ assert_eq!(limit.resets_at, Some(1789466238));
+ assert_eq!(limit.window, Some(CodexLimitWindow::SevenDay));
+ server.await.unwrap();
+ }
+
+ #[tokio::test]
+ async fn http_stream_retries_with_current_attempt_headers() {
+ let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+ let addr = listener.local_addr().unwrap();
+ let server = tokio::spawn(async move {
+ for attempt in 0..2 {
+ let (mut stream, _) = listener.accept().await.unwrap();
+ read_http_request(&mut stream).await;
+ let (body, headers) = if attempt == 0 {
+ (
+ br#"data: {"type":"response.failed","status_code":503,"error":{"message":"server error","retry_after":"0"}}
+
+"#.as_slice(),
+ "",
+ )
+ } else {
+ (
+ br#"data: {"type":"error","status_code":429,"error":{"type":"usage_limit_reached","message":"weekly limit reached","resets_in_seconds":90}}
+
+"#.as_slice(),
+ "x-codex-secondary-reset-after-seconds: 90\r\nx-codex-secondary-reset-at: 1789466238\r\nx-codex-secondary-window-minutes: 10080\r\n",
+ )
+ };
+ let head = format!(
+ "HTTP/1.1 200 OK\r\ncontent-type: text/event-stream\r\n{headers}content-length: {}\r\nconnection: close\r\n\r\n",
+ body.len()
+ );
+ stream.write_all(head.as_bytes()).await.unwrap();
+ stream.write_all(body).await.unwrap();
+ }
+ });
+
+ let client = Arc::new(http_test_client(format!("http://{addr}/responses"), 1_000));
+ client.auth_manager().set_test_auth(http_test_auth());
+ let mut events = client
+ .stream_codex_http_events(&buffered_test_request(), &http_test_context())
+ .await
+ .unwrap();
+ let _ = events.recv().await.unwrap().unwrap();
+ let error = events.recv().await.unwrap().unwrap_err();
+ let limit = error.usage_limit.expect("usage limit");
+ assert_eq!(limit.resets_at, Some(1789466238));
+ assert_eq!(limit.window, Some(CodexLimitWindow::SevenDay));
+ server.await.unwrap();
+ }
+
#[tokio::test]
async fn http_stream_bounds_initial_status_retries() {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
diff --git a/src/providers/codex/events.rs b/src/providers/codex/events.rs
index b19bcec..1c63740 100644
--- a/src/providers/codex/events.rs
+++ b/src/providers/codex/events.rs
@@ -307,6 +307,21 @@ pub(crate) fn usage_limit_from_event(payload: &Value) -> Option<CodexUsageLimit>
usage_limit_from_payload(payload)
}
+/// Read a quota exhaustion event while consulting the current HTTP response
+/// headers for metadata that is absent from the event payload.
+pub(crate) fn usage_limit_from_event_with_headers(
+ payload: &Value,
+ headers: &[(String, String)],
+) -> Option<CodexUsageLimit> {
+ if !matches!(
+ payload.get("type").and_then(Value::as_str),
+ Some("response.failed" | "response.error" | "error")
+ ) {
+ return None;
+ }
+ usage_limit_from_payload_with_headers(payload, headers)
+}
+
/// 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.
@@ -318,13 +333,31 @@ pub(crate) fn usage_limit_from_response(
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)
+ direct.chain(events).find_map(|payload| {
+ // Parse JSON before checking the event shape so escaped strings and all
+ // other valid JSON forms retain serde_json's normal semantics. Header
+ // lookup is only needed for an actual quota event.
+ is_usage_limit_payload(&payload)
+ .then(|| usage_limit_from_payload_with_headers(&payload, headers))
+ .flatten()
})
}
+fn is_usage_limit_payload(payload: &Value) -> bool {
+ event_error(payload)
+ .and_then(|error| error.get("type"))
+ .and_then(Value::as_str)
+ == Some("usage_limit_reached")
+}
+
fn usage_limit_from_payload(payload: &Value) -> Option<CodexUsageLimit> {
+ usage_limit_from_payload_with_headers(payload, &[])
+}
+
+fn usage_limit_from_payload_with_headers(
+ payload: &Value,
+ response_headers: &[(String, String)],
+) -> Option<CodexUsageLimit> {
let error = event_error(payload)?;
if error.get("type").and_then(Value::as_str) != Some("usage_limit_reached") {
return None;
@@ -332,13 +365,22 @@ fn usage_limit_from_payload(payload: &Value) -> Option<CodexUsageLimit> {
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, resets_at);
+ let limiting_prefix =
+ limiting_window_prefix(payload, response_headers, resets_in_seconds, resets_at);
let resets_at = resets_at.or_else(|| {
let prefix = limiting_prefix?;
- header_number(payload, &format!("X-Codex-{prefix}-Reset-At"))
+ header_number(
+ payload,
+ response_headers,
+ &format!("X-Codex-{prefix}-Reset-At"),
+ )
});
let window = limiting_prefix.and_then(|prefix| {
- match header_number(payload, &format!("X-Codex-{prefix}-Window-Minutes")) {
+ match header_number(
+ payload,
+ response_headers,
+ &format!("X-Codex-{prefix}-Window-Minutes"),
+ ) {
Some(300) => Some(CodexLimitWindow::FiveHour),
Some(10_080) => Some(CodexLimitWindow::SevenDay),
_ => None,
@@ -361,27 +403,36 @@ fn usage_limit_from_payload(payload: &Value) -> Option<CodexUsageLimit> {
/// error's own clock.
fn limiting_window_prefix(
payload: &Value,
+ response_headers: &[(String, String)],
resets_in_seconds: Option<u64>,
resets_at: Option<u64>,
) -> Option<&'static str> {
let by_countdown = resets_in_seconds.and_then(|actual| {
closest_window(
actual,
- header_number(payload, "X-Codex-Primary-Reset-After-Seconds"),
- header_number(payload, "X-Codex-Secondary-Reset-After-Seconds"),
+ header_number(
+ payload,
+ response_headers,
+ "X-Codex-Primary-Reset-After-Seconds",
+ ),
+ header_number(
+ payload,
+ response_headers,
+ "X-Codex-Secondary-Reset-After-Seconds",
+ ),
)
});
let by_epoch = resets_at.and_then(|actual| {
closest_window(
actual,
- header_number(payload, "X-Codex-Primary-Reset-At"),
- header_number(payload, "X-Codex-Secondary-Reset-At"),
+ header_number(payload, response_headers, "X-Codex-Primary-Reset-At"),
+ header_number(payload, response_headers, "X-Codex-Secondary-Reset-At"),
)
});
by_countdown.or(by_epoch).or_else(|| {
match (
- window_headers_present(payload, "Primary"),
- window_headers_present(payload, "Secondary"),
+ window_headers_present(payload, response_headers, "Primary"),
+ window_headers_present(payload, response_headers, "Secondary"),
) {
(true, false) => Some("Primary"),
(false, true) => Some("Secondary"),
@@ -413,39 +464,43 @@ fn closest_window(
}
}
-fn window_headers_present(payload: &Value, prefix: &str) -> bool {
+fn window_headers_present(
+ payload: &Value,
+ response_headers: &[(String, String)],
+ prefix: &str,
+) -> bool {
["Reset-After-Seconds", "Reset-At", "Window-Minutes"]
.into_iter()
- .any(|suffix| header_number(payload, &format!("X-Codex-{prefix}-{suffix}")).is_some())
-}
-
-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;
- };
- 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()));
- }
- }
+ .any(|suffix| {
+ header_number(
+ payload,
+ response_headers,
+ &format!("X-Codex-{prefix}-{suffix}"),
+ )
+ .is_some()
+ })
}
-fn header_number(payload: &Value, name: &str) -> Option<u64> {
+fn header_number(
+ payload: &Value,
+ response_headers: &[(String, String)],
+ name: &str,
+) -> Option<u64> {
payload
- .get("headers")?
- .as_object()?
- .iter()
- .find(|(key, _)| key.eq_ignore_ascii_case(name))
- .and_then(|(_, value)| numeric_value(Some(value)))
+ .get("headers")
+ .and_then(Value::as_object)
+ .and_then(|headers| {
+ headers
+ .iter()
+ .find(|(key, _)| key.eq_ignore_ascii_case(name))
+ .and_then(|(_, value)| numeric_value(Some(value)))
+ })
+ .or_else(|| {
+ response_headers
+ .iter()
+ .find(|(key, _)| key.eq_ignore_ascii_case(name))
+ .and_then(|(_, value)| value.parse().ok())
+ })
}
fn numeric_value(value: Option<&Value>) -> Option<u64> {
@@ -688,6 +743,47 @@ mod tests {
assert_eq!(limit.window, Some(CodexLimitWindow::SevenDay));
}
+ #[test]
+ fn parses_header_only_sse_quota_metadata_without_byte_matching() {
+ let body = br#"data: {"type":"error","error":{"type":"usage_limit_reached","message":"weekly \"limit\" reached","resets_in_seconds":90}}
+
+"#;
+ 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 ignores_quota_text_in_successful_buffered_events() {
+ let body = br#"data: {"type":"response.output_text.delta","delta":"the text says \"usage_limit_reached\" but is not an error"}
+
+data: {"type":"response.completed","response":{"status":"completed"}}
+
+"#;
+ let headers = vec![(
+ "X-Codex-Secondary-Window-Minutes".to_string(),
+ "10080".to_string(),
+ )];
+
+ assert!(usage_limit_from_response(body, &headers).is_none());
+ }
+
#[test]
fn classifies_retryable_failure_kinds() {
let overload = classify_event_failure(&serde_json::json!({
diff --git a/tests/smoke_cutover.rs b/tests/smoke_cutover.rs
index dfadb2e..ae393d4 100644
--- a/tests/smoke_cutover.rs
+++ b/tests/smoke_cutover.rs
@@ -218,7 +218,10 @@ async fn spawn_auto_fallback_usage_limit_upstream(
http::Response::builder()
.status(StatusCode::OK)
.header("content-type", "text/event-stream")
- .body(Body::from(codex_usage_limit_sse("usage_limit_reached")))
+ .header("x-codex-primary-reset-after-seconds", "90")
+ .header("x-codex-primary-reset-at", "1788879437")
+ .header("x-codex-primary-window-minutes", "300")
+ .body(Body::from(codex_header_only_usage_limit_sse()))
.unwrap()
}
}
@@ -1177,6 +1180,22 @@ fn codex_usage_limit_sse(error_type: &str) -> Vec<u8> {
format!("data: {}\n\n", codex_usage_limit_event(error_type)).into_bytes()
}
+fn codex_header_only_usage_limit_sse() -> Vec<u8> {
+ format!(
+ "data: {}\n\n",
+ json!({
+ "type": "error",
+ "status_code": 429,
+ "error": {
+ "type": "usage_limit_reached",
+ "message": "The usage limit has been reached",
+ "resets_in_seconds": 90
+ }
+ })
+ )
+ .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");
@@ -1247,6 +1266,53 @@ async fn smoke_codex_http_usage_limit_event_fast_fails_live_request() {
assert_usage_limit_response(response).await;
}
+#[allow(clippy::await_holding_lock)]
+#[tokio::test]
+async fn smoke_codex_http_header_only_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 listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+ let addr = listener.local_addr().unwrap();
+ 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::OK)
+ .header("content-type", "text/event-stream")
+ .header("x-codex-primary-reset-after-seconds", "90")
+ .header("x-codex-primary-reset-at", "1788879437")
+ .header("x-codex-primary-window-minutes", "300")
+ .body(Body::from(codex_header_only_usage_limit_sse()))
+ .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", format!("http://{addr}"));
+ 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() {