letta-nightly 0.13.0.dev20251031104146__py3-none-any.whl → 0.13.1.dev20251101010313__py3-none-any.whl

letta/schemas/llm_config.py

@@ -1,11 +1,15 @@
-from typing import TYPE_CHECKING, Literal, Optional
+from typing import TYPE_CHECKING, Annotated, Literal, Optional, Union
 
 from pydantic import BaseModel, ConfigDict, Field, model_validator
 
 from letta.constants import LETTA_MODEL_ENDPOINT
+from letta.errors import LettaInvalidArgumentError
 from letta.log import get_logger
 from letta.schemas.enums import AgentType, ProviderCategory
 
+if TYPE_CHECKING:
+    from letta.schemas.model import ModelSettings
+
 logger = get_logger(__name__)
 
 
@@ -163,6 +167,24 @@ class LLMConfig(BaseModel):
 
         return values
 
+    @model_validator(mode="before")
+    @classmethod
+    def validate_codex_reasoning_effort(cls, values):
+        """
+        Validate that gpt-5-codex models do not use 'minimal' reasoning effort.
+        Codex models require at least 'low' reasoning effort.
+        """
+        from letta.llm_api.openai_client import does_not_support_minimal_reasoning
+
+        model = values.get("model")
+        reasoning_effort = values.get("reasoning_effort")
+
+        if model and does_not_support_minimal_reasoning(model) and reasoning_effort == "minimal":
+            raise LettaInvalidArgumentError(
+                f"Model '{model}' does not support 'minimal' reasoning effort. Please use 'low', 'medium', or 'high' instead."
+            )
+        return values
+
     @classmethod
     def default_config(cls, model_name: str):
         """
@@ -233,6 +255,98 @@ class LLMConfig(BaseModel):
             + (f" [ip={self.model_endpoint}]" if self.model_endpoint else "")
         )
 
+    def _to_model(self) -> "ModelSettings":
+        """
+        Convert LLMConfig back into a Model schema (OpenAIModelSettings, AnthropicModelSettings, etc.).
+        This is the inverse of the _to_legacy_config_params() methods in model.py.
+        """
+        from letta.schemas.model import (
+            AnthropicModelSettings,
+            AnthropicThinking,
+            AzureModelSettings,
+            BedrockModelSettings,
+            DeepseekModelSettings,
+            GeminiThinkingConfig,
+            GoogleAIModelSettings,
+            GoogleVertexModelSettings,
+            GroqModelSettings,
+            Model,
+            OpenAIModelSettings,
+            OpenAIReasoning,
+            TogetherModelSettings,
+            XAIModelSettings,
+        )
+
+        if self.model_endpoint_type == "openai":
+            return OpenAIModelSettings(
+                model=self.model,
+                max_output_tokens=self.max_tokens or 4096,
+                temperature=self.temperature,
+                reasoning=OpenAIReasoning(reasoning_effort=self.reasoning_effort or "minimal"),
+            )
+        elif self.model_endpoint_type == "anthropic":
+            thinking_type = "enabled" if self.enable_reasoner else "disabled"
+            return AnthropicModelSettings(
+                model=self.model,
+                max_output_tokens=self.max_tokens or 4096,
+                temperature=self.temperature,
+                thinking=AnthropicThinking(type=thinking_type, budget_tokens=self.max_reasoning_tokens or 1024),
+                verbosity=self.verbosity,
+            )
+        elif self.model_endpoint_type == "google_ai":
+            return GoogleAIModelSettings(
+                model=self.model,
+                max_output_tokens=self.max_tokens or 65536,
+                temperature=self.temperature,
+                thinking_config=GeminiThinkingConfig(
+                    include_thoughts=self.max_reasoning_tokens > 0, thinking_budget=self.max_reasoning_tokens or 1024
+                ),
+            )
+        elif self.model_endpoint_type == "google_vertex":
+            return GoogleVertexModelSettings(
+                model=self.model,
+                max_output_tokens=self.max_tokens or 65536,
+                temperature=self.temperature,
+                thinking_config=GeminiThinkingConfig(
+                    include_thoughts=self.max_reasoning_tokens > 0, thinking_budget=self.max_reasoning_tokens or 1024
+                ),
+            )
+        elif self.model_endpoint_type == "azure":
+            return AzureModelSettings(
+                model=self.model,
+                max_output_tokens=self.max_tokens or 4096,
+                temperature=self.temperature,
+            )
+        elif self.model_endpoint_type == "xai":
+            return XAIModelSettings(
+                model=self.model,
+                max_output_tokens=self.max_tokens or 4096,
+                temperature=self.temperature,
+            )
+        elif self.model_endpoint_type == "groq":
+            return GroqModelSettings(
+                model=self.model,
+                max_output_tokens=self.max_tokens or 4096,
+                temperature=self.temperature,
+            )
+        elif self.model_endpoint_type == "deepseek":
+            return DeepseekModelSettings(
+                model=self.model,
+                max_output_tokens=self.max_tokens or 4096,
+                temperature=self.temperature,
+            )
+        elif self.model_endpoint_type == "together":
+            return TogetherModelSettings(
+                model=self.model,
+                max_output_tokens=self.max_tokens or 4096,
+                temperature=self.temperature,
+            )
+        elif self.model_endpoint_type == "bedrock":
+            return Model(model=self.model, max_output_tokens=self.max_tokens or 4096)
+        else:
+            # If we don't know the model type, use the default Model schema
+            return Model(model=self.model, max_output_tokens=self.max_tokens or 4096)
+
     @classmethod
     def is_openai_reasoning_model(cls, config: "LLMConfig") -> bool:
         from letta.llm_api.openai_client import is_openai_reasoning_model
@@ -277,6 +391,8 @@ class LLMConfig(BaseModel):
         - Google Gemini (2.5 family): force disabled until native reasoning supported
         - All others: disabled (no simulated reasoning via kwargs)
         """
+        from letta.llm_api.openai_client import does_not_support_minimal_reasoning
+
         # V1 agent policy: do not allow simulated reasoning for non-native models
         if agent_type is not None and agent_type == AgentType.letta_v1_agent:
             # OpenAI native reasoning models: always on
@@ -284,7 +400,8 @@ class LLMConfig(BaseModel):
                 config.put_inner_thoughts_in_kwargs = False
                 config.enable_reasoner = True
                 if config.reasoning_effort is None:
-                    if config.model.startswith("gpt-5"):
+                    # Codex models cannot use "minimal" reasoning effort
+                    if config.model.startswith("gpt-5") and not does_not_support_minimal_reasoning(config.model):
                         config.reasoning_effort = "minimal"
                     else:
                         config.reasoning_effort = "medium"
@@ -324,7 +441,8 @@ class LLMConfig(BaseModel):
                 config.enable_reasoner = True
                 if config.reasoning_effort is None:
                     # GPT-5 models default to minimal, others to medium
-                    if config.model.startswith("gpt-5"):
+                    # Codex models cannot use "minimal" reasoning effort
+                    if config.model.startswith("gpt-5") and not does_not_support_minimal_reasoning(config.model):
                         config.reasoning_effort = "minimal"
                     else:
                         config.reasoning_effort = "medium"
@@ -357,7 +475,8 @@ class LLMConfig(BaseModel):
                 config.put_inner_thoughts_in_kwargs = False
                 if config.reasoning_effort is None:
                     # GPT-5 models default to minimal, others to medium
-                    if config.model.startswith("gpt-5"):
+                    # Codex models cannot use "minimal" reasoning effort
+                    if config.model.startswith("gpt-5") and not does_not_support_minimal_reasoning(config.model):
                         config.reasoning_effort = "minimal"
                     else:
                         config.reasoning_effort = "medium"

letta/schemas/mcp.py

@@ -13,13 +13,14 @@ from letta.functions.mcp_client.types import (
     StreamableHTTPServerConfig,
 )
 from letta.orm.mcp_oauth import OAuthSessionStatus
+from letta.schemas.enums import PrimitiveType
 from letta.schemas.letta_base import LettaBase
 from letta.schemas.secret import Secret
 from letta.settings import settings
 
 
 class BaseMCPServer(LettaBase):
-    __id_prefix__ = "mcp_server"
+    __id_prefix__ = PrimitiveType.MCP_SERVER.value
 
 
 class MCPServer(BaseMCPServer):
@@ -178,7 +179,7 @@ UpdateMCPServer = Union[UpdateSSEMCPServer, UpdateStdioMCPServer, UpdateStreamab
 
 # OAuth-related schemas
 class BaseMCPOAuth(LettaBase):
-    __id_prefix__ = "mcp-oauth"
+    __id_prefix__ = PrimitiveType.MCP_OAUTH.value
 
 
 class MCPOAuthSession(BaseMCPOAuth):

letta/schemas/mcp_server.py

@@ -13,12 +13,13 @@ from letta.functions.mcp_client.types import (
     StreamableHTTPServerConfig,
 )
 from letta.orm.mcp_oauth import OAuthSessionStatus
+from letta.schemas.enums import PrimitiveType
 from letta.schemas.letta_base import LettaBase
 from letta.schemas.secret import Secret
 
 
 class BaseMCPServer(LettaBase):
-    __id_prefix__ = "mcp_server"
+    __id_prefix__ = PrimitiveType.MCP_SERVER.value
 
 
 # Create Schemas (for POST requests)
@@ -101,7 +102,7 @@ UpdateMCPServerUnion = Union[UpdateStdioMCPServer, UpdateSSEMCPServer, UpdateStr
 
 # OAuth-related schemas
 class BaseMCPOAuth(LettaBase):
-    __id_prefix__ = "mcp-oauth"
+    __id_prefix__ = PrimitiveType.MCP_OAUTH.value
 
 
 class MCPOAuthSession(BaseMCPOAuth):

letta/schemas/message.py

@@ -13,7 +13,6 @@ from datetime import datetime, timezone
 from enum import Enum
 from typing import Annotated, Any, Dict, List, Literal, Optional, Union
 
-from letta_client import LettaMessageUnion
 from openai.types.chat.chat_completion_message_tool_call import ChatCompletionMessageToolCall as OpenAIToolCall, Function as OpenAIFunction
 from openai.types.responses import ResponseReasoningItem
 from pydantic import BaseModel, Field, field_validator, model_validator
@@ -57,6 +56,14 @@ from letta.system import unpack_message
 from letta.utils import parse_json, validate_function_response
 
 
+def truncate_tool_return(content: Optional[str], limit: Optional[int]) -> Optional[str]:
+    if limit is None or content is None:
+        return content
+    if len(content) <= limit:
+        return content
+    return content[:limit] + f"... [truncated {len(content) - limit} chars]"
+
+
 def add_inner_thoughts_to_tool_call(
     tool_call: OpenAIToolCall,
     inner_thoughts: str,
@@ -1091,6 +1098,7 @@ class Message(BaseMessage):
         # if true, then treat the content field as AssistantMessage
         native_content: bool = False,
         strip_request_heartbeat: bool = False,
+        tool_return_truncation_chars: Optional[int] = None,
     ) -> dict | None:
         """Go from Message class to ChatCompletion message object"""
         assert not (native_content and put_inner_thoughts_in_kwargs), "native_content and put_inner_thoughts_in_kwargs cannot both be true"
@@ -1139,8 +1147,14 @@ class Message(BaseMessage):
                 assert self.tool_calls is not None or text_content is not None, vars(self)
             except AssertionError as e:
                 # relax check if this message only contains reasoning content
-                if self.content is not None and len(self.content) > 0 and isinstance(self.content[0], ReasoningContent):
-                    return None
+                if self.content is not None and len(self.content) > 0:
+                    # Check if all non-empty content is reasoning-related
+                    all_reasoning = all(
+                        isinstance(c, (ReasoningContent, SummarizedReasoningContent, OmittedReasoningContent, RedactedReasoningContent))
+                        for c in self.content
+                    )
+                    if all_reasoning:
+                        return None
                 raise e
 
             # if native content, then put it directly inside the content
@@ -1181,12 +1195,26 @@ class Message(BaseMessage):
                         tool_call_dict["id"] = tool_call_dict["id"][:max_tool_id_length]
 
         elif self.role == "tool":
-            assert self.tool_call_id is not None, vars(self)
-            openai_message = {
-                "content": text_content,
-                "role": self.role,
-                "tool_call_id": self.tool_call_id[:max_tool_id_length] if max_tool_id_length else self.tool_call_id,
-            }
+            # Handle tool returns - if tool_returns exists, use the first one
+            if self.tool_returns and len(self.tool_returns) > 0:
+                tool_return = self.tool_returns[0]
+                if not tool_return.tool_call_id:
+                    raise TypeError("OpenAI API requires tool_call_id to be set.")
+                func_response = truncate_tool_return(tool_return.func_response, tool_return_truncation_chars)
+                openai_message = {
+                    "content": func_response,
+                    "role": self.role,
+                    "tool_call_id": tool_return.tool_call_id[:max_tool_id_length] if max_tool_id_length else tool_return.tool_call_id,
+                }
+            else:
+                # Legacy fallback for old message format
+                assert self.tool_call_id is not None, vars(self)
+                legacy_content = truncate_tool_return(text_content, tool_return_truncation_chars)
+                openai_message = {
+                    "content": legacy_content,
+                    "role": self.role,
+                    "tool_call_id": self.tool_call_id[:max_tool_id_length] if max_tool_id_length else self.tool_call_id,
+                }
 
         else:
             raise ValueError(self.role)
@@ -1215,22 +1243,42 @@ class Message(BaseMessage):
         max_tool_id_length: int = TOOL_CALL_ID_MAX_LEN,
         put_inner_thoughts_in_kwargs: bool = False,
         use_developer_message: bool = False,
+        tool_return_truncation_chars: Optional[int] = None,
     ) -> List[dict]:
         messages = Message.filter_messages_for_llm_api(messages)
-        result = [
-            m.to_openai_dict(
+        result: List[dict] = []
+
+        for m in messages:
+            # Special case: OpenAI Chat Completions requires a separate tool message per tool_call_id
+            # If we have multiple explicit tool_returns on a single Message, expand into one dict per return
+            if m.role == MessageRole.tool and m.tool_returns and len(m.tool_returns) > 0:
+                for tr in m.tool_returns:
+                    if not tr.tool_call_id:
+                        raise TypeError("ToolReturn came back without a tool_call_id.")
+                    result.append(
+                        {
+                            "content": tr.func_response,
+                            "role": "tool",
+                            "tool_call_id": tr.tool_call_id[:max_tool_id_length] if max_tool_id_length else tr.tool_call_id,
+                        }
+                    )
+                continue
+
+            d = m.to_openai_dict(
                 max_tool_id_length=max_tool_id_length,
                 put_inner_thoughts_in_kwargs=put_inner_thoughts_in_kwargs,
                 use_developer_message=use_developer_message,
+                tool_return_truncation_chars=tool_return_truncation_chars,
             )
-            for m in messages
-        ]
-        result = [m for m in result if m is not None]
+            if d is not None:
+                result.append(d)
+
         return result
 
     def to_openai_responses_dicts(
         self,
         max_tool_id_length: int = TOOL_CALL_ID_MAX_LEN,
+        tool_return_truncation_chars: Optional[int] = None,
     ) -> List[dict]:
         """Go from Message class to ChatCompletion message object"""
 
@@ -1306,15 +1354,31 @@ class Message(BaseMessage):
                     )
 
         elif self.role == "tool":
-            assert self.tool_call_id is not None, vars(self)
-            assert len(self.content) == 1 and isinstance(self.content[0], TextContent), vars(self)
-            message_dicts.append(
-                {
-                    "type": "function_call_output",
-                    "call_id": self.tool_call_id[:max_tool_id_length] if max_tool_id_length else self.tool_call_id,
-                    "output": self.content[0].text,
-                }
-            )
+            # Handle tool returns - similar pattern to Anthropic
+            if self.tool_returns:
+                for tool_return in self.tool_returns:
+                    if not tool_return.tool_call_id:
+                        raise TypeError("OpenAI Responses API requires tool_call_id to be set.")
+                    func_response = truncate_tool_return(tool_return.func_response, tool_return_truncation_chars)
+                    message_dicts.append(
+                        {
+                            "type": "function_call_output",
+                            "call_id": tool_return.tool_call_id[:max_tool_id_length] if max_tool_id_length else tool_return.tool_call_id,
+                            "output": func_response,
+                        }
+                    )
+            else:
+                # Legacy fallback for old message format
+                assert self.tool_call_id is not None, vars(self)
+                assert len(self.content) == 1 and isinstance(self.content[0], TextContent), vars(self)
+                legacy_output = truncate_tool_return(self.content[0].text, tool_return_truncation_chars)
+                message_dicts.append(
+                    {
+                        "type": "function_call_output",
+                        "call_id": self.tool_call_id[:max_tool_id_length] if max_tool_id_length else self.tool_call_id,
+                        "output": legacy_output,
+                    }
+                )
 
         else:
             raise ValueError(self.role)
@@ -1325,11 +1389,16 @@ class Message(BaseMessage):
     def to_openai_responses_dicts_from_list(
         messages: List[Message],
         max_tool_id_length: int = TOOL_CALL_ID_MAX_LEN,
+        tool_return_truncation_chars: Optional[int] = None,
     ) -> List[dict]:
         messages = Message.filter_messages_for_llm_api(messages)
         result = []
         for message in messages:
-            result.extend(message.to_openai_responses_dicts(max_tool_id_length=max_tool_id_length))
+            result.extend(
+                message.to_openai_responses_dicts(
+                    max_tool_id_length=max_tool_id_length, tool_return_truncation_chars=tool_return_truncation_chars
+                )
+            )
         return result
 
     def to_anthropic_dict(
@@ -1340,6 +1409,7 @@ class Message(BaseMessage):
         # if true, then treat the content field as AssistantMessage
         native_content: bool = False,
         strip_request_heartbeat: bool = False,
+        tool_return_truncation_chars: Optional[int] = None,
     ) -> dict | None:
         """
         Convert to an Anthropic message dictionary
@@ -1515,11 +1585,12 @@ class Message(BaseMessage):
             for tool_return in self.tool_returns:
                 if not tool_return.tool_call_id:
                     raise TypeError("Anthropic API requires tool_use_id to be set.")
+                func_response = truncate_tool_return(tool_return.func_response, tool_return_truncation_chars)
                 content.append(
                     {
                         "type": "tool_result",
                         "tool_use_id": tool_return.tool_call_id,
-                        "content": tool_return.func_response,
+                        "content": func_response,
                     }
                 )
             if content:
@@ -1532,6 +1603,7 @@ class Message(BaseMessage):
                     raise TypeError("Anthropic API requires tool_use_id to be set.")
 
                 # This is for legacy reasons
+                legacy_content = truncate_tool_return(text_content, tool_return_truncation_chars)
                 anthropic_message = {
                     "role": "user",  # NOTE: diff
                     "content": [
@@ -1539,7 +1611,7 @@ class Message(BaseMessage):
                         {
                             "type": "tool_result",
                             "tool_use_id": self.tool_call_id,
-                            "content": text_content,
+                            "content": legacy_content,
                         }
                     ],
                 }
@@ -1558,6 +1630,7 @@ class Message(BaseMessage):
         # if true, then treat the content field as AssistantMessage
         native_content: bool = False,
         strip_request_heartbeat: bool = False,
+        tool_return_truncation_chars: Optional[int] = None,
     ) -> List[dict]:
         messages = Message.filter_messages_for_llm_api(messages)
         result = [
@@ -1567,6 +1640,7 @@ class Message(BaseMessage):
                 put_inner_thoughts_in_kwargs=put_inner_thoughts_in_kwargs,
                 native_content=native_content,
                 strip_request_heartbeat=strip_request_heartbeat,
+                tool_return_truncation_chars=tool_return_truncation_chars,
             )
             for m in messages
         ]
@@ -1580,6 +1654,7 @@ class Message(BaseMessage):
         # if true, then treat the content field as AssistantMessage
         native_content: bool = False,
         strip_request_heartbeat: bool = False,
+        tool_return_truncation_chars: Optional[int] = None,
     ) -> dict | None:
         """
         Go from Message class to Google AI REST message object
@@ -1717,34 +1792,75 @@ class Message(BaseMessage):
 
         elif self.role == "tool":
             # NOTE: Significantly different tool calling format, more similar to function calling format
-            assert self.tool_call_id is not None, vars(self)
 
-            if self.name is None:
-                logger.warning("Couldn't find function name on tool call, defaulting to tool ID instead.")
-                function_name = self.tool_call_id
+            # Handle tool returns - similar pattern to Anthropic
+            if self.tool_returns:
+                parts = []
+                for tool_return in self.tool_returns:
+                    if not tool_return.tool_call_id:
+                        raise TypeError("Google AI API requires tool_call_id to be set.")
+
+                    # Use the function name if available, otherwise use tool_call_id
+                    function_name = self.name if self.name else tool_return.tool_call_id
+
+                    # Truncate the tool return if needed
+                    func_response = truncate_tool_return(tool_return.func_response, tool_return_truncation_chars)
+
+                    # NOTE: Google AI API wants the function response as JSON only, no string
+                    try:
+                        function_response = parse_json(func_response)
+                    except:
+                        function_response = {"function_response": func_response}
+
+                    parts.append(
+                        {
+                            "functionResponse": {
+                                "name": function_name,
+                                "response": {
+                                    "name": function_name,  # NOTE: name twice... why?
+                                    "content": function_response,
+                                },
+                            }
+                        }
+                    )
+
+                google_ai_message = {
+                    "role": "function",
+                    "parts": parts,
+                }
             else:
-                function_name = self.name
+                # Legacy fallback for old message format
+                assert self.tool_call_id is not None, vars(self)
 
-            # NOTE: Google AI API wants the function response as JSON only, no string
-            try:
-                function_response = parse_json(text_content)
-            except:
-                function_response = {"function_response": text_content}
+                if self.name is None:
+                    logger.warning("Couldn't find function name on tool call, defaulting to tool ID instead.")
+                    function_name = self.tool_call_id
+                else:
+                    function_name = self.name
 
-            google_ai_message = {
-                "role": "function",
-                "parts": [
-                    {
-                        "functionResponse": {
-                            "name": function_name,
-                            "response": {
-                                "name": function_name,  # NOTE: name twice... why?
-                                "content": function_response,
-                            },
+                # Truncate the legacy content if needed
+                legacy_content = truncate_tool_return(text_content, tool_return_truncation_chars)
+
+                # NOTE: Google AI API wants the function response as JSON only, no string
+                try:
+                    function_response = parse_json(legacy_content)
+                except:
+                    function_response = {"function_response": legacy_content}
+
+                google_ai_message = {
+                    "role": "function",
+                    "parts": [
+                        {
+                            "functionResponse": {
+                                "name": function_name,
+                                "response": {
+                                    "name": function_name,  # NOTE: name twice... why?
+                                    "content": function_response,
+                                },
+                            }
                         }
-                    }
-                ],
-            }
+                    ],
+                }
 
         else:
             raise ValueError(self.role)
@@ -1765,6 +1881,7 @@ class Message(BaseMessage):
         current_model: str,
         put_inner_thoughts_in_kwargs: bool = True,
         native_content: bool = False,
+        tool_return_truncation_chars: Optional[int] = None,
     ):
         messages = Message.filter_messages_for_llm_api(messages)
         result = [
@@ -1772,6 +1889,7 @@ class Message(BaseMessage):
                 current_model=current_model,
                 put_inner_thoughts_in_kwargs=put_inner_thoughts_in_kwargs,
                 native_content=native_content,
+                tool_return_truncation_chars=tool_return_truncation_chars,
             )
             for m in messages
         ]