letta-nightly 0.11.7.dev20251006104136__py3-none-any.whl → 0.11.7.dev20251008104128__py3-none-any.whl

letta/services/agent_serialization_manager.py

@@ -208,6 +208,22 @@ class AgentSerializationManager:
         )
         agent_schema.id = agent_file_id
 
+        # Ensure all in-context messages are present before ID remapping.
+        # AgentSchema.from_agent_state fetches a limited slice (~50) and may exclude messages still
+        # referenced by in_context_message_ids. Fetch any missing in-context messages by ID so remapping succeeds.
+        existing_msg_ids = {m.id for m in (agent_schema.messages or [])}
+        in_context_ids = agent_schema.in_context_message_ids or []
+        missing_in_context_ids = [mid for mid in in_context_ids if mid not in existing_msg_ids]
+        if missing_in_context_ids:
+            missing_msgs = await self.message_manager.get_messages_by_ids_async(message_ids=missing_in_context_ids, actor=actor)
+            fetched_ids = {m.id for m in missing_msgs}
+            not_found = [mid for mid in missing_in_context_ids if mid not in fetched_ids]
+            if not_found:
+                # Surface a clear mapping error; handled upstream by the route/export wrapper.
+                raise AgentExportIdMappingError(db_id=not_found[0], entity_type=MessageSchema.__id_prefix__)
+            for msg in missing_msgs:
+                agent_schema.messages.append(MessageSchema.from_message(msg))
+
         # wipe the values of tool_exec_environment_variables (they contain secrets)
         agent_secrets = agent_schema.secrets or agent_schema.tool_exec_environment_variables
         if agent_secrets:

letta/services/archive_manager.py

@@ -19,32 +19,6 @@ logger = get_logger(__name__)
 class ArchiveManager:
     """Manager class to handle business logic related to Archives."""
 
-    @enforce_types
-    @trace_method
-    def create_archive(
-        self,
-        name: str,
-        description: Optional[str] = None,
-        actor: PydanticUser = None,
-    ) -> PydanticArchive:
-        """Create a new archive."""
-        try:
-            with db_registry.session() as session:
-                # determine vector db provider based on settings
-                vector_db_provider = VectorDBProvider.TPUF if should_use_tpuf() else VectorDBProvider.NATIVE
-
-                archive = ArchiveModel(
-                    name=name,
-                    description=description,
-                    organization_id=actor.organization_id,
-                    vector_db_provider=vector_db_provider,
-                )
-                archive.create(session, actor=actor)
-                return archive.to_pydantic()
-        except Exception as e:
-            logger.exception(f"Failed to create archive {name}. error={e}")
-            raise
-
     @enforce_types
     @trace_method
     async def create_archive_async(
@@ -160,36 +134,6 @@ class ArchiveManager:
             )
             return [a.to_pydantic() for a in archives]
 
-    @enforce_types
-    @trace_method
-    def attach_agent_to_archive(
-        self,
-        agent_id: str,
-        archive_id: str,
-        is_owner: bool,
-        actor: PydanticUser,
-    ) -> None:
-        """Attach an agent to an archive."""
-        with db_registry.session() as session:
-            # Check if already attached
-            existing = session.query(ArchivesAgents).filter_by(agent_id=agent_id, archive_id=archive_id).first()
-
-            if existing:
-                # Update ownership if needed
-                if existing.is_owner != is_owner:
-                    existing.is_owner = is_owner
-                    session.commit()
-                return
-
-            # Create new relationship
-            archives_agents = ArchivesAgents(
-                agent_id=agent_id,
-                archive_id=archive_id,
-                is_owner=is_owner,
-            )
-            session.add(archives_agents)
-            session.commit()
-
     @enforce_types
     @trace_method
     async def attach_agent_to_archive_async(
@@ -345,50 +289,6 @@ class ArchiveManager:
                 # this shouldn't happen, but if it does, re-raise
                 raise
 
-    @enforce_types
-    @trace_method
-    def get_or_create_default_archive_for_agent(
-        self,
-        agent_id: str,
-        agent_name: Optional[str] = None,
-        actor: PydanticUser = None,
-    ) -> PydanticArchive:
-        """Get the agent's default archive, creating one if it doesn't exist."""
-        with db_registry.session() as session:
-            # First check if agent has any archives
-            query = select(ArchivesAgents.archive_id).where(ArchivesAgents.agent_id == agent_id)
-            result = session.execute(query)
-            archive_ids = [row[0] for row in result.fetchall()]
-
-            if archive_ids:
-                # TODO: Remove this check once we support multiple archives per agent
-                if len(archive_ids) > 1:
-                    raise ValueError(f"Agent {agent_id} has multiple archives, which is not yet supported")
-                # Get the archive
-                archive = ArchiveModel.read(db_session=session, identifier=archive_ids[0], actor=actor)
-                return archive.to_pydantic()
-
-            # Create a default archive for this agent
-            archive_name = f"{agent_name or f'Agent {agent_id}'}'s Archive"
-
-            # Create the archive
-            archive_model = ArchiveModel(
-                name=archive_name,
-                description="Default archive created automatically",
-                organization_id=actor.organization_id,
-            )
-            archive_model.create(session, actor=actor)
-
-        # Attach the agent to the archive as owner
-        self.attach_agent_to_archive(
-            agent_id=agent_id,
-            archive_id=archive_model.id,
-            is_owner=True,
-            actor=actor,
-        )
-
-        return archive_model.to_pydantic()
-
     @enforce_types
     @trace_method
     async def get_agents_for_archive_async(