Platform for stateful agents: AI with advanced memory that can learn and self-improve over time.
fix: numerous tool execution bugs (#2371)
Andy Li595ef112215b
diff --git a/letta/__main__.py b/letta/__main__.pynew file mode 100644index 000000000..89f11424b--- /dev/null+++ b/letta/__main__.py@@ -0,0 +1,3 @@+from .main import app++app()diff --git a/letta/functions/ast_parsers.py b/letta/functions/ast_parsers.pyindex 3113cd963..620e8ba21 100644--- a/letta/functions/ast_parsers.py+++ b/letta/functions/ast_parsers.py@@ -5,23 +5,13 @@ import typingfrom typing import Dict, Optional, Tuplefrom letta.errors import LettaToolCreateError--# Registry of known types for annotation resolution-BUILTIN_TYPES = {- "int": int,- "float": float,- "str": str,- "dict": dict,- "list": list,- "set": set,- "tuple": tuple,- "bool": bool,-}+from letta.types import JsonDictdef resolve_type(annotation: str):"""Resolve a type annotation string into a Python type.+ Previously, primitive support for int, float, str, dict, list, set, tuple, bool.Args:annotation (str): The annotation string (e.g., 'int', 'list[int]', 'dict[str, int]').@@ -32,24 +22,19 @@ def resolve_type(annotation: str):Raises:ValueError: If the annotation is unsupported or invalid."""- if annotation in BUILTIN_TYPES:- return BUILTIN_TYPES[annotation]+ python_types = {**vars(typing), **vars(builtins)}++ if annotation in python_types:+ return python_types[annotation]try:# Allow use of typing and builtins in a safe eval context- namespace = {- **vars(typing),- **vars(builtins),- "list": list,- "dict": dict,- "tuple": tuple,- "set": set,- }- return eval(annotation, namespace)+ return eval(annotation, python_types)except Exception:raise ValueError(f"Unsupported annotation: {annotation}")+# TODO :: THIS MUST BE EDITED TO HANDLE THINGSdef get_function_annotations_from_source(source_code: str, function_name: str) -> Dict[str, str]:"""Parse the source code to extract annotations for a given function name.@@ -76,7 +61,8 @@ def get_function_annotations_from_source(source_code: str, function_name: str) -raise ValueError(f"Function '{function_name}' not found in the provided source code.")-def coerce_dict_args_by_annotations(function_args: dict, annotations: Dict[str, str]) -> dict:+# NOW json_loads -> ast.literal_eval -> typing.get_origin+def coerce_dict_args_by_annotations(function_args: JsonDict, annotations: Dict[str, str]) -> dict:coerced_args = dict(function_args) # Shallow copyfor arg_name, value in coerced_args.items():@@ -110,8 +96,8 @@ def coerce_dict_args_by_annotations(function_args: dict, annotations: Dict[str,return coerced_args-def get_function_name_and_description(source_code: str, name: Optional[str] = None) -> Tuple[str, str]:- """Gets the name and description for a given function source code by parsing the AST.+def get_function_name_and_docstring(source_code: str, name: Optional[str] = None) -> Tuple[str, str]:+ """Gets the name and docstring for a given function source code by parsing the AST.Args:source_code: The source code to parsediff --git a/letta/functions/schema_generator.py b/letta/functions/schema_generator.pyindex d26506302..6f1c003c6 100644--- a/letta/functions/schema_generator.py+++ b/letta/functions/schema_generator.py@@ -143,7 +143,10 @@ def pydantic_model_to_open_ai(model: Type[BaseModel]) -> dict:parameters["required"] = sorted(k for k, v in parameters["properties"].items() if "default" not in v)if "description" not in schema:- if docstring.short_description:+ # Support multiline docstrings for complex functions, TODO (cliandy): consider having this as a setting+ if docstring.long_description:+ schema["description"] = docstring.long_description+ elif docstring.short_description:schema["description"] = docstring.short_descriptionelse:raise ValueError(f"No description found in docstring or description field (model: {model}, docstring: {docstring})")@@ -330,10 +333,17 @@ def generate_schema(function, name: Optional[str] = None, description: Optional[# Parse the docstringdocstring = parse(function.__doc__)+ if not description:+ # Support multiline docstrings for complex functions, TODO (cliandy): consider having this as a setting+ if docstring.long_description:+ description = docstring.long_description+ else:+ description = docstring.short_description+# Prepare the schema dictionaryschema = {"name": function.__name__ if name is None else name,- "description": docstring.short_description if description is None else description,+ "description": description,"parameters": {"type": "object", "properties": {}, "required": []},}diff --git a/letta/schemas/message.py b/letta/schemas/message.pyindex 36c29ef61..1b684094d 100644--- a/letta/schemas/message.py+++ b/letta/schemas/message.py@@ -654,6 +654,8 @@ class Message(BaseMessage):parse_content_parts = Falseif self.content and len(self.content) == 1 and isinstance(self.content[0], TextContent):text_content = self.content[0].text+ elif self.content and len(self.content) == 1 and isinstance(self.content[0], ToolReturnContent):+ text_content = self.content[0].content# Otherwise, check if we have TextContent and multiple other partselif self.content and len(self.content) > 1:text = [content for content in self.content if isinstance(content, TextContent)]@@ -866,6 +868,8 @@ class Message(BaseMessage):# role: str ('user' or 'model')if self.content and len(self.content) == 1 and isinstance(self.content[0], TextContent):text_content = self.content[0].text+ elif self.content and len(self.content) == 1 and isinstance(self.content[0], ToolReturnContent):+ text_content = self.content[0].contentelse:text_content = None@@ -1000,6 +1004,8 @@ class Message(BaseMessage):# embedded function calls in multi-turn conversation become more clearif self.content and len(self.content) == 1 and isinstance(self.content[0], TextContent):text_content = self.content[0].text+ if self.content and len(self.content) == 1 and isinstance(self.content[0], ToolReturnContent):+ text_content = self.content[0].contentelse:text_content = Noneif self.role == "system":diff --git a/letta/schemas/tool.py b/letta/schemas/tool.pyindex 81e97aa21..af20bd2ab 100644--- a/letta/schemas/tool.py+++ b/letta/schemas/tool.py@@ -11,7 +11,7 @@ from letta.constants import (LETTA_VOICE_TOOL_MODULE_NAME,MCP_TOOL_TAG_NAME_PREFIX,)-from letta.functions.ast_parsers import get_function_name_and_description+from letta.functions.ast_parsers import get_function_name_and_docstringfrom letta.functions.composio_helpers import generate_composio_tool_wrapperfrom letta.functions.functions import derive_openai_json_schema, get_json_schema_from_modulefrom letta.functions.mcp_client.types import MCPTool@@ -84,7 +84,7 @@ class Tool(BaseTool):# TODO: We skip this for Composio bc composio json schemas are derived differentlyif not (COMPOSIO_TOOL_TAG_NAME in self.tags):if self.args_json_schema is not None:- name, description = get_function_name_and_description(self.source_code, self.name)+ name, description = get_function_name_and_docstring(self.source_code, self.name)args_schema = generate_model_from_args_json_schema(self.args_json_schema)self.json_schema = generate_schema_from_args_schema_v2(args_schema=args_schema,diff --git a/letta/server/rest_api/interface.py b/letta/server/rest_api/interface.pyindex 33085408a..b930f7743 100644--- a/letta/server/rest_api/interface.py+++ b/letta/server/rest_api/interface.py@@ -1338,8 +1338,8 @@ class StreamingServerInterface(AgentChunkStreamingInterface):tool_return=msg,status=msg_obj.tool_returns[0].status if msg_obj.tool_returns else "success",tool_call_id=msg_obj.tool_call_id,- stdout=msg_obj.tool_returns[0].stdout if msg_obj.tool_returns else None,- stderr=msg_obj.tool_returns[0].stderr if msg_obj.tool_returns else None,+ stdout=msg_obj.tool_returns[0].stdout if msg_obj.tool_returns else [],+ stderr=msg_obj.tool_returns[0].stderr if msg_obj.tool_returns else [],name=msg_obj.name,otid=Message.generate_otid_from_id(msg_obj.id, chunk_index) if chunk_index is not None else None,)@@ -1354,8 +1354,8 @@ class StreamingServerInterface(AgentChunkStreamingInterface):tool_return=msg,status=msg_obj.tool_returns[0].status if msg_obj.tool_returns else "error",tool_call_id=msg_obj.tool_call_id,- stdout=msg_obj.tool_returns[0].stdout if msg_obj.tool_returns else None,- stderr=msg_obj.tool_returns[0].stderr if msg_obj.tool_returns else None,+ stdout=msg_obj.tool_returns[0].stdout if msg_obj.tool_returns else [],+ stderr=msg_obj.tool_returns[0].stderr if msg_obj.tool_returns else [],name=msg_obj.name,otid=Message.generate_otid_from_id(msg_obj.id, chunk_index) if chunk_index is not None else None,)diff --git a/letta/services/helpers/tool_execution_helper.py b/letta/services/helpers/tool_execution_helper.pyindex 043594cc6..34ea17afd 100644--- a/letta/services/helpers/tool_execution_helper.py+++ b/letta/services/helpers/tool_execution_helper.py@@ -60,6 +60,9 @@ def run_subprocess(command: list, env: Optional[Dict[str, str]] = None, fail_msgexcept subprocess.CalledProcessError as e:logger.error(f"{fail_msg}\nSTDOUT:\n{e.stdout}\nSTDERR:\n{e.stderr}")raise RuntimeError(f"{fail_msg}: {e.stderr.strip()}") from e+ except Exception as e:+ logger.error(f"{fail_msg}: {e}")+ raise RuntimeError(f"{fail_msg}: {e}")def ensure_pip_is_up_to_date(python_exec: str, env: Optional[Dict[str, str]] = None):diff --git a/letta/services/helpers/tool_parser_helper.py b/letta/services/helpers/tool_parser_helper.pynew file mode 100644index 000000000..36798a914--- /dev/null+++ b/letta/services/helpers/tool_parser_helper.py@@ -0,0 +1,63 @@+import ast+import base64+import pickle+from typing import Any++from letta.schemas.agent import AgentState+from letta.types import JsonValue+++def parse_stdout_best_effort(text: str | bytes) -> tuple[Any, AgentState | None]:+ """+ Decode and unpickle the result from the function execution if possible.+ Returns (function_return_value, agent_state).+ """+ if not text:+ return None, None+ if isinstance(text, str):+ text = base64.b64decode(text)+ result = pickle.loads(text)+ agent_state = result["agent_state"]+ return result["results"], agent_state+++def parse_function_arguments(source_code: str, tool_name: str):+ """Get arguments of a function from its source code"""+ tree = ast.parse(source_code)+ args = []+ for node in ast.walk(tree):+ if isinstance(node, ast.FunctionDef) and node.name == tool_name:+ for arg in node.args.args:+ args.append(arg.arg)+ return args+++def convert_param_to_str_value(param_type: str, raw_value: JsonValue) -> str:+ """+ Convert parameter to Python code representation based on JSON schema type.+ TODO (cliandy): increase sanitization checks here to fail at the right place+ """++ valid_types = {"string", "integer", "boolean", "number", "array", "object"}+ if param_type not in valid_types:+ raise TypeError(f"Unsupported type: {param_type}, raw_value={raw_value}")+ if param_type == "string":+ # Safely handle python string+ return repr(raw_value)+ if param_type == "integer":+ return str(int(raw_value))+ if param_type == "boolean":+ if isinstance(raw_value, bool):+ return str(raw_value)+ if isinstance(raw_value, int) and raw_value in (0, 1):+ return str(bool(raw_value))+ if isinstance(raw_value, str) and raw_value.strip().lower() in ("true", "false"):+ return raw_value.strip().lower().capitalize()+ raise ValueError(f"Invalid boolean value: {raw_value}")+ if param_type == "array":+ pass # need more testing here+ # if isinstance(raw_value, str):+ # if raw_value.strip()[0] != "[" or raw_value.strip()[-1] != "]":+ # raise ValueError(f'Invalid array value: "{raw_value}"')+ # return raw_value.strip()+ return str(raw_value)diff --git a/letta/services/tool_executor/tool_execution_sandbox.py b/letta/services/tool_executor/tool_execution_sandbox.pyindex e466cd9e0..4d60de8f7 100644--- a/letta/services/tool_executor/tool_execution_sandbox.py+++ b/letta/services/tool_executor/tool_execution_sandbox.py@@ -1,4 +1,3 @@-import astimport base64import ioimport os@@ -23,6 +22,7 @@ from letta.services.helpers.tool_execution_helper import (find_python_executable,install_pip_requirements_for_sandbox,)+from letta.services.helpers.tool_parser_helper import convert_param_to_str_value, parse_function_argumentsfrom letta.services.organization_manager import OrganizationManagerfrom letta.services.sandbox_config_manager import SandboxConfigManagerfrom letta.services.tool_manager import ToolManager@@ -52,7 +52,6 @@ class ToolExecutionSandbox:self.tool_name = tool_nameself.args = argsself.user = user- # get organizationself.organization = OrganizationManager().get_organization_by_id(self.user.organization_id)self.privileged_tools = self.organization.privileged_tools@@ -476,16 +475,6 @@ class ToolExecutionSandbox:agent_state = result["agent_state"]return result["results"], agent_state- def parse_function_arguments(self, source_code: str, tool_name: str):- """Get arguments of a function from its source code"""- tree = ast.parse(source_code)- args = []- for node in ast.walk(tree):- if isinstance(node, ast.FunctionDef) and node.name == tool_name:- for arg in node.args.args:- args.append(arg.arg)- return args-def generate_execution_script(self, agent_state: AgentState, wrap_print_with_markers: bool = False) -> str:"""Generate code to run inside of execution sandbox.@@ -498,7 +487,7 @@ class ToolExecutionSandbox:Returns:code (str): The generated code strong"""- if "agent_state" in self.parse_function_arguments(self.tool.source_code, self.tool.name):+ if "agent_state" in parse_function_arguments(self.tool.source_code, self.tool.name):inject_agent_state = Trueelse:inject_agent_state = False@@ -546,7 +535,7 @@ class ToolExecutionSandbox:code += (self.LOCAL_SANDBOX_RESULT_VAR_NAME+ ' = {"results": '- + self.invoke_function_call(inject_agent_state=inject_agent_state)+ + self.invoke_function_call(inject_agent_state=inject_agent_state) # this inject_agent_state is the main difference+ ', "agent_state": agent_state}\n')code += (@@ -562,24 +551,6 @@ class ToolExecutionSandbox:return code- def _convert_param_to_value(self, param_type: str, raw_value: str) -> str:-- if param_type == "string":- value = "pickle.loads(" + str(pickle.dumps(raw_value)) + ")"-- elif param_type == "integer" or param_type == "boolean" or param_type == "number":- value = raw_value-- elif param_type == "array":- value = raw_value-- elif param_type == "object":- value = raw_value-- else:- raise TypeError(f"Unsupported type: {param_type}, raw_value={raw_value}")- return str(value)-def initialize_param(self, name: str, raw_value: str) -> str:params = self.tool.json_schema["parameters"]["properties"]spec = params.get(name)@@ -591,8 +562,7 @@ class ToolExecutionSandbox:if param_type is None and spec.get("parameters"):param_type = spec["parameters"].get("type")- value = self._convert_param_to_value(param_type, raw_value)-+ value = convert_param_to_str_value(param_type, raw_value)return name + " = " + value + "\n"def invoke_function_call(self, inject_agent_state: bool) -> str:diff --git a/letta/services/tool_executor/tool_executor.py b/letta/services/tool_executor/tool_executor.pyindex 0e1fbe016..17866aaa8 100644--- a/letta/services/tool_executor/tool_executor.py+++ b/letta/services/tool_executor/tool_executor.py@@ -39,6 +39,7 @@ from letta.services.tool_sandbox.e2b_sandbox import AsyncToolSandboxE2Bfrom letta.services.tool_sandbox.local_sandbox import AsyncToolSandboxLocalfrom letta.settings import tool_settingsfrom letta.tracing import trace_method+from letta.types import JsonDictfrom letta.utils import get_friendly_error_msglogger = get_logger(__name__)@@ -107,11 +108,20 @@ class LettaCoreToolExecutor(ToolExecutor):# Execute the appropriate functionfunction_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 ToolExecutionResult(- status="success",- func_return=function_response,- )+ try:+ function_response = function_map[function_name](agent_state, actor, **function_args_copy)+ return ToolExecutionResult(+ status="success",+ func_return=function_response,+ agent_state=agent_state,+ )+ except Exception as e:+ return ToolExecutionResult(+ status="error",+ func_return=e,+ agent_state=agent_state,+ stderr=[get_friendly_error_msg(function_name=function_name, exception_name=type(e).__name__, exception_message=str(e))],+ )def send_message(self, agent_state: AgentState, actor: User, message: str) -> Optional[str]:"""@@ -708,7 +718,7 @@ class SandboxToolExecutor(ToolExecutor):async def execute(self,function_name: str,- function_args: dict,+ function_args: JsonDict,agent_state: AgentState,tool: Tool,actor: User,@@ -749,7 +759,8 @@ class SandboxToolExecutor(ToolExecutor):except Exception as e: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:+ @staticmethod+ def _prepare_function_args(function_args: JsonDict, tool: Tool, function_name: str) -> dict:"""Prepare function arguments with proper type coercion."""try:# Parse the source code to extract function annotations@@ -761,7 +772,8 @@ class SandboxToolExecutor(ToolExecutor):# This is defensive programming - we try to coerce but fall back if it failsreturn function_args- def _create_agent_state_copy(self, agent_state: AgentState):+ @staticmethod+ def _create_agent_state_copy(agent_state: AgentState):"""Create a copy of agent state for sandbox execution."""agent_state_copy = agent_state.__deepcopy__()# Remove tools from copy to prevent nested tool execution@@ -769,8 +781,8 @@ class SandboxToolExecutor(ToolExecutor):agent_state_copy.tool_rules = []return agent_state_copy+ @staticmethoddef _handle_execution_error(- self,exception: Exception,function_name: str,stderr: str,@@ -812,6 +824,7 @@ class LettaBuiltinToolExecutor(ToolExecutor):return ToolExecutionResult(status="success",func_return=function_response,+ agent_state=agent_state,)async def run_code(self, code: str, language: Literal["python", "js", "ts", "r", "java"]) -> str:diff --git a/letta/services/tool_sandbox/base.py b/letta/services/tool_sandbox/base.pyindex 71d76e947..e21d4743d 100644--- a/letta/services/tool_sandbox/base.py+++ b/letta/services/tool_sandbox/base.py@@ -1,9 +1,7 @@-import ast-import base64import pickleimport uuidfrom abc import ABC, abstractmethod-from typing import Any, Dict, Optional, Tuple+from typing import Any, Dict, Optionalfrom letta.functions.helpers import generate_model_from_args_json_schemafrom letta.schemas.agent import AgentState@@ -11,20 +9,21 @@ from letta.schemas.sandbox_config import SandboxConfigfrom letta.schemas.tool import Toolfrom letta.schemas.tool_execution_result import ToolExecutionResultfrom letta.services.helpers.tool_execution_helper import add_imports_and_pydantic_schemas_for_args+from letta.services.helpers.tool_parser_helper import convert_param_to_str_value, parse_function_argumentsfrom letta.services.sandbox_config_manager import SandboxConfigManagerfrom letta.services.tool_manager import ToolManager+from letta.types import JsonDict, JsonValueclass AsyncToolSandboxBase(ABC):NAMESPACE = uuid.NAMESPACE_DNS- LOCAL_SANDBOX_RESULT_START_MARKER = str(uuid.uuid5(NAMESPACE, "local-sandbox-result-start-marker"))- LOCAL_SANDBOX_RESULT_END_MARKER = str(uuid.uuid5(NAMESPACE, "local-sandbox-result-end-marker"))+ LOCAL_SANDBOX_RESULT_START_MARKER = uuid.uuid5(NAMESPACE, "local-sandbox-result-start-marker").bytesLOCAL_SANDBOX_RESULT_VAR_NAME = "result_ZQqiequkcFwRwwGQMqkt"def __init__(self,tool_name: str,- args: dict,+ args: JsonDict,user,tool_object: Optional[Tool] = None,sandbox_config: Optional[SandboxConfig] = None,@@ -48,7 +47,7 @@ class AsyncToolSandboxBase(ABC):self._sandbox_config_manager = None# See if we should inject agent_state or not based on the presence of the "agent_state" arg- if "agent_state" in self.parse_function_arguments(self.tool.source_code, self.tool.name):+ if "agent_state" in parse_function_arguments(self.tool.source_code, self.tool.name):self.inject_agent_state = Trueelse:self.inject_agent_state = False@@ -74,83 +73,50 @@ class AsyncToolSandboxBase(ABC):def generate_execution_script(self, agent_state: Optional[AgentState], wrap_print_with_markers: bool = False) -> str:"""- Generate code to run inside of execution sandbox.- Serialize the agent state and arguments, call the tool,- then base64-encode/pickle the result.+ Generate code to run inside of execution sandbox. Serialize the agent state and arguments, call the tool,+ then base64-encode/pickle the result. Runs a jinja2 template constructing the python file."""- code = "from typing import *\n"- code += "import pickle\n"- code += "import sys\n"- code += "import base64\n"+ from letta.templates.template_helper import render_template- # Additional imports to support agent state- if self.inject_agent_state:- code += "import letta\n"- code += "from letta import * \n"+ TEMPLATE_NAME = "sandbox_code_file.py.j2"++ future_import = False+ schema_code = None- # Add schema code if availableif self.tool.args_json_schema:+ # Add schema code if availableschema_code = add_imports_and_pydantic_schemas_for_args(self.tool.args_json_schema)if "from __future__ import annotations" in schema_code:schema_code = schema_code.replace("from __future__ import annotations", "").lstrip()- code = "from __future__ import annotations\n\n" + code- code += schema_code + "\n"-- # Load the agent state- if self.inject_agent_state:- agent_state_pickle = pickle.dumps(agent_state)- code += f"agent_state = pickle.loads({agent_state_pickle})\n"- else:- code += "agent_state = None\n"+ future_import = True- # Initialize arguments- if self.tool.args_json_schema:+ # Initialize argumentsargs_schema = generate_model_from_args_json_schema(self.tool.args_json_schema)- code += f"args_object = {args_schema.__name__}(**{self.args})\n"+ tool_args = f"args_object = {args_schema.__name__}(**{self.args})\n"for param in self.args:- code += f"{param} = args_object.{param}\n"+ tool_args += f"{param} = args_object.{param}\n"else:+ tool_args = ""for param in self.args:- code += self.initialize_param(param, self.args[param])-- # Insert the tool's source code- code += "\n" + self.tool.source_code + "\n"-- # Invoke the function and store the result in a global variable- code += (- f"{self.LOCAL_SANDBOX_RESULT_VAR_NAME}" + ' = {"results": ' + self.invoke_function_call() + ', "agent_state": agent_state}\n'- )- code += (- f"{self.LOCAL_SANDBOX_RESULT_VAR_NAME} = base64.b64encode("- f"pickle.dumps({self.LOCAL_SANDBOX_RESULT_VAR_NAME})"- ").decode('utf-8')\n"+ tool_args += self.initialize_param(param, self.args[param])++ agent_state_pickle = pickle.dumps(agent_state) if self.inject_agent_state else None++ return render_template(+ TEMPLATE_NAME,+ future_import=future_import,+ inject_agent_state=self.inject_agent_state,+ schema_imports=schema_code,+ agent_state_pickle=agent_state_pickle,+ tool_args=tool_args,+ tool_source_code=self.tool.source_code,+ local_sandbox_result_var_name=self.LOCAL_SANDBOX_RESULT_VAR_NAME,+ invoke_function_call=self.invoke_function_call(),+ wrap_print_with_markers=wrap_print_with_markers,+ start_marker=self.LOCAL_SANDBOX_RESULT_START_MARKER,)- if wrap_print_with_markers:- code += f"sys.stdout.write('{self.LOCAL_SANDBOX_RESULT_START_MARKER}')\n"- code += f"sys.stdout.write(str({self.LOCAL_SANDBOX_RESULT_VAR_NAME}))\n"- code += f"sys.stdout.write('{self.LOCAL_SANDBOX_RESULT_END_MARKER}')\n"- else:- code += f"{self.LOCAL_SANDBOX_RESULT_VAR_NAME}\n"-- return code-- def _convert_param_to_value(self, param_type: str, raw_value: str) -> str:- """- Convert parameter to Python code representation based on JSON schema type.- """- if param_type == "string":- # Safely inject a Python string via pickle- value = "pickle.loads(" + str(pickle.dumps(raw_value)) + ")"- elif param_type in ["integer", "boolean", "number", "array", "object"]:- # This is simplistic. In real usage, ensure correct type-casting or sanitization.- value = raw_value- else:- raise TypeError(f"Unsupported type: {param_type}, raw_value={raw_value}")-- return str(value)-- def initialize_param(self, name: str, raw_value: str) -> str:+ def initialize_param(self, name: str, raw_value: JsonValue) -> str:"""Produce code for initializing a single parameter in the generated script."""@@ -164,7 +130,7 @@ class AsyncToolSandboxBase(ABC):if param_type is None and spec.get("parameters"):param_type = spec["parameters"].get("type")- value = self._convert_param_to_value(param_type, raw_value)+ value = convert_param_to_str_value(param_type, raw_value)return f"{name} = {value}\n"def invoke_function_call(self) -> str:@@ -184,24 +150,5 @@ class AsyncToolSandboxBase(ABC):func_call_str = self.tool.name + "(" + params + ")"return func_call_str- def parse_best_effort(self, text: str) -> Tuple[Any, Optional[AgentState]]:- """- Decode and unpickle the result from the function execution if possible.- Returns (function_return_value, agent_state).- """- if not text:- return None, None-- result = pickle.loads(base64.b64decode(text))- agent_state = result["agent_state"]- return result["results"], agent_state-- def parse_function_arguments(self, source_code: str, tool_name: str):- """Get arguments of a function from its source code"""- tree = ast.parse(source_code)- args = []- for node in ast.walk(tree):- if isinstance(node, ast.FunctionDef) and node.name == tool_name:- for arg in node.args.args:- args.append(arg.arg)- return args+ def _update_env_vars(self):+ pass # TODOdiff --git a/letta/services/tool_sandbox/e2b_sandbox.py b/letta/services/tool_sandbox/e2b_sandbox.pyindex 07ab57276..ea07f1f11 100644--- a/letta/services/tool_sandbox/e2b_sandbox.py+++ b/letta/services/tool_sandbox/e2b_sandbox.py@@ -1,16 +1,23 @@-from typing import Any, Dict, Optional+from typing import TYPE_CHECKING, Any, Dict, Optional++from e2b_code_interpreter import AsyncSandboxfrom letta.log import get_loggerfrom letta.schemas.agent import AgentStatefrom letta.schemas.sandbox_config import SandboxConfig, SandboxTypefrom letta.schemas.tool import Toolfrom letta.schemas.tool_execution_result import ToolExecutionResult+from letta.services.helpers.tool_parser_helper import parse_stdout_best_effortfrom letta.services.tool_sandbox.base import AsyncToolSandboxBasefrom letta.tracing import log_event, trace_method+from letta.types import JsonDictfrom letta.utils import get_friendly_error_msglogger = get_logger(__name__)+if TYPE_CHECKING:+ from e2b_code_interpreter import Execution+class AsyncToolSandboxE2B(AsyncToolSandboxBase):METADATA_CONFIG_STATE_KEY = "config_state"@@ -18,9 +25,9 @@ class AsyncToolSandboxE2B(AsyncToolSandboxBase):def __init__(self,tool_name: str,- args: dict,+ args: JsonDict,user,- force_recreate=True,+ force_recreate: bool = True,tool_object: Optional[Tool] = None,sandbox_config: Optional[SandboxConfig] = None,sandbox_env_vars: Optional[Dict[str, Any]] = None,@@ -92,7 +99,7 @@ class AsyncToolSandboxE2B(AsyncToolSandboxBase):)execution = await e2b_sandbox.run_code(code, envs=env_vars)if execution.results:- func_return, agent_state = self.parse_best_effort(execution.results[0].text)+ func_return, agent_state = parse_stdout_best_effort(execution.results[0].text)log_event("e2b_execution_succeeded",{@@ -138,16 +145,15 @@ class AsyncToolSandboxE2B(AsyncToolSandboxBase):sandbox_config_fingerprint=sbx_config.fingerprint(),)- def parse_exception_from_e2b_execution(self, e2b_execution: "Execution") -> Exception:+ @staticmethod+ def parse_exception_from_e2b_execution(e2b_execution: "Execution") -> Exception:builtins_dict = __builtins__ if isinstance(__builtins__, dict) else vars(__builtins__)# Dynamically fetch the exception class from builtins, defaulting to Exception if not foundexception_class = builtins_dict.get(e2b_execution.error.name, Exception)return exception_class(e2b_execution.error.value)@trace_method- async def create_e2b_sandbox_with_metadata_hash(self, sandbox_config: SandboxConfig) -> "Sandbox":- from e2b_code_interpreter import AsyncSandbox-+ async def create_e2b_sandbox_with_metadata_hash(self, sandbox_config: SandboxConfig) -> "AsyncSandbox":state_hash = sandbox_config.fingerprint()e2b_config = sandbox_config.get_e2b_config()@@ -194,8 +200,7 @@ class AsyncToolSandboxE2B(AsyncToolSandboxBase):return sbx- async def list_running_e2b_sandboxes(self):- from e2b_code_interpreter import AsyncSandbox-+ @staticmethod+ async def list_running_e2b_sandboxes():# List running sandboxes and access metadata.return await AsyncSandbox.list()diff --git a/letta/services/tool_sandbox/local_sandbox.py b/letta/services/tool_sandbox/local_sandbox.pyindex 276409516..8fe34870a 100644--- a/letta/services/tool_sandbox/local_sandbox.py+++ b/letta/services/tool_sandbox/local_sandbox.py@@ -1,8 +1,12 @@import asyncio+import hashlibimport os+import structimport sysimport tempfile-from typing import Any, Dict, Optional, Tuple+from typing import Any, Dict, Optional++from pydantic.config import JsonDictfrom letta.schemas.agent import AgentStatefrom letta.schemas.sandbox_config import SandboxConfig, SandboxType@@ -13,10 +17,11 @@ from letta.services.helpers.tool_execution_helper import (find_python_executable,install_pip_requirements_for_sandbox,)+from letta.services.helpers.tool_parser_helper import parse_stdout_best_effortfrom letta.services.tool_sandbox.base import AsyncToolSandboxBasefrom letta.settings import tool_settingsfrom letta.tracing import log_event, trace_method-from letta.utils import get_friendly_error_msg+from letta.utils import get_friendly_error_msg, parse_stderr_error_msgclass AsyncToolSandboxLocal(AsyncToolSandboxBase):@@ -26,7 +31,7 @@ class AsyncToolSandboxLocal(AsyncToolSandboxBase):def __init__(self,tool_name: str,- args: dict,+ args: JsonDict,user,force_recreate_venv=False,tool_object: Optional[Tool] = None,@@ -123,7 +128,15 @@ class AsyncToolSandboxLocal(AsyncToolSandboxBase):# If not using venv, use whatever Python we are running onpython_executable = sys.executable- exec_env["PYTHONWARNINGS"] = "ignore"+ # handle unwanted terminal behavior+ exec_env.update(+ {+ "PYTHONWARNINGS": "ignore",+ "NO_COLOR": "1",+ "TERM": "dumb",+ "PYTHONUNBUFFERED": "1",+ }+ )# Execute in subprocessreturn await self._execute_tool_subprocess(@@ -170,6 +183,7 @@ class AsyncToolSandboxLocal(AsyncToolSandboxBase):Execute user code in a subprocess, always capturing stdout and stderr.We parse special markers to extract the pickled result string."""+ stdout_text = ""try:log_event(name="start subprocess")@@ -190,13 +204,20 @@ class AsyncToolSandboxLocal(AsyncToolSandboxBase):raise TimeoutError(f"Executing tool {self.tool_name} timed out after 60 seconds.")- stdout = stdout_bytes.decode("utf-8") if stdout_bytes else ""stderr = stderr_bytes.decode("utf-8") if stderr_bytes else ""log_event(name="finish subprocess")# Parse markers to isolate the function result- func_result, stdout_text = self.parse_out_function_results_markers(stdout)- func_return, agent_state = self.parse_best_effort(func_result)+ func_result_bytes, stdout_text = self.parse_out_function_results_markers(stdout_bytes)+ func_return, agent_state = parse_stdout_best_effort(func_result_bytes)++ if process.returncode != 0 and func_return is None:+ exception_name, msg = parse_stderr_error_msg(stderr)+ func_return = get_friendly_error_msg(+ function_name=self.tool_name,+ exception_name=exception_name,+ exception_message=msg,+ )return ToolExecutionResult(func_return=func_return,@@ -213,6 +234,8 @@ class AsyncToolSandboxLocal(AsyncToolSandboxBase):raise eprint(f"Subprocess execution for tool {self.tool_name} encountered an error: {e}")+ print(e.__class__.__name__)+ print(e.__traceback__)func_return = get_friendly_error_msg(function_name=self.tool_name,exception_name=type(e).__name__,@@ -221,27 +244,32 @@ class AsyncToolSandboxLocal(AsyncToolSandboxBase):return ToolExecutionResult(func_return=func_return,agent_state=None,- stdout=[],+ stdout=[stdout_text],stderr=[str(e)],status="error",sandbox_config_fingerprint=sbx_config.fingerprint(),)- def parse_out_function_results_markers(self, text: str) -> Tuple[str, str]:+ def parse_out_function_results_markers(self, data: bytes) -> tuple[bytes, str]:"""Parse the function results out of the stdout using special markers.- Returns (function_result_str, stripped_stdout).+ Returns (function_results_bytes, stripped_stdout_bytes)."""- if self.LOCAL_SANDBOX_RESULT_START_MARKER not in text:- # No markers found, so nothing to parse- return "", text-- marker_len = len(self.LOCAL_SANDBOX_RESULT_START_MARKER)- start_index = text.index(self.LOCAL_SANDBOX_RESULT_START_MARKER) + marker_len- end_index = text.index(self.LOCAL_SANDBOX_RESULT_END_MARKER)-- # The actual pickled base64 is between start_index and end_index- results_str = text[start_index:end_index]- # The rest of stdout (minus the markers)- remainder = text[: start_index - marker_len] + text[end_index + marker_len :]- return results_str, remainder+ pos = data.find(self.LOCAL_SANDBOX_RESULT_START_MARKER)+ if pos < 0:+ return b"", data.decode("utf-8") if data else ""++ DATA_LENGTH_INDICATOR = 4+ CHECKSUM_LENGTH = 32+ pos_start = pos + len(self.LOCAL_SANDBOX_RESULT_START_MARKER)+ checksum_start = pos_start + DATA_LENGTH_INDICATOR+ message_start = checksum_start + CHECKSUM_LENGTH++ message_len = struct.unpack(">I", data[pos_start:checksum_start])[0]+ checksum = data[checksum_start:message_start]+ message_data = data[message_start : message_start + message_len]+ actual_checksum = hashlib.md5(message_data).hexdigest().encode("ascii")+ if actual_checksum == checksum:+ remainder = data[:pos] + data[message_start + message_len :]+ return message_data, (remainder.decode("utf-8") if remainder else "")+ raise Exception("Function ran, but output is corrupted.")diff --git a/letta/templates/__init__.py b/letta/templates/__init__.pynew file mode 100644index 000000000..e69de29bbdiff --git a/letta/templates/sandbox_code_file.py.j2 b/letta/templates/sandbox_code_file.py.j2new file mode 100644index 000000000..953b8ae86--- /dev/null+++ b/letta/templates/sandbox_code_file.py.j2@@ -0,0 +1,47 @@+{{ 'from __future__ import annotations' if future_import else '' }}+from typing import *+import pickle+import sys+import base64+import struct+import hashlib++{# Additional imports to support agent state #}+{% if inject_agent_state %}+import letta+from letta import *+{% endif %}++{# Add schema code if available #}+{{ schema_imports or ''}}++{# Load agent state #}+agent_state = {{ 'pickle.loads(' ~ agent_state_pickle ~ ')' if agent_state_pickle else 'None' }}++{{ tool_args }}++{# The tool's source code #}+{{ tool_source_code }}++{# Invoke the function and store the result in a global variable #}+{{ local_sandbox_result_var_name }} = {+ "results": {{ invoke_function_call }},+ "agent_state": agent_state+}++{{ local_sandbox_result_var_name }}_pkl = pickle.dumps({{ local_sandbox_result_var_name }})++{% if wrap_print_with_markers %}+{# Combine everything to flush and write at once. #}+data_checksum = hashlib.md5({{ local_sandbox_result_var_name }}_pkl).hexdigest().encode('ascii')+{{ local_sandbox_result_var_name }}_msg = (+ {{ start_marker }} ++ struct.pack('>I', len({{ local_sandbox_result_var_name }}_pkl)) ++ data_checksum ++ {{ local_sandbox_result_var_name }}_pkl+)+sys.stdout.buffer.write({{ local_sandbox_result_var_name }}_msg)+sys.stdout.buffer.flush()+{% else %}+base64.b64encode({{ local_sandbox_result_var_name }}_pkl).decode('utf-8')+{% endif %}diff --git a/letta/templates/template_helper.py b/letta/templates/template_helper.pynew file mode 100644index 000000000..0d2359cef--- /dev/null+++ b/letta/templates/template_helper.py@@ -0,0 +1,16 @@+import os++from jinja2 import Environment, FileSystemLoader, StrictUndefined++TEMPLATE_DIR = os.path.dirname(__file__)+jinja_env = Environment(+ loader=FileSystemLoader(TEMPLATE_DIR),+ undefined=StrictUndefined,+ trim_blocks=True,+ lstrip_blocks=True,+)+++def render_template(template_name: str, **kwargs):+ template = jinja_env.get_template(template_name)+ return template.render(**kwargs)diff --git a/letta/types/__init__.py b/letta/types/__init__.pyindex e69de29bb..b0f83c651 100644--- a/letta/types/__init__.py+++ b/letta/types/__init__.py@@ -0,0 +1,7 @@+from typing import Any, TypeAlias++from pydantic import JsonValue++JsonDict: TypeAlias = dict[str, JsonValue]++__all__ = ["JsonDict", "JsonValue"]diff --git a/letta/utils.py b/letta/utils.pyindex a23735b2d..069d0a1a1 100644--- a/letta/utils.py+++ b/letta/utils.py@@ -1034,6 +1034,20 @@ def get_friendly_error_msg(function_name: str, exception_name: str, exception_mereturn error_msg+def parse_stderr_error_msg(stderr_txt: str, last_n_lines: int = 3) -> tuple[str, str]:+ """+ Parses out from the last `last_n_line` of `stderr_txt` the Exception type and message.+ """+ index = -(last_n_lines + 1)+ pattern = r"(\w+(?:Error|Exception)): (.+?)$"+ for line in stderr_txt.split("\n")[:index:-1]:+ if "Error" in line or "Exception" in line:+ match = re.search(pattern, line)+ if match:+ return match.group(1), match.group(2)+ return "", ""++def run_async_task(coro: Coroutine[Any, Any, Any]) -> Any:"""Safely runs an asynchronous coroutine in a synchronous context.diff --git a/tests/test_tool_schema_parsing_files/list_of_pydantic_example.json b/tests/test_tool_schema_parsing_files/list_of_pydantic_example.jsonindex d2aeb6bd4..e272884db 100644--- a/tests/test_tool_schema_parsing_files/list_of_pydantic_example.json+++ b/tests/test_tool_schema_parsing_files/list_of_pydantic_example.json@@ -1,6 +1,6 @@{"name": "create_task_plan",- "description": "Creates a task plan for the current task.",+ "description": "It takes in a list of steps, and updates the task with the new steps provided.\nIf there are any current steps, they will be overwritten.\nEach step in the list should have the following format:\n{\n \"name\": <string> -- Name of the step.\n \"key\": <string> -- Unique identifier for the step.\n \"description\": <string> -- An exhaustic description of what this step is trying to achieve and accomplish.\n}","parameters": {"type": "object","properties": {diff --git a/tests/test_tool_schema_parsing_files/list_of_pydantic_example_so.json b/tests/test_tool_schema_parsing_files/list_of_pydantic_example_so.jsonindex f4b8a9307..69b92c1c4 100644--- a/tests/test_tool_schema_parsing_files/list_of_pydantic_example_so.json+++ b/tests/test_tool_schema_parsing_files/list_of_pydantic_example_so.json@@ -1,6 +1,6 @@{"name": "create_task_plan",- "description": "Creates a task plan for the current task.",+ "description": "It takes in a list of steps, and updates the task with the new steps provided.\nIf there are any current steps, they will be overwritten.\nEach step in the list should have the following format:\n{\n \"name\": <string> -- Name of the step.\n \"key\": <string> -- Unique identifier for the step.\n \"description\": <string> -- An exhaustic description of what this step is trying to achieve and accomplish.\n}","strict": true,"parameters": {"type": "object",diff --git a/tests/test_tool_schema_parsing_files/nested_pydantic_as_arg_example.json b/tests/test_tool_schema_parsing_files/nested_pydantic_as_arg_example.jsonindex 087182cfd..c3c555509 100644--- a/tests/test_tool_schema_parsing_files/nested_pydantic_as_arg_example.json+++ b/tests/test_tool_schema_parsing_files/nested_pydantic_as_arg_example.json@@ -1,6 +1,6 @@{"name": "create_task_plan",- "description": "Creates a task plan for the current task.",+ "description": "It takes in a list of steps, and updates the task with the new steps provided.\nIf there are any current steps, they will be overwritten.\nEach step in the list should have the following format:\n{\n \"name\": <string> -- Name of the step.\n \"key\": <string> -- Unique identifier for the step.\n \"description\": <string> -- An exhaustic description of what this step is trying to achieve and accomplish.\n}","parameters": {"type": "object","properties": {diff --git a/tests/test_tool_schema_parsing_files/nested_pydantic_as_arg_example_so.json b/tests/test_tool_schema_parsing_files/nested_pydantic_as_arg_example_so.jsonindex 0a3113890..e1543c1e8 100644--- a/tests/test_tool_schema_parsing_files/nested_pydantic_as_arg_example_so.json+++ b/tests/test_tool_schema_parsing_files/nested_pydantic_as_arg_example_so.json@@ -1,6 +1,6 @@{"name": "create_task_plan",- "description": "Creates a task plan for the current task.",+ "description": "It takes in a list of steps, and updates the task with the new steps provided.\nIf there are any current steps, they will be overwritten.\nEach step in the list should have the following format:\n{\n \"name\": <string> -- Name of the step.\n \"key\": <string> -- Unique identifier for the step.\n \"description\": <string> -- An exhaustic description of what this step is trying to achieve and accomplish.\n}","strict": true,"parameters": {"type": "object",diff --git a/tests/test_tool_schema_parsing_files/simple_d20.json b/tests/test_tool_schema_parsing_files/simple_d20.jsonindex 7d660bafe..2764eead4 100644--- a/tests/test_tool_schema_parsing_files/simple_d20.json+++ b/tests/test_tool_schema_parsing_files/simple_d20.json@@ -1,6 +1,6 @@{"name": "roll_d20",- "description": "Simulate the roll of a 20-sided die (d20).",+ "description": "This function generates a random integer between 1 and 20, inclusive,\nwhich represents the outcome of a single roll of a d20.","parameters": {"type": "object","properties": {},diff --git a/tests/test_tool_schema_parsing_files/simple_d20_so.json b/tests/test_tool_schema_parsing_files/simple_d20_so.jsonindex 2f3ddeab7..68b74cec1 100644--- a/tests/test_tool_schema_parsing_files/simple_d20_so.json+++ b/tests/test_tool_schema_parsing_files/simple_d20_so.json@@ -1,6 +1,6 @@{"name": "roll_d20",- "description": "Simulate the roll of a 20-sided die (d20).",+ "description": "This function generates a random integer between 1 and 20, inclusive,\nwhich represents the outcome of a single roll of a d20.","strict": true,"parameters": {"type": "object",