letta-client 1.0.0a8__py3-none-any.whl → 1.0.0a10__py3-none-any.whl

letta_client/types/block_modify_response.py

@@ -0,0 +1,63 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, Optional
+
+from .._models import BaseModel
+
+__all__ = ["BlockModifyResponse"]
+
+
+class BlockModifyResponse(BaseModel):
+    value: str
+    """Value of the block."""
+
+    id: Optional[str] = None
+    """The human-friendly ID of the Block"""
+
+    base_template_id: Optional[str] = None
+    """(Deprecated) The base template id of the block."""
+
+    created_by_id: Optional[str] = None
+    """The id of the user that made this Block."""
+
+    deployment_id: Optional[str] = None
+    """(Deprecated) The id of the deployment."""
+
+    description: Optional[str] = None
+    """Description of the block."""
+
+    entity_id: Optional[str] = None
+    """(Deprecated) The id of the entity within the template."""
+
+    hidden: Optional[bool] = None
+    """(Deprecated) If set to True, the block will be hidden."""
+
+    is_template: Optional[bool] = None
+    """Whether the block is a template (e.g. saved human/persona options)."""
+
+    label: Optional[str] = None
+    """Label of the block (e.g. 'human', 'persona') in the context window."""
+
+    last_updated_by_id: Optional[str] = None
+    """The id of the user that last updated this Block."""
+
+    limit: Optional[int] = None
+    """Character limit of the block."""
+
+    metadata: Optional[Dict[str, object]] = None
+    """Metadata of the block."""
+
+    preserve_on_migration: Optional[bool] = None
+    """(Deprecated) Preserve the block on template migration."""
+
+    project_id: Optional[str] = None
+    """The associated project id."""
+
+    read_only: Optional[bool] = None
+    """(Deprecated) Whether the agent has read-only access to the block."""
+
+    template_id: Optional[str] = None
+    """(Deprecated) The id of the template."""
+
+    template_name: Optional[str] = None
+    """(Deprecated) The name of the block template (if it is a template)."""

letta_client/types/block_retrieve_response.py

@@ -0,0 +1,63 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, Optional
+
+from .._models import BaseModel
+
+__all__ = ["BlockRetrieveResponse"]
+
+
+class BlockRetrieveResponse(BaseModel):
+    value: str
+    """Value of the block."""
+
+    id: Optional[str] = None
+    """The human-friendly ID of the Block"""
+
+    base_template_id: Optional[str] = None
+    """(Deprecated) The base template id of the block."""
+
+    created_by_id: Optional[str] = None
+    """The id of the user that made this Block."""
+
+    deployment_id: Optional[str] = None
+    """(Deprecated) The id of the deployment."""
+
+    description: Optional[str] = None
+    """Description of the block."""
+
+    entity_id: Optional[str] = None
+    """(Deprecated) The id of the entity within the template."""
+
+    hidden: Optional[bool] = None
+    """(Deprecated) If set to True, the block will be hidden."""
+
+    is_template: Optional[bool] = None
+    """Whether the block is a template (e.g. saved human/persona options)."""
+
+    label: Optional[str] = None
+    """Label of the block (e.g. 'human', 'persona') in the context window."""
+
+    last_updated_by_id: Optional[str] = None
+    """The id of the user that last updated this Block."""
+
+    limit: Optional[int] = None
+    """Character limit of the block."""
+
+    metadata: Optional[Dict[str, object]] = None
+    """Metadata of the block."""
+
+    preserve_on_migration: Optional[bool] = None
+    """(Deprecated) Preserve the block on template migration."""
+
+    project_id: Optional[str] = None
+    """The associated project id."""
+
+    read_only: Optional[bool] = None
+    """(Deprecated) Whether the agent has read-only access to the block."""
+
+    template_id: Optional[str] = None
+    """(Deprecated) The id of the template."""
+
+    template_name: Optional[str] = None
+    """(Deprecated) The name of the block template (if it is a template)."""

letta_client/types/create_block_param.py

@@ -38,9 +38,6 @@ class CreateBlockParam(TypedDict, total=False):
     metadata: Optional[Dict[str, object]]
     """Metadata of the block."""
 
-    name: Optional[str]
-    """The id of the template."""
-
     preserve_on_migration: Optional[bool]
     """Preserve the block on template migration."""
 
@@ -49,3 +46,9 @@ class CreateBlockParam(TypedDict, total=False):
 
     read_only: bool
     """Whether the agent has read-only access to the block."""
+
+    template_id: Optional[str]
+    """The id of the template."""
+
+    template_name: Optional[str]
+    """Name of the block if it is a template."""

letta_client/types/{folder_update_params.py → folder_modify_params.py}

@@ -7,10 +7,10 @@ from typing_extensions import TypedDict
 
 from .embedding_config_param import EmbeddingConfigParam
 
-__all__ = ["FolderUpdateParams"]
+__all__ = ["FolderModifyParams"]
 
 
-class FolderUpdateParams(TypedDict, total=False):
+class FolderModifyParams(TypedDict, total=False):
     description: Optional[str]
     """The description of the source."""
 

letta_client/types/{group_update_params.py → group_modify_params.py}

@@ -9,7 +9,7 @@ from .._types import SequenceNotStr
 from .._utils import PropertyInfo
 
 __all__ = [
-    "GroupUpdateParams",
+    "GroupModifyParams",
     "ManagerConfig",
     "ManagerConfigRoundRobinManagerUpdate",
     "ManagerConfigSupervisorManagerUpdate",
@@ -19,7 +19,7 @@ __all__ = [
 ]
 
 
-class GroupUpdateParams(TypedDict, total=False):
+class GroupModifyParams(TypedDict, total=False):
     agent_ids: Optional[SequenceNotStr[str]]
 
     description: Optional[str]

letta_client/types/groups/__init__.py

@@ -4,6 +4,6 @@ from __future__ import annotations
 
 from .message_list_params import MessageListParams as MessageListParams
 from .message_send_params import MessageSendParams as MessageSendParams
+from .message_modify_params import MessageModifyParams as MessageModifyParams
 from .message_stream_params import MessageStreamParams as MessageStreamParams
-from .message_update_params import MessageUpdateParams as MessageUpdateParams
-from .message_update_response import MessageUpdateResponse as MessageUpdateResponse
+from .message_modify_response import MessageModifyResponse as MessageModifyResponse

letta_client/types/groups/{message_update_params.py → message_modify_params.py}

@@ -9,7 +9,7 @@ from ..agents.letta_user_message_content_union_param import LettaUserMessageCont
 from ..agents.letta_assistant_message_content_union_param import LettaAssistantMessageContentUnionParam
 
 __all__ = [
-    "MessageUpdateParams",
+    "MessageModifyParams",
     "UpdateSystemMessage",
     "UpdateUserMessage",
     "UpdateReasoningMessage",
@@ -65,6 +65,6 @@ class UpdateAssistantMessage(TypedDict, total=False):
     message_type: Literal["assistant_message"]
 
 
-MessageUpdateParams: TypeAlias = Union[
+MessageModifyParams: TypeAlias = Union[
     UpdateSystemMessage, UpdateUserMessage, UpdateReasoningMessage, UpdateAssistantMessage
 ]

letta_client/types/groups/{message_update_response.py → message_modify_response.py}

@@ -14,9 +14,9 @@ from ..agents.approval_request_message import ApprovalRequestMessage
 from ..agents.hidden_reasoning_message import HiddenReasoningMessage
 from ..agents.approval_response_message import ApprovalResponseMessage
 
-__all__ = ["MessageUpdateResponse"]
+__all__ = ["MessageModifyResponse"]
 
-MessageUpdateResponse: TypeAlias = Annotated[
+MessageModifyResponse: TypeAlias = Annotated[
     Union[
         SystemMessage,
         UserMessage,

letta_client/types/identities/__init__.py

@@ -4,4 +4,5 @@ from __future__ import annotations
 
 from .agent_list_params import AgentListParams as AgentListParams
 from .block_list_params import BlockListParams as BlockListParams
+from .block_list_response import BlockListResponse as BlockListResponse
 from .property_upsert_params import PropertyUpsertParams as PropertyUpsertParams

letta_client/types/identities/block_list_response.py

@@ -0,0 +1,63 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, Optional
+
+from ..._models import BaseModel
+
+__all__ = ["BlockListResponse"]
+
+
+class BlockListResponse(BaseModel):
+    value: str
+    """Value of the block."""
+
+    id: Optional[str] = None
+    """The human-friendly ID of the Block"""
+
+    base_template_id: Optional[str] = None
+    """(Deprecated) The base template id of the block."""
+
+    created_by_id: Optional[str] = None
+    """The id of the user that made this Block."""
+
+    deployment_id: Optional[str] = None
+    """(Deprecated) The id of the deployment."""
+
+    description: Optional[str] = None
+    """Description of the block."""
+
+    entity_id: Optional[str] = None
+    """(Deprecated) The id of the entity within the template."""
+
+    hidden: Optional[bool] = None
+    """(Deprecated) If set to True, the block will be hidden."""
+
+    is_template: Optional[bool] = None
+    """Whether the block is a template (e.g. saved human/persona options)."""
+
+    label: Optional[str] = None
+    """Label of the block (e.g. 'human', 'persona') in the context window."""
+
+    last_updated_by_id: Optional[str] = None
+    """The id of the user that last updated this Block."""
+
+    limit: Optional[int] = None
+    """Character limit of the block."""
+
+    metadata: Optional[Dict[str, object]] = None
+    """Metadata of the block."""
+
+    preserve_on_migration: Optional[bool] = None
+    """(Deprecated) Preserve the block on template migration."""
+
+    project_id: Optional[str] = None
+    """The associated project id."""
+
+    read_only: Optional[bool] = None
+    """(Deprecated) Whether the agent has read-only access to the block."""
+
+    template_id: Optional[str] = None
+    """(Deprecated) The id of the template."""
+
+    template_name: Optional[str] = None
+    """(Deprecated) The name of the block template (if it is a template)."""

letta_client/types/{identity_update_params.py → identity_modify_params.py}

@@ -9,10 +9,10 @@ from .._types import SequenceNotStr
 from .identity_type import IdentityType
 from .identity_property_param import IdentityPropertyParam
 
-__all__ = ["IdentityUpdateParams"]
+__all__ = ["IdentityModifyParams"]
 
 
-class IdentityUpdateParams(TypedDict, total=False):
+class IdentityModifyParams(TypedDict, total=False):
     agent_ids: Optional[SequenceNotStr[str]]
     """The agent ids that are associated with the identity."""
 

letta_client/types/tool.py

@@ -1,15 +1,19 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 from typing import Dict, List, Optional
+from abc import abstractmethod
+from textwrap import dedent
+import inspect
+import typing
 
-from pydantic import Field as FieldInfo
+from pydantic import Field as FieldInfo, Field, model_validator
 
 from .._models import BaseModel
 from .tool_type import ToolType
 from .npm_requirement import NpmRequirement
 from .pip_requirement import PipRequirement
 
-__all__ = ["Tool"]
+__all__ = ["Tool", "BaseTool"]
 
 
 class Tool(BaseModel):
@@ -66,3 +70,103 @@ class Tool(BaseModel):
 
     tool_type: Optional[ToolType] = None
     """The type of the tool."""
+
+
+class BaseTool(Tool):
+    name: Optional[str] = Field(default=None, 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: typing.Any, **kwargs: typing.Any) -> 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

letta_client/types/{tool_update_params.py → tool_modify_params.py}

@@ -10,10 +10,10 @@ from .._utils import PropertyInfo
 from .npm_requirement_param import NpmRequirementParam
 from .pip_requirement_param import PipRequirementParam
 
-__all__ = ["ToolUpdateParams"]
+__all__ = ["ToolModifyParams"]
 
 
-class ToolUpdateParams(TypedDict, total=False):
+class ToolModifyParams(TypedDict, total=False):
     args_json_schema: Optional[Dict[str, object]]
     """The args JSON schema of the function."""
 

{letta_client-1.0.0a8.dist-info → letta_client-1.0.0a10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: letta-client
-Version: 1.0.0a8
+Version: 1.0.0a10
 Summary: The official Python library for the letta API
 Project-URL: Homepage, https://github.com/letta-ai/letta-python
 Project-URL: Repository, https://github.com/letta-ai/letta-python