opencode-anthropic-fix 0.1.20 → 0.1.21

package/index.mjs

@@ -21,6 +21,7 @@ import {
 } from "./lib/backoff.mjs";
 import { callHaiku } from "./lib/haiku-call.mjs";
 import { summarize as rollingSummarize } from "./lib/rolling-summarizer.mjs";
+import { staleReadEviction, perToolClassPrune } from "./lib/message-transform.mjs";
 
 // ---------------------------------------------------------------------------
 // Account management CLI prompts
@@ -4058,6 +4059,24 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
         },
       ],
     },
+    /**
+     * Stateless message-list transforms. Previously fork-only patches
+     * (4c3f4fc19 stale-read eviction, 797ae24d8 per-tool-class prune)
+     * now live here and apply on the cloned request messages. Hook
+     * input is `{}` — no sessionID, so these are global policies.
+     */
+    "experimental.chat.messages.transform": async (_input, output) => {
+      const strategies = config?.token_economy_strategies;
+      if (!strategies) return;
+      if (!output?.messages) return;
+
+      if (strategies.stale_read_eviction) {
+        staleReadEviction({ messages: output.messages });
+      }
+      if (strategies.per_tool_class_prune) {
+        perToolClassPrune({ messages: output.messages });
+      }
+    },
     "experimental.session.compacting": async (input, output) => {
       // Reset adaptive context state on session compaction (new conversation boundary).
       // This prevents sticky escalation from leaking across conversations.

package/lib/config.mjs

@@ -311,6 +311,17 @@ export const DEFAULT_CONFIG = {
      *  summary, bypassing the main model. Requires opencode fork support
      *  — no-op without it. Off by default. */
     haiku_rolling_summary: false,
+    /** Stale-read eviction: replace `read`/`view` tool outputs from
+     *  messages older than N turns with a placeholder. Runs on every
+     *  request via `experimental.chat.messages.transform`. Saves
+     *  ~1-2KB per old read × conversation depth. Off by default. */
+    stale_read_eviction: false,
+    /** Per-tool-class prune thresholds: apply different token budgets
+     *  to reproducible (read/grep/glob/ls) vs stateful (bash/edit/write)
+     *  tool outputs during request assembly. Reproducible outputs can
+     *  be re-run on demand, so they prune at a lower threshold. Off by
+     *  default — when ON, uses 10_000/40_000 token budgets. */
+    per_tool_class_prune: false,
   },
   /** Output cap: default max_tokens to save context window. */
   output_cap: {
@@ -791,6 +802,14 @@ function validateConfig(raw) {
         typeof tes.haiku_rolling_summary === "boolean"
           ? tes.haiku_rolling_summary
           : DEFAULT_CONFIG.token_economy_strategies.haiku_rolling_summary,
+      stale_read_eviction:
+        typeof tes.stale_read_eviction === "boolean"
+          ? tes.stale_read_eviction
+          : DEFAULT_CONFIG.token_economy_strategies.stale_read_eviction,
+      per_tool_class_prune:
+        typeof tes.per_tool_class_prune === "boolean"
+          ? tes.per_tool_class_prune
+          : DEFAULT_CONFIG.token_economy_strategies.per_tool_class_prune,
     };
   }
 

package/lib/config.test.mjs

@@ -410,3 +410,51 @@ describe("token_economy_strategies.haiku_rolling_summary", () => {
     expect(cfg.token_economy_strategies.haiku_rolling_summary).toBe(false);
   });
 });
+
+describe("token_economy_strategies.stale_read_eviction", () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  it("defaults to false in DEFAULT_CONFIG", () => {
+    expect(DEFAULT_CONFIG.token_economy_strategies.stale_read_eviction).toBe(false);
+  });
+
+  it("accepts true when explicitly set", () => {
+    existsSync.mockReturnValue(true);
+    readFileSync.mockReturnValue(JSON.stringify({ token_economy_strategies: { stale_read_eviction: true } }));
+    const cfg = loadConfig();
+    expect(cfg.token_economy_strategies.stale_read_eviction).toBe(true);
+  });
+
+  it("falls back to default on non-boolean value", () => {
+    existsSync.mockReturnValue(true);
+    readFileSync.mockReturnValue(JSON.stringify({ token_economy_strategies: { stale_read_eviction: 1 } }));
+    const cfg = loadConfig();
+    expect(cfg.token_economy_strategies.stale_read_eviction).toBe(false);
+  });
+});
+
+describe("token_economy_strategies.per_tool_class_prune", () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  it("defaults to false in DEFAULT_CONFIG", () => {
+    expect(DEFAULT_CONFIG.token_economy_strategies.per_tool_class_prune).toBe(false);
+  });
+
+  it("accepts true when explicitly set", () => {
+    existsSync.mockReturnValue(true);
+    readFileSync.mockReturnValue(JSON.stringify({ token_economy_strategies: { per_tool_class_prune: true } }));
+    const cfg = loadConfig();
+    expect(cfg.token_economy_strategies.per_tool_class_prune).toBe(true);
+  });
+
+  it("falls back to default on non-boolean value", () => {
+    existsSync.mockReturnValue(true);
+    readFileSync.mockReturnValue(JSON.stringify({ token_economy_strategies: { per_tool_class_prune: "on" } }));
+    const cfg = loadConfig();
+    expect(cfg.token_economy_strategies.per_tool_class_prune).toBe(false);
+  });
+});

package/lib/message-transform.mjs

@@ -0,0 +1,132 @@
+/**
+ * Stateless message-list transforms applied via
+ * `experimental.chat.messages.transform` hook. The hook input is empty
+ * (`{}` — no sessionID, no agent role), so these policies are global to
+ * all sessions when enabled.
+ *
+ * The `messages` array passed to the hook is a `structuredClone` of the
+ * session state, so mutation is safe and ONLY affects the outbound
+ * request — storage is untouched.
+ */
+
+/** Tool names treated as read-class (content can be re-fetched). */
+export const STALE_READ_TOOLS = new Set(["read", "view"]);
+
+/** Tool names trivially re-runnable (idempotent + cheap). */
+export const REPRODUCIBLE_TOOLS = new Set(["read", "grep", "glob", "ls", "list", "find"]);
+
+/** Tools never pruned (provider-critical, e.g. skill catalog). */
+const PRUNE_PROTECTED_TOOLS = new Set(["skill"]);
+
+/** Replacement text for stale read outputs. */
+const STALE_READ_PLACEHOLDER = "[File was read earlier in this session — re-read if you need the current contents]";
+
+/** Rough char-to-token ratio — same heuristic opencode uses for estimates. */
+function estimateTokens(text) {
+  if (typeof text !== "string" || text.length === 0) return 0;
+  return Math.ceil(text.length / 4);
+}
+
+/**
+ * Replace read/view tool outputs from messages older than `threshold`
+ * messages-from-end with a placeholder note, and drop their attachments.
+ *
+ * Stateless. Does NOT mutate storage. Only affects the outbound request.
+ *
+ * @param {{messages: Array<{info: any, parts: any[]}>, threshold?: number, tools?: Set<string>}} args
+ * @returns {{evicted: number}} — how many tool parts were rewritten
+ */
+export function staleReadEviction({ messages, threshold = 10, tools = STALE_READ_TOOLS }) {
+  if (!Array.isArray(messages) || messages.length <= threshold) {
+    return { evicted: 0 };
+  }
+
+  const cutoff = messages.length - threshold;
+  let evicted = 0;
+
+  for (let i = 0; i < cutoff; i++) {
+    const msg = messages[i];
+    if (!msg?.parts) continue;
+
+    for (const part of msg.parts) {
+      if (part?.type !== "tool") continue;
+      if (part.state?.status !== "completed") continue;
+      if (part.state.time?.compacted) continue;
+      if (!tools.has(part.tool)) continue;
+
+      part.state.output = STALE_READ_PLACEHOLDER;
+      if (part.state.attachments) {
+        part.state.attachments = [];
+      }
+      evicted++;
+    }
+  }
+
+  return { evicted };
+}
+
+/**
+ * Prune older tool outputs by class, keeping the most recent N tokens
+ * worth per class (reproducible vs stateful). Walks backward from the
+ * end; once a class's running total exceeds its threshold, older outputs
+ * of that class are replaced with empty strings.
+ *
+ * Stateless. Mirrors the core `compaction.prune()` logic but applies at
+ * request-assembly time instead of persisting to storage.
+ *
+ * @param {{messages: Array<{info: any, parts: any[]}>, reproducibleThreshold?: number, statefulThreshold?: number, reproducibleTools?: Set<string>}} args
+ * @returns {{pruned: number, tokensSaved: number}}
+ */
+export function perToolClassPrune({
+  messages,
+  reproducibleThreshold = 10_000,
+  statefulThreshold = 40_000,
+  reproducibleTools = REPRODUCIBLE_TOOLS,
+}) {
+  if (!Array.isArray(messages) || messages.length === 0) {
+    return { pruned: 0, tokensSaved: 0 };
+  }
+
+  let totalReproducible = 0;
+  let totalStateful = 0;
+  let pruned = 0;
+  let tokensSaved = 0;
+
+  // Walk backward through messages; within each message, also backward
+  // through parts — matches the original prune() ordering.
+  outer: for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (!msg?.parts?.length) continue;
+
+    for (let j = msg.parts.length - 1; j >= 0; j--) {
+      const part = msg.parts[j];
+      if (part?.type !== "tool") continue;
+      if (part.state?.status !== "completed") continue;
+      if (PRUNE_PROTECTED_TOOLS.has(part.tool)) continue;
+      if (part.state.time?.compacted) break outer;
+
+      const estimate = estimateTokens(part.state.output);
+      const isReproducible = reproducibleTools.has(part.tool.toLowerCase());
+
+      if (isReproducible) {
+        totalReproducible += estimate;
+        if (totalReproducible > reproducibleThreshold) {
+          part.state.output = "";
+          if (part.state.attachments) part.state.attachments = [];
+          pruned++;
+          tokensSaved += estimate;
+        }
+      } else {
+        totalStateful += estimate;
+        if (totalStateful > statefulThreshold) {
+          part.state.output = "";
+          if (part.state.attachments) part.state.attachments = [];
+          pruned++;
+          tokensSaved += estimate;
+        }
+      }
+    }
+  }
+
+  return { pruned, tokensSaved };
+}

package/lib/message-transform.test.mjs

@@ -0,0 +1,173 @@
+import { describe, expect, it } from "vitest";
+import { staleReadEviction, perToolClassPrune, STALE_READ_TOOLS, REPRODUCIBLE_TOOLS } from "./message-transform.mjs";
+
+/** Build a message with a single tool part. */
+function toolMsg(tool, output, { compacted = false, attachments } = {}) {
+  return {
+    info: { role: "assistant", id: `msg-${Math.random()}` },
+    parts: [
+      {
+        type: "tool",
+        callID: "c1",
+        tool,
+        state: {
+          status: "completed",
+          input: {},
+          output,
+          title: "t",
+          metadata: {},
+          time: { start: 0, end: 1, ...(compacted ? { compacted: 1 } : {}) },
+          ...(attachments ? { attachments } : {}),
+        },
+      },
+    ],
+  };
+}
+
+describe("staleReadEviction", () => {
+  it("is a no-op when messages <= threshold", () => {
+    const msgs = [toolMsg("read", "content")];
+    const { evicted } = staleReadEviction({ messages: msgs, threshold: 10 });
+    expect(evicted).toBe(0);
+    expect(msgs[0].parts[0].state.output).toBe("content");
+  });
+
+  it("replaces read output older than threshold with placeholder", () => {
+    const msgs = Array.from({ length: 15 }, (_, i) => toolMsg("read", `file ${i} content`));
+    const { evicted } = staleReadEviction({ messages: msgs, threshold: 10 });
+    expect(evicted).toBe(5);
+    expect(msgs[0].parts[0].state.output).toMatch(/re-read if you need/);
+    expect(msgs[4].parts[0].state.output).toMatch(/re-read if you need/);
+    expect(msgs[5].parts[0].state.output).toBe("file 5 content");
+    expect(msgs[14].parts[0].state.output).toBe("file 14 content");
+  });
+
+  it("leaves non-read tools untouched", () => {
+    const msgs = Array.from({ length: 15 }, (_, i) => toolMsg("bash", `cmd ${i} output`));
+    const { evicted } = staleReadEviction({ messages: msgs, threshold: 10 });
+    expect(evicted).toBe(0);
+    expect(msgs[0].parts[0].state.output).toBe("cmd 0 output");
+  });
+
+  it("skips already-compacted tool parts", () => {
+    const msgs = [
+      toolMsg("read", "stale but compacted", { compacted: true }),
+      ...Array.from({ length: 11 }, (_, i) => toolMsg("read", `x${i}`)),
+    ];
+    const { evicted } = staleReadEviction({ messages: msgs, threshold: 10 });
+    expect(evicted).toBe(1);
+    expect(msgs[0].parts[0].state.output).toBe("stale but compacted");
+    expect(msgs[1].parts[0].state.output).toMatch(/re-read if you need/);
+  });
+
+  it("strips attachments when evicting", () => {
+    const msgs = Array.from({ length: 15 }, (_, i) =>
+      toolMsg("read", `file ${i}`, {
+        attachments: [{ type: "file", mime: "image/png", url: "x" }],
+      }),
+    );
+    staleReadEviction({ messages: msgs, threshold: 10 });
+    expect(msgs[0].parts[0].state.attachments).toEqual([]);
+    expect(msgs[14].parts[0].state.attachments).toHaveLength(1);
+  });
+
+  it("accepts `view` as a read-class tool", () => {
+    expect(STALE_READ_TOOLS.has("view")).toBe(true);
+    const msgs = Array.from({ length: 15 }, (_, i) => toolMsg("view", `content ${i}`));
+    const { evicted } = staleReadEviction({ messages: msgs, threshold: 10 });
+    expect(evicted).toBe(5);
+  });
+
+  it("handles empty/missing messages gracefully", () => {
+    expect(staleReadEviction({ messages: [] }).evicted).toBe(0);
+    expect(staleReadEviction({ messages: null }).evicted).toBe(0);
+  });
+});
+
+describe("perToolClassPrune", () => {
+  it("prunes old reproducible outputs over the 10k threshold", () => {
+    const output = "x".repeat(30_000); // ~7_500 tokens (chars/4)
+    const msgs = Array.from({ length: 3 }, () => toolMsg("read", output));
+    const { pruned, tokensSaved } = perToolClassPrune({
+      messages: msgs,
+      reproducibleThreshold: 10_000,
+    });
+    // Walk backward: newest (7_500) fits under 10k, older 2 push total over → pruned.
+    expect(pruned).toBe(2);
+    expect(tokensSaved).toBeGreaterThan(10_000);
+    expect(msgs[2].parts[0].state.output).toBe(output); // newest kept
+    expect(msgs[0].parts[0].state.output).toBe("");
+    expect(msgs[1].parts[0].state.output).toBe("");
+  });
+
+  it("uses higher threshold for stateful tools (bash)", () => {
+    const mid = "x".repeat(50_000); // ~12_500 tokens
+    const msgs = Array.from({ length: 3 }, () => toolMsg("bash", mid));
+    const { pruned } = perToolClassPrune({
+      messages: msgs,
+      statefulThreshold: 40_000,
+    });
+    // 3 × 12_500 = 37_500 < 40_000 → nothing pruned
+    expect(pruned).toBe(0);
+  });
+
+  it("never prunes protected tools (skill)", () => {
+    const big = "x".repeat(500_000); // ~125_000 tokens — would bust any threshold
+    const msgs = Array.from({ length: 3 }, () => toolMsg("skill", big));
+    const { pruned } = perToolClassPrune({ messages: msgs });
+    expect(pruned).toBe(0);
+    expect(msgs[0].parts[0].state.output).toBe(big);
+  });
+
+  it("stops walking back when it hits a compacted part", () => {
+    const big = "x".repeat(50_000);
+    const msgs = [
+      toolMsg("read", "must-not-prune-old", { compacted: true }),
+      ...Array.from({ length: 3 }, () => toolMsg("read", big)),
+    ];
+    perToolClassPrune({ messages: msgs, reproducibleThreshold: 10_000 });
+    // Compacted sentinel preserved; walk terminates before reaching it.
+    expect(msgs[0].parts[0].state.output).toBe("must-not-prune-old");
+  });
+
+  it("tracks reproducible and stateful budgets independently", () => {
+    const output = "x".repeat(30_000); // ~7_500 tokens each
+    // interleave: read, bash, read, bash, read, bash (oldest to newest)
+    const msgs = [
+      toolMsg("read", output),
+      toolMsg("bash", output),
+      toolMsg("read", output),
+      toolMsg("bash", output),
+      toolMsg("read", output),
+      toolMsg("bash", output),
+    ];
+    const { pruned } = perToolClassPrune({
+      messages: msgs,
+      reproducibleThreshold: 10_000,
+      statefulThreshold: 40_000,
+    });
+    // reads: 7_500, 15_000 → over → prune; 22_500 → prune. 2 old reads pruned.
+    // bash:  7_500, 15_000, 22_500 → all under 40k → 0 pruned.
+    expect(pruned).toBe(2);
+    expect(msgs[4].parts[0].state.output).toBe(output); // newest read kept
+    expect(msgs[5].parts[0].state.output).toBe(output); // newest bash kept
+    expect(msgs[0].parts[0].state.output).toBe(""); // oldest read pruned
+    expect(msgs[2].parts[0].state.output).toBe(""); // middle read pruned
+  });
+
+  it("normalizes tool name case when classifying", () => {
+    expect(REPRODUCIBLE_TOOLS.has("read")).toBe(true);
+    const output = "x".repeat(30_000); // ~7_500 tokens
+    const msgs = Array.from({ length: 3 }, () => toolMsg("READ", output));
+    const { pruned } = perToolClassPrune({
+      messages: msgs,
+      reproducibleThreshold: 10_000,
+    });
+    expect(pruned).toBe(2);
+  });
+
+  it("handles empty/missing messages gracefully", () => {
+    expect(perToolClassPrune({ messages: [] }).pruned).toBe(0);
+    expect(perToolClassPrune({ messages: null }).pruned).toBe(0);
+  });
+});

package/package.json

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