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

letta_client/types/agents/approval_return_param.py

@@ -0,0 +1,22 @@
+# 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__ = ["ApprovalReturnParam"]
+
+
+class ApprovalReturnParam(TypedDict, total=False):
+    approve: Required[bool]
+    """Whether the tool has been approved"""
+
+    tool_call_id: Required[str]
+    """The ID of the tool call that corresponds to this approval"""
+
+    reason: Optional[str]
+    """An optional explanation for the provided approval status"""
+
+    type: Literal["approval"]
+    """The message type to be created."""

letta_client/types/agents/assistant_message.py

@@ -0,0 +1,48 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Union, Optional
+from datetime import datetime
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+from .letta_assistant_message_content_union import LettaAssistantMessageContentUnion
+
+__all__ = ["AssistantMessage"]
+
+
+class AssistantMessage(BaseModel):
+    """A message sent by the LLM in response to user input. Used in the LLM context.
+
+    Args:
+        id (str): The ID of the message
+        date (datetime): The date the message was created in ISO format
+        name (Optional[str]): The name of the sender of the message
+        content (Union[str, List[LettaAssistantMessageContentUnion]]): The message content sent by the agent (can be a string or an array of content parts)
+    """
+
+    id: str
+
+    content: Union[List[LettaAssistantMessageContentUnion], str]
+    """
+    The message content sent by the agent (can be a string or an array of content
+    parts)
+    """
+
+    date: datetime
+
+    is_err: Optional[bool] = None
+
+    message_type: Optional[Literal["assistant_message"]] = None
+    """The type of the message."""
+
+    name: Optional[str] = None
+
+    otid: Optional[str] = None
+
+    run_id: Optional[str] = None
+
+    sender_id: Optional[str] = None
+
+    seq_id: Optional[int] = None
+
+    step_id: Optional[str] = None

letta_client/types/agents/block.py

@@ -0,0 +1,68 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Optional
+
+from ..._models import BaseModel
+
+__all__ = ["Block"]
+
+
+class Block(BaseModel):
+    """A Block represents a reserved section of the LLM's context window."""
+
+    value: str
+    """Value of the block."""
+
+    id: Optional[str] = None
+    """The human-friendly ID of the Block"""
+
+    base_template_id: Optional[str] = None
+    """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
+    """The id of the deployment."""
+
+    description: Optional[str] = None
+    """Description of the block."""
+
+    entity_id: Optional[str] = None
+    """The id of the entity within the template."""
+
+    hidden: Optional[bool] = None
+    """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
+    """Preserve the block on template migration."""
+
+    project_id: Optional[str] = None
+    """The associated project id."""
+
+    read_only: Optional[bool] = None
+    """Whether the agent has read-only access to the block."""
+
+    tags: Optional[List[str]] = None
+    """The tags associated with the block."""
+
+    template_id: Optional[str] = None
+    """The id of the template."""
+
+    template_name: Optional[str] = None
+    """Name of the block if it is a template."""

letta_client/types/agents/block_list_params.py

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

letta_client/types/agents/block_update_params.py

@@ -0,0 +1,63 @@
+# 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__ = ["BlockUpdateParams"]
+
+
+class BlockUpdateParams(TypedDict, total=False):
+    agent_id: Required[str]
+    """The ID of the agent in the format 'agent-<uuid4>'"""
+
+    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
+    """Whether the block is a template (e.g. saved human/persona options)."""
+
+    label: Optional[str]
+    """Label of the block (e.g. 'human', 'persona') in the context window."""
+
+    limit: Optional[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."""
+
+    value: Optional[str]
+    """Value of the block."""

letta_client/types/agents/event_message.py

@@ -0,0 +1,40 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, Optional
+from datetime import datetime
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["EventMessage"]
+
+
+class EventMessage(BaseModel):
+    """A message for notifying the developer that an event that has occured (e.g.
+
+    a compaction). Events are NOT part of the context window.
+    """
+
+    id: str
+
+    date: datetime
+
+    event_data: Dict[str, object]
+
+    event_type: Literal["compaction"]
+
+    is_err: Optional[bool] = None
+
+    message_type: Optional[Literal["event"]] = None
+
+    name: Optional[str] = None
+
+    otid: Optional[str] = None
+
+    run_id: Optional[str] = None
+
+    sender_id: Optional[str] = None
+
+    seq_id: Optional[int] = None
+
+    step_id: Optional[str] = None

letta_client/types/agents/file_close_all_response.py

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

letta_client/types/agents/file_list_params.py

@@ -0,0 +1,40 @@
+# 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__ = ["FileListParams"]
+
+
+class FileListParams(TypedDict, total=False):
+    after: Optional[str]
+    """File ID cursor for pagination.
+
+    Returns files that come after this file ID in the specified sort order
+    """
+
+    before: Optional[str]
+    """File ID cursor for pagination.
+
+    Returns files that come before this file ID in the specified sort order
+    """
+
+    cursor: Optional[str]
+    """Pagination cursor from previous response (deprecated, use before/after)"""
+
+    is_open: Optional[bool]
+    """Filter by open status (true for open files, false for closed files)"""
+
+    limit: Optional[int]
+    """Maximum number of files to return"""
+
+    order: Literal["asc", "desc"]
+    """Sort order for files by creation time.
+
+    'asc' for oldest first, 'desc' for newest first
+    """
+
+    order_by: Literal["created_at"]
+    """Field to sort by"""

letta_client/types/agents/file_list_response.py

@@ -0,0 +1,42 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from datetime import datetime
+
+from ..._models import BaseModel
+
+__all__ = ["FileListResponse"]
+
+
+class FileListResponse(BaseModel):
+    """Response model for agent file attachments showing file status in agent context"""
+
+    id: str
+    """Unique identifier of the file-agent relationship"""
+
+    file_id: str
+    """Unique identifier of the file"""
+
+    file_name: str
+    """Name of the file"""
+
+    folder_id: str
+    """Unique identifier of the folder/source"""
+
+    folder_name: str
+    """Name of the folder/source"""
+
+    is_open: bool
+    """Whether the file is currently open in the agent's context"""
+
+    end_line: Optional[int] = None
+    """Ending line number if file was opened with line range"""
+
+    last_accessed_at: Optional[datetime] = None
+    """Timestamp of last access by the agent"""
+
+    start_line: Optional[int] = None
+    """Starting line number if file was opened with line range"""
+
+    visible_content: Optional[str] = None
+    """Portion of the file visible to the agent if open"""

letta_client/types/agents/file_open_response.py

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

letta_client/types/agents/folder_list_params.py

@@ -0,0 +1,34 @@
+# 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]
+    """Source ID cursor for pagination.
+
+    Returns sources that come after this source ID in the specified sort order
+    """
+
+    before: Optional[str]
+    """Source ID cursor for pagination.
+
+    Returns sources that come before this source ID in the specified sort order
+    """
+
+    limit: Optional[int]
+    """Maximum number of sources to return"""
+
+    order: Literal["asc", "desc"]
+    """Sort order for sources by creation time.
+
+    'asc' for oldest first, 'desc' for newest first
+    """
+
+    order_by: Literal["created_at"]
+    """Field to sort by"""

letta_client/types/agents/folder_list_response.py

@@ -0,0 +1,49 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, Optional
+from datetime import datetime
+
+from ..._models import BaseModel
+from ..embedding_config import EmbeddingConfig
+from ..vector_db_provider import VectorDBProvider
+
+__all__ = ["FolderListResponse"]
+
+
+class FolderListResponse(BaseModel):
+    """
+    (Deprecated: Use Folder) Representation of a source, which is a collection of files and passages.
+    """
+
+    id: str
+    """The human-friendly ID of the Source"""
+
+    embedding_config: EmbeddingConfig
+    """The embedding configuration used by the source."""
+
+    name: str
+    """The name of the source."""
+
+    created_at: Optional[datetime] = None
+    """The timestamp when the source was created."""
+
+    created_by_id: Optional[str] = None
+    """The id of the user that made this Tool."""
+
+    description: Optional[str] = None
+    """The description of the source."""
+
+    instructions: Optional[str] = None
+    """Instructions for how to use the source."""
+
+    last_updated_by_id: Optional[str] = None
+    """The id of the user that made this Tool."""
+
+    metadata: Optional[Dict[str, object]] = None
+    """Metadata associated with the source."""
+
+    updated_at: Optional[datetime] = None
+    """The timestamp when the source was last updated."""
+
+    vector_db_provider: Optional[VectorDBProvider] = None
+    """The vector database provider used for this source's passages"""

letta_client/types/agents/hidden_reasoning_message.py

@@ -0,0 +1,49 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from datetime import datetime
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["HiddenReasoningMessage"]
+
+
+class HiddenReasoningMessage(BaseModel):
+    """
+    Representation of an agent's internal reasoning where reasoning content
+    has been hidden from the response.
+
+    Args:
+        id (str): The ID of the message
+        date (datetime): The date the message was created in ISO format
+        name (Optional[str]): The name of the sender of the message
+        state (Literal["redacted", "omitted"]): Whether the reasoning
+            content was redacted by the provider or simply omitted by the API
+        hidden_reasoning (Optional[str]): The internal reasoning of the agent
+    """
+
+    id: str
+
+    date: datetime
+
+    state: Literal["redacted", "omitted"]
+
+    hidden_reasoning: Optional[str] = None
+
+    is_err: Optional[bool] = None
+
+    message_type: Optional[Literal["hidden_reasoning_message"]] = None
+    """The type of the message."""
+
+    name: Optional[str] = None
+
+    otid: Optional[str] = None
+
+    run_id: Optional[str] = None
+
+    sender_id: Optional[str] = None
+
+    seq_id: Optional[int] = None
+
+    step_id: Optional[str] = None

letta_client/types/agents/image_content.py

@@ -0,0 +1,67 @@
+# 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
+
+__all__ = ["ImageContent", "Source", "SourceURLImage", "SourceBase64Image", "SourceLettaImage"]
+
+
+class SourceURLImage(BaseModel):
+    url: str
+    """The URL of the image."""
+
+    type: Optional[Literal["url"]] = None
+    """The source type for the image."""
+
+
+class SourceBase64Image(BaseModel):
+    data: str
+    """The base64 encoded image data."""
+
+    media_type: str
+    """The media type for the image."""
+
+    detail: Optional[str] = None
+    """
+    What level of detail to use when processing and understanding the image (low,
+    high, or auto to let the model decide)
+    """
+
+    type: Optional[Literal["base64"]] = None
+    """The source type for the image."""
+
+
+class SourceLettaImage(BaseModel):
+    file_id: str
+    """The unique identifier of the image file persisted in storage."""
+
+    data: Optional[str] = None
+    """The base64 encoded image data."""
+
+    detail: Optional[str] = None
+    """
+    What level of detail to use when processing and understanding the image (low,
+    high, or auto to let the model decide)
+    """
+
+    media_type: Optional[str] = None
+    """The media type for the image."""
+
+    type: Optional[Literal["letta"]] = None
+    """The source type for the image."""
+
+
+Source: TypeAlias = Annotated[
+    Union[SourceURLImage, SourceBase64Image, SourceLettaImage], PropertyInfo(discriminator="type")
+]
+
+
+class ImageContent(BaseModel):
+    source: Source
+    """The source of the image."""
+
+    type: Optional[Literal["image"]] = None
+    """The type of the message."""

letta_client/types/agents/image_content_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 Union, Optional
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
+
+__all__ = ["ImageContentParam", "Source", "SourceURLImage", "SourceBase64Image", "SourceLettaImage"]
+
+
+class SourceURLImage(TypedDict, total=False):
+    url: Required[str]
+    """The URL of the image."""
+
+    type: Literal["url"]
+    """The source type for the image."""
+
+
+class SourceBase64Image(TypedDict, total=False):
+    data: Required[str]
+    """The base64 encoded image data."""
+
+    media_type: Required[str]
+    """The media type for the image."""
+
+    detail: Optional[str]
+    """
+    What level of detail to use when processing and understanding the image (low,
+    high, or auto to let the model decide)
+    """
+
+    type: Literal["base64"]
+    """The source type for the image."""
+
+
+class SourceLettaImage(TypedDict, total=False):
+    file_id: Required[str]
+    """The unique identifier of the image file persisted in storage."""
+
+    data: Optional[str]
+    """The base64 encoded image data."""
+
+    detail: Optional[str]
+    """
+    What level of detail to use when processing and understanding the image (low,
+    high, or auto to let the model decide)
+    """
+
+    media_type: Optional[str]
+    """The media type for the image."""
+
+    type: Literal["letta"]
+    """The source type for the image."""
+
+
+Source: TypeAlias = Union[SourceURLImage, SourceBase64Image, SourceLettaImage]
+
+
+class ImageContentParam(TypedDict, total=False):
+    source: Required[Source]
+    """The source of the image."""
+
+    type: Literal["image"]
+    """The type of the message."""