letta-nightly 0.11.7.dev20251008104128__py3-none-any.whl → 0.12.0.dev20251009203644__py3-none-any.whl

letta/schemas/letta_message.py

@@ -190,7 +190,8 @@ class ToolCallMessage(LettaMessage):
     message_type: Literal[MessageType.tool_call_message] = Field(
         default=MessageType.tool_call_message, description="The type of the message."
     )
-    tool_call: Union[ToolCall, ToolCallDelta]
+    tool_call: Union[ToolCall, ToolCallDelta] = Field(..., deprecated=True)
+    tool_calls: Optional[Union[List[ToolCall], ToolCallDelta]] = None
 
     def model_dump(self, *args, **kwargs):
         """
@@ -198,8 +199,14 @@ class ToolCallMessage(LettaMessage):
         """
         kwargs["exclude_none"] = True
         data = super().model_dump(*args, **kwargs)
-        if isinstance(data["tool_call"], dict):
+        if isinstance(data.get("tool_call"), dict):
             data["tool_call"] = {k: v for k, v in data["tool_call"].items() if v is not None}
+        if isinstance(data.get("tool_calls"), dict):
+            data["tool_calls"] = {k: v for k, v in data["tool_calls"].items() if v is not None}
+        elif isinstance(data.get("tool_calls"), list):
+            data["tool_calls"] = [
+                {k: v for k, v in item.items() if v is not None} if isinstance(item, dict) else item for item in data["tool_calls"]
+            ]
         return data
 
     class Config:
@@ -226,6 +233,14 @@ class ToolCallMessage(LettaMessage):
         return v
 
 
+class ToolReturn(BaseModel):
+    tool_return: str
+    status: Literal["success", "error"]
+    tool_call_id: str
+    stdout: Optional[List[str]] = None
+    stderr: Optional[List[str]] = None
+
+
 class ToolReturnMessage(LettaMessage):
     """
     A message representing the return value of a tool call (generated by Letta executing the requested tool).
@@ -234,21 +249,23 @@ class ToolReturnMessage(LettaMessage):
         id (str): The ID of the message
         date (datetime): The date the message was created in ISO format
         name (Optional[str]): The name of the sender of the message
-        tool_return (str): The return value of the tool
-        status (Literal["success", "error"]): The status of the tool call
-        tool_call_id (str): A unique identifier for the tool call that generated this message
-        stdout (Optional[List(str)]): Captured stdout (e.g. prints, logs) from the tool invocation
-        stderr (Optional[List(str)]): Captured stderr from the tool invocation
+        tool_return (str): The return value of the tool (deprecated, use tool_returns)
+        status (Literal["success", "error"]): The status of the tool call (deprecated, use tool_returns)
+        tool_call_id (str): A unique identifier for the tool call that generated this message (deprecated, use tool_returns)
+        stdout (Optional[List(str)]): Captured stdout (e.g. prints, logs) from the tool invocation (deprecated, use tool_returns)
+        stderr (Optional[List(str)]): Captured stderr from the tool invocation (deprecated, use tool_returns)
+        tool_returns (Optional[List[ToolReturn]]): List of tool returns for multi-tool support
     """
 
     message_type: Literal[MessageType.tool_return_message] = Field(
         default=MessageType.tool_return_message, description="The type of the message."
     )
-    tool_return: str
-    status: Literal["success", "error"]
-    tool_call_id: str
-    stdout: Optional[List[str]] = None
-    stderr: Optional[List[str]] = None
+    tool_return: str = Field(..., deprecated=True)
+    status: Literal["success", "error"] = Field(..., deprecated=True)
+    tool_call_id: str = Field(..., deprecated=True)
+    stdout: Optional[List[str]] = Field(None, deprecated=True)
+    stderr: Optional[List[str]] = Field(None, deprecated=True)
+    tool_returns: Optional[List[ToolReturn]] = None
 
 
 class ApprovalRequestMessage(LettaMessage):

letta/schemas/message.py

@@ -492,23 +492,27 @@ class Message(BaseMessage):
         assistant_message_tool_kwarg: str = DEFAULT_MESSAGE_TOOL_KWARG,
     ) -> List[LettaMessage]:
         messages = []
-        # This is type FunctionCall
-        for tool_call in self.tool_calls:
-            otid = Message.generate_otid_from_id(self.id, current_message_count + len(messages))
-            # If we're supporting using assistant message,
-            # then we want to treat certain function calls as a special case
-            if use_assistant_message and tool_call.function.name == assistant_message_tool_name:
-                # We need to unpack the actual message contents from the function call
-                try:
-                    func_args = parse_json(tool_call.function.arguments)
-                    message_string = validate_function_response(func_args[assistant_message_tool_kwarg], 0, truncate=False)
-                except KeyError:
-                    raise ValueError(f"Function call {tool_call.function.name} missing {assistant_message_tool_kwarg} argument")
+
+        # If assistant mode is off, just create one ToolCallMessage with all tool calls
+        if not use_assistant_message:
+            all_tool_call_objs = [
+                ToolCall(
+                    name=tool_call.function.name,
+                    arguments=tool_call.function.arguments,
+                    tool_call_id=tool_call.id,
+                )
+                for tool_call in self.tool_calls
+            ]
+
+            if all_tool_call_objs:
+                otid = Message.generate_otid_from_id(self.id, current_message_count)
                 messages.append(
-                    AssistantMessage(
+                    ToolCallMessage(
                         id=self.id,
                         date=self.created_at,
-                        content=message_string,
+                        # use first tool call for the deprecated field
+                        tool_call=all_tool_call_objs[0],
+                        tool_calls=all_tool_call_objs,
                         name=self.name,
                         otid=otid,
                         sender_id=self.sender_id,
@@ -517,16 +521,41 @@ class Message(BaseMessage):
                         run_id=self.run_id,
                     )
                 )
-            else:
+            return messages
+
+        collected_tool_calls = []
+
+        for tool_call in self.tool_calls:
+            otid = Message.generate_otid_from_id(self.id, current_message_count + len(messages))
+
+            if tool_call.function.name == assistant_message_tool_name:
+                if collected_tool_calls:
+                    tool_call_message = ToolCallMessage(
+                        id=self.id,
+                        date=self.created_at,
+                        # use first tool call for the deprecated field
+                        tool_call=collected_tool_calls[0],
+                        tool_calls=collected_tool_calls.copy(),
+                        name=self.name,
+                        otid=Message.generate_otid_from_id(self.id, current_message_count + len(messages)),
+                        sender_id=self.sender_id,
+                        step_id=self.step_id,
+                        is_err=self.is_err,
+                        run_id=self.run_id,
+                    )
+                    messages.append(tool_call_message)
+                    collected_tool_calls = []  # reset the collection
+
+                try:
+                    func_args = parse_json(tool_call.function.arguments)
+                    message_string = validate_function_response(func_args[assistant_message_tool_kwarg], 0, truncate=False)
+                except KeyError:
+                    raise ValueError(f"Function call {tool_call.function.name} missing {assistant_message_tool_kwarg} argument")
                 messages.append(
-                    ToolCallMessage(
+                    AssistantMessage(
                         id=self.id,
                         date=self.created_at,
-                        tool_call=ToolCall(
-                            name=tool_call.function.name,
-                            arguments=tool_call.function.arguments,
-                            tool_call_id=tool_call.id,
-                        ),
+                        content=message_string,
                         name=self.name,
                         otid=otid,
                         sender_id=self.sender_id,
@@ -535,6 +564,32 @@ class Message(BaseMessage):
                         run_id=self.run_id,
                     )
                 )
+            else:
+                # non-assistant tool call, collect it
+                tool_call_obj = ToolCall(
+                    name=tool_call.function.name,
+                    arguments=tool_call.function.arguments,
+                    tool_call_id=tool_call.id,
+                )
+                collected_tool_calls.append(tool_call_obj)
+
+        # flush any remaining collected tool calls
+        if collected_tool_calls:
+            tool_call_message = ToolCallMessage(
+                id=self.id,
+                date=self.created_at,
+                # use first tool call for the deprecated field
+                tool_call=collected_tool_calls[0],
+                tool_calls=collected_tool_calls,
+                name=self.name,
+                otid=Message.generate_otid_from_id(self.id, current_message_count + len(messages)),
+                sender_id=self.sender_id,
+                step_id=self.step_id,
+                is_err=self.is_err,
+                run_id=self.run_id,
+            )
+            messages.append(tool_call_message)
+
         return messages
 
     def _convert_tool_return_message(self) -> List[ToolReturnMessage]:
@@ -556,6 +611,13 @@ class Message(BaseMessage):
         if self.role != MessageRole.tool:
             raise ValueError(f"Cannot convert message of type {self.role} to ToolReturnMessage")
 
+        # This is a very special buggy case during the double writing period
+        # where there is no tool call id on the tool return object, but it exists top level
+        # This is meant to be a short term patch - this can happen when people are using old agent files that were exported
+        # during a specific migration state
+        if len(self.tool_returns) == 1 and self.tool_call_id and not self.tool_returns[0].tool_call_id:
+            self.tool_returns[0].tool_call_id = self.tool_call_id
+
         if self.tool_returns:
             return self._convert_explicit_tool_returns()
 
@@ -647,6 +709,16 @@ class Message(BaseMessage):
         Returns:
             Configured ToolReturnMessage instance
         """
+        from letta.schemas.letta_message import ToolReturn as ToolReturnSchema
+
+        tool_return_obj = ToolReturnSchema(
+            tool_return=message_text,
+            status=status,
+            tool_call_id=tool_call_id,
+            stdout=stdout,
+            stderr=stderr,
+        )
+
         return ToolReturnMessage(
             id=self.id,
             date=self.created_at,
@@ -655,6 +727,7 @@ class Message(BaseMessage):
             tool_call_id=tool_call_id,
             stdout=stdout,
             stderr=stderr,
+            tool_returns=[tool_return_obj],
             name=self.name,
             otid=Message.generate_otid_from_id(self.id, otid_index),
             sender_id=self.sender_id,
@@ -965,7 +1038,13 @@ class Message(BaseMessage):
             }
 
         elif self.role == "assistant" or self.role == "approval":
-            assert self.tool_calls is not None or text_content is not None, vars(self)
+            try:
+                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
+                raise e
 
             # if native content, then put it directly inside the content
             if native_content:
@@ -1040,6 +1119,7 @@ class Message(BaseMessage):
         put_inner_thoughts_in_kwargs: bool = False,
         use_developer_message: bool = False,
     ) -> List[dict]:
+        messages = Message.filter_messages_for_llm_api(messages)
         result = [
             m.to_openai_dict(
                 max_tool_id_length=max_tool_id_length,
@@ -1149,6 +1229,7 @@ class Message(BaseMessage):
         messages: List[Message],
         max_tool_id_length: int = TOOL_CALL_ID_MAX_LEN,
     ) -> 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))
@@ -1156,6 +1237,7 @@ class Message(BaseMessage):
 
     def to_anthropic_dict(
         self,
+        current_model: str,
         inner_thoughts_xml_tag="thinking",
         put_inner_thoughts_in_kwargs: bool = False,
         # if true, then treat the content field as AssistantMessage
@@ -1242,20 +1324,22 @@ class Message(BaseMessage):
                     for content_part in self.content:
                         # TextContent, ImageContent, ToolCallContent, ToolReturnContent, ReasoningContent, RedactedReasoningContent, OmittedReasoningContent
                         if isinstance(content_part, ReasoningContent):
-                            content.append(
-                                {
-                                    "type": "thinking",
-                                    "thinking": content_part.reasoning,
-                                    "signature": content_part.signature,
-                                }
-                            )
+                            if current_model == self.model:
+                                content.append(
+                                    {
+                                        "type": "thinking",
+                                        "thinking": content_part.reasoning,
+                                        "signature": content_part.signature,
+                                    }
+                                )
                         elif isinstance(content_part, RedactedReasoningContent):
-                            content.append(
-                                {
-                                    "type": "redacted_thinking",
-                                    "data": content_part.data,
-                                }
-                            )
+                            if current_model == self.model:
+                                content.append(
+                                    {
+                                        "type": "redacted_thinking",
+                                        "data": content_part.data,
+                                    }
+                                )
                         elif isinstance(content_part, TextContent):
                             content.append(
                                 {
@@ -1272,20 +1356,22 @@ class Message(BaseMessage):
                 if self.content is not None and len(self.content) >= 1:
                     for content_part in self.content:
                         if isinstance(content_part, ReasoningContent):
-                            content.append(
-                                {
-                                    "type": "thinking",
-                                    "thinking": content_part.reasoning,
-                                    "signature": content_part.signature,
-                                }
-                            )
+                            if current_model == self.model:
+                                content.append(
+                                    {
+                                        "type": "thinking",
+                                        "thinking": content_part.reasoning,
+                                        "signature": content_part.signature,
+                                    }
+                                )
                         if isinstance(content_part, RedactedReasoningContent):
-                            content.append(
-                                {
-                                    "type": "redacted_thinking",
-                                    "data": content_part.data,
-                                }
-                            )
+                            if current_model == self.model:
+                                content.append(
+                                    {
+                                        "type": "redacted_thinking",
+                                        "data": content_part.data,
+                                    }
+                                )
                         if isinstance(content_part, TextContent):
                             content.append(
                                 {
@@ -1349,14 +1435,17 @@ class Message(BaseMessage):
     @staticmethod
     def to_anthropic_dicts_from_list(
         messages: List[Message],
+        current_model: str,
         inner_thoughts_xml_tag: str = "thinking",
         put_inner_thoughts_in_kwargs: bool = False,
         # if true, then treat the content field as AssistantMessage
         native_content: bool = False,
         strip_request_heartbeat: bool = False,
     ) -> List[dict]:
+        messages = Message.filter_messages_for_llm_api(messages)
         result = [
             m.to_anthropic_dict(
+                current_model=current_model,
                 inner_thoughts_xml_tag=inner_thoughts_xml_tag,
                 put_inner_thoughts_in_kwargs=put_inner_thoughts_in_kwargs,
                 native_content=native_content,
@@ -1369,6 +1458,7 @@ class Message(BaseMessage):
 
     def to_google_dict(
         self,
+        current_model: str,
         put_inner_thoughts_in_kwargs: bool = True,
         # if true, then treat the content field as AssistantMessage
         native_content: bool = False,
@@ -1484,11 +1574,12 @@ class Message(BaseMessage):
                 for content in self.content:
                     if isinstance(content, TextContent):
                         native_part = {"text": content.text}
-                        if content.signature:
+                        if content.signature and current_model == self.model:
                             native_part["thought_signature"] = content.signature
                         native_google_content_parts.append(native_part)
                     elif isinstance(content, ReasoningContent):
-                        native_google_content_parts.append({"text": content.reasoning, "thought": True})
+                        if current_model == self.model:
+                            native_google_content_parts.append({"text": content.reasoning, "thought": True})
                     elif isinstance(content, ToolCallContent):
                         native_part = {
                             "function_call": {
@@ -1496,7 +1587,7 @@ class Message(BaseMessage):
                                 "args": content.input,
                             },
                         }
-                        if content.signature:
+                        if content.signature and current_model == self.model:
                             native_part["thought_signature"] = content.signature
                         native_google_content_parts.append(native_part)
                     else:
@@ -1554,11 +1645,14 @@ class Message(BaseMessage):
     @staticmethod
     def to_google_dicts_from_list(
         messages: List[Message],
+        current_model: str,
         put_inner_thoughts_in_kwargs: bool = True,
         native_content: bool = False,
     ):
+        messages = Message.filter_messages_for_llm_api(messages)
         result = [
             m.to_google_dict(
+                current_model=current_model,
                 put_inner_thoughts_in_kwargs=put_inner_thoughts_in_kwargs,
                 native_content=native_content,
             )
@@ -1567,6 +1661,53 @@ class Message(BaseMessage):
         result = [m for m in result if m is not None]
         return result
 
+    def is_approval_request(self) -> bool:
+        return self.role == "approval" and self.tool_calls is not None and len(self.tool_calls) > 0
+
+    def is_approval_response(self) -> bool:
+        return self.role == "approval" and self.tool_calls is None and self.approve is not None
+
+    def is_summarization_message(self) -> bool:
+        return (
+            self.role == "user"
+            and self.content is not None
+            and len(self.content) == 1
+            and isinstance(self.content[0], TextContent)
+            and "system_alert" in self.content[0].text
+        )
+
+    @staticmethod
+    def filter_messages_for_llm_api(
+        messages: List[Message],
+    ) -> List[Message]:
+        messages = [m for m in messages if m is not None]
+        if len(messages) == 0:
+            return []
+        # Add special handling for legacy bug where summarization triggers in the middle of hitl
+        messages_to_filter = []
+        for i in range(len(messages) - 1):
+            first_message_is_approval = messages[i].is_approval_request()
+            second_message_is_summary = messages[i + 1].is_summarization_message()
+            third_message_is_optional_approval = i + 2 >= len(messages) or messages[i + 2].is_approval_response()
+            if first_message_is_approval and second_message_is_summary and third_message_is_optional_approval:
+                messages_to_filter.append(messages[i])
+        for idx in reversed(messages_to_filter):  # reverse to avoid index shift
+            messages.remove(idx)
+
+        # Filter last message if it is a lone approval request without a response - this only occurs for token counting
+        if messages[-1].role == "approval" and messages[-1].tool_calls is not None and len(messages[-1].tool_calls) > 0:
+            messages.remove(messages[-1])
+
+        # Filter last message if it is a lone reasoning message without assistant message or tool call
+        if (
+            messages[-1].role == "assistant"
+            and messages[-1].tool_calls is None
+            and (not messages[-1].content or all(not isinstance(content_part, TextContent) for content_part in messages[-1].content))
+        ):
+            messages.remove(messages[-1])
+
+        return messages
+
     @staticmethod
     def generate_otid_from_id(message_id: str, index: int) -> str:
         """

letta/schemas/run_metrics.py

@@ -0,0 +1,21 @@
+from typing import Optional
+
+from pydantic import Field
+
+from letta.schemas.letta_base import LettaBase
+
+
+class RunMetricsBase(LettaBase):
+    __id_prefix__ = "run"
+
+
+class RunMetrics(RunMetricsBase):
+    id: str = Field(..., description="The id of the run this metric belongs to (matches runs.id).")
+    organization_id: Optional[str] = Field(None, description="The unique identifier of the organization.")
+    agent_id: Optional[str] = Field(None, description="The unique identifier of the agent.")
+    project_id: Optional[str] = Field(None, description="The project that the run belongs to (cloud only).")
+    run_start_ns: Optional[int] = Field(None, description="The timestamp of the start of the run in nanoseconds.")
+    run_ns: Optional[int] = Field(None, description="Total time for the run in nanoseconds.")
+    num_steps: Optional[int] = Field(None, description="The number of steps in the run.")
+    template_id: Optional[str] = Field(None, description="The template ID that the run belongs to (cloud only).")
+    base_template_id: Optional[str] = Field(None, description="The base template ID that the run belongs to (cloud only).")

letta/server/db.py

@@ -10,18 +10,11 @@ from sqlalchemy.ext.asyncio import (
     create_async_engine,
 )
 
+from letta.database_utils import get_database_uri_for_context
 from letta.settings import settings
 
-# Convert PostgreSQL URI to async format
-pg_uri = settings.letta_pg_uri
-if pg_uri.startswith("postgresql://"):
-    async_pg_uri = pg_uri.replace("postgresql://", "postgresql+asyncpg://")
-else:
-    # Handle other URI formats (e.g., postgresql+pg8000://)
-    async_pg_uri = f"postgresql+asyncpg://{pg_uri.split('://', 1)[1]}" if "://" in pg_uri else pg_uri
-
-# Replace sslmode with ssl for asyncpg
-async_pg_uri = async_pg_uri.replace("sslmode=", "ssl=")
+# Convert PostgreSQL URI to async format using common utility
+async_pg_uri = get_database_uri_for_context(settings.letta_pg_uri, "async")
 
 # Build engine configuration based on settings
 engine_args = {