empathy-framework 5.0.0__py3-none-any.whl → 5.0.3__py3-none-any.whl

empathy_os/telemetry/approval_gates.py

@@ -236,19 +236,13 @@ class ApprovalGate:
         # Store approval request (for UI to retrieve)
         request_key = f"approval_request:{request_id}"
         try:
-            if hasattr(self.memory, "stash"):
-                self.memory.stash(
-                    key=request_key,
-                    data=request.to_dict(),
-                    credentials=None,
-                    ttl_seconds=int(timeout) + 60,  # TTL = timeout + buffer
-                )
-            elif hasattr(self.memory, "_redis"):
+            # Use direct Redis access for custom TTL
+            if hasattr(self.memory, "_client") and self.memory._client:
                 import json
 
-                self.memory._redis.setex(request_key, int(timeout) + 60, json.dumps(request.to_dict()))
+                self.memory._client.setex(request_key, int(timeout) + 60, json.dumps(request.to_dict()))
             else:
-                logger.warning("Cannot store approval request: unsupported memory type")
+                logger.warning("Cannot store approval request: no Redis backend available")
         except Exception as e:
             logger.error(f"Failed to store approval request: {e}")
             return ApprovalResponse(
@@ -294,12 +288,11 @@ class ApprovalGate:
         # Update request status to timeout
         request.status = "timeout"
         try:
-            if hasattr(self.memory, "stash"):
-                self.memory.stash(key=request_key, data=request.to_dict(), credentials=None, ttl_seconds=60)
-            elif hasattr(self.memory, "_redis"):
+            # Use direct Redis access
+            if hasattr(self.memory, "_client") and self.memory._client:
                 import json
 
-                self.memory._redis.setex(request_key, 60, json.dumps(request.to_dict()))
+                self.memory._client.setex(request_key, 60, json.dumps(request.to_dict()))
         except Exception:
             pass
 
@@ -322,10 +315,10 @@ class ApprovalGate:
             if hasattr(self.memory, "retrieve"):
                 data = self.memory.retrieve(response_key, credentials=None)
             # Try direct Redis access
-            elif hasattr(self.memory, "_redis"):
+            elif hasattr(self.memory, "_client"):
                 import json
 
-                raw_data = self.memory._redis.get(response_key)
+                raw_data = self.memory._client.get(response_key)
                 if raw_data:
                     if isinstance(raw_data, bytes):
                         raw_data = raw_data.decode("utf-8")
@@ -376,16 +369,13 @@ class ApprovalGate:
         # Store approval response (for workflow to retrieve)
         response_key = f"approval_response:{request_id}"
         try:
-            if hasattr(self.memory, "stash"):
-                self.memory.stash(
-                    key=response_key, data=response.to_dict(), credentials=None, ttl_seconds=300  # 5 min TTL
-                )
-            elif hasattr(self.memory, "_redis"):
+            # Use direct Redis access
+            if hasattr(self.memory, "_client") and self.memory._client:
                 import json
 
-                self.memory._redis.setex(response_key, 300, json.dumps(response.to_dict()))
+                self.memory._client.setex(response_key, 300, json.dumps(response.to_dict()))
             else:
-                logger.warning("Cannot store approval response: unsupported memory type")
+                logger.warning("Cannot store approval response: no Redis backend available")
                 return False
         except Exception as e:
             logger.error(f"Failed to store approval response: {e}")
@@ -396,10 +386,10 @@ class ApprovalGate:
         try:
             if hasattr(self.memory, "retrieve"):
                 request_data = self.memory.retrieve(request_key, credentials=None)
-            elif hasattr(self.memory, "_redis"):
+            elif hasattr(self.memory, "_client"):
                 import json
 
-                raw_data = self.memory._redis.get(request_key)
+                raw_data = self.memory._client.get(request_key)
                 if raw_data:
                     if isinstance(raw_data, bytes):
                         raw_data = raw_data.decode("utf-8")
@@ -413,12 +403,11 @@ class ApprovalGate:
                 request = ApprovalRequest.from_dict(request_data)
                 request.status = "approved" if approved else "rejected"
 
-                if hasattr(self.memory, "stash"):
-                    self.memory.stash(key=request_key, data=request.to_dict(), credentials=None, ttl_seconds=300)
-                elif hasattr(self.memory, "_redis"):
+                # Use direct Redis access
+                if hasattr(self.memory, "_client") and self.memory._client:
                     import json
 
-                    self.memory._redis.setex(request_key, 300, json.dumps(request.to_dict()))
+                    self.memory._client.setex(request_key, 300, json.dumps(request.to_dict()))
         except Exception as e:
             logger.debug(f"Failed to update request status: {e}")
 
@@ -457,12 +446,12 @@ class ApprovalGate:
             >>> for request in pending:
             ...     print(f"{request.approval_type}: {request.context}")
         """
-        if not self.memory or not hasattr(self.memory, "_redis"):
+        if not self.memory or not hasattr(self.memory, "_client"):
             return []
 
         try:
             # Scan for approval_request:* keys
-            keys = self.memory._redis.keys("approval_request:*")
+            keys = self.memory._client.keys("approval_request:*")
 
             requests = []
             for key in keys:
@@ -475,7 +464,7 @@ class ApprovalGate:
                 else:
                     import json
 
-                    raw_data = self.memory._redis.get(key)
+                    raw_data = self.memory._client.get(key)
                     if raw_data:
                         if isinstance(raw_data, bytes):
                             raw_data = raw_data.decode("utf-8")
@@ -512,11 +501,11 @@ class ApprovalGate:
         Returns:
             Number of requests cleared
         """
-        if not self.memory or not hasattr(self.memory, "_redis"):
+        if not self.memory or not hasattr(self.memory, "_client"):
             return 0
 
         try:
-            keys = self.memory._redis.keys("approval_request:*")
+            keys = self.memory._client.keys("approval_request:*")
             now = datetime.utcnow()
             cleared = 0
 
@@ -530,7 +519,7 @@ class ApprovalGate:
                 else:
                     import json
 
-                    raw_data = self.memory._redis.get(key)
+                    raw_data = self.memory._client.get(key)
                     if raw_data:
                         if isinstance(raw_data, bytes):
                             raw_data = raw_data.decode("utf-8")
@@ -548,12 +537,11 @@ class ApprovalGate:
                 if elapsed > request.timeout_seconds and request.status == "pending":
                     # Update to timeout status
                     request.status = "timeout"
-                    if hasattr(self.memory, "stash"):
-                        self.memory.stash(key=key, data=request.to_dict(), credentials=None, ttl_seconds=60)
-                    elif hasattr(self.memory, "_redis"):
+                    # Use direct Redis access
+                    if hasattr(self.memory, "_client") and self.memory._client:
                         import json
 
-                        self.memory._redis.setex(key, 60, json.dumps(request.to_dict()))
+                        self.memory._client.setex(key, 60, json.dumps(request.to_dict()))
 
                     cleared += 1
 

empathy_os/telemetry/event_streaming.py

@@ -103,14 +103,14 @@ class EventStreamer:
     Publishes events to Redis Streams and provides methods for consuming
     events via polling or blocking reads.
 
-    Stream naming: empathy:events:{event_type}
+    Stream naming: stream:{event_type}
     Examples:
-    - empathy:events:agent_heartbeat
-    - empathy:events:coordination_signal
-    - empathy:events:workflow_progress
+    - stream:agent_heartbeat
+    - stream:coordination_signal
+    - stream:workflow_progress
     """
 
-    STREAM_PREFIX = "empathy:events:"
+    STREAM_PREFIX = "stream:"
     MAX_STREAM_LENGTH = 10000  # Trim streams to last 10K events
     DEFAULT_BLOCK_MS = 5000  # 5 seconds blocking read timeout
 
@@ -142,7 +142,7 @@ class EventStreamer:
             event_type: Type of event
 
         Returns:
-            Stream key (e.g., "empathy:events:agent_heartbeat")
+            Stream key (e.g., "stream:agent_heartbeat")
         """
         return f"{self.STREAM_PREFIX}{event_type}"
 
@@ -162,7 +162,7 @@ class EventStreamer:
         Returns:
             Event ID (Redis stream entry ID) if successful, empty string otherwise
         """
-        if not self.memory or not hasattr(self.memory, "_redis"):
+        if not self.memory or not hasattr(self.memory, "_client") or not self.memory._client:
             logger.debug("Cannot publish event: no Redis backend")
             return ""
 
@@ -178,7 +178,7 @@ class EventStreamer:
 
         try:
             # Add to stream with automatic trimming (MAXLEN)
-            event_id = self.memory._redis.xadd(
+            event_id = self.memory._client.xadd(
                 stream_key,
                 entry,
                 maxlen=self.MAX_STREAM_LENGTH,
@@ -219,7 +219,7 @@ class EventStreamer:
             >>> for event in streamer.consume_events(event_types=["agent_heartbeat"]):
             ...     print(f"Agent {event.data['agent_id']} status: {event.data['status']}")
         """
-        if not self.memory or not hasattr(self.memory, "_redis"):
+        if not self.memory or not hasattr(self.memory, "_client") or not self.memory._client:
             logger.warning("Cannot consume events: no Redis backend")
             return
 
@@ -230,7 +230,7 @@ class EventStreamer:
             streams = {self._get_stream_key(et): start_id for et in event_types}
         else:
             # Subscribe to all event streams (expensive - requires KEYS scan)
-            all_streams = self.memory._redis.keys(f"{self.STREAM_PREFIX}*")
+            all_streams = self.memory._client.keys(f"{self.STREAM_PREFIX}*")
             streams = {s.decode("utf-8") if isinstance(s, bytes) else s: start_id for s in all_streams}
 
         if not streams:
@@ -243,7 +243,7 @@ class EventStreamer:
         try:
             while True:
                 # XREAD: blocking read from multiple streams
-                results = self.memory._redis.xread(
+                results = self.memory._client.xread(
                     last_ids,
                     count=count,
                     block=block_ms,
@@ -294,7 +294,7 @@ class EventStreamer:
         Returns:
             List of recent events (newest first)
         """
-        if not self.memory or not hasattr(self.memory, "_redis"):
+        if not self.memory or not hasattr(self.memory, "_client") or not self.memory._client:
             logger.debug("Cannot get recent events: no Redis backend")
             return []
 
@@ -302,7 +302,7 @@ class EventStreamer:
 
         try:
             # XREVRANGE: get events in reverse chronological order
-            results = self.memory._redis.xrevrange(
+            results = self.memory._client.xrevrange(
                 stream_key,
                 max=end_id,
                 min=start_id,
@@ -333,13 +333,13 @@ class EventStreamer:
         Returns:
             Dictionary with stream info (length, first_entry, last_entry, etc.)
         """
-        if not self.memory or not hasattr(self.memory, "_redis"):
+        if not self.memory or not hasattr(self.memory, "_client") or not self.memory._client:
             return {}
 
         stream_key = self._get_stream_key(event_type)
 
         try:
-            info = self.memory._redis.xinfo_stream(stream_key)
+            info = self.memory._client.xinfo_stream(stream_key)
 
             # Decode bytes keys/values
             decoded_info = {}
@@ -365,13 +365,13 @@ class EventStreamer:
         Returns:
             True if deleted, False otherwise
         """
-        if not self.memory or not hasattr(self.memory, "_redis"):
+        if not self.memory or not hasattr(self.memory, "_client") or not self.memory._client:
             return False
 
         stream_key = self._get_stream_key(event_type)
 
         try:
-            result = self.memory._redis.delete(stream_key)
+            result = self.memory._client.delete(stream_key)
             return result > 0
         except Exception as e:
             logger.error(f"Failed to delete stream {event_type}: {e}")
@@ -387,14 +387,14 @@ class EventStreamer:
         Returns:
             Number of events trimmed
         """
-        if not self.memory or not hasattr(self.memory, "_redis"):
+        if not self.memory or not hasattr(self.memory, "_client") or not self.memory._client:
             return 0
 
         stream_key = self._get_stream_key(event_type)
 
         try:
             # XTRIM: trim to approximate max length
-            trimmed = self.memory._redis.xtrim(
+            trimmed = self.memory._client.xtrim(
                 stream_key,
                 maxlen=max_length,
                 approximate=True,

empathy_os/telemetry/feedback_loop.py

@@ -229,16 +229,13 @@ class FeedbackLoop:
         key = f"feedback:{workflow_name}:{stage_name}:{tier}:{feedback_id}"
 
         try:
-            if hasattr(self.memory, "stash"):
-                self.memory.stash(
-                    key=key, data=entry.to_dict(), credentials=None, ttl_seconds=self.FEEDBACK_TTL
-                )
-            elif hasattr(self.memory, "_redis"):
+            # Use direct Redis access for custom TTL
+            if hasattr(self.memory, "_client") and self.memory._client:
                 import json
 
-                self.memory._redis.setex(key, self.FEEDBACK_TTL, json.dumps(entry.to_dict()))
+                self.memory._client.setex(key, self.FEEDBACK_TTL, json.dumps(entry.to_dict()))
             else:
-                logger.warning("Cannot store feedback: unsupported memory type")
+                logger.warning("Cannot store feedback: no Redis backend available")
                 return ""
         except Exception as e:
             logger.error(f"Failed to store feedback: {e}")
@@ -263,7 +260,7 @@ class FeedbackLoop:
         Returns:
             List of feedback entries (newest first)
         """
-        if not self.memory or not hasattr(self.memory, "_redis"):
+        if not self.memory or not hasattr(self.memory, "_client"):
             return []
 
         # Convert tier to string if ModelTier enum
@@ -277,7 +274,7 @@ class FeedbackLoop:
             else:
                 pattern = f"feedback:{workflow_name}:{stage_name}:*"
 
-            keys = self.memory._redis.keys(pattern)
+            keys = self.memory._client.keys(pattern)
 
             entries = []
             for key in keys:
@@ -308,10 +305,10 @@ class FeedbackLoop:
         try:
             if hasattr(self.memory, "retrieve"):
                 return self.memory.retrieve(key, credentials=None)
-            elif hasattr(self.memory, "_redis"):
+            elif hasattr(self.memory, "_client"):
                 import json
 
-                data = self.memory._redis.get(key)
+                data = self.memory._client.get(key)
                 if data:
                     if isinstance(data, bytes):
                         data = data.decode("utf-8")
@@ -494,13 +491,13 @@ class FeedbackLoop:
         Returns:
             List of (stage_name, stats) tuples for underperforming stages
         """
-        if not self.memory or not hasattr(self.memory, "_redis"):
+        if not self.memory or not hasattr(self.memory, "_client"):
             return []
 
         try:
             # Find all feedback keys for this workflow
             pattern = f"feedback:{workflow_name}:*"
-            keys = self.memory._redis.keys(pattern)
+            keys = self.memory._client.keys(pattern)
 
             # Extract unique stages
             stages = set()
@@ -537,7 +534,7 @@ class FeedbackLoop:
         Returns:
             Number of feedback entries cleared
         """
-        if not self.memory or not hasattr(self.memory, "_redis"):
+        if not self.memory or not hasattr(self.memory, "_client"):
             return 0
 
         try:
@@ -546,11 +543,11 @@ class FeedbackLoop:
             else:
                 pattern = f"feedback:{workflow_name}:*"
 
-            keys = self.memory._redis.keys(pattern)
+            keys = self.memory._client.keys(pattern)
             if not keys:
                 return 0
 
-            deleted = self.memory._redis.delete(*keys)
+            deleted = self.memory._client.delete(*keys)
             return deleted
         except Exception as e:
             logger.error(f"Failed to clear feedback: {e}")

empathy_os/workflows/batch_processing.py

@@ -109,19 +109,22 @@ class BatchProcessingWorkflow:
         if not requests:
             raise ValueError("requests cannot be empty")
 
-        # Convert to Anthropic batch format
+        # Convert to Anthropic Message Batches format
         api_requests = []
         for req in requests:
             model = get_model("anthropic", req.model_tier)
             if model is None:
                 raise ValueError(f"Unknown model tier: {req.model_tier}")
 
+            # Use correct format with params wrapper
             api_requests.append(
                 {
                     "custom_id": req.task_id,
-                    "model": model.id,
-                    "messages": self._format_messages(req),
-                    "max_tokens": 4096,
+                    "params": {
+                        "model": model.id,
+                        "messages": self._format_messages(req),
+                        "max_tokens": 4096,
+                    },
                 }
             )
 
@@ -153,17 +156,58 @@ class BatchProcessingWorkflow:
                 for req in requests
             ]
 
-        # Parse results
+        # Parse results - new Message Batches API format
         results = []
         for raw in raw_results:
             task_id = raw.get("custom_id", "unknown")
+            result = raw.get("result", {})
+            result_type = result.get("type", "unknown")
+
+            if result_type == "succeeded":
+                # Extract message content from succeeded result
+                message = result.get("message", {})
+                content_blocks = message.get("content", [])
+
+                # Convert content blocks to simple output format
+                output_text = ""
+                for block in content_blocks:
+                    if isinstance(block, dict) and block.get("type") == "text":
+                        output_text += block.get("text", "")
+
+                output = {
+                    "content": output_text,
+                    "usage": message.get("usage", {}),
+                    "model": message.get("model"),
+                    "stop_reason": message.get("stop_reason"),
+                }
+                results.append(BatchResult(task_id=task_id, success=True, output=output))
+
+            elif result_type == "errored":
+                # Extract error from errored result
+                error = result.get("error", {})
+                error_msg = error.get("message", "Unknown error")
+                error_type = error.get("type", "unknown_error")
+                results.append(
+                    BatchResult(task_id=task_id, success=False, error=f"{error_type}: {error_msg}")
+                )
+
+            elif result_type == "expired":
+                results.append(
+                    BatchResult(task_id=task_id, success=False, error="Request expired")
+                )
+
+            elif result_type == "canceled":
+                results.append(
+                    BatchResult(task_id=task_id, success=False, error="Request canceled")
+                )
 
-            if "error" in raw:
-                error_msg = raw["error"].get("message", "Unknown error")
-                results.append(BatchResult(task_id=task_id, success=False, error=error_msg))
             else:
                 results.append(
-                    BatchResult(task_id=task_id, success=True, output=raw.get("response"))
+                    BatchResult(
+                        task_id=task_id,
+                        success=False,
+                        error=f"Unknown result type: {result_type}",
+                    )
                 )
 
         # Log summary
@@ -201,7 +245,9 @@ class BatchProcessingWorkflow:
             logger.warning(
                 f"Missing required field {e} for task {request.task_type}, using raw input"
             )
-            content = prompt_template.format(input=json.dumps(request.input_data))
+            # Use default template instead of the specific one
+            default_template = "Process the following:\n\n{input}"
+            content = default_template.format(input=json.dumps(request.input_data))
 
         return [{"role": "user", "content": content}]
 

empathy_os/vscode_bridge 2.py

@@ -1,173 +0,0 @@
-"""VS Code Extension Bridge
-
-Provides functions to write data that the VS Code extension can pick up.
-Enables Claude Code CLI output to appear in VS Code webview panels.
-
-Copyright 2026 Smart-AI-Memory
-Licensed under Fair Source License 0.9
-"""
-
-import json
-from dataclasses import asdict, dataclass
-from datetime import datetime
-from pathlib import Path
-from typing import Any
-
-
-@dataclass
-class ReviewFinding:
-    """A code review finding."""
-
-    id: str
-    file: str
-    line: int
-    severity: str  # 'critical' | 'high' | 'medium' | 'low' | 'info'
-    category: str  # 'security' | 'performance' | 'maintainability' | 'style' | 'correctness'
-    message: str
-    column: int = 1
-    details: str | None = None
-    recommendation: str | None = None
-
-
-@dataclass
-class CodeReviewResult:
-    """Code review results for VS Code bridge."""
-
-    findings: list[dict[str, Any]]
-    summary: dict[str, Any]
-    verdict: str  # 'approve' | 'approve_with_suggestions' | 'request_changes' | 'reject'
-    security_score: int
-    formatted_report: str
-    model_tier_used: str
-    timestamp: str
-
-
-def get_empathy_dir() -> Path:
-    """Get the .empathy directory, creating if needed."""
-    empathy_dir = Path(".empathy")
-    empathy_dir.mkdir(exist_ok=True)
-    return empathy_dir
-
-
-def write_code_review_results(
-    findings: list[dict[str, Any]] | None = None,
-    summary: dict[str, Any] | None = None,
-    verdict: str = "approve_with_suggestions",
-    security_score: int = 85,
-    formatted_report: str = "",
-    model_tier_used: str = "capable",
-) -> Path:
-    """Write code review results for VS Code extension to pick up.
-
-    Args:
-        findings: List of finding dicts with keys: id, file, line, severity, category, message
-        summary: Summary dict with keys: total_findings, by_severity, by_category, files_affected
-        verdict: One of 'approve', 'approve_with_suggestions', 'request_changes', 'reject'
-        security_score: 0-100 score
-        formatted_report: Markdown formatted report
-        model_tier_used: 'cheap', 'capable', or 'premium'
-
-    Returns:
-        Path to the written file
-    """
-    findings = findings or []
-
-    # Build summary if not provided
-    if summary is None:
-        by_severity: dict[str, int] = {}
-        by_category: dict[str, int] = {}
-        files_affected: set[str] = set()
-
-        for f in findings:
-            sev = f.get("severity", "info")
-            cat = f.get("category", "correctness")
-            by_severity[sev] = by_severity.get(sev, 0) + 1
-            by_category[cat] = by_category.get(cat, 0) + 1
-            if f.get("file"):
-                files_affected.add(f["file"])
-
-        summary = {
-            "total_findings": len(findings),
-            "by_severity": by_severity,
-            "by_category": by_category,
-            "files_affected": list(files_affected),
-        }
-
-    result = CodeReviewResult(
-        findings=findings,
-        summary=summary,
-        verdict=verdict,
-        security_score=security_score,
-        formatted_report=formatted_report,
-        model_tier_used=model_tier_used,
-        timestamp=datetime.now().isoformat(),
-    )
-
-    output_path = get_empathy_dir() / "code-review-results.json"
-
-    with open(output_path, "w") as f:
-        json.dump(asdict(result), f, indent=2)
-
-    return output_path
-
-
-def write_pr_review_results(
-    pr_number: int | str,
-    title: str,
-    findings: list[dict[str, Any]],
-    verdict: str = "approve_with_suggestions",
-    summary_text: str = "",
-) -> Path:
-    """Write PR review results for VS Code extension.
-
-    Convenience wrapper for PR reviews from GitHub.
-
-    Args:
-        pr_number: The PR number
-        title: PR title
-        findings: List of review findings
-        verdict: Review verdict
-        summary_text: Summary of the review
-
-    Returns:
-        Path to the written file
-    """
-    formatted_report = f"""## PR #{pr_number}: {title}
-
-{summary_text}
-
-### Findings ({len(findings)})
-
-"""
-    for f in findings:
-        formatted_report += f"- **{f.get('severity', 'info').upper()}** [{f.get('file', 'unknown')}:{f.get('line', 0)}]: {f.get('message', '')}\n"
-
-    return write_code_review_results(
-        findings=findings,
-        verdict=verdict,
-        formatted_report=formatted_report,
-        model_tier_used="capable",
-    )
-
-
-# Quick helper for Claude Code to call
-def send_to_vscode(
-    message: str,
-    findings: list[dict[str, Any]] | None = None,
-    verdict: str = "approve_with_suggestions",
-) -> str:
-    """Quick helper to send review results to VS Code.
-
-    Usage in Claude Code:
-        from empathy_os.vscode_bridge import send_to_vscode
-        send_to_vscode("Review complete", findings=[...])
-
-    Returns:
-        Confirmation message
-    """
-    path = write_code_review_results(
-        findings=findings or [],
-        formatted_report=message,
-        verdict=verdict,
-    )
-    return f"Results written to {path} - VS Code will update automatically"