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

empathy_os/models/registry.py

@@ -0,0 +1,382 @@
+"""Unified Model Registry - Single Source of Truth
+
+This module provides a centralized model configuration that is consumed by:
+- empathy_llm_toolkit.routing.ModelRouter (via compatibility properties)
+- src/empathy_os/workflows.config.WorkflowConfig
+- src/empathy_os.cost_tracker
+
+Pricing is stored in per-million tokens (industry standard) with computed
+properties for per-1k compatibility with legacy code.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any
+
+
+class ModelTier(Enum):
+    """Model tier classification for routing.
+
+    CHEAP: Fast, low-cost models for simple tasks (~$0.15-1.00/M input)
+    CAPABLE: Balanced models for most development work (~$2.50-3.00/M input)
+    PREMIUM: Highest capability for complex reasoning (~$15.00/M input)
+    """
+
+    CHEAP = "cheap"
+    CAPABLE = "capable"
+    PREMIUM = "premium"
+
+
+class ModelProvider(Enum):
+    """Supported model providers."""
+
+    ANTHROPIC = "anthropic"
+    OPENAI = "openai"
+    GOOGLE = "google"
+    OLLAMA = "ollama"
+    HYBRID = "hybrid"
+    CUSTOM = "custom"
+
+
+@dataclass(frozen=True)
+class ModelInfo:
+    """Unified model information - single source of truth.
+
+    Pricing is stored in per-million tokens format. Use the cost_per_1k_*
+    properties for compatibility with code expecting per-1k pricing.
+
+    Attributes:
+        id: Model identifier (e.g., "claude-3-5-haiku-20241022")
+        provider: Provider name (e.g., "anthropic")
+        tier: Tier level (e.g., "cheap")
+        input_cost_per_million: Input token cost per million tokens
+        output_cost_per_million: Output token cost per million tokens
+        max_tokens: Maximum output tokens
+        supports_vision: Whether model supports vision/images
+        supports_tools: Whether model supports tool/function calling
+
+    """
+
+    id: str
+    provider: str
+    tier: str
+    input_cost_per_million: float
+    output_cost_per_million: float
+    max_tokens: int = 4096
+    supports_vision: bool = False
+    supports_tools: bool = True
+
+    # Compatibility properties for toolkit (per-1k pricing)
+    @property
+    def model_id(self) -> str:
+        """Alias for id - compatibility with ModelRouter.ModelConfig."""
+        return self.id
+
+    @property
+    def name(self) -> str:
+        """Alias for id - compatibility with WorkflowConfig.ModelConfig."""
+        return self.id
+
+    @property
+    def cost_per_1k_input(self) -> float:
+        """Input cost per 1k tokens - for ModelRouter compatibility."""
+        return self.input_cost_per_million / 1000
+
+    @property
+    def cost_per_1k_output(self) -> float:
+        """Output cost per 1k tokens - for ModelRouter compatibility."""
+        return self.output_cost_per_million / 1000
+
+    def to_router_config(self) -> dict[str, Any]:
+        """Convert to ModelRouter.ModelConfig compatible dict."""
+        return {
+            "model_id": self.id,
+            "cost_per_1k_input": self.cost_per_1k_input,
+            "cost_per_1k_output": self.cost_per_1k_output,
+            "max_tokens": self.max_tokens,
+            "supports_tools": self.supports_tools,
+        }
+
+    def to_workflow_config(self) -> dict[str, Any]:
+        """Convert to WorkflowConfig.ModelConfig compatible dict."""
+        return {
+            "name": self.id,
+            "provider": self.provider,
+            "tier": self.tier,
+            "input_cost_per_million": self.input_cost_per_million,
+            "output_cost_per_million": self.output_cost_per_million,
+            "max_tokens": self.max_tokens,
+            "supports_vision": self.supports_vision,
+            "supports_tools": self.supports_tools,
+        }
+
+    def to_cost_tracker_pricing(self) -> dict[str, float]:
+        """Convert to cost_tracker MODEL_PRICING format."""
+        return {
+            "input": self.input_cost_per_million,
+            "output": self.output_cost_per_million,
+        }
+
+
+# =============================================================================
+# MODEL REGISTRY - Single Source of Truth
+# =============================================================================
+# All model configurations are defined here. Other modules should import
+# from this registry rather than defining their own model configs.
+
+MODEL_REGISTRY: dict[str, dict[str, ModelInfo]] = {
+    # -------------------------------------------------------------------------
+    # Anthropic Claude Models
+    # -------------------------------------------------------------------------
+    "anthropic": {
+        "cheap": ModelInfo(
+            id="claude-3-5-haiku-20241022",
+            provider="anthropic",
+            tier="cheap",
+            input_cost_per_million=0.80,
+            output_cost_per_million=4.00,
+            max_tokens=8192,
+            supports_vision=False,
+            supports_tools=True,
+        ),
+        "capable": ModelInfo(
+            id="claude-sonnet-4-20250514",
+            provider="anthropic",
+            tier="capable",
+            input_cost_per_million=3.00,
+            output_cost_per_million=15.00,
+            max_tokens=8192,
+            supports_vision=True,
+            supports_tools=True,
+        ),
+        "premium": ModelInfo(
+            id="claude-opus-4-5-20251101",
+            provider="anthropic",
+            tier="premium",
+            input_cost_per_million=15.00,
+            output_cost_per_million=75.00,
+            max_tokens=8192,
+            supports_vision=True,
+            supports_tools=True,
+        ),
+    },
+    # -------------------------------------------------------------------------
+    # OpenAI Models
+    # -------------------------------------------------------------------------
+    "openai": {
+        "cheap": ModelInfo(
+            id="gpt-4o-mini",
+            provider="openai",
+            tier="cheap",
+            input_cost_per_million=0.15,
+            output_cost_per_million=0.60,
+            max_tokens=4096,
+            supports_vision=False,
+            supports_tools=True,
+        ),
+        "capable": ModelInfo(
+            id="gpt-4o",
+            provider="openai",
+            tier="capable",
+            input_cost_per_million=2.50,
+            output_cost_per_million=10.00,
+            max_tokens=4096,
+            supports_vision=True,
+            supports_tools=True,
+        ),
+        "premium": ModelInfo(
+            id="o1",
+            provider="openai",
+            tier="premium",
+            input_cost_per_million=15.00,
+            output_cost_per_million=60.00,
+            max_tokens=32768,
+            supports_vision=False,
+            supports_tools=False,  # o1 doesn't support tools yet
+        ),
+    },
+    # -------------------------------------------------------------------------
+    # Google Gemini Models
+    # Key feature: Massive context windows (1M-2M tokens)
+    # Model recommendations by tier:
+    #   cheap: gemini-2.0-flash-exp (1M context, fast, very cheap)
+    #   capable: gemini-1.5-pro (2M context, excellent for large codebases)
+    #   premium: gemini-2.5-pro (Google's most capable reasoning model)
+    # -------------------------------------------------------------------------
+    "google": {
+        "cheap": ModelInfo(
+            id="gemini-2.0-flash-exp",
+            provider="google",
+            tier="cheap",
+            input_cost_per_million=0.10,
+            output_cost_per_million=0.40,
+            max_tokens=8192,
+            supports_vision=True,
+            supports_tools=True,
+        ),
+        "capable": ModelInfo(
+            id="gemini-1.5-pro",
+            provider="google",
+            tier="capable",
+            input_cost_per_million=1.25,
+            output_cost_per_million=5.00,
+            max_tokens=8192,
+            supports_vision=True,
+            supports_tools=True,
+        ),
+        "premium": ModelInfo(
+            id="gemini-2.5-pro",
+            provider="google",
+            tier="premium",
+            input_cost_per_million=1.25,
+            output_cost_per_million=10.00,
+            max_tokens=8192,
+            supports_vision=True,
+            supports_tools=True,
+        ),
+    },
+    # -------------------------------------------------------------------------
+    # Ollama (Local) Models - Zero cost
+    # Model recommendations by tier:
+    #   cheap: Small, fast models (3B params) - llama3.2:3b
+    #   capable: Mid-size models (8B params) - llama3.1:8b
+    #   premium: Large models (70B params) - llama3.1:70b
+    # Users need to pull models: ollama pull llama3.2:3b llama3.1:8b llama3.1:70b
+    # -------------------------------------------------------------------------
+    "ollama": {
+        "cheap": ModelInfo(
+            id="llama3.2:3b",
+            provider="ollama",
+            tier="cheap",
+            input_cost_per_million=0.0,
+            output_cost_per_million=0.0,
+            max_tokens=4096,
+            supports_vision=False,
+            supports_tools=True,
+        ),
+        "capable": ModelInfo(
+            id="llama3.1:8b",
+            provider="ollama",
+            tier="capable",
+            input_cost_per_million=0.0,
+            output_cost_per_million=0.0,
+            max_tokens=8192,
+            supports_vision=False,
+            supports_tools=True,
+        ),
+        "premium": ModelInfo(
+            id="llama3.1:70b",
+            provider="ollama",
+            tier="premium",
+            input_cost_per_million=0.0,
+            output_cost_per_million=0.0,
+            max_tokens=8192,
+            supports_vision=False,
+            supports_tools=True,
+        ),
+    },
+    # -------------------------------------------------------------------------
+    # Hybrid - Mix of best models from different providers
+    # -------------------------------------------------------------------------
+    "hybrid": {
+        "cheap": ModelInfo(
+            id="gpt-4o-mini",  # OpenAI - cheapest per token
+            provider="openai",
+            tier="cheap",
+            input_cost_per_million=0.15,
+            output_cost_per_million=0.60,
+            max_tokens=4096,
+            supports_vision=False,
+            supports_tools=True,
+        ),
+        "capable": ModelInfo(
+            id="claude-sonnet-4-20250514",  # Anthropic - best reasoning
+            provider="anthropic",
+            tier="capable",
+            input_cost_per_million=3.00,
+            output_cost_per_million=15.00,
+            max_tokens=8192,
+            supports_vision=True,
+            supports_tools=True,
+        ),
+        "premium": ModelInfo(
+            id="claude-opus-4-5-20251101",  # Anthropic - best overall
+            provider="anthropic",
+            tier="premium",
+            input_cost_per_million=15.00,
+            output_cost_per_million=75.00,
+            max_tokens=8192,
+            supports_vision=True,
+            supports_tools=True,
+        ),
+    },
+}
+
+
+# =============================================================================
+# HELPER FUNCTIONS
+# =============================================================================
+
+
+def get_model(provider: str, tier: str) -> ModelInfo | None:
+    """Get model info for a provider/tier combination.
+
+    Args:
+        provider: Provider name (anthropic, openai, ollama, hybrid)
+        tier: Tier level (cheap, capable, premium)
+
+    Returns:
+        ModelInfo if found, None otherwise
+
+    """
+    provider_models = MODEL_REGISTRY.get(provider.lower())
+    if provider_models is None:
+        return None
+    return provider_models.get(tier.lower())
+
+
+def get_all_models() -> dict[str, dict[str, ModelInfo]]:
+    """Get the complete model registry."""
+    return MODEL_REGISTRY
+
+
+def get_pricing_for_model(model_id: str) -> dict[str, float] | None:
+    """Get pricing for a model by its ID.
+
+    Args:
+        model_id: Model identifier (e.g., "claude-3-5-haiku-20241022")
+
+    Returns:
+        Dict with 'input' and 'output' keys (per-million pricing), or None
+
+    """
+    for provider_models in MODEL_REGISTRY.values():
+        for model_info in provider_models.values():
+            if model_info.id == model_id:
+                return model_info.to_cost_tracker_pricing()
+    return None
+
+
+def get_supported_providers() -> list[str]:
+    """Get list of supported provider names."""
+    return list(MODEL_REGISTRY.keys())
+
+
+def get_tiers() -> list[str]:
+    """Get list of available tiers."""
+    return [tier.value for tier in ModelTier]
+
+
+# =============================================================================
+# TIER PRICING (for backward compatibility with cost_tracker)
+# =============================================================================
+# These are tier-level pricing aliases for when specific model isn't known
+
+TIER_PRICING: dict[str, dict[str, float]] = {
+    "cheap": {"input": 0.80, "output": 4.00},  # Haiku 3.5 pricing
+    "capable": {"input": 3.00, "output": 15.00},  # Sonnet 4 pricing
+    "premium": {"input": 15.00, "output": 75.00},  # Opus 4.5 pricing
+}

empathy_os/models/tasks.py

@@ -0,0 +1,302 @@
+"""Shared Task-Type Schema for Empathy Framework
+
+Provides a unified vocabulary for task types across:
+- empathy_llm_toolkit.routing.ModelRouter
+- src/empathy_os/workflows.WorkflowBase
+- empathy_software_plugin.wizards.MultiModelWizard
+
+This module defines:
+- TaskType enum with canonical task names
+- Task-to-tier mappings
+- Task normalization and lookup functions
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+from dataclasses import dataclass
+from enum import Enum
+
+from .registry import ModelTier
+
+
+class TaskType(Enum):
+    """Canonical task types for model routing.
+
+    Tasks are organized by their typical tier:
+    - CHEAP tier: Simple, fast tasks
+    - CAPABLE tier: Standard development work
+    - PREMIUM tier: Complex reasoning and coordination
+    """
+
+    # =========================================================================
+    # CHEAP TIER TASKS (~$0.15-1.00/M input)
+    # Fast models for simple, well-defined tasks
+    # =========================================================================
+    SUMMARIZE = "summarize"
+    CLASSIFY = "classify"
+    TRIAGE = "triage"
+    MATCH_PATTERN = "match_pattern"
+    EXTRACT_TOPICS = "extract_topics"
+    LINT_CHECK = "lint_check"
+    FORMAT_CODE = "format_code"
+    SIMPLE_QA = "simple_qa"
+    CATEGORIZE = "categorize"
+
+    # =========================================================================
+    # CAPABLE TIER TASKS (~$2.50-3.00/M input)
+    # Balanced models for standard development work
+    # =========================================================================
+    GENERATE_CODE = "generate_code"
+    FIX_BUG = "fix_bug"
+    REVIEW_SECURITY = "review_security"
+    ANALYZE_PERFORMANCE = "analyze_performance"
+    WRITE_TESTS = "write_tests"
+    REFACTOR = "refactor"
+    EXPLAIN_CODE = "explain_code"
+    DOCUMENT_CODE = "document_code"
+    ANALYZE_ERROR = "analyze_error"
+    SUGGEST_FIX = "suggest_fix"
+
+    # =========================================================================
+    # PREMIUM TIER TASKS (~$15.00/M input)
+    # Highest capability for complex reasoning
+    # =========================================================================
+    COORDINATE = "coordinate"
+    SYNTHESIZE_RESULTS = "synthesize_results"
+    ARCHITECTURAL_DECISION = "architectural_decision"
+    NOVEL_PROBLEM = "novel_problem"
+    FINAL_REVIEW = "final_review"
+    COMPLEX_REASONING = "complex_reasoning"
+    MULTI_STEP_PLANNING = "multi_step_planning"
+    CRITICAL_DECISION = "critical_decision"
+
+
+@dataclass(frozen=True)
+class TaskInfo:
+    """Information about a task type."""
+
+    task_type: TaskType
+    tier: ModelTier
+    description: str
+
+
+# =============================================================================
+# TASK-TO-TIER MAPPINGS
+# =============================================================================
+
+# Cheap tier tasks
+CHEAP_TASKS: frozenset[str] = frozenset(
+    [
+        TaskType.SUMMARIZE.value,
+        TaskType.CLASSIFY.value,
+        TaskType.TRIAGE.value,
+        TaskType.MATCH_PATTERN.value,
+        TaskType.EXTRACT_TOPICS.value,
+        TaskType.LINT_CHECK.value,
+        TaskType.FORMAT_CODE.value,
+        TaskType.SIMPLE_QA.value,
+        TaskType.CATEGORIZE.value,
+    ],
+)
+
+# Capable tier tasks
+CAPABLE_TASKS: frozenset[str] = frozenset(
+    [
+        TaskType.GENERATE_CODE.value,
+        TaskType.FIX_BUG.value,
+        TaskType.REVIEW_SECURITY.value,
+        TaskType.ANALYZE_PERFORMANCE.value,
+        TaskType.WRITE_TESTS.value,
+        TaskType.REFACTOR.value,
+        TaskType.EXPLAIN_CODE.value,
+        TaskType.DOCUMENT_CODE.value,
+        TaskType.ANALYZE_ERROR.value,
+        TaskType.SUGGEST_FIX.value,
+    ],
+)
+
+# Premium tier tasks
+PREMIUM_TASKS: frozenset[str] = frozenset(
+    [
+        TaskType.COORDINATE.value,
+        TaskType.SYNTHESIZE_RESULTS.value,
+        TaskType.ARCHITECTURAL_DECISION.value,
+        TaskType.NOVEL_PROBLEM.value,
+        TaskType.FINAL_REVIEW.value,
+        TaskType.COMPLEX_REASONING.value,
+        TaskType.MULTI_STEP_PLANNING.value,
+        TaskType.CRITICAL_DECISION.value,
+    ],
+)
+
+# Complete mapping for lookup
+TASK_TIER_MAP: dict[str, ModelTier] = {
+    **dict.fromkeys(CHEAP_TASKS, ModelTier.CHEAP),
+    **dict.fromkeys(CAPABLE_TASKS, ModelTier.CAPABLE),
+    **dict.fromkeys(PREMIUM_TASKS, ModelTier.PREMIUM),
+}
+
+
+# =============================================================================
+# HELPER FUNCTIONS
+# =============================================================================
+
+
+def normalize_task_type(task_type: str) -> str:
+    """Normalize a task type string for lookup.
+
+    Converts to lowercase and normalizes separators to underscores.
+
+    Args:
+        task_type: Task type string (e.g., "Fix-Bug", "fix bug", "FIX_BUG")
+
+    Returns:
+        Normalized task type (e.g., "fix_bug")
+
+    """
+    return task_type.lower().replace("-", "_").replace(" ", "_")
+
+
+def get_tier_for_task(task_type: str | TaskType) -> ModelTier:
+    """Get the appropriate tier for a task type.
+
+    Args:
+        task_type: Task type string or TaskType enum
+
+    Returns:
+        ModelTier for the task (defaults to CAPABLE for unknown tasks)
+
+    Example:
+        >>> get_tier_for_task("summarize")
+        ModelTier.CHEAP
+        >>> get_tier_for_task("fix_bug")
+        ModelTier.CAPABLE
+        >>> get_tier_for_task("coordinate")
+        ModelTier.PREMIUM
+        >>> get_tier_for_task("unknown_task")
+        ModelTier.CAPABLE
+
+    """
+    # Handle TaskType enum
+    if isinstance(task_type, TaskType):
+        task_str = task_type.value
+    else:
+        task_str = normalize_task_type(task_type)
+
+    # Lookup in mapping
+    return TASK_TIER_MAP.get(task_str, ModelTier.CAPABLE)
+
+
+def get_tasks_for_tier(tier: ModelTier) -> list[str]:
+    """Get all task types for a given tier.
+
+    Args:
+        tier: ModelTier to get tasks for
+
+    Returns:
+        List of task type strings
+
+    """
+    if tier == ModelTier.CHEAP:
+        return list(CHEAP_TASKS)
+    if tier == ModelTier.CAPABLE:
+        return list(CAPABLE_TASKS)
+    if tier == ModelTier.PREMIUM:
+        return list(PREMIUM_TASKS)
+    return []
+
+
+def get_all_tasks() -> dict[str, list[str]]:
+    """Get all known task types organized by tier.
+
+    Returns:
+        Dict mapping tier name to list of task types
+
+    """
+    return {
+        "cheap": list(CHEAP_TASKS),
+        "capable": list(CAPABLE_TASKS),
+        "premium": list(PREMIUM_TASKS),
+    }
+
+
+def is_known_task(task_type: str) -> bool:
+    """Check if a task type is known/defined.
+
+    Args:
+        task_type: Task type string
+
+    Returns:
+        True if task is defined, False otherwise
+
+    """
+    normalized = normalize_task_type(task_type)
+    return normalized in TASK_TIER_MAP
+
+
+# =============================================================================
+# TASK INFO REGISTRY
+# =============================================================================
+# Detailed information about each task type
+
+TASK_INFO: dict[TaskType, TaskInfo] = {
+    # Cheap tasks
+    TaskType.SUMMARIZE: TaskInfo(
+        TaskType.SUMMARIZE,
+        ModelTier.CHEAP,
+        "Summarize text or code into concise form",
+    ),
+    TaskType.CLASSIFY: TaskInfo(
+        TaskType.CLASSIFY,
+        ModelTier.CHEAP,
+        "Classify input into predefined categories",
+    ),
+    TaskType.TRIAGE: TaskInfo(
+        TaskType.TRIAGE,
+        ModelTier.CHEAP,
+        "Quick assessment and prioritization",
+    ),
+    TaskType.SIMPLE_QA: TaskInfo(
+        TaskType.SIMPLE_QA,
+        ModelTier.CHEAP,
+        "Answer simple, factual questions",
+    ),
+    # Capable tasks
+    TaskType.GENERATE_CODE: TaskInfo(
+        TaskType.GENERATE_CODE,
+        ModelTier.CAPABLE,
+        "Generate new code from requirements",
+    ),
+    TaskType.FIX_BUG: TaskInfo(
+        TaskType.FIX_BUG,
+        ModelTier.CAPABLE,
+        "Identify and fix bugs in code",
+    ),
+    TaskType.REVIEW_SECURITY: TaskInfo(
+        TaskType.REVIEW_SECURITY,
+        ModelTier.CAPABLE,
+        "Review code for security vulnerabilities",
+    ),
+    TaskType.WRITE_TESTS: TaskInfo(
+        TaskType.WRITE_TESTS,
+        ModelTier.CAPABLE,
+        "Write unit or integration tests",
+    ),
+    # Premium tasks
+    TaskType.COORDINATE: TaskInfo(
+        TaskType.COORDINATE,
+        ModelTier.PREMIUM,
+        "Coordinate multi-agent workflows",
+    ),
+    TaskType.ARCHITECTURAL_DECISION: TaskInfo(
+        TaskType.ARCHITECTURAL_DECISION,
+        ModelTier.PREMIUM,
+        "Make complex architectural decisions",
+    ),
+    TaskType.COMPLEX_REASONING: TaskInfo(
+        TaskType.COMPLEX_REASONING,
+        ModelTier.PREMIUM,
+        "Handle complex multi-step reasoning",
+    ),
+}