empathy-framework 2.4.0__py3-none-any.whl → 3.8.2__py3-none-any.whl

empathy_os/cost_tracker.py

@@ -1,5 +1,4 @@
-"""
-Cost Tracking for Empathy Framework
+"""Cost Tracking for Empathy Framework
 
 Tracks API costs across model tiers and calculates savings from
 smart model routing (Haiku/Sonnet/Opus selection).
@@ -10,6 +9,8 @@ Features:
 - Generate weekly/monthly reports
 - Integrate with `empathy costs` and `empathy morning` commands
 
+Model pricing is sourced from empathy_os.models.MODEL_REGISTRY.
+
 Copyright 2025 Smart-AI-Memory
 Licensed under Fair Source License 0.9
 """
@@ -17,32 +18,49 @@ Licensed under Fair Source License 0.9
 import json
 from datetime import datetime, timedelta
 from pathlib import Path
+from typing import Any
+
+# Import pricing from unified registry
+from empathy_os.models import MODEL_REGISTRY
+from empathy_os.models.registry import TIER_PRICING
+
+
+def _build_model_pricing() -> dict[str, dict[str, float]]:
+    """Build MODEL_PRICING from unified registry."""
+    pricing: dict[str, dict[str, float]] = {}
+
+    # Add all models from registry
+    for provider_models in MODEL_REGISTRY.values():
+        for model_info in provider_models.values():
+            pricing[model_info.id] = {
+                "input": model_info.input_cost_per_million,
+                "output": model_info.output_cost_per_million,
+            }
+
+    # Add tier aliases from registry
+    pricing.update(TIER_PRICING)
+
+    # Add legacy model names for backward compatibility
+    legacy_models = {
+        "claude-3-haiku-20240307": {"input": 0.25, "output": 1.25},
+        "claude-3-5-sonnet-20241022": {"input": 3.00, "output": 15.00},
+        "claude-opus-4-20250514": {"input": 15.00, "output": 75.00},
+        "gpt-4-turbo": {"input": 10.00, "output": 30.00},
+    }
+    pricing.update(legacy_models)
+
+    return pricing
 
-# Pricing per million tokens (as of December 2024)
-MODEL_PRICING = {
-    # Anthropic Claude models
-    "claude-3-haiku-20240307": {"input": 0.25, "output": 1.25},
-    "claude-3-5-haiku-20241022": {"input": 0.80, "output": 4.00},
-    "claude-3-5-sonnet-20241022": {"input": 3.00, "output": 15.00},
-    "claude-sonnet-4-20250514": {"input": 3.00, "output": 15.00},
-    "claude-opus-4-20250514": {"input": 15.00, "output": 75.00},
-    # Tier aliases (for backward compatibility)
-    "cheap": {"input": 0.25, "output": 1.25},
-    "capable": {"input": 3.00, "output": 15.00},
-    "premium": {"input": 15.00, "output": 75.00},
-    # OpenAI models (for comparison)
-    "gpt-4o": {"input": 2.50, "output": 10.00},
-    "gpt-4o-mini": {"input": 0.15, "output": 0.60},
-    "gpt-4-turbo": {"input": 10.00, "output": 30.00},
-}
+
+# Pricing per million tokens - sourced from unified registry
+MODEL_PRICING = _build_model_pricing()
 
 # Default premium model for baseline comparison
-BASELINE_MODEL = "claude-opus-4-20250514"
+BASELINE_MODEL = "claude-opus-4-5-20251101"
 
 
 class CostTracker:
-    """
-    Tracks API costs and calculates savings from model routing.
+    """Tracks API costs and calculates savings from model routing.
 
     Usage:
         tracker = CostTracker()
@@ -51,11 +69,11 @@ class CostTracker:
     """
 
     def __init__(self, storage_dir: str = ".empathy"):
-        """
-        Initialize cost tracker.
+        """Initialize cost tracker.
 
         Args:
             storage_dir: Directory for cost data storage
+
         """
         self.storage_dir = Path(storage_dir)
         self.storage_dir.mkdir(parents=True, exist_ok=True)
@@ -89,8 +107,7 @@ class CostTracker:
             json.dump(self.data, f, indent=2)
 
     def _calculate_cost(self, model: str, input_tokens: int, output_tokens: int) -> float:
-        """
-        Calculate cost for a request.
+        """Calculate cost for a request.
 
         Args:
             model: Model name or tier
@@ -99,8 +116,9 @@ class CostTracker:
 
         Returns:
             Cost in USD
+
         """
-        pricing = MODEL_PRICING.get(model, MODEL_PRICING.get("capable"))
+        pricing = MODEL_PRICING.get(model) or MODEL_PRICING["capable"]
         input_cost = (input_tokens / 1_000_000) * pricing["input"]
         output_cost = (output_tokens / 1_000_000) * pricing["output"]
         return input_cost + output_cost
@@ -113,8 +131,7 @@ class CostTracker:
         task_type: str = "unknown",
         tier: str | None = None,
     ) -> dict:
-        """
-        Log an API request with cost tracking.
+        """Log an API request with cost tracking.
 
         Args:
             model: Model name used
@@ -125,6 +142,7 @@ class CostTracker:
 
         Returns:
             Request record with cost information
+
         """
         actual_cost = self._calculate_cost(model, input_tokens, output_tokens)
         baseline_cost = self._calculate_cost(BASELINE_MODEL, input_tokens, output_tokens)
@@ -175,25 +193,24 @@ class CostTracker:
         """Determine tier from model name."""
         if "haiku" in model.lower():
             return "cheap"
-        elif "opus" in model.lower():
+        if "opus" in model.lower():
             return "premium"
-        else:
-            return "capable"
+        return "capable"
 
     def get_summary(self, days: int = 7) -> dict:
-        """
-        Get cost summary for recent period.
+        """Get cost summary for recent period.
 
         Args:
             days: Number of days to include
 
         Returns:
             Summary with totals and savings percentage
+
         """
         cutoff = datetime.now() - timedelta(days=days)
         cutoff_str = cutoff.strftime("%Y-%m-%d")
 
-        totals = {
+        totals: dict[str, Any] = {
             "days": days,
             "requests": 0,
             "input_tokens": 0,
@@ -226,7 +243,8 @@ class CostTracker:
         # Calculate savings percentage
         if totals["baseline_cost"] > 0:
             totals["savings_percent"] = round(
-                (totals["savings"] / totals["baseline_cost"]) * 100, 1
+                (totals["savings"] / totals["baseline_cost"]) * 100,
+                1,
             )
         else:
             totals["savings_percent"] = 0
@@ -234,14 +252,14 @@ class CostTracker:
         return totals
 
     def get_report(self, days: int = 7) -> str:
-        """
-        Generate a formatted cost report.
+        """Generate a formatted cost report.
 
         Args:
             days: Number of days to include
 
         Returns:
             Formatted report string
+
         """
         summary = self.get_summary(days)
 
@@ -272,7 +290,7 @@ class CostTracker:
                 [
                     "BY MODEL TIER",
                     "-" * 40,
-                ]
+                ],
             )
             for tier, count in sorted(summary["by_tier"].items(), key=lambda x: -x[1]):
                 if count > 0:
@@ -286,7 +304,7 @@ class CostTracker:
                 [
                     "BY TASK TYPE (Top 5)",
                     "-" * 40,
-                ]
+                ],
             )
             sorted_tasks = sorted(summary["by_task"].items(), key=lambda x: -x[1])[:5]
             for task, count in sorted_tasks:
@@ -300,25 +318,27 @@ class CostTracker:
                 "  for simple tasks and Opus only when needed.",
                 "=" * 60,
                 "",
-            ]
+            ],
         )
 
         return "\n".join(lines)
 
-    def get_today(self) -> dict:
+    def get_today(self) -> dict[str, int | float]:
         """Get today's cost summary."""
         today = datetime.now().strftime("%Y-%m-%d")
-        return self.data.get("daily_totals", {}).get(
-            today,
-            {
-                "requests": 0,
-                "input_tokens": 0,
-                "output_tokens": 0,
-                "actual_cost": 0,
-                "baseline_cost": 0,
-                "savings": 0,
-            },
-        )
+        daily_totals = self.data.get("daily_totals", {})
+        default: dict[str, int | float] = {
+            "requests": 0,
+            "input_tokens": 0,
+            "output_tokens": 0,
+            "actual_cost": 0,
+            "baseline_cost": 0,
+            "savings": 0,
+        }
+        if isinstance(daily_totals, dict) and today in daily_totals:
+            result = daily_totals[today]
+            return result if isinstance(result, dict) else default
+        return default
 
 
 def cmd_costs(args):
@@ -355,8 +375,7 @@ def log_request(
     task_type: str = "unknown",
     tier: str | None = None,
 ) -> dict:
-    """
-    Convenience function to log a request to the global tracker.
+    """Convenience function to log a request to the global tracker.
 
     Usage:
         from empathy_os.cost_tracker import log_request

empathy_os/dashboard/__init__.py

@@ -0,0 +1,15 @@
+"""Visual Dashboard for Empathy Framework
+
+Web-based view of patterns, costs, and health trends.
+
+Usage:
+    empathy dashboard
+    # Opens browser to http://localhost:8765
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+from empathy_os.dashboard.server import cmd_dashboard, run_dashboard
+
+__all__ = ["cmd_dashboard", "run_dashboard"]