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

lucidicai/telemetry/otel_init.py

@@ -1,13 +1,15 @@
-"""OpenTelemetry initialization and configuration for Lucidic"""
+"""OpenTelemetry initialization and configuration for Lucidic
+
+Adds thread-safety and idempotence to avoid duplicate tracer provider
+registration and repeated instrumentation under concurrency.
+"""
 import logging
 from typing import List, Optional
 
 from opentelemetry import trace
 from opentelemetry.sdk.trace import TracerProvider
 from opentelemetry.sdk.resources import Resource
-from opentelemetry.instrumentation.openai import OpenAIInstrumentor
-from opentelemetry.instrumentation.anthropic import AnthropicInstrumentor
-from opentelemetry.instrumentation.langchain import LangchainInstrumentor
+# Instrumentors are imported lazily inside methods to avoid import errors
 
 from .lucidic_span_processor import LucidicSpanProcessor
 from .otel_provider import OpenTelemetryProvider
@@ -15,6 +17,10 @@ from lucidicai.client import Client
 
 logger = logging.getLogger("Lucidic")
 
+import threading
+
+
+_init_lock = threading.Lock()
 
 class LucidicTelemetry:
     """Manages OpenTelemetry initialization for Lucidic"""
@@ -37,59 +43,73 @@ class LucidicTelemetry:
     
     def initialize(self, agent_id: str, service_name: str = "lucidic-ai") -> None:
         """Initialize OpenTelemetry with Lucidic configuration"""
-        if self.tracer_provider:
-            logger.debug("OpenTelemetry already initialized")
-            return
-            
-        try:
-            # Create resource
-            resource = Resource.create({
-                "service.name": service_name,
-                "service.version": "1.0.0",
-                "lucidic.agent_id": agent_id,
-            })
-            
-            # Create tracer provider
-            self.tracer_provider = TracerProvider(resource=resource)
-            
-            # Add our custom span processor for real-time event handling
-            self.span_processor = LucidicSpanProcessor()
-            self.tracer_provider.add_span_processor(self.span_processor)
-            
-            # Set as global provider
-            trace.set_tracer_provider(self.tracer_provider)
-            
-            logger.info("[LucidicTelemetry] OpenTelemetry initialized")
-            
-        except Exception as e:
-            logger.error(f"Failed to initialize OpenTelemetry: {e}")
-            raise
+        with _init_lock:
+            if self.tracer_provider:
+                logger.debug("OpenTelemetry already initialized")
+                return
+            try:
+                resource = Resource.create({
+                    "service.name": service_name,
+                    "service.version": "1.0.0",
+                    "lucidic.agent_id": agent_id,
+                })
+                provider = TracerProvider(resource=resource)
+                processor = LucidicSpanProcessor()
+                provider.add_span_processor(processor)
+                try:
+                    trace.set_tracer_provider(provider)
+                except Exception as e:
+                    # Another provider may already be registered; proceed with ours as a local provider
+                    logger.debug(f"Global tracer provider already set: {e}")
+                self.tracer_provider = provider
+                self.span_processor = processor
+                logger.info("[LucidicTelemetry] OpenTelemetry initialized")
+            except Exception as e:
+                logger.error(f"Failed to initialize OpenTelemetry: {e}")
+                raise
     
     def instrument_providers(self, providers: List[str]) -> None:
         """Instrument specified providers"""
-        for provider in providers:
-            try:
-                if provider == "openai" and provider not in self.instrumentors:
-                    self._instrument_openai()
-                elif provider == "anthropic" and provider not in self.instrumentors:
-                    self._instrument_anthropic()
-                elif provider == "langchain" and provider not in self.instrumentors:
-                    self._instrument_langchain()
-                elif provider == "pydantic_ai":
-                    # Custom instrumentation needed
-                    logger.info(f"[LucidicTelemetry] Pydantic AI will use manual instrumentation")
-                elif provider == "openai_agents":
-                    # OpenAI Agents uses the same OpenAI instrumentation
-                    self._instrument_openai_agents()
-                elif provider == "litellm":
-                    # LiteLLM uses callbacks, not OpenTelemetry instrumentation
-                    logger.info(f"[LucidicTelemetry] LiteLLM will use callback-based instrumentation")
-            except Exception as e:
-                logger.error(f"Failed to instrument {provider}: {e}")
+        with _init_lock:
+            for provider in providers:
+                # Map synonyms to canonical names
+                canonical = provider
+                if provider in ("google_generativeai",):
+                    canonical = "google"
+                elif provider in ("vertex_ai",):
+                    canonical = "vertexai"
+                elif provider in ("aws_bedrock", "amazon_bedrock"):
+                    canonical = "bedrock"
+                try:
+                    if canonical == "openai" and canonical not in self.instrumentors:
+                        self._instrument_openai()
+                    elif canonical == "anthropic" and canonical not in self.instrumentors:
+                        self._instrument_anthropic()
+                    elif canonical == "langchain" and canonical not in self.instrumentors:
+                        self._instrument_langchain()
+                    elif canonical == "google" and canonical not in self.instrumentors:
+                        self._instrument_google_generativeai()
+                    elif canonical == "vertexai" and canonical not in self.instrumentors:
+                        self._instrument_vertexai()
+                    elif canonical == "bedrock" and canonical not in self.instrumentors:
+                        self._instrument_bedrock()
+                    elif canonical == "cohere" and canonical not in self.instrumentors:
+                        self._instrument_cohere()
+                    elif canonical == "groq" and canonical not in self.instrumentors:
+                        self._instrument_groq()
+                    elif canonical == "pydantic_ai":
+                        logger.info(f"[LucidicTelemetry] Pydantic AI will use manual instrumentation")
+                    elif canonical == "openai_agents":
+                        self._instrument_openai_agents()
+                    elif canonical == "litellm":
+                        logger.info(f"[LucidicTelemetry] LiteLLM will use callback-based instrumentation")
+                except Exception as e:
+                    logger.error(f"Failed to instrument {canonical}: {e}")
     
     def _instrument_openai(self) -> None:
         """Instrument OpenAI"""
         try:
+            from opentelemetry.instrumentation.openai import OpenAIInstrumentor
             # Get client for masking function
             client = Client()
             
@@ -125,6 +145,7 @@ class LucidicTelemetry:
     def _instrument_anthropic(self) -> None:
         """Instrument Anthropic"""
         try:
+            from opentelemetry.instrumentation.anthropic import AnthropicInstrumentor
             instrumentor = AnthropicInstrumentor()
             
             # Get client for context
@@ -153,6 +174,7 @@ class LucidicTelemetry:
     def _instrument_langchain(self) -> None:
         """Instrument LangChain"""
         try:
+            from opentelemetry.instrumentation.langchain import LangchainInstrumentor
             instrumentor = LangchainInstrumentor()
             instrumentor.instrument(tracer_provider=self.tracer_provider)
             
@@ -163,6 +185,73 @@ class LucidicTelemetry:
             logger.error(f"Failed to instrument LangChain: {e}")
             raise
 
+    def _instrument_google_generativeai(self) -> None:
+        """Instrument Google Generative AI"""
+        try:
+            from opentelemetry.instrumentation.google_generativeai import GoogleGenerativeAiInstrumentor
+            instrumentor = GoogleGenerativeAiInstrumentor(exception_logger=lambda e: logger.error(f"Google Generative AI error: {e}"))
+            instrumentor.instrument(tracer_provider=self.tracer_provider)
+            self.instrumentors["google"] = instrumentor
+            logger.info("[LucidicTelemetry] Instrumented Google Generative AI")
+        except Exception as e:
+            logger.error(f"Failed to instrument Google Generative AI: {e}")
+            raise
+
+    def _instrument_vertexai(self) -> None:
+        """Instrument Vertex AI"""
+        try:
+            from opentelemetry.instrumentation.vertexai import VertexAIInstrumentor
+            instrumentor = VertexAIInstrumentor(exception_logger=lambda e: logger.error(f"Vertex AI error: {e}"))
+            instrumentor.instrument(tracer_provider=self.tracer_provider)
+            self.instrumentors["vertexai"] = instrumentor
+            logger.info("[LucidicTelemetry] Instrumented Vertex AI")
+        except Exception as e:
+            logger.error(f"Failed to instrument Vertex AI: {e}")
+            raise
+
+    def _instrument_cohere(self) -> None:
+        """Instrument Cohere"""
+        try:
+            from opentelemetry.instrumentation.cohere import CohereInstrumentor
+            instrumentor = CohereInstrumentor(exception_logger=lambda e: logger.error(f"Cohere error: {e}"), use_legacy_attributes=True)
+            instrumentor.instrument(tracer_provider=self.tracer_provider)
+            self.instrumentors["cohere"] = instrumentor
+            logger.info("[LucidicTelemetry] Instrumented Cohere")
+        except Exception as e:
+            logger.error(f"Failed to instrument Cohere: {e}")
+            raise
+
+    def _instrument_bedrock(self) -> None:
+        """Instrument AWS Bedrock"""
+        try:
+            from opentelemetry.instrumentation.bedrock import BedrockInstrumentor
+            instrumentor = BedrockInstrumentor(enrich_token_usage=True, exception_logger=lambda e: logger.error(f"Bedrock error: {e}"))
+            instrumentor.instrument(tracer_provider=self.tracer_provider)
+            self.instrumentors["bedrock"] = instrumentor
+            logger.info("[LucidicTelemetry] Instrumented Bedrock")
+        except Exception as e:
+            logger.error(f"Failed to instrument Bedrock: {e}")
+            raise
+
+    def _instrument_groq(self) -> None:
+        """Instrument Groq"""
+        try:
+            from lucidicai.client import Client
+            client = Client()
+            def get_custom_attributes():
+                attrs = {}
+                if client.session and client.session.active_step:
+                    attrs["lucidic.step_id"] = client.session.active_step.step_id
+                return attrs
+            from opentelemetry.instrumentation.groq import GroqInstrumentor
+            instrumentor = GroqInstrumentor(exception_logger=lambda e: logger.error(f"Groq error: {e}"), use_legacy_attributes=True, get_common_metrics_attributes=get_custom_attributes)
+            instrumentor.instrument(tracer_provider=self.tracer_provider)
+            self.instrumentors["groq"] = instrumentor
+            logger.info("[LucidicTelemetry] Instrumented Groq")
+        except Exception as e:
+            logger.error(f"Failed to instrument Groq: {e}")
+            raise
+
     def _instrument_openai_agents(self) -> None:
         """Instrument OpenAI Agents SDK"""
         try:
@@ -197,4 +286,27 @@ class LucidicTelemetry:
             
     def is_initialized(self) -> bool:
         """Check if telemetry is initialized"""
-        return self.tracer_provider is not None
+        return self.tracer_provider is not None
+
+    def force_flush(self) -> None:
+        """Best-effort force flush of telemetry before shutdown.
+
+        Uses whichever force_flush hooks are available on the provider or span processor.
+        Swallows all exceptions to avoid interfering with process shutdown paths.
+        """
+        try:
+            provider = getattr(self, 'tracer_provider', None)
+            if provider and hasattr(provider, 'force_flush'):
+                try:
+                    provider.force_flush()
+                except Exception:
+                    pass
+            processor = getattr(self, 'span_processor', None)
+            if processor and hasattr(processor, 'force_flush'):
+                try:
+                    processor.force_flush()
+                except Exception:
+                    pass
+        except Exception:
+            # Never raise from force_flush
+            pass

lucidicai/telemetry/otel_provider.py

@@ -8,12 +8,11 @@ from opentelemetry.trace import Tracer, Span
 from opentelemetry.sdk.trace import TracerProvider
 from opentelemetry.sdk.trace.export import BatchSpanProcessor
 from opentelemetry.sdk.resources import Resource
-from opentelemetry.instrumentation.openai import OpenAIInstrumentor
-from opentelemetry.instrumentation.anthropic import AnthropicInstrumentor
-from opentelemetry.instrumentation.langchain import LangchainInstrumentor
+# Instrumentors are imported lazily inside methods to avoid import errors
 from opentelemetry.semconv_ai import SpanAttributes
 
 from .lucidic_exporter import LucidicSpanExporter
+from .lucidic_span_processor import LucidicSpanProcessor
 from .base_provider import BaseProvider
 from lucidicai.client import Client
 
@@ -47,9 +46,17 @@ class OpenTelemetryProvider(BaseProvider):
         lucidic_exporter = LucidicSpanExporter()
         span_processor = BatchSpanProcessor(lucidic_exporter)
         self.tracer_provider.add_span_processor(span_processor)
+        # Also add session-stamping processor to ensure correct attribution
+        try:
+            self.tracer_provider.add_span_processor(LucidicSpanProcessor())
+        except Exception:
+            pass
         
-        # Set as global provider
-        trace.set_tracer_provider(self.tracer_provider)
+        # Set as global provider (ignore if already set)
+        try:
+            trace.set_tracer_provider(self.tracer_provider)
+        except Exception:
+            pass
         
         # Get tracer
         self.tracer = trace.get_tracer(__name__)
@@ -93,6 +100,7 @@ class OpenTelemetryProvider(BaseProvider):
         """Instrument OpenAI with OpenLLMetry"""
         if "openai" not in self.instrumentors:
             try:
+                from opentelemetry.instrumentation.openai import OpenAIInstrumentor
                 instrumentor = OpenAIInstrumentor()
                 instrumentor.instrument(
                     tracer_provider=self.tracer_provider,
@@ -108,6 +116,7 @@ class OpenTelemetryProvider(BaseProvider):
         """Instrument Anthropic with OpenLLMetry"""
         if "anthropic" not in self.instrumentors:
             try:
+                from opentelemetry.instrumentation.anthropic import AnthropicInstrumentor
                 instrumentor = AnthropicInstrumentor()
                 instrumentor.instrument(
                     tracer_provider=self.tracer_provider,
@@ -122,6 +131,7 @@ class OpenTelemetryProvider(BaseProvider):
         """Instrument LangChain with OpenLLMetry"""
         if "langchain" not in self.instrumentors:
             try:
+                from opentelemetry.instrumentation.langchain import LangchainInstrumentor
                 instrumentor = LangchainInstrumentor()
                 instrumentor.instrument(tracer_provider=self.tracer_provider)
                 self.instrumentors["langchain"] = instrumentor

lucidicai/telemetry/utils/universal_image_interceptor.py

@@ -124,6 +124,35 @@ class UniversalImageInterceptor:
                                     logger.info(f"[Universal Interceptor] Stored Google image, placeholder: {placeholder}")
                 processed_messages.append(message)
         return processed_messages
+
+    @staticmethod
+    def extract_and_store_images_genai_contents(contents: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """Extract and store images/text from google.genai 'contents' structure
+        
+        Example:
+        contents = [
+            {"text": "What's in this image?"},
+            {"inline_data": {"mime_type": "image/jpeg", "data": "..."}}
+        ]
+        """
+        if not isinstance(contents, list):
+            return contents
+        clear_stored_texts()
+        texts = []
+        for item in contents:
+            if isinstance(item, dict):
+                if 'text' in item and isinstance(item['text'], str):
+                    texts.append(item['text'])
+                elif 'inline_data' in item and isinstance(item['inline_data'], dict):
+                    data = item['inline_data'].get('data', '')
+                    mime = item['inline_data'].get('mime_type', 'image/jpeg')
+                    if data:
+                        data_url = f"data:{mime};base64,{data}"
+                        store_image(data_url)
+        if texts:
+            combined = ' '.join(texts)
+            store_text(combined, 0)
+        return contents
     
     @staticmethod
     def intercept_images(messages: Any, provider: str = "auto") -> Any:
@@ -273,4 +302,64 @@ def patch_google_client(client):
         client.generate_content = interceptor(original_generate)
         if DEBUG:
             logger.info("[Universal Interceptor] Patched Google client for image interception")
+    return client
+
+
+def patch_google_genai() -> None:
+    """Patch google.genai to intercept images/text passed via contents
+    Wraps Models.generate_content and AsyncModels.generate_content
+    """
+    try:
+        from google.genai import models as genai_models
+    except Exception:
+        return
+
+    def wrap_generate_content(original_func):
+        def wrapper(*args, **kwargs):
+            contents = kwargs.get('contents', None)
+            if contents is None and len(args) >= 2:
+                # Likely signature: (self, contents=..., ...)
+                contents = args[1]
+            if contents is not None:
+                try:
+                    UniversalImageInterceptor.extract_and_store_images_genai_contents(contents)
+                except Exception:
+                    pass
+            return original_func(*args, **kwargs)
+        return wrapper
+
+    # Patch sync Models
+    try:
+        if hasattr(genai_models, 'Models') and hasattr(genai_models.Models, 'generate_content'):
+            original = genai_models.Models.generate_content
+            if not getattr(original, '__lucidic_patched__', False):
+                patched = wrap_generate_content(original)
+                setattr(patched, '__lucidic_patched__', True)
+                genai_models.Models.generate_content = patched
+    except Exception:
+        pass
+
+    # Patch async Models (if present)
+    try:
+        if hasattr(genai_models, 'AsyncModels') and hasattr(genai_models.AsyncModels, 'generate_content'):
+            original_async = genai_models.AsyncModels.generate_content
+            if not getattr(original_async, '__lucidic_patched__', False):
+                patched_async = wrap_generate_content(original_async)
+                setattr(patched_async, '__lucidic_patched__', True)
+                genai_models.AsyncModels.generate_content = patched_async
+    except Exception:
+        pass
+
+
+def patch_vertexai_client(client):
+    """Patch a Vertex AI client/model instance to intercept images (Google format)"""
+    interceptor = UniversalImageInterceptor.create_interceptor("google")
+    
+    # Vertex AI GenerativeModel has generate_content / generate_content_async
+    if hasattr(client, 'generate_content'):
+        original_generate = client.generate_content
+        client.generate_content = interceptor(original_generate)
+    if hasattr(client, 'generate_content_async'):
+        original_generate_async = getattr(client, 'generate_content_async')
+        client.generate_content_async = UniversalImageInterceptor.create_async_interceptor("google")(original_generate_async)
     return client

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

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

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

@@ -1,14 +1,15 @@
-lucidicai/__init__.py,sha256=-eSSR9UaMubE0KpbesR2jLU0xUn37oucMNxjgKaCfkA,20738
+lucidicai/__init__.py,sha256=bac3gGZ1Rxn4ZRr4hYssPcucdfHDTD2yTlAGfP1cqzM,29840
 lucidicai/action.py,sha256=sPRd1hTIVXDqnvG9ZXWEipUFh0bsXcE0Fm7RVqmVccM,237
-lucidicai/client.py,sha256=MZuNd1S6MTwNRDJ8cUrZfnTZgBBHFwTO2Pc_-wbVNEM,8981
+lucidicai/client.py,sha256=qTY0LIuG6NbdV4Gy09poqDDe-pFnlWtEQi7Xhf2exNE,9856
 lucidicai/constants.py,sha256=_u0z3M4geZgS1g-CrOZUVjtcew8l70dKQnpVQvlXh9w,2172
-lucidicai/decorators.py,sha256=oqXyfHk9f9UmeaIquuU8mtzed1qZtO_-svwadpoat6g,13950
+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=EF-KNPMBHGdNnhchu5HF7QnYJSMofUaq-QuGL0j_OAE,2521
+lucidicai/event.py,sha256=2Rxa4EDLFBTBFTNXD4sjQ9DCMLiloFQqugL7unyYcL4,2642
 lucidicai/image_upload.py,sha256=6SRudg-BpInM2gzMx1Yf1Rz_Zyh8inwoJ7U4pBw7ruY,3807
 lucidicai/lru.py,sha256=PXiDSoUCOxjamG1QlQx6pDbQCm8h5hKAnnr_NI0PEgE,618
-lucidicai/model_pricing.py,sha256=o1yWCaF5Qxj4tloXxVG3SZXcTMKtk56J_Nfdo8M4uR0,11947
-lucidicai/session.py,sha256=NFkWJioqGcRxHjfqwWw-1DZSiScNpnUlY1gtGGApqSQ,4060
+lucidicai/model_pricing.py,sha256=Dxi6e0WjcIyCTkVX7K7f0pJ5rPu7nSt3lOmgzAUQl1o,12402
+lucidicai/session.py,sha256=bSI6_kOHQEuk7z8NtNbU_RZoc41UxhwWrztwScFuNTw,4068
 lucidicai/singleton.py,sha256=gfT3XdWLXSIWMqDXbY6-pnesMZ8RGRitaEPhIsgrRPw,1272
 lucidicai/state.py,sha256=4Tb1X6l2or6w_e62FYSuEeghAv3xXm5gquKwzCpvdok,235
 lucidicai/step.py,sha256=_oBIyTBZBvNkUkYHIrwWd75KMSlMtR9Ws2Lo71Lyff8,2522
@@ -33,19 +34,19 @@ lucidicai/providers/universal_image_interceptor.py,sha256=7d-hw4xihRwvvA1AP8-vqY
 lucidicai/telemetry/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lucidicai/telemetry/base_provider.py,sha256=nrZVr4Y9xcAiMn4uAN3t3k6DlHNTvlXrA4qQg7lANOQ,544
 lucidicai/telemetry/litellm_bridge.py,sha256=mOdjEfvP--ToDv8snoOMU4pRQx_Yg4s2o3BMTMzeRK8,14979
-lucidicai/telemetry/lucidic_exporter.py,sha256=h2GOnEk22Fpeke4Zc7SSk391yr0joUApVwolV5Q4hz4,10818
-lucidicai/telemetry/lucidic_span_processor.py,sha256=9EKD4fvnEQIoPBLhGCAHRxsLAWmJNGFnb1NpwRUlMOI,30048
+lucidicai/telemetry/lucidic_exporter.py,sha256=XAeMQClz5MbGb8ziNT9bhAk3bcqTAkcMxJHvxKAjbCk,11435
+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
-lucidicai/telemetry/otel_handlers.py,sha256=HqGYIWJI_Vp8So2-HMpPjnrgTBSgBHHLDu01z_sq-Qk,14646
-lucidicai/telemetry/otel_init.py,sha256=d0JcdDD23U_0xyBCAPOcZkFuOwv_7kI9Mih4msin6fw,7997
-lucidicai/telemetry/otel_provider.py,sha256=GZPhSEsEPVKrr5A0u5-WNn7OmxNgRWBcam9dyqjf91o,7042
+lucidicai/telemetry/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/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.3.1.dist-info/METADATA,sha256=fMRzVo9mOgHvcC6PGrH5zdyLaMRrz3KBch6fMkHtgEE,902
-lucidicai-1.3.1.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
-lucidicai-1.3.1.dist-info/top_level.txt,sha256=vSSdM3lclF4I5tyVC0xxUk8eIRnnYXMe1hW-eO91HUo,10
-lucidicai-1.3.1.dist-info/RECORD,,
+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,,