auto-model-router 0.4.6 → 0.4.8

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

package/README.md

@@ -410,8 +410,12 @@ user-visible notice channel; use `/router why`), the automatic daily summary
 
 ### Codex CLI
 
-Codex talks to custom providers over the chat-completions wire. Run the
-router (`auto-model-router serve --port 8788`) and add a provider:
+Codex (0.150 and later) speaks only the Responses API, which the router
+serves at `POST /v1/responses`: the body is translated to the chat shape
+the router routes on (`instructions` → system, `input` items → messages,
+function calls and outputs → tool calls and tool messages) and the upstream
+stream is rendered back as Responses events. Run the router
+(`auto-model-router serve --port 8788`) and add a provider:
 
 ```toml
 # ~/.codex/config.toml
@@ -421,13 +425,17 @@ model_provider = "auto-model-router"
 [model_providers.auto-model-router]
 name = "auto-model-router"
 base_url = "http://127.0.0.1:8788/v1"
-wire_api = "chat"
+env_key = "AUTO_MODEL_ROUTER_API_KEY"   # any value; the router is keyless
+wire_api = "responses"
 http_headers = { "X-Omp-Harness" = "codex" }
 ```
 
-The router drops the OpenAI-platform-only parameters Codex sends (`store`,
-`prompt_cache_key`, `service_tier`) before dispatch. No session id or hooks:
-reports are per harness, and there is no toast, digest or `/router`.
+Verified live with codex 0.153: the captured request is
+`test/fixtures/harness/codex-responses.json`. Stateless only — Codex sends
+`store: false` and the full input each turn; `previous_response_id` is
+rejected. Reasoning summaries and encrypted reasoning are not produced. No
+session id or hooks: reports are per harness, and there is no toast, digest
+or `/router`.
 
 ### Aider
 
@@ -437,8 +445,12 @@ export OPENAI_API_KEY=local
 aider --model openai/auto
 ```
 
-Aider sends no tool calls, so every turn classifies on its text alone. No
-session id or hooks.
+Verified live with aider 0.86 (captured request:
+`test/fixtures/harness/aider.json`). Aider sends no tool calls, so every turn
+classifies on its text alone, and no custom headers, so its rows carry no
+harness id unless you set one in a model settings file
+(`extra_params: { extra_headers: { X-Omp-Harness: aider } }`). No session
+id or hooks.
 
 ### Cline, Roo Code, Kilo Code
 
@@ -468,9 +480,28 @@ digest applies only through summarising compaction
 }
 ```
 
-OpenCode's tool names (`read`, `grep`, `glob`, `bash`, `webfetch`) match the
-router's canonical list. Its plugin API has tool and message hooks, so a
-native port (session identity, digest) is the next candidate after Hermes.
+Verified live with opencode 1.18 (captured request:
+`test/fixtures/harness/opencode.json`). OpenCode's AI SDK validates every
+SSE frame, which is why the router's final summary frame is shaped as a
+chunk with no choices. Its tool names (`read`, `grep`, `glob`, `bash`,
+`webfetch`) match the router's canonical list.
+
+**Native features (OpenCode plugin API).** Copy
+`opencode-plugin/auto-model-router.ts` to `~/.config/opencode/plugin/` (or a
+project's `.opencode/plugin/`); OpenCode loads it on start. It adds:
+
+- **Session identity** — `X-Omp-Session`, `X-Omp-Harness` (`opencode`, or
+  `OMP_HARNESS_ID`) and `X-Omp-Subagent` for sessions with a parent, through
+  the `chat.headers` hook.
+- **Routing toast** — when a session goes idle, its last routed turn's
+  provider, model, tier and cost appear as a TUI toast.
+- **Tool-result digest** — large `read`, `grep`, `glob`, `bash` and
+  `webfetch` results go to `/v1/router/digest` through `tool.execute.after`
+  and the model gets the digest. Off unless `digest.enabled`.
+
+No `/router` command (OpenCode commands are markdown files, not plugin
+hooks): use `auto-model-router report` on the terminal, or the router's
+HTTP endpoints.
 
 ### The OpenRouter key
 
@@ -1077,10 +1108,10 @@ plus a harness header; the rest needs the harness's own hook API.
 | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
 | omp | native provider | yes | yes | yes | yes | full hub | yes | yes | experimental |
 | Hermes | provider plugin | yes | yes (native plugin) | yes (native plugin) | no | text | yes (native plugin) | on demand | no |
-| Codex CLI | config only | yes | no | no | no | no | compaction only | no | no |
-| Aider | config only | yes | no | no | no | no | no tools | no | no |
+| Codex CLI | Responses API wire | yes | no | no | no | no | compaction only | no | no |
+| Aider | config only | via model settings | no | no | no | no | no tools | no | no |
 | Cline / Roo / Kilo | config only | if headers supported | no | no | no | no | compaction only | no | no |
-| OpenCode | config only | yes | no | no | no | no | compaction only | no | no |
+| OpenCode | config + plugin | yes | yes (plugin) | yes (plugin) | yes (plugin) | no | yes (plugin) | no | no |
 | Claude Code | needs an Anthropic Messages wire module | — | — | — | — | — | — | — | — |
 
 A single embedded router can serve several omp sessions without them stepping

package/hermes-plugin/native/__init__.py

@@ -273,9 +273,11 @@ def _why_text(e: Dict[str, Any]) -> str:
     pt, ct = usage.get("promptTokens", 0) or 0, usage.get("cachedTokens", 0) or 0
     cache = f"{round(100 * ct / pt)}%" if pt else "n/a"
     cost = e.get("reportedUsd")
+    if cost is None:
+        cost = e.get("predictedUsd") or 0
     lines = [
         f"last turn: {e.get('servedSlug') or e.get('slug')} [{e.get('tier')}] · {e.get('classificationSource')} (confidence {e.get('confidence')})",
-        f"cost ${cost if cost is not None else e.get('predictedUsd')} · cache hit {cache} · latency {e.get('latencyMs')}ms",
+        f"cost ${float(cost):.5f} · cache hit {cache} · latency {e.get('latencyMs')}ms",
     ]
     for r in e.get("reasons") or []:
         lines.append(f"  - {r}")

package/opencode-plugin/auto-model-router.ts

@@ -0,0 +1,151 @@
+/**
+ * OpenCode plugin: auto-model-router native features.
+ *
+ * OpenCode reaches the router through an OpenAI-compatible provider block
+ * (see README, "OpenCode"). This plugin adds what the provider block cannot:
+ *
+ * - **Session identity** — `chat.headers` adds `X-Omp-Session`,
+ *   `X-Omp-Harness` and, for a session with a parent (a subagent),
+ *   `X-Omp-Subagent`, so per-session reports, feedback and the router's
+ *   subagent profile work as in omp.
+ * - **Routing toast** — when a session goes idle, the model, tier and cost of
+ *   its last routed turn are shown as a TUI toast (nothing in `run` mode).
+ * - **Tool-result digest** — `tool.execute.after` sends a large read, grep,
+ *   glob, bash or webfetch result to the router's `/v1/router/digest` and
+ *   hands the model the digest instead. The router decides (policy, session
+ *   tier, cost guard). Off unless `digest.enabled` is set in the router config.
+ *
+ * Install: copy this file to `~/.config/opencode/plugin/auto-model-router.ts`
+ * (or `.opencode/plugin/` in a project). OpenCode loads it on start. The
+ * router URL is `AUTO_MODEL_ROUTER_URL`, else port `AUTO_MODEL_ROUTER_PORT`
+ * (default 8788) on localhost.
+ */
+
+import type { Plugin } from "@opencode-ai/plugin";
+
+const PROVIDER_ID = "auto-model-router";
+const BASE_URL = process.env.AUTO_MODEL_ROUTER_URL ?? `http://127.0.0.1:${process.env.AUTO_MODEL_ROUTER_PORT ?? "8788"}`;
+const HARNESS_ID = process.env.OMP_HARNESS_ID ?? "opencode";
+const POLICY_TTL_MS = 60_000;
+
+interface DigestPolicy {
+	enabled: boolean;
+	minBytes: number;
+	maxBytes: number;
+	tools: string[];
+	toolAliases: Record<string, string>;
+}
+const DISABLED: DigestPolicy = { enabled: false, minBytes: 0, maxBytes: 0, tools: [], toolAliases: {} };
+
+function parsePolicy(json: unknown): DigestPolicy {
+	if (json === null || typeof json !== "object") return DISABLED;
+	const p = json as Record<string, unknown>;
+	if (p.enabled !== true) return DISABLED;
+	return {
+		enabled: true,
+		minBytes: typeof p.minBytes === "number" ? p.minBytes : 12_000,
+		maxBytes: typeof p.maxBytes === "number" ? p.maxBytes : 400_000,
+		tools: Array.isArray(p.tools) ? p.tools.filter((t): t is string => typeof t === "string").map((t) => t.toLowerCase()) : [],
+		toolAliases: p.toolAliases !== null && typeof p.toolAliases === "object" ? Object.fromEntries(Object.entries(p.toolAliases as Record<string, unknown>).filter((e): e is [string, string] => typeof e[1] === "string")) : {},
+	};
+}
+
+/** Whether a tool result is worth sending: policy on, eligible tool, size in the window. */
+export function shouldDigest(policy: DigestPolicy, tool: string, text: string): boolean {
+	if (!policy.enabled) return false;
+	const lower = tool.toLowerCase();
+	if (!policy.tools.includes(policy.toolAliases[lower] ?? lower)) return false;
+	const bytes = Buffer.byteLength(text);
+	return bytes >= policy.minBytes && bytes <= policy.maxBytes;
+}
+
+/** One toast line for the last routed turn of a session. */
+export function toastLine(e: { slug?: string; servedSlug?: string; tier?: string; reportedUsd?: number | null; predictedUsd?: number }): string {
+	const slug = e.servedSlug ?? e.slug ?? "?";
+	const provider = slug.startsWith("ollama/") ? "ollama" : "openrouter";
+	const usd = e.reportedUsd ?? e.predictedUsd ?? 0;
+	return `${provider} · ${slug.replace(/^ollama\//, "")} [${e.tier ?? "?"}] · $${usd.toFixed(5)}`;
+}
+
+export const AutoModelRouter: Plugin = async ({ client }) => {
+	let policy = DISABLED;
+	let policyAtMs = 0;
+	const parents = new Map<string, string | null>();
+	const lastToasted = new Map<string, string>();
+
+	async function refreshPolicy(): Promise<DigestPolicy> {
+		if (Date.now() - policyAtMs < POLICY_TTL_MS) return policy;
+		policyAtMs = Date.now();
+		try {
+			const res = await fetch(`${BASE_URL}/v1/router/digest/policy`, { signal: AbortSignal.timeout(2_000) });
+			policy = res.ok ? parsePolicy(await res.json()) : DISABLED;
+		} catch {
+			policy = DISABLED;
+		}
+		return policy;
+	}
+
+	async function parentOf(sessionID: string): Promise<string | null> {
+		const known = parents.get(sessionID);
+		if (known !== undefined) return known;
+		let parent: string | null = null;
+		try {
+			const res = await client.session.get({ path: { id: sessionID } });
+			parent = res.data?.parentID ?? null;
+		} catch {
+			parent = null;
+		}
+		parents.set(sessionID, parent);
+		return parent;
+	}
+
+	async function toast(sessionID: string): Promise<void> {
+		try {
+			const res = await fetch(`${BASE_URL}/v1/router/decisions?limit=1&session=${encodeURIComponent(sessionID)}`, { signal: AbortSignal.timeout(2_000) });
+			if (!res.ok) return;
+			const body = (await res.json()) as { entries?: { id: string; slug?: string; servedSlug?: string; tier?: string; reportedUsd?: number | null; predictedUsd?: number }[] };
+			const entry = body.entries?.[0];
+			if (entry === undefined || lastToasted.get(sessionID) === entry.id) return;
+			lastToasted.set(sessionID, entry.id);
+			await client.tui.showToast({ body: { title: "auto-model-router", message: toastLine(entry), variant: "info", duration: 4_000 } });
+		} catch {
+			// No TUI (run mode) or router down: nothing to show.
+		}
+	}
+
+	return {
+		"chat.headers": async (input, output) => {
+			if (input.model.providerID !== PROVIDER_ID) return;
+			output.headers["X-Omp-Session"] = input.sessionID;
+			output.headers["X-Omp-Harness"] = HARNESS_ID;
+			if ((await parentOf(input.sessionID)) !== null) output.headers["X-Omp-Subagent"] = "1";
+		},
+		event: async ({ event }) => {
+			if (event.type === "session.created") {
+				const info = (event as { properties: { info: { id: string; parentID?: string } } }).properties.info;
+				parents.set(info.id, info.parentID ?? null);
+			} else if (event.type === "session.idle") {
+				await toast((event as { properties: { sessionID: string } }).properties.sessionID);
+			}
+		},
+		"tool.execute.after": async (input, output) => {
+			const p = await refreshPolicy();
+			if (typeof output.output !== "string" || !shouldDigest(p, input.tool, output.output)) return;
+			try {
+				const res = await fetch(`${BASE_URL}/v1/router/digest`, {
+					method: "POST",
+					headers: { "content-type": "application/json" },
+					body: JSON.stringify({ ompSessionId: input.sessionID, harnessId: HARNESS_ID, toolName: input.tool, input: input.args ?? {}, content: output.output, query: "" }),
+					signal: AbortSignal.timeout(30_000),
+				});
+				if (!res.ok) return;
+				const r = (await res.json()) as { digested: boolean; text?: string };
+				if (r.digested && typeof r.text === "string") output.output = r.text;
+			} catch {
+				// Router unreachable or slow: the raw result stands.
+			}
+		},
+	};
+};
+
+export default AutoModelRouter;

package/opencode-plugin/opencode-plugin.d.ts

@@ -0,0 +1,39 @@
+/**
+ * LOCAL ambient stub for OpenCode's plugin API — not the vendor's types.
+ *
+ * `@opencode-ai/plugin` is resolved by OpenCode when it loads the plugin; it
+ * is not a dependency of this repo. This declares only the surface
+ * auto-model-router.ts uses, so the plugin is type-checked with the rest of
+ * the tree (tsconfig.all.json). The real types live in the package OpenCode
+ * installs under ~/.config/opencode/node_modules/@opencode-ai/plugin; treat a
+ * change here as a claim about that API that only a live session confirms.
+ */
+declare module "@opencode-ai/plugin" {
+	export interface SessionInfo {
+		id: string;
+		parentID?: string;
+	}
+	export interface OpencodeClient {
+		session: {
+			get(options: { path: { id: string } }): Promise<{ data?: SessionInfo }>;
+		};
+		tui: {
+			showToast(options: { body: { title?: string; message: string; variant: "info" | "success" | "warning" | "error"; duration?: number } }): Promise<unknown>;
+		};
+	}
+	export interface PluginInput {
+		client: OpencodeClient;
+		directory: string;
+		worktree: string;
+	}
+	export type Event =
+		| { type: "session.created"; properties: { info: SessionInfo } }
+		| { type: "session.idle"; properties: { sessionID: string } }
+		| { type: string; properties?: unknown };
+	export interface Hooks {
+		event?: (input: { event: Event }) => Promise<void>;
+		"chat.headers"?: (input: { sessionID: string; agent: string; model: { providerID?: string; id?: string } }, output: { headers: Record<string, string> }) => Promise<void>;
+		"tool.execute.after"?: (input: { tool: string; sessionID: string; callID: string; args: unknown }, output: { title: string; output: string; metadata: unknown }) => Promise<void>;
+	}
+	export type Plugin = (input: PluginInput) => Promise<Hooks>;
+}

package/package.json

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

package/src/server/digest.ts

@@ -121,6 +121,14 @@ interface RecentDigest {
 	atMs: number;
 	ledgerId: string;
 	rerun: boolean;
+	/**
+	 * Whether the call that PRODUCED this digest has been seen. A tool_result
+	 * digest is made before the next request, and that request's last
+	 * assistant message carries the producing call; it must not count as a
+	 * re-run. A compaction digest covers a call already in history, so its
+	 * origin counts as seen from the start.
+	 */
+	originSeen: boolean;
 }
 const RERUN_WINDOW_MS = 2 * 3_600_000;
 const RECENT_PER_SESSION = 50;
@@ -261,7 +269,7 @@ export function createDigester(deps: DigesterDeps): Digester {
 			if (text === "" || text.length >= inputBytes * 0.9) return { digested: false, reason: "digest did not shrink the output" };
 			if (req.ompSessionId !== "") {
 				const list = recent.get(req.ompSessionId) ?? [];
-				list.push({ tool: req.toolName.toLowerCase(), arg: primaryArg(JSON.stringify(req.input)), atMs: startedAt, ledgerId: entry.id, rerun: false });
+				list.push({ tool: req.toolName.toLowerCase(), arg: primaryArg(JSON.stringify(req.input)), atMs: startedAt, ledgerId: entry.id, rerun: false, originSeen: source === "compaction" });
 				recent.set(req.ompSessionId, list.slice(-RECENT_PER_SESSION));
 			}
 			return {
@@ -284,6 +292,11 @@ export function createDigester(deps: DigesterDeps): Digester {
 				if (arg === null) continue;
 				for (const d of list) {
 					if (d.rerun || d.tool !== tool || d.arg !== arg || nowMs - d.atMs > RERUN_WINDOW_MS) continue;
+					if (!d.originSeen) {
+						// The producing call, arriving in the next request's history.
+						d.originSeen = true;
+						continue;
+					}
 					d.rerun = true;
 					marked++;
 					try {

package/src/server/http.ts

@@ -25,8 +25,9 @@ import { openDb } from "../util/sqlite.ts";
 import { WireErrorException, renderErrorEnvelope } from "../wire/openai/errors.ts";
 import { renderModelList } from "../wire/openai/models.ts";
 import { parseChatRequest } from "../wire/openai/request.ts";
+import { createResponsesBufferedSink, createResponsesStreamingSink, parseResponsesRequest } from "../wire/openai/responses.ts";
 import { createBufferedSink, createStreamingSink } from "../wire/openai/sink.ts";
-import type { NormRequest, WireError } from "../wire/types.ts";
+import type { NormRequest, ResponseSink, WireError } from "../wire/types.ts";
 import { runTurn } from "./turn.ts";
 
 export interface StartedServer {
@@ -321,10 +322,19 @@ export function startServer(cfg: RouterConfig): StartedServer {
 		inFlightTurns--;
 	};
 
-	const handleChatCompletions = async (req: Request): Promise<Response> => {
+	/** A wire: how a request body becomes a NormRequest and how the turn is rendered back. */
+	interface Wire {
+		parse(body: unknown, headers: Headers): NormRequest;
+		streaming(model: string): { sink: ResponseSink; response: Response };
+		buffered(model: string): { sink: ResponseSink; response: Promise<Response> };
+	}
+	const CHAT_WIRE: Wire = { parse: parseChatRequest, streaming: createStreamingSink, buffered: createBufferedSink };
+	const RESPONSES_WIRE: Wire = { parse: parseResponsesRequest, streaming: createResponsesStreamingSink, buffered: createResponsesBufferedSink };
+
+	const handleTurn = async (req: Request, wire: Wire): Promise<Response> => {
 		let normReq: NormRequest;
 		try {
-			normReq = parseChatRequest(await req.json(), req.headers);
+			normReq = wire.parse(await req.json(), req.headers);
 		} catch (err) {
 			// The slot was acquired before parsing; a rejected body never reaches
 			// runTurn's `finally`, so it must be released here or every malformed
@@ -338,9 +348,7 @@ export function startServer(cfg: RouterConfig): StartedServer {
 			});
 		}
 
-		const { sink, response } = normReq.stream
-			? createStreamingSink(normReq.requestedModel)
-			: createBufferedSink(normReq.requestedModel);
+		const { sink, response } = normReq.stream ? wire.streaming(normReq.requestedModel) : wire.buffered(normReq.requestedModel);
 
 		// The client signal aborts the upstream dispatch on disconnect. runTurn is
 		// expected to render its own failures into the sink; this catch is the last
@@ -399,7 +407,14 @@ export function startServer(cfg: RouterConfig): StartedServer {
 					if (!acquireTurn()) {
 						return wireErrorResponse({ status: 429, code: "too_many_requests", message: "too many concurrent turns" });
 					}
-					return await handleChatCompletions(req);
+					return await handleTurn(req, CHAT_WIRE);
+				}
+				if (req.method === "POST" && url.pathname === "/v1/responses") {
+					// The Responses API wire (Codex CLI). Same turn, different rendering.
+					if (!acquireTurn()) {
+						return wireErrorResponse({ status: 429, code: "too_many_requests", message: "too many concurrent turns" });
+					}
+					return await handleTurn(req, RESPONSES_WIRE);
 				}
 				if (req.method === "GET" && url.pathname === "/v1/models") {
 					return json(renderModelList(cfg, ledger.blendedRate(cfg.ledger.blendWindowDays)));

package/src/util/sse.ts

@@ -4,7 +4,7 @@
  * frame is emitted per token on the hot path.
  */
 
-const encoder = new TextEncoder();
+export const encoder = new TextEncoder();
 
 /** One `data:` frame carrying a JSON payload, terminated by a blank line. */
 export function sseDataFrame(value: unknown): string {