lmnr 0.5.2__py3-none-any.whl → 0.6.0__py3-none-any.whl

lmnr/sdk/client/asynchronous/resources/agent.py

@@ -40,11 +40,13 @@ class AsyncAgent(BaseAsyncResource):
         return_screenshots: bool = False,
         return_agent_state: bool = False,
         return_storage_state: bool = False,
+        disable_give_control: bool = False,
         timeout: Optional[int] = None,
         cdp_url: Optional[str] = None,
         max_steps: Optional[int] = None,
         thinking_token_budget: Optional[int] = None,
         start_url: Optional[str] = None,
+        user_agent: Optional[str] = None,
     ) -> AsyncIterator[RunAgentResponseChunk]:
         """Run Laminar index agent in streaming mode.
 
@@ -60,11 +62,13 @@ class AsyncAgent(BaseAsyncResource):
             return_screenshots (bool, optional): whether to return screenshots of the agent's states at every step. Default to False.
             return_agent_state (bool, optional): whether to return the agent's state in the final chunk. Default to False.
             return_storage_state (bool, optional): whether to return the storage state in the final chunk. Default to False.
+            disable_give_control (bool, optional): whether to NOT give the agent additional direction to give control to the user for tasks such as login. Default to False.
             timeout (Optional[int], optional): timeout seconds for the agent's response. Default to None.
             cdp_url (Optional[str], optional): Chrome DevTools Protocol URL of an existing browser session. Default to None.
             max_steps (Optional[int], optional): maximum number of steps the agent can take. If not set, the backend will use a default value (currently 100). Default to None.
             thinking_token_budget (Optional[int], optional): maximum number of tokens the underlying LLM can spend on thinking in each step, if supported by the model. Default to None.
             start_url (Optional[str], optional): the URL to start the agent on. Must be a valid URL - refer to https://playwright.dev/docs/api/class-page#page-goto. If not specified, the agent infers this from the prompt. Default to None.
+            user_agent (Optional[str], optional): the user to be sent to the browser. If not specified, Laminar uses the default user agent. Default to None.
 
         Returns:
             AsyncIterator[RunAgentResponseChunk]: a generator of response chunks
@@ -84,11 +88,13 @@ class AsyncAgent(BaseAsyncResource):
         return_screenshots: bool = False,
         return_agent_state: bool = False,
         return_storage_state: bool = False,
+        disable_give_control: bool = False,
         timeout: Optional[int] = None,
         cdp_url: Optional[str] = None,
         max_steps: Optional[int] = None,
         thinking_token_budget: Optional[int] = None,
         start_url: Optional[str] = None,
+        user_agent: Optional[str] = None,
     ) -> AgentOutput:
         """Run Laminar index agent.
 
@@ -103,11 +109,13 @@ class AsyncAgent(BaseAsyncResource):
             return_screenshots (bool, optional): whether to return screenshots of the agent's states at every step. Default to False.
             return_agent_state (bool, optional): whether to return the agent's state. Default to False.
             return_storage_state (bool, optional): whether to return the storage state. Default to False.
+            disable_give_control (bool, optional): whether to NOT give the agent additional direction to give control to the user for tasks such as login. Default to False.
             timeout (Optional[int], optional): timeout seconds for the agent's response. Default to None.
             cdp_url (Optional[str], optional): Chrome DevTools Protocol URL of an existing browser session. Default to None.
             max_steps (Optional[int], optional): maximum number of steps the agent can take. If not set, the backend will use a default value (currently 100). Default to None.
             thinking_token_budget (Optional[int], optional): maximum number of tokens the underlying LLM can spend on thinking in each step, if supported by the model. Default to None.
             start_url (Optional[str], optional): the URL to start the agent on. Must be a valid URL - refer to https://playwright.dev/docs/api/class-page#page-goto. If not specified, the agent infers this from the prompt. Default to None.
+            user_agent (Optional[str], optional): the user to be sent to the browser. If not specified, Laminar uses the default user agent. Default to None.
 
         Returns:
             AgentOutput: agent output
@@ -128,10 +136,12 @@ class AsyncAgent(BaseAsyncResource):
         return_screenshots: bool = False,
         return_agent_state: bool = False,
         return_storage_state: bool = False,
+        disable_give_control: bool = False,
         timeout: Optional[int] = None,
         max_steps: Optional[int] = None,
         thinking_token_budget: Optional[int] = None,
         start_url: Optional[str] = None,
+        user_agent: Optional[str] = None,
     ) -> AgentOutput:
         """Run Laminar index agent.
 
@@ -147,11 +157,14 @@ class AsyncAgent(BaseAsyncResource):
             return_screenshots (bool, optional): whether to return screenshots of the agent's states at every step. Default to False.
             return_agent_state (bool, optional): whether to return the agent's state. Default to False.
             return_storage_state (bool, optional): whether to return the storage state. Default to False.
+            disable_give_control (bool, optional): whether to NOT give the agent additional direction to give control to the user for tasks such as login. Default to False.
             timeout (Optional[int], optional): timeout seconds for the agent's response. Default to None.
             cdp_url (Optional[str], optional): Chrome DevTools Protocol URL of an existing browser session. Default to None.
             max_steps (Optional[int], optional): maximum number of steps the agent can take. If not set, the backend will use a default value (currently 100). Default to None.
             thinking_token_budget (Optional[int], optional): maximum number of tokens the underlying LLM can spend on thinking in each step, if supported by the model. Default to None.
             start_url (Optional[str], optional): the URL to start the agent on. Must be a valid URL - refer to https://playwright.dev/docs/api/class-page#page-goto. If not specified, the agent infers this from the prompt. Default to None.
+            user_agent (Optional[str], optional): the user to be sent to the browser. If not specified, Laminar uses the default user agent. Default to None.
+
         Returns:
             AgentOutput: agent output
         """
@@ -170,11 +183,13 @@ class AsyncAgent(BaseAsyncResource):
         return_screenshots: bool = False,
         return_agent_state: bool = False,
         return_storage_state: bool = False,
+        disable_give_control: bool = False,
         timeout: Optional[int] = None,
         cdp_url: Optional[str] = None,
         max_steps: Optional[int] = None,
         thinking_token_budget: Optional[int] = None,
         start_url: Optional[str] = None,
+        user_agent: Optional[str] = None,
     ) -> Union[AgentOutput, Awaitable[AsyncIterator[RunAgentResponseChunk]]]:
         """Run Laminar index agent.
 
@@ -190,11 +205,13 @@ class AsyncAgent(BaseAsyncResource):
             return_screenshots (bool, optional): whether to return screenshots of the agent's states at every step. Default to False.
             return_agent_state (bool, optional): whether to return the agent's state. Default to False.
             return_storage_state (bool, optional): whether to return the storage state. Default to False.
+            disable_give_control (bool, optional): whether to NOT give the agent additional direction to give control to the user for tasks such as login. Default to False.
             timeout (Optional[int], optional): timeout seconds for the agent's response. Default to None.
             cdp_url (Optional[str], optional): Chrome DevTools Protocol URL of an existing browser session. Default to None.
             max_steps (Optional[int], optional): maximum number of steps the agent can take. If not set, the backend will use a default value (currently 100). Default to None.
             thinking_token_budget (Optional[int], optional): maximum number of tokens the underlying LLM can spend on thinking in each step, if supported by the model. Default to None.
             start_url (Optional[str], optional): the URL to start the agent on. Must be a valid URL - refer to https://playwright.dev/docs/api/class-page#page-goto. If not specified, the agent infers this from the prompt. Default to None.
+            user_agent (Optional[str], optional): the user to be sent to the browser. If not specified, Laminar uses the default user agent. Default to None.
 
         Returns:
             Union[AgentOutput, AsyncIterator[RunAgentResponseChunk]]: agent output or a generator of response chunks
@@ -228,6 +245,8 @@ class AsyncAgent(BaseAsyncResource):
             return_screenshots=return_screenshots,
             return_agent_state=return_agent_state,
             return_storage_state=return_storage_state,
+            disable_give_control=disable_give_control,
+            user_agent=user_agent,
             timeout=timeout,
             cdp_url=cdp_url,
             max_steps=max_steps,
@@ -259,6 +278,8 @@ class AsyncAgent(BaseAsyncResource):
             json=request.model_dump(by_alias=True),
             headers=self._headers(),
         ) as response:
+            if response.status_code != 200:
+                raise RuntimeError(await response.read())
             async for line in response.aiter_lines():
                 line = str(line)
                 if line.startswith("[DONE]"):
@@ -269,7 +290,7 @@ class AsyncAgent(BaseAsyncResource):
                 if line:
                     chunk = RunAgentResponseChunk.model_validate_json(line)
                     yield chunk.root
-                    if chunk.root.chunk_type in ["finalOutput", "error"]:
+                    if chunk.root.chunk_type in ["finalOutput", "error", "timeout"]:
                         break
 
     async def __run_non_streaming(self, request: RunAgentRequest) -> AgentOutput:

lmnr/sdk/client/synchronous/resources/agent.py

@@ -32,11 +32,13 @@ class Agent(BaseResource):
         return_screenshots: bool = False,
         return_agent_state: bool = False,
         return_storage_state: bool = False,
+        disable_give_control: bool = False,
         timeout: Optional[int] = None,
         cdp_url: Optional[str] = None,
         max_steps: Optional[int] = None,
         thinking_token_budget: Optional[int] = None,
         start_url: Optional[str] = None,
+        user_agent: Optional[str] = None,
     ) -> Generator[RunAgentResponseChunk, None, None]:
         """Run Laminar index agent in streaming mode.
 
@@ -52,11 +54,13 @@ class Agent(BaseResource):
             return_screenshots (bool, optional): whether to return screenshots of the agent's states at every step. Default to False.
             return_agent_state (bool, optional): whether to return the agent's state. Default to False.
             return_storage_state (bool, optional): whether to return the storage state. Default to False.
+            disable_give_control (bool, optional): whether to NOT give the agent additional direction to give control to the user for tasks such as login. Default to False.
             timeout (Optional[int], optional): timeout seconds for the agent's response. Default to None.
             cdp_url (Optional[str], optional): Chrome DevTools Protocol URL of an existing browser session. Default to None.
             max_steps (Optional[int], optional): maximum number of steps the agent can take. If not set, the backend will use a default value (currently 100). Default to None.
             thinking_token_budget (Optional[int], optional): maximum number of tokens the underlying LLM can spend on thinking in each step, if supported by the model. Default to None.
             start_url (Optional[str], optional): the URL to start the agent on. Must be a valid URL - refer to https://playwright.dev/docs/api/class-page#page-goto. If not specified, the agent infers this from the prompt. Default to None.
+            user_agent (Optional[str], optional): the user to be sent to the browser. If not specified, Laminar uses the default user agent. Default to None.
         Returns:
             Generator[RunAgentResponseChunk, None, None]: a generator of response chunks
         """
@@ -74,12 +78,14 @@ class Agent(BaseResource):
         storage_state: Optional[str] = None,
         return_screenshots: bool = False,
         return_agent_state: bool = False,
+        disable_give_control: bool = False,
         return_storage_state: bool = False,
         timeout: Optional[int] = None,
         cdp_url: Optional[str] = None,
         max_steps: Optional[int] = None,
         thinking_token_budget: Optional[int] = None,
         start_url: Optional[str] = None,
+        user_agent: Optional[str] = None,
     ) -> AgentOutput:
         """Run Laminar index agent.
 
@@ -94,11 +100,14 @@ class Agent(BaseResource):
             return_screenshots (bool, optional): whether to return screenshots of the agent's states at every step. Default to False.
             return_agent_state (bool, optional): whether to return the agent's state. Default to False.
             return_storage_state (bool, optional): whether to return the storage state. Default to False.
+            disable_give_control (bool, optional): whether to NOT give the agent additional direction to give control to the user for tasks such as login. Default to False.
             timeout (Optional[int], optional): timeout seconds for the agent's response. Default to None.
             cdp_url (Optional[str], optional): Chrome DevTools Protocol URL of an existing browser session. Default to None.
             max_steps (Optional[int], optional): maximum number of steps the agent can take. If not set, the backend will use a default value (currently 100). Default to None.
             thinking_token_budget (Optional[int], optional): maximum number of tokens the underlying LLM can spend on thinking in each step, if supported by the model. Default to None.
             start_url (Optional[str], optional): the URL to start the agent on. Must be a valid URL - refer to https://playwright.dev/docs/api/class-page#page-goto. If not specified, the agent infers this from the prompt. Default to None.
+            user_agent (Optional[str], optional): the user to be sent to the browser. If not specified, Laminar uses the default user agent. Default to None.
+
         Returns:
             AgentOutput: agent output
         """
@@ -118,11 +127,13 @@ class Agent(BaseResource):
         return_screenshots: bool = False,
         return_agent_state: bool = False,
         return_storage_state: bool = False,
+        disable_give_control: bool = False,
         timeout: Optional[int] = None,
         cdp_url: Optional[str] = None,
         max_steps: Optional[int] = None,
         thinking_token_budget: Optional[int] = None,
         start_url: Optional[str] = None,
+        user_agent: Optional[str] = None,
     ) -> AgentOutput:
         """Run Laminar index agent.
 
@@ -138,11 +149,14 @@ class Agent(BaseResource):
             return_screenshots (bool, optional): whether to return screenshots of the agent's states at every step. Default to False.
             return_agent_state (bool, optional): whether to return the agent's state. Default to False.
             return_storage_state (bool, optional): whether to return the storage state. Default to False.
+            disable_give_control (bool, optional): whether to NOT give the agent additional direction to give control to the user for tasks such as login. Default to False.
             timeout (Optional[int], optional): timeout seconds for the agent's response. Default to None.
             cdp_url (Optional[str], optional): Chrome DevTools Protocol URL of an existing browser session. Default to None.
             max_steps (Optional[int], optional): maximum number of steps the agent can take. If not set, the backend will use a default value (currently 100). Default to None.
             thinking_token_budget (Optional[int], optional): maximum number of tokens the underlying LLM can spend on thinking in each step, if supported by the model. Default to None.
             start_url (Optional[str], optional): the URL to start the agent on. Must be a valid URL - refer to https://playwright.dev/docs/api/class-page#page-goto. If not specified, the agent infers this from the prompt. Default to None.
+            user_agent (Optional[str], optional): the user to be sent to the browser. If not specified, Laminar uses the default user agent. Default to None.
+
         Returns:
             AgentOutput: agent output
         """
@@ -161,11 +175,13 @@ class Agent(BaseResource):
         return_screenshots: bool = False,
         return_agent_state: bool = False,
         return_storage_state: bool = False,
+        disable_give_control: bool = False,
         timeout: Optional[int] = None,
         cdp_url: Optional[str] = None,
         max_steps: Optional[int] = None,
         thinking_token_budget: Optional[int] = None,
         start_url: Optional[str] = None,
+        user_agent: Optional[str] = None,
     ) -> Union[AgentOutput, Generator[RunAgentResponseChunk, None, None]]:
         """Run Laminar index agent.
 
@@ -181,11 +197,13 @@ class Agent(BaseResource):
             return_screenshots (bool, optional): whether to return screenshots of the agent's states at every step. Default to False.
             return_agent_state (bool, optional): whether to return the agent's state. Default to False.
             return_storage_state (bool, optional): whether to return the storage state. Default to False.
+            disable_give_control (bool, optional): whether to NOT give the agent additional direction to give control to the user for tasks such as login. Default to False.
             timeout (Optional[int], optional): timeout seconds for the agent's response. Default to None.
             cdp_url (Optional[str], optional): Chrome DevTools Protocol URL of an existing browser session. Default to None.
             max_steps (Optional[int], optional): maximum number of steps the agent can take. If not set, the backend will use a default value (currently 100). Default to None.
             thinking_token_budget (Optional[int], optional): maximum number of tokens the underlying LLM can spend on thinking in each step, if supported by the model. Default to None.
             start_url (Optional[str], optional): the URL to start the agent on. Must be a valid URL - refer to https://playwright.dev/docs/api/class-page#page-goto. If not specified, the agent infers this from the prompt. Default to None.
+            user_agent (Optional[str], optional): the user to be sent to the browser. If not specified, Laminar uses the default user agent. Default to None.
 
         Returns:
             Union[AgentOutput, Generator[RunAgentResponseChunk, None, None]]: agent output or a generator of response chunks
@@ -224,6 +242,8 @@ class Agent(BaseResource):
             max_steps=max_steps,
             thinking_token_budget=thinking_token_budget,
             start_url=start_url,
+            disable_give_control=disable_give_control,
+            user_agent=user_agent,
         )
 
         # For streaming case, use a generator function
@@ -250,6 +270,8 @@ class Agent(BaseResource):
             json=request.model_dump(by_alias=True),
             headers=self._headers(),
         ) as response:
+            if response.status_code != 200:
+                raise RuntimeError(response.read())
             for line in response.iter_lines():
                 line = str(line)
                 if line.startswith("[DONE]"):
@@ -260,7 +282,7 @@ class Agent(BaseResource):
                 if line:
                     chunk = RunAgentResponseChunk.model_validate_json(line)
                     yield chunk.root
-                    if chunk.root.chunk_type in ["finalOutput", "error"]:
+                    if chunk.root.chunk_type in ["finalOutput", "error", "timeout"]:
                         break
 
     def __run_non_streaming(self, request: RunAgentRequest) -> AgentOutput:

lmnr/sdk/decorators.py

@@ -1,4 +1,4 @@
-from lmnr.openllmetry_sdk.decorators.base import (
+from lmnr.opentelemetry_lib.decorators import (
     entity_method,
     aentity_method,
 )
@@ -7,8 +7,10 @@ from opentelemetry.trace import INVALID_SPAN, get_current_span
 from typing import Callable, Literal, Optional, TypeVar, Union, cast
 from typing_extensions import ParamSpec
 
-from lmnr.openllmetry_sdk.tracing.attributes import SESSION_ID
-from lmnr.openllmetry_sdk.tracing.tracing import update_association_properties
+from lmnr.opentelemetry_lib.tracing.attributes import SESSION_ID
+from lmnr.opentelemetry_lib.tracing.context_properties import (
+    update_association_properties,
+)
 
 from .utils import is_async
 

lmnr/sdk/eval_control.py

@@ -1,4 +1,5 @@
 from contextvars import ContextVar
 
-PREPARE_ONLY = ContextVar("__lmnr_prepare_only", default=False)
-EVALUATION_INSTANCE = ContextVar("__lmnr_evaluation_instance", default=None)
+
+PREPARE_ONLY: ContextVar[bool] = ContextVar("__lmnr_prepare_only", default=False)
+EVALUATION_INSTANCE = ContextVar("__lmnr_evaluation_instance")

lmnr/sdk/evaluations.py

@@ -1,12 +1,12 @@
 import asyncio
 import re
 import uuid
-import dotenv
+
 from tqdm import tqdm
 from typing import Any, Awaitable, Optional, Set, Union
 
-from lmnr.openllmetry_sdk.instruments import Instruments
-from lmnr.openllmetry_sdk.tracing.attributes import SPAN_TYPE
+from lmnr.opentelemetry_lib.tracing.instruments import Instruments
+from lmnr.opentelemetry_lib.tracing.attributes import SPAN_TYPE
 
 from lmnr.sdk.client.asynchronous.async_client import AsyncLaminarClient
 from lmnr.sdk.client.synchronous.sync_client import LaminarClient
@@ -111,7 +111,7 @@ class Evaluation:
         trace_export_timeout_seconds: Optional[int] = None,
     ):
         """
-        Initializes an instance of the Evaluations class.
+        Initializes an instance of the Evaluation class.
 
         Parameters:
             data (Union[List[EvaluationDatapoint|dict], EvaluationDataset]):\
@@ -176,7 +176,6 @@ class Evaluation:
 
         base_url = base_url or from_env("LMNR_BASE_URL") or "https://api.lmnr.ai"
 
-        self.is_finished = False
         self.reporter = EvaluationReporter(base_url)
         if isinstance(data, list):
             self.data = [
@@ -196,12 +195,7 @@ class Evaluation:
         self.upload_tasks = []
         self.base_http_url = f"{base_url}:{http_port or 443}"
 
-        api_key = project_api_key
-        if not api_key:
-            dotenv_path = dotenv.find_dotenv(usecwd=True)
-            api_key = dotenv.get_key(
-                dotenv_path=dotenv_path, key_to_get="LMNR_PROJECT_API_KEY"
-            )
+        api_key = project_api_key or from_env("LMNR_PROJECT_API_KEY")
         if not api_key:
             raise ValueError(
                 "Please initialize the Laminar object with"
@@ -225,8 +219,6 @@ class Evaluation:
         )
 
     async def run(self) -> Awaitable[None]:
-        if self.is_finished:
-            raise Exception("Evaluation is already finished")
         return await self._run()
 
     async def _run(self) -> None:
@@ -253,17 +245,19 @@ class Evaluation:
                 self._logger.debug("All upload tasks completed")
         except Exception as e:
             self.reporter.stopWithError(e)
-            self.is_finished = True
             await self._shutdown()
             return
 
         average_scores = get_average_scores(result_datapoints)
         self.reporter.stop(average_scores, evaluation.projectId, evaluation.id)
-        self.is_finished = True
         await self._shutdown()
 
     async def _shutdown(self):
-        L.shutdown()
+        # We use flush() instead of shutdown() because multiple evaluations
+        # can be run sequentially in the same process. `shutdown()` would
+        # close the OTLP exporter and we wouldn't be able to export traces in
+        # the next evaluation.
+        L.flush()
         await self.client.close()
         if isinstance(self.data, LaminarDataset) and self.data.client:
             self.data.client.close()

lmnr/sdk/laminar.py

@@ -1,21 +1,17 @@
 from contextlib import contextmanager
 from contextvars import Context
-from lmnr.openllmetry_sdk import TracerManager
-from lmnr.openllmetry_sdk.instruments import Instruments
-from lmnr.openllmetry_sdk.tracing import get_tracer
-from lmnr.openllmetry_sdk.tracing.attributes import (
+from lmnr.opentelemetry_lib import TracerManager
+from lmnr.opentelemetry_lib.tracing.instruments import Instruments
+from lmnr.opentelemetry_lib.tracing.tracer import get_tracer
+from lmnr.opentelemetry_lib.tracing.attributes import (
     ASSOCIATION_PROPERTIES,
     Attributes,
     SPAN_TYPE,
 )
-from lmnr.openllmetry_sdk.config import MAX_MANUAL_SPAN_PAYLOAD_SIZE
-from lmnr.openllmetry_sdk.decorators.base import json_dumps
+from lmnr.opentelemetry_lib import MAX_MANUAL_SPAN_PAYLOAD_SIZE
+from lmnr.opentelemetry_lib.decorators import json_dumps
 from opentelemetry import context as context_api, trace
 from opentelemetry.context import attach, detach
-from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import (
-    OTLPSpanExporter,
-    Compression,
-)
 from opentelemetry.sdk.trace.id_generator import RandomIdGenerator
 from opentelemetry.util.types import AttributeValue
 
@@ -28,13 +24,13 @@ import os
 import re
 import uuid
 
-from lmnr.openllmetry_sdk.tracing.attributes import (
+from lmnr.opentelemetry_lib.tracing.attributes import (
     SESSION_ID,
     SPAN_INPUT,
     SPAN_OUTPUT,
     TRACE_TYPE,
 )
-from lmnr.openllmetry_sdk.tracing.tracing import (
+from lmnr.opentelemetry_lib.tracing.context_properties import (
     get_association_properties,
     remove_association_properties,
     set_association_properties,
@@ -52,8 +48,6 @@ from .types import (
 
 
 class Laminar:
-    __base_http_url: str
-    __base_grpc_url: str
     __project_api_key: Optional[str] = None
     __initialized: bool = False
 
@@ -116,6 +110,8 @@ class Laminar:
 
         url = base_url or from_env("LMNR_BASE_URL") or "https://api.lmnr.ai"
         url = url.rstrip("/")
+        if not url.startswith("http"):
+            url = f"https://{url}"
         if match := re.search(r":(\d{1,5})$", url):
             url = url[: -len(match.group(0))]
             if http_port is None:
@@ -124,36 +120,22 @@ class Laminar:
             else:
                 cls.__logger.info(f"Using HTTP port passed as an argument: {http_port}")
 
-        cls.__base_http_url = f"{url}:{http_port or 443}"
-        cls.__base_grpc_url = f"{url}:{grpc_port or 8443}"
-
         cls.__initialized = True
+
         if not os.getenv("OTEL_ATTRIBUTE_COUNT_LIMIT"):
             # each message is at least 2 attributes: role and content,
             # but the default attribute limit is 128, so raise it
             os.environ["OTEL_ATTRIBUTE_COUNT_LIMIT"] = "10000"
 
-        # if not is_latest_version():
-        #     cls.__logger.warning(
-        #         "You are using an older version of the Laminar SDK. "
-        #         f"Latest version: {get_latest_pypi_version()}, current version: {SDK_VERSION}.\n"
-        #         "Please update to the latest version by running "
-        #         "`pip install --upgrade lmnr`."
-        #     )
-
         TracerManager.init(
-            base_http_url=cls.__base_http_url,
+            base_url=url,
+            http_port=http_port or 443,
+            port=grpc_port or 8443,
             project_api_key=cls.__project_api_key,
-            exporter=OTLPSpanExporter(
-                endpoint=cls.__base_grpc_url,
-                headers={"authorization": f"Bearer {cls.__project_api_key}"},
-                compression=Compression.Gzip,
-                # default timeout is 10 seconds, increase it to 30 seconds
-                timeout=export_timeout_seconds or 30,
-            ),
             instruments=instruments,
             disable_batch=disable_batch,
             max_export_batch_size=max_export_batch_size,
+            timeout_seconds=export_timeout_seconds,
         )
 
     @classmethod
@@ -680,7 +662,7 @@ class Laminar:
         """Set the metadata for the current trace.
 
         Args:
-            metadata (dict[str, str]): Metadata to set for the trace. Willl be\
+            metadata (dict[str, str]): Metadata to set for the trace. Will be\
                 sent as attributes, so must be json serializable.
         """
         props = {f"metadata.{k}": json_dumps(v) for k, v in metadata.items()}

lmnr/sdk/types.py

@@ -249,6 +249,8 @@ class RunAgentRequest(pydantic.BaseModel):
     max_steps: Optional[int] = pydantic.Field(default=None)
     thinking_token_budget: Optional[int] = pydantic.Field(default=None)
     start_url: Optional[str] = pydantic.Field(default=None)
+    disable_give_control: bool = pydantic.Field(default=False)
+    user_agent: Optional[str] = pydantic.Field(default=None)
 
 
 class ActionResult(pydantic.BaseModel):

lmnr/sdk/utils.py

@@ -37,10 +37,9 @@ def is_async(func: typing.Callable) -> bool:
         return True
 
     # Fallback: check if the function's code object contains 'async'.
-    # This is for cases when a decorator did not properly use
+    # This is for cases when a decorator (not ours) did not properly use
     # `functools.wraps` or `functools.update_wrapper`
-    CO_COROUTINE = inspect.CO_COROUTINE
-    return (func.__code__.co_flags & CO_COROUTINE) != 0
+    return (func.__code__.co_flags & inspect.CO_COROUTINE) != 0
 
 
 def is_async_iterator(o: typing.Any) -> bool:

lmnr/version.py

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