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

letta_sdk/types/agent_create_params.py

@@ -0,0 +1,215 @@
+# 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 typing_extensions import Annotated, TypeAlias, TypedDict
+
+from .._types import SequenceNotStr
+from .._utils import PropertyInfo
+from .agent_type import AgentType
+from .llm_config_param import LlmConfigParam
+from .create_block_param import CreateBlockParam
+from .init_tool_rule_param import InitToolRuleParam
+from .message_create_param import MessageCreateParam
+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__ = ["AgentCreateParams", "ResponseFormat", "ToolRule"]
+
+
+class AgentCreateParams(TypedDict, total=False):
+    agent_type: AgentType
+    """The type of agent."""
+
+    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."""
+
+    context_window_limit: Optional[int]
+    """The context window limit 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_chunk_size: Optional[int]
+    """The embedding chunk size used by the agent."""
+
+    embedding_config: Optional[EmbeddingConfigParam]
+    """Configuration for embedding model connection and processing parameters."""
+
+    enable_reasoner: Optional[bool]
+    """Whether to enable internal extended thinking step for a reasoner model."""
+
+    enable_sleeptime: Optional[bool]
+    """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"""
+
+    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."""
+
+    include_base_tool_rules: Optional[bool]
+    """If true, attaches the Letta base tool rules (e.g.
+
+    deny all tools not explicitly allowed).
+    """
+
+    include_base_tools: bool
+    """If true, attaches the Letta core tools (e.g. core_memory related functions)."""
+
+    include_default_source: bool
+    """
+    If true, automatically creates and attaches a default data source for this
+    agent.
+    """
+
+    include_multi_agent_tools: bool
+    """If true, attaches the Letta multi-agent tools (e.g.
+
+    sending a message to another agent).
+    """
+
+    initial_message_sequence: Optional[Iterable[MessageCreateParam]]
+    """The initial set of messages to put in the agent's in-context memory."""
+
+    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.
+    """
+
+    max_reasoning_tokens: Optional[int]
+    """The maximum number of tokens to generate for reasoning step.
+
+    If not set, the model will use its default value.
+    """
+
+    max_tokens: Optional[int]
+    """The maximum number of tokens to generate, including reasoning step.
+
+    If not set, the model will use its default value.
+    """
+
+    memory_blocks: Optional[Iterable[CreateBlockParam]]
+    """The blocks to create in the agent's in-context memory."""
+
+    memory_variables: Optional[Dict[str, str]]
+    """The variables that should be set for the agent."""
+
+    message_buffer_autoclear: 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.
+    """
+
+    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: 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: Optional[str]
+    """
+    Deprecated: Project should now be passed via the X-Project header instead of in
+    the request body. If using the sdk, this can be done via the new x_project field
+    below.
+    """
+
+    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: bool
+    """Whether the agent is a template"""
+
+    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."""
+
+    tools: Optional[SequenceNotStr[str]]
+    """The tools used by the agent."""
+
+    x_project: Annotated[str, PropertyInfo(alias="X-Project")]
+    """The project slug to associate with the agent (cloud only)."""
+
+
+ResponseFormat: TypeAlias = Union[TextResponseFormatParam, JsonSchemaResponseFormatParam, JsonObjectResponseFormatParam]
+
+ToolRule: TypeAlias = Union[
+    ChildToolRuleParam,
+    InitToolRuleParam,
+    TerminalToolRuleParam,
+    ConditionalToolRuleParam,
+    ContinueToolRuleParam,
+    RequiredBeforeExitToolRuleParam,
+    MaxCountPerStepToolRuleParam,
+    ParentToolRuleParam,
+    RequiresApprovalToolRuleParam,
+]

letta_sdk/types/agent_environment_variable.py

@@ -0,0 +1,37 @@
+# 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__ = ["AgentEnvironmentVariable"]
+
+
+class AgentEnvironmentVariable(BaseModel):
+    agent_id: str
+    """The ID of the agent this environment variable belongs to."""
+
+    key: str
+    """The name of the environment variable."""
+
+    value: str
+    """The value of the environment variable."""
+
+    id: Optional[str] = None
+    """The human-friendly ID of the Agent-env"""
+
+    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."""
+
+    description: Optional[str] = None
+    """An optional description of the environment variable."""
+
+    last_updated_by_id: Optional[str] = None
+    """The id of the user that made this object."""
+
+    updated_at: Optional[datetime] = None
+    """The timestamp when the object was last updated."""

letta_sdk/types/agent_export_params.py

@@ -0,0 +1,17 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import TypedDict
+
+__all__ = ["AgentExportParams"]
+
+
+class AgentExportParams(TypedDict, total=False):
+    max_steps: int
+
+    use_legacy_format: bool
+    """If true, exports using the legacy single-agent format (v1).
+
+    If false, exports using the new multi-entity format (v2).
+    """

letta_sdk/types/agent_export_response.py

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

letta_sdk/types/agent_import_params.py

@@ -0,0 +1,39 @@
+# 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 Required, Annotated, TypedDict
+
+from .._types import FileTypes
+from .._utils import PropertyInfo
+
+__all__ = ["AgentImportParams"]
+
+
+class AgentImportParams(TypedDict, total=False):
+    file: Required[FileTypes]
+
+    append_copy_suffix: bool
+    """If set to True, appends "\\__copy" to the end of the agent name."""
+
+    env_vars_json: Optional[str]
+    """Environment variables as a JSON string to pass to the agent for tool execution."""
+
+    override_embedding_handle: Optional[str]
+    """Override import with specific embedding handle."""
+
+    override_existing_tools: bool
+    """
+    If set to True, existing tools can get their source code overwritten by the
+    uploaded tool definitions. Note that Letta core tools can never be updated
+    externally.
+    """
+
+    project_id: Optional[str]
+    """The project ID to associate the uploaded agent with."""
+
+    strip_messages: bool
+    """If set to True, strips all messages from the agent before importing."""
+
+    x_override_embedding_model: Annotated[str, PropertyInfo(alias="x-override-embedding-model")]

letta_sdk/types/agent_import_response.py

@@ -0,0 +1,12 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List
+
+from .._models import BaseModel
+
+__all__ = ["AgentImportResponse"]
+
+
+class AgentImportResponse(BaseModel):
+    agent_ids: List[str]
+    """List of IDs of the imported agents"""

letta_sdk/types/agent_list_groups_params.py

@@ -0,0 +1,13 @@
+# 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__ = ["AgentListGroupsParams"]
+
+
+class AgentListGroupsParams(TypedDict, total=False):
+    manager_type: Optional[str]
+    """Manager type to filter groups by"""

letta_sdk/types/agent_list_groups_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 .group import Group
+
+__all__ = ["AgentListGroupsResponse"]
+
+AgentListGroupsResponse: TypeAlias = List[Group]

letta_sdk/types/agent_list_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 Optional
+from typing_extensions import Literal, TypedDict
+
+from .._types import SequenceNotStr
+
+__all__ = ["AgentListParams"]
+
+
+class AgentListParams(TypedDict, total=False):
+    after: Optional[str]
+    """Cursor for pagination"""
+
+    ascending: bool
+    """
+    Whether to sort agents oldest to newest (True) or newest to oldest (False,
+    default)
+    """
+
+    base_template_id: Optional[str]
+    """Search agents by base template ID"""
+
+    before: Optional[str]
+    """Cursor for pagination"""
+
+    identifier_keys: Optional[SequenceNotStr[str]]
+    """Search agents by identifier keys"""
+
+    identity_id: Optional[str]
+    """Search agents by identity ID"""
+
+    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.
+    """
+
+    limit: Optional[int]
+    """Limit for pagination"""
+
+    match_all_tags: bool
+    """If True, only returns agents that match ALL given tags.
+
+    Otherwise, return agents that have ANY of the passed-in tags.
+    """
+
+    name: Optional[str]
+    """Name of the agent"""
+
+    order: Literal["asc", "desc"]
+    """Sort order for agents by creation time.
+
+    'asc' for oldest first, 'desc' for newest first
+    """
+
+    order_by: Literal["created_at", "last_run_completion"]
+    """Field to sort by"""
+
+    project_id: Optional[str]
+    """
+    Search agents by project ID - this will default to your default project on cloud
+    """
+
+    query_text: Optional[str]
+    """Search agents by name"""
+
+    sort_by: Optional[str]
+    """Field to sort by. Options: 'created_at' (default), 'last_run_completion'"""
+
+    tags: Optional[SequenceNotStr[str]]
+    """List of tags to filter agents by"""
+
+    template_id: Optional[str]
+    """Search agents by template ID"""

letta_sdk/types/agent_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 .agent_state import AgentState
+
+__all__ = ["AgentListResponse"]
+
+AgentListResponse: TypeAlias = List[AgentState]

letta_sdk/types/agent_migrate_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_extensions import Required, TypedDict
+
+__all__ = ["AgentMigrateParams"]
+
+
+class AgentMigrateParams(TypedDict, total=False):
+    preserve_core_memories: Required[bool]
+
+    to_template: Required[str]
+
+    preserve_tool_variables: bool
+    """
+    If true, preserves the existing agent's tool environment variables instead of
+    using the template's variables
+    """

letta_sdk/types/agent_migrate_response.py

@@ -0,0 +1,11 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = ["AgentMigrateResponse"]
+
+
+class AgentMigrateResponse(BaseModel):
+    success: Literal[True]

letta_sdk/types/agent_reset_messages_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 TypedDict
+
+__all__ = ["AgentResetMessagesParams"]
+
+
+class AgentResetMessagesParams(TypedDict, total=False):
+    add_default_initial_messages: bool
+    """If true, adds the default initial messages after resetting."""

letta_sdk/types/agent_retrieve_context_response.py

@@ -0,0 +1,110 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import TYPE_CHECKING, Dict, List, Optional
+from typing_extensions import Literal
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+from .agents.message import Message
+
+__all__ = ["AgentRetrieveContextResponse", "FunctionsDefinition", "FunctionsDefinitionFunction"]
+
+
+class FunctionsDefinitionFunction(BaseModel):
+    name: str
+
+    description: Optional[str] = None
+
+    parameters: Optional[Dict[str, object]] = None
+
+    strict: Optional[bool] = None
+
+    if TYPE_CHECKING:
+        # Some versions of Pydantic <2.8.0 have a bug and don’t allow assigning a
+        # value to this field, so for compatibility we avoid doing it at runtime.
+        __pydantic_extra__: Dict[str, object] = FieldInfo(init=False)  # pyright: ignore[reportIncompatibleVariableOverride]
+
+        # Stub to indicate that arbitrary properties are accepted.
+        # To access properties that are not valid identifiers you can use `getattr`, e.g.
+        # `getattr(obj, '$type')`
+        def __getattr__(self, attr: str) -> object: ...
+    else:
+        __pydantic_extra__: Dict[str, object]
+
+
+class FunctionsDefinition(BaseModel):
+    function: FunctionsDefinitionFunction
+
+    type: Literal["function"]
+
+    if TYPE_CHECKING:
+        # Some versions of Pydantic <2.8.0 have a bug and don’t allow assigning a
+        # value to this field, so for compatibility we avoid doing it at runtime.
+        __pydantic_extra__: Dict[str, object] = FieldInfo(init=False)  # pyright: ignore[reportIncompatibleVariableOverride]
+
+        # Stub to indicate that arbitrary properties are accepted.
+        # To access properties that are not valid identifiers you can use `getattr`, e.g.
+        # `getattr(obj, '$type')`
+        def __getattr__(self, attr: str) -> object: ...
+    else:
+        __pydantic_extra__: Dict[str, object]
+
+
+class AgentRetrieveContextResponse(BaseModel):
+    context_window_size_current: int
+    """The current number of tokens in the context window."""
+
+    context_window_size_max: int
+    """The maximum amount of tokens the context window can hold."""
+
+    core_memory: str
+    """The content of the core memory."""
+
+    external_memory_summary: str
+    """
+    The metadata summary of the external memory sources (archival + recall
+    metadata).
+    """
+
+    functions_definitions: Optional[List[FunctionsDefinition]] = None
+    """The content of the functions definitions."""
+
+    messages: List[Message]
+    """The messages in the context window."""
+
+    num_archival_memory: int
+    """The number of messages in the archival memory."""
+
+    num_messages: int
+    """The number of messages in the context window."""
+
+    num_recall_memory: int
+    """The number of messages in the recall memory."""
+
+    num_tokens_core_memory: int
+    """The number of tokens in the core memory."""
+
+    num_tokens_external_memory_summary: int
+    """
+    The number of tokens in the external memory summary (archival + recall
+    metadata).
+    """
+
+    num_tokens_functions_definitions: int
+    """The number of tokens in the functions definitions."""
+
+    num_tokens_messages: int
+    """The number of tokens in the messages list."""
+
+    num_tokens_summary_memory: int
+    """The number of tokens in the summary memory."""
+
+    num_tokens_system: int
+    """The number of tokens in the system prompt."""
+
+    system_prompt: str
+    """The content of the system prompt."""
+
+    summary_memory: Optional[str] = None
+    """The content of the summary memory."""

letta_sdk/types/agent_retrieve_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
+
+from .._types import SequenceNotStr
+
+__all__ = ["AgentRetrieveParams"]
+
+
+class AgentRetrieveParams(TypedDict, total=False):
+    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.
+    """