@tormentalabs/claude-code-wire-compat 0.5.0 → 0.7.0-rc.1

package/src/build-request.ts

@@ -1,5 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
+import { MAX_INPUT_SIZE } from "./limits.js";
+
 import { composeBetas, composeBetasWithAudit } from "./betas.js";
 import type {
   BuiltClaudeCodeCountTokensRequest,
@@ -30,6 +32,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,12 +41,16 @@ import {
 } from "./request-body.js";
 import { sha256Hex } from "./sha256.js";
 import { buildCanonicalSystem, IDENTITY_TEXT } from "./system-prompt.js";
-import { isThinkingDisplayActive } from "./thinking.js";
-import { classifySurrogateAt } from "./unicode.js";
+import { isThinkingActive, isThinkingDisplayActive } from "./thinking.js";
+import {
+  inspectText,
+  TEXT_POLICY_IDENTIFIER,
+  TEXT_POLICY_PROSE,
+} from "./unicode.js";
+import { violationDetails, type ViolationPathSegment } from "./violation.js";
 
 const METHOD = "POST";
 const MAX_INPUT_DEPTH = 100;
-const MAX_INPUT_SIZE = 1_000_000;
 const FORBIDDEN_KEYS = new Set(["__proto__", "prototype", "constructor"]);
 const INPUT_KEYS = new Set([
   "accessToken",
@@ -152,6 +159,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. */
@@ -197,8 +206,9 @@ type UnknownRecord = Readonly<Record<string, unknown>>;
 
 function fail(
   code: ConstructorParameters<typeof ClaudeCodeWireError>[0] = "INVALID_INPUT",
+  safeDetails: Readonly<Record<string, string | number | boolean>> = {},
 ): never {
-  throw new ClaudeCodeWireError(code);
+  throw new ClaudeCodeWireError(code, safeDetails);
 }
 
 function isRecord(value: unknown): value is UnknownRecord {
@@ -228,39 +238,51 @@ function assertExactKeys(
 /**
  * Screens one string from the caller's input graph.
  *
- * TAB (0x09), LF (0x0A) and CR (0x0D) are ALLOWED. This function walks the
- * whole input graph, which is overwhelmingly BODY content — message text,
- * system blocks, tool descriptions — where a line break is ordinary prose that
- * `JSON.stringify` escapes on the way out. Rejecting them here made the package
- * unusable for real traffic: no genuine prompt is a single line.
+ * BODY PROSE POLICY (decision P1.T1, 2026-09-25): every well-formed UTF-16
+ * string is accepted. Control characters are valid Unicode scalars;
+ * `JSON.stringify` escapes the C0 range and emits DEL/C1 raw, and
+ * `TextEncoder` encodes every scalar deterministically, so no control
+ * character can desync the body from its hash. Real tool output legitimately
+ * carries ESC (ANSI colour), NUL, FF and DEL; synthetic probes reproduced
+ * rejection before fetch, not the original incident's exact input. The old rule was a
+ * library-local defensive heuristic with no upstream provenance; whether the
+ * remote API rejects any scalar is a remote concern, surfaced as a remote
+ * error, not a local pre-flight abort.
  *
- * The strict rule those three characters used to be caught by is a HEADER rule,
- * and it still lives where it belongs and still applies in full:
- * `assertHeaderText` in `src/headers.ts` rejects every control character,
- * including these three, because a bare LF in a header is request smuggling.
- * `src/metadata.ts` is likewise unchanged: `user_id` and metadata keys are
- * identifiers that travel as JSON inside a header, not prose.
+ * What did NOT move:
  *
- * Every other C0 control (0x00-0x08, 0x0B, 0x0C, 0x0E-0x1F) and DEL (0x7F)
- * stay rejected: they have no meaning in prompt text and are a reliable signal
- * of a corrupted or hostile input.
- *
- * LONE SURROGATES stay rejected in every context, deliberately. `TextEncoder`
- * silently replaces them with U+FFFD, so an unpaired surrogate would corrupt
- * the body — and the body hash recorded in evidence — with no error anywhere.
+ * - HEADERS: `assertHeaderText` in `src/headers.ts` still rejects every
+ *   control character, TAB/LF/CR included, because a bare LF in a header is
+ *   request smuggling. `src/metadata.ts` is likewise unchanged: `user_id` and
+ *   metadata keys are identifiers that travel as JSON inside a header, not
+ *   prose, and keep their own strict rule.
+ * - LONE SURROGATES stay rejected in every context, deliberately.
+ *   Raw `TextEncoder` replaces them, whereas JSON serialization escapes them.
+ *   Rejecting them keeps the text contract independent of serialization order.
  */
-function inspectString(value: string): number {
-  for (let index = 0; index < value.length; index += 1) {
-    const unit = value.charCodeAt(index);
-    if (
-      (unit <= 0x1f && unit !== 0x09 && unit !== 0x0a && unit !== 0x0d) ||
-      unit === 0x7f
-    ) {
-      fail("INVALID_UNICODE");
-    }
-    const classification = classifySurrogateAt(value, index);
-    if (classification === "loneSurrogate") fail("INVALID_UNICODE");
-    if (classification === "surrogatePair") index += 1;
+function inspectString(
+  value: string,
+  path: readonly ViolationPathSegment[],
+  inKey: boolean,
+): number {
+  const root = path[0];
+  const prose =
+    root === "messages" ||
+    root === "system" ||
+    root === "tools" ||
+    root === "stopSequences" ||
+    root === "stop_sequences" ||
+    root === "body";
+  const violation = inspectText(
+    value,
+    prose ? TEXT_POLICY_PROSE : TEXT_POLICY_IDENTIFIER,
+  );
+  if (violation !== null) {
+    if (violation.reason === "control-char") fail("INVALID_UNICODE");
+    fail(
+      "INVALID_UNICODE",
+      violationDetails(violation, path, value.length, inKey),
+    );
   }
   return new TextEncoder().encode(value).byteLength;
 }
@@ -268,11 +290,14 @@ function inspectString(value: string): number {
 function inspectGraph(value: unknown): void {
   const active = new WeakSet();
   let size = 0;
+  // Mutable walk stack: pushed/popped per node and only READ (synchronously)
+  // when a failure renders it, so successful requests pay no per-node copy.
+  const path: ViolationPathSegment[] = [];
 
   function visit(current: unknown, depth: number): void {
     if (depth > MAX_INPUT_DEPTH) fail("INPUT_TOO_DEEP");
     if (typeof current === "string") {
-      size += inspectString(current);
+      size += inspectString(current, path, false);
     } else if (
       current === null ||
       typeof current === "boolean" ||
@@ -297,8 +322,16 @@ function inspectGraph(value: unknown): void {
       size += keys.length;
       for (const key of keys) {
         if (typeof key !== "string" || FORBIDDEN_KEYS.has(key)) fail();
-        size += inspectString(key);
+        // Only ARRAY indices become numeric segments; digits inside an object
+        // key are user-controlled text and must stay masked (QA F1).
+        const segment: ViolationPathSegment =
+          Array.isArray(current) && /^(?:0|[1-9]\d{0,5})$/u.test(key)
+            ? Number(key)
+            : key;
+        path.push(segment);
+        size += inspectString(key, path, true);
         visit(ownValue(current, key), depth + 1);
+        path.pop();
       }
       active.delete(current);
     }
@@ -319,10 +352,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 +376,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 +394,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 +992,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 +1082,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 +1108,8 @@ function parseCapabilityDecisions(
     contextManagement: readBoolean("contextManagement"),
     temperature: readBoolean("temperature"),
     rejectsDisabledThinking: readBoolean("rejectsDisabledThinking"),
+    midConvToolChange: readBoolean("midConvToolChange"),
+    perTurnEffort: readBoolean("perTurnEffort"),
   };
 }
 
@@ -1071,7 +1117,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 +1488,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 +1566,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 +1632,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 +1648,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 +1670,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 +1768,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.
@@ -1730,6 +1793,7 @@ export function parseBuiltClaudeCodeRequest(
     const body = ownValue(value, "body");
     if (typeof body !== "string") fail();
     const parsedBody = parseBody(body);
+    inspectGraph(parsedBody);
     const headers = parseHeaders(ownValue(value, "headers"));
     const evidence = parseEvidence(ownValue(value, "evidence"), pinnedProfile);
     // Reading evidence is not trusting evidence. A claim that the seam

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";

package/src/limits.ts

@@ -0,0 +1,4 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+/** Aggregate graph budget, not a serialized request-size guarantee. */
+export const MAX_INPUT_SIZE = 1_000_000;

package/src/model-capabilities.ts

@@ -9,20 +9,20 @@ import { profileBehaviors } from "./profile-behaviors.js";
 import { CLAUDE_CODE_2_1_195_PROFILE } from "./profiles/claude-code-2.1.195.js";
 
 /*
- * Capability derivation, ported from the genuine client's nine capability
- * predicates.
+ * Capability derivation, ported from the genuine client's capability
+ * predicates and, since 2.1.280, from catalogue strings that have no predicate
+ * upstream at all.
  *
  * READ THIS FIRST -- there are two derivation paths and they are not
  * interchangeable:
  *
  *   1. Catalogue path (`deriveCapabilitiesFromCatalogue`), taken for every id
- *      present in the 2.1.195 catalogue. Six of the nine capabilities have a
- *      verbatim upstream string in `ClaudeCodeCatalogueEntry.capabilities`
- *      (`effort`, `max_effort`, `xhigh_effort`, `adaptive_thinking`,
- *      `context_management`, `rejects_disabled_thinking`) and are read from
- *      there. The other three (`thinking`, `interleavedThinking`,
- *      `temperature`) have NO catalogue string in any client version and stay
- *      predicate-derived.
+ *      present in the catalogue. The fields listed in
+ *      `CATALOGUE_BACKED_CAPABILITIES` have a verbatim upstream string in
+ *      `ClaudeCodeCatalogueEntry.capabilities` and are read from there; that
+ *      map is the enumeration, so this comment does not repeat it. The rest
+ *      (`thinking`, `interleavedThinking`, `temperature`) have NO catalogue
+ *      string in any client version and stay predicate-derived.
  *   2. Predicate fallback (`deriveCapabilitiesFromPredicates`), taken for ids
  *      with no catalogue entry -- `claude-mythos-5` (absent by product
  *      decision D-1), ids from a newer client, and anything that escaped
@@ -39,7 +39,7 @@ import { CLAUDE_CODE_2_1_195_PROFILE } from "./profiles/claude-code-2.1.195.js";
  * surprising:
  *
  *   On the first-party provider -- the only provider this package targets --
- *   every one of these nine predicates reduces to a pure function of the
+ *   every one of these predicates reduces to a pure function of the
  *   normalized model id.
  *
  * Why. Upstream, each predicate has the shape
@@ -87,7 +87,7 @@ import { CLAUDE_CODE_2_1_195_PROFILE } from "./profiles/claude-code-2.1.195.js";
  * `claude-mythos-5` has no catalogue entry by product decision D-1. Upstream
  * special-cases it by name in `Kw`, `Hke`, `Yte` and `Uot`; this port subsumes
  * those clauses into the first-party fallback, which yields an identical
- * result. The explicit D-1 test asserting its full nine-boolean row is the
+ * result. The explicit D-1 test asserting its full capability row is the
  * guard for that equivalence.
  *
  * Model ids reaching these functions have already been normalized by
@@ -337,11 +337,19 @@ export function rejectsDisabledThinking(normalizedId: string): boolean {
 }
 
 /**
- * The six `ClaudeCodeCapabilities` fields the catalogue represents, paired
- * with their verbatim upstream capability string. The three omitted fields --
- * `thinking`, `interleavedThinking`, `temperature` -- have no catalogue
- * string in any client version and are derived from their predicates on both
- * paths.
+ * The `ClaudeCodeCapabilities` fields the catalogue represents, paired with
+ * their verbatim upstream capability string. Whatever is not a key here --
+ * `thinking`, `interleavedThinking` and `temperature` today -- has no
+ * catalogue string in any client version and is derived from its predicate on
+ * both paths. The literal below is the enumeration; no count is restated in
+ * prose, because a count beside the thing it counts goes stale on the next
+ * port.
+ *
+ * `per_turn_timing` is deliberately NOT mapped. It is a real 2.1.280
+ * catalogue string carried by three models, but the beta it would gate,
+ * `timing-2026-09-09`, is environment-gated off on the default path, so a
+ * field here would be a capability nothing reads. Mapping it would invent a
+ * derived value with no emission behind it.
  */
 const CATALOGUE_BACKED_CAPABILITIES = {
   effort: "effort",
@@ -350,12 +358,14 @@ const CATALOGUE_BACKED_CAPABILITIES = {
   adaptiveThinking: "adaptive_thinking",
   contextManagement: "context_management",
   rejectsDisabledThinking: "rejects_disabled_thinking",
+  midConvToolChange: "mid_conv_tool_change",
+  perTurnEffort: "per_turn_effort",
 } as const;
 
 /**
- * Pure catalogue -> capabilities mapping. Reads nothing but `entry` for the
- * six catalogue-backed fields; `normalizedId` is used only for the three
- * fields the catalogue does not represent.
+ * Pure catalogue -> capabilities mapping. Reads nothing but `entry` for every
+ * catalogue-backed field; `normalizedId` is used only for the fields the
+ * catalogue does not represent.
  *
  * This function applies no exceptions and no id special cases. The one cell
  * where the 2.1.195 catalogue disagrees with the wire is corrected by the
@@ -381,6 +391,8 @@ export function deriveCapabilitiesFromCatalogue(
     rejectsDisabledThinking: has(
       CATALOGUE_BACKED_CAPABILITIES.rejectsDisabledThinking,
     ),
+    midConvToolChange: has(CATALOGUE_BACKED_CAPABILITIES.midConvToolChange),
+    perTurnEffort: has(CATALOGUE_BACKED_CAPABILITIES.perTurnEffort),
   });
 }
 
@@ -408,6 +420,30 @@ function deriveCapabilitiesFromPredicates(
     contextManagement: supportsContextManagement(normalizedId),
     temperature: supportsTemperature(normalizedId),
     rejectsDisabledThinking: rejectsDisabledThinking(normalizedId),
+    /*
+     * Both are FALSE here, and this is the one place where the two derivation
+     * paths stop agreeing in kind: the six older catalogue-backed fields above
+     * resolve maximally permissive for an uncatalogued id, these two resolve
+     * restrictive. That asymmetry is deliberate, and the reason differs per
+     * field.
+     *
+     * `perTurnEffort: false` MATCHES upstream. Its lookup consults the static
+     * catalogue and, at default settings, the remote client-data path that
+     * could override it is empty, so an id with no entry yields false there
+     * too.
+     *
+     * `midConvToolChange: false` DIVERGES from upstream, which still sends
+     * `mid-conversation-tool-changes-2026-07-01` for a model it has no
+     * catalogue entry for. The analysis document records that as a divergence
+     * recorded but not ported, for the same reason the package declines the
+     * neighbouring permissive tail: a capability granted to an unknown id is a
+     * guess about a model this package knows nothing about.
+     *
+     * Neither field has an upstream predicate to fall back on -- both exist
+     * only as catalogue strings -- so there is no third option here.
+     */
+    midConvToolChange: false,
+    perTurnEffort: false,
   });
 }
 

package/src/model-identity.ts

@@ -21,17 +21,30 @@ function dottedToDashedVersion(model: string): string {
   return model.replace(/(\d)\.(\d)/g, "$1-$2");
 }
 
-/** Ports upstream `$_` (binary offset 226639025). */
+/**
+ * Ports upstream `$_` (binary offset 226639025); in the 2.1.280 bundle the
+ * function is `GF` at byte offset 7413751. The two offsets are in different
+ * address spaces: the first indexes the 2.1.195 platform binary, the second
+ * the carved 2.1.280 JavaScript bundle, so neither can be found in the other.
+ *
+ * Rung order is load-bearing: each test is a substring test, so a longer id
+ * must precede the shorter id it contains or the shorter rung swallows it.
+ */
 export function normalizeModelId(model: string): string {
   model = dottedToDashedVersion(model.toLowerCase());
+  if (model.includes("claude-fable-5-1")) return "claude-fable-5-1";
   if (model.includes("claude-fable-5")) return "claude-fable-5";
+  if (model.includes("claude-mythos-5-1")) return "claude-mythos-5-1";
   if (model.includes("claude-mythos-5")) return "claude-mythos-5";
+  if (model.includes("claude-opus-5-5")) return "claude-opus-5-5";
+  if (model.includes("claude-opus-5")) return "claude-opus-5";
   if (model.includes("claude-opus-4-8")) return "claude-opus-4-8";
   if (model.includes("claude-opus-4-7")) return "claude-opus-4-7";
   if (model.includes("claude-opus-4-6")) return "claude-opus-4-6";
   if (model.includes("claude-opus-4-5")) return "claude-opus-4-5";
   if (model.includes("claude-opus-4-1")) return "claude-opus-4-1";
   if (/claude-opus-4(?!-\d(?!\d))/.test(model)) return "claude-opus-4-0";
+  if (model.includes("claude-sonnet-5")) return "claude-sonnet-5";
   if (model.includes("claude-sonnet-4-6")) return "claude-sonnet-4-6";
   if (model.includes("claude-sonnet-4-5")) return "claude-sonnet-4-5";
   if (/claude-sonnet-4(?!-\d(?!\d))/.test(model)) return "claude-sonnet-4-0";