auto-model-router 0.2.23 → 0.2.24

package/omp-extension/embed-logic.ts

@@ -106,6 +106,27 @@ export function resolveEmbedPort(envPort: string | undefined, configuredPort = 0
 	return 0;
 }
 
+/**
+ * The port omp's `models.yml` currently advertises for our provider, or null
+ * when the block is absent or unparseable.
+ *
+ * This is the port omp resolves `modelRoles.default` against DURING STARTUP,
+ * before this extension loads. If it disagrees with the port we end up serving,
+ * this session's main-model handle points somewhere we are not listening, and
+ * only a restart can rebuild it — there is no API to re-resolve an already
+ * built handle. Detecting the mismatch is what turns a baffling
+ * "Unable to connect" on every real turn into a message that names the cause.
+ */
+export function modelsYmlPort(text: string): number | null {
+	const block = /^\s*auto-model-router:\s*$/m.exec(text);
+	if (block === null) return null;
+	const rest = text.slice(block.index);
+	const url = /baseUrl:\s*http:\/\/[^\s:]+:(\d+)/.exec(rest);
+	if (url === null) return null;
+	const port = Number.parseInt(url[1] ?? "", 10);
+	return Number.isInteger(port) ? port : null;
+}
+
 /**
  * Absolute path of the shared embed port file under a router home directory.
  */

package/omp-extension/router-embed.ts

@@ -19,10 +19,11 @@
  *     - /path/to/auto-model-router/omp-extension/router-toast.ts
  */
 
+import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 
-import { syncModelsYml } from "../src/cli/config-cmd.ts";
+import { ompModelsPath, syncModelsYml } from "../src/cli/config-cmd.ts";
 import { loadConfig } from "../src/config/load.ts";
 import { startServer } from "../src/server/http.ts";
 import type { StartedServer } from "../src/server/http.ts";
@@ -36,11 +37,21 @@ import {
 	EMBED_PROVIDER_ID,
 	embedPortPath,
 	readEmbedPort,
+	modelsYmlPort,
 	probeEmbed,
 	resolveEmbedPort,
 	writeEmbedPort,
 } from "./embed-logic.ts";
 
+/** omp's models.yml as text, or "" when it does not exist / cannot be read. */
+function readModelsYml(): string {
+	try {
+		return readFileSync(ompModelsPath(), "utf8");
+	} catch {
+		return "";
+	}
+}
+
 /**
  * Registers the auto-model-router provider (and its virtual models) into omp's model
  * registry at a specific bound port.
@@ -166,13 +177,30 @@ export default function (pi: ExtensionAPI): void {
 		// Publish the shared port; subagents and the toast read it from here.
 		writeEmbedPort(portFile, actualPort);
 
+		// What omp resolved `modelRoles.default` against at STARTUP, before this
+		// extension loaded. If it names a different port than we serve, this
+		// session's main-model handle points at a socket we are not listening on
+		// and every real turn fails with "Unable to connect" while utility calls
+		// (resolved later, from the registration below) still work. Nothing here
+		// can rebuild that handle, so say so plainly instead of leaving the user
+		// to diagnose it.
+		const advertised = modelsYmlPort(readModelsYml());
+		if (advertised !== null && advertised !== actualPort) {
+			pi.setLabel(`auto-model-router: RESTART NEEDED — omp resolved :${advertised}, router serves :${actualPort}`);
+			console.warn(
+				`[auto-model-router] models.yml advertised port ${advertised} at startup but this router serves ${actualPort}. ` +
+					`omp resolves the default model before extensions load, so this session's main model still points at ${advertised}. ` +
+					`models.yml has been corrected — restart omp once and it will be right.`,
+			);
+		}
+
 		// Keep models.yml pointing at this port. Headless runs (`-p`) and
 		// subagent processes resolve models from models.yml in a FRESH registry
 		// — extension registration does not reach them — so without this they
 		// fail with "Model not found" when no interactive session is live
 		// (the print-mode gap the external benchmark hit).
 		const syncAction = syncModelsYml(cfg, actualPort);
-		if (syncAction !== null) pi.setLabel(`auto-model-router embed (models.yml ${syncAction})`);
+		if (syncAction !== null && advertised === actualPort) pi.setLabel(`auto-model-router embed (models.yml ${syncAction})`);
 		registerRouterProvider(pi, actualPort, cfg, sessionId);
 
 		pi.on("session_shutdown", () => {

package/package.json

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

package/test/embed-logic.test.ts

@@ -9,6 +9,7 @@ import {
 	EMBED_PORT_FILE,
 	EMBED_PROVIDER_ID,
 	embedPortPath,
+	modelsYmlPort,
 	readEmbedPort,
 	resolveEmbedPort,
 	writeEmbedPort,
@@ -55,6 +56,46 @@ describe("resolveEmbedPort", () => {
 	});
 });
 
+describe("modelsYmlPort", () => {
+	// This is the port omp resolves modelRoles.default against at STARTUP,
+	// before the extension loads. A disagreement with the served port means
+	// every main-agent turn in that session fails with "Unable to connect"
+	// while utility calls still work, so the extension has to detect it.
+	const REAL = `providers:
+    # BEGIN auto-model-router
+    auto-model-router:
+      baseUrl: http://127.0.0.1:58724/v1
+      api: openai-completions
+      auth: none
+      models:
+        - id: auto
+          name: Auto (auto-model-router)
+`;
+
+	test("reads the advertised port out of a real block", () => {
+		expect(modelsYmlPort(REAL)).toBe(58724);
+	});
+
+	test("returns null when our provider block is absent", () => {
+		expect(modelsYmlPort("providers:\n    openrouter:\n      baseUrl: https://openrouter.ai/api/v1\n")).toBeNull();
+		expect(modelsYmlPort("")).toBeNull();
+	});
+
+	test("is not fooled by another provider's baseUrl appearing first", () => {
+		const mixed = `providers:
+    llama.cpp:
+      baseUrl: http://127.0.0.1:8080/v1
+    auto-model-router:
+      baseUrl: http://127.0.0.1:8788/v1
+`;
+		expect(modelsYmlPort(mixed)).toBe(8788);
+	});
+
+	test("returns null when the block carries no parseable url", () => {
+		expect(modelsYmlPort("providers:\n    auto-model-router:\n      api: openai-completions\n")).toBeNull();
+	});
+});
+
 describe("embed port file", () => {
 	let dir: string;
 

package/tools/verify-embed-port.ts

@@ -51,17 +51,23 @@ check("an explicit env port still wins", resolveEmbedPort("8812", configured) ==
 check("an explicit env 0 still requests an ephemeral port", resolveEmbedPort("0", configured) === 0);
 
 // 2. First session binds it; a second must see it healthy (=> reuse, no bind war).
-cfg1.server.port = portA;
+//    Uses a DISCOVERED free port, not the machine's configured one: a real
+//    router may already be serving 8788 here, and this check must be hermetic.
+const scout = Bun.serve({ port: 0, hostname: "127.0.0.1", fetch: () => new Response("scout") });
+const freePort = scout.port as number;
+scout.stop(true);
+cfg1.server.port = freePort;
+
 let first: StartedServer | null = null;
 try {
 	first = startServer(cfg1);
 } catch (err) {
-	check("first session can bind the deterministic port", false, String(err));
+	check("first session can bind its chosen port", false, String(err));
 }
 
 if (first !== null) {
-	check("first session bound the deterministic port", first.server.port === portA, { bound: first.server.port, wanted: portA });
-	check("router answers /health there (so a peer session reuses it)", await probeEmbed(portA), { port: portA });
+	check("first session bound the port it asked for", first.server.port === freePort, { bound: first.server.port, wanted: freePort });
+	check("router answers /health there (so a peer session reuses it)", await probeEmbed(freePort), { port: freePort });
 
 	// 3. A non-router occupant must not be mistaken for our router.
 	const squatter = Bun.serve({ port: 0, hostname: "127.0.0.1", fetch: () => new Response("not a router", { status: 404 }) });