letta-nightly 0.9.1.dev20250731104458__py3-none-any.whl → 0.10.0.dev20250801010504__py3-none-any.whl

letta/services/tool_executor/files_tool_executor.py

@@ -142,6 +142,7 @@ class LettaFileToolExecutor(ToolExecutor):
         # Process each file
         opened_files = []
         all_closed_files = []
+        all_previous_ranges = {}  # Collect all previous ranges from all files
 
         for file_request in file_requests:
             file_name = file_request.file_name
@@ -181,7 +182,7 @@ class LettaFileToolExecutor(ToolExecutor):
             visible_content = "\n".join(content_lines)
 
             # Handle LRU eviction and file opening
-            closed_files, was_already_open = await self.files_agents_manager.enforce_max_open_files_and_open(
+            closed_files, was_already_open, previous_ranges = await self.files_agents_manager.enforce_max_open_files_and_open(
                 agent_id=agent_state.id,
                 file_id=file_id,
                 file_name=file_name,
@@ -189,42 +190,45 @@ class LettaFileToolExecutor(ToolExecutor):
                 actor=self.actor,
                 visible_content=visible_content,
                 max_files_open=agent_state.max_files_open,
+                start_line=start + 1 if start is not None else None,  # convert to 1-indexed for user display
+                end_line=end if end is not None else None,  # end is already exclusive in slicing, so this is correct
             )
 
             opened_files.append(file_name)
             all_closed_files.extend(closed_files)
+            all_previous_ranges.update(previous_ranges)  # Merge previous ranges from this file
 
         # Update access timestamps for all opened files efficiently
         await self.files_agents_manager.mark_access_bulk(agent_id=agent_state.id, file_names=file_names, actor=self.actor)
 
-        # Build success message
-        if len(file_requests) == 1:
-            # Single file - maintain existing format
-            file_request = file_requests[0]
-            file_name = file_request.file_name
-            offset = file_request.offset
-            length = file_request.length
-            if offset is not None and length is not None:
-                end_line = offset + length - 1
-                success_msg = (
-                    f"Successfully opened file {file_name}, lines {offset} to {end_line} are now visible in memory block <{file_name}>"
-                )
-            elif offset is not None:
-                success_msg = f"Successfully opened file {file_name}, lines {offset} to end are now visible in memory block <{file_name}>"
+        # Helper function to format previous range info
+        def format_previous_range(file_name: str) -> str:
+            if file_name in all_previous_ranges:
+                old_start, old_end = all_previous_ranges[file_name]
+                if old_start is not None and old_end is not None:
+                    return f" (previously lines {old_start}-{old_end})"
+                elif old_start is not None:
+                    return f" (previously lines {old_start}-end)"
+                else:
+                    return " (previously full file)"
+            return ""
+
+        # Build unified success message - treat single and multiple files consistently
+        file_summaries = []
+        for req in file_requests:
+            previous_info = format_previous_range(req.file_name)
+            if req.offset is not None and req.length is not None:
+                end_line = req.offset + req.length - 1
+                file_summaries.append(f"{req.file_name} (lines {req.offset}-{end_line}){previous_info}")
+            elif req.offset is not None:
+                file_summaries.append(f"{req.file_name} (lines {req.offset}-end){previous_info}")
             else:
-                success_msg = f"Successfully opened file {file_name}, entire file is now visible in memory block <{file_name}>"
+                file_summaries.append(f"{req.file_name}{previous_info}")
+
+        if len(file_requests) == 1:
+            success_msg = f"* Opened {file_summaries[0]}"
         else:
-            # Multiple files - show individual ranges if specified
-            file_summaries = []
-            for req in file_requests:
-                if req.offset is not None and req.length is not None:
-                    end_line = req.offset + req.length - 1
-                    file_summaries.append(f"{req.file_name} (lines {req.offset}-{end_line})")
-                elif req.offset is not None:
-                    file_summaries.append(f"{req.file_name} (lines {req.offset}-end)")
-                else:
-                    file_summaries.append(req.file_name)
-            success_msg = f"Successfully opened {len(file_requests)} files: {', '.join(file_summaries)}"
+            success_msg = f"* Opened {len(file_requests)} files: {', '.join(file_summaries)}"
 
         # Add information about closed files
         if closed_by_close_all_others:

letta/services/tool_executor/mcp_tool_executor.py

@@ -35,8 +35,17 @@ class ExternalMCPToolExecutor(ToolExecutor):
 
         mcp_manager = MCPManager()
         # TODO: may need to have better client connection management
+
+        environment_variables = {}
+        if agent_state:
+            environment_variables = agent_state.get_agent_env_vars_as_dict()
+
         function_response, success = await mcp_manager.execute_mcp_server_tool(
-            mcp_server_name=mcp_server_name, tool_name=function_name, tool_args=function_args, actor=actor
+            mcp_server_name=mcp_server_name,
+            tool_name=function_name,
+            tool_args=function_args,
+            environment_variables=environment_variables,
+            actor=actor,
         )
 
         return ToolExecutionResult(

letta/services/tool_executor/{tool_executor.py → sandbox_tool_executor.py}

@@ -5,13 +5,13 @@ from letta.functions.ast_parsers import coerce_dict_args_by_annotations, get_fun
 from letta.log import get_logger
 from letta.otel.tracing import trace_method
 from letta.schemas.agent import AgentState
+from letta.schemas.enums import SandboxType
 from letta.schemas.sandbox_config import SandboxConfig
 from letta.schemas.tool import Tool
 from letta.schemas.tool_execution_result import ToolExecutionResult
 from letta.schemas.user import User
 from letta.services.agent_manager import AgentManager
 from letta.services.tool_executor.tool_executor_base import ToolExecutor
-from letta.services.tool_sandbox.e2b_sandbox import AsyncToolSandboxE2B
 from letta.services.tool_sandbox.local_sandbox import AsyncToolSandboxLocal
 from letta.settings import tool_settings
 from letta.types import JsonDict
@@ -19,6 +19,11 @@ from letta.utils import get_friendly_error_msg
 
 logger = get_logger(__name__)
 
+if tool_settings.e2b_api_key:
+    from letta.services.tool_sandbox.e2b_sandbox import AsyncToolSandboxE2B
+if tool_settings.modal_api_key:
+    from letta.services.tool_sandbox.modal_sandbox import AsyncToolSandboxModal
+
 
 class SandboxToolExecutor(ToolExecutor):
     """Executor for sandboxed tools."""
@@ -48,10 +53,14 @@ class SandboxToolExecutor(ToolExecutor):
             agent_state_copy = self._create_agent_state_copy(agent_state) if agent_state else None
 
             # Execute in sandbox depending on API key
-            if tool_settings.e2b_api_key:
+            if tool_settings.sandbox_type == SandboxType.E2B:
                 sandbox = AsyncToolSandboxE2B(
                     function_name, function_args, actor, tool_object=tool, sandbox_config=sandbox_config, sandbox_env_vars=sandbox_env_vars
                 )
+            elif tool_settings.sandbox_type == SandboxType.MODAL:
+                sandbox = AsyncToolSandboxModal(
+                    function_name, function_args, actor, tool_object=tool, sandbox_config=sandbox_config, sandbox_env_vars=sandbox_env_vars
+                )
             else:
                 sandbox = AsyncToolSandboxLocal(
                     function_name, function_args, actor, tool_object=tool, sandbox_config=sandbox_config, sandbox_env_vars=sandbox_env_vars
@@ -59,6 +68,9 @@ class SandboxToolExecutor(ToolExecutor):
 
             tool_execution_result = await sandbox.run(agent_state=agent_state_copy)
 
+            log_lines = (tool_execution_result.stdout or []) + (tool_execution_result.stderr or [])
+            logger.debug("Tool execution log: %s", "\n".join(log_lines))
+
             # Verify memory integrity
             if agent_state:
                 new_memory_str = await agent_state.memory.compile_async()

letta/services/tool_executor/tool_execution_manager.py

@@ -24,7 +24,7 @@ from letta.services.tool_executor.core_tool_executor import LettaCoreToolExecuto
 from letta.services.tool_executor.files_tool_executor import LettaFileToolExecutor
 from letta.services.tool_executor.mcp_tool_executor import ExternalMCPToolExecutor
 from letta.services.tool_executor.multi_agent_tool_executor import LettaMultiAgentToolExecutor
-from letta.services.tool_executor.tool_executor import SandboxToolExecutor
+from letta.services.tool_executor.sandbox_tool_executor import SandboxToolExecutor
 from letta.services.tool_executor.tool_executor_base import ToolExecutor
 from letta.utils import get_friendly_error_msg
 

letta/services/tool_executor/tool_execution_sandbox.py

@@ -13,7 +13,8 @@ from letta.functions.helpers import generate_model_from_args_json_schema
 from letta.log import get_logger
 from letta.otel.tracing import log_event, trace_method
 from letta.schemas.agent import AgentState
-from letta.schemas.sandbox_config import SandboxConfig, SandboxType
+from letta.schemas.enums import SandboxType
+from letta.schemas.sandbox_config import SandboxConfig
 from letta.schemas.tool import Tool
 from letta.schemas.tool_execution_result import ToolExecutionResult
 from letta.schemas.user import User

letta/services/tool_manager.py

@@ -19,6 +19,7 @@ from letta.constants import (
     LOCAL_ONLY_MULTI_AGENT_TOOLS,
     MCP_TOOL_TAG_NAME_PREFIX,
 )
+from letta.errors import LettaToolNameConflictError
 from letta.functions.functions import derive_openai_json_schema, load_function_set
 from letta.log import get_logger
 from letta.orm.enums import ToolType
@@ -143,13 +144,6 @@ class ToolManager:
             PydanticTool(tool_type=ToolType.EXTERNAL_COMPOSIO, name=tool_create.json_schema["name"], **tool_create.model_dump()), actor
         )
 
-    @enforce_types
-    @trace_method
-    def create_or_update_langchain_tool(self, tool_create: ToolCreate, actor: PydanticUser) -> PydanticTool:
-        return self.create_or_update_tool(
-            PydanticTool(tool_type=ToolType.EXTERNAL_LANGCHAIN, name=tool_create.json_schema["name"], **tool_create.model_dump()), actor
-        )
-
     @enforce_types
     @trace_method
     def create_tool(self, pydantic_tool: PydanticTool, actor: PydanticUser) -> PydanticTool:
@@ -306,6 +300,16 @@ class ToolManager:
             count = result.scalar()
             return count > 0
 
+    @enforce_types
+    @trace_method
+    async def tool_name_exists_async(self, tool_name: str, actor: PydanticUser) -> bool:
+        """Check if a tool with the given name exists in the user's organization (lightweight check)."""
+        async with db_registry.async_session() as session:
+            query = select(func.count(ToolModel.id)).where(ToolModel.name == tool_name, ToolModel.organization_id == actor.organization_id)
+            result = await session.execute(query)
+            count = result.scalar()
+            return count > 0
+
     @enforce_types
     @trace_method
     async def list_tools_async(
@@ -386,22 +390,39 @@ class ToolManager:
         self, tool_id: str, tool_update: ToolUpdate, actor: PydanticUser, updated_tool_type: Optional[ToolType] = None
     ) -> PydanticTool:
         """Update a tool by its ID with the given ToolUpdate object."""
+        # First, check if source code update would cause a name conflict
+        update_data = tool_update.model_dump(to_orm=True, exclude_none=True)
+        new_name = None
+        new_schema = None
+
+        if "source_code" in update_data.keys() and "json_schema" not in update_data.keys():
+            # Derive the new schema and name from the source code
+            new_schema = derive_openai_json_schema(source_code=update_data["source_code"])
+            new_name = new_schema["name"]
+
+            # Get current tool to check if name is changing
+            current_tool = self.get_tool_by_id(tool_id=tool_id, actor=actor)
+
+            # Check if the name is changing and if so, verify it doesn't conflict
+            if new_name != current_tool.name:
+                # Check if a tool with the new name already exists
+                existing_tool = self.get_tool_by_name(tool_name=new_name, actor=actor)
+                if existing_tool:
+                    raise LettaToolNameConflictError(tool_name=new_name)
+
+        # Now perform the update within the session
         with db_registry.session() as session:
             # Fetch the tool by ID
             tool = ToolModel.read(db_session=session, identifier=tool_id, actor=actor)
 
             # Update tool attributes with only the fields that were explicitly set
-            update_data = tool_update.model_dump(to_orm=True, exclude_none=True)
             for key, value in update_data.items():
                 setattr(tool, key, value)
 
-            # If source code is changed and a new json_schema is not provided, we want to auto-refresh the schema
-            if "source_code" in update_data.keys() and "json_schema" not in update_data.keys():
-                pydantic_tool = tool.to_pydantic()
-                new_schema = derive_openai_json_schema(source_code=pydantic_tool.source_code)
-
+            # If we already computed the new schema, apply it
+            if new_schema is not None:
                 tool.json_schema = new_schema
-                tool.name = new_schema["name"]
+                tool.name = new_name
 
             if updated_tool_type:
                 tool.tool_type = updated_tool_type
@@ -415,22 +436,39 @@ class ToolManager:
         self, tool_id: str, tool_update: ToolUpdate, actor: PydanticUser, updated_tool_type: Optional[ToolType] = None
     ) -> PydanticTool:
         """Update a tool by its ID with the given ToolUpdate object."""
+        # First, check if source code update would cause a name conflict
+        update_data = tool_update.model_dump(to_orm=True, exclude_none=True)
+        new_name = None
+        new_schema = None
+
+        if "source_code" in update_data.keys() and "json_schema" not in update_data.keys():
+            # Derive the new schema and name from the source code
+            new_schema = derive_openai_json_schema(source_code=update_data["source_code"])
+            new_name = new_schema["name"]
+
+            # Get current tool to check if name is changing
+            current_tool = await self.get_tool_by_id_async(tool_id=tool_id, actor=actor)
+
+            # Check if the name is changing and if so, verify it doesn't conflict
+            if new_name != current_tool.name:
+                # Check if a tool with the new name already exists
+                name_exists = await self.tool_name_exists_async(tool_name=new_name, actor=actor)
+                if name_exists:
+                    raise LettaToolNameConflictError(tool_name=new_name)
+
+        # Now perform the update within the session
         async with db_registry.async_session() as session:
             # Fetch the tool by ID
             tool = await ToolModel.read_async(db_session=session, identifier=tool_id, actor=actor)
 
             # Update tool attributes with only the fields that were explicitly set
-            update_data = tool_update.model_dump(to_orm=True, exclude_none=True)
             for key, value in update_data.items():
                 setattr(tool, key, value)
 
-            # If source code is changed and a new json_schema is not provided, we want to auto-refresh the schema
-            if "source_code" in update_data.keys() and "json_schema" not in update_data.keys():
-                pydantic_tool = tool.to_pydantic()
-                new_schema = derive_openai_json_schema(source_code=pydantic_tool.source_code)
-
+            # If we already computed the new schema, apply it
+            if new_schema is not None:
                 tool.json_schema = new_schema
-                tool.name = new_schema["name"]
+                tool.name = new_name
 
             if updated_tool_type:
                 tool.tool_type = updated_tool_type

letta/services/tool_sandbox/base.py

@@ -1,3 +1,4 @@
+import os
 import pickle
 import uuid
 from abc import ABC, abstractmethod
@@ -188,5 +189,20 @@ class AsyncToolSandboxBase(ABC):
         """
         return False  # Default to False for local execution
 
-    def _update_env_vars(self):
-        pass  # TODO
+    async def _gather_env_vars(self, agent_state: AgentState | None, additional_env_vars: dict[str, str], sbx_id: str, is_local: bool):
+        env = os.environ.copy() if is_local else {}
+        if self.provided_sandbox_env_vars:
+            env.update(self.provided_sandbox_env_vars)
+        else:
+            env_vars = await self.sandbox_config_manager.get_sandbox_env_vars_as_dict_async(
+                sandbox_config_id=sbx_id, actor=self.user, limit=None
+            )
+            env.update(env_vars)
+
+        if agent_state:
+            env.update(agent_state.get_agent_env_vars_as_dict())
+
+        if additional_env_vars:
+            env.update(additional_env_vars)
+
+        return env

letta/services/tool_sandbox/e2b_sandbox.py

@@ -6,7 +6,8 @@ from e2b_code_interpreter import AsyncSandbox
 from letta.log import get_logger
 from letta.otel.tracing import log_event, trace_method
 from letta.schemas.agent import AgentState
-from letta.schemas.sandbox_config import SandboxConfig, SandboxType
+from letta.schemas.enums import SandboxType
+from letta.schemas.sandbox_config import SandboxConfig
 from letta.schemas.tool import Tool
 from letta.schemas.tool_execution_result import ToolExecutionResult
 from letta.services.helpers.tool_parser_helper import parse_stdout_best_effort
@@ -41,22 +42,6 @@ class AsyncToolSandboxE2B(AsyncToolSandboxBase):
         self,
         agent_state: Optional[AgentState] = None,
         additional_env_vars: Optional[Dict] = None,
-    ) -> ToolExecutionResult:
-        """
-        Run the tool in a sandbox environment asynchronously,
-        *always* using a subprocess for execution.
-        """
-        result = await self.run_e2b_sandbox(agent_state=agent_state, additional_env_vars=additional_env_vars)
-
-        # Simple console logging for demonstration
-        for log_line in (result.stdout or []) + (result.stderr or []):
-            print(f"Tool execution log: {log_line}")
-
-        return result
-
-    @trace_method
-    async def run_e2b_sandbox(
-        self, agent_state: Optional[AgentState] = None, additional_env_vars: Optional[Dict] = None
     ) -> ToolExecutionResult:
         if self.provided_sandbox_config:
             sbx_config = self.provided_sandbox_config
@@ -76,30 +61,15 @@ class AsyncToolSandboxE2B(AsyncToolSandboxBase):
         # await sbx.set_timeout(sbx_config.get_e2b_config().timeout)
 
         # Get environment variables for the sandbox
-        # TODO: We set limit to 100 here, but maybe we want it uncapped? Realistically this should be fine.
-        env_vars = {}
-        if self.provided_sandbox_env_vars:
-            env_vars.update(self.provided_sandbox_env_vars)
-        else:
-            db_env_vars = await self.sandbox_config_manager.get_sandbox_env_vars_as_dict_async(
-                sandbox_config_id=sbx_config.id, actor=self.user, limit=100
-            )
-            env_vars.update(db_env_vars)
-        # Get environment variables for this agent specifically
-        if agent_state:
-            env_vars.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_vars.update(additional_env_vars)
+        envs = await self._gather_env_vars(agent_state, additional_env_vars, sbx_config.id, is_local=False)
         code = await self.generate_execution_script(agent_state=agent_state)
 
         try:
             log_event(
                 "e2b_execution_started",
-                {"tool": self.tool_name, "sandbox_id": e2b_sandbox.sandbox_id, "code": code, "env_vars": env_vars},
+                {"tool": self.tool_name, "sandbox_id": e2b_sandbox.sandbox_id, "code": code, "env_vars": envs},
             )
-            execution = await e2b_sandbox.run_code(code, envs=env_vars)
+            execution = await e2b_sandbox.run_code(code, envs=envs)
 
             if execution.results:
                 func_return, agent_state = parse_stdout_best_effort(execution.results[0].text)

letta/services/tool_sandbox/local_sandbox.py

@@ -11,7 +11,8 @@ from pydantic.config import JsonDict
 from letta.log import get_logger
 from letta.otel.tracing import log_event, trace_method
 from letta.schemas.agent import AgentState
-from letta.schemas.sandbox_config import SandboxConfig, SandboxType
+from letta.schemas.enums import SandboxType
+from letta.schemas.sandbox_config import SandboxConfig
 from letta.schemas.tool import Tool
 from letta.schemas.tool_execution_result import ToolExecutionResult
 from letta.services.helpers.tool_execution_helper import (
@@ -44,34 +45,16 @@ class AsyncToolSandboxLocal(AsyncToolSandboxBase):
         super().__init__(tool_name, args, user, tool_object, sandbox_config=sandbox_config, sandbox_env_vars=sandbox_env_vars)
         self.force_recreate_venv = force_recreate_venv
 
+    @trace_method
     async def run(
         self,
         agent_state: Optional[AgentState] = None,
         additional_env_vars: Optional[Dict] = None,
     ) -> ToolExecutionResult:
         """
-        Run the tool in a sandbox environment asynchronously,
-        *always* using a subprocess for execution.
-        """
-        result = await self.run_local_dir_sandbox(agent_state=agent_state, additional_env_vars=additional_env_vars)
-
-        # Simple console logging for demonstration
-        for log_line in (result.stdout or []) + (result.stderr or []):
-            print(f"Tool execution log: {log_line}")
-
-        return result
-
-    @trace_method
-    async def run_local_dir_sandbox(
-        self,
-        agent_state: Optional[AgentState],
-        additional_env_vars: Optional[Dict],
-    ) -> ToolExecutionResult:
-        """
-        Unified asynchronous method to run the tool in a local sandbox environment,
-        always via subprocess for multi-core parallelism.
+        Run the tool in a local sandbox environment asynchronously.
+        Uses a subprocess for multi-core parallelism.
         """
-        # Get sandbox configuration
         if self.provided_sandbox_config:
             sbx_config = self.provided_sandbox_config
         else:

letta/services/tool_sandbox/modal_sandbox.py

@@ -0,0 +1,205 @@
+from typing import Any, Dict, Optional
+
+import modal
+
+from letta.log import get_logger
+from letta.otel.tracing import log_event, trace_method
+from letta.schemas.agent import AgentState
+from letta.schemas.enums import SandboxType
+from letta.schemas.sandbox_config import SandboxConfig
+from letta.schemas.tool import Tool
+from letta.schemas.tool_execution_result import ToolExecutionResult
+from letta.services.helpers.tool_parser_helper import parse_stdout_best_effort
+from letta.services.tool_sandbox.base import AsyncToolSandboxBase
+from letta.settings import tool_settings
+from letta.types import JsonDict
+from letta.utils import get_friendly_error_msg
+
+logger = get_logger(__name__)
+
+
+class AsyncToolSandboxModal(AsyncToolSandboxBase):
+    def __init__(
+        self,
+        tool_name: str,
+        args: JsonDict,
+        user,
+        tool_object: Tool | None = None,
+        sandbox_config: SandboxConfig | None = None,
+        sandbox_env_vars: dict[str, Any] | None = None,
+    ):
+        super().__init__(tool_name, args, user, tool_object, sandbox_config=sandbox_config, sandbox_env_vars=sandbox_env_vars)
+
+        if not tool_settings.modal_api_key:
+            raise ValueError("Modal API key is required but not set in tool_settings.modal_api_key")
+
+        # Create a unique app name based on tool and config
+        self._app_name = self._generate_app_name()
+
+    def _generate_app_name(self) -> str:
+        """Generate a unique app name based on tool and configuration. Created based on tool name and org"""
+        return f"{self.user.organization_id}-{self.tool_name}"
+
+    async def _fetch_or_create_modal_app(self, sbx_config: SandboxConfig, env_vars: Dict[str, str]) -> modal.App:
+        """Create a Modal app with the tool function registered."""
+        app = await modal.App.lookup.aio(self._app_name)
+        modal_config = sbx_config.get_modal_config()
+
+        # Get the base image with dependencies
+        image = self._get_modal_image(sbx_config)
+
+        # Decorator for the tool, note information on running untrusted code: https://modal.com/docs/guide/restricted-access
+        # The `@app.function` decorator must apply to functions in global scope, unless `serialized=True` is set.
+        @app.function(image=image, timeout=modal_config.timeout, restrict_modal_access=True, max_inputs=1, serialized=True)
+        def execute_tool_with_script(execution_script: str, environment_vars: dict[str, str]):
+            """Execute the generated tool script in Modal sandbox."""
+            import os
+
+            # Note: We pass environment variables directly instead of relying on Modal secrets
+            # This is more flexible and doesn't require pre-configured secrets
+            for key, value in environment_vars.items():
+                os.environ[key] = str(value)
+
+            exec_globals = {}
+            exec(execution_script, exec_globals)
+
+        # Store the function reference in the app for later use
+        app.remote_executor = execute_tool_with_script
+        return app
+
+    @trace_method
+    async def run(
+        self,
+        agent_state: Optional[AgentState] = None,
+        additional_env_vars: Optional[Dict] = None,
+    ) -> ToolExecutionResult:
+        if self.provided_sandbox_config:
+            sbx_config = self.provided_sandbox_config
+        else:
+            sbx_config = await self.sandbox_config_manager.get_or_create_default_sandbox_config_async(
+                sandbox_type=SandboxType.MODAL, actor=self.user
+            )
+
+        envs = await self._gather_env_vars(agent_state, additional_env_vars or {}, sbx_config.id, is_local=False)
+
+        # Generate execution script (this includes the tool source code and execution logic)
+        execution_script = await self.generate_execution_script(agent_state=agent_state)
+
+        try:
+            log_event(
+                "modal_execution_started",
+                {"tool": self.tool_name, "app_name": self._app_name, "env_vars": list(envs)},
+            )
+
+            # Create Modal app with the tool function registered
+            app = await self._fetch_or_create_modal_app(sbx_config, envs)
+
+            # Execute the tool remotely
+            with app.run():
+                result = app.remote_executor.remote(execution_script, envs)
+
+            # Process the result
+            if result["error"]:
+                logger.error(
+                    f"Executing tool {self.tool_name} raised a {result['error']['name']} with message: \n{result['error']['value']}"
+                )
+                logger.error(f"Traceback from Modal sandbox: \n{result['error']['traceback']}")
+                func_return = get_friendly_error_msg(
+                    function_name=self.tool_name, exception_name=result["error"]["name"], exception_message=result["error"]["value"]
+                )
+                log_event(
+                    "modal_execution_failed",
+                    {
+                        "tool": self.tool_name,
+                        "app_name": self._app_name,
+                        "error_type": result["error"]["name"],
+                        "error_message": result["error"]["value"],
+                        "func_return": func_return,
+                    },
+                )
+                # Parse the result from stdout even if there was an error
+                # (in case the function returned something before failing)
+                agent_state = None  # Initialize agent_state
+                try:
+                    func_return_parsed, agent_state_parsed = parse_stdout_best_effort(result["stdout"])
+                    if func_return_parsed is not None:
+                        func_return = func_return_parsed
+                        agent_state = agent_state_parsed
+                except Exception:
+                    # If parsing fails, keep the error message
+                    pass
+            else:
+                func_return, agent_state = parse_stdout_best_effort(result["stdout"])
+                log_event(
+                    "modal_execution_succeeded",
+                    {
+                        "tool": self.tool_name,
+                        "app_name": self._app_name,
+                        "func_return": func_return,
+                    },
+                )
+
+            return ToolExecutionResult(
+                func_return=func_return,
+                agent_state=agent_state,
+                stdout=[result["stdout"]] if result["stdout"] else [],
+                stderr=[result["stderr"]] if result["stderr"] else [],
+                status="error" if result["error"] else "success",
+                sandbox_config_fingerprint=sbx_config.fingerprint(),
+            )
+
+        except Exception as e:
+            logger.error(f"Modal execution for tool {self.tool_name} encountered an error: {e}")
+            func_return = get_friendly_error_msg(
+                function_name=self.tool_name,
+                exception_name=type(e).__name__,
+                exception_message=str(e),
+            )
+            log_event(
+                "modal_execution_error",
+                {
+                    "tool": self.tool_name,
+                    "app_name": self._app_name,
+                    "error": str(e),
+                    "func_return": func_return,
+                },
+            )
+            return ToolExecutionResult(
+                func_return=func_return,
+                agent_state=None,
+                stdout=[],
+                stderr=[str(e)],
+                status="error",
+                sandbox_config_fingerprint=sbx_config.fingerprint(),
+            )
+
+    def _get_modal_image(self, sbx_config: SandboxConfig) -> modal.Image:
+        """Get Modal image with required public python dependencies.
+
+        Caching and rebuilding is handled in a cascading manner
+        https://modal.com/docs/guide/images#image-caching-and-rebuilds
+        """
+        image = modal.Image.debian_slim(python_version="3.12")
+
+        all_requirements = ["letta"]
+
+        # Add sandbox-specific pip requirements
+        modal_configs = sbx_config.get_modal_config()
+        if modal_configs.pip_requirements:
+            all_requirements.extend([str(req) for req in modal_configs.pip_requirements])
+
+        # Add tool-specific pip requirements
+        if self.tool and self.tool.pip_requirements:
+            all_requirements.extend([str(req) for req in self.tool.pip_requirements])
+
+        if all_requirements:
+            image = image.pip_install(*all_requirements)
+
+        return image
+
+    def use_top_level_await(self) -> bool:
+        """
+        Modal functions don't have an active event loop by default,
+        so we should use asyncio.run() like local execution.
+        """
+        return False