auto-model-router 0.4.4 → 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.4",
+    "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.4",
+      "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. |
@@ -837,6 +939,14 @@ task needed, and `digest.maxOutputTokens` or `digest.model` is the lever.
 | `baselines` | `anthropic/claude-opus-5`, `anthropic/claude-sonnet-5` | Models the report prices the window's traffic on as a single-model counterfactual. Unknown slugs are skipped. |
 | `dailySummary` | `true` | Post the daily summary (below) into the transcript at the first interactive omp session start of each day. Hot-reloads. |
 
+### `harnessSwitch` — harness-side model switch (experimental)
+
+| Key | Default | Meaning |
+| --- | --- | --- |
+| `enabled` | `false` | Let the `router-switch` extension move omp's active model for mapped tiers. |
+| `models` | `{}` | Tier → harness model as `provider/id` in omp's own registry, e.g. `hard: anthropic/claude-opus-4-8`. A tier serves itself and every tier above it up to the next mapped one; unmapped tiers stay on the router. |
+| `minConfidence` | `0.6` | Advice below this heuristic confidence leaves the model where it is. |
+
 ### `ledger` — cost measurement
 
 | Key | Default | Meaning |
@@ -929,8 +1039,50 @@ router handles for you: no `models[]` fallback cascade, no `tool_choice`,
 `reasoning_effort` instead of the `reasoning` object, and no `cache_control`
 markers (they are stripped before dispatch).
 
+## Harness-side model switch (experimental)
+
+Most engineers reach Claude through a subscription, not an API key, and a
+subscription model cannot be proxied: the router would have to translate to
+Anthropic's wire format and carry omp's OAuth token through a third-party
+process. The `router-switch` extension takes the other route. Before omp
+starts a turn on a user prompt it asks the router which tier the prompt is
+(`POST /v1/router/advise`, the heuristic classifier over the prompt text,
+nothing dispatched or recorded). When that tier is mapped in
+`harnessSwitch.models`, the extension moves omp's active model to the mapped
+harness model; when a later prompt is advised below every mapped tier, it
+moves back to the router model it left. A model the user picked by hand is
+never touched. Native turns bill the subscription and never reach the
+ledger; the router serves and accounts for the rest.
+
+```yaml
+# ~/.auto-model-router/config.yml
+harnessSwitch:
+  enabled: true
+  models:
+    hard: anthropic/claude-opus-4-8
+```
+
+Install `omp-extension/router-switch.ts` beside the embed extension and
+restart omp. Known limits of the prototype: the advice sees only the prompt
+text, not the conversation, so a hard task that only becomes hard three tool
+calls in stays on the router (the router's own escalation still applies
+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/omp-extension/pi-coding-agent.d.ts

@@ -109,6 +109,12 @@ declare module "@oh-my-pi/pi-coding-agent" {
 		/** Interval whose errors omp isolates, and whose handle `clearTimer` cancels. */
 		setInterval(handler: () => void | Promise<void>, ms: number): unknown;
 		clearTimer(timer: unknown): void;
+		/** The active model, when one is set. (Real type: `Model`.) */
+		model: { provider: string; id: string } | undefined;
+		/** Looks a model up in omp's registry by provider and id. */
+		modelRegistry: { find(provider: string, modelId: string): unknown };
+		/** Sets the session's active model; false when omp has no key for it. */
+		setModel(model: unknown): Promise<boolean>;
 	}
 
 	export interface CommandDefinition {