Skip to content

armgit / letta

Public Imported from GitHub
0

Platform for stateful agents: AI with advanced memory that can learn and self-improve over time.

chore: Add instrumentation to async E2B (#2273)

Matthew Zhou71bc0eabac96
diff --git a/letta/agents/letta_agent.py b/letta/agents/letta_agent.py
index 88af2eca8..8cb35fa78 100644
--- a/letta/agents/letta_agent.py
+++ b/letta/agents/letta_agent.py
@@ -650,6 +650,7 @@ class LettaAgent(BaseAgent):
results = await asyncio.gather(*tasks)
return results
+ @trace_method
async def _load_last_function_response_async(self):
"""Load the last function response from message history"""
in_context_messages = await self.agent_manager.get_in_context_messages_async(agent_id=self.agent_id, actor=self.actor)
diff --git a/letta/services/tool_executor/tool_executor.py b/letta/services/tool_executor/tool_executor.py
index 0cf1eb75c..92b2aab76 100644
--- a/letta/services/tool_executor/tool_executor.py
+++ b/letta/services/tool_executor/tool_executor.py
@@ -28,6 +28,7 @@ from letta.services.passage_manager import PassageManager
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.tracing import trace_method
from letta.utils import get_friendly_error_msg
@@ -508,6 +509,7 @@ class LettaMultiAgentToolExecutor(ToolExecutor):
class ExternalComposioToolExecutor(ToolExecutor):
"""Executor for external Composio tools."""
+ @trace_method
async def execute(
self,
function_name: str,
@@ -599,6 +601,7 @@ class ExternalMCPToolExecutor(ToolExecutor):
class SandboxToolExecutor(ToolExecutor):
"""Executor for sandboxed tools."""
+ @trace_method
async def execute(
self,
function_name: str,
@@ -683,6 +686,7 @@ class SandboxToolExecutor(ToolExecutor):
class LettaBuiltinToolExecutor(ToolExecutor):
"""Executor for built in Letta tools."""
+ @trace_method
async def execute(
self,
function_name: str,
diff --git a/letta/services/tool_sandbox/e2b_sandbox.py b/letta/services/tool_sandbox/e2b_sandbox.py
index ee1703d5f..6f8130851 100644
--- a/letta/services/tool_sandbox/e2b_sandbox.py
+++ b/letta/services/tool_sandbox/e2b_sandbox.py
@@ -6,6 +6,7 @@ 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.tracing import log_event, trace_method
from letta.utils import get_friendly_error_msg
logger = get_logger(__name__)
@@ -27,6 +28,7 @@ class AsyncToolSandboxE2B(AsyncToolSandboxBase):
super().__init__(tool_name, args, user, tool_object, sandbox_config=sandbox_config, sandbox_env_vars=sandbox_env_vars)
self.force_recreate = force_recreate
+ @trace_method
async def run(
self,
agent_state: Optional[AgentState] = None,
@@ -44,6 +46,7 @@ class AsyncToolSandboxE2B(AsyncToolSandboxBase):
return result
+ @trace_method
async def run_e2b_sandbox(
self, agent_state: Optional[AgentState] = None, additional_env_vars: Optional[Dict] = None
) -> ToolExecutionResult:
@@ -81,10 +84,21 @@ class AsyncToolSandboxE2B(AsyncToolSandboxBase):
env_vars.update(additional_env_vars)
code = self.generate_execution_script(agent_state=agent_state)
+ log_event(
+ "e2b_execution_started",
+ {"tool": self.tool_name, "sandbox_id": e2b_sandbox.sandbox_id, "code": code[:200], "env_vars": env_vars},
+ )
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)
+ log_event(
+ "e2b_execution_succeeded",
+ {
+ "tool": self.tool_name,
+ "sandbox_id": e2b_sandbox.sandbox_id,
+ "func_return": func_return,
+ },
+ )
elif execution.error:
logger.error(f"Executing tool {self.tool_name} raised a {execution.error.name} with message: \n{execution.error.value}")
logger.error(f"Traceback from e2b sandbox: \n{execution.error.traceback}")
@@ -92,7 +106,25 @@ class AsyncToolSandboxE2B(AsyncToolSandboxBase):
function_name=self.tool_name, exception_name=execution.error.name, exception_message=execution.error.value
)
execution.logs.stderr.append(execution.error.traceback)
+ log_event(
+ "e2b_execution_failed",
+ {
+ "tool": self.tool_name,
+ "sandbox_id": e2b_sandbox.sandbox_id,
+ "error_type": execution.error.name,
+ "error_message": execution.error.value,
+ "func_return": func_return,
+ },
+ )
else:
+ log_event(
+ "e2b_execution_empty",
+ {
+ "tool": self.tool_name,
+ "sandbox_id": e2b_sandbox.sandbox_id,
+ "status": "no_results_no_error",
+ },
+ )
raise ValueError(f"Tool {self.tool_name} returned execution with None")
return ToolExecutionResult(
@@ -110,24 +142,54 @@ class AsyncToolSandboxE2B(AsyncToolSandboxBase):
exception_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
state_hash = sandbox_config.fingerprint()
e2b_config = sandbox_config.get_e2b_config()
+ log_event(
+ "e2b_sandbox_create_started",
+ {
+ "sandbox_fingerprint": state_hash,
+ "has_template": bool(e2b_config.template),
+ },
+ )
+
if e2b_config.template:
sbx = await AsyncSandbox.create(sandbox_config.get_e2b_config().template, metadata={self.METADATA_CONFIG_STATE_KEY: state_hash})
else:
- # no template
sbx = await AsyncSandbox.create(
metadata={self.METADATA_CONFIG_STATE_KEY: state_hash}, **e2b_config.model_dump(exclude={"pip_requirements"})
)
- # install pip requirements
+ log_event(
+ "e2b_sandbox_create_finished",
+ {
+ "sandbox_id": sbx.sandbox_id,
+ "sandbox_fingerprint": state_hash,
+ },
+ )
+
if e2b_config.pip_requirements:
for package in e2b_config.pip_requirements:
+ log_event(
+ "e2b_pip_install_started",
+ {
+ "sandbox_id": sbx.sandbox_id,
+ "package": package,
+ },
+ )
await sbx.commands.run(f"pip install {package}")
+ log_event(
+ "e2b_pip_install_finished",
+ {
+ "sandbox_id": sbx.sandbox_id,
+ "package": package,
+ },
+ )
+
return sbx
async def list_running_e2b_sandboxes(self):