auto-model-router 0.22.0 → 0.24.0

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.22.0",
+    "version": "0.24.0",
     "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.22.0",
+      "version": "0.24.0",
       "author": {
         "name": "drewappling",
         "email": "drewappling@gmail.com"

package/package.json

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

package/src/catalog/composite.ts

@@ -35,7 +35,12 @@ export interface CompositeBias {
 	/** False when OpenRouter cannot dispatch (no key): its models are listed for metadata only, never served. Default true. */
 	serveOpenRouter?: () => boolean;
 	/** Named upstreams' models, built from the OpenRouter models (twins) and filtered by each upstream's breaker. */
-	named?: { models(openrouter: readonly CatalogModel[]): readonly CatalogModel[]; serving(id: string): boolean };
+	named?: {
+		models(openrouter: readonly CatalogModel[]): readonly CatalogModel[];
+		serving(id: string): boolean;
+		/** That upstream's `costBias`, so prepaid capacity ranks below list price. 1 when it has none. */
+		bias?(id: string): number;
+	};
 }
 
 /** Shared empty list, so a deployment without named upstreams keeps the merged snapshot's identity. */
@@ -81,8 +86,14 @@ export function createCompositeCatalog(
 		merged = serveBase ? mergeSnapshots(base, available ? models : []) : { ...base, models: available ? [...models] : [] };
 		if (named.length > 0) merged = { ...merged, models: [...merged.models, ...named] };
 		// 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 } };
+		// candidate scoring reads it off the snapshot it is ranking. Each named upstream
+		// adds its own, so prepaid capacity ranks below list price without being free.
+		const biases: Record<string, number> = { ollama: providerBias };
+		for (const m of named) {
+			const b = bias.named?.bias?.(m.provider) ?? 1;
+			if (b !== 1) biases[m.provider] = b;
+		}
+		merged = { ...merged, providerBias: biases };
 		return merged;
 	}
 

package/src/catalog/static-catalog.ts

@@ -29,9 +29,17 @@ export function buildUpstreamModels(entry: UpstreamEntry, openrouter: readonly C
 		const twin = (m.twin !== undefined ? bySlug.get(m.twin) : undefined) ?? twins.get(normalizeModelKey(m.id)) ?? null;
 		const modalities: Modality[] = ["text"];
 		if (m.vision ?? twin?.inputModalities.includes("image") ?? false) modalities.push("image");
-		const price: CatalogModel["price"] = { prompt: m.input / 1e6, completion: m.output / 1e6 };
-		if (m.cachedInput !== undefined) price.cacheRead = m.cachedInput / 1e6;
-		if (m.cacheWrite !== undefined) price.cacheWrite = m.cacheWrite / 1e6;
+		// An omitted price means "whatever the twin costs": a subscription sells the same
+		// weights per token on OpenRouter, so the twin is the only honest figure. Falling
+		// back to zero instead would win every tier outright and silence the quality floors.
+		const price: CatalogModel["price"] = {
+			prompt: m.input !== undefined ? m.input / 1e6 : (twin?.price.prompt ?? 0),
+			completion: m.output !== undefined ? m.output / 1e6 : (twin?.price.completion ?? 0),
+		};
+		const cacheRead = m.cachedInput !== undefined ? m.cachedInput / 1e6 : twin?.price.cacheRead;
+		const cacheWrite = m.cacheWrite !== undefined ? m.cacheWrite / 1e6 : twin?.price.cacheWrite;
+		if (cacheRead !== undefined) price.cacheRead = cacheRead;
+		if (cacheWrite !== undefined) price.cacheWrite = cacheWrite;
 		const model: CatalogModel = {
 			slug: `${entry.id}/${m.id}`,
 			canonicalSlug: `${entry.id}/${m.id}`,

package/src/config/schema.ts

@@ -64,8 +64,8 @@ export const RESERVED_UPSTREAM_IDS: readonly string[] = ["openrouter", "ollama",
 const upstreamModel = z.strictObject({
 	id: z.string().min(1),
 	name: z.string().optional(),
-	input: z.number().nonnegative(),
-	output: z.number().nonnegative(),
+	input: z.number().nonnegative().optional(),
+	output: z.number().nonnegative().optional(),
 	cachedInput: z.number().nonnegative().optional(),
 	cacheWrite: z.number().nonnegative().optional(),
 	contextLength: z.number().int().positive().optional(),
@@ -87,11 +87,13 @@ const upstream = z.strictObject({
 	enabled: z.boolean().optional(),
 	baseUrl: z.string().min(1),
 	apiKey: z.string().optional(),
+	auth: z.enum(["api-key", "oauth-bearer"]).optional(),
 	apiVersion: z.string().optional(),
 	headers: z.record(z.string(), z.string()).optional(),
 	timeoutMs: z.number().positive().optional(),
 	rateLimitCooldownMs: z.number().nonnegative().optional(),
 	quotaCooldownMs: z.number().nonnegative().optional(),
+	costBias: z.number().positive().max(1).optional(),
 	models: z.array(upstreamModel),
 });
 

package/src/config/types.ts

@@ -906,10 +906,15 @@ export interface UpstreamModelConfig {
 	/** The model id the provider knows (an Azure deployment name for `azure`). The catalog slug is `<upstream id>/<id>`. */
 	id: string;
 	name?: string;
-	/** USD per million prompt tokens. */
-	input: number;
-	/** USD per million completion tokens. */
-	output: number;
+	/**
+	 * USD per million prompt tokens. Absent ⇒ the OpenRouter twin's price, which is what
+	 * a subscription upstream wants: the same weights are sold per token there, so the
+	 * twin is the only honest figure for what a turn is worth. Pair it with `costBias`
+	 * to rank prepaid capacity below list without pretending it is free.
+	 */
+	input?: number;
+	/** USD per million completion tokens. Absent ⇒ the OpenRouter twin's. */
+	output?: number;
 	/** USD per million cached prompt tokens, when the provider discounts them. */
 	cachedInput?: number;
 	/** USD per million prompt tokens written to cache (Anthropic). */
@@ -943,11 +948,20 @@ export interface UpstreamEntry {
 	apiKey: string;
 	/** Azure only: the `api-version` query parameter. */
 	apiVersion: string;
+	/** `api-key` sends `x-api-key`; `oauth-bearer` sends `Authorization: Bearer` plus the Claude OAuth beta headers (a Claude Pro/Max subscription token). */
+	auth: "api-key" | "oauth-bearer";
 	/** Extra request headers, e.g. a gateway's own auth. */
 	headers: Record<string, string>;
 	timeoutMs: number;
 	rateLimitCooldownMs: number;
 	quotaCooldownMs: number;
+	/**
+	 * Ranking multiplier on this upstream's forecast cost, like `ollama.costBias`: below 1
+	 * prefers capacity that is already paid for (a Claude Pro/Max subscription) without
+	 * pricing it at zero, which would win every tier and make quality floors meaningless.
+	 * Ranking only — the ledger still records the price the catalog carries. Default 1.
+	 */
+	costBias: number;
 	models: UpstreamModelConfig[];
 }
 

package/src/config/upstreams.ts

@@ -17,9 +17,11 @@ export function completeUpstreamEntry(raw: Record<string, unknown>): UpstreamEnt
 		apiKey: typeof raw.apiKey === "string" ? raw.apiKey : "",
 		apiVersion: typeof raw.apiVersion === "string" ? raw.apiVersion : "2024-10-21",
 		headers: (raw.headers as Record<string, string> | undefined) ?? {},
+		auth: raw.auth === "oauth-bearer" ? "oauth-bearer" : "api-key",
 		timeoutMs: typeof raw.timeoutMs === "number" ? raw.timeoutMs : 600_000,
 		rateLimitCooldownMs: typeof raw.rateLimitCooldownMs === "number" ? raw.rateLimitCooldownMs : 60_000,
 		quotaCooldownMs: typeof raw.quotaCooldownMs === "number" ? raw.quotaCooldownMs : 15 * 60_000,
+		costBias: typeof raw.costBias === "number" && raw.costBias > 0 ? raw.costBias : 1,
 		models: (raw.models as UpstreamEntry["models"] | undefined) ?? [],
 	};
 }

package/src/cost/ledger.ts

@@ -20,6 +20,7 @@ import { computeBlendedRate } from "./blended.ts";
 import { computeCost } from "./forecast.ts";
 import type {
 	BlendedRate,
+	CostBreakdown,
 	EscalationCost,
 	Ledger,
 	LedgerEntry,
@@ -283,6 +284,9 @@ export function toEntry(row: LedgerRow): LedgerEntry {
 		// Likewise a row from before v19, or a turn with redaction off: absent,
 		// which is a different fact from 0 (the rules ran and matched nothing).
 		...(row.redactions === null || row.redactions === undefined ? {} : { redactions: row.redactions }),
+		// A row recorded before pricing, or one whose model could not be priced,
+		// stores NULL; absent is the front door's cue to fall back to the blend.
+		...(row.cost_breakdown === null || row.cost_breakdown === undefined ? {} : { costBreakdown: JSON.parse(row.cost_breakdown) as CostBreakdown }),
 	};
 }
 

package/src/cost/types.ts

@@ -167,6 +167,13 @@ export interface LedgerEntry {
 	 * provider (Ollama) exists only in memory, so the orchestrator hands it over.
 	 */
 	priceModel?: CatalogModel;
+	/**
+	 * The cost component split the router computed when it recorded this row,
+	 * from its own catalog prices. Absent when the row predates pricing, or
+	 * when the model could not be priced (NULL in the ledger) — a front door
+	 * shows input/output/cache costs from this rather than re-deriving them.
+	 */
+	costBreakdown?: CostBreakdown;
 }
 
 /**

package/src/router/candidates.ts

@@ -357,12 +357,14 @@ export function buildCandidates(args: BuildCandidatesArgs): { candidates: Candid
 			filters.escalationCostWeight > 0 && args.escalationUsdPerPromptToken !== undefined
 				? filters.escalationCostWeight * escalationRate * args.escalationUsdPerPromptToken * features.promptTokens
 				: 0;
-		// Provider bias: an Ollama plan's included credits are money already
-		// spent, so an operator may value them below list price in ranking. The
-		// ledger still records list price.
-		// The snapshot carries the LIVE bias (credit-aware); the static config
-		// value is the fallback for snapshots built without one.
-		const providerBias = snapshot.providerBias?.[model.provider] ?? (model.provider === "ollama" ? cfg.ollama.costBias : 1);
+		// Provider bias: capacity already paid for — an Ollama plan's included credits, a
+		// Claude Pro/Max subscription — is money already spent, so an operator may value it
+		// below list price in ranking. The ledger still records list price.
+		// The snapshot carries the LIVE bias (credit-aware, and each named upstream's own);
+		// the static config value is the fallback for snapshots built without one.
+		const providerBias =
+			snapshot.providerBias?.[model.provider] ??
+			(model.provider === "ollama" ? cfg.ollama.costBias : (cfg.upstreams.find((u) => u.id === model.provider)?.costBias ?? 1));
 		const effectiveUsd = (fc.expectedUsd / Math.max(trustScore, 0.5) + escalationUsd) * latencyMult * providerBias;
 		// Score is assigned in a SECOND PASS below: both qualityNormalization and
 		// capabilityFloorUsd are properties of the candidate SET, not of one
@@ -381,7 +383,7 @@ export function buildCandidates(args: BuildCandidatesArgs): { candidates: Candid
 		if (escalationUsd > 0) {
 			reasons.push(`escalation risk +$${escalationUsd.toFixed(6)} (rate ${(escalationRate * 100).toFixed(2)}% × measured retry cost)`);
 		}
-		if (providerBias !== 1) reasons.push(`provider bias ×${providerBias} (ollama.costBias, plan credits remaining)`);
+		if (providerBias !== 1) reasons.push(`provider bias ×${providerBias} (${model.provider === "ollama" ? "ollama.costBias, plan credits remaining" : `${model.provider}.costBias, capacity already paid for`})`);
 		if (latencyMult > 1 && latency !== null) {
 			reasons.push(
 				`latency penalty ×${latencyMult.toFixed(2)} (ttft ${Math.round(latency.ttftMs)}ms, ${latency.tokensPerSec.toFixed(0)} tok/s over ${latency.samples} samples)`,

package/src/server/providers.ts

@@ -77,7 +77,7 @@ export function createProviders(cfg: RouterConfig, db: Database, log: Logger = c
 	};
 	const namedServingOne = (id: string): boolean => {
 		const entry = cfg.upstreams.find((u) => u.id === id);
-		if (entry === undefined || !entry.enabled || entry.apiKey === "" && entry.kind !== "openai") return entry !== undefined && entry.enabled && (named(id)?.available() ?? false);
+		if (entry === undefined || !entry.enabled || (entry.apiKey === "" && entry.kind !== "openai" && entry.auth !== "oauth-bearer")) return entry !== undefined && entry.enabled && (named(id)?.available() ?? false);
 		return named(id)?.available() ?? false;
 	};
 	const namedServing = (): string[] => cfg.upstreams.filter((u) => u.enabled && namedServingOne(u.id)).map((u) => u.id);
@@ -91,7 +91,7 @@ export function createProviders(cfg: RouterConfig, db: Database, log: Logger = c
 			usage: ollamaUsage,
 			live: () => ({ costBias: cfg.ollama.costBias, biasUntilUsage: cfg.ollama.biasUntilUsage }),
 			serveOpenRouter: () => cfg.openrouter.apiKey !== "",
-			named: { models: (base) => staticCatalog.get(base), serving: namedServingOne },
+			named: { models: (base) => staticCatalog.get(base), serving: namedServingOne, bias: (id) => cfg.upstreams.find((u) => u.id === id)?.costBias ?? 1 },
 		}),
 		ollama,
 		ollamaServing,

package/src/upstream/anthropic.ts

@@ -355,6 +355,27 @@ function transportError(id: string, err: unknown): UpstreamError {
 	return new UpstreamError("network", 0, err instanceof Error ? err.message : String(err), true);
 }
 
+/**
+ * Anthropic accepts a Pro/Max subscription token only on Claude Code's own traffic: unless
+ * the FIRST system block carries this exact line, the API answers 429 `rate_limit_error`
+ * with the message "Error" — a refusal wearing a quota's clothes, not a real rate limit,
+ * which the breaker would otherwise read as "slow down" and cool the upstream off.
+ *
+ * Claude Code sends it itself. Every other client — an OpenAI-wire caller, the router's own
+ * classifier and digest chores — would be refused, so an `oauth-bearer` upstream adds it
+ * when it is missing. It goes in as its own leading block rather than being merged into the
+ * caller's text, because that is the shape Claude Code sends and it keeps the caller's
+ * `cache_control` markers attached to the blocks they were written for.
+ */
+const CLAUDE_CODE_IDENTITY = "You are Claude Code, Anthropic's official CLI for Claude.";
+
+function withClaudeCodeIdentity(body: Record<string, unknown>): Record<string, unknown> {
+	const system = Array.isArray(body.system) ? (body.system as Block[]) : [];
+	const first = asRec(system[0]);
+	if (first !== null && typeof first.text === "string" && first.text.startsWith(CLAUDE_CODE_IDENTITY)) return body;
+	return { ...body, system: [{ type: "text", text: CLAUDE_CODE_IDENTITY }, ...system] };
+}
+
 export function createAnthropicClient(cfg: RouterConfig, id: string, fetchImpl: FetchLike = fetch): NamedUpstreamClient {
 	const lookup = upstreamLookup(cfg, id);
 	const log = createLogger(cfg.logLevel);
@@ -379,7 +400,8 @@ export function createAnthropicClient(cfg: RouterConfig, id: string, fetchImpl:
 		const { modelId, model } = modelInfo(e, slug);
 		const opts: AnthropicBodyOptions = { modelId, supportsReasoning: model?.supportsReasoning ?? false };
 		if (model?.maxCompletionTokens !== undefined) opts.maxCompletionTokens = model.maxCompletionTokens;
-		return { rendered: toAnthropicBody(body, opts), servedSlug: `${id}/${modelId}` };
+		const rendered = toAnthropicBody(body, opts);
+		return { rendered: e.auth === "oauth-bearer" ? withClaudeCodeIdentity(rendered) : rendered, servedSlug: `${id}/${modelId}` };
 	}
 	function composeSignal(e: UpstreamEntry, caller: AbortSignal | undefined): AbortSignal | null {
 		const timeout = e.timeoutMs > 0 ? AbortSignal.timeout(e.timeoutMs) : null;
@@ -388,7 +410,11 @@ export function createAnthropicClient(cfg: RouterConfig, id: string, fetchImpl:
 	}
 	async function post(e: UpstreamEntry, body: Record<string, unknown>, signal: AbortSignal | undefined): Promise<Response> {
 		const headers: Record<string, string> = { "content-type": "application/json", "anthropic-version": ANTHROPIC_VERSION, ...e.headers };
-		if (e.apiKey !== "") headers["x-api-key"] = e.apiKey;
+		if (e.auth === "oauth-bearer") {
+			// A Claude Pro/Max subscription token: Bearer auth at the first-party API, with the OAuth beta. No per-token cost is reported.
+			headers["authorization"] = `Bearer ${e.apiKey}`;
+			headers["anthropic-beta"] = e.headers["anthropic-beta"] ?? "oauth-2025-04-20,claude-code-20250219";
+		} else if (e.apiKey !== "") headers["x-api-key"] = e.apiKey;
 		try {
 			return await fetchImpl(`${e.baseUrl.replace(/\/+$/, "")}/v1/messages`, { method: "POST", headers, body: JSON.stringify(body), signal: composeSignal(e, signal) });
 		} catch (err) {

package/test/upstreams.test.ts

@@ -100,6 +100,23 @@ describe("static catalog", () => {
 		expect(unknown!.tokenizer).toBe("Claude");
 	});
 
+	test("a subscription model with no price of its own inherits the twin's, so it never ranks as free", () => {
+		// A Pro/Max subscription publishes no per-token rates, and pricing it at zero would beat
+		// every model in every tier outright. The twin sells the same weights, so it is the rate.
+		const e = entry({ id: "anthropic-subscription", kind: "anthropic", costBias: 0.1, models: [{ id: "claude-sonnet-4-20250514", twin: "anthropic/claude-sonnet-4" }] });
+		const [sub] = buildUpstreamModels(e, twins);
+		const twin = twins.find((m) => m.slug === "anthropic/claude-sonnet-4")!;
+		expect(sub!.price.prompt).toBe(twin.price.prompt);
+		expect(sub!.price.completion).toBe(twin.price.completion);
+		expect(sub!.price.prompt).toBeGreaterThan(0);
+		expect(sub!.isFree).toBe(false);
+		// The discount is a RANKING bias on the entry, never a rewrite of the recorded price.
+		expect(e.costBias).toBe(0.1);
+		// An explicit zero still means zero: a self-hosted server is genuinely free.
+		const free = entry({ id: "vllm", kind: "openai", models: [{ id: "local", input: 0, output: 0 }] });
+		expect(buildUpstreamModels(free, twins)[0]!.price).toEqual({ prompt: 0, completion: 0 });
+	});
+
 	test("the source rebuilds only when the entries or the OpenRouter models change", () => {
 		const cfg = cfgWith([entry({ id: "vllm", kind: "openai" })]);
 		const src = createStaticCatalogSource(cfg);
@@ -349,6 +366,32 @@ describe("the Anthropic client", () => {
 		expect(classifyAnthropicStatus("a", 400, { error: { message: "prompt is too long: 250000 tokens" } })).toMatchObject({ kind: "context_length", retryable: false });
 		expect(classifyAnthropicStatus("a", 401, {})).toMatchObject({ kind: "auth", retryable: false });
 	});
+
+	test("a subscription upstream: OAuth bearer instead of x-api-key, and the Claude Code identity leads the system blocks", async () => {
+		// Anthropic answers a Pro/Max token 429 "Error" unless the first system block says this,
+		// so the literal is the wire contract and is spelled out here rather than imported.
+		const identity = "You are Claude Code, Anthropic's official CLI for Claude.";
+		let headers: Record<string, string> = {};
+		let sent: Record<string, unknown> = {};
+		const fetchImpl = async (_u: string, init?: RequestInit): Promise<Response> => {
+			headers = init?.headers as Record<string, string>;
+			sent = JSON.parse(String(init?.body)) as Record<string, unknown>;
+			return sse([`event: message_stop${NL}data: {"type":"message_stop"}`]);
+		};
+		const cfg = cfgWith([entry({ id: "sub", kind: "anthropic", auth: "oauth-bearer", baseUrl: "https://api.anthropic.com", apiKey: "sk-ant-oat01-x", models: [{ id: "claude-sonnet-5", input: 0, output: 0 }] })]);
+		const drain = async (messages: unknown[]): Promise<void> => {
+			const d = await createAnthropicClient(cfg, "sub", fetchImpl).dispatch({ body: { model: "sub/claude-sonnet-5", messages, max_tokens: 16 }, sessionId: "s", signal: new AbortController().signal });
+			for await (const c of d.chunks) void c;
+		};
+		await drain([{ role: "user", content: "ping" }]);
+		expect(headers.authorization).toBe("Bearer sk-ant-oat01-x");
+		expect(headers["anthropic-beta"]).toContain("oauth-2025-04-20");
+		expect(headers["x-api-key"]).toBeUndefined();
+		expect(sent.system).toEqual([{ type: "text", text: identity }]);
+		// A caller that already identifies as Claude Code keeps its own block; it is not said twice.
+		await drain([{ role: "system", content: `${identity} Be brief.` }, { role: "user", content: "ping" }]);
+		expect(sent.system).toEqual([{ type: "text", text: `${identity} Be brief.` }]);
+	});
 });
 
 describe("the composite catalog with named upstreams", () => {

package/test/views.test.ts

@@ -215,4 +215,20 @@ describe("decision entries", () => {
 		expect(bob.find((e) => e.id === "l3")?.error).toBe("boom");
 		expect(bob.find((e) => e.id === "l3")?.feedback[0]?.note).toBe("looped");
 	});
+
+	test("the recorded cost split rides along; unpriced rows leave it absent", () => {
+		const { decisionEntries } = require("../src/cost/views.ts") as typeof import("../src/cost/views.ts");
+		// The fixture records before any catalog fetch, so every row stored NULL;
+		// one priced row stands in for a turn the router could price at record time.
+		db.run("UPDATE ledger SET cost_breakdown = ? WHERE id = 'l1'", [
+			JSON.stringify({ freshPrompt: 0.006, cacheRead: 0.004, cacheWrite: 0, completion: 0.002, reasoning: 0, images: 0, request: 0, total: 0.006, tierAtPromptTokens: 0 }),
+		]);
+		const entries = decisionEntries(db, { sinceMs: since, harness: null });
+		const priced = entries.find((e) => e.id === "l1");
+		expect(priced?.costBreakdown?.total).toBeCloseTo(0.006, 6);
+		expect(priced?.costBreakdown?.cacheRead).toBeCloseTo(0.004, 6);
+		// A row the ledger could not price (all of them here, NULL column) has no
+		// breakdown at all — the front door's cue to fall back to the blend.
+		expect(entries.find((e) => e.id === "l2")?.costBreakdown).toBeUndefined();
+	});
 });