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

letta_client/types/agents/message_stream_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 .message_type import MessageType
+from .text_content_param import TextContentParam
+from .image_content_param import ImageContentParam
+from ..message_create_param import MessageCreateParam
+from .approval_create_param import ApprovalCreateParam
+from .reasoning_content_param import ReasoningContentParam
+from .tool_call_content_param import ToolCallContentParam
+from .tool_return_content_param import ToolReturnContentParam
+from .omitted_reasoning_content_param import OmittedReasoningContentParam
+from .redacted_reasoning_content_param import RedactedReasoningContentParam
+
+__all__ = [
+    "MessageStreamParams",
+    "ClientTool",
+    "InputUnionMember1",
+    "InputUnionMember1SummarizedReasoningContent",
+    "InputUnionMember1SummarizedReasoningContentSummary",
+    "Message",
+]
+
+
+class MessageStreamParams(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/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_client/types/agents/omitted_reasoning_content.py

@@ -0,0 +1,20 @@
+# 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):
+    """
+    A placeholder for reasoning content we know is present, but isn't returned by the provider (e.g. OpenAI GPT-5 on ChatCompletions)
+    """
+
+    signature: Optional[str] = None
+    """A unique identifier for this reasoning step."""
+
+    type: Optional[Literal["omitted_reasoning"]] = None
+    """Indicates this is an omitted reasoning step."""

letta_client/types/agents/omitted_reasoning_content_param.py

@@ -0,0 +1,20 @@
+# 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__ = ["OmittedReasoningContentParam"]
+
+
+class OmittedReasoningContentParam(TypedDict, total=False):
+    """
+    A placeholder for reasoning content we know is present, but isn't returned by the provider (e.g. OpenAI GPT-5 on ChatCompletions)
+    """
+
+    signature: Optional[str]
+    """A unique identifier for this reasoning step."""
+
+    type: Literal["omitted_reasoning"]
+    """Indicates this is an omitted reasoning step."""

letta_client/types/agents/passage_create_params.py

@@ -0,0 +1,23 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union, Optional
+from datetime import datetime
+from typing_extensions import Required, Annotated, TypedDict
+
+from ..._types import SequenceNotStr
+from ..._utils import PropertyInfo
+
+__all__ = ["PassageCreateParams"]
+
+
+class PassageCreateParams(TypedDict, total=False):
+    text: Required[str]
+    """Text to write to archival memory."""
+
+    created_at: Annotated[Union[str, datetime, None], PropertyInfo(format="iso8601")]
+    """Optional timestamp for the memory (defaults to current UTC time)."""
+
+    tags: Optional[SequenceNotStr[str]]
+    """Optional list of tags to attach to the memory."""

letta_client/types/agents/passage_create_response.py

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

letta_client/types/agents/passage_list_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__ = ["PassageListParams"]
+
+
+class PassageListParams(TypedDict, total=False):
+    after: Optional[str]
+    """Unique ID of the memory to start the query range at."""
+
+    ascending: Optional[bool]
+    """
+    Whether to sort passages oldest to newest (True, default) or newest to oldest
+    (False)
+    """
+
+    before: Optional[str]
+    """Unique ID of the memory to end the query range at."""
+
+    limit: Optional[int]
+    """How many results to include in the response."""
+
+    search: Optional[str]
+    """Search passages by text"""

letta_client/types/agents/passage_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 ..passage import Passage
+
+__all__ = ["PassageListResponse"]
+
+PassageListResponse: TypeAlias = List[Passage]

letta_client/types/agents/passage_search_params.py

@@ -0,0 +1,35 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union, Optional
+from datetime import datetime
+from typing_extensions import Literal, Required, Annotated, TypedDict
+
+from ..._types import SequenceNotStr
+from ..._utils import PropertyInfo
+
+__all__ = ["PassageSearchParams"]
+
+
+class PassageSearchParams(TypedDict, total=False):
+    query: Required[str]
+    """String to search for using semantic similarity"""
+
+    end_datetime: Annotated[Union[str, datetime, None], PropertyInfo(format="iso8601")]
+    """Filter results to passages created before this datetime"""
+
+    start_datetime: Annotated[Union[str, datetime, None], PropertyInfo(format="iso8601")]
+    """Filter results to passages created after this datetime"""
+
+    tag_match_mode: Literal["any", "all"]
+    """
+    How to match tags - 'any' to match passages with any of the tags, 'all' to match
+    only passages with all tags
+    """
+
+    tags: Optional[SequenceNotStr[str]]
+    """Optional list of tags to filter search results"""
+
+    top_k: Optional[int]
+    """Maximum number of results to return. Uses system default if not specified"""

letta_client/types/agents/passage_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 ..._models import BaseModel
+
+__all__ = ["PassageSearchResponse", "Result"]
+
+
+class Result(BaseModel):
+    id: str
+    """Unique identifier of the archival memory passage"""
+
+    content: str
+    """Text content of the archival memory passage"""
+
+    timestamp: str
+    """Timestamp of when the memory was created, formatted in agent's timezone"""
+
+    tags: Optional[List[str]] = None
+    """List of tags associated with this memory"""
+
+
+class PassageSearchResponse(BaseModel):
+    count: int
+    """Total number of results returned"""
+
+    results: List[Result]
+    """List of search results matching the query"""

letta_client/types/agents/reasoning_content.py

@@ -0,0 +1,27 @@
+# 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):
+    """Sent via the Anthropic Messages API"""
+
+    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_client/types/agents/reasoning_content_param.py

@@ -0,0 +1,27 @@
+# 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):
+    """Sent via the Anthropic Messages API"""
+
+    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_client/types/agents/reasoning_message.py

@@ -0,0 +1,50 @@
+# 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):
+    """Representation of an agent's internal reasoning.
+
+    Args:
+        id (str): The ID of the message
+        date (datetime): The date the message was created in ISO format
+        name (Optional[str]): The name of the sender of the message
+        source (Literal["reasoner_model", "non_reasoner_model"]): Whether the reasoning
+            content was generated natively by a reasoner model or derived via prompting
+        reasoning (str): The internal reasoning of the agent
+        signature (Optional[str]): The model-generated signature of the reasoning step
+    """
+
+    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_client/types/agents/redacted_reasoning_content.py

@@ -0,0 +1,18 @@
+# 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):
+    """Sent via the Anthropic Messages API"""
+
+    data: str
+    """The redacted or filtered intermediate reasoning content."""
+
+    type: Optional[Literal["redacted_reasoning"]] = None
+    """Indicates this is a redacted thinking step."""

letta_client/types/agents/redacted_reasoning_content_param.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 Literal, Required, TypedDict
+
+__all__ = ["RedactedReasoningContentParam"]
+
+
+class RedactedReasoningContentParam(TypedDict, total=False):
+    """Sent via the Anthropic Messages API"""
+
+    data: Required[str]
+    """The redacted or filtered intermediate reasoning content."""
+
+    type: Literal["redacted_reasoning"]
+    """Indicates this is a redacted thinking step."""

letta_client/types/agents/run.py

@@ -0,0 +1,91 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Optional
+from datetime import datetime
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+from .message_type import MessageType
+from ..stop_reason_type import StopReasonType
+
+__all__ = ["Run", "RequestConfig"]
+
+
+class RequestConfig(BaseModel):
+    """The request configuration for the run."""
+
+    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):
+    """Representation of a run - a conversation or processing session for an agent.
+
+    Runs track when agents process messages and maintain the relationship between agents, steps, and messages.
+    """
+
+    id: str
+    """The human-friendly ID of the Run"""
+
+    agent_id: str
+    """The unique identifier of the agent associated with the run."""
+
+    background: Optional[bool] = None
+    """Whether the run was created in background mode."""
+
+    base_template_id: Optional[str] = None
+    """The base template ID that the run belongs to."""
+
+    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 run completes."""
+
+    completed_at: Optional[datetime] = None
+    """The timestamp when the run was completed."""
+
+    conversation_id: Optional[str] = None
+    """The unique identifier of the conversation associated with the run."""
+
+    created_at: Optional[datetime] = None
+    """The timestamp when the run was created."""
+
+    metadata: Optional[Dict[str, object]] = None
+    """Additional metadata for the run."""
+
+    request_config: Optional[RequestConfig] = None
+    """The request configuration for the run."""
+
+    status: Optional[Literal["created", "running", "completed", "failed", "cancelled"]] = None
+    """The current status of the run."""
+
+    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"""

letta_client/types/agents/summary_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__ = ["SummaryMessage"]
+
+
+class SummaryMessage(BaseModel):
+    """A message representing a summary of the conversation.
+
+    Sent to the LLM as a user or system message depending on the provider.
+    """
+
+    id: str
+
+    date: datetime
+
+    summary: str
+
+    is_err: Optional[bool] = None
+
+    message_type: Optional[Literal["summary"]] = None
+
+    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