empathy-framework 5.1.1__py3-none-any.whl → 5.3.0__py3-none-any.whl

empathy_os/telemetry/agent_tracking.py

@@ -53,6 +53,7 @@ class AgentHeartbeat:
     current_task: str
     last_beat: datetime
     metadata: dict[str, Any] = field(default_factory=dict)
+    display_name: str | None = None  # Optional human-readable name for dashboard
 
     def to_dict(self) -> dict[str, Any]:
         """Convert to dictionary for serialization."""
@@ -63,6 +64,7 @@ class AgentHeartbeat:
             "current_task": self.current_task,
             "last_beat": self.last_beat.isoformat() if isinstance(self.last_beat, datetime) else self.last_beat,
             "metadata": self.metadata,
+            "display_name": self.display_name,
         }
 
     @classmethod
@@ -82,6 +84,7 @@ class AgentHeartbeat:
             current_task=data["current_task"],
             last_beat=last_beat,
             metadata=data.get("metadata", {}),
+            display_name=data.get("display_name"),
         )
 
 
@@ -110,6 +113,7 @@ class HeartbeatCoordinator:
         """
         self.memory = memory
         self.agent_id: str | None = None
+        self.display_name: str | None = None
         self._enable_streaming = enable_streaming
         self._event_streamer = None
 
@@ -142,20 +146,28 @@ class HeartbeatCoordinator:
 
         return self._event_streamer
 
-    def start_heartbeat(self, agent_id: str, metadata: dict[str, Any] | None = None) -> None:
+    def start_heartbeat(
+        self, agent_id: str, metadata: dict[str, Any] | None = None, display_name: str | None = None
+    ) -> None:
         """Start heartbeat for an agent.
 
         Args:
             agent_id: Unique agent identifier
             metadata: Initial metadata (workflow, run_id, etc.)
+            display_name: Optional human-readable name for dashboard display
         """
         if not self.memory:
             logger.debug("Heartbeat tracking disabled (no memory backend)")
             return
 
         self.agent_id = agent_id
+        self.display_name = display_name
         self._publish_heartbeat(
-            status="starting", progress=0.0, current_task="initializing", metadata=metadata or {}
+            status="starting",
+            progress=0.0,
+            current_task="initializing",
+            metadata=metadata or {},
+            display_name=display_name,
         )
 
     def beat(self, status: str = "running", progress: float = 0.0, current_task: str = "") -> None:
@@ -169,7 +181,13 @@ class HeartbeatCoordinator:
         if not self.agent_id or not self.memory:
             return
 
-        self._publish_heartbeat(status=status, progress=progress, current_task=current_task, metadata={})
+        self._publish_heartbeat(
+            status=status,
+            progress=progress,
+            current_task=current_task,
+            metadata={},
+            display_name=self.display_name,
+        )
 
     def stop_heartbeat(self, final_status: str = "completed") -> None:
         """Stop heartbeat (agent finished).
@@ -192,7 +210,7 @@ class HeartbeatCoordinator:
         self.agent_id = None
 
     def _publish_heartbeat(
-        self, status: str, progress: float, current_task: str, metadata: dict[str, Any]
+        self, status: str, progress: float, current_task: str, metadata: dict[str, Any], display_name: str | None = None
     ) -> None:
         """Publish heartbeat to Redis with TTL and optionally to event stream."""
         if not self.memory or not self.agent_id:
@@ -205,10 +223,11 @@ class HeartbeatCoordinator:
             current_task=current_task,
             last_beat=datetime.utcnow(),
             metadata=metadata,
+            display_name=display_name,
         )
 
         # Store in Redis with TTL (Pattern 1)
-        key = f"heartbeat:{self.agent_id}"
+        key = f"empathy:heartbeat:{self.agent_id}"
         try:
             # Use direct Redis access for heartbeats (need custom 30s TTL)
             if hasattr(self.memory, "_client") and self.memory._client:
@@ -243,9 +262,9 @@ class HeartbeatCoordinator:
             return []
 
         try:
-            # Scan for heartbeat:* keys
+            # Scan for empathy:heartbeat:* keys
             if hasattr(self.memory, "_client") and self.memory._client:
-                keys = self.memory._client.keys("heartbeat:*")
+                keys = self.memory._client.keys("empathy:heartbeat:*")
             else:
                 logger.warning("Cannot scan for heartbeats: no Redis access")
                 return []

empathy_os/telemetry/approval_gates.py

@@ -458,19 +458,16 @@ class ApprovalGate:
                 if isinstance(key, bytes):
                     key = key.decode("utf-8")
 
-                # Retrieve request
-                if hasattr(self.memory, "retrieve"):
-                    data = self.memory.retrieve(key, credentials=None)
-                else:
-                    import json
+                # Retrieve request - use direct Redis access (approval keys are stored without prefix)
+                import json
 
-                    raw_data = self.memory._client.get(key)
-                    if raw_data:
-                        if isinstance(raw_data, bytes):
-                            raw_data = raw_data.decode("utf-8")
-                        data = json.loads(raw_data)
-                    else:
-                        data = None
+                raw_data = self.memory._client.get(key)
+                if raw_data:
+                    if isinstance(raw_data, bytes):
+                        raw_data = raw_data.decode("utf-8")
+                    data = json.loads(raw_data)
+                else:
+                    data = None
 
                 if not data:
                     continue
@@ -513,19 +510,16 @@ class ApprovalGate:
                 if isinstance(key, bytes):
                     key = key.decode("utf-8")
 
-                # Retrieve request
-                if hasattr(self.memory, "retrieve"):
-                    data = self.memory.retrieve(key, credentials=None)
-                else:
-                    import json
+                # Retrieve request - use direct Redis access (approval keys are stored without prefix)
+                import json
 
-                    raw_data = self.memory._client.get(key)
-                    if raw_data:
-                        if isinstance(raw_data, bytes):
-                            raw_data = raw_data.decode("utf-8")
-                        data = json.loads(raw_data)
-                    else:
-                        data = None
+                raw_data = self.memory._client.get(key)
+                if raw_data:
+                    if isinstance(raw_data, bytes):
+                        raw_data = raw_data.decode("utf-8")
+                    data = json.loads(raw_data)
+                else:
+                    data = None
 
                 if not data:
                     continue