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

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

@@ -27,7 +27,16 @@ 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,
+        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,
     ) -> Generator[RunAgentResponseChunk, None, None]:
         """Run Laminar index agent in streaming mode.
 
@@ -38,7 +47,16 @@ 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.
+            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.
         Returns:
             Generator[RunAgentResponseChunk, None, None]: a generator of response chunks
         """
@@ -52,7 +70,16 @@ 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,
+        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,
     ) -> AgentOutput:
         """Run Laminar index agent.
 
@@ -62,8 +89,16 @@ 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.
+            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.
         Returns:
             AgentOutput: agent output
         """
@@ -78,7 +113,16 @@ 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,
+        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,
     ) -> AgentOutput:
         """Run Laminar index agent.
 
@@ -89,8 +133,16 @@ 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.
+            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.
         Returns:
             AgentOutput: agent output
         """
@@ -104,7 +156,16 @@ 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,
+        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,
     ) -> Union[AgentOutput, Generator[RunAgentResponseChunk, None, None]]:
         """Run Laminar index agent.
 
@@ -115,7 +176,16 @@ 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.
+            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.
 
         Returns:
             Union[AgentOutput, Generator[RunAgentResponseChunk, None, None]]: agent output or a generator of response chunks
@@ -137,15 +207,23 @@ 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,
         )
 
         # For streaming case, use a generator function
@@ -169,7 +247,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 +260,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 +277,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 +291,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

@@ -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)
         )
 

lmnr/sdk/laminar.py

@@ -2,7 +2,7 @@ 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 import get_tracer
+from lmnr.openllmetry_sdk.tracing import get_tracer
 from lmnr.openllmetry_sdk.tracing.attributes import (
     ASSOCIATION_PROPERTIES,
     Attributes,
@@ -652,8 +652,8 @@ class Laminar:
 
     @classmethod
     def shutdown(cls):
-        cls.__initialized = False
-        return TracerManager.shutdown()
+        if cls.is_initialized():
+            TracerManager.shutdown()
 
     @classmethod
     def set_session(

lmnr/sdk/types.py

@@ -1,118 +1,20 @@
 import logging
 import datetime
 from enum import Enum
-import httpx
 import json
 from opentelemetry.trace import SpanContext, TraceFlags
 import pydantic
 from typing import Any, Awaitable, Callable, Literal, Optional, Union
 import uuid
 
-from .utils import serialize
-
-
-class ChatMessage(pydantic.BaseModel):
-    role: str
-    content: str
-
+import pydantic.alias_generators
 
-class ConditionedValue(pydantic.BaseModel):
-    condition: str
-    value: "NodeInput"
+from .utils import serialize
 
 
 Numeric = Union[int, float]
 NumericTypes = (int, float)  # for use with isinstance
 
-NodeInput = Union[str, list[ChatMessage], ConditionedValue, Numeric, bool]
-PipelineOutput = Union[NodeInput]
-
-
-class PipelineRunRequest(pydantic.BaseModel):
-    inputs: dict[str, NodeInput]
-    pipeline: str
-    env: dict[str, str] = pydantic.Field(default_factory=dict)
-    metadata: dict[str, str] = pydantic.Field(default_factory=dict)
-    stream: bool = pydantic.Field(default=False)
-    parent_span_id: Optional[uuid.UUID] = pydantic.Field(default=None)
-    trace_id: Optional[uuid.UUID] = pydantic.Field(default=None)
-
-    # uuid is not serializable by default, so we need to convert it to a string
-    def to_dict(self):
-        return {
-            "inputs": {
-                k: v.model_dump() if isinstance(v, pydantic.BaseModel) else serialize(v)
-                for k, v in self.inputs.items()
-            },
-            "pipeline": self.pipeline,
-            "env": self.env,
-            "metadata": self.metadata,
-            "stream": self.stream,
-            "parentSpanId": str(self.parent_span_id) if self.parent_span_id else None,
-            "traceId": str(self.trace_id) if self.trace_id else None,
-        }
-
-
-class PipelineRunResponse(pydantic.BaseModel):
-    outputs: dict[str, dict[str, PipelineOutput]]
-    run_id: str
-
-
-class SemanticSearchRequest(pydantic.BaseModel):
-    query: str
-    dataset_id: uuid.UUID
-    limit: Optional[int] = pydantic.Field(default=None)
-    threshold: Optional[float] = pydantic.Field(default=None, ge=0.0, le=1.0)
-
-    def to_dict(self):
-        res = {
-            "query": self.query,
-            "datasetId": str(self.dataset_id),
-        }
-        if self.limit is not None:
-            res["limit"] = self.limit
-        if self.threshold is not None:
-            res["threshold"] = self.threshold
-        return res
-
-
-class SemanticSearchResult(pydantic.BaseModel):
-    dataset_id: uuid.UUID
-    score: float
-    data: dict[str, Any]
-    content: str
-
-
-class SemanticSearchResponse(pydantic.BaseModel):
-    results: list[SemanticSearchResult]
-
-
-class PipelineRunError(Exception):
-    error_code: str
-    error_message: str
-
-    def __init__(self, response: httpx.Response):
-        try:
-            resp_json = response.json()
-            try:
-                resp_dict = dict(resp_json)
-            except Exception:
-                resp_dict = {}
-            self.error_code = resp_dict.get("error_code")
-            self.error_message = resp_dict.get("error_message")
-            super().__init__(self.error_message)
-        except Exception:
-            super().__init__(response.text)
-
-    def __str__(self) -> str:
-        try:
-            return str(
-                {"error_code": self.error_code, "error_message": self.error_message}
-            )
-        except Exception:
-            return super().__str__()
-
-
 EvaluationDatapointData = Any  # non-null, must be JSON-serializable
 EvaluationDatapointTarget = Optional[Any]  # must be JSON-serializable
 EvaluationDatapointMetadata = Optional[Any]  # must be JSON-serializable
@@ -322,52 +224,18 @@ class LaminarSpanContext(pydantic.BaseModel):
 class ModelProvider(str, Enum):
     ANTHROPIC = "anthropic"
     BEDROCK = "bedrock"
-
-
-# class AgentChatMessageContentTextBlock(pydantic.BaseModel):
-#     type: Literal["text"]
-#     text: str
-
-
-# class AgentChatMessageImageUrlBlock(pydantic.BaseModel):
-#     type: Literal["image"]
-#     imageUrl: str
-
-
-# class AgentChatMessageImageBase64Block(pydantic.BaseModel):
-#     type: Literal["image"]
-#     imageB64: str
-
-
-# class AgentChatMessageImageBlock(pydantic.RootModel):
-#     root: Union[AgentChatMessageImageUrlBlock, AgentChatMessageImageBase64Block]
-
-
-# class AgentChatMessageContentBlock(pydantic.RootModel):
-#     root: Union[AgentChatMessageContentTextBlock, AgentChatMessageImageBlock]
-
-
-# class AgentChatMessageContent(pydantic.RootModel):
-#     root: Union[str, list[AgentChatMessageContentBlock]]
-
-
-# class AgentChatMessage(pydantic.BaseModel):
-#     role: str
-#     content: AgentChatMessageContent
-#     name: Optional[str] = None
-#     toolCallId: Optional[str] = None
-#     isStateMessage: bool = False
-
-
-# class AgentState(pydantic.BaseModel):
-# messages: str = pydantic.Field(default="")
-# messages: list[AgentChatMessage] = pydantic.Field(default_factory=list)
-# browser_state: Optional[BrowserState] = None
+    OPENAI = "openai"
+    GEMINI = "gemini"
 
 
 class RunAgentRequest(pydantic.BaseModel):
+    model_config = pydantic.ConfigDict(
+        alias_generator=pydantic.alias_generators.to_camel,
+        populate_by_name=True,
+    )
     prompt: str
-    state: Optional[str] = pydantic.Field(default=None)
+    storage_state: Optional[str] = pydantic.Field(default=None)
+    agent_state: Optional[str] = pydantic.Field(default=None)
     parent_span_context: Optional[str] = pydantic.Field(default=None)
     model_provider: Optional[ModelProvider] = pydantic.Field(default=None)
     model: Optional[str] = pydantic.Field(default=None)
@@ -375,50 +243,96 @@ class RunAgentRequest(pydantic.BaseModel):
     enable_thinking: bool = pydantic.Field(default=True)
     cdp_url: Optional[str] = pydantic.Field(default=None)
     return_screenshots: bool = pydantic.Field(default=False)
-
-    def to_dict(self):
-        result = {
-            "prompt": self.prompt,
-            "stream": self.stream,
-            "enableThinking": self.enable_thinking,
-            "returnScreenshots": self.return_screenshots,
-        }
-        if self.state:
-            result["state"] = self.state
-        if self.parent_span_context:
-            result["parentSpanContext"] = self.parent_span_context
-        if self.model_provider:
-            result["modelProvider"] = self.model_provider.value
-        if self.model:
-            result["model"] = self.model
-        if self.cdp_url:
-            result["cdpUrl"] = self.cdp_url
-        return result
+    return_storage_state: bool = pydantic.Field(default=False)
+    return_agent_state: bool = pydantic.Field(default=False)
+    timeout: Optional[int] = pydantic.Field(default=None)
+    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)
 
 
 class ActionResult(pydantic.BaseModel):
-    isDone: bool = pydantic.Field(default=False)
+    model_config = pydantic.ConfigDict(
+        alias_generator=pydantic.alias_generators.to_camel
+    )
+    is_done: bool = pydantic.Field(default=False)
     content: Optional[str] = pydantic.Field(default=None)
     error: Optional[str] = pydantic.Field(default=None)
 
 
 class AgentOutput(pydantic.BaseModel):
+    model_config = pydantic.ConfigDict(
+        alias_generator=pydantic.alias_generators.to_camel
+    )
     result: ActionResult = pydantic.Field(default_factory=ActionResult)
+    # Browser state with data related to auth, such as cookies.
+    # A stringified JSON object.
+    # Only returned if return_storage_state is True.
+    # CAUTION: This object may become large. It also may contain sensitive data.
+    storage_state: Optional[str] = pydantic.Field(default=None)
+    # Agent state with data related to the agent's state, such as the chat history.
+    # A stringified JSON object.
+    # Only returned if return_agent_state is True.
+    # CAUTION: This object is large.
+    agent_state: Optional[str] = pydantic.Field(default=None)
 
 
 class StepChunkContent(pydantic.BaseModel):
-    chunkType: Literal["step"]
-    messageId: uuid.UUID
-    actionResult: ActionResult
-    summary: str
+    model_config = pydantic.ConfigDict(
+        alias_generator=pydantic.alias_generators.to_camel
+    )
+    chunk_type: Literal["step"] = pydantic.Field(default="step")
+    message_id: uuid.UUID = pydantic.Field()
+    action_result: ActionResult = pydantic.Field()
+    summary: str = pydantic.Field()
+    screenshot: Optional[str] = pydantic.Field(default=None)
+
+
+class TimeoutChunkContent(pydantic.BaseModel):
+    """Chunk content to indicate that timeout has been hit. The only difference from a regular step
+    is the chunk type. This is the last chunk in the stream.
+    """
+
+    model_config = pydantic.ConfigDict(
+        alias_generator=pydantic.alias_generators.to_camel
+    )
+    chunk_type: Literal["timeout"] = pydantic.Field(default="timeout")
+    message_id: uuid.UUID = pydantic.Field()
+    summary: str = pydantic.Field()
     screenshot: Optional[str] = pydantic.Field(default=None)
 
 
 class FinalOutputChunkContent(pydantic.BaseModel):
-    chunkType: Literal["finalOutput"]
-    messageId: uuid.UUID
-    content: AgentOutput
+    """Chunk content to indicate that the agent has finished executing. This
+    is the last chunk in the stream.
+    """
+
+    model_config = pydantic.ConfigDict(
+        alias_generator=pydantic.alias_generators.to_camel
+    )
+
+    chunk_type: Literal["finalOutput"] = pydantic.Field(default="finalOutput")
+    message_id: uuid.UUID = pydantic.Field()
+    content: AgentOutput = pydantic.Field()
+
+
+class ErrorChunkContent(pydantic.BaseModel):
+    """Chunk content to indicate that an error has occurred. Typically, this
+    is the last chunk in the stream.
+    """
+
+    model_config = pydantic.ConfigDict(
+        alias_generator=pydantic.alias_generators.to_camel
+    )
+    chunk_type: Literal["error"] = pydantic.Field(default="error")
+    message_id: uuid.UUID = pydantic.Field()
+    error: str = pydantic.Field()
 
 
 class RunAgentResponseChunk(pydantic.RootModel):
-    root: Union[StepChunkContent, FinalOutputChunkContent]
+    root: Union[
+        StepChunkContent,
+        FinalOutputChunkContent,
+        ErrorChunkContent,
+        TimeoutChunkContent,
+    ]

lmnr/sdk/utils.py

@@ -88,13 +88,20 @@ def get_input_from_func_args(
     is_method: bool = False,
     func_args: list[typing.Any] = [],
     func_kwargs: dict[str, typing.Any] = {},
+    ignore_inputs: typing.Optional[list[str]] = None,
 ) -> dict[str, typing.Any]:
     # Remove implicitly passed "self" or "cls" argument for
     # instance or class methods
-    res = func_kwargs.copy()
+    res = {
+        k: v
+        for k, v in func_kwargs.items()
+        if not (ignore_inputs and k in ignore_inputs)
+    }
     for i, k in enumerate(inspect.signature(func).parameters.keys()):
         if is_method and k in ["self", "cls"]:
             continue
+        if ignore_inputs and k in ignore_inputs:
+            continue
         # If param has default value, then it's not present in func args
         if i < len(func_args):
             res[k] = func_args[i]

lmnr/version.py

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