auto-model-router 0.6.1 → 0.6.3

package/.github/workflows/release.yml

@@ -26,16 +26,21 @@ jobs:
       - name: Install dependencies
         run: npm install
 
-      - name: Check if version already published
+      # Publish only when the tagged version is NEWER than npm's latest. A tag that
+      # reaches GitHub late (git push --tags after the fact) must never publish an
+      # old version as a fresh release.
+      - name: Check if version is newer than the published one
         id: version
         run: |
           LOCAL=$(node -p "require('./package.json').version")
           PUBLISHED=$(npm view auto-model-router version 2>/dev/null || echo "0.0.0")
           echo "local=$LOCAL published=$PUBLISHED"
-          if [ "$LOCAL" != "$PUBLISHED" ]; then
+          NEWEST=$(printf '%s\n' "$PUBLISHED" "$LOCAL" | sort -V | tail -1)
+          if [ "$LOCAL" != "$PUBLISHED" ] && [ "$NEWEST" = "$LOCAL" ]; then
             echo "changed=true" >> "$GITHUB_OUTPUT"
           else
             echo "changed=false" >> "$GITHUB_OUTPUT"
+            echo "::warning::$LOCAL is not newer than the published $PUBLISHED; nothing published"
           fi
 
       - name: Publish to npm
@@ -45,6 +50,7 @@ jobs:
           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
 
       - name: Create GitHub Release
+        if: steps.version.outputs.changed == 'true'
         uses: softprops/action-gh-release@v2
         with:
           generate_release_notes: true

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.3",
     "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.3",
       "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`,
@@ -1260,6 +1267,11 @@ adds the Codex provider and the Aider settings, and prints (or with `--profile`
 the environment lines for Claude Code. `--harness omp,hermes` restricts it; `--dry-run`
 shows the changes. Delete `remote.json` to go back to a local router. (`join` is an alias.)
 
+In remote mode omp sends `X-Agentdox-Scope` derived from the workspace folder, so one
+remote router serves every repo on the machine with that repo's shared context. The remote
+decides what to do with it: a team edition that pins a scope on the member's group
+overrides it, and one that pins none follows the workspace.
+
 ## Multiple coding harnesses, one router
 
 **One router process for everything.** omp's embed extension binds a private

package/omp-extension/remote-logic.ts

@@ -63,7 +63,7 @@ export const REMOTE_MODELS: readonly { id: string; name: string }[] = [
  * the session and subagent tags, and the virtual models. Costs are USD per
  * million tokens, like the embedded config.
  */
-export function remoteProviderRegistration(remote: RemoteRouter, sessionId: string, subagent: boolean, blend: { inputPerMtok: number; outputPerMtok: number }): {
+export function remoteProviderRegistration(remote: RemoteRouter, sessionId: string, subagent: boolean, blend: { inputPerMtok: number; outputPerMtok: number }, agentdoxScope = ""): {
 	baseUrl: string;
 	api: string;
 	apiKey: string;
@@ -73,6 +73,10 @@ export function remoteProviderRegistration(remote: RemoteRouter, sessionId: stri
 	const headers: Record<string, string> = {};
 	if (sessionId !== "") headers["X-Omp-Session"] = sessionId;
 	if (subagent) headers["X-Omp-Subagent"] = "1";
+	// Which project's shared context this workspace draws on. The bridge lives on the remote
+	// router, so this is sent whatever the local config says; the remote decides what to do with
+	// it (a team that pins a scope for the group overrides it, and one that pins none follows it).
+	if (agentdoxScope !== "") headers["X-Agentdox-Scope"] = agentdoxScope;
 	const round = (v: number): number => Math.round(v * 1e4) / 1e4;
 	return {
 		baseUrl: `${remote.url}/v1`,

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/omp-extension/router-embed.ts

@@ -32,17 +32,7 @@ import type { RouterConfig } from "../src/config/types.ts";
 
 import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
 
-import {
-	buildProviderConfig,
-	EMBED_DUMMY_API_KEY,
-	EMBED_PROVIDER_ID,
-	embedPortPath,
-	readEmbedPort,
-	modelsYmlPort,
-	probeEmbed,
-	resolveEmbedPort,
-	writeEmbedPort,
-} from "./embed-logic.ts";
+import { EMBED_DUMMY_API_KEY, EMBED_PROVIDER_ID, buildProviderConfig, deriveAgentdoxScope, embedPortPath, modelsYmlPort, probeEmbed, readEmbedPort, resolveEmbedPort, writeEmbedPort } from "./embed-logic.ts";
 
 /** omp's models.yml as text, or "" when it does not exist / cannot be read. */
 function readModelsYml(): string {
@@ -173,7 +163,7 @@ export default function (pi: ExtensionAPI): void {
 		// locally; the other extensions find it through remote.json.
 		const remote = readRemoteRouter(routerHome());
 		if (remote !== null) {
-			pi.registerProvider(EMBED_PROVIDER_ID, remoteProviderRegistration(remote, sessionId, !ctx.hasUI, cfg.ledger.fallbackBlend));
+			pi.registerProvider(EMBED_PROVIDER_ID, remoteProviderRegistration(remote, sessionId, !ctx.hasUI, cfg.ledger.fallbackBlend, deriveAgentdoxScope(process.cwd())));
 			pi.setLabel(`auto-model-router remote (${remote.url.replace(/^https?:\/\//, "")})`);
 			writeEmbedLog(`remote mode url=${remote.url} user=${remote.userId} session=${sessionId}`);
 			return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auto-model-router",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "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/remote.test.ts

@@ -22,6 +22,10 @@ describe("remote-logic", () => {
 		expect(reg).toMatchObject({ baseUrl: "https://team.example/v1", api: "openai-completions", apiKey: "amrt_k", headers: { "X-Omp-Session": "sess-1", "X-Omp-Subagent": "1" } });
 		expect(reg.models.map((m) => m.id)).toEqual(["auto", "auto-cheap", "auto-max"]);
 		expect(reg.models[0]!.cost).toEqual({ input: 1, output: 4, cacheRead: 0.1, cacheWrite: 1.25 });
+		// The workspace's project travels with the turn, so one remote router serves every repo on
+		// the machine with the right context; the remote may still override it.
+		expect(reg.headers["X-Agentdox-Scope"]).toBeUndefined();
+		expect(remoteProviderRegistration(t, "", false, { inputPerMtok: 1, outputPerMtok: 4 }, "omp-router").headers).toEqual({ "X-Agentdox-Scope": "omp-router" });
 		const dir = mkdtempSync(join(tmpdir(), "amr-remote-"));
 		expect(readRemoteRouter(dir)).toBeNull();
 		writeFileSync(join(dir, "remote.json"), JSON.stringify({ url: "https://t", key: "k" }));

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");