opencode-anthropic-fix 0.1.31 → 0.2.0

package/lib/env.test.mjs

@@ -0,0 +1,25 @@
+import { describe, expect, it } from "vitest";
+
+import { isFalsyEnv, isTruthyEnv } from "./env.mjs";
+
+describe("environment value parsers", () => {
+  describe("isTruthyEnv", () => {
+    it.each(["1", "true", "yes", " TRUE ", "Yes"])("accepts %j", (value) => {
+      expect(isTruthyEnv(value)).toBe(true);
+    });
+
+    it.each([undefined, "", "0", "false", "no", "on", "off", "anything"])("rejects %j", (value) => {
+      expect(isTruthyEnv(value)).toBe(false);
+    });
+  });
+
+  describe("isFalsyEnv", () => {
+    it.each(["0", "false", "no", " FALSE ", "No"])("accepts %j", (value) => {
+      expect(isFalsyEnv(value)).toBe(true);
+    });
+
+    it.each([undefined, "", "1", "true", "yes", "on", "off", "anything"])("rejects %j", (value) => {
+      expect(isFalsyEnv(value)).toBe(false);
+    });
+  });
+});

package/lib/mimicry/cache.mjs

@@ -0,0 +1,62 @@
+import { isTruthyEnv } from "../env.mjs";
+
+/**
+ * Resolve the prompt-cache TTL for the current request role and overrides.
+ *
+ * @param {{configuredTtl: string, roleScopedTtl: boolean, isMainForCache: boolean, isSubagent?: boolean, env?: NodeJS.ProcessEnv}} options
+ * @returns {string}
+ */
+export function resolveCacheTtl({
+  configuredTtl,
+  roleScopedTtl,
+  isMainForCache,
+  isSubagent = false,
+  env = process.env,
+}) {
+  if (isTruthyEnv(env.FORCE_PROMPT_CACHING_5M)) return "5m";
+  if (isTruthyEnv(env.ENABLE_PROMPT_CACHING_1H)) return "1h";
+  if (roleScopedTtl && isSubagent) return "5m";
+  if (roleScopedTtl && !isMainForCache) return "5m";
+  return configuredTtl;
+}
+
+/**
+ * Decide whether the tools cache breakpoint should be placed for this turn.
+ *
+ * @param {Map<string, number> | null | undefined} stability
+ * @returns {boolean}
+ */
+export function shouldPlaceToolBreakpoint(stability) {
+  if (!stability || stability.size === 0) return true;
+  const STABLE_TURNS = 2;
+  const systemStability = stability.get("system_prompt");
+  const systemIsStable = typeof systemStability === "number" && systemStability >= STABLE_TURNS;
+  if (!systemIsStable) return true;
+  for (const [source, turns] of stability) {
+    if (source.startsWith("tool:") && turns === 0) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/**
+ * Update consecutive-unchanged counters on the supplied stability map.
+ *
+ * @param {Map<string, string>} current
+ * @param {Map<string, string>} previous
+ * @param {Map<string, number>} stability
+ * @returns {void}
+ */
+export function updateBoundaryStability(current, previous, stability) {
+  for (const [source, hash] of current) {
+    if (previous.get(source) === hash) {
+      stability.set(source, (stability.get(source) || 0) + 1);
+    } else {
+      stability.set(source, 0);
+    }
+  }
+  for (const source of [...stability.keys()]) {
+    if (!current.has(source)) stability.delete(source);
+  }
+}

package/lib/mimicry/cache.test.mjs

@@ -0,0 +1,112 @@
+import { describe, expect, it } from "vitest";
+
+import { resolveCacheTtl, shouldPlaceToolBreakpoint, updateBoundaryStability } from "./cache.mjs";
+
+describe("resolveCacheTtl", () => {
+  const base = {
+    configuredTtl: "1h",
+    roleScopedTtl: true,
+    isMainForCache: true,
+    env: {},
+  };
+
+  it("returns the configured TTL for the main role", () => {
+    expect(resolveCacheTtl(base)).toBe("1h");
+  });
+
+  it("downgrades side-query and subagent roles when role scoping is enabled", () => {
+    expect(resolveCacheTtl({ ...base, isMainForCache: false })).toBe("5m");
+    expect(resolveCacheTtl({ ...base, isSubagent: true })).toBe("5m");
+  });
+
+  it("honors the 5m environment override first", () => {
+    expect(
+      resolveCacheTtl({
+        ...base,
+        env: { FORCE_PROMPT_CACHING_5M: "1", ENABLE_PROMPT_CACHING_1H: "1" },
+      }),
+    ).toBe("5m");
+  });
+
+  it("honors the 1h environment override before role scoping", () => {
+    expect(
+      resolveCacheTtl({
+        ...base,
+        isMainForCache: false,
+        env: { ENABLE_PROMPT_CACHING_1H: "true" },
+      }),
+    ).toBe("1h");
+  });
+
+  it("keeps the configured TTL when role scoping is disabled", () => {
+    expect(resolveCacheTtl({ ...base, configuredTtl: "5m", roleScopedTtl: false })).toBe("5m");
+  });
+});
+
+describe("shouldPlaceToolBreakpoint", () => {
+  it("places a breakpoint when stability data is unavailable", () => {
+    expect(shouldPlaceToolBreakpoint(undefined)).toBe(true);
+    expect(shouldPlaceToolBreakpoint(new Map())).toBe(true);
+  });
+
+  it("places a breakpoint below the stable-system boundary", () => {
+    expect(
+      shouldPlaceToolBreakpoint(
+        new Map([
+          ["system_prompt", 1],
+          ["tool:read", 0],
+        ]),
+      ),
+    ).toBe(true);
+  });
+
+  it("skips a volatile tool breakpoint once the system is stable", () => {
+    expect(
+      shouldPlaceToolBreakpoint(
+        new Map([
+          ["system_prompt", 2],
+          ["tool:read", 0],
+        ]),
+      ),
+    ).toBe(false);
+  });
+
+  it("places the breakpoint when both system and tools are stable", () => {
+    expect(
+      shouldPlaceToolBreakpoint(
+        new Map([
+          ["system_prompt", 2],
+          ["tool:read", 1],
+        ]),
+      ),
+    ).toBe(true);
+  });
+});
+
+describe("updateBoundaryStability", () => {
+  it("mutates only the passed stability map across boundary transitions", () => {
+    const previous = new Map([
+      ["system_prompt", "system-v1"],
+      ["tool:read", "read-v1"],
+      ["tool:gone", "gone-v1"],
+    ]);
+    const current = new Map([
+      ["system_prompt", "system-v1"],
+      ["tool:read", "read-v2"],
+      ["tool:new", "new-v1"],
+    ]);
+    const stability = new Map([
+      ["system_prompt", 1],
+      ["tool:read", 4],
+      ["tool:gone", 3],
+    ]);
+
+    expect(updateBoundaryStability(current, previous, stability)).toBeUndefined();
+
+    expect([...stability]).toEqual([
+      ["system_prompt", 2],
+      ["tool:read", 0],
+      ["tool:new", 0],
+    ]);
+  });
+});