windhover 0.12.0__tar.gz → 0.14.0__tar.gz

{windhover-0.12.0 → windhover-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: windhover
-Version: 0.12.0
+Version: 0.14.0
 Summary: Self-hosted, mobile-friendly observability for LangGraph — traces, run history, cost, and a living graph view.
 Project-URL: Repository, https://github.com/justfeltlikerunning/windhover
 Author: justfeltlikerunning
@@ -17,7 +17,7 @@ Requires-Dist: langgraph>=0.2; extra == 'dev'
 Requires-Dist: pytest; extra == 'dev'
 Description-Content-Type: text/markdown
 
-<p align="center"><img src="docs/logo.svg" width="112" alt="Windhover — a hovering kestrel"></p>
+<p align="center"><img src="https://raw.githubusercontent.com/justfeltlikerunning/windhover/main/docs/logo.svg" width="112" alt="Windhover — a hovering kestrel"></p>
 <h1 align="center">Windhover</h1>
 <p align="center">
   <a href="https://pypi.org/project/windhover/"><img src="https://img.shields.io/pypi/v/windhover" alt="PyPI"></a>
@@ -40,11 +40,11 @@ your own app. No LangSmith account, no cloud tunnel, no fragile websocket. HTTP
 
 | Living graph (parallel fan-out) | Trace drawer — retrievers, LLM calls, cost, state |
 |---|---|
-| ![Graph view](docs/graph.png) | ![Trace drawer](docs/trace.png) |
+| ![Graph view](https://raw.githubusercontent.com/justfeltlikerunning/windhover/main/docs/graph.png) | ![Trace drawer](https://raw.githubusercontent.com/justfeltlikerunning/windhover/main/docs/trace.png) |
 
 | Runs — search, tags, sessions, interrupts | Dashboards — per-day, per-model |
 |---|---|
-| ![Runs table](docs/runs.png) | ![Stats](docs/stats.png) |
+| ![Runs table](https://raw.githubusercontent.com/justfeltlikerunning/windhover/main/docs/runs.png) | ![Stats](https://raw.githubusercontent.com/justfeltlikerunning/windhover/main/docs/stats.png) |
 
 ## Quick start
 ```bash
@@ -57,6 +57,9 @@ Edit the graph file while it runs and the canvas updates itself.
 
 Your own graph: `WINDHOVER_GRAPH="myapp.graphs:g" WINDHOVER_GRAPH_DIR=/path python -m windhover.server`
 
+Several graphs behind one URL: `WINDHOVER_GRAPH="checkout=app.flows:checkout,support=app.flows:support"`
+(a selector appears in the top bar; `langgraph.json` projects serve all their graphs automatically).
+
 ## Trace runs from any app
 ```python
 from windhover import WindhoverTracer

{windhover-0.12.0 → windhover-0.14.0}/README.md

@@ -1,4 +1,4 @@
-<p align="center"><img src="docs/logo.svg" width="112" alt="Windhover — a hovering kestrel"></p>
+<p align="center"><img src="https://raw.githubusercontent.com/justfeltlikerunning/windhover/main/docs/logo.svg" width="112" alt="Windhover — a hovering kestrel"></p>
 <h1 align="center">Windhover</h1>
 <p align="center">
   <a href="https://pypi.org/project/windhover/"><img src="https://img.shields.io/pypi/v/windhover" alt="PyPI"></a>
@@ -21,11 +21,11 @@ your own app. No LangSmith account, no cloud tunnel, no fragile websocket. HTTP
 
 | Living graph (parallel fan-out) | Trace drawer — retrievers, LLM calls, cost, state |
 |---|---|
-| ![Graph view](docs/graph.png) | ![Trace drawer](docs/trace.png) |
+| ![Graph view](https://raw.githubusercontent.com/justfeltlikerunning/windhover/main/docs/graph.png) | ![Trace drawer](https://raw.githubusercontent.com/justfeltlikerunning/windhover/main/docs/trace.png) |
 
 | Runs — search, tags, sessions, interrupts | Dashboards — per-day, per-model |
 |---|---|
-| ![Runs table](docs/runs.png) | ![Stats](docs/stats.png) |
+| ![Runs table](https://raw.githubusercontent.com/justfeltlikerunning/windhover/main/docs/runs.png) | ![Stats](https://raw.githubusercontent.com/justfeltlikerunning/windhover/main/docs/stats.png) |
 
 ## Quick start
 ```bash
@@ -38,6 +38,9 @@ Edit the graph file while it runs and the canvas updates itself.
 
 Your own graph: `WINDHOVER_GRAPH="myapp.graphs:g" WINDHOVER_GRAPH_DIR=/path python -m windhover.server`
 
+Several graphs behind one URL: `WINDHOVER_GRAPH="checkout=app.flows:checkout,support=app.flows:support"`
+(a selector appears in the top bar; `langgraph.json` projects serve all their graphs automatically).
+
 ## Trace runs from any app
 ```python
 from windhover import WindhoverTracer

{windhover-0.12.0 → windhover-0.14.0}/docs/GUIDE.md

@@ -57,7 +57,12 @@ WINDHOVER_GRAPH="myapp.graphs:graph" WINDHOVER_GRAPH_DIR=/path/to/app windhover
 ```
 
 Projects with a **`langgraph.json`** (the LangGraph Studio/CLI convention) need no flags —
-run `windhover` in the project directory and it uses the file's first graph.
+run `windhover` in the project directory and every graph the file defines is served.
+
+**Multiple graphs**: `WINDHOVER_GRAPH="checkout=app.flows:checkout,support=app.flows:support"`
+puts a graph selector in the top bar. The selector scopes the canvas, New run, node source,
+and Memory; the Runs page gets an extra graph filter; human-in-the-loop actions always follow
+the graph the run belongs to.
 
 - The canvas always reflects **current-on-disk** topology (a subprocess re-extracts on
   file change). Runs, however, execute the graph **imported at startup** — restart the
@@ -187,11 +192,46 @@ for semantic grading, run your own judge and `POST /api/runs/{id}/scores`.
   shows the tool-call JSON as the LLM output instead of an empty box.
 - **Auth**: set `WINDHOVER_TOKEN` to require `Authorization: Bearer …` (or `?token=`)
   on `/api`. The UI prompts once and remembers. The HTML shell itself stays public —
-  it contains no data.
+  it contains no data. External tracers pass it as `WindhoverTracer(url, token="…")`.
+  **Set the token before exposing Windhover beyond localhost** — the HITL endpoints can
+  resume and edit graph state.
+- **Alerts**: `WINDHOVER_WEBHOOK=https://…` POSTs a compact JSON summary whenever a run
+  errors or pauses on an interrupt (`{source, graph, run_id, status, error, text, …}`) —
+  point it at a Slack/Discord webhook or your own receiver. Fire-and-forget.
 - **Retention**: `WINDHOVER_RETENTION_DAYS=30` prunes old runs on startup and every 6h.
   Default keeps everything.
 - **Deep links**: `#runs`, `#sessions`, `#stats`, `#run=<id>`.
 
+## Running it for real
+
+- **The tracer never slows your app.** Events go onto a bounded in-memory queue drained
+  by a background thread; if the Windhover host is slow or down, events are dropped —
+  your pipeline's latency is unchanged. (Sheds oldest-first at 2,000 queued events.)
+- **Systemd** (adjust paths):
+  ```ini
+  [Unit]
+  Description=Windhover
+  After=network.target
+
+  [Service]
+  WorkingDirectory=/opt/myapp
+  Environment=WINDHOVER_GRAPH=myapp.graphs:graph
+  Environment=WINDHOVER_DB=/var/lib/windhover/windhover.db
+  Environment=WINDHOVER_TOKEN=change-me
+  Environment=WINDHOVER_RETENTION_DAYS=30
+  ExecStart=/opt/myapp/.venv/bin/windhover
+  Restart=always
+  TimeoutStopSec=10
+
+  [Install]
+  WantedBy=multi-user.target
+  ```
+  `TimeoutStopSec` matters: open SSE connections otherwise stretch restarts.
+- **Reverse proxy**: plain HTTP + SSE — any proxy works; disable response buffering for
+  `/api/events` and `/api/run` (nginx: `proxy_buffering off;`).
+- **Backups**: runs live in one SQLite file (`WINDHOVER_DB`); copy it (plus `-wal`) or
+  rely on `/api/export` for tabular run data.
+
 ## Try it all on the demo graph
 
 `WINDHOVER_GRAPH=windhover.demo_graph:graph windhover`, then:

{windhover-0.12.0 → windhover-0.14.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "windhover"
-version = "0.12.0"
+version = "0.14.0"
 description = "Self-hosted, mobile-friendly observability for LangGraph — traces, run history, cost, and a living graph view."
 readme = "README.md"
 requires-python = ">=3.10"

{windhover-0.12.0 → windhover-0.14.0}/tests/test_smoke.py

@@ -555,22 +555,56 @@ def test_message_serialization():
 
 
 def test_langgraph_json_discovery():
-    import json as _json, importlib
+    import json as _json
     d = tempfile.mkdtemp()
     gdir = os.path.join(d, "src"); os.makedirs(gdir)
-    open(os.path.join(gdir, "app.py"), "w").write("graph = None\n")
+    open(os.path.join(gdir, "app.py"), "w").write("graph = None\nother = None\n")
     open(os.path.join(d, "langgraph.json"), "w").write(
-        _json.dumps({"graphs": {"main": "./src/app.py:graph"}}))
+        _json.dumps({"graphs": {"main": "./src/app.py:graph",
+                                "side": "./src/app.py:other"}}))
     os.environ.pop("WINDHOVER_GRAPH", None)
     os.environ["WINDHOVER_GRAPH_DIR"] = d
     try:
         from windhover.config import Config
         cfg = Config.from_env()
-        assert cfg.graph_ref == "app:graph", cfg.graph_ref
+        assert cfg.graphs == (("main", "app:graph"), ("side", "app:other")), cfg.graphs
+        assert cfg.graph_ref == "app:graph"          # back-compat: first graph
         assert cfg.graph_dir == gdir, cfg.graph_dir
     finally:
         os.environ.pop("WINDHOVER_GRAPH_DIR", None)
-    print("langgraph.json discovery OK")
+    print("langgraph.json multi-discovery OK")
+
+
+def test_env_multi_graph_parsing():
+    from windhover.config import Config
+    os.environ["WINDHOVER_GRAPH"] = "alpha=m1:g1, m2:g2 ,beta=m3:g3"
+    try:
+        cfg = Config.from_env()
+        assert cfg.graphs == (("alpha", "m1:g1"), ("m2:g2", "m2:g2"),
+                              ("beta", "m3:g3")), cfg.graphs
+    finally:
+        os.environ.pop("WINDHOVER_GRAPH", None)
+    print("env multi-graph parsing OK")
+
+
+def test_nonblocking_sink_and_webhook_hook():
+    # sink to an unreachable host must return instantly and never raise
+    from windhover.tracer import http_sink
+    sink = http_sink("http://10.255.255.1:9", max_queue=10)
+    t0 = time.time()
+    for i in range(50):
+        sink({"kind": "span", "i": i})
+    assert time.time() - t0 < 0.5, "sink blocked the caller"
+
+    # store hook fires with the closing status (webhook wiring point)
+    p = tempfile.mktemp(suffix=".db")
+    s = Store(p)
+    fired = []
+    s.on_run_closed = lambda summary: fired.append(summary)
+    s.open_run({"id": "w1", "graph": "g", "started_ms": 1000})
+    s.close_run("w1", "error", 1500, error="Boom: it broke")
+    assert fired and fired[0]["status"] == "error" and "Boom" in fired[0]["error"]
+    print("non-blocking sink + webhook hook OK")
 
 
 if __name__ == "__main__":
@@ -598,4 +632,6 @@ if __name__ == "__main__":
     test_functional_api_tracing()
     test_message_serialization()
     test_langgraph_json_discovery()
+    test_env_multi_graph_parsing()
+    test_nonblocking_sink_and_webhook_hook()
     print("ALL SMOKE TESTS PASSED")

windhover-0.14.0/windhover/config.py

@@ -0,0 +1,89 @@
+"""Windhover configuration — one place, read from the environment.
+
+Multi-graph: WINDHOVER_GRAPH accepts a comma-separated list of graphs, each
+"module:attr" or "name=module:attr". With no env set, ALL graphs from a
+langgraph.json (the LangGraph Studio/CLI project file) are served.
+"""
+from __future__ import annotations
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+PKG_DIR = Path(__file__).resolve().parent
+
+
+@dataclass(frozen=True)
+class Config:
+    graphs: tuple           # ((name, "module:attr"), …); () = ingest-only
+    graph_dir: str          # import path for the graph modules
+    db_path: str
+    host: str
+    port: int
+    watch: bool             # live-topology file watcher
+    pricing_path: str
+    retention_days: int     # 0 = keep runs forever
+    token: str              # WINDHOVER_TOKEN: require Bearer/query token on /api ("" = open)
+    webhook: str            # WINDHOVER_WEBHOOK: POST run summaries on error/interrupted ("" = off)
+
+    @property
+    def graph_ref(self) -> str:
+        """First graph's ref — kept for single-graph callers/back-compat."""
+        return self.graphs[0][1] if self.graphs else ""
+
+    @staticmethod
+    def _parse_env_graphs(raw: str) -> tuple:
+        out = []
+        for part in raw.split(","):
+            part = part.strip()
+            if not part:
+                continue
+            if "=" in part.split(":")[0]:          # "name=module:attr"
+                name, _, ref = part.partition("=")
+                out.append((name.strip(), ref.strip()))
+            else:
+                out.append((part, part))            # name defaults to the ref
+        return tuple(out)
+
+    @staticmethod
+    def _discover() -> tuple:
+        """No WINDHOVER_GRAPH? Serve every graph a langgraph.json defines.
+        Returns ((name, ref), …), graph_dir."""
+        import json as _json
+        base = os.environ.get("WINDHOVER_GRAPH_DIR", os.getcwd())
+        try:
+            graphs = _json.loads(open(os.path.join(base, "langgraph.json")).read()).get("graphs") or {}
+        except Exception:
+            return (), base
+        out, gdir = [], base
+        for name, ref in graphs.items():
+            path, _, attr = str(ref).partition(":")
+            if not attr:
+                continue
+            if path.endswith(".py"):
+                full = os.path.normpath(os.path.join(base, path))
+                gdir = os.path.dirname(full)        # langgraph convention: shared src dir
+                out.append((str(name), f"{os.path.splitext(os.path.basename(full))[0]}:{attr}"))
+            else:
+                out.append((str(name), f"{path}:{attr}"))
+        return tuple(out), gdir
+
+    @classmethod
+    def from_env(cls) -> "Config":
+        raw = os.environ.get("WINDHOVER_GRAPH", "")
+        graph_dir = os.environ.get("WINDHOVER_GRAPH_DIR", os.getcwd())
+        if raw:
+            graphs = cls._parse_env_graphs(raw)
+        else:
+            graphs, graph_dir = cls._discover()
+        return cls(
+            graphs=graphs,
+            graph_dir=graph_dir,
+            db_path=os.environ.get("WINDHOVER_DB", str(PKG_DIR.parent / "windhover.db")),
+            host=os.environ.get("WINDHOVER_HOST", "0.0.0.0"),
+            port=int(os.environ.get("WINDHOVER_PORT", "8090")),
+            watch=os.environ.get("WINDHOVER_WATCH", "1") not in ("0", "false", "no"),
+            pricing_path=os.environ.get("WINDHOVER_PRICING", str(PKG_DIR / "pricing.json")),
+            retention_days=int(os.environ.get("WINDHOVER_RETENTION_DAYS", "0") or 0),
+            token=os.environ.get("WINDHOVER_TOKEN", ""),
+            webhook=os.environ.get("WINDHOVER_WEBHOOK", ""),
+        )

windhover-0.14.0/windhover/demo_rag.py

@@ -0,0 +1,55 @@
+"""Second demo graph — a tiny retrieval pipeline, so multi-graph serving is
+demoable out of the box:
+
+    WINDHOVER_GRAPH="numbers=windhover.demo_graph:graph,rag=windhover.demo_rag:graph" windhover
+"""
+import operator
+import time
+from typing import Annotated, TypedDict
+from langgraph.graph import StateGraph, START, END
+
+_DOCS = [
+    {"id": "handbook#12", "text": "Refunds are processed within five business days."},
+    {"id": "handbook#31", "text": "Enterprise plans include priority support."},
+    {"id": "faq#4", "text": "You can export your data as CSV at any time."},
+]
+
+
+class State(TypedDict):
+    question: str
+    hits: Annotated[list, operator.add]
+    answer: str
+
+
+def retrieve(s):
+    time.sleep(.15)
+    q = (s.get("question") or "").lower()
+    hits = [d for d in _DOCS if any(w in d["text"].lower() for w in q.split())] or _DOCS[:1]
+    return {"hits": hits}
+
+
+def grade(s):
+    time.sleep(.1)
+    return {"hits": []}  # additive reducer: nothing new, grading is a pass-through demo
+
+
+def answer(s):
+    time.sleep(.2)
+    src = s["hits"][0] if s["hits"] else {"id": "none", "text": ""}
+    return {"answer": f"Per {src['id']}: {src['text']}"}
+
+
+_g = StateGraph(State)
+_g.add_node("retrieve", retrieve)
+_g.add_node("grade", grade)
+_g.add_node("answer", answer)
+_g.add_edge(START, "retrieve")
+_g.add_edge("retrieve", "grade")
+_g.add_edge("grade", "answer")
+_g.add_edge("answer", END)
+
+try:
+    from langgraph.checkpoint.memory import MemorySaver
+    graph = _g.compile(checkpointer=MemorySaver())
+except Exception:
+    graph = _g.compile()

{windhover-0.12.0 → windhover-0.14.0}/windhover/server.py

@@ -22,11 +22,26 @@ cfg = Config.from_env()
 store = Store(cfg.db_path)
 STATIC = Path(__file__).parent / "static"
 
-graph = None
-if cfg.graph_ref:
+GRAPHS: dict = {}          # name -> compiled graph
+if cfg.graphs:
     sys.path.insert(0, cfg.graph_dir)
-    _m, _a = cfg.graph_ref.split(":")
-    graph = getattr(importlib.import_module(_m), _a)
+    for _name, _ref in cfg.graphs:
+        try:
+            _m, _a = _ref.split(":")
+            GRAPHS[_name] = getattr(importlib.import_module(_m), _a)
+        except Exception as _e:
+            print(f"[windhover] failed to import graph {_name} ({_ref}): {_e}")
+
+
+def _default_name() -> str:
+    return next(iter(GRAPHS), "")
+
+
+def _graph_for(name=None):
+    """Resolve a graph by registry name; no name -> the first graph."""
+    if name:
+        return GRAPHS.get(name)
+    return next(iter(GRAPHS.values()), None)
 
 app = FastAPI(title="Windhover")
 
@@ -54,7 +69,8 @@ async def _auth_middleware(request: Request, call_next):
 
 # ---- topology manager (subprocess extraction, mtime-cached) ---------------
 class Topo:
-    def __init__(self):
+    def __init__(self, name: str, ref: str):
+        self.name, self.ref = name, ref
         self.lock = threading.Lock()
         self.sig = None
         self.data = {"topology": {"nodes": [], "edges": []}, "schema": {}, "sources": {}}
@@ -62,8 +78,6 @@ class Topo:
         self.version = 0
 
     def _signature(self) -> float:
-        if not cfg.graph_ref:
-            return 0.0
         try:
             return max((p.stat().st_mtime for p in Path(cfg.graph_dir).glob("*.py")),
                        default=0.0)
@@ -71,8 +85,6 @@ class Topo:
             return 0.0
 
     def refresh(self, force=False) -> None:
-        if not cfg.graph_ref:
-            return
         sig = self._signature()
         with self.lock:
             if not force and sig == self.sig:
@@ -80,7 +92,7 @@ class Topo:
             self.sig = sig
         try:
             out = subprocess.run(
-                [sys.executable, "-m", "windhover.extract", cfg.graph_ref, cfg.graph_dir],
+                [sys.executable, "-m", "windhover.extract", self.ref, cfg.graph_dir],
                 capture_output=True, text=True, timeout=20,
                 cwd=str(Path(__file__).parent.parent))
             data = json.loads(out.stdout)
@@ -95,7 +107,7 @@ class Topo:
 
     def get(self) -> dict:
         with self.lock:
-            return {**self.data["topology"], "graph": cfg.graph_ref, "hash": self.hash,
+            return {**self.data["topology"], "graph": self.name, "hash": self.hash,
                     "version": self.version, "xray": self.data.get("topology_xray")}
 
     def schema(self) -> dict:
@@ -107,20 +119,28 @@ class Topo:
             return self.data.get("sources", {})
 
 
-TOPO = Topo()
-TOPO.refresh(force=True)
+TOPOS: dict = {name: Topo(name, ref) for name, ref in cfg.graphs if name in GRAPHS}
+for _t in TOPOS.values():
+    _t.refresh(force=True)
+
+
+def _topo_for(name=None):
+    if name:
+        return TOPOS.get(name)
+    return next(iter(TOPOS.values()), None)
 
 
 def _watch_loop():
-    while cfg.watch and cfg.graph_ref:
+    while cfg.watch and TOPOS:
         time.sleep(2)
-        try:
-            TOPO.refresh()
-        except Exception:
-            pass
+        for tp in TOPOS.values():
+            try:
+                tp.refresh()
+            except Exception:
+                pass
 
 
-if cfg.watch and cfg.graph_ref:
+if cfg.watch and TOPOS:
     threading.Thread(target=_watch_loop, daemon=True).start()
 
 
@@ -140,6 +160,36 @@ if cfg.retention_days > 0:
     threading.Thread(target=_retention_loop, daemon=True).start()
 
 
+def _fire_webhook(summary: dict) -> None:
+    """POST a compact alert when a run needs attention. Fire-and-forget."""
+    if summary.get("status") not in ("error", "interrupted"):
+        return
+    def _post():
+        try:
+            import urllib.request
+            run = store.run_detail(summary["id"]) or summary
+            body = {
+                "source": "windhover", "graph": run.get("graph") or _default_name(),
+                "run_id": summary["id"], "status": summary["status"],
+                "duration_ms": summary.get("duration_ms"),
+                "session": run.get("session"), "thread_id": run.get("thread_id"),
+                "error": (str(summary.get("error") or "").strip().splitlines() or [None])[-1],
+                "text": f"[windhover] run {summary['id']} {summary['status']}"
+                        f" ({run.get('graph') or _default_name()})",
+            }
+            req = urllib.request.Request(
+                cfg.webhook, data=json.dumps(body).encode(),
+                headers={"Content-Type": "application/json"})
+            urllib.request.urlopen(req, timeout=5)
+        except Exception:
+            pass
+    threading.Thread(target=_post, daemon=True).start()
+
+
+if cfg.webhook:
+    store.on_run_closed = _fire_webhook
+
+
 def _template(schema: dict) -> dict:
     out = {}
     for k, p in (schema.get("properties") or {}).items():
@@ -149,16 +199,29 @@ def _template(schema: dict) -> dict:
 
 
 # ---- endpoints ------------------------------------------------------------
+@app.get("/api/graphs")
+def api_graphs():
+    return JSONResponse({"graphs": list(GRAPHS.keys()), "default": _default_name()})
+
+
 @app.get("/api/graph")
-def api_graph():
-    return JSONResponse(TOPO.get())
+def api_graph(graph: str = None):
+    tp = _topo_for(graph)
+    if tp is None:
+        return JSONResponse({"nodes": [], "edges": [], "graph": "", "hash": "",
+                             "version": 0, "xray": None})
+    return JSONResponse(tp.get())
 
 
 @app.get("/api/schema")
-def api_schema():
-    s = TOPO.schema()
-    with TOPO.lock:
-        ctx = TOPO.data.get("context_schema") or {}
+def api_schema(graph: str = None):
+    tp = _topo_for(graph)
+    if tp is None:
+        return JSONResponse({"schema": {}, "template": {},
+                             "context_schema": {}, "context_template": {}})
+    s = tp.schema()
+    with tp.lock:
+        ctx = tp.data.get("context_schema") or {}
     return JSONResponse({"schema": s, "template": _template(s),
                          "context_schema": ctx, "context_template": _template(ctx)})
 
@@ -167,7 +230,7 @@ def _sse(ev: str, data: dict) -> str:
     return f"event: {ev}\ndata: {json.dumps(data)}\n\n"
 
 
-def _stream_execution(graph_input, config, tracer, stream_kwargs=None):
+def _stream_execution(gr, graph_input, config, tracer, stream_kwargs=None):
     """Shared SSE executor for /api/run and /api/threads/…/resume. Detects both
     dynamic interrupts (__interrupt__ updates) and static breakpoints (stream
     ends with pending next-nodes) and corrects the run status accordingly."""
@@ -178,7 +241,7 @@ def _stream_execution(graph_input, config, tracer, stream_kwargs=None):
     def worker():
         try:
             interrupted = False
-            for mode, chunk in graph.stream(graph_input, config=config,
+            for mode, chunk in gr.stream(graph_input, config=config,
                                             stream_mode=["updates", "custom"],
                                             **(stream_kwargs or {})):
                 if mode == "custom":
@@ -208,9 +271,9 @@ def _stream_execution(graph_input, config, tracer, stream_kwargs=None):
                                         "params": {"cached": True}})
                         seq_extra[0] += 1
                     q.put(("node", {"node": node, "cached": cached or None}))
-            if not interrupted and getattr(graph, "checkpointer", None) is not None:
+            if not interrupted and getattr(gr, "checkpointer", None) is not None:
                 try:  # static breakpoint: stream ended but nodes are pending
-                    st = graph.get_state(config)
+                    st = gr.get_state(config)
                     if st.next:
                         interrupted = True
                         q.put(("interrupt", {"run_id": run_id,
@@ -240,21 +303,24 @@ def _stream_execution(graph_input, config, tracer, stream_kwargs=None):
 
 @app.post("/api/run")
 async def api_run(request: Request):
-    if graph is None:
-        return JSONResponse({"error": "no local graph (WINDHOVER_GRAPH unset)"}, 400)
     try:
         payload = await request.json()
     except Exception:
         payload = {}
+    gname = payload.pop("_graph", None) or _default_name()
+    gr = _graph_for(gname)
+    if gr is None:
+        return JSONResponse({"error": "no local graph (WINDHOVER_GRAPH unset "
+                            "or unknown graph name)"}, 400)
     session = payload.pop("_session", None)
     tags = payload.pop("_tags", None)
     thread = payload.pop("_thread", None)
     pause_before = payload.pop("_interrupt_before", None)
     pause_after = payload.pop("_interrupt_after", None)
     extra_conf = payload.pop("_configurable", None)
-    tracer = SpanBuilder(db_sink(store), run_name=cfg.graph_ref, session=session, tags=tags)
+    tracer = SpanBuilder(db_sink(store), run_name=gname, session=session, tags=tags)
     config = {"callbacks": [tracer]}
-    if thread or getattr(graph, "checkpointer", None) is not None:
+    if thread or getattr(gr, "checkpointer", None) is not None:
         # a checkpointed graph needs a thread; default to the run id so
         # time-travel works out of the box
         config["configurable"] = {"thread_id": thread or tracer.run_id}
@@ -265,15 +331,16 @@ async def api_run(request: Request):
         sk["interrupt_before"] = [str(n) for n in pause_before]
     if pause_after:
         sk["interrupt_after"] = [str(n) for n in pause_after]
-    return _stream_execution(payload, config, tracer, sk)
+    return _stream_execution(gr, payload, config, tracer, sk)
 
 
 @app.post("/api/threads/{thread_id}/resume")
-async def api_thread_resume(request: Request, thread_id: str):
+async def api_thread_resume(request: Request, thread_id: str, graph: str = None):
     """Human-in-the-loop: answer an interrupt (Command(resume=…)), redirect
     (Command(goto=…)), continue past a static breakpoint (no body), or fork
     from an earlier checkpoint (checkpoint_id)."""
-    if graph is None or getattr(graph, "checkpointer", None) is None:
+    gr = _graph_for(graph)
+    if gr is None or getattr(gr, "checkpointer", None) is None:
         return JSONResponse({"error": "no local graph with a checkpointer"}, 400)
     try:
         body = await request.json()
@@ -289,21 +356,22 @@ async def api_thread_resume(request: Request, thread_id: str):
         graph_input = Command(goto=str(body["goto"]), update=body.get("update"))
     else:
         graph_input = None  # plain continue (static breakpoint / after state edit)
-    tracer = SpanBuilder(db_sink(store), run_name=cfg.graph_ref,
+    tracer = SpanBuilder(db_sink(store), run_name=graph or _default_name(),
                          session=body.get("_session"),
                          tags=(body.get("_tags") or []) + ["resume"])
     configurable = {"thread_id": thread_id}
     if body.get("checkpoint_id"):
         configurable["checkpoint_id"] = str(body["checkpoint_id"])
     config = {"callbacks": [tracer], "configurable": configurable}
-    return _stream_execution(graph_input, config, tracer)
+    return _stream_execution(gr, graph_input, config, tracer)
 
 
 @app.post("/api/threads/{thread_id}/state")
-async def api_thread_update_state(request: Request, thread_id: str):
+async def api_thread_update_state(request: Request, thread_id: str, graph: str = None):
     """Human-in-the-loop: edit state at the current (or a given) checkpoint —
     LangGraph's update_state. Follow with …/resume to continue on the edit."""
-    if graph is None or getattr(graph, "checkpointer", None) is None:
+    gr = _graph_for(graph)
+    if gr is None or getattr(gr, "checkpointer", None) is None:
         return JSONResponse({"error": "no local graph with a checkpointer"}, 400)
     body = await request.json()
     values = body.get("values")
@@ -313,8 +381,8 @@ async def api_thread_update_state(request: Request, thread_id: str):
     if body.get("checkpoint_id"):
         configurable["checkpoint_id"] = str(body["checkpoint_id"])
     try:
-        new_cfg = graph.update_state({"configurable": configurable}, values,
-                                     as_node=body.get("as_node"))
+        new_cfg = gr.update_state({"configurable": configurable}, values,
+                                  as_node=body.get("as_node"))
         return JSONResponse({"ok": True, "checkpoint_id":
                              (new_cfg.get("configurable") or {}).get("checkpoint_id")})
     except Exception as e:
@@ -415,8 +483,9 @@ def api_node(name: str, limit: int = 25):
 
 
 @app.get("/api/nodes/{name}/source")
-def api_node_source(name: str):
-    src = TOPO.sources().get(name)
+def api_node_source(name: str, graph: str = None):
+    tp = _topo_for(graph)
+    src = (tp.sources() if tp else {}).get(name)
     if src:
         return JSONResponse(src)
     return JSONResponse({"error": "no source available for this node "
@@ -424,14 +493,15 @@ def api_node_source(name: str):
 
 
 @app.get("/api/threads/{thread_id}/history")
-def api_thread_history(thread_id: str, limit: int = 80):
+def api_thread_history(thread_id: str, limit: int = 80, graph: str = None):
     """Time-travel: LangGraph checkpoint history for a thread (local graph
     with a checkpointer only)."""
-    if graph is None or getattr(graph, "checkpointer", None) is None:
+    gr = _graph_for(graph)
+    if gr is None or getattr(gr, "checkpointer", None) is None:
         return JSONResponse({"error": "no local graph with a checkpointer"}, 404)
     steps = []
     try:
-        for st in graph.get_state_history({"configurable": {"thread_id": thread_id}}):
+        for st in gr.get_state_history({"configurable": {"thread_id": thread_id}}):
             md = st.metadata or {}
             steps.append({
                 "checkpoint_id": ((st.config or {}).get("configurable") or {}).get("checkpoint_id"),
@@ -450,9 +520,10 @@ def api_thread_history(thread_id: str, limit: int = 80):
 
 
 @app.get("/api/memory/namespaces")
-def api_memory_namespaces():
+def api_memory_namespaces(graph: str = None):
     """LangGraph long-term memory (Store) browser — namespaces."""
-    st = getattr(graph, "store", None) if graph is not None else None
+    gr = _graph_for(graph)
+    st = getattr(gr, "store", None) if gr is not None else None
     if st is None:
         return JSONResponse({"error": "no local graph with a store"}, 404)
     try:
@@ -462,9 +533,11 @@ def api_memory_namespaces():
 
 
 @app.get("/api/memory/items")
-def api_memory_items(namespace: str, query: str = None, limit: int = 50):
+def api_memory_items(namespace: str, query: str = None, limit: int = 50,
+                     graph: str = None):
     """Items in one namespace (dot-separated); optional semantic/text query."""
-    st = getattr(graph, "store", None) if graph is not None else None
+    gr = _graph_for(graph)
+    st = getattr(gr, "store", None) if gr is not None else None
     if st is None:
         return JSONResponse({"error": "no local graph with a store"}, 404)
     try:
@@ -516,10 +589,12 @@ def _expected_score(expected, output) -> float:
 
 
 @app.post("/api/datasets/{ds_id}/run")
-def api_dataset_run(ds_id: str):
+def api_dataset_run(ds_id: str, graph: str = None):
     """Batch-eval: run the local graph over every dataset item; expected values
     become an expected_match score on each run. Fire-and-forget worker."""
-    if graph is None:
+    gname = graph or _default_name()
+    gr = _graph_for(gname)
+    if gr is None:
         return JSONResponse({"error": "no local graph (WINDHOVER_GRAPH unset)"}, 400)
     ds = store.dataset(ds_id)
     if not ds:
@@ -528,13 +603,13 @@ def api_dataset_run(ds_id: str):
 
     def worker():
         for i, item in enumerate(ds["items"]):
-            tracer = SpanBuilder(db_sink(store), run_name=cfg.graph_ref,
+            tracer = SpanBuilder(db_sink(store), run_name=gname,
                                  session=session, tags=[f"dataset:{ds['name']}"])
             config = {"callbacks": [tracer]}
-            if getattr(graph, "checkpointer", None) is not None:
+            if getattr(gr, "checkpointer", None) is not None:
                 config["configurable"] = {"thread_id": tracer.run_id}
             try:
-                out = graph.invoke(dict(item["input"]), config=config)
+                out = gr.invoke(dict(item["input"]), config=config)
             except Exception:
                 continue  # tracer already recorded the error run
             if "expected" in item:
@@ -556,12 +631,14 @@ async def api_events(request: Request):
     async def gen():
         import asyncio
         seen = -1
-        yield _sse("hello", {"version": TOPO.version})
+        def _ver():
+            return sum(tp.version for tp in TOPOS.values())
+        yield _sse("hello", {"version": _ver()})
         while True:
             if await request.is_disconnected():
                 break
-            if TOPO.version != seen:
-                seen = TOPO.version
+            if _ver() != seen:
+                seen = _ver()
                 yield _sse("topology", {"version": seen})
             else:
                 yield ": ping\n\n"

{windhover-0.12.0 → windhover-0.14.0}/windhover/static/index.html

@@ -149,7 +149,7 @@ window.resumeThread=async(tid)=>{
   const raw=document.getElementById('hitl-val').value.trim();
   const body={}; const v=parseMaybeJSON(raw); if(v!==undefined) body.value=v;
   closeAll(); switchView('graph'); toast('Resuming thread '+tid.slice(0,8)+'…');
-  const res=await fetch('/api/threads/'+encodeURIComponent(tid)+'/resume',
+  const res=await fetch('/api/threads/'+encodeURIComponent(tid)+'/resume?'+rgparam(),
     {method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify(body)});
   if(!res.ok){ toast((await res.json()).error||'resume failed'); return; }
   await consumeRunStream(res);
@@ -157,14 +157,14 @@ window.resumeThread=async(tid)=>{
 window.resumeGoto=async(tid)=>{
   const g=document.getElementById('hitl-goto').value; if(!g) return toast('Pick a node first');
   closeAll(); switchView('graph'); toast('Redirecting thread to '+g+'…');
-  const res=await fetch('/api/threads/'+encodeURIComponent(tid)+'/resume',
+  const res=await fetch('/api/threads/'+encodeURIComponent(tid)+'/resume?'+rgparam(),
     {method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({goto:g})});
   if(!res.ok){ toast((await res.json()).error||'resume failed'); return; }
   await consumeRunStream(res);
 };
 window.rerunFrom=async(tid,cid)=>{
   closeAll(); switchView('graph'); toast('Forking from checkpoint '+String(cid).slice(-8)+'…');
-  const res=await fetch('/api/threads/'+encodeURIComponent(tid)+'/resume',
+  const res=await fetch('/api/threads/'+encodeURIComponent(tid)+'/resume?'+rgparam(),
     {method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({checkpoint_id:cid})});
   if(!res.ok){ toast((await res.json()).error||'fork failed'); return; }
   await consumeRunStream(res);
@@ -174,7 +174,7 @@ window.editState=async(tid,cid,valuesJson)=>{
   if(cur==null) return;
   let values; try{ values=JSON.parse(cur); }catch(e){ return toast('Invalid JSON'); }
   const body={values}; if(cid) body.checkpoint_id=cid;
-  const res=await fetch('/api/threads/'+encodeURIComponent(tid)+'/state',
+  const res=await fetch('/api/threads/'+encodeURIComponent(tid)+'/state?'+rgparam(),
     {method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify(body)});
   const d=await res.json();
   if(!res.ok) return toast(d.error||'update_state failed');
@@ -184,7 +184,7 @@ window.editState=async(tid,cid,valuesJson)=>{
 
 /* ---------- time-travel (checkpoint history) ---------- */
 window.showHistory=async(tid)=>{
-  let d=null; try{ const r=await fetch('/api/threads/'+encodeURIComponent(tid)+'/history');
+  let d=null; try{ const r=await fetch('/api/threads/'+encodeURIComponent(tid)+'/history?'+rgparam());
     d=await r.json(); if(!r.ok) return toast(d.error||'history unavailable'); }catch(e){ return toast('history unavailable'); }
   const steps=d.steps||[];
   $('#d-title').textContent='thread '+tid.slice(0,10)+' · time-travel';
@@ -398,6 +398,8 @@ aside{background:var(--rail);border-right:1px solid var(--rail-line)}
 .crumb{font-family:var(--display);font-weight:600;font-size:17px;letter-spacing:.005em}
 .pill{font-family:var(--mono);letter-spacing:.02em}
 .plabel{font-size:9.5px;letter-spacing:.14em;text-transform:uppercase;color:var(--muted)}
+#gsel{background:transparent;border:none;color:var(--text2);font:inherit;outline:none;cursor:pointer;max-width:260px}
+#gsel option{background:var(--surface);color:var(--text)}
 .page-head h1{font-family:var(--display);font-weight:600;letter-spacing:.005em}
 .page-head h1::after{content:"";display:block;width:52px;height:4px;margin-top:7px;
   background:repeating-linear-gradient(90deg,var(--rufous) 0 7px,transparent 7px 13px)}
@@ -459,13 +461,13 @@ th{font-family:var(--mono);letter-spacing:.11em;font-size:10.5px}
       <button data-v="memory" id="nav-mem" style="display:none">${ICON.mem} Memory</button>
       <button data-v="stats">${ICON.chart} Stats</button>
     </nav>
-    <div class="side-foot"><span class="live-dot" id="live-dot" title="live topology"></span><span id="foot-note">watching</span><span class="spacer"></span><span class="mono" id="ver">v0.12</span></div>
+    <div class="side-foot"><span class="live-dot" id="live-dot" title="live topology"></span><span id="foot-note">watching</span><span class="spacer"></span><span class="mono" id="ver">v0.14</span></div>
   </aside>
 
   <main>
     <div class="topbar">
       <span class="crumb" id="crumb">Graph</span>
-      <span class="pill" id="gpill"><span class="live-dot"></span><span class="plabel">graph</span><span id="gname">—</span></span>
+      <span class="pill" id="gpill"><span class="live-dot"></span><span class="plabel">graph</span><span id="gname">—</span><select id="gsel" style="display:none"></select></span>
       <div class="spacer"></div>
       <button class="icon-btn" id="theme" title="theme">${ICON.moon}</button>
       <button class="btn primary" id="newrun">${ICON.play} New run</button>
@@ -491,6 +493,7 @@ th{font-family:var(--mono);letter-spacing:.11em;font-size:10.5px}
           <div class="page-head"><h1>Runs</h1><span class="sub" id="runs-sub"></span></div>
           <div class="rtools">
             <input type="search" id="rq" placeholder="Search payloads, prompts, errors…">
+            <select id="rgraph" style="display:none"></select>
             <select id="rstatus"><option value="">All statuses</option>
               <option value="done">done</option><option value="error">error</option>
               <option value="interrupted">interrupted</option>
@@ -628,10 +631,31 @@ function cyStyle(){ return [
 function applyCyStyle(){ cy.style(cyStyle()); }
 
 /* ---------- graph ---------- */
+let GSEL=localStorage.getItem('wh-graph')||'';
+async function loadGraphList(){
+  try{
+    const d=await(await fetch('/api/graphs')).json();
+    window.__graphList=d.graphs||[];
+    if(!window.__graphList.includes(GSEL)) GSEL=d.default||'';
+    const sel=$('#gsel');
+    if(window.__graphList.length>1){
+      sel.style.display=''; $('#gname').style.display='none';
+      sel.innerHTML=window.__graphList.map(g=>`<option ${g===GSEL?'selected':''}>${esc(g)}</option>`).join('');
+      sel.onchange=()=>{ GSEL=sel.value; localStorage.setItem('wh-graph',GSEL);
+        loadGraph(true); probeMemory(); if(VIEW==='memory') loadMemory(); };
+      const rg=$('#rgraph');
+      if(rg){ rg.style.display='';
+        rg.innerHTML='<option value="">All graphs</option>'+window.__graphList.map(g=>`<option>${esc(g)}</option>`).join('');
+        rg.onchange=e=>{RF.graph=e.target.value;RF.offset=0;loadRuns();}; }
+    }
+  }catch(e){}
+}
+function gparam(pfx){ return GSEL?pfx+'graph='+encodeURIComponent(GSEL):''; }
+function rgparam(){ const g=(window.__run||{}).graph||GSEL; return g?'graph='+encodeURIComponent(g):''; }
 let XRAY=false;
 window.toggleXray=()=>{ XRAY=!XRAY; const b=$('#xray'); if(b)b.classList.toggle('on',XRAY); loadGraph(true); };
 async function loadGraph(force){
-  const t=await(await fetch('/api/graph')).json();
+  const t=await(await fetch('/api/graph?'+gparam(''))).json();
   $('#gname').textContent=t.graph||'ingest-only';
   const xb=$('#xray'); if(xb) xb.style.display=t.xray?'':'none';
   if(!t.nodes.length){ $('#view-graph').innerHTML='<div class="empty" style="padding-top:120px"><div class="t">No local graph configured</div>Set <span class="mono">WINDHOVER_GRAPH</span>, or trace runs in from your app and open Runs.</div>'; return; }
@@ -696,7 +720,7 @@ function codeBlock(src,hi){ const lines=src.code.replace(/\n$/,'').split('\n');
 /* ---------- node pane (tap a node on the graph) ---------- */
 async function openNode(name){
   let d={}; try{ d=await(await fetch('/api/nodes/'+encodeURIComponent(name))).json(); }catch(e){}
-  let src=null; try{ const rs=await fetch('/api/nodes/'+encodeURIComponent(name)+'/source');
+  let src=null; try{ const rs=await fetch('/api/nodes/'+encodeURIComponent(name)+'/source?'+gparam(''));
     if(rs.ok) src=await rs.json(); }catch(e){}
   const s=d.summary||{}, errs=s.errors||0;
   $('#d-title').textContent=name;
@@ -771,7 +795,7 @@ function switchView(v){ VIEW=v;
 $$('.nav button,.bottom-nav button').forEach(b=>b.onclick=()=>switchView(b.dataset.v));
 
 /* ---------- new run ---------- */
-$('#newrun').onclick=async()=>{ let tpl={},ctx={},cs={}; try{const sd=await(await fetch('/api/schema')).json(); tpl=sd.template||{}; ctx=sd.context_template||{}; cs=sd.context_schema||{};}catch(e){}
+$('#newrun').onclick=async()=>{ let tpl={},ctx={},cs={}; try{const sd=await(await fetch('/api/schema?'+gparam(''))).json(); tpl=sd.template||{}; ctx=sd.context_template||{}; cs=sd.context_schema||{};}catch(e){}
   $('#input-json').value=JSON.stringify(tpl,null,2);
   const cw=document.getElementById('ctx-wrap');
   if(cw){ const has=cs&&cs.properties&&Object.keys(cs.properties).length;
@@ -785,6 +809,7 @@ $('#do-run').onclick=async()=>{ let input; try{input=JSON.parse($('#input-json')
   const sess=$('#run-session').value.trim();
   const tags=$('#run-tags').value.split(',').map(s=>s.trim()).filter(Boolean);
   if(sess)input._session=sess; if(tags.length)input._tags=tags;
+  if(GSEL) input._graph=GSEL;
   const paused=[...document.querySelectorAll('.pause-chip.on')].map(e=>e.dataset.n);
   if(paused.length) input._interrupt_before=paused;
   const cw=document.getElementById('ctx-wrap');
@@ -813,11 +838,11 @@ async function runNow(input){
 }
 
 /* ---------- runs table (filters + pagination) ---------- */
-const RF={q:'',status:'',tag:'',bookmarked:false,session:'',offset:0,limit:50};
+const RF={q:'',status:'',tag:'',bookmarked:false,session:'',graph:'',offset:0,limit:50};
 function runParams(){ const p=new URLSearchParams();
   if(RF.q)p.set('q',RF.q); if(RF.status)p.set('status',RF.status);
   if(RF.tag)p.set('tag',RF.tag); if(RF.bookmarked)p.set('bookmarked','1');
-  if(RF.session)p.set('session',RF.session); return p; }
+  if(RF.session)p.set('session',RF.session); if(RF.graph)p.set('graph',RF.graph); return p; }
 async function loadRuns(){
   const p=runParams(); p.set('limit',RF.limit); p.set('offset',RF.offset);
   const d=await(await fetch('/api/runs?'+p)).json();
@@ -1038,7 +1063,7 @@ window.resumeThread=async(tid)=>{
   const raw=document.getElementById('hitl-val').value.trim();
   const body={}; const v=parseMaybeJSON(raw); if(v!==undefined) body.value=v;
   closeAll(); switchView('graph'); toast('Resuming thread '+tid.slice(0,8)+'…');
-  const res=await fetch('/api/threads/'+encodeURIComponent(tid)+'/resume',
+  const res=await fetch('/api/threads/'+encodeURIComponent(tid)+'/resume?'+rgparam(),
     {method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify(body)});
   if(!res.ok){ toast((await res.json()).error||'resume failed'); return; }
   await consumeRunStream(res);
@@ -1046,14 +1071,14 @@ window.resumeThread=async(tid)=>{
 window.resumeGoto=async(tid)=>{
   const g=document.getElementById('hitl-goto').value; if(!g) return toast('Pick a node first');
   closeAll(); switchView('graph'); toast('Redirecting thread to '+g+'…');
-  const res=await fetch('/api/threads/'+encodeURIComponent(tid)+'/resume',
+  const res=await fetch('/api/threads/'+encodeURIComponent(tid)+'/resume?'+rgparam(),
     {method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({goto:g})});
   if(!res.ok){ toast((await res.json()).error||'resume failed'); return; }
   await consumeRunStream(res);
 };
 window.rerunFrom=async(tid,cid)=>{
   closeAll(); switchView('graph'); toast('Forking from checkpoint '+String(cid).slice(-8)+'…');
-  const res=await fetch('/api/threads/'+encodeURIComponent(tid)+'/resume',
+  const res=await fetch('/api/threads/'+encodeURIComponent(tid)+'/resume?'+rgparam(),
     {method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({checkpoint_id:cid})});
   if(!res.ok){ toast((await res.json()).error||'fork failed'); return; }
   await consumeRunStream(res);
@@ -1063,7 +1088,7 @@ window.editState=async(tid,cid,valuesJson)=>{
   if(cur==null) return;
   let values; try{ values=JSON.parse(cur); }catch(e){ return toast('Invalid JSON'); }
   const body={values}; if(cid) body.checkpoint_id=cid;
-  const res=await fetch('/api/threads/'+encodeURIComponent(tid)+'/state',
+  const res=await fetch('/api/threads/'+encodeURIComponent(tid)+'/state?'+rgparam(),
     {method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify(body)});
   const d=await res.json();
   if(!res.ok) return toast(d.error||'update_state failed');
@@ -1073,7 +1098,7 @@ window.editState=async(tid,cid,valuesJson)=>{
 
 /* ---------- time-travel (checkpoint history) ---------- */
 window.showHistory=async(tid)=>{
-  let d=null; try{ const r=await fetch('/api/threads/'+encodeURIComponent(tid)+'/history');
+  let d=null; try{ const r=await fetch('/api/threads/'+encodeURIComponent(tid)+'/history?'+rgparam());
     d=await r.json(); if(!r.ok) return toast(d.error||'history unavailable'); }catch(e){ return toast('history unavailable'); }
   const steps=d.steps||[];
   $('#d-title').textContent='thread '+tid.slice(0,10)+' · time-travel';
@@ -1199,7 +1224,7 @@ let tT; function toast(m){ const t=$('#toast'); t.textContent=m; t.classList.add
 
 let MEM_NS=[];
 async function probeMemory(){
-  try{ const r=await fetch('/api/memory/namespaces'); if(!r.ok) return;
+  try{ const r=await fetch('/api/memory/namespaces?'+gparam('')); if(!r.ok){ document.getElementById('nav-mem').style.display='none'; return; }
     MEM_NS=(await r.json()).namespaces||[];
     document.getElementById('nav-mem').style.display='';
     const m=document.querySelector('.bottom-nav .nav-mem'); if(m)m.style.display='';
@@ -1207,7 +1232,7 @@ async function probeMemory(){
 }
 async function loadMemory(){
   const sel=document.getElementById('mem-ns');
-  try{ const r=await fetch('/api/memory/namespaces'); MEM_NS=(await r.json()).namespaces||[]; }catch(e){}
+  try{ const r=await fetch('/api/memory/namespaces?'+gparam('')); MEM_NS=(await r.json()).namespaces||[]; }catch(e){}
   const cur=sel.value;
   sel.innerHTML=MEM_NS.map(ns=>`<option value="${esc(ns.join('.'))}">${esc(ns.join(' / '))}</option>`).join('');
   if(cur) sel.value=cur;
@@ -1215,7 +1240,7 @@ async function loadMemory(){
   const w=document.getElementById('mem-wrap');
   if(!ns){ w.innerHTML='<div class="empty"><div class="t">No memories yet</div>Nodes write with <span class="mono">get_store().put(namespace, key, value)</span> — items appear here.</div>'; return; }
   const q=document.getElementById('mem-q').value.trim();
-  const p=new URLSearchParams({namespace:ns}); if(q)p.set('query',q);
+  const p=new URLSearchParams({namespace:ns}); if(q)p.set('query',q); if(GSEL)p.set('graph',GSEL);
   let d={items:[]}; try{ d=await(await fetch('/api/memory/items?'+p)).json(); }catch(e){}
   w.innerHTML=(d.items||[]).length?`<div style="overflow:auto"><table>
     <thead><tr><th>Key</th><th>Value</th><th class="r">Updated</th></tr></thead>
@@ -1240,13 +1265,13 @@ async function loadDatasets(){
     :`<div class="empty" style="padding:14px"><div class="t">No datasets yet</div>POST <span class="mono">/api/datasets</span> with <span class="mono">{name, items:[{input:{…}, expected:…}]}</span> — runs land in a session with an <span class="mono">expected_match</span> score per item.</div>`;
 }
 window.runDataset=async(id,name)=>{
-  const r=await fetch('/api/datasets/'+id+'/run',{method:'POST'});
+  const r=await fetch('/api/datasets/'+id+'/run?'+gparam(''),{method:'POST'});
   const d=await r.json();
   if(!r.ok) return toast(d.error||'eval failed to start');
   toast('Eval started: '+d.items+' items → session '+d.session);
 };
 window.delDataset=async(id)=>{ await fetch('/api/datasets/'+id,{method:'DELETE'}); loadDatasets(); };
-loadGraph(); liveTopology(); probeMemory();
+loadGraphList().then(()=>{ loadGraph(); probeMemory(); }); liveTopology();
 /* deep links: #runs #sessions #stats #run=<id> */
 (function(){ const h=location.hash.slice(1);
   if(h==='runs'||h==='sessions'||h==='stats') switchView(h);

{windhover-0.12.0 → windhover-0.14.0}/windhover/store.py

@@ -27,6 +27,7 @@ class Store:
         self.path = path
         self.has_fts = False
         self.has_json1 = False
+        self.on_run_closed = None   # optional hook(run_dict) — used for webhooks
         self._init()
 
     def _conn(self) -> sqlite3.Connection:
@@ -171,6 +172,12 @@ class Store:
                 WHERE id=?""",
                 (status, ended_ms, ended_ms - started, error, agg["nc"], agg["lc"],
                  pt, ct, (pt or 0) + (ct or 0) if (pt or ct) else None, agg["cost"], run_id))
+        if self.on_run_closed is not None:
+            try:
+                self.on_run_closed({"id": run_id, "status": status, "error": error,
+                                    "duration_ms": ended_ms - started})
+            except Exception:
+                pass
 
     def update_run_meta(self, run_id: str, tags: Optional[list] = None,
                         bookmarked: Optional[bool] = None) -> bool:

{windhover-0.12.0 → windhover-0.14.0}/windhover/tracer.py

@@ -456,19 +456,48 @@ def db_sink(store) -> Callable[[dict], None]:
     return lambda ev: apply_to_store(store, ev, source="ui")
 
 
-def http_sink(base_url: str) -> Callable[[dict], None]:
-    import urllib.request
+def http_sink(base_url: str, token: Optional[str] = None,
+              max_queue: int = 2000) -> Callable[[dict], None]:
+    """Non-blocking: events go onto a bounded queue drained by a daemon thread,
+    so a slow or unreachable Windhover host NEVER adds latency to the traced
+    app. On overflow the oldest events are dropped (observability is
+    best-effort; the app comes first)."""
+    import queue as _q, threading as _t, urllib.request
     url = base_url.rstrip("/") + "/api/ingest"
+    headers = {"Content-Type": "application/json"}
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+    buf: "_q.Queue" = _q.Queue(maxsize=max_queue)
+
+    def _drain():
+        while True:
+            ev = buf.get()
+            try:
+                req = urllib.request.Request(url, data=json.dumps(ev).encode(),
+                                             headers=headers)
+                urllib.request.urlopen(req, timeout=5)
+            except Exception:
+                pass  # drop — never retry-storm a down collector
+
+    _t.Thread(target=_drain, daemon=True).start()
 
     def sink(ev: dict) -> None:
-        req = urllib.request.Request(url, data=json.dumps(ev).encode(),
-                                     headers={"Content-Type": "application/json"})
-        urllib.request.urlopen(req, timeout=3)
+        try:
+            buf.put_nowait(ev)
+        except _q.Full:
+            try:
+                buf.get_nowait()          # shed oldest, keep newest
+                buf.put_nowait(ev)
+            except Exception:
+                pass
     return sink
 
 
 class WindhoverTracer(SpanBuilder):
-    """Drop into any app: config={"callbacks": [WindhoverTracer("http://host:8090")]}."""
+    """Drop into any app: config={"callbacks": [WindhoverTracer("http://host:8090")]}.
+    Non-blocking; pass token= when the collector sets WINDHOVER_TOKEN."""
     def __init__(self, base_url: str, name: str = "external",
-                 session: Optional[str] = None, tags: Optional[list] = None):
-        super().__init__(http_sink(base_url), run_name=name, session=session, tags=tags)
+                 session: Optional[str] = None, tags: Optional[list] = None,
+                 token: Optional[str] = None):
+        super().__init__(http_sink(base_url, token=token),
+                         run_name=name, session=session, tags=tags)

windhover-0.12.0/windhover/config.py

@@ -1,61 +0,0 @@
-"""Windhover configuration — one place, read from the environment."""
-from __future__ import annotations
-import os
-from dataclasses import dataclass
-from pathlib import Path
-
-PKG_DIR = Path(__file__).resolve().parent
-
-
-@dataclass(frozen=True)
-class Config:
-    graph_ref: str            # "module:attr" of a compiled graph ("" = ingest-only)
-    graph_dir: str            # import path for the graph module
-    db_path: str
-    host: str
-    port: int
-    watch: bool               # live-topology file watcher
-    pricing_path: str
-    retention_days: int       # 0 = keep runs forever
-    token: str                # WINDHOVER_TOKEN: require Bearer/query token on /api ("" = open)
-
-    @staticmethod
-    def _discover() -> tuple[str, str]:
-        """No WINDHOVER_GRAPH? Look for a langgraph.json (LangGraph's standard
-        project file) in WINDHOVER_GRAPH_DIR / cwd and use its first graph.
-        Returns (graph_ref, graph_dir) or ("", dir)."""
-        import json as _json
-        base = os.environ.get("WINDHOVER_GRAPH_DIR", os.getcwd())
-        cfg_path = os.path.join(base, "langgraph.json")
-        try:
-            graphs = _json.loads(open(cfg_path).read()).get("graphs") or {}
-            for _name, ref in graphs.items():
-                path, _, attr = str(ref).partition(":")
-                if not attr:
-                    continue
-                if path.endswith(".py"):
-                    full = os.path.normpath(os.path.join(base, path))
-                    return (f"{os.path.splitext(os.path.basename(full))[0]}:{attr}",
-                            os.path.dirname(full))
-                return f"{path}:{attr}", base   # already module:attr
-        except Exception:
-            pass
-        return "", base
-
-    @classmethod
-    def from_env(cls) -> "Config":
-        graph_ref = os.environ.get("WINDHOVER_GRAPH", "")
-        graph_dir = os.environ.get("WINDHOVER_GRAPH_DIR", os.getcwd())
-        if not graph_ref:
-            graph_ref, graph_dir = cls._discover()
-        return cls(
-            graph_ref=graph_ref,
-            graph_dir=graph_dir,
-            db_path=os.environ.get("WINDHOVER_DB", str(PKG_DIR.parent / "windhover.db")),
-            host=os.environ.get("WINDHOVER_HOST", "0.0.0.0"),
-            port=int(os.environ.get("WINDHOVER_PORT", "8090")),
-            watch=os.environ.get("WINDHOVER_WATCH", "1") not in ("0", "false", "no"),
-            pricing_path=os.environ.get("WINDHOVER_PRICING", str(PKG_DIR / "pricing.json")),
-            retention_days=int(os.environ.get("WINDHOVER_RETENTION_DAYS", "0") or 0),
-            token=os.environ.get("WINDHOVER_TOKEN", ""),
-        )