@tokenbuddy/tokenbuddy 1.0.36 → 1.0.38

package/tests/model-index.test.ts

@@ -1,198 +0,0 @@
-import { ModelIndex } from "../src/model-index.js";
-import type { RegistrySeller } from "../src/seller-catalog.js";
-
-function makeSeller(overrides: Partial<RegistrySeller> & { id: string; models?: string[] }): RegistrySeller {
-  return {
-    id: overrides.id,
-    name: overrides.name ?? overrides.id,
-    status: overrides.status,
-    url: overrides.url ?? `https://${overrides.id}.example.com`,
-    supportedProtocols: overrides.supportedProtocols ?? ["chat_completions"],
-    paymentMethods: overrides.paymentMethods ?? ["clawtip"],
-    models: overrides.models
-  };
-}
-
-describe("ModelIndex", () => {
-  test("rebuilds an empty snapshot without throwing", () => {
-    const index = new ModelIndex();
-    index.rebuild([], { registryVersion: 1 });
-
-    expect(index.sellersFor("anything")).toEqual([]);
-    expect(index.knownModelIds()).toEqual([]);
-    const stats = index.stats();
-    expect(stats.sellerCount).toBe(0);
-    expect(stats.modelCount).toBe(0);
-    expect(stats.missingModelsCount).toBe(0);
-    expect(stats.registryVersion).toBe(1);
-  });
-
-  test("rebuild populates byModel and bySeller from a registry snapshot", () => {
-    const index = new ModelIndex();
-    const sellers: RegistrySeller[] = [
-      makeSeller({ id: "s1", models: ["claude-sonnet-4-5", "gpt-4o"] }),
-      makeSeller({ id: "s2", models: ["gpt-4o", "deepseek-v4-pro"] })
-    ];
-
-    index.rebuild(sellers, { registryVersion: 4, defaultSellerId: "s1" });
-
-    expect(index.sellersFor("claude-sonnet-4-5").map((s) => s.id)).toEqual(["s1"]);
-    expect(index.sellersFor("gpt-4o").map((s) => s.id)).toEqual(["s1", "s2"]);
-    expect(index.sellersFor("deepseek-v4-pro").map((s) => s.id)).toEqual(["s2"]);
-    expect(index.getSeller("s1")?.url).toBe("https://s1.example.com");
-    expect(index.getSeller("missing")).toBeUndefined();
-    expect(index.stats().defaultSellerId).toBe("s1");
-    expect(index.stats().registryVersion).toBe(4);
-  });
-
-  test("model id matching is case-insensitive and trims whitespace", () => {
-    const index = new ModelIndex();
-    index.rebuild([makeSeller({ id: "s1", models: ["claude-sonnet-4-5"] })]);
-
-    expect(index.sellersFor("Claude-Sonnet-4-5").map((s) => s.id)).toEqual(["s1"]);
-    expect(index.sellersFor("  claude-sonnet-4-5  ").map((s) => s.id)).toEqual(["s1"]);
-    expect(index.sellersFor("CLAUDE-SONNET-4-5").map((s) => s.id)).toEqual(["s1"]);
-  });
-
-  test("filters by protocol and payment method", () => {
-    const index = new ModelIndex();
-    const sellers: RegistrySeller[] = [
-      makeSeller({
-        id: "s-chat",
-        models: ["gpt-4o"],
-        supportedProtocols: ["chat_completions"],
-        paymentMethods: ["clawtip"]
-      }),
-      makeSeller({
-        id: "s-msg",
-        models: ["gpt-4o"],
-        supportedProtocols: ["messages"],
-        paymentMethods: ["mock"]
-      })
-    ];
-    index.rebuild(sellers);
-
-    const chatClawtip = index.sellersFor("gpt-4o", { protocol: "chat_completions", paymentMethod: "clawtip" });
-    expect(chatClawtip.map((s) => s.id)).toEqual(["s-chat"]);
-
-    const messages = index.sellersFor("gpt-4o", { protocol: "messages" });
-    expect(messages.map((s) => s.id)).toEqual(["s-msg"]);
-
-    const messagesClawtip = index.sellersFor("gpt-4o", { protocol: "messages", paymentMethod: "clawtip" });
-    expect(messagesClawtip).toEqual([]);
-
-    const noFilter = index.sellersFor("gpt-4o");
-    expect(noFilter.map((s) => s.id).sort()).toEqual(["s-chat", "s-msg"]);
-  });
-
-  test("indexes only active buyer-visible registry sellers", () => {
-    const index = new ModelIndex();
-    index.rebuild([
-      makeSeller({ id: "legacy-no-status", models: ["gpt-4o"] }),
-      makeSeller({ id: "active", status: "active", models: ["gpt-4o"] }),
-      makeSeller({ id: "pending", status: "pending", models: ["gpt-4o"] }),
-      makeSeller({ id: "offline", status: "offline", models: ["gpt-4o"] })
-    ]);
-
-    expect(index.sellersFor("gpt-4o").map((seller) => seller.id)).toEqual(["legacy-no-status", "active"]);
-    expect(index.getSeller("pending")).toBeUndefined();
-  });
-
-  test("sellers missing models field are excluded from lookups but still addressable by id", () => {
-    const index = new ModelIndex();
-    const sellers: RegistrySeller[] = [
-      makeSeller({ id: "ok", models: ["gpt-4o"] }),
-      makeSeller({ id: "broken" }) // no models
-    ];
-    index.rebuild(sellers);
-
-    expect(index.sellersFor("gpt-4o").map((s) => s.id)).toEqual(["ok"]);
-    expect(index.getSeller("broken")?.id).toBe("broken");
-    expect(index.stats().missingModelsCount).toBe(1);
-    expect(index.stats().sellerCount).toBe(2);
-  });
-
-  test("resolve returns matched flag and snapshot", () => {
-    const index = new ModelIndex();
-    index.rebuild([makeSeller({ id: "s1", models: ["gpt-4o"] })]);
-
-    const hit = index.resolve("gpt-4o");
-    expect(hit.matched).toBe(true);
-    expect(hit.sellers).toHaveLength(1);
-
-    const miss = index.resolve("unknown-model");
-    expect(miss.matched).toBe(false);
-    expect(miss.sellers).toEqual([]);
-  });
-
-  test("rebuild replaces the previous snapshot atomically", () => {
-    const index = new ModelIndex();
-    index.rebuild([makeSeller({ id: "s1", models: ["m1"] })], { registryVersion: 1 });
-    expect(index.sellersFor("m1")).toHaveLength(1);
-
-    index.rebuild([makeSeller({ id: "s2", models: ["m2"] })], { registryVersion: 2 });
-    expect(index.sellersFor("m1")).toEqual([]);
-    expect(index.sellersFor("m2")).toHaveLength(1);
-    expect(index.stats().registryVersion).toBe(2);
-  });
-
-  test("prune drops sellers that have not been seen within staleAfterMs", () => {
-    const index = new ModelIndex();
-    index.rebuild([
-      makeSeller({ id: "s1", models: ["gpt-4o", "m1"] }),
-      makeSeller({ id: "s2", models: ["m2"] })
-    ]);
-
-    const now = 1_700_000_000_000;
-    const lastSeenAt = new Map<string, number>([
-      ["s1", now - 1000], // fresh
-      ["s2", now - 10 * 24 * 60 * 60 * 1000] // 10 days old
-    ]);
-
-    const removed = index.prune(lastSeenAt, 7 * 24 * 60 * 60 * 1000, now);
-    expect(removed).toBe(1);
-    expect(index.getSeller("s1")).toBeDefined();
-    expect(index.getSeller("s2")).toBeUndefined();
-    // Models that belonged only to the pruned seller must be removed.
-    expect(index.sellersFor("m2")).toEqual([]);
-    // Models shared with the remaining seller must still resolve.
-    expect(index.sellersFor("gpt-4o")).toHaveLength(1);
-  });
-
-  test("prune is a no-op when staleAfterMs is non-positive", () => {
-    const index = new ModelIndex();
-    index.rebuild([makeSeller({ id: "s1", models: ["m1"] })]);
-    expect(index.prune(new Map([["s1", 0]]), 0)).toBe(0);
-    expect(index.sellersFor("m1")).toHaveLength(1);
-  });
-
-  test("ignores malformed model entries when populating the index", () => {
-    const index = new ModelIndex();
-    const sellers: RegistrySeller[] = [
-      {
-        id: "s1",
-        name: "s1",
-        url: "https://s1.example.com",
-        supportedProtocols: ["chat_completions"],
-        paymentMethods: ["clawtip"],
-        // Mixed valid / invalid entries; the index must skip the bad ones
-        // without throwing.
-        models: ["m1", "", "   ", "m2"] as string[]
-      }
-    ];
-    index.rebuild(sellers);
-
-    expect(index.sellersFor("m1")).toHaveLength(1);
-    expect(index.sellersFor("m2")).toHaveLength(1);
-    expect(index.knownModelIds().sort()).toEqual(["m1", "m2"]);
-  });
-
-  test("knownModelIds returns a snapshot that does not mutate internal state", () => {
-    const index = new ModelIndex();
-    index.rebuild([makeSeller({ id: "s1", models: ["m1"] })]);
-
-    const ids = index.knownModelIds();
-    ids.push("hacked");
-    expect(index.knownModelIds()).toEqual(["m1"]);
-  });
-});

package/tests/package-update.test.ts

@@ -1,147 +0,0 @@
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-import {
-  checkPackageUpdate,
-  runPackageUpdate,
-  scheduleLaunchAgentRestart,
-} from "../src/package-update.js";
-
-function makeFetch(latestVersion: string, ok = true): typeof fetch {
-  return (async () => ({
-    ok,
-    status: ok ? 200 : 404,
-    json: async () => ({ "dist-tags": { latest: latestVersion } }),
-  })) as unknown as typeof fetch;
-}
-
-function writePackageJson(root: string, version: string, name = "@tokenbuddy/tokenbuddy"): string {
-  const binDir = path.join(root, "bin");
-  fs.mkdirSync(binDir, { recursive: true });
-  const binPath = path.join(binDir, "tb.js");
-  fs.writeFileSync(binPath, "", "utf8");
-  fs.writeFileSync(path.join(root, "package.json"), JSON.stringify({ name, version }), "utf8");
-  return binPath;
-}
-
-describe("TokenBuddy package update", () => {
-  let tempRoot: string;
-
-  beforeEach(() => {
-    tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "tokenbuddy-package-update-"));
-  });
-
-  afterEach(() => {
-    fs.rmSync(tempRoot, { recursive: true, force: true });
-  });
-
-  test("checks npm latest for the scoped tokenbuddy package", async () => {
-    const binPath = writePackageJson(tempRoot, "1.0.0");
-
-    const check = await checkPackageUpdate({
-      fetch: makeFetch("1.2.0"),
-      argv: ["node", binPath],
-      cwd: tempRoot,
-      env: {},
-    });
-
-    expect(check).toMatchObject({
-      packageName: "@tokenbuddy/tokenbuddy",
-      currentVersion: "1.0.0",
-      latestVersion: "1.2.0",
-      updateAvailable: true,
-      registryUrl: "https://registry.npmjs.org/%40tokenbuddy%2Ftokenbuddy",
-      installCommand: "npm install -g @tokenbuddy/tokenbuddy@1.2.0",
-    });
-  });
-
-  test("uses the unscoped package name only for legacy unscoped installs", async () => {
-    const binPath = writePackageJson(tempRoot, "1.0.0", "tokenbuddy");
-
-    const check = await checkPackageUpdate({
-      fetch: makeFetch("1.2.0"),
-      argv: ["node", binPath],
-      cwd: tempRoot,
-      env: {},
-    });
-
-    expect(check.packageName).toBe("tokenbuddy");
-    expect(check.installCommand).toBe("npm install -g tokenbuddy@1.2.0");
-  });
-
-  test("installs the latest package and restarts tb-proxyd when an update is available", async () => {
-    const binPath = writePackageJson(tempRoot, "1.0.0");
-    const installCalls: Array<{ command: string; args: string[] }> = [];
-    const restartCalls: number[] = [];
-
-    const result = await runPackageUpdate(
-      { apply: true, controlPort: 17820 },
-      {
-        fetch: makeFetch("1.1.0"),
-        argv: ["node", binPath],
-        cwd: tempRoot,
-        env: {},
-        runNpmInstall: (command, args) => {
-          installCalls.push({ command, args });
-        },
-        restartProxyd: async (controlPort) => {
-          restartCalls.push(controlPort);
-          return { attempted: true, restarted: true, method: "launchd" };
-        },
-      },
-    );
-
-    expect(result.install).toMatchObject({ attempted: true, succeeded: true });
-    expect(result.restart).toMatchObject({ attempted: true, restarted: true });
-    expect(installCalls).toEqual([{ command: "npm", args: ["install", "-g", "@tokenbuddy/tokenbuddy@1.1.0"] }]);
-    expect(restartCalls).toEqual([17820]);
-  });
-
-  test("does not install or restart when the current version is already latest", async () => {
-    const binPath = writePackageJson(tempRoot, "1.0.0");
-    const result = await runPackageUpdate(
-      { apply: true, controlPort: 17820 },
-      {
-        fetch: makeFetch("1.0.0"),
-        argv: ["node", binPath],
-        cwd: tempRoot,
-        env: {},
-        runNpmInstall: () => {
-          throw new Error("install should not run");
-        },
-        restartProxyd: async () => {
-          throw new Error("restart should not run");
-        },
-      },
-    );
-
-    expect(result.install.attempted).toBe(false);
-    expect(result.restart.attempted).toBe(false);
-  });
-
-  test("reports launchd restart scheduling without blocking on the current daemon process", () => {
-    const homeDir = path.join(tempRoot, "home");
-    const plistPath = path.join(homeDir, "Library", "LaunchAgents", "com.tokenbuddy.proxyd.plist");
-    fs.mkdirSync(path.dirname(plistPath), { recursive: true });
-    fs.writeFileSync(plistPath, "", "utf8");
-    const children: string[][] = [];
-
-    const result = scheduleLaunchAgentRestart({
-      platform: "darwin",
-      homeDir,
-      spawn: ((command: string, args: string[]) => {
-        children.push([command, ...args]);
-        return { unref: () => undefined };
-      }) as unknown as typeof import("child_process").spawn,
-    });
-
-    expect(result).toMatchObject({
-      attempted: true,
-      scheduled: true,
-      method: "launchd",
-      plistPath,
-    });
-    expect(children[0]).toEqual(expect.arrayContaining(["sh", "-c"]));
-    expect(children[0][2]).toContain("launchctl kickstart -k");
-  });
-});

package/tests/prewarm-cache.test.ts

@@ -1,296 +0,0 @@
-import {
-  DEFAULT_PREWARM_TTL_MS,
-  PrewarmCache,
-  prewarmKey
-} from "../src/prewarm-cache.js";
-
-describe("PrewarmCache", () => {
-  function makeCandidate(overrides: { sellerId: string; healthScore?: number; url?: string }) {
-    return {
-      sellerId: overrides.sellerId,
-      url: overrides.url ?? `https://${overrides.sellerId}.example.com`,
-      healthScore: overrides.healthScore ?? 80
-    };
-  }
-
-  test("key encoding is collision-free and case-insensitive", () => {
-    const a = prewarmKey("gpt-4o", "chat_completions", "clawtip");
-    const b = prewarmKey("GPT-4O", "Chat_Completions", "ClawTip");
-    expect(a).toBe(b);
-  });
-
-  test("get returns undefined for unknown keys; freshness reports empty", () => {
-    const cache = new PrewarmCache();
-    expect(cache.get("m1", "chat_completions", "clawtip")).toBeUndefined();
-    const f = cache.freshness("m1", "chat_completions", "clawtip");
-    expect(f.present).toBe(false);
-    expect(f.expired).toBe(true);
-    expect(f.expiringSoon).toBe(true);
-    expect(f.state).toBe("empty");
-  });
-
-  test("beginWarming creates a new warming entry without mutating any prior candidates", () => {
-    const cache = new PrewarmCache();
-    cache.commitWarm({
-      modelId: "gpt-4o",
-      protocol: "chat_completions",
-      paymentMethod: "clawtip",
-      candidates: [makeCandidate({ sellerId: "s1" })]
-    });
-
-    const begin = cache.beginWarming("gpt-4o", "chat_completions", "clawtip");
-    expect(begin.hadPrevious).toBe(true);
-    expect(begin.entry.state).toBe("warming");
-    // Prior warm candidates are preserved while a new probe is in flight;
-    // a re-probe that finds nothing must not silently wipe the cache.
-    expect(begin.entry.candidates).toHaveLength(1);
-    expect(begin.entry.candidates[0].sellerId).toBe("s1");
-  });
-
-  test("commitWarm resets warmedAt and replaces candidates", () => {
-    const fakeNow = (() => {
-      let t = 1_000_000;
-      return () => t;
-    })();
-    const cache = new PrewarmCache({ now: fakeNow });
-    cache.commitWarm({
-      modelId: "gpt-4o",
-      protocol: "chat_completions",
-      paymentMethod: "clawtip",
-      candidates: [makeCandidate({ sellerId: "s1" })]
-    });
-    expect(cache.get("gpt-4o", "chat_completions", "clawtip")?.warmedAt).toBe(1_000_000);
-
-    fakeNow();
-    fakeNow();
-    const advanced = 1_000_000 + 9 * 60 * 1000; // 9 minutes later, still warm
-    const secondNow = (() => {
-      let t = advanced;
-      return () => t;
-    })();
-    const cache2 = new PrewarmCache({ now: secondNow });
-    cache2.commitWarm({
-      modelId: "gpt-4o",
-      protocol: "chat_completions",
-      paymentMethod: "clawtip",
-      candidates: [makeCandidate({ sellerId: "s1" })]
-    });
-    cache2.commitWarm({
-      modelId: "gpt-4o",
-      protocol: "chat_completions",
-      paymentMethod: "clawtip",
-      candidates: [makeCandidate({ sellerId: "s2" }), makeCandidate({ sellerId: "s3" })]
-    });
-    const entry = cache2.get("gpt-4o", "chat_completions", "clawtip");
-    expect(entry?.warmedAt).toBe(advanced);
-    expect(entry?.state).toBe("warm");
-    expect(entry?.candidates.map((c) => c.sellerId).sort()).toEqual(["s2", "s3"]);
-  });
-
-  test("commitWarm with zero candidates marks the entry as empty", () => {
-    const cache = new PrewarmCache();
-    const result = cache.commitWarm({
-      modelId: "gpt-4o",
-      protocol: "chat_completions",
-      paymentMethod: "clawtip",
-      candidates: []
-    });
-    expect(result.entry.state).toBe("empty");
-    expect(result.entry.candidates).toEqual([]);
-  });
-
-  test("commitWarm treats zero tokens-per-second as unknown", () => {
-    const cache = new PrewarmCache();
-    cache.commitWarm({
-      modelId: "gpt-4o",
-      protocol: "chat_completions",
-      paymentMethod: "clawtip",
-      candidates: [{
-        ...makeCandidate({ sellerId: "s1" }),
-        avgTokensPerSecond: 0
-      }]
-    });
-
-    expect(cache.get("gpt-4o", "chat_completions", "clawtip")?.candidates[0].avgTokensPerSecond).toBeUndefined();
-  });
-
-  test("freshness reports expiringSoon when within the last 10% of TTL", () => {
-    // Use a controllable `now` so we can advance time deterministically.
-    let now = 0;
-    const cache = new PrewarmCache({ now: () => now, defaultTtlMs: 1000 });
-    cache.commitWarm({
-      modelId: "gpt-4o",
-      protocol: "chat_completions",
-      paymentMethod: "clawtip",
-      candidates: [makeCandidate({ sellerId: "s1" })]
-    });
-
-    // At t=0: warmedAt=0, age=0, far from expiry.
-    const fresh = cache.freshness("gpt-4o", "chat_completions", "clawtip");
-    expect(fresh.expired).toBe(false);
-    expect(fresh.expiringSoon).toBe(false);
-    expect(fresh.remainingMs).toBe(1000);
-
-    // At t=850: 150ms left, not in the last 10%.
-    now = 850;
-    const midLife = cache.freshness("gpt-4o", "chat_completions", "clawtip");
-    expect(midLife.expired).toBe(false);
-    expect(midLife.expiringSoon).toBe(false);
-    expect(midLife.remainingMs).toBe(150);
-
-    // At t=950: 50ms left, in the last 10%.
-    now = 950;
-    const nearEnd = cache.freshness("gpt-4o", "chat_completions", "clawtip");
-    expect(nearEnd.expired).toBe(false);
-    expect(nearEnd.expiringSoon).toBe(true);
-    expect(nearEnd.remainingMs).toBe(50);
-
-    // At t=1100: past TTL, expired.
-    now = 1100;
-    const past = cache.freshness("gpt-4o", "chat_completions", "clawtip");
-    expect(past.expired).toBe(true);
-    expect(past.state).toBe("stale");
-  });
-
-  test("recordFailure increments consecutive failures and marks entry stale", () => {
-    const cache = new PrewarmCache();
-    cache.commitWarm({
-      modelId: "gpt-4o",
-      protocol: "chat_completions",
-      paymentMethod: "clawtip",
-      candidates: [makeCandidate({ sellerId: "s1" })]
-    });
-    const first = cache.recordFailure("gpt-4o", "chat_completions", "clawtip", "503");
-    expect(first?.consecutiveWarmingFailures).toBe(1);
-    expect(first?.state).toBe("stale");
-    const second = cache.recordFailure("gpt-4o", "chat_completions", "clawtip");
-    expect(second?.consecutiveWarmingFailures).toBe(2);
-  });
-
-  test("recordFailure is a no-op when the key is unknown", () => {
-    const cache = new PrewarmCache();
-    expect(cache.recordFailure("missing", "chat_completions", "clawtip")).toBeUndefined();
-  });
-
-  test("invalidateSeller drops the seller from every entry", () => {
-    const cache = new PrewarmCache();
-    cache.commitWarm({
-      modelId: "gpt-4o",
-      protocol: "chat_completions",
-      paymentMethod: "clawtip",
-      candidates: [makeCandidate({ sellerId: "s1" }), makeCandidate({ sellerId: "s2" })]
-    });
-    cache.commitWarm({
-      modelId: "claude-sonnet-4-5",
-      protocol: "chat_completions",
-      paymentMethod: "clawtip",
-      candidates: [makeCandidate({ sellerId: "s2" })]
-    });
-
-    const affected = cache.invalidateSeller("s2");
-    expect(affected).toBe(2);
-    const gpt = cache.get("gpt-4o", "chat_completions", "clawtip");
-    expect(gpt?.candidates.map((c) => c.sellerId)).toEqual(["s1"]);
-    const claude = cache.get("claude-sonnet-4-5", "chat_completions", "clawtip");
-    expect(claude?.state).toBe("empty");
-    expect(claude?.candidates).toEqual([]);
-  });
-
-  test("invalidateKey removes a single entry entirely", () => {
-    const cache = new PrewarmCache();
-    cache.commitWarm({
-      modelId: "gpt-4o",
-      protocol: "chat_completions",
-      paymentMethod: "clawtip",
-      candidates: [makeCandidate({ sellerId: "s1" })]
-    });
-    expect(cache.invalidateKey("gpt-4o", "chat_completions", "clawtip")).toBe(true);
-    expect(cache.invalidateKey("gpt-4o", "chat_completions", "clawtip")).toBe(false);
-    expect(cache.size()).toBe(0);
-  });
-
-  test("evictExpired removes only entries past their TTL", () => {
-    // Use a single controllable clock so commit and evict see consistent time.
-    let now = 0;
-    const cache = new PrewarmCache({ now: () => now, defaultTtlMs: 1000 });
-    cache.commitWarm({
-      modelId: "gpt-4o",
-      protocol: "chat_completions",
-      paymentMethod: "clawtip",
-      candidates: [makeCandidate({ sellerId: "s1" })]
-    });
-    cache.commitWarm({
-      modelId: "claude-sonnet-4-5",
-      protocol: "chat_completions",
-      paymentMethod: "clawtip",
-      candidates: [makeCandidate({ sellerId: "s2" })]
-    });
-    // Clock at 0; both fresh.
-    expect(cache.evictExpired()).toBe(0);
-
-    // Advance to t=500; still fresh.
-    now = 500;
-    expect(cache.evictExpired()).toBe(0);
-
-    // Advance to t=1500; both entries now older than TTL=1000.
-    now = 1500;
-    expect(cache.evictExpired()).toBe(2);
-    expect(cache.size()).toBe(0);
-  });
-
-  test("isExpiringSoon returns true only inside the expiry window", () => {
-    const cache = new PrewarmCache({ now: () => 0, defaultTtlMs: 1000 });
-    cache.commitWarm({
-      modelId: "gpt-4o",
-      protocol: "chat_completions",
-      paymentMethod: "clawtip",
-      candidates: [makeCandidate({ sellerId: "s1" })]
-    });
-    // At t=0: warmedAt==0, age==0, not expiring.
-    expect(cache.isExpiringSoon("gpt-4o", "chat_completions", "clawtip", 100, 200)).toBe(false);
-    // At t=850 (150ms left, within 100ms window? no).
-    expect(cache.isExpiringSoon("gpt-4o", "chat_completions", "clawtip", 100, 850)).toBe(false);
-    // At t=950 (50ms left, within 100ms window).
-    expect(cache.isExpiringSoon("gpt-4o", "chat_completions", "clawtip", 100, 950)).toBe(true);
-    // At t=1000 (expired; not in the "soon" window anymore).
-    expect(cache.isExpiringSoon("gpt-4o", "chat_completions", "clawtip", 100, 1000)).toBe(false);
-  });
-
-  test("snapshot returns deep copies that do not mutate cache state", () => {
-    const cache = new PrewarmCache();
-    cache.commitWarm({
-      modelId: "gpt-4o",
-      protocol: "chat_completions",
-      paymentMethod: "clawtip",
-      candidates: [makeCandidate({ sellerId: "s1" })]
-    });
-    const snap = cache.snapshot();
-    snap[0].candidates[0].healthScore = -1;
-    expect(cache.get("gpt-4o", "chat_completions", "clawtip")?.candidates[0].healthScore).not.toBe(-1);
-  });
-
-  test("keys() decodes the cache key back into the model/protocol/payment triple", () => {
-    const cache = new PrewarmCache();
-    cache.commitWarm({
-      modelId: "gpt-4o",
-      protocol: "chat_completions",
-      paymentMethod: "clawtip",
-      candidates: [makeCandidate({ sellerId: "s1" })]
-    });
-    cache.commitWarm({
-      modelId: "claude-sonnet-4-5",
-      protocol: "messages",
-      paymentMethod: "clawtip",
-      candidates: [makeCandidate({ sellerId: "s2" })]
-    });
-    const keys = cache.keys().sort((a, b) => a.modelId.localeCompare(b.modelId));
-    expect(keys).toEqual([
-      { modelId: "claude-sonnet-4-5", protocol: "messages", paymentMethod: "clawtip" },
-      { modelId: "gpt-4o", protocol: "chat_completions", paymentMethod: "clawtip" }
-    ]);
-  });
-
-  test("default TTL is 10 minutes", () => {
-    expect(DEFAULT_PREWARM_TTL_MS).toBe(600_000);
-  });
-});