letta-client 0.1.53__tar.gz → 0.1.54__tar.gz

{letta_client-0.1.53 → letta_client-0.1.54}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-client
-Version: 0.1.53
+Version: 0.1.54
 Summary: 
 Requires-Python: >=3.8,<4.0
 Classifier: Intended Audience :: Developers

{letta_client-0.1.53 → letta_client-0.1.54}/pyproject.toml

@@ -3,7 +3,7 @@ name = "letta-client"
 
 [tool.poetry]
 name = "letta-client"
-version = "0.1.53"
+version = "0.1.54"
 description = ""
 readme = "README.md"
 authors = []

letta_client-0.1.54/src/letta_client/client.py

@@ -0,0 +1,382 @@
+import inspect
+import typing
+from pydantic import BaseModel, Field, model_validator
+from textwrap import dedent
+from abc import abstractmethod
+
+from .base_client import AsyncLettaBase, LettaBase
+from .core.request_options import RequestOptions
+from .tools.client import ToolsClient as ToolsClientBase
+from .types.tool import Tool
+
+# this is used as the default value for optional parameters
+OMIT = typing.cast(typing.Any, ...)
+
+
+class Letta(LettaBase):
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.tools = ToolsClient(client_wrapper=self._client_wrapper)
+
+
+class AsyncLetta(AsyncLettaBase):
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.tools = ToolsClient(client_wrapper=self._client_wrapper)
+
+
+class BaseTool(Tool):
+    name: str = Field(..., description="The name of the function.")
+    args_schema: typing.Optional[typing.Type[BaseModel]] = Field(default=None, description="The schema for validating the tool's arguments.")
+
+    @abstractmethod
+    def run(self, *args, **kwargs) -> typing.Any:
+        """
+        Execute the tool with the provided arguments.
+
+        Parameters
+        ----------
+        self
+            The instance of the tool
+        *args
+            Positional arguments to pass to the tool.
+        **kwargs
+            Keyword arguments to pass to the tool.
+
+        Returns
+        -------
+        typing.Any
+            The result of executing the tool.
+        """
+        pass
+
+
+    @model_validator(mode="after")
+    def no_self_in_run_source(self) -> "BaseTool":
+        """
+        Validate that the provided implementation does not reference `self` in the
+        `run` method implementation.
+
+        This check is performed after the model is created, so `self` is guaranteed
+        to be set.
+
+        If `self` is found in the source code of the `run` method, a `ValueError` is
+        raised with a message pointing to the line and value of the offending code.
+        """
+        source_code = self.get_source_code()
+        if "self." in source_code:
+            raise_on_line, line_value = None, None
+            for i, line in enumerate(source_code.splitlines()):
+                if "self." in line:
+                    raise_on_line, line_value = i+1, line
+                    break;
+            raise ValueError(
+                f"Detected reference to 'self' in line {raise_on_line} of implementation, " +
+                f"which is not allowed:\n\n{line_value}\n\n" +
+                f"Please pass in the arguments directly to run() instead.")
+        return self
+
+
+    def get_source_code(self) -> str:
+        """
+        Get the source code of the `run` method, which will be executed in an agent step.
+
+        Returns
+        -------
+        str
+            The source code of the tool.
+        """
+        source_code = dedent(inspect.getsource(self.run))
+
+        # replace tool name
+        source_code = source_code.replace("def run", f"def {self.name}")
+
+        # remove self, handling several cases
+        source_code_lines = source_code.splitlines()
+        if "self" in source_code_lines[0]:
+            # def run(self, ...): or def run (self,): or def run(self):
+            source_code_lines[0] = source_code_lines[0].replace("self, ", "").replace("self,", "").replace("self", "")
+        else:
+            maybe_line_to_delete = None
+            for i, line in enumerate(source_code_lines):
+                if line.strip() == "self" or line.strip() == "self,":
+                    # def run(
+                    #   self,
+                    #   ...
+                    # ):
+                    maybe_line_to_delete = i
+                    break
+                elif line.strip().startswith("self"):
+                    # def run(
+                    #   self, ...
+                    # ):
+                    source_code_lines[i] = line.replace("self, ", "").replace("self,", "").replace("self", "")
+                    break
+            if maybe_line_to_delete is not None:
+                del source_code_lines[maybe_line_to_delete]
+                if maybe_line_to_delete == 1 and source_code_lines[0].strip()[-1] == "(" and source_code_lines[1].strip()[0] == ")":
+                    # def run(
+                    #   self
+                    # ):
+                    source_code_lines[0] = source_code_lines[0].strip() + source_code_lines[1].strip()
+                    del source_code_lines[1]
+
+        source_code = "\n".join(source_code_lines)
+        return source_code
+
+
+class ToolsClient(ToolsClientBase):
+
+    def create_from_function(
+        self,
+        *,
+        func: typing.Callable,
+        args_schema: typing.Optional[typing.Type[BaseModel]] = OMIT,
+        description: typing.Optional[str] = OMIT,
+        tags: typing.Optional[typing.Sequence[str]] = OMIT,
+        source_type: typing.Optional[str] = OMIT,
+        json_schema: typing.Optional[
+            typing.Dict[str, typing.Optional[typing.Any]]
+        ] = OMIT,
+        return_char_limit: typing.Optional[int] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> Tool:
+        """
+        Create a new tool from a callable
+
+        Parameters
+        ----------
+        func : typing.Callable
+            The callable to create the tool from.
+        
+        args_schema : typing.Optional[typing.Type[BaseModel]]
+            The arguments schema of the function, as a Pydantic model.
+
+        description : typing.Optional[str]
+            The description of the tool.
+
+        tags : typing.Optional[typing.Sequence[str]]
+            Metadata tags.
+
+        source_type : typing.Optional[str]
+            The source type of the function.
+
+        json_schema : typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]]
+            The JSON schema of the function (auto-generated from source_code if not provided)
+
+        return_char_limit : typing.Optional[int]
+            The maximum number of characters in the response.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        Tool
+            Successful Response
+
+        Examples
+        --------
+        from letta_client import Letta
+
+        client = Letta(
+            token="YOUR_TOKEN",
+        )
+        
+        def add_two_numbers(a: int, b: int) -> int:
+            return a + b
+        
+        client.tools.create_from_function(
+            func=add_two_numbers,
+        )
+
+        class InventoryEntryData(BaseModel):
+            data: InventoryEntry
+            quantity_change: int
+
+        def manage_inventory(data: InventoryEntry, quantity_change: int) -> bool:
+            pass
+        
+        client.tools.create_from_function(
+            func=manage_inventory,
+            args_schema=InventoryEntryData,
+        )
+        """
+        source_code = dedent(inspect.getsource(func))
+        args_json_schema = args_schema.model_json_schema() if args_schema and args_schema != OMIT else None
+        return self.create(
+            source_code=source_code,
+            args_json_schema=args_json_schema,
+            description=description,
+            tags=tags,
+            source_type=source_type,
+            json_schema=json_schema,
+            return_char_limit=return_char_limit,
+            request_options=request_options,
+        )
+
+
+    def upsert_from_function(
+        self,
+        *,
+        func: typing.Callable,
+        args_schema: typing.Optional[typing.Type[BaseModel]] = OMIT,
+        description: typing.Optional[str] = OMIT,
+        tags: typing.Optional[typing.Sequence[str]] = OMIT,
+        source_type: typing.Optional[str] = OMIT,
+        json_schema: typing.Optional[
+            typing.Dict[str, typing.Optional[typing.Any]]
+        ] = OMIT,
+        return_char_limit: typing.Optional[int] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> Tool:
+        """
+        Create or update a tool from a callable
+
+        Parameters
+        ----------
+        func : typing.Callable
+            The callable to create or update the tool from.
+        
+        args_schema : typing.Optional[typing.Type[BaseModel]]
+            The arguments schema of the function, as a Pydantic model.
+
+        description : typing.Optional[str]
+            The description of the tool.
+
+        tags : typing.Optional[typing.Sequence[str]]
+            Metadata tags.
+
+        source_type : typing.Optional[str]
+            The source type of the function.
+
+        json_schema : typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]]
+            The JSON schema of the function (auto-generated from source_code if not provided)
+
+        return_char_limit : typing.Optional[int]
+            The maximum number of characters in the response.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        Tool
+            Successful Response
+
+        Examples
+        --------
+        from letta_client import Letta
+
+        client = Letta(
+            token="YOUR_TOKEN",
+        )
+
+        def add_two_numbers(a: int, b: int) -> int:
+            return a + b
+        
+        client.tools.upsert_from_function(
+            func=add_two_numbers,
+        )
+
+        class InventoryEntryData(BaseModel):
+            data: InventoryEntry
+            quantity_change: int
+
+        def manage_inventory(data: InventoryEntry, quantity_change: int) -> bool:
+            pass
+        
+        client.tools.upsert_from_function(
+            func=manage_inventory,
+            args_schema=InventoryEntryData,
+        )
+        """
+        source_code = dedent(inspect.getsource(func))
+        args_json_schema = args_schema.model_json_schema() if args_schema and args_schema != OMIT else None
+        return self.upsert(
+            source_code=source_code,
+            args_json_schema=args_json_schema,
+            description=description,
+            tags=tags,
+            source_type=source_type,
+            json_schema=json_schema,
+            return_char_limit=return_char_limit,
+            request_options=request_options,
+        )
+    
+    def add(
+        self,
+        *,
+        tool: BaseTool,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> Tool:
+        """
+        Add a tool to Letta from a custom Tool class
+
+        Parameters
+        ----------
+        tool : BaseTool
+            The tool object to be added.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        Tool
+            Successful Response
+
+        Examples
+        --------
+        from letta_client import Letta
+
+        client = Letta(
+            token="YOUR_TOKEN",
+        )
+
+        class InventoryItem(BaseModel):
+            sku: str  # Unique product identifier
+            name: str  # Product name
+            price: float  # Current price
+            category: str  # Product category (e.g., "Electronics", "Clothing")
+
+        class InventoryEntry(BaseModel):
+            timestamp: int  # Unix timestamp of the transaction
+            item: InventoryItem  # The product being updated
+            transaction_id: str  # Unique identifier for this inventory update
+
+        class InventoryEntryData(BaseModel):
+            data: InventoryEntry
+            quantity_change: int  # Change in quantity (positive for additions, negative for removals)
+
+        class ManageInventoryTool(BaseTool):
+            name: str = "manage_inventory"
+            args_schema: Type[BaseModel] = InventoryEntryData
+            description: str = "Update inventory catalogue with a new data entry"
+            tags: List[str] = ["inventory", "shop"]
+
+            def run(self, data: InventoryEntry, quantity_change: int) -> bool:
+                '''
+                Implementation of the manage_inventory tool
+                '''
+                print(f"Updated inventory for {data.item.name} with a quantity change of {quantity_change}")
+                return True
+                
+        client.tools.add(
+            tool=ManageInventoryTool()
+        )
+        """
+        source_code = tool.get_source_code()
+        args_json_schema = tool.args_schema.model_json_schema() if tool.args_schema else None
+        return self.upsert(
+            source_code=source_code,
+            args_json_schema=args_json_schema or OMIT,
+            description=tool.description or OMIT,
+            tags=tool.tags or OMIT,
+            source_type=tool.source_type or OMIT,
+            json_schema=tool.json_schema or OMIT,
+            return_char_limit=tool.return_char_limit or OMIT,
+            request_options=request_options,
+        )

{letta_client-0.1.53 → letta_client-0.1.54}/src/letta_client/core/client_wrapper.py

@@ -16,7 +16,7 @@ class BaseClientWrapper:
         headers: typing.Dict[str, str] = {
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "letta-client",
-            "X-Fern-SDK-Version": "0.1.53",
+            "X-Fern-SDK-Version": "0.1.54",
         }
         if self.token is not None:
             headers["Authorization"] = f"Bearer {self.token}"

{letta_client-0.1.53 → letta_client-0.1.54}/src/letta_client/runs/client.py

@@ -13,6 +13,7 @@ from ..core.jsonable_encoder import jsonable_encoder
 from ..types.message_role import MessageRole
 from ..types.letta_message_union import LettaMessageUnion
 from ..types.usage_statistics import UsageStatistics
+from ..types.step import Step
 from ..core.client_wrapper import AsyncClientWrapper
 
 
@@ -395,6 +396,99 @@ class RunsClient:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
+    def list_run_steps(
+        self,
+        run_id: str,
+        *,
+        before: typing.Optional[str] = None,
+        after: typing.Optional[str] = None,
+        limit: typing.Optional[int] = None,
+        order: typing.Optional[str] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> typing.List[Step]:
+        """
+        Get messages associated with a run with filtering options.
+
+        Args:
+            run_id: ID of the run
+            before: A cursor for use in pagination. `before` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, starting with obj_foo, your subsequent call can include before=obj_foo in order to fetch the previous page of the list.
+            after: A cursor for use in pagination. `after` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with obj_foo, your subsequent call can include after=obj_foo in order to fetch the next page of the list.
+            limit: Maximum number of steps to return
+            order: Sort order by the created_at timestamp of the objects. asc for ascending order and desc for descending order.
+
+        Returns:
+            A list of steps associated with the run.
+
+        Parameters
+        ----------
+        run_id : str
+
+        before : typing.Optional[str]
+            Cursor for pagination
+
+        after : typing.Optional[str]
+            Cursor for pagination
+
+        limit : typing.Optional[int]
+            Maximum number of messages to return
+
+        order : typing.Optional[str]
+            Sort order by the created_at timestamp of the objects. asc for ascending order and desc for descending order.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        typing.List[Step]
+            Successful Response
+
+        Examples
+        --------
+        from letta_client import Letta
+
+        client = Letta(
+            token="YOUR_TOKEN",
+        )
+        client.runs.list_run_steps(
+            run_id="run_id",
+        )
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            f"v1/runs/{jsonable_encoder(run_id)}/steps",
+            method="GET",
+            params={
+                "before": before,
+                "after": after,
+                "limit": limit,
+                "order": order,
+            },
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return typing.cast(
+                    typing.List[Step],
+                    construct_type(
+                        type_=typing.List[Step],  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+            if _response.status_code == 422:
+                raise UnprocessableEntityError(
+                    typing.cast(
+                        HttpValidationError,
+                        construct_type(
+                            type_=HttpValidationError,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    )
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
 
 class AsyncRunsClient:
     def __init__(self, *, client_wrapper: AsyncClientWrapper):
@@ -822,3 +916,104 @@ class AsyncRunsClient:
         except JSONDecodeError:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    async def list_run_steps(
+        self,
+        run_id: str,
+        *,
+        before: typing.Optional[str] = None,
+        after: typing.Optional[str] = None,
+        limit: typing.Optional[int] = None,
+        order: typing.Optional[str] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> typing.List[Step]:
+        """
+        Get messages associated with a run with filtering options.
+
+        Args:
+            run_id: ID of the run
+            before: A cursor for use in pagination. `before` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, starting with obj_foo, your subsequent call can include before=obj_foo in order to fetch the previous page of the list.
+            after: A cursor for use in pagination. `after` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with obj_foo, your subsequent call can include after=obj_foo in order to fetch the next page of the list.
+            limit: Maximum number of steps to return
+            order: Sort order by the created_at timestamp of the objects. asc for ascending order and desc for descending order.
+
+        Returns:
+            A list of steps associated with the run.
+
+        Parameters
+        ----------
+        run_id : str
+
+        before : typing.Optional[str]
+            Cursor for pagination
+
+        after : typing.Optional[str]
+            Cursor for pagination
+
+        limit : typing.Optional[int]
+            Maximum number of messages to return
+
+        order : typing.Optional[str]
+            Sort order by the created_at timestamp of the objects. asc for ascending order and desc for descending order.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        typing.List[Step]
+            Successful Response
+
+        Examples
+        --------
+        import asyncio
+
+        from letta_client import AsyncLetta
+
+        client = AsyncLetta(
+            token="YOUR_TOKEN",
+        )
+
+
+        async def main() -> None:
+            await client.runs.list_run_steps(
+                run_id="run_id",
+            )
+
+
+        asyncio.run(main())
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"v1/runs/{jsonable_encoder(run_id)}/steps",
+            method="GET",
+            params={
+                "before": before,
+                "after": after,
+                "limit": limit,
+                "order": order,
+            },
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return typing.cast(
+                    typing.List[Step],
+                    construct_type(
+                        type_=typing.List[Step],  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+            if _response.status_code == 422:
+                raise UnprocessableEntityError(
+                    typing.cast(
+                        HttpValidationError,
+                        construct_type(
+                            type_=HttpValidationError,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    )
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)

letta_client-0.1.53/src/letta_client/client.py

@@ -1,76 +0,0 @@
-import inspect
-import typing
-from textwrap import dedent
-
-from .base_client import AsyncLettaBase, LettaBase
-from .core.request_options import RequestOptions
-from .tools.client import ToolsClient as ToolsClientBase
-from .types.tool import Tool
-
-# this is used as the default value for optional parameters
-OMIT = typing.cast(typing.Any, ...)
-
-
-class Letta(LettaBase):
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.tools = ToolsClient(client_wrapper=self._client_wrapper)
-
-
-class AsyncLetta(AsyncLettaBase):
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.tools = ToolsClient(client_wrapper=self._client_wrapper)
-
-
-class ToolsClient(ToolsClientBase):
-
-    def create_from_function(
-        self,
-        *,
-        func: typing.Callable,
-        description: typing.Optional[str] = OMIT,
-        tags: typing.Optional[typing.Sequence[str]] = OMIT,
-        source_type: typing.Optional[str] = OMIT,
-        json_schema: typing.Optional[
-            typing.Dict[str, typing.Optional[typing.Any]]
-        ] = OMIT,
-        return_char_limit: typing.Optional[int] = OMIT,
-        request_options: typing.Optional[RequestOptions] = None,
-    ) -> Tool:
-        source_code = dedent(inspect.getsource(func))
-        return self.create(
-            source_code=source_code,
-            description=description,
-            tags=tags,
-            source_type=source_type,
-            json_schema=json_schema,
-            return_char_limit=return_char_limit,
-            request_options=request_options,
-        )
-
-    def upsert_from_function(
-        self,
-        *,
-        func: typing.Callable,
-        description: typing.Optional[str] = OMIT,
-        tags: typing.Optional[typing.Sequence[str]] = OMIT,
-        source_type: typing.Optional[str] = OMIT,
-        json_schema: typing.Optional[
-            typing.Dict[str, typing.Optional[typing.Any]]
-        ] = OMIT,
-        return_char_limit: typing.Optional[int] = OMIT,
-        request_options: typing.Optional[RequestOptions] = None,
-    ) -> Tool:
-        source_code = dedent(inspect.getsource(func))
-        return self.upsert(
-            source_code=source_code,
-            description=description,
-            tags=tags,
-            source_type=source_type,
-            json_schema=json_schema,
-            return_char_limit=return_char_limit,
-            request_options=request_options,
-        )