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

package/src/betas.ts

@@ -11,8 +11,10 @@ import {
   supportsStructuredOutputs,
 } from "./model-capabilities.js";
 import { BETA_REGISTRY_2_1_233 } from "./profiles/beta-registry-2.1.233.js";
+import { BETA_REGISTRY_2_1_280 } from "./profiles/beta-registry-2.1.280.js";
 import { CLAUDE_CODE_2_1_195_PROFILE } from "./profiles/claude-code-2.1.195.js";
 import { CLAUDE_CODE_2_1_233_PROFILE } from "./profiles/claude-code-2.1.233.js";
+import { CLAUDE_CODE_2_1_280_PROFILE } from "./profiles/claude-code-2.1.280.js";
 
 /*
  * Provenance. The emitted order is a port of the genuine client's base beta set
@@ -41,13 +43,22 @@ interface BetaRegistryEntry {
  * The entries the push sites below require, as a structural contract rather
  * than a reference to one concrete registry.
  *
- * Registry versions have different key sets. Every key here except
- * `NARRATION_SUMMARIES` is present in all of them, so those push sites index
- * directly. `NARRATION_SUMMARIES` is optional because upstream removed it after
- * 2.1.195 (see `src/profiles/beta-registry-2.1.233.ts`): its push site survives
- * and becomes inert when the resolved registry has no entry to push. Making the
- * optionality part of the TYPE is what forces every future registry to be
- * checked against the push sites at compile time instead of at runtime.
+ * Registry versions have different key sets. Every REQUIRED key here is present
+ * in all of them, so those push sites index directly. The optional ones are
+ * optional because they exist in some registry versions and not others, and a
+ * push site whose key is absent becomes inert: it evaluates its gates, finds no
+ * entry, pushes nothing, and the surrounding order closes up with no gap.
+ * Making the optionality part of the TYPE is what forces every future registry
+ * to be checked against the push sites at compile time instead of at runtime.
+ *
+ * `NARRATION_SUMMARIES` is optional in the older direction -- upstream removed
+ * it after 2.1.195 (see `src/profiles/beta-registry-2.1.233.ts`). The keys
+ * added for 2.1.280 -- the remaining optional members declared below -- are
+ * optional in the newer direction: they are absent from the 2.1.195 registry,
+ * and all but `PER_MESSAGE_EFFORT` are absent from the 2.1.233 one. `PER_MESSAGE_EFFORT` IS declared by the 2.1.233 registry, so
+ * registry absence does not keep its site inert there; what does is the
+ * catalogue, because no 2.1.233 model declares the backing capability. The two
+ * mechanisms are not interchangeable and both are load-bearing.
  */
 export interface ComposableBetaRegistry {
   readonly CLAUDE_CODE: BetaRegistryEntry;
@@ -60,7 +71,12 @@ export interface ComposableBetaRegistry {
   readonly STRUCTURED_OUTPUTS: BetaRegistryEntry;
   readonly PROMPT_CACHING_SCOPE: BetaRegistryEntry;
   readonly MID_CONVERSATION_SYSTEM: BetaRegistryEntry;
+  readonly PER_MESSAGE_EFFORT?: BetaRegistryEntry;
+  readonly MID_CONV_TOOL_CHANGE?: BetaRegistryEntry;
+  readonly MID_CONVERSATION_SYSTEM_CLEAR_AT?: BetaRegistryEntry;
   readonly EFFORT: BetaRegistryEntry;
+  readonly THINKING_BINDING_CONTROLS?: BetaRegistryEntry;
+  readonly THINKING_DISPLAY_UPDATES?: BetaRegistryEntry;
   readonly SPEED: BetaRegistryEntry;
   readonly AFK_MODE: BetaRegistryEntry;
   readonly EXTENDED_CACHE_TTL: BetaRegistryEntry;
@@ -73,6 +89,7 @@ const PROFILE_BETA_REGISTRIES: ReadonlyMap<string, ComposableBetaRegistry> =
   new Map<string, ComposableBetaRegistry>([
     [CLAUDE_CODE_2_1_195_PROFILE.id, BETA_REGISTRY],
     [CLAUDE_CODE_2_1_233_PROFILE.id, BETA_REGISTRY_2_1_233],
+    [CLAUDE_CODE_2_1_280_PROFILE.id, BETA_REGISTRY_2_1_280],
   ]);
 
 /**
@@ -84,8 +101,17 @@ const PROFILE_BETA_REGISTRIES: ReadonlyMap<string, ComposableBetaRegistry> =
  * give `composeBetas` a second, differently-worded opinion about profile
  * validity. Standalone callers keep the 2.1.195 behaviour they had before
  * profiles were a parameter.
+ *
+ * Exported for tests only, and deliberately NOT re-exported from
+ * `src/index.ts`: the public runtime surface stays closed. That fallback is
+ * precisely why a test needs to reach this function. A profile bound to the
+ * wrong registry, or to none, silently composes against 2.1.195 instead of
+ * failing, and every required key of `ComposableBetaRegistry` currently
+ * carries an identical header in all three registries -- so a mis-binding
+ * changes no emitted byte and no behavioural suite can see it. Asking this
+ * function directly is the only way to observe the binding at all.
  */
-function resolveBetaRegistry(
+export function resolveBetaRegistry(
   profile: ClaudeCodeProtocolProfile,
 ): ComposableBetaRegistry {
   return PROFILE_BETA_REGISTRIES.get(profile.id) ?? BETA_REGISTRY;
@@ -96,6 +122,17 @@ export interface ComposeBetasInput {
   readonly normalizedId: string;
   readonly capabilities: ClaudeCodeCapabilities;
   readonly thinkingDisplayActive: boolean;
+  /**
+   * Whether a `thinking` object of type `adaptive` or `enabled` will reach the
+   * wire for this request AND the model is interleaved-thinking capable, i.e.
+   * upstream `ac` minus its `Fg()` term. Compute it with `isThinkingActive`
+   * from `./thinking.js`; never re-derive it at a call site.
+   *
+   * Required rather than optional: it is a total function of inputs every call
+   * site already holds, and requiring it is what forces a new call site to
+   * decide rather than silently inherit a default.
+   */
+  readonly thinkingActive: boolean;
   readonly cacheTtl?: "5m" | "1h" | null;
   readonly speed?: "standard" | "fast" | null;
   /**
@@ -129,6 +166,19 @@ export interface ComposeBetasInput {
 export interface ComposedBetas {
   readonly betas: readonly string[];
   readonly suppressedBetaNames: readonly string[];
+  /**
+   * Present only when push site 12b fired. This is the body-side half of a
+   * beta/body pair: the site pushes the display-updates beta AND decides that
+   * the body's `thinking` object carries `display: "updates"`. The consumer is
+   * the canonical body builder (`buildCanonicalBody`), which hands it to
+   * `resolveThinking`.
+   *
+   * `suppressBetas` cannot unset it. Suppressing the beta identifier removes
+   * the HEADER only; the body keeps `display: "updates"`. That matches the
+   * existing coupled pair where suppressing `effort-2025-11-24` leaves
+   * `output_config.effort` in the body.
+   */
+  readonly thinkingDisplayOverride?: "updates";
 }
 
 /**
@@ -240,10 +290,151 @@ export function composeBetasWithAudit(
 
   // No web-search beta: upstream pushes it only for vertex and foundry.
   if (experimental) out.push(registry.PROMPT_CACHING_SCOPE.header);
-  if (supportsMidConversationSystem(input.normalizedId, profile))
+
+  /*
+   * Upstream `jR`. The local boolean below records that this site PUSHED, which
+   * is what sites 11b and 11c gate on -- upstream reads `Ee.includes(jR)`, the
+   * composed array, not the registry. Asking the registry instead would fire
+   * those two sites for a model this one skipped.
+   */
+  const midConversationSystemFired = supportsMidConversationSystem(
+    input.normalizedId,
+    profile,
+  );
+  if (midConversationSystemFired) {
     out.push(registry.MID_CONVERSATION_SYSTEM.header);
+  }
+
+  /*
+   * Site 11a. Upstream `wRt`, which reduces to
+   * `Fg() && mD(provider) && catalogue-declares-per_turn_effort`; the provider
+   * term is first-party here by construction.
+   */
+  const perMessageEffort = registry.PER_MESSAGE_EFFORT;
+  if (
+    experimental &&
+    input.capabilities.perTurnEffort &&
+    perMessageEffort !== undefined
+  ) {
+    out.push(perMessageEffort.header);
+  }
+
+  /*
+   * Site 11b. Upstream `oQt() && Tue(model)`. `Tue` opens with
+   * `if (!Fg() || !kue(e)) return false`, so the experimental gate is upstream's
+   * and not an addition. Step 3 of `Tue` -- which sends the beta for any model
+   * with NO catalogue entry -- is deliberately not ported; see the analysis
+   * document's divergence record.
+   */
+  const midConvToolChange = registry.MID_CONV_TOOL_CHANGE;
+  if (
+    experimental &&
+    midConversationSystemFired &&
+    input.capabilities.midConvToolChange &&
+    midConvToolChange !== undefined
+  ) {
+    out.push(midConvToolChange.header);
+  }
+
+  /*
+   * Site 11c. Upstream `Mo`, which is the one site whose experimental gate is
+   * invisible at the statement level -- `Mo` names no `Fg()` at all. The gate is
+   * reached three calls deep instead: `Mee` is `oRt(model) !== "off"`, `oRt`
+   * wraps `fur`, and `fur` opens by returning `"off"` when `Fg()` is false. So
+   * `experimental` is upstream's own conjunct here exactly as it is at 11a and
+   * 11b, and a reader who checks only the `Mo` expression will wrongly conclude
+   * it was invented. It was not.
+   *
+   * `Mo`'s remaining conjuncts are constants for this package. `!l7(querySource)`
+   * holds because `l7` is true only for the two auto-mode query sources. `!Vr`
+   * holds because `Vr` is a per-session latch, and a stateless package composes
+   * every request as a first request. `Mee`'s other terms are fixed on the
+   * first-party path. What is left is `Ee.includes(jR)`, which is precisely the
+   * `midConversationSystemFired` outcome recorded at site 11.
+   */
+  const midConversationSystemClearAt =
+    registry.MID_CONVERSATION_SYSTEM_CLEAR_AT;
+  if (
+    experimental &&
+    midConversationSystemFired &&
+    midConversationSystemClearAt !== undefined
+  ) {
+    out.push(midConversationSystemClearAt.header);
+  }
+
+  // Site 12.
   if (input.capabilities.effort) out.push(registry.EFFORT.header);
 
+  /*
+   * Site 12a. Upstream `er && Fg()` with the latch write, which on the pinned
+   * first-party path collapses to thinking-active AND experimental.
+   * The coupled body field `thinking.block_binding` is NOT emitted: it needs a
+   * host override this package cannot observe.
+   */
+  const thinkingBindingControls = registry.THINKING_BINDING_CONTROLS;
+  if (
+    experimental &&
+    input.thinkingActive &&
+    thinkingBindingControls !== undefined
+  ) {
+    out.push(thinkingBindingControls.header);
+  }
+
+  /*
+   * Site 12b. Upstream guards the push with
+   * `(yc?.type === "adaptive" || yc?.type === "enabled") && ac && firstParty
+   *  && !callerSuppliedDisplay && ...` plus the simulate-proxy environment
+   * variable and a per-session latch. The reachable remainder of that guard is
+   * modelled below: `experimental` is upstream's `Fg()` term inside `ac`,
+   * `input.thinkingActive` is the thinking-type test together with the rest of
+   * `ac`, and `!input.thinkingDisplayActive` is the caller-supplied-display
+   * test. First-party is not modelled because this package only builds the
+   * first-party path, the simulate-proxy env var is not modelled because the
+   * package reads no environment, and the per-session latch is always empty in
+   * a stateless package that composes every request as a first request.
+   *
+   * The branch is additionally reached only when the display-mode resolver
+   * `Gxt` returns its connector-text result; its other results break out
+   * before the push. `!policy.thinkingSummariesShown` is that resolver's
+   * `sQt()` term, mapped onto the profile flag exactly as at the
+   * redact-thinking site above. See the 2.1.280 analysis document, §6.4, for
+   * the resolver itself.
+   *
+   * The resolver's other two diverting branches are already covered by
+   * `!thinkingDisplayActive`. A caller display of `"summarized"` takes the
+   * first branch, and `"omitted"` takes the second whenever the
+   * explicit-display flag is falsy, which is the only state this package can
+   * express -- it models no equivalent of that flag. Under a truthy
+   * explicit-display flag upstream would fall through and overwrite an
+   * explicit `"omitted"` with `"updates"`; that input is unreachable here, and
+   * is recorded rather than modelled.
+   *
+   * The site is coupled: it pushes the beta, records `display: "updates"` for
+   * the body builder, and removes the previously composed redact-thinking beta
+   * (upstream `qu()`).
+   *
+   * The splice sits INSIDE this block and is deliberately the LAST thing it
+   * does. At this point `out` holds only canonical pushes, because the caller
+   * `additionalBetas` merge runs later. So a caller who explicitly supplies
+   * `redact-thinking-2026-02-12` in `additionalBetas` still gets it, precisely
+   * because the merge's `if (!out.includes(beta))` test now succeeds. Moving
+   * the splice after the merge would silently eat that caller's entry.
+   */
+  const thinkingDisplayUpdates = registry.THINKING_DISPLAY_UPDATES;
+  let thinkingDisplayOverride: "updates" | undefined;
+  if (
+    experimental &&
+    input.thinkingActive &&
+    !policy.thinkingSummariesShown &&
+    !input.thinkingDisplayActive &&
+    thinkingDisplayUpdates !== undefined
+  ) {
+    out.push(thinkingDisplayUpdates.header);
+    thinkingDisplayOverride = "updates";
+    const redactIndex = out.indexOf(registry.REDACT_THINKING.header);
+    if (redactIndex !== -1) out.splice(redactIndex, 1);
+  }
+
   if (input.speed === "fast" && !out.includes(registry.SPEED.header)) {
     out.push(registry.SPEED.header);
   }
@@ -286,6 +477,9 @@ export function composeBetasWithAudit(
     return Object.freeze({
       betas: Object.freeze(out),
       suppressedBetaNames: NO_SUPPRESSED_BETAS,
+      ...(thinkingDisplayOverride === undefined
+        ? {}
+        : { thinkingDisplayOverride }),
     });
   }
   const suppressed = new Set(validateAdditionalBetas(input.suppressBetas));
@@ -298,5 +492,10 @@ export function composeBetasWithAudit(
   return Object.freeze({
     betas: Object.freeze(kept),
     suppressedBetaNames: Object.freeze(removed),
+    // The suppression filter above touches only the header list; the body
+    // half of the site-12b pair survives it by design.
+    ...(thinkingDisplayOverride === undefined
+      ? {}
+      : { thinkingDisplayOverride }),
   });
 }

package/src/build-request.ts

@@ -30,6 +30,7 @@ import {
 import { resolveModel } from "./models.js";
 import { CLAUDE_CODE_2_1_195_PROFILE } from "./profiles/claude-code-2.1.195.js";
 import { CLAUDE_CODE_2_1_233_PROFILE } from "./profiles/claude-code-2.1.233.js";
+import { CLAUDE_CODE_2_1_280_PROFILE } from "./profiles/claude-code-2.1.280.js";
 import type { NormalizedRequestInput } from "./redaction.js";
 import { buildRedactedEvidence, toSafeErrorDetails } from "./redaction.js";
 import {
@@ -38,7 +39,7 @@ import {
 } from "./request-body.js";
 import { sha256Hex } from "./sha256.js";
 import { buildCanonicalSystem, IDENTITY_TEXT } from "./system-prompt.js";
-import { isThinkingDisplayActive } from "./thinking.js";
+import { isThinkingActive, isThinkingDisplayActive } from "./thinking.js";
 import { classifySurrogateAt } from "./unicode.js";
 
 const METHOD = "POST";
@@ -152,6 +153,8 @@ const CAPABILITY_KEYS = [
   "contextManagement",
   "temperature",
   "rejectsDisabledThinking",
+  "midConvToolChange",
+  "perTurnEffort",
 ] as const;
 const CAPABILITY_KEY_SET = new Set(CAPABILITY_KEYS);
 /** Adds the optional package-extension override keys carried by evidence. */
@@ -319,10 +322,14 @@ function containsString(value: unknown, target: string): boolean {
 }
 
 /**
- * The profiles this package will assemble a request for. Two entries: the
- * 2.1.195 default and the 2.1.233 profile, which callers must pass
- * explicitly. Admitting a profile is exactly this list -- `validateProfile`
- * did not change to accept the second one.
+ * Every pinned profile singleton, and nothing else. The set is not enumerated
+ * in prose here: the literal below IS the enumeration and cannot go stale,
+ * whereas a count in a comment goes stale on the next port -- which is exactly
+ * what happened to the text this replaced. Which profile a caller gets when it
+ * passes none is `DEFAULT_PROFILE` below and is deliberately not restated
+ * here, so that a default switch touches one line rather than two. Admitting a
+ * profile is exactly this list -- `validateProfile` never changed to accept a
+ * new one.
  *
  * Membership is by REFERENCE, deliberately. A structural check would accept a
  * caller-built object that merely looks like a pinned profile, and every wire
@@ -339,11 +346,16 @@ function containsString(value: unknown, target: string): boolean {
 const ACCEPTED_PROFILES: ReadonlySet<ClaudeCodeProtocolProfile> = new Set([
   CLAUDE_CODE_2_1_195_PROFILE,
   CLAUDE_CODE_2_1_233_PROFILE,
+  CLAUDE_CODE_2_1_280_PROFILE,
 ]);
 
 /**
- * The profile every public entry point resolves to when the caller supplies
- * none. Declared once so that the default is a single, greppable seam: a test
+ * The profile the request-building entry points (`buildClaudeCodeRequest`,
+ * `buildClaudeCodeCountTokensRequest` and `parseBuiltClaudeCodeRequest`)
+ * resolve to when the caller supplies none. It is not a global default: the
+ * model-query and anti-verbosity helpers deliberately keep their own,
+ * separately declared default and are NOT governed by this constant. Declared
+ * once so that the default is a single, greppable seam: a test
  * that means "whatever the default is" reads THIS instead of naming a
  * version, which keeps a default switch to a one-line diff and keeps tests
  * that genuinely mean 2.1.195 honest about saying so.
@@ -352,7 +364,7 @@ const ACCEPTED_PROFILES: ReadonlySet<ClaudeCodeProtocolProfile> = new Set([
  * from `src/index.ts`: the public runtime surface stays closed.
  */
 export const DEFAULT_PROFILE: ClaudeCodeProtocolProfile =
-  CLAUDE_CODE_2_1_233_PROFILE;
+  CLAUDE_CODE_2_1_280_PROFILE;
 
 function validateProfile(
   profile: ClaudeCodeProtocolProfile,
@@ -950,6 +962,8 @@ function requestedCapabilities(
     temperature: raw?.temperature ?? supported.temperature,
     rejectsDisabledThinking:
       raw?.rejectsDisabledThinking ?? supported.rejectsDisabledThinking,
+    midConvToolChange: raw?.midConvToolChange ?? supported.midConvToolChange,
+    perTurnEffort: raw?.perTurnEffort ?? supported.perTurnEffort,
   };
   for (const key of CAPABILITY_KEYS) {
     if (typeof result[key] !== "boolean") fail("UNSUPPORTED_CAPABILITY");
@@ -1038,7 +1052,7 @@ function parseCapabilityDecisions(
   value: unknown,
 ): ClaudeCodeCapabilityDecisions {
   if (!isRecord(value)) fail();
-  // The nine capability keys are mandatory; the package-extension override keys
+  // Every capability key is mandatory; the package-extension override keys
   // are optional and must survive the round-trip untouched, so they are allowed
   // here but never synthesized.
   assertExactKeys(value, CAPABILITY_DECISION_KEY_SET);
@@ -1064,6 +1078,8 @@ function parseCapabilityDecisions(
     contextManagement: readBoolean("contextManagement"),
     temperature: readBoolean("temperature"),
     rejectsDisabledThinking: readBoolean("rejectsDisabledThinking"),
+    midConvToolChange: readBoolean("midConvToolChange"),
+    perTurnEffort: readBoolean("perTurnEffort"),
   };
 }
 
@@ -1071,7 +1087,7 @@ function parseCapabilityDecisions(
  * Validates evidence against the profile the request was parsed under, not
  * against a hardcoded singleton. `parseBuiltClaudeCodeRequest` already
  * validates `url` against `pinnedProfile.endpoint`; the profile id is the one
- * remaining field where the two pinned profiles differ, so it has to follow
+ * remaining field where pinned profiles differ, so it has to follow
  * the same source or a request built with a non-default profile could never
  * be re-parsed. Still fail-closed: the profile reaching here has already
  * passed `validateProfile`.
@@ -1442,6 +1458,10 @@ export async function buildClaudeCodeCountTokensRequest(
           normalizedId: resolvedModel.id,
           capabilities: resolvedModel.capabilities,
           thinkingDisplayActive: false,
+          // A constant, not a re-derivation: this path carries no thinking
+          // request, so `isThinkingActive(undefined, capabilities)` is false
+          // by construction.
+          thinkingActive: false,
         },
         effectiveProfile,
       ),
@@ -1516,8 +1536,9 @@ export async function buildClaudeCodeCountTokensRequest(
 /**
  * Builds one canonical request for the pinned Claude Code wire profile.
  *
- * @param profile - The only accepted value is the exported
- * `CLAUDE_CODE_2_1_195_PROFILE` singleton. Any other object, even a
+ * @param profile - The accepted values are the exported pinned profile
+ * singletons held in `ACCEPTED_PROFILES`; omitting the argument resolves to
+ * `DEFAULT_PROFILE`. Any other object, even a
  * structurally identical clone, is rejected with `ClaudeCodeWireError` code
  * `INVALID_INPUT`. This deliberate fail-closed behaviour prevents callers from
  * substituting an unpinned protocol profile.
@@ -1581,13 +1602,12 @@ export async function buildClaudeCodeRequest(
       validated.suppressBillingBlock,
       validated.suppressIdentityBlock,
     );
-    const canonicalBody = buildCanonicalBody(
-      evidenceRequest(validated.source, validated.source.model),
-      effectiveModel,
-      system,
-      metadata,
-      effectiveProfile,
-    );
+    /*
+     * Composition runs BEFORE body construction so that a beta site can hand a
+     * decision to the body emitter. Both calls are pure and neither feeds the
+     * other's arguments today, so the order itself changes no serialised byte;
+     * the swap lands on its own so the packed-consumer digests prove that.
+     */
     const composedBetas = composeBetasWithAudit(
       {
         rawModel: validated.source.model,
@@ -1598,6 +1618,10 @@ export async function buildClaudeCodeRequest(
           capabilities,
           effectiveProfile.betaPolicy,
         ),
+        thinkingActive: isThinkingActive(
+          validated.source.thinking,
+          capabilities,
+        ),
         ...(validated.source.cacheControl?.ttl === undefined
           ? {}
           : { cacheTtl: validated.source.cacheControl.ttl }),
@@ -1616,6 +1640,14 @@ export async function buildClaudeCodeRequest(
       },
       effectiveProfile,
     );
+    const canonicalBody = buildCanonicalBody(
+      evidenceRequest(validated.source, validated.source.model),
+      effectiveModel,
+      system,
+      metadata,
+      effectiveProfile,
+      composedBetas.thinkingDisplayOverride,
+    );
     const betas = composedBetas.betas;
     const headerPlan = buildOrderedHeaderPlan({
       accessToken: validated.source.accessToken,
@@ -1706,8 +1738,9 @@ export async function buildClaudeCodeRequest(
 /**
  * Validates and clones a previously built request into a deeply frozen value.
  *
- * @param profile - The only accepted value is the exported
- * `CLAUDE_CODE_2_1_195_PROFILE` singleton. Any other object, even a
+ * @param profile - The accepted values are the exported pinned profile
+ * singletons held in `ACCEPTED_PROFILES`; omitting the argument resolves to
+ * `DEFAULT_PROFILE`. Any other object, even a
  * structurally identical clone, is rejected with `ClaudeCodeWireError` code
  * `INVALID_INPUT`. This deliberate fail-closed behaviour prevents callers from
  * substituting an unpinned protocol profile.

package/src/contracts.ts

@@ -669,6 +669,10 @@ export interface ClaudeCodeCapabilities {
   readonly contextManagement: boolean;
   readonly temperature: boolean;
   readonly rejectsDisabledThinking: boolean;
+  /** Catalogue string `mid_conv_tool_change`. */
+  readonly midConvToolChange: boolean;
+  /** Catalogue string `per_turn_effort`. */
+  readonly perTurnEffort: boolean;
 }
 
 /** Host-state beta gates pinned for a default first-party environment. */
@@ -1221,8 +1225,9 @@ export interface RedactedRequestEvidence {
 }
 
 /**
- * Records the nine model capability decisions, plus any package-extension beta
- * override the caller supplied.
+ * Records every model capability decision -- the key set is exactly
+ * `keyof ClaudeCodeCapabilities`, so it widens whenever that interface does --
+ * plus any package-extension beta override the caller supplied.
  *
  * The override keys are OPTIONAL and are emitted only when the corresponding
  * member of `betaOverrides` is present, so evidence for a request that omits

package/src/fingerprint.ts

@@ -56,6 +56,11 @@ export async function createBillingFingerprint(
   crypto?: Pick<Crypto, "subtle">,
 ): Promise<string> {
   const cryptoProvider = crypto ?? getDefaultCrypto();
+  // The upstream transcription in the analysis doc writes `||` here; `??` is a
+  // deliberate, safe difference, not a divergence to "fix" in either
+  // direction. A string subscript yields either a one-unit string, which is
+  // always truthy, or `undefined`, so no value makes the two operators
+  // disagree (and no test can tell them apart).
   const material = `${FINGERPRINT_PREFIX}${firstUserText[4] ?? "0"}${firstUserText[7] ?? "0"}${firstUserText[20] ?? "0"}${cliVersion}`;
   const bytes = new TextEncoder().encode(material);
 

package/src/headers.ts

@@ -8,6 +8,7 @@ import type {
 import { ClaudeCodeWireError } from "./contracts.js";
 import { CLAUDE_CODE_2_1_195_PROFILE } from "./profiles/claude-code-2.1.195.js";
 import { CLAUDE_CODE_2_1_233_PROFILE } from "./profiles/claude-code-2.1.233.js";
+import { CLAUDE_CODE_2_1_280_PROFILE } from "./profiles/claude-code-2.1.280.js";
 
 const HEADER_NAMES = Object.freeze({
   anthropicBeta: "anthropic-beta",
@@ -163,13 +164,14 @@ function parseExtraHeaderPolicy(value: unknown): ClaudeCodeExtraHeaderPolicy {
 
 /**
  * Accepts a pinned profile by REFERENCE, never by shape, and returns the
- * singleton itself so nothing downstream can be handed a look-alike. Adding
- * the second pinned profile widens the accepted set by exactly one object;
+ * singleton itself so nothing downstream can be handed a look-alike. Each
+ * pinned profile widens the accepted set by exactly one object;
  * anything else, including a structural clone, still fails closed.
  */
 function parseProfile(value: unknown): ClaudeCodeProtocolProfile {
   if (value === CLAUDE_CODE_2_1_195_PROFILE) return CLAUDE_CODE_2_1_195_PROFILE;
   if (value === CLAUDE_CODE_2_1_233_PROFILE) return CLAUDE_CODE_2_1_233_PROFILE;
+  if (value === CLAUDE_CODE_2_1_280_PROFILE) return CLAUDE_CODE_2_1_280_PROFILE;
   throw new ClaudeCodeWireError("INVALID_INPUT");
 }
 

package/src/index.ts

@@ -82,5 +82,7 @@ export {
 } from "./model-queries.js";
 
 export { BETA_REGISTRY_2_1_233 } from "./profiles/beta-registry-2.1.233.js";
+export { BETA_REGISTRY_2_1_280 } from "./profiles/beta-registry-2.1.280.js";
 export { CLAUDE_CODE_2_1_195_PROFILE } from "./profiles/claude-code-2.1.195.js";
 export { CLAUDE_CODE_2_1_233_PROFILE } from "./profiles/claude-code-2.1.233.js";
+export { CLAUDE_CODE_2_1_280_PROFILE } from "./profiles/claude-code-2.1.280.js";