auto-model-router 0.11.0 → 0.13.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.11.0",
+    "version": "0.13.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.11.0",
+      "version": "0.13.0",
       "author": {
         "name": "drewappling",
         "email": "drewappling@gmail.com"

package/README.md

@@ -1355,6 +1355,66 @@ becomes Claude Code's key helper and, with `--profile`, goes on PATH. `connect
 `remote.json` records the executable, and a refresh from inside omp keeps the helper
 pointed at it.
 
+### The remote's skills come along
+
+A remote that serves a skills bundle (`GET <url>/setup/skills` with the member key: a
+version and a list of `{ name, files }`, each with a `SKILL.md`) has it installed by
+`connect`, and by every refresh, into the harnesses it configured that read user-level
+skills: Claude Code's `~/.claude/skills/<name>/` and omp's `~/.omp/agent/skills/<name>/`.
+`<router home>/skills-installed.json` records what was placed, so an update removes what
+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.11.0",
+  "version": "0.13.0",
   "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,89 @@
+/**
+ * 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),
+			isFree: m.input === 0 && m.output === 0,
+			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/cli/connect.ts

@@ -31,6 +31,7 @@ import { fileURLToPath } from "node:url";
 import { refreshAccountOf, remoteFilePath } from "../../omp-extension/remote-logic.ts";
 import { SCOPE_ENV } from "../context/scope.ts";
 import { executablePath, materializePackage, readEmbeddedPackage } from "./embedded.ts";
+import { fetchSkills, installSkills, type SkillsBundle, type SkillsInstallReport, type SkillsTarget } from "./skills.ts";
 import { pickStore, saveRefreshToken, type StoreDeps, type StoreKind } from "./credential-store.ts";
 import { flagString, type CliArgs } from "./args.ts";
 
@@ -65,6 +66,8 @@ export interface ConnectOptions {
 	 * remote.json records it so a refresh from omp keeps pointing at it.
 	 */
 	exePath?: string;
+	/** The remote's skills bundle, installed into every configured harness that reads user-level skills. */
+	skills?: SkillsBundle;
 	platform: string;
 	pathHas: (bin: string) => boolean;
 }
@@ -75,6 +78,8 @@ export interface ConnectReport {
 	skipped: string[];
 	envLines: string[];
 	notes: string[];
+	/** What the remote's skills bundle did, when there was one. */
+	skills?: SkillsInstallReport;
 }
 
 const expand = (raw: string, home: string): string => (raw === "~" || raw.startsWith("~/") || raw.startsWith("~\\") ? join(home, raw.slice(1)) : raw);
@@ -360,6 +365,17 @@ export function connectRemote(o: ConnectOptions): ConnectReport {
 	report.envLines.unshift(`AUTO_MODEL_ROUTER_URL=${o.url}`, `AUTO_MODEL_ROUTER_API_KEY=${o.key}`);
 	report.envLines = [...new Set(report.envLines)];
 
+	// 6b. The remote's skills, into the harnesses configured above that read a
+	// user-level skills directory. Hermes, Codex and Aider have none we know of.
+	if (o.skills !== undefined) {
+		const targets: SkillsTarget[] = [];
+		if (report.configured.some((c) => c.startsWith("omp ("))) targets.push({ harness: "omp", dir: join(agentDir, "skills") });
+		if (report.configured.some((c) => c.startsWith("Claude Code ("))) targets.push({ harness: "Claude Code", dir: join(claudeDir, "skills") });
+		report.skills = installSkills(o.skills, targets, rh, o.dryRun);
+		if (report.skills.placed.length > 0) report.configured.push(`skills ${o.skills.version} (${report.skills.placed.join(", ")})`);
+		for (const s of report.skills.skipped) report.notes.push(`skill ${s}`);
+	}
+
 	// 7. Persist the environment.
 	if (o.profile && !o.dryRun) {
 		if (o.platform === "win32") {
@@ -445,6 +461,7 @@ export async function connectCommand(args: CliArgs): Promise<void> {
 	const pathHas = (bin: string): boolean => Bun.which(bin) !== null;
 	const packageDir = await resolvePackageDir();
 	const exePath = executablePath();
+	const fetchImpl = fetch;
 	let name = flagString(args, "name") ?? "";
 	let userId = flagString(args, "user-id") ?? "";
 	let device = flagString(args, "device") ?? "";
@@ -476,6 +493,8 @@ export async function connectCommand(args: CliArgs): Promise<void> {
 	// A single-project machine can label every request; a machine with several
 	// repos should leave it off and let the extensions send the workspace's own.
 	const scopeFlag = flagString(args, "scope");
+	// The remote's skills for the agents on this machine; a remote without any serves 404.
+	const skills = await fetchSkills(url, key, fetchImpl);
 	const report = connectRemote({
 		url,
 		key,
@@ -495,7 +514,9 @@ export async function connectCommand(args: CliArgs): Promise<void> {
 		...(Number.isFinite(refreshExpires) ? { refreshExpiresAtMs: refreshExpires } : {}),
 		...(device === "" ? {} : { device }),
 		...(exePath === null ? {} : { exePath }),
+		...(skills.bundle === null ? {} : { skills: skills.bundle }),
 	});
+	if (skills.note !== undefined) report.notes.push(skills.note);
 	if (exePath !== null) console.log(`executable ${exePath}; package files under ${packageDir}`);
 	console.log(`${args.flags.has("dry-run") ? "would write" : "wrote"} ${report.remoteFile}${name === "" ? "" : ` for ${name}`}`);
 	for (const c of report.configured) console.log(`  configured ${c}`);

package/src/cli/refresh.ts

@@ -14,6 +14,7 @@
  */
 
 import { executablePath, materializePackage, readEmbeddedPackage } from "./embedded.ts";
+import { fetchSkills } from "./skills.ts";
 import { homedir } from "node:os";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -96,6 +97,8 @@ export async function refreshAndRewrite(opts: { remote: RemoteRouter; fetchImpl?
 	const embedded = opts.packageDir === undefined ? await readEmbeddedPackage() : null;
 	const packageDir = opts.packageDir ?? (embedded === null ? resolve(dirname(fileURLToPath(import.meta.url)), "..", "..") : materializePackage(rh, embedded));
 	const exePath = opts.remote.executable ?? executablePath() ?? undefined;
+	// A refresh is when the team's skills reach a machine that has not re-run connect.
+	const skills = await fetchSkills(opts.remote.url, fresh.key, opts.fetchImpl ?? fetch);
 	connectRemote({
 		url: opts.remote.url,
 		key: fresh.key,
@@ -117,6 +120,7 @@ export async function refreshAndRewrite(opts: { remote: RemoteRouter; fetchImpl?
 		...(opts.remote.refreshTokenStore !== undefined ? { store: opts.remote.refreshTokenStore } : {}),
 		...(opts.storeDeps !== undefined ? { storeDeps: opts.storeDeps } : {}),
 		...(exePath !== undefined ? { exePath } : {}),
+		...(skills.bundle === null ? {} : { skills: skills.bundle }),
 		// undefined keeps whatever scope the managed models.yml block already carries.
 	});
 	return fresh;

package/src/cli/skills.ts

@@ -0,0 +1,145 @@
+/**
+ * Skills served by a remote router, installed by `connect`.
+ *
+ * A coding agent is only as good as the instructions it carries, and a team
+ * has instructions it wants every member's agent to have: how its shared
+ * context works, how to use the router well. The remote serves them as one
+ * versioned bundle (`GET <url>/setup/skills`, with the member key), and
+ * `connect` writes them into every harness it configures that reads a
+ * user-level skills directory — Claude Code's `~/.claude/skills`, omp's
+ * `~/.omp/agent/skills`. A manifest under the router home records what was
+ * placed, so an update removes what the bundle no longer carries and a skill
+ * the member wrote themselves under the same name is never touched.
+ */
+
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+export interface SkillsBundle {
+	/** Changes whenever any file changes; what `connect` reports and remembers. */
+	version: string;
+	skills: { name: string; files: Record<string, string> }[];
+}
+
+const NAME = /^[a-z0-9][a-z0-9._-]{0,63}$/;
+const REL = /^(?!\.)(?!.*\/\.)[A-Za-z0-9._-]+(?:\/[A-Za-z0-9._-]+)*$/;
+
+/** Parses a bundle defensively: a malformed one installs nothing rather than something odd. */
+export function parseSkillsBundle(value: unknown): SkillsBundle | null {
+	if (typeof value !== "object" || value === null) return null;
+	const raw = value as Record<string, unknown>;
+	if (typeof raw.version !== "string" || raw.version === "" || !Array.isArray(raw.skills)) return null;
+	const skills: SkillsBundle["skills"] = [];
+	for (const s of raw.skills) {
+		if (typeof s !== "object" || s === null) return null;
+		const r = s as Record<string, unknown>;
+		if (typeof r.name !== "string" || !NAME.test(r.name) || typeof r.files !== "object" || r.files === null) return null;
+		const files: Record<string, string> = {};
+		for (const [rel, content] of Object.entries(r.files as Record<string, unknown>)) {
+			if (!REL.test(rel) || typeof content !== "string") return null;
+			files[rel] = content;
+		}
+		if (files["SKILL.md"] === undefined) return null;
+		skills.push({ name: r.name, files });
+	}
+	return { version: raw.version, skills };
+}
+
+/** The remote's bundle, or null when it serves none (404) or cannot be reached; never throws. */
+export async function fetchSkills(url: string, key: string, fetchImpl: typeof fetch = fetch): Promise<{ bundle: SkillsBundle | null; note?: string }> {
+	try {
+		const res = await fetchImpl(`${url}/setup/skills`, { headers: { authorization: `Bearer ${key}` }, signal: AbortSignal.timeout(15_000) });
+		if (res.status === 404) return { bundle: null };
+		if (!res.ok) return { bundle: null, note: `skills: ${url}/setup/skills answered ${res.status}; nothing installed` };
+		const bundle = parseSkillsBundle(await res.json());
+		return bundle === null ? { bundle: null, note: "skills: the remote's bundle was not understood; nothing installed" } : { bundle };
+	} catch (err) {
+		return { bundle: null, note: `skills: could not fetch ${url}/setup/skills (${err instanceof Error ? err.message : String(err)}); nothing installed` };
+	}
+}
+
+export interface SkillsTarget {
+	/** Shown in the report: "Claude Code", "omp". */
+	harness: string;
+	/** The harness's user-level skills directory; each skill goes in `<dir>/<name>/`. */
+	dir: string;
+}
+
+export interface SkillsInstallReport {
+	version: string;
+	/** "<harness>: <name>" per skill written. */
+	placed: string[];
+	/** Files from an earlier install the bundle no longer carries. */
+	removed: string[];
+	/** Skills left alone because the member has their own of that name there. */
+	skipped: string[];
+}
+
+interface Manifest {
+	version: string;
+	files: string[];
+}
+
+export function skillsManifestPath(routerHome: string): string {
+	return join(routerHome, "skills-installed.json");
+}
+
+export function readSkillsManifest(routerHome: string): Manifest | null {
+	try {
+		const raw = JSON.parse(readFileSync(skillsManifestPath(routerHome), "utf8")) as Record<string, unknown>;
+		return typeof raw.version === "string" && Array.isArray(raw.files) ? { version: raw.version, files: raw.files.filter((f): f is string => typeof f === "string") } : null;
+	} catch {
+		return null;
+	}
+}
+
+const norm = (p: string): string => p.replaceAll("\\", "/");
+
+/**
+ * Writes the bundle into each target, records what it placed, removes what a
+ * previous install placed that is gone now, and skips a skill directory it did
+ * not create. Pure over the file system: no network, so a test can drive it.
+ */
+export function installSkills(bundle: SkillsBundle, targets: readonly SkillsTarget[], routerHome: string, dryRun = false): SkillsInstallReport {
+	const previous = readSkillsManifest(routerHome);
+	const ours = new Set((previous?.files ?? []).map(norm));
+	const report: SkillsInstallReport = { version: bundle.version, placed: [], removed: [], skipped: [] };
+	const placedFiles: string[] = [];
+	for (const t of targets) {
+		for (const skill of bundle.skills) {
+			const dir = join(t.dir, skill.name);
+			const foreign = existsSync(dir) && !readdirSync(dir).some((f) => ours.has(norm(join(dir, f))));
+			if (foreign) {
+				report.skipped.push(`${t.harness}: ${skill.name} (a skill of that name is already there and was not placed by connect; left alone)`);
+				continue;
+			}
+			for (const [rel, content] of Object.entries(skill.files)) {
+				const path = join(dir, ...rel.split("/"));
+				placedFiles.push(norm(path));
+				if (dryRun) continue;
+				mkdirSync(dirname(path), { recursive: true });
+				writeFileSync(path, content, "utf8");
+			}
+			report.placed.push(`${t.harness}: ${skill.name}`);
+		}
+	}
+	const keep = new Set(placedFiles);
+	for (const old of ours) {
+		if (keep.has(old)) continue;
+		report.removed.push(old);
+		if (dryRun) continue;
+		rmSync(old, { force: true });
+		// An emptied skill directory goes too, so the harness does not list a hollow skill.
+		const parent = dirname(old);
+		try {
+			if (readdirSync(parent).length === 0) rmSync(parent, { recursive: true, force: true });
+		} catch {
+			/* already gone */
+		}
+	}
+	if (!dryRun) {
+		mkdirSync(routerHome, { recursive: true });
+		writeFileSync(skillsManifestPath(routerHome), `${JSON.stringify({ version: bundle.version, files: placedFiles } satisfies Manifest, null, 2)}\n`, "utf8");
+	}
+	return report;
+}

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/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>;