lmnr 0.7.1__py3-none-any.whl → 0.7.3__py3-none-any.whl

lmnr/__init__.py

@@ -3,6 +3,7 @@ from .sdk.client.asynchronous.async_client import AsyncLaminarClient
 from .sdk.datasets import EvaluationDataset, LaminarDataset
 from .sdk.evaluations import evaluate
 from .sdk.laminar import Laminar
+from .sdk.types import SessionRecordingOptions, MaskInputOptions
 from .sdk.types import (
     AgentOutput,
     FinalOutputChunkContent,
@@ -38,4 +39,6 @@ __all__ = [
     "get_tracer",
     "evaluate",
     "observe",
+    "SessionRecordingOptions",
+    "MaskInputOptions",
 ]

lmnr/opentelemetry_lib/__init__.py

@@ -6,6 +6,7 @@ from opentelemetry.sdk.resources import SERVICE_NAME
 
 from lmnr.opentelemetry_lib.tracing.instruments import Instruments
 from lmnr.opentelemetry_lib.tracing import TracerWrapper
+from lmnr.sdk.types import SessionRecordingOptions
 
 MAX_MANUAL_SPAN_PAYLOAD_SIZE = 1024 * 1024 * 10  # 10MB
 
@@ -30,6 +31,7 @@ class TracerManager:
         timeout_seconds: int = 30,
         set_global_tracer_provider: bool = True,
         otel_logger_level: int = logging.ERROR,
+        session_recording_options: SessionRecordingOptions | None = None,
     ) -> None:
         enable_content_tracing = True
 
@@ -50,6 +52,7 @@ class TracerManager:
             timeout_seconds=timeout_seconds,
             set_global_tracer_provider=set_global_tracer_provider,
             otel_logger_level=otel_logger_level,
+            session_recording_options=session_recording_options,
         )
 
     @staticmethod

lmnr/opentelemetry_lib/opentelemetry/instrumentation/anthropic/__init__.py

@@ -29,6 +29,10 @@ from .utils import (
     shared_metrics_attributes,
     should_emit_events,
 )
+from .streaming import (
+    WrappedAsyncMessageStreamManager,
+    WrappedMessageStreamManager,
+)
 from .version import __version__
 
 from lmnr.opentelemetry_lib.tracing.context import get_current_context
@@ -52,6 +56,7 @@ logger = logging.getLogger(__name__)
 
 _instruments = ("anthropic >= 0.3.11",)
 
+
 WRAPPED_METHODS = [
     {
         "package": "anthropic.resources.completions",
@@ -71,6 +76,15 @@ WRAPPED_METHODS = [
         "method": "stream",
         "span_name": "anthropic.chat",
     },
+    # This method is on an async resource, but is meant to be called as
+    # an async context manager (async with), which we don't need to await;
+    # thus, we wrap it with a sync wrapper
+    {
+        "package": "anthropic.resources.messages",
+        "object": "AsyncMessages",
+        "method": "stream",
+        "span_name": "anthropic.chat",
+    },
 ]
 
 WRAPPED_AMETHODS = [
@@ -86,12 +100,6 @@ WRAPPED_AMETHODS = [
         "method": "create",
         "span_name": "anthropic.chat",
     },
-    {
-        "package": "anthropic.resources.messages",
-        "object": "AsyncMessages",
-        "method": "stream",
-        "span_name": "anthropic.chat",
-    },
 ]
 
 
@@ -99,6 +107,23 @@ def is_streaming_response(response):
     return isinstance(response, Stream) or isinstance(response, AsyncStream)
 
 
+def is_stream_manager(response):
+    """Check if response is a MessageStreamManager or AsyncMessageStreamManager"""
+    try:
+        from anthropic.lib.streaming._messages import (
+            MessageStreamManager,
+            AsyncMessageStreamManager,
+        )
+
+        return isinstance(response, (MessageStreamManager, AsyncMessageStreamManager))
+    except ImportError:
+        # Check by class name as fallback
+        return (
+            response.__class__.__name__ == "MessageStreamManager"
+            or response.__class__.__name__ == "AsyncMessageStreamManager"
+        )
+
+
 @dont_throw
 async def _aset_token_usage(
     span,
@@ -437,6 +462,33 @@ def _wrap(
             event_logger,
             kwargs,
         )
+    elif is_stream_manager(response):
+        if response.__class__.__name__ == "AsyncMessageStreamManager":
+            return WrappedAsyncMessageStreamManager(
+                response,
+                span,
+                instance._client,
+                start_time,
+                token_histogram,
+                choice_counter,
+                duration_histogram,
+                exception_counter,
+                event_logger,
+                kwargs,
+            )
+        else:
+            return WrappedMessageStreamManager(
+                response,
+                span,
+                instance._client,
+                start_time,
+                token_histogram,
+                choice_counter,
+                duration_histogram,
+                exception_counter,
+                event_logger,
+                kwargs,
+            )
     elif response:
         try:
             metric_attributes = shared_metrics_attributes(response)
@@ -532,6 +584,33 @@ async def _awrap(
             event_logger,
             kwargs,
         )
+    elif is_stream_manager(response):
+        if response.__class__.__name__ == "AsyncMessageStreamManager":
+            return WrappedAsyncMessageStreamManager(
+                response,
+                span,
+                instance._client,
+                start_time,
+                token_histogram,
+                choice_counter,
+                duration_histogram,
+                exception_counter,
+                event_logger,
+                kwargs,
+            )
+        else:
+            return WrappedMessageStreamManager(
+                response,
+                span,
+                instance._client,
+                start_time,
+                token_histogram,
+                choice_counter,
+                duration_histogram,
+                exception_counter,
+                event_logger,
+                kwargs,
+            )
     elif response:
         metric_attributes = shared_metrics_attributes(response)
 

lmnr/opentelemetry_lib/opentelemetry/instrumentation/anthropic/span_utils.py

@@ -113,18 +113,43 @@ async def aset_input_attributes(span, kwargs):
                 )
             for i, message in enumerate(kwargs.get("messages")):
                 prompt_index = i + (1 if has_system_message else 0)
+                content = message.get("content")
+                tool_use_blocks = []
+                other_blocks = []
+                if isinstance(content, list):
+                    for block in content:
+                        if dict(block).get("type") == "tool_use":
+                            tool_use_blocks.append(dict(block))
+                        else:
+                            other_blocks.append(block)
+                    content = other_blocks
                 set_span_attribute(
                     span,
                     f"{SpanAttributes.LLM_PROMPTS}.{prompt_index}.content",
-                    await _dump_content(
-                        message_index=i, span=span, content=message.get("content")
-                    ),
+                    await _dump_content(message_index=i, span=span, content=content),
                 )
                 set_span_attribute(
                     span,
                     f"{SpanAttributes.LLM_PROMPTS}.{prompt_index}.role",
                     message.get("role"),
                 )
+                if tool_use_blocks:
+                    for tool_num, tool_use_block in enumerate(tool_use_blocks):
+                        set_span_attribute(
+                            span,
+                            f"{SpanAttributes.LLM_PROMPTS}.{prompt_index}.tool_calls.{tool_num}.id",
+                            tool_use_block.get("id"),
+                        )
+                        set_span_attribute(
+                            span,
+                            f"{SpanAttributes.LLM_PROMPTS}.{prompt_index}.tool_calls.{tool_num}.name",
+                            tool_use_block.get("name"),
+                        )
+                        set_span_attribute(
+                            span,
+                            f"{SpanAttributes.LLM_PROMPTS}.{prompt_index}.tool_calls.{tool_num}.arguments",
+                            json.dumps(tool_use_block.get("input")),
+                        )
 
         if kwargs.get("tools") is not None:
             for i, tool in enumerate(kwargs.get("tools")):
@@ -160,8 +185,8 @@ def _set_span_completions(span, response):
             content_block_type = content.type
             # usually, Antrhopic responds with just one text block,
             # but the API allows for multiple text blocks, so concatenate them
-            if content_block_type == "text":
-                text += content.text
+            if content_block_type == "text" and hasattr(content, "text"):
+                text += content.text or ""
             elif content_block_type == "thinking":
                 content = dict(content)
                 # override the role to thinking
@@ -242,15 +267,33 @@ def set_streaming_response_attributes(span, complete_response_events):
     if not span.is_recording() or not complete_response_events:
         return
 
-    try:
-        for event in complete_response_events:
-            index = event.get("index")
-            prefix = f"{SpanAttributes.LLM_COMPLETIONS}.{index}"
+    index = 0
+    for event in complete_response_events:
+        prefix = f"{SpanAttributes.LLM_COMPLETIONS}.{index}"
+        set_span_attribute(span, f"{prefix}.finish_reason", event.get("finish_reason"))
+        role = "thinking" if event.get("type") == "thinking" else "assistant"
+        # Thinking is added as a separate completion, so we need to increment the index
+        if event.get("type") == "thinking":
+            index += 1
+        set_span_attribute(span, f"{prefix}.role", role)
+        if event.get("type") == "tool_use":
+            set_span_attribute(
+                span,
+                f"{prefix}.tool_calls.0.id",
+                event.get("id"),
+            )
             set_span_attribute(
-                span, f"{prefix}.finish_reason", event.get("finish_reason")
+                span,
+                f"{prefix}.tool_calls.0.name",
+                event.get("name"),
             )
-            role = "thinking" if event.get("type") == "thinking" else "assistant"
-            set_span_attribute(span, f"{prefix}.role", role)
+            tool_arguments = event.get("input")
+            if tool_arguments is not None:
+                set_span_attribute(
+                    span,
+                    f"{prefix}.tool_calls.0.arguments",
+                    # already stringified
+                    tool_arguments,
+                )
+        else:
             set_span_attribute(span, f"{prefix}.content", event.get("text"))
-    except Exception as e:
-        logger.warning("Failed to set completion attributes, error: %s", str(e))

lmnr/opentelemetry_lib/opentelemetry/instrumentation/anthropic/streaming.py

@@ -40,15 +40,19 @@ def _process_response_item(item, complete_response):
             complete_response["events"].append(
                 {"index": index, "text": "", "type": item.content_block.type}
             )
-    elif item.type == "content_block_delta" and item.delta.type in [
-        "thinking_delta",
-        "text_delta",
-    ]:
+            if item.content_block.type == "tool_use":
+                complete_response["events"][index]["id"] = item.content_block.id
+                complete_response["events"][index]["name"] = item.content_block.name
+                complete_response["events"][index]["input"] = ""
+
+    elif item.type == "content_block_delta":
         index = item.index
         if item.delta.type == "thinking_delta":
-            complete_response["events"][index]["text"] += item.delta.thinking
+            complete_response["events"][index]["text"] += item.delta.thinking or ""
         elif item.delta.type == "text_delta":
-            complete_response["events"][index]["text"] += item.delta.text
+            complete_response["events"][index]["text"] += item.delta.text or ""
+        elif item.delta.type == "input_json_delta":
+            complete_response["events"][index]["input"] += item.delta.partial_json
     elif item.type == "message_delta":
         for event in complete_response.get("events", []):
             event["finish_reason"] = item.delta.stop_reason
@@ -293,3 +297,99 @@ async def abuild_from_streaming_response(
     if span.is_recording():
         span.set_status(Status(StatusCode.OK))
         span.end()
+
+
+class WrappedMessageStreamManager:
+    """Wrapper for MessageStreamManager that handles instrumentation"""
+
+    def __init__(
+        self,
+        stream_manager,
+        span,
+        instance,
+        start_time,
+        token_histogram,
+        choice_counter,
+        duration_histogram,
+        exception_counter,
+        event_logger,
+        kwargs,
+    ):
+        self._stream_manager = stream_manager
+        self._span = span
+        self._instance = instance
+        self._start_time = start_time
+        self._token_histogram = token_histogram
+        self._choice_counter = choice_counter
+        self._duration_histogram = duration_histogram
+        self._exception_counter = exception_counter
+        self._event_logger = event_logger
+        self._kwargs = kwargs
+
+    def __enter__(self):
+        # Call the original stream manager's __enter__ to get the actual stream
+        stream = self._stream_manager.__enter__()
+        # Return the wrapped stream
+        return build_from_streaming_response(
+            self._span,
+            stream,
+            self._instance,
+            self._start_time,
+            self._token_histogram,
+            self._choice_counter,
+            self._duration_histogram,
+            self._exception_counter,
+            self._event_logger,
+            self._kwargs,
+        )
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return self._stream_manager.__exit__(exc_type, exc_val, exc_tb)
+
+
+class WrappedAsyncMessageStreamManager:
+    """Wrapper for AsyncMessageStreamManager that handles instrumentation"""
+
+    def __init__(
+        self,
+        stream_manager,
+        span,
+        instance,
+        start_time,
+        token_histogram,
+        choice_counter,
+        duration_histogram,
+        exception_counter,
+        event_logger,
+        kwargs,
+    ):
+        self._stream_manager = stream_manager
+        self._span = span
+        self._instance = instance
+        self._start_time = start_time
+        self._token_histogram = token_histogram
+        self._choice_counter = choice_counter
+        self._duration_histogram = duration_histogram
+        self._exception_counter = exception_counter
+        self._event_logger = event_logger
+        self._kwargs = kwargs
+
+    async def __aenter__(self):
+        # Call the original stream manager's __aenter__ to get the actual stream
+        stream = await self._stream_manager.__aenter__()
+        # Return the wrapped stream
+        return abuild_from_streaming_response(
+            self._span,
+            stream,
+            self._instance,
+            self._start_time,
+            self._token_histogram,
+            self._choice_counter,
+            self._duration_histogram,
+            self._exception_counter,
+            self._event_logger,
+            self._kwargs,
+        )
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        return await self._stream_manager.__aexit__(exc_type, exc_val, exc_tb)

lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/shared/chat_wrappers.py

@@ -1012,7 +1012,7 @@ def _parse_tool_calls(
         # Handle dict or ChatCompletionMessageToolCall
         if isinstance(tool_call, dict):
             tool_call_data = copy.deepcopy(tool_call)
-        elif isinstance(tool_call, ChatCompletionMessageToolCall):
+        elif _is_tool_call_model(tool_call):
             tool_call_data = tool_call.model_dump()
         elif isinstance(tool_call, FunctionCall):
             function_call = tool_call.model_dump()
@@ -1029,6 +1029,17 @@ def _parse_tool_calls(
     return result
 
 
+def _is_tool_call_model(tool_call):
+    try:
+        from openai.types.chat.chat_completion_message_tool_call import (
+            ChatCompletionMessageFunctionToolCall,
+        )
+
+        return isinstance(tool_call, ChatCompletionMessageFunctionToolCall)
+    except Exception:
+        return False
+
+
 @singledispatch
 def _parse_choice_event(choice) -> ChoiceEvent:
     has_message = choice.message is not None

lmnr/opentelemetry_lib/tracing/__init__.py

@@ -5,6 +5,7 @@ import threading
 from lmnr.opentelemetry_lib.tracing.processor import LaminarSpanProcessor
 from lmnr.sdk.client.asynchronous.async_client import AsyncLaminarClient
 from lmnr.sdk.client.synchronous.sync_client import LaminarClient
+from lmnr.sdk.types import SessionRecordingOptions
 from lmnr.sdk.log import VerboseColorfulFormatter
 from lmnr.opentelemetry_lib.tracing.instruments import (
     Instruments,
@@ -38,6 +39,7 @@ MAX_EVENTS_OR_ATTRIBUTES_PER_SPAN = 5000
 class TracerWrapper(object):
     resource_attributes: dict = {}
     enable_content_tracing: bool = True
+    session_recording_options: SessionRecordingOptions = {}
     _lock = threading.Lock()
     _tracer_provider: TracerProvider | None = None
     _logger: logging.Logger
@@ -62,6 +64,7 @@ class TracerWrapper(object):
         timeout_seconds: int = 30,
         set_global_tracer_provider: bool = True,
         otel_logger_level: int = logging.ERROR,
+        session_recording_options: SessionRecordingOptions | None = None,
     ) -> "TracerWrapper":
         # Silence some opentelemetry warnings
         logging.getLogger("opentelemetry.trace").setLevel(otel_logger_level)
@@ -71,6 +74,9 @@ class TracerWrapper(object):
             if not hasattr(cls, "instance"):
                 cls._initialize_logger(cls)
                 obj = super(TracerWrapper, cls).__new__(cls)
+                
+                # Store session recording options
+                cls.session_recording_options = session_recording_options or {}
 
                 obj._client = LaminarClient(
                     base_url=base_http_url,
@@ -243,6 +249,11 @@ class TracerWrapper(object):
             self._logger.warning("TracerWrapper not fully initialized, cannot flush")
             return False
         return self._span_processor.force_flush()
+    
+    @classmethod
+    def get_session_recording_options(cls) -> SessionRecordingOptions:
+        """Get the session recording options set during initialization."""
+        return cls.session_recording_options
 
     def get_tracer(self):
         if self._tracer_provider is None:

lmnr/sdk/browser/pw_utils.py

@@ -1,5 +1,7 @@
+import orjson
 import logging
 import os
+import time
 
 from opentelemetry import trace
 
@@ -9,6 +11,8 @@ from lmnr.sdk.browser.utils import retry_sync, retry_async
 from lmnr.sdk.client.synchronous.sync_client import LaminarClient
 from lmnr.sdk.client.asynchronous.async_client import AsyncLaminarClient
 from lmnr.opentelemetry_lib.tracing.context import get_current_context
+from lmnr.opentelemetry_lib.tracing import TracerWrapper
+from lmnr.sdk.types import MaskInputOptions
 
 try:
     if is_package_installed("playwright"):
@@ -32,17 +36,24 @@ except ImportError as e:
 
 logger = logging.getLogger(__name__)
 
+OLD_BUFFER_TIMEOUT = 60
+
 current_dir = os.path.dirname(os.path.abspath(__file__))
 with open(os.path.join(current_dir, "recorder", "record.umd.min.cjs"), "r") as f:
     RRWEB_CONTENT = f"() => {{ {f.read()} }}"
 
 INJECT_PLACEHOLDER = """
-() => {
+(mask_input_options) => {
     const BATCH_TIMEOUT = 2000; // Send events after 2 seconds
     const MAX_WORKER_PROMISES = 50; // Max concurrent worker promises
     const HEARTBEAT_INTERVAL = 1000;
-    
+    const CHUNK_SIZE = 256 * 1024; // 256KB chunks
+    const CHUNK_SEND_DELAY = 100; // 100ms delay between chunks
+
     window.lmnrRrwebEventsBatch = [];
+    window.lmnrChunkQueue = [];
+    window.lmnrChunkSequence = 0;
+    window.lmnrCurrentBatchId = null;
 
     // Create a Web Worker for heavy JSON processing with chunked processing
     const createCompressionWorker = () => {
@@ -99,6 +110,25 @@ INJECT_PLACEHOLDER = """
     let compressionWorker = null;
     let workerPromises = new Map();
     let workerId = 0;
+    let workerSupported = null; // null = unknown, true = supported, false = blocked by CSP
+
+    // Test if workers are supported (not blocked by CSP)
+    function testWorkerSupport() {
+        if (workerSupported !== null) {
+            return workerSupported;
+        }
+        
+        try {
+            const testWorker = createCompressionWorker();
+            testWorker.terminate();
+            workerSupported = true;
+            return true;
+        } catch (error) {
+            console.warn('Web Workers blocked by CSP, will use main thread compression:', error);
+            workerSupported = false;
+            return false;
+        }
+    }
 
     // Cleanup function for worker
     const cleanupWorker = () => {
@@ -222,6 +252,11 @@ INJECT_PLACEHOLDER = """
     // Alternative: Use transferable objects for maximum efficiency
     async function compressLargeObjectTransferable(data) {
         try {
+            // Check if workers are supported first
+            if (!testWorkerSupport()) {
+                return compressSmallObject(data);
+            }
+            
             // Clean up stale promises first
             cleanupStalePromises();
             
@@ -281,49 +316,60 @@ INJECT_PLACEHOLDER = """
 
     // Worker-based compression for large objects
     async function compressLargeObject(data, isLarge = true) {
+        // Check if workers are supported first - if not, use main thread compression
+        if (!testWorkerSupport()) {
+            return await compressSmallObject(data);
+        }
+        
         try {
             // Use transferable objects for better performance
             return await compressLargeObjectTransferable(data);
         } catch (error) {
             console.warn('Transferable failed, falling back to string method:', error);
-            // Fallback to string method
-            const jsonString = await stringifyNonBlocking(data);
+            try {
+                // Fallback to string method with worker
+                const jsonString = await stringifyNonBlocking(data);
+
+                return new Promise((resolve, reject) => {
+                    if (!compressionWorker) {
+                        compressionWorker = createCompressionWorker();
+                        compressionWorker.onmessage = (e) => {
+                            const { id, success, data: result, error } = e.data;
+                            const promise = workerPromises.get(id);
+                            if (promise) {
+                                workerPromises.delete(id);
+                                if (success) {
+                                    promise.resolve(result);
+                                } else {
+                                    promise.reject(new Error(error));
+                                }
+                            }
+                        };
+                        
+                        compressionWorker.onerror = (error) => {
+                            console.error('Compression worker error:', error);
+                            cleanupWorker();
+                        };
+                    }
 
-            return new Promise((resolve, reject) => {
-                if (!compressionWorker) {
-                    compressionWorker = createCompressionWorker();
-                    compressionWorker.onmessage = (e) => {
-                        const { id, success, data: result, error } = e.data;
-                        const promise = workerPromises.get(id);
-                        if (promise) {
+                    const id = ++workerId;
+                    workerPromises.set(id, { resolve, reject });
+                    
+                    // Set timeout to prevent hanging promises
+                    setTimeout(() => {
+                        if (workerPromises.has(id)) {
                             workerPromises.delete(id);
-                            if (success) {
-                                promise.resolve(result);
-                            } else {
-                                promise.reject(new Error(error));
-                            }
+                            reject(new Error('Compression timeout'));
                         }
-                    };
+                    }, 10000);
                     
-                    compressionWorker.onerror = (error) => {
-                        console.error('Compression worker error:', error);
-                        cleanupWorker();
-                    };
-                }
-
-                const id = ++workerId;
-                workerPromises.set(id, { resolve, reject });
-                
-                // Set timeout to prevent hanging promises
-                setTimeout(() => {
-                    if (workerPromises.has(id)) {
-                        workerPromises.delete(id);
-                        reject(new Error('Compression timeout'));
-                    }
-                }, 10000);
-                
-                compressionWorker.postMessage({ jsonString, id });
-            });
+                    compressionWorker.postMessage({ jsonString, id });
+                });
+            } catch (workerError) {
+                console.warn('Worker creation failed, falling back to main thread compression:', workerError);
+                // Final fallback: compress on main thread (may block UI but will work)
+                return await compressSmallObject(data);
+            }
         }
     }
 
@@ -343,15 +389,82 @@ INJECT_PLACEHOLDER = """
         return false;
     }
 
+    // Create chunks from a string with metadata
+    function createChunks(str, batchId) {
+        const chunks = [];
+        const totalChunks = Math.ceil(str.length / CHUNK_SIZE);
+        
+        for (let i = 0; i < str.length; i += CHUNK_SIZE) {
+            const chunk = str.slice(i, i + CHUNK_SIZE);
+            chunks.push({
+                batchId: batchId,
+                chunkIndex: chunks.length,
+                totalChunks: totalChunks,
+                data: chunk,
+                isFinal: chunks.length === totalChunks - 1
+            });
+        }
+        
+        return chunks;
+    }
+
+    // Send chunks with flow control
+    async function sendChunks(chunks) {
+        if (typeof window.lmnrSendEvents !== 'function') {
+            return;
+        }
+
+        window.lmnrChunkQueue.push(...chunks);
+        
+        // Process queue
+        while (window.lmnrChunkQueue.length > 0) {
+            const chunk = window.lmnrChunkQueue.shift();
+            try {
+                await window.lmnrSendEvents(chunk);
+                // Small delay between chunks to avoid overwhelming CDP
+                await new Promise(resolve => setTimeout(resolve, CHUNK_SEND_DELAY));
+            } catch (error) {
+                console.error('Failed to send chunk:', error);
+                // On error, clear failed chunk batch from queue
+                window.lmnrChunkQueue = window.lmnrChunkQueue.filter(c => c.batchId !== chunk.batchId);
+                break;
+            }
+        }
+    }
+
     async function sendBatchIfReady() {
         if (window.lmnrRrwebEventsBatch.length > 0 && typeof window.lmnrSendEvents === 'function') {
             const events = window.lmnrRrwebEventsBatch;
             window.lmnrRrwebEventsBatch = [];
 
             try {
-                await window.lmnrSendEvents(events);
+                // Generate unique batch ID
+                const batchId = `${Date.now()}_${window.lmnrChunkSequence++}`;
+                window.lmnrCurrentBatchId = batchId;
+                
+                // Stringify the entire batch
+                const batchString = JSON.stringify(events);
+                
+                // Check size and chunk if necessary
+                if (batchString.length <= CHUNK_SIZE) {
+                    // Small enough to send as single chunk
+                    const chunk = {
+                        batchId: batchId,
+                        chunkIndex: 0,
+                        totalChunks: 1,
+                        data: batchString,
+                        isFinal: true
+                    };
+                    await window.lmnrSendEvents(chunk);
+                } else {
+                    // Need to chunk
+                    const chunks = createChunks(batchString, batchId);
+                    await sendChunks(chunks);
+                }
             } catch (error) {
                 console.error('Failed to send events:', error);
+                // Clear batch to prevent memory buildup
+                window.lmnrRrwebEventsBatch = [];
             }
         }
     }
@@ -387,7 +500,16 @@ INJECT_PLACEHOLDER = """
         },
         recordCanvas: true,
         collectFonts: true,
-        recordCrossOriginIframes: true
+        recordCrossOriginIframes: true,
+        maskInputOptions: {
+            password: true,
+            textarea: mask_input_options.textarea || false,
+            text: mask_input_options.text || false,
+            number: mask_input_options.number || false,
+            select: mask_input_options.select || false,
+            email: mask_input_options.email || false,
+            tel: mask_input_options.tel || false,
+        }
     });
 
     function heartbeat() {
@@ -407,6 +529,30 @@ INJECT_PLACEHOLDER = """
 """
 
 
+def get_mask_input_setting() -> MaskInputOptions:
+    """Get the mask_input setting from session recording configuration."""
+    try:
+        config = TracerWrapper.get_session_recording_options()
+        return config.get("mask_input_options", MaskInputOptions(
+            textarea=False,
+            text=False,
+            number=False,
+            select=False,
+            email=False,
+            tel=False,
+        ))
+    except (AttributeError, Exception):
+        # Fallback to default configuration if TracerWrapper is not initialized
+        return MaskInputOptions(
+            textarea=False,
+            text=False,
+            number=False,
+            select=False,
+            email=False,
+            tel=False,
+        )
+
+
 def inject_session_recorder_sync(page: SyncPage):
     try:
         try:
@@ -435,7 +581,7 @@ def inject_session_recorder_sync(page: SyncPage):
                 return
 
             try:
-                page.evaluate(INJECT_PLACEHOLDER)
+                page.evaluate(INJECT_PLACEHOLDER, get_mask_input_setting())
             except Exception as e:
                 logger.debug(f"Failed to inject session recorder: {e}")
 
@@ -471,7 +617,7 @@ async def inject_session_recorder_async(page: Page):
                 return
 
             try:
-                await page.evaluate(INJECT_PLACEHOLDER)
+                await page.evaluate(INJECT_PLACEHOLDER, get_mask_input_setting())
             except Exception as e:
                 logger.debug(f"Failed to inject session recorder placeholder: {e}")
 
@@ -486,17 +632,54 @@ def start_recording_events_sync(page: SyncPage, session_id: str, client: Laminar
     span = trace.get_current_span(ctx)
     trace_id = format(span.get_span_context().trace_id, "032x")
     span.set_attribute("lmnr.internal.has_browser_session", True)
-
-    try:
-        if page.evaluate("""() => typeof window.lmnrSendEvents !== 'undefined'"""):
-            return
-    except Exception:
-        pass
-
-    def send_events_from_browser(events):
+    
+    # Buffer for reassembling chunks
+    chunk_buffers = {}
+    
+    def send_events_from_browser(chunk):
         try:
-            if events and len(events) > 0:
-                client._browser_events.send(session_id, trace_id, events)
+            # Handle chunked data
+            batch_id = chunk['batchId']
+            chunk_index = chunk['chunkIndex']
+            total_chunks = chunk['totalChunks']
+            data = chunk['data']
+            
+            # Initialize buffer for this batch if needed
+            if batch_id not in chunk_buffers:
+                chunk_buffers[batch_id] = {
+                    'chunks': {},
+                    'total': total_chunks,
+                    'timestamp': time.time()
+                }
+            
+            # Store chunk
+            chunk_buffers[batch_id]['chunks'][chunk_index] = data
+            
+            # Check if we have all chunks
+            if len(chunk_buffers[batch_id]['chunks']) == total_chunks:
+                # Reassemble the full message
+                full_data = ''.join(chunk_buffers[batch_id]['chunks'][i] for i in range(total_chunks))
+                
+                # Parse the JSON
+                events = orjson.loads(full_data)
+                
+                # Send to server
+                if events and len(events) > 0:
+                    client._browser_events.send(session_id, trace_id, events)
+                
+                # Clean up buffer
+                del chunk_buffers[batch_id]
+            
+            # Clean up old incomplete buffers
+            current_time = time.time()
+            to_delete = []
+            for bid, buffer in chunk_buffers.items():
+                if current_time - buffer['timestamp'] > OLD_BUFFER_TIMEOUT:
+                    to_delete.append(bid)
+            for bid in to_delete:
+                logger.debug(f"Cleaning up incomplete chunk buffer: {bid}")
+                del chunk_buffers[bid]
+                
         except Exception as e:
             logger.debug(f"Could not send events: {e}")
 
@@ -524,19 +707,56 @@ async def start_recording_events_async(
     span = trace.get_current_span(ctx)
     trace_id = format(span.get_span_context().trace_id, "032x")
     span.set_attribute("lmnr.internal.has_browser_session", True)
-
-    try:
-        if await page.evaluate(
-            """() => typeof window.lmnrSendEvents !== 'undefined'"""
-        ):
-            return
-    except Exception:
-        pass
     
-    async def send_events_from_browser(events):
+    # Buffer for reassembling chunks
+    chunk_buffers = {}
+    
+    async def send_events_from_browser(chunk):
         try:
-            if events and len(events) > 0:
-                await client._browser_events.send(session_id, trace_id, events)
+            # Handle chunked data
+            batch_id = chunk['batchId']
+            chunk_index = chunk['chunkIndex']
+            total_chunks = chunk['totalChunks']
+            data = chunk['data']
+
+            # Initialize buffer for this batch if needed
+            if batch_id not in chunk_buffers:
+                chunk_buffers[batch_id] = {
+                    'chunks': {},
+                    'total': total_chunks,
+                    'timestamp': time.time()
+                }
+            
+            # Store chunk
+            chunk_buffers[batch_id]['chunks'][chunk_index] = data
+            
+            # Check if we have all chunks
+            if len(chunk_buffers[batch_id]['chunks']) == total_chunks:
+                # Reassemble the full message
+                full_data = ''
+                for i in range(total_chunks):
+                    full_data += chunk_buffers[batch_id]['chunks'][i]
+                
+                # Parse the JSON
+                events = orjson.loads(full_data)
+                
+                # Send to server
+                if events and len(events) > 0:
+                    await client._browser_events.send(session_id, trace_id, events)
+                
+                # Clean up buffer
+                del chunk_buffers[batch_id]
+            
+            # Clean up old incomplete buffers
+            current_time = time.time()
+            to_delete = []
+            for bid, buffer in chunk_buffers.items():
+                if current_time - buffer['timestamp'] > OLD_BUFFER_TIMEOUT:
+                    to_delete.append(bid)
+            for bid in to_delete:
+                logger.debug(f"Cleaning up incomplete chunk buffer: {bid}")
+                del chunk_buffers[bid]
+
         except Exception as e:
             logger.debug(f"Could not send events: {e}")
 

lmnr/sdk/decorators.py

@@ -102,7 +102,8 @@ def observe(
             ):
                 logger.warning("Tags must be a list of strings. Tags will be ignored.")
             else:
-                association_properties["tags"] = tags
+                # list(set(tags)) to deduplicate tags
+                association_properties["tags"] = list(set(tags))
         if input_formatter is not None and ignore_input:
             logger.warning(
                 f"observe, function {func.__name__}: Input formatter"

lmnr/sdk/laminar.py

@@ -45,6 +45,7 @@ from .log import VerboseColorfulFormatter
 
 from .types import (
     LaminarSpanContext,
+    SessionRecordingOptions,
     TraceType,
 )
 
@@ -73,6 +74,7 @@ class Laminar:
         export_timeout_seconds: int | None = None,
         set_global_tracer_provider: bool = True,
         otel_logger_level: int = logging.ERROR,
+        session_recording_options: SessionRecordingOptions | None = None,
     ):
         """Initialize Laminar context across the application.
         This method must be called before using any other Laminar methods or
@@ -119,6 +121,10 @@ class Laminar:
                 Defaults to True.
             otel_logger_level (int, optional): OpenTelemetry logger level. Defaults\
                 to logging.ERROR.
+            session_recording_options (SessionRecordingOptions | None, optional): Options\
+                for browser session recording. Currently supports 'mask_input'\
+                (bool) to control whether input fields are masked during recording.\
+                Defaults to None (uses default masking behavior).
 
         Raises:
             ValueError: If project API key is not set
@@ -179,6 +185,7 @@ class Laminar:
             timeout_seconds=export_timeout_seconds,
             set_global_tracer_provider=set_global_tracer_provider,
             otel_logger_level=otel_logger_level,
+            session_recording_options=session_recording_options,
         )
 
     @classmethod
@@ -741,7 +748,8 @@ class Laminar:
                 "Tags must be a list of strings. Tags will be ignored."
             )
             return
-        span.set_attribute(f"{ASSOCIATION_PROPERTIES}.tags", tags)
+        # list(set(tags)) to deduplicate tags
+        span.set_attribute(f"{ASSOCIATION_PROPERTIES}.tags", list(set(tags)))
 
     @classmethod
     def set_trace_session_id(cls, session_id: str | None = None):

lmnr/sdk/types.py

@@ -9,7 +9,7 @@ import uuid
 
 from enum import Enum
 from opentelemetry.trace import SpanContext, TraceFlags
-from typing import Any, Awaitable, Callable, Literal, Optional
+from typing import Any, Awaitable, Callable, Literal, Optional, TypedDict
 
 from .utils import serialize
 
@@ -346,3 +346,15 @@ class RunAgentResponseChunk(pydantic.RootModel):
         | ErrorChunkContent
         | TimeoutChunkContent
     )
+
+
+class MaskInputOptions(TypedDict):
+    textarea: bool | None
+    text: bool | None
+    number: bool | None
+    select: bool | None
+    email: bool | None
+    tel: bool | None
+
+class SessionRecordingOptions(TypedDict):
+    mask_input_options: MaskInputOptions | None

lmnr/version.py

@@ -3,7 +3,7 @@ import httpx
 from packaging import version
 
 
-__version__ = "0.7.1"
+__version__ = "0.7.3"
 PYTHON_VERSION = f"{sys.version_info.major}.{sys.version_info.minor}"
 
 

{lmnr-0.7.1.dist-info → lmnr-0.7.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lmnr
-Version: 0.7.1
+Version: 0.7.3
 Summary: Python SDK for Laminar
 Author: lmnr.ai
 Author-email: lmnr.ai <founders@lmnr.ai>
@@ -19,61 +19,59 @@ Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.33.0
 Requires-Dist: opentelemetry-exporter-otlp-proto-grpc>=1.33.0
 Requires-Dist: opentelemetry-instrumentation>=0.54b0
 Requires-Dist: opentelemetry-semantic-conventions>=0.54b0
-Requires-Dist: opentelemetry-semantic-conventions-ai>=0.4.9
+Requires-Dist: opentelemetry-semantic-conventions-ai>=0.4.11
 Requires-Dist: tqdm>=4.0
 Requires-Dist: tenacity>=8.0
 Requires-Dist: grpcio>=1
 Requires-Dist: httpx>=0.25.0
 Requires-Dist: orjson>=3.10.18
 Requires-Dist: packaging>=22.0
-Requires-Dist: opentelemetry-instrumentation-alephalpha>=0.40.12 ; extra == 'alephalpha'
-Requires-Dist: opentelemetry-instrumentation-alephalpha>=0.40.12 ; extra == 'all'
-Requires-Dist: opentelemetry-instrumentation-bedrock>=0.40.12 ; extra == 'all'
-Requires-Dist: opentelemetry-instrumentation-chromadb>=0.40.12 ; extra == 'all'
-Requires-Dist: opentelemetry-instrumentation-cohere>=0.40.12 ; extra == 'all'
-Requires-Dist: opentelemetry-instrumentation-crewai>=0.40.12 ; extra == 'all'
-Requires-Dist: opentelemetry-instrumentation-google-generativeai<0.40.10 ; extra == 'all'
-Requires-Dist: opentelemetry-instrumentation-haystack>=0.40.12 ; extra == 'all'
-Requires-Dist: opentelemetry-instrumentation-lancedb>=0.40.12 ; extra == 'all'
-Requires-Dist: opentelemetry-instrumentation-langchain>=0.40.12 ; extra == 'all'
-Requires-Dist: opentelemetry-instrumentation-llamaindex>=0.40.12 ; extra == 'all'
-Requires-Dist: opentelemetry-instrumentation-marqo>=0.40.12 ; extra == 'all'
-Requires-Dist: opentelemetry-instrumentation-mcp>=0.40.12 ; extra == 'all'
-Requires-Dist: opentelemetry-instrumentation-milvus>=0.40.12 ; extra == 'all'
-Requires-Dist: opentelemetry-instrumentation-mistralai>=0.40.12 ; extra == 'all'
-Requires-Dist: opentelemetry-instrumentation-ollama>=0.40.12 ; extra == 'all'
-Requires-Dist: opentelemetry-instrumentation-pinecone>=0.40.12 ; extra == 'all'
-Requires-Dist: opentelemetry-instrumentation-qdrant>=0.40.12 ; extra == 'all'
-Requires-Dist: opentelemetry-instrumentation-replicate>=0.40.12 ; extra == 'all'
-Requires-Dist: opentelemetry-instrumentation-sagemaker>=0.40.12 ; extra == 'all'
-Requires-Dist: opentelemetry-instrumentation-together>=0.40.12 ; extra == 'all'
-Requires-Dist: opentelemetry-instrumentation-transformers>=0.40.12 ; extra == 'all'
-Requires-Dist: opentelemetry-instrumentation-vertexai>=0.40.12 ; extra == 'all'
-Requires-Dist: opentelemetry-instrumentation-watsonx>=0.40.12 ; extra == 'all'
-Requires-Dist: opentelemetry-instrumentation-weaviate>=0.40.12 ; extra == 'all'
-Requires-Dist: opentelemetry-instrumentation-bedrock>=0.40.12 ; extra == 'bedrock'
-Requires-Dist: opentelemetry-instrumentation-chromadb>=0.40.12 ; extra == 'chromadb'
-Requires-Dist: opentelemetry-instrumentation-cohere>=0.40.12 ; extra == 'cohere'
-Requires-Dist: opentelemetry-instrumentation-crewai>=0.40.12 ; extra == 'crewai'
-Requires-Dist: opentelemetry-instrumentation-google-generativeai<0.40.10 ; extra == 'google-generativeai'
-Requires-Dist: opentelemetry-instrumentation-haystack>=0.40.12 ; extra == 'haystack'
-Requires-Dist: opentelemetry-instrumentation-lancedb>=0.40.12 ; extra == 'lancedb'
-Requires-Dist: opentelemetry-instrumentation-langchain>=0.40.12 ; extra == 'langchain'
-Requires-Dist: opentelemetry-instrumentation-llamaindex>=0.40.12 ; extra == 'llamaindex'
-Requires-Dist: opentelemetry-instrumentation-marqo>=0.40.12 ; extra == 'marqo'
-Requires-Dist: opentelemetry-instrumentation-mcp>=0.40.12 ; extra == 'mcp'
-Requires-Dist: opentelemetry-instrumentation-milvus>=0.40.12 ; extra == 'milvus'
-Requires-Dist: opentelemetry-instrumentation-mistralai>=0.40.12 ; extra == 'mistralai'
-Requires-Dist: opentelemetry-instrumentation-ollama>=0.40.12 ; extra == 'ollama'
-Requires-Dist: opentelemetry-instrumentation-pinecone>=0.40.12 ; extra == 'pinecone'
-Requires-Dist: opentelemetry-instrumentation-qdrant>=0.40.12 ; extra == 'qdrant'
-Requires-Dist: opentelemetry-instrumentation-replicate>=0.40.12 ; extra == 'replicate'
-Requires-Dist: opentelemetry-instrumentation-sagemaker>=0.40.12 ; extra == 'sagemaker'
-Requires-Dist: opentelemetry-instrumentation-together>=0.40.12 ; extra == 'together'
-Requires-Dist: opentelemetry-instrumentation-transformers>=0.40.12 ; extra == 'transformers'
-Requires-Dist: opentelemetry-instrumentation-vertexai>=0.40.12 ; extra == 'vertexai'
-Requires-Dist: opentelemetry-instrumentation-watsonx>=0.40.12 ; extra == 'watsonx'
-Requires-Dist: opentelemetry-instrumentation-weaviate>=0.40.12 ; extra == 'weaviate'
+Requires-Dist: opentelemetry-instrumentation-alephalpha>=0.44.0 ; extra == 'alephalpha'
+Requires-Dist: opentelemetry-instrumentation-alephalpha>=0.44.0 ; extra == 'all'
+Requires-Dist: opentelemetry-instrumentation-bedrock>=0.44.0 ; extra == 'all'
+Requires-Dist: opentelemetry-instrumentation-chromadb>=0.44.0 ; extra == 'all'
+Requires-Dist: opentelemetry-instrumentation-cohere>=0.44.0 ; extra == 'all'
+Requires-Dist: opentelemetry-instrumentation-crewai>=0.44.0 ; extra == 'all'
+Requires-Dist: opentelemetry-instrumentation-haystack>=0.44.0 ; extra == 'all'
+Requires-Dist: opentelemetry-instrumentation-lancedb>=0.44.0 ; extra == 'all'
+Requires-Dist: opentelemetry-instrumentation-langchain>=0.44.0 ; extra == 'all'
+Requires-Dist: opentelemetry-instrumentation-llamaindex>=0.44.0 ; extra == 'all'
+Requires-Dist: opentelemetry-instrumentation-marqo>=0.44.0 ; extra == 'all'
+Requires-Dist: opentelemetry-instrumentation-mcp>=0.44.0 ; extra == 'all'
+Requires-Dist: opentelemetry-instrumentation-milvus>=0.44.0 ; extra == 'all'
+Requires-Dist: opentelemetry-instrumentation-mistralai>=0.44.0 ; extra == 'all'
+Requires-Dist: opentelemetry-instrumentation-ollama>=0.44.0 ; extra == 'all'
+Requires-Dist: opentelemetry-instrumentation-pinecone>=0.44.0 ; extra == 'all'
+Requires-Dist: opentelemetry-instrumentation-qdrant>=0.44.0 ; extra == 'all'
+Requires-Dist: opentelemetry-instrumentation-replicate>=0.44.0 ; extra == 'all'
+Requires-Dist: opentelemetry-instrumentation-sagemaker>=0.44.0 ; extra == 'all'
+Requires-Dist: opentelemetry-instrumentation-together>=0.44.0 ; extra == 'all'
+Requires-Dist: opentelemetry-instrumentation-transformers>=0.44.0 ; extra == 'all'
+Requires-Dist: opentelemetry-instrumentation-vertexai>=0.44.0 ; extra == 'all'
+Requires-Dist: opentelemetry-instrumentation-watsonx>=0.44.0 ; extra == 'all'
+Requires-Dist: opentelemetry-instrumentation-weaviate>=0.44.0 ; extra == 'all'
+Requires-Dist: opentelemetry-instrumentation-bedrock>=0.44.0 ; extra == 'bedrock'
+Requires-Dist: opentelemetry-instrumentation-chromadb>=0.44.0 ; extra == 'chromadb'
+Requires-Dist: opentelemetry-instrumentation-cohere>=0.44.0 ; extra == 'cohere'
+Requires-Dist: opentelemetry-instrumentation-crewai>=0.44.0 ; extra == 'crewai'
+Requires-Dist: opentelemetry-instrumentation-haystack>=0.44.0 ; extra == 'haystack'
+Requires-Dist: opentelemetry-instrumentation-lancedb>=0.44.0 ; extra == 'lancedb'
+Requires-Dist: opentelemetry-instrumentation-langchain>=0.44.0 ; extra == 'langchain'
+Requires-Dist: opentelemetry-instrumentation-llamaindex>=0.44.0 ; extra == 'llamaindex'
+Requires-Dist: opentelemetry-instrumentation-marqo>=0.44.0 ; extra == 'marqo'
+Requires-Dist: opentelemetry-instrumentation-mcp>=0.44.0 ; extra == 'mcp'
+Requires-Dist: opentelemetry-instrumentation-milvus>=0.44.0 ; extra == 'milvus'
+Requires-Dist: opentelemetry-instrumentation-mistralai>=0.44.0 ; extra == 'mistralai'
+Requires-Dist: opentelemetry-instrumentation-ollama>=0.44.0 ; extra == 'ollama'
+Requires-Dist: opentelemetry-instrumentation-pinecone>=0.44.0 ; extra == 'pinecone'
+Requires-Dist: opentelemetry-instrumentation-qdrant>=0.44.0 ; extra == 'qdrant'
+Requires-Dist: opentelemetry-instrumentation-replicate>=0.44.0 ; extra == 'replicate'
+Requires-Dist: opentelemetry-instrumentation-sagemaker>=0.44.0 ; extra == 'sagemaker'
+Requires-Dist: opentelemetry-instrumentation-together>=0.44.0 ; extra == 'together'
+Requires-Dist: opentelemetry-instrumentation-transformers>=0.44.0 ; extra == 'transformers'
+Requires-Dist: opentelemetry-instrumentation-vertexai>=0.44.0 ; extra == 'vertexai'
+Requires-Dist: opentelemetry-instrumentation-watsonx>=0.44.0 ; extra == 'watsonx'
+Requires-Dist: opentelemetry-instrumentation-weaviate>=0.44.0 ; extra == 'weaviate'
 Requires-Python: >=3.10, <4
 Provides-Extra: alephalpha
 Provides-Extra: all
@@ -81,7 +79,6 @@ Provides-Extra: bedrock
 Provides-Extra: chromadb
 Provides-Extra: cohere
 Provides-Extra: crewai
-Provides-Extra: google-generativeai
 Provides-Extra: haystack
 Provides-Extra: lancedb
 Provides-Extra: langchain

{lmnr-0.7.1.dist-info → lmnr-0.7.3.dist-info}/RECORD

@@ -1,16 +1,16 @@
-lmnr/__init__.py,sha256=47422a1fd58f5be3e7870ccb3ed7de4f1ac520d942e0c83cbcf903b0600a08f6,1278
+lmnr/__init__.py,sha256=8be7b56ab62735fd54ca90a0642784c6153ed1d6e0f12734619ca0618dd9fbdb,1398
 lmnr/cli.py,sha256=b8780b51f37fe9e20db5495c41d3ad3837f6b48f408b09a58688d017850c0796,6047
 lmnr/opentelemetry_lib/.flake8,sha256=6c2c6e0e51b1dd8439e501ca3e21899277076a787da868d0254ba37056b79405,150
-lmnr/opentelemetry_lib/__init__.py,sha256=6962aca915d485586ed814b9e799ced898594ac2bc6d35329405705b26eab861,2160
+lmnr/opentelemetry_lib/__init__.py,sha256=1350e8d12ea2f422751ab3a80d7d32d10c27ad8e4c2989407771dc6e544d9c65,2350
 lmnr/opentelemetry_lib/decorators/__init__.py,sha256=216536fb3ac8de18e6dfe4dfb2e571074c727466f97e6dcd609339c8458a345a,11511
 lmnr/opentelemetry_lib/litellm/__init__.py,sha256=8a3679381ca5660cf53e4b7571850906c6635264129149adebda8f3f7c248f68,15127
 lmnr/opentelemetry_lib/litellm/utils.py,sha256=da8cf0553f82dc7203109f117a4c7b4185e8baf34caad12d7823875515201a27,539
-lmnr/opentelemetry_lib/opentelemetry/instrumentation/anthropic/__init__.py,sha256=984b8f97eb31d4345ea4c52237451f791af189c4a94aaf2625edfd05107d8a6e,20696
+lmnr/opentelemetry_lib/opentelemetry/instrumentation/anthropic/__init__.py,sha256=2604189b7598edb5404ddbcd0775bdf2dc506dd5e6319eef4e4724e39c420301,23276
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/anthropic/config.py,sha256=972919b821b9b7e5dc7cd191ba7e78b30b6efa5d63514e8cb301996d6386392c,369
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/anthropic/event_emitter.py,sha256=812b3ea1c5a04412113d4dd770717561861595f9eec5b94dd8174c6ddfb7572a,6831
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/anthropic/event_models.py,sha256=3c27c21b1aeb02bc19a91fb8c05717ae1c10ab4b01300c664aba42e0f50cb5a3,876
-lmnr/opentelemetry_lib/opentelemetry/instrumentation/anthropic/span_utils.py,sha256=9d0bb3825a6b5c28ac3778d49b7e67dc829530b2ebe34ef3f0e273f51caebcea,9422
-lmnr/opentelemetry_lib/opentelemetry/instrumentation/anthropic/streaming.py,sha256=e999ad093275c5195b5d31dfea456726afd5f474cd779be7af892f54d7b416b8,10129
+lmnr/opentelemetry_lib/opentelemetry/instrumentation/anthropic/span_utils.py,sha256=6a931571b4a036cd8711419cadad737ec46cc67b4368f2f662f1a565737f9f9b,11403
+lmnr/opentelemetry_lib/opentelemetry/instrumentation/anthropic/streaming.py,sha256=7ca9f49e4d9a3bac292d13a8ee9827fdfb8a46d13ebdcbbfbac9c5584d11eaf3,13441
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/anthropic/utils.py,sha256=0044f02da8b99322fdbf3f8f6663f04ff5d1295ddae92a635fd16eb685d5fbb6,5386
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/anthropic/version.py,sha256=5aacde4ca55ef50ed07a239ad8a86889e0621b1cc72be19bd93be7c9e20910a9,23
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/google_genai/__init__.py,sha256=a47d4d1234e0278d1538748130a79c03d6cb3486976cb5d19578fe1b90f28e7b,20524
@@ -28,7 +28,7 @@ lmnr/opentelemetry_lib/opentelemetry/instrumentation/langgraph/__init__.py,sha25
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/langgraph/utils.py,sha256=9dff6c2595e79edb38818668aed1220efc188d8a982594c04f4ceeb6e3ff47a6,1512
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/__init__.py,sha256=8b91dc16af927eee75b969c0980c606680b347a87f8533bc0f4a092e5ec6e5c9,2071
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/shared/__init__.py,sha256=9d182c8cef5ee1e205dc4c2f7c8e49d8403ee9fee66072c5cfdd29a0d54f61a2,15149
-lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/shared/chat_wrappers.py,sha256=6042b3bcf94f38c90bdebaa2c6c9ac1a4723d1801b8e7c20cf8cc3926cef83ad,38657
+lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/shared/chat_wrappers.py,sha256=92aed53560c49e0ec3ef5e20ddb6c2096bb26078cc3e10b2f80a9dcef7a3e520,38937
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/shared/completion_wrappers.py,sha256=3a45c07d9d0f37baf409a48e2a1b577f28041c623c41f59ada1c87b94285ae3b,9537
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/shared/config.py,sha256=8016e4af0291a77484ce88d7d1ca06146b1229ae0e0a0f46e042faf75b456a8f,507
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/shared/embeddings_wrappers.py,sha256=324eeeaf8dd862f49c15bb7290d414e77ad51cdf532c2cfd74358783cdf654a5,9330
@@ -45,7 +45,7 @@ lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/version.py,sha256=4f
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/opentelemetry/__init__.py,sha256=1f86cdf738e2f68586b0a4569bb1e40edddd85c529f511ef49945ddb7b61fab5,2648
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/skyvern/__init__.py,sha256=764e4fe979fb08d7821419a3cc5c3ae89a6664b626ef928259f8f175c939eaea,6334
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/threading/__init__.py,sha256=90aa8558467d7e469fe1a6c75372c113da403557715f03b522b2fab94b287c40,6320
-lmnr/opentelemetry_lib/tracing/__init__.py,sha256=a39e9a48f8a842ce7f7ec53364d793c1a303dcfd485aee7a72ade07d1b3635a2,9662
+lmnr/opentelemetry_lib/tracing/__init__.py,sha256=1019d25eab017547e914aa9703d4c4bc3fabb7ae0327f0dcb266c3d09f9a08e8,10207
 lmnr/opentelemetry_lib/tracing/_instrument_initializers.py,sha256=a15a46a0515462319195a96f7cdb695e72a1559c3212964f5883ab824031bf70,15125
 lmnr/opentelemetry_lib/tracing/attributes.py,sha256=32fa30565b977c2a92202dc2bf1ded583a81d02a6bf5ba52958f75a8be08cbbe,1497
 lmnr/opentelemetry_lib/tracing/context.py,sha256=83f842be0fc29a96647cbf005c39ea761b0fb5913c4102f965411f47906a6135,4103
@@ -62,7 +62,7 @@ lmnr/sdk/browser/__init__.py,sha256=e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b
 lmnr/sdk/browser/browser_use_otel.py,sha256=37d26de1af37f76774af176cb226e0b04988fc3bf419a2fd899ad36e79562fad,5104
 lmnr/sdk/browser/patchright_otel.py,sha256=9d22ab1f28f1eddbcfd0032a14fe306bfe00bfc7f11128cb99836c4dd15fb7c8,4800
 lmnr/sdk/browser/playwright_otel.py,sha256=50c0a5a75155a3a7ff5db84790ffb409c9cbd0351eef212d83d923893730223b,9459
-lmnr/sdk/browser/pw_utils.py,sha256=f6cb4b7cb59d6b488298f462cf88aa967a424f5bfdfd91c39998df930b212c2c,20420
+lmnr/sdk/browser/pw_utils.py,sha256=e8b839d729bf4d80e07db0a8bb616b41da43219a019d2ce9596c1b6e9f848074,29061
 lmnr/sdk/browser/recorder/record.umd.min.cjs,sha256=f09c09052c2fc474efb0405e63d8d26ed2184b994513ce8aee04efdac8be155d,181235
 lmnr/sdk/browser/utils.py,sha256=4a668776d2938108d25fbcecd61c8e1710a4da3e56230d5fefca5964dd09e3c1,2371
 lmnr/sdk/client/asynchronous/async_client.py,sha256=e8feae007506cd2e4b08e72706f5f1bb4ea54492b4aa6b68ef184a129de8f466,4948
@@ -82,15 +82,15 @@ lmnr/sdk/client/synchronous/resources/evaluators.py,sha256=3cd6a17e7a9cc0441c2d2
 lmnr/sdk/client/synchronous/resources/tags.py,sha256=123deec43128662c21cb275b2df6a102372f875315b0bd36806555394c1d4b5b,2270
 lmnr/sdk/client/synchronous/sync_client.py,sha256=0bebe88e3aed689505e9ed3d32036f76df4c3496e4d659162bd41abedc026f16,5299
 lmnr/sdk/datasets.py,sha256=3fd851c5f97bf88eaa84b1451a053eaff23b4497cbb45eac2f9ea0e5f2886c00,1708
-lmnr/sdk/decorators.py,sha256=0c6b95b92ec8023f28cd15ddc47849888fa91f2534d575f626e3557f5f0a0c02,6451
+lmnr/sdk/decorators.py,sha256=2ccf9ecd9616ad1d52301febd8af630288ba63db2d36302236f606a460fc08ca,6516
 lmnr/sdk/eval_control.py,sha256=291394ac385c653ae9b5167e871bebeb4fe8fc6b7ff2ed38e636f87015dcba86,184
 lmnr/sdk/evaluations.py,sha256=b41f7737b084dc5b64b2952659b729622e0918fd492bfcddde7177d1a1c690ae,22572
-lmnr/sdk/laminar.py,sha256=c38590ec5d65d5dedad37258f13f4f88f989e9ae10cbdb30bd1acdad5443e1d6,34427
+lmnr/sdk/laminar.py,sha256=f9dbacc6549d19701db7a986cb29c82114b1a054900a282b1ae9dbe6a488129b,34974
 lmnr/sdk/log.py,sha256=9edfd83263f0d4845b1b2d1beeae2b4ed3f8628de941f371a893d72b79c348d4,2213
-lmnr/sdk/types.py,sha256=c4868d7d1df2fbd108fe5990900675bff2e595f6ff207afcf166ad4853f5eb0a,12670
+lmnr/sdk/types.py,sha256=ded526d1289442672236265bd6cbb4381fc55d8ce0fce1d6e7b2541e54c758c4,12948
 lmnr/sdk/utils.py,sha256=4beb884ae6fbbc7d8cf639b036b726ea6a2a658f0a6386faf5735a13d706a2d8,5039
-lmnr/version.py,sha256=05f60eaaaa74f6161e0194247bb2244c9a3b5c1176c8902c6075ebef93276235,1321
-lmnr-0.7.1.dist-info/WHEEL,sha256=ab6157bc637547491fb4567cd7ddf26b04d63382916ca16c29a5c8e94c9c9ef7,79
-lmnr-0.7.1.dist-info/entry_points.txt,sha256=abdf3411b7dd2d7329a241f2da6669bab4e314a747a586ecdb9f888f3035003c,39
-lmnr-0.7.1.dist-info/METADATA,sha256=847134a28ee45d56155835c491fbeb4a12cd6650709991550fff10976a328212,14473
-lmnr-0.7.1.dist-info/RECORD,,
+lmnr/version.py,sha256=65bb6a01739adaee6189918df22c9e8df76cfc10339b704416f686014f066b2b,1321
+lmnr-0.7.3.dist-info/WHEEL,sha256=ab6157bc637547491fb4567cd7ddf26b04d63382916ca16c29a5c8e94c9c9ef7,79
+lmnr-0.7.3.dist-info/entry_points.txt,sha256=abdf3411b7dd2d7329a241f2da6669bab4e314a747a586ecdb9f888f3035003c,39
+lmnr-0.7.3.dist-info/METADATA,sha256=2952132a1ddd7d9e0f8c50fdd39e159174825b812b898bf48135c1c69ee7d5db,14196
+lmnr-0.7.3.dist-info/RECORD,,