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

empathy_os/cli/parsers/batch.py

@@ -0,0 +1,118 @@
+"""Argument parser for batch processing commands.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+
+def register_parsers(subparsers):
+    """Register batch command parsers.
+
+    Args:
+        subparsers: Subparser object from main argument parser
+
+    Returns:
+        None: Adds batch subparser with submit, status, results, wait subcommands
+    """
+    from ..commands.batch import (
+        cmd_batch_results,
+        cmd_batch_status,
+        cmd_batch_submit,
+        cmd_batch_wait,
+    )
+
+    # Main batch command
+    batch_parser = subparsers.add_parser(
+        "batch",
+        help="Batch processing via Anthropic Batch API (50% cost savings)",
+        description="Submit and manage batch processing jobs for non-urgent tasks",
+    )
+
+    # Batch subcommands
+    batch_subparsers = batch_parser.add_subparsers(dest="batch_command", required=True)
+
+    # batch submit command
+    submit_parser = batch_subparsers.add_parser(
+        "submit",
+        help="Submit a batch processing job from JSON file",
+        description="Submit batch requests for asynchronous processing (50% cost savings)",
+    )
+
+    submit_parser.add_argument(
+        "input_file",
+        help='JSON file with batch requests. Format: [{"task_id": "...", "task_type": "...", "input_data": {...}}]',
+    )
+
+    submit_parser.set_defaults(func=cmd_batch_submit)
+
+    # batch status command
+    status_parser = batch_subparsers.add_parser(
+        "status",
+        help="Check status of a batch processing job",
+        description="Display current status and request counts for a batch",
+    )
+
+    status_parser.add_argument(
+        "batch_id",
+        help="Batch ID (e.g., msgbatch_abc123)",
+    )
+
+    status_parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Output raw JSON status",
+    )
+
+    status_parser.set_defaults(func=cmd_batch_status)
+
+    # batch results command
+    results_parser = batch_subparsers.add_parser(
+        "results",
+        help="Retrieve results from completed batch",
+        description="Download and save batch results to JSON file",
+    )
+
+    results_parser.add_argument(
+        "batch_id",
+        help="Batch ID (e.g., msgbatch_abc123)",
+    )
+
+    results_parser.add_argument(
+        "output_file",
+        help="Path to output JSON file",
+    )
+
+    results_parser.set_defaults(func=cmd_batch_results)
+
+    # batch wait command
+    wait_parser = batch_subparsers.add_parser(
+        "wait",
+        help="Wait for batch to complete and retrieve results",
+        description="Poll batch status until completion, then download results",
+    )
+
+    wait_parser.add_argument(
+        "batch_id",
+        help="Batch ID (e.g., msgbatch_abc123)",
+    )
+
+    wait_parser.add_argument(
+        "output_file",
+        help="Path to output JSON file",
+    )
+
+    wait_parser.add_argument(
+        "--poll-interval",
+        type=int,
+        default=300,
+        help="Seconds between status checks (default: 300 = 5 minutes)",
+    )
+
+    wait_parser.add_argument(
+        "--timeout",
+        type=int,
+        default=86400,
+        help="Maximum wait time in seconds (default: 86400 = 24 hours)",
+    )
+
+    wait_parser.set_defaults(func=cmd_batch_wait)

empathy_os/cli/parsers/cache.py

@@ -0,0 +1,65 @@
+"""Argument parser for cache commands.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+
+def register_parsers(subparsers):
+    """Register cache command parsers.
+
+    Args:
+        subparsers: Subparser object from main argument parser
+
+    Returns:
+        None: Adds cache subparser with stats and clear subcommands
+    """
+    from ..commands.cache import cmd_cache_clear, cmd_cache_stats
+    # Main cache command
+    cache_parser = subparsers.add_parser(
+        "cache",
+        help="Cache monitoring and management",
+        description="Monitor prompt caching performance and cost savings",
+    )
+
+    # Cache subcommands
+    cache_subparsers = cache_parser.add_subparsers(dest="cache_command", required=True)
+
+    # cache stats command
+    stats_parser = cache_subparsers.add_parser(
+        "stats",
+        help="Show cache performance statistics",
+        description="Display prompt caching metrics including hit rate and cost savings",
+    )
+
+    stats_parser.add_argument(
+        "--days",
+        type=int,
+        default=7,
+        help="Number of days to analyze (default: 7)",
+    )
+
+    stats_parser.add_argument(
+        "--format",
+        choices=["table", "json"],
+        default="table",
+        help="Output format (default: table)",
+    )
+
+    stats_parser.add_argument(
+        "--verbose",
+        "-v",
+        action="store_true",
+        help="Show detailed token metrics",
+    )
+
+    stats_parser.set_defaults(func=cmd_cache_stats)
+
+    # cache clear command (placeholder)
+    clear_parser = cache_subparsers.add_parser(
+        "clear",
+        help="Clear cache (note: Anthropic cache is server-side with 5min TTL)",
+        description="Information about cache clearing",
+    )
+
+    clear_parser.set_defaults(func=cmd_cache_clear)

empathy_os/cli/parsers/routing.py

@@ -0,0 +1,110 @@
+"""Argument parser for adaptive routing commands.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+
+def register_parsers(subparsers):
+    """Register routing command parsers.
+
+    Args:
+        subparsers: Subparser object from main argument parser
+
+    Returns:
+        None: Adds routing subparser with stats, check, models subcommands
+    """
+    from ..commands.routing import (
+        cmd_routing_check,
+        cmd_routing_models,
+        cmd_routing_stats,
+    )
+
+    # Main routing command
+    routing_parser = subparsers.add_parser(
+        "routing",
+        help="Adaptive model routing statistics and recommendations",
+        description="Analyze model routing performance based on historical telemetry",
+    )
+
+    # Routing subcommands
+    routing_subparsers = routing_parser.add_subparsers(
+        dest="routing_command", required=True
+    )
+
+    # routing stats command
+    stats_parser = routing_subparsers.add_parser(
+        "stats",
+        help="Show routing statistics for a workflow",
+        description="Display model performance metrics and recommendations",
+    )
+
+    stats_parser.add_argument("workflow", help="Workflow name (e.g., 'code-review')")
+
+    stats_parser.add_argument(
+        "--stage",
+        help="Stage name (optional, shows all stages if not specified)",
+    )
+
+    stats_parser.add_argument(
+        "--days",
+        type=int,
+        default=7,
+        help="Number of days to analyze (default: 7)",
+    )
+
+    stats_parser.set_defaults(func=cmd_routing_stats)
+
+    # routing check command
+    check_parser = routing_subparsers.add_parser(
+        "check",
+        help="Check for tier upgrade recommendations",
+        description="Analyze failure rates and recommend tier upgrades",
+    )
+
+    check_parser.add_argument(
+        "--workflow",
+        help="Workflow name (required unless --all is used)",
+    )
+
+    check_parser.add_argument(
+        "--stage",
+        help="Stage name (optional)",
+    )
+
+    check_parser.add_argument(
+        "--all",
+        action="store_true",
+        help="Check all workflows",
+    )
+
+    check_parser.add_argument(
+        "--days",
+        type=int,
+        default=7,
+        help="Number of days to analyze (default: 7)",
+    )
+
+    check_parser.set_defaults(func=cmd_routing_check)
+
+    # routing models command
+    models_parser = routing_subparsers.add_parser(
+        "models",
+        help="Compare model performance",
+        description="Show performance metrics for all models from a provider",
+    )
+
+    models_parser.add_argument(
+        "--provider",
+        default="anthropic",
+        help="Provider name (default: anthropic)",
+    )
+
+    models_parser.add_argument(
+        "--days",
+        type=int,
+        default=7,
+        help="Number of days to analyze (default: 7)",
+    )
+
+    models_parser.set_defaults(func=cmd_routing_models)

empathy_os/dashboard/standalone_server.py

@@ -290,17 +290,28 @@ class StandaloneDashboardHandler(BaseHTTPRequestHandler):
                     # Get last N entries from stream
                     entries = r.xrevrange(stream_key, count=limit)
                     for entry_id, fields in entries:
+                        # Parse event structure: top-level fields + data payload
+                        event_type = fields.get(b"event_type", b"unknown").decode("utf-8")
+                        timestamp = fields.get(b"timestamp", b"").decode("utf-8")
+                        source = fields.get(b"source", b"empathy_os").decode("utf-8")
+
+                        # Parse the data payload (JSON-encoded)
+                        data = {}
                         if b"data" in fields:
-                            event = json.loads(fields[b"data"].decode("utf-8"))
-                            result.append(
-                                {
-                                    "event_id": event.get("event_id"),
-                                    "event_type": event.get("event_type"),
-                                    "timestamp": event.get("timestamp"),
-                                    "data": event.get("data", {}),
-                                    "source": event.get("source"),
-                                }
-                            )
+                            try:
+                                data = json.loads(fields[b"data"].decode("utf-8"))
+                            except json.JSONDecodeError:
+                                data = {}
+
+                        result.append(
+                            {
+                                "event_id": entry_id.decode("utf-8") if isinstance(entry_id, bytes) else entry_id,
+                                "event_type": event_type,
+                                "timestamp": timestamp,
+                                "data": data,
+                                "source": source,
+                            }
+                        )
                 except Exception as e:
                     logger.debug(f"Stream {stream_key} not found or empty: {e}")
 
@@ -320,7 +331,7 @@ class StandaloneDashboardHandler(BaseHTTPRequestHandler):
                 return
 
             result = []
-            for key in r.keys(b"approval:pending:*"):
+            for key in r.keys(b"approval_request:*"):
                 try:
                     data = r.get(key)
                     if data:

empathy_os/metrics/collector.py

@@ -0,0 +1,31 @@
+"""Metrics collector stub (deprecated).
+
+This module is a placeholder for legacy code compatibility.
+The functionality has been moved to other modules.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+
+class MetricsCollector:
+    """Deprecated metrics collector class.
+
+    This class is maintained for backward compatibility but is deprecated.
+    """
+
+    def __init__(self, db_path: str | None = None):
+        """Initialize metrics collector.
+
+        Args:
+            db_path: Path to database (deprecated parameter)
+        """
+        self.db_path = db_path
+
+    def collect(self):
+        """Collect metrics (deprecated)."""
+        return {}
+
+    def get_stats(self):
+        """Get statistics (deprecated)."""
+        return {}

empathy_os/models/token_estimator.py

@@ -44,16 +44,17 @@ def _get_encoding(model_id: str) -> Any:
 
 
 def estimate_tokens(text: str, model_id: str = "claude-sonnet-4-5-20250514") -> int:
-    """Estimate token count for text.
+    """Estimate token count for text using accurate token counting.
 
-    Uses tiktoken for accurate counting, falls back to heuristic if unavailable.
+    Uses empathy_llm_toolkit's token counter which leverages tiktoken for fast,
+    accurate local counting (~98% accurate). Falls back to heuristic if unavailable.
 
     Args:
         text: The text to count tokens for
         model_id: The model ID to use for encoding selection
 
     Returns:
-        Estimated token count
+        Accurate token count
 
     Raises:
         ValueError: If model_id is empty
@@ -66,16 +67,23 @@ def estimate_tokens(text: str, model_id: str = "claude-sonnet-4-5-20250514") ->
     if not text:
         return 0
 
-    if TIKTOKEN_AVAILABLE:
-        try:
-            encoding = _get_encoding(model_id)
-            if encoding:
-                return len(encoding.encode(text))
-        except Exception:
-            pass  # Fall through to heuristic
-
-    # Heuristic fallback
-    return max(1, int(len(text) * TOKENS_PER_CHAR_HEURISTIC))
+    # Use new accurate token counting from empathy_llm_toolkit
+    try:
+        from empathy_llm_toolkit.utils.tokens import count_tokens
+
+        return count_tokens(text, model=model_id, use_api=False)
+    except ImportError:
+        # Fallback to tiktoken if toolkit not available
+        if TIKTOKEN_AVAILABLE:
+            try:
+                encoding = _get_encoding(model_id)
+                if encoding:
+                    return len(encoding.encode(text))
+            except Exception:
+                pass  # Fall through to heuristic
+
+        # Last resort: heuristic fallback
+        return max(1, int(len(text) * TOKENS_PER_CHAR_HEURISTIC))
 
 
 def estimate_workflow_cost(

empathy_os/telemetry/agent_coordination.py

@@ -222,15 +222,13 @@ class CoordinationSignals:
         key = f"{self.KEY_PREFIX}{target_key}:{signal_type}:{signal_id}"
 
         try:
-            if hasattr(self.memory, "stash"):
-                # Pass credentials through to memory backend for permission enforcement
-                self.memory.stash(key=key, data=signal.to_dict(), credentials=credentials, ttl_seconds=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, ttl, json.dumps(signal.to_dict()))
+                self.memory._client.setex(key, ttl, json.dumps(signal.to_dict()))
             else:
-                logger.warning(f"Cannot send signal: unsupported memory type {type(self.memory)}")
+                logger.warning(f"Cannot send signal: no Redis backend available")
         except Exception as e:
             logger.error(f"Failed to send signal {signal_id}: {e}")
 
@@ -341,8 +339,8 @@ class CoordinationSignals:
             ]
 
             for pattern in patterns:
-                if hasattr(self.memory, "_redis"):
-                    keys = self.memory._redis.keys(pattern)
+                if hasattr(self.memory, "_client"):
+                    keys = self.memory._client.keys(pattern)
                 else:
                     continue
 
@@ -393,8 +391,8 @@ class CoordinationSignals:
 
             signals = []
             for pattern in patterns:
-                if hasattr(self.memory, "_redis"):
-                    keys = self.memory._redis.keys(pattern)
+                if hasattr(self.memory, "_client"):
+                    keys = self.memory._client.keys(pattern)
                 else:
                     continue
 
@@ -451,10 +449,10 @@ class CoordinationSignals:
         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")
@@ -470,8 +468,8 @@ class CoordinationSignals:
             return False
 
         try:
-            if hasattr(self.memory, "_redis"):
-                return self.memory._redis.delete(key) > 0
+            if hasattr(self.memory, "_client"):
+                return self.memory._client.delete(key) > 0
             return False
         except Exception as e:
             logger.debug(f"Failed to delete signal {key}: {e}")

empathy_os/telemetry/agent_tracking.py

@@ -211,18 +211,14 @@ class HeartbeatCoordinator:
         # Store in Redis with TTL (Pattern 1)
         key = f"heartbeat:{self.agent_id}"
         try:
-            # Use stash if available (UnifiedMemory), otherwise try Redis directly
-            if hasattr(self.memory, "stash"):
-                self.memory.stash(
-                    key=key, data=heartbeat.to_dict(), credentials=None, ttl_seconds=self.HEARTBEAT_TTL
-                )
-            elif hasattr(self.memory, "_redis"):
-                # Direct Redis access for ShortTermMemory
+            # Use direct Redis access for heartbeats (need custom 30s TTL)
+            if hasattr(self.memory, "_client") and self.memory._client:
+                # Direct Redis access with setex for custom TTL
                 import json
 
-                self.memory._redis.setex(key, self.HEARTBEAT_TTL, json.dumps(heartbeat.to_dict()))
+                self.memory._client.setex(key, self.HEARTBEAT_TTL, json.dumps(heartbeat.to_dict()))
             else:
-                logger.warning(f"Cannot publish heartbeat: unsupported memory type {type(self.memory)}")
+                logger.warning(f"Cannot publish heartbeat: no Redis backend available")
         except Exception as e:
             logger.warning(f"Failed to publish heartbeat for {self.agent_id}: {e}")
 
@@ -249,8 +245,8 @@ class HeartbeatCoordinator:
 
         try:
             # Scan for heartbeat:* keys
-            if hasattr(self.memory, "_redis"):
-                keys = self.memory._redis.keys("heartbeat:*")
+            if hasattr(self.memory, "_client") and self.memory._client:
+                keys = self.memory._client.keys("heartbeat:*")
             else:
                 logger.warning("Cannot scan for heartbeats: no Redis access")
                 return []
@@ -305,23 +301,26 @@ class HeartbeatCoordinator:
         return None
 
     def _retrieve_heartbeat(self, key: str) -> dict[str, Any] | None:
-        """Retrieve heartbeat data from memory."""
+        """Retrieve heartbeat data from memory.
+
+        Heartbeat keys are stored directly as 'heartbeat:{agent_id}' and must be
+        retrieved via direct Redis access, not through the standard retrieve() method
+        which expects keys with 'working:{agent_id}:{key}' format.
+        """
         if not self.memory:
             return None
 
         try:
-            # Try retrieve method first (UnifiedMemory)
-            if hasattr(self.memory, "retrieve"):
-                return self.memory.retrieve(key, credentials=None)
-            # Try direct Redis access
-            elif hasattr(self.memory, "_redis"):
+            # Use direct Redis access for heartbeat keys
+            if hasattr(self.memory, "_client") and 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")
-                    return json.loads(data)
+                    result = json.loads(data)
+                    return result if isinstance(result, dict) else None
             return None
         except Exception as e:
             logger.debug(f"Failed to retrieve heartbeat {key}: {e}")