letta-nightly 0.6.50.dev20250411104155__py3-none-any.whl → 0.6.52.dev20250412051016__py3-none-any.whl

letta/__init__.py

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

letta/agent.py

@@ -110,19 +110,19 @@ class Agent(BaseAgent):
         self.user = user
 
         # initialize a tool rules solver
-        if agent_state.tool_rules:
-            # if there are tool rules, print out a warning
-            for rule in agent_state.tool_rules:
-                if not isinstance(rule, TerminalToolRule):
-                    warnings.warn("Tool rules only work reliably for the latest OpenAI models that support structured outputs.")
-                    break
-
         self.tool_rules_solver = ToolRulesSolver(tool_rules=agent_state.tool_rules)
 
         # gpt-4, gpt-3.5-turbo, ...
         self.model = self.agent_state.llm_config.model
         self.supports_structured_output = check_supports_structured_output(model=self.model, tool_rules=agent_state.tool_rules)
 
+        # if there are tool rules, print out a warning
+        if not self.supports_structured_output and agent_state.tool_rules:
+            for rule in agent_state.tool_rules:
+                if not isinstance(rule, TerminalToolRule):
+                    warnings.warn("Tool rules only work reliably for model backends that support structured outputs (e.g. OpenAI gpt-4o).")
+                    break
+
         # state managers
         self.block_manager = BlockManager()
 
@@ -236,17 +236,15 @@ class Agent(BaseAgent):
 
         # Extend conversation with function response
         function_response = package_function_response(False, error_msg)
-        new_message = Message.dict_to_message(
+        new_message = Message(
             agent_id=self.agent_state.id,
-            user_id=self.agent_state.created_by_id,
+            # Base info OpenAI-style
             model=self.model,
-            openai_message_dict={
-                "role": "tool",
-                "name": function_name,
-                "content": function_response,
-                "tool_call_id": tool_call_id,
-            },
-            name=self.agent_state.name,
+            role="tool",
+            name=function_name,  # NOTE: when role is 'tool', the 'name' is the function name, not agent name
+            content=[TextContent(text=function_response)],
+            tool_call_id=tool_call_id,
+            # Letta extras
             tool_returns=tool_returns,
             group_id=group_id,
         )
@@ -386,6 +384,7 @@ class Agent(BaseAgent):
                     delay = min(backoff_factor * (2 ** (attempt - 1)), max_delay)
                     warnings.warn(f"Attempt {attempt} failed: {ve}. Retrying in {delay} seconds...")
                     time.sleep(delay)
+                    continue
 
             except Exception as e:
                 # For non-retryable errors, exit immediately
@@ -397,6 +396,7 @@ class Agent(BaseAgent):
                 # trigger summarization
                 log_telemetry(self.logger, "_get_ai_reply summarize_messages_inplace")
                 self.summarize_messages_inplace()
+
             # return the response
             return response
 
@@ -455,7 +455,6 @@ class Agent(BaseAgent):
                 Message.dict_to_message(
                     id=response_message_id,
                     agent_id=self.agent_state.id,
-                    user_id=self.agent_state.created_by_id,
                     model=self.model,
                     openai_message_dict=response_message.model_dump(),
                     name=self.agent_state.name,
@@ -659,17 +658,15 @@ class Agent(BaseAgent):
                 else None
             )
             messages.append(
-                Message.dict_to_message(
+                Message(
                     agent_id=self.agent_state.id,
-                    user_id=self.agent_state.created_by_id,
+                    # Base info OpenAI-style
                     model=self.model,
-                    openai_message_dict={
-                        "role": "tool",
-                        "name": function_name,
-                        "content": function_response,
-                        "tool_call_id": tool_call_id,
-                    },
-                    name=self.agent_state.name,
+                    role="tool",
+                    name=function_name,  # NOTE: when role is 'tool', the 'name' is the function name, not agent name
+                    content=[TextContent(text=function_response)],
+                    tool_call_id=tool_call_id,
+                    # Letta extras
                     tool_returns=[tool_return] if sandbox_run_result else None,
                     group_id=group_id,
                 )
@@ -686,7 +683,6 @@ class Agent(BaseAgent):
                 Message.dict_to_message(
                     id=response_message_id,
                     agent_id=self.agent_state.id,
-                    user_id=self.agent_state.created_by_id,
                     model=self.model,
                     openai_message_dict=response_message.model_dump(),
                     name=self.agent_state.name,
@@ -777,7 +773,6 @@ class Agent(BaseAgent):
                 assert self.agent_state.created_by_id is not None
                 next_input_message = Message.dict_to_message(
                     agent_id=self.agent_state.id,
-                    user_id=self.agent_state.created_by_id,
                     model=self.model,
                     openai_message_dict={
                         "role": "user",  # TODO: change to system?
@@ -789,7 +784,6 @@ class Agent(BaseAgent):
                 assert self.agent_state.created_by_id is not None
                 next_input_message = Message.dict_to_message(
                     agent_id=self.agent_state.id,
-                    user_id=self.agent_state.created_by_id,
                     model=self.model,
                     openai_message_dict={
                         "role": "user",  # TODO: change to system?
@@ -801,7 +795,6 @@ class Agent(BaseAgent):
                 assert self.agent_state.created_by_id is not None
                 next_input_message = Message.dict_to_message(
                     agent_id=self.agent_state.id,
-                    user_id=self.agent_state.created_by_id,
                     model=self.model,
                     openai_message_dict={
                         "role": "user",  # TODO: change to system?
@@ -1057,7 +1050,6 @@ class Agent(BaseAgent):
         assert self.agent_state.created_by_id is not None, "User ID is not set"
         user_message = Message.dict_to_message(
             agent_id=self.agent_state.id,
-            user_id=self.agent_state.created_by_id,
             model=self.model,
             openai_message_dict=openai_message_dict,
             # created_at=timestamp,
@@ -1117,7 +1109,6 @@ class Agent(BaseAgent):
             messages=[
                 Message.dict_to_message(
                     agent_id=self.agent_state.id,
-                    user_id=self.agent_state.created_by_id,
                     model=self.model,
                     openai_message_dict=packed_summary_message,
                 )

letta/agents/base_agent.py

@@ -1,11 +1,13 @@
 from abc import ABC, abstractmethod
-from typing import Any, AsyncGenerator, Optional, Union
+from typing import Any, AsyncGenerator, List, Optional, Union
 
 import openai
 
 from letta.schemas.enums import MessageStreamStatus
-from letta.schemas.letta_message import LegacyLettaMessage, LettaMessage, UserMessage
+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.user import User
 from letta.services.agent_manager import AgentManager
 from letta.services.message_manager import MessageManager
@@ -33,7 +35,7 @@ class BaseAgent(ABC):
         self.actor = actor
 
     @abstractmethod
-    async def step(self, input_message: UserMessage, max_steps: int = 10) -> LettaResponse:
+    async def step(self, input_messages: List[MessageCreate], max_steps: int = 10) -> LettaResponse:
         """
         Main execution loop for the agent.
         """
@@ -41,15 +43,24 @@ class BaseAgent(ABC):
 
     @abstractmethod
     async def step_stream(
-        self, input_message: UserMessage, max_steps: int = 10
+        self, input_messages: List[MessageCreate], max_steps: int = 10
     ) -> AsyncGenerator[Union[LettaMessage, LegacyLettaMessage, MessageStreamStatus], None]:
         """
         Main streaming execution loop for the agent.
         """
         raise NotImplementedError
 
-    def pre_process_input_message(self, input_message: UserMessage) -> Any:
+    def pre_process_input_message(self, input_messages: List[MessageCreate]) -> Any:
         """
         Pre-process function to run on the input_message.
         """
-        return input_message.model_dump()
+
+        def get_content(message: MessageCreate) -> str:
+            if isinstance(message.content, str):
+                return message.content
+            elif message.content and len(message.content) == 1 and isinstance(message.content[0], TextContent):
+                return message.content[0].text
+            else:
+                return ""
+
+        return [{"role": input_message.role, "content": get_content(input_message)} for input_message in input_messages]

letta/agents/ephemeral_agent.py

@@ -5,9 +5,8 @@ import openai
 from letta.agents.base_agent import BaseAgent
 from letta.schemas.agent import AgentState
 from letta.schemas.enums import MessageRole
-from letta.schemas.letta_message import UserMessage
 from letta.schemas.letta_message_content import TextContent
-from letta.schemas.message import Message
+from letta.schemas.message import Message, MessageCreate
 from letta.schemas.openai.chat_completion_request import ChatCompletionRequest
 from letta.schemas.user import User
 from letta.services.agent_manager import AgentManager
@@ -37,15 +36,15 @@ class EphemeralAgent(BaseAgent):
             actor=actor,
         )
 
-    async def step(self, input_message: UserMessage) -> List[Message]:
+    async def step(self, input_messages: List[MessageCreate]) -> List[Message]:
         """
         Synchronous method that takes a user's input text and returns a summary from OpenAI.
         Returns a list of ephemeral Message objects containing both the user text and the assistant summary.
         """
         agent_state = self.agent_manager.get_agent_by_id(agent_id=self.agent_id, actor=self.actor)
 
-        input_message = self.pre_process_input_message(input_message=input_message)
-        request = self._build_openai_request([input_message], agent_state)
+        openai_messages = self.pre_process_input_message(input_messages=input_messages)
+        request = self._build_openai_request(openai_messages, agent_state)
 
         chat_completion = await self.openai_client.chat.completions.create(**request.model_dump(exclude_unset=True))
 
@@ -66,7 +65,7 @@ class EphemeralAgent(BaseAgent):
         )
         return openai_request
 
-    async def step_stream(self, input_message: UserMessage) -> AsyncGenerator[str, None]:
+    async def step_stream(self, input_messages: List[MessageCreate]) -> AsyncGenerator[str, None]:
         """
         This agent is synchronous-only. If called in an async context, raise an error.
         """

letta/agents/ephemeral_memory_agent.py

@@ -7,9 +7,8 @@ from letta.helpers.tool_execution_helper import enable_strict_mode
 from letta.orm.enums import ToolType
 from letta.schemas.agent import AgentState
 from letta.schemas.enums import MessageRole
-from letta.schemas.letta_message import UserMessage
 from letta.schemas.letta_message_content import TextContent
-from letta.schemas.message import Message
+from letta.schemas.message import Message, MessageCreate
 from letta.schemas.openai.chat_completion_request import ChatCompletionRequest, Tool
 from letta.schemas.user import User
 from letta.services.agent_manager import AgentManager
@@ -38,15 +37,15 @@ class EphemeralMemoryAgent(BaseAgent):
             actor=actor,
         )
 
-    async def step(self, input_message: UserMessage) -> List[Message]:
+    async def step(self, input_messages: List[MessageCreate]) -> List[Message]:
         """
         Synchronous method that takes a user's input text and returns a summary from OpenAI.
         Returns a list of ephemeral Message objects containing both the user text and the assistant summary.
         """
         agent_state = self.agent_manager.get_agent_by_id(agent_id=self.agent_id, actor=self.actor)
 
-        input_message = self.pre_process_input_message(input_message=input_message)
-        request = self._build_openai_request([input_message], agent_state)
+        openai_messages = self.pre_process_input_message(input_messages=input_messages)
+        request = self._build_openai_request(openai_messages, agent_state)
 
         chat_completion = await self.openai_client.chat.completions.create(**request.model_dump(exclude_unset=True))
 
@@ -57,7 +56,8 @@ class EphemeralMemoryAgent(BaseAgent):
             )
         ]
 
-    def pre_process_input_message(self, input_message: UserMessage) -> Dict:
+    def pre_process_input_message(self, input_messages: List[MessageCreate]) -> List[Dict]:
+        input_message = input_messages[0]
         input_prompt_augmented = f"""
         You are a memory recall agent whose job is to comb through a large set of messages and write relevant memories in relation to a user query.
         Your response will directly populate a "memory block" called "human" that describes the user, that will be used to answer more questions in the future.
@@ -78,9 +78,7 @@ class EphemeralMemoryAgent(BaseAgent):
         Your response:
         """
 
-        input_message.content = input_prompt_augmented
-        # print(input_prompt_augmented)
-        return input_message.model_dump()
+        return [{"role": "user", "content": input_prompt_augmented}]
 
     def _format_messages_llm_friendly(self):
         messages = self.message_manager.list_messages_for_agent(agent_id=self.agent_id, actor=self.actor)
@@ -107,7 +105,7 @@ class EphemeralMemoryAgent(BaseAgent):
 
         return [Tool(type="function", function=enable_strict_mode(t.json_schema)) for t in tools]
 
-    async def step_stream(self, input_message: UserMessage) -> AsyncGenerator[str, None]:
+    async def step_stream(self, input_messages: List[MessageCreate]) -> AsyncGenerator[str, None]:
         """
         This agent is synchronous-only. If called in an async context, raise an error.
         """

letta/agents/helpers.py

@@ -1,11 +1,11 @@
-from typing import Dict, List, Tuple
+from typing import List, Tuple
 
 from letta.schemas.agent import AgentState
 from letta.schemas.letta_response import LettaResponse
-from letta.schemas.message import Message
+from letta.schemas.message import Message, MessageCreate
 from letta.schemas.usage import LettaUsageStatistics
 from letta.schemas.user import User
-from letta.server.rest_api.utils import create_user_message
+from letta.server.rest_api.utils import create_input_messages
 from letta.services.message_manager import MessageManager
 
 
@@ -20,13 +20,13 @@ def _create_letta_response(new_in_context_messages: list[Message], use_assistant
 
 
 def _prepare_in_context_messages(
-    input_message: Dict, agent_state: AgentState, message_manager: MessageManager, actor: User
+    input_messages: List[MessageCreate], agent_state: AgentState, message_manager: MessageManager, actor: User
 ) -> Tuple[List[Message], List[Message]]:
     """
     Prepares in-context messages for an agent, based on the current state and a new user input.
 
     Args:
-        input_message (Dict): The new user input message to process.
+        input_messages (List[MessageCreate]): The new user input messages to process.
         agent_state (AgentState): The current state of the agent, including message buffer config.
         message_manager (MessageManager): The manager used to retrieve and create messages.
         actor (User): The user performing the action, used for access control and attribution.
@@ -46,7 +46,7 @@ def _prepare_in_context_messages(
 
     # Create a new user message from the input and store it
     new_in_context_messages = message_manager.create_many_messages(
-        [create_user_message(input_message=input_message, agent_id=agent_state.id, actor=actor)], actor=actor
+        create_input_messages(input_messages=input_messages, agent_id=agent_state.id, actor=actor), actor=actor
     )
 
     return current_in_context_messages, new_in_context_messages

letta/agents/letta_agent.py

@@ -18,12 +18,11 @@ 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
-from letta.schemas.enums import MessageStreamStatus
+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, MessageUpdate
-from letta.schemas.openai.chat_completion_request import UserMessage
+from letta.schemas.message import Message, MessageCreate, MessageUpdate
 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
@@ -60,11 +59,10 @@ class LettaAgent(BaseAgent):
         self.use_assistant_message = use_assistant_message
 
     @trace_method
-    async def step(self, input_message: UserMessage, max_steps: int = 10) -> LettaResponse:
-        input_message = self.pre_process_input_message(input_message)
+    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)
         current_in_context_messages, new_in_context_messages = _prepare_in_context_messages(
-            input_message, agent_state, self.message_manager, self.actor
+            input_messages, agent_state, self.message_manager, self.actor
         )
         tool_rules_solver = ToolRulesSolver(agent_state.tool_rules)
         llm_client = LLMClient.create(
@@ -96,16 +94,15 @@ class LettaAgent(BaseAgent):
 
     @trace_method
     async def step_stream(
-        self, input_message: UserMessage, max_steps: int = 10, use_assistant_message: bool = False
+        self, input_messages: List[MessageCreate], max_steps: int = 10, use_assistant_message: bool = False
     ) -> AsyncGenerator[str, None]:
         """
         Main streaming loop that yields partial tokens.
         Whenever we detect a tool call, we yield from _handle_ai_response as well.
         """
-        input_message = self.pre_process_input_message(input_message)
         agent_state = self.agent_manager.get_agent_by_id(self.agent_id, actor=self.actor)
         current_in_context_messages, new_in_context_messages = _prepare_in_context_messages(
-            input_message, agent_state, self.message_manager, self.actor
+            input_messages, agent_state, self.message_manager, self.actor
         )
         tool_rules_solver = ToolRulesSolver(agent_state.tool_rules)
         llm_client = LLMClient.create(
@@ -362,7 +359,9 @@ class LettaAgent(BaseAgent):
                     f"{message}"
                 )
 
-                letta_response = await letta_agent.step(UserMessage(content=augmented_message))
+                letta_response = await letta_agent.step(
+                    [MessageCreate(role=MessageRole.system, content=[TextContent(text=augmented_message)])]
+                )
                 messages = letta_response.messages
 
                 send_message_content = [message.content for message in messages if isinstance(message, AssistantMessage)]

letta/agents/letta_agent_batch.py

@@ -0,0 +1,164 @@
+from typing import Dict, List
+
+from letta.agents.helpers import _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.llm_api.llm_client import LLMClient
+from letta.log import get_logger
+from letta.orm.enums import ToolType
+from letta.schemas.agent import AgentState, AgentStepState
+from letta.schemas.enums import JobStatus, ProviderType
+from letta.schemas.letta_request import LettaBatchRequest
+from letta.schemas.letta_response import LettaBatchResponse
+from letta.schemas.message import Message, MessageCreate, MessageUpdate
+from letta.schemas.user import User
+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.llm_batch_manager import LLMBatchManager
+from letta.services.message_manager import MessageManager
+from letta.services.passage_manager import PassageManager
+from letta.utils import united_diff
+
+logger = get_logger(__name__)
+
+
+# TODO: Limitations ->
+# TODO: Only works with anthropic for now
+class LettaAgentBatch:
+
+    def __init__(
+        self,
+        batch_id: str,
+        message_manager: MessageManager,
+        agent_manager: AgentManager,
+        block_manager: BlockManager,
+        passage_manager: PassageManager,
+        batch_manager: LLMBatchManager,
+        actor: User,
+        use_assistant_message: bool = True,
+        max_steps: int = 10,
+    ):
+        self.batch_id = batch_id
+        self.message_manager = message_manager
+        self.agent_manager = agent_manager
+        self.block_manager = block_manager
+        self.passage_manager = passage_manager
+        self.batch_manager = batch_manager
+        self.use_assistant_message = use_assistant_message
+        self.actor = actor
+        self.max_steps = max_steps
+
+    async def step_until_request(
+        self, batch_requests: List[LettaBatchRequest], agent_step_state_mapping: Dict[str, AgentStepState]
+    ) -> LettaBatchResponse:
+        agent_messages_mapping: Dict[str, List[Message]] = {}
+        agent_tools_mapping: Dict[str, List[dict]] = {}
+        agent_states = []
+
+        for batch_request in batch_requests:
+            agent_id = batch_request.agent_id
+            agent_state = self.agent_manager.get_agent_by_id(agent_id, actor=self.actor)
+            agent_states.append(agent_state)
+            agent_messages_mapping[agent_id] = self.get_in_context_messages_per_agent(
+                agent_state=agent_state, input_messages=batch_request.messages
+            )
+            agent_tools_mapping[agent_id] = self.prepare_tools_per_agent(
+                agent_state, agent_step_state_mapping.get(agent_id).tool_rules_solver
+            )
+
+        # TODO: This is a hack, this is because LLM client expects a LLM config
+        # TODO: But that doesn't really work in batch land
+        # TODO: @caren will factor this out
+        llm_client = LLMClient.create(
+            llm_config=agent_states[0].llm_config,
+            put_inner_thoughts_first=True,
+        )
+        agent_llm_config_mapping = {agent_state.id: agent_state.llm_config for agent_state in agent_states}
+        batch_response = await llm_client.send_llm_batch_request_async(
+            agent_messages_mapping=agent_messages_mapping,
+            agent_tools_mapping=agent_tools_mapping,
+            agent_llm_config_mapping=agent_llm_config_mapping,
+        )
+
+        # Write the response into the jobs table, where it will get picked up by the next cron run
+        batch_job = self.batch_manager.create_batch_job(
+            llm_provider=ProviderType.anthropic,  # TODO: Expand to more
+            create_batch_response=batch_response,
+            actor=self.actor,
+            status=JobStatus.running,
+        )
+
+        # TODO: Make this much more efficient by doing creates in bulk
+        for agent_state in agent_states:
+            agent_step_state = agent_step_state_mapping.get(agent_state.id)
+            self.batch_manager.create_batch_item(
+                batch_id=batch_job.id,
+                agent_id=agent_state.id,
+                llm_config=agent_state.llm_config,
+                actor=self.actor,
+                step_state=agent_step_state,
+            )
+
+        return LettaBatchResponse(
+            batch_id=batch_job.id, status=batch_job.status, last_polled_at=get_utc_time(), created_at=batch_job.created_at
+        )
+
+    async def resume_step_after_request(self, batch_id: str):
+        pass
+
+    def prepare_tools_per_agent(self, agent_state: AgentState, tool_rules_solver: ToolRulesSolver) -> List[dict]:
+        tools = [t for t in agent_state.tools if t.tool_type in {ToolType.CUSTOM, ToolType.LETTA_CORE, ToolType.LETTA_MEMORY_CORE}]
+        valid_tool_names = tool_rules_solver.get_allowed_tool_names(available_tools=set([t.name for t in tools]))
+        return [enable_strict_mode(t.json_schema) for t in tools if t.name in set(valid_tool_names)]
+
+    def get_in_context_messages_per_agent(self, agent_state: AgentState, input_messages: List[MessageCreate]) -> List[Message]:
+        current_in_context_messages, new_in_context_messages = _prepare_in_context_messages(
+            input_messages, agent_state, self.message_manager, self.actor
+        )
+
+        in_context_messages = self._rebuild_memory(current_in_context_messages + new_in_context_messages, agent_state)
+        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
+            )
+
+            # 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

letta/agents/voice_agent.py

@@ -19,8 +19,9 @@ from letta.log import get_logger
 from letta.orm.enums import ToolType
 from letta.schemas.agent import AgentState
 from letta.schemas.block import BlockUpdate
+from letta.schemas.letta_message_content import TextContent
 from letta.schemas.letta_response import LettaResponse
-from letta.schemas.message import Message, MessageUpdate
+from letta.schemas.message import Message, MessageCreate, MessageUpdate
 from letta.schemas.openai.chat_completion_request import (
     AssistantMessage,
     ChatCompletionRequest,
@@ -34,8 +35,8 @@ from letta.schemas.user import User
 from letta.server.rest_api.utils import (
     convert_letta_messages_to_openai,
     create_assistant_messages_from_openai_response,
+    create_input_messages,
     create_letta_messages_from_llm_response,
-    create_user_message,
 )
 from letta.services.agent_manager import AgentManager
 from letta.services.block_manager import BlockManager
@@ -93,19 +94,18 @@ class VoiceAgent(BaseAgent):
             agent_id=agent_id, openai_client=openai_client, message_manager=message_manager, agent_manager=agent_manager, actor=actor
         )
 
-    async def step(self, input_message: UserMessage, max_steps: int = 10) -> LettaResponse:
+    async def step(self, input_messages: List[MessageCreate], max_steps: int = 10) -> LettaResponse:
         raise NotImplementedError("LowLatencyAgent does not have a synchronous step implemented currently.")
 
-    async def step_stream(self, input_message: UserMessage, max_steps: int = 10) -> AsyncGenerator[str, None]:
+    async def step_stream(self, input_messages: List[MessageCreate], max_steps: int = 10) -> AsyncGenerator[str, None]:
         """
         Main streaming loop that yields partial tokens.
         Whenever we detect a tool call, we yield from _handle_ai_response as well.
         """
-        input_message = self.pre_process_input_message(input_message)
         agent_state = self.agent_manager.get_agent_by_id(self.agent_id, actor=self.actor)
         in_context_messages = self.message_manager.get_messages_by_ids(message_ids=agent_state.message_ids, actor=self.actor)
-        letta_message_db_queue = [create_user_message(input_message=input_message, agent_id=agent_state.id, actor=self.actor)]
-        in_memory_message_history = [input_message]
+        letta_message_db_queue = [create_input_messages(input_messages=input_messages, agent_id=agent_state.id, actor=self.actor)]
+        in_memory_message_history = self.pre_process_input_message(input_messages)
 
         # TODO: Define max steps here
         for _ in range(max_steps):
@@ -372,7 +372,7 @@ class VoiceAgent(BaseAgent):
                 return f"Failed to call tool. Error: {e}", False
 
     async def _recall_memory(self, query, agent_state: AgentState) -> None:
-        results = await self.offline_memory_agent.step(UserMessage(content=query))
+        results = await self.offline_memory_agent.step([MessageCreate(role="user", content=[TextContent(text=query)])])
         target_block = next(b for b in agent_state.memory.blocks if b.label == self.summary_block_label)
         self.block_manager.update_block(
             block_id=target_block.id, block_update=BlockUpdate(value=results[0].content[0].text), actor=self.actor

letta/functions/function_sets/base.py

@@ -226,7 +226,7 @@ def core_memory_insert(agent_state: "AgentState", target_block_label: str, new_m
     if line_number is None:
         line_number = len(current_value_list)
     if replace:
-        current_value_list[line_number] = new_memory
+        current_value_list[line_number - 1] = new_memory
     else:
         current_value_list.insert(line_number, new_memory)
     new_value = "\n".join(current_value_list)