lmnr 0.7.6__py3-none-any.whl → 0.7.8__py3-none-any.whl

lmnr/opentelemetry_lib/decorators/__init__.py

@@ -1,5 +1,4 @@
 from functools import wraps
-import logging
 import pydantic
 import orjson
 import types
@@ -60,7 +59,7 @@ def json_dumps(data: dict) -> str:
         ).decode("utf-8")
     except Exception:
         # Log the exception and return a placeholder if serialization completely fails
-        logging.warning("Failed to serialize data to JSON, type: %s", type(data))
+        logger.info("Failed to serialize data to JSON, type: %s", type(data))
         return "{}"  # Return an empty JSON object as a fallback
 
 

lmnr/opentelemetry_lib/litellm/__init__.py

@@ -7,14 +7,13 @@ from opentelemetry.trace import SpanKind, Status, StatusCode, Tracer
 from lmnr.opentelemetry_lib.litellm.utils import model_as_dict, set_span_attribute
 from lmnr.opentelemetry_lib.tracing import TracerWrapper
 
-from lmnr.opentelemetry_lib.tracing.context import get_event_attributes_from_context
+from lmnr.opentelemetry_lib.tracing.context import (
+    get_current_context,
+    get_event_attributes_from_context,
+)
 from lmnr.opentelemetry_lib.utils.package_check import is_package_installed
 from lmnr.sdk.log import get_default_logger
 
-from lmnr.opentelemetry_lib.opentelemetry.instrumentation.openai import (
-    OpenAIInstrumentor,
-)
-
 logger = get_default_logger(__name__)
 
 SUPPORTED_CALL_TYPES = ["completion", "acompletion"]
@@ -46,6 +45,10 @@ try:
                 raise ValueError("Laminar must be initialized before LiteLLM callback")
 
             if is_package_installed("openai"):
+                from lmnr.opentelemetry_lib.opentelemetry.instrumentation.openai import (
+                    OpenAIInstrumentor,
+                )
+
                 openai_instrumentor = OpenAIInstrumentor()
                 if (
                     openai_instrumentor
@@ -117,6 +120,7 @@ try:
                 attributes={
                     "lmnr.internal.provider": "litellm",
                 },
+                context=get_current_context(),
             )
             try:
                 model = kwargs.get("model", "unknown")

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

@@ -375,6 +375,7 @@ def _build_from_streaming_response(
             # total token count in every chunk is greater by prompt token count than it should be,
             # thus this awkward logic here
             if aggregated_usage_metadata.get("prompt_token_count") is None:
+                # or 0, not .get(key, 0), because sometimes the value is explicitly None
                 aggregated_usage_metadata["prompt_token_count"] = (
                     usage_dict.get("prompt_token_count") or 0
                 )
@@ -417,14 +418,15 @@ async def _abuild_from_streaming_response(
     aggregated_usage_metadata = defaultdict(int)
     model_version = None
     async for chunk in response:
+        if chunk.model_version:
+            model_version = chunk.model_version
+
         if chunk.candidates:
             # Currently gemini throws an error if you pass more than one candidate
             # with streaming
             if chunk.candidates and len(chunk.candidates) > 0:
                 final_parts += chunk.candidates[0].content.parts or []
                 role = chunk.candidates[0].content.role or role
-                if chunk.model_version:
-                    model_version = chunk.model_version
         if chunk.usage_metadata:
             usage_dict = to_dict(chunk.usage_metadata)
             # prompt token count is sent in every chunk
@@ -432,11 +434,12 @@ async def _abuild_from_streaming_response(
             # total token count in every chunk is greater by prompt token count than it should be,
             # thus this awkward logic here
             if aggregated_usage_metadata.get("prompt_token_count") is None:
-                aggregated_usage_metadata["prompt_token_count"] = usage_dict.get(
-                    "prompt_token_count"
+                # or 0, not .get(key, 0), because sometimes the value is explicitly None
+                aggregated_usage_metadata["prompt_token_count"] = (
+                    usage_dict.get("prompt_token_count") or 0
                 )
-                aggregated_usage_metadata["total_token_count"] = usage_dict.get(
-                    "total_token_count"
+                aggregated_usage_metadata["total_token_count"] = (
+                    usage_dict.get("total_token_count") or 0
                 )
             aggregated_usage_metadata["candidates_token_count"] += (
                 usage_dict.get("candidates_token_count") or 0

lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/utils.py

@@ -12,6 +12,7 @@ from .shared.config import Config
 
 import openai
 
+
 _OPENAI_VERSION = version("openai")
 
 LMNR_TRACE_CONTENT = "LMNR_TRACE_CONTENT"
@@ -22,6 +23,7 @@ def is_openai_v1():
 
 
 def is_azure_openai(instance):
+
     return is_openai_v1() and isinstance(
         instance._client, (openai.AsyncAzureOpenAI, openai.AzureOpenAI)
     )

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

@@ -0,0 +1,389 @@
+"""OpenTelemetry OpenHands AI instrumentation"""
+
+import sys
+from typing import Collection
+
+from lmnr.opentelemetry_lib.decorators import json_dumps
+from lmnr.opentelemetry_lib.tracing.attributes import (
+    ASSOCIATION_PROPERTIES,
+    SESSION_ID,
+    USER_ID,
+)
+from lmnr.opentelemetry_lib.utils.wrappers import _with_tracer_wrapper
+from lmnr.sdk.log import get_default_logger
+from lmnr.sdk.utils import get_input_from_func_args
+from lmnr import Laminar
+from lmnr.version import __version__
+
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from opentelemetry.instrumentation.utils import unwrap
+from opentelemetry.trace import get_tracer, Tracer
+from wrapt import wrap_function_wrapper
+
+logger = get_default_logger(__name__)
+
+_instruments = ("openhands-ai >= 0.9.0", "openhands-aci >= 0.1.0")
+parent_spans = {}
+
+
+def is_message_action(event) -> bool:
+    """Check if event has action attribute equal to 'message'."""
+    return event and hasattr(event, "action") and event.action == "message"
+
+
+def is_user_message(event) -> bool:
+    """Check if event is a message action from user source."""
+    return (
+        is_message_action(event) and hasattr(event, "source") and event.source == "user"
+    )
+
+
+def is_agent_message(event) -> bool:
+    """Check if event is a message action from agent source."""
+    return (
+        is_message_action(event)
+        and hasattr(event, "source")
+        and event.source == "agent"
+    )
+
+
+def is_agent_state_changed_to(event, state: str) -> bool:
+    """Check if event is an agent_state_changed observation with specific state."""
+    return (
+        event
+        and hasattr(event, "observation")
+        and event.observation == "agent_state_changed"
+        and hasattr(event, "agent_state")
+        and event.agent_state == state
+    )
+
+
+def get_handle_action_action(event) -> str:
+    """Get the action of the handle_action event."""
+    if event and hasattr(event, "action"):
+        try:
+            return event.action.value
+        except Exception:
+            return event.action
+    return None
+
+
+WRAPPED_METHODS = [
+    {
+        "package": "openhands.agenthub.codeact_agent.codeact_agent",
+        "object": "CodeActAgent",
+        "methods": [
+            {"method": "step"},
+            {"method": "response_to_actions"},
+        ],
+    },
+    {
+        "package": "openhands.controller.agent_controller",
+        "object": "AgentController",
+        "methods": [
+            {"method": "_step", "async": True},
+            {
+                "method": "_handle_action",
+                "async": True,
+                "span_type": "TOOL",
+            },
+            {"method": "_handle_observation", "async": True},
+            {"method": "_handle_message_action", "async": True},
+            {"method": "on_event"},
+            {"method": "save_state"},
+            {"method": "get_trajectory"},
+            {"method": "start_delegate"},
+            {"method": "end_delegate"},
+            {"method": "_is_stuck"},
+        ],
+    },
+]
+
+
+@_with_tracer_wrapper
+def _wrap_on_event(tracer: Tracer, to_wrap, wrapped, instance, args, kwargs):
+    """Wrapper for on_event."""
+    controller_id = instance.id
+    user_id = instance.user_id
+    event = kwargs.get("event", args[0] if len(args) > 0 else None)
+    start_event = False
+    finish_event = False
+    user_message = ""
+    agent_message = ""
+    span_name = to_wrap.get("span_name")
+    span_type = to_wrap.get("span_type", "DEFAULT")
+    if event and hasattr(event, "action") and event.action == "system":
+        return wrapped(*args, **kwargs)
+
+    event_type = None
+    subtype = None
+    if event and hasattr(event, "action"):
+        event_type = "action"
+        try:
+            subtype = event.action.value
+        except Exception:
+            subtype = event.action
+    elif event and hasattr(event, "observation"):
+        event_type = "observation"
+        try:
+            subtype = event.observation.value
+        except Exception:
+            subtype = event.observation
+    if event_type and subtype:
+        span_name = f"event.{event_type}.{subtype}"
+        span_type = "EVENT"
+
+    # start trace on user message
+    if is_user_message(event):
+        user_message = event.content if hasattr(event, "content") else ""
+        start_event = True
+    # end trace on agent state change to finished or error
+    if is_agent_state_changed_to(event, "stopped") or is_agent_state_changed_to(
+        event, "awaiting_user_input"
+    ):
+        finish_event = True
+
+    if is_agent_state_changed_to(event, "user_rejected"):
+        agent_message = "<user_rejected>"
+
+    if is_agent_message(event):
+        agent_message = event.content if hasattr(event, "content") else ""
+
+    if start_event:
+        if controller_id in parent_spans:
+            logger.debug(
+                "Received a message, but already have a span for this trace. Resetting span."
+            )
+            parent_spans[controller_id].end()
+            del parent_spans[controller_id]
+        parent_span = Laminar.start_span("conversation.turn", span_type="DEFAULT")
+        if user_id:
+            parent_span.set_attribute(f"{ASSOCIATION_PROPERTIES}.{USER_ID}", user_id)
+        if user_message:
+            parent_span.set_attribute("lmnr.span.input", user_message)
+        parent_span.set_attribute(
+            f"{ASSOCIATION_PROPERTIES}.{SESSION_ID}", controller_id
+        )
+        parent_spans[controller_id] = parent_span
+
+    if controller_id in parent_spans:
+        with Laminar.use_span(parent_spans[controller_id]):
+            result = _wrap_sync_method_inner(
+                tracer,
+                {**to_wrap, "span_name": span_name, "span_type": span_type},
+                wrapped,
+                instance,
+                args,
+                kwargs,
+            )
+            if agent_message:
+                parent_spans[controller_id].set_attribute(
+                    "lmnr.span.output", agent_message
+                )
+            if finish_event:
+                parent_spans[controller_id].end()
+                del parent_spans[controller_id]
+            return result
+
+    return wrapped(*args, **kwargs)
+
+
+@_with_tracer_wrapper
+async def _wrap_handle_action(tracer: Tracer, to_wrap, wrapped, instance, args, kwargs):
+    """Wrapper for on_event."""
+    event = kwargs.get("event", args[0] if len(args) > 0 else None)
+    if event and hasattr(event, "action"):
+        if event.action == "system":
+            return await wrapped(*args, **kwargs)
+    action_name = get_handle_action_action(event)
+    if action_name and action_name != "message":
+        to_wrap["span_name"] = f"action.{action_name}"
+    controller_id = instance.id
+    if controller_id not in parent_spans:
+        return await wrapped(*args, **kwargs)
+    return await _wrap_async_method_inner(
+        tracer, to_wrap, wrapped, instance, args, kwargs
+    )
+
+
+def _wrap_sync_method_inner(tracer: Tracer, to_wrap, wrapped, instance, args, kwargs):
+    """Wrapper for synchronous methods."""
+    span_name = to_wrap.get("span_name")
+
+    with Laminar.start_as_current_span(
+        span_name,
+        span_type=to_wrap.get("span_type", "DEFAULT"),
+        input=json_dumps(
+            get_input_from_func_args(
+                wrapped, to_wrap.get("object") is not None, args, kwargs
+            )
+        ),
+    ) as span:
+        try:
+            result = wrapped(*args, **kwargs)
+
+            # Capture output
+            if not to_wrap.get("ignore_output"):
+                span.set_attribute("lmnr.span.output", json_dumps(result))
+            return result
+
+        except Exception as e:
+            span.record_exception(e)
+            raise
+
+
+@_with_tracer_wrapper
+def _wrap_sync_method(tracer: Tracer, to_wrap, wrapped, instance, args, kwargs):
+    instance_id = None
+    if to_wrap.get("object") == "AgentController":
+        instance_id = instance.id
+    if to_wrap.get("object") == "ActionExecutionClient" and hasattr(instance, "sid"):
+        instance_id = instance.sid
+    if instance_id is not None and instance_id not in parent_spans:
+        return wrapped(*args, **kwargs)
+    return _wrap_sync_method_inner(tracer, to_wrap, wrapped, instance, args, kwargs)
+
+
+async def _wrap_async_method_inner(
+    tracer: Tracer, to_wrap, wrapped, instance, args, kwargs
+):
+    """Wrapper for asynchronous methods."""
+    span_name = to_wrap.get("span_name")
+    instance_id = None
+    if to_wrap.get("object") == "AgentController":
+        instance_id = instance.id
+    if to_wrap.get("object") == "ActionExecutionClient" and hasattr(instance, "sid"):
+        instance_id = instance.sid
+    if instance_id is not None and instance_id not in parent_spans:
+        return await wrapped(*args, **kwargs)
+
+    with Laminar.start_as_current_span(
+        span_name,
+        span_type=to_wrap.get("span_type", "DEFAULT"),
+        input=json_dumps(
+            get_input_from_func_args(
+                wrapped, to_wrap.get("object") is not None, args, kwargs
+            )
+        ),
+    ) as span:
+        try:
+            result = await wrapped(*args, **kwargs)
+
+            # Capture output
+            if not to_wrap.get("ignore_output"):
+                span.set_attribute("lmnr.span.output", json_dumps(result))
+            return result
+
+        except Exception as e:
+            span.record_exception(e)
+            raise
+
+
+@_with_tracer_wrapper
+async def _wrap_async_method(tracer: Tracer, to_wrap, wrapped, instance, args, kwargs):
+    """Wrapper for asynchronous methods."""
+    return await _wrap_async_method_inner(
+        tracer, to_wrap, wrapped, instance, args, kwargs
+    )
+
+
+class OpenHandsInstrumentor(BaseInstrumentor):
+    """An instrumentor for OpenHands AI."""
+
+    def __init__(self):
+        super().__init__()
+
+    def instrumentation_dependencies(self) -> Collection[str]:
+        return _instruments
+
+    def _instrument(self, **kwargs):
+        """Instrument OpenHands AI methods."""
+        tracer_provider = kwargs.get("tracer_provider")
+        tracer = get_tracer(__name__, __version__, tracer_provider)
+
+        for wrapped_config in WRAPPED_METHODS:
+            wrap_package = wrapped_config.get("package")
+
+            wrap_object = wrapped_config.get("object")
+            methods = wrapped_config.get("methods", [])
+
+            for method_config in methods:
+
+                wrap_method = method_config.get("method")
+                async_wrap = method_config.get("async", False)
+                windows_only = method_config.get("windows_only", False)
+                if windows_only and sys.platform != "win32":
+                    continue
+
+                # Create the method configuration for the wrapper
+                method_wrapper_config = {
+                    "package": wrap_package,
+                    "object": wrap_object,
+                    "method": wrap_method,
+                    "span_name": method_config.get(
+                        "span_name",
+                        f"{wrap_object}.{wrap_method}" if wrap_object else wrap_method,
+                    ),
+                    "span_type": method_config.get("span_type", "DEFAULT"),
+                    "async": async_wrap,
+                }
+
+                # Determine the target for wrapping
+                if wrap_object:
+                    target = f"{wrap_object}.{wrap_method}"
+                else:
+                    target = wrap_method
+
+                if wrap_object == "AgentController" and wrap_method == "on_event":
+                    wrap_function_wrapper(
+                        wrap_package,
+                        target,
+                        _wrap_on_event(tracer, method_wrapper_config),
+                    )
+                    continue
+                if wrap_object == "AgentController" and wrap_method == "_handle_action":
+                    wrap_function_wrapper(
+                        wrap_package,
+                        target,
+                        _wrap_handle_action(tracer, method_wrapper_config),
+                    )
+                    continue
+
+                try:
+                    if async_wrap:
+                        wrap_function_wrapper(
+                            wrap_package,
+                            target,
+                            _wrap_async_method(tracer, method_wrapper_config),
+                        )
+                    else:
+                        wrap_function_wrapper(
+                            wrap_package,
+                            target,
+                            _wrap_sync_method(tracer, method_wrapper_config),
+                        )
+                except (ModuleNotFoundError, AttributeError) as e:
+                    logger.debug(f"Could not instrument {wrap_package}.{target}: {e}")
+
+    def _uninstrument(self, **kwargs):
+        """Remove OpenHands AI instrumentation."""
+        for wrapped_config in WRAPPED_METHODS:
+            wrap_package = wrapped_config.get("package")
+            wrap_object = wrapped_config.get("object")
+            methods = wrapped_config.get("methods", [])
+
+            for method_config in methods:
+                wrap_method = method_config.get("method")
+
+                # Determine the module path for unwrapping
+                if wrap_object:
+                    module_path = f"{wrap_package}.{wrap_object}"
+                else:
+                    module_path = wrap_package
+
+                try:
+                    unwrap(module_path, wrap_method)
+                except (AttributeError, ValueError) as e:
+                    logger.debug(
+                        f"Could not uninstrument {module_path}.{wrap_method}: {e}"
+                    )

lmnr/opentelemetry_lib/tracing/_instrument_initializers.py

@@ -268,6 +268,15 @@ class OpenAIInstrumentorInitializer(InstrumentorInitializer):
         )
 
 
+class OpenHandsAIInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(self, *args, **kwargs) -> BaseInstrumentor | None:
+        if not is_package_installed("openhands-ai"):
+            return None
+        from ..opentelemetry.instrumentation.openhands_ai import OpenHandsInstrumentor
+
+        return OpenHandsInstrumentor()
+
+
 class OpenTelemetryInstrumentorInitializer(InstrumentorInitializer):
     def init_instrumentor(self, *args, **kwargs) -> BaseInstrumentor | None:
         from ..opentelemetry.instrumentation.opentelemetry import (

lmnr/opentelemetry_lib/tracing/instruments.py

@@ -33,6 +33,7 @@ class Instruments(Enum):
     MISTRAL = "mistral"
     OLLAMA = "ollama"
     OPENAI = "openai"
+    OPENHANDS = "openhands"
     # Patch OpenTelemetry to fix DataDog's broken Span context
     # See lmnr.opentelemetry_lib.opentelemetry.instrumentation.opentelemetry
     # for more details.
@@ -75,6 +76,7 @@ INSTRUMENTATION_INITIALIZERS: dict[
     Instruments.MISTRAL: initializers.MistralInstrumentorInitializer(),
     Instruments.OLLAMA: initializers.OllamaInstrumentorInitializer(),
     Instruments.OPENAI: initializers.OpenAIInstrumentorInitializer(),
+    Instruments.OPENHANDS: initializers.OpenHandsAIInstrumentorInitializer(),
     Instruments.OPENTELEMETRY: initializers.OpenTelemetryInstrumentorInitializer(),
     Instruments.PATCHRIGHT: initializers.PatchrightInstrumentorInitializer(),
     Instruments.PINECONE: initializers.PineconeInstrumentorInitializer(),

lmnr/opentelemetry_lib/utils/wrappers.py

@@ -0,0 +1,11 @@
+# TODO: Remove the same thing from openai, anthropic, etc, and use this instead
+
+
+def _with_tracer_wrapper(func):
+    def _with_tracer(tracer, to_wrap):
+        def wrapper(wrapped, instance, args, kwargs):
+            return func(tracer, to_wrap, wrapped, instance, args, kwargs)
+
+        return wrapper
+
+    return _with_tracer

lmnr/sdk/browser/playwright_otel.py

@@ -154,6 +154,26 @@ async def _wrap_bring_to_front_async(
     await take_full_snapshot_async(instance)
 
 
+@with_tracer_and_client_wrapper
+def _wrap_browser_new_page_sync(
+    tracer: Tracer, client: LaminarClient, to_wrap, wrapped, instance, args, kwargs
+):
+    page = wrapped(*args, **kwargs)
+    session_id = str(uuid.uuid4().hex)
+    start_recording_events_sync(page, session_id, client)
+    return page
+
+
+@with_tracer_and_client_wrapper
+async def _wrap_browser_new_page_async(
+    tracer: Tracer, client: AsyncLaminarClient, to_wrap, wrapped, instance, args, kwargs
+):
+    page = await wrapped(*args, **kwargs)
+    session_id = str(uuid.uuid4().hex)
+    await start_recording_events_async(page, session_id, client)
+    return page
+
+
 WRAPPED_METHODS = [
     {
         "package": "playwright.sync_api",
@@ -191,6 +211,12 @@ WRAPPED_METHODS = [
         "method": "bring_to_front",
         "wrapper": _wrap_bring_to_front_sync,
     },
+    {
+        "package": "playwright.sync_api",
+        "object": "Browser",
+        "method": "new_page",
+        "wrapper": _wrap_browser_new_page_sync,
+    },
 ]
 
 WRAPPED_METHODS_ASYNC = [
@@ -230,6 +256,12 @@ WRAPPED_METHODS_ASYNC = [
         "method": "bring_to_front",
         "wrapper": _wrap_bring_to_front_async,
     },
+    {
+        "package": "playwright.async_api",
+        "object": "Browser",
+        "method": "new_page",
+        "wrapper": _wrap_browser_new_page_async,
+    },
 ]
 
 

lmnr/sdk/utils.py

@@ -132,13 +132,13 @@ def is_otel_attribute_value_type(value: typing.Any) -> bool:
 
 def format_id(id_value: str | int | uuid.UUID) -> str:
     """Format trace/span/evaluation ID to a UUID string, or return valid UUID strings as-is.
-    
+
     Args:
         id_value: The ID in various formats (UUID, int, or valid UUID string)
-        
+
     Returns:
         str: UUID string representation
-        
+
     Raises:
         ValueError: If id_value cannot be converted to a valid UUID
     """

lmnr/version.py

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

{lmnr-0.7.6.dist-info → lmnr-0.7.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lmnr
-Version: 0.7.6
+Version: 0.7.8
 Summary: Python SDK for Laminar
 Author: lmnr.ai
 Author-email: lmnr.ai <founders@lmnr.ai>

{lmnr-0.7.6.dist-info → lmnr-0.7.8.dist-info}/RECORD

@@ -2,8 +2,8 @@ lmnr/__init__.py,sha256=8be7b56ab62735fd54ca90a0642784c6153ed1d6e0f12734619ca061
 lmnr/cli.py,sha256=b8780b51f37fe9e20db5495c41d3ad3837f6b48f408b09a58688d017850c0796,6047
 lmnr/opentelemetry_lib/.flake8,sha256=6c2c6e0e51b1dd8439e501ca3e21899277076a787da868d0254ba37056b79405,150
 lmnr/opentelemetry_lib/__init__.py,sha256=1350e8d12ea2f422751ab3a80d7d32d10c27ad8e4c2989407771dc6e544d9c65,2350
-lmnr/opentelemetry_lib/decorators/__init__.py,sha256=e2ddd9252e0f3d82601081d655342af56413e09dc827ac07f66b51d3b575156e,11814
-lmnr/opentelemetry_lib/litellm/__init__.py,sha256=c72a5d23eb14f03926e713b70acf2c67063f74678c2dfd5824f1bdbc8ce1900f,15723
+lmnr/opentelemetry_lib/decorators/__init__.py,sha256=b9bab9acd44c7d4d98660a8de1f4e42b9387170c62e3239fba174a8461255ead,11795
+lmnr/opentelemetry_lib/litellm/__init__.py,sha256=d67d18581b42d7e5d9c724bd201044fb7a04d79e7162f5a47007c0a1f413141a,15852
 lmnr/opentelemetry_lib/litellm/utils.py,sha256=da8cf0553f82dc7203109f117a4c7b4185e8baf34caad12d7823875515201a27,539
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/anthropic/__init__.py,sha256=2604189b7598edb5404ddbcd0775bdf2dc506dd5e6319eef4e4724e39c420301,23276
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/anthropic/config.py,sha256=972919b821b9b7e5dc7cd191ba7e78b30b6efa5d63514e8cb301996d6386392c,369
@@ -13,7 +13,7 @@ lmnr/opentelemetry_lib/opentelemetry/instrumentation/anthropic/span_utils.py,sha
 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
+lmnr/opentelemetry_lib/opentelemetry/instrumentation/google_genai/__init__.py,sha256=1eab6773a3c89c207fe0b508555062872cbf37674183a0eb4ed7e20785cef870,20701
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/google_genai/config.py,sha256=db9cdebc9ee0dccb493ffe608eede3047efec20ed26c3924b72b2e50edbd92c2,245
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/google_genai/schema_utils.py,sha256=857a6bc52f8bfd4da72786173615d31faaf3f9378f8f6150ffe8f6f9c4bb78f9,685
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/google_genai/utils.py,sha256=f1248196246826d899304e510c4c2df74088d8169d28f1d0aed578a7a6c3cbfd,7669
@@ -35,27 +35,29 @@ lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/shared/embeddings_wr
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/shared/event_emitter.py,sha256=9c96455b5ca2064dd3a9fb570d78b14ebbdf3d02f8e33255ee9e301c31336c9e,3043
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/shared/event_models.py,sha256=3c27c21b1aeb02bc19a91fb8c05717ae1c10ab4b01300c664aba42e0f50cb5a3,876
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/shared/image_gen_wrappers.py,sha256=9650a0e4ad2d3bfb2a072590da189bcf4f807aca070945af26a9f9b99d779b77,2021
-lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/utils.py,sha256=541e94d60c94b8a8035ee74cda00ca3576a3f50a215df03d948de58665dbc25b,4649
+lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/utils.py,sha256=6b7ebc420e76c266f723248463c09175f536e10166015db12075e5e05f1c0f51,4651
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/v0/__init__.py,sha256=7f43421e052bd8f64d5d5b03170a3b7187c2ce038362fa15b5d1d0c43bc1a40d,6143
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/v1/__init__.py,sha256=7bdbf691ac89efb42ade686b7dbe69bd139a84f48482a013b7b68d3baa5b9c98,13527
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/v1/assistant_wrappers.py,sha256=558036c734559b3526647c1b18cfb986699e8fb322855af72ea054c2e458f721,10404
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/v1/event_handler_wrapper.py,sha256=4809cde003e5892822828b373aa3e43a8adbaee4ff443f198401003f43c15e8a,4366
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/v1/responses_wrappers.py,sha256=b3853c60c58a36ba64de184211ac2d112bb8b53c4af62f0fc716fb87d168fd4b,24790
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/version.py,sha256=4f39aaa913f3e49b0c174bc23028687d00bfaffc745bd3fe241e0ae6b442bed1,24
+lmnr/opentelemetry_lib/opentelemetry/instrumentation/openhands_ai/__init__.py,sha256=8f5f73528e1e0ced28938cbedf5b9774b408e178ae42191284f4630d0aa99beb,13648
 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=b96aee7590af1853fffc4c3d8ce9127a67e1ce589f695a99aabe6b37d70b0e48,10203
-lmnr/opentelemetry_lib/tracing/_instrument_initializers.py,sha256=dfeace460aa0daceb34266f93321acdce6b61847ad2113f428a8cd9493a93a55,14830
+lmnr/opentelemetry_lib/tracing/_instrument_initializers.py,sha256=f66dbe208fc1bd4075c0725561f6151a4c7622e6ecfa961b7ad6674d18dfb97f,15180
 lmnr/opentelemetry_lib/tracing/attributes.py,sha256=a879e337ff4e8569a4454544d303ccbc3b04bd42e1cdb765eb563aeaa08f731d,1653
 lmnr/opentelemetry_lib/tracing/context.py,sha256=83f842be0fc29a96647cbf005c39ea761b0fb5913c4102f965411f47906a6135,4103
 lmnr/opentelemetry_lib/tracing/exporter.py,sha256=6af8e61fd873e8f5db315d9b9f1edbf46b860ba7e50140f0bdcc6864c6d35a03,2082
-lmnr/opentelemetry_lib/tracing/instruments.py,sha256=993c5e4a827f0828ad4ee1ac9b18a2220e1b271a051ec05974f73cf82f48d172,5512
+lmnr/opentelemetry_lib/tracing/instruments.py,sha256=950c351bbc05a7665e6c0eb0ed1bafc1b4b2a037ed1086786ec8496802ecef2e,5618
 lmnr/opentelemetry_lib/tracing/processor.py,sha256=cbc70f138e70c878ef57b02a2c46ef48dd7f694a522623a82dff1623b73d1e1c,3353
 lmnr/opentelemetry_lib/tracing/tracer.py,sha256=33769a9a97385f5697eb0e0a6b1813a57ed956c7a8379d7ac2523e700e7dd528,1362
 lmnr/opentelemetry_lib/utils/__init__.py,sha256=a4d85fd06def4dde5c728734de2d4c5c36eb89c49a8aa09b8b50cb5a149e90af,604
 lmnr/opentelemetry_lib/utils/json_encoder.py,sha256=74ae9bfdac6bef42182fb56ff9bbb8c27b6f0c3bb29eda2ab0769d76a5fb3f9f,463
 lmnr/opentelemetry_lib/utils/package_check.py,sha256=f8274186c96815c996a25fae06bf913f0bb7c835507739949f37c03bbe5d9ca9,527
+lmnr/opentelemetry_lib/utils/wrappers.py,sha256=f7b1134809f2c408976a71e661fee5cb1aad172f4467846994205a60bf994e9f,330
 lmnr/py.typed,sha256=e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855,0
 lmnr/sdk/__init__.py,sha256=e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855,0
 lmnr/sdk/browser/__init__.py,sha256=e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855,0
@@ -63,7 +65,7 @@ lmnr/sdk/browser/browser_use_cdp_otel.py,sha256=aa14e3ea7bd0980a4b1fc2d9a5d40d38
 lmnr/sdk/browser/browser_use_otel.py,sha256=e5549878c07bad451efef9f460ce52202284cff50075bce700ca61749102c5eb,5065
 lmnr/sdk/browser/cdp_utils.py,sha256=3f43e4b9958e752b1b9aa0a3ae6321ef9e1cb66b3f4ca07990584b2c60c17a97,26103
 lmnr/sdk/browser/patchright_otel.py,sha256=9d22ab1f28f1eddbcfd0032a14fe306bfe00bfc7f11128cb99836c4dd15fb7c8,4800
-lmnr/sdk/browser/playwright_otel.py,sha256=50c0a5a75155a3a7ff5db84790ffb409c9cbd0351eef212d83d923893730223b,9459
+lmnr/sdk/browser/playwright_otel.py,sha256=859d220d856c8fe7104863efca0c6a3ed5464d778675e07d7f79c48f73d5e838,10416
 lmnr/sdk/browser/pw_utils.py,sha256=a75769eb977d8e56c38a0eefad09b87550b872f8d4df186b36a8c4d4af2bffaf,29021
 lmnr/sdk/browser/recorder/record.umd.min.cjs,sha256=f09c09052c2fc474efb0405e63d8d26ed2184b994513ce8aee04efdac8be155d,181235
 lmnr/sdk/browser/utils.py,sha256=4a668776d2938108d25fbcecd61c8e1710a4da3e56230d5fefca5964dd09e3c1,2371
@@ -90,9 +92,9 @@ lmnr/sdk/evaluations.py,sha256=895d0b1af77395bddfbf69388679eb03f8f4d2ef03facab27
 lmnr/sdk/laminar.py,sha256=24d680407ce694f1a7ec0e9c0524eae3deb7d638ad5caff3a591ddf7963ad480,37533
 lmnr/sdk/log.py,sha256=9edfd83263f0d4845b1b2d1beeae2b4ed3f8628de941f371a893d72b79c348d4,2213
 lmnr/sdk/types.py,sha256=f8a8368e225c4d2f82df54d92f029065afb60c3eff494c77c6e574963ed524ff,13454
-lmnr/sdk/utils.py,sha256=4beb884ae6fbbc7d8cf639b036b726ea6a2a658f0a6386faf5735a13d706a2d8,5039
-lmnr/version.py,sha256=d3747c091ad12262da3123ec8cd3a9ecdd8ee197c270773b4953d9fb342c6c0c,1321
-lmnr-0.7.6.dist-info/WHEEL,sha256=ab6157bc637547491fb4567cd7ddf26b04d63382916ca16c29a5c8e94c9c9ef7,79
-lmnr-0.7.6.dist-info/entry_points.txt,sha256=abdf3411b7dd2d7329a241f2da6669bab4e314a747a586ecdb9f888f3035003c,39
-lmnr-0.7.6.dist-info/METADATA,sha256=2224332cbdca13b77e0b54b575efcc7d7923957dfabc51dfbe9f3988f8bd1ef9,14196
-lmnr-0.7.6.dist-info/RECORD,,
+lmnr/sdk/utils.py,sha256=0c5a81c305dcd3922f4b31c4f42cf83719c03888725838395adae167de92db76,5019
+lmnr/version.py,sha256=fafd83a5d984558d181b537237ee4ba4e9ccbad408b74e243065597b77580152,1321
+lmnr-0.7.8.dist-info/WHEEL,sha256=ab6157bc637547491fb4567cd7ddf26b04d63382916ca16c29a5c8e94c9c9ef7,79
+lmnr-0.7.8.dist-info/entry_points.txt,sha256=abdf3411b7dd2d7329a241f2da6669bab4e314a747a586ecdb9f888f3035003c,39
+lmnr-0.7.8.dist-info/METADATA,sha256=272987c3279723e7609210aef23cf45f706ecd6750fc45d6a0e08d409302acf0,14196
+lmnr-0.7.8.dist-info/RECORD,,