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

letta_sdk/types/agents/message_search_response.py

@@ -0,0 +1,29 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from typing_extensions import TypeAlias
+
+from .message import Message
+from ..._models import BaseModel
+
+__all__ = ["MessageSearchResponse", "MessageSearchResponseItem"]
+
+
+class MessageSearchResponseItem(BaseModel):
+    embedded_text: str
+    """The embedded content (LLM-friendly)"""
+
+    message: Message
+    """The raw message object"""
+
+    rrf_score: float
+    """Reciprocal Rank Fusion combined score"""
+
+    fts_rank: Optional[int] = None
+    """Full-text search rank position if FTS was used"""
+
+    vector_rank: Optional[int] = None
+    """Vector search rank position if vector search was used"""
+
+
+MessageSearchResponse: TypeAlias = List[MessageSearchResponseItem]

letta_sdk/types/agents/message_send_async_params.py

@@ -0,0 +1,49 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List, Union, Iterable, Optional
+from typing_extensions import Required, TypeAlias, TypedDict
+
+from .message_type import MessageType
+from ..message_create_param import MessageCreateParam
+from .approval_create_param import ApprovalCreateParam
+
+__all__ = ["MessageSendAsyncParams", "Message"]
+
+
+class MessageSendAsyncParams(TypedDict, total=False):
+    messages: Required[Iterable[Message]]
+    """The messages to be sent to the agent."""
+
+    assistant_message_tool_kwarg: str
+    """The name of the message argument in the designated message tool."""
+
+    assistant_message_tool_name: str
+    """The name of the designated message tool."""
+
+    callback_url: Optional[str]
+    """Optional callback URL to POST to when the job completes"""
+
+    enable_thinking: str
+    """
+    If set to True, enables reasoning before responses or tool calls from the agent.
+    """
+
+    include_return_message_types: Optional[List[MessageType]]
+    """Only return specified message types in the response.
+
+    If `None` (default) returns all messages.
+    """
+
+    max_steps: int
+    """Maximum number of steps the agent should take to process the request."""
+
+    use_assistant_message: bool
+    """
+    Whether the server should parse specific tool call arguments (default
+    `send_message`) as `AssistantMessage` objects.
+    """
+
+
+Message: TypeAlias = Union[MessageCreateParam, ApprovalCreateParam]

letta_sdk/types/agents/message_send_params.py

@@ -0,0 +1,46 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List, Union, Iterable, Optional
+from typing_extensions import Required, TypeAlias, TypedDict
+
+from .message_type import MessageType
+from ..message_create_param import MessageCreateParam
+from .approval_create_param import ApprovalCreateParam
+
+__all__ = ["MessageSendParams", "Message"]
+
+
+class MessageSendParams(TypedDict, total=False):
+    messages: Required[Iterable[Message]]
+    """The messages to be sent to the agent."""
+
+    assistant_message_tool_kwarg: str
+    """The name of the message argument in the designated message tool."""
+
+    assistant_message_tool_name: str
+    """The name of the designated message tool."""
+
+    enable_thinking: str
+    """
+    If set to True, enables reasoning before responses or tool calls from the agent.
+    """
+
+    include_return_message_types: Optional[List[MessageType]]
+    """Only return specified message types in the response.
+
+    If `None` (default) returns all messages.
+    """
+
+    max_steps: int
+    """Maximum number of steps the agent should take to process the request."""
+
+    use_assistant_message: bool
+    """
+    Whether the server should parse specific tool call arguments (default
+    `send_message`) as `AssistantMessage` objects.
+    """
+
+
+Message: TypeAlias = Union[MessageCreateParam, ApprovalCreateParam]

letta_sdk/types/agents/message_send_stream_params.py

@@ -0,0 +1,61 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List, Union, Iterable, Optional
+from typing_extensions import Required, TypeAlias, TypedDict
+
+from .message_type import MessageType
+from ..message_create_param import MessageCreateParam
+from .approval_create_param import ApprovalCreateParam
+
+__all__ = ["MessageSendStreamParams", "Message"]
+
+
+class MessageSendStreamParams(TypedDict, total=False):
+    messages: Required[Iterable[Message]]
+    """The messages to be sent to the agent."""
+
+    assistant_message_tool_kwarg: str
+    """The name of the message argument in the designated message tool."""
+
+    assistant_message_tool_name: str
+    """The name of the designated message tool."""
+
+    background: bool
+    """Whether to process the request in the background."""
+
+    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.
+    """
+
+    include_return_message_types: Optional[List[MessageType]]
+    """Only return specified message types in the response.
+
+    If `None` (default) returns all messages.
+    """
+
+    max_steps: int
+    """Maximum number of steps the agent should take to process the request."""
+
+    stream_tokens: bool
+    """
+    Flag to determine if individual tokens should be streamed, rather than streaming
+    per step.
+    """
+
+    use_assistant_message: bool
+    """
+    Whether the server should parse specific tool call arguments (default
+    `send_message`) as `AssistantMessage` objects.
+    """
+
+
+Message: TypeAlias = Union[MessageCreateParam, ApprovalCreateParam]

letta_sdk/types/agents/message_type.py

@@ -0,0 +1,17 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal, TypeAlias
+
+__all__ = ["MessageType"]
+
+MessageType: TypeAlias = Literal[
+    "system_message",
+    "user_message",
+    "assistant_message",
+    "reasoning_message",
+    "hidden_reasoning_message",
+    "tool_call_message",
+    "tool_return_message",
+    "approval_request_message",
+    "approval_response_message",
+]

letta_sdk/types/agents/message_update_params.py

@@ -0,0 +1,66 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union, Iterable
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
+
+from .letta_user_message_content_union_param import LettaUserMessageContentUnionParam
+from .letta_assistant_message_content_union_param import LettaAssistantMessageContentUnionParam
+
+__all__ = [
+    "MessageUpdateParams",
+    "UpdateSystemMessage",
+    "UpdateUserMessage",
+    "UpdateReasoningMessage",
+    "UpdateAssistantMessage",
+]
+
+
+class UpdateSystemMessage(TypedDict, total=False):
+    agent_id: Required[str]
+
+    content: Required[str]
+    """
+    The message content sent by the system (can be a string or an array of
+    multi-modal content parts)
+    """
+
+    message_type: Literal["system_message"]
+
+
+class UpdateUserMessage(TypedDict, total=False):
+    agent_id: Required[str]
+
+    content: Required[Union[Iterable[LettaUserMessageContentUnionParam], str]]
+    """
+    The message content sent by the user (can be a string or an array of multi-modal
+    content parts)
+    """
+
+    message_type: Literal["user_message"]
+
+
+class UpdateReasoningMessage(TypedDict, total=False):
+    agent_id: Required[str]
+
+    reasoning: Required[str]
+
+    message_type: Literal["reasoning_message"]
+
+
+class UpdateAssistantMessage(TypedDict, total=False):
+    agent_id: Required[str]
+
+    content: Required[Union[Iterable[LettaAssistantMessageContentUnionParam], str]]
+    """
+    The message content sent by the assistant (can be a string or an array of
+    content parts)
+    """
+
+    message_type: Literal["assistant_message"]
+
+
+MessageUpdateParams: TypeAlias = Union[
+    UpdateSystemMessage, UpdateUserMessage, UpdateReasoningMessage, UpdateAssistantMessage
+]

letta_sdk/types/agents/message_update_response.py

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

letta_sdk/types/agents/omitted_reasoning_content.py

@@ -0,0 +1,13 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["OmittedReasoningContent"]
+
+
+class OmittedReasoningContent(BaseModel):
+    type: Optional[Literal["omitted_reasoning"]] = None
+    """Indicates this is an omitted reasoning step."""

letta_sdk/types/agents/omitted_reasoning_content_param.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 Literal, TypedDict
+
+__all__ = ["OmittedReasoningContentParam"]
+
+
+class OmittedReasoningContentParam(TypedDict, total=False):
+    type: Literal["omitted_reasoning"]
+    """Indicates this is an omitted reasoning step."""

letta_sdk/types/agents/reasoning_content.py

@@ -0,0 +1,25 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ReasoningContent"]
+
+
+class ReasoningContent(BaseModel):
+    is_native: bool
+    """
+    Whether the reasoning content was generated by a reasoner model that processed
+    this step.
+    """
+
+    reasoning: str
+    """The intermediate reasoning or thought process content."""
+
+    signature: Optional[str] = None
+    """A unique identifier for this reasoning step."""
+
+    type: Optional[Literal["reasoning"]] = None
+    """Indicates this is a reasoning/intermediate step."""

letta_sdk/types/agents/reasoning_content_param.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 Literal, Required, TypedDict
+
+__all__ = ["ReasoningContentParam"]
+
+
+class ReasoningContentParam(TypedDict, total=False):
+    is_native: Required[bool]
+    """
+    Whether the reasoning content was generated by a reasoner model that processed
+    this step.
+    """
+
+    reasoning: Required[str]
+    """The intermediate reasoning or thought process content."""
+
+    signature: Optional[str]
+    """A unique identifier for this reasoning step."""
+
+    type: Literal["reasoning"]
+    """Indicates this is a reasoning/intermediate step."""

letta_sdk/types/agents/reasoning_message.py

@@ -0,0 +1,38 @@
+# 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__ = ["ReasoningMessage"]
+
+
+class ReasoningMessage(BaseModel):
+    id: str
+
+    date: datetime
+
+    reasoning: str
+
+    is_err: Optional[bool] = None
+
+    message_type: Optional[Literal["reasoning_message"]] = None
+    """The type of the message."""
+
+    name: Optional[str] = None
+
+    otid: Optional[str] = None
+
+    run_id: Optional[str] = None
+
+    sender_id: Optional[str] = None
+
+    seq_id: Optional[int] = None
+
+    signature: Optional[str] = None
+
+    source: Optional[Literal["reasoner_model", "non_reasoner_model"]] = None
+
+    step_id: Optional[str] = None

letta_sdk/types/agents/redacted_reasoning_content.py

@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["RedactedReasoningContent"]
+
+
+class RedactedReasoningContent(BaseModel):
+    data: str
+    """The redacted or filtered intermediate reasoning content."""
+
+    type: Optional[Literal["redacted_reasoning"]] = None
+    """Indicates this is a redacted thinking step."""

letta_sdk/types/agents/redacted_reasoning_content_param.py

@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["RedactedReasoningContentParam"]
+
+
+class RedactedReasoningContentParam(TypedDict, total=False):
+    data: Required[str]
+    """The redacted or filtered intermediate reasoning content."""
+
+    type: Literal["redacted_reasoning"]
+    """Indicates this is a redacted thinking step."""

letta_sdk/types/agents/run.py

@@ -0,0 +1,84 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Optional
+from datetime import datetime
+
+from .job_type import JobType
+from ..._models import BaseModel
+from .job_status import JobStatus
+from .message_type import MessageType
+from ..stop_reason_type import StopReasonType
+
+__all__ = ["Run", "RequestConfig"]
+
+
+class RequestConfig(BaseModel):
+    assistant_message_tool_kwarg: Optional[str] = None
+    """The name of the message argument in the designated message tool."""
+
+    assistant_message_tool_name: Optional[str] = None
+    """The name of the designated message tool."""
+
+    include_return_message_types: Optional[List[MessageType]] = None
+    """Only return specified message types in the response.
+
+    If `None` (default) returns all messages.
+    """
+
+    use_assistant_message: Optional[bool] = None
+    """
+    Whether the server should parse specific tool call arguments (default
+    `send_message`) as `AssistantMessage` objects.
+    """
+
+
+class Run(BaseModel):
+    id: Optional[str] = None
+    """The human-friendly ID of the Run"""
+
+    callback_error: Optional[str] = None
+    """Optional error message from attempting to POST the callback endpoint."""
+
+    callback_sent_at: Optional[datetime] = None
+    """Timestamp when the callback was last attempted."""
+
+    callback_status_code: Optional[int] = None
+    """HTTP status code returned by the callback endpoint."""
+
+    callback_url: Optional[str] = None
+    """If set, POST to this URL when the job completes."""
+
+    completed_at: Optional[datetime] = None
+    """The unix timestamp of when the job was completed."""
+
+    created_at: Optional[datetime] = None
+    """The unix timestamp of when the job was created."""
+
+    created_by_id: Optional[str] = None
+    """The id of the user that made this object."""
+
+    job_type: Optional[JobType] = None
+
+    last_updated_by_id: Optional[str] = None
+    """The id of the user that made this object."""
+
+    metadata: Optional[Dict[str, object]] = None
+    """The metadata of the job."""
+
+    request_config: Optional[RequestConfig] = None
+    """The request configuration for the run."""
+
+    status: Optional[JobStatus] = None
+    """The status of the job."""
+
+    stop_reason: Optional[StopReasonType] = None
+    """The reason why the run was stopped."""
+
+    total_duration_ns: Optional[int] = None
+    """Total run duration in nanoseconds"""
+
+    ttft_ns: Optional[int] = None
+    """Time to first token for a run in nanoseconds"""
+
+    updated_at: Optional[datetime] = None
+    """The timestamp when the object was last updated."""

letta_sdk/types/agents/source_list_response.py

@@ -0,0 +1,10 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List
+from typing_extensions import TypeAlias
+
+from ..source import Source
+
+__all__ = ["SourceListResponse"]
+
+SourceListResponse: TypeAlias = List[Source]

letta_sdk/types/agents/system_message.py

@@ -0,0 +1,35 @@
+# 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__ = ["SystemMessage"]
+
+
+class SystemMessage(BaseModel):
+    id: str
+
+    content: str
+    """The message content sent by the system"""
+
+    date: datetime
+
+    is_err: Optional[bool] = None
+
+    message_type: Optional[Literal["system_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/text_content.py

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

letta_sdk/types/agents/text_content_param.py

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

letta_sdk/types/agents/tool_call.py

@@ -0,0 +1,13 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from ..._models import BaseModel
+
+__all__ = ["ToolCall"]
+
+
+class ToolCall(BaseModel):
+    arguments: str
+
+    name: str
+
+    tool_call_id: str

letta_sdk/types/agents/tool_call_content.py

@@ -0,0 +1,25 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ToolCallContent"]
+
+
+class ToolCallContent(BaseModel):
+    id: str
+    """A unique identifier for this specific tool call instance."""
+
+    input: Dict[str, object]
+    """
+    The parameters being passed to the tool, structured as a dictionary of parameter
+    names to values.
+    """
+
+    name: str
+    """The name of the tool being called."""
+
+    type: Optional[Literal["tool_call"]] = None
+    """Indicates this content represents a tool call event."""