letta-client 1.0.0a4__py3-none-any.whl → 1.0.0a6__py3-none-any.whl

letta_sdk/types/agents/archival_memory_list_params.py

@@ -0,0 +1,28 @@
+# 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__ = ["ArchivalMemoryListParams"]
+
+
+class ArchivalMemoryListParams(TypedDict, total=False):
+    after: Optional[str]
+    """Unique ID of the memory to start the query range at."""
+
+    ascending: Optional[bool]
+    """
+    Whether to sort passages oldest to newest (True, default) or newest to oldest
+    (False)
+    """
+
+    before: Optional[str]
+    """Unique ID of the memory to end the query range at."""
+
+    limit: Optional[int]
+    """How many results to include in the response."""
+
+    search: Optional[str]
+    """Search passages by text"""

letta_sdk/types/agents/archival_memory_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 ..passage import Passage
+
+__all__ = ["ArchivalMemoryListResponse"]
+
+ArchivalMemoryListResponse: TypeAlias = List[Passage]

letta_sdk/types/agents/archival_memory_search_params.py

@@ -0,0 +1,35 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union, Optional
+from datetime import datetime
+from typing_extensions import Literal, Required, Annotated, TypedDict
+
+from ..._types import SequenceNotStr
+from ..._utils import PropertyInfo
+
+__all__ = ["ArchivalMemorySearchParams"]
+
+
+class ArchivalMemorySearchParams(TypedDict, total=False):
+    query: Required[str]
+    """String to search for using semantic similarity"""
+
+    end_datetime: Annotated[Union[str, datetime, None], PropertyInfo(format="iso8601")]
+    """Filter results to passages created before this datetime"""
+
+    start_datetime: Annotated[Union[str, datetime, None], PropertyInfo(format="iso8601")]
+    """Filter results to passages created after this datetime"""
+
+    tag_match_mode: Literal["any", "all"]
+    """
+    How to match tags - 'any' to match passages with any of the tags, 'all' to match
+    only passages with all tags
+    """
+
+    tags: Optional[SequenceNotStr[str]]
+    """Optional list of tags to filter search results"""
+
+    top_k: Optional[int]
+    """Maximum number of results to return. Uses system default if not specified"""

letta_sdk/types/agents/archival_memory_search_response.py

@@ -0,0 +1,26 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+
+from ..._models import BaseModel
+
+__all__ = ["ArchivalMemorySearchResponse", "Result"]
+
+
+class Result(BaseModel):
+    content: str
+    """Text content of the archival memory passage"""
+
+    timestamp: str
+    """Timestamp of when the memory was created, formatted in agent's timezone"""
+
+    tags: Optional[List[str]] = None
+    """List of tags associated with this memory"""
+
+
+class ArchivalMemorySearchResponse(BaseModel):
+    count: int
+    """Total number of results returned"""
+
+    results: List[Result]
+    """List of search results matching the query"""

letta_sdk/types/agents/assistant_message.py

@@ -0,0 +1,39 @@
+# 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):
+    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_sdk/types/agents/core_memory/__init__.py

@@ -0,0 +1,7 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .block import Block as Block
+from .block_list_response import BlockListResponse as BlockListResponse
+from .block_update_params import BlockUpdateParams as BlockUpdateParams

letta_sdk/types/agents/core_memory/block.py

@@ -0,0 +1,60 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, Optional
+
+from ...._models import BaseModel
+
+__all__ = ["Block"]
+
+
+class Block(BaseModel):
+    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."""
+
+    name: Optional[str] = None
+    """The id of the template."""
+
+    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."""

letta_sdk/types/agents/core_memory/block_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 .block import Block
+
+__all__ = ["BlockListResponse"]
+
+BlockListResponse: TypeAlias = List[Block]

letta_sdk/types/agents/core_memory/block_update_params.py

@@ -0,0 +1,54 @@
+# 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
+
+__all__ = ["BlockUpdateParams"]
+
+
+class BlockUpdateParams(TypedDict, total=False):
+    agent_id: Required[str]
+
+    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."""
+
+    name: Optional[str]
+    """The id of the template."""
+
+    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."""
+
+    value: Optional[str]
+    """Value of the block."""

letta_sdk/types/agents/core_memory_retrieve_variables_response.py

@@ -0,0 +1,11 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict
+
+from ..._models import BaseModel
+
+__all__ = ["CoreMemoryRetrieveVariablesResponse"]
+
+
+class CoreMemoryRetrieveVariablesResponse(BaseModel):
+    variables: Dict[str, str]

letta_sdk/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_sdk/types/agents/file_list_params.py

@@ -0,0 +1,19 @@
+# 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__ = ["FileListParams"]
+
+
+class FileListParams(TypedDict, total=False):
+    cursor: Optional[str]
+    """Pagination cursor from previous response"""
+
+    is_open: Optional[bool]
+    """Filter by open status (true for open files, false for closed files)"""
+
+    limit: int
+    """Number of items to return (1-100)"""

letta_sdk/types/agents/file_list_response.py

@@ -0,0 +1,51 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from datetime import datetime
+
+from ..._models import BaseModel
+
+__all__ = ["FileListResponse", "File"]
+
+
+class File(BaseModel):
+    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"""
+
+
+class FileListResponse(BaseModel):
+    files: List[File]
+    """List of file attachments for the agent"""
+
+    has_more: bool
+    """Whether more results exist after this page"""
+
+    next_cursor: Optional[str] = None
+    """Cursor for fetching the next page (file-agent relationship ID)"""

letta_sdk/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_sdk/types/agents/folder_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 ..source import Source
+
+__all__ = ["FolderListResponse"]
+
+FolderListResponse: TypeAlias = List[Source]

letta_sdk/types/agents/hidden_reasoning_message.py

@@ -0,0 +1,36 @@
+# 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):
+    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_sdk/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_sdk/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."""

letta_sdk/types/agents/job_status.py

@@ -0,0 +1,7 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal, TypeAlias
+
+__all__ = ["JobStatus"]
+
+JobStatus: TypeAlias = Literal["created", "running", "completed", "failed", "pending", "cancelled", "expired"]

letta_sdk/types/agents/job_type.py

@@ -0,0 +1,7 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal, TypeAlias
+
+__all__ = ["JobType"]
+
+JobType: TypeAlias = Literal["job", "run", "batch"]

letta_sdk/types/agents/letta_assistant_message_content_union.py

@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["LettaAssistantMessageContentUnion"]
+
+
+class LettaAssistantMessageContentUnion(BaseModel):
+    text: str
+    """The text content of the message."""
+
+    type: Optional[Literal["text"]] = None
+    """The type of the message."""

letta_sdk/types/agents/letta_assistant_message_content_union_param.py

@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["LettaAssistantMessageContentUnionParam"]
+
+
+class LettaAssistantMessageContentUnionParam(TypedDict, total=False):
+    text: Required[str]
+    """The text content of the message."""
+
+    type: Literal["text"]
+    """The type of the message."""

letta_sdk/types/agents/letta_message_union.py

@@ -0,0 +1,32 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union
+from typing_extensions import Annotated, TypeAlias
+
+from ..._utils import PropertyInfo
+from .user_message import UserMessage
+from .system_message import SystemMessage
+from .assistant_message import AssistantMessage
+from .reasoning_message import ReasoningMessage
+from .tool_call_message import ToolCallMessage
+from ..tool_return_message import ToolReturnMessage
+from .approval_request_message import ApprovalRequestMessage
+from .hidden_reasoning_message import HiddenReasoningMessage
+from .approval_response_message import ApprovalResponseMessage
+
+__all__ = ["LettaMessageUnion"]
+
+LettaMessageUnion: TypeAlias = Annotated[
+    Union[
+        SystemMessage,
+        UserMessage,
+        ReasoningMessage,
+        HiddenReasoningMessage,
+        ToolCallMessage,
+        ToolReturnMessage,
+        AssistantMessage,
+        ApprovalRequestMessage,
+        ApprovalResponseMessage,
+    ],
+    PropertyInfo(discriminator="message_type"),
+]