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

letta_client/types/init_tool_rule.py

@@ -1,32 +1,32 @@
-# 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 Dict, Optional
+from typing_extensions import Literal
 
+from .._models import BaseModel
 
-class InitToolRule(UncheckedBaseModel):
-    """
-    Represents the initial tool rule configuration.
-    """
+__all__ = ["InitToolRule"]
 
-    tool_name: str = pydantic.Field()
-    """
-    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 Jinja2 template for generating agent prompt about this tool rule. Template can use variables like 'tool_name' and rule-specific attributes.
+class InitToolRule(BaseModel):
+    """Represents the initial tool rule configuration."""
+
+    tool_name: str
+    """The name of the tool. Must exist in the database for the user's organization."""
+
+    args: Optional[Dict[str, object]] = 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.
     """
 
-    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,32 @@
+# 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):
+    """Represents the initial tool rule configuration."""
+
+    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,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 JsonObjectResponseFormat(UncheckedBaseModel):
-    """
-    Response format for JSON object responses.
-    """
+__all__ = ["JsonObjectResponseFormat"]
 
-    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 JsonObjectResponseFormat(BaseModel):
+    """Response format for JSON object responses."""
 
-        class Config:
-            frozen = True
-            smart_union = True
-            extra = pydantic.Extra.allow
+    type: Optional[Literal["json_object"]] = None
+    """The type of the response format."""

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

letta_client/types/json_schema_response_format.py

@@ -1,27 +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.
 
-from ..core.unchecked_base_model import UncheckedBaseModel
-import typing
-import pydantic
-from ..core.pydantic_utilities import IS_PYDANTIC_V2
+from typing import Dict, Optional
+from typing_extensions import Literal
 
+from .._models import BaseModel
 
-class JsonSchemaResponseFormat(UncheckedBaseModel):
-    """
-    Response format for JSON schema-based responses.
-    """
+__all__ = ["JsonSchemaResponseFormat"]
 
-    type: typing.Literal["json_schema"] = "json_schema"
-    json_schema: typing.Dict[str, typing.Optional[typing.Any]] = pydantic.Field()
-    """
-    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 JsonSchemaResponseFormat(BaseModel):
+    """Response format for JSON schema-based responses."""
 
-        class Config:
-            frozen = True
-            smart_union = True
-            extra = pydantic.Extra.allow
+    json_schema: Dict[str, object]
+    """The JSON schema of the response."""
+
+    type: Optional[Literal["json_schema"]] = None
+    """The type of the response format."""

letta_client/types/json_schema_response_format_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 Dict
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["JsonSchemaResponseFormatParam"]
+
+
+class JsonSchemaResponseFormatParam(TypedDict, total=False):
+    """Response format for JSON schema-based responses."""
+
+    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,109 +1,158 @@
-# 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
-from .llm_config_model_endpoint_type import LlmConfigModelEndpointType
-import typing
+from typing import Union, Optional
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from pydantic import Field as FieldInfo
+
+from .._utils import PropertyInfo
+from .._models import BaseModel
 from .provider_category import ProviderCategory
-from .llm_config_reasoning_effort import LlmConfigReasoningEffort
-from ..core.pydantic_utilities import IS_PYDANTIC_V2
+from .text_response_format import TextResponseFormat
+from .json_object_response_format import JsonObjectResponseFormat
+from .json_schema_response_format import JsonSchemaResponseFormat
 
+__all__ = ["LlmConfig", "ResponseFormat"]
 
-class LlmConfig(UncheckedBaseModel):
-    """
-    Configuration for a Language Model (LLM) model. This object specifies all the information necessary to access an LLM model to usage with Letta, except for secret keys.
-
-    Attributes:
-        model (str): The name of the LLM model.
-        model_endpoint_type (str): The endpoint type for the model.
-        model_endpoint (str): The endpoint for the model.
-        model_wrapper (str): The wrapper for the model. This is used to wrap additional text around the input/output of the model. This is useful for text-to-text completions, such as the Completions API in OpenAI.
-        context_window (int): The context window size for the model.
-        put_inner_thoughts_in_kwargs (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.
-        temperature (float): The temperature to use when generating text with the model. A higher temperature will result in more random text.
-        max_tokens (int): The maximum number of tokens to generate.
-    """
+ResponseFormat: TypeAlias = Annotated[
+    Union[TextResponseFormat, JsonSchemaResponseFormat, JsonObjectResponseFormat, None],
+    PropertyInfo(discriminator="type"),
+]
 
-    model: str = pydantic.Field()
-    """
-    LLM model name. 
-    """
 
-    model_endpoint_type: LlmConfigModelEndpointType = pydantic.Field()
-    """
-    The endpoint type for the model.
-    """
+class LlmConfig(BaseModel):
+    """Configuration for Language Model (LLM) connection and generation parameters.
 
-    model_endpoint: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    The endpoint for the model.
+    .. deprecated::
+        LLMConfig is deprecated and should not be used as an input or return type in API calls.
+        Use the schemas in letta.schemas.model (ModelSettings, OpenAIModelSettings, etc.) instead.
+        For conversion, use the _to_model() method or Model._from_llm_config() method.
     """
 
-    provider_name: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    The provider name for the model.
-    """
+    context_window: int
+    """The context window size for the model."""
 
-    provider_category: typing.Optional[ProviderCategory] = pydantic.Field(default=None)
-    """
-    The provider category for the model.
-    """
+    model: str
+    """LLM model name."""
 
-    model_wrapper: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    The wrapper 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",
+        "zai",
+        "chatgpt_oauth",
+    ] = FieldInfo(alias="model_endpoint_type")
+    """The endpoint type for the model."""
 
-    context_window: int = pydantic.Field()
-    """
-    The context window size for the model.
-    """
+    compatibility_type: Optional[Literal["gguf", "mlx"]] = None
+    """The framework compatibility type for the model."""
 
-    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.
-    """
+    display_name: Optional[str] = None
+    """A human-friendly display name for the model."""
 
-    handle: typing.Optional[str] = pydantic.Field(default=None)
-    """
-    The handle for this config, in the format provider/model-name.
+    effort: Optional[Literal["low", "medium", "high"]] = None
+    """The effort level for Anthropic Opus 4.5 model (controls token spending).
+
+    Not setting this gives similar performance to 'high'.
     """
 
-    temperature: typing.Optional[float] = pydantic.Field(default=None)
+    enable_reasoner: Optional[bool] = None
     """
-    The temperature to use when generating text with the model. A higher temperature will result in more random text.
+    Whether or not the model should use extended thinking if it is a 'reasoning'
+    style model
     """
 
-    max_tokens: typing.Optional[int] = pydantic.Field(default=None)
+    frequency_penalty: Optional[float] = None
     """
-    The maximum number of tokens to generate. If not set, the model will use its default value.
+    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.
     """
 
-    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
+    handle: Optional[str] = None
+    """The handle for this config, in the format provider/model-name."""
+
+    max_reasoning_tokens: Optional[int] = 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.
     """
 
-    reasoning_effort: typing.Optional[LlmConfigReasoningEffort] = pydantic.Field(default=None)
+    max_tokens: Optional[int] = None
+    """The maximum number of tokens to generate.
+
+    If not set, the model will use its default value.
     """
-    The reasoning effort to use when generating text reasoning models
+
+    api_model_endpoint: Optional[str] = FieldInfo(alias="model_endpoint", default=None)
+    """The endpoint for the model."""
+
+    api_model_wrapper: Optional[str] = FieldInfo(alias="model_wrapper", default=None)
+    """The wrapper for the model."""
+
+    parallel_tool_calls: Optional[bool] = None
+    """Deprecated: Use model_settings to configure parallel tool calls instead.
+
+    If set to True, enables parallel tool calling. Defaults to False.
     """
 
-    max_reasoning_tokens: typing.Optional[int] = pydantic.Field(default=None)
+    provider_category: Optional[ProviderCategory] = None
+    """The provider category for the model."""
+
+    provider_name: Optional[str] = None
+    """The provider name for the model."""
+
+    put_inner_thoughts_in_kwargs: Optional[bool] = 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.
     """
-    Configurable thinking budget for extended thinking, only used if enable_reasoner is True. Minimum value is 1024.
+
+    reasoning_effort: Optional[Literal["none", "minimal", "low", "medium", "high", "xhigh"]] = None
+    """The reasoning effort to use when generating text reasoning models"""
+
+    response_format: Optional[ResponseFormat] = None
+    """The response format for the model's output.
+
+    Supports text, json_object, and json_schema (structured outputs). Can be set via
+    model_settings.
     """
 
-    frequency_penalty: typing.Optional[float] = pydantic.Field(default=None)
+    strict: Optional[bool] = None
+    """Enable strict mode for tool calling.
+
+    When true, tool schemas include strict: true and additionalProperties: false,
+    guaranteeing tool outputs match JSON schemas.
     """
-    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.
+
+    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,155 @@
+# 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, Required, TypeAlias, TypedDict
+
+from .provider_category import ProviderCategory
+from .text_response_format_param import TextResponseFormatParam
+from .json_object_response_format_param import JsonObjectResponseFormatParam
+from .json_schema_response_format_param import JsonSchemaResponseFormatParam
+
+__all__ = ["LlmConfigParam", "ResponseFormat"]
+
+ResponseFormat: TypeAlias = Union[TextResponseFormatParam, JsonSchemaResponseFormatParam, JsonObjectResponseFormatParam]
+
+
+class LlmConfigParam(TypedDict, total=False):
+    """Configuration for Language Model (LLM) connection and generation parameters.
+
+    .. deprecated::
+        LLMConfig is deprecated and should not be used as an input or return type in API calls.
+        Use the schemas in letta.schemas.model (ModelSettings, OpenAIModelSettings, etc.) instead.
+        For conversion, use the _to_model() method or Model._from_llm_config() method.
+    """
+
+    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",
+            "zai",
+            "chatgpt_oauth",
+        ]
+    ]
+    """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."""
+
+    effort: Optional[Literal["low", "medium", "high"]]
+    """The effort level for Anthropic Opus 4.5 model (controls token spending).
+
+    Not setting this gives similar performance to 'high'.
+    """
+
+    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]
+    """Deprecated: Use model_settings to configure parallel tool calls instead.
+
+    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["none", "minimal", "low", "medium", "high", "xhigh"]]
+    """The reasoning effort to use when generating text reasoning models"""
+
+    response_format: Optional[ResponseFormat]
+    """The response format for the model's output.
+
+    Supports text, json_object, and json_schema (structured outputs). Can be set via
+    model_settings.
+    """
+
+    strict: bool
+    """Enable strict mode for tool calling.
+
+    When true, tool schemas include strict: true and additionalProperties: false,
+    guaranteeing tool outputs match JSON schemas.
+    """
+
+    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."""