Initial Commit 🚀 🚀

api/services/pricing/README.md

@@ -0,0 +1,76 @@
+# Pricing Module
+
+This module contains pricing models and registries for different AI services used in workflow cost calculations.
+
+## Structure
+
+```
+pricing/
+├── __init__.py           # Main module exports
+├── models.py            # Base pricing model classes
+├── llm.py              # LLM pricing configurations
+├── tts.py              # TTS pricing configurations  
+├── stt.py              # STT pricing configurations
+├── registry.py         # Combined pricing registry
+└── README.md           # This file
+```
+
+## Pricing Models
+
+### TokenPricingModel
+Used for LLM services that charge based on tokens:
+- `prompt_token_price`: Cost per prompt token
+- `completion_token_price`: Cost per completion token
+- `cache_read_discount`: Discount for cache read tokens (default 50%)
+- `cache_creation_multiplier`: Premium for cache creation tokens (default 25%)
+
+### CharacterPricingModel
+Used for TTS services that charge based on character count:
+- `character_price`: Cost per character
+
+### TimePricingModel
+Used for STT services that charge based on time:
+- `second_price`: Cost per second
+
+## Adding New Pricing
+
+### Adding a New LLM Model
+Edit `llm.py` and add the model to the appropriate provider:
+
+```python
+ServiceProviders.OPENAI: {
+    "new-model": TokenPricingModel(
+        prompt_token_price=Decimal("2.00") / 1000000,
+        completion_token_price=Decimal("8.00") / 1000000,
+    ),
+    # ... existing models
+}
+```
+
+### Adding a New Provider
+1. Add pricing configurations to the appropriate service file (llm.py, tts.py, stt.py)
+2. The registry will automatically include them
+
+### Adding a New Service Type
+1. Create a new pricing file (e.g., `image.py`)
+2. Define the pricing models
+3. Import and add to `registry.py`
+
+## Usage
+
+The pricing registry is automatically imported and used by the cost calculator:
+
+```python
+from api.services.pricing import PRICING_REGISTRY
+from api.services.workflow.cost_calculator import cost_calculator
+
+# The cost calculator uses the pricing registry automatically
+result = cost_calculator.calculate_total_cost(usage_info)
+```
+
+## Maintenance
+
+- Update pricing when providers change their rates
+- All prices should use `Decimal` for precision
+- Include comments with current pricing from provider documentation
+- Test changes with existing test suite 

api/services/pricing/__init__.py

@@ -0,0 +1,9 @@
+"""
+Pricing module for workflow cost calculation.
+
+This module contains pricing models and registries for different AI services.
+"""
+
+from .registry import PRICING_REGISTRY
+
+__all__ = ["PRICING_REGISTRY"]

api/services/pricing/cost_calculator.py

@@ -0,0 +1,228 @@
+"""
+Cost Calculator for Workflow Runs
+
+This module provides a comprehensive cost calculation system for workflow runs based on usage metrics
+from different AI service providers (OpenAI, Groq, Deepgram, etc.).
+
+Features:
+- Token-based pricing for LLM services with cache optimization support
+- Character-based pricing for TTS services
+- Time-based pricing for STT services
+- Configurable pricing models that can be updated
+- Support for multiple providers and models
+- Automatic provider inference from model names
+- JSON serialization support for database storage
+
+Usage:
+    from api.tasks.cost_calculator import cost_calculator
+
+    usage_info = {
+        "llm": {
+            "processor_name|||gpt-4o": {
+                "prompt_tokens": 1000,
+                "completion_tokens": 500,
+                "total_tokens": 1500,
+                "cache_read_input_tokens": 0,
+                "cache_creation_input_tokens": 0
+            }
+        },
+        "tts": {
+            "processor_name|||aura-2-helena-en": 2000  # character count
+        }
+    }
+
+    cost_breakdown = cost_calculator.calculate_total_cost(usage_info)
+    print(f"Total cost: ${cost_breakdown['total']:.6f}")
+"""
+
+from decimal import Decimal
+from typing import Any, Dict, Optional, Tuple
+
+from api.services.configuration.registry import ServiceProviders
+from api.services.pricing import PRICING_REGISTRY
+from api.services.pricing.models import (
+    PricingModel,
+)
+
+
+class CostCalculator:
+    """Main cost calculator class"""
+
+    def __init__(self, pricing_registry: Dict = None):
+        self.pricing_registry = pricing_registry or PRICING_REGISTRY
+
+    def get_pricing_model(
+        self, service_type: str, provider: str, model: str
+    ) -> Optional[PricingModel]:
+        """Get pricing model for a specific service, provider, and model"""
+        try:
+            service_pricing = self.pricing_registry.get(service_type, {})
+
+            # Try to get pricing for the specific provider
+            provider_pricing = service_pricing.get(provider, {})
+            pricing_model = provider_pricing.get(model) or provider_pricing.get(
+                "default"
+            )
+
+            if pricing_model:
+                return pricing_model
+
+            # If not found, try the "default" provider for this service type
+            default_provider_pricing = service_pricing.get("default", {})
+            return default_provider_pricing.get(model) or default_provider_pricing.get(
+                "default"
+            )
+
+        except (KeyError, AttributeError):
+            return None
+
+    def calculate_llm_cost(
+        self, provider: str, model: str, usage: Dict[str, int]
+    ) -> Decimal:
+        """Calculate cost for LLM usage"""
+        pricing_model = self.get_pricing_model("llm", provider, model)
+        if not pricing_model:
+            return Decimal("0")
+        return pricing_model.calculate_cost(usage)
+
+    def calculate_tts_cost(
+        self, provider: str, model: str, character_count: int
+    ) -> Decimal:
+        """Calculate cost for TTS usage"""
+        pricing_model = self.get_pricing_model("tts", provider, model)
+        if not pricing_model:
+            return Decimal("0")
+        return pricing_model.calculate_cost(character_count)
+
+    def calculate_stt_cost(self, provider: str, model: str, seconds: float) -> Decimal:
+        """Calculate cost for STT usage"""
+        pricing_model = self.get_pricing_model("stt", provider, model)
+        if not pricing_model:
+            return Decimal("0")
+        return pricing_model.calculate_cost(seconds)
+
+    def calculate_total_cost(self, usage_info: Dict) -> Dict[str, Any]:
+        llm_cost_total = Decimal("0")
+        tts_cost_total = Decimal("0")
+        stt_cost_total = Decimal("0")
+
+        # Calculate LLM costs
+        llm_usage = usage_info.get("llm", {})
+        for key, usage in llm_usage.items():
+            processor, model = self._parse_key(key)
+            # Try to determine provider from processor name or model
+            provider = self._infer_provider_from_model(model, "llm")
+            cost = self.calculate_llm_cost(provider, model, usage)
+            llm_cost_total += cost
+
+        # Calculate TTS costs
+        tts_usage = usage_info.get("tts", {})
+        for key, character_count in tts_usage.items():
+            processor, model = self._parse_key(key)
+            # Handle the case where model is "None" - infer from processor
+            if model.lower() in ["none", "null", ""]:
+                provider = self._infer_provider_from_processor(processor, "tts")
+                model = "default"  # Use default model for the provider
+            else:
+                provider = self._infer_provider_from_model(model, "tts")
+            cost = self.calculate_tts_cost(provider, model, character_count)
+            tts_cost_total += cost
+
+        # Calculate STT costs from explicit stt usage
+        stt_usage = usage_info.get("stt", {})
+        for key, seconds in stt_usage.items():
+            processor, model = self._parse_key(key)
+            provider = self._infer_provider_from_model(model, "stt")
+            cost = self.calculate_stt_cost(provider, model, seconds)
+            stt_cost_total += cost
+
+        total_cost = llm_cost_total + tts_cost_total + stt_cost_total
+
+        return {
+            "llm_cost": float(llm_cost_total),
+            "tts_cost": float(tts_cost_total),
+            "stt_cost": float(stt_cost_total),
+            "total": float(total_cost),
+        }
+
+    def _parse_key(self, key) -> Tuple[str, str]:
+        """Parse key which is in format 'processor|||model'"""
+        if isinstance(key, str) and "|||" in key:
+            parts = key.split("|||", 1)
+            return parts[0], parts[1]
+        else:
+            # Fallback for backwards compatibility or malformed keys
+            return str(key), "unknown"
+
+    def _infer_provider_from_model(self, model: str, service_type: str) -> str:
+        """Infer provider from model name"""
+        if not model:
+            return "unknown"
+
+        model_lower = model.lower()
+
+        # OpenAI models
+        if any(keyword in model_lower for keyword in ["gpt", "whisper", "openai"]):
+            return ServiceProviders.OPENAI
+
+        # Groq models
+        if any(keyword in model_lower for keyword in ["groq"]):
+            return ServiceProviders.GROQ
+
+        # Elevenlabs models
+        if any(keyword in model_lower for keyword in ["eleven"]):
+            return ServiceProviders.ELEVENLABS
+
+        # Deepgram models
+        if any(
+            keyword in model_lower
+            for keyword in ["deepgram", "nova", "phonecall", "general"]
+        ):
+            return ServiceProviders.DEEPGRAM
+
+        # Default to first available provider for the service type
+        service_providers = self.pricing_registry.get(service_type, {})
+        if service_providers:
+            return list(service_providers.keys())[0]
+
+        return "unknown"
+
+    def _infer_provider_from_processor(self, processor: str, service_type: str) -> str:
+        """Infer provider from processor name"""
+        if not processor:
+            return "unknown"
+
+        processor_lower = processor.lower()
+
+        # OpenAI processors
+        if any(keyword in processor_lower for keyword in ["openai", "gpt"]):
+            return ServiceProviders.OPENAI
+
+        # Groq processors
+        if any(keyword in processor_lower for keyword in ["groq"]):
+            return ServiceProviders.GROQ
+
+        # Deepgram processors
+        if any(keyword in processor_lower for keyword in ["deepgram"]):
+            return ServiceProviders.DEEPGRAM
+
+        # Default to first available provider for the service type
+        service_providers = self.pricing_registry.get(service_type, {})
+        if service_providers:
+            return list(service_providers.keys())[0]
+
+        return "unknown"
+
+    def update_pricing(
+        self, service_type: str, provider: str, model: str, pricing_model: PricingModel
+    ):
+        """Update pricing for a specific service/provider/model combination"""
+        if service_type not in self.pricing_registry:
+            self.pricing_registry[service_type] = {}
+        if provider not in self.pricing_registry[service_type]:
+            self.pricing_registry[service_type][provider] = {}
+        self.pricing_registry[service_type][provider][model] = pricing_model
+
+
+# Global cost calculator instance
+cost_calculator = CostCalculator()

api/services/pricing/llm.py

@@ -0,0 +1,143 @@
+"""
+LLM pricing models for different providers.
+
+Prices are per 1000 tokens for most models, with some newer models priced per million tokens.
+"""
+
+from decimal import Decimal
+from typing import Dict
+
+from api.services.configuration.registry import ServiceProviders
+
+from .models import TokenPricingModel
+
+# LLM pricing registry
+LLM_PRICING: Dict[str, Dict[str, TokenPricingModel]] = {
+    ServiceProviders.OPENAI: {
+        "gpt-3.5-turbo": TokenPricingModel(
+            prompt_token_price=Decimal("0.0015") / 1000,  # $0.0015 per 1K tokens
+            completion_token_price=Decimal("0.002") / 1000,  # $0.002 per 1K tokens
+        ),
+        "gpt-4": TokenPricingModel(
+            prompt_token_price=Decimal("0.03") / 1000,  # $0.03 per 1K tokens
+            completion_token_price=Decimal("0.06") / 1000,  # $0.06 per 1K tokens
+        ),
+        "gpt-4.1": TokenPricingModel(
+            prompt_token_price=Decimal("2.00") / 1000000,  # $2.00 per 1M tokens
+            completion_token_price=Decimal("8.00") / 1000000,  # $8.00 per 1M tokens
+        ),
+        "gpt-4.1-mini": TokenPricingModel(
+            prompt_token_price=Decimal("0.40") / 1000000,  # $0.40 per 1M tokens
+            completion_token_price=Decimal("1.60") / 1000000,  # $1.60 per 1M tokens
+        ),
+        "gpt-4.1-nano": TokenPricingModel(
+            prompt_token_price=Decimal("0.10") / 1000000,  # $0.10 per 1M tokens
+            completion_token_price=Decimal("0.40") / 1000000,  # $0.40 per 1M tokens
+        ),
+        "gpt-4.5-preview": TokenPricingModel(
+            prompt_token_price=Decimal("75.00") / 1000000,  # $75.00 per 1M tokens
+            completion_token_price=Decimal("150.00") / 1000000,  # $150.00 per 1M tokens
+        ),
+        "gpt-4o": TokenPricingModel(
+            prompt_token_price=Decimal("2.50") / 1000000,  # $2.50 per 1M tokens - FIXED
+            completion_token_price=Decimal("10.00")
+            / 1000000,  # $10.00 per 1M tokens - FIXED
+        ),
+        "gpt-4o-audio-preview": TokenPricingModel(
+            prompt_token_price=Decimal("2.50") / 1000000,  # $2.50 per 1M tokens
+            completion_token_price=Decimal("10.00") / 1000000,  # $10.00 per 1M tokens
+        ),
+        "gpt-4o-realtime-preview": TokenPricingModel(
+            prompt_token_price=Decimal("5.00") / 1000000,  # $5.00 per 1M tokens
+            completion_token_price=Decimal("20.00") / 1000000,  # $20.00 per 1M tokens
+        ),
+        "gpt-4o-mini": TokenPricingModel(
+            prompt_token_price=Decimal("0.15") / 1000000,  # $0.15 per 1M tokens
+            completion_token_price=Decimal("0.60") / 1000000,  # $0.60 per 1M tokens
+        ),
+        "gpt-4o-mini-audio-preview": TokenPricingModel(
+            prompt_token_price=Decimal("0.15") / 1000000,  # $0.15 per 1M tokens
+            completion_token_price=Decimal("0.60") / 1000000,  # $0.60 per 1M tokens
+        ),
+        "gpt-4o-mini-realtime-preview": TokenPricingModel(
+            prompt_token_price=Decimal("0.60") / 1000000,  # $0.60 per 1M tokens
+            completion_token_price=Decimal("2.40") / 1000000,  # $2.40 per 1M tokens
+        ),
+        "gpt-4o-search-preview": TokenPricingModel(
+            prompt_token_price=Decimal("2.50") / 1000000,  # $2.50 per 1M tokens
+            completion_token_price=Decimal("10.00") / 1000000,  # $10.00 per 1M tokens
+        ),
+        "gpt-4o-mini-search-preview": TokenPricingModel(
+            prompt_token_price=Decimal("0.15") / 1000000,  # $0.15 per 1M tokens
+            completion_token_price=Decimal("0.60") / 1000000,  # $0.60 per 1M tokens
+        ),
+        "o1": TokenPricingModel(
+            prompt_token_price=Decimal("15.00") / 1000000,  # $15.00 per 1M tokens
+            completion_token_price=Decimal("60.00") / 1000000,  # $60.00 per 1M tokens
+        ),
+        "o1-pro": TokenPricingModel(
+            prompt_token_price=Decimal("150.00") / 1000000,  # $150.00 per 1M tokens
+            completion_token_price=Decimal("600.00") / 1000000,  # $600.00 per 1M tokens
+        ),
+        "o1-mini": TokenPricingModel(
+            prompt_token_price=Decimal("1.10") / 1000000,  # $1.10 per 1M tokens
+            completion_token_price=Decimal("4.40") / 1000000,  # $4.40 per 1M tokens
+        ),
+        "o3": TokenPricingModel(
+            prompt_token_price=Decimal("10.00") / 1000000,  # $10.00 per 1M tokens
+            completion_token_price=Decimal("40.00") / 1000000,  # $40.00 per 1M tokens
+        ),
+        "o3-mini": TokenPricingModel(
+            prompt_token_price=Decimal("1.10") / 1000000,  # $1.10 per 1M tokens
+            completion_token_price=Decimal("4.40") / 1000000,  # $4.40 per 1M tokens
+        ),
+        "o4-mini": TokenPricingModel(
+            prompt_token_price=Decimal("1.10") / 1000000,  # $1.10 per 1M tokens
+            completion_token_price=Decimal("4.40") / 1000000,  # $4.40 per 1M tokens
+        ),
+        "computer-use-preview": TokenPricingModel(
+            prompt_token_price=Decimal("3.00") / 1000000,  # $3.00 per 1M tokens
+            completion_token_price=Decimal("12.00") / 1000000,  # $12.00 per 1M tokens
+        ),
+        "gpt-image-1": TokenPricingModel(
+            prompt_token_price=Decimal("5.00") / 1000000,  # $5.00 per 1M tokens
+            completion_token_price=Decimal("0") / 1000000,  # No output pricing shown
+        ),
+        "codex-mini-latest": TokenPricingModel(
+            prompt_token_price=Decimal("1.50") / 1000000,  # $1.50 per 1M tokens
+            completion_token_price=Decimal("6.00") / 1000000,  # $6.00 per 1M tokens
+        ),
+        # Transcription models
+        "gpt-4o-transcribe": TokenPricingModel(
+            prompt_token_price=Decimal("2.50") / 1000000,  # $2.50 per 1M tokens
+            completion_token_price=Decimal("10.00") / 1000000,  # $10.00 per 1M tokens
+        ),
+        "gpt-4o-mini-transcribe": TokenPricingModel(
+            prompt_token_price=Decimal("1.25") / 1000000,  # $1.25 per 1M tokens
+            completion_token_price=Decimal("5.00") / 1000000,  # $5.00 per 1M tokens
+        ),
+        # TTS models with token-based pricing
+        "gpt-4o-mini-tts": TokenPricingModel(
+            prompt_token_price=Decimal("0.60") / 1000000,  # $0.60 per 1M tokens
+            completion_token_price=Decimal("0")
+            / 1000000,  # No completion tokens for TTS
+        ),
+    },
+    ServiceProviders.GROQ: {
+        "llama-3.3-70b-versatile": TokenPricingModel(
+            prompt_token_price=Decimal("0.00059") / 1000,  # $0.00059 per 1K tokens
+            completion_token_price=Decimal("0.00079") / 1000,  # $0.00079 per 1K tokens
+        ),
+        "deepseek-r1-distill-llama-70b": TokenPricingModel(
+            prompt_token_price=Decimal("0.00059") / 1000,  # Assuming similar pricing
+            completion_token_price=Decimal("0.00079") / 1000,
+        ),
+    },
+    ServiceProviders.AZURE: {
+        "gpt-4.1-mini": TokenPricingModel(
+            prompt_token_price=Decimal("0.44") / 1000000,  # $0.40 per 1M tokens
+            completion_token_price=Decimal("8.80")
+            / 1000000,  # $1.60 per 1M tokens if using data zone
+        )
+    },
+}

api/services/pricing/models.py

@@ -0,0 +1,89 @@
+"""
+Base pricing models for different service types.
+"""
+
+from decimal import Decimal
+from enum import Enum
+from typing import Any, Dict
+
+
+class CostType(Enum):
+    LLM_TOKENS = "llm_tokens"
+    TTS_CHARACTERS = "tts_characters"
+    STT_SECONDS = "stt_seconds"
+
+
+class PricingModel:
+    """Base class for pricing models"""
+
+    def calculate_cost(self, usage: Any) -> Decimal:
+        """Calculate cost based on usage"""
+        raise NotImplementedError
+
+
+class TokenPricingModel(PricingModel):
+    """Pricing model for token-based services (LLM)"""
+
+    def __init__(
+        self,
+        prompt_token_price: Decimal,
+        completion_token_price: Decimal,
+        cache_read_discount: Decimal = Decimal("0.5"),  # 50% discount for cache reads
+        cache_creation_multiplier: Decimal = Decimal(
+            "1.25"
+        ),  # 25% premium for cache creation
+    ):
+        self.prompt_token_price = prompt_token_price
+        self.completion_token_price = completion_token_price
+        self.cache_read_discount = cache_read_discount
+        self.cache_creation_multiplier = cache_creation_multiplier
+
+    def calculate_cost(self, usage: Dict[str, int]) -> Decimal:
+        """Calculate cost for LLM token usage"""
+        prompt_tokens = usage.get("prompt_tokens", 0)
+        completion_tokens = usage.get("completion_tokens", 0)
+        cache_read_tokens = usage.get("cache_read_input_tokens") or 0
+        cache_creation_tokens = usage.get("cache_creation_input_tokens") or 0
+
+        # Base cost
+        prompt_cost = Decimal(prompt_tokens) * self.prompt_token_price
+        completion_cost = Decimal(completion_tokens) * self.completion_token_price
+
+        # Cache adjustments
+        cache_read_savings = (
+            Decimal(cache_read_tokens)
+            * self.prompt_token_price
+            * self.cache_read_discount
+        )
+        cache_creation_premium = (
+            Decimal(cache_creation_tokens)
+            * self.prompt_token_price
+            * (self.cache_creation_multiplier - 1)
+        )
+
+        total_cost = (
+            prompt_cost + completion_cost - cache_read_savings + cache_creation_premium
+        )
+        return max(total_cost, Decimal("0"))  # Ensure non-negative
+
+
+class CharacterPricingModel(PricingModel):
+    """Pricing model for character-based services (TTS)"""
+
+    def __init__(self, character_price: Decimal):
+        self.character_price = character_price
+
+    def calculate_cost(self, character_count: int) -> Decimal:
+        """Calculate cost for TTS character usage"""
+        return Decimal(character_count) * self.character_price
+
+
+class TimePricingModel(PricingModel):
+    """Pricing model for time-based services (STT)"""
+
+    def __init__(self, second_price: Decimal):
+        self.second_price = second_price
+
+    def calculate_cost(self, seconds: float) -> Decimal:
+        """Calculate cost for STT time usage"""
+        return Decimal(str(seconds)) * self.second_price

api/services/pricing/registry.py

@@ -0,0 +1,16 @@
+"""
+Main pricing registry that combines all service type pricing models.
+"""
+
+from typing import Dict
+
+from .llm import LLM_PRICING
+from .stt import STT_PRICING
+from .tts import TTS_PRICING
+
+# Combined pricing registry for all service types
+PRICING_REGISTRY: Dict = {
+    "llm": LLM_PRICING,
+    "tts": TTS_PRICING,
+    "stt": STT_PRICING,
+}

api/services/pricing/stt.py

@@ -0,0 +1,26 @@
+"""
+STT (Speech-to-Text) pricing models for different providers.
+
+Prices are per second for STT services.
+"""
+
+from decimal import Decimal
+from typing import Dict
+
+from api.services.configuration.registry import ServiceProviders
+
+from .models import TimePricingModel
+
+# STT pricing registry
+STT_PRICING: Dict[str, Dict[str, TimePricingModel]] = {
+    ServiceProviders.DEEPGRAM: {
+        "nova-3-general": TimePricingModel(Decimal("0.0077") / 60),
+        "nova-2": TimePricingModel(Decimal("0.0058") / 60),
+        "default": TimePricingModel(Decimal("0.0077") / 60),
+    },
+    ServiceProviders.OPENAI: {
+        "gpt-4o-transcribe": TimePricingModel(Decimal("0.015") / 60),
+        "default": TimePricingModel(Decimal("0.015") / 60),
+    },
+    "default": {"default": TimePricingModel(Decimal("0.0077") / 60)},
+}

api/services/pricing/tts.py

@@ -0,0 +1,30 @@
+"""
+TTS (Text-to-Speech) pricing models for different providers.
+
+Prices are per character for TTS services.
+"""
+
+from decimal import Decimal
+from typing import Dict
+
+from api.services.configuration.registry import ServiceProviders
+
+from .models import CharacterPricingModel
+
+# TTS pricing registry
+TTS_PRICING: Dict[str, Dict[str, CharacterPricingModel]] = {
+    ServiceProviders.OPENAI: {
+        "gpt-4o-mini-tts": CharacterPricingModel(Decimal("0.6") / 1_00_00_000),
+        "default": CharacterPricingModel(Decimal("0.6") / 1_00_00_000),
+    },
+    ServiceProviders.DEEPGRAM: {
+        "aura-2": CharacterPricingModel(Decimal("0.030") / 1_000),
+        "aura-1": CharacterPricingModel(Decimal("0.015") / 1_000),
+        "default": CharacterPricingModel(Decimal("0.030") / 1_000),
+    },
+    ServiceProviders.ELEVENLABS: {
+        # 6400 usd per 250*1e6 characters
+        "default": CharacterPricingModel(Decimal("0.0256") / 1_000)
+    },
+    "default": {"default": CharacterPricingModel(Decimal("0.030") / 1_000)},
+}