auto-model-router 0.30.3 → 0.32.0

package/test/skills.test.ts

@@ -9,7 +9,7 @@ const NL = String.fromCharCode(10);
 const bundle = (version: string, skills: Record<string, Record<string, string>>): SkillsBundle => ({ version, skills: Object.entries(skills).map(([name, files]) => ({ name, files })) });
 
 describe("skills served by the remote, installed by connect", () => {
-	test("a bundle is parsed defensively", () => {
+	test("a bundle is parsed defensively", async () => {
 		expect(parseSkillsBundle({ version: "v1", skills: [{ name: "team-context", files: { "SKILL.md": "# x" } }] })?.skills[0]?.name).toBe("team-context");
 		expect(parseSkillsBundle({ version: "v1", skills: [{ name: "Bad Name", files: { "SKILL.md": "# x" } }] })).toBeNull();
 		expect(parseSkillsBundle({ version: "v1", skills: [{ name: "ok", files: { "notes.md": "x" } }] })).toBeNull(); // no SKILL.md
@@ -18,7 +18,7 @@ describe("skills served by the remote, installed by connect", () => {
 		expect(parseSkillsBundle("nope")).toBeNull();
 	});
 
-	test("install writes each skill into each target, updates in place, removes what is gone, and leaves a member's own skill alone", () => {
+	test("install writes each skill into each target, updates in place, removes what is gone, and leaves a member's own skill alone", async () => {
 		const home = mkdtempSync(join(tmpdir(), "amr-skills-"));
 		const rh = join(home, ".auto-model-router");
 		const claude = join(home, ".claude", "skills");
@@ -83,7 +83,7 @@ describe("skills served by the remote, installed by connect", () => {
 		expect((await fetchSkills("https://t", "k", odd)).note).toContain("not understood");
 	});
 
-	test("connect installs the bundle only into the harnesses it configured", () => {
+	test("connect installs the bundle only into the harnesses it configured", async () => {
 		const home = mkdtempSync(join(tmpdir(), "amr-skills-connect-"));
 		mkdirSync(join(home, ".claude"), { recursive: true });
 		const agent = join(home, ".omp", "agent");

package/test/sql-shim.test.ts

@@ -0,0 +1,154 @@
+/**
+ * The dialect shim. Every case here is a way the two engines differ that cost
+ * a real bug while the ledger was ported: a JSON boolean read as the wrong
+ * type silently counted estimated cache hits as measured ones, a NULL
+ * parameter without a cast made Postgres refuse to plan the statement, and a
+ * repeated named bind mapped to the wrong slot reads the wrong column.
+ */
+import { describe, expect, test } from "bun:test";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { bindNamed, jsonParam, jsonValue, num, numOrNull, openSqlDb } from "../src/util/sql.ts";
+
+describe("bindNamed", () => {
+	test("numbers placeholders in order of first appearance, reusing a slot on postgres", async () => {
+		const text = "SELECT * FROM t WHERE a >= $since AND (b < $until OR c = $since)";
+		const pg = bindNamed(text, { since: 10, until: 20 }, true);
+		expect(pg.text).toBe("SELECT * FROM t WHERE a >= $1 AND (b < $2 OR c = $1)");
+		expect(pg.values).toEqual([10, 20]);
+
+		// SQLite's `?` cannot reuse a slot, so a repeat binds again, in order.
+		const lite = bindNamed(text, { since: 10, until: 20 }, false);
+		expect(lite.text).toBe("SELECT * FROM t WHERE a >= ? AND (b < ? OR c = ?)");
+		expect(lite.values).toEqual([10, 20, 10]);
+	});
+
+	test("leaves JSON paths alone and refuses an unbound name", async () => {
+		// `'$.isSubagent'` is a JSON path, not a placeholder.
+		const out = bindNamed("SELECT json_extract(features, '$.isSubagent') FROM t WHERE a = $a", { a: 1 }, true);
+		expect(out.text).toContain("'$.isSubagent'");
+		expect(out.values).toEqual([1]);
+		// A missing bind is a programming error, not an implicit NULL.
+		expect(() => bindNamed("SELECT $missing", {}, true)).toThrow();
+	});
+});
+
+describe("numeric coercion", () => {
+	test("postgres' string aggregates become numbers, and absent stays absent", async () => {
+		// Postgres returns COUNT(*) and BIGINT sums as strings; the ledger's
+		// helpers do arithmetic on them.
+		expect(num("42")).toBe(42);
+		expect(num(42)).toBe(42);
+		// A nullable aggregate must not silently become 0.
+		expect(num(null)).toBe(0);
+		expect(numOrNull(null)).toBeNull();
+		expect(numOrNull(undefined)).toBeNull();
+		expect(numOrNull("2.5")).toBe(2.5);
+	});
+});
+
+const engines = [
+	{ name: "sqlite", url: `sqlite://${join(tmpdir(), `shim-${process.pid}-${Date.now()}.db`)}` },
+	...(process.env.AMR_ROUTER_TEST_PG === undefined ? [] : [{ name: "postgres", url: process.env.AMR_ROUTER_TEST_PG }]),
+];
+
+for (const engine of engines) {
+	describe(`shim on ${engine.name}`, () => {
+		test("json members read back as number, text and boolean", async () => {
+			const db = openSqlDb(engine.url);
+			try {
+				await db.sql.unsafe("DROP TABLE IF EXISTS shim_probe");
+				await db.sql.unsafe(`CREATE TABLE shim_probe (id TEXT, u ${db.type("json")})`);
+				await db.sql`INSERT INTO shim_probe (id, u) VALUES (${"a"}, ${jsonParam(db, { promptTokens: 42, kind: "chat", estimated: true })})`;
+				await db.sql`INSERT INTO shim_probe (id, u) VALUES (${"b"}, ${jsonParam(db, { promptTokens: 1, kind: "chat", estimated: false })})`;
+
+				const rows = await db.query<{ id: string; tok: unknown; kind: unknown; est: unknown }>(
+					`SELECT id, ${db.jsonNum("u", "promptTokens")} AS tok, ${db.jsonText("u", "kind")} AS kind,
+						${db.jsonBool("u", "estimated")} AS est
+					FROM shim_probe WHERE id = $id`,
+					{ id: "a" },
+				);
+				expect(num(rows[0]?.tok)).toBe(42);
+				expect(rows[0]?.kind).toBe("chat");
+				// The boolean is the case that differed: json_extract yields the
+				// INTEGER 1, `->>` yields the TEXT 'true', and sqlite's IN does not
+				// coerce between them.
+				expect(num(rows[0]?.est)).toBe(1);
+
+				const off = await db.one<{ est: unknown }>(
+					`SELECT ${db.jsonBool("u", "estimated")} AS est FROM shim_probe WHERE id = $id`,
+					{ id: "b" },
+				);
+				expect(num(off?.est)).toBe(0);
+
+				// An aggregate over a JSON member: the reason jsonNum casts.
+				const total = await db.one<{ n: unknown }>(`SELECT SUM(${db.jsonNum("u", "promptTokens")}) AS n FROM shim_probe`);
+				expect(num(total?.n)).toBe(43);
+			} finally {
+				await db.sql.unsafe("DROP TABLE IF EXISTS shim_probe");
+				await db.close();
+			}
+		});
+
+		test("an optional filter works with a NULL parameter, and substring search matches", async () => {
+			const db = openSqlDb(engine.url);
+			try {
+				await db.sql.unsafe("DROP TABLE IF EXISTS shim_filter");
+				await db.sql.unsafe("CREATE TABLE shim_filter (h TEXT, reasons TEXT)");
+				await db.sql`INSERT INTO shim_filter (h, reasons) VALUES (${"h1"}, ${"failover: upstream died"})`;
+				await db.sql`INSERT INTO shim_filter (h, reasons) VALUES (${"h2"}, ${"cheapest"})`;
+
+				// The `(${x} IS NULL OR col = ${x})` idiom: Postgres cannot infer a
+				// type for a bare NULL placeholder without the cast.
+				const all = await db.query<{ h: string }>(
+					`SELECT h FROM shim_filter WHERE ($h${db.nullableText} IS NULL OR h = $h) ORDER BY h`,
+					{ h: null },
+				);
+				expect(all.map((r) => r.h)).toEqual(["h1", "h2"]);
+
+				const one = await db.query<{ h: string }>(
+					`SELECT h FROM shim_filter WHERE ($h${db.nullableText} IS NULL OR h = $h)`,
+					{ h: "h2" },
+				);
+				expect(one.map((r) => r.h)).toEqual(["h2"]);
+
+				const failovers = await db.query<{ h: string }>(
+					`SELECT h FROM shim_filter WHERE ${db.contains("reasons", "'failover:'")}`,
+				);
+				expect(failovers.map((r) => r.h)).toEqual(["h1"]);
+			} finally {
+				await db.sql.unsafe("DROP TABLE IF EXISTS shim_filter");
+				await db.close();
+			}
+		});
+
+		test("scalar minimum takes two arguments on both engines", async () => {
+			const db = openSqlDb(engine.url);
+			try {
+				// Postgres reserves MIN for the aggregate; LEAST is the scalar.
+				const row = await db.one<{ v: unknown }>(`SELECT ${db.least("3", "7")} AS v`);
+				expect(num(row?.v)).toBe(3);
+			} finally {
+				await db.close();
+			}
+		});
+
+		test("a json column round-trips whichever way it is stored", async () => {
+			const db = openSqlDb(engine.url);
+			try {
+				await db.sql.unsafe("DROP TABLE IF EXISTS shim_rt");
+				await db.sql.unsafe(`CREATE TABLE shim_rt (u ${db.type("json")})`);
+				const value = { a: 1, nested: { b: [1, 2, 3] } };
+				await db.sql`INSERT INTO shim_rt (u) VALUES (${jsonParam(db, value)})`;
+				const row = await db.one<{ u: unknown }>("SELECT u FROM shim_rt");
+				// Stringifying into a JSONB column stores a JSON *string*, and every
+				// `->>` on it then reads NULL; jsonParam is what prevents that.
+				expect(jsonValue<typeof value>(row?.u)).toEqual(value);
+			} finally {
+				await db.sql.unsafe("DROP TABLE IF EXISTS shim_rt");
+				await db.close();
+			}
+		});
+	});
+}

package/test/state.test.ts

@@ -1,90 +1,97 @@
 import { describe, expect, test } from "bun:test";
 
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
 import { createConversationStore } from "../src/router/state.ts";
-import { openDb } from "../src/util/sqlite.ts";
+import { migrateStore } from "../src/util/schema.ts";
+import { openSqlDb } from "../src/util/sql.ts";
 
-function mkStore() {
-	const db = openDb(":memory:");
+async function mkStore() {
+	// A file per store: the shim cannot share `:memory:` between handles, and a
+	// real deployment is a file (or a database) anyway.
+	const db = openSqlDb(join(tmpdir(), `state-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.db`));
+	await migrateStore(db);
 	return { db, store: createConversationStore(db) };
 }
 
 describe("conversation spend accounting", () => {
-	test("accrue accumulates instead of overwriting", () => {
-		const { db, store } = mkStore();
+	test("accrue accumulates instead of overwriting", async () => {
+		const { db, store } = await mkStore();
 		try {
-			store.load("k1");
-			store.accrue("k1", { spentUsd: 0.25 });
-			store.accrue("k1", { spentUsd: 0.5 });
-			store.accrue("k1", { escalations: 1 });
-			store.accrue("k1", { escalations: 2 });
+			await store.load("k1");
+			await store.accrue("k1", { spentUsd: 0.25 });
+			await store.accrue("k1", { spentUsd: 0.5 });
+			await store.accrue("k1", { escalations: 1 });
+			await store.accrue("k1", { escalations: 2 });
 
-			const state = store.get("k1");
+			const state = await store.get("k1");
 			expect(state?.spentUsd).toBeCloseTo(0.75, 10);
 			expect(state?.escalations).toBe(3);
 		} finally {
-			db.close();
+			await db.close();
 		}
 	});
 
-	test("save cannot clobber spend booked by a dispatch that never committed", () => {
+	test("save cannot clobber spend booked by a dispatch that never committed", async () => {
 		// The live bug: a dispatch is billed by the upstream, aborts mid-stream,
 		// and returns before the commit path. The NEXT dispatch had already loaded
 		// a turn-start snapshot, and `save` wrote that snapshot's stale total back
 		// over the aborted dispatch's cost. 30% of real spend vanished this way.
-		const { db, store } = mkStore();
+		const { db, store } = await mkStore();
 		try {
-			const snapshot = store.load("k1");
+			const snapshot = await store.load("k1");
 			expect(snapshot.spentUsd).toBe(0);
 
 			// An aborted dispatch books its cost while `snapshot` is still in hand.
-			store.accrue("k1", { spentUsd: 0.4, escalations: 1 });
+			await store.accrue("k1", { spentUsd: 0.4, escalations: 1 });
 
 			// The in-flight turn now commits using the state it loaded earlier.
 			snapshot.turn = 1;
 			snapshot.currentSlug = "cheap/model";
-			store.save(snapshot);
+			await store.save(snapshot);
 
-			const after = store.get("k1");
+			const after = await store.get("k1");
 			expect(after?.spentUsd).toBeCloseTo(0.4, 10);
 			expect(after?.escalations).toBe(1);
 			// The latest-wins fields still persist normally.
 			expect(after?.turn).toBe(1);
 			expect(after?.currentSlug).toBe("cheap/model");
 		} finally {
-			db.close();
+			await db.close();
 		}
 	});
 
-	test("interleaved dispatches both keep their money", () => {
-		const { db, store } = mkStore();
+	test("interleaved dispatches both keep their money", async () => {
+		const { db, store } = await mkStore();
 		try {
-			const a = store.load("k1");
-			const b = store.get("k1");
+			const a = await store.load("k1");
+			const b = await store.get("k1");
 			expect(b).not.toBeNull();
 
-			store.accrue("k1", { spentUsd: 0.1 });
-			store.save(a);
-			store.accrue("k1", { spentUsd: 0.2 });
-			if (b !== null) store.save(b);
+			await store.accrue("k1", { spentUsd: 0.1 });
+			await store.save(a);
+			await store.accrue("k1", { spentUsd: 0.2 });
+			if (b !== null) await store.save(b);
 
-			expect(store.get("k1")?.spentUsd).toBeCloseTo(0.3, 10);
+			expect((await store.get("k1"))?.spentUsd).toBeCloseTo(0.3, 10);
 		} finally {
-			db.close();
+			await db.close();
 		}
 	});
 
-	test("a zero delta does not touch the row", () => {
+	test("a zero delta does not touch the row", async () => {
 		// Bumping updated_at_ms for a no-op write would keep a dead conversation
 		// alive against `prune`, which reaps on that timestamp.
-		const { db, store } = mkStore();
+		const { db, store } = await mkStore();
 		try {
-			store.load("k1");
-			const before = store.get("k1")?.updatedAtMs ?? 0;
+			await store.load("k1");
+			const before = (await store.get("k1"))?.updatedAtMs ?? 0;
 			expect(before).toBeGreaterThan(0);
-			store.accrue("k1", { spentUsd: 0, escalations: 0 });
-			expect(store.get("k1")?.updatedAtMs).toBe(before);
+			await store.accrue("k1", { spentUsd: 0, escalations: 0 });
+			expect((await store.get("k1"))?.updatedAtMs).toBe(before);
 		} finally {
-			db.close();
+			await db.close();
 		}
 	});
 });

package/test/summary.test.ts

@@ -1,9 +1,15 @@
 import { describe, expect, test } from "bun:test";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
 
 import { DEFAULT_CONFIG } from "../src/config/defaults.ts";
-import { createLedger } from "../src/cost/ledger.ts";
+import { createSqlLedger } from "../src/cost/ledger-sql.ts";
+import { migrateStore } from "../src/util/schema.ts";
+import type { AsyncLedger } from "../src/cost/types.ts";
 import { buildDailySummary, countTierChanges, createKv, DAILY_SUMMARY_INTERVAL_MS, markSummaryShown, renderDailySummary, summaryDue, summaryHasNews } from "../src/cost/summary.ts";
 import type { LedgerEntry } from "../src/cost/types.ts";
+import { openSqlDb, type SqlDb } from "../src/util/sql.ts";
 import { openDb } from "../src/util/sqlite.ts";
 import { fetchSummary } from "../omp-extension/report-logic.ts";
 
@@ -53,27 +59,30 @@ function entry(over: Partial<LedgerEntry>): LedgerEntry {
 	} as LedgerEntry;
 }
 
-function seeded() {
+async function seeded(): Promise<{ db: SqlDb; ledger: AsyncLedger }> {
 	const cfg = structuredClone(DEFAULT_CONFIG);
-	cfg.ledger.path = ":memory:";
-	const db = openDb(":memory:");
-	const ledger = createLedger(db, cfg);
-	return { db, ledger };
+	// A file, not `:memory:`: the summary reads the report through its own
+	// handle on the store, which an in-memory database cannot share.
+	const path = join(tmpdir(), `summary-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.db`);
+	cfg.ledger.path = path;
+	const db = openSqlDb(path);
+	await migrateStore(db);
+	return { db, ledger: createSqlLedger(db, cfg, { findModel: () => null }) };
 }
 
 describe("buildDailySummary", () => {
-	test("compares the last 24h with the day before and names the top models and tier moves", () => {
-		const { db, ledger } = seeded();
+	test("compares the last 24h with the day before and names the top models and tier moves", async () => {
+		const { db, ledger } = await seeded();
 		try {
 			// Yesterday: one conversation climbing simple → hard, then dropping to moderate; a second model.
-			ledger.record(entry({ createdAtMs: NOW - 5 * HOUR, tier: "simple", turn: 1 }));
-			ledger.record(entry({ createdAtMs: NOW - 4 * HOUR, tier: "hard", turn: 2, slug: "vendor/big", servedSlug: "vendor/big", reportedUsd: 0.5 }));
-			ledger.record(entry({ createdAtMs: NOW - 3 * HOUR, tier: "moderate", turn: 3, escalationSignal: "empty_completion", wasted: true }));
-			ledger.record(entry({ createdAtMs: NOW - 3 * HOUR + 1, tier: "moderate", turn: 3, attempt: 1 }));
-			ledger.record(entry({ createdAtMs: NOW - 2 * HOUR, requestedModel: "digest", slug: "vendor/tiny", servedSlug: "vendor/tiny", conversationKey: "d", reportedUsd: 0.001 }));
+			await ledger.record(entry({ createdAtMs: NOW - 5 * HOUR, tier: "simple", turn: 1 }));
+			await ledger.record(entry({ createdAtMs: NOW - 4 * HOUR, tier: "hard", turn: 2, slug: "vendor/big", servedSlug: "vendor/big", reportedUsd: 0.5 }));
+			await ledger.record(entry({ createdAtMs: NOW - 3 * HOUR, tier: "moderate", turn: 3, escalationSignal: "empty_completion", wasted: true }));
+			await ledger.record(entry({ createdAtMs: NOW - 3 * HOUR + 1, tier: "moderate", turn: 3, attempt: 1 }));
+			await ledger.record(entry({ createdAtMs: NOW - 2 * HOUR, requestedModel: "digest", slug: "vendor/tiny", servedSlug: "vendor/tiny", conversationKey: "d", reportedUsd: 0.001 }));
 			// The day before: pricier.
-			for (let i = 0; i < 4; i++) ledger.record(entry({ createdAtMs: NOW - 30 * HOUR - i, conversationKey: "old", reportedUsd: 0.4 }));
-			const s = buildDailySummary(db, { nowMs: NOW, baselines: [{ slug: "anthropic/claude-opus-5", prompt: 15e-6, completion: 75e-6, cacheRead: 1.5e-6 }] });
+			for (let i = 0; i < 4; i++) await ledger.record(entry({ createdAtMs: NOW - 30 * HOUR - i, conversationKey: "old", reportedUsd: 0.4 }));
+			const s = await buildDailySummary(db, { nowMs: NOW, baselines: [{ slug: "anthropic/claude-opus-5", prompt: 15e-6, completion: 75e-6, cacheRead: 1.5e-6 }] });
 			expect(s.current.dispatches).toBe(5);
 			expect(s.current.spendUsd).toBeCloseTo(0.531, 6);
 			expect(s.current.escalations).toBe(1);
@@ -103,29 +112,29 @@ describe("buildDailySummary", () => {
 		}
 	});
 
-	test("an empty day renders as such and carries no news unless a model is spiking", () => {
-		const { db } = seeded();
+	test("an empty day renders as such and carries no news unless a model is spiking", async () => {
+		const { db } = await seeded();
 		try {
-			const s = buildDailySummary(db, { nowMs: NOW });
+			const s = await buildDailySummary(db, { nowMs: NOW });
 			expect(summaryHasNews(s)).toBe(false);
 			const text = renderDailySummary(s);
 			expect(text).toContain("no routed turns in the last 24h");
 			expect(text).toContain("soft failures: no model spiking in the last hour");
 			expect(text).not.toContain("ollama:");
 			expect(summaryHasNews({ ...s, spikes: [{ slug: "a/b", recentDispatches: 5, recentFailures: 3, recentRate: 0.6, baselineDispatches: 0, baselineFailures: 0, baselineRate: 0 }] })).toBe(true);
-			expect(countTierChanges(db, 0, "")).toEqual({ up: 0, down: 0 });
+			expect(await countTierChanges(db, 0, "")).toEqual({ up: 0, down: 0 });
 		} finally {
 			db.close();
 		}
 	});
 
-	test("harness scope narrows both windows", () => {
-		const { db, ledger } = seeded();
+	test("harness scope narrows both windows", async () => {
+		const { db, ledger } = await seeded();
 		try {
-			ledger.record(entry({ harnessId: "a" }));
-			ledger.record(entry({ harnessId: "b", reportedUsd: 5 }));
-			expect(buildDailySummary(db, { nowMs: NOW, harnessId: "a" }).current).toMatchObject({ dispatches: 1, spendUsd: 0.01 });
-			expect(buildDailySummary(db, { nowMs: NOW }).current.dispatches).toBe(2);
+			await ledger.record(entry({ harnessId: "a" }));
+			await ledger.record(entry({ harnessId: "b", reportedUsd: 5 }));
+			expect((await buildDailySummary(db, { nowMs: NOW, harnessId: "a" })).current).toMatchObject({ dispatches: 1, spendUsd: 0.01 });
+			expect((await buildDailySummary(db, { nowMs: NOW })).current.dispatches).toBe(2);
 		} finally {
 			db.close();
 		}
@@ -133,8 +142,10 @@ describe("buildDailySummary", () => {
 });
 
 describe("once-a-day gate", () => {
-	test("router_kv marks the summary shown per harness for 20h, surviving a reopen", () => {
-		const db = openDb(":memory:");
+	test("router_kv marks the summary shown per harness for 20h, surviving a reopen", async () => {
+		// `createKv` owns `router_kv` on a bun:sqlite handle — not the ledger's
+		// table, and not part of the shim port.
+		const db = openDb(join(tmpdir(), `t-summary.test-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.db`));
 		try {
 			const kv = createKv(db);
 			expect(summaryDue(kv, "", NOW)).toBe(true);