auto-model-router 0.4.5 → 0.4.6

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

package/README.md

@@ -371,6 +371,107 @@ providers:
     default_model: auto
 ```
 
+**Native features (Hermes plugin API).** The provider plugin above only
+registers the model provider; Hermes never calls `register(ctx)` on
+provider plugins, so the features that need hooks live in a second,
+standalone plugin:
+
+```bash
+cp -r hermes-plugin/native "$HERMES_HOME/plugins/auto-model-router"
+hermes plugins enable auto-model-router
+```
+
+It adds, through Hermes middleware and hooks:
+
+- **Session identity** — `X-Omp-Session` and `X-Omp-Subagent` on every router
+  request (a session that reported a parent session is a subagent), so
+  per-session reports, `/router why`, feedback and the router's
+  `server.subagentProfile` work as in omp. `X-Omp-Harness` is `hermes` (or
+  `OMP_HARNESS_ID`).
+- **Tool-result digest** — large `read_file`, `search_files` and `terminal`
+  results go to `/v1/router/digest` and the model gets the digest (see
+  [`digest`](#digest--cheap-model-digest-of-large-tool-results); Hermes tool
+  names are mapped by `digest.toolAliases`). Off unless `digest.enabled`.
+- **`/router`** — `report [days] [--all]`, `summary`, `status`, `why`,
+  `good`/`bad [note]`, `pin <model|off>`, `tier <tier|off> [turns]`, as text.
+
+Point Hermes's side jobs at the cheap profile so they cost what omp's do:
+
+```yaml
+# $HERMES_HOME/config.yaml
+auxiliary:
+  vision:      { provider: auto-model-router, model: auto-cheap }
+  compression: { provider: auto-model-router, model: auto-cheap }
+```
+
+Not available in Hermes: a per-turn routing toast (its plugin API has no
+user-visible notice channel; use `/router why`), the automatic daily summary
+(`/router summary` on demand), and the harness-side model switch.
+
+### 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:
+
+```toml
+# ~/.codex/config.toml
+model = "auto"
+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"
+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`.
+
+### Aider
+
+```bash
+export OPENAI_API_BASE=http://127.0.0.1:8788/v1
+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.
+
+### Cline, Roo Code, Kilo 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.
+
+### OpenCode
+
+```json
+// ~/.config/opencode/opencode.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": "opencode" } },
+      "models": { "auto": { "name": "auto" }, "auto-cheap": { "name": "auto-cheap" }, "auto-max": { "name": "auto-max" } }
+    }
+  },
+  "model": "auto-model-router/auto"
+}
+```
+
+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.
+
 ### The OpenRouter key
 
 **omp does not need to be authenticated to OpenRouter.** On a routed turn omp
@@ -818,6 +919,7 @@ is a ledger row (`requestedModel` `digest`) and the report totals them.
 | `enabled` | `false` | Master switch; the extension polls it every minute. |
 | `minBytes` / `maxBytes` | `12000` / `400000` | Result size window that gets digested. |
 | `tools` | `read, grep, glob, bash, web_fetch, webfetch, ls, find` | Eligible tool names (lower-case). |
+| `toolAliases` | Hermes, Cline/Roo/Kilo, Codex and OpenCode spellings (`read_file` → `read`, `search_files` → `grep`, `terminal`/`execute_command`/`shell` → `bash`, …) | Harness tool names mapped onto the canonical `tools` list, so one list serves every harness. |
 | `fromTier` | `moderate` | Digest only when the session's current model is at or above this tier. |
 | `tier` / `model` | `simple` / unset | Where the digest model is picked from, or a pinned slug. |
 | `maxOutputTokens` | `700` | Digest length cap. |
@@ -968,6 +1070,19 @@ there); and the switch happens at prompt boundaries, never mid-turn.
 
 ## Multiple coding harnesses, one router
 
+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.
+
+| Harness | Wire | Harness id | Session id | Subagent flag | Toast | `/router` | Digest | Daily summary | Model switch |
+| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
+| 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 |
+| 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 |
+| Claude Code | needs an Anthropic Messages wire module | — | — | — | — | — | — | — | — |
+
 A single embedded router can serve several omp sessions without them stepping
 on each other:
 

package/hermes-plugin/__init__.py

@@ -105,5 +105,8 @@ profile = ProviderProfile(
     fallback_models=("auto", "auto-cheap", "auto-max"),
     display_name="auto-model-router",
     description="Per-turn cost/complexity-aware model routing",
+    # The harness id the router records on every row (per-harness budgets and
+    # reports). The native plugin adds the per-session headers on top.
+    default_headers={"X-Omp-Harness": os.environ.get("OMP_HARNESS_ID", "hermes")},
 )
 register_provider(profile)

package/hermes-plugin/native/__init__.py

@@ -0,0 +1,348 @@
+"""Hermes standalone plugin: auto-model-router native features.
+
+Companion to the ``model-providers/auto-model-router`` provider plugin (which
+spawns the router and registers it as a provider). Hermes routes provider
+plugins through its own discovery and never calls ``register(ctx)`` on them,
+so the features that need the plugin API live here:
+
+* **Session identity** — ``llm_request`` middleware adds the ``X-Omp-Session``,
+  ``X-Omp-Harness`` and ``X-Omp-Subagent`` headers to every router request,
+  so per-session reports, ``/router why``, feedback and the router's subagent
+  profile work the way they do in omp. A session is a subagent when
+  ``pre_llm_call`` reported a parent session for it.
+* **Tool-result digest** — ``tool_execution`` middleware sends a large
+  ``read_file`` / ``search_files`` / ``terminal`` result to the router's
+  ``/v1/router/digest`` and hands the model the digest instead. The router
+  decides (policy, session tier, cost guard); this plugin only ships text that
+  passes the cheap client-side checks. Off unless ``digest.enabled`` is set in
+  the router config.
+* **``/router``** — report, summary, status, why, good, bad, pin, tier, as
+  text, over the same HTTP endpoints omp's ``/router`` uses.
+
+Install:
+
+    mkdir -p "$HERMES_HOME/plugins"
+    cp -r hermes-plugin/native "$HERMES_HOME/plugins/auto-model-router"
+    hermes plugins enable auto-model-router
+
+The router URL is ``http://127.0.0.1:$AUTO_MODEL_ROUTER_PORT`` (default 8788),
+the port the provider plugin spawns on.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import threading
+import time
+import urllib.error
+import urllib.request
+from typing import Any, Callable, Dict, Optional
+
+logger = logging.getLogger(__name__)
+
+PORT = int(os.environ.get("AUTO_MODEL_ROUTER_PORT", "8788"))
+BASE_URL = f"http://127.0.0.1:{PORT}"
+# The harness id the router records on every row. Override to run several
+# Hermes profiles against one router with separate budgets and reports.
+HARNESS_ID = os.environ.get("OMP_HARNESS_ID", "hermes")
+PROVIDER_NAME = "auto-model-router"
+POLICY_TTL_S = 60.0
+DIGEST_TIMEOUT_S = 30.0
+# Hermes wraps every tool result in a JSON object; the digest replaces the
+# largest string field (``content`` for read_file, ``output`` for terminal,
+# the match text for search_files).
+MIN_FIELD_SHARE = 0.8
+
+
+# ---------------------------------------------------------------------------
+# HTTP helpers (stdlib only; plugins should not add dependencies)
+# ---------------------------------------------------------------------------
+
+
+def _get(path: str, timeout: float = 5.0, text: bool = False) -> Any:
+    req = urllib.request.Request(BASE_URL + path, headers={"Accept": "text/plain" if text else "application/json"})
+    with urllib.request.urlopen(req, timeout=timeout) as resp:
+        body = resp.read().decode("utf-8")
+        return body if text else json.loads(body)
+
+
+def _post(path: str, payload: Dict[str, Any], timeout: float = 5.0) -> Any:
+    data = json.dumps(payload).encode("utf-8")
+    req = urllib.request.Request(BASE_URL + path, data=data, headers={"Content-Type": "application/json"}, method="POST")
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            return json.loads(resp.read().decode("utf-8"))
+    except urllib.error.HTTPError as exc:
+        try:
+            err = json.loads(exc.read().decode("utf-8"))
+            message = (err.get("error") or {}).get("message") or str(exc)
+        except Exception:
+            message = str(exc)
+        raise RuntimeError(message) from exc
+
+
+# ---------------------------------------------------------------------------
+# Session identity
+# ---------------------------------------------------------------------------
+
+
+class _Sessions:
+    """Which sessions are subagents (they reported a parent session)."""
+
+    def __init__(self) -> None:
+        self._lock = threading.Lock()
+        self._parent: Dict[str, str] = {}
+
+    def note(self, session_id: str, parent_session_id: str) -> None:
+        if not session_id:
+            return
+        with self._lock:
+            if parent_session_id:
+                self._parent[session_id] = parent_session_id
+            else:
+                self._parent.pop(session_id, None)
+
+    def is_subagent(self, session_id: str) -> bool:
+        with self._lock:
+            return bool(session_id) and session_id in self._parent
+
+
+SESSIONS = _Sessions()
+# The session the user is driving; ``/router`` acts on it.
+_CURRENT = {"session_id": ""}
+
+
+def on_pre_llm_call(session_id: str = "", parent_session_id: str = "", **_: Any) -> None:
+    SESSIONS.note(session_id, parent_session_id)
+    if not parent_session_id and session_id:
+        _CURRENT["session_id"] = session_id
+    return None
+
+
+def identity_headers(session_id: str) -> Dict[str, str]:
+    headers = {"X-Omp-Harness": HARNESS_ID}
+    if session_id:
+        headers["X-Omp-Session"] = session_id
+    if SESSIONS.is_subagent(session_id):
+        headers["X-Omp-Subagent"] = "1"
+    return headers
+
+
+def on_llm_request(request: Dict[str, Any] = None, provider: str = "", session_id: str = "", **_: Any) -> Optional[Dict[str, Any]]:
+    """Attach the router's identity headers to requests bound for the router."""
+    if request is None or provider != PROVIDER_NAME:
+        return None
+    updated = dict(request)
+    extra = dict(updated.get("extra_headers") or {})
+    extra.update(identity_headers(session_id))
+    updated["extra_headers"] = extra
+    return {"request": updated, "source": "auto-model-router", "reason": "session identity headers"}
+
+
+# ---------------------------------------------------------------------------
+# Tool-result digest
+# ---------------------------------------------------------------------------
+
+
+class _Policy:
+    def __init__(self) -> None:
+        self._at = 0.0
+        self.value: Dict[str, Any] = {"enabled": False}
+
+    def get(self) -> Dict[str, Any]:
+        now = time.monotonic()
+        if now - self._at >= POLICY_TTL_S:
+            self._at = now
+            try:
+                p = _get("/v1/router/digest/policy", timeout=2.0)
+                self.value = p if isinstance(p, dict) else {"enabled": False}
+            except Exception:
+                self.value = {"enabled": False}
+        return self.value
+
+
+POLICY = _Policy()
+
+
+def canonical_tool(policy: Dict[str, Any], tool_name: str) -> str:
+    lower = (tool_name or "").lower()
+    aliases = policy.get("toolAliases") or {}
+    return str(aliases.get(lower, lower)).lower()
+
+
+def largest_string_field(result: Any) -> Optional[str]:
+    """The key holding most of a JSON tool result's bytes, or None."""
+    if not isinstance(result, dict):
+        return None
+    best, best_len, total = None, 0, 0
+    for k, v in result.items():
+        if isinstance(v, str):
+            n = len(v.encode("utf-8"))
+            total += n
+            if n > best_len:
+                best, best_len = k, n
+    if best is None or total == 0 or best_len < total * MIN_FIELD_SHARE:
+        return None
+    return best
+
+
+def should_send(policy: Dict[str, Any], tool_name: str, text: str) -> bool:
+    if not policy.get("enabled"):
+        return False
+    tools = [str(t).lower() for t in (policy.get("tools") or [])]
+    if canonical_tool(policy, tool_name) not in tools:
+        return False
+    n = len(text.encode("utf-8"))
+    return int(policy.get("minBytes", 12000)) <= n <= int(policy.get("maxBytes", 400000))
+
+
+def on_tool_execution(next_call: Callable[[Any], Any] = None, args: Any = None, tool_name: str = "", session_id: str = "", **_: Any) -> Any:
+    """Run the tool, then replace a large result with the router's digest."""
+    if next_call is None:
+        return None
+    result = next_call(args)
+    try:
+        return maybe_digest(result, tool_name, args if isinstance(args, dict) else {}, session_id)
+    except Exception as exc:  # never lose a tool result to the digest path
+        logger.debug("auto-model-router digest skipped: %s", exc)
+        return result
+
+
+def maybe_digest(result: Any, tool_name: str, args: Dict[str, Any], session_id: str, post: Callable[..., Any] = None) -> Any:
+    post = post or _post
+    policy = POLICY.get()
+    if not policy.get("enabled") or not isinstance(result, str):
+        return result
+    try:
+        parsed = json.loads(result)
+    except Exception:
+        return result
+    if isinstance(parsed, dict) and parsed.get("error"):
+        return result
+    field = largest_string_field(parsed)
+    text = parsed.get(field) if field else (parsed if isinstance(parsed, str) else None)
+    if not isinstance(text, str) or not should_send(policy, tool_name, text):
+        return result
+    r = post(
+        "/v1/router/digest",
+        {"ompSessionId": session_id, "harnessId": HARNESS_ID, "toolName": tool_name, "input": args, "content": text, "query": ""},
+        timeout=DIGEST_TIMEOUT_S,
+    )
+    if not isinstance(r, dict) or not r.get("digested") or not isinstance(r.get("text"), str):
+        return result
+    if field is None:
+        return r["text"]
+    parsed[field] = r["text"]
+    return json.dumps(parsed, ensure_ascii=False)
+
+
+# ---------------------------------------------------------------------------
+# /router command
+# ---------------------------------------------------------------------------
+
+USAGE = "usage: /router report [days] [--all] | summary [--all] | status | why | good [note] | bad [note] | pin <model|off> | tier <tier|off> [turns]"
+
+
+def _status_text(h: Dict[str, Any]) -> str:
+    lines = [f"auto-model-router at {BASE_URL}: {h.get('status', 'unknown')}"]
+    lines.append(f"openrouter: key {'configured (' + str(h.get('apiKeySource', '?')) + ')' if h.get('apiKeyConfigured') else 'MISSING'}")
+    c = h.get("catalog")
+    lines.append(f"catalog: {c.get('models', 0)} models" if isinstance(c, dict) else "catalog: not fetched yet")
+    o = h.get("ollama")
+    if isinstance(o, dict):
+        meter = o.get("meter") or {}
+        usage = f" · {meter.get('plan', 'plan')} ${meter.get('usedUsd', 0):.2f} of ${meter.get('creditsUsd', '?')}" if meter else ""
+        lines.append(f"ollama cloud: {o.get('models', 0)} models · {'available' if o.get('available') else 'COOLING DOWN'}{usage}")
+    else:
+        lines.append("ollama cloud: disabled")
+    sf = h.get("softFailures") or {}
+    spikes = sf.get("spikes") or []
+    if spikes:
+        lines.append(f"soft failures SPIKING ({len(spikes)}):")
+        for s in spikes:
+            lines.append(f"  {s.get('slug')}: {round(100 * s.get('recentRate', 0))}% of {s.get('recentDispatches', 0)} failed in the last hour (7d baseline {round(100 * s.get('baselineRate', 0))}%)")
+    else:
+        lines.append("soft failures: no model spiking in the last hour")
+    return "\n".join(lines)
+
+
+def _why_text(e: Dict[str, Any]) -> str:
+    usage = e.get("usage") or {}
+    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")
+    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",
+    ]
+    for r in e.get("reasons") or []:
+        lines.append(f"  - {r}")
+    return "\n".join(lines)
+
+
+def _parse_window(args: list) -> tuple:
+    days, scope = 7, HARNESS_ID
+    for a in args:
+        low = a.lower()
+        if low in ("--all", "all"):
+            scope = ""
+        elif low.rstrip("d").isdigit():
+            days = int(low.rstrip("d"))
+    return days, scope
+
+
+def router_command(raw_args: str = "", get: Callable[..., Any] = None, post: Callable[..., Any] = None) -> str:
+    get, post = get or _get, post or _post
+    parts = (raw_args or "").split()
+    verb = parts[0].lower() if parts else ""
+    rest = parts[1:]
+    session = _CURRENT["session_id"]
+    try:
+        if verb == "report":
+            days, scope = _parse_window(rest)
+            q = f"?days={days}&format=text" + (f"&harness={scope}" if scope else "")
+            return get(f"/v1/router/report{q}", text=True)
+        if verb in ("summary", "daily"):
+            _, scope = _parse_window(rest)
+            q = "?format=text" + (f"&harness={scope}" if scope else "")
+            return get(f"/v1/router/summary{q}", text=True)
+        if verb in ("status", "health"):
+            return _status_text(get("/health"))
+        if verb in ("why", "explain"):
+            body = get(f"/v1/router/decisions?limit=1&session={session}")
+            entries = body.get("entries") or []
+            return _why_text(entries[0]) if entries else "no routed turn in this session yet"
+        if verb in ("good", "bad"):
+            r = post("/v1/router/feedback", {"ompSessionId": session, "verdict": verb, "note": " ".join(rest)})
+            return f"recorded {verb} for {r.get('slug')} [{r.get('tier')}]"
+        if verb == "pin":
+            if not rest:
+                return USAGE
+            r = post("/v1/router/override", {"ompSessionId": session, "slug": None if rest[0].lower() == "off" else rest[0]})
+            o = r.get("override") or {}
+            return f"pin: {o.get('slug') or 'cleared'}"
+        if verb == "tier":
+            if not rest:
+                return USAGE
+            turns = int(rest[1]) if len(rest) > 1 and rest[1].isdigit() else 10
+            r = post("/v1/router/override", {"ompSessionId": session, "tier": None if rest[0].lower() == "off" else rest[0], "turns": turns})
+            o = r.get("override") or {}
+            left = o.get("turnsLeft")
+            return f"tier: {o.get('tier') or 'cleared'}" + (f" for {left} turns" if o.get("tier") and left else "")
+        return USAGE
+    except Exception as exc:
+        return f"router unreachable at {BASE_URL}: {exc}"
+
+
+# ---------------------------------------------------------------------------
+# registration
+# ---------------------------------------------------------------------------
+
+
+def register(ctx: Any) -> None:
+    ctx.register_hook("pre_llm_call", on_pre_llm_call)
+    ctx.register_middleware("llm_request", on_llm_request)
+    ctx.register_middleware("tool_execution", on_tool_execution)
+    ctx.register_command("router", router_command, description="auto-model-router: report, summary, status, why, feedback, pin, tier", args_hint="report|summary|status|why|good|bad|pin|tier")

package/hermes-plugin/native/plugin.yaml

@@ -0,0 +1,5 @@
+name: auto-model-router
+kind: standalone
+version: 1.0.0
+description: auto-model-router native features — session identity, tool-result digest, /router command
+author: drewappling

package/omp-extension/digest-logic.ts

@@ -8,10 +8,12 @@ export interface DigestPolicy {
 	minBytes: number;
 	maxBytes: number;
 	tools: string[];
+	/** Harness tool name → canonical name in `tools`. */
+	toolAliases: Record<string, string>;
 	fromTier: string;
 }
 
-export const DISABLED_POLICY: DigestPolicy = { enabled: false, minBytes: 0, maxBytes: 0, tools: [], fromTier: "hard" };
+export const DISABLED_POLICY: DigestPolicy = { enabled: false, minBytes: 0, maxBytes: 0, tools: [], toolAliases: {}, fromTier: "hard" };
 
 /** The text of a tool result's content parts; images are left alone (and block digesting). */
 export function textOf(content: ReadonlyArray<{ type: string; text?: string }>): { text: string; hasImage: boolean } {
@@ -27,7 +29,8 @@ export function textOf(content: ReadonlyArray<{ type: string; text?: string }>):
 /** Client-side gate: cheap checks before anything is sent to the router. */
 export function shouldSend(policy: DigestPolicy, toolName: string, isError: boolean, text: string, hasImage: boolean): boolean {
 	if (!policy.enabled || isError || hasImage) return false;
-	if (!policy.tools.includes(toolName.toLowerCase())) return false;
+	const lower = toolName.toLowerCase();
+	if (!policy.tools.includes(policy.toolAliases[lower] ?? lower)) return false;
 	const bytes = Buffer.byteLength(text);
 	return bytes >= policy.minBytes && bytes <= policy.maxBytes;
 }
@@ -42,6 +45,10 @@ export function parsePolicy(json: unknown): DigestPolicy {
 		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").map(([k, v]) => [k.toLowerCase(), v.toLowerCase()]))
+				: {},
 		fromTier: typeof p.fromTier === "string" ? p.fromTier : "hard",
 	};
 }

package/package.json

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

package/src/config/defaults.ts

@@ -309,6 +309,20 @@ export const DEFAULT_CONFIG: RouterConfig = {
 		maxOutputTokens: 700,
 		maxCostUsd: 0.02,
 		timeoutMs: 25_000,
+		// Hermes, Cline/Roo/Kilo, Codex and OpenCode spellings of the same tools.
+		toolAliases: {
+			read_file: "read",
+			search_files: "grep",
+			list_files: "ls",
+			list_dir: "ls",
+			list: "ls",
+			terminal: "bash",
+			execute_command: "bash",
+			execute_code: "bash",
+			shell: "bash",
+			web_extract: "web_fetch",
+			fetch_url: "web_fetch",
+		},
 	},
 	report: {
 		// The frontier pair most omp users would otherwise run on.

package/src/config/schema.ts

@@ -296,6 +296,7 @@ export const configInputSchema = z.strictObject({
 			maxOutputTokens: z.number().int().positive().optional(),
 			maxCostUsd: z.number().nonnegative().optional(),
 			timeoutMs: z.number().int().positive().optional(),
+			toolAliases: z.record(z.string(), z.string()).optional(),
 		})
 		.optional(),
 	ledger: ledger.optional(),

package/src/config/types.ts

@@ -587,6 +587,14 @@ export interface DigestConfig {
 	/** Skip when the digest itself would cost more than this, USD. */
 	maxCostUsd: number;
 	timeoutMs: number;
+	/**
+	 * Harness tool names → the canonical names `tools` lists (read, grep,
+	 * glob, bash, ls, web_fetch, …). Hermes calls its reader `read_file`,
+	 * Cline `execute_command`, OpenCode `webfetch`; the alias table lets one
+	 * `tools` list serve every harness. Lower-case keys; unknown names pass
+	 * through unchanged.
+	 */
+	toolAliases: Record<string, string>;
 }
 
 /** Usage-report options. */

package/src/server/digest.ts

@@ -67,10 +67,16 @@ const DIGEST_SYSTEM = `You condense tool output for a coding agent that is mid-t
 const tierIdx = (t: string): number => TIER_ORDER.indexOf(t as Tier);
 
 /** Whether a session's current model is expensive enough for a digest to pay off. */
+/** The canonical tool name a harness-specific one maps to (`digest.toolAliases`); lower-cased. */
+export function canonicalTool(cfg: Pick<DigestConfig, "toolAliases">, toolName: string): string {
+	const lower = toolName.toLowerCase();
+	return cfg.toolAliases[lower] ?? lower;
+}
+
 export function digestApplies(cfg: DigestConfig, toolName: string, bytes: number, isError: boolean, currentTier: string | null): { ok: true } | { ok: false; reason: string } {
 	if (!cfg.enabled) return { ok: false, reason: "digest disabled" };
 	if (isError) return { ok: false, reason: "error results are never digested" };
-	if (!cfg.tools.includes(toolName.toLowerCase())) return { ok: false, reason: `tool ${toolName} not in digest.tools` };
+	if (!cfg.tools.includes(canonicalTool(cfg, toolName))) return { ok: false, reason: `tool ${toolName} not in digest.tools` };
 	if (bytes < cfg.minBytes) return { ok: false, reason: `${bytes} bytes < minBytes ${cfg.minBytes}` };
 	if (bytes > cfg.maxBytes) return { ok: false, reason: `${bytes} bytes > maxBytes ${cfg.maxBytes}` };
 	if (currentTier === null) return { ok: false, reason: "no routed turn in this session yet" };

package/src/server/http.ts

@@ -9,8 +9,8 @@ import { createSessionOverrides } from "./overrides.ts";
 import { createDigester } from "./digest.ts";
 import { advise } from "./advise.ts";
 import { TIER_ORDER, type Tier } from "../router/types.ts";
-import { baselinePrices, buildUsageReport } from "../cost/report.ts";
-import { buildDailySummary, createKv, markSummaryShown, summaryDue, summaryHasNews, type SummaryOllama } from "../cost/summary.ts";
+import { baselinePrices, buildUsageReport, renderUsageReport } from "../cost/report.ts";
+import { buildDailySummary, createKv, markSummaryShown, renderDailySummary, summaryDue, summaryHasNews, type SummaryOllama } from "../cost/summary.ts";
 import type { Ledger, ModelTrust } from "../cost/types.ts";
 import { createRouter } from "../router/index.ts";
 import { createConversationStore } from "../router/state.ts";
@@ -414,7 +414,10 @@ export function startServer(cfg: RouterConfig): StartedServer {
 					const parsedDays = rawDays === null ? 7 : Number.parseInt(rawDays, 10);
 					const windowDays = Number.isInteger(parsedDays) ? Math.min(Math.max(parsedDays, 1), 365) : 7;
 					const harnessId = url.searchParams.get("harness") ?? "";
-					return json(buildUsageReport(db, { windowDays, harnessId, baselines: baselinePrices(cfg.report.baselines, (s) => catalog.find(s)) }));
+					const report = buildUsageReport(db, { windowDays, harnessId, baselines: baselinePrices(cfg.report.baselines, (s) => catalog.find(s)) });
+					// ?format=text: the rendered report for harnesses without a renderer of their own (the Hermes plugin).
+					if (url.searchParams.get("format") === "text") return new Response(renderUsageReport(report), { headers: { "content-type": "text/plain; charset=utf-8" } });
+					return json(report);
 				}
 				if (req.method === "GET" && url.pathname === "/v1/router/advise/policy") {
 					const h = cfg.harnessSwitch;
@@ -456,6 +459,7 @@ export function startServer(cfg: RouterConfig): StartedServer {
 					});
 					if (auto && !summaryHasNews(summary)) return json({ due: false, reason: "nothing to report", summary: null });
 					if (auto) markSummaryShown(kv, harnessId);
+					if (url.searchParams.get("format") === "text") return new Response(renderDailySummary(summary), { headers: { "content-type": "text/plain; charset=utf-8" } });
 					return json({ due: true, summary });
 				}
 				if (req.method === "GET" && url.pathname === "/v1/router/decisions") {
@@ -500,7 +504,7 @@ export function startServer(cfg: RouterConfig): StartedServer {
 				}
 				if (req.method === "GET" && url.pathname === "/v1/router/digest/policy") {
 					const d = cfg.digest;
-					return json({ enabled: d.enabled, minBytes: d.minBytes, maxBytes: d.maxBytes, tools: d.tools, fromTier: d.fromTier });
+					return json({ enabled: d.enabled, minBytes: d.minBytes, maxBytes: d.maxBytes, tools: d.tools, toolAliases: d.toolAliases, fromTier: d.fromTier });
 				}
 				if (req.method === "POST" && url.pathname === "/v1/router/digest") {
 					const body = (await req.json().catch(() => null)) as Record<string, unknown> | null;

package/src/wire/openai/request.ts

@@ -213,6 +213,9 @@ function applyCompaction(messages: Record<string, unknown>[], edits: readonly Co
 	}
 }
 
+/** Request parameters that exist only on OpenAI's own platform; dropped before dispatch. */
+export const OPENAI_ONLY_PARAMS: readonly string[] = ["store", "prompt_cache_key", "safety_identifier", "service_tier", "metadata", "web_search_options"];
+
 function renderUpstreamBody(
 	original: Record<string, unknown>,
 	m: UpstreamMutations,
@@ -227,6 +230,10 @@ function renderUpstreamBody(
 	body.stream = true;
 	// OpenRouter returns usage unconditionally and the parameter is deprecated.
 	delete body.stream_options;
+	// OpenAI-platform-only parameters other harnesses send (Codex, Aider,
+	// Cline): storage, cache keys, tiers and abuse ids mean nothing upstream
+	// and some providers reject unknown fields.
+	for (const key of OPENAI_ONLY_PARAMS) delete body[key];
 
 	if (m.maxTokens !== undefined) {
 		// Respect whichever max-token spelling the client used.

package/test/config-wizard.test.ts

@@ -142,7 +142,7 @@ describe("validateField", () => {
 
 describe("WIZARD_SECTIONS coverage", () => {
 	/** Leaves that are edited as whole records/arrays rather than fields. */
-	const RECORD_PATHS = new Set(["ollama.prices", "ollama.twins", "profiles"]);
+	const RECORD_PATHS = new Set(["ollama.prices", "ollama.twins", "digest.toolAliases", "profiles"]);
 
 	function leaves(obj: unknown, prefix = ""): string[] {
 		if (typeof obj !== "object" || obj === null || Array.isArray(obj)) return [prefix];

package/test/failover.test.ts

@@ -78,7 +78,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 		budget: { onExceeded: "downgrade" },
 		report: { baselines: [], dailySummary: false },
 		harnessSwitch: { enabled: false, models: {}, minConfidence: 0.6 },
-		digest: { enabled: false, minBytes: 12_000, maxBytes: 400_000, tools: ["read"], fromTier: "moderate", tier: "simple", model: "", maxOutputTokens: 700, maxCostUsd: 0.02, timeoutMs: 25_000 },
+		digest: { enabled: false, minBytes: 12_000, maxBytes: 400_000, tools: ["read"], fromTier: "moderate", tier: "simple", model: "", maxOutputTokens: 700, maxCostUsd: 0.02, timeoutMs: 25_000, toolAliases: {} },
 		profiles: [],
 		ledger: { path: ":memory:", blendWindowDays: 7, blendMinSamples: 20, fallbackBlend: { inputPerMtok: 1, outputPerMtok: 4 }, conversationTtlMs: 86_400_000 , retentionDays: 0,},
 		adaptiveTierFloors: true,

package/test/harness-requests.test.ts

@@ -0,0 +1,137 @@
+import { describe, expect, test } from "bun:test";
+
+import { DEFAULT_CONFIG } from "../src/config/defaults.ts";
+import { canonicalTool, digestApplies } from "../src/server/digest.ts";
+import { OPENAI_ONLY_PARAMS, parseChatRequest } from "../src/wire/openai/request.ts";
+import type { UpstreamMutations } from "../src/wire/types.ts";
+import { parsePolicy, shouldSend } from "../omp-extension/digest-logic.ts";
+
+/**
+ * Request shapes the config-only harnesses send to an OpenAI-compatible
+ * endpoint, as each harness documents them: the router must parse them,
+ * keep their tool calls and headers, and drop the OpenAI-platform-only
+ * parameters before dispatch. These are representative bodies, not captured
+ * traffic; a harness release that changes its shape belongs here as a new case.
+ */
+
+const MUT: UpstreamMutations = { slug: "x/y", fallbacks: [], sessionId: "s", cacheBreakpointMessageIndices: [], reasoning: undefined, maxTokens: undefined, stripAssistantReasoning: false };
+
+const TOOL = (name: string) => ({ type: "function", function: { name, description: name, parameters: { type: "object", properties: { path: { type: "string" } } } } });
+
+const HARNESSES: Record<string, { headers: Record<string, string>; body: Record<string, unknown>; toolCall?: string }> = {
+	codex: {
+		headers: { "X-Omp-Harness": "codex" },
+		body: {
+			model: "auto",
+			messages: [
+				{ role: "developer", content: "You are Codex." },
+				{ role: "user", content: "fix the failing test" },
+				{ role: "assistant", content: null, tool_calls: [{ id: "call_1", type: "function", function: { name: "shell", arguments: '{"command":["cat","x.ts"]}' } }] },
+				{ role: "tool", tool_call_id: "call_1", content: "export const x = 1;" },
+			],
+			tools: [TOOL("shell"), TOOL("apply_patch")],
+			stream: true,
+			store: false,
+			prompt_cache_key: "session-abc",
+			reasoning_effort: "medium",
+			parallel_tool_calls: false,
+		},
+		toolCall: "shell",
+	},
+	aider: {
+		headers: { "X-Omp-Harness": "aider" },
+		body: { model: "auto", messages: [{ role: "system", content: "Act as an expert software developer." }, { role: "user", content: "add a retry helper" }], stream: true, temperature: 0, extra_body: {} },
+	},
+	cline: {
+		headers: { "X-Omp-Harness": "cline" },
+		body: {
+			model: "auto",
+			messages: [
+				{ role: "system", content: "You are Cline." },
+				{ role: "user", content: [{ type: "text", text: "<task>rename the helper</task>" }] },
+				{ role: "assistant", content: null, tool_calls: [{ id: "c1", type: "function", function: { name: "read_file", arguments: '{"path":"src/a.ts"}' } }] },
+				{ role: "tool", tool_call_id: "c1", content: [{ type: "text", text: "line 1\nline 2" }] },
+			],
+			tools: [TOOL("read_file"), TOOL("execute_command"), TOOL("search_files")],
+			stream: true,
+			stream_options: { include_usage: true },
+			temperature: 0,
+		},
+		toolCall: "read_file",
+	},
+	opencode: {
+		headers: { "X-Omp-Harness": "opencode" },
+		body: {
+			model: "auto",
+			messages: [{ role: "system", content: "opencode" }, { role: "user", content: "list the tests" }],
+			tools: [TOOL("read"), TOOL("bash"), TOOL("glob"), TOOL("webfetch")],
+			stream: true,
+			stream_options: { include_usage: true },
+			max_tokens: 8192,
+			service_tier: "auto",
+		},
+	},
+	hermes: {
+		headers: { "X-Omp-Harness": "hermes", "X-Omp-Session": "hermes-session-1", "X-Omp-Subagent": "1" },
+		body: {
+			model: "auto",
+			messages: [
+				{ role: "system", content: "You are Hermes." },
+				{ role: "user", content: "summarise the repo" },
+				{ role: "assistant", content: null, tool_calls: [{ id: "h1", type: "function", function: { name: "read_file", arguments: '{"path":"README.md"}' } }] },
+				{ role: "tool", tool_call_id: "h1", content: '{"content":"# repo","path":"README.md"}' },
+			],
+			tools: [TOOL("read_file"), TOOL("terminal"), TOOL("search_files"), TOOL("delegate_task")],
+			stream: true,
+			max_tokens: 4096,
+		},
+		toolCall: "read_file",
+	},
+};
+
+describe("config-only harness request shapes", () => {
+	for (const [name, h] of Object.entries(HARNESSES)) {
+		test(`${name}: parses, keeps headers and tool calls, and drops OpenAI-only parameters`, () => {
+			const req = parseChatRequest(structuredClone(h.body), new Headers(h.headers));
+			expect(req.harnessId).toBe(name);
+			expect(req.requestedModel).toBe("auto");
+			expect(req.messages.length).toBe((h.body.messages as unknown[]).length);
+			if (h.toolCall !== undefined) {
+				const assistant = req.messages.find((m) => m.role === "assistant");
+				expect(assistant?.toolCalls[0]?.name).toBe(h.toolCall);
+				expect(req.messages.find((m) => m.role === "tool")?.toolCallId).toBeDefined();
+			}
+			const out = req.renderUpstreamBody(MUT);
+			for (const key of OPENAI_ONLY_PARAMS) expect(key in out).toBe(false);
+			expect("stream_options" in out).toBe(false);
+			expect(out.model).toBe("x/y");
+			expect(out.stream).toBe(true);
+			// Parameters every provider understands survive.
+			if ("temperature" in h.body) expect(out.temperature).toBe(h.body.temperature);
+			if ("tools" in h.body) expect((out.tools as unknown[]).length).toBe((h.body.tools as unknown[]).length);
+		});
+	}
+
+	test("hermes headers carry session and subagent identity", () => {
+		const req = parseChatRequest(structuredClone(HARNESSES.hermes!.body), new Headers(HARNESSES.hermes!.headers));
+		expect(req.ompSessionId).toBe("hermes-session-1");
+		expect(req.isSubagent).toBe(true);
+	});
+});
+
+describe("digest tool aliases across harnesses", () => {
+	const d = { ...DEFAULT_CONFIG.digest, enabled: true, minBytes: 10, maxBytes: 10_000 };
+	test("harness spellings map onto the canonical tools list on both sides", () => {
+		for (const [alias, canonical] of [["read_file", "read"], ["search_files", "grep"], ["terminal", "bash"], ["execute_command", "bash"], ["shell", "bash"], ["list_files", "ls"], ["web_extract", "web_fetch"], ["READ_FILE", "read"]] as const) {
+			expect(canonicalTool(d, alias)).toBe(canonical);
+			expect(digestApplies(d, alias, 500, false, "hard").ok).toBe(true);
+		}
+		expect(canonicalTool(d, "write_file")).toBe("write_file");
+		expect(digestApplies(d, "write_file", 500, false, "hard").ok).toBe(false);
+		// The policy the router publishes carries the aliases, and the client gate honours them.
+		const policy = parsePolicy({ enabled: true, minBytes: 10, maxBytes: 10_000, tools: d.tools, toolAliases: d.toolAliases, fromTier: "moderate" });
+		expect(shouldSend(policy, "search_files", false, "x".repeat(100), false)).toBe(true);
+		expect(shouldSend(policy, "delegate_task", false, "x".repeat(100), false)).toBe(false);
+		expect(parsePolicy({ enabled: true }).toolAliases).toEqual({});
+	});
+});

package/test/turn.test.ts

@@ -78,7 +78,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 		budget: { onExceeded: "downgrade" },
 		report: { baselines: [], dailySummary: false },
 		harnessSwitch: { enabled: false, models: {}, minConfidence: 0.6 },
-		digest: { enabled: false, minBytes: 12_000, maxBytes: 400_000, tools: ["read"], fromTier: "moderate", tier: "simple", model: "", maxOutputTokens: 700, maxCostUsd: 0.02, timeoutMs: 25_000 },
+		digest: { enabled: false, minBytes: 12_000, maxBytes: 400_000, tools: ["read"], fromTier: "moderate", tier: "simple", model: "", maxOutputTokens: 700, maxCostUsd: 0.02, timeoutMs: 25_000, toolAliases: {} },
 		profiles: [],
 		ledger: { path: ":memory:", blendWindowDays: 7, blendMinSamples: 20, fallbackBlend: { inputPerMtok: 1, outputPerMtok: 4 }, conversationTtlMs: 86_400_000 , retentionDays: 0,},
 		adaptiveTierFloors: true,