lucidicai 2.0.2__py3-none-any.whl → 2.1.1__py3-none-any.whl

lucidicai/utils/logger.py

@@ -0,0 +1,168 @@
+"""Centralized logging utilities for Lucidic SDK.
+
+This module provides consistent logging functions that respect
+LUCIDIC_DEBUG and LUCIDIC_VERBOSE environment variables.
+"""
+import os
+import logging
+from typing import Any, Optional
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Configure base logger
+logging.basicConfig(
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    level=logging.WARNING  # Default to WARNING, will be overridden by env vars
+)
+
+# Get the logger
+logger = logging.getLogger("Lucidic")
+
+
+def _env_true(value: Optional[str]) -> bool:
+    """Check if environment variable is truthy."""
+    if value is None:
+        return False
+    return value.lower() in ('true', '1', 'yes')
+
+
+def is_debug() -> bool:
+    """Check if debug mode is enabled."""
+    return _env_true(os.getenv('LUCIDIC_DEBUG'))
+
+
+def is_verbose() -> bool:
+    """Check if verbose mode is enabled."""
+    return _env_true(os.getenv('LUCIDIC_VERBOSE'))
+
+
+def debug(message: str, *args: Any, **kwargs: Any) -> None:
+    """Log debug message if LUCIDIC_DEBUG is enabled.
+    
+    Args:
+        message: Log message with optional formatting
+        *args: Positional arguments for message formatting
+        **kwargs: Keyword arguments for logging
+    """
+    if is_debug():
+        logger.debug(f"[DEBUG] {message}", *args, **kwargs)
+
+
+def info(message: str, *args: Any, **kwargs: Any) -> None:
+    """Log info message (always visible).
+    
+    Args:
+        message: Log message with optional formatting
+        *args: Positional arguments for message formatting
+        **kwargs: Keyword arguments for logging
+    """
+    logger.info(message, *args, **kwargs)
+
+
+def warning(message: str, *args: Any, **kwargs: Any) -> None:
+    """Log warning message (always visible).
+    
+    Args:
+        message: Log message with optional formatting
+        *args: Positional arguments for message formatting
+        **kwargs: Keyword arguments for logging
+    """
+    logger.warning(message, *args, **kwargs)
+
+
+def error(message: str, *args: Any, **kwargs: Any) -> None:
+    """Log error message (always visible).
+    
+    Args:
+        message: Log message with optional formatting
+        *args: Positional arguments for message formatting
+        **kwargs: Keyword arguments for logging
+    """
+    logger.error(message, *args, **kwargs)
+
+
+def verbose(message: str, *args: Any, **kwargs: Any) -> None:
+    """Log verbose message if LUCIDIC_VERBOSE or LUCIDIC_DEBUG is enabled.
+    
+    Args:
+        message: Log message with optional formatting
+        *args: Positional arguments for message formatting
+        **kwargs: Keyword arguments for logging
+    """
+    if is_debug() or is_verbose():
+        logger.info(f"[VERBOSE] {message}", *args, **kwargs)
+
+
+def truncate_id(id_str: Optional[str], length: int = 8) -> str:
+    """Truncate UUID for logging.
+    
+    Args:
+        id_str: UUID string to truncate
+        length: Number of characters to keep
+        
+    Returns:
+        Truncated ID with ellipsis
+    """
+    if not id_str:
+        return "None"
+    if len(id_str) <= length:
+        return id_str
+    return f"{id_str[:length]}..."
+
+
+def mask_sensitive(data: dict, sensitive_keys: set = None) -> dict:
+    """Mask sensitive data in dictionary for logging.
+    
+    Args:
+        data: Dictionary potentially containing sensitive data
+        sensitive_keys: Set of keys to mask (default: common sensitive keys)
+        
+    Returns:
+        Dictionary with sensitive values masked
+    """
+    if sensitive_keys is None:
+        sensitive_keys = {
+            'api_key', 'apikey', 'api-key',
+            'token', 'auth', 'authorization',
+            'password', 'secret', 'key',
+            'x-api-key', 'x-auth-token'
+        }
+    
+    masked = {}
+    for key, value in data.items():
+        if any(k in key.lower() for k in sensitive_keys):
+            if value:
+                # Show first few chars for debugging
+                masked[key] = f"{str(value)[:4]}...MASKED" if len(str(value)) > 4 else "MASKED"
+            else:
+                masked[key] = value
+        else:
+            masked[key] = value
+    return masked
+
+
+def truncate_data(data: Any, max_length: int = 500) -> str:
+    """Truncate long data for logging.
+    
+    Args:
+        data: Data to truncate
+        max_length: Maximum length
+        
+    Returns:
+        Truncated string representation
+    """
+    str_data = str(data)
+    if len(str_data) <= max_length:
+        return str_data
+    return f"{str_data[:max_length]}... (truncated)"
+
+
+# Configure logger level based on environment
+if is_debug():
+    logger.setLevel(logging.DEBUG)
+elif is_verbose():
+    logger.setLevel(logging.INFO)
+else:
+    logger.setLevel(logging.WARNING)

lucidicai/utils/queue.py

@@ -0,0 +1,393 @@
+"""Parallel event queue for efficient event processing.
+
+This module provides a high-performance event queue that processes events
+in parallel while respecting parent-child dependencies.
+"""
+import gzip
+import io
+import json
+import queue
+import threading
+import time
+import requests
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional, Set, Tuple
+
+from ..core.config import get_config
+from ..utils.logger import debug, info, warning, error, truncate_id, truncate_data
+
+
+class EventQueue:
+    """High-performance parallel event queue."""
+    
+    def __init__(self, client):
+        """Initialize the event queue."""
+        self.config = get_config()
+        self._client = client
+        
+        # Queue configuration
+        self.max_queue_size = self.config.event_queue.max_queue_size
+        self.flush_interval_ms = self.config.event_queue.flush_interval_ms
+        self.flush_at_count = self.config.event_queue.flush_at_count
+        self.blob_threshold = self.config.event_queue.blob_threshold
+        self.max_workers = self.config.event_queue.max_parallel_workers
+        self.retry_failed = self.config.event_queue.retry_failed
+        
+        # Runtime state
+        self._queue = queue.Queue(maxsize=self.max_queue_size)
+        self._stopped = threading.Event()
+        self._flush_event = threading.Event()
+        self._worker: Optional[threading.Thread] = None
+        self._sent_ids: Set[str] = set()
+        # Removed deferred queue - no longer needed since backend handles any order
+        
+        # Thread pool for parallel processing
+        self._executor = ThreadPoolExecutor(
+            max_workers=self.max_workers,
+            thread_name_prefix="LucidicSender"
+        )
+        
+        # Thread safety
+        self._flush_lock = threading.Lock()
+        self._processing_count = 0
+        self._processing_lock = threading.Lock()
+        
+        # Start background worker
+        self._start_worker()
+        
+        debug(f"[EventQueue] Initialized with {self.max_workers} parallel workers, batch size: {self.flush_at_count}, flush interval: {self.flush_interval_ms}ms")
+
+    def queue_event(self, event_request: Dict[str, Any]) -> None:
+        """Enqueue an event for background processing."""
+        if "defer_count" not in event_request:
+            event_request["defer_count"] = 0
+        
+        try:
+            self._queue.put(event_request, block=True, timeout=0.001)
+            
+            event_id = event_request.get('client_event_id', 'unknown')
+            parent_id = event_request.get('client_parent_event_id')
+            debug(f"[EventQueue] Queued event {truncate_id(event_id)} (parent: {truncate_id(parent_id)}), queue size: {self._queue.qsize()}")
+            
+            # Wake worker if batch large enough
+            if self._queue.qsize() >= self.flush_at_count:
+                self._flush_event.set()
+                
+        except queue.Full:
+            warning(f"[EventQueue] Queue at max size {self.max_queue_size}, dropping event")
+
+    def force_flush(self, timeout_seconds: float = 5.0) -> None:
+        """Flush current queue synchronously (best-effort)."""
+        with self._flush_lock:
+            debug(f"[EventQueue] Force flush requested, queue size: {self._queue.qsize()}")
+            
+            # Signal the worker to flush immediately
+            self._flush_event.set()
+            
+            # Wait for the queue to be processed
+            end_time = time.time() + timeout_seconds
+            last_size = -1
+            stable_count = 0
+            
+            debug(f"[EventQueue] Force flush: entering wait loop, timeout={timeout_seconds}s")
+            iterations = 0
+            start_time = time.time()
+            while time.time() < end_time:
+                iterations += 1
+                if iterations % 20 == 1:  # Log every second (20 * 0.05s)
+                    debug(f"[EventQueue] Force flush: iteration {iterations}, time left: {end_time - time.time():.1f}s")
+                
+                current_size = self._queue.qsize()
+                
+                with self._processing_lock:
+                    processing = self._processing_count
+                
+                # Check if we're done
+                if current_size == 0 and processing == 0:
+                    if stable_count >= 2:
+                        debug("[EventQueue] Force flush complete")
+                        return
+                    stable_count += 1
+                    debug(f"[EventQueue] Force flush: queue empty, stable_count={stable_count}")
+                else:
+                    stable_count = 0
+                
+                # Check for progress
+                if current_size == last_size:
+                    stable_count += 1
+                    if stable_count >= 10:  # 0.5 seconds of no progress
+                        break
+                else:
+                    stable_count = 0
+                    last_size = current_size
+                
+                self._flush_event.set()
+                time.sleep(0.05)
+                
+                # Safety check to prevent infinite loop
+                if time.time() - start_time > timeout_seconds + 1:
+                    warning(f"[EventQueue] Force flush: exceeded timeout by >1s, breaking")
+                    break
+            
+            debug(f"[EventQueue] Force flush: exited wait loop after {time.time() - start_time:.1f}s")
+
+    def is_empty(self) -> bool:
+        """Check if queue is completely empty."""
+        with self._processing_lock:
+            queue_empty = self._queue.empty()
+            not_processing = self._processing_count == 0
+        # No deferred queue to check anymore
+        return queue_empty and not_processing
+
+    def shutdown(self, timeout: float = 5.0) -> None:
+        """Shutdown the event queue."""
+        info(f"[EventQueue] Shutting down with {self._queue.qsize()} events in queue")
+        
+        # Flush remaining events
+        self.force_flush(timeout_seconds=timeout)
+        
+        # Shutdown executor (timeout param added in Python 3.9+)
+        try:
+            self._executor.shutdown(wait=True, timeout=timeout)
+        except TypeError:
+            # Fallback for older Python versions
+            self._executor.shutdown(wait=True)
+        
+        # Signal stop
+        self._stopped.set()
+        self._flush_event.set()
+        
+        # Wait for worker
+        if self._worker and self._worker.is_alive():
+            self._worker.join(timeout=timeout)
+
+    # --- Internal Implementation ---
+    
+    def _start_worker(self) -> None:
+        """Start the background worker thread."""
+        if self._worker and self._worker.is_alive():
+            return
+        
+        self._worker = threading.Thread(
+            target=self._run_loop,
+            name="LucidicEventQueue",
+            daemon=self.config.event_queue.daemon_mode
+        )
+        self._worker.start()
+
+    def _run_loop(self) -> None:
+        """Main worker loop."""
+        while not self._stopped.is_set():
+            batch = self._collect_batch()
+            
+            if batch:
+                with self._processing_lock:
+                    self._processing_count = len(batch)
+                
+                try:
+                    self._process_batch(batch)
+                except Exception as e:
+                    error(f"[EventQueue] Batch processing error: {e}")
+                finally:
+                    with self._processing_lock:
+                        self._processing_count = 0
+
+    def _collect_batch(self) -> List[Dict[str, Any]]:
+        """Collect a batch of events from the queue."""
+        batch: List[Dict[str, Any]] = []
+        deadline = time.time() + (self.flush_interval_ms / 1000.0)
+        
+        while True:
+            # Check for force flush
+            if self._flush_event.is_set():
+                self._flush_event.clear()
+                # Drain entire queue
+                while not self._queue.empty():
+                    try:
+                        batch.append(self._queue.get_nowait())
+                    except queue.Empty:
+                        break
+                if batch:
+                    break
+            
+            # Check batch size
+            if len(batch) >= self.flush_at_count:
+                break
+            
+            # Check deadline
+            remaining_time = deadline - time.time()
+            if remaining_time <= 0:
+                break
+            
+            # Try to get an item
+            try:
+                timeout = min(remaining_time, 0.05)
+                item = self._queue.get(block=True, timeout=timeout)
+                batch.append(item)
+            except queue.Empty:
+                if self._stopped.is_set():
+                    # Drain remaining on shutdown
+                    while not self._queue.empty():
+                        try:
+                            batch.append(self._queue.get_nowait())
+                        except queue.Empty:
+                            break
+                    break
+                if batch and time.time() >= deadline:
+                    break
+        
+        return batch
+
+    def _process_batch(self, batch: List[Dict[str, Any]]) -> None:
+        """Process batch with parallel sending."""
+        debug(f"[EventQueue] Processing batch of {len(batch)} events")
+        
+        # No need to handle deferred events - we don't defer anymore
+        
+        # Group for parallel processing
+        dependency_groups = self._group_by_dependencies(batch)
+        
+        # Process each group in parallel
+        for group_index, group in enumerate(dependency_groups):
+            debug(f"[EventQueue] Processing dependency group {group_index + 1}/{len(dependency_groups)} with {len(group)} events in parallel")
+            
+            # Submit all events in group for parallel processing
+            futures_to_event = {}
+            for event in group:
+                future = self._executor.submit(self._send_event_safe, event)
+                futures_to_event[future] = event
+            
+            # Wait for completion
+            for future in as_completed(futures_to_event):
+                event = futures_to_event[future]
+                try:
+                    success = future.result(timeout=30)
+                    if success:
+                        if event_id := event.get("client_event_id"):
+                            self._sent_ids.add(event_id)
+                except Exception as e:
+                    debug(f"[EventQueue] Failed to send event: {e}")
+                    if self.retry_failed:
+                        self._retry_event(event)
+
+    def _group_by_dependencies(self, events: List[Dict[str, Any]]) -> List[List[Dict[str, Any]]]:
+        """Group events for parallel processing.
+        
+        Since the backend handles events in any order using client-side event IDs,
+        we don't need to check dependencies. Just return all events in one group
+        for maximum parallel processing.
+        """
+        if not events:
+            return []
+        
+        # Mark all event IDs as sent for tracking
+        for event in events:
+            if event_id := event.get("client_event_id"):
+                self._sent_ids.add(event_id)
+        
+        # Return all events in a single group for parallel processing
+        return [events]
+
+    def _send_event_safe(self, event_request: Dict[str, Any]) -> bool:
+        """Send event with error suppression if configured."""
+        if self.config.error_handling.suppress_errors:
+            try:
+                return self._send_event(event_request)
+            except Exception as e:
+                warning(f"[EventQueue] Suppressed send error: {e}")
+                return False
+        else:
+            return self._send_event(event_request)
+
+    def _send_event(self, event_request: Dict[str, Any]) -> bool:
+        """Send a single event to the backend."""
+        # No dependency checking needed - backend handles events in any order
+        
+        # Check for blob offloading
+        payload = event_request.get("payload", {})
+        raw_bytes = json.dumps(payload, separators=(",", ":"), ensure_ascii=False).encode("utf-8")
+        should_offload = len(raw_bytes) > self.blob_threshold
+        
+        if should_offload:
+            event_id = event_request.get('client_event_id', 'unknown')
+            debug(f"[EventQueue] Event {truncate_id(event_id)} needs blob storage ({len(raw_bytes)} bytes > {self.blob_threshold} threshold)")
+        
+        send_body: Dict[str, Any] = dict(event_request)
+        if should_offload:
+            send_body["needs_blob"] = True
+            send_body["payload"] = self._create_preview(send_body.get("type"), payload)
+        else:
+            send_body["needs_blob"] = False
+        
+        # Send event
+        try:
+            response = self._client.make_request("events", "POST", send_body)
+            
+            # Handle blob upload if needed
+            if should_offload:
+                blob_url = response.get("blob_url")
+                if blob_url:
+                    compressed = self._compress_json(payload)
+                    self._upload_blob(blob_url, compressed)
+                    debug(f"[EventQueue] Blob uploaded for event {truncate_id(event_request.get('client_event_id'))}")
+                else:
+                    error("[EventQueue] No blob_url received for large payload")
+                    return False
+            
+            return True
+            
+        except Exception as e:
+            debug(f"[EventQueue] Failed to send event {truncate_id(event_request.get('client_event_id'))}: {e}")
+            return False
+
+    def _retry_event(self, event: Dict[str, Any]) -> None:
+        """Retry a failed event."""
+        event["retry_count"] = event.get("retry_count", 0) + 1
+        if event["retry_count"] <= 3:
+            try:
+                self._queue.put_nowait(event)
+            except queue.Full:
+                pass
+
+    @staticmethod
+    def _compress_json(payload: Dict[str, Any]) -> bytes:
+        """Compress JSON payload using gzip."""
+        raw = json.dumps(payload, separators=(",", ":"), ensure_ascii=False).encode("utf-8")
+        buf = io.BytesIO()
+        with gzip.GzipFile(fileobj=buf, mode="wb") as gz:
+            gz.write(raw)
+        return buf.getvalue()
+
+    def _upload_blob(self, blob_url: str, data: bytes) -> None:
+        """Upload compressed blob to presigned URL."""
+        headers = {"Content-Type": "application/json", "Content-Encoding": "gzip"}
+        resp = requests.put(blob_url, data=data, headers=headers)
+        resp.raise_for_status()
+
+    @staticmethod
+    def _create_preview(event_type: Optional[str], payload: Dict[str, Any]) -> Dict[str, Any]:
+        """Create preview of large payload for logging."""
+        try:
+            t = (event_type or "generic").lower()
+            
+            if t == "llm_generation":
+                req = payload.get("request", {})
+                return {
+                    "request": {
+                        "model": str(req.get("model", ""))[:200],
+                        "provider": str(req.get("provider", ""))[:200],
+                        "messages": "truncated"
+                    },
+                    "response": {"output": "truncated"}
+                }
+            elif t == "function_call":
+                return {
+                    "function_name": str(payload.get("function_name", ""))[:200],
+                    "arguments": "truncated"
+                }
+            else:
+                return {"details": "preview_unavailable"}
+                
+        except Exception:
+            return {"details": "preview_error"}

{lucidicai-2.0.2.dist-info → lucidicai-2.1.1.dist-info}/METADATA

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

{lucidicai-2.0.2.dist-info → lucidicai-2.1.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-lucidicai/__init__.py,sha256=gLCbPIuvS7-PHVVdCtmx4x-lq1yRJDEbvpqRq3-1BHw,36531
+lucidicai/__init__.py,sha256=b5om5w8CV6UjgmeFOlzHTyC-m2PNDgQJ5AcOD7SizYk,12600
 lucidicai/action.py,sha256=sPRd1hTIVXDqnvG9ZXWEipUFh0bsXcE0Fm7RVqmVccM,237
 lucidicai/client.py,sha256=IIhlY6Mfwy47FeMxzpvIygCaqcI1FnqiXiVU6M4QEiE,22327
 lucidicai/constants.py,sha256=zN8O7TjoRHRlaGa9CZUWppS73rhzKGwaEkF9XMTV0Cg,1160
@@ -17,6 +17,16 @@ lucidicai/singleton.py,sha256=SKiNBgt_Wb5cCWbMt3IWjRAQw3v153LTRgqvDj8poF8,1457
 lucidicai/state.py,sha256=4Tb1X6l2or6w_e62FYSuEeghAv3xXm5gquKwzCpvdok,235
 lucidicai/step.py,sha256=_oBIyTBZBvNkUkYHIrwWd75KMSlMtR9Ws2Lo71Lyff8,2522
 lucidicai/streaming.py,sha256=QOLAzhwxetvx711J8VcphY5kXWPJz9XEBJrmHveRKMc,9796
+lucidicai/api/__init__.py,sha256=UOYuFZupG0TgzMAxbLNgpodDXhDRXBgMva8ZblgBN9Y,31
+lucidicai/api/client.py,sha256=czD3sg4wgyGQTVVlnSi3wpeCt90_D4eOuK8nBlpiv4U,7276
+lucidicai/api/resources/__init__.py,sha256=Wc8-JfL82wkE7eB8PHplqYvaEG2oXNXXhRyEPeduJeE,27
+lucidicai/api/resources/dataset.py,sha256=6UnMUd-y__TOAjUJLjbc0lZJRTy_gHkyoE82OvjFoN4,5583
+lucidicai/api/resources/event.py,sha256=GyyNL3_k53EbmvTdgJEABexiuJnoX61hxWey7DYmlYY,2434
+lucidicai/api/resources/session.py,sha256=w7b4kkbWdbaNbwuMBFgEeVmDfaYozBf9OK8B8L9B1m8,3730
+lucidicai/core/__init__.py,sha256=b0YQkd8190Y_GgwUcmf0tOiSLARd7L4kq4jwfhhGAyI,39
+lucidicai/core/config.py,sha256=P9y5aSZRkAehTvoBdYEc6x5-jiumB5cxftoMtJatl7w,7980
+lucidicai/core/errors.py,sha256=aRfdXABiTWFTiWELgu2Dz_wxVSggcBFqX7Q-toCy_fY,2130
+lucidicai/core/types.py,sha256=KabcTBQe7SemigccKfJSDiJmjSJDJJvvtefSd8pfrJI,702
 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
@@ -34,25 +44,44 @@ lucidicai/providers/otel_provider.py,sha256=ixLc80-_Vag0EO_92wj2m3_lg6HXyIpz9Md4
 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/sdk/__init__.py,sha256=UrkV9FYbZkBxaX9qwxGbCJdXp-JqMpn0_u-huO9Y-ec,32
+lucidicai/sdk/context.py,sha256=_tNem1a39CY-cFWue173eM7FgeUmOEmQ42EfkvKhehQ,7515
+lucidicai/sdk/decorators.py,sha256=B5BXG9Sn5ruUkxFq10L1rrCR_wzYUPlYeu5aqyXetMM,8393
+lucidicai/sdk/error_boundary.py,sha256=IPr5wS9rS7ZQNgEaBwK53UaixAm6L2rijKKFfxcxjUI,9190
+lucidicai/sdk/event.py,sha256=NiPcnPzYCU0VlFbBk93LD88wqAYmnglV64nQb2XteOs,3747
+lucidicai/sdk/event_builder.py,sha256=oMvt39m07ZLmPllJTWwRxpinJUz9_AD17yNE6wQRoDA,10423
+lucidicai/sdk/init.py,sha256=RMTyu_LZIo9Pi0uA76jkRviX6VBuvIuVpmFUXC7zwA4,12784
+lucidicai/sdk/shutdown_manager.py,sha256=I5ylR96QHQ_SfP1euAiM0qQ-I7upCPMW1HUNvoj7hCw,12090
+lucidicai/sdk/features/__init__.py,sha256=23KUF2EZBzsaH9JUFDGNXZb_3PSfc35VZfD59gAfyR0,26
+lucidicai/sdk/features/dataset.py,sha256=qFGnu8Wm1yhaflBhtm-5veN-KaoxGLBL5xWEifkrsY0,19416
+lucidicai/sdk/features/feature_flag.py,sha256=SzuzHiVnbticD6Ojn0_i9xQKui2s9QUFPJ7LixzAtf4,13844
 lucidicai/telemetry/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lucidicai/telemetry/base_provider.py,sha256=nrZVr4Y9xcAiMn4uAN3t3k6DlHNTvlXrA4qQg7lANOQ,544
-lucidicai/telemetry/context_capture_processor.py,sha256=k4_uTaoOhLeUAZsyUcDExVNXadk0nR4R1hJW096EVwY,2472
+lucidicai/telemetry/context_bridge.py,sha256=NwyclZvPcZHZtIvLSrY3oO8WQ_J1JSuHWIr36gxA7xk,2989
+lucidicai/telemetry/context_capture_processor.py,sha256=kzKWpg5m0OMUP5we6g453FjckWwA_jAVjOKCfiyKVN8,3651
 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/litellm_bridge.py,sha256=GlNeTX0HCu4JsUqfCGBb62XA61fhyWKv5ohfqSkriaE,16574
+lucidicai/telemetry/lucidic_exporter.py,sha256=tD1A2UGn0vuOW_FV_GVLXuXSxYYZf6r79Pczrn6d0lc,13189
 lucidicai/telemetry/lucidic_span_processor.py,sha256=-jo7Muuslo3ZCSAysLsDGBqJijQSpIOvJHPbPNjP4iQ,31029
 lucidicai/telemetry/openai_agents_instrumentor.py,sha256=__wIbeglMnEEf4AGTQ--FXeWCKmz2yy8SBupwprEdZA,12694
+lucidicai/telemetry/openai_patch.py,sha256=BRSwX4JQLd1kiH43K2FnGvk6rcf5rfZg9lxg_wPb45M,11904
+lucidicai/telemetry/openai_uninstrument.py,sha256=zELpoz2BU8O-rdHrg_7NuvjdNoY6swgoqVm5NtTCJRQ,3456
 lucidicai/telemetry/opentelemetry_converter.py,sha256=xOHCqoTyO4hUkL6k7fxy84PbljPpYep6ET9ZqbkJehc,17665
 lucidicai/telemetry/otel_handlers.py,sha256=OCzXuYog6AuwjI4eXy5Sk40DUehyz48QOxuOujXnEVU,20859
 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/telemetry_init.py,sha256=i5lxd2RzIADv2Va06APob9CmQ0KZMSbLKDrGtAGFyBo,9503
 lucidicai/telemetry/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lucidicai/telemetry/utils/image_storage.py,sha256=4Z59ZpVexr7-lcExfr8GsqXe0y2VZmr8Yjwa-3DeOxU,1457
+lucidicai/telemetry/utils/model_pricing.py,sha256=Dxi6e0WjcIyCTkVX7K7f0pJ5rPu7nSt3lOmgzAUQl1o,12402
 lucidicai/telemetry/utils/text_storage.py,sha256=L62MMJ8E23TDqDTUv2aRntdKMCItsXV7XjY6cFwx2DE,1503
 lucidicai/telemetry/utils/universal_image_interceptor.py,sha256=vARgMk1hVSF--zfi5b8qBpJJOESuD17YlH9xqxmB9Uw,15954
-lucidicai-2.0.2.dist-info/METADATA,sha256=V1siloLacf-bYmlcOYtg0Tac9ZJM3wWxDrj2Co_O498,902
-lucidicai-2.0.2.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
-lucidicai-2.0.2.dist-info/top_level.txt,sha256=vSSdM3lclF4I5tyVC0xxUk8eIRnnYXMe1hW-eO91HUo,10
-lucidicai-2.0.2.dist-info/RECORD,,
+lucidicai/utils/__init__.py,sha256=ZiGtmJaF0ph9iIFIgQiAreVuYM_1o7qu9VySK1NblTw,22
+lucidicai/utils/images.py,sha256=YHFjeKHRxzWu0IsuNwKw303egPsd99AShaD4WND1lJk,12325
+lucidicai/utils/logger.py,sha256=R3B3gSee64F6UVHUrShihBq_O7W7bgfrBiVDXTO3Isg,4777
+lucidicai/utils/queue.py,sha256=iBhazYt9EPTpyuexfDyPjvJT-2ODaAbCBbGYvLVl8wM,15815
+lucidicai-2.1.1.dist-info/METADATA,sha256=QWcIgu6okS3ZQmbRJgq_2mAgHUnhV9tazlTSPmUMqKg,902
+lucidicai-2.1.1.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
+lucidicai-2.1.1.dist-info/top_level.txt,sha256=vSSdM3lclF4I5tyVC0xxUk8eIRnnYXMe1hW-eO91HUo,10
+lucidicai-2.1.1.dist-info/RECORD,,