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

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/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.2.dist-info → lucidicai-2.0.1.dist-info}/METADATA

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

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

@@ -1,18 +1,22 @@
-lucidicai/__init__.py,sha256=KAjcOBwj4ENz1IxsrVS2gmuzn14tiPNNCtSczjEeDZ0,21617
+lucidicai/__init__.py,sha256=3gm2pFPTndvfx1zalGWqBdbdkUE_DDvAPbtsoIV5720,35879
 lucidicai/action.py,sha256=sPRd1hTIVXDqnvG9ZXWEipUFh0bsXcE0Fm7RVqmVccM,237
-lucidicai/client.py,sha256=s3EKrtcgMXGxEyguxQihncPz8AEXxSG32PXSNdOCvNg,9111
-lucidicai/constants.py,sha256=_u0z3M4geZgS1g-CrOZUVjtcew8l70dKQnpVQvlXh9w,2172
-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=o1yWCaF5Qxj4tloXxVG3SZXcTMKtk56J_Nfdo8M4uR0,11947
-lucidicai/session.py,sha256=bSI6_kOHQEuk7z8NtNbU_RZoc41UxhwWrztwScFuNTw,4068
-lucidicai/singleton.py,sha256=gfT3XdWLXSIWMqDXbY6-pnesMZ8RGRitaEPhIsgrRPw,1272
+lucidicai/model_pricing.py,sha256=Dxi6e0WjcIyCTkVX7K7f0pJ5rPu7nSt3lOmgzAUQl1o,12402
+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
@@ -32,20 +36,23 @@ 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=h2GOnEk22Fpeke4Zc7SSk391yr0joUApVwolV5Q4hz4,10818
-lucidicai/telemetry/lucidic_span_processor.py,sha256=9EKD4fvnEQIoPBLhGCAHRxsLAWmJNGFnb1NpwRUlMOI,30048
+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
-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/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=zPfVsMjtKxJP2n2OOjKbtPiQJTZ0sf5_28GWprOnJP4,12185
-lucidicai-1.3.2.dist-info/METADATA,sha256=sGAV3cdtrPBKSB-f2OOenESBbvJNeoV4ipwupEJ42r0,902
-lucidicai-1.3.2.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
-lucidicai-1.3.2.dist-info/top_level.txt,sha256=vSSdM3lclF4I5tyVC0xxUk8eIRnnYXMe1hW-eO91HUo,10
-lucidicai-1.3.2.dist-info/RECORD,,
+lucidicai/telemetry/utils/universal_image_interceptor.py,sha256=vARgMk1hVSF--zfi5b8qBpJJOESuD17YlH9xqxmB9Uw,15954
+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,,