lucidicai 3.1.1__py3-none-any.whl → 3.3.0__py3-none-any.whl

lucidicai/__init__.py

@@ -34,8 +34,11 @@ from .core.errors import (
     FeatureFlagError,
 )
 
+# Integrations
+from .integrations.livekit import setup_livekit
+
 # Version
-__version__ = "3.1.1"
+__version__ = "3.3.0"
 
 # All exports
 __all__ = [
@@ -50,6 +53,8 @@ __all__ = [
     "InvalidOperationError",
     "PromptError",
     "FeatureFlagError",
+    # Integrations
+    "setup_livekit",
     # Version
     "__version__",
 ]

lucidicai/client.py

@@ -64,6 +64,8 @@ class LucidicAI:
         auto_end: Whether sessions auto-end on context exit or process shutdown.
         production: If True, suppress SDK errors. If None, checks LUCIDIC_PRODUCTION env var.
         region: Deployment region ("us", "india"). Falls back to LUCIDIC_REGION env var.
+        base_url: Custom base URL for API requests. Takes precedence over region.
+                  Falls back to LUCIDIC_BASE_URL env var.
         **kwargs: Additional configuration options passed to SDKConfig.
 
     Raises:
@@ -93,6 +95,13 @@ class LucidicAI:
             agent_id="...",
             region="india"
         )
+
+        # Custom base URL (e.g., self-hosted deployment)
+        client = LucidicAI(
+            api_key="...",
+            agent_id="...",
+            base_url="https://custom.example.com/api"
+        )
     """
 
     def __init__(
@@ -103,6 +112,7 @@ class LucidicAI:
         auto_end: bool = True,
         production: Optional[bool] = None,
         region: Optional[str] = None,
+        base_url: Optional[str] = None,
         **kwargs,
     ):
         # Generate unique client ID for telemetry routing
@@ -119,6 +129,7 @@ class LucidicAI:
             agent_id=agent_id,
             auto_end=auto_end,
             region=region,
+            base_url=base_url,
             **kwargs,
         )
 

lucidicai/core/config.py

@@ -53,16 +53,20 @@ class NetworkConfig:
     connection_pool_maxsize: int = 100
 
     @classmethod
-    def from_env(cls, region: Optional[str] = None, debug: bool = False) -> 'NetworkConfig':
+    def from_env(cls, region: Optional[str] = None, base_url: Optional[str] = None, debug: bool = False) -> 'NetworkConfig':
         """Load network configuration from environment variables.
 
-        Priority: debug > region argument > LUCIDIC_REGION env var > default
+        Priority: debug > base_url argument > LUCIDIC_BASE_URL > region argument > LUCIDIC_REGION > default
 
         Args:
             region: Region string override (e.g., "us", "india")
-            debug: If True, use localhost URL regardless of region
+            base_url: Custom base URL override (takes precedence over region)
+            debug: If True, use localhost URL regardless of other settings
         """
-        # If debug mode, use localhost (ignores region)
+        import logging
+        logger = logging.getLogger("Lucidic")
+
+        # If debug mode, use localhost (highest priority)
         if debug:
             return cls(
                 base_url=DEBUG_URL,
@@ -74,7 +78,28 @@ class NetworkConfig:
                 connection_pool_maxsize=int(os.getenv("LUCIDIC_CONNECTION_POOL_MAXSIZE", "100"))
             )
 
-        # Resolve region: argument > env var > default
+        # Resolve base_url: argument > env var
+        resolved_base_url = base_url or os.getenv("LUCIDIC_BASE_URL")
+
+        if resolved_base_url:
+            # base_url takes precedence over region
+            region_str = region or os.getenv("LUCIDIC_REGION")
+            if region_str:
+                logger.warning(
+                    f"[LucidicAI] Both base_url and region specified. "
+                    f"Using base_url '{resolved_base_url}', ignoring region '{region_str}'."
+                )
+            return cls(
+                base_url=resolved_base_url,
+                region=None,  # Custom deployment, no region
+                timeout=int(os.getenv("LUCIDIC_TIMEOUT", "30")),
+                max_retries=int(os.getenv("LUCIDIC_MAX_RETRIES", "3")),
+                backoff_factor=float(os.getenv("LUCIDIC_BACKOFF_FACTOR", "0.5")),
+                connection_pool_size=int(os.getenv("LUCIDIC_CONNECTION_POOL_SIZE", "20")),
+                connection_pool_maxsize=int(os.getenv("LUCIDIC_CONNECTION_POOL_MAXSIZE", "100"))
+            )
+
+        # Fall back to region-based URL resolution
         region_str = region or os.getenv("LUCIDIC_REGION")
         resolved_region = Region.from_string(region_str) if region_str else DEFAULT_REGION
 
@@ -147,11 +172,13 @@ class SDKConfig:
     debug: bool = False
     
     @classmethod
-    def from_env(cls, region: Optional[str] = None, **overrides) -> 'SDKConfig':
+    def from_env(cls, region: Optional[str] = None, base_url: Optional[str] = None, **overrides) -> 'SDKConfig':
         """Create configuration from environment variables with optional overrides.
 
         Args:
             region: Region string (e.g., "us", "india"). Priority: arg > env var > default
+            base_url: Custom base URL override. Takes precedence over region.
+                      Falls back to LUCIDIC_BASE_URL env var.
             **overrides: Additional configuration overrides
         """
         from dotenv import load_dotenv
@@ -165,7 +192,7 @@ class SDKConfig:
             auto_end=os.getenv("LUCIDIC_AUTO_END", "true").lower() == "true",
             production_monitoring=False,
             blob_threshold=int(os.getenv("LUCIDIC_BLOB_THRESHOLD", "65536")),
-            network=NetworkConfig.from_env(region=region, debug=debug),
+            network=NetworkConfig.from_env(region=region, base_url=base_url, debug=debug),
             error_handling=ErrorHandlingConfig.from_env(),
             telemetry=TelemetryConfig.from_env(),
             environment=Environment.DEBUG if debug else Environment.PRODUCTION,

lucidicai/integrations/__init__.py

@@ -0,0 +1,9 @@
+"""Third-party integrations for Lucidic AI SDK.
+
+This module provides integrations with external platforms and frameworks
+that have their own OpenTelemetry instrumentation.
+"""
+
+from .livekit import setup_livekit, LucidicLiveKitExporter
+
+__all__ = ["setup_livekit", "LucidicLiveKitExporter"]

lucidicai/integrations/livekit.py

@@ -0,0 +1,409 @@
+"""LiveKit voice agent integration for Lucidic AI SDK.
+
+This module provides OpenTelemetry span export for LiveKit voice agents,
+converting LiveKit's internal spans into Lucidic events with full metadata
+support including latency diagnostics, EOU detection data, and tool context.
+
+Example:
+    from lucidicai import LucidicAI
+    from lucidicai.integrations.livekit import setup_livekit
+    from livekit.agents import AgentServer, JobContext, AgentSession, cli
+    from livekit.agents.telemetry import set_tracer_provider
+
+    client = LucidicAI(api_key="...", agent_id="...")
+    server = AgentServer()
+
+    @server.rtc_session()
+    async def entrypoint(ctx: JobContext):
+        trace_provider = setup_livekit(
+            client=client,
+            session_id=ctx.room.name,
+        )
+        set_tracer_provider(trace_provider)
+        # ... rest of agent setup
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from datetime import datetime, timezone
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Sequence
+
+from opentelemetry import context as otel_context
+from opentelemetry.sdk.trace import ReadableSpan, SpanProcessor
+from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
+from opentelemetry.trace import Span
+from opentelemetry.util.types import AttributeValue
+
+if TYPE_CHECKING:
+    from opentelemetry.sdk.trace import TracerProvider
+    from ..client import LucidicAI
+
+logger = logging.getLogger("lucidicai.integrations.livekit")
+
+
+class LucidicLiveKitExporter(SpanExporter):
+    """Custom OpenTelemetry exporter for LiveKit voice agent spans.
+
+    Converts LiveKit spans (llm_node, function_tool) into Lucidic events
+    with full metadata including latency diagnostics, EOU detection,
+    and tool context.
+    """
+
+    # livekit span names we care about
+    LIVEKIT_LLM_SPANS = {"llm_node", "function_tool"}
+
+    def __init__(self, client: "LucidicAI", session_id: str):
+        """Initialize the exporter.
+
+        Args:
+            client: Initialized LucidicAI client instance
+            session_id: Session ID for all events created by this exporter
+        """
+        self._client = client
+        self._session_id = session_id
+        self._shutdown = False
+
+    def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
+        """Export spans to Lucidic as events.
+
+        Args:
+            spans: Sequence of completed OpenTelemetry spans
+
+        Returns:
+            SpanExportResult indicating success or failure
+        """
+        if self._shutdown:
+            return SpanExportResult.SUCCESS
+
+        try:
+            for span in spans:
+                if self._is_livekit_llm_span(span):
+                    self._process_span(span)
+            return SpanExportResult.SUCCESS
+        except Exception as e:
+            logger.error(f"[LiveKit] Failed to export spans: {e}")
+            return SpanExportResult.FAILURE
+
+    def _is_livekit_llm_span(self, span: ReadableSpan) -> bool:
+        """Check if span is a LiveKit LLM-related span we should process."""
+        return span.name in self.LIVEKIT_LLM_SPANS
+
+    def _process_span(self, span: ReadableSpan) -> None:
+        """Process a single LiveKit span and create corresponding Lucidic event."""
+        try:
+            if span.name == "llm_node":
+                event_data = self._convert_llm_span(span)
+                self._client.events.create(**event_data)
+                logger.debug(f"[LiveKit] Created llm_generation event for span {span.name}")
+            elif span.name == "function_tool":
+                event_data = self._convert_function_span(span)
+                self._client.events.create(**event_data)
+                logger.debug(f"[LiveKit] Created function_call event for span {span.name}")
+        except Exception as e:
+            logger.error(f"[LiveKit] Failed to process span {span.name}: {e}")
+
+    def _convert_llm_span(self, span: ReadableSpan) -> Dict[str, Any]:
+        """Convert an llm_node span to llm_generation event data."""
+        attrs = dict(span.attributes or {})
+
+        # extract messages from chat context
+        messages = self._parse_chat_context(attrs.get("lk.chat_ctx"))
+
+        # extract output text
+        output = attrs.get("lk.response.text", "")
+
+        # build metadata with diagnostics
+        metadata = self._build_metadata(attrs)
+
+        # calculate duration
+        duration = None
+        if span.start_time and span.end_time:
+            duration = (span.end_time - span.start_time) / 1e9
+
+        # extract timing for occurred_at
+        occurred_at = None
+        if span.start_time:
+            occurred_at = datetime.fromtimestamp(
+                span.start_time / 1e9, tz=timezone.utc
+            ).isoformat()
+
+        return {
+            "type": "llm_generation",
+            "session_id": self._session_id,
+            "model": attrs.get("gen_ai.request.model", "unknown"),
+            "messages": messages,
+            "output": output,
+            "input_tokens": attrs.get("gen_ai.usage.input_tokens"),
+            "output_tokens": attrs.get("gen_ai.usage.output_tokens"),
+            "duration": duration,
+            "occurred_at": occurred_at,
+            "metadata": metadata,
+        }
+
+    def _convert_function_span(self, span: ReadableSpan) -> Dict[str, Any]:
+        """Convert a function_tool span to function_call event data."""
+        attrs = dict(span.attributes or {})
+
+        # calculate duration
+        duration = None
+        if span.start_time and span.end_time:
+            duration = (span.end_time - span.start_time) / 1e9
+
+        # extract timing for occurred_at
+        occurred_at = None
+        if span.start_time:
+            occurred_at = datetime.fromtimestamp(
+                span.start_time / 1e9, tz=timezone.utc
+            ).isoformat()
+
+        # build metadata (subset for function calls)
+        metadata = {
+            "job_id": attrs.get("lk.job_id"),
+            "room_name": attrs.get("lk.room_name") or attrs.get("room_id"),
+            "agent_name": attrs.get("lk.agent_name"),
+            "generation_id": attrs.get("lk.generation_id"),
+            "tool_call_id": attrs.get("lk.function_tool.id"),
+        }
+        metadata = self._clean_none_values(metadata)
+
+        return {
+            "type": "function_call",
+            "session_id": self._session_id,
+            "function_name": attrs.get("lk.function_tool.name", "unknown"),
+            "arguments": attrs.get("lk.function_tool.arguments"),
+            "return_value": attrs.get("lk.function_tool.output"),
+            "duration": duration,
+            "occurred_at": occurred_at,
+            "metadata": metadata,
+        }
+
+    def _parse_chat_context(self, chat_ctx_json: Optional[str]) -> List[Dict[str, str]]:
+        """Parse LiveKit's lk.chat_ctx JSON into Lucidic messages format.
+
+        Args:
+            chat_ctx_json: JSON string of LiveKit chat context
+
+        Returns:
+            List of message dicts with role and content keys
+        """
+        if not chat_ctx_json:
+            return []
+
+        try:
+            chat_ctx = json.loads(chat_ctx_json)
+            messages = []
+
+            # livekit chat context has 'items' list
+            items = chat_ctx.get("items", [])
+            for item in items:
+                if item.get("type") == "message":
+                    role = item.get("role", "user")
+                    # livekit stores content in various ways
+                    content = item.get("text_content", "")
+                    if not content:
+                        # try content array
+                        content_list = item.get("content", [])
+                        if isinstance(content_list, list):
+                            text_parts = []
+                            for c in content_list:
+                                if isinstance(c, str):
+                                    text_parts.append(c)
+                                elif isinstance(c, dict) and c.get("type") == "text":
+                                    text_parts.append(c.get("text", ""))
+                            content = " ".join(text_parts)
+                        elif isinstance(content_list, str):
+                            content = content_list
+
+                    messages.append({"role": role, "content": content})
+
+            return messages
+        except (json.JSONDecodeError, TypeError) as e:
+            logger.debug(f"[LiveKit] Failed to parse chat context: {e}")
+            return []
+
+    def _build_metadata(self, attrs: Dict[str, Any]) -> Dict[str, Any]:
+        """Build metadata dict with diagnostics from span attributes.
+
+        Args:
+            attrs: Span attributes dictionary
+
+        Returns:
+            Cleaned metadata dict with nested diagnostics
+        """
+        metadata = {
+            # identity & tracking
+            "job_id": attrs.get("lk.job_id"),
+            "room_name": attrs.get("lk.room_name") or attrs.get("room_id"),
+            "agent_name": attrs.get("lk.agent_name"),
+            "participant_id": attrs.get("lk.participant_id"),
+            "generation_id": attrs.get("lk.generation_id"),
+            "parent_generation_id": attrs.get("lk.parent_generation_id"),
+            "speech_id": attrs.get("lk.speech_id"),
+            "interrupted": attrs.get("lk.interrupted"),
+            # diagnostics (nested)
+            "diagnostics": {
+                "latency": {
+                    "llm_ttft": attrs.get("llm_node_ttft"),
+                    "tts_ttfb": attrs.get("tts_node_ttfb"),
+                    "e2e_latency": attrs.get("e2e_latency"),
+                    "transcription_delay": attrs.get("lk.transcription_delay"),
+                    "end_of_turn_delay": attrs.get("lk.end_of_turn_delay"),
+                },
+                "eou": {
+                    "probability": attrs.get("lk.eou.probability"),
+                    "threshold": attrs.get("lk.eou.unlikely_threshold"),
+                    "delay": attrs.get("lk.eou.endpointing_delay"),
+                    "language": attrs.get("lk.eou.language"),
+                },
+                "tools": {
+                    "function_tools": attrs.get("lk.function_tools"),
+                    "provider_tools": attrs.get("lk.provider_tools"),
+                    "tool_sets": attrs.get("lk.tool_sets"),
+                },
+                "session_options": attrs.get("lk.session_options"),
+            },
+        }
+        return self._clean_none_values(metadata)
+
+    def _clean_none_values(self, d: Dict[str, Any]) -> Dict[str, Any]:
+        """Recursively remove None values and empty dicts.
+
+        Args:
+            d: Dictionary to clean
+
+        Returns:
+            Cleaned dictionary with no None values or empty nested dicts
+        """
+        cleaned = {}
+        for k, v in d.items():
+            if isinstance(v, dict):
+                nested = self._clean_none_values(v)
+                if nested:  # only include non-empty dicts
+                    cleaned[k] = nested
+            elif v is not None:
+                cleaned[k] = v
+        return cleaned
+
+    def shutdown(self) -> None:
+        """Shutdown the exporter."""
+        self._shutdown = True
+        logger.debug("[LiveKit] Exporter shutdown")
+
+    def force_flush(self, timeout_millis: int = 30000) -> bool:
+        """Force flush pending exports.
+
+        Returns:
+            True (events are created synchronously)
+        """
+        return True
+
+
+class _MetadataSpanProcessor(SpanProcessor):
+    """Span processor that adds metadata to all spans.
+
+    This allows users to attach custom metadata (e.g., customer_id, environment)
+    that will be included on every span exported.
+    """
+
+    def __init__(self, metadata: Dict[str, AttributeValue]):
+        """Initialize with metadata to attach.
+
+        Args:
+            metadata: Dictionary of metadata key-value pairs
+        """
+        self._metadata = metadata
+
+    def on_start(
+        self, span: Span, parent_context: Optional[otel_context.Context] = None
+    ) -> None:
+        """Called when a span is started - attach metadata."""
+        span.set_attributes(self._metadata)
+
+    def on_end(self, span: ReadableSpan) -> None:
+        """Called when a span ends - no action needed."""
+        pass
+
+    def shutdown(self) -> None:
+        """Shutdown the processor."""
+        pass
+
+    def force_flush(self, timeout_millis: int = 30000) -> bool:
+        """Force flush - no buffering in this processor."""
+        return True
+
+
+def setup_livekit(
+    client: "LucidicAI",
+    session_id: str,
+    session_name: Optional[str] = None,
+    metadata: Optional[Dict[str, AttributeValue]] = None,
+) -> "TracerProvider":
+    """Set up Lucidic tracing for LiveKit voice agents.
+
+    Automatically creates a Lucidic session and configures OpenTelemetry
+    to export LiveKit spans as Lucidic events.
+
+    Args:
+        client: Initialized LucidicAI client instance
+        session_id: Session ID for all events (typically ctx.room.name)
+        session_name: Optional human-readable session name
+        metadata: Optional metadata to attach to all spans (e.g., customer_id)
+
+    Returns:
+        TracerProvider to pass to livekit's set_tracer_provider()
+
+    Example:
+        from lucidicai import LucidicAI
+        from lucidicai.integrations.livekit import setup_livekit
+        from livekit.agents import AgentServer, JobContext, AgentSession, cli
+        from livekit.agents.telemetry import set_tracer_provider
+
+        client = LucidicAI(api_key="...", agent_id="...")
+        server = AgentServer()
+
+        @server.rtc_session()
+        async def entrypoint(ctx: JobContext):
+            trace_provider = setup_livekit(
+                client=client,
+                session_id=ctx.room.name,
+                session_name=f"Voice Call - {ctx.room.name}",
+            )
+            set_tracer_provider(trace_provider)
+
+            async def cleanup():
+                trace_provider.force_flush()
+            ctx.add_shutdown_callback(cleanup)
+
+            session = AgentSession(...)
+            await session.start(agent=MyAgent(), room=ctx.room)
+
+        if __name__ == "__main__":
+            cli.run_app(server)
+    """
+    from opentelemetry.sdk.trace import TracerProvider
+    from opentelemetry.sdk.trace.export import BatchSpanProcessor
+
+    # auto-create Lucidic session
+    client.sessions.create(
+        session_id=session_id,
+        session_name=session_name or f"LiveKit Voice Session - {session_id}",
+    )
+    logger.info(f"[LiveKit] Created Lucidic session: {session_id}")
+
+    # create exporter
+    exporter = LucidicLiveKitExporter(client, session_id)
+
+    # create tracer provider
+    trace_provider = TracerProvider()
+
+    # add metadata processor if metadata provided
+    if metadata:
+        trace_provider.add_span_processor(_MetadataSpanProcessor(metadata))
+
+    # add exporter via batch processor
+    trace_provider.add_span_processor(BatchSpanProcessor(exporter))
+
+    logger.info("[LiveKit] Lucidic tracing configured")
+    return trace_provider

{lucidicai-3.1.1.dist-info → lucidicai-3.3.0.dist-info}/METADATA

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

{lucidicai-3.1.1.dist-info → lucidicai-3.3.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
-lucidicai/__init__.py,sha256=83k3iIyPlLhhZ_fRyy54x4Ry9WbRhNTK1bczhvHSj_A,1180
+lucidicai/__init__.py,sha256=gdk3Y-cq-RaTbhBcBE77saBwHSbIvqaScU9gNoTi7_g,1284
 lucidicai/action.py,sha256=sPRd1hTIVXDqnvG9ZXWEipUFh0bsXcE0Fm7RVqmVccM,237
-lucidicai/client.py,sha256=WnkUeo_Z0uP4xh66gNC6MJhYdyhRpjC61OBjHEJLHq4,14674
+lucidicai/client.py,sha256=LC9KPhZgTnt5klntHoyCQWWpRUE-X58lM80uAaWBNiU,15090
 lucidicai/constants.py,sha256=zN8O7TjoRHRlaGa9CZUWppS73rhzKGwaEkF9XMTV0Cg,1160
 lucidicai/context.py,sha256=ruEXAndSv0gQ-YEXLlC4Fx6NNbaylfp_dZxbpwmLZSA,4622
 lucidicai/dataset.py,sha256=wu25X02JyWkht_yQabgQpGZFfzbNTxG6tf5k9ol8Amo,4005
@@ -29,9 +29,11 @@ lucidicai/api/resources/feature_flag.py,sha256=ii412DIkZCEAhrXdGydcpQKveqGlFq4Nl
 lucidicai/api/resources/prompt.py,sha256=tdMVTaLc3DDRbd_R8Xd5mkvpdwQONfr8OwkJRTE0atE,2495
 lucidicai/api/resources/session.py,sha256=jW_bftHdunhLHl_3-k0nqB5FrtLhlFeCF0tMFE82nNw,20761
 lucidicai/core/__init__.py,sha256=b0YQkd8190Y_GgwUcmf0tOiSLARd7L4kq4jwfhhGAyI,39
-lucidicai/core/config.py,sha256=06XZPOCpB8YY9nzqt7deR3CP6MAQIKCTZYdSzscAPDY,8730
+lucidicai/core/config.py,sha256=q4h-yR35Ay_3znL7vavri6ScfeM69RjHShNNzjoQthc,10194
 lucidicai/core/errors.py,sha256=bYSRPqadXUCPadVLb-2fj63CB6jlAnfDeu2azHB2z8M,2137
 lucidicai/core/types.py,sha256=KabcTBQe7SemigccKfJSDiJmjSJDJJvvtefSd8pfrJI,702
+lucidicai/integrations/__init__.py,sha256=9eJxdcw9C_zLXLQGdKK-uwCYhjdnEelrXbYYNo48ewk,292
+lucidicai/integrations/livekit.py,sha256=vcP55JFTmBJtpSP6MCnQ94WQdbR221VZFwvXxs3oOq8,15036
 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
@@ -91,7 +93,7 @@ lucidicai/utils/images.py,sha256=z8mlIKgFfrIbuk-l4L2rB62uw_uPO79sHPXPY7eLu2A,128
 lucidicai/utils/logger.py,sha256=R3B3gSee64F6UVHUrShihBq_O7W7bgfrBiVDXTO3Isg,4777
 lucidicai/utils/queue.py,sha256=8DQwnGw7pINEJ0dNSkB0PhdPW-iBQQ-YZg23poe4umE,17323
 lucidicai/utils/serialization.py,sha256=KdOREZd7XBxFBAZ86DePMfYPzSVyKr4RcgUa82aFxrs,820
-lucidicai-3.1.1.dist-info/METADATA,sha256=OCfPUqhEyRmBCQWTOoKUwbw3hR7T6JNZY9XtxyUbXxE,902
-lucidicai-3.1.1.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
-lucidicai-3.1.1.dist-info/top_level.txt,sha256=vSSdM3lclF4I5tyVC0xxUk8eIRnnYXMe1hW-eO91HUo,10
-lucidicai-3.1.1.dist-info/RECORD,,
+lucidicai-3.3.0.dist-info/METADATA,sha256=p8D3cXfEzfEC4HnYYz68keBQwzNDOkSqifh8H13m1t4,902
+lucidicai-3.3.0.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
+lucidicai-3.3.0.dist-info/top_level.txt,sha256=vSSdM3lclF4I5tyVC0xxUk8eIRnnYXMe1hW-eO91HUo,10
+lucidicai-3.3.0.dist-info/RECORD,,