auto-model-router 0.1.0

package/test/models-yml.test.ts

@@ -0,0 +1,186 @@
+import { describe, expect, test } from "bun:test";
+import { parse as parseYaml } from "yaml";
+
+import { loadConfig } from "../src/config/load.ts";
+import {
+	BEGIN_GUARD,
+	END_GUARD,
+	assertUsableModelsYaml,
+	renderProviderBlock,
+	spliceProviderBlock,
+} from "../src/cli/config-cmd.ts";
+
+const cfg = loadConfig({});
+const BLOCK = renderProviderBlock(cfg, null);
+
+/** A models.yml with other providers, comments, and non-default indentation. */
+const EXISTING = `providers:
+    fastflowlm:
+        api: openai-completions
+        auth: none
+        baseUrl: http://127.0.0.1:52625/v1
+        models:
+            # contextWindow must match FLM's runtime KV cache, NOT the
+            # model's architectural limit.
+            - contextWindow: 32768
+              id: qwen3.6-moe:35b-a3b
+              name: Qwen3.6 MoE 35B-A3B (NPU)
+    ollama:
+        api: openai-responses
+        auth: none
+        baseUrl: http://127.0.0.1:11434/v1
+        discovery:
+            type: ollama
+`;
+
+function providersOf(text: string): Record<string, unknown> {
+	const parsed: unknown = parseYaml(text);
+	if (typeof parsed !== "object" || parsed === null || !("providers" in parsed)) {
+		throw new Error("no providers mapping");
+	}
+	const providers = parsed.providers;
+	if (typeof providers !== "object" || providers === null) throw new Error("providers is not a mapping");
+	return providers as Record<string, unknown>;
+}
+
+function countOf(text: string, needle: string): number {
+	return text.split(needle).length - 1;
+}
+
+describe("renderProviderBlock", () => {
+	test("emits costs in USD per MILLION tokens, not per token", () => {
+		const providers = providersOf(`providers:\n${BLOCK.split("\n").map((l) => (l === "" ? "" : `  ${l}`)).join("\n")}\n`);
+		const router = providers["auto-model-router"];
+		expect(typeof router).toBe("object");
+		const parsed: unknown = parseYaml(BLOCK);
+		expect(typeof parsed).toBe("object");
+		// Fallback blend is dollars-per-million; a per-token figure would be ~1e-6.
+		expect(cfg.ledger.fallbackBlend.inputPerMtok).toBeGreaterThan(0.01);
+		expect(BLOCK).toContain(`input: ${cfg.ledger.fallbackBlend.inputPerMtok}`);
+	});
+
+	test("declares one model per configured profile", () => {
+		for (const profile of cfg.profiles) expect(BLOCK).toContain(`id: ${profile.id}`);
+	});
+
+	test("advertises a keyless openai-compatible provider", () => {
+		expect(BLOCK).toContain("api: openai-completions");
+		expect(BLOCK).toContain("auth: none");
+		expect(BLOCK).toContain("/v1");
+	});
+});
+
+describe("spliceProviderBlock", () => {
+	test("preserves every original line and comment", () => {
+		const result = spliceProviderBlock(EXISTING, BLOCK);
+		expect(result.action).toBe("inserted");
+		const after = result.text.split("\n");
+		for (const line of EXISTING.split("\n")) {
+			if (line.trim() === "") continue;
+			expect(after).toContain(line);
+		}
+		expect(result.text).toContain("# model's architectural limit.");
+	});
+
+	test("leaves the pre-existing providers intact and adds ours", () => {
+		const result = spliceProviderBlock(EXISTING, BLOCK);
+		const providers = providersOf(result.text);
+		expect(Object.keys(providers).sort()).toEqual(["auto-model-router", "fastflowlm", "ollama"]);
+	});
+
+	test("is idempotent: a second run replaces rather than duplicates", () => {
+		const once = spliceProviderBlock(EXISTING, BLOCK);
+		const twice = spliceProviderBlock(once.text, BLOCK);
+		expect(twice.action).toBe("replaced");
+		expect(countOf(twice.text, BEGIN_GUARD)).toBe(1);
+		expect(countOf(twice.text, END_GUARD)).toBe(1);
+		expect(countOf(twice.text, "auto-model-router:")).toBe(1);
+		providersOf(twice.text);
+	});
+
+	test("refreshed cost figures replace the old ones in place", () => {
+		const first = spliceProviderBlock(EXISTING, renderProviderBlock(cfg, null));
+		const updated = spliceProviderBlock(
+			first.text,
+			renderProviderBlock(cfg, {
+				inputPerMtok: 0.4242,
+				outputPerMtok: 1.2345,
+				cacheReadPerMtok: 0.0424,
+				cacheWritePerMtok: 0.5303,
+				sampleCount: 99,
+				windowDays: 7,
+			}),
+		);
+		expect(updated.text).toContain("0.4242");
+		expect(countOf(updated.text, BEGIN_GUARD)).toBe(1);
+		providersOf(updated.text);
+	});
+
+	test("adds a providers mapping when the file has none", () => {
+		const result = spliceProviderBlock("# just a comment\n", BLOCK);
+		expect(result.text).toContain("# just a comment");
+		expect(countOf(result.text, "providers:")).toBe(1);
+		expect(Object.keys(providersOf(result.text))).toContain("auto-model-router");
+	});
+
+	test("creates a whole file from empty input", () => {
+		const result = spliceProviderBlock("", BLOCK);
+		expect(result.action).toBe("created");
+		expect(Object.keys(providersOf(result.text))).toContain("auto-model-router");
+	});
+
+	test("survives a UTF-8 BOM without producing a duplicate providers key", () => {
+		// A BOM made the first line read as "\uFEFFproviders:", so the top-level
+		// key was missed and a second one appended -- which makes omp discard the
+		// entire file.
+		const result = spliceProviderBlock(`\uFEFF${EXISTING}`, BLOCK);
+		expect(result.text.startsWith("\uFEFF")).toBe(true);
+		const lines = result.text.split("\n");
+		expect(lines.filter((l) => /^\uFEFF?providers\s*:/.test(l))).toHaveLength(1);
+		expect(Object.keys(providersOf(result.text)).sort()).toEqual(["auto-model-router", "fastflowlm", "ollama"]);
+	});
+
+	test("preserves CRLF line endings", () => {
+		const crlf = EXISTING.replaceAll("\n", "\r\n");
+		const result = spliceProviderBlock(crlf, BLOCK);
+		expect(result.text).toContain("\r\n");
+		// No stray bare LF introduced by the inserted block.
+		expect(result.text.replaceAll("\r\n", "")).not.toContain("\n");
+		providersOf(result.text);
+	});
+
+	test("matches the existing child indentation", () => {
+		// EXISTING indents providers' children by four spaces; mixing widths
+		// under one mapping is invalid YAML.
+		const result = spliceProviderBlock(EXISTING, BLOCK);
+		const begin = result.text.split("\n").find((l) => l.includes(BEGIN_GUARD));
+		expect(begin).toBeDefined();
+		expect(begin?.startsWith("    #")).toBe(true);
+	});
+
+	test("a two-space file gets two-space children", () => {
+		const twoSpace = "providers:\n  ollama:\n    auth: none\n";
+		const result = spliceProviderBlock(twoSpace, BLOCK);
+		const begin = result.text.split("\n").find((l) => l.includes(BEGIN_GUARD));
+		expect(begin?.startsWith("  #")).toBe(true);
+		providersOf(result.text);
+	});
+});
+
+describe("assertUsableModelsYaml", () => {
+	test("accepts a correctly spliced result", () => {
+		expect(() => assertUsableModelsYaml(spliceProviderBlock(EXISTING, BLOCK).text)).not.toThrow();
+	});
+
+	test("rejects a duplicate providers key, which YAML treats as fatal", () => {
+		expect(() => assertUsableModelsYaml("providers:\n  a:\n    auth: none\nproviders:\n  b:\n    auth: none\n")).toThrow();
+	});
+
+	test("rejects a file without our provider", () => {
+		expect(() => assertUsableModelsYaml("providers:\n  ollama:\n    auth: none\n")).toThrow();
+	});
+
+	test("rejects a file with no providers mapping", () => {
+		expect(() => assertUsableModelsYaml("something: else\n")).toThrow();
+	});
+});

package/test/omp-credentials.test.ts

@@ -0,0 +1,185 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { Database } from "bun:sqlite";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { readOmpCredential, resolveOpenRouterKey } from "../src/config/omp-credentials.ts";
+
+/**
+ * omp's real `auth_credentials` DDL, copied verbatim from a live
+ * `~/.omp/agent/agent.db`. Tests must fail if we drift from the actual schema,
+ * so this is not a simplified stand-in.
+ */
+const SCHEMA = `
+CREATE TABLE auth_credentials (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  provider TEXT NOT NULL,
+  credential_type TEXT NOT NULL,
+  data TEXT NOT NULL,
+  disabled_cause TEXT DEFAULT NULL,
+  identity_key TEXT DEFAULT NULL,
+  created_at INTEGER NOT NULL DEFAULT (CAST(strftime('%s','now') AS INTEGER)),
+  updated_at INTEGER NOT NULL DEFAULT (CAST(strftime('%s','now') AS INTEGER))
+)`;
+
+const dirs: string[] = [];
+const savedEnv = new Map<string, string | undefined>();
+
+function setEnv(key: string, value: string | undefined): void {
+	if (!savedEnv.has(key)) savedEnv.set(key, process.env[key]);
+	if (value === undefined) delete process.env[key];
+	else process.env[key] = value;
+}
+
+interface Row {
+	provider: string;
+	type: string;
+	data: unknown;
+	disabled?: string;
+	updatedAt?: number;
+}
+
+function storeWith(rows: Row[]): string {
+	const dir = mkdtempSync(join(tmpdir(), "ompr-cred-"));
+	dirs.push(dir);
+	const path = join(dir, "agent.db");
+	const db = new Database(path);
+	db.exec(SCHEMA);
+	const insert = db.query(
+		"INSERT INTO auth_credentials (provider, credential_type, data, disabled_cause, updated_at) VALUES (?, ?, ?, ?, ?)",
+	);
+	for (const r of rows) {
+		insert.run(r.provider, r.type, JSON.stringify(r.data), r.disabled ?? null, r.updatedAt ?? Math.floor(Date.now() / 1000));
+	}
+	db.close();
+	return path;
+}
+
+afterEach(() => {
+	for (const [key, value] of savedEnv) {
+		if (value === undefined) delete process.env[key];
+		else process.env[key] = value;
+	}
+	savedEnv.clear();
+	for (const dir of dirs.splice(0)) rmSync(dir, { recursive: true, force: true });
+});
+
+describe("readOmpCredential", () => {
+	test("reads an api_key credential in omp's stored shape", () => {
+		// Matches the real `ollama-cloud` row: {"key": "...", "source": "..."}
+		const path = storeWith([{ provider: "openrouter", type: "api_key", data: { key: "sk-or-real", source: "login" } }]);
+		expect(readOmpCredential("openrouter", path)).toBe("sk-or-real");
+	});
+
+	test("returns null for a provider that is not logged in", () => {
+		const path = storeWith([{ provider: "anthropic", type: "oauth", data: { access: "x", expires: Date.now() + 1e6 } }]);
+		expect(readOmpCredential("openrouter", path)).toBeNull();
+	});
+
+	test("accepts an unexpired oauth access token", () => {
+		const path = storeWith([
+			{ provider: "openrouter", type: "oauth", data: { access: "tok-live", refresh: "r", expires: Date.now() + 600_000 } },
+		]);
+		expect(readOmpCredential("openrouter", path)).toBe("tok-live");
+	});
+
+	test("rejects an expired oauth token rather than burning a turn on a 401", () => {
+		// Refreshing is omp's job; we hold the store read-only.
+		const path = storeWith([
+			{ provider: "openrouter", type: "oauth", data: { access: "tok-stale", refresh: "r", expires: Date.now() - 1000 } },
+		]);
+		expect(readOmpCredential("openrouter", path)).toBeNull();
+	});
+
+	test("skips a disabled credential", () => {
+		const path = storeWith([
+			{ provider: "openrouter", type: "api_key", data: { key: "sk-or-dead" }, disabled: "revoked" },
+		]);
+		expect(readOmpCredential("openrouter", path)).toBeNull();
+	});
+
+	test("prefers the most recently updated credential", () => {
+		const path = storeWith([
+			{ provider: "openrouter", type: "api_key", data: { key: "sk-or-old" }, updatedAt: 1000 },
+			{ provider: "openrouter", type: "api_key", data: { key: "sk-or-new" }, updatedAt: 2000 },
+		]);
+		expect(readOmpCredential("openrouter", path)).toBe("sk-or-new");
+	});
+
+	test("survives a missing, unreadable, or unexpected store", () => {
+		expect(readOmpCredential("openrouter", join(tmpdir(), "definitely-absent-agent.db"))).toBeNull();
+		const dir = mkdtempSync(join(tmpdir(), "ompr-cred-"));
+		dirs.push(dir);
+		const garbage = join(dir, "agent.db");
+		writeFileSync(garbage, "this is definitely not a sqlite database");
+		// A corrupt or foreign file must degrade to "no key", never throw.
+		expect(() => readOmpCredential("openrouter", garbage)).not.toThrow();
+		expect(readOmpCredential("openrouter", garbage)).toBeNull();
+	});
+
+	test("skips a row whose data is not valid JSON", () => {
+		const dir = mkdtempSync(join(tmpdir(), "ompr-cred-"));
+		dirs.push(dir);
+		const path = join(dir, "agent.db");
+		const db = new Database(path);
+		db.exec(SCHEMA);
+		db.query("INSERT INTO auth_credentials (provider, credential_type, data) VALUES (?, ?, ?)").run(
+			"openrouter",
+			"api_key",
+			"{not json",
+		);
+		db.close();
+		expect(readOmpCredential("openrouter", path)).toBeNull();
+	});
+
+	test("declines to read a local store when a remote auth broker is configured", () => {
+		const path = storeWith([{ provider: "openrouter", type: "api_key", data: { key: "sk-or-local" } }]);
+		setEnv("OMP_AUTH_BROKER_URL", "https://broker.example");
+		// Broker mode replaces the local store; reading it would be a stale lie.
+		expect(readOmpCredential("openrouter", path)).toBeNull();
+	});
+});
+
+describe("resolveOpenRouterKey", () => {
+	test("explicit configuration wins over the borrowed credential", () => {
+		setEnv("OPENROUTER_API_KEY", undefined);
+		const resolved = resolveOpenRouterKey("sk-or-explicit");
+		expect(resolved.apiKey).toBe("sk-or-explicit");
+		expect(resolved.source).toBe("config");
+	});
+
+	test("attributes a key that came from the environment", () => {
+		setEnv("OPENROUTER_API_KEY", "sk-or-from-env");
+		const resolved = resolveOpenRouterKey("sk-or-from-env");
+		expect(resolved.source).toBe("env");
+	});
+
+	test("reports an actionable message when nothing is configured", () => {
+		setEnv("OPENROUTER_API_KEY", undefined);
+		setEnv("PI_CODING_AGENT_DIR", mkdtempSync(join(tmpdir(), "ompr-empty-agent-")));
+		dirs.push(process.env.PI_CODING_AGENT_DIR ?? "");
+		const resolved = resolveOpenRouterKey("");
+		expect(resolved.apiKey).toBe("");
+		expect(resolved.source).toBe("none");
+		expect(resolved.detail).toContain("/login openrouter");
+	});
+
+	test("borrows omp's credential when nothing else is configured", () => {
+		setEnv("OPENROUTER_API_KEY", undefined);
+		const dir = mkdtempSync(join(tmpdir(), "ompr-agentdir-"));
+		dirs.push(dir);
+		const db = new Database(join(dir, "agent.db"));
+		db.exec(SCHEMA);
+		db.query("INSERT INTO auth_credentials (provider, credential_type, data) VALUES (?, ?, ?)").run(
+			"openrouter",
+			"api_key",
+			JSON.stringify({ key: "sk-or-borrowed", source: "login" }),
+		);
+		db.close();
+		setEnv("PI_CODING_AGENT_DIR", dir);
+		const resolved = resolveOpenRouterKey("");
+		expect(resolved.apiKey).toBe("sk-or-borrowed");
+		expect(resolved.source).toBe("omp-auth-store");
+	});
+});