lucidicai 2.1.0__tar.gz → 2.1.1__tar.gz

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

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

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

@@ -14,6 +14,10 @@ from .sdk.init import (
     init as _init,
     get_session_id as _get_session_id,
     clear_state as _clear_state,
+    # Thread-local session management (advanced users)
+    set_thread_session,
+    clear_thread_session,
+    get_thread_session,
 )
 
 from .sdk.event import (
@@ -32,6 +36,7 @@ from .sdk.context import (
     session_async,
     run_session,
     run_in_session,
+    thread_worker_with_session,  # Thread isolation helper
     current_session_id,
     current_parent_event_id,
 )
@@ -55,12 +60,15 @@ def _update_session(
     session_eval=None,
     session_eval_reason=None,
     is_successful=None,
-    is_successful_reason=None
+    is_successful_reason=None,
+    session_id=None  # Accept explicit session_id
 ):
     """Update the current session."""
     from .sdk.init import get_resources, get_session_id
-    
-    session_id = get_session_id()
+
+    # Use provided session_id or fall back to context
+    if not session_id:
+        session_id = get_session_id()
     if not session_id:
         return
     
@@ -87,12 +95,15 @@ def _end_session(
     session_eval_reason=None,
     is_successful=None,
     is_successful_reason=None,
-    wait_for_flush=True
+    wait_for_flush=True,
+    session_id=None  # Accept explicit session_id
 ):
     """End the current session."""
     from .sdk.init import get_resources, get_session_id, get_event_queue
-    
-    session_id = get_session_id()
+
+    # Use provided session_id or fall back to context
+    if not session_id:
+        session_id = get_session_id()
     if not session_id:
         return
     
@@ -282,7 +293,7 @@ get_error_history = error_boundary.get_error_history
 clear_error_history = error_boundary.clear_error_history
 
 # Version
-__version__ = "2.0.0"
+__version__ = "2.1.1"
 
 # Apply error boundary wrapping to all SDK functions
 from .sdk.error_boundary import wrap_sdk_function
@@ -371,8 +382,14 @@ __all__ = [
     'session_async',
     'run_session',
     'run_in_session',
+    'thread_worker_with_session',
     'current_session_id',
     'current_parent_event_id',
+
+    # Thread-local session management (advanced)
+    'set_thread_session',
+    'clear_thread_session',
+    'get_thread_session',
     
     # Error types
     'LucidicError',

{lucidicai-2.1.0 → lucidicai-2.1.1}/lucidicai/core/config.py

@@ -19,7 +19,7 @@ class Environment(Enum):
 @dataclass
 class NetworkConfig:
     """Network and connection settings"""
-    base_url: str = "https://api.lucidic.ai/api"
+    base_url: str = "https://backend.lucidic.ai/api"
     timeout: int = 30
     max_retries: int = 3
     backoff_factor: float = 0.5
@@ -31,7 +31,7 @@ class NetworkConfig:
         """Load network configuration from environment variables"""
         debug = os.getenv("LUCIDIC_DEBUG", "False").lower() == "true"
         return cls(
-            base_url="http://localhost:8000/api" if debug else "https://api.lucidic.ai/api",
+            base_url="http://localhost:8000/api" if debug else "https://backend.lucidic.ai/api",
             timeout=int(os.getenv("LUCIDIC_TIMEOUT", "30")),
             max_retries=int(os.getenv("LUCIDIC_MAX_RETRIES", "3")),
             backoff_factor=float(os.getenv("LUCIDIC_BACKOFF_FACTOR", "0.5")),

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

@@ -1,4 +1,4 @@
-"""Async-safe context helpers for session (and step, extensible).
+"""Async-safe and thread-safe context helpers for session (and step, extensible).
 
 This module exposes context variables and helpers to bind a Lucidic
 session to the current execution context (threads/async tasks), so
@@ -11,6 +11,7 @@ import contextvars
 from typing import Optional, Iterator, AsyncIterator, Callable, Any, Dict
 import logging
 import os
+import threading
 
 
 # Context variable for the active Lucidic session id
@@ -26,32 +27,71 @@ current_parent_event_id: contextvars.ContextVar[Optional[str]] = contextvars.Con
 
 
 def set_active_session(session_id: Optional[str]) -> None:
-    """Bind the given session id to the current execution context."""
+    """Bind the given session id to the current execution context.
+
+    Sets both contextvar and thread-local storage when in a thread.
+    """
+    from .init import set_thread_session, is_main_thread
+
     current_session_id.set(session_id)
 
+    # Also set thread-local storage if we're in a non-main thread
+    if session_id and not is_main_thread():
+        set_thread_session(session_id)
+
 
 def clear_active_session() -> None:
-    """Clear any active session binding in the current execution context."""
+    """Clear any active session binding in the current execution context.
+
+    Clears both contextvar and thread-local storage when in a thread.
+    """
+    from .init import clear_thread_session, is_main_thread
+
     current_session_id.set(None)
 
+    # Also clear thread-local storage if we're in a non-main thread
+    if not is_main_thread():
+        clear_thread_session()
+
 
 @contextmanager
 def bind_session(session_id: str) -> Iterator[None]:
-    """Context manager to temporarily bind an active session id."""
+    """Context manager to temporarily bind an active session id.
+
+    Handles both thread-local and context variable storage for proper isolation.
+    """
+    from .init import set_thread_session, clear_thread_session, is_main_thread
+
     token = current_session_id.set(session_id)
+
+    # If we're in a non-main thread, also set thread-local storage
+    thread_local_set = False
+    if not is_main_thread():
+        set_thread_session(session_id)
+        thread_local_set = True
+
     try:
         yield
     finally:
+        if thread_local_set:
+            clear_thread_session()
         current_session_id.reset(token)
 
 
 @asynccontextmanager
 async def bind_session_async(session_id: str) -> AsyncIterator[None]:
     """Async context manager to temporarily bind an active session id."""
+    from .init import set_task_session, clear_task_session
+
     token = current_session_id.set(session_id)
+
+    # Also set task-local for async isolation
+    set_task_session(session_id)
+
     try:
         yield
     finally:
+        clear_task_session()
         current_session_id.reset(token)
 
 
@@ -81,9 +121,11 @@ def session(**init_params) -> Iterator[None]:
     Notes:
     - Ignores any provided auto_end parameter and ends the session on context exit.
     - If LUCIDIC_DEBUG is true, logs a warning about ignoring auto_end.
+    - Handles thread-local storage for proper thread isolation.
     """
     # Lazy import to avoid circular imports
     import lucidicai as lai  # type: ignore
+    from .init import set_thread_session, clear_thread_session, is_main_thread
 
     # Force auto_end to False inside a context manager to control explicit end
     user_auto_end = init_params.get('auto_end', None)
@@ -95,12 +137,22 @@ def session(**init_params) -> Iterator[None]:
 
     session_id = lai.init(**init_params)
     token = current_session_id.set(session_id)
+
+    # If we're in a non-main thread, also set thread-local storage
+    thread_local_set = False
+    if not is_main_thread():
+        set_thread_session(session_id)
+        thread_local_set = True
+
     try:
         yield
     finally:
+        if thread_local_set:
+            clear_thread_session()
         current_session_id.reset(token)
         try:
-            lai.end_session()
+            # Pass session_id explicitly to avoid context issues
+            lai.end_session(session_id=session_id)
         except Exception:
             # Avoid masking the original exception from the with-block
             pass
@@ -110,6 +162,7 @@ def session(**init_params) -> Iterator[None]:
 async def session_async(**init_params) -> AsyncIterator[None]:
     """Async counterpart of session(...)."""
     import lucidicai as lai  # type: ignore
+    from .init import set_task_session, clear_task_session
 
     user_auto_end = init_params.get('auto_end', None)
     init_params = dict(init_params)
@@ -120,12 +173,19 @@ async def session_async(**init_params) -> AsyncIterator[None]:
 
     session_id = lai.init(**init_params)
     token = current_session_id.set(session_id)
+
+    # Set task-local session for true isolation in async
+    set_task_session(session_id)
+
     try:
         yield
     finally:
+        # Clear task-local session first
+        clear_task_session()
         current_session_id.reset(token)
         try:
-            lai.end_session()
+            # Pass session_id explicitly to avoid context issues in async
+            lai.end_session(session_id=session_id)
         except Exception:
             pass
 
@@ -142,3 +202,30 @@ def run_in_session(session_id: str, fn: Callable[..., Any], *fn_args: Any, **fn_
         return fn(*fn_args, **fn_kwargs)
 
 
+def thread_worker_with_session(session_id: str, target: Callable[..., Any], *args, **kwargs) -> Any:
+    """Wrapper for thread worker functions that ensures proper session isolation.
+
+    Use this as the target function for threads to ensure each thread gets
+    its own session context without bleeding from the parent thread.
+
+    Example:
+        thread = Thread(
+            target=thread_worker_with_session,
+            args=(session_id, actual_worker_function, arg1, arg2),
+            kwargs={'key': 'value'}
+        )
+    """
+    from .init import set_thread_session, clear_thread_session
+
+    # Set thread-local session immediately
+    set_thread_session(session_id)
+
+    try:
+        # Also bind to contextvar for compatibility
+        with bind_session(session_id):
+            return target(*args, **kwargs)
+    finally:
+        # Clean up thread-local storage
+        clear_thread_session()
+
+

{lucidicai-2.1.0 → lucidicai-2.1.1}/lucidicai/sdk/event.py

@@ -12,23 +12,27 @@ from ..utils.logger import debug, truncate_id
 def create_event(
     type: str = "generic",
     event_id: Optional[str] = None,
+    session_id: Optional[str] = None,  # accept explicit session_id
     **kwargs
 ) -> str:
     """Create a new event.
-    
+
     Args:
         type: Event type (llm_generation, function_call, error_traceback, generic)
         event_id: Optional client event ID (will generate if not provided)
+        session_id: Optional session ID (will use context if not provided)
         **kwargs: Event-specific fields
-        
+
     Returns:
         Event ID (client-generated or provided UUID)
     """
     # Import here to avoid circular dependency
     from ..sdk.init import get_session_id, get_event_queue
-    
-    # Get current session
-    session_id = get_session_id()
+
+    # Use provided session_id or fall back to context
+    if not session_id:
+        session_id = get_session_id()
+
     if not session_id:
         # No active session, return dummy ID
         debug("[Event] No active session, returning dummy event ID")

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

@@ -4,6 +4,9 @@ This module handles SDK initialization, separating concerns from the main __init
 """
 import uuid
 from typing import List, Optional
+import asyncio
+import threading
+from weakref import WeakKeyDictionary
 
 from ..api.client import HttpClient
 from ..api.resources.event import EventResource
@@ -21,14 +24,18 @@ from opentelemetry.sdk.trace import TracerProvider
 
 class SDKState:
     """Container for SDK runtime state."""
-    
+
     def __init__(self):
         self.http: Optional[HttpClient] = None
         self.event_queue: Optional[EventQueue] = None
         self.session_id: Optional[str] = None
         self.tracer_provider: Optional[TracerProvider] = None
         self.resources = {}
-    
+        # Task-local storage for async task isolation
+        self.task_sessions: WeakKeyDictionary = WeakKeyDictionary()
+        # Thread-local storage for thread isolation
+        self.thread_local = threading.local()
+
     def reset(self):
         """Reset SDK state."""
         # Shutdown telemetry first to ensure all spans are exported
@@ -42,17 +49,21 @@ class SDKState:
                 debug("[SDK] TracerProvider shutdown complete")
             except Exception as e:
                 error(f"[SDK] Error shutting down TracerProvider: {e}")
-        
+
         if self.event_queue:
             self.event_queue.shutdown()
         if self.http:
             self.http.close()
-        
+
         self.http = None
         self.event_queue = None
         self.session_id = None
         self.tracer_provider = None
         self.resources = {}
+        self.task_sessions.clear()
+        # Clear thread-local storage for current thread
+        if hasattr(self.thread_local, 'session_id'):
+            delattr(self.thread_local, 'session_id')
 
 
 # Global SDK state
@@ -243,8 +254,87 @@ def _initialize_telemetry(providers: List[str]) -> None:
     info(f"[Telemetry] Initialized for providers: {providers}")
 
 
+def set_task_session(session_id: str) -> None:
+    """Set session ID for current async task (if in async context)."""
+    try:
+        if task := asyncio.current_task():
+            _sdk_state.task_sessions[task] = session_id
+            debug(f"[SDK] Set task-local session {truncate_id(session_id)} for task {task.get_name()}")
+    except RuntimeError:
+        # Not in async context, ignore
+        pass
+
+
+def clear_task_session() -> None:
+    """Clear session ID for current async task (if in async context)."""
+    try:
+        if task := asyncio.current_task():
+            _sdk_state.task_sessions.pop(task, None)
+            debug(f"[SDK] Cleared task-local session for task {task.get_name()}")
+    except RuntimeError:
+        # Not in async context, ignore
+        pass
+
+
+def set_thread_session(session_id: str) -> None:
+    """Set session ID for current thread.
+
+    This provides true thread-local storage that doesn't inherit from parent thread.
+    """
+    _sdk_state.thread_local.session_id = session_id
+    current_thread = threading.current_thread()
+    debug(f"[SDK] Set thread-local session {truncate_id(session_id)} for thread {current_thread.name}")
+
+
+def clear_thread_session() -> None:
+    """Clear session ID for current thread."""
+    if hasattr(_sdk_state.thread_local, 'session_id'):
+        delattr(_sdk_state.thread_local, 'session_id')
+        current_thread = threading.current_thread()
+        debug(f"[SDK] Cleared thread-local session for thread {current_thread.name}")
+
+
+def get_thread_session() -> Optional[str]:
+    """Get session ID from thread-local storage."""
+    return getattr(_sdk_state.thread_local, 'session_id', None)
+
+
+def is_main_thread() -> bool:
+    """Check if we're running in the main thread."""
+    return threading.current_thread() is threading.main_thread()
+
+
 def get_session_id() -> Optional[str]:
-    """Get the current session ID."""
+    """Get the current session ID.
+
+    Priority:
+    1. Task-local session (for async tasks)
+    2. Thread-local session (for threads) - NO FALLBACK for threads
+    3. SDK state session (for main thread)
+    4. Context variable session (fallback for main thread only)
+    """
+    # First check task-local storage for async isolation
+    try:
+        if task := asyncio.current_task():
+            if task_session := _sdk_state.task_sessions.get(task):
+                debug(f"[SDK] Using task-local session {truncate_id(task_session)}")
+                return task_session
+    except RuntimeError:
+        # Not in async context
+        pass
+
+    # Check if we're in a thread
+    if not is_main_thread():
+        # For threads, ONLY use thread-local storage - no fallback!
+        # This prevents inheriting the parent thread's session
+        thread_session = get_thread_session()
+        if thread_session:
+            debug(f"[SDK] Using thread-local session {truncate_id(thread_session)}")
+        else:
+            debug(f"[SDK] Thread {threading.current_thread().name} has no thread-local session")
+        return thread_session  # Return None if not set - don't fall back!
+
+    # For main thread only: fall back to SDK state or context variable
     return _sdk_state.session_id or current_session_id.get()
 
 

{lucidicai-2.1.0 → lucidicai-2.1.1}/lucidicai/telemetry/litellm_bridge.py

@@ -149,6 +149,7 @@ class LucidicLiteLLMCallback(CustomLogger):
             # Create event with correct field names
             create_event(
                 type="llm_generation",
+                session_id=session_id,  # Pass session_id explicitly
                 provider=provider,
                 model=model,
                 messages=messages,
@@ -210,6 +211,7 @@ class LucidicLiteLLMCallback(CustomLogger):
 
             create_event(
                 type="error_traceback",
+                session_id=session_id,  # Pass session_id explicitly
                 error=error_msg,
                 traceback="",
                 parent_event_id=parent_id,  # This will be normalized by EventBuilder

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

@@ -41,11 +41,18 @@ class LucidicSpanExporter(SpanExporter):
             if not detect_is_llm_span(span):
                 verbose(f"[Telemetry] Skipping non-LLM span: {span.name}")
                 return
-            
+
             debug(f"[Telemetry] Processing LLM span: {span.name}")
 
             attributes = dict(span.attributes or {})
 
+            # 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"):
+                # This might be from incorrect standard instrumentation
+                verbose(f"[Telemetry] Skipping potentially duplicate responses span without our marker")
+                return
+
             # Resolve session id
             target_session_id = attributes.get('lucidic.session_id')
             if not target_session_id:
@@ -84,7 +91,18 @@ class LucidicSpanExporter(SpanExporter):
             provider = self._detect_provider_name(attributes)
             messages = extract_prompts(attributes) or []
             params = self._extract_params(attributes)
-            output_text = extract_completions(span, attributes) or "Response received"
+            output_text = extract_completions(span, attributes)
+
+            # 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
+                if not messages and not attributes.get("lucidic.instrumented"):
+                    verbose(f"[Telemetry] Skipping span {span.name} with no meaningful content")
+                    return
+                # Use a more descriptive default if we must
+                if not output_text:
+                    output_text = "Response received"
+
             input_tokens = self._extract_prompt_tokens(attributes)
             output_tokens = self._extract_completion_tokens(attributes)
             cost = self._calculate_cost(attributes)
@@ -99,9 +117,10 @@ class LucidicSpanExporter(SpanExporter):
             
             try:
                 # Create immutable event via non-blocking queue
-                debug(f"[Telemetry] Creating LLM event with parent_id: {truncate_id(parent_id)}")
+                debug(f"[Telemetry] Creating LLM event with parent_id: {truncate_id(parent_id)}, session_id: {truncate_id(target_session_id)}")
                 event_id = create_event(
                 type="llm_generation",
+                session_id=target_session_id,  # Pass the session_id explicitly
                 occurred_at=occurred_at,
                 duration=duration_seconds,
                 provider=provider,
@@ -155,14 +174,15 @@ class LucidicSpanExporter(SpanExporter):
 
             # Create event
             event_kwargs = {
+                'session_id': target_session_id,  # Pass session_id explicitly
                 'description': description,
                 'result': "Processing...",  # Will be updated when span ends
                 'model': model
             }
-            
+
             if images:
                 event_kwargs['screenshots'] = images
-                
+
             return create_event(**event_kwargs)
             
         except Exception as e:
@@ -225,31 +245,35 @@ class LucidicSpanExporter(SpanExporter):
         }
 
     def _extract_prompt_tokens(self, attributes: Dict[str, Any]) -> int:
-        return (
-            attributes.get(SpanAttributes.LLM_USAGE_PROMPT_TOKENS) or
-            attributes.get('gen_ai.usage.prompt_tokens') or
-            attributes.get('gen_ai.usage.input_tokens') or 0
-        )
+        # Check each attribute and return the first non-None value
+        value = attributes.get(SpanAttributes.LLM_USAGE_PROMPT_TOKENS)
+        if value is not None:
+            return value
+        value = attributes.get('gen_ai.usage.prompt_tokens')
+        if value is not None:
+            return value
+        value = attributes.get('gen_ai.usage.input_tokens')
+        if value is not None:
+            return value
+        return 0
 
     def _extract_completion_tokens(self, attributes: Dict[str, Any]) -> int:
-        return (
-            attributes.get(SpanAttributes.LLM_USAGE_COMPLETION_TOKENS) or
-            attributes.get('gen_ai.usage.completion_tokens') or
-            attributes.get('gen_ai.usage.output_tokens') or 0
-        )
+        # Check each attribute and return the first non-None value
+        value = attributes.get(SpanAttributes.LLM_USAGE_COMPLETION_TOKENS)
+        if value is not None:
+            return value
+        value = attributes.get('gen_ai.usage.completion_tokens')
+        if value is not None:
+            return value
+        value = attributes.get('gen_ai.usage.output_tokens')
+        if value is not None:
+            return value
+        return 0
     
     def _calculate_cost(self, attributes: Dict[str, Any]) -> Optional[float]:
-        prompt_tokens = (
-            attributes.get(SpanAttributes.LLM_USAGE_PROMPT_TOKENS) or
-            attributes.get('gen_ai.usage.prompt_tokens') or
-            attributes.get('gen_ai.usage.input_tokens') or 0
-        )
-        completion_tokens = (
-            attributes.get(SpanAttributes.LLM_USAGE_COMPLETION_TOKENS) or
-            attributes.get('gen_ai.usage.completion_tokens') or
-            attributes.get('gen_ai.usage.output_tokens') or 0
-        )
-        total_tokens = (prompt_tokens or 0) + (completion_tokens or 0)
+        prompt_tokens = self._extract_prompt_tokens(attributes)
+        completion_tokens = self._extract_completion_tokens(attributes)
+        total_tokens = prompt_tokens + completion_tokens
         if total_tokens > 0:
             model = (
                 attributes.get(SpanAttributes.LLM_RESPONSE_MODEL) or

lucidicai-2.1.1/lucidicai/telemetry/openai_patch.py

@@ -0,0 +1,295 @@
+"""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

lucidicai-2.1.1/lucidicai/telemetry/openai_uninstrument.py

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

{lucidicai-2.1.0 → lucidicai-2.1.1}/lucidicai/telemetry/telemetry_init.py

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

{lucidicai-2.1.0 → lucidicai-2.1.1}/lucidicai.egg-info/PKG-INFO

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

{lucidicai-2.1.0 → lucidicai-2.1.1}/lucidicai.egg-info/SOURCES.txt

@@ -34,6 +34,8 @@ lucidicai/telemetry/extract.py
 lucidicai/telemetry/litellm_bridge.py
 lucidicai/telemetry/lucidic_exporter.py
 lucidicai/telemetry/openai_agents_instrumentor.py
+lucidicai/telemetry/openai_patch.py
+lucidicai/telemetry/openai_uninstrument.py
 lucidicai/telemetry/telemetry_init.py
 lucidicai/telemetry/utils/__init__.py
 lucidicai/telemetry/utils/model_pricing.py

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

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