Platform for stateful agents: AI with advanced memory that can learn and self-improve over time.
fix(core): bulk soft-delete conversation messages [LET-7864] (#9834)
Sarah Wooders22d4343c2fbe
diff --git a/letta/helpers/tpuf_client.py b/letta/helpers/tpuf_client.pyindex 4976080a5..76b2c1343 100644--- a/letta/helpers/tpuf_client.py+++ b/letta/helpers/tpuf_client.py@@ -670,6 +670,7 @@ class TurbopufferClient:project_ids_list = []template_ids_list = []conversation_ids_list = []+ is_deleted_list = []for (original_idx, text), embedding in zip(filtered_messages, embeddings):message_id = message_ids[original_idx]@@ -696,6 +697,7 @@ class TurbopufferClient:project_ids_list.append(project_id)template_ids_list.append(template_id)conversation_ids_list.append(conversation_id)+ is_deleted_list.append(False)# build column-based upsert dataupsert_columns = {@@ -706,6 +708,7 @@ class TurbopufferClient:"agent_id": agent_ids_list,"role": message_roles,"created_at": created_at_timestamps,+ "is_deleted": is_deleted_list,}# only include conversation_id if it's provided@@ -734,6 +737,7 @@ class TurbopufferClient:schema={"text": {"type": "string", "full_text_search": True},"conversation_id": {"type": "string"},+ "is_deleted": {"type": "bool"},},)logger.info(f"Successfully inserted {len(ids)} messages to Turbopuffer for agent {agent_id}")@@ -1010,6 +1014,9 @@ class TurbopufferClient:raise@trace_method+ # TODO: Once existing TPUF namespaces are backfilled with is_deleted attribute,+ # add is_deleted=False filter to query_messages_by_agent_id and query_messages_by_org_id.+ # Until then, soft-deleted messages are filtered out via DB post-filter in MessageManager.search_messages_async.async def query_messages_by_agent_id(self,agent_id: str,diff --git a/letta/services/conversation_manager.py b/letta/services/conversation_manager.pyindex 814ffabf7..22ab839eb 100644--- a/letta/services/conversation_manager.py+++ b/letta/services/conversation_manager.py@@ -4,7 +4,7 @@ if TYPE_CHECKING:pass# Import AgentState outside TYPE_CHECKING for @enforce_types decorator-from sqlalchemy import and_, asc, delete, desc, func, nulls_last, or_, select+from sqlalchemy import and_, asc, delete, desc, func, nulls_last, or_, select, updatefrom letta.errors import LettaInvalidArgumentErrorfrom letta.helpers.datetime_helpers import get_utc_time@@ -169,6 +169,7 @@ class ConversationManager:model=agent_state.llm_config.model,openai_message_dict={"role": "system", "content": system_message_str},)+ system_message.conversation_id = conversation_id# Persist the new system messagepersisted_messages = await message_manager.create_many_messages_async([system_message], actor=actor)@@ -408,9 +409,26 @@ class ConversationManager:# Get isolated blocks before modifying conversationisolated_blocks = list(conversation.isolated_blocks)- # Soft delete the conversation first- conversation.is_deleted = True- await conversation.update_async(db_session=session, actor=actor)+ # Bulk soft-delete conversation message associations.+ await session.execute(+ update(ConversationMessageModel)+ .where(ConversationMessageModel.conversation_id == conversation_id)+ .where(ConversationMessageModel.organization_id == actor.organization_id)+ .where(ConversationMessageModel.is_deleted == False)+ .values({ConversationMessageModel.is_deleted: True})+ )++ # Bulk soft-delete messages that belong to this real conversation.+ await session.execute(+ update(MessageModel)+ .where(MessageModel.conversation_id == conversation_id)+ .where(MessageModel.organization_id == actor.organization_id)+ .where(MessageModel.is_deleted == False)+ .values({MessageModel.is_deleted: True})+ )++ # Soft delete the conversation+ await conversation.delete_async(db_session=session, actor=actor)# Hard-delete isolated blocks (Block model doesn't support soft-delete)# Following same pattern as block_manager.delete_block_asyncdiff --git a/letta/services/group_manager.py b/letta/services/group_manager.pyindex 1a5708460..4b4123f10 100644--- a/letta/services/group_manager.py+++ b/letta/services/group_manager.py@@ -218,6 +218,7 @@ class GroupManager:before=before,after=after,limit=limit,+ check_is_deleted=True,**filters,)diff --git a/letta/services/llm_batch_manager.py b/letta/services/llm_batch_manager.pyindex d544adf31..20787d53e 100644--- a/letta/services/llm_batch_manager.py+++ b/letta/services/llm_batch_manager.py@@ -180,6 +180,7 @@ class LLMBatchManager:.join(LLMBatchItem, MessageModel.batch_item_id == LLMBatchItem.id).join(LLMBatchJob, LLMBatchItem.llm_batch_id == LLMBatchJob.id).where(LLMBatchJob.letta_batch_job_id == letta_batch_job_id)+ .where(MessageModel.is_deleted == False))if actor is not None:diff --git a/letta/services/message_manager.py b/letta/services/message_manager.pyindex e4a6ca0c3..3d2eba39d 100644--- a/letta/services/message_manager.py+++ b/letta/services/message_manager.py@@ -352,7 +352,12 @@ class MessageManager:"""Fetch a message by ID."""async with db_registry.async_session() as session:try:- message = await MessageModel.read_async(db_session=session, identifier=message_id, actor=actor)+ message = await MessageModel.read_async(+ db_session=session,+ identifier=message_id,+ actor=actor,+ check_is_deleted=True,+ )return message.to_pydantic()except NoResultFound:return None@@ -362,7 +367,12 @@ class MessageManager:async def get_messages_by_ids_async(self, message_ids: List[str], actor: PydanticUser) -> List[PydanticMessage]:"""Fetch messages by ID and return them in the requested order. Async version of above function."""async with db_registry.async_session() as session:- results = await MessageModel.read_multiple_async(db_session=session, identifiers=message_ids, actor=actor)+ results = await MessageModel.read_multiple_async(+ db_session=session,+ identifiers=message_ids,+ actor=actor,+ check_is_deleted=True,+ )return self._get_messages_by_id_postprocess(results, message_ids)def _get_messages_by_id_postprocess(@@ -931,6 +941,7 @@ class MessageManager:# Build a query that directly filters the Message table by agent_id.query = select(MessageModel)+ query = query.where(MessageModel.is_deleted == False)if agent_id:await validate_agent_exists_async(session, agent_id, actor)@@ -988,7 +999,10 @@ class MessageManager:# Apply 'after' pagination if specified.if after:- after_query = select(MessageModel.sequence_id).where(MessageModel.id == after)+ after_query = select(MessageModel.sequence_id).where(+ MessageModel.id == after,+ MessageModel.is_deleted == False,+ )after_result = await session.execute(after_query)after_ref = after_result.one_or_none()if not after_ref:@@ -998,7 +1012,10 @@ class MessageManager:# Apply 'before' pagination if specified.if before:- before_query = select(MessageModel.sequence_id).where(MessageModel.id == before)+ before_query = select(MessageModel.sequence_id).where(+ MessageModel.id == before,+ MessageModel.is_deleted == False,+ )before_result = await session.execute(before_query)before_ref = before_result.one_or_none()if not before_ref:diff --git a/letta/services/step_manager.py b/letta/services/step_manager.pyindex d89b21f17..019ff403f 100644--- a/letta/services/step_manager.py+++ b/letta/services/step_manager.py@@ -327,6 +327,7 @@ class StepManager:ascending=ascending,limit=limit,actor=actor,+ check_is_deleted=True,step_id=step_id,)return [message.to_pydantic() for message in messages]diff --git a/tests/integration_test_conversations_sdk.py b/tests/integration_test_conversations_sdk.pyindex 27aa81f48..5c38d725d 100644--- a/tests/integration_test_conversations_sdk.py+++ b/tests/integration_test_conversations_sdk.py@@ -92,10 +92,12 @@ class TestConversationsSDK:# Verify message ordering by listing messagesmessages = client.conversations.messages.list(conversation_id=created.id)assert len(messages) >= 3 # system + user + assistant- # First message should be system message (shared across conversations)+ # First message should be system message for this conversation.assert messages[0].message_type == "system_message", f"First message should be system_message, got {messages[0].message_type}"+ assert getattr(messages[0], "conversation_id", None) == created.id# Second message should be user messageassert messages[1].message_type == "user_message", f"Second message should be user_message, got {messages[1].message_type}"+ assert getattr(messages[1], "conversation_id", None) == created.iddef test_send_message_to_conversation(self, client: Letta, agent):"""Test sending a message to a conversation."""@@ -113,6 +115,9 @@ class TestConversationsSDK:# Check response contains messagesassert len(messages) > 0+ for message in messages:+ if hasattr(message, "id"):+ assert getattr(message, "conversation_id", None) == conversation.id# Should have at least an assistant messagemessage_types = [m.message_type for m in messages if hasattr(m, "message_type")]assert "assistant_message" in message_types@@ -771,6 +776,10 @@ class TestConversationsSDK:assert "messages" in data, "Response should contain messages"assert len(data["messages"]) > 0, "Should receive response messages"+ # Default conversation remains virtual, so returned messages should still have no conversation_id.+ for message in data["messages"]:+ assert message.get("conversation_id") is None+# Verify we got an assistant messageassistant_messages = [m for m in data["messages"] if m.get("message_type") == "assistant_message"]assert len(assistant_messages) > 0, "Should receive at least one assistant message"diff --git a/tests/managers/test_conversation_manager.py b/tests/managers/test_conversation_manager.pyindex 18730ee56..ee7c7b0c7 100644--- a/tests/managers/test_conversation_manager.py+++ b/tests/managers/test_conversation_manager.py@@ -197,6 +197,121 @@ async def test_delete_conversation_removes_from_list(conversation_manager, serveassert conv2.id not in conv_ids+async def test_delete_conversation_soft_deletes_messages(conversation_manager, server: SyncServer, sarah_agent, default_user):+ """Test that deleting a conversation soft-deletes messages by Message.conversation_id."""+ from letta.schemas.letta_message_content import TextContent+ from letta.schemas.message import Message as PydanticMessage++ # Create conversation and verify the initial system message is stamped with the conversation ID.+ conversation = await conversation_manager.create_conversation(+ agent_id=sarah_agent.id,+ conversation_create=CreateConversation(summary="Delete with messages"),+ actor=default_user,+ )++ message_ids = await conversation_manager.get_message_ids_for_conversation(+ conversation_id=conversation.id,+ actor=default_user,+ )+ assert len(message_ids) == 1++ system_message = await server.message_manager.get_message_by_id_async(message_ids[0], actor=default_user)+ assert system_message is not None+ assert system_message.conversation_id == conversation.id++ user_message = PydanticMessage(+ agent_id=sarah_agent.id,+ role="user",+ content=[TextContent(text="Message to be soft deleted")],+ conversation_id=conversation.id,+ )+ created_messages = await server.message_manager.create_many_messages_async([user_message], actor=default_user)+ user_message_id = created_messages[0].id++ await conversation_manager.add_messages_to_conversation(+ conversation_id=conversation.id,+ agent_id=sarah_agent.id,+ message_ids=[user_message_id],+ actor=default_user,+ )++ # Sanity-check message is visible before delete+ before_delete = await server.message_manager.get_message_by_id_async(user_message_id, actor=default_user)+ assert before_delete is not None++ # Delete conversation+ await conversation_manager.delete_conversation(+ conversation_id=conversation.id,+ actor=default_user,+ )++ # Both system and user messages should now be hidden (soft-deleted)+ after_delete_system = await server.message_manager.get_message_by_id_async(message_ids[0], actor=default_user)+ after_delete = await server.message_manager.get_message_by_id_async(user_message_id, actor=default_user)+ assert after_delete_system is None+ assert after_delete is None+++async def test_delete_conversation_only_soft_deletes_messages_for_that_conversation(+ conversation_manager, server: SyncServer, sarah_agent, default_user+):+ """Test deleting one conversation does not affect messages from another conversation."""+ from letta.schemas.letta_message_content import TextContent+ from letta.schemas.message import Message as PydanticMessage++ conv1 = await conversation_manager.create_conversation(+ agent_id=sarah_agent.id,+ conversation_create=CreateConversation(summary="Conversation one"),+ actor=default_user,+ )+ conv2 = await conversation_manager.create_conversation(+ agent_id=sarah_agent.id,+ conversation_create=CreateConversation(summary="Conversation two"),+ actor=default_user,+ )++ conv1_message = PydanticMessage(+ agent_id=sarah_agent.id,+ role="user",+ content=[TextContent(text="conv1 message")],+ conversation_id=conv1.id,+ )+ conv2_message = PydanticMessage(+ agent_id=sarah_agent.id,+ role="user",+ content=[TextContent(text="conv2 message")],+ conversation_id=conv2.id,+ )+ created_messages = await server.message_manager.create_many_messages_async([conv1_message, conv2_message], actor=default_user)+ conv1_message_id, conv2_message_id = [message.id for message in created_messages]++ await conversation_manager.add_messages_to_conversation(+ conversation_id=conv1.id,+ agent_id=sarah_agent.id,+ message_ids=[conv1_message_id],+ actor=default_user,+ )+ await conversation_manager.add_messages_to_conversation(+ conversation_id=conv2.id,+ agent_id=sarah_agent.id,+ message_ids=[conv2_message_id],+ actor=default_user,+ )++ await conversation_manager.delete_conversation(+ conversation_id=conv1.id,+ actor=default_user,+ )++ assert await server.message_manager.get_message_by_id_async(conv1_message_id, actor=default_user) is None++ still_visible = await server.message_manager.get_message_by_id_async(conv2_message_id, actor=default_user)+ assert still_visible is not None+ assert still_visible.conversation_id == conv2.id++@pytest.mark.asyncioasync def test_delete_conversation_double_delete_raises(conversation_manager, server: SyncServer, sarah_agent, default_user):"""Test that deleting an already-deleted conversation raises NoResultFound."""diff --git a/tests/managers/test_message_manager.py b/tests/managers/test_message_manager.pyindex 6a689ec79..2f65eca0a 100644--- a/tests/managers/test_message_manager.py+++ b/tests/managers/test_message_manager.py@@ -325,6 +325,57 @@ async def test_message_delete(server: SyncServer, hello_world_message_fixture, dassert retrieved is None+async def test_soft_deleted_message_excluded_from_list_and_getters(server: SyncServer, sarah_agent, default_user):+ """Test soft-deleted messages are excluded from list/get message APIs."""+ message = PydanticMessage(+ agent_id=sarah_agent.id,+ role=MessageRole.user,+ content=[TextContent(text="soft delete visibility test")],+ )++ created = await server.message_manager.create_many_messages_async([message], actor=default_user)+ assert len(created) == 1+ message_id = created[0].id++ # Verify message is initially visible+ assert await server.message_manager.get_message_by_id_async(message_id, actor=default_user) is not None+ fetched_by_ids = await server.message_manager.get_messages_by_ids_async([message_id], actor=default_user)+ assert [m.id for m in fetched_by_ids] == [message_id]++ listed_before = await server.message_manager.list_messages(+ actor=default_user,+ agent_id=sarah_agent.id,+ roles=[MessageRole.user],+ limit=200,+ ascending=False,+ )+ assert message_id in [m.id for m in listed_before]++ # Soft delete message directly in ORM+ from letta.orm.message import Message as MessageModel+ from letta.server.db import db_registry++ async with db_registry.async_session() as session:+ orm_message = await MessageModel.read_async(db_session=session, identifier=message_id, actor=default_user)+ orm_message.is_deleted = True+ await orm_message.update_async(db_session=session, actor=default_user)++ # Verify hidden everywhere+ assert await server.message_manager.get_message_by_id_async(message_id, actor=default_user) is None+ fetched_by_ids_after = await server.message_manager.get_messages_by_ids_async([message_id], actor=default_user)+ assert fetched_by_ids_after == []++ listed_after = await server.message_manager.list_messages(+ actor=default_user,+ agent_id=sarah_agent.id,+ roles=[MessageRole.user],+ limit=200,+ ascending=False,+ )+ assert message_id not in [m.id for m in listed_after]++@pytest.mark.asyncioasync def test_message_conversation_id_persistence(server: SyncServer, sarah_agent, default_user):"""Test that conversation_id is properly persisted and retrieved from DB to Pydantic object"""