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

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,19 +1,18 @@
-# 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",
-        "llm_api_error",
-        "invalid_llm_response",
-        "invalid_tool_call",
-        "max_steps",
-        "no_tool_call",
-        "tool_rule",
-        "cancelled",
-        "requires_approval",
-    ],
-    typing.Any,
+__all__ = ["StopReasonType"]
+
+StopReasonType: TypeAlias = Literal[
+    "end_turn",
+    "error",
+    "llm_api_error",
+    "invalid_llm_response",
+    "invalid_tool_call",
+    "max_steps",
+    "no_tool_call",
+    "tool_rule",
+    "cancelled",
+    "requires_approval",
 ]

letta_client/types/supervisor_manager_param.py

@@ -0,0 +1,13 @@
+# 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__ = ["SupervisorManagerParam"]
+
+
+class SupervisorManagerParam(TypedDict, total=False):
+    manager_agent_id: Required[str]
+
+    manager_type: Literal["supervisor"]

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/templates/__init__.py

@@ -0,0 +1,5 @@
+# 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

letta_client/types/templates/agent_create_params.py

@@ -0,0 +1,52 @@
+# 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):
+    project_id: Required[str]
+
+    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/terminal_tool_rule.py

@@ -1,33 +1,18 @@
-# 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 import Optional
+from typing_extensions import Literal
 
-import pydantic
-from ..core.pydantic_utilities import IS_PYDANTIC_V2
-from ..core.unchecked_base_model import UncheckedBaseModel
+from .._models import BaseModel
 
+__all__ = ["TerminalToolRule"]
 
-class TerminalToolRule(UncheckedBaseModel):
-    """
-    Represents a terminal tool rule configuration where if this tool gets called, it must end the agent loop.
-    """
 
-    tool_name: str = pydantic.Field()
-    """
-    The name of the tool. Must exist in the database for the user's organization.
-    """
+class TerminalToolRule(BaseModel):
+    tool_name: str
+    """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)
-    """
-    Optional template string (ignored).
-    """
+    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:
-
-        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,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, Required, TypedDict
+
+__all__ = ["TerminalToolRuleParam"]
+
+
+class TerminalToolRuleParam(TypedDict, total=False):
+    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,24 +1,13 @@
-# 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 import Optional
+from typing_extensions import Literal
 
-import pydantic
-from ..core.pydantic_utilities import IS_PYDANTIC_V2
-from ..core.unchecked_base_model import UncheckedBaseModel
+from .._models import BaseModel
 
+__all__ = ["TextResponseFormat"]
 
-class TextResponseFormat(UncheckedBaseModel):
-    """
-    Response format for plain text responses.
-    """
 
-    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 Config:
-            frozen = True
-            smart_union = True
-            extra = pydantic.Extra.allow
+class TextResponseFormat(BaseModel):
+    type: Optional[Literal["text"]] = None
+    """The type of the response format."""

letta_client/types/text_response_format_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__ = ["TextResponseFormatParam"]
+
+
+class TextResponseFormatParam(TypedDict, total=False):
+    type: Literal["text"]
+    """The type of the response format."""

letta_client/types/tool.py

@@ -1,121 +1,68 @@
-# 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 import Dict, List, Optional
 
-import pydantic
-import typing_extensions
-from ..core.pydantic_utilities import IS_PYDANTIC_V2
-from ..core.serialization import FieldMetadata
-from ..core.unchecked_base_model import UncheckedBaseModel
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+from .tool_type import ToolType
 from .npm_requirement import NpmRequirement
 from .pip_requirement import PipRequirement
-from .tool_type import ToolType
 
+__all__ = ["Tool"]
 
-class Tool(UncheckedBaseModel):
-    """
-    Representation of a tool, which is a function that can be called by the agent.
-
-    Parameters:
-        id (str): The unique identifier of the tool.
-        name (str): The name of the function.
-        tags (List[str]): Metadata tags.
-        source_code (str): The source code of the function.
-        json_schema (Dict): The JSON schema of the function.
-    """
 
-    id: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    The human-friendly ID of the Tool
-    """
+class Tool(BaseModel):
+    id: Optional[str] = None
+    """The human-friendly ID of the Tool"""
 
-    tool_type: typing.Optional[ToolType] = pydantic.Field(default=None)
-    """
-    The type of the tool.
-    """
+    args_json_schema: Optional[Dict[str, object]] = None
+    """The args JSON schema of the function."""
 
-    description: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    The description of the tool.
-    """
+    created_by_id: Optional[str] = None
+    """The id of the user that made this Tool."""
 
-    source_type: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    The type of the source code.
-    """
+    default_requires_approval: Optional[bool] = None
+    """Default value for whether or not executing this tool requires approval."""
 
-    name: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    The name of the function.
-    """
+    description: Optional[str] = None
+    """The description of the tool."""
 
-    tags: typing.Optional[typing.List[str]] = pydantic.Field(default=None)
+    enable_parallel_execution: Optional[bool] = None
     """
-    Metadata tags.
+    If set to True, then this tool will potentially be executed concurrently with
+    other tools. Default False.
     """
 
-    source_code: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    The source code of the function.
-    """
+    json_schema: Optional[Dict[str, object]] = None
+    """The JSON schema of the function."""
 
-    json_schema: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] = pydantic.Field(default=None)
-    """
-    The JSON schema of the function.
-    """
+    last_updated_by_id: Optional[str] = None
+    """The id of the user that made this Tool."""
 
-    args_json_schema: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] = pydantic.Field(default=None)
-    """
-    The args JSON schema of the function.
-    """
+    metadata: Optional[Dict[str, object]] = FieldInfo(alias="metadata_", default=None)
+    """A dictionary of additional metadata for the tool."""
 
-    return_char_limit: typing.Optional[int] = pydantic.Field(default=None)
-    """
-    The maximum number of characters in the response.
-    """
+    name: Optional[str] = None
+    """The name of the function."""
 
-    pip_requirements: typing.Optional[typing.List[PipRequirement]] = pydantic.Field(default=None)
-    """
-    Optional list of pip packages required by this tool.
-    """
+    npm_requirements: Optional[List[NpmRequirement]] = None
+    """Optional list of npm packages required by this tool."""
 
-    npm_requirements: typing.Optional[typing.List[NpmRequirement]] = pydantic.Field(default=None)
-    """
-    Optional list of npm packages required by this tool.
-    """
+    pip_requirements: Optional[List[PipRequirement]] = None
+    """Optional list of pip packages required by this tool."""
 
-    default_requires_approval: typing.Optional[bool] = pydantic.Field(default=None)
-    """
-    Default value for whether or not executing this tool requires approval.
-    """
+    return_char_limit: Optional[int] = None
+    """The maximum number of characters in the response."""
 
-    enable_parallel_execution: typing.Optional[bool] = pydantic.Field(default=None)
-    """
-    If set to True, then this tool will potentially be executed concurrently with other tools. Default False.
-    """
+    source_code: Optional[str] = None
+    """The source code of the function."""
 
-    created_by_id: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    The id of the user that made this Tool.
-    """
-
-    last_updated_by_id: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    The id of the user that made this Tool.
-    """
-
-    metadata: typing_extensions.Annotated[
-        typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]], FieldMetadata(alias="metadata_")
-    ] = pydantic.Field(default=None)
-    """
-    A dictionary of additional metadata for the tool.
-    """
+    source_type: Optional[str] = None
+    """The type of the source code."""
 
-    if IS_PYDANTIC_V2:
-        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
-    else:
+    tags: Optional[List[str]] = None
+    """Metadata tags."""
 
-        class Config:
-            frozen = True
-            smart_union = True
-            extra = pydantic.Extra.allow
+    tool_type: Optional[ToolType] = None
+    """The type of the tool."""

letta_client/types/tool_count_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 Optional
+from typing_extensions import TypedDict
+
+from .._types import SequenceNotStr
+
+__all__ = ["ToolCountParams"]
+
+
+class ToolCountParams(TypedDict, total=False):
+    exclude_letta_tools: Optional[bool]
+    """Exclude built-in Letta tools from the count"""
+
+    exclude_tool_types: Optional[SequenceNotStr[str]]
+    """Tool type(s) to exclude - accepts repeated params or comma-separated values"""
+
+    name: Optional[str]
+
+    names: Optional[SequenceNotStr[str]]
+    """Filter by specific tool names"""
+
+    return_only_letta_tools: Optional[bool]
+    """Count only tools with tool*type starting with 'letta*'"""
+
+    search: Optional[str]
+    """Search tool names (case-insensitive partial match)"""
+
+    tool_ids: Optional[SequenceNotStr[str]]
+    """Filter by specific tool IDs - accepts repeated params or comma-separated values"""
+
+    tool_types: Optional[SequenceNotStr[str]]
+    """Filter by tool type(s) - accepts repeated params or comma-separated values"""

letta_client/types/tool_count_response.py

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

letta_client/types/tool_create_params.py

@@ -0,0 +1,53 @@
+# 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 Required, TypedDict
+
+from .._types import SequenceNotStr
+from .npm_requirement_param import NpmRequirementParam
+from .pip_requirement_param import PipRequirementParam
+
+__all__ = ["ToolCreateParams"]
+
+
+class ToolCreateParams(TypedDict, total=False):
+    source_code: Required[str]
+    """The source code of the function."""
+
+    args_json_schema: Optional[Dict[str, object]]
+    """The args JSON schema of the function."""
+
+    default_requires_approval: Optional[bool]
+    """Whether or not to require approval before executing this tool."""
+
+    description: Optional[str]
+    """The description of the tool."""
+
+    enable_parallel_execution: Optional[bool]
+    """
+    If set to True, then this tool will potentially be executed concurrently with
+    other tools. Default False.
+    """
+
+    json_schema: Optional[Dict[str, object]]
+    """
+    The JSON schema of the function (auto-generated from source_code if not
+    provided)
+    """
+
+    npm_requirements: Optional[Iterable[NpmRequirementParam]]
+    """Optional list of npm packages required by this tool."""
+
+    pip_requirements: Optional[Iterable[PipRequirementParam]]
+    """Optional list of pip packages required by this tool."""
+
+    return_char_limit: int
+    """The maximum number of characters in the response."""
+
+    source_type: str
+    """The source type of the function."""
+
+    tags: Optional[SequenceNotStr[str]]
+    """Metadata tags."""

letta_client/types/tool_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__ = ["ToolListParams"]
+
+
+class ToolListParams(TypedDict, total=False):
+    after: Optional[str]
+    """Tool ID cursor for pagination.
+
+    Returns tools that come after this tool ID in the specified sort order
+    """
+
+    before: Optional[str]
+    """Tool ID cursor for pagination.
+
+    Returns tools that come before this tool ID in the specified sort order
+    """
+
+    exclude_tool_types: Optional[SequenceNotStr[str]]
+    """Tool type(s) to exclude - accepts repeated params or comma-separated values"""
+
+    limit: Optional[int]
+    """Maximum number of tools to return"""
+
+    name: Optional[str]
+    """Filter by single tool name"""
+
+    names: Optional[SequenceNotStr[str]]
+    """Filter by specific tool names"""
+
+    order: Literal["asc", "desc"]
+    """Sort order for tools by creation time.
+
+    'asc' for oldest first, 'desc' for newest first
+    """
+
+    order_by: Literal["created_at"]
+    """Field to sort by"""
+
+    return_only_letta_tools: Optional[bool]
+    """Return only tools with tool*type starting with 'letta*'"""
+
+    search: Optional[str]
+    """Search tool names (case-insensitive partial match)"""
+
+    tool_ids: Optional[SequenceNotStr[str]]
+    """Filter by specific tool IDs - accepts repeated params or comma-separated values"""
+
+    tool_types: Optional[SequenceNotStr[str]]
+    """Filter by tool type(s) - accepts repeated params or comma-separated values"""

letta_client/types/tool_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 .tool import Tool
+
+__all__ = ["ToolListResponse"]
+
+ToolListResponse: TypeAlias = List[Tool]