Upload 2 files

websocket_hub.py

@@ -295,13 +295,79 @@ class ConnectionManager:
 
         await self._broadcast_update(space_name, snap_copy)
 
+    def _extract_signal_metadata(self, snapshot: dict) -> dict:
+        """
+        Extract signal and score metadata from snapshot for broadcast enrichment.
+        Computes confidence scores and signal strength metrics.
+        """
+        voting = snapshot.get("voting", {})
+        training = snapshot.get("training", {})
+        
+        flip_direction = voting.get("flip_direction", "NONE")
+        flip_action = voting.get("flip_action", "HOLD")
+        last_price = voting.get("last_price", 0.0)
+        signal_source = voting.get("signal_source", "LOG")
+        
+        # Vote-based confidence (if available from legacy fields)
+        buy_count = voting.get("buy_count", 0)
+        sell_count = voting.get("sell_count", 0)
+        total_votes = buy_count + sell_count
+        vote_confidence = 0.0
+        if total_votes > 0:
+            max_votes = max(buy_count, sell_count)
+            vote_confidence = float(max_votes) / total_votes
+        
+        # Training-based confidence (accuracy metric)
+        train_confidence = training.get("avn_accuracy", 0.0)
+        
+        # Blended confidence score [0, 1]
+        if vote_confidence > 0 and train_confidence > 0:
+            blended_confidence = (vote_confidence + train_confidence) / 2.0
+        elif vote_confidence > 0:
+            blended_confidence = vote_confidence
+        else:
+            blended_confidence = train_confidence
+        
+        # Signal strength based on action type and confidence
+        signal_strength = 0.0
+        if flip_direction in ("BUY", "SELL"):
+            signal_strength = blended_confidence
+        
+        return {
+            "signal": {
+                "direction": flip_direction,
+                "action": flip_action,
+                "source": signal_source,
+            },
+            "scores": {
+                "vote_confidence": round(vote_confidence, 4),
+                "train_confidence": round(train_confidence, 4),
+                "blended_confidence": round(blended_confidence, 4),
+                "signal_strength": round(signal_strength, 4),
+            },
+            "voting_stats": {
+                "buy_count": buy_count,
+                "sell_count": sell_count,
+                "total_votes": total_votes,
+            },
+            "price": last_price,
+        }
+
     async def _broadcast_update(self, space_name: str, snapshot: dict) -> None:
         if not self._subscribers:
             return
+        
+        # Extract signal metadata for this asset
+        signal_metadata = self._extract_signal_metadata(snapshot)
+        
+        # Enhanced message format with per-asset signals and scores
         message = json.dumps({
             "type":          "metrics_update",
-            "space_name":    space_name,
-            "snapshot":      snapshot,
+            "asset": {
+                "space_name":    space_name,
+                "metadata":      signal_metadata,
+                "snapshot":      snapshot,
+            },
             "hub_timestamp": time.time(),
         })
         dead: list = []
@@ -318,9 +384,19 @@ class ConnectionManager:
     async def send_initial_state(self, ws: WebSocket) -> None:
         async with self._lock:
             snapshots_copy = dict(self._snapshots)
+        
+        # Enrich each snapshot with signal metadata
+        enriched_assets = {}
+        for space_name, snapshot in snapshots_copy.items():
+            signal_metadata = self._extract_signal_metadata(snapshot)
+            enriched_assets[space_name] = {
+                "metadata": signal_metadata,
+                "snapshot": snapshot,
+            }
+        
         message = json.dumps({
             "type":          "initial_state",
-            "snapshots":     snapshots_copy,
+            "assets":        enriched_assets,
             "hub_timestamp": time.time(),
         })
         await ws.send_text(message)