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

letta_client/types/identity_property_param.py

@@ -0,0 +1,19 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Union
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["IdentityPropertyParam"]
+
+
+class IdentityPropertyParam(TypedDict, total=False):
+    key: Required[str]
+    """The key of the property"""
+
+    type: Required[Literal["string", "number", "boolean", "json"]]
+    """The type of the property"""
+
+    value: Required[Union[str, float, bool, Dict[str, object]]]
+    """The value of the property"""

letta_client/types/identity_type.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
 
-IdentityType = typing.Union[typing.Literal["org", "user", "other"], typing.Any]
+__all__ = ["IdentityType"]
+
+IdentityType: TypeAlias = Literal["org", "user", "other"]

letta_client/types/identity_update_params.py

@@ -0,0 +1,32 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Iterable, Optional
+from typing_extensions import TypedDict
+
+from .._types import SequenceNotStr
+from .identity_type import IdentityType
+from .identity_property_param import IdentityPropertyParam
+
+__all__ = ["IdentityUpdateParams"]
+
+
+class IdentityUpdateParams(TypedDict, total=False):
+    agent_ids: Optional[SequenceNotStr[str]]
+    """The agent ids that are associated with the identity."""
+
+    block_ids: Optional[SequenceNotStr[str]]
+    """The IDs of the blocks associated with the identity."""
+
+    identifier_key: Optional[str]
+    """External, user-generated identifier key of the identity."""
+
+    identity_type: Optional[IdentityType]
+    """Enum to represent the type of the identity."""
+
+    name: Optional[str]
+    """The name of the identity."""
+
+    properties: Optional[Iterable[IdentityPropertyParam]]
+    """List of properties associated with the identity."""

letta_client/types/identity_upsert_params.py

@@ -0,0 +1,39 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Iterable, Optional
+from typing_extensions import Required, Annotated, TypedDict
+
+from .._types import SequenceNotStr
+from .._utils import PropertyInfo
+from .identity_type import IdentityType
+from .identity_property_param import IdentityPropertyParam
+
+__all__ = ["IdentityUpsertParams"]
+
+
+class IdentityUpsertParams(TypedDict, total=False):
+    identifier_key: Required[str]
+    """External, user-generated identifier key of the identity."""
+
+    identity_type: Required[IdentityType]
+    """The type of the identity."""
+
+    name: Required[str]
+    """The name of the identity."""
+
+    agent_ids: Optional[SequenceNotStr[str]]
+    """The agent ids that are associated with the identity."""
+
+    block_ids: Optional[SequenceNotStr[str]]
+    """The IDs of the blocks associated with the identity."""
+
+    project_id: Optional[str]
+    """The project id of the identity, if applicable."""
+
+    properties: Optional[Iterable[IdentityPropertyParam]]
+    """List of properties associated with the identity."""
+
+    x_project: Annotated[str, PropertyInfo(alias="X-Project")]
+    """The project slug to associate with the identity (cloud only)."""

letta_client/types/init_tool_rule.py

@@ -1,38 +1,30 @@
-# 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, 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__ = ["InitToolRule"]
 
-class InitToolRule(UncheckedBaseModel):
-    """
-    Represents the initial tool rule configuration.
-    """
 
-    tool_name: str = pydantic.Field()
-    """
-    The name of the tool. Must exist in the database for the user's organization.
-    """
+class InitToolRule(BaseModel):
+    tool_name: str
+    """The name of the tool. Must exist in the database for the user's organization."""
 
-    type: typing.Literal["run_first"] = "run_first"
-    prompt_template: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    Optional template string (ignored). Rendering uses fast built-in formatting for performance.
-    """
+    args: Optional[Dict[str, object]] = None
+    """Optional prefilled arguments for this tool.
 
-    args: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] = pydantic.Field(default=None)
-    """
-    Optional prefilled arguments for this tool. When present, these values will override any LLM-provided arguments with the same keys during invocation. Keys must match the tool's parameter names and values must satisfy the tool's JSON schema. Supports partial prefill; non-overlapping parameters are left to the model.
+    When present, these values will override any LLM-provided arguments with the
+    same keys during invocation. Keys must match the tool's parameter names and
+    values must satisfy the tool's JSON schema. Supports partial prefill;
+    non-overlapping parameters are left to the model.
     """
 
-    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).
+
+    Rendering uses fast built-in formatting for performance.
+    """
 
-        class Config:
-            frozen = True
-            smart_union = True
-            extra = pydantic.Extra.allow
+    type: Optional[Literal["run_first"]] = None

letta_client/types/init_tool_rule_param.py

@@ -0,0 +1,30 @@
+# 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 Literal, Required, TypedDict
+
+__all__ = ["InitToolRuleParam"]
+
+
+class InitToolRuleParam(TypedDict, total=False):
+    tool_name: Required[str]
+    """The name of the tool. Must exist in the database for the user's organization."""
+
+    args: Optional[Dict[str, object]]
+    """Optional prefilled arguments for this tool.
+
+    When present, these values will override any LLM-provided arguments with the
+    same keys during invocation. Keys must match the tool's parameter names and
+    values must satisfy the tool's JSON schema. Supports partial prefill;
+    non-overlapping parameters are left to the model.
+    """
+
+    prompt_template: Optional[str]
+    """Optional template string (ignored).
+
+    Rendering uses fast built-in formatting for performance.
+    """
+
+    type: Literal["run_first"]

letta_client/types/json_object_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__ = ["JsonObjectResponseFormat"]
 
-class JsonObjectResponseFormat(UncheckedBaseModel):
-    """
-    Response format for JSON object responses.
-    """
 
-    type: typing.Literal["json_object"] = "json_object"
-
-    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 JsonObjectResponseFormat(BaseModel):
+    type: Optional[Literal["json_object"]] = None
+    """The type of the response format."""

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

letta_client/types/json_schema_response_format.py

@@ -1,28 +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.
 
-import typing
+from typing import Dict, 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__ = ["JsonSchemaResponseFormat"]
 
-class JsonSchemaResponseFormat(UncheckedBaseModel):
-    """
-    Response format for JSON schema-based responses.
-    """
 
-    type: typing.Literal["json_schema"] = "json_schema"
-    json_schema: typing.Dict[str, typing.Optional[typing.Any]] = pydantic.Field()
-    """
-    The JSON schema of the response.
-    """
+class JsonSchemaResponseFormat(BaseModel):
+    json_schema: Dict[str, object]
+    """The JSON schema of the response."""
 
-    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["json_schema"]] = None
+    """The type of the response format."""

letta_client/types/json_schema_response_format_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 Dict
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["JsonSchemaResponseFormatParam"]
+
+
+class JsonSchemaResponseFormatParam(TypedDict, total=False):
+    json_schema: Required[Dict[str, object]]
+    """The JSON schema of the response."""
+
+    type: Literal["json_schema"]
+    """The type of the response format."""

letta_client/types/letta_message_content_union_param.py

@@ -0,0 +1,26 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from typing_extensions import TypeAlias
+
+from .agents.text_content_param import TextContentParam
+from .agents.image_content_param import ImageContentParam
+from .agents.reasoning_content_param import ReasoningContentParam
+from .agents.tool_call_content_param import ToolCallContentParam
+from .agents.tool_return_content_param import ToolReturnContentParam
+from .agents.omitted_reasoning_content_param import OmittedReasoningContentParam
+from .agents.redacted_reasoning_content_param import RedactedReasoningContentParam
+
+__all__ = ["LettaMessageContentUnionParam"]
+
+LettaMessageContentUnionParam: TypeAlias = Union[
+    TextContentParam,
+    ImageContentParam,
+    ToolCallContentParam,
+    ToolReturnContentParam,
+    ReasoningContentParam,
+    RedactedReasoningContentParam,
+    OmittedReasoningContentParam,
+]

letta_client/types/llm_config.py

@@ -1,127 +1,116 @@
-# 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 .llm_config_compatibility_type import LlmConfigCompatibilityType
-from .llm_config_model_endpoint_type import LlmConfigModelEndpointType
-from .llm_config_reasoning_effort import LlmConfigReasoningEffort
-from .llm_config_verbosity import LlmConfigVerbosity
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
 from .provider_category import ProviderCategory
 
+__all__ = ["LlmConfig"]
 
-class LlmConfig(UncheckedBaseModel):
-    """
-    Configuration for Language Model (LLM) connection and generation parameters.
-    """
 
-    model: str = pydantic.Field()
-    """
-    LLM model name. 
-    """
+class LlmConfig(BaseModel):
+    context_window: int
+    """The context window size for the model."""
 
-    display_name: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    A human-friendly display name for the model.
-    """
+    model: str
+    """LLM model name."""
 
-    model_endpoint_type: LlmConfigModelEndpointType = pydantic.Field()
-    """
-    The endpoint type for the model.
-    """
+    api_model_endpoint_type: Literal[
+        "openai",
+        "anthropic",
+        "google_ai",
+        "google_vertex",
+        "azure",
+        "groq",
+        "ollama",
+        "webui",
+        "webui-legacy",
+        "lmstudio",
+        "lmstudio-legacy",
+        "lmstudio-chatcompletions",
+        "llamacpp",
+        "koboldcpp",
+        "vllm",
+        "hugging-face",
+        "mistral",
+        "together",
+        "bedrock",
+        "deepseek",
+        "xai",
+    ] = FieldInfo(alias="model_endpoint_type")
+    """The endpoint type for the model."""
 
-    model_endpoint: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    The endpoint for the model.
-    """
+    compatibility_type: Optional[Literal["gguf", "mlx"]] = None
+    """The framework compatibility type for the model."""
 
-    provider_name: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    The provider name for the model.
-    """
+    display_name: Optional[str] = None
+    """A human-friendly display name for the model."""
 
-    provider_category: typing.Optional[ProviderCategory] = pydantic.Field(default=None)
+    enable_reasoner: Optional[bool] = None
     """
-    The provider category for the model.
+    Whether or not the model should use extended thinking if it is a 'reasoning'
+    style model
     """
 
-    model_wrapper: typing.Optional[str] = pydantic.Field(default=None)
+    frequency_penalty: Optional[float] = None
     """
-    The wrapper for the model.
+    Positive values penalize new tokens based on their existing frequency in the
+    text so far, decreasing the model's likelihood to repeat the same line verbatim.
+    From OpenAI: Number between -2.0 and 2.0.
     """
 
-    context_window: int = pydantic.Field()
-    """
-    The context window size for the model.
-    """
+    handle: Optional[str] = None
+    """The handle for this config, in the format provider/model-name."""
 
-    put_inner_thoughts_in_kwargs: typing.Optional[bool] = pydantic.Field(default=None)
-    """
-    Puts 'inner_thoughts' as a kwarg in the function call if this is set to True. This helps with function calling performance and also the generation of inner thoughts.
-    """
+    max_reasoning_tokens: Optional[int] = None
+    """Configurable thinking budget for extended thinking.
 
-    handle: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    The handle for this config, in the format provider/model-name.
+    Used for enable_reasoner and also for Google Vertex models like Gemini 2.5
+    Flash. Minimum value is 1024 when used with enable_reasoner.
     """
 
-    temperature: typing.Optional[float] = pydantic.Field(default=None)
-    """
-    The temperature to use when generating text with the model. A higher temperature will result in more random text.
-    """
+    max_tokens: Optional[int] = None
+    """The maximum number of tokens to generate.
 
-    max_tokens: typing.Optional[int] = pydantic.Field(default=None)
-    """
-    The maximum number of tokens to generate. If not set, the model will use its default value.
+    If not set, the model will use its default value.
     """
 
-    enable_reasoner: typing.Optional[bool] = pydantic.Field(default=None)
-    """
-    Whether or not the model should use extended thinking if it is a 'reasoning' style model
-    """
+    api_model_endpoint: Optional[str] = FieldInfo(alias="model_endpoint", default=None)
+    """The endpoint for the model."""
 
-    reasoning_effort: typing.Optional[LlmConfigReasoningEffort] = pydantic.Field(default=None)
-    """
-    The reasoning effort to use when generating text reasoning models
-    """
+    api_model_wrapper: Optional[str] = FieldInfo(alias="model_wrapper", default=None)
+    """The wrapper for the model."""
 
-    max_reasoning_tokens: typing.Optional[int] = pydantic.Field(default=None)
-    """
-    Configurable thinking budget for extended thinking. Used for enable_reasoner and also for Google Vertex models like Gemini 2.5 Flash. Minimum value is 1024 when used with enable_reasoner.
-    """
+    parallel_tool_calls: Optional[bool] = None
+    """If set to True, enables parallel tool calling. Defaults to False."""
 
-    frequency_penalty: typing.Optional[float] = pydantic.Field(default=None)
-    """
-    Positive values penalize new tokens based on their existing frequency in the text so far, decreasing the model's likelihood to repeat the same line verbatim. From OpenAI: Number between -2.0 and 2.0.
-    """
+    provider_category: Optional[ProviderCategory] = None
+    """The provider category for the model."""
 
-    compatibility_type: typing.Optional[LlmConfigCompatibilityType] = pydantic.Field(default=None)
-    """
-    The framework compatibility type for the model.
-    """
+    provider_name: Optional[str] = None
+    """The provider name for the model."""
 
-    verbosity: typing.Optional[LlmConfigVerbosity] = pydantic.Field(default=None)
-    """
-    Soft control for how verbose model output should be, used for GPT-5 models.
-    """
+    put_inner_thoughts_in_kwargs: Optional[bool] = None
+    """Puts 'inner_thoughts' as a kwarg in the function call if this is set to True.
 
-    tier: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    The cost tier for the model (cloud only).
+    This helps with function calling performance and also the generation of inner
+    thoughts.
     """
 
-    parallel_tool_calls: typing.Optional[bool] = pydantic.Field(default=None)
-    """
-    If set to True, enables parallel tool calling. Defaults to False.
+    reasoning_effort: Optional[Literal["minimal", "low", "medium", "high"]] = None
+    """The reasoning effort to use when generating text reasoning models"""
+
+    temperature: Optional[float] = None
+    """The temperature to use when generating text with the model.
+
+    A higher temperature will result in more random text.
     """
 
-    if IS_PYDANTIC_V2:
-        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
-    else:
+    tier: Optional[str] = None
+    """The cost tier for the model (cloud only)."""
 
-        class Config:
-            frozen = True
-            smart_union = True
-            extra = pydantic.Extra.allow
+    verbosity: Optional[Literal["low", "medium", "high"]] = None
+    """Soft control for how verbose model output should be, used for GPT-5 models."""

letta_client/types/llm_config_param.py

@@ -0,0 +1,117 @@
+# 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 .provider_category import ProviderCategory
+
+__all__ = ["LlmConfigParam"]
+
+
+class LlmConfigParam(TypedDict, total=False):
+    context_window: Required[int]
+    """The context window size for the model."""
+
+    model: Required[str]
+    """LLM model name."""
+
+    model_endpoint_type: Required[
+        Literal[
+            "openai",
+            "anthropic",
+            "google_ai",
+            "google_vertex",
+            "azure",
+            "groq",
+            "ollama",
+            "webui",
+            "webui-legacy",
+            "lmstudio",
+            "lmstudio-legacy",
+            "lmstudio-chatcompletions",
+            "llamacpp",
+            "koboldcpp",
+            "vllm",
+            "hugging-face",
+            "mistral",
+            "together",
+            "bedrock",
+            "deepseek",
+            "xai",
+        ]
+    ]
+    """The endpoint type for the model."""
+
+    compatibility_type: Optional[Literal["gguf", "mlx"]]
+    """The framework compatibility type for the model."""
+
+    display_name: Optional[str]
+    """A human-friendly display name for the model."""
+
+    enable_reasoner: bool
+    """
+    Whether or not the model should use extended thinking if it is a 'reasoning'
+    style model
+    """
+
+    frequency_penalty: Optional[float]
+    """
+    Positive values penalize new tokens based on their existing frequency in the
+    text so far, decreasing the model's likelihood to repeat the same line verbatim.
+    From OpenAI: Number between -2.0 and 2.0.
+    """
+
+    handle: Optional[str]
+    """The handle for this config, in the format provider/model-name."""
+
+    max_reasoning_tokens: int
+    """Configurable thinking budget for extended thinking.
+
+    Used for enable_reasoner and also for Google Vertex models like Gemini 2.5
+    Flash. Minimum value is 1024 when used with enable_reasoner.
+    """
+
+    max_tokens: Optional[int]
+    """The maximum number of tokens to generate.
+
+    If not set, the model will use its default value.
+    """
+
+    model_endpoint: Optional[str]
+    """The endpoint for the model."""
+
+    model_wrapper: Optional[str]
+    """The wrapper for the model."""
+
+    parallel_tool_calls: Optional[bool]
+    """If set to True, enables parallel tool calling. Defaults to False."""
+
+    provider_category: Optional[ProviderCategory]
+    """The provider category for the model."""
+
+    provider_name: Optional[str]
+    """The provider name for the model."""
+
+    put_inner_thoughts_in_kwargs: Optional[bool]
+    """Puts 'inner_thoughts' as a kwarg in the function call if this is set to True.
+
+    This helps with function calling performance and also the generation of inner
+    thoughts.
+    """
+
+    reasoning_effort: Optional[Literal["minimal", "low", "medium", "high"]]
+    """The reasoning effort to use when generating text reasoning models"""
+
+    temperature: float
+    """The temperature to use when generating text with the model.
+
+    A higher temperature will result in more random text.
+    """
+
+    tier: Optional[str]
+    """The cost tier for the model (cloud only)."""
+
+    verbosity: Optional[Literal["low", "medium", "high"]]
+    """Soft control for how verbose model output should be, used for GPT-5 models."""