auto-model-router 0.11.0 → 0.13.0

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,28 @@ 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[] = [];
+export function setKnownUpstreamIds(ids: readonly string[]): void {
+	knownUpstreamIds = ids.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 +298,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/index.ts

@@ -28,7 +28,7 @@ Usage: auto-model-router <command> [options]
   stats      Show routed spend, per-model share, and escalation rates
   report     Usage analytics: providers, models, tiers, cost, speed, cache hit rate
   export     One row per day, harness and model as CSV (--json for rows)
-  connect    Point this machine at a remote router (--url with --key[, --refresh-token] or --setup-token <one-time token from a team>; --scope pins one project for the whole machine (default: each workspace's own); --profile persists the environment and, from the compiled executable, PATH)
+  connect    Point this machine at a remote router (--url with --key[, --refresh-token] or --setup-token <one-time token from a team>; --scope pins one project for the whole machine (default: each workspace's own); --profile persists the environment and, from the compiled executable, PATH; the remote's skills are installed for Claude Code and omp)
   refresh    Trade the refresh token for a new access key and re-write every harness config (--force: even when not near expiry)
   token      Print an access key that is good right now, refreshing first if needed (for a harness key-helper)
   models     Show what each complexity tier would consider, and why

package/src/lib.ts

@@ -15,7 +15,8 @@
 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 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";
@@ -24,5 +25,6 @@ export { spendUsdSince, feedbackView, exportRows, exportCsv, harnessScopeParam,
 export { createLedger } from "./cost/ledger.ts";
 export { createFeedbackStore, type FeedbackStore, type FeedbackRecord } from "./cost/feedback.ts";
 export { buildExecutable, collectPackageFiles, executableFileName, hostTarget, isExecutableTarget, EXECUTABLE_TARGETS, type ExecutableTarget, type BuildExecutableResult } from "./cli/build-executable.ts";
+export { parseSkillsBundle, type SkillsBundle } from "./cli/skills.ts";
 export type { RequestPolicy } from "./wire/types.ts";
 export type { Ledger, LedgerEntry } from "./cost/types.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,
 	};
 }