auto-model-router 0.3.1 → 0.3.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.3.1",
+    "version": "0.3.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.3.1",
+      "version": "0.3.2",
       "author": {
         "name": "drewappling",
         "email": "drewappling@gmail.com"

package/README.md

@@ -623,7 +623,7 @@ an OpenRouter sibling). See [Ollama Cloud](#ollama-cloud) below.
 | `usagePollMs` | `600000` (10 min) | How often plan usage is re-read. `0` disables it (static bias). Needs the API key; the daemon path without one keeps a static bias. |
 | `quotaCooldownMs` | `900000` | Route around Ollama this long after a 402 (credits exhausted). |
 | `rateLimitCooldownMs` | `60000` | Route around Ollama this long after a 429 (concurrency cap). |
-| `planCreditsUsd` | `0` | Dollar value of the plan's included monthly credits (Pro 60, Max 300). Lets `/health` and `/router status` show ollama.com's plan reading as dollars next to the ledger's figure. `0` shows the share only. |
+| `planCreditsUsd` | `0` | Override for the plan's included monthly credits. `0` detects the plan from ollama.com (`POST /api/me`) and applies its published allowance (Pro $60, Max $300), so `/health` and `/router status` show ollama.com's reading as dollars next to the ledger's figure. Set it for a plan the router does not know. |
 
 ### `tiers` — per-tier economic envelope
 
@@ -824,8 +824,9 @@ What happens once it is on:
   previous prompt is taken as the cached prefix and priced at the cached
   rate; a first turn, a switch, or a longer gap is priced cold. The ledger
   flags these rows (`usage.cachedEstimated`) and reports show their cache
-  rate as `~N%`. Set `planCreditsUsd` (Pro 60, Max 300) to see ollama.com's
-  own dollar reading in `/router status` as the cross-check.
+  rate as `~N%`. `/router status` shows ollama.com's own dollar reading as
+  the cross-check: the plan is read from `POST /api/me` and its published
+  allowance applied (`planCreditsUsd` overrides it).
 - **Same economics, same failover.** Candidates from both providers are ranked
   together; `costBias` tilts the comparison while a plan's included credits
   would otherwise go unused. **Credit-aware by default:** the router reads the

package/omp-extension/report-logic.ts

@@ -74,8 +74,8 @@ export interface HealthSnapshot {
 		available?: boolean;
 		cooldownUntilMs?: number | null;
 		lastTrip?: { kind?: string; atMs?: number; message?: string } | null;
-		usage?: { monthlyUsedFraction?: number | null; activityCostUsd?: number | null; fetchedAtMs?: number | null } | null;
-		meter?: { usedUsd?: number; creditsUsd?: number } | null;
+		usage?: { monthlyUsedFraction?: number | null; activityCostUsd?: number | null; plan?: string | null; fetchedAtMs?: number | null } | null;
+		meter?: { usedUsd?: number; creditsUsd?: number; plan?: string | null } | null;
 		costBias?: { configured?: number; effective?: number; biasUntilUsage?: number };
 	} | null;
 	catalog?: {
@@ -106,7 +106,8 @@ export function renderStatus(baseUrl: string, h: HealthSnapshot, nowMs = Date.no
 		const avail = o.available === true ? "available" : `COOLING DOWN${o.cooldownUntilMs ? ` until ${new Date(o.cooldownUntilMs).toLocaleTimeString()}` : ""}`;
 		const frac = o.usage?.monthlyUsedFraction;
 		const meter = o.meter !== undefined && o.meter !== null && o.meter.usedUsd !== undefined ? ` ($${o.meter.usedUsd.toFixed(2)} of $${o.meter.creditsUsd ?? "?"})` : "";
-		const usage = frac === undefined || frac === null ? "plan usage unknown" : `plan usage ${(frac * 100).toFixed(1)}%${meter}`;
+		const planName = o.meter?.plan ?? o.usage?.plan ?? null;
+		const usage = frac === undefined || frac === null ? "plan usage unknown" : `${planName === null ? "plan" : `${planName} plan`} usage ${(frac * 100).toFixed(1)}%${meter}`;
 		const bias = o.costBias === undefined ? "" : ` · cost bias ×${o.costBias.effective ?? o.costBias.configured ?? 1} (until ${((o.costBias.biasUntilUsage ?? 1) * 100).toFixed(0)}%)`;
 		const trip = o.lastTrip !== undefined && o.lastTrip !== null ? ` · last trip ${o.lastTrip.kind ?? "?"}${o.lastTrip.atMs ? ` ${mins(nowMs - o.lastTrip.atMs)} ago` : ""}` : "";
 		out.push(`ollama cloud: ${o.models ?? 0} models · ${avail} · key ${o.apiKeySource ?? "?"} · ${usage}${bias}${trip}`);

package/package.json

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

package/src/cli/config-wizard.ts

@@ -143,7 +143,7 @@ export const WIZARD_SECTIONS: readonly SectionSpec[] = [
 			{ path: "ollama.usagePollMs", label: "Plan usage poll", kind: "number", min: 0, hint: "ms, 0=off" },
 			{ path: "ollama.quotaCooldownMs", label: "Quota (402) cooldown", kind: "number", min: 0, hint: "ms" },
 			{ path: "ollama.rateLimitCooldownMs", label: "Rate-limit (429) cooldown", kind: "number", min: 0, hint: "ms" },
-			{ path: "ollama.planCreditsUsd", label: "Plan credits per month $", kind: "number", min: 0, hint: "Pro 60, Max 300; 0=unknown" },
+			{ path: "ollama.planCreditsUsd", label: "Plan credits per month $", kind: "number", min: 0, hint: "0=detect plan (Pro 60, Max 300)" },
 		],
 	},
 	{

package/src/config/types.ts

@@ -115,9 +115,9 @@ export interface OllamaConfig {
 	/** How long to route around Ollama after a 429 (concurrency cap), ms. */
 	rateLimitCooldownMs: number;
 	/**
-	 * Dollar value of the plan's included monthly credits (Pro 60, Max 300), so
-	 * the plan-relative usage reading can be shown as dollars beside the
-	 * ledger's own Ollama figure. 0 ⇒ unknown: usage is shown as a share only.
+	 * Override for the plan's included monthly credits, USD. 0 (default) reads
+	 * the plan from ollama.com (`POST /api/me`) and applies its published
+	 * allowance (Pro 60, Max 300); set this for a plan the router does not know.
 	 */
 	planCreditsUsd: number;
 }

package/src/upstream/ollama-usage.ts

@@ -35,9 +35,26 @@ export interface OllamaUsage {
 	activityCostUsd: number | null;
 	/** Requests this billing month, summed over models. */
 	requestsThisMonth: number;
+	/** Subscription name from `POST /api/me` (`pro`, `max`, …), or null when unknown. */
+	plan: string | null;
 	fetchedAtMs: number;
 }
 
+/**
+ * Included monthly credits per plan, USD, from ollama.com/pricing (2026-09-07):
+ * Pro $20/mo carries $60 of usage, Max $100/mo carries $300. The dashboard's
+ * dollar figure is `limits.monthly.usage` × this. A plan not listed here
+ * (free, team, an unseen tier) yields no dollar reading rather than a guess.
+ */
+export const PLAN_CREDITS_USD: Readonly<Record<string, number>> = { pro: 60, max: 300 };
+
+/** The plan named by an `/api/me` payload, lower-cased, or null. */
+export function parseOllamaPlan(json: unknown): string | null {
+	const root = asRec(json);
+	const plan = root?.Plan ?? root?.plan;
+	return typeof plan === "string" && plan.trim() !== "" ? plan.trim().toLowerCase() : null;
+}
+
 function asRec(v: unknown): Record<string, unknown> | null {
 	return typeof v === "object" && v !== null && !Array.isArray(v) ? (v as Record<string, unknown>) : null;
 }
@@ -72,6 +89,7 @@ export function parseOllamaUsage(json: unknown, nowMs = Date.now()): OllamaUsage
 		monthlyUsageRaw: usageRaw,
 		activityCostUsd: Number.isFinite(cost) ? cost : null,
 		requestsThisMonth: requests,
+		plan: null,
 		fetchedAtMs: nowMs,
 	};
 }
@@ -98,8 +116,35 @@ export function createOllamaUsageSource(
 	let checkedAtMs = 0;
 	let inflight: Promise<OllamaUsage | null> | null = null;
 	let warned = false;
+	let plan: string | null = null;
+	let planWarned = false;
+
+	/** Best-effort: a missing plan only costs the dollar reading, never the bias. */
+	async function refreshPlan(): Promise<void> {
+		try {
+			const res = await fetchImpl(`${root}/api/me`, {
+				method: "POST",
+				headers: { authorization: `Bearer ${opts.apiKey}` },
+				signal: AbortSignal.timeout(opts.timeoutMs),
+			});
+			if (res.ok) {
+				const parsed = parseOllamaPlan(await res.json());
+				if (parsed !== null) plan = parsed;
+			} else if (!planWarned) {
+				planWarned = true;
+				opts.log.warn("ollama account endpoint unavailable; plan stays unknown", { status: res.status });
+			}
+		} catch (err) {
+			if (!planWarned) {
+				planWarned = true;
+				opts.log.warn("ollama account fetch failed; plan stays unknown", { error: err instanceof Error ? err.message : String(err) });
+			}
+		}
+	}
 
 	async function refresh(): Promise<OllamaUsage | null> {
+		// The plan changes rarely, but the call is one small request per poll.
+		await refreshPlan();
 		try {
 			const res = await fetchImpl(`${root}/api/usage`, {
 				headers: { authorization: `Bearer ${opts.apiKey}` },
@@ -108,7 +153,7 @@ export function createOllamaUsageSource(
 			if (res.ok) {
 				const parsed = parseOllamaUsage(await res.json());
 				if (parsed !== null) {
-					current = parsed;
+					current = { ...parsed, plan };
 					warned = false;
 				} else if (!warned) {
 					warned = true;
@@ -156,8 +201,21 @@ export function effectiveOllamaBias(costBias: number, biasUntilUsage: number, us
 	return used >= biasUntilUsage ? 1 : costBias;
 }
 
+/**
+ * Included credits for this account: the configured override when set, else
+ * the detected plan's published allowance, else null.
+ */
+export function ollamaPlanCredits(usage: OllamaUsage | null, overrideUsd: number): number | null {
+	if (overrideUsd > 0) return overrideUsd;
+	const plan = usage?.plan ?? null;
+	if (plan === null) return null;
+	return PLAN_CREDITS_USD[plan] ?? null;
+}
+
 /** The dashboard's dollar reading: plan share × included credits, when both are known. */
-export function ollamaMeter(usage: OllamaUsage | null, planCreditsUsd: number): { usedUsd: number; creditsUsd: number } | null {
-	if (usage === null || usage.monthlyUsedFraction === null || !(planCreditsUsd > 0)) return null;
-	return { usedUsd: Math.round(usage.monthlyUsedFraction * planCreditsUsd * 100) / 100, creditsUsd: planCreditsUsd };
+export function ollamaMeter(usage: OllamaUsage | null, overrideUsd: number): { usedUsd: number; creditsUsd: number; plan: string | null } | null {
+	if (usage === null || usage.monthlyUsedFraction === null) return null;
+	const credits = ollamaPlanCredits(usage, overrideUsd);
+	if (credits === null) return null;
+	return { usedUsd: Math.round(usage.monthlyUsedFraction * credits * 100) / 100, creditsUsd: credits, plan: usage.plan };
 }

package/test/ollama.test.ts

@@ -22,7 +22,7 @@ import { buildCandidates } from "../src/router/candidates.ts";
 import { extractFeatures } from "../src/router/features.ts";
 import { createMultiUpstream } from "../src/upstream/multi.ts";
 import { classifyOllamaStatus, createOllamaClient, toOllamaBody } from "../src/upstream/ollama.ts";
-import { createOllamaUsageSource, effectiveOllamaBias, NO_USAGE, ollamaMeter, parseOllamaUsage, usageFraction } from "../src/upstream/ollama-usage.ts";
+import { createOllamaUsageSource, effectiveOllamaBias, NO_USAGE, ollamaMeter, parseOllamaPlan, parseOllamaUsage, usageFraction } from "../src/upstream/ollama-usage.ts";
 import type { Dispatch, DispatchOptions, UpstreamClient } from "../src/upstream/types.ts";
 import { createLogger } from "../src/util/log.ts";
 import { parseChatRequest } from "../src/wire/openai/request.ts";
@@ -444,7 +444,7 @@ describe("ollama plan usage (credit-aware bias)", () => {
 	});
 
 	test("the bias holds under the threshold, switches to list price above it, and stays on when usage is unknown", () => {
-		const at = (f: number | null) => (f === null ? null : { monthlyUsedFraction: f, monthlyUsageRaw: f, activityCostUsd: null, requestsThisMonth: 0, fetchedAtMs: 0 });
+		const at = (f: number | null) => (f === null ? null : { monthlyUsedFraction: f, monthlyUsageRaw: f, activityCostUsd: null, requestsThisMonth: 0, plan: null, fetchedAtMs: 0 });
 		expect(effectiveOllamaBias(0.1, 0.9, at(0.5))).toBe(0.1);
 		expect(effectiveOllamaBias(0.1, 0.9, at(0.9))).toBe(1);
 		expect(effectiveOllamaBias(0.1, 0.9, at(1))).toBe(1);
@@ -457,15 +457,21 @@ describe("ollama plan usage (credit-aware bias)", () => {
 		let calls = 0;
 		let fail = false;
 		const fetchImpl = async (url: string, init?: RequestInit): Promise<Response> => {
+			expect((init?.headers as Record<string, string>).authorization).toBe("Bearer k");
+			// The plan rides along on every poll: POST /api/me (GET answers 405).
+			if (url === "https://ollama.com/api/me") {
+				expect(init?.method).toBe("POST");
+				return Response.json({ ID: "x", Email: "e", Plan: "Pro" });
+			}
 			calls++;
 			expect(url).toBe("https://ollama.com/api/usage");
-			expect((init?.headers as Record<string, string>).authorization).toBe("Bearer k");
 			if (fail) return new Response("down", { status: 503 });
 			return Response.json({ ...PAYLOAD, limits: { monthly: { usage: 42, models: [] } } });
 		};
 		const src = createOllamaUsageSource({ apiKey: "k", pollMs: 20, timeoutMs: 1000, log, fetchImpl });
 		expect(src.peek()).toBeNull();
 		expect((await src.get())?.monthlyUsedFraction).toBeCloseTo(0.42, 6);
+		expect(src.peek()?.plan).toBe("pro");
 		await src.get();
 		expect(calls).toBe(1); // within the interval
 		fail = true;
@@ -482,7 +488,7 @@ describe("ollama plan usage (credit-aware bias)", () => {
 		const source = { get: async () => ollamaModels, peek: () => ollamaModels, invalidate: () => {} };
 		const breaker = { available: () => true, cooldownUntilMs: () => null, lastTrip: () => null };
 		let used = 0.2;
-		const usage = { get: async () => ({ monthlyUsedFraction: used, monthlyUsageRaw: used * 100, activityCostUsd: null, requestsThisMonth: 0, fetchedAtMs: 0 }), peek: () => ({ monthlyUsedFraction: used, monthlyUsageRaw: used * 100, activityCostUsd: null, requestsThisMonth: 0, fetchedAtMs: 0 }) };
+		const usage = { get: async () => ({ monthlyUsedFraction: used, monthlyUsageRaw: used * 100, activityCostUsd: null, requestsThisMonth: 0, plan: null, fetchedAtMs: 0 }), peek: () => ({ monthlyUsedFraction: used, monthlyUsageRaw: used * 100, activityCostUsd: null, requestsThisMonth: 0, plan: null, fetchedAtMs: 0 }) };
 		const catalog = createCompositeCatalog(openrouter, source, breaker, { costBias: 0.1, biasUntilUsage: 0.9, usage });
 
 		const a = await catalog.get();
@@ -506,16 +512,29 @@ describe("ollama plan usage (credit-aware bias)", () => {
 
 
 describe("ollamaMeter", () => {
-	test("plan share times credits is the dashboard's dollar figure", () => {
-		const usage = { monthlyUsedFraction: 0.104, monthlyUsageRaw: 0.104, activityCostUsd: 0, requestsThisMonth: 1250, fetchedAtMs: 1 };
-		// 10.4% of Pro's $60 is the $6.24 ollama.com shows.
-		expect(ollamaMeter(usage, 60)).toEqual({ usedUsd: 6.24, creditsUsd: 60 });
+	const usage = (plan: string | null, frac: number | null = 0.104) => ({ monthlyUsedFraction: frac, monthlyUsageRaw: frac, activityCostUsd: 0, requestsThisMonth: 1250, plan, fetchedAtMs: 1 });
+
+	test("a detected plan applies its published allowance: 10.4% of Pro's $60 is the $6.24 ollama.com shows", () => {
+		expect(ollamaMeter(usage("pro"), 0)).toEqual({ usedUsd: 6.24, creditsUsd: 60, plan: "pro" });
+		expect(ollamaMeter(usage("max"), 0)).toEqual({ usedUsd: 31.2, creditsUsd: 300, plan: "max" });
 	});
 
-	test("unknown credits or usage yields no meter", () => {
-		const usage = { monthlyUsedFraction: 0.5, monthlyUsageRaw: 0.5, activityCostUsd: 0, requestsThisMonth: 1, fetchedAtMs: 1 };
-		expect(ollamaMeter(usage, 0)).toBeNull();
+	test("a configured override wins over the detected plan; an unknown plan without one yields no meter", () => {
+		expect(ollamaMeter(usage("pro"), 100)).toEqual({ usedUsd: 10.4, creditsUsd: 100, plan: "pro" });
+		expect(ollamaMeter(usage("team"), 0)).toBeNull();
+		expect(ollamaMeter(usage("team"), 500)?.creditsUsd).toBe(500);
+		expect(ollamaMeter(usage(null), 0)).toBeNull();
+	});
+
+	test("no usage reading yields no meter", () => {
 		expect(ollamaMeter(null, 60)).toBeNull();
-		expect(ollamaMeter({ ...usage, monthlyUsedFraction: null }, 60)).toBeNull();
+		expect(ollamaMeter(usage("pro", null), 60)).toBeNull();
+	});
+
+	test("parseOllamaPlan reads the account payload case-insensitively", () => {
+		expect(parseOllamaPlan({ ID: "x", Plan: "Pro" })).toBe("pro");
+		expect(parseOllamaPlan({ plan: "max" })).toBe("max");
+		expect(parseOllamaPlan({ Plan: "" })).toBeNull();
+		expect(parseOllamaPlan("nope")).toBeNull();
 	});
 });

package/test/report-logic.test.ts

@@ -65,7 +65,7 @@ describe("renderStatus", () => {
 				apiKeySource: "omp",
 				lastTrip: { kind: "quota", atMs: now - 120_000, message: "402" },
 				usage: { monthlyUsedFraction: 0.42, activityCostUsd: 3.1, fetchedAtMs: now },
-				meter: { usedUsd: 25.2, creditsUsd: 60 },
+				meter: { usedUsd: 25.2, creditsUsd: 60, plan: "pro" },
 				costBias: { configured: 0.1, effective: 0.1, biasUntilUsage: 0.9 },
 			},
 			catalog: { models: 240, ageMs: 5 * 60_000, keyScoped: true, shrink: { fromModels: 300, toModels: 120, atMs: now } },
@@ -76,7 +76,7 @@ describe("renderStatus", () => {
 		expect(text).toContain("refreshed 5m ago");
 		expect(text).toContain("SHRANK 300 -> 120");
 		expect(text).toContain("COOLING DOWN");
-		expect(text).toContain("plan usage 42.0% ($25.20 of $60)");
+		expect(text).toContain("pro plan usage 42.0% ($25.20 of $60)");
 		expect(text).toContain("cost bias ×0.1 (until 90%)");
 		expect(text).toContain("last trip quota 2m ago");
 		expect(text).toContain("scope omp-router");