lucidicai 2.1.0__py3-none-any.whl → 2.1.2__py3-none-any.whl

lucidicai/telemetry/openai_patch.py

@@ -0,0 +1,425 @@
+"""OpenAI responses API instrumentation patch.
+
+This module provides instrumentation for OpenAI's responses.parse and responses.create APIs
+which are not covered by the standard opentelemetry-instrumentation-openai package.
+"""
+import functools
+import logging
+import time
+from typing import Any, Callable, Optional, Dict
+
+from opentelemetry import trace
+from opentelemetry.trace import Status, StatusCode, SpanKind
+
+from ..sdk.context import current_session_id, current_parent_event_id
+from ..utils.logger import debug, verbose, warning
+
+logger = logging.getLogger("Lucidic")
+
+
+class OpenAIResponsesPatcher:
+    """Patches OpenAI client to instrument responses API methods."""
+
+    def __init__(self, tracer_provider=None):
+        """Initialize the patcher.
+
+        Args:
+            tracer_provider: OpenTelemetry TracerProvider to use
+        """
+        self._tracer_provider = tracer_provider or trace.get_tracer_provider()
+        self._tracer = self._tracer_provider.get_tracer(__name__)
+        self._is_patched = False
+        self._original_init = None
+        self._client_refs = []  # Keep track of patched clients for cleanup
+
+    def patch(self):
+        """Apply the patch to OpenAI client initialization."""
+        if self._is_patched:
+            debug("[OpenAI Patch] responses API already patched")
+            return
+
+        try:
+            import openai
+            from openai import OpenAI
+
+            # Store the original __init__
+            original_init = OpenAI.__init__
+
+            @functools.wraps(original_init)
+            def patched_init(client_self, *args, **kwargs):
+                # Call original initialization
+                original_init(client_self, *args, **kwargs)
+
+                # Patch responses API methods
+                self._patch_responses_api(client_self)
+
+                # Also patch beta.chat.completions.parse if it exists
+                self._patch_beta_api(client_self)
+
+            # Replace the __init__ method
+            OpenAI.__init__ = patched_init
+            self._original_init = original_init
+            self._is_patched = True
+
+            logger.info("[OpenAI Patch] Successfully patched OpenAI client for responses API")
+
+        except ImportError:
+            logger.warning("[OpenAI Patch] OpenAI library not installed, skipping patch")
+        except Exception as e:
+            logger.error(f"[OpenAI Patch] Failed to patch responses API: {e}")
+
+    def _patch_responses_api(self, client):
+        """Patch the responses API methods on the client."""
+        # Check for client.resources.responses (newer structure)
+        if hasattr(client, 'resources') and hasattr(client.resources, 'responses'):
+            responses = client.resources.responses
+            self._patch_responses_object(responses, "client.resources.responses")
+
+        # Check for client.responses (direct access)
+        if hasattr(client, 'responses'):
+            responses = client.responses
+            self._patch_responses_object(responses, "client.responses")
+
+    def _patch_responses_object(self, responses, location: str):
+        """Patch methods on a responses object.
+
+        Args:
+            responses: The responses object to patch
+            location: String describing where this object is (for logging)
+        """
+        methods_to_patch = {
+            'parse': 'openai.responses.parse',
+            'create': 'openai.responses.create'
+        }
+
+        for method_name, span_name in methods_to_patch.items():
+            if hasattr(responses, method_name):
+                original_method = getattr(responses, method_name)
+                wrapped_method = self._create_method_wrapper(original_method, span_name)
+                setattr(responses, method_name, wrapped_method)
+
+                # Track for cleanup
+                self._client_refs.append((responses, method_name, original_method))
+
+                verbose(f"[OpenAI Patch] Patched {location}.{method_name}")
+
+    def _patch_beta_api(self, client):
+        """Patch beta.chat.completions.parse if it exists."""
+        try:
+            if (hasattr(client, 'beta') and
+                hasattr(client.beta, 'chat') and
+                hasattr(client.beta.chat, 'completions') and
+                hasattr(client.beta.chat.completions, 'parse')):
+
+                completions = client.beta.chat.completions
+                original_parse = completions.parse
+
+                # Wrap with a slightly different span name for clarity
+                wrapped_parse = self._create_method_wrapper(
+                    original_parse,
+                    'openai.beta.chat.completions.parse'
+                )
+                completions.parse = wrapped_parse
+
+                # Track for cleanup
+                self._client_refs.append((completions, 'parse', original_parse))
+
+                verbose("[OpenAI Patch] Patched beta.chat.completions.parse")
+
+        except Exception as e:
+            debug(f"[OpenAI Patch] Could not patch beta API: {e}")
+
+    def _create_method_wrapper(self, original_method: Callable, span_name: str) -> Callable:
+        """Create a wrapper for an OpenAI API method.
+
+        Args:
+            original_method: The original method to wrap
+            span_name: Name for the OpenTelemetry span
+
+        Returns:
+            Wrapped method with instrumentation
+        """
+        @functools.wraps(original_method)
+        def wrapper(*args, **kwargs):
+            # Create span for tracing
+            with self._tracer.start_as_current_span(
+                span_name,
+                kind=SpanKind.CLIENT
+            ) as span:
+                start_time = time.time()
+
+                try:
+                    # Debug log for responses.create to understand the parameters
+                    if 'responses.create' in span_name:
+                        debug(f"[OpenAI Patch] responses.create called with kwargs keys: {list(kwargs.keys())}")
+
+                    # Extract and process request parameters
+                    request_attrs = self._extract_request_attributes(span_name, args, kwargs)
+
+                    # Set span attributes
+                    span.set_attribute("gen_ai.system", "openai")
+                    span.set_attribute("gen_ai.operation.name", span_name)
+
+                    # Add our instrumentation marker
+                    span.set_attribute("lucidic.instrumented", span_name)
+                    span.set_attribute("lucidic.patch.version", "2.0")
+
+                    # Set request attributes on span
+                    for key, value in request_attrs.items():
+                        if value is not None:
+                            span.set_attribute(key, value)
+                            if 'responses.create' in span_name and ('prompt' in key or 'completion' in key):
+                                debug(f"[OpenAI Patch] Set attribute {key}: {str(value)[:100]}")
+
+                    # Call the original method
+                    result = original_method(*args, **kwargs)
+
+                    # Process the response
+                    self._set_response_attributes(span, result, span_name, start_time)
+
+                    span.set_status(Status(StatusCode.OK))
+                    return result
+
+                except Exception as e:
+                    # Record error in span
+                    span.set_status(Status(StatusCode.ERROR, str(e)))
+                    span.record_exception(e)
+
+                    # The exporter will handle creating error events from the span
+                    raise
+
+        return wrapper
+
+    def _extract_request_attributes(self, span_name: str, args: tuple, kwargs: dict) -> Dict[str, Any]:
+        """Extract request attributes based on the API method being called.
+
+        Args:
+            span_name: Name of the span/API method
+            args: Positional arguments
+            kwargs: Keyword arguments
+
+        Returns:
+            Dictionary of span attributes to set
+        """
+        attrs = {}
+
+        # Common attributes
+        model = kwargs.get('model', 'unknown')
+        attrs['gen_ai.request.model'] = model
+
+        temperature = kwargs.get('temperature')
+        if temperature is not None:
+            attrs['gen_ai.request.temperature'] = temperature
+
+        # Method-specific handling
+        if 'responses.parse' in span_name:
+            # Handle responses.parse format
+            input_param = kwargs.get('input', [])
+            text_format = kwargs.get('text_format')
+            instructions = kwargs.get('instructions')
+
+            # Convert input to messages format
+            if isinstance(input_param, str):
+                messages = [{"role": "user", "content": input_param}]
+            elif isinstance(input_param, list):
+                messages = input_param
+            else:
+                messages = []
+
+            if text_format and hasattr(text_format, '__name__'):
+                attrs['gen_ai.request.response_format'] = text_format.__name__
+
+            if instructions:
+                # Never truncate - EventQueue handles large messages automatically
+                attrs['gen_ai.request.instructions'] = str(instructions)
+
+        elif 'responses.create' in span_name:
+            # Handle responses.create format - it uses 'input' not 'messages'
+            input_param = kwargs.get('input', [])
+
+            # Convert input to messages format
+            if isinstance(input_param, str):
+                messages = [{"role": "user", "content": input_param}]
+            elif isinstance(input_param, list):
+                messages = input_param
+            else:
+                messages = []
+
+            # Handle text parameter for structured outputs
+            text_format = kwargs.get('text')
+            if text_format and hasattr(text_format, '__name__'):
+                attrs['gen_ai.request.response_format'] = text_format.__name__
+
+        elif 'completions.parse' in span_name:
+            # Handle standard chat completion format
+            messages = kwargs.get('messages', [])
+
+            # Handle response_format for structured outputs
+            response_format = kwargs.get('response_format')
+            if response_format:
+                if hasattr(response_format, '__name__'):
+                    attrs['gen_ai.request.response_format'] = response_format.__name__
+                elif isinstance(response_format, dict):
+                    attrs['gen_ai.request.response_format'] = str(response_format)
+
+        else:
+            # Fallback: try to get messages from kwargs
+            messages = kwargs.get('messages', kwargs.get('input', []))
+            if isinstance(messages, str):
+                messages = [{"role": "user", "content": messages}]
+
+        # Always set message attributes for proper event creation
+        # The EventQueue handles large messages automatically with blob storage
+        for i, msg in enumerate(messages):
+            if isinstance(msg, dict):
+                role = msg.get('role', 'user')
+                content = msg.get('content', '')
+                attrs[f'gen_ai.prompt.{i}.role'] = role
+                # Always include full content - EventQueue handles large messages
+                attrs[f'gen_ai.prompt.{i}.content'] = str(content)
+
+        return attrs
+
+    def _set_response_attributes(self, span, result, span_name: str, start_time: float):
+        """Set response attributes on the span for the exporter to use.
+
+        Args:
+            span: OpenTelemetry span
+            result: Response from OpenAI
+            span_name: Name of the API method
+            start_time: Request start time
+        """
+        duration = time.time() - start_time
+        span.set_attribute("lucidic.duration_seconds", duration)
+
+        # Extract output based on response structure
+        output_text = None
+
+        # Handle different response formats
+        if 'responses.parse' in span_name:
+            # responses.parse format
+            if hasattr(result, 'output_parsed'):
+                output_text = str(result.output_parsed)
+            elif hasattr(result, 'parsed'):
+                output_text = str(result.parsed)
+
+        elif 'responses.create' in span_name:
+            # responses.create returns a Response object with output_text
+            if hasattr(result, 'output_text'):
+                output_text = result.output_text
+            elif hasattr(result, 'output'):
+                output_text = result.output
+            else:
+                # Log what we actually got for debugging
+                debug(f"[OpenAI Patch] responses.create result type: {type(result)}")
+                debug(f"[OpenAI Patch] responses.create result attributes: {[attr for attr in dir(result) if not attr.startswith('_')]}")
+
+        elif 'completions.parse' in span_name:
+            # Standard chat completion format
+            if hasattr(result, 'choices') and result.choices:
+                choice = result.choices[0]
+                if hasattr(choice, 'message'):
+                    msg = choice.message
+                    if hasattr(msg, 'parsed'):
+                        # Structured output
+                        output_text = str(msg.parsed)
+                    elif hasattr(msg, 'content'):
+                        # Regular content
+                        output_text = msg.content
+                elif hasattr(choice, 'text'):
+                    # Completion format
+                    output_text = choice.text
+
+        # Set completion attributes if we have output
+        if output_text:
+            # Never truncate - EventQueue handles large messages automatically
+            span.set_attribute("gen_ai.completion.0.role", "assistant")
+            span.set_attribute("gen_ai.completion.0.content", output_text)
+            debug(f"[OpenAI Patch] Set completion: {output_text[:100]}")
+        else:
+            debug(f"[OpenAI Patch] No output_text found for {span_name}")
+
+        # Handle usage data
+        if hasattr(result, 'usage'):
+            usage = result.usage
+
+            # Debug logging
+            debug(f"[OpenAI Patch] Usage object type: {type(usage)}")
+            debug(f"[OpenAI Patch] Usage attributes: {[attr for attr in dir(usage) if not attr.startswith('_')]}")
+
+            # Extract tokens with proper handling
+            prompt_tokens = None
+            completion_tokens = None
+            total_tokens = None
+
+            # Try different ways to access token data
+            if hasattr(usage, 'prompt_tokens'):
+                prompt_tokens = usage.prompt_tokens
+            elif hasattr(usage, 'input_tokens'):
+                prompt_tokens = usage.input_tokens
+
+            if hasattr(usage, 'completion_tokens'):
+                completion_tokens = usage.completion_tokens
+            elif hasattr(usage, 'output_tokens'):
+                completion_tokens = usage.output_tokens
+
+            if hasattr(usage, 'total_tokens'):
+                total_tokens = usage.total_tokens
+            elif prompt_tokens is not None and completion_tokens is not None:
+                total_tokens = prompt_tokens + completion_tokens
+
+            debug(f"[OpenAI Patch] Extracted tokens - prompt: {prompt_tokens}, completion: {completion_tokens}, total: {total_tokens}")
+
+            # Set usage attributes on span
+            if prompt_tokens is not None:
+                span.set_attribute("gen_ai.usage.prompt_tokens", prompt_tokens)
+            if completion_tokens is not None:
+                span.set_attribute("gen_ai.usage.completion_tokens", completion_tokens)
+            if total_tokens is not None:
+                span.set_attribute("gen_ai.usage.total_tokens", total_tokens)
+
+    def unpatch(self):
+        """Remove the patch and restore original behavior."""
+        if not self._is_patched:
+            return
+
+        try:
+            # Restore original __init__ if we have it
+            if self._original_init:
+                import openai
+                from openai import OpenAI
+                OpenAI.__init__ = self._original_init
+
+            # Restore original methods on tracked clients
+            for obj, method_name, original_method in self._client_refs:
+                try:
+                    setattr(obj, method_name, original_method)
+                except:
+                    pass  # Client might have been garbage collected
+
+            self._client_refs.clear()
+            self._is_patched = False
+
+            logger.info("[OpenAI Patch] Successfully removed responses API patch")
+
+        except Exception as e:
+            logger.error(f"[OpenAI Patch] Failed to unpatch: {e}")
+
+
+# Global singleton instance
+_patcher_instance: Optional[OpenAIResponsesPatcher] = None
+
+
+def get_responses_patcher(tracer_provider=None) -> OpenAIResponsesPatcher:
+    """Get or create the global patcher instance.
+
+    Args:
+        tracer_provider: OpenTelemetry TracerProvider
+
+    Returns:
+        The singleton patcher instance
+    """
+    global _patcher_instance
+    if _patcher_instance is None:
+        _patcher_instance = OpenAIResponsesPatcher(tracer_provider)
+    return _patcher_instance

lucidicai/telemetry/openai_uninstrument.py

@@ -0,0 +1,87 @@
+"""Utility to uninstrument specific OpenAI methods to prevent duplicates.
+
+This module helps prevent the standard OpenTelemetry instrumentation
+from creating duplicate spans for methods we're handling ourselves.
+"""
+import logging
+
+logger = logging.getLogger("Lucidic")
+
+
+def uninstrument_responses(openai_module):
+    """Remove any incorrect instrumentation from responses module.
+
+    The standard OpenTelemetry instrumentation might try to instrument
+    responses.create (which doesn't exist) or other responses methods.
+    This function removes any such instrumentation.
+
+    Args:
+        openai_module: The OpenAI module
+    """
+    try:
+        # Check if responses module exists
+        if not hasattr(openai_module, 'resources'):
+            return
+
+        resources = openai_module.resources
+        if not hasattr(resources, 'responses'):
+            return
+
+        responses = resources.responses
+
+        # Check for incorrectly wrapped methods
+        methods_to_check = ['create', 'parse']
+
+        for method_name in methods_to_check:
+            if hasattr(responses, method_name):
+                method = getattr(responses, method_name)
+
+                # Check if it's wrapped (wrapped methods usually have __wrapped__ attribute)
+                if hasattr(method, '__wrapped__'):
+                    # Restore original
+                    original = method.__wrapped__
+                    setattr(responses, method_name, original)
+                    logger.debug(f"[OpenAI Uninstrument] Removed wrapper from responses.{method_name}")
+
+                # Also check for _original_* attributes (another wrapping pattern)
+                original_attr = f'_original_{method_name}'
+                if hasattr(responses, original_attr):
+                    original = getattr(responses, original_attr)
+                    setattr(responses, method_name, original)
+                    delattr(responses, original_attr)
+                    logger.debug(f"[OpenAI Uninstrument] Restored original responses.{method_name}")
+
+        # Also check the Responses class itself
+        if hasattr(responses, 'Responses'):
+            Responses = responses.Responses
+            for method_name in methods_to_check:
+                if hasattr(Responses, method_name):
+                    method = getattr(Responses, method_name)
+                    if hasattr(method, '__wrapped__'):
+                        original = method.__wrapped__
+                        setattr(Responses, method_name, original)
+                        logger.debug(f"[OpenAI Uninstrument] Removed wrapper from Responses.{method_name}")
+
+    except Exception as e:
+        logger.debug(f"[OpenAI Uninstrument] Error while checking responses instrumentation: {e}")
+
+
+def clean_openai_instrumentation():
+    """Clean up any problematic OpenAI instrumentation.
+
+    This should be called after standard instrumentation but before our patches.
+    """
+    try:
+        import openai
+        uninstrument_responses(openai)
+
+        # Also check if client instances need cleaning
+        if hasattr(openai, 'OpenAI'):
+            # The OpenAI class might have wrapped __init__ that creates bad instrumentation
+            # We don't want to break it, just ensure responses aren't double-instrumented
+            pass
+
+    except ImportError:
+        pass  # OpenAI not installed
+    except Exception as e:
+        logger.debug(f"[OpenAI Uninstrument] Error during cleanup: {e}")

lucidicai/telemetry/telemetry_init.py

@@ -55,7 +55,22 @@ def instrument_providers(providers: list, tracer_provider: TracerProvider, exist
                 inst.instrument(tracer_provider=tracer_provider, enrich_token_usage=True)
                 _global_instrumentors["openai"] = inst
                 new_instrumentors["openai"] = inst
-                logger.info("[Telemetry] Instrumented OpenAI")
+
+                # Clean up any problematic instrumentation from standard library
+                from .openai_uninstrument import clean_openai_instrumentation
+                clean_openai_instrumentation()
+
+                # Add patch for responses API methods (not covered by standard instrumentation)
+                import os
+                if os.getenv('LUCIDIC_DISABLE_RESPONSES_PATCH', 'false').lower() != 'true':
+                    from .openai_patch import get_responses_patcher
+                    patcher = get_responses_patcher(tracer_provider)
+                    patcher.patch()
+                    _global_instrumentors["openai_responses_patch"] = patcher
+                else:
+                    logger.info("[Telemetry] Skipping responses API patch (disabled via LUCIDIC_DISABLE_RESPONSES_PATCH)")
+
+                logger.info("[Telemetry] Instrumented OpenAI (including responses.parse, responses.create, beta.chat.completions.parse)")
             except Exception as e:
                 logger.error(f"Failed to instrument OpenAI: {e}")
 

lucidicai/utils/queue.py

@@ -372,19 +372,51 @@ class EventQueue:
             t = (event_type or "generic").lower()
             
             if t == "llm_generation":
+
                 req = payload.get("request", {})
+                usage = payload.get("usage", {})
+                messages = req.get("messages", [])[:5]
+                output = payload.get("response", {}).get("output", {})
+                compressed_messages = []
+                for i, m in enumerate(messages):
+                    compressed_message_item = {}
+                    for k, v in messages[i].items():
+                        compressed_message_item[k] = str(v)[:200] if v else None
+                    compressed_messages.append(compressed_message_item)
                 return {
                     "request": {
-                        "model": str(req.get("model", ""))[:200],
-                        "provider": str(req.get("provider", ""))[:200],
-                        "messages": "truncated"
+                        "model": req.get("model")[:200] if req.get("model") else None,
+                        "provider": req.get("provider")[:200] if req.get("provider") else None,
+                        "messages": compressed_messages,
+                    },
+                    "usage": {
+                        k: usage.get(k) for k in ("input_tokens", "output_tokens", "cost") if k in usage
                     },
-                    "response": {"output": "truncated"}
+                    "response": {
+                        "output": str(output)[:200] if output else None,
+                    }
                 }
+
             elif t == "function_call":
+                args = payload.get("arguments")
+                truncated_args = (
+                    {k: (str(v)[:200] if v is not None else None) for k, v in args.items()}
+                    if isinstance(args, dict)
+                    else (str(args)[:200] if args is not None else None)    
+                )
+                return {
+                    "function_name": payload.get("function_name")[:200] if payload.get("function_name") else None,
+                    "arguments": truncated_args,
+                }
+
+            elif t == "error_traceback":
+                return {
+                    "error": payload.get("error")[:200] if payload.get("error") else None,
+                }
+
+            elif t == "generic":
                 return {
-                    "function_name": str(payload.get("function_name", ""))[:200],
-                    "arguments": "truncated"
+                    "details": payload.get("details")[:200] if payload.get("details") else None,
                 }
             else:
                 return {"details": "preview_unavailable"}

{lucidicai-2.1.0.dist-info → lucidicai-2.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lucidicai
-Version: 2.1.0
+Version: 2.1.2
 Summary: Lucidic AI Python SDK
 Author: Andy Liang
 Author-email: andy@lucidic.ai

{lucidicai-2.1.0.dist-info → lucidicai-2.1.2.dist-info}/RECORD

@@ -1,4 +1,4 @@
-lucidicai/__init__.py,sha256=qAza0IBGUQS3e-_uXzRvqVxUH7XliA5XYieTEpXnGT0,11992
+lucidicai/__init__.py,sha256=WwZ3A73h0Ttk1xgiiCt9yM-zXD1vIvQNg6XLTbMYQLY,12757
 lucidicai/action.py,sha256=sPRd1hTIVXDqnvG9ZXWEipUFh0bsXcE0Fm7RVqmVccM,237
 lucidicai/client.py,sha256=IIhlY6Mfwy47FeMxzpvIygCaqcI1FnqiXiVU6M4QEiE,22327
 lucidicai/constants.py,sha256=zN8O7TjoRHRlaGa9CZUWppS73rhzKGwaEkF9XMTV0Cg,1160
@@ -24,7 +24,7 @@ lucidicai/api/resources/dataset.py,sha256=6UnMUd-y__TOAjUJLjbc0lZJRTy_gHkyoE82Ov
 lucidicai/api/resources/event.py,sha256=GyyNL3_k53EbmvTdgJEABexiuJnoX61hxWey7DYmlYY,2434
 lucidicai/api/resources/session.py,sha256=w7b4kkbWdbaNbwuMBFgEeVmDfaYozBf9OK8B8L9B1m8,3730
 lucidicai/core/__init__.py,sha256=b0YQkd8190Y_GgwUcmf0tOiSLARd7L4kq4jwfhhGAyI,39
-lucidicai/core/config.py,sha256=m5kl9wiVp5J0DW6ES--GzsMgyykSYtaCi3D-2tW650M,7972
+lucidicai/core/config.py,sha256=P9y5aSZRkAehTvoBdYEc6x5-jiumB5cxftoMtJatl7w,7980
 lucidicai/core/errors.py,sha256=aRfdXABiTWFTiWELgu2Dz_wxVSggcBFqX7Q-toCy_fY,2130
 lucidicai/core/types.py,sha256=KabcTBQe7SemigccKfJSDiJmjSJDJJvvtefSd8pfrJI,702
 lucidicai/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -45,12 +45,12 @@ lucidicai/providers/pydantic_ai_handler.py,sha256=Yhd9VTJhq292ZzJF04O_jYGRh-1bzs
 lucidicai/providers/text_storage.py,sha256=L62MMJ8E23TDqDTUv2aRntdKMCItsXV7XjY6cFwx2DE,1503
 lucidicai/providers/universal_image_interceptor.py,sha256=7d-hw4xihRwvvA1AP8-vqYNChtmVXKmn09MN4pDS7KQ,12126
 lucidicai/sdk/__init__.py,sha256=UrkV9FYbZkBxaX9qwxGbCJdXp-JqMpn0_u-huO9Y-ec,32
-lucidicai/sdk/context.py,sha256=ruEXAndSv0gQ-YEXLlC4Fx6NNbaylfp_dZxbpwmLZSA,4622
+lucidicai/sdk/context.py,sha256=5Z5bLXKX3hFS-LN-lYVK3ho3b3LmNFi66UOd0cIYkZ0,9873
 lucidicai/sdk/decorators.py,sha256=B5BXG9Sn5ruUkxFq10L1rrCR_wzYUPlYeu5aqyXetMM,8393
 lucidicai/sdk/error_boundary.py,sha256=IPr5wS9rS7ZQNgEaBwK53UaixAm6L2rijKKFfxcxjUI,9190
-lucidicai/sdk/event.py,sha256=jadK8bZ_kkpycx5zHC5tlNUqL_yCk2WJ6REuFrSrIVI,3564
+lucidicai/sdk/event.py,sha256=NiPcnPzYCU0VlFbBk93LD88wqAYmnglV64nQb2XteOs,3747
 lucidicai/sdk/event_builder.py,sha256=oMvt39m07ZLmPllJTWwRxpinJUz9_AD17yNE6wQRoDA,10423
-lucidicai/sdk/init.py,sha256=gxWfK_c22BcAwnv9LZWqmS_G303_rRAhA0zt2nWKdvc,9289
+lucidicai/sdk/init.py,sha256=tfpTRZLT317xNC_GE2OKqRR02Nj3s3a12CJELc-vVAE,12923
 lucidicai/sdk/shutdown_manager.py,sha256=I5ylR96QHQ_SfP1euAiM0qQ-I7upCPMW1HUNvoj7hCw,12090
 lucidicai/sdk/features/__init__.py,sha256=23KUF2EZBzsaH9JUFDGNXZb_3PSfc35VZfD59gAfyR0,26
 lucidicai/sdk/features/dataset.py,sha256=qFGnu8Wm1yhaflBhtm-5veN-KaoxGLBL5xWEifkrsY0,19416
@@ -60,16 +60,18 @@ lucidicai/telemetry/base_provider.py,sha256=nrZVr4Y9xcAiMn4uAN3t3k6DlHNTvlXrA4qQ
 lucidicai/telemetry/context_bridge.py,sha256=NwyclZvPcZHZtIvLSrY3oO8WQ_J1JSuHWIr36gxA7xk,2989
 lucidicai/telemetry/context_capture_processor.py,sha256=kzKWpg5m0OMUP5we6g453FjckWwA_jAVjOKCfiyKVN8,3651
 lucidicai/telemetry/extract.py,sha256=30Iqvnr9I0EkD61GRCMN0Zpk3fLmRYcuVajWjRz0z9I,6814
-lucidicai/telemetry/litellm_bridge.py,sha256=QXUNwFI3GyvCQtnsnnSnmh2BfdnfnbKIDjfc_Rviau4,16436
-lucidicai/telemetry/lucidic_exporter.py,sha256=ghzPVGJlR3yPtRNMtnvlqcMuQCNTkU-oRLyu_YiuzQU,11892
+lucidicai/telemetry/litellm_bridge.py,sha256=GlNeTX0HCu4JsUqfCGBb62XA61fhyWKv5ohfqSkriaE,16574
+lucidicai/telemetry/lucidic_exporter.py,sha256=tn5_Tk2QoYP6nZUmYoS19zyXdCfg6H4gy7tSlz6tCt4,14017
 lucidicai/telemetry/lucidic_span_processor.py,sha256=-jo7Muuslo3ZCSAysLsDGBqJijQSpIOvJHPbPNjP4iQ,31029
 lucidicai/telemetry/openai_agents_instrumentor.py,sha256=__wIbeglMnEEf4AGTQ--FXeWCKmz2yy8SBupwprEdZA,12694
+lucidicai/telemetry/openai_patch.py,sha256=3VEU7-7O9DMgKn9xVvAjhEWTCDih454o7lEBHPgLLI8,17083
+lucidicai/telemetry/openai_uninstrument.py,sha256=zELpoz2BU8O-rdHrg_7NuvjdNoY6swgoqVm5NtTCJRQ,3456
 lucidicai/telemetry/opentelemetry_converter.py,sha256=xOHCqoTyO4hUkL6k7fxy84PbljPpYep6ET9ZqbkJehc,17665
 lucidicai/telemetry/otel_handlers.py,sha256=OCzXuYog6AuwjI4eXy5Sk40DUehyz48QOxuOujXnEVU,20859
 lucidicai/telemetry/otel_init.py,sha256=hjUOX8nEBLrDOuh0UTKFfG-C98yFZHTiP8ql59bmNXY,13780
 lucidicai/telemetry/otel_provider.py,sha256=e5XcpQTd_a5UrMAq-EQcJ0zUJpO7NO16T-BphVUigR4,7513
 lucidicai/telemetry/pydantic_ai_handler.py,sha256=WPa3tFcVgVnPPO3AxcNOTbNkmODLgNOrU2_3GVtWqUw,28261
-lucidicai/telemetry/telemetry_init.py,sha256=8RMzZeeHYvaJKaM5KeSt0svaUAqODHmLstECjgHr8fc,8660
+lucidicai/telemetry/telemetry_init.py,sha256=YpjcYDcqlWpUDDz76-x2v4K0yz_ToEpuaDz_Hypbr2w,9554
 lucidicai/telemetry/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lucidicai/telemetry/utils/image_storage.py,sha256=4Z59ZpVexr7-lcExfr8GsqXe0y2VZmr8Yjwa-3DeOxU,1457
 lucidicai/telemetry/utils/model_pricing.py,sha256=Dxi6e0WjcIyCTkVX7K7f0pJ5rPu7nSt3lOmgzAUQl1o,12402
@@ -78,8 +80,8 @@ lucidicai/telemetry/utils/universal_image_interceptor.py,sha256=vARgMk1hVSF--zfi
 lucidicai/utils/__init__.py,sha256=ZiGtmJaF0ph9iIFIgQiAreVuYM_1o7qu9VySK1NblTw,22
 lucidicai/utils/images.py,sha256=YHFjeKHRxzWu0IsuNwKw303egPsd99AShaD4WND1lJk,12325
 lucidicai/utils/logger.py,sha256=R3B3gSee64F6UVHUrShihBq_O7W7bgfrBiVDXTO3Isg,4777
-lucidicai/utils/queue.py,sha256=iBhazYt9EPTpyuexfDyPjvJT-2ODaAbCBbGYvLVl8wM,15815
-lucidicai-2.1.0.dist-info/METADATA,sha256=5olKiUoS21uLWjjoOkbJaQGY1J0FDJSTKMVGmOcoTEI,902
-lucidicai-2.1.0.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
-lucidicai-2.1.0.dist-info/top_level.txt,sha256=vSSdM3lclF4I5tyVC0xxUk8eIRnnYXMe1hW-eO91HUo,10
-lucidicai-2.1.0.dist-info/RECORD,,
+lucidicai/utils/queue.py,sha256=tZYPAUHRAK_uyE8Mk4PloObsBcfITurHwIlNHr3gMFU,17326
+lucidicai-2.1.2.dist-info/METADATA,sha256=ZcL5YaquJn3D5MyMf7UqZTzrP9m5E4XAhEJQJAuOXTs,902
+lucidicai-2.1.2.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
+lucidicai-2.1.2.dist-info/top_level.txt,sha256=vSSdM3lclF4I5tyVC0xxUk8eIRnnYXMe1hW-eO91HUo,10
+lucidicai-2.1.2.dist-info/RECORD,,