letta-nightly 0.11.7.dev20251007104119__py3-none-any.whl → 0.12.0.dev20251009104148__py3-none-any.whl

letta/schemas/message.py

@@ -11,9 +11,10 @@ from enum import Enum
 from typing import Annotated, Any, Dict, List, Literal, Optional, Union
 
 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
 
-from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG, TOOL_CALL_ID_MAX_LEN
+from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG, REQUEST_HEARTBEAT_PARAM, TOOL_CALL_ID_MAX_LEN
 from letta.helpers.datetime_helpers import get_utc_time, is_utc_datetime
 from letta.helpers.json_helpers import json_dumps
 from letta.local_llm.constants import INNER_THOUGHTS_KWARG, INNER_THOUGHTS_KWARG_VERTEX
@@ -25,6 +26,7 @@ from letta.schemas.letta_message import (
     AssistantMessage,
     HiddenReasoningMessage,
     LettaMessage,
+    MessageType,
     ReasoningMessage,
     SystemMessage,
     ToolCall,
@@ -38,7 +40,9 @@ from letta.schemas.letta_message_content import (
     OmittedReasoningContent,
     ReasoningContent,
     RedactedReasoningContent,
+    SummarizedReasoningContent,
     TextContent,
+    ToolCallContent,
     ToolReturnContent,
     get_letta_message_content_union_str_json_schema,
 )
@@ -192,6 +196,7 @@ class Message(BaseMessage):
     tool_call_id: Optional[str] = Field(default=None, description="The ID of the tool call. Only applicable for role tool.")
     # Extras
     step_id: Optional[str] = Field(default=None, description="The id of the step that this message was created in.")
+    run_id: Optional[str] = Field(default=None, description="The id of the run that this message was created in.")
     otid: Optional[str] = Field(default=None, description="The offline threading id associated with this message")
     tool_returns: Optional[List[ToolReturn]] = Field(default=None, description="Tool execution return information for prior tool calls")
     group_id: Optional[str] = Field(default=None, description="The multi-agent group that the message was sent in")
@@ -208,6 +213,13 @@ class Message(BaseMessage):
     # This overrides the optional base orm schema, created_at MUST exist on all messages objects
     created_at: datetime = Field(default_factory=get_utc_time, description="The timestamp when the object was created.")
 
+    # validate that run_id is set
+    # @model_validator(mode="after")
+    # def validate_run_id(self):
+    #    if self.run_id is None:
+    #        raise ValueError("Run ID is required")
+    #    return self
+
     @field_validator("role")
     @classmethod
     def validate_role(cls, v: str) -> str:
@@ -239,6 +251,7 @@ class Message(BaseMessage):
         assistant_message_tool_kwarg: str = DEFAULT_MESSAGE_TOOL_KWARG,
         reverse: bool = True,
         include_err: Optional[bool] = None,
+        text_is_assistant_message: bool = False,
     ) -> List[LettaMessage]:
         if use_assistant_message:
             message_ids_to_remove = []
@@ -270,6 +283,7 @@ class Message(BaseMessage):
                 assistant_message_tool_kwarg=assistant_message_tool_kwarg,
                 reverse=reverse,
                 include_err=include_err,
+                text_is_assistant_message=text_is_assistant_message,
             )
         ]
 
@@ -280,12 +294,15 @@ class Message(BaseMessage):
         assistant_message_tool_kwarg: str = DEFAULT_MESSAGE_TOOL_KWARG,
         reverse: bool = True,
         include_err: Optional[bool] = None,
+        text_is_assistant_message: bool = False,
     ) -> List[LettaMessage]:
         """Convert message object (in DB format) to the style used by the original Letta API"""
+
         messages = []
         if self.role == MessageRole.assistant:
             if self.content:
-                messages.extend(self._convert_reasoning_messages())
+                messages.extend(self._convert_reasoning_messages(text_is_assistant_message=text_is_assistant_message))
+
             if self.tool_calls is not None:
                 messages.extend(
                     self._convert_tool_call_messages(
@@ -296,14 +313,14 @@ class Message(BaseMessage):
                     ),
                 )
         elif self.role == MessageRole.tool:
-            messages.append(self._convert_tool_return_message())
+            messages.extend(self._convert_tool_return_message())
         elif self.role == MessageRole.user:
             messages.append(self._convert_user_message())
         elif self.role == MessageRole.system:
             messages.append(self._convert_system_message())
         elif self.role == MessageRole.approval:
             if self.content:
-                messages.extend(self._convert_reasoning_messages())
+                messages.extend(self._convert_reasoning_messages(text_is_assistant_message=text_is_assistant_message))
             if self.tool_calls is not None:
                 tool_calls = self._convert_tool_call_messages()
                 assert len(tool_calls) == 1
@@ -317,6 +334,7 @@ class Message(BaseMessage):
                     approve=self.approve,
                     approval_request_id=self.approval_request_id,
                     reason=self.denial_reason,
+                    run_id=self.run_id,
                 )
                 messages.append(approval_response_message)
         else:
@@ -324,30 +342,37 @@ class Message(BaseMessage):
 
         return messages[::-1] if reverse else messages
 
-    def _convert_reasoning_messages(self, current_message_count: int = 0) -> List[LettaMessage]:
+    def _convert_reasoning_messages(
+        self,
+        current_message_count: int = 0,
+        text_is_assistant_message: bool = False,  # For v3 loop, set to True
+    ) -> List[LettaMessage]:
         messages = []
-        # Check for ReACT-style COT inside of TextContent
-        if len(self.content) == 1 and isinstance(self.content[0], TextContent):
+
+        for content_part in self.content:
             otid = Message.generate_otid_from_id(self.id, current_message_count + len(messages))
-            messages.append(
-                ReasoningMessage(
-                    id=self.id,
-                    date=self.created_at,
-                    reasoning=self.content[0].text,
-                    name=self.name,
-                    otid=otid,
-                    sender_id=self.sender_id,
-                    step_id=self.step_id,
-                    is_err=self.is_err,
-                )
-            )
-        # Otherwise, we may have a list of multiple types
-        else:
-            # TODO we can probably collapse these two cases into a single loop
-            for content_part in self.content:
-                otid = Message.generate_otid_from_id(self.id, current_message_count + len(messages))
-                if isinstance(content_part, TextContent):
-                    # COT
+
+            if isinstance(content_part, TextContent):
+                if text_is_assistant_message:
+                    # .content is assistant message
+                    if messages and messages[-1].message_type == MessageType.assistant_message:
+                        messages[-1].content += content_part.text
+                    else:
+                        messages.append(
+                            AssistantMessage(
+                                id=self.id,
+                                date=self.created_at,
+                                content=content_part.text,
+                                name=self.name,
+                                otid=otid,
+                                sender_id=self.sender_id,
+                                step_id=self.step_id,
+                                is_err=self.is_err,
+                                run_id=self.run_id,
+                            )
+                        )
+                else:
+                    # .content is COT
                     messages.append(
                         ReasoningMessage(
                             id=self.id,
@@ -358,10 +383,15 @@ class Message(BaseMessage):
                             sender_id=self.sender_id,
                             step_id=self.step_id,
                             is_err=self.is_err,
+                            run_id=self.run_id,
                         )
                     )
-                elif isinstance(content_part, ReasoningContent):
-                    # "native" COT
+
+            elif isinstance(content_part, ReasoningContent):
+                # "native" COT
+                if messages and messages[-1].message_type == MessageType.reasoning_message:
+                    messages[-1].reasoning += content_part.reasoning
+                else:
                     messages.append(
                         ReasoningMessage(
                             id=self.id,
@@ -373,41 +403,87 @@ class Message(BaseMessage):
                             otid=otid,
                             step_id=self.step_id,
                             is_err=self.is_err,
+                            run_id=self.run_id,
                         )
                     )
-                elif isinstance(content_part, RedactedReasoningContent):
-                    # "native" redacted/hidden COT
+
+            elif isinstance(content_part, SummarizedReasoningContent):
+                # TODO remove the cast and just return the native type
+                casted_content_part = content_part.to_reasoning_content()
+                if casted_content_part is not None:
                     messages.append(
-                        HiddenReasoningMessage(
+                        ReasoningMessage(
                             id=self.id,
                             date=self.created_at,
-                            state="redacted",
-                            hidden_reasoning=content_part.data,
+                            reasoning=casted_content_part.reasoning,
+                            source="reasoner_model",  # TODO do we want to tag like this?
+                            signature=casted_content_part.signature,
                             name=self.name,
                             otid=otid,
-                            sender_id=self.sender_id,
                             step_id=self.step_id,
                             is_err=self.is_err,
+                            run_id=self.run_id,
                         )
                     )
-                elif isinstance(content_part, OmittedReasoningContent):
-                    # Special case for "hidden reasoning" models like o1/o3
-                    # NOTE: we also have to think about how to return this during streaming
-                    messages.append(
-                        HiddenReasoningMessage(
-                            id=self.id,
-                            date=self.created_at,
-                            state="omitted",
-                            name=self.name,
-                            otid=otid,
-                            step_id=self.step_id,
-                            is_err=self.is_err,
-                        )
+
+            elif isinstance(content_part, RedactedReasoningContent):
+                # "native" redacted/hidden COT
+                messages.append(
+                    HiddenReasoningMessage(
+                        id=self.id,
+                        date=self.created_at,
+                        state="redacted",
+                        hidden_reasoning=content_part.data,
+                        name=self.name,
+                        otid=otid,
+                        sender_id=self.sender_id,
+                        step_id=self.step_id,
+                        is_err=self.is_err,
+                        run_id=self.run_id,
                     )
-                else:
-                    warnings.warn(f"Unrecognized content part in assistant message: {content_part}")
+                )
+
+            elif isinstance(content_part, OmittedReasoningContent):
+                # Special case for "hidden reasoning" models like o1/o3
+                # NOTE: we also have to think about how to return this during streaming
+                messages.append(
+                    HiddenReasoningMessage(
+                        id=self.id,
+                        date=self.created_at,
+                        state="omitted",
+                        name=self.name,
+                        otid=otid,
+                        step_id=self.step_id,
+                        is_err=self.is_err,
+                        run_id=self.run_id,
+                    )
+                )
+
+            else:
+                warnings.warn(f"Unrecognized content part in assistant message: {content_part}")
+
         return messages
 
+    def _convert_assistant_message(
+        self,
+    ) -> AssistantMessage:
+        if self.content and len(self.content) == 1 and isinstance(self.content[0], TextContent):
+            text_content = self.content[0].text
+        else:
+            raise ValueError(f"Invalid assistant message (no text object on message): {self.content}")
+
+        return AssistantMessage(
+            id=self.id,
+            date=self.created_at,
+            content=text_content,
+            name=self.name,
+            otid=self.otid,
+            sender_id=self.sender_id,
+            step_id=self.step_id,
+            # is_err=self.is_err,
+            run_id=self.run_id,
+        )
+
     def _convert_tool_call_messages(
         self,
         current_message_count: int = 0,
@@ -438,6 +514,7 @@ class Message(BaseMessage):
                         sender_id=self.sender_id,
                         step_id=self.step_id,
                         is_err=self.is_err,
+                        run_id=self.run_id,
                     )
                 )
             else:
@@ -455,49 +532,135 @@ class Message(BaseMessage):
                         sender_id=self.sender_id,
                         step_id=self.step_id,
                         is_err=self.is_err,
+                        run_id=self.run_id,
                     )
                 )
         return messages
 
-    def _convert_tool_return_message(self) -> ToolReturnMessage:
-        """Convert tool role message to ToolReturnMessage
+    def _convert_tool_return_message(self) -> List[ToolReturnMessage]:
+        """Convert tool role message to ToolReturnMessage.
 
-        the tool return is packaged as follows:
+        The tool return is packaged as follows:
             packaged_message = {
                 "status": "OK" if was_success else "Failed",
                 "message": response_string,
                 "time": formatted_time,
             }
+
+        Returns:
+            List[ToolReturnMessage]: Converted tool return messages
+
+        Raises:
+            ValueError: If message role is not 'tool', parsing fails, or no valid content exists
         """
-        if self.content and len(self.content) == 1 and isinstance(self.content[0], TextContent):
-            text_content = self.content[0].text
-        else:
-            raise ValueError(f"Invalid tool return (no text object on message): {self.content}")
+        if self.role != MessageRole.tool:
+            raise ValueError(f"Cannot convert message of type {self.role} to ToolReturnMessage")
+
+        if self.tool_returns:
+            return self._convert_explicit_tool_returns()
+
+        return self._convert_legacy_tool_return()
 
+    def _convert_explicit_tool_returns(self) -> List[ToolReturnMessage]:
+        """Convert explicit tool returns to ToolReturnMessage list."""
+        tool_returns = []
+
+        for index, tool_return in enumerate(self.tool_returns):
+            parsed_data = self._parse_tool_response(tool_return.func_response)
+
+            tool_returns.append(
+                self._create_tool_return_message(
+                    message_text=parsed_data["message"],
+                    status=parsed_data["status"],
+                    tool_call_id=tool_return.tool_call_id,
+                    stdout=tool_return.stdout,
+                    stderr=tool_return.stderr,
+                    otid_index=index,
+                )
+            )
+
+        return tool_returns
+
+    def _convert_legacy_tool_return(self) -> List[ToolReturnMessage]:
+        """Convert legacy single text content to ToolReturnMessage."""
+        if not self._has_single_text_content():
+            raise ValueError(f"No valid tool returns to convert: {self}")
+
+        text_content = self.content[0].text
+        parsed_data = self._parse_tool_response(text_content)
+
+        return [
+            self._create_tool_return_message(
+                message_text=parsed_data["message"],
+                status=parsed_data["status"],
+                tool_call_id=self.tool_call_id,
+                stdout=None,
+                stderr=None,
+                otid_index=0,
+            )
+        ]
+
+    def _has_single_text_content(self) -> bool:
+        """Check if message has exactly one text content item."""
+        return self.content and len(self.content) == 1 and isinstance(self.content[0], TextContent)
+
+    def _parse_tool_response(self, response_text: str) -> dict:
+        """Parse tool response JSON and extract message and status.
+
+        Args:
+            response_text: Raw JSON response text
+
+        Returns:
+            Dictionary with 'message' and 'status' keys
+
+        Raises:
+            ValueError: If JSON parsing fails
+        """
         try:
-            function_return = parse_json(text_content)
-            message_text = str(function_return.get("message", text_content))
-            status = self._parse_tool_status(function_return["status"])
-        except json.JSONDecodeError:
-            raise ValueError(f"Failed to decode function return: {text_content}")
+            function_return = parse_json(response_text)
+            return {
+                "message": str(function_return.get("message", response_text)),
+                "status": self._parse_tool_status(function_return.get("status", "OK")),
+            }
+        except json.JSONDecodeError as e:
+            raise ValueError(f"Failed to decode function return: {response_text}") from e
 
-        # if self.tool_call_id is None:
-        #     import pdb;pdb.set_trace()
-        assert self.tool_call_id is not None
+    def _create_tool_return_message(
+        self,
+        message_text: str,
+        status: str,
+        tool_call_id: Optional[str],
+        stdout: Optional[str],
+        stderr: Optional[str],
+        otid_index: int,
+    ) -> ToolReturnMessage:
+        """Create a ToolReturnMessage with common attributes.
 
+        Args:
+            message_text: The tool return message text
+            status: Tool execution status
+            tool_call_id: Optional tool call identifier
+            stdout: Optional standard output
+            stderr: Optional standard error
+            otid_index: Index for OTID generation
+
+        Returns:
+            Configured ToolReturnMessage instance
+        """
         return ToolReturnMessage(
             id=self.id,
             date=self.created_at,
             tool_return=message_text,
-            status=self.tool_returns[0].status if self.tool_returns else status,
-            tool_call_id=self.tool_call_id,
-            stdout=self.tool_returns[0].stdout if self.tool_returns else None,
-            stderr=self.tool_returns[0].stderr if self.tool_returns else None,
+            status=status,
+            tool_call_id=tool_call_id,
+            stdout=stdout,
+            stderr=stderr,
             name=self.name,
-            otid=Message.generate_otid_from_id(self.id, 0),
+            otid=Message.generate_otid_from_id(self.id, otid_index),
             sender_id=self.sender_id,
             step_id=self.step_id,
             is_err=self.is_err,
+            run_id=self.run_id,
         )
 
     @staticmethod
@@ -531,6 +694,7 @@ class Message(BaseMessage):
             sender_id=self.sender_id,
             step_id=self.step_id,
             is_err=self.is_err,
+            run_id=self.run_id,
         )
 
     def _convert_system_message(self) -> SystemMessage:
@@ -548,6 +712,7 @@ class Message(BaseMessage):
             otid=self.otid,
             sender_id=self.sender_id,
             step_id=self.step_id,
+            run_id=self.run_id,
         )
 
     @staticmethod
@@ -561,6 +726,7 @@ class Message(BaseMessage):
         name: Optional[str] = None,
         group_id: Optional[str] = None,
         tool_returns: Optional[List[ToolReturn]] = None,
+        run_id: Optional[str] = None,
     ) -> Message:
         """Convert a ChatCompletion message object into a Message object (synced to DB)"""
         if not created_at:
@@ -622,6 +788,7 @@ class Message(BaseMessage):
                     id=str(id),
                     tool_returns=tool_returns,
                     group_id=group_id,
+                    run_id=run_id,
                 )
             else:
                 return Message(
@@ -636,6 +803,7 @@ class Message(BaseMessage):
                     created_at=created_at,
                     tool_returns=tool_returns,
                     group_id=group_id,
+                    run_id=run_id,
                 )
 
         elif "function_call" in openai_message_dict and openai_message_dict["function_call"] is not None:
@@ -671,6 +839,7 @@ class Message(BaseMessage):
                     id=str(id),
                     tool_returns=tool_returns,
                     group_id=group_id,
+                    run_id=run_id,
                 )
             else:
                 return Message(
@@ -685,6 +854,7 @@ class Message(BaseMessage):
                     created_at=created_at,
                     tool_returns=tool_returns,
                     group_id=group_id,
+                    run_id=run_id,
                 )
 
         else:
@@ -720,6 +890,7 @@ class Message(BaseMessage):
                     id=str(id),
                     tool_returns=tool_returns,
                     group_id=group_id,
+                    run_id=run_id,
                 )
             else:
                 return Message(
@@ -734,6 +905,7 @@ class Message(BaseMessage):
                     created_at=created_at,
                     tool_returns=tool_returns,
                     group_id=group_id,
+                    run_id=run_id,
                 )
 
     def to_openai_dict_search_results(self, max_tool_id_length: int = TOOL_CALL_ID_MAX_LEN) -> dict:
@@ -746,8 +918,13 @@ 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,
+        # if true, then treat the content field as AssistantMessage
+        native_content: bool = False,
+        strip_request_heartbeat: bool = False,
     ) -> 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"
+
         if self.role == "approval" and self.tool_calls is None:
             return None
 
@@ -763,8 +940,8 @@ class Message(BaseMessage):
         # Otherwise, check if we have TextContent and multiple other parts
         elif self.content and len(self.content) > 1:
             text = [content for content in self.content if isinstance(content, TextContent)]
-            assert len(text) == 1, f"multiple text content parts found in a single message: {self.content}"
-            text_content = text[0].text
+            # assert len(text) == 1, f"multiple text content parts found in a single message: {self.content}"
+            text_content = "\n\n".join([t.text for t in text])
             parse_content_parts = True
         else:
             text_content = None
@@ -788,11 +965,28 @@ class Message(BaseMessage):
             }
 
         elif self.role == "assistant" or self.role == "approval":
-            assert self.tool_calls is not None or text_content is not None
-            openai_message = {
-                "content": None if (put_inner_thoughts_in_kwargs and self.tool_calls is not None) else text_content,
-                "role": "assistant",
-            }
+            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:
+                openai_message = {
+                    # TODO support listed content (if it's possible for role assistant?)
+                    # "content": self.content,
+                    "content": text_content,  # here content is not reasoning, it's assistant message
+                    "role": "assistant",
+                }
+            # otherwise, if inner_thoughts_in_kwargs, hold it for the tool calls
+            else:
+                openai_message = {
+                    "content": None if (put_inner_thoughts_in_kwargs and self.tool_calls is not None) else text_content,
+                    "role": "assistant",
+                }
 
             if self.tool_calls is not None:
                 if put_inner_thoughts_in_kwargs:
@@ -807,6 +1001,11 @@ class Message(BaseMessage):
                     ]
                 else:
                     openai_message["tool_calls"] = [tool_call.model_dump() for tool_call in self.tool_calls]
+
+                if strip_request_heartbeat:
+                    for tool_call_dict in openai_message["tool_calls"]:
+                        tool_call_dict.pop(REQUEST_HEARTBEAT_PARAM, None)
+
                 if max_tool_id_length:
                     for tool_call_dict in openai_message["tool_calls"]:
                         tool_call_dict["id"] = tool_call_dict["id"][:max_tool_id_length]
@@ -847,6 +1046,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,
@@ -858,10 +1058,118 @@ class Message(BaseMessage):
         result = [m for m in result if m is not None]
         return result
 
+    def to_openai_responses_dicts(
+        self,
+        max_tool_id_length: int = TOOL_CALL_ID_MAX_LEN,
+    ) -> List[dict]:
+        """Go from Message class to ChatCompletion message object"""
+
+        if self.role == "approval" and self.tool_calls is None:
+            return []
+
+        message_dicts = []
+
+        if self.role == "system":
+            assert len(self.content) == 1 and isinstance(self.content[0], TextContent), vars(self)
+            message_dicts.append(
+                {
+                    "role": "developer",
+                    "content": self.content[0].text,
+                }
+            )
+
+        elif self.role == "user":
+            # TODO do we need to do a swap to placeholder text here for images?
+            assert all([isinstance(c, TextContent) or isinstance(c, ImageContent) for c in self.content]), vars(self)
+
+            user_dict = {
+                "role": self.role.value if hasattr(self.role, "value") else self.role,
+                # TODO support multi-modal
+                "content": self.content[0].text,
+            }
+
+            # Optional field, do not include if null or invalid
+            if self.name is not None:
+                if bool(re.match(r"^[^\s<|\\/>]+$", self.name)):
+                    user_dict["name"] = self.name
+                else:
+                    warnings.warn(f"Using OpenAI with invalid 'name' field (name={self.name} role={self.role}).")
+
+            message_dicts.append(user_dict)
+
+        elif self.role == "assistant" or self.role == "approval":
+            assert self.tool_calls is not None or (self.content is not None and len(self.content) > 0)
+
+            # A few things may be in here, firstly reasoning content, secondly assistant messages, thirdly tool calls
+            # TODO check if OpenAI Responses is capable of R->A->T like Anthropic?
+
+            if self.content is not None:
+                for content_part in self.content:
+                    if isinstance(content_part, SummarizedReasoningContent):
+                        message_dicts.append(
+                            {
+                                "type": "reasoning",
+                                "id": content_part.id,
+                                "summary": [{"type": "summary_text", "text": s.text} for s in content_part.summary],
+                                "encrypted_content": content_part.encrypted_content,
+                            }
+                        )
+                    elif isinstance(content_part, TextContent):
+                        message_dicts.append(
+                            {
+                                "role": "assistant",
+                                "content": content_part.text,
+                            }
+                        )
+                    # else skip
+
+            if self.tool_calls is not None:
+                for tool_call in self.tool_calls:
+                    message_dicts.append(
+                        {
+                            "type": "function_call",
+                            "call_id": tool_call.id[:max_tool_id_length] if max_tool_id_length else tool_call.id,
+                            "name": tool_call.function.name,
+                            "arguments": tool_call.function.arguments,
+                            "status": "completed",  # TODO check if needed?
+                        }
+                    )
+
+        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,
+                }
+            )
+
+        else:
+            raise ValueError(self.role)
+
+        return message_dicts
+
+    @staticmethod
+    def to_openai_responses_dicts_from_list(
+        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))
+        return result
+
     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
+        native_content: bool = False,
+        strip_request_heartbeat: bool = False,
     ) -> dict | None:
         """
         Convert to an Anthropic message dictionary
@@ -869,6 +1177,8 @@ class Message(BaseMessage):
         Args:
             inner_thoughts_xml_tag (str): The XML tag to wrap around inner thoughts
         """
+        assert not (native_content and put_inner_thoughts_in_kwargs), "native_content and put_inner_thoughts_in_kwargs cannot both be true"
+
         if self.role == "approval" and self.tool_calls is None:
             return None
 
@@ -929,43 +1239,80 @@ class Message(BaseMessage):
                 }
 
         elif self.role == "assistant" or self.role == "approval":
-            assert self.tool_calls is not None or text_content is not None
+            # assert self.tool_calls is not None or text_content is not None, vars(self)
+            assert self.tool_calls is not None or len(self.content) > 0
             anthropic_message = {
                 "role": "assistant",
             }
             content = []
-            # COT / reasoning / thinking
-            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 isinstance(content_part, RedactedReasoningContent):
-                        content.append(
-                            {
-                                "type": "redacted_thinking",
-                                "data": content_part.data,
-                            }
-                        )
-                    if isinstance(content_part, TextContent):
-                        content.append(
-                            {
-                                "type": "text",
-                                "text": content_part.text,
-                            }
-                        )
-            elif text_content is not None:
-                content.append(
-                    {
-                        "type": "text",
-                        "text": add_xml_tag(string=text_content, xml_tag=inner_thoughts_xml_tag),
-                    }
-                )
+            if native_content:
+                # No special handling for TextContent
+                if self.content is not None:
+                    for content_part in self.content:
+                        # TextContent, ImageContent, ToolCallContent, ToolReturnContent, ReasoningContent, RedactedReasoningContent, OmittedReasoningContent
+                        if isinstance(content_part, ReasoningContent):
+                            if current_model == self.model:
+                                content.append(
+                                    {
+                                        "type": "thinking",
+                                        "thinking": content_part.reasoning,
+                                        "signature": content_part.signature,
+                                    }
+                                )
+                        elif isinstance(content_part, RedactedReasoningContent):
+                            if current_model == self.model:
+                                content.append(
+                                    {
+                                        "type": "redacted_thinking",
+                                        "data": content_part.data,
+                                    }
+                                )
+                        elif isinstance(content_part, TextContent):
+                            content.append(
+                                {
+                                    "type": "text",
+                                    "text": content_part.text,
+                                }
+                            )
+                        else:
+                            # Skip unsupported types eg OmmitedReasoningContent
+                            pass
+
+            else:
+                # COT / reasoning / thinking
+                if self.content is not None and len(self.content) >= 1:
+                    for content_part in self.content:
+                        if isinstance(content_part, ReasoningContent):
+                            if current_model == self.model:
+                                content.append(
+                                    {
+                                        "type": "thinking",
+                                        "thinking": content_part.reasoning,
+                                        "signature": content_part.signature,
+                                    }
+                                )
+                        if isinstance(content_part, RedactedReasoningContent):
+                            if current_model == self.model:
+                                content.append(
+                                    {
+                                        "type": "redacted_thinking",
+                                        "data": content_part.data,
+                                    }
+                                )
+                        if isinstance(content_part, TextContent):
+                            content.append(
+                                {
+                                    "type": "text",
+                                    "text": content_part.text,
+                                }
+                            )
+                elif text_content is not None:
+                    content.append(
+                        {
+                            "type": "text",
+                            "text": add_xml_tag(string=text_content, xml_tag=inner_thoughts_xml_tag),
+                        }
+                    )
             # Tool calling
             if self.tool_calls is not None:
                 for tool_call in self.tool_calls:
@@ -978,6 +1325,9 @@ class Message(BaseMessage):
                     else:
                         tool_call_input = parse_json(tool_call.function.arguments)
 
+                    if strip_request_heartbeat:
+                        tool_call_input.pop(REQUEST_HEARTBEAT_PARAM, None)
+
                     content.append(
                         {
                             "type": "tool_use",
@@ -987,8 +1337,6 @@ class Message(BaseMessage):
                         }
                     )
 
-            # If the only content was text, unpack it back into a singleton
-            # TODO support multi-modal
             anthropic_message["content"] = content
 
         elif self.role == "tool":
@@ -1014,23 +1362,40 @@ 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,
+                strip_request_heartbeat=strip_request_heartbeat,
             )
             for m in messages
         ]
         result = [m for m in result if m is not None]
         return result
 
-    def to_google_dict(self, put_inner_thoughts_in_kwargs: bool = True) -> dict | None:
+    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,
+        strip_request_heartbeat: bool = False,
+    ) -> dict | None:
         """
         Go from Message class to Google AI REST message object
         """
+        assert not (native_content and put_inner_thoughts_in_kwargs), "native_content and put_inner_thoughts_in_kwargs cannot both be true"
+
         if self.role == "approval" and self.tool_calls is None:
             return None
 
@@ -1080,7 +1445,7 @@ class Message(BaseMessage):
             }
 
         elif self.role == "assistant" or self.role == "approval":
-            assert self.tool_calls is not None or text_content is not None
+            assert self.tool_calls is not None or text_content is not None or len(self.content) > 1
             google_ai_message = {
                 "role": "model",  # NOTE: different
             }
@@ -1088,7 +1453,12 @@ class Message(BaseMessage):
             # NOTE: Google AI API doesn't allow non-null content + function call
             # To get around this, just two a two part message, inner thoughts first then
             parts = []
-            if not put_inner_thoughts_in_kwargs and text_content is not None:
+
+            if native_content and text_content is not None:
+                # TODO support multi-part assistant content
+                parts.append({"text": text_content})
+
+            elif not put_inner_thoughts_in_kwargs and text_content is not None:
                 # NOTE: ideally we do multi-part for CoT / inner thoughts + function call, but Google AI API doesn't allow it
                 raise NotImplementedError
                 parts.append({"text": text_content})
@@ -1110,6 +1480,9 @@ class Message(BaseMessage):
                         assert len(self.tool_calls) == 1
                         function_args[INNER_THOUGHTS_KWARG_VERTEX] = text_content
 
+                    if strip_request_heartbeat:
+                        function_args.pop(REQUEST_HEARTBEAT_PARAM, None)
+
                     parts.append(
                         {
                             "functionCall": {
@@ -1119,8 +1492,37 @@ class Message(BaseMessage):
                         }
                     )
             else:
-                assert text_content is not None
-                parts.append({"text": text_content})
+                if not native_content:
+                    assert text_content is not None
+                    parts.append({"text": text_content})
+
+            if self.content and len(self.content) > 1:
+                native_google_content_parts = []
+                for content in self.content:
+                    if isinstance(content, TextContent):
+                        native_part = {"text": content.text}
+                        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):
+                        if current_model == self.model:
+                            native_google_content_parts.append({"text": content.reasoning, "thought": True})
+                    elif isinstance(content, ToolCallContent):
+                        native_part = {
+                            "function_call": {
+                                "name": content.name,
+                                "args": content.input,
+                            },
+                        }
+                        if content.signature and current_model == self.model:
+                            native_part["thought_signature"] = content.signature
+                        native_google_content_parts.append(native_part)
+                    else:
+                        # silently drop other content types
+                        pass
+                if native_google_content_parts:
+                    parts = native_google_content_parts
+
             google_ai_message["parts"] = parts
 
         elif self.role == "tool":
@@ -1170,17 +1572,61 @@ 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,
             )
             for m in messages
         ]
         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])
+
+        return messages
+
     @staticmethod
     def generate_otid_from_id(message_id: str, index: int) -> str:
         """
@@ -1200,10 +1646,11 @@ class Message(BaseMessage):
 
 
 class ToolReturn(BaseModel):
+    tool_call_id: Optional[Any] = Field(None, description="The ID for the tool call")
     status: Literal["success", "error"] = Field(..., description="The status of the tool call")
     stdout: Optional[List[str]] = Field(default=None, description="Captured stdout (e.g. prints, logs) from the tool invocation")
     stderr: Optional[List[str]] = Field(default=None, description="Captured stderr from the tool invocation")
-    # func_return: Optional[Any] = Field(None, description="The function return object")
+    func_response: Optional[str] = Field(None, description="The function response string")
 
 
 class MessageSearchRequest(BaseModel):