auto-model-router 0.4.8 → 0.4.9

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

package/README.md

@@ -430,12 +430,14 @@ wire_api = "responses"
 http_headers = { "X-Omp-Harness" = "codex" }
 ```
 
-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`.
+Verified live with codex 0.153, text and tool-call turns: 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.
+Codex's thread id (sent in the body) becomes the session id and its agent
+name marks subagents, so per-session reports, feedback over the HTTP API and
+the subagent profile work without a plugin. No hooks: there is no toast,
+digest or `/router`.
 
 ### Aider
 
@@ -447,10 +449,18 @@ aider --model openai/auto
 
 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.
+classifies on its text alone. It sends no custom headers by default; a model
+settings file in the project adds the harness id (verified live):
+
+```yaml
+# .aider.model.settings.yml
+- name: openai/auto
+  extra_params:
+    extra_headers:
+      X-Omp-Harness: aider
+```
+
+No session id or hooks.
 
 ### Cline, Roo Code, Kilo Code
 
@@ -1101,6 +1111,25 @@ there); and the switch happens at prompt boundaries, never mid-turn.
 
 ## Multiple coding harnesses, one router
 
+**One router process for everything.** omp's embed extension binds a private
+router on an ephemeral port per session by default, while Hermes, Codex,
+OpenCode and Aider talk to a standalone router on port 8788. Those are two
+processes over two homes, and per-process state (pins, the digest re-run
+memory) and reports stay apart. To share one router:
+
+1. Run it once, before the harnesses start: `auto-model-router serve --port 8788`
+   (against the default home, `~/.auto-model-router`).
+2. Set `AUTO_MODEL_ROUTER_PORT=8788` in omp's environment. The embed then
+   attaches to the router already answering on that port instead of binding
+   its own (it still binds 8788 itself if nothing is there, which the others
+   then reuse).
+3. Point Hermes, Codex, OpenCode and Aider at `http://127.0.0.1:8788/v1` as
+   in their recipes. Hermes's provider plugin only spawns a router when
+   nothing listens on 8788, so it joins the shared one too.
+
+Each harness keeps its own `X-Omp-Harness` id, so budgets and reports stay
+per harness while the ledger, catalog and conversation state are shared.
+
 What each harness gets today. "Config only" means the OpenAI-compatible wire
 plus a harness header; the rest needs the harness's own hook API.
 
@@ -1108,7 +1137,7 @@ 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 | Responses API wire | yes | no | no | no | no | compaction only | no | no |
+| Codex CLI | Responses API wire | yes | yes (from body) | yes (from body) | 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 + plugin | yes | yes (plugin) | yes (plugin) | yes (plugin) | no | yes (plugin) | no | no |

package/hermes-plugin/native/selftest.py

@@ -0,0 +1,103 @@
+"""Self-test for the Hermes native plugin's pure functions.
+
+Run by test/hermes-plugin.test.ts when a Python interpreter is on PATH (the
+Bun suite cannot import Python), and directly:
+
+    python hermes-plugin/native/selftest.py
+
+Exercises identity headers, the digest gate and replacement, and the /router
+command rendering against fake transports. Exits non-zero on the first
+failure with the assertion that failed.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import json
+import os
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+spec = importlib.util.spec_from_file_location("amr_native", os.path.join(HERE, "__init__.py"))
+m = importlib.util.module_from_spec(spec)
+assert spec.loader is not None
+spec.loader.exec_module(m)
+
+
+def test_identity_headers() -> None:
+    m.on_pre_llm_call(session_id="s1", parent_session_id="")
+    m.on_pre_llm_call(session_id="s2", parent_session_id="s1")
+    r = m.on_llm_request(request={"model": "auto", "extra_headers": {"A": "b"}}, provider="auto-model-router", session_id="s2")
+    assert r["request"]["extra_headers"] == {"A": "b", "X-Omp-Harness": m.HARNESS_ID, "X-Omp-Session": "s2", "X-Omp-Subagent": "1"}, r
+    main = m.on_llm_request(request={"model": "auto"}, provider="auto-model-router", session_id="s1")
+    assert "X-Omp-Subagent" not in main["request"]["extra_headers"], main
+    assert m.on_llm_request(request={}, provider="anthropic", session_id="s1") is None
+    assert m._CURRENT["session_id"] == "s1"
+
+
+def test_digest() -> None:
+    m.POLICY.value = {"enabled": True, "minBytes": 10, "maxBytes": 100000, "tools": ["read", "grep", "bash"], "toolAliases": {"read_file": "read", "terminal": "bash"}, "fromTier": "moderate"}
+    m.POLICY._at = 10**12
+    calls = []
+
+    def fake_post(path, payload, timeout=0):
+        calls.append((path, payload["toolName"], len(payload["content"])))
+        return {"digested": True, "text": "[digest] short"}
+
+    big = json.dumps({"content": "x" * 500, "path": "a.ts"})
+    out = m.maybe_digest(big, "read_file", {"path": "a.ts"}, "s1", post=fake_post)
+    assert json.loads(out)["content"] == "[digest] short", out
+    assert json.loads(out)["path"] == "a.ts"
+    assert calls == [("/v1/router/digest", "read_file", 500)], calls
+    err = json.dumps({"error": "nope", "content": "x" * 500})
+    assert m.maybe_digest(err, "read_file", {}, "s1", post=fake_post) == err
+    assert m.maybe_digest(json.dumps({"content": "x" * 500}), "write_file", {}, "s1", post=fake_post).startswith('{"content": "xxx')
+    plain = "plain text " * 100
+    assert m.maybe_digest(plain, "read_file", {}, "s1", post=fake_post) == plain
+    assert len(calls) == 1
+    assert m.canonical_tool(m.POLICY.value, "TERMINAL") == "bash"
+    assert m.largest_string_field({"a": "x" * 90, "b": "y" * 5}) == "a"
+    assert m.largest_string_field({"a": "x" * 50, "b": "y" * 50}) is None
+
+
+def test_router_command() -> None:
+    def fake_get(path, timeout=5.0, text=False):
+        if path.startswith("/v1/router/report"):
+            return "REPORT " + path
+        if path.startswith("/v1/router/summary"):
+            return "SUMMARY " + path
+        if path.startswith("/health"):
+            return {"status": "ok", "apiKeyConfigured": True, "apiKeySource": "env", "catalog": {"models": 3}, "ollama": None, "softFailures": {"spikes": [{"slug": "a/b", "recentRate": 0.5, "recentDispatches": 8, "baselineRate": 0.05}]}}
+        if path.startswith("/v1/router/decisions"):
+            return {"entries": [{"slug": "a/b", "tier": "hard", "classificationSource": "heuristic", "confidence": 0.7, "reportedUsd": 0.0000097, "usage": {"promptTokens": 100, "cachedTokens": 50}, "latencyMs": 900, "reasons": ["r1"]}]}
+        return {}
+
+    def fake_post(path, payload, timeout=5.0):
+        if path == "/v1/router/feedback":
+            return {"slug": "a/b", "tier": "hard"}
+        return {"override": {"slug": payload.get("slug"), "tier": payload.get("tier"), "turnsLeft": payload.get("turns")}}
+
+    assert m.router_command("report 30 --all", get=fake_get, post=fake_post) == "REPORT /v1/router/report?days=30&format=text"
+    assert m.router_command("report", get=fake_get, post=fake_post).endswith(f"days=7&format=text&harness={m.HARNESS_ID}")
+    assert m.router_command("summary", get=fake_get, post=fake_post).startswith("SUMMARY /v1/router/summary?format=text&harness=")
+    status = m.router_command("status", get=fake_get, post=fake_post)
+    assert "soft failures SPIKING (1)" in status and "a/b: 50% of 8" in status, status
+    why = m.router_command("why", get=fake_get, post=fake_post)
+    assert "last turn: a/b [hard]" in why and "$0.00001" in why and "cache hit 50%" in why, why
+    assert m.router_command("good nice", get=fake_get, post=fake_post) == "recorded good for a/b [hard]"
+    assert m.router_command("pin a/b", get=fake_get, post=fake_post) == "pin: a/b"
+    assert m.router_command("tier hard 5", get=fake_get, post=fake_post) == "tier: hard for 5 turns"
+    assert m.router_command("tier off", get=fake_get, post=fake_post) == "tier: cleared"
+    assert m.router_command("bogus", get=fake_get, post=fake_post) == m.USAGE
+
+    def down(path, timeout=5.0, text=False):
+        raise OSError("connection refused")
+
+    assert m.router_command("status", get=down, post=fake_post).startswith("router unreachable at")
+
+
+if __name__ == "__main__":
+    for name, fn in [(n, f) for n, f in globals().items() if n.startswith("test_")]:
+        fn()
+        print(f"ok {name}")
+    sys.exit(0)

package/package.json

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

package/src/cost/ledger.ts

@@ -376,6 +376,9 @@ export function createLedger(db: Database, cfg: RouterConfig): Ledger {
 	const ratioStmt = db.query("SELECT est_bytes, actual_tokens, samples FROM token_calibration WHERE tokenizer = ?");
 	const recentStmt = db.query("SELECT * FROM ledger ORDER BY created_at_ms DESC LIMIT ?");
 	const pruneStmt = db.query("DELETE FROM ledger WHERE created_at_ms < ?");
+	// Ollama meter samples (one per usage poll) only matter for the current
+	// billing cycle's calibration; they age out with the ledger rows.
+	const pruneMeterStmt = db.query("DELETE FROM ollama_meter_samples WHERE at_ms < ?");
 	const wasteStmt = db.query("UPDATE ledger SET wasted = 1 WHERE id = ?");
 	const providerSpendStmt = db.query(
 		"SELECT COALESCE(SUM(COALESCE(reported_usd, predicted_usd)), 0) AS total FROM ledger WHERE created_at_ms >= ? AND COALESCE(served_slug, slug) LIKE ?",
@@ -627,7 +630,9 @@ export function createLedger(db: Database, cfg: RouterConfig): Ledger {
 		},
 		prune(retentionDays: number, nowMs = Date.now()): number {
 			if (retentionDays <= 0) return 0;
-			return pruneStmt.run(nowMs - retentionDays * DAY_MS).changes;
+			const cutoff = nowMs - retentionDays * DAY_MS;
+			pruneMeterStmt.run(cutoff);
+			return pruneStmt.run(cutoff).changes;
 		},
 		markWasted(id: string): void {
 			wasteStmt.run(id);

package/src/cost/summary.ts

@@ -28,6 +28,7 @@ export interface SummaryWindow {
 	modelSwitches: number;
 	digests: number;
 	digestSpendUsd: number;
+	digestReruns: number;
 	subagentSpendUsd: number;
 }
 
@@ -81,6 +82,7 @@ function windowOf(r: UsageReport): SummaryWindow {
 		modelSwitches: t.modelSwitches,
 		digests: t.digests,
 		digestSpendUsd: t.digestSpendUsd,
+		digestReruns: t.digestReruns,
 		subagentSpendUsd: t.subagentSpendUsd,
 	};
 }
@@ -172,7 +174,7 @@ export function renderDailySummary(s: DailySummary): string {
 			out.push(b.savedShare >= 0 ? `saved ${pct(b.savedShare)} vs ${b.slug} (${usd(b.usd)} at list)` : `cost ${pct(-b.savedShare)} MORE than ${b.slug} (${usd(b.usd)} at list)`);
 		}
 		const extras: string[] = [];
-		if (c.digests > 0) extras.push(`${c.digests} digests for ${usd(c.digestSpendUsd)}`);
+		if (c.digests > 0) extras.push(`${c.digests} digests for ${usd(c.digestSpendUsd)} (re-run rate ${pct(c.digestReruns / c.digests)})`);
 		if (c.subagentSpendUsd > 0) extras.push(`subagents ${usd(c.subagentSpendUsd)}`);
 		if (extras.length > 0) out.push(extras.join(" · "));
 	}

package/src/wire/openai/responses.ts

@@ -123,8 +123,35 @@ export function responsesToChatBody(body: unknown): Rec {
 	return out;
 }
 
+/**
+ * Codex carries its identity in the body, not in headers: the thread id under
+ * `client_metadata` (also the `prompt_cache_key`), and the agent name inside
+ * the JSON-encoded `x-codex-turn-metadata` (`/root` is the main agent). When
+ * the caller sent no X-Omp-Session / X-Omp-Subagent header, they are derived
+ * from those, so Codex gets per-session reports, feedback and the subagent
+ * profile without a plugin.
+ */
+export function identityHeadersFromBody(body: unknown, headers: Headers): Headers {
+	if (!isRec(body)) return headers;
+	const h = new Headers(headers);
+	const cm = isRec(body.client_metadata) ? body.client_metadata : {};
+	if ((h.get("x-omp-session") ?? "").trim() === "") {
+		const id = [cm.thread_id, cm.session_id, body.prompt_cache_key].find((v): v is string => typeof v === "string" && v !== "");
+		if (id !== undefined) h.set("x-omp-session", id);
+	}
+	if ((h.get("x-omp-subagent") ?? "").trim() === "" && typeof cm["x-codex-turn-metadata"] === "string") {
+		try {
+			const meta: unknown = JSON.parse(cm["x-codex-turn-metadata"]);
+			if (isRec(meta) && typeof meta.agent_name === "string" && meta.agent_name !== "" && meta.agent_name !== "/root") h.set("x-omp-subagent", "1");
+		} catch {
+			// Not JSON: no subagent signal.
+		}
+	}
+	return h;
+}
+
 export function parseResponsesRequest(body: unknown, headers: Headers): NormRequest {
-	const norm = parseChatRequest(responsesToChatBody(body), headers);
+	const norm = parseChatRequest(responsesToChatBody(body), identityHeadersFromBody(body, headers));
 	return { ...norm, protocol: "openai-responses" };
 }
 

package/test/harness-requests.test.ts

@@ -138,6 +138,9 @@ describe("captured harness requests", () => {
 		expect(req.harnessId).toBe("codex");
 		expect(req.requestedModel).toBe("auto");
 		expect(req.stream).toBe(true);
+		// The thread id in the body becomes the session id; the root agent is not a subagent.
+		expect(req.ompSessionId).toBe((f.body.client_metadata as { thread_id: string }).thread_id);
+		expect(req.isSubagent).toBe(false);
 		// instructions became the system message; the input items follow in order.
 		expect(req.messages.map((m) => m.role)).toEqual(["system", "developer", "user", "user"]);
 		expect(req.messages[0]?.text).toContain("coding agent running in the Codex CLI");

package/test/hermes-plugin.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, test } from "bun:test";
+
+/**
+ * The Hermes native plugin is Python, which this suite cannot import. Its
+ * pure functions (identity headers, digest gate and replacement, /router
+ * rendering) are exercised by hermes-plugin/native/selftest.py; this test
+ * runs it when a Python interpreter is on PATH and is skipped otherwise, so
+ * a machine without Python still passes the suite but a machine with one
+ * catches a regression.
+ */
+
+const python = Bun.which("python") ?? Bun.which("python3");
+const ROOT = `${import.meta.dir}/..`;
+
+describe("hermes native plugin", () => {
+	(python === null ? test.skip : test)("the Python self-test passes", () => {
+		const run = Bun.spawnSync([python!, "hermes-plugin/native/selftest.py"], { cwd: ROOT, stdout: "pipe", stderr: "pipe" });
+		const out = `${run.stdout.toString()}\n${run.stderr.toString()}`;
+		expect(out).toContain("ok test_identity_headers");
+		expect(out).toContain("ok test_digest");
+		expect(out).toContain("ok test_router_command");
+		expect(run.exitCode).toBe(0);
+	});
+
+	test("the plugin files parse as Python and declare the standalone kind", async () => {
+		const manifest = await Bun.file(`${ROOT}/hermes-plugin/native/plugin.yaml`).text();
+		expect(manifest).toContain("kind: standalone");
+		const src = await Bun.file(`${ROOT}/hermes-plugin/native/__init__.py`).text();
+		expect(src).toContain("def register(ctx");
+		for (const hook of ['register_hook("pre_llm_call"', 'register_middleware("llm_request"', 'register_middleware("tool_execution"', 'register_command("router"']) expect(src).toContain(hook);
+	});
+});

package/test/summary.test.ts

@@ -95,7 +95,7 @@ describe("buildDailySummary", () => {
 			// Tiny seeded turns cost more than Opus would have at list price: the honest branch renders.
 			expect(text).toContain("cost 574% MORE than anthropic/claude-opus-5 ($0.079 at list)");
 			expect(renderDailySummary({ ...s, baseline: { slug: "anthropic/claude-opus-5", usd: 2.5, savedShare: 0.7876 } })).toContain("saved 79% vs anthropic/claude-opus-5 ($2.50 at list)");
-			expect(text).toContain("1 digests for $0.001");
+			expect(text).toContain("1 digests for $0.001 (re-run rate 0%)");
 			expect(text).toContain("soft failures SPIKING (1):\n  vendor/big: 50% of 8 failed in the last 1h (7d baseline 3% of 90)");
 			expect(text).toContain("ollama: pro plan $25.20 of $60 · ~23 days of credits left");
 		} finally {

package/test/tokens.test.ts

@@ -292,7 +292,9 @@ describe("ledger.prune and markWasted", () => {
 			for (let i = 0; i < 5; i++) ledger.record(entry({ createdAtMs: now - i * 100 * DAY }));
 			expect(ledger.prune?.(0, now)).toBe(0);
 			expect(ledger.recentEntries(10)).toHaveLength(5);
+			db.run("INSERT INTO ollama_meter_samples (at_ms, meter_usd, ledger_usd) VALUES (?, 1, 1), (?, 2, 2)", [now - 400 * DAY, now - DAY]);
 			expect(ledger.prune?.(365, now)).toBe(1); // only the 400-day-old row
+			expect((db.query("SELECT COUNT(*) AS n FROM ollama_meter_samples").get() as { n: number }).n).toBe(1);
 			expect(ledger.recentEntries(10)).toHaveLength(4);
 			expect(ledger.prune?.(150, now)).toBe(2); // 200 and 300 days old
 			const left = ledger.recentEntries(10);

package/test/wire-responses.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test } from "bun:test";
 
 import { WireErrorException } from "../src/wire/openai/errors.ts";
-import { createResponsesBufferedSink, createResponsesStreamingSink, parseResponsesRequest, responsesToChatBody } from "../src/wire/openai/responses.ts";
+import { createResponsesBufferedSink, createResponsesStreamingSink, identityHeadersFromBody, parseResponsesRequest, responsesToChatBody } from "../src/wire/openai/responses.ts";
 import type { StreamEvent, TurnSummary, UpstreamChunk } from "../src/wire/types.ts";
 
 /**
@@ -67,6 +67,20 @@ describe("responsesToChatBody", () => {
 		expect(() => responsesToChatBody({ model: "auto", input: [] })).toThrow(WireErrorException);
 	});
 
+	test("Codex identity is read from the body when the headers carry none", () => {
+		const meta = (agent: string) => JSON.stringify({ session_id: "t1", thread_id: "t1", agent_name: agent, turn_id: "u1" });
+		const body = { model: "auto", input: "x", prompt_cache_key: "t1", client_metadata: { thread_id: "t1", session_id: "t1", "x-codex-turn-metadata": meta("/root") } };
+		const main = parseResponsesRequest(body, HEADERS);
+		expect(main.ompSessionId).toBe("t1");
+		expect(main.isSubagent).toBe(false);
+		const sub = parseResponsesRequest({ ...body, client_metadata: { ...body.client_metadata, "x-codex-turn-metadata": meta("/root/explorer") } }, HEADERS);
+		expect(sub.isSubagent).toBe(true);
+		// Explicit headers win; a body without metadata adds nothing.
+		expect(identityHeadersFromBody(body, new Headers({ "X-Omp-Session": "mine" })).get("x-omp-session")).toBe("mine");
+		expect(identityHeadersFromBody({ model: "auto", input: "x" }, HEADERS).get("x-omp-session")).toBeNull();
+		expect(identityHeadersFromBody({ model: "auto", input: "x", client_metadata: { "x-codex-turn-metadata": "not json" } }, HEADERS).get("x-omp-subagent")).toBeNull();
+	});
+
 	test("parseResponsesRequest yields a routed request tagged with the wire", () => {
 		const req = parseResponsesRequest({ model: "auto-model-router/auto-cheap", input: "hello", stream: false }, HEADERS);
 		expect(req.protocol).toBe("openai-responses");