letta-nightly 0.8.0.dev20250606195656__py3-none-any.whl → 0.8.2.dev20250606215616__py3-none-any.whl

letta/services/tool_executor/multi_agent_tool_executor.py

@@ -0,0 +1,123 @@
+import asyncio
+from typing import Any, Dict, List, Optional
+
+from letta.schemas.agent import AgentState
+from letta.schemas.enums import MessageRole
+from letta.schemas.letta_message import AssistantMessage
+from letta.schemas.letta_message_content import TextContent
+from letta.schemas.message import MessageCreate
+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.tool_executor.tool_executor import logger
+from letta.services.tool_executor.tool_executor_base import ToolExecutor
+
+
+class LettaMultiAgentToolExecutor(ToolExecutor):
+    """Executor for LETTA multi-agent core tools."""
+
+    async def execute(
+        self,
+        function_name: str,
+        function_args: dict,
+        tool: Tool,
+        actor: User,
+        agent_state: Optional[AgentState] = None,
+        sandbox_config: Optional[SandboxConfig] = None,
+        sandbox_env_vars: Optional[Dict[str, Any]] = None,
+    ) -> ToolExecutionResult:
+        assert agent_state is not None, "Agent state is required for multi-agent tools"
+        function_map = {
+            "send_message_to_agent_and_wait_for_reply": self.send_message_to_agent_and_wait_for_reply,
+            "send_message_to_agent_async": self.send_message_to_agent_async,
+            "send_message_to_agents_matching_tags": self.send_message_to_agents_matching_tags_async,
+        }
+
+        if function_name not in function_map:
+            raise ValueError(f"Unknown function: {function_name}")
+
+        # Execute the appropriate function
+        function_args_copy = function_args.copy()  # Make a copy to avoid modifying the original
+        function_response = await function_map[function_name](agent_state, **function_args_copy)
+        return ToolExecutionResult(
+            status="success",
+            func_return=function_response,
+        )
+
+    async def send_message_to_agent_and_wait_for_reply(self, agent_state: AgentState, message: str, other_agent_id: str) -> str:
+        augmented_message = (
+            f"[Incoming message from agent with ID '{agent_state.id}' - to reply to this message, "
+            f"make sure to use the 'send_message' at the end, and the system will notify the sender of your response] "
+            f"{message}"
+        )
+
+        return str(await self._process_agent(agent_id=other_agent_id, message=augmented_message))
+
+    async def send_message_to_agent_async(self, agent_state: AgentState, message: str, other_agent_id: str) -> str:
+        # 1) Build the prefixed system‐message
+        prefixed = (
+            f"[Incoming message from agent with ID '{agent_state.id}' - "
+            f"to reply to this message, make sure to use the "
+            f"'send_message_to_agent_async' tool, or the agent will not receive your message] "
+            f"{message}"
+        )
+
+        task = asyncio.create_task(self._process_agent(agent_id=other_agent_id, message=prefixed))
+
+        task.add_done_callback(lambda t: (logger.error(f"Async send_message task failed: {t.exception()}") if t.exception() else None))
+
+        return "Successfully sent message"
+
+    async def send_message_to_agents_matching_tags_async(
+        self, agent_state: AgentState, message: str, match_all: List[str], match_some: List[str]
+    ) -> str:
+        # Find matching agents
+        matching_agents = await self.agent_manager.list_agents_matching_tags_async(
+            actor=self.actor, match_all=match_all, match_some=match_some
+        )
+        if not matching_agents:
+            return str([])
+
+        augmented_message = (
+            "[Incoming message from external Letta agent - to reply to this message, "
+            "make sure to use the 'send_message' at the end, and the system will notify "
+            "the sender of your response] "
+            f"{message}"
+        )
+
+        tasks = [
+            asyncio.create_task(self._process_agent(agent_id=agent_state.id, message=augmented_message)) for agent_state in matching_agents
+        ]
+        results = await asyncio.gather(*tasks)
+        return str(results)
+
+    async def _process_agent(self, agent_id: str, message: str) -> Dict[str, Any]:
+        from letta.agents.letta_agent import LettaAgent
+
+        try:
+            letta_agent = LettaAgent(
+                agent_id=agent_id,
+                message_manager=self.message_manager,
+                agent_manager=self.agent_manager,
+                block_manager=self.block_manager,
+                passage_manager=self.passage_manager,
+                actor=self.actor,
+            )
+
+            letta_response = await letta_agent.step([MessageCreate(role=MessageRole.system, content=[TextContent(text=message)])])
+            messages = letta_response.messages
+
+            send_message_content = [message.content for message in messages if isinstance(message, AssistantMessage)]
+
+            return {
+                "agent_id": agent_id,
+                "response": send_message_content if send_message_content else ["<no response>"],
+            }
+
+        except Exception as e:
+            return {
+                "agent_id": agent_id,
+                "error": str(e),
+                "type": type(e).__name__,
+            }

letta/services/tool_executor/tool_execution_manager.py

@@ -2,8 +2,12 @@ import traceback
 from typing import Any, Dict, Optional, Type
 
 from letta.constants import FUNCTION_RETURN_VALUE_TRUNCATED
+from letta.helpers.datetime_helpers import AsyncTimer
 from letta.log import get_logger
 from letta.orm.enums import ToolType
+from letta.otel.context import get_ctx_attributes
+from letta.otel.metric_registry import MetricRegistry
+from letta.otel.tracing import trace_method
 from letta.schemas.agent import AgentState
 from letta.schemas.sandbox_config import SandboxConfig
 from letta.schemas.tool import Tool
@@ -13,16 +17,14 @@ from letta.services.agent_manager import AgentManager
 from letta.services.block_manager import BlockManager
 from letta.services.message_manager import MessageManager
 from letta.services.passage_manager import PassageManager
-from letta.services.tool_executor.tool_executor import (
-    ExternalComposioToolExecutor,
-    ExternalMCPToolExecutor,
-    LettaBuiltinToolExecutor,
-    LettaCoreToolExecutor,
-    LettaMultiAgentToolExecutor,
-    SandboxToolExecutor,
-    ToolExecutor,
-)
-from letta.tracing import trace_method
+from letta.services.tool_executor.builtin_tool_executor import LettaBuiltinToolExecutor
+from letta.services.tool_executor.composio_tool_executor import ExternalComposioToolExecutor
+from letta.services.tool_executor.core_tool_executor import LettaCoreToolExecutor
+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.tool_executor_base import ToolExecutor
 from letta.utils import get_friendly_error_msg
 
 
@@ -35,6 +37,7 @@ class ToolExecutorFactory:
         ToolType.LETTA_SLEEPTIME_CORE: LettaCoreToolExecutor,
         ToolType.LETTA_MULTI_AGENT_CORE: LettaMultiAgentToolExecutor,
         ToolType.LETTA_BUILTIN: LettaBuiltinToolExecutor,
+        ToolType.LETTA_FILES_CORE: LettaFileToolExecutor,
         ToolType.EXTERNAL_COMPOSIO: ExternalComposioToolExecutor,
         ToolType.EXTERNAL_MCP: ExternalMCPToolExecutor,
     }
@@ -85,10 +88,13 @@ class ToolExecutionManager:
         self.sandbox_env_vars = sandbox_env_vars
 
     @trace_method
-    async def execute_tool_async(self, function_name: str, function_args: dict, tool: Tool) -> ToolExecutionResult:
+    async def execute_tool_async(
+        self, function_name: str, function_args: dict, tool: Tool, step_id: str | None = None
+    ) -> ToolExecutionResult:
         """
         Execute a tool asynchronously and persist any state changes.
         """
+        status = "error"  # set as default for tracking purposes
         try:
             executor = ToolExecutorFactory.get_executor(
                 tool.tool_type,
@@ -98,9 +104,17 @@ class ToolExecutionManager:
                 passage_manager=self.passage_manager,
                 actor=self.actor,
             )
-            result = await executor.execute(
-                function_name, function_args, tool, self.actor, self.agent_state, self.sandbox_config, self.sandbox_env_vars
-            )
+
+            def _metrics_callback(exec_time_ms: int, exc):
+                return MetricRegistry().tool_execution_time_ms_histogram.record(
+                    exec_time_ms, dict(get_ctx_attributes(), **{"tool.name": tool.name})
+                )
+
+            async with AsyncTimer(callback_func=_metrics_callback):
+                result = await executor.execute(
+                    function_name, function_args, tool, self.actor, self.agent_state, self.sandbox_config, self.sandbox_env_vars
+                )
+            status = result.status
 
             # trim result
             return_str = str(result.func_return)
@@ -110,6 +124,7 @@ class ToolExecutionManager:
             return result
 
         except Exception as e:
+            status = "error"
             self.logger.error(f"Error executing tool {function_name}: {str(e)}")
             error_message = get_friendly_error_msg(
                 function_name=function_name,
@@ -121,3 +136,8 @@ class ToolExecutionManager:
                 func_return=error_message,
                 stderr=[traceback.format_exc()],
             )
+        finally:
+            metric_attrs = {"tool.name": tool.name, "tool.execution_success": status == "success"}
+            if status == "error" and step_id:
+                metric_attrs["step.id"] = step_id
+            MetricRegistry().tool_execution_counter.add(1, dict(get_ctx_attributes(), **metric_attrs))

letta/services/tool_executor/tool_execution_sandbox.py

@@ -11,6 +11,7 @@ from typing import Any, Dict, Optional
 
 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.tool import Tool
@@ -27,7 +28,6 @@ from letta.services.organization_manager import OrganizationManager
 from letta.services.sandbox_config_manager import SandboxConfigManager
 from letta.services.tool_manager import ToolManager
 from letta.settings import tool_settings
-from letta.tracing import log_event, trace_method
 from letta.utils import get_friendly_error_msg
 
 logger = get_logger(__name__)