opencode-anthropic-fix 2.0.0 → 2.1.1

package/lib/mimicry/system-prompt.mjs

@@ -1,5 +1,6 @@
 import { isTruthyEnv } from "../env.mjs";
 import { isOpus46Model, isOpus47Model, isOpus48Model } from "./wire-compat.mjs";
+import { truncateGraphemes } from "../unicode-text.mjs";
 
 /**
  * The canonical Claude Code identity text.
@@ -146,16 +147,25 @@ export function tailSystemBlock(text, maxChars, turnThreshold) {
 }
 
 export function compactToolDescription(text) {
-  return text
-    .replace(/<example[\s\S]*?<\/example>/gi, "")
-    .replace(/\|[\s|:-]+\|/g, "")
-    .replace(/^\|.*\|$/gm, "")
-    .replace(/^(?:\s*[-*]\s+.{200,})$/gm, (m) => m.slice(0, 200) + "...")
-    .replace(/^(#{1,3}\s+)/gm, "")
-    .replace(/\*\*([^*]+)\*\*/g, "$1")
-    .replace(/`([^`]+)`/g, "$1")
-    .replace(/\n{3,}/g, "\n\n")
-    .trim();
+  return (
+    text
+      .replace(/<example[\s\S]*?<\/example>/gi, "")
+      .replace(/\|[\s|:-]+\|/g, "")
+      .replace(/^\|.*\|$/gm, "")
+      // Budget is 200 UTF-16 units on the matched line itself; the "..." suffix
+      // is NOT counted against that budget (legacy contract: it is appended
+      // unconditionally after the cut). truncateGraphemes only ever cuts on a
+      // grapheme boundary, so a surrogate pair or combining sequence sitting
+      // across unit 200 is excluded whole rather than split — for ASCII text
+      // (single-unit graphemes) this is byte-for-byte identical to the old
+      // `m.slice(0, 200)`.
+      .replace(/^(?:\s*[-*]\s+.{200,})$/gm, (m) => truncateGraphemes(m, 200) + "...")
+      .replace(/^(#{1,3}\s+)/gm, "")
+      .replace(/\*\*([^*]+)\*\*/g, "$1")
+      .replace(/`([^`]+)`/g, "$1")
+      .replace(/\n{3,}/g, "\n\n")
+      .trim()
+  );
 }
 
 export function compactSystemText(text, mode) {

package/lib/mimicry/wire-compat.mjs

@@ -5,10 +5,10 @@
  */
 
 import {
-  BETA_REGISTRY_2_1_233,
+  BETA_REGISTRY_2_1_280,
   buildClaudeCodeRequest,
   buildClaudeCodeCountTokensRequest,
-  CLAUDE_CODE_2_1_233_PROFILE,
+  CLAUDE_CODE_2_1_280_PROFILE,
   hasOneMillionContext,
   isAdaptiveThinkingModel,
   isClaude3Model,
@@ -22,8 +22,13 @@ import {
   supportsStructuredOutputs,
   supportsWebSearch,
 } from "@tormentalabs/claude-code-wire-compat";
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { stripStainlessHelperMarkers } from "./headers.mjs";
 
+const WIRE_COMPAT_PACKAGE_NAME = "@tormentalabs/claude-code-wire-compat";
+
 /**
  * Model-family predicates, re-exported so the rest of the tree classifies models
  * through the SAME catalogue the request builder classifies them with.
@@ -76,11 +81,11 @@ export {
  * than on the wire.
  *
  * Shape: `{ KEY: { featureKey, header } }`, deep-frozen by the package. It is
- * pinned to 2.1.233 rather than derived from `WIRE_PROFILE` because the package
+ * pinned to 2.1.280 rather than derived from `WIRE_PROFILE` because the package
  * exports no profile->registry accessor; if the emulated baseline moves, this
  * binding and `WIRE_PROFILE` move together.
  */
-export { BETA_REGISTRY_2_1_233 };
+export { BETA_REGISTRY_2_1_280 };
 
 /**
  * 1M-context eligibility under the profile the plugin actually emulates.
@@ -89,7 +94,7 @@ export { BETA_REGISTRY_2_1_233 };
  * PROFILE-DEPENDENT: its second parameter selects the model catalogue, and it
  * defaults to the package's own baseline (2.1.195), not to ours. The two
  * disagree in practice — `claude-mythos-5` is ineligible under 2.1.195 and
- * eligible under 2.1.233 — so calling it bare would gate the plugin's context
+ * eligible under 2.1.280 — so calling it bare would gate the plugin's context
  * decisions on a profile the plugin does not emulate anywhere else.
  *
  * This wrapper binds `WIRE_PROFILE`, so eligibility follows the emulated
@@ -113,14 +118,118 @@ export function isEligibleFor1MContextWire(model) {
  * `mimicryBaseline` reported by `lib/diagnose.mjs` — reads it from here instead
  * of re-declaring a hand-maintained copy.
  *
- * NOTE: this is a BASELINE, not the profile the request path uses. The
- * composition path deliberately passes no explicit `profile` so it inherits the
- * package's `DEFAULT_PROFILE` (see `lib/mimicry/adapter-input.mjs`); naming a
- * profile here only pins what the plugin reports about itself.
+ * THIS IS ALSO THE PROFILE THE REQUEST PATH ACTUALLY USES, not merely a
+ * reporting baseline. `buildWireCompatibleRequest` and
+ * `buildWireCompatibleCountTokensRequest` both pass this constant as the
+ * explicit `profile` argument to `buildClaudeCodeRequest` /
+ * `buildClaudeCodeCountTokensRequest` (see the package's own 0.6.0 CHANGELOG:
+ * "the pin has to be passed on every call to each of the three entry points
+ * that read the default seam -- pinning the builders alone is not enough").
+ *
+ * WHY AN EXPLICIT PASS, RATHER THAN LETTING THE CALL INHERIT THE PACKAGE'S
+ * `DEFAULT_PROFILE`. The dependency is pinned to the `latest` dist-tag
+ * (`docs/shared-package-provenance.md`) precisely so package releases --
+ * fixes, new opt-in fields -- reach the plugin without a code change. Before
+ * this constant was threaded through, an unnamed `profile` argument meant the
+ * EMULATED CLIENT VERSION floated on that same tag: 0.6.0 moved
+ * `DEFAULT_PROFILE` to 2.1.280 in a minor release and broke 48 plugin tests
+ * that were still asserting 2.1.233 bytes. Passing `WIRE_PROFILE` explicitly on
+ * every entry point decouples the two axes: `latest` keeps bringing library
+ * fixes, and the emulated profile now moves only when this binding is
+ * deliberately repointed at a different exported profile singleton -- a
+ * one-line change reviewed like any other wire change, not a side effect of
+ * `npm update`.
  *
  * @type {import('@tormentalabs/claude-code-wire-compat').ClaudeCodeProtocolProfile}
  */
-export const WIRE_PROFILE = CLAUDE_CODE_2_1_233_PROFILE;
+export const WIRE_PROFILE = CLAUDE_CODE_2_1_280_PROFILE;
+
+/**
+ * Version of `@tormentalabs/claude-code-wire-compat` baked in at BUILD time by
+ * `scripts/build.mjs`'s esbuild `define`, read from the package that was
+ * actually installed in `node_modules` when the bundle was produced.
+ *
+ * WHY THIS EXISTS. `getWireCompatPackageVersion` below resolves the version at
+ * RUNTIME through `import.meta.resolve`, which requires the package to still
+ * be a separate, independently resolvable module -- true for an unbundled
+ * import (tests, `node cli.mjs`, a host importing `index.mjs` directly) but
+ * false for the bundles `scripts/build.mjs` produces: esbuild INLINES the
+ * package's source into the single output file, so there is no
+ * `node_modules/@tormentalabs/claude-code-wire-compat` for the bundle to
+ * resolve at its own runtime, and the resolution silently degrades to
+ * "unknown" -- defeating the diagnostic bundle's whole point of reporting what
+ * the running process actually built against.
+ *
+ * `__WIRE_COMPAT_PACKAGE_VERSION__` is a bare, undeclared global identifier,
+ * not an import and not `process.env`, because esbuild's `define` performs a
+ * textual substitution of exactly that shape at bundle time. `typeof` never
+ * throws on an undeclared identifier, so referencing it this way is exactly as
+ * safe unbundled as it is bundled: unbundled, esbuild never touched this file,
+ * the identifier stays undeclared, `typeof` reads `"undefined"`, and this
+ * constant is `undefined` -- `getWireCompatPackageVersion` then falls through
+ * to the runtime resolution exactly as it did before this constant existed.
+ *
+ * @type {string | undefined}
+ */
+/* global __WIRE_COMPAT_PACKAGE_VERSION__:readonly */
+const BUNDLED_WIRE_COMPAT_PACKAGE_VERSION =
+  typeof __WIRE_COMPAT_PACKAGE_VERSION__ === "string" ? __WIRE_COMPAT_PACKAGE_VERSION__ : undefined;
+
+/**
+ * The version of @tormentalabs/claude-code-wire-compat this process actually
+ * runs against: the build-time injected version when bundled (see
+ * `BUNDLED_WIRE_COMPAT_PACKAGE_VERSION` above), otherwise the version
+ * resolved fresh from `node_modules` on every call rather than cached at
+ * module load.
+ *
+ * WHY THE RUNTIME FALLBACK EXISTS. `package.json` pins the dependency to the
+ * `latest` dist-tag (see docs/shared-package-provenance.md), so the version an
+ * UNBUNDLED run actually runs against is whatever `package-lock.json` resolved
+ * at install time -- it is not a literal anywhere in this source tree. A
+ * diagnostic bundle that wants to say what wire the running process is
+ * actually built against (as opposed to `WIRE_PROFILE.cliVersion`, the
+ * BASELINE this file pins) has to read it off disk.
+ *
+ * Deliberately resolves through `node_modules`, not `package-lock.json`: the
+ * lock says what a future `npm ci` WOULD install, `node_modules` says what
+ * THIS process actually loaded, and the two can disagree after an `npm
+ * install` that has not been re-run (see `scripts/check-wire-compat-drift.mjs`,
+ * which checks exactly that disagreement).
+ *
+ * Resolution failure degrades to "unknown" rather than throwing -- a
+ * diagnostic bundle must never fail to build over a missing package.json.
+ *
+ * Resolves via `import.meta.resolve`, not `createRequire(...).resolve`: the
+ * package is ESM-only (its `exports` map declares an `import` condition and
+ * no `require` one), so the CJS resolver fails it with "No 'exports' main
+ * defined" even though the package is genuinely installed.
+ *
+ * @returns {string}
+ */
+export function getWireCompatPackageVersion() {
+  if (BUNDLED_WIRE_COMPAT_PACKAGE_VERSION) return BUNDLED_WIRE_COMPAT_PACKAGE_VERSION;
+  try {
+    let directory = path.dirname(fileURLToPath(import.meta.resolve(WIRE_COMPAT_PACKAGE_NAME)));
+    // Walk up from the package's resolved entry file (e.g. .../dist/index.js)
+    // to the package.json alongside its root -- the entry file is not
+    // guaranteed to be a direct sibling of it.
+    for (let depth = 0; depth < 6; depth += 1) {
+      const candidate = path.join(directory, "package.json");
+      if (existsSync(candidate)) {
+        const manifest = JSON.parse(readFileSync(candidate, "utf8"));
+        if (manifest.name === WIRE_COMPAT_PACKAGE_NAME && typeof manifest.version === "string") {
+          return manifest.version;
+        }
+      }
+      const parent = path.dirname(directory);
+      if (parent === directory) break;
+      directory = parent;
+    }
+  } catch {
+    // Fall through to "unknown".
+  }
+  return "unknown";
+}
 
 const PROFILE_OVERRIDE_ENV = "OPENCODE_ANTHROPIC_PROFILE_OVERRIDE";
 
@@ -408,7 +517,11 @@ export async function buildWireCompatibleRequest(body, transport) {
   stripStainlessHelperMarkers(parsed?.tools, parsed?.messages);
   let built;
   try {
-    built = await buildClaudeCodeRequest(toClaudeCodeRequestInput(parsed, transport));
+    // `WIRE_PROFILE` is passed EXPLICITLY rather than omitted -- see its own
+    // doc comment above for why an omitted argument here would let a future
+    // package release move the emulated client profile out from under the
+    // `latest` dist-tag.
+    built = await buildClaudeCodeRequest(toClaudeCodeRequestInput(parsed, transport), WIRE_PROFILE);
   } catch (error) {
     throw foldSafeDetailsIntoMessage(error);
   }
@@ -501,9 +614,10 @@ export function toClaudeCodeCountTokensInput(body, transport) {
 
 /**
  * Build a Claude Code `/v1/messages/count_tokens` request from the JSON body
- * received from the host. Mirrors `buildWireCompatibleRequest`, including the
- * deliberate absence of an explicit `profile` argument so the count turn
- * inherits the package's `DEFAULT_PROFILE` exactly like the main turn does.
+ * received from the host. Mirrors `buildWireCompatibleRequest`, including
+ * passing `WIRE_PROFILE` as the explicit `profile` argument so the count turn
+ * is pinned to the same emulated client profile as the main turn, rather than
+ * inheriting whatever the installed package declares as its `DEFAULT_PROFILE`.
  *
  * @param {string | undefined} body
  * @param {Parameters<typeof toClaudeCodeCountTokensInput>[1]} transport
@@ -519,7 +633,10 @@ export async function buildWireCompatibleCountTokensRequest(body, transport) {
   stripStainlessHelperMarkers(parsed?.tools, parsed?.messages);
   let built;
   try {
-    built = await buildClaudeCodeCountTokensRequest(toClaudeCodeCountTokensInput(parsed, transport));
+    // See `buildWireCompatibleRequest`'s equivalent comment: explicit on
+    // purpose, so the count-tokens surface cannot silently move to a different
+    // profile than the main turn on a package bump.
+    built = await buildClaudeCodeCountTokensRequest(toClaudeCodeCountTokensInput(parsed, transport), WIRE_PROFILE);
   } catch (error) {
     throw foldSafeDetailsIntoMessage(error);
   }

package/lib/rolling-summarizer.mjs

@@ -1,3 +1,5 @@
+import { truncateGraphemes } from "./unicode-text.mjs";
+
 /**
  * Deterministic rolling summarizer — Phase B Task B3.
  *
@@ -176,18 +178,31 @@ export function formatTemplate(parsed, maxChars) {
     }
     const longest = current[longestName];
     if (longest.length <= EMPTY_SECTION.length) break;
-    // Chop 10% (at least 8 chars) off the end of the longest section.
+    // Chop 10% (at least 8 chars) off the end of the longest section. Cut on
+    // a grapheme boundary — never split a surrogate pair or combining
+    // sequence — while still guaranteeing progress: the target is always
+    // strictly below `longest.length` here, so truncateGraphemes always
+    // shortens it (it only ever returns the input unchanged when the input
+    // already fits the target).
     const chop = Math.max(8, Math.floor(longest.length * 0.1));
-    current = { ...current, [longestName]: longest.slice(0, Math.max(EMPTY_SECTION.length, longest.length - chop)) };
+    const target = Math.max(EMPTY_SECTION.length, longest.length - chop);
+    current = { ...current, [longestName]: truncateGraphemes(longest, target) };
     out = render(current);
   }
 
-  // Final hard cap: if we somehow still exceed, slice the envelope.  Still
+  // Final hard cap: if we somehow still exceed, cut the envelope on a
+  // grapheme boundary instead of slicing UTF-16 units blindly.  Still
   // deterministic (input-driven only).
   if (out.length > maxChars) {
     const closing = "\n</session-summary>";
-    const head = out.slice(0, Math.max(0, maxChars - closing.length));
-    out = head + closing;
+    if (maxChars <= closing.length) {
+      // The budget doesn't even cover the closing tag by itself. Match the
+      // pre-existing fallback shape — a bare, well-formed closing tag —
+      // rather than emitting an envelope with no closing tag at all.
+      out = closing;
+    } else {
+      out = truncateGraphemes(out, maxChars, { suffix: closing });
+    }
   }
   return out;
 }

package/lib/unicode-text.mjs

@@ -0,0 +1,111 @@
+/**
+ * Grapheme-safe text truncation.
+ *
+ * Every plugin-side text budget that ends up on the wire (system prompt
+ * compaction, rolling-summary sections/envelope, and any future caller) has
+ * historically been enforced with `String.prototype.slice(0, N)`. `slice`
+ * counts UTF-16 code units and has no notion of "user-perceived character":
+ * it can cut a surrogate pair in half (producing a lone surrogate, which
+ * `@tormentalabs/claude-code-wire-compat` rejects with `INVALID_UNICODE`) or
+ * cut a multi-codepoint grapheme cluster in half (producing well-formed
+ * UTF-16 that nonetheless renders as a broken glyph — a dangling combining
+ * mark, half a ZWJ sequence, half a flag, a skin-tone modifier with no base
+ * emoji, and so on).
+ *
+ * `truncateGraphemes` is the single, pure helper that replaces those
+ * `slice(0, N)` call sites. It only ever cuts on a grapheme-cluster boundary
+ * (per `Intl.Segmenter` with `granularity: "grapheme"`) and never emits a
+ * lone surrogate or a split cluster.
+ *
+ * Budget unit: UTF-16 code units — i.e. `String.prototype.length`. This is
+ * the same unit the `slice(0, N)` call sites it replaces already used, so
+ * swapping in this helper with the same `N` preserves the legacy budget
+ * semantics (it does NOT switch callers to a UTF-8 byte budget or a visual
+ * column budget; a caller that needs one of those must convert before and
+ * after calling in).
+ *
+ * @module lib/unicode-text
+ */
+
+/**
+ * Return the longest prefix of `text` that:
+ *   - ends exactly on a grapheme-cluster boundary (never splits a surrogate
+ *     pair and never splits a base character from a combining mark, ZWJ
+ *     sequence, flag, or emoji modifier);
+ *   - together with `options.suffix` appended, has a UTF-16 length
+ *     (`.length`) less than or equal to `maxUnits`.
+ *
+ * Edge-case contract (all explicit; the function never throws):
+ *   - `text === ""` -> `""`.
+ *   - `maxUnits` is `NaN`, or not a number at all -> treated as `0` (the
+ *     most conservative reading: if the budget itself is meaningless,
+ *     nothing is guaranteed to fit).
+ *   - `maxUnits < 0` -> treated as `0`.
+ *   - `maxUnits === Infinity` -> `text` is returned unchanged; there is no
+ *     ceiling to cut against.
+ *   - `text.length <= maxUnits` -> `text` is returned unchanged, WITHOUT the
+ *     suffix appended. Nothing was truncated, so nothing marks that it was —
+ *     this matches the legacy call sites, where the suffix only ever showed
+ *     up when a cut actually happened.
+ *   - The very first grapheme cluster of `text` is already wider than the
+ *     room left for the prefix (`maxUnits - suffix.length`) -> the prefix is
+ *     `""`. The cluster is NEVER split to make it fit; if `options.suffix`
+ *     itself fits within `maxUnits` on its own it is still returned alone,
+ *     otherwise the overall result is `""`.
+ *   - Long combining-mark sequences, ZWJ emoji, flags, and skin-tone
+ *     modifiers are each a single grapheme cluster to `Intl.Segmenter` and
+ *     are therefore included or excluded as one indivisible unit, however
+ *     many UTF-16 units or code points they span.
+ *
+ * Performance: `text` is segmented at most once. If `text.length <=
+ * maxUnits`, segmentation is skipped entirely (fast path) — no reason to pay
+ * for it when no truncation can possibly be needed. When truncation IS
+ * needed, the segments are walked forward exactly once, accumulating length
+ * until the next segment would exceed the budget; this is O(n) in the length
+ * of `text`, never quadratic, and always terminates because the walk is a
+ * single forward pass over a finite iterator.
+ *
+ * @param {string} text
+ * @param {number} maxUnits - budget in UTF-16 code units (`.length`).
+ * @param {{suffix?: string}} [options]
+ * @returns {string}
+ */
+export function truncateGraphemes(text, maxUnits, options) {
+  const suffix = options && typeof options.suffix === "string" ? options.suffix : "";
+  const input = typeof text === "string" ? text : String(text ?? "");
+  if (input.length === 0) return "";
+
+  // Normalize the budget: non-numbers and NaN are the most conservative
+  // reading (0); negative budgets clamp to 0; Infinity is left as-is and
+  // falls through the normal comparisons below (any finite length is <=
+  // Infinity, so it hits the "already fits" fast path further down).
+  let limit = maxUnits;
+  if (typeof limit !== "number" || Number.isNaN(limit)) {
+    limit = 0;
+  } else if (limit < 0) {
+    limit = 0;
+  }
+
+  // Fast path: already within budget. Skip segmenting entirely, and do NOT
+  // append the suffix — nothing was truncated.
+  if (input.length <= limit) return input;
+
+  const budgetForPrefix = limit - suffix.length;
+  if (budgetForPrefix <= 0) {
+    // No room for even one grapheme once the suffix is reserved. Return the
+    // suffix alone if it fits the whole budget by itself; otherwise "".
+    // Either way, no partial cluster is ever produced.
+    return suffix.length <= limit ? suffix : "";
+  }
+
+  const segmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+  let prefix = "";
+  let used = 0;
+  for (const { segment } of segmenter.segment(input)) {
+    const segmentLength = segment.length;
+    if (used + segmentLength > budgetForPrefix) break;
+    prefix += segment;
+    used += segmentLength;
+  }
+  return prefix + suffix;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-anthropic-fix",
-  "version": "2.0.0",
+  "version": "2.1.1",
   "license": "GPL-3.0-or-later",
   "repository": {
     "type": "git",
@@ -32,6 +32,8 @@
     "install:link": "node scripts/install.mjs link",
     "install:copy": "npm run build && node scripts/install.mjs copy",
     "uninstall": "node scripts/install.mjs uninstall",
+    "sync:wire-compat": "node scripts/sync-wire-compat.mjs",
+    "check:wire-compat-drift": "node scripts/check-wire-compat-drift.mjs",
     "prepare": "husky"
   },
   "lint-staged": {
@@ -55,6 +57,6 @@
     "vitest": "^4.0.18"
   },
   "dependencies": {
-    "@tormentalabs/claude-code-wire-compat": "0.5.0"
+    "@tormentalabs/claude-code-wire-compat": "latest"
   }
 }