opencode-anthropic-fix 0.1.32 → 0.2.0

package/lib/token-economy/transforms.test.mjs

@@ -0,0 +1,192 @@
+import { describe, expect, it } from "vitest";
+import {
+  applyAdaptiveThinkingZero,
+  applyContextHintCompaction,
+  applySessionToolResultDedupe,
+  applyStableToolOrdering,
+  applyToolResultDedupe,
+  applyToolSchemaDeferral,
+  applyTrailingSummaryTrim,
+  estimatePromptTokensFromParsed,
+  injectTokenBudgetBlock,
+  parseNaturalLanguageBudget,
+} from "./transforms.mjs";
+
+describe("token-economy transforms", () => {
+  it.each([
+    ["Use 1 million tokens", 1_000_000],
+    ["budget: 500k", 500_000],
+    ["spend 1200", 1_200],
+  ])("parses natural-language budget %s", (content, expected) => {
+    expect(parseNaturalLanguageBudget([{ role: "user", content }])).toBe(expected);
+  });
+
+  it("injects a token budget system block", () => {
+    const existing = { type: "text", text: "Existing prompt" };
+    const result = injectTokenBudgetBlock([existing], { limit: 10_000, used: 2_500, continuations: 1 }, 0.9);
+
+    expect(result).toHaveLength(2);
+    expect(result[0]).toEqual({
+      type: "text",
+      text: `Token budget: ${(2_500).toLocaleString()}/${(10_000).toLocaleString()} tokens used (25%). Stop generating at ${(9_000).toLocaleString()} tokens. Remaining: ${(7_500).toLocaleString()} tokens.`,
+    });
+    expect(result[1]).toBe(existing);
+  });
+
+  it("estimates a plausible prompt token count from a parsed body", () => {
+    const result = estimatePromptTokensFromParsed({
+      system: [{ type: "text", text: "12345678" }],
+      messages: [{ role: "user", content: "12345678" }],
+    });
+
+    expect(result).toBe(4);
+  });
+
+  it("dedupes repeated reproducible results while preserving stateful results", () => {
+    const messages = [
+      {
+        role: "assistant",
+        content: [
+          { type: "tool_use", id: "read-1", name: "read", input: { path: "a.mjs" } },
+          { type: "tool_use", id: "bash-1", name: "bash", input: { command: "date" } },
+        ],
+      },
+      {
+        role: "user",
+        content: [
+          { type: "tool_result", tool_use_id: "read-1", content: "old read" },
+          { type: "tool_result", tool_use_id: "bash-1", content: "old bash" },
+        ],
+      },
+      {
+        role: "assistant",
+        content: [
+          { type: "tool_use", id: "read-2", name: "read", input: { path: "a.mjs" } },
+          { type: "tool_use", id: "bash-2", name: "bash", input: { command: "date" } },
+        ],
+      },
+      {
+        role: "user",
+        content: [
+          { type: "tool_result", tool_use_id: "read-2", content: "latest read" },
+          { type: "tool_result", tool_use_id: "bash-2", content: "latest bash" },
+        ],
+      },
+    ];
+
+    const result = applySessionToolResultDedupe(messages);
+
+    expect(result.changed).toBe(true);
+    expect(result.stats.deduped).toBe(1);
+    expect(result.messages[1].content[0].content).toBe('[Read of {"path":"a.mjs"} superseded by later read at msg #3]');
+    expect(result.messages[3].content[0].content).toBe("latest read");
+    expect(result.messages[1].content[1].content).toBe("old bash");
+    expect(result.messages[3].content[1].content).toBe("latest bash");
+  });
+
+  it("clears thinking and old tool results while keeping the latest eight", () => {
+    const messages = [
+      {
+        role: "assistant",
+        content: [
+          { type: "thinking", thinking: "secret" },
+          { type: "text", text: "answer" },
+        ],
+      },
+      ...Array.from({ length: 10 }, (_, i) => ({
+        role: "user",
+        content: [{ type: "tool_result", tool_use_id: `tool-${i}`, content: `result-${i}` }],
+      })),
+    ];
+
+    const result = applyContextHintCompaction(messages);
+
+    expect(result.stats).toEqual({ thinkingCleared: 1, toolResultsCleared: 2 });
+    expect(result.messages[0].content).toEqual([{ type: "text", text: "answer" }]);
+    expect(result.messages[1].content[0].content).toBe("[Old tool result content cleared]");
+    expect(result.messages[2].content[0].content).toBe("[Old tool result content cleared]");
+    expect(result.messages[3].content[0].content).toBe("result-2");
+    expect(result.messages[10].content[0].content).toBe("result-9");
+  });
+
+  it("trims a trailing summary block from a past assistant message", () => {
+    const summary = `Summary: ${"completed the requested implementation. ".repeat(3)}`;
+    const messages = [
+      {
+        role: "assistant",
+        content: [
+          { type: "text", text: "Useful detail" },
+          { type: "text", text: summary },
+        ],
+      },
+      { role: "user", content: "Continue" },
+      { role: "assistant", content: [{ type: "text", text: "Current response" }] },
+    ];
+
+    const result = applyTrailingSummaryTrim(messages);
+
+    expect(result).toMatchObject({ changed: true, trimmed: 1 });
+    expect(result.messages[0].content).toEqual([{ type: "text", text: "Useful detail" }]);
+  });
+
+  it("dedupes a repeated safe tool result", () => {
+    const messages = [
+      {
+        role: "assistant",
+        content: [
+          { type: "tool_use", id: "first", name: "Read", input: { file: "a" } },
+          { type: "tool_use", id: "second", name: "Read", input: { file: "a" } },
+        ],
+      },
+      {
+        role: "user",
+        content: [
+          { type: "tool_result", tool_use_id: "first", content: "one" },
+          { type: "tool_result", tool_use_id: "second", content: "two" },
+        ],
+      },
+    ];
+
+    const result = applyToolResultDedupe(messages, { seen: new Map(), safeTools: new Set(["Read"]) });
+
+    expect(result).toMatchObject({ changed: true, deduped: 1 });
+    expect(result.messages[1].content[1].content).toBe("[Identical to tool_use_id=first]");
+  });
+
+  it("orders tools stably by name", () => {
+    const tools = [{ name: "write" }, { name: "grep" }, { name: "read" }];
+    expect(applyStableToolOrdering(tools).map((tool) => tool.name)).toEqual(["grep", "read", "write"]);
+    expect(tools.map((tool) => tool.name)).toEqual(["write", "grep", "read"]);
+  });
+
+  it("defers schemas only for uninvoked configured tools", () => {
+    const tools = [
+      { name: "read", input_schema: { type: "object", required: ["path"] } },
+      { name: "grep", input_schema: { type: "object", required: ["pattern"] } },
+    ];
+
+    const result = applyToolSchemaDeferral(tools, {
+      deferred: new Set(["read", "grep"]),
+      invoked: new Set(["grep"]),
+    });
+
+    expect(result.deferredCount).toBe(1);
+    expect(result.tools[0].input_schema).toEqual({ type: "object", properties: {}, additionalProperties: true });
+    expect(result.tools[1]).toBe(tools[1]);
+  });
+
+  it("disables thinking for a simple follow-up", () => {
+    const parsed = {
+      thinking: { type: "enabled", budget_tokens: 4_096 },
+      messages: [
+        { role: "user", content: "Initial request" },
+        { role: "assistant", content: "Done" },
+        { role: "user", content: "Thanks" },
+      ],
+    };
+
+    expect(applyAdaptiveThinkingZero(parsed)).toEqual({ applied: true, previousBudget: 4_096 });
+    expect(parsed).not.toHaveProperty("thinking");
+    expect(parsed.temperature).toBe(1);
+  });
+});

package/lib/tuning.mjs

@@ -0,0 +1,70 @@
+/**
+ * Centralized tuning values for retry / overload-recovery behavior, wired into
+ * runtime code as of Wave 3. The service-wide retry budget and the 529 fallback
+ * threshold are consumed directly in index.mjs; the base-delay, backoff, max-delay
+ * and jitter constants are consumed by the pure decision helpers in
+ * lib/retry/overload-loop.mjs. The OAuth token-refresh timeout and the
+ * foreground-refresh expiry buffer remain inline in index.mjs (documented below).
+ *
+ * Constants that are already centralized remain in their existing homes:
+ * retry cooldown constants live in lib/backoff.mjs, while account-selection
+ * stickiness and switch thresholds live in lib/rotation.mjs.
+ *
+ * @module tuning
+ */
+
+/**
+ * Bounds foreground service-wide retries so overload recovery cannot loop indefinitely.
+ * Consumed at the index.mjs maxServiceRetries budget (foreground branch).
+ * @see lib/retry/overload-loop.mjs
+ */
+export const SERVICE_WIDE_MAX_RETRIES = 2;
+
+/**
+ * Delays model fallback until repeated overloads show that retrying the current model is ineffective.
+ * Consumed at the index.mjs consecutive-529 model-fallback gate.
+ * @see lib/retry/overload-loop.mjs
+ */
+export const CONSECUTIVE_529_FALLBACK_THRESHOLD = 3;
+
+/**
+ * Starts service retries with a short delay to recover quickly from transient overloads.
+ * Consumed by computeServiceRetrySleepMs in lib/retry/overload-loop.mjs.
+ * @see lib/retry/overload-loop.mjs
+ */
+export const SERVICE_RETRY_BASE_DELAY_SEC = 0.5;
+
+/**
+ * Doubles each service-retry delay to reduce pressure during a sustained outage.
+ * Consumed by computeServiceRetrySleepMs in lib/retry/overload-loop.mjs.
+ * @see lib/retry/overload-loop.mjs
+ */
+export const SERVICE_RETRY_BACKOFF_MULTIPLIER = 2;
+
+/**
+ * Caps service-retry latency so overload handling remains responsive.
+ * Consumed by computeServiceRetrySleepMs in lib/retry/overload-loop.mjs.
+ * @see lib/retry/overload-loop.mjs
+ */
+export const SERVICE_RETRY_MAX_DELAY_SEC = 3;
+
+/**
+ * Spreads service retries across clients while retaining most of the calculated delay.
+ * Consumed by computeServiceRetrySleepMs in lib/retry/overload-loop.mjs.
+ * @see lib/retry/overload-loop.mjs
+ */
+export const SERVICE_RETRY_JITTER_FRACTION = 0.25;
+
+/**
+ * Prevents an unresponsive OAuth refresh request from blocking account recovery indefinitely.
+ * Current call-site: index.mjs (inline OAuth refresh AbortSignal.timeout).
+ * @see test/conformance/regression.test.mjs Fix #12
+ */
+export const TOKEN_REFRESH_TIMEOUT_MS = 15000;
+
+/**
+ * Refreshes foreground credentials early enough to avoid token expiry during an active request.
+ * Current call-site: index.mjs (inline foreground refresh expiry check).
+ * @see test/conformance/regression.test.mjs Fix #13
+ */
+export const FOREGROUND_REFRESH_EXPIRY_BUFFER_MS = 300000;

package/lib/tuning.test.mjs

@@ -0,0 +1,89 @@
+import { readFileSync } from "node:fs";
+import { describe, it, expect } from "vitest";
+
+import * as tuning from "./tuning.mjs";
+
+const indexSource = readFileSync(new URL("../index.mjs", import.meta.url), "utf8");
+
+const expectedValues = {
+  SERVICE_WIDE_MAX_RETRIES: 2,
+  CONSECUTIVE_529_FALLBACK_THRESHOLD: 3,
+  SERVICE_RETRY_BASE_DELAY_SEC: 0.5,
+  SERVICE_RETRY_BACKOFF_MULTIPLIER: 2,
+  SERVICE_RETRY_MAX_DELAY_SEC: 3,
+  SERVICE_RETRY_JITTER_FRACTION: 0.25,
+  TOKEN_REFRESH_TIMEOUT_MS: 15000,
+  FOREGROUND_REFRESH_EXPIRY_BUFFER_MS: 300000,
+};
+
+/**
+ * @param {RegExp} pattern
+ * @param {number} [group]
+ * @returns {number}
+ */
+function extractNumber(pattern, group = 1) {
+  const match = indexSource.match(pattern);
+  expect(match, `Expected index.mjs to match ${pattern}`).not.toBeNull();
+  return Number(match[group].replaceAll("_", ""));
+}
+
+describe("tuning constants", () => {
+  it("exports every documented numeric value", () => {
+    for (const [name, expected] of Object.entries(expectedValues)) {
+      expect(tuning).toHaveProperty(name);
+      expect(typeof tuning[name]).toBe("number");
+      expect(tuning[name]).toBe(expected);
+    }
+  });
+
+  it("wires the service retry budget and fallback threshold to tuning constants", () => {
+    // Wave 3 P3.2 replaced the inline literals with imported constant references.
+    expect(indexSource).toMatch(
+      /const\s+maxServiceRetries\s*=\s*requestClass\s*===\s*"background"[\s\S]*?:\s*SERVICE_WIDE_MAX_RETRIES\s*;/,
+    );
+    expect(indexSource).toMatch(/consecutive529Count\s*>=\s*CONSECUTIVE_529_FALLBACK_THRESHOLD/);
+    expect(indexSource).toMatch(
+      /import\s*\{[^}]*\bSERVICE_WIDE_MAX_RETRIES\b[^}]*\bCONSECUTIVE_529_FALLBACK_THRESHOLD\b[^}]*\}\s*from\s*"\.\/lib\/tuning\.mjs"/,
+    );
+  });
+
+  it("consumes the service retry delay constants in the overload-loop helper", () => {
+    // The Math.min/jitter delay formula moved out of index.mjs into this helper (P3.2).
+    const overloadSource = readFileSync(new URL("./retry/overload-loop.mjs", import.meta.url), "utf8");
+    for (const name of [
+      "SERVICE_RETRY_BASE_DELAY_SEC",
+      "SERVICE_RETRY_BACKOFF_MULTIPLIER",
+      "SERVICE_RETRY_MAX_DELAY_SEC",
+      "SERVICE_RETRY_JITTER_FRACTION",
+    ]) {
+      expect(overloadSource, `overload-loop.mjs must consume ${name}`).toContain(name);
+    }
+    expect(overloadSource).toMatch(/from\s*"\.\.\/tuning\.mjs"/);
+    // The inline delay formula must no longer live in index.mjs.
+    expect(indexSource).not.toMatch(/1\s*-\s*Math\.random\(\)\s*\*\s*0\.25/);
+  });
+
+  it("matches the inline token refresh timeout and foreground expiry buffer", () => {
+    const tokenRefreshTimeout = extractNumber(
+      /refreshToken\(\s*account\.refreshToken\s*,\s*\{\s*signal:\s*AbortSignal\.timeout\(\s*(\d[\d_]*)\s*\)\s*\}\s*\)/,
+    );
+    const foregroundExpiryBuffer = extractNumber(/account\.expires\s*<\s*Date\.now\(\)\s*\+\s*(\d[\d_]*)/);
+
+    expect(tokenRefreshTimeout).toBe(tuning.TOKEN_REFRESH_TIMEOUT_MS);
+    expect(foregroundExpiryBuffer).toBe(tuning.FOREGROUND_REFRESH_EXPIRY_BUFFER_MS);
+  });
+
+  it("gives every exported constant an adjacent JSDoc @see tag", () => {
+    const tuningSource = readFileSync(new URL("./tuning.mjs", import.meta.url), "utf8");
+    const exports = [...tuningSource.matchAll(/export const\s+([A-Z0-9_]+)\s*=/g)];
+
+    expect(exports.map((match) => match[1])).toEqual(Object.keys(expectedValues));
+    for (const exported of exports) {
+      const prefix = tuningSource.slice(0, exported.index);
+      const adjacentJSDoc = prefix.slice(prefix.lastIndexOf("/**"));
+      expect(adjacentJSDoc, `${exported[1]} must have an adjacent JSDoc @see tag`).toMatch(
+        /^\/\*\*[\s\S]*?@see\s+\S[^\n]*[\s\S]*?\*\/\s*$/,
+      );
+    }
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-anthropic-fix",
-  "version": "0.1.32",
+  "version": "0.2.0",
   "license": "GPL-3.0-or-later",
   "repository": {
     "type": "git",
@@ -20,8 +20,10 @@
   ],
   "scripts": {
     "build": "node scripts/build.mjs",
+    "check:invariants": "node scripts/check-invariants.mjs",
     "test": "vitest run",
     "test:watch": "vitest",
+    "coverage": "vitest run --coverage",
     "lint": "eslint .",
     "lint:fix": "eslint --fix .",
     "format": "prettier --write .",
@@ -43,6 +45,7 @@
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "@opencode-ai/plugin": "^1.2.27",
+    "@vitest/coverage-v8": "^4.0.18",
     "esbuild": "^0.27.3",
     "eslint": "^10.0.0",
     "husky": "^9.1.7",