paygent-sdk 3.0.1__tar.gz → 4.0.0__tar.gz

{paygent_sdk-3.0.1/paygent_sdk.egg-info → paygent_sdk-4.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: paygent-sdk
-Version: 3.0.1
+Version: 4.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-3.0.1 → paygent_sdk-4.0.0}/paygent_sdk/__init__.py

@@ -8,8 +8,10 @@ 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
+    UsageData, UsageDataWithStrings, APIRequest,
+    SttUsageData, TtsUsageData,
+    RawUsageData, SendUsageV2Response, CostBreakdown,
+    Customer, CustomerCreateOrGetRequest
 )
 from .voice_client import send_stt_usage, send_tts_usage  # Import to attach methods to Client
 
@@ -50,14 +52,17 @@ __all__ = [
     "UsageData", 
     "UsageDataWithStrings", 
     "APIRequest", 
-    "ModelPricing",
-    "MODEL_PRICING",
     
     # Voice data models
     "SttUsageData",
     "TtsUsageData",
-    "SttModelPricing",
-    "TtsModelPricing",
+    
+    # New V2 & Customer models
+    "RawUsageData",
+    "SendUsageV2Response",
+    "CostBreakdown",
+    "Customer",
+    "CustomerCreateOrGetRequest",
     
     # Wrappers
     "PaygentOpenAI",

{paygent_sdk-3.0.1 → paygent_sdk-4.0.0}/paygent_sdk/client.py

@@ -17,7 +17,16 @@ try:
 except ImportError:
     tiktoken = None
 
-from .models import UsageData, UsageDataWithStrings, APIRequest, ModelPricing, MODEL_PRICING
+from .models import (
+    UsageData,
+    UsageDataWithStrings,
+    APIRequest,
+    RawUsageData,
+    SendUsageV2Response,
+    CostBreakdown,
+    Customer,
+    CustomerCreateOrGetRequest,
+)
 
 
 class Client:
@@ -79,52 +88,6 @@ class Client:
         """
         return cls(api_key)
 
-    def _calculate_cost(self, model: str, usage_data: UsageData) -> float:
-        """
-        Calculate the cost based on model and usage data.
-        
-        Args:
-            model: The AI model name
-            usage_data: Usage data containing token counts
-            
-        Returns:
-            Calculated cost in USD
-        """
-        pricing = MODEL_PRICING.get(model)
-        if not pricing:
-            self.logger.warning(f"Unknown model '{model}', using default pricing")
-            # Use default pricing for unknown models (per 1000 tokens)
-            pricing = ModelPricing(
-                prompt_tokens_cost=0.0001,  # $0.10 per 1000 tokens
-                completion_tokens_cost=0.0001  # $0.10 per 1000 tokens
-            )
-
-        # 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 + 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}"
-        )
-
-        return total_cost
 
     def send_usage(
         self, 
@@ -174,67 +137,6 @@ class Client:
         # Cost calculated (no logging for performance)
 
         # Prepare API request
-        api_request = APIRequest(
-            agent_id=agent_id,
-            customer_id=customer_id,
-            indicator=indicator,
-            amount=cost
-        )
-
-        # Prepare request data
-        request_data = {
-            "agentId": api_request.agent_id,
-            "customerId": api_request.customer_id,
-            "indicator": api_request.indicator,
-            "amount": api_request.amount,
-            "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
-        }
-
-        self.logger.debug(f"API request body: {json.dumps(request_data)}")
-
-        # Create HTTP request
-        url = urljoin(self.base_url, "/api/v1/usage")
-        
-        headers = {
-            "Content-Type": "application/json",
-            "paygent-api-key": self.api_key
-        }
-
-        self.logger.debug(f"Making HTTP POST request to: {url}")
-
-        try:
-            # Make HTTP request
-            response = self.session.post(
-                url,
-                json=request_data,
-                headers=headers,
-                timeout=30
-            )
-            
-            self.logger.debug(
-                f"API response status: {response.status_code}, "
-                f"body: {response.text}"
-            )
-
-            # Check response status
-            if 200 <= response.status_code < 300:
-                # Success - no logging to minimize verbosity
-                return
-
-            # Handle error response
-            self.logger.error(
-                f"API request failed with status {response.status_code}: {response.text}"
-            )
-            response.raise_for_status()
-
-        except requests.RequestException as e:
-            self.logger.error(f"HTTP request failed: {e}")
-            raise
-
     def set_log_level(self, level: int) -> None:
         """
         Set the logging level for the client.
@@ -339,38 +241,34 @@ class Client:
         word_count = len(text.split())
         return int(word_count * 1.3)
 
-    def _calculate_cost_from_strings(self, model: str, usage_data: UsageDataWithStrings) -> float:
+    def send_usage(
+        self, 
+        agent_id: str, 
+        customer_id: str, 
+        indicator: str, 
+        usage_data: UsageData
+    ) -> None:
         """
-        Calculate the cost based on model and usage data with strings.
+        Send usage data to the Paygent API.
+        This legacy method now internally uses the V2 API for server-side pricing.
         
         Args:
-            model: The AI model name
-            usage_data: Usage data containing prompt and output strings
+            agent_id: Unique identifier for the agent
+            customer_id: Unique identifier for the customer
+            indicator: Indicator for the usage event
+            usage_data: Usage data containing model and token information
             
-        Returns:
-            Calculated cost in USD
+        Raises:
+            requests.RequestException: If the HTTP request fails
         """
-        # Count tokens
-        prompt_tokens = self._get_token_count(model, usage_data.prompt_string)
-        completion_tokens = self._get_token_count(model, usage_data.output_string)
-        total_tokens = prompt_tokens + completion_tokens
-
-        self.logger.debug(
-            f"Token counting for model '{model}': "
-            f"prompt_tokens={prompt_tokens}, completion_tokens={completion_tokens}, "
-            f"total_tokens={total_tokens}"
-        )
-
-        # Create UsageData for cost calculation
-        usage_data_obj = UsageData(
-            service_provider=usage_data.service_provider,
-            model=model,
-            prompt_tokens=prompt_tokens,
-            completion_tokens=completion_tokens,
-            total_tokens=total_tokens
+        raw_usage = RawUsageData(
+            provider=usage_data.service_provider,
+            model=usage_data.model,
+            input_tokens=usage_data.prompt_tokens,
+            output_tokens=usage_data.completion_tokens,
+            cached_tokens=usage_data.cached_tokens
         )
-
-        return self._calculate_cost(model, usage_data_obj)
+        self.send_usage_v2(agent_id, customer_id, indicator, raw_usage)
 
     def send_usage_with_token_string(
         self, 
@@ -381,7 +279,8 @@ class Client:
     ) -> None:
         """
         Send usage data to the Paygent API using prompt and output strings.
-        The function automatically counts tokens using proper tokenizers for each model provider and calculates costs.
+        The function automatically counts tokens using proper tokenizers for each model provider.
+        This method now internally uses the V2 API for server-side pricing.
         
         Args:
             agent_id: Unique identifier for the agent
@@ -393,54 +292,73 @@ class Client:
             requests.RequestException: If the HTTP request fails
             ValueError: If the usage data is invalid
         """
-        # Removed verbose logging - only log errors
-        # Calculate cost from strings
-        try:
-            cost = self._calculate_cost_from_strings(usage_data.model, usage_data)
-        except Exception as e:
-            self.logger.error(f"Failed to calculate cost from strings: {e}")
-            raise ValueError(f"Failed to calculate cost from strings: {e}") from e
-
-        # 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)
         completion_tokens = self._get_token_count(usage_data.model, usage_data.output_string)
 
-        # Prepare API request
-        api_request = APIRequest(
-            agent_id=agent_id,
-            customer_id=customer_id,
-            indicator=indicator,
-            amount=cost
+        raw_usage = RawUsageData(
+            provider=usage_data.service_provider,
+            model=usage_data.model,
+            input_tokens=prompt_tokens,
+            output_tokens=completion_tokens
         )
-
+        self.send_usage_v2(agent_id, customer_id, indicator, raw_usage)
+
+    def send_usage_v2(
+        self,
+        agent_id: str,
+        customer_id: str,
+        indicator: str,
+        raw_usage: RawUsageData
+    ) -> SendUsageV2Response:
+        """
+        Send usage data to the Paygent API v2 (backend-calculated pricing).
+        
+        Args:
+            agent_id: Unique identifier for the agent
+            customer_id: Unique identifier for the customer
+            indicator: Indicator for the usage event
+            raw_usage: Raw usage data including model, provider, tokens, etc.
+            
+        Returns:
+            SendUsageV2Response containing cost breakdown and model metadata
+            
+        Raises:
+            requests.RequestException: If the HTTP request fails
+        """
+        self.logger.debug(f"Sending V2 usage data for model: {raw_usage.model}")
+        
         # Prepare request data
         request_data = {
-            "agentId": api_request.agent_id,
-            "customerId": api_request.customer_id,
-            "indicator": api_request.indicator,
-            "amount": api_request.amount,
-            "inputToken": prompt_tokens,
-            "outputToken": completion_tokens,
-            "model": usage_data.model,
-            "serviceProvider": usage_data.service_provider
+            "agentId": agent_id,
+            "customerId": customer_id,
+            "indicator": indicator,
+            "rawUsage": {
+                "provider": raw_usage.provider,
+                "model": raw_usage.model,
+            }
         }
-
-        self.logger.debug(f"API request body: {json.dumps(request_data)}")
-
-        # Create HTTP request
-        url = urljoin(self.base_url, "/api/v1/usage")
         
+        # Add optional fields
+        if raw_usage.input_tokens is not None:
+            request_data["rawUsage"]["inputTokens"] = raw_usage.input_tokens
+        if raw_usage.output_tokens is not None:
+            request_data["rawUsage"]["outputTokens"] = raw_usage.output_tokens
+        if raw_usage.cached_tokens is not None:
+            request_data["rawUsage"]["cachedTokens"] = raw_usage.cached_tokens
+        if raw_usage.audio_duration is not None:
+            request_data["rawUsage"]["audioDuration"] = raw_usage.audio_duration
+        if raw_usage.character_count is not None:
+            request_data["rawUsage"]["characterCount"] = raw_usage.character_count
+        
+        # Create HTTP request
+        url = urljoin(self.base_url, "/api/v2/usage")
         headers = {
             "Content-Type": "application/json",
             "paygent-api-key": self.api_key
         }
-
-        self.logger.debug(f"Making HTTP POST request to: {url}")
-
+        
         try:
-            # Make HTTP request
             response = self.session.post(
                 url,
                 json=request_data,
@@ -449,21 +367,127 @@ class Client:
             )
             
             self.logger.debug(
-                f"API response status: {response.status_code}, "
+                f"V2 API response status: {response.status_code}, "
                 f"body: {response.text}"
             )
+            
+            response.raise_for_status()
+            
+            # Parse response
+            response_data = response.json()
+            self.logger.info("V2 usage data sent successfully")
+            
+            # Parse breakdown
+            breakdown_data = response_data.get("breakdown", {})
+            breakdown = CostBreakdown(
+                input_cost=breakdown_data.get("inputCost", 0.0),
+                output_cost=breakdown_data.get("outputCost", 0.0),
+                cached_cost=breakdown_data.get("cachedCost", 0.0),
+                audio_cost=breakdown_data.get("audioCost", 0.0),
+                total_cost=breakdown_data.get("totalCost", 0.0)
+            )
+            
+            return SendUsageV2Response(
+                cp_data_id=response_data.get("cpDataId", ""),
+                calculated_cost=response_data.get("calculatedCost", 0.0),
+                breakdown=breakdown,
+                model_metadata=response_data.get("modelMetadata", {})
+            )
+            
+        except requests.RequestException as e:
+            self.logger.error(f"Failed to send V2 usage data: {e}")
+            raise
 
-            # Check response status
-            if 200 <= response.status_code < 300:
-                # Success - no logging to minimize verbosity
-                return
-
-            # Handle error response
-            self.logger.error(
-                f"API request failed with status {response.status_code}: {response.text}"
+    def create_or_get_customer(self, request: CustomerCreateOrGetRequest) -> Customer:
+        """
+        Create a customer if they don't exist, or return the existing customer.
+        This method is idempotent - calling it multiple times with the same external_id will return the same customer.
+        
+        Args:
+            request: Customer creation request with required name and external_id
+            
+        Returns:
+            The created or existing customer
+            
+        Raises:
+            ValueError: If validation fails
+            requests.RequestException: If the HTTP request fails
+        """
+        # Validate required fields
+        if not request.name or request.name.strip() == '':
+            self.logger.error('Validation failed: Customer name is required')
+            raise ValueError('Customer name is required')
+        
+        if not request.external_id or request.external_id.strip() == '':
+            self.logger.error('Validation failed: Customer external_id is required')
+            raise ValueError('Customer external_id is required')
+        
+        self.logger.debug(f"Creating or getting customer with external_id: {request.external_id}")
+        
+        try:
+            # Prepare request data
+            request_data = {
+                "name": request.name,
+                "externalId": request.external_id,
+            }
+            
+            # Add optional fields
+            if request.email:
+                request_data["email"] = request.email
+            if request.website:
+                request_data["website"] = request.website
+            if request.phone:
+                request_data["phone"] = request.phone
+            if request.address_line1:
+                request_data["addressLine1"] = request.address_line1
+            if request.address_line2:
+                request_data["addressLine2"] = request.address_line2
+            if request.city:
+                request_data["city"] = request.city
+            if request.state:
+                request_data["state"] = request.state
+            if request.zip_code:
+                request_data["zipCode"] = request.zip_code
+            if request.country:
+                request_data["country"] = request.country
+            
+            # Call create-or-get endpoint
+            url = urljoin(self.base_url, "/api/v1/customers/create-or-get")
+            headers = {
+                "Content-Type": "application/json",
+                "paygent-api-key": self.api_key
+            }
+            
+            response = self.session.post(
+                url,
+                json=request_data,
+                headers=headers,
+                timeout=30
             )
+            
             response.raise_for_status()
-
+            
+            # Parse response
+            response_data = response.json()
+            self.logger.info(f"Customer created/retrieved successfully with external_id: {request.external_id}")
+            
+            return Customer(
+                id=response_data.get("id", ""),
+                external_id=response_data.get("externalId", ""),
+                name=response_data.get("name", ""),
+                email=response_data.get("email"),
+                website=response_data.get("website"),
+                phone=response_data.get("phone"),
+                address_line1=response_data.get("addressLine1"),
+                address_line2=response_data.get("addressLine2"),
+                city=response_data.get("city"),
+                state=response_data.get("state"),
+                zip_code=response_data.get("zipCode"),
+                country=response_data.get("country"),
+                created_at=response_data.get("createdAt"),
+                updated_at=response_data.get("updatedAt")
+            )
+            
         except requests.RequestException as e:
-            self.logger.error(f"HTTP request failed: {e}")
+            self.logger.error(f"Failed to create or get customer: {e}")
             raise