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

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/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/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/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/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/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.dist-info → lucidicai-2.1.2.dist-info}/METADATA

@@ -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.dist-info → lucidicai-2.1.2.dist-info}/RECORD

@@ -1,4 +1,4 @@
-lucidicai/__init__.py,sha256=b5om5w8CV6UjgmeFOlzHTyC-m2PNDgQJ5AcOD7SizYk,12600
+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
@@ -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=_tNem1a39CY-cFWue173eM7FgeUmOEmQ42EfkvKhehQ,7515
+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=NiPcnPzYCU0VlFbBk93LD88wqAYmnglV64nQb2XteOs,3747
 lucidicai/sdk/event_builder.py,sha256=oMvt39m07ZLmPllJTWwRxpinJUz9_AD17yNE6wQRoDA,10423
-lucidicai/sdk/init.py,sha256=RMTyu_LZIo9Pi0uA76jkRviX6VBuvIuVpmFUXC7zwA4,12784
+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
@@ -61,17 +61,17 @@ lucidicai/telemetry/context_bridge.py,sha256=NwyclZvPcZHZtIvLSrY3oO8WQ_J1JSuHWIr
 lucidicai/telemetry/context_capture_processor.py,sha256=kzKWpg5m0OMUP5we6g453FjckWwA_jAVjOKCfiyKVN8,3651
 lucidicai/telemetry/extract.py,sha256=30Iqvnr9I0EkD61GRCMN0Zpk3fLmRYcuVajWjRz0z9I,6814
 lucidicai/telemetry/litellm_bridge.py,sha256=GlNeTX0HCu4JsUqfCGBb62XA61fhyWKv5ohfqSkriaE,16574
-lucidicai/telemetry/lucidic_exporter.py,sha256=tD1A2UGn0vuOW_FV_GVLXuXSxYYZf6r79Pczrn6d0lc,13189
+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=BRSwX4JQLd1kiH43K2FnGvk6rcf5rfZg9lxg_wPb45M,11904
+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=i5lxd2RzIADv2Va06APob9CmQ0KZMSbLKDrGtAGFyBo,9503
+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
@@ -80,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.1.dist-info/METADATA,sha256=QWcIgu6okS3ZQmbRJgq_2mAgHUnhV9tazlTSPmUMqKg,902
-lucidicai-2.1.1.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
-lucidicai-2.1.1.dist-info/top_level.txt,sha256=vSSdM3lclF4I5tyVC0xxUk8eIRnnYXMe1hW-eO91HUo,10
-lucidicai-2.1.1.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,,