letta-nightly 0.8.13.dev20250714104447__py3-none-any.whl → 0.8.15.dev20250715080149__py3-none-any.whl

letta/services/block_manager.py

@@ -23,8 +23,8 @@ logger = get_logger(__name__)
 class BlockManager:
     """Manager class to handle business logic related to Blocks."""
 
-    @trace_method
     @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)
@@ -38,8 +38,8 @@ class BlockManager:
                 block.create(session, actor=actor)
             return block.to_pydantic()
 
-    @trace_method
     @enforce_types
+    @trace_method
     async def create_or_update_block_async(self, block: PydanticBlock, actor: PydanticUser) -> PydanticBlock:
         """Create a new block based on the Block schema."""
         db_block = await self.get_block_by_id_async(block.id, actor)
@@ -53,8 +53,8 @@ class BlockManager:
                 await block.create_async(session, actor=actor)
                 return block.to_pydantic()
 
-    @trace_method
     @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.
@@ -77,8 +77,8 @@ class BlockManager:
             # Convert back to Pydantic
             return [m.to_pydantic() for m in created_models]
 
-    @trace_method
     @enforce_types
+    @trace_method
     async def batch_create_blocks_async(self, blocks: List[PydanticBlock], actor: PydanticUser) -> List[PydanticBlock]:
         """
         Batch-create multiple Blocks in one transaction for better performance.
@@ -101,8 +101,8 @@ class BlockManager:
             # Convert back to Pydantic
             return [m.to_pydantic() for m in created_models]
 
-    @trace_method
     @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
@@ -117,8 +117,8 @@ class BlockManager:
             block.update(db_session=session, actor=actor)
             return block.to_pydantic()
 
-    @trace_method
     @enforce_types
+    @trace_method
     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
@@ -133,8 +133,8 @@ class BlockManager:
             await block.update_async(db_session=session, actor=actor)
             return block.to_pydantic()
 
-    @trace_method
     @enforce_types
+    @trace_method
     def delete_block(self, block_id: str, actor: PydanticUser) -> PydanticBlock:
         """Delete a block by its ID."""
         with db_registry.session() as session:
@@ -142,8 +142,8 @@ class BlockManager:
             block.hard_delete(db_session=session, actor=actor)
             return block.to_pydantic()
 
-    @trace_method
     @enforce_types
+    @trace_method
     async def delete_block_async(self, block_id: str, actor: PydanticUser) -> PydanticBlock:
         """Delete a block by its ID."""
         async with db_registry.async_session() as session:
@@ -151,8 +151,8 @@ class BlockManager:
             await block.hard_delete_async(db_session=session, actor=actor)
             return block.to_pydantic()
 
-    @trace_method
     @enforce_types
+    @trace_method
     async def get_blocks_async(
         self,
         actor: PydanticUser,
@@ -214,8 +214,8 @@ class BlockManager:
 
             return [block.to_pydantic() for block in blocks]
 
-    @trace_method
     @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:
@@ -225,8 +225,8 @@ class BlockManager:
             except NoResultFound:
                 return None
 
-    @trace_method
     @enforce_types
+    @trace_method
     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:
@@ -236,8 +236,8 @@ class BlockManager:
             except NoResultFound:
                 return None
 
-    @trace_method
     @enforce_types
+    @trace_method
     async def get_all_blocks_by_ids_async(self, block_ids: List[str], actor: Optional[PydanticUser] = None) -> List[PydanticBlock]:
         """Retrieve blocks by their ids without loading unnecessary relationships. Async implementation."""
         from sqlalchemy import select
@@ -284,8 +284,8 @@ class BlockManager:
 
             return pydantic_blocks
 
-    @trace_method
     @enforce_types
+    @trace_method
     async def get_agents_for_block_async(
         self,
         block_id: str,
@@ -301,8 +301,8 @@ class BlockManager:
             agents = await asyncio.gather(*[agent.to_pydantic_async(include_relationships=include_relationships) for agent in agents_orm])
             return agents
 
-    @trace_method
     @enforce_types
+    @trace_method
     async def size_async(self, actor: PydanticUser) -> int:
         """
         Get the total count of blocks for the given user.
@@ -312,8 +312,8 @@ class BlockManager:
 
     # Block History Functions
 
-    @trace_method
     @enforce_types
+    @trace_method
     def checkpoint_block(
         self,
         block_id: str,
@@ -416,8 +416,8 @@ class BlockManager:
         updated_block = block.update(db_session=session, actor=actor, no_commit=True)
         return updated_block
 
-    @trace_method
     @enforce_types
+    @trace_method
     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.
@@ -459,8 +459,8 @@ class BlockManager:
             session.commit()
             return block.to_pydantic()
 
-    @trace_method
     @enforce_types
+    @trace_method
     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.
@@ -498,8 +498,8 @@ class BlockManager:
             session.commit()
             return block.to_pydantic()
 
-    @trace_method
     @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]]:

letta/services/context_window_calculator/context_window_calculator.py

@@ -4,11 +4,14 @@ from typing import Any, List, Optional, Tuple
 from openai.types.beta.function_tool import FunctionTool as OpenAITool
 
 from letta.log import get_logger
+from letta.schemas.agent import AgentState
 from letta.schemas.enums import MessageRole
 from letta.schemas.letta_message_content import TextContent
 from letta.schemas.memory import ContextWindowOverview
+from letta.schemas.message import Message
 from letta.schemas.user import User as PydanticUser
 from letta.services.context_window_calculator.token_counter import TokenCounter
+from letta.services.message_manager import MessageManager
 
 logger = get_logger(__name__)
 
@@ -56,16 +59,18 @@ class ContextWindowCalculator:
         return None, 1
 
     async def calculate_context_window(
-        self, agent_state: Any, actor: PydanticUser, token_counter: TokenCounter, message_manager: Any, passage_manager: Any
+        self,
+        agent_state: AgentState,
+        actor: PydanticUser,
+        token_counter: TokenCounter,
+        message_manager: MessageManager,
+        system_message_compiled: Message,
+        num_archival_memories: int,
+        num_messages: int,
     ) -> ContextWindowOverview:
         """Calculate context window information using the provided token counter"""
-
-        # Fetch data concurrently
-        (in_context_messages, passage_manager_size, message_manager_size) = await asyncio.gather(
-            message_manager.get_messages_by_ids_async(message_ids=agent_state.message_ids, actor=actor),
-            passage_manager.agent_passage_size_async(actor=actor, agent_id=agent_state.id),
-            message_manager.size_async(actor=actor, agent_id=agent_state.id),
-        )
+        messages = await message_manager.get_messages_by_ids_async(message_ids=agent_state.message_ids[1:], actor=actor)
+        in_context_messages = [system_message_compiled] + messages
 
         # Convert messages to appropriate format
         converted_messages = token_counter.convert_messages(in_context_messages)
@@ -128,8 +133,8 @@ class ContextWindowCalculator:
         return ContextWindowOverview(
             # context window breakdown (in messages)
             num_messages=len(in_context_messages),
-            num_archival_memory=passage_manager_size,
-            num_recall_memory=message_manager_size,
+            num_archival_memory=num_archival_memories,
+            num_recall_memory=num_messages,
             num_tokens_external_memory_summary=num_tokens_external_memory_summary,
             external_memory_summary=external_memory_summary,
             # top-level information

letta/services/context_window_calculator/token_counter.py

@@ -1,7 +1,11 @@
+import hashlib
+import json
 from abc import ABC, abstractmethod
 from typing import Any, Dict, List
 
+from letta.helpers.decorators import async_redis_cache
 from letta.llm_api.anthropic_client import AnthropicClient
+from letta.otel.tracing import trace_method
 from letta.schemas.openai.chat_completion_request import Tool as OpenAITool
 from letta.utils import count_tokens
 
@@ -33,16 +37,34 @@ class AnthropicTokenCounter(TokenCounter):
         self.client = anthropic_client
         self.model = model
 
+    @trace_method
+    @async_redis_cache(
+        key_func=lambda self, text: f"anthropic_text_tokens:{self.model}:{hashlib.sha256(text.encode()).hexdigest()[:16]}",
+        prefix="token_counter",
+        ttl_s=3600,  # cache for 1 hour
+    )
     async def count_text_tokens(self, text: str) -> int:
         if not text:
             return 0
         return await self.client.count_tokens(model=self.model, messages=[{"role": "user", "content": text}])
 
+    @trace_method
+    @async_redis_cache(
+        key_func=lambda self, messages: f"anthropic_message_tokens:{self.model}:{hashlib.sha256(json.dumps(messages, sort_keys=True).encode()).hexdigest()[:16]}",
+        prefix="token_counter",
+        ttl_s=3600,  # cache for 1 hour
+    )
     async def count_message_tokens(self, messages: List[Dict[str, Any]]) -> int:
         if not messages:
             return 0
         return await self.client.count_tokens(model=self.model, messages=messages)
 
+    @trace_method
+    @async_redis_cache(
+        key_func=lambda self, tools: f"anthropic_tool_tokens:{self.model}:{hashlib.sha256(json.dumps([t.model_dump() for t in tools], sort_keys=True).encode()).hexdigest()[:16]}",
+        prefix="token_counter",
+        ttl_s=3600,  # cache for 1 hour
+    )
     async def count_tool_tokens(self, tools: List[OpenAITool]) -> int:
         if not tools:
             return 0
@@ -58,11 +80,23 @@ class TiktokenCounter(TokenCounter):
     def __init__(self, model: str):
         self.model = model
 
+    @trace_method
+    @async_redis_cache(
+        key_func=lambda self, text: f"tiktoken_text_tokens:{self.model}:{hashlib.sha256(text.encode()).hexdigest()[:16]}",
+        prefix="token_counter",
+        ttl_s=3600,  # cache for 1 hour
+    )
     async def count_text_tokens(self, text: str) -> int:
         if not text:
             return 0
         return count_tokens(text)
 
+    @trace_method
+    @async_redis_cache(
+        key_func=lambda self, messages: f"tiktoken_message_tokens:{self.model}:{hashlib.sha256(json.dumps(messages, sort_keys=True).encode()).hexdigest()[:16]}",
+        prefix="token_counter",
+        ttl_s=3600,  # cache for 1 hour
+    )
     async def count_message_tokens(self, messages: List[Dict[str, Any]]) -> int:
         if not messages:
             return 0
@@ -70,6 +104,12 @@ class TiktokenCounter(TokenCounter):
 
         return num_tokens_from_messages(messages=messages, model=self.model)
 
+    @trace_method
+    @async_redis_cache(
+        key_func=lambda self, tools: f"tiktoken_tool_tokens:{self.model}:{hashlib.sha256(json.dumps([t.model_dump() for t in tools], sort_keys=True).encode()).hexdigest()[:16]}",
+        prefix="token_counter",
+        ttl_s=3600,  # cache for 1 hour
+    )
     async def count_tool_tokens(self, tools: List[OpenAITool]) -> int:
         if not tools:
             return 0

letta/services/file_manager.py

@@ -8,6 +8,7 @@ from sqlalchemy.exc import IntegrityError
 from sqlalchemy.orm import selectinload
 
 from letta.constants import MAX_FILENAME_LENGTH
+from letta.helpers.decorators import async_redis_cache
 from letta.orm.errors import NoResultFound
 from letta.orm.file import FileContent as FileContentModel
 from letta.orm.file import FileMetadata as FileMetadataModel
@@ -34,6 +35,16 @@ class DuplicateFileError(Exception):
 class FileManager:
     """Manager class to handle business logic related to files."""
 
+    async def _invalidate_file_caches(self, file_id: str, actor: PydanticUser, original_filename: str = None, source_id: str = None):
+        """Invalidate all caches related to a file."""
+        # invalidate file content cache (all variants)
+        await self.get_file_by_id.cache_invalidate(self, file_id, actor, include_content=True)
+        await self.get_file_by_id.cache_invalidate(self, file_id, actor, include_content=False)
+
+        # invalidate filename-based cache if we have the info
+        if original_filename and source_id:
+            await self.get_file_by_original_name_and_source.cache_invalidate(self, original_filename, source_id, actor)
+
     @enforce_types
     @trace_method
     async def create_file(
@@ -61,6 +72,10 @@ class FileManager:
 
                 await session.commit()
                 await session.refresh(file_orm)
+
+                # invalidate cache for this new file
+                await self._invalidate_file_caches(file_orm.id, actor, file_orm.original_file_name, file_orm.source_id)
+
                 return await file_orm.to_pydantic_async()
 
             except IntegrityError:
@@ -70,6 +85,12 @@ class FileManager:
     # TODO: We make actor optional for now, but should most likely be enforced due to security reasons
     @enforce_types
     @trace_method
+    @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",
+        ttl_s=3600,
+        model_class=PydanticFileMetadata,
+    )
     async def get_file_by_id(
         self, file_id: str, actor: Optional[PydanticUser] = None, *, include_content: bool = False, strip_directory_prefix: bool = False
     ) -> Optional[PydanticFileMetadata]:
@@ -155,6 +176,9 @@ class FileManager:
             await session.execute(stmt)
             await session.commit()
 
+            # invalidate cache for this file
+            await self._invalidate_file_caches(file_id, actor)
+
             # Reload via normal accessor so we return a fully-attached object
             file_orm = await FileMetadataModel.read_async(
                 db_session=session,
@@ -200,6 +224,9 @@ class FileManager:
 
             await session.commit()
 
+            # invalidate cache for this file since content changed
+            await self._invalidate_file_caches(file_id, actor)
+
             # Reload with content
             query = select(FileMetadataModel).options(selectinload(FileMetadataModel.content)).where(FileMetadataModel.id == file_id)
             result = await session.execute(query)
@@ -239,6 +266,10 @@ class FileManager:
         """Delete a file by its ID."""
         async with db_registry.async_session() as session:
             file = await FileMetadataModel.read_async(db_session=session, identifier=file_id)
+
+            # invalidate cache for this file before deletion
+            await self._invalidate_file_caches(file_id, actor, file.original_file_name, file.source_id)
+
             await file.hard_delete_async(db_session=session, actor=actor)
             return await file.to_pydantic_async()
 
@@ -285,6 +316,12 @@ class FileManager:
 
     @enforce_types
     @trace_method
+    @async_redis_cache(
+        key_func=lambda self, original_filename, source_id, actor: f"{original_filename}:{source_id}:{actor.organization_id}",
+        prefix="file_by_name",
+        ttl_s=3600,
+        model_class=PydanticFileMetadata,
+    )
     async def get_file_by_original_name_and_source(
         self, original_filename: str, source_id: str, actor: PydanticUser
     ) -> Optional[PydanticFileMetadata]:

letta/services/file_processor/chunker/line_chunker.py

@@ -40,6 +40,10 @@ class LineChunker:
 
     def _chunk_by_lines(self, text: str, preserve_indentation: bool = False) -> List[str]:
         """Traditional line-based chunking for code and structured data"""
+        # early stop, can happen if the there's nothing on a specific file
+        if not text:
+            return []
+
         lines = []
         for line in text.splitlines():
             if preserve_indentation:
@@ -57,6 +61,10 @@ class LineChunker:
 
     def _chunk_by_sentences(self, text: str) -> List[str]:
         """Sentence-based chunking for documentation and markup"""
+        # early stop, can happen if the there's nothing on a specific file
+        if not text:
+            return []
+
         # Simple sentence splitting on periods, exclamation marks, and question marks
         # followed by whitespace or end of string
         sentence_pattern = r"(?<=[.!?])\s+(?=[A-Z])"
@@ -75,6 +83,10 @@ class LineChunker:
 
     def _chunk_by_characters(self, text: str, target_line_length: int = 100) -> List[str]:
         """Character-based wrapping for prose text"""
+        # early stop, can happen if the there's nothing on a specific file
+        if not text:
+            return []
+
         words = text.split()
         lines = []
         current_line = []
@@ -110,6 +122,11 @@ class LineChunker:
         strategy = self._determine_chunking_strategy(file_metadata)
         text = file_metadata.content
 
+        # early stop, can happen if the there's nothing on a specific file
+        if not text:
+            logger.warning(f"File ({file_metadata}) has no content")
+            return []
+
         # Apply the appropriate chunking strategy
         if strategy == ChunkingStrategy.DOCUMENTATION:
             content_lines = self._chunk_by_sentences(text)

letta/services/file_processor/embedder/openai_embedder.py

@@ -25,7 +25,6 @@ class OpenAIEmbedder(BaseEmbedder):
             else EmbeddingConfig.default_config(model_name="letta")
         )
         self.embedding_config = embedding_config or self.default_embedding_config
-        self.max_concurrent_requests = 20
 
         # TODO: Unify to global OpenAI client
         self.client: OpenAIClient = cast(
@@ -48,9 +47,55 @@ class OpenAIEmbedder(BaseEmbedder):
                 "embedding_endpoint_type": self.embedding_config.embedding_endpoint_type,
             },
         )
-        embeddings = await self.client.request_embeddings(inputs=batch, embedding_config=self.embedding_config)
-        log_event("embedder.batch_completed", {"batch_size": len(batch), "embeddings_generated": len(embeddings)})
-        return [(idx, e) for idx, e in zip(batch_indices, embeddings)]
+
+        try:
+            embeddings = await self.client.request_embeddings(inputs=batch, embedding_config=self.embedding_config)
+            log_event("embedder.batch_completed", {"batch_size": len(batch), "embeddings_generated": len(embeddings)})
+            return [(idx, e) for idx, e in zip(batch_indices, embeddings)]
+        except Exception as e:
+            # if it's a token limit error and we can split, do it
+            if self._is_token_limit_error(e) and len(batch) > 1:
+                logger.warning(f"Token limit exceeded for batch of size {len(batch)}, splitting in half and retrying")
+                log_event(
+                    "embedder.batch_split_retry",
+                    {
+                        "original_batch_size": len(batch),
+                        "error": str(e),
+                        "split_size": len(batch) // 2,
+                    },
+                )
+
+                # split batch in half
+                mid = len(batch) // 2
+                batch1 = batch[:mid]
+                batch1_indices = batch_indices[:mid]
+                batch2 = batch[mid:]
+                batch2_indices = batch_indices[mid:]
+
+                # retry with smaller batches
+                result1 = await self._embed_batch(batch1, batch1_indices)
+                result2 = await self._embed_batch(batch2, batch2_indices)
+
+                return result1 + result2
+            else:
+                # re-raise for other errors or if batch size is already 1
+                raise
+
+    def _is_token_limit_error(self, error: Exception) -> bool:
+        """Check if the error is due to token limit exceeded"""
+        # convert to string and check for token limit patterns
+        error_str = str(error).lower()
+
+        # TODO: This is quite brittle, works for now
+        # check for the specific patterns we see in token limit errors
+        is_token_limit = (
+            "max_tokens_per_request" in error_str
+            or ("requested" in error_str and "tokens" in error_str and "max" in error_str and "per request" in error_str)
+            or "token limit" in error_str
+            or ("bad request to openai" in error_str and "tokens" in error_str and "max" in error_str)
+        )
+
+        return is_token_limit
 
     @trace_method
     async def generate_embedded_passages(self, file_id: str, source_id: str, chunks: List[str], actor: User) -> List[Passage]:
@@ -100,7 +145,7 @@ class OpenAIEmbedder(BaseEmbedder):
 
         log_event(
             "embedder.concurrent_processing_started",
-            {"concurrent_tasks": len(tasks), "max_concurrent_requests": self.max_concurrent_requests},
+            {"concurrent_tasks": len(tasks)},
         )
         results = await asyncio.gather(*tasks)
         log_event("embedder.concurrent_processing_completed", {"batches_processed": len(results)})

letta/services/files_agents_manager.py

@@ -29,6 +29,7 @@ class FileAgentManager:
         agent_id: str,
         file_id: str,
         file_name: str,
+        source_id: str,
         actor: PydanticUser,
         is_open: bool = True,
         visible_content: Optional[str] = None,
@@ -47,7 +48,12 @@ class FileAgentManager:
         if is_open:
             # Use the efficient LRU + open method
             closed_files, was_already_open = await self.enforce_max_open_files_and_open(
-                agent_id=agent_id, file_id=file_id, file_name=file_name, actor=actor, visible_content=visible_content or ""
+                agent_id=agent_id,
+                file_id=file_id,
+                file_name=file_name,
+                source_id=source_id,
+                actor=actor,
+                visible_content=visible_content or "",
             )
 
             # Get the updated file agent to return
@@ -85,6 +91,7 @@ class FileAgentManager:
                     agent_id=agent_id,
                     file_id=file_id,
                     file_name=file_name,
+                    source_id=source_id,
                     organization_id=actor.organization_id,
                     is_open=is_open,
                     visible_content=visible_content,
@@ -327,7 +334,7 @@ class FileAgentManager:
     @enforce_types
     @trace_method
     async def enforce_max_open_files_and_open(
-        self, *, agent_id: str, file_id: str, file_name: str, actor: PydanticUser, visible_content: str
+        self, *, agent_id: str, file_id: str, file_name: str, source_id: str, actor: PydanticUser, visible_content: str
     ) -> tuple[List[str], bool]:
         """
         Efficiently handle LRU eviction and file opening in a single transaction.
@@ -336,6 +343,7 @@ class FileAgentManager:
             agent_id: ID of the agent
             file_id: ID of the file to open
             file_name: Name of the file to open
+            source_id: ID of the source (denormalized from files.source_id)
             actor: User performing the action
             visible_content: Content to set for the opened file
 
@@ -418,6 +426,7 @@ class FileAgentManager:
                     agent_id=agent_id,
                     file_id=file_id,
                     file_name=file_name,
+                    source_id=source_id,
                     organization_id=actor.organization_id,
                     is_open=True,
                     visible_content=visible_content,
@@ -516,6 +525,7 @@ class FileAgentManager:
                             agent_id=agent_id,
                             file_id=meta.id,
                             file_name=meta.file_name,
+                            source_id=meta.source_id,
                             organization_id=actor.organization_id,
                             is_open=is_now_open,
                             visible_content=vc,

letta/services/group_manager.py

@@ -19,8 +19,8 @@ from letta.utils import enforce_types
 
 class GroupManager:
 
-    @trace_method
     @enforce_types
+    @trace_method
     def list_groups(
         self,
         actor: PydanticUser,
@@ -45,22 +45,22 @@ class GroupManager:
             )
             return [group.to_pydantic() for group in groups]
 
-    @trace_method
     @enforce_types
+    @trace_method
     def retrieve_group(self, group_id: str, actor: PydanticUser) -> PydanticGroup:
         with db_registry.session() as session:
             group = GroupModel.read(db_session=session, identifier=group_id, actor=actor)
             return group.to_pydantic()
 
-    @trace_method
     @enforce_types
+    @trace_method
     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)
             return group.to_pydantic()
 
-    @trace_method
     @enforce_types
+    @trace_method
     def create_group(self, group: GroupCreate, actor: PydanticUser) -> PydanticGroup:
         with db_registry.session() as session:
             new_group = GroupModel()
@@ -150,8 +150,8 @@ class GroupManager:
             await new_group.create_async(session, actor=actor)
             return new_group.to_pydantic()
 
-    @trace_method
     @enforce_types
+    @trace_method
     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)
@@ -213,16 +213,16 @@ class GroupManager:
             await group.update_async(session, actor=actor)
             return group.to_pydantic()
 
-    @trace_method
     @enforce_types
+    @trace_method
     def delete_group(self, group_id: str, actor: PydanticUser) -> None:
         with db_registry.session() as session:
             # Retrieve the agent
             group = GroupModel.read(db_session=session, identifier=group_id, actor=actor)
             group.hard_delete(session)
 
-    @trace_method
     @enforce_types
+    @trace_method
     def list_group_messages(
         self,
         actor: PydanticUser,
@@ -258,8 +258,8 @@ class GroupManager:
 
             return messages
 
-    @trace_method
     @enforce_types
+    @trace_method
     def reset_messages(self, group_id: str, actor: PydanticUser) -> None:
         with db_registry.session() as session:
             # Ensure group is loadable by user
@@ -272,8 +272,8 @@ class GroupManager:
 
             session.commit()
 
-    @trace_method
     @enforce_types
+    @trace_method
     def bump_turns_counter(self, group_id: str, actor: PydanticUser) -> int:
         with db_registry.session() as session:
             # Ensure group is loadable by user
@@ -284,8 +284,8 @@ class GroupManager:
             group.update(session, actor=actor)
             return group.turns_counter
 
-    @trace_method
     @enforce_types
+    @trace_method
     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
@@ -309,8 +309,8 @@ class GroupManager:
 
             return prev_last_processed_message_id
 
-    @trace_method
     @enforce_types
+    @trace_method
     async def get_last_processed_message_id_and_update_async(
         self, group_id: str, last_processed_message_id: str, actor: PydanticUser
     ) -> str: