letta-nightly 0.11.7.dev20251006104136__py3-none-any.whl → 0.11.7.dev20251008104128__py3-none-any.whl

letta/server/server.py

@@ -10,19 +10,16 @@ from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 
 import httpx
 from anthropic import AsyncAnthropic
-from composio.client import Composio
-from composio.client.collections import ActionModel, AppModel
 from fastapi import HTTPException
 from fastapi.responses import StreamingResponse
 
 import letta.constants as constants
 import letta.server.utils as server_utils
 import letta.system as system
-from letta.agent import Agent, save_agent
 from letta.config import LettaConfig
 from letta.constants import LETTA_TOOL_EXECUTION_DIR
 from letta.data_sources.connectors import DataConnector, load_data
-from letta.errors import HandleNotFoundError
+from letta.errors import HandleNotFoundError, LettaInvalidArgumentError, LettaMCPConnectionError, LettaMCPTimeoutError
 from letta.functions.mcp_client.types import MCPServerType, MCPTool, MCPToolHealth, SSEServerConfig, StdioServerConfig
 from letta.functions.schema_validator import validate_complete_json_schema
 from letta.groups.helpers import load_multi_agent
@@ -68,6 +65,7 @@ from letta.schemas.providers import (
     LMStudioOpenAIProvider,
     OllamaProvider,
     OpenAIProvider,
+    OpenRouterProvider,
     Provider,
     TogetherProvider,
     VLLMProvider,
@@ -100,6 +98,7 @@ from letta.services.message_manager import MessageManager
 from letta.services.organization_manager import OrganizationManager
 from letta.services.passage_manager import PassageManager
 from letta.services.provider_manager import ProviderManager
+from letta.services.run_manager import RunManager
 from letta.services.sandbox_config_manager import SandboxConfigManager
 from letta.services.source_manager import SourceManager
 from letta.services.step_manager import StepManager
@@ -115,65 +114,7 @@ config = LettaConfig.load()
 logger = get_logger(__name__)
 
 
-class Server(object):
-    """Abstract server class that supports multi-agent multi-user"""
-
-    @abstractmethod
-    def list_agents(self, user_id: str) -> dict:
-        """List all available agents to a user"""
-        raise NotImplementedError
-
-    @abstractmethod
-    def get_agent_memory(self, user_id: str, agent_id: str) -> dict:
-        """Return the memory of an agent (core memory + non-core statistics)"""
-        raise NotImplementedError
-
-    @abstractmethod
-    def get_server_config(self, user_id: str) -> dict:
-        """Return the base config"""
-        raise NotImplementedError
-
-    @abstractmethod
-    def update_agent_core_memory(self, user_id: str, agent_id: str, label: str, actor: User) -> Memory:
-        """Update the agents core memory block, return the new state"""
-        raise NotImplementedError
-
-    @abstractmethod
-    def create_agent(
-        self,
-        request: CreateAgent,
-        actor: User,
-        # interface
-        interface: Union[AgentInterface, None] = None,
-    ) -> AgentState:
-        """Create a new agent using a config"""
-        raise NotImplementedError
-
-    @abstractmethod
-    def user_message(self, user_id: str, agent_id: str, message: str) -> None:
-        """Process a message from the user, internally calls step"""
-        raise NotImplementedError
-
-    @abstractmethod
-    def system_message(self, user_id: str, agent_id: str, message: str) -> None:
-        """Process a message from the system, internally calls step"""
-        raise NotImplementedError
-
-    @abstractmethod
-    def send_messages(self, user_id: str, agent_id: str, input_messages: List[MessageCreate]) -> None:
-        """Send a list of messages to the agent"""
-        raise NotImplementedError
-
-    @abstractmethod
-    def run_command(self, user_id: str, agent_id: str, command: str) -> Union[str, None]:
-        """Run a command on the agent, e.g. /memory
-
-        May return a string with a message generated by the command
-        """
-        raise NotImplementedError
-
-
-class SyncServer(Server):
+class SyncServer(object):
     """Simple single-threaded / blocking server process"""
 
     def __init__(
@@ -218,6 +159,7 @@ class SyncServer(Server):
         self.sandbox_config_manager = SandboxConfigManager()
         self.message_manager = MessageManager()
         self.job_manager = JobManager()
+        self.run_manager = RunManager()
         self.agent_manager = AgentManager()
         self.archive_manager = ArchiveManager()
         self.provider_manager = ProviderManager()
@@ -246,58 +188,17 @@ class SyncServer(Server):
         limits = httpx.Limits(max_connections=100, max_keepalive_connections=80, keepalive_expiry=300)
         self.httpx_client = httpx.AsyncClient(timeout=timeout, follow_redirects=True, limits=limits)
 
-        # Make default user and org
-        if init_with_default_org_and_user:
-            self.default_org = self.organization_manager.create_default_organization()
-            self.default_user = self.user_manager.create_default_user()
-            self.tool_manager.upsert_base_tools(actor=self.default_user)
-
-            # Add composio keys to the tool sandbox env vars of the org
-            if tool_settings.composio_api_key:
-                manager = SandboxConfigManager()
-                sandbox_config = manager.get_or_create_default_sandbox_config(sandbox_type=SandboxType.LOCAL, actor=self.default_user)
-
-                manager.create_sandbox_env_var(
-                    SandboxEnvironmentVariableCreate(key="COMPOSIO_API_KEY", value=tool_settings.composio_api_key),
-                    sandbox_config_id=sandbox_config.id,
-                    actor=self.default_user,
-                )
-
-            # For OSS users, create a local sandbox config
-            oss_default_user = self.user_manager.get_default_user()
-            use_venv = False if not tool_settings.tool_exec_venv_name else True
-            venv_name = tool_settings.tool_exec_venv_name or "venv"
-            tool_dir = tool_settings.tool_exec_dir or LETTA_TOOL_EXECUTION_DIR
-
-            venv_dir = Path(tool_dir) / venv_name
-            tool_path = Path(tool_dir)
-
-            if tool_path.exists() and not tool_path.is_dir():
-                logger.error(f"LETTA_TOOL_SANDBOX_DIR exists but is not a directory: {tool_dir}")
-            else:
-                if not tool_path.exists():
-                    logger.warning(f"LETTA_TOOL_SANDBOX_DIR does not exist, creating now: {tool_dir}")
-                    tool_path.mkdir(parents=True, exist_ok=True)
-
-                if tool_settings.tool_exec_venv_name and not venv_dir.is_dir():
-                    logger.warning(
-                        f"Provided LETTA_TOOL_SANDBOX_VENV_NAME is not a valid venv ({venv_dir}), one will be created for you during tool execution."
-                    )
+        # For MCP
+        # TODO: remove this
+        """Initialize the MCP clients (there may be multiple)"""
+        self.mcp_clients: Dict[str, AsyncBaseMCPClient] = {}
 
-                sandbox_config_create = SandboxConfigCreate(
-                    config=LocalSandboxConfig(sandbox_dir=tool_settings.tool_exec_dir, use_venv=use_venv, venv_name=venv_name)
-                )
-                sandbox_config = self.sandbox_config_manager.create_or_update_sandbox_config(
-                    sandbox_config_create=sandbox_config_create, actor=oss_default_user
-                )
-                logger.info(f"Successfully created default local sandbox config:\n{sandbox_config.get_local_config().model_dump()}")
+        # TODO: Remove these in memory caches
+        self._llm_config_cache = {}
+        self._embedding_config_cache = {}
 
-                if use_venv and tool_settings.tool_exec_autoreload_venv:
-                    prepare_local_sandbox(
-                        sandbox_config.get_local_config(),
-                        env=os.environ.copy(),
-                        force_recreate=True,
-                    )
+        # TODO: Replace this with the Anthropic client we have in house
+        self.anthropic_async_client = AsyncAnthropic()
 
         # collect providers (always has Letta as a default)
         self._enabled_providers: List[Provider] = [LettaProvider(name="letta")]
@@ -375,6 +276,7 @@ class SyncServer(Server):
                     name="vllm",
                     base_url=model_settings.vllm_api_base,
                     default_prompt_formatter=model_settings.default_prompt_formatter,
+                    handle_base=model_settings.vllm_handle_base,
                 )
             )
 
@@ -398,18 +300,58 @@ class SyncServer(Server):
             self._enabled_providers.append(DeepSeekProvider(name="deepseek", api_key=model_settings.deepseek_api_key))
         if model_settings.xai_api_key:
             self._enabled_providers.append(XAIProvider(name="xai", api_key=model_settings.xai_api_key))
+        if model_settings.openrouter_api_key:
+            self._enabled_providers.append(
+                OpenRouterProvider(
+                    name="openrouter",
+                    api_key=model_settings.openrouter_api_key,
+                    handle_base=model_settings.openrouter_handle_base,
+                )
+            )
 
-        # For MCP
-        # TODO: remove this
-        """Initialize the MCP clients (there may be multiple)"""
-        self.mcp_clients: Dict[str, AsyncBaseMCPClient] = {}
+    async def init_async(self, init_with_default_org_and_user: bool = True):
+        # Make default user and org
+        if init_with_default_org_and_user:
+            self.default_org = await self.organization_manager.create_default_organization_async()
+            self.default_user = await self.user_manager.create_default_actor_async()
+            print(f"Default user: {self.default_user} and org: {self.default_org}")
+            await self.tool_manager.upsert_base_tools_async(actor=self.default_user)
 
-        # TODO: Remove these in memory caches
-        self._llm_config_cache = {}
-        self._embedding_config_cache = {}
+            # For OSS users, create a local sandbox config
+            oss_default_user = await self.user_manager.get_default_actor_async()
+            use_venv = False if not tool_settings.tool_exec_venv_name else True
+            venv_name = tool_settings.tool_exec_venv_name or "venv"
+            tool_dir = tool_settings.tool_exec_dir or LETTA_TOOL_EXECUTION_DIR
 
-        # TODO: Replace this with the Anthropic client we have in house
-        self.anthropic_async_client = AsyncAnthropic()
+            venv_dir = Path(tool_dir) / venv_name
+            tool_path = Path(tool_dir)
+
+            if tool_path.exists() and not tool_path.is_dir():
+                logger.error(f"LETTA_TOOL_SANDBOX_DIR exists but is not a directory: {tool_dir}")
+            else:
+                if not tool_path.exists():
+                    logger.warning(f"LETTA_TOOL_SANDBOX_DIR does not exist, creating now: {tool_dir}")
+                    tool_path.mkdir(parents=True, exist_ok=True)
+
+                if tool_settings.tool_exec_venv_name and not venv_dir.is_dir():
+                    logger.warning(
+                        f"Provided LETTA_TOOL_SANDBOX_VENV_NAME is not a valid venv ({venv_dir}), one will be created for you during tool execution."
+                    )
+
+                sandbox_config_create = SandboxConfigCreate(
+                    config=LocalSandboxConfig(sandbox_dir=tool_settings.tool_exec_dir, use_venv=use_venv, venv_name=venv_name)
+                )
+                sandbox_config = await self.sandbox_config_manager.create_or_update_sandbox_config_async(
+                    sandbox_config_create=sandbox_config_create, actor=oss_default_user
+                )
+                logger.debug(f"Successfully created default local sandbox config:\n{sandbox_config.get_local_config().model_dump()}")
+
+                if use_venv and tool_settings.tool_exec_autoreload_venv:
+                    prepare_local_sandbox(
+                        sandbox_config.get_local_config(),
+                        env=os.environ.copy(),
+                        force_recreate=True,
+                    )
 
     async def init_mcp_clients(self):
         # TODO: remove this
@@ -421,7 +363,7 @@ class SyncServer(Server):
             elif server_config.type == MCPServerType.STDIO:
                 self.mcp_clients[server_name] = AsyncStdioMCPClient(server_config)
             else:
-                raise ValueError(f"Invalid MCP server config: {server_config}")
+                raise LettaInvalidArgumentError(f"Invalid MCP server config: {server_config}", argument_name="server_config")
 
             try:
                 await self.mcp_clients[server_name].connect_to_server()
@@ -436,329 +378,6 @@ class SyncServer(Server):
             logger.info(f"MCP tools connected: {', '.join([t.name for t in mcp_tools])}")
             logger.debug(f"MCP tools: {', '.join([str(t) for t in mcp_tools])}")
 
-    def load_agent(self, agent_id: str, actor: User, interface: Union[AgentInterface, None] = None) -> Agent:
-        """Updated method to load agents from persisted storage"""
-        agent_state = self.agent_manager.get_agent_by_id(agent_id=agent_id, actor=actor)
-        # TODO: Think about how to integrate voice sleeptime into sleeptime
-        # TODO: Voice sleeptime agents turn into normal agents when being messaged
-        if agent_state.multi_agent_group and agent_state.multi_agent_group.manager_type != ManagerType.voice_sleeptime:
-            return load_multi_agent(
-                group=agent_state.multi_agent_group, agent_state=agent_state, actor=actor, interface=interface, mcp_clients=self.mcp_clients
-            )
-
-        interface = interface or self.default_interface_factory()
-        return Agent(agent_state=agent_state, interface=interface, user=actor, mcp_clients=self.mcp_clients)
-
-    def _step(
-        self,
-        actor: User,
-        agent_id: str,
-        input_messages: List[MessageCreate],
-        interface: Union[AgentInterface, None] = None,  # needed to getting responses
-        put_inner_thoughts_first: bool = True,
-        # timestamp: Optional[datetime],
-    ) -> LettaUsageStatistics:
-        """Send the input message through the agent"""
-        # TODO: Thread actor directly through this function, since the top level caller most likely already retrieved the user
-        logger.debug(f"Got input messages: {input_messages}")
-        letta_agent = None
-        try:
-            letta_agent = self.load_agent(agent_id=agent_id, interface=interface, actor=actor)
-            if letta_agent is None:
-                raise KeyError(f"Agent (user={actor.id}, agent={agent_id}) is not loaded")
-
-            # Determine whether or not to token stream based on the capability of the interface
-            token_streaming = letta_agent.interface.streaming_mode if hasattr(letta_agent.interface, "streaming_mode") else False
-
-            logger.debug("Starting agent step")
-            if interface:
-                metadata = interface.metadata if hasattr(interface, "metadata") else None
-            else:
-                metadata = None
-
-            usage_stats = letta_agent.step(
-                input_messages=input_messages,
-                chaining=self.chaining,
-                max_chaining_steps=self.max_chaining_steps,
-                stream=token_streaming,
-                skip_verify=True,
-                metadata=metadata,
-                put_inner_thoughts_first=put_inner_thoughts_first,
-            )
-
-        except Exception as e:
-            logger.error(f"Error in server._step: {e}")
-            print(traceback.print_exc())
-            raise
-        finally:
-            logger.debug("Calling step_yield()")
-            if letta_agent:
-                letta_agent.interface.step_yield()
-
-        return usage_stats
-
-    def _command(self, user_id: str, agent_id: str, command: str) -> LettaUsageStatistics:
-        """Process a CLI command"""
-        # TODO: Thread actor directly through this function, since the top level caller most likely already retrieved the user
-        actor = self.user_manager.get_user_or_default(user_id=user_id)
-
-        logger.debug(f"Got command: {command}")
-
-        # Get the agent object (loaded in memory)
-        letta_agent = self.load_agent(agent_id=agent_id, actor=actor)
-        usage = None
-
-        if command.lower() == "exit":
-            # exit not supported on server.py
-            raise ValueError(command)
-
-        elif command.lower() == "save" or command.lower() == "savechat":
-            save_agent(letta_agent)
-
-        elif command.lower() == "attach":
-            # Different from CLI, we extract the data source name from the command
-            command = command.strip().split()
-            try:
-                data_source = int(command[1])
-            except:
-                raise ValueError(command)
-
-            # attach data to agent from source
-            letta_agent.attach_source(
-                user=self.user_manager.get_user_by_id(user_id=user_id),
-                source_id=data_source,
-                source_manager=self.source_manager,
-                agent_manager=self.agent_manager,
-            )
-
-        elif command.lower() == "dump" or command.lower().startswith("dump "):
-            # Check if there's an additional argument that's an integer
-            command = command.strip().split()
-            amount = int(command[1]) if len(command) > 1 and command[1].isdigit() else 0
-            if amount == 0:
-                letta_agent.interface.print_messages(letta_agent.messages, dump=True)
-            else:
-                letta_agent.interface.print_messages(letta_agent.messages[-min(amount, len(letta_agent.messages)) :], dump=True)
-
-        elif command.lower() == "dumpraw":
-            letta_agent.interface.print_messages_raw(letta_agent.messages)
-
-        elif command.lower() == "memory":
-            ret_str = "\nDumping memory contents:\n" + f"\n{str(letta_agent.agent_state.memory)}" + f"\n{str(letta_agent.passage_manager)}"
-            return ret_str
-
-        elif command.lower() == "pop" or command.lower().startswith("pop "):
-            # Check if there's an additional argument that's an integer
-            command = command.strip().split()
-            pop_amount = int(command[1]) if len(command) > 1 and command[1].isdigit() else 3
-            n_messages = len(letta_agent.messages)
-            MIN_MESSAGES = 2
-            if n_messages <= MIN_MESSAGES:
-                logger.debug(f"Agent only has {n_messages} messages in stack, none left to pop")
-            elif n_messages - pop_amount < MIN_MESSAGES:
-                logger.debug(f"Agent only has {n_messages} messages in stack, cannot pop more than {n_messages - MIN_MESSAGES}")
-            else:
-                logger.debug(f"Popping last {pop_amount} messages from stack")
-                for _ in range(min(pop_amount, len(letta_agent.messages))):
-                    letta_agent.messages.pop()
-
-        elif command.lower() == "retry":
-            # TODO this needs to also modify the persistence manager
-            logger.debug("Retrying for another answer")
-            while len(letta_agent.messages) > 0:
-                if letta_agent.messages[-1].get("role") == "user":
-                    # we want to pop up to the last user message and send it again
-                    letta_agent.messages[-1].get("content")
-                    letta_agent.messages.pop()
-                    break
-                letta_agent.messages.pop()
-
-        elif command.lower() == "rethink" or command.lower().startswith("rethink "):
-            # TODO this needs to also modify the persistence manager
-            if len(command) < len("rethink "):
-                logger.warning("Missing text after the command")
-            else:
-                for x in range(len(letta_agent.messages) - 1, 0, -1):
-                    if letta_agent.messages[x].get("role") == "assistant":
-                        text = command[len("rethink ") :].strip()
-                        letta_agent.messages[x].update({"content": text})
-                        break
-
-        elif command.lower() == "rewrite" or command.lower().startswith("rewrite "):
-            # TODO this needs to also modify the persistence manager
-            if len(command) < len("rewrite "):
-                logger.warning("Missing text after the command")
-            else:
-                for x in range(len(letta_agent.messages) - 1, 0, -1):
-                    if letta_agent.messages[x].get("role") == "assistant":
-                        text = command[len("rewrite ") :].strip()
-                        args = json_loads(letta_agent.messages[x].get("function_call").get("arguments"))
-                        args["message"] = text
-                        letta_agent.messages[x].get("function_call").update({"arguments": json_dumps(args)})
-                        break
-
-        # No skip options
-        elif command.lower() == "wipe":
-            # exit not supported on server.py
-            raise ValueError(command)
-
-        elif command.lower() == "heartbeat":
-            input_message = system.get_heartbeat()
-            usage = self._step(actor=actor, agent_id=agent_id, input_message=input_message)
-
-        elif command.lower() == "memorywarning":
-            input_message = system.get_token_limit_warning()
-            usage = self._step(actor=actor, agent_id=agent_id, input_message=input_message)
-
-        if not usage:
-            usage = LettaUsageStatistics()
-
-        return usage
-
-    def user_message(
-        self,
-        user_id: str,
-        agent_id: str,
-        message: Union[str, Message],
-        timestamp: Optional[datetime] = None,
-    ) -> LettaUsageStatistics:
-        """Process an incoming user message and feed it through the Letta agent"""
-        try:
-            actor = self.user_manager.get_user_by_id(user_id=user_id)
-        except NoResultFound:
-            raise ValueError(f"User user_id={user_id} does not exist")
-
-        try:
-            agent = self.agent_manager.get_agent_by_id(agent_id=agent_id, actor=actor)
-        except NoResultFound:
-            raise ValueError(f"Agent agent_id={agent_id} does not exist")
-
-        # Basic input sanitization
-        if isinstance(message, str):
-            if len(message) == 0:
-                raise ValueError(f"Invalid input: '{message}'")
-
-            # If the input begins with a command prefix, reject
-            elif message.startswith("/"):
-                raise ValueError(f"Invalid input: '{message}'")
-
-            packaged_user_message = system.package_user_message(
-                user_message=message,
-                timezone=agent.timezone,
-            )
-
-            # NOTE: eventually deprecate and only allow passing Message types
-            message = MessageCreate(
-                agent_id=agent_id,
-                role="user",
-                content=[TextContent(text=packaged_user_message)],
-            )
-
-        # Run the agent state forward
-        usage = self._step(actor=actor, agent_id=agent_id, input_messages=[message])
-        return usage
-
-    def system_message(
-        self,
-        user_id: str,
-        agent_id: str,
-        message: Union[str, Message],
-        timestamp: Optional[datetime] = None,
-    ) -> LettaUsageStatistics:
-        """Process an incoming system message and feed it through the Letta agent"""
-        try:
-            actor = self.user_manager.get_user_by_id(user_id=user_id)
-        except NoResultFound:
-            raise ValueError(f"User user_id={user_id} does not exist")
-
-        try:
-            agent = self.agent_manager.get_agent_by_id(agent_id=agent_id, actor=actor)
-        except NoResultFound:
-            raise ValueError(f"Agent agent_id={agent_id} does not exist")
-
-        # Basic input sanitization
-        if isinstance(message, str):
-            if len(message) == 0:
-                raise ValueError(f"Invalid input: '{message}'")
-
-            # If the input begins with a command prefix, reject
-            elif message.startswith("/"):
-                raise ValueError(f"Invalid input: '{message}'")
-
-            packaged_system_message = system.package_system_message(system_message=message)
-
-            # NOTE: eventually deprecate and only allow passing Message types
-            # Convert to a Message object
-
-            if timestamp:
-                message = Message(
-                    agent_id=agent_id,
-                    role="system",
-                    content=[TextContent(text=packaged_system_message)],
-                    created_at=timestamp,
-                )
-            else:
-                message = Message(
-                    agent_id=agent_id,
-                    role="system",
-                    content=[TextContent(text=packaged_system_message)],
-                )
-
-        if isinstance(message, Message):
-            # Can't have a null text field
-            message_text = message.content[0].text
-            if message_text is None or len(message_text) == 0:
-                raise ValueError(f"Invalid input: '{message_text}'")
-            # If the input begins with a command prefix, reject
-            elif message_text.startswith("/"):
-                raise ValueError(f"Invalid input: '{message_text}'")
-
-        else:
-            raise TypeError(f"Invalid input: '{message}' - type {type(message)}")
-
-        if timestamp:
-            # Override the timestamp with what the caller provided
-            message.created_at = timestamp
-
-        # Run the agent state forward
-        return self._step(actor=actor, agent_id=agent_id, input_messages=message)
-
-    # TODO: Deprecate this
-    def send_messages(
-        self,
-        actor: User,
-        agent_id: str,
-        input_messages: List[MessageCreate],
-        wrap_user_message: bool = True,
-        wrap_system_message: bool = True,
-        interface: Union[AgentInterface, ChatCompletionsStreamingInterface, None] = None,  # needed for responses
-        metadata: Optional[dict] = None,  # Pass through metadata to interface
-        put_inner_thoughts_first: bool = True,
-    ) -> LettaUsageStatistics:
-        """Send a list of messages to the agent."""
-
-        # Store metadata in interface if provided
-        if metadata and hasattr(interface, "metadata"):
-            interface.metadata = metadata
-
-        # Run the agent state forward
-        return self._step(
-            actor=actor,
-            agent_id=agent_id,
-            input_messages=input_messages,
-            interface=interface,
-            put_inner_thoughts_first=put_inner_thoughts_first,
-        )
-
-    # @LockingServer.agent_lock_decorator
-    def run_command(self, user_id: str, agent_id: str, command: str) -> LettaUsageStatistics:
-        """Run a command on the agent"""
-        # If the input begins with a command prefix, attempt to process it as a command
-        if command.startswith("/"):
-            if len(command) > 1:
-                command = command[1:]  # strip the prefix
-        return self._command(user_id=user_id, agent_id=agent_id, command=command)
-
     @trace_method
     def get_cached_llm_config(self, actor: User, **kwargs):
         key = make_key(**kwargs)
@@ -788,54 +407,6 @@ class SyncServer(Server):
             self._embedding_config_cache[key] = await self.get_embedding_config_from_handle_async(actor=actor, **kwargs)
         return self._embedding_config_cache[key]
 
-    @trace_method
-    def create_agent(
-        self,
-        request: CreateAgent,
-        actor: User,
-        interface: AgentInterface | None = None,
-    ) -> AgentState:
-        warnings.warn("This method is deprecated, use create_agent_async where possible.", DeprecationWarning, stacklevel=2)
-        if request.llm_config is None:
-            if request.model is None:
-                raise ValueError("Must specify either model or llm_config in request")
-            config_params = {
-                "handle": request.model,
-                "context_window_limit": request.context_window_limit,
-                "max_tokens": request.max_tokens,
-                "max_reasoning_tokens": request.max_reasoning_tokens,
-                "enable_reasoner": request.enable_reasoner,
-            }
-            log_event(name="start get_cached_llm_config", attributes=config_params)
-            request.llm_config = self.get_cached_llm_config(actor=actor, **config_params)
-            log_event(name="end get_cached_llm_config", attributes=config_params)
-
-        if request.embedding_config is None:
-            if request.embedding is None:
-                raise ValueError("Must specify either embedding or embedding_config in request")
-            embedding_config_params = {
-                "handle": request.embedding,
-                "embedding_chunk_size": request.embedding_chunk_size or constants.DEFAULT_EMBEDDING_CHUNK_SIZE,
-            }
-            log_event(name="start get_cached_embedding_config", attributes=embedding_config_params)
-            request.embedding_config = self.get_cached_embedding_config(actor=actor, **embedding_config_params)
-            log_event(name="end get_cached_embedding_config", attributes=embedding_config_params)
-
-        log_event(name="start create_agent db")
-        main_agent = self.agent_manager.create_agent(
-            agent_create=request,
-            actor=actor,
-        )
-        log_event(name="end create_agent db")
-
-        if request.enable_sleeptime:
-            if request.agent_type == AgentType.voice_convo_agent:
-                main_agent = self.create_voice_sleeptime_agent(main_agent=main_agent, actor=actor)
-            else:
-                main_agent = self.create_sleeptime_agent(main_agent=main_agent, actor=actor)
-
-        return main_agent
-
     @trace_method
     async def create_agent_async(
         self,
@@ -845,7 +416,7 @@ class SyncServer(Server):
         if request.llm_config is None:
             if request.model is None:
                 if settings.default_llm_handle is None:
-                    raise ValueError("Must specify either model or llm_config in request")
+                    raise LettaInvalidArgumentError("Must specify either model or llm_config in request", argument_name="model")
                 else:
                     request.model = settings.default_llm_handle
             config_params = {
@@ -865,7 +436,9 @@ class SyncServer(Server):
         if request.embedding_config is None:
             if request.embedding is None:
                 if settings.default_embedding_handle is None:
-                    raise ValueError("Must specify either embedding or embedding_config in request")
+                    raise LettaInvalidArgumentError(
+                        "Must specify either embedding or embedding_config in request", argument_name="embedding"
+                    )
                 else:
                     request.embedding = settings.default_embedding_handle
             embedding_config_params = {
@@ -903,32 +476,6 @@ class SyncServer(Server):
 
         return main_agent
 
-    def update_agent(
-        self,
-        agent_id: str,
-        request: UpdateAgent,
-        actor: User,
-    ) -> AgentState:
-        if request.model is not None:
-            request.llm_config = self.get_llm_config_from_handle(handle=request.model, actor=actor)
-
-        if request.embedding is not None:
-            request.embedding_config = self.get_embedding_config_from_handle(handle=request.embedding, actor=actor)
-
-        if request.enable_sleeptime:
-            agent = self.agent_manager.get_agent_by_id(agent_id=agent_id, actor=actor)
-            if agent.multi_agent_group is None:
-                if agent.agent_type == AgentType.voice_convo_agent:
-                    self.create_voice_sleeptime_agent(main_agent=agent, actor=actor)
-                else:
-                    self.create_sleeptime_agent(main_agent=agent, actor=actor)
-
-        return self.agent_manager.update_agent(
-            agent_id=agent_id,
-            agent_update=request,
-            actor=actor,
-        )
-
     async def update_agent_async(
         self,
         agent_id: str,
@@ -955,38 +502,6 @@ class SyncServer(Server):
             actor=actor,
         )
 
-    def create_sleeptime_agent(self, main_agent: AgentState, actor: User) -> AgentState:
-        request = CreateAgent(
-            name=main_agent.name + "-sleeptime",
-            agent_type=AgentType.sleeptime_agent,
-            block_ids=[block.id for block in main_agent.memory.blocks],
-            memory_blocks=[
-                CreateBlock(
-                    label="memory_persona",
-                    value=get_persona_text("sleeptime_memory_persona"),
-                ),
-            ],
-            llm_config=main_agent.llm_config,
-            embedding_config=main_agent.embedding_config,
-            project_id=main_agent.project_id,
-        )
-        sleeptime_agent = self.agent_manager.create_agent(
-            agent_create=request,
-            actor=actor,
-        )
-        self.group_manager.create_group(
-            group=GroupCreate(
-                description="",
-                agent_ids=[sleeptime_agent.id],
-                manager_config=SleeptimeManager(
-                    manager_agent_id=main_agent.id,
-                    sleeptime_agent_frequency=5,
-                ),
-            ),
-            actor=actor,
-        )
-        return self.agent_manager.get_agent_by_id(agent_id=main_agent.id, actor=actor)
-
     async def create_sleeptime_agent_async(self, main_agent: AgentState, actor: User) -> AgentState:
         request = CreateAgent(
             name=main_agent.name + "-sleeptime",
@@ -1019,40 +534,6 @@ class SyncServer(Server):
         )
         return await self.agent_manager.get_agent_by_id_async(agent_id=main_agent.id, actor=actor)
 
-    def create_voice_sleeptime_agent(self, main_agent: AgentState, actor: User) -> AgentState:
-        # TODO: Inject system
-        request = CreateAgent(
-            name=main_agent.name + "-sleeptime",
-            agent_type=AgentType.voice_sleeptime_agent,
-            block_ids=[block.id for block in main_agent.memory.blocks],
-            memory_blocks=[
-                CreateBlock(
-                    label="memory_persona",
-                    value=get_persona_text("voice_memory_persona"),
-                ),
-            ],
-            llm_config=LLMConfig.default_config("gpt-4.1"),
-            embedding_config=main_agent.embedding_config,
-            project_id=main_agent.project_id,
-        )
-        voice_sleeptime_agent = self.agent_manager.create_agent(
-            agent_create=request,
-            actor=actor,
-        )
-        self.group_manager.create_group(
-            group=GroupCreate(
-                description="Low latency voice chat with async memory management.",
-                agent_ids=[voice_sleeptime_agent.id],
-                manager_config=VoiceSleeptimeManager(
-                    manager_agent_id=main_agent.id,
-                    max_message_buffer_length=constants.DEFAULT_MAX_MESSAGE_BUFFER_LENGTH,
-                    min_message_buffer_length=constants.DEFAULT_MIN_MESSAGE_BUFFER_LENGTH,
-                ),
-            ),
-            actor=actor,
-        )
-        return self.agent_manager.get_agent_by_id(agent_id=main_agent.id, actor=actor)
-
     async def create_voice_sleeptime_agent_async(self, main_agent: AgentState, actor: User) -> AgentState:
         # TODO: Inject system
         request = CreateAgent(
@@ -1087,24 +568,11 @@ class SyncServer(Server):
         )
         return await self.agent_manager.get_agent_by_id_async(agent_id=main_agent.id, actor=actor)
 
-    # convert name->id
-
-    # TODO: These can be moved to agent_manager
-    def get_agent_memory(self, agent_id: str, actor: User) -> Memory:
-        """Return the memory of an agent (core memory)"""
-        return self.agent_manager.get_agent_by_id(agent_id=agent_id, actor=actor).memory
-
     async def get_agent_memory_async(self, agent_id: str, actor: User) -> Memory:
         """Return the memory of an agent (core memory)"""
         agent = await self.agent_manager.get_agent_by_id_async(agent_id=agent_id, actor=actor)
         return agent.memory
 
-    def get_archival_memory_summary(self, agent_id: str, actor: User) -> ArchivalMemorySummary:
-        return ArchivalMemorySummary(size=self.agent_manager.passage_size(actor=actor, agent_id=agent_id))
-
-    def get_recall_memory_summary(self, agent_id: str, actor: User) -> RecallMemorySummary:
-        return RecallMemorySummary(size=self.message_manager.size(actor=actor, agent_id=agent_id))
-
     async def get_agent_archival_async(
         self,
         agent_id: str,
@@ -1149,7 +617,7 @@ class SyncServer(Server):
         # delete the passage
         await self.passage_manager.delete_passage_by_id_async(passage_id=memory_id, actor=actor)
 
-    def get_agent_recall(
+    async def get_agent_recall(
         self,
         user_id: str,
         agent_id: str,
@@ -1165,9 +633,9 @@ class SyncServer(Server):
     ) -> Union[List[Message], List[LettaMessage]]:
         # TODO: Thread actor directly through this function, since the top level caller most likely already retrieved the user
 
-        actor = self.user_manager.get_user_or_default(user_id=user_id)
+        actor = await self.user_manager.get_actor_or_default_async(actor_id=user_id)
 
-        records = self.message_manager.list_messages_for_agent(
+        records = await self.message_manager.list_messages(
             agent_id=agent_id,
             actor=actor,
             after=after,
@@ -1206,7 +674,7 @@ class SyncServer(Server):
         assistant_message_tool_kwarg: str = constants.DEFAULT_MESSAGE_TOOL_KWARG,
         include_err: Optional[bool] = None,
     ) -> Union[List[Message], List[LettaMessage]]:
-        records = await self.message_manager.list_messages_for_agent_async(
+        records = await self.message_manager.list_messages(
             agent_id=agent_id,
             actor=actor,
             after=after,
@@ -1218,6 +686,10 @@ class SyncServer(Server):
         )
 
         if not return_message_object:
+            # Get agent state to determine if it's a react agent
+            agent_state = await self.agent_manager.get_agent_by_id_async(agent_id=agent_id, actor=actor)
+            text_is_assistant_message = agent_state.agent_type == AgentType.letta_v1_agent
+
             records = Message.to_letta_messages_from_list(
                 messages=records,
                 use_assistant_message=use_assistant_message,
@@ -1225,6 +697,7 @@ class SyncServer(Server):
                 assistant_message_tool_kwarg=assistant_message_tool_kwarg,
                 reverse=reverse,
                 include_err=include_err,
+                text_is_assistant_message=text_is_assistant_message,
             )
 
         if reverse:
@@ -1289,7 +762,7 @@ class SyncServer(Server):
         # TODO: move this into a thread
         source = await self.source_manager.get_source_by_id(source_id=source_id)
         if source is None:
-            raise ValueError(f"Source {source_id} does not exist")
+            raise NoResultFound(f"Source {source_id} does not exist")
         connector = DirectoryConnector(input_files=[file_path])
         num_passages, num_documents = await self.load_data(user_id=source.created_by_id, source_name=source.name, connector=connector)
 
@@ -1423,78 +896,12 @@ class SyncServer(Server):
         actor = await self.user_manager.get_actor_by_id_async(actor_id=user_id)
         source = await self.source_manager.get_source_by_name(source_name=source_name, actor=actor)
         if source is None:
-            raise ValueError(f"Data source {source_name} does not exist for user {user_id}")
+            raise NoResultFound(f"Data source {source_name} does not exist for user {user_id}")
 
         # load data into the document store
         passage_count, document_count = await load_data(connector, source, self.passage_manager, self.file_manager, actor=actor)
         return passage_count, document_count
 
-    def list_all_sources(self, actor: User) -> List[Source]:
-        # TODO: legacy: remove
-        """List all sources (w/ extra metadata) belonging to a user"""
-
-        sources = self.source_manager.list_sources(actor=actor)
-
-        # Add extra metadata to the sources
-        sources_with_metadata = []
-        for source in sources:
-            # count number of passages
-            num_passages = self.agent_manager.passage_size(actor=actor, source_id=source.id)
-
-            # TODO: add when files table implemented
-            ## count number of files
-            # document_conn = StorageConnector.get_storage_connector(TableType.FILES, self.config, user_id=user_id)
-            # num_documents = document_conn.size({"data_source": source.name})
-            num_documents = 0
-
-            agents = self.source_manager.list_attached_agents(source_id=source.id, actor=actor)
-            # add the agent name information
-            attached_agents = [{"id": agent.id, "name": agent.name} for agent in agents]
-
-            # Overwrite metadata field, should be empty anyways
-            source.metadata = dict(
-                num_documents=num_documents,
-                num_passages=num_passages,
-                attached_agents=attached_agents,
-            )
-
-            sources_with_metadata.append(source)
-
-        return sources_with_metadata
-
-    def update_agent_message(self, message_id: str, request: MessageUpdate, actor: User) -> Message:
-        """Update the details of a message associated with an agent"""
-
-        # Get the current message
-        return self.message_manager.update_message_by_id(message_id=message_id, message_update=request, actor=actor)
-
-    def list_llm_models(
-        self,
-        actor: User,
-        provider_category: Optional[List[ProviderCategory]] = None,
-        provider_name: Optional[str] = None,
-        provider_type: Optional[ProviderType] = None,
-    ) -> List[LLMConfig]:
-        """List available models"""
-        llm_models = []
-        for provider in self.get_enabled_providers(
-            provider_category=provider_category,
-            provider_name=provider_name,
-            provider_type=provider_type,
-            actor=actor,
-        ):
-            try:
-                llm_models.extend(provider.list_llm_models())
-            except Exception as e:
-                import traceback
-
-                traceback.print_exc()
-                warnings.warn(f"An error occurred while listing LLM models for provider {provider}: {e}")
-
-        llm_models.extend(self.get_local_llm_configs())
-
-        return llm_models
-
     @trace_method
     async def list_llm_models_async(
         self,
@@ -1548,16 +955,6 @@ class SyncServer(Server):
 
         return unique_models
 
-    def list_embedding_models(self, actor: User) -> List[EmbeddingConfig]:
-        """List available embedding models"""
-        embedding_models = []
-        for provider in self.get_enabled_providers(actor):
-            try:
-                embedding_models.extend(provider.list_embedding_models())
-            except Exception as e:
-                warnings.warn(f"An error occurred while listing embedding models for provider {provider}: {e}")
-        return embedding_models
-
     async def list_embedding_models_async(self, actor: User) -> List[EmbeddingConfig]:
         """Asynchronously list available embedding models with maximum concurrency"""
         import asyncio
@@ -1587,35 +984,6 @@ class SyncServer(Server):
 
         return embedding_models
 
-    def get_enabled_providers(
-        self,
-        actor: User,
-        provider_category: Optional[List[ProviderCategory]] = None,
-        provider_name: Optional[str] = None,
-        provider_type: Optional[ProviderType] = None,
-    ) -> List[Provider]:
-        providers = []
-        if not provider_category or ProviderCategory.base in provider_category:
-            providers_from_env = [p for p in self._enabled_providers]
-            providers.extend(providers_from_env)
-
-        if not provider_category or ProviderCategory.byok in provider_category:
-            providers_from_db = self.provider_manager.list_providers(
-                name=provider_name,
-                provider_type=provider_type,
-                actor=actor,
-            )
-            providers_from_db = [p.cast_to_subtype() for p in providers_from_db]
-            providers.extend(providers_from_db)
-
-        if provider_name is not None:
-            providers = [p for p in providers if p.name == provider_name]
-
-        if provider_type is not None:
-            providers = [p for p in providers if p.provider_type == provider_type]
-
-        return providers
-
     async def get_enabled_providers_async(
         self,
         actor: User,
@@ -1645,60 +1013,6 @@ class SyncServer(Server):
 
         return providers
 
-    @trace_method
-    def get_llm_config_from_handle(
-        self,
-        actor: User,
-        handle: str,
-        context_window_limit: Optional[int] = None,
-        max_tokens: Optional[int] = None,
-        max_reasoning_tokens: Optional[int] = None,
-        enable_reasoner: Optional[bool] = None,
-    ) -> LLMConfig:
-        try:
-            provider_name, model_name = handle.split("/", 1)
-            provider = self.get_provider_from_name(provider_name, actor)
-
-            llm_configs = [config for config in provider.list_llm_models() if config.handle == handle]
-            if not llm_configs:
-                llm_configs = [config for config in provider.list_llm_models() if config.model == model_name]
-            if not llm_configs:
-                available_handles = [config.handle for config in provider.list_llm_models()]
-                raise HandleNotFoundError(handle, available_handles)
-        except ValueError as e:
-            llm_configs = [config for config in self.get_local_llm_configs() if config.handle == handle]
-            if not llm_configs:
-                llm_configs = [config for config in self.get_local_llm_configs() if config.model == model_name]
-            if not llm_configs:
-                raise e
-
-        if len(llm_configs) == 1:
-            llm_config = llm_configs[0]
-        elif len(llm_configs) > 1:
-            raise ValueError(f"Multiple LLM models with name {model_name} supported by {provider_name}")
-        else:
-            llm_config = llm_configs[0]
-
-        if context_window_limit is not None:
-            if context_window_limit > llm_config.context_window:
-                raise ValueError(f"Context window limit ({context_window_limit}) is greater than maximum of ({llm_config.context_window})")
-            llm_config.context_window = context_window_limit
-        else:
-            llm_config.context_window = min(llm_config.context_window, model_settings.global_max_context_window_limit)
-
-        if max_tokens is not None:
-            llm_config.max_tokens = max_tokens
-        if max_reasoning_tokens is not None:
-            if not max_tokens or max_reasoning_tokens > max_tokens:
-                raise ValueError(f"Max reasoning tokens ({max_reasoning_tokens}) must be less than max tokens ({max_tokens})")
-            llm_config.max_reasoning_tokens = max_reasoning_tokens
-        if enable_reasoner is not None:
-            llm_config.enable_reasoner = enable_reasoner
-            if enable_reasoner and llm_config.model_endpoint_type == "anthropic":
-                llm_config.put_inner_thoughts_in_kwargs = False
-
-        return llm_config
-
     @trace_method
     async def get_llm_config_from_handle_async(
         self,
@@ -1730,13 +1044,18 @@ class SyncServer(Server):
         if len(llm_configs) == 1:
             llm_config = llm_configs[0]
         elif len(llm_configs) > 1:
-            raise ValueError(f"Multiple LLM models with name {model_name} supported by {provider_name}")
+            raise LettaInvalidArgumentError(
+                f"Multiple LLM models with name {model_name} supported by {provider_name}", argument_name="model_name"
+            )
         else:
             llm_config = llm_configs[0]
 
         if context_window_limit is not None:
             if context_window_limit > llm_config.context_window:
-                raise ValueError(f"Context window limit ({context_window_limit}) is greater than maximum of ({llm_config.context_window})")
+                raise LettaInvalidArgumentError(
+                    f"Context window limit ({context_window_limit}) is greater than maximum of ({llm_config.context_window})",
+                    argument_name="context_window_limit",
+                )
             llm_config.context_window = context_window_limit
         else:
             llm_config.context_window = min(llm_config.context_window, model_settings.global_max_context_window_limit)
@@ -1745,7 +1064,10 @@ class SyncServer(Server):
             llm_config.max_tokens = max_tokens
         if max_reasoning_tokens is not None:
             if not max_tokens or max_reasoning_tokens > max_tokens:
-                raise ValueError(f"Max reasoning tokens ({max_reasoning_tokens}) must be less than max tokens ({max_tokens})")
+                raise LettaInvalidArgumentError(
+                    f"Max reasoning tokens ({max_reasoning_tokens}) must be less than max tokens ({max_tokens})",
+                    argument_name="max_reasoning_tokens",
+                )
             llm_config.max_reasoning_tokens = max_reasoning_tokens
         if enable_reasoner is not None:
             llm_config.enable_reasoner = enable_reasoner
@@ -1754,35 +1076,6 @@ class SyncServer(Server):
 
         return llm_config
 
-    @trace_method
-    def get_embedding_config_from_handle(
-        self, actor: User, handle: str, embedding_chunk_size: int = constants.DEFAULT_EMBEDDING_CHUNK_SIZE
-    ) -> EmbeddingConfig:
-        try:
-            provider_name, model_name = handle.split("/", 1)
-            provider = self.get_provider_from_name(provider_name, actor)
-
-            embedding_configs = [config for config in provider.list_embedding_models() if config.handle == handle]
-            if not embedding_configs:
-                raise ValueError(f"Embedding model {model_name} is not supported by {provider_name}")
-        except ValueError as e:
-            # search local configs
-            embedding_configs = [config for config in self.get_local_embedding_configs() if config.handle == handle]
-            if not embedding_configs:
-                raise e
-
-        if len(embedding_configs) == 1:
-            embedding_config = embedding_configs[0]
-        elif len(embedding_configs) > 1:
-            raise ValueError(f"Multiple embedding models with name {model_name} supported by {provider_name}")
-        else:
-            embedding_config = embedding_configs[0]
-
-        if embedding_chunk_size:
-            embedding_config.embedding_chunk_size = embedding_chunk_size
-
-        return embedding_config
-
     @trace_method
     async def get_embedding_config_from_handle_async(
         self, actor: User, handle: str, embedding_chunk_size: int = constants.DEFAULT_EMBEDDING_CHUNK_SIZE
@@ -1794,8 +1087,10 @@ class SyncServer(Server):
             all_embedding_configs = await provider.list_embedding_models_async()
             embedding_configs = [config for config in all_embedding_configs if config.handle == handle]
             if not embedding_configs:
-                raise ValueError(f"Embedding model {model_name} is not supported by {provider_name}")
-        except ValueError as e:
+                raise LettaInvalidArgumentError(
+                    f"Embedding model {model_name} is not supported by {provider_name}", argument_name="model_name"
+                )
+        except LettaInvalidArgumentError as e:
             # search local configs
             embedding_configs = [config for config in self.get_local_embedding_configs() if config.handle == handle]
             if not embedding_configs:
@@ -1804,7 +1099,9 @@ class SyncServer(Server):
         if len(embedding_configs) == 1:
             embedding_config = embedding_configs[0]
         elif len(embedding_configs) > 1:
-            raise ValueError(f"Multiple embedding models with name {model_name} supported by {provider_name}")
+            raise LettaInvalidArgumentError(
+                f"Multiple embedding models with name {model_name} supported by {provider_name}", argument_name="model_name"
+            )
         else:
             embedding_config = embedding_configs[0]
 
@@ -1813,28 +1110,16 @@ class SyncServer(Server):
 
         return embedding_config
 
-    def get_provider_from_name(self, provider_name: str, actor: User) -> Provider:
-        providers = [provider for provider in self.get_enabled_providers(actor) if provider.name == provider_name]
-        if not providers:
-            raise ValueError(
-                f"Provider {provider_name} is not supported (supported providers: {', '.join([provider.name for provider in self._enabled_providers])})"
-            )
-        elif len(providers) > 1:
-            raise ValueError(f"Multiple providers with name {provider_name} supported")
-        else:
-            provider = providers[0]
-
-        return provider
-
     async def get_provider_from_name_async(self, provider_name: str, actor: User) -> Provider:
         all_providers = await self.get_enabled_providers_async(actor)
         providers = [provider for provider in all_providers if provider.name == provider_name]
         if not providers:
-            raise ValueError(
-                f"Provider {provider_name} is not supported (supported providers: {', '.join([provider.name for provider in self._enabled_providers])})"
+            raise LettaInvalidArgumentError(
+                f"Provider {provider_name} is not supported (supported providers: {', '.join([provider.name for provider in self._enabled_providers])})",
+                argument_name="provider_name",
             )
         elif len(providers) > 1:
-            raise ValueError(f"Multiple providers with name {provider_name} supported")
+            raise LettaInvalidArgumentError(f"Multiple providers with name {provider_name} supported", argument_name="provider_name")
         else:
             provider = providers[0]
 
@@ -1842,40 +1127,42 @@ class SyncServer(Server):
 
     def get_local_llm_configs(self):
         llm_models = []
-        try:
-            llm_configs_dir = os.path.expanduser("~/.letta/llm_configs")
-            if os.path.exists(llm_configs_dir):
-                for filename in os.listdir(llm_configs_dir):
-                    if filename.endswith(".json"):
-                        filepath = os.path.join(llm_configs_dir, filename)
-                        try:
-                            with open(filepath, "r") as f:
-                                config_data = json.load(f)
-                                llm_config = LLMConfig(**config_data)
-                                llm_models.append(llm_config)
-                        except (json.JSONDecodeError, ValueError) as e:
-                            warnings.warn(f"Error parsing LLM config file {filename}: {e}")
-        except Exception as e:
-            warnings.warn(f"Error reading LLM configs directory: {e}")
+        # NOTE: deprecated
+        # try:
+        #    llm_configs_dir = os.path.expanduser("~/.letta/llm_configs")
+        #    if os.path.exists(llm_configs_dir):
+        #        for filename in os.listdir(llm_configs_dir):
+        #            if filename.endswith(".json"):
+        #                filepath = os.path.join(llm_configs_dir, filename)
+        #                try:
+        #                    with open(filepath, "r") as f:
+        #                        config_data = json.load(f)
+        #                        llm_config = LLMConfig(**config_data)
+        #                        llm_models.append(llm_config)
+        #                except (json.JSONDecodeError, ValueError) as e:
+        #                    warnings.warn(f"Error parsing LLM config file {filename}: {e}")
+        # except Exception as e:
+        #    warnings.warn(f"Error reading LLM configs directory: {e}")
         return llm_models
 
     def get_local_embedding_configs(self):
         embedding_models = []
-        try:
-            embedding_configs_dir = os.path.expanduser("~/.letta/embedding_configs")
-            if os.path.exists(embedding_configs_dir):
-                for filename in os.listdir(embedding_configs_dir):
-                    if filename.endswith(".json"):
-                        filepath = os.path.join(embedding_configs_dir, filename)
-                        try:
-                            with open(filepath, "r") as f:
-                                config_data = json.load(f)
-                                embedding_config = EmbeddingConfig(**config_data)
-                                embedding_models.append(embedding_config)
-                        except (json.JSONDecodeError, ValueError) as e:
-                            warnings.warn(f"Error parsing embedding config file {filename}: {e}")
-        except Exception as e:
-            warnings.warn(f"Error reading embedding configs directory: {e}")
+        # NOTE: deprecated
+        # try:
+        #    embedding_configs_dir = os.path.expanduser("~/.letta/embedding_configs")
+        #    if os.path.exists(embedding_configs_dir):
+        #        for filename in os.listdir(embedding_configs_dir):
+        #            if filename.endswith(".json"):
+        #                filepath = os.path.join(embedding_configs_dir, filename)
+        #                try:
+        #                    with open(filepath, "r") as f:
+        #                        config_data = json.load(f)
+        #                        embedding_config = EmbeddingConfig(**config_data)
+        #                        embedding_models.append(embedding_config)
+        #                except (json.JSONDecodeError, ValueError) as e:
+        #                    warnings.warn(f"Error parsing embedding config file {filename}: {e}")
+        # except Exception as e:
+        #    warnings.warn(f"Error reading embedding configs directory: {e}")
         return embedding_models
 
     def add_llm_model(self, request: LLMConfig) -> LLMConfig:
@@ -1898,8 +1185,12 @@ class SyncServer(Server):
     ) -> ToolReturnMessage:
         """Run a tool from source code"""
 
+        from letta.services.tool_schema_generator import generate_schema_for_tool_creation, generate_schema_for_tool_update
+
         if tool_source_type not in (None, ToolSourceType.python, ToolSourceType.typescript):
-            raise ValueError("Tool source type is not supported at this time. Found {tool_source_type}")
+            raise LettaInvalidArgumentError(
+                f"Tool source type is not supported at this time. Found {tool_source_type}", argument_name="tool_source_type"
+            )
 
         # If tools_json_schema is explicitly passed in, override it on the created Tool object
         if tool_json_schema:
@@ -1920,6 +1211,11 @@ class SyncServer(Server):
                 source_type=tool_source_type,
             )
 
+        # try to get the schema
+        if not tool.name:
+            if not tool.json_schema:
+                tool.json_schema = generate_schema_for_tool_creation(tool)
+            tool.name = tool.json_schema.get("name")
         assert tool.name is not None, "Failed to create tool object"
 
         # TODO eventually allow using agent state in tools
@@ -1932,7 +1228,7 @@ class SyncServer(Server):
                 message_manager=self.message_manager,
                 agent_manager=self.agent_manager,
                 block_manager=self.block_manager,
-                job_manager=self.job_manager,
+                run_manager=self.run_manager,
                 passage_manager=self.passage_manager,
                 actor=actor,
                 sandbox_env_vars=tool_env_vars,
@@ -1965,33 +1261,6 @@ class SyncServer(Server):
                 stderr=[traceback.format_exc()],
             )
 
-    # Composio wrappers
-    @staticmethod
-    def get_composio_client(api_key: Optional[str] = None):
-        if api_key:
-            return Composio(api_key=api_key)
-        elif tool_settings.composio_api_key:
-            return Composio(api_key=tool_settings.composio_api_key)
-        else:
-            return Composio()
-
-    @staticmethod
-    def get_composio_apps(api_key: Optional[str] = None) -> List["AppModel"]:
-        """Get a list of all Composio apps with actions"""
-        apps = SyncServer.get_composio_client(api_key=api_key).apps.get()
-        apps_with_actions = []
-        for app in apps:
-            # A bit of hacky logic until composio patches this
-            if app.meta["actionsCount"] > 0 and not app.name.lower().endswith("_beta"):
-                apps_with_actions.append(app)
-
-        return apps_with_actions
-
-    def get_composio_actions_from_app_name(self, composio_app_name: str, api_key: Optional[str] = None) -> List["ActionModel"]:
-        actions = self.get_composio_client(api_key=api_key).actions.get(apps=[composio_app_name])
-        # Filter out deprecated composio actions
-        return [action for action in actions if "deprecated" not in action.description.lower()]
-
     # MCP wrappers
     # TODO support both command + SSE servers (via config)
     def get_mcp_servers(self) -> dict[str, Union[SSEServerConfig, StdioServerConfig]]:
@@ -2055,7 +1324,7 @@ class SyncServer(Server):
     async def get_tools_from_mcp_server(self, mcp_server_name: str) -> List[MCPTool]:
         """List the tools in an MCP server. Requires a client to be created."""
         if mcp_server_name not in self.mcp_clients:
-            raise ValueError(f"No client was created for MCP server: {mcp_server_name}")
+            raise LettaInvalidArgumentError(f"No client was created for MCP server: {mcp_server_name}", argument_name="mcp_server_name")
 
         tools = await self.mcp_clients[mcp_server_name].list_tools()
         # Add health information to each tool
@@ -2087,11 +1356,13 @@ class SyncServer(Server):
         except Exception as e:
             # Raise an error telling the user to fix the config file
             logger.error(f"Failed to parse MCP config file at {mcp_config_path}: {e}")
-            raise ValueError(f"Failed to parse MCP config file {mcp_config_path}")
+            raise LettaInvalidArgumentError(f"Failed to parse MCP config file {mcp_config_path}")
 
         # Check if the server name is already in the config
         if server_config.server_name in current_mcp_servers and not allow_upsert:
-            raise ValueError(f"Server name {server_config.server_name} is already in the config file")
+            raise LettaInvalidArgumentError(
+                f"Server name {server_config.server_name} is already in the config file", argument_name="server_name"
+            )
 
         # Attempt to initialize the connection to the server
         if server_config.type == MCPServerType.SSE:
@@ -2099,7 +1370,7 @@ class SyncServer(Server):
         elif server_config.type == MCPServerType.STDIO:
             new_mcp_client = AsyncStdioMCPClient(server_config)
         else:
-            raise ValueError(f"Invalid MCP server config: {server_config}")
+            raise LettaInvalidArgumentError(f"Invalid MCP server config: {server_config}", argument_name="server_config")
         try:
             await new_mcp_client.connect_to_server()
         except:
@@ -2124,7 +1395,7 @@ class SyncServer(Server):
                 json.dump(new_mcp_file, f, indent=4)
         except Exception as e:
             logger.error(f"Failed to write MCP config file at {mcp_config_path}: {e}")
-            raise ValueError(f"Failed to write MCP config file {mcp_config_path}")
+            raise LettaInvalidArgumentError(f"Failed to write MCP config file {mcp_config_path}")
 
         return list(current_mcp_servers.values())
 
@@ -2147,12 +1418,12 @@ class SyncServer(Server):
         except Exception as e:
             # Raise an error telling the user to fix the config file
             logger.error(f"Failed to parse MCP config file at {mcp_config_path}: {e}")
-            raise ValueError(f"Failed to parse MCP config file {mcp_config_path}")
+            raise LettaInvalidArgumentError(f"Failed to parse MCP config file {mcp_config_path}")
 
         # Check if the server name is already in the config
         # If it's not, throw an error
         if server_name not in current_mcp_servers:
-            raise ValueError(f"Server name {server_name} not found in MCP config file")
+            raise LettaInvalidArgumentError(f"Server name {server_name} not found in MCP config file", argument_name="server_name")
 
         # Remove from the server file
         del current_mcp_servers[server_name]
@@ -2164,7 +1435,7 @@ class SyncServer(Server):
                 json.dump(new_mcp_file, f, indent=4)
         except Exception as e:
             logger.error(f"Failed to write MCP config file at {mcp_config_path}: {e}")
-            raise ValueError(f"Failed to write MCP config file {mcp_config_path}")
+            raise LettaInvalidArgumentError(f"Failed to write MCP config file {mcp_config_path}")
 
         return list(current_mcp_servers.values())
 
@@ -2226,7 +1497,9 @@ class SyncServer(Server):
             )
             streaming_interface = letta_agent.interface
             if not isinstance(streaming_interface, StreamingServerInterface):
-                raise ValueError(f"Agent has wrong type of interface: {type(streaming_interface)}")
+                raise LettaInvalidArgumentError(
+                    f"Agent has wrong type of interface: {type(streaming_interface)}", argument_name="interface"
+                )
 
             # Enable token-streaming within the request if desired
             streaming_interface.streaming_mode = stream_tokens
@@ -2331,7 +1604,7 @@ class SyncServer(Server):
     ) -> Union[StreamingResponse, LettaResponse]:
         include_final_message = True
         if not stream_steps and stream_tokens:
-            raise ValueError("stream_steps must be 'true' if stream_tokens is 'true'")
+            raise LettaInvalidArgumentError("stream_steps must be 'true' if stream_tokens is 'true'", argument_name="stream_steps")
 
         group = await self.group_manager.retrieve_group_async(group_id=group_id, actor=actor)
         agent_state_id = group.manager_agent_id or (group.agent_ids[0] if len(group.agent_ids) > 0 else None)
@@ -2357,7 +1630,7 @@ class SyncServer(Server):
         )
         streaming_interface = letta_multi_agent.interface
         if not isinstance(streaming_interface, StreamingServerInterface):
-            raise ValueError(f"Agent has wrong type of interface: {type(streaming_interface)}")
+            raise LettaInvalidArgumentError(f"Agent has wrong type of interface: {type(streaming_interface)}", argument_name="interface")
         streaming_interface.streaming_mode = stream_tokens
         streaming_interface.streaming_chat_completion_mode = chat_completion_mode
         if metadata and hasattr(streaming_interface, "metadata"):