lucidicai 1.3.1__py3-none-any.whl → 1.3.5__py3-none-any.whl

lucidicai/model_pricing.py

@@ -3,6 +3,12 @@ import logging
 logger = logging.getLogger("Lucidic")
 
 MODEL_PRICING = {
+
+    # OpenAI GPT-5 Series (Verified 2025)
+    "gpt-5": {"input": 10.0, "output": 10.0},
+    "gpt-5-mini": {"input": 0.250, "output": 2.0},
+    "gpt-5-nano": {"input": 0.05, "output": 0.4},
+
     # OpenAI GPT-4o Series (Verified 2025)
     "gpt-4o": {"input": 2.5, "output": 10.0},
     "gpt-4o-mini": {"input": 0.15, "output": 0.6},
@@ -190,6 +196,7 @@ PROVIDER_AVERAGES = {
     "together": {"input": 0.15, "output": 0.15},    # Together AI average
     "perplexity": {"input": 0.4, "output": 1.5},    # Perplexity average
     "grok": {"input": 2.4, "output": 12},           # Grok average
+    "groq": {"input": 0.3, "output": 0.6},          # Groq average (placeholder)
 }
 
 def get_provider_from_model(model: str) -> str:
@@ -218,6 +225,8 @@ def get_provider_from_model(model: str) -> str:
         return "perplexity"
     elif any(grok in model_lower for grok in ["grok", "xAI"]):
         return "grok"
+    elif "groq" in model_lower:
+        return "groq"
     else:
         return "unknown"
 
@@ -228,6 +237,8 @@ def normalize_model_name(model: str) -> str:
     model_lower = model.lower()
     # Remove provider prefixes (generalizable pattern: any_provider/)
     model_lower = re.sub(r'^[^/]+/', '', model_lower)
+    # Strip Google/Vertex prefixes
+    model_lower = model_lower.replace('publishers/google/models/', '').replace('models/', '')
     
     # Strip date suffixes (20240229, 20241022, etc.) but preserve model versions like o1-mini, o3-mini
     # Pattern: remove -YYYYMMDD or -YYYY-MM-DD at the end

lucidicai/session.py

@@ -31,7 +31,7 @@ class Session:
         self.session_eval = None
         self.session_eval_reason = None
         self.has_gif = None
-
+        
     @property   
     def active_step(self) -> Optional[Step]:
         """Get the active step object"""

lucidicai/telemetry/lucidic_exporter.py

@@ -8,6 +8,7 @@ from opentelemetry.trace import StatusCode
 from opentelemetry.semconv_ai import SpanAttributes
 
 from lucidicai.client import Client
+from lucidicai.context import current_session_id
 from lucidicai.model_pricing import calculate_cost
 from lucidicai.image_upload import extract_base64_images
 
@@ -28,9 +29,6 @@ class LucidicSpanExporter(SpanExporter):
         """Export spans by converting them to Lucidic events"""
         try:
             client = Client()
-            if not client.session:
-                logger.debug("No active session, skipping span export")
-                return SpanExportResult.SUCCESS
                 
             for span in spans:
                 self._process_span(span, client)
@@ -100,6 +98,19 @@ class LucidicSpanExporter(SpanExporter):
                    attributes.get(SpanAttributes.LLM_REQUEST_MODEL) or \
                    attributes.get('gen_ai.request.model') or 'unknown'
             
+            # Resolve target session id for this span
+            target_session_id = attributes.get('lucidic.session_id')
+            if not target_session_id:
+                try:
+                    target_session_id = current_session_id.get(None)
+                except Exception:
+                    target_session_id = None
+            if not target_session_id:
+                if getattr(client, 'session', None) and getattr(client.session, 'session_id', None):
+                    target_session_id = client.session.session_id
+            if not target_session_id:
+                return None
+
             # Create event
             event_kwargs = {
                 'description': description,
@@ -115,7 +126,7 @@ class LucidicSpanExporter(SpanExporter):
             if step_id:
                 event_kwargs['step_id'] = step_id
                 
-            return client.session.create_event(**event_kwargs)
+            return client.create_event_for_session(target_session_id, **event_kwargs)
             
         except Exception as e:
             logger.error(f"Failed to create event from span: {e}")
@@ -143,6 +154,7 @@ class LucidicSpanExporter(SpanExporter):
             if cost is not None:
                 update_kwargs['cost_added'] = cost
                 
+            # Route update to the same session; event_id is globally unique so server resolves it
             client.session.update_event(**update_kwargs)
             
         except Exception as e:

lucidicai/telemetry/lucidic_span_processor.py

@@ -1,4 +1,9 @@
-"""Custom span processor for real-time Lucidic event handling"""
+"""Custom span processor for real-time Lucidic event handling
+
+Updated to stamp spans with the correct session id from async-safe
+context, and to create events for that session without mutating the
+global client session.
+"""
 import os
 import logging
 import json
@@ -10,7 +15,8 @@ from opentelemetry.semconv_ai import SpanAttributes
 
 from lucidicai.client import Client
 from lucidicai.model_pricing import calculate_cost
-from .utils.image_storage import get_stored_images, clear_stored_images
+from lucidicai.context import current_session_id
+from .utils.image_storage import get_stored_images, clear_stored_images, get_image_by_placeholder
 from .utils.text_storage import get_stored_text, clear_stored_texts
 
 logger = logging.getLogger("Lucidic")
@@ -35,11 +41,15 @@ class LucidicSpanProcessor(SpanProcessor):
                 logger.info(f"[SpanProcessor] on_start called for span: {span.name}")
                 # logger.info(f"[SpanProcessor] Span attributes at start: {dict(span.attributes or {})}")
                 
+            # Stamp session id from contextvars if available
+            try:
+                sid = current_session_id.get(None)
+                if sid:
+                    span.set_attribute('lucidic.session_id', sid)
+            except Exception:
+                pass
+
             client = Client()
-            if not client.session:
-                logger.debug("No active session, skipping span tracking")
-                return
-                
             # Only process LLM spans
             if not self._is_llm_span(span):
                 if DEBUG:
@@ -88,9 +98,6 @@ class LucidicSpanProcessor(SpanProcessor):
                 return
                 
             client = Client()
-            if not client.session:
-                return
-            
             span_context = self.span_contexts.pop(span_id, {})
             
             # Create event with all the attributes now available
@@ -127,7 +134,7 @@ class LucidicSpanProcessor(SpanProcessor):
         
         # Check span name
         span_name_lower = span.name.lower()
-        llm_patterns = ['openai', 'anthropic', 'chat', 'completion', 'embedding', 'gemini', 'claude']
+        llm_patterns = ['openai', 'anthropic', 'chat', 'completion', 'embedding', 'gemini', 'claude', 'bedrock', 'vertex', 'cohere', 'groq']
         
         if any(pattern in span_name_lower for pattern in llm_patterns):
             return True
@@ -248,6 +255,22 @@ class LucidicSpanProcessor(SpanProcessor):
             # Check success
             is_successful = span.status.status_code != StatusCode.ERROR
             
+            # Resolve target session id for this span
+            target_session_id = attributes.get('lucidic.session_id')
+            if not target_session_id:
+                try:
+                    target_session_id = current_session_id.get(None)
+                except Exception:
+                    target_session_id = None
+            if not target_session_id:
+                # Fallback to global client session if set
+                if getattr(client, 'session', None) and getattr(client.session, 'session_id', None):
+                    target_session_id = client.session.session_id
+            if not target_session_id:
+                if DEBUG:
+                    logger.info("[SpanProcessor] No session id found for span; skipping event creation")
+                return None
+
             # Create event with all data
             event_kwargs = {
                 'description': description,
@@ -268,8 +291,8 @@ class LucidicSpanProcessor(SpanProcessor):
             if step_id:
                 event_kwargs['step_id'] = step_id
                 
-            # Create the event (already completed)
-            event_id = client.session.create_event(**event_kwargs)
+            # Create the event (already completed) for the resolved session id
+            event_id = client.create_event_for_session(target_session_id, **event_kwargs)
                 
             return event_id
             
@@ -397,53 +420,48 @@ class LucidicSpanProcessor(SpanProcessor):
         while True:
             prefix = f"gen_ai.prompt.{i}"
             role = attributes.get(f"{prefix}.role")
-            
-            if not role:
-                break
-                
-            message = {"role": role}
-            
-            # Get content
             content = attributes.get(f"{prefix}.content")
+
+            # Check if any attributes exist for this index
+            attr_has_any = False
+            for key in attributes.keys():
+                if isinstance(key, str) and key.startswith(f"{prefix}."):
+                    attr_has_any = True
+                    break
+
+            stored_text = get_stored_text(i)
+            stored_images = get_stored_images()
+
+            # Break if no indexed attrs and not the first synthetic message case
+            if not attr_has_any and not (i == 0 and (stored_text or stored_images)):
+                break
+
+            message = {"role": role or "user"}
+
             if content:
                 # Try to parse JSON content (for multimodal)
                 try:
                     import json
                     parsed_content = json.loads(content)
                     message["content"] = parsed_content
-                except:
+                except Exception:
                     message["content"] = content
             else:
-                # Content might be missing for multimodal messages due to size limits
-                # Check if we have stored text and/or images in thread-local storage
-                stored_text = get_stored_text(i)
-                stored_images = get_stored_images()
-                
-                if stored_text or stored_images:
+                # Content missing: synthesize from stored text/images
+                synthetic_content = []
+                if stored_text and i == 0:
+                    synthetic_content.append({"type": "text", "text": stored_text})
+                if stored_images and i == 0:
+                    for img in stored_images:
+                        synthetic_content.append({"type": "image_url", "image_url": {"url": img}})
+                if synthetic_content:
                     if DEBUG:
-                        logger.info(f"[SpanProcessor] No content for message {i}, but found stored text/images")
-                    
-                    # Create synthetic content with both text and images
-                    synthetic_content = []
-                    
-                    # Add text if available
-                    if stored_text:
-                        synthetic_content.append({
-                            "type": "text",
-                            "text": stored_text
-                        })
-                    
-                    # Add images if available
-                    if stored_images and i == 0:  # Assume first message might have images
-                        for idx, img in enumerate(stored_images):
-                            synthetic_content.append({
-                                "type": "image_url",
-                                "image_url": {"url": img}
-                            })
-                    
-                    if synthetic_content:
-                        message["content"] = synthetic_content
-            
+                        logger.info(f"[SpanProcessor] Using stored text/images for message {i}")
+                    message["content"] = synthetic_content
+                elif not attr_has_any:
+                    # No real attributes and nothing stored to synthesize -> stop
+                    break
+
             messages.append(message)
             i += 1
             

lucidicai/telemetry/otel_handlers.py

@@ -1,4 +1,7 @@
-"""OpenTelemetry-based handlers that maintain backward compatibility"""
+"""OpenTelemetry-based handlers that maintain backward compatibility
+
+Adds guards to avoid repeated monkey-patching under concurrent init.
+"""
 import logging
 from typing import Optional
 
@@ -7,6 +10,11 @@ from .otel_init import LucidicTelemetry
 
 logger = logging.getLogger("Lucidic")
 
+import threading
+
+_patch_lock = threading.Lock()
+_openai_patched = False
+_anthropic_patched = False
 
 class OTelOpenAIHandler(BaseProvider):
     """OpenAI handler using OpenTelemetry instrumentation"""
@@ -35,37 +43,27 @@ class OTelOpenAIHandler(BaseProvider):
             
             # Also patch OpenAI client to intercept images
             try:
-                import openai
-                from .utils.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
-                
+                with _patch_lock:
+                    global _openai_patched
+                    if not _openai_patched:
+                        import openai
+                        from .utils.universal_image_interceptor import UniversalImageInterceptor, patch_openai_client
+                        interceptor = UniversalImageInterceptor.create_interceptor("openai")
+                        if hasattr(openai, 'ChatCompletion'):
+                            original = openai.ChatCompletion.create
+                            openai.ChatCompletion.create = interceptor(original)
+                        original_client_init = openai.OpenAI.__init__
+                        def patched_init(self, *args, **kwargs):
+                            original_client_init(self, *args, **kwargs)
+                            patch_openai_client(self)
+                        openai.OpenAI.__init__ = patched_init
+                        if hasattr(openai, 'AsyncOpenAI'):
+                            original_async_init = openai.AsyncOpenAI.__init__
+                            def patched_async_init(self, *args, **kwargs):
+                                original_async_init(self, *args, **kwargs)
+                                patch_openai_client(self)
+                            openai.AsyncOpenAI.__init__ = patched_async_init
+                        _openai_patched = True
             except Exception as e:
                 logger.warning(f"Could not patch OpenAI for image interception: {e}")
             
@@ -108,32 +106,25 @@ class OTelAnthropicHandler(BaseProvider):
             
             # Also patch Anthropic client to intercept images
             try:
-                import anthropic
-                from .utils.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
-                
+                with _patch_lock:
+                    global _anthropic_patched
+                    if not _anthropic_patched:
+                        import anthropic
+                        from .utils.universal_image_interceptor import UniversalImageInterceptor, patch_anthropic_client
+                        interceptor = UniversalImageInterceptor.create_interceptor("anthropic")
+                        async_interceptor = UniversalImageInterceptor.create_async_interceptor("anthropic")
+                        original_client_init = anthropic.Anthropic.__init__
+                        def patched_init(self, *args, **kwargs):
+                            original_client_init(self, *args, **kwargs)
+                            patch_anthropic_client(self)
+                        anthropic.Anthropic.__init__ = patched_init
+                        if hasattr(anthropic, 'AsyncAnthropic'):
+                            original_async_init = anthropic.AsyncAnthropic.__init__
+                            def patched_async_init(self, *args, **kwargs):
+                                original_async_init(self, *args, **kwargs)
+                                patch_anthropic_client(self)
+                            anthropic.AsyncAnthropic.__init__ = patched_async_init
+                        _anthropic_patched = True
             except Exception as e:
                 logger.warning(f"Could not patch Anthropic for image interception: {e}")
             
@@ -356,4 +347,161 @@ class OTelLiteLLMHandler(BaseProvider):
             logger.info("[OTel LiteLLM Handler] Instrumentation disabled")
             
         except Exception as e:
-            logger.error(f"Error disabling LiteLLM instrumentation: {e}")
+            logger.error(f"Error disabling LiteLLM instrumentation: {e}")
+
+
+class OTelBedrockHandler(BaseProvider):
+    """AWS Bedrock handler using OpenTelemetry instrumentation"""
+    
+    def __init__(self):
+        super().__init__()
+        self._provider_name = "Bedrock"
+        self.telemetry = LucidicTelemetry()
+    
+    def handle_response(self, response, kwargs, session: Optional = None):
+        return response
+    
+    def override(self):
+        try:
+            from lucidicai.client import Client
+            client = Client()
+            if not self.telemetry.is_initialized():
+                self.telemetry.initialize(agent_id=client.agent_id)
+            self.telemetry.instrument_providers(["bedrock"])
+            logger.info("[OTel Bedrock Handler] Instrumentation enabled")
+        except Exception as e:
+            logger.error(f"Failed to enable Bedrock instrumentation: {e}")
+            raise
+    
+    def undo_override(self):
+        logger.info("[OTel Bedrock Handler] Instrumentation will be disabled on shutdown")
+
+
+class OTelGoogleGenerativeAIHandler(BaseProvider):
+    """Google Generative AI handler using OpenTelemetry instrumentation"""
+    
+    def __init__(self):
+        super().__init__()
+        self._provider_name = "Google Generative AI"
+        self.telemetry = LucidicTelemetry()
+    
+    def handle_response(self, response, kwargs, session: Optional = None):
+        return response
+    
+    def override(self):
+        try:
+            from lucidicai.client import Client
+            client = Client()
+            if not self.telemetry.is_initialized():
+                self.telemetry.initialize(agent_id=client.agent_id)
+            self.telemetry.instrument_providers(["google"])
+            # Best-effort image interception for Google clients where applicable
+            try:
+                from .utils.universal_image_interceptor import patch_google_client, patch_google_genai
+                _ = patch_google_client
+                patch_google_genai()
+            except Exception as e:
+                logger.debug(f"[OTel Google Handler] Image interception not applied: {e}")
+            logger.info("[OTel Google Handler] Instrumentation enabled")
+        except Exception as e:
+            logger.error(f"Failed to enable Google Generative AI instrumentation: {e}")
+            raise
+    
+    def undo_override(self):
+        logger.info("[OTel Google Handler] Instrumentation will be disabled on shutdown")
+
+
+class OTelVertexAIHandler(BaseProvider):
+    """Vertex AI handler using OpenTelemetry instrumentation"""
+    
+    def __init__(self):
+        super().__init__()
+        self._provider_name = "Vertex AI"
+        self.telemetry = LucidicTelemetry()
+    
+    def handle_response(self, response, kwargs, session: Optional = None):
+        return response
+    
+    def override(self):
+        try:
+            from lucidicai.client import Client
+            client = Client()
+            if not self.telemetry.is_initialized():
+                self.telemetry.initialize(agent_id=client.agent_id)
+            self.telemetry.instrument_providers(["vertexai"])
+            # Best-effort image interception for Vertex AI clients where applicable
+            try:
+                from .utils.universal_image_interceptor import patch_vertexai_client
+                _ = patch_vertexai_client
+            except Exception as e:
+                logger.debug(f"[OTel Vertex Handler] Image interception not applied: {e}")
+            logger.info("[OTel Vertex Handler] Instrumentation enabled")
+        except Exception as e:
+            logger.error(f"Failed to enable Vertex AI instrumentation: {e}")
+            raise
+    
+    def undo_override(self):
+        logger.info("[OTel Vertex Handler] Instrumentation will be disabled on shutdown")
+
+
+class OTelCohereHandler(BaseProvider):
+    """Cohere handler using OpenTelemetry instrumentation"""
+    
+    def __init__(self):
+        super().__init__()
+        self._provider_name = "Cohere"
+        self.telemetry = LucidicTelemetry()
+    
+    def handle_response(self, response, kwargs, session: Optional = None):
+        return response
+    
+    def override(self):
+        try:
+            from lucidicai.client import Client
+            client = Client()
+            if not self.telemetry.is_initialized():
+                self.telemetry.initialize(agent_id=client.agent_id)
+            self.telemetry.instrument_providers(["cohere"])
+            logger.info("[OTel Cohere Handler] Instrumentation enabled")
+        except Exception as e:
+            logger.error(f"Failed to enable Cohere instrumentation: {e}")
+            raise
+    
+    def undo_override(self):
+        logger.info("[OTel Cohere Handler] Instrumentation will be disabled on shutdown")
+
+
+class OTelGroqHandler(BaseProvider):
+    """Groq handler using OpenTelemetry instrumentation"""
+    
+    def __init__(self):
+        super().__init__()
+        self._provider_name = "Groq"
+        self.telemetry = LucidicTelemetry()
+    
+    def handle_response(self, response, kwargs, session: Optional = None):
+        return response
+    
+    def override(self):
+        try:
+            from lucidicai.client import Client
+            client = Client()
+            if not self.telemetry.is_initialized():
+                self.telemetry.initialize(agent_id=client.agent_id)
+            self.telemetry.instrument_providers(["groq"])
+            # Best-effort image interception for Groq (OpenAI-compatible)
+            try:
+                import groq  # noqa: F401
+                from .utils.universal_image_interceptor import UniversalImageInterceptor
+                # We cannot reliably patch class constructors here without instance; users calling Groq client
+                # will still have images captured via OpenLLMetry attributes; optional future improvement.
+                _ = UniversalImageInterceptor
+            except Exception as e:
+                logger.debug(f"[OTel Groq Handler] Image interception not applied: {e}")
+            logger.info("[OTel Groq Handler] Instrumentation enabled")
+        except Exception as e:
+            logger.error(f"Failed to enable Groq instrumentation: {e}")
+            raise
+    
+    def undo_override(self):
+        logger.info("[OTel Groq Handler] Instrumentation will be disabled on shutdown")