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

letta_client/types/child_tool_rule.py

@@ -1,37 +1,48 @@
-# This file was auto-generated by Fern from our API Definition.
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-from ..core.unchecked_base_model import UncheckedBaseModel
-import pydantic
-import typing
-from ..core.pydantic_utilities import IS_PYDANTIC_V2
+from typing import Dict, List, Optional
+from typing_extensions import Literal
 
+from .._models import BaseModel
 
-class ChildToolRule(UncheckedBaseModel):
-    """
-    A ToolRule represents a tool that can be invoked by the agent.
-    """
+__all__ = ["ChildToolRule", "ChildArgNode"]
 
-    tool_name: str = pydantic.Field()
-    """
-    The name of the tool. Must exist in the database for the user's organization.
-    """
 
-    type: typing.Literal["constrain_child_tools"] = "constrain_child_tools"
-    prompt_template: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    Optional Jinja2 template for generating agent prompt about this tool rule.
+class ChildArgNode(BaseModel):
+    """Typed child override for prefilled arguments.
+
+    When used in a ChildToolRule, if this child is selected next, its `args` will be
+    applied as prefilled arguments (overriding overlapping LLM-provided values).
     """
 
-    children: typing.List[str] = pydantic.Field()
+    name: str
+    """The name of the child tool to invoke next."""
+
+    args: Optional[Dict[str, object]] = None
+    """Optional prefilled arguments for this child tool.
+
+    Keys must match the tool's parameter names and values must satisfy the tool's
+    JSON schema. Supports partial prefill; non-overlapping parameters are left to
+    the model.
     """
-    The children tools that can be invoked.
+
+
+class ChildToolRule(BaseModel):
+    """A ToolRule represents a tool that can be invoked by the agent."""
+
+    children: List[str]
+    """The children tools that can be invoked."""
+
+    tool_name: str
+    """The name of the tool. Must exist in the database for the user's organization."""
+
+    child_arg_nodes: Optional[List[ChildArgNode]] = None
+    """Optional list of typed child argument overrides.
+
+    Each node must reference a child in 'children'.
     """
 
-    if IS_PYDANTIC_V2:
-        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
-    else:
+    prompt_template: Optional[str] = None
+    """Optional template string (ignored)."""
 
-        class Config:
-            frozen = True
-            smart_union = True
-            extra = pydantic.Extra.allow
+    type: Optional[Literal["constrain_child_tools"]] = None

letta_client/types/child_tool_rule_param.py

@@ -0,0 +1,50 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Iterable, Optional
+from typing_extensions import Literal, Required, TypedDict
+
+from .._types import SequenceNotStr
+
+__all__ = ["ChildToolRuleParam", "ChildArgNode"]
+
+
+class ChildArgNode(TypedDict, total=False):
+    """Typed child override for prefilled arguments.
+
+    When used in a ChildToolRule, if this child is selected next, its `args` will be
+    applied as prefilled arguments (overriding overlapping LLM-provided values).
+    """
+
+    name: Required[str]
+    """The name of the child tool to invoke next."""
+
+    args: Optional[Dict[str, object]]
+    """Optional prefilled arguments for this child tool.
+
+    Keys must match the tool's parameter names and values must satisfy the tool's
+    JSON schema. Supports partial prefill; non-overlapping parameters are left to
+    the model.
+    """
+
+
+class ChildToolRuleParam(TypedDict, total=False):
+    """A ToolRule represents a tool that can be invoked by the agent."""
+
+    children: Required[SequenceNotStr[str]]
+    """The children tools that can be invoked."""
+
+    tool_name: Required[str]
+    """The name of the tool. Must exist in the database for the user's organization."""
+
+    child_arg_nodes: Optional[Iterable[ChildArgNode]]
+    """Optional list of typed child argument overrides.
+
+    Each node must reference a child in 'children'.
+    """
+
+    prompt_template: Optional[str]
+    """Optional template string (ignored)."""
+
+    type: Literal["constrain_child_tools"]

letta_client/types/conditional_tool_rule.py

@@ -1,47 +1,31 @@
-# This file was auto-generated by Fern from our API Definition.
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-from ..core.unchecked_base_model import UncheckedBaseModel
-import pydantic
-import typing
-from ..core.pydantic_utilities import IS_PYDANTIC_V2
+from typing import Dict, Optional
+from typing_extensions import Literal
 
+from .._models import BaseModel
 
-class ConditionalToolRule(UncheckedBaseModel):
-    """
-    A ToolRule that conditionally maps to different child tools based on the output.
-    """
+__all__ = ["ConditionalToolRule"]
 
-    tool_name: str = pydantic.Field()
-    """
-    The name of the tool. Must exist in the database for the user's organization.
-    """
 
-    type: typing.Literal["conditional"] = "conditional"
-    prompt_template: typing.Optional[str] = pydantic.Field(default=None)
+class ConditionalToolRule(BaseModel):
     """
-    Optional Jinja2 template for generating agent prompt about this tool rule.
+    A ToolRule that conditionally maps to different child tools based on the output.
     """
 
-    default_child: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    The default child tool to be called. If None, any tool can be called.
-    """
+    child_output_mapping: Dict[str, str]
+    """The output case to check for mapping"""
 
-    child_output_mapping: typing.Dict[str, str] = pydantic.Field()
-    """
-    The output case to check for mapping
-    """
+    tool_name: str
+    """The name of the tool. Must exist in the database for the user's organization."""
 
-    require_output_mapping: typing.Optional[bool] = pydantic.Field(default=None)
-    """
-    Whether to throw an error when output doesn't match any case
-    """
+    default_child: Optional[str] = None
+    """The default child tool to be called. If None, any tool can be called."""
+
+    prompt_template: Optional[str] = None
+    """Optional template string (ignored)."""
 
-    if IS_PYDANTIC_V2:
-        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
-    else:
+    require_output_mapping: Optional[bool] = None
+    """Whether to throw an error when output doesn't match any case"""
 
-        class Config:
-            frozen = True
-            smart_union = True
-            extra = pydantic.Extra.allow
+    type: Optional[Literal["conditional"]] = None

letta_client/types/conditional_tool_rule_param.py

@@ -0,0 +1,31 @@
+# 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 Literal, Required, TypedDict
+
+__all__ = ["ConditionalToolRuleParam"]
+
+
+class ConditionalToolRuleParam(TypedDict, total=False):
+    """
+    A ToolRule that conditionally maps to different child tools based on the output.
+    """
+
+    child_output_mapping: Required[Dict[str, str]]
+    """The output case to check for mapping"""
+
+    tool_name: Required[str]
+    """The name of the tool. Must exist in the database for the user's organization."""
+
+    default_child: Optional[str]
+    """The default child tool to be called. If None, any tool can be called."""
+
+    prompt_template: Optional[str]
+    """Optional template string (ignored)."""
+
+    require_output_mapping: bool
+    """Whether to throw an error when output doesn't match any case"""
+
+    type: Literal["conditional"]

letta_client/types/continue_tool_rule.py

@@ -1,32 +1,22 @@
-# This file was auto-generated by Fern from our API Definition.
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-from ..core.unchecked_base_model import UncheckedBaseModel
-import pydantic
-import typing
-from ..core.pydantic_utilities import IS_PYDANTIC_V2
+from typing import Optional
+from typing_extensions import Literal
 
+from .._models import BaseModel
 
-class ContinueToolRule(UncheckedBaseModel):
-    """
-    Represents a tool rule configuration where if this tool gets called, it must continue the agent loop.
-    """
+__all__ = ["ContinueToolRule"]
 
-    tool_name: str = pydantic.Field()
-    """
-    The name of the tool. Must exist in the database for the user's organization.
-    """
 
-    type: typing.Literal["continue_loop"] = "continue_loop"
-    prompt_template: typing.Optional[str] = pydantic.Field(default=None)
+class ContinueToolRule(BaseModel):
     """
-    Optional Jinja2 template for generating agent prompt about this tool rule.
+    Represents a tool rule configuration where if this tool gets called, it must continue the agent loop.
     """
 
-    if IS_PYDANTIC_V2:
-        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
-    else:
+    tool_name: str
+    """The name of the tool. Must exist in the database for the user's organization."""
+
+    prompt_template: Optional[str] = None
+    """Optional template string (ignored)."""
 
-        class Config:
-            frozen = True
-            smart_union = True
-            extra = pydantic.Extra.allow
+    type: Optional[Literal["continue_loop"]] = None

letta_client/types/continue_tool_rule_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__ = ["ContinueToolRuleParam"]
+
+
+class ContinueToolRuleParam(TypedDict, total=False):
+    """
+    Represents a tool rule configuration where if this tool gets called, it must continue the agent loop.
+    """
+
+    tool_name: Required[str]
+    """The name of the tool. Must exist in the database for the user's organization."""
+
+    prompt_template: Optional[str]
+    """Optional template string (ignored)."""
+
+    type: Literal["continue_loop"]

letta_client/types/conversation.py

@@ -0,0 +1,42 @@
+# 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__ = ["Conversation"]
+
+
+class Conversation(BaseModel):
+    """Represents a conversation on an agent for concurrent messaging."""
+
+    id: str
+    """The unique identifier of the conversation."""
+
+    agent_id: str
+    """The ID of the agent this conversation belongs to."""
+
+    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."""
+
+    in_context_message_ids: Optional[List[str]] = None
+    """The IDs of in-context messages for the conversation."""
+
+    isolated_block_ids: Optional[List[str]] = None
+    """
+    IDs of blocks that are isolated (specific to this conversation, overriding agent
+    defaults).
+    """
+
+    last_updated_by_id: Optional[str] = None
+    """The id of the user that made this object."""
+
+    summary: Optional[str] = None
+    """A summary of the conversation."""
+
+    updated_at: Optional[datetime] = None
+    """The timestamp when the object was last updated."""

letta_client/types/conversation_cancel_response.py

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

letta_client/types/conversation_create_params.py

@@ -0,0 +1,25 @@
+# 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, TypedDict
+
+from .._types import SequenceNotStr
+
+__all__ = ["ConversationCreateParams"]
+
+
+class ConversationCreateParams(TypedDict, total=False):
+    agent_id: Required[str]
+    """The agent ID to create a conversation for"""
+
+    isolated_block_labels: Optional[SequenceNotStr[str]]
+    """
+    List of block labels that should be isolated (conversation-specific) rather than
+    shared across conversations. New blocks will be created as copies of the agent's
+    blocks with these labels.
+    """
+
+    summary: Optional[str]
+    """A summary of the conversation."""

letta_client/types/conversation_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 Required, TypedDict
+
+__all__ = ["ConversationListParams"]
+
+
+class ConversationListParams(TypedDict, total=False):
+    agent_id: Required[str]
+    """The agent ID to list conversations for"""
+
+    after: Optional[str]
+    """Cursor for pagination (conversation ID)"""
+
+    limit: int
+    """Maximum number of conversations to return"""

letta_client/types/conversation_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 .conversation import Conversation
+
+__all__ = ["ConversationListResponse"]
+
+ConversationListResponse: TypeAlias = List[Conversation]

letta_client/types/conversation_update_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__ = ["ConversationUpdateParams"]
+
+
+class ConversationUpdateParams(TypedDict, total=False):
+    summary: Optional[str]
+    """A summary of the conversation."""

letta_client/types/conversations/__init__.py

@@ -0,0 +1,7 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .message_list_params import MessageListParams as MessageListParams
+from .message_create_params import MessageCreateParams as MessageCreateParams
+from .message_stream_params import MessageStreamParams as MessageStreamParams

letta_client/types/conversations/message_create_params.py

@@ -0,0 +1,166 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, List, Union, Iterable, Optional
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
+
+from ..agents.message_type import MessageType
+from ..message_create_param import MessageCreateParam
+from ..agents.text_content_param import TextContentParam
+from ..agents.image_content_param import ImageContentParam
+from ..agents.approval_create_param import ApprovalCreateParam
+from ..agents.reasoning_content_param import ReasoningContentParam
+from ..agents.tool_call_content_param import ToolCallContentParam
+from ..agents.tool_return_content_param import ToolReturnContentParam
+from ..agents.omitted_reasoning_content_param import OmittedReasoningContentParam
+from ..agents.redacted_reasoning_content_param import RedactedReasoningContentParam
+
+__all__ = [
+    "MessageCreateParams",
+    "ClientTool",
+    "InputUnionMember1",
+    "InputUnionMember1SummarizedReasoningContent",
+    "InputUnionMember1SummarizedReasoningContentSummary",
+    "Message",
+]
+
+
+class MessageCreateParams(TypedDict, total=False):
+    assistant_message_tool_kwarg: str
+    """The name of the message argument in the designated message tool.
+
+    Still supported for legacy agent types, but deprecated for letta_v1_agent
+    onward.
+    """
+
+    assistant_message_tool_name: str
+    """The name of the designated message tool.
+
+    Still supported for legacy agent types, but deprecated for letta_v1_agent
+    onward.
+    """
+
+    background: bool
+    """
+    Whether to process the request in the background (only used when
+    streaming=true).
+    """
+
+    client_tools: Optional[Iterable[ClientTool]]
+    """Client-side tools that the agent can call.
+
+    When the agent calls a client-side tool, execution pauses and returns control to
+    the client to execute the tool and provide the result via a ToolReturn.
+    """
+
+    enable_thinking: str
+    """
+    If set to True, enables reasoning before responses or tool calls from the agent.
+    """
+
+    include_pings: bool
+    """
+    Whether to include periodic keepalive ping messages in the stream to prevent
+    connection timeouts (only used when streaming=true).
+    """
+
+    include_return_message_types: Optional[List[MessageType]]
+    """Only return specified message types in the response.
+
+    If `None` (default) returns all messages.
+    """
+
+    input: Union[str, Iterable[InputUnionMember1], None]
+    """Syntactic sugar for a single user message.
+
+    Equivalent to messages=[{'role': 'user', 'content': input}].
+    """
+
+    max_steps: int
+    """Maximum number of steps the agent should take to process the request."""
+
+    messages: Optional[Iterable[Message]]
+    """The messages to be sent to the agent."""
+
+    override_model: Optional[str]
+    """Model handle to use for this request instead of the agent's default model.
+
+    This allows sending a message to a different model without changing the agent's
+    configuration.
+    """
+
+    stream_tokens: bool
+    """
+    Flag to determine if individual tokens should be streamed, rather than streaming
+    per step (only used when streaming=true).
+    """
+
+    streaming: bool
+    """If True, returns a streaming response (Server-Sent Events).
+
+    If False (default), returns a complete response.
+    """
+
+    use_assistant_message: bool
+    """
+    Whether the server should parse specific tool call arguments (default
+    `send_message`) as `AssistantMessage` objects. Still supported for legacy agent
+    types, but deprecated for letta_v1_agent onward.
+    """
+
+
+class ClientTool(TypedDict, total=False):
+    """Schema for a client-side tool passed in the request.
+
+    Client-side tools are executed by the client, not the server. When the agent
+    calls a client-side tool, execution pauses and returns control to the client
+    to execute the tool and provide the result.
+    """
+
+    name: Required[str]
+    """The name of the tool function"""
+
+    description: Optional[str]
+    """Description of what the tool does"""
+
+    parameters: Optional[Dict[str, object]]
+    """JSON Schema for the function parameters"""
+
+
+class InputUnionMember1SummarizedReasoningContentSummary(TypedDict, total=False):
+    index: Required[int]
+    """The index of the summary part."""
+
+    text: Required[str]
+    """The text of the summary part."""
+
+
+class InputUnionMember1SummarizedReasoningContent(TypedDict, total=False):
+    """The style of reasoning content returned by the OpenAI Responses API"""
+
+    id: Required[str]
+    """The unique identifier for this reasoning step."""
+
+    summary: Required[Iterable[InputUnionMember1SummarizedReasoningContentSummary]]
+    """Summaries of the reasoning content."""
+
+    encrypted_content: str
+    """The encrypted reasoning content."""
+
+    type: Literal["summarized_reasoning"]
+    """Indicates this is a summarized reasoning step."""
+
+
+InputUnionMember1: TypeAlias = Union[
+    TextContentParam,
+    ImageContentParam,
+    ToolCallContentParam,
+    ToolReturnContentParam,
+    ReasoningContentParam,
+    RedactedReasoningContentParam,
+    OmittedReasoningContentParam,
+    InputUnionMember1SummarizedReasoningContent,
+]
+
+Message: TypeAlias = Union[MessageCreateParam, ApprovalCreateParam]

letta_client/types/conversations/message_list_params.py

@@ -0,0 +1,43 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import Literal, TypedDict
+
+__all__ = ["MessageListParams"]
+
+
+class MessageListParams(TypedDict, total=False):
+    after: Optional[str]
+    """Message ID cursor for pagination.
+
+    Returns messages that come after this message ID in the specified sort order
+    """
+
+    before: Optional[str]
+    """Message ID cursor for pagination.
+
+    Returns messages that come before this message ID in the specified sort order
+    """
+
+    group_id: Optional[str]
+    """Group ID to filter messages by."""
+
+    include_err: Optional[bool]
+    """Whether to include error messages and error statuses.
+
+    For debugging purposes only.
+    """
+
+    limit: Optional[int]
+    """Maximum number of messages to return"""
+
+    order: Literal["asc", "desc"]
+    """Sort order for messages by creation time.
+
+    'asc' for oldest first, 'desc' for newest first
+    """
+
+    order_by: Literal["created_at"]
+    """Field to sort by"""

letta_client/types/conversations/message_stream_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__ = ["MessageStreamParams"]
+
+
+class MessageStreamParams(TypedDict, total=False):
+    batch_size: Optional[int]
+    """Number of entries to read per batch."""
+
+    include_pings: Optional[bool]
+    """
+    Whether to include periodic keepalive ping messages in the stream to prevent
+    connection timeouts.
+    """
+
+    poll_interval: Optional[float]
+    """Seconds to wait between polls when no new data."""
+
+    starting_after: int
+    """Sequence id to use as a cursor for pagination.
+
+    Response will start streaming after this chunk sequence id
+    """