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

letta_client/types/__init__.py

@@ -0,0 +1,111 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .step import Step as Step
+from .tool import Tool as Tool
+from .group import Group as Group
+from .folder import Folder as Folder
+from .archive import Archive as Archive
+from .identity import Identity as Identity
+from .batch_job import BatchJob as BatchJob
+from .tool_type import ToolType as ToolType
+from .agent_type import AgentType as AgentType
+from .llm_config import LlmConfig as LlmConfig
+from .agent_state import AgentState as AgentState
+from .manager_type import ManagerType as ManagerType
+from .identity_type import IdentityType as IdentityType
+from .provider_type import ProviderType as ProviderType
+from .init_tool_rule import InitToolRule as InitToolRule
+from .provider_trace import ProviderTrace as ProviderTrace
+from .child_tool_rule import ChildToolRule as ChildToolRule
+from .health_response import HealthResponse as HealthResponse
+from .npm_requirement import NpmRequirement as NpmRequirement
+from .pip_requirement import PipRequirement as PipRequirement
+from .run_list_params import RunListParams as RunListParams
+from .tag_list_params import TagListParams as TagListParams
+from .embedding_config import EmbeddingConfig as EmbeddingConfig
+from .llm_config_param import LlmConfigParam as LlmConfigParam
+from .parent_tool_rule import ParentToolRule as ParentToolRule
+from .step_list_params import StepListParams as StepListParams
+from .stop_reason_type import StopReasonType as StopReasonType
+from .tool_list_params import ToolListParams as ToolListParams
+from .agent_list_params import AgentListParams as AgentListParams
+from .batch_list_params import BatchListParams as BatchListParams
+from .block_list_params import BlockListParams as BlockListParams
+from .group_list_params import GroupListParams as GroupListParams
+from .identity_property import IdentityProperty as IdentityProperty
+from .model_list_params import ModelListParams as ModelListParams
+from .provider_category import ProviderCategory as ProviderCategory
+from .tag_list_response import TagListResponse as TagListResponse
+from .tool_count_params import ToolCountParams as ToolCountParams
+from .continue_tool_rule import ContinueToolRule as ContinueToolRule
+from .create_block_param import CreateBlockParam as CreateBlockParam
+from .folder_list_params import FolderListParams as FolderListParams
+from .terminal_tool_rule import TerminalToolRule as TerminalToolRule
+from .tool_create_params import ToolCreateParams as ToolCreateParams
+from .tool_update_params import ToolUpdateParams as ToolUpdateParams
+from .tool_upsert_params import ToolUpsertParams as ToolUpsertParams
+from .vector_db_provider import VectorDBProvider as VectorDBProvider
+from .agent_create_params import AgentCreateParams as AgentCreateParams
+from .agent_update_params import AgentUpdateParams as AgentUpdateParams
+from .archive_list_params import ArchiveListParams as ArchiveListParams
+from .batch_create_params import BatchCreateParams as BatchCreateParams
+from .block_create_params import BlockCreateParams as BlockCreateParams
+from .block_update_params import BlockUpdateParams as BlockUpdateParams
+from .group_create_params import GroupCreateParams as GroupCreateParams
+from .group_update_params import GroupUpdateParams as GroupUpdateParams
+from .model_list_response import ModelListResponse as ModelListResponse
+from .tool_count_response import ToolCountResponse as ToolCountResponse
+from .tool_return_message import ToolReturnMessage as ToolReturnMessage
+from .agent_count_response import AgentCountResponse as AgentCountResponse
+from .block_count_response import BlockCountResponse as BlockCountResponse
+from .folder_create_params import FolderCreateParams as FolderCreateParams
+from .folder_update_params import FolderUpdateParams as FolderUpdateParams
+from .group_count_response import GroupCountResponse as GroupCountResponse
+from .identity_list_params import IdentityListParams as IdentityListParams
+from .init_tool_rule_param import InitToolRuleParam as InitToolRuleParam
+from .message_create_param import MessageCreateParam as MessageCreateParam
+from .text_response_format import TextResponseFormat as TextResponseFormat
+from .agent_retrieve_params import AgentRetrieveParams as AgentRetrieveParams
+from .archive_create_params import ArchiveCreateParams as ArchiveCreateParams
+from .archive_list_response import ArchiveListResponse as ArchiveListResponse
+from .archive_update_params import ArchiveUpdateParams as ArchiveUpdateParams
+from .child_tool_rule_param import ChildToolRuleParam as ChildToolRuleParam
+from .conditional_tool_rule import ConditionalToolRule as ConditionalToolRule
+from .dynamic_manager_param import DynamicManagerParam as DynamicManagerParam
+from .folder_count_response import FolderCountResponse as FolderCountResponse
+from .npm_requirement_param import NpmRequirementParam as NpmRequirementParam
+from .pip_requirement_param import PipRequirementParam as PipRequirementParam
+from .embedding_config_param import EmbeddingConfigParam as EmbeddingConfigParam
+from .identity_create_params import IdentityCreateParams as IdentityCreateParams
+from .identity_update_params import IdentityUpdateParams as IdentityUpdateParams
+from .identity_upsert_params import IdentityUpsertParams as IdentityUpsertParams
+from .parent_tool_rule_param import ParentToolRuleParam as ParentToolRuleParam
+from .identity_count_response import IdentityCountResponse as IdentityCountResponse
+from .identity_property_param import IdentityPropertyParam as IdentityPropertyParam
+from .sleeptime_manager_param import SleeptimeManagerParam as SleeptimeManagerParam
+from .agent_export_file_params import AgentExportFileParams as AgentExportFileParams
+from .agent_import_file_params import AgentImportFileParams as AgentImportFileParams
+from .continue_tool_rule_param import ContinueToolRuleParam as ContinueToolRuleParam
+from .supervisor_manager_param import SupervisorManagerParam as SupervisorManagerParam
+from .terminal_tool_rule_param import TerminalToolRuleParam as TerminalToolRuleParam
+from .round_robin_manager_param import RoundRobinManagerParam as RoundRobinManagerParam
+from .agent_environment_variable import AgentEnvironmentVariable as AgentEnvironmentVariable
+from .agent_export_file_response import AgentExportFileResponse as AgentExportFileResponse
+from .agent_import_file_response import AgentImportFileResponse as AgentImportFileResponse
+from .text_response_format_param import TextResponseFormatParam as TextResponseFormatParam
+from .conditional_tool_rule_param import ConditionalToolRuleParam as ConditionalToolRuleParam
+from .json_object_response_format import JsonObjectResponseFormat as JsonObjectResponseFormat
+from .json_schema_response_format import JsonSchemaResponseFormat as JsonSchemaResponseFormat
+from .requires_approval_tool_rule import RequiresApprovalToolRule as RequiresApprovalToolRule
+from .max_count_per_step_tool_rule import MaxCountPerStepToolRule as MaxCountPerStepToolRule
+from .voice_sleeptime_manager_param import VoiceSleeptimeManagerParam as VoiceSleeptimeManagerParam
+from .required_before_exit_tool_rule import RequiredBeforeExitToolRule as RequiredBeforeExitToolRule
+from .tool_upsert_base_tools_response import ToolUpsertBaseToolsResponse as ToolUpsertBaseToolsResponse
+from .json_object_response_format_param import JsonObjectResponseFormatParam as JsonObjectResponseFormatParam
+from .json_schema_response_format_param import JsonSchemaResponseFormatParam as JsonSchemaResponseFormatParam
+from .letta_message_content_union_param import LettaMessageContentUnionParam as LettaMessageContentUnionParam
+from .requires_approval_tool_rule_param import RequiresApprovalToolRuleParam as RequiresApprovalToolRuleParam
+from .max_count_per_step_tool_rule_param import MaxCountPerStepToolRuleParam as MaxCountPerStepToolRuleParam
+from .required_before_exit_tool_rule_param import RequiredBeforeExitToolRuleParam as RequiredBeforeExitToolRuleParam

{letta_sdk → letta_client}/types/agent_create_params.py

@@ -63,7 +63,7 @@ class AgentCreateParams(TypedDict, total=False):
     """If set to True, memory management will move to a background agent thread."""
 
     from_template: Optional[str]
-    """The template id used to configure the agent"""
+    """Deprecated: please use the 'create agents from a template' endpoint instead."""
 
     hidden: Optional[bool]
     """If set to True, the agent will be hidden."""
@@ -141,6 +141,9 @@ class AgentCreateParams(TypedDict, total=False):
     name: str
     """The name of the agent."""
 
+    parallel_tool_calls: Optional[bool]
+    """If set to True, enables parallel tool calling. Defaults to False."""
+
     per_file_view_window_char_limit: Optional[int]
     """The per-file view window character limit for this agent.
 
@@ -176,7 +179,7 @@ class AgentCreateParams(TypedDict, total=False):
     """The tags associated with the agent."""
 
     template: bool
-    """Whether the agent is a template"""
+    """Deprecated: No longer used"""
 
     template_id: Optional[str]
     """The id of the template the agent belongs to."""

{letta_sdk → letta_client}/types/agent_environment_variable.py

@@ -35,3 +35,6 @@ class AgentEnvironmentVariable(BaseModel):
 
     updated_at: Optional[datetime] = None
     """The timestamp when the object was last updated."""
+
+    value_enc: Optional[str] = None
+    """Encrypted secret value (stored as encrypted string)"""

letta_client/types/agent_export_file_params.py

@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import TypedDict
+
+__all__ = ["AgentExportFileParams"]
+
+
+class AgentExportFileParams(TypedDict, total=False):
+    max_steps: int
+
+    use_legacy_format: bool
+    """
+    If True, exports using the legacy single-agent 'v1' format with inline
+    tools/blocks. If False, exports using the new multi-entity 'v2' format, with
+    separate agents, tools, blocks, files, etc.
+    """

letta_sdk/types/agent_export_response.py → letta_client/types/agent_export_file_response.py

@@ -2,6 +2,6 @@
 
 from typing_extensions import TypeAlias
 
-__all__ = ["AgentExportResponse"]
+__all__ = ["AgentExportFileResponse"]
 
-AgentExportResponse: TypeAlias = str
+AgentExportFileResponse: TypeAlias = str

letta_sdk/types/agent_import_params.py → letta_client/types/agent_import_file_params.py

@@ -8,10 +8,10 @@ from typing_extensions import Required, Annotated, TypedDict
 from .._types import FileTypes
 from .._utils import PropertyInfo
 
-__all__ = ["AgentImportParams"]
+__all__ = ["AgentImportFileParams"]
 
 
-class AgentImportParams(TypedDict, total=False):
+class AgentImportFileParams(TypedDict, total=False):
     file: Required[FileTypes]
 
     append_copy_suffix: bool
@@ -30,6 +30,9 @@ class AgentImportParams(TypedDict, total=False):
     externally.
     """
 
+    override_name: Optional[str]
+    """If provided, overrides the agent name with this value."""
+
     project_id: Optional[str]
     """The project ID to associate the uploaded agent with."""
 

letta_sdk/types/agent_import_response.py → letta_client/types/agent_import_file_response.py

@@ -4,9 +4,9 @@ from typing import List
 
 from .._models import BaseModel
 
-__all__ = ["AgentImportResponse"]
+__all__ = ["AgentImportFileResponse"]
 
 
-class AgentImportResponse(BaseModel):
+class AgentImportFileResponse(BaseModel):
     agent_ids: List[str]
     """List of IDs of the imported agents"""

{letta_sdk → letta_client}/types/agent_list_params.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import Optional
+from typing import List, Optional
 from typing_extensions import Literal, TypedDict
 
 from .._types import SequenceNotStr
@@ -32,11 +32,28 @@ class AgentListParams(TypedDict, total=False):
     identity_id: Optional[str]
     """Search agents by identity ID"""
 
+    include: List[
+        Literal[
+            "agent.blocks",
+            "agent.identities",
+            "agent.managed_group",
+            "agent.secrets",
+            "agent.sources",
+            "agent.tags",
+            "agent.tools",
+        ]
+    ]
+    """Specify which relational fields to include in the response.
+
+    No relationships are included by default.
+    """
+
     include_relationships: Optional[SequenceNotStr[str]]
     """
     Specify which relational fields (e.g., 'tools', 'sources', 'memory') to include
     in the response. If not provided, all relationships are loaded by default. Using
-    this can optimize performance by reducing unnecessary joins.
+    this can optimize performance by reducing unnecessary joins.This is a legacy
+    parameter, and no longer supported after 1.0.0 SDK versions.
     """
 
     limit: Optional[int]

{letta_sdk → letta_client}/types/agent_retrieve_params.py

@@ -2,8 +2,8 @@
 
 from __future__ import annotations
 
-from typing import Optional
-from typing_extensions import TypedDict
+from typing import List, Optional
+from typing_extensions import Literal, TypedDict
 
 from .._types import SequenceNotStr
 
@@ -11,9 +11,26 @@ __all__ = ["AgentRetrieveParams"]
 
 
 class AgentRetrieveParams(TypedDict, total=False):
+    include: List[
+        Literal[
+            "agent.blocks",
+            "agent.identities",
+            "agent.managed_group",
+            "agent.secrets",
+            "agent.sources",
+            "agent.tags",
+            "agent.tools",
+        ]
+    ]
+    """Specify which relational fields to include in the response.
+
+    No relationships are included by default.
+    """
+
     include_relationships: Optional[SequenceNotStr[str]]
     """
     Specify which relational fields (e.g., 'tools', 'sources', 'memory') to include
     in the response. If not provided, all relationships are loaded by default. Using
-    this can optimize performance by reducing unnecessary joins.
+    this can optimize performance by reducing unnecessary joins.This is a legacy
+    parameter, and no longer supported after 1.0.0 SDK versions.
     """

{letta_sdk → letta_client}/types/agent_state.py

@@ -6,18 +6,19 @@ 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 .identity import Identity
 from .agent_type import AgentType
 from .llm_config import LlmConfig
-from .agents.memory import Memory
+from .agents.block import Block
 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 .vector_db_provider import VectorDBProvider
 from .text_response_format import TextResponseFormat
 from .conditional_tool_rule import ConditionalToolRule
 from .agent_environment_variable import AgentEnvironmentVariable
@@ -27,7 +28,125 @@ 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"]
+__all__ = ["AgentState", "Memory", "MemoryFileBlock", "Source", "ResponseFormat", "ToolRule"]
+
+
+class MemoryFileBlock(BaseModel):
+    file_id: str
+    """Unique identifier of the file."""
+
+    is_open: bool
+    """True if the agent currently has the file open."""
+
+    source_id: str
+    """Unique identifier of the source."""
+
+    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_accessed_at: Optional[datetime] = None
+    """UTC timestamp of the agent’s most recent access to this file.
+
+    Any operations from the open, close, or search tools will update this field.
+    """
+
+    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."""
+
+
+class Memory(BaseModel):
+    blocks: List[Block]
+    """Memory blocks contained in the agent's in-context memory"""
+
+    agent_type: Union[AgentType, str, None] = None
+    """Agent type controlling prompt rendering."""
+
+    file_blocks: Optional[List[MemoryFileBlock]] = None
+    """Special blocks representing the agent's in-context memory of an attached file"""
+
+    prompt_template: Optional[str] = None
+    """Deprecated. Ignored for performance."""
+
+
+class Source(BaseModel):
+    embedding_config: EmbeddingConfig
+    """The embedding configuration used by the source."""
+
+    name: str
+    """The name of the source."""
+
+    id: Optional[str] = None
+    """The human-friendly ID 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"""
+
 
 ResponseFormat: TypeAlias = Annotated[
     Union[TextResponseFormat, JsonSchemaResponseFormat, JsonObjectResponseFormat, None],
@@ -57,6 +176,9 @@ class AgentState(BaseModel):
     agent_type: AgentType
     """The type of agent."""
 
+    blocks: List[Block]
+    """The memory blocks used by the agent."""
+
     embedding_config: EmbeddingConfig
     """The embedding configuration used by the agent."""
 
@@ -105,6 +227,9 @@ class AgentState(BaseModel):
     hidden: Optional[bool] = None
     """If set to True, the agent will be hidden."""
 
+    identities: Optional[List[Identity]] = None
+    """The identities associated with this agent."""
+
     identity_ids: Optional[List[str]] = None
     """The ids of the identities associated with this agent."""
 
@@ -117,6 +242,9 @@ class AgentState(BaseModel):
     last_updated_by_id: Optional[str] = None
     """The id of the user that made this object."""
 
+    managed_group: Optional[Group] = None
+    """The multi-agent group that this agent manages"""
+
     max_files_open: Optional[int] = None
     """Maximum number of files that can be open at once for this agent.
 

{letta_sdk → letta_client}/types/agent_type.py

@@ -7,6 +7,7 @@ __all__ = ["AgentType"]
 AgentType: TypeAlias = Literal[
     "memgpt_agent",
     "memgpt_v2_agent",
+    "letta_v1_agent",
     "react_agent",
     "workflow_agent",
     "split_thread_agent",

{letta_sdk → letta_client}/types/agent_update_params.py

@@ -33,6 +33,9 @@ class AgentUpdateParams(TypedDict, total=False):
     block_ids: Optional[SequenceNotStr[str]]
     """The ids of the blocks used by the agent."""
 
+    context_window_limit: Optional[int]
+    """The context window limit used by the agent."""
+
     description: Optional[str]
     """The description of the agent."""
 
@@ -69,6 +72,12 @@ class AgentUpdateParams(TypedDict, total=False):
     Setting this too high may exceed the context window, which will break the agent.
     """
 
+    max_tokens: Optional[int]
+    """The maximum number of tokens to generate, including reasoning step.
+
+    If not set, the model will use its default value.
+    """
+
     message_buffer_autoclear: Optional[bool]
     """
     If set to True, the agent will not remember previous messages (though the agent
@@ -91,6 +100,9 @@ class AgentUpdateParams(TypedDict, total=False):
     name: Optional[str]
     """The name of the agent."""
 
+    parallel_tool_calls: Optional[bool]
+    """If set to True, enables parallel tool calling. Defaults to False."""
+
     per_file_view_window_char_limit: Optional[int]
     """The per-file view window character limit for this agent.
 

{letta_sdk → letta_client}/types/agents/__init__.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from .run import Run as Run
-from .memory import Memory as Memory
+from .block import Block as Block
 from .message import Message as Message
 from .job_type import JobType as JobType
 from .tool_call import ToolCall as ToolCall
@@ -18,31 +18,33 @@ 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 .tool_list_params import ToolListParams as ToolListParams
 from .assistant_message import AssistantMessage as AssistantMessage
+from .block_list_params import BlockListParams as BlockListParams
+from .group_list_params import GroupListParams as GroupListParams
 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 .tool_return_param import ToolReturnParam as ToolReturnParam
 from .file_list_response import FileListResponse as FileListResponse
 from .file_open_response import FileOpenResponse as FileOpenResponse
+from .folder_list_params import FolderListParams as FolderListParams
 from .text_content_param import TextContentParam as TextContentParam
-from .tool_list_response import ToolListResponse as ToolListResponse
+from .block_update_params import BlockUpdateParams as BlockUpdateParams
 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 .message_reset_params import MessageResetParams as MessageResetParams
 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_stream_params import MessageStreamParams as MessageStreamParams
 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
@@ -53,33 +55,20 @@ from .message_send_async_params import MessageSendAsyncParams as MessageSendAsyn
 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 .tool_update_approval_params import ToolUpdateApprovalParams as ToolUpdateApprovalParams
 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_client/types/agents/approval_create_param.py

@@ -0,0 +1,44 @@
+# 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, TypeAlias, TypedDict
+
+from .tool_return_param import ToolReturnParam
+
+__all__ = ["ApprovalCreateParam", "Approval", "ApprovalApprovalReturn"]
+
+
+class ApprovalApprovalReturn(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."""
+
+
+Approval: TypeAlias = Union[ApprovalApprovalReturn, ToolReturnParam]
+
+
+class ApprovalCreateParam(TypedDict, total=False):
+    approval_request_id: Optional[str]
+    """The message ID of the approval request"""
+
+    approvals: Optional[Iterable[Approval]]
+    """The list of approval responses"""
+
+    approve: Optional[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."""