letta-nightly 0.7.30.dev20250603104343__py3-none-any.whl → 0.8.0.dev20250604201135__py3-none-any.whl

letta/services/tool_manager.py

@@ -1,7 +1,7 @@
 import asyncio
 import importlib
 import warnings
-from typing import List, Optional
+from typing import List, Optional, Union
 
 from letta.constants import (
     BASE_FUNCTION_RETURN_CHAR_LIMIT,
@@ -26,6 +26,7 @@ from letta.schemas.tool import Tool as PydanticTool
 from letta.schemas.tool import ToolCreate, ToolUpdate
 from letta.schemas.user import User as PydanticUser
 from letta.server.db import db_registry
+from letta.services.mcp.types import SSEServerConfig, StdioServerConfig
 from letta.tracing import trace_method
 from letta.utils import enforce_types, printd
 
@@ -90,6 +91,12 @@ class ToolManager:
 
         return tool
 
+    @enforce_types
+    async def create_mcp_server(
+        self, server_config: Union[StdioServerConfig, SSEServerConfig], actor: PydanticUser
+    ) -> List[Union[StdioServerConfig, SSEServerConfig]]:
+        pass
+
     @enforce_types
     @trace_method
     def create_or_update_mcp_tool(self, tool_create: ToolCreate, mcp_server_name: str, actor: PydanticUser) -> PydanticTool:
@@ -101,6 +108,16 @@ class ToolManager:
             actor,
         )
 
+    @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}}
+        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()
+            ),
+            actor,
+        )
+
     @enforce_types
     @trace_method
     def create_or_update_composio_tool(self, tool_create: ToolCreate, actor: PydanticUser) -> PydanticTool:
@@ -108,6 +125,13 @@ class ToolManager:
             PydanticTool(tool_type=ToolType.EXTERNAL_COMPOSIO, name=tool_create.json_schema["name"], **tool_create.model_dump()), actor
         )
 
+    @enforce_types
+    @trace_method
+    async def create_or_update_composio_tool_async(self, tool_create: ToolCreate, actor: PydanticUser) -> PydanticTool:
+        return await self.create_or_update_tool_async(
+            PydanticTool(tool_type=ToolType.EXTERNAL_COMPOSIO, name=tool_create.json_schema["name"], **tool_create.model_dump()), actor
+        )
+
     @enforce_types
     @trace_method
     def create_or_update_langchain_tool(self, tool_create: ToolCreate, actor: PydanticUser) -> PydanticTool:
@@ -145,7 +169,7 @@ class ToolManager:
 
             tool = ToolModel(**tool_data)
             await tool.create_async(session, actor=actor)  # Re-raise other database-related errors
-        return tool.to_pydantic()
+            return tool.to_pydantic()
 
     @enforce_types
     @trace_method
@@ -215,6 +239,7 @@ class ToolManager:
     @trace_method
     async def list_tools_async(self, actor: PydanticUser, after: Optional[str] = None, limit: Optional[int] = 50) -> List[PydanticTool]:
         """List all tools with optional pagination."""
+        tools_to_delete = []
         async with db_registry.async_session() as session:
             tools = await ToolModel.list_async(
                 db_session=session,
@@ -223,23 +248,26 @@ class ToolManager:
                 organization_id=actor.organization_id,
             )
 
-        # Remove any malformed tools
-        results = []
-        for tool in tools:
-            try:
-                pydantic_tool = tool.to_pydantic()
-                results.append(pydantic_tool)
-            except (ValueError, ModuleNotFoundError, AttributeError) as e:
-                logger.warning(f"Deleting malformed tool with id={tool.id} and name={tool.name}, error was:\n{e}")
-                logger.warning("Deleted tool: ")
-                logger.warning(tool.pretty_print_columns())
-                self.delete_tool_by_id(tool.id, actor=actor)
+            # Remove any malformed tools
+            results = []
+            for tool in tools:
+                try:
+                    pydantic_tool = tool.to_pydantic()
+                    results.append(pydantic_tool)
+                except (ValueError, ModuleNotFoundError, AttributeError) as e:
+                    tools_to_delete.append(tool)
+                    logger.warning(f"Deleting malformed tool with id={tool.id} and name={tool.name}, error was:\n{e}")
+                    logger.warning("Deleted tool: ")
+                    logger.warning(tool.pretty_print_columns())
+
+        for tool in tools_to_delete:
+            await self.delete_tool_by_id_async(tool.id, actor=actor)
 
         return results
 
     @enforce_types
     @trace_method
-    def size(
+    async def size_async(
         self,
         actor: PydanticUser,
         include_base_tools: bool,
@@ -249,10 +277,10 @@ class ToolManager:
 
         If include_builtin is True, it will also count the built-in tools.
         """
-        with db_registry.session() as session:
+        async with db_registry.async_session() as session:
             if include_base_tools:
-                return ToolModel.size(db_session=session, actor=actor)
-            return ToolModel.size(db_session=session, actor=actor, name=LETTA_TOOL_SET)
+                return await ToolModel.size_async(db_session=session, actor=actor)
+            return await ToolModel.size_async(db_session=session, actor=actor, name=LETTA_TOOL_SET)
 
     @enforce_types
     @trace_method
@@ -324,6 +352,17 @@ class ToolManager:
             except NoResultFound:
                 raise ValueError(f"Tool with id {tool_id} not found.")
 
+    @enforce_types
+    @trace_method
+    async def delete_tool_by_id_async(self, tool_id: str, actor: PydanticUser) -> None:
+        """Delete a tool by its ID."""
+        async with db_registry.async_session() as session:
+            try:
+                tool = await ToolModel.read_async(db_session=session, identifier=tool_id, actor=actor)
+                await tool.hard_delete_async(db_session=session, actor=actor)
+            except NoResultFound:
+                raise ValueError(f"Tool with id {tool_id} not found.")
+
     @enforce_types
     @trace_method
     def upsert_base_tools(self, actor: PydanticUser) -> List[PydanticTool]:

letta/services/tool_sandbox/base.py

@@ -1,9 +1,7 @@
-import ast
-import base64
 import pickle
 import uuid
 from abc import ABC, abstractmethod
-from typing import Any, Dict, Optional, Tuple
+from typing import Any, Dict, Optional
 
 from letta.functions.helpers import generate_model_from_args_json_schema
 from letta.schemas.agent import AgentState
@@ -11,20 +9,21 @@ from letta.schemas.sandbox_config import SandboxConfig
 from letta.schemas.tool import Tool
 from letta.schemas.tool_execution_result import ToolExecutionResult
 from letta.services.helpers.tool_execution_helper import add_imports_and_pydantic_schemas_for_args
+from letta.services.helpers.tool_parser_helper import convert_param_to_str_value, parse_function_arguments
 from letta.services.sandbox_config_manager import SandboxConfigManager
 from letta.services.tool_manager import ToolManager
+from letta.types import JsonDict, JsonValue
 
 
 class AsyncToolSandboxBase(ABC):
     NAMESPACE = uuid.NAMESPACE_DNS
-    LOCAL_SANDBOX_RESULT_START_MARKER = str(uuid.uuid5(NAMESPACE, "local-sandbox-result-start-marker"))
-    LOCAL_SANDBOX_RESULT_END_MARKER = str(uuid.uuid5(NAMESPACE, "local-sandbox-result-end-marker"))
+    LOCAL_SANDBOX_RESULT_START_MARKER = uuid.uuid5(NAMESPACE, "local-sandbox-result-start-marker").bytes
     LOCAL_SANDBOX_RESULT_VAR_NAME = "result_ZQqiequkcFwRwwGQMqkt"
 
     def __init__(
         self,
         tool_name: str,
-        args: dict,
+        args: JsonDict,
         user,
         tool_object: Optional[Tool] = None,
         sandbox_config: Optional[SandboxConfig] = None,
@@ -48,7 +47,7 @@ class AsyncToolSandboxBase(ABC):
         self._sandbox_config_manager = None
 
         # See if we should inject agent_state or not based on the presence of the "agent_state" arg
-        if "agent_state" in self.parse_function_arguments(self.tool.source_code, self.tool.name):
+        if "agent_state" in parse_function_arguments(self.tool.source_code, self.tool.name):
             self.inject_agent_state = True
         else:
             self.inject_agent_state = False
@@ -74,83 +73,50 @@ class AsyncToolSandboxBase(ABC):
 
     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.
+        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.
         """
-        code = "from typing import *\n"
-        code += "import pickle\n"
-        code += "import sys\n"
-        code += "import base64\n"
+        from letta.templates.template_helper import render_template
 
-        # Additional imports to support agent state
-        if self.inject_agent_state:
-            code += "import letta\n"
-            code += "from letta import * \n"
+        TEMPLATE_NAME = "sandbox_code_file.py.j2"
+
+        future_import = False
+        schema_code = None
 
-        # Add schema code if available
         if self.tool.args_json_schema:
+            # Add schema code if available
             schema_code = add_imports_and_pydantic_schemas_for_args(self.tool.args_json_schema)
             if "from __future__ import annotations" in schema_code:
                 schema_code = schema_code.replace("from __future__ import annotations", "").lstrip()
-                code = "from __future__ import annotations\n\n" + code
-            code += schema_code + "\n"
-
-        # Load the agent state
-        if self.inject_agent_state:
-            agent_state_pickle = pickle.dumps(agent_state)
-            code += f"agent_state = pickle.loads({agent_state_pickle})\n"
-        else:
-            code += "agent_state = None\n"
+                future_import = True
 
-        # Initialize arguments
-        if self.tool.args_json_schema:
+            # Initialize arguments
             args_schema = generate_model_from_args_json_schema(self.tool.args_json_schema)
-            code += f"args_object = {args_schema.__name__}(**{self.args})\n"
+            tool_args = f"args_object = {args_schema.__name__}(**{self.args})\n"
             for param in self.args:
-                code += f"{param} = args_object.{param}\n"
+                tool_args += f"{param} = args_object.{param}\n"
         else:
+            tool_args = ""
             for param in self.args:
-                code += self.initialize_param(param, self.args[param])
-
-        # Insert the tool's source code
-        code += "\n" + self.tool.source_code + "\n"
-
-        # Invoke the function and store the result in a global variable
-        code += (
-            f"{self.LOCAL_SANDBOX_RESULT_VAR_NAME}" + ' = {"results": ' + self.invoke_function_call() + ', "agent_state": agent_state}\n'
-        )
-        code += (
-            f"{self.LOCAL_SANDBOX_RESULT_VAR_NAME} = base64.b64encode("
-            f"pickle.dumps({self.LOCAL_SANDBOX_RESULT_VAR_NAME})"
-            ").decode('utf-8')\n"
+                tool_args += self.initialize_param(param, self.args[param])
+
+        agent_state_pickle = pickle.dumps(agent_state) if self.inject_agent_state else None
+
+        return render_template(
+            TEMPLATE_NAME,
+            future_import=future_import,
+            inject_agent_state=self.inject_agent_state,
+            schema_imports=schema_code,
+            agent_state_pickle=agent_state_pickle,
+            tool_args=tool_args,
+            tool_source_code=self.tool.source_code,
+            local_sandbox_result_var_name=self.LOCAL_SANDBOX_RESULT_VAR_NAME,
+            invoke_function_call=self.invoke_function_call(),
+            wrap_print_with_markers=wrap_print_with_markers,
+            start_marker=self.LOCAL_SANDBOX_RESULT_START_MARKER,
         )
 
-        if wrap_print_with_markers:
-            code += f"sys.stdout.write('{self.LOCAL_SANDBOX_RESULT_START_MARKER}')\n"
-            code += f"sys.stdout.write(str({self.LOCAL_SANDBOX_RESULT_VAR_NAME}))\n"
-            code += f"sys.stdout.write('{self.LOCAL_SANDBOX_RESULT_END_MARKER}')\n"
-        else:
-            code += f"{self.LOCAL_SANDBOX_RESULT_VAR_NAME}\n"
-
-        return code
-
-    def _convert_param_to_value(self, param_type: str, raw_value: str) -> str:
-        """
-        Convert parameter to Python code representation based on JSON schema type.
-        """
-        if param_type == "string":
-            # Safely inject a Python string via pickle
-            value = "pickle.loads(" + str(pickle.dumps(raw_value)) + ")"
-        elif param_type in ["integer", "boolean", "number", "array", "object"]:
-            # This is simplistic. In real usage, ensure correct type-casting or sanitization.
-            value = raw_value
-        else:
-            raise TypeError(f"Unsupported type: {param_type}, raw_value={raw_value}")
-
-        return str(value)
-
-    def initialize_param(self, name: str, raw_value: str) -> str:
+    def initialize_param(self, name: str, raw_value: JsonValue) -> str:
         """
         Produce code for initializing a single parameter in the generated script.
         """
@@ -164,7 +130,7 @@ class AsyncToolSandboxBase(ABC):
         if param_type is None and spec.get("parameters"):
             param_type = spec["parameters"].get("type")
 
-        value = self._convert_param_to_value(param_type, raw_value)
+        value = convert_param_to_str_value(param_type, raw_value)
         return f"{name} = {value}\n"
 
     def invoke_function_call(self) -> str:
@@ -184,24 +150,5 @@ class AsyncToolSandboxBase(ABC):
         func_call_str = self.tool.name + "(" + params + ")"
         return func_call_str
 
-    def parse_best_effort(self, text: str) -> Tuple[Any, Optional[AgentState]]:
-        """
-        Decode and unpickle the result from the function execution if possible.
-        Returns (function_return_value, agent_state).
-        """
-        if not text:
-            return None, None
-
-        result = pickle.loads(base64.b64decode(text))
-        agent_state = result["agent_state"]
-        return result["results"], agent_state
-
-    def parse_function_arguments(self, source_code: str, tool_name: str):
-        """Get arguments of a function from its source code"""
-        tree = ast.parse(source_code)
-        args = []
-        for node in ast.walk(tree):
-            if isinstance(node, ast.FunctionDef) and node.name == tool_name:
-                for arg in node.args.args:
-                    args.append(arg.arg)
-        return args
+    def _update_env_vars(self):
+        pass  # TODO

letta/services/tool_sandbox/e2b_sandbox.py

@@ -1,16 +1,23 @@
-from typing import Any, Dict, Optional
+from typing import TYPE_CHECKING, Any, Dict, Optional
+
+from e2b_code_interpreter import AsyncSandbox
 
 from letta.log import get_logger
 from letta.schemas.agent import AgentState
 from letta.schemas.sandbox_config import SandboxConfig, SandboxType
 from letta.schemas.tool import Tool
 from letta.schemas.tool_execution_result import ToolExecutionResult
+from letta.services.helpers.tool_parser_helper import parse_stdout_best_effort
 from letta.services.tool_sandbox.base import AsyncToolSandboxBase
 from letta.tracing import log_event, trace_method
+from letta.types import JsonDict
 from letta.utils import get_friendly_error_msg
 
 logger = get_logger(__name__)
 
+if TYPE_CHECKING:
+    from e2b_code_interpreter import Execution
+
 
 class AsyncToolSandboxE2B(AsyncToolSandboxBase):
     METADATA_CONFIG_STATE_KEY = "config_state"
@@ -18,9 +25,9 @@ class AsyncToolSandboxE2B(AsyncToolSandboxBase):
     def __init__(
         self,
         tool_name: str,
-        args: dict,
+        args: JsonDict,
         user,
-        force_recreate=True,
+        force_recreate: bool = True,
         tool_object: Optional[Tool] = None,
         sandbox_config: Optional[SandboxConfig] = None,
         sandbox_env_vars: Optional[Dict[str, Any]] = None,
@@ -92,7 +99,7 @@ class AsyncToolSandboxE2B(AsyncToolSandboxBase):
         )
         execution = await e2b_sandbox.run_code(code, envs=env_vars)
         if execution.results:
-            func_return, agent_state = self.parse_best_effort(execution.results[0].text)
+            func_return, agent_state = parse_stdout_best_effort(execution.results[0].text)
             log_event(
                 "e2b_execution_succeeded",
                 {
@@ -138,16 +145,15 @@ class AsyncToolSandboxE2B(AsyncToolSandboxBase):
             sandbox_config_fingerprint=sbx_config.fingerprint(),
         )
 
-    def parse_exception_from_e2b_execution(self, e2b_execution: "Execution") -> Exception:
+    @staticmethod
+    def parse_exception_from_e2b_execution(e2b_execution: "Execution") -> Exception:
         builtins_dict = __builtins__ if isinstance(__builtins__, dict) else vars(__builtins__)
         # Dynamically fetch the exception class from builtins, defaulting to Exception if not found
         exception_class = builtins_dict.get(e2b_execution.error.name, Exception)
         return exception_class(e2b_execution.error.value)
 
     @trace_method
-    async def create_e2b_sandbox_with_metadata_hash(self, sandbox_config: SandboxConfig) -> "Sandbox":
-        from e2b_code_interpreter import AsyncSandbox
-
+    async def create_e2b_sandbox_with_metadata_hash(self, sandbox_config: SandboxConfig) -> "AsyncSandbox":
         state_hash = sandbox_config.fingerprint()
         e2b_config = sandbox_config.get_e2b_config()
 
@@ -194,8 +200,7 @@ class AsyncToolSandboxE2B(AsyncToolSandboxBase):
 
         return sbx
 
-    async def list_running_e2b_sandboxes(self):
-        from e2b_code_interpreter import AsyncSandbox
-
+    @staticmethod
+    async def list_running_e2b_sandboxes():
         # List running sandboxes and access metadata.
         return await AsyncSandbox.list()

letta/services/tool_sandbox/local_sandbox.py

@@ -1,8 +1,12 @@
 import asyncio
+import hashlib
 import os
+import struct
 import sys
 import tempfile
-from typing import Any, Dict, Optional, Tuple
+from typing import Any, Dict, Optional
+
+from pydantic.config import JsonDict
 
 from letta.schemas.agent import AgentState
 from letta.schemas.sandbox_config import SandboxConfig, SandboxType
@@ -13,10 +17,11 @@ from letta.services.helpers.tool_execution_helper import (
     find_python_executable,
     install_pip_requirements_for_sandbox,
 )
+from letta.services.helpers.tool_parser_helper import parse_stdout_best_effort
 from letta.services.tool_sandbox.base import AsyncToolSandboxBase
 from letta.settings import tool_settings
 from letta.tracing import log_event, trace_method
-from letta.utils import get_friendly_error_msg
+from letta.utils import get_friendly_error_msg, parse_stderr_error_msg
 
 
 class AsyncToolSandboxLocal(AsyncToolSandboxBase):
@@ -26,7 +31,7 @@ class AsyncToolSandboxLocal(AsyncToolSandboxBase):
     def __init__(
         self,
         tool_name: str,
-        args: dict,
+        args: JsonDict,
         user,
         force_recreate_venv=False,
         tool_object: Optional[Tool] = None,
@@ -123,7 +128,15 @@ class AsyncToolSandboxLocal(AsyncToolSandboxBase):
                 # If not using venv, use whatever Python we are running on
                 python_executable = sys.executable
 
-            exec_env["PYTHONWARNINGS"] = "ignore"
+            # handle unwanted terminal behavior
+            exec_env.update(
+                {
+                    "PYTHONWARNINGS": "ignore",
+                    "NO_COLOR": "1",
+                    "TERM": "dumb",
+                    "PYTHONUNBUFFERED": "1",
+                }
+            )
 
             # Execute in subprocess
             return await self._execute_tool_subprocess(
@@ -170,6 +183,7 @@ class AsyncToolSandboxLocal(AsyncToolSandboxBase):
         Execute user code in a subprocess, always capturing stdout and stderr.
         We parse special markers to extract the pickled result string.
         """
+        stdout_text = ""
         try:
             log_event(name="start subprocess")
 
@@ -190,13 +204,20 @@ class AsyncToolSandboxLocal(AsyncToolSandboxBase):
 
                 raise TimeoutError(f"Executing tool {self.tool_name} timed out after 60 seconds.")
 
-            stdout = stdout_bytes.decode("utf-8") if stdout_bytes else ""
             stderr = stderr_bytes.decode("utf-8") if stderr_bytes else ""
             log_event(name="finish subprocess")
 
             # Parse markers to isolate the function result
-            func_result, stdout_text = self.parse_out_function_results_markers(stdout)
-            func_return, agent_state = self.parse_best_effort(func_result)
+            func_result_bytes, stdout_text = self.parse_out_function_results_markers(stdout_bytes)
+            func_return, agent_state = parse_stdout_best_effort(func_result_bytes)
+
+            if process.returncode != 0 and func_return is None:
+                exception_name, msg = parse_stderr_error_msg(stderr)
+                func_return = get_friendly_error_msg(
+                    function_name=self.tool_name,
+                    exception_name=exception_name,
+                    exception_message=msg,
+                )
 
             return ToolExecutionResult(
                 func_return=func_return,
@@ -213,6 +234,8 @@ class AsyncToolSandboxLocal(AsyncToolSandboxBase):
                 raise e
 
             print(f"Subprocess execution for tool {self.tool_name} encountered an error: {e}")
+            print(e.__class__.__name__)
+            print(e.__traceback__)
             func_return = get_friendly_error_msg(
                 function_name=self.tool_name,
                 exception_name=type(e).__name__,
@@ -221,27 +244,32 @@ class AsyncToolSandboxLocal(AsyncToolSandboxBase):
             return ToolExecutionResult(
                 func_return=func_return,
                 agent_state=None,
-                stdout=[],
+                stdout=[stdout_text],
                 stderr=[str(e)],
                 status="error",
                 sandbox_config_fingerprint=sbx_config.fingerprint(),
             )
 
-    def parse_out_function_results_markers(self, text: str) -> Tuple[str, str]:
+    def parse_out_function_results_markers(self, data: bytes) -> tuple[bytes, str]:
         """
         Parse the function results out of the stdout using special markers.
-        Returns (function_result_str, stripped_stdout).
+        Returns (function_results_bytes, stripped_stdout_bytes).
         """
-        if self.LOCAL_SANDBOX_RESULT_START_MARKER not in text:
-            # No markers found, so nothing to parse
-            return "", text
-
-        marker_len = len(self.LOCAL_SANDBOX_RESULT_START_MARKER)
-        start_index = text.index(self.LOCAL_SANDBOX_RESULT_START_MARKER) + marker_len
-        end_index = text.index(self.LOCAL_SANDBOX_RESULT_END_MARKER)
-
-        # The actual pickled base64 is between start_index and end_index
-        results_str = text[start_index:end_index]
-        # The rest of stdout (minus the markers)
-        remainder = text[: start_index - marker_len] + text[end_index + marker_len :]
-        return results_str, remainder
+        pos = data.find(self.LOCAL_SANDBOX_RESULT_START_MARKER)
+        if pos < 0:
+            return b"", data.decode("utf-8") if data else ""
+
+        DATA_LENGTH_INDICATOR = 4
+        CHECKSUM_LENGTH = 32
+        pos_start = pos + len(self.LOCAL_SANDBOX_RESULT_START_MARKER)
+        checksum_start = pos_start + DATA_LENGTH_INDICATOR
+        message_start = checksum_start + CHECKSUM_LENGTH
+
+        message_len = struct.unpack(">I", data[pos_start:checksum_start])[0]
+        checksum = data[checksum_start:message_start]
+        message_data = data[message_start : message_start + message_len]
+        actual_checksum = hashlib.md5(message_data).hexdigest().encode("ascii")
+        if actual_checksum == checksum:
+            remainder = data[:pos] + data[message_start + message_len :]
+            return message_data, (remainder.decode("utf-8") if remainder else "")
+        raise Exception("Function ran, but output is corrupted.")

letta/services/user_manager.py

@@ -1,5 +1,7 @@
 from typing import List, Optional
 
+from sqlalchemy import select, text
+
 from letta.orm.errors import NoResultFound
 from letta.orm.organization import Organization as OrganizationModel
 from letta.orm.user import User as UserModel
@@ -38,6 +40,27 @@ class UserManager:
 
             return user.to_pydantic()
 
+    @enforce_types
+    @trace_method
+    async def create_default_actor_async(self, org_id: str = OrganizationManager.DEFAULT_ORG_ID) -> PydanticUser:
+        """Create the default user."""
+        async with db_registry.async_session() as session:
+            # Make sure the org id exists
+            try:
+                await OrganizationModel.read_async(db_session=session, identifier=org_id)
+            except NoResultFound:
+                raise ValueError(f"No organization with {org_id} exists in the organization table.")
+
+            # Try to retrieve the user
+            try:
+                actor = await UserModel.read_async(db_session=session, identifier=self.DEFAULT_USER_ID)
+            except NoResultFound:
+                # If it doesn't exist, make it
+                actor = UserModel(id=self.DEFAULT_USER_ID, name=self.DEFAULT_USER_NAME, organization_id=org_id)
+                await actor.create_async(session)
+
+            return actor.to_pydantic()
+
     @enforce_types
     @trace_method
     def create_user(self, pydantic_user: PydanticUser) -> PydanticUser:
@@ -123,7 +146,18 @@ class UserManager:
     async def get_actor_by_id_async(self, actor_id: str) -> PydanticUser:
         """Fetch a user by ID asynchronously."""
         async with db_registry.async_session() as session:
-            user = await UserModel.read_async(db_session=session, identifier=actor_id)
+            # Turn off seqscan to force use pk index
+            await session.execute(text("SET LOCAL enable_seqscan = OFF"))
+            try:
+                stmt = select(UserModel).where(UserModel.id == actor_id)
+                result = await session.execute(stmt)
+                user = result.scalar_one_or_none()
+            finally:
+                await session.execute(text("SET LOCAL enable_seqscan = ON"))
+
+            if not user:
+                raise NoResultFound(f"User not found with id={actor_id}")
+
             return user.to_pydantic()
 
     @enforce_types
@@ -154,8 +188,7 @@ class UserManager:
         try:
             return await self.get_actor_by_id_async(self.DEFAULT_USER_ID)
         except NoResultFound:
-            # Fall back to synchronous version since create_default_user isn't async yet
-            return self.create_default_user(org_id=self.DEFAULT_ORG_ID)
+            return await self.create_default_actor_async(org_id=self.DEFAULT_ORG_ID)
 
     @enforce_types
     @trace_method

letta/settings.py

@@ -172,6 +172,10 @@ class Settings(BaseSettings):
     debug: Optional[bool] = False
     cors_origins: Optional[list] = cors_origins
 
+    # default handles
+    default_llm_handle: Optional[str] = None
+    default_embedding_handle: Optional[str] = None
+
     # database configuration
     pg_db: Optional[str] = None
     pg_user: Optional[str] = None
@@ -204,15 +208,15 @@ class Settings(BaseSettings):
     uvicorn_reload: bool = False
     uvicorn_timeout_keep_alive: int = 5
 
+    use_uvloop: bool = False
+    use_granian: bool = False
+
     # event loop parallelism
     event_loop_threadpool_max_workers: int = 43
 
     # experimental toggle
     use_experimental: bool = False
     use_vertex_structured_outputs_experimental: bool = False
-    use_vertex_async_loop_experimental: bool = False
-    experimental_enable_async_db_engine: bool = False
-    experimental_skip_rebuild_memory: bool = False
 
     # LLM provider client settings
     httpx_max_retries: int = 5
@@ -231,6 +235,9 @@ class Settings(BaseSettings):
     batch_job_polling_lookback_weeks: int = 2
     batch_job_polling_batch_size: Optional[int] = None
 
+    # for OCR
+    mistral_api_key: Optional[str] = None
+
     @property
     def letta_pg_uri(self) -> str:
         if self.pg_uri: