windhover 0.9.0__tar.gz → 0.10.0__tar.gz

{windhover-0.9.0 → windhover-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: windhover
-Version: 0.9.0
+Version: 0.10.0
 Summary: Self-hosted, mobile-friendly observability for LangGraph — traces, run history, cost, and a living graph view.
 Project-URL: Repository, https://github.com/justfeltlikerunning/windhover
 Author: justfeltlikerunning
@@ -81,8 +81,11 @@ graph.invoke(input, config={
 - **Clickable graph** — tap a node for health, latency, wiring, its **source code**, and recent executions with payloads.
 - **Error forensics** — failed runs show the full traceback; the failing node turns red on the
   graph, and the node's source renders with the **throwing line highlighted**.
-- **Human-in-the-loop aware** — a graph paused on `interrupt()` shows an amber **interrupted**
-  status plus the payload it's asking a human about.
+- **Human-in-the-loop console** — a paused graph shows an amber **interrupted** status with the
+  question it's asking; answer it (`Command(resume=…)`), redirect it (`Command(goto=…)`), set
+  static breakpoints per run (`interrupt_before`), **edit state** at any checkpoint
+  (`update_state`), or **fork** a thread from any historical checkpoint — all from the UI,
+  all pure LangGraph primitives.
 - **State evolution** — every trace shows which state keys each node wrote, in order.
 - **X-ray** — graphs with subgraphs get a canvas toggle that expands composite nodes
   (`get_graph(xray=True)`).

{windhover-0.9.0 → windhover-0.10.0}/README.md

@@ -62,8 +62,11 @@ graph.invoke(input, config={
 - **Clickable graph** — tap a node for health, latency, wiring, its **source code**, and recent executions with payloads.
 - **Error forensics** — failed runs show the full traceback; the failing node turns red on the
   graph, and the node's source renders with the **throwing line highlighted**.
-- **Human-in-the-loop aware** — a graph paused on `interrupt()` shows an amber **interrupted**
-  status plus the payload it's asking a human about.
+- **Human-in-the-loop console** — a paused graph shows an amber **interrupted** status with the
+  question it's asking; answer it (`Command(resume=…)`), redirect it (`Command(goto=…)`), set
+  static breakpoints per run (`interrupt_before`), **edit state** at any checkpoint
+  (`update_state`), or **fork** a thread from any historical checkpoint — all from the UI,
+  all pure LangGraph primitives.
 - **State evolution** — every trace shows which state keys each node wrote, in order.
 - **X-ray** — graphs with subgraphs get a canvas toggle that expands composite nodes
   (`get_graph(xray=True)`).

{windhover-0.9.0 → windhover-0.10.0}/pyproject.toml

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

{windhover-0.9.0 → windhover-0.10.0}/tests/test_smoke.py

@@ -360,6 +360,69 @@ def test_demo_memory_and_events_end_to_end():
     print("demo memory + custom event end-to-end OK")
 
 
+def test_hitl_interrupt_resume():
+    """Dynamic interrupt pauses (status interrupted); Command(resume) finishes."""
+    from typing import TypedDict
+    from langgraph.graph import StateGraph, START, END
+    from langgraph.checkpoint.memory import MemorySaver
+    from langgraph.types import Command, interrupt
+    p = tempfile.mktemp(suffix=".db")
+    s = Store(p)
+
+    class St(TypedDict):
+        x: int
+    def gate(st):
+        ok = interrupt({"question": f"allow x={st['x']}?"})
+        return {"x": st["x"] if ok else 0}
+    g = StateGraph(St)
+    g.add_node("gate", gate)
+    g.add_edge(START, "gate"); g.add_edge("gate", END)
+    app = g.compile(checkpointer=MemorySaver())
+    cfgc = {"configurable": {"thread_id": "hitl-1"}}
+
+    tr1 = SpanBuilder(db_sink(s), run_name="hitl")
+    out = app.invoke({"x": 5}, config={"callbacks": [tr1], **cfgc})
+    assert "__interrupt__" in out
+    time.sleep(.05)
+    assert s.run_detail(tr1.run_id)["status"] == "interrupted"
+
+    tr2 = SpanBuilder(db_sink(s), run_name="hitl")
+    out2 = app.invoke(Command(resume=True), config={"callbacks": [tr2], **cfgc})
+    assert out2["x"] == 5
+    time.sleep(.05)
+    assert s.run_detail(tr2.run_id)["status"] == "done"
+    print("HITL interrupt/resume OK")
+
+
+def test_static_breakpoint_and_state_edit():
+    """interrupt_before pauses with pending next; update_state edit sticks."""
+    from typing import TypedDict
+    from langgraph.graph import StateGraph, START, END
+    from langgraph.checkpoint.memory import MemorySaver
+    p = tempfile.mktemp(suffix=".db")
+    s = Store(p)
+
+    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": "bp-1"}}
+
+    tr = SpanBuilder(db_sink(s), run_name="bp")
+    for _ in app.stream({"x": 1}, config={"callbacks": [tr], **cfgc},
+                        stream_mode="updates", interrupt_before=["mul"]):
+        pass
+    st = app.get_state(cfgc)
+    assert st.next == ("mul",), st.next          # paused before mul
+    app.update_state(cfgc, {"x": 100})           # human edits the state
+    out = app.invoke(None, config=cfgc)          # continue
+    assert out["x"] == 1000, out                 # 100 * 10 — edit took effect
+    print("static breakpoint + state edit OK")
+
+
 if __name__ == "__main__":
     test_cost(); print("cost OK")
     test_store_roundtrip()
@@ -377,4 +440,6 @@ if __name__ == "__main__":
     test_datasets_and_scoring()
     test_ttft_retry_custom_event_usage_detail()
     test_demo_memory_and_events_end_to_end()
+    test_hitl_interrupt_resume()
+    test_static_breakpoint_and_state_edit()
     print("ALL SMOKE TESTS PASSED")

{windhover-0.9.0 → windhover-0.10.0}/windhover/demo_graph.py

@@ -24,7 +24,15 @@ def seed(s):
     if n < 0:
         raise ValueError(f"n must be non-negative, got {n} — the demo guard tripped")
     return {"n": n}
-def grow(s):       time.sleep(.3);  return {"n": s["n"] * 3}
+def grow(s):
+    time.sleep(.3)
+    grown = s["n"] * 3
+    if grown > 500:  # human-in-the-loop: big growth needs approval
+        from langgraph.types import interrupt
+        approved = interrupt({"question": f"grow {s['n']} -> {grown}? (true/false)"})
+        if not approved:
+            return {"n": s["n"]}
+    return {"n": grown}
 def parity(s):     time.sleep(.4);  return {"notes": ["even" if s["n"] % 2 == 0 else "odd"]}
 def sign(s):       time.sleep(.25); return {"notes": ["positive" if s["n"] > 0 else "non-positive"]}
 def magnitude(s):  time.sleep(.35); return {"notes": ["big" if abs(s["n"]) > 100 else "small"]}

{windhover-0.9.0 → windhover-0.10.0}/windhover/server.py

@@ -163,31 +163,19 @@ def _sse(ev: str, data: dict) -> str:
     return f"event: {ev}\ndata: {json.dumps(data)}\n\n"
 
 
-@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 = {}
-    session = payload.pop("_session", None)
-    tags = payload.pop("_tags", None)
-    thread = payload.pop("_thread", None)
-    tracer = SpanBuilder(db_sink(store), run_name=cfg.graph_ref, session=session, tags=tags)
+def _stream_execution(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."""
     run_id = tracer.run_id
-    config = {"callbacks": [tracer]}
-    if thread or getattr(graph, "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 run_id}
     q: "queue.Queue" = queue.Queue()
 
     def worker():
         try:
             interrupted = False
-            for mode, chunk in graph.stream(payload, config=config,
-                                            stream_mode=["updates", "custom"]):
+            for mode, chunk in graph.stream(graph_input, config=config,
+                                            stream_mode=["updates", "custom"],
+                                            **(stream_kwargs or {})):
                 if mode == "custom":
                     # get_stream_writer() output from inside a node -> live progress
                     q.put(("progress", {"data": _trunc(chunk, 600)}))
@@ -198,6 +186,18 @@ async def api_run(request: Request):
                         q.put(("interrupt", {"run_id": run_id}))
                     else:
                         q.put(("node", {"node": node}))
+            if not interrupted and getattr(graph, "checkpointer", None) is not None:
+                try:  # static breakpoint: stream ended but nodes are pending
+                    st = graph.get_state(config)
+                    if st.next:
+                        interrupted = True
+                        q.put(("interrupt", {"run_id": run_id,
+                                             "next": list(st.next)}))
+                except Exception:
+                    pass
+            if interrupted:
+                # tracer closed the run as done on root end; correct it
+                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
@@ -216,6 +216,86 @@ async def api_run(request: Request):
     return StreamingResponse(stream(), media_type="text/event-stream")
 
 
+@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 = {}
+    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)
+    tracer = SpanBuilder(db_sink(store), run_name=cfg.graph_ref, session=session, tags=tags)
+    config = {"callbacks": [tracer]}
+    if thread or getattr(graph, "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}
+    sk = {}
+    if pause_before:
+        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)
+
+
+@app.post("/api/threads/{thread_id}/resume")
+async def api_thread_resume(request: Request, thread_id: str):
+    """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:
+        return JSONResponse({"error": "no local graph with a checkpointer"}, 400)
+    try:
+        body = await request.json()
+    except Exception:
+        body = {}
+    try:
+        from langgraph.types import Command
+    except Exception:
+        return JSONResponse({"error": "langgraph.types.Command unavailable"}, 500)
+    if "value" in body:
+        graph_input = Command(resume=body["value"])
+    elif body.get("goto"):
+        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,
+                         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)
+
+
+@app.post("/api/threads/{thread_id}/state")
+async def api_thread_update_state(request: Request, thread_id: str):
+    """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:
+        return JSONResponse({"error": "no local graph with a checkpointer"}, 400)
+    body = await request.json()
+    values = body.get("values")
+    if not isinstance(values, dict):
+        return JSONResponse({"error": "requires values (object of state keys)"}, 400)
+    configurable = {"thread_id": thread_id}
+    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"))
+        return JSONResponse({"ok": True, "checkpoint_id":
+                             (new_cfg.get("configurable") or {}).get("checkpoint_id")})
+    except Exception as e:
+        return JSONResponse({"error": str(e)}, 400)
+
+
 @app.post("/api/ingest")
 async def api_ingest(request: Request):
     ev = await request.json()

{windhover-0.9.0 → windhover-0.10.0}/windhover/static/index.html

@@ -130,6 +130,58 @@ td.r,th.r{text-align:right}
 .empty{padding:56px 20px;text-align:center;color:var(--muted)}
 .empty .t{font-weight:600;color:var(--text2);margin-bottom:4px}
 
+/* ---------- human-in-the-loop ---------- */
+async function consumeRunStream(res){
+  const rd=res.body.getReader(),dec=new TextDecoder(); let buf='';
+  while(true){ const {value,done}=await rd.read(); if(done)break; buf+=dec.decode(value,{stream:true});
+    let ps=buf.split('\n\n'); buf=ps.pop();
+    for(const p of ps){ const ev=(p.match(/event: (.*)/)||[])[1],dm=(p.match(/data: (.*)/s)||[])[1]; if(!ev)continue; const d=dm?JSON.parse(dm):{};
+      if(ev==='node'&&cy){ cy.$id(d.node).addClass('running'); }
+      else if(ev==='progress'){ toast('progress: '+JSON.stringify(d.data).slice(0,120)); }
+      else if(ev==='interrupted'){ toast('Paused again — awaiting human'); }
+      else if(ev==='done'){ toast('Resumed run complete'); }
+      else if(ev==='error'){ toast('Resume error: '+(d.message||'failed')); } } }
+  if(VIEW==='runs') loadRuns();
+}
+function parseMaybeJSON(v){ if(v==='')return undefined;
+  try{ return JSON.parse(v); }catch(e){ return v; } }
+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',
+    {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);
+};
+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',
+    {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',
+    {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);
+};
+window.editState=async(tid,cid,valuesJson)=>{
+  const cur=window.prompt('Edit state values (JSON object) — applied via update_state:',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',
+    {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');
+  toast('State updated — new checkpoint '+String(d.checkpoint_id||'').slice(-8)+'; Resume to continue');
+  showHistory(tid);
+};
+
 /* ---------- time-travel (checkpoint history) ---------- */
 window.showHistory=async(tid)=>{
   let d=null; try{ const r=await fetch('/api/threads/'+encodeURIComponent(tid)+'/history');
@@ -153,6 +205,10 @@ window.showHistory=async(tid)=>{
       <div class="tr-detail" id="${did}">
         ${s.writes!=null?kv('writes',s.writes):''}
         ${kv('state at this checkpoint',s.values)}
+        <div style="display:flex;gap:8px;margin:4px 0 10px">
+          <button class="btn ghost" onclick='rerunFrom("${esc(tid)}","${esc(s.checkpoint_id||'')}")'>⑂ Re-run from here</button>
+          <button class="btn ghost" onclick='editState("${esc(tid)}","${esc(s.checkpoint_id||'')}",${JSON.stringify(JSON.stringify(s.values??{}))})'>✎ Edit state</button>
+        </div>
       </div></div>`;
   }).join('')||'<div class="empty">No checkpoints recorded for this thread</div>';
   $('#scrim').classList.add('on'); $('#drawer').classList.add('on');
@@ -297,6 +353,8 @@ textarea:focus{border-color:var(--accent)}
 .star.on{color:var(--warn)}
 .tagchip{display:inline-block;background:var(--accent-weak);color:var(--accent-text);font-size:10.5px;font-weight:600;
   padding:1.5px 7px;border-radius:5px;margin:1px 4px 1px 0;cursor:pointer}
+.pause-chip{background:var(--surface2);color:var(--text2);border:1px dashed var(--border2)}
+.pause-chip.on{background:var(--warn-weak);color:var(--warn);border-style:solid;border-color:var(--warn)}
 .scorechip{display:inline-block;background:var(--ok-weak);color:var(--ok);font-size:10.5px;font-weight:600;
   padding:1.5px 7px;border-radius:5px;margin:1px 4px 1px 0}
 .pager{display:flex;align-items:center;gap:12px;justify-content:flex-end;margin-top:10px;color:var(--muted);font-size:12.5px}
@@ -396,7 +454,7 @@ 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.9</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.10</span></div>
   </aside>
 
   <main>
@@ -496,6 +554,8 @@ th{font-family:var(--mono);letter-spacing:.11em;font-size:10.5px}
       <input id="run-session" placeholder="session (optional)" style="flex:1;min-width:130px">
       <input id="run-tags" placeholder="tags, comma-separated (optional)" style="flex:1;min-width:160px">
     </div>
+    <div class="hint" style="margin:8px 0 4px">Pause before (static breakpoints — resume from the run drawer):</div>
+    <div id="pause-chips" style="display:flex;flex-wrap:wrap;gap:6px"></div>
     <div class="actions">
       <button class="btn ghost" onclick="closeAll()">Cancel</button>
       <button class="btn primary" id="do-run">${ICON.play} Run</button>
@@ -699,11 +759,17 @@ $$('.nav button,.bottom-nav button').forEach(b=>b.onclick=()=>switchView(b.datas
 
 /* ---------- new run ---------- */
 $('#newrun').onclick=async()=>{ let tpl={}; try{tpl=(await(await fetch('/api/schema')).json()).template||{};}catch(e){}
-  $('#input-json').value=JSON.stringify(tpl,null,2); $('#scrim').classList.add('on'); $('#modal').classList.add('on'); };
+  $('#input-json').value=JSON.stringify(tpl,null,2);
+  const pc=document.getElementById('pause-chips');
+  if(pc&&cy) pc.innerHTML=cy.nodes().filter(n=>!n.data('terminal')).map(n=>
+    `<span class="tagchip pause-chip" data-n="${esc(n.id())}" onclick="this.classList.toggle('on')">${esc(n.id())}</span>`).join('');
+  $('#scrim').classList.add('on'); $('#modal').classList.add('on'); };
 $('#do-run').onclick=async()=>{ let input; try{input=JSON.parse($('#input-json').value||'{}');}catch(e){return toast('Invalid JSON input');}
   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;
+  const paused=[...document.querySelectorAll('.pause-chip.on')].map(e=>e.dataset.n);
+  if(paused.length) input._interrupt_before=paused;
   closeAll(); switchView('graph'); await runNow(input); };
 
 async function runNow(input){
@@ -822,6 +888,19 @@ async function openRun(id){
       <span class="chip node">${esc(s.name)}</span>
       ${Object.keys(s.output).map(k=>`<span class="tagchip" style="cursor:default">${esc(k)}</span>`).join('')}
       <span style="color:var(--muted);font-size:11px;margin-left:auto" class="mono">${s.dur_ms!=null?fmtms(s.dur_ms):''}</span></div>`).join('');
+  if(r.status==='interrupted'&&r.thread_id){
+    const ivs=r.spans.filter(s=>s.type==='interrupt'); const iv=ivs.find(s=>s.output!=null)||ivs.pop();
+    html += `<div class="kv" style="margin-top:14px"><div class="k" style="color:var(--warn)">interrupt — awaiting human</div>
+      ${iv&&iv.output!=null?`<pre>${esc(JSON.stringify(iv.output,null,2))}</pre>`:'<pre>paused at a breakpoint</pre>'}
+      <div class="scoreadd" style="margin-top:8px">
+        <input id="hitl-val" placeholder='resume value — JSON or text (blank = just continue)' style="flex:1;min-width:200px">
+        <button class="btn primary" onclick="resumeThread('${esc(r.thread_id)}')">Resume</button>
+      </div>
+      <div class="scoreadd">
+        <select id="hitl-goto"><option value="">goto node (optional)…</option></select>
+        <button class="btn ghost" onclick="resumeGoto('${esc(r.thread_id)}')">Send to node</button>
+      </div></div>`;
+  }
   html += `<div class="kv" style="margin-top:14px"><div class="k">scores</div></div>
     ${(r.scores||[]).map(sc=>`<div class="scorerow"><span class="scorechip">${esc(sc.name)} ${sc.value}</span>
       ${sc.comment?`<span style="color:var(--muted);font-size:12px">${esc(sc.comment)}</span>`:''}
@@ -838,6 +917,9 @@ async function openRun(id){
   $('#d-body').innerHTML=html;
   openIds.forEach(i=>{const e=document.getElementById(i); if(e){e.style.display='block';
     const row=e.previousElementSibling; row&&row.querySelector('.caret')?.classList.add('open');}});
+  const gsel=document.getElementById('hitl-goto');
+  if(gsel&&cy) gsel.innerHTML='<option value="">goto node (optional)…</option>'+
+    cy.nodes().filter(n=>!n.data('terminal')).map(n=>`<option>${esc(n.id())}</option>`).join('');
   $('#scrim').classList.add('on'); $('#drawer').classList.add('on');
   clearTimeout(window.__liveT);
   if(r.status==='running')
@@ -906,6 +988,58 @@ window.showSpanSource=async(sid)=>{
                   :'<pre>no source available for this node (external run, or inspect could not trace it)</pre>';
 };
 
+/* ---------- human-in-the-loop ---------- */
+async function consumeRunStream(res){
+  const rd=res.body.getReader(),dec=new TextDecoder(); let buf='';
+  while(true){ const {value,done}=await rd.read(); if(done)break; buf+=dec.decode(value,{stream:true});
+    let ps=buf.split('\n\n'); buf=ps.pop();
+    for(const p of ps){ const ev=(p.match(/event: (.*)/)||[])[1],dm=(p.match(/data: (.*)/s)||[])[1]; if(!ev)continue; const d=dm?JSON.parse(dm):{};
+      if(ev==='node'&&cy){ cy.$id(d.node).addClass('running'); }
+      else if(ev==='progress'){ toast('progress: '+JSON.stringify(d.data).slice(0,120)); }
+      else if(ev==='interrupted'){ toast('Paused again — awaiting human'); }
+      else if(ev==='done'){ toast('Resumed run complete'); }
+      else if(ev==='error'){ toast('Resume error: '+(d.message||'failed')); } } }
+  if(VIEW==='runs') loadRuns();
+}
+function parseMaybeJSON(v){ if(v==='')return undefined;
+  try{ return JSON.parse(v); }catch(e){ return v; } }
+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',
+    {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);
+};
+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',
+    {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',
+    {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);
+};
+window.editState=async(tid,cid,valuesJson)=>{
+  const cur=window.prompt('Edit state values (JSON object) — applied via update_state:',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',
+    {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');
+  toast('State updated — new checkpoint '+String(d.checkpoint_id||'').slice(-8)+'; Resume to continue');
+  showHistory(tid);
+};
+
 /* ---------- time-travel (checkpoint history) ---------- */
 window.showHistory=async(tid)=>{
   let d=null; try{ const r=await fetch('/api/threads/'+encodeURIComponent(tid)+'/history');
@@ -929,6 +1063,10 @@ window.showHistory=async(tid)=>{
       <div class="tr-detail" id="${did}">
         ${s.writes!=null?kv('writes',s.writes):''}
         ${kv('state at this checkpoint',s.values)}
+        <div style="display:flex;gap:8px;margin:4px 0 10px">
+          <button class="btn ghost" onclick='rerunFrom("${esc(tid)}","${esc(s.checkpoint_id||'')}")'>⑂ Re-run from here</button>
+          <button class="btn ghost" onclick='editState("${esc(tid)}","${esc(s.checkpoint_id||'')}",${JSON.stringify(JSON.stringify(s.values??{}))})'>✎ Edit state</button>
+        </div>
       </div></div>`;
   }).join('')||'<div class="empty">No checkpoints recorded for this thread</div>';
   $('#scrim').classList.add('on'); $('#drawer').classList.add('on');

{windhover-0.9.0 → windhover-0.10.0}/windhover/tracer.py

@@ -137,6 +137,7 @@ class SpanBuilder(BaseCallbackHandler):
         self._open: dict[str, dict] = {}   # langchain run_id -> pending span
         self._span_of: dict[str, str] = {} # langchain run_id -> our span id (for parent links)
         self._seq = 0
+        self._interrupted = False
 
     # -- infra --
     def _emit(self, ev: dict) -> None:
@@ -206,8 +207,11 @@ class SpanBuilder(BaseCallbackHandler):
             # LangGraph human-in-the-loop: a paused graph surfaces __interrupt__
             # in its final output — that's a pause awaiting Command(resume=...),
             # not a completion.
-            interrupted = isinstance(outputs, dict) and "__interrupt__" in outputs
-            if interrupted:
+            interrupted = self._interrupted or (
+                isinstance(outputs, dict) and "__interrupt__" in outputs)
+            if interrupted and not self._interrupted:
+                # marker not yet emitted by the GraphInterrupt path
+                self._interrupted = True
                 self._finish_span(
                     {"span_id": uuid.uuid4().hex[:12], "type": "interrupt",
                      "name": "interrupt", "t": time.time(), "parent": None,
@@ -219,6 +223,32 @@ class SpanBuilder(BaseCallbackHandler):
 
     def on_chain_error(self, error, *, run_id=None, **kw):
         info = self._open.pop(run_id, None)
+        # LangGraph signals a human-in-the-loop pause by raising GraphInterrupt
+        # through the node — that's a pause, not a failure.
+        if type(error).__name__ in ("GraphInterrupt", "NodeInterrupt"):
+            payload = []
+            try:
+                for i in (error.args[0] if error.args else []):
+                    payload.append(getattr(i, "value", str(i)))
+            except Exception:
+                pass
+            if info:
+                self._finish_span(info, status="interrupted",
+                                  output=_trunc(payload) if payload else None)
+            if not self._interrupted:  # one marker span per pause
+                self._interrupted = True
+                now = time.time()
+                self._emit({"kind": "span", "id": uuid.uuid4().hex[:12],
+                            "run_id": self.run_id, "parent_id": None,
+                            "seq": self._seq, "type": "interrupt", "name": "interrupt",
+                            "status": "ok", "started_ms": int(now * 1000),
+                            "ended_ms": int(now * 1000), "offset_ms": self._rel(now),
+                            "dur_ms": 0, "input": None,
+                            "output": _trunc(payload) if payload else None,
+                            "model": None, "prompt_tokens": None,
+                            "completion_tokens": None, "cost_usd": None, "error": None})
+                self._seq += 1
+            return
         err = _err_text(error)
         if info:
             self._finish_span(info, status="error", error=err)