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

letta_client/types/together_model_settings.py

@@ -0,0 +1,36 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union, Optional
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from .._utils import PropertyInfo
+from .._models import BaseModel
+from .text_response_format import TextResponseFormat
+from .json_object_response_format import JsonObjectResponseFormat
+from .json_schema_response_format import JsonSchemaResponseFormat
+
+__all__ = ["TogetherModelSettings", "ResponseFormat"]
+
+ResponseFormat: TypeAlias = Annotated[
+    Union[TextResponseFormat, JsonSchemaResponseFormat, JsonObjectResponseFormat, None],
+    PropertyInfo(discriminator="type"),
+]
+
+
+class TogetherModelSettings(BaseModel):
+    """Together AI model configuration (OpenAI-compatible)."""
+
+    max_output_tokens: Optional[int] = None
+    """The maximum number of tokens the model can generate."""
+
+    parallel_tool_calls: Optional[bool] = None
+    """Whether to enable parallel tool calling."""
+
+    provider_type: Optional[Literal["together"]] = None
+    """The type of the provider."""
+
+    response_format: Optional[ResponseFormat] = None
+    """The response format for the model."""
+
+    temperature: Optional[float] = None
+    """The temperature of the model."""

letta_client/types/together_model_settings_param.py

@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union, Optional
+from typing_extensions import Literal, TypeAlias, TypedDict
+
+from .text_response_format_param import TextResponseFormatParam
+from .json_object_response_format_param import JsonObjectResponseFormatParam
+from .json_schema_response_format_param import JsonSchemaResponseFormatParam
+
+__all__ = ["TogetherModelSettingsParam", "ResponseFormat"]
+
+ResponseFormat: TypeAlias = Union[TextResponseFormatParam, JsonSchemaResponseFormatParam, JsonObjectResponseFormatParam]
+
+
+class TogetherModelSettingsParam(TypedDict, total=False):
+    """Together AI model configuration (OpenAI-compatible)."""
+
+    max_output_tokens: int
+    """The maximum number of tokens the model can generate."""
+
+    parallel_tool_calls: bool
+    """Whether to enable parallel tool calling."""
+
+    provider_type: Literal["together"]
+    """The type of the provider."""
+
+    response_format: Optional[ResponseFormat]
+    """The response format for the model."""
+
+    temperature: float
+    """The temperature of the model."""

letta_client/types/tool.py

@@ -1,104 +1,177 @@
-# 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
-import pydantic
+import inspect
+from abc import abstractmethod
+from typing import Dict, List, Optional
+from textwrap import dedent
+
+from pydantic import Field, Field as FieldInfo
+
+from .._models import BaseModel
 from .tool_type import ToolType
+from .npm_requirement import NpmRequirement
 from .pip_requirement import PipRequirement
-import typing_extensions
-from ..core.serialization import FieldMetadata
-from ..core.pydantic_utilities import IS_PYDANTIC_V2
 
+__all__ = ["Tool", "BaseTool"]
 
-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):
+    """Representation of a tool, which is a function that can be called by the agent."""
 
-    tool_type: typing.Optional[ToolType] = pydantic.Field(default=None)
-    """
-    The type of the tool.
-    """
+    id: str
+    """The human-friendly ID of the Tool"""
 
-    description: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    The description of the tool.
-    """
+    args_json_schema: Optional[Dict[str, object]] = None
+    """The args JSON schema of the function."""
 
-    source_type: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    The type of the source code.
-    """
+    created_by_id: Optional[str] = None
+    """The id of the user that made this Tool."""
 
-    name: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    The name of the function.
-    """
+    default_requires_approval: Optional[bool] = None
+    """Default value for whether or not executing this tool requires approval."""
 
-    tags: typing.Optional[typing.List[str]] = pydantic.Field(default=None)
-    """
-    Metadata tags.
-    """
+    description: Optional[str] = None
+    """The description of the tool."""
 
-    source_code: typing.Optional[str] = pydantic.Field(default=None)
+    enable_parallel_execution: Optional[bool] = None
     """
-    The source code of the function.
+    If set to True, then this tool will potentially be executed concurrently with
+    other tools. Default False.
     """
 
-    json_schema: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] = pydantic.Field(default=None)
-    """
-    The JSON schema of the function.
-    """
+    json_schema: Optional[Dict[str, object]] = None
+    """The JSON schema of the function."""
 
-    args_json_schema: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] = pydantic.Field(default=None)
-    """
-    The args JSON schema of the function.
-    """
+    last_updated_by_id: Optional[str] = None
+    """The id of the user that made this Tool."""
 
-    return_char_limit: typing.Optional[int] = pydantic.Field(default=None)
-    """
-    The maximum number of characters in the response.
-    """
+    metadata: Optional[Dict[str, object]] = FieldInfo(alias="metadata_", default=None)
+    """A dictionary of additional metadata for the tool."""
 
-    pip_requirements: typing.Optional[typing.List[PipRequirement]] = pydantic.Field(default=None)
-    """
-    Optional list of pip packages required by this tool.
-    """
+    name: Optional[str] = None
+    """The name of the function."""
 
-    created_by_id: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    The id of the user that made this Tool.
-    """
+    npm_requirements: Optional[List[NpmRequirement]] = None
+    """Optional list of npm packages required by 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.
-    """
+    pip_requirements: Optional[List[PipRequirement]] = None
+    """Optional list of pip packages required by this tool."""
 
-    if IS_PYDANTIC_V2:
-        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
-    else:
+    project_id: Optional[str] = None
+    """The project id of the tool."""
 
-        class Config:
-            frozen = True
-            smart_union = True
-            extra = pydantic.Extra.allow
+    return_char_limit: Optional[int] = None
+    """The maximum number of characters in the response."""
+
+    source_code: Optional[str] = None
+    """The source code of the function."""
+
+    source_type: Optional[str] = None
+    """The type of the source code."""
+
+    tags: Optional[List[str]] = None
+    """Metadata tags."""
+
+    tool_type: Optional[ToolType] = None
+    """The type of the tool."""
+
+
+class BaseTool(Tool):
+    name: Optional[str] = Field(default=None, description="The name of the function.")
+    args_schema: typing.Optional[typing.Type[BaseModel]] = Field(default=None, description="The schema for validating the tool's arguments.")
+
+    @abstractmethod
+    def run(self, *args: typing.Any, **kwargs: typing.Any) -> typing.Any:
+        """
+        Execute the tool with the provided arguments.
+
+        Parameters
+        ----------
+        self
+            The instance of the tool
+        *args
+            Positional arguments to pass to the tool.
+        **kwargs
+            Keyword arguments to pass to the tool.
+
+        Returns
+        -------
+        typing.Any
+            The result of executing the tool.
+        """
+        pass
+
+
+    # @model_validator(mode="after")
+    # def no_self_in_run_source(self) -> "BaseTool":
+    #     """
+    #     Validate that the provided implementation does not reference `self` in the
+    #     `run` method implementation.
+
+    #     This check is performed after the model is created, so `self` is guaranteed
+    #     to be set.
+
+    #     If `self` is found in the source code of the `run` method, a `ValueError` is
+    #     raised with a message pointing to the line and value of the offending code.
+    #     """
+    #     source_code = self.get_source_code()
+    #     if "self." in source_code:
+    #         raise_on_line, line_value = None, None
+    #         for i, line in enumerate(source_code.splitlines()):
+    #             if "self." in line:
+    #                 raise_on_line, line_value = i+1, line
+    #                 break;
+    #         raise ValueError(
+    #             f"Detected reference to 'self' in line {raise_on_line} of implementation, " +
+    #             f"which is not allowed:\n\n{line_value}\n\n" +
+    #             f"Please pass in the arguments directly to run() instead.")
+    #     return self
+
+
+    def get_source_code(self) -> str:
+        """
+        Get the source code of the `run` method, which will be executed in an agent step.
+
+        Returns
+        -------
+        str
+            The source code of the tool.
+        """
+        source_code = dedent(inspect.getsource(self.run))
+
+        # replace tool name
+        source_code = source_code.replace("def run", f"def {self.name}")
+
+        # remove self, handling several cases
+        source_code_lines = source_code.splitlines()
+        if "self" in source_code_lines[0]:
+            # def run(self, ...): or def run (self,): or def run(self):
+            source_code_lines[0] = source_code_lines[0].replace("self, ", "").replace("self,", "").replace("self", "")
+        else:
+            maybe_line_to_delete = None
+            for i, line in enumerate(source_code_lines):
+                if line.strip() == "self" or line.strip() == "self,":
+                    # def run(
+                    #   self,
+                    #   ...
+                    # ):
+                    maybe_line_to_delete = i
+                    break
+                elif line.strip().startswith("self"):
+                    # def run(
+                    #   self, ...
+                    # ):
+                    source_code_lines[i] = line.replace("self, ", "").replace("self,", "").replace("self", "")
+                    break
+            if maybe_line_to_delete is not None:
+                del source_code_lines[maybe_line_to_delete]
+                if maybe_line_to_delete == 1 and source_code_lines[0].strip()[-1] == "(" and source_code_lines[1].strip()[0] == ")":
+                    # def run(
+                    #   self
+                    # ):
+                    source_code_lines[0] = source_code_lines[0].strip() + source_code_lines[1].strip()
+                    del source_code_lines[1]
+
+        source_code = "\n".join(source_code_lines)
+        return source_code

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_return_message.py

@@ -1,14 +1,16 @@
-# 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 datetime as dt
-import typing
-from .tool_return_message_status import ToolReturnMessageStatus
-from ..core.pydantic_utilities import IS_PYDANTIC_V2
-import pydantic
+from typing import List, Optional
+from datetime import datetime
+from typing_extensions import Literal
 
+from .._models import BaseModel
+from .agents.tool_return import ToolReturn
 
-class ToolReturnMessage(UncheckedBaseModel):
+__all__ = ["ToolReturnMessage"]
+
+
+class ToolReturnMessage(BaseModel):
     """
     A message representing the return value of a tool call (generated by Letta executing the requested tool).
 
@@ -16,32 +18,43 @@ class ToolReturnMessage(UncheckedBaseModel):
         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
-        tool_return (str): The return value of the tool
-        status (Literal["success", "error"]): The status of the tool call
-        tool_call_id (str): A unique identifier for the tool call that generated this message
-        stdout (Optional[List(str)]): Captured stdout (e.g. prints, logs) from the tool invocation
-        stderr (Optional[List(str)]): Captured stderr from the tool invocation
+        tool_return (str): The return value of the tool (deprecated, use tool_returns)
+        status (Literal["success", "error"]): The status of the tool call (deprecated, use tool_returns)
+        tool_call_id (str): A unique identifier for the tool call that generated this message (deprecated, use tool_returns)
+        stdout (Optional[List(str)]): Captured stdout (e.g. prints, logs) from the tool invocation (deprecated, use tool_returns)
+        stderr (Optional[List(str)]): Captured stderr from the tool invocation (deprecated, use tool_returns)
+        tool_returns (Optional[List[ToolReturn]]): List of tool returns for multi-tool support
     """
 
     id: str
-    date: dt.datetime
-    name: typing.Optional[str] = None
-    message_type: typing.Literal["tool_return_message"] = "tool_return_message"
-    otid: typing.Optional[str] = None
-    sender_id: typing.Optional[str] = None
-    step_id: typing.Optional[str] = None
-    is_err: typing.Optional[bool] = None
-    tool_return: str
-    status: ToolReturnMessageStatus
+
+    date: datetime
+
+    status: Literal["success", "error"]
+
     tool_call_id: str
-    stdout: typing.Optional[typing.List[str]] = None
-    stderr: typing.Optional[typing.List[str]] = None
 
-    if IS_PYDANTIC_V2:
-        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
-    else:
+    tool_return: str
+
+    is_err: Optional[bool] = None
+
+    message_type: Optional[Literal["tool_return_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
+
+    stderr: Optional[List[str]] = None
+
+    stdout: Optional[List[str]] = None
+
+    step_id: Optional[str] = None
 
-        class Config:
-            frozen = True
-            smart_union = True
-            extra = pydantic.Extra.allow
+    tool_returns: Optional[List[ToolReturn]] = None

letta_client/types/tool_search_params.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, TypedDict
+
+from .._types import SequenceNotStr
+
+__all__ = ["ToolSearchParams"]
+
+
+class ToolSearchParams(TypedDict, total=False):
+    limit: int
+    """Maximum number of results to return."""
+
+    query: Optional[str]
+    """Text query for semantic search."""
+
+    search_mode: Literal["vector", "fts", "hybrid"]
+    """Search mode: vector, fts, or hybrid."""
+
+    tags: Optional[SequenceNotStr[str]]
+    """Filter by tags (match any)."""
+
+    tool_types: Optional[SequenceNotStr[str]]
+    """Filter by tool types (e.g., 'custom', 'letta_core')."""

letta_client/types/tool_search_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_search_result import ToolSearchResult
+
+__all__ = ["ToolSearchResponse"]
+
+ToolSearchResponse: TypeAlias = List[ToolSearchResult]

letta_client/types/tool_search_result.py

@@ -0,0 +1,27 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from .tool import Tool
+from .._models import BaseModel
+
+__all__ = ["ToolSearchResult"]
+
+
+class ToolSearchResult(BaseModel):
+    """Result from a tool search operation."""
+
+    combined_score: float
+    """Combined relevance score (RRF for hybrid mode)."""
+
+    tool: Tool
+    """The matched tool."""
+
+    embedded_text: Optional[str] = None
+    """The embedded text content used for matching."""
+
+    fts_rank: Optional[int] = None
+    """Full-text search rank position."""
+
+    vector_rank: Optional[int] = None
+    """Vector search rank position."""

letta_client/types/tool_type.py

@@ -1,20 +1,19 @@
-# 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
 
-ToolType = typing.Union[
-    typing.Literal[
-        "custom",
-        "letta_core",
-        "letta_memory_core",
-        "letta_multi_agent_core",
-        "letta_sleeptime_core",
-        "letta_voice_sleeptime_core",
-        "letta_builtin",
-        "letta_files_core",
-        "external_composio",
-        "external_langchain",
-        "external_mcp",
-    ],
-    typing.Any,
+__all__ = ["ToolType"]
+
+ToolType: TypeAlias = Literal[
+    "custom",
+    "letta_core",
+    "letta_memory_core",
+    "letta_multi_agent_core",
+    "letta_sleeptime_core",
+    "letta_voice_sleeptime_core",
+    "letta_builtin",
+    "letta_files_core",
+    "external_langchain",
+    "external_composio",
+    "external_mcp",
 ]