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

package/README.md

@@ -1365,6 +1365,12 @@ 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.
 
+A remote whose `/setup/info` says `mcp: true` (a team edition serving shared context) also
+gets a `team-context` MCP server written for omp (`~/.omp/agent/mcp.json`) and Claude Code
+(`~/.claude.json`): `type: http`, the remote's `/mcp`, the member key in the Authorization
+header. Every refresh rewrites it with the current key, like models.yml; other servers in
+those files are untouched, and a remote that stops serving MCP has the entry removed.
+
 ## Direct upstreams: OpenAI, Azure OpenAI, Anthropic, vLLM
 
 OpenRouter and Ollama Cloud are the built-in upstreams. `upstreams:` adds named ones the

package/package.json

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

package/src/catalog/static-catalog.ts

@@ -47,7 +47,8 @@ export function buildUpstreamModels(entry: UpstreamEntry, openrouter: readonly C
 			priceTiers: [],
 			quality: m.quality !== undefined ? { ...m.quality } : twin === null ? {} : { ...twin.quality },
 			tokenizer: tokenizerFor(entry.kind, twin),
-			isFree: m.input === 0 && m.output === 0,
+			// 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,
 		};

package/src/cli/connect.ts

@@ -68,6 +68,12 @@ export interface ConnectOptions {
 	exePath?: string;
 	/** The remote's skills bundle, installed into every configured harness that reads user-level skills. */
 	skills?: SkillsBundle;
+	/**
+	 * The remote's MCP endpoint (a team edition serving shared context): written as the
+	 * `team-context` server for omp and Claude Code with the member key, rewritten on every
+	 * refresh like models.yml. `null` removes an entry a previous connect wrote.
+	 */
+	mcp?: { url: string | null };
 	platform: string;
 	pathHas: (bin: string) => boolean;
 }
@@ -80,6 +86,39 @@ export interface ConnectReport {
 	notes: string[];
 	/** What the remote's skills bundle did, when there was one. */
 	skills?: SkillsInstallReport;
+	/** Files that gained (or lost) the team-context MCP server. */
+	mcp?: string[];
+}
+
+/** The name of the MCP server connect manages in a harness's config. */
+export const MCP_SERVER_NAME = "team-context";
+
+/**
+ * Merges the team-context server into an `mcpServers` JSON file (omp's mcp.json, Claude
+ * Code's ~/.claude.json), leaving every other key and server alone; `url` null removes it.
+ * Returns the new text, or null when nothing changes.
+ */
+export function mergeMcpServers(before: string, url: string | null, key: string): string | null {
+	let root: Record<string, unknown> = {};
+	if (before.trim() !== "") {
+		try {
+			const parsed = JSON.parse(before) as unknown;
+			if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
+			root = parsed as Record<string, unknown>;
+		} catch {
+			return null; // a file we cannot parse is not ours to rewrite
+		}
+	}
+	const servers = { ...((root.mcpServers as Record<string, unknown> | undefined) ?? {}) };
+	if (url === null) {
+		if (!(MCP_SERVER_NAME in servers)) return null;
+		delete servers[MCP_SERVER_NAME];
+	} else {
+		const next = { type: "http", url, headers: { Authorization: `Bearer ${key}` } };
+		if (JSON.stringify(servers[MCP_SERVER_NAME]) === JSON.stringify(next)) return null;
+		servers[MCP_SERVER_NAME] = next;
+	}
+	return `${JSON.stringify({ ...root, mcpServers: servers }, null, 2)}\n`;
 }
 
 const expand = (raw: string, home: string): string => (raw === "~" || raw.startsWith("~/") || raw.startsWith("~\\") ? join(home, raw.slice(1)) : raw);
@@ -376,6 +415,24 @@ export function connectRemote(o: ConnectOptions): ConnectReport {
 		for (const s of report.skills.skipped) report.notes.push(`skill ${s}`);
 	}
 
+	// 6c. The remote's MCP endpoint (shared context tools), for the harnesses configured above
+	// that read a user-level mcpServers file; the member key travels in the header and is
+	// rewritten with every refresh, like models.yml.
+	if (o.mcp !== undefined) {
+		const files: string[] = [];
+		if (report.configured.some((c) => c.startsWith("omp ("))) files.push(join(agentDir, "mcp.json"));
+		if (report.configured.some((c) => c.startsWith("Claude Code ("))) files.push(join(o.home, ".claude.json"));
+		report.mcp = [];
+		for (const path of files) {
+			const before = existsSync(path) ? readFileSync(path, "utf8") : "";
+			const after = mergeMcpServers(before, o.mcp.url, o.key);
+			if (after === null) continue;
+			write(path, after);
+			report.mcp.push(path);
+		}
+		if (o.mcp.url !== null && files.length > 0) report.configured.push(`MCP (${MCP_SERVER_NAME} → ${o.mcp.url}: ${files.map((f) => f.replaceAll("\\", "/")).join(", ")})`);
+	}
+
 	// 7. Persist the environment.
 	if (o.profile && !o.dryRun) {
 		if (o.platform === "win32") {
@@ -433,6 +490,18 @@ export async function exchangeSetupToken(url: string, token: string, device: str
 	};
 }
 
+/** What a team edition says about itself at /setup/info; a plain router answers nothing. */
+export async function fetchSetupInfo(url: string, fetchImpl: typeof fetch = fetch): Promise<{ mcp: boolean }> {
+	try {
+		const res = await fetchImpl(`${url}/setup/info`, { signal: AbortSignal.timeout(10_000) });
+		if (!res.ok) return { mcp: false };
+		const body = (await res.json()) as { mcp?: unknown };
+		return { mcp: body.mcp === true };
+	} catch {
+		return { mcp: false };
+	}
+}
+
 /** Adds `dir` to the user's PATH on Windows, once, through the registry-backed API rather than setx. */
 function addToUserPathWindows(dir: string): void {
 	const quoted = `'${dir.replaceAll("'", "''")}'`;
@@ -495,6 +564,8 @@ export async function connectCommand(args: CliArgs): Promise<void> {
 	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);
+	// Its shared-context MCP endpoint, when it is a team edition serving one.
+	const info = await fetchSetupInfo(url, fetchImpl);
 	const report = connectRemote({
 		url,
 		key,
@@ -515,6 +586,7 @@ export async function connectCommand(args: CliArgs): Promise<void> {
 		...(device === "" ? {} : { device }),
 		...(exePath === null ? {} : { exePath }),
 		...(skills.bundle === null ? {} : { skills: skills.bundle }),
+		mcp: { url: info.mcp ? `${url}/mcp` : null },
 	});
 	if (skills.note !== undefined) report.notes.push(skills.note);
 	if (exePath !== null) console.log(`executable ${exePath}; package files under ${packageDir}`);

package/src/cli/refresh.ts

@@ -14,6 +14,7 @@
  */
 
 import { executablePath, materializePackage, readEmbeddedPackage } from "./embedded.ts";
+import { fetchSetupInfo } from "./connect.ts";
 import { fetchSkills } from "./skills.ts";
 import { homedir } from "node:os";
 import { dirname, resolve } from "node:path";
@@ -99,6 +100,7 @@ export async function refreshAndRewrite(opts: { remote: RemoteRouter; fetchImpl?
 	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);
+	const info = await fetchSetupInfo(opts.remote.url, opts.fetchImpl ?? fetch);
 	connectRemote({
 		url: opts.remote.url,
 		key: fresh.key,
@@ -121,6 +123,7 @@ export async function refreshAndRewrite(opts: { remote: RemoteRouter; fetchImpl?
 		...(opts.storeDeps !== undefined ? { storeDeps: opts.storeDeps } : {}),
 		...(exePath !== undefined ? { exePath } : {}),
 		...(skills.bundle === null ? {} : { skills: skills.bundle }),
+		mcp: { url: info.mcp ? `${opts.remote.url}/mcp` : null },
 		// undefined keeps whatever scope the managed models.yml block already carries.
 	});
 	return fresh;

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/cost/report.ts

@@ -138,12 +138,14 @@ const PT = "json_extract(usage, '$.promptTokens')";
 const CT = "json_extract(usage, '$.cachedTokens')";
 const COMP = "json_extract(usage, '$.completionTokens')";
 /** 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));
+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;
+	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 {
@@ -151,13 +153,13 @@ export function providerOfSlug(slug: string): string {
 	const cut = slug.indexOf("/");
 	if (cut > 0) {
 		const head = slug.slice(0, cut);
-		if (knownUpstreamIds.includes(head)) return head;
+		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`;
+	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";

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; the remote's skills are installed for Claude Code and omp)
+  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 and its MCP endpoint 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

@@ -17,6 +17,7 @@ export { loadConfig, apiKeySource } from "./config/load.ts";
 export { DEFAULT_CONFIG } from "./config/defaults.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/providers.ts

@@ -82,7 +82,7 @@ export function createProviders(cfg: RouterConfig, db: Database, log: Logger = c
 	};
 	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));
+	setKnownUpstreamIds(() => cfg.upstreams.map((u) => u.id));
 	return {
 		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() }, {

package/test/mcp-entry.test.ts

@@ -0,0 +1,157 @@
+import { describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { connectRemote, fetchSetupInfo, MCP_SERVER_NAME, mergeMcpServers } from "../src/cli/connect.ts";
+import { refreshAndRewrite } from "../src/cli/refresh.ts";
+import { parseRemoteRouter } from "../omp-extension/remote-logic.ts";
+
+const NL = "\n";
+const read = (p: string): Record<string, unknown> => JSON.parse(readFileSync(p, "utf8")) as Record<string, unknown>;
+const servers = (p: string): Record<string, unknown> => (read(p).mcpServers as Record<string, unknown>) ?? {};
+const auth = (p: string): string => (servers(p)[MCP_SERVER_NAME] as { headers: { Authorization: string } }).headers.Authorization;
+
+describe("mergeMcpServers", () => {
+	test("adds the team-context server next to the others and keeps every other key", () => {
+		const before = JSON.stringify({ $schema: "https://x/mcp-schema.json", mcpServers: { agentdox: { type: "http", url: "http://localhost:3003/mcp" } }, other: 1 });
+		const after = mergeMcpServers(before, "https://team.example/mcp", "amrt_k");
+		expect(after).not.toBeNull();
+		const doc = JSON.parse(after!) as Record<string, unknown>;
+		expect(doc.$schema).toBe("https://x/mcp-schema.json");
+		expect(doc.other).toBe(1);
+		expect(doc.mcpServers).toEqual({
+			agentdox: { type: "http", url: "http://localhost:3003/mcp" },
+			[MCP_SERVER_NAME]: { type: "http", url: "https://team.example/mcp", headers: { Authorization: "Bearer amrt_k" } },
+		});
+		expect(after!.endsWith("\n")).toBe(true);
+	});
+
+	test("an empty or missing file becomes a fresh mcpServers document", () => {
+		expect(JSON.parse(mergeMcpServers("", "https://t/mcp", "k")!)).toEqual({ mcpServers: { [MCP_SERVER_NAME]: { type: "http", url: "https://t/mcp", headers: { Authorization: "Bearer k" } } } });
+		expect(JSON.parse(mergeMcpServers("  \n", "https://t/mcp", "k")!)).toHaveProperty("mcpServers");
+	});
+
+	test("is idempotent, removes on null, and leaves a file it cannot parse alone", () => {
+		const one = mergeMcpServers("", "https://t/mcp", "k")!;
+		expect(mergeMcpServers(one, "https://t/mcp", "k")).toBeNull(); // unchanged
+		expect(mergeMcpServers(one, "https://t/mcp", "k2")).not.toBeNull(); // a new key rewrites
+		const removed = mergeMcpServers(one, null, "k")!;
+		expect(JSON.parse(removed)).toEqual({ mcpServers: {} });
+		expect(mergeMcpServers(removed, null, "k")).toBeNull(); // nothing to remove
+		expect(mergeMcpServers("{ not json", "https://t/mcp", "k")).toBeNull();
+		expect(mergeMcpServers("[1,2]", "https://t/mcp", "k")).toBeNull();
+	});
+});
+
+describe("connect writes the team MCP endpoint", () => {
+	function fixture(): { home: string; agent: string; env: Record<string, string> } {
+		const home = mkdtempSync(join(tmpdir(), "amr-mcp-connect-"));
+		mkdirSync(join(home, ".claude"), { recursive: true });
+		const agent = join(home, ".omp", "agent");
+		mkdirSync(agent, { recursive: true });
+		writeFileSync(join(agent, "config.yml"), `extensions: []${NL}`, "utf8");
+		const env = { HOME: home, PI_CODING_AGENT_DIR: agent, AUTO_MODEL_ROUTER_HOME: join(home, ".auto-model-router"), HERMES_HOME: join(home, "no-hermes") };
+		return { home, agent, env };
+	}
+
+	test("into omp mcp.json and Claude Code ~/.claude.json, only for the harnesses it configured", () => {
+		const { home, agent, env } = fixture();
+		try {
+			// Pre-existing servers and unrelated settings survive.
+			writeFileSync(join(agent, "mcp.json"), JSON.stringify({ $schema: "s", mcpServers: { agentdox: { type: "http", url: "http://localhost:3003/mcp" } } }, null, 2));
+			writeFileSync(join(home, ".claude.json"), JSON.stringify({ claudeAiMcpEverConnected: true, mcpServers: {} }));
+			const r = connectRemote({ url: "https://team.example", key: "amrt_k", userId: "u", name: "Ada", profile: false, dryRun: false, only: ["omp", "claude"], env, home, packageDir: "/pkg", mcp: { url: "https://team.example/mcp" }, platform: "linux", pathHas: () => false });
+			expect(r.mcp?.length).toBe(2);
+			expect(r.configured.some((c) => c.startsWith(`MCP (${MCP_SERVER_NAME} → https://team.example/mcp`))).toBe(true);
+			const omp = read(join(agent, "mcp.json"));
+			expect(omp.$schema).toBe("s");
+			expect(servers(join(agent, "mcp.json"))).toEqual({
+				agentdox: { type: "http", url: "http://localhost:3003/mcp" },
+				[MCP_SERVER_NAME]: { type: "http", url: "https://team.example/mcp", headers: { Authorization: "Bearer amrt_k" } },
+			});
+			const claude = read(join(home, ".claude.json"));
+			expect(claude.claudeAiMcpEverConnected).toBe(true);
+			expect(servers(join(home, ".claude.json"))[MCP_SERVER_NAME]).toEqual({ type: "http", url: "https://team.example/mcp", headers: { Authorization: "Bearer amrt_k" } });
+
+			// A second connect with the same key changes nothing.
+			const r2 = connectRemote({ url: "https://team.example", key: "amrt_k", userId: "u", name: "Ada", profile: false, dryRun: false, only: ["omp", "claude"], env, home, packageDir: "/pkg", mcp: { url: "https://team.example/mcp" }, platform: "linux", pathHas: () => false });
+			expect(r2.mcp).toEqual([]);
+
+			// Only Claude Code asked for: the omp file is not touched even though it exists.
+			rmSync(join(agent, "mcp.json"));
+			const r3 = connectRemote({ url: "https://team.example", key: "amrt_k3", userId: "u", name: "Ada", profile: false, dryRun: false, only: ["claude"], env, home, packageDir: "/pkg", mcp: { url: "https://team.example/mcp" }, platform: "linux", pathHas: () => false });
+			expect(r3.mcp).toEqual([join(home, ".claude.json")]);
+			expect(existsSync(join(agent, "mcp.json"))).toBe(false);
+			expect(auth(join(home, ".claude.json"))).toBe("Bearer amrt_k3");
+
+			// A remote that stops serving MCP has the entry removed; the neighbours stay.
+			const r4 = connectRemote({ url: "https://team.example", key: "amrt_k3", userId: "u", name: "Ada", profile: false, dryRun: false, only: ["claude"], env, home, packageDir: "/pkg", mcp: { url: null }, platform: "linux", pathHas: () => false });
+			expect(r4.mcp).toEqual([join(home, ".claude.json")]);
+			expect(servers(join(home, ".claude.json"))).toEqual({});
+			expect(read(join(home, ".claude.json")).claudeAiMcpEverConnected).toBe(true);
+			expect(r4.configured.some((c) => c.startsWith("MCP ("))).toBe(false);
+		} finally {
+			rmSync(home, { recursive: true, force: true });
+		}
+	});
+
+	test("a dry run reports the files without writing them; no mcp option leaves them alone", () => {
+		const { home, agent, env } = fixture();
+		try {
+			const r = connectRemote({ url: "https://team.example", key: "amrt_k", userId: "u", name: "Ada", profile: false, dryRun: true, only: ["omp"], env, home, packageDir: "/pkg", mcp: { url: "https://team.example/mcp" }, platform: "linux", pathHas: () => false });
+			expect(r.mcp).toEqual([join(agent, "mcp.json")]);
+			expect(existsSync(join(agent, "mcp.json"))).toBe(false);
+			const r2 = connectRemote({ url: "https://team.example", key: "amrt_k", userId: "u", name: "Ada", profile: false, dryRun: false, only: ["omp"], env, home, packageDir: "/pkg", platform: "linux", pathHas: () => false });
+			expect(r2.mcp).toBeUndefined();
+			expect(existsSync(join(agent, "mcp.json"))).toBe(false);
+		} finally {
+			rmSync(home, { recursive: true, force: true });
+		}
+	});
+
+	test("refresh rewrites the entry with the new key, asking the remote whether it still serves MCP", async () => {
+		const { home, agent, env } = fixture();
+		const routerHome = env.AUTO_MODEL_ROUTER_HOME!;
+		try {
+			connectRemote({ url: "https://team.example", key: "amrt_old", userId: "u_ada", name: "Ada", refreshToken: "amrr_r1", keyExpiresAtMs: 1, refreshExpiresAtMs: 2, profile: false, dryRun: false, only: ["omp"], env, home, packageDir: process.cwd(), mcp: { url: "https://team.example/mcp" }, platform: "linux", pathHas: () => false });
+			expect(auth(join(agent, "mcp.json"))).toBe("Bearer amrt_old");
+			const seen: string[] = [];
+			const fetchImpl = (async (input: string | URL | Request) => {
+				const url = String(input);
+				seen.push(url);
+				if (url.endsWith("/setup/info")) return Response.json({ version: "0.18.0", mcp: true });
+				if (url.endsWith("/setup/skills")) return new Response("", { status: 404 });
+				return Response.json({ key: "amrt_new", keyExpiresAtMs: 50, refreshToken: "amrr_r2", refreshExpiresAtMs: 90 });
+			}) as unknown as typeof fetch;
+			const remote = parseRemoteRouter(readFileSync(join(routerHome, "remote.json"), "utf8"))!;
+			await refreshAndRewrite({ remote, fetchImpl, home, packageDir: process.cwd(), env, platform: "linux", pathHas: () => false, routerHome });
+			expect(seen.some((u) => u === "https://team.example/setup/info")).toBe(true);
+			expect(servers(join(agent, "mcp.json"))[MCP_SERVER_NAME]).toEqual({ type: "http", url: "https://team.example/mcp", headers: { Authorization: "Bearer amrt_new" } });
+			// The remote no longer serves MCP (a plain router answers 404): the entry goes.
+			const plain = (async (input: string | URL | Request) => {
+				const url = String(input);
+				if (url.endsWith("/setup/info") || url.endsWith("/setup/skills")) return new Response("", { status: 404 });
+				return Response.json({ key: "amrt_new2", keyExpiresAtMs: 60, refreshToken: "amrr_r3", refreshExpiresAtMs: 99 });
+			}) as unknown as typeof fetch;
+			const remote2 = parseRemoteRouter(readFileSync(join(routerHome, "remote.json"), "utf8"))!;
+			await refreshAndRewrite({ remote: remote2, fetchImpl: plain, home, packageDir: process.cwd(), env, platform: "linux", pathHas: () => false, routerHome });
+			expect(servers(join(agent, "mcp.json"))).toEqual({});
+		} finally {
+			rmSync(home, { recursive: true, force: true });
+		}
+	});
+});
+
+describe("fetchSetupInfo", () => {
+	test("reads mcp from a team, and answers false for a plain router, a bad body or a dead remote", async () => {
+		expect(await fetchSetupInfo("https://t", (async () => Response.json({ mcp: true })) as unknown as typeof fetch)).toEqual({ mcp: true });
+		expect(await fetchSetupInfo("https://t", (async () => Response.json({ mcp: "yes" })) as unknown as typeof fetch)).toEqual({ mcp: false });
+		expect(await fetchSetupInfo("https://t", (async () => new Response("", { status: 404 })) as unknown as typeof fetch)).toEqual({ mcp: false });
+		expect(await fetchSetupInfo("https://t", (async () => new Response("<html>", { status: 200 })) as unknown as typeof fetch)).toEqual({ mcp: false });
+		expect(
+			await fetchSetupInfo("https://t", (async () => {
+				throw new Error("down");
+			}) as unknown as typeof fetch),
+		).toEqual({ mcp: false });
+	});
+});

package/test/upstreams.test.ts

@@ -108,7 +108,7 @@ describe("static catalog", () => {
 		applyConfigPatch(cfg, { upstreams: [{ id: "vllm", kind: "openai", baseUrl: "http://vllm:8000/v1", models: [{ id: "llama", input: 0, output: 0 }] }] } as never);
 		const second = src.get(twins);
 		expect(second).not.toBe(first);
-		expect(second[0]!.isFree).toBe(true);
+		expect(second[0]!.isFree).toBe(false); // $0 self-hosted models must not fall under the free-tier exclusion
 	});
 });