letta-nightly 0.9.0.dev20250725104508__py3-none-any.whl → 0.9.1.dev20250727063635__py3-none-any.whl

letta/services/mcp_manager.py

@@ -1,15 +1,29 @@
 import json
 import os
+import secrets
+import uuid
+from datetime import datetime, timedelta
 from typing import Any, Dict, List, Optional, Tuple, Union
 
+from fastapi import HTTPException
 from sqlalchemy import null
 
 import letta.constants as constants
 from letta.functions.mcp_client.types import MCPServerType, MCPTool, SSEServerConfig, StdioServerConfig, StreamableHTTPServerConfig
 from letta.log import get_logger
 from letta.orm.errors import NoResultFound
+from letta.orm.mcp_oauth import MCPOAuth, OAuthSessionStatus
 from letta.orm.mcp_server import MCPServer as MCPServerModel
-from letta.schemas.mcp import MCPServer, UpdateMCPServer, UpdateSSEMCPServer, UpdateStdioMCPServer, UpdateStreamableHTTPMCPServer
+from letta.schemas.mcp import (
+    MCPOAuthSession,
+    MCPOAuthSessionCreate,
+    MCPOAuthSessionUpdate,
+    MCPServer,
+    UpdateMCPServer,
+    UpdateSSEMCPServer,
+    UpdateStdioMCPServer,
+    UpdateStreamableHTTPMCPServer,
+)
 from letta.schemas.tool import Tool as PydanticTool
 from letta.schemas.tool import ToolCreate
 from letta.schemas.user import User as PydanticUser
@@ -34,27 +48,21 @@ class MCPManager:
     @enforce_types
     async def list_mcp_server_tools(self, mcp_server_name: str, actor: PydanticUser) -> List[MCPTool]:
         """Get a list of all tools for a specific MCP server."""
-        mcp_server_id = await self.get_mcp_server_id_by_name(mcp_server_name, actor=actor)
-        mcp_config = await self.get_mcp_server_by_id_async(mcp_server_id, actor=actor)
-        server_config = mcp_config.to_config()
-
-        if mcp_config.server_type == MCPServerType.SSE:
-            mcp_client = AsyncSSEMCPClient(server_config=server_config)
-        elif mcp_config.server_type == MCPServerType.STDIO:
-            mcp_client = AsyncStdioMCPClient(server_config=server_config)
-        elif mcp_config.server_type == MCPServerType.STREAMABLE_HTTP:
-            mcp_client = AsyncStreamableHTTPMCPClient(server_config=server_config)
-        else:
-            raise ValueError(f"Unsupported MCP server type: {mcp_config.server_type}")
-        await mcp_client.connect_to_server()
-
-        # list tools
-        tools = await mcp_client.list_tools()
-
-        # TODO: change to pydantic tools
-        await mcp_client.cleanup()
-
-        return tools
+        try:
+            mcp_server_id = await self.get_mcp_server_id_by_name(mcp_server_name, actor=actor)
+            mcp_config = await self.get_mcp_server_by_id_async(mcp_server_id, actor=actor)
+            server_config = mcp_config.to_config()
+            mcp_client = await self.get_mcp_client(server_config, actor)
+            await mcp_client.connect_to_server()
+
+            # list tools
+            tools = await mcp_client.list_tools()
+            return tools
+        except Exception as e:
+            logger.error(f"Error listing tools for MCP server {mcp_server_name}: {e}")
+            return []
+        finally:
+            await mcp_client.cleanup()
 
     @enforce_types
     async def execute_mcp_server_tool(
@@ -72,38 +80,37 @@ class MCPManager:
             # read from config file
             mcp_config = self.read_mcp_config()
             if mcp_server_name not in mcp_config:
-                print("MCP server not found in config.", mcp_config)
                 raise ValueError(f"MCP server {mcp_server_name} not found in config.")
             server_config = mcp_config[mcp_server_name]
 
-        if isinstance(server_config, SSEServerConfig):
-            # mcp_client = AsyncSSEMCPClient(server_config=server_config)
-            async with AsyncSSEMCPClient(server_config=server_config) as mcp_client:
-                result, success = await mcp_client.execute_tool(tool_name, tool_args)
-                logger.info(f"MCP Result: {result}, Success: {success}")
-                return result, success
-        elif isinstance(server_config, StdioServerConfig):
-            async with AsyncStdioMCPClient(server_config=server_config) as mcp_client:
-                result, success = await mcp_client.execute_tool(tool_name, tool_args)
-                logger.info(f"MCP Result: {result}, Success: {success}")
-                return result, success
-        elif isinstance(server_config, StreamableHTTPServerConfig):
-            async with AsyncStreamableHTTPMCPClient(server_config=server_config) as mcp_client:
-                result, success = await mcp_client.execute_tool(tool_name, tool_args)
-                logger.info(f"MCP Result: {result}, Success: {success}")
-                return result, success
-        else:
-            raise ValueError(f"Unsupported server config type: {type(server_config)}")
+        mcp_client = await self.get_mcp_client(server_config, actor)
+        await mcp_client.connect_to_server()
+
+        # call tool
+        result, success = await mcp_client.execute_tool(tool_name, tool_args)
+        logger.info(f"MCP Result: {result}, Success: {success}")
+        # TODO: change to pydantic tool
+
+        await mcp_client.cleanup()
+
+        return result, success
 
     @enforce_types
     async def add_tool_from_mcp_server(self, mcp_server_name: str, mcp_tool_name: str, actor: PydanticUser) -> PydanticTool:
         """Add a tool from an MCP server to the Letta tool registry."""
+        # get the MCP server ID, we should migrate to use the server_id instead of the name
+        mcp_server_id = await self.get_mcp_server_id_by_name(mcp_server_name, actor=actor)
+        if not mcp_server_id:
+            raise ValueError(f"MCP server '{mcp_server_name}' not found")
+
         mcp_tools = await self.list_mcp_server_tools(mcp_server_name, actor=actor)
 
         for mcp_tool in mcp_tools:
             if mcp_tool.name == mcp_tool_name:
                 tool_create = ToolCreate.from_mcp(mcp_server_name=mcp_server_name, mcp_tool=mcp_tool)
-                return await self.tool_manager.create_mcp_tool_async(tool_create=tool_create, mcp_server_name=mcp_server_name, actor=actor)
+                return await self.tool_manager.create_mcp_tool_async(
+                    tool_create=tool_create, mcp_server_name=mcp_server_name, mcp_server_id=mcp_server_id, actor=actor
+                )
 
         # failed to add - handle error?
         return None
@@ -223,6 +230,18 @@ class MCPManager:
             # Convert the SQLAlchemy Tool object to PydanticTool
             return mcp_server.to_pydantic()
 
+    @enforce_types
+    async def get_mcp_servers_by_ids(self, mcp_server_ids: List[str], actor: PydanticUser) -> List[MCPServer]:
+        """Fetch multiple MCP servers by their IDs in a single query."""
+        if not mcp_server_ids:
+            return []
+
+        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
+            )
+            return [mcp_server.to_pydantic() for mcp_server in mcp_servers]
+
     @enforce_types
     async def get_mcp_server(self, mcp_server_name: str, actor: PydanticUser) -> PydanticTool:
         """Get a tool by name."""
@@ -319,3 +338,246 @@ class MCPManager:
                                 logger.error(f"Failed to parse server params for MCP server {server_name} (skipping): {e}")
                                 continue
         return mcp_server_list
+
+    async def get_mcp_client(
+        self,
+        server_config: Union[SSEServerConfig, StdioServerConfig, StreamableHTTPServerConfig],
+        actor: PydanticUser,
+        oauth_provider: Optional[Any] = None,
+    ) -> Union[AsyncSSEMCPClient, AsyncStdioMCPClient, AsyncStreamableHTTPMCPClient]:
+        """
+        Helper function to create the appropriate MCP client based on server configuration.
+
+        Args:
+            server_config: The server configuration object
+            actor: The user making the request
+            oauth_provider: Optional OAuth provider for authentication
+
+        Returns:
+            The appropriate MCP client instance
+
+        Raises:
+            ValueError: If server config type is not supported
+        """
+        # If no OAuth provider is provided, check if we have stored OAuth credentials
+        if oauth_provider is None and hasattr(server_config, "server_url"):
+            oauth_session = await self.get_oauth_session_by_server(server_config.server_url, actor)
+            if oauth_session and oauth_session.access_token:
+                # Create OAuth provider from stored credentials
+                from letta.services.mcp.oauth_utils import create_oauth_provider
+
+                oauth_provider = await create_oauth_provider(
+                    session_id=oauth_session.id,
+                    server_url=oauth_session.server_url,
+                    redirect_uri=oauth_session.redirect_uri,
+                    mcp_manager=self,
+                    actor=actor,
+                )
+
+        if server_config.type == MCPServerType.SSE:
+            server_config = SSEServerConfig(**server_config.model_dump())
+            return AsyncSSEMCPClient(server_config=server_config, oauth_provider=oauth_provider)
+        elif server_config.type == MCPServerType.STDIO:
+            server_config = StdioServerConfig(**server_config.model_dump())
+            return AsyncStdioMCPClient(server_config=server_config, oauth_provider=oauth_provider)
+        elif server_config.type == MCPServerType.STREAMABLE_HTTP:
+            server_config = StreamableHTTPServerConfig(**server_config.model_dump())
+            return AsyncStreamableHTTPMCPClient(server_config=server_config, oauth_provider=oauth_provider)
+        else:
+            raise ValueError(f"Unsupported server config type: {type(server_config)}")
+
+    # OAuth-related methods
+    @enforce_types
+    async def create_oauth_session(self, session_create: MCPOAuthSessionCreate, actor: PydanticUser) -> MCPOAuthSession:
+        """Create a new OAuth session for MCP server authentication."""
+        async with db_registry.async_session() as session:
+            # Create the OAuth session with a unique state
+            oauth_session = MCPOAuth(
+                id="mcp-oauth-" + str(uuid.uuid4())[:8],
+                state=secrets.token_urlsafe(32),
+                server_url=session_create.server_url,
+                server_name=session_create.server_name,
+                user_id=session_create.user_id,
+                organization_id=session_create.organization_id,
+                status=OAuthSessionStatus.PENDING,
+                created_at=datetime.now(),
+                updated_at=datetime.now(),
+            )
+            oauth_session = await oauth_session.create_async(session, actor=actor)
+
+            # Convert to Pydantic model
+            return MCPOAuthSession(
+                id=oauth_session.id,
+                state=oauth_session.state,
+                server_url=oauth_session.server_url,
+                server_name=oauth_session.server_name,
+                user_id=oauth_session.user_id,
+                organization_id=oauth_session.organization_id,
+                status=oauth_session.status,
+                created_at=oauth_session.created_at,
+                updated_at=oauth_session.updated_at,
+            )
+
+    @enforce_types
+    async def get_oauth_session_by_id(self, session_id: str, actor: PydanticUser) -> Optional[MCPOAuthSession]:
+        """Get an OAuth session by its ID."""
+        async with db_registry.async_session() as session:
+            try:
+                oauth_session = await MCPOAuth.read_async(db_session=session, identifier=session_id, actor=actor)
+                return MCPOAuthSession(
+                    id=oauth_session.id,
+                    state=oauth_session.state,
+                    server_url=oauth_session.server_url,
+                    server_name=oauth_session.server_name,
+                    user_id=oauth_session.user_id,
+                    organization_id=oauth_session.organization_id,
+                    authorization_url=oauth_session.authorization_url,
+                    authorization_code=oauth_session.authorization_code,
+                    access_token=oauth_session.access_token,
+                    refresh_token=oauth_session.refresh_token,
+                    token_type=oauth_session.token_type,
+                    expires_at=oauth_session.expires_at,
+                    scope=oauth_session.scope,
+                    client_id=oauth_session.client_id,
+                    client_secret=oauth_session.client_secret,
+                    redirect_uri=oauth_session.redirect_uri,
+                    status=oauth_session.status,
+                    created_at=oauth_session.created_at,
+                    updated_at=oauth_session.updated_at,
+                )
+            except NoResultFound:
+                return None
+
+    @enforce_types
+    async def get_oauth_session_by_server(self, server_url: str, actor: PydanticUser) -> Optional[MCPOAuthSession]:
+        """Get the latest OAuth session by server URL, organization, and user."""
+        from sqlalchemy import desc, select
+
+        async with db_registry.async_session() as session:
+            # Query for OAuth session matching organization, user, server URL, and status
+            # Order by updated_at desc to get the most recent record
+            result = await session.execute(
+                select(MCPOAuth)
+                .where(
+                    MCPOAuth.organization_id == actor.organization_id,
+                    MCPOAuth.user_id == actor.id,
+                    MCPOAuth.server_url == server_url,
+                    MCPOAuth.status == OAuthSessionStatus.AUTHORIZED,
+                )
+                .order_by(desc(MCPOAuth.updated_at))
+                .limit(1)
+            )
+            oauth_session = result.scalar_one_or_none()
+
+            if not oauth_session:
+                return None
+
+            return MCPOAuthSession(
+                id=oauth_session.id,
+                state=oauth_session.state,
+                server_url=oauth_session.server_url,
+                server_name=oauth_session.server_name,
+                user_id=oauth_session.user_id,
+                organization_id=oauth_session.organization_id,
+                authorization_url=oauth_session.authorization_url,
+                authorization_code=oauth_session.authorization_code,
+                access_token=oauth_session.access_token,
+                refresh_token=oauth_session.refresh_token,
+                token_type=oauth_session.token_type,
+                expires_at=oauth_session.expires_at,
+                scope=oauth_session.scope,
+                client_id=oauth_session.client_id,
+                client_secret=oauth_session.client_secret,
+                redirect_uri=oauth_session.redirect_uri,
+                status=oauth_session.status,
+                created_at=oauth_session.created_at,
+                updated_at=oauth_session.updated_at,
+            )
+
+    @enforce_types
+    async def update_oauth_session(self, session_id: str, session_update: MCPOAuthSessionUpdate, actor: PydanticUser) -> MCPOAuthSession:
+        """Update an existing OAuth session."""
+        async with db_registry.async_session() as session:
+            oauth_session = await MCPOAuth.read_async(db_session=session, identifier=session_id, actor=actor)
+
+            # Update fields that are provided
+            if session_update.authorization_url is not None:
+                oauth_session.authorization_url = session_update.authorization_url
+            if session_update.authorization_code is not None:
+                oauth_session.authorization_code = session_update.authorization_code
+            if session_update.access_token is not None:
+                oauth_session.access_token = session_update.access_token
+            if session_update.refresh_token is not None:
+                oauth_session.refresh_token = session_update.refresh_token
+            if session_update.token_type is not None:
+                oauth_session.token_type = session_update.token_type
+            if session_update.expires_at is not None:
+                oauth_session.expires_at = session_update.expires_at
+            if session_update.scope is not None:
+                oauth_session.scope = session_update.scope
+            if session_update.client_id is not None:
+                oauth_session.client_id = session_update.client_id
+            if session_update.client_secret is not None:
+                oauth_session.client_secret = session_update.client_secret
+            if session_update.redirect_uri is not None:
+                oauth_session.redirect_uri = session_update.redirect_uri
+            if session_update.status is not None:
+                oauth_session.status = session_update.status
+
+            # Always update the updated_at timestamp
+            oauth_session.updated_at = datetime.now()
+
+            oauth_session = await oauth_session.update_async(db_session=session, actor=actor)
+
+            return MCPOAuthSession(
+                id=oauth_session.id,
+                state=oauth_session.state,
+                server_url=oauth_session.server_url,
+                server_name=oauth_session.server_name,
+                user_id=oauth_session.user_id,
+                organization_id=oauth_session.organization_id,
+                authorization_url=oauth_session.authorization_url,
+                authorization_code=oauth_session.authorization_code,
+                access_token=oauth_session.access_token,
+                refresh_token=oauth_session.refresh_token,
+                token_type=oauth_session.token_type,
+                expires_at=oauth_session.expires_at,
+                scope=oauth_session.scope,
+                client_id=oauth_session.client_id,
+                client_secret=oauth_session.client_secret,
+                redirect_uri=oauth_session.redirect_uri,
+                status=oauth_session.status,
+                created_at=oauth_session.created_at,
+                updated_at=oauth_session.updated_at,
+            )
+
+    @enforce_types
+    async def delete_oauth_session(self, session_id: str, actor: PydanticUser) -> None:
+        """Delete an OAuth session."""
+        async with db_registry.async_session() as session:
+            try:
+                oauth_session = await MCPOAuth.read_async(db_session=session, identifier=session_id, actor=actor)
+                await oauth_session.hard_delete_async(db_session=session, actor=actor)
+            except NoResultFound:
+                raise ValueError(f"OAuth session with id {session_id} not found.")
+
+    @enforce_types
+    async def cleanup_expired_oauth_sessions(self, max_age_hours: int = 24) -> int:
+        """Clean up expired OAuth sessions and return the count of deleted sessions."""
+        cutoff_time = datetime.now() - timedelta(hours=max_age_hours)
+
+        async with db_registry.async_session() as session:
+            from sqlalchemy import select
+
+            # Find expired sessions
+            result = await session.execute(select(MCPOAuth).where(MCPOAuth.created_at < cutoff_time))
+            expired_sessions = result.scalars().all()
+
+            # Delete expired sessions using async ORM method
+            for oauth_session in expired_sessions:
+                await oauth_session.hard_delete_async(db_session=session, actor=None)
+
+            if expired_sessions:
+                logger.info(f"Cleaned up {len(expired_sessions)} expired OAuth sessions")
+
+            return len(expired_sessions)

letta/services/provider_manager.py

@@ -213,12 +213,12 @@ class ProviderManager:
             provider_type=provider_check.provider_type,
             api_key=provider_check.api_key,
             provider_category=ProviderCategory.byok,
-            access_id_key=provider_check.access_id_key,  # This contains the access key ID for Bedrock
+            access_key=provider_check.access_key,  # This contains the access key ID for Bedrock
             region=provider_check.region,
         ).cast_to_subtype()
 
         # TODO: add more string sanity checks here before we hit actual endpoints
         if not provider.api_key:
-            raise ValueError("API key is required")
+            raise ValueError("API key is required!")
 
         await provider.check_api_key()

letta/services/tool_executor/tool_executor.py

@@ -36,7 +36,10 @@ class SandboxToolExecutor(ToolExecutor):
     ) -> ToolExecutionResult:
 
         # Store original memory state
-        orig_memory_str = agent_state.memory.compile() if agent_state else None
+        if agent_state:
+            orig_memory_str = await agent_state.memory.compile_async()
+        else:
+            orig_memory_str = None
 
         try:
             # Prepare function arguments
@@ -58,7 +61,8 @@ class SandboxToolExecutor(ToolExecutor):
 
             # Verify memory integrity
             if agent_state:
-                assert orig_memory_str == agent_state.memory.compile(), "Memory should not be modified in a sandbox tool"
+                new_memory_str = await agent_state.memory.compile_async()
+                assert orig_memory_str == new_memory_str, "Memory should not be modified in a sandbox tool"
 
             # Update agent memory if needed
             if tool_execution_result.agent_state is not None:

letta/services/tool_manager.py

@@ -106,8 +106,10 @@ class ToolManager:
 
     @enforce_types
     @trace_method
-    def create_or_update_mcp_tool(self, tool_create: ToolCreate, mcp_server_name: str, actor: PydanticUser) -> PydanticTool:
-        metadata = {MCP_TOOL_TAG_NAME_PREFIX: {"server_name": mcp_server_name}}
+    def create_or_update_mcp_tool(
+        self, tool_create: ToolCreate, mcp_server_name: str, mcp_server_id: str, actor: PydanticUser
+    ) -> PydanticTool:
+        metadata = {MCP_TOOL_TAG_NAME_PREFIX: {"server_name": mcp_server_name, "server_id": mcp_server_id}}
         return self.create_or_update_tool(
             PydanticTool(
                 tool_type=ToolType.EXTERNAL_MCP, name=tool_create.json_schema["name"], metadata_=metadata, **tool_create.model_dump()
@@ -116,8 +118,10 @@ class ToolManager:
         )
 
     @enforce_types
-    async def create_mcp_tool_async(self, tool_create: ToolCreate, mcp_server_name: str, actor: PydanticUser) -> PydanticTool:
-        metadata = {MCP_TOOL_TAG_NAME_PREFIX: {"server_name": mcp_server_name}}
+    async def create_mcp_tool_async(
+        self, tool_create: ToolCreate, mcp_server_name: str, mcp_server_id: str, actor: PydanticUser
+    ) -> PydanticTool:
+        metadata = {MCP_TOOL_TAG_NAME_PREFIX: {"server_name": mcp_server_name, "server_id": mcp_server_id}}
         return await self.create_or_update_tool_async(
             PydanticTool(
                 tool_type=ToolType.EXTERNAL_MCP, name=tool_create.json_schema["name"], metadata_=metadata, **tool_create.model_dump()

letta/services/tool_sandbox/base.py

@@ -74,12 +74,12 @@ class AsyncToolSandboxBase(ABC):
         """
         raise NotImplementedError
 
-    def generate_execution_script(self, agent_state: Optional[AgentState], wrap_print_with_markers: bool = False) -> str:
+    async def generate_execution_script(self, agent_state: Optional[AgentState], wrap_print_with_markers: bool = False) -> str:
         """
         Generate code to run inside of execution sandbox. Serialize the agent state and arguments, call the tool,
         then base64-encode/pickle the result. Runs a jinja2 template constructing the python file.
         """
-        from letta.templates.template_helper import render_template
+        from letta.templates.template_helper import render_template_async
 
         # Select the appropriate template based on whether the function is async
         TEMPLATE_NAME = "sandbox_code_file_async.py.j2" if self.is_async_function else "sandbox_code_file.py.j2"
@@ -106,7 +106,7 @@ class AsyncToolSandboxBase(ABC):
 
         agent_state_pickle = pickle.dumps(agent_state) if self.inject_agent_state else None
 
-        return render_template(
+        return await render_template_async(
             TEMPLATE_NAME,
             future_import=future_import,
             inject_agent_state=self.inject_agent_state,

letta/services/tool_sandbox/e2b_sandbox.py

@@ -92,7 +92,7 @@ class AsyncToolSandboxE2B(AsyncToolSandboxBase):
         # Finally, get any that are passed explicitly into the `run` function call
         if additional_env_vars:
             env_vars.update(additional_env_vars)
-        code = self.generate_execution_script(agent_state=agent_state)
+        code = await self.generate_execution_script(agent_state=agent_state)
 
         try:
             log_event(

letta/services/tool_sandbox/local_sandbox.py

@@ -99,8 +99,8 @@ class AsyncToolSandboxLocal(AsyncToolSandboxBase):
 
         # Make sure sandbox directory exists
         sandbox_dir = os.path.expanduser(local_configs.sandbox_dir)
-        if not os.path.exists(sandbox_dir) or not os.path.isdir(sandbox_dir):
-            os.makedirs(sandbox_dir)
+        if not await asyncio.to_thread(lambda: os.path.exists(sandbox_dir) and os.path.isdir(sandbox_dir)):
+            await asyncio.to_thread(os.makedirs, sandbox_dir)
 
         # If using a virtual environment, ensure it's prepared in parallel
         venv_preparation_task = None
@@ -109,11 +109,18 @@ class AsyncToolSandboxLocal(AsyncToolSandboxBase):
             venv_preparation_task = asyncio.create_task(self._prepare_venv(local_configs, venv_path, env))
 
         # Generate and write execution script (always with markers, since we rely on stdout)
-        with tempfile.NamedTemporaryFile(mode="w", dir=sandbox_dir, suffix=".py", delete=False) as temp_file:
-            code = self.generate_execution_script(agent_state=agent_state, wrap_print_with_markers=True)
-            temp_file.write(code)
-            temp_file.flush()
-            temp_file_path = temp_file.name
+        code = await self.generate_execution_script(agent_state=agent_state, wrap_print_with_markers=True)
+
+        async def write_temp_file(dir, content):
+            def _write():
+                with tempfile.NamedTemporaryFile(mode="w", dir=dir, suffix=".py", delete=False) as temp_file:
+                    temp_file.write(content)
+                    temp_file.flush()
+                    return temp_file.name
+
+            return await asyncio.to_thread(_write)
+
+        temp_file_path = await write_temp_file(sandbox_dir, code)
 
         try:
             # If we started a venv preparation task, wait for it to complete
@@ -159,14 +166,14 @@ class AsyncToolSandboxLocal(AsyncToolSandboxBase):
             from letta.settings import settings
 
             if not settings.debug:
-                os.remove(temp_file_path)
+                await asyncio.to_thread(os.remove, temp_file_path)
 
     @trace_method
     async def _prepare_venv(self, local_configs, venv_path: str, env: Dict[str, str]):
         """
         Prepare virtual environment asynchronously (in a background thread).
         """
-        if self.force_recreate_venv or not os.path.isdir(venv_path):
+        if self.force_recreate_venv or not await asyncio.to_thread(os.path.isdir, venv_path):
             sandbox_dir = os.path.expanduser(local_configs.sandbox_dir)
             log_event(name="start create_venv_for_local_sandbox", attributes={"venv_path": venv_path})
             await asyncio.to_thread(

letta/settings.py

@@ -242,7 +242,7 @@ class Settings(BaseSettings):
     uvicorn_reload: bool = False
     uvicorn_timeout_keep_alive: int = 5
 
-    use_uvloop: bool = Field(default=True, description="Enable uvloop as asyncio event loop.")
+    use_uvloop: bool = Field(default=False, description="Enable uvloop as asyncio event loop.")
     use_granian: bool = Field(default=False, description="Use Granian for workers")
     sqlalchemy_tracing: bool = False
 
@@ -278,6 +278,10 @@ class Settings(BaseSettings):
     pinecone_agent_index: Optional[str] = "recall"
     upsert_pinecone_indices: bool = False
 
+    # File processing timeout settings
+    file_processing_timeout_minutes: int = 30
+    file_processing_timeout_error_message: str = "File processing timed out after {} minutes. Please try again."
+
     @property
     def letta_pg_uri(self) -> str:
         if self.pg_uri:
@@ -327,6 +331,11 @@ class LogSettings(BaseSettings):
     verbose_telemetry_logging: bool = Field(False)
 
 
+class TelemetrySettings(BaseSettings):
+    model_config = SettingsConfigDict(env_prefix="letta_telemetry_", extra="ignore")
+    profiler: bool | None = Field(False, description="Enable use of the profiler.")
+
+
 # singleton
 settings = Settings(_env_parse_none_str="None")
 test_settings = TestSettings()
@@ -334,3 +343,4 @@ model_settings = ModelSettings()
 tool_settings = ToolSettings()
 summarizer_settings = SummarizerSettings()
 log_settings = LogSettings()
+telemetry_settings = TelemetrySettings()

letta/system.py

@@ -141,7 +141,7 @@ def package_user_message(
     return json_dumps(packaged_message)
 
 
-def package_function_response(was_success, response_string, timezone):
+def package_function_response(was_success: bool, response_string: str, timezone: str | None) -> str:
     formatted_time = get_local_time(timezone=timezone)
     packaged_message = {
         "status": "OK" if was_success else "Failed",

letta/templates/template_helper.py

@@ -1,8 +1,10 @@
 import os
 
-from jinja2 import Environment, FileSystemLoader, StrictUndefined
+from jinja2 import Environment, FileSystemLoader, StrictUndefined, Template
 
 TEMPLATE_DIR = os.path.dirname(__file__)
+
+# Synchronous environment (for backward compatibility)
 jinja_env = Environment(
     loader=FileSystemLoader(TEMPLATE_DIR),
     undefined=StrictUndefined,
@@ -10,7 +12,29 @@ jinja_env = Environment(
     lstrip_blocks=True,
 )
 
+# Async-enabled environment
+jinja_async_env = Environment(
+    loader=FileSystemLoader(TEMPLATE_DIR),
+    undefined=StrictUndefined,
+    trim_blocks=True,
+    lstrip_blocks=True,
+    enable_async=True,  # Enable async support
+)
+
 
 def render_template(template_name: str, **kwargs):
+    """Synchronous template rendering function (kept for backward compatibility)"""
     template = jinja_env.get_template(template_name)
     return template.render(**kwargs)
+
+
+async def render_template_async(template_name: str, **kwargs):
+    """Asynchronous template rendering function that doesn't block the event loop"""
+    template = jinja_async_env.get_template(template_name)
+    return await template.render_async(**kwargs)
+
+
+async def render_string_async(template_string: str, **kwargs):
+    """Asynchronously render a template from a string"""
+    template = Template(template_string, enable_async=True)
+    return await template.render_async(**kwargs)