auto-model-router 0.4.3 → 0.4.5

package/test/select.test.ts

@@ -1052,6 +1052,30 @@ describe("hysteresis.confirmUpgradesBelowConfidence", () => {
 	});
 });
 
+describe("recorded forecast is the expected price, not the cold worst case", () => {
+	const warmSlug = "x-ai/grok-4.6";
+	test("a warm stay prices the previous prompt as cache reads; coldUsd keeps the cold figure", () => {
+		const cfg: RouterConfig = { ...BASE, hysteresis: { ...BASE.hysteresis, switchMargin: 1e6 } };
+		const d = run({
+			tier: "hard",
+			promptTokens: 80_000,
+			cfg,
+			st: state({ currentSlug: warmSlug, currentTier: "hard", cacheWarmSlug: warmSlug, cacheWarmAtMs: Date.now(), lastPromptTokens: 60_000 }),
+		});
+		expect(d.slug).toBe(warmSlug);
+		// 60k of the 80k prompt is the cached prefix; no reliability sample ⇒ assumed reliable.
+		expect(d.forecast.assumedCacheHitRate).toBeCloseTo(0.75, 6);
+		expect(d.forecast.expectedUsd).toBeLessThan(d.forecast.coldUsd);
+		expect(d.forecast.breakdown.cacheRead).toBeGreaterThan(0);
+	});
+
+	test("a cold turn records the cold price", () => {
+		const d = run({ tier: "hard", promptTokens: 80_000 });
+		expect(d.forecast.assumedCacheHitRate).toBe(0);
+		expect(d.forecast.expectedUsd).toBeLessThanOrEqual(d.forecast.coldUsd);
+	});
+});
+
 describe("cache reliability in the stay/switch comparison", () => {
 	const warmSlug = "x-ai/grok-4.6";
 	function ledgerWithReliability(rate: number | null, samples = 50): Ledger {

package/test/support/preload.ts

@@ -0,0 +1,19 @@
+/**
+ * Test preload (bunfig.toml `[test] preload`): isolate every test from the
+ * developer's live router home BEFORE any module loads.
+ *
+ * Five test files build their config with `loadConfig({})`, which layers
+ * `$AUTO_MODEL_ROUTER_HOME/config.yml` over the defaults. Run alone they read
+ * the real config and fail on whatever the developer has tuned; run in the
+ * full suite they happened to pass because an earlier file had already
+ * pointed the home at a temp dir. Doing it here makes both cases the same.
+ * Tests that want a specific home (config.test.ts, embed-lifecycle) still
+ * set their own; this only supplies the default.
+ */
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+if (process.env.AUTO_MODEL_ROUTER_HOME === undefined) {
+	process.env.AUTO_MODEL_ROUTER_HOME = mkdtempSync(join(tmpdir(), "amr-test-home-"));
+}

package/test/tokens.test.ts

@@ -281,3 +281,27 @@ describe("ledger.softFailureSpikes", () => {
 		}
 	});
 });
+
+describe("ledger.prune and markWasted", () => {
+	test("prune deletes rows past retention and 0 keeps everything; markWasted flips one row", () => {
+		const db = openDb(":memory:");
+		try {
+			const ledger = createLedger(db, cfg);
+			const now = 1_800_000_000_000;
+			const DAY = 86_400_000;
+			for (let i = 0; i < 5; i++) ledger.record(entry({ createdAtMs: now - i * 100 * DAY }));
+			expect(ledger.prune?.(0, now)).toBe(0);
+			expect(ledger.recentEntries(10)).toHaveLength(5);
+			expect(ledger.prune?.(365, now)).toBe(1); // only the 400-day-old row
+			expect(ledger.recentEntries(10)).toHaveLength(4);
+			expect(ledger.prune?.(150, now)).toBe(2); // 200 and 300 days old
+			const left = ledger.recentEntries(10);
+			expect(left).toHaveLength(2);
+			expect(left.every((e) => e.wasted === false)).toBe(true);
+			ledger.markWasted?.(left[0]!.id);
+			expect(ledger.recentEntries(10).find((e) => e.id === left[0]!.id)?.wasted).toBe(true);
+		} finally {
+			db.close();
+		}
+	});
+});

package/test/turn.test.ts

@@ -77,9 +77,10 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 		compaction: { enabled: false, budgetTokens: 40_000, floorRatio: 1, fitToWindow: true, protectRecentTurns: 4, maxToolResultBytes: 4_096, keepHeadBytes: 512, keepTailBytes: 512, elideSupersededReads: true, collapseDuplicateResults: true, replanGrowthRatio: 1, digestToolResults: false, digestMaxPerTurn: 2 },
 		budget: { onExceeded: "downgrade" },
 		report: { baselines: [], dailySummary: false },
+		harnessSwitch: { enabled: false, models: {}, minConfidence: 0.6 },
 		digest: { enabled: false, minBytes: 12_000, maxBytes: 400_000, tools: ["read"], fromTier: "moderate", tier: "simple", model: "", maxOutputTokens: 700, maxCostUsd: 0.02, timeoutMs: 25_000 },
 		profiles: [],
-		ledger: { path: ":memory:", blendWindowDays: 7, blendMinSamples: 20, fallbackBlend: { inputPerMtok: 1, outputPerMtok: 4 }, conversationTtlMs: 86_400_000 },
+		ledger: { path: ":memory:", blendWindowDays: 7, blendMinSamples: 20, fallbackBlend: { inputPerMtok: 1, outputPerMtok: 4 }, conversationTtlMs: 86_400_000 , retentionDays: 0,},
 		adaptiveTierFloors: true,
 		adaptivePriceCeilings: false,
 		logLevel: "silent",

package/tools/gen-migration-fixtures.ts

@@ -0,0 +1,69 @@
+#!/usr/bin/env bun
+/**
+ * Regenerates the old-schema ledger fixtures that test/migrations.test.ts
+ * opens with the CURRENT bootstrap.
+ *
+ *   bun tools/gen-migration-fixtures.ts
+ *
+ * For each release tag that changed the schema, the bootstrap of THAT tag is
+ * taken from git, run against a fresh file, and a dummy row is inserted into
+ * every table (filling each NOT NULL column without a default by its declared
+ * type), so the migrations have data to carry, not just DDL. The WAL is folded
+ * back into the main file and the result lands in test/fixtures/migrations/
+ * as router-v<user_version>.db. Small (a few dozen KB each); commit them.
+ *
+ * Re-run only when adding a NEW historical version: rewriting existing
+ * fixtures would erase the very thing the test guards.
+ */
+
+import { Database } from "bun:sqlite";
+import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { $ } from "bun";
+
+/** One tag per schema version that shipped. */
+const TAGS = ["v0.1.0", "v0.1.4", "v0.2.0", "v0.2.10", "v0.2.22", "v0.2.28", "v0.3.0"];
+const OUT_DIR = join(import.meta.dir, "..", "test", "fixtures", "migrations");
+mkdirSync(OUT_DIR, { recursive: true });
+const work = mkdtempSync(join(tmpdir(), "amr-migrations-"));
+
+function dummy(type: string, name: string): string | number {
+	const t = type.toUpperCase();
+	if (name === "id" || name === "key") return `fixture-${name}`;
+	if (name === "created_at_ms" || name === "updated_at_ms" || name === "fetched_at_ms") return 1_756_000_000_000;
+	if (t.includes("INT") || t.includes("REAL")) return 1;
+	if (name === "usage") return JSON.stringify({ promptTokens: 100, cachedTokens: 0, cacheWriteTokens: 0, completionTokens: 10, reasoningTokens: 0, images: 0 });
+	if (name === "reasons") return JSON.stringify(["fixture"]);
+	if (name === "payload") return JSON.stringify({ data: [] });
+	return `fixture-${name}`;
+}
+
+for (const tag of TAGS) {
+	const src = await $`git show ${tag}:src/util/sqlite.ts`.text();
+	const modPath = join(work, `sqlite-${tag}.ts`);
+	await Bun.write(modPath, src);
+	const dbPath = join(work, `${tag}.db`);
+	const mod = (await import(modPath)) as { openDb(path: string): Database };
+	const db = mod.openDb(dbPath);
+	const version = (db.query("PRAGMA user_version").get() as { user_version: number }).user_version;
+	const tables = (db.query("SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'").all() as { name: string }[]).map((r) => r.name);
+	for (const table of tables) {
+		const cols = db.query(`PRAGMA table_info(${table})`).all() as { name: string; type: string; notnull: number; dflt_value: string | null; pk: number }[];
+		// NOT NULL columns without a default, plus text primary keys (SQLite lets
+		// a TEXT PRIMARY KEY be NULL, but the router never writes one that way).
+		const fill = cols.filter((c) => (c.notnull === 1 && c.dflt_value === null && !(c.pk === 1 && c.type.toUpperCase().includes("INT"))) || (c.pk === 1 && !c.type.toUpperCase().includes("INT")));
+		// A ledger row with an error string exercises the v4 error_kind backfill.
+		const values = fill.map((c) => (table === "ledger" && c.name === "error" ? "upstream_error: 502" : dummy(c.type, c.name)));
+		if (fill.length === 0) continue;
+		db.run(`INSERT INTO ${table} (${fill.map((c) => c.name).join(", ")}) VALUES (${fill.map(() => "?").join(", ")})`, values);
+		if (table === "ledger" && cols.some((c) => c.name === "error")) db.run(`UPDATE ledger SET error = 'upstream_error: 502'`);
+	}
+	db.run("PRAGMA wal_checkpoint(TRUNCATE)");
+	db.run("PRAGMA journal_mode = DELETE");
+	db.close();
+	const out = join(OUT_DIR, `router-v${version}.db`);
+	await Bun.write(out, Bun.file(dbPath));
+	console.log(`${tag} → ${out} (user_version ${version}, tables: ${tables.join(", ")})`);
+}
+rmSync(work, { recursive: true, force: true });