windhover 0.14.1__tar.gz → 0.14.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: windhover
-Version: 0.14.1
+Version: 0.14.2
 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

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "windhover"
-version = "0.14.1"
+version = "0.14.2"
 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.2}/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.2}/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.2}/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');
@@ -727,6 +729,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){}
@@ -1106,6 +1109,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 +1144,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 +1230,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.2}/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.2}/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,