auto-model-router 0.6.1 → 0.6.2

package/.omp-plugin/marketplace.json

@@ -7,14 +7,14 @@
   },
   "metadata": {
     "description": "auto-model-router: a local cost/complexity-aware model router for Oh My Pi, backed by OpenRouter",
-    "version": "0.6.1",
+    "version": "0.6.2",
     "pluginRoot": "."
   },
   "plugins": [
     {
       "name": "auto-model-router",
       "description": "Local cost/complexity-aware model router for Oh My Pi, backed by OpenRouter. Runs in-process, routes per turn by price and task complexity, with budget caps, mid-stream escalation, and cache-aware hysteresis.",
-      "version": "0.6.1",
+      "version": "0.6.2",
       "author": {
         "name": "drewappling",
         "email": "drewappling@gmail.com"

package/README.md

@@ -1149,6 +1149,13 @@ What happens once it is on:
   cooldown.
 - **Ollama reports no cost per response**, so the ledger records the
   predicted figure at list price for those rows.
+- **Ollama Cloud alone works.** With `ollama.enabled` and no OpenRouter key,
+  the router routes over Ollama's models only. OpenRouter's catalog is public,
+  so it is still read (the twins' benchmarks and capabilities come from it),
+  but its models are never candidates; `/health` lists what can serve under
+  `serving` (`["ollama"]`, `["openrouter","ollama"]`, …). Tier coverage is
+  whatever Ollama's catalog spans; a tier with nothing in it relaxes to the
+  best available band, as it does under any other narrowing.
 
 Ollama's compatibility layer differs from OpenRouter's in a few ways the
 router handles for you: no `models[]` fallback cascade, no `tool_choice`,

package/omp-extension/report-logic.ts

@@ -104,6 +104,8 @@ export function renderSoftFailureSpikes(spikes: readonly SoftFailureSpikeView[]
 export interface HealthSnapshot {
 	status?: string;
 	apiKeyConfigured?: boolean;
+	/** Upstreams that can serve a turn right now (`openrouter` needs its key; `ollama` needs to be on and out of cooldown). */
+	serving?: string[];
 	apiKeySource?: string;
 	agentdox?: { url?: string; defaultScope?: string; recordTurns?: boolean } | null;
 	ollama?: {
@@ -133,7 +135,9 @@ const mins = (ms: number): string => (ms >= 3_600_000 ? `${(ms / 3_600_000).toFi
 /** Renders `/health` as a few plain lines for the transcript. */
 export function renderStatus(baseUrl: string, h: HealthSnapshot, nowMs = Date.now()): string {
 	const out: string[] = [`auto-model-router at ${baseUrl}: ${h.status ?? "unknown"}`];
-	out.push(`openrouter: key ${h.apiKeyConfigured === true ? `configured (${h.apiKeySource ?? "?"})` : "MISSING"}`);
+	const orKey = h.apiKeyConfigured === true ? `configured (${h.apiKeySource ?? "?"})` : h.serving?.includes("ollama") === true ? "missing · routing over ollama cloud only" : "MISSING";
+	out.push(`openrouter: key ${orKey}`);
+	if (h.serving !== undefined && h.serving.length === 0) out.push("serving: NOTHING (no OpenRouter key and Ollama off or cooling down)");
 	const c = h.catalog;
 	if (c !== undefined && c !== null) {
 		const shrink = c.shrink !== undefined && c.shrink !== null ? ` · SHRANK ${c.shrink.fromModels ?? "?"} -> ${c.shrink.toModels ?? "?"}` : "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auto-model-router",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "private": false,
   "description": "Local cost/complexity-aware model router for Oh My Pi, backed by OpenRouter",
   "type": "module",

package/src/catalog/composite.ts

@@ -10,6 +10,13 @@
  * Ollama models are left out entirely: a candidate that will 402 or 429 is
  * not a candidate, and hiding it here means the turn routes straight to an
  * OpenRouter model instead of paying a doomed dispatch first.
+ *
+ * The same rule covers OpenRouter: without a key its models cannot be
+ * dispatched (its catalog is public, so they would still be listed), and
+ * `serveOpenRouter` leaves them out so an Ollama-only deployment routes over
+ * Ollama Cloud alone instead of picking models that 401 at dispatch time. The
+ * OpenRouter catalog is still fetched: Ollama's models borrow their twins'
+ * benchmarks and capabilities from it.
  */
 
 import type { OllamaAvailability } from "../upstream/ollama.ts";
@@ -25,6 +32,8 @@ export interface CompositeBias {
 	usage: OllamaUsageSource;
 	/** When given, read on every use instead of the static pair, so a config hot reload applies. */
 	live?: () => { costBias: number; biasUntilUsage: number };
+	/** False when OpenRouter cannot dispatch (no key): its models are listed for metadata only, never served. Default true. */
+	serveOpenRouter?: () => boolean;
 }
 
 export function createCompositeCatalog(
@@ -36,6 +45,7 @@ export function createCompositeCatalog(
 	let lastBase: CatalogSnapshot | null = null;
 	let lastOllama: readonly CatalogModel[] = [];
 	let lastAvailable = true;
+	let lastServeBase = true;
 	let lastBias = 1;
 	let merged: CatalogSnapshot | null = null;
 
@@ -47,13 +57,15 @@ export function createCompositeCatalog(
 
 	function combine(base: CatalogSnapshot, models: readonly CatalogModel[]): CatalogSnapshot {
 		const available = availability.available();
+		const serveBase = bias.serveOpenRouter?.() ?? true;
 		const providerBias = currentBias();
-		if (merged !== null && base === lastBase && models === lastOllama && available === lastAvailable && providerBias === lastBias) return merged;
+		if (merged !== null && base === lastBase && models === lastOllama && available === lastAvailable && serveBase === lastServeBase && providerBias === lastBias) return merged;
 		lastBase = base;
 		lastOllama = models;
 		lastAvailable = available;
+		lastServeBase = serveBase;
 		lastBias = providerBias;
-		merged = mergeSnapshots(base, available ? models : []);
+		merged = serveBase ? mergeSnapshots(base, available ? models : []) : { ...base, models: available ? [...models] : [] };
 		// A fresh object either way once anything changed; stamp the live bias so
 		// candidate scoring reads it off the snapshot it is ranking.
 		merged = { ...merged, providerBias: { ollama: providerBias } };

package/src/server/http.ts

@@ -241,7 +241,8 @@ export function startServer(cfg: RouterConfig): StartedServer {
 	}
 
 	if (cfg.openrouter.apiKey === "") {
-		log.warn("OPENROUTER_API_KEY is not set; /v1/chat/completions will fail at dispatch time");
+		if (ollama !== null) log.warn("no OpenRouter key: routing over Ollama Cloud models only (OpenRouter's catalog is read for metadata, never served)");
+		else log.warn("OPENROUTER_API_KEY is not set and Ollama is off; /v1/chat/completions will fail at dispatch time");
 	}
 	if (ollama !== null) {
 		log.info("ollama cloud upstream enabled", {
@@ -608,6 +609,9 @@ export function startServer(cfg: RouterConfig): StartedServer {
 					return json({
 						status: "ok",
 						apiKeyConfigured: cfg.openrouter.apiKey !== "",
+						// Which upstreams turns can actually be served from: OpenRouter needs
+						// its key; Ollama needs to be on and out of cooldown.
+						serving: [...(cfg.openrouter.apiKey !== "" ? ["openrouter"] : []), ...(ollama !== null && ollama.available() ? ["ollama"] : [])],
 						// Provenance only; never the key itself.
 						apiKeySource: apiKeySource(cfg).source,
 						// Provenance only; never the agentdox token itself.

package/src/server/providers.ts

@@ -55,6 +55,7 @@ export function createProviders(cfg: RouterConfig, db: Database, log: Logger = c
 			biasUntilUsage: cfg.ollama.biasUntilUsage,
 			usage: ollamaUsage,
 			live: () => ({ costBias: cfg.ollama.costBias, biasUntilUsage: cfg.ollama.biasUntilUsage }),
+			serveOpenRouter: () => cfg.openrouter.apiKey !== "",
 		}),
 		ollama,
 		ollamaUsage,

package/test/ollama.test.ts

@@ -398,6 +398,32 @@ describe("multi upstream + composite catalog", () => {
 		expect(catalog.ollamaModels()).toHaveLength(3); // still known, just hidden
 		expect(mergeSnapshots(base, []).models).toBe(base.models);
 	});
+
+	test("without an OpenRouter key only the Ollama models are served; the OpenRouter catalog still feeds metadata and lookups", async () => {
+		const base: CatalogSnapshot = { models: OR_MODELS, fetchedAtMs: 1, keyScoped: false };
+		const openrouter: CatalogSource = { get: async () => base, refresh: async () => base, peek: () => base, find: (s) => OR_MODELS.find((m) => m.slug === s) };
+		const ollamaModels = buildOllamaModels({ listings: listings(), openrouter: OR_MODELS, cfg: OLLAMA, log });
+		let available = true;
+		let keyed = false;
+		const source = { get: async () => ollamaModels, peek: () => ollamaModels, invalidate: () => {} };
+		const breaker = { available: () => available, cooldownUntilMs: () => null, lastTrip: () => null };
+		const catalog = createCompositeCatalog(openrouter, source, breaker, { costBias: 1, biasUntilUsage: 1, usage: NO_USAGE, serveOpenRouter: () => keyed });
+
+		const a = await catalog.get();
+		expect(a.models.map((m) => m.provider)).toEqual(["ollama", "ollama", "ollama"]);
+		expect(a.fetchedAtMs).toBe(1);
+		expect(await catalog.get()).toBe(a); // memoised while nothing changes
+		expect(catalog.find("z-ai/glm-5.3-flash")?.provider).toBe("openrouter"); // lookups (served-model attribution) still resolve
+		expect(a.models[0]?.quality).toEqual(OR_MODELS.find((m) => m.slug === "z-ai/glm-5.3-flash")?.quality); // twin metadata borrowed
+
+		available = false;
+		expect((await catalog.get()).models).toEqual([]); // nothing can serve: breaker open, no key
+		available = true;
+		keyed = true; // a hot-reloaded key brings OpenRouter back without a restart
+		const c = await catalog.get();
+		expect(c.models.length).toBe(OR_MODELS.length + 3);
+		expect(c).not.toBe(a);
+	});
 });
 
 describe("selection over a mixed catalog", () => {

package/test/report-logic.test.ts

@@ -99,6 +99,8 @@ describe("renderStatus", () => {
 	test("degrades cleanly when sections are absent", () => {
 		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");
+		expect(renderStatus("http://h", { status: "ok", apiKeyConfigured: false, serving: [] })).toContain("serving: NOTHING");
 		expect(text).toContain("catalog: not fetched yet");
 		expect(text).toContain("ollama cloud: disabled");
 		expect(text).toContain("agentdox: off");