@tormentalabs/claude-code-wire-compat 0.4.0 → 0.6.0

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

@@ -0,0 +1,364 @@
+// 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.280.
+ *
+ * Provenance: extracted from the official 2.1.280 win32-x64 binary. The
+ * catalogue and every scalar below are transcribed from
+ * `docs/protocol/versions/claude-code-2.1.280-analysis.md`, which records the
+ * byte offsets they came from. The catalogue was additionally re-extracted
+ * from the carved bundle independently of that document (cluster bytes
+ * 5941320-5955961) and agreed on every field of all twenty entries; that
+ * re-extraction is not a claim you have to take on trust, because the method
+ * it used is written down in section 5.2.1 of the analysis document and can be
+ * re-run against the same dump.
+ *
+ * `effort_cost_index` is deliberately omitted, as in the 2.1.233 profile, and
+ * so are the other nine static-catalogue fields the package does not model
+ * (analysis document section 5.1).
+ *
+ * Context modelling follows 2.1.233 exactly. `supports_1m_suffix` is not
+ * modelled, so an entry declaring a 200000 window with nothing but that flag
+ * carries no `context` object here. `native_1m_3p` on `claude-sonnet-5` names
+ * bedrock, vertex and foundry; this package is anthropic-only, so that flag is
+ * not modelled either.
+ */
+
+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_280_PROFILE: ClaudeCodeProtocolProfile =
+  deepFreeze({
+    id: "claude-code-2.1.280-sdk-0.112.1",
+    cliVersion: "2.1.280",
+    sdkVersion: "0.112.1",
+    endpoint: "https://api.anthropic.com/v1/messages?beta=true",
+    countTokensEndpoint: COUNT_TOKENS_ENDPOINT,
+    entrypoint: "cli",
+    userAgent: "claude-cli/2.1.280 (external, cli)",
+    buildTime: "2026-09-21T20:40:17Z",
+    gitSha: "80abbfe7d7232280011ff01a21ae3338f4c6e372",
+    // RETAINED from 2.1.233, not asserted. The 2.1.280 analysis document does
+    // not examine the billing block at all -- it contains no occurrence of
+    // "attribution" -- so this is silence, which is not the same as evidence of
+    // no change. The only indirect support is that the salt behind the
+    // fingerprint is unchanged (section 13); the fingerprint it produces, not
+    // the salt, is what appears on the billing line. Section 13.2 draws this
+    // exact distinction for the beta policy and it applies here too: where the
+    // evidence is absent the previous release's value is retained rather than
+    // re-derived, and a later release that captures live traffic should settle
+    // it.
+    attributionHeaderEnabled: true,
+    provider: "anthropic",
+    anthropicVersion: "2023-06-01",
+    // Section 9.2: `context_hint` remains off for 2.1.280. Section 7.6 agrees
+    // -- its fourteen-identifier default-path `anthropic-beta` literal contains
+    // no `context-hint` identifier -- but that is the same gate restated, not a
+    // second line of evidence, because the 7.6 row cites the gate 9.2 resolves.
+    // Only two things put that identifier into an emitted list: this flag,
+    // which also emits a `context_hint` body field, and a caller passing the
+    // identifier explicitly through the `additionalBetas` request seam.
+    contextHintEnabled: false,
+    /*
+     * The eleven flags of analysis document section 13.2, which grades each
+     * one. That grading is carried here per flag, because two of the eleven are
+     * *retained* from 2.1.233 rather than resolved from this build -- their
+     * upstream gates gave no answer -- and nothing in the value itself
+     * distinguishes a retained flag from a derived one. A later release that
+     * resolves a retained gate changes that flag on evidence; a later release
+     * that merely repeats it has learned nothing.
+     */
+    betaPolicy: {
+      // RETAINED. The gate reduces to a predicate whose own gate is
+      // unresolved. What it decides is position rather than presence: the SDK
+      // appends the OAuth beta unconditionally on a token-cache session
+      // (section 8.3), so the choice is slot 2 versus appended last, and this
+      // profile pins slot 2 as 2.1.195 and 2.1.233 do.
+      oauthAuthenticated: true,
+      // Derived.
+      experimentalBetasEnabled: true,
+      // From the bundle: the gate reads an opt-out environment variable that is
+      // unset by default.
+      oneMillionContextEnabled: true,
+      // Derived.
+      interleavedThinkingEnabled: true,
+      // Derived.
+      interactive: true,
+      // Derived.
+      thinkingSummariesShown: false,
+      // Derived.
+      thinkingTokenCountEnabled: true,
+      // From the bundle, and inert for this profile either way: the 2.1.280
+      // registry slot that would carry `narration_summaries` is null in this
+      // build, so there is no entry for this flag to gate.
+      narrationSummariesEnabled: false,
+      // Derived.
+      structuredOutputsEnabled: false,
+      // RETAINED. Its gates are unresolved in this build.
+      afkModeEnabled: false,
+      // Changed from 2.1.233, where the 2.1.233 profile pins `false`. Section
+      // 7.6.2 resolves all three legs of the 2.1.280 gate to true. Whether the
+      // 2.1.233 value was always wrong cannot be settled without the 2.1.233
+      // binary, and inferring one release's value from another's is exactly
+      // what the tracking runbook forbids, so that profile is deliberately left
+      // alone.
+      cacheDiagnosisEnabled: true,
+    },
+    /**
+     * Verbatim genuine-client catalogue, 20 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",
+        ],
+      },
+      // 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 },
+      },
+      "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",
+          "adaptive_thinking",
+          "context_management",
+        ],
+      },
+      "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",
+      },
+      // Gains `mid_conv_tool_change` since 2.1.233. That key is mapped by
+      // `deriveCapabilitiesFromCatalogue` to `midConvToolChange`, and it
+      // drives the `mid-conversation-tool-changes-2026-07-01` beta header
+      // (section 7.6) through the guard transcribed in section 13.3.
+      "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",
+          "mid_conv_tool_change",
+          "context_management",
+          "fast_mode",
+          "lean_prompt",
+        ],
+        defaultEffort: "high",
+      },
+      // Gains `mid_conv_tool_change` and `thinking_disabled_effort_cap` since
+      // 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",
+          "mid_conv_tool_change",
+          "context_management",
+          "thinking_disabled_effort_cap",
+          "fast_mode",
+          "lean_prompt",
+          "refusal_fallback",
+          "opus_5_prompt_bundle",
+        ],
+        defaultEffort: "high",
+      },
+      // New at 2.1.280, and the only catalogue entry in any ported profile
+      // whose `default_effort` is `medium`. It is also the only entry whose
+      // default and upper output-token limits are both 128000.
+      "claude-opus-5-5": {
+        family: "opus",
+        context: { window: 1e6, native1m: true, supports1mBeta: true },
+        maxOutputTokens: { default: 128000, upper: 128000 },
+        capabilities: [
+          "effort",
+          "max_effort",
+          "xhigh_effort",
+          "adaptive_thinking",
+          "rejects_disabled_thinking",
+          "mid_conv_system",
+          "mid_conv_tool_change",
+          "per_turn_effort",
+          "per_turn_timing",
+          "context_management",
+          "fast_mode",
+          "lean_prompt",
+          "refusal_fallback",
+          "opus_5_5_prompt_bundle",
+        ],
+        defaultEffort: "medium",
+      },
+      // Gains `mid_conv_tool_change` since 2.1.233. Carries no `fast_mode`,
+      // as in 2.1.233.
+      "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",
+          "mid_conv_tool_change",
+          "context_management",
+          "lean_prompt",
+          "fable_5_mitigations",
+          "refusal_fallback",
+        ],
+        defaultEffort: "high",
+      },
+      // New at 2.1.280.
+      "claude-fable-5-1": {
+        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",
+          "mid_conv_tool_change",
+          "per_turn_effort",
+          "per_turn_timing",
+          "context_management",
+          "lean_prompt",
+          "fable_5_mitigations",
+          "refusal_fallback",
+          "fable_5_1_prompt_bundle",
+        ],
+        defaultEffort: "high",
+      },
+      // Keeps the empty capability array it was catalogued with at 2.1.233.
+      // That is a denial, not a gap.
+      "claude-mythos-5": {
+        family: "mythos",
+        context: { window: 1e6, native1m: true, supports1mBeta: true },
+        capabilities: [],
+        maxOutputTokens: { default: 64000, upper: 128000 },
+      },
+      // New at 2.1.280. Unlike `claude-fable-5-1` it carries no
+      // `per_turn_effort` and no `refusal_fallback`.
+      "claude-mythos-5-1": {
+        family: "mythos",
+        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",
+          "mid_conv_tool_change",
+          "per_turn_timing",
+          "context_management",
+          "lean_prompt",
+          "fable_5_mitigations",
+          "fable_5_1_prompt_bundle",
+        ],
+        defaultEffort: "high",
+      },
+    },
+  });

package/src/redaction.ts

@@ -75,6 +75,7 @@ const ENDPOINT = "https://api.anthropic.com/v1/messages?beta=true";
 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",
+  "claude-code-2.1.280-sdk-0.112.1",
 ]);
 const FORBIDDEN_KEYS = new Set(["__proto__", "prototype", "constructor"]);
 const SAFE_ERROR_CODES = new Set([
@@ -267,6 +268,8 @@ function capabilityDecisions(
     contextManagement: requested?.contextManagement ?? false,
     temperature: requested?.temperature ?? false,
     rejectsDisabledThinking: requested?.rejectsDisabledThinking ?? false,
+    midConvToolChange: requested?.midConvToolChange ?? false,
+    perTurnEffort: requested?.perTurnEffort ?? false,
   });
 }
 

package/src/request-body.ts

@@ -357,6 +357,8 @@ type ModelResolution = Readonly<{
     contextManagement: boolean;
     temperature: boolean;
     rejectsDisabledThinking: boolean;
+    midConvToolChange: boolean;
+    perTurnEffort: boolean;
   }>;
 }>;
 
@@ -1451,7 +1453,11 @@ function modelResolution(
     (capabilities.temperature !== undefined &&
       typeof capabilities.temperature !== "boolean") ||
     (capabilities.rejectsDisabledThinking !== undefined &&
-      typeof capabilities.rejectsDisabledThinking !== "boolean")
+      typeof capabilities.rejectsDisabledThinking !== "boolean") ||
+    (capabilities.midConvToolChange !== undefined &&
+      typeof capabilities.midConvToolChange !== "boolean") ||
+    (capabilities.perTurnEffort !== undefined &&
+      typeof capabilities.perTurnEffort !== "boolean")
   ) {
     fail("INVALID_INPUT");
   }
@@ -1486,6 +1492,14 @@ function modelResolution(
         capabilities.rejectsDisabledThinking,
         derived.rejectsDisabledThinking,
       ),
+      midConvToolChange: capabilityBoolean(
+        capabilities.midConvToolChange,
+        derived.midConvToolChange,
+      ),
+      perTurnEffort: capabilityBoolean(
+        capabilities.perTurnEffort,
+        derived.perTurnEffort,
+      ),
     },
   };
 }
@@ -1731,6 +1745,7 @@ export function buildCanonicalBody(
   rawSystemBlocks: unknown,
   rawMetadata: unknown,
   profile?: ClaudeCodeProtocolProfile,
+  thinkingDisplayOverride?: "updates",
 ): Readonly<Record<string, unknown>> {
   inspectJsonInputs([
     rawInput,
@@ -1837,6 +1852,7 @@ export function buildCanonicalBody(
     effectiveProfile.betaPolicy,
     maxTokens,
     effectiveProfile,
+    thinkingDisplayOverride,
   );
   if (resolved.emitted !== undefined) result["thinking"] = resolved.emitted;
 
@@ -1902,9 +1918,15 @@ export function buildCanonicalBody(
       result["output_format"] = nullable(item, outputFormat);
     else if (key === "toolChoice") {
       const validatedToolChoice = toolChoice(item);
+      // Upstream demotes only `tool` here. This package deliberately also
+      // demotes `any`: the Messages API rejects every forced tool choice while
+      // extended thinking is on, so passing `any` through could only produce
+      // an HTTP 400. Shared by every profile; see `MEMORY.md`, 2026-09-24.
+      const forcedToolChoice =
+        validatedToolChoice["type"] === "tool" ||
+        validatedToolChoice["type"] === "any";
       result["tool_choice"] =
-        validatedToolChoice["type"] === "tool" &&
-        resolved.extendedThinkingActive
+        forcedToolChoice && resolved.extendedThinkingActive
           ? { type: "auto" }
           : validatedToolChoice;
     } else if (key === "topP") result["top_p"] = requireNumber(item);

package/src/thinking.ts

@@ -70,7 +70,12 @@ export interface ResolvedThinking {
    * suppresses `temperature`, matching upstream `nr`.
    */
   readonly requestActive: boolean;
-  /** Whether `tool_choice` of type `tool` must be demoted to `auto`. */
+  /**
+   * Whether a forced `tool_choice` (type `tool` or `any`) must be demoted to
+   * `auto`. Upstream demotes only `tool`; demoting `any` as well is a
+   * deliberate divergence, because the API rejects any forced tool choice
+   * while extended thinking is on (see `MEMORY.md`, 2026-09-24).
+   */
   readonly extendedThinkingActive: boolean;
 }
 
@@ -275,6 +280,92 @@ export function isThinkingDisplayActive(
   );
 }
 
+/**
+ * The three thinking types the resolver can emit, or `undefined` when no
+ * `thinking` object reaches the wire at all.
+ */
+export type ResolvedThinkingType = "adaptive" | "enabled" | "disabled";
+
+/**
+ * Narrows an unvalidated caller `thinking` value to its `type` literal.
+ *
+ * Deliberately tolerant of unvalidated input for the same reason
+ * `isThinkingDisplayActive` is: beta composition asks this question before
+ * `buildCanonicalBody` has validated the shape. Anything malformed answers
+ * `undefined` here and is rejected later by the body validator.
+ */
+function thinkingRequestType(
+  request: unknown,
+): ThinkingRequest["type"] | undefined {
+  if (request === null || typeof request !== "object") return undefined;
+  const type = (request as Record<string, unknown>)["type"];
+  if (type === "enabled" || type === "adaptive" || type === "disabled") {
+    return type;
+  }
+  return undefined;
+}
+
+/**
+ * Decides WHICH thinking object `resolveThinking` will emit, without building
+ * it.
+ *
+ * Split out of `resolveThinking` so that beta composition and body emission
+ * answer the same question from one place. A second, independently written
+ * copy of this predicate is exactly how a beta header and the body field it
+ * is coupled to drift apart.
+ */
+export function resolveThinkingType(
+  requestType: ThinkingRequest["type"] | undefined,
+  capabilities: ClaudeCodeCapabilities,
+): ResolvedThinkingType | undefined {
+  const requestActive = requestType !== undefined && requestType !== "disabled";
+  if (requestActive && capabilities.thinking) {
+    return capabilities.adaptiveThinking ? "adaptive" : "enabled";
+  }
+  if (
+    requestType === "disabled" &&
+    capabilities.thinking &&
+    !capabilities.rejectsDisabledThinking
+  ) {
+    return "disabled";
+  }
+  return undefined;
+}
+
+/**
+ * Upstream `ac = Kg && Fg() && iQt(model)`, the predicate the 2.1.280 thinking
+ * push sites gate on, with `Fg()` (`experimentalBetasEnabled`) factored OUT.
+ *
+ * Every push site conjoins the experimental gate itself, so folding it in here
+ * would count it twice and make the one site that legitimately does not want it
+ * impossible to express. `Kg`'s environment-disable term is not modelled: this
+ * package reads no environment.
+ *
+ * This is deliberately NOT `ResolvedThinking.requestActive`. That one is true
+ * whenever the caller asked for thinking at all, including for a model whose
+ * capabilities emit no thinking object — which would ship a thinking beta
+ * header for a body that carries no thinking block.
+ *
+ * Upstream `ac` conjoins only the interleaved predicate `iQt`; requiring a
+ * resolved `"adaptive"`/`"enabled"` type additionally requires
+ * `capabilities.thinking`, one conjunct more than upstream. That extra term is
+ * unobservable in practice: `supportsThinking` and `supportsInterleavedThinking`
+ * in `model-capabilities.ts` are the same expression, so no derived capability
+ * set separates them. Only an explicit caller capability override can, and then
+ * the package declines to announce a thinking beta for a request whose body
+ * will carry no thinking object.
+ */
+export function isThinkingActive(
+  request: unknown,
+  capabilities: ClaudeCodeCapabilities,
+): boolean {
+  const type = resolveThinkingType(thinkingRequestType(request), capabilities);
+  return (
+    (type === "adaptive" || type === "enabled") &&
+    capabilities.interleavedThinking
+  );
+}
+
 /**
  * Resolves the caller's thinking request into the object the genuine client
  * would put on the wire.
@@ -283,6 +374,13 @@ export function isThinkingDisplayActive(
  * for the enabled branch — `budget_tokens` FIRST — and `{type, display}` for
  * adaptive. Serialised bodies are compared byte for byte, so the insertion
  * order below must not be rearranged.
+ *
+ * `displayOverride` is the body-side half of beta push site 12b
+ * (`thinkingDisplayOverride` from `composeBetasWithAudit`); it is not
+ * caller-facing, which is why `ThinkingDisplay` stays unwidened. When both it
+ * and a caller display are present the override wins -- a combination the
+ * composition guard makes unreachable, since site 12b requires that the caller
+ * supplied no display.
  */
 export function resolveThinking(
   request: ThinkingRequest | undefined,
@@ -291,6 +389,7 @@ export function resolveThinking(
   betaPolicy: ClaudeCodeBetaPolicy,
   maxTokens: number,
   profile: ClaudeCodeProtocolProfile = CLAUDE_CODE_2_1_195_PROFILE,
+  displayOverride?: "updates",
 ): ResolvedThinking {
   // Upstream `nr = n.type !== "disabled" && !CLAUDE_CODE_DISABLE_THINKING`.
   const requestActive = request !== undefined && request.type !== "disabled";
@@ -301,38 +400,61 @@ export function resolveThinking(
   );
   const display = displayActive ? request?.display : undefined;
 
+  const resolvedType = resolveThinkingType(request?.type, capabilities);
+
   let emitted: Record<string, unknown> | undefined;
 
-  if (requestActive && capabilities.thinking) {
-    if (capabilities.adaptiveThinking) {
-      emitted = { type: "adaptive" };
-      if (display !== undefined) emitted["display"] = display;
-    } else {
-      // 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, profile, maxTokens).upperLimit - 1;
-      emitted = { budget_tokens: Math.min(maxTokens - 1, requested) };
-      emitted["type"] = "enabled";
-      if (display !== undefined) emitted["display"] = display;
-    }
-  } else if (
-    request?.type === "disabled" &&
-    capabilities.thinking &&
-    !capabilities.rejectsDisabledThinking
-  ) {
+  if (resolvedType === "adaptive") {
+    emitted = { type: "adaptive" };
+    if (display !== undefined) emitted["display"] = display;
+    // Assignment, not reconstruction: an existing key keeps its position and a
+    // new one appends last, matching upstream `{...yc, display: "updates"}`.
+    if (displayOverride !== undefined) emitted["display"] = displayOverride;
+  } else if (resolvedType === "enabled") {
+    // Transcribed from the 2.1.280 analysis document:
+    //   let hf = mlo(_e);
+    //   if (r.type === "enabled" && r.budgetTokens !== void 0) hf = r.budgetTokens;
+    //   hf = Math.max(1024, Math.min(Rv - 1, hf));
+    // The default budget is the model's upper limit minus one. The caller's
+    // `budgetTokens` replaces it only when the caller itself declared an
+    // `enabled` request -- the guard reads the caller's raw `type`, not the
+    // resolved one, so an `adaptive` request downgraded to `enabled` on a
+    // model without adaptive thinking ignores its budget. The result is
+    // clamped to the emitted `max_tokens` minus one, and the floor of 1024 is
+    // applied after that clamp, so the floor wins when the two conflict.
+    //
+    // No older analysis document in this repository transcribes this
+    // computation at all, so the floor and the type guard are evidenced for
+    // 2.1.280 only. They are applied to every profile as one shared
+    // behaviour -- the same deliberate choice already made for the model-id
+    // normalizer ladder -- and nothing here asserts whether older clients
+    // had them.
+    //
+    // 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 callerBudget =
+      request?.type === "enabled" ? request.budgetTokens : undefined;
+    const requested =
+      callerBudget ??
+      modelOutputTokenLimits(normalizedId, profile, maxTokens).upperLimit - 1;
+    emitted = {
+      budget_tokens: Math.max(1024, Math.min(maxTokens - 1, requested)),
+    };
+    emitted["type"] = "enabled";
+    if (display !== undefined) emitted["display"] = display;
+    // Same in-place assignment as the adaptive arm: order stays
+    // `budget_tokens, type, display`.
+    if (displayOverride !== undefined) emitted["display"] = displayOverride;
+  } else if (resolvedType === "disabled") {
     emitted = { type: "disabled" };
   }
 
   // Upstream `Jr = Xn?.type === "enabled" || Xn?.type === "adaptive"
   //             || Xn === void 0 && U4e(u)`.
+  // Upstream uses this to demote `tool_choice` of type `tool`; the
+  // request body also demotes type `any` on it, a documented divergence.
   const extendedThinkingActive =
     emitted?.["type"] === "enabled" ||
     emitted?.["type"] === "adaptive" ||