paygent-sdk 1.0.0__tar.gz → 2.0.0__tar.gz

{paygent_sdk-1.0.0/paygent_sdk.egg-info → paygent_sdk-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: paygent-sdk
-Version: 1.0.0
+Version: 2.0.0
 Summary: Official Python SDK for Paygent - Track AI usage and costs across multiple providers (OpenAI, Anthropic, Google, DeepSeek, etc.)
 Home-page: https://github.com/paygent/paygent-sdk-python
 Author: Paygent

paygent_sdk-2.0.0/paygent_sdk/__init__.py

@@ -0,0 +1,100 @@
+"""
+Paygent SDK for Python
+
+A Python SDK for integrating with the Paygent API to track usage and costs for AI models.
+
+For the Go SDK equivalent, see: https://github.com/paygent/paygent-sdk-go
+"""
+
+from .client import Client
+from .models import (
+    UsageData, UsageDataWithStrings, APIRequest, ModelPricing, MODEL_PRICING,
+    SttUsageData, TtsUsageData, SttModelPricing, TtsModelPricing
+)
+from .voice_client import send_stt_usage, send_tts_usage  # Import to attach methods to Client
+
+# Import wrappers with optional LangChain support
+try:
+    from .wrappers import (
+        PaygentOpenAI,
+        PaygentAnthropic,
+        PaygentMistral,
+        PaygentGemini,
+        PaygentLangChainCallback
+    )
+    _has_langchain = True
+except ImportError:
+    from .wrappers import (
+        PaygentOpenAI,
+        PaygentAnthropic,
+        PaygentMistral,
+        PaygentGemini
+    )
+    _has_langchain = False
+from .constants import (
+    ServiceProvider,
+    OpenAIModels,
+    AnthropicModels,
+    GoogleDeepMindModels,
+    MetaModels,
+    AWSModels,
+    MistralAIModels,
+    CohereModels,
+    DeepSeekModels,
+    DeepgramSTTModels,
+    MicrosoftAzureSpeechSTTModels,
+    GoogleCloudSpeechSTTModels,
+    AssemblyAISTTModels,
+    AmazonPollyTTSModels,
+    MicrosoftAzureSpeechTTSModels,
+    GoogleCloudTextToSpeechTTSModels,
+    DeepgramTTSModels,
+    is_model_supported
+)
+
+__version__ = "1.0.0"
+__all__ = [
+    # Core classes
+    "Client",
+    "UsageData", 
+    "UsageDataWithStrings", 
+    "APIRequest", 
+    "ModelPricing",
+    "MODEL_PRICING",
+    
+    # Voice data models
+    "SttUsageData",
+    "TtsUsageData",
+    "SttModelPricing",
+    "TtsModelPricing",
+    
+    # Wrappers
+    "PaygentOpenAI",
+    "PaygentAnthropic",
+    "PaygentMistral",
+    "PaygentGemini",
+    
+    # Constants
+    "ServiceProvider",
+    "OpenAIModels",
+    "AnthropicModels", 
+    "GoogleDeepMindModels",
+    "MetaModels",
+    "AWSModels",
+    "MistralAIModels",
+    "CohereModels",
+    "DeepSeekModels",
+    
+    # STT/TTS Model constants
+    "DeepgramSTTModels",
+    "MicrosoftAzureSpeechSTTModels",
+    "GoogleCloudSpeechSTTModels",
+    "AssemblyAISTTModels",
+    "AmazonPollyTTSModels",
+    "MicrosoftAzureSpeechTTSModels",
+    "GoogleCloudTextToSpeechTTSModels",
+    "DeepgramTTSModels",
+    
+    # Utility functions
+    "is_model_supported"
+]

{paygent_sdk-1.0.0 → paygent_sdk-2.0.0}/paygent_sdk/client.py

@@ -23,20 +23,22 @@ from .models import UsageData, UsageDataWithStrings, APIRequest, ModelPricing, M
 class Client:
     """Paygent SDK client for tracking usage and costs for AI models."""
 
-    def __init__(self, api_key: str, base_url: str = "http://13.201.118.45:8080"):
+    def __init__(self, api_key: str):
         """
         Initialize the Paygent SDK client.
 
         Args:
             api_key: Your Paygent API key
-            base_url: Base URL for the Paygent API (default: http://13.201.118.45:8080)
         """
         self.api_key = api_key
-        self.base_url = base_url.rstrip('/')
+        # Locked configuration - cannot be changed by users
+        self.base_url = "https://cp-api.withpaygent.com"
+        # self.base_url = "http://localhost:8082"
+        self.timeout = 3000
         
-        # Setup logging
+        # Setup logging with ERROR level by default (minimal logging)
         self.logger = logging.getLogger(f"paygent_sdk.{id(self)}")
-        self.logger.setLevel(logging.INFO)
+        self.logger.setLevel(logging.ERROR)
         
         # Add console handler if no handlers exist
         if not self.logger.handlers:
@@ -61,13 +63,13 @@ class Client:
         self.session.mount("http://", adapter)
         self.session.mount("https://", adapter)
         
-        # Set default timeout
-        self.session.timeout = 30
+        # Set timeout from locked configuration
+        self.session.timeout = self.timeout
 
     @classmethod
     def new_client(cls, api_key: str) -> 'Client':
         """
-        Create a new Paygent SDK client with the default API URL.
+        Create a new Paygent SDK client.
 
         Args:
             api_key: Your Paygent API key
@@ -77,20 +79,6 @@ class Client:
         """
         return cls(api_key)
 
-    @classmethod
-    def new_client_with_url(cls, api_key: str, base_url: str) -> 'Client':
-        """
-        Create a new Paygent SDK client with a custom base URL.
-
-        Args:
-            api_key: Your Paygent API key
-            base_url: Custom base URL for the Paygent API
-            
-        Returns:
-            Client instance
-        """
-        return cls(api_key, base_url)
-
     def _calculate_cost(self, model: str, usage_data: UsageData) -> float:
         """
         Calculate the cost based on model and usage data.
@@ -145,10 +133,7 @@ class Client:
             requests.RequestException: If the HTTP request fails
             ValueError: If the usage data is invalid
         """
-        self.logger.info(
-            f"Starting sendUsage for agentID={agent_id}, customerID={customer_id}, "
-            f"indicator={indicator}, model={usage_data.model}"
-        )
+        # Removed verbose logging - only log errors
 
         # Calculate cost
         try:
@@ -157,7 +142,7 @@ class Client:
             self.logger.error(f"Failed to calculate cost: {e}")
             raise ValueError(f"Failed to calculate cost: {e}") from e
 
-        self.logger.info(f"Calculated cost: {cost:.6f} for model {usage_data.model}")
+        # Cost calculated (no logging for performance)
 
         # Prepare API request
         api_request = APIRequest(
@@ -207,10 +192,7 @@ class Client:
 
             # Check response status
             if 200 <= response.status_code < 300:
-                self.logger.info(
-                    f"Successfully sent usage data for agentID={agent_id}, "
-                    f"customerID={customer_id}, cost={cost:.6f}"
-                )
+                # Success - no logging to minimize verbosity
                 return
 
             # Handle error response
@@ -381,11 +363,7 @@ class Client:
             requests.RequestException: If the HTTP request fails
             ValueError: If the usage data is invalid
         """
-        self.logger.info(
-            f"Starting sendUsageWithTokenString for agentID={agent_id}, customerID={customer_id}, "
-            f"indicator={indicator}, serviceProvider={usage_data.service_provider}, model={usage_data.model}"
-        )
-
+        # Removed verbose logging - only log errors
         # Calculate cost from strings
         try:
             cost = self._calculate_cost_from_strings(usage_data.model, usage_data)
@@ -393,7 +371,7 @@ class Client:
             self.logger.error(f"Failed to calculate cost from strings: {e}")
             raise ValueError(f"Failed to calculate cost from strings: {e}") from e
 
-        self.logger.info(f"Calculated cost: {cost:.6f} for model {usage_data.model} from strings")
+        # Cost calculated from strings (no logging for performance)
 
         # Calculate token counts for API request
         prompt_tokens = self._get_token_count(usage_data.model, usage_data.prompt_string)
@@ -447,10 +425,7 @@ class Client:
 
             # Check response status
             if 200 <= response.status_code < 300:
-                self.logger.info(
-                    f"Successfully sent usage data from strings for agentID={agent_id}, "
-                    f"customerID={customer_id}, cost={cost:.6f}"
-                )
+                # Success - no logging to minimize verbosity
                 return
 
             # Handle error response

{paygent_sdk-1.0.0 → paygent_sdk-2.0.0}/paygent_sdk/constants.py

@@ -19,6 +19,18 @@ class ServiceProvider:
     COHERE = "Cohere"
     DEEPSEEK = "DeepSeek"
     CUSTOM = "Custom"
+    
+    # STT Service Providers
+    DEEPGRAM = "Deepgram"
+    MICROSOFT_AZURE_SPEECH = "Microsoft Azure Speech Service"
+    GOOGLE_CLOUD_SPEECH = "Google Cloud Speech-to-Text"
+    ASSEMBLY_AI = "AssemblyAI"
+    
+    # TTS Service Providers
+    AMAZON_POLLY = "Amazon Polly"
+    MICROSOFT_AZURE_SPEECH_TTS = "Microsoft Azure Speech Service"
+    GOOGLE_CLOUD_TEXT_TO_SPEECH = "Google Cloud Text-to-Speech"
+    DEEPGRAM_TTS = "Deepgram"
 
 
 # OpenAI Models
@@ -202,6 +214,78 @@ class DeepSeekModels:
 
 
 
+# Deepgram STT Models
+class DeepgramSTTModels:
+    """Deepgram STT model constants."""
+    FLUX = "Flux"
+    NOVA_3_MONOLINGUAL = "Nova-3 (Monolingual)"
+    NOVA_3_MULTILINGUAL = "Nova-3 (Multilingual)"
+    NOVA_1 = "Nova-1"
+    NOVA_2 = "Nova-2"
+    ENHANCED = "Enhanced"
+    BASE = "Base"
+    REDACTION = "Redaction (Add-on)"
+    KEYTERM_PROMPTING = "Keyterm Prompting (Add-on)"
+    SPEAKER_DIARIZATION = "Speaker Diarization (Add-on)"
+
+
+# Microsoft Azure Speech Service STT Models
+class MicrosoftAzureSpeechSTTModels:
+    """Microsoft Azure Speech Service STT model constants."""
+    STANDARD = "Azure Speech Standard"
+    CUSTOM = "Azure Speech Custom"
+
+
+# Google Cloud Speech-to-Text STT Models
+class GoogleCloudSpeechSTTModels:
+    """Google Cloud Speech-to-Text STT model constants."""
+    STANDARD = "Google Cloud Speech Standard"
+
+
+# AssemblyAI STT Models
+class AssemblyAISTTModels:
+    """AssemblyAI STT model constants."""
+    UNIVERSAL_STREAMING = "Universal-Streaming"
+    UNIVERSAL_STREAMING_MULTILANG = "Universal-Streaming Multilingual"
+    KEYTERMS_PROMPTING = "Keyterms Prompting"
+
+
+# Amazon Polly TTS Models
+class AmazonPollyTTSModels:
+    """Amazon Polly TTS model constants."""
+    STANDARD = "Amazon Polly Standard"
+    NEURAL = "Amazon Polly Neural"
+    LONG_FORM = "Amazon Polly Long-form"
+    GENERATIVE = "Amazon Polly Generative"
+
+
+# Microsoft Azure Speech Service TTS Models
+class MicrosoftAzureSpeechTTSModels:
+    """Microsoft Azure Speech Service TTS model constants."""
+    STANDARD = "Azure TTS Standard"
+    CUSTOM = "Azure TTS Custom"
+    CUSTOM_NEURAL_HD = "Azure TTS Custom Neural HD"
+
+
+# Google Cloud Text-to-Speech TTS Models
+class GoogleCloudTextToSpeechTTSModels:
+    """Google Cloud Text-to-Speech TTS model constants."""
+    CHIRP_3_HD = "Google Cloud TTS Chirp 3: HD"
+    INSTANT_CUSTOM = "Google Cloud TTS Instant custom"
+    WAVENET = "Google Cloud TTS WaveNet"
+    STUDIO = "Google Cloud TTS Studio"
+    STANDARD = "Google Cloud TTS Standard"
+    NEURAL2 = "Google Cloud TTS Neural2"
+    POLYGLOT_PREVIEW = "Google Cloud TTS Polyglot (Preview)"
+
+
+# Deepgram TTS Models
+class DeepgramTTSModels:
+    """Deepgram TTS model constants."""
+    AURA_2 = "Deepgram Aura-2"
+    AURA_1 = "Deepgram Aura-1"
+
+
 def is_model_supported(model: str) -> bool:
     """
     Check if a model is supported by the SDK.

{paygent_sdk-1.0.0 → paygent_sdk-2.0.0}/paygent_sdk/models.py

@@ -53,6 +53,34 @@ class ModelPricing:
     completion_tokens_cost: float
 
 
+@dataclass
+class SttUsageData:
+    """Represents the STT usage data structure."""
+    service_provider: str
+    model: str
+    audio_duration: int  # Duration in seconds
+
+
+@dataclass
+class TtsUsageData:
+    """Represents the TTS usage data structure."""
+    service_provider: str
+    model: str
+    character_count: int  # Number of characters
+
+
+@dataclass
+class SttModelPricing:
+    """Represents pricing information for STT models (cost per hour in USD)."""
+    cost_per_hour: float  # Cost per hour in USD
+
+
+@dataclass
+class TtsModelPricing:
+    """Represents pricing information for TTS models (cost per 1 million characters in USD)."""
+    cost_per_million_characters: float  # Cost per 1 million characters in USD
+
+
 # Default model pricing (cost per 1000 tokens in USD)
 MODEL_PRICING: Dict[str, ModelPricing] = {
     # OpenAI Models (pricing per 1000 tokens)

paygent_sdk-2.0.0/paygent_sdk/voice_client.py

@@ -0,0 +1,263 @@
+"""
+Voice client implementation for STT and TTS usage tracking.
+"""
+
+import logging
+from typing import Dict
+from urllib.parse import urljoin
+
+import requests
+
+from .constants import (
+    DeepgramSTTModels,
+    MicrosoftAzureSpeechSTTModels,
+    GoogleCloudSpeechSTTModels,
+    AssemblyAISTTModels,
+    AmazonPollyTTSModels,
+    MicrosoftAzureSpeechTTSModels,
+    GoogleCloudTextToSpeechTTSModels,
+    DeepgramTTSModels,
+)
+from .models import SttModelPricing, TtsModelPricing
+
+
+# STT model pricing (cost per hour in USD)
+STT_MODEL_PRICING: Dict[str, SttModelPricing] = {
+    # Deepgram Models
+    DeepgramSTTModels.FLUX: SttModelPricing(cost_per_hour=0.462),  # $0.462 per hour
+    DeepgramSTTModels.NOVA_3_MONOLINGUAL: SttModelPricing(cost_per_hour=0.462),  # $0.462 per hour
+    DeepgramSTTModels.NOVA_3_MULTILINGUAL: SttModelPricing(cost_per_hour=0.552),  # $0.552 per hour
+    DeepgramSTTModels.NOVA_1: SttModelPricing(cost_per_hour=0.348),  # $0.348 per hour
+    DeepgramSTTModels.NOVA_2: SttModelPricing(cost_per_hour=0.348),  # $0.348 per hour
+    DeepgramSTTModels.ENHANCED: SttModelPricing(cost_per_hour=0.99),  # $0.99 per hour
+    DeepgramSTTModels.BASE: SttModelPricing(cost_per_hour=0.87),  # $0.87 per hour
+    DeepgramSTTModels.REDACTION: SttModelPricing(cost_per_hour=0.12),  # $0.12 per hour (add-on)
+    DeepgramSTTModels.KEYTERM_PROMPTING: SttModelPricing(cost_per_hour=0.072),  # $0.072 per hour (add-on)
+    DeepgramSTTModels.SPEAKER_DIARIZATION: SttModelPricing(cost_per_hour=0.12),  # $0.12 per hour (add-on)
+
+    # Microsoft Azure Speech Service Models
+    MicrosoftAzureSpeechSTTModels.STANDARD: SttModelPricing(cost_per_hour=1.0),  # $1.0 per hour
+    MicrosoftAzureSpeechSTTModels.CUSTOM: SttModelPricing(cost_per_hour=1.2),  # $1.2 per hour
+
+    # Google Cloud Speech-to-Text Models
+    GoogleCloudSpeechSTTModels.STANDARD: SttModelPricing(cost_per_hour=0.96),  # $0.96 per hour
+
+    # AssemblyAI Models
+    AssemblyAISTTModels.UNIVERSAL_STREAMING: SttModelPricing(cost_per_hour=0.15),  # $0.15 per hour
+    AssemblyAISTTModels.UNIVERSAL_STREAMING_MULTILANG: SttModelPricing(cost_per_hour=0.15),  # $0.15 per hour
+    AssemblyAISTTModels.KEYTERMS_PROMPTING: SttModelPricing(cost_per_hour=0.04),  # $0.04 per hour
+}
+
+
+# TTS model pricing (cost per 1 million characters in USD)
+TTS_MODEL_PRICING: Dict[str, TtsModelPricing] = {
+    # Amazon Polly Models
+    AmazonPollyTTSModels.STANDARD: TtsModelPricing(cost_per_million_characters=0.4),  # $0.4 per 1 million characters
+    AmazonPollyTTSModels.NEURAL: TtsModelPricing(cost_per_million_characters=16.0),  # $16 per 1 million characters
+    AmazonPollyTTSModels.LONG_FORM: TtsModelPricing(cost_per_million_characters=100.0),  # $100 per 1 million characters
+    AmazonPollyTTSModels.GENERATIVE: TtsModelPricing(cost_per_million_characters=30.0),  # $30 per 1 million characters
+
+    # Microsoft Azure Speech Service TTS Models
+    MicrosoftAzureSpeechTTSModels.STANDARD: TtsModelPricing(cost_per_million_characters=15.0),  # $15 per 1 million characters
+    MicrosoftAzureSpeechTTSModels.CUSTOM: TtsModelPricing(cost_per_million_characters=24.0),  # $24 per 1 million characters
+    MicrosoftAzureSpeechTTSModels.CUSTOM_NEURAL_HD: TtsModelPricing(cost_per_million_characters=48.0),  # $48 per 1 million characters
+
+    # Google Cloud Text-to-Speech TTS Models
+    GoogleCloudTextToSpeechTTSModels.CHIRP_3_HD: TtsModelPricing(cost_per_million_characters=30.0),  # $30 per 1 million characters
+    GoogleCloudTextToSpeechTTSModels.INSTANT_CUSTOM: TtsModelPricing(cost_per_million_characters=60.0),  # $60 per 1 million characters
+    GoogleCloudTextToSpeechTTSModels.WAVENET: TtsModelPricing(cost_per_million_characters=4.0),  # $4 per 1 million characters
+    GoogleCloudTextToSpeechTTSModels.STUDIO: TtsModelPricing(cost_per_million_characters=160.0),  # $160 per 1 million characters
+    GoogleCloudTextToSpeechTTSModels.STANDARD: TtsModelPricing(cost_per_million_characters=4.0),  # $4 per 1 million characters
+    GoogleCloudTextToSpeechTTSModels.NEURAL2: TtsModelPricing(cost_per_million_characters=16.0),  # $16 per 1 million characters
+    GoogleCloudTextToSpeechTTSModels.POLYGLOT_PREVIEW: TtsModelPricing(cost_per_million_characters=16.0),  # $16 per 1 million characters
+
+    # Deepgram TTS Models
+    DeepgramTTSModels.AURA_2: TtsModelPricing(cost_per_million_characters=30.0),  # $30 per 1 million characters
+    DeepgramTTSModels.AURA_1: TtsModelPricing(cost_per_million_characters=15.0),  # $15 per 1 million characters
+}
+
+
+def _calculate_stt_cost(client_instance, model: str, audio_duration_seconds: int) -> float:
+    """
+    Calculate the cost based on STT model and audio duration.
+    
+    Args:
+        client_instance: The Client instance
+        model: The STT model name
+        audio_duration_seconds: Audio duration in seconds
+        
+    Returns:
+        Calculated cost in USD
+    """
+    pricing = STT_MODEL_PRICING.get(model)
+    
+    if not pricing:
+        client_instance.logger.warning(f"Unknown STT model '{model}', using default pricing")
+        # Use default pricing for unknown models (per hour)
+        pricing = SttModelPricing(cost_per_hour=0.5)  # $0.50 per hour default
+    
+    # Calculate cost: (duration in seconds / 3600) * cost per hour
+    # Convert seconds to hours and multiply by cost per hour
+    duration_hours = audio_duration_seconds / 3600.0
+    total_cost = duration_hours * pricing.cost_per_hour
+    
+    client_instance.logger.debug(
+        f"STT cost calculation for model '{model}': "
+        f"duration={audio_duration_seconds} seconds ({duration_hours:.6f} hours), "
+        f"cost_per_hour={pricing.cost_per_hour:.6f}, total={total_cost:.6f}"
+    )
+    
+    return total_cost
+
+
+def _calculate_tts_cost(client_instance, model: str, character_count: int) -> float:
+    """
+    Calculate the cost based on TTS model and character count.
+    
+    Args:
+        client_instance: The Client instance
+        model: The TTS model name
+        character_count: Number of characters
+        
+    Returns:
+        Calculated cost in USD
+    """
+    pricing = TTS_MODEL_PRICING.get(model)
+    
+    if not pricing:
+        client_instance.logger.warning(f"Unknown TTS model '{model}', using default pricing")
+        # Use default pricing for unknown models (per 1 million characters)
+        pricing = TtsModelPricing(cost_per_million_characters=10.0)  # $10 per 1 million characters default
+    
+    # Calculate cost: (character count / 1,000,000) * cost per 1 million characters
+    # Convert character count to millions and multiply by cost per million
+    characters_in_millions = character_count / 1000000.0
+    total_cost = characters_in_millions * pricing.cost_per_million_characters
+    
+    client_instance.logger.debug(
+        f"TTS cost calculation for model '{model}': "
+        f"characters={character_count} ({characters_in_millions:.6f} millions), "
+        f"cost_per_million={pricing.cost_per_million_characters:.6f}, total={total_cost:.6f}"
+    )
+    
+    return total_cost
+
+
+def send_stt_usage(client_instance, agent_id: str, customer_id: str, stt_usage_data) -> None:
+    """
+    Send STT usage data to the Paygent API.
+    
+    Args:
+        client_instance: The Client instance
+        agent_id: Unique identifier for the agent
+        customer_id: Unique identifier for the customer
+        stt_usage_data: SttUsageData containing model and audio duration information
+        
+    Raises:
+        requests.RequestException: If the request fails
+    """
+    client_instance.logger.info(
+        f"Starting send_stt_usage for agentID={agent_id}, customerID={customer_id}, "
+        f"model={stt_usage_data.model}, duration={stt_usage_data.audio_duration} seconds"
+    )
+    
+    try:
+        # Calculate cost
+        cost = _calculate_stt_cost(client_instance, stt_usage_data.model, stt_usage_data.audio_duration)
+        client_instance.logger.info(f"Calculated STT cost: {cost:.6f} for model {stt_usage_data.model}")
+        
+        # Prepare API request
+        api_request = {
+            "agentId": agent_id,
+            "customerId": customer_id,
+            "indicator": "stt-usage",  # Default indicator for STT usage
+            "amount": cost,
+            "audioDuration": stt_usage_data.audio_duration,
+            "model": stt_usage_data.model,
+            "serviceProvider": stt_usage_data.service_provider,
+        }
+        
+        # Make HTTP request
+        url = urljoin(client_instance.base_url, "/api/v1/usage")
+        headers = {
+            "Content-Type": "application/json",
+            "paygent-api-key": client_instance.api_key,
+        }
+        
+        response = client_instance.session.post(url, json=api_request, headers=headers)
+        response.raise_for_status()
+        
+        client_instance.logger.info(
+            f"Successfully sent STT usage data for agentID={agent_id}, "
+            f"customerID={customer_id}, cost={cost:.6f}"
+        )
+    except requests.RequestException as e:
+        client_instance.logger.error(f"Failed to send STT usage data: {str(e)}")
+        raise
+
+
+def send_tts_usage(client_instance, agent_id: str, customer_id: str, tts_usage_data) -> None:
+    """
+    Send TTS usage data to the Paygent API.
+    
+    Args:
+        client_instance: The Client instance
+        agent_id: Unique identifier for the agent
+        customer_id: Unique identifier for the customer
+        tts_usage_data: TtsUsageData containing model and character count information
+        
+    Raises:
+        requests.RequestException: If the request fails
+    """
+    client_instance.logger.info(
+        f"Starting send_tts_usage for agentID={agent_id}, customerID={customer_id}, "
+        f"model={tts_usage_data.model}, characters={tts_usage_data.character_count}"
+    )
+    
+    try:
+        # Calculate cost
+        cost = _calculate_tts_cost(client_instance, tts_usage_data.model, tts_usage_data.character_count)
+        client_instance.logger.info(f"Calculated TTS cost: {cost:.6f} for model {tts_usage_data.model}")
+        
+        # Prepare API request
+        api_request = {
+            "agentId": agent_id,
+            "customerId": customer_id,
+            "indicator": "tts-usage",  # Default indicator for TTS usage
+            "amount": cost,
+            "characterCount": tts_usage_data.character_count,
+            "model": tts_usage_data.model,
+            "serviceProvider": tts_usage_data.service_provider,
+        }
+        
+        # Make HTTP request
+        url = urljoin(client_instance.base_url, "/api/v1/usage")
+        headers = {
+            "Content-Type": "application/json",
+            "paygent-api-key": client_instance.api_key,
+        }
+        
+        response = client_instance.session.post(url, json=api_request, headers=headers)
+        response.raise_for_status()
+        
+        client_instance.logger.info(
+            f"Successfully sent TTS usage data for agentID={agent_id}, "
+            f"customerID={customer_id}, cost={cost:.6f}"
+        )
+    except requests.RequestException as e:
+        client_instance.logger.error(f"Failed to send TTS usage data: {str(e)}")
+        raise
+
+
+# Add methods to Client class
+def _add_voice_methods_to_client():
+    """Dynamically add voice methods to the Client class."""
+    from .client import Client
+    
+    Client.send_stt_usage = send_stt_usage
+    Client.send_tts_usage = send_tts_usage
+
+
+# Call this function to attach methods when module is imported
+_add_voice_methods_to_client()
+

paygent_sdk-2.0.0/paygent_sdk/wrappers/__init__.py

@@ -0,0 +1,30 @@
+"""
+Wrappers for automatic usage tracking with AI provider SDKs.
+
+This module provides wrapper classes that intercept API calls to various AI providers
+and automatically send usage data to Paygent for tracking and billing.
+"""
+
+from .openai_wrapper import PaygentOpenAI
+from .anthropic_wrapper import PaygentAnthropic
+from .mistral_wrapper import PaygentMistral
+from .gemini_wrapper import PaygentGemini
+
+# LangChain integration (optional dependency)
+try:
+    from .langchain_wrapper import PaygentLangChainCallback
+    __all__ = [
+        "PaygentOpenAI",
+        "PaygentAnthropic",
+        "PaygentMistral",
+        "PaygentGemini",
+        "PaygentLangChainCallback",
+    ]
+except ImportError:
+    # LangChain not installed
+    __all__ = [
+        "PaygentOpenAI",
+        "PaygentAnthropic",
+        "PaygentMistral",
+        "PaygentGemini",
+    ]