lucidicai 1.2.15__py3-none-any.whl → 1.2.17__py3-none-any.whl

lucidicai/providers/openai_agents_instrumentor.py

@@ -0,0 +1,307 @@
+"""OpenAI Agents SDK instrumentor that hooks into OpenAI API calls"""
+import logging
+from typing import Any, Dict, Optional, List
+from opentelemetry import trace
+from opentelemetry.trace import Status, StatusCode, SpanKind
+from contextlib import contextmanager
+import threading
+import json
+
+logger = logging.getLogger("Lucidic")
+
+# Thread-local storage for context
+_thread_local = threading.local()
+
+
+class OpenAIAgentsInstrumentor:
+    """instrumentor that captures OpenAI API calls within agent runs"""
+    
+    def __init__(self, tracer_provider=None):
+        self._tracer_provider = tracer_provider or trace.get_tracer_provider()
+        self._tracer = self._tracer_provider.get_tracer(__name__)
+        self._is_instrumented = False
+        self._original_openai_create = None
+        
+    def instrument(self):
+        """Enable instrumentation"""
+        if self._is_instrumented:
+            logger.warning("OpenAI Agents SDK already instrumented")
+            return
+            
+        try:
+            # First, patch OpenAI to capture API calls
+            self._patch_openai()
+            
+            # Then set up agents tracing
+            from agents import set_trace_processors
+            from agents.tracing.processors import TracingProcessor
+            
+            processor = OpenAIAgentsTracingProcessor(self)
+            set_trace_processors([processor])
+            
+            self._is_instrumented = True
+            logger.info("OpenAI Agents SDK instrumentation enabled")
+            
+        except Exception as e:
+            logger.error(f"Failed to instrument OpenAI Agents SDK: {e}")
+            raise
+    
+    def uninstrument(self):
+        """Disable instrumentation"""
+        if not self._is_instrumented:
+            return
+            
+        try:
+            # Restore OpenAI
+            self._unpatch_openai()
+            
+            # Restore default processor
+            from agents import set_trace_processors
+            from agents.tracing.processors import default_processor
+            set_trace_processors([default_processor])
+            
+            self._is_instrumented = False
+            logger.info("OpenAI Agents SDK instrumentation disabled")
+            
+        except Exception as e:
+            logger.error(f"Failed to uninstrument: {e}")
+    
+    def _patch_openai(self):
+        """Patch OpenAI client to capture messages"""
+        try:
+            import openai
+            
+            # Store original
+            self._original_openai_create = openai.chat.completions.create
+            
+            def wrapped_create(*args, **kwargs):
+                # Capture the messages
+                messages = kwargs.get('messages', [])
+                
+                # Store in thread local
+                if not hasattr(_thread_local, 'current_messages'):
+                    _thread_local.current_messages = []
+                _thread_local.current_messages = messages
+                
+                # Call original
+                response = self._original_openai_create(*args, **kwargs)
+                
+                # Store response
+                _thread_local.current_response = response
+                
+                return response
+            
+            # Replace
+            openai.chat.completions.create = wrapped_create
+            logger.debug("Patched OpenAI chat.completions.create")
+            
+        except Exception as e:
+            logger.error(f"Failed to patch OpenAI: {e}")
+    
+    def _unpatch_openai(self):
+        """Restore OpenAI client"""
+        if self._original_openai_create:
+            try:
+                import openai
+                openai.chat.completions.create = self._original_openai_create
+                logger.debug("Restored OpenAI chat.completions.create")
+            except:
+                pass
+
+
+class OpenAIAgentsTracingProcessor:
+    """processor that captures richer data"""
+    
+    def __init__(self, instrumentor: OpenAIAgentsInstrumentor):
+        self.instrumentor = instrumentor
+        self.tracer = instrumentor._tracer
+        self._active_spans = {}
+        self._agent_context = {}  # Store agent context
+        
+    def on_span_start(self, span_data: Any) -> None:
+        """Called when a span starts"""
+        try:
+            span_id = str(id(span_data))
+            actual_data = getattr(span_data, 'span_data', span_data)
+            data_type = actual_data.__class__.__name__
+            
+            # Create span name
+            if hasattr(actual_data, 'name'):
+                span_name = f"openai.agents.{actual_data.name}"
+                agent_name = actual_data.name
+            else:
+                span_name = f"openai.agents.{data_type}"
+                agent_name = data_type
+            
+            # For agent spans, store context
+            if data_type == "AgentSpanData":
+                self._agent_context[agent_name] = {
+                    'instructions': getattr(actual_data, 'instructions', None),
+                    'name': agent_name
+                }
+            
+            # Create span
+            otel_span = self.tracer.start_span(
+                name=span_name,
+                kind=SpanKind.INTERNAL,
+                attributes={
+                    "gen_ai.system": "openai_agents",
+                    "gen_ai.operation.name": data_type.lower().replace("spandata", ""),
+                }
+            )
+            
+            # Add agent name
+            if hasattr(actual_data, 'name'):
+                otel_span.set_attribute("gen_ai.agent.name", actual_data.name)
+            
+            self._active_spans[span_id] = {
+                'span': otel_span,
+                'type': data_type,
+                'data': actual_data
+            }
+            
+        except Exception as e:
+            logger.error(f"Error in on_span_start: {e}")
+    
+    def on_span_end(self, span_data: Any) -> None:
+        """Called when a span ends"""
+        try:
+            span_id = str(id(span_data))
+            
+            if span_id not in self._active_spans:
+                return
+            
+            span_info = self._active_spans.pop(span_id)
+            otel_span = span_info['span']
+            data_type = span_info['type']
+            actual_data = getattr(span_data, 'span_data', span_data)
+            
+            # Handle different span types
+            if data_type == "ResponseSpanData":
+                self._handle_response_span(otel_span, actual_data)
+            elif data_type == "FunctionSpanData":
+                self._handle_function_span(otel_span, actual_data)
+            elif data_type == "AgentSpanData":
+                self._handle_agent_span(otel_span, actual_data)
+            
+            # Set status and end
+            otel_span.set_status(Status(StatusCode.OK))
+            otel_span.end()
+            
+        except Exception as e:
+            logger.error(f"Error in on_span_end: {e}")
+    
+    def _handle_response_span(self, otel_span: Any, span_data: Any) -> None:
+        """Handle response span - this is where we capture prompts and completions"""
+        try:
+            # Log what we're working with
+            logger.debug(f"Handling response span, span_data type: {type(span_data)}")
+            
+            # First check span_data.input for user messages
+            prompt_index = 0
+            
+            # Get instructions (system prompt) from response
+            if hasattr(span_data, 'response') and span_data.response:
+                resp = span_data.response
+                if hasattr(resp, 'instructions') and resp.instructions:
+                    otel_span.set_attribute(f"gen_ai.prompt.{prompt_index}.role", "system")
+                    otel_span.set_attribute(f"gen_ai.prompt.{prompt_index}.content", str(resp.instructions)[:2048])
+                    prompt_index += 1
+            
+            # Get user messages from span_data.input
+            if hasattr(span_data, 'input') and span_data.input:
+                if isinstance(span_data.input, list):
+                    # Input is a list of messages
+                    for msg in span_data.input:
+                        if isinstance(msg, dict):
+                            role = msg.get('role', '')
+                            content = msg.get('content', '')
+                            otel_span.set_attribute(f"gen_ai.prompt.{prompt_index}.role", role)
+                            otel_span.set_attribute(f"gen_ai.prompt.{prompt_index}.content", str(content)[:2048])
+                            prompt_index += 1
+                elif isinstance(span_data.input, str):
+                    # Input is a string
+                    otel_span.set_attribute(f"gen_ai.prompt.{prompt_index}.role", "user")
+                    otel_span.set_attribute(f"gen_ai.prompt.{prompt_index}.content", str(span_data.input)[:2048])
+                    prompt_index += 1
+            
+            # Get response from output
+            if hasattr(span_data, 'response') and span_data.response:
+                resp = span_data.response
+                
+                # Look for the assistant's response in output
+                if hasattr(resp, 'output') and resp.output:
+                    for item in resp.output:
+                        if hasattr(item, 'type') and item.type == 'message':
+                            if hasattr(item, 'content'):
+                                content = item.content
+                                if isinstance(content, list):
+                                    # Extract text
+                                    texts = []
+                                    for c in content:
+                                        if hasattr(c, 'text'):
+                                            texts.append(c.text)
+                                    if texts:
+                                        content = " ".join(texts)
+                                
+                                otel_span.set_attribute("gen_ai.completion.0.role", "assistant")
+                                otel_span.set_attribute("gen_ai.completion.0.content", str(content)[:2048])
+                                break
+            
+            # Note: Response extraction from thread local was removed since we already
+            # extract the completion from span_data.response.output above
+            
+            # Set model and usage
+            if hasattr(span_data, 'response') and span_data.response:
+                resp = span_data.response
+                if hasattr(resp, 'model'):
+                    otel_span.set_attribute("gen_ai.response.model", resp.model)
+                    otel_span.set_attribute("gen_ai.request.model", resp.model)
+                
+                if hasattr(resp, 'usage') and resp.usage:
+                    usage = resp.usage
+                    if hasattr(usage, 'input_tokens'):
+                        otel_span.set_attribute("gen_ai.usage.prompt_tokens", usage.input_tokens)
+                    if hasattr(usage, 'output_tokens'):
+                        otel_span.set_attribute("gen_ai.usage.completion_tokens", usage.output_tokens)
+                    if hasattr(usage, 'total_tokens'):
+                        otel_span.set_attribute("gen_ai.usage.total_tokens", usage.total_tokens)
+                        
+        except Exception as e:
+            logger.error(f"Error handling response span: {e}")
+    
+    def _handle_function_span(self, otel_span: Any, span_data: Any) -> None:
+        """Handle function/tool spans"""
+        if hasattr(span_data, 'name'):
+            otel_span.set_attribute("gen_ai.tool.name", span_data.name)
+        
+        if hasattr(span_data, 'input'):
+            otel_span.set_attribute("gen_ai.tool.parameters", json.dumps(span_data.input)[:500])
+        
+        if hasattr(span_data, 'output'):
+            otel_span.set_attribute("gen_ai.tool.result", str(span_data.output)[:500])
+    
+    def _handle_agent_span(self, otel_span: Any, span_data: Any) -> None:
+        """Handle agent spans"""
+        # Agent spans typically don't have much data at end
+        pass
+    
+    def on_trace_start(self, trace_data: Any) -> None:
+        """Called when a trace starts"""
+        # Clear thread local
+        if hasattr(_thread_local, 'current_messages'):
+            del _thread_local.current_messages
+        if hasattr(_thread_local, 'current_response'):
+            del _thread_local.current_response
+    
+    def on_trace_end(self, trace_data: Any) -> None:
+        """Called when a trace ends"""
+        pass
+    
+    def force_flush(self, timeout_seconds: float = 30.0) -> bool:
+        """Force flush"""
+        return True
+    
+    def shutdown(self) -> None:
+        """Shutdown"""
+        pass

lucidicai/providers/openai_handler.py

@@ -122,20 +122,7 @@ class OpenAIHandler(BaseProvider):
                 if session is None:
                     logger.info(f"[OpenAI Handler] No session, skipping tracking")
                     return await original_method(*args, **kwargs)
-                
-                # Auto-create step if no active step exists
-                if session.active_step is None:
-                    logger.info(f"[OpenAI Handler] No active step, auto-creating step")
-                    try:
-                        step_id = session.create_step(
-                            state="Auto-created step for API call",
-                            action=f"Execute {method_name}",
-                            goal="Process API request"
-                        )
-                        logger.info(f"[OpenAI Handler] Created step: {step_id}")
-                    except Exception as e:
-                        logger.error(f"[OpenAI Handler] Failed to auto-create step: {e}")
-                        return await original_method(*args, **kwargs)
+
                 
                 # Prepare kwargs
                 self._prepare_streaming_kwargs(method_name, kwargs)
@@ -157,20 +144,6 @@ class OpenAIHandler(BaseProvider):
                     logger.info(f"[OpenAI Handler] No session, skipping tracking")
                     return original_method(*args, **kwargs)
                 
-                # Auto-create step if no active step exists
-                if session.active_step is None:
-                    logger.info(f"[OpenAI Handler] No active step, auto-creating step")
-                    try:
-                        step_id = session.create_step(
-                            state="Auto-created step for API call",
-                            action=f"Execute {method_name}",
-                            goal="Process API request"
-                        )
-                        logger.info(f"[OpenAI Handler] Created step: {step_id}")
-                    except Exception as e:
-                        logger.error(f"[OpenAI Handler] Failed to auto-create step: {e}")
-                        return original_method(*args, **kwargs)
-                
                 # Prepare kwargs
                 self._prepare_streaming_kwargs(method_name, kwargs)
                 
@@ -394,20 +367,6 @@ class OpenAIHandler(BaseProvider):
                 logger.info(f"[OpenAI Handler] No session, skipping tracking")
                 return await original_method(*args, **kwargs)
             
-            # Auto-create step if no active step exists
-            if session.active_step is None:
-                logger.info(f"[OpenAI Handler] No active step, auto-creating step")
-                try:
-                    step_id = session.create_step(
-                        state="Auto-created step for responses API call",
-                        action="Execute responses.create",
-                        goal="Process API request"
-                    )
-                    logger.info(f"[OpenAI Handler] Created step: {step_id}")
-                except Exception as e:
-                    logger.error(f"[OpenAI Handler] Failed to auto-create step: {e}")
-                    return await original_method(*args, **kwargs)
-            
             # Check for agent context
             agent_name = self._get_agent_name_from_input(kwargs.get('input', []))
             
@@ -500,20 +459,6 @@ class OpenAIHandler(BaseProvider):
                 logger.info(f"[OpenAI Handler] No session, skipping tracking")
                 return original_method(*args, **kwargs)
             
-            # Auto-create step if no active step exists
-            if session.active_step is None:
-                logger.info(f"[OpenAI Handler] No active step, auto-creating step")
-                try:
-                    step_id = session.create_step(
-                        state="Auto-created step for responses API call",
-                        action="Execute responses.create",
-                        goal="Process API request"
-                    )
-                    logger.info(f"[OpenAI Handler] Created step: {step_id}")
-                except Exception as e:
-                    logger.error(f"[OpenAI Handler] Failed to auto-create step: {e}")
-                    return original_method(*args, **kwargs)
-            
             # Check for agent context
             agent_name = self._get_agent_name_from_input(kwargs.get('input', []))
             

lucidicai/providers/otel_handlers.py

@@ -0,0 +1,266 @@
+"""OpenTelemetry-based handlers that maintain backward compatibility"""
+import logging
+from typing import Optional
+
+from .base_providers import BaseProvider
+from .otel_init import LucidicTelemetry
+
+logger = logging.getLogger("Lucidic")
+
+
+class OTelOpenAIHandler(BaseProvider):
+    """OpenAI handler using OpenTelemetry instrumentation"""
+    
+    def __init__(self):
+        super().__init__()
+        self._provider_name = "OpenAI"
+        self.telemetry = LucidicTelemetry()
+        
+    def handle_response(self, response, kwargs, session: Optional = None):
+        """Not needed with OpenTelemetry approach"""
+        return response
+        
+    def override(self):
+        """Enable OpenAI instrumentation"""
+        try:
+            from lucidicai.client import Client
+            client = Client()
+            
+            # Initialize telemetry if needed
+            if not self.telemetry.is_initialized():
+                self.telemetry.initialize(agent_id=client.agent_id)
+                
+            # Instrument OpenAI
+            self.telemetry.instrument_providers(["openai"])
+            
+            # Also patch OpenAI client to intercept images
+            try:
+                import openai
+                from .universal_image_interceptor import UniversalImageInterceptor, patch_openai_client
+                
+                # Create interceptor for OpenAI
+                interceptor = UniversalImageInterceptor.create_interceptor("openai")
+                
+                # Patch the module-level create method
+                if hasattr(openai, 'ChatCompletion'):
+                    # Old API
+                    original = openai.ChatCompletion.create
+                    openai.ChatCompletion.create = interceptor(original)
+                    
+                # Also patch any client instances that might be created
+                original_client_init = openai.OpenAI.__init__
+                def patched_init(self, *args, **kwargs):
+                    original_client_init(self, *args, **kwargs)
+                    # Patch this instance
+                    patch_openai_client(self)
+                
+                openai.OpenAI.__init__ = patched_init
+                
+                # Also patch AsyncOpenAI
+                if hasattr(openai, 'AsyncOpenAI'):
+                    original_async_init = openai.AsyncOpenAI.__init__
+                    def patched_async_init(self, *args, **kwargs):
+                        original_async_init(self, *args, **kwargs)
+                        # Patch this instance
+                        patch_openai_client(self)
+                    
+                    openai.AsyncOpenAI.__init__ = patched_async_init
+                
+            except Exception as e:
+                logger.warning(f"Could not patch OpenAI for image interception: {e}")
+            
+            logger.info("[OTel OpenAI Handler] Instrumentation enabled")
+            
+        except Exception as e:
+            logger.error(f"Failed to enable OpenAI instrumentation: {e}")
+            raise
+            
+    def undo_override(self):
+        """Disable instrumentation"""
+        # Telemetry uninstrumentation is handled globally
+        logger.info("[OTel OpenAI Handler] Instrumentation will be disabled on shutdown")
+
+
+class OTelAnthropicHandler(BaseProvider):
+    """Anthropic handler using OpenTelemetry instrumentation"""
+    
+    def __init__(self):
+        super().__init__()
+        self._provider_name = "Anthropic"
+        self.telemetry = LucidicTelemetry()
+        
+    def handle_response(self, response, kwargs, session: Optional = None):
+        """Not needed with OpenTelemetry approach"""
+        return response
+        
+    def override(self):
+        """Enable Anthropic instrumentation"""
+        try:
+            from lucidicai.client import Client
+            client = Client()
+            
+            # Initialize telemetry if needed
+            if not self.telemetry.is_initialized():
+                self.telemetry.initialize(agent_id=client.agent_id)
+                
+            # Instrument Anthropic
+            self.telemetry.instrument_providers(["anthropic"])
+            
+            # Also patch Anthropic client to intercept images
+            try:
+                import anthropic
+                from .universal_image_interceptor import UniversalImageInterceptor, patch_anthropic_client
+                
+                # Create interceptors for Anthropic
+                interceptor = UniversalImageInterceptor.create_interceptor("anthropic")
+                async_interceptor = UniversalImageInterceptor.create_async_interceptor("anthropic")
+                
+                # Patch any client instances that might be created
+                original_client_init = anthropic.Anthropic.__init__
+                def patched_init(self, *args, **kwargs):
+                    original_client_init(self, *args, **kwargs)
+                    # Patch this instance
+                    patch_anthropic_client(self)
+                
+                anthropic.Anthropic.__init__ = patched_init
+                
+                # Also patch async client
+                if hasattr(anthropic, 'AsyncAnthropic'):
+                    original_async_init = anthropic.AsyncAnthropic.__init__
+                    def patched_async_init(self, *args, **kwargs):
+                        original_async_init(self, *args, **kwargs)
+                        # Patch this instance
+                        patch_anthropic_client(self)
+                    
+                    anthropic.AsyncAnthropic.__init__ = patched_async_init
+                
+            except Exception as e:
+                logger.warning(f"Could not patch Anthropic for image interception: {e}")
+            
+            logger.info("[OTel Anthropic Handler] Instrumentation enabled")
+            
+        except Exception as e:
+            logger.error(f"Failed to enable Anthropic instrumentation: {e}")
+            raise
+            
+    def undo_override(self):
+        """Disable instrumentation"""
+        logger.info("[OTel Anthropic Handler] Instrumentation will be disabled on shutdown")
+
+
+class OTelLangChainHandler(BaseProvider):
+    """LangChain handler using OpenTelemetry instrumentation"""
+    
+    def __init__(self):
+        super().__init__()
+        self._provider_name = "LangChain"
+        self.telemetry = LucidicTelemetry()
+        
+    def handle_response(self, response, kwargs, session: Optional = None):
+        """Not needed with OpenTelemetry approach"""
+        return response
+        
+    def override(self):
+        """Enable LangChain instrumentation"""
+        try:
+            from lucidicai.client import Client
+            client = Client()
+            
+            # Initialize telemetry if needed
+            if not self.telemetry.is_initialized():
+                self.telemetry.initialize(agent_id=client.agent_id)
+                
+            # Instrument LangChain
+            self.telemetry.instrument_providers(["langchain"])
+            
+            logger.info("[OTel LangChain Handler] Instrumentation enabled")
+            
+        except Exception as e:
+            logger.error(f"Failed to enable LangChain instrumentation: {e}")
+            raise
+            
+    def undo_override(self):
+        """Disable instrumentation"""
+        logger.info("[OTel LangChain Handler] Instrumentation will be disabled on shutdown")
+
+
+class OTelPydanticAIHandler(BaseProvider):
+    """Pydantic AI handler - requires custom implementation"""
+    
+    def __init__(self):
+        super().__init__()
+        self._provider_name = "PydanticAI"
+        self.telemetry = LucidicTelemetry()
+        self._original_methods = {}
+        
+    def handle_response(self, response, kwargs, session: Optional = None):
+        """Handle Pydantic AI responses"""
+        return response
+        
+    def override(self):
+        """Enable Pydantic AI instrumentation"""
+        try:
+            from lucidicai.client import Client
+            client = Client()
+            
+            # Initialize telemetry if needed
+            if not self.telemetry.is_initialized():
+                self.telemetry.initialize(agent_id=client.agent_id)
+                
+            # For now, we'll use the original Pydantic AI handler
+            # until OpenLLMetry adds support
+            from .pydantic_ai_handler import PydanticAIHandler
+            self._fallback_handler = PydanticAIHandler()
+            self._fallback_handler.override()
+            
+            logger.info("[OTel PydanticAI Handler] Using fallback handler until OpenLLMetry support is available")
+            
+        except Exception as e:
+            logger.error(f"Failed to enable Pydantic AI instrumentation: {e}")
+            raise
+            
+    def undo_override(self):
+        """Disable instrumentation"""
+        if hasattr(self, '_fallback_handler'):
+            self._fallback_handler.undo_override()
+        logger.info("[OTel PydanticAI Handler] Instrumentation disabled")
+
+
+class OTelOpenAIAgentsHandler(BaseProvider):
+    """OpenAI Agents handler using OpenTelemetry instrumentation"""
+    
+    def __init__(self):
+        super().__init__()
+        self._provider_name = "OpenAI Agents"
+        self.telemetry = LucidicTelemetry()
+        self._is_instrumented = False
+        
+    def handle_response(self, response, kwargs, session: Optional = None):
+        """Not needed with OpenTelemetry approach"""
+        return response
+        
+    def override(self):
+        """Enable OpenAI Agents instrumentation"""
+        try:
+            from lucidicai.client import Client
+            client = Client()
+            
+            # Initialize telemetry if needed
+            if not self.telemetry.is_initialized():
+                self.telemetry.initialize(agent_id=client.agent_id)
+                
+            # Only instrument OpenAI Agents (it will handle OpenAI calls internally)
+            self.telemetry.instrument_providers(["openai_agents"])
+            
+            self._is_instrumented = True
+            
+            logger.info("[OTel OpenAI Agents Handler] Full instrumentation enabled")
+            
+        except Exception as e:
+            logger.error(f"Failed to enable OpenAI Agents instrumentation: {e}")
+            raise
+            
+    def undo_override(self):
+        """Disable instrumentation"""
+        self._is_instrumented = False
+        logger.info("[OTel OpenAI Agents Handler] Instrumentation will be disabled on shutdown")