lucidicai 2.1.1__py3-none-any.whl → 2.1.3__py3-none-any.whl

lucidicai/telemetry/openai_patch.py

@@ -1,12 +1,12 @@
-"""OpenAI responses.parse instrumentation patch.
+"""OpenAI responses API instrumentation patch.
 
-This module provides instrumentation for OpenAI's responses.parse API
-which is not covered by the standard opentelemetry-instrumentation-openai package.
+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
+from typing import Any, Callable, Optional, Dict
 
 from opentelemetry import trace
 from opentelemetry.trace import Status, StatusCode, SpanKind
@@ -18,7 +18,7 @@ logger = logging.getLogger("Lucidic")
 
 
 class OpenAIResponsesPatcher:
-    """Patches OpenAI client to instrument responses.parse method."""
+    """Patches OpenAI client to instrument responses API methods."""
 
     def __init__(self, tracer_provider=None):
         """Initialize the patcher.
@@ -29,13 +29,13 @@ class OpenAIResponsesPatcher:
         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._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.parse already patched")
+            debug("[OpenAI Patch] responses API already patched")
             return
 
         try:
@@ -50,102 +50,132 @@ class OpenAIResponsesPatcher:
                 # 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)
+                # Patch responses API methods
+                self._patch_responses_api(client_self)
 
-                        # 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")
+                # 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.parse")
+            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.parse: {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_parse_wrapper(self, original_method: Callable) -> Callable:
-        """Create a wrapper for the responses.parse method.
+    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 parse method to wrap
+            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(**kwargs):
+        def wrapper(*args, **kwargs):
             # Create span for tracing
             with self._tracer.start_as_current_span(
-                "openai.responses.parse",
+                span_name,
                 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 = []
+                    # 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.request.model", model)
-                    span.set_attribute("gen_ai.request.temperature", temperature)
-                    span.set_attribute("gen_ai.operation.name", "responses.parse")
+                    span.set_attribute("gen_ai.operation.name", span_name)
 
-                    # Add a unique marker for our instrumentation
-                    span.set_attribute("lucidic.instrumented", "responses.parse")
-                    span.set_attribute("lucidic.patch.version", "1.0")
+                    # Add our instrumentation marker
+                    span.set_attribute("lucidic.instrumented", span_name)
+                    span.set_attribute("lucidic.patch.version", "2.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))
+                    # 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(**kwargs)
+                    result = original_method(*args, **kwargs)
 
-                    # Process the response and set attributes on span
-                    self._set_response_attributes(span, result, model, messages, start_time, text_format)
+                    # Process the response
+                    self._set_response_attributes(span, result, span_name, start_time)
 
                     span.set_status(Status(StatusCode.OK))
                     return result
@@ -160,29 +190,154 @@ class OpenAIResponsesPatcher:
 
         return wrapper
 
-    def _set_response_attributes(self, span, result, model: str, messages: list, start_time: float, text_format):
+    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
-            model: Model name
-            messages: Input messages
+            span_name: Name of the API method
             start_time: Request start time
-            text_format: Response format (Pydantic model)
         """
         duration = time.time() - start_time
+        span.set_attribute("lucidic.duration_seconds", duration)
 
-        # Extract output
+        # Extract output based on response structure
         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
+        # 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'):
@@ -223,54 +378,29 @@ class OpenAIResponsesPatcher:
             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'):
+            # Restore original __init__ if we have it
+            if 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:
+            # Restore original methods on tracked clients
+            for obj, method_name, original_method in self._client_refs:
                 try:
-                    responses_obj.parse = original_parse
+                    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.parse patch")
+            logger.info("[OpenAI Patch] Successfully removed responses API patch")
 
         except Exception as e:
             logger.error(f"[OpenAI Patch] Failed to unpatch: {e}")

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/utils/images.py

@@ -11,7 +11,7 @@ import logging
 import threading
 from typing import List, Dict, Any, Optional, Tuple, Union
 from PIL import Image
-import requests
+import httpx
 
 logger = logging.getLogger("Lucidic")
 
@@ -299,9 +299,9 @@ class ImageUploader:
             image_obj, content_type = ImageHandler.prepare_for_upload(image_data, format)
         
         # Upload to S3
-        upload_response = requests.put(
+        upload_response = httpx.put(
             url,
-            data=image_obj.getvalue() if hasattr(image_obj, 'getvalue') else image_obj,
+            content=image_obj.getvalue() if hasattr(image_obj, 'getvalue') else image_obj,
             headers={"Content-Type": content_type}
         )
         upload_response.raise_for_status()

lucidicai/utils/queue.py

@@ -9,7 +9,7 @@ import json
 import queue
 import threading
 import time
-import requests
+import httpx
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional, Set, Tuple
@@ -362,7 +362,7 @@ class EventQueue:
     def _upload_blob(self, blob_url: str, data: bytes) -> None:
         """Upload compressed blob to presigned URL."""
         headers = {"Content-Type": "application/json", "Content-Encoding": "gzip"}
-        resp = requests.put(blob_url, data=data, headers=headers)
+        resp = httpx.put(blob_url, content=data, headers=headers)
         resp.raise_for_status()
 
     @staticmethod
@@ -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.dist-info → lucidicai-2.1.3.dist-info}/METADATA

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