Platform for stateful agents: AI with advanced memory that can learn and self-improve over time.
fix: Fix bugs with exporting/importing agents with files (#4089)
Matthew Zhoua2f4ca5f8900
diff --git a/letta/schemas/agent_file.py b/letta/schemas/agent_file.pyindex 02d3988aa..73477c2e6 100644--- a/letta/schemas/agent_file.py+++ b/letta/schemas/agent_file.py@@ -129,7 +129,7 @@ class AgentSchema(CreateAgent):memory_blocks=[], # TODO: Convert from agent_state.memory if neededtools=[],tool_ids=[tool.id for tool in agent_state.tools] if agent_state.tools else [],- source_ids=[], # [source.id for source in agent_state.sources] if agent_state.sources else [],+ source_ids=[source.id for source in agent_state.sources] if agent_state.sources else [],block_ids=[block.id for block in agent_state.memory.blocks],tool_rules=agent_state.tool_rules,tags=agent_state.tags,diff --git a/letta/services/agent_serialization_manager.py b/letta/services/agent_serialization_manager.pyindex 56f324d73..722801ccf 100644--- a/letta/services/agent_serialization_manager.py+++ b/letta/services/agent_serialization_manager.py@@ -1,3 +1,4 @@+import uuidfrom datetime import datetime, timezonefrom typing import Any, Dict, List, Optional@@ -519,8 +520,20 @@ class AgentSerializationManager:if schema.sources:# convert source schemas to pydantic sourcespydantic_sources = []++ # First, do a fast batch check for existing source names to avoid conflicts+ source_names_to_check = [s.name for s in schema.sources]+ existing_source_names = await self.source_manager.get_existing_source_names(source_names_to_check, actor)+for source_schema in schema.sources:source_data = source_schema.model_dump(exclude={"id", "embedding", "embedding_chunk_size"})++ # Check if source name already exists, if so add unique suffix+ original_name = source_data["name"]+ if original_name in existing_source_names:+ unique_suffix = uuid.uuid4().hex[:8]+ source_data["name"] = f"{original_name}_{unique_suffix}"+pydantic_sources.append(Source(**source_data))# bulk upsert all sources at once@@ -529,13 +542,15 @@ class AgentSerializationManager:# map file ids to database ids# note: sources are matched by name during upsert, so we need to match by name here toocreated_sources_by_name = {source.name: source for source in created_sources}- for source_schema in schema.sources:- created_source = created_sources_by_name.get(source_schema.name)+ for i, source_schema in enumerate(schema.sources):+ # Use the pydantic source name (which may have been modified for uniqueness)+ source_name = pydantic_sources[i].name+ created_source = created_sources_by_name.get(source_name)if created_source:file_to_db_ids[source_schema.id] = created_source.idimported_count += 1else:- logger.warning(f"Source {source_schema.name} was not created during bulk upsert")+ logger.warning(f"Source {source_name} was not created during bulk upsert")# 4. Create files (depends on sources)for file_schema in schema.files:@@ -595,6 +610,10 @@ class AgentSerializationManager:if agent_data.get("block_ids"):agent_data["block_ids"] = [file_to_db_ids[file_id] for file_id in agent_data["block_ids"]]+ # Remap source_ids from file IDs to database IDs+ if agent_data.get("source_ids"):+ agent_data["source_ids"] = [file_to_db_ids[file_id] for file_id in agent_data["source_ids"]]+if env_vars:for var in agent_data["tool_exec_environment_variables"]:var["value"] = env_vars.get(var["key"], "")@@ -641,14 +660,16 @@ class AgentSerializationManager:for file_agent_schema in agent_schema.files_agents:file_db_id = file_to_db_ids[file_agent_schema.file_id]- # Use cached file metadata if available+ # Use cached file metadata if available (with content)if file_db_id not in file_metadata_cache:- file_metadata_cache[file_db_id] = await self.file_manager.get_file_by_id(file_db_id, actor)+ file_metadata_cache[file_db_id] = await self.file_manager.get_file_by_id(+ file_db_id, actor, include_content=True+ )file_metadata = file_metadata_cache[file_db_id]files_for_agent.append(file_metadata)if file_agent_schema.visible_content:- visible_content_map[file_db_id] = file_agent_schema.visible_content+ visible_content_map[file_metadata.file_name] = file_agent_schema.visible_content# Bulk attach files to agentawait self.file_agent_manager.attach_files_bulk(diff --git a/letta/services/source_manager.py b/letta/services/source_manager.pyindex dbab4f29e..28b314b04 100644--- a/letta/services/source_manager.py+++ b/letta/services/source_manager.py@@ -143,7 +143,6 @@ class SourceManager:update_dict[col.name] = excluded[col.name]upsert_stmt = stmt.on_conflict_do_update(index_elements=["name", "organization_id"], set_=update_dict)-await session.execute(upsert_stmt)await session.commit()@@ -397,3 +396,29 @@ class SourceManager:sources_orm = result.scalars().all()return [source.to_pydantic() for source in sources_orm]++ @enforce_types+ @trace_method+ async def get_existing_source_names(self, source_names: List[str], actor: PydanticUser) -> set[str]:+ """+ Fast batch check to see which source names already exist for the organization.++ Args:+ source_names: List of source names to check+ actor: User performing the action++ Returns:+ Set of source names that already exist+ """+ if not source_names:+ return set()++ async with db_registry.async_session() as session:+ query = select(SourceModel.name).where(+ SourceModel.name.in_(source_names), SourceModel.organization_id == actor.organization_id, SourceModel.is_deleted == False+ )++ result = await session.execute(query)+ existing_names = result.scalars().all()++ return set(existing_names)diff --git a/poetry.lock b/poetry.lockindex 7a5489388..3d2d408d3 100644--- a/poetry.lock+++ b/poetry.lock@@ -3473,13 +3473,13 @@ vcr = ["vcrpy (>=7.0.0)"][[package]]name = "letta-client"-version = "0.1.271"+version = "0.1.272"description = ""optional = falsepython-versions = "<4.0,>=3.8"files = [- {file = "letta_client-0.1.271-py3-none-any.whl", hash = "sha256:edbf6323e472202090113147b1c9ed280151d4966999686046d48c50c19c74fc"},- {file = "letta_client-0.1.271.tar.gz", hash = "sha256:ae7944e594fe87dd80ce5057c42806e8c24b55e11f8fe6d05420fbc5af9b4180"},+ {file = "letta_client-0.1.272-py3-none-any.whl", hash = "sha256:ed5afffce9431e9dd1170c642efc68b1b5edadfe1923a467f017588dd371447e"},+ {file = "letta_client-0.1.272.tar.gz", hash = "sha256:40bb1e802aeabbb9cb6eaa2105eff7e8a704ac0962623e4b27d6320e57029dcc"},][package.dependencies]diff --git a/tests/helpers/utils.py b/tests/helpers/utils.pyindex 244676886..7ce5b989c 100644--- a/tests/helpers/utils.py+++ b/tests/helpers/utils.py@@ -278,3 +278,39 @@ async def upload_test_agentfile_from_disk_async(client: AsyncLetta, filename: stwith open(file_path, "rb") as f:uploaded = await client.agents.import_file(file=f, append_copy_suffix=True, override_existing_tools=False)return uploaded+++def upload_file_and_wait(+ client: Letta,+ source_id: str,+ file_path: str,+ name: Optional[str] = None,+ max_wait: int = 60,+ duplicate_handling: Optional["DuplicateFileHandling"] = None,+):+ """Helper function to upload a file and wait for processing to complete"""+ from letta_client import DuplicateFileHandling as ClientDuplicateFileHandling++ with open(file_path, "rb") as f:+ if duplicate_handling:+ # handle both client and server enum types+ if hasattr(duplicate_handling, "value"):+ # server enum type+ duplicate_handling = ClientDuplicateFileHandling(duplicate_handling.value)+ file_metadata = client.sources.files.upload(source_id=source_id, file=f, duplicate_handling=duplicate_handling, name=name)+ else:+ file_metadata = client.sources.files.upload(source_id=source_id, file=f, name=name)++ # wait for the file to be processed+ start_time = time.time()+ while file_metadata.processing_status != "completed" and file_metadata.processing_status != "error":+ if time.time() - start_time > max_wait:+ raise TimeoutError(f"File processing timed out after {max_wait} seconds")+ time.sleep(1)+ file_metadata = client.sources.get_file_metadata(source_id=source_id, file_id=file_metadata.id)+ print("Waiting for file processing to complete...", file_metadata.processing_status)++ if file_metadata.processing_status == "error":+ raise RuntimeError(f"File processing failed: {file_metadata.error_message}")++ return file_metadatadiff --git a/tests/test_managers.py b/tests/test_managers.pyindex 02956d8fe..adeadd41e 100644--- a/tests/test_managers.py+++ b/tests/test_managers.py@@ -5698,6 +5698,59 @@ async def test_get_set_blocks_for_identities(server: SyncServer, default_block,# ======================================================================================================================+async def test_get_existing_source_names(server: SyncServer, default_user, event_loop):+ """Test the fast batch check for existing source names."""+ # Create some test sources+ source1 = PydanticSource(+ name="test_source_1",+ embedding_config=EmbeddingConfig(+ embedding_endpoint_type="openai",+ embedding_endpoint="https://api.openai.com/v1",+ embedding_model="text-embedding-ada-002",+ embedding_dim=1536,+ embedding_chunk_size=300,+ ),+ )+ source2 = PydanticSource(+ name="test_source_2",+ embedding_config=EmbeddingConfig(+ embedding_endpoint_type="openai",+ embedding_endpoint="https://api.openai.com/v1",+ embedding_model="text-embedding-ada-002",+ embedding_dim=1536,+ embedding_chunk_size=300,+ ),+ )++ # Create the sources+ created_source1 = await server.source_manager.create_source(source1, default_user)+ created_source2 = await server.source_manager.create_source(source2, default_user)++ # Test batch check - mix of existing and non-existing names+ names_to_check = ["test_source_1", "test_source_2", "non_existent_source", "another_non_existent"]+ existing_names = await server.source_manager.get_existing_source_names(names_to_check, default_user)++ # Verify results+ assert len(existing_names) == 2+ assert "test_source_1" in existing_names+ assert "test_source_2" in existing_names+ assert "non_existent_source" not in existing_names+ assert "another_non_existent" not in existing_names++ # Test with empty list+ empty_result = await server.source_manager.get_existing_source_names([], default_user)+ assert len(empty_result) == 0++ # Test with all non-existing names+ non_existing_result = await server.source_manager.get_existing_source_names(["fake1", "fake2"], default_user)+ assert len(non_existing_result) == 0++ # Cleanup+ await server.source_manager.delete_source(created_source1.id, default_user)+ await server.source_manager.delete_source(created_source2.id, default_user)++@pytest.mark.asyncioasync def test_create_source(server: SyncServer, default_user, event_loop):"""Test creating a new source."""diff --git a/tests/test_sdk_client.py b/tests/test_sdk_client.pyindex b06f6934d..562245813 100644--- a/tests/test_sdk_client.py+++ b/tests/test_sdk_client.py@@ -17,6 +17,8 @@ from letta_client.core import ApiErrorfrom letta_client.types import AgentState, ToolReturnMessagefrom pydantic import BaseModel, Field+from tests.helpers.utils import upload_file_and_wait+# ConstantsSERVER_PORT = 8283@@ -1869,3 +1871,132 @@ def test_agent_serialization_v2(if len(original_user_msgs) > 0 and len(imported_user_msgs) > 0:assert imported_user_msgs[0].content == original_user_msgs[0].content, "User message content not preserved"assert "Test message" in imported_user_msgs[0].content, "Test message content not found"+++def test_export_import_agent_with_files(client: LettaSDKClient):+ """Test exporting and importing an agent with files attached."""++ # Clean up any existing source with the same name from previous runs+ existing_sources = client.sources.list()+ for existing_source in existing_sources:+ client.sources.delete(source_id=existing_source.id)++ # Create a source and upload test files+ source = client.sources.create(name="test_export_source", embedding="openai/text-embedding-3-small")++ # Upload test files to the source+ test_files = ["tests/data/test.txt", "tests/data/test.md"]++ for file_path in test_files:+ upload_file_and_wait(client, source.id, file_path)++ # Verify files were uploaded successfully+ files_in_source = client.sources.files.list(source_id=source.id, limit=10)+ assert len(files_in_source) == len(test_files), f"Expected {len(test_files)} files, got {len(files_in_source)}"++ # Create a simple agent with the source attached+ temp_agent = client.agents.create(+ memory_blocks=[+ CreateBlock(label="human", value="username: sarah"),+ ],+ model="openai/gpt-4o-mini",+ embedding="openai/text-embedding-3-small",+ source_ids=[source.id], # Attach the source with files+ )++ # Verify the agent has the source and file blocks+ agent_state = client.agents.retrieve(agent_id=temp_agent.id)+ assert len(agent_state.sources) == 1, "Agent should have one source attached"+ assert agent_state.sources[0].id == source.id, "Agent should have the correct source attached"++ # Verify file blocks are present+ file_blocks = agent_state.memory.file_blocks+ assert len(file_blocks) == len(test_files), f"Expected {len(test_files)} file blocks, got {len(file_blocks)}"++ # Export the agent+ serialized_agent = client.agents.export_file(agent_id=temp_agent.id, use_legacy_format=False)++ # Convert to JSON bytes for import+ json_str = json.dumps(serialized_agent)+ file_obj = io.BytesIO(json_str.encode("utf-8"))++ # Import the agent+ import_result = client.agents.import_file(file=file_obj, append_copy_suffix=True, override_existing_tools=True)++ # Verify import was successful+ assert len(import_result.agent_ids) == 1, "Should have imported exactly one agent"+ imported_agent_id = import_result.agent_ids[0]+ imported_agent = client.agents.retrieve(agent_id=imported_agent_id)++ # Verify the source is attached to the imported agent+ assert len(imported_agent.sources) == 1, "Imported agent should have one source attached"+ imported_source = imported_agent.sources[0]++ # Check that imported source has the same files+ imported_files = client.sources.files.list(source_id=imported_source.id, limit=10)+ assert len(imported_files) == len(test_files), f"Imported source should have {len(test_files)} files"++ # Verify file blocks are preserved in imported agent+ imported_file_blocks = imported_agent.memory.file_blocks+ assert len(imported_file_blocks) == len(test_files), f"Imported agent should have {len(test_files)} file blocks"++ # Verify file block content+ for file_block in imported_file_blocks:+ assert file_block.value is not None and len(file_block.value) > 0, "Imported file block should have content"+ assert "[Viewing file start" in file_block.value, "Imported file block should show file viewing header"++ # Test that files can be opened on the imported agent+ if len(imported_files) > 0:+ test_file = imported_files[0]+ client.agents.files.open(agent_id=imported_agent_id, file_id=test_file.id)++ # Clean up+ client.agents.delete(agent_id=temp_agent.id)+ client.agents.delete(agent_id=imported_agent_id)+ client.sources.delete(source_id=source.id)+++def test_import_agent_with_files_from_disk(client: LettaSDKClient):+ """Test exporting an agent with files to disk and importing it back."""+ # Upload test files to the source+ test_files = ["tests/data/test.txt", "tests/data/test.md"]++ # Save to file+ file_path = os.path.join(os.path.dirname(__file__), "test_agent_files", "test_agent_with_files_and_sources.af")++ # Now import from the file+ with open(file_path, "rb") as f:+ import_result = client.agents.import_file(+ file=f, append_copy_suffix=True, override_existing_tools=True # Use suffix to avoid name conflict+ )++ # Verify import was successful+ assert len(import_result.agent_ids) == 1, "Should have imported exactly one agent"+ imported_agent_id = import_result.agent_ids[0]+ imported_agent = client.agents.retrieve(agent_id=imported_agent_id)++ # Verify the source is attached to the imported agent+ assert len(imported_agent.sources) == 1, "Imported agent should have one source attached"+ imported_source = imported_agent.sources[0]++ # Check that imported source has the same files+ imported_files = client.sources.files.list(source_id=imported_source.id, limit=10)+ assert len(imported_files) == len(test_files), f"Imported source should have {len(test_files)} files"++ # Verify file blocks are preserved in imported agent+ imported_file_blocks = imported_agent.memory.file_blocks+ assert len(imported_file_blocks) == len(test_files), f"Imported agent should have {len(test_files)} file blocks"++ # Verify file block content+ for file_block in imported_file_blocks:+ assert file_block.value is not None and len(file_block.value) > 0, "Imported file block should have content"+ assert "[Viewing file start" in file_block.value, "Imported file block should show file viewing header"++ # Test that files can be opened on the imported agent+ if len(imported_files) > 0:+ test_file = imported_files[0]+ client.agents.files.open(agent_id=imported_agent_id, file_id=test_file.id)++ # Clean up agents and sources+ client.agents.delete(agent_id=imported_agent_id)+ client.sources.delete(source_id=imported_source.id)diff --git a/tests/test_sources.py b/tests/test_sources.pyindex 905e1297d..cb0d2d1e5 100644--- a/tests/test_sources.py+++ b/tests/test_sources.py@@ -4,11 +4,10 @@ import tempfileimport threadingimport timefrom datetime import datetime, timedelta-from typing import Optionalimport pytestfrom dotenv import load_dotenv-from letta_client import CreateBlock, DuplicateFileHandling+from letta_client import CreateBlockfrom letta_client import Letta as LettaSDKClientfrom letta_client import LettaRequestfrom letta_client import MessageCreate as ClientMessageCreate@@ -19,6 +18,7 @@ from letta.schemas.enums import FileProcessingStatus, ToolTypefrom letta.schemas.message import MessageCreatefrom letta.schemas.user import Userfrom letta.settings import settings+from tests.helpers.utils import upload_file_and_waitfrom tests.utils import wait_for_server# Constants@@ -72,36 +72,6 @@ def client() -> LettaSDKClient:yield client-def upload_file_and_wait(- client: LettaSDKClient,- source_id: str,- file_path: str,- name: Optional[str] = None,- max_wait: int = 60,- duplicate_handling: DuplicateFileHandling = None,-):- """Helper function to upload a file and wait for processing to complete"""- with open(file_path, "rb") as f:- if duplicate_handling:- file_metadata = client.sources.files.upload(source_id=source_id, file=f, duplicate_handling=duplicate_handling, name=name)- else:- file_metadata = client.sources.files.upload(source_id=source_id, file=f, name=name)-- # Wait for the file to be processed- start_time = time.time()- while file_metadata.processing_status != "completed" and file_metadata.processing_status != "error":- if time.time() - start_time > max_wait:- pytest.fail(f"File processing timed out after {max_wait} seconds")- time.sleep(1)- file_metadata = client.sources.get_file_metadata(source_id=source_id, file_id=file_metadata.id)- print("Waiting for file processing to complete...", file_metadata.processing_status)-- if file_metadata.processing_status == "error":- pytest.fail(f"File processing failed: {file_metadata.error_message}")-- return file_metadata--@pytest.fixturedef agent_state(disable_pinecone, client: LettaSDKClient):open_file_tool = client.tools.list(name="open_files")[0]