paid-python 0.0.5a40__py3-none-any.whl → 0.1.0__py3-none-any.whl

paid/tracing/wrappers/openai_agents/openaiAgentsHook.py

@@ -1,14 +1,10 @@
 from typing import Any, Optional
 
-from opentelemetry import trace
-from opentelemetry.trace import Status, StatusCode
+from opentelemetry.trace import Span, Status, StatusCode
 
+from paid.logger import logger
 from paid.tracing.tracing import (
     get_paid_tracer,
-    logger,
-    paid_external_agent_id_var,
-    paid_external_customer_id_var,
-    paid_token_var,
 )
 
 try:
@@ -22,7 +18,7 @@ except ImportError:
 
 # Global dictionary to store spans keyed by context object ID
 # This avoids polluting user's context.context and works across async boundaries
-_paid_span_store: dict[int, trace.Span] = {}
+_paid_span_store: dict[int, Span] = {}
 
 
 class PaidOpenAIAgentsHook(RunHooks[Any]):
@@ -32,14 +28,12 @@ class PaidOpenAIAgentsHook(RunHooks[Any]):
     Can optionally wrap user-provided hooks to combine Paid tracking with custom behavior.
     """
 
-    def __init__(self, user_hooks: Optional[RunHooks[Any]] = None, optional_tracing: bool = False):
+    def __init__(self, user_hooks: Optional[RunHooks[Any]] = None):
         """
         Initialize PaidAgentsHook.
 
         Args:
             user_hooks: Optional user-provided RunHooks to combine with Paid tracking
-            optional_tracing: If True, gracefully skip tracing when context is missing.
-                             If False, raise errors when tracing context is not available.
 
         Usage:
             @paid_tracing("<ext_customer_id>", "<ext_agent_id>")
@@ -55,67 +49,26 @@ class PaidOpenAIAgentsHook(RunHooks[Any]):
 
             my_hook = MyHook()
             hook = PaidAgentsHook(user_hooks=my_hook)
-
-            # Optional tracing (won't raise errors if context missing)
-            hook = PaidAgentsHook(optional_tracing=True)
         """
         super().__init__()
-        self.tracer = get_paid_tracer()
-        self.optional_tracing = optional_tracing
         self.user_hooks = user_hooks
 
-    def _get_context_vars(self):
-        """Get tracing context from context variables set by Paid.trace()."""
-        external_customer_id = paid_external_customer_id_var.get()
-        external_agent_id = paid_external_agent_id_var.get()
-        token = paid_token_var.get()
-        return external_customer_id, external_agent_id, token
-
-    def _should_skip_tracing(self, external_customer_id: Optional[str], token: Optional[str]) -> bool:
-        """Check if tracing should be skipped."""
-        # Check if there's an active span (from Paid.trace())
-        current_span = trace.get_current_span()
-        if current_span == trace.INVALID_SPAN:
-            if self.optional_tracing:
-                logger.info(f"{self.__class__.__name__} No tracing, skipping LLM tracking.")
-                return True
-            raise RuntimeError("No OTEL span found. Make sure to call this method from Paid.trace().")
-
-        if not (external_customer_id and token):
-            if self.optional_tracing:
-                logger.info(f"{self.__class__.__name__} No external_customer_id or token, skipping LLM tracking")
-                return True
-            raise RuntimeError(
-                "Missing required tracing information: external_customer_id or token."
-                " Make sure to call this method from Paid.trace()."
-            )
-        return False
-
     def _start_span(self, context, agent, hook_name) -> None:
         try:
-            external_customer_id, external_agent_id, token = self._get_context_vars()
-
-            # Skip tracing if required context is missing
-            if self._should_skip_tracing(external_customer_id, token):
-                return
+            tracer = get_paid_tracer()
 
             # Get model name from agent
             model_name = str(agent.model if agent.model else get_default_model())
 
             # Start span for this LLM call
-            span = self.tracer.start_span(f"openai.agents.{hook_name}")
-            logger.debug(f"{hook_name} : started span")
+            span = tracer.start_span(f"openai.agents.{hook_name}")
 
             # Set initial attributes
             attributes = {
                 "gen_ai.system": "openai",
                 "gen_ai.operation.name": f"{hook_name}",
-                "external_customer_id": external_customer_id,
-                "token": token,
                 "gen_ai.request.model": model_name,
             }
-            if external_agent_id:
-                attributes["external_agent_id"] = external_agent_id
 
             span.set_attributes(attributes)
 
@@ -123,7 +76,6 @@ class PaidOpenAIAgentsHook(RunHooks[Any]):
             # This works across async boundaries without polluting user's context
             context_id = id(context)
             _paid_span_store[context_id] = span
-            logger.debug(f"_start_span: Stored span for context ID {context_id}")
 
         except Exception as error:
             logger.error(f"Error while starting span in PaidAgentsHook.{hook_name}: {error}")
@@ -133,7 +85,6 @@ class PaidOpenAIAgentsHook(RunHooks[Any]):
             # Retrieve span from global dict using context object ID
             context_id = id(context)
             span = _paid_span_store.get(context_id)
-            logger.debug(f"_end_span: Retrieved span for context ID {context_id}: {span}")
 
             if span:
                 # Get usage data from the response
@@ -161,17 +112,13 @@ class PaidOpenAIAgentsHook(RunHooks[Any]):
                     span.set_status(Status(StatusCode.ERROR, "No usage available"))
 
                 span.end()
-                logger.debug(f"{hook_name} : ended span")
 
                 # Clean up from global dict
                 del _paid_span_store[context_id]
-                logger.debug(f"_end_span: Cleaned up span for context ID {context_id}")
-            else:
-                logger.warning(f"_end_span: No span found for context ID {context_id}")
 
         except Exception as error:
-            logger.error(f"Error while ending span in PaidAgentsHook.{hook_name}_end: {error}")
             # Try to end span on error
+            logger.error(f"Error while ending span in PaidAgentsHook.{hook_name}: {error}")
             try:
                 context_id = id(context)
                 span = _paid_span_store.get(context_id)
@@ -181,26 +128,18 @@ class PaidOpenAIAgentsHook(RunHooks[Any]):
                     span.end()
                     del _paid_span_store[context_id]
             except:
-                pass
+                logger.error(f"Failed to end span after error in PaidAgentsHook.{hook_name}")
 
     async def on_llm_start(self, context, agent, system_prompt, input_items) -> None:
-        logger.debug(f"on_llm_start : context_usage : {getattr(context, 'usage', None)}")
-
         if self.user_hooks and hasattr(self.user_hooks, "on_llm_start"):
             await self.user_hooks.on_llm_start(context, agent, system_prompt, input_items)
 
     async def on_llm_end(self, context, agent, response) -> None:
-        logger.debug(
-            f"on_llm_end : context_usage : {getattr(context, 'usage', None)} : response_usage : {getattr(response, 'usage', None)}"
-        )
-
         if self.user_hooks and hasattr(self.user_hooks, "on_llm_end"):
             await self.user_hooks.on_llm_end(context, agent, response)
 
     async def on_agent_start(self, context, agent) -> None:
         """Start a span for agent operations and call user hooks."""
-        logger.debug(f"on_agent_start : context_usage : {getattr(context, 'usage', None)}")
-
         if self.user_hooks and hasattr(self.user_hooks, "on_agent_start"):
             await self.user_hooks.on_agent_start(context, agent)
 
@@ -208,26 +147,19 @@ class PaidOpenAIAgentsHook(RunHooks[Any]):
 
     async def on_agent_end(self, context, agent, output) -> None:
         """End the span for agent operations and call user hooks."""
-        logger.debug(f"on_agent_end : context_usage : {getattr(context, 'usage', None)}")
-
         self._end_span(context, "on_agent")
 
         if self.user_hooks and hasattr(self.user_hooks, "on_agent_end"):
             await self.user_hooks.on_agent_end(context, agent, output)
 
     async def on_handoff(self, context, from_agent, to_agent) -> None:
-        logger.debug(f"on_handoff : context_usage : {getattr(context, 'usage', None)}")
         if self.user_hooks and hasattr(self.user_hooks, "on_handoff"):
             await self.user_hooks.on_handoff(context, from_agent, to_agent)
 
     async def on_tool_start(self, context, agent, tool) -> None:
-        logger.debug(f"on_tool_start : context_usage : {getattr(context, 'usage', None)}")
-
         if self.user_hooks and hasattr(self.user_hooks, "on_tool_start"):
             await self.user_hooks.on_tool_start(context, agent, tool)
 
     async def on_tool_end(self, context, agent, tool, result) -> None:
-        logger.debug(f"on_tool_end : context_usage : {getattr(context, 'usage', None)}")
-
         if self.user_hooks and hasattr(self.user_hooks, "on_tool_end"):
             await self.user_hooks.on_tool_end(context, agent, tool, result)

{paid_python-0.0.5a40.dist-info → paid_python-0.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: paid-python
-Version: 0.0.5a40
+Version: 0.1.0
 Summary: 
 Requires-Python: >=3.9,<3.14
 Classifier: Intended Audience :: Developers
@@ -135,7 +135,7 @@ from paid.tracing import paid_tracing
 
 @paid_tracing("<external_customer_id>", external_agent_id="<optional_external_agent_id>")
 def some_agent_workflow():  # your function
-    # Your logic - use any AI providers with Paid wrappers or send signals with Paid.signal().
+    # Your logic - use any AI providers with Paid wrappers or send signals with signal().
     # This function is typically an event processor that should lead to AI calls or events emitted as Paid signals
 ```
 
@@ -263,31 +263,24 @@ paid_autoinstrument(libraries=["anthropic", "openai"])
 
 - Auto-instrumentation uses official OpenTelemetry instrumentors for each AI library
 - It automatically wraps library calls without requiring you to use Paid wrapper classes
-- Works seamlessly with `@paid_tracing()` decorator or `Paid.trace()` callback
+- Works seamlessly with `@paid_tracing()` decorator or context manager
 - Costs are tracked in the same way as when using manual wrappers
 - Should be called once during application startup, typically before creating AI client instances
 
 ## Signaling via OTEL tracing
 
-A more reliable and user-friendly way to send signals is to send them via OTEL tracing.
-This allows you to send signals with less arguments and boilerplate as the information is available in the tracing context `Paid.trace()` or `@paid_tracing()`.
-The interface is `Paid.signal()`, which takes in signal name, optional data, and a flag that attaches costs from the same trace.
-`Paid.signal()` has to be called within a trace - meaning inside of a callback to `Paid.trace()`.
-In contrast to `Paid.usage.record_bulk()`, `Paid.signal()` is using OpenTelemetry to provide reliable delivery.
+Signals allow you to emit events within your tracing context. They have access to all tracing information, so you need fewer arguments compared to manual API calls.
+Use the `signal()` function which must be called within an active `@paid_tracing()` context (decorator or context manager).
 
 Here's an example of how to use it:
 
 ```python
-from paid import Paid
-from paid.tracing import paid_tracing
-
-# Initialize Paid SDK
-client = Paid(token="PAID_API_KEY")
+from paid.tracing import paid_tracing, signal
 
-@paid_tracing("your_external_customer_id", "your_external_agent_id")  # external_agent_id is necessary for sending signals
+@paid_tracing("your_external_customer_id", "your_external_agent_id")
 def do_work():
     # ...do some work...
-    client.signal(
+    signal(
         event_name="<your_signal_name>",
         data={ } # optional data (ex. manual cost tracking data)
     )
@@ -295,28 +288,21 @@ def do_work():
 do_work()
 ```
 
-Same, but using callback to specify the function to trace:
+Same approach with context manager:
 
 ```python
-from paid import Paid
-
-# Initialize Paid SDK
-client = Paid(token="PAID_API_KEY")
-
-# Initialize tracing, must be after initializing Paid SDK
-client.initialize_tracing()
+from paid.tracing import paid_tracing, signal
 
 def do_work():
     # ...do some work...
-    client.signal(
+    signal(
         event_name="<your_signal_name>",
         data={ } # optional data (ex. manual cost tracking data)
     )
 
-# Finally, capture the traces!
-client.trace(external_customer_id = "<your_external_customer_id>",
-                external_agent_id = "<your_external_agent_id>",  # external_agent_id is required for signals
-                fn = lambda: do_work())
+# Use context manager instead
+with paid_tracing("your_external_customer_id", "your_external_agent_id"):
+    do_work()
 ```
 
 ### Signal-costs - Attaching cost traces to a signal
@@ -328,17 +314,13 @@ as the wrappers and hooks that recorded those costs.
 This will look something like this:
 
 ```python
-from paid import Paid
-from paid.tracing import paid_tracing
-
-# Initialize Paid SDK
-client = Paid(token="PAID_API_KEY")
+from paid.tracing import paid_tracing, signal
 
-@paid_tracing("your_external_customer_id", "your_external_agent_id")  # external_agent_id is necessary for sending signals
+@paid_tracing("your_external_customer_id", "your_external_agent_id")
 def do_work():
     # ... your workflow logic
     # ... your AI calls made through Paid wrappers or hooks
-    client.signal(
+    signal(
         event_name="<your_signal_name>",
         data={ }, # optional data (ex. manual cost tracking data)
         enable_cost_tracing=True, # set this flag to associate it with costs
@@ -356,20 +338,17 @@ Then, all of the costs traced in @paid_tracing() context are related to that sig
 Sometimes your agent workflow cannot fit into a single traceable function like above,
 because it has to be disjoint for whatever reason. It could even be running across different machines.
 
-For such cases, you can pass a tracing token directly to `@paid_tracing()` or `Paid.trace()` to link distributed traces together.
+For such cases, you can pass a tracing token directly to `@paid_tracing()` or context manager to link distributed traces together.
 
 #### Using `tracing_token` parameter (Recommended)
 
-The simplest way to implement distributed tracing is to pass the token directly to the decorator or trace function:
+The simplest way to implement distributed tracing is to pass the token directly to the decorator or context manager:
 
 ```python
-from paid import Paid
-from paid.tracing import paid_tracing, generate_tracing_token
+from paid.tracing import paid_tracing, signal, generate_tracing_token
 from paid.tracing.wrappers.openai import PaidOpenAI
 from openai import OpenAI
 
-# Initialize
-client = Paid(token="<PAID_API_KEY>")
 openai_client = PaidOpenAI(OpenAI(api_key="<OPENAI_API_KEY>"))
 
 # Process 1: Generate token and do initial work
@@ -387,7 +366,7 @@ def process_part_1():
         messages=[{"role": "user", "content": "Analyze data"}]
     )
     # Signal without cost tracing
-    client.signal("part_1_complete", enable_cost_tracing=False)
+    signal("part_1_complete", enable_cost_tracing=False)
 
 process_part_1()
 
@@ -402,164 +381,42 @@ def process_part_2():
         messages=[{"role": "user", "content": "Generate response"}]
     )
     # Signal WITH cost tracing - links all costs from both processes
-    client.signal("workflow_complete", enable_cost_tracing=True)
+    signal("workflow_complete", enable_cost_tracing=True)
 
 process_part_2()
 # No cleanup needed - token is scoped to the decorated function
 ```
 
-Using `Paid.trace()` instead of decorator:
+Using context manager instead of decorator:
 
 ```python
-from paid import Paid
-from paid.tracing import generate_tracing_token
+from paid.tracing import paid_tracing, signal, generate_tracing_token
 from paid.tracing.wrappers.openai import PaidOpenAI
 from openai import OpenAI
 
 # Initialize
-client = Paid(token="<PAID_API_KEY>")
-client.initialize_tracing()
 openai_client = PaidOpenAI(OpenAI(api_key="<OPENAI_API_KEY>"))
 
-# Process 1: Generate and use token
+# Process 1: Generate token and do initial work
 token = generate_tracing_token()
 save_to_storage("workflow_123", token)
 
-def process_part_1():
+with paid_tracing("customer_123", external_agent_id="agent_123", tracing_token=token):
     response = openai_client.chat.completions.create(
         model="gpt-4",
         messages=[{"role": "user", "content": "Analyze data"}]
     )
-    client.signal("part_1_complete", enable_cost_tracing=False)
-
-client.trace(
-    external_customer_id="customer_123",
-    external_agent_id="agent_123",
-    tracing_token=token,
-    fn=lambda: process_part_1()
-)
+    signal("part_1_complete", enable_cost_tracing=False)
 
 # Process 2: Retrieve and use the same token
 token = load_from_storage("workflow_123")
 
-def process_part_2():
+with paid_tracing("customer_123", external_agent_id="agent_123", tracing_token=token):
     response = openai_client.chat.completions.create(
         model="gpt-4",
         messages=[{"role": "user", "content": "Generate response"}]
     )
-    client.signal("workflow_complete", enable_cost_tracing=True)
-
-client.trace(
-    external_customer_id="customer_123",
-    external_agent_id="agent_123",
-    tracing_token=token,
-    fn=lambda: process_part_2()
-)
-```
-
-#### Alternative: Using global context (Advanced)
-
-For more complex scenarios where you need to set the tracing context globally, you can use these functions:
-
-```python
-from paid.tracing import (
-    generate_tracing_token,
-    generate_and_set_tracing_token,
-    set_tracing_token,
-    unset_tracing_token
-)
-
-def generate_tracing_token() -> int:
-    """
-    Generates and returns a tracing token without setting it in the tracing context.
-    Useful when you only want to store or send a tracing token somewhere else
-    without immediately activating it.
-
-    Returns:
-        int: The tracing token (OpenTelemetry trace ID)
-    """
-
-def generate_and_set_tracing_token() -> int:
-    """
-    This function returns tracing token and attaches it to all consequent
-    Paid.trace() or @paid_tracing tracing contexts. So all the costs and signals that share this
-    tracing context are associated with each other.
-
-    To stop associating the traces one can either call
-    generate_and_set_tracing_token() once again or call unset_tracing_token().
-    The former is suitable if you still want to trace but in a fresh
-    context, and the latter will go back to unique traces per Paid.trace().
-
-    Returns:
-        int: The tracing token (OpenTelemetry trace ID)
-    """
-
-def set_tracing_token(token: int):
-    """
-    Sets tracing token. Provided token should come from generate_and_set_tracing_token()
-    or generate_tracing_token(). Once set, the consequent traces Paid.trace() or
-    @paid_tracing() will be related to each other.
-
-    Args:
-        token (int): A tracing token from generate_and_set_tracing_token() or generate_tracing_token()
-    """
-
-def unset_tracing_token():
-    """
-    Unsets the token previously set by generate_and_set_tracing_token()
-    or by set_tracing_token(token). Does nothing if the token was never set.
-    """
-```
-
-Example using global context:
-
-```python
-from paid import Paid
-from paid.tracing import paid_tracing, generate_and_set_tracing_token, set_tracing_token, unset_tracing_token
-from paid.tracing.wrappers.openai import PaidOpenAI
-from openai import OpenAI
-
-# Initialize
-client = Paid(token="<PAID_API_KEY>")
-openai_client = PaidOpenAI(OpenAI(api_key="<OPENAI_API_KEY>"))
-
-# Process 1: Generate token and do initial work
-token = generate_and_set_tracing_token()
-print(f"Tracing token: {token}")
-
-# Store token for other processes (e.g., in Redis, database, message queue)
-save_to_storage("workflow_123", token)
-
-@paid_tracing("customer_123", external_agent_id="agent_123")
-def process_part_1():
-    # AI calls here will be traced
-    response = openai_client.chat.completions.create(
-        model="gpt-4",
-        messages=[{"role": "user", "content": "Analyze data"}]
-    )
-    # Signal without cost tracing
-    client.signal("part_1_complete", enable_cost_tracing=False)
-
-process_part_1()
-
-# Process 2 (different machine/process): Retrieve and use token
-token = load_from_storage("workflow_123")
-set_tracing_token(token)
-
-@paid_tracing("customer_123", external_agent_id="agent_123")
-def process_part_2():
-    # AI calls here will be linked to the same trace
-    response = openai_client.chat.completions.create(
-        model="gpt-4",
-        messages=[{"role": "user", "content": "Generate response"}]
-    )
-    # Signal WITH cost tracing - links all costs from both processes
-    client.signal("workflow_complete", enable_cost_tracing=True)
-
-process_part_2()
-
-# Clean up
-unset_tracing_token()
+    signal("workflow_complete", enable_cost_tracing=True)
 ```
 
 ## Manual Cost Tracking
@@ -594,16 +451,12 @@ client.usage.record_bulk(signals=[signal])
 Alternatively the same `costData` payload can be passed to OTLP signaling mechanism:
 
 ```python
-from paid import Paid
-from paid.tracing import paid_tracing
-
-# Initialize Paid SDK
-client = Paid(token="PAID_API_KEY")
+from paid.tracing import paid_tracing, signal
 
-@paid_tracing("your_external_customer_id", "your_external_agent_id")  # external_agent_id is required for sending signals
+@paid_tracing("your_external_customer_id", "your_external_agent_id")
 def do_work():
     # ...do some work...
-    client.signal(
+    signal(
         event_name="<your_signal_name>",
         data={
             "costData": {
@@ -652,16 +505,12 @@ client.usage.record_bulk(signals=[signal])
 Same but via OTEL signaling:
 
 ```python
-from paid import Paid
-from paid.tracing import paid_tracing
+from paid.tracing import paid_tracing, signal
 
-# Initialize Paid SDK
-client = Paid(token="PAID_API_KEY")
-
-@paid_tracing("your_external_customer_id", "your_external_agent_id")  # external_agent_id is required for sending signals
+@paid_tracing("your_external_customer_id", "your_external_agent_id")
 def do_work():
     # ...do some work...
-    client.signal(
+    signal(
         event_name="<your_signal_name>",
         data={
             "costData": {
@@ -725,15 +574,13 @@ await generate_image()
 
 ### Async Signaling
 
-The `signal()` method works seamlessly in async contexts:
+The `signal()` function works seamlessly in async contexts:
 
 ```python
-from paid import AsyncPaid
-from paid.tracing import paid_tracing
+from paid.tracing import paid_tracing, signal
 from paid.tracing.wrappers.openai import PaidAsyncOpenAI
 from openai import AsyncOpenAI
 
-client = AsyncPaid(token="PAID_API_KEY")
 openai_client = PaidAsyncOpenAI(AsyncOpenAI(api_key="<OPENAI_API_KEY>"))
 
 @paid_tracing("your_external_customer_id", "your_external_agent_id")
@@ -744,8 +591,8 @@ async def do_work():
         messages=[{"role": "user", "content": "Hello!"}]
     )
 
-    # Send signal (synchronous call within async function)
-    client.signal(
+    # Send signal (works in async context)
+    signal(
         event_name="<your_signal_name>",
         enable_cost_tracing=True  # Associate with traced costs
     )

{paid_python-0.0.5a40.dist-info → paid_python-0.1.0.dist-info}/RECORD

@@ -2,7 +2,7 @@ paid/__init__.py,sha256=D1SeLoeTlySo_vZCZrxFX3y5KhKGrHflphLXoewImfk,1826
 paid/agents/__init__.py,sha256=_VhToAyIt_5axN6CLJwtxg3-CO7THa_23pbUzqhXJa4,85
 paid/agents/client.py,sha256=ojc3H-nx4MqDrb74_i6JE_wjHSJaVAErsIunfNeffMo,23305
 paid/agents/raw_client.py,sha256=jN9LvPK2-bGeNQzcV3iRmprpegXKtO2JaOEXjnPfz9Y,26833
-paid/client.py,sha256=BZm5FcU2pwbIDDPFoqTR_L-DsBJOFDyy4yiIKWFdRBc,20021
+paid/client.py,sha256=AWo35RlJ5bP2A5bGre3iY1GbBdYW7gu7HlioQIOoltk,23038
 paid/contacts/__init__.py,sha256=_VhToAyIt_5axN6CLJwtxg3-CO7THa_23pbUzqhXJa4,85
 paid/contacts/client.py,sha256=sNm-yAg4dR9AyYWL7-RC_CuCCvOXX7YlDAUqn47yZhE,14058
 paid/contacts/raw_client.py,sha256=ZYNWuekHiL2sqK_gHR0IzcrLAopUKRXIqMUi-fuLGe4,19211
@@ -28,6 +28,7 @@ paid/errors/__init__.py,sha256=bFCa9MSXuABYvuPmur95svTaWqHETaijD3q2ZMl0A-Q,285
 paid/errors/bad_request_error.py,sha256=_nkSDHMpzm0RadIc19BDq-yM9uJMQGWNrdsT2_6B6Iw,348
 paid/errors/forbidden_error.py,sha256=eDJG4NiZy5uBKpftwKuKJLcmV3zbKs55WFPH1FHI7Pk,347
 paid/errors/not_found_error.py,sha256=nsBHj9gxzRkoJMdFyChYv9ePaPYYf8h4s2nuoUo4CuI,346
+paid/logger.py,sha256=CIo_i2n2Azp4g57GkU9twb_GzJ7x9lZmURqPsq4379M,514
 paid/orders/__init__.py,sha256=CrbHKbmp63NAum57EE9NnGmJqLKiWDMLyPRemOs_U9w,126
 paid/orders/client.py,sha256=TO3hsHj_0w1NTipmu092yQaEawLyKEHHQA1Je2Gj4QE,11533
 paid/orders/lines/__init__.py,sha256=_VhToAyIt_5axN6CLJwtxg3-CO7THa_23pbUzqhXJa4,85
@@ -35,27 +36,29 @@ paid/orders/lines/client.py,sha256=GqSwiXdlu49KLHt7uccS_H4nkVQosM1_PQOcPA9v82A,4
 paid/orders/lines/raw_client.py,sha256=KZN_yBokCOkf1lUb4ZJtX_NZbqmTqCdJNoaIOdWar8I,4590
 paid/orders/raw_client.py,sha256=650e1Sj2vi9KVJc15M3ENXIKYoth0qMz66dzvXy1Sb4,16245
 paid/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-paid/tracing/__init__.py,sha256=A5wSKOHV0nzNQ3QhoQObHfL6tS3Rfn2Wmzzd6OaXyfo,437
-paid/tracing/autoinstrumentation.py,sha256=Ak1GvDEb4tTnSLq1m4fhwZTLc4fcL8gAPeYoUoHB7TA,6662
-paid/tracing/signal.py,sha256=RBZjaBds6YQ_qF32UxkKwBcxL98vr3rjvUvPqvK-URg,2108
-paid/tracing/tracing.py,sha256=_Yy-p7HypHlIQwLZPsAuYNgbp4pOvHf7R7wTqZlw5ow,29608
+paid/tracing/__init__.py,sha256=IP6OkV885_xlK1H68RxGTX_IhpVAkY266zsWgnQKKTs,440
+paid/tracing/autoinstrumentation.py,sha256=p57bU87x1Xi-nb_2C4O56tcgfvN2UYZAd9pJ0Vyh9Nw,6765
+paid/tracing/context_manager.py,sha256=ZVsmum4np_Eyub1_D0D5ChhvdBWnkFBFqzZHxSsljdU,9716
+paid/tracing/distributed_tracing.py,sha256=CpUWpHai-4LxLLHbGxz41r9h5wLG-dC83YL5Vg29OBI,3967
+paid/tracing/signal.py,sha256=PfYxF6EFQS8j7RY5_C5NXrCBVu9Hq2E2tyG4fdQScJk,3252
+paid/tracing/tracing.py,sha256=Xtue-_vuAKLnZ1l6d-tSj9o0UWmMPgXggTVgXYb1Zz4,16230
 paid/tracing/wrappers/__init__.py,sha256=IIleLB_JUbzLw7FshrU2VHZAKF3dZHMGy1O5zCBwwqM,1588
 paid/tracing/wrappers/anthropic/__init__.py,sha256=_x1fjySAQxuT5cIGO_jU09LiGcZH-WQLqKg8mUFAu2w,115
-paid/tracing/wrappers/anthropic/anthropicWrapper.py,sha256=csEtioxYBY5iVW-EDvTzI7g76AAt4ODkZu5MpwQUOXo,8318
+paid/tracing/wrappers/anthropic/anthropicWrapper.py,sha256=pGchbOb41CbTxc7H8xXoM-LjR085spqrzXqCVC_rrFk,4913
 paid/tracing/wrappers/bedrock/__init__.py,sha256=HSeZYbslJuWU5xWJm2rAHz4sL_Hxb70iJjTyAOoJj3s,67
-paid/tracing/wrappers/bedrock/bedrockWrapper.py,sha256=96cnRK01j2pdMzk_U89etypc9iBi6dH20GU2wfc0IGg,3480
+paid/tracing/wrappers/bedrock/bedrockWrapper.py,sha256=aKfGpbkGqJfI-9QX7O-3vkf15Fi35pPyDxOjydTNpQk,1962
 paid/tracing/wrappers/gemini/__init__.py,sha256=6tzEaxuuYcJEtQHlxzjPLqJuEDY2cZe6QC_ZvZCHMS4,64
-paid/tracing/wrappers/gemini/geminiWrapper.py,sha256=vwz0C2SCxc6Y_91FtrebHHwjytYSzj88gFPi-vnKcSM,5627
+paid/tracing/wrappers/gemini/geminiWrapper.py,sha256=xXp8gJyT4k39CWCni_Whnua4dEdyFLtYPK9Wqa9ZByU,3837
 paid/tracing/wrappers/langchain/__init__.py,sha256=LDNPT9UoZen-8f5K0-FO2-Bau7jpeM0Ht3FxctfWW3w,101
-paid/tracing/wrappers/langchain/paidLangChainCallback.py,sha256=6yWGDbCCLkJal_ghpIU0XeyiA7OCxQjsd61bcwcYC1I,14631
+paid/tracing/wrappers/langchain/paidLangChainCallback.py,sha256=2wKFGsYaHwBl24o0UtBZsGne5SGObbaZH54nKvIP3wI,12794
 paid/tracing/wrappers/llamaindex/__init__.py,sha256=bM2bibDwbb_cmvQehb8i-fi9XwSx2HAk6qpGee7wnu8,88
-paid/tracing/wrappers/llamaindex/llamaIndexWrapper.py,sha256=ZIWgb8ePzSui3iglf2jBD48mewU_y1qjUav4PqapTUI,4855
+paid/tracing/wrappers/llamaindex/llamaIndexWrapper.py,sha256=p4Ft7PhZ5cQ_QWeKmdJlYEH75u0seNVBMiXfki8O7sU,3271
 paid/tracing/wrappers/mistral/__init__.py,sha256=_Z1DVul6JBG9vYSXSc9mpm0M4l8GebBWSxwBodGQnew,74
-paid/tracing/wrappers/mistral/mistralWrapper.py,sha256=drUgBw5zVDo8AyHbv-iIccfOIzqe5pphpMODuO3AmEE,13671
+paid/tracing/wrappers/mistral/mistralWrapper.py,sha256=IgK_N5tEj4HDLKxw3uwJYiXB9BQyxLNF-04uiNHMD5Y,8265
 paid/tracing/wrappers/openai/__init__.py,sha256=pfaL3O4f4WOS47UUcdZbDbZSNB9fsTyE_WLqqBahVzs,100
-paid/tracing/wrappers/openai/openAiWrapper.py,sha256=jMO1Ix-5YI2Tifnohv_E9PAizZgyy6Ltuaw06lI9X0c,37731
+paid/tracing/wrappers/openai/openAiWrapper.py,sha256=DIMOGdQTjpFaiKV-JeJvNH_cxHsfmzu2wIrKXDwRkbw,22148
 paid/tracing/wrappers/openai_agents/__init__.py,sha256=-xX5HPhYYX6hDWbn5FpFw-P6M2h0k1X9Qjrg0Bkv7cc,94
-paid/tracing/wrappers/openai_agents/openaiAgentsHook.py,sha256=pMFKZahbNdHs7rl3vKTSHtafgR9r9RuEhYC-Hn8qgxE,10066
+paid/tracing/wrappers/openai_agents/openaiAgentsHook.py,sha256=-uXUNL0S85cFVT7ObrL9hzEQAIYh5Lo1JgEE57hxk2Y,6650
 paid/tracing/wrappers/utils.py,sha256=_0FCF3BC2wK5cU8suEvo_mXm6Jn8ULkyeEhnYPUlO2Y,2347
 paid/types/__init__.py,sha256=Q0XwHtdwgNww7mVxCMKSh9Xrw-Nakjrf49MJDm3Yfbw,2088
 paid/types/address.py,sha256=fJa_oYXxsIxJXFZy5UQqflVkr8BQkwQ7fKhp2wO05fo,871
@@ -95,7 +98,7 @@ paid/usage/__init__.py,sha256=_VhToAyIt_5axN6CLJwtxg3-CO7THa_23pbUzqhXJa4,85
 paid/usage/client.py,sha256=280WJuepoovk3BAVbAx2yN2Q_qBdvx3CcPkLu8lXslc,3030
 paid/usage/raw_client.py,sha256=2acg5C4lxuZodZjepU9QYF0fmBxgG-3ZgXs1zUJG-wM,3709
 paid/version.py,sha256=QIpDFnOrxMxrs86eL0iNH0mSZ1DO078wWHYY9TYAoew,78
-paid_python-0.0.5a40.dist-info/LICENSE,sha256=Nz4baY1zvv0Qy7lqrQtbaiMhmEeGr2Q7A93aqzpml4c,1071
-paid_python-0.0.5a40.dist-info/METADATA,sha256=nYIZ5wk9dUtPzQbFFra5ZeT_Oki7ad4IExFwsJuu8AE,23706
-paid_python-0.0.5a40.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
-paid_python-0.0.5a40.dist-info/RECORD,,
+paid_python-0.1.0.dist-info/LICENSE,sha256=Nz4baY1zvv0Qy7lqrQtbaiMhmEeGr2Q7A93aqzpml4c,1071
+paid_python-0.1.0.dist-info/METADATA,sha256=liDYbzbDdhe3sBUeAuPaBbD7P99Q3YLYClqGqIu9pYs,18729
+paid_python-0.1.0.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
+paid_python-0.1.0.dist-info/RECORD,,