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

letta_client/types/agents/internal_message.py

@@ -0,0 +1,271 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import TYPE_CHECKING, Dict, List, Union, Optional
+from datetime import datetime
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from pydantic import Field as FieldInfo
+
+from ..._utils import PropertyInfo
+from ..._models import BaseModel
+from .message_role import MessageRole
+from .text_content import TextContent
+from .image_content import ImageContent
+from .approval_return import ApprovalReturn
+from .reasoning_content import ReasoningContent
+from .tool_call_content import ToolCallContent
+from .tool_return_content import ToolReturnContent
+from .omitted_reasoning_content import OmittedReasoningContent
+from .redacted_reasoning_content import RedactedReasoningContent
+
+__all__ = [
+    "InternalMessage",
+    "Approval",
+    "ApprovalLettaSchemasMessageToolReturnOutput",
+    "ApprovalLettaSchemasMessageToolReturnOutputFuncResponseUnionMember1",
+    "Content",
+    "ContentSummarizedReasoningContent",
+    "ContentSummarizedReasoningContentSummary",
+    "ToolCall",
+    "ToolCallFunction",
+    "ToolReturn",
+    "ToolReturnFuncResponseUnionMember1",
+]
+
+ApprovalLettaSchemasMessageToolReturnOutputFuncResponseUnionMember1: TypeAlias = Annotated[
+    Union[TextContent, ImageContent], PropertyInfo(discriminator="type")
+]
+
+
+class ApprovalLettaSchemasMessageToolReturnOutput(BaseModel):
+    status: Literal["success", "error"]
+    """The status of the tool call"""
+
+    func_response: Union[str, List[ApprovalLettaSchemasMessageToolReturnOutputFuncResponseUnionMember1], None] = None
+    """The function response - either a string or list of content parts (text/image)"""
+
+    stderr: Optional[List[str]] = None
+    """Captured stderr from the tool invocation"""
+
+    stdout: Optional[List[str]] = None
+    """Captured stdout (e.g. prints, logs) from the tool invocation"""
+
+    tool_call_id: Optional[object] = None
+    """The ID for the tool call"""
+
+
+Approval: TypeAlias = Union[ApprovalReturn, ApprovalLettaSchemasMessageToolReturnOutput]
+
+
+class ContentSummarizedReasoningContentSummary(BaseModel):
+    index: int
+    """The index of the summary part."""
+
+    text: str
+    """The text of the summary part."""
+
+
+class ContentSummarizedReasoningContent(BaseModel):
+    """The style of reasoning content returned by the OpenAI Responses API"""
+
+    id: str
+    """The unique identifier for this reasoning step."""
+
+    summary: List[ContentSummarizedReasoningContentSummary]
+    """Summaries of the reasoning content."""
+
+    encrypted_content: Optional[str] = None
+    """The encrypted reasoning content."""
+
+    type: Optional[Literal["summarized_reasoning"]] = None
+    """Indicates this is a summarized reasoning step."""
+
+
+Content: TypeAlias = Annotated[
+    Union[
+        TextContent,
+        ImageContent,
+        ToolCallContent,
+        ToolReturnContent,
+        ReasoningContent,
+        RedactedReasoningContent,
+        OmittedReasoningContent,
+        ContentSummarizedReasoningContent,
+    ],
+    PropertyInfo(discriminator="type"),
+]
+
+
+class ToolCallFunction(BaseModel):
+    """The function that the model called."""
+
+    arguments: str
+
+    name: str
+
+    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 ToolCall(BaseModel):
+    """A call to a function tool created by the model."""
+
+    id: str
+
+    function: ToolCallFunction
+    """The function that the model called."""
+
+    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]
+
+
+ToolReturnFuncResponseUnionMember1: TypeAlias = Annotated[
+    Union[TextContent, ImageContent], PropertyInfo(discriminator="type")
+]
+
+
+class ToolReturn(BaseModel):
+    status: Literal["success", "error"]
+    """The status of the tool call"""
+
+    func_response: Union[str, List[ToolReturnFuncResponseUnionMember1], None] = None
+    """The function response - either a string or list of content parts (text/image)"""
+
+    stderr: Optional[List[str]] = None
+    """Captured stderr from the tool invocation"""
+
+    stdout: Optional[List[str]] = None
+    """Captured stdout (e.g. prints, logs) from the tool invocation"""
+
+    tool_call_id: Optional[object] = None
+    """The ID for the tool call"""
+
+
+class InternalMessage(BaseModel):
+    """Letta's internal representation of a message.
+
+    Includes methods to convert to/from LLM provider formats.
+
+        Attributes:
+            id (str): The unique identifier of the message.
+            role (MessageRole): The role of the participant.
+            text (str): The text of the message.
+            user_id (str): The unique identifier of the user.
+            agent_id (str): The unique identifier of the agent.
+            model (str): The model used to make the function call.
+            name (str): The name of the participant.
+            created_at (datetime): The time the message was created.
+            tool_calls (List[OpenAIToolCall,]): The list of tool calls requested.
+            tool_call_id (str): The id of the tool call.
+            step_id (str): The id of the step that this message was created in.
+            otid (str): The offline threading id associated with this message.
+            tool_returns (List[ToolReturn]): The list of tool returns requested.
+            group_id (str): The multi-agent group that the message was sent in.
+            sender_id (str): The id of the sender of the message, can be an identity id or agent id.
+            conversation_id (str): The conversation this message belongs to.
+    t
+    """
+
+    id: str
+    """The human-friendly ID of the Message"""
+
+    role: MessageRole
+    """The role of the participant."""
+
+    agent_id: Optional[str] = None
+    """The unique identifier of the agent."""
+
+    approval_request_id: Optional[str] = None
+    """
+    The id of the approval request if this message is associated with a tool call
+    request.
+    """
+
+    approvals: Optional[List[Approval]] = None
+    """The list of approvals for this message."""
+
+    approve: Optional[bool] = None
+    """Whether tool call is approved."""
+
+    batch_item_id: Optional[str] = None
+    """The id of the LLMBatchItem that this message is associated with"""
+
+    content: Optional[List[Content]] = None
+    """The content of the message."""
+
+    conversation_id: Optional[str] = None
+    """The conversation this message 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."""
+
+    denial_reason: Optional[str] = None
+    """The reason the tool call request was denied."""
+
+    group_id: Optional[str] = None
+    """The multi-agent group that the message was sent in"""
+
+    is_err: Optional[bool] = None
+    """Whether this message is part of an error step.
+
+    Used only for debugging purposes.
+    """
+
+    last_updated_by_id: Optional[str] = None
+    """The id of the user that made this object."""
+
+    model: Optional[str] = None
+    """The model used to make the function call."""
+
+    name: Optional[str] = None
+    """For role user/assistant: the (optional) name of the participant.
+
+    For role tool/function: the name of the function called.
+    """
+
+    otid: Optional[str] = None
+    """The offline threading id associated with this message"""
+
+    run_id: Optional[str] = None
+    """The id of the run that this message was created in."""
+
+    sender_id: Optional[str] = None
+    """The id of the sender of the message, can be an identity id or agent id"""
+
+    step_id: Optional[str] = None
+    """The id of the step that this message was created in."""
+
+    tool_call_id: Optional[str] = None
+    """The ID of the tool call. Only applicable for role tool."""
+
+    tool_calls: Optional[List[ToolCall]] = None
+    """The list of tool calls requested. Only applicable for role assistant."""
+
+    tool_returns: Optional[List[ToolReturn]] = None
+    """Tool execution return information for prior tool calls"""
+
+    updated_at: Optional[datetime] = None
+    """The timestamp when the object was last updated."""

letta_client/types/agents/job_status.py

@@ -0,0 +1,7 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal, TypeAlias
+
+__all__ = ["JobStatus"]
+
+JobStatus: TypeAlias = Literal["created", "running", "completed", "failed", "pending", "cancelled", "expired"]

letta_client/types/agents/job_type.py

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

letta_client/types/agents/letta_assistant_message_content_union.py

@@ -0,0 +1,19 @@
+# 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__ = ["LettaAssistantMessageContentUnion"]
+
+
+class LettaAssistantMessageContentUnion(BaseModel):
+    text: str
+    """The text content of the message."""
+
+    signature: Optional[str] = None
+    """Stores a unique identifier for any reasoning associated with this text content."""
+
+    type: Optional[Literal["text"]] = None
+    """The type of the message."""

letta_client/types/agents/letta_response.py

@@ -0,0 +1,76 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from typing_extensions import Literal
+
+from .message import Message
+from ..._models import BaseModel
+from ..stop_reason_type import StopReasonType
+
+__all__ = ["LettaResponse", "StopReason", "Usage"]
+
+
+class StopReason(BaseModel):
+    """The stop reason from Letta indicating why agent loop stopped execution."""
+
+    stop_reason: StopReasonType
+    """The reason why execution stopped."""
+
+    message_type: Optional[Literal["stop_reason"]] = None
+    """The type of the message."""
+
+
+class Usage(BaseModel):
+    """The usage statistics of the agent."""
+
+    cache_write_tokens: Optional[int] = None
+    """The number of input tokens written to cache (Anthropic only).
+
+    None if not reported by provider.
+    """
+
+    cached_input_tokens: Optional[int] = None
+    """The number of input tokens served from cache. None if not reported by provider."""
+
+    completion_tokens: Optional[int] = None
+    """The number of tokens generated by the agent."""
+
+    message_type: Optional[Literal["usage_statistics"]] = None
+
+    prompt_tokens: Optional[int] = None
+    """The number of tokens in the prompt."""
+
+    reasoning_tokens: Optional[int] = None
+    """The number of reasoning/thinking tokens generated.
+
+    None if not reported by provider.
+    """
+
+    run_ids: Optional[List[str]] = None
+    """The background task run IDs associated with the agent interaction"""
+
+    step_count: Optional[int] = None
+    """The number of steps taken by the agent."""
+
+    total_tokens: Optional[int] = None
+    """The total number of tokens processed by the agent."""
+
+
+class LettaResponse(BaseModel):
+    """
+    Response object from an agent interaction, consisting of the new messages generated by the agent and usage statistics.
+    The type of the returned messages can be either `Message` or `LettaMessage`, depending on what was specified in the request.
+
+    Attributes:
+        messages (List[Union[Message, LettaMessage]]): The messages returned by the agent.
+        usage (LettaUsageStatistics): The usage statistics
+    """
+
+    messages: List[Message]
+    """The messages returned by the agent."""
+
+    stop_reason: StopReason
+    """The stop reason from Letta indicating why agent loop stopped execution."""
+
+    usage: Usage
+    """The usage statistics of the agent."""

letta_client/types/agents/letta_streaming_response.py

@@ -0,0 +1,155 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Union, Optional
+from datetime import datetime
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from ..._utils import PropertyInfo
+from ..._models import BaseModel
+from .user_message import UserMessage
+from .system_message import SystemMessage
+from ..stop_reason_type import StopReasonType
+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__ = ["LettaStreamingResponse", "LettaPing", "LettaErrorMessage", "LettaStopReason", "LettaUsageStatistics"]
+
+
+class LettaPing(BaseModel):
+    """
+    A ping message used as a keepalive to prevent SSE streams from timing out during long running requests.
+
+    Args:
+        id (str): The ID of the message
+        date (datetime): The date the message was created in ISO format
+    """
+
+    id: str
+
+    date: datetime
+
+    is_err: Optional[bool] = None
+
+    message_type: Optional[Literal["ping"]] = None
+    """The type of the message.
+
+    Ping messages are a keep-alive to prevent SSE streams from timing out during
+    long running requests.
+    """
+
+    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
+
+
+class LettaErrorMessage(BaseModel):
+    """
+    Error messages are used to notify the client of an error that occurred during the agent's execution.
+    """
+
+    error_type: str
+    """The type of error."""
+
+    message: str
+    """The error message."""
+
+    message_type: Literal["error_message"]
+    """The type of the message."""
+
+    run_id: str
+    """The ID of the run."""
+
+    detail: Optional[str] = None
+    """An optional error detail."""
+
+    seq_id: Optional[int] = None
+    """The sequence ID for cursor-based pagination."""
+
+
+class LettaStopReason(BaseModel):
+    """The stop reason from Letta indicating why agent loop stopped execution."""
+
+    stop_reason: StopReasonType
+    """The reason why execution stopped."""
+
+    message_type: Optional[Literal["stop_reason"]] = None
+    """The type of the message."""
+
+
+class LettaUsageStatistics(BaseModel):
+    """Usage statistics for the agent interaction.
+
+    Attributes:
+        completion_tokens (int): The number of tokens generated by the agent.
+        prompt_tokens (int): The number of tokens in the prompt.
+        total_tokens (int): The total number of tokens processed by the agent.
+        step_count (int): The number of steps taken by the agent.
+        cached_input_tokens (Optional[int]): The number of input tokens served from cache. None if not reported.
+        cache_write_tokens (Optional[int]): The number of input tokens written to cache. None if not reported.
+        reasoning_tokens (Optional[int]): The number of reasoning/thinking tokens generated. None if not reported.
+    """
+
+    cache_write_tokens: Optional[int] = None
+    """The number of input tokens written to cache (Anthropic only).
+
+    None if not reported by provider.
+    """
+
+    cached_input_tokens: Optional[int] = None
+    """The number of input tokens served from cache. None if not reported by provider."""
+
+    completion_tokens: Optional[int] = None
+    """The number of tokens generated by the agent."""
+
+    message_type: Optional[Literal["usage_statistics"]] = None
+
+    prompt_tokens: Optional[int] = None
+    """The number of tokens in the prompt."""
+
+    reasoning_tokens: Optional[int] = None
+    """The number of reasoning/thinking tokens generated.
+
+    None if not reported by provider.
+    """
+
+    run_ids: Optional[List[str]] = None
+    """The background task run IDs associated with the agent interaction"""
+
+    step_count: Optional[int] = None
+    """The number of steps taken by the agent."""
+
+    total_tokens: Optional[int] = None
+    """The total number of tokens processed by the agent."""
+
+
+LettaStreamingResponse: TypeAlias = Annotated[
+    Union[
+        SystemMessage,
+        UserMessage,
+        ReasoningMessage,
+        HiddenReasoningMessage,
+        ToolCallMessage,
+        ToolReturnMessage,
+        AssistantMessage,
+        ApprovalRequestMessage,
+        ApprovalResponseMessage,
+        LettaPing,
+        LettaErrorMessage,
+        LettaStopReason,
+        LettaUsageStatistics,
+    ],
+    PropertyInfo(discriminator="message_type"),
+]

letta_client/types/agents/letta_user_message_content_union.py

@@ -0,0 +1,14 @@
+# 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 .text_content import TextContent
+from .image_content import ImageContent
+
+__all__ = ["LettaUserMessageContentUnion"]
+
+LettaUserMessageContentUnion: TypeAlias = Annotated[
+    Union[TextContent, ImageContent], PropertyInfo(discriminator="type")
+]

letta_client/types/agents/message.py

@@ -0,0 +1,36 @@
+# 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 .event_message import EventMessage
+from .system_message import SystemMessage
+from .summary_message import SummaryMessage
+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__ = ["Message"]
+
+Message: TypeAlias = Annotated[
+    Union[
+        SystemMessage,
+        UserMessage,
+        ReasoningMessage,
+        HiddenReasoningMessage,
+        ToolCallMessage,
+        ToolReturnMessage,
+        AssistantMessage,
+        ApprovalRequestMessage,
+        ApprovalResponseMessage,
+        SummaryMessage,
+        EventMessage,
+    ],
+    PropertyInfo(discriminator="message_type"),
+]

letta_client/types/agents/message_cancel_params.py

@@ -0,0 +1,15 @@
+# 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__ = ["MessageCancelParams"]
+
+
+class MessageCancelParams(TypedDict, total=False):
+    run_ids: Optional[SequenceNotStr[str]]
+    """Optional list of run IDs to cancel"""

letta_client/types/agents/message_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__ = ["MessageCancelResponse"]
+
+MessageCancelResponse: TypeAlias = Dict[str, object]