llm-costs 0.1.0__tar.gz

llm_costs-0.1.0/.gitignore

@@ -0,0 +1,16 @@
+# Python-generated files
+__pycache__/
+*.py[cod]
+*$py.class
+build/
+dist/
+wheels/
+*.egg-info/
+
+# Virtual environments
+.venv/
+
+# Testing/tooling
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/

llm_costs-0.1.0/.python-version

@@ -0,0 +1 @@
+3.13.0

llm_costs-0.1.0/PKG-INFO

@@ -0,0 +1,201 @@
+Metadata-Version: 2.4
+Name: llm-costs
+Version: 0.1.0
+Summary: LLM cost calculator for major providers
+Author-email: jason <jtan92@gmail.com>
+Requires-Python: >=3.13
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.8; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# llm-costs
+
+LLM cost calculator for major providers. Calculates API costs from token usage data.
+
+## Installation
+
+```bash
+pip install llm-costs
+```
+
+Or with uv:
+
+```bash
+uv add llm-costs
+```
+
+## Usage
+
+```python
+from llm_costs import calculate_cost, get_model_pricing
+
+# Calculate cost from LangChain UsageMetadata structure
+result = calculate_cost(
+    provider="anthropic",
+    model="claude-sonnet-4-20250514",
+    usage={
+        "input_tokens": 1000,
+        "output_tokens": 500,
+        "total_tokens": 1500,
+    },
+)
+
+print(f"Cost: ${result['cost']:.6f}")  # Cost: $0.010500
+print(f"Input: ${result['breakdown']['input_cost']:.6f}")
+print(f"Output: ${result['breakdown']['output_cost']:.6f}")
+```
+
+### With Prompt Caching
+
+```python
+result = calculate_cost(
+    provider="anthropic",
+    model="claude-sonnet-4-20250514",
+    usage={
+        "input_tokens": 1000,
+        "output_tokens": 500,
+        "total_tokens": 1500,
+        "input_token_details": {
+            "cache_read": 5000,
+            "cache_creation": 0,
+        },
+    },
+)
+```
+
+### Batch Pricing
+
+```python
+result = calculate_cost(
+    provider="anthropic",
+    model="claude-sonnet-4-20250514",
+    usage={"input_tokens": 1000, "output_tokens": 500, "total_tokens": 1500},
+    batch=True,  # 50% discount
+)
+```
+
+### Get Model Pricing Info
+
+```python
+pricing = get_model_pricing("anthropic", "claude-sonnet-4-20250514")
+print(f"Input: ${pricing['input']}/MTok")   # Input: $3.0/MTok
+print(f"Output: ${pricing['output']}/MTok") # Output: $15.0/MTok
+```
+
+### List Available Models
+
+```python
+from llm_costs.calculator import list_models, list_providers
+
+providers = list_providers()  # ['anthropic', 'openai', 'google']
+models = list_models("anthropic")  # ['claude-opus-4-5-20251101', ...]
+```
+
+## Supported Providers
+
+### Anthropic
+
+| Model | Input | Output | Cache Read |
+|-------|-------|--------|------------|
+| claude-opus-4-5-20251101 | $5.00 | $25.00 | $0.50 |
+| claude-opus-4-1-20250414 | $15.00 | $75.00 | $1.50 |
+| claude-opus-4-20250514 | $15.00 | $75.00 | $1.50 |
+| claude-sonnet-4-5-20250514 | $3.00 | $15.00 | $0.30 |
+| claude-sonnet-4-20250514 | $3.00 | $15.00 | $0.30 |
+| claude-3-7-sonnet-20250219 | $3.00 | $15.00 | $0.30 |
+| claude-haiku-4-5-20250514 | $1.00 | $5.00 | $0.10 |
+| claude-3-5-haiku-20241022 | $0.80 | $4.00 | $0.08 |
+| claude-3-opus-20240229 | $15.00 | $75.00 | $1.50 |
+| claude-3-haiku-20240307 | $0.25 | $1.25 | $0.03 |
+
+Prices per million tokens. Long context pricing (>200K tokens) applies to Sonnet models.
+
+### OpenAI
+
+| Model | Input | Output | Cache Read |
+|-------|-------|--------|------------|
+| gpt-5.2 | $1.75 | $14.00 | $0.175 |
+| gpt-5.1 | $1.25 | $10.00 | $0.125 |
+| gpt-5 | $1.25 | $10.00 | $0.125 |
+| gpt-5-mini | $0.25 | $2.00 | $0.025 |
+| gpt-5-nano | $0.05 | $0.40 | $0.005 |
+| gpt-5.2-pro | $21.00 | $168.00 | - |
+| gpt-5-pro | $15.00 | $120.00 | - |
+| gpt-4.1 | $2.00 | $8.00 | $0.50 |
+| gpt-4.1-mini | $0.40 | $1.60 | $0.10 |
+| gpt-4.1-nano | $0.10 | $0.40 | $0.025 |
+| gpt-4o | $2.50 | $10.00 | $1.25 |
+| gpt-4o-mini | $0.15 | $0.60 | $0.075 |
+| o1 | $15.00 | $60.00 | $7.50 |
+| o1-pro | $150.00 | $600.00 | - |
+| o1-mini | $1.10 | $4.40 | $0.55 |
+| o3 | $2.00 | $8.00 | $0.50 |
+| o3-pro | $20.00 | $80.00 | - |
+| o3-mini | $1.10 | $4.40 | $0.55 |
+| o3-deep-research | $10.00 | $40.00 | $2.50 |
+| o4-mini | $1.10 | $4.40 | $0.275 |
+| o4-mini-deep-research | $2.00 | $8.00 | $0.50 |
+| computer-use-preview | $3.00 | $12.00 | - |
+
+Prices per million tokens (Standard tier).
+
+### Google
+
+| Model | Input | Output | Cache Read |
+|-------|-------|--------|------------|
+| gemini-3-pro-preview | $2.00 | $12.00 | $0.20 |
+| gemini-2.5-pro | $1.25 | $10.00 | $0.125 |
+| gemini-2.5-flash | $0.30 | $2.50 | $0.03 |
+| gemini-2.5-flash-lite | $0.10 | $0.40 | $0.01 |
+| gemini-2.0-flash | $0.10 | $0.40 | $0.025 |
+| gemini-2.0-flash-lite | $0.075 | $0.30 | - |
+
+Prices per million tokens (Paid tier). Long context pricing (>200K tokens) applies to Pro models.
+
+## Usage Schema
+
+The library accepts token usage in LangChain's `UsageMetadata` format:
+
+```python
+{
+    "input_tokens": int,
+    "output_tokens": int,
+    "total_tokens": int,
+    "input_token_details": {
+        "cache_read": int,      # Cached tokens read
+        "cache_creation": int,  # Tokens written to cache
+    },
+    "output_token_details": {
+        "reasoning": int,       # Reasoning tokens (o1/thinking models)
+    },
+}
+```
+
+## Return Value
+
+`calculate_cost()` returns a `CostResult`:
+
+```python
+{
+    "cost": 0.0105,           # Total cost in USD
+    "currency": "USD",
+    "breakdown": {
+        "input_cost": 0.003,
+        "output_cost": 0.0075,
+        "cache_read_cost": 0.0,      # If applicable
+        "cache_creation_cost": 0.0,  # If applicable
+    },
+    "pricing_used": {
+        "input_per_mtok": 3.0,
+        "output_per_mtok": 15.0,
+        "batch_applied": False,
+        "long_context_applied": False,
+    },
+}
+```
+
+## License
+
+MIT

llm_costs-0.1.0/README.md

@@ -0,0 +1,189 @@
+# llm-costs
+
+LLM cost calculator for major providers. Calculates API costs from token usage data.
+
+## Installation
+
+```bash
+pip install llm-costs
+```
+
+Or with uv:
+
+```bash
+uv add llm-costs
+```
+
+## Usage
+
+```python
+from llm_costs import calculate_cost, get_model_pricing
+
+# Calculate cost from LangChain UsageMetadata structure
+result = calculate_cost(
+    provider="anthropic",
+    model="claude-sonnet-4-20250514",
+    usage={
+        "input_tokens": 1000,
+        "output_tokens": 500,
+        "total_tokens": 1500,
+    },
+)
+
+print(f"Cost: ${result['cost']:.6f}")  # Cost: $0.010500
+print(f"Input: ${result['breakdown']['input_cost']:.6f}")
+print(f"Output: ${result['breakdown']['output_cost']:.6f}")
+```
+
+### With Prompt Caching
+
+```python
+result = calculate_cost(
+    provider="anthropic",
+    model="claude-sonnet-4-20250514",
+    usage={
+        "input_tokens": 1000,
+        "output_tokens": 500,
+        "total_tokens": 1500,
+        "input_token_details": {
+            "cache_read": 5000,
+            "cache_creation": 0,
+        },
+    },
+)
+```
+
+### Batch Pricing
+
+```python
+result = calculate_cost(
+    provider="anthropic",
+    model="claude-sonnet-4-20250514",
+    usage={"input_tokens": 1000, "output_tokens": 500, "total_tokens": 1500},
+    batch=True,  # 50% discount
+)
+```
+
+### Get Model Pricing Info
+
+```python
+pricing = get_model_pricing("anthropic", "claude-sonnet-4-20250514")
+print(f"Input: ${pricing['input']}/MTok")   # Input: $3.0/MTok
+print(f"Output: ${pricing['output']}/MTok") # Output: $15.0/MTok
+```
+
+### List Available Models
+
+```python
+from llm_costs.calculator import list_models, list_providers
+
+providers = list_providers()  # ['anthropic', 'openai', 'google']
+models = list_models("anthropic")  # ['claude-opus-4-5-20251101', ...]
+```
+
+## Supported Providers
+
+### Anthropic
+
+| Model | Input | Output | Cache Read |
+|-------|-------|--------|------------|
+| claude-opus-4-5-20251101 | $5.00 | $25.00 | $0.50 |
+| claude-opus-4-1-20250414 | $15.00 | $75.00 | $1.50 |
+| claude-opus-4-20250514 | $15.00 | $75.00 | $1.50 |
+| claude-sonnet-4-5-20250514 | $3.00 | $15.00 | $0.30 |
+| claude-sonnet-4-20250514 | $3.00 | $15.00 | $0.30 |
+| claude-3-7-sonnet-20250219 | $3.00 | $15.00 | $0.30 |
+| claude-haiku-4-5-20250514 | $1.00 | $5.00 | $0.10 |
+| claude-3-5-haiku-20241022 | $0.80 | $4.00 | $0.08 |
+| claude-3-opus-20240229 | $15.00 | $75.00 | $1.50 |
+| claude-3-haiku-20240307 | $0.25 | $1.25 | $0.03 |
+
+Prices per million tokens. Long context pricing (>200K tokens) applies to Sonnet models.
+
+### OpenAI
+
+| Model | Input | Output | Cache Read |
+|-------|-------|--------|------------|
+| gpt-5.2 | $1.75 | $14.00 | $0.175 |
+| gpt-5.1 | $1.25 | $10.00 | $0.125 |
+| gpt-5 | $1.25 | $10.00 | $0.125 |
+| gpt-5-mini | $0.25 | $2.00 | $0.025 |
+| gpt-5-nano | $0.05 | $0.40 | $0.005 |
+| gpt-5.2-pro | $21.00 | $168.00 | - |
+| gpt-5-pro | $15.00 | $120.00 | - |
+| gpt-4.1 | $2.00 | $8.00 | $0.50 |
+| gpt-4.1-mini | $0.40 | $1.60 | $0.10 |
+| gpt-4.1-nano | $0.10 | $0.40 | $0.025 |
+| gpt-4o | $2.50 | $10.00 | $1.25 |
+| gpt-4o-mini | $0.15 | $0.60 | $0.075 |
+| o1 | $15.00 | $60.00 | $7.50 |
+| o1-pro | $150.00 | $600.00 | - |
+| o1-mini | $1.10 | $4.40 | $0.55 |
+| o3 | $2.00 | $8.00 | $0.50 |
+| o3-pro | $20.00 | $80.00 | - |
+| o3-mini | $1.10 | $4.40 | $0.55 |
+| o3-deep-research | $10.00 | $40.00 | $2.50 |
+| o4-mini | $1.10 | $4.40 | $0.275 |
+| o4-mini-deep-research | $2.00 | $8.00 | $0.50 |
+| computer-use-preview | $3.00 | $12.00 | - |
+
+Prices per million tokens (Standard tier).
+
+### Google
+
+| Model | Input | Output | Cache Read |
+|-------|-------|--------|------------|
+| gemini-3-pro-preview | $2.00 | $12.00 | $0.20 |
+| gemini-2.5-pro | $1.25 | $10.00 | $0.125 |
+| gemini-2.5-flash | $0.30 | $2.50 | $0.03 |
+| gemini-2.5-flash-lite | $0.10 | $0.40 | $0.01 |
+| gemini-2.0-flash | $0.10 | $0.40 | $0.025 |
+| gemini-2.0-flash-lite | $0.075 | $0.30 | - |
+
+Prices per million tokens (Paid tier). Long context pricing (>200K tokens) applies to Pro models.
+
+## Usage Schema
+
+The library accepts token usage in LangChain's `UsageMetadata` format:
+
+```python
+{
+    "input_tokens": int,
+    "output_tokens": int,
+    "total_tokens": int,
+    "input_token_details": {
+        "cache_read": int,      # Cached tokens read
+        "cache_creation": int,  # Tokens written to cache
+    },
+    "output_token_details": {
+        "reasoning": int,       # Reasoning tokens (o1/thinking models)
+    },
+}
+```
+
+## Return Value
+
+`calculate_cost()` returns a `CostResult`:
+
+```python
+{
+    "cost": 0.0105,           # Total cost in USD
+    "currency": "USD",
+    "breakdown": {
+        "input_cost": 0.003,
+        "output_cost": 0.0075,
+        "cache_read_cost": 0.0,      # If applicable
+        "cache_creation_cost": 0.0,  # If applicable
+    },
+    "pricing_used": {
+        "input_per_mtok": 3.0,
+        "output_per_mtok": 15.0,
+        "batch_applied": False,
+        "long_context_applied": False,
+    },
+}
+```
+
+## License
+
+MIT

llm_costs-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[project]
+name = "llm-costs"
+version = "0.1.0"
+description = "LLM cost calculator for major providers"
+authors = [
+  { name="jason", email="jtan92@gmail.com" },
+]
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "pyyaml>=6.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "ruff>=0.8",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/llm_costs"]
+
+[tool.ruff]
+target-version = "py313"
+line-length = 100
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP"]

llm_costs-0.1.0/src/llm_costs/__init__.py

@@ -0,0 +1,5 @@
+"""LLM cost calculator for major providers."""
+
+from llm_costs.calculator import calculate_cost, get_model_pricing
+
+__all__ = ["calculate_cost", "get_model_pricing"]

llm_costs-0.1.0/src/llm_costs/calculator.py

@@ -0,0 +1,176 @@
+"""Main cost calculation API."""
+
+from pathlib import Path
+
+import yaml
+
+from llm_costs.models import CostResult
+from llm_costs.providers.anthropic import calculate_anthropic_cost
+from llm_costs.providers.google import calculate_google_cost
+from llm_costs.providers.openai import calculate_openai_cost
+
+# Cache for loaded pricing configs
+_pricing_cache: dict[str, dict] = {}
+
+# Provider to calculator function mapping
+_PROVIDER_CALCULATORS = {
+    "anthropic": calculate_anthropic_cost,
+    "openai": calculate_openai_cost,
+    "google": calculate_google_cost,
+}
+
+
+def _get_pricing_dir() -> Path:
+    """Get the directory containing pricing YAML files."""
+    return Path(__file__).parent / "pricing"
+
+
+def _load_pricing(provider: str) -> dict:
+    """Load pricing config for a provider, with caching."""
+    if provider in _pricing_cache:
+        return _pricing_cache[provider]
+
+    pricing_file = _get_pricing_dir() / f"{provider}.yaml"
+    if not pricing_file.exists():
+        raise ValueError(f"No pricing data for provider: {provider}")
+
+    with open(pricing_file) as f:
+        pricing = yaml.safe_load(f)
+
+    _pricing_cache[provider] = pricing
+    return pricing
+
+
+def calculate_cost(
+    provider: str,
+    model: str,
+    usage: dict,
+    batch: bool = False,
+    long_context: bool | None = None,
+) -> CostResult:
+    """
+    Calculate cost for an LLM API call.
+
+    Args:
+        provider: Provider name ("anthropic", "openai", "google")
+        model: Model name (e.g., "claude-sonnet-4-20250514", "gpt-4o")
+        usage: Token usage in LangChain UsageMetadata format:
+            {
+                "input_tokens": int,
+                "output_tokens": int,
+                "total_tokens": int,
+                "input_token_details": {
+                    "cache_read": int,      # Cached input tokens read
+                    "cache_creation": int,  # Tokens written to cache
+                },
+                "output_token_details": {
+                    "reasoning": int,       # Reasoning tokens (o1/thinking models)
+                },
+            }
+        batch: Whether batch API pricing applies (typically 50% discount)
+        long_context: Force long context pricing. Auto-detected if None based on
+            total input tokens exceeding provider threshold (typically 200K).
+
+    Returns:
+        CostResult with total cost, breakdown, and pricing info used.
+
+    Raises:
+        ValueError: If provider or model is unknown.
+
+    Example:
+        >>> result = calculate_cost(
+        ...     provider="anthropic",
+        ...     model="claude-sonnet-4-20250514",
+        ...     usage={
+        ...         "input_tokens": 1000,
+        ...         "output_tokens": 500,
+        ...         "total_tokens": 1500,
+        ...     },
+        ... )
+        >>> print(f"Cost: ${result['cost']:.6f}")
+        Cost: $0.010500
+    """
+    provider = provider.lower()
+
+    if provider not in _PROVIDER_CALCULATORS:
+        raise ValueError(f"Unknown provider: {provider}. Supported: {list(_PROVIDER_CALCULATORS)}")
+
+    pricing = _load_pricing(provider)
+    calculator = _PROVIDER_CALCULATORS[provider]
+
+    # Build kwargs - not all providers support all options
+    kwargs: dict = {
+        "model": model,
+        "usage": usage,
+        "pricing": pricing,
+        "batch": batch,
+    }
+
+    # Only pass long_context to providers that support it
+    if provider in ("anthropic", "google"):
+        kwargs["long_context"] = long_context
+
+    return calculator(**kwargs)
+
+
+def get_model_pricing(provider: str, model: str) -> dict | None:
+    """
+    Get pricing info for a specific model.
+
+    Args:
+        provider: Provider name ("anthropic", "openai", "google")
+        model: Model name or alias
+
+    Returns:
+        Model pricing config dict, or None if not found.
+
+    Example:
+        >>> pricing = get_model_pricing("anthropic", "claude-sonnet-4-20250514")
+        >>> print(f"Input: ${pricing['input']}/MTok")
+        Input: $3.0/MTok
+    """
+    provider = provider.lower()
+
+    try:
+        pricing = _load_pricing(provider)
+    except ValueError:
+        return None
+
+    models = pricing.get("models", {})
+
+    # Direct match
+    if model in models:
+        return models[model]
+
+    # Check aliases
+    for model_config in models.values():
+        aliases = model_config.get("aliases", [])
+        if model in aliases:
+            return model_config
+
+    return None
+
+
+def list_models(provider: str) -> list[str]:
+    """
+    List all known models for a provider.
+
+    Args:
+        provider: Provider name
+
+    Returns:
+        List of model names (primary names, not aliases)
+    """
+    provider = provider.lower()
+
+    try:
+        pricing = _load_pricing(provider)
+    except ValueError:
+        return []
+
+    return list(pricing.get("models", {}).keys())
+
+
+def list_providers() -> list[str]:
+    """List all supported providers."""
+    return list(_PROVIDER_CALCULATORS.keys())

llm_costs-0.1.0/src/llm_costs/models.py

@@ -0,0 +1,22 @@
+"""Type definitions for LLM cost calculation."""
+
+from typing import NotRequired, TypedDict
+
+
+class CostBreakdown(TypedDict):
+    """Itemized cost breakdown."""
+
+    input_cost: float
+    output_cost: float
+    cache_read_cost: NotRequired[float]
+    cache_creation_cost: NotRequired[float]
+    reasoning_cost: NotRequired[float]
+
+
+class CostResult(TypedDict):
+    """Result from calculate_cost()."""
+
+    cost: float
+    currency: str
+    breakdown: CostBreakdown
+    pricing_used: dict[str, float | bool]