windhover 0.13.0__tar.gz → 0.14.1__tar.gz

{windhover-0.13.0 → windhover-0.14.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: windhover
-Version: 0.13.0
+Version: 0.14.1
 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
@@ -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.13.0 → windhover-0.14.1}/README.md

@@ -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.13.0 → windhover-0.14.1}/docs/GUIDE.md

@@ -57,7 +57,13 @@ 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 **everything** — canvas, New run,
+node source, Memory, Runs, Sessions, Stats (so per-node latency and model usage never mix
+graphs). The Runs page keeps an "All graphs" override in its own 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

{windhover-0.13.0 → windhover-0.14.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "windhover"
-version = "0.13.0"
+version = "0.14.1"
 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.13.0 → windhover-0.14.1}/tests/test_smoke.py

@@ -555,22 +555,61 @@ 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_graph_scoped_stats_and_sessions():
+    p = tempfile.mktemp(suffix=".db")
+    s = Store(p)
+    now = int(time.time() * 1000)
+    for i, g in enumerate(("alpha", "alpha", "beta")):
+        rid = f"g{i}"
+        s.open_run({"id": rid, "graph": g, "session": f"sess-{g}", "started_ms": now - i})
+        s.add_span({"id": f"s{i}", "run_id": rid, "type": "node", "name": "shared_name",
+                    "seq": 0, "dur_ms": 100 * (i + 1)})
+        s.add_span({"id": f"l{i}", "run_id": rid, "type": "llm", "name": "m", "seq": 1,
+                    "model": f"model-{g}", "dur_ms": 5, "prompt_tokens": 10,
+                    "completion_tokens": 1})
+        s.close_run(rid, "done", now + 10)
+    st_a = s.stats(graph="alpha")
+    assert st_a["totals"]["runs"] == 2
+    assert st_a["per_node"][0]["n"] == 2            # only alpha's spans, not beta's
+    assert [m["model"] for m in st_a["models"]] == ["model-alpha"]
+    st_all = s.stats()
+    assert st_all["totals"]["runs"] == 3 and st_all["per_node"][0]["n"] == 3
+    ses_b = s.sessions(graph="beta")
+    assert [x["session"] for x in ses_b] == ["sess-beta"]
+    assert len(s.sessions()) == 2
+    print("graph-scoped stats/sessions OK")
 
 
 def test_nonblocking_sink_and_webhook_hook():
@@ -618,5 +657,7 @@ if __name__ == "__main__":
     test_functional_api_tracing()
     test_message_serialization()
     test_langgraph_json_discovery()
+    test_env_multi_graph_parsing()
+    test_graph_scoped_stats_and_sessions()
     test_nonblocking_sink_and_webhook_hook()
     print("ALL SMOKE TESTS PASSED")

windhover-0.14.1/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.1/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.13.0 → windhover-0.14.1}/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()
 
 
@@ -149,13 +169,13 @@ def _fire_webhook(summary: dict) -> None:
             import urllib.request
             run = store.run_detail(summary["id"]) or summary
             body = {
-                "source": "windhover", "graph": run.get("graph") or cfg.graph_ref,
+                "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 cfg.graph_ref})",
+                        f" ({run.get('graph') or _default_name()})",
             }
             req = urllib.request.Request(
                 cfg.webhook, data=json.dumps(body).encode(),
@@ -179,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)})
 
@@ -197,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."""
@@ -208,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":
@@ -238,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,
@@ -270,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}
@@ -295,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()
@@ -319,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")
@@ -343,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:
@@ -376,8 +414,8 @@ def api_runs(limit: int = 50, offset: int = 0, q: str = None, status: str = None
 
 
 @app.get("/api/sessions")
-def api_sessions(limit: int = 100):
-    return JSONResponse(store.sessions(limit=limit))
+def api_sessions(limit: int = 100, graph: str = None):
+    return JSONResponse(store.sessions(limit=limit, graph=graph or None))
 
 
 @app.get("/api/runs/{run_id}")
@@ -445,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 "
@@ -454,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"),
@@ -480,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:
@@ -492,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:
@@ -546,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:
@@ -558,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:
@@ -577,8 +622,8 @@ def api_dataset_run(ds_id: str):
 
 
 @app.get("/api/stats")
-def api_stats(days: int = 30):
-    return JSONResponse(store.stats(days=max(1, min(days, 365))))
+def api_stats(days: int = 30, graph: str = None):
+    return JSONResponse(store.stats(days=max(1, min(days, 365)), graph=graph or None))
 
 
 @app.get("/api/events")
@@ -586,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.13.0 → windhover-0.14.1}/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.13</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>
@@ -523,7 +526,7 @@ th{font-family:var(--mono);letter-spacing:.11em;font-size:10.5px}
       </div>
       <div id="view-stats" style="display:none">
         <div class="page">
-          <div class="page-head"><h1>Stats</h1><span class="sub">all recorded runs</span></div>
+          <div class="page-head"><h1>Stats</h1><span class="sub" id="stats-sub">all recorded runs</span></div>
           <div id="stats-body"></div>
         </div>
       </div>
@@ -628,10 +631,39 @@ 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);
+        RF.graph=GSEL; const rg=$('#rgraph'); if(rg) rg.value=GSEL;
+        loadGraph(true); probeMemory();
+        if(VIEW==='memory') loadMemory();
+        if(VIEW==='runs') loadRuns();
+        if(VIEW==='sessions') loadSessions();
+        if(VIEW==='stats'){ loadStats(); loadDatasets(); } };
+      const rg=$('#rgraph');
+      if(rg){ rg.style.display='';
+        rg.innerHTML='<option value="">All graphs</option>'+window.__graphList.map(g=>`<option>${esc(g)}</option>`).join('');
+        RF.graph=GSEL; rg.value=GSEL;
+        rg.onchange=e=>{RF.graph=e.target.value;RF.offset=0;loadRuns();}; }
+    }
+  }catch(e){}
+}
+function multiGraph(){ return (window.__graphList||[]).length>1; }
+function gscope(){ return multiGraph()&&GSEL?'graph='+encodeURIComponent(GSEL):''; }
+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 +728,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 +803,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 +817,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 +846,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();
@@ -864,7 +897,7 @@ $('#rbook').onclick=()=>{RF.bookmarked=!RF.bookmarked;$('#rbook').classList.togg
 
 /* ---------- sessions ---------- */
 async function loadSessions(){
-  const ss=await(await fetch('/api/sessions')).json();
+  const ss=await(await fetch('/api/sessions?'+gscope())).json();
   $('#sess-sub').textContent=ss.length?`${ss.length} session${ss.length===1?'':'s'}`:'';
   if(!ss.length){ $('#sess-wrap').innerHTML='<div class="empty"><div class="t">No sessions yet</div>Pass <span class="mono">session=</span> to <span class="mono">WindhoverTracer</span>, or <span class="mono">config={"metadata": {"windhover_session": …}}</span> in any LangChain/LangGraph app.</div>'; return; }
   $('#sess-wrap').innerHTML=`<div style="overflow:auto"><table>
@@ -1038,7 +1071,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 +1079,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 +1096,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 +1106,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';
@@ -1153,11 +1186,13 @@ function chartCard(title,daily,val,errKey){
     <div class="clabels"><span>${daily[0]?.day||''}</span><span>${daily[daily.length-1]?.day||''}</span></div></div></div>`;
 }
 async function loadStats(){
-  const s=await(await fetch('/api/stats?days=30')).json(); const t=s.totals||{};
+  const s=await(await fetch('/api/stats?days=30&'+gscope())).json(); const t=s.totals||{};
   const errRate=t.runs?Math.round((t.errors||0)/t.runs*100):0;
   const max=Math.max(1,...(s.per_node||[]).map(n=>n.avg_ms||0));
   const daily=s.daily||[], models=s.models||[];
   const db=t.db_bytes!=null?(t.db_bytes/1048576).toFixed(1)+' MB db':'';
+  const ssub=document.getElementById('stats-sub');
+  if(ssub) ssub.textContent=(multiGraph()&&GSEL)?('graph: '+GSEL):'all recorded runs';
   $('#stats-body').innerHTML=`
     <div class="metrics">
       <div class="metric"><div class="v num">${t.runs||0}</div><div class="l">Total runs</div></div>
@@ -1199,7 +1234,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 +1242,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 +1250,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 +1275,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.13.0 → windhover-0.14.1}/windhover/store.py

@@ -310,14 +310,18 @@ class Store:
                     r["scores"] = sc.get(r["id"]) or None
         return {"runs": rows, "total": total, "limit": limit, "offset": offset}
 
-    def sessions(self, limit: int = 100) -> list[dict]:
+    def sessions(self, limit: int = 100, graph: Optional[str] = None) -> list[dict]:
+        cond, args = "", []
+        if graph:
+            cond = " AND graph=?"; args.append(graph)
         with _lock, self._conn() as c:
-            return [dict(r) for r in c.execute("""SELECT session,
+            return [dict(r) for r in c.execute(f"""SELECT session,
                 COUNT(*) runs, COUNT(*) FILTER (WHERE status='error') errors,
                 MIN(started_ms) first_ms, MAX(started_ms) last_ms,
                 SUM(total_tokens) tokens, SUM(cost_usd) cost, SUM(duration_ms) duration_ms
-                FROM runs WHERE session IS NOT NULL AND session!=''
-                GROUP BY session ORDER BY last_ms DESC LIMIT ?""", (limit,)).fetchall()]
+                FROM runs WHERE session IS NOT NULL AND session!=''{cond}
+                GROUP BY session ORDER BY last_ms DESC LIMIT ?""",
+                (*args, limit)).fetchall()]
 
     def run_detail(self, run_id: str) -> Optional[dict]:
         with _lock, self._conn() as c:
@@ -366,27 +370,36 @@ class Store:
                     s[f] = json.loads(s[f]) if s.get(f) else None
         return {"name": name, "summary": dict(agg), "recent": rows}
 
-    def stats(self, days: int = 30) -> dict:
+    def stats(self, days: int = 30, graph: Optional[str] = None) -> dict:
         cutoff = int((time.time() - days * 86400) * 1000)
+        rcond, rargs = ("", [])
+        scond, sargs = ("", [])
+        if graph:
+            rcond = " WHERE graph=?"; rargs = [graph]
+            scond = " AND runs.graph=?"; sargs = [graph]
         with _lock, self._conn() as c:
-            tot = c.execute("""SELECT COUNT(*) runs,
+            tot = c.execute(f"""SELECT COUNT(*) runs,
                 COUNT(*) FILTER (WHERE status='error') errors,
                 SUM(total_tokens) tokens, SUM(cost_usd) cost,
-                SUM(llm_calls) llm_calls FROM runs""").fetchone()
-            per_node = c.execute("""SELECT name, COUNT(*) n, AVG(dur_ms) avg_ms,
-                SUM(cost_usd) cost FROM spans WHERE type='node'
-                GROUP BY name ORDER BY avg_ms DESC LIMIT 20""").fetchall()
-            models = c.execute("""SELECT model, COUNT(*) calls,
-                SUM(prompt_tokens) prompt_tokens, SUM(completion_tokens) completion_tokens,
-                SUM(cost_usd) cost, AVG(dur_ms) avg_ms
-                FROM spans WHERE type='llm' AND model IS NOT NULL
-                GROUP BY model ORDER BY calls DESC LIMIT 20""").fetchall()
-            daily = c.execute("""SELECT
+                SUM(llm_calls) llm_calls FROM runs{rcond}""", rargs).fetchone()
+            per_node = c.execute(f"""SELECT spans.name, COUNT(*) n,
+                AVG(spans.dur_ms) avg_ms, SUM(spans.cost_usd) cost
+                FROM spans JOIN runs ON runs.id = spans.run_id
+                WHERE spans.type='node'{scond}
+                GROUP BY spans.name ORDER BY avg_ms DESC LIMIT 20""", sargs).fetchall()
+            models = c.execute(f"""SELECT spans.model, COUNT(*) calls,
+                SUM(spans.prompt_tokens) prompt_tokens,
+                SUM(spans.completion_tokens) completion_tokens,
+                SUM(spans.cost_usd) cost, AVG(spans.dur_ms) avg_ms
+                FROM spans JOIN runs ON runs.id = spans.run_id
+                WHERE spans.type='llm' AND spans.model IS NOT NULL{scond}
+                GROUP BY spans.model ORDER BY calls DESC LIMIT 20""", sargs).fetchall()
+            daily = c.execute(f"""SELECT
                 strftime('%Y-%m-%d', started_ms/1000, 'unixepoch') day,
                 COUNT(*) runs, COUNT(*) FILTER (WHERE status='error') errors,
                 SUM(total_tokens) tokens, SUM(cost_usd) cost
-                FROM runs WHERE started_ms >= ?
-                GROUP BY day ORDER BY day""", (cutoff,)).fetchall()
+                FROM runs WHERE started_ms >= ?{' AND graph=?' if graph else ''}
+                GROUP BY day ORDER BY day""", (cutoff, *rargs)).fetchall()
         try:
             db_bytes = os.path.getsize(self.path)
         except OSError:
@@ -395,4 +408,4 @@ class Store:
                 "per_node": [dict(r) for r in per_node],
                 "models": [dict(r) for r in models],
                 "daily": [dict(r) for r in daily],
-                "days": days}
+                "days": days, "graph": graph}

windhover-0.13.0/windhover/config.py

@@ -1,63 +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)
-    webhook: str              # WINDHOVER_WEBHOOK: POST run summaries on error/interrupted ("" = off)
-
-    @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", ""),
-            webhook=os.environ.get("WINDHOVER_WEBHOOK", ""),
-        )