auto-model-router 0.4.8 → 0.4.10

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.10",
     "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.10",
       "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,21 +449,97 @@ 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):
 
-### Cline, Roo Code, Kilo Code
+```yaml
+# .aider.model.settings.yml
+- name: openai/auto
+  extra_params:
+    extra_headers:
+      X-Omp-Harness: aider
+```
+
+No session id or hooks.
+
+### Cline CLI
+
+```bash
+cline auth -p openai -b http://127.0.0.1:8788/v1 -k local -m auto
+cline -P openai -m auto "your task"
+```
+
+Verified live with cline 3.0 (captured request:
+`test/fixtures/harness/cline-cli.json`). The CLI sends native tool calls
+(`read_files`, `search_codebase`, `run_commands`, `fetch_web_content`, …),
+all in `digest.toolAliases`, and no custom headers, so its rows carry no
+harness id. No session id or hooks.
+
+### Kilo Code CLI
+
+Kilo's CLI is built on OpenCode, so its config is OpenCode's with a different
+file name:
+
+```json
+// kilo.json in the project (or ~/.config/kilo/kilo.json)
+{
+  "provider": {
+    "auto-model-router": {
+      "npm": "@ai-sdk/openai-compatible",
+      "name": "auto-model-router",
+      "options": { "baseURL": "http://127.0.0.1:8788/v1", "apiKey": "local", "headers": { "X-Omp-Harness": "kilo" } },
+      "models": { "auto": { "name": "auto" }, "auto-cheap": { "name": "auto-cheap" } }
+    }
+  },
+  "model": "auto-model-router/auto"
+}
+```
+
+Verified live with kilo 7.5 (captured request:
+`test/fixtures/harness/kilo.json`); tool names match OpenCode's. The
+OpenCode plugin was not picked up from `.kilo/plugin`, `.opencode/plugin` or
+the config's `plugin` list in this test, so Kilo is config-only for now.
+
+### Roo Code (VS Code)
+
+Roo's welcome screen has *Import Settings*; a profile file skips the form:
+
+```json
+{
+  "providerProfiles": {
+    "currentApiConfigName": "auto-model-router",
+    "apiConfigs": {
+      "auto-model-router": {
+        "apiProvider": "openai",
+        "openAiBaseUrl": "http://127.0.0.1:8788/v1",
+        "openAiApiKey": "local",
+        "openAiModelId": "auto",
+        "openAiHeaders": { "X-Omp-Harness": "roo" },
+        "openAiCustomModelInfo": { "maxTokens": 8192, "contextWindow": 400000, "supportsImages": true, "supportsPromptCache": true, "inputPrice": 0, "outputPrice": 0 },
+        "id": "amr-0001"
+      }
+    }
+  }
+}
+```
+
+Verified live with Roo Code 3.54 (captured request:
+`test/fixtures/harness/roo.json`, including a tool round trip): native tool
+calls (`read_file`, `search_files`, `list_files`, `apply_diff`, …), all in
+`digest.toolAliases`, and the harness header through `openAiHeaders`. Two
+cautions: 3.54 announces itself as the last Roo Code release, and its
+Architect mode loops on a model that never calls `attempt_completion`, so
+start in Code mode or pin a stronger profile (`auto-max`) for it. No session
+id or hooks: the digest applies only through summarising compaction.
+
+### Cline (VS Code)
 
 Choose the *OpenAI Compatible* provider in the extension's settings, set the
 base URL to `http://127.0.0.1:8788/v1`, any API key, and the model id `auto`
-(or `auto-cheap` / `auto-max`). Where the extension offers custom headers,
-add `X-Omp-Harness` with the harness name. Their tool names
-(`read_file`, `search_files`, `execute_command`, `list_files`) are already
-in `digest.toolAliases`, but with no hook to intercept tool results the
-digest applies only through summarising compaction
-(`compaction.digestToolResults`), which runs inside the router.
+(or `auto-cheap` / `auto-max`); add `X-Omp-Harness` under custom headers if
+offered. Not verified live here (the CLI above was); its tool names are in
+`digest.toolAliases`, and the digest applies only through summarising
+compaction.
 
 ### OpenCode
 
@@ -1101,6 +1179,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,9 +1205,12 @@ 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 |
+| Cline CLI | config only | no | no | no | no | no | compaction only | no | no |
+| Kilo Code CLI | config only | yes | no | no | no | no | compaction only | no | no |
+| Roo Code (VS Code) | config only | yes | no | no | no | no | compaction only | no | no |
+| Cline (VS Code) | config only, unverified | 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 |
 | Claude Code | needs an Anthropic Messages wire module | — | — | — | — | — | — | — | — |
 

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.10",
   "private": false,
   "description": "Local cost/complexity-aware model router for Oh My Pi, backed by OpenRouter",
   "type": "module",

package/src/config/defaults.ts

@@ -322,6 +322,11 @@ export const DEFAULT_CONFIG: RouterConfig = {
 			shell: "bash",
 			web_extract: "web_fetch",
 			fetch_url: "web_fetch",
+			// Cline CLI 3.x
+			read_files: "read",
+			search_codebase: "grep",
+			run_commands: "bash",
+			fetch_web_content: "web_fetch",
 		},
 	},
 	report: {

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" };
 }