auto-model-router 0.16.0 → 0.18.0

package/src/server/catalog-view.ts

@@ -0,0 +1,130 @@
+/**
+ * The router's model catalog as data, with a policy's verdict per model: what
+ * `GET /v1/router/catalog` answers. A team front door renders it for its
+ * governance views ("which models can this group reach, and why not the
+ * rest"), so admission is decided by the SAME matcher and in the SAME order
+ * as `buildCandidates` — the built-in denials, then allow, deny, free and
+ * tool support — over the filters `applyRequestPolicy` produced, and a pin
+ * takes effect only when the pinned model itself survives them, exactly as
+ * `select` treats a forced slug. Tiers are per turn and take no part.
+ */
+
+import type { CatalogModel, Modality, QualityScores } from "../catalog/types.ts";
+import type { FilterConfig } from "../config/types.ts";
+import { builtInDenial, globToRe } from "../router/candidates.ts";
+
+export interface CatalogViewModel {
+	slug: string;
+	canonicalSlug: string;
+	name: string;
+	/** The upstream that serves it: `openrouter`, `ollama`, or a named upstream's id. */
+	provider: string;
+	/**
+	 * The slug's namespace before the first `/` (`anthropic`). For a named
+	 * upstream's `<id>/<model>` the vendor is the model id's own namespace when
+	 * it carries one (`vllm/meta-llama/x` ⇒ `meta-llama`), else the upstream id.
+	 */
+	vendor: string;
+	contextLength: number;
+	maxCompletionTokens?: number;
+	supportsTools: boolean;
+	supportsReasoning: boolean;
+	reasoningMandatory: boolean;
+	inputModalities: Modality[];
+	/** USD per MILLION tokens, the catalog's own units. */
+	price: { prompt: number; completion: number; cacheRead?: number; cacheWrite?: number };
+	quality: QualityScores;
+	isFree: boolean;
+	/** Present only when a policy was asked about. */
+	admitted?: boolean;
+	/** Present only when not admitted: which filter kept the model out. */
+	reason?: string;
+}
+
+export interface CatalogView {
+	/** When the catalog was last fetched; 0 before the first fetch. */
+	fetchedAtMs: number;
+	/** Sorted by slug. */
+	models: CatalogViewModel[];
+}
+
+/** The filters a turn routes under: the configured ones, or those `applyRequestPolicy` merged a policy into. */
+export type AdmissionFilters = Pick<FilterConfig, "allow" | "deny" | "includeFree" | "requireToolSupport">;
+
+export interface CatalogViewArgs {
+	models: readonly CatalogModel[];
+	fetchedAtMs: number;
+	/** When given, every model carries `admitted` and, if out, `reason`. */
+	verdict?: { filters: AdmissionFilters; pin?: string };
+	/** Why a provider cannot take a turn now, or null when it can. */
+	unserved: (provider: string) => string | null;
+}
+
+/** Per-token catalog prices as USD per million, rounded so `0.22` does not come out as `0.22000000000000003`. */
+function perMillion(usdPerToken: number): number {
+	return Math.round(usdPerToken * 1e6 * 1e6) / 1e6;
+}
+
+export function vendorOf(model: Pick<CatalogModel, "slug" | "provider">): string {
+	const slash = model.slug.indexOf("/");
+	const head = slash === -1 ? model.slug : model.slug.slice(0, slash);
+	if (model.provider === "openrouter" || model.provider === "ollama" || head !== model.provider) return head;
+	const rest = model.slug.slice(slash + 1);
+	const inner = rest.indexOf("/");
+	return inner === -1 ? model.provider : rest.slice(0, inner);
+}
+
+/**
+ * Why the filters keep a model out, or null when it passes. The order is
+ * `buildCandidates`' so the first reason is the one a turn would record.
+ */
+function filterReason(model: CatalogModel, filters: AdmissionFilters, allowRes: readonly RegExp[], denyRes: readonly RegExp[]): string | null {
+	const builtIn = builtInDenial(model);
+	if (builtIn !== null) return builtIn;
+	if (allowRes.length > 0 && !allowRes.some((re) => re.test(model.slug))) return "not in the allow list";
+	const denied = denyRes.findIndex((re) => re.test(model.slug));
+	if (denied !== -1) return `denied by ${filters.deny[denied]}`;
+	if (model.isFree && !filters.includeFree) return "free models excluded (filters.includeFree)";
+	if (filters.requireToolSupport && !model.supportsTools) return "no tool support (filters.requireToolSupport)";
+	return null;
+}
+
+export function catalogView(args: CatalogViewArgs): CatalogView {
+	const sorted = [...args.models].sort((a, b) => (a.slug < b.slug ? -1 : a.slug > b.slug ? 1 : 0));
+	const verdict = args.verdict;
+	const allowRes = verdict === undefined ? [] : verdict.filters.allow.map(globToRe);
+	const denyRes = verdict === undefined ? [] : verdict.filters.deny.map(globToRe);
+	// One reason per slug before the pin is considered: the pin only bites when
+	// the pinned model itself is in, as `select` ignores a pin the filters drop.
+	const reasons = new Map<string, string | null>();
+	if (verdict !== undefined) for (const m of sorted) reasons.set(m.slug, args.unserved(m.provider) ?? filterReason(m, verdict.filters, allowRes, denyRes));
+	const pin = verdict?.pin !== undefined && reasons.get(verdict.pin) === null ? verdict.pin : undefined;
+	const models = sorted.map((m): CatalogViewModel => {
+		const price: CatalogViewModel["price"] = { prompt: perMillion(m.price.prompt), completion: perMillion(m.price.completion) };
+		if (m.price.cacheRead !== undefined) price.cacheRead = perMillion(m.price.cacheRead);
+		if (m.price.cacheWrite !== undefined) price.cacheWrite = perMillion(m.price.cacheWrite);
+		const out: CatalogViewModel = {
+			slug: m.slug,
+			canonicalSlug: m.canonicalSlug,
+			name: m.name,
+			provider: m.provider,
+			vendor: vendorOf(m),
+			contextLength: m.contextLength,
+			...(m.maxCompletionTokens === undefined ? {} : { maxCompletionTokens: m.maxCompletionTokens }),
+			supportsTools: m.supportsTools,
+			supportsReasoning: m.supportsReasoning,
+			reasoningMandatory: m.reasoningMandatory,
+			inputModalities: [...m.inputModalities],
+			price,
+			quality: { ...m.quality },
+			isFree: m.isFree,
+		};
+		if (verdict !== undefined) {
+			const reason = reasons.get(m.slug) ?? (pin !== undefined && m.slug !== pin ? `pinned to ${pin}` : null);
+			out.admitted = reason === null;
+			if (reason !== null) out.reason = reason;
+		}
+		return out;
+	});
+	return { fetchedAtMs: args.fetchedAtMs, models };
+}

package/src/server/digest.ts

@@ -101,6 +101,7 @@ function syntheticRequest(req: DigestRequest, promptText: string): NormRequest {
 		agentdoxScope: "",
 		agentdoxGroup: "",
 		agentdoxPersonal: "",
+		agentdoxOrigin: "",
 		isSubagent: true,
 		requestedModel: "digest",
 		messages: [

package/src/server/http.ts

@@ -6,6 +6,10 @@ import { createBridgeFromConfig } from "../context/index.ts";
 import { createFeedbackStore, type Verdict } from "../cost/feedback.ts";
 import { createLedger } from "../cost/ledger.ts";
 import { createSessionOverrides } from "./overrides.ts";
+import { catalogView } from "./catalog-view.ts";
+import { buildUpstreamModels } from "../catalog/static-catalog.ts";
+import { applyRequestPolicy, resolveProfile } from "../router/index.ts";
+import { parsePolicyHeader } from "../wire/openai/request.ts";
 import { createDigester } from "./digest.ts";
 import { advise } from "./advise.ts";
 import { TIER_ORDER, type Tier } from "../router/types.ts";
@@ -484,6 +488,40 @@ export function startServer(cfg: RouterConfig): StartedServer {
 				if (req.method === "GET" && url.pathname === "/v1/router/stats") {
 					return json(computeStats(ledger));
 				}
+				if (req.method === "GET" && url.pathname === "/v1/router/catalog") {
+					// The catalog as data, judged under `?policy=` (the X-Omp-Policy
+					// JSON) when one is given: a front door's governance view. Never
+					// blocks on a fetch; before the first one it is empty.
+					const rawPolicy = url.searchParams.get("policy");
+					let verdict: { filters: RouterConfig["filters"]; pin?: string } | undefined;
+					if (rawPolicy !== null) {
+						// The header parser forgives a malformed value (a turn must not
+						// fail on it); a view asked about one must say so instead.
+						let parsed: unknown;
+						try {
+							parsed = JSON.parse(rawPolicy);
+						} catch {
+							parsed = undefined;
+						}
+						if (parsed === undefined || parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+							return wireErrorResponse({ status: 400, code: "invalid_request_error", message: "policy must be a JSON object (the X-Omp-Policy shape)" });
+						}
+						const policed = applyRequestPolicy(resolveProfile(cfg, "auto"), cfg, parsePolicyHeader(rawPolicy), undefined);
+						verdict = { filters: policed.cfg.filters, ...(policed.forceSlug === undefined ? {} : { pin: policed.forceSlug }) };
+					}
+					const snap = catalog.peekAll?.() ?? catalog.peek();
+					// A disabled named upstream's models are not built for routing; list them too, so "why not" has an answer.
+					const disabled = snap === null ? [] : cfg.upstreams.filter((u) => !u.enabled).flatMap((u) => buildUpstreamModels(u, snap.models));
+					const unserved = (provider: string): string | null => {
+						if (provider === "openrouter") return cfg.openrouter.apiKey === "" ? "upstream openrouter has no API key" : null;
+						if (provider === "ollama") return !cfg.ollama.enabled ? "upstream ollama is disabled" : ollama.available() ? null : "upstream ollama is in cooldown";
+						const entry = cfg.upstreams.find((u) => u.id === provider);
+						if (entry === undefined) return `upstream ${provider} is not configured`;
+						if (!entry.enabled) return `upstream ${provider} is disabled`;
+						return providers.named(provider)?.available() ?? true ? null : `upstream ${provider} is in cooldown`;
+					};
+					return json(catalogView({ models: snap === null ? [] : [...snap.models, ...disabled], fetchedAtMs: snap?.fetchedAtMs ?? 0, ...(verdict === undefined ? {} : { verdict }), unserved }));
+				}
 				if (req.method === "GET" && url.pathname === "/v1/router/spend") {
 					// Spend since an instant over a harness set: what a front door's
 					// budget check needs when it cannot read the ledger file.

package/src/server/providers.ts

@@ -11,7 +11,7 @@ import { createAnthropicClient } from "../upstream/anthropic.ts";
 import { createCompatClient, type NamedUpstreamClient } from "../upstream/compat.ts";
 import { createOllamaCatalog } from "../catalog/ollama-catalog.ts";
 import { createCatalog } from "../catalog/openrouter-catalog.ts";
-import type { CatalogSource } from "../catalog/types.ts";
+import type { CatalogSnapshot, CatalogSource } from "../catalog/types.ts";
 import type { RouterConfig } from "../config/types.ts";
 import { createMultiUpstream } from "../upstream/multi.ts";
 import { createOllamaClient, type OllamaClient } from "../upstream/ollama.ts";
@@ -24,7 +24,7 @@ import { createLogger, type Logger } from "../util/log.ts";
 
 export interface Providers {
 	upstream: UpstreamClient;
-	catalog: CatalogSource & { ollamaModels?(): unknown[]; ollamaBias?(): number };
+	catalog: CatalogSource & { ollamaModels?(): unknown[]; ollamaBias?(): number; peekAll?(): CatalogSnapshot | null };
 	/** Always present: it carries the circuit breaker. Whether it SERVES follows `cfg.ollama.enabled`. */
 	ollama: OllamaClient;
 	/** True while Ollama Cloud is enabled and out of cooldown, read live. */

package/src/wire/openai/request.ts

@@ -1,4 +1,4 @@
-import { acceptScope } from "../../context/scope.ts";
+import { acceptOrigin, acceptScope } from "../../context/scope.ts";
 import type {
 	RequestPolicy,
 	CompactionEdit,
@@ -341,6 +341,11 @@ export function parseChatRequest(body: unknown, headers: Headers): NormRequest {
 	const agentdoxGroup = acceptScope(headers.get("x-agentdox-group"));
 	const agentdoxPersonal = acceptScope(headers.get("x-agentdox-personal"));
 
+	// The workspace's repository fingerprint, for a front door that keeps a
+	// project registry. Same sentinel rule as the scope: omp sends the env-var
+	// NAME when the variable is unset, and a name is never a fingerprint.
+	const agentdoxOrigin = acceptOrigin(headers.get("x-agentdox-origin"));
+
 	// Subagent marker from the embed extension (sessions without a UI).
 	const isSubagent = (headers.get("x-omp-subagent") ?? "").trim() === "1";
 
@@ -409,6 +414,7 @@ export function parseChatRequest(body: unknown, headers: Headers): NormRequest {
 		agentdoxScope,
 		agentdoxGroup,
 		agentdoxPersonal,
+		agentdoxOrigin,
 		isSubagent,
 		...(policy === undefined ? {} : { policy }),
 		requestedModel,

package/src/wire/types.ts

@@ -109,6 +109,15 @@ export interface NormRequest {
 	 * renders LAST. Empty when absent or not a slug ⇒ no personal layer.
 	 */
 	agentdoxPersonal: string;
+	/**
+	 * The workspace's repository fingerprint from the `X-Agentdox-Origin`
+	 * request header (`<host>/<path>` of its git remote `origin`, see
+	 * `src/context/scope.ts`). Validated here, in one place, for a front door
+	 * with a project registry — the team edition — which uses it to find the
+	 * project two same-named folders are really about. The router's own bridge
+	 * has no registry and never reads it. Empty when absent or not a fingerprint.
+	 */
+	agentdoxOrigin: string;
 	/** `X-Omp-Subagent: 1`: the caller is an omp subagent (a session without a UI). */
 	isSubagent: boolean;
 	/**

package/test/anthropic-wire.test.ts

@@ -154,6 +154,12 @@ describe("parseMessagesRequest", () => {
 		expect(parseMessagesRequest(CLAUDE_CODE_BODY, new Headers({ "x-agentdox-group": "Not A Slug" })).agentdoxGroup).toBe("");
 	});
 
+	test("the origin fingerprint reaches the request on the Anthropic path too", () => {
+		expect(parseMessagesRequest(CLAUDE_CODE_BODY, new Headers({ "user-agent": "claude-cli/2.1.263" })).agentdoxOrigin).toBe("");
+		expect(parseMessagesRequest(CLAUDE_CODE_BODY, new Headers({ "x-agentdox-origin": "github.com/drewappling/omp-router" })).agentdoxOrigin).toBe("github.com/drewappling/omp-router");
+		expect(parseMessagesRequest(CLAUDE_CODE_BODY, new Headers({ "x-agentdox-origin": "https://github.com/a/b" })).agentdoxOrigin).toBe("");
+	});
+
 	test("a request captured from Claude Code 2.1: system inside messages, JSON user_id, adaptive thinking with effort, 23 custom tools", () => {
 		const fixture = JSON.parse(readFileSync("test/fixtures/harness/claude-code.json", "utf8")) as { headers: Record<string, string>; body: Record<string, unknown> };
 		const norm = parseMessagesRequest(fixture.body, new Headers(fixture.headers));

package/test/catalog-view.test.ts

@@ -0,0 +1,249 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { normalizeCatalogModel } from "../src/catalog/openrouter-catalog.ts";
+import { buildUpstreamModels } from "../src/catalog/static-catalog.ts";
+import type { CatalogModel } from "../src/catalog/types.ts";
+import { DEFAULT_CONFIG } from "../src/config/defaults.ts";
+import { completeUpstreamEntry } from "../src/config/upstreams.ts";
+import { catalogView, vendorOf, type CatalogView, type CatalogViewModel } from "../src/server/catalog-view.ts";
+import { startServer, type StartedServer } from "../src/server/http.ts";
+import { openDb } from "../src/util/sqlite.ts";
+
+/**
+ * The catalog as data for a front door's governance views: every model the
+ * router knows, and under a policy whether a turn could reach it and why not.
+ * Pinned over the pure view and over `GET /v1/router/catalog`, which judges
+ * with the router's own matcher — the same globs, the same order as
+ * `buildCandidates`, a pin that only bites when the pinned model is in.
+ */
+
+const FIXTURE = (await Bun.file("test/fixtures/openrouter-models.json").json()) as { data: unknown[] };
+
+function model(over: Partial<CatalogModel> & { slug: string }): CatalogModel {
+	return {
+		provider: "openrouter",
+		canonicalSlug: `${over.slug}-20260101`,
+		name: over.slug,
+		contextLength: 200_000,
+		supportsTools: true,
+		supportsReasoning: false,
+		reasoningMandatory: false,
+		supportsToolChoice: true,
+		inputModalities: ["text"],
+		price: { prompt: 0.000003, completion: 0.000015 },
+		priceTiers: [],
+		quality: { intelligence: 60 },
+		tokenizer: "Claude",
+		isFree: false,
+		createdAtMs: 0,
+		author: over.slug.split("/")[0] ?? "",
+		...over,
+	};
+}
+
+const vllm = completeUpstreamEntry({ id: "vllm", kind: "openai", baseUrl: "http://vllm:8000/v1", apiKey: "", models: [{ id: "meta-llama/Llama-3", input: 0, output: 0, contextLength: 8_000 }] });
+const azure = completeUpstreamEntry({ id: "azure-eu", kind: "azure", enabled: false, baseUrl: "https://r.openai.azure.com", apiKey: "k", models: [{ id: "gpt-4o-deploy", input: 2.5, output: 10, cachedInput: 1.25 }] });
+
+const MODELS: CatalogModel[] = [
+	model({ slug: "openai/gpt-5", quality: { intelligence: 70, coding: 72 }, maxCompletionTokens: 128_000, price: { prompt: 0.00000125, completion: 0.00001, cacheRead: 0.000000125 } }),
+	model({ slug: "anthropic/claude-sonnet-5", supportsReasoning: true }),
+	model({ slug: "anthropic/claude-haiku-5" }),
+	model({ slug: "anthropic/claude-opus-5:batch" }),
+	model({ slug: "liquid/lfm:free", isFree: true, price: { prompt: 0, completion: 0 } }),
+	model({ slug: "tencent/translator", supportsTools: false }),
+	model({ slug: "ollama/glm-5.3-flash", provider: "ollama", author: "ollama" }),
+	...buildUpstreamModels(vllm, []),
+	...buildUpstreamModels(azure, []),
+];
+
+const served = () => null;
+const bySlug = (view: CatalogView): Map<string, CatalogViewModel> => new Map(view.models.map((m) => [m.slug, m]));
+
+describe("catalogView", () => {
+	test("sorted by slug, prices per million, vendor per slug, and no verdict without a policy", () => {
+		const view = catalogView({ models: MODELS, fetchedAtMs: 123, unserved: served });
+		expect(view.fetchedAtMs).toBe(123);
+		expect(view.models.map((m) => m.slug)).toEqual([...MODELS.map((m) => m.slug)].sort());
+		const gpt = bySlug(view).get("openai/gpt-5")!;
+		expect(gpt).toEqual({
+			slug: "openai/gpt-5",
+			canonicalSlug: "openai/gpt-5-20260101",
+			name: "openai/gpt-5",
+			provider: "openrouter",
+			vendor: "openai",
+			contextLength: 200_000,
+			maxCompletionTokens: 128_000,
+			supportsTools: true,
+			supportsReasoning: false,
+			reasoningMandatory: false,
+			inputModalities: ["text"],
+			price: { prompt: 1.25, completion: 10, cacheRead: 0.125 },
+			quality: { intelligence: 70, coding: 72 },
+			isFree: false,
+		});
+		expect("admitted" in gpt).toBe(false);
+		expect("reason" in gpt).toBe(false);
+		expect("maxCompletionTokens" in bySlug(view).get("anthropic/claude-haiku-5")!).toBe(false);
+		// A named upstream's prices are per million already; they round-trip.
+		expect(bySlug(view).get("azure-eu/gpt-4o-deploy")!.price).toEqual({ prompt: 2.5, completion: 10, cacheRead: 1.25 });
+	});
+
+	test("vendor: the namespace before the first slash; a named upstream's model id may carry its own", () => {
+		expect(vendorOf({ slug: "anthropic/claude-sonnet-5", provider: "openrouter" })).toBe("anthropic");
+		expect(vendorOf({ slug: "ollama/glm-5.3-flash", provider: "ollama" })).toBe("ollama");
+		expect(vendorOf({ slug: "vllm/meta-llama/Llama-3", provider: "vllm" })).toBe("meta-llama");
+		expect(vendorOf({ slug: "azure-eu/gpt-4o-deploy", provider: "azure-eu" })).toBe("azure-eu");
+		const view = bySlug(catalogView({ models: MODELS, fetchedAtMs: 0, unserved: served }));
+		expect(view.get("vllm/meta-llama/Llama-3")!.vendor).toBe("meta-llama");
+		expect(view.get("azure-eu/gpt-4o-deploy")!.vendor).toBe("azure-eu");
+	});
+
+	test("an empty policy still judges: the router's own filters and the upstream's state", () => {
+		const unserved = (p: string) => (p === "azure-eu" ? "upstream azure-eu is disabled" : null);
+		const view = bySlug(catalogView({ models: MODELS, fetchedAtMs: 0, verdict: { filters: DEFAULT_CONFIG.filters }, unserved }));
+		expect(view.get("openai/gpt-5")).toMatchObject({ admitted: true });
+		expect("reason" in view.get("openai/gpt-5")!).toBe(false);
+		expect(view.get("anthropic/claude-opus-5:batch")).toMatchObject({ admitted: false, reason: "built-in deny: floating alias, batch endpoint, stealth, or meta-router" });
+		expect(view.get("liquid/lfm:free")).toMatchObject({ admitted: false, reason: "free models excluded (filters.includeFree)" });
+		expect(view.get("tencent/translator")).toMatchObject({ admitted: false, reason: "no tool support (filters.requireToolSupport)" });
+		expect(view.get("azure-eu/gpt-4o-deploy")).toMatchObject({ admitted: false, reason: "upstream azure-eu is disabled" });
+		// A $0 named-upstream model is self-hosted, never "free".
+		expect(view.get("vllm/meta-llama/Llama-3")).toMatchObject({ admitted: true });
+		// Filters relaxed: the same models come in.
+		const open = bySlug(catalogView({ models: MODELS, fetchedAtMs: 0, verdict: { filters: { ...DEFAULT_CONFIG.filters, includeFree: true, requireToolSupport: false } }, unserved: served }));
+		expect(open.get("liquid/lfm:free")!.admitted).toBe(true);
+		expect(open.get("tencent/translator")!.admitted).toBe(true);
+	});
+
+	test("allow list, deny glob and pin, in the order a turn applies them", () => {
+		const filters = { ...DEFAULT_CONFIG.filters, allow: ["anthropic/*", "vllm/*"], deny: ["*haiku*"] };
+		const view = bySlug(catalogView({ models: MODELS, fetchedAtMs: 0, verdict: { filters }, unserved: served }));
+		expect(view.get("openai/gpt-5")).toMatchObject({ admitted: false, reason: "not in the allow list" });
+		expect(view.get("anthropic/claude-haiku-5")).toMatchObject({ admitted: false, reason: "denied by *haiku*" });
+		expect(view.get("anthropic/claude-sonnet-5")).toMatchObject({ admitted: true });
+		expect(view.get("vllm/meta-llama/Llama-3")).toMatchObject({ admitted: true });
+		// A pin keeps every other model out.
+		const pinned = bySlug(catalogView({ models: MODELS, fetchedAtMs: 0, verdict: { filters, pin: "anthropic/claude-sonnet-5" }, unserved: served }));
+		expect(pinned.get("anthropic/claude-sonnet-5")).toMatchObject({ admitted: true });
+		expect(pinned.get("vllm/meta-llama/Llama-3")).toMatchObject({ admitted: false, reason: "pinned to anthropic/claude-sonnet-5" });
+		expect(pinned.get("openai/gpt-5")).toMatchObject({ admitted: false, reason: "not in the allow list" }); // the earlier reason stands
+		// A pin the filters drop is ignored, as select ignores it: nothing else is pinned out.
+		const dropped = bySlug(catalogView({ models: MODELS, fetchedAtMs: 0, verdict: { filters, pin: "anthropic/claude-haiku-5" }, unserved: served }));
+		expect(dropped.get("anthropic/claude-haiku-5")).toMatchObject({ admitted: false, reason: "denied by *haiku*" });
+		expect(dropped.get("anthropic/claude-sonnet-5")).toMatchObject({ admitted: true });
+		// So is a pin naming no model.
+		expect(bySlug(catalogView({ models: MODELS, fetchedAtMs: 0, verdict: { filters, pin: "nobody/here" }, unserved: served })).get("anthropic/claude-sonnet-5")!.admitted).toBe(true);
+	});
+});
+
+describe("GET /v1/router/catalog", () => {
+	let handle: StartedServer;
+	let empty: StartedServer;
+	const dir = mkdtempSync(join(tmpdir(), "amr-catalog-"));
+	const FETCHED = Date.now() - 60_000;
+	beforeAll(() => {
+		const cfg = structuredClone(DEFAULT_CONFIG);
+		cfg.server.host = "127.0.0.1";
+		cfg.server.port = 0;
+		cfg.server.apiKey = "k";
+		cfg.logLevel = "silent";
+		// Nothing reaches the network: the catalog is served from its on-disk
+		// cache (within TTL), the periodic refresh is off, and the base URL is dead.
+		cfg.openrouter.apiKey = "sk-test";
+		cfg.openrouter.baseUrl = "http://127.0.0.1:9/api/v1";
+		cfg.openrouter.catalogRefreshMs = 0;
+		cfg.benchmarks.enabled = false;
+		cfg.upstreams = [vllm, azure];
+		cfg.ledger.path = join(dir, "router.db");
+		const db = openDb(cfg.ledger.path);
+		db.run("INSERT INTO catalog_cache (id, payload, fetched_at_ms, etag, key_scoped) VALUES (1, ?, ?, NULL, 0)", [JSON.stringify(FIXTURE.data), FETCHED]);
+		db.close();
+		handle = startServer(cfg);
+		const bare = structuredClone(cfg);
+		bare.upstreams = [];
+		bare.ledger.path = join(dir, "empty.db");
+		empty = startServer(bare);
+	});
+	afterAll(async () => {
+		await handle.stop();
+		await empty.stop();
+		try {
+			rmSync(dir, { recursive: true, force: true });
+		} catch {
+			/* Windows may hold the WAL briefly */
+		}
+	});
+	const get = (path: string, port = handle.server.port) => fetch(`http://127.0.0.1:${port}${path}`, { headers: { authorization: "Bearer k" } });
+	const view = async (path: string): Promise<Map<string, CatalogViewModel>> => bySlug((await (await get(path)).json()) as CatalogView);
+
+	test("the catalog as data: authenticated, sorted, every upstream's models, no verdict without a policy", async () => {
+		expect((await fetch(`http://127.0.0.1:${handle.server.port}/v1/router/catalog`)).status).toBe(401);
+		const res = await get("/v1/router/catalog");
+		expect(res.status).toBe(200);
+		const body = (await res.json()) as CatalogView;
+		expect(body.fetchedAtMs).toBe(FETCHED);
+		const slugs = body.models.map((m) => m.slug);
+		expect(slugs).toEqual([...slugs].sort());
+		// Every OpenRouter model the fixture normalises to, plus both named upstreams' — the disabled one too.
+		expect(slugs).toHaveLength(FIXTURE.data.filter((m) => normalizeCatalogModel(m) !== null).length + 2);
+		const models = bySlug(body);
+		const opus = models.get("anthropic/claude-opus-5")!;
+		const raw = normalizeCatalogModel(FIXTURE.data.find((m) => (m as { id: string }).id === "anthropic/claude-opus-5"))!;
+		expect(opus).toEqual({
+			slug: "anthropic/claude-opus-5",
+			canonicalSlug: raw.canonicalSlug,
+			name: raw.name,
+			provider: "openrouter",
+			vendor: "anthropic",
+			contextLength: raw.contextLength,
+			maxCompletionTokens: 128_000,
+			supportsTools: true,
+			supportsReasoning: raw.supportsReasoning,
+			reasoningMandatory: raw.reasoningMandatory,
+			inputModalities: raw.inputModalities,
+			price: { prompt: 5, completion: raw.price.completion * 1e6, cacheRead: 0.5, ...(raw.price.cacheWrite === undefined ? {} : { cacheWrite: raw.price.cacheWrite * 1e6 }) },
+			quality: raw.quality,
+			isFree: false,
+		});
+		expect(models.get("vllm/meta-llama/Llama-3")).toMatchObject({ provider: "vllm", vendor: "meta-llama", contextLength: 8_000 });
+		expect(models.get("azure-eu/gpt-4o-deploy")).toMatchObject({ provider: "azure-eu", vendor: "azure-eu", price: { prompt: 2.5, completion: 10, cacheRead: 1.25 } });
+		expect(body.models.some((m) => "admitted" in m || "reason" in m)).toBe(false);
+	});
+
+	test("judged under a policy: allow, deny, pin, the router's filters and the upstream's state", async () => {
+		const allowed = await view(`/v1/router/catalog?policy=${encodeURIComponent(JSON.stringify({ allow: ["anthropic/*", "azure-eu/*"], deny: ["anthropic/claude-opus-5"], maxTier: "simple" }))}`);
+		expect(allowed.get("anthropic/claude-sonnet-4.5")).toMatchObject({ admitted: true });
+		expect(allowed.get("anthropic/claude-opus-5")).toMatchObject({ admitted: false, reason: "denied by anthropic/claude-opus-5" });
+		expect(allowed.get("anthropic/claude-opus-5:batch")).toMatchObject({ admitted: false, reason: "built-in deny: floating alias, batch endpoint, stealth, or meta-router" });
+		expect(allowed.get("openai/gpt-5.6-luna")).toMatchObject({ admitted: false, reason: "not in the allow list" });
+		expect(allowed.get("azure-eu/gpt-4o-deploy")).toMatchObject({ admitted: false, reason: "upstream azure-eu is disabled" });
+		// The configured deny list stays in force under a policy's, as applyRequestPolicy adds rather than replaces.
+		const pinned = await view(`/v1/router/catalog?policy=${encodeURIComponent(JSON.stringify({ pin: "vllm/meta-llama/Llama-3" }))}`);
+		expect(pinned.get("vllm/meta-llama/Llama-3")).toMatchObject({ admitted: true });
+		expect(pinned.get("anthropic/claude-sonnet-4.5")).toMatchObject({ admitted: false, reason: "pinned to vllm/meta-llama/Llama-3" });
+		expect(pinned.get("tencent/hy-mt2-1.8b")).toMatchObject({ admitted: false, reason: "no tool support (filters.requireToolSupport)" });
+		expect(pinned.get("liquid/lfm-2.5-2.6b:free")).toMatchObject({ admitted: false, reason: "free models excluded (filters.includeFree)" });
+		// `{}` is a policy too: every model carries a verdict.
+		const plain = await view("/v1/router/catalog?policy=%7B%7D");
+		expect(plain.get("anthropic/claude-sonnet-4.5")).toMatchObject({ admitted: true });
+		expect([...plain.values()].every((m) => typeof m.admitted === "boolean")).toBe(true);
+	});
+
+	test("a malformed policy is a 400 in the wire error shape", async () => {
+		for (const bad of ["%7B", "not-json", "%5B%5D", "null", "1"]) {
+			const res = await get(`/v1/router/catalog?policy=${bad}`);
+			expect(res.status).toBe(400);
+			const body = (await res.json()) as { error: { message: string; type: string; code: string } };
+			expect(body.error.code).toBe("invalid_request_error");
+			expect(body.error.message).toContain("policy");
+		}
+	});
+
+	test("before the first fetch: empty, never a wait", async () => {
+		expect((await (await get("/v1/router/catalog", empty.server.port)).json()) as CatalogView).toEqual({ fetchedAtMs: 0, models: [] });
+		expect((await (await get("/v1/router/catalog?policy=%7B%7D", empty.server.port)).json()) as CatalogView).toEqual({ fetchedAtMs: 0, models: [] });
+	});
+});

package/test/embed-logic.test.ts

@@ -1,11 +1,12 @@
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
-import { mkdtempSync, rmSync } from "node:fs";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
 import {
 	buildProviderConfig,
 	deriveAgentdoxScope,
+	deriveWorkspaceOrigin,
 	EMBED_PORT_FILE,
 	EMBED_PROVIDER_ID,
 	embedPortPath,
@@ -207,3 +208,87 @@ describe("agentdox scope", () => {
 		expect(buildProviderConfig(1234, cfg, "/x/ashlands").agentdoxScope).toBeUndefined();
 	});
 });
+
+describe("workspace origin", () => {
+	const CONFIG = ['[core]', '\trepositoryformatversion = 0', '[remote "origin"]', '\turl = https://github.com/DrewAppling/omp-router.git', '\tfetch = +refs/heads/*:refs/remotes/origin/*', '[branch "main"]', '\tremote = origin', ''].join("\n");
+	let root: string;
+	beforeAll(() => {
+		root = mkdtempSync(join(tmpdir(), "amr-origin-"));
+	});
+	afterAll(() => {
+		rmSync(root, { recursive: true, force: true });
+	});
+
+	test("a plain repository: the remote from .git/config, also from a subdirectory", () => {
+		const repo = join(root, "repo");
+		mkdirSync(join(repo, ".git"), { recursive: true });
+		writeFileSync(join(repo, ".git", "config"), CONFIG);
+		mkdirSync(join(repo, "src", "deep"), { recursive: true });
+		expect(deriveWorkspaceOrigin(repo)).toBe("github.com/drewappling/omp-router");
+		expect(deriveWorkspaceOrigin(join(repo, "src", "deep"))).toBe("github.com/drewappling/omp-router");
+		// The scope is still the folder, untouched by any of this.
+		expect(deriveAgentdoxScope(repo)).toBe("repo");
+	});
+
+	test("a worktree: .git is a file naming the git dir, whose shared config is one hop further", () => {
+		// The main checkout holds the config; the worktree's own dir only points at it.
+		const main = join(root, "main");
+		mkdirSync(join(main, ".git", "worktrees", "wt"), { recursive: true });
+		writeFileSync(join(main, ".git", "config"), CONFIG.replace("github.com/DrewAppling/omp-router.git", "gitlab.example.com:2222/team/api/").replace("https://", "ssh://git@"));
+		writeFileSync(join(main, ".git", "worktrees", "wt", "commondir"), "../..\n");
+		const wt = join(root, "wt");
+		mkdirSync(wt, { recursive: true });
+		writeFileSync(join(wt, ".git"), `gitdir: ${join(main, ".git", "worktrees", "wt")}\n`);
+		expect(deriveWorkspaceOrigin(wt)).toBe("gitlab.example.com/team/api");
+		// A submodule-style pointer: the named dir has its own config, relative to the .git file.
+		const sub = join(root, "sub");
+		mkdirSync(join(sub, "modules", "lib"), { recursive: true });
+		mkdirSync(join(sub, "lib"), { recursive: true });
+		writeFileSync(join(sub, "modules", "lib", "config"), CONFIG.replace("DrewAppling/omp-router", "org/lib"));
+		writeFileSync(join(sub, "lib", ".git"), "gitdir: ../modules/lib\n");
+		expect(deriveWorkspaceOrigin(join(sub, "lib"))).toBe("github.com/org/lib");
+	});
+
+	test("no remote, a local remote, no repository, or nothing at all: no fingerprint, never a throw", () => {
+		const bare = join(root, "bare");
+		mkdirSync(join(bare, ".git"), { recursive: true });
+		writeFileSync(join(bare, ".git", "config"), "[core]\n\tbare = false\n");
+		expect(deriveWorkspaceOrigin(bare)).toBe("");
+		const local = join(root, "local");
+		mkdirSync(join(local, ".git"), { recursive: true });
+		writeFileSync(join(local, ".git", "config"), '[remote "origin"]\n\turl = /srv/git/local.git\n');
+		expect(deriveWorkspaceOrigin(local)).toBe("");
+		// A `.git` file that leads nowhere is the boundary: the walk stops there.
+		const dangling = join(root, "repo", "dangling");
+		mkdirSync(dangling, { recursive: true });
+		writeFileSync(join(dangling, ".git"), "gitdir: /nowhere/at/all\n");
+		expect(deriveWorkspaceOrigin(dangling)).toBe("");
+		expect(deriveWorkspaceOrigin(join(root, "not-a-repo", "missing"))).toBe("");
+		expect(deriveWorkspaceOrigin("")).toBe("");
+		expect(
+			deriveWorkspaceOrigin("/anywhere", () => {
+				throw new Error("disk on fire");
+			}),
+		).toBe("");
+	});
+
+	test("the first url under [remote \"origin\"] wins; other remotes do not count", () => {
+		const read = () => '[remote "upstream"]\n\turl = https://github.com/other/thing.git\n[remote "origin"]\n\turl = git@github.com:me/thing.git\n\turl = https://github.com/me/second.git\n';
+		expect(deriveWorkspaceOrigin("/x/repo", read)).toBe("github.com/me/thing");
+		expect(deriveWorkspaceOrigin("/x/repo", () => '[remote "upstream"]\n\turl = https://github.com/other/thing.git\n')).toBe("");
+	});
+
+	test("buildProviderConfig carries the origin beside the scope, only where the scope goes", () => {
+		const base = {
+			server: { host: "127.0.0.1" },
+			profiles: [],
+			ledger: { fallbackBlend: { inputPerMtok: 1, outputPerMtok: 1 } },
+		};
+		const on = buildProviderConfig(1234, { ...base, context: { enabled: true, defaultScope: "" } }, "/x/ashlands", "github.com/me/ashlands");
+		expect(on.agentdoxScope).toBe("ashlands");
+		expect(on.agentdoxOrigin).toBe("github.com/me/ashlands");
+		expect(buildProviderConfig(1234, { ...base, context: { enabled: true, defaultScope: "" } }, "/x/ashlands", "").agentdoxOrigin).toBeUndefined();
+		expect(buildProviderConfig(1234, { ...base, context: { enabled: true, defaultScope: "" } }, "/x/ashlands").agentdoxOrigin).toBeUndefined();
+		expect(buildProviderConfig(1234, { ...base, context: { enabled: false, defaultScope: "" } }, "/x/ashlands", "github.com/me/ashlands").agentdoxOrigin).toBeUndefined();
+	});
+});

package/test/escalate.test.ts

@@ -26,6 +26,7 @@ function req(messages: NormMessage[] = [], over: Partial<NormRequest> = {}): Nor
 		agentdoxScope: "",
 		agentdoxGroup: "",
 		agentdoxPersonal: "",
+		agentdoxOrigin: "",
 		isSubagent: false,
 		requestedModel: "auto",
 		messages,

package/test/failover.test.ts

@@ -98,6 +98,7 @@ function mkReq(): NormRequest {
 		agentdoxScope: "",
 		agentdoxGroup: "",
 		agentdoxPersonal: "",
+		agentdoxOrigin: "",
 		isSubagent: false,
 		requestedModel: "auto",
 		messages: [{ role: "user", text: "hi", images: 0, textBytes: 2, toolCalls: [] }],