letta-client 0.1.64__py3-none-any.whl → 0.1.66__py3-none-any.whl

letta_client/tools/client.py

@@ -13,6 +13,8 @@ from ..core.api_error import ApiError
 from ..types.tool_return_message import ToolReturnMessage
 from ..types.app_model import AppModel
 from ..types.action_model import ActionModel
+from .types.list_mcp_servers_response_value import ListMcpServersResponseValue
+from ..types.mcp_tool import McpTool
 from ..core.client_wrapper import AsyncClientWrapper
 
 # this is used as the default value for optional parameters
@@ -816,6 +818,179 @@ class ToolsClient:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
+    def list_mcp_servers(
+        self, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> typing.Dict[str, ListMcpServersResponseValue]:
+        """
+        Get a list of all configured MCP servers
+
+        Parameters
+        ----------
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        typing.Dict[str, ListMcpServersResponseValue]
+            Successful Response
+
+        Examples
+        --------
+        from letta_client import Letta
+
+        client = Letta(
+            token="YOUR_TOKEN",
+        )
+        client.tools.list_mcp_servers()
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            "v1/tools/mcp/servers",
+            method="GET",
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return typing.cast(
+                    typing.Dict[str, ListMcpServersResponseValue],
+                    construct_type(
+                        type_=typing.Dict[str, ListMcpServersResponseValue],  # 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)
+
+    def list_mcp_tools_by_server(
+        self, mcp_server_name: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> typing.List[McpTool]:
+        """
+        Get a list of all tools for a specific MCP server
+
+        Parameters
+        ----------
+        mcp_server_name : str
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        typing.List[McpTool]
+            Successful Response
+
+        Examples
+        --------
+        from letta_client import Letta
+
+        client = Letta(
+            token="YOUR_TOKEN",
+        )
+        client.tools.list_mcp_tools_by_server(
+            mcp_server_name="mcp_server_name",
+        )
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            f"v1/tools/mcp/servers/{jsonable_encoder(mcp_server_name)}/tools",
+            method="GET",
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return typing.cast(
+                    typing.List[McpTool],
+                    construct_type(
+                        type_=typing.List[McpTool],  # 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)
+
+    def add_mcp_tool(
+        self, mcp_server_name: str, mcp_tool_name: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> Tool:
+        """
+        Add a new MCP tool by server + tool name
+
+        Parameters
+        ----------
+        mcp_server_name : str
+
+        mcp_tool_name : str
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        Tool
+            Successful Response
+
+        Examples
+        --------
+        from letta_client import Letta
+
+        client = Letta(
+            token="YOUR_TOKEN",
+        )
+        client.tools.add_mcp_tool(
+            mcp_server_name="mcp_server_name",
+            mcp_tool_name="mcp_tool_name",
+        )
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            f"v1/tools/mcp/servers/{jsonable_encoder(mcp_server_name)}/{jsonable_encoder(mcp_tool_name)}",
+            method="POST",
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return typing.cast(
+                    Tool,
+                    construct_type(
+                        type_=Tool,  # 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 AsyncToolsClient:
     def __init__(self, *, client_wrapper: AsyncClientWrapper):
@@ -1703,3 +1878,200 @@ class AsyncToolsClient:
         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_mcp_servers(
+        self, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> typing.Dict[str, ListMcpServersResponseValue]:
+        """
+        Get a list of all configured MCP servers
+
+        Parameters
+        ----------
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        typing.Dict[str, ListMcpServersResponseValue]
+            Successful Response
+
+        Examples
+        --------
+        import asyncio
+
+        from letta_client import AsyncLetta
+
+        client = AsyncLetta(
+            token="YOUR_TOKEN",
+        )
+
+
+        async def main() -> None:
+            await client.tools.list_mcp_servers()
+
+
+        asyncio.run(main())
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "v1/tools/mcp/servers",
+            method="GET",
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return typing.cast(
+                    typing.Dict[str, ListMcpServersResponseValue],
+                    construct_type(
+                        type_=typing.Dict[str, ListMcpServersResponseValue],  # 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)
+
+    async def list_mcp_tools_by_server(
+        self, mcp_server_name: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> typing.List[McpTool]:
+        """
+        Get a list of all tools for a specific MCP server
+
+        Parameters
+        ----------
+        mcp_server_name : str
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        typing.List[McpTool]
+            Successful Response
+
+        Examples
+        --------
+        import asyncio
+
+        from letta_client import AsyncLetta
+
+        client = AsyncLetta(
+            token="YOUR_TOKEN",
+        )
+
+
+        async def main() -> None:
+            await client.tools.list_mcp_tools_by_server(
+                mcp_server_name="mcp_server_name",
+            )
+
+
+        asyncio.run(main())
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"v1/tools/mcp/servers/{jsonable_encoder(mcp_server_name)}/tools",
+            method="GET",
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return typing.cast(
+                    typing.List[McpTool],
+                    construct_type(
+                        type_=typing.List[McpTool],  # 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)
+
+    async def add_mcp_tool(
+        self, mcp_server_name: str, mcp_tool_name: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> Tool:
+        """
+        Add a new MCP tool by server + tool name
+
+        Parameters
+        ----------
+        mcp_server_name : str
+
+        mcp_tool_name : str
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        Tool
+            Successful Response
+
+        Examples
+        --------
+        import asyncio
+
+        from letta_client import AsyncLetta
+
+        client = AsyncLetta(
+            token="YOUR_TOKEN",
+        )
+
+
+        async def main() -> None:
+            await client.tools.add_mcp_tool(
+                mcp_server_name="mcp_server_name",
+                mcp_tool_name="mcp_tool_name",
+            )
+
+
+        asyncio.run(main())
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"v1/tools/mcp/servers/{jsonable_encoder(mcp_server_name)}/{jsonable_encoder(mcp_tool_name)}",
+            method="POST",
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return typing.cast(
+                    Tool,
+                    construct_type(
+                        type_=Tool,  # 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/tools/types/__init__.py

@@ -0,0 +1,5 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from .list_mcp_servers_response_value import ListMcpServersResponseValue
+
+__all__ = ["ListMcpServersResponseValue"]

letta_client/tools/types/list_mcp_servers_response_value.py

@@ -0,0 +1,7 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+from ...types.sse_server_config import SseServerConfig
+from ...types.local_server_config import LocalServerConfig
+
+ListMcpServersResponseValue = typing.Union[SseServerConfig, LocalServerConfig]

letta_client/types/__init__.py

@@ -72,6 +72,7 @@ from .conflict_error_body import ConflictErrorBody
 from .context_window_overview import ContextWindowOverview
 from .continue_tool_rule import ContinueToolRule
 from .create_block import CreateBlock
+from .dynamic_manager import DynamicManager
 from .e_2_b_sandbox_config import E2BSandboxConfig
 from .embedding_config import EmbeddingConfig
 from .embedding_config_embedding_endpoint_type import EmbeddingConfigEmbeddingEndpointType
@@ -83,6 +84,9 @@ from .function_definition_input import FunctionDefinitionInput
 from .function_definition_output import FunctionDefinitionOutput
 from .function_output import FunctionOutput
 from .function_tool import FunctionTool
+from .group import Group
+from .group_create import GroupCreate
+from .group_create_manager_config import GroupCreateManagerConfig
 from .health import Health
 from .http_validation_error import HttpValidationError
 from .identity import Identity
@@ -105,10 +109,15 @@ from .letta_message_union import LettaMessageUnion
 from .letta_request import LettaRequest
 from .letta_request_config import LettaRequestConfig
 from .letta_response import LettaResponse
+from .letta_streaming_request import LettaStreamingRequest
 from .letta_usage_statistics import LettaUsageStatistics
 from .llm_config import LlmConfig
 from .llm_config_model_endpoint_type import LlmConfigModelEndpointType
 from .local_sandbox_config import LocalSandboxConfig
+from .local_server_config import LocalServerConfig
+from .manager_type import ManagerType
+from .mcp_server_type import McpServerType
+from .mcp_tool import McpTool
 from .memory import Memory
 from .message import Message
 from .message_create import MessageCreate
@@ -133,6 +142,7 @@ from .reasoning_message import ReasoningMessage
 from .response_format_json_object import ResponseFormatJsonObject
 from .response_format_json_schema import ResponseFormatJsonSchema
 from .response_format_text import ResponseFormatText
+from .round_robin_manager import RoundRobinManager
 from .run import Run
 from .sandbox_config import SandboxConfig
 from .sandbox_config_create import SandboxConfigCreate
@@ -144,7 +154,9 @@ from .sandbox_environment_variable_create import SandboxEnvironmentVariableCreat
 from .sandbox_environment_variable_update import SandboxEnvironmentVariableUpdate
 from .sandbox_type import SandboxType
 from .source import Source
+from .sse_server_config import SseServerConfig
 from .step import Step
+from .supervisor_manager import SupervisorManager
 from .system_message import SystemMessage
 from .system_message_content import SystemMessageContent
 from .terminal_tool_rule import TerminalToolRule
@@ -254,6 +266,7 @@ __all__ = [
     "ContextWindowOverview",
     "ContinueToolRule",
     "CreateBlock",
+    "DynamicManager",
     "E2BSandboxConfig",
     "EmbeddingConfig",
     "EmbeddingConfigEmbeddingEndpointType",
@@ -265,6 +278,9 @@ __all__ = [
     "FunctionDefinitionOutput",
     "FunctionOutput",
     "FunctionTool",
+    "Group",
+    "GroupCreate",
+    "GroupCreateManagerConfig",
     "Health",
     "HttpValidationError",
     "Identity",
@@ -287,10 +303,15 @@ __all__ = [
     "LettaRequest",
     "LettaRequestConfig",
     "LettaResponse",
+    "LettaStreamingRequest",
     "LettaUsageStatistics",
     "LlmConfig",
     "LlmConfigModelEndpointType",
     "LocalSandboxConfig",
+    "LocalServerConfig",
+    "ManagerType",
+    "McpServerType",
+    "McpTool",
     "Memory",
     "Message",
     "MessageCreate",
@@ -311,6 +332,7 @@ __all__ = [
     "ResponseFormatJsonObject",
     "ResponseFormatJsonSchema",
     "ResponseFormatText",
+    "RoundRobinManager",
     "Run",
     "SandboxConfig",
     "SandboxConfigCreate",
@@ -322,7 +344,9 @@ __all__ = [
     "SandboxEnvironmentVariableUpdate",
     "SandboxType",
     "Source",
+    "SseServerConfig",
     "Step",
+    "SupervisorManager",
     "SystemMessage",
     "SystemMessageContent",
     "TerminalToolRule",

letta_client/types/agent_state.py

@@ -12,6 +12,7 @@ from .memory import Memory
 from .tool import Tool
 from .source import Source
 from .agent_environment_variable import AgentEnvironmentVariable
+from .group import Group
 from ..core.pydantic_utilities import IS_PYDANTIC_V2
 
 
@@ -153,6 +154,11 @@ class AgentState(UncheckedBaseModel):
     If set to True, the agent will not remember previous messages (though the agent will still retain state via core memory blocks and archival/recall memory). Not recommended unless you have an advanced use case.
     """
 
+    multi_agent_group: typing.Optional[Group] = pydantic.Field(default=None)
+    """
+    The multi-agent group that this agent manages
+    """
+
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
     else:

letta_client/types/dynamic_manager.py

@@ -0,0 +1,33 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.unchecked_base_model import UncheckedBaseModel
+import typing
+import pydantic
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class DynamicManager(UncheckedBaseModel):
+    manager_type: typing.Literal["dynamic"] = "dynamic"
+    manager_agent_id: str = pydantic.Field()
+    """
+    
+    """
+
+    termination_token: typing.Optional[str] = pydantic.Field(default=None)
+    """
+    
+    """
+
+    max_turns: typing.Optional[int] = pydantic.Field(default=None)
+    """
+    
+    """
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

letta_client/types/group.py

@@ -0,0 +1,53 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.unchecked_base_model import UncheckedBaseModel
+import pydantic
+from .manager_type import ManagerType
+import typing
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class Group(UncheckedBaseModel):
+    id: str = pydantic.Field()
+    """
+    The id of the group. Assigned by the database.
+    """
+
+    manager_type: ManagerType = pydantic.Field()
+    """
+    
+    """
+
+    agent_ids: typing.List[str] = pydantic.Field()
+    """
+    
+    """
+
+    description: str = pydantic.Field()
+    """
+    
+    """
+
+    manager_agent_id: typing.Optional[str] = pydantic.Field(default=None)
+    """
+    
+    """
+
+    termination_token: typing.Optional[str] = pydantic.Field(default=None)
+    """
+    
+    """
+
+    max_turns: typing.Optional[int] = pydantic.Field(default=None)
+    """
+    
+    """
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

letta_client/types/group_create.py

@@ -0,0 +1,33 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.unchecked_base_model import UncheckedBaseModel
+import typing
+import pydantic
+from .group_create_manager_config import GroupCreateManagerConfig
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class GroupCreate(UncheckedBaseModel):
+    agent_ids: typing.List[str] = pydantic.Field()
+    """
+    
+    """
+
+    description: str = pydantic.Field()
+    """
+    
+    """
+
+    manager_config: typing.Optional[GroupCreateManagerConfig] = pydantic.Field(default=None)
+    """
+    
+    """
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

letta_client/types/group_create_manager_config.py

@@ -0,0 +1,8 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+from .dynamic_manager import DynamicManager
+from .round_robin_manager import RoundRobinManager
+from .supervisor_manager import SupervisorManager
+
+GroupCreateManagerConfig = typing.Union[DynamicManager, RoundRobinManager, SupervisorManager]

letta_client/types/letta_streaming_request.py

@@ -0,0 +1,43 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.unchecked_base_model import UncheckedBaseModel
+import typing
+from .message_create import MessageCreate
+import pydantic
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class LettaStreamingRequest(UncheckedBaseModel):
+    messages: typing.List[MessageCreate] = pydantic.Field()
+    """
+    The messages to be sent to the agent.
+    """
+
+    use_assistant_message: typing.Optional[bool] = pydantic.Field(default=None)
+    """
+    Whether the server should parse specific tool call arguments (default `send_message`) as `AssistantMessage` objects.
+    """
+
+    assistant_message_tool_name: typing.Optional[str] = pydantic.Field(default=None)
+    """
+    The name of the designated message tool.
+    """
+
+    assistant_message_tool_kwarg: typing.Optional[str] = pydantic.Field(default=None)
+    """
+    The name of the message argument in the designated message tool.
+    """
+
+    stream_tokens: typing.Optional[bool] = pydantic.Field(default=None)
+    """
+    Flag to determine if individual tokens should be streamed. Set to True for token streaming (requires stream_steps = True).
+    """
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow