windhover 0.10.0__tar.gz → 0.11.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: windhover
-Version: 0.10.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
@@ -93,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.10.0 → windhover-0.11.0}/README.md

@@ -74,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.10.0 → windhover-0.11.0}/pyproject.toml

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

@@ -423,6 +423,69 @@ def test_static_breakpoint_and_state_edit():
     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()
@@ -442,4 +505,6 @@ if __name__ == "__main__":
     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.10.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.10.0 → windhover-0.11.0}/windhover/server.py

@@ -156,7 +156,10 @@ 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:
@@ -229,12 +232,15 @@ async def api_run(request: Request):
     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]

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

@@ -454,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.10</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>
@@ -554,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 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">
@@ -613,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()); }
@@ -626,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});
@@ -704,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>`;
@@ -758,8 +766,12 @@ 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){}
+$('#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('');
@@ -770,6 +782,9 @@ $('#do-run').onclick=async()=>{ let input; try{input=JSON.parse($('#input-json')
   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){
@@ -956,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):''}

{windhover-0.10.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.10.0 → windhover-0.11.0}/windhover/tracer.py

@@ -153,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),
@@ -164,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_")
@@ -180,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 [])
@@ -257,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)
@@ -285,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):