auto-model-router 0.31.0 → 0.32.0

package/test/redaction.test.ts

@@ -1,16 +1,18 @@
 import { describe, expect, test } from "bun:test";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
+import { openSqlDb } from "../src/util/sql.ts";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+
 import { DEFAULT_CONFIG } from "../src/config/defaults.ts";
 import { loadConfig } from "../src/config/load.ts";
 import { compileRedactionRules, redactionRulesFor, validateRedactionPattern, validateRedactionRule } from "../src/config/redaction.ts";
-import { createLedger } from "../src/cost/ledger.ts";
 import { buildUsageReport, renderUsageReport } from "../src/cost/report.ts";
+import { createSqlLedger } from "../src/cost/ledger-sql.ts";
+import { migrateStore } from "../src/util/schema.ts";
 import { EMPTY_USAGE, type LedgerEntry } from "../src/cost/types.ts";
 import { redactUpstreamBody } from "../src/server/redact.ts";
-import { openDb } from "../src/util/sqlite.ts";
 import { parseMessagesRequest } from "../src/wire/anthropic/messages.ts";
 import { parseChatRequest } from "../src/wire/openai/request.ts";
 import { parseResponsesRequest } from "../src/wire/openai/responses.ts";
@@ -27,7 +29,7 @@ function rules(...specs: { name: string; pattern: string; replacement?: string }
 }
 
 describe("pattern guard", () => {
-	test("the shapes a real rule uses all compile", () => {
+	test("the shapes a real rule uses all compile", async () => {
 		for (const pattern of [
 			"sk-live-[a-z0-9]{16,}",
 			"AKIA[0-9A-Z]{16}",
@@ -40,7 +42,7 @@ describe("pattern guard", () => {
 		}
 	});
 
-	test("a pattern that can backtrack catastrophically is refused, with the reason", () => {
+	test("a pattern that can backtrack catastrophically is refused, with the reason", async () => {
 		const nested = validateRedactionPattern("(a+)+$");
 		expect(nested).toContain("nested unbounded quantifiers");
 		expect(nested).toContain("exponential");
@@ -54,14 +56,14 @@ describe("pattern guard", () => {
 		expect(validateRedactionPattern("(?<k>x)\\k<k>")).toContain("backreferences");
 	});
 
-	test("a pattern that cannot compile, is empty, matches nothing, or is enormous is refused", () => {
+	test("a pattern that cannot compile, is empty, matches nothing, or is enormous is refused", async () => {
 		expect(validateRedactionPattern("(unclosed")).toContain("does not compile");
 		expect(validateRedactionPattern("")).toBe("pattern must not be empty");
 		expect(validateRedactionPattern("x*")).toContain("matches the empty string");
 		expect(validateRedactionPattern(`a${"b".repeat(600)}`)).toContain("the limit is 512");
 	});
 
-	test("a legacy pattern the unicode flag alone rejects still loads", () => {
+	test("a legacy pattern the unicode flag alone rejects still loads", async () => {
 		// `\d{1,2}` is fine either way; an unescaped `{` is a syntax error under
 		// `u` and a literal brace without it. An operator's working rule must not
 		// break on an upgrade, so `u` is preferred, not required.
@@ -70,19 +72,19 @@ describe("pattern guard", () => {
 		expect(rules({ name: "unicode", pattern: "sk-[a-z0-9]+" })[0]!.regex.flags).toBe("gu");
 	});
 
-	test("a rule name is checked too, since it is echoed into the prompt", () => {
+	test("a rule name is checked too, since it is echoed into the prompt", async () => {
 		expect(validateRedactionRule({ name: "api key", pattern: "sk-\\w+" })).toBeNull();
 		expect(validateRedactionRule({ name: "", pattern: "sk-\\w+" })).toContain("name must be");
 		expect(validateRedactionRule({ name: "[redacted]\ninjected", pattern: "sk-\\w+" })).toContain("name must be");
 	});
 
-	test("compiling a rule set names the offending rule and refuses the whole set", () => {
+	test("compiling a rule set names the offending rule and refuses the whole set", async () => {
 		expect(() => rules({ name: "ok", pattern: "sk-\\w+" }, { name: "greedy", pattern: "(x+)+" })).toThrow(
 			/redaction rule "greedy": nested unbounded quantifiers/,
 		);
 	});
 
-	test("the config file rejects a backtracking rule at load, naming its path", () => {
+	test("the config file rejects a backtracking rule at load, naming its path", async () => {
 		const dir = mkdtempSync(join(tmpdir(), "amr-redact-"));
 		try {
 			const path = join(dir, "config.yml");
@@ -99,7 +101,7 @@ describe("pattern guard", () => {
 		}
 	});
 
-	test("compiled rules are memoised on the rule text, and off means none", () => {
+	test("compiled rules are memoised on the rule text, and off means none", async () => {
 		const cfg = { enabled: true, rules: [{ name: "key", pattern: "sk-\\w+" }], scanTools: false };
 		expect(redactionRulesFor(cfg)).toBe(redactionRulesFor({ ...cfg, rules: [{ name: "key", pattern: "sk-\\w+" }] }));
 		expect(redactionRulesFor({ ...cfg, enabled: false })).toEqual([]);
@@ -112,19 +114,19 @@ describe("pattern guard", () => {
 describe("each rule shape", () => {
 	const body = () => ({ messages: [{ role: "user", content: `token ${SECRET} and 10.1.2.3` }] });
 
-	test("a rule with no replacement redacts to [redacted:<name>]", () => {
+	test("a rule with no replacement redacts to [redacted:<name>]", async () => {
 		const b = body();
 		expect(redactUpstreamBody(b, rules({ name: "api key", pattern: "sk-live-[a-z0-9]+" }), { scanTools: false })).toBe(1);
 		expect(b.messages[0]!.content).toBe("token [redacted:api key] and 10.1.2.3");
 	});
 
-	test("a rule with a replacement uses it", () => {
+	test("a rule with a replacement uses it", async () => {
 		const b = body();
 		redactUpstreamBody(b, rules({ name: "ip", pattern: "(?:\\d{1,3}\\.){3}\\d{1,3}", replacement: "0.0.0.0" }), { scanTools: false });
 		expect(b.messages[0]!.content).toBe(`token ${SECRET} and 0.0.0.0`);
 	});
 
-	test("several rules all apply, and every match counts", () => {
+	test("several rules all apply, and every match counts", async () => {
 		const b = { messages: [{ role: "user", content: `${SECRET} ${SECRET} 10.1.2.3` }] };
 		const n = redactUpstreamBody(
 			b,
@@ -135,7 +137,7 @@ describe("each rule shape", () => {
 		expect(b.messages[0]!.content).toBe("[redacted:key] [redacted:key] [redacted:ip]");
 	});
 
-	test("nothing to match leaves the body untouched and counts zero", () => {
+	test("nothing to match leaves the body untouched and counts zero", async () => {
 		const b = { messages: [{ role: "user", content: "nothing secret here" }] };
 		expect(redactUpstreamBody(b, rules({ name: "key", pattern: "sk-live-[a-z0-9]+" }), { scanTools: false })).toBe(0);
 		expect(b.messages[0]!.content).toBe("nothing secret here");
@@ -157,7 +159,7 @@ describe("what the walker reaches", () => {
 		};
 	}
 
-	test("message text is redacted; tool arguments and tool results wait for scanTools", () => {
+	test("message text is redacted; tool arguments and tool results wait for scanTools", async () => {
 		const b = fullBody();
 		expect(redactUpstreamBody(b, KEY, { scanTools: false })).toBe(2);
 		const messages = b.messages as Record<string, unknown>[];
@@ -171,7 +173,7 @@ describe("what the walker reaches", () => {
 		expect(b.model).toBe("sk-live-notreally/model");
 	});
 
-	test("with scanTools, arguments and results go too and nothing else changes", () => {
+	test("with scanTools, arguments and results go too and nothing else changes", async () => {
 		const b = fullBody();
 		expect(redactUpstreamBody(b, KEY, { scanTools: true })).toBe(4);
 		const messages = b.messages as Record<string, unknown>[];
@@ -184,7 +186,7 @@ describe("what the walker reaches", () => {
 		expect(messages[3]!.tool_call_id).toBe("c1");
 	});
 
-	test("no rules is a no-op, and a body without messages is ignored", () => {
+	test("no rules is a no-op, and a body without messages is ignored", async () => {
 		const b = fullBody();
 		expect(redactUpstreamBody(b, [], { scanTools: true })).toBe(0);
 		expect(JSON.stringify(b)).toContain(SECRET);
@@ -204,7 +206,7 @@ describe("every wire renders into the shape redaction reads", () => {
 		stripAssistantReasoning: false,
 	};
 
-	test("chat completions, Responses and Anthropic Messages all lose the secret", () => {
+	test("chat completions, Responses and Anthropic Messages all lose the secret", async () => {
 		const chat = parseChatRequest(
 			{ model: "auto", messages: [{ role: "system", content: `rules ${SECRET}` }, { role: "user", content: `use ${SECRET}` }] },
 			new Headers(),
@@ -265,36 +267,40 @@ describe("the ledger keeps the count and never the match", () => {
 		};
 	}
 
-	test("the column round-trips, absent stays absent, and the report totals it", () => {
-		const db = openDb(":memory:");
+	test("the column round-trips, absent stays absent, and the report totals it", async () => {
+		const path = join(tmpdir(), `redaction-${process.pid}-${Date.now()}.db`);
+		const db = openSqlDb(path);
 		try {
-			const ledger = createLedger(db, { ...DEFAULT_CONFIG, ledger: { ...DEFAULT_CONFIG.ledger, path: ":memory:" } });
+			await migrateStore(db);
+			const ledger = createSqlLedger(db, { ...DEFAULT_CONFIG, ledger: { ...DEFAULT_CONFIG.ledger, path } }, { findModel: () => null });
 			const now = Date.now();
-			ledger.record(entry({ createdAtMs: now - 3, redactions: 3 }));
-			ledger.record(entry({ createdAtMs: now - 2, redactions: 0 }));
-			ledger.record(entry({ createdAtMs: now - 1 })); // redaction off: NULL, which is not 0
-			const recorded = ledger.recentEntries(10);
+			await ledger.record(entry({ createdAtMs: now - 3, redactions: 3 }));
+			await ledger.record(entry({ createdAtMs: now - 2, redactions: 0 }));
+			await ledger.record(entry({ createdAtMs: now - 1 })); // redaction off: NULL, which is not 0
+			const recorded = await ledger.recentEntries(10);
 			expect(recorded.map((e) => e.redactions)).toEqual([undefined, 0, 3]);
-			const totals = buildUsageReport(db, { windowDays: 7 }).totals;
+			const totals = (await buildUsageReport(db, { windowDays: 7 })).totals;
 			expect(totals.redactions).toBe(3);
 			expect(totals.redactedTurns).toBe(1);
-			expect(renderUsageReport(buildUsageReport(db, { windowDays: 7 }))).toContain("redaction: 1 turns had something removed (3 strings)");
+			expect(renderUsageReport(await buildUsageReport(db, { windowDays: 7 }))).toContain("redaction: 1 turns had something removed (3 strings)");
 		} finally {
-			db.close();
+			await db.close();
 		}
 	});
 
-	test("a window with no redaction says nothing about it", () => {
-		const db = openDb(":memory:");
+	test("a window with no redaction says nothing about it", async () => {
+		const path = join(tmpdir(), `redaction-none-${process.pid}-${Date.now()}.db`);
+		const db = openSqlDb(path);
 		try {
-			const ledger = createLedger(db, { ...DEFAULT_CONFIG, ledger: { ...DEFAULT_CONFIG.ledger, path: ":memory:" } });
-			ledger.record(entry({}));
-			const report = buildUsageReport(db, { windowDays: 7 });
+			await migrateStore(db);
+			const ledger = createSqlLedger(db, { ...DEFAULT_CONFIG, ledger: { ...DEFAULT_CONFIG.ledger, path } }, { findModel: () => null });
+			await ledger.record(entry({}));
+			const report = await buildUsageReport(db, { windowDays: 7 });
 			expect(report.totals.redactions).toBe(0);
 			expect(report.totals.redactedTurns).toBe(0);
 			expect(renderUsageReport(report)).not.toContain("redaction:");
 		} finally {
-			db.close();
+			await db.close();
 		}
 	});
 });

package/test/remote.test.ts

@@ -18,7 +18,7 @@ import { hasRefresh, refreshAccountOf } from "../omp-extension/remote-logic.ts";
  */
 
 describe("remote-logic", () => {
-	test("remote.json is parsed defensively and turned into omp's provider registration", () => {
+	test("remote.json is parsed defensively and turned into omp's provider registration", async () => {
 		expect(parseRemoteRouter("nope")).toBeNull();
 		expect(parseRemoteRouter(JSON.stringify({ url: "https://t/", key: "" }))).toBeNull();
 		const t = parseRemoteRouter(JSON.stringify({ url: "https://team.example/", key: "amrt_k", userId: "u_1", name: "Ada" }))!;
@@ -44,7 +44,7 @@ describe("remote-logic", () => {
 		rmSync(dir, { recursive: true, force: true });
 	});
 
-	test("text edits keep files byte-identical apart from the lines they add", () => {
+	test("text edits keep files byte-identical apart from the lines they add", async () => {
 		expect(addExtensions("", ["/a.ts"])).toBe("extensions:\n  - /a.ts\n");
 		expect(addExtensions("foo: 1\nextensions:\n  - /x.ts\nbar: 2\n", ["/x.ts", "/a.ts"])).toBe("foo: 1\nextensions:\n  - /a.ts\n  - /x.ts\nbar: 2\n");
 		expect(addExtensions("foo: 1\r\n", ["/a.ts"])).toBe("foo: 1\r\nextensions:\r\n  - /a.ts\r\n");
@@ -68,7 +68,7 @@ describe("connect", () => {
 		return { home, o };
 	}
 
-	test("writes remote.json and configures omp, Hermes, Codex, Aider and Claude Code idempotently", () => {
+	test("writes remote.json and configures omp, Hermes, Codex, Aider and Claude Code idempotently", async () => {
 		const { home, o } = scenario();
 		const r1 = connectRemote(o);
 		expect(existsSync(r1.remoteFile)).toBe(true);
@@ -93,7 +93,7 @@ describe("connect", () => {
 		rmSync(home, { recursive: true, force: true });
 	});
 
-	test("--harness restricts, --dry-run writes nothing, --profile appends once to the shell rc", () => {
+	test("--harness restricts, --dry-run writes nothing, --profile appends once to the shell rc", async () => {
 		const { home, o } = scenario({ only: ["omp"], dryRun: true });
 		const r = connectRemote(o);
 		expect(existsSync(r.remoteFile)).toBe(false);
@@ -118,7 +118,7 @@ describe("omp models.yml for a remote router", () => {
 	const NL = String.fromCharCode(10);
 	const yaml = (...lines: string[]): string => lines.join(NL) + NL;
 
-	test("the block names the remote, the key and the three virtual models; the scope follows the workspace unless pinned", () => {
+	test("the block names the remote, the key and the three virtual models; the scope follows the workspace unless pinned", async () => {
 		const block = renderRemoteModelsYml("https://team.example/", "amrt_k", BLEND);
 		expect(block).toContain("baseUrl: https://team.example/v1");
 		expect(block).toContain("apiKey: amrt_k");
@@ -141,7 +141,7 @@ describe("omp models.yml for a remote router", () => {
 		expect(pinned).toContain(`X-Agentdox-Origin: ${ORIGIN_ENV}`);
 	});
 
-	test("merging keeps other providers, replaces our own block, and is idempotent", () => {
+	test("merging keeps other providers, replaces our own block, and is idempotent", async () => {
 		const block = renderRemoteModelsYml("https://team.example", "k1", BLEND);
 		const empty = mergeModelsYml("", block);
 		expect(empty.startsWith("providers:")).toBe(true);
@@ -160,7 +160,7 @@ describe("omp models.yml for a remote router", () => {
 		expect(rekeyed).toContain("openai:");
 	});
 
-	test("a hand-written provider of the same name is left alone", () => {
+	test("a hand-written provider of the same name is left alone", async () => {
 		expect(hasForeignRouterProvider(yaml("providers:", "  auto-model-router:", "    baseUrl: http://127.0.0.1:1/v1"))).toBe(true);
 		expect(hasForeignRouterProvider(mergeModelsYml("", renderRemoteModelsYml("https://t", "k", BLEND)))).toBe(false);
 		expect(hasForeignRouterProvider(yaml("providers:", "  openai: {}"))).toBe(false);
@@ -171,7 +171,7 @@ describe("short-lived remote credentials", () => {
 	const NL = String.fromCharCode(10);
 	const remote = { url: "https://team.example", key: "amrt_old", userId: "u_ada", name: "Ada", joinedAtMs: 1, refreshToken: "amrr_r1", keyExpiresAtMs: 0, refreshExpiresAtMs: 0, device: "laptop" };
 
-	test("remote.json round-trips the credential fields, and a permanent key has none", () => {
+	test("remote.json round-trips the credential fields, and a permanent key has none", async () => {
 		const parsed = parseRemoteRouter(JSON.stringify(remote))!;
 		expect(parsed).toMatchObject({ refreshToken: "amrr_r1", keyExpiresAtMs: 0, refreshExpiresAtMs: 0, device: "laptop" });
 		const permanent = parseRemoteRouter(JSON.stringify({ url: "https://t", key: "k" }))!;
@@ -179,7 +179,7 @@ describe("short-lived remote credentials", () => {
 		expect(shouldRefresh(permanent)).toBe(false);
 	});
 
-	test("a key is refreshed a day ahead of expiry, never without a refresh token", () => {
+	test("a key is refreshed a day ahead of expiry, never without a refresh token", async () => {
 		const now = 1_000_000_000_000;
 		const day = 24 * 3_600_000;
 		expect(shouldRefresh({ ...remote, keyExpiresAtMs: now + 3 * day }, now)).toBe(false);
@@ -206,7 +206,7 @@ describe("short-lived remote credentials", () => {
 		}
 		expect(err?.code).toBe("refresh_reused");
 		expect(err?.message).toBe("already used");
-		await expect(refreshCredential({ ...remote, refreshToken: "" }, ok)).rejects.toBeInstanceOf(RefreshError);
+		(await expect(refreshCredential({ ...remote, refreshToken: "" }, ok))).rejects.toBeInstanceOf(RefreshError);
 	});
 
 	test("refreshAndRewrite re-writes remote.json and the managed models.yml block, keeping its scope and join time", async () => {
@@ -252,7 +252,7 @@ describe("the refresh token lives in the OS credential store", () => {
 	const vault = new Map<string, string>();
 	const backend = { save: (a: string, s: string) => void vault.set(a, s), load: (a: string) => vault.get(a) ?? null, remove: (a: string) => void vault.delete(a) };
 
-	test("the store is picked from the platform and its tools; the file is the fallback everywhere", () => {
+	test("the store is picked from the platform and its tools; the file is the fallback everywhere", async () => {
 		expect(pickStore("win32", (b) => b === "powershell")).toBe("dpapi");
 		expect(pickStore("win32", () => false)).toBe("file");
 		expect(pickStore("darwin", (b) => b === "security")).toBe("keychain");
@@ -261,7 +261,7 @@ describe("the refresh token lives in the OS credential store", () => {
 		expect(refreshAccountOf("https://team.example:8790/", "u_ada")).toBe("u_ada@team.example:8790");
 	});
 
-	test("save/load through a store, and the file fallback keeps the token owner-readable", () => {
+	test("save/load through a store, and the file fallback keeps the token owner-readable", async () => {
 		const home = mkdtempSync(join(tmpdir(), "amr-store-"));
 		try {
 			expect(saveRefreshToken(home, "u@t", "amrr_x", "keychain", { backend })).toBe("keychain");

package/test/report-logic.test.ts

@@ -3,11 +3,11 @@ import { describe, expect, test } from "bun:test";
 import { fetchReport, parseReportArgs, renderSoftFailureSpikes, renderStatus, type HealthSnapshot } from "../omp-extension/report-logic.ts";
 
 describe("parseReportArgs", () => {
-	test("defaults to 7 days scoped to the harness", () => {
+	test("defaults to 7 days scoped to the harness", async () => {
 		expect(parseReportArgs("", "omp")).toEqual({ windowDays: 7, harnessId: "omp" });
 	});
 
-	test("accepts bare numbers and d/h/w suffixes", () => {
+	test("accepts bare numbers and d/h/w suffixes", async () => {
 		expect(parseReportArgs("30", "")).toEqual({ windowDays: 30, harnessId: "" });
 		expect(parseReportArgs("14d", "")).toEqual({ windowDays: 14, harnessId: "" });
 		expect(parseReportArgs("24h", "")).toEqual({ windowDays: 1, harnessId: "" });
@@ -15,12 +15,12 @@ describe("parseReportArgs", () => {
 		expect(parseReportArgs("2w", "")).toEqual({ windowDays: 14, harnessId: "" });
 	});
 
-	test("--all drops the harness scope and --harness= sets one", () => {
+	test("--all drops the harness scope and --harness= sets one", async () => {
 		expect(parseReportArgs("7d --all", "omp").harnessId).toBe("");
 		expect(parseReportArgs("--harness=hermes", "omp").harnessId).toBe("hermes");
 	});
 
-	test("ignores junk and clamps the window", () => {
+	test("ignores junk and clamps the window", async () => {
 		expect(parseReportArgs("bogus 0 -3", "x")).toEqual({ windowDays: 7, harnessId: "x" });
 		expect(parseReportArgs("9999", "").windowDays).toBe(365);
 	});
@@ -45,13 +45,13 @@ describe("fetchReport", () => {
 			seen.push(url);
 			return new Response("nope", { status: 503 });
 		};
-		await expect(fetchReport("http://h", { windowDays: 7, harnessId: "" }, {}, fake)).rejects.toThrow("503");
+		(await expect(fetchReport("http://h", { windowDays: 7, harnessId: "" }, {}, fake))).rejects.toThrow("503");
 		expect(seen).toEqual(["http://h/v1/router/report?days=7"]);
 	});
 });
 
 describe("renderStatus", () => {
-	test("summarises keys, catalog, ollama and agentdox", () => {
+	test("summarises keys, catalog, ollama and agentdox", async () => {
 		const now = 1_000_000_000;
 		const h: HealthSnapshot = {
 			status: "ok",
@@ -89,14 +89,14 @@ describe("renderStatus", () => {
 		expect(text).toContain("recording turns");
 	});
 
-	test("reports a quiet hour and omits the line for routers that predate the check", () => {
+	test("reports a quiet hour and omits the line for routers that predate the check", async () => {
 		expect(renderStatus("http://h", { status: "ok", softFailures: { spikes: [] } })).toContain("soft failures: no model spiking in the last hour");
 		expect(renderStatus("http://h", { status: "ok" })).not.toContain("soft failures");
 		expect(renderSoftFailureSpikes(null)).toEqual([]);
 		expect(renderSoftFailureSpikes([{ slug: "a/b", recentRate: 0.5, recentDispatches: 6 }], 30 * 60_000, 7)).toEqual(["a/b: 50% of 6 failed in the last 30m (7d baseline 0% of 0)"]);
 	});
 
-	test("degrades cleanly when sections are absent", () => {
+	test("degrades cleanly when sections are absent", async () => {
 		const text = renderStatus("http://h", { status: "ok", apiKeyConfigured: false });
 		expect(text).toContain("key MISSING");
 		expect(renderStatus("http://h", { status: "ok", apiKeyConfigured: false, serving: ["ollama"] })).toContain("routing over ollama cloud only");