nangsontay
diff --git a/‎crates/headroom-proxy/src/compression/mod.rs‎
Lines changed: 158 additions & 0 deletions b/‎crates/headroom-proxy/src/compression/mod.rs‎
Lines changed: 158 additions & 0 deletions
diff --git a/‎crates/headroom-proxy/src/proxy.rs‎
Lines changed: 21 additions & 1 deletion b/‎crates/headroom-proxy/src/proxy.rs‎
Lines changed: 21 additions & 1 deletion
@@ -85,6 +85,67 @@ pub fn classify_compressible_path(path: &str) -> Option<CompressibleEndpoint> {
     }
 }
 
+/// Strip the `[1m]` context-window tier suffix that the Headroom
+/// CLI appends to Anthropic model IDs (e.g. `glm-5.2[1m]`,
+/// `claude-3-7-sonnet[1m]`) before forwarding to the upstream
+/// Anthropic API. The upstream does not recognize the suffix and
+/// rejects requests with 400.
+///
+/// This mirrors the Python proxy's `sanitize_anthropic_model_id()`
+/// (Python PR #1840, fixes issue #1812). The Rust proxy
+/// intentionally scopes this to **Anthropic** requests only — the
+/// `[1m]` marker is an Anthropic / Claude Code compatibility
+/// signal emitted by the CLI, and we must not silently mutate
+/// OpenAI-compatible request model IDs. The caller is responsible
+/// for gating on `CompressibleEndpoint::AnthropicMessages` before
+/// invoking this function; doing so at the call site (not inside
+/// this function) keeps the helper cheap and unambiguous.
+///
+/// Returns the original `body` byte-for-byte on every "no
+/// sanitization" path:
+/// - body is not valid JSON
+/// - body has no top-level `model` field
+/// - top-level `model` is not a string
+/// - the string does not end in `[1m]`
+/// - re-serialization fails (extremely unusual; we have already
+///   parsed the body, but `serde_json` could in theory reject a
+///   value shape it accepted on parse)
+pub fn sanitize_anthropic_model_id_in_body(body: bytes::Bytes) -> bytes::Bytes {
+    let Ok(mut parsed) = serde_json::from_slice::<serde_json::Value>(&body) else {
+        return body;
+    };
+
+    let Some(model_value) = parsed.get_mut("model") else {
+        return body;
+    };
+
+    let serde_json::Value::String(model) = model_value else {
+        return body;
+    };
+
+    let sanitized = trim_anthropic_model_id_suffix(model);
+    if sanitized == *model {
+        // Either no `[1m]` suffix to strip, or the suffix is not at
+        // the tail (e.g. `claude-3-7-sonnet[1m]-thinking` — not a
+        // CLI-emitted shape, but a defensive no-op). Byte-equal
+        // passthrough preserves the cache-safety invariant.
+        return body;
+    }
+
+    *model = sanitized;
+    match serde_json::to_vec(&parsed) {
+        Ok(buf) => bytes::Bytes::from(buf),
+        Err(_) => body,
+    }
+}
+
+/// Pure helper: strip a trailing `[1m]` from a model ID string.
+/// Exposed for unit tests; production callers should use
+/// [`sanitize_anthropic_model_id_in_body`].
+fn trim_anthropic_model_id_suffix(model: &str) -> String {
+    model.trim_end_matches("[1m]").to_string()
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -124,4 +185,101 @@ mod tests {
         assert!(!is_compressible_path("/"));
         assert!(!is_compressible_path(""));
     }
+
+    // ─── [1m] Anthropic model-suffix sanitizer (PR #2027) ────────────
+    //
+    // PR #2027 review feedback (JerrettDavis): the sanitizer must
+    // strip the `[1m]` CLI suffix from Anthropic `/v1/messages`
+    // request bodies without mutating OpenAI-shaped bodies. These
+    // unit tests pin the pure helper; integration coverage for
+    // /v1/messages vs /v1/chat/completions vs /v1/responses lives
+    // in `tests/integration_anthropic_model_sanitize.rs`.
+
+    #[test]
+    fn sanitizer_strips_trailing_1m_suffix() {
+        let body = br#"{"model":"glm-5.2[1m]","max_tokens":1024,"messages":[]}"#;
+        let out = sanitize_anthropic_model_id_in_body(bytes::Bytes::copy_from_slice(body));
+        let parsed: serde_json::Value = serde_json::from_slice(&out).unwrap();
+        assert_eq!(parsed["model"], "glm-5.2");
+        // Other fields round-trip unchanged.
+        assert_eq!(parsed["max_tokens"], 1024);
+        assert!(parsed["messages"].is_array());
+    }
+
+    #[test]
+    fn sanitizer_strips_suffix_from_claude_model() {
+        let body = br#"{"model":"claude-3-7-sonnet[1m]","max_tokens":1024}"#;
+        let out = sanitize_anthropic_model_id_in_body(bytes::Bytes::copy_from_slice(body));
+        let parsed: serde_json::Value = serde_json::from_slice(&out).unwrap();
+        assert_eq!(parsed["model"], "claude-3-7-sonnet");
+    }
+
+    #[test]
+    fn sanitizer_passthrough_when_no_suffix() {
+        let body = br#"{"model":"claude-3-7-sonnet","max_tokens":1024}"#;
+        let original = bytes::Bytes::copy_from_slice(body);
+        let out = sanitize_anthropic_model_id_in_body(original.clone());
+        // Byte-equal — required to keep the cache-safety invariant
+        // for the (very common) no-suffix case.
+        assert_eq!(out, original);
+    }
+
+    #[test]
+    fn sanitizer_passthrough_when_model_not_string() {
+        // Anthropic `/v1/messages` requires a string model, but a
+        // malformed body must round-trip unchanged — we never
+        // mutate non-string `model` values.
+        let body = br#"{"model":42,"max_tokens":1024}"#;
+        let original = bytes::Bytes::copy_from_slice(body);
+        let out = sanitize_anthropic_model_id_in_body(original.clone());
+        assert_eq!(out, original);
+    }
+
+    #[test]
+    fn sanitizer_passthrough_when_no_model_field() {
+        let body = br#"{"max_tokens":1024,"messages":[]}"#;
+        let original = bytes::Bytes::copy_from_slice(body);
+        let out = sanitize_anthropic_model_id_in_body(original.clone());
+        assert_eq!(out, original);
+    }
+
+    #[test]
+    fn sanitizer_passthrough_for_non_json_body() {
+        // A non-JSON body (e.g. SSE-rewritten or streaming chunk)
+        // must round-trip unchanged. The compressible-path gate in
+        // proxy.rs already filters by Content-Type=application/json,
+        // so this is a belt-and-braces check.
+        let body = b"not json at all";
+        let original = bytes::Bytes::copy_from_slice(body);
+        let out = sanitize_anthropic_model_id_in_body(original.clone());
+        assert_eq!(out, original);
+    }
+
+    #[test]
+    fn sanitizer_passthrough_for_1m_not_at_tail() {
+        // Defensive: a `[1m]` mid-string is not a CLI suffix and
+        // must not be mutated. Real CLI behavior only ever appends
+        // `[1m]` at the tail, but a future wire format should not
+        // silently corrupt legitimate `model` strings.
+        let body = br#"{"model":"claude-3-7-sonnet[1m]-thinking","max_tokens":1024}"#;
+        let original = bytes::Bytes::copy_from_slice(body);
+        let out = sanitize_anthropic_model_id_in_body(original.clone());
+        assert_eq!(out, original);
+    }
+
+    #[test]
+    fn trim_helper_pure() {
+        // The pure helper is a thin wrapper around
+        // `str::trim_end_matches`; pin its behavior directly so
+        // refactors that swap the implementation can't silently
+        // change the strip semantics.
+        assert_eq!(trim_anthropic_model_id_suffix("glm-5.2[1m]"), "glm-5.2");
+        assert_eq!(trim_anthropic_model_id_suffix("claude[1m]"), "claude");
+        assert_eq!(trim_anthropic_model_id_suffix("claude"), "claude");
+        // `trim_end_matches` is greedy — back-to-back suffixes are
+        // all stripped. The CLI never emits this, but pinning the
+        // behavior makes the helper a pure function with a stable
+        // contract.
+        assert_eq!(trim_anthropic_model_id_suffix("claude[1m][1m]"), "claude");
+    }
 }
@@ -10,9 +10,9 @@ use axum::http::{HeaderMap, HeaderName, Request, Response, StatusCode, Uri};
 use axum::response::IntoResponse;
 use axum::routing::{any, get, post};
 use axum::Router;
+use futures_util::{StreamExt as _, TryStreamExt};
 #[cfg(test)]
 use bytes::Bytes;
-use futures_util::{StreamExt as _, TryStreamExt};
 #[cfg(test)]
 use http_body_util::BodyExt;
 
@@ -632,6 +632,26 @@ pub(crate) async fn forward_http(
         let endpoint = compression::classify_compressible_path(uri.path())
             .expect("is_compressible_path guarded above");
 
+        // PR-2027: strip the `[1m]` context-window tier suffix from
+        // the request body for Anthropic messages only. The
+        // Headroom CLI appends `[1m]` to model IDs (e.g.
+        // `glm-5.2[1m]`, `claude-3-7-sonnet[1m]`) to signal 1M
+        // context to Claude Code; the upstream Anthropic API does
+        // not recognize the suffix and rejects the request. The
+        // suffix is an Anthropic/Claude Code compatibility marker,
+        // so we must not silently mutate OpenAI-compatible
+        // request model IDs. The sanitizer is gated on the
+        // already-classified `endpoint`, which is the same source
+        // of truth the dispatcher uses below — keeping the gate
+        // and the dispatch in lockstep.
+        let buffered = match endpoint {
+            compression::CompressibleEndpoint::AnthropicMessages => {
+                compression::sanitize_anthropic_model_id_in_body(buffered)
+            }
+            compression::CompressibleEndpoint::OpenAiChatCompletions
+            | compression::CompressibleEndpoint::OpenAiResponses => buffered,
+        };
+
         // PR-E5 + PR-E6: cache-stabilization observability hooks.
         // Both run READ-ONLY against the buffered body and emit
         // structured logs only — passthrough invariant from Phase A