letta-nightly 0.7.4.dev20250424184820__py3-none-any.whl → 0.7.5.dev20250425104208__py3-none-any.whl

letta/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.7.4"
+__version__ = "0.7.5"
 
 # import clients
 from letta.client.client import LocalClient, RESTClient, create_client

letta/agent.py

@@ -190,16 +190,15 @@ class Agent(BaseAgent):
         Returns:
             modified (bool): whether the memory was updated
         """
-        if self.agent_state.memory.compile() != new_memory.compile():
+        system_message = self.message_manager.get_message_by_id(message_id=self.agent_state.message_ids[0], actor=self.user)
+        if new_memory.compile() not in system_message.content[0].text:
             # update the blocks (LRW) in the DB
             for label in self.agent_state.memory.list_block_labels():
                 updated_value = new_memory.get_block(label).value
                 if updated_value != self.agent_state.memory.get_block(label).value:
                     # update the block if it's changed
                     block_id = self.agent_state.memory.get_block(label).id
-                    block = self.block_manager.update_block(
-                        block_id=block_id, block_update=BlockUpdate(value=updated_value), actor=self.user
-                    )
+                    self.block_manager.update_block(block_id=block_id, block_update=BlockUpdate(value=updated_value), actor=self.user)
 
             # refresh memory from DB (using block ids)
             self.agent_state.memory = Memory(

letta/schemas/providers.py

@@ -1233,7 +1233,10 @@ class AzureProvider(Provider):
         """
         This is hardcoded for now, since there is no API endpoints to retrieve metadata for a model.
         """
-        return AZURE_MODEL_TO_CONTEXT_LENGTH.get(model_name, 4096)
+        context_window = AZURE_MODEL_TO_CONTEXT_LENGTH.get(model_name, None)
+        if context_window is None:
+            context_window = LLM_MAX_TOKENS.get(model_name, 4096)
+        return context_window
 
 
 class VLLMChatCompletionsProvider(Provider):

letta/server/rest_api/routers/v1/agents.py

@@ -104,6 +104,17 @@ def list_agents(
     )
 
 
+@router.get("/count", response_model=int, operation_id="count_agents")
+def count_agents(
+    server: SyncServer = Depends(get_letta_server),
+    actor_id: Optional[str] = Header(None, alias="user_id"),
+):
+    """
+    Get the count of all agents associated with a given user.
+    """
+    return server.agent_manager.size(actor=server.user_manager.get_user_or_default(user_id=actor_id))
+
+
 class IndentedORJSONResponse(Response):
     media_type = "application/json"
 

letta/server/rest_api/routers/v1/identities.py

@@ -49,6 +49,24 @@ def list_identities(
     return identities
 
 
+@router.get("/count", tags=["identities"], response_model=int, operation_id="count_identities")
+def count_identities(
+    server: "SyncServer" = Depends(get_letta_server),
+    actor_id: Optional[str] = Header(None, alias="user_id"),
+):
+    """
+    Get count of all identities for a user
+    """
+    try:
+        return server.identity_manager.size(actor=server.user_manager.get_user_or_default(user_id=actor_id))
+    except NoResultFound:
+        return 0
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"{e}")
+
+
 @router.get("/{identity_id}", tags=["identities"], response_model=Identity, operation_id="retrieve_identity")
 def retrieve_identity(
     identity_id: str,

letta/server/rest_api/routers/v1/sources.py

@@ -67,6 +67,17 @@ def list_sources(
     return server.list_all_sources(actor=actor)
 
 
+@router.get("/count", response_model=int, operation_id="count_sources")
+def count_sources(
+    server: "SyncServer" = Depends(get_letta_server),
+    actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
+):
+    """
+    Count all data sources created by a user.
+    """
+    return server.source_manager.size(actor=server.user_manager.get_user_or_default(user_id=actor_id))
+
+
 @router.post("/", response_model=Source, operation_id="create_source")
 def create_source(
     source_create: SourceCreate,

letta/server/rest_api/routers/v1/tools.py

@@ -80,6 +80,21 @@ def list_tools(
         raise HTTPException(status_code=500, detail=str(e))
 
 
+@router.get("/count", response_model=int, operation_id="count_tools")
+def count_tools(
+    server: SyncServer = Depends(get_letta_server),
+    actor_id: Optional[str] = Header(None, alias="user_id"),
+):
+    """
+    Get a count of all tools available to agents belonging to the org of the user
+    """
+    try:
+        return server.tool_manager.size(actor=server.user_manager.get_user_or_default(user_id=actor_id))
+    except Exception as e:
+        print(f"Error occurred: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
 @router.post("/", response_model=Tool, operation_id="create_tool")
 def create_tool(
     request: ToolCreate = Body(...),

letta/server/server.py

@@ -1308,14 +1308,12 @@ class SyncServer(Server):
             tool_execution_result = ToolExecutionSandbox(tool.name, tool_args, actor, tool_object=tool).run(
                 agent_state=agent_state, additional_env_vars=tool_env_vars
             )
-            status = "error" if tool_execution_result.stderr else "success"
-            tool_return = str(tool_execution_result.stderr) if tool_execution_result.stderr else str(tool_execution_result.func_return)
             return ToolReturnMessage(
                 id="null",
                 tool_call_id="null",
                 date=get_utc_time(),
-                status=status,
-                tool_return=tool_return,
+                status=tool_execution_result.status,
+                tool_return=str(tool_execution_result.func_return),
                 stdout=tool_execution_result.stdout,
                 stderr=tool_execution_result.stderr,
             )

letta/services/agent_manager.py

@@ -556,6 +556,16 @@ class AgentManager:
 
             return list(session.execute(query).scalars())
 
+    def size(
+        self,
+        actor: PydanticUser,
+    ) -> int:
+        """
+        Get the total count of agents for the given user.
+        """
+        with self.session_maker() as session:
+            return AgentModel.size(db_session=session, actor=actor)
+
     @enforce_types
     def get_agent_by_id(self, agent_id: str, actor: PydanticUser) -> PydanticAgentState:
         """Fetch an agent by its ID."""
@@ -590,15 +600,18 @@ class AgentManager:
             agents_to_delete = [agent]
             sleeptime_group_to_delete = None
 
-            # Delete sleeptime agent and group
+            # Delete sleeptime agent and group (TODO this is flimsy pls fix)
             if agent.multi_agent_group:
                 participant_agent_ids = agent.multi_agent_group.agent_ids
                 if agent.multi_agent_group.manager_type == ManagerType.sleeptime and len(participant_agent_ids) == 1:
-                    sleeptime_agent = AgentModel.read(db_session=session, identifier=participant_agent_ids[0], actor=actor)
-                    if sleeptime_agent.agent_type == AgentType.sleeptime_agent:
-                        sleeptime_agent_group = GroupModel.read(db_session=session, identifier=agent.multi_agent_group.id, actor=actor)
-                        sleeptime_group_to_delete = sleeptime_agent_group
+                    try:
+                        sleeptime_agent = AgentModel.read(db_session=session, identifier=participant_agent_ids[0], actor=actor)
                         agents_to_delete.append(sleeptime_agent)
+                    except NoResultFound:
+                        pass  # agent already deleted
+                    sleeptime_agent_group = GroupModel.read(db_session=session, identifier=agent.multi_agent_group.id, actor=actor)
+                    sleeptime_group_to_delete = sleeptime_agent_group
+
             try:
                 if sleeptime_group_to_delete is not None:
                     session.delete(sleeptime_group_to_delete)
@@ -931,7 +944,8 @@ class AgentManager:
             modified (bool): whether the memory was updated
         """
         agent_state = self.get_agent_by_id(agent_id=agent_id, actor=actor)
-        if agent_state.memory.compile() != new_memory.compile():
+        system_message = self.message_manager.get_message_by_id(message_id=agent_state.message_ids[0], actor=actor)
+        if new_memory.compile() not in system_message.content[0].text:
             # update the blocks (LRW) in the DB
             for label in agent_state.memory.list_block_labels():
                 updated_value = new_memory.get_block(label).value

letta/services/identity_manager.py

@@ -190,6 +190,17 @@ class IdentityManager:
             session.delete(identity)
             session.commit()
 
+    @enforce_types
+    def size(
+        self,
+        actor: PydanticUser,
+    ) -> int:
+        """
+        Get the total count of identities for the given user.
+        """
+        with self.session_maker() as session:
+            return IdentityModel.size(db_session=session, actor=actor)
+
     def _process_relationship(
         self,
         session: Session,

letta/services/mcp/base_client.py

@@ -0,0 +1,67 @@
+from contextlib import AsyncExitStack
+from typing import Optional, Tuple
+
+from mcp import ClientSession
+from mcp import Tool as MCPTool
+from mcp.types import TextContent
+
+from letta.functions.mcp_client.types import BaseServerConfig
+from letta.log import get_logger
+
+logger = get_logger(__name__)
+
+
+# TODO: Get rid of Async prefix on this class name once we deprecate old sync code
+class AsyncBaseMCPClient:
+    def __init__(self, server_config: BaseServerConfig):
+        self.server_config = server_config
+        self.exit_stack = AsyncExitStack()
+        self.session: Optional[ClientSession] = None
+        self.initialized = False
+
+    async def connect_to_server(self):
+        try:
+            await self._initialize_connection(self.server_config)
+            await self.session.initialize()
+            self.initialized = True
+        except Exception as e:
+            logger.error(
+                f"Connecting to MCP server failed. Please review your server config: {self.server_config.model_dump_json(indent=4)}"
+            )
+            raise e
+
+    async def _initialize_connection(self, exit_stack: AsyncExitStack[bool | None], server_config: BaseServerConfig) -> None:
+        raise NotImplementedError("Subclasses must implement _initialize_connection")
+
+    async def list_tools(self) -> list[MCPTool]:
+        self._check_initialized()
+        response = await self.session.list_tools()
+        return response.tools
+
+    async def execute_tool(self, tool_name: str, tool_args: dict) -> Tuple[str, bool]:
+        self._check_initialized()
+        result = await self.session.call_tool(tool_name, tool_args)
+        parsed_content = []
+        for content_piece in result.content:
+            if isinstance(content_piece, TextContent):
+                parsed_content.append(content_piece.text)
+                print("parsed_content (text)", parsed_content)
+            else:
+                parsed_content.append(str(content_piece))
+                print("parsed_content (other)", parsed_content)
+        if len(parsed_content) > 0:
+            final_content = " ".join(parsed_content)
+        else:
+            # TODO move hardcoding to constants
+            final_content = "Empty response from tool"
+
+        return final_content, result.isError
+
+    def _check_initialized(self):
+        if not self.initialized:
+            logger.error("MCPClient has not been initialized")
+            raise RuntimeError("MCPClient has not been initialized")
+
+    async def cleanup(self):
+        """Clean up resources"""
+        await self.exit_stack.aclose()

letta/services/mcp/sse_client.py

@@ -0,0 +1,25 @@
+from contextlib import AsyncExitStack
+
+from mcp import ClientSession
+from mcp.client.sse import sse_client
+
+from letta.functions.mcp_client.types import SSEServerConfig
+from letta.log import get_logger
+from letta.services.mcp.base_client import AsyncBaseMCPClient
+
+# see: https://modelcontextprotocol.io/quickstart/user
+MCP_CONFIG_TOPLEVEL_KEY = "mcpServers"
+
+logger = get_logger(__name__)
+
+
+# TODO: Get rid of Async prefix on this class name once we deprecate old sync code
+class AsyncSSEMCPClient(AsyncBaseMCPClient):
+    async def _initialize_connection(self, exit_stack: AsyncExitStack[bool | None], server_config: SSEServerConfig) -> None:
+        sse_cm = sse_client(url=server_config.server_url)
+        sse_transport = await exit_stack.enter_async_context(sse_cm)
+        self.stdio, self.write = sse_transport
+
+        # Create and enter the ClientSession context manager
+        session_cm = ClientSession(self.stdio, self.write)
+        self.session = await exit_stack.enter_async_context(session_cm)

letta/services/mcp/stdio_client.py

@@ -0,0 +1,19 @@
+from contextlib import AsyncExitStack
+
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+
+from letta.functions.mcp_client.types import StdioServerConfig
+from letta.log import get_logger
+from letta.services.mcp.base_client import AsyncBaseMCPClient
+
+logger = get_logger(__name__)
+
+
+# TODO: Get rid of Async prefix on this class name once we deprecate old sync code
+class AsyncStdioMCPClient(AsyncBaseMCPClient):
+    async def _initialize_connection(self, exit_stack: AsyncExitStack[bool | None], server_config: StdioServerConfig) -> None:
+        server_params = StdioServerParameters(command=server_config.command, args=server_config.args)
+        stdio_transport = await exit_stack.enter_async_context(stdio_client(server_params))
+        self.stdio, self.write = stdio_transport
+        self.session = await exit_stack.enter_async_context(ClientSession(self.stdio, self.write))

letta/services/mcp/types.py

@@ -0,0 +1,48 @@
+from enum import Enum
+from typing import List, Optional
+
+from mcp import Tool
+from pydantic import BaseModel, Field
+
+
+class MCPTool(Tool):
+    """A simple wrapper around MCP's tool definition (to avoid conflict with our own)"""
+
+
+class MCPServerType(str, Enum):
+    SSE = "sse"
+    STDIO = "stdio"
+
+
+class BaseServerConfig(BaseModel):
+    server_name: str = Field(..., description="The name of the server")
+    type: MCPServerType
+
+
+class SSEServerConfig(BaseServerConfig):
+    type: MCPServerType = MCPServerType.SSE
+    server_url: str = Field(..., description="The URL of the server (MCP SSE client will connect to this URL)")
+
+    def to_dict(self) -> dict:
+        values = {
+            "transport": "sse",
+            "url": self.server_url,
+        }
+        return values
+
+
+class StdioServerConfig(BaseServerConfig):
+    type: MCPServerType = MCPServerType.STDIO
+    command: str = Field(..., description="The command to run (MCP 'local' client will run this command)")
+    args: List[str] = Field(..., description="The arguments to pass to the command")
+    env: Optional[dict[str, str]] = Field(None, description="Environment variables to set")
+
+    def to_dict(self) -> dict:
+        values = {
+            "transport": "stdio",
+            "command": self.command,
+            "args": self.args,
+        }
+        if self.env is not None:
+            values["env"] = self.env
+        return values

letta/services/source_manager.py

@@ -77,6 +77,17 @@ class SourceManager:
             )
             return [source.to_pydantic() for source in sources]
 
+    @enforce_types
+    def size(
+        self,
+        actor: PydanticUser,
+    ) -> int:
+        """
+        Get the total count of sources for the given user.
+        """
+        with self.session_maker() as session:
+            return SourceModel.size(db_session=session, actor=actor)
+
     @enforce_types
     def list_attached_agents(self, source_id: str, actor: Optional[PydanticUser] = None) -> List[PydanticAgentState]:
         """

letta/services/tool_executor/tool_execution_sandbox.py

@@ -1,10 +1,12 @@
 import ast
 import base64
+import io
 import os
 import pickle
 import subprocess
 import sys
 import tempfile
+import traceback
 import uuid
 from typing import Any, Dict, Optional
 
@@ -117,98 +119,108 @@ class ToolExecutionSandbox:
 
     @trace_method
     def run_local_dir_sandbox(
-        self,
-        agent_state: Optional[AgentState] = None,
-        additional_env_vars: Optional[Dict] = None,
+        self, agent_state: Optional[AgentState] = None, additional_env_vars: Optional[Dict] = None
     ) -> ToolExecutionResult:
-        sbx_config = self.sandbox_config_manager.get_or_create_default_sandbox_config(
-            sandbox_type=SandboxType.LOCAL,
-            actor=self.user,
-        )
+        sbx_config = self.sandbox_config_manager.get_or_create_default_sandbox_config(sandbox_type=SandboxType.LOCAL, actor=self.user)
         local_configs = sbx_config.get_local_config()
-        sandbox_dir = os.path.expanduser(local_configs.sandbox_dir)
-        venv_path = os.path.join(sandbox_dir, local_configs.venv_name)
 
-        # Aggregate environment variables
+        # Get environment variables for the sandbox
         env = os.environ.copy()
-        env.update(self.sandbox_config_manager.get_sandbox_env_vars_as_dict(sandbox_config_id=sbx_config.id, actor=self.user, limit=100))
+        env_vars = self.sandbox_config_manager.get_sandbox_env_vars_as_dict(sandbox_config_id=sbx_config.id, actor=self.user, limit=100)
+        env.update(env_vars)
+
+        # Get environment variables for this agent specifically
         if agent_state:
             env.update(agent_state.get_agent_env_vars_as_dict())
+
+        # Finally, get any that are passed explicitly into the `run` function call
         if additional_env_vars:
             env.update(additional_env_vars)
 
-        # Ensure sandbox dir exists
-        if not os.path.exists(sandbox_dir):
-            logger.warning(f"Sandbox directory does not exist, creating: {sandbox_dir}")
-            os.makedirs(sandbox_dir)
+        # Safety checks
+        if not os.path.exists(local_configs.sandbox_dir) or not os.path.isdir(local_configs.sandbox_dir):
+            logger.warning(f"Sandbox directory does not exist, creating: {local_configs.sandbox_dir}")
+            os.makedirs(local_configs.sandbox_dir)
+
+        # Write the code to a temp file in the sandbox_dir
+        with tempfile.NamedTemporaryFile(mode="w", dir=local_configs.sandbox_dir, suffix=".py", delete=False) as temp_file:
+            if local_configs.force_create_venv:
+                # If using venv, we need to wrap with special string markers to separate out the output and the stdout (since it is all in stdout)
+                code = self.generate_execution_script(agent_state=agent_state, wrap_print_with_markers=True)
+            else:
+                code = self.generate_execution_script(agent_state=agent_state)
 
-        # Write the code to a temp file
-        with tempfile.NamedTemporaryFile(mode="w", dir=sandbox_dir, suffix=".py", delete=False) as temp_file:
-            code = self.generate_execution_script(agent_state=agent_state, wrap_print_with_markers=True)
             temp_file.write(code)
             temp_file.flush()
             temp_file_path = temp_file.name
-
         try:
-            # Decide whether to use venv
-            use_venv = os.path.isdir(venv_path)
-
-            if self.force_recreate_venv or (not use_venv and local_configs.force_create_venv):
-                logger.warning(f"Virtual environment not found at {venv_path}. Creating one...")
-                log_event(name="start create_venv_for_local_sandbox", attributes={"venv_path": venv_path})
-                create_venv_for_local_sandbox(
-                    sandbox_dir_path=sandbox_dir,
-                    venv_path=venv_path,
-                    env=env,
-                    force_recreate=self.force_recreate_venv,
-                )
-                log_event(name="finish create_venv_for_local_sandbox")
-                use_venv = True
-
-            if use_venv:
-                log_event(name="start install_pip_requirements_for_sandbox", attributes={"local_configs": local_configs.model_dump_json()})
-                install_pip_requirements_for_sandbox(local_configs, env=env)
-                log_event(name="finish install_pip_requirements_for_sandbox", attributes={"local_configs": local_configs.model_dump_json()})
-
-                python_executable = find_python_executable(local_configs)
-                if not os.path.isfile(python_executable):
-                    logger.warning(
-                        f"Python executable not found at expected venv path: {python_executable}. Falling back to system Python."
-                    )
-                    python_executable = sys.executable
-                else:
-                    env = dict(env)
-                    env["VIRTUAL_ENV"] = venv_path
-                    env["PATH"] = os.path.join(venv_path, "bin") + ":" + env.get("PATH", "")
+            if local_configs.force_create_venv:
+                return self.run_local_dir_sandbox_venv(sbx_config, env, temp_file_path)
             else:
-                python_executable = sys.executable
+                return self.run_local_dir_sandbox_directly(sbx_config, env, temp_file_path)
+        except Exception as e:
+            logger.error(f"Executing tool {self.tool_name} has an unexpected error: {e}")
+            logger.error(f"Logging out tool {self.tool_name} auto-generated code for debugging: \n\n{code}")
+            raise e
+        finally:
+            # Clean up the temp file
+            os.remove(temp_file_path)
+
+    @trace_method
+    def run_local_dir_sandbox_venv(
+        self,
+        sbx_config: SandboxConfig,
+        env: Dict[str, str],
+        temp_file_path: str,
+    ) -> ToolExecutionResult:
+        local_configs = sbx_config.get_local_config()
+        sandbox_dir = os.path.expanduser(local_configs.sandbox_dir)  # Expand tilde
+        venv_path = os.path.join(sandbox_dir, local_configs.venv_name)
+
+        # Recreate venv if required
+        if self.force_recreate_venv or not os.path.isdir(venv_path):
+            logger.warning(f"Virtual environment directory does not exist at: {venv_path}, creating one now...")
+            log_event(name="start create_venv_for_local_sandbox", attributes={"venv_path": venv_path})
+            create_venv_for_local_sandbox(
+                sandbox_dir_path=sandbox_dir, venv_path=venv_path, env=env, force_recreate=self.force_recreate_venv
+            )
+            log_event(name="finish create_venv_for_local_sandbox")
+
+        log_event(name="start install_pip_requirements_for_sandbox", attributes={"local_configs": local_configs.model_dump_json()})
+        install_pip_requirements_for_sandbox(local_configs, env=env)
+        log_event(name="finish install_pip_requirements_for_sandbox", attributes={"local_configs": local_configs.model_dump_json()})
+
+        # Ensure Python executable exists
+        python_executable = find_python_executable(local_configs)
+        if not os.path.isfile(python_executable):
+            raise FileNotFoundError(f"Python executable not found in virtual environment: {python_executable}")
 
-            env["PYTHONWARNINGS"] = "ignore"
+        # Set up environment variables
+        env["VIRTUAL_ENV"] = venv_path
+        env["PATH"] = os.path.join(venv_path, "bin") + ":" + env["PATH"]
+        env["PYTHONWARNINGS"] = "ignore"
 
+        # Execute the code
+        try:
             log_event(name="start subprocess")
             result = subprocess.run(
-                [python_executable, temp_file_path],
-                env=env,
-                cwd=sandbox_dir,
-                timeout=60,
-                capture_output=True,
-                text=True,
+                [python_executable, temp_file_path], env=env, cwd=sandbox_dir, timeout=60, capture_output=True, text=True, check=True
             )
             log_event(name="finish subprocess")
             func_result, stdout = self.parse_out_function_results_markers(result.stdout)
-            func_return, parsed_agent_state = self.parse_best_effort(func_result)
+            func_return, agent_state = self.parse_best_effort(func_result)
 
             return ToolExecutionResult(
                 status="success",
                 func_return=func_return,
-                agent_state=parsed_agent_state,
+                agent_state=agent_state,
                 stdout=[stdout] if stdout else [],
                 stderr=[result.stderr] if result.stderr else [],
                 sandbox_config_fingerprint=sbx_config.fingerprint(),
             )
 
         except subprocess.CalledProcessError as e:
-            logger.error(f"Tool execution failed: {e}")
+            logger.error(f"Executing tool {self.tool_name} has process error: {e}")
             func_return = get_friendly_error_msg(
                 function_name=self.tool_name,
                 exception_name=type(e).__name__,
@@ -228,11 +240,72 @@ class ToolExecutionSandbox:
 
         except Exception as e:
             logger.error(f"Executing tool {self.tool_name} has an unexpected error: {e}")
-            logger.error(f"Generated script:\n{code}")
             raise e
 
-        finally:
-            os.remove(temp_file_path)
+    @trace_method
+    def run_local_dir_sandbox_directly(
+        self,
+        sbx_config: SandboxConfig,
+        env: Dict[str, str],
+        temp_file_path: str,
+    ) -> ToolExecutionResult:
+        status = "success"
+        func_return, agent_state, stderr = None, None, None
+
+        old_stdout = sys.stdout
+        old_stderr = sys.stderr
+        captured_stdout, captured_stderr = io.StringIO(), io.StringIO()
+
+        sys.stdout = captured_stdout
+        sys.stderr = captured_stderr
+
+        try:
+            with self.temporary_env_vars(env):
+
+                # Read and compile the Python script
+                with open(temp_file_path, "r", encoding="utf-8") as f:
+                    source = f.read()
+                code_obj = compile(source, temp_file_path, "exec")
+
+                # Provide a dict for globals.
+                globals_dict = dict(env)  # or {}
+                # If you need to mimic `__main__` behavior:
+                globals_dict["__name__"] = "__main__"
+                globals_dict["__file__"] = temp_file_path
+
+                # Execute the compiled code
+                log_event(name="start exec", attributes={"temp_file_path": temp_file_path})
+                exec(code_obj, globals_dict)
+                log_event(name="finish exec", attributes={"temp_file_path": temp_file_path})
+
+                # Get result from the global dict
+                func_result = globals_dict.get(self.LOCAL_SANDBOX_RESULT_VAR_NAME)
+                func_return, agent_state = self.parse_best_effort(func_result)
+
+        except Exception as e:
+            func_return = get_friendly_error_msg(
+                function_name=self.tool_name,
+                exception_name=type(e).__name__,
+                exception_message=str(e),
+            )
+            traceback.print_exc(file=sys.stderr)
+            status = "error"
+
+        # Restore stdout/stderr
+        sys.stdout = old_stdout
+        sys.stderr = old_stderr
+
+        stdout_output = [captured_stdout.getvalue()] if captured_stdout.getvalue() else []
+        stderr_output = [captured_stderr.getvalue()] if captured_stderr.getvalue() else []
+
+        return ToolExecutionResult(
+            status=status,
+            func_return=func_return,
+            agent_state=agent_state,
+            stdout=stdout_output,
+            stderr=stderr_output,
+            sandbox_config_fingerprint=sbx_config.fingerprint(),
+        )
 
     def parse_out_function_results_markers(self, text: str):
         if self.LOCAL_SANDBOX_RESULT_START_MARKER not in text:

letta/services/tool_manager.py

@@ -145,6 +145,17 @@ class ToolManager:
 
         return results
 
+    @enforce_types
+    def size(
+        self,
+        actor: PydanticUser,
+    ) -> int:
+        """
+        Get the total count of tools for the given user.
+        """
+        with self.session_maker() as session:
+            return ToolModel.size(db_session=session, actor=actor)
+
     @enforce_types
     def update_tool_by_id(self, tool_id: str, tool_update: ToolUpdate, actor: PydanticUser) -> PydanticTool:
         """Update a tool by its ID with the given ToolUpdate object."""

{letta_nightly-0.7.4.dev20250424184820.dist-info → letta_nightly-0.7.5.dev20250425104208.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.7.4.dev20250424184820
+Version: 0.7.5.dev20250425104208
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team

{letta_nightly-0.7.4.dev20250424184820.dist-info → letta_nightly-0.7.5.dev20250425104208.dist-info}/RECORD

@@ -1,6 +1,6 @@
-letta/__init__.py,sha256=syDK9U6HGmZVN3Corz6hxHnV1EA-JVL--ta6nFa6z5s,917
+letta/__init__.py,sha256=bAqRCwvutm5LP1C2uuuUcODc0u_yqtCtac7CL9bi61k,917
 letta/__main__.py,sha256=6Hs2PV7EYc5Tid4g4OtcLXhqVHiNYTGzSBdoOnW2HXA,29
-letta/agent.py,sha256=YmAkpFXHwZ0UhoatyIE-ZrV-kQDwg7f4A1o4cymoI-Y,72170
+letta/agent.py,sha256=VCTvaT0skG1uj7s76GVEMKge9Q0ranjajlQtpjST4iw,72242
 letta/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/agents/base_agent.py,sha256=yjB1Yz6L-9hTFinqkvyf6c-8dDX9O4u8VCrKrvA4G3s,2348
 letta/agents/ephemeral_agent.py,sha256=el-SUF_16vv_7OouIR-6z0pAE9Yc0PLibygvfCKwqfo,2736
@@ -221,7 +221,7 @@ letta/schemas/openai/embedding_response.py,sha256=WKIZpXab1Av7v6sxKG8feW3ZtpQUNo
 letta/schemas/openai/openai.py,sha256=Hilo5BiLAGabzxCwnwfzK5QrWqwYD8epaEKFa4Pwndk,7970
 letta/schemas/organization.py,sha256=TXrHN4IBQnX-mWvRuCOH57XZSLYCVOY0wWm2_UzDQIA,1279
 letta/schemas/passage.py,sha256=RG0vkaewEu4a_NAZM-FVyMammHjqpPP0RDYAdu27g6A,3723
-letta/schemas/providers.py,sha256=lUz9QvMm_-wUUJZ5OGRsefsora0Y_55s3xQwnzL8gOw,51643
+letta/schemas/providers.py,sha256=6TyGvmfAT-bgmYblfjheQ3Ki4gGxVCFfC5Lt8D3X4qc,51784
 letta/schemas/response_format.py,sha256=pXNsjbtpA3Tf8HsDyIa40CSmoUbVR_7n2WOfQaX4aFs,2204
 letta/schemas/run.py,sha256=SRqPRziINIiPunjOhE_NlbnQYgxTvqmbauni_yfBQRA,2085
 letta/schemas/sandbox_config.py,sha256=Uu_GDofZasycarUVjXB1tL5-X1pLXSsrCB_7XycRIuM,6011
@@ -258,11 +258,11 @@ letta/server/rest_api/routers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5N
 letta/server/rest_api/routers/openai/chat_completions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/server/rest_api/routers/openai/chat_completions/chat_completions.py,sha256=Ksh_F6hJDOrafY2Gxz7NQdQZXBNeX-3-w4mVEQgMhrQ,5327
 letta/server/rest_api/routers/v1/__init__.py,sha256=M-L-Ls4rQaVyQvMjFNEu3NhcRLCvsbOKI-l7F4JxifQ,1557
-letta/server/rest_api/routers/v1/agents.py,sha256=Tn6IXvC0Pd03q62AleKHbQm1nv06734sYA-pelYcrPo,34289
+letta/server/rest_api/routers/v1/agents.py,sha256=3mbPzEKBCzJmpUBUmJrs1WbmkIGTjEJ32HNUb1Lo5_M,34676
 letta/server/rest_api/routers/v1/blocks.py,sha256=Sefvon0jLvlNh0oAzntUcDZptnutuJOf-2Wcad_45Dg,4169
 letta/server/rest_api/routers/v1/groups.py,sha256=sLXkw8kgf9fhaQwb-n0SVbyzH6-e1kdzNuqGbdvPPgo,10890
 letta/server/rest_api/routers/v1/health.py,sha256=MoOjkydhGcJXTiuJrKIB0etVXiRMdTa51S8RQ8-50DQ,399
-letta/server/rest_api/routers/v1/identities.py,sha256=iH1OAOHHu1DTrQBSJpU0DfpXrPHjbpETKrRLUepDh7w,6877
+letta/server/rest_api/routers/v1/identities.py,sha256=fvp-0cwvb4iX1fUGPkL--9nq8YD3tIE47kYRxUgOlp4,7462
 letta/server/rest_api/routers/v1/jobs.py,sha256=4oeJfI2odNGubU_g7WSORJhn_usFsbRaD-qm86rve1E,2746
 letta/server/rest_api/routers/v1/llms.py,sha256=lYp5URXtZk1yu_Pe-p1Wq1uQ0qeb6aWtx78rXSB7N_E,881
 letta/server/rest_api/routers/v1/messages.py,sha256=3hfaiiCBiWr-wub_uzr3Vyh4IBTZYwGqeDG-2h6Xlus,5753
@@ -270,15 +270,15 @@ letta/server/rest_api/routers/v1/organizations.py,sha256=r7rj-cA3shgAgM0b2JCMqjY
 letta/server/rest_api/routers/v1/providers.py,sha256=MVfAUvXj_2jx8XFwSigM-8CuCfEATW60h8J5UEmAhp0,3146
 letta/server/rest_api/routers/v1/runs.py,sha256=9nuJRjBtRgZPq3CiCEUA_3S2xPHFP5DsJxIenH5OO34,8847
 letta/server/rest_api/routers/v1/sandbox_configs.py,sha256=9hqnnMwJ3wCwO-Bezu3Xl8i3TDSIuInw3gSeHaKUXfE,8526
-letta/server/rest_api/routers/v1/sources.py,sha256=igrT2w2fkwMDhw8LZMjRug00YG5mYg08C6ZLpRHeYq4,10270
+letta/server/rest_api/routers/v1/sources.py,sha256=U9cf7DlqKAvXgNnmyOvr2XLBHiJbimFCQw__gV__HV8,10709
 letta/server/rest_api/routers/v1/steps.py,sha256=DVVwaxLNbNAgWpr2oQkrNjdS-wi0bP8kVJZUO-hiaf8,3275
 letta/server/rest_api/routers/v1/tags.py,sha256=coydgvL6-9cuG2Hy5Ea7QY3inhTHlsf69w0tcZenBus,880
-letta/server/rest_api/routers/v1/tools.py,sha256=k_4kSFMsK2WNSmNMclMdu3GrNo-JDqtQxelxG8OfuxQ,18279
+letta/server/rest_api/routers/v1/tools.py,sha256=vDDhG25vQOz3y12XN_dayh4OweW1rjaLHxZJuJgZkQA,18821
 letta/server/rest_api/routers/v1/users.py,sha256=G5DBHSkPfBgVHN2Wkm-rVYiLQAudwQczIq2Z3YLdbVo,2277
 letta/server/rest_api/routers/v1/voice.py,sha256=0lerWjrKLkt4gXLhZl1cIcgstOz9Q2HZwc67L58BCXE,2451
 letta/server/rest_api/static_files.py,sha256=NG8sN4Z5EJ8JVQdj19tkFa9iQ1kBPTab9f_CUxd_u4Q,3143
 letta/server/rest_api/utils.py,sha256=OKUWg7u4vmROVweqRrs83bQvS958bZAoR_bUFDwwqsc,14861
-letta/server/server.py,sha256=lEoFawsNHHa2VI-ipFuYqToi7OgJrVYOLUlNd_CYHqA,79889
+letta/server/server.py,sha256=XcZ_vrQkG2CVr_mgCKVAV6EMVjuR4lQVtU3FTAUJIIc,79726
 letta/server/startup.sh,sha256=MRXh1RKbS5lyA7XAsk7O6Q4LEKOqnv5B-dwe0SnTHeQ,2514
 letta/server/static_files/assets/index-048c9598.js,sha256=mR16XppvselwKCcNgONs4L7kZEVa4OEERm4lNZYtLSk,146819
 letta/server/static_files/assets/index-0e31b727.css,sha256=SBbja96uiQVLDhDOroHgM6NSl7tS4lpJRCREgSS_hA8,7672
@@ -292,30 +292,35 @@ letta/server/ws_api/interface.py,sha256=TWl9vkcMCnLsUtgsuENZ-ku2oMDA-OUTzLh_yNRo
 letta/server/ws_api/protocol.py,sha256=5mDgpfNZn_kNwHnpt5Dsuw8gdNH298sgxTGed3etzYg,1836
 letta/server/ws_api/server.py,sha256=cBSzf-V4zT1bL_0i54OTI3cMXhTIIxqjSRF8pYjk7fg,5835
 letta/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/services/agent_manager.py,sha256=I893THGSJrwQt-NynuY2rUJxTOGVCetIlXdkEZALc7w,71123
+letta/services/agent_manager.py,sha256=9BRBbAf0LXftDzke8OBzVgzOmP1FLCnsRSQggbNxeOU,71581
 letta/services/block_manager.py,sha256=rphbpGBIEDFvCJ5GJt6A1OfbURGFQZ3WardljELQyAc,15225
 letta/services/group_manager.py,sha256=z1woWRRnjkWrGG_auSicXr2bJaJ653JV6PYl2N_AUfw,12224
 letta/services/helpers/agent_manager_helper.py,sha256=57ARg5TcmE_JdrWmhz5uaNHAt1NGlJ3wQH1tP2XOiAs,17825
 letta/services/helpers/tool_execution_helper.py,sha256=E8knHJUP_EKmAzwKx-z-rd5EKjU-oroyPzyElUmq83o,6968
-letta/services/identity_manager.py,sha256=PqnUnM3OGCRnd5NPjGonwYBnYAQK8rpiissdNYUouGU,9389
+letta/services/identity_manager.py,sha256=sjHTCPbLYRDyWCJ3qjcuKZqWqzDoEuslRsDVKQtBraE,9683
 letta/services/job_manager.py,sha256=Z9cSD-IqpiOIWE_UOTBUEIxGITrJ10JT1G3ske-0yIY,17166
 letta/services/llm_batch_manager.py,sha256=jm6MY91hrZdcPOsimSd7Ns3mf0J4SwKV2_ShWXhD02k,16819
+letta/services/mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+letta/services/mcp/base_client.py,sha256=YoRb9eKKTGaLxaMVtuH5UcC74iXyWlcyYbC5xOeGr4k,2571
+letta/services/mcp/sse_client.py,sha256=Vj0AgaadgMnpFQOWkSoPfeOI00ZvURMf3TIU7fv_DN8,1012
+letta/services/mcp/stdio_client.py,sha256=wdPzTqSRkibjt9pXhwi0Nul_z_cTAPim-OHjLc__yBE,925
+letta/services/mcp/types.py,sha256=nmcnQn2EpxXzXg5_pWPsHZobfxO6OucaUgz1bVvam7o,1411
 letta/services/message_manager.py,sha256=iRFFu7WP9GBtGKrQp5Igiqp_wonSfRKZ_Ran5X6SZZA,17946
 letta/services/organization_manager.py,sha256=Ax0KmPSc_YYsYaxeld9gc7ST-J6DemHQ542DD7l7AWA,3989
 letta/services/passage_manager.py,sha256=KY18gHTbx8ROBsOeR7ZAefTMGZwzbxYqOjbadqVFiyQ,9121
 letta/services/per_agent_lock_manager.py,sha256=porM0cKKANQ1FvcGXOO_qM7ARk5Fgi1HVEAhXsAg9-4,546
 letta/services/provider_manager.py,sha256=_gEBW0tYIf2vJEGGYxk-nvogrFI9sjFl_97MSL5WC2s,3759
 letta/services/sandbox_config_manager.py,sha256=ATgZNWNpkdIQDUPy4ABsguHQba2PZf51-c4Ji60MzLE,13361
-letta/services/source_manager.py,sha256=SE24AiPPhpvZMGDD047H3_ZDD7OM4zHbTW1JXjPEv7U,7672
+letta/services/source_manager.py,sha256=yW88wAJoeAWtbg0FxifE352jhgOTKNiG7K-IPKXKnvg,7961
 letta/services/step_manager.py,sha256=B64iYn6Dt9yRKsSJ5vLxWQR2t-apvPLfUZyzrUsJTpI,5335
 letta/services/summarizer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/services/summarizer/enums.py,sha256=szzPX2OBRRJEZsBTGYQThrNz02ELFqhuLwvOR7ozi7A,208
 letta/services/summarizer/summarizer.py,sha256=4rbbzcB_lY4-3ybT8HMxM8OskLC38YCs9n5h0NhWRcY,4988
 letta/services/tool_executor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/services/tool_executor/tool_execution_manager.py,sha256=RcmnwPougb8AxIwKdC4N9ZxTvOQqJyjI6CaVHF2HBi4,4505
-letta/services/tool_executor/tool_execution_sandbox.py,sha256=EMQC25mYf7OxsUNPHFNkbcUZHZvf4QaeO94xenQJv4Y,21450
+letta/services/tool_executor/tool_execution_sandbox.py,sha256=hu-SVqfRalJGcXRKTpbYkqgX-DZH3Uky_eD_vh0kx6s,24704
 letta/services/tool_executor/tool_executor.py,sha256=keWIzQuwqSzcC6kWcbTY_SfclhKtOT5CZNE-r3OBWNk,27372
-letta/services/tool_manager.py,sha256=a5PyLqYDd1H3snWdQGxl-dscMrBHlXcwg6U4T-tc_IM,10276
+letta/services/tool_manager.py,sha256=lFnQkgBYXAXl9q_8_TqJX_UZtLTATXmPliCdm8_7K8M,10561
 letta/services/tool_sandbox/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/services/tool_sandbox/base.py,sha256=pUnPFkEg9I5ktMuT4AOOxbTnTmZTGcTA2phLe1H1EdY,8306
 letta/services/tool_sandbox/e2b_sandbox.py,sha256=umsXfolzM_j67izswECDdVfnlcm03wLpMoZtS6SZ0sc,6147
@@ -327,8 +332,8 @@ letta/streaming_utils.py,sha256=jLqFTVhUL76FeOuYk8TaRQHmPTf3HSRc2EoJwxJNK6U,1194
 letta/system.py,sha256=dnOrS2FlRMwijQnOvfrky0Lg8wEw-FUq2zzfAJOUSKA,8477
 letta/tracing.py,sha256=RstWXpfWVF77nmb_ISORVWd9IQw2Ky3de40k_S70yKI,8258
 letta/utils.py,sha256=IZFvtj9WYcrxUbkoUUYGDxMYQYdn5SgfqsvnARGsAzc,32245
-letta_nightly-0.7.4.dev20250424184820.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
-letta_nightly-0.7.4.dev20250424184820.dist-info/METADATA,sha256=VuX6foyFknSyK3rzhVvx8iY8IY4yHwnfo_yIpjEFi8I,22282
-letta_nightly-0.7.4.dev20250424184820.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-letta_nightly-0.7.4.dev20250424184820.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
-letta_nightly-0.7.4.dev20250424184820.dist-info/RECORD,,
+letta_nightly-0.7.5.dev20250425104208.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
+letta_nightly-0.7.5.dev20250425104208.dist-info/METADATA,sha256=WeqMXkmCYUka4wxlVOUi9CB9eVUtVbf2m3oXQ-4Ik6w,22282
+letta_nightly-0.7.5.dev20250425104208.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+letta_nightly-0.7.5.dev20250425104208.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
+letta_nightly-0.7.5.dev20250425104208.dist-info/RECORD,,