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

lucidicai/telemetry/lucidic_exporter.py

@@ -1,16 +1,21 @@
-"""Custom OpenTelemetry exporter for Lucidic backend compatibility"""
+"""Custom OpenTelemetry exporter for Lucidic (Exporter-only mode).
+
+Converts completed spans into immutable typed LLM events via Client.create_event(),
+which enqueues non-blocking delivery through the EventQueue.
+"""
 import json
 import logging
 from typing import Sequence, Optional, Dict, Any, List
+from datetime import datetime, timezone
 from opentelemetry.sdk.trace import ReadableSpan
 from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
 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.context import current_session_id, current_parent_event_id
 from lucidicai.model_pricing import calculate_cost
-from lucidicai.image_upload import extract_base64_images
+from .extract import detect_is_llm_span, extract_images, extract_prompts, extract_completions, extract_model
 
 logger = logging.getLogger("Lucidic")
 import os
@@ -20,69 +25,90 @@ VERBOSE = os.getenv("LUCIDIC_VERBOSE", "False") == "True"
 
 
 class LucidicSpanExporter(SpanExporter):
-    """Custom exporter that converts OpenTelemetry spans to Lucidic events"""
-    
-    def __init__(self):
-        self.pending_events = {}  # Track events by span_id
-        
+    """Exporter that creates immutable LLM events for completed spans."""
+
     def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
-        """Export spans by converting them to Lucidic events"""
         try:
             client = Client()
-                
+            if DEBUG and spans:
+                logger.debug(f"[LucidicSpanExporter] Processing {len(spans)} spans")
             for span in spans:
                 self._process_span(span, client)
-                
+            if DEBUG and spans:
+                logger.debug(f"[LucidicSpanExporter] Successfully exported {len(spans)} spans")
             return SpanExportResult.SUCCESS
         except Exception as e:
             logger.error(f"Failed to export spans: {e}")
             return SpanExportResult.FAILURE
-    
+
     def _process_span(self, span: ReadableSpan, client: Client) -> None:
-        """Process a single span and convert to Lucidic event"""
+        """Convert a single LLM span into a typed, immutable event."""
         try:
-            # Skip non-LLM spans
-            if not self._is_llm_span(span):
+            if not detect_is_llm_span(span):
                 return
-                
-            # Extract relevant attributes
+
             attributes = dict(span.attributes or {})
+
+            # Resolve session id
+            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 and getattr(client, 'session', None) and getattr(client.session, 'session_id', None):
+                target_session_id = client.session.session_id
+            if not target_session_id:
+                return
+
+            # Parent nesting - get from span attributes (captured at span creation)
+            parent_id = attributes.get('lucidic.parent_event_id')
+            if not parent_id:
+                # Fallback to trying context (may work if same thread)
+                try:
+                    parent_id = current_parent_event_id.get(None)
+                except Exception:
+                    parent_id = None
+
+            # Timing
+            occurred_at = datetime.fromtimestamp(span.start_time / 1_000_000_000, tz=timezone.utc) if span.start_time else datetime.now(tz=timezone.utc)
+            duration_seconds = ((span.end_time - span.start_time) / 1_000_000_000) if (span.start_time and span.end_time) else None
+
+            # Typed fields using extract utilities
+            model = extract_model(attributes) or 'unknown'
+            provider = self._detect_provider_name(attributes)
+            messages = extract_prompts(attributes) or []
+            params = self._extract_params(attributes)
+            output_text = extract_completions(span, attributes) or "Response received"
+            input_tokens = self._extract_prompt_tokens(attributes)
+            output_tokens = self._extract_completion_tokens(attributes)
+            cost = self._calculate_cost(attributes)
+            images = extract_images(attributes)
+
+            # Create immutable event via non-blocking queue
+            event_id = client.create_event(
+                type="llm_generation",
+                session_id=target_session_id,
+                parent_event_id=parent_id,
+                occurred_at=occurred_at,
+                duration=duration_seconds,
+                provider=provider,
+                model=model,
+                messages=messages,
+                params=params,
+                output=output_text,
+                input_tokens=input_tokens,
+                output_tokens=output_tokens,
+                cost=cost,
+                raw={"images": images} if images else None,
+            )
             
-            # Create or update event based on span lifecycle
-            span_id = format(span.context.span_id, '016x')
-            
-            if span_id not in self.pending_events:
-                # New span - create event
-                event_id = self._create_event_from_span(span, attributes, client)
-                if event_id:
-                    self.pending_events[span_id] = {
-                        'event_id': event_id,
-                        'start_time': span.start_time
-                    }
-            else:
-                # Span ended - update event
-                event_info = self.pending_events.pop(span_id)
-                self._update_event_from_span(span, attributes, event_info['event_id'], client)
-                
+            if DEBUG:
+                logger.debug(f"[LucidicSpanExporter] Created LLM event {event_id} for session {target_session_id[:8]}...")
+
         except Exception as e:
             logger.error(f"Failed to process span {span.name}: {e}")
     
-    def _is_llm_span(self, span: ReadableSpan) -> bool:
-        """Check if this is an LLM-related span"""
-        # Check span name patterns
-        llm_patterns = ['openai', 'anthropic', 'chat', 'completion', 'embedding', 'llm']
-        span_name_lower = span.name.lower()
-        
-        if any(pattern in span_name_lower for pattern in llm_patterns):
-            return True
-            
-        # Check for LLM attributes
-        if span.attributes:
-            for key in span.attributes:
-                if key.startswith('gen_ai.') or key.startswith('llm.'):
-                    return True
-                    
-        return False
     
     def _create_event_from_span(self, span: ReadableSpan, attributes: Dict[str, Any], client: Client) -> Optional[str]:
         """Create a Lucidic event from span start"""
@@ -121,11 +147,6 @@ class LucidicSpanExporter(SpanExporter):
             if images:
                 event_kwargs['screenshots'] = images
                 
-            # Check if we have a specific step_id in span attributes
-            step_id = attributes.get('lucidic.step_id')
-            if step_id:
-                event_kwargs['step_id'] = step_id
-                
             return client.create_event_for_session(target_session_id, **event_kwargs)
             
         except Exception as e:
@@ -133,32 +154,8 @@ class LucidicSpanExporter(SpanExporter):
             return None
     
     def _update_event_from_span(self, span: ReadableSpan, attributes: Dict[str, Any], event_id: str, client: Client) -> None:
-        """Update a Lucidic event from span end"""
-        try:
-            # Extract response/result
-            result = self._extract_result(span, attributes)
-            
-            # Calculate cost if we have token usage
-            cost = self._calculate_cost(attributes)
-            
-            # Determine success
-            is_successful = span.status.status_code != StatusCode.ERROR
-            
-            update_kwargs = {
-                'event_id': event_id,
-                'result': result,
-                'is_finished': True,
-                'is_successful': is_successful
-            }
-            
-            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:
-            logger.error(f"Failed to update event from span: {e}")
+        """Deprecated: events are immutable; no updates performed."""
+        return
     
     def _extract_description(self, span: ReadableSpan, attributes: Dict[str, Any]) -> str:
         """Extract description from span attributes"""
@@ -198,74 +195,60 @@ class LucidicSpanExporter(SpanExporter):
             
         return "Response received"
     
-    def _extract_images(self, attributes: Dict[str, Any]) -> List[str]:
-        """Extract base64 images from attributes"""
-        images = []
-        
-        # Check prompts for multimodal content
-        prompts = attributes.get(SpanAttributes.LLM_PROMPTS) or \
-                 attributes.get('gen_ai.prompt')
-                 
-        if isinstance(prompts, list):
-            for prompt in prompts:
-                if isinstance(prompt, dict) and 'content' in prompt:
-                    content = prompt['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) and 'url' in image_url:
-                                    url = image_url['url']
-                                    if url.startswith('data:image'):
-                                        images.append(url)
-                                        
-        return images
+    def _detect_provider_name(self, attributes: Dict[str, Any]) -> str:
+        name = attributes.get('gen_ai.system') or attributes.get('service.name')
+        if name:
+            return str(name)
+        return "openai" if 'openai' in (str(attributes.get('service.name', '')).lower()) else "unknown"
     
-    def _format_messages(self, messages: List[Any]) -> str:
-        """Format message list into description"""
-        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
-                    text_parts = []
-                    for item in content:
-                        if isinstance(item, dict) and item.get('type') == 'text':
-                            text_parts.append(item.get('text', ''))
-                    if text_parts:
-                        formatted.append(f"{role}: {' '.join(text_parts)}")
-                        
-        return '\n'.join(formatted) if formatted else "Model request"
+
+    def _extract_params(self, attributes: Dict[str, Any]) -> Dict[str, Any]:
+        return {
+            "temperature": attributes.get('gen_ai.request.temperature'),
+            "max_tokens": attributes.get('gen_ai.request.max_tokens'),
+            "top_p": attributes.get('gen_ai.request.top_p'),
+        }
+
+    def _extract_prompt_tokens(self, attributes: Dict[str, Any]) -> int:
+        return (
+            attributes.get(SpanAttributes.LLM_USAGE_PROMPT_TOKENS) or
+            attributes.get('gen_ai.usage.prompt_tokens') or
+            attributes.get('gen_ai.usage.input_tokens') or 0
+        )
+
+    def _extract_completion_tokens(self, attributes: Dict[str, Any]) -> int:
+        return (
+            attributes.get(SpanAttributes.LLM_USAGE_COMPLETION_TOKENS) or
+            attributes.get('gen_ai.usage.completion_tokens') or
+            attributes.get('gen_ai.usage.output_tokens') or 0
+        )
     
     def _calculate_cost(self, attributes: Dict[str, Any]) -> Optional[float]:
-        """Calculate cost from token usage"""
-        prompt_tokens = attributes.get(SpanAttributes.LLM_USAGE_PROMPT_TOKENS) or \
-                       attributes.get('gen_ai.usage.prompt_tokens') or 0
-        completion_tokens = attributes.get(SpanAttributes.LLM_USAGE_COMPLETION_TOKENS) or \
-                           attributes.get('gen_ai.usage.completion_tokens') or 0
-        
-        if prompt_tokens or completion_tokens:
-            model = attributes.get(SpanAttributes.LLM_RESPONSE_MODEL) or \
-                   attributes.get(SpanAttributes.LLM_REQUEST_MODEL) or \
-                   attributes.get('gen_ai.request.model')
-                   
+        prompt_tokens = (
+            attributes.get(SpanAttributes.LLM_USAGE_PROMPT_TOKENS) or
+            attributes.get('gen_ai.usage.prompt_tokens') or
+            attributes.get('gen_ai.usage.input_tokens') or 0
+        )
+        completion_tokens = (
+            attributes.get(SpanAttributes.LLM_USAGE_COMPLETION_TOKENS) or
+            attributes.get('gen_ai.usage.completion_tokens') or
+            attributes.get('gen_ai.usage.output_tokens') or 0
+        )
+        total_tokens = (prompt_tokens or 0) + (completion_tokens or 0)
+        if total_tokens > 0:
+            model = (
+                attributes.get(SpanAttributes.LLM_RESPONSE_MODEL) or
+                attributes.get(SpanAttributes.LLM_REQUEST_MODEL) or
+                attributes.get('gen_ai.response.model') or
+                attributes.get('gen_ai.request.model')
+            )
             if model:
-                return calculate_cost(prompt_tokens, completion_tokens, model)
-                
+                usage = {"prompt_tokens": prompt_tokens or 0, "completion_tokens": completion_tokens or 0, "total_tokens": total_tokens}
+                return calculate_cost(model, usage)
         return None
     
     def shutdown(self) -> None:
-        """Shutdown the exporter"""
-        # Process any remaining pending events
-        if self.pending_events:
-            logger.warning(f"Shutting down with {len(self.pending_events)} pending events")
-            
+        return None
+
     def force_flush(self, timeout_millis: int = 30000) -> bool:
-        """Force flush any pending spans"""
         return True

lucidicai/telemetry/telemetry_init.py

@@ -0,0 +1,189 @@
+"""Unified telemetry initialization - SpanExporter-only architecture.
+
+Provides functions to instrument OpenTelemetry providers.
+Provider creation is now handled by the Client singleton.
+"""
+import logging
+import threading
+from typing import Dict, Any, Optional
+
+from opentelemetry.sdk.trace import TracerProvider
+
+logger = logging.getLogger("Lucidic")
+
+# Global tracking to prevent duplicate instrumentation
+_global_instrumentors = {}
+_instrumentation_lock = threading.Lock()
+
+
+def instrument_providers(providers: list, tracer_provider: TracerProvider, existing_instrumentors: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Instrument the requested providers with the given TracerProvider.
+    Only instruments providers that haven't been instrumented yet.
+    Uses global tracking to prevent duplicate instrumentation across threads.
+    
+    Args:
+        providers: List of provider names to instrument
+        tracer_provider: The TracerProvider to use for instrumentation
+        existing_instrumentors: Dict of already instrumented providers (ignored, kept for compatibility)
+        
+    Returns:
+        Dict of newly instrumented providers (name -> instrumentor)
+    """
+    global _global_instrumentors
+    new_instrumentors = {}
+
+    # Normalize provider names
+    canonical = set()
+    for p in providers or []:
+        if p in ("google_generativeai",):
+            canonical.add("google")
+        elif p in ("vertex_ai",):
+            canonical.add("vertexai")
+        elif p in ("aws_bedrock", "amazon_bedrock"):
+            canonical.add("bedrock")
+        else:
+            canonical.add(p)
+
+    # Use global lock to prevent race conditions
+    with _instrumentation_lock:
+        # OpenAI
+        if "openai" in canonical and "openai" not in _global_instrumentors:
+            try:
+                from opentelemetry.instrumentation.openai import OpenAIInstrumentor
+                inst = OpenAIInstrumentor()
+                inst.instrument(tracer_provider=tracer_provider, enrich_token_usage=True)
+                _global_instrumentors["openai"] = inst
+                new_instrumentors["openai"] = inst
+                logger.info("[Telemetry] Instrumented OpenAI")
+            except Exception as e:
+                logger.error(f"Failed to instrument OpenAI: {e}")
+
+        # Anthropic
+        if "anthropic" in canonical and "anthropic" not in _global_instrumentors:
+            try:
+                from opentelemetry.instrumentation.anthropic import AnthropicInstrumentor
+                inst = AnthropicInstrumentor()
+                inst.instrument(tracer_provider=tracer_provider)
+                _global_instrumentors["anthropic"] = inst
+                new_instrumentors["anthropic"] = inst
+                logger.info("[Telemetry] Instrumented Anthropic")
+            except Exception as e:
+                logger.error(f"Failed to instrument Anthropic: {e}")
+
+        # LangChain
+        if "langchain" in canonical and "langchain" not in _global_instrumentors:
+            try:
+                from opentelemetry.instrumentation.langchain import LangchainInstrumentor
+                inst = LangchainInstrumentor()
+                inst.instrument(tracer_provider=tracer_provider)
+                _global_instrumentors["langchain"] = inst
+                new_instrumentors["langchain"] = inst
+                logger.info("[Telemetry] Instrumented LangChain")
+            except Exception as e:
+                logger.error(f"Failed to instrument LangChain: {e}")
+
+        # Google Generative AI
+        if "google" in canonical and "google" not in _global_instrumentors:
+            try:
+                from opentelemetry.instrumentation.google_generativeai import GoogleGenerativeAiInstrumentor
+                inst = GoogleGenerativeAiInstrumentor()
+                inst.instrument(tracer_provider=tracer_provider)
+                _global_instrumentors["google"] = inst
+                new_instrumentors["google"] = inst
+                logger.info("[Telemetry] Instrumented Google Generative AI")
+            except Exception as e:
+                logger.error(f"Failed to instrument Google Generative AI: {e}")
+
+        # Vertex AI
+        if "vertexai" in canonical and "vertexai" not in _global_instrumentors:
+            try:
+                from opentelemetry.instrumentation.vertexai import VertexAIInstrumentor
+                inst = VertexAIInstrumentor()
+                inst.instrument(tracer_provider=tracer_provider)
+                _global_instrumentors["vertexai"] = inst
+                new_instrumentors["vertexai"] = inst
+                logger.info("[Telemetry] Instrumented Vertex AI")
+            except Exception as e:
+                logger.error(f"Failed to instrument Vertex AI: {e}")
+
+        # Bedrock
+        if "bedrock" in canonical and "bedrock" not in _global_instrumentors:
+            try:
+                from opentelemetry.instrumentation.bedrock import BedrockInstrumentor
+                inst = BedrockInstrumentor(enrich_token_usage=True)
+                inst.instrument(tracer_provider=tracer_provider)
+                _global_instrumentors["bedrock"] = inst
+                new_instrumentors["bedrock"] = inst
+                logger.info("[Telemetry] Instrumented Bedrock")
+            except Exception as e:
+                logger.error(f"Failed to instrument Bedrock: {e}")
+
+        # Cohere
+        if "cohere" in canonical and "cohere" not in _global_instrumentors:
+            try:
+                from opentelemetry.instrumentation.cohere import CohereInstrumentor
+                inst = CohereInstrumentor()
+                inst.instrument(tracer_provider=tracer_provider)
+                _global_instrumentors["cohere"] = inst
+                new_instrumentors["cohere"] = inst
+                logger.info("[Telemetry] Instrumented Cohere")
+            except Exception as e:
+                logger.error(f"Failed to instrument Cohere: {e}")
+
+        # Groq
+        if "groq" in canonical and "groq" not in _global_instrumentors:
+            try:
+                from opentelemetry.instrumentation.groq import GroqInstrumentor
+                inst = GroqInstrumentor()
+                inst.instrument(tracer_provider=tracer_provider)
+                _global_instrumentors["groq"] = inst
+                new_instrumentors["groq"] = inst
+                logger.info("[Telemetry] Instrumented Groq")
+            except Exception as e:
+                logger.error(f"Failed to instrument Groq: {e}")
+
+        # LiteLLM - callback-based (not OpenTelemetry)
+        if "litellm" in canonical and "litellm" not in _global_instrumentors:
+            logger.info("[Telemetry] LiteLLM uses callback-based instrumentation")
+            # LiteLLM requires setup via litellm_bridge.py
+            try:
+                from .litellm_bridge import setup_litellm_callback
+                setup_litellm_callback()
+                _global_instrumentors["litellm"] = None  # No instrumentor object
+                new_instrumentors["litellm"] = None
+            except Exception as e:
+                logger.error(f"Failed to setup LiteLLM: {e}")
+
+        # Pydantic AI - manual spans
+        if "pydantic_ai" in canonical and "pydantic_ai" not in _global_instrumentors:
+            logger.info("[Telemetry] Pydantic AI requires manual span creation")
+            # No automatic instrumentation available
+            _global_instrumentors["pydantic_ai"] = None
+            new_instrumentors["pydantic_ai"] = None
+
+        # OpenAI Agents - custom instrumentor
+        if "openai_agents" in canonical and "openai_agents" not in _global_instrumentors:
+            try:
+                from .openai_agents_instrumentor import OpenAIAgentsInstrumentor
+                inst = OpenAIAgentsInstrumentor(tracer_provider=tracer_provider)
+                inst.instrument()
+                _global_instrumentors["openai_agents"] = inst
+                new_instrumentors["openai_agents"] = inst
+                logger.info("[Telemetry] Instrumented OpenAI Agents SDK")
+            except Exception as e:
+                logger.error(f"Failed to instrument OpenAI Agents: {e}")
+
+    return new_instrumentors
+
+
+# Keep the old function for backward compatibility (deprecated)
+def initialize_telemetry(providers: list, agent_id: str):
+    """
+    DEPRECATED: Use Client.initialize_telemetry() instead.
+    This function is kept for backward compatibility but will not work correctly
+    in multi-threaded environments.
+    """
+    logger.warning("[Telemetry] initialize_telemetry() is deprecated. Telemetry should be initialized via Client.")
+    # Return empty tuple to satisfy old callers
+    return None, []

{lucidicai-1.3.5.dist-info → lucidicai-2.0.1.dist-info}/METADATA

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

{lucidicai-1.3.5.dist-info → lucidicai-2.0.1.dist-info}/RECORD

@@ -1,19 +1,22 @@
-lucidicai/__init__.py,sha256=bac3gGZ1Rxn4ZRr4hYssPcucdfHDTD2yTlAGfP1cqzM,29840
+lucidicai/__init__.py,sha256=3gm2pFPTndvfx1zalGWqBdbdkUE_DDvAPbtsoIV5720,35879
 lucidicai/action.py,sha256=sPRd1hTIVXDqnvG9ZXWEipUFh0bsXcE0Fm7RVqmVccM,237
-lucidicai/client.py,sha256=qTY0LIuG6NbdV4Gy09poqDDe-pFnlWtEQi7Xhf2exNE,9856
-lucidicai/constants.py,sha256=_u0z3M4geZgS1g-CrOZUVjtcew8l70dKQnpVQvlXh9w,2172
-lucidicai/context.py,sha256=R3YRxRMnzKt-RqG1FkcT7__o-cyKRcvSzqonzRNBkZk,3975
-lucidicai/decorators.py,sha256=Z3w7AHXoYwZcvcu_Q0yNsSfkFd42fuQPscb4B0PPq6A,14542
-lucidicai/errors.py,sha256=gTg0bdzjuTcUnakRbZnxjngO4gZnRLVwRHRglpZZJsM,970
-lucidicai/event.py,sha256=2Rxa4EDLFBTBFTNXD4sjQ9DCMLiloFQqugL7unyYcL4,2642
+lucidicai/client.py,sha256=dRSwOAGth_b-RRBjLuxhPI75ULpQHP7M-KfP9X-XYjY,22172
+lucidicai/constants.py,sha256=zN8O7TjoRHRlaGa9CZUWppS73rhzKGwaEkF9XMTV0Cg,1160
+lucidicai/context.py,sha256=ruEXAndSv0gQ-YEXLlC4Fx6NNbaylfp_dZxbpwmLZSA,4622
+lucidicai/dataset.py,sha256=IgWCUhoclq1ZzSNc22UHd3fLs0hJv9A81OQizjbHtiE,3951
+lucidicai/decorators.py,sha256=obpHbGLhRd-yIL5xIqzjNmf-ZKCIIx5vlYnMpCcJ7Uo,5416
+lucidicai/errors.py,sha256=XT9UiYVoi88VsxrD2RU96l6mwCmxSeICOWhghB0iJ7Y,2058
+lucidicai/event.py,sha256=ObPXS22QIB-n4eHxzEimTtrlOxC1L6_eQVUAx4ZIT7s,2089
+lucidicai/event_queue.py,sha256=7Y8hkrm0a7EGCBN2oW_XWd-GkJ9Cihnu2Gyk6FMftks,20065
+lucidicai/feature_flag.py,sha256=Hfcoqqb5VimuaY1Q0NXl08elxQWG97KqzRpaMfE4PYA,11841
 lucidicai/image_upload.py,sha256=6SRudg-BpInM2gzMx1Yf1Rz_Zyh8inwoJ7U4pBw7ruY,3807
 lucidicai/lru.py,sha256=PXiDSoUCOxjamG1QlQx6pDbQCm8h5hKAnnr_NI0PEgE,618
 lucidicai/model_pricing.py,sha256=Dxi6e0WjcIyCTkVX7K7f0pJ5rPu7nSt3lOmgzAUQl1o,12402
-lucidicai/session.py,sha256=bSI6_kOHQEuk7z8NtNbU_RZoc41UxhwWrztwScFuNTw,4068
-lucidicai/singleton.py,sha256=gfT3XdWLXSIWMqDXbY6-pnesMZ8RGRitaEPhIsgrRPw,1272
+lucidicai/session.py,sha256=wHnjUPo7ANzJAdz_llA4EXKeCAm0WZR0Ij9dNvdCodY,1729
+lucidicai/singleton.py,sha256=SKiNBgt_Wb5cCWbMt3IWjRAQw3v153LTRgqvDj8poF8,1457
 lucidicai/state.py,sha256=4Tb1X6l2or6w_e62FYSuEeghAv3xXm5gquKwzCpvdok,235
 lucidicai/step.py,sha256=_oBIyTBZBvNkUkYHIrwWd75KMSlMtR9Ws2Lo71Lyff8,2522
-lucidicai/streaming.py,sha256=Y59vQOqhcOvTQWSAIamAnGCaQqCZz77N62_V2fuQlFA,11565
+lucidicai/streaming.py,sha256=QOLAzhwxetvx711J8VcphY5kXWPJz9XEBJrmHveRKMc,9796
 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
@@ -33,8 +36,10 @@ 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=XAeMQClz5MbGb8ziNT9bhAk3bcqTAkcMxJHvxKAjbCk,11435
+lucidicai/telemetry/context_capture_processor.py,sha256=k4_uTaoOhLeUAZsyUcDExVNXadk0nR4R1hJW096EVwY,2472
+lucidicai/telemetry/extract.py,sha256=30Iqvnr9I0EkD61GRCMN0Zpk3fLmRYcuVajWjRz0z9I,6814
+lucidicai/telemetry/litellm_bridge.py,sha256=CFXVu8nduBtJEhv21maNMrkXV_x5ropy--7qr6HAjh8,16542
+lucidicai/telemetry/lucidic_exporter.py,sha256=PfUB5a5o6av1YbYj52WQ-I71q8PBja3xvYTRWItFDPc,11029
 lucidicai/telemetry/lucidic_span_processor.py,sha256=-jo7Muuslo3ZCSAysLsDGBqJijQSpIOvJHPbPNjP4iQ,31029
 lucidicai/telemetry/openai_agents_instrumentor.py,sha256=__wIbeglMnEEf4AGTQ--FXeWCKmz2yy8SBupwprEdZA,12694
 lucidicai/telemetry/opentelemetry_converter.py,sha256=xOHCqoTyO4hUkL6k7fxy84PbljPpYep6ET9ZqbkJehc,17665
@@ -42,11 +47,12 @@ lucidicai/telemetry/otel_handlers.py,sha256=OCzXuYog6AuwjI4eXy5Sk40DUehyz48QOxuO
 lucidicai/telemetry/otel_init.py,sha256=hjUOX8nEBLrDOuh0UTKFfG-C98yFZHTiP8ql59bmNXY,13780
 lucidicai/telemetry/otel_provider.py,sha256=e5XcpQTd_a5UrMAq-EQcJ0zUJpO7NO16T-BphVUigR4,7513
 lucidicai/telemetry/pydantic_ai_handler.py,sha256=WPa3tFcVgVnPPO3AxcNOTbNkmODLgNOrU2_3GVtWqUw,28261
+lucidicai/telemetry/telemetry_init.py,sha256=8RMzZeeHYvaJKaM5KeSt0svaUAqODHmLstECjgHr8fc,8660
 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=vARgMk1hVSF--zfi5b8qBpJJOESuD17YlH9xqxmB9Uw,15954
-lucidicai-1.3.5.dist-info/METADATA,sha256=u-IHX3Y158OpO3FlhYjNMklIr1UB_1xqOz0HnURiiug,902
-lucidicai-1.3.5.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
-lucidicai-1.3.5.dist-info/top_level.txt,sha256=vSSdM3lclF4I5tyVC0xxUk8eIRnnYXMe1hW-eO91HUo,10
-lucidicai-1.3.5.dist-info/RECORD,,
+lucidicai-2.0.1.dist-info/METADATA,sha256=DOyezEU2bp3jBJOiNkXIOOZu55NRdLXztk95jZf9rwA,902
+lucidicai-2.0.1.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
+lucidicai-2.0.1.dist-info/top_level.txt,sha256=vSSdM3lclF4I5tyVC0xxUk8eIRnnYXMe1hW-eO91HUo,10
+lucidicai-2.0.1.dist-info/RECORD,,