lucidicai 1.2.19__py3-none-any.whl → 1.2.20__py3-none-any.whl

lucidicai/__init__.py

@@ -16,7 +16,8 @@ from .telemetry.otel_handlers import (
     OTelAnthropicHandler,
     OTelLangChainHandler,
     OTelPydanticAIHandler,
-    OTelOpenAIAgentsHandler
+    OTelOpenAIAgentsHandler,
+    OTelLiteLLMHandler
 )
 
 # Import telemetry manager
@@ -25,7 +26,7 @@ from .telemetry.otel_init import LucidicTelemetry
 # Import decorators
 from .decorators import step, event
 
-ProviderType = Literal["openai", "anthropic", "langchain", "pydantic_ai", "openai_agents"]
+ProviderType = Literal["openai", "anthropic", "langchain", "pydantic_ai", "openai_agents", "litellm"]
 
 # Configure logging
 logger = logging.getLogger("Lucidic")
@@ -77,6 +78,9 @@ def _setup_providers(client: Client, providers: List[ProviderType]) -> None:
             except Exception as e:
                 logger.error(f"Failed to set up OpenAI Agents provider: {e}")
                 raise
+        elif provider == "litellm":
+            client.set_provider(OTelLiteLLMHandler())
+            setup_providers.add("litellm")
 
 __all__ = [
     'Client',
@@ -267,6 +271,13 @@ def end_session(
     client = Client()
     if not client.session:
         return
+    
+    # Wait for any pending LiteLLM callbacks before ending session
+    for provider in client.providers:
+        if hasattr(provider, '_callback') and hasattr(provider._callback, 'wait_for_pending_callbacks'):
+            logger.info("Waiting for LiteLLM callbacks to complete before ending session...")
+            provider._callback.wait_for_pending_callbacks(timeout=5.0)
+    
     client.session.update_session(is_finished=True, **locals())
     client.clear()
 

lucidicai/event.py

@@ -33,7 +33,7 @@ class Event:
         from .client import Client
         if 'screenshots' in kwargs and kwargs['screenshots'] is not None:
             for i in range(len(kwargs['screenshots'])):
-                presigned_url, bucket_name, object_key = get_presigned_url(Client().agent_id, session_id=self.session_id, event_id=self.event_id, nthscreenshot=i + len(self.screenshots))
+                presigned_url, bucket_name, object_key = get_presigned_url(Client().agent_id, session_id=self.session_id, event_id=self.event_id, nthscreenshot=len(self.screenshots))
                 upload_image_to_s3(presigned_url, kwargs['screenshots'][i], "JPEG")
                 self.screenshots.append(kwargs['screenshots'][i])
         if 'is_finished' in kwargs:

lucidicai/model_pricing.py

@@ -29,9 +29,9 @@ MODEL_PRICING = {
     # OpenAI o-Series (Reasoning Models) - Verified 2025
     "o1": {"input": 15.0, "output": 60.0},
     "o1-preview": {"input": 15.0, "output": 60.0},
-    "o1-mini": {"input": 3.0, "output": 15.0},  # Corrected: was 12.0
-    "o3": {"input": 15.0, "output": 60.0},  # Estimated based on o1
-    "o3-mini": {"input": 1.1, "output": 4.4},  # Verified
+    "o1-mini": {"input": 3.0, "output": 15.0}, 
+    "o3": {"input": 15.0, "output": 60.0}, 
+    "o3-mini": {"input": 1.1, "output": 4.4}, 
     "o4-mini": {"input": 4.00, "output": 16.0},
     
     # OpenAI Legacy Models
@@ -48,7 +48,7 @@ MODEL_PRICING = {
     # Claude 3.5 Models - Verified 2025
     "claude-3-5-sonnet": {"input": 3.0, "output": 15.0},
     "claude-3-5-sonnet-latest": {"input": 3.0, "output": 15.0},
-    "claude-3-5-haiku": {"input": 1.0, "output": 5.0},  # Corrected: was 0.8/4.0
+    "claude-3-5-haiku": {"input": 1.0, "output": 5.0}, 
     "claude-3-5-haiku-latest": {"input": 1.0, "output": 5.0},
     "claude-3-7-sonnet": {"input": 3.0, "output": 15.0},  # Same as 3.5 sonnet
     "claude-3-7-sonnet-latest": {"input": 3.0, "output": 15.0},
@@ -106,17 +106,17 @@ MODEL_PRICING = {
     "meta-llama/llama-guard-4-12b-128k": {"input": 0.20, "output": 0.20},
     
     # Meta Llama 3.x Series - Verified 2025 (Together AI pricing)
-    "llama-3.3-70b": {"input": 0.54, "output": 0.88},  # Corrected
-    "llama-3.1-405b": {"input": 6.0, "output": 12.0},   # Corrected (Cerebras pricing)
-    "llama-3.1-70b": {"input": 0.54, "output": 0.88},   # Corrected
-    "llama-3.1-8b": {"input": 0.10, "output": 0.18},    # Corrected
-    "llama-3-70b": {"input": 0.54, "output": 0.88},     # Using consistent pricing
-    "llama-3-8b": {"input": 0.10, "output": 0.18},      # Using consistent pricing
+    "llama-3.3-70b": {"input": 0.54, "output": 0.88}, 
+    "llama-3.1-405b": {"input": 6.0, "output": 12.0},  
+    "llama-3.1-70b": {"input": 0.54, "output": 0.88},  
+    "llama-3.1-8b": {"input": 0.10, "output": 0.18},   
+    "llama-3-70b": {"input": 0.54, "output": 0.88},    
+    "llama-3-8b": {"input": 0.10, "output": 0.18},     
     "llama-guard-3-8b": {"input": 0.20, "output": 0.20},
-    "meta-llama/llama-3.3-70b-versatile-128k": {"input": 0.54, "output": 0.88},  # Updated
-    "meta-llama/llama-3.1-8b-instant-128k": {"input": 0.10, "output": 0.18},     # Updated
-    "meta-llama/llama-3-70b-8k": {"input": 0.54, "output": 0.88},                # Updated
-    "meta-llama/llama-3-8b-8k": {"input": 0.10, "output": 0.18},                 # Updated
+    "meta-llama/llama-3.3-70b-versatile-128k": {"input": 0.54, "output": 0.88}, 
+    "meta-llama/llama-3.1-8b-instant-128k": {"input": 0.10, "output": 0.18},     
+    "meta-llama/llama-3-70b-8k": {"input": 0.54, "output": 0.88},                
+    "meta-llama/llama-3-8b-8k": {"input": 0.10, "output": 0.18},                 
     "meta-llama/llama-guard-3-8b-8k": {"input": 0.20, "output": 0.20},
     
     # Mistral Models
@@ -149,7 +149,7 @@ MODEL_PRICING = {
     "qwen-turbo": {"input": 0.3, "output": 0.6},
     "qwen-plus": {"input": 0.5, "output": 2.0},
     "qwen-max": {"input": 2.0, "output": 6.0},
-    "qwen2.5-32b-instruct": {"input": 0.7, "output": "2.8"},
+    "qwen2.5-32b-instruct": {"input": 0.7, "output": 2.8},
     "qwen2.5-max": {"input": 1.6, "output": 6.4},
     
     # Google Gemma Models

lucidicai/telemetry/litellm_bridge.py

@@ -0,0 +1,369 @@
+"""Bridge between LiteLLM's CustomLogger and Lucidic's telemetry system"""
+import logging
+import os
+import time
+import threading
+from typing import Dict, Any, Optional, List
+from datetime import datetime
+
+try:
+    from litellm import CustomLogger
+except ImportError:
+    # Create a dummy CustomLogger if litellm is not installed
+    class CustomLogger:
+        def __init__(self, **kwargs):
+            pass
+
+from lucidicai.client import Client
+from lucidicai.model_pricing import calculate_cost
+
+logger = logging.getLogger("Lucidic")
+DEBUG = os.getenv("LUCIDIC_DEBUG", "False") == "True"
+
+
+class LucidicLiteLLMCallback(CustomLogger):
+    """
+    Custom callback for LiteLLM that bridges to Lucidic's event system.
+    
+    This callback integrates LiteLLM's logging with Lucidic's session/step/event hierarchy,
+    enabling automatic tracking of all LiteLLM-supported providers.
+    """
+    
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._active_events = {}  # Track active events for streaming
+        self._pending_callbacks = set()  # Track pending callback executions
+        self._callback_lock = threading.Lock()  # Thread-safe callback tracking
+        
+    def _register_callback(self, callback_id: str):
+        """Register a callback as pending"""
+        with self._callback_lock:
+            self._pending_callbacks.add(callback_id)
+            if DEBUG:
+                logger.info(f"LiteLLM Bridge: Registered callback {callback_id}, pending: {len(self._pending_callbacks)}")
+    
+    def _complete_callback(self, callback_id: str):
+        """Mark a callback as completed"""
+        with self._callback_lock:
+            self._pending_callbacks.discard(callback_id)
+            if DEBUG:
+                logger.info(f"LiteLLM Bridge: Completed callback {callback_id}, pending: {len(self._pending_callbacks)}")
+    
+    def wait_for_pending_callbacks(self, timeout: float = 5.0):
+        """Wait for all pending callbacks to complete"""
+        start_time = time.time()
+        
+        while time.time() - start_time < timeout:
+            with self._callback_lock:
+                if not self._pending_callbacks:
+                    if DEBUG:
+                        logger.info("LiteLLM Bridge: All callbacks completed")
+                    return True
+            
+            time.sleep(0.1)  # Check every 100ms
+        
+        # Timeout reached
+        with self._callback_lock:
+            pending_count = len(self._pending_callbacks)
+            if pending_count > 0:
+                logger.warning(f"LiteLLM Bridge: Timeout waiting for {pending_count} callbacks")
+                # Clear pending callbacks to avoid memory leak
+                self._pending_callbacks.clear()
+        
+        return False
+        
+    def log_pre_api_call(self, model, messages, kwargs):
+        """Called before the LLM API call"""
+        try:
+            client = Client()
+            if not client.session:
+                return
+                
+            # Extract description from messages
+            description = self._format_messages(messages)
+            
+            # Apply masking if configured
+            if hasattr(client, 'mask') and callable(client.mask):
+                description = client.mask(description)
+                
+            # Store pre-call info for later use
+            call_id = kwargs.get("litellm_call_id", str(time.time())) if kwargs else str(time.time())
+            self._active_events[call_id] = {
+                "model": model,
+                "messages": messages,
+                "description": description,
+                "start_time": time.time()
+            }
+            
+        except Exception as e:
+            logger.error(f"LiteLLM Bridge error in pre_api_call: {e}")
+            if DEBUG:
+                import traceback
+                traceback.print_exc()
+    
+    def log_success_event(self, kwargs, response_obj, start_time, end_time):
+        """Called on successful LLM completion"""
+        # Generate unique callback ID
+        callback_id = f"success_{id(kwargs)}_{start_time}"
+        self._register_callback(callback_id)
+        
+        try:
+            client = Client()
+            if not client.session:
+                self._complete_callback(callback_id)
+                return
+                
+            # Get call info
+            call_id = kwargs.get("litellm_call_id", str(start_time))
+            pre_call_info = self._active_events.pop(call_id, {})
+            
+            # Extract model and provider info
+            model = kwargs.get("model", pre_call_info.get("model", "unknown"))
+            provider = self._extract_provider(model)
+            
+            # Get messages for description
+            messages = kwargs.get("messages", pre_call_info.get("messages", []))
+            description = pre_call_info.get("description") or self._format_messages(messages)
+            
+            # Extract response content
+            result = self._extract_response_content(response_obj)
+            
+            # Apply masking to result if configured
+            if hasattr(client, 'mask') and callable(client.mask):
+                result = client.mask(result)
+            
+            # Calculate cost if usage info is available
+            usage = self._extract_usage(response_obj)
+            cost = None
+            if usage:
+                cost = self._calculate_litellm_cost(model, usage)
+            
+            # Extract any images from multimodal requests
+            images = self._extract_images_from_messages(messages)
+            
+            # Create event
+            event_kwargs = {
+                "description": description,
+                "result": result,
+                "model": f"{provider}/{model}" if "/" not in model else model,
+                "is_finished": True
+            }
+            
+            if cost is not None:
+                event_kwargs["cost_added"] = cost
+                
+            if images:
+                event_kwargs["screenshots"] = images
+                
+            # Add metadata
+            metadata = {
+                "provider": provider,
+                "duration_ms": (end_time - start_time) * 1000,
+                "litellm": True
+            }
+            if usage:
+                metadata["usage"] = usage
+                
+            event_kwargs["metadata"] = metadata
+            
+            # Create the event
+            client.session.create_event(**event_kwargs)
+            
+            if DEBUG:
+                logger.info(f"LiteLLM Bridge: Created event for {model} completion")
+                
+        except Exception as e:
+            logger.error(f"LiteLLM Bridge error in log_success_event: {e}")
+            if DEBUG:
+                import traceback
+                traceback.print_exc()
+        finally:
+            self._complete_callback(callback_id)
+    
+    def log_failure_event(self, kwargs, response_obj, start_time, end_time):
+        """Called on failed LLM completion"""
+        # Generate unique callback ID
+        callback_id = f"failure_{id(kwargs)}_{start_time}"
+        self._register_callback(callback_id)
+        
+        try:
+            client = Client()
+            if not client.session:
+                self._complete_callback(callback_id)
+                return
+                
+            # Get call info
+            call_id = kwargs.get("litellm_call_id", str(start_time))
+            pre_call_info = self._active_events.pop(call_id, {})
+            
+            # Extract model info
+            model = kwargs.get("model", pre_call_info.get("model", "unknown"))
+            provider = self._extract_provider(model)
+            
+            # Get messages for description
+            messages = kwargs.get("messages", pre_call_info.get("messages", []))
+            description = pre_call_info.get("description") or self._format_messages(messages)
+            
+            # Format error
+            error_msg = str(response_obj) if response_obj else "Unknown error"
+            
+            # Create failed event
+            event_kwargs = {
+                "description": description,
+                "result": f"Error: {error_msg}",
+                "model": f"{provider}/{model}" if "/" not in model else model,
+                "is_finished": True,
+                "metadata": {
+                    "provider": provider,
+                    "duration_ms": (end_time - start_time) * 1000,
+                    "litellm": True,
+                    "error": True
+                }
+            }
+            
+            client.session.create_event(**event_kwargs)
+            
+            if DEBUG:
+                logger.info(f"LiteLLM Bridge: Created error event for {model}")
+                
+        except Exception as e:
+            logger.error(f"LiteLLM Bridge error in log_failure_event: {e}")
+            if DEBUG:
+                import traceback
+                traceback.print_exc()
+        finally:
+            self._complete_callback(callback_id)
+    
+    def log_stream_event(self, kwargs, response_obj, start_time, end_time):
+        """Called for streaming responses"""
+        # For now, we'll handle the complete response in log_success_event
+        # This could be enhanced to show real-time streaming updates
+        pass
+    
+    async def async_log_success_event(self, kwargs, response_obj, start_time, end_time):
+        """Async version of log_success_event"""
+        # Delegate to sync version - Lucidic client handles both sync/async internally
+        self.log_success_event(kwargs, response_obj, start_time, end_time)
+    
+    async def async_log_failure_event(self, kwargs, response_obj, start_time, end_time):
+        """Async version of log_failure_event"""
+        # Delegate to sync version
+        self.log_failure_event(kwargs, response_obj, start_time, end_time)
+    
+    async def async_log_stream_event(self, kwargs, response_obj, start_time, end_time):
+        """Async version of log_stream_event"""
+        self.log_stream_event(kwargs, response_obj, start_time, end_time)
+    
+    def _extract_provider(self, model: str) -> str:
+        """Extract provider from model string"""
+        if "/" in model:
+            return model.split("/")[0]
+        
+        # Try to infer provider from model name patterns
+        model_lower = model.lower()
+        if "gpt" in model_lower:
+            return "openai"
+        elif "claude" in model_lower:
+            return "anthropic"
+        elif "gemini" in model_lower:
+            return "vertex_ai"
+        elif "llama" in model_lower:
+            return "meta"
+        elif "mistral" in model_lower:
+            return "mistral"
+        
+        return "unknown"
+    
+    def _format_messages(self, messages: List[Dict[str, Any]]) -> str:
+        """Format messages into a description string"""
+        if not messages:
+            return "LiteLLM Request"
+            
+        formatted = []
+        for msg in messages:
+            if isinstance(msg, dict):
+                role = msg.get("role", "unknown")
+                content = msg.get("content", "")
+                
+                if isinstance(content, str):
+                    formatted.append(f"{role}: {content}")
+                elif isinstance(content, list):
+                    # Handle multimodal content
+                    texts = []
+                    for item in content:
+                        if isinstance(item, dict) and item.get("type") == "text":
+                            texts.append(item.get("text", ""))
+                    if texts:
+                        formatted.append(f"{role}: {' '.join(texts)}")
+                        
+        return "\n".join(formatted) if formatted else "LiteLLM Request"
+    
+    def _extract_response_content(self, response_obj) -> str:
+        """Extract response content from LiteLLM response object"""
+        try:
+            # Handle different response types
+            if hasattr(response_obj, "choices") and response_obj.choices:
+                # Standard completion response
+                choice = response_obj.choices[0]
+                if hasattr(choice, "message") and hasattr(choice.message, "content"):
+                    return choice.message.content or "No content"
+                elif hasattr(choice, "text"):
+                    return choice.text or "No content"
+            
+            # Fallback to string representation
+            return str(response_obj)
+            
+        except Exception as e:
+            logger.error(f"Error extracting response content: {e}")
+            return "Response received"
+    
+    def _extract_usage(self, response_obj) -> Optional[Dict[str, int]]:
+        """Extract usage information from response"""
+        try:
+            if hasattr(response_obj, "usage"):
+                usage = response_obj.usage
+                if hasattr(usage, "prompt_tokens") and hasattr(usage, "completion_tokens"):
+                    return {
+                        "prompt_tokens": usage.prompt_tokens,
+                        "completion_tokens": usage.completion_tokens,
+                        "total_tokens": usage.total_tokens if hasattr(usage, "total_tokens") else (usage.prompt_tokens + usage.completion_tokens)
+                    }
+        except Exception as e:
+            logger.debug(f"Could not extract usage: {e}")
+        
+        return None
+    
+    def _calculate_litellm_cost(self, model: str, usage: Dict[str, int]) -> Optional[float]:
+        """Calculate cost using Lucidic's pricing model"""
+        try:
+            # LiteLLM model names might need normalization for pricing lookup
+            normalized_model = model
+            if "/" in model:
+                # Extract the model name after the provider prefix
+                # e.g., "openai/gpt-4o" -> "gpt-4o"
+                parts = model.split("/", 1)
+                if len(parts) == 2:
+                    normalized_model = parts[1]
+            
+            return calculate_cost(normalized_model, usage)
+        except Exception as e:
+            logger.debug(f"Could not calculate cost for {model}: {e}")
+            return None
+    
+    def _extract_images_from_messages(self, messages: List[Dict[str, Any]]) -> List[str]:
+        """Extract base64 images from multimodal messages"""
+        images = []
+        
+        for msg in messages:
+            if isinstance(msg, dict):
+                content = msg.get("content", "")
+                if isinstance(content, list):
+                    for item in content:
+                        if isinstance(item, dict) and item.get("type") == "image_url":
+                            image_url = item.get("image_url", {})
+                            if isinstance(image_url, dict):
+                                url = image_url.get("url", "")
+                                if url.startswith("data:image"):
+                                    images.append(url)
+                                    
+        return images

lucidicai/telemetry/otel_handlers.py

@@ -263,4 +263,97 @@ class OTelOpenAIAgentsHandler(BaseProvider):
     def undo_override(self):
         """Disable instrumentation"""
         self._is_instrumented = False
-        logger.info("[OTel OpenAI Agents Handler] Instrumentation will be disabled on shutdown")
+        logger.info("[OTel OpenAI Agents Handler] Instrumentation will be disabled on shutdown")
+
+
+class OTelLiteLLMHandler(BaseProvider):
+    """LiteLLM handler using CustomLogger callback system"""
+    
+    def __init__(self):
+        super().__init__()
+        self._provider_name = "LiteLLM"
+        self.telemetry = LucidicTelemetry()
+        self._callback = None
+        self._original_callbacks = None
+        
+    def handle_response(self, response, kwargs, session: Optional = None):
+        """Not needed with callback approach"""
+        return response
+        
+    def override(self):
+        """Enable LiteLLM instrumentation via callbacks"""
+        try:
+            import litellm
+            from lucidicai.client import Client
+            from .litellm_bridge import LucidicLiteLLMCallback
+            
+            client = Client()
+            
+            # Initialize telemetry if needed
+            if not self.telemetry.is_initialized():
+                self.telemetry.initialize(agent_id=client.agent_id)
+            
+            # Create our callback instance
+            self._callback = LucidicLiteLLMCallback()
+            
+            # Store original callbacks
+            self._original_callbacks = litellm.callbacks if hasattr(litellm, 'callbacks') else None
+            
+            # Add our callback to LiteLLM
+            if litellm.callbacks is None:
+                litellm.callbacks = []
+            
+            # Add our callback if not already present
+            if self._callback not in litellm.callbacks:
+                litellm.callbacks.append(self._callback)
+            
+            # Also set success/failure callbacks
+            if not hasattr(litellm, 'success_callback') or litellm.success_callback is None:
+                litellm.success_callback = []
+            if not hasattr(litellm, 'failure_callback') or litellm.failure_callback is None:
+                litellm.failure_callback = []
+            
+            # Add to callback lists if not present
+            if self._callback not in litellm.success_callback:
+                litellm.success_callback.append(self._callback)
+            if self._callback not in litellm.failure_callback:
+                litellm.failure_callback.append(self._callback)
+            
+            logger.info("[OTel LiteLLM Handler] Callback instrumentation enabled")
+            
+        except ImportError:
+            logger.error("LiteLLM not installed. Please install with: pip install litellm")
+            raise
+        except Exception as e:
+            logger.error(f"Failed to enable LiteLLM instrumentation: {e}")
+            raise
+            
+    def undo_override(self):
+        """Disable LiteLLM instrumentation"""
+        try:
+            import litellm
+            
+            # Wait for pending callbacks to complete before cleanup
+            if self._callback and hasattr(self._callback, 'wait_for_pending_callbacks'):
+                logger.info("[OTel LiteLLM Handler] Waiting for pending callbacks to complete...")
+                self._callback.wait_for_pending_callbacks(timeout=5.0)
+            
+            # Remove our callback from all callback lists
+            if self._callback:
+                if hasattr(litellm, 'callbacks') and litellm.callbacks and self._callback in litellm.callbacks:
+                    litellm.callbacks.remove(self._callback)
+                    
+                if hasattr(litellm, 'success_callback') and litellm.success_callback and self._callback in litellm.success_callback:
+                    litellm.success_callback.remove(self._callback)
+                    
+                if hasattr(litellm, 'failure_callback') and litellm.failure_callback and self._callback in litellm.failure_callback:
+                    litellm.failure_callback.remove(self._callback)
+            
+            # Restore original callbacks if we stored them
+            if self._original_callbacks is not None:
+                litellm.callbacks = self._original_callbacks
+            
+            logger.info("[OTel LiteLLM Handler] Instrumentation disabled")
+            
+        except Exception as e:
+            logger.error(f"Error disabling LiteLLM instrumentation: {e}")

lucidicai/telemetry/otel_init.py

@@ -81,6 +81,9 @@ class LucidicTelemetry:
                 elif provider == "openai_agents":
                     # OpenAI Agents uses the same OpenAI instrumentation
                     self._instrument_openai_agents()
+                elif provider == "litellm":
+                    # LiteLLM uses callbacks, not OpenTelemetry instrumentation
+                    logger.info(f"[LucidicTelemetry] LiteLLM will use callback-based instrumentation")
             except Exception as e:
                 logger.error(f"Failed to instrument {provider}: {e}")
     

{lucidicai-1.2.19.dist-info → lucidicai-1.2.20.dist-info}/METADATA

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

{lucidicai-1.2.19.dist-info → lucidicai-1.2.20.dist-info}/RECORD

@@ -1,12 +1,12 @@
-lucidicai/__init__.py,sha256=qu1NTg-te86yT2j8BVz2NSi_Zs2G842K_YpxlMs9m6Q,20036
+lucidicai/__init__.py,sha256=sUfrleiPQPuXq5e0UnkXPjuTShiVoHnPtl_O0nzPcd8,20589
 lucidicai/action.py,sha256=sPRd1hTIVXDqnvG9ZXWEipUFh0bsXcE0Fm7RVqmVccM,237
 lucidicai/client.py,sha256=3yBVppvwBwesca_pZSKgTUDihzZe5JhVgh1AALCpJ_Q,6620
 lucidicai/constants.py,sha256=_u0z3M4geZgS1g-CrOZUVjtcew8l70dKQnpVQvlXh9w,2172
 lucidicai/decorators.py,sha256=oqXyfHk9f9UmeaIquuU8mtzed1qZtO_-svwadpoat6g,13950
 lucidicai/errors.py,sha256=gTg0bdzjuTcUnakRbZnxjngO4gZnRLVwRHRglpZZJsM,970
-lucidicai/event.py,sha256=2j5G4drwVhmdQkk9-armYQj1ctmLm2H_rNfPsfV_8wA,2004
+lucidicai/event.py,sha256=iPbNBRb2ZFohBsrRQZHzfa9GbxCsgFIw3M8w4gFrSi4,2000
 lucidicai/image_upload.py,sha256=6SRudg-BpInM2gzMx1Yf1Rz_Zyh8inwoJ7U4pBw7ruY,3807
-lucidicai/model_pricing.py,sha256=Q_Kd8OtKPqtvZ4pIh__ztKb3RXe-cX-8xgrM-AIUj9E,12189
+lucidicai/model_pricing.py,sha256=o1yWCaF5Qxj4tloXxVG3SZXcTMKtk56J_Nfdo8M4uR0,11947
 lucidicai/session.py,sha256=T_4z3CLKMp5DOKSVpdWwMZkZG9ndXU6oiI5Al6DHSTY,5501
 lucidicai/singleton.py,sha256=gfT3XdWLXSIWMqDXbY6-pnesMZ8RGRitaEPhIsgrRPw,1272
 lucidicai/state.py,sha256=4Tb1X6l2or6w_e62FYSuEeghAv3xXm5gquKwzCpvdok,235
@@ -31,19 +31,20 @@ lucidicai/providers/text_storage.py,sha256=L62MMJ8E23TDqDTUv2aRntdKMCItsXV7XjY6c
 lucidicai/providers/universal_image_interceptor.py,sha256=7d-hw4xihRwvvA1AP8-vqYNChtmVXKmn09MN4pDS7KQ,12126
 lucidicai/telemetry/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lucidicai/telemetry/base_provider.py,sha256=nrZVr4Y9xcAiMn4uAN3t3k6DlHNTvlXrA4qQg7lANOQ,544
+lucidicai/telemetry/litellm_bridge.py,sha256=mOdjEfvP--ToDv8snoOMU4pRQx_Yg4s2o3BMTMzeRK8,14979
 lucidicai/telemetry/lucidic_exporter.py,sha256=h2GOnEk22Fpeke4Zc7SSk391yr0joUApVwolV5Q4hz4,10818
 lucidicai/telemetry/lucidic_span_processor.py,sha256=LhkyJGBnTKpTWdBi2wyW9th4CWZ9EtZ8ulaE0rwYj0Y,27432
 lucidicai/telemetry/openai_agents_instrumentor.py,sha256=__wIbeglMnEEf4AGTQ--FXeWCKmz2yy8SBupwprEdZA,12694
 lucidicai/telemetry/opentelemetry_converter.py,sha256=xOHCqoTyO4hUkL6k7fxy84PbljPpYep6ET9ZqbkJehc,17665
-lucidicai/telemetry/otel_handlers.py,sha256=XgeDCL7ZjtaQ7HX8HKmYGTDqO6yne7gXZaScpdKvq98,10527
-lucidicai/telemetry/otel_init.py,sha256=RMsWRG3WZWvZN6WeLWSehsfUB_vWSuclVMCcSO31GEU,7770
+lucidicai/telemetry/otel_handlers.py,sha256=HqGYIWJI_Vp8So2-HMpPjnrgTBSgBHHLDu01z_sq-Qk,14646
+lucidicai/telemetry/otel_init.py,sha256=d0JcdDD23U_0xyBCAPOcZkFuOwv_7kI9Mih4msin6fw,7997
 lucidicai/telemetry/otel_provider.py,sha256=GZPhSEsEPVKrr5A0u5-WNn7OmxNgRWBcam9dyqjf91o,7042
 lucidicai/telemetry/pydantic_ai_handler.py,sha256=WPa3tFcVgVnPPO3AxcNOTbNkmODLgNOrU2_3GVtWqUw,28261
 lucidicai/telemetry/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lucidicai/telemetry/utils/image_storage.py,sha256=4Z59ZpVexr7-lcExfr8GsqXe0y2VZmr8Yjwa-3DeOxU,1457
 lucidicai/telemetry/utils/text_storage.py,sha256=L62MMJ8E23TDqDTUv2aRntdKMCItsXV7XjY6cFwx2DE,1503
 lucidicai/telemetry/utils/universal_image_interceptor.py,sha256=zPfVsMjtKxJP2n2OOjKbtPiQJTZ0sf5_28GWprOnJP4,12185
-lucidicai-1.2.19.dist-info/METADATA,sha256=WxcYafsohbT_xHO3Nw9b1XhcvhnERuzuHL6b8QrKvvQ,903
-lucidicai-1.2.19.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
-lucidicai-1.2.19.dist-info/top_level.txt,sha256=vSSdM3lclF4I5tyVC0xxUk8eIRnnYXMe1hW-eO91HUo,10
-lucidicai-1.2.19.dist-info/RECORD,,
+lucidicai-1.2.20.dist-info/METADATA,sha256=vn20bB7YfIoEnDP-o_rATqNh2vDhvBORz5snd_0Sjxw,903
+lucidicai-1.2.20.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
+lucidicai-1.2.20.dist-info/top_level.txt,sha256=vSSdM3lclF4I5tyVC0xxUk8eIRnnYXMe1hW-eO91HUo,10
+lucidicai-1.2.20.dist-info/RECORD,,