lucidicai 2.1.1__tar.gz → 2.1.2__tar.gz

{lucidicai-2.1.1 → lucidicai-2.1.2}/PKG-INFO

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

{lucidicai-2.1.1 → lucidicai-2.1.2}/lucidicai/__init__.py

@@ -100,6 +100,7 @@ def _end_session(
 ):
     """End the current session."""
     from .sdk.init import get_resources, get_session_id, get_event_queue
+    from .sdk.shutdown_manager import get_shutdown_manager
 
     # Use provided session_id or fall back to context
     if not session_id:
@@ -125,6 +126,9 @@ def _end_session(
     # Clear session context
     clear_active_session()
 
+    # unregister from shutdown manager
+    get_shutdown_manager().unregister_session(session_id)
+
 
 def _get_session():
     """Get the current session object."""
@@ -293,7 +297,7 @@ get_error_history = error_boundary.get_error_history
 clear_error_history = error_boundary.clear_error_history
 
 # Version
-__version__ = "2.1.1"
+__version__ = "2.1.2"
 
 # Apply error boundary wrapping to all SDK functions
 from .sdk.error_boundary import wrap_sdk_function

{lucidicai-2.1.1 → lucidicai-2.1.2}/lucidicai/sdk/context.py

@@ -151,6 +151,27 @@ def session(**init_params) -> Iterator[None]:
             clear_thread_session()
         current_session_id.reset(token)
         try:
+            # Force flush OpenTelemetry spans before ending session
+            from .init import get_tracer_provider
+            from ..utils.logger import debug, info
+            import time
+
+            tracer_provider = get_tracer_provider()
+            if tracer_provider:
+                debug(f"[Session] Force flushing OpenTelemetry spans for session {session_id}")
+                try:
+                    # Force flush with 5 second timeout to ensure all spans are exported
+                    flush_result = tracer_provider.force_flush(timeout_millis=5000)
+                    debug(f"[Session] Tracer provider force_flush returned: {flush_result}")
+
+                    # Give a small additional delay to ensure the exporter processes everything
+                    # This is necessary because force_flush on the provider flushes the processors,
+                    # but the exporter might still be processing the spans
+                    time.sleep(0.5)
+                    debug(f"[Session] Successfully flushed spans for session {session_id}")
+                except Exception as e:
+                    debug(f"[Session] Error flushing spans: {e}")
+
             # Pass session_id explicitly to avoid context issues
             lai.end_session(session_id=session_id)
         except Exception:
@@ -184,6 +205,27 @@ async def session_async(**init_params) -> AsyncIterator[None]:
         clear_task_session()
         current_session_id.reset(token)
         try:
+            # Force flush OpenTelemetry spans before ending session
+            from .init import get_tracer_provider
+            from ..utils.logger import debug, info
+            import asyncio
+
+            tracer_provider = get_tracer_provider()
+            if tracer_provider:
+                debug(f"[Session] Force flushing OpenTelemetry spans for async session {session_id}")
+                try:
+                    # Force flush with 5 second timeout to ensure all spans are exported
+                    flush_result = tracer_provider.force_flush(timeout_millis=5000)
+                    debug(f"[Session] Tracer provider force_flush returned: {flush_result}")
+
+                    # Give a small additional delay to ensure the exporter processes everything
+                    # This is necessary because force_flush on the provider flushes the processors,
+                    # but the exporter might still be processing the spans
+                    await asyncio.sleep(0.5)
+                    debug(f"[Session] Successfully flushed spans for async session {session_id}")
+                except Exception as e:
+                    debug(f"[Session] Error flushing spans: {e}")
+
             # Pass session_id explicitly to avoid context issues in async
             lai.end_session(session_id=session_id)
         except Exception:

{lucidicai-2.1.1 → lucidicai-2.1.2}/lucidicai/sdk/init.py

@@ -353,6 +353,11 @@ def get_resources() -> dict:
     return _sdk_state.resources
 
 
+def get_tracer_provider() -> Optional[TracerProvider]:
+    """Get the tracer provider instance."""
+    return _sdk_state.tracer_provider
+
+
 def clear_state() -> None:
     """Clear SDK state (for testing)."""
     global _sdk_state

{lucidicai-2.1.1 → lucidicai-2.1.2}/lucidicai/telemetry/lucidic_exporter.py

@@ -46,6 +46,14 @@ class LucidicSpanExporter(SpanExporter):
 
             attributes = dict(span.attributes or {})
 
+            # Debug: Check what attributes we have for responses.create
+            if span.name == "openai.responses.create":
+                debug(f"[Telemetry] responses.create span has {len(attributes)} attributes")
+                # Check for specific attributes we're interested in
+                has_prompts = any(k.startswith('gen_ai.prompt') for k in attributes.keys())
+                has_completions = any(k.startswith('gen_ai.completion') for k in attributes.keys())
+                debug(f"[Telemetry] Has prompt attrs: {has_prompts}, Has completion attrs: {has_completions}")
+
             # Skip spans that are likely duplicates or incomplete
             # Check if this is a responses.parse span that was already handled
             if span.name == "openai.responses.create" and not attributes.get("lucidic.instrumented"):
@@ -93,6 +101,11 @@ class LucidicSpanExporter(SpanExporter):
             params = self._extract_params(attributes)
             output_text = extract_completions(span, attributes)
 
+            # Debug for responses.create
+            if span.name == "openai.responses.create":
+                debug(f"[Telemetry] Extracted messages: {messages}")
+                debug(f"[Telemetry] Extracted output: {output_text}")
+
             # Skip spans with no meaningful output (likely incomplete or duplicate instrumentation)
             if not output_text or output_text == "Response received":
                 # Only use "Response received" if we have other meaningful data

lucidicai-2.1.2/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-2.1.1 → lucidicai-2.1.2}/lucidicai/telemetry/telemetry_init.py

@@ -60,7 +60,7 @@ def instrument_providers(providers: list, tracer_provider: TracerProvider, exist
                 from .openai_uninstrument import clean_openai_instrumentation
                 clean_openai_instrumentation()
 
-                # Add patch for responses.parse (not covered by standard 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
@@ -68,9 +68,9 @@ def instrument_providers(providers: list, tracer_provider: TracerProvider, exist
                     patcher.patch()
                     _global_instrumentors["openai_responses_patch"] = patcher
                 else:
-                    logger.info("[Telemetry] Skipping responses.parse patch (disabled via LUCIDIC_DISABLE_RESPONSES_PATCH)")
+                    logger.info("[Telemetry] Skipping responses API patch (disabled via LUCIDIC_DISABLE_RESPONSES_PATCH)")
 
-                logger.info("[Telemetry] Instrumented OpenAI (including responses.parse)")
+                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-2.1.1 → lucidicai-2.1.2}/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.1 → lucidicai-2.1.2}/lucidicai.egg-info/PKG-INFO

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

{lucidicai-2.1.1 → lucidicai-2.1.2}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="lucidicai",
-    version="2.1.1",
+    version="2.1.2",
     packages=find_packages(),
     install_requires=[
         "requests>=2.25.1",

lucidicai-2.1.1/lucidicai/telemetry/openai_patch.py

@@ -1,295 +0,0 @@
-"""OpenAI responses.parse instrumentation patch.
-
-This module provides instrumentation for OpenAI's responses.parse API
-which is not covered by the standard opentelemetry-instrumentation-openai package.
-"""
-import functools
-import logging
-import time
-from typing import Any, Callable, Optional
-
-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.parse method."""
-
-    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_parse = 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.parse 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 the responses.parse method on this specific instance
-                if hasattr(client_self, 'resources') and hasattr(client_self.resources, 'responses'):
-                    responses = client_self.resources.responses
-                    if hasattr(responses, 'parse'):
-                        # Store original and apply wrapper
-                        original_parse = responses.parse
-                        responses.parse = self._create_parse_wrapper(original_parse)
-
-                        # Track this client for cleanup
-                        self._client_refs.append((responses, original_parse))
-
-                        verbose("[OpenAI Patch] Patched responses.parse on client instance")
-
-                # Also patch the direct access if available
-                if hasattr(client_self, 'responses') and hasattr(client_self.responses, 'parse'):
-                    original_parse = client_self.responses.parse
-                    client_self.responses.parse = self._create_parse_wrapper(original_parse)
-                    self._client_refs.append((client_self.responses, original_parse))
-                    verbose("[OpenAI Patch] Patched client.responses.parse")
-
-            # 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.parse")
-
-        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.parse: {e}")
-
-    def _create_parse_wrapper(self, original_method: Callable) -> Callable:
-        """Create a wrapper for the responses.parse method.
-
-        Args:
-            original_method: The original parse method to wrap
-
-        Returns:
-            Wrapped method with instrumentation
-        """
-        @functools.wraps(original_method)
-        def wrapper(**kwargs):
-            # Create span for tracing
-            with self._tracer.start_as_current_span(
-                "openai.responses.parse",
-                kind=SpanKind.CLIENT
-            ) as span:
-                start_time = time.time()
-
-                try:
-                    # Extract request parameters
-                    model = kwargs.get('model', 'unknown')
-                    temperature = kwargs.get('temperature', 1.0)
-                    input_param = kwargs.get('input', [])
-                    text_format = kwargs.get('text_format')
-                    instructions = kwargs.get('instructions')
-
-                    # Convert input to messages format if needed
-                    if isinstance(input_param, str):
-                        messages = [{"role": "user", "content": input_param}]
-                    elif isinstance(input_param, list):
-                        messages = input_param
-                    else:
-                        messages = []
-
-                    # Set span attributes
-                    span.set_attribute("gen_ai.system", "openai")
-                    span.set_attribute("gen_ai.request.model", model)
-                    span.set_attribute("gen_ai.request.temperature", temperature)
-                    span.set_attribute("gen_ai.operation.name", "responses.parse")
-
-                    # Add a unique marker for our instrumentation
-                    span.set_attribute("lucidic.instrumented", "responses.parse")
-                    span.set_attribute("lucidic.patch.version", "1.0")
-
-                    if text_format and hasattr(text_format, '__name__'):
-                        span.set_attribute("gen_ai.request.response_format", text_format.__name__)
-
-                    if instructions:
-                        span.set_attribute("gen_ai.request.instructions", str(instructions))
-
-                    # Always set message attributes for proper event creation
-                    for i, msg in enumerate(messages):  # Include all messages
-                        if isinstance(msg, dict):
-                            role = msg.get('role', 'user')
-                            content = msg.get('content', '')
-                            span.set_attribute(f"gen_ai.prompt.{i}.role", role)
-                            # Always include full content - EventQueue handles large messages
-                            span.set_attribute(f"gen_ai.prompt.{i}.content", str(content))
-
-                    # Call the original method
-                    result = original_method(**kwargs)
-
-                    # Process the response and set attributes on span
-                    self._set_response_attributes(span, result, model, messages, start_time, text_format)
-
-                    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 _set_response_attributes(self, span, result, model: str, messages: list, start_time: float, text_format):
-        """Set response attributes on the span for the exporter to use.
-
-        Args:
-            span: OpenTelemetry span
-            result: Response from OpenAI
-            model: Model name
-            messages: Input messages
-            start_time: Request start time
-            text_format: Response format (Pydantic model)
-        """
-        duration = time.time() - start_time
-
-        # Extract output
-        output_text = None
-
-        # Handle structured output response
-        if hasattr(result, 'output_parsed'):
-            output_text = str(result.output_parsed)
-
-            # Always set completion attributes so the exporter can extract them
-            span.set_attribute("gen_ai.completion.0.role", "assistant")
-            span.set_attribute("gen_ai.completion.0.content", output_text)
-
-        # 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)
-
-        # Set additional metadata for the exporter
-        if text_format and hasattr(text_format, '__name__'):
-            span.set_attribute("lucidic.response_format", text_format.__name__)
-
-        # Set duration as attribute
-        span.set_attribute("lucidic.duration_seconds", duration)
-
-
-    def _should_capture_content(self) -> bool:
-        """Check if message content should be captured.
-
-        Returns:
-            True if content capture is enabled
-        """
-
-        return True # always capture content for now 
-        
-        import os
-        # check OTEL standard env var
-        otel_capture = os.getenv('OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT', 'false')
-        # check Lucidic-specific env var
-        lucidic_capture = os.getenv('LUCIDIC_CAPTURE_CONTENT', 'false')
-
-        return otel_capture.lower() == 'true' or lucidic_capture.lower() == 'true'
-
-    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 hasattr(self, '_original_init'):
-                import openai
-                from openai import OpenAI
-                OpenAI.__init__ = self._original_init
-
-            # restore original parse methods on tracked clients
-            for responses_obj, original_parse in self._client_refs:
-                try:
-                    responses_obj.parse = original_parse
-                except:
-                    pass  # Client might have been garbage collected
-
-            self._client_refs.clear()
-            self._is_patched = False
-
-            logger.info("[OpenAI Patch] Successfully removed responses.parse 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