opencode-anthropic-fix 0.1.32 → 0.2.0

package/lib/session-metrics.mjs

@@ -0,0 +1,75 @@
+// ---------------------------------------------------------------------------
+// Session-level cache & cost tracking (Phase 4)
+// ---------------------------------------------------------------------------
+//
+// Extracted from index.mjs (W3·P3.3). `sessionMetrics` is a process-lifetime
+// singleton shared BY REFERENCE across the plugin and the extracted lib
+// modules: importers mutate `sessionMetrics.<field>` in place and it is never
+// reassigned, so a plain `import { sessionMetrics }` observes the same live
+// object everywhere. The test reset helper mutates in place (delete keys +
+// Object.assign) precisely to preserve this shared identity.
+
+/**
+ * Factory for the initial sessionMetrics shape. Returns a fresh object each
+ * call so the reset helper (and any future test hook) doesn't alias nested
+ * state (lastQuota, perModel, costBreakdown, tokenBudget, usedTools Set).
+ * Keep this in sync with the type annotation below.
+ */
+export function createInitialSessionMetrics() {
+  return {
+    turns: 0,
+    totalInput: 0,
+    totalOutput: 0,
+    totalCacheRead: 0,
+    totalCacheWrite: 0,
+    totalWebSearchRequests: 0,
+    recentCacheRates: [], // rolling window of last 5 turns
+    sessionCostUsd: 0,
+    costBreakdown: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    sessionStartTime: Date.now(),
+    lastQuota: {
+      tokens: 0,
+      requests: 0,
+      inputTokens: 0,
+      updatedAt: 0,
+      // Window-based unified headers from response
+      fiveHour: { utilization: 0, resets_at: null, status: null, surpassedThreshold: null },
+      sevenDay: { utilization: 0, resets_at: null, status: null, surpassedThreshold: null },
+      // Overall/fallback/overage from response headers
+      overallStatus: null,
+      representativeClaim: null,
+      fallback: null,
+      fallbackPercentage: null,
+      overageStatus: null,
+      overageReason: null,
+      // Usage endpoint polling (A6)
+      lastPollAt: 0,
+    },
+    lastStopReason: null, // tracks most recent stop_reason for output cap escalation
+    perModel: {}, // Map<modelId, { input, output, cacheRead, cacheWrite, costUsd, turns }>
+    lastModelId: null,
+    lastRequestBody: null, // Last intercepted request body (JSON string, capped 2MB) for /anthropic context
+    /** Token budget tracking (A9) */
+    tokenBudget: {
+      limit: 0, // 0 = unset
+      used: 0, // accumulated output tokens
+      continuations: 0,
+      outputHistory: [], // last 5 output token deltas
+    },
+    /** Tools used in this session (populated from assistant tool_use blocks in messages) */
+    usedTools: new Set(),
+  };
+}
+
+/** @type {{turns: number, totalInput: number, totalOutput: number, totalCacheRead: number, totalCacheWrite: number, totalWebSearchRequests: number, recentCacheRates: number[], sessionCostUsd: number, costBreakdown: {input: number, output: number, cacheRead: number, cacheWrite: number}, sessionStartTime: number, lastQuota: {tokens: number, requests: number, inputTokens: number, updatedAt: number, fiveHour: {utilization: number, resets_at: string|null, status: string|null, surpassedThreshold: number|null}, sevenDay: {utilization: number, resets_at: string|null, status: string|null, surpassedThreshold: number|null}, overallStatus: string|null, representativeClaim: string|null, fallback: string|null, fallbackPercentage: number|null, overageStatus: string|null, overageReason: string|null, lastPollAt: number}, lastStopReason: string | null, perModel: Record<string, {input: number, output: number, cacheRead: number, cacheWrite: number, costUsd: number, turns: number}>, lastModelId: string | null, lastRequestBody: string | null, tokenBudget: {limit: number, used: number, continuations: number, outputHistory: number[]}, usedTools: Set<string>}} */
+export const sessionMetrics = createInitialSessionMetrics();
+
+/**
+ * Get rolling average cache hit rate over last 5 turns.
+ * @returns {number} 0-1
+ */
+export function getAverageCacheHitRate() {
+  const rates = sessionMetrics.recentCacheRates;
+  if (rates.length === 0) return 0;
+  return rates.reduce((a, b) => a + b, 0) / rates.length;
+}

package/lib/session-metrics.test.mjs

@@ -0,0 +1,67 @@
+import { describe, it, expect } from "vitest";
+import { createInitialSessionMetrics, sessionMetrics, getAverageCacheHitRate } from "./session-metrics.mjs";
+
+describe("session-metrics", () => {
+  describe("createInitialSessionMetrics", () => {
+    it("returns a fresh object with the documented zeroed shape", () => {
+      const m = createInitialSessionMetrics();
+      expect(m.turns).toBe(0);
+      expect(m.totalInput).toBe(0);
+      expect(m.totalOutput).toBe(0);
+      expect(m.totalCacheRead).toBe(0);
+      expect(m.totalCacheWrite).toBe(0);
+      expect(m.recentCacheRates).toEqual([]);
+      expect(m.sessionCostUsd).toBe(0);
+      expect(m.costBreakdown).toEqual({ input: 0, output: 0, cacheRead: 0, cacheWrite: 0 });
+      expect(m.lastStopReason).toBeNull();
+      expect(m.perModel).toEqual({});
+      expect(m.lastModelId).toBeNull();
+      expect(m.lastRequestBody).toBeNull();
+      expect(m.tokenBudget).toEqual({ limit: 0, used: 0, continuations: 0, outputHistory: [] });
+      expect(m.usedTools).toBeInstanceOf(Set);
+      expect(m.usedTools.size).toBe(0);
+      expect(m.lastQuota.fiveHour).toEqual({
+        utilization: 0,
+        resets_at: null,
+        status: null,
+        surpassedThreshold: null,
+      });
+    });
+
+    it("does not alias nested state between calls (fresh Set/objects/arrays)", () => {
+      const a = createInitialSessionMetrics();
+      const b = createInitialSessionMetrics();
+      expect(a.usedTools).not.toBe(b.usedTools);
+      expect(a.lastQuota).not.toBe(b.lastQuota);
+      expect(a.tokenBudget).not.toBe(b.tokenBudget);
+      expect(a.recentCacheRates).not.toBe(b.recentCacheRates);
+      a.usedTools.add("Bash");
+      expect(b.usedTools.size).toBe(0);
+    });
+  });
+
+  describe("sessionMetrics singleton", () => {
+    it("is a shared object reference whose mutations persist", () => {
+      const before = sessionMetrics.turns;
+      sessionMetrics.turns = before + 1;
+      expect(sessionMetrics.turns).toBe(before + 1);
+      sessionMetrics.turns = before; // restore
+    });
+  });
+
+  describe("getAverageCacheHitRate", () => {
+    it("returns 0 when there are no recent rates", () => {
+      const saved = sessionMetrics.recentCacheRates;
+      sessionMetrics.recentCacheRates = [];
+      expect(getAverageCacheHitRate()).toBe(0);
+      sessionMetrics.recentCacheRates = saved;
+    });
+
+    it("returns the arithmetic mean of the rolling window", () => {
+      const saved = sessionMetrics.recentCacheRates;
+      sessionMetrics.recentCacheRates = [0.2, 0.4, 0.6];
+      expect(getAverageCacheHitRate()).toBeCloseTo(0.4, 10);
+      sessionMetrics.recentCacheRates = saved;
+    });
+  });
+});

package/lib/storage.test.mjs

@@ -10,6 +10,9 @@ import {
 } from "./storage.mjs";
 import { promises as fs } from "node:fs";
 import { existsSync, readFileSync, appendFileSync, writeFileSync } from "node:fs";
+import { randomBytes } from "node:crypto";
+
+const itWindows = process.platform === "win32" ? it : it.skip;
 
 // Mock fs modules
 vi.mock("node:fs", () => ({
@@ -364,6 +367,85 @@ describe("saveAccounts", () => {
     expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining(".tmp"));
   });
 
+  it("keeps persisted JSON consistent when concurrent saves commit out of order", async () => {
+    randomBytes
+      .mockReturnValueOnce({ toString: () => "writer-one" })
+      .mockReturnValueOnce({ toString: () => "writer-two" });
+
+    const files = new Map();
+    let markFirstWriteStarted;
+    const firstWriteStarted = new Promise((resolve) => {
+      markFirstWriteStarted = resolve;
+    });
+    let releaseFirstWrite;
+    const firstWriteBlocked = new Promise((resolve) => {
+      releaseFirstWrite = resolve;
+    });
+
+    fs.writeFile.mockImplementation(async (path, content) => {
+      if (path.includes("writer-one")) {
+        markFirstWriteStarted();
+        await firstWriteBlocked;
+      }
+      files.set(path, content);
+    });
+    fs.rename.mockImplementation(async (tempPath, storagePath) => {
+      const content = files.get(tempPath);
+      if (content === undefined) throw new Error("temp file missing");
+      files.set(storagePath, content);
+      files.delete(tempPath);
+    });
+
+    const firstStorage = {
+      version: 1,
+      accounts: [{ refreshToken: "first-writer" }],
+      activeIndex: 0,
+    };
+    const secondStorage = {
+      version: 1,
+      accounts: [{ refreshToken: "second-writer" }],
+      activeIndex: 0,
+    };
+    const emptyDisk = { version: 1, accounts: [], activeIndex: 0 };
+
+    const firstSave = saveAccounts(firstStorage, emptyDisk);
+    await firstWriteStarted;
+    await saveAccounts(secondStorage, emptyDisk);
+    releaseFirstWrite();
+    await firstSave;
+
+    const storagePath = fs.rename.mock.calls.at(-1)[1];
+    const persisted = JSON.parse(files.get(storagePath));
+    expect(persisted).toEqual(firstStorage);
+    expect([...files.keys()].filter((path) => path.endsWith(".tmp"))).toEqual([]);
+  });
+
+  itWindows("propagates a Windows ACL-denied write and removes the temp file", async () => {
+    const accessDenied = Object.assign(new Error("access denied"), { code: "EACCES" });
+    fs.writeFile.mockRejectedValue(accessDenied);
+    fs.unlink.mockResolvedValue(undefined);
+
+    const storage = { version: 1, accounts: [], activeIndex: 0 };
+    await expect(saveAccounts(storage, storage)).rejects.toBe(accessDenied);
+
+    const tempPath = fs.writeFile.mock.calls[0][0];
+    expect(fs.rename).not.toHaveBeenCalled();
+    expect(fs.unlink).toHaveBeenCalledWith(tempPath);
+  });
+
+  it("cleans up the temp file when atomic rename fails", async () => {
+    const renameError = Object.assign(new Error("rename failed"), { code: "EPERM" });
+    fs.rename.mockRejectedValue(renameError);
+    fs.unlink.mockResolvedValue(undefined);
+
+    const storage = { version: 1, accounts: [], activeIndex: 0 };
+    await expect(saveAccounts(storage, storage)).rejects.toBe(renameError);
+
+    const tempPath = fs.writeFile.mock.calls[0][0];
+    expect(fs.rename).toHaveBeenCalledWith(tempPath, expect.stringMatching(/anthropic-accounts\.json$/));
+    expect(fs.unlink).toHaveBeenCalledWith(tempPath);
+  });
+
   it("merges auth fields from fresher disk state", async () => {
     fs.readFile.mockResolvedValue(
       JSON.stringify({

package/lib/token-economy/microcompact.mjs

@@ -0,0 +1,35 @@
+/**
+ * Microcompact decision helpers (token-economy).
+ *
+ * Pure helpers extracted from index.mjs: whether to inject microcompact betas
+ * based on estimated prompt token usage, and the fixed microcompact beta list.
+ * The stateful microcompact gating (microcompactState) remains in the
+ * interceptor shell in index.mjs.
+ *
+ * @module token-economy/microcompact
+ */
+
+/**
+ * Determine if microcompact betas should be injected based on estimated token usage.
+ * @param {number} estimatedTokens - Estimated prompt token count
+ * @param {object} config - Plugin config
+ * @returns {boolean}
+ */
+export function shouldMicrocompact(estimatedTokens, config) {
+  if (!config.microcompact?.enabled) return false;
+  const thresholdPct = config.microcompact.threshold_percent ?? 80;
+  // Use the model's context window. Default to 200K if unknown.
+  // Adaptive context may escalate to 1M, but we use the base 200K for threshold
+  // to be conservative (microcompact at 160K tokens is still valuable).
+  const contextWindow = 200_000;
+  const threshold = contextWindow * (thresholdPct / 100);
+  return estimatedTokens >= threshold;
+}
+
+/**
+ * Build the list of microcompact betas to inject.
+ * @returns {string[]} Array of beta flag strings
+ */
+export function buildMicrocompactBetas() {
+  return ["clear_tool_uses_20250919", "clear_thinking_20251015"];
+}

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

@@ -0,0 +1,28 @@
+import { describe, it, expect } from "vitest";
+import { shouldMicrocompact, buildMicrocompactBetas } from "./microcompact.mjs";
+
+describe("shouldMicrocompact", () => {
+  it("returns false when microcompact is disabled or unconfigured", () => {
+    expect(shouldMicrocompact(1_000_000, {})).toBe(false);
+    expect(shouldMicrocompact(1_000_000, { microcompact: { enabled: false } })).toBe(false);
+  });
+
+  it("uses the default 80% threshold of a 200K window (=160K)", () => {
+    const config = { microcompact: { enabled: true } };
+    expect(shouldMicrocompact(159_999, config)).toBe(false);
+    expect(shouldMicrocompact(160_000, config)).toBe(true);
+    expect(shouldMicrocompact(200_000, config)).toBe(true);
+  });
+
+  it("honors a custom threshold_percent", () => {
+    const config = { microcompact: { enabled: true, threshold_percent: 50 } };
+    expect(shouldMicrocompact(99_999, config)).toBe(false);
+    expect(shouldMicrocompact(100_000, config)).toBe(true);
+  });
+});
+
+describe("buildMicrocompactBetas", () => {
+  it("returns the fixed microcompact beta flag list", () => {
+    expect(buildMicrocompactBetas()).toEqual(["clear_tool_uses_20250919", "clear_thinking_20251015"]);
+  });
+});