auto-model-router 0.2.26 → 0.2.27

package/omp-extension/router-embed.ts

@@ -23,7 +23,7 @@ import { appendFileSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 
-import { ompModelsPath, syncModelsYml } from "../src/cli/config-cmd.ts";
+import { ompModelsPath } 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";
@@ -207,20 +207,39 @@ export default function (pi: ExtensionAPI): void {
 		// default — never take this path, so sessions stay independent.
 		if (requestedPort !== 0 && (await probeEmbed(requestedPort))) {
 			writeEmbedPort(portFile, requestedPort);
-			syncModelsYml(cfg, requestedPort);
 			registerRouterProvider(pi, requestedPort, cfg, sessionId);
 			pi.setLabel(`auto-model-router embed (shared :${requestedPort})`);
 			return;
 		}
 
-		// Bind. If a FIXED port was requested and something else holds it, fall
-		// back to an ephemeral one rather than leaving this session with no
-		// provider at all. An ephemeral request that fails is a real error.
+		// ADOPT THE ADVERTISED PORT. This is the fix for "provider error: Unable
+		// to connect" on every real turn while utility calls kept working.
+		//
+		// omp resolves `modelRoles.default` (auto-model-router/auto) from
+		// models.yml during STARTUP — before this extension loads, so before we
+		// can bind or register anything. That resolved handle is a SNAPSHOT: a
+		// later registerProvider replaces the registry entry but cannot rewrite
+		// a handle omp already built. models.yml names the port of the LAST
+		// session that wrote it, which after a normal restart is the session the
+		// user just closed — a dead socket. Utility calls (title generation,
+		// auto-thinking) resolve AFTER our registration and so hit the live port,
+		// which is exactly the asymmetry that made this look like a router fault.
+		// Measured in the field via embed.log:
+		//   embed ready pid=61872 port=54985 models.yml-advertised=50596
+		//
+		// So bind the port omp already resolved against, whenever nothing holds
+		// it. Each session still runs its OWN router — this only chooses which
+		// port that router listens on. A live peer holding it means the handle
+		// works anyway (that peer serves it), and we fall back to ephemeral.
+		const advertised = modelsYmlPort(readModelsYml());
+		if (requestedPort === 0 && advertised !== null) cfg.server.port = advertised;
+
+		// Fall back to an ephemeral port when the preferred one is taken, rather
+		// than leaving this session with no provider at all.
 		let started: StartedServer;
 		try {
 			started = startServer(cfg);
-		} catch (err) {
-			if (requestedPort === 0) throw err;
+		} catch {
 			cfg.server.port = 0;
 			started = startServer(cfg);
 		}
@@ -232,18 +251,23 @@ export default function (pi: ExtensionAPI): void {
 		// Publish the port; subagents and the toast read it from here.
 		writeEmbedPort(portFile, actualPort);
 
-		// 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 advertised = modelsYmlPort(readModelsYml());
-		const syncAction = syncModelsYml(cfg, actualPort);
+		// models.yml is deliberately NOT written. The port belongs to THIS
+		// process and changes every launch, so persisting it into a file omp
+		// reads at STARTUP — before this extension loads — makes a dead port
+		// authoritative for the next session's `modelRoles.default`, and that
+		// handle is a snapshot no later registration can repair. That is the
+		// regression this whole class of failure came from. The provider is
+		// registered dynamically below instead, which is what worked before the
+		// file was ever written.
+		//
+		// `auto-model-router config --write` still exists for anyone who wants a
+		// static block on purpose; the adoption above keeps such a block
+		// harmless by binding whatever port it names when that port is free.
 
 		// Register BEFORE any await: everything omp resolves after this point
 		// picks up the live URL, so the registration must not sit behind I/O.
 		registerRouterProvider(pi, actualPort, cfg, sessionId);
-		pi.setLabel(`auto-model-router embed :${actualPort}${syncAction === null ? "" : ` (models.yml ${syncAction})`}`);
+		pi.setLabel(`auto-model-router embed :${actualPort}`);
 
 		// NO `session_shutdown` teardown. That event is emitted from session
 		// DISPOSAL — including omp's provider-refresh / extension-reload path,
@@ -259,7 +283,7 @@ export default function (pi: ExtensionAPI): void {
 		writeEmbedLog(
 			`embed ready pid=${process.pid} port=${actualPort}` +
 				` models.yml-advertised=${advertised ?? "none"}` +
-				` sync=${syncAction ?? "current"}` +
+				` models.yml-untouched` +
 				` self-probe=${(await probeEmbed(actualPort)) ? "ok" : "FAILED"}` +
 				` session=${sessionId}`,
 		);

package/package.json

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

package/src/cli/config-cmd.ts

@@ -317,44 +317,6 @@ export function ompModelsPath(): string {
 	if (agentDir !== undefined && agentDir !== "") return join(agentDir, "models.yml");
 	return join(homedir(), ".omp", "agent", "models.yml");
 }
-/**
- * Keeps omp's models.yml carrying an up-to-date `auto-model-router` provider
- * block pointing at `port`, silently. The embedded extension calls this every
- * time the main session binds its router, so headless (`-p`) runs, subagent
- * processes, and any other consumer that builds a FRESH model registry (which
- * extension registration does NOT reach) still resolve
- * `auto-model-router/auto` — they read models.yml, not the live registry.
- *
- * Same splice + validation as `config --write`, minus the console output and
- * the backup: this runs on every session start, and a `.bak` per launch would
- * churn the directory. Failure to write is logged by the caller, never thrown —
- * a read-only models.yml must degrade to "registration only", which is the
- * pre-existing behavior.
- *
- * Returns the splice action, or null when nothing was written (already
- * current, or the write failed).
- */
-export function syncModelsYml(cfg: RouterConfig, port: number, target = ompModelsPath()): SpliceResult["action"] | null {
-	try {
-		const pointed: RouterConfig = { ...cfg, server: { ...cfg.server, port } };
-		const block = renderProviderBlock(pointed, null);
-		const existing = existsSync(target) ? readFileSync(target, "utf8") : "";
-		const result = spliceProviderBlock(existing, block);
-		if (result.action === "replaced") {
-			// The guards make "replaced" cheap to detect but the text may still be
-			// byte-identical (same port, same costs): skip the write so the file
-			// mtime stays stable for tools watching it.
-			if (result.text === existing) return null;
-		}
-		assertUsableModelsYaml(result.text);
-		mkdirSync(dirname(target), { recursive: true });
-		writeFileSync(target, result.text, "utf8");
-		return result.action;
-	} catch {
-		return null;
-	}
-}
-
 /** omp's models.yml location: `$PI_CODING_AGENT_DIR` relocates the whole agent dir. */
 
 export async function configCommand(args: CliArgs): Promise<void> {

package/test/embed-lifecycle.test.ts

@@ -1,28 +1,35 @@
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
-import { mkdtempSync, rmSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
 import type { ExtensionAPI, ExtensionContext, ProviderRegistration } from "@oh-my-pi/pi-coding-agent";
 
 /**
- * The embedded router's lifetime is the PROCESS, not a session.
+ * How the embedded router must behave, pinned against the two failures that
+ * produced "provider error: Unable to connect" on every real turn while utility
+ * calls kept working.
  *
- * omp emits `session_shutdown` from session DISPOSAL, and disposal includes its
- * provider-refresh / extension-reload path — which runs in a throwaway
- * extension host while the real session keeps going. This module is cached per
- * process, so tearing the router down in that handler stopped the LIVE router.
- * Every later turn then failed with Bun's "Unable to connect", while utility
- * calls resolved after a subsequent rebind still worked: exactly the asymmetry
- * seen in the field, where only `toolCount: 0` dispatches reached the ledger and
- * the port named in `embed.port` answered nothing.
+ * 1. THE PORT COMES FROM THIS PROCESS, NOT FROM A FILE. omp resolves
+ *    `modelRoles.default` from models.yml during STARTUP — before this extension
+ *    loads — and that handle is a snapshot no later registerProvider can
+ *    rewrite. So the extension must not persist its ephemeral port into
+ *    models.yml (a dead port then becomes authoritative for the NEXT session),
+ *    and when a block already exists it adopts the port that block names so the
+ *    handle omp built is valid. Measured in the field:
+ *      embed ready pid=61872 port=54985 models.yml-advertised=50596
  *
- * One boot shared by every test here, deliberately: the extension module is
- * cached per process in production too, so this is the real shape.
+ * 2. THE ROUTER'S LIFETIME IS THE PROCESS. omp emits `session_shutdown` from
+ *    session disposal, which includes its provider-refresh / extension-reload
+ *    path running in a throwaway host while the real session continues. This
+ *    module is cached per process, so a teardown there stopped the LIVE router.
+ *
+ * One boot shared by every test, deliberately: the module is cached per process
+ * in production too, so this is the real shape.
  */
 
-const handlers = new Map<string, ((event: unknown, ctx: ExtensionContext) => void | Promise<void>)[]>();
 const registrations: { id: string; baseUrl: string }[] = [];
+const handlers = new Map<string, ((event: unknown, ctx: ExtensionContext) => void | Promise<void>)[]>();
 
 const pi: ExtensionAPI = {
 	setLabel: () => {},
@@ -43,7 +50,7 @@ async function fire(event: string, sessionId: string): Promise<void> {
 	for (const handler of handlers.get(event) ?? []) await handler({ type: event }, ctx);
 }
 
-/** Health-probes the router; used to assert the socket's state, not to wait. */
+/** Health-probes the router: asserts the socket's state, never used as a wait. */
 async function alive(port: number): Promise<boolean> {
 	try {
 		const res = await fetch(`http://127.0.0.1:${port}/health`, { signal: AbortSignal.timeout(2_000) });
@@ -53,64 +60,108 @@ async function alive(port: number): Promise<boolean> {
 	}
 }
 
+const portOfLatestRegistration = (): number =>
+	Number.parseInt(/:(\d+)\//.exec(registrations.at(-1)?.baseUrl ?? "")?.[1] ?? "0", 10);
+
 let home = "";
-let port = 0;
+let modelsYmlPath = "";
+let advertised = 0;
+let modelsYmlBefore = "";
 
 beforeAll(async () => {
 	home = mkdtempSync(join(tmpdir(), "embed-life-"));
+	const agentDir = join(home, "agent");
+	mkdirSync(agentDir, { recursive: true });
+	modelsYmlPath = join(agentDir, "models.yml");
+
+	// A port nothing listens on — the shape a restart leaves behind, since
+	// models.yml names the session the user just closed.
+	const probe = Bun.serve({ port: 0, hostname: "127.0.0.1", fetch: () => new Response("x") });
+	advertised = probe.port as number;
+	probe.stop(true);
+
+	writeFileSync(
+		modelsYmlPath,
+		`providers:
+    # BEGIN auto-model-router
+    auto-model-router:
+      baseUrl: http://127.0.0.1:${advertised}/v1
+      api: openai-completions
+      auth: none
+      models:
+        - id: auto
+          name: Auto (auto-model-router)
+    # END auto-model-router
+`,
+		"utf8",
+	);
+	modelsYmlBefore = readFileSync(modelsYmlPath, "utf8");
+
 	process.env.AUTO_MODEL_ROUTER_HOME = home;
 	process.env.AUTO_MODEL_ROUTER_DB = join(home, "router.db");
+	process.env.PI_CODING_AGENT_DIR = agentDir;
+	delete process.env.AUTO_MODEL_ROUTER_PORT;
+
 	const mod = (await import("../omp-extension/router-embed.ts")) as { default: (api: ExtensionAPI) => void };
 	mod.default(pi);
 	await fire("session_start", "session-one");
-	port = Number.parseInt(/:(\d+)\//.exec(registrations.at(-1)?.baseUrl ?? "")?.[1] ?? "0", 10);
 });
 
 afterAll(async () => {
-	// Release the socket the way the extension intends: on process signals.
+	// Release the socket the way the extension intends: on a process signal.
 	process.emit("SIGTERM");
-	// Poll the real condition rather than guessing a duration; each fetch
-	// attempt yields, so this settles as soon as the socket is actually closed.
-	for (let i = 0; i < 50 && (await alive(port)); i++) {
-		/* keep probing until the port stops answering */
+	// Poll the real condition instead of guessing a duration; each probe yields.
+	for (let i = 0; i < 50 && (await alive(portOfLatestRegistration())); i++) {
+		/* keep probing until the socket stops answering */
 	}
-	// A still-open SQLite handle can hold the file on Windows; the temp dir is
-	// disposable either way.
+	delete process.env.PI_CODING_AGENT_DIR;
 	try {
 		rmSync(home, { recursive: true, force: true });
 	} catch {
-		/* leave it to the OS temp reaper */
+		/* SQLite may still hold the file on Windows; the temp dir is disposable */
 	}
 });
 
-describe("embedded router lifetime", () => {
-	test("binds a router and registers it for the session", () => {
-		expect(port).toBeGreaterThan(0);
-		expect(registrations.at(-1)?.id).toBe("auto-model-router");
+describe("embedded router: port selection", () => {
+	test("adopts the port models.yml advertises, so omp's pre-resolved handle is valid", () => {
+		expect(portOfLatestRegistration()).toBe(advertised);
+	});
+
+	test("the adopted port actually serves", async () => {
+		expect(await alive(advertised)).toBe(true);
 	});
 
-	test("the router answers on the port it registered", async () => {
-		expect(await alive(port)).toBe(true);
+	test("does NOT write its port into models.yml", () => {
+		// Persisting an ephemeral port makes it authoritative for the NEXT
+		// session's startup resolution, which is where the dead handle came from.
+		expect(readFileSync(modelsYmlPath, "utf8")).toBe(modelsYmlBefore);
 	});
 
+	test("publishes the port for subagents and the toast", () => {
+		const portFile = join(home, "embed.port");
+		expect(existsSync(portFile)).toBe(true);
+		expect(readFileSync(portFile, "utf8").trim()).toBe(String(advertised));
+	});
+});
+
+describe("embedded router: lifetime", () => {
 	test("registers NO session_shutdown teardown", () => {
-		// omp fires this from a throwaway host during provider refresh, so a
-		// teardown here kills a router the live session is still using.
+		// omp fires that from a throwaway host during provider refresh, so a
+		// teardown there kills a router the live session is still using.
 		expect(handlers.get("session_shutdown") ?? []).toHaveLength(0);
 	});
 
 	test("a session_shutdown leaves the router running", async () => {
 		await fire("session_shutdown", "session-one");
-		expect(await alive(port)).toBe(true);
+		expect(await alive(advertised)).toBe(true);
 	});
 
 	test("a second session reuses the same port instead of rebinding", async () => {
-		// Rebinding would take a different port and orphan every model handle omp
-		// had already resolved against the first one.
+		// Rebinding would take a different port and orphan every handle omp had
+		// already resolved against the first one.
 		await fire("session_start", "session-two");
-		const latest = Number.parseInt(/:(\d+)\//.exec(registrations.at(-1)?.baseUrl ?? "")?.[1] ?? "0", 10);
-		expect(latest).toBe(port);
-		expect(await alive(port)).toBe(true);
+		expect(portOfLatestRegistration()).toBe(advertised);
+		expect(await alive(advertised)).toBe(true);
 	});
 
 	test("each session still gets its own registration, so per-session tagging survives reuse", () => {