Update websocket_hub.py

websocket_hub.py

@@ -33,6 +33,7 @@ import json
 import logging
 import os
 import time
+from collections import deque
 from datetime import datetime
 from pathlib import Path
 from typing import Dict, List, Optional, Set
@@ -146,17 +147,21 @@ def _validate_and_normalize(space_name: str, raw: dict) -> Optional[dict]:
     }
 
 
+_METRIC_HISTORY_LEN: int = int(os.environ.get("QUASAR_METRIC_HISTORY", "200"))
+
+
 # ══════════════════════════════════════════════════════════════════════════════════════
 # SECTION 2 — CONNECTION MANAGER
 # ══════════════════════════════════════════════════════════════════════════════════════
 
 class ConnectionManager:
     def __init__(self):
-        self._publishers:     Dict[str, WebSocket] = {}
-        self._subscribers:    Set[WebSocket]        = set()
-        self._snapshots:      Dict[str, dict]       = {}
+        self._publishers:     Dict[str, WebSocket]       = {}
+        self._subscribers:    Set[WebSocket]              = set()
+        self._snapshots:      Dict[str, dict]             = {}
+        self._history:        Dict[str, deque]            = {}   # rolling per-space history
         self._lock            = asyncio.Lock()
-        self._total_ingested: int                   = 0
+        self._total_ingested: int                         = 0
 
     async def register_publisher(self, space_name: str, ws: WebSocket) -> None:
         await ws.accept()
@@ -198,6 +203,26 @@ class ConnectionManager:
             self._total_ingested += 1
             snap_copy = copy.deepcopy(snap)
 
+            # ── Rolling metric history (for sparkline charts in dashboard) ────────
+            # Only record a point when training fields arrive AND at least one
+            # loss/accuracy field is non-zero (avoids flooding history with empty
+            # default-value points before training metrics connect).
+            training = snap["training"]
+            if normalized["training"] and any(
+                training.get(k, 0) != 0
+                for k in ("actor_loss", "critic_loss", "avn_loss", "avn_accuracy")
+            ):
+                if space_name not in self._history:
+                    self._history[space_name] = deque(maxlen=_METRIC_HISTORY_LEN)
+                self._history[space_name].append({
+                    "ts":           snap["last_updated"],
+                    "actor_loss":   training.get("actor_loss",   0.0),
+                    "critic_loss":  training.get("critic_loss",  0.0),
+                    "avn_loss":     training.get("avn_loss",     0.0),
+                    "avn_accuracy": training.get("avn_accuracy", 0.0),
+                    "training_steps": training.get("training_steps", 0),
+                })
+
         await self._broadcast_update(space_name, snap_copy)
 
     async def _broadcast_update(self, space_name: str, snapshot: dict) -> None:
@@ -236,6 +261,10 @@ class ConnectionManager:
     def get_all_snapshots(self) -> dict:
         return dict(self._snapshots)
 
+    def get_metric_history(self) -> dict:
+        """Return a plain dict of {space_name: [point, …]} for all spaces with history."""
+        return {name: list(dq) for name, dq in self._history.items()}
+
     def get_health(self) -> dict:
         now = time.time()
         return {
@@ -634,11 +663,10 @@ async def serve_dashboard():
 @app.get("/api/state")
 async def api_state():
     """Full dashboard state polled by hub_dashboard.html every 2 s."""
-    h        = manager.get_health()
     rankings = _compute_rankings()
     return JSONResponse({
         "rankings":       rankings,
-        "metric_history": {},
+        "metric_history": manager.get_metric_history(),
         "health": {
             "hub_connected":    True,
             "spaces_connected": len(manager.get_all_snapshots()),
@@ -670,4 +698,4 @@ _START_TIME = time.time()
 if __name__ == "__main__":
     port = int(os.environ.get("PORT", 7860))
     logger.info(f"🚀 QUASAR Hub starting on port {port}")
-    uvicorn.run(app, host="0.0.0.0", port=port, log_level="info")
+    uvicorn.run(app, host="0.0.0.0", port=port, log_level="info")