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

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"""

letta_client/types/mcp_servers/tool_run_response.py

@@ -0,0 +1,43 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+from ..agent_state import AgentState
+
+__all__ = ["ToolRunResponse"]
+
+
+class ToolRunResponse(BaseModel):
+    status: Literal["success", "error"]
+    """The status of the tool execution and return object"""
+
+    agent_state: Optional[AgentState] = None
+    """Representation of an agent's state.
+
+    This is the state of the agent at a given time, and is persisted in the DB
+    backend. The state has all the information needed to recreate a persisted agent.
+
+    Parameters: id (str): The unique identifier of the agent. name (str): The name
+    of the agent (must be unique to the user). created_at (datetime): The datetime
+    the agent was created. message_ids (List[str]): The ids of the messages in the
+    agent's in-context memory. memory (Memory): The in-context memory of the agent.
+    tools (List[str]): The tools used by the agent. This includes any memory editing
+    functions specified in `memory`. system (str): The system prompt used by the
+    agent. llm_config (LLMConfig): The LLM configuration used by the agent.
+    embedding_config (EmbeddingConfig): The embedding configuration used by the
+    agent.
+    """
+
+    func_return: Optional[object] = None
+    """The function return object"""
+
+    sandbox_config_fingerprint: Optional[str] = None
+    """The fingerprint of the config for the sandbox"""
+
+    stderr: Optional[List[str]] = None
+    """Captured stderr from the function invocation"""
+
+    stdout: Optional[List[str]] = None
+    """Captured stdout (prints, logs) from function invocation"""

letta_client/types/step_list_params.py

@@ -3,10 +3,9 @@
 from __future__ import annotations
 
 from typing import Optional
-from typing_extensions import Literal, Annotated, TypedDict
+from typing_extensions import Literal, TypedDict
 
 from .._types import SequenceNotStr
-from .._utils import PropertyInfo
 
 __all__ = ["StepListParams"]
 
@@ -56,6 +55,3 @@ class StepListParams(TypedDict, total=False):
 
     trace_ids: Optional[SequenceNotStr[str]]
     """Filter by trace ids returned by the server"""
-
-    x_project: Annotated[str, PropertyInfo(alias="X-Project")]
-    """Filter by project slug to associate with the group (cloud only)."""

letta_client/types/tool.py

@@ -1,12 +1,12 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-from typing import Dict, List, Optional
+import typing
+import inspect
 from abc import abstractmethod
+from typing import Dict, List, Optional
 from textwrap import dedent
-import inspect
-import typing
 
-from pydantic import Field as FieldInfo, Field
+from pydantic import Field, Field as FieldInfo
 
 from .._models import BaseModel
 from .tool_type import ToolType

{letta_client-1.0.0a11.dist-info → letta_client-1.0.0a12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: letta-client
-Version: 1.0.0a11
+Version: 1.0.0a12
 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