letta-client 0.1.232__py3-none-any.whl → 1.7.2__py3-none-any.whl

letta_client/types/create_block_param.py

@@ -0,0 +1,61 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Optional
+from typing_extensions import Required, TypedDict
+
+from .._types import SequenceNotStr
+
+__all__ = ["CreateBlockParam"]
+
+
+class CreateBlockParam(TypedDict, total=False):
+    """Create a block"""
+
+    label: Required[str]
+    """Label of the block."""
+
+    value: Required[str]
+    """Value of the block."""
+
+    base_template_id: Optional[str]
+    """The base template id of the block."""
+
+    deployment_id: Optional[str]
+    """The id of the deployment."""
+
+    description: Optional[str]
+    """Description of the block."""
+
+    entity_id: Optional[str]
+    """The id of the entity within the template."""
+
+    hidden: Optional[bool]
+    """If set to True, the block will be hidden."""
+
+    is_template: bool
+
+    limit: int
+    """Character limit of the block."""
+
+    metadata: Optional[Dict[str, object]]
+    """Metadata of the block."""
+
+    preserve_on_migration: Optional[bool]
+    """Preserve the block on template migration."""
+
+    project_id: Optional[str]
+    """The associated project id."""
+
+    read_only: bool
+    """Whether the agent has read-only access to the block."""
+
+    tags: Optional[SequenceNotStr[str]]
+    """The tags to associate with 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/create_sse_mcp_server_param.py

@@ -0,0 +1,26 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Optional
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["CreateSseMcpServerParam"]
+
+
+class CreateSseMcpServerParam(TypedDict, total=False):
+    """Create a new SSE MCP 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"""
+
+    mcp_server_type: Literal["sse"]

letta_client/types/create_stdio_mcp_server_param.py

@@ -0,0 +1,25 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Optional
+from typing_extensions import Literal, Required, TypedDict
+
+from .._types import SequenceNotStr
+
+__all__ = ["CreateStdioMcpServerParam"]
+
+
+class CreateStdioMcpServerParam(TypedDict, total=False):
+    """Create a new Stdio MCP server"""
+
+    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)"""
+
+    env: Optional[Dict[str, str]]
+    """Environment variables to set"""
+
+    mcp_server_type: Literal["stdio"]

letta_client/types/create_streamable_http_mcp_server_param.py

@@ -0,0 +1,26 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Optional
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["CreateStreamableHTTPMcpServerParam"]
+
+
+class CreateStreamableHTTPMcpServerParam(TypedDict, total=False):
+    """Create a new Streamable HTTP MCP 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"""
+
+    mcp_server_type: Literal["streamable_http"]

letta_client/types/deepseek_model_settings.py

@@ -0,0 +1,36 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union, Optional
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from .._utils import PropertyInfo
+from .._models import BaseModel
+from .text_response_format import TextResponseFormat
+from .json_object_response_format import JsonObjectResponseFormat
+from .json_schema_response_format import JsonSchemaResponseFormat
+
+__all__ = ["DeepseekModelSettings", "ResponseFormat"]
+
+ResponseFormat: TypeAlias = Annotated[
+    Union[TextResponseFormat, JsonSchemaResponseFormat, JsonObjectResponseFormat, None],
+    PropertyInfo(discriminator="type"),
+]
+
+
+class DeepseekModelSettings(BaseModel):
+    """Deepseek model configuration (OpenAI-compatible)."""
+
+    max_output_tokens: Optional[int] = None
+    """The maximum number of tokens the model can generate."""
+
+    parallel_tool_calls: Optional[bool] = None
+    """Whether to enable parallel tool calling."""
+
+    provider_type: Optional[Literal["deepseek"]] = None
+    """The type of the provider."""
+
+    response_format: Optional[ResponseFormat] = None
+    """The response format for the model."""
+
+    temperature: Optional[float] = None
+    """The temperature of the model."""

letta_client/types/deepseek_model_settings_param.py

@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union, Optional
+from typing_extensions import Literal, TypeAlias, TypedDict
+
+from .text_response_format_param import TextResponseFormatParam
+from .json_object_response_format_param import JsonObjectResponseFormatParam
+from .json_schema_response_format_param import JsonSchemaResponseFormatParam
+
+__all__ = ["DeepseekModelSettingsParam", "ResponseFormat"]
+
+ResponseFormat: TypeAlias = Union[TextResponseFormatParam, JsonSchemaResponseFormatParam, JsonObjectResponseFormatParam]
+
+
+class DeepseekModelSettingsParam(TypedDict, total=False):
+    """Deepseek model configuration (OpenAI-compatible)."""
+
+    max_output_tokens: int
+    """The maximum number of tokens the model can generate."""
+
+    parallel_tool_calls: bool
+    """Whether to enable parallel tool calling."""
+
+    provider_type: Literal["deepseek"]
+    """The type of the provider."""
+
+    response_format: Optional[ResponseFormat]
+    """The response format for the model."""
+
+    temperature: float
+    """The temperature of the model."""

letta_client/types/embedding_config.py

@@ -1,82 +1,62 @@
-# This file was auto-generated by Fern from our API Definition.
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-from ..core.unchecked_base_model import UncheckedBaseModel
-from .embedding_config_embedding_endpoint_type import EmbeddingConfigEmbeddingEndpointType
-import pydantic
-import typing
-from ..core.pydantic_utilities import IS_PYDANTIC_V2
+from typing import Optional
+from typing_extensions import Literal
 
+from .._models import BaseModel
 
-class EmbeddingConfig(UncheckedBaseModel):
-    """
-    Embedding model configuration. This object specifies all the information necessary to access an embedding model to usage with Letta, except for secret keys.
+__all__ = ["EmbeddingConfig"]
 
-    Attributes:
-        embedding_endpoint_type (str): The endpoint type for the model.
-        embedding_endpoint (str): The endpoint for the model.
-        embedding_model (str): The model for the embedding.
-        embedding_dim (int): The dimension of the embedding.
-        embedding_chunk_size (int): The chunk size of the embedding.
-        azure_endpoint (:obj:`str`, optional): The Azure endpoint for the model (Azure only).
-        azure_version (str): The Azure version for the model (Azure only).
-        azure_deployment (str): The Azure deployment for the model (Azure only).
-    """
 
-    embedding_endpoint_type: EmbeddingConfigEmbeddingEndpointType = pydantic.Field()
-    """
-    The endpoint type for the model.
-    """
+class EmbeddingConfig(BaseModel):
+    """Configuration for embedding model connection and processing parameters."""
 
-    embedding_endpoint: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    The endpoint for the model (`None` if local).
-    """
+    embedding_dim: int
+    """The dimension of the embedding."""
 
-    embedding_model: str = pydantic.Field()
-    """
-    The model for the embedding.
-    """
+    embedding_endpoint_type: Literal[
+        "openai",
+        "anthropic",
+        "bedrock",
+        "google_ai",
+        "google_vertex",
+        "azure",
+        "groq",
+        "ollama",
+        "webui",
+        "webui-legacy",
+        "lmstudio",
+        "lmstudio-legacy",
+        "llamacpp",
+        "koboldcpp",
+        "vllm",
+        "hugging-face",
+        "mistral",
+        "together",
+        "pinecone",
+    ]
+    """The endpoint type for the model."""
 
-    embedding_dim: int = pydantic.Field()
-    """
-    The dimension of the embedding.
-    """
+    embedding_model: str
+    """The model for the embedding."""
 
-    embedding_chunk_size: typing.Optional[int] = pydantic.Field(default=None)
-    """
-    The chunk size of the embedding.
-    """
+    azure_deployment: Optional[str] = None
+    """The Azure deployment for the model."""
 
-    handle: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    The handle for this config, in the format provider/model-name.
-    """
+    azure_endpoint: Optional[str] = None
+    """The Azure endpoint for the model."""
 
-    batch_size: typing.Optional[int] = pydantic.Field(default=None)
-    """
-    The maximum batch size for processing embeddings.
-    """
+    azure_version: Optional[str] = None
+    """The Azure version for the model."""
 
-    azure_endpoint: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    The Azure endpoint for the model.
-    """
+    batch_size: Optional[int] = None
+    """The maximum batch size for processing embeddings."""
 
-    azure_version: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    The Azure version for the model.
-    """
+    embedding_chunk_size: Optional[int] = None
+    """The chunk size of the embedding."""
 
-    azure_deployment: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    The Azure deployment for the model.
-    """
+    embedding_endpoint: Optional[str] = None
+    """The endpoint for the model (`None` if local)."""
 
-    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
+    handle: Optional[str] = None
+    """The handle for this config, in the format provider/model-name."""

letta_client/types/embedding_config_param.py

@@ -0,0 +1,64 @@
+# 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 Literal, Required, TypedDict
+
+__all__ = ["EmbeddingConfigParam"]
+
+
+class EmbeddingConfigParam(TypedDict, total=False):
+    """Configuration for embedding model connection and processing parameters."""
+
+    embedding_dim: Required[int]
+    """The dimension of the embedding."""
+
+    embedding_endpoint_type: Required[
+        Literal[
+            "openai",
+            "anthropic",
+            "bedrock",
+            "google_ai",
+            "google_vertex",
+            "azure",
+            "groq",
+            "ollama",
+            "webui",
+            "webui-legacy",
+            "lmstudio",
+            "lmstudio-legacy",
+            "llamacpp",
+            "koboldcpp",
+            "vllm",
+            "hugging-face",
+            "mistral",
+            "together",
+            "pinecone",
+        ]
+    ]
+    """The endpoint type for the model."""
+
+    embedding_model: Required[str]
+    """The model for the embedding."""
+
+    azure_deployment: Optional[str]
+    """The Azure deployment for the model."""
+
+    azure_endpoint: Optional[str]
+    """The Azure endpoint for the model."""
+
+    azure_version: Optional[str]
+    """The Azure version for the model."""
+
+    batch_size: int
+    """The maximum batch size for processing embeddings."""
+
+    embedding_chunk_size: Optional[int]
+    """The chunk size of the embedding."""
+
+    embedding_endpoint: Optional[str]
+    """The endpoint for the model (`None` if local)."""
+
+    handle: Optional[str]
+    """The handle for this config, in the format provider/model-name."""

letta_client/types/embedding_model.py

@@ -0,0 +1,81 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+from .provider_type import ProviderType
+
+__all__ = ["EmbeddingModel"]
+
+
+class EmbeddingModel(BaseModel):
+    display_name: str
+    """Display name for the model shown in UI"""
+
+    embedding_dim: int
+    """The dimension of the embedding"""
+
+    embedding_endpoint_type: Literal[
+        "openai",
+        "anthropic",
+        "bedrock",
+        "google_ai",
+        "google_vertex",
+        "azure",
+        "groq",
+        "ollama",
+        "webui",
+        "webui-legacy",
+        "lmstudio",
+        "lmstudio-legacy",
+        "llamacpp",
+        "koboldcpp",
+        "vllm",
+        "hugging-face",
+        "mistral",
+        "together",
+        "pinecone",
+    ]
+    """Deprecated: Use 'provider_type' field instead.
+
+    The endpoint type for the embedding model.
+    """
+
+    embedding_model: str
+    """Deprecated: Use 'name' field instead. Embedding model name."""
+
+    name: str
+    """The actual model name used by the provider"""
+
+    provider_name: str
+    """The name of the provider"""
+
+    provider_type: ProviderType
+    """The type of the provider"""
+
+    azure_deployment: Optional[str] = None
+    """Deprecated: The Azure deployment for the model."""
+
+    azure_endpoint: Optional[str] = None
+    """Deprecated: The Azure endpoint for the model."""
+
+    azure_version: Optional[str] = None
+    """Deprecated: The Azure version for the model."""
+
+    batch_size: Optional[int] = None
+    """Deprecated: The maximum batch size for processing embeddings."""
+
+    embedding_chunk_size: Optional[int] = None
+    """Deprecated: The chunk size of the embedding."""
+
+    embedding_endpoint: Optional[str] = None
+    """Deprecated: The endpoint for the model."""
+
+    handle: Optional[str] = None
+    """The handle for this config, in the format provider/model-name."""
+
+    api_model_type: Optional[Literal["embedding"]] = FieldInfo(alias="model_type", default=None)
+    """Type of model (llm or embedding)"""

letta_client/types/folder.py

@@ -1,81 +1,43 @@
-# This file was auto-generated by Fern from our API Definition.
-
-from ..core.unchecked_base_model import UncheckedBaseModel
-import pydantic
-import typing
-from .embedding_config import EmbeddingConfig
-import datetime as dt
-from ..core.pydantic_utilities import IS_PYDANTIC_V2
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
+from typing import Dict, Optional
+from datetime import datetime
 
-class Folder(UncheckedBaseModel):
-    """
-    Representation of a folder, which is a collection of files and passages.
+from .._models import BaseModel
+from .embedding_config import EmbeddingConfig
 
-    Parameters:
-        id (str): The ID of the folder
-        name (str): The name of the folder.
-        embedding_config (EmbeddingConfig): The embedding configuration used by the folder.
-        user_id (str): The ID of the user that created the folder.
-        metadata (dict): Metadata associated with the folder.
-        description (str): The description of the folder.
-    """
+__all__ = ["Folder"]
 
-    name: str = pydantic.Field()
-    """
-    The name of the folder.
-    """
 
-    description: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    The description of the folder.
-    """
+class Folder(BaseModel):
+    """Representation of a folder, which is a collection of files and passages."""
 
-    instructions: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    Instructions for how to use the folder.
-    """
+    id: str
+    """The human-friendly ID of the Source"""
 
-    metadata: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] = pydantic.Field(default=None)
-    """
-    Metadata associated with the folder.
-    """
+    embedding_config: EmbeddingConfig
+    """The embedding configuration used by the folder."""
 
-    id: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    The human-friendly ID of the Source
-    """
+    name: str
+    """The name of the folder."""
 
-    embedding_config: EmbeddingConfig = pydantic.Field()
-    """
-    The embedding configuration used by the folder.
-    """
+    created_at: Optional[datetime] = None
+    """The timestamp when the folder was created."""
 
-    created_by_id: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    The id of the user that made this Tool.
-    """
+    created_by_id: Optional[str] = None
+    """The id of the user that made this Tool."""
 
-    last_updated_by_id: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    The id of the user that made this Tool.
-    """
+    description: Optional[str] = None
+    """The description of the folder."""
 
-    created_at: typing.Optional[dt.datetime] = pydantic.Field(default=None)
-    """
-    The timestamp when the folder was created.
-    """
+    instructions: Optional[str] = None
+    """Instructions for how to use the folder."""
 
-    updated_at: typing.Optional[dt.datetime] = pydantic.Field(default=None)
-    """
-    The timestamp when the folder was last updated.
-    """
+    last_updated_by_id: Optional[str] = None
+    """The id of the user that made this Tool."""
 
-    if IS_PYDANTIC_V2:
-        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
-    else:
+    metadata: Optional[Dict[str, object]] = None
+    """Metadata associated with the folder."""
 
-        class Config:
-            frozen = True
-            smart_union = True
-            extra = pydantic.Extra.allow
+    updated_at: Optional[datetime] = None
+    """The timestamp when the folder was last updated."""

letta_client/types/folder_create_params.py

@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Optional
+from typing_extensions import Required, TypedDict
+
+from .embedding_config_param import EmbeddingConfigParam
+
+__all__ = ["FolderCreateParams"]
+
+
+class FolderCreateParams(TypedDict, total=False):
+    name: Required[str]
+    """The name of the source."""
+
+    description: Optional[str]
+    """The description of the source."""
+
+    embedding: Optional[str]
+    """The handle for the embedding config used by the source."""
+
+    embedding_chunk_size: Optional[int]
+    """The chunk size of the embedding."""
+
+    embedding_config: Optional[EmbeddingConfigParam]
+    """Configuration for embedding model connection and processing parameters."""
+
+    instructions: Optional[str]
+    """Instructions for how to use the source."""
+
+    metadata: Optional[Dict[str, object]]
+    """Metadata associated with the source."""

letta_client/types/folder_list_params.py

@@ -0,0 +1,37 @@
+# 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 Literal, TypedDict
+
+__all__ = ["FolderListParams"]
+
+
+class FolderListParams(TypedDict, total=False):
+    after: Optional[str]
+    """Folder ID cursor for pagination.
+
+    Returns folders that come after this folder ID in the specified sort order
+    """
+
+    before: Optional[str]
+    """Folder ID cursor for pagination.
+
+    Returns folders that come before this folder ID in the specified sort order
+    """
+
+    limit: Optional[int]
+    """Maximum number of folders to return"""
+
+    name: Optional[str]
+    """Folder name to filter by"""
+
+    order: Literal["asc", "desc"]
+    """Sort order for folders by creation time.
+
+    'asc' for oldest first, 'desc' for newest first
+    """
+
+    order_by: Literal["created_at"]
+    """Field to sort by"""