@miller-tech/uap 1.129.1 → 1.129.2

package/tools/agents/scripts/anthropic_proxy.py

@@ -8954,6 +8954,12 @@ async def stream_anthropic_response(
     text_chunks: list[str] = []  # accumulate text for logging
     reasoning_chunks: list[str] = []  # accumulate reasoning for fallback
 
+    # Real token counts from upstream's final usage chunk (llama-server /
+    # OpenAI emit it on the last data frame). The per-delta output_tokens
+    # counter is a chunk count that misses tool-call deltas entirely; prefer
+    # upstream truth for telemetry and the session monitor.
+    upstream_usage: dict = {}
+
     try:
         async for line in openai_stream.aiter_lines():
             if not line.startswith("data: "):
@@ -8966,6 +8972,9 @@ async def stream_anthropic_response(
             except json.JSONDecodeError:
                 continue
 
+            if isinstance(chunk.get("usage"), dict):
+                upstream_usage = chunk["usage"]
+
             choice = (chunk.get("choices") or [{}])[0]
             delta = choice.get("delta", {})
 
@@ -9239,6 +9248,28 @@ async def stream_anthropic_response(
     # message_stop
     yield f"event: message_stop\ndata: {json.dumps({'type': 'message_stop'})}\n\n"
 
+    # Per-project telemetry for the TRUE streaming path. The only other call
+    # sites are on the non-stream / guarded-non-stream paths, so streaming
+    # sessions (the client default) wrote no task_outcomes rows and
+    # per-project dashboards froze at the last non-stream response.
+    # Prefer upstream's real usage: last_input_tokens is a char-based request
+    # estimate, and the per-delta counter misses tool-call turns entirely.
+    upstream_input = int(upstream_usage.get("prompt_tokens") or 0)
+    if upstream_input > 0:
+        monitor.last_input_tokens = upstream_input
+    usage_final = {
+        "input_tokens": upstream_input or getattr(monitor, "last_input_tokens", 0) or 0,
+        "output_tokens": int(upstream_usage.get("completion_tokens") or 0) or output_tokens,
+    }
+    # After message_stop (never delays the client's final frame; a disconnect
+    # parked exactly on that yield skips recording, matching the non-stream
+    # "completed responses only" semantics) and off the event loop (a locked
+    # analytics DB must not stall token delivery for concurrent sessions).
+    try:
+        await asyncio.to_thread(_record_project_telemetry, anthropic_body, model, usage_final)
+    except Exception:
+        pass
+
 
 # ===========================================================================
 # API Endpoints

package/tools/agents/tests/test_stream_telemetry.py

@@ -0,0 +1,82 @@
+"""The TRUE streaming path must record per-project telemetry.
+
+Regression for the frozen-dashboard incident (2026-07-08): the only
+_record_project_telemetry call sites were on the non-stream / guarded
+non-stream paths, so streaming sessions (the client default) wrote no
+task_outcomes rows and per-project dashboards showed static data forever.
+"""
+import asyncio
+import importlib.util
+import unittest
+from pathlib import Path
+
+proxy_path = Path(__file__).resolve().parents[1] / "scripts" / "anthropic_proxy.py"
+spec = importlib.util.spec_from_file_location("anthropic_proxy", proxy_path)
+ap = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(ap)
+
+
+class FakeOpenAIStream:
+    """Minimal httpx.Response stand-in: yields OpenAI SSE lines."""
+
+    def __init__(self, lines):
+        self._lines = lines
+
+    async def aiter_lines(self):
+        for line in self._lines:
+            yield line
+
+    async def aclose(self):
+        pass
+
+
+OPENAI_LINES = [
+    'data: {"choices": [{"delta": {"content": "hello"}, "finish_reason": null}]}',
+    'data: {"choices": [{"delta": {}, "finish_reason": "stop"}], "usage": {"prompt_tokens": 456, "completion_tokens": 5}}',
+    "data: [DONE]",
+]
+
+
+class StreamTelemetryTest(unittest.TestCase):
+    def _drive(self, body):
+        monitor = ap.SessionMonitor()
+        monitor.last_input_tokens = 123
+        recorded = []
+        saved = ap._record_project_telemetry
+        ap._record_project_telemetry = lambda b, m, u: recorded.append((b, m, u))
+        try:
+            gen = ap.stream_anthropic_response(
+                FakeOpenAIStream(OPENAI_LINES), "test-model", monitor, body
+            )
+
+            async def consume():
+                return [frame async for frame in gen]
+
+            frames = asyncio.run(consume())
+        finally:
+            ap._record_project_telemetry = saved
+        return frames, recorded
+
+    def test_streaming_response_records_project_telemetry(self):
+        body = {"messages": [{"role": "user", "content": "hi"}]}
+        frames, recorded = self._drive(body)
+        self.assertTrue(any("message_stop" in f for f in frames))
+        self.assertEqual(len(recorded), 1)
+        recorded_body, model, usage = recorded[0]
+        self.assertIs(recorded_body, body)
+        self.assertEqual(model, "test-model")
+        # Upstream's final usage chunk wins over the request-side estimate and
+        # the per-delta chunk counter (which misses tool-call turns).
+        self.assertEqual(usage.get("input_tokens"), 456)
+        self.assertEqual(usage.get("output_tokens"), 5)
+
+    def test_telemetry_recorded_after_client_visible_stream_end(self):
+        # The recorder must not delay or reorder client frames: message_stop is
+        # emitted before the telemetry write happens.
+        frames, recorded = self._drive({"messages": []})
+        self.assertIn("message_stop", frames[-1])
+        self.assertEqual(len(recorded), 1)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/web/dashboard.html

@@ -629,6 +629,9 @@
       // page is opened without the server substitution (mutations then 401).
       const DASHBOARD_TOKEN = '__UAP_DASHBOARD_TOKEN__'.startsWith('__UAP') ? '' : '__UAP_DASHBOARD_TOKEN__';
       const MUTATION_HEADERS = { 'X-Uap-Dashboard-Token': DASHBOARD_TOKEN };
+      // Server-injected push cadence (uap dash serve --refresh); the fallback
+      // poll below matches it. 2000 when opened without server substitution.
+      const REFRESH_MS = Number('__UAP_DASH_REFRESH_MS__') > 0 ? Number('__UAP_DASH_REFRESH_MS__') : 2000;
       let ws = null;
       let reconnectTimer = null;
       let reconnectDelay = 1000;
@@ -1281,7 +1284,7 @@
       setInterval(async()=>{
         if(ws&&ws.readyState===WebSocket.OPEN)return;
         try{const r=await fetch(API_URL+'/api/dashboard');if(!r.ok)return;const d=await r.json();if(d)render(d);document.getElementById('ws-status').className='status-dot polling';document.getElementById('refresh-info').textContent='Polling - '+new Date().toLocaleTimeString();document.title='UAP Dashboard - Polling';}catch{}
-      }, 2000);
+      }, REFRESH_MS);
 
       // Resize: re-init charts
       let resizeT;