auto-model-router 0.2.31 → 0.3.0

package/omp-extension/router-configure.ts

@@ -1,13 +1,30 @@
 /**
- * omp extension: `/router` — edit auto-model-router's settings through
- * omp's native UI dialogs.
+ * omp extension: `/router` — configure auto-model-router and pull usage
+ * reports without leaving the session.
  *
- * The command walks the same sections and fields as `auto-model-router config`
- * (reusing `WIZARD_SECTIONS` / `PROFILE_FIELDS` from the router's CLI) but
- * prompts through `ctx.ui` select/input/confirm dialogs instead of stdin.
- * Edits are persisted through the router's own validated merge
- * (`writeRouterConfig`), so the on-disk config.yml is schema-checked and
- * backed up exactly as the CLI wizard does.
+ *   /router                 menu: Configure / Report / Status
+ *   /router config          edit any section of the router's config.yml
+ *   /router report          usage analytics in a fullscreen hub styled like
+ *                           /models: views for overview, providers, models,
+ *                           tiers, by day and status, with the time window
+ *                           (24h / 7d / 30d / 90d) and harness scope chosen
+ *                           in the sidebar. `/router report 30d --all` presets
+ *                           them. Headless sessions get the text instead.
+ *   /router status          the router's /health: keys, catalog, Ollama
+ *                           availability and plan usage, agentdox.
+ *
+ * Configuration walks the same sections and fields as `auto-model-router
+ * config` (reusing `WIZARD_SECTIONS` / `PROFILE_FIELDS` from the router's
+ * CLI) but prompts through `ctx.ui` select/input dialogs. Edits are persisted
+ * through the router's own validated merge (`writeRouterConfig`), so the
+ * on-disk config.yml is schema-checked and backed up exactly as the CLI
+ * wizard does.
+ *
+ * Reports and status are fetched from the running router
+ * (`GET /v1/router/report`, `GET /health`) and posted into the transcript as
+ * a custom message, so they scroll with the conversation and the model can
+ * answer questions about them. If the router is unreachable the report falls
+ * back to reading the ledger directly.
  *
  * Install alongside router-embed.ts:
  *
@@ -15,64 +32,198 @@
  *   extensions:
  *     - /path/to/auto-model-router/omp-extension/router-embed.ts
  *     - /path/to/auto-model-router/omp-extension/router-configure.ts
- *
- * Run `/router` in an omp session to pick a section, edit its
- * fields, and save.
  */
 
-import { loadConfig } from "../src/config/load.ts";
+import { existsSync } from "node:fs";
+
 import { applyAnswers, PROFILE_FIELDS, WIZARD_SECTIONS } from "../src/cli/config-wizard.ts";
-import { writeRouterConfig, routerConfigPath } from "../src/cli/config-cmd.ts";
+import { routerConfigPath, writeRouterConfig } from "../src/cli/config-cmd.ts";
+import { loadConfig } from "../src/config/load.ts";
 import type { RouterConfig } from "../src/config/types.ts";
+import { buildUsageReport, renderUsageReport, type UsageReport } from "../src/cost/report.ts";
+import { openDb } from "../src/util/sqlite.ts";
 
-import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@oh-my-pi/pi-coding-agent";
 
-import { editProfile, sectionTitles, walkSection, type ConfigUi } from "./configure-logic.ts";
+import { matchesKey, truncateToWidth, visibleWidth } from "@oh-my-pi/pi-tui";
+
+import { editProfile, editSectionMenu, type ConfigUi, type SelectOption } from "./configure-logic.ts";
+import { ReportHub } from "./report-hub.ts";
+import { fetchReport, parseReportArgs, renderStatus, type HealthSnapshot, type ReportRequest } from "./report-logic.ts";
+import { routerAuthHeaders, routerBaseUrl } from "./router-url.ts";
+
+// This harness's id, matching the X-Omp-Harness header the router records.
+// Empty ⇒ reports cover every harness (single-harness default).
+const HARNESS_ID = process.env.OMP_HARNESS_ID ?? "";
+
+/** Custom message type for report/status output in the transcript. */
+const MESSAGE_TYPE = "auto-model-router";
 
 export default function (pi: ExtensionAPI): void {
-	pi.setLabel("auto-model-router configure");
+	pi.setLabel("auto-model-router");
 
 	pi.registerCommand("router", {
-		description: "Configure auto-model-router settings through the native UI",
-		handler: async (_args, ctx) => {
-			const ui = ctx.ui;
-			const cfg = loadConfig();
-			const answers: Record<string, unknown> = {};
-
-			for (;;) {
-				const options = [...sectionTitles(WIZARD_SECTIONS), "Profiles", "Save and exit", "Quit without saving"];
-				const chosen = await ui.select("auto-model-router configure", options);
-				if (chosen === undefined) return;
-				if (chosen === "Quit without saving") return;
-				if (chosen === "Save and exit") break;
-
-				if (chosen === "Profiles") {
-					await editProfiles(ui, cfg, answers);
-					continue;
-				}
-
-				const section = WIZARD_SECTIONS.find((s) => s.title === chosen);
-				if (section === undefined) continue;
-				await walkSection(ui, section, cfg, answers);
-			}
-
-			if (Object.keys(answers).length === 0) {
-				ui.notify("no changes made", "info");
-				return;
+		description: "auto-model-router: configure, usage report, status",
+		handler: async (args, ctx) => {
+			const [verb = "", ...rest] = args.trim().split(/\s+/).filter((t) => t !== "");
+			const tail = rest.join(" ");
+			switch (verb.toLowerCase()) {
+				case "config":
+				case "configure":
+					return configure(ctx);
+				case "report":
+					return report(pi, ctx, tail);
+				case "status":
+				case "health":
+					return status(pi, ctx);
+				case "":
+					break;
+				default:
+					ctx.ui.notify(`unknown /router subcommand "${verb}" (config | report [7d] [--all] | status)`, "warn");
+					return;
 			}
 
-			try {
-				const target = routerConfigPath();
-				const partial = applyAnswers(answers);
-				const backup = writeRouterConfig(target, partial);
-				ui.notify(`wrote ${target}${backup ? ` (backup: ${backup})` : ""}`, "info");
-			} catch (err) {
-				ui.notify(err instanceof Error ? err.message : String(err), "error");
-			}
+			const chosen = await ctx.ui.select("auto-model-router", [
+				{ label: "Configure", description: "edit any router setting" },
+				{ label: "Report", description: "usage analytics; window and scope adjustable inside" },
+				{ label: "Status", description: "keys, catalog, Ollama, agentdox" },
+			]);
+			if (chosen === undefined) return;
+			if (chosen === "Configure") return configure(ctx);
+			if (chosen === "Status") return status(pi, ctx);
+			if (chosen === "Report") return report(pi, ctx, "");
 		},
 	});
 }
 
+/** Posts a block of text into the transcript without triggering a turn. */
+function post(pi: ExtensionAPI, text: string): void {
+	pi.sendMessage({ customType: MESSAGE_TYPE, content: `\`\`\`text\n${text}\n\`\`\``, display: true }, { triggerTurn: false });
+}
+
+/** Loads a report: the running router first, the ledger directly if it is down. */
+async function loadReport(req: ReportRequest): Promise<UsageReport> {
+	try {
+		return await fetchReport(routerBaseUrl(), req, routerAuthHeaders());
+	} catch (err) {
+		// Router not reachable (standalone `serve` not running, or embed still
+		// starting): read the ledger directly so the report still comes back.
+		const cfg = loadConfig();
+		if (!existsSync(cfg.ledger.path)) {
+			throw new Error(`router unreachable (${err instanceof Error ? err.message : String(err)}) and no ledger at ${cfg.ledger.path}`);
+		}
+		const db = openDb(cfg.ledger.path);
+		try {
+			return buildUsageReport(db, req);
+		} finally {
+			db.close();
+		}
+	}
+}
+
+async function loadStatus(): Promise<string> {
+	const baseUrl = routerBaseUrl();
+	const res = await fetch(`${baseUrl}/health`, { headers: routerAuthHeaders(), signal: AbortSignal.timeout(5_000) });
+	if (!res.ok) throw new Error(`router returned ${res.status}`);
+	return renderStatus(baseUrl, (await res.json()) as HealthSnapshot);
+}
+
+async function report(pi: ExtensionAPI, ctx: ExtensionContext, argText: string): Promise<void> {
+	const req = parseReportArgs(argText, HARNESS_ID);
+	// Interactive sessions get the fullscreen hub (the /models look); headless
+	// and print modes get the text posted into the transcript.
+	if (ctx.hasUI && typeof ctx.ui.custom === "function") {
+		await ctx.ui.custom<void>(
+			(tui, theme, keybindings, done) =>
+				new ReportHub({
+					theme,
+					text: { visibleWidth, truncateToWidth },
+					keys: {
+						up: (d) => keybindings.matches(d, "tui.select.up"),
+						down: (d) => keybindings.matches(d, "tui.select.down"),
+						pageUp: (d) => keybindings.matches(d, "tui.select.pageUp"),
+						pageDown: (d) => keybindings.matches(d, "tui.select.pageDown"),
+						cancel: (d) => keybindings.matches(d, "tui.select.cancel"),
+						confirm: (d) => keybindings.matches(d, "tui.select.confirm"),
+						left: (d) => matchesKey(d, "left"),
+						right: (d) => matchesKey(d, "right"),
+					},
+					source: { report: loadReport, status: loadStatus },
+					rows: () => tui.terminal?.rows ?? process.stdout.rows ?? 40,
+					requestRender: () => tui.requestRender(),
+					close: () => done(undefined),
+					initial: req,
+					harnessId: HARNESS_ID,
+				}),
+			{ overlay: true, overlayOptions: { fullscreen: true, width: "100%", maxHeight: "100%", anchor: "center" } },
+		);
+		return;
+	}
+	let data: UsageReport;
+	try {
+		data = await loadReport(req);
+	} catch (err) {
+		ctx.ui.notify(err instanceof Error ? err.message : String(err), "error");
+		return;
+	}
+	if (data.totals.dispatches === 0) {
+		ctx.ui.notify(`no routed turns in the last ${req.windowDays}d${req.harnessId === "" ? "" : ` for harness ${req.harnessId}`}`, "info");
+		return;
+	}
+	post(pi, renderUsageReport(data));
+}
+
+async function status(pi: ExtensionAPI, ctx: ExtensionContext): Promise<void> {
+	try {
+		post(pi, await loadStatus());
+	} catch (err) {
+		ctx.ui.notify(`router unreachable at ${routerBaseUrl()}: ${err instanceof Error ? err.message : String(err)}`, "error");
+	}
+}
+
+async function configure(ctx: ExtensionContext): Promise<void> {
+	const ui = ctx.ui;
+	const cfg = loadConfig();
+	const answers: Record<string, unknown> = {};
+
+	for (;;) {
+		// Each section shows how many of its fields have pending edits.
+		const options: SelectOption[] = WIZARD_SECTIONS.map((s) => {
+			const touched = s.fields.filter((f) => f.path in answers).length;
+			return touched > 0 ? { label: s.title, description: `${touched} pending` } : { label: s.title, description: `${s.fields.length} settings` };
+		});
+		options.push("profiles" in answers ? { label: "Profiles", description: "pending" } : { label: "Profiles", description: `${cfg.profiles.length} profiles` }, "Save and exit", "Quit without saving");
+		const pending = Object.keys(answers).length;
+		const chosen = await ui.select(`auto-model-router configure${pending > 0 ? ` (${pending} pending)` : ""}`, options);
+		if (chosen === undefined) return;
+		if (chosen === "Quit without saving") return;
+		if (chosen === "Save and exit") break;
+
+		if (chosen === "Profiles") {
+			await editProfiles(ui, cfg, answers);
+			continue;
+		}
+
+		const section = WIZARD_SECTIONS.find((s) => s.title === chosen);
+		if (section === undefined) continue;
+		await editSectionMenu(ui, section, cfg, answers);
+	}
+
+	if (Object.keys(answers).length === 0) {
+		ui.notify("no changes made", "info");
+		return;
+	}
+
+	try {
+		const target = routerConfigPath();
+		const partial = applyAnswers(answers);
+		const backup = writeRouterConfig(target, partial);
+		ui.notify(`wrote ${target}${backup ? ` (backup: ${backup})` : ""} — restart omp for server/upstream/ledger changes`, "info");
+	} catch (err) {
+		ui.notify(err instanceof Error ? err.message : String(err), "error");
+	}
+}
+
 /** Edits the profiles array as whole elements, mirroring the CLI wizard. */
 async function editProfiles(
 	ui: ConfigUi,
@@ -83,7 +234,8 @@ async function editProfiles(
 	// expects), converting at the boundary to/from ProfileConfig.
 	const list: Record<string, unknown>[] = cfg.profiles.map((p) => ({ ...p }));
 	const names = list.map((p, i) => `${i + 1}) ${p.id} (${p.name})`);
-	const choice = await ui.select("Profiles", [...names, "+ Add profile", "Back"]);
+	const items: SelectOption[] = list.map((p, i) => ({ label: names[i] ?? "", description: `${p.minTier}..${p.maxTier} · ctx ${p.contextWindow} · out ${p.maxTokens}` }));
+	const choice = await ui.select("Profiles", [...items, "+ Add profile", "Back"]);
 	if (choice === undefined || choice === "Back") return;
 
 	if (choice === "+ Add profile") {

package/omp-extension/router-url.ts

@@ -0,0 +1,52 @@
+/**
+ * Where the router is listening, resolved fresh on every call.
+ *
+ * The embedded router binds a free OS-assigned port and writes it to the
+ * port file at session start, so nothing can cache the URL: the toast poll,
+ * `/router report` and `/router status` all resolve it at the moment of use.
+ * Precedence: `AUTO_MODEL_ROUTER_URL`, the embed port file,
+ * `AUTO_MODEL_ROUTER_PORT`, then `server.port` in the router's config.yml.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+import { parse as parseYaml } from "yaml";
+
+import { embedPortPath, readEmbedPort } from "./embed-logic.ts";
+import { resolveRouterUrl } from "./toast-logic.ts";
+
+/** `$AUTO_MODEL_ROUTER_HOME` with `~` expanded, default `~/.auto-model-router`. */
+export function routerHome(): string {
+	const raw = process.env.AUTO_MODEL_ROUTER_HOME ?? join(homedir(), ".auto-model-router");
+	return raw === "~" || raw.startsWith("~/") || raw.startsWith("~\\") ? join(homedir(), raw.slice(1)) : raw;
+}
+
+/** Raw router config.yml, or null when there is none to read. */
+export function readRouterConfigText(): string | null {
+	const path = join(routerHome(), "config.yml");
+	if (!existsSync(path)) return null;
+	try {
+		return readFileSync(path, "utf8");
+	} catch {
+		return null;
+	}
+}
+
+/** Base URL of the router this omp process should talk to. */
+export function routerBaseUrl(): string {
+	return resolveRouterUrl(
+		process.env.AUTO_MODEL_ROUTER_URL,
+		readRouterConfigText(),
+		parseYaml,
+		process.env.AUTO_MODEL_ROUTER_PORT,
+		readEmbedPort(embedPortPath(routerHome())),
+	);
+}
+
+/** Authorization header for a router configured with `server.apiKey`. */
+export function routerAuthHeaders(): Record<string, string> {
+	const key = process.env.AUTO_MODEL_ROUTER_API_KEY;
+	return key === undefined || key === "" ? {} : { authorization: `Bearer ${key}` };
+}

package/omp-extension/toast-logic.ts

@@ -98,10 +98,22 @@ export interface ToastMessage {
 	text: string;
 }
 
+/**
+ * Provider and model for display. Catalog slugs namespace providers by
+ * prefix: `ollama/<id>` is Ollama Cloud, anything else is OpenRouter (whose
+ * slugs keep their vendor segment, e.g. `z-ai/glm-5.3-flash`). The Ollama
+ * prefix is dropped from the displayed model since the provider label
+ * already says it.
+ */
+export function providerOf(slug: string): { provider: string; model: string } {
+	if (slug.startsWith("ollama/")) return { provider: "ollama", model: slug.slice("ollama/".length) };
+	return { provider: "openrouter", model: slug };
+}
+
 export function toToastText(d: ToastDecision): string {
-	const model = d.servedSlug ?? d.slug;
+	const { provider, model } = providerOf(d.servedSlug ?? d.slug);
 	const cost = d.reportedUsd === null ? "" : ` \u00b7 $${d.reportedUsd.toFixed(5)}`;
-	return `${model} [${d.tier}]${cost}`;
+	return `${provider} \u00b7 ${model} [${d.tier}]${cost}`;
 }
 
 /**

package/package.json

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

package/src/catalog/composite.ts

@@ -0,0 +1,97 @@
+/**
+ * A `CatalogSource` that presents OpenRouter's catalog and Ollama Cloud's as
+ * one snapshot, so selection ranks them together.
+ *
+ * The merged snapshot object is reused until either side actually changes,
+ * because `tierPlanFor` memoises per snapshot identity and a fresh object per
+ * turn would recompute the tier plan every turn for nothing.
+ *
+ * While the Ollama breaker is open (plan quota or concurrency limit hit), the
+ * Ollama models are left out entirely: a candidate that will 402 or 429 is
+ * not a candidate, and hiding it here means the turn routes straight to an
+ * OpenRouter model instead of paying a doomed dispatch first.
+ */
+
+import type { OllamaAvailability } from "../upstream/ollama.ts";
+import { effectiveOllamaBias, NO_USAGE, type OllamaUsageSource } from "../upstream/ollama-usage.ts";
+import { mergeSnapshots, type OllamaCatalogSource } from "./ollama-catalog.ts";
+import type { CatalogModel, CatalogShrink, CatalogSnapshot, CatalogSource } from "./types.ts";
+
+export interface CompositeBias {
+	/** Static multiplier from config. */
+	costBias: number;
+	/** Plan usage fraction at which the bias switches off (list price). */
+	biasUntilUsage: number;
+	usage: OllamaUsageSource;
+}
+
+export function createCompositeCatalog(
+	openrouter: CatalogSource,
+	ollama: OllamaCatalogSource,
+	availability: OllamaAvailability,
+	bias: CompositeBias = { costBias: 1, biasUntilUsage: 1, usage: NO_USAGE },
+): CatalogSource & { ollamaModels(): CatalogModel[]; ollamaBias(): number } {
+	let lastBase: CatalogSnapshot | null = null;
+	let lastOllama: readonly CatalogModel[] = [];
+	let lastAvailable = true;
+	let lastBias = 1;
+	let merged: CatalogSnapshot | null = null;
+
+	/** The multiplier in force from the latest usage reading (no network). */
+	function currentBias(): number {
+		return effectiveOllamaBias(bias.costBias, bias.biasUntilUsage, bias.usage.peek());
+	}
+
+	function combine(base: CatalogSnapshot, models: readonly CatalogModel[]): CatalogSnapshot {
+		const available = availability.available();
+		const providerBias = currentBias();
+		if (merged !== null && base === lastBase && models === lastOllama && available === lastAvailable && providerBias === lastBias) return merged;
+		lastBase = base;
+		lastOllama = models;
+		lastAvailable = available;
+		lastBias = providerBias;
+		merged = mergeSnapshots(base, available ? models : []);
+		// A fresh object either way once anything changed; stamp the live bias so
+		// candidate scoring reads it off the snapshot it is ranking.
+		merged = { ...merged, providerBias: { ollama: providerBias } };
+		return merged;
+	}
+
+	function find(slug: string): CatalogModel | undefined {
+		const fromBase = openrouter.find(slug);
+		if (fromBase !== undefined) return fromBase;
+		for (const m of lastOllama) if (m.slug === slug) return m;
+		for (const m of ollama.peek()) if (m.slug === slug) return m;
+		return undefined;
+	}
+
+	return {
+		async get(): Promise<CatalogSnapshot> {
+			const base = await openrouter.get();
+			const models = await ollama.get(base.models);
+			// Refreshes on its own poll interval; a cached reading returns at once.
+			await bias.usage.get();
+			return combine(base, models);
+		},
+		async refresh(): Promise<CatalogSnapshot> {
+			const base = await openrouter.refresh();
+			ollama.invalidate();
+			const models = await ollama.get(base.models);
+			await bias.usage.get();
+			return combine(base, models);
+		},
+		ollamaBias: currentBias,
+		peek(): CatalogSnapshot | null {
+			const base = openrouter.peek();
+			if (base === null) return null;
+			return combine(base, ollama.peek());
+		},
+		find,
+		lastShrink(): CatalogShrink | null {
+			return openrouter.lastShrink?.() ?? null;
+		},
+		ollamaModels(): CatalogModel[] {
+			return [...ollama.peek()];
+		},
+	};
+}