Skip to content

armgit / letta

Public Imported from GitHub
0

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.py
index 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 data
upsert_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.py
index 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, update
from letta.errors import LettaInvalidArgumentError
from 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 message
persisted_messages = await message_manager.create_many_messages_async([system_message], actor=actor)
@@ -408,9 +409,26 @@ class ConversationManager:
# Get isolated blocks before modifying conversation
isolated_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_async
diff --git a/letta/services/group_manager.py b/letta/services/group_manager.py
index 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.py
index 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.py
index 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.py
index 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.py
index 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 messages
messages = 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 message
assert 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.id
def 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 messages
assert 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 message
message_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 message
assistant_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.py
index 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, serve
assert 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.asyncio
async 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.py
index 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, d
assert 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.asyncio
async 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"""