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.rsindex 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.rsindex 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.rsindex 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() {