letta-nightly 0.7.13.dev20250512104305__py3-none-any.whl → 0.7.14.dev20250513020711__py3-none-any.whl

letta/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.7.13"
+__version__ = "0.7.14"
 
 # import clients
 from letta.client.client import LocalClient, RESTClient, create_client

letta/agent.py

@@ -133,7 +133,6 @@ class Agent(BaseAgent):
         # Different interfaces can handle events differently
         # e.g., print in CLI vs send a discord message with a discord bot
         self.interface = interface
-        self.chunk_index = 0
 
         # Create the persistence manager object based on the AgentState info
         self.message_manager = MessageManager()
@@ -248,11 +247,9 @@ class Agent(BaseAgent):
             group_id=group_id,
         )
         messages.append(new_message)
-        self.interface.function_message(f"Error: {error_msg}", msg_obj=new_message, chunk_index=self.chunk_index)
-        self.chunk_index += 1
+        self.interface.function_message(f"Error: {error_msg}", msg_obj=new_message, chunk_index=0)
         if include_function_failed_message:
-            self.interface.function_message(f"Ran {function_name}({function_args})", msg_obj=new_message, chunk_index=self.chunk_index)
-            self.chunk_index += 1
+            self.interface.function_message(f"Ran {function_name}({function_args})", msg_obj=new_message)
 
         # Return updated messages
         return messages
@@ -422,6 +419,7 @@ class Agent(BaseAgent):
         messages = []  # append these to the history when done
         function_name = None
         function_args = {}
+        chunk_index = 0
 
         # Step 2: check if LLM wanted to call a function
         if response_message.function_call or (response_message.tool_calls is not None and len(response_message.tool_calls) > 0):
@@ -465,8 +463,8 @@ class Agent(BaseAgent):
             nonnull_content = False
             if response_message.content or response_message.reasoning_content or response_message.redacted_reasoning_content:
                 # The content if then internal monologue, not chat
-                self.interface.internal_monologue(response_message.content, msg_obj=messages[-1], chunk_index=self.chunk_index)
-                self.chunk_index += 1
+                self.interface.internal_monologue(response_message.content, msg_obj=messages[-1], chunk_index=chunk_index)
+                chunk_index += 1
                 # Flag to avoid printing a duplicate if inner thoughts get popped from the function call
                 nonnull_content = True
 
@@ -515,8 +513,8 @@ class Agent(BaseAgent):
                 response_message.content = function_args.pop("inner_thoughts")
             # The content if then internal monologue, not chat
             if response_message.content and not nonnull_content:
-                self.interface.internal_monologue(response_message.content, msg_obj=messages[-1], chunk_index=self.chunk_index)
-                self.chunk_index += 1
+                self.interface.internal_monologue(response_message.content, msg_obj=messages[-1], chunk_index=chunk_index)
+                chunk_index += 1
 
             # (Still parsing function args)
             # Handle requests for immediate heartbeat
@@ -542,8 +540,8 @@ class Agent(BaseAgent):
             # handle cases where we return a json message
             if "message" in function_args:
                 function_args["message"] = str(function_args.get("message", ""))
-            self.interface.function_message(f"Running {function_name}({function_args})", msg_obj=messages[-1], chunk_index=self.chunk_index)
-            self.chunk_index += 1
+            self.interface.function_message(f"Running {function_name}({function_args})", msg_obj=messages[-1], chunk_index=chunk_index)
+            chunk_index = 0  # reset chunk index after assistant message
             try:
                 # handle tool execution (sandbox) and state updates
                 log_telemetry(
@@ -667,10 +665,9 @@ class Agent(BaseAgent):
                     group_id=group_id,
                 )
             )  # extend conversation with function response
-            self.interface.function_message(f"Ran {function_name}({function_args})", msg_obj=messages[-1], chunk_index=self.chunk_index)
-            self.chunk_index += 1
-            self.interface.function_message(f"Success: {function_response_string}", msg_obj=messages[-1], chunk_index=self.chunk_index)
-            self.chunk_index += 1
+            self.interface.function_message(f"Ran {function_name}({function_args})", msg_obj=messages[-1], chunk_index=chunk_index)
+            self.interface.function_message(f"Success: {function_response_string}", msg_obj=messages[-1], chunk_index=chunk_index)
+            chunk_index += 1
             self.last_function_response = function_response
 
         else:
@@ -685,8 +682,8 @@ class Agent(BaseAgent):
                     group_id=group_id,
                 )
             )  # extend conversation with assistant's reply
-            self.interface.internal_monologue(response_message.content, msg_obj=messages[-1], chunk_index=self.chunk_index)
-            self.chunk_index += 1
+            self.interface.internal_monologue(response_message.content, msg_obj=messages[-1], chunk_index=chunk_index)
+            chunk_index += 1
             heartbeat_request = False
             function_failed = False
 

letta/agents/base_agent.py

@@ -3,14 +3,21 @@ from typing import Any, AsyncGenerator, List, Optional, Union
 
 import openai
 
+from letta.helpers.datetime_helpers import get_utc_time
+from letta.log import get_logger
+from letta.schemas.agent import AgentState
 from letta.schemas.enums import MessageStreamStatus
 from letta.schemas.letta_message import LegacyLettaMessage, LettaMessage
 from letta.schemas.letta_message_content import TextContent
 from letta.schemas.letta_response import LettaResponse
-from letta.schemas.message import MessageCreate
+from letta.schemas.message import Message, MessageCreate, MessageUpdate
 from letta.schemas.user import User
 from letta.services.agent_manager import AgentManager
+from letta.services.helpers.agent_manager_helper import compile_system_message
 from letta.services.message_manager import MessageManager
+from letta.utils import united_diff
+
+logger = get_logger(__name__)
 
 
 class BaseAgent(ABC):
@@ -64,3 +71,107 @@ class BaseAgent(ABC):
                 return ""
 
         return [{"role": input_message.role.value, "content": get_content(input_message)} for input_message in input_messages]
+
+    def _rebuild_memory(
+        self,
+        in_context_messages: List[Message],
+        agent_state: AgentState,
+        num_messages: int | None = None,  # storing these calculations is specific to the voice agent
+        num_archival_memories: int | None = None,
+    ) -> List[Message]:
+        try:
+            # Refresh Memory
+            # TODO: This only happens for the summary block (voice?)
+            # [DB Call] loading blocks (modifies: agent_state.memory.blocks)
+            self.agent_manager.refresh_memory(agent_state=agent_state, actor=self.actor)
+
+            # TODO: This is a pretty brittle pattern established all over our code, need to get rid of this
+            curr_system_message = in_context_messages[0]
+            curr_memory_str = agent_state.memory.compile()
+            curr_system_message_text = curr_system_message.content[0].text
+            if curr_memory_str in curr_system_message_text:
+                # NOTE: could this cause issues if a block is removed? (substring match would still work)
+                logger.debug(
+                    f"Memory hasn't changed for agent id={agent_state.id} and actor=({self.actor.id}, {self.actor.name}), skipping system prompt rebuild"
+                )
+                return in_context_messages
+
+            memory_edit_timestamp = get_utc_time()
+
+            # [DB Call] size of messages and archival memories
+            num_messages = num_messages or self.message_manager.size(actor=self.actor, agent_id=agent_state.id)
+            num_archival_memories = num_archival_memories or self.passage_manager.size(actor=self.actor, agent_id=agent_state.id)
+
+            new_system_message_str = compile_system_message(
+                system_prompt=agent_state.system,
+                in_context_memory=agent_state.memory,
+                in_context_memory_last_edit=memory_edit_timestamp,
+                previous_message_count=num_messages,
+                archival_memory_size=num_archival_memories,
+            )
+
+            diff = united_diff(curr_system_message_text, new_system_message_str)
+            if len(diff) > 0:
+                logger.debug(f"Rebuilding system with new memory...\nDiff:\n{diff}")
+
+                # [DB Call] Update Messages
+                new_system_message = self.message_manager.update_message_by_id(
+                    curr_system_message.id, message_update=MessageUpdate(content=new_system_message_str), actor=self.actor
+                )
+                # Skip pulling down the agent's memory again to save on a db call
+                return [new_system_message] + in_context_messages[1:]
+
+            else:
+                return in_context_messages
+        except:
+            logger.exception(f"Failed to rebuild memory for agent id={agent_state.id} and actor=({self.actor.id}, {self.actor.name})")
+            raise
+
+    async def _rebuild_memory_async(self, in_context_messages: List[Message], agent_state: AgentState) -> List[Message]:
+        """
+        Async version of function above. For now before breaking up components, changes should be made in both places.
+        """
+        try:
+            # [DB Call] loading blocks (modifies: agent_state.memory.blocks)
+            await self.agent_manager.refresh_memory_async(agent_state=agent_state, actor=self.actor)
+
+            # TODO: This is a pretty brittle pattern established all over our code, need to get rid of this
+            curr_system_message = in_context_messages[0]
+            curr_memory_str = agent_state.memory.compile()
+            curr_system_message_text = curr_system_message.content[0].text
+            if curr_memory_str in curr_system_message_text:
+                logger.debug(
+                    f"Memory hasn't changed for agent id={agent_state.id} and actor=({self.actor.id}, {self.actor.name}), skipping system prompt rebuild"
+                )
+                return in_context_messages
+
+            memory_edit_timestamp = get_utc_time()
+
+            # [DB Call] size of messages and archival memories
+            # todo: blocking for now
+            num_messages = num_messages or self.message_manager.size(actor=self.actor, agent_id=agent_state.id)
+            num_archival_memories = num_archival_memories or self.passage_manager.size(actor=self.actor, agent_id=agent_state.id)
+
+            new_system_message_str = compile_system_message(
+                system_prompt=agent_state.system,
+                in_context_memory=agent_state.memory,
+                in_context_memory_last_edit=memory_edit_timestamp,
+                previous_message_count=num_messages,
+                archival_memory_size=num_archival_memories,
+            )
+
+            diff = united_diff(curr_system_message_text, new_system_message_str)
+            if len(diff) > 0:
+                logger.debug(f"Rebuilding system with new memory...\nDiff:\n{diff}")
+
+                # [DB Call] Update Messages
+                new_system_message = self.message_manager.update_message_by_id_async(
+                    curr_system_message.id, message_update=MessageUpdate(content=new_system_message_str), actor=self.actor
+                )
+                return [new_system_message] + in_context_messages[1:]
+
+            else:
+                return in_context_messages
+        except:
+            logger.exception(f"Failed to rebuild memory for agent id={agent_state.id} and actor=({self.actor.id}, {self.actor.name})")
+            raise

letta/agents/letta_agent.py

@@ -9,7 +9,6 @@ from openai.types.chat import ChatCompletion, ChatCompletionChunk
 from letta.agents.base_agent import BaseAgent
 from letta.agents.helpers import _create_letta_response, _prepare_in_context_messages
 from letta.helpers import ToolRulesSolver
-from letta.helpers.datetime_helpers import get_utc_time
 from letta.helpers.tool_execution_helper import enable_strict_mode
 from letta.interfaces.anthropic_streaming_interface import AnthropicStreamingInterface
 from letta.llm_api.llm_client import LLMClient
@@ -22,18 +21,18 @@ from letta.schemas.enums import MessageRole, MessageStreamStatus
 from letta.schemas.letta_message import AssistantMessage
 from letta.schemas.letta_message_content import OmittedReasoningContent, ReasoningContent, RedactedReasoningContent, TextContent
 from letta.schemas.letta_response import LettaResponse
-from letta.schemas.message import Message, MessageCreate, MessageUpdate
+from letta.schemas.message import Message, MessageCreate
 from letta.schemas.openai.chat_completion_response import ToolCall
 from letta.schemas.user import User
 from letta.server.rest_api.utils import create_letta_messages_from_llm_response
 from letta.services.agent_manager import AgentManager
 from letta.services.block_manager import BlockManager
-from letta.services.helpers.agent_manager_helper import compile_system_message
 from letta.services.message_manager import MessageManager
 from letta.services.passage_manager import PassageManager
 from letta.services.tool_executor.tool_execution_manager import ToolExecutionManager
+from letta.settings import settings
+from letta.system import package_function_response
 from letta.tracing import log_event, trace_method
-from letta.utils import united_diff
 
 logger = get_logger(__name__)
 
@@ -59,6 +58,8 @@ class LettaAgent(BaseAgent):
         self.use_assistant_message = use_assistant_message
         self.response_messages: List[Message] = []
 
+        self.last_function_response = self._load_last_function_response()
+
     @trace_method
     async def step(self, input_messages: List[MessageCreate], max_steps: int = 10) -> LettaResponse:
         agent_state = self.agent_manager.get_agent_by_id(self.agent_id, actor=self.actor)
@@ -168,6 +169,7 @@ class LettaAgent(BaseAgent):
         yield f"data: {MessageStreamStatus.done.model_dump_json()}\n\n"
 
     @trace_method
+    # When raising an error this doesn't show up
     async def _get_ai_reply(
         self,
         llm_client: LLMClientBase,
@@ -176,7 +178,13 @@ class LettaAgent(BaseAgent):
         tool_rules_solver: ToolRulesSolver,
         stream: bool,
     ) -> ChatCompletion | AsyncStream[ChatCompletionChunk]:
-        in_context_messages = self._rebuild_memory(in_context_messages, agent_state)
+        if settings.experimental_enable_async_db_engine:
+            in_context_messages = await self._rebuild_memory_async(in_context_messages, agent_state)
+        else:
+            if settings.experimental_skip_rebuild_memory and agent_state.llm_config.model_endpoint_type == "google_vertex":
+                logger.info("Skipping memory rebuild")
+            else:
+                in_context_messages = self._rebuild_memory(in_context_messages, agent_state)
 
         tools = [
             t
@@ -194,7 +202,12 @@ class LettaAgent(BaseAgent):
             or (t.tool_type == ToolType.EXTERNAL_COMPOSIO)
         ]
 
-        valid_tool_names = tool_rules_solver.get_allowed_tool_names(available_tools=set([t.name for t in tools]))
+        # Mirror the sync agent loop: get allowed tools or allow all if none are allowed
+        valid_tool_names = tool_rules_solver.get_allowed_tool_names(
+            available_tools=set([t.name for t in tools]),
+            last_function_response=self.last_function_response,
+        ) or list(set(t.name for t in tools))
+
         # TODO: Copied from legacy agent loop, so please be cautious
         # Set force tool
         force_tool_call = None
@@ -255,6 +268,7 @@ class LettaAgent(BaseAgent):
             tool_args=tool_args,
             agent_state=agent_state,
         )
+        function_response = package_function_response(tool_result, success_flag)
 
         # 4. Register tool call with tool rule solver
         # Resolve whether or not to continue stepping
@@ -283,54 +297,10 @@ class LettaAgent(BaseAgent):
             pre_computed_tool_message_id=pre_computed_tool_message_id,
         )
         persisted_messages = self.message_manager.create_many_messages(tool_call_messages, actor=self.actor)
+        self.last_function_response = function_response
 
         return persisted_messages, continue_stepping
 
-    def _rebuild_memory(self, in_context_messages: List[Message], agent_state: AgentState) -> List[Message]:
-        try:
-            self.agent_manager.refresh_memory(agent_state=agent_state, actor=self.actor)
-
-            # TODO: This is a pretty brittle pattern established all over our code, need to get rid of this
-            curr_system_message = in_context_messages[0]
-            curr_memory_str = agent_state.memory.compile()
-            curr_system_message_text = curr_system_message.content[0].text
-            if curr_memory_str in curr_system_message_text:
-                # NOTE: could this cause issues if a block is removed? (substring match would still work)
-                logger.debug(
-                    f"Memory hasn't changed for agent id={agent_state.id} and actor=({self.actor.id}, {self.actor.name}), skipping system prompt rebuild"
-                )
-                return in_context_messages
-
-            memory_edit_timestamp = get_utc_time()
-
-            num_messages = self.message_manager.size(actor=self.actor, agent_id=agent_state.id)
-            num_archival_memories = self.passage_manager.size(actor=self.actor, agent_id=agent_state.id)
-
-            new_system_message_str = compile_system_message(
-                system_prompt=agent_state.system,
-                in_context_memory=agent_state.memory,
-                in_context_memory_last_edit=memory_edit_timestamp,
-                previous_message_count=num_messages,
-                archival_memory_size=num_archival_memories,
-            )
-
-            diff = united_diff(curr_system_message_text, new_system_message_str)
-            if len(diff) > 0:
-                logger.debug(f"Rebuilding system with new memory...\nDiff:\n{diff}")
-
-                new_system_message = self.message_manager.update_message_by_id(
-                    curr_system_message.id, message_update=MessageUpdate(content=new_system_message_str), actor=self.actor
-                )
-
-                # Skip pulling down the agent's memory again to save on a db call
-                return [new_system_message] + in_context_messages[1:]
-
-            else:
-                return in_context_messages
-        except:
-            logger.exception(f"Failed to rebuild memory for agent id={agent_state.id} and actor=({self.actor.id}, {self.actor.name})")
-            raise
-
     @trace_method
     async def _execute_tool(self, tool_name: str, tool_args: dict, agent_state: AgentState) -> Tuple[str, bool]:
         """
@@ -348,10 +318,6 @@ class LettaAgent(BaseAgent):
                 results = await self._send_message_to_agents_matching_tags(**tool_args)
                 log_event(name="finish_send_message_to_agents_matching_tags", attributes=tool_args)
                 return json.dumps(results), True
-            elif target_tool.tool_type == ToolType.EXTERNAL_COMPOSIO:
-                log_event(name=f"start_composio_{tool_name}_execution", attributes=tool_args)
-                log_event(name=f"finish_compsio_{tool_name}_execution", attributes=tool_args)
-                return tool_execution_result.func_return, True
             else:
                 tool_execution_manager = ToolExecutionManager(agent_state=agent_state, actor=self.actor)
                 # TODO: Integrate sandbox result
@@ -416,3 +382,17 @@ class LettaAgent(BaseAgent):
         tasks = [asyncio.create_task(process_agent(agent_state=agent_state, message=message)) for agent_state in matching_agents]
         results = await asyncio.gather(*tasks)
         return results
+
+    def _load_last_function_response(self):
+        """Load the last function response from message history"""
+        in_context_messages = self.agent_manager.get_in_context_messages(agent_id=self.agent_id, actor=self.actor)
+        for msg in reversed(in_context_messages):
+            if msg.role == MessageRole.tool and msg.content and len(msg.content) == 1 and isinstance(msg.content[0], TextContent):
+                text_content = msg.content[0].text
+                try:
+                    response_json = json.loads(text_content)
+                    if response_json.get("message"):
+                        return response_json["message"]
+                except (json.JSONDecodeError, KeyError):
+                    raise ValueError(f"Invalid JSON format in message: {text_content}")
+        return None

letta/agents/letta_agent_batch.py

@@ -1,11 +1,12 @@
 import json
 import uuid
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
+from typing import Any, AsyncGenerator, Dict, List, Optional, Sequence, Tuple, Union
 
 from aiomultiprocess import Pool
 from anthropic.types.beta.messages import BetaMessageBatchCanceledResult, BetaMessageBatchErroredResult, BetaMessageBatchSucceededResult
 
+from letta.agents.base_agent import BaseAgent
 from letta.agents.helpers import _prepare_in_context_messages
 from letta.helpers import ToolRulesSolver
 from letta.helpers.datetime_helpers import get_utc_time
@@ -16,20 +17,20 @@ from letta.local_llm.constants import INNER_THOUGHTS_KWARG
 from letta.log import get_logger
 from letta.orm.enums import ToolType
 from letta.schemas.agent import AgentState, AgentStepState
-from letta.schemas.enums import AgentStepStatus, JobStatus, ProviderType
+from letta.schemas.enums import AgentStepStatus, JobStatus, MessageStreamStatus, ProviderType
 from letta.schemas.job import JobUpdate
+from letta.schemas.letta_message import LegacyLettaMessage, LettaMessage
 from letta.schemas.letta_message_content import OmittedReasoningContent, ReasoningContent, RedactedReasoningContent, TextContent
 from letta.schemas.letta_request import LettaBatchRequest
-from letta.schemas.letta_response import LettaBatchResponse
+from letta.schemas.letta_response import LettaBatchResponse, LettaResponse
 from letta.schemas.llm_batch_job import LLMBatchItem
-from letta.schemas.message import Message, MessageCreate, MessageUpdate
+from letta.schemas.message import Message, MessageCreate
 from letta.schemas.openai.chat_completion_response import ToolCall as OpenAIToolCall
 from letta.schemas.sandbox_config import SandboxConfig, SandboxType
 from letta.schemas.user import User
 from letta.server.rest_api.utils import create_heartbeat_system_message, create_letta_messages_from_llm_response
 from letta.services.agent_manager import AgentManager
 from letta.services.block_manager import BlockManager
-from letta.services.helpers.agent_manager_helper import compile_system_message
 from letta.services.job_manager import JobManager
 from letta.services.llm_batch_manager import LLMBatchManager
 from letta.services.message_manager import MessageManager
@@ -38,7 +39,6 @@ from letta.services.sandbox_config_manager import SandboxConfigManager
 from letta.services.tool_executor.tool_execution_manager import ToolExecutionManager
 from letta.settings import tool_settings
 from letta.tracing import log_event, trace_method
-from letta.utils import united_diff
 
 logger = get_logger(__name__)
 
@@ -95,7 +95,7 @@ async def execute_tool_wrapper(params: ToolExecutionParams) -> Tuple[str, Tuple[
 
 # TODO: Limitations ->
 # TODO: Only works with anthropic for now
-class LettaAgentBatch:
+class LettaAgentBatch(BaseAgent):
 
     def __init__(
         self,
@@ -539,43 +539,20 @@ class LettaAgentBatch:
         return in_context_messages
 
     # TODO: Make this a bullk function
-    def _rebuild_memory(self, in_context_messages: List[Message], agent_state: AgentState) -> List[Message]:
-        agent_state = self.agent_manager.refresh_memory(agent_state=agent_state, actor=self.actor)
-
-        # TODO: This is a pretty brittle pattern established all over our code, need to get rid of this
-        curr_system_message = in_context_messages[0]
-        curr_memory_str = agent_state.memory.compile()
-        curr_system_message_text = curr_system_message.content[0].text
-        if curr_memory_str in curr_system_message_text:
-            # NOTE: could this cause issues if a block is removed? (substring match would still work)
-            logger.debug(
-                f"Memory hasn't changed for agent id={agent_state.id} and actor=({self.actor.id}, {self.actor.name}), skipping system prompt rebuild"
-            )
-            return in_context_messages
-
-        memory_edit_timestamp = get_utc_time()
-
-        num_messages = self.message_manager.size(actor=self.actor, agent_id=agent_state.id)
-        num_archival_memories = self.passage_manager.size(actor=self.actor, agent_id=agent_state.id)
-
-        new_system_message_str = compile_system_message(
-            system_prompt=agent_state.system,
-            in_context_memory=agent_state.memory,
-            in_context_memory_last_edit=memory_edit_timestamp,
-            previous_message_count=num_messages,
-            archival_memory_size=num_archival_memories,
-        )
-
-        diff = united_diff(curr_system_message_text, new_system_message_str)
-        if len(diff) > 0:
-            logger.debug(f"Rebuilding system with new memory...\nDiff:\n{diff}")
-
-            new_system_message = self.message_manager.update_message_by_id(
-                curr_system_message.id, message_update=MessageUpdate(content=new_system_message_str), actor=self.actor
-            )
+    def _rebuild_memory(
+        self,
+        in_context_messages: List[Message],
+        agent_state: AgentState,
+        num_messages: int | None = None,
+        num_archival_memories: int | None = None,
+    ) -> List[Message]:
+        return super()._rebuild_memory(in_context_messages, agent_state)
 
-            # Skip pulling down the agent's memory again to save on a db call
-            return [new_system_message] + in_context_messages[1:]
+    # Not used in batch.
+    async def step(self, input_messages: List[MessageCreate], max_steps: int = 10) -> LettaResponse:
+        raise NotImplementedError
 
-        else:
-            return in_context_messages
+    async def step_stream(
+        self, input_messages: List[MessageCreate], max_steps: int = 10
+    ) -> AsyncGenerator[Union[LettaMessage, LegacyLettaMessage, MessageStreamStatus], None]:
+        raise NotImplementedError

letta/agents/voice_agent.py

@@ -22,7 +22,7 @@ from letta.orm.enums import ToolType
 from letta.schemas.agent import AgentState, AgentType
 from letta.schemas.enums import MessageRole
 from letta.schemas.letta_response import LettaResponse
-from letta.schemas.message import Message, MessageCreate, MessageUpdate
+from letta.schemas.message import Message, MessageCreate
 from letta.schemas.openai.chat_completion_request import (
     AssistantMessage,
     ChatCompletionRequest,
@@ -47,7 +47,6 @@ from letta.services.passage_manager import PassageManager
 from letta.services.summarizer.enums import SummarizationMode
 from letta.services.summarizer.summarizer import Summarizer
 from letta.settings import model_settings
-from letta.utils import united_diff
 
 logger = get_logger(__name__)
 
@@ -293,48 +292,17 @@ class VoiceAgent(BaseAgent):
             agent_id=self.agent_id, message_ids=[m.id for m in new_in_context_messages], actor=self.actor
         )
 
-    def _rebuild_memory(self, in_context_messages: List[Message], agent_state: AgentState) -> List[Message]:
-        # Refresh memory
-        # TODO: This only happens for the summary block
-        # TODO: We want to extend this refresh to be general, and stick it in agent_manager
-        block_ids = [block.id for block in agent_state.memory.blocks]
-        agent_state.memory.blocks = self.block_manager.get_all_blocks_by_ids(block_ids=block_ids, actor=self.actor)
-
-        # TODO: This is a pretty brittle pattern established all over our code, need to get rid of this
-        curr_system_message = in_context_messages[0]
-        curr_memory_str = agent_state.memory.compile()
-        curr_system_message_text = curr_system_message.content[0].text
-        if curr_memory_str in curr_system_message_text:
-            # NOTE: could this cause issues if a block is removed? (substring match would still work)
-            logger.debug(
-                f"Memory hasn't changed for agent id={agent_state.id} and actor=({self.actor.id}, {self.actor.name}), skipping system prompt rebuild"
-            )
-            return in_context_messages
-
-        memory_edit_timestamp = get_utc_time()
-
-        new_system_message_str = compile_system_message(
-            system_prompt=agent_state.system,
-            in_context_memory=agent_state.memory,
-            in_context_memory_last_edit=memory_edit_timestamp,
-            previous_message_count=self.num_messages,
-            archival_memory_size=self.num_archival_memories,
+    def _rebuild_memory(
+        self,
+        in_context_messages: List[Message],
+        agent_state: AgentState,
+        num_messages: int | None = None,
+        num_archival_memories: int | None = None,
+    ) -> List[Message]:
+        return super()._rebuild_memory(
+            in_context_messages, agent_state, num_messages=self.num_messages, num_archival_memories=self.num_archival_memories
         )
 
-        diff = united_diff(curr_system_message_text, new_system_message_str)
-        if len(diff) > 0:
-            logger.debug(f"Rebuilding system with new memory...\nDiff:\n{diff}")
-
-            new_system_message = self.message_manager.update_message_by_id(
-                curr_system_message.id, message_update=MessageUpdate(content=new_system_message_str), actor=self.actor
-            )
-
-            # Skip pulling down the agent's memory again to save on a db call
-            return [new_system_message] + in_context_messages[1:]
-
-        else:
-            return in_context_messages
-
     def _build_openai_request(self, openai_messages: List[Dict], agent_state: AgentState) -> ChatCompletionRequest:
         tool_schemas = self._build_tool_schemas(agent_state)
         tool_choice = "auto" if tool_schemas else None

letta/functions/schema_generator.py

@@ -466,9 +466,13 @@ def generate_tool_schema_for_mcp(
     name = mcp_tool.name
     description = mcp_tool.description
 
-    assert "type" in parameters_schema
-    assert "required" in parameters_schema
-    assert "properties" in parameters_schema
+    assert "type" in parameters_schema, parameters_schema
+    assert "properties" in parameters_schema, parameters_schema
+    # assert "required" in parameters_schema, parameters_schema
+
+    # Zero-arg tools often omit "required" because nothing is required.
+    # Normalise so downstream code can treat it consistently.
+    parameters_schema.setdefault("required", [])
 
     # Add the optional heartbeat parameter
     if append_heartbeat:

letta/llm_api/anthropic.py

@@ -997,10 +997,12 @@ def anthropic_chat_completions_process_stream(
                         expect_reasoning_content=extended_thinking,
                         name=name,
                         message_index=message_idx,
+                        prev_message_type=prev_message_type,
                     )
-                    if message_type != prev_message_type and message_type is not None:
+                    if message_type != prev_message_type and message_type is not None and prev_message_type is not None:
                         message_idx += 1
-                    prev_message_type = message_type
+                    if message_type is not None:
+                        prev_message_type = message_type
                 elif isinstance(stream_interface, AgentRefreshStreamingInterface):
                     stream_interface.process_refresh(chat_completion_response)
                 else:

letta/llm_api/openai.py

@@ -325,10 +325,12 @@ def openai_chat_completions_process_stream(
                         expect_reasoning_content=expect_reasoning_content,
                         name=name,
                         message_index=message_idx,
+                        prev_message_type=prev_message_type,
                     )
-                    if message_type != prev_message_type and message_type is not None:
+                    if message_type != prev_message_type and message_type is not None and prev_message_type is not None:
                         message_idx += 1
-                    prev_message_type = message_type
+                    if message_type is not None:
+                        prev_message_type = message_type
                 elif isinstance(stream_interface, AgentRefreshStreamingInterface):
                     stream_interface.process_refresh(chat_completion_response)
                 else:

letta/orm/agents_tags.py

@@ -1,4 +1,4 @@
-from sqlalchemy import ForeignKey, String, UniqueConstraint
+from sqlalchemy import ForeignKey, Index, String, UniqueConstraint
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from letta.orm.base import Base
@@ -6,7 +6,10 @@ from letta.orm.base import Base
 
 class AgentsTags(Base):
     __tablename__ = "agents_tags"
-    __table_args__ = (UniqueConstraint("agent_id", "tag", name="unique_agent_tag"),)
+    __table_args__ = (
+        UniqueConstraint("agent_id", "tag", name="unique_agent_tag"),
+        Index("ix_agents_tags_agent_id_tag", "agent_id", "tag"),
+    )
 
     # # agent generates its own id
     # # TODO: We want to migrate all the ORM models to do this, so we will need to move this to the SqlalchemyBase