misroute 0.2.2__tar.gz → 0.2.3__tar.gz

{misroute-0.2.2 → misroute-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: misroute
-Version: 0.2.2
+Version: 0.2.3
 Summary: Find the tools your agent confuses and test whether a fix helps, against a neutral edit
 Keywords: mcp,agents,llm,tool-use,evaluation
 Author: philippyt

{misroute-0.2.2 → misroute-0.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "misroute"
-version = "0.2.2"
+version = "0.2.3"
 description = "Find the tools your agent confuses and test whether a fix helps, against a neutral edit"
 requires-python = ">=3.11"
 readme = "README.md"

{misroute-0.2.2 → misroute-0.2.3}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "misroute"
-version = "0.2.2"
+version = "0.2.3"
 description = "Find the tools your agent confuses and test whether a fix helps, against a neutral edit"
 authors = [
     { name = "philippyt", email = "philipaha@proton.me" }

{misroute-0.2.2 → misroute-0.2.3}/src/misroute/config.py

@@ -1,3 +1,4 @@
+import os
 from pathlib import Path
 from typing import Any, Literal
 import yaml
@@ -91,6 +92,22 @@ class Config(BaseModel):
         return self.model(name)
 
 
+def env_path(config: str | Path) -> Path:
+    return Path(config).resolve().parent / ".env"
+
+
+def load_env(config: str | Path) -> None:
+    """Read KEY=VALUE lines from .env next to the config into the environment, without overriding set values."""
+    path = env_path(config)
+    if not path.exists():
+        return
+    for line in path.read_text(encoding="utf-8").splitlines():
+        key, sep, value = line.partition("=")
+        if sep and key.strip() and not key.lstrip().startswith("#"):
+            os.environ.setdefault(key.strip(), value.strip().strip('"').strip("'"))
+
+
 def load(path: str | Path) -> Config:
+    load_env(path)
     data = yaml.safe_load(Path(path).read_text(encoding="utf-8")) or {}
     return Config.model_validate(data)

{misroute-0.2.2 → misroute-0.2.3}/src/misroute/models/openai_compat.py

@@ -86,7 +86,14 @@ class OpenAICompatAdapter:
             kw["tools"] = to_openai(tools)
         if extra := self.cfg.options.get("extra"):
             kw["extra_body"] = extra
-        resp = await self.client.chat.completions.create(**kw)
+        try:
+            resp = await self.client.chat.completions.create(**kw)
+        except openai.BadRequestError as e:
+            if "temperature" not in kw or "temperature" not in str(e).lower():
+                raise
+            self.cfg.options["temperature"] = None
+            kw.pop("temperature")
+            resp = await self.client.chat.completions.create(**kw)
         msg = resp.choices[0].message
         calls = [Call(c.function.name, parse_args(c.function.arguments), c.id) for c in msg.tool_calls or []]
         text = msg.content or ""

{misroute-0.2.2 → misroute-0.2.3}/src/misroute/ui/app.py

@@ -7,10 +7,12 @@ from starlette.applications import Starlette
 from starlette.requests import Request
 from starlette.responses import HTMLResponse, JSONResponse, Response
 from starlette.routing import Route
+from misroute.config import load_env
 from misroute.guard.wrapper import approve
 from misroute.models.base import BudgetExceeded
 from misroute.project import Project
 from misroute.report.html import html
+from misroute.ui import setup
 
 PHASES = ("lint", "discover", "probe", "fix")
 
@@ -104,10 +106,17 @@ def create(config: Path) -> Starlette:
         return HTMLResponse(page)
 
     async def report(request: Request) -> Response:
+        if not config.exists():
+            return HTMLResponse("<p style='font-family:system-ui;color:#6b6b66'>Set up a server and a model first</p>")
         return HTMLResponse(html(runner.project().store))
 
     async def state(request: Request) -> Response:
-        cfg = runner.project().cfg
+        if not config.exists():
+            return JSONResponse({"configured": False, "running": False, **runner.state, "models": [], "modes": []})
+        try:
+            cfg = runner.project().cfg
+        except Exception as e:
+            return JSONResponse({"configured": False, "config_error": str(e)[:400], "running": False, **runner.state})
         return JSONResponse(
             {
                 "running": runner.running,
@@ -117,9 +126,27 @@ def create(config: Path) -> Starlette:
                 ],
                 "modes": list(cfg.modes),
                 "budget": cfg.budget_usd,
+                "configured": True,
             }
         )
 
+    async def setup_get(request: Request) -> Response:
+        load_env(config)
+        return JSONResponse(setup.current(config))
+
+    async def setup_test(request: Request) -> Response:
+        if bad := guarded(request):
+            return bad
+        return JSONResponse(await setup.test(config, await request.json()))
+
+    async def setup_save(request: Request) -> Response:
+        if bad := guarded(request):
+            return bad
+        try:
+            return JSONResponse(setup.save(config, await request.json()))
+        except Exception as e:
+            return JSONResponse({"error": str(e)[:600]}, status_code=400)
+
     async def estimate(request: Request) -> Response:
         if bad := guarded(request):
             return bad
@@ -150,6 +177,9 @@ def create(config: Path) -> Starlette:
             Route("/", index),
             Route("/report", report),
             Route("/api/state", state),
+            Route("/api/setup", setup_get),
+            Route("/api/setup/test", setup_test, methods=["POST"]),
+            Route("/api/setup/save", setup_save, methods=["POST"]),
             Route("/api/estimate", estimate, methods=["POST"]),
             Route("/api/run", run, methods=["POST"]),
             Route("/api/guard", guard),

{misroute-0.2.2 → misroute-0.2.3}/src/misroute/ui/index.html

@@ -37,6 +37,7 @@ code { font-size: 12px; }
 <header>
   <b>misroute</b>
   <nav>
+    <button data-tab="setup">Setup</button>
     <button data-tab="results" class="on">Results</button>
     <button data-tab="run">Run</button>
     <button data-tab="guard">Guard</button>
@@ -44,6 +45,53 @@ code { font-size: 12px; }
   <span id="status"></span>
 </header>
 <main>
+  <section id="setup">
+    <div class="card">
+      <h3 style="margin-top:0">MCP server</h3>
+      <div class="row">
+        <div><label for="server_kind">Connect with</label>
+          <select id="server_kind"><option value="url">URL</option><option value="command">Local command</option><option value="openapi">OpenAPI file</option></select></div>
+        <div style="flex:1;min-width:260px"><label for="server_value" id="server_label">URL</label><input id="server_value" style="width:100%" placeholder="https://your-server/mcp"></div>
+      </div>
+      <div class="row">
+        <div style="flex:1;min-width:220px"><label for="server_token">Bearer token, optional</label><input id="server_token" type="password" style="width:100%" autocomplete="off"></div>
+        <div style="flex:1;min-width:220px"><label for="include_tools">Only these tools, optional</label><input id="include_tools" style="width:100%" placeholder="*issue*, *pull_request*"></div>
+      </div>
+      <p class="muted" id="token_note"></p>
+    </div>
+    <div class="card">
+      <h3 style="margin-top:0">Model</h3>
+      <div class="row">
+        <div><label for="provider">Provider</label>
+          <select id="provider">
+            <option value="openai-compatible">OpenAI compatible (OpenRouter, vLLM, Ollama, relay)</option>
+            <option value="anthropic">Anthropic API</option>
+            <option value="anthropic-foundry">Anthropic on Azure Foundry</option>
+            <option value="azure-openai">Azure OpenAI</option>
+            <option value="bedrock">Anthropic on Bedrock</option>
+          </select></div>
+        <div><label for="name">Name</label><input id="name" value="main" style="width:120px"></div>
+        <div style="flex:1;min-width:200px"><label for="model">Model or deployment</label><input id="model" style="width:100%"></div>
+      </div>
+      <div class="row">
+        <div style="flex:1;min-width:260px"><label for="base_url">Endpoint</label><input id="base_url" style="width:100%"></div>
+        <div id="api_version_box" hidden><label for="api_version">API version</label><input id="api_version" value="2024-10-21" style="width:130px"></div>
+      </div>
+      <div class="row">
+        <div style="flex:1;min-width:220px"><label for="api_key">API key</label><input id="api_key" type="password" style="width:100%" autocomplete="off"></div>
+        <div><label for="price_in">Dollars per million input tokens</label><input id="price_in" type="number" step="0.01" style="width:120px"></div>
+        <div><label for="price_out">Per million output tokens</label><input id="price_out" type="number" step="0.01" style="width:120px"></div>
+        <div><label for="budget_usd">Budget per run, dollars</label><input id="budget_usd" type="number" step="0.5" value="5" style="width:110px"></div>
+      </div>
+      <p class="muted" id="key_note"></p>
+      <label>Modes</label>
+      <div class="checks"><label><input type="checkbox" class="smode" value="json" checked>json</label><label><input type="checkbox" class="smode" value="code">code</label></div>
+      <button class="ghost" id="test">Test connection</button>
+      <button class="primary" id="save">Save</button>
+    </div>
+    <div class="card" id="setupResult" hidden></div>
+  </section>
+
   <section id="results" class="on"><iframe id="report" src="/report" title="report"></iframe></section>
 
   <section id="run">
@@ -99,7 +147,7 @@ function body() {
 
 $("estimate").onclick = async () => {
   const r = await post("/api/estimate", body());
-  $("estimateText").textContent = r.error ? r.error : `${r.calls} model calls, est $${r.cost.toFixed(2)}`;
+  $("estimateText").textContent = r.error ? r.error : `up to ${r.calls} model calls, up to $${r.cost.toFixed(2)}`;
   $("start").disabled = !!r.error;
 };
 ["phase", "top", "trials"].forEach((id) => $(id).onchange = () => { $("start").disabled = true; $("estimateText").textContent = ""; });
@@ -113,6 +161,11 @@ $("start").onclick = async () => {
 
 async function poll() {
   const s = await fetch("/api/state").then((r) => r.json());
+  if (!s.configured) {
+    $("status").textContent = s.config_error ? "config problem, see Setup" : "not set up";
+    if (!location.hash) location.hash = "setup";
+    return;
+  }
   if (!$("models").children.length) {
     $("models").innerHTML = s.models.map((m) => `<label><input type="checkbox" value="${esc(m.name)}" ${m.tested ? "checked" : ""}>${esc(m.name)}</label>`).join("");
     $("modes").innerHTML = ["json", "code"].map((m) => `<label><input type="checkbox" value="${m}" ${s.modes.includes(m) ? "checked" : ""}>${m}</label>`).join("");
@@ -142,6 +195,70 @@ async function loadGuard() {
     <td>${esc(e.tool)}</td><td>${esc(e.other)}</td><td class="muted">${new Date(e.at * 1000).toLocaleTimeString()}</td></tr>`).join("");
 }
 
+const LABELS = { url: ["URL", "https://your-server/mcp"], command: ["Command", "npx your-mcp-server"], openapi: ["Path to OpenAPI file", "api.json"] };
+const ENDPOINTS = {
+  "openai-compatible": "https://openrouter.ai/api/v1",
+  anthropic: "empty for the Anthropic API",
+  "anthropic-foundry": "https://your-resource.services.ai.azure.com/anthropic",
+  "azure-openai": "https://your-resource.openai.azure.com",
+  bedrock: "empty",
+};
+function refreshSetup() {
+  const [label, hint] = LABELS[$("server_kind").value];
+  $("server_label").textContent = label;
+  $("server_value").placeholder = hint;
+  $("base_url").placeholder = ENDPOINTS[$("provider").value];
+  $("api_version_box").hidden = $("provider").value !== "azure-openai";
+}
+$("server_kind").onchange = refreshSetup;
+$("provider").onchange = refreshSetup;
+
+const FIELDS = ["server_kind", "server_value", "server_token", "include_tools", "provider", "name", "model", "base_url", "api_version", "api_key", "price_in", "price_out", "budget_usd"];
+function setupForm() {
+  const f = Object.fromEntries(FIELDS.map((id) => [id, $(id).value.trim()]));
+  f.modes = [...document.querySelectorAll(".smode:checked")].map((i) => i.value);
+  f.keep_token = true;
+  return f;
+}
+
+function showSetup(html) { $("setupResult").hidden = false; $("setupResult").innerHTML = html; }
+
+$("test").onclick = async () => {
+  showSetup('<span class="muted">Testing</span>');
+  const r = await post("/api/setup/test", setupForm());
+  if (r.error) return showSetup(`<span class="bad">${esc(r.error)}</span>`);
+  const t = r.tools.error ? `<span class="bad">Server: ${esc(r.tools.error)}</span>`
+    : `<span class="good">Server: ${r.tools.count} tools</span> <span class="muted">${esc(r.tools.names.join(", "))}</span>`;
+  const m = r.model.error ? `<span class="bad">Model: ${esc(r.model.error)}</span>`
+    : `<span class="good">Model replied ${esc(JSON.stringify(r.model.reply))}</span> <span class="muted">${r.model.tokens_in} tokens in, ${r.model.tokens_out} out</span>`;
+  showSetup(`<p style="margin:0 0 8px">${t}</p><p style="margin:0">${m}</p>`);
+};
+
+$("save").onclick = async () => {
+  const r = await post("/api/setup/save", setupForm());
+  if (r.error) return showSetup(`<span class="bad">${esc(r.error)}</span>`);
+  const keys = r.env.length ? ` <span class="muted">keys in .env: ${esc(r.env.join(", "))}</span>` : "";
+  showSetup(`<span class="good">Saved ${esc(r.saved)}</span>${keys}`);
+  $("models").innerHTML = "";
+  $("report").src = "/report";
+  $("server_token").value = "";
+  $("api_key").value = "";
+  loadSetup();
+  poll();
+};
+
+async function loadSetup() {
+  const c = await fetch("/api/setup").then((r) => r.json());
+  if (c.configured) {
+    FIELDS.filter((id) => id !== "server_token" && id !== "api_key").forEach((id) => { if (c[id] !== undefined) $(id).value = c[id]; });
+    document.querySelectorAll(".smode").forEach((i) => { i.checked = c.modes.includes(i.value); });
+  }
+  $("token_note").textContent = c.has_token ? "A token is saved, leave the field empty to keep it" : "";
+  $("key_note").textContent = c.has_key ? "A key is saved, leave the field empty to keep it" : "";
+  refreshSetup();
+}
+
+loadSetup();
 show(location.hash.slice(1) || "results");
 poll();
 </script>

misroute-0.2.3/src/misroute/ui/setup.py

@@ -0,0 +1,128 @@
+import os
+import shlex
+from pathlib import Path
+from typing import Any
+import yaml
+from misroute.config import Config, env_path
+from misroute.models import build
+from misroute.project import Project
+
+TOKEN_VAR = "MISROUTE_MCP_TOKEN"
+KEY_VAR = "MISROUTE_MODEL_KEY"
+
+
+def server_block(form: dict) -> dict[str, Any]:
+    kind, value = form.get("server_kind", "url"), str(form.get("server_value", "")).strip()
+    if not value:
+        raise ValueError("server is empty")
+    out: dict[str, Any] = {"command": shlex.split(value, posix=os.name != "nt")} if kind == "command" else {kind: value}
+    if form.get("server_token") or (form.get("keep_token") and os.environ.get(TOKEN_VAR)):
+        out["auth"] = f"bearer_env:{TOKEN_VAR}"
+    include = [x.strip() for x in str(form.get("include_tools", "")).split(",") if x.strip()]
+    if include:
+        out["include_tools"] = include
+    return out
+
+
+def model_block(form: dict) -> dict[str, Any]:
+    provider = form.get("provider", "openai-compatible")
+    out: dict[str, Any] = {"name": form.get("name") or "main", "provider": provider, "model": form.get("model")}
+    if form.get("base_url"):
+        out["base_url"] = form["base_url"]
+    if provider != "bedrock":
+        out["api_key_env"] = KEY_VAR
+    for k in ("price_in", "price_out"):
+        if form.get(k) not in (None, ""):
+            out[k] = float(form[k])
+    options: dict[str, Any] = {}
+    if provider == "azure-openai" and form.get("api_version"):
+        options["api_version"] = form["api_version"]
+    if options:
+        out["options"] = options
+    return out
+
+
+def merged(config: Path, form: dict) -> dict[str, Any]:
+    data = yaml.safe_load(config.read_text(encoding="utf-8")) if config.exists() else {}
+    data = data or {}
+    model = model_block(form)
+    others = [m for m in data.get("models", []) if m.get("name") != model["name"]]
+    data.update(server=server_block(form), models=[model, *others])
+    names = {m["name"] for m in data["models"]}
+    for role in ("generator", "validator", "writer"):
+        if data.get(role) not in names:
+            data.pop(role, None)
+    data["modes"] = form.get("modes") or data.get("modes") or ["json"]
+    if form.get("budget_usd") not in (None, ""):
+        data["budget_usd"] = float(form["budget_usd"])
+    return data
+
+
+def secrets(form: dict) -> dict[str, str]:
+    out = {}
+    if form.get("server_token"):
+        out[TOKEN_VAR] = form["server_token"]
+    if form.get("api_key"):
+        out[KEY_VAR] = form["api_key"]
+    return out
+
+
+def save(config: Path, form: dict) -> dict[str, Any]:
+    data = merged(config, form)
+    Config.model_validate(data)
+    config.write_text(yaml.safe_dump(data, sort_keys=False), encoding="utf-8")
+    new = secrets(form)
+    if new:
+        path = env_path(config)
+        lines = [ln for ln in (path.read_text(encoding="utf-8").splitlines() if path.exists() else [])]
+        lines = [ln for ln in lines if ln.split("=", 1)[0].strip() not in new]
+        path.write_text("\n".join([*lines, *(f"{k}={v}" for k, v in new.items())]) + "\n", encoding="utf-8")
+        os.environ.update(new)
+    return {"saved": str(config), "env": sorted(new)}
+
+
+async def test(config: Path, form: dict) -> dict[str, Any]:
+    """List the server's tools, which is free, and make one tiny model call to check the key."""
+    os.environ.update(secrets(form))
+    out: dict[str, Any] = {}
+    try:
+        cfg = Config.model_validate(merged(config, form))
+    except Exception as e:
+        return {"error": f"config: {e}"}
+    try:
+        tools = await Project(cfg, root=config.parent / ".misroute").tools()
+        out["tools"] = {"count": len(tools), "names": [t.name for t in tools[:15]]}
+    except Exception as e:
+        out["tools"] = {"error": f"{type(e).__name__}: {e}"[:600]}
+    try:
+        turn = await build(cfg.models[0]).chat("Reply with the single word ok.", [])
+        out["model"] = {"reply": turn.text[:80], "tokens_in": turn.tokens_in, "tokens_out": turn.tokens_out}
+    except Exception as e:
+        out["model"] = {"error": f"{type(e).__name__}: {e}"[:600]}
+    return out
+
+
+def current(config: Path) -> dict[str, Any]:
+    if not config.exists():
+        return {"configured": False}
+    data = yaml.safe_load(config.read_text(encoding="utf-8")) or {}
+    server, model = data.get("server", {}), (data.get("models") or [{}])[0]
+    kind = next((k for k in ("url", "command", "openapi") if server.get(k)), "url")
+    value = " ".join(server["command"]) if kind == "command" else server.get(kind, "")
+    return {
+        "configured": True,
+        "server_kind": kind,
+        "server_value": value,
+        "include_tools": ", ".join(server.get("include_tools", [])),
+        "has_token": bool(os.environ.get(TOKEN_VAR)),
+        "has_key": bool(os.environ.get(model.get("api_key_env") or KEY_VAR)),
+        "provider": model.get("provider", "openai-compatible"),
+        "name": model.get("name", "main"),
+        "model": model.get("model", ""),
+        "base_url": model.get("base_url", ""),
+        "price_in": model.get("price_in", ""),
+        "price_out": model.get("price_out", ""),
+        "api_version": (model.get("options") or {}).get("api_version", ""),
+        "budget_usd": data.get("budget_usd", 5),
+        "modes": data.get("modes", ["json"]),
+    }