lmnr 0.5.1a0__py3-none-any.whl → 0.5.3__py3-none-any.whl

lmnr/sdk/client/asynchronous/async_client.py

@@ -11,8 +11,6 @@ from lmnr.sdk.client.asynchronous.resources import (
     AsyncAgent,
     AsyncBrowserEvents,
     AsyncEvals,
-    AsyncPipeline,
-    AsyncSemanticSearch,
 )
 from lmnr.sdk.utils import from_env
 
@@ -66,12 +64,6 @@ class AsyncLaminarClient:
         )
 
         # Initialize resource objects
-        self.__pipeline = AsyncPipeline(
-            self.__client, self.__base_url, self.__project_api_key
-        )
-        self.__semantic_search = AsyncSemanticSearch(
-            self.__client, self.__base_url, self.__project_api_key
-        )
         self.__agent = AsyncAgent(
             self.__client, self.__base_url, self.__project_api_key
         )
@@ -82,24 +74,6 @@ class AsyncLaminarClient:
             self.__client, self.__base_url, self.__project_api_key
         )
 
-    @property
-    def pipeline(self) -> AsyncPipeline:
-        """Get the Pipeline resource.
-
-        Returns:
-            Pipeline: The Pipeline resource instance.
-        """
-        return self.__pipeline
-
-    @property
-    def semantic_search(self) -> AsyncSemanticSearch:
-        """Get the SemanticSearch resource.
-
-        Returns:
-            SemanticSearch: The SemanticSearch resource instance.
-        """
-        return self.__semantic_search
-
     @property
     def agent(self) -> AsyncAgent:
         """Get the Agent resource.
@@ -137,14 +111,6 @@ class AsyncLaminarClient:
         """
         await self.__client.aclose()
 
-    @property
-    def base_url(self) -> str:
-        return self.__base_url
-
-    @property
-    def project_api_key(self) -> str:
-        return self.__project_api_key
-
     async def __aenter__(self: _T) -> _T:
         return self
 

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

@@ -1,12 +1,8 @@
 from lmnr.sdk.client.asynchronous.resources.agent import AsyncAgent
 from lmnr.sdk.client.asynchronous.resources.browser_events import AsyncBrowserEvents
 from lmnr.sdk.client.asynchronous.resources.evals import AsyncEvals
-from lmnr.sdk.client.asynchronous.resources.pipeline import AsyncPipeline
-from lmnr.sdk.client.asynchronous.resources.semantic_search import AsyncSemanticSearch
 
 __all__ = [
-    "AsyncPipeline",
-    "AsyncSemanticSearch",
     "AsyncAgent",
     "AsyncEvals",
     "AsyncBrowserEvents",

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

@@ -35,7 +35,18 @@ class AsyncAgent(BaseAsyncResource):
         model_provider: Optional[ModelProvider] = None,
         model: Optional[str] = None,
         enable_thinking: bool = True,
+        agent_state: Optional[str] = None,
+        storage_state: Optional[str] = None,
         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.
 
@@ -46,7 +57,19 @@ class AsyncAgent(BaseAsyncResource):
             model_provider (Optional[ModelProvider], optional): LLM model provider
             model (Optional[str], optional): LLM model name
             enable_thinking (bool, optional): whether to enable thinking on the underlying LLM. Default to True.
+            agent_state (Optional[str], optional): the agent's state as returned by the previous agent run. Default to None.
+            storage_state (Optional[str], optional): the browser's storage state as returned by the previous agent run. Default to None.
             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
         """
@@ -60,7 +83,18 @@ class AsyncAgent(BaseAsyncResource):
         model_provider: Optional[ModelProvider] = None,
         model: Optional[str] = None,
         enable_thinking: bool = True,
+        agent_state: Optional[str] = None,
+        storage_state: Optional[str] = None,
         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.
 
@@ -70,7 +104,19 @@ class AsyncAgent(BaseAsyncResource):
             model_provider (Optional[ModelProvider], optional): LLM model provider
             model (Optional[str], optional): LLM model name
             enable_thinking (bool, optional): whether to enable thinking on the underlying LLM. Default to True.
+            agent_state (Optional[str], optional): the agent's state as returned by the previous agent run. Default to None.
+            storage_state (Optional[str], optional): the browser's storage state as returned by the previous agent run. Default to None.
             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
         """
@@ -85,7 +131,17 @@ class AsyncAgent(BaseAsyncResource):
         model: Optional[str] = None,
         stream: Literal[False] = False,
         enable_thinking: bool = True,
+        agent_state: Optional[str] = None,
+        storage_state: Optional[str] = None,
         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.
 
@@ -96,7 +152,19 @@ class AsyncAgent(BaseAsyncResource):
             model (Optional[str], optional): LLM model name
             stream (Literal[False], optional): whether to stream the agent's response
             enable_thinking (bool, optional): whether to enable thinking on the underlying LLM. Default to True.
+            agent_state (Optional[str], optional): the agent's state as returned by the previous agent run. Default to None.
+            storage_state (Optional[str], optional): the browser's storage state as returned by the previous agent run. Default to None.
             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
         """
@@ -110,7 +178,18 @@ class AsyncAgent(BaseAsyncResource):
         model: Optional[str] = None,
         stream: bool = False,
         enable_thinking: bool = True,
+        agent_state: Optional[str] = None,
+        storage_state: Optional[str] = None,
         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.
 
@@ -121,7 +200,19 @@ class AsyncAgent(BaseAsyncResource):
             model (Optional[str], optional): LLM model name
             stream (bool, optional): whether to stream the agent's response
             enable_thinking (bool, optional): whether to enable thinking on the underlying LLM. Default to True.
+            agent_state (Optional[str], optional): the agent's state as returned by the previous agent run. Default to None.
+            storage_state (Optional[str], optional): the browser's storage state as returned by the previous agent run. Default to None.
             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
         """
@@ -142,15 +233,25 @@ class AsyncAgent(BaseAsyncResource):
             parent_span_context=parent_span_context,
             model_provider=model_provider,
             model=model,
-            # We always connect to stream, because our TLS listeners on AWS
-            # Network load balancers have a hard fixed idle timeout of 350 seconds.
+            agent_state=agent_state,
+            storage_state=storage_state,
+            # We always connect to stream, because our network configuration
+            # has a hard fixed idle timeout of 350 seconds.
             # This means that if we don't stream, the connection will be closed.
             # For now, we just return the content of the final chunk if `stream` is
             # `False`.
-            # https://aws.amazon.com/blogs/networking-and-content-delivery/introducing-nlb-tcp-configurable-idle-timeout/
             stream=True,
             enable_thinking=enable_thinking,
             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,
+            thinking_token_budget=thinking_token_budget,
+            start_url=start_url,
         )
 
         # For streaming case, use a generator function
@@ -174,7 +275,7 @@ class AsyncAgent(BaseAsyncResource):
         async with self._client.stream(
             "POST",
             self._base_url + "/v1/agent/run",
-            json=request.to_dict(),
+            json=request.model_dump(by_alias=True),
             headers=self._headers(),
         ) as response:
             async for line in response.aiter_lines():
@@ -187,6 +288,8 @@ class AsyncAgent(BaseAsyncResource):
                 if line:
                     chunk = RunAgentResponseChunk.model_validate_json(line)
                     yield chunk.root
+                    if chunk.root.chunk_type in ["finalOutput", "error"]:
+                        break
 
     async def __run_non_streaming(self, request: RunAgentRequest) -> AgentOutput:
         """Run agent in non-streaming mode.
@@ -202,9 +305,11 @@ class AsyncAgent(BaseAsyncResource):
         async with self._client.stream(
             "POST",
             self._base_url + "/v1/agent/run",
-            json=request.to_dict(),
+            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]"):
@@ -214,7 +319,11 @@ class AsyncAgent(BaseAsyncResource):
                 line = line[6:]
                 if line:
                     chunk = RunAgentResponseChunk.model_validate_json(line)
-                    if chunk.root.chunkType == "finalOutput":
+                    if chunk.root.chunk_type == "finalOutput":
                         final_chunk = chunk.root
+                    elif chunk.root.chunk_type == "error":
+                        raise RuntimeError(chunk.root.error)
+                    elif chunk.root.chunk_type == "timeout":
+                        raise TimeoutError("Agent timed out")
 
         return final_chunk.content if final_chunk is not None else AgentOutput()

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

@@ -1,7 +1,5 @@
 from lmnr.sdk.client.synchronous.resources.agent import Agent
 from lmnr.sdk.client.synchronous.resources.browser_events import BrowserEvents
 from lmnr.sdk.client.synchronous.resources.evals import Evals
-from lmnr.sdk.client.synchronous.resources.pipeline import Pipeline
-from lmnr.sdk.client.synchronous.resources.semantic_search import SemanticSearch
 
-__all__ = ["Pipeline", "SemanticSearch", "Agent", "Evals", "BrowserEvents"]
+__all__ = ["Agent", "Evals", "BrowserEvents"]

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

@@ -27,7 +27,18 @@ class Agent(BaseResource):
         model_provider: Optional[ModelProvider] = None,
         model: Optional[str] = None,
         enable_thinking: bool = True,
+        agent_state: Optional[str] = None,
+        storage_state: Optional[str] = None,
         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.
 
@@ -38,7 +49,18 @@ class Agent(BaseResource):
             model_provider (Optional[ModelProvider], optional): LLM model provider
             model (Optional[str], optional): LLM model name
             enable_thinking (bool, optional): whether to enable thinking on the underlying LLM. Default to True.
+            agent_state (Optional[str], optional): the agent's state as returned by the previous agent run. Default to None.
+            storage_state (Optional[str], optional): the browser's storage state as returned by the previous agent run. Default to None.
             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
         """
@@ -52,7 +74,18 @@ class Agent(BaseResource):
         model_provider: Optional[ModelProvider] = None,
         model: Optional[str] = None,
         enable_thinking: bool = True,
+        agent_state: Optional[str] = None,
+        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.
 
@@ -62,7 +95,18 @@ class Agent(BaseResource):
             model_provider (Optional[ModelProvider], optional): LLM model provider
             model (Optional[str], optional): LLM model name
             enable_thinking (bool, optional): whether to enable thinking on the underlying LLM. Default to True.
+            agent_state (Optional[str], optional): the agent's state as returned by the previous agent run. Default to None.
+            storage_state (Optional[str], optional): the browser's storage state as returned by the previous agent run. Default to None.
             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
@@ -78,7 +122,18 @@ class Agent(BaseResource):
         model: Optional[str] = None,
         stream: Literal[False] = False,
         enable_thinking: bool = True,
+        agent_state: Optional[str] = None,
+        storage_state: Optional[str] = None,
         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.
 
@@ -89,7 +144,18 @@ class Agent(BaseResource):
             model (Optional[str], optional): LLM model name
             stream (Literal[False], optional): whether to stream the agent's response
             enable_thinking (bool, optional): whether to enable thinking on the underlying LLM. Default to True.
+            agent_state (Optional[str], optional): the agent's state as returned by the previous agent run. Default to None.
+            storage_state (Optional[str], optional): the browser's storage state as returned by the previous agent run. Default to None.
             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
@@ -104,7 +170,18 @@ class Agent(BaseResource):
         model: Optional[str] = None,
         stream: bool = False,
         enable_thinking: bool = True,
+        agent_state: Optional[str] = None,
+        storage_state: Optional[str] = None,
         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.
 
@@ -115,7 +192,18 @@ class Agent(BaseResource):
             model (Optional[str], optional): LLM model name
             stream (bool, optional): whether to stream the agent's response
             enable_thinking (bool, optional): whether to enable thinking on the underlying LLM. Default to True.
+            agent_state (Optional[str], optional): the agent's state as returned by the previous agent run. Default to None.
+            storage_state (Optional[str], optional): the browser's storage state as returned by the previous agent run. Default to None.
             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
@@ -137,15 +225,25 @@ class Agent(BaseResource):
             parent_span_context=parent_span_context,
             model_provider=model_provider,
             model=model,
-            # We always connect to stream, because our TLS listeners on AWS
-            # Network load balancers have a hard fixed idle timeout of 350 seconds.
+            agent_state=agent_state,
+            storage_state=storage_state,
+            # We always connect to stream, because our network configuration
+            # has a hard fixed idle timeout of 350 seconds.
             # This means that if we don't stream, the connection will be closed.
             # For now, we just return the content of the final chunk if `stream` is
             # `False`.
-            # https://aws.amazon.com/blogs/networking-and-content-delivery/introducing-nlb-tcp-configurable-idle-timeout/
             stream=True,
             enable_thinking=enable_thinking,
             return_screenshots=return_screenshots,
+            return_agent_state=return_agent_state,
+            return_storage_state=return_storage_state,
+            timeout=timeout,
+            cdp_url=cdp_url,
+            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
@@ -169,7 +267,7 @@ class Agent(BaseResource):
         with self._client.stream(
             "POST",
             self._base_url + "/v1/agent/run",
-            json=request.to_dict(),
+            json=request.model_dump(by_alias=True),
             headers=self._headers(),
         ) as response:
             for line in response.iter_lines():
@@ -182,6 +280,8 @@ class Agent(BaseResource):
                 if line:
                     chunk = RunAgentResponseChunk.model_validate_json(line)
                     yield chunk.root
+                    if chunk.root.chunk_type in ["finalOutput", "error"]:
+                        break
 
     def __run_non_streaming(self, request: RunAgentRequest) -> AgentOutput:
         """Run agent in non-streaming mode.
@@ -197,9 +297,11 @@ class Agent(BaseResource):
         with self._client.stream(
             "POST",
             self._base_url + "/v1/agent/run",
-            json=request.to_dict(),
+            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]"):
@@ -209,7 +311,11 @@ class Agent(BaseResource):
                 line = line[6:]
                 if line:
                     chunk = RunAgentResponseChunk.model_validate_json(line)
-                    if chunk.root.chunkType == "finalOutput":
+                    if chunk.root.chunk_type == "finalOutput":
                         final_chunk = chunk.root
+                    elif chunk.root.chunk_type == "error":
+                        raise RuntimeError(chunk.root.error)
+                    elif chunk.root.chunk_type == "timeout":
+                        raise TimeoutError("Agent timed out")
 
         return final_chunk.content if final_chunk is not None else AgentOutput()

lmnr/sdk/client/synchronous/sync_client.py

@@ -11,8 +11,6 @@ from lmnr.sdk.client.synchronous.resources import (
     Agent,
     BrowserEvents,
     Evals,
-    Pipeline,
-    SemanticSearch,
 )
 from lmnr.sdk.utils import from_env
 
@@ -25,8 +23,6 @@ class LaminarClient:
     __client: httpx.Client = None
 
     # Resource properties
-    __pipeline: Optional[Pipeline] = None
-    __semantic_search: Optional[SemanticSearch] = None
     __agent: Optional[Agent] = None
     __evals: Optional[Evals] = None
 
@@ -71,36 +67,12 @@ class LaminarClient:
         )
 
         # Initialize resource objects
-        self.__pipeline = Pipeline(
-            self.__client, self.__base_url, self.__project_api_key
-        )
-        self.__semantic_search = SemanticSearch(
-            self.__client, self.__base_url, self.__project_api_key
-        )
         self.__agent = Agent(self.__client, self.__base_url, self.__project_api_key)
         self.__evals = Evals(self.__client, self.__base_url, self.__project_api_key)
         self.__browser_events = BrowserEvents(
             self.__client, self.__base_url, self.__project_api_key
         )
 
-    @property
-    def pipeline(self) -> Pipeline:
-        """Get the Pipeline resource.
-
-        Returns:
-            Pipeline: The Pipeline resource instance.
-        """
-        return self.__pipeline
-
-    @property
-    def semantic_search(self) -> SemanticSearch:
-        """Get the SemanticSearch resource.
-
-        Returns:
-            SemanticSearch: The SemanticSearch resource instance.
-        """
-        return self.__semantic_search
-
     @property
     def agent(self) -> Agent:
         """Get the Agent resource.
@@ -150,14 +122,6 @@ class LaminarClient:
         if hasattr(self, "_client"):
             self.__client.close()
 
-    @property
-    def base_url(self) -> str:
-        return self.__base_url
-
-    @property
-    def project_api_key(self) -> str:
-        return self.__project_api_key
-
     def __enter__(self: _T) -> _T:
         return self
 

lmnr/sdk/decorators.py

@@ -1,4 +1,4 @@
-from lmnr.openllmetry_sdk.decorators.base import (
+from lmnr.opentelemetry_lib.decorators.base import (
     entity_method,
     aentity_method,
 )
@@ -7,8 +7,8 @@ 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.tracing import update_association_properties
 
 from .utils import is_async
 
@@ -24,6 +24,7 @@ def observe(
     ignore_input: bool = False,
     ignore_output: bool = False,
     span_type: Union[Literal["DEFAULT"], Literal["LLM"], Literal["TOOL"]] = "DEFAULT",
+    ignore_inputs: Optional[list[str]] = None,
 ) -> Callable[[Callable[P, R]], Callable[P, R]]:
     """The main decorator entrypoint for Laminar. This is used to wrap
     functions and methods to create spans.
@@ -32,9 +33,20 @@ def observe(
         name (Optional[str], optional): Name of the span. Function
                         name is used if not specified.
                         Defaults to None.
-        session_id (Optional[str], optional): Session ID to associate with the
+        session_id (Optional[str], optional): Session ID to associate with the\
                         span and the following context. Defaults to None.
-
+        ignore_input (bool, optional): Whether to ignore ALL input of the\
+                        wrapped function. Defaults to False.
+        ignore_output (bool, optional): Whether to ignore ALL output of the\
+                        wrapped function. Defaults to False.
+        span_type (Union[Literal["DEFAULT"], Literal["LLM"], Literal["TOOL"]], optional): Type of the span.
+                        Defaults to "DEFAULT".
+        ignore_inputs (Optional[list[str]], optional): List of input keys to ignore.
+                        For example, if the wrapped function takes three arguments,\
+                        def foo(a, b, `sensitive_data`), and you want to ignore the\
+                        `sensitive_data` argument, you can pass ["sensitive_data"] to\
+                        this argument.
+                        Defaults to None.
     Raises:
         Exception: re-raises the exception if the wrapped function raises
                    an exception
@@ -58,6 +70,7 @@ def observe(
                 ignore_input=ignore_input,
                 ignore_output=ignore_output,
                 span_type=span_type,
+                ignore_inputs=ignore_inputs,
             )(func)
             if is_async(func)
             else entity_method(
@@ -65,6 +78,7 @@ def observe(
                 ignore_input=ignore_input,
                 ignore_output=ignore_output,
                 span_type=span_type,
+                ignore_inputs=ignore_inputs,
             )(func)
         )