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

letta_client/types/step_list_params.py

@@ -0,0 +1,57 @@
+# 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__ = ["StepListParams"]
+
+
+class StepListParams(TypedDict, total=False):
+    after: Optional[str]
+    """Return steps after this step ID"""
+
+    agent_id: Optional[str]
+    """Filter by the ID of the agent that performed the step"""
+
+    before: Optional[str]
+    """Return steps before this step ID"""
+
+    end_date: Optional[str]
+    """Return steps before this ISO datetime (e.g. "2025-01-29T15:01:19-08:00")"""
+
+    feedback: Optional[Literal["positive", "negative"]]
+    """Filter by feedback"""
+
+    has_feedback: Optional[bool]
+    """Filter by whether steps have feedback (true) or not (false)"""
+
+    limit: Optional[int]
+    """Maximum number of steps to return"""
+
+    model: Optional[str]
+    """Filter by the name of the model used for the step"""
+
+    order: Literal["asc", "desc"]
+    """Sort order for steps by creation time.
+
+    'asc' for oldest first, 'desc' for newest first
+    """
+
+    order_by: Literal["created_at"]
+    """Field to sort by"""
+
+    project_id: Optional[str]
+    """Filter by the project ID that is associated with the step (cloud only)."""
+
+    start_date: Optional[str]
+    """Return steps after this ISO datetime (e.g. "2025-01-29T15:01:19-08:00")"""
+
+    tags: Optional[SequenceNotStr[str]]
+    """Filter by tags"""
+
+    trace_ids: Optional[SequenceNotStr[str]]
+    """Filter by trace ids returned by the server"""

letta_client/types/steps/__init__.py

@@ -0,0 +1,8 @@
+# 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_list_response import MessageListResponse as MessageListResponse
+from .feedback_create_params import FeedbackCreateParams as FeedbackCreateParams
+from .metric_retrieve_response import MetricRetrieveResponse as MetricRetrieveResponse

letta_client/types/steps/feedback_create_params.py

@@ -0,0 +1,18 @@
+# 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__ = ["FeedbackCreateParams"]
+
+
+class FeedbackCreateParams(TypedDict, total=False):
+    feedback: Optional[Literal["positive", "negative"]]
+    """Whether this feedback is positive or negative"""
+
+    tags: Optional[SequenceNotStr[str]]
+    """Feedback tags to add to the step"""

letta_client/types/steps/message_list_params.py

@@ -0,0 +1,34 @@
+# 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
+    """
+
+    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"]
+    """Sort by field"""

letta_client/types/steps/message_list_response.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 ..agents.user_message import UserMessage
+from ..tool_return_message import ToolReturnMessage
+from ..agents.event_message import EventMessage
+from ..agents.system_message import SystemMessage
+from ..agents.summary_message import SummaryMessage
+from ..agents.assistant_message import AssistantMessage
+from ..agents.reasoning_message import ReasoningMessage
+from ..agents.tool_call_message import ToolCallMessage
+from ..agents.approval_request_message import ApprovalRequestMessage
+from ..agents.hidden_reasoning_message import HiddenReasoningMessage
+from ..agents.approval_response_message import ApprovalResponseMessage
+
+__all__ = ["MessageListResponse"]
+
+MessageListResponse: TypeAlias = Annotated[
+    Union[
+        SystemMessage,
+        UserMessage,
+        ReasoningMessage,
+        HiddenReasoningMessage,
+        ToolCallMessage,
+        ToolReturnMessage,
+        AssistantMessage,
+        ApprovalRequestMessage,
+        ApprovalResponseMessage,
+        SummaryMessage,
+        EventMessage,
+    ],
+    PropertyInfo(discriminator="message_type"),
+]

letta_client/types/steps/metric_retrieve_response.py

@@ -0,0 +1,45 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from ..._models import BaseModel
+
+__all__ = ["MetricRetrieveResponse"]
+
+
+class MetricRetrieveResponse(BaseModel):
+    id: str
+    """The id of the step this metric belongs to (matches steps.id)."""
+
+    agent_id: Optional[str] = None
+    """The unique identifier of the agent."""
+
+    base_template_id: Optional[str] = None
+    """The base template ID that the step belongs to (cloud only)."""
+
+    llm_request_ns: Optional[int] = None
+    """Time spent on LLM requests in nanoseconds."""
+
+    llm_request_start_ns: Optional[int] = None
+    """The timestamp of the start of the llm request in nanoseconds."""
+
+    project_id: Optional[str] = None
+    """The project that the step belongs to (cloud only)."""
+
+    provider_id: Optional[str] = None
+    """The unique identifier of the provider."""
+
+    run_id: Optional[str] = None
+    """The unique identifier of the run."""
+
+    step_ns: Optional[int] = None
+    """Total time for the step in nanoseconds."""
+
+    step_start_ns: Optional[int] = None
+    """The timestamp of the start of the step in nanoseconds."""
+
+    template_id: Optional[str] = None
+    """The template ID that the step belongs to (cloud only)."""
+
+    tool_execution_ns: Optional[int] = None
+    """Time spent on tool execution in nanoseconds."""

letta_client/types/stop_reason_type.py

@@ -1,8 +1,20 @@
-# This file was auto-generated by Fern from our API Definition.
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import typing
+from typing_extensions import Literal, TypeAlias
 
-StopReasonType = typing.Union[
-    typing.Literal["end_turn", "error", "invalid_tool_call", "max_steps", "no_tool_call", "tool_rule", "cancelled"],
-    typing.Any,
+__all__ = ["StopReasonType"]
+
+StopReasonType: TypeAlias = Literal[
+    "end_turn",
+    "error",
+    "llm_api_error",
+    "invalid_llm_response",
+    "invalid_tool_call",
+    "max_steps",
+    "max_tokens_exceeded",
+    "no_tool_call",
+    "tool_rule",
+    "cancelled",
+    "requires_approval",
+    "context_window_overflow_in_system_prompt",
 ]

letta_client/types/streamable_http_mcp_server.py

@@ -0,0 +1,32 @@
+# 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__ = ["StreamableHTTPMcpServer"]
+
+
+class StreamableHTTPMcpServer(BaseModel):
+    """A Streamable HTTP MCP server"""
+
+    server_name: str
+    """The name of the MCP server"""
+
+    server_url: str
+    """The URL of the server"""
+
+    id: Optional[str] = None
+    """The human-friendly ID of the Mcp_server"""
+
+    auth_header: Optional[str] = None
+    """The name of the authentication header (e.g., 'Authorization')"""
+
+    auth_token: Optional[str] = None
+    """The authentication token or API key value"""
+
+    custom_headers: Optional[Dict[str, str]] = None
+    """Custom HTTP headers to include with requests"""
+
+    mcp_server_type: Optional[Literal["streamable_http"]] = None

letta_client/types/tag_list_params.py

@@ -0,0 +1,40 @@
+# 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__ = ["TagListParams"]
+
+
+class TagListParams(TypedDict, total=False):
+    after: Optional[str]
+    """Tag cursor for pagination.
+
+    Returns tags that come after this tag in the specified sort order
+    """
+
+    before: Optional[str]
+    """Tag cursor for pagination.
+
+    Returns tags that come before this tag in the specified sort order
+    """
+
+    limit: Optional[int]
+    """Maximum number of tags to return"""
+
+    name: Optional[str]
+    """Filter tags by name"""
+
+    order: Literal["asc", "desc"]
+    """Sort order for tags.
+
+    'asc' for alphabetical order, 'desc' for reverse alphabetical order
+    """
+
+    order_by: Literal["name"]
+    """Field to sort by"""
+
+    query_text: Optional[str]
+    """Filter tags by text search. Deprecated, please use name field instead"""

letta_client/types/tag_list_response.py

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

letta_client/types/template_create_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 Dict, Union, Optional
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
+
+__all__ = ["TemplateCreateParams", "Variant0", "Variant1"]
+
+
+class Variant0(TypedDict, total=False):
+    agent_id: Required[str]
+    """The ID of the agent to use as a template, can be from any project"""
+
+    type: Required[Literal["agent"]]
+
+    name: str
+    """Optional custom name for the template.
+
+    If not provided, a random name will be generated.
+    """
+
+
+class Variant1(TypedDict, total=False):
+    agent_file: Required[Dict[str, Optional[object]]]
+    """
+    The agent file to use as a template, this should be a JSON file exported from
+    the platform
+    """
+
+    type: Required[Literal["agent_file"]]
+
+    name: str
+    """Optional custom name for the template.
+
+    If not provided, a random name will be generated.
+    """
+
+    update_existing_tools: bool
+    """
+    If true, update existing custom tools source_code and json_schema (source_type
+    cannot be changed)
+    """
+
+
+TemplateCreateParams: TypeAlias = Union[Variant0, Variant1]

letta_client/types/template_create_response.py

@@ -0,0 +1,29 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from .._models import BaseModel
+
+__all__ = ["TemplateCreateResponse"]
+
+
+class TemplateCreateResponse(BaseModel):
+    id: str
+
+    latest_version: str
+    """The latest version of the template"""
+
+    name: str
+    """The exact name of the template"""
+
+    project_id: str
+
+    project_slug: str
+
+    template_deployment_slug: str
+    """The full name of the template, including version and project slug"""
+
+    updated_at: str
+    """When the template was last updated"""
+
+    description: Optional[str] = None

letta_client/types/template_delete_response.py

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

letta_client/types/template_update_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 Dict, Optional
+from typing_extensions import Required, TypedDict
+
+__all__ = ["TemplateUpdateParams"]
+
+
+class TemplateUpdateParams(TypedDict, total=False):
+    agent_file_json: Required[Dict[str, Optional[object]]]
+    """The agent file to update the current template version from"""
+
+    save_existing_changes: bool
+    """
+    If true, Letta will automatically save any changes as a version before updating
+    the template
+    """
+
+    update_existing_tools: bool
+    """
+    If true, update existing custom tools source_code and json_schema (source_type
+    cannot be changed)
+    """

letta_client/types/template_update_response.py

@@ -0,0 +1,13 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from .._models import BaseModel
+
+__all__ = ["TemplateUpdateResponse"]
+
+
+class TemplateUpdateResponse(BaseModel):
+    success: bool
+
+    message: Optional[str] = None

letta_client/types/templates/__init__.py

@@ -0,0 +1,6 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .agent_create_params import AgentCreateParams as AgentCreateParams
+from .agent_create_response import AgentCreateResponse as AgentCreateResponse

letta_client/types/templates/agent_create_params.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__ = ["AgentCreateParams", "InitialMessageSequence"]
+
+
+class AgentCreateParams(TypedDict, total=False):
+    agent_name: str
+    """The name of the agent, optional otherwise a random one will be assigned"""
+
+    identity_ids: SequenceNotStr[str]
+    """The identity ids to assign to the agent"""
+
+    initial_message_sequence: Iterable[InitialMessageSequence]
+    """
+    Set an initial sequence of messages, if not provided, the agent will start with
+    the default message sequence, if an empty array is provided, the agent will
+    start with no messages
+    """
+
+    memory_variables: Dict[str, str]
+    """The memory variables to assign to the agent"""
+
+    tags: SequenceNotStr[str]
+    """The tags to assign to the agent"""
+
+    tool_variables: Dict[str, str]
+    """The tool variables to assign to the agent"""
+
+
+class InitialMessageSequence(TypedDict, total=False):
+    content: Required[str]
+
+    role: Required[Literal["user", "system", "assistant"]]
+
+    batch_item_id: Optional[str]
+
+    group_id: Optional[str]
+
+    name: Optional[str]
+
+    otid: Optional[str]
+
+    sender_id: Optional[str]

letta_client/types/templates/agent_create_response.py

@@ -0,0 +1,20 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+
+from ..._models import BaseModel
+
+__all__ = ["AgentCreateResponse"]
+
+
+class AgentCreateResponse(BaseModel):
+    """Response containing created agent IDs and associated metadata"""
+
+    agent_ids: List[str]
+    """Array of created agent IDs"""
+
+    deployment_id: str
+    """The deployment ID for the created agents"""
+
+    group_id: Optional[str] = None
+    """Optional group ID if agents were created in a group"""

letta_client/types/terminal_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 TerminalToolRule(UncheckedBaseModel):
-    """
-    Represents a terminal tool rule configuration where if this tool gets called, it must end the agent loop.
-    """
+__all__ = ["TerminalToolRule"]
 
-    tool_name: str = pydantic.Field()
-    """
-    The name of the tool. Must exist in the database for the user's organization.
-    """
 
-    type: typing.Literal["exit_loop"] = "exit_loop"
-    prompt_template: typing.Optional[str] = pydantic.Field(default=None)
+class TerminalToolRule(BaseModel):
     """
-    Optional Jinja2 template for generating agent prompt about this tool rule.
+    Represents a terminal tool rule configuration where if this tool gets called, it must end 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["exit_loop"]] = None

letta_client/types/terminal_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__ = ["TerminalToolRuleParam"]
+
+
+class TerminalToolRuleParam(TypedDict, total=False):
+    """
+    Represents a terminal tool rule configuration where if this tool gets called, it must end 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["exit_loop"]

letta_client/types/text_response_format.py

@@ -1,23 +1,15 @@
-# 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 typing
-from ..core.pydantic_utilities import IS_PYDANTIC_V2
-import pydantic
+from typing import Optional
+from typing_extensions import Literal
 
+from .._models import BaseModel
 
-class TextResponseFormat(UncheckedBaseModel):
-    """
-    Response format for plain text responses.
-    """
+__all__ = ["TextResponseFormat"]
 
-    type: typing.Literal["text"] = "text"
 
-    if IS_PYDANTIC_V2:
-        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
-    else:
+class TextResponseFormat(BaseModel):
+    """Response format for plain text responses."""
 
-        class Config:
-            frozen = True
-            smart_union = True
-            extra = pydantic.Extra.allow
+    type: Optional[Literal["text"]] = None
+    """The type of the response format."""

letta_client/types/text_response_format_param.py

@@ -0,0 +1,14 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, TypedDict
+
+__all__ = ["TextResponseFormatParam"]
+
+
+class TextResponseFormatParam(TypedDict, total=False):
+    """Response format for plain text responses."""
+
+    type: Literal["text"]
+    """The type of the response format."""