Platform for stateful agents: AI with advanced memory that can learn and self-improve over time.
feat: recompile system message on new conversation creation (#9508)
github-actions[bot]0020f4b866e0
diff --git a/letta/agents/helpers.py b/letta/agents/helpers.pyindex 28f5d3041..efc8f37f8 100644--- a/letta/agents/helpers.py+++ b/letta/agents/helpers.py@@ -192,44 +192,15 @@ async def _prepare_in_context_messages_no_persist_async(# Otherwise, include the full list of messages from the conversationcurrent_in_context_messages = await message_manager.get_messages_by_ids_async(message_ids=message_ids, actor=actor)else:- # No messages in conversation yet - compile a new system message for this conversation- # Each conversation gets its own system message (captures memory state at conversation start)- from letta.prompts.prompt_generator import PromptGenerator- from letta.services.passage_manager import PassageManager-- num_messages = await message_manager.size_async(actor=actor, agent_id=agent_state.id)- passage_manager = PassageManager()- num_archival_memories = await passage_manager.agent_passage_size_async(actor=actor, agent_id=agent_state.id)-- system_message_str = await PromptGenerator.compile_system_message_async(- system_prompt=agent_state.system,- in_context_memory=agent_state.memory,- in_context_memory_last_edit=get_utc_time(),- timezone=agent_state.timezone,- user_defined_variables=None,- append_icm_if_missing=True,- previous_message_count=num_messages,- archival_memory_size=num_archival_memories,- sources=agent_state.sources,- max_files_open=agent_state.max_files_open,- )- system_message = Message.dict_to_message(- agent_id=agent_state.id,- model=agent_state.llm_config.model,- openai_message_dict={"role": "system", "content": system_message_str},- )-- # Persist the new system message- persisted_messages = await message_manager.create_many_messages_async([system_message], actor=actor)- system_message = persisted_messages[0]-- # Add it to the conversation tracking- await conversation_manager.add_messages_to_conversation(+ # No messages in conversation yet (fallback) - compile a new system message+ # Normally this is handled at conversation creation time, but this covers+ # edge cases where a conversation exists without a system message.+ system_message = await conversation_manager.compile_and_save_system_message_for_conversation(conversation_id=conversation_id,agent_id=agent_state.id,- message_ids=[system_message.id],actor=actor,- starting_position=0,+ agent_state=agent_state,+ message_manager=message_manager,)current_in_context_messages = [system_message]diff --git a/letta/services/conversation_manager.py b/letta/services/conversation_manager.pyindex 3b95a2e60..f499c5878 100644--- a/letta/services/conversation_manager.py+++ b/letta/services/conversation_manager.py@@ -7,6 +7,7 @@ if TYPE_CHECKING:from sqlalchemy import and_, asc, delete, desc, func, nulls_last, or_, selectfrom letta.errors import LettaInvalidArgumentError+from letta.helpers.datetime_helpers import get_utc_timefrom letta.orm.agent import Agent as AgentModelfrom letta.orm.block import Block as BlockModelfrom letta.orm.blocks_conversations import BlocksConversations@@ -73,7 +74,101 @@ class ConversationManager:pydantic_conversation = conversation.to_pydantic()pydantic_conversation.isolated_block_ids = isolated_block_ids- return pydantic_conversation++ # Compile and persist the initial system message for this conversation+ # This ensures the conversation captures the latest memory block state at creation time+ await self.compile_and_save_system_message_for_conversation(+ conversation_id=pydantic_conversation.id,+ agent_id=agent_id,+ actor=actor,+ )++ return pydantic_conversation++ @trace_method+ async def compile_and_save_system_message_for_conversation(+ self,+ conversation_id: str,+ agent_id: str,+ actor: PydanticUser,+ agent_state: Optional["AgentState"] = None,+ message_manager: Optional[object] = None,+ ) -> PydanticMessage:+ """Compile and persist the initial system message for a conversation.++ This recompiles the system prompt with the latest memory block values+ and metadata, ensuring the conversation starts with an up-to-date+ system message.++ This is the single source of truth for creating a conversation's system+ message — used both at conversation creation time and as a fallback+ when a conversation has no messages yet.++ Args:+ conversation_id: The conversation to add the system message to+ agent_id: The agent this conversation belongs to+ actor: The user performing the action+ agent_state: Optional pre-loaded agent state (avoids redundant DB load)+ message_manager: Optional pre-loaded MessageManager instance++ Returns:+ The persisted system message+ """+ # Lazy imports to avoid circular dependencies+ from letta.prompts.prompt_generator import PromptGenerator+ from letta.services.message_manager import MessageManager+ from letta.services.passage_manager import PassageManager++ if message_manager is None:+ message_manager = MessageManager()++ if agent_state is None:+ from letta.services.agent_manager import AgentManager++ agent_state = await AgentManager().get_agent_by_id_async(+ agent_id=agent_id,+ include_relationships=["memory", "sources"],+ actor=actor,+ )++ passage_manager = PassageManager()+ num_messages = await message_manager.size_async(actor=actor, agent_id=agent_id)+ num_archival_memories = await passage_manager.agent_passage_size_async(actor=actor, agent_id=agent_id)++ # Compile the system message with current memory state+ system_message_str = await PromptGenerator.compile_system_message_async(+ system_prompt=agent_state.system,+ in_context_memory=agent_state.memory,+ in_context_memory_last_edit=get_utc_time(),+ timezone=agent_state.timezone,+ user_defined_variables=None,+ append_icm_if_missing=True,+ previous_message_count=num_messages,+ archival_memory_size=num_archival_memories,+ sources=agent_state.sources,+ max_files_open=agent_state.max_files_open,+ )++ system_message = PydanticMessage.dict_to_message(+ agent_id=agent_id,+ model=agent_state.llm_config.model,+ openai_message_dict={"role": "system", "content": system_message_str},+ )++ # Persist the new system message+ persisted_messages = await message_manager.create_many_messages_async([system_message], actor=actor)+ system_message = persisted_messages[0]++ # Add it to the conversation tracking at position 0+ await self.add_messages_to_conversation(+ conversation_id=conversation_id,+ agent_id=agent_id,+ message_ids=[system_message.id],+ actor=actor,+ starting_position=0,+ )++ return system_message@enforce_types@trace_methoddiff --git a/tests/integration_test_conversations_sdk.py b/tests/integration_test_conversations_sdk.pyindex 129e0ecfa..45462d717 100644--- a/tests/integration_test_conversations_sdk.py+++ b/tests/integration_test_conversations_sdk.py@@ -62,12 +62,14 @@ class TestConversationsSDK:# Create a conversationcreated = client.conversations.create(agent_id=agent.id)- # Retrieve it (should have empty in_context_message_ids initially)+ # Retrieve it (should have system message from creation)retrieved = client.conversations.retrieve(conversation_id=created.id)assert retrieved.id == created.idassert retrieved.agent_id == created.agent_id- assert retrieved.in_context_message_ids == []+ # Conversation should have 1 system message immediately after creation+ assert len(retrieved.in_context_message_ids) == 1+ assert retrieved.in_context_message_ids[0].startswith("message-")# Send a message to the conversationlist(@@ -834,3 +836,132 @@ class TestConversationCompact:)assert response.status_code == 404+++class TestConversationSystemMessageRecompilation:+ """Tests that verify the system message is recompiled with latest memory state on new conversation creation."""++ def test_new_conversation_recompiles_system_message_with_updated_memory(self, client: Letta, server_url: str):+ """Test the full workflow:+ 1. Agent is created+ 2. Send message to agent (through a conversation)+ 3. Modify the memory block -> check system message is NOT updated with the modified value+ 4. Create a new conversation+ 5. Check new conversation system message DOES have the modified value+ """+ unique_marker = f"UNIQUE_MARKER_{uuid.uuid4().hex[:8]}"++ # Step 1: Create an agent with known memory blocks+ agent = client.agents.create(+ name=f"test_sys_msg_recompile_{uuid.uuid4().hex[:8]}",+ model="openai/gpt-4o-mini",+ embedding="openai/text-embedding-3-small",+ memory_blocks=[+ {"label": "human", "value": "The user is a test user."},+ {"label": "persona", "value": "You are a helpful assistant."},+ ],+ )++ try:+ # Step 2: Create a conversation and send a message to it+ conv1 = client.conversations.create(agent_id=agent.id)++ list(+ client.conversations.messages.create(+ conversation_id=conv1.id,+ messages=[{"role": "user", "content": "Hello, just a quick test."}],+ )+ )++ # Verify the conversation has messages including a system message+ conv1_messages = client.conversations.messages.list(+ conversation_id=conv1.id,+ order="asc",+ )+ assert len(conv1_messages) >= 3 # system + user + assistant+ assert conv1_messages[0].message_type == "system_message"++ # Get the original system message content+ original_system_content = conv1_messages[0].content+ assert unique_marker not in original_system_content, "Marker should not be in original system message"++ # Step 3: Modify the memory block with a unique marker+ client.agents.blocks.update(+ agent_id=agent.id,+ block_label="human",+ value=f"The user is a test user. {unique_marker}",+ )++ # Verify the block was actually updated+ updated_block = client.agents.blocks.retrieve(agent_id=agent.id, block_label="human")+ assert unique_marker in updated_block.value++ # Check that the OLD conversation's system message is NOT updated+ conv1_messages_after_update = client.conversations.messages.list(+ conversation_id=conv1.id,+ order="asc",+ )+ old_system_content = conv1_messages_after_update[0].content+ assert unique_marker not in old_system_content, (+ "Old conversation system message should NOT contain the updated memory value"+ )++ # Step 4: Create a new conversation+ conv2 = client.conversations.create(agent_id=agent.id)++ # Step 5: Check the new conversation's system message has the updated value+ # The system message should be compiled at creation time with the latest memory+ conv2_retrieved = client.conversations.retrieve(conversation_id=conv2.id)+ assert len(conv2_retrieved.in_context_message_ids) == 1, (+ f"New conversation should have exactly 1 system message, got {len(conv2_retrieved.in_context_message_ids)}"+ )++ conv2_messages = client.conversations.messages.list(+ conversation_id=conv2.id,+ order="asc",+ )+ assert len(conv2_messages) >= 1+ assert conv2_messages[0].message_type == "system_message"++ new_system_content = conv2_messages[0].content+ assert unique_marker in new_system_content, (+ f"New conversation system message should contain the updated memory value '{unique_marker}', "+ f"but system message content did not include it"+ )++ finally:+ client.agents.delete(agent_id=agent.id)++ def test_conversation_creation_initializes_system_message(self, client: Letta, server_url: str):+ """Test that creating a conversation immediately initializes it with a system message."""+ agent = client.agents.create(+ name=f"test_conv_init_{uuid.uuid4().hex[:8]}",+ model="openai/gpt-4o-mini",+ embedding="openai/text-embedding-3-small",+ memory_blocks=[+ {"label": "human", "value": "Test user for system message init."},+ {"label": "persona", "value": "You are a helpful assistant."},+ ],+ )++ try:+ # Create a conversation (without sending any messages)+ conversation = client.conversations.create(agent_id=agent.id)++ # Verify the conversation has a system message immediately+ retrieved = client.conversations.retrieve(conversation_id=conversation.id)+ assert len(retrieved.in_context_message_ids) == 1, (+ f"Expected 1 system message after conversation creation, got {len(retrieved.in_context_message_ids)}"+ )++ # Verify the system message content contains memory block values+ messages = client.conversations.messages.list(+ conversation_id=conversation.id,+ order="asc",+ )+ assert len(messages) == 1+ assert messages[0].message_type == "system_message"+ assert "Test user for system message init." in messages[0].content++ finally:+ client.agents.delete(agent_id=agent.id)