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

letta/services/block_manager.py

@@ -3,8 +3,9 @@ from datetime import datetime
 from typing import Dict, List, Optional
 
 from sqlalchemy import and_, delete, func, or_, select
-from sqlalchemy.orm import Session
+from sqlalchemy.ext.asyncio import AsyncSession
 
+from letta.errors import LettaInvalidArgumentError
 from letta.log import get_logger
 from letta.orm.agent import Agent as AgentModel
 from letta.orm.block import Block as BlockModel
@@ -23,24 +24,65 @@ from letta.utils import enforce_types
 logger = get_logger(__name__)
 
 
+def validate_block_limit_constraint(update_data: dict, existing_block: BlockModel) -> None:
+    """
+    Validates that block limit constraints are satisfied when updating a block.
+
+    Rules:
+    - If limit is being updated, it must be >= the length of the value (existing or new)
+    - If value is being updated, its length must not exceed the limit (existing or new)
+
+    Args:
+        update_data: Dictionary of fields to update
+        existing_block: The current block being updated
+
+    Raises:
+        LettaInvalidArgumentError: If validation fails
+    """
+    # If limit is being updated, ensure it's >= current value length
+    if "limit" in update_data:
+        # Get the value that will be used (either from update_data or existing)
+        value_to_check = update_data.get("value", existing_block.value)
+        limit_to_check = update_data["limit"]
+        if value_to_check and limit_to_check < len(value_to_check):
+            raise LettaInvalidArgumentError(
+                f"Limit ({limit_to_check}) cannot be less than current value length ({len(value_to_check)} characters)",
+                argument_name="limit",
+            )
+    # If value is being updated and there's an existing limit, ensure value doesn't exceed limit
+    elif "value" in update_data and existing_block.limit:
+        if len(update_data["value"]) > existing_block.limit:
+            raise LettaInvalidArgumentError(
+                f"Value length ({len(update_data['value'])} characters) exceeds block limit ({existing_block.limit} characters)",
+                argument_name="value",
+            )
+
+
+def validate_block_creation(block_data: dict) -> None:
+    """
+    Validates that block limit constraints are satisfied when creating a block.
+
+    Rules:
+    - If both value and limit are provided, limit must be >= value length
+
+    Args:
+        block_data: Dictionary of block fields for creation
+
+    Raises:
+        LettaInvalidArgumentError: If validation fails
+    """
+    value = block_data.get("value")
+    limit = block_data.get("limit")
+
+    if value and limit and len(value) > limit:
+        raise LettaInvalidArgumentError(
+            f"Block limit ({limit}) must be greater than or equal to value length ({len(value)} characters)", argument_name="limit"
+        )
+
+
 class BlockManager:
     """Manager class to handle business logic related to Blocks."""
 
-    @enforce_types
-    @trace_method
-    def create_or_update_block(self, block: PydanticBlock, actor: PydanticUser) -> PydanticBlock:
-        """Create a new block based on the Block schema."""
-        db_block = self.get_block_by_id(block.id, actor)
-        if db_block:
-            update_data = BlockUpdate(**block.model_dump(to_orm=True, exclude_none=True))
-            self.update_block(block.id, update_data, actor)
-        else:
-            with db_registry.session() as session:
-                data = block.model_dump(to_orm=True, exclude_none=True)
-                block = BlockModel(**data, organization_id=actor.organization_id)
-                block.create(session, actor=actor)
-            return block.to_pydantic()
-
     @enforce_types
     @trace_method
     async def create_or_update_block_async(self, block: PydanticBlock, actor: PydanticUser) -> PydanticBlock:
@@ -52,36 +94,14 @@ class BlockManager:
         else:
             async with db_registry.async_session() as session:
                 data = block.model_dump(to_orm=True, exclude_none=True)
+                # Validate block creation constraints
+                validate_block_creation(data)
                 block = BlockModel(**data, organization_id=actor.organization_id)
                 await block.create_async(session, actor=actor, no_commit=True, no_refresh=True)
                 pydantic_block = block.to_pydantic()
                 await session.commit()
                 return pydantic_block
 
-    @enforce_types
-    @trace_method
-    def batch_create_blocks(self, blocks: List[PydanticBlock], actor: PydanticUser) -> List[PydanticBlock]:
-        """
-        Batch-create multiple Blocks in one transaction for better performance.
-        Args:
-            blocks: List of PydanticBlock schemas to create
-            actor:    The user performing the operation
-        Returns:
-            List of created PydanticBlock instances (with IDs, timestamps, etc.)
-        """
-        if not blocks:
-            return []
-
-        with db_registry.session() as session:
-            block_models = [
-                BlockModel(**block.model_dump(to_orm=True, exclude_none=True), organization_id=actor.organization_id) for block in blocks
-            ]
-
-            created_models = BlockModel.batch_create(items=block_models, db_session=session, actor=actor)
-
-            # Convert back to Pydantic
-            return [m.to_pydantic() for m in created_models]
-
     @enforce_types
     @trace_method
     async def batch_create_blocks_async(self, blocks: List[PydanticBlock], actor: PydanticUser) -> List[PydanticBlock]:
@@ -97,6 +117,11 @@ class BlockManager:
             return []
 
         async with db_registry.async_session() as session:
+            # Validate all blocks before creating any
+            for block in blocks:
+                block_data = block.model_dump(to_orm=True, exclude_none=True)
+                validate_block_creation(block_data)
+
             block_models = [
                 BlockModel(**block.model_dump(to_orm=True, exclude_none=True), organization_id=actor.organization_id) for block in blocks
             ]
@@ -107,22 +132,6 @@ class BlockManager:
             await session.commit()
             return result
 
-    @enforce_types
-    @trace_method
-    def update_block(self, block_id: str, block_update: BlockUpdate, actor: PydanticUser) -> PydanticBlock:
-        """Update a block by its ID with the given BlockUpdate object."""
-        # Safety check for block
-
-        with db_registry.session() as session:
-            block = BlockModel.read(db_session=session, identifier=block_id, actor=actor)
-            update_data = block_update.model_dump(to_orm=True, exclude_unset=True, exclude_none=True)
-
-            for key, value in update_data.items():
-                setattr(block, key, value)
-
-            block.update(db_session=session, actor=actor)
-            return block.to_pydantic()
-
     @enforce_types
     @trace_method
     async def update_block_async(self, block_id: str, block_update: BlockUpdate, actor: PydanticUser) -> PydanticBlock:
@@ -133,6 +142,9 @@ class BlockManager:
             block = await BlockModel.read_async(db_session=session, identifier=block_id, actor=actor)
             update_data = block_update.model_dump(to_orm=True, exclude_unset=True, exclude_none=True)
 
+            # Validate limit constraints before updating
+            validate_block_limit_constraint(update_data, block)
+
             for key, value in update_data.items():
                 setattr(block, key, value)
 
@@ -141,19 +153,6 @@ class BlockManager:
             await session.commit()
             return pydantic_block
 
-    @enforce_types
-    @trace_method
-    def delete_block(self, block_id: str, actor: PydanticUser) -> None:
-        """Delete a block by its ID."""
-        with db_registry.session() as session:
-            # First, delete all references in blocks_agents table
-            session.execute(delete(BlocksAgents).where(BlocksAgents.block_id == block_id))
-            session.flush()
-
-            # Then delete the block itself
-            block = BlockModel.read(db_session=session, identifier=block_id)
-            block.hard_delete(db_session=session, actor=actor)
-
     @enforce_types
     @trace_method
     async def delete_block_async(self, block_id: str, actor: PydanticUser) -> None:
@@ -352,17 +351,6 @@ class BlockManager:
 
             return [block.to_pydantic() for block in blocks]
 
-    @enforce_types
-    @trace_method
-    def get_block_by_id(self, block_id: str, actor: Optional[PydanticUser] = None) -> Optional[PydanticBlock]:
-        """Retrieve a block by its name."""
-        with db_registry.session() as session:
-            try:
-                block = BlockModel.read(db_session=session, identifier=block_id, actor=actor)
-                return block.to_pydantic()
-            except NoResultFound:
-                return None
-
     @enforce_types
     @trace_method
     async def get_block_by_id_async(self, block_id: str, actor: Optional[PydanticUser] = None) -> Optional[PydanticBlock]:
@@ -524,9 +512,90 @@ class BlockManager:
 
     # Block History Functions
 
+    @enforce_types
+    async def _move_block_to_sequence(self, session: AsyncSession, block: BlockModel, target_seq: int, actor: PydanticUser) -> BlockModel:
+        """
+        Internal helper that moves the 'block' to the specified 'target_seq' within BlockHistory.
+        1) Find the BlockHistory row at sequence_number=target_seq
+        2) Copy fields into the block
+        3) Update and flush (no_commit=True) - the caller is responsible for final commit
+
+        Raises:
+            NoResultFound: if no BlockHistory row for (block_id, target_seq)
+        """
+        if not block.id:
+            raise ValueError("Block is missing an ID. Cannot move sequence.")
+
+        stmt = select(BlockHistory).filter(
+            BlockHistory.block_id == block.id,
+            BlockHistory.sequence_number == target_seq,
+        )
+        result = await session.execute(stmt)
+        target_entry = result.scalar_one_or_none()
+        if not target_entry:
+            raise NoResultFound(f"No BlockHistory row found for block_id={block.id} at sequence={target_seq}")
+
+        # Copy fields from target_entry to block
+        block.description = target_entry.description  # type: ignore
+        block.label = target_entry.label  # type: ignore
+        block.value = target_entry.value  # type: ignore
+        block.limit = target_entry.limit  # type: ignore
+        block.metadata_ = target_entry.metadata_  # type: ignore
+        block.current_history_entry_id = target_entry.id  # type: ignore
+
+        # Update in DB (optimistic locking).
+        # We'll do a flush now; the caller does final commit.
+        updated_block = await block.update_async(db_session=session, actor=actor, no_commit=True)
+        return updated_block
+
     @enforce_types
     @trace_method
-    def checkpoint_block(
+    async def bulk_update_block_values_async(
+        self, updates: Dict[str, str], actor: PydanticUser, return_hydrated: bool = False
+    ) -> Optional[List[PydanticBlock]]:
+        """
+        Bulk-update the `value` field for multiple blocks in one transaction.
+
+        Args:
+            updates: mapping of block_id -> new value
+            actor:   the user performing the update (for org scoping, permissions, audit)
+            return_hydrated: whether to return the pydantic Block objects that were updated
+
+        Returns:
+            the updated Block objects as Pydantic schemas
+
+        Raises:
+            NoResultFound if any block_id doesn't exist or isn't visible to this actor
+            ValueError     if any new value exceeds its block's limit
+        """
+        async with db_registry.async_session() as session:
+            query = select(BlockModel).where(BlockModel.id.in_(updates.keys()), BlockModel.organization_id == actor.organization_id)
+            result = await session.execute(query)
+            blocks = result.scalars().all()
+
+            found_ids = {b.id for b in blocks}
+            missing = set(updates.keys()) - found_ids
+            if missing:
+                logger.warning(f"Block IDs not found or inaccessible, skipping during bulk update: {missing!r}")
+
+            for block in blocks:
+                new_val = updates[block.id]
+                if len(new_val) > block.limit:
+                    logger.warning(f"Value length ({len(new_val)}) exceeds limit ({block.limit}) for block {block.id!r}, truncating...")
+                    new_val = new_val[: block.limit]
+                block.value = new_val
+
+            await session.commit()
+
+            if return_hydrated:
+                # TODO: implement for async
+                pass
+
+            return None
+
+    @enforce_types
+    @trace_method
+    async def checkpoint_block_async(
         self,
         block_id: str,
         actor: PydanticUser,
@@ -543,17 +612,17 @@ class BlockManager:
           strictly linear history.
         - A single commit at the end ensures atomicity.
         """
-        with db_registry.session() as session:
+        async with db_registry.async_session() as session:
             # 1) Load the Block
             if use_preloaded_block is not None:
-                block = session.merge(use_preloaded_block)
+                block = await session.merge(use_preloaded_block)
             else:
-                block = BlockModel.read(db_session=session, identifier=block_id, actor=actor)
+                block = await BlockModel.read_async(db_session=session, identifier=block_id, actor=actor)
 
             # 2) Identify the block's current checkpoint (if any)
             current_entry = None
             if block.current_history_entry_id:
-                current_entry = session.get(BlockHistory, block.current_history_entry_id)
+                current_entry = await session.get(BlockHistory, block.current_history_entry_id)
 
             # The current sequence, or 0 if no checkpoints exist
             current_seq = current_entry.sequence_number if current_entry else 0
@@ -561,7 +630,13 @@ class BlockManager:
             # 3) Truncate any future checkpoints
             #    If we are at seq=2, but there's a seq=3 or higher from a prior "redo chain",
             #    remove those, so we maintain a strictly linear undo/redo stack.
-            session.query(BlockHistory).filter(BlockHistory.block_id == block.id, BlockHistory.sequence_number > current_seq).delete()
+            stmt = select(BlockHistory).filter(BlockHistory.block_id == block.id, BlockHistory.sequence_number > current_seq)
+            result = await session.execute(stmt)
+            for entry in result.scalars():
+                session.delete(entry)
+
+            # Flush the deletes to ensure they're executed before we create a new entry
+            await session.flush()
 
             # 4) Determine the next sequence number
             next_seq = current_seq + 1
@@ -579,19 +654,19 @@ class BlockManager:
                 actor_type=ActorType.LETTA_AGENT if agent_id else ActorType.LETTA_USER,
                 actor_id=agent_id if agent_id else actor.id,
             )
-            history_entry.create(session, actor=actor, no_commit=True)
+            await history_entry.create_async(session, actor=actor, no_commit=True)
 
             # 6) Update the block’s pointer to the new checkpoint
             block.current_history_entry_id = history_entry.id
 
             # 7) Flush changes, then commit once
-            block = block.update(db_session=session, actor=actor, no_commit=True)
-            session.commit()
+            block = await block.update_async(db_session=session, actor=actor, no_commit=True)
+            await session.commit()
 
             return block.to_pydantic()
 
     @enforce_types
-    def _move_block_to_sequence(self, session: Session, block: BlockModel, target_seq: int, actor: PydanticUser) -> BlockModel:
+    async def _move_block_to_sequence(self, session: AsyncSession, block: BlockModel, target_seq: int, actor: PydanticUser) -> BlockModel:
         """
         Internal helper that moves the 'block' to the specified 'target_seq' within BlockHistory.
         1) Find the BlockHistory row at sequence_number=target_seq
@@ -604,14 +679,12 @@ class BlockManager:
         if not block.id:
             raise ValueError("Block is missing an ID. Cannot move sequence.")
 
-        target_entry = (
-            session.query(BlockHistory)
-            .filter(
-                BlockHistory.block_id == block.id,
-                BlockHistory.sequence_number == target_seq,
-            )
-            .one_or_none()
+        stmt = select(BlockHistory).filter(
+            BlockHistory.block_id == block.id,
+            BlockHistory.sequence_number == target_seq,
         )
+        result = await session.execute(stmt)
+        target_entry = result.scalar_one_or_none()
         if not target_entry:
             raise NoResultFound(f"No BlockHistory row found for block_id={block.id} at sequence={target_seq}")
 
@@ -625,132 +698,102 @@ class BlockManager:
 
         # Update in DB (optimistic locking).
         # We'll do a flush now; the caller does final commit.
-        updated_block = block.update(db_session=session, actor=actor, no_commit=True)
+        updated_block = await block.update_async(db_session=session, actor=actor, no_commit=True)
         return updated_block
 
     @enforce_types
     @trace_method
-    def undo_checkpoint_block(self, block_id: str, actor: PydanticUser, use_preloaded_block: Optional[BlockModel] = None) -> PydanticBlock:
+    async def undo_checkpoint_block(
+        self, block_id: str, actor: PydanticUser, use_preloaded_block: Optional[BlockModel] = None
+    ) -> PydanticBlock:
         """
         Move the block to the immediately previous checkpoint in BlockHistory.
         If older sequences have been pruned, we jump to the largest sequence
         number that is still < current_seq.
         """
-        with db_registry.session() as session:
+        async with db_registry.async_session() as session:
             # 1) Load the current block
             block = (
-                session.merge(use_preloaded_block)
+                await session.merge(use_preloaded_block)
                 if use_preloaded_block
-                else BlockModel.read(db_session=session, identifier=block_id, actor=actor)
+                else await BlockModel.read_async(db_session=session, identifier=block_id, actor=actor)
             )
 
             if not block.current_history_entry_id:
-                raise ValueError(f"Block {block_id} has no history entry - cannot undo.")
+                raise LettaInvalidArgumentError(f"Block {block_id} has no history entry - cannot undo.", argument_name="block_id")
 
-            current_entry = session.get(BlockHistory, block.current_history_entry_id)
+            current_entry = await session.get(BlockHistory, block.current_history_entry_id)
             if not current_entry:
                 raise NoResultFound(f"BlockHistory row not found for id={block.current_history_entry_id}")
 
             current_seq = current_entry.sequence_number
 
             # 2) Find the largest sequence < current_seq
-            previous_entry = (
-                session.query(BlockHistory)
+            stmt = (
+                select(BlockHistory)
                 .filter(BlockHistory.block_id == block.id, BlockHistory.sequence_number < current_seq)
                 .order_by(BlockHistory.sequence_number.desc())
-                .first()
+                .limit(1)
             )
+            result = await session.execute(stmt)
+            previous_entry = result.scalar_one_or_none()
             if not previous_entry:
                 # No earlier checkpoint available
-                raise ValueError(f"Block {block_id} is already at the earliest checkpoint (seq={current_seq}). Cannot undo further.")
+                raise LettaInvalidArgumentError(
+                    f"Block {block_id} is already at the earliest checkpoint (seq={current_seq}). Cannot undo further.",
+                    argument_name="block_id",
+                )
 
             # 3) Move to that sequence
-            block = self._move_block_to_sequence(session, block, previous_entry.sequence_number, actor)
+            block = await self._move_block_to_sequence(session, block, previous_entry.sequence_number, actor)
 
             # 4) Commit
-            session.commit()
+            await session.commit()
             return block.to_pydantic()
 
     @enforce_types
     @trace_method
-    def redo_checkpoint_block(self, block_id: str, actor: PydanticUser, use_preloaded_block: Optional[BlockModel] = None) -> PydanticBlock:
+    async def redo_checkpoint_block(
+        self, block_id: str, actor: PydanticUser, use_preloaded_block: Optional[BlockModel] = None
+    ) -> PydanticBlock:
         """
         Move the block to the next checkpoint if it exists.
         If some middle checkpoints have been pruned, we jump to the smallest
         sequence > current_seq that remains.
         """
-        with db_registry.session() as session:
+        async with db_registry.async_session() as session:
             block = (
-                session.merge(use_preloaded_block)
+                await session.merge(use_preloaded_block)
                 if use_preloaded_block
-                else BlockModel.read(db_session=session, identifier=block_id, actor=actor)
+                else await BlockModel.read_async(db_session=session, identifier=block_id, actor=actor)
             )
 
             if not block.current_history_entry_id:
-                raise ValueError(f"Block {block_id} has no history entry - cannot redo.")
+                raise LettaInvalidArgumentError(f"Block {block_id} has no history entry - cannot redo.", argument_name="block_id")
 
-            current_entry = session.get(BlockHistory, block.current_history_entry_id)
+            current_entry = await session.get(BlockHistory, block.current_history_entry_id)
             if not current_entry:
-                raise NoResultFound(f"BlockHistory row not found for id={block.current_history_entry_id}")
+                raise LettaInvalidArgumentError(
+                    f"BlockHistory row not found for id={block.current_history_entry_id}", argument_name="block_id"
+                )
 
             current_seq = current_entry.sequence_number
 
             # Find the smallest sequence that is > current_seq
-            next_entry = (
-                session.query(BlockHistory)
+            stmt = (
+                select(BlockHistory)
                 .filter(BlockHistory.block_id == block.id, BlockHistory.sequence_number > current_seq)
                 .order_by(BlockHistory.sequence_number.asc())
-                .first()
+                .limit(1)
             )
+            result = await session.execute(stmt)
+            next_entry = result.scalar_one_or_none()
             if not next_entry:
-                raise ValueError(f"Block {block_id} is at the highest checkpoint (seq={current_seq}). Cannot redo further.")
-
-            block = self._move_block_to_sequence(session, block, next_entry.sequence_number, actor)
-
-            session.commit()
-            return block.to_pydantic()
-
-    @enforce_types
-    @trace_method
-    async def bulk_update_block_values_async(
-        self, updates: Dict[str, str], actor: PydanticUser, return_hydrated: bool = False
-    ) -> Optional[List[PydanticBlock]]:
-        """
-        Bulk-update the `value` field for multiple blocks in one transaction.
-
-        Args:
-            updates: mapping of block_id -> new value
-            actor:   the user performing the update (for org scoping, permissions, audit)
-            return_hydrated: whether to return the pydantic Block objects that were updated
-
-        Returns:
-            the updated Block objects as Pydantic schemas
-
-        Raises:
-            NoResultFound if any block_id doesn't exist or isn't visible to this actor
-            ValueError     if any new value exceeds its block's limit
-        """
-        async with db_registry.async_session() as session:
-            query = select(BlockModel).where(BlockModel.id.in_(updates.keys()), BlockModel.organization_id == actor.organization_id)
-            result = await session.execute(query)
-            blocks = result.scalars().all()
+                raise LettaInvalidArgumentError(
+                    f"Block {block_id} is at the highest checkpoint (seq={current_seq}). Cannot redo further.", argument_name="block_id"
+                )
 
-            found_ids = {b.id for b in blocks}
-            missing = set(updates.keys()) - found_ids
-            if missing:
-                logger.warning(f"Block IDs not found or inaccessible, skipping during bulk update: {missing!r}")
-
-            for block in blocks:
-                new_val = updates[block.id]
-                if len(new_val) > block.limit:
-                    logger.warning(f"Value length ({len(new_val)}) exceeds limit ({block.limit}) for block {block.id!r}, truncating...")
-                    new_val = new_val[: block.limit]
-                block.value = new_val
+            block = await self._move_block_to_sequence(session, block, next_entry.sequence_number, actor)
 
             await session.commit()
-
-            if return_hydrated:
-                # TODO: implement for async
-                pass
-
-            return None
+            return block.to_pydantic()

letta/services/file_manager.py

@@ -406,7 +406,7 @@ class FileManager:
         actor: PydanticUser,
         before: Optional[str] = None,
         after: Optional[str] = None,
-        limit: Optional[int] = 50,
+        limit: Optional[int] = None,
         ascending: Optional[bool] = True,
         include_content: bool = False,
         strip_directory_prefix: bool = False,

letta/services/files_agents_manager.py

@@ -300,6 +300,9 @@ class FileAgentManager:
         cursor: Optional[str] = None,
         limit: int = 20,
         is_open: Optional[bool] = None,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        ascending: bool = False,
     ) -> tuple[List[PydanticFileAgent], Optional[str], bool]:
         """
         Return paginated file associations for an agent.
@@ -307,9 +310,12 @@ class FileAgentManager:
         Args:
             agent_id: The agent ID to get files for
             actor: User performing the action
-            cursor: Pagination cursor (file-agent ID to start after)
+            cursor: Pagination cursor (file-agent ID to start after) - deprecated, use before/after
             limit: Maximum number of results to return
             is_open: Optional filter for open/closed status (None = all, True = open only, False = closed only)
+            before: File-agent ID cursor for pagination. Returns files that come before this ID in the specified sort order
+            after: File-agent ID cursor for pagination. Returns files that come after this ID in the specified sort order
+            ascending: Sort order (True = ascending by created_at/id, False = descending)
 
         Returns:
             Tuple of (file_agents, next_cursor, has_more)
@@ -325,14 +331,27 @@ class FileAgentManager:
             if is_open is not None:
                 conditions.append(FileAgentModel.is_open == is_open)
 
-            # apply cursor if provided (get records after this ID)
-            if cursor:
+            # handle pagination cursors (support both old and new style)
+            if before:
+                conditions.append(FileAgentModel.id < before)
+            elif after:
+                conditions.append(FileAgentModel.id > after)
+            elif cursor:
+                # fallback to old cursor behavior for backwards compatibility
                 conditions.append(FileAgentModel.id > cursor)
 
             query = select(FileAgentModel).where(and_(*conditions))
 
-            # order by ID for stable pagination
-            query = query.order_by(FileAgentModel.id)
+            # apply sorting based on pagination method
+            if before or after:
+                # For new cursor-based pagination, use created_at + id ordering
+                if ascending:
+                    query = query.order_by(FileAgentModel.created_at.asc(), FileAgentModel.id.asc())
+                else:
+                    query = query.order_by(FileAgentModel.created_at.desc(), FileAgentModel.id.desc())
+            else:
+                # For old cursor compatibility, maintain original behavior (ascending by ID)
+                query = query.order_by(FileAgentModel.id)
 
             # fetch limit + 1 to check if there are more results
             query = query.limit(limit + 1)
@@ -711,31 +730,3 @@ class FileAgentManager:
         if not assoc:
             raise NoResultFound(f"FileAgent(agent_id={agent_id}, file_name={file_name}) not found in org {actor.organization_id}")
         return assoc
-
-    @enforce_types
-    @trace_method
-    async def get_files_agents_for_agents_async(self, agent_ids: List[str], actor: PydanticUser) -> List[PydanticFileAgent]:
-        """
-        Get all file-agent relationships for multiple agents in a single query.
-
-        Args:
-            agent_ids: List of agent IDs to find file-agent relationships for
-            actor: User performing the action
-
-        Returns:
-            List[PydanticFileAgent]: List of file-agent relationships for these agents
-        """
-        if not agent_ids:
-            return []
-
-        async with db_registry.async_session() as session:
-            query = select(FileAgentModel).where(
-                FileAgentModel.agent_id.in_(agent_ids),
-                FileAgentModel.organization_id == actor.organization_id,
-                FileAgentModel.is_deleted == False,
-            )
-
-            result = await session.execute(query)
-            file_agents_orm = result.scalars().all()
-
-            return [file_agent.to_pydantic() for file_agent in file_agents_orm]