adaptive-memory-multi-model-router 1.2.2 → 1.3.1

package/src/providers/anthropic.py

@@ -0,0 +1,304 @@
+"""
+Anthropic Provider Implementation - Agent 2 Output (Part 1)
+
+Implements Anthropic Claude API provider.
+"""
+
+import os
+import time
+from typing import Dict, Any
+from datetime import datetime
+
+from .base import BaseProvider, ProviderConfig, ProviderResponse, ProviderHealth
+
+
+class AnthropicProvider(BaseProvider):
+    """
+    Anthropic Claude API provider.
+
+    Supports models: claude-sonnet-4, claude-opus-4, claude-haiku-4
+    """
+
+    # Pricing (per 1M tokens as of 2025)
+    PRICING = {
+        "claude-sonnet-4": {"input": 3.0, "output": 15.0},
+        "claude-opus-4": {"input": 15.0, "output": 75.0},
+        "claude-haiku-4": {"input": 0.25, "output": 1.25},
+    }
+
+    def __init__(self, config: ProviderConfig):
+        super().__init__(config)
+        self.api_key = os.getenv(config.api_key_env)
+
+        if not self.api_key:
+            raise ValueError(f"API key not found: {config.api_key_env}")
+
+    async def execute(
+        self,
+        prompt: str,
+        max_tokens: int = 2000,
+        temperature: float = 0.7,
+        **kwargs
+    ) -> ProviderResponse:
+        """
+        Execute prompt with Anthropic Claude.
+
+        Note: This is a placeholder implementation.
+        In production, use actual Anthropic API:
+        ```python
+        import anthropic
+        client = anthropic.Anthropic(api_key=self.api_key)
+        message = client.messages.create(
+            model=self.config.model,
+            max_tokens=max_tokens,
+            temperature=temperature,
+            messages=[{"role": "user", "content": prompt}]
+        )
+        ```
+        """
+        start_time = time.time()
+
+        try:
+            # Placeholder: Simulate API call
+            # In production, use actual Anthropic SDK
+            response_content = await self._mock_api_call(prompt, max_tokens)
+
+            latency_ms = (time.time() - start_time) * 1000
+
+            # Estimate tokens (rough approximation: 1 token ≈ 4 chars)
+            estimated_tokens = len(prompt) // 4 + len(response_content) // 4
+
+            response = ProviderResponse(
+                success=True,
+                content=response_content,
+                tokens_used=estimated_tokens,
+                cost=self.calculate_cost(estimated_tokens),
+                latency_ms=latency_ms,
+                model=self.config.model,
+                provider=self.config.name,
+                timestamp=datetime.now().isoformat(),
+                metadata={
+                    "temperature": temperature,
+                    "max_tokens": max_tokens
+                }
+            )
+
+            return response
+
+        except Exception as e:
+            latency_ms = (time.time() - start_time) * 1000
+
+            return ProviderResponse(
+                success=False,
+                content="",
+                tokens_used=0,
+                cost=0.0,
+                latency_ms=latency_ms,
+                model=self.config.model,
+                provider=self.config.name,
+                timestamp=datetime.now().isoformat(),
+                metadata={},
+                error=str(e)
+            )
+
+    async def _mock_api_call(self, prompt: str, max_tokens: int) -> str:
+        """Mock API call for development (replace with real API)"""
+        # Simulate network delay
+        import asyncio
+        await asyncio.sleep(0.5)
+
+        return f"[Anthropic {self.config.model}] Response to: {prompt[:100]}..."
+
+    def calculate_cost(self, tokens: int) -> float:
+        """
+        Calculate cost in USD.
+
+        Anthropic charges separately for input and output tokens.
+        We estimate 50/50 split for simplicity.
+        """
+        pricing = self.PRICING.get(self.config.model, {"input": 3.0, "output": 15.0})
+
+        # Assume 50/50 input/output split
+        input_cost = (tokens / 2) * pricing["input"] / 1_000_000
+        output_cost = (tokens / 2) * pricing["output"] / 1_000_000
+
+        return input_cost + output_cost
+
+    async def health_check(self) -> ProviderHealth:
+        """
+        Check Anthropic API health.
+
+        In production, make actual API call:
+        ```python
+        try:
+            client = anthropic.Anthropic(api_key=self.api_key)
+            # Simple ping
+            start = time.time()
+            # Make minimal request
+            latency = (time.time() - start) * 1000
+            return ProviderHealth(status="healthy", latency_ms=latency, ...)
+        except Exception:
+            return ProviderHealth(status="unhealthy", ...)
+        ```
+        """
+        import asyncio
+
+        try:
+            start = time.time()
+
+            # Mock health check (replace with real API ping)
+            await asyncio.sleep(0.2)
+
+            latency_ms = (time.time() - start) * 1000
+
+            self.health = ProviderHealth(
+                status="healthy",
+                last_check=datetime.now().isoformat(),
+                consecutive_failures=0,
+                latency_ms=latency_ms,
+                uptime_percentage=100.0
+            )
+
+            return self.health
+
+        except Exception as e:
+            self.health = ProviderHealth(
+                status="unhealthy",
+                last_check=datetime.now().isoformat(),
+                consecutive_failures=self.health.consecutive_failures + 1,
+                last_error=str(e)
+            )
+
+            return self.health
+
+
+class OpenAIProvider(BaseProvider):
+    """
+    OpenAI GPT API provider.
+
+    Supports models: gpt-4o, gpt-4-turbo, gpt-3.5-turbo
+    """
+
+    # Pricing (per 1M tokens as of 2025)
+    PRICING = {
+        "gpt-4o": {"input": 2.50, "output": 10.0},
+        "gpt-4-turbo": {"input": 10.0, "output": 30.0},
+        "gpt-3.5-turbo": {"input": 0.50, "output": 1.50},
+    }
+
+    def __init__(self, config: ProviderConfig):
+        super().__init__(config)
+        self.api_key = os.getenv(config.api_key_env)
+
+        if not self.api_key:
+            raise ValueError(f"API key not found: {config.api_key_env}")
+
+    async def execute(
+        self,
+        prompt: str,
+        max_tokens: int = 2000,
+        temperature: float = 0.7,
+        **kwargs
+    ) -> ProviderResponse:
+        """
+        Execute prompt with OpenAI GPT.
+
+        Note: This is a placeholder implementation.
+        In production, use actual OpenAI API:
+        ```python
+        from openai import AsyncOpenAI
+        client = AsyncOpenAI(api_key=self.api_key)
+        response = await client.chat.completions.create(
+            model=self.config.model,
+            messages=[{"role": "user", "content": prompt}],
+            max_tokens=max_tokens,
+            temperature=temperature
+        )
+        ```
+        """
+        start_time = time.time()
+
+        try:
+            # Placeholder: Simulate API call
+            response_content = await self._mock_api_call(prompt, max_tokens)
+
+            latency_ms = (time.time() - start_time) * 1000
+            estimated_tokens = len(prompt) // 4 + len(response_content) // 4
+
+            response = ProviderResponse(
+                success=True,
+                content=response_content,
+                tokens_used=estimated_tokens,
+                cost=self.calculate_cost(estimated_tokens),
+                latency_ms=latency_ms,
+                model=self.config.model,
+                provider=self.config.name,
+                timestamp=datetime.now().isoformat(),
+                metadata={
+                    "temperature": temperature,
+                    "max_tokens": max_tokens
+                }
+            )
+
+            return response
+
+        except Exception as e:
+            latency_ms = (time.time() - start_time) * 1000
+
+            return ProviderResponse(
+                success=False,
+                content="",
+                tokens_used=0,
+                cost=0.0,
+                latency_ms=latency_ms,
+                model=self.config.model,
+                provider=self.config.name,
+                timestamp=datetime.now().isoformat(),
+                metadata={},
+                error=str(e)
+            )
+
+    async def _mock_api_call(self, prompt: str, max_tokens: int) -> str:
+        """Mock API call for development"""
+        import asyncio
+        await asyncio.sleep(0.4)
+
+        return f"[OpenAI {self.config.model}] Response to: {prompt[:100]}..."
+
+    def calculate_cost(self, tokens: int) -> float:
+        """Calculate cost in USD"""
+        pricing = self.PRICING.get(self.config.model, {"input": 2.50, "output": 10.0})
+
+        input_cost = (tokens / 2) * pricing["input"] / 1_000_000
+        output_cost = (tokens / 2) * pricing["output"] / 1_000_000
+
+        return input_cost + output_cost
+
+    async def health_check(self) -> ProviderHealth:
+        """Check OpenAI API health"""
+        import asyncio
+
+        try:
+            start = time.time()
+            await asyncio.sleep(0.2)
+            latency_ms = (time.time() - start) * 1000
+
+            self.health = ProviderHealth(
+                status="healthy",
+                last_check=datetime.now().isoformat(),
+                consecutive_failures=0,
+                latency_ms=latency_ms,
+                uptime_percentage=100.0
+            )
+
+            return self.health
+
+        except Exception as e:
+            self.health = ProviderHealth(
+                status="unhealthy",
+                last_check=datetime.now().isoformat(),
+                consecutive_failures=self.health.consecutive_failures + 1,
+                last_error=str(e)
+            )
+
+            return self.health

package/src/providers/base.py

@@ -0,0 +1,241 @@
+"""
+Base Provider Interface - Agent 1 Output
+
+Abstract base class for all LLM providers.
+Provides unified interface for multi-provider system.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Dict, Any, Optional
+from datetime import datetime
+from dataclasses import dataclass
+import asyncio
+
+
+@dataclass
+class ProviderConfig:
+    """Configuration for a provider"""
+    name: str
+    model: str
+    api_key_env: str
+    priority: int = 1
+    max_retries: int = 3
+    timeout: int = 30
+    enabled: bool = True
+
+
+@dataclass
+class ProviderHealth:
+    """Health status of a provider"""
+    status: str  # "healthy", "degraded", "unhealthy"
+    last_check: str
+    consecutive_failures: int
+    last_error: Optional[str] = None
+    latency_ms: Optional[float] = None
+    uptime_percentage: float = 100.0
+
+
+@dataclass
+class ProviderResponse:
+    """Standardized response from any provider"""
+    success: bool
+    content: str
+    tokens_used: int
+    cost: float
+    latency_ms: float
+    model: str
+    provider: str
+    timestamp: str
+    metadata: Dict[str, Any]
+    error: Optional[str] = None
+
+
+class BaseProvider(ABC):
+    """
+    Abstract base class for all LLM providers.
+
+    All providers must implement these methods to ensure
+    consistent interface across the multi-provider system.
+    """
+
+    def __init__(self, config: ProviderConfig):
+        self.config = config
+        self.health = ProviderHealth(
+            status="healthy",
+            last_check=datetime.now().isoformat(),
+            consecutive_failures=0
+        )
+        self._request_count = 0
+        self._success_count = 0
+        self._total_tokens = 0
+        self._total_cost = 0.0
+
+    @abstractmethod
+    async def execute(
+        self,
+        prompt: str,
+        max_tokens: int = 2000,
+        temperature: float = 0.7,
+        **kwargs
+    ) -> ProviderResponse:
+        """
+        Execute a prompt with this provider.
+
+        Args:
+            prompt: The prompt to execute
+            max_tokens: Maximum tokens in response
+            temperature: Sampling temperature
+            **kwargs: Provider-specific parameters
+
+        Returns:
+            ProviderResponse with standardized format
+        """
+        pass
+
+    @abstractmethod
+    def calculate_cost(self, tokens: int) -> float:
+        """
+        Calculate cost for token usage.
+
+        Args:
+            tokens: Number of tokens used
+
+        Returns:
+            Cost in USD
+        """
+        pass
+
+    @abstractmethod
+    async def health_check(self) -> ProviderHealth:
+        """
+        Check if provider is healthy and accessible.
+
+        Returns:
+            ProviderHealth status
+        """
+        pass
+
+    async def execute_with_retry(
+        self,
+        prompt: str,
+        max_retries: Optional[int] = None,
+        **kwargs
+    ) -> ProviderResponse:
+        """
+        Execute with automatic retry on failure.
+
+        Implements exponential backoff and circuit breaker pattern.
+        """
+        max_retries = max_retries or self.config.max_retries
+        last_error = None
+
+        for attempt in range(max_retries + 1):
+            try:
+                # Check if circuit is open (too many failures)
+                if self._is_circuit_open():
+                    await self._wait_for_circuit_close()
+                    continue
+
+                # Execute request
+                response = await self.execute(prompt, **kwargs)
+
+                # Update health on success
+                if response.success:
+                    self._record_success()
+                    self.health.consecutive_failures = 0
+                else:
+                    self._record_failure(response.error)
+                    raise Exception(response.error)
+
+                return response
+
+            except Exception as e:
+                last_error = str(e)
+                self._record_failure(last_error)
+
+                if attempt < max_retries:
+                    # Exponential backoff
+                    wait_time = 2 ** attempt
+                    await asyncio.sleep(wait_time)
+                    continue
+
+        # All retries failed
+        return ProviderResponse(
+            success=False,
+            content="",
+            tokens_used=0,
+            cost=0.0,
+            latency_ms=0.0,
+            model=self.config.model,
+            provider=self.config.name,
+            timestamp=datetime.now().isoformat(),
+            metadata={},
+            error=f"Failed after {max_retries} retries: {last_error}"
+        )
+
+    def get_health(self) -> ProviderHealth:
+        """Get current health status"""
+        return self.health
+
+    def get_stats(self) -> Dict[str, Any]:
+        """Get provider statistics"""
+        success_rate = (
+            (self._success_count / self._request_count * 100)
+            if self._request_count > 0
+            else 0
+        )
+
+        return {
+            "provider": self.config.name,
+            "model": self.config.model,
+            "requests": self._request_count,
+            "successes": self._success_count,
+            "success_rate": success_rate,
+            "total_tokens": self._total_tokens,
+            "total_cost": self._total_cost,
+            "avg_cost_per_1k_tokens": (
+                (self._total_cost / self._total_tokens * 1000)
+                if self._total_tokens > 0
+                else 0
+            ),
+            "health_status": self.health.status,
+            "uptime": self.health.uptime_percentage
+        }
+
+    def _record_success(self):
+        """Record successful request"""
+        self._request_count += 1
+        self._success_count += 1
+        self.health.last_check = datetime.now().isoformat()
+
+    def _record_failure(self, error: str):
+        """Record failed request"""
+        self._request_count += 1
+        self.health.consecutive_failures += 1
+        self.health.last_error = error
+        self.health.last_check = datetime.now().isoformat()
+
+        # Update status based on failures
+        if self.health.consecutive_failures >= 5:
+            self.health.status = "unhealthy"
+        elif self.health.consecutive_failures >= 2:
+            self.health.status = "degraded"
+
+    def _is_circuit_open(self) -> bool:
+        """Check if circuit breaker is open (too many failures)"""
+        return (
+            self.health.consecutive_failures >= 3 and
+            self.health.status == "unhealthy"
+        )
+
+    async def _wait_for_circuit_close(self):
+        """Wait before retrying when circuit is open"""
+        await asyncio.sleep(5)  # Wait 5 seconds
+
+    def __repr__(self) -> str:
+        return (
+            f"{self.__class__.__name__}("
+            f"name={self.config.name}, "
+            f"model={self.config.model}, "
+            f"status={self.health.status})"
+        )