@tormentalabs/claude-code-wire-compat 0.1.0-rc.16 → 0.1.0

package/src/metadata.ts

@@ -0,0 +1,331 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+import { ClaudeCodeWireError } from "./contracts.js";
+import type {
+  ClaudeCodeMetadataOverrides,
+  ClaudeCodeRuntimeIdentity,
+  JsonValue,
+} from "./contracts.js";
+import { inspectJsonInputs, validatedJson } from "./request-body.js";
+import { classifySurrogateAt } from "./unicode.js";
+
+const MAX_TEXT_LENGTH = 8_192;
+const FORBIDDEN_KEYS = new Set(["__proto__", "prototype", "constructor"]);
+const CORRELATION_KEYS = new Set([
+  "user_id",
+  "device_id",
+  "account_uuid",
+  "session_id",
+]);
+/**
+ * The members of the derived `user_id` JSON object.
+ *
+ * `metadataOverrides.userIdFields` may not carry these keys: the package writes
+ * them last so correlation always wins, and a silently overwritten caller value
+ * would look honoured while being discarded.
+ */
+const IDENTITY_KEYS = new Set(["device_id", "account_uuid", "session_id"]);
+
+function hasInvalidUtf16(value: string): boolean {
+  for (let index = 0; index < value.length; index += 1) {
+    const classification = classifySurrogateAt(value, index);
+    if (classification === "loneSurrogate") return true;
+    if (classification === "surrogatePair") index += 1;
+  }
+  return false;
+}
+
+function hasControlCharacter(value: string): boolean {
+  for (let index = 0; index < value.length; index += 1) {
+    const codeUnit = value.charCodeAt(index);
+    if (codeUnit <= 0x1f || codeUnit === 0x7f) return true;
+  }
+  return false;
+}
+
+function ownDataValue(value: object, key: string): unknown {
+  const descriptor = Object.getOwnPropertyDescriptor(value, key);
+  return descriptor === undefined || !("value" in descriptor)
+    ? undefined
+    : descriptor.value;
+}
+
+function validateIdentityText(
+  value: unknown,
+  field: keyof ClaudeCodeRuntimeIdentity,
+): string {
+  if (typeof value !== "string") {
+    throw new ClaudeCodeWireError("INVALID_IDENTITY", { field });
+  }
+  if (hasInvalidUtf16(value)) {
+    throw new ClaudeCodeWireError("INVALID_UNICODE", { field });
+  }
+  if (
+    value.length === 0 ||
+    value.length > MAX_TEXT_LENGTH ||
+    value.trim().length === 0 ||
+    hasControlCharacter(value)
+  ) {
+    throw new ClaudeCodeWireError("INVALID_IDENTITY", { field });
+  }
+  return value;
+}
+
+function validateIdentityObject(identity: unknown): object {
+  if (
+    typeof identity !== "object" ||
+    identity === null ||
+    Array.isArray(identity)
+  ) {
+    throw new ClaudeCodeWireError("INVALID_IDENTITY");
+  }
+  for (const key of Reflect.ownKeys(identity)) {
+    if (typeof key !== "string" || FORBIDDEN_KEYS.has(key)) {
+      throw new ClaudeCodeWireError("INVALID_IDENTITY");
+    }
+  }
+  return identity;
+}
+
+export function validateRuntimeIdentity(
+  identity: unknown,
+): ClaudeCodeRuntimeIdentity {
+  const source = validateIdentityObject(identity);
+  const sessionId = validateIdentityText(
+    ownDataValue(source, "sessionId"),
+    "sessionId",
+  );
+  const deviceId = validateIdentityText(
+    ownDataValue(source, "deviceId"),
+    "deviceId",
+  );
+  const accountUuid = validateIdentityText(
+    ownDataValue(source, "accountUuid"),
+    "accountUuid",
+  );
+  const runtime = validateIdentityText(
+    ownDataValue(source, "runtime"),
+    "runtime",
+  );
+  const runtimeVersion = validateIdentityText(
+    ownDataValue(source, "runtimeVersion"),
+    "runtimeVersion",
+  );
+  const os = validateIdentityText(ownDataValue(source, "os"), "os");
+  const arch = validateIdentityText(ownDataValue(source, "arch"), "arch");
+
+  if (runtime !== "node" && runtime !== "bun" && runtime !== "workerd") {
+    throw new ClaudeCodeWireError("INVALID_IDENTITY", { field: "runtime" });
+  }
+  if (os !== "Windows" && os !== "Linux" && os !== "macOS") {
+    throw new ClaudeCodeWireError("INVALID_IDENTITY", { field: "os" });
+  }
+
+  return Object.freeze({
+    sessionId,
+    deviceId,
+    accountUuid,
+    runtime,
+    runtimeVersion,
+    os,
+    arch,
+  });
+}
+
+function validateMetadataKey(key: PropertyKey): string {
+  if (typeof key !== "string" || FORBIDDEN_KEYS.has(key)) {
+    throw new ClaudeCodeWireError("INVALID_INPUT");
+  }
+  if (hasInvalidUtf16(key)) {
+    throw new ClaudeCodeWireError("INVALID_UNICODE", { field: "metadataKey" });
+  }
+  if (key.length > MAX_TEXT_LENGTH) {
+    throw new ClaudeCodeWireError("INPUT_TOO_LARGE", {
+      field: "metadataKey",
+    });
+  }
+  if (key.length === 0 || hasControlCharacter(key)) {
+    throw new ClaudeCodeWireError("INVALID_INPUT", { field: "metadataKey" });
+  }
+  return key;
+}
+
+function validateMetadataValue(value: unknown, key: string): JsonValue {
+  if (typeof value === "string") {
+    if (hasInvalidUtf16(value)) {
+      throw new ClaudeCodeWireError("INVALID_UNICODE", { field: key });
+    }
+    if (value.length > MAX_TEXT_LENGTH) {
+      throw new ClaudeCodeWireError("INPUT_TOO_LARGE", { field: key });
+    }
+    if (hasControlCharacter(value)) {
+      throw new ClaudeCodeWireError("INVALID_UNICODE", { field: key });
+    }
+    return value;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new ClaudeCodeWireError("INVALID_INPUT", { field: key });
+    }
+    return value;
+  }
+  if (typeof value === "boolean" || value === null) return value;
+  if (typeof value !== "object") {
+    throw new ClaudeCodeWireError("INVALID_INPUT", { field: key });
+  }
+  inspectJsonInputs([value], (nestedString) => {
+    if (hasInvalidUtf16(nestedString)) {
+      throw new ClaudeCodeWireError("INVALID_UNICODE", { field: key });
+    }
+    if (nestedString.length > MAX_TEXT_LENGTH) {
+      throw new ClaudeCodeWireError("INPUT_TOO_LARGE", { field: key });
+    }
+    if (hasControlCharacter(nestedString)) {
+      throw new ClaudeCodeWireError("INVALID_UNICODE", { field: key });
+    }
+  });
+  return validatedJson(value);
+}
+
+function expectedCorrelationValue(
+  key: string,
+  identity: ClaudeCodeRuntimeIdentity,
+  userId: string,
+): string | undefined {
+  switch (key) {
+    case "user_id":
+      return userId;
+    case "device_id":
+      return identity.deviceId;
+    case "account_uuid":
+      return identity.accountUuid;
+    case "session_id":
+      return identity.sessionId;
+    default:
+      return undefined;
+  }
+}
+
+function validateMetadataObject(metadata: unknown): object {
+  if (
+    typeof metadata !== "object" ||
+    metadata === null ||
+    Array.isArray(metadata)
+  ) {
+    throw new ClaudeCodeWireError("INVALID_INPUT", { field: "metadata" });
+  }
+  return metadata;
+}
+
+/**
+ * Validates a package-extension `user_id` replacement.
+ *
+ * PACKAGE EXTENSION, not observed Claude Code behaviour. The value is opaque to
+ * this package, so it is checked only for wire-safety, never for correlation.
+ */
+function validateOverrideUserId(value: unknown): string {
+  if (typeof value !== "string") {
+    throw new ClaudeCodeWireError("INVALID_INPUT", { field: "userId" });
+  }
+  if (hasInvalidUtf16(value)) {
+    throw new ClaudeCodeWireError("INVALID_UNICODE", { field: "userId" });
+  }
+  if (value.length > MAX_TEXT_LENGTH) {
+    throw new ClaudeCodeWireError("INPUT_TOO_LARGE", { field: "userId" });
+  }
+  if (hasControlCharacter(value)) {
+    throw new ClaudeCodeWireError("INVALID_UNICODE", { field: "userId" });
+  }
+  if (value.length === 0 || value.trim().length === 0) {
+    throw new ClaudeCodeWireError("INVALID_INPUT", { field: "userId" });
+  }
+  return value;
+}
+
+/** Validates the package-extension members merged into the `user_id` object. */
+function validateUserIdFields(value: unknown): [string, JsonValue][] {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new ClaudeCodeWireError("INVALID_INPUT", { field: "userIdFields" });
+  }
+  const entries: [string, JsonValue][] = [];
+  for (const rawKey of Reflect.ownKeys(value)) {
+    const key = validateMetadataKey(rawKey);
+    if (IDENTITY_KEYS.has(key)) {
+      throw new ClaudeCodeWireError("INVALID_INPUT", { field: key });
+    }
+    entries.push([key, validateMetadataValue(ownDataValue(value, key), key)]);
+  }
+  return entries;
+}
+
+/**
+ * Resolves the emitted `user_id`, applying the package-extension seam.
+ *
+ * With no overrides this is the derived correlation triple, byte for byte as
+ * before the seam existed. The two override members are mutually exclusive
+ * because they express opposite intents: one abandons the derived value, the
+ * other extends it.
+ */
+function resolveUserId(
+  identity: ClaudeCodeRuntimeIdentity,
+  overrides: unknown,
+): string {
+  const correlation = {
+    device_id: identity.deviceId,
+    account_uuid: identity.accountUuid,
+    session_id: identity.sessionId,
+  };
+  if (overrides === undefined) return JSON.stringify(correlation);
+  if (
+    typeof overrides !== "object" ||
+    overrides === null ||
+    Array.isArray(overrides)
+  ) {
+    throw new ClaudeCodeWireError("INVALID_INPUT", {
+      field: "metadataOverrides",
+    });
+  }
+  const hasUserId = Object.hasOwn(overrides, "userId");
+  const hasUserIdFields = Object.hasOwn(overrides, "userIdFields");
+  if (hasUserId && hasUserIdFields) {
+    throw new ClaudeCodeWireError("INVALID_INPUT", {
+      field: "metadataOverrides",
+    });
+  }
+  if (hasUserId) {
+    return validateOverrideUserId(ownDataValue(overrides, "userId"));
+  }
+  if (!hasUserIdFields) return JSON.stringify(correlation);
+  const fields = validateUserIdFields(ownDataValue(overrides, "userIdFields"));
+  // Caller members first, correlation last: the triple always wins, which
+  // mirrors how the consumer composes the same object.
+  return JSON.stringify({ ...Object.fromEntries(fields), ...correlation });
+}
+
+export function buildCorrelatedMetadata(
+  identity: ClaudeCodeRuntimeIdentity,
+  suppliedMetadata?: Readonly<Record<string, JsonValue>>,
+  overrides?: ClaudeCodeMetadataOverrides,
+): Readonly<Record<string, JsonValue>> {
+  const validatedIdentity = validateRuntimeIdentity(identity);
+  const userId = resolveUserId(validatedIdentity, overrides);
+  const entries: [string, JsonValue][] = [["user_id", userId]];
+
+  if (suppliedMetadata === undefined) return Object.freeze({ user_id: userId });
+  const metadataObject = validateMetadataObject(suppliedMetadata);
+
+  for (const rawKey of Reflect.ownKeys(metadataObject)) {
+    const key = validateMetadataKey(rawKey);
+    const value = validateMetadataValue(ownDataValue(metadataObject, key), key);
+    if (CORRELATION_KEYS.has(key)) {
+      const expected = expectedCorrelationValue(key, validatedIdentity, userId);
+      if (value !== expected) {
+        throw new ClaudeCodeWireError("INVALID_INPUT", { field: key });
+      }
+      if (key === "user_id") continue;
+    }
+    entries.push([key, value]);
+  }
+
+  return Object.freeze(Object.fromEntries(entries));
+}

package/src/model-capabilities.ts

@@ -0,0 +1,295 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+import type { ClaudeCodeCapabilities } from "./contracts.js";
+
+/*
+ * Capability derivation, ported from the genuine client's nine capability
+ * predicates.
+ *
+ * THE LOAD-BEARING FACT, stated up front because it is 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
+ *   normalized model id. The catalogue's `capabilities` string array does not
+ *   participate in capability derivation at all.
+ *
+ * Why. Upstream, each predicate has the shape
+ *
+ *     let override = W9(model, cap);            // env-var capability override
+ *     if (override !== undefined) return override;
+ *     let id = mo(model);                       // normalize
+ *     if (<exclusion list>) return false;
+ *     if (JB(id, cap) || id === "claude-mythos-5") return true;
+ *     return ZO(l_(model));                     // provider fallback
+ *
+ * and in this package:
+ *
+ *   - `W9` opens with `if (td()) return;` and `td()` is true for first party,
+ *     so the override always yields `undefined`. It also reads environment
+ *     variables, which this package is designed never to do. Guard dropped.
+ *   - `ZO(...)` is `provider is firstParty|anthropicAws|foundry|mantle`. The
+ *     profile pins `provider: "anthropic"`, so `ZO(...)` is unconditionally
+ *     true and `return ZO(l_(e))` becomes `return true`.
+ *   - Therefore the `JB(id, cap)` catalogue-membership test and the
+ *     `claude-mythos-5` special case can only return `true` from a position
+ *     where the fallback already returns `true`. They are unobservable.
+ *   - `l_(e) === "foundry"` branches are unreachable for the same reason.
+ *   - `ut(CLAUDE_CODE_ALWAYS_ENABLE_EFFORT)` reads an environment variable;
+ *     dropped by the same design rule as `W9`.
+ *
+ * Only the leading exclusion list is observable, so that is all these
+ * functions contain.
+ *
+ * WARNING TO FUTURE READERS. Two things follow that look like bugs and are not:
+ *
+ *   1. No membership test was lost. Do NOT "restore" a `JB`-equivalent check
+ *      here. Adding one back cannot change any result, but it reintroduces
+ *      dead branches that cannot be covered or mutation-killed.
+ *   2. The catalogue `capabilities` arrays are retained in the profile as
+ *      faithful transcribed evidence AND are consumed elsewhere --
+ *      `mid_conv_system`, `lean_prompt` and `fast_mode` are read by later
+ *      work packages. Do NOT delete them because this module ignores them.
+ *
+ * `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
+ * guard for that equivalence.
+ *
+ * Model ids reaching these functions have already been normalized by
+ * `resolveModel` via `normalizeModelId`.
+ */
+
+/**
+ * Upstream `Kw` at byte offset 227719902.
+ *
+ * Elided: the `W9` override, `CLAUDE_CODE_ALWAYS_ENABLE_EFFORT`, the
+ * `JB(id, "effort") || id === "claude-mythos-5"` test, and the `ZO` fallback.
+ */
+export function supportsEffort(normalizedId: string): boolean {
+  if (
+    normalizedId.includes("claude-3-") ||
+    normalizedId === "claude-opus-4-0" ||
+    normalizedId === "claude-opus-4-1" ||
+    normalizedId === "claude-sonnet-4-0" ||
+    normalizedId === "claude-sonnet-4-5" ||
+    normalizedId === "claude-haiku-4-5"
+  ) {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Upstream `Hke` at byte offset 227720257.
+ *
+ * Its exclusion list is `Kw`'s plus `claude-opus-4-5`. Elided: the `W9`
+ * override, the `JB(id, "max_effort") || id === "claude-mythos-5"` test, and
+ * the `ZO` fallback.
+ */
+export function supportsMaxEffort(normalizedId: string): boolean {
+  if (
+    normalizedId.includes("claude-3-") ||
+    normalizedId === "claude-opus-4-0" ||
+    normalizedId === "claude-opus-4-1" ||
+    normalizedId === "claude-opus-4-5" ||
+    normalizedId === "claude-sonnet-4-0" ||
+    normalizedId === "claude-sonnet-4-5" ||
+    normalizedId === "claude-haiku-4-5"
+  ) {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Upstream `Yte` at byte offset 227720583.
+ *
+ * Its exclusion list is `Hke`'s plus `claude-opus-4-6` and
+ * `claude-sonnet-4-6`. Elided: the `W9` override, the
+ * `JB(id, "xhigh_effort") || id === "claude-mythos-5"` test, and the `ZO`
+ * fallback.
+ */
+export function supportsXhighEffort(normalizedId: string): boolean {
+  if (
+    normalizedId.includes("claude-3-") ||
+    normalizedId === "claude-opus-4-0" ||
+    normalizedId === "claude-opus-4-1" ||
+    normalizedId === "claude-opus-4-5" ||
+    normalizedId === "claude-opus-4-6" ||
+    normalizedId === "claude-sonnet-4-0" ||
+    normalizedId === "claude-sonnet-4-5" ||
+    normalizedId === "claude-sonnet-4-6" ||
+    normalizedId === "claude-haiku-4-5"
+  ) {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Upstream `Uot` at byte offset 227383245.
+ *
+ * Its exclusion list is `Kw`'s plus `claude-opus-4-5`, matching `Hke`'s today.
+ * The two are transcribed separately on purpose: they are independent upstream
+ * predicates that happen to agree at this client version. Elided: the `W9`
+ * override, the `JB(id, "adaptive_thinking") || id === "claude-mythos-5"`
+ * test, and the `ZO` fallback.
+ */
+export function supportsAdaptiveThinking(normalizedId: string): boolean {
+  if (
+    normalizedId.includes("claude-3-") ||
+    normalizedId === "claude-opus-4-0" ||
+    normalizedId === "claude-opus-4-1" ||
+    normalizedId === "claude-opus-4-5" ||
+    normalizedId === "claude-sonnet-4-0" ||
+    normalizedId === "claude-sonnet-4-5" ||
+    normalizedId === "claude-haiku-4-5"
+  ) {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Upstream `D9r` at byte offset 227382784.
+ *
+ * Reduces to the same body as `supportsInterleavedThinking` and
+ * `supportsContextManagement` at this client version. Kept separate on
+ * purpose: three independent upstream predicates with different provenance
+ * that are versioned independently upstream. Do not merge them.
+ *
+ * Elided: the `W9` override.
+ */
+export function supportsThinking(normalizedId: string): boolean {
+  return !normalizedId.includes("claude-3-");
+}
+
+/**
+ * Upstream `QOt` at byte offset 227384610.
+ *
+ * See the note on `supportsThinking` about the three identical bodies.
+ * Elided: the `W9` override, the unreachable `foundry` branch, and the
+ * non-`ZO` provider tail (`claude-haiku-4-5` is excluded only for providers
+ * outside `ZO`, which cannot occur here -- note this is why haiku 4.5 has
+ * interleaved thinking on first party but not on, say, vertex).
+ */
+export function supportsInterleavedThinking(normalizedId: string): boolean {
+  return !normalizedId.includes("claude-3-");
+}
+
+/**
+ * Upstream `n0d` at byte offset 227385143.
+ *
+ * See the note on `supportsThinking` about the three identical bodies.
+ * Elided: the unreachable `foundry` branch and the non-`ZO` tail
+ * `JB(id, "context_management") || id === "claude-mythos-5"`. `n0d` has no
+ * `W9` override upstream.
+ */
+export function supportsContextManagement(normalizedId: string): boolean {
+  return !normalizedId.includes("claude-3-");
+}
+
+/**
+ * Upstream `j4e` at byte offset 227385302.
+ *
+ * Elided: the unconditionally true `ZO` provider gate.
+ * This beta-only gate is intentionally absent from `ClaudeCodeCapabilities`.
+ */
+export function supportsStructuredOutputs(normalizedId: string): boolean {
+  return !(
+    normalizedId.includes("claude-3-") ||
+    normalizedId === "claude-opus-4-0" ||
+    normalizedId === "claude-sonnet-4-0"
+  );
+}
+
+/**
+ * Upstream `RCn` at byte offset 227387413.
+ *
+ * Elided: host-state gates, the `W9` override, the unobservable `JB`/mythos
+ * clause, and the unconditionally true `ZO` fallback. This exclusion list
+ * differs from `rejectsDisabledThinking` by one member: that predicate also
+ * excludes `claude-opus-4-8`. Do not merge them.
+ * This beta-only gate is intentionally absent from `ClaudeCodeCapabilities`.
+ */
+export function supportsMidConversationSystem(normalizedId: string): boolean {
+  return !(
+    normalizedId.includes("claude-3-") ||
+    normalizedId === "claude-opus-4-0" ||
+    normalizedId === "claude-opus-4-1" ||
+    normalizedId === "claude-opus-4-5" ||
+    normalizedId === "claude-opus-4-6" ||
+    normalizedId === "claude-opus-4-7" ||
+    normalizedId === "claude-sonnet-4-0" ||
+    normalizedId === "claude-sonnet-4-5" ||
+    normalizedId === "claude-sonnet-4-6" ||
+    normalizedId === "claude-haiku-4-5"
+  );
+}
+
+/**
+ * Upstream `LCn` at byte offset 227385451.
+ *
+ * INVERTED POLARITY relative to every other predicate in this module: this
+ * list is an ALLOWLIST. Membership means temperature IS supported. Do not
+ * refactor it into the shared exclusion-list shape.
+ *
+ * Elided: the `W9` override.
+ */
+export function supportsTemperature(normalizedId: string): boolean {
+  return (
+    normalizedId.includes("claude-3-") ||
+    normalizedId === "claude-opus-4-0" ||
+    normalizedId === "claude-opus-4-1" ||
+    normalizedId === "claude-opus-4-5" ||
+    normalizedId === "claude-opus-4-6" ||
+    normalizedId === "claude-sonnet-4-0" ||
+    normalizedId === "claude-sonnet-4-5" ||
+    normalizedId === "claude-sonnet-4-6" ||
+    normalizedId === "claude-haiku-4-5"
+  );
+}
+
+/**
+ * Upstream `U4e` at byte offset 227382881.
+ *
+ * Its exclusion list is the widest of the five: every catalogue model except
+ * `claude-fable-5`. It has no `W9` override and no `claude-mythos-5` clause
+ * upstream. Elided: the `JB(id, "rejects_disabled_thinking")` test and the
+ * `ZO` fallback.
+ */
+export function rejectsDisabledThinking(normalizedId: string): boolean {
+  if (
+    normalizedId.includes("claude-3-") ||
+    normalizedId === "claude-opus-4-0" ||
+    normalizedId === "claude-opus-4-1" ||
+    normalizedId === "claude-opus-4-5" ||
+    normalizedId === "claude-opus-4-6" ||
+    normalizedId === "claude-opus-4-7" ||
+    normalizedId === "claude-opus-4-8" ||
+    normalizedId === "claude-sonnet-4-0" ||
+    normalizedId === "claude-sonnet-4-5" ||
+    normalizedId === "claude-sonnet-4-6" ||
+    normalizedId === "claude-haiku-4-5"
+  ) {
+    return false;
+  }
+  return true;
+}
+
+export function deriveCapabilities(
+  normalizedId: string,
+): ClaudeCodeCapabilities {
+  return Object.freeze({
+    thinking: supportsThinking(normalizedId),
+    adaptiveThinking: supportsAdaptiveThinking(normalizedId),
+    interleavedThinking: supportsInterleavedThinking(normalizedId),
+    effort: supportsEffort(normalizedId),
+    maxEffort: supportsMaxEffort(normalizedId),
+    xhighEffort: supportsXhighEffort(normalizedId),
+    contextManagement: supportsContextManagement(normalizedId),
+    temperature: supportsTemperature(normalizedId),
+    rejectsDisabledThinking: rejectsDisabledThinking(normalizedId),
+  });
+}

package/src/model-identity.ts

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+import type { ClaudeCodeModelFamily } from "./contracts.js";
+
+/** Ports upstream `dp` (binary offset 226644497). */
+export function stripModelMarkers(model: string): string {
+  return model.replace(/\[(1|2)m\]/gi, "");
+}
+
+/** Ports upstream `$_` (binary offset 226639025). */
+export function normalizeModelId(model: string): string {
+  model = model.toLowerCase();
+  if (model.includes("claude-fable-5")) return "claude-fable-5";
+  if (model.includes("claude-mythos-5")) return "claude-mythos-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-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";
+  if (model.includes("claude-haiku-4-5")) return "claude-haiku-4-5";
+  if (model.includes("claude-3-7-sonnet")) return "claude-3-7-sonnet";
+  if (model.includes("claude-3-5-sonnet")) return "claude-3-5-sonnet";
+  if (model.includes("claude-3-5-haiku")) return "claude-3-5-haiku";
+  if (model.includes("claude-3-opus")) return "claude-3-opus";
+  if (model.includes("claude-3-sonnet")) return "claude-3-sonnet";
+  if (model.includes("claude-3-haiku")) return "claude-3-haiku";
+  return model.replace(/-\d{8}$/, "");
+}
+
+/**
+ * Derives the package-local family classification used only by
+ * `RedactedRequestEvidence`; upstream has no corresponding family concept.
+ */
+export function modelFamilyOf(normalizedId: string): ClaudeCodeModelFamily {
+  if (normalizedId.includes("fable")) return "fable";
+  if (normalizedId.includes("mythos")) return "mythos";
+  if (normalizedId.includes("haiku")) return "haiku";
+  if (normalizedId.includes("sonnet")) return "sonnet";
+  if (normalizedId.includes("opus")) return "opus";
+  return "unknown";
+}