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

lucidicai/telemetry/utils/text_storage.py

@@ -0,0 +1,53 @@
+"""Thread-local storage for text content from multimodal messages"""
+import threading
+from typing import List, Optional
+import logging
+
+logger = logging.getLogger("Lucidic")
+
+# Thread-local storage for text content
+_text_storage = threading.local()
+
+def store_text(text: str, message_index: int = 0) -> None:
+    """Store text content for a message
+    
+    Args:
+        text: The text content to store
+        message_index: The index of the message (default 0)
+    """
+    if not hasattr(_text_storage, 'texts'):
+        _text_storage.texts = {}
+    
+    _text_storage.texts[message_index] = text
+    logger.debug(f"[TextStorage] Stored text for message {message_index}: {text[:50]}...")
+
+def get_stored_text(message_index: int = 0) -> Optional[str]:
+    """Get stored text for a message
+    
+    Args:
+        message_index: The index of the message (default 0)
+        
+    Returns:
+        The stored text or None if not found
+    """
+    if not hasattr(_text_storage, 'texts'):
+        return None
+    
+    return _text_storage.texts.get(message_index)
+
+def get_all_stored_texts() -> dict:
+    """Get all stored texts
+    
+    Returns:
+        Dictionary of message_index -> text
+    """
+    if not hasattr(_text_storage, 'texts'):
+        return {}
+    
+    return _text_storage.texts.copy()
+
+def clear_stored_texts() -> None:
+    """Clear all stored texts"""
+    if hasattr(_text_storage, 'texts'):
+        _text_storage.texts = {}
+        logger.debug("[TextStorage] Cleared all stored texts")

lucidicai/telemetry/utils/universal_image_interceptor.py

@@ -0,0 +1,276 @@
+"""Universal image interceptor for all LLM providers to capture images from multimodal requests"""
+import logging
+import os
+from typing import Any, Dict, List, Union, Tuple
+from .image_storage import store_image, get_stored_images
+from .text_storage import store_text, clear_stored_texts
+
+logger = logging.getLogger("Lucidic")
+DEBUG = os.getenv("LUCIDIC_DEBUG", "False") == "True"
+VERBOSE = os.getenv("LUCIDIC_VERBOSE", "False") == "True"
+
+class UniversalImageInterceptor:
+    """Universal image interceptor that can handle different provider formats"""
+    
+    @staticmethod
+    def extract_and_store_images_openai(messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """Extract and store images from OpenAI-style messages
+        
+        OpenAI format:
+        {
+            "role": "user",
+            "content": [
+                {"type": "text", "text": "What's in this image?"},
+                {"type": "image_url", "image_url": {"url": "data:image/jpeg;base64,..."}}
+            ]
+        }
+        """
+        processed_messages = []
+        clear_stored_texts()  # Clear any previous texts
+        
+        for msg_idx, message in enumerate(messages):
+            if isinstance(message, dict):
+                content = message.get('content')
+                if isinstance(content, list):
+                    # Extract and store text content for multimodal messages
+                    text_parts = []
+                    has_images = False
+                    
+                    for item in content:
+                        if isinstance(item, dict):
+                            if item.get('type') == 'text':
+                                text_parts.append(item.get('text', ''))
+                            elif item.get('type') == 'image_url':
+                                has_images = True
+                                image_data = item.get('image_url', {})
+                                if isinstance(image_data, dict):
+                                    url = image_data.get('url', '')
+                                    if url.startswith('data:image'):
+                                        # Store the image
+                                        placeholder = store_image(url)
+                                        if DEBUG:
+                                            logger.info(f"[Universal Interceptor] Stored OpenAI image, placeholder: {placeholder}")
+                    
+                    # If we have both text and images, store the text separately
+                    if text_parts and has_images:
+                        combined_text = ' '.join(text_parts)
+                        store_text(combined_text, msg_idx)
+                        if VERBOSE:
+                            logger.info(f"[Universal Interceptor] Stored text for multimodal message {msg_idx}: {combined_text[:50]}...")
+                
+                processed_messages.append(message)
+        return processed_messages
+    
+    @staticmethod
+    def extract_and_store_images_anthropic(messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """Extract and store images from Anthropic-style messages
+        
+        Anthropic format:
+        {
+            "role": "user",
+            "content": [
+                {"type": "text", "text": "What's in this image?"},
+                {"type": "image", "source": {"type": "base64", "media_type": "image/jpeg", "data": "..."}}
+            ]
+        }
+        """
+        processed_messages = []
+        for message in messages:
+            if isinstance(message, dict):
+                content = message.get('content')
+                if isinstance(content, list):
+                    for item in content:
+                        if isinstance(item, dict) and item.get('type') == 'image':
+                            source = item.get('source', {})
+                            if isinstance(source, dict):
+                                data = source.get('data', '')
+                                media_type = source.get('media_type', 'image/jpeg')
+                                if data:
+                                    # Convert to data URL format for consistency
+                                    data_url = f"data:{media_type};base64,{data}"
+                                    placeholder = store_image(data_url)
+                                    if DEBUG:
+                                        logger.info(f"[Universal Interceptor] Stored Anthropic image, placeholder: {placeholder}")
+                processed_messages.append(message)
+        return processed_messages
+    
+    @staticmethod
+    def extract_and_store_images_google(messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """Extract and store images from Google/Gemini-style messages
+        
+        Google format can vary but often uses:
+        {
+            "parts": [
+                {"text": "What's in this image?"},
+                {"inline_data": {"mime_type": "image/jpeg", "data": "..."}}
+            ]
+        }
+        """
+        processed_messages = []
+        for message in messages:
+            if isinstance(message, dict):
+                parts = message.get('parts', [])
+                for part in parts:
+                    if isinstance(part, dict) and 'inline_data' in part:
+                        inline_data = part['inline_data']
+                        if isinstance(inline_data, dict):
+                            data = inline_data.get('data', '')
+                            mime_type = inline_data.get('mime_type', 'image/jpeg')
+                            if data:
+                                # Convert to data URL format
+                                data_url = f"data:{mime_type};base64,{data}"
+                                placeholder = store_image(data_url)
+                                if DEBUG:
+                                    logger.info(f"[Universal Interceptor] Stored Google image, placeholder: {placeholder}")
+                processed_messages.append(message)
+        return processed_messages
+    
+    @staticmethod
+    def intercept_images(messages: Any, provider: str = "auto") -> Any:
+        """Universal image interception for any provider
+        
+        Args:
+            messages: The messages to process
+            provider: The provider type ("openai", "anthropic", "google", "auto")
+                     If "auto", will try to detect the format
+        
+        Returns:
+            The processed messages (unchanged, but images are stored)
+        """
+        if not messages or not isinstance(messages, list):
+            return messages
+        
+        # Auto-detect provider format if needed
+        if provider == "auto":
+            provider = UniversalImageInterceptor._detect_provider_format(messages)
+        
+        # Process based on provider
+        if provider == "openai":
+            return UniversalImageInterceptor.extract_and_store_images_openai(messages)
+        elif provider == "anthropic":
+            return UniversalImageInterceptor.extract_and_store_images_anthropic(messages)
+        elif provider == "google":
+            return UniversalImageInterceptor.extract_and_store_images_google(messages)
+        else:
+            if DEBUG:
+                logger.warning(f"[Universal Interceptor] Unknown provider format: {provider}")
+            return messages
+    
+    @staticmethod
+    def _detect_provider_format(messages: List[Dict[str, Any]]) -> str:
+        """Detect the provider format based on message structure"""
+        for message in messages:
+            if isinstance(message, dict):
+                # Check for OpenAI format
+                content = message.get('content')
+                if isinstance(content, list):
+                    for item in content:
+                        if isinstance(item, dict):
+                            if item.get('type') == 'image_url' and 'image_url' in item:
+                                return "openai"
+                            elif item.get('type') == 'image' and 'source' in item:
+                                return "anthropic"
+                
+                # Check for Google format
+                if 'parts' in message:
+                    return "google"
+        
+        return "unknown"
+    
+    @staticmethod
+    def create_interceptor(provider: str):
+        """Create a function interceptor for a specific provider
+        
+        Args:
+            provider: The provider type ("openai", "anthropic", "google")
+        
+        Returns:
+            A function that can wrap the provider's API call
+        """
+        def interceptor(original_func):
+            def wrapper(*args, **kwargs):
+                # Extract messages from kwargs (common location)
+                messages = kwargs.get('messages', None)
+                
+                # For Anthropic, messages might be in args[1]
+                if messages is None and len(args) > 1 and isinstance(args[1], list):
+                    messages = args[1]
+                
+                # Intercept images if messages found
+                if messages:
+                    UniversalImageInterceptor.intercept_images(messages, provider)
+                
+                # Call the original function
+                return original_func(*args, **kwargs)
+            
+            return wrapper
+        
+        return interceptor
+    
+    @staticmethod
+    def create_async_interceptor(provider: str):
+        """Create an async function interceptor for a specific provider"""
+        def interceptor(original_func):
+            async def wrapper(*args, **kwargs):
+                # Extract messages from kwargs (common location)
+                messages = kwargs.get('messages', None)
+                
+                # For Anthropic, messages might be in args[1]
+                if messages is None and len(args) > 1 and isinstance(args[1], list):
+                    messages = args[1]
+                
+                # Intercept images if messages found
+                if messages:
+                    UniversalImageInterceptor.intercept_images(messages, provider)
+                
+                # Call the original function
+                return await original_func(*args, **kwargs)
+            
+            return wrapper
+        
+        return interceptor
+
+
+def patch_openai_client(client):
+    """Patch an OpenAI client instance to intercept images"""
+    interceptor = UniversalImageInterceptor.create_interceptor("openai")
+    
+    if hasattr(client, 'chat') and hasattr(client.chat, 'completions'):
+        original_create = client.chat.completions.create
+        client.chat.completions.create = interceptor(original_create)
+        if DEBUG:
+            logger.info("[Universal Interceptor] Patched OpenAI client for image interception")
+    return client
+
+
+def patch_anthropic_client(client):
+    """Patch an Anthropic client instance to intercept images"""
+    interceptor = UniversalImageInterceptor.create_interceptor("anthropic")
+    async_interceptor = UniversalImageInterceptor.create_async_interceptor("anthropic")
+    
+    if hasattr(client, 'messages'):
+        if hasattr(client.messages, 'create'):
+            original_create = client.messages.create
+            client.messages.create = interceptor(original_create)
+        
+        # Handle async version
+        if hasattr(client.messages, 'acreate'):
+            original_acreate = client.messages.acreate
+            client.messages.acreate = async_interceptor(original_acreate)
+        
+        if DEBUG:
+            logger.info("[Universal Interceptor] Patched Anthropic client for image interception")
+    return client
+
+
+def patch_google_client(client):
+    """Patch a Google/Gemini client instance to intercept images"""
+    interceptor = UniversalImageInterceptor.create_interceptor("google")
+    
+    # Google's client structure varies, but often uses generate_content
+    if hasattr(client, 'generate_content'):
+        original_generate = client.generate_content
+        client.generate_content = interceptor(original_generate)
+        if DEBUG:
+            logger.info("[Universal Interceptor] Patched Google client for image interception")
+    return client

{lucidicai-1.2.15.dist-info → lucidicai-1.2.17.dist-info}/METADATA

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

lucidicai-1.2.17.dist-info/RECORD

@@ -0,0 +1,49 @@
+lucidicai/__init__.py,sha256=lj8_84KeLYcJVrqUnkuyeFKUfwv1L5qY85gtpMxEsIM,19765
+lucidicai/action.py,sha256=sPRd1hTIVXDqnvG9ZXWEipUFh0bsXcE0Fm7RVqmVccM,237
+lucidicai/client.py,sha256=_EHUB--u-hvdhKTks4jpqvA18-GBwJfnyjoPZOXkA04,6374
+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/image_upload.py,sha256=6SRudg-BpInM2gzMx1Yf1Rz_Zyh8inwoJ7U4pBw7ruY,3807
+lucidicai/model_pricing.py,sha256=Q_Kd8OtKPqtvZ4pIh__ztKb3RXe-cX-8xgrM-AIUj9E,12189
+lucidicai/session.py,sha256=_67V6Be9Js-JEdCfiY_wkr4VUkQOdwZKUGUwf5mGXps,5429
+lucidicai/singleton.py,sha256=gfT3XdWLXSIWMqDXbY6-pnesMZ8RGRitaEPhIsgrRPw,1272
+lucidicai/state.py,sha256=4Tb1X6l2or6w_e62FYSuEeghAv3xXm5gquKwzCpvdok,235
+lucidicai/step.py,sha256=_oBIyTBZBvNkUkYHIrwWd75KMSlMtR9Ws2Lo71Lyff8,2522
+lucidicai/streaming.py,sha256=Y59vQOqhcOvTQWSAIamAnGCaQqCZz77N62_V2fuQlFA,11565
+lucidicai/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lucidicai/providers/anthropic_handler.py,sha256=GZEa4QOrjZ9ftu_qTwY3L410HwKzkXgN7omYRsEQ4LU,10174
+lucidicai/providers/base_providers.py,sha256=nrZVr4Y9xcAiMn4uAN3t3k6DlHNTvlXrA4qQg7lANOQ,544
+lucidicai/providers/image_storage.py,sha256=4Z59ZpVexr7-lcExfr8GsqXe0y2VZmr8Yjwa-3DeOxU,1457
+lucidicai/providers/langchain.py,sha256=xLJPFV2hfCOXsundCUZiYBf-g0dS5MDUYKoz22W8fO8,22184
+lucidicai/providers/lucidic_exporter.py,sha256=-uM7jnz7mkapo9ni7hhN7m3EDa0M_Uhz03NdiqfiP9k,10759
+lucidicai/providers/lucidic_span_processor.py,sha256=8bNV-6W1Y8ELi54vMVqQ_mXJouaOJvF3MkeBdamip0w,26799
+lucidicai/providers/openai_agents_handler.py,sha256=AAMtY7HZ-7UvTn1RVwd-uHhibJusZoOnWSw32xNcewo,18957
+lucidicai/providers/openai_agents_instrumentor.py,sha256=AMCTPeLvmHMNGGxelNaHIMu2s7eppLmruIYnlQ1WHDY,12732
+lucidicai/providers/openai_handler.py,sha256=CrFlM7RUAQjOmqWjAkV71dBRhe7gu-YEKXtSHfb70DE,32119
+lucidicai/providers/opentelemetry_converter.py,sha256=xOHCqoTyO4hUkL6k7fxy84PbljPpYep6ET9ZqbkJehc,17665
+lucidicai/providers/otel_handlers.py,sha256=HFCBryXB3LQ5ir03PWWlskH7Y-Yip88kFVm1HQAUXRc,10516
+lucidicai/providers/otel_init.py,sha256=RMsWRG3WZWvZN6WeLWSehsfUB_vWSuclVMCcSO31GEU,7770
+lucidicai/providers/otel_provider.py,sha256=ixLc80-_Vag0EO_92wj2m3_lg6HXyIpz9Md4JdVAbtM,7043
+lucidicai/providers/pydantic_ai_handler.py,sha256=Yhd9VTJhq292ZzJF04O_jYGRh-1bzs70BzQdo7a2Z9M,28269
+lucidicai/providers/text_storage.py,sha256=L62MMJ8E23TDqDTUv2aRntdKMCItsXV7XjY6cFwx2DE,1503
+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/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_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.17.dist-info/METADATA,sha256=SljtwfhzcGtEwnsx6JAmqDmYY9KniQi5mY3KH3xhR6M,577
+lucidicai-1.2.17.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
+lucidicai-1.2.17.dist-info/top_level.txt,sha256=vSSdM3lclF4I5tyVC0xxUk8eIRnnYXMe1hW-eO91HUo,10
+lucidicai-1.2.17.dist-info/RECORD,,

lucidicai-1.2.15.dist-info/RECORD

@@ -1,25 +0,0 @@
-lucidicai/__init__.py,sha256=sNUGk7kd2IsjL39WgRkc7VuulRbFB5o1liK_65iEH9E,17034
-lucidicai/action.py,sha256=sPRd1hTIVXDqnvG9ZXWEipUFh0bsXcE0Fm7RVqmVccM,237
-lucidicai/client.py,sha256=axJ9JjDq6qIuyyYtiQlMREPTKD_eKve-0pOBKHH7HZg,5695
-lucidicai/constants.py,sha256=_u0z3M4geZgS1g-CrOZUVjtcew8l70dKQnpVQvlXh9w,2172
-lucidicai/errors.py,sha256=gTg0bdzjuTcUnakRbZnxjngO4gZnRLVwRHRglpZZJsM,970
-lucidicai/event.py,sha256=9Z1yuP7Pef0sdXABU9SCHCLZSu6DfK--uGZoq-a9_IA,1974
-lucidicai/image_upload.py,sha256=ShacoEaGXbQESatfp-CrIygsDntt9IkcCqZcc9uLZVQ,3130
-lucidicai/model_pricing.py,sha256=Q_Kd8OtKPqtvZ4pIh__ztKb3RXe-cX-8xgrM-AIUj9E,12189
-lucidicai/session.py,sha256=goLQxBvXkLT5kS3eSfht3IFqvfYfgULC4eECSIanrPc,4909
-lucidicai/singleton.py,sha256=gfT3XdWLXSIWMqDXbY6-pnesMZ8RGRitaEPhIsgrRPw,1272
-lucidicai/state.py,sha256=4Tb1X6l2or6w_e62FYSuEeghAv3xXm5gquKwzCpvdok,235
-lucidicai/step.py,sha256=egDmr3z3ZXu5nBJqeepj0Ml3ifDuyg07OwTB6vOJCaY,2462
-lucidicai/streaming.py,sha256=wQ32xMCHvaNaM6OQoAhY-yS5KoLi71KQPCbcxjpLzbU,11658
-lucidicai/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lucidicai/providers/anthropic_handler.py,sha256=h6T_Iw0jcpwMhozAb8jOf6L_PihCKVaSScMBBA_otI0,10493
-lucidicai/providers/base_providers.py,sha256=nrZVr4Y9xcAiMn4uAN3t3k6DlHNTvlXrA4qQg7lANOQ,544
-lucidicai/providers/langchain.py,sha256=SSzgoY9UQ1kWuxYpgk1zil2EJGIVGyeWOVAPFvCifNQ,25521
-lucidicai/providers/openai_agents_handler.py,sha256=AAMtY7HZ-7UvTn1RVwd-uHhibJusZoOnWSw32xNcewo,18957
-lucidicai/providers/openai_handler.py,sha256=j2SW3YlGY1FhMO7d03WaIRxAtti6xATnoo2h8jh-uJk,35166
-lucidicai/providers/opentelemetry_converter.py,sha256=xOHCqoTyO4hUkL6k7fxy84PbljPpYep6ET9ZqbkJehc,17665
-lucidicai/providers/pydantic_ai_handler.py,sha256=Vu03SEqRuQNbmOK3iPwWVqczVRZNDDVoilDILIycK8c,28935
-lucidicai-1.2.15.dist-info/METADATA,sha256=gM8vDiiFysOgG0OG6hcgnxYH4k2U1t1Mb0D_2cpfQfk,577
-lucidicai-1.2.15.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
-lucidicai-1.2.15.dist-info/top_level.txt,sha256=vSSdM3lclF4I5tyVC0xxUk8eIRnnYXMe1hW-eO91HUo,10
-lucidicai-1.2.15.dist-info/RECORD,,