lucidicai 3.4.1__py3-none-any.whl → 3.4.3__py3-none-any.whl

lucidicai/__init__.py

@@ -41,7 +41,7 @@ from .api.resources.prompt import Prompt
 from .integrations.livekit import setup_livekit
 
 # Version
-__version__ = "3.4.1"
+__version__ = "3.4.3"
 
 # All exports
 __all__ = [

lucidicai/api/client.py

@@ -207,6 +207,19 @@ class HttpClient:
         data = self._add_timestamp(data)
         return self.request("PUT", endpoint, json=data)
     
+    def patch(self, endpoint: str, data: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Make a synchronous PATCH request.
+
+        Args:
+            endpoint: API endpoint (without base URL)
+            data: Request body data
+
+        Returns:
+            Response data as dictionary
+        """
+        data = self._add_timestamp(data)
+        return self.request("PATCH", endpoint, json=data)
+
     def delete(self, endpoint: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
         """Make a synchronous DELETE request.
         
@@ -301,6 +314,19 @@ class HttpClient:
         data = self._add_timestamp(data)
         return await self.arequest("PUT", endpoint, json=data)
     
+    async def apatch(self, endpoint: str, data: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Make an asynchronous PATCH request.
+
+        Args:
+            endpoint: API endpoint (without base URL)
+            data: Request body data
+
+        Returns:
+            Response data as dictionary
+        """
+        data = self._add_timestamp(data)
+        return await self.arequest("PATCH", endpoint, json=data)
+
     async def adelete(self, endpoint: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
         """Make an asynchronous DELETE request.
         

lucidicai/api/resources/prompt.py

@@ -2,7 +2,7 @@
 import logging
 import time
 from dataclasses import dataclass
-from typing import Any, Dict, Optional, Tuple, TYPE_CHECKING
+from typing import Any, Dict, List, Optional, Tuple, TYPE_CHECKING
 
 from ..client import HttpClient
 
@@ -58,6 +58,21 @@ class PromptResource:
         self._production = production
         self._cache: Dict[Tuple[str, str], Dict[str, Any]] = {}
 
+    def _invalidate_cache(self, prompt_name: str, label: Optional[str] = None) -> None:
+        """Invalidate cached prompt entries.
+
+        Args:
+            prompt_name: Name of the prompt to invalidate.
+            label: If provided, only invalidate the specific (prompt_name, label) entry.
+                   If None, invalidate all entries matching prompt_name.
+        """
+        if label is not None:
+            self._cache.pop((prompt_name, label), None)
+        else:
+            keys_to_remove = [k for k in self._cache if k[0] == prompt_name]
+            for k in keys_to_remove:
+                del self._cache[k]
+
     def _is_cache_valid(self, cache_key: Tuple[str, str], cache_ttl: int) -> bool:
         """Check if a cached prompt is still valid.
 
@@ -106,7 +121,7 @@ class PromptResource:
                 metadata = self._cache[cache_key]["metadata"]
             else:
                 response = self.http.get(
-                    "getprompt",
+                    "sdk/prompts",
                     {"prompt_name": prompt_name, "label": label, "agent_id": self._config.agent_id},
                 )
                 raw_content = response.get("prompt_content", "")
@@ -150,7 +165,7 @@ class PromptResource:
                 metadata = self._cache[cache_key]["metadata"]
             else:
                 response = await self.http.aget(
-                    "getprompt",
+                    "sdk/prompts",
                     {"prompt_name": prompt_name, "label": label, "agent_id": self._config.agent_id},
                 )
                 raw_content = response.get("prompt_content", "")
@@ -173,3 +188,155 @@ class PromptResource:
                 logger.error(f"[PromptResource] Failed to get prompt: {e}")
                 return Prompt(raw_content="", content="", metadata={})
             raise
+
+    def update(
+        self,
+        prompt_name: str,
+        prompt_content: str,
+        description: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        labels: Optional[List[str]] = None,
+    ) -> Prompt:
+        """Update a prompt, creating a new immutable version.
+
+        Args:
+            prompt_name: Name of the prompt to update.
+            prompt_content: New content for the prompt.
+            description: Optional description for the prompt version.
+            metadata: Optional metadata dict to attach to the prompt version.
+            labels: Optional list of labels to assign to the new version.
+
+        Returns:
+            A Prompt object with the new content and metadata from the response.
+        """
+        try:
+            body: Dict[str, Any] = {
+                "agent_id": self._config.agent_id,
+                "prompt_name": prompt_name,
+                "prompt_content": prompt_content,
+            }
+            if description is not None:
+                body["description"] = description
+            if metadata is not None:
+                body["metadata"] = metadata
+            if labels is not None:
+                body["labels"] = labels
+
+            response = self.http.put("sdk/prompts", data=body)
+            response_metadata = response.get("metadata", {})
+
+            self._invalidate_cache(prompt_name)
+
+            return Prompt(raw_content=prompt_content, content=prompt_content, metadata=response_metadata)
+        except Exception as e:
+            if self._production:
+                logger.error(f"[PromptResource] Failed to update prompt: {e}")
+                return Prompt(raw_content="", content="", metadata={})
+            raise
+
+    async def aupdate(
+        self,
+        prompt_name: str,
+        prompt_content: str,
+        description: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        labels: Optional[List[str]] = None,
+    ) -> Prompt:
+        """Update a prompt, creating a new immutable version (asynchronous).
+
+        See update() for full documentation.
+        """
+        try:
+            body: Dict[str, Any] = {
+                "agent_id": self._config.agent_id,
+                "prompt_name": prompt_name,
+                "prompt_content": prompt_content,
+            }
+            if description is not None:
+                body["description"] = description
+            if metadata is not None:
+                body["metadata"] = metadata
+            if labels is not None:
+                body["labels"] = labels
+
+            response = await self.http.aput("sdk/prompts", data=body)
+            response_metadata = response.get("metadata", {})
+
+            self._invalidate_cache(prompt_name)
+
+            return Prompt(raw_content=prompt_content, content=prompt_content, metadata=response_metadata)
+        except Exception as e:
+            if self._production:
+                logger.error(f"[PromptResource] Failed to update prompt: {e}")
+                return Prompt(raw_content="", content="", metadata={})
+            raise
+
+    def update_metadata(
+        self,
+        prompt_name: str,
+        label: str,
+        metadata: Dict[str, Any],
+    ) -> Prompt:
+        """Update metadata on an existing prompt version.
+
+        Sends a PATCH request to update only the metadata for the prompt version
+        identified by (prompt_name, label). The prompt content is not returned
+        by this endpoint, so the returned Prompt will have empty content fields.
+
+        Args:
+            prompt_name: Name of the prompt.
+            label: Label identifying the prompt version to update.
+            metadata: Metadata dict to set on the prompt version.
+
+        Returns:
+            A Prompt object with empty content and the updated metadata.
+        """
+        try:
+            body: Dict[str, Any] = {
+                "agent_id": self._config.agent_id,
+                "prompt_name": prompt_name,
+                "label": label,
+                "metadata": metadata,
+            }
+
+            response = self.http.patch("sdk/prompts", data=body)
+            response_metadata = response.get("metadata", {})
+
+            self._invalidate_cache(prompt_name, label)
+
+            return Prompt(raw_content="", content="", metadata=response_metadata)
+        except Exception as e:
+            if self._production:
+                logger.error(f"[PromptResource] Failed to update prompt metadata: {e}")
+                return Prompt(raw_content="", content="", metadata={})
+            raise
+
+    async def aupdate_metadata(
+        self,
+        prompt_name: str,
+        label: str,
+        metadata: Dict[str, Any],
+    ) -> Prompt:
+        """Update metadata on an existing prompt version (asynchronous).
+
+        See update_metadata() for full documentation.
+        """
+        try:
+            body: Dict[str, Any] = {
+                "agent_id": self._config.agent_id,
+                "prompt_name": prompt_name,
+                "label": label,
+                "metadata": metadata,
+            }
+
+            response = await self.http.apatch("sdk/prompts", data=body)
+            response_metadata = response.get("metadata", {})
+
+            self._invalidate_cache(prompt_name, label)
+
+            return Prompt(raw_content="", content="", metadata=response_metadata)
+        except Exception as e:
+            if self._production:
+                logger.error(f"[PromptResource] Failed to update prompt metadata: {e}")
+                return Prompt(raw_content="", content="", metadata={})
+            raise

lucidicai/integrations/livekit.py

@@ -40,19 +40,37 @@ if TYPE_CHECKING:
     from opentelemetry.sdk.trace import TracerProvider
     from ..client import LucidicAI
 
+from ..telemetry.utils.model_pricing import calculate_cost
+from ..telemetry.utils.provider import detect_provider
+
 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.
+    Converts LiveKit spans into Lucidic events:
+    - llm_request spans -> llm_generation events (with model, tokens, messages, output)
+    - function_tool spans -> function_call events (with name, arguments, return value)
+
+    The llm_request span contains:
+    - gen_ai.request.model: Model name
+    - gen_ai.usage.input_tokens / gen_ai.usage.output_tokens: Token counts
+    - lk.llm_metrics: JSON with ttft, duration, tokens_per_second, metadata
+    - GenAI events: gen_ai.system.message, gen_ai.user.message, gen_ai.assistant.message,
+      gen_ai.tool.message (inputs), gen_ai.choice (output with optional tool_calls)
+
+    The function_tool span contains:
+    - lk.function_tool.id: Tool call ID
+    - lk.function_tool.name: Function name
+    - lk.function_tool.arguments: JSON arguments
+    - lk.function_tool.output: Return value
+    - lk.function_tool.is_error: Error flag
     """
 
     # livekit span names we care about
-    LIVEKIT_LLM_SPANS = {"llm_node", "function_tool"}
+    # note: llm_request has model/provider/tokens, llm_node is parent without these
+    LIVEKIT_LLM_SPANS = {"llm_request", "function_tool"}
 
     def __init__(self, client: "LucidicAI", session_id: str):
         """Initialize the exporter.
@@ -90,10 +108,150 @@ class LucidicLiveKitExporter(SpanExporter):
         """Check if span is a LiveKit LLM-related span we should process."""
         return span.name in self.LIVEKIT_LLM_SPANS
 
+    def _parse_llm_metrics(self, attrs: Dict[str, Any]) -> Dict[str, Any]:
+        """Parse lk.llm_metrics JSON to extract provider, model, and timing info.
+
+        Args:
+            attrs: Span attributes dictionary
+
+        Returns:
+            Dict with 'provider', 'model', 'ttft', 'tokens_per_second' keys if found
+        """
+        llm_metrics_json = attrs.get("lk.llm_metrics")
+        if not llm_metrics_json:
+            return {}
+
+        try:
+            if isinstance(llm_metrics_json, str):
+                metrics = json.loads(llm_metrics_json)
+            else:
+                metrics = llm_metrics_json
+
+            result = {}
+            metadata = metrics.get("metadata", {})
+
+            if metadata.get("model_provider"):
+                result["provider"] = metadata["model_provider"]
+            if metadata.get("model_name"):
+                result["model"] = metadata["model_name"]
+
+            # extract timing and performance metrics
+            if metrics.get("ttft") is not None:
+                result["ttft"] = metrics["ttft"]
+            if metrics.get("duration") is not None:
+                result["duration"] = metrics["duration"]
+            if metrics.get("tokens_per_second") is not None:
+                result["tokens_per_second"] = metrics["tokens_per_second"]
+            if metrics.get("cancelled") is not None:
+                result["cancelled"] = metrics["cancelled"]
+
+            return result
+        except (json.JSONDecodeError, TypeError) as e:
+            logger.debug(f"[LiveKit] Failed to parse llm_metrics: {e}")
+            return {}
+
+    def _parse_span_events(self, span: ReadableSpan) -> tuple[List[Dict[str, Any]], str, List[Dict[str, Any]]]:
+        """Parse span events to extract messages, output, and tool calls.
+
+        llm_request spans have GenAI events:
+        - gen_ai.system.message, gen_ai.user.message, gen_ai.assistant.message (input)
+        - gen_ai.tool.message (tool output)
+        - gen_ai.choice (output/completion with optional tool_calls)
+
+        Args:
+            span: The OpenTelemetry span
+
+        Returns:
+            Tuple of (messages list, output string, tool_calls list)
+        """
+        messages: List[Dict[str, Any]] = []
+        output = ""
+        tool_calls: List[Dict[str, Any]] = []
+
+        # map event names to roles
+        event_to_role = {
+            "gen_ai.system.message": "system",
+            "gen_ai.user.message": "user",
+            "gen_ai.assistant.message": "assistant",
+            "gen_ai.tool.message": "tool",
+        }
+
+        if not span.events:
+            return messages, output, tool_calls
+
+        for event in span.events:
+            event_name = event.name
+            event_attrs = dict(event.attributes or {})
+
+            if event_name in event_to_role:
+                # message event
+                role = event_to_role[event_name]
+                msg: Dict[str, Any] = {"role": role}
+
+                content = event_attrs.get("content", "")
+                if content:
+                    msg["content"] = content
+
+                # handle tool_calls in assistant messages (input tool calls)
+                if event_name == "gen_ai.assistant.message" and "tool_calls" in event_attrs:
+                    msg["tool_calls"] = self._parse_tool_calls(event_attrs["tool_calls"])
+
+                # handle tool message metadata
+                if event_name == "gen_ai.tool.message":
+                    if "name" in event_attrs:
+                        msg["name"] = event_attrs["name"]
+                    if "id" in event_attrs:
+                        msg["tool_call_id"] = event_attrs["id"]
+
+                messages.append(msg)
+
+            elif event_name == "gen_ai.choice":
+                # completion/output event
+                content = event_attrs.get("content", "")
+                if content:
+                    output = content
+
+                # extract tool_calls from completion if present
+                if "tool_calls" in event_attrs:
+                    tool_calls = self._parse_tool_calls(event_attrs["tool_calls"])
+
+        return messages, output, tool_calls
+
+    def _parse_tool_calls(self, tool_calls_attr: Any) -> List[Dict[str, Any]]:
+        """Parse tool_calls attribute from GenAI events.
+
+        Tool calls are stored as a list of JSON strings.
+
+        Args:
+            tool_calls_attr: The tool_calls attribute value (list of JSON strings)
+
+        Returns:
+            List of parsed tool call dicts
+        """
+        if not tool_calls_attr:
+            return []
+
+        parsed = []
+        try:
+            # tool_calls is a list of JSON strings
+            if isinstance(tool_calls_attr, (list, tuple)):
+                for tc in tool_calls_attr:
+                    if isinstance(tc, str):
+                        parsed.append(json.loads(tc))
+                    elif isinstance(tc, dict):
+                        parsed.append(tc)
+            elif isinstance(tool_calls_attr, str):
+                # single JSON string
+                parsed.append(json.loads(tool_calls_attr))
+        except (json.JSONDecodeError, TypeError) as e:
+            logger.debug(f"[LiveKit] Failed to parse tool_calls: {e}")
+
+        return parsed
+
     def _process_span(self, span: ReadableSpan) -> None:
         """Process a single LiveKit span and create corresponding Lucidic event."""
         try:
-            if span.name == "llm_node":
+            if span.name == "llm_request":
                 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}")
@@ -105,21 +263,48 @@ class LucidicLiveKitExporter(SpanExporter):
             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."""
+        """Convert an llm_request 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"))
+        # parse lk.llm_metrics for provider/model/timing
+        llm_info = self._parse_llm_metrics(attrs)
 
-        # extract output text
-        output = attrs.get("lk.response.text", "")
+        # extract model (gen_ai attribute takes precedence, fallback to metrics)
+        model = attrs.get("gen_ai.request.model") or llm_info.get("model") or "unknown"
 
-        # build metadata with diagnostics
-        metadata = self._build_metadata(attrs)
+        # extract provider (from metrics first, then detect from model)
+        provider = llm_info.get("provider") or detect_provider(model=model, attributes=attrs)
 
-        # calculate duration
-        duration = None
-        if span.start_time and span.end_time:
+        # extract messages, output, and tool_calls from span events (llm_request uses GenAI events)
+        messages, output, tool_calls = self._parse_span_events(span)
+
+        # fallback to lk.chat_ctx if no events (backwards compatibility)
+        if not messages:
+            messages = self._parse_chat_context(attrs.get("lk.chat_ctx"))
+
+        # fallback to lk.response.text if no output from events
+        if not output:
+            output = attrs.get("lk.response.text", "")
+
+        # extract token counts
+        input_tokens = attrs.get("gen_ai.usage.input_tokens")
+        output_tokens = attrs.get("gen_ai.usage.output_tokens")
+
+        # calculate cost using existing pricing utility
+        cost = None
+        if input_tokens is not None and output_tokens is not None:
+            token_usage = {
+                "input_tokens": input_tokens,
+                "output_tokens": output_tokens,
+            }
+            cost = calculate_cost(model, token_usage)
+
+        # build metadata with diagnostics from llm_metrics
+        metadata = self._build_llm_metadata(attrs, llm_info)
+
+        # calculate duration (prefer from metrics, fallback to span timing)
+        duration = llm_info.get("duration")
+        if duration is None and span.start_time and span.end_time:
             duration = (span.end_time - span.start_time) / 1e9
 
         # extract timing for occurred_at
@@ -129,19 +314,27 @@ class LucidicLiveKitExporter(SpanExporter):
                 span.start_time / 1e9, tz=timezone.utc
             ).isoformat()
 
-        return {
+        result: Dict[str, Any] = {
             "type": "llm_generation",
             "session_id": self._session_id,
-            "model": attrs.get("gen_ai.request.model", "unknown"),
+            "provider": provider,
+            "model": model,
             "messages": messages,
             "output": output,
-            "input_tokens": attrs.get("gen_ai.usage.input_tokens"),
-            "output_tokens": attrs.get("gen_ai.usage.output_tokens"),
+            "input_tokens": input_tokens,
+            "output_tokens": output_tokens,
+            "cost": cost,
             "duration": duration,
             "occurred_at": occurred_at,
             "metadata": metadata,
         }
 
+        # include tool_calls if present (LLM requested function calls)
+        if tool_calls:
+            result["tool_calls"] = tool_calls
+
+        return result
+
     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 {})
@@ -158,17 +351,16 @@ class LucidicLiveKitExporter(SpanExporter):
                 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)
+        # extract function call details (these are the attributes actually on function_tool span)
+        tool_call_id = attrs.get("lk.function_tool.id")
+        is_error = attrs.get("lk.function_tool.is_error", False)
 
-        return {
+        # build metadata with tool call id
+        metadata: Dict[str, Any] = {}
+        if tool_call_id:
+            metadata["tool_call_id"] = tool_call_id
+
+        result: Dict[str, Any] = {
             "type": "function_call",
             "session_id": self._session_id,
             "function_name": attrs.get("lk.function_tool.name", "unknown"),
@@ -176,9 +368,17 @@ class LucidicLiveKitExporter(SpanExporter):
             "return_value": attrs.get("lk.function_tool.output"),
             "duration": duration,
             "occurred_at": occurred_at,
-            "metadata": metadata,
         }
 
+        # include is_error flag if the tool execution failed
+        if is_error:
+            result["is_error"] = True
+
+        if metadata:
+            result["metadata"] = metadata
+
+        return result
+
     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.
 
@@ -223,49 +423,61 @@ class LucidicLiveKitExporter(SpanExporter):
             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.
+    def _build_llm_metadata(self, attrs: Dict[str, Any], llm_info: Dict[str, Any]) -> Dict[str, Any]:
+        """Build metadata dict with diagnostics from llm_request span attributes.
+
+        Note: llm_request spans have limited attributes. Most metadata (job_id, room_name,
+        generation_id, etc.) are on parent spans (agent_session, agent_turn) and are only
+        available if a MetadataSpanProcessor propagates them.
 
         Args:
             attrs: Span attributes dictionary
+            llm_info: Parsed lk.llm_metrics data
 
         Returns:
-            Cleaned metadata dict with nested diagnostics
+            Cleaned metadata dict with available 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"),
-            },
+        metadata: Dict[str, Any] = {}
+
+        # timing metrics from lk.llm_metrics (actually available on llm_request)
+        if llm_info.get("ttft") is not None:
+            metadata["ttft"] = llm_info["ttft"]
+        if llm_info.get("tokens_per_second") is not None:
+            metadata["tokens_per_second"] = llm_info["tokens_per_second"]
+        if llm_info.get("cancelled"):
+            metadata["cancelled"] = llm_info["cancelled"]
+
+        # retry count if available (set on llm_request_run, may be propagated)
+        retry_count = attrs.get("lk.retry_count")
+        if retry_count is not None and retry_count > 0:
+            metadata["retry_count"] = retry_count
+
+        # attributes that may be available via MetadataSpanProcessor
+        # (set by user or propagated from parent spans)
+        optional_attrs = {
+            "job_id": "lk.job_id",
+            "room_name": "lk.room_name",
+            "room_id": "room_id",
+            "agent_name": "lk.agent_name",
+            "participant_id": "lk.participant_id",
+            "generation_id": "lk.generation_id",
+            "parent_generation_id": "lk.parent_generation_id",
+            "speech_id": "lk.speech_id",
+            "interrupted": "lk.interrupted",
         }
-        return self._clean_none_values(metadata)
+
+        for key, attr_name in optional_attrs.items():
+            value = attrs.get(attr_name)
+            if value is not None:
+                metadata[key] = value
+
+        # prefer room_name over room_id
+        if "room_id" in metadata and "room_name" not in metadata:
+            metadata["room_name"] = metadata.pop("room_id")
+        elif "room_id" in metadata:
+            del metadata["room_id"]
+
+        return metadata
 
     def _clean_none_values(self, d: Dict[str, Any]) -> Dict[str, Any]:
         """Recursively remove None values and empty dicts.

lucidicai/telemetry/utils/model_pricing.py

@@ -92,8 +92,8 @@ MODEL_PRICING = {
     # Google Gemini 2.5 Series (2025) - Verified
     "gemini-2.5-pro": {"input": 1.25, "output": 10.0},  # Up to 200k tokens
     "gemini-2.5-pro-preview": {"input": 1.25, "output": 10.0},
-    "gemini-2.5-flash": {"input": 0.15, "output": 0.6},  # Non-thinking
-    "gemini-2.5-flash-preview": {"input": 0.15, "output": 0.6},
+    "gemini-2.5-flash": {"input": 0.30, "output": 2.5},  # Non-thinking
+    "gemini-2.5-flash-preview": {"input": 0.30, "output": 2.5},
     
     # Google Gemini 2.0 Series - Verified
     "gemini-2.0-flash": {"input": 0.1, "output": 0.4},

{lucidicai-3.4.1.dist-info → lucidicai-3.4.3.dist-info}/METADATA

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

{lucidicai-3.4.1.dist-info → lucidicai-3.4.3.dist-info}/RECORD

@@ -1,4 +1,4 @@
-lucidicai/__init__.py,sha256=d0jiR0fpY1JbmHuczLu7sni-Qk9zZXe5M8zHxURe4RA,1376
+lucidicai/__init__.py,sha256=Qc3hC7-4pxHthUdGnIKdlrJ8Sxrou8yvCo17FUFPb7M,1376
 lucidicai/action.py,sha256=sPRd1hTIVXDqnvG9ZXWEipUFh0bsXcE0Fm7RVqmVccM,237
 lucidicai/client.py,sha256=BGKP91_Oj5kHQU0osYf1T_BWakL8KIhs0AgUc5X99sU,15104
 lucidicai/constants.py,sha256=zN8O7TjoRHRlaGa9CZUWppS73rhzKGwaEkF9XMTV0Cg,1160
@@ -19,21 +19,21 @@ 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=0Ia5cXo5OKifhP-63TPAWPuy2bWCzR9VN4BpWIMo34w,13212
+lucidicai/api/client.py,sha256=T3EIDReCsHQ4vqgwKdsVxZ0gz_XrFQLIoJNhS7lhRuo,14054
 lucidicai/api/resources/__init__.py,sha256=DDgviDW3Su-G1ofkZGlaJMc2pzYJqrbBnEruNg1whCM,416
 lucidicai/api/resources/dataset.py,sha256=I6g9ah4vaqEH1jyeouBn7xvC0oAuDNPeyl-bmtNj-T0,17400
 lucidicai/api/resources/evals.py,sha256=_3nLE6dMLht844mWw7kl_hctjv5JIuC6MP06YWUgLnI,7235
 lucidicai/api/resources/event.py,sha256=GTIU5sIbLNTWAHk4rB120xWTRkhnraz9JNfamEygyNo,14267
 lucidicai/api/resources/experiment.py,sha256=fOIKJ5d89bHJBVZ3wjbhY_6XF3kLHz9TE3BVPA5pNpA,3563
 lucidicai/api/resources/feature_flag.py,sha256=ii412DIkZCEAhrXdGydcpQKveqGlFq4NlgdmWQnU83c,2259
-lucidicai/api/resources/prompt.py,sha256=M2ZovMX74-ULksMXzXPXVgBziRcTcmz40GnDcJx30Q0,6053
+lucidicai/api/resources/prompt.py,sha256=kddb9X05om9xbWBLjUGoCFEsao-J-vyqjn_RzZIyht0,12278
 lucidicai/api/resources/session.py,sha256=jW_bftHdunhLHl_3-k0nqB5FrtLhlFeCF0tMFE82nNw,20761
 lucidicai/core/__init__.py,sha256=b0YQkd8190Y_GgwUcmf0tOiSLARd7L4kq4jwfhhGAyI,39
 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/integrations/livekit.py,sha256=DduLEDvc2rjHUBNhmvSovCthXSZuBOLCDSD1dZ6BxjA,23140
 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
@@ -84,7 +84,7 @@ lucidicai/telemetry/telemetry_init.py,sha256=YpjcYDcqlWpUDDz76-x2v4K0yz_ToEpuaDz
 lucidicai/telemetry/telemetry_manager.py,sha256=XiNv-etC6ZRMyYav0v8HqURD2PGaXbwlY0O86lxfWIk,6587
 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=_5izJRMS1moJNccO-N3pxv3VDWUiq9LVgDwZK4LHn9M,11897
+lucidicai/telemetry/utils/model_pricing.py,sha256=kqQh8-rO_XW3c8WvPrGgUmYdhGIm1M0psUaAYt5BYYo,11897
 lucidicai/telemetry/utils/provider.py,sha256=Ca6C7n4TGTLfnRgC1f7zr_-aZfg87vCjEjRJkMJyFwE,2682
 lucidicai/telemetry/utils/text_storage.py,sha256=L62MMJ8E23TDqDTUv2aRntdKMCItsXV7XjY6cFwx2DE,1503
 lucidicai/telemetry/utils/universal_image_interceptor.py,sha256=vARgMk1hVSF--zfi5b8qBpJJOESuD17YlH9xqxmB9Uw,15954
@@ -93,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.4.1.dist-info/METADATA,sha256=oPV8Sh8GPs876yl42Vk7ZyAe2HyD8NW9K_jxO1p8kf4,902
-lucidicai-3.4.1.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
-lucidicai-3.4.1.dist-info/top_level.txt,sha256=vSSdM3lclF4I5tyVC0xxUk8eIRnnYXMe1hW-eO91HUo,10
-lucidicai-3.4.1.dist-info/RECORD,,
+lucidicai-3.4.3.dist-info/METADATA,sha256=9HOARc8RzOxYwhidKz27iaG3i3RTD92XQAbI4vTe72A,902
+lucidicai-3.4.3.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
+lucidicai-3.4.3.dist-info/top_level.txt,sha256=vSSdM3lclF4I5tyVC0xxUk8eIRnnYXMe1hW-eO91HUo,10
+lucidicai-3.4.3.dist-info/RECORD,,