letta-nightly 0.7.0.dev20250423003112__py3-none-any.whl → 0.7.2.dev20250423222439__py3-none-any.whl

letta/services/tool_executor/tool_executor.py

@@ -1,15 +1,17 @@
 import math
+import traceback
 from abc import ABC, abstractmethod
-from typing import Any, Dict, Optional, Tuple
+from typing import Any, Dict, Optional
 
-from letta.constants import COMPOSIO_ENTITY_ENV_VAR_KEY, RETRIEVAL_QUERY_DEFAULT_PAGE_SIZE
+from letta.constants import COMPOSIO_ENTITY_ENV_VAR_KEY, CORE_MEMORY_LINE_NUMBER_WARNING, RETRIEVAL_QUERY_DEFAULT_PAGE_SIZE
 from letta.functions.ast_parsers import coerce_dict_args_by_annotations, get_function_annotations_from_source
 from letta.functions.helpers import execute_composio_action, generate_composio_action_from_func_name
 from letta.helpers.composio_helpers import get_composio_api_key
 from letta.helpers.json_helpers import json_dumps
 from letta.schemas.agent import AgentState
-from letta.schemas.sandbox_config import SandboxConfig, SandboxRunResult
+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.message_manager import MessageManager
@@ -33,7 +35,7 @@ class ToolExecutor(ABC):
         actor: User,
         sandbox_config: Optional[SandboxConfig] = None,
         sandbox_env_vars: Optional[Dict[str, Any]] = None,
-    ) -> Tuple[Any, Optional[SandboxRunResult]]:
+    ) -> ToolExecutionResult:
         """Execute the tool and return the result."""
 
 
@@ -49,13 +51,19 @@ class LettaCoreToolExecutor(ToolExecutor):
         actor: User,
         sandbox_config: Optional[SandboxConfig] = None,
         sandbox_env_vars: Optional[Dict[str, Any]] = None,
-    ) -> Tuple[Any, Optional[SandboxRunResult]]:
+    ) -> ToolExecutionResult:
         # Map function names to method calls
         function_map = {
             "send_message": self.send_message,
             "conversation_search": self.conversation_search,
             "archival_memory_search": self.archival_memory_search,
             "archival_memory_insert": self.archival_memory_insert,
+            "core_memory_append": self.core_memory_append,
+            "core_memory_replace": self.core_memory_replace,
+            "memory_replace": self.memory_replace,
+            "memory_insert": self.memory_insert,
+            "memory_rethink": self.memory_rethink,
+            "memory_finish_edits": self.memory_finish_edits,
         }
 
         if function_name not in function_map:
@@ -64,7 +72,10 @@ class LettaCoreToolExecutor(ToolExecutor):
         # Execute the appropriate function
         function_args_copy = function_args.copy()  # Make a copy to avoid modifying the original
         function_response = function_map[function_name](agent_state, actor, **function_args_copy)
-        return function_response, None
+        return ToolExecutionResult(
+            status="success",
+            func_return=function_response,
+        )
 
     def send_message(self, agent_state: AgentState, actor: User, message: str) -> Optional[str]:
         """
@@ -181,51 +192,7 @@ class LettaCoreToolExecutor(ToolExecutor):
         AgentManager().rebuild_system_prompt(agent_id=agent_state.id, actor=actor, force=True)
         return None
 
-
-class LettaMultiAgentToolExecutor(ToolExecutor):
-    """Executor for LETTA multi-agent core tools."""
-
-    # TODO: Implement
-    # def execute(self, function_name: str, function_args: dict, agent: "Agent", tool: Tool) -> Tuple[
-    #     Any, Optional[SandboxRunResult]]:
-    #     callable_func = get_function_from_module(LETTA_MULTI_AGENT_TOOL_MODULE_NAME, function_name)
-    #     function_args["self"] = agent  # need to attach self to arg since it's dynamically linked
-    #     function_response = callable_func(**function_args)
-    #     return function_response, None
-
-
-class LettaMemoryToolExecutor(ToolExecutor):
-    """Executor for LETTA memory core tools with direct implementation."""
-
-    def execute(
-        self,
-        function_name: str,
-        function_args: dict,
-        agent_state: AgentState,
-        tool: Tool,
-        actor: User,
-        sandbox_config: Optional[SandboxConfig] = None,
-        sandbox_env_vars: Optional[Dict[str, Any]] = None,
-    ) -> Tuple[Any, Optional[SandboxRunResult]]:
-        # Map function names to method calls
-        function_map = {
-            "core_memory_append": self.core_memory_append,
-            "core_memory_replace": self.core_memory_replace,
-        }
-
-        if function_name not in function_map:
-            raise ValueError(f"Unknown function: {function_name}")
-
-        # Execute the appropriate function with the copied state
-        function_args_copy = function_args.copy()  # Make a copy to avoid modifying the original
-        function_response = function_map[function_name](agent_state, **function_args_copy)
-
-        # Update memory if changed
-        AgentManager().update_memory_if_changed(agent_id=agent_state.id, new_memory=agent_state.memory, actor=actor)
-
-        return function_response, None
-
-    def core_memory_append(self, agent_state: "AgentState", label: str, content: str) -> Optional[str]:
+    def core_memory_append(self, agent_state: "AgentState", actor: User, label: str, content: str) -> Optional[str]:
         """
         Append to the contents of core memory.
 
@@ -239,9 +206,17 @@ class LettaMemoryToolExecutor(ToolExecutor):
         current_value = str(agent_state.memory.get_block(label).value)
         new_value = current_value + "\n" + str(content)
         agent_state.memory.update_block_value(label=label, value=new_value)
+        AgentManager().update_memory_if_changed(agent_id=agent_state.id, new_memory=agent_state.memory, actor=actor)
         return None
 
-    def core_memory_replace(self, agent_state: "AgentState", label: str, old_content: str, new_content: str) -> Optional[str]:
+    def core_memory_replace(
+        self,
+        agent_state: "AgentState",
+        actor: User,
+        label: str,
+        old_content: str,
+        new_content: str,
+    ) -> Optional[str]:
         """
         Replace the contents of core memory. To delete memories, use an empty string for new_content.
 
@@ -258,8 +233,253 @@ class LettaMemoryToolExecutor(ToolExecutor):
             raise ValueError(f"Old content '{old_content}' not found in memory block '{label}'")
         new_value = current_value.replace(str(old_content), str(new_content))
         agent_state.memory.update_block_value(label=label, value=new_value)
+        AgentManager().update_memory_if_changed(agent_id=agent_state.id, new_memory=agent_state.memory, actor=actor)
         return None
 
+    def memory_replace(
+        agent_state: "AgentState",
+        actor: User,
+        label: str,
+        old_str: str,
+        new_str: Optional[str] = None,
+    ) -> str:
+        """
+        The memory_replace command allows you to replace a specific string in a memory
+        block with a new string. This is used for making precise edits.
+
+        Args:
+            label (str): Section of the memory to be edited, identified by its label.
+            old_str (str): The text to replace (must match exactly, including whitespace
+                and indentation).
+            new_str (Optional[str]): The new text to insert in place of the old text.
+                Omit this argument to delete the old_str.
+
+        Returns:
+            str: The success message
+        """
+        import re
+
+        if bool(re.search(r"\nLine \d+: ", old_str)):
+            raise ValueError(
+                "old_str contains a line number prefix, which is not allowed. "
+                "Do not include line numbers when calling memory tools (line "
+                "numbers are for display purposes only)."
+            )
+        if CORE_MEMORY_LINE_NUMBER_WARNING in old_str:
+            raise ValueError(
+                "old_str contains a line number warning, which is not allowed. "
+                "Do not include line number information when calling memory tools "
+                "(line numbers are for display purposes only)."
+            )
+        if bool(re.search(r"\nLine \d+: ", new_str)):
+            raise ValueError(
+                "new_str contains a line number prefix, which is not allowed. "
+                "Do not include line numbers when calling memory tools (line "
+                "numbers are for display purposes only)."
+            )
+
+        old_str = str(old_str).expandtabs()
+        new_str = str(new_str).expandtabs()
+        current_value = str(agent_state.memory.get_block(label).value).expandtabs()
+
+        # Check if old_str is unique in the block
+        occurences = current_value.count(old_str)
+        if occurences == 0:
+            raise ValueError(
+                f"No replacement was performed, old_str `{old_str}` did not appear " f"verbatim in memory block with label `{label}`."
+            )
+        elif occurences > 1:
+            content_value_lines = current_value.split("\n")
+            lines = [idx + 1 for idx, line in enumerate(content_value_lines) if old_str in line]
+            raise ValueError(
+                f"No replacement was performed. Multiple occurrences of "
+                f"old_str `{old_str}` in lines {lines}. Please ensure it is unique."
+            )
+
+        # Replace old_str with new_str
+        new_value = current_value.replace(str(old_str), str(new_str))
+
+        # Write the new content to the block
+        agent_state.memory.update_block_value(label=label, value=new_value)
+
+        AgentManager().update_memory_if_changed(agent_id=agent_state.id, new_memory=agent_state.memory, actor=actor)
+
+        # Create a snippet of the edited section
+        SNIPPET_LINES = 3
+        replacement_line = current_value.split(old_str)[0].count("\n")
+        start_line = max(0, replacement_line - SNIPPET_LINES)
+        end_line = replacement_line + SNIPPET_LINES + new_str.count("\n")
+        snippet = "\n".join(new_value.split("\n")[start_line : end_line + 1])
+
+        # Prepare the success message
+        success_msg = f"The core memory block with label `{label}` has been edited. "
+        # success_msg += self._make_output(
+        #     snippet, f"a snippet of {path}", start_line + 1
+        # )
+        # success_msg += f"A snippet of core memory block `{label}`:\n{snippet}\n"
+        success_msg += (
+            "Review the changes and make sure they are as expected (correct indentation, "
+            "no duplicate lines, etc). Edit the memory block again if necessary."
+        )
+
+        # return None
+        return success_msg
+
+    def memory_insert(
+        agent_state: "AgentState",
+        actor: User,
+        label: str,
+        new_str: str,
+        insert_line: int = -1,
+    ) -> str:
+        """
+        The memory_insert command allows you to insert text at a specific location
+        in a memory block.
+
+        Args:
+            label (str): Section of the memory to be edited, identified by its label.
+            new_str (str): The text to insert.
+            insert_line (int): The line number after which to insert the text (0 for
+                beginning of file). Defaults to -1 (end of the file).
+
+        Returns:
+            str: The success message
+        """
+        import re
+
+        if bool(re.search(r"\nLine \d+: ", new_str)):
+            raise ValueError(
+                "new_str contains a line number prefix, which is not allowed. Do not "
+                "include line numbers when calling memory tools (line numbers are for "
+                "display purposes only)."
+            )
+        if CORE_MEMORY_LINE_NUMBER_WARNING in new_str:
+            raise ValueError(
+                "new_str contains a line number warning, which is not allowed. Do not "
+                "include line number information when calling memory tools (line numbers "
+                "are for display purposes only)."
+            )
+
+        current_value = str(agent_state.memory.get_block(label).value).expandtabs()
+        new_str = str(new_str).expandtabs()
+        current_value_lines = current_value.split("\n")
+        n_lines = len(current_value_lines)
+
+        # Check if we're in range, from 0 (pre-line), to 1 (first line), to n_lines (last line)
+        if insert_line < 0 or insert_line > n_lines:
+            raise ValueError(
+                f"Invalid `insert_line` parameter: {insert_line}. It should be within "
+                f"the range of lines of the memory block: {[0, n_lines]}, or -1 to "
+                f"append to the end of the memory block."
+            )
+
+        # Insert the new string as a line
+        SNIPPET_LINES = 3
+        new_str_lines = new_str.split("\n")
+        new_value_lines = current_value_lines[:insert_line] + new_str_lines + current_value_lines[insert_line:]
+        snippet_lines = (
+            current_value_lines[max(0, insert_line - SNIPPET_LINES) : insert_line]
+            + new_str_lines
+            + current_value_lines[insert_line : insert_line + SNIPPET_LINES]
+        )
+
+        # Collate into the new value to update
+        new_value = "\n".join(new_value_lines)
+        snippet = "\n".join(snippet_lines)
+
+        # Write into the block
+        agent_state.memory.update_block_value(label=label, value=new_value)
+
+        AgentManager().update_memory_if_changed(agent_id=agent_state.id, new_memory=agent_state.memory, actor=actor)
+
+        # Prepare the success message
+        success_msg = f"The core memory block with label `{label}` has been edited. "
+        # success_msg += self._make_output(
+        #     snippet,
+        #     "a snippet of the edited file",
+        #     max(1, insert_line - SNIPPET_LINES + 1),
+        # )
+        # success_msg += f"A snippet of core memory block `{label}`:\n{snippet}\n"
+        success_msg += (
+            "Review the changes and make sure they are as expected (correct indentation, "
+            "no duplicate lines, etc). Edit the memory block again if necessary."
+        )
+
+        return success_msg
+
+    def memory_rethink(agent_state: "AgentState", actor: User, label: str, new_memory: str) -> str:
+        """
+        The memory_rethink command allows you to completely rewrite the contents of a
+        memory block. Use this tool to make large sweeping changes (e.g. when you want
+        to condense or reorganize the memory blocks), do NOT use this tool to make small
+        precise edits (e.g. add or remove a line, replace a specific string, etc).
+
+        Args:
+            label (str): The memory block to be rewritten, identified by its label.
+            new_memory (str): The new memory contents with information integrated from
+                existing memory blocks and the conversation context.
+
+        Returns:
+            str: The success message
+        """
+        import re
+
+        if bool(re.search(r"\nLine \d+: ", new_memory)):
+            raise ValueError(
+                "new_memory contains a line number prefix, which is not allowed. Do not "
+                "include line numbers when calling memory tools (line numbers are for "
+                "display purposes only)."
+            )
+        if CORE_MEMORY_LINE_NUMBER_WARNING in new_memory:
+            raise ValueError(
+                "new_memory contains a line number warning, which is not allowed. Do not "
+                "include line number information when calling memory tools (line numbers "
+                "are for display purposes only)."
+            )
+
+        if agent_state.memory.get_block(label) is None:
+            agent_state.memory.create_block(label=label, value=new_memory)
+
+        agent_state.memory.update_block_value(label=label, value=new_memory)
+
+        AgentManager().update_memory_if_changed(agent_id=agent_state.id, new_memory=agent_state.memory, actor=actor)
+
+        # Prepare the success message
+        success_msg = f"The core memory block with label `{label}` has been edited. "
+        # success_msg += self._make_output(
+        #     snippet, f"a snippet of {path}", start_line + 1
+        # )
+        # success_msg += f"A snippet of core memory block `{label}`:\n{snippet}\n"
+        success_msg += (
+            "Review the changes and make sure they are as expected (correct indentation, "
+            "no duplicate lines, etc). Edit the memory block again if necessary."
+        )
+
+        # return None
+        return success_msg
+
+    def memory_finish_edits(agent_state: "AgentState") -> None:
+        """
+        Call the memory_finish_edits command when you are finished making edits
+        (integrating all new information) into the memory blocks. This function
+        is called when the agent is done rethinking the memory.
+
+        Returns:
+            Optional[str]: None is always returned as this function does not produce a response.
+        """
+        return None
+
+
+class LettaMultiAgentToolExecutor(ToolExecutor):
+    """Executor for LETTA multi-agent core tools."""
+
+    # TODO: Implement
+    # def execute(self, function_name: str, function_args: dict, agent: "Agent", tool: Tool) -> ToolExecutionResult:
+    #     callable_func = get_function_from_module(LETTA_MULTI_AGENT_TOOL_MODULE_NAME, function_name)
+    #     function_args["self"] = agent  # need to attach self to arg since it's dynamically linked
+    #     function_response = callable_func(**function_args)
+    #     return ToolExecutionResult(func_return=function_response)
+
 
 class ExternalComposioToolExecutor(ToolExecutor):
     """Executor for external Composio tools."""
@@ -273,7 +493,7 @@ class ExternalComposioToolExecutor(ToolExecutor):
         actor: User,
         sandbox_config: Optional[SandboxConfig] = None,
         sandbox_env_vars: Optional[Dict[str, Any]] = None,
-    ) -> Tuple[Any, Optional[SandboxRunResult]]:
+    ) -> ToolExecutionResult:
         action_name = generate_composio_action_from_func_name(tool.name)
 
         # Get entity ID from the agent_state
@@ -287,7 +507,10 @@ class ExternalComposioToolExecutor(ToolExecutor):
             action_name=action_name, args=function_args, api_key=composio_api_key, entity_id=entity_id
         )
 
-        return function_response, None
+        return ToolExecutionResult(
+            status="success",
+            func_return=function_response,
+        )
 
     def _get_entity_id(self, agent_state: AgentState) -> Optional[str]:
         """Extract the entity ID from environment variables."""
@@ -302,8 +525,7 @@ class ExternalMCPToolExecutor(ToolExecutor):
 
     # TODO: Implement
     #
-    # def execute(self, function_name: str, function_args: dict, agent_state: AgentState, tool: Tool, actor: User) -> Tuple[
-    #     Any, Optional[SandboxRunResult]]:
+    # def execute(self, function_name: str, function_args: dict, agent_state: AgentState, tool: Tool, actor: User) -> ToolExecutionResult:
     #     # Get the server name from the tool tag
     #     server_name = self._extract_server_name(tool)
     #
@@ -316,8 +538,10 @@ class ExternalMCPToolExecutor(ToolExecutor):
     #     # Execute the tool
     #     function_response, is_error = mcp_client.execute_tool(tool_name=function_name, tool_args=function_args)
     #
-    #     sandbox_run_result = SandboxRunResult(status="error" if is_error else "success")
-    #     return function_response, sandbox_run_result
+    #     return ToolExecutionResult(
+    #         status="error" if is_error else "success",
+    #         func_return=function_response,
+    #     )
     #
     # def _extract_server_name(self, tool: Tool) -> str:
     #     """Extract server name from tool tags."""
@@ -360,7 +584,7 @@ class SandboxToolExecutor(ToolExecutor):
         actor: User,
         sandbox_config: Optional[SandboxConfig] = None,
         sandbox_env_vars: Optional[Dict[str, Any]] = None,
-    ) -> Tuple[Any, Optional[SandboxRunResult]]:
+    ) -> ToolExecutionResult:
 
         # Store original memory state
         orig_memory_str = agent_state.memory.compile()
@@ -381,21 +605,19 @@ class SandboxToolExecutor(ToolExecutor):
                     function_name, function_args, actor, tool_object=tool, sandbox_config=sandbox_config, sandbox_env_vars=sandbox_env_vars
                 )
 
-            sandbox_run_result = await sandbox.run(agent_state=agent_state_copy)
-
-            function_response, updated_agent_state = sandbox_run_result.func_return, sandbox_run_result.agent_state
+            tool_execution_result = await sandbox.run(agent_state=agent_state_copy)
 
             # Verify memory integrity
             assert orig_memory_str == agent_state.memory.compile(), "Memory should not be modified in a sandbox tool"
 
             # Update agent memory if needed
-            if updated_agent_state is not None:
-                AgentManager().update_memory_if_changed(agent_state.id, updated_agent_state.memory, actor)
+            if tool_execution_result.agent_state is not None:
+                AgentManager().update_memory_if_changed(agent_state.id, tool_execution_result.agent_state.memory, actor)
 
-            return function_response, sandbox_run_result
+            return tool_execution_result
 
         except Exception as e:
-            return self._handle_execution_error(e, function_name)
+            return self._handle_execution_error(e, function_name, traceback.format_exc())
 
     def _prepare_function_args(self, function_args: dict, tool: Tool, function_name: str) -> dict:
         """Prepare function arguments with proper type coercion."""
@@ -417,9 +639,18 @@ class SandboxToolExecutor(ToolExecutor):
         agent_state_copy.tool_rules = []
         return agent_state_copy
 
-    def _handle_execution_error(self, exception: Exception, function_name: str) -> Tuple[str, SandboxRunResult]:
+    def _handle_execution_error(
+        self,
+        exception: Exception,
+        function_name: str,
+        stderr: str,
+    ) -> ToolExecutionResult:
         """Handle tool execution errors."""
         error_message = get_friendly_error_msg(
             function_name=function_name, exception_name=type(exception).__name__, exception_message=str(exception)
         )
-        return error_message, SandboxRunResult(status="error")
+        return ToolExecutionResult(
+            status="error",
+            func_return=error_message,
+            stderr=[stderr],
+        )

letta/services/tool_sandbox/base.py

@@ -7,8 +7,9 @@ from typing import Any, Dict, Optional, Tuple
 
 from letta.functions.helpers import generate_model_from_args_json_schema
 from letta.schemas.agent import AgentState
-from letta.schemas.sandbox_config import SandboxConfig, SandboxRunResult
+from letta.schemas.sandbox_config import SandboxConfig
 from letta.schemas.tool import Tool
+from letta.schemas.tool_execution_result import ToolExecutionResult
 from letta.services.helpers.tool_execution_helper import add_imports_and_pydantic_schemas_for_args
 from letta.services.sandbox_config_manager import SandboxConfigManager
 from letta.services.tool_manager import ToolManager
@@ -64,7 +65,7 @@ class AsyncToolSandboxBase(ABC):
         self,
         agent_state: Optional[AgentState] = None,
         additional_env_vars: Optional[Dict] = None,
-    ) -> SandboxRunResult:
+    ) -> ToolExecutionResult:
         """
         Run the tool in a sandbox environment asynchronously.
         Must be implemented by subclasses.

letta/services/tool_sandbox/e2b_sandbox.py

@@ -2,8 +2,9 @@ from typing import Any, Dict, Optional
 
 from letta.log import get_logger
 from letta.schemas.agent import AgentState
-from letta.schemas.sandbox_config import SandboxConfig, SandboxRunResult, SandboxType
+from letta.schemas.sandbox_config import SandboxConfig, SandboxType
 from letta.schemas.tool import Tool
+from letta.schemas.tool_execution_result import ToolExecutionResult
 from letta.services.tool_sandbox.base import AsyncToolSandboxBase
 from letta.utils import get_friendly_error_msg
 
@@ -30,7 +31,7 @@ class AsyncToolSandboxE2B(AsyncToolSandboxBase):
         self,
         agent_state: Optional[AgentState] = None,
         additional_env_vars: Optional[Dict] = None,
-    ) -> SandboxRunResult:
+    ) -> ToolExecutionResult:
         """
         Run the tool in a sandbox environment asynchronously,
         *always* using a subprocess for execution.
@@ -45,7 +46,7 @@ class AsyncToolSandboxE2B(AsyncToolSandboxBase):
 
     async def run_e2b_sandbox(
         self, agent_state: Optional[AgentState] = None, additional_env_vars: Optional[Dict] = None
-    ) -> SandboxRunResult:
+    ) -> ToolExecutionResult:
         if self.provided_sandbox_config:
             sbx_config = self.provided_sandbox_config
         else:
@@ -94,7 +95,7 @@ class AsyncToolSandboxE2B(AsyncToolSandboxBase):
         else:
             raise ValueError(f"Tool {self.tool_name} returned execution with None")
 
-        return SandboxRunResult(
+        return ToolExecutionResult(
             func_return=func_return,
             agent_state=agent_state,
             stdout=execution.logs.stdout,

letta/services/tool_sandbox/local_sandbox.py

@@ -5,8 +5,9 @@ import tempfile
 from typing import Any, Dict, Optional, Tuple
 
 from letta.schemas.agent import AgentState
-from letta.schemas.sandbox_config import SandboxConfig, SandboxRunResult, SandboxType
+from letta.schemas.sandbox_config import SandboxConfig, SandboxType
 from letta.schemas.tool import Tool
+from letta.schemas.tool_execution_result import ToolExecutionResult
 from letta.services.helpers.tool_execution_helper import (
     create_venv_for_local_sandbox,
     find_python_executable,
@@ -39,7 +40,7 @@ class AsyncToolSandboxLocal(AsyncToolSandboxBase):
         self,
         agent_state: Optional[AgentState] = None,
         additional_env_vars: Optional[Dict] = None,
-    ) -> SandboxRunResult:
+    ) -> ToolExecutionResult:
         """
         Run the tool in a sandbox environment asynchronously,
         *always* using a subprocess for execution.
@@ -53,7 +54,11 @@ class AsyncToolSandboxLocal(AsyncToolSandboxBase):
         return result
 
     @trace_method
-    async def run_local_dir_sandbox(self, agent_state: Optional[AgentState], additional_env_vars: Optional[Dict]) -> SandboxRunResult:
+    async def run_local_dir_sandbox(
+        self,
+        agent_state: Optional[AgentState],
+        additional_env_vars: Optional[Dict],
+    ) -> ToolExecutionResult:
         """
         Unified asynchronougit pus method to run the tool in a local sandbox environment,
         always via subprocess for multi-core parallelism.
@@ -156,7 +161,7 @@ class AsyncToolSandboxLocal(AsyncToolSandboxBase):
     @trace_method
     async def _execute_tool_subprocess(
         self, sbx_config, python_executable: str, temp_file_path: str, env: Dict[str, str], cwd: str
-    ) -> SandboxRunResult:
+    ) -> ToolExecutionResult:
         """
         Execute user code in a subprocess, always capturing stdout and stderr.
         We parse special markers to extract the pickled result string.
@@ -189,7 +194,7 @@ class AsyncToolSandboxLocal(AsyncToolSandboxBase):
             func_result, stdout_text = self.parse_out_function_results_markers(stdout)
             func_return, agent_state = self.parse_best_effort(func_result)
 
-            return SandboxRunResult(
+            return ToolExecutionResult(
                 func_return=func_return,
                 agent_state=agent_state,
                 stdout=[stdout_text] if stdout_text else [],
@@ -209,7 +214,7 @@ class AsyncToolSandboxLocal(AsyncToolSandboxBase):
                 exception_name=type(e).__name__,
                 exception_message=str(e),
             )
-            return SandboxRunResult(
+            return ToolExecutionResult(
                 func_return=func_return,
                 agent_state=None,
                 stdout=[],

{letta_nightly-0.7.0.dev20250423003112.dist-info → letta_nightly-0.7.2.dev20250423222439.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.7.0.dev20250423003112
+Version: 0.7.2.dev20250423222439
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team