letta-nightly 0.12.1.dev20251024104217__py3-none-any.whl → 0.13.0.dev20251025104015__py3-none-any.whl

letta/services/archive_manager.py

@@ -1,17 +1,22 @@
+import asyncio
+from datetime import datetime
 from typing import List, Optional
 
-from sqlalchemy import select
+from sqlalchemy import delete, or_, select
 
 from letta.helpers.tpuf_client import should_use_tpuf
 from letta.log import get_logger
 from letta.orm import ArchivalPassage, Archive as ArchiveModel, ArchivesAgents
 from letta.otel.tracing import trace_method
+from letta.schemas.agent import AgentState as PydanticAgentState
 from letta.schemas.archive import Archive as PydanticArchive
-from letta.schemas.enums import VectorDBProvider
+from letta.schemas.embedding_config import EmbeddingConfig
+from letta.schemas.enums import PrimitiveType, VectorDBProvider
 from letta.schemas.user import User as PydanticUser
 from letta.server.db import db_registry
-from letta.settings import settings
+from letta.settings import DatabaseChoice, settings
 from letta.utils import enforce_types
+from letta.validators import raise_on_invalid_id
 
 logger = get_logger(__name__)
 
@@ -24,6 +29,7 @@ class ArchiveManager:
     async def create_archive_async(
         self,
         name: str,
+        embedding_config: EmbeddingConfig,
         description: Optional[str] = None,
         actor: PydanticUser = None,
     ) -> PydanticArchive:
@@ -38,6 +44,7 @@ class ArchiveManager:
                     description=description,
                     organization_id=actor.organization_id,
                     vector_db_provider=vector_db_provider,
+                    embedding_config=embedding_config,
                 )
                 await archive.create_async(session, actor=actor)
                 return archive.to_pydantic()
@@ -47,6 +54,7 @@ class ArchiveManager:
 
     @enforce_types
     @trace_method
+    @raise_on_invalid_id(param_name="archive_id", expected_prefix=PrimitiveType.ARCHIVE)
     async def get_archive_by_id_async(
         self,
         archive_id: str,
@@ -63,6 +71,7 @@ class ArchiveManager:
 
     @enforce_types
     @trace_method
+    @raise_on_invalid_id(param_name="archive_id", expected_prefix=PrimitiveType.ARCHIVE)
     async def update_archive_async(
         self,
         archive_id: str,
@@ -89,6 +98,7 @@ class ArchiveManager:
 
     @enforce_types
     @trace_method
+    @raise_on_invalid_id(param_name="agent_id", expected_prefix=PrimitiveType.AGENT)
     async def list_archives_async(
         self,
         *,
@@ -136,6 +146,8 @@ class ArchiveManager:
 
     @enforce_types
     @trace_method
+    @raise_on_invalid_id(param_name="agent_id", expected_prefix=PrimitiveType.AGENT)
+    @raise_on_invalid_id(param_name="archive_id", expected_prefix=PrimitiveType.ARCHIVE)
     async def attach_agent_to_archive_async(
         self,
         agent_id: str,
@@ -172,6 +184,34 @@ class ArchiveManager:
 
     @enforce_types
     @trace_method
+    @raise_on_invalid_id(param_name="agent_id", expected_prefix=PrimitiveType.AGENT)
+    @raise_on_invalid_id(param_name="archive_id", expected_prefix=PrimitiveType.ARCHIVE)
+    async def detach_agent_from_archive_async(
+        self,
+        agent_id: str,
+        archive_id: str,
+        actor: PydanticUser = None,
+    ) -> None:
+        """Detach an agent from an archive."""
+        async with db_registry.async_session() as session:
+            # Delete the relationship directly
+            result = await session.execute(
+                delete(ArchivesAgents).where(
+                    ArchivesAgents.agent_id == agent_id,
+                    ArchivesAgents.archive_id == archive_id,
+                )
+            )
+
+            if result.rowcount == 0:
+                logger.warning(f"Attempted to detach unattached agent {agent_id} from archive {archive_id}")
+            else:
+                logger.info(f"Detached agent {agent_id} from archive {archive_id}")
+
+            await session.commit()
+
+    @enforce_types
+    @trace_method
+    @raise_on_invalid_id(param_name="agent_id", expected_prefix=PrimitiveType.AGENT)
     async def get_default_archive_for_agent_async(
         self,
         agent_id: str,
@@ -204,6 +244,7 @@ class ArchiveManager:
 
     @enforce_types
     @trace_method
+    @raise_on_invalid_id(param_name="archive_id", expected_prefix=PrimitiveType.ARCHIVE)
     async def delete_archive_async(
         self,
         archive_id: str,
@@ -219,12 +260,51 @@ class ArchiveManager:
             await archive_model.hard_delete_async(session, actor=actor)
             logger.info(f"Deleted archive {archive_id}")
 
+    @enforce_types
+    @trace_method
+    @raise_on_invalid_id(param_name="archive_id", expected_prefix=PrimitiveType.ARCHIVE)
+    @raise_on_invalid_id(param_name="passage_id", expected_prefix=PrimitiveType.PASSAGE)
+    async def delete_passage_from_archive_async(
+        self,
+        archive_id: str,
+        passage_id: str,
+        actor: PydanticUser = None,
+        strict_mode: bool = False,
+    ) -> None:
+        """Delete a passage from an archive.
+
+        Args:
+            archive_id: ID of the archive containing the passage
+            passage_id: ID of the passage to delete
+            actor: User performing the operation
+            strict_mode: If True, raise errors on Turbopuffer failures
+
+        Raises:
+            NoResultFound: If archive or passage not found
+            ValueError: If passage does not belong to the specified archive
+        """
+        from letta.services.passage_manager import PassageManager
+
+        await self.get_archive_by_id_async(archive_id=archive_id, actor=actor)
+
+        passage_manager = PassageManager()
+        passage = await passage_manager.get_agent_passage_by_id_async(passage_id=passage_id, actor=actor)
+
+        if passage.archive_id != archive_id:
+            raise ValueError(f"Passage {passage_id} does not belong to archive {archive_id}")
+
+        await passage_manager.delete_agent_passage_by_id_async(
+            passage_id=passage_id,
+            actor=actor,
+            strict_mode=strict_mode,
+        )
+        logger.info(f"Deleted passage {passage_id} from archive {archive_id}")
+
     @enforce_types
     @trace_method
     async def get_or_create_default_archive_for_agent_async(
         self,
-        agent_id: str,
-        agent_name: Optional[str] = None,
+        agent_state: PydanticAgentState,
         actor: PydanticUser = None,
     ) -> PydanticArchive:
         """Get the agent's default archive, creating one if it doesn't exist."""
@@ -236,14 +316,14 @@ class ArchiveManager:
         agent_manager = AgentManager()
 
         archive_ids = await agent_manager.get_agent_archive_ids_async(
-            agent_id=agent_id,
+            agent_id=agent_state.id,
             actor=actor,
         )
 
         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")
+                raise ValueError(f"Agent {agent_state.id} has multiple archives, which is not yet supported")
             # Get the archive
             archive = await self.get_archive_by_id_async(
                 archive_id=archive_ids[0],
@@ -252,9 +332,10 @@ class ArchiveManager:
             return archive
 
         # Create a default archive for this agent
-        archive_name = f"{agent_name or f'Agent {agent_id}'}'s Archive"
+        archive_name = f"{agent_state.name}'s Archive"
         archive = await self.create_archive_async(
             name=archive_name,
+            embedding_config=agent_state.embedding_config,
             description="Default archive created automatically",
             actor=actor,
         )
@@ -262,7 +343,7 @@ class ArchiveManager:
         try:
             # Attach the agent to the archive as owner
             await self.attach_agent_to_archive_async(
-                agent_id=agent_id,
+                agent_id=agent_state.id,
                 archive_id=archive.id,
                 is_owner=True,
                 actor=actor,
@@ -271,12 +352,12 @@ class ArchiveManager:
         except IntegrityError:
             # race condition: another concurrent request already created and attached an archive
             # clean up the orphaned archive we just created
-            logger.info(f"Race condition detected for agent {agent_id}, cleaning up orphaned archive {archive.id}")
+            logger.info(f"Race condition detected for agent {agent_state.id}, cleaning up orphaned archive {archive.id}")
             await self.delete_archive_async(archive_id=archive.id, actor=actor)
 
             # fetch the existing archive that was created by the concurrent request
             archive_ids = await agent_manager.get_agent_archive_ids_async(
-                agent_id=agent_id,
+                agent_id=agent_state.id,
                 actor=actor,
             )
             if archive_ids:
@@ -291,15 +372,86 @@ class ArchiveManager:
 
     @enforce_types
     @trace_method
+    @raise_on_invalid_id(param_name="archive_id", expected_prefix=PrimitiveType.ARCHIVE)
     async def get_agents_for_archive_async(
         self,
         archive_id: str,
         actor: PydanticUser,
-    ) -> List[str]:
-        """Get all agent IDs that have access to an archive."""
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        limit: Optional[int] = 50,
+        ascending: bool = False,
+        include: List[str] = [],
+    ) -> List[PydanticAgentState]:
+        """Get agents that have access to an archive with pagination support.
+
+        Uses a subquery approach to avoid expensive JOINs.
+        """
+        from letta.orm import Agent as AgentModel
+
         async with db_registry.async_session() as session:
-            result = await session.execute(select(ArchivesAgents.agent_id).where(ArchivesAgents.archive_id == archive_id))
-            return [row[0] for row in result.fetchall()]
+            # Start with a basic query using subquery instead of JOIN
+            query = (
+                select(AgentModel)
+                .where(AgentModel.id.in_(select(ArchivesAgents.agent_id).where(ArchivesAgents.archive_id == archive_id)))
+                .where(AgentModel.organization_id == actor.organization_id)
+            )
+
+            # Apply pagination using cursor-based approach
+            if after:
+                result = (await session.execute(select(AgentModel.created_at, AgentModel.id).where(AgentModel.id == after))).first()
+                if result:
+                    after_sort_value, after_id = result
+                    # SQLite does not support as granular timestamping, so we need to round the timestamp
+                    if settings.database_engine is DatabaseChoice.SQLITE and isinstance(after_sort_value, datetime):
+                        after_sort_value = after_sort_value.strftime("%Y-%m-%d %H:%M:%S")
+
+                    if ascending:
+                        query = query.where(
+                            AgentModel.created_at > after_sort_value,
+                            or_(AgentModel.created_at == after_sort_value, AgentModel.id > after_id),
+                        )
+                    else:
+                        query = query.where(
+                            AgentModel.created_at < after_sort_value,
+                            or_(AgentModel.created_at == after_sort_value, AgentModel.id < after_id),
+                        )
+
+            if before:
+                result = (await session.execute(select(AgentModel.created_at, AgentModel.id).where(AgentModel.id == before))).first()
+                if result:
+                    before_sort_value, before_id = result
+                    # SQLite does not support as granular timestamping, so we need to round the timestamp
+                    if settings.database_engine is DatabaseChoice.SQLITE and isinstance(before_sort_value, datetime):
+                        before_sort_value = before_sort_value.strftime("%Y-%m-%d %H:%M:%S")
+
+                    if ascending:
+                        query = query.where(
+                            AgentModel.created_at < before_sort_value,
+                            or_(AgentModel.created_at == before_sort_value, AgentModel.id < before_id),
+                        )
+                    else:
+                        query = query.where(
+                            AgentModel.created_at > before_sort_value,
+                            or_(AgentModel.created_at == before_sort_value, AgentModel.id > before_id),
+                        )
+
+            # Apply sorting
+            if ascending:
+                query = query.order_by(AgentModel.created_at.asc(), AgentModel.id.asc())
+            else:
+                query = query.order_by(AgentModel.created_at.desc(), AgentModel.id.desc())
+
+            # Apply limit
+            if limit:
+                query = query.limit(limit)
+
+            # Execute the query
+            result = await session.execute(query)
+            agents_orm = result.scalars().all()
+
+            agents = await asyncio.gather(*[agent.to_pydantic_async(include_relationships=[], include=include) for agent in agents_orm])
+            return agents
 
     @enforce_types
     @trace_method
@@ -333,6 +485,7 @@ class ArchiveManager:
 
     @enforce_types
     @trace_method
+    @raise_on_invalid_id(param_name="archive_id", expected_prefix=PrimitiveType.ARCHIVE)
     async def get_or_set_vector_db_namespace_async(
         self,
         archive_id: str,

letta/services/block_manager.py

@@ -15,11 +15,12 @@ from letta.orm.errors import NoResultFound
 from letta.otel.tracing import trace_method
 from letta.schemas.agent import AgentState as PydanticAgentState
 from letta.schemas.block import Block as PydanticBlock, BlockUpdate
-from letta.schemas.enums import ActorType
+from letta.schemas.enums import ActorType, PrimitiveType
 from letta.schemas.user import User as PydanticUser
 from letta.server.db import db_registry
 from letta.settings import DatabaseChoice, settings
 from letta.utils import enforce_types
+from letta.validators import raise_on_invalid_id
 
 logger = get_logger(__name__)
 
@@ -134,10 +135,9 @@ class BlockManager:
 
     @enforce_types
     @trace_method
+    @raise_on_invalid_id(param_name="block_id", expected_prefix=PrimitiveType.BLOCK)
     async def update_block_async(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
-
         async with db_registry.async_session() as session:
             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)
@@ -155,6 +155,7 @@ class BlockManager:
 
     @enforce_types
     @trace_method
+    @raise_on_invalid_id(param_name="block_id", expected_prefix=PrimitiveType.BLOCK)
     async def delete_block_async(self, block_id: str, actor: PydanticUser) -> None:
         """Delete a block by its ID."""
         async with db_registry.async_session() as session:
@@ -353,6 +354,7 @@ class BlockManager:
 
     @enforce_types
     @trace_method
+    @raise_on_invalid_id(param_name="block_id", expected_prefix=PrimitiveType.BLOCK)
     async def get_block_by_id_async(self, block_id: str, actor: Optional[PydanticUser] = None) -> Optional[PydanticBlock]:
         """Retrieve a block by its name."""
         async with db_registry.async_session() as session:
@@ -412,11 +414,13 @@ class BlockManager:
 
     @enforce_types
     @trace_method
+    @raise_on_invalid_id(param_name="block_id", expected_prefix=PrimitiveType.BLOCK)
     async def get_agents_for_block_async(
         self,
         block_id: str,
         actor: PydanticUser,
         include_relationships: Optional[List[str]] = None,
+        include: List[str] = [],
         before: Optional[str] = None,
         after: Optional[str] = None,
         limit: Optional[int] = 50,
@@ -498,7 +502,9 @@ class BlockManager:
             result = await session.execute(query)
             agents_orm = result.scalars().all()
 
-            agents = await asyncio.gather(*[agent.to_pydantic_async(include_relationships=include_relationships) for agent in agents_orm])
+            agents = await asyncio.gather(
+                *[agent.to_pydantic_async(include_relationships=include_relationships, include=include) for agent in agents_orm]
+            )
             return agents
 
     @enforce_types
@@ -595,6 +601,8 @@ class BlockManager:
 
     @enforce_types
     @trace_method
+    @raise_on_invalid_id(param_name="block_id", expected_prefix=PrimitiveType.BLOCK)
+    @raise_on_invalid_id(param_name="agent_id", expected_prefix=PrimitiveType.AGENT)
     async def checkpoint_block_async(
         self,
         block_id: str,
@@ -703,6 +711,7 @@ class BlockManager:
 
     @enforce_types
     @trace_method
+    @raise_on_invalid_id(param_name="block_id", expected_prefix=PrimitiveType.BLOCK)
     async def undo_checkpoint_block(
         self, block_id: str, actor: PydanticUser, use_preloaded_block: Optional[BlockModel] = None
     ) -> PydanticBlock:
@@ -753,6 +762,7 @@ class BlockManager:
 
     @enforce_types
     @trace_method
+    @raise_on_invalid_id(param_name="block_id", expected_prefix=PrimitiveType.BLOCK)
     async def redo_checkpoint_block(
         self, block_id: str, actor: PydanticUser, use_preloaded_block: Optional[BlockModel] = None
     ) -> PydanticBlock:

letta/services/file_manager.py

@@ -15,7 +15,7 @@ from letta.orm.errors import NoResultFound
 from letta.orm.file import FileContent as FileContentModel, FileMetadata as FileMetadataModel
 from letta.orm.sqlalchemy_base import AccessType
 from letta.otel.tracing import trace_method
-from letta.schemas.enums import FileProcessingStatus
+from letta.schemas.enums import FileProcessingStatus, PrimitiveType
 from letta.schemas.file import FileMetadata as PydanticFileMetadata
 from letta.schemas.source import Source as PydanticSource
 from letta.schemas.source_metadata import FileStats, OrganizationSourcesStats, SourceStats
@@ -23,6 +23,7 @@ from letta.schemas.user import User as PydanticUser
 from letta.server.db import db_registry
 from letta.settings import settings
 from letta.utils import enforce_types
+from letta.validators import raise_on_invalid_id
 
 logger = get_logger(__name__)
 
@@ -60,7 +61,11 @@ class FileManager:
         text: Optional[str] = None,
     ) -> PydanticFileMetadata:
         # short-circuit if it already exists
-        existing = await self.get_file_by_id(file_metadata.id, actor=actor)
+        try:
+            existing = await self.get_file_by_id(file_metadata.id, actor=actor)
+        except NoResultFound:
+            existing = None
+
         if existing:
             return existing
 
@@ -89,6 +94,7 @@ class FileManager:
     # TODO: We make actor optional for now, but should most likely be enforced due to security reasons
     @enforce_types
     @trace_method
+    @raise_on_invalid_id(param_name="file_id", expected_prefix=PrimitiveType.FILE)
     # @async_redis_cache(
     #     key_func=lambda self, file_id, actor=None, include_content=False, strip_directory_prefix=False: f"{file_id}:{actor.organization_id if actor else 'none'}:{include_content}:{strip_directory_prefix}",
     #     prefix="file_content",
@@ -105,38 +111,33 @@ class FileManager:
         lazy SELECT (avoids MissingGreenlet).
         """
         async with db_registry.async_session() as session:
-            try:
-                if include_content:
-                    # explicit eager load
-                    query = (
-                        select(FileMetadataModel).where(FileMetadataModel.id == file_id).options(selectinload(FileMetadataModel.content))
-                    )
-                    # apply org-scoping if actor provided
-                    if actor:
-                        query = FileMetadataModel.apply_access_predicate(
-                            query,
-                            actor,
-                            access=["read"],
-                            access_type=AccessType.ORGANIZATION,
-                        )
-
-                    result = await session.execute(query)
-                    file_orm = result.scalar_one()
-                else:
-                    # fast path (metadata only)
-                    file_orm = await FileMetadataModel.read_async(
-                        db_session=session,
-                        identifier=file_id,
-                        actor=actor,
+            if include_content:
+                # explicit eager load
+                query = select(FileMetadataModel).where(FileMetadataModel.id == file_id).options(selectinload(FileMetadataModel.content))
+                # apply org-scoping if actor provided
+                if actor:
+                    query = FileMetadataModel.apply_access_predicate(
+                        query,
+                        actor,
+                        access=["read"],
+                        access_type=AccessType.ORGANIZATION,
                     )
 
-                return await file_orm.to_pydantic_async(include_content=include_content, strip_directory_prefix=strip_directory_prefix)
+                result = await session.execute(query)
+                file_orm = result.scalar_one()
+            else:
+                # fast path (metadata only)
+                file_orm = await FileMetadataModel.read_async(
+                    db_session=session,
+                    identifier=file_id,
+                    actor=actor,
+                )
 
-            except NoResultFound:
-                return None
+            return await file_orm.to_pydantic_async(include_content=include_content, strip_directory_prefix=strip_directory_prefix)
 
     @enforce_types
     @trace_method
+    @raise_on_invalid_id(param_name="file_id", expected_prefix=PrimitiveType.FILE)
     async def update_file_status(
         self,
         *,
@@ -173,7 +174,6 @@ class FileManager:
         * 1st round-trip → UPDATE with optional state validation
         * 2nd round-trip → SELECT fresh row (same as read_async) if update succeeded
         """
-
         if processing_status is None and error_message is None and total_chunks is None and chunks_embedded is None:
             raise ValueError("Nothing to update")
 
@@ -355,6 +355,7 @@ class FileManager:
 
     @enforce_types
     @trace_method
+    @raise_on_invalid_id(param_name="file_id", expected_prefix=PrimitiveType.FILE)
     async def upsert_file_content(
         self,
         *,
@@ -400,6 +401,7 @@ class FileManager:
 
     @enforce_types
     @trace_method
+    @raise_on_invalid_id(param_name="source_id", expected_prefix=PrimitiveType.SOURCE)
     async def list_files(
         self,
         source_id: str,
@@ -457,6 +459,7 @@ class FileManager:
 
     @enforce_types
     @trace_method
+    @raise_on_invalid_id(param_name="file_id", expected_prefix=PrimitiveType.FILE)
     async def delete_file(self, file_id: str, actor: PydanticUser) -> PydanticFileMetadata:
         """Delete a file by its ID."""
         async with db_registry.async_session() as session:
@@ -511,6 +514,7 @@ class FileManager:
 
     @enforce_types
     @trace_method
+    @raise_on_invalid_id(param_name="source_id", expected_prefix=PrimitiveType.SOURCE)
     # @async_redis_cache(
     #     key_func=lambda self, original_filename, source_id, actor: f"{original_filename}:{source_id}:{actor.organization_id}",
     #     prefix="file_by_name",

letta/services/group_manager.py

@@ -9,6 +9,7 @@ from letta.orm.errors import NoResultFound
 from letta.orm.group import Group as GroupModel
 from letta.orm.message import Message as MessageModel
 from letta.otel.tracing import trace_method
+from letta.schemas.enums import PrimitiveType
 from letta.schemas.group import Group as PydanticGroup, GroupCreate, GroupUpdate, InternalTemplateGroupCreate, ManagerType
 from letta.schemas.letta_message import LettaMessage
 from letta.schemas.message import Message as PydanticMessage
@@ -16,6 +17,7 @@ from letta.schemas.user import User as PydanticUser
 from letta.server.db import db_registry
 from letta.settings import DatabaseChoice, settings
 from letta.utils import enforce_types
+from letta.validators import raise_on_invalid_id
 
 
 class GroupManager:
@@ -62,6 +64,7 @@ class GroupManager:
 
     @enforce_types
     @trace_method
+    @raise_on_invalid_id(param_name="group_id", expected_prefix=PrimitiveType.GROUP)
     async def retrieve_group_async(self, group_id: str, actor: PydanticUser) -> PydanticGroup:
         async with db_registry.async_session() as session:
             group = await GroupModel.read_async(db_session=session, identifier=group_id, actor=actor)
@@ -119,6 +122,7 @@ class GroupManager:
 
     @enforce_types
     @trace_method
+    @raise_on_invalid_id(param_name="group_id", expected_prefix=PrimitiveType.GROUP)
     async def modify_group_async(self, group_id: str, group_update: GroupUpdate, actor: PydanticUser) -> PydanticGroup:
         async with db_registry.async_session() as session:
             group = await GroupModel.read_async(db_session=session, identifier=group_id, actor=actor)
@@ -182,6 +186,7 @@ class GroupManager:
 
     @enforce_types
     @trace_method
+    @raise_on_invalid_id(param_name="group_id", expected_prefix=PrimitiveType.GROUP)
     async def delete_group_async(self, group_id: str, actor: PydanticUser) -> None:
         async with db_registry.async_session() as session:
             group = await GroupModel.read_async(db_session=session, identifier=group_id, actor=actor)
@@ -189,6 +194,7 @@ class GroupManager:
 
     @enforce_types
     @trace_method
+    @raise_on_invalid_id(param_name="group_id", expected_prefix=PrimitiveType.GROUP)
     async def list_group_messages_async(
         self,
         actor: PydanticUser,
@@ -226,6 +232,7 @@ class GroupManager:
 
     @enforce_types
     @trace_method
+    @raise_on_invalid_id(param_name="group_id", expected_prefix=PrimitiveType.GROUP)
     async def reset_messages_async(self, group_id: str, actor: PydanticUser) -> None:
         async with db_registry.async_session() as session:
             # Ensure group is loadable by user
@@ -241,6 +248,7 @@ class GroupManager:
 
     @enforce_types
     @trace_method
+    @raise_on_invalid_id(param_name="group_id", expected_prefix=PrimitiveType.GROUP)
     async def bump_turns_counter_async(self, group_id: str, actor: PydanticUser) -> int:
         async with db_registry.async_session() as session:
             # Ensure group is loadable by user
@@ -253,6 +261,8 @@ class GroupManager:
 
     @enforce_types
     @trace_method
+    @raise_on_invalid_id(param_name="group_id", expected_prefix=PrimitiveType.GROUP)
+    @raise_on_invalid_id(param_name="last_processed_message_id", expected_prefix=PrimitiveType.MESSAGE)
     async def get_last_processed_message_id_and_update_async(
         self, group_id: str, last_processed_message_id: str, actor: PydanticUser
     ) -> str: