windhover 0.14.1__tar.gz → 0.14.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: windhover
-Version: 0.14.1
+Version: 0.14.3
 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
@@ -117,6 +117,11 @@ graph.invoke(input, config={
 - **Run history + replay** — SQLite; runs persist even if the browser closes (worker thread).
 - **Living graph** — file watcher re-extracts topology in a subprocess and pushes it to the UI.
 - **Dashboards** — runs/tokens per day, per-model usage and latency, per-node latency, error rate.
+- **Multi-graph** — serve every graph in your project behind one URL; a top-bar selector
+  scopes all views (runs, sessions, stats included — metrics never mix graphs).
+- **Alerts** — `WINDHOVER_WEBHOOK` pushes a JSON summary when a run errors or pauses.
+- **Never slows your app** — the remote tracer is non-blocking (bounded queue; drops
+  rather than delays when the collector is down).
 - **Mobile-first PWA**, light/dark. Fully local (FastAPI + Cytoscape.js).
 
 ## Datasets API
@@ -135,11 +140,13 @@ curl -X POST :8090/api/runs/RUN_ID/scores -H 'Content-Type: application/json' \
 ```
 
 ## Config (env)
-`WINDHOVER_GRAPH` (module:attr; unset = ingest-only) · `WINDHOVER_GRAPH_DIR` · `WINDHOVER_DB`
+`WINDHOVER_GRAPH` (`module:attr`, or a comma list `name=module:attr,…`; unset = langgraph.json
+discovery, else ingest-only) · `WINDHOVER_GRAPH_DIR` · `WINDHOVER_DB`
 · `WINDHOVER_HOST`/`WINDHOVER_PORT` (0.0.0.0/8090) · `WINDHOVER_WATCH` (1) · `WINDHOVER_PRICING`
 · `WINDHOVER_RETENTION_DAYS` (0 = keep forever; else prune older runs on startup + every 6h)
 · `WINDHOVER_TOKEN` (set to require `Authorization: Bearer <token>` — or `?token=` — on all
-`/api` routes; the UI prompts once and remembers it).
+`/api` routes; the UI prompts once and remembers it)
+· `WINDHOVER_WEBHOOK` (POST a JSON alert whenever a run errors or pauses on an interrupt).
 Edit `windhover/pricing.json` for your models' $/1M rates (unknown model → cost null).
 
 ## Docs

{windhover-0.14.1 → windhover-0.14.3}/README.md

@@ -98,6 +98,11 @@ graph.invoke(input, config={
 - **Run history + replay** — SQLite; runs persist even if the browser closes (worker thread).
 - **Living graph** — file watcher re-extracts topology in a subprocess and pushes it to the UI.
 - **Dashboards** — runs/tokens per day, per-model usage and latency, per-node latency, error rate.
+- **Multi-graph** — serve every graph in your project behind one URL; a top-bar selector
+  scopes all views (runs, sessions, stats included — metrics never mix graphs).
+- **Alerts** — `WINDHOVER_WEBHOOK` pushes a JSON summary when a run errors or pauses.
+- **Never slows your app** — the remote tracer is non-blocking (bounded queue; drops
+  rather than delays when the collector is down).
 - **Mobile-first PWA**, light/dark. Fully local (FastAPI + Cytoscape.js).
 
 ## Datasets API
@@ -116,11 +121,13 @@ curl -X POST :8090/api/runs/RUN_ID/scores -H 'Content-Type: application/json' \
 ```
 
 ## Config (env)
-`WINDHOVER_GRAPH` (module:attr; unset = ingest-only) · `WINDHOVER_GRAPH_DIR` · `WINDHOVER_DB`
+`WINDHOVER_GRAPH` (`module:attr`, or a comma list `name=module:attr,…`; unset = langgraph.json
+discovery, else ingest-only) · `WINDHOVER_GRAPH_DIR` · `WINDHOVER_DB`
 · `WINDHOVER_HOST`/`WINDHOVER_PORT` (0.0.0.0/8090) · `WINDHOVER_WATCH` (1) · `WINDHOVER_PRICING`
 · `WINDHOVER_RETENTION_DAYS` (0 = keep forever; else prune older runs on startup + every 6h)
 · `WINDHOVER_TOKEN` (set to require `Authorization: Bearer <token>` — or `?token=` — on all
-`/api` routes; the UI prompts once and remembers it).
+`/api` routes; the UI prompts once and remembers it)
+· `WINDHOVER_WEBHOOK` (POST a JSON alert whenever a run errors or pauses on an interrupt).
 Edit `windhover/pricing.json` for your models' $/1M rates (unknown model → cost null).
 
 ## Docs

{windhover-0.14.1 → windhover-0.14.3}/SPEC.md

@@ -1,4 +1,4 @@
-# Windhover — engineering spec (current as of v0.11)
+# Windhover — engineering spec (current as of v0.14)
 
 Self-hosted LangGraph/LangChain observability + human-in-the-loop console.
 Code is the only source of truth; Windhover observes and, for HITL, drives the
@@ -22,22 +22,36 @@ breakpoints, update_state, checkpoint forking). No visual editing, ever.
 ## Architecture
 - **FastAPI + SSE** (no websockets). Single-file UI (`static/index.html`) +
   vendored cytoscape/dagre/fonts.
+- **Multi-graph registry**: `WINDHOVER_GRAPH` comma list (`name=module:attr`)
+  or every graph in `langgraph.json`; per-graph `Topo` watchers; `graph=`
+  scopes graph/schema/source/memory/threads/stats/sessions/dataset-run;
+  `/api/run` takes `_graph`; run rows store the registry name.
 - **Topology**: subprocess (`windhover.extract`) re-imports the graph on file
   mtime change → nodes/edges (+labels/metadata), input & context schemas,
   per-node source (inspect, unwrapped), x-ray variant; sha1-hash change bumps a
   version pushed over `/api/events` SSE.
-- **Tracer** (`windhover.tracer.SpanBuilder`): chains→node spans (langgraph_node
-  metadata), LLM (params, tools offered, tokens+details, TTFT, streaming
-  partials every ~0.5 s), tools, retrievers, retries, custom events,
-  GraphInterrupt→interrupted, session/tags/run_name/thread_id via config
-  metadata. Best-effort: never raises into the user's graph.
+- **Tracer** (`windhover.tracer.SpanBuilder`): concurrency-safe per-root run
+  contexts (parallel invokes = separate runs; bare llm/tool/retriever calls
+  open implicit runs; bookkeeping purged per run — no growth in long-lived
+  apps). Captures chains→node spans, LLM (params, tools offered,
+  tokens+cache/reasoning details, TTFT, streaming partials ~0.5 s), tools,
+  retrievers, retries, custom events, GraphInterrupt→interrupted (a pause,
+  never an error), messages as {role, content, tool_calls},
+  session/tags/run_name/thread_id via config metadata. The HTTP sink is
+  non-blocking (bounded queue + drain thread, sheds oldest). Best-effort:
+  never raises into — or slows — the user's graph.
 - **Store** (`windhover.store`, SQLite WAL, schema v7): runs / spans (tree) /
   scores / datasets (+span_fts). Feature-detects FTS5 & json1 at startup;
   idempotent column migrations.
 - **HITL** (`/api/threads/*`): thin wrappers over `Command(resume|goto)`,
   `interrupt_before/after`, `update_state`, `get_state_history`, checkpoint-id
-  forking. Requires the local graph to have a checkpointer.
+  forking. Requires the local graph to have a checkpointer. Pending-node
+  detection queries by thread only (a checkpoint_id would read history).
+- **Cache visibility**: LangGraph `CachePolicy` hits fire no callbacks; local
+  runs synthesize the node span with `params.cached`.
 - **Auth**: optional `WINDHOVER_TOKEN` Bearer/?token= gate on `/api` only.
+- **Alerts**: `WINDHOVER_WEBHOOK` POSTs a summary on error/interrupted runs
+  (store.on_run_closed hook, fire-and-forget, deduped).
 
 ## Data model (schema v7)
 `runs`: id · graph · source(ui|ingest) · status(running|done|error|interrupted) ·

{windhover-0.14.1 → windhover-0.14.3}/docs/GUIDE.md

@@ -154,6 +154,23 @@ curl -X POST :8090/api/datasets -H 'Content-Type: application/json' -d '{
 numbers/booleans, substring-of-output-JSON for strings. It's a smoke-level matcher —
 for semantic grading, run your own judge and `POST /api/runs/{id}/scores`.
 
+## Deep agents & agent frameworks
+
+Agent frameworks built on LangGraph — including `deepagents` (planning, virtual file
+system, sub-agents) and `create_react_agent` — trace with **no integration work**:
+
+- Every LLM call shows the **tools the model was offered**, so you can see an agent's
+  action space shrink inside a sub-agent.
+- **Sub-agents nest**: the `task` tool call that spawns one carries the entire child
+  agent's spans beneath it — one tree from top-level plan to nested completion.
+- **Plans render as checklists**: todo-shaped state (`[{content, status}]`) displays
+  with ✓/◐/○ markers instead of raw JSON, and state evolution shows each planning
+  update in order.
+- Framework-internal middleware spans (e.g. `TodoListMiddleware.after_model`) appear
+  italic-muted so the agent's real work stands out.
+- The canvas shows the compiled loop (agent ↔ tools) — an agent's *structure* lives in
+  its traces, not its topology; that's the nature of dynamic agents.
+
 ## More things the audit covered
 
 - **Concurrency & batch** — one tracer instance safely handles parallel `.invoke()`s:

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

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

@@ -632,6 +632,63 @@ def test_nonblocking_sink_and_webhook_hook():
     print("non-blocking sink + webhook hook OK")
 
 
+def test_fork_not_marked_interrupted():
+    """Pending-next check must query by thread only — a config carrying
+    checkpoint_id reads the historical checkpoint and falsely flags forks."""
+    os.environ.setdefault("WINDHOVER_DB", tempfile.mktemp(suffix=".db"))
+    from windhover.server import _pending_next
+    from typing import TypedDict
+    from langgraph.graph import StateGraph, START, END
+    from langgraph.checkpoint.memory import MemorySaver
+
+    class St(TypedDict):
+        x: int
+    g = StateGraph(St)
+    g.add_node("inc", lambda st: {"x": st["x"] + 1})
+    g.add_node("mul", lambda st: {"x": st["x"] * 10})
+    g.add_edge(START, "inc"); g.add_edge("inc", "mul"); g.add_edge("mul", END)
+    app = g.compile(checkpointer=MemorySaver())
+    cfgc = {"configurable": {"thread_id": "fork-t"}}
+    app.invoke({"x": 1}, config=cfgc)                       # completes
+    hist = list(app.get_state_history(cfgc))
+    early = next(s for s in hist if s.next)                 # historical, pending
+    cid = early.config["configurable"]["checkpoint_id"]
+    fork_cfg = {"configurable": {"thread_id": "fork-t", "checkpoint_id": cid}}
+    assert app.get_state(fork_cfg).next, "sanity: historical checkpoint has next"
+    assert _pending_next(app, fork_cfg) == [], "must ignore checkpoint_id"
+    print("fork-not-interrupted OK")
+
+
+def test_score_rejects_nonfinite():
+    p = tempfile.mktemp(suffix=".db")
+    s = Store(p)
+    s.open_run({"id": "sf1", "graph": "g", "started_ms": 1})
+    s.close_run("sf1", "done", 2)
+    assert s.add_score("sf1", "ok", 0.5) is not None
+    assert s.add_score("sf1", "bad", float("inf")) is None
+    assert s.add_score("sf1", "bad", float("nan")) is None
+    # the runs API payload must stay JSON-parseable
+    import json as _json
+    _json.loads(_json.dumps(s.runs()["runs"][0], allow_nan=False))
+    print("non-finite score rejection OK")
+
+
+def test_tracer_cleanup_no_leak():
+    p = tempfile.mktemp(suffix=".db")
+    s = Store(p)
+    tr = SpanBuilder(db_sink(s), run_name="leak")
+    for i in range(20):
+        tr.on_chain_start({}, {"i": i}, run_id=f"r{i}", parent_run_id=None)
+        tr.on_chain_start({}, {}, run_id=f"n{i}", parent_run_id=f"r{i}",
+                          metadata={"langgraph_node": "w"})
+        tr.on_chain_end({}, run_id=f"n{i}")
+        tr.on_chain_end({}, run_id=f"r{i}")
+    assert s.runs(limit=100)["total"] == 20
+    assert not tr._runs and not tr._root_of and not tr._span_of and not tr._open, (
+        len(tr._runs), len(tr._root_of), len(tr._span_of), len(tr._open))
+    print("tracer cleanup (no leak) OK")
+
+
 if __name__ == "__main__":
     test_cost(); print("cost OK")
     test_store_roundtrip()
@@ -660,4 +717,7 @@ if __name__ == "__main__":
     test_env_multi_graph_parsing()
     test_graph_scoped_stats_and_sessions()
     test_nonblocking_sink_and_webhook_hook()
+    test_fork_not_marked_interrupted()
+    test_score_rejects_nonfinite()
+    test_tracer_cleanup_no_leak()
     print("ALL SMOKE TESTS PASSED")

{windhover-0.14.1 → windhover-0.14.3}/windhover/server.py

@@ -230,6 +230,20 @@ def _sse(ev: str, data: dict) -> str:
     return f"event: {ev}\ndata: {json.dumps(data)}\n\n"
 
 
+def _pending_next(gr, config) -> list:
+    """Nodes still pending on the LATEST checkpoint of this thread. Must query
+    by thread only — carrying a checkpoint_id (fork/resume-from) would read the
+    HISTORICAL checkpoint, whose next-nodes are always non-empty."""
+    try:
+        thread_id = (config.get("configurable") or {}).get("thread_id")
+        if not thread_id:
+            return []
+        st = gr.get_state({"configurable": {"thread_id": thread_id}})
+        return list(st.next or [])
+    except Exception:
+        return []
+
+
 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
@@ -272,17 +286,17 @@ def _stream_execution(gr, graph_input, config, tracer, stream_kwargs=None):
                         seq_extra[0] += 1
                     q.put(("node", {"node": node, "cached": cached or None}))
             if not interrupted and getattr(gr, "checkpointer", None) is not None:
-                try:  # static breakpoint: stream ended but nodes are pending
-                    st = gr.get_state(config)
-                    if st.next:
-                        interrupted = True
-                        q.put(("interrupt", {"run_id": run_id,
-                                             "next": list(st.next)}))
-                except Exception:
-                    pass
+                nxt = _pending_next(gr, config)
+                if nxt:
+                    interrupted = True
+                    q.put(("interrupt", {"run_id": run_id, "next": nxt}))
             if interrupted:
-                # tracer closed the run as done on root end; correct it
-                store.close_run(run_id, "interrupted", int(time.time() * 1000))
+                # correct the status ONLY if the tracer didn't already mark it
+                # (dynamic interrupts close as interrupted themselves — a second
+                # close here would double-fire the webhook)
+                row = store.run_detail(run_id)
+                if row and row.get("status") != "interrupted":
+                    store.close_run(run_id, "interrupted", int(time.time() * 1000))
             q.put(("interrupted" if interrupted else "done", {"run_id": run_id}))
         except Exception as e:
             # tracer already recorded the error span/close; surface to the client too
@@ -307,6 +321,17 @@ async def api_run(request: Request):
         payload = await request.json()
     except Exception:
         payload = {}
+    if not isinstance(payload, dict):
+        # non-dict graph inputs (e.g. functional-API entrypoints taking a
+        # scalar) carry no _directives — run them as-is on the default graph
+        gr = _graph_for(_default_name())
+        if gr is None:
+            return JSONResponse({"error": "no local graph"}, 400)
+        tracer = SpanBuilder(db_sink(store), run_name=_default_name())
+        config = {"callbacks": [tracer]}
+        if getattr(gr, "checkpointer", None) is not None:
+            config["configurable"] = {"thread_id": tracer.run_id}
+        return _stream_execution(gr, payload, config, tracer)
     gname = payload.pop("_graph", None) or _default_name()
     gr = _graph_for(gname)
     if gr is None:
@@ -441,8 +466,10 @@ async def api_score_add(request: Request, run_id: str):
         name, value = str(body["name"]).strip(), float(body["value"])
     except (KeyError, TypeError, ValueError):
         return JSONResponse({"error": "requires name (str) and value (number)"}, 400)
-    if not name:
-        return JSONResponse({"error": "name must be non-empty"}, 400)
+    import math
+    if not name or not math.isfinite(value):
+        return JSONResponse({"error": "name must be non-empty and value finite "
+                            "(NaN/Infinity would corrupt API JSON)"}, 400)
     sc = store.add_score(run_id, name, value, comment=body.get("comment"),
                          source=body.get("source", "api"))
     return JSONResponse(sc) if sc else JSONResponse({"error": "run not found"}, 404)

{windhover-0.14.1 → windhover-0.14.3}/windhover/static/index.html

@@ -184,6 +184,7 @@ window.editState=async(tid,cid,valuesJson)=>{
 
 /* ---------- time-travel (checkpoint history) ---------- */
 window.showHistory=async(tid)=>{
+  clearTimeout(window.__liveT);
   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||[];
@@ -218,6 +219,7 @@ window.showHistory=async(tid)=>{
 window.pickDiff=async(id)=>{
   if(!window.__diffA||window.__diffA===id){ window.__diffA=id; toast('Compare: pick a second run (open it, hit compare)'); return; }
   const a=window.__diffA; window.__diffA=null;
+  clearTimeout(window.__liveT);
   const [ra,rb]=await Promise.all([fetch('/api/runs/'+a).then(r=>r.json()),
                                    fetch('/api/runs/'+id).then(r=>r.json())]);
   const tops=r=>r.spans.filter(s=>!s.parent_id&&s.type==='node');
@@ -328,6 +330,13 @@ window.pickDiff=async(id)=>{
 .msg .mrole{flex:none;font-family:var(--mono);font-size:9.5px;letter-spacing:.08em;text-transform:uppercase;color:var(--muted);padding-top:2px;width:64px;text-align:right}
 .msg.user .mrole{color:var(--accent-text)} .msg.assistant .mrole{color:var(--chip-llm-t)} .msg.tool .mrole,.msg.system .mrole{color:var(--chip-tool-t)}
 .msg>div{background:var(--surface);border:1px solid var(--border);border-radius:8px;padding:5px 9px;white-space:pre-wrap;word-break:break-word;flex:1}
+.todos{background:var(--surface2);border:1px solid var(--border);border-radius:8px;padding:8px 12px;display:flex;flex-direction:column;gap:4px}
+.todo{font-size:12.5px;display:flex;gap:8px;align-items:baseline}
+.todo .ti{font-family:var(--mono);color:var(--muted)}
+.todo.completed{color:var(--muted);text-decoration:line-through}
+.todo.completed .ti{color:var(--ok);text-decoration:none}
+.todo.in_progress .ti{color:var(--warn)}
+.tr-name.fw{color:var(--muted);font-weight:500;font-style:italic}
 
 /* ---------- modal (new run) ---------- */
 .modal{position:fixed;inset:0;display:grid;place-items:center;z-index:60;opacity:0;pointer-events:none;transition:.15s}
@@ -727,6 +736,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){
+  clearTimeout(window.__liveT); window.__run=null;
   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?'+gparam(''));
     if(rs.ok) src=await rs.json(); }catch(e){}
@@ -1005,7 +1015,7 @@ function renderSpans(list,byParent,total,depth){
       <div class="tr-row" onclick="tog('${did}',this)">
         <div class="tr-main"><span class="indent" style="width:${depth*18}px"></span>
           <span class="caret">▶</span><span class="chip ${s.type}">${s.type}</span>
-          <span class="tr-name ${s.status==='error'?'err':''}">${esc(s.name||s.type)}</span>${s.retries?`<span class="badge-retry">↻${s.retries}</span>`:''}</div>
+          <span class="tr-name ${s.status==='error'?'err':''} ${/Middleware\./.test(s.name||'')?'fw':''}">${esc(s.name||s.type)}</span>${s.retries?`<span class="badge-retry">↻${s.retries}</span>`:''}</div>
         <div class="tr-gantt"><div class="tr-bar ${s.type}" style="left:${left}%;width:${width}%"></div></div>
         <div class="tr-meta">${meta}</div>
       </div>
@@ -1021,6 +1031,9 @@ function renderSpans(list,byParent,total,depth){
   }).join('');
 }
 function isMsg(m){ return m&&typeof m==='object'&&typeof m.content!=='undefined'&&typeof (m.role||m.type)==='string'; }
+function isTodo(x){ return x&&typeof x==='object'&&typeof x.content==='string'&&typeof x.status==='string'; }
+function todoHtml(arr){ const ic={completed:'✓','in_progress':'◐',pending:'○'};
+  return `<div class="todos">${arr.map(t=>`<div class="todo ${esc(t.status)}"><span class="ti">${ic[t.status]||'○'}</span>${esc(t.content)}</div>`).join('')}</div>`; }
 function chatHtml(arr){ return `<div class="chat">${arr.map(m=>{
   const role=(m.role||m.type||'').replace('human','user').replace('ai','assistant');
   const body=typeof m.content==='string'?m.content:JSON.stringify(m.content);
@@ -1030,8 +1043,10 @@ function chatHtml(arr){ return `<div class="chat">${arr.map(m=>{
 function kv(k,v){
   const msgs=Array.isArray(v)&&v.length&&v.every(isMsg)?v
     :(v&&typeof v==='object'&&Array.isArray(v.messages)&&v.messages.length&&v.messages.every(isMsg)?v.messages:null);
+  const todos=Array.isArray(v)&&v.length&&v.every(isTodo)?v
+    :(v&&typeof v==='object'&&Array.isArray(v.todos)&&v.todos.length&&v.todos.every(isTodo)?v.todos:null);
   const txt=typeof v==='string'?v:JSON.stringify(v,null,2);
-  return `<div class="kv"><div class="k">${k}<button class="copy" onclick="navigator.clipboard.writeText(${JSON.stringify(txt).replace(/"/g,'&quot;')});toast('Copied')">copy</button></div>${msgs?chatHtml(msgs):`<pre>${esc(txt)}</pre>`}</div>`; }
+  return `<div class="kv"><div class="k">${k}<button class="copy" onclick="navigator.clipboard.writeText(${JSON.stringify(txt).replace(/"/g,'&quot;')});toast('Copied')">copy</button></div>${msgs?chatHtml(msgs):(todos?todoHtml(todos):`<pre>${esc(txt)}</pre>`)}</div>`; }
 window.tog=(id,row)=>{ const el=document.getElementById(id); const open=el.style.display==='block';
   el.style.display=open?'none':'block'; row.querySelector('.caret').classList.toggle('open',!open); };
 window.replay=async(steps)=>{ closeAll(); switchView('graph');
@@ -1106,6 +1121,7 @@ window.editState=async(tid,cid,valuesJson)=>{
 
 /* ---------- time-travel (checkpoint history) ---------- */
 window.showHistory=async(tid)=>{
+  clearTimeout(window.__liveT);
   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||[];
@@ -1140,6 +1156,7 @@ window.showHistory=async(tid)=>{
 window.pickDiff=async(id)=>{
   if(!window.__diffA||window.__diffA===id){ window.__diffA=id; toast('Compare: pick a second run (open it, hit compare)'); return; }
   const a=window.__diffA; window.__diffA=null;
+  clearTimeout(window.__liveT);
   const [ra,rb]=await Promise.all([fetch('/api/runs/'+a).then(r=>r.json()),
                                    fetch('/api/runs/'+id).then(r=>r.json())]);
   const tops=r=>r.spans.filter(s=>!s.parent_id&&s.type==='node');
@@ -1225,7 +1242,7 @@ async function loadStats(){
 }
 
 /* ---------- misc ---------- */
-function closeAll(){ $('#scrim').classList.remove('on'); $('#drawer').classList.remove('on'); $('#modal').classList.remove('on'); }
+function closeAll(){ clearTimeout(window.__liveT); $('#scrim').classList.remove('on'); $('#drawer').classList.remove('on'); $('#modal').classList.remove('on'); }
 function esc(s){ return String(s).replace(/[&<>]/g,c=>({'&':'&amp;','<':'&lt;','>':'&gt;'}[c])); }
 function fmtms(ms){ return ms<1000?ms+' ms':(ms/1000).toFixed(1)+' s'; }
 function fmtk(n){ return n<1000?String(n):(n/1000).toFixed(1)+'k'; }

{windhover-0.14.1 → windhover-0.14.3}/windhover/store.py

@@ -195,6 +195,9 @@ class Store:
 
     def add_score(self, run_id: str, name: str, value: float,
                   comment: Optional[str] = None, source: str = "api") -> Optional[dict]:
+        import math
+        if not math.isfinite(float(value)):
+            return None  # NaN/Infinity would render the runs API unparseable
         with _lock, self._conn() as c:
             if not c.execute("SELECT 1 FROM runs WHERE id=?", (run_id,)).fetchone():
                 return None

{windhover-0.14.1 → windhover-0.14.3}/windhover/tracer.py

@@ -151,6 +151,7 @@ class SpanBuilder(BaseCallbackHandler):
         self.session = session
         self.tags = tags
         self.run_id = uuid.uuid4().hex[:12]     # id of the FIRST run this tracer opens
+        self._closed = 0                         # runs completed (cleanup bookkeeping)
         self._runs: dict = {}                    # lc root id -> run ctx
         self._root_of: dict = {}                 # lc run id -> lc root id
         self._open: dict = {}                    # lc run id -> pending span info
@@ -171,7 +172,10 @@ class SpanBuilder(BaseCallbackHandler):
         if root is None:
             root = self._root_of.get(run_id) or (run_id if parent_run_id is None else parent_run_id)
         self._root_of[run_id] = root
-        return root, self._runs.get(root)
+        ctx = self._runs.get(root)
+        if ctx is not None:
+            ctx["members"].add(run_id)
+        return root, ctx
 
     def _open_ctx(self, root, inputs, metadata=None, lc_tags=None):
         md = metadata or {}
@@ -181,8 +185,8 @@ class SpanBuilder(BaseCallbackHandler):
                      if not str(t).startswith(self._INTERNAL_TAG_PREFIXES)]
         extra = md.get("windhover_tags") or []
         tags = list(dict.fromkeys([*(self.tags or []), *map(str, extra), *map(str, user_tags)])) or None
-        ctx = {"id": self.run_id if not self._runs else uuid.uuid4().hex[:12],
-               "t0": time.time(), "seq": 0, "interrupted": False}
+        ctx = {"id": self.run_id if not self._closed and not self._runs else uuid.uuid4().hex[:12],
+               "t0": time.time(), "seq": 0, "interrupted": False, "members": {root}}
         self._runs[root] = ctx
         self._emit({"kind": "run_open", "run_id": ctx["id"], "graph": name,
                     "input": _trunc(inputs), "started_ms": int(ctx["t0"] * 1000),
@@ -229,11 +233,17 @@ class SpanBuilder(BaseCallbackHandler):
         ctx["seq"] += 1
 
     def _close_ctx(self, root, status, error=None):
-        ctx = self._runs.get(root)
+        ctx = self._runs.pop(root, None)
         if ctx is None:
             return
         self._emit({"kind": "run_close", "run_id": ctx["id"], "status": status,
                     "ended_ms": int(time.time() * 1000), "error": error})
+        # long-lived tracers (production apps) must not grow without bound
+        self._closed += 1
+        for m in ctx.get("members", ()):
+            self._root_of.pop(m, None)
+            self._span_of.pop(m, None)
+            self._open.pop(m, None)
 
     # -- chains / nodes --------------------------------------------------------
     def on_chain_start(self, serialized, inputs, *, run_id=None, parent_run_id=None,