windhover 0.8.0__tar.gz → 0.9.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: windhover
-Version: 0.8.0
+Version: 0.9.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
@@ -90,7 +90,14 @@ 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.
+- **Live tail** — open a running run and watch its spans arrive in real time; nodes can push
+  progress via LangGraph's `get_stream_writer()`.
+- **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
+  time-to-first-token; cache-read / reasoning token details show on the model line.
+- **Memory browser** — graphs compiled with a LangGraph `Store` get a Memory view: browse
+  namespaces and search long-term memory items.
 - **Time-travel** — checkpointed graphs get a per-thread checkpoint browser: state, writes,
   and next-nodes at every superstep (`get_state_history`).
 - **Run diff** — compare any two runs node-by-node: identical vs differing outputs,

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

@@ -71,7 +71,14 @@ 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.
+- **Live tail** — open a running run and watch its spans arrive in real time; nodes can push
+  progress via LangGraph's `get_stream_writer()`.
+- **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
+  time-to-first-token; cache-read / reasoning token details show on the model line.
+- **Memory browser** — graphs compiled with a LangGraph `Store` get a Memory view: browse
+  namespaces and search long-term memory items.
 - **Time-travel** — checkpointed graphs get a per-thread checkpoint browser: state, writes,
   and next-nodes at every superstep (`get_state_history`).
 - **Run diff** — compare any two runs node-by-node: identical vs differing outputs,

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

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

@@ -299,6 +299,67 @@ def test_datasets_and_scoring():
     print("datasets + scoring OK")
 
 
+def test_ttft_retry_custom_event_usage_detail():
+    p = tempfile.mktemp(suffix=".db")
+    s = Store(p)
+    tr = SpanBuilder(db_sink(s), run_name="deep")
+    tr.on_chain_start({}, {"q": 1}, run_id="root", parent_run_id=None)
+    tr.on_chat_model_start({"kwargs": {"model": "gpt-4o"}}, [[]],
+                           run_id="llm1", parent_run_id="root")
+    time.sleep(0.02)
+    tr.on_llm_new_token("Hel", run_id="llm1")          # -> ttft stamped
+    tr.on_llm_new_token("lo", run_id="llm1")           # ignored (only first counts)
+
+    class RS:  # tenacity RetryCallState stand-in
+        attempt_number = 3
+    tr.on_retry(RS(), run_id="llm1")
+
+    class Msg:
+        content = "Hello"
+        usage_metadata = {"input_tokens": 900, "output_tokens": 40,
+                          "input_token_details": {"cache_read": 700},
+                          "output_token_details": {"reasoning": 12}}
+    class Gen:
+        text = "Hello"; message = Msg()
+    class Resp:
+        llm_output = None; generations = [[Gen()]]
+    tr.on_llm_end(Resp(), run_id="llm1")
+    tr.on_custom_event("checkpoint-saved", {"rows": 42}, run_id="root")
+    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["ttft_ms"] is not None and llm["ttft_ms"] >= 15
+    assert llm["retries"] == 3
+    assert llm["usage_detail"] == {"input_cache_read": 700, "output_reasoning": 12}
+    assert llm["prompt_tokens"] == 900
+    ev = [x for x in d["spans"] if x["type"] == "event"]
+    assert ev and ev[0]["name"] == "checkpoint-saved" and ev[0]["output"] == {"rows": 42}
+    print("ttft/retry/custom-event/usage-detail OK")
+
+
+def test_demo_memory_and_events_end_to_end():
+    """Demo graph writes long-term memory + dispatches a custom event — both
+    must be observable."""
+    import importlib
+    import windhover.demo_graph as dg
+    importlib.reload(dg)  # fresh InMemoryStore per test
+    p = tempfile.mktemp(suffix=".db")
+    s = Store(p)
+    tr = SpanBuilder(db_sink(s), run_name="demo")
+    dg.graph.invoke({"n": 7}, config={"callbacks": [tr],
+                                      "configurable": {"thread_id": "mem-t"}})
+    time.sleep(.1)
+    d = s.run_detail(tr.run_id)
+    ev = [x for x in d["spans"] if x["type"] == "event"]
+    assert ev and ev[0]["name"] == "summary-ready", [x["type"] for x in d["spans"]]
+    assert dg.graph.store is not None
+    items = dg.graph.store.search(("demo", "summaries"))
+    assert items and items[0].value["n"] == 21   # n=7 -> grow x3
+    assert ("demo", "summaries") in dg.graph.store.list_namespaces()
+    print("demo memory + custom event end-to-end OK")
+
+
 if __name__ == "__main__":
     test_cost(); print("cost OK")
     test_store_roundtrip()
@@ -314,4 +375,6 @@ if __name__ == "__main__":
     test_auth_check()
     test_thread_capture_and_history()
     test_datasets_and_scoring()
+    test_ttft_retry_custom_event_usage_detail()
+    test_demo_memory_and_events_end_to_end()
     print("ALL SMOKE TESTS PASSED")

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

@@ -28,7 +28,22 @@ def grow(s):       time.sleep(.3);  return {"n": s["n"] * 3}
 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"]}
-def summarize(s):  time.sleep(.2);  return {"notes": [f"n={s['n']}: " + ", ".join(s["notes"])]}
+def summarize(s):
+    time.sleep(.1)
+    try:  # progress + custom events + long-term memory, all observable in Windhover
+        from langgraph.config import get_stream_writer, get_store
+        writer = get_stream_writer()
+        writer({"stage": "summarize", "pct": 50})
+        from langchain_core.callbacks import dispatch_custom_event
+        dispatch_custom_event("summary-ready", {"n": s["n"], "parts": len(s["notes"])})
+        store = get_store()
+        if store is not None:
+            store.put(("demo", "summaries"), f"n-{s['n']}",
+                      {"n": s["n"], "notes": s["notes"]})
+    except Exception:
+        pass
+    time.sleep(.1)
+    return {"notes": [f"n={s['n']}: " + ", ".join(s["notes"])]}
 
 
 _g = StateGraph(State)
@@ -45,8 +60,9 @@ _g.add_edge("sign", "summarize")
 _g.add_edge("magnitude", "summarize")
 _g.add_edge("summarize", END)
 
-try:  # checkpointer makes the Time-travel view demoable; optional dependency surface
+try:  # checkpointer + store make Time-travel and Memory demoable
     from langgraph.checkpoint.memory import MemorySaver
-    graph = _g.compile(checkpointer=MemorySaver())
+    from langgraph.store.memory import InMemoryStore
+    graph = _g.compile(checkpointer=MemorySaver(), store=InMemoryStore())
 except Exception:
     graph = _g.compile()

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

@@ -186,9 +186,13 @@ async def api_run(request: Request):
     def worker():
         try:
             interrupted = False
-            for update in graph.stream(payload, config=config,
-                                       stream_mode="updates"):
-                for node in update:
+            for mode, chunk in graph.stream(payload, config=config,
+                                            stream_mode=["updates", "custom"]):
+                if mode == "custom":
+                    # get_stream_writer() output from inside a node -> live progress
+                    q.put(("progress", {"data": _trunc(chunk, 600)}))
+                    continue
+                for node in chunk:
                     if node == "__interrupt__":
                         interrupted = True
                         q.put(("interrupt", {"run_id": run_id}))
@@ -340,6 +344,36 @@ def api_thread_history(thread_id: str, limit: int = 80):
     return JSONResponse({"thread_id": thread_id, "steps": steps})
 
 
+@app.get("/api/memory/namespaces")
+def api_memory_namespaces():
+    """LangGraph long-term memory (Store) browser — namespaces."""
+    st = getattr(graph, "store", None) if graph is not None else None
+    if st is None:
+        return JSONResponse({"error": "no local graph with a store"}, 404)
+    try:
+        return JSONResponse({"namespaces": [list(ns) for ns in st.list_namespaces()]})
+    except Exception as e:
+        return JSONResponse({"error": str(e)}, 500)
+
+
+@app.get("/api/memory/items")
+def api_memory_items(namespace: str, query: str = None, limit: int = 50):
+    """Items in one namespace (dot-separated); optional semantic/text query."""
+    st = getattr(graph, "store", None) if graph is not None else None
+    if st is None:
+        return JSONResponse({"error": "no local graph with a store"}, 404)
+    try:
+        ns = tuple(namespace.split(".")) if namespace else ()
+        items = st.search(ns, query=query, limit=max(1, min(limit, 200)))
+        return JSONResponse({"namespace": namespace, "items": [
+            {"key": i.key, "value": _trunc(i.value, 3000),
+             "created_at": str(getattr(i, "created_at", "") or "") or None,
+             "updated_at": str(getattr(i, "updated_at", "") or "") or None,
+             "score": getattr(i, "score", None)} for i in items]})
+    except Exception as e:
+        return JSONResponse({"error": str(e)}, 500)
+
+
 @app.get("/api/datasets")
 def api_datasets():
     return JSONResponse([{k: d[k] for k in ("id", "name", "n_items", "created_ms")}

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

@@ -236,6 +236,7 @@ window.pickDiff=async(id)=>{
 .chip.tool{background:var(--chip-tool);color:var(--chip-tool-t)}
 .chip.retriever{background:var(--chip-ret);color:var(--chip-ret-t)}
 .chip.interrupt{background:var(--warn-weak);color:var(--warn)}
+.chip.event{background:var(--surface2);color:var(--text2);border:1px dashed var(--border2)}
 .tr-name{font-weight:600;font-size:13px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
 .tr-name.err{color:var(--err)}
 .tr-gantt{height:6px;background:var(--surface2);border-radius:3px;position:relative;overflow:hidden}
@@ -250,6 +251,12 @@ window.pickDiff=async(id)=>{
 .code .ln{color:var(--muted);text-align:right;user-select:none;position:sticky;left:-12px;background:var(--surface2);padding-left:12px}
 .code .cl{white-space:pre}
 .code .errline{background:var(--err-weak)}
+.py-k{color:var(--accent-text);font-weight:600}
+.py-s{color:var(--ok)}
+.py-c{color:var(--muted);font-style:italic}
+.py-n{color:var(--chip-tool-t)}
+.py-d{color:var(--chip-llm-t)}
+.py-f{font-weight:700}
 .code .cl.errline{box-shadow:inset 3px 0 0 var(--err);padding-left:6px;margin-left:-6px}
 .errhint{font:11px var(--mono);color:var(--err);margin-top:3px;max-width:400px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
 .diffgrid{display:grid;grid-template-columns:1fr 1fr;gap:10px}
@@ -341,6 +348,8 @@ th{font-family:var(--mono);letter-spacing:.11em;font-size:10.5px}
 .tr-bar.tool{background:var(--chip-tool-t)}
 .tr-bar.retriever{background:var(--chip-ret-t)}
 .tr-bar.interrupt{background:var(--warn)}
+.tr-bar.event{background:var(--border2)}
+.badge-retry{font-family:var(--mono);font-size:10px;color:var(--warn);background:var(--warn-weak);border-radius:5px;padding:1px 6px;margin-left:6px}
 .charts .card:nth-child(2) .cbar{background:var(--chip-llm-t)}
 #cy{background:radial-gradient(circle,var(--border) 1px,transparent 1.5px) 0 0/24px 24px}
 .legend{font-family:var(--mono);font-size:10.5px;letter-spacing:.06em;text-transform:uppercase}
@@ -384,9 +393,10 @@ th{font-family:var(--mono);letter-spacing:.11em;font-size:10.5px}
       <button data-v="graph" class="on">${ICON.graph} Graph</button>
       <button data-v="runs">${ICON.list} Runs</button>
       <button data-v="sessions">${ICON.layers} Sessions</button>
+      <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.8</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.9</span></div>
   </aside>
 
   <main>
@@ -438,6 +448,16 @@ th{font-family:var(--mono);letter-spacing:.11em;font-size:10.5px}
           <div class="card"><div id="sess-wrap"><div class="empty">Loading…</div></div></div>
         </div>
       </div>
+      <div id="view-memory" style="display:none">
+        <div class="page">
+          <div class="page-head"><h1>Memory</h1><span class="sub">LangGraph long-term store</span></div>
+          <div class="rtools">
+            <select id="mem-ns"></select>
+            <input type="search" id="mem-q" placeholder="Search this namespace…">
+          </div>
+          <div class="card"><div id="mem-wrap"><div class="empty">Loading…</div></div></div>
+        </div>
+      </div>
       <div id="view-stats" style="display:none">
         <div class="page">
           <div class="page-head"><h1>Stats</h1><span class="sub">all recorded runs</span></div>
@@ -452,6 +472,7 @@ th{font-family:var(--mono);letter-spacing:.11em;font-size:10.5px}
   <button data-v="graph" class="on">${ICON.graph}<span>Graph</span></button>
   <button data-v="runs">${ICON.list}<span>Runs</span></button>
   <button data-v="sessions">${ICON.layers}<span>Sessions</span></button>
+  <button data-v="memory" class="nav-mem" style="display:none">${ICON.mem}<span>Memory</span></button>
   <button data-v="stats">${ICON.chart}<span>Stats</span></button>
 </div>
 
@@ -491,6 +512,7 @@ const ICON = {
   list:'<svg viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round"><path d="M8 6h12M8 12h12M8 18h12"/><circle cx="4" cy="6" r="1.1" fill="currentColor" stroke="none"/><circle cx="4" cy="12" r="1.1" fill="currentColor" stroke="none"/><circle cx="4" cy="18" r="1.1" fill="currentColor" stroke="none"/></svg>',
   chart:'<svg viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round"><path d="M4 20V9M10 20V4M16 20v-7M21 20H3"/></svg>',
   layers:'<svg viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linejoin="round"><path d="M12 3 3 8l9 5 9-5-9-5z"/><path d="M3 13l9 5 9-5"/></svg>',
+  mem:'<svg viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round"><ellipse cx="12" cy="5.5" rx="7.5" ry="2.8"/><path d="M4.5 5.5v6c0 1.6 3.4 2.8 7.5 2.8s7.5-1.2 7.5-2.8v-6"/><path d="M4.5 11.5v6c0 1.6 3.4 2.8 7.5 2.8s7.5-1.2 7.5-2.8v-6"/></svg>',
   play:'<svg viewBox="0 0 24 24" width="14" height="14" fill="currentColor"><path d="M7 4.8v14.4c0 .8.9 1.3 1.6.9l11-7.2c.6-.4.6-1.4 0-1.8l-11-7.2c-.7-.4-1.6.1-1.6.9z"/></svg>',
   moon:'<svg viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round"><path d="M20 13.5A8 8 0 1 1 10.5 4 6.5 6.5 0 0 0 20 13.5z"/></svg>',
   x:'<svg viewBox="0 0 24 24" width="15" height="15" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round"><path d="M6 6l12 12M18 6L6 18"/></svg>',
@@ -581,9 +603,23 @@ function tbLines(err,src){ const out=new Set();
     if(m[1].split('/').pop()===base){ const ln=+m[2];
       if(ln>=src.line_start&&ln<=src.line_end) out.add(ln); } }
   return out; }
+const PY_TOKEN=/(#.*$)|("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')|(@\w+)|\b(def|class|return|if|elif|else|for|while|try|except|finally|raise|with|as|import|from|lambda|pass|break|continue|and|or|not|in|is|None|True|False|global|nonlocal|yield|async|await|del|assert|self)\b|(\b\d+(?:\.\d+)?\b)/g;
+function pyHi(line){ let out='',last=0,defNext=false;
+  for(const m of line.matchAll(PY_TOKEN)){
+    out+=esc(line.slice(last,m.index)); last=m.index+m[0].length;
+    const t=esc(m[0]);
+    if(m[1])      out+=`<span class="py-c">${t}</span>`;
+    else if(m[2]) out+=`<span class="py-s">${t}</span>`;
+    else if(m[3]) out+=`<span class="py-d">${t}</span>`;
+    else if(m[4]) out+=`<span class="py-k">${t}</span>`;
+    else          out+=`<span class="py-n">${t}</span>`;
+  }
+  out+=esc(line.slice(last));
+  // bold the name right after def/class
+  return out.replace(/(<span class="py-k">(?:def|class)<\/span> )([A-Za-z_]\w*)/,'$1<span class="py-f">$2</span>'); }
 function codeBlock(src,hi){ const lines=src.code.replace(/\n$/,'').split('\n');
   return `<div class="code">${lines.map((l,i)=>{ const ln=src.line_start+i, h=hi.has(ln);
-    return `<span class="ln ${h?'errline':''}">${ln}</span><span class="cl ${h?'errline':''}">${esc(l)||' '}</span>`;
+    return `<span class="ln ${h?'errline':''}">${ln}</span><span class="cl ${h?'errline':''}">${pyHi(l)||' '}</span>`;
   }).join('')}</div>`; }
 
 /* ---------- node pane (tap a node on the graph) ---------- */
@@ -653,9 +689,10 @@ function switchView(v){ VIEW=v;
   if(location.hash!=='#'+v) history.replaceState(null,'','#'+v);
   $$('.nav button,.bottom-nav button').forEach(b=>b.classList.toggle('on',b.dataset.v===v));
   $('#crumb').textContent=v[0].toUpperCase()+v.slice(1);
-  for(const k of ['graph','runs','sessions','stats'])
+  for(const k of ['graph','runs','sessions','memory','stats'])
     $('#view-'+k).style.display=v===k?'':'none';
-  if(v==='runs')loadRuns(); if(v==='sessions')loadSessions(); if(v==='stats'){loadStats();loadDatasets();}
+  if(v==='runs')loadRuns(); if(v==='sessions')loadSessions(); if(v==='memory')loadMemory();
+  if(v==='stats'){loadStats();loadDatasets();}
   if(cy&&v==='graph')setTimeout(()=>cy.resize(),40);
 }
 $$('.nav button,.bottom-nav button').forEach(b=>b.onclick=()=>switchView(b.dataset.v));
@@ -680,6 +717,7 @@ async function runNow(input){
       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.$id(prev).addClass('done').removeClass('running'); cy.$id(d.node).addClass('running');
           cy.edges(`[source="${prev}"][target="${d.node}"]`).addClass('flow'); prev=d.node; }
+        else if(ev==='progress'){ toast('progress: '+JSON.stringify(d.data).slice(0,120)); }
         else if(ev==='interrupt'){ toast('Run paused at an interrupt — awaiting resume'); }
         else if(ev==='interrupted'){ cy.$id(prev).addClass('running'); toast('Run interrupted — see Runs for the payload'); }
         else if(ev==='done'){ cy.$id(prev).addClass('done').removeClass('running'); cy.$id('__end__').addClass('done'); toast('Run complete — saved to Runs'); }
@@ -823,6 +861,7 @@ function renderSpans(list,byParent,total,depth){
     const kids=byParent[s.id]||[];
     const left=((s.offset_ms||0)/total*100).toFixed(2), width=Math.max(1.2,(s.dur_ms||0)/total*100).toFixed(2);
     const meta=[s.dur_ms!=null?s.dur_ms+'ms':null,
+      s.ttft_ms!=null?'ttft '+s.ttft_ms+'ms':null,
       s.type==='llm'&&(s.prompt_tokens!=null||s.completion_tokens!=null)?fmtk((s.prompt_tokens||0)+(s.completion_tokens||0))+'t':null,
       s.cost_usd!=null?'$'+s.cost_usd.toFixed(4):null].filter(Boolean).join(' · ');
     const did='sp'+s.id;
@@ -830,12 +869,12 @@ function renderSpans(list,byParent,total,depth){
       <div class="tr-row" onclick="tog('${did}',this)">
         <div class="tr-main"><span class="indent" style="width:${depth*18}px"></span>
           <span class="caret">▶</span><span class="chip ${s.type}">${s.type}</span>
-          <span class="tr-name ${s.status==='error'?'err':''}">${esc(s.name||s.type)}</span></div>
+          <span class="tr-name ${s.status==='error'?'err':''}">${esc(s.name||s.type)}</span>${s.retries?`<span class="badge-retry">↻${s.retries}</span>`:''}</div>
         <div class="tr-gantt"><div class="tr-bar ${s.type}" style="left:${left}%;width:${width}%"></div></div>
         <div class="tr-meta">${meta}</div>
       </div>
       <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`:''}</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(', ')):''}</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):''}
@@ -989,6 +1028,37 @@ function fmtk(n){ return n<1000?String(n):(n/1000).toFixed(1)+'k'; }
 function ago(ms){ const s=(Date.now()-ms)/1000; if(s<60)return Math.round(s)+'s ago'; if(s<3600)return Math.round(s/60)+'m ago'; if(s<86400)return Math.round(s/3600)+'h ago'; return Math.round(s/86400)+'d ago'; }
 let tT; function toast(m){ const t=$('#toast'); t.textContent=m; t.classList.add('show'); clearTimeout(tT); tT=setTimeout(()=>t.classList.remove('show'),2600); }
 
+let MEM_NS=[];
+async function probeMemory(){
+  try{ const r=await fetch('/api/memory/namespaces'); if(!r.ok) return;
+    MEM_NS=(await r.json()).namespaces||[];
+    document.getElementById('nav-mem').style.display='';
+    const m=document.querySelector('.bottom-nav .nav-mem'); if(m)m.style.display='';
+  }catch(e){}
+}
+async function loadMemory(){
+  const sel=document.getElementById('mem-ns');
+  try{ const r=await fetch('/api/memory/namespaces'); MEM_NS=(await r.json()).namespaces||[]; }catch(e){}
+  const cur=sel.value;
+  sel.innerHTML=MEM_NS.map(ns=>`<option value="${esc(ns.join('.'))}">${esc(ns.join(' / '))}</option>`).join('');
+  if(cur) sel.value=cur;
+  const ns=sel.value;
+  const w=document.getElementById('mem-wrap');
+  if(!ns){ w.innerHTML='<div class="empty"><div class="t">No memories yet</div>Nodes write with <span class="mono">get_store().put(namespace, key, value)</span> — items appear here.</div>'; return; }
+  const q=document.getElementById('mem-q').value.trim();
+  const p=new URLSearchParams({namespace:ns}); if(q)p.set('query',q);
+  let d={items:[]}; try{ d=await(await fetch('/api/memory/items?'+p)).json(); }catch(e){}
+  w.innerHTML=(d.items||[]).length?`<div style="overflow:auto"><table>
+    <thead><tr><th>Key</th><th>Value</th><th class="r">Updated</th></tr></thead>
+    <tbody>${d.items.map(i=>`<tr>
+      <td class="mono" style="font-weight:600;white-space:nowrap">${esc(i.key)}</td>
+      <td><pre style="margin:0;white-space:pre-wrap;word-break:break-word;font:12px/1.5 var(--mono);max-width:640px">${esc(JSON.stringify(i.value,null,1)).slice(0,600)}</pre></td>
+      <td class="r" style="color:var(--muted);white-space:nowrap">${i.updated_at?esc(String(i.updated_at).slice(0,19).replace('T',' ')):'—'}</td></tr>`).join('')}</tbody></table></div>`
+    :'<div class="empty">Nothing in this namespace'+(q?' matching that query':'')+'.</div>';
+}
+document.addEventListener('change',e=>{ if(e.target&&e.target.id==='mem-ns') loadMemory(); });
+let memQT; document.addEventListener('input',e=>{ if(e.target&&e.target.id==='mem-q'){ clearTimeout(memQT); memQT=setTimeout(loadMemory,300); } });
+
 async function loadDatasets(){
   const w=document.getElementById('ds-wrap'); if(!w) return;
   let ds=[]; try{ ds=await(await fetch('/api/datasets')).json(); }catch(e){}
@@ -1007,7 +1077,7 @@ window.runDataset=async(id,name)=>{
   toast('Eval started: '+d.items+' items → session '+d.session);
 };
 window.delDataset=async(id)=>{ await fetch('/api/datasets/'+id,{method:'DELETE'}); loadDatasets(); };
-loadGraph(); liveTopology();
+loadGraph(); liveTopology(); probeMemory();
 /* deep links: #runs #sessions #stats #run=<id> */
 (function(){ const h=location.hash.slice(1);
   if(h==='runs'||h==='sessions'||h==='stats') switchView(h);

{windhover-0.8.0 → windhover-0.9.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 = 5
+SCHEMA_VERSION = 6
 _lock = threading.Lock()
 
 
@@ -68,6 +68,11 @@ class Store:
                 c.execute("ALTER TABLE runs ADD COLUMN bookmarked INTEGER DEFAULT 0")
             if "thread_id" not in cols:
                 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")):
+                if col not in scols:
+                    c.execute(f"ALTER TABLE spans ADD COLUMN {col} {typ}")
             try:
                 c.execute("SELECT count(*) FROM json_each('[1]')")
                 self.has_json1 = True
@@ -133,15 +138,18 @@ class Store:
         with _lock, self._conn() as c:
             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)
-              VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)""",
+               dur_ms,input,output,model,prompt_tokens,completion_tokens,cost_usd,error,
+               retries,ttft_ms,usage_detail)
+              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"),
                json.dumps(s.get("input"), default=str) if s.get("input") is not None else None,
                json.dumps(s.get("output"), default=str) if s.get("output") is not None else None,
                s.get("model"), s.get("prompt_tokens"), s.get("completion_tokens"),
-               s.get("cost_usd"), s.get("error")))
+               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))
             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(?,?,?)",
@@ -316,7 +324,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"):
+            for k in ("input", "output", "usage_detail"):
                 s[k] = json.loads(s[k]) if s.get(k) else None
         d["spans"] = spans
         d["scores"] = scores

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

@@ -77,24 +77,31 @@ def _model_name(serialized: dict, kw: dict) -> str:
     return ids[-1] if ids else "llm"
 
 
-def _usage(response: Any) -> tuple[Optional[int], Optional[int]]:
+def _usage(response: Any) -> tuple[Optional[int], Optional[int], Optional[dict]]:
+    """(prompt, completion, detail) — detail carries cache_read/cache_creation/
+    reasoning token counts when the provider reports them."""
     # OpenAI-style aggregate
     out = getattr(response, "llm_output", None) or {}
     for key in ("token_usage", "usage"):
         u = out.get(key) if isinstance(out, dict) else None
         if u:
             return (u.get("prompt_tokens") or u.get("input_tokens"),
-                    u.get("completion_tokens") or u.get("output_tokens"))
+                    u.get("completion_tokens") or u.get("output_tokens"), None)
     # per-generation usage_metadata (chat models)
     try:
         for gens in response.generations:
             for g in gens:
                 um = getattr(getattr(g, "message", None), "usage_metadata", None)
                 if um:
-                    return um.get("input_tokens"), um.get("output_tokens")
+                    detail = {}
+                    for side in ("input_token_details", "output_token_details"):
+                        for k, v in (um.get(side) or {}).items():
+                            if v:
+                                detail[f"{side.split('_')[0]}_{k}"] = v
+                    return um.get("input_tokens"), um.get("output_tokens"), detail or None
     except Exception:
         pass
-    return None, None
+    return None, None, None
 
 
 def _gen_text(response: Any) -> str:
@@ -142,7 +149,7 @@ class SpanBuilder(BaseCallbackHandler):
         return int((t - (self._t0 or t)) * 1000)
 
     def _finish_span(self, info: dict, *, output=None, status="ok", error=None,
-                     model=None, pt=None, ct=None):
+                     model=None, pt=None, ct=None, usage_detail=None):
         now = time.time()
         sid = info["span_id"]
         self._emit({"kind": "span", "id": sid, "run_id": self.run_id,
@@ -153,7 +160,10 @@ class SpanBuilder(BaseCallbackHandler):
                     "dur_ms": int((now - info["t"]) * 1000),
                     "input": info.get("input"), "output": output, "model": model,
                     "prompt_tokens": pt, "completion_tokens": ct,
-                    "cost_usd": cost_of(model, pt, ct), "error": error})
+                    "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
 
     # -- chains / nodes --
@@ -235,15 +245,41 @@ class SpanBuilder(BaseCallbackHandler):
         info = self._open.pop(run_id, None)
         if not info:
             return
-        pt, ct = _usage(response)
+        pt, ct, detail = _usage(response)
         self._finish_span(info, output=_gen_text(response)[:4000],
-                          model=info["name"], pt=pt, ct=ct)
+                          model=info["name"], pt=pt, ct=ct, usage_detail=detail)
 
     def on_llm_error(self, error, *, run_id=None, **kw):
         info = self._open.pop(run_id, None)
         if info:
             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
+        info = self._open.get(run_id)
+        if info is not None and "ttft" not in info:
+            info["ttft"] = time.time() - info["t"]
+
+    # -- retries (tenacity, e.g. rate limits) --
+    def on_retry(self, retry_state, *, run_id=None, **kw):
+        info = self._open.get(run_id)
+        if info is not None:
+            info["retries"] = getattr(retry_state, "attempt_number", None) or \
+                              (info.get("retries") or 0) + 1
+
+    # -- custom events (langchain dispatch_custom_event) --
+    def on_custom_event(self, name, data, *, run_id=None, **kw):
+        now = time.time()
+        self._emit({"kind": "span", "id": uuid.uuid4().hex[:12], "run_id": self.run_id,
+                    "parent_id": self._span_of.get(run_id),
+                    "seq": self._seq, "type": "event", "name": str(name), "status": "ok",
+                    "started_ms": int(now * 1000), "ended_ms": int(now * 1000),
+                    "offset_ms": self._rel(now), "dur_ms": 0,
+                    "input": None, "output": _trunc(data), "model": None,
+                    "prompt_tokens": None, "completion_tokens": None,
+                    "cost_usd": None, "error": None})
+        self._seq += 1
+
     # -- retrievers (LangChain RAG) --
     def on_retriever_start(self, serialized, query, *, run_id=None, parent_run_id=None, **kw):
         sid = uuid.uuid4().hex[:12]