opencode-anthropic-fix 0.1.18 → 0.1.20

package/index.mjs

@@ -19,6 +19,8 @@ import {
   parseShouldRetryHeader,
   TRANSIENT_RETRY_THRESHOLD_MS,
 } from "./lib/backoff.mjs";
+import { callHaiku } from "./lib/haiku-call.mjs";
+import { summarize as rollingSummarize } from "./lib/rolling-summarizer.mjs";
 
 // ---------------------------------------------------------------------------
 // Account management CLI prompts
@@ -110,6 +112,58 @@ async function promptManageAccounts(accountManager) {
   }
 }
 
+/**
+ * Pure driver for experimental.session.summarize. Extracted from the handler
+ * closure so it can be unit-tested without bootstrapping the full plugin.
+ * All external dependencies are injected.
+ *
+ * @param {object} deps
+ * @param {object|null} deps.config - Plugin config; handler no-ops if config.token_economy_strategies.haiku_rolling_summary is not true.
+ * @param {() => Promise<string>} deps.getAccessToken - Resolves to a Bearer OAuth token (or throws).
+ * @param {typeof globalThis.fetch} deps.fetchFn - HTTP transport.
+ * @param {typeof callHaiku} deps.callHaikuFn - Haiku API caller.
+ * @param {typeof rollingSummarize} deps.rollingSummarizeFn - Deterministic summarizer.
+ * @param {{warn: (msg: string) => void}} [deps.logger] - For fall-through warnings.
+ * @param {{sessionID: string, messages: unknown[], model: unknown}} input
+ * @param {{summary?: string, modelID?: string, providerID?: string, tokens?: {input: number, output: number}, cost?: number}} output
+ */
+async function runHaikuSessionSummarize(
+  { config, getAccessToken, fetchFn, callHaikuFn, rollingSummarizeFn, logger },
+  input,
+  output,
+) {
+  if (!config?.token_economy_strategies?.haiku_rolling_summary) return;
+
+  try {
+    let capturedTokens = { input: 0, output: 0 };
+    let capturedCost = 0;
+    const haikuCall = async (request) => {
+      const r = await callHaikuFn({
+        prompt: request.prompt,
+        fetch: fetchFn,
+        getAccessToken,
+      });
+      capturedTokens = r.tokens;
+      capturedCost = r.cost;
+      return r.text;
+    };
+
+    const summaryText = await rollingSummarizeFn(input.messages, { haikuCall });
+    if (typeof summaryText !== "string" || summaryText.length === 0) return;
+
+    output.summary = summaryText;
+    output.modelID = "claude-haiku-4-5-20251001";
+    output.providerID = "anthropic";
+    output.tokens = capturedTokens;
+    output.cost = capturedCost;
+  } catch (err) {
+    if (logger && typeof logger.warn === "function") {
+      const msg = err && typeof err === "object" && "message" in err ? err.message : String(err);
+      logger.warn(`[opencode-anthropic-fix] haiku rolling summary failed; falling back to default compaction: ${msg}`);
+    }
+  }
+}
+
 export async function AnthropicAuthPlugin({ client, project, directory, worktree, serverUrl, $ }) {
   const config = loadConfig();
   _pluginConfig = config; // expose to module-level functions (cache stats, response headers)
@@ -2913,8 +2967,12 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
                   _adaptiveOverride,
                   _tokenEconomy,
                 );
-                // v2.1.107: cch attestation via xxHash64(body, seed) & 0xFFFFF
-                const finalBody = await computeAndReplaceCCH(body);
+                // cch stays as the static "00000" placeholder — cc-107 and cc-108
+                // JS bundles both emit `cch=00000;` unconditionally in the billing
+                // header. The Bun-binary Attestation.zig xxHash64 mechanism lives in
+                // a SEPARATE header path, not in this body field. Re-hashing here
+                // mutates system[0] each turn, invalidating the prompt cache.
+                const finalBody = body;
 
                 // Opt-in: dump the OUTGOING body (post-cch) so diagnostics reflect
                 // exactly what went on the wire. Previously dumped `body` which
@@ -4041,6 +4099,41 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
       // lib/rolling-summarizer.mjs — call summarize(messages, {haikuCall}) here
       // behind config.token_economy.rolling_summarizer when messages are available.
     },
+    /**
+     * B3 L2 Option C: Plugin-generated compaction summary via Haiku.
+     * Gated on token_economy_strategies.haiku_rolling_summary. See
+     * runHaikuSessionSummarize at the top of this file for the full driver
+     * — the closure here only binds account/token/config state.
+     */
+    "experimental.session.summarize": async (input, output) => {
+      if (!config?.token_economy_strategies?.haiku_rolling_summary) return;
+      if (!accountManager) return;
+
+      const account = accountManager.getCurrentAccount();
+      if (!account) return;
+
+      const getAccessToken = async () => {
+        let tok = account.access;
+        if (!tok || !account.expires || account.expires < Date.now()) {
+          tok = await refreshAccountTokenSingleFlight(account);
+        }
+        if (!tok) throw new Error("no access token available for Haiku call");
+        return tok;
+      };
+
+      await runHaikuSessionSummarize(
+        {
+          config,
+          getAccessToken,
+          fetchFn: globalThis.fetch,
+          callHaikuFn: callHaiku,
+          rollingSummarizeFn: rollingSummarize,
+          logger: typeof console !== "undefined" ? console : undefined,
+        },
+        input,
+        output,
+      );
+    },
   };
 }
 
@@ -8839,6 +8932,8 @@ AnthropicAuthPlugin.__testing__ = {
   // exposed for session-dedupe regression tests (phase C3)
   applySessionToolResultDedupe,
   maybeApplySessionToolResultDedupe,
+  // exposed for experimental.session.summarize integration tests
+  runHaikuSessionSummarize,
   get cachedCCPrompt() {
     return cachedCCPrompt;
   },

package/lib/config.mjs

@@ -305,6 +305,12 @@ export const DEFAULT_CONFIG = {
      *  10-20% on long sessions. Pure over message history → cache-stable.
      *  Off by default (conservative mode territory). */
     tool_result_dedupe_session_wide: false,
+    /** Haiku rolling-summary compaction: when a matching opencode fork
+     *  exposes the `experimental.session.summarize` hook, the plugin calls
+     *  claude-haiku-4-5-20251001 at temperature 0 to produce the compaction
+     *  summary, bypassing the main model. Requires opencode fork support
+     *  — no-op without it. Off by default. */
+    haiku_rolling_summary: false,
   },
   /** Output cap: default max_tokens to save context window. */
   output_cap: {
@@ -781,6 +787,10 @@ function validateConfig(raw) {
         typeof tes.tool_result_dedupe_session_wide === "boolean"
           ? tes.tool_result_dedupe_session_wide
           : DEFAULT_CONFIG.token_economy_strategies.tool_result_dedupe_session_wide,
+      haiku_rolling_summary:
+        typeof tes.haiku_rolling_summary === "boolean"
+          ? tes.haiku_rolling_summary
+          : DEFAULT_CONFIG.token_economy_strategies.haiku_rolling_summary,
     };
   }
 

package/lib/config.test.mjs

@@ -379,3 +379,34 @@ describe("loadConfig", () => {
     expect(config.adaptive_context.enabled).toBe(false);
   });
 });
+
+describe("token_economy_strategies.haiku_rolling_summary", () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  it("defaults to false in DEFAULT_CONFIG", () => {
+    expect(DEFAULT_CONFIG.token_economy_strategies.haiku_rolling_summary).toBe(false);
+  });
+
+  it("defaults to false when config file omits the flag", () => {
+    existsSync.mockReturnValue(true);
+    readFileSync.mockReturnValue(JSON.stringify({}));
+    const cfg = loadConfig();
+    expect(cfg.token_economy_strategies.haiku_rolling_summary).toBe(false);
+  });
+
+  it("accepts true when explicitly set in config file", () => {
+    existsSync.mockReturnValue(true);
+    readFileSync.mockReturnValue(JSON.stringify({ token_economy_strategies: { haiku_rolling_summary: true } }));
+    const cfg = loadConfig();
+    expect(cfg.token_economy_strategies.haiku_rolling_summary).toBe(true);
+  });
+
+  it("falls back to default on non-boolean value (graceful, does not throw)", () => {
+    existsSync.mockReturnValue(true);
+    readFileSync.mockReturnValue(JSON.stringify({ token_economy_strategies: { haiku_rolling_summary: "yes" } }));
+    const cfg = loadConfig();
+    expect(cfg.token_economy_strategies.haiku_rolling_summary).toBe(false);
+  });
+});

package/lib/haiku-call.mjs

@@ -0,0 +1,44 @@
+export const MODEL = "claude-haiku-4-5-20251001";
+export const TEMPERATURE = 0;
+export const MAX_TOKENS = 2048;
+export const ANTHROPIC_VERSION = "2023-06-01";
+export const API_URL = "https://api.anthropic.com/v1/messages";
+
+// Haiku 4.5 pricing as of 2026-04-18 (USD per million tokens).
+const PRICE_INPUT_PER_MTOK = 1.0;
+const PRICE_OUTPUT_PER_MTOK = 5.0;
+
+export async function callHaiku({ prompt, fetch, getAccessToken }) {
+  const token = await getAccessToken();
+
+  const res = await fetch(API_URL, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${token}`,
+      "anthropic-version": ANTHROPIC_VERSION,
+    },
+    body: JSON.stringify({
+      model: MODEL,
+      temperature: TEMPERATURE,
+      max_tokens: MAX_TOKENS,
+      messages: [{ role: "user", content: [{ type: "text", text: prompt }] }],
+    }),
+  });
+
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(`Haiku call failed: HTTP ${res.status} ${body}`);
+  }
+
+  const json = await res.json();
+  const textBlock = (json.content ?? []).find((b) => b.type === "text");
+  if (!textBlock || typeof textBlock.text !== "string" || textBlock.text.length === 0) {
+    throw new Error("Haiku response has no text content");
+  }
+  const input = json.usage?.input_tokens ?? 0;
+  const output = json.usage?.output_tokens ?? 0;
+  const cost = (input / 1e6) * PRICE_INPUT_PER_MTOK + (output / 1e6) * PRICE_OUTPUT_PER_MTOK;
+
+  return { text: textBlock.text, tokens: { input, output }, cost };
+}

package/lib/haiku-call.test.mjs

@@ -0,0 +1,72 @@
+import { describe, expect, it, vi } from "vitest";
+import { callHaiku } from "./haiku-call.mjs";
+
+describe("callHaiku", () => {
+  it("returns text + tokens + cost on 200 response", async () => {
+    const fetchMock = vi.fn(async () => ({
+      ok: true,
+      status: 200,
+      json: async () => ({
+        content: [{ type: "text", text: "summary body here" }],
+        usage: { input_tokens: 100, output_tokens: 30 },
+      }),
+    }));
+    const getAccessToken = vi.fn(async () => "oauth-token-abc");
+
+    const result = await callHaiku({
+      prompt: "summarize this",
+      fetch: fetchMock,
+      getAccessToken,
+    });
+
+    expect(result.text).toBe("summary body here");
+    expect(result.tokens).toEqual({ input: 100, output: 30 });
+    // Haiku 4.5 pricing: $1/MTok input, $5/MTok output (2026-04-18)
+    // cost = 100/1e6 * 1 + 30/1e6 * 5 = 0.0001 + 0.00015 = 0.00025
+    expect(result.cost).toBeCloseTo(0.00025, 8);
+
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    const [url, opts] = fetchMock.mock.calls[0];
+    expect(url).toBe("https://api.anthropic.com/v1/messages");
+    expect(opts.method).toBe("POST");
+    expect(opts.headers.authorization).toBe("Bearer oauth-token-abc");
+    expect(opts.headers["anthropic-version"]).toBe("2023-06-01");
+    const body = JSON.parse(opts.body);
+    expect(body.model).toBe("claude-haiku-4-5-20251001");
+    expect(body.temperature).toBe(0);
+    expect(body.max_tokens).toBe(2048);
+    expect(body.messages).toEqual([{ role: "user", content: [{ type: "text", text: "summarize this" }] }]);
+  });
+
+  it("throws on non-2xx HTTP response", async () => {
+    const fetchMock = vi.fn(async () => ({
+      ok: false,
+      status: 429,
+      text: async () => "rate limited",
+    }));
+    const getAccessToken = vi.fn(async () => "oauth-token-abc");
+
+    await expect(callHaiku({ prompt: "x", fetch: fetchMock, getAccessToken })).rejects.toThrow(/HTTP 429/);
+  });
+
+  it("throws when response content is missing or not text", async () => {
+    const fetchMock = vi.fn(async () => ({
+      ok: true,
+      status: 200,
+      json: async () => ({ content: [], usage: { input_tokens: 0, output_tokens: 0 } }),
+    }));
+    const getAccessToken = vi.fn(async () => "oauth-token-abc");
+
+    await expect(callHaiku({ prompt: "x", fetch: fetchMock, getAccessToken })).rejects.toThrow(/no text content/i);
+  });
+
+  it("throws when getAccessToken rejects", async () => {
+    const fetchMock = vi.fn();
+    const getAccessToken = vi.fn(async () => {
+      throw new Error("oauth expired");
+    });
+
+    await expect(callHaiku({ prompt: "x", fetch: fetchMock, getAccessToken })).rejects.toThrow(/oauth expired/);
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-anthropic-fix",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "license": "GPL-3.0-or-later",
   "main": "./index.mjs",
   "files": [