auto-model-router 0.2.20 → 0.2.21

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.2.20",
+    "version": "0.2.21",
     "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.2.20",
+      "version": "0.2.21",
       "author": {
         "name": "drewappling",
         "email": "drewappling@gmail.com"

package/package.json

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

package/src/config/hot-reload.ts

@@ -0,0 +1,163 @@
+/**
+ * Hot reload for `config.yml`.
+ *
+ * The router is long-lived (an omp session embeds it), and the ranking knobs —
+ * tiers, filters, escalation, budgets, hysteresis — are exactly what a tuning
+ * session wants to change without restarting the harness. This module watches
+ * the config file, re-validates it through the same schema `loadConfig` uses,
+ * and mutates the SHARED config object in place.
+ *
+ * In-place mutation is the design: every consumer reads `cfg.tiers`,
+ * `cfg.filters`, `cfg.escalation` … at call time through the same object
+ * reference, so field assignment makes every per-turn read live with zero
+ * call-site changes. What is deliberately NOT reloaded is anything captured at
+ * construction — the listening socket (server.*), the OpenRouter client
+ * (openrouter.*), and the agentdox bridge (context.*). Those still require a
+ * restart; the watcher re-pinns them from the live object and reports skips.
+ *
+ * Safety properties:
+ *  - Schema validation BEFORE any mutation; an invalid file leaves the running
+ *    config untouched and logs the zod issues, exactly like loadConfig.
+ *  - fs.watch fires several times per save; a trailing debounce collapses them.
+ *  - A half-written or invalid file never throws into the watcher: the reload
+ *    is skipped and the previous config keeps serving.
+ *  - A deleted or emptied knob reverts to its DEFAULT, mirroring loadConfig's
+ *    merge order (defaults <- file): the file is the source of truth, so
+ *    disabling a feature by deleting its key works.
+ */
+
+import { existsSync, readFileSync, watch, type FSWatcher } from "node:fs";
+import { parse as parseYaml } from "yaml";
+import { configInputSchema } from "./schema.ts";
+import { DEFAULT_CONFIG } from "./defaults.ts";
+import { deepMerge, resolveTilde } from "./load.ts";
+import type { RouterConfig } from "./types.ts";
+
+/** Milliseconds of quiet after the last fs event before a reload actually runs. */
+const DEBOUNCE_MS = 250;
+
+/** The validated file input, or why it could not be used. */
+export type ConfigRead =
+	| { ok: true; cfg: RouterConfig }
+	| { ok: false; error: string };
+
+/**
+ * Re-reads and schema-validates the config file. Exported for tests: this is
+ * the exact gate a file must pass before it may touch the running config.
+ *
+ * The result is merged over DEFAULT_CONFIG — the file is the full source of
+ * truth, so a knob REMOVED from the file reverts to its default, matching what
+ * a restart would do. `server`/`openrouter`/`context` come back too, but the
+ * applier re-pinns those blocks from the live object, since they were captured
+ * by construction.
+ */
+export function readValidatedConfig(path: string): ConfigRead {
+	try {
+		if (!existsSync(path)) return { ok: false, error: "file missing" };
+		const raw: unknown = parseYaml(readFileSync(path, "utf8"));
+		if (raw === null || raw === undefined) return { ok: false, error: "file empty" };
+		const parsed = configInputSchema.safeParse(raw);
+		if (!parsed.success) {
+			const lines = parsed.error.issues
+				.slice(0, 5)
+				.map((issue) => `  - ${issue.path.join(".")}: ${issue.message}`)
+				.join("\n");
+			return { ok: false, error: `schema validation failed:\n${lines}` };
+		}
+		return { ok: true, cfg: deepMerge(DEFAULT_CONFIG, parsed.data) };
+	} catch (err) {
+		return { ok: false, error: err instanceof Error ? err.message : String(err) };
+	}
+}
+
+/** What changed in a reload, for logging. */
+export interface ReloadSummary {
+	changed: string[];
+}
+
+/** A live config file watcher. */
+export interface ConfigWatcher {
+	/** Stops watching. Idempotent. */
+	close(): void;
+}
+
+/** Options for watchConfig. */
+export interface WatchConfigOptions {
+	/** Called after a successful in-place reload that changed something. */
+	onReload?: (summary: ReloadSummary) => void;
+	/** Called when a file could not be applied (invalid, unreadable). */
+	onError?: (message: string) => void;
+}
+
+/**
+ * Watches `path` and applies valid changes to `live` in place. `frozen` blocks
+ * (top-level names) are re-copied from `pinned` after every reload so file
+ * edits to construction-captured blocks cannot silently diverge.
+ */
+export function watchConfig(
+	path: string,
+	live: RouterConfig,
+	pinned: RouterConfig,
+	frozen: readonly (keyof RouterConfig)[],
+	opts: WatchConfigOptions = {},
+): ConfigWatcher {
+	let closed = false;
+	let timer: ReturnType<typeof setTimeout> | undefined;
+	let lastError = "";
+
+	const apply = (): void => {
+		if (closed) return;
+		const result = readValidatedConfig(path);
+		if (!result.ok) {
+			// A half-written file is normal (editors truncate-then-write): stay on
+			// the current config. Report each distinct error once.
+			if (result.error !== lastError) {
+				lastError = result.error;
+				opts.onError?.(result.error);
+			}
+			return;
+		}
+		lastError = "";
+
+		const frozenSet = new Set(frozen);
+		const changed: string[] = [];
+		const next = result.cfg as unknown as Record<string, unknown>;
+		for (const key of Object.keys(next)) {
+			// Frozen blocks belong to construction: keep the pinned values.
+			const value = frozenSet.has(key as keyof RouterConfig)
+				? (pinned as unknown as Record<string, unknown>)[key]
+				: next[key];
+			const before = JSON.stringify((live as unknown as Record<string, unknown>)[key]);
+			const after = JSON.stringify(value);
+			if (before !== after) changed.push(key);
+			(live as unknown as Record<string, unknown>)[key] = value;
+		}
+		if (changed.length > 0) opts.onReload?.({ changed });
+	};
+
+	const schedule = (): void => {
+		clearTimeout(timer);
+		timer = setTimeout(() => {
+			timer = undefined;
+			apply();
+		}, DEBOUNCE_MS);
+	};
+
+	let watcher: FSWatcher | null = null;
+	try {
+		watcher = watch(resolveTilde(path), { persistent: false }, schedule);
+	} catch {
+		// Unwatchable file is not fatal: the router keeps its boot config.
+	}
+
+	return {
+		close() {
+			closed = true;
+			clearTimeout(timer);
+			timer = undefined;
+			watcher?.close();
+			watcher = null;
+		},
+	};
+}
+

package/src/config/load.ts

@@ -36,7 +36,7 @@ function mergeValue(base: unknown, override: unknown): unknown {
 	return override;
 }
 
-function deepMerge(base: RouterConfig, override: unknown): RouterConfig {
+export function deepMerge(base: RouterConfig, override: unknown): RouterConfig {
 	return mergeValue(base, override) as RouterConfig;
 }
 

package/src/server/http.ts

@@ -10,6 +10,8 @@ import { createConversationStore } from "../router/state.ts";
 import { createOpenRouterClient } from "../upstream/openrouter.ts";
 import { UpstreamError } from "../upstream/types.ts";
 import { apiKeySource } from "../config/load.ts";
+import { routerConfigPath } from "../cli/config-cmd.ts";
+import { watchConfig } from "../config/hot-reload.ts";
 import type { RouterConfig } from "../config/types.ts";
 import { createLogger } from "../util/log.ts";
 import { openDb } from "../util/sqlite.ts";
@@ -177,6 +179,27 @@ export function startServer(cfg: RouterConfig): StartedServer {
 	const context = createBridgeFromConfig(cfg, db);
 	const turnDeps = { config: cfg, router, upstream, ledger, conversations, catalog, context };
 
+	// Hot reload: ranking knobs (tiers, filters, escalation, budgets, …) take
+	// effect on the next turn without a restart, because every consumer reads
+	// the shared config object at call time. Construction-captured blocks
+	// (server socket, OpenRouter client, agentdox bridge) are pinned — editing
+	// those still requires a restart, and the watcher says so explicitly.
+	const pinned = { ...cfg };
+	const configWatcher = watchConfig(
+		routerConfigPath(),
+		cfg,
+		pinned,
+		["server", "openrouter", "context", "ledger"],
+		{
+			onReload: ({ changed }) => {
+				log.info("config reloaded", { changed: changed.join(", ") });
+			},
+			onError: (message) => {
+				log.warn("config reload rejected; keeping the running config", { error: message });
+			},
+		},
+	);
+
 	if (context.enabled) {
 		log.info("agentdox context bridge enabled", {
 			url: cfg.context.baseUrl,
@@ -355,8 +378,8 @@ export function startServer(cfg: RouterConfig): StartedServer {
 	return {
 		server,
 		stop: async () => {
+			configWatcher.close();
 			clearInterval(pruneTimer);
-			clearInterval(catalogRefreshTimer);
 			await server.stop(true);
 			// Drain queued agentdox write-backs before the DB closes under them.
 			context.close();

package/test/hot-reload.test.ts

@@ -0,0 +1,131 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { DEFAULT_CONFIG } from "../src/config/defaults.ts";
+import type { RouterConfig } from "../src/config/types.ts";
+import { readValidatedConfig, watchConfig, type ConfigWatcher } from "../src/config/hot-reload.ts";
+
+const DIR = join(import.meta.dir, ".tmp-hot-reload");
+const CFG = join(DIR, "config.yml");
+
+beforeAll(() => {
+	rmSync(DIR, { recursive: true, force: true });
+	mkdirSync(DIR, { recursive: true });
+});
+afterAll(() => {
+	rmSync(DIR, { recursive: true, force: true });
+});
+
+/** A clone of the shipped defaults serialized as YAML via JSON (the schema accepts JSON). */
+function yamlOf(partial: Record<string, unknown>): string {
+	const lines: string[] = [];
+	for (const [k, v] of Object.entries(partial)) {
+		if (typeof v === "object" && v !== null) {
+			lines.push(`${k}:`);
+			for (const [k2, v2] of Object.entries(v)) {
+				lines.push(`  ${k2}: ${JSON.stringify(v2).replaceAll('"', v2 === true || v2 === false || typeof v2 === "number" ? "" : '"')}`);
+			}
+		} else {
+			lines.push(`${k}: ${JSON.stringify(v)}`);
+		}
+	}
+	return lines.join("\n");
+}
+
+/** Waits out the watcher's debounce. */
+const settle = (): Promise<void> => new Promise((resolve) => setTimeout(resolve, 400));
+
+describe("readValidatedConfig", () => {
+	test("accepts a valid partial and merges over defaults (removed knobs revert)", () => {
+		writeFileSync(CFG, yamlOf({ filters: { latencyWeight: 0.5 } }));
+		const result = readValidatedConfig(CFG);
+		expect(result.ok).toBe(true);
+		if (!result.ok) return;
+		expect(result.cfg.filters.latencyWeight).toBe(0.5);
+		// Untouched knobs carry the shipped default, not garbage.
+		expect(result.cfg.filters.contextHeadroom).toBe(DEFAULT_CONFIG.filters.contextHeadroom);
+		// A tier not mentioned in the file keeps its default shape.
+		expect(result.cfg.tiers.simple).toEqual(DEFAULT_CONFIG.tiers.simple);
+	});
+
+	test("rejects a schema violation and names the path", () => {
+		writeFileSync(CFG, yamlOf({ tiers: { hard: { capabilityFloorUsd: -5 } } }));
+		const result = readValidatedConfig(CFG);
+		expect(result.ok).toBe(false);
+		if (result.ok) return;
+		expect(result.error).toContain("capabilityFloorUsd");
+	});
+
+	test("rejects malformed YAML", () => {
+		writeFileSync(CFG, "filters: [unclosed");
+		const result = readValidatedConfig(CFG);
+		expect(result.ok).toBe(false);
+	});
+
+	test("reports a missing file", () => {
+		const result = readValidatedConfig(join(DIR, "nope.yml"));
+		expect(result.ok).toBe(false);
+	});
+});
+
+describe("watchConfig", () => {
+	const live: RouterConfig = structuredClone(DEFAULT_CONFIG);
+	let watcher: ConfigWatcher | null = null;
+	const reloads: string[][] = [];
+	const errors: string[] = [];
+
+	beforeAll(() => {
+		writeFileSync(CFG, "");
+		watcher = watchConfig(CFG, live, structuredClone(DEFAULT_CONFIG), ["server", "openrouter", "context", "ledger"], {
+			onReload: ({ changed }) => reloads.push(changed),
+			onError: (message) => errors.push(message),
+		});
+	});
+	afterAll(() => watcher?.close());
+
+	test("a valid edit mutates the live object in place, no restart", async () => {
+		writeFileSync(CFG, yamlOf({ tiers: { hard: { capabilityFloorUsd: 0.35 } } }));
+		await settle();
+		expect(live.tiers.hard.capabilityFloorUsd).toBe(0.35);
+		expect(reloads.flat()).toContain("tiers");
+	});
+
+	test("a second edit replaces the value and reverting restores the default", async () => {
+		writeFileSync(CFG, yamlOf({ tiers: { hard: { capabilityFloorUsd: 0.65 } } }));
+		await settle();
+		expect(live.tiers.hard.capabilityFloorUsd).toBe(0.65);
+		// Deleting the knob reverts to the shipped default, mirroring a restart.
+		writeFileSync(CFG, yamlOf({ filters: { latencyWeight: 0.4 } }));
+		await settle();
+		expect(live.tiers.hard.capabilityFloorUsd).toBeUndefined();
+		expect(live.filters.latencyWeight).toBe(0.4);
+	});
+
+	test("frozen blocks are pinned: file edits to them cannot reach the live object", async () => {
+		writeFileSync(CFG, yamlOf({ server: { port: 1, host: "10.9.9.9" }, filters: { latencyWeight: 0.3 } }));
+		await settle();
+		expect(live.server.port).toBe(DEFAULT_CONFIG.server.port);
+		expect(live.server.host).toBe(DEFAULT_CONFIG.server.host);
+		// The non-frozen sibling still applied.
+		expect(live.filters.latencyWeight).toBe(0.3);
+	});
+
+	test("an invalid file is rejected and the running config keeps serving", async () => {
+		const before = structuredClone(live.filters);
+		const tierBefore = structuredClone(live.tiers.hard);
+		// capabilityFloorUsd must be strictly positive: -1 is a schema violation.
+		writeFileSync(CFG, yamlOf({ tiers: { hard: { capabilityFloorUsd: -1 } } }));
+		await settle();
+		expect(errors.length).toBeGreaterThan(0);
+		expect(errors.at(-1)).toContain("capabilityFloorUsd");
+		// The live object keeps the last-good values.
+		expect(live.tiers.hard.capabilityFloorUsd).toBe(tierBefore.capabilityFloorUsd);
+		expect(live.filters.latencyWeight).toBe(before.latencyWeight);
+	});
+	test("close() stops watching: later edits are ignored", async () => {
+		watcher?.close();
+		writeFileSync(CFG, yamlOf({ filters: { latencyWeight: 9.9 } }));
+		await settle();
+		expect(live.filters.latencyWeight).not.toBe(9.9);
+	});
+});

package/test/tier-plan.test.ts

@@ -2,14 +2,18 @@ import { describe, expect, test } from "bun:test";
 
 import { joinBenchmarks, normalizeCatalogModel } from "../src/catalog/openrouter-catalog.ts";
 import type { CatalogModel, CatalogSnapshot } from "../src/catalog/types.ts";
-import { loadConfig } from "../src/config/load.ts";
+import { DEFAULT_CONFIG } from "../src/config/defaults.ts";
 import { buildCandidates } from "../src/router/candidates.ts";
 import { extractFeatures } from "../src/router/features.ts";
 import { computeTierPlan, effectivePriceCeiling, effectiveQualityFloor, tierPlanFor } from "../src/router/tier-plan.ts";
 import { TIER_ORDER } from "../src/router/types.ts";
 import { parseChatRequest } from "../src/wire/openai/request.ts";
 
-const BASE = loadConfig({});
+// SHIPPED defaults, deliberately NOT loadConfig({}): that reads the developer's
+// live ~/.auto-model-router/config.yml, so an enabled machine-wide knob (e.g.
+// tiers.hard.capabilityFloorUsd during the 0.2.20 rollout) silently changed
+// these expectations and made the suite machine-dependent.
+const BASE = DEFAULT_CONFIG;
 
 /** Raw `/models`-shaped record with a controllable coding score and price. */
 function raw(id: string, coding: number | null, inPerMtok: number): Record<string, unknown> {