windhover 0.9.0__tar.gz → 0.11.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: windhover
-Version: 0.9.0
+Version: 0.11.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)`).
@@ -90,8 +93,12 @@ graph.invoke(input, config={
   status/tag/session filters, bookmarks, pagination, CSV/JSON export.
 - **Sessions** — group runs into threads/batches; roll-up tokens, cost, errors.
 - **Scores** — attach numeric evals to runs (API or UI): eval harnesses, LLM-as-judge, human review.
-- **Live tail** — open a running run and watch its spans arrive in real time; nodes can push
-  progress via LangGraph's `get_stream_writer()`.
+- **Live tail** — open a running run and watch spans arrive — including **the model typing**
+  (streamed tokens flush into the span twice a second); nodes push progress via
+  `get_stream_writer()`.
+- **Call configs** — every LLM span records temperature/max-tokens/stream **and the tools the
+  model was offered**; conditional-edge branch labels and `add_node(metadata=…)` render on the
+  graph and node pane; graphs with a context schema get a runtime-context box on New run.
 - **Custom events** — `dispatch_custom_event("name", {...})` anywhere in your app lands as an
   event marker in the trace, parented to the node that fired it.
 - **Retries + TTFT** — tenacity retries badge the span (`↻2`); streaming LLM calls record

{windhover-0.9.0 → windhover-0.11.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)`).
@@ -71,8 +74,12 @@ graph.invoke(input, config={
   status/tag/session filters, bookmarks, pagination, CSV/JSON export.
 - **Sessions** — group runs into threads/batches; roll-up tokens, cost, errors.
 - **Scores** — attach numeric evals to runs (API or UI): eval harnesses, LLM-as-judge, human review.
-- **Live tail** — open a running run and watch its spans arrive in real time; nodes can push
-  progress via LangGraph's `get_stream_writer()`.
+- **Live tail** — open a running run and watch spans arrive — including **the model typing**
+  (streamed tokens flush into the span twice a second); nodes push progress via
+  `get_stream_writer()`.
+- **Call configs** — every LLM span records temperature/max-tokens/stream **and the tools the
+  model was offered**; conditional-edge branch labels and `add_node(metadata=…)` render on the
+  graph and node pane; graphs with a context schema get a runtime-context box on New run.
 - **Custom events** — `dispatch_custom_event("name", {...})` anywhere in your app lands as an
   event marker in the trace, parented to the node that fired it.
 - **Retries + TTFT** — tenacity retries badge the span (`↻2`); streaming LLM calls record

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

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

@@ -360,6 +360,132 @@ 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")
+
+
+def test_streaming_partials_params_tools():
+    """Token stream flushes partial spans (live 'model typing'); invocation
+    params + offered tools captured per LLM span."""
+    p = tempfile.mktemp(suffix=".db")
+    s = Store(p)
+    tr = SpanBuilder(db_sink(s), run_name="stream")
+    tr.on_chain_start({}, {"q": 1}, run_id="root", parent_run_id=None)
+    tr.on_chat_model_start(
+        {"kwargs": {"model": "fable-fast"}}, [[]], run_id="L", parent_run_id="root",
+        invocation_params={"model": "fable-fast", "temperature": 0.1, "stream": True,
+                           "tools": [{"function": {"name": "get_weather"}}]})
+    tr.on_llm_new_token("Hello ", run_id="L")
+    tr._open["L"]["flushed"] = 0            # force the throttle window open
+    tr.on_llm_new_token("wind", run_id="L")  # -> partial flush
+    mid = s.run_detail(tr.run_id)
+    llm_mid = [x for x in mid["spans"] if x["type"] == "llm"][0]
+    assert llm_mid["status"] == "running" and "Hello wind" in llm_mid["output"]
+
+    class Msg:
+        content = "Hello windhover"
+        usage_metadata = {"input_tokens": 10, "output_tokens": 3}
+    class Gen:
+        text = "Hello windhover"; message = Msg()
+    class Resp:
+        llm_output = None; generations = [[Gen()]]
+    tr.on_llm_end(Resp(), run_id="L")
+    tr.on_chain_end({}, run_id="root")
+    d = s.run_detail(tr.run_id)
+    llm = [x for x in d["spans"] if x["type"] == "llm"][0]
+    assert llm["status"] == "ok" and llm["output"] == "Hello windhover"
+    assert llm["params"]["temperature"] == 0.1
+    assert llm["params"]["tools_offered"] == ["get_weather"]
+    assert len([x for x in d["spans"] if x["type"] == "llm"]) == 1  # partial replaced
+    print("streaming partials + params/tools OK")
+
+
+def test_edge_labels_and_node_metadata():
+    from typing import TypedDict, Literal
+    from langgraph.graph import StateGraph, START, END
+    from windhover.extract import topology
+
+    class St(TypedDict):
+        x: int
+    def route(st) -> Literal["yes", "no"]:
+        return "yes"
+    g = StateGraph(St)
+    g.add_node("decide", lambda st: {"x": st["x"]},
+               metadata={"owner": "team-a", "doc": "routing"})
+    g.add_node("approve", lambda st: {"x": 1})
+    g.add_node("reject", lambda st: {"x": 0})
+    g.add_edge(START, "decide")
+    g.add_conditional_edges("decide", route, {"yes": "approve", "no": "reject"})
+    g.add_edge("approve", END); g.add_edge("reject", END)
+    topo = topology(g.compile())
+    decide = next(n for n in topo["nodes"] if n["id"] == "decide")
+    assert decide["metadata"] == {"owner": "team-a", "doc": "routing"}
+    labels = {(e["source"], e["target"]): e["label"] for e in topo["edges"]}
+    assert labels[("decide", "approve")] == "yes"
+    assert labels[("decide", "reject")] == "no"
+    assert labels[("__start__", "decide")] is None
+    print("edge labels + node metadata OK")
+
+
 if __name__ == "__main__":
     test_cost(); print("cost OK")
     test_store_roundtrip()
@@ -377,4 +503,8 @@ 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()
+    test_streaming_partials_params_tools()
+    test_edge_labels_and_node_metadata()
     print("ALL SMOKE TESTS PASSED")

{windhover-0.9.0 → windhover-0.11.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.11.0}/windhover/extract.py

@@ -10,10 +10,12 @@ import sys, json, importlib, inspect, functools
 def topology(graph, xray: bool = False) -> dict:
     g = graph.get_graph(xray=True) if xray else graph.get_graph()
     nodes = [{"id": nid, "label": str(getattr(n, "name", nid)).replace("__", ""),
-              "terminal": nid.endswith(("__start__", "__end__"))}
+              "terminal": nid.endswith(("__start__", "__end__")),
+              "metadata": getattr(n, "metadata", None) or None}
              for nid, n in g.nodes.items()]
     edges = [{"id": f"e{i}", "source": e.source, "target": e.target,
-              "conditional": bool(getattr(e, "conditional", False))}
+              "conditional": bool(getattr(e, "conditional", False)),
+              "label": str(e.data) if getattr(e, "data", None) not in (None, e.target) else None}
              for i, e in enumerate(g.edges)]
     return {"nodes": nodes, "edges": edges}
 
@@ -28,6 +30,18 @@ def input_schema(graph) -> dict:
     return {}
 
 
+def context_schema(graph) -> dict:
+    """Runtime context/config schema (langgraph >=1.0 name, older fallback)."""
+    for meth in ("get_context_jsonschema", "get_config_jsonschema"):
+        try:
+            s = getattr(graph, meth)()
+            if isinstance(s, dict) and s.get("properties"):
+                return s
+        except Exception:
+            continue
+    return {}
+
+
 def _unwrap(fn):
     """Peel partials, decorators, and bound methods down to the user function."""
     seen = set()
@@ -93,7 +107,8 @@ def load(ref: str, dir_: str):
 if __name__ == "__main__":
     ref, dir_ = sys.argv[1], sys.argv[2]
     g = load(ref, dir_)
-    out = {"topology": topology(g), "schema": input_schema(g), "sources": sources(g)}
+    out = {"topology": topology(g), "schema": input_schema(g), "sources": sources(g),
+           "context_schema": context_schema(g)}
     try:  # subgraph x-ray view, only when it actually differs
         tx = topology(g, xray=True)
         if tx != out["topology"]:

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

@@ -156,38 +156,29 @@ def api_graph():
 @app.get("/api/schema")
 def api_schema():
     s = TOPO.schema()
-    return JSONResponse({"schema": s, "template": _template(s)})
+    with TOPO.lock:
+        ctx = TOPO.data.get("context_schema") or {}
+    return JSONResponse({"schema": s, "template": _template(s),
+                         "context_schema": ctx, "context_template": _template(ctx)})
 
 
 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 +189,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 +219,89 @@ 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)
+    extra_conf = payload.pop("_configurable", 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}
+    if isinstance(extra_conf, dict) and extra_conf:
+        config.setdefault("configurable", {}).update(extra_conf)
+    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.11.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.11</span></div>
   </aside>
 
   <main>
@@ -496,6 +554,10 @@ 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 id="ctx-wrap" style="display:none"><div class="hint" style="margin:8px 0 4px">Runtime context / configurable (from the graph's context schema):</div>
+    <textarea id="ctx-json" spellcheck="false" style="min-height:70px"></textarea></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>
@@ -553,6 +615,9 @@ function cyStyle(){ return [
  {selector:'node.err',style:{'border-color':cssv('--err'),'background-color':cssv('--err-weak')}},
  {selector:'edge',style:{'width':1.6,'line-color':cssv('--border2'),'target-arrow-color':cssv('--border2'),'target-arrow-shape':'triangle','curve-style':'bezier','arrow-scale':1}},
  {selector:'edge[?conditional]',style:{'line-style':'dashed'}},
+ {selector:'edge[label]',style:{'label':'data(label)','font-size':10,
+   'font-family':'ui-monospace, Menlo, Consolas, monospace','color':cssv('--text2'),
+   'text-background-color':cssv('--bg'),'text-background-opacity':.9,'text-background-padding':2}},
  {selector:'edge.flow',style:{'line-color':cssv('--accent'),'target-arrow-color':cssv('--accent'),'width':2.4}},
 ];}
 function applyCyStyle(){ cy.style(cyStyle()); }
@@ -566,9 +631,10 @@ async function loadGraph(force){
   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; }
   const topo=(XRAY&&t.xray)?t.xray:t;
+  window.__nodes=Object.fromEntries(topo.nodes.map(n=>[n.id,n]));
   const els=[];
   topo.nodes.forEach(n=>els.push({data:{id:n.id,label:n.label,terminal:n.terminal?1:undefined}}));
-  topo.edges.forEach(e=>els.push({data:{id:e.id,source:e.source,target:e.target,conditional:e.conditional?1:undefined}}));
+  topo.edges.forEach(e=>els.push({data:{id:e.id,source:e.source,target:e.target,conditional:e.conditional?1:undefined,label:e.label||undefined}}));
   if(cy&&!force){return;}
   cy=cytoscape({container:$('#cy'),elements:els,style:cyStyle(),
     layout:layoutOpts(),minZoom:.2,maxZoom:3,wheelSensitivity:.12});
@@ -644,6 +710,8 @@ async function openNode(name){
   const hiAll=new Set();
   if(src)(d.recent||[]).forEach(r=>{ if(r.error) tbLines(r.error,src).forEach(x=>hiAll.add(x)); });
   let html=`<div class="kv"><div class="k">wiring</div><pre>${esc((inn.join(', ')||'START')+'  →  '+name+'  →  '+(out.join(', ')||'END'))}</pre></div>`;
+  const nmeta=(window.__nodes||{})[name]?.metadata;
+  if(nmeta) html+=kv('node metadata', nmeta);
   if(src) html+=`<div class="kv"><div class="k">source · ${esc((src.file||'').split('/').pop())}:${src.line_start}${hiAll.size?` · <span style="color:var(--err)">error line${hiAll.size>1?'s':''} ${[...hiAll].join(', ')}</span>`:''}
       <button class="copy" onclick="navigator.clipboard.writeText(__nodeSrc.code);toast('Copied source')">copy</button></div>${codeBlock(src,hiAll)}</div>`;
   html+=`<div class="kv"><div class="k">executions — newest first, expand for payloads</div></div>`;
@@ -698,12 +766,25 @@ 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={}; 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'); };
+$('#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){}
+  $('#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;
+    cw.style.display=has?'':'none';
+    if(has) document.getElementById('ctx-json').value=JSON.stringify(ctx,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;
+  const cw=document.getElementById('ctx-wrap');
+  if(cw&&cw.style.display!=='none'){ try{ const c=JSON.parse(document.getElementById('ctx-json').value||'{}');
+    if(Object.keys(c).length) input._configurable=c; }catch(e){ return toast('Invalid context JSON'); } }
   closeAll(); switchView('graph'); await runNow(input); };
 
 async function runNow(input){
@@ -822,6 +903,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 +932,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')
@@ -874,7 +971,7 @@ function renderSpans(list,byParent,total,depth){
         <div class="tr-meta">${meta}</div>
       </div>
       <div class="tr-detail" id="${did}">
-        ${s.model?`<div class="kv"><div class="k">model</div><pre>${esc(s.model)}${s.prompt_tokens!=null?`  ·  ${s.prompt_tokens} in / ${s.completion_tokens||0} out`:''}${s.usage_detail?'  ·  '+esc(Object.entries(s.usage_detail).map(([k,v])=>`${v} ${k.replace('input_','').replace('output_','')}`).join(', ')):''}</pre></div>`:''}
+        ${s.model?`<div class="kv"><div class="k">model</div><pre>${esc(s.model)}${s.prompt_tokens!=null?`  ·  ${s.prompt_tokens} in / ${s.completion_tokens||0} out`:''}${s.usage_detail?'  ·  '+esc(Object.entries(s.usage_detail).map(([k,v])=>`${v} ${k.replace('input_','').replace('output_','')}`).join(', ')):''}${s.params?'\n'+esc(Object.entries(s.params).map(([k,v])=>k==='tools_offered'?'tools: '+v.join(', '):k+'='+v).join('  ·  ')):''}</pre></div>`:''}
         ${s.error?`<div class="kv"><div class="k">error${s.type==='node'?`<button class="copy" onclick="showSpanSource('${s.id}')">view source</button>`:''}</div><pre class="err">${esc(s.error)}</pre><div id="src-${s.id}"></div></div>`:''}
         ${s.input!=null?kv('input',s.input):''}
         ${s.output!=null?kv('output',s.output):''}
@@ -906,6 +1003,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 +1078,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.11.0}/windhover/store.py

@@ -13,7 +13,7 @@ from __future__ import annotations
 import json, os, sqlite3, threading, time, uuid
 from typing import Any, Optional
 
-SCHEMA_VERSION = 6
+SCHEMA_VERSION = 7
 _lock = threading.Lock()
 
 
@@ -70,7 +70,7 @@ class Store:
                 c.execute("ALTER TABLE runs ADD COLUMN thread_id TEXT")
             scols = [r[1] for r in c.execute("PRAGMA table_info(spans)").fetchall()]
             for col, typ in (("retries", "INTEGER"), ("ttft_ms", "INTEGER"),
-                             ("usage_detail", "TEXT")):
+                             ("usage_detail", "TEXT"), ("params", "TEXT")):
                 if col not in scols:
                     c.execute(f"ALTER TABLE spans ADD COLUMN {col} {typ}")
             try:
@@ -139,8 +139,8 @@ class Store:
             c.execute("""INSERT OR REPLACE INTO spans
               (id,run_id,parent_id,seq,type,name,status,started_ms,ended_ms,offset_ms,
                dur_ms,input,output,model,prompt_tokens,completion_tokens,cost_usd,error,
-               retries,ttft_ms,usage_detail)
-              VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)""",
+               retries,ttft_ms,usage_detail,params)
+              VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)""",
               (s["id"], s["run_id"], s.get("parent_id"), s.get("seq", 0), s["type"],
                s.get("name"), s.get("status", "ok"), s.get("started_ms"), s.get("ended_ms"),
                s.get("offset_ms"), s.get("dur_ms"),
@@ -149,7 +149,8 @@ class Store:
                s.get("model"), s.get("prompt_tokens"), s.get("completion_tokens"),
                s.get("cost_usd"), s.get("error"),
                s.get("retries"), s.get("ttft_ms"),
-               json.dumps(s.get("usage_detail")) if s.get("usage_detail") else None))
+               json.dumps(s.get("usage_detail")) if s.get("usage_detail") else None,
+               json.dumps(s.get("params")) if s.get("params") else None))
             if self.has_fts:
                 c.execute("DELETE FROM span_fts WHERE span_id=?", (s["id"],))
                 c.execute("INSERT INTO span_fts(text,span_id,run_id) VALUES(?,?,?)",
@@ -324,7 +325,7 @@ class Store:
         for k in ("input", "tags"):
             d[k] = json.loads(d[k]) if d.get(k) else None
         for s in spans:
-            for k in ("input", "output", "usage_detail"):
+            for k in ("input", "output", "usage_detail", "params"):
                 s[k] = json.loads(s[k]) if s.get(k) else None
         d["spans"] = spans
         d["scores"] = scores

{windhover-0.9.0 → windhover-0.11.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:
@@ -152,9 +153,13 @@ class SpanBuilder(BaseCallbackHandler):
                      model=None, pt=None, ct=None, usage_detail=None):
         now = time.time()
         sid = info["span_id"]
+        seq = info.get("seq")
+        if seq is None:
+            seq = self._seq
+            self._seq += 1
         self._emit({"kind": "span", "id": sid, "run_id": self.run_id,
                     "parent_id": self._span_of.get(info.get("parent")),
-                    "seq": self._seq, "type": info["type"], "name": info["name"],
+                    "seq": seq, "type": info["type"], "name": info["name"],
                     "status": status, "started_ms": int(info["t"] * 1000),
                     "ended_ms": int(now * 1000), "offset_ms": self._rel(info["t"]),
                     "dur_ms": int((now - info["t"]) * 1000),
@@ -163,8 +168,7 @@ class SpanBuilder(BaseCallbackHandler):
                     "cost_usd": cost_of(model, pt, ct), "error": error,
                     "retries": info.get("retries"),
                     "ttft_ms": int(info["ttft"] * 1000) if info.get("ttft") is not None else None,
-                    "usage_detail": usage_detail})
-        self._seq += 1
+                    "usage_detail": usage_detail, "params": info.get("params")})
 
     # -- chains / nodes --
     _INTERNAL_TAG_PREFIXES = ("graph:", "langsmith:", "seq:", "langgraph_")
@@ -179,6 +183,8 @@ class SpanBuilder(BaseCallbackHandler):
             #   config={"metadata": {"windhover_session": ..., "windhover_tags": [...]},
             #           "tags": [...]}
             md = metadata or {}
+            if md.get("windhover_run_name"):
+                self.run_name = str(md["windhover_run_name"])
             if md.get("windhover_session"):
                 self.session = str(md["windhover_session"])
             user_tags = [t for t in (tags or [])
@@ -206,8 +212,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 +228,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)
@@ -227,12 +262,31 @@ class SpanBuilder(BaseCallbackHandler):
                         "ended_ms": int(time.time() * 1000), "error": err})
 
     # -- LLMs --
+    @staticmethod
+    def _llm_params(kw) -> Optional[dict]:
+        inv = kw.get("invocation_params") or {}
+        out = {}
+        for k in ("temperature", "max_tokens", "max_completion_tokens", "stream", "top_p"):
+            if inv.get(k) is not None:
+                out[k] = inv[k]
+        tools = []
+        for tl in (inv.get("tools") or []):
+            fn = tl.get("function", tl) if isinstance(tl, dict) else {}
+            if isinstance(fn, dict) and fn.get("name"):
+                tools.append(fn["name"])
+        if tools:
+            out["tools_offered"] = tools
+        return out or None
+
     def _llm_start(self, serialized, prompt, run_id, parent_run_id, kw):
         sid = uuid.uuid4().hex[:12]
         self._span_of[run_id] = sid
+        seq = self._seq
+        self._seq += 1  # reserved now so streaming partials keep a stable order
         self._open[run_id] = {"span_id": sid, "type": "llm",
                               "name": _model_name(serialized, kw), "t": time.time(),
-                              "parent": parent_run_id, "input": _trunc(prompt)}
+                              "parent": parent_run_id, "input": _trunc(prompt),
+                              "seq": seq, "params": self._llm_params(kw)}
 
     def on_llm_start(self, serialized, prompts, *, run_id=None, parent_run_id=None, **kw):
         self._llm_start(serialized, prompts, run_id, parent_run_id, kw)
@@ -255,10 +309,30 @@ class SpanBuilder(BaseCallbackHandler):
             self._finish_span(info, status="error", error=_err_text(error), model=info["name"])
 
     def on_llm_new_token(self, token, *, run_id=None, **kw):
-        # streaming: first token stamps time-to-first-token
+        # streaming: first token stamps time-to-first-token; the growing text is
+        # flushed as a partial span every ~0.5s so a live-tailed drawer shows
+        # the model typing
         info = self._open.get(run_id)
-        if info is not None and "ttft" not in info:
-            info["ttft"] = time.time() - info["t"]
+        if info is None:
+            return
+        now = time.time()
+        if "ttft" not in info:
+            info["ttft"] = now - info["t"]
+        info["buf"] = (info.get("buf") or "") + (token or "")
+        if now - info.get("flushed", 0) >= 0.5 and info.get("buf"):
+            info["flushed"] = now
+            self._emit({"kind": "span", "id": info["span_id"], "run_id": self.run_id,
+                        "parent_id": self._span_of.get(info.get("parent")),
+                        "seq": info["seq"], "type": "llm", "name": info["name"],
+                        "status": "running", "started_ms": int(info["t"] * 1000),
+                        "ended_ms": None, "offset_ms": self._rel(info["t"]),
+                        "dur_ms": int((now - info["t"]) * 1000),
+                        "input": info.get("input"), "output": info["buf"][-4000:],
+                        "model": info["name"], "prompt_tokens": None,
+                        "completion_tokens": None, "cost_usd": None, "error": None,
+                        "retries": info.get("retries"),
+                        "ttft_ms": int(info["ttft"] * 1000),
+                        "usage_detail": None, "params": info.get("params")})
 
     # -- retries (tenacity, e.g. rate limits) --
     def on_retry(self, retry_state, *, run_id=None, **kw):