auto-model-router 0.12.0 → 0.13.1

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

package/README.md

@@ -1365,6 +1365,56 @@ skills: Claude Code's `~/.claude/skills/<name>/` and omp's `~/.omp/agent/skills/
 the bundle no longer carries, and a skill of the same name the member wrote themselves is
 left alone with a note. A remote without skills answers 404 and nothing happens.
 
+## Direct upstreams: OpenAI, Azure OpenAI, Anthropic, vLLM
+
+OpenRouter and Ollama Cloud are the built-in upstreams. `upstreams:` adds named ones the
+router dispatches to directly, each with a static, priced model list (a direct provider
+publishes no routing catalog): OpenAI-compatible servers (`kind: openai` — OpenAI itself,
+vLLM, a gateway), Azure OpenAI (`kind: azure`, the deployment name is the model and the
+`api-version` is a field), and Anthropic natively (`kind: anthropic`, translated to and from
+the Messages API, `cache_control` markers kept because Anthropic honours them).
+
+```yaml
+upstreams:
+  - id: openai-direct                 # the catalog namespace: openai-direct/gpt-4o
+    kind: openai
+    baseUrl: https://api.openai.com/v1
+    apiKey: sk-…
+    models:
+      - { id: gpt-4o, input: 2.5, output: 10, cachedInput: 1.25 }          # USD per million tokens
+      - { id: gpt-4o-mini, input: 0.15, output: 0.6, cachedInput: 0.075 }
+  - id: azure-eu
+    kind: azure
+    baseUrl: https://my-resource.openai.azure.com
+    apiVersion: 2024-10-21
+    apiKey: …
+    models: [{ id: gpt-4o-deploy, twin: openai/gpt-4o, input: 2.5, output: 10 }]
+  - id: anthropic-direct
+    kind: anthropic
+    baseUrl: https://api.anthropic.com
+    apiKey: sk-ant-…
+    models:
+      - { id: claude-sonnet-4-20250514, twin: anthropic/claude-sonnet-4, input: 3, output: 15, cachedInput: 0.3, cacheWrite: 3.75, supportsReasoning: true, maxCompletionTokens: 64000 }
+  - id: vllm
+    kind: openai
+    baseUrl: http://vllm.internal:8000/v1
+    models: [{ id: llama-3.3-70b, input: 0, output: 0, contextLength: 128000, quality: { coding: 60, intelligence: 55 } }]
+```
+
+Each model enters the catalog as `<id>/<model>` and ranks beside everything else: prices from
+the entry, context length, capabilities and quality scores from the OpenRouter **twin** of the
+same model (`twin` names it, or the normalised name finds it — `gpt-4o` matches
+`openai/gpt-4o`), or from the entry when it says so. A model with no scores serves only the
+trivial tier, as an unbenchmarked OpenRouter model would. `id` must not be an OpenRouter vendor
+namespace (`openai`, `anthropic`, …), or `openai/gpt-4o` would be ambiguous. A 429 opens a
+short breaker and an out-of-quota answer a longer one, and the catalog hides that upstream's
+models while it is open, exactly as for Ollama Cloud. The list hot-reloads: a changed key or a
+new entry applies to the next turn. `/health` lists each upstream's state, never its key;
+`report` and `export` name the upstream as the provider of its slugs.
+
+Not here: Bedrock and Vertex need cloud signing and are a later addition; a gateway that
+speaks OpenAI in front of them works today as `kind: openai`.
+
 ## Multiple coding harnesses, one router
 
 **One router process for everything.** omp's embed extension binds a private

package/package.json

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

package/src/catalog/composite.ts

@@ -34,8 +34,13 @@ export interface CompositeBias {
 	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;
+	/** 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 };
 }
 
+/** Shared empty list, so a deployment without named upstreams keeps the merged snapshot's identity. */
+const NO_NAMED: readonly CatalogModel[] = [];
+
 export function createCompositeCatalog(
 	openrouter: CatalogSource,
 	ollama: OllamaCatalogSource,
@@ -47,6 +52,8 @@ export function createCompositeCatalog(
 	let lastAvailable = true;
 	let lastServeBase = true;
 	let lastBias = 1;
+	let lastNamed: readonly CatalogModel[] = [];
+	let lastNamedServing = "";
 	let merged: CatalogSnapshot | null = null;
 
 	/** The multiplier in force from the latest usage reading (no network). */
@@ -59,13 +66,20 @@ export function createCompositeCatalog(
 		const available = availability.available();
 		const serveBase = bias.serveOpenRouter?.() ?? true;
 		const providerBias = currentBias();
-		if (merged !== null && base === lastBase && models === lastOllama && available === lastAvailable && serveBase === lastServeBase && providerBias === lastBias) return merged;
+		// Named upstreams: every enabled entry's models, minus those of an upstream in cooldown.
+		const namedAll = bias.named?.models(base.models) ?? NO_NAMED;
+		const namedServing = namedAll.map((m) => (bias.named?.serving(m.provider) ?? true ? "1" : "0")).join("");
+		if (merged !== null && base === lastBase && models === lastOllama && available === lastAvailable && serveBase === lastServeBase && providerBias === lastBias && namedAll === lastNamed && namedServing === lastNamedServing) return merged;
 		lastBase = base;
 		lastOllama = models;
 		lastAvailable = available;
 		lastServeBase = serveBase;
 		lastBias = providerBias;
+		lastNamed = namedAll;
+		lastNamedServing = namedServing;
+		const named = namedAll.filter((m) => bias.named?.serving(m.provider) ?? true);
 		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 } };
@@ -77,6 +91,7 @@ export function createCompositeCatalog(
 		if (fromBase !== undefined) return fromBase;
 		for (const m of lastOllama) if (m.slug === slug) return m;
 		for (const m of ollama.peek()) if (m.slug === slug) return m;
+		for (const m of lastNamed) if (m.slug === slug) return m;
 		return undefined;
 	}
 

package/src/catalog/static-catalog.ts

@@ -0,0 +1,90 @@
+/**
+ * Catalog models for the named upstreams in `upstreams: []`.
+ *
+ * A direct provider publishes no routing catalog the way OpenRouter does, so
+ * each entry names its models with prices (USD per million tokens) and what
+ * routing needs to know. Quality scores come from the entry when given,
+ * otherwise from the OpenRouter twin of the same model (`twin` names it, or
+ * the normalised name finds it), so a direct `gpt-4o` ranks like OpenRouter's
+ * `openai/gpt-4o` rather than as an unscored model stuck in the trivial tier.
+ */
+
+import type { RouterConfig, UpstreamEntry, UpstreamModelConfig } from "../config/types.ts";
+import type { Logger } from "../util/log.ts";
+import { normalizeModelKey } from "./benchmark-feeds.ts";
+import { twinIndex } from "./ollama-catalog.ts";
+import type { CatalogModel, Modality } from "./types.ts";
+
+function tokenizerFor(kind: UpstreamEntry["kind"], twin: CatalogModel | null): string {
+	if (twin !== null) return twin.tokenizer;
+	return kind === "anthropic" ? "Claude" : kind === "openai" || kind === "azure" ? "GPT" : "Other";
+}
+
+/** One entry's models as catalog models. Pure. */
+export function buildUpstreamModels(entry: UpstreamEntry, openrouter: readonly CatalogModel[]): CatalogModel[] {
+	const twins = twinIndex(openrouter);
+	const bySlug = new Map(openrouter.map((m) => [m.slug, m] as const));
+	const out: CatalogModel[] = [];
+	for (const m of entry.models) {
+		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;
+		const model: CatalogModel = {
+			slug: `${entry.id}/${m.id}`,
+			canonicalSlug: `${entry.id}/${m.id}`,
+			name: `${m.name ?? m.id} (${entry.id})`,
+			provider: entry.id,
+			contextLength: m.contextLength ?? twin?.contextLength ?? 128_000,
+			supportsTools: m.supportsTools ?? twin?.supportsTools ?? true,
+			supportsReasoning: m.supportsReasoning ?? twin?.supportsReasoning ?? false,
+			reasoningMandatory: twin?.reasoningMandatory ?? false,
+			supportsToolChoice: m.supportsToolChoice ?? true,
+			inputModalities: modalities,
+			price,
+			priceTiers: [],
+			quality: m.quality !== undefined ? { ...m.quality } : twin === null ? {} : { ...twin.quality },
+			tokenizer: tokenizerFor(entry.kind, twin),
+			// A $0 model here is a self-hosted server, not a public provider's rate-limited free tier: never excluded as "free".
+			isFree: false,
+			createdAtMs: twin?.createdAtMs ?? 0,
+			author: entry.id,
+		};
+		const maxOut = m.maxCompletionTokens ?? twin?.maxCompletionTokens;
+		if (maxOut !== undefined) model.maxCompletionTokens = maxOut;
+		out.push(model);
+	}
+	return out;
+}
+
+export interface StaticCatalogSource {
+	/** Models of every enabled entry, rebuilt when the entries or the OpenRouter models change. */
+	get(openrouter: readonly CatalogModel[]): CatalogModel[];
+	/** The last built set. */
+	peek(): CatalogModel[];
+}
+
+/** Memoised over the live `cfg.upstreams` array (replaced wholesale on a change) and the OpenRouter models. */
+export function createStaticCatalogSource(cfg: RouterConfig, log?: Logger): StaticCatalogSource {
+	let lastEntries: readonly UpstreamEntry[] | null = null;
+	let lastBase: readonly CatalogModel[] | null = null;
+	let built: CatalogModel[] = [];
+	return {
+		get(openrouter) {
+			if (cfg.upstreams === lastEntries && openrouter === lastBase) return built;
+			lastEntries = cfg.upstreams;
+			lastBase = openrouter;
+			built = cfg.upstreams.filter((u) => u.enabled).flatMap((u) => buildUpstreamModels(u, openrouter));
+			if (built.length > 0) log?.debug("named upstream models built", { models: built.length, upstreams: cfg.upstreams.filter((u) => u.enabled).map((u) => u.id).join(", ") });
+			return built;
+		},
+		peek: () => built,
+	};
+}
+
+/** The published model that an entry names, for clients that need its limits. */
+export function upstreamModel(entry: UpstreamEntry, modelId: string): UpstreamModelConfig | undefined {
+	return entry.models.find((m) => m.id === modelId);
+}

package/src/catalog/types.ts

@@ -45,8 +45,8 @@ export interface QualityScores {
 	agentic?: number;
 }
 
-/** Which upstream serves a catalog model. Slugs are namespaced per provider (`ollama/…`). */
-export type CatalogProvider = "openrouter" | "ollama";
+/** Which upstream serves a catalog model: `openrouter`, `ollama`, or a named upstream's id. Slugs are namespaced per provider (`ollama/…`, `<id>/…`). */
+export type CatalogProvider = string;
 
 export interface CatalogModel {
 	/** OpenRouter slug, e.g. `anthropic/claude-sonnet-4.5`, or `ollama/<id>`. Routing identity. */

package/src/config/apply.ts

@@ -14,6 +14,7 @@
  */
 
 import type { RouterConfig } from "./types.ts";
+import { completeUpstreams } from "./upstreams.ts";
 import type { DeepPartial } from "./load.ts";
 
 type Rec = Record<string, unknown>;
@@ -57,7 +58,10 @@ export function assignInPlace(target: Rec, source: Rec, prefix = "", opts: { pru
 
 /** `assignInPlace` over a typed config. Returns the dotted paths that changed. */
 export function applyConfigPatch(live: RouterConfig, patch: DeepPartial<RouterConfig>): string[] {
-	return assignInPlace(live as unknown as Rec, patch as Rec);
+	const changed = assignInPlace(live as unknown as Rec, patch as Rec);
+	// A patched upstream list arrives sparse (what the author set); clients read complete records.
+	if (changed.some((c) => c === "upstreams" || c.startsWith("upstreams."))) completeUpstreams(live);
+	return changed;
 }
 
 /** True when any changed path falls inside `block` (`"ollama"` matches `ollama.apiKey`). */

package/src/config/defaults.ts

@@ -62,6 +62,9 @@ export const DEFAULT_CONFIG: RouterConfig = {
 		// its dashboard is that share × the plan's credits. Unknown until set.
 		planCreditsUsd: 0,
 	},
+	// Named direct upstreams (OpenAI, Azure OpenAI, Anthropic, vLLM…): none until configured.
+	// Each entry's own defaults are filled in by loadConfig (see load.ts).
+	upstreams: [],
 	benchmarks: {
 		// Keyless BenchLM alone fills real gaps, so this is on by default; the AA
 		// feed only actually fires once a key is present (config or env).

package/src/config/hot-reload.ts

@@ -30,6 +30,7 @@ import { existsSync, readFileSync, watch, type FSWatcher } from "node:fs";
 import { parse as parseYaml } from "yaml";
 import { configInputSchema } from "./schema.ts";
 import { assignInPlace } from "./apply.ts";
+import { completeUpstreams } from "./upstreams.ts";
 import { DEFAULT_CONFIG } from "./defaults.ts";
 import { deepMerge, resolveTilde } from "./load.ts";
 import type { RouterConfig } from "./types.ts";
@@ -182,6 +183,8 @@ export function watchConfig(
 		// One in-place pass over the whole config: block identity survives, and a
 		// knob deleted from the file reverts, exactly as a restart would leave it.
 		const changed = assignInPlace(live as unknown as Record<string, unknown>, staged, "", { prune: true });
+		// A reloaded upstream list is as sparse as the file; clients read complete records.
+		if (changed.some((c) => c === "upstreams" || c.startsWith("upstreams."))) completeUpstreams(live);
 		if (changed.length > 0) opts.onReload?.({ changed });
 	};
 

package/src/config/load.ts

@@ -6,6 +6,7 @@ import { DEFAULT_CONFIG } from "./defaults.ts";
 import { configInputSchema } from "./schema.ts";
 import { resolveOllamaKey, resolveOpenRouterKey, type ResolvedCredential } from "./omp-credentials.ts";
 import type { RouterConfig } from "./types.ts";
+import { completeUpstreams } from "./upstreams.ts";
 
 const LOG_LEVELS: readonly RouterConfig["logLevel"][] = ["silent", "error", "warn", "info", "debug"];
 
@@ -161,6 +162,8 @@ export function loadConfig(opts?: { path?: string; overrides?: DeepPartial<Route
 	const ollamaCredential = resolveOllamaKey(cfg.ollama.apiKey);
 	cfg.ollama.apiKey = ollamaCredential.apiKey;
 	ollamaKeyProvenance.set(cfg, ollamaCredential);
+	// Named upstream entries: fill the optional fields so every client reads a complete record.
+	completeUpstreams(cfg);
 
 	return cfg;
 }

package/src/config/schema.ts

@@ -57,6 +57,43 @@ const ollama = z.strictObject({
 	planCreditsUsd: z.number().nonnegative().optional(),
 });
 
+/** Ids that would collide with OpenRouter's own vendor namespaces or the built-in upstreams. */
+export const RESERVED_UPSTREAM_IDS: readonly string[] = ["openrouter", "ollama", "openai", "anthropic", "google", "meta-llama", "mistralai", "x-ai", "deepseek", "qwen", "amazon", "microsoft", "cohere", "perplexity", "nvidia", "moonshotai", "z-ai", "minimax"];
+
+const upstreamModel = z.strictObject({
+	id: z.string().min(1),
+	name: z.string().optional(),
+	input: z.number().nonnegative(),
+	output: z.number().nonnegative(),
+	cachedInput: z.number().nonnegative().optional(),
+	cacheWrite: z.number().nonnegative().optional(),
+	contextLength: z.number().int().positive().optional(),
+	maxCompletionTokens: z.number().int().positive().optional(),
+	supportsTools: z.boolean().optional(),
+	supportsReasoning: z.boolean().optional(),
+	supportsToolChoice: z.boolean().optional(),
+	vision: z.boolean().optional(),
+	quality: z.strictObject({ intelligence: z.number().optional(), coding: z.number().optional(), agentic: z.number().optional() }).optional(),
+	twin: z.string().optional(),
+});
+
+const upstream = z.strictObject({
+	id: z
+		.string()
+		.regex(/^[a-z0-9][a-z0-9-]{0,31}$/, "lowercase letters, digits and dashes")
+		.refine((id) => !RESERVED_UPSTREAM_IDS.includes(id), { message: "this id is a vendor namespace on OpenRouter or a built-in upstream; use e.g. openai-direct, azure-eu, anthropic-direct, vllm" }),
+	kind: z.enum(["openai", "azure", "anthropic"]),
+	enabled: z.boolean().optional(),
+	baseUrl: z.string().min(1),
+	apiKey: z.string().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(),
+	models: z.array(upstreamModel),
+});
+
 const benchmarks = z.strictObject({
 	enabled: z.boolean().optional(),
 	artificialAnalysisApiKey: z.string().optional(),
@@ -268,6 +305,7 @@ export const configInputSchema = z.strictObject({
 		})
 		.optional(),
 	ollama: ollama.optional(),
+	upstreams: z.array(upstream).optional(),
 	filters: filters.optional(),
 	classifier: classifier.optional(),
 	escalation: escalation.optional(),

package/src/config/types.ts

@@ -843,10 +843,65 @@ export interface CompactionConfig {
 	collapseDuplicateResults: boolean;
 }
 
+/** Which API a named upstream speaks. */
+export type UpstreamKind = "openai" | "azure" | "anthropic";
+
+/** One model a named upstream serves, with what routing needs since there is no catalog to fetch. */
+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 cached prompt tokens, when the provider discounts them. */
+	cachedInput?: number;
+	/** USD per million prompt tokens written to cache (Anthropic). */
+	cacheWrite?: number;
+	/** Absent ⇒ the OpenRouter twin's, else 128k. */
+	contextLength?: number;
+	maxCompletionTokens?: number;
+	supportsTools?: boolean;
+	supportsReasoning?: boolean;
+	supportsToolChoice?: boolean;
+	/** Accepts images. Absent ⇒ the twin's. */
+	vision?: boolean;
+	/** 0-100 scores; absent ⇒ borrowed from the OpenRouter twin. */
+	quality?: { intelligence?: number; coding?: number; agentic?: number };
+	/** The OpenRouter slug whose scores and capabilities this model borrows; absent ⇒ matched by name. */
+	twin?: string;
+}
+
+/**
+ * A named upstream beside OpenRouter and Ollama Cloud: OpenAI, Azure OpenAI,
+ * Anthropic, or any OpenAI-compatible server (vLLM, a gateway). Its models
+ * enter the catalog as `<id>/<model>` and dispatch to it.
+ */
+export interface UpstreamEntry {
+	/** Lowercase slug; the catalog namespace. Must not be an OpenRouter vendor namespace such as `openai` or `anthropic`. */
+	id: string;
+	kind: UpstreamKind;
+	enabled: boolean;
+	/** `https://api.openai.com/v1`, `https://<resource>.openai.azure.com`, `https://api.anthropic.com`, `http://vllm:8000/v1`. */
+	baseUrl: string;
+	apiKey: string;
+	/** Azure only: the `api-version` query parameter. */
+	apiVersion: string;
+	/** Extra request headers, e.g. a gateway's own auth. */
+	headers: Record<string, string>;
+	timeoutMs: number;
+	rateLimitCooldownMs: number;
+	quotaCooldownMs: number;
+	models: UpstreamModelConfig[];
+}
+
 export interface RouterConfig {
 	server: ServerConfig;
 	openrouter: OpenRouterConfig;
 	ollama: OllamaConfig;
+	/** Named direct upstreams; empty by default. */
+	upstreams: UpstreamEntry[];
 	benchmarks: BenchmarksConfig;
 	tiers: Record<Tier, TierConfig>;
 	tasks: Record<TaskType, TaskConfig>;

package/src/config/upstreams.ts

@@ -0,0 +1,31 @@
+/**
+ * Named upstream entries as they arrive (a file, an env-built patch, a dashboard patch)
+ * carry only what the author set; every client reads a complete record, so the optional
+ * fields are filled here, at load and after every live apply.
+ */
+
+import type { UpstreamEntry } from "./types.ts";
+
+/** Fills an upstream entry's optional fields, so every client reads a complete record. */
+export function completeUpstreamEntry(raw: Record<string, unknown>): UpstreamEntry {
+	const kind = raw.kind as UpstreamEntry["kind"];
+	return {
+		id: raw.id as string,
+		kind,
+		enabled: typeof raw.enabled === "boolean" ? raw.enabled : true,
+		baseUrl: raw.baseUrl as string,
+		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) ?? {},
+		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,
+		models: (raw.models as UpstreamEntry["models"] | undefined) ?? [],
+	};
+}
+
+/** Replaces the live list's entries with completed ones, in place, when a patch touched them. */
+export function completeUpstreams(cfg: { upstreams: UpstreamEntry[] }): void {
+	const completed = cfg.upstreams.map((u) => completeUpstreamEntry(u as unknown as Record<string, unknown>));
+	cfg.upstreams.splice(0, cfg.upstreams.length, ...completed);
+}

package/src/cost/report.ts

@@ -137,7 +137,30 @@ const USD = "COALESCE(reported_usd, predicted_usd)";
 const PT = "json_extract(usage, '$.promptTokens')";
 const CT = "json_extract(usage, '$.cachedTokens')";
 const COMP = "json_extract(usage, '$.completionTokens')";
-const PROVIDER = "CASE WHEN slug LIKE 'ollama/%' THEN 'ollama' ELSE 'openrouter' END";
+/** Named upstream ids the ledger's provider derivation knows; set by createProviders from the live config. */
+let knownUpstreamIds: () => readonly string[] = () => [];
+/** Ids, or a getter read live so a hot-reloaded list applies; an embedder (the team edition) calls this too, since the registry is per process. */
+export function setKnownUpstreamIds(ids: readonly string[] | (() => readonly string[])): void {
+	const read = typeof ids === "function" ? ids : () => ids;
+	knownUpstreamIds = () => read().filter((id) => /^[a-z0-9][a-z0-9-]{0,31}$/.test(id));
+}
+export function knownUpstreams(): readonly string[] {
+	return knownUpstreamIds();
+}
+/** The provider of a slug: its namespace when that names a known upstream, else OpenRouter's own. */
+export function providerOfSlug(slug: string): string {
+	if (slug.startsWith("ollama/")) return "ollama";
+	const cut = slug.indexOf("/");
+	if (cut > 0) {
+		const head = slug.slice(0, cut);
+		if (knownUpstreamIds().includes(head)) return head;
+	}
+	return "openrouter";
+}
+/** SQL twin of providerOfSlug; ids are validated to a slug alphabet so they can be inlined. */
+function providerCase(): string {
+	return `CASE WHEN slug LIKE 'ollama/%' THEN 'ollama' ${knownUpstreamIds().map((id) => `WHEN slug LIKE '${id}/%' THEN '${id}'`).join(" ")} ELSE 'openrouter' END`;
+}
 const STREAMED = "ttft_ms IS NOT NULL AND ttft_ms > 0 AND error IS NULL";
 const EST = "json_extract(usage, '$.cachedEstimated') = 1";
 /** Rows a forecast can be judged on: a reported cost, a prediction, clean and kept, not a side call. */
@@ -277,7 +300,7 @@ export function buildUsageReport(
 
 	const windowSpend = t.spend;
 	const providers = (
-		db.query(`SELECT ${PROVIDER} AS key, ${ROW_SELECT} FROM ledger WHERE ${where} GROUP BY key ORDER BY spend DESC`).all(bind) as RawRow[]
+		db.query(`SELECT ${providerCase()} AS key, ${ROW_SELECT} FROM ledger WHERE ${where} GROUP BY key ORDER BY spend DESC`).all(bind) as RawRow[]
 	).map((r) => toRow(r, windowSpend));
 
 	const modelRows = db

package/src/cost/views.ts

@@ -8,6 +8,7 @@
  * columns and accept a read-only database handle.
  */
 
+import { providerOfSlug } from "./report.ts";
 import type { Database } from "bun:sqlite";
 import { harnessFilter } from "./report.ts";
 
@@ -120,7 +121,7 @@ export function exportRows(db: Database, sinceMs: number, harness: HarnessScope)
 		day: r.day,
 		harnessId: r.harness_id,
 		slug: r.slug,
-		provider: r.slug.startsWith("ollama/") ? "ollama" : "openrouter",
+		provider: providerOfSlug(r.slug),
 		dispatches: r.dispatches,
 		promptTokens: r.prompt_tokens,
 		cachedTokens: r.cached_tokens,

package/src/lib.ts

@@ -15,7 +15,9 @@
 export { startServer, type ReconfigureResult, type StartedServer } from "./server/http.ts";
 export { loadConfig, apiKeySource } from "./config/load.ts";
 export { DEFAULT_CONFIG } from "./config/defaults.ts";
-export type { RouterConfig } from "./config/types.ts";
+export type { RouterConfig, UpstreamEntry, UpstreamKind, UpstreamModelConfig } from "./config/types.ts";
+export { RESERVED_UPSTREAM_IDS } from "./config/schema.ts";
+export { setKnownUpstreamIds, providerOfSlug } from "./cost/report.ts";
 export type { DeepPartial } from "./config/load.ts";
 export { buildUsageReport, renderUsageReport, type UsageReport, type ReportTotals } from "./cost/report.ts";
 export { buildDailySummary, renderDailySummary, type DailySummary } from "./cost/summary.ts";

package/src/server/http.ts

@@ -226,7 +226,8 @@ export function startServer(cfg: RouterConfig): StartedServer {
 	if (cfg.ledger.path !== ":memory:") mkdirSync(dirname(cfg.ledger.path), { recursive: true });
 	const db = openDb(cfg.ledger.path);
 	const ledger = createLedger(db, cfg);
-	const { upstream, catalog, ollama, ollamaServing, ollamaUsage, ollamaCostScale } = createProviders(cfg, db, log);
+	const providers = createProviders(cfg, db, log);
+	const { upstream, catalog, ollama, ollamaServing, ollamaUsage, ollamaCostScale } = providers;
 	const conversations = createConversationStore(db);
 	const router = createRouter({ config: cfg, catalog, ledger, conversations, upstream });
 	const context = createBridgeFromConfig(cfg, db);
@@ -272,6 +273,10 @@ export function startServer(cfg: RouterConfig): StartedServer {
 		if (cfg.ollama.enabled) 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");
 	}
+	for (const u of cfg.upstreams) {
+		if (!u.enabled) continue;
+		log.info(`named upstream enabled: ${u.id}`, { kind: u.kind, baseUrl: u.baseUrl, models: u.models.length, apiKeyConfigured: u.apiKey !== "" });
+	}
 	if (cfg.ollama.enabled) {
 		log.info("ollama cloud upstream enabled", {
 			baseUrl: cfg.ollama.baseUrl,
@@ -639,7 +644,12 @@ export function startServer(cfg: RouterConfig): StartedServer {
 						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"] : []), ...(ollamaServing() ? ["ollama"] : [])],
+						serving: [...(cfg.openrouter.apiKey !== "" ? ["openrouter"] : []), ...(ollamaServing() ? ["ollama"] : []), ...providers.namedServing()],
+						// Named direct upstreams: never the key. `available` is each one's breaker.
+						upstreams: cfg.upstreams.map((u) => {
+							const client = providers.named(u.id);
+							return { id: u.id, kind: u.kind, enabled: u.enabled, baseUrl: u.baseUrl, apiKeyConfigured: u.apiKey !== "", models: u.models.length, available: client?.available() ?? true, cooldownUntilMs: client?.cooldownUntilMs() ?? null, lastTrip: client?.lastTrip() ?? null };
+						}),
 						// Provenance only; never the key itself.
 						apiKeySource: apiKeySource(cfg).source,
 						// Provenance only; never the agentdox token itself.

package/src/server/providers.ts

@@ -6,6 +6,9 @@
 
 import type { Database } from "bun:sqlite";
 import { createCompositeCatalog } from "../catalog/composite.ts";
+import { createStaticCatalogSource } from "../catalog/static-catalog.ts";
+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";
@@ -13,6 +16,7 @@ import type { RouterConfig } from "../config/types.ts";
 import { createMultiUpstream } from "../upstream/multi.ts";
 import { createOllamaClient, type OllamaClient } from "../upstream/ollama.ts";
 import { createLedger } from "../cost/ledger.ts";
+import { setKnownUpstreamIds } from "../cost/report.ts";
 import { createOllamaUsageSource, type OllamaUsageSource } from "../upstream/ollama-usage.ts";
 import { createOpenRouterClient } from "../upstream/openrouter.ts";
 import type { UpstreamClient } from "../upstream/types.ts";
@@ -29,6 +33,10 @@ export interface Providers {
 	ollamaUsage: OllamaUsageSource;
 	/** Multiplier that brings the ledger's Ollama estimate in line with the plan meter; 1 until calibrated. */
 	ollamaCostScale: () => number;
+	/** The client for a named upstream id, built on first use; undefined for an id not configured. */
+	named(id: string): NamedUpstreamClient | undefined;
+	/** Ids of the named upstreams that can take a turn now: enabled, keyed, out of cooldown. */
+	namedServing(): string[];
 }
 
 export function createProviders(cfg: RouterConfig, db: Database, log: Logger = createLogger(cfg.logLevel)): Providers {
@@ -53,18 +61,43 @@ export function createProviders(cfg: RouterConfig, db: Database, log: Logger = c
 		// estimate can be scaled to what ollama.com actually bills.
 		calibration: { db, ledgerUsd: () => ledgerForCalibration.providerSpendSince?.("ollama/", 0) ?? 0, planCreditsOverrideUsd: cfg.ollama.planCreditsUsd },
 	});
+	// Named upstreams (OpenAI, Azure, Anthropic, vLLM…): a client per id, built when
+	// first needed and kept — its breaker state must survive config reloads — while
+	// the entry it reads is looked up live, so a changed key or URL applies at once.
+	const namedClients = new Map<string, NamedUpstreamClient>();
+	const named = (id: string): NamedUpstreamClient | undefined => {
+		const entry = cfg.upstreams.find((u) => u.id === id);
+		if (entry === undefined) return undefined;
+		let client = namedClients.get(id);
+		if (client === undefined) {
+			client = entry.kind === "anthropic" ? createAnthropicClient(cfg, id) : createCompatClient(cfg, id);
+			namedClients.set(id, client);
+		}
+		return client;
+	};
+	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);
+		return named(id)?.available() ?? false;
+	};
+	const namedServing = (): string[] => cfg.upstreams.filter((u) => u.enabled && namedServingOne(u.id)).map((u) => u.id);
+	const staticCatalog = createStaticCatalogSource(cfg, log);
+	setKnownUpstreamIds(() => cfg.upstreams.map((u) => u.id));
 	return {
-		upstream: createMultiUpstream(openrouter, ollama),
+		upstream: createMultiUpstream(openrouter, ollama, named, () => cfg.upstreams.map((u) => u.id)),
 		catalog: createCompositeCatalog(openrouterCatalog, createOllamaCatalog(cfg.ollama, log, fetch, db), { available: ollamaServing, cooldownUntilMs: () => ollama.cooldownUntilMs(), lastTrip: () => ollama.lastTrip() }, {
 			costBias: cfg.ollama.costBias,
 			biasUntilUsage: cfg.ollama.biasUntilUsage,
 			usage: ollamaUsage,
 			live: () => ({ costBias: cfg.ollama.costBias, biasUntilUsage: cfg.ollama.biasUntilUsage }),
 			serveOpenRouter: () => cfg.openrouter.apiKey !== "",
+			named: { models: (base) => staticCatalog.get(base), serving: namedServingOne },
 		}),
 		ollama,
 		ollamaServing,
 		ollamaUsage,
 		ollamaCostScale: () => ollamaUsage.calibration()?.factor ?? 1,
+		named,
+		namedServing,
 	};
 }