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

letta_client/types/models/__init__.py

@@ -0,0 +1,5 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .embedding_list_response import EmbeddingListResponse as EmbeddingListResponse

letta_client/types/models/embedding_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 ..embedding_model import EmbeddingModel
+
+__all__ = ["EmbeddingListResponse"]
+
+EmbeddingListResponse: TypeAlias = List[EmbeddingModel]

letta_client/types/npm_requirement.py

@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from .._models import BaseModel
+
+__all__ = ["NpmRequirement"]
+
+
+class NpmRequirement(BaseModel):
+    name: str
+    """Name of the npm package."""
+
+    version: Optional[str] = None
+    """Optional version of the package, following semantic versioning."""

letta_client/types/npm_requirement_param.py

@@ -0,0 +1,16 @@
+# 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 Required, TypedDict
+
+__all__ = ["NpmRequirementParam"]
+
+
+class NpmRequirementParam(TypedDict, total=False):
+    name: Required[str]
+    """Name of the npm package."""
+
+    version: Optional[str]
+    """Optional version of the package, following semantic versioning."""

letta_client/types/openai_model_settings.py

@@ -0,0 +1,51 @@
+# 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__ = ["OpenAIModelSettings", "Reasoning", "ResponseFormat"]
+
+
+class Reasoning(BaseModel):
+    """The reasoning configuration for the model."""
+
+    reasoning_effort: Optional[Literal["none", "minimal", "low", "medium", "high", "xhigh"]] = None
+    """The reasoning effort to use when generating text reasoning models"""
+
+
+ResponseFormat: TypeAlias = Annotated[
+    Union[TextResponseFormat, JsonSchemaResponseFormat, JsonObjectResponseFormat, None],
+    PropertyInfo(discriminator="type"),
+]
+
+
+class OpenAIModelSettings(BaseModel):
+    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["openai"]] = None
+    """The type of the provider."""
+
+    reasoning: Optional[Reasoning] = None
+    """The reasoning configuration for the model."""
+
+    response_format: Optional[ResponseFormat] = None
+    """The response format for the model."""
+
+    strict: Optional[bool] = None
+    """Enable strict mode for tool calling.
+
+    When true, tool outputs are guaranteed to match JSON schemas.
+    """
+
+    temperature: Optional[float] = None
+    """The temperature of the model."""

letta_client/types/openai_model_settings_param.py

@@ -0,0 +1,48 @@
+# 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__ = ["OpenAIModelSettingsParam", "Reasoning", "ResponseFormat"]
+
+
+class Reasoning(TypedDict, total=False):
+    """The reasoning configuration for the model."""
+
+    reasoning_effort: Literal["none", "minimal", "low", "medium", "high", "xhigh"]
+    """The reasoning effort to use when generating text reasoning models"""
+
+
+ResponseFormat: TypeAlias = Union[TextResponseFormatParam, JsonSchemaResponseFormatParam, JsonObjectResponseFormatParam]
+
+
+class OpenAIModelSettingsParam(TypedDict, total=False):
+    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["openai"]
+    """The type of the provider."""
+
+    reasoning: Reasoning
+    """The reasoning configuration for the model."""
+
+    response_format: Optional[ResponseFormat]
+    """The response format for the model."""
+
+    strict: bool
+    """Enable strict mode for tool calling.
+
+    When true, tool outputs are guaranteed to match JSON schemas.
+    """
+
+    temperature: float
+    """The temperature of the model."""

letta_client/types/parent_tool_rule.py

@@ -1,37 +1,25 @@
-# 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 List, Optional
+from typing_extensions import Literal
 
+from .._models import BaseModel
 
-class ParentToolRule(UncheckedBaseModel):
-    """
-    A ToolRule that only allows a child tool to be called if the parent has been called.
-    """
+__all__ = ["ParentToolRule"]
 
-    tool_name: str = pydantic.Field()
-    """
-    The name of the tool. Must exist in the database for the user's organization.
-    """
 
-    type: typing.Literal["parent_last_tool"] = "parent_last_tool"
-    prompt_template: typing.Optional[str] = pydantic.Field(default=None)
+class ParentToolRule(BaseModel):
     """
-    Optional Jinja2 template for generating agent prompt about this tool rule.
+    A ToolRule that only allows a child tool to be called if the parent has been called.
     """
 
-    children: typing.List[str] = pydantic.Field()
-    """
-    The children tools that can be invoked.
-    """
+    children: List[str]
+    """The children tools that can be invoked."""
+
+    tool_name: str
+    """The name of the tool. Must exist in the database for the user's organization."""
 
-    if IS_PYDANTIC_V2:
-        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
-    else:
+    prompt_template: Optional[str] = None
+    """Optional template string (ignored)."""
 
-        class Config:
-            frozen = True
-            smart_union = True
-            extra = pydantic.Extra.allow
+    type: Optional[Literal["parent_last_tool"]] = None

letta_client/types/parent_tool_rule_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
+
+from .._types import SequenceNotStr
+
+__all__ = ["ParentToolRuleParam"]
+
+
+class ParentToolRuleParam(TypedDict, total=False):
+    """
+    A ToolRule that only allows a child tool to be called if the parent has been called.
+    """
+
+    children: Required[SequenceNotStr[str]]
+    """The children tools that can be invoked."""
+
+    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["parent_last_tool"]

letta_client/types/passage.py

@@ -1,103 +1,58 @@
-# 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 datetime as dt
+from typing import Dict, List, Optional
+from datetime import datetime
+
+from .._models import BaseModel
 from .embedding_config import EmbeddingConfig
-from ..core.pydantic_utilities import IS_PYDANTIC_V2
-
-
-class Passage(UncheckedBaseModel):
-    """
-    Representation of a passage, which is stored in archival memory.
-
-    Parameters:
-        text (str): The text of the passage.
-        embedding (List[float]): The embedding of the passage.
-        embedding_config (EmbeddingConfig): The embedding configuration used by the passage.
-        created_at (datetime): The creation date of the passage.
-        user_id (str): The unique identifier of the user associated with the passage.
-        agent_id (str): The unique identifier of the agent associated with the passage.
-        source_id (str): The data source of the passage.
-        file_id (str): The unique identifier of the file associated with the passage.
-    """
-
-    created_by_id: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    The id of the user that made this object.
-    """
-
-    last_updated_by_id: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    The id of the user that made this object.
-    """
-
-    created_at: typing.Optional[dt.datetime] = pydantic.Field(default=None)
-    """
-    The creation date of the passage.
-    """
-
-    updated_at: typing.Optional[dt.datetime] = pydantic.Field(default=None)
-    """
-    The timestamp when the object was last updated.
-    """
-
-    is_deleted: typing.Optional[bool] = pydantic.Field(default=None)
-    """
-    Whether this passage is deleted or not.
-    """
-
-    agent_id: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    The unique identifier of the agent associated with the passage.
-    """
-
-    source_id: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    The data source of the passage.
-    """
-
-    file_id: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    The unique identifier of the file associated with the passage.
-    """
-
-    file_name: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    The name of the file (only for source passages).
-    """
-
-    metadata: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] = pydantic.Field(default=None)
-    """
-    The metadata of the passage.
-    """
-
-    id: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    The human-friendly ID of the Passage
-    """
-
-    text: str = pydantic.Field()
-    """
-    The text of the passage.
-    """
-
-    embedding: typing.Optional[typing.List[float]] = pydantic.Field(default=None)
-    """
-    The embedding of the passage.
-    """
-
-    embedding_config: typing.Optional[EmbeddingConfig] = pydantic.Field(default=None)
-    """
-    The embedding configuration used by the passage.
-    """
-
-    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
+
+__all__ = ["Passage"]
+
+
+class Passage(BaseModel):
+    """Representation of a passage, which is stored in archival memory."""
+
+    embedding: Optional[List[float]] = None
+    """The embedding of the passage."""
+
+    embedding_config: Optional[EmbeddingConfig] = None
+    """Configuration for embedding model connection and processing parameters."""
+
+    text: str
+    """The text of the passage."""
+
+    id: Optional[str] = None
+    """The human-friendly ID of the Passage"""
+
+    archive_id: Optional[str] = None
+    """The unique identifier of the archive containing this passage."""
+
+    created_at: Optional[datetime] = None
+    """The creation date of the passage."""
+
+    created_by_id: Optional[str] = None
+    """The id of the user that made this object."""
+
+    file_id: Optional[str] = None
+    """The unique identifier of the file associated with the passage."""
+
+    file_name: Optional[str] = None
+    """The name of the file (only for source passages)."""
+
+    is_deleted: Optional[bool] = None
+    """Whether this passage is deleted or not."""
+
+    last_updated_by_id: Optional[str] = None
+    """The id of the user that made this object."""
+
+    metadata: Optional[Dict[str, object]] = None
+    """The metadata of the passage."""
+
+    source_id: Optional[str] = None
+    """Deprecated: Use `folder_id` field instead. The data source of the passage."""
+
+    tags: Optional[List[str]] = None
+    """Tags associated with this passage."""
+
+    updated_at: Optional[datetime] = None
+    """The timestamp when the object was last updated."""

letta_client/types/passage_search_params.py

@@ -0,0 +1,41 @@
+# 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]
+    """Text query for semantic search"""
+
+    agent_id: Optional[str]
+    """Filter passages by agent ID"""
+
+    archive_id: Optional[str]
+    """Filter passages by archive ID"""
+
+    end_date: Annotated[Union[str, datetime, None], PropertyInfo(format="iso8601")]
+    """Filter results to passages created before this datetime"""
+
+    limit: int
+    """Maximum number of results to return"""
+
+    start_date: 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"""

letta_client/types/passage_search_response.py

@@ -0,0 +1,25 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Optional
+from typing_extensions import TypeAlias
+
+from .passage import Passage
+from .._models import BaseModel
+
+__all__ = ["PassageSearchResponse", "PassageSearchResponseItem"]
+
+
+class PassageSearchResponseItem(BaseModel):
+    """Result from a passage search operation with scoring details."""
+
+    passage: Passage
+    """The passage object"""
+
+    score: float
+    """Relevance score"""
+
+    metadata: Optional[Dict[str, object]] = None
+    """Additional metadata about the search result"""
+
+
+PassageSearchResponse: TypeAlias = List[PassageSearchResponseItem]

letta_client/types/pip_requirement.py

@@ -1,27 +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 pydantic
-import typing
-from ..core.pydantic_utilities import IS_PYDANTIC_V2
+from typing import Optional
 
+from .._models import BaseModel
 
-class PipRequirement(UncheckedBaseModel):
-    name: str = pydantic.Field()
-    """
-    Name of the pip package.
-    """
+__all__ = ["PipRequirement"]
 
-    version: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    Optional version of the package, following semantic versioning.
-    """
 
-    if IS_PYDANTIC_V2:
-        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
-    else:
+class PipRequirement(BaseModel):
+    name: str
+    """Name of the pip package."""
 
-        class Config:
-            frozen = True
-            smart_union = True
-            extra = pydantic.Extra.allow
+    version: Optional[str] = None
+    """Optional version of the package, following semantic versioning."""

letta_client/types/pip_requirement_param.py

@@ -0,0 +1,16 @@
+# 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 Required, TypedDict
+
+__all__ = ["PipRequirementParam"]
+
+
+class PipRequirementParam(TypedDict, total=False):
+    name: Required[str]
+    """Name of the pip package."""
+
+    version: Optional[str]
+    """Optional version of the package, following semantic versioning."""

letta_client/types/provider_category.py

@@ -1,5 +1,7 @@
-# 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
 
-ProviderCategory = typing.Union[typing.Literal["base", "byok"], typing.Any]
+__all__ = ["ProviderCategory"]
+
+ProviderCategory: TypeAlias = Literal["base", "byok"]

letta_client/types/provider_trace.py

@@ -1,70 +1,65 @@
-# 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 datetime as dt
-from ..core.pydantic_utilities import IS_PYDANTIC_V2
+from typing import Dict, List, Optional
+from datetime import datetime
 
+from .._models import BaseModel
 
-class ProviderTrace(UncheckedBaseModel):
-    """
-    Letta's internal representation of a provider trace.
+__all__ = ["ProviderTrace"]
+
+
+class ProviderTrace(BaseModel):
+    """Letta's internal representation of a provider trace.
 
     Attributes:
         id (str): The unique identifier of the provider trace.
         request_json (Dict[str, Any]): JSON content of the provider request.
         response_json (Dict[str, Any]): JSON content of the provider response.
         step_id (str): ID of the step that this trace is associated with.
+        agent_id (str): ID of the agent that generated this trace.
+        agent_tags (list[str]): Tags associated with the agent for filtering.
+        call_type (str): Type of call (agent_step, summarization, etc.).
+        run_id (str): ID of the run this trace is associated with.
+        source (str): Source service that generated this trace (memgpt-server, lettuce-py).
         organization_id (str): The unique identifier of the organization.
         created_at (datetime): The timestamp when the object was created.
     """
 
-    created_by_id: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    The id of the user that made this object.
-    """
+    request_json: Dict[str, object]
+    """JSON content of the provider request"""
 
-    last_updated_by_id: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    The id of the user that made this object.
-    """
+    response_json: Dict[str, object]
+    """JSON content of the provider response"""
 
-    created_at: typing.Optional[dt.datetime] = pydantic.Field(default=None)
-    """
-    The timestamp when the object was created.
-    """
+    id: Optional[str] = None
+    """The human-friendly ID of the Provider_trace"""
 
-    updated_at: typing.Optional[dt.datetime] = pydantic.Field(default=None)
-    """
-    The timestamp when the object was last updated.
-    """
+    agent_id: Optional[str] = None
+    """ID of the agent that generated this trace"""
 
-    id: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    The human-friendly ID of the Provider_trace
-    """
+    agent_tags: Optional[List[str]] = None
+    """Tags associated with the agent for filtering"""
 
-    request_json: typing.Dict[str, typing.Optional[typing.Any]] = pydantic.Field()
-    """
-    JSON content of the provider request
-    """
+    call_type: Optional[str] = None
+    """Type of call (agent_step, summarization, etc.)"""
 
-    response_json: typing.Dict[str, typing.Optional[typing.Any]] = pydantic.Field()
-    """
-    JSON content of the provider response
-    """
+    created_at: Optional[datetime] = None
+    """The timestamp when the object was created."""
 
-    step_id: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    ID of the step that this trace is associated with
-    """
+    created_by_id: Optional[str] = None
+    """The id of the user that made this object."""
+
+    last_updated_by_id: Optional[str] = None
+    """The id of the user that made this object."""
+
+    run_id: Optional[str] = None
+    """ID of the run this trace is associated with"""
+
+    source: Optional[str] = None
+    """Source service that generated this trace (memgpt-server, lettuce-py)"""
 
-    if IS_PYDANTIC_V2:
-        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
-    else:
+    step_id: Optional[str] = None
+    """ID of the step that this trace is associated with"""
 
-        class Config:
-            frozen = True
-            smart_union = True
-            extra = pydantic.Extra.allow
+    updated_at: Optional[datetime] = None
+    """The timestamp when the object was last updated."""