llm-cost-guard 0.1.0__py3-none-any.whl

llm_cost_guard/pricing/loader.py

@@ -0,0 +1,221 @@
+"""
+Pricing data loader for LLM Cost Guard.
+"""
+
+import os
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, Optional
+import logging
+import yaml
+
+from llm_cost_guard.models import ModelPricing, ModelType
+from llm_cost_guard.exceptions import PricingNotFoundError
+
+logger = logging.getLogger(__name__)
+
+# Default pricing data directory
+PRICING_DIR = Path(__file__).parent
+
+
+class PricingLoader:
+    """Loads and manages pricing data for LLM providers."""
+
+    def __init__(
+        self,
+        pricing_overrides: Optional[Dict[str, Dict[str, Any]]] = None,
+        pricing_stale_warning_days: int = 7,
+        pricing_stale_error_days: int = 30,
+        bedrock_region: str = "us-east-1",
+    ):
+        self._pricing_data: Dict[str, Dict[str, ModelPricing]] = {}
+        self._pricing_versions: Dict[str, str] = {}
+        self._pricing_overrides = pricing_overrides or {}
+        self._stale_warning_days = pricing_stale_warning_days
+        self._stale_error_days = pricing_stale_error_days
+        self._bedrock_region = bedrock_region
+        self._last_loaded: Optional[datetime] = None
+
+        self._load_all_pricing()
+
+    def _load_all_pricing(self) -> None:
+        """Load pricing from all YAML files."""
+        for yaml_file in PRICING_DIR.glob("*.yaml"):
+            provider = yaml_file.stem
+            self._load_provider_pricing(provider, yaml_file)
+
+        self._last_loaded = datetime.now()
+
+    def _load_provider_pricing(self, provider: str, yaml_path: Path) -> None:
+        """Load pricing for a specific provider."""
+        try:
+            with open(yaml_path, "r") as f:
+                data = yaml.safe_load(f)
+
+            if not data:
+                return
+
+            self._pricing_versions[provider] = data.get("version", "unknown")
+            self._pricing_data[provider] = {}
+
+            models = data.get("models", {})
+            for model_name, model_data in models.items():
+                model_type_str = model_data.get("model_type", "chat")
+                model_type = ModelType(model_type_str) if model_type_str else ModelType.CHAT
+
+                pricing = ModelPricing(
+                    input_cost_per_1k=model_data.get("input_cost_per_1k", 0.0),
+                    output_cost_per_1k=model_data.get("output_cost_per_1k", 0.0),
+                    cached_input_cost_per_1k=model_data.get("cached_input_cost_per_1k"),
+                    context_window=model_data.get("context_window", 128000),
+                    model_type=model_type,
+                    image_cost_per_image=model_data.get("image_cost_per_image"),
+                    audio_cost_per_minute=model_data.get("audio_cost_per_minute"),
+                    embedding_dimensions=model_data.get("embedding_dimensions"),
+                )
+                self._pricing_data[provider][model_name] = pricing
+
+        except Exception as e:
+            logger.warning(f"Failed to load pricing for {provider}: {e}")
+
+    def get_pricing(self, provider: str, model: str) -> ModelPricing:
+        """Get pricing for a specific model."""
+        # Normalize provider and model names
+        provider = provider.lower()
+        model_lower = model.lower()
+
+        # Check overrides first
+        override_key = f"{provider}/{model}"
+        if override_key in self._pricing_overrides:
+            override = self._pricing_overrides[override_key]
+            return ModelPricing(
+                input_cost_per_1k=override.get("input_cost_per_1k", 0.0),
+                output_cost_per_1k=override.get("output_cost_per_1k", 0.0),
+                cached_input_cost_per_1k=override.get("cached_input_cost_per_1k"),
+                context_window=override.get("context_window", 128000),
+            )
+
+        # Check loaded pricing
+        if provider in self._pricing_data:
+            provider_pricing = self._pricing_data[provider]
+
+            # Try exact match
+            if model in provider_pricing:
+                return provider_pricing[model]
+
+            # Try lowercase match
+            if model_lower in provider_pricing:
+                return provider_pricing[model_lower]
+
+            # Try prefix match (for versioned models like gpt-4-0613)
+            for known_model in provider_pricing:
+                if model_lower.startswith(known_model) or known_model.startswith(model_lower):
+                    return provider_pricing[known_model]
+
+        raise PricingNotFoundError(
+            f"Pricing not found for {provider}/{model}", provider=provider, model=model
+        )
+
+    def calculate_cost(
+        self,
+        provider: str,
+        model: str,
+        input_tokens: int,
+        output_tokens: int,
+        cached_tokens: int = 0,
+    ) -> tuple[float, float, float]:
+        """
+        Calculate cost for a call.
+        Returns (input_cost, output_cost, total_cost).
+        """
+        pricing = self.get_pricing(provider, model)
+
+        # Calculate input cost (considering cache)
+        regular_input_tokens = input_tokens - cached_tokens
+        input_cost = (regular_input_tokens / 1000) * pricing.input_cost_per_1k
+
+        # Add cached token cost if applicable
+        if cached_tokens > 0 and pricing.cached_input_cost_per_1k is not None:
+            input_cost += (cached_tokens / 1000) * pricing.cached_input_cost_per_1k
+
+        # Calculate output cost
+        output_cost = (output_tokens / 1000) * pricing.output_cost_per_1k
+
+        total_cost = input_cost + output_cost
+
+        return input_cost, output_cost, total_cost
+
+    def estimate_cost(
+        self,
+        provider: str,
+        model: str,
+        input_tokens: int,
+        max_output_tokens: int = 4096,
+    ) -> float:
+        """Estimate maximum cost for a call (for budget reservation)."""
+        pricing = self.get_pricing(provider, model)
+
+        input_cost = (input_tokens / 1000) * pricing.input_cost_per_1k
+        output_cost = (max_output_tokens / 1000) * pricing.output_cost_per_1k
+
+        return input_cost + output_cost
+
+    @property
+    def last_updated(self) -> Optional[datetime]:
+        """Get when pricing was last loaded."""
+        return self._last_loaded
+
+    @property
+    def pricing_version(self) -> Dict[str, str]:
+        """Get pricing versions for all providers."""
+        return dict(self._pricing_versions)
+
+    @property
+    def is_stale(self) -> bool:
+        """Check if pricing data is stale (beyond warning threshold)."""
+        if self._last_loaded is None:
+            return True
+
+        age_days = (datetime.now() - self._last_loaded).days
+        return age_days >= self._stale_warning_days
+
+    @property
+    def is_very_stale(self) -> bool:
+        """Check if pricing data is very stale (beyond error threshold)."""
+        if self._last_loaded is None:
+            return True
+
+        age_days = (datetime.now() - self._last_loaded).days
+        return age_days >= self._stale_error_days
+
+    def get_all_models(self, provider: Optional[str] = None) -> Dict[str, list[str]]:
+        """Get all known models, optionally filtered by provider."""
+        if provider:
+            return {provider: list(self._pricing_data.get(provider, {}).keys())}
+        return {p: list(models.keys()) for p, models in self._pricing_data.items()}
+
+    def refresh(self) -> None:
+        """Reload pricing data from files."""
+        self._pricing_data.clear()
+        self._pricing_versions.clear()
+        self._load_all_pricing()
+
+
+# Global pricing loader instance
+_global_loader: Optional[PricingLoader] = None
+
+
+def get_pricing(provider: str, model: str) -> ModelPricing:
+    """Get pricing for a model using the global loader."""
+    global _global_loader
+    if _global_loader is None:
+        _global_loader = PricingLoader()
+    return _global_loader.get_pricing(provider, model)
+
+
+def get_pricing_loader() -> PricingLoader:
+    """Get the global pricing loader instance."""
+    global _global_loader
+    if _global_loader is None:
+        _global_loader = PricingLoader()
+    return _global_loader

llm_cost_guard/pricing/openai.yaml

@@ -0,0 +1,148 @@
+version: "2026-01-15"
+models:
+  # GPT-4o models
+  gpt-4o:
+    input_cost_per_1k: 0.0025
+    output_cost_per_1k: 0.01
+    cached_input_cost_per_1k: 0.00125
+    context_window: 128000
+    model_type: chat
+
+  gpt-4o-2024-11-20:
+    input_cost_per_1k: 0.0025
+    output_cost_per_1k: 0.01
+    cached_input_cost_per_1k: 0.00125
+    context_window: 128000
+    model_type: chat
+
+  gpt-4o-mini:
+    input_cost_per_1k: 0.00015
+    output_cost_per_1k: 0.0006
+    cached_input_cost_per_1k: 0.000075
+    context_window: 128000
+    model_type: chat
+
+  gpt-4o-mini-2024-07-18:
+    input_cost_per_1k: 0.00015
+    output_cost_per_1k: 0.0006
+    cached_input_cost_per_1k: 0.000075
+    context_window: 128000
+    model_type: chat
+
+  # GPT-4 Turbo
+  gpt-4-turbo:
+    input_cost_per_1k: 0.01
+    output_cost_per_1k: 0.03
+    context_window: 128000
+    model_type: chat
+
+  gpt-4-turbo-preview:
+    input_cost_per_1k: 0.01
+    output_cost_per_1k: 0.03
+    context_window: 128000
+    model_type: chat
+
+  # GPT-4
+  gpt-4:
+    input_cost_per_1k: 0.03
+    output_cost_per_1k: 0.06
+    context_window: 8192
+    model_type: chat
+
+  gpt-4-32k:
+    input_cost_per_1k: 0.06
+    output_cost_per_1k: 0.12
+    context_window: 32768
+    model_type: chat
+
+  # GPT-3.5 Turbo
+  gpt-3.5-turbo:
+    input_cost_per_1k: 0.0005
+    output_cost_per_1k: 0.0015
+    context_window: 16385
+    model_type: chat
+
+  gpt-3.5-turbo-0125:
+    input_cost_per_1k: 0.0005
+    output_cost_per_1k: 0.0015
+    context_window: 16385
+    model_type: chat
+
+  gpt-3.5-turbo-instruct:
+    input_cost_per_1k: 0.0015
+    output_cost_per_1k: 0.002
+    context_window: 4096
+    model_type: completion
+
+  # o1 reasoning models
+  o1:
+    input_cost_per_1k: 0.015
+    output_cost_per_1k: 0.06
+    cached_input_cost_per_1k: 0.0075
+    context_window: 200000
+    model_type: chat
+
+  o1-preview:
+    input_cost_per_1k: 0.015
+    output_cost_per_1k: 0.06
+    context_window: 128000
+    model_type: chat
+
+  o1-mini:
+    input_cost_per_1k: 0.003
+    output_cost_per_1k: 0.012
+    cached_input_cost_per_1k: 0.0015
+    context_window: 128000
+    model_type: chat
+
+  # Embedding models
+  text-embedding-3-small:
+    input_cost_per_1k: 0.00002
+    output_cost_per_1k: 0.0
+    context_window: 8191
+    model_type: embedding
+    embedding_dimensions: 1536
+
+  text-embedding-3-large:
+    input_cost_per_1k: 0.00013
+    output_cost_per_1k: 0.0
+    context_window: 8191
+    model_type: embedding
+    embedding_dimensions: 3072
+
+  text-embedding-ada-002:
+    input_cost_per_1k: 0.0001
+    output_cost_per_1k: 0.0
+    context_window: 8191
+    model_type: embedding
+    embedding_dimensions: 1536
+
+  # Image models (DALL-E)
+  dall-e-3:
+    input_cost_per_1k: 0.0
+    output_cost_per_1k: 0.0
+    image_cost_per_image: 0.04  # standard quality 1024x1024
+    model_type: image
+
+  dall-e-2:
+    input_cost_per_1k: 0.0
+    output_cost_per_1k: 0.0
+    image_cost_per_image: 0.02
+    model_type: image
+
+  # Audio models
+  whisper-1:
+    input_cost_per_1k: 0.0
+    output_cost_per_1k: 0.0
+    audio_cost_per_minute: 0.006
+    model_type: audio
+
+  tts-1:
+    input_cost_per_1k: 0.015
+    output_cost_per_1k: 0.0
+    model_type: audio
+
+  tts-1-hd:
+    input_cost_per_1k: 0.03
+    output_cost_per_1k: 0.0
+    model_type: audio

llm_cost_guard/pricing/vertex.yaml

@@ -0,0 +1,133 @@
+version: "2026-01-15"
+# Google Vertex AI / Gemini pricing
+models:
+  # Gemini 1.5 Pro
+  gemini-1.5-pro:
+    input_cost_per_1k: 0.00125
+    output_cost_per_1k: 0.005
+    context_window: 2000000
+    model_type: chat
+
+  gemini-1.5-pro-001:
+    input_cost_per_1k: 0.00125
+    output_cost_per_1k: 0.005
+    context_window: 2000000
+    model_type: chat
+
+  gemini-1.5-pro-002:
+    input_cost_per_1k: 0.00125
+    output_cost_per_1k: 0.005
+    context_window: 2000000
+    model_type: chat
+
+  # Gemini 1.5 Flash
+  gemini-1.5-flash:
+    input_cost_per_1k: 0.000075
+    output_cost_per_1k: 0.0003
+    context_window: 1000000
+    model_type: chat
+
+  gemini-1.5-flash-001:
+    input_cost_per_1k: 0.000075
+    output_cost_per_1k: 0.0003
+    context_window: 1000000
+    model_type: chat
+
+  gemini-1.5-flash-002:
+    input_cost_per_1k: 0.000075
+    output_cost_per_1k: 0.0003
+    context_window: 1000000
+    model_type: chat
+
+  # Gemini 1.0 Pro
+  gemini-1.0-pro:
+    input_cost_per_1k: 0.0005
+    output_cost_per_1k: 0.0015
+    context_window: 32760
+    model_type: chat
+
+  gemini-1.0-pro-001:
+    input_cost_per_1k: 0.0005
+    output_cost_per_1k: 0.0015
+    context_window: 32760
+    model_type: chat
+
+  gemini-1.0-pro-002:
+    input_cost_per_1k: 0.0005
+    output_cost_per_1k: 0.0015
+    context_window: 32760
+    model_type: chat
+
+  # Gemini 2.0 Flash
+  gemini-2.0-flash-exp:
+    input_cost_per_1k: 0.0
+    output_cost_per_1k: 0.0
+    context_window: 1000000
+    model_type: chat
+
+  # PaLM 2 (legacy)
+  text-bison:
+    input_cost_per_1k: 0.00025
+    output_cost_per_1k: 0.0005
+    context_window: 8192
+    model_type: chat
+
+  text-bison-32k:
+    input_cost_per_1k: 0.00025
+    output_cost_per_1k: 0.0005
+    context_window: 32000
+    model_type: chat
+
+  chat-bison:
+    input_cost_per_1k: 0.00025
+    output_cost_per_1k: 0.0005
+    context_window: 8192
+    model_type: chat
+
+  chat-bison-32k:
+    input_cost_per_1k: 0.00025
+    output_cost_per_1k: 0.0005
+    context_window: 32000
+    model_type: chat
+
+  # Embeddings
+  textembedding-gecko:
+    input_cost_per_1k: 0.00001
+    output_cost_per_1k: 0.0
+    context_window: 3072
+    model_type: embedding
+    embedding_dimensions: 768
+
+  textembedding-gecko-multilingual:
+    input_cost_per_1k: 0.00001
+    output_cost_per_1k: 0.0
+    context_window: 3072
+    model_type: embedding
+    embedding_dimensions: 768
+
+  text-embedding-004:
+    input_cost_per_1k: 0.00001
+    output_cost_per_1k: 0.0
+    context_window: 2048
+    model_type: embedding
+    embedding_dimensions: 768
+
+  text-multilingual-embedding-002:
+    input_cost_per_1k: 0.00001
+    output_cost_per_1k: 0.0
+    context_window: 2048
+    model_type: embedding
+    embedding_dimensions: 768
+
+  # Image models
+  imagen-3.0-generate-001:
+    input_cost_per_1k: 0.0
+    output_cost_per_1k: 0.0
+    image_cost_per_image: 0.04
+    model_type: image
+
+  imagen-3.0-fast-generate-001:
+    input_cost_per_1k: 0.0
+    output_cost_per_1k: 0.0
+    image_cost_per_image: 0.02
+    model_type: image

llm_cost_guard/providers/__init__.py

@@ -0,0 +1,69 @@
+"""
+LLM provider integrations for LLM Cost Guard.
+"""
+
+from llm_cost_guard.providers.base import Provider
+from llm_cost_guard.providers.openai import OpenAIProvider
+from llm_cost_guard.providers.anthropic import AnthropicProvider
+from llm_cost_guard.providers.bedrock import BedrockProvider
+
+__all__ = [
+    "Provider",
+    "OpenAIProvider",
+    "AnthropicProvider",
+    "BedrockProvider",
+    "get_provider",
+    "detect_provider",
+]
+
+
+def get_provider(name: str) -> Provider:
+    """Get a provider by name."""
+    providers = {
+        "openai": OpenAIProvider,
+        "anthropic": AnthropicProvider,
+        "bedrock": BedrockProvider,
+    }
+
+    name = name.lower()
+    if name not in providers:
+        raise ValueError(f"Unknown provider: {name}. Available: {list(providers.keys())}")
+
+    return providers[name]()
+
+
+def detect_provider(model: str) -> str:
+    """Detect the provider from a model name."""
+    model_lower = model.lower()
+
+    # OpenAI models
+    if any(
+        prefix in model_lower
+        for prefix in ["gpt-", "o1", "text-embedding", "dall-e", "whisper", "tts-"]
+    ):
+        return "openai"
+
+    # Anthropic models
+    if "claude" in model_lower and not model_lower.startswith("anthropic."):
+        return "anthropic"
+
+    # AWS Bedrock models (have provider prefix)
+    if any(
+        model_lower.startswith(prefix)
+        for prefix in [
+            "anthropic.",
+            "amazon.",
+            "meta.",
+            "mistral.",
+            "cohere.",
+            "ai21.",
+        ]
+    ):
+        return "bedrock"
+
+    # Google Vertex AI
+    if any(prefix in model_lower for prefix in ["gemini", "palm", "text-bison", "chat-bison"]):
+        return "vertex"
+
+    # Default to OpenAI
+    return "openai"

llm_cost_guard/providers/anthropic.py

@@ -0,0 +1,115 @@
+"""
+Anthropic provider for LLM Cost Guard.
+"""
+
+from typing import Any
+
+from llm_cost_guard.models import UsageData
+from llm_cost_guard.providers.base import Provider
+
+
+class AnthropicProvider(Provider):
+    """Anthropic API provider."""
+
+    @property
+    def name(self) -> str:
+        return "anthropic"
+
+    def extract_usage(self, response: Any) -> UsageData:
+        """Extract token usage from an Anthropic API response."""
+        usage = UsageData()
+
+        # Handle dictionary response
+        if isinstance(response, dict):
+            usage_data = response.get("usage", {})
+            usage.input_tokens = usage_data.get("input_tokens", 0)
+            usage.output_tokens = usage_data.get("output_tokens", 0)
+
+            # Check for cached tokens
+            usage.cached_tokens = usage_data.get("cache_read_input_tokens", 0)
+            cache_creation = usage_data.get("cache_creation_input_tokens", 0)
+
+            # Total tokens
+            usage.total_tokens = usage.input_tokens + usage.output_tokens
+
+            return usage
+
+        # Handle Anthropic client response object
+        if hasattr(response, "usage") and response.usage is not None:
+            usage.input_tokens = getattr(response.usage, "input_tokens", 0) or 0
+            usage.output_tokens = getattr(response.usage, "output_tokens", 0) or 0
+
+            # Anthropic prompt caching
+            if hasattr(response.usage, "cache_read_input_tokens"):
+                usage.cached_tokens = response.usage.cache_read_input_tokens or 0
+
+            usage.total_tokens = usage.input_tokens + usage.output_tokens
+
+        return usage
+
+    def extract_model(self, response: Any) -> str:
+        """Extract the model name from an Anthropic API response."""
+        if isinstance(response, dict):
+            return response.get("model", "unknown")
+
+        if hasattr(response, "model"):
+            return response.model or "unknown"
+
+        return "unknown"
+
+    def extract_cached_tokens(self, response: Any) -> int:
+        """Extract cached token count from an Anthropic API response."""
+        usage = self.extract_usage(response)
+        return usage.cached_tokens
+
+    def normalize_model_name(self, model: str) -> str:
+        """Normalize Anthropic model name."""
+        # Anthropic model names are usually already normalized
+        return model
+
+
+class AnthropicStreamingHandler:
+    """Handler for streaming Anthropic responses."""
+
+    def __init__(self):
+        self.input_tokens = 0
+        self.output_tokens = 0
+        self.model = "unknown"
+        self._started = False
+
+    def handle_event(self, event: Any) -> None:
+        """Process a streaming event."""
+        if isinstance(event, dict):
+            event_type = event.get("type", "")
+
+            if event_type == "message_start":
+                message = event.get("message", {})
+                self.model = message.get("model", self.model)
+                usage = message.get("usage", {})
+                self.input_tokens = usage.get("input_tokens", 0)
+
+            elif event_type == "message_delta":
+                usage = event.get("usage", {})
+                self.output_tokens = usage.get("output_tokens", 0)
+
+        else:
+            # Handle event objects
+            event_type = getattr(event, "type", "")
+
+            if event_type == "message_start":
+                if hasattr(event, "message"):
+                    self.model = getattr(event.message, "model", self.model)
+                    if hasattr(event.message, "usage"):
+                        self.input_tokens = getattr(event.message.usage, "input_tokens", 0)
+
+            elif event_type == "message_delta":
+                if hasattr(event, "usage"):
+                    self.output_tokens = getattr(event.usage, "output_tokens", 0)
+
+    def get_usage(self) -> UsageData:
+        """Get final usage data."""
+        return UsageData(
+            input_tokens=self.input_tokens,
+            output_tokens=self.output_tokens,
+            total_tokens=self.input_tokens + self.output_tokens,
+        )