letta-client 1.0.0a11__py3-none-any.whl → 1.0.0a13__py3-none-any.whl

letta_client/types/__init__.py

@@ -94,18 +94,24 @@ from .sleeptime_manager_param import SleeptimeManagerParam as SleeptimeManagerPa
 from .agent_export_file_params import AgentExportFileParams as AgentExportFileParams
 from .agent_import_file_params import AgentImportFileParams as AgentImportFileParams
 from .continue_tool_rule_param import ContinueToolRuleParam as ContinueToolRuleParam
+from .mcp_server_create_params import McpServerCreateParams as McpServerCreateParams
+from .mcp_server_list_response import McpServerListResponse as McpServerListResponse
+from .mcp_server_modify_params import McpServerModifyParams as McpServerModifyParams
 from .supervisor_manager_param import SupervisorManagerParam as SupervisorManagerParam
 from .terminal_tool_rule_param import TerminalToolRuleParam as TerminalToolRuleParam
 from .round_robin_manager_param import RoundRobinManagerParam as RoundRobinManagerParam
 from .agent_environment_variable import AgentEnvironmentVariable as AgentEnvironmentVariable
 from .agent_export_file_response import AgentExportFileResponse as AgentExportFileResponse
 from .agent_import_file_response import AgentImportFileResponse as AgentImportFileResponse
+from .mcp_server_create_response import McpServerCreateResponse as McpServerCreateResponse
+from .mcp_server_modify_response import McpServerModifyResponse as McpServerModifyResponse
 from .text_response_format_param import TextResponseFormatParam as TextResponseFormatParam
 from .conditional_tool_rule_param import ConditionalToolRuleParam as ConditionalToolRuleParam
 from .json_object_response_format import JsonObjectResponseFormat as JsonObjectResponseFormat
 from .json_schema_response_format import JsonSchemaResponseFormat as JsonSchemaResponseFormat
 from .requires_approval_tool_rule import RequiresApprovalToolRule as RequiresApprovalToolRule
 from .max_count_per_step_tool_rule import MaxCountPerStepToolRule as MaxCountPerStepToolRule
+from .mcp_server_retrieve_response import McpServerRetrieveResponse as McpServerRetrieveResponse
 from .voice_sleeptime_manager_param import VoiceSleeptimeManagerParam as VoiceSleeptimeManagerParam
 from .required_before_exit_tool_rule import RequiredBeforeExitToolRule as RequiredBeforeExitToolRule
 from .tool_upsert_base_tools_response import ToolUpsertBaseToolsResponse as ToolUpsertBaseToolsResponse

letta_client/types/agent_create_params.py

@@ -3,10 +3,9 @@
 from __future__ import annotations
 
 from typing import Dict, Union, Iterable, Optional
-from typing_extensions import Annotated, TypeAlias, TypedDict
+from typing_extensions import TypeAlias, TypedDict
 
 from .._types import SequenceNotStr
-from .._utils import PropertyInfo
 from .agent_type import AgentType
 from .llm_config_param import LlmConfigParam
 from .create_block_param import CreateBlockParam
@@ -199,9 +198,6 @@ class AgentCreateParams(TypedDict, total=False):
     tools: Optional[SequenceNotStr[str]]
     """The tools used by the agent."""
 
-    x_project: Annotated[str, PropertyInfo(alias="X-Project")]
-    """The project slug to associate with the agent (cloud only)."""
-
 
 ResponseFormat: TypeAlias = Union[TextResponseFormatParam, JsonSchemaResponseFormatParam, JsonObjectResponseFormatParam]
 

letta_client/types/group_create_params.py

@@ -3,10 +3,9 @@
 from __future__ import annotations
 
 from typing import Union, Optional
-from typing_extensions import Required, Annotated, TypeAlias, TypedDict
+from typing_extensions import Required, TypeAlias, TypedDict
 
 from .._types import SequenceNotStr
-from .._utils import PropertyInfo
 from .dynamic_manager_param import DynamicManagerParam
 from .sleeptime_manager_param import SleeptimeManagerParam
 from .supervisor_manager_param import SupervisorManagerParam
@@ -31,9 +30,6 @@ class GroupCreateParams(TypedDict, total=False):
 
     shared_block_ids: SequenceNotStr[str]
 
-    x_project: Annotated[str, PropertyInfo(alias="X-Project")]
-    """The project slug to associate with the group (cloud only)."""
-
 
 ManagerConfig: TypeAlias = Union[
     RoundRobinManagerParam,

letta_client/types/group_modify_params.py

@@ -3,10 +3,9 @@
 from __future__ import annotations
 
 from typing import Union, Optional
-from typing_extensions import Literal, Required, Annotated, TypeAlias, TypedDict
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
 
 from .._types import SequenceNotStr
-from .._utils import PropertyInfo
 
 __all__ = [
     "GroupModifyParams",
@@ -31,9 +30,6 @@ class GroupModifyParams(TypedDict, total=False):
 
     shared_block_ids: Optional[SequenceNotStr[str]]
 
-    x_project: Annotated[str, PropertyInfo(alias="X-Project")]
-    """The project slug to associate with the group (cloud only)."""
-
 
 class ManagerConfigRoundRobinManagerUpdate(TypedDict, total=False):
     manager_type: Literal["round_robin"]

letta_client/types/identity_create_params.py

@@ -3,10 +3,9 @@
 from __future__ import annotations
 
 from typing import Iterable, Optional
-from typing_extensions import Required, Annotated, TypedDict
+from typing_extensions import Required, TypedDict
 
 from .._types import SequenceNotStr
-from .._utils import PropertyInfo
 from .identity_type import IdentityType
 from .identity_property_param import IdentityPropertyParam
 
@@ -34,6 +33,3 @@ class IdentityCreateParams(TypedDict, total=False):
 
     properties: Optional[Iterable[IdentityPropertyParam]]
     """List of properties associated with the identity."""
-
-    x_project: Annotated[str, PropertyInfo(alias="X-Project")]
-    """The project slug to associate with the identity (cloud only)."""

letta_client/types/identity_upsert_params.py

@@ -3,10 +3,9 @@
 from __future__ import annotations
 
 from typing import Iterable, Optional
-from typing_extensions import Required, Annotated, TypedDict
+from typing_extensions import Required, TypedDict
 
 from .._types import SequenceNotStr
-from .._utils import PropertyInfo
 from .identity_type import IdentityType
 from .identity_property_param import IdentityPropertyParam
 
@@ -34,6 +33,3 @@ class IdentityUpsertParams(TypedDict, total=False):
 
     properties: Optional[Iterable[IdentityPropertyParam]]
     """List of properties associated with the identity."""
-
-    x_project: Annotated[str, PropertyInfo(alias="X-Project")]
-    """The project slug to associate with the identity (cloud only)."""

letta_client/types/mcp_server_create_params.py

@@ -0,0 +1,67 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Union, Optional
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
+
+from .._types import SequenceNotStr
+
+__all__ = ["McpServerCreateParams", "CreateStdioMcpServer", "CreateSsemcpServer", "CreateStreamableHttpmcpServer"]
+
+
+class CreateStdioMcpServer(TypedDict, total=False):
+    args: Required[SequenceNotStr[str]]
+    """The arguments to pass to the command"""
+
+    command: Required[str]
+    """The command to run (MCP 'local' client will run this command)"""
+
+    server_name: Required[str]
+    """The name of the server"""
+
+    env: Optional[Dict[str, str]]
+    """Environment variables to set"""
+
+    type: Literal["sse", "stdio", "streamable_http"]
+
+
+class CreateSsemcpServer(TypedDict, total=False):
+    server_name: Required[str]
+    """The name of the server"""
+
+    server_url: Required[str]
+    """The URL of the server"""
+
+    auth_header: Optional[str]
+    """The name of the authentication header (e.g., 'Authorization')"""
+
+    auth_token: Optional[str]
+    """The authentication token or API key value"""
+
+    custom_headers: Optional[Dict[str, str]]
+    """Custom HTTP headers to include with requests"""
+
+    type: Literal["sse", "stdio", "streamable_http"]
+
+
+class CreateStreamableHttpmcpServer(TypedDict, total=False):
+    server_name: Required[str]
+    """The name of the server"""
+
+    server_url: Required[str]
+    """The URL of the server"""
+
+    auth_header: Optional[str]
+    """The name of the authentication header (e.g., 'Authorization')"""
+
+    auth_token: Optional[str]
+    """The authentication token or API key value"""
+
+    custom_headers: Optional[Dict[str, str]]
+    """Custom HTTP headers to include with requests"""
+
+    type: Literal["sse", "stdio", "streamable_http"]
+
+
+McpServerCreateParams: TypeAlias = Union[CreateStdioMcpServer, CreateSsemcpServer, CreateStreamableHttpmcpServer]

letta_client/types/mcp_server_create_response.py

@@ -0,0 +1,74 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Union, Optional
+from typing_extensions import Literal, TypeAlias
+
+from .._models import BaseModel
+
+__all__ = ["McpServerCreateResponse", "StdioMcpServer", "SsemcpServer", "StreamableHttpmcpServer"]
+
+
+class StdioMcpServer(BaseModel):
+    args: List[str]
+    """The arguments to pass to the command"""
+
+    command: str
+    """The command to run (MCP 'local' client will run this command)"""
+
+    server_name: str
+    """The name of the server"""
+
+    id: Optional[str] = None
+    """The human-friendly ID of the Mcp_server"""
+
+    env: Optional[Dict[str, str]] = None
+    """Environment variables to set"""
+
+    type: Optional[Literal["sse", "stdio", "streamable_http"]] = None
+
+
+class SsemcpServer(BaseModel):
+    server_name: str
+    """The name of the server"""
+
+    server_url: str
+    """The URL of the server"""
+
+    id: Optional[str] = None
+    """The human-friendly ID of the Mcp_server"""
+
+    auth_header: Optional[str] = None
+    """The name of the authentication header (e.g., 'Authorization')"""
+
+    auth_token: Optional[str] = None
+    """The authentication token or API key value"""
+
+    custom_headers: Optional[Dict[str, str]] = None
+    """Custom HTTP headers to include with requests"""
+
+    type: Optional[Literal["sse", "stdio", "streamable_http"]] = None
+
+
+class StreamableHttpmcpServer(BaseModel):
+    server_name: str
+    """The name of the server"""
+
+    server_url: str
+    """The URL of the server"""
+
+    id: Optional[str] = None
+    """The human-friendly ID of the Mcp_server"""
+
+    auth_header: Optional[str] = None
+    """The name of the authentication header (e.g., 'Authorization')"""
+
+    auth_token: Optional[str] = None
+    """The authentication token or API key value"""
+
+    custom_headers: Optional[Dict[str, str]] = None
+    """Custom HTTP headers to include with requests"""
+
+    type: Optional[Literal["sse", "stdio", "streamable_http"]] = None
+
+
+McpServerCreateResponse: TypeAlias = Union[StdioMcpServer, SsemcpServer, StreamableHttpmcpServer]

letta_client/types/mcp_server_list_response.py

@@ -0,0 +1,86 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Union, Optional
+from typing_extensions import Literal, TypeAlias
+
+from .._models import BaseModel
+
+__all__ = [
+    "McpServerListResponse",
+    "McpServerListResponseItem",
+    "McpServerListResponseItemStdioMcpServer",
+    "McpServerListResponseItemSsemcpServer",
+    "McpServerListResponseItemStreamableHttpmcpServer",
+]
+
+
+class McpServerListResponseItemStdioMcpServer(BaseModel):
+    args: List[str]
+    """The arguments to pass to the command"""
+
+    command: str
+    """The command to run (MCP 'local' client will run this command)"""
+
+    server_name: str
+    """The name of the server"""
+
+    id: Optional[str] = None
+    """The human-friendly ID of the Mcp_server"""
+
+    env: Optional[Dict[str, str]] = None
+    """Environment variables to set"""
+
+    type: Optional[Literal["sse", "stdio", "streamable_http"]] = None
+
+
+class McpServerListResponseItemSsemcpServer(BaseModel):
+    server_name: str
+    """The name of the server"""
+
+    server_url: str
+    """The URL of the server"""
+
+    id: Optional[str] = None
+    """The human-friendly ID of the Mcp_server"""
+
+    auth_header: Optional[str] = None
+    """The name of the authentication header (e.g., 'Authorization')"""
+
+    auth_token: Optional[str] = None
+    """The authentication token or API key value"""
+
+    custom_headers: Optional[Dict[str, str]] = None
+    """Custom HTTP headers to include with requests"""
+
+    type: Optional[Literal["sse", "stdio", "streamable_http"]] = None
+
+
+class McpServerListResponseItemStreamableHttpmcpServer(BaseModel):
+    server_name: str
+    """The name of the server"""
+
+    server_url: str
+    """The URL of the server"""
+
+    id: Optional[str] = None
+    """The human-friendly ID of the Mcp_server"""
+
+    auth_header: Optional[str] = None
+    """The name of the authentication header (e.g., 'Authorization')"""
+
+    auth_token: Optional[str] = None
+    """The authentication token or API key value"""
+
+    custom_headers: Optional[Dict[str, str]] = None
+    """Custom HTTP headers to include with requests"""
+
+    type: Optional[Literal["sse", "stdio", "streamable_http"]] = None
+
+
+McpServerListResponseItem: TypeAlias = Union[
+    McpServerListResponseItemStdioMcpServer,
+    McpServerListResponseItemSsemcpServer,
+    McpServerListResponseItemStreamableHttpmcpServer,
+]
+
+McpServerListResponse: TypeAlias = List[McpServerListResponseItem]

letta_client/types/mcp_server_modify_params.py

@@ -0,0 +1,76 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Union, Optional
+from typing_extensions import TypeAlias, TypedDict
+
+from .._types import SequenceNotStr
+
+__all__ = [
+    "McpServerModifyParams",
+    "LettaSchemasMcpServerUpdateStdioMcpServer",
+    "LettaSchemasMcpServerUpdateSsemcpServer",
+    "LettaSchemasMcpServerUpdateStreamableHttpmcpServer",
+]
+
+
+class LettaSchemasMcpServerUpdateStdioMcpServer(TypedDict, total=False):
+    args: Optional[SequenceNotStr[str]]
+    """The arguments to pass to the command"""
+
+    command: Optional[str]
+    """The command to run the MCP server"""
+
+    env: Optional[Dict[str, str]]
+    """Environment variables to set"""
+
+    server_name: Optional[str]
+    """The name of the MCP server"""
+
+
+class LettaSchemasMcpServerUpdateSsemcpServer(TypedDict, total=False):
+    token: Optional[str]
+    """The authentication token (internal)"""
+
+    auth_header: Optional[str]
+    """The name of the authentication header (e.g., 'Authorization')"""
+
+    auth_token: Optional[str]
+    """The authentication token or API key value"""
+
+    custom_headers: Optional[Dict[str, str]]
+    """Custom headers to send with requests"""
+
+    server_name: Optional[str]
+    """The name of the MCP server"""
+
+    server_url: Optional[str]
+    """The URL of the SSE MCP server"""
+
+
+class LettaSchemasMcpServerUpdateStreamableHttpmcpServer(TypedDict, total=False):
+    token: Optional[str]
+    """The authentication token (internal)"""
+
+    auth_header: Optional[str]
+    """The name of the authentication header (e.g., 'Authorization')"""
+
+    auth_token: Optional[str]
+    """The authentication token or API key value"""
+
+    custom_headers: Optional[Dict[str, str]]
+    """Custom headers to send with requests"""
+
+    server_name: Optional[str]
+    """The name of the MCP server"""
+
+    server_url: Optional[str]
+    """The URL of the Streamable HTTP MCP server"""
+
+
+McpServerModifyParams: TypeAlias = Union[
+    LettaSchemasMcpServerUpdateStdioMcpServer,
+    LettaSchemasMcpServerUpdateSsemcpServer,
+    LettaSchemasMcpServerUpdateStreamableHttpmcpServer,
+]

letta_client/types/mcp_server_modify_response.py

@@ -0,0 +1,74 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Union, Optional
+from typing_extensions import Literal, TypeAlias
+
+from .._models import BaseModel
+
+__all__ = ["McpServerModifyResponse", "StdioMcpServer", "SsemcpServer", "StreamableHttpmcpServer"]
+
+
+class StdioMcpServer(BaseModel):
+    args: List[str]
+    """The arguments to pass to the command"""
+
+    command: str
+    """The command to run (MCP 'local' client will run this command)"""
+
+    server_name: str
+    """The name of the server"""
+
+    id: Optional[str] = None
+    """The human-friendly ID of the Mcp_server"""
+
+    env: Optional[Dict[str, str]] = None
+    """Environment variables to set"""
+
+    type: Optional[Literal["sse", "stdio", "streamable_http"]] = None
+
+
+class SsemcpServer(BaseModel):
+    server_name: str
+    """The name of the server"""
+
+    server_url: str
+    """The URL of the server"""
+
+    id: Optional[str] = None
+    """The human-friendly ID of the Mcp_server"""
+
+    auth_header: Optional[str] = None
+    """The name of the authentication header (e.g., 'Authorization')"""
+
+    auth_token: Optional[str] = None
+    """The authentication token or API key value"""
+
+    custom_headers: Optional[Dict[str, str]] = None
+    """Custom HTTP headers to include with requests"""
+
+    type: Optional[Literal["sse", "stdio", "streamable_http"]] = None
+
+
+class StreamableHttpmcpServer(BaseModel):
+    server_name: str
+    """The name of the server"""
+
+    server_url: str
+    """The URL of the server"""
+
+    id: Optional[str] = None
+    """The human-friendly ID of the Mcp_server"""
+
+    auth_header: Optional[str] = None
+    """The name of the authentication header (e.g., 'Authorization')"""
+
+    auth_token: Optional[str] = None
+    """The authentication token or API key value"""
+
+    custom_headers: Optional[Dict[str, str]] = None
+    """Custom HTTP headers to include with requests"""
+
+    type: Optional[Literal["sse", "stdio", "streamable_http"]] = None
+
+
+McpServerModifyResponse: TypeAlias = Union[StdioMcpServer, SsemcpServer, StreamableHttpmcpServer]

letta_client/types/mcp_server_retrieve_response.py

@@ -0,0 +1,74 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Union, Optional
+from typing_extensions import Literal, TypeAlias
+
+from .._models import BaseModel
+
+__all__ = ["McpServerRetrieveResponse", "StdioMcpServer", "SsemcpServer", "StreamableHttpmcpServer"]
+
+
+class StdioMcpServer(BaseModel):
+    args: List[str]
+    """The arguments to pass to the command"""
+
+    command: str
+    """The command to run (MCP 'local' client will run this command)"""
+
+    server_name: str
+    """The name of the server"""
+
+    id: Optional[str] = None
+    """The human-friendly ID of the Mcp_server"""
+
+    env: Optional[Dict[str, str]] = None
+    """Environment variables to set"""
+
+    type: Optional[Literal["sse", "stdio", "streamable_http"]] = None
+
+
+class SsemcpServer(BaseModel):
+    server_name: str
+    """The name of the server"""
+
+    server_url: str
+    """The URL of the server"""
+
+    id: Optional[str] = None
+    """The human-friendly ID of the Mcp_server"""
+
+    auth_header: Optional[str] = None
+    """The name of the authentication header (e.g., 'Authorization')"""
+
+    auth_token: Optional[str] = None
+    """The authentication token or API key value"""
+
+    custom_headers: Optional[Dict[str, str]] = None
+    """Custom HTTP headers to include with requests"""
+
+    type: Optional[Literal["sse", "stdio", "streamable_http"]] = None
+
+
+class StreamableHttpmcpServer(BaseModel):
+    server_name: str
+    """The name of the server"""
+
+    server_url: str
+    """The URL of the server"""
+
+    id: Optional[str] = None
+    """The human-friendly ID of the Mcp_server"""
+
+    auth_header: Optional[str] = None
+    """The name of the authentication header (e.g., 'Authorization')"""
+
+    auth_token: Optional[str] = None
+    """The authentication token or API key value"""
+
+    custom_headers: Optional[Dict[str, str]] = None
+    """Custom HTTP headers to include with requests"""
+
+    type: Optional[Literal["sse", "stdio", "streamable_http"]] = None
+
+
+McpServerRetrieveResponse: TypeAlias = Union[StdioMcpServer, SsemcpServer, StreamableHttpmcpServer]

letta_client/types/mcp_servers/__init__.py

@@ -0,0 +1,8 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .tool_run_params import ToolRunParams as ToolRunParams
+from .tool_run_response import ToolRunResponse as ToolRunResponse
+from .tool_list_response import ToolListResponse as ToolListResponse
+from .refresh_trigger_params import RefreshTriggerParams as RefreshTriggerParams

letta_client/types/mcp_servers/refresh_trigger_params.py

@@ -0,0 +1,12 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import TypedDict
+
+__all__ = ["RefreshTriggerParams"]
+
+
+class RefreshTriggerParams(TypedDict, total=False):
+    agent_id: Optional[str]

letta_client/types/mcp_servers/tool_list_response.py

@@ -0,0 +1,10 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List
+from typing_extensions import TypeAlias
+
+from ..tool import Tool
+
+__all__ = ["ToolListResponse"]
+
+ToolListResponse: TypeAlias = List[Tool]

letta_client/types/mcp_servers/tool_run_params.py

@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict
+from typing_extensions import Required, TypedDict
+
+__all__ = ["ToolRunParams"]
+
+
+class ToolRunParams(TypedDict, total=False):
+    mcp_server_id: Required[str]
+
+    args: Dict[str, object]
+    """Arguments to pass to the MCP tool"""