Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy
Rust
publish the per-request id as a `request-id` response header (#105)
Peter Zde3e8db882b6
diff --git a/src/server.rs b/src/server.rsindex bb563d9..8a84255 100644--- a/src/server.rs+++ b/src/server.rs@@ -1783,13 +1783,31 @@ async fn dispatch_request(response}+/// Header Claude Code reads to populate the `requestId` field it writes into+/// every transcript record.+pub const REQUEST_ID_HEADER: &str = "request-id";+fn monitor_response_body(response: Response, guard: RequestMonitorGuard) -> Response {let status = response.status();let outcome = response.extensions().get::<NativeResponseOutcome>().cloned();- let (parts, body) = response.into_parts();+ let (mut parts, body) = response.into_parts();+ // Publish the per-request id this proxy already mints. Anthropic returns+ // `request-id`, and Claude Code records it as `requestId`; without it every+ // downstream consumer that de-duplicates transcript records by request id+ // (its own parser, usage dashboards) counts each request twice, because a+ // transcript legitimately repeats a record and the id is what resolves it.+ //+ // Stamped here rather than at each `return` because every response path in+ // this module funnels through this function, and it is applied to the parts+ // before the body is streamed, so a streaming SSE response carries it too.+ if !parts.headers.contains_key(REQUEST_ID_HEADER)+ && let Ok(value) = http::HeaderValue::from_str(&guard.req_id)+ {+ parts.headers.insert(REQUEST_ID_HEADER, value);+ }let stream = futures_util::stream::unfold((body, guard, outcome),move |(mut body, mut guard, outcome)| async move {@@ -2144,6 +2162,82 @@ fn _unused(session_state: Option<&SessionState>) {let _ = session_state;}+#[cfg(test)]+mod request_id_header_tests {+ use super::{REQUEST_ID_HEADER, RequestMonitorGuard, monitor_response_body};+ use axum::body::Body;+ use axum::response::Response;+ use http::{HeaderValue, StatusCode};++ fn guard(req_id: &str) -> RequestMonitorGuard {+ RequestMonitorGuard::new(None, req_id.to_string())+ }++ // Claude Code populates its transcript `requestId` from this header.+ // Without it, consumers that de-duplicate transcript records by request id+ // count every request twice, because a transcript legitimately repeats a+ // record and the id is what resolves the repeat.+ #[test]+ fn stamps_the_request_id_on_a_response() {+ let response = Response::builder()+ .status(StatusCode::OK)+ .body(Body::from("{}"))+ .unwrap();+ let stamped = monitor_response_body(response, guard("req-abc-123"));+ assert_eq!(+ stamped.headers().get(REQUEST_ID_HEADER).unwrap(),+ "req-abc-123"+ );+ }++ // Streaming responses carry it too: the header is applied to the parts+ // before the body is streamed, which is why the body-level message id is+ // not a substitute for SSE.+ #[test]+ fn stamps_a_streaming_response_before_the_body() {+ let response = Response::builder()+ .status(StatusCode::OK)+ .header("content-type", "text/event-stream")+ .body(Body::from("event: message_start\n"))+ .unwrap();+ let stamped = monitor_response_body(response, guard("req-stream-1"));+ assert_eq!(+ stamped.headers().get(REQUEST_ID_HEADER).unwrap(),+ "req-stream-1"+ );+ }++ // An upstream that already supplied one owns it; overwriting would relabel+ // a real provider id with a local uuid.+ #[test]+ fn does_not_clobber_an_upstream_supplied_id() {+ let response = Response::builder()+ .status(StatusCode::OK)+ .header(+ REQUEST_ID_HEADER,+ HeaderValue::from_static("upstream-owned"),+ )+ .body(Body::from("{}"))+ .unwrap();+ let stamped = monitor_response_body(response, guard("local-uuid"));+ assert_eq!(+ stamped.headers().get(REQUEST_ID_HEADER).unwrap(),+ "upstream-owned"+ );+ }++ // Error responses are de-duplicated by the same key as successes.+ #[test]+ fn stamps_error_responses_too() {+ let response = Response::builder()+ .status(StatusCode::TOO_MANY_REQUESTS)+ .body(Body::from("{\"error\":\"rate limited\"}"))+ .unwrap();+ let stamped = monitor_response_body(response, guard("req-429"));+ assert_eq!(stamped.headers().get(REQUEST_ID_HEADER).unwrap(), "req-429");+ }+}+#[cfg(test)]mod auto_review_tests {use super::{apply_auto_review_model, headers_to_record, is_claude_auto_review_request};