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

letta_sdk/types/agent_search_params.py

@@ -0,0 +1,78 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union, Iterable, Optional
+from typing_extensions import Literal, Required, Annotated, TypeAlias, TypedDict
+
+from .._types import SequenceNotStr
+from .._utils import PropertyInfo
+
+__all__ = [
+    "AgentSearchParams",
+    "Search",
+    "SearchUnionMember0",
+    "SearchUnionMember1",
+    "SearchUnionMember2",
+    "SearchUnionMember3",
+    "SearchUnionMember4",
+]
+
+
+class AgentSearchParams(TypedDict, total=False):
+    after: Optional[str]
+
+    ascending: bool
+
+    combinator: Literal["AND"]
+
+    limit: float
+
+    project_id: str
+
+    search: Iterable[Search]
+
+    sort_by: Annotated[Literal["created_at", "last_run_completion"], PropertyInfo(alias="sortBy")]
+
+
+class SearchUnionMember0(TypedDict, total=False):
+    field: Required[Literal["version"]]
+
+    value: Required[str]
+
+
+class SearchUnionMember1(TypedDict, total=False):
+    field: Required[Literal["name"]]
+
+    operator: Required[Literal["eq", "contains"]]
+
+    value: Required[str]
+
+
+class SearchUnionMember2(TypedDict, total=False):
+    field: Required[Literal["tags"]]
+
+    operator: Required[Literal["contains"]]
+
+    value: Required[SequenceNotStr[str]]
+
+
+class SearchUnionMember3(TypedDict, total=False):
+    field: Required[Literal["identity"]]
+
+    operator: Required[Literal["eq"]]
+
+    value: Required[str]
+
+
+class SearchUnionMember4(TypedDict, total=False):
+    field: Required[Literal["templateName"]]
+
+    operator: Required[Literal["eq"]]
+
+    value: Required[str]
+
+
+Search: TypeAlias = Union[
+    SearchUnionMember0, SearchUnionMember1, SearchUnionMember2, SearchUnionMember3, SearchUnionMember4
+]

letta_sdk/types/agent_search_response.py

@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+from .agent_state import AgentState
+
+__all__ = ["AgentSearchResponse"]
+
+
+class AgentSearchResponse(BaseModel):
+    agents: List[AgentState]
+
+    next_cursor: Optional[str] = FieldInfo(alias="nextCursor", default=None)

letta_sdk/types/agent_state.py

@@ -0,0 +1,170 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Union, Optional
+from datetime import datetime
+from typing_extensions import Annotated, TypeAlias
+
+from .tool import Tool
+from .group import Group
+from .source import Source
+from .._utils import PropertyInfo
+from .._models import BaseModel
+from .agent_type import AgentType
+from .llm_config import LlmConfig
+from .agents.memory import Memory
+from .init_tool_rule import InitToolRule
+from .child_tool_rule import ChildToolRule
+from .embedding_config import EmbeddingConfig
+from .parent_tool_rule import ParentToolRule
+from .continue_tool_rule import ContinueToolRule
+from .terminal_tool_rule import TerminalToolRule
+from .text_response_format import TextResponseFormat
+from .conditional_tool_rule import ConditionalToolRule
+from .agent_environment_variable import AgentEnvironmentVariable
+from .json_object_response_format import JsonObjectResponseFormat
+from .json_schema_response_format import JsonSchemaResponseFormat
+from .requires_approval_tool_rule import RequiresApprovalToolRule
+from .max_count_per_step_tool_rule import MaxCountPerStepToolRule
+from .required_before_exit_tool_rule import RequiredBeforeExitToolRule
+
+__all__ = ["AgentState", "ResponseFormat", "ToolRule"]
+
+ResponseFormat: TypeAlias = Annotated[
+    Union[TextResponseFormat, JsonSchemaResponseFormat, JsonObjectResponseFormat, None],
+    PropertyInfo(discriminator="type"),
+]
+
+ToolRule: TypeAlias = Annotated[
+    Union[
+        ChildToolRule,
+        InitToolRule,
+        TerminalToolRule,
+        ConditionalToolRule,
+        ContinueToolRule,
+        RequiredBeforeExitToolRule,
+        MaxCountPerStepToolRule,
+        ParentToolRule,
+        RequiresApprovalToolRule,
+    ],
+    PropertyInfo(discriminator="type"),
+]
+
+
+class AgentState(BaseModel):
+    id: str
+    """The id of the agent. Assigned by the database."""
+
+    agent_type: AgentType
+    """The type of agent."""
+
+    embedding_config: EmbeddingConfig
+    """The embedding configuration used by the agent."""
+
+    llm_config: LlmConfig
+    """The LLM configuration used by the agent."""
+
+    memory: Memory
+    """The in-context memory of the agent."""
+
+    name: str
+    """The name of the agent."""
+
+    sources: List[Source]
+    """The sources used by the agent."""
+
+    system: str
+    """The system prompt used by the agent."""
+
+    tags: List[str]
+    """The tags associated with the agent."""
+
+    tools: List[Tool]
+    """The tools used by the agent."""
+
+    base_template_id: Optional[str] = None
+    """The base template id of the agent."""
+
+    created_at: Optional[datetime] = None
+    """The timestamp when the object was created."""
+
+    created_by_id: Optional[str] = None
+    """The id of the user that made this object."""
+
+    deployment_id: Optional[str] = None
+    """The id of the deployment."""
+
+    description: Optional[str] = None
+    """The description of the agent."""
+
+    enable_sleeptime: Optional[bool] = None
+    """If set to True, memory management will move to a background agent thread."""
+
+    entity_id: Optional[str] = None
+    """The id of the entity within the template."""
+
+    hidden: Optional[bool] = None
+    """If set to True, the agent will be hidden."""
+
+    identity_ids: Optional[List[str]] = None
+    """The ids of the identities associated with this agent."""
+
+    last_run_completion: Optional[datetime] = None
+    """The timestamp when the agent last completed a run."""
+
+    last_run_duration_ms: Optional[int] = None
+    """The duration in milliseconds of the agent's last run."""
+
+    last_updated_by_id: Optional[str] = None
+    """The id of the user that made this object."""
+
+    max_files_open: Optional[int] = None
+    """Maximum number of files that can be open at once for this agent.
+
+    Setting this too high may exceed the context window, which will break the agent.
+    """
+
+    message_buffer_autoclear: Optional[bool] = None
+    """
+    If set to True, the agent will not remember previous messages (though the agent
+    will still retain state via core memory blocks and archival/recall memory). Not
+    recommended unless you have an advanced use case.
+    """
+
+    message_ids: Optional[List[str]] = None
+    """The ids of the messages in the agent's in-context memory."""
+
+    metadata: Optional[Dict[str, object]] = None
+    """The metadata of the agent."""
+
+    multi_agent_group: Optional[Group] = None
+    """The multi-agent group that this agent manages"""
+
+    per_file_view_window_char_limit: Optional[int] = None
+    """The per-file view window character limit for this agent.
+
+    Setting this too high may exceed the context window, which will break the agent.
+    """
+
+    project_id: Optional[str] = None
+    """The id of the project the agent belongs to."""
+
+    response_format: Optional[ResponseFormat] = None
+    """The response format used by the agent when returning from `send_message`."""
+
+    secrets: Optional[List[AgentEnvironmentVariable]] = None
+    """The environment variables for tool execution specific to this agent."""
+
+    template_id: Optional[str] = None
+    """The id of the template the agent belongs to."""
+
+    timezone: Optional[str] = None
+    """The timezone of the agent (IANA format)."""
+
+    tool_exec_environment_variables: Optional[List[AgentEnvironmentVariable]] = None
+    """Deprecated: use `secrets` field instead."""
+
+    tool_rules: Optional[List[ToolRule]] = None
+    """The list of tool rules."""
+
+    updated_at: Optional[datetime] = None
+    """The timestamp when the object was last updated."""

letta_sdk/types/agent_summarize_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_extensions import Required, TypedDict
+
+__all__ = ["AgentSummarizeParams"]
+
+
+class AgentSummarizeParams(TypedDict, total=False):
+    max_message_length: Required[int]
+    """Maximum number of messages to retain after summarization."""

letta_sdk/types/agent_type.py

@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal, TypeAlias
+
+__all__ = ["AgentType"]
+
+AgentType: TypeAlias = Literal[
+    "memgpt_agent",
+    "memgpt_v2_agent",
+    "react_agent",
+    "workflow_agent",
+    "split_thread_agent",
+    "sleeptime_agent",
+    "voice_convo_agent",
+    "voice_sleeptime_agent",
+]

letta_sdk/types/agent_update_params.py

@@ -0,0 +1,149 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Union, Iterable, Optional
+from datetime import datetime
+from typing_extensions import Annotated, TypeAlias, TypedDict
+
+from .._types import SequenceNotStr
+from .._utils import PropertyInfo
+from .llm_config_param import LlmConfigParam
+from .init_tool_rule_param import InitToolRuleParam
+from .child_tool_rule_param import ChildToolRuleParam
+from .embedding_config_param import EmbeddingConfigParam
+from .parent_tool_rule_param import ParentToolRuleParam
+from .continue_tool_rule_param import ContinueToolRuleParam
+from .terminal_tool_rule_param import TerminalToolRuleParam
+from .text_response_format_param import TextResponseFormatParam
+from .conditional_tool_rule_param import ConditionalToolRuleParam
+from .json_object_response_format_param import JsonObjectResponseFormatParam
+from .json_schema_response_format_param import JsonSchemaResponseFormatParam
+from .requires_approval_tool_rule_param import RequiresApprovalToolRuleParam
+from .max_count_per_step_tool_rule_param import MaxCountPerStepToolRuleParam
+from .required_before_exit_tool_rule_param import RequiredBeforeExitToolRuleParam
+
+__all__ = ["AgentUpdateParams", "ResponseFormat", "ToolRule"]
+
+
+class AgentUpdateParams(TypedDict, total=False):
+    base_template_id: Optional[str]
+    """The base template id of the agent."""
+
+    block_ids: Optional[SequenceNotStr[str]]
+    """The ids of the blocks used by the agent."""
+
+    description: Optional[str]
+    """The description of the agent."""
+
+    embedding: Optional[str]
+    """
+    The embedding configuration handle used by the agent, specified in the format
+    provider/model-name.
+    """
+
+    embedding_config: Optional[EmbeddingConfigParam]
+    """Configuration for embedding model connection and processing parameters."""
+
+    enable_sleeptime: Optional[bool]
+    """If set to True, memory management will move to a background agent thread."""
+
+    hidden: Optional[bool]
+    """If set to True, the agent will be hidden."""
+
+    identity_ids: Optional[SequenceNotStr[str]]
+    """The ids of the identities associated with this agent."""
+
+    last_run_completion: Annotated[Union[str, datetime, None], PropertyInfo(format="iso8601")]
+    """The timestamp when the agent last completed a run."""
+
+    last_run_duration_ms: Optional[int]
+    """The duration in milliseconds of the agent's last run."""
+
+    llm_config: Optional[LlmConfigParam]
+    """Configuration for Language Model (LLM) connection and generation parameters."""
+
+    max_files_open: Optional[int]
+    """Maximum number of files that can be open at once for this agent.
+
+    Setting this too high may exceed the context window, which will break the agent.
+    """
+
+    message_buffer_autoclear: Optional[bool]
+    """
+    If set to True, the agent will not remember previous messages (though the agent
+    will still retain state via core memory blocks and archival/recall memory). Not
+    recommended unless you have an advanced use case.
+    """
+
+    message_ids: Optional[SequenceNotStr[str]]
+    """The ids of the messages in the agent's in-context memory."""
+
+    metadata: Optional[Dict[str, object]]
+    """The metadata of the agent."""
+
+    model: Optional[str]
+    """
+    The LLM configuration handle used by the agent, specified in the format
+    provider/model-name, as an alternative to specifying llm_config.
+    """
+
+    name: Optional[str]
+    """The name of the agent."""
+
+    per_file_view_window_char_limit: Optional[int]
+    """The per-file view window character limit for this agent.
+
+    Setting this too high may exceed the context window, which will break the agent.
+    """
+
+    project_id: Optional[str]
+    """The id of the project the agent belongs to."""
+
+    reasoning: Optional[bool]
+    """Whether to enable reasoning for this agent."""
+
+    response_format: Optional[ResponseFormat]
+    """The response format for the agent."""
+
+    secrets: Optional[Dict[str, str]]
+    """The environment variables for tool execution specific to this agent."""
+
+    source_ids: Optional[SequenceNotStr[str]]
+    """The ids of the sources used by the agent."""
+
+    system: Optional[str]
+    """The system prompt used by the agent."""
+
+    tags: Optional[SequenceNotStr[str]]
+    """The tags associated with the agent."""
+
+    template_id: Optional[str]
+    """The id of the template the agent belongs to."""
+
+    timezone: Optional[str]
+    """The timezone of the agent (IANA format)."""
+
+    tool_exec_environment_variables: Optional[Dict[str, str]]
+    """Deprecated: use `secrets` field instead"""
+
+    tool_ids: Optional[SequenceNotStr[str]]
+    """The ids of the tools used by the agent."""
+
+    tool_rules: Optional[Iterable[ToolRule]]
+    """The tool rules governing the agent."""
+
+
+ResponseFormat: TypeAlias = Union[TextResponseFormatParam, JsonSchemaResponseFormatParam, JsonObjectResponseFormatParam]
+
+ToolRule: TypeAlias = Union[
+    ChildToolRuleParam,
+    InitToolRuleParam,
+    TerminalToolRuleParam,
+    ConditionalToolRuleParam,
+    ContinueToolRuleParam,
+    RequiredBeforeExitToolRuleParam,
+    MaxCountPerStepToolRuleParam,
+    ParentToolRuleParam,
+    RequiresApprovalToolRuleParam,
+]

letta_sdk/types/agents/__init__.py

@@ -0,0 +1,85 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .run import Run as Run
+from .memory import Memory as Memory
+from .message import Message as Message
+from .job_type import JobType as JobType
+from .tool_call import ToolCall as ToolCall
+from .job_status import JobStatus as JobStatus
+from .tool_return import ToolReturn as ToolReturn
+from .message_role import MessageRole as MessageRole
+from .message_type import MessageType as MessageType
+from .text_content import TextContent as TextContent
+from .user_message import UserMessage as UserMessage
+from .image_content import ImageContent as ImageContent
+from .letta_response import LettaResponse as LettaResponse
+from .system_message import SystemMessage as SystemMessage
+from .tool_call_delta import ToolCallDelta as ToolCallDelta
+from .file_list_params import FileListParams as FileListParams
+from .assistant_message import AssistantMessage as AssistantMessage
+from .reasoning_content import ReasoningContent as ReasoningContent
+from .reasoning_message import ReasoningMessage as ReasoningMessage
+from .tool_call_content import ToolCallContent as ToolCallContent
+from .tool_call_message import ToolCallMessage as ToolCallMessage
+from .file_list_response import FileListResponse as FileListResponse
+from .file_open_response import FileOpenResponse as FileOpenResponse
+from .text_content_param import TextContentParam as TextContentParam
+from .tool_list_response import ToolListResponse as ToolListResponse
+from .image_content_param import ImageContentParam as ImageContentParam
+from .letta_message_union import LettaMessageUnion as LettaMessageUnion
+from .letta_request_param import LettaRequestParam as LettaRequestParam
+from .message_list_params import MessageListParams as MessageListParams
+from .message_send_params import MessageSendParams as MessageSendParams
+from .tool_return_content import ToolReturnContent as ToolReturnContent
+from .folder_list_response import FolderListResponse as FolderListResponse
+from .source_list_response import SourceListResponse as SourceListResponse
+from .approval_create_param import ApprovalCreateParam as ApprovalCreateParam
+from .message_cancel_params import MessageCancelParams as MessageCancelParams
+from .message_list_response import MessageListResponse as MessageListResponse
+from .message_search_params import MessageSearchParams as MessageSearchParams
+from .message_update_params import MessageUpdateParams as MessageUpdateParams
+from .file_close_all_response import FileCloseAllResponse as FileCloseAllResponse
+from .message_cancel_response import MessageCancelResponse as MessageCancelResponse
+from .message_search_response import MessageSearchResponse as MessageSearchResponse
+from .message_update_response import MessageUpdateResponse as MessageUpdateResponse
+from .reasoning_content_param import ReasoningContentParam as ReasoningContentParam
+from .tool_call_content_param import ToolCallContentParam as ToolCallContentParam
+from .approval_request_message import ApprovalRequestMessage as ApprovalRequestMessage
+from .hidden_reasoning_message import HiddenReasoningMessage as HiddenReasoningMessage
+from .approval_response_message import ApprovalResponseMessage as ApprovalResponseMessage
+from .message_send_async_params import MessageSendAsyncParams as MessageSendAsyncParams
+from .omitted_reasoning_content import OmittedReasoningContent as OmittedReasoningContent
+from .tool_return_content_param import ToolReturnContentParam as ToolReturnContentParam
+from .update_user_message_param import UpdateUserMessageParam as UpdateUserMessageParam
+from .message_send_stream_params import MessageSendStreamParams as MessageSendStreamParams
+from .redacted_reasoning_content import RedactedReasoningContent as RedactedReasoningContent
+from .archival_memory_list_params import ArchivalMemoryListParams as ArchivalMemoryListParams
+from .tool_modify_approval_params import ToolModifyApprovalParams as ToolModifyApprovalParams
+from .update_system_message_param import UpdateSystemMessageParam as UpdateSystemMessageParam
+from .archival_memory_create_params import ArchivalMemoryCreateParams as ArchivalMemoryCreateParams
+from .archival_memory_list_response import ArchivalMemoryListResponse as ArchivalMemoryListResponse
+from .archival_memory_search_params import ArchivalMemorySearchParams as ArchivalMemorySearchParams
+from .letta_streaming_request_param import LettaStreamingRequestParam as LettaStreamingRequestParam
+from .update_assistant_message_param import UpdateAssistantMessageParam as UpdateAssistantMessageParam
+from .update_reasoning_message_param import UpdateReasoningMessageParam as UpdateReasoningMessageParam
+from .archival_memory_create_response import ArchivalMemoryCreateResponse as ArchivalMemoryCreateResponse
+from .archival_memory_search_response import ArchivalMemorySearchResponse as ArchivalMemorySearchResponse
+from .omitted_reasoning_content_param import OmittedReasoningContentParam as OmittedReasoningContentParam
+from .letta_user_message_content_union import LettaUserMessageContentUnion as LettaUserMessageContentUnion
+from .redacted_reasoning_content_param import RedactedReasoningContentParam as RedactedReasoningContentParam
+from .message_preview_raw_payload_params import MessagePreviewRawPayloadParams as MessagePreviewRawPayloadParams
+from .message_preview_raw_payload_response import MessagePreviewRawPayloadResponse as MessagePreviewRawPayloadResponse
+from .letta_assistant_message_content_union import (
+    LettaAssistantMessageContentUnion as LettaAssistantMessageContentUnion,
+)
+from .letta_user_message_content_union_param import (
+    LettaUserMessageContentUnionParam as LettaUserMessageContentUnionParam,
+)
+from .core_memory_retrieve_variables_response import (
+    CoreMemoryRetrieveVariablesResponse as CoreMemoryRetrieveVariablesResponse,
+)
+from .letta_assistant_message_content_union_param import (
+    LettaAssistantMessageContentUnionParam as LettaAssistantMessageContentUnionParam,
+)

letta_sdk/types/agents/approval_create_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__ = ["ApprovalCreateParam"]
+
+
+class ApprovalCreateParam(TypedDict, total=False):
+    approval_request_id: Required[str]
+    """The message ID of the approval request"""
+
+    approve: Required[bool]
+    """Whether the tool has been approved"""
+
+    reason: Optional[str]
+    """An optional explanation for the provided approval status"""
+
+    type: Literal["approval"]
+    """The message type to be created."""

letta_sdk/types/agents/approval_request_message.py

@@ -0,0 +1,39 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union, Optional
+from datetime import datetime
+from typing_extensions import Literal, TypeAlias
+
+from . import tool_call
+from ..._models import BaseModel
+from .tool_call_delta import ToolCallDelta
+
+__all__ = ["ApprovalRequestMessage", "ToolCall"]
+
+ToolCall: TypeAlias = Union[tool_call.ToolCall, ToolCallDelta]
+
+
+class ApprovalRequestMessage(BaseModel):
+    id: str
+
+    date: datetime
+
+    tool_call: ToolCall
+    """The tool call that has been requested by the llm to run"""
+
+    is_err: Optional[bool] = None
+
+    message_type: Optional[Literal["approval_request_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/approval_response_message.py

@@ -0,0 +1,41 @@
+# 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__ = ["ApprovalResponseMessage"]
+
+
+class ApprovalResponseMessage(BaseModel):
+    id: str
+
+    approval_request_id: str
+    """The message ID of the approval request"""
+
+    approve: bool
+    """Whether the tool has been approved"""
+
+    date: datetime
+
+    is_err: Optional[bool] = None
+
+    message_type: Optional[Literal["approval_response_message"]] = None
+    """The type of the message."""
+
+    name: Optional[str] = None
+
+    otid: Optional[str] = None
+
+    reason: Optional[str] = None
+    """An optional explanation for the provided approval status"""
+
+    run_id: Optional[str] = None
+
+    sender_id: Optional[str] = None
+
+    seq_id: Optional[int] = None
+
+    step_id: Optional[str] = None

letta_sdk/types/agents/archival_memory_create_params.py

@@ -0,0 +1,23 @@
+# 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 Required, Annotated, TypedDict
+
+from ..._types import SequenceNotStr
+from ..._utils import PropertyInfo
+
+__all__ = ["ArchivalMemoryCreateParams"]
+
+
+class ArchivalMemoryCreateParams(TypedDict, total=False):
+    text: Required[str]
+    """Text to write to archival memory."""
+
+    created_at: Annotated[Union[str, datetime, None], PropertyInfo(format="iso8601")]
+    """Optional timestamp for the memory (defaults to current UTC time)."""
+
+    tags: Optional[SequenceNotStr[str]]
+    """Optional list of tags to attach to the memory."""

letta_sdk/types/agents/archival_memory_create_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__ = ["ArchivalMemoryCreateResponse"]
+
+ArchivalMemoryCreateResponse: TypeAlias = List[Passage]