routstrd 0.4.8 → 0.4.9

package/src/cli.test.ts

@@ -1,192 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import { mkdtempSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from "fs";
-import { tmpdir } from "os";
-import { join } from "path";
-import {
-  collectRecentRequestsFromLines,
-  initializeWallet,
-  parseStructuredLogLine,
-} from "./cli";
-
-const tempDirs: string[] = [];
-
-function makeTempDir(): string {
-  const dir = mkdtempSync(join(tmpdir(), "routstrd-wallet-test-"));
-  tempDirs.push(dir);
-  return dir;
-}
-
-function permissions(path: string): number {
-  return statSync(path).mode & 0o777;
-}
-
-afterEach(() => {
-  for (const dir of tempDirs.splice(0)) {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-describe("parseStructuredLogLine", () => {
-  test("extracts timestamp, level, request id, model, and routing flag", () => {
-    const line =
-      "[2026-08-27T13:00:00.000Z] [INFO] [req:a1b2c3d4] [model:gpt-5] Routing request with path: /v1/chat/completions";
-
-    expect(parseStructuredLogLine(line)).toEqual({
-      timestamp: "2026-08-27T13:00:00.000Z",
-      level: "INFO",
-      requestId: "a1b2c3d4",
-      modelId: "gpt-5",
-      isRouting: true,
-    });
-  });
-
-  test("parses SDK child lines without marking them as routing lines", () => {
-    const line =
-      "[2026-08-27T13:00:01.000Z] [DEBUG] [req:a1b2c3d4] [model:gpt-5] [BalanceManager] token stuff";
-
-    expect(parseStructuredLogLine(line)).toEqual({
-      timestamp: "2026-08-27T13:00:01.000Z",
-      level: "DEBUG",
-      requestId: "a1b2c3d4",
-      modelId: "gpt-5",
-      isRouting: false,
-    });
-  });
-
-  test("handles legacy lines that have a request id but no model tag", () => {
-    const line =
-      "[2026-08-27T13:00:02.000Z] [INFO] [req:deadbeef] Routing request with path: /v1/responses";
-
-    expect(parseStructuredLogLine(line)).toEqual({
-      timestamp: "2026-08-27T13:00:02.000Z",
-      level: "INFO",
-      requestId: "deadbeef",
-      modelId: undefined,
-      isRouting: true,
-    });
-  });
-
-  test("extracts the bare request id from colon-joined legacy child tags", () => {
-    const line =
-      "[2026-08-27T13:00:04.000Z] [INFO] [req:deadbeef:RoutstrClient] [RoutstrClient] generic request pricing input {\"modelId\":\"deepseek-v4-flash-0731\"}";
-
-    const parsed = parseStructuredLogLine(line);
-    expect(parsed.requestId).toBe("deadbeef");
-    expect(parsed.modelId).toBe("deepseek-v4-flash-0731");
-    expect(parsed.isRouting).toBe(false);
-  });
-
-  test("falls back to the JSON modelId when no model tag is present", () => {
-    const line =
-      "[2026-08-27T13:00:05.000Z] [INFO] [req:deadbeef:RoutstrClient] [RoutstrClient] generic request pricing input {\"modelId\":\"deepseek-v4-pro-0813\",\"messageCount\":121}";
-
-    expect(parseStructuredLogLine(line).modelId).toBe("deepseek-v4-pro-0813");
-  });
-
-  test("returns an empty record for plain non-request lines", () => {
-    const line = "[2026-08-27T13:00:03.000Z] [WARN] Some startup message";
-
-    expect(parseStructuredLogLine(line)).toEqual({
-      timestamp: "2026-08-27T13:00:03.000Z",
-      level: "WARN",
-      requestId: undefined,
-      modelId: undefined,
-      isRouting: false,
-    });
-  });
-});
-
-describe("collectRecentRequestsFromLines", () => {
-  const lines = [
-    "[2026-08-27T13:00:00.000Z] [INFO] [req:11111111] [model:gpt-5] Routing request with path: /a",
-    "[2026-08-27T13:00:01.000Z] [DEBUG] [req:11111111] [model:gpt-5] [BalanceManager] token",
-    "[2026-08-27T13:00:02.000Z] [INFO] [req:22222222] [model:claude-sonnet-4.5] Routing request with path: /b",
-    "[2026-08-27T13:00:03.000Z] [DEBUG] [req:22222222] [model:claude-sonnet-4.5] [ModelManager] refresh",
-  ];
-
-  test("returns one record per request, newest first", () => {
-    expect(collectRecentRequestsFromLines(lines, 10)).toEqual([
-      {
-        requestId: "22222222",
-        modelId: "claude-sonnet-4.5",
-        timestamp: "2026-08-27T13:00:02.000Z",
-      },
-      {
-        requestId: "11111111",
-        modelId: "gpt-5",
-        timestamp: "2026-08-27T13:00:00.000Z",
-      },
-    ]);
-  });
-
-  test("respects the limit", () => {
-    expect(collectRecentRequestsFromLines(lines, 1)).toEqual([
-      {
-        requestId: "22222222",
-        modelId: "claude-sonnet-4.5",
-        timestamp: "2026-08-27T13:00:02.000Z",
-      },
-    ]);
-  });
-
-  test("defaults the model to unknown for legacy routing lines", () => {
-    const legacy = [
-      "[2026-08-27T13:00:00.000Z] [INFO] [req:deadbeef] Routing request with path: /a",
-    ];
-
-    expect(collectRecentRequestsFromLines(legacy, 10)).toEqual([
-      {
-        requestId: "deadbeef",
-        modelId: "unknown",
-        timestamp: "2026-08-27T13:00:00.000Z",
-      },
-    ]);
-  });
-
-  test("enriches the model from a sibling pricing line in legacy logs", () => {
-    const legacy = [
-      "[2026-08-27T13:00:00.000Z] [INFO] [req:deadbeef] Routing request with path: /a",
-      "[2026-08-27T13:00:01.000Z] [INFO] [req:deadbeef:RoutstrClient] [RoutstrClient] generic request pricing input {\"modelId\":\"deepseek-v4-flash-0731\"}",
-    ];
-
-    expect(collectRecentRequestsFromLines(legacy, 10)).toEqual([
-      {
-        requestId: "deadbeef",
-        modelId: "deepseek-v4-flash-0731",
-        timestamp: "2026-08-27T13:00:00.000Z",
-      },
-    ]);
-  });
-});
-
-describe("initializeWallet", () => {
-  test("creates the wallet directory and config with restrictive permissions", () => {
-    const walletDir = join(makeTempDir(), "wallet");
-
-    initializeWallet(walletDir);
-
-    const walletConfig = join(walletDir, "config.json");
-    expect(permissions(walletDir)).toBe(0o700);
-    expect(permissions(walletConfig)).toBe(0o600);
-
-    const config = JSON.parse(readFileSync(walletConfig, "utf8"));
-    expect(config.encrypted).toBe(false);
-    expect(typeof config.mnemonic).toBe("string");
-    expect(config.mnemonic.length).toBeGreaterThan(0);
-  });
-
-  test("repairs permissions without replacing an existing wallet", () => {
-    const walletDir = join(makeTempDir(), "wallet");
-    const walletConfig = join(walletDir, "config.json");
-    const existingConfig = JSON.stringify({ mnemonic: "existing seed" });
-
-    mkdirSync(walletDir, { mode: 0o755 });
-    writeFileSync(walletConfig, existingConfig, { mode: 0o644 });
-
-    initializeWallet(walletDir);
-
-    expect(readFileSync(walletConfig, "utf8")).toBe(existingConfig);
-    expect(permissions(walletDir)).toBe(0o700);
-    expect(permissions(walletConfig)).toBe(0o600);
-  });
-});

package/src/daemon/fatal-error.test.ts

@@ -1,104 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import { unlinkSync } from "fs";
-import { tmpdir } from "os";
-import { join } from "path";
-import { exitOnUncaughtException } from "./fatal-error";
-
-const fatalErrorModule = JSON.stringify(join(import.meta.dir, "fatal-error.ts"));
-
-const fixturePaths: string[] = [];
-
-afterEach(() => {
-  while (fixturePaths.length > 0) {
-    try {
-      unlinkSync(fixturePaths.pop()!);
-    } catch {
-      // Best effort cleanup of temp fixtures.
-    }
-  }
-});
-
-/** Run a fixture script in a real subprocess so process.exit is for real. */
-async function runFixture(source: string): Promise<{
-  exitCode: number;
-  stdout: string;
-  stderr: string;
-}> {
-  const scriptPath = join(
-    tmpdir(),
-    `routstrd-fatal-error-fixture-${crypto.randomUUID()}.ts`,
-  );
-  fixturePaths.push(scriptPath);
-  await Bun.write(scriptPath, source);
-  const proc = Bun.spawn(["bun", scriptPath], {
-    stdout: "pipe",
-    stderr: "pipe",
-  });
-  const [stdout, stderr] = await Promise.all([
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text(),
-  ]);
-  const exitCode = await proc.exited;
-  return { exitCode, stdout, stderr };
-}
-
-describe("exitOnUncaughtException", () => {
-  test("reports the error and exits with code 1", () => {
-    let exitCode: number | undefined;
-    const stderrLines: string[] = [];
-    const originalConsoleError = console.error;
-    console.error = (...args: unknown[]) => {
-      stderrLines.push(args.map(String).join(" "));
-    };
-    try {
-      exitOnUncaughtException(new Error("boom"), (code) => {
-        exitCode = code;
-      });
-    } finally {
-      console.error = originalConsoleError;
-    }
-    expect(exitCode).toBe(1);
-    expect(stderrLines.join("\n")).toContain("boom");
-  });
-
-  test("handles non-Error thrown values", () => {
-    let exitCode: number | undefined;
-    const originalConsoleError = console.error;
-    console.error = () => {};
-    try {
-      exitOnUncaughtException("string failure", (code) => {
-        exitCode = code;
-      });
-    } finally {
-      console.error = originalConsoleError;
-    }
-    expect(exitCode).toBe(1);
-  });
-});
-
-describe("installGlobalErrorHandlers (subprocess)", () => {
-  test("an uncaught exception exits the process with code 1", async () => {
-    const { exitCode, stderr } = await runFixture(`
-      import { installGlobalErrorHandlers } from ${fatalErrorModule};
-      installGlobalErrorHandlers();
-      setTimeout(() => {
-        throw new Error("boom-uncaught");
-      }, 10);
-    `);
-    expect(exitCode).toBe(1);
-    expect(stderr).toContain("boom-uncaught");
-  });
-
-  test("an unhandled rejection is logged without exiting", async () => {
-    const { exitCode, stdout } = await runFixture(`
-      import { installGlobalErrorHandlers } from ${fatalErrorModule};
-      installGlobalErrorHandlers();
-      Promise.reject(new Error("boom-rejection"));
-      setTimeout(() => {
-        console.log("STILL-ALIVE");
-      }, 50);
-    `);
-    expect(exitCode).toBe(0);
-    expect(stdout).toContain("STILL-ALIVE");
-  });
-});

package/src/daemon/http/usage-summary.test.ts

@@ -1,272 +0,0 @@
-import { describe, it, expect, beforeEach } from "bun:test";
-import { createMemoryUsageTrackingDriver } from "@routstr/sdk/storage";
-import type { UsageTrackingEntry } from "@routstr/sdk/storage";
-import type { ClientEntry } from "../../utils/clients";
-import { getUsageSummary, __resetUsageSummaryCacheForTest } from "./usage-summary";
-
-// ─── Test fixtures ────────────────────────────────────────────────────────────
-//
-// All timestamps are computed relative to "now" so the fixtures never age
-// out of getUsageSummary's 30-day rolling window. We anchor to a recent UTC
-// midnight ~10 days ago and keep the same hour-of-day structure the
-// tz-bucketing assertions depend on.
-//
-// tz = 300 (UTC-5 / EST). After shifting by -300min, UTC dates become:
-//   d1: <anchor> 10:00Z → local <anchor> 05:00 → local day "<anchor>"
-//   d2: <anchor+1d> 03:00Z → local <anchor> 22:00 → local day "<anchor>"
-//   d3: <anchor+1d> 06:00Z → local <anchor+1d> 01:00 → local day "<anchor+1d>"
-
-const _BASE_UTC_MIDNIGHT = Math.floor(Date.now() / 86_400_000) * 86_400_000;
-const _ANCHOR_MS = _BASE_UTC_MIDNIGHT - 10 * 86_400_000; // 10 days ago UTC
-const D1 = _ANCHOR_MS + 10 * 3_600_000; // 10:00Z → local day <anchor>
-const D2 = _ANCHOR_MS + 1 * 86_400_000 + 3 * 3_600_000; // 03:00Z next day → local day <anchor>
-const D3 = _ANCHOR_MS + 1 * 86_400_000 + 6 * 3_600_000; // 06:00Z next day → local day <anchor+1d>
-
-/** Compute the local-day date string the same way the SDK's day grouping does. */
-function localDayDateStr(ts: number, tzOffsetMinutes: number): string {
-  const d = new Date(ts - tzOffsetMinutes * 60_000);
-  return `${d.getUTCFullYear()}-${String(d.getUTCMonth() + 1).padStart(2, "0")}-${String(d.getUTCDate()).padStart(2, "0")}`;
-}
-
-const BASE_ENTRY: Omit<UsageTrackingEntry, "id" | "timestamp" | "modelId" | "client" | "totalTokens"> = {
-  baseUrl: "https://api.openai.com/",
-  requestId: "req-1",
-  cost: 0.01,
-  satsCost: 10,
-  promptTokens: 100,
-  completionTokens: 50,
-};
-
-function makeEntry(
-  id: string,
-  overrides: Partial<UsageTrackingEntry> & Pick<UsageTrackingEntry, "id" | "timestamp" | "modelId" | "totalTokens">,
-): UsageTrackingEntry {
-  return {
-    ...BASE_ENTRY,
-    ...overrides,
-    id,
-  };
-}
-
-// Seed entries:
-// - 2 entries for model-a, client-1 (owned by npub1)
-// - 1 entry for model-b, client-2 (no npub)
-// - 1 entry for model-a, no client (null client)
-// - totalTokens spread across tiny (< 1000) and small (1000-10000) buckets
-
-const ENTRIES: UsageTrackingEntry[] = [
-  // model-a, client-1, day 2026-05-20 (D1), totalTokens=500 (tiny)
-  makeEntry("e1", {
-    id: "e1",
-    timestamp: D1,
-    modelId: "model-a",
-    client: "client-1",
-    totalTokens: 500,
-    promptTokens: 350,
-    completionTokens: 150,
-    satsCost: 10,
-    cost: 0.01,
-  }),
-  // model-a, client-1, day 2026-05-20 (D2), totalTokens=2000 (small)
-  makeEntry("e2", {
-    id: "e2",
-    timestamp: D2,
-    modelId: "model-a",
-    client: "client-1",
-    totalTokens: 2000,
-    promptTokens: 1400,
-    completionTokens: 600,
-    satsCost: 20,
-    cost: 0.02,
-  }),
-  // model-b, client-2, day 2026-05-21 (D3), totalTokens=800 (tiny)
-  makeEntry("e3", {
-    id: "e3",
-    timestamp: D3,
-    modelId: "model-b",
-    client: "client-2",
-    totalTokens: 800,
-    promptTokens: 600,
-    completionTokens: 200,
-    satsCost: 8,
-    cost: 0.008,
-  }),
-  // model-a, no client, day 2026-05-21 (D3), totalTokens=5000 (small)
-  makeEntry("e4", {
-    id: "e4",
-    timestamp: D3 + 1000,
-    modelId: "model-a",
-    client: undefined,
-    totalTokens: 5000,
-    promptTokens: 3500,
-    completionTokens: 1500,
-    satsCost: 50,
-    cost: 0.05,
-  }),
-];
-
-const CLIENTS: ClientEntry[] = [
-  {
-    clientId: "client-1",
-    name: "Client One",
-    apiKey: "sk-client1",
-    createdAt: D1 - 86400000,
-    ownerNpub: "npub1abc",
-  },
-  {
-    clientId: "client-2",
-    name: "Client Two",
-    apiKey: "sk-client2",
-    createdAt: D1 - 86400000,
-    // no ownerNpub
-  },
-];
-
-const TZ = 300; // UTC-5 / EST
-
-describe("getUsageSummary", () => {
-  let driver: ReturnType<typeof createMemoryUsageTrackingDriver>;
-
-  beforeEach(async () => {
-    // Reset the module-level memo cache explicitly so each test starts cold.
-    // Without this, tests 2-10 would share the cached object from test 1
-    // (all use the same fixtures → identical cache key → same TTL window).
-    __resetUsageSummaryCacheForTest();
-    driver = createMemoryUsageTrackingDriver(ENTRIES);
-  });
-
-  it("returns correct totals", async () => {
-    const summary = await getUsageSummary(driver, CLIENTS, TZ);
-
-    expect(summary.totals.requests).toBe(4);
-    expect(summary.totals.totalTokens).toBe(500 + 2000 + 800 + 5000);
-    expect(summary.totals.promptTokens).toBe(350 + 1400 + 600 + 3500);
-    expect(summary.totals.completionTokens).toBe(150 + 600 + 200 + 1500);
-    expect(summary.totals.satsCost).toBe(10 + 20 + 8 + 50);
-    expect(summary.totals.cost).toBeCloseTo(0.01 + 0.02 + 0.008 + 0.05, 5);
-  });
-
-  it("returns models sorted desc by satsCost", async () => {
-    const summary = await getUsageSummary(driver, CLIENTS, TZ);
-    const { models } = summary;
-
-    // model-a: 3 entries (e1, e2, e4) total satsCost = 10+20+50 = 80
-    // model-b: 1 entry (e3) satsCost = 8
-    expect(models).toHaveLength(2);
-    expect(models[0]!.modelId).toBe("model-a");
-    expect(models[0]!.satsCost).toBe(80);
-    expect(models[0]!.requests).toBe(3);
-    expect(models[1]!.modelId).toBe("model-b");
-    expect(models[1]!.satsCost).toBe(8);
-  });
-
-  it("returns days most-recent-first with correct tz-bucketing", async () => {
-    const summary = await getUsageSummary(driver, CLIENTS, TZ);
-    const { days } = summary;
-
-    // D1 (10:00Z) and D2 (next day 03:00Z) both bucket to local day <anchor>;
-    // D3 (next day 06:00Z) buckets to local day <anchor+1d>.
-    // So: day <anchor> has e1+e2, day <anchor+1d> has e3+e4
-    expect(days.length).toBeGreaterThanOrEqual(2);
-
-    // Most-recent-first: <anchor+1d> first
-    expect(days[0]!.date).toBe(localDayDateStr(D3, TZ));
-    expect(days[0]!.requests).toBe(2); // e3, e4
-    expect(days[0]!.satsCost).toBe(8 + 50);
-
-    expect(days[1]!.date).toBe(localDayDateStr(D1, TZ));
-    expect(days[1]!.requests).toBe(2); // e1, e2
-    expect(days[1]!.satsCost).toBe(10 + 20);
-  });
-
-  it("returns empty hoursToday (test entries are not today)", async () => {
-    const summary = await getUsageSummary(driver, CLIENTS, TZ);
-    // Test entries are ~10 days ago, not today
-    expect(summary.hoursToday).toHaveLength(0);
-  });
-
-  it("returns correct sizeBuckets", async () => {
-    const summary = await getUsageSummary(driver, CLIENTS, TZ);
-    const { sizeBuckets } = summary;
-
-    // tiny [0, 1000): e1 (500) + e3 (800) = 2 entries
-    expect(sizeBuckets.tiny.count).toBe(2);
-    expect(sizeBuckets.tiny.cost).toBe(10 + 8);
-
-    // small [1000, 10000): e2 (2000) + e4 (5000) = 2 entries
-    expect(sizeBuckets.small.count).toBe(2);
-    expect(sizeBuckets.small.cost).toBe(20 + 50);
-
-    // medium, large, huge should be 0
-    expect(sizeBuckets.medium.count).toBe(0);
-    expect(sizeBuckets.large.count).toBe(0);
-    expect(sizeBuckets.huge.count).toBe(0);
-  });
-
-  it("returns per-client topModels for top non-null clients", async () => {
-    const summary = await getUsageSummary(driver, CLIENTS, TZ);
-    const { clients } = summary;
-
-    // client-1: e1 + e2 (model-a), satsCost = 30
-    // client-2: e3 (model-b), satsCost = 8
-    // unknown (null client): e4 (model-a), satsCost = 50
-    // Sorted desc by satsCost: unknown (50), client-1 (30), client-2 (8)
-
-    const c1 = clients.find((c) => c.client === "client-1");
-    expect(c1).toBeDefined();
-    expect(c1!.requests).toBe(2);
-    expect(c1!.satsCost).toBe(30);
-    // client-1 is in top 3 non-null clients, should have topModels
-    expect(c1!.topModels.length).toBeGreaterThan(0);
-    expect(c1!.topModels[0]!.modelId).toBe("model-a");
-
-    const c2 = clients.find((c) => c.client === "client-2");
-    expect(c2).toBeDefined();
-    expect(c2!.requests).toBe(1);
-    expect(c2!.satsCost).toBe(8);
-
-    // unknown client (null group) should have empty topModels
-    const unknown = clients.find((c) => c.client === "unknown");
-    expect(unknown).toBeDefined();
-    expect(unknown!.topModels).toHaveLength(0);
-  });
-
-  it("folds client rows into npubs correctly", async () => {
-    const summary = await getUsageSummary(driver, CLIENTS, TZ);
-    const { npubs } = summary;
-
-    // Only client-1 has ownerNpub = "npub1abc"
-    // npub1abc: e1 + e2 = requests 2, satsCost 30
-    expect(npubs).toHaveLength(1);
-    expect(npubs[0]!.npub).toBe("npub1abc");
-    expect(npubs[0]!.requests).toBe(2);
-    expect(npubs[0]!.satsCost).toBe(30);
-    // Top models for npub1abc (clients: ["client-1"]): only model-a
-    expect(npubs[0]!.topModels.length).toBeGreaterThan(0);
-    expect(npubs[0]!.topModels[0]!.modelId).toBe("model-a");
-  });
-
-  it("returns recent entries (up to 50)", async () => {
-    const summary = await getUsageSummary(driver, CLIENTS, TZ);
-    expect(summary.recent).toHaveLength(4); // only 4 entries in driver
-    // Should be sorted desc by timestamp
-    expect(summary.recent[0]!.timestamp).toBeGreaterThanOrEqual(summary.recent[1]!.timestamp);
-  });
-
-  it("returns providers correctly", async () => {
-    const summary = await getUsageSummary(driver, CLIENTS, TZ);
-    const { providers } = summary;
-
-    // All entries use the same baseUrl
-    expect(providers).toHaveLength(1);
-    expect(providers[0]!.baseUrl).toBe("https://api.openai.com/");
-    expect(providers[0]!.requests).toBe(4);
-  });
-
-  it("caches results for same key within TTL", async () => {
-    const summary1 = await getUsageSummary(driver, CLIENTS, TZ);
-    const summary2 = await getUsageSummary(driver, CLIENTS, TZ);
-    // Same object reference means it was served from cache
-    expect(summary1).toBe(summary2);
-  });
-});

package/src/daemon/models.test.ts

@@ -1,81 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import type { SdkStore } from "@routstr/sdk";
-import { createModelService } from "./models";
-
-/**
- * `ensureProvidersBootstrapped` must mirror the review-disabled provider set
- * (kind 38425) into the SdkStore. The SDK applies review disables to the
- * discovery adapter during bootstrap, but `providers list` and per-model
- * provider views read the store — if the store is not kept in sync, a fresh
- * install reports "0 disabled" while routing silently excludes them.
- */
-describe("createModelService.ensureProvidersBootstrapped", () => {
-  function makeStore(initialBaseUrls: string[] = []) {
-    const disabledCalls: string[][] = [];
-    const state: Record<string, unknown> = {
-      baseUrlsList: initialBaseUrls,
-      setBaseUrlsList: (urls: string[]) => {
-        state.baseUrlsList = urls;
-      },
-      disabledProviders: [],
-      setDisabledProviders: (urls: string[]) => {
-        state.disabledProviders = urls;
-        disabledCalls.push(urls);
-      },
-      manuallyDisabledProviders: [],
-      manuallyEnabledProviders: [],
-    };
-
-    return {
-      store: { getState: () => state } as unknown as SdkStore,
-      state,
-      disabledCalls,
-    };
-  }
-
-  function makeModelManager(
-    providers: string[],
-    reviewedDisabled: string[] | null,
-  ) {
-    return {
-      bootstrapProviders: async () => providers,
-      syncReviewedProvidersFromNostr: async () => reviewedDisabled,
-    } as never;
-  }
-
-  it("mirrors review-disabled providers into the store after bootstrap", async () => {
-    const { store, state, disabledCalls } = makeStore();
-    const modelManager = makeModelManager(
-      ["https://ok.example/", "https://bad.example/"],
-      ["https://bad.example/"],
-    );
-    const service = createModelService(
-      modelManager as never,
-      {} as never,
-      store,
-    );
-
-    await service.ensureProvidersBootstrapped();
-
-    expect(disabledCalls).toEqual([["https://bad.example/"]]);
-    expect(state.disabledProviders).toEqual(["https://bad.example/"]);
-  });
-
-  it("leaves the store unchanged when review sync reports no change (null)", async () => {
-    const { store, state, disabledCalls } = makeStore(["https://ok.example/"]);
-    const modelManager = makeModelManager(
-      ["https://ok.example/", "https://new.example/"],
-      null,
-    );
-    const service = createModelService(
-      modelManager as never,
-      {} as never,
-      store,
-    );
-
-    await service.ensureProvidersBootstrapped();
-
-    expect(disabledCalls).toEqual([]);
-    expect(state.disabledProviders).toEqual([]);
-  });
-});