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

letta/schemas/environment_variables.py

@@ -2,6 +2,7 @@ from typing import Optional
 
 from pydantic import Field
 
+from letta.schemas.enums import PrimitiveType
 from letta.schemas.letta_base import LettaBase, OrmMetadataBase
 from letta.schemas.secret import Secret
 from letta.settings import settings
@@ -52,7 +53,7 @@ class EnvironmentVariableUpdateBase(LettaBase):
 
 # Environment Variable
 class SandboxEnvironmentVariableBase(EnvironmentVariableBase):
-    __id_prefix__ = "sandbox-env"
+    __id_prefix__ = PrimitiveType.SANDBOX_ENV.value
     sandbox_config_id: str = Field(..., description="The ID of the sandbox config this environment variable belongs to.")
 
 
@@ -70,7 +71,7 @@ class SandboxEnvironmentVariableUpdate(EnvironmentVariableUpdateBase):
 
 # Agent-Specific Environment Variable
 class AgentEnvironmentVariableBase(EnvironmentVariableBase):
-    __id_prefix__ = "agent-env"
+    __id_prefix__ = PrimitiveType.AGENT_ENV.value
     agent_id: str = Field(..., description="The ID of the agent this environment variable belongs to.")
 
 

letta/schemas/group.py

@@ -34,7 +34,7 @@ class Group(GroupBase):
     template_id: Optional[str] = Field(None, description="The id of the template.")
     base_template_id: Optional[str] = Field(None, description="The base template id.")
     deployment_id: Optional[str] = Field(None, description="The id of the deployment.")
-    shared_block_ids: List[str] = Field([], description="")
+    shared_block_ids: List[str] = Field([], description="", deprecated=True)
     # Pattern fields
     manager_agent_id: Optional[str] = Field(None, description="")
     termination_token: Optional[str] = Field(None, description="")
@@ -174,7 +174,7 @@ class GroupCreate(BaseModel):
     description: str = Field(..., description="")
     manager_config: ManagerConfigUnion = Field(RoundRobinManager(), description="")
     project_id: Optional[str] = Field(None, description="The associated project id.")
-    shared_block_ids: List[str] = Field([], description="")
+    shared_block_ids: List[str] = Field([], description="", deprecated=True)
     hidden: Optional[bool] = Field(
         None,
         description="If set to True, the group will be hidden.",
@@ -194,4 +194,4 @@ class GroupUpdate(BaseModel):
     description: Optional[str] = Field(None, description="")
     manager_config: Optional[ManagerConfigUpdateUnion] = Field(None, description="")
     project_id: Optional[str] = Field(None, description="The associated project id.")
-    shared_block_ids: Optional[List[str]] = Field(None, description="")
+    shared_block_ids: Optional[List[str]] = Field(None, description="", deprecated=True)

letta/schemas/letta_response.py

@@ -4,11 +4,24 @@ import re
 from datetime import datetime
 from typing import List, Union
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, RootModel
 
 from letta.helpers.json_helpers import json_dumps
 from letta.schemas.enums import JobStatus, MessageStreamStatus
-from letta.schemas.letta_message import LettaMessage, LettaMessageUnion
+from letta.schemas.letta_message import (
+    ApprovalRequestMessage,
+    ApprovalResponseMessage,
+    AssistantMessage,
+    HiddenReasoningMessage,
+    LettaMessage,
+    LettaMessageUnion,
+    LettaPing,
+    ReasoningMessage,
+    SystemMessage,
+    ToolCallMessage,
+    ToolReturnMessage,
+    UserMessage,
+)
 from letta.schemas.letta_stop_reason import LettaStopReason
 from letta.schemas.message import Message
 from letta.schemas.usage import LettaUsageStatistics
@@ -170,8 +183,27 @@ class LettaResponse(BaseModel):
         return html_output
 
 
-# The streaming response is either [DONE], [DONE_STEP], [DONE], an error, or a LettaMessage
-LettaStreamingResponse = Union[LettaMessage, MessageStreamStatus, LettaStopReason, LettaUsageStatistics]
+# The streaming response can be any of the individual message types, plus metadata types
+class LettaStreamingResponse(RootModel):
+    """
+    Streaming response type for Server-Sent Events (SSE) endpoints.
+    Each event in the stream will be one of these types.
+    """
+
+    root: Union[
+        SystemMessage,
+        UserMessage,
+        ReasoningMessage,
+        HiddenReasoningMessage,
+        ToolCallMessage,
+        ToolReturnMessage,
+        AssistantMessage,
+        ApprovalRequestMessage,
+        ApprovalResponseMessage,
+        LettaPing,
+        LettaStopReason,
+        LettaUsageStatistics,
+    ] = Field(..., discriminator="message_type")
 
 
 class LettaBatchResponse(BaseModel):

letta/schemas/llm_batch_job.py

@@ -5,7 +5,7 @@ from anthropic.types.beta.messages import BetaMessageBatch, BetaMessageBatchIndi
 from pydantic import BaseModel, Field
 
 from letta.helpers import ToolRulesSolver
-from letta.schemas.enums import AgentStepStatus, JobStatus, ProviderType
+from letta.schemas.enums import AgentStepStatus, JobStatus, PrimitiveType, ProviderType
 from letta.schemas.letta_base import OrmMetadataBase
 from letta.schemas.llm_config import LLMConfig
 
@@ -16,7 +16,7 @@ class AgentStepState(BaseModel):
 
 
 class LLMBatchItemBase(OrmMetadataBase, validate_assignment=True):
-    __id_prefix__ = "batch_item"
+    __id_prefix__ = PrimitiveType.BATCH_ITEM.value
 
 
 class LLMBatchItem(LLMBatchItemBase, validate_assignment=True):
@@ -47,7 +47,7 @@ class LLMBatchJob(OrmMetadataBase, validate_assignment=True):
     Each job corresponds to one API call that sends multiple messages to the LLM provider, and aggregates responses across all agent submissions.
     """
 
-    __id_prefix__ = "batch_req"
+    __id_prefix__ = PrimitiveType.BATCH_REQUEST.value
 
     id: Optional[str] = Field(None, description="The id of the batch job. Assigned by the database.")
     status: JobStatus = Field(..., description="The current status of the batch (e.g., created, in_progress, done).")

letta/schemas/llm_config.py

@@ -3,6 +3,7 @@ from typing import TYPE_CHECKING, Literal, Optional
 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
 
@@ -163,6 +164,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):
         """
@@ -277,6 +296,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 +305,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 +346,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 +380,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
         ]

letta/schemas/organization.py

@@ -4,12 +4,13 @@ from typing import Optional
 from pydantic import Field
 
 from letta.helpers.datetime_helpers import get_utc_time
+from letta.schemas.enums import PrimitiveType
 from letta.schemas.letta_base import LettaBase
 from letta.utils import create_random_username
 
 
 class OrganizationBase(LettaBase):
-    __id_prefix__ = "org"
+    __id_prefix__ = PrimitiveType.ORGANIZATION.value
 
 
 class Organization(OrganizationBase):

letta/schemas/passage.py

@@ -6,11 +6,12 @@ from pydantic import Field, field_validator
 from letta.constants import MAX_EMBEDDING_DIM
 from letta.helpers.datetime_helpers import get_utc_time
 from letta.schemas.embedding_config import EmbeddingConfig
+from letta.schemas.enums import PrimitiveType
 from letta.schemas.letta_base import OrmMetadataBase
 
 
 class PassageBase(OrmMetadataBase):
-    __id_prefix__ = "passage"
+    __id_prefix__ = PrimitiveType.PASSAGE.value
 
     is_deleted: bool = Field(False, description="Whether this passage is deleted or not.")
 

letta/schemas/provider_trace.py

@@ -6,11 +6,12 @@ from typing import Any, Dict, Optional
 from pydantic import BaseModel, Field
 
 from letta.helpers.datetime_helpers import get_utc_time
+from letta.schemas.enums import PrimitiveType
 from letta.schemas.letta_base import OrmMetadataBase
 
 
 class BaseProviderTrace(OrmMetadataBase):
-    __id_prefix__ = "provider_trace"
+    __id_prefix__ = PrimitiveType.PROVIDER_TRACE.value
 
 
 class ProviderTraceCreate(BaseModel):