letta-nightly 0.11.6.dev20250903104037__py3-none-any.whl → 0.11.7.dev20250904045700__py3-none-any.whl

letta/services/agent_serialization_manager.py

@@ -28,6 +28,7 @@ from letta.schemas.agent_file import (
     ToolSchema,
 )
 from letta.schemas.block import Block
+from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.enums import FileProcessingStatus
 from letta.schemas.file import FileMetadata
 from letta.schemas.group import Group, GroupCreate
@@ -432,6 +433,8 @@ class AgentSerializationManager:
         override_existing_tools: bool = True,
         dry_run: bool = False,
         env_vars: Optional[Dict[str, Any]] = None,
+        override_embedding_config: Optional[EmbeddingConfig] = None,
+        project_id: Optional[str] = None,
     ) -> ImportResult:
         """
         Import AgentFileSchema into the database.
@@ -530,6 +533,12 @@ class AgentSerializationManager:
                 source_names_to_check = [s.name for s in schema.sources]
                 existing_source_names = await self.source_manager.get_existing_source_names(source_names_to_check, actor)
 
+                # override embedding_config
+                if override_embedding_config:
+                    for source_schema in schema.sources:
+                        source_schema.embedding_config = override_embedding_config
+                        source_schema.embedding = override_embedding_config.handle
+
                 for source_schema in schema.sources:
                     source_data = source_schema.model_dump(exclude={"id", "embedding", "embedding_chunk_size"})
 
@@ -577,10 +586,12 @@ class AgentSerializationManager:
             # Start background tasks for file processing
             background_tasks = []
             if schema.files and any(f.content for f in schema.files):
+                # Use override embedding config if provided, otherwise use agent's config
+                embedder_config = override_embedding_config if override_embedding_config else schema.agents[0].embedding_config
                 if should_use_pinecone():
-                    embedder = PineconeEmbedder(embedding_config=schema.agents[0].embedding_config)
+                    embedder = PineconeEmbedder(embedding_config=embedder_config)
                 else:
-                    embedder = OpenAIEmbedder(embedding_config=schema.agents[0].embedding_config)
+                    embedder = OpenAIEmbedder(embedding_config=embedder_config)
                 file_processor = FileProcessor(
                     file_parser=self.file_parser,
                     embedder=embedder,
@@ -613,6 +624,11 @@ class AgentSerializationManager:
 
             # 6. Create agents with empty message history
             for agent_schema in schema.agents:
+                # Override embedding_config if provided
+                if override_embedding_config:
+                    agent_schema.embedding_config = override_embedding_config
+                    agent_schema.embedding = override_embedding_config.handle
+
                 # Convert AgentSchema back to CreateAgent, remapping tool/block IDs
                 agent_data = agent_schema.model_dump(exclude={"id", "in_context_message_ids", "messages"})
                 if append_copy_suffix:
@@ -634,6 +650,10 @@ class AgentSerializationManager:
                     for var in agent_data["tool_exec_environment_variables"]:
                         var["value"] = env_vars.get(var["key"], "")
 
+                # Override project_id if provided
+                if project_id:
+                    agent_data["project_id"] = project_id
+
                 agent_create = CreateAgent(**agent_data)
                 created_agent = await self.agent_manager.create_agent_async(agent_create, actor, _init_with_no_messages=True)
                 file_to_db_ids[agent_schema.id] = created_agent.id
@@ -648,7 +668,7 @@ class AgentSerializationManager:
                 messages = []
                 for message_schema in agent_schema.messages:
                     # Convert MessageSchema back to Message, setting agent_id to new DB ID
-                    message_data = message_schema.model_dump(exclude={"id"})
+                    message_data = message_schema.model_dump(exclude={"id", "type"})
                     message_data["agent_id"] = agent_db_id  # Remap agent_id to new database ID
                     message_obj = Message(**message_data)
                     messages.append(message_obj)

letta/services/archive_manager.py

@@ -2,13 +2,14 @@ from typing import List, Optional
 
 from sqlalchemy import select
 
+from letta.helpers.tpuf_client import should_use_tpuf
 from letta.log import get_logger
-from letta.orm import ArchivalPassage
-from letta.orm import Archive as ArchiveModel
-from letta.orm import ArchivesAgents
+from letta.orm import ArchivalPassage, Archive as ArchiveModel, ArchivesAgents
 from letta.schemas.archive import Archive as PydanticArchive
+from letta.schemas.enums import VectorDBProvider
 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
 
 logger = get_logger(__name__)
@@ -27,10 +28,14 @@ class ArchiveManager:
         """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()
@@ -48,10 +53,14 @@ class ArchiveManager:
         """Create a new archive."""
         try:
             async with db_registry.async_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,
                 )
                 await archive.create_async(session, actor=actor)
                 return archive.to_pydantic()
@@ -138,6 +147,37 @@ class ArchiveManager:
             session.add(archives_agents)
             await session.commit()
 
+    @enforce_types
+    async def get_default_archive_for_agent_async(
+        self,
+        agent_id: str,
+        actor: PydanticUser = None,
+    ) -> Optional[PydanticArchive]:
+        """Get the agent's default archive if it exists, return None otherwise."""
+        # First check if agent has any archives
+        from letta.services.agent_manager import AgentManager
+
+        agent_manager = AgentManager()
+
+        archive_ids = await agent_manager.get_agent_archive_ids_async(
+            agent_id=agent_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")
+            # Get the archive
+            archive = await self.get_archive_by_id_async(
+                archive_id=archive_ids[0],
+                actor=actor,
+            )
+            return archive
+
+        # No archive found, return None
+        return None
+
     @enforce_types
     async def get_or_create_default_archive_for_agent_async(
         self,
@@ -267,3 +307,32 @@ class ArchiveManager:
 
             # For now, return the first agent (backwards compatibility)
             return agent_ids[0]
+
+    @enforce_types
+    async def get_or_set_vector_db_namespace_async(
+        self,
+        archive_id: str,
+    ) -> str:
+        """Get the vector database namespace for an archive, creating it if it doesn't exist."""
+        from sqlalchemy import update
+
+        async with db_registry.async_session() as session:
+            # check if namespace already exists
+            result = await session.execute(select(ArchiveModel._vector_db_namespace).where(ArchiveModel.id == archive_id))
+            row = result.fetchone()
+
+            if row and row[0]:
+                return row[0]
+
+            # generate namespace name using same logic as tpuf_client
+            environment = settings.environment
+            if environment:
+                namespace_name = f"archive_{archive_id}_{environment.lower()}"
+            else:
+                namespace_name = f"archive_{archive_id}"
+
+            # update the archive with the namespace
+            await session.execute(update(ArchiveModel).where(ArchiveModel.id == archive_id).values(_vector_db_namespace=namespace_name))
+            await session.commit()
+
+            return namespace_name

letta/services/block_manager.py

@@ -13,8 +13,7 @@ from letta.orm.blocks_agents import BlocksAgents
 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
-from letta.schemas.block import BlockUpdate
+from letta.schemas.block import Block as PydanticBlock, BlockUpdate
 from letta.schemas.enums import ActorType
 from letta.schemas.user import User as PydanticUser
 from letta.server.db import db_registry

letta/services/context_window_calculator/token_counter.py

@@ -6,6 +6,7 @@ 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.message import Message
 from letta.schemas.openai.chat_completion_request import Tool as OpenAITool
 from letta.utils import count_tokens
 
@@ -50,7 +51,8 @@ class AnthropicTokenCounter(TokenCounter):
 
     @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]}",
+        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
     )
@@ -61,7 +63,8 @@ class AnthropicTokenCounter(TokenCounter):
 
     @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]}",
+        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
     )
@@ -71,7 +74,7 @@ class AnthropicTokenCounter(TokenCounter):
         return await self.client.count_tokens(model=self.model, tools=tools)
 
     def convert_messages(self, messages: List[Any]) -> List[Dict[str, Any]]:
-        return [m.to_anthropic_dict() for m in messages]
+        return Message.to_anthropic_dicts_from_list(messages)
 
 
 class TiktokenCounter(TokenCounter):
@@ -93,7 +96,8 @@ class TiktokenCounter(TokenCounter):
 
     @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]}",
+        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
     )
@@ -106,7 +110,8 @@ class TiktokenCounter(TokenCounter):
 
     @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]}",
+        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
     )
@@ -120,4 +125,4 @@ class TiktokenCounter(TokenCounter):
         return num_tokens_from_functions(functions=functions, model=self.model)
 
     def convert_messages(self, messages: List[Any]) -> List[Dict[str, Any]]:
-        return [m.to_openai_dict() for m in messages]
+        return Message.to_openai_dicts_from_list(messages)

letta/services/file_manager.py

@@ -12,8 +12,7 @@ from letta.constants import MAX_FILENAME_LENGTH
 from letta.helpers.pinecone_utils import list_pinecone_index_for_files, should_use_pinecone
 from letta.log import get_logger
 from letta.orm.errors import NoResultFound
-from letta.orm.file import FileContent as FileContentModel
-from letta.orm.file import FileMetadata as FileMetadataModel
+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
@@ -60,7 +59,6 @@ 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)
         if existing:

letta/services/files_agents_manager.py

@@ -7,10 +7,8 @@ from letta.log import get_logger
 from letta.orm.errors import NoResultFound
 from letta.orm.files_agents import FileAgent as FileAgentModel
 from letta.otel.tracing import trace_method
-from letta.schemas.block import Block as PydanticBlock
-from letta.schemas.block import FileBlock as PydanticFileBlock
-from letta.schemas.file import FileAgent as PydanticFileAgent
-from letta.schemas.file import FileMetadata
+from letta.schemas.block import Block as PydanticBlock, FileBlock as PydanticFileBlock
+from letta.schemas.file import FileAgent as PydanticFileAgent, FileMetadata
 from letta.schemas.user import User as PydanticUser
 from letta.server.db import db_registry
 from letta.utils import enforce_types

letta/services/group_manager.py

@@ -1,6 +1,6 @@
-from typing import List, Optional
+from typing import List, Optional, Union
 
-from sqlalchemy import select
+from sqlalchemy import delete, select
 from sqlalchemy.orm import Session
 
 from letta.orm.agent import Agent as AgentModel
@@ -8,8 +8,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.group import Group as PydanticGroup
-from letta.schemas.group import GroupCreate, GroupUpdate, ManagerType
+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
 from letta.schemas.user import User as PydanticUser
@@ -20,7 +19,7 @@ from letta.utils import enforce_types
 class GroupManager:
     @enforce_types
     @trace_method
-    def list_groups(
+    async def list_groups_async(
         self,
         actor: PydanticUser,
         project_id: Optional[str] = None,
@@ -29,13 +28,13 @@ class GroupManager:
         after: Optional[str] = None,
         limit: Optional[int] = 50,
     ) -> list[PydanticGroup]:
-        with db_registry.session() as session:
+        async with db_registry.async_session() as session:
             filters = {"organization_id": actor.organization_id}
             if project_id:
                 filters["project_id"] = project_id
             if manager_type:
                 filters["manager_type"] = manager_type
-            groups = GroupModel.list(
+            groups = await GroupModel.list_async(
                 db_session=session,
                 before=before,
                 after=after,
@@ -60,7 +59,7 @@ class GroupManager:
 
     @enforce_types
     @trace_method
-    def create_group(self, group: GroupCreate, actor: PydanticUser) -> PydanticGroup:
+    def create_group(self, group: Union[GroupCreate, InternalTemplateGroupCreate], actor: PydanticUser) -> PydanticGroup:
         with db_registry.session() as session:
             new_group = GroupModel()
             new_group.organization_id = actor.organization_id
@@ -96,6 +95,11 @@ class GroupManager:
                 case _:
                     raise ValueError(f"Unsupported manager type: {group.manager_config.manager_type}")
 
+            if isinstance(group, InternalTemplateGroupCreate):
+                new_group.base_template_id = group.base_template_id
+                new_group.template_id = group.template_id
+                new_group.deployment_id = group.deployment_id
+
             self._process_agent_relationship(session=session, group=new_group, agent_ids=group.agent_ids, allow_partial=False)
 
             if group.shared_block_ids:
@@ -105,7 +109,7 @@ class GroupManager:
             return new_group.to_pydantic()
 
     @enforce_types
-    async def create_group_async(self, group: GroupCreate, actor: PydanticUser) -> PydanticGroup:
+    async def create_group_async(self, group: Union[GroupCreate, InternalTemplateGroupCreate], actor: PydanticUser) -> PydanticGroup:
         async with db_registry.async_session() as session:
             new_group = GroupModel()
             new_group.organization_id = actor.organization_id
@@ -141,6 +145,11 @@ class GroupManager:
                 case _:
                     raise ValueError(f"Unsupported manager type: {group.manager_config.manager_type}")
 
+            if isinstance(group, InternalTemplateGroupCreate):
+                new_group.base_template_id = group.base_template_id
+                new_group.template_id = group.template_id
+                new_group.deployment_id = group.deployment_id
+
             await self._process_agent_relationship_async(session=session, group=new_group, agent_ids=group.agent_ids, allow_partial=False)
 
             if group.shared_block_ids:
@@ -264,6 +273,43 @@ class GroupManager:
 
             return messages
 
+    @enforce_types
+    @trace_method
+    async def list_group_messages_async(
+        self,
+        actor: PydanticUser,
+        group_id: Optional[str] = None,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        limit: Optional[int] = 50,
+        use_assistant_message: bool = True,
+        assistant_message_tool_name: str = "send_message",
+        assistant_message_tool_kwarg: str = "message",
+    ) -> list[LettaMessage]:
+        async with db_registry.async_session() as session:
+            filters = {
+                "organization_id": actor.organization_id,
+                "group_id": group_id,
+            }
+            messages = await MessageModel.list_async(
+                db_session=session,
+                before=before,
+                after=after,
+                limit=limit,
+                **filters,
+            )
+
+            messages = PydanticMessage.to_letta_messages_from_list(
+                messages=[msg.to_pydantic() for msg in messages],
+                use_assistant_message=use_assistant_message,
+                assistant_message_tool_name=assistant_message_tool_name,
+                assistant_message_tool_kwarg=assistant_message_tool_kwarg,
+            )
+
+            # TODO: filter messages to return a clean conversation history
+
+            return messages
+
     @enforce_types
     @trace_method
     def reset_messages(self, group_id: str, actor: PydanticUser) -> None:
@@ -278,6 +324,21 @@ class GroupManager:
 
             session.commit()
 
+    @enforce_types
+    @trace_method
+    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
+            group = await GroupModel.read_async(db_session=session, identifier=group_id, actor=actor)
+
+            # Delete all messages in the group
+            delete_stmt = delete(MessageModel).where(
+                MessageModel.organization_id == actor.organization_id, MessageModel.group_id == group_id
+            )
+            await session.execute(delete_stmt)
+
+            await session.commit()
+
     @enforce_types
     @trace_method
     def bump_turns_counter(self, group_id: str, actor: PydanticUser) -> int:
@@ -332,15 +393,15 @@ class GroupManager:
             return prev_last_processed_message_id
 
     @enforce_types
-    def size(
+    async def size(
         self,
         actor: PydanticUser,
     ) -> int:
         """
         Get the total count of groups for the given user.
         """
-        with db_registry.session() as session:
-            return GroupModel.size(db_session=session, actor=actor)
+        async with db_registry.async_session() as session:
+            return await GroupModel.size_async(db_session=session, actor=actor)
 
     def _process_agent_relationship(self, session: Session, group: GroupModel, agent_ids: List[str], allow_partial=False, replace=True):
         if not agent_ids:

letta/services/helpers/agent_manager_helper.py

@@ -1,4 +1,3 @@
-import os
 import uuid
 from datetime import datetime
 from typing import List, Literal, Optional, Set
@@ -465,7 +464,6 @@ def package_initial_message_sequence(
     # create the agent object
     init_messages = []
     for message_create in initial_message_sequence:
-
         if message_create.role == MessageRole.user:
             packed_message = system.package_user_message(
                 user_message=message_create.content,
@@ -499,8 +497,10 @@ def package_initial_message_sequence(
             import json
             import uuid
 
-            from openai.types.chat.chat_completion_message_tool_call import ChatCompletionMessageToolCall as OpenAIToolCall
-            from openai.types.chat.chat_completion_message_tool_call import Function as OpenAIFunction
+            from openai.types.chat.chat_completion_message_tool_call import (
+                ChatCompletionMessageToolCall as OpenAIToolCall,
+                Function as OpenAIFunction,
+            )
 
             from letta.constants import DEFAULT_MESSAGE_TOOL
 
@@ -1208,7 +1208,7 @@ def calculate_base_tools(is_v2: bool) -> Set[str]:
 
 def calculate_multi_agent_tools() -> Set[str]:
     """Calculate multi-agent tools, excluding local-only tools in production environment."""
-    if os.getenv("LETTA_ENVIRONMENT") == "PRODUCTION":
+    if settings.environment == "PRODUCTION":
         return set(MULTI_AGENT_TOOLS) - set(LOCAL_ONLY_MULTI_AGENT_TOOLS)
     else:
         return set(MULTI_AGENT_TOOLS)

letta/services/identity_manager.py

@@ -9,8 +9,14 @@ from letta.orm.block import Block as BlockModel
 from letta.orm.errors import UniqueConstraintViolationError
 from letta.orm.identity import Identity as IdentityModel
 from letta.otel.tracing import trace_method
-from letta.schemas.identity import Identity as PydanticIdentity
-from letta.schemas.identity import IdentityCreate, IdentityProperty, IdentityType, IdentityUpdate, IdentityUpsert
+from letta.schemas.identity import (
+    Identity as PydanticIdentity,
+    IdentityCreate,
+    IdentityProperty,
+    IdentityType,
+    IdentityUpdate,
+    IdentityUpsert,
+)
 from letta.schemas.user import User as PydanticUser
 from letta.server.db import db_registry
 from letta.settings import DatabaseChoice, settings
@@ -18,7 +24,6 @@ from letta.utils import enforce_types
 
 
 class IdentityManager:
-
     @enforce_types
     @trace_method
     async def list_identities_async(

letta/services/job_manager.py

@@ -1,4 +1,3 @@
-from datetime import datetime
 from functools import partial, reduce
 from operator import add
 from typing import List, Literal, Optional, Union
@@ -14,13 +13,10 @@ from letta.orm.job import Job as JobModel
 from letta.orm.job_messages import JobMessage
 from letta.orm.message import Message as MessageModel
 from letta.orm.sqlalchemy_base import AccessType
-from letta.orm.step import Step
-from letta.orm.step import Step as StepModel
+from letta.orm.step import Step, Step as StepModel
 from letta.otel.tracing import log_event, trace_method
 from letta.schemas.enums import JobStatus, JobType, MessageRole
-from letta.schemas.job import BatchJob as PydanticBatchJob
-from letta.schemas.job import Job as PydanticJob
-from letta.schemas.job import JobUpdate, LettaRequestConfig
+from letta.schemas.job import BatchJob as PydanticBatchJob, Job as PydanticJob, JobUpdate, LettaRequestConfig
 from letta.schemas.letta_message import LettaMessage
 from letta.schemas.message import Message as PydanticMessage
 from letta.schemas.run import Run as PydanticRun
@@ -28,7 +24,6 @@ from letta.schemas.step import Step as PydanticStep
 from letta.schemas.usage import LettaUsageStatistics
 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
 
 logger = get_logger(__name__)
@@ -337,11 +332,7 @@ class JobManager:
                 conditions = []
                 if before_obj:
                     # records before this cursor (older)
-
                     before_timestamp = before_obj.created_at
-                    # SQLite does not support as granular timestamping, so we need to round the timestamp
-                    if settings.database_engine is DatabaseChoice.SQLITE and isinstance(before_timestamp, datetime):
-                        before_timestamp = before_timestamp.strftime("%Y-%m-%d %H:%M:%S")
 
                     conditions.append(
                         or_(
@@ -353,9 +344,6 @@ class JobManager:
                 if after_obj:
                     # records after this cursor (newer)
                     after_timestamp = after_obj.created_at
-                    # SQLite does not support as granular timestamping, so we need to round the timestamp
-                    if settings.database_engine is DatabaseChoice.SQLITE and isinstance(after_timestamp, datetime):
-                        after_timestamp = after_timestamp.strftime("%Y-%m-%d %H:%M:%S")
 
                     conditions.append(
                         or_(JobModel.created_at > after_timestamp, and_(JobModel.created_at == after_timestamp, JobModel.id > after_obj.id))

letta/services/llm_batch_manager.py

@@ -11,9 +11,7 @@ from letta.orm.llm_batch_items import LLMBatchItem
 from letta.orm.llm_batch_job import LLMBatchJob
 from letta.otel.tracing import trace_method
 from letta.schemas.enums import AgentStepStatus, JobStatus, ProviderType
-from letta.schemas.llm_batch_job import AgentStepState
-from letta.schemas.llm_batch_job import LLMBatchItem as PydanticLLMBatchItem
-from letta.schemas.llm_batch_job import LLMBatchJob as PydanticLLMBatchJob
+from letta.schemas.llm_batch_job import AgentStepState, LLMBatchItem as PydanticLLMBatchItem, LLMBatchJob as PydanticLLMBatchJob
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.message import Message as PydanticMessage
 from letta.schemas.user import User as PydanticUser

letta/services/mcp/base_client.py

@@ -1,8 +1,7 @@
 from contextlib import AsyncExitStack
 from typing import Optional, Tuple
 
-from mcp import ClientSession
-from mcp import Tool as MCPTool
+from mcp import ClientSession, Tool as MCPTool
 from mcp.client.auth import OAuthClientProvider
 from mcp.types import TextContent
 

letta/services/mcp_manager.py

@@ -33,8 +33,7 @@ from letta.schemas.mcp import (
     UpdateStdioMCPServer,
     UpdateStreamableHTTPMCPServer,
 )
-from letta.schemas.tool import Tool as PydanticTool
-from letta.schemas.tool import ToolCreate
+from letta.schemas.tool import Tool as PydanticTool, ToolCreate
 from letta.schemas.user import User as PydanticUser
 from letta.server.db import db_registry
 from letta.services.mcp.sse_client import MCP_CONFIG_TOPLEVEL_KEY, AsyncSSEMCPClient
@@ -137,8 +136,7 @@ class MCPManager:
                 if mcp_tool.health:
                     if mcp_tool.health.status == "INVALID":
                         raise ValueError(
-                            f"Tool {mcp_tool_name} cannot be attached, JSON schema is invalid."
-                            f"Reasons: {', '.join(mcp_tool.health.reasons)}"
+                            f"Tool {mcp_tool_name} cannot be attached, JSON schema is invalid.Reasons: {', '.join(mcp_tool.health.reasons)}"
                         )
 
                 tool_create = ToolCreate.from_mcp(mcp_server_name=mcp_server_name, mcp_tool=mcp_tool)
@@ -305,7 +303,9 @@ class MCPManager:
 
         async with db_registry.async_session() as session:
             mcp_servers = await MCPServerModel.list_async(
-                db_session=session, organization_id=actor.organization_id, id=mcp_server_ids  # This will use the IN operator
+                db_session=session,
+                organization_id=actor.organization_id,
+                id=mcp_server_ids,  # This will use the IN operator
             )
             return [mcp_server.to_pydantic() for mcp_server in mcp_servers]
 
@@ -407,7 +407,6 @@ class MCPManager:
                 # with the value being the schema from StdioServerParameters
                 if MCP_CONFIG_TOPLEVEL_KEY in mcp_config:
                     for server_name, server_params_raw in mcp_config[MCP_CONFIG_TOPLEVEL_KEY].items():
-
                         # No support for duplicate server names
                         if server_name in mcp_server_list:
                             # Duplicate server names are configuration issues, not system errors