@tormentalabs/claude-code-wire-compat 0.1.0 → 0.2.0

package/src/profiles/claude-code-2.1.195.ts

@@ -50,32 +50,39 @@ export const CLAUDE_CODE_2_1_195_PROFILE: ClaudeCodeProtocolProfile =
       "claude-3-5-haiku": {
         family: "haiku",
         capabilities: [],
+        maxOutputTokens: { default: 8192, upper: 8192 },
       },
       "claude-haiku-4-5": {
         family: "haiku",
         capabilities: ["context_management"],
+        maxOutputTokens: { default: 32000, upper: 64000 },
       },
       "claude-3-5-sonnet": {
         family: "sonnet",
         capabilities: [],
+        maxOutputTokens: { default: 8192, upper: 8192 },
       },
       "claude-3-7-sonnet": {
         family: "sonnet",
         capabilities: [],
+        maxOutputTokens: { default: 32000, upper: 64000 },
       },
       "claude-sonnet-4-0": {
         family: "sonnet",
         context: { window: 200000, supports1mBeta: true },
         capabilities: ["context_management"],
+        maxOutputTokens: { default: 32000, upper: 64000 },
       },
       "claude-sonnet-4-5": {
         family: "sonnet",
         context: { window: 200000, supports1mBeta: true },
         capabilities: ["context_management"],
+        maxOutputTokens: { default: 32000, upper: 64000 },
       },
       "claude-sonnet-4-6": {
         family: "sonnet",
         context: { window: 200000, supports1mBeta: true },
+        maxOutputTokens: { default: 32000, upper: 128000 },
         capabilities: [
           "effort",
           "max_effort",
@@ -86,18 +93,22 @@ export const CLAUDE_CODE_2_1_195_PROFILE: ClaudeCodeProtocolProfile =
       "claude-opus-4-0": {
         family: "opus",
         capabilities: ["context_management"],
+        maxOutputTokens: { default: 32000, upper: 32000 },
       },
       "claude-opus-4-1": {
         family: "opus",
         capabilities: ["context_management"],
+        maxOutputTokens: { default: 32000, upper: 32000 },
       },
       "claude-opus-4-5": {
         family: "opus",
         capabilities: ["context_management"],
+        maxOutputTokens: { default: 32000, upper: 64000 },
       },
       "claude-opus-4-6": {
         family: "opus",
         context: { window: 200000, supports1mBeta: true },
+        maxOutputTokens: { default: 64000, upper: 128000 },
         capabilities: [
           "effort",
           "max_effort",
@@ -109,6 +120,7 @@ export const CLAUDE_CODE_2_1_195_PROFILE: ClaudeCodeProtocolProfile =
       "claude-opus-4-7": {
         family: "opus",
         context: { window: 1e6, native1m: true, supports1mBeta: true },
+        maxOutputTokens: { default: 64000, upper: 128000 },
         capabilities: [
           "effort",
           "max_effort",
@@ -122,6 +134,7 @@ export const CLAUDE_CODE_2_1_195_PROFILE: ClaudeCodeProtocolProfile =
       "claude-opus-4-8": {
         family: "opus",
         context: { window: 1e6, native1m: true, supports1mBeta: true },
+        maxOutputTokens: { default: 64000, upper: 128000 },
         capabilities: [
           "effort",
           "max_effort",
@@ -137,6 +150,7 @@ export const CLAUDE_CODE_2_1_195_PROFILE: ClaudeCodeProtocolProfile =
       "claude-fable-5": {
         family: "fable",
         context: { window: 1e6, native1m: true, supports1mBeta: true },
+        maxOutputTokens: { default: 64000, upper: 128000 },
         capabilities: [
           "effort",
           "max_effort",

package/src/profiles/claude-code-2.1.233.ts

@@ -0,0 +1,240 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+import type { ClaudeCodeProtocolProfile } from "../contracts.js";
+import { COUNT_TOKENS_ENDPOINT } from "../count-tokens.js";
+
+/*
+ * Protocol profile for genuine client 2.1.233.
+ *
+ * Provenance: extracted from the official 2.1.233 win32-x64 binary. The
+ * catalogue and every scalar below are transcribed from
+ * `docs/protocol/versions/claude-code-2.1.233-analysis.md`, which records the
+ * byte offsets they came from.
+ *
+ * `effort_cost_index` -- the only static-catalogue field added between 2.1.222
+ * and 2.1.233 -- is deliberately omitted; the decision is recorded in
+ * `docs/source-trace.md`.
+ *
+ * Context modelling follows 2.1.195 exactly wherever the upstream flags are
+ * the same. `supports_1m_suffix` is not modelled, so an entry declaring a
+ * 200000 window with nothing but that flag carries no `context` object here,
+ * as in the 2.1.195 profile.
+ */
+
+function deepFreeze<T>(value: T): T {
+  if (value !== null && typeof value === "object") {
+    for (const key of Reflect.ownKeys(value)) {
+      deepFreeze(Reflect.get(value, key));
+    }
+    Object.freeze(value);
+  }
+  return value;
+}
+
+export const CLAUDE_CODE_2_1_233_PROFILE: ClaudeCodeProtocolProfile =
+  deepFreeze({
+    id: "claude-code-2.1.233-sdk-0.112.1",
+    cliVersion: "2.1.233",
+    sdkVersion: "0.112.1",
+    endpoint: "https://api.anthropic.com/v1/messages?beta=true",
+    countTokensEndpoint: COUNT_TOKENS_ENDPOINT,
+    entrypoint: "cli",
+    userAgent: "claude-cli/2.1.233 (external, cli)",
+    buildTime: "2026-08-14T17:21:48Z",
+    gitSha: "f8d57569aaf350fe25dc4dfa10cad59db8ea4d45",
+    attributionHeaderEnabled: true,
+    provider: "anthropic",
+    anthropicVersion: "2023-06-01",
+    contextHintEnabled: false,
+    betaPolicy: {
+      oauthAuthenticated: true,
+      experimentalBetasEnabled: true,
+      oneMillionContextEnabled: true,
+      interleavedThinkingEnabled: true,
+      interactive: true,
+      thinkingSummariesShown: false,
+      thinkingTokenCountEnabled: true,
+      // Inert for this profile: 2.1.233 removed `narration_summaries` from the
+      // beta registry, so there is no entry for this flag to gate.
+      narrationSummariesEnabled: false,
+      structuredOutputsEnabled: false,
+      afkModeEnabled: false,
+      cacheDiagnosisEnabled: false,
+    },
+    /**
+     * Verbatim genuine-client catalogue, 17 entries in the catalogue's own
+     * order. `defaultEffort` is policy exposed as catalogue data; this package
+     * must never apply it to a request.
+     */
+    supportedModels: {
+      "claude-3-5-haiku": {
+        family: "haiku",
+        capabilities: [],
+        maxOutputTokens: { default: 8192, upper: 8192 },
+      },
+      "claude-haiku-4-5": {
+        family: "haiku",
+        capabilities: ["context_management"],
+        maxOutputTokens: { default: 32000, upper: 64000 },
+      },
+      "claude-3-5-sonnet": {
+        family: "sonnet",
+        capabilities: [],
+        maxOutputTokens: { default: 8192, upper: 8192 },
+      },
+      "claude-3-7-sonnet": {
+        family: "sonnet",
+        capabilities: [],
+        maxOutputTokens: { default: 32000, upper: 64000 },
+      },
+      "claude-sonnet-4-0": {
+        family: "sonnet",
+        context: { window: 200000, supports1mBeta: true },
+        capabilities: ["context_management"],
+        maxOutputTokens: { default: 32000, upper: 64000 },
+      },
+      "claude-sonnet-4-5": {
+        family: "sonnet",
+        context: { window: 200000, supports1mBeta: true },
+        capabilities: ["context_management"],
+        maxOutputTokens: { default: 32000, upper: 64000 },
+      },
+      "claude-sonnet-4-6": {
+        family: "sonnet",
+        context: { window: 200000, supports1mBeta: true },
+        maxOutputTokens: { default: 32000, upper: 128000 },
+        capabilities: [
+          "effort",
+          "max_effort",
+          "adaptive_thinking",
+          "context_management",
+        ],
+      },
+      // New at 2.1.233. The entry also declares `native_1m_3p` for
+      // bedrock/vertex/foundry; this package is anthropic-only, so that flag
+      // is not modelled.
+      "claude-sonnet-5": {
+        family: "sonnet",
+        context: { window: 1e6, native1m: true, supports1mBeta: true },
+        maxOutputTokens: { default: 64000, upper: 128000 },
+        capabilities: [
+          "effort",
+          "max_effort",
+          "xhigh_effort",
+          "adaptive_thinking",
+          "mid_conv_system",
+          "context_management",
+        ],
+        defaultEffort: "high",
+      },
+      "claude-opus-4-0": {
+        family: "opus",
+        capabilities: ["context_management"],
+        maxOutputTokens: { default: 32000, upper: 32000 },
+      },
+      "claude-opus-4-1": {
+        family: "opus",
+        capabilities: ["context_management"],
+        maxOutputTokens: { default: 32000, upper: 32000 },
+      },
+      // No `effort`, and no exception restoring it. The C1 exception in
+      // `model-capabilities.ts` belongs to 2.1.195, whose derivation ran off
+      // predicates; 2.1.233 derives from this catalogue, so the omission is
+      // the genuine answer here.
+      "claude-opus-4-5": {
+        family: "opus",
+        capabilities: ["context_management"],
+        maxOutputTokens: { default: 32000, upper: 64000 },
+      },
+      // Delta D3 vs 2.1.195: `fast_mode` is gone from this entry.
+      "claude-opus-4-6": {
+        family: "opus",
+        context: { window: 200000, supports1mBeta: true },
+        maxOutputTokens: { default: 64000, upper: 128000 },
+        capabilities: [
+          "effort",
+          "max_effort",
+          "adaptive_thinking",
+          "context_management",
+        ],
+      },
+      // Delta D3 vs 2.1.195: `fast_mode` is gone from this entry too.
+      "claude-opus-4-7": {
+        family: "opus",
+        context: { window: 1e6, native1m: true, supports1mBeta: true },
+        maxOutputTokens: { default: 64000, upper: 128000 },
+        capabilities: [
+          "effort",
+          "max_effort",
+          "xhigh_effort",
+          "adaptive_thinking",
+          "context_management",
+        ],
+        defaultEffort: "xhigh",
+      },
+      "claude-opus-4-8": {
+        family: "opus",
+        context: { window: 1e6, native1m: true, supports1mBeta: true },
+        maxOutputTokens: { default: 64000, upper: 128000 },
+        capabilities: [
+          "effort",
+          "max_effort",
+          "xhigh_effort",
+          "adaptive_thinking",
+          "mid_conv_system",
+          "context_management",
+          "fast_mode",
+          "lean_prompt",
+        ],
+        defaultEffort: "high",
+      },
+      // New at 2.1.233.
+      "claude-opus-5": {
+        family: "opus",
+        context: { window: 1e6, native1m: true, supports1mBeta: true },
+        maxOutputTokens: { default: 64000, upper: 128000 },
+        capabilities: [
+          "effort",
+          "max_effort",
+          "xhigh_effort",
+          "adaptive_thinking",
+          "mid_conv_system",
+          "context_management",
+          "fast_mode",
+          "lean_prompt",
+          "refusal_fallback",
+          "opus_5_prompt_bundle",
+        ],
+        defaultEffort: "high",
+      },
+      "claude-fable-5": {
+        family: "fable",
+        context: { window: 1e6, native1m: true, supports1mBeta: true },
+        maxOutputTokens: { default: 64000, upper: 128000 },
+        capabilities: [
+          "effort",
+          "max_effort",
+          "xhigh_effort",
+          "adaptive_thinking",
+          "rejects_disabled_thinking",
+          "mid_conv_system",
+          "context_management",
+          "lean_prompt",
+          "fable_5_mitigations",
+          "refusal_fallback",
+        ],
+        defaultEffort: "high",
+      },
+      // New at 2.1.233, and the notable one: under 2.1.195 `claude-mythos-5`
+      // had no catalogue entry at all (product decision D-1) and was
+      // recognised only by name in individual predicates. Here it is
+      // catalogued with an empty capability array, which is a denial rather
+      // than the maximally permissive predicate fallback.
+      "claude-mythos-5": {
+        family: "mythos",
+        context: { window: 1e6, native1m: true, supports1mBeta: true },
+        capabilities: [],
+        maxOutputTokens: { default: 64000, upper: 128000 },
+      },
+    },
+  });

package/src/redaction.ts

@@ -65,6 +65,17 @@ export interface BuildRedactedEvidenceInput {
 const MAX_INPUT_DEPTH = 100;
 const MAX_INPUT_SIZE = 1_000_000;
 const ENDPOINT = "https://api.anthropic.com/v1/messages?beta=true";
+/**
+ * The profile ids evidence may claim, spelled out here for the same reason
+ * `ENDPOINT` is: this module validates UNTRUSTED evidence records, so it
+ * compares them against literals of its own rather than importing the
+ * profiles it is checking. Membership stays exact -- an id outside this set
+ * is rejected, as a free-form id always was.
+ */
+const PINNED_PROFILE_IDS: ReadonlySet<string> = new Set([
+  "claude-code-2.1.195-sdk-0.94.0",
+  "claude-code-2.1.233-sdk-0.112.1",
+]);
 const FORBIDDEN_KEYS = new Set(["__proto__", "prototype", "constructor"]);
 const SAFE_ERROR_CODES = new Set([
   "INVALID_INPUT",
@@ -285,7 +296,11 @@ function assertEvidenceSources(value: unknown): void {
   const logicalHeaders = readOwnValue(value, "logicalHeaders");
   const betaFeatures = readOwnValue(value, "betaFeatures");
 
-  if (profileId !== "claude-code-2.1.195-sdk-0.94.0" || endpoint !== ENDPOINT) {
+  if (
+    typeof profileId !== "string" ||
+    !PINNED_PROFILE_IDS.has(profileId) ||
+    endpoint !== ENDPOINT
+  ) {
     throw wireError("INVALID_INPUT");
   }
   if (effectiveProfile !== undefined) {

package/src/request-body.ts

@@ -1413,22 +1413,26 @@ function capabilityBoolean(value: unknown, fallback: boolean): boolean {
   return value;
 }
 
-function modelResolution(value: unknown): ModelResolution {
+function modelResolution(
+  value: unknown,
+  profile: ClaudeCodeProtocolProfile = CLAUDE_CODE_2_1_195_PROFILE,
+): ModelResolution {
   const record = requireRecord(value);
   const capabilityValue = record["capabilities"];
-  // A catalogue-shaped capability array is accepted at this boundary, but it
-  // never affects derivation: on first party every predicate depends only on
-  // the normalized id. See the header of `model-capabilities.ts`. The elements
-  // are still validated so that malformed input fails closed.
+  // A catalogue-shaped capability array is accepted at this boundary, but its
+  // elements never drive derivation: the active profile's catalogue does,
+  // falling back to the id predicates. See the header of
+  // `model-capabilities.ts`. The elements are still validated so that
+  // malformed input fails closed.
   if (Array.isArray(capabilityValue)) {
     for (const capability of capabilityValue) {
       if (typeof capability !== "string") fail("INVALID_INPUT");
     }
   }
   const capabilities = Array.isArray(capabilityValue)
-    ? deriveCapabilities(String(record["id"]))
+    ? deriveCapabilities(String(record["id"]), profile)
     : requireRecord(capabilityValue);
-  const derived = deriveCapabilities(String(record["id"]));
+  const derived = deriveCapabilities(String(record["id"]), profile);
   if (
     (capabilities.thinking !== undefined &&
       typeof capabilities.thinking !== "boolean") ||
@@ -1739,7 +1743,8 @@ export function buildCanonicalBody(
   const input = requireRecord(rawInput);
   assertExactKeys(input, INPUT_KEY_SET);
   requireKeys(input, ["maxTokens", "messages"]);
-  const resolvedModel = modelResolution(rawResolvedModel);
+  const effectiveProfile = profile ?? CLAUDE_CODE_2_1_195_PROFILE;
+  const resolvedModel = modelResolution(rawResolvedModel, effectiveProfile);
   if (
     hasOwn(input, "model") &&
     (typeof input["model"] !== "string" ||
@@ -1775,6 +1780,7 @@ export function buildCanonicalBody(
   const maxTokens = clampMaxTokens(
     requirePositiveInteger(input["maxTokens"]),
     resolvedModel.id,
+    effectiveProfile,
   );
   const result: Record<string, unknown> = {
     model: resolvedModel.wireId,
@@ -1828,8 +1834,9 @@ export function buildCanonicalBody(
     thinkingRequest,
     resolvedModel.id,
     resolvedModel.capabilities,
-    (profile ?? CLAUDE_CODE_2_1_195_PROFILE).betaPolicy,
+    effectiveProfile.betaPolicy,
     maxTokens,
+    effectiveProfile,
   );
   if (resolved.emitted !== undefined) result["thinking"] = resolved.emitted;
 

package/src/thinking.ts

@@ -3,7 +3,10 @@
 import type {
   ClaudeCodeBetaPolicy,
   ClaudeCodeCapabilities,
+  ClaudeCodeProtocolProfile,
 } from "./contracts.js";
+import { profileBehaviors } from "./profile-behaviors.js";
+import { CLAUDE_CODE_2_1_195_PROFILE } from "./profiles/claude-code-2.1.195.js";
 
 /**
  * Extended-thinking resolution, ported from the genuine client's request
@@ -73,9 +76,21 @@ export interface ResolvedThinking {
 
 /**
  * Per-model output token limits, ported from upstream `Xxe` at byte offset
- * 227378240. Keyed on the NORMALISED model id, and deliberately independent of
- * the catalogue: `claude-3-opus`, `claude-3-sonnet` and `claude-3-haiku` are
- * reachable through the normaliser but have no catalogue entry.
+ * 227378240. Keyed on the NORMALISED model id.
+ *
+ * Resolution order, since Fase 1.2:
+ *
+ *   1. The pinned 2.1.195 catalogue, when the id has an entry carrying
+ *      `maxOutputTokens`. That is the single source of truth for every model
+ *      the profile knows, and `token-limits-equivalence.test.ts` pins the two
+ *      sources cell by cell.
+ *   2. Otherwise the transcribed `Xxe` table below, preserved intact as the
+ *      demarcated fallback. It is NOT dead code and must not be trimmed to
+ *      "only the ids the catalogue lacks": `claude-3-opus`, `claude-3-sonnet`
+ *      and `claude-3-haiku` are reachable through the normaliser with no
+ *      catalogue entry, `claude-mythos-5` is absent from the catalogue by
+ *      product decision D-1, and any id from a newer client lands on the
+ *      final fallback row.
  *
  * Both fields are load-bearing. `upperLimit` seeds the thinking budget when the
  * caller supplies none (upstream `wvi = Xxe(e).upperLimit - 1`); `default` caps
@@ -89,38 +104,96 @@ export interface ResolvedThinking {
  *     override this package cannot observe.
  *   - `bvi(e)` adjusts BOTH fields, but sits behind `_vi()`, which returns a
  *     hard `false`. Dead code upstream.
+ *
+ * From 2.1.222 onward upstream grew a THIRD adjustment, this one derived from
+ * the request rather than from host state, and therefore observable: see
+ * `requestedMaxTokens` below.
+ *
+ * @param requestedMaxTokens
+ *   The caller's own `max_tokens`, when the call site has it. Modelled for
+ *   profiles from 2.1.222 onward only; see the demarcated block below.
  */
 export function modelOutputTokenLimits(
   normalizedId: string,
+  profile: ClaudeCodeProtocolProfile = CLAUDE_CODE_2_1_195_PROFILE,
+  requestedMaxTokens?: number,
 ): ModelOutputTokenLimits {
-  if (normalizedId === "claude-fable-5" || normalizedId === "claude-mythos-5") {
-    return { default: 64000, upperLimit: 128000 };
-  }
-  if (normalizedId === "claude-opus-4-8") {
-    return { default: 64000, upperLimit: 128000 };
-  }
-  if (normalizedId === "claude-opus-4-7") {
-    return { default: 64000, upperLimit: 128000 };
-  }
-  if (normalizedId === "claude-sonnet-4-6") {
-    return { default: 32000, upperLimit: 128000 };
-  }
-  if (normalizedId === "claude-opus-4-6") {
-    return { default: 64000, upperLimit: 128000 };
-  }
+  const resolved = resolveDeclaredLimits(normalizedId, profile);
+
+  /*
+   * ---- Demarcated: request-derived upper bound, upstream 2.1.222+. ----
+   *
+   * Upstream raises `upperLimit` to the caller's own `max_tokens` and lowers
+   * `default` to fit under it:
+   *
+   *   upperLimit = requestedMaxTokens;
+   *   default    = Math.min(default, upperLimit);
+   *
+   * Verified byte-identical between upstream 2.1.222 and 2.1.233.
+   *
+   * The gate is STRUCTURAL, not a capability flag: this behaviour exists in
+   * upstream 2.1.222+ and 2.1.195 does not have it, so the 195 profile must
+   * never see it. Which profiles are on which side is `profile-behaviors.ts`'s
+   * question, not this module's.
+   *
+   * `Number.isSafeInteger` is deliberately stricter than upstream's truthy
+   * check. The upstream runtime only ever produces integers in this field, so
+   * the two agree on every reachable input; here a NaN or Infinity would
+   * propagate straight into `budget_tokens`, which must stay an integer.
+   */
   if (
-    normalizedId === "claude-opus-4-5" ||
-    normalizedId === "claude-sonnet-4-0" ||
-    normalizedId === "claude-sonnet-4-5" ||
-    normalizedId === "claude-haiku-4-5"
+    profileBehaviors(profile).requestDerivedTokenCeiling &&
+    requestedMaxTokens !== undefined &&
+    Number.isSafeInteger(requestedMaxTokens) &&
+    requestedMaxTokens >= 4096
   ) {
-    return { default: 32000, upperLimit: 64000 };
+    const upperLimit = requestedMaxTokens;
+    return { default: Math.min(resolved.default, upperLimit), upperLimit };
   }
-  if (
-    normalizedId === "claude-opus-4-1" ||
-    normalizedId === "claude-opus-4-0"
-  ) {
-    return { default: 32000, upperLimit: 32000 };
+
+  return resolved;
+}
+
+function resolveDeclaredLimits(
+  normalizedId: string,
+  profile: ClaudeCodeProtocolProfile,
+): ModelOutputTokenLimits {
+  const declared = profile.supportedModels[normalizedId]?.maxOutputTokens;
+  if (declared !== undefined) {
+    // `upper` is the catalogue's name for what this module calls `upperLimit`;
+    // the rename happens here and nowhere else.
+    return { default: declared.default, upperLimit: declared.upper };
+  }
+
+  /*
+   * ---- Demarcated fallback: the reachable remainder of `Xxe`. ----
+   *
+   * No catalogue id reaches this point. Every entry of the 2.1.195 catalogue
+   * declares `maxOutputTokens`, and `capability-equivalence.test.ts` fails if
+   * one stops doing so, which is what keeps the rows below to the ids the
+   * catalogue genuinely cannot answer for:
+   *
+   *   - `claude-mythos-5` has no catalogue entry by product decision D-1.
+   *   - `claude-3-opus`, `claude-3-sonnet` and `claude-3-haiku` are reachable
+   *     through the normaliser and predate the catalogue.
+   *
+   * The rows for catalogued ids were deleted rather than kept "just in case":
+   * they were unreachable, so they could be neither covered nor
+   * mutation-killed, and a second copy of a limit that no longer serves any
+   * request is exactly the duplicated table
+   * `test/governance/single-source-of-truth.test.ts` exists to prevent.
+   *
+   * This mirrors upstream 2.1.222, where derivation is catalogue-first and
+   * the surviving legacy rows are the `claude-3-*` ones plus a generic tail.
+   *
+   * If a future profile omits `maxOutputTokens` for some id, that id lands on
+   * the generic tail below -- 32000/128000 -- rather than on a stale
+   * per-model row. That is deliberate: a wrong-but-loud generic limit is
+   * recoverable, a silently stale per-model limit is not. The equivalence
+   * guard fires first in any case.
+   */
+  if (normalizedId === "claude-mythos-5") {
+    return { default: 64000, upperLimit: 128000 };
   }
   if (normalizedId === "claude-3-opus") {
     return { default: 4096, upperLimit: 4096 };
@@ -131,15 +204,6 @@ export function modelOutputTokenLimits(
   if (normalizedId === "claude-3-haiku") {
     return { default: 4096, upperLimit: 4096 };
   }
-  if (
-    normalizedId === "claude-3-5-sonnet" ||
-    normalizedId === "claude-3-5-haiku"
-  ) {
-    return { default: 8192, upperLimit: 8192 };
-  }
-  if (normalizedId === "claude-3-7-sonnet") {
-    return { default: 32000, upperLimit: 64000 };
-  }
   return { default: 32000, upperLimit: 128000 };
 }
 
@@ -162,12 +226,22 @@ export function modelOutputTokenLimits(
  * Upstream uses `||`, not `??`, so a zero override would fall back to the
  * default. Unreachable here: `max_tokens` is validated as a positive integer
  * before this runs.
+ *
+ * `requested` is forwarded as the request-derived bound so that this call site
+ * reads the same table upstream reads. It cannot change the result: the
+ * override only ever lowers `default` to `requested`, and
+ * `min(requested, min(default, requested)) === min(requested, default)`. It is
+ * passed for coherence of reading, not for effect.
  */
 export function clampMaxTokens(
   requested: number,
   normalizedId: string,
+  profile: ClaudeCodeProtocolProfile = CLAUDE_CODE_2_1_195_PROFILE,
 ): number {
-  return Math.min(requested, modelOutputTokenLimits(normalizedId).default);
+  return Math.min(
+    requested,
+    modelOutputTokenLimits(normalizedId, profile, requested).default,
+  );
 }
 
 /**
@@ -216,6 +290,7 @@ export function resolveThinking(
   capabilities: ClaudeCodeCapabilities,
   betaPolicy: ClaudeCodeBetaPolicy,
   maxTokens: number,
+  profile: ClaudeCodeProtocolProfile = CLAUDE_CODE_2_1_195_PROFILE,
 ): ResolvedThinking {
   // Upstream `nr = n.type !== "disabled" && !CLAUDE_CODE_DISABLE_THINKING`.
   const requestActive = request !== undefined && request.type !== "disabled";
@@ -236,9 +311,14 @@ export function resolveThinking(
       // Upstream: `let Tr = wvi(u)` — the model's upper limit minus one —
       // overridden by the caller's budget when supplied, then clamped by
       // `Tr = Math.min(Fi - 1, Tr)` where `Fi` is the emitted `max_tokens`.
+      //
+      // This is the one wire-visible consumer of the request-derived bound: on
+      // a 2.1.222+ profile a caller asking for a `max_tokens` above the
+      // catalogue's upper limit seeds the default budget from THEIR number
+      // minus one, not from the catalogue's.
       const requested =
         request.budgetTokens ??
-        modelOutputTokenLimits(normalizedId).upperLimit - 1;
+        modelOutputTokenLimits(normalizedId, profile, maxTokens).upperLimit - 1;
       emitted = { budget_tokens: Math.min(maxTokens - 1, requested) };
       emitted["type"] = "enabled";
       if (display !== undefined) emitted["display"] = display;