Platform for stateful agents: AI with advanced memory that can learn and self-improve over time.
feat: add otid to new agent loop (#1635)
cthomas29fcccb3a43c
diff --git a/letta/agents/base_agent.py b/letta/agents/base_agent.pyindex 8a7930889..3500fba3a 100644--- a/letta/agents/base_agent.py+++ b/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, Unionimport openaifrom 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 TextContentfrom letta.schemas.letta_response import LettaResponse+from letta.schemas.message import MessageCreatefrom letta.schemas.user import Userfrom letta.services.agent_manager import AgentManagerfrom 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):@abstractmethodasync 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]diff --git a/letta/agents/ephemeral_agent.py b/letta/agents/ephemeral_agent.pyindex 91e893432..d951b4349 100644--- a/letta/agents/ephemeral_agent.py+++ b/letta/agents/ephemeral_agent.py@@ -5,9 +5,8 @@ import openaifrom letta.agents.base_agent import BaseAgentfrom letta.schemas.agent import AgentStatefrom letta.schemas.enums import MessageRole-from letta.schemas.letta_message import UserMessagefrom letta.schemas.letta_message_content import TextContent-from letta.schemas.message import Message+from letta.schemas.message import Message, MessageCreatefrom letta.schemas.openai.chat_completion_request import ChatCompletionRequestfrom letta.schemas.user import Userfrom 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."""diff --git a/letta/agents/ephemeral_memory_agent.py b/letta/agents/ephemeral_memory_agent.pyindex 03fc64e07..af765d028 100644--- a/letta/agents/ephemeral_memory_agent.py+++ b/letta/agents/ephemeral_memory_agent.py@@ -7,9 +7,8 @@ from letta.helpers.tool_execution_helper import enable_strict_modefrom letta.orm.enums import ToolTypefrom letta.schemas.agent import AgentStatefrom letta.schemas.enums import MessageRole-from letta.schemas.letta_message import UserMessagefrom letta.schemas.letta_message_content import TextContent-from letta.schemas.message import Message+from letta.schemas.message import Message, MessageCreatefrom letta.schemas.openai.chat_completion_request import ChatCompletionRequest, Toolfrom letta.schemas.user import Userfrom 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."""diff --git a/letta/agents/helpers.py b/letta/agents/helpers.pyindex 9f614510d..9460a7ce0 100644--- a/letta/agents/helpers.py+++ b/letta/agents/helpers.py@@ -1,11 +1,11 @@-from typing import Dict, List, Tuple+from typing import List, Tuplefrom letta.schemas.agent import AgentStatefrom letta.schemas.letta_response import LettaResponse-from letta.schemas.message import Message+from letta.schemas.message import Message, MessageCreatefrom letta.schemas.usage import LettaUsageStatisticsfrom letta.schemas.user import User-from letta.server.rest_api.utils import create_user_message+from letta.server.rest_api.utils import create_input_messagesfrom letta.services.message_manager import MessageManager@@ -20,13 +20,13 @@ def _create_letta_response(new_in_context_messages: list[Message], use_assistantdef _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 itnew_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_messagesdiff --git a/letta/agents/letta_agent.py b/letta/agents/letta_agent.pyindex 128a10731..a158c10ea 100644--- a/letta/agents/letta_agent.py+++ b/letta/agents/letta_agent.py@@ -18,12 +18,11 @@ from letta.local_llm.constants import INNER_THOUGHTS_KWARGfrom letta.log import get_loggerfrom letta.orm.enums import ToolTypefrom letta.schemas.agent import AgentState-from letta.schemas.enums import MessageStreamStatus+from letta.schemas.enums import MessageRole, MessageStreamStatusfrom letta.schemas.letta_message import AssistantMessagefrom letta.schemas.letta_message_content import OmittedReasoningContent, ReasoningContent, RedactedReasoningContent, TextContentfrom 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, MessageUpdatefrom letta.schemas.openai.chat_completion_response import ToolCallfrom letta.schemas.user import Userfrom 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_methodasync 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.messagessend_message_content = [message.content for message in messages if isinstance(message, AssistantMessage)]diff --git a/letta/agents/voice_agent.py b/letta/agents/voice_agent.pyindex 16f8ff972..a0601183a 100644--- a/letta/agents/voice_agent.py+++ b/letta/agents/voice_agent.py@@ -19,8 +19,9 @@ from letta.log import get_loggerfrom letta.orm.enums import ToolTypefrom letta.schemas.agent import AgentStatefrom letta.schemas.block import BlockUpdate+from letta.schemas.letta_message_content import TextContentfrom letta.schemas.letta_response import LettaResponse-from letta.schemas.message import Message, MessageUpdate+from letta.schemas.message import Message, MessageCreate, MessageUpdatefrom letta.schemas.openai.chat_completion_request import (AssistantMessage,ChatCompletionRequest,@@ -34,8 +35,8 @@ from letta.schemas.user import Userfrom 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 AgentManagerfrom 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 herefor _ in range(max_steps):@@ -372,7 +372,7 @@ class VoiceAgent(BaseAgent):return f"Failed to call tool. Error: {e}", Falseasync 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.actordiff --git a/letta/server/rest_api/routers/v1/agents.py b/letta/server/rest_api/routers/v1/agents.pyindex fa6012817..c6744b10c 100644--- a/letta/server/rest_api/routers/v1/agents.py+++ b/letta/server/rest_api/routers/v1/agents.py@@ -22,7 +22,6 @@ from letta.schemas.letta_request import LettaRequest, LettaStreamingRequestfrom letta.schemas.letta_response import LettaResponsefrom letta.schemas.memory import ContextWindowOverview, CreateArchivalMemory, Memoryfrom letta.schemas.message import MessageCreate-from letta.schemas.openai.chat_completion_request import UserMessagefrom letta.schemas.passage import Passage, PassageUpdatefrom letta.schemas.run import Runfrom letta.schemas.source import Source@@ -610,9 +609,7 @@ async def send_message(actor=actor,)- messages = request.messages- content = messages[0].content[0].text if messages and not isinstance(messages[0].content, str) else messages[0].content- result = await experimental_agent.step(UserMessage(content=content), max_steps=10)+ result = await experimental_agent.step(request.messages, max_steps=10)else:result = await server.send_message_to_agent(agent_id=agent_id,@@ -672,10 +669,8 @@ async def send_message_streaming(actor=actor,)- messages = request.messages- content = messages[0].content[0].text if messages and not isinstance(messages[0].content, str) else messages[0].contentresult = StreamingResponse(- experimental_agent.step_stream(UserMessage(content=content), max_steps=10, use_assistant_message=request.use_assistant_message),+ experimental_agent.step_stream(request.messages, max_steps=10, use_assistant_message=request.use_assistant_message),media_type="text/event-stream",)else:diff --git a/letta/server/rest_api/utils.py b/letta/server/rest_api/utils.pyindex a8aea9598..af944ec12 100644--- a/letta/server/rest_api/utils.py+++ b/letta/server/rest_api/utils.py@@ -19,7 +19,7 @@ from letta.helpers.datetime_helpers import get_utc_timefrom letta.log import get_loggerfrom letta.schemas.enums import MessageRolefrom letta.schemas.letta_message_content import OmittedReasoningContent, ReasoningContent, RedactedReasoningContent, TextContent-from letta.schemas.message import Message+from letta.schemas.message import Message, MessageCreatefrom letta.schemas.usage import LettaUsageStatisticsfrom letta.schemas.user import Userfrom letta.server.rest_api.interface import StreamingServerInterface@@ -140,31 +140,29 @@ def log_error_to_sentry(e):sentry_sdk.capture_exception(e)-def create_user_message(input_message: dict, agent_id: str, actor: User) -> Message:+def create_input_messages(input_messages: List[MessageCreate], agent_id: str, actor: User) -> List[Message]:"""Converts a user input message into the internal structured format."""- # Generate timestamp in the correct format- # Skip pytz for performance reasons- now = get_utc_time().isoformat()-- # Format message as structured JSON- structured_message = {"type": "user_message", "message": input_message["content"], "time": now}-- # Construct the Message object- user_message = Message(- id=f"message-{uuid.uuid4()}",- role=MessageRole.user,- content=[TextContent(text=json.dumps(structured_message, indent=2))], # Store structured JSON- organization_id=actor.organization_id,- agent_id=agent_id,- model=None,- tool_calls=None,- tool_call_id=None,- created_at=get_utc_time(),- )+ new_messages = []+ for input_message in input_messages:+ # Construct the Message object+ new_message = Message(+ id=f"message-{uuid.uuid4()}",+ role=input_message.role,+ content=input_message.content,+ name=input_message.name,+ otid=input_message.otid,+ organization_id=actor.organization_id,+ agent_id=agent_id,+ model=None,+ tool_calls=None,+ tool_call_id=None,+ created_at=get_utc_time(),+ )+ new_messages.append(new_message)- return user_message+ return new_messagesdef create_letta_messages_from_llm_response(diff --git a/letta/services/summarizer/summarizer.py b/letta/services/summarizer/summarizer.pyindex a726ce01e..45f7b01fc 100644--- a/letta/services/summarizer/summarizer.py+++ b/letta/services/summarizer/summarizer.py@@ -4,8 +4,8 @@ from typing import List, Tuplefrom letta.agents.base_agent import BaseAgentfrom letta.schemas.enums import MessageRole-from letta.schemas.message import Message-from letta.schemas.openai.chat_completion_request import UserMessage+from letta.schemas.letta_message_content import TextContent+from letta.schemas.message import Message, MessageCreatefrom letta.services.summarizer.enums import SummarizationMode@@ -95,8 +95,15 @@ class Summarizer:"It should be in note-taking format in natural English. You are to return the new, updated memory only.")- messages = await self.summarizer_agent.step(UserMessage(content=summary_request_text))- current_summary = "\n".join([m.content[0].text for m in messages])+ response = await self.summarizer_agent.step(+ input_messages=[+ MessageCreate(+ role=MessageRole.user,+ content=[TextContent(text=summary_request_text)],+ ),+ ],+ )+ current_summary = "\n".join([m.content[0].text for m in response.messages if m.message_type == "assistant_message"])current_summary = f"{self.summary_prefix}{current_summary}"return updated_in_context_messages, current_summary, Truediff --git a/tests/integration_test_experimental.py b/tests/integration_test_experimental.pyindex 71268b213..6ade107b2 100644--- a/tests/integration_test_experimental.py+++ b/tests/integration_test_experimental.py@@ -7,14 +7,15 @@ import httpximport openaiimport pytestfrom dotenv import load_dotenv-from letta_client import CreateBlock, Letta+from letta_client import CreateBlock, Letta, MessageCreate, TextContentfrom openai.types.chat.chat_completion_chunk import ChatCompletionChunkfrom letta.agents.letta_agent import LettaAgentfrom letta.schemas.embedding_config import EmbeddingConfigfrom letta.schemas.enums import MessageStreamStatus+from letta.schemas.letta_message_content import TextContent as LettaTextContentfrom letta.schemas.llm_config import LLMConfig-from letta.schemas.openai.chat_completion_request import UserMessage+from letta.schemas.message import MessageCreate as LettaMessageCreatefrom letta.schemas.tool import ToolCreatefrom letta.schemas.usage import LettaUsageStatisticsfrom letta.services.agent_manager import AgentManager@@ -248,7 +249,7 @@ async def test_new_agent_loop(disable_e2b_api_key, openai_client, agent_state, mactor=actor,)- response = await agent.step(UserMessage(content=message))+ response = await agent.step([LettaMessageCreate(role="user", content=[LettaTextContent(text=message)])])@pytest.mark.asyncio@@ -265,7 +266,7 @@ async def test_rethink_tool(disable_e2b_api_key, openai_client, agent_state, mes)assert "chicken" not in AgentManager().get_agent_by_id(agent_state.id, actor).memory.get_block("human").value- response = await agent.step(UserMessage(content=message))+ response = await agent.step([LettaMessageCreate(role="user", content=[LettaTextContent(text=message)])])assert "chicken" in AgentManager().get_agent_by_id(agent_state.id, actor).memory.get_block("human").value@@ -275,9 +276,16 @@ async def test_multi_agent_broadcast(disable_e2b_api_key, client, openai_client,stale_agents = AgentManager().list_agents(actor=actor, limit=300)for agent in stale_agents:- client.delete_agent(agent_id=agent.id)+ AgentManager().delete_agent(agent_id=agent.id, actor=actor)- manager_agent_state = client.create_agent(name=f"manager", include_base_tools=True, include_multi_agent_tools=True, tags=["manager"])+ manager_agent_state = client.agents.create(+ name=f"manager",+ include_base_tools=True,+ include_multi_agent_tools=True,+ tags=["manager"],+ model="openai/gpt-4o",+ embedding="letta/letta-free",+ )manager_agent = LettaAgent(agent_id=manager_agent_state.id,message_manager=MessageManager(),@@ -290,12 +298,31 @@ async def test_multi_agent_broadcast(disable_e2b_api_key, client, openai_client,tag = "subagent"workers = []for idx in range(30):- workers.append(client.create_agent(name=f"worker_{idx}", include_base_tools=True, tags=[tag], tool_ids=[weather_tool.id]))+ workers.append(+ client.agents.create(+ name=f"worker_{idx}",+ include_base_tools=True,+ tags=[tag],+ tool_ids=[weather_tool.id],+ model="openai/gpt-4o",+ embedding="letta/letta-free",+ ),+ )response = await manager_agent.step(- UserMessage(- content="Use the `send_message_to_agents_matching_tags` tool to send a message to agents with tag 'subagent' asking them to check the weather in Seattle.",- )+ [+ LettaMessageCreate(+ role="user",+ content=[+ LettaTextContent(+ text=(+ "Use the `send_message_to_agents_matching_tags` tool to send a message to agents with "+ "tag 'subagent' asking them to check the weather in Seattle."+ )+ ),+ ],+ ),+ ])@@ -334,10 +361,14 @@ def test_multi_agent_broadcast_client(client: Letta, weather_tool):response = client.agents.messages.create(agent_id=supervisor.id,messages=[- {- "role": "user",- "content": "Use the `send_message_to_agents_matching_tags` tool to send a message to agents with tag 'worker' asking them to check the weather in Seattle.",- }+ MessageCreate(+ role="user",+ content=[+ TextContent(+ text="Use the `send_message_to_agents_matching_tags` tool to send a message to agents with tag 'worker' asking them to check the weather in Seattle."+ )+ ],+ )],)end = time.perf_counter()@@ -456,10 +487,10 @@ def test_anthropic_streaming(client: Letta):response = client.agents.messages.create_stream(agent_id=agent.id,messages=[- {- "role": "user",- "content": "Use core memory append to append `banana` to the persona core memory.",- }+ MessageCreate(+ role="user",+ content=[TextContent(text="Use the core memory append tool to append `banana` to the persona core memory.")],+ ),],stream_tokens=True,)