payi 0.1.0a133__py3-none-any.whl → 0.1.0a134__py3-none-any.whl

payi/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "payi"
-__version__ = "0.1.0-alpha.133"  # x-release-please-version
+__version__ = "0.1.0-alpha.134"  # x-release-please-version

payi/lib/AnthropicInstrumentor.py

@@ -195,15 +195,26 @@ class _AnthropicProviderRequest(_ProviderRequest):
 
         return None
 
+    def _update_resource_name(self, model: str) -> str:
+        return ("anthropic." if self._is_vertex else "") + model
+
     @override
-    def process_request(self, instance: Any, extra_headers: 'dict[str, str]', args: Sequence[Any], kwargs: Any) -> bool:
-        self._ingest["resource"] = ("anthropic." if self._is_vertex else "") + kwargs.get("model", "")
+    def process_request(self, instance: Any, extra_headers: 'dict[str, str]',  args: Sequence[Any], kwargs: Any) -> bool:
+        self._ingest["resource"] = self._update_resource_name(kwargs.get("model", ""))
+
+        if self._price_as.resource_scope:
+            self._ingest["resource_scope"] = self._price_as.resource_scope
+        
+        # override defaults
+        if self._price_as.category:
+            self._ingest["category"] = self._price_as.category
+        if self._price_as.resource:
+            self._ingest["resource"] = self._update_resource_name(self._price_as.resource)
 
         self._instrumentor._logger.debug(f"Processing anthropic request: model {self._ingest['resource']}, category {self._category}")
 
         messages = kwargs.get("messages")
         if messages:
-
             anthropic_has_image_and_get_texts(self, messages)
 
         return True

payi/lib/BedrockInstrumentor.py

@@ -1,6 +1,6 @@
 import os
 import json
-from typing import TYPE_CHECKING, Any, Optional, Sequence
+from typing import TYPE_CHECKING, Any, Dict, Optional, Sequence
 from functools import wraps
 from typing_extensions import override
 
@@ -12,6 +12,7 @@ from payi.types.pay_i_common_models_api_router_header_info_param import PayIComm
 
 from .instrument import (
     PayiInstrumentAwsBedrockConfig,
+    _Context,
     _ChunkResult,
     _IsStreaming,
     _StreamingType,
@@ -35,8 +36,31 @@ class BedrockInstrumentor:
 
     _guardrail_trace: bool = True
 
+    _model_mapping: Dict[str, _Context] = {}
+
+    @staticmethod
+    def get_mapping(model_id: Optional[str]) -> _Context:
+        if not model_id:
+            return  {}
+
+        return BedrockInstrumentor._model_mapping.get(model_id, {})
+
+    @staticmethod
+    def configure(aws_config: Optional[PayiInstrumentAwsBedrockConfig]) -> None:
+        if not aws_config:
+            return
+        
+        trace = aws_config.get("guardrail_trace", True)
+        if trace is None:
+            trace = True
+        BedrockInstrumentor._guardrail_trace = trace
+
+        model_mappings = aws_config.get("model_mappings", [])
+        if model_mappings:
+            BedrockInstrumentor._model_mapping = _PayiInstrumentor._model_mapping_to_context_dict(model_mappings)
+
     @staticmethod
-    def instrument(instrumentor: _PayiInstrumentor, aws_config: Optional[PayiInstrumentAwsBedrockConfig]) -> None:
+    def instrument(instrumentor: _PayiInstrumentor) -> None:
         BedrockInstrumentor._instrumentor = instrumentor
 
         BedrockInstrumentor._module_version = get_version_helper(BedrockInstrumentor._module_name)
@@ -58,9 +82,6 @@ class BedrockInstrumentor:
             instrumentor._logger.debug(f"Error instrumenting bedrock: {e}")
             return
 
-        if aws_config:
-            BedrockInstrumentor._guardrail_trace = aws_config.get("guardrail_trace", True)
-
 @_PayiInstrumentor.payi_wrapper
 def create_client_wrapper(instrumentor: _PayiInstrumentor, wrapped: Any, instance: Any, *args: Any, **kwargs: Any) -> Any: #  noqa: ARG001
     if kwargs.get("service_name") != "bedrock-runtime":
@@ -69,10 +90,10 @@ def create_client_wrapper(instrumentor: _PayiInstrumentor, wrapped: Any, instanc
 
     try:
         client: Any = wrapped(*args, **kwargs)
-        client.invoke_model = wrap_invoke(instrumentor, client.invoke_model)
-        client.invoke_model_with_response_stream = wrap_invoke_stream(instrumentor, client.invoke_model_with_response_stream)
-        client.converse = wrap_converse(instrumentor, client.converse)
-        client.converse_stream = wrap_converse_stream(instrumentor, client.converse_stream)
+        client.invoke_model = wrap_invoke(instrumentor, client.invoke_model, client)
+        client.invoke_model_with_response_stream = wrap_invoke_stream(instrumentor, client.invoke_model_with_response_stream, client)
+        client.converse = wrap_converse(instrumentor, client.converse, client)
+        client.converse_stream = wrap_converse_stream(instrumentor, client.converse_stream, client)
 
         instrumentor._logger.debug(f"Instrumented bedrock client")
 
@@ -221,7 +242,7 @@ class InvokeResponseWrapper(ObjectProxy): # type: ignore
 
         return data # type: ignore
 
-def wrap_invoke(instrumentor: _PayiInstrumentor, wrapped: Any) -> Any:
+def wrap_invoke(instrumentor: _PayiInstrumentor, wrapped: Any, instance: Any) -> Any:
     @wraps(wrapped)
     def invoke_wrapper(*args: Any, **kwargs: 'dict[str, Any]') -> Any:
         modelId:str = kwargs.get("modelId", "") # type: ignore
@@ -230,14 +251,14 @@ def wrap_invoke(instrumentor: _PayiInstrumentor, wrapped: Any) -> Any:
             _BedrockInvokeProviderRequest(instrumentor=instrumentor, model_id=modelId),
             _IsStreaming.false,
             wrapped,
-            None,
+            instance,
             args,
             kwargs,
         )   
     
     return invoke_wrapper
 
-def wrap_invoke_stream(instrumentor: _PayiInstrumentor, wrapped: Any) -> Any:
+def wrap_invoke_stream(instrumentor: _PayiInstrumentor, wrapped: Any, instance: Any) -> Any:
     @wraps(wrapped)
     def invoke_wrapper(*args: Any, **kwargs: Any) -> Any:
         modelId: str = kwargs.get("modelId", "") # type: ignore
@@ -247,14 +268,14 @@ def wrap_invoke_stream(instrumentor: _PayiInstrumentor, wrapped: Any) -> Any:
             _BedrockInvokeProviderRequest(instrumentor=instrumentor, model_id=modelId),
             _IsStreaming.true,
             wrapped,
-            None,
+            instance,
             args,
             kwargs,
         )
 
     return invoke_wrapper
 
-def wrap_converse(instrumentor: _PayiInstrumentor, wrapped: Any) -> Any:
+def wrap_converse(instrumentor: _PayiInstrumentor, wrapped: Any, instance: Any) -> Any:
     @wraps(wrapped)
     def invoke_wrapper(*args: Any, **kwargs: 'dict[str, Any]') -> Any:
         modelId:str = kwargs.get("modelId", "") # type: ignore
@@ -264,14 +285,14 @@ def wrap_converse(instrumentor: _PayiInstrumentor, wrapped: Any) -> Any:
             _BedrockConverseProviderRequest(instrumentor=instrumentor),
             _IsStreaming.false,
             wrapped,
-            None,
+            instance,
             args,
             kwargs,
         )
     
     return invoke_wrapper
 
-def wrap_converse_stream(instrumentor: _PayiInstrumentor, wrapped: Any) -> Any:
+def wrap_converse_stream(instrumentor: _PayiInstrumentor, wrapped: Any, instance: Any) -> Any:
     @wraps(wrapped)
     def invoke_wrapper(*args: Any, **kwargs: Any) -> Any:
         modelId: str = kwargs.get("modelId", "") # type: ignore
@@ -281,7 +302,7 @@ def wrap_converse_stream(instrumentor: _PayiInstrumentor, wrapped: Any) -> Any:
             _BedrockConverseProviderRequest(instrumentor=instrumentor),
             _IsStreaming.true,
             wrapped,
-            None,
+            instance,
             args,
             kwargs,
         )
@@ -301,10 +322,25 @@ class _BedrockProviderRequest(_ProviderRequest):
             )
 
     @override
-    def process_request(self, instance: Any, extra_headers: 'dict[str, str]', args: Sequence[Any], kwargs: Any) -> bool:
-        # boto3 doesn't allow extra_headers
-        kwargs.pop("extra_headers", None)
-        self._ingest["resource"] = kwargs.get("modelId", "")
+    def process_request(self, instance: Any, extra_headers: 'dict[str, str]',  args: Sequence[Any], kwargs: Any) -> bool:
+        modelId =  kwargs.get("modelId", "")
+        self._ingest["resource"] = modelId
+
+        if not self._price_as.resource and not self._price_as.category and BedrockInstrumentor._model_mapping:
+            deployment = BedrockInstrumentor._model_mapping.get(modelId, {})
+            self._price_as.category = deployment.get("price_as_category", "")
+            self._price_as.resource = deployment.get("price_as_resource", "")
+            self._price_as.resource_scope = deployment.get("resource_scope", None)
+
+        if self._price_as.resource_scope:
+            self._ingest["resource_scope"] = self._price_as.resource_scope
+        
+        # override defaults
+        if self._price_as.category:
+            self._ingest["category"] = self._price_as.category
+        if self._price_as.resource:
+            self._ingest["resource"] = self._price_as.resource
+
         return True
 
     @override
@@ -384,11 +420,25 @@ class _BedrockProviderRequest(_ProviderRequest):
 class _BedrockInvokeProviderRequest(_BedrockProviderRequest):
     def __init__(self, instrumentor: _PayiInstrumentor, model_id: str):
         super().__init__(instrumentor=instrumentor)
-        self._is_anthropic: bool = 'anthropic' in model_id
-        self._is_nova: bool = 'nova' in model_id
-        self._is_meta: bool = 'meta' in model_id
-        self._is_amazon_titan_embed_text_v1: bool = 'amazon.titan-embed-text-v1' == model_id
-        self._is_cohere_embed_english_v3: bool = 'cohere.embed-english-v3' == model_id
+
+        price_as_resource = BedrockInstrumentor._model_mapping.get(model_id, {}).get("price_as_resource", None)
+        if price_as_resource:
+            model_id = price_as_resource
+
+        self._is_anthropic: bool = False
+        self._is_nova: bool = False
+        self._is_meta: bool = False
+        self._is_amazon_titan_embed_text_v1: bool = False
+        self._is_cohere_embed_english_v3: bool = False
+
+        self._assign_model_state(model_id=model_id)
+
+    def _assign_model_state(self, model_id: str) -> None:
+        self._is_anthropic = 'anthropic' in model_id
+        self._is_nova = 'nova' in model_id
+        self._is_meta = 'meta' in model_id
+        self._is_amazon_titan_embed_text_v1 = 'amazon.titan-embed-text-v1' == model_id
+        self._is_cohere_embed_english_v3 = 'cohere.embed-english-v3' == model_id
 
     @override
     def process_request(self, instance: Any, extra_headers: 'dict[str, str]', args: Sequence[Any], kwargs: Any) -> bool:
@@ -396,6 +446,10 @@ class _BedrockInvokeProviderRequest(_BedrockProviderRequest):
 
         super().process_request(instance, extra_headers, args, kwargs)
     
+        # super().process_request will assign price_as mapping from global state, so evaluate afterwards
+        if self._price_as.resource:
+            self._assign_model_state(model_id=self._price_as.resource)
+
         guardrail_id = kwargs.get("guardrailIdentifier", "")
         if guardrail_id:
             self.add_internal_request_property(PayiPropertyNames.aws_bedrock_guardrail_id, guardrail_id)
@@ -524,7 +578,7 @@ class _BedrockConverseProviderRequest(_BedrockProviderRequest):
     @override
     def process_request(self, instance: Any, extra_headers: 'dict[str, str]', args: Sequence[Any], kwargs: Any) -> bool:
         super().process_request(instance, extra_headers, args, kwargs)
-        
+
         guardrail_config = kwargs.get("guardrailConfig", {})
         if guardrail_config:
             guardrailIdentifier = guardrail_config.get("guardrailIdentifier", "")

payi/lib/OpenAIInstrumentor.py

@@ -1,15 +1,23 @@
 import json
-from typing import Any, Union, Optional, Sequence
+from typing import Any, Dict, Union, Optional, Sequence
 from typing_extensions import override
 from importlib.metadata import version
 
 import tiktoken  # type: ignore
 from wrapt import wrap_function_wrapper  # type: ignore
 
-from payi.lib.helpers import PayiCategories, PayiHeaderNames
+from payi.lib.helpers import PayiCategories
 from payi.types.ingest_units_params import Units
 
-from .instrument import _ChunkResult, _IsStreaming, _StreamingType, _ProviderRequest, _PayiInstrumentor
+from .instrument import (
+    PayiInstrumentAzureOpenAiConfig,
+    _Context,
+    _ChunkResult,
+    _IsStreaming,
+    _StreamingType,
+    _ProviderRequest,
+    _PayiInstrumentor,
+)
 from .version_helper import get_version_helper
 
 
@@ -17,12 +25,20 @@ class OpenAiInstrumentor:
     _module_name: str = "openai"
     _module_version: str = ""
 
+    _azure_openai_deployments: Dict[str, _Context] = {}
+
     @staticmethod
     def is_azure(instance: Any) -> bool:
         from openai import AzureOpenAI, AsyncAzureOpenAI # type: ignore # noqa: I001
 
         return isinstance(instance._client, (AsyncAzureOpenAI, AzureOpenAI))
 
+    @staticmethod
+    def configure(azure_openai_config: Optional[PayiInstrumentAzureOpenAiConfig]) -> None:
+        if azure_openai_config:
+            model_mappings = azure_openai_config.get("model_mappings", [])
+            OpenAiInstrumentor._azure_openai_deployments = _PayiInstrumentor._model_mapping_to_context_dict(model_mappings)
+
     @staticmethod
     def instrument(instrumentor: _PayiInstrumentor) -> None:
         try:
@@ -52,7 +68,7 @@ class OpenAiInstrumentor:
                 aembeddings_wrapper(instrumentor),
             )
         except Exception as e:
-            instrumentor._logger.debug(f"Error instrumenting openai: {e}")
+            instrumentor._logger.debug(f"Error instrumenting openai completions: {e}")
 
         # responses separately as they are relatively new and the client may not be using the latest openai module
         try:            
@@ -69,7 +85,7 @@ class OpenAiInstrumentor:
             )
 
         except Exception as e:
-            instrumentor._logger.debug(f"Error instrumenting openai: {e}")
+            instrumentor._logger.debug(f"Error instrumenting openai responses: {e}")
 
 @_PayiInstrumentor.payi_wrapper
 def embeddings_wrapper(
@@ -201,44 +217,39 @@ class _OpenAiProviderRequest(_ProviderRequest):
         self._input_tokens_details_key = input_tokens_details_key
 
     @override
-    def process_request(self, instance: Any, extra_headers: 'dict[str, str]', args: Sequence[Any], kwargs: Any) -> bool: # type: ignore
-        self._ingest["resource"] = kwargs.get("model", "")
+    def process_request(self, instance: Any, extra_headers: 'dict[str, str]',  args: Sequence[Any], kwargs: Any) -> bool: # type: ignore
+        model = kwargs.get("model", "")
 
         if not (instance and hasattr(instance, "_client")) or OpenAiInstrumentor.is_azure(instance) is False:
+            self._ingest["resource"] = model
             return True
 
-        context = self._instrumentor.get_context_safe()
-        price_as_category = extra_headers.get(PayiHeaderNames.price_as_category) or context.get("price_as_category")
-        price_as_resource = extra_headers.get(PayiHeaderNames.price_as_resource) or context.get("price_as_resource")
-        resource_scope = extra_headers.get(PayiHeaderNames.resource_scope) or context.get("resource_scope")
-
-        if PayiHeaderNames.price_as_category in extra_headers:
-            del extra_headers[PayiHeaderNames.price_as_category]
-        if PayiHeaderNames.price_as_resource in extra_headers:
-            del extra_headers[PayiHeaderNames.price_as_resource]
-        if PayiHeaderNames.resource_scope in extra_headers:
-            del extra_headers[PayiHeaderNames.resource_scope]
-            
-        if not price_as_resource and not price_as_category:
+        if not self._price_as.resource and not self._price_as.category and OpenAiInstrumentor._azure_openai_deployments:
+            deployment = OpenAiInstrumentor._azure_openai_deployments.get(model, {})
+            self._price_as.category = deployment.get("price_as_category", None)
+            self._price_as.resource = deployment.get("price_as_resource", None)
+            self._price_as.resource_scope = deployment.get("resource_scope", None)
+
+        if not self._price_as.resource and not self._price_as.category:
             self._instrumentor._logger.error("Azure OpenAI requires price as resource and/or category to be specified, not ingesting")
             return False
 
-        if resource_scope:
-            if not(resource_scope in ["global", "datazone"] or resource_scope.startswith("region")):
+        if self._price_as.resource_scope:
+            if not (self._price_as.resource_scope in ["global", "datazone"] or self._price_as.resource_scope.startswith("region")):
                 self._instrumentor._logger.error("Azure OpenAI invalid resource scope, not ingesting")
                 return False
 
-            self._ingest["resource_scope"] = resource_scope
+            self._ingest["resource_scope"] = self._price_as.resource_scope
 
         self._category = PayiCategories.azure_openai
 
         self._ingest["category"] = self._category
 
-        if price_as_category:
+        if self._price_as.category:
             # price as category overrides default
-            self._ingest["category"] = price_as_category
-        if price_as_resource:
-            self._ingest["resource"] = price_as_resource
+            self._ingest["category"] = self._price_as.category
+        if self._price_as.resource:
+            self._ingest["resource"] = self._price_as.resource
 
         return True
 

payi/lib/helpers.py

@@ -1,15 +1,18 @@
 import os
-from typing import Dict, List, Union
+import json
+from typing import Any, Dict, List, Union
 
 PAYI_BASE_URL = "https://api.pay-i.com"
 
 class PayiHeaderNames:
     limit_ids:str  = "xProxy-Limit-IDs"
     request_tags:str = "xProxy-Request-Tags"
+    request_properties:str = "xProxy-Request-Properties"
     use_case_id:str = "xProxy-UseCase-ID"
     use_case_name:str = "xProxy-UseCase-Name"
     use_case_version:str = "xProxy-UseCase-Version"
     use_case_step:str = "xProxy-UseCase-Step"
+    use_case_properties:str = "xProxy-UseCase-Properties"
     user_id:str = "xProxy-User-ID"
     account_name:str = "xProxy-Account-Name"
     price_as_category:str = "xProxy-PriceAs-Category"
@@ -37,6 +40,11 @@ class PayiPropertyNames:
     aws_bedrock_guardrail_version:str = "system.aws.bedrock.guardrail.version"
     aws_bedrock_guardrail_action:str = "system.aws.bedrock.guardrail.action"
 
+class PayiResourceScopes:
+    global_scope: str = "global"
+    datazone_scope: str = "datazone"
+    region_scope: str = "region"
+
 def create_limit_header_from_ids(*, limit_ids: List[str]) -> Dict[str, str]:
     if not isinstance(limit_ids, list):  # type: ignore
         raise TypeError("limit_ids must be a list")
@@ -53,6 +61,9 @@ def create_request_header_from_tags(*, request_tags: List[str]) -> Dict[str, str
 
     return { PayiHeaderNames.request_tags: ",".join(valid_tags) } if valid_tags else {}
 
+def _compact_json(data: Any) -> str:
+    return json.dumps(data, separators=(',', ':'))  
+
 def create_headers(
     *,
     limit_ids: Union[List[str], None] = None,
@@ -63,6 +74,8 @@ def create_headers(
     use_case_name: Union[str, None] = None,
     use_case_version: Union[int, None] = None,
     use_case_step: Union[str, None] = None,
+    use_case_properties: Union[Dict[str, str], None] = None,
+    request_properties: Union[Dict[str, str], None] = None,
     price_as_category: Union[str, None] = None,
     price_as_resource: Union[str, None] = None,
     resource_scope: Union[str, None] = None,
@@ -83,6 +96,10 @@ def create_headers(
         headers.update({ PayiHeaderNames.use_case_name: use_case_name})
     if use_case_version:
         headers.update({ PayiHeaderNames.use_case_version: str(use_case_version)})
+    if use_case_properties:
+        headers.update({ PayiHeaderNames.use_case_properties: _compact_json(use_case_properties) })
+    if request_properties:
+        headers.update({ PayiHeaderNames.request_properties: _compact_json(request_properties) })
     if use_case_step:
         headers.update({ PayiHeaderNames.use_case_step: use_case_step})
     if price_as_category:

payi/lib/instrument.py

@@ -19,7 +19,7 @@ from wrapt import ObjectProxy  # type: ignore
 
 from payi import Payi, AsyncPayi, APIStatusError, APIConnectionError, __version__ as _payi_version
 from payi.types import IngestUnitsParams
-from payi.lib.helpers import PayiHeaderNames, PayiPropertyNames
+from payi.lib.helpers import PayiHeaderNames, PayiPropertyNames, _compact_json
 from payi.types.shared import XproxyResult
 from payi.types.ingest_response import IngestResponse
 from payi.types.ingest_units_params import Units, ProviderResponseFunctionCall
@@ -36,7 +36,13 @@ _g_logger: logging.Logger = logging.getLogger("payi.instrument")
 class _ChunkResult:
     send_chunk_to_caller: bool
     ingest: bool = False
-    
+
+@dataclass
+class PriceAs:
+    category: Optional[str]
+    resource: Optional[str]
+    resource_scope: Optional[str]
+
 class _ProviderRequest:
     def __init__(
             self, 
@@ -62,6 +68,7 @@ class _ProviderRequest:
         self._function_calls: Optional[list[ProviderResponseFunctionCall]] = None
         self._is_large_context: bool = False
         self._internal_request_properties: dict[str, Optional[str]] = {}
+        self._price_as: PriceAs = PriceAs(category=None, resource=None, resource_scope=None)
 
     def process_chunk(self, _chunk: Any) -> _ChunkResult:
         return _ChunkResult(send_chunk_to_caller=True)
@@ -147,8 +154,20 @@ class _ProviderRequest:
             self._ingest["provider_response_function_calls"] = self._function_calls
         self._function_calls.append(ProviderResponseFunctionCall(name=name, arguments=arguments))
 
+class PayiInstrumentModelMapping(TypedDict, total=False):
+    model: str
+    price_as_category: Optional[str]
+    price_as_resource: Optional[str]
+    # "global", "datazone", "region", "region.<region_name>"
+    resource_scope: Optional[str]   
+
 class PayiInstrumentAwsBedrockConfig(TypedDict, total=False):
-    guardrail_trace: bool
+    guardrail_trace: Optional[bool]
+    model_mappings: Optional[Sequence[PayiInstrumentModelMapping]]
+
+class PayiInstrumentAzureOpenAiConfig(TypedDict, total=False):
+    # map deployment name known model
+    model_mappings: Sequence[PayiInstrumentModelMapping] 
 
 class PayiInstrumentOfflineInstrumentationConfig(TypedDict, total=False):
     file_name: str
@@ -168,6 +187,7 @@ class PayiInstrumentConfig(TypedDict, total=False):
     request_tags: Optional["list[str]"]
     request_properties: Optional["dict[str, Optional[str]]"]
     aws_config: Optional[PayiInstrumentAwsBedrockConfig]
+    azure_openai_config: Optional[PayiInstrumentAzureOpenAiConfig]
     offline_instrumentation: Optional[PayiInstrumentOfflineInstrumentationConfig]
 
 class PayiContext(TypedDict, total=False):
@@ -186,6 +206,19 @@ class PayiContext(TypedDict, total=False):
     resource_scope: Optional[str]
     last_result: Optional[Union[XproxyResult, XproxyError]]
 
+class PayiInstanceDefaultContext(TypedDict, total=False):
+    use_case_name: Optional[str]
+    use_case_id: Optional[str]
+    use_case_version: Optional[int]
+    use_case_properties: Optional["dict[str, str]"]
+    limit_ids: Optional['list[str]']
+    user_id: Optional[str]
+    account_name: Optional[str]
+    request_properties: Optional["dict[str, str]"]
+    price_as_category: Optional[str]
+    price_as_resource: Optional[str]
+    resource_scope: Optional[str]
+
 class _Context(TypedDict, total=False):
     proxy: Optional[bool]
     use_case_name: Optional[str]
@@ -277,7 +310,8 @@ class _PayiInstrumentor:
         self._blocked_limits: set[str] = set()
         self._exceeded_limits: set[str] = set()
 
-        self._api_connection_error_last_log_time: float = time.time()
+        # by not setting to time.time() the first connection error is always logged
+        self._api_connection_error_last_log_time: float = 0
         self._api_connection_error_count: int = 0
         self._api_connection_error_window: int = global_config.get("connection_error_logging_window", 60)
         if self._api_connection_error_window < 0:
@@ -303,10 +337,21 @@ class _PayiInstrumentor:
 
         global_instrumentation = global_config.pop("global_instrumentation", True)
 
+        # configure first, then instrument
+        aws_config = global_config.get("aws_config", None)
+        if aws_config:
+            from .BedrockInstrumentor import BedrockInstrumentor
+            BedrockInstrumentor.configure(aws_config=aws_config)
+
+        azure_openai_config = global_config.get("azure_openai_config", None)
+        if azure_openai_config:
+            from .OpenAIInstrumentor import OpenAiInstrumentor
+            OpenAiInstrumentor.configure(azure_openai_config=azure_openai_config)
+
         if instruments is None or "*" in instruments:
-            self._instrument_all(global_config=global_config)
+            self._instrument_all()
         else:
-            self._instrument_specific(instruments=instruments, global_config=global_config)
+            self._instrument_specific(instruments=instruments)
 
         if global_instrumentation:
             if "proxy" not in global_config:
@@ -338,13 +383,13 @@ class _PayiInstrumentor:
             context_keys = list(_Context.__annotations__.keys()) if hasattr(_Context, '__annotations__') else []
             for key in context_keys:
                 if key in global_config:
-                    context[key] = global_config[key] # type: ignore
+                    context[key] = global_config[key] # type: ignore[literal-required]
 
             self._init_current_context(**context)
             
             # Store the initialized context as the global initial context (immutable after this point)
             # All threads will inherit a copy of this context on their first access
-            current_context = self.get_context()
+            current_context = self._context
             self._global_initial_context = current_context.copy() if current_context else None 
 
     def _ensure_payi_clients(self) -> None:
@@ -355,20 +400,20 @@ class _PayiInstrumentor:
             self._payi = Payi()
             self._apayi = AsyncPayi()
 
-    def _instrument_all(self, global_config: PayiInstrumentConfig) -> None:
+    def _instrument_all(self) -> None:
         self._instrument_openai()
         self._instrument_anthropic()
-        self._instrument_aws_bedrock(global_config.get("aws_config", None))
+        self._instrument_aws_bedrock()
         self._instrument_google_vertex()
         self._instrument_google_genai()
 
-    def _instrument_specific(self, instruments: Set[str], global_config: PayiInstrumentConfig) -> None:
+    def _instrument_specific(self, instruments: Set[str]) -> None:
         if PayiCategories.openai in instruments or PayiCategories.azure_openai in instruments:
             self._instrument_openai()
         if PayiCategories.anthropic in instruments:
             self._instrument_anthropic()
         if PayiCategories.aws_bedrock in instruments:
-            self._instrument_aws_bedrock(global_config.get("aws_config", None))
+            self._instrument_aws_bedrock()
         if PayiCategories.google_vertex in instruments:
             self._instrument_google_vertex()
             self._instrument_google_genai()
@@ -391,11 +436,11 @@ class _PayiInstrumentor:
         except Exception as e:
             self._logger.error(f"Error instrumenting Anthropic: {e}")
 
-    def _instrument_aws_bedrock(self, aws_config: Optional[PayiInstrumentAwsBedrockConfig]) -> None:
+    def _instrument_aws_bedrock(self) -> None:
         from .BedrockInstrumentor import BedrockInstrumentor
 
         try:
-            BedrockInstrumentor.instrument(self, aws_config=aws_config)
+            BedrockInstrumentor.instrument(self)
 
         except Exception as e:
             self._logger.error(f"Error instrumenting AWS bedrock: {e}")
@@ -418,6 +463,28 @@ class _PayiInstrumentor:
         except Exception as e:
             self._logger.error(f"Error instrumenting Google GenAi: {e}")
 
+    @staticmethod
+    def _model_mapping_to_context_dict(model_mappings: Sequence[PayiInstrumentModelMapping]) -> 'dict[str, _Context]':
+        context: dict[str, _Context] = {}
+        for mapping in model_mappings:
+            model = mapping.get("model", "")
+            if not model:
+                continue
+
+            price_as_category = mapping.get("price_as_category", None)
+            price_as_resource = mapping.get("price_as_resource", None)
+            resource_scope = mapping.get("resource_scope", None)
+
+            if not price_as_category and not price_as_resource:
+                continue
+
+            context[model] = _Context(
+                price_as_category=price_as_category,
+                price_as_resource=price_as_resource,
+                resource_scope=resource_scope,
+            )
+        return context
+
     def _write_offline_ingest_packets(self) -> None:
         if not self._offline_instrumentation_file_name or not self._offline_ingest_packets:
             return
@@ -458,7 +525,17 @@ class _PayiInstrumentor:
 
         return log_ingest_units
         
-    def _process_ingest_units(
+    def _merge_internal_request_properties(self, request: _ProviderRequest) -> None:
+        if not request._internal_request_properties:
+            return
+        
+        properties = request._ingest.get("properties") or {}
+        request._ingest["properties"] = properties
+        for key, value in request._internal_request_properties.items():
+            if key not in properties:
+                properties[key] = value
+                
+    def _after_invoke_update_request(
         self,
         request: _ProviderRequest,
         extra_headers: 'dict[str, str]') -> None:
@@ -477,12 +554,7 @@ class _PayiInstrumentor:
         if 'resource' not in ingest_units or ingest_units['resource'] == '':
             ingest_units['resource'] = "system.unknown_model"
 
-        if request._internal_request_properties:
-            properties = ingest_units.get("properties") or {}
-            ingest_units["properties"] = properties
-            for key, value in request._internal_request_properties.items():
-                if key not in properties:
-                    properties[key] = value
+        self._merge_internal_request_properties(request)
 
         request_json = ingest_units.get('provider_request_json', "")
         if request_json and self._instrument_inline_data is False:
@@ -491,7 +563,7 @@ class _PayiInstrumentor:
                 if request.remove_inline_data(prompt_dict):
                     self._logger.debug(f"Removed inline data from provider_request_json")
                     # store the modified dict back as JSON string
-                    ingest_units['provider_request_json'] = json.dumps(prompt_dict)
+                    ingest_units['provider_request_json'] = _compact_json(prompt_dict)
 
             except Exception as e:
                 self._logger.error(f"Error serializing provider_request_json: {e}")
@@ -544,7 +616,7 @@ class _PayiInstrumentor:
         self._logger.debug(f"_aingest_units")
 
         extra_headers: 'dict[str, str]' = {}
-        self._process_ingest_units(request, extra_headers=extra_headers)
+        self._after_invoke_update_request(request, extra_headers=extra_headers)
 
         try:
             if self._logger.isEnabledFor(logging.DEBUG):
@@ -668,7 +740,7 @@ class _PayiInstrumentor:
         self._logger.debug(f"_ingest_units")
 
         extra_headers: 'dict[str, str]' = {}
-        self._process_ingest_units(request, extra_headers=extra_headers)
+        self._after_invoke_update_request(request, extra_headers=extra_headers)
 
         try:
             if self._payi:
@@ -763,6 +835,56 @@ class _PayiInstrumentor:
         else:
             return value.copy()
 
+    def _set_instance_default_context(
+        self,
+        instance: Any,
+        context: PayiInstanceDefaultContext
+    ) -> None:
+        if instance is None:
+            raise ValueError("instance cannot be None")
+        if not context:
+            raise ValueError("context_dict cannot be None or empty")
+        
+        context = context.copy()
+        if "use_case_properties" in context and context["use_case_properties"] is not None:
+            context["use_case_properties"] = context["use_case_properties"].copy()
+        if "request_properties" in context and context["request_properties"] is not None:
+            context["request_properties"] = context["request_properties"].copy()
+        if "limit_ids" in context and context["limit_ids"] is not None:
+            context["limit_ids"] = context["limit_ids"].copy()
+
+        instance.__payi_default_context__ = context
+        self._logger.debug(f"payi_set_default_context: attached context to instance {type(instance).__name__}")
+
+    @staticmethod
+    def _get_instance_default_context(
+        instance: Any
+    ) -> "Optional[PayiInstanceDefaultContext]":
+        if instance is None:
+            return None
+
+        context = getattr(instance, "__payi_default_context__", None)
+        if not context:
+            inner_instance = getattr(instance, "_client", None)
+            if inner_instance:
+                context = getattr(inner_instance, "__payi_default_context__", None)
+
+        # Return a copy to prevent external modifications
+        return context if context else None
+
+    @staticmethod
+    def _merge_context_instance_defaults(
+        context: _Context,
+        instance_defaults: Optional[PayiInstanceDefaultContext]
+    ) -> _Context:
+        if instance_defaults:
+            context = context.copy()
+            for key, value in instance_defaults.items():
+                if value is not None and context.get(key, None) is None:
+                    context[key] = value # type: ignore[literal-required]
+
+        return context
+
     def _init_current_context(
         self,
         proxy: Optional[bool] = None,
@@ -781,7 +903,7 @@ class _PayiInstrumentor:
         ) -> None:
 
         # there will always be a current context
-        context: _Context = self.get_context() # type: ignore
+        context: _Context = self._context # type: ignore
         parent_context: _Context = self._context_stack[-2] if len(self._context_stack) > 1 else {}
 
         parent_proxy = parent_context.get("proxy", self._proxy_default)
@@ -923,27 +1045,38 @@ class _PayiInstrumentor:
         if self._context_stack:
             self._context_stack.pop()
 
-    def get_context(self) -> Optional[_Context]:
+    @property
+    def _context(self) -> Optional[_Context]:
         # Return the current top of the stack
         return self._context_stack[-1] if self._context_stack else None
 
-    def get_context_safe(self) -> _Context:
+    @property
+    def _context_safe(self) -> _Context:
         # Return the current top of the stack
-        return self.get_context() or {}
+        return self._context or {}
+
+    def _extract_price_as(self, extra_headers: "dict[str, str]") -> PriceAs:
+        context = self._context_safe
 
-    def _prepare_ingest(
+        return PriceAs(
+            category=extra_headers.pop(PayiHeaderNames.price_as_category, None) or context.get("price_as_category", None),
+            resource=extra_headers.pop(PayiHeaderNames.price_as_resource, None) or context.get("price_as_resource", None),
+            resource_scope=extra_headers.pop(PayiHeaderNames.resource_scope, None) or context.get("resource_scope", None),
+        )
+
+    def _before_invoke_update_request(
         self,
         request: _ProviderRequest,
-        context: _Context,
         ingest_extra_headers: "dict[str, str]", # do not conflict with potential kwargs["extra_headers"]
         args: Sequence[Any],
         kwargs: 'dict[str, Any]',
     ) -> None:
 
-        limit_ids = ingest_extra_headers.pop(PayiHeaderNames.limit_ids, None)
         # pop and ignore the request tags header since it is no longer processed
         ingest_extra_headers.pop(PayiHeaderNames.request_tags, None)
 
+        limit_ids = ingest_extra_headers.pop(PayiHeaderNames.limit_ids, None)
+
         use_case_name = ingest_extra_headers.pop(PayiHeaderNames.use_case_name, None)
         use_case_id = ingest_extra_headers.pop(PayiHeaderNames.use_case_id, None)
         use_case_version = ingest_extra_headers.pop(PayiHeaderNames.use_case_version, None)
@@ -952,6 +1085,9 @@ class _PayiInstrumentor:
         user_id = ingest_extra_headers.pop(PayiHeaderNames.user_id, None)
         account_name = ingest_extra_headers.pop(PayiHeaderNames.account_name, None)
 
+        request_properties = ingest_extra_headers.pop(PayiHeaderNames.request_properties, "")
+        use_case_properties = ingest_extra_headers.pop(PayiHeaderNames.use_case_properties, "")
+
         if limit_ids:
             request._ingest["limit_ids"] = limit_ids.split(",")
         if use_case_name:
@@ -966,23 +1102,10 @@ class _PayiInstrumentor:
             request._ingest["user_id"] = user_id
         if account_name:
             request._ingest["account_name"] = account_name
-
-        request_properties = context.get("request_properties", None)
         if request_properties:
-            request._ingest["properties"] = request_properties
-
-        use_case_properties = context.get("use_case_properties", None)
+            request._ingest["properties"] = json.loads(request_properties)
         if use_case_properties:
-            request._ingest["use_case_properties"] = use_case_properties
-
-        if request._internal_request_properties:
-            if "properties" in request._ingest and request._ingest["properties"] is not None:
-                # Merge internal request properties, but don't override existing keys
-                for key, value in request._internal_request_properties.items():
-                    if key not in request._ingest["properties"]:
-                        request._ingest["properties"][key] = value
-            else:
-                request._ingest["properties"] = request._internal_request_properties # Assign
+            request._ingest["use_case_properties"] = json.loads(use_case_properties)
 
         if len(ingest_extra_headers) > 0:
             request._ingest["provider_request_headers"] = [PayICommonModelsAPIRouterHeaderInfoParam(name=k, value=v) for k, v in ingest_extra_headers.items()]
@@ -1006,7 +1129,7 @@ class _PayiInstrumentor:
         request.process_request_prompt(provider_prompt, args, kwargs)
 
         if self._log_prompt_and_response:
-            request._ingest["provider_request_json"] = json.dumps(provider_prompt)
+            request._ingest["provider_request_json"] = _compact_json(provider_prompt)
 
         request._ingest["event_timestamp"] = datetime.now(timezone.utc)
         
@@ -1021,7 +1144,7 @@ class _PayiInstrumentor:
     ) -> Any:
         self._logger.debug(f"async_invoke_wrapper: instance {instance}, category {request._category}")
 
-        context = self.get_context()
+        context = self._context
 
         # Bedrock client does not have an async method
 
@@ -1031,6 +1154,8 @@ class _PayiInstrumentor:
             # wrapped function invoked outside of decorator scope
             return await wrapped(*args, **kwargs)
 
+        # context = self._merge_context_instance_defaults(context, self._get_instance_default_context(instance))
+
         # after _udpate_headers, all metadata to add to ingest is in extra_headers, keyed by the xproxy-xxx header name
         extra_headers: Optional[dict[str, str]] = kwargs.get("extra_headers")
         extra_headers = (extra_headers or {}).copy()
@@ -1046,12 +1171,16 @@ class _PayiInstrumentor:
             self._logger.debug(f"async_invoke_wrapper: sending proxy request")
 
             return await wrapped(*args, **kwargs)
+        
+        request._price_as = self._extract_price_as(extra_headers)
+        if not request.supports_extra_headers and "extra_headers" in kwargs:
+            kwargs.pop("extra_headers", None)
 
         current_frame = inspect.currentframe()
         # f_back excludes the current frame, strip() cleans up whitespace and newlines
         stack = [frame.strip() for frame in traceback.format_stack(current_frame.f_back)]  # type: ignore
 
-        request._ingest['properties'] = { 'system.stack_trace': json.dumps(stack) }
+        request._ingest['properties'] = { 'system.stack_trace': _compact_json(stack) }
 
         if request.process_request(instance, extra_headers, args, kwargs) is False:
             self._logger.debug(f"async_invoke_wrapper: calling wrapped instance")
@@ -1068,7 +1197,7 @@ class _PayiInstrumentor:
             stream = False
 
         try:
-            self._prepare_ingest(request, context, extra_headers, args, kwargs)
+            self._before_invoke_update_request(request, extra_headers, args, kwargs)
             self._logger.debug(f"async_invoke_wrapper: calling wrapped instance (stream={stream})")
 
             if "extra_headers" in kwargs:
@@ -1146,7 +1275,7 @@ class _PayiInstrumentor:
     ) -> Any:
         self._logger.debug(f"invoke_wrapper: instance {instance}, category {request._category}")
 
-        context = self.get_context()
+        context = self._context
 
         if not context:
             if not request.supports_extra_headers:
@@ -1157,6 +1286,8 @@ class _PayiInstrumentor:
             # wrapped function invoked outside of decorator scope
             return wrapped(*args, **kwargs)
 
+        # context = self._merge_context_instance_defaults(context, self._get_instance_default_context(instance))
+
         # after _udpate_headers, all metadata to add to ingest is in extra_headers, keyed by the xproxy-xxx header name
         extra_headers: Optional[dict[str, str]] = kwargs.get("extra_headers")
         extra_headers = (extra_headers or {}).copy()
@@ -1172,12 +1303,16 @@ class _PayiInstrumentor:
             self._logger.debug(f"invoke_wrapper: sending proxy request")
 
             return wrapped(*args, **kwargs)
+
+        request._price_as = self._extract_price_as(extra_headers)
+        if not request.supports_extra_headers and "extra_headers" in kwargs:
+            kwargs.pop("extra_headers", None)
         
         current_frame = inspect.currentframe()
         # f_back excludes the current frame, strip() cleans up whitespace and newlines
         stack = [frame.strip() for frame in traceback.format_stack(current_frame.f_back)]  # type: ignore
 
-        request._ingest['properties'] = { 'system.stack_trace': json.dumps(stack) }
+        request._ingest['properties'] = { 'system.stack_trace': _compact_json(stack) }
 
         if request.process_request(instance, extra_headers, args, kwargs) is False:
             self._logger.debug(f"invoke_wrapper: calling wrapped instance")
@@ -1194,7 +1329,7 @@ class _PayiInstrumentor:
             stream = False
 
         try:
-            self._prepare_ingest(request, context, extra_headers, args, kwargs)
+            self._before_invoke_update_request(request, extra_headers, args, kwargs)
             self._logger.debug(f"invoke_wrapper: calling wrapped instance (stream={stream})")
 
             if "extra_headers" in kwargs:
@@ -1274,7 +1409,7 @@ class _PayiInstrumentor:
         self
     ) -> 'dict[str, str]':
         extra_headers: dict[str, str] = {}
-        context = self.get_context()
+        context = self._context
         if context:
             self._update_extra_headers(context, extra_headers)
 
@@ -1303,13 +1438,38 @@ class _PayiInstrumentor:
         context_price_as_resource: Optional[str] = context.get("price_as_resource")
         context_resource_scope: Optional[str] = context.get("resource_scope")
 
-        # headers_limit_ids = extra_headers.get(PayiHeaderNames.limit_ids, None)
-    
+        context_request_properties: Optional[dict[str, Optional[str]]] = context.get("request_properties")
+        context_use_case_properties: Optional[dict[str, Optional[str]]] = context.get("use_case_properties")
+
+        if PayiHeaderNames.request_properties in extra_headers:
+            headers_request_properties = extra_headers.get(PayiHeaderNames.request_properties, None)
+
+            if not headers_request_properties:
+                # headers_request_properties is empty, remove it from extra_headers
+                extra_headers.pop(PayiHeaderNames.request_properties, None)
+            else:
+                # leave the value in extra_headers
+                ...
+        elif context_request_properties:
+            extra_headers[PayiHeaderNames.request_properties] = _compact_json(context_request_properties)
+
+        if PayiHeaderNames.use_case_properties in extra_headers:
+            headers_use_case_properties = extra_headers.get(PayiHeaderNames.use_case_properties, None)
+
+            if not headers_use_case_properties:
+                # headers_use_case_properties is empty, remove it from extra_headers
+                extra_headers.pop(PayiHeaderNames.use_case_properties, None)
+            else:
+                # leave the value in extra_headers
+                ...
+        elif context_use_case_properties:
+            extra_headers[PayiHeaderNames.use_case_properties] = _compact_json(context_use_case_properties)
+
         # If the caller specifies limit_ids in extra_headers, it takes precedence over the decorator
         if PayiHeaderNames.limit_ids in extra_headers:
             headers_limit_ids = extra_headers.get(PayiHeaderNames.limit_ids)
 
-            if headers_limit_ids is None or len(headers_limit_ids) == 0:
+            if not headers_limit_ids:
                 # headers_limit_ids is empty, remove it from extra_headers
                 extra_headers.pop(PayiHeaderNames.limit_ids, None)
             else:   
@@ -1320,7 +1480,7 @@ class _PayiInstrumentor:
 
         if PayiHeaderNames.user_id in extra_headers:
             headers_user_id = extra_headers.get(PayiHeaderNames.user_id, None)
-            if headers_user_id is None or len(headers_user_id) == 0:
+            if not headers_user_id:
                 # headers_user_id is empty, remove it from extra_headers
                 extra_headers.pop(PayiHeaderNames.user_id, None)
             else:
@@ -1331,7 +1491,7 @@ class _PayiInstrumentor:
 
         if PayiHeaderNames.account_name in extra_headers:
             headers_account_name = extra_headers.get(PayiHeaderNames.account_name, None)
-            if headers_account_name is None or len(headers_account_name) == 0:
+            if not headers_account_name:
                 # headers_account_name is empty, remove it from extra_headers
                 extra_headers.pop(PayiHeaderNames.account_name, None)
             else:
@@ -1342,7 +1502,7 @@ class _PayiInstrumentor:
 
         if PayiHeaderNames.use_case_name in extra_headers:
             headers_use_case_name = extra_headers.get(PayiHeaderNames.use_case_name, None)
-            if headers_use_case_name is None or len(headers_use_case_name) == 0:
+            if not headers_use_case_name:
                 # headers_use_case_name is empty, remove all use case related headers
                 extra_headers.pop(PayiHeaderNames.use_case_name, None)
                 extra_headers.pop(PayiHeaderNames.use_case_id, None)
@@ -1604,7 +1764,7 @@ class _StreamIteratorWrapper(ObjectProxy):  # type: ignore
             return chunk
         else:
             # assume dict
-            return json.dumps(chunk)
+            return _compact_json(chunk)
 
 class _StreamManagerWrapper(ObjectProxy):  # type: ignore
     def __init__(
@@ -1678,7 +1838,7 @@ class _GeneratorWrapper:  # type: ignore
             
         if self._log_prompt_and_response:
             dict = self._chunk_to_dict(chunk) 
-            self._responses.append(json.dumps(dict))
+            self._responses.append(_compact_json(dict))
                 
         return self._request.process_chunk(chunk)
     
@@ -1916,7 +2076,7 @@ def get_context() -> PayiContext:
     """
     if not _instrumentor:
         return PayiContext()
-    internal_context = _instrumentor.get_context() or {}
+    internal_context = _instrumentor._context_safe
 
     context_dict = {
         key: value
@@ -1925,4 +2085,13 @@ def get_context() -> PayiContext:
     }
     if _instrumentor._last_result:
         context_dict["last_result"] = _instrumentor._last_result
-    return PayiContext(**dict(context_dict))  # type: ignore
+    return PayiContext(**dict(context_dict))  # type: ignore
+
+# def payi_set_default_context(
+#     instance: Any,
+#     context: PayiInstanceDefaultContext
+# ) -> None:
+#     if not _instrumentor:
+#         raise RuntimeError("payi_instrument() must be called before using payi_add_client_default_context()")
+    
+#     _instrumentor._set_instance_default_context(instance, context)

{payi-0.1.0a133.dist-info → payi-0.1.0a134.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: payi
-Version: 0.1.0a133
+Version: 0.1.0a134
 Summary: The official Python library for the payi API
 Project-URL: Homepage, https://github.com/Pay-i/pay-i-python
 Project-URL: Repository, https://github.com/Pay-i/pay-i-python

{payi-0.1.0a133.dist-info → payi-0.1.0a134.dist-info}/RECORD

@@ -11,7 +11,7 @@ payi/_resource.py,sha256=j2jIkTr8OIC8sU6-05nxSaCyj4MaFlbZrwlyg4_xJos,1088
 payi/_response.py,sha256=rh9oJAvCKcPwQFm4iqH_iVrmK8bNx--YP_A2a4kN1OU,28776
 payi/_streaming.py,sha256=r-qd1jFI1Df33CEelGocyNFdGg4C_NAK8TEX9GmxdOM,10141
 payi/_types.py,sha256=d6xrZDG6rG6opphTN7UVYdEOis3977LrQQgpNtklXZE,7234
-payi/_version.py,sha256=kw_Cm8vm327o_bU7L7yyNX5kwwFwX2nVPCsToTbFc6g,166
+payi/_version.py,sha256=PfQ5Xib4CNlYWPqPk3ILAQTZxnM8F2pDXmLoDhpmUCQ,166
 payi/pagination.py,sha256=k2356QGPOUSjRF2vHpwLBdF6P-2vnQzFfRIJQAHGQ7A,1258
 payi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 payi/_utils/__init__.py,sha256=7fch0GT9zpNnErbciSpUNa-SjTxxjY6kxHxKMOM4AGs,2305
@@ -27,15 +27,15 @@ payi/_utils/_transform.py,sha256=NjCzmnfqYrsAikUHQig6N9QfuTVbKipuP3ur9mcNF-E,159
 payi/_utils/_typing.py,sha256=N_5PPuFNsaygbtA_npZd98SVN1LQQvFTKL6bkWPBZGU,4786
 payi/_utils/_utils.py,sha256=0dDqauUbVZEXV0NVl7Bwu904Wwo5eyFCZpQThhFNhyA,12253
 payi/lib/.keep,sha256=wuNrz-5SXo3jJaJOJgz4vFHM41YH_g20F5cRQo0vLes,224
-payi/lib/AnthropicInstrumentor.py,sha256=SI6nzU-eVufHbxV5gxgrZDhx3TewRVnsvtwDuwEG6WU,16484
-payi/lib/BedrockInstrumentor.py,sha256=-dF3mk2nsCOrYxeV75eBORxYEJ7Nd1nIJWsy4-2LEHk,27324
+payi/lib/AnthropicInstrumentor.py,sha256=AyVwflcprDt7ah0fO7gtQjcwLiElxX_W-GnL6e86K7g,16971
+payi/lib/BedrockInstrumentor.py,sha256=wc3R838Sp1Gr5GTe_S1egx8rG6kHllVZsnPZhX2sSYQ,29464
 payi/lib/GoogleGenAiInstrumentor.py,sha256=LHiEZ7G5IhCcDlpVzQlXW9Ok96MHLeq7emEhFzPBTm0,8836
-payi/lib/OpenAIInstrumentor.py,sha256=_ULwIli11XP1yZK_pMGXuaSmHZ5pozuEt_v5DfhNuGw,22914
+payi/lib/OpenAIInstrumentor.py,sha256=3rR7EndaUXZrT1HSzfhAWIVjX2ha172un56HOqBsQf0,23183
 payi/lib/Stopwatch.py,sha256=7OJlxvr2Jyb6Zr1LYCYKczRB7rDVKkIR7gc4YoleNdE,764
 payi/lib/VertexInstrumentor.py,sha256=OWuMPiW4LdLhj6DSAAy5qZiosVo8DSAuFWGxYpEucoE,7431
 payi/lib/VertexRequest.py,sha256=42F7xCRYY6h3EMUZD1x4-_cwyAcVhnzT9M5zl4KwtE0,11801
-payi/lib/helpers.py,sha256=6c0RFMS0AYVIxU6q8ak1CDwMTwldIN7N2O2XkxTO7ag,4931
-payi/lib/instrument.py,sha256=Mc9ipigz21qvuM6tWC1GoYSr-zoJDBrGmxZm6DxqCbo,78765
+payi/lib/helpers.py,sha256=kqKXVdHlTcK_OQgIwuDXKbtbmezDMxTv7Ax7O0oSTgk,5658
+payi/lib/instrument.py,sha256=HhSQpAEwlEDwPhpZWZVTq2xHdZgy12W255DMlpkl24Y,85586
 payi/lib/version_helper.py,sha256=v0lC3kuaXn6PBDolE3mkmwJiA8Ot3z4RkVR7wlBuZCs,540
 payi/lib/data/cohere_embed_english_v3.json,sha256=YEWwjml3_i16cdsOx_7UKe6xpVFnxTEhP8T1n54R6gY,718306
 payi/resources/__init__.py,sha256=B2bn1ZfCf6TbHlzZvy5TpFPtALnFcBRPYVKQH3S5qfQ,2457
@@ -135,7 +135,7 @@ payi/types/use_cases/definitions/kpi_retrieve_response.py,sha256=uQXliSvS3k-yDYw
 payi/types/use_cases/definitions/kpi_update_params.py,sha256=jbawdWAdMnsTWVH0qfQGb8W7_TXe3lq4zjSRu44d8p8,373
 payi/types/use_cases/definitions/kpi_update_response.py,sha256=zLyEoT0S8d7XHsnXZYT8tM7yDw0Aze0Mk-_Z6QeMtc8,459
 payi/types/use_cases/definitions/limit_config_create_params.py,sha256=Y6RR7IYiTZHYJ4y6m2TmlAe4ArtbjEl7fIrAhnCvuPI,464
-payi-0.1.0a133.dist-info/METADATA,sha256=Y0bDz9gEnpdYXh7hMvgRGnnJ632FAYiKf4bnv1Fq6-c,16324
-payi-0.1.0a133.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-payi-0.1.0a133.dist-info/licenses/LICENSE,sha256=CQt03aM-P4a3Yg5qBg3JSLVoQS3smMyvx7tYg_6V7Gk,11334
-payi-0.1.0a133.dist-info/RECORD,,
+payi-0.1.0a134.dist-info/METADATA,sha256=Xgtk_iCsvrSL62RxLuRrqgOesuMmKsHpEgpBcWQWy6U,16324
+payi-0.1.0a134.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+payi-0.1.0a134.dist-info/licenses/LICENSE,sha256=CQt03aM-P4a3Yg5qBg3JSLVoQS3smMyvx7tYg_6V7Gk,11334
+payi-0.1.0a134.dist-info/RECORD,,