auto-model-router 0.7.0 → 0.7.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.7.0",
+    "version": "0.7.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.7.0",
+      "version": "0.7.1",
       "author": {
         "name": "drewappling",
         "email": "drewappling@gmail.com"

package/README.md

@@ -1296,10 +1296,21 @@ adds the Codex provider and the Aider settings, and prints (or with `--profile`
 the environment lines for Claude Code. `--harness omp,hermes` restricts it; `--dry-run`
 shows the changes. Delete `remote.json` to go back to a local router. (`join` is an alias.)
 
+`connect` also writes omp's `models.yml` (a managed block, other providers untouched, the
+previous file backed up). That entry is what makes `auto-model-router/auto` resolvable at
+**startup**: omp builds the main model's handle before extensions load, so without it only
+the late-resolved roles (`smol`, `tiny`) reach the router and the main turns fall back to
+whatever else is authenticated. A local router deliberately gets no such entry — its port
+is ephemeral, so a persisted one names a dead socket next launch — but a remote's URL and
+key are stable. **The file then holds the member key: treat it as a secret.**
+
 In remote mode omp sends `X-Agentdox-Scope` derived from the workspace folder, so one
 remote router serves every repo on the machine with that repo's shared context. The remote
 decides what to do with it: a team edition that pins a scope on the member's group
-overrides it, and one that pins none follows the workspace.
+overrides it, and one that pins none follows the workspace. That header rides on the roles
+the extensions register; the **main** model's handle comes from `models.yml`, which is
+machine-wide, so it carries a scope only if you pass `--scope <slug>` to `connect` — right
+for a single-project machine, wrong for one with several repos.
 
 ## Multiple coding harnesses, one router
 

package/package.json

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

package/src/cli/connect.ts

@@ -4,7 +4,12 @@
  * `<router home>/remote.json` (the omp extensions then run in remote mode and
  * never bind a local router), and configures every harness it finds:
  *
- *   omp         the four extensions are added to ~/.omp/agent/config.yml
+ *   omp         the four extensions are added to ~/.omp/agent/config.yml, and
+ *               the remote is written into ~/.omp/agent/models.yml so
+ *               `auto-model-router/auto` resolves at STARTUP — omp builds the
+ *               main model's handle before extensions load, so without that
+ *               entry only the late-resolved roles (smol, tiny) reach the
+ *               router and the main turns fall back to another provider
  *   Hermes      the provider plugin and the native plugin are copied into
  *               $HERMES_HOME/plugins and .env points them at the remote
  *   Codex       ~/.codex/config.toml gains the auto-model-router provider
@@ -37,6 +42,10 @@ export interface ConnectOptions {
 	home: string;
 	/** Where this package lives (the extensions are referenced from here). */
 	packageDir: string;
+	/** Cost figures omp shows for the remote's virtual models, USD per million tokens. */
+	blend?: { inputPerMtok: number; outputPerMtok: number };
+	/** Adds `X-Agentdox-Scope` to omp's models.yml entry. Machine-wide: only for a single-project machine. */
+	agentdoxScope?: string;
 	platform: string;
 	pathHas: (bin: string) => boolean;
 }
@@ -103,6 +112,90 @@ http_headers = { "X-Omp-Harness" = "codex" }
 `;
 }
 
+/** The models a remote router advertises, and what omp should believe they cost. */
+const REMOTE_MODEL_ROWS: readonly { id: string; name: string }[] = [
+	{ id: "auto", name: "Auto (auto-model-router)" },
+	{ id: "auto-cheap", name: "Auto Cheap (auto-model-router)" },
+	{ id: "auto-max", name: "Auto Max (auto-model-router)" },
+];
+
+const MODELS_YML_BEGIN = "  # BEGIN auto-model-router (remote)";
+const MODELS_YML_END = "  # END auto-model-router (remote)";
+
+/**
+ * omp's `models.yml` entry for a remote router.
+ *
+ * A LOCAL router deliberately never writes this file: its port is ephemeral, so
+ * a persisted entry names a dead socket on the next launch. A remote router has
+ * neither problem — the URL and the key are stable — and the entry is what makes
+ * omp's main model resolvable at startup, before extensions load.
+ *
+ * `scope` adds `X-Agentdox-Scope` to every request through this provider. It is
+ * off by default on purpose: the file is machine-wide, so a scope here would
+ * label turns from every workspace with one project. The extensions still send
+ * the workspace's own scope on the roles that resolve after they load.
+ */
+export function renderRemoteModelsYml(url: string, key: string, blend: { inputPerMtok: number; outputPerMtok: number }, scope = ""): string {
+	const round = (v: number): number => Math.round(v * 1e4) / 1e4;
+	const cost = {
+		input: round(blend.inputPerMtok),
+		output: round(blend.outputPerMtok),
+		cacheRead: round(blend.inputPerMtok * 0.1),
+		cacheWrite: round(blend.inputPerMtok * 1.25),
+	};
+	const lines = [
+		MODELS_YML_BEGIN,
+		"  # Managed by `auto-model-router connect`. Remove this block to stop routing omp through the remote.",
+		"  auto-model-router:",
+		`    baseUrl: ${url.replace(/\/+$/, "")}/v1`,
+		"    api: openai-completions",
+		`    apiKey: ${key}`,
+	];
+	if (scope !== "") lines.push("    headers:", `      X-Agentdox-Scope: ${scope}`);
+	lines.push("    models:");
+	for (const m of REMOTE_MODEL_ROWS) {
+		lines.push(
+			`      - id: ${m.id}`,
+			`        name: ${m.name}`,
+			"        contextWindow: 200000",
+			"        maxTokens: 32000",
+			"        input: [text, image]",
+			`        cost: { input: ${cost.input}, output: ${cost.output}, cacheRead: ${cost.cacheRead}, cacheWrite: ${cost.cacheWrite} }`,
+		);
+	}
+	lines.push(MODELS_YML_END);
+	return lines.join("\n");
+}
+
+/**
+ * Merges the remote block into an existing `models.yml`, replacing a previous
+ * one and leaving every other provider alone. Returns the new file text.
+ */
+export function mergeModelsYml(before: string, blockText: string): string {
+	const eol = before.includes("\r\n") ? "\r\n" : "\n";
+	const body = before.replace(/^\uFEFF/, "");
+	const block = blockText.split("\n").join(eol);
+	const begin = body.indexOf(MODELS_YML_BEGIN);
+	if (begin >= 0) {
+		const endIdx = body.indexOf(MODELS_YML_END, begin);
+		const end = endIdx < 0 ? body.length : endIdx + MODELS_YML_END.length;
+		return `${body.slice(0, begin)}${block}${body.slice(end)}`;
+	}
+	// A provider entry for the same id from an earlier local install would shadow
+	// ours; the caller reports it rather than editing a block it does not own.
+	if (body.trim() === "") return `providers:${eol}${block}${eol}`;
+	if (/^providers:\s*$/m.test(body)) {
+		return body.replace(/^providers:\s*$/m, (m) => `${m}${eol}${block}`);
+	}
+	return `${body.replace(/\s*$/, "")}${eol}providers:${eol}${block}${eol}`;
+}
+
+/** True when the file already defines our provider outside a block we manage. */
+export function hasForeignRouterProvider(text: string): boolean {
+	if (text.includes(MODELS_YML_BEGIN)) return false;
+	return /^\s{2,}auto-model-router:\s*$/m.test(text);
+}
+
 export function connectRemote(o: ConnectOptions): ConnectReport {
 	const report: ConnectReport = { remoteFile: "", configured: [], skipped: [], envLines: [], notes: [] };
 	const write = (path: string, content: string): void => {
@@ -124,7 +217,22 @@ export function connectRemote(o: ConnectOptions): ConnectReport {
 		const before = existsSync(cfgPath) ? readFileSync(cfgPath, "utf8") : "";
 		const after = addExtensions(before, ext);
 		if (after !== before) write(cfgPath, after);
-		report.configured.push(`omp (${cfgPath}; pick auto-model-router/auto as the model)`);
+		// models.yml: what makes the MAIN model resolvable, since omp builds that
+		// handle at startup, before the extensions register anything.
+		const modelsPath = join(agentDir, "models.yml");
+		const modelsBefore = existsSync(modelsPath) ? readFileSync(modelsPath, "utf8") : "";
+		if (hasForeignRouterProvider(modelsBefore)) {
+			report.notes.push(`${modelsPath} already defines an auto-model-router provider by hand; left alone — remove it to let connect manage the remote entry`);
+			report.configured.push(`omp (${cfgPath}; extensions only)`);
+		} else {
+			const modelsAfter = mergeModelsYml(modelsBefore, renderRemoteModelsYml(o.url, o.key, o.blend ?? { inputPerMtok: 1.1, outputPerMtok: 4.4 }, o.agentdoxScope ?? ""));
+			if (modelsAfter !== modelsBefore) {
+				// Never overwrite another provider's work without a way back.
+				if (modelsBefore !== "" && !o.dryRun) writeFileSync(`${modelsPath}.${new Date().toISOString().replaceAll(":", "-")}.bak`, modelsBefore, "utf8");
+				write(modelsPath, modelsAfter);
+			}
+			report.configured.push(`omp (${cfgPath} + ${modelsPath}; auto-model-router/auto is ready to pick)`);
+		}
 	} else report.skipped.push("omp (no ~/.omp/agent)");
 
 	// 3. Hermes
@@ -183,6 +291,7 @@ export function connectRemote(o: ConnectOptions): ConnectReport {
 			report.notes.push(`environment appended to ${rc}; open a new shell or source it`);
 		}
 	} else report.notes.push("add the environment lines to your shell profile, or re-run with --profile");
+	report.notes.push("omp's models.yml now carries the member key; treat that file as a secret");
 	return report;
 }
 
@@ -205,7 +314,10 @@ export async function connectCommand(args: CliArgs): Promise<void> {
 	}
 	// HOME wins when set (Git Bash, WSL, CI) so a caller can redirect every write; the OS profile otherwise.
 	const home = process.env.HOME !== undefined && process.env.HOME !== "" ? process.env.HOME : homedir();
-	const report = connectRemote({ url, key, userId, name, profile: args.flags.has("profile"), dryRun: args.flags.has("dry-run"), only, env: process.env, home, packageDir, platform: process.platform, pathHas });
+	// 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 agentdoxScope = flagString(args, "scope") ?? "";
+	const report = connectRemote({ url, key, userId, name, profile: args.flags.has("profile"), dryRun: args.flags.has("dry-run"), only, env: process.env, home, packageDir, platform: process.platform, pathHas, agentdoxScope });
 	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}`);
 	for (const s of report.skipped) console.log(`  skipped    ${s}`);

package/src/index.ts

@@ -26,7 +26,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, --key; --profile persists the environment)
+  connect    Point this machine at a remote router (--url, --key; --scope labels a single-project machine; --profile persists the environment)
   models     Show what each complexity tier would consider, and why
   explain    Route a saved request without dispatching it, and explain the decision
   config     Interactive wizard over the router's own config.yml

package/src/server/turn.ts

@@ -93,13 +93,21 @@ function lastUserText(req: NormRequest): string {
 	return "";
 }
 
-/** Session title: the conversation's opening ask, truncated. */
+/**
+ * Session title: the conversation's opening ask, truncated.
+ *
+ * Read through `userContent`, the same filter the recorded user message uses:
+ * a harness wraps the first message in reminders (omp opens with a
+ * `<system-reminder>` naming the date and cwd), and titling a session with that
+ * wrapper both reads as noise in agentdox and is re-injected into later context
+ * assembly, which lists session titles.
+ */
 function sessionTitle(req: NormRequest): string {
 	for (const m of req.messages) {
-		if (m.role === "user" && m.text.trim() !== "") {
-			const t = m.text.trim().replace(/\s+/g, " ");
-			return t.length > 80 ? `${t.slice(0, 79)}…` : t;
-		}
+		if (m.role !== "user") continue;
+		const t = userContent(m.text);
+		if (t === "") continue;
+		return t.length > 80 ? `${t.slice(0, 79)}…` : t;
 	}
 	return `omp ${req.conversationKey.slice(0, 8)}`;
 }

package/test/remote.test.ts

@@ -5,6 +5,7 @@ import { join } from "node:path";
 
 import { addExtensions, codexBlock, connectRemote, setDotenv, type ConnectOptions } from "../src/cli/connect.ts";
 import { parseRemoteRouter, readRemoteRouter, remoteProviderRegistration } from "../omp-extension/remote-logic.ts";
+import { hasForeignRouterProvider, mergeModelsYml, renderRemoteModelsYml } from "../src/cli/connect.ts";
 
 /**
  * Remote mode: remote.json puts the omp extensions on a router elsewhere,
@@ -102,3 +103,47 @@ describe("connect", () => {
 		rmSync(h2, { recursive: true, force: true });
 	});
 });
+
+describe("omp models.yml for a remote router", () => {
+	const BLEND = { inputPerMtok: 1.1, outputPerMtok: 4.4 };
+	const NL = String.fromCharCode(10);
+	const yaml = (...lines: string[]): string => lines.join(NL) + NL;
+
+	test("the block names the remote, the key and the three virtual models; a scope is opt-in", () => {
+		const block = renderRemoteModelsYml("https://team.example/", "amrt_k", BLEND);
+		expect(block).toContain("baseUrl: https://team.example/v1");
+		expect(block).toContain("apiKey: amrt_k");
+		expect(block).toContain("- id: auto");
+		expect(block).toContain("- id: auto-cheap");
+		expect(block).toContain("- id: auto-max");
+		expect(block).toContain("cost: { input: 1.1, output: 4.4, cacheRead: 0.11, cacheWrite: 1.375 }");
+		// Machine-wide file: no scope unless the caller asks for one.
+		expect(block).not.toContain("X-Agentdox-Scope");
+		expect(renderRemoteModelsYml("https://team.example", "k", BLEND, "omp-router")).toContain("X-Agentdox-Scope: omp-router");
+	});
+
+	test("merging keeps other providers, replaces our own block, and is idempotent", () => {
+		const block = renderRemoteModelsYml("https://team.example", "k1", BLEND);
+		const empty = mergeModelsYml("", block);
+		expect(empty.startsWith("providers:")).toBe(true);
+		expect(mergeModelsYml(empty, block)).toBe(empty);
+
+		const existing = yaml("providers:", "  openai:", "    apiKey: sk-x");
+		const merged = mergeModelsYml(existing, block);
+		expect(merged).toContain("openai:");
+		expect(merged).toContain("baseUrl: https://team.example/v1");
+
+		// A later connect with a new key replaces the block in place, not a second copy.
+		const rekeyed = mergeModelsYml(merged, renderRemoteModelsYml("https://team.example", "k2", BLEND));
+		expect(rekeyed).toContain("apiKey: k2");
+		expect(rekeyed).not.toContain("apiKey: k1");
+		expect(rekeyed.match(/auto-model-router:/g)).toHaveLength(1);
+		expect(rekeyed).toContain("openai:");
+	});
+
+	test("a hand-written provider of the same name is left alone", () => {
+		expect(hasForeignRouterProvider(yaml("providers:", "  auto-model-router:", "    baseUrl: http://127.0.0.1:1/v1"))).toBe(true);
+		expect(hasForeignRouterProvider(mergeModelsYml("", renderRemoteModelsYml("https://t", "k", BLEND)))).toBe(false);
+		expect(hasForeignRouterProvider(yaml("providers:", "  openai: {}"))).toBe(false);
+	});
+});