paygent-sdk 1.0.0__py3-none-any.whl → 3.0.0__py3-none-any.whl

paygent_sdk/__init__.py

@@ -7,7 +7,17 @@ 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
+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
+
+# Wrappers are lazily imported in the wrappers module to avoid requiring
+# installation of peer dependencies (openai, anthropic, mistral, etc.) that aren't being used.
+# You can still import them normally:
+#   from paygent_sdk import PaygentOpenAI, PaygentGemini, etc.
+# But they will only actually load when first accessed.
 from .constants import (
     ServiceProvider,
     OpenAIModels,
@@ -18,6 +28,18 @@ from .constants import (
     MistralAIModels,
     CohereModels,
     DeepSeekModels,
+    MoonshotAIModels,
+    DeepgramSTTModels,
+    MicrosoftAzureSpeechSTTModels,
+    GoogleCloudSpeechSTTModels,
+    AssemblyAISTTModels,
+    ElevenLabsSTTModels,
+    SonioxSTTModels,
+    AmazonPollyTTSModels,
+    MicrosoftAzureSpeechTTSModels,
+    GoogleCloudTextToSpeechTTSModels,
+    DeepgramTTSModels,
+    ElevenLabsTTSModels,
     is_model_supported
 )
 
@@ -31,6 +53,18 @@ __all__ = [
     "ModelPricing",
     "MODEL_PRICING",
     
+    # Voice data models
+    "SttUsageData",
+    "TtsUsageData",
+    "SttModelPricing",
+    "TtsModelPricing",
+    
+    # Wrappers
+    "PaygentOpenAI",
+    "PaygentAnthropic",
+    "PaygentMistral",
+    "PaygentGemini",
+    
     # Constants
     "ServiceProvider",
     "OpenAIModels",
@@ -41,7 +75,38 @@ __all__ = [
     "MistralAIModels",
     "CohereModels",
     "DeepSeekModels",
+    "MoonshotAIModels",
+    
+    # STT/TTS Model constants
+    "DeepgramSTTModels",
+    "MicrosoftAzureSpeechSTTModels",
+    "GoogleCloudSpeechSTTModels",
+    "AssemblyAISTTModels",
+    "ElevenLabsSTTModels",
+    "SonioxSTTModels",
+    "AmazonPollyTTSModels",
+    "MicrosoftAzureSpeechTTSModels",
+    "GoogleCloudTextToSpeechTTSModels",
+    "DeepgramTTSModels",
+    "ElevenLabsTTSModels",
     
     # Utility functions
     "is_model_supported"
 ]
+
+
+def __getattr__(name):
+    """
+    Lazy import wrapper classes to avoid requiring peer dependencies that aren't being used.
+    
+    This allows importing wrappers like:
+        from paygent_sdk import PaygentOpenAI
+    
+    But the actual import only happens when accessed, so if you never use PaygentOpenAI,
+    you don't need the openai package installed.
+    """
+    if name in ["PaygentOpenAI", "PaygentAnthropic", "PaygentMistral", "PaygentGemini", "PaygentLangChainCallback"]:
+        from . import wrappers
+        return getattr(wrappers, name)
+    
+    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")

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.
@@ -113,12 +101,25 @@ class Client:
 
         # Calculate cost per 1000 tokens
         prompt_cost = (usage_data.prompt_tokens / 1000.0) * pricing.prompt_tokens_cost
+        
+        # Handle cached tokens: if model doesn't support caching (cached_tokens_cost is None),
+        # bill cached tokens at regular prompt token rate
+        cached_cost = 0.0
+        if usage_data.cached_tokens and usage_data.cached_tokens > 0:
+            if pricing.cached_tokens_cost is not None:
+                # Model supports caching - use cached token price
+                cached_cost = (usage_data.cached_tokens / 1000.0) * pricing.cached_tokens_cost
+            else:
+                # Model doesn't support caching - bill at prompt token rate
+                cached_cost = (usage_data.cached_tokens / 1000.0) * pricing.prompt_tokens_cost
+        
         completion_cost = (usage_data.completion_tokens / 1000.0) * pricing.completion_tokens_cost
-        total_cost = prompt_cost + completion_cost
+        total_cost = prompt_cost + cached_cost + completion_cost
 
         self.logger.debug(
             f"Cost calculation for model '{model}': "
             f"prompt_tokens={usage_data.prompt_tokens} ({prompt_cost:.6f}), "
+            f"cached_tokens={usage_data.cached_tokens or 0} ({cached_cost:.6f}), "
             f"completion_tokens={usage_data.completion_tokens} ({completion_cost:.6f}), "
             f"total={total_cost:.6f}"
         )
@@ -145,19 +146,32 @@ 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
+
+        # 🎯 AUTOMATIC CACHED TOKEN HANDLING
+        # Users can pass total prompt tokens - we automatically subtract cached tokens
+        # This makes manual tracking easier (no math required!)
+        cached_tokens = usage_data.cached_tokens or 0
+        regular_prompt_tokens = usage_data.prompt_tokens - cached_tokens
+
+        # Calculate cost using separated token counts
+        adjusted_usage_data = UsageData(
+            service_provider=usage_data.service_provider,
+            model=usage_data.model,
+            prompt_tokens=regular_prompt_tokens,
+            completion_tokens=usage_data.completion_tokens,
+            total_tokens=usage_data.total_tokens,
+            cached_tokens=cached_tokens
         )
 
         # Calculate cost
         try:
-            cost = self._calculate_cost(usage_data.model, usage_data)
+            cost = self._calculate_cost(usage_data.model, adjusted_usage_data)
         except Exception as e:
             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(
@@ -173,7 +187,8 @@ class Client:
             "customerId": api_request.customer_id,
             "indicator": api_request.indicator,
             "amount": api_request.amount,
-            "inputToken": usage_data.prompt_tokens,
+            "inputToken": regular_prompt_tokens,  # Send non-cached tokens
+            "cachedToken": cached_tokens,  # Send cached tokens separately
             "outputToken": usage_data.completion_tokens,
             "model": usage_data.model,
             "serviceProvider": usage_data.service_provider
@@ -207,10 +222,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 +393,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 +401,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 +455,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/constants.py

@@ -18,7 +18,23 @@ class ServiceProvider:
     MISTRAL_AI = "Mistral AI"
     COHERE = "Cohere"
     DEEPSEEK = "DeepSeek"
+    MOONSHOT_AI = "Moonshot AI"
     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"
+    ELEVEN_LABS_STT = "Eleven Labs STT"
+    SONIOX = "Soniox"
+    
+    # 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"
+    ELEVEN_LABS_TTS = "Eleven Labs TTS"
 
 
 # OpenAI Models
@@ -198,8 +214,113 @@ class DeepSeekModels:
     DEEPSEEK_V3_2_EXP = "DeepSeek V3.2-Exp"
 
 
+# Moonshot AI Models
+class MoonshotAIModels:
+    """Moonshot AI / Kimi model constants."""
+    KIMI_K2_INSTRUCT_0905 = "Kimi k2-instruct-0905"
+    KIMI_K2_0905_1T_256K = "Kimi k2-0905-1T-256K"
+
+
+
+
+
+
+# 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)"
+    # Growth tier models
+    GROWTH_NOVA_3_MONOLINGUAL = "Growth Nova-3 (Monolingual)"
+    GROWTH_NOVA_3_MULTILINGUAL = "Growth Nova-3 (Multilingual)"
+    GROWTH_NOVA_1 = "Growth Nova-1"
+    GROWTH_NOVA_2 = "Growth Nova-2"
+
+
+# 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"
+
+
+# Eleven Labs STT Models
+class ElevenLabsSTTModels:
+    """Eleven Labs STT model constants."""
+    BUSINESS_SCRIBE_V1_V2 = "Eleven Labs Business Scribe V1/V2"
+
+
+# Soniox STT Models
+class SonioxSTTModels:
+    """Soniox STT model constants."""
+    REAL_TIME = "Soniox Real Time"
+
+
+# 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_NEURAL = "Azure TTS Standard Neural"
+    CUSTOM_SYNTHESIS = "Azure TTS Custom Synthesis"
+    CUSTOM_SYNTHESIS_NEURAL_HD = "Azure TTS Custom Synthesis 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"
+    # Growth tier models
+    GROWTH_AURA_2 = "Deepgram Growth Aura-2"
+    GROWTH_AURA_1 = "Deepgram Growth Aura-1"
 
 
+# Eleven Labs TTS Models
+class ElevenLabsTTSModels:
+    """Eleven Labs TTS model constants."""
+    BUSINESS_MULTILINGUAL_V2_V3 = "Eleven Labs Business Multilingual V2/V3"
 
 
 def is_model_supported(model: str) -> bool:

paygent_sdk/models.py

@@ -15,6 +15,7 @@ from .constants import (
     MistralAIModels,
     CohereModels,
     DeepSeekModels,
+    MoonshotAIModels,
 )
 
 
@@ -26,6 +27,7 @@ class UsageData:
     prompt_tokens: int
     completion_tokens: int
     total_tokens: int
+    cached_tokens: Optional[int] = None  # Optional cached tokens
 
 
 @dataclass
@@ -51,6 +53,35 @@ class ModelPricing:
     """Represents pricing information for different models."""
     prompt_tokens_cost: float
     completion_tokens_cost: float
+    cached_tokens_cost: Optional[float] = None  # Optional cached token cost (if None, model doesn't support caching)
+
+
+@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)
@@ -58,22 +89,27 @@ MODEL_PRICING: Dict[str, ModelPricing] = {
     # OpenAI Models (pricing per 1000 tokens)
     OpenAIModels.GPT_5: ModelPricing(
         prompt_tokens_cost=0.00125,  # $0.00125 per 1000 tokens
+        cached_tokens_cost=0.000125,  # 90% discount for cached tokens
         completion_tokens_cost=0.01  # $0.01 per 1000 tokens
     ),
     OpenAIModels.GPT_5_MINI: ModelPricing(
         prompt_tokens_cost=0.00025,  # $0.00025 per 1000 tokens
+        cached_tokens_cost=0.000025,  # 90% discount for cached tokens
         completion_tokens_cost=0.002  # $0.002 per 1000 tokens
     ),
     OpenAIModels.GPT_5_NANO: ModelPricing(
         prompt_tokens_cost=0.00005,  # $0.00005 per 1000 tokens
+        cached_tokens_cost=0.000005,  # 90% discount for cached tokens
         completion_tokens_cost=0.0004  # $0.0004 per 1000 tokens
     ),
     OpenAIModels.GPT_5_CHAT_LATEST: ModelPricing(
         prompt_tokens_cost=0.00125,  # $0.00125 per 1000 tokens
+        cached_tokens_cost=0.000125,  # 90% discount for cached tokens
         completion_tokens_cost=0.01  # $0.01 per 1000 tokens
     ),
     OpenAIModels.GPT_5_CODEX: ModelPricing(
         prompt_tokens_cost=0.00125,  # $0.00125 per 1000 tokens
+        cached_tokens_cost=0.000125,  # 90% discount for cached tokens
         completion_tokens_cost=0.01  # $0.01 per 1000 tokens
     ),
     OpenAIModels.GPT_5_PRO: ModelPricing(
@@ -86,26 +122,32 @@ MODEL_PRICING: Dict[str, ModelPricing] = {
     ),
     OpenAIModels.GPT_4_1: ModelPricing(
         prompt_tokens_cost=0.002,  # $0.002 per 1000 tokens
+        cached_tokens_cost=0.0005,  # 50% discount for cached tokens
         completion_tokens_cost=0.008  # $0.008 per 1000 tokens
     ),
     OpenAIModels.GPT_4_1_MINI: ModelPricing(
         prompt_tokens_cost=0.0004,  # $0.0004 per 1000 tokens
+        cached_tokens_cost=0.0001,  # 50% discount for cached tokens
         completion_tokens_cost=0.0016  # $0.0016 per 1000 tokens
     ),
     OpenAIModels.GPT_4_1_NANO: ModelPricing(
         prompt_tokens_cost=0.0001,  # $0.0001 per 1000 tokens
+        cached_tokens_cost=0.000025,  # 50% discount for cached tokens
         completion_tokens_cost=0.0004  # $0.0004 per 1000 tokens
     ),
     OpenAIModels.GPT_4O: ModelPricing(
         prompt_tokens_cost=0.0025,  # $0.0025 per 1000 tokens
+        cached_tokens_cost=0.00125,  # 50% discount for cached tok
         completion_tokens_cost=0.01  # $0.01 per 1000 tokens
     ),
     OpenAIModels.GPT_4O_2024_05_13: ModelPricing(
         prompt_tokens_cost=0.005,  # $0.005 per 1000 tokens
+        cached_tokens_cost=0.0025,  # 50% discount for cached tokens
         completion_tokens_cost=0.015  # $0.015 per 1000 tokens
     ),
     OpenAIModels.GPT_4O_MINI: ModelPricing(
         prompt_tokens_cost=0.00015,  # $0.00015 per 1000 tokens
+        cached_tokens_cost=0.000075,  # 50% discount for cached tokens
         completion_tokens_cost=0.0006  # $0.0006 per 1000 tokens
     ),
     OpenAIModels.GPT_REALTIME: ModelPricing(
@@ -118,10 +160,12 @@ MODEL_PRICING: Dict[str, ModelPricing] = {
     ),
     OpenAIModels.GPT_4O_REALTIME_PREVIEW: ModelPricing(
         prompt_tokens_cost=0.005,  # $0.005 per 1000 tokens
+        cached_tokens_cost=0.0025,  # 50% discount for cached tokens
         completion_tokens_cost=0.02  # $0.02 per 1000 tokens
     ),
     OpenAIModels.GPT_4O_MINI_REALTIME_PREVIEW: ModelPricing(
         prompt_tokens_cost=0.0006,  # $0.0006 per 1000 tokens
+        cached_tokens_cost=0.0003,  # 50% discount for cached tokens
         completion_tokens_cost=0.0024  # $0.0024 per 1000 tokens
     ),
     OpenAIModels.GPT_AUDIO: ModelPricing(
@@ -482,4 +526,16 @@ MODEL_PRICING: Dict[str, ModelPricing] = {
         prompt_tokens_cost=0.000028,  # $0.000028 per 1000 tokens
         completion_tokens_cost=0.00042  # $0.00042 per 1000 tokens
     ),
+
+    # Moonshot AI / Kimi Models (pricing per 1000 tokens)
+    MoonshotAIModels.KIMI_K2_INSTRUCT_0905: ModelPricing(
+        prompt_tokens_cost=0.001,  # $0.001 per 1000 tokens
+        cached_tokens_cost=0.0005,  # $0.0005 per 1000 tokens (as specified)
+        completion_tokens_cost=0.003  # $0.003 per 1000 tokens
+    ),
+    MoonshotAIModels.KIMI_K2_0905_1T_256K: ModelPricing(
+        prompt_tokens_cost=0.001,  # $0.001 per 1000 tokens
+        # cached_tokens_cost not specified - model doesn't support cached tokens
+        completion_tokens_cost=0.003  # $0.003 per 1000 tokens
+    ),
 }