letta-nightly 0.7.20.dev20250520104253__py3-none-any.whl → 0.7.21.dev20250521233415__py3-none-any.whl

letta/agents/letta_agent.py

@@ -8,8 +8,9 @@ from openai.types import CompletionUsage
 from openai.types.chat import ChatCompletion, ChatCompletionChunk
 
 from letta.agents.base_agent import BaseAgent
-from letta.agents.helpers import _create_letta_response, _prepare_in_context_messages_async
+from letta.agents.helpers import _create_letta_response, _prepare_in_context_messages_async, generate_step_id
 from letta.helpers import ToolRulesSolver
+from letta.helpers.datetime_helpers import get_utc_timestamp_ns
 from letta.helpers.tool_execution_helper import enable_strict_mode
 from letta.interfaces.anthropic_streaming_interface import AnthropicStreamingInterface
 from letta.interfaces.openai_streaming_interface import OpenAIStreamingInterface
@@ -24,7 +25,8 @@ from letta.schemas.letta_message import AssistantMessage
 from letta.schemas.letta_message_content import OmittedReasoningContent, ReasoningContent, RedactedReasoningContent, TextContent
 from letta.schemas.letta_response import LettaResponse
 from letta.schemas.message import Message, MessageCreate
-from letta.schemas.openai.chat_completion_response import ToolCall
+from letta.schemas.openai.chat_completion_response import ToolCall, UsageStatistics
+from letta.schemas.provider_trace import ProviderTraceCreate
 from letta.schemas.usage import LettaUsageStatistics
 from letta.schemas.user import User
 from letta.server.rest_api.utils import create_letta_messages_from_llm_response
@@ -32,10 +34,11 @@ 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.step_manager import NoopStepManager, StepManager
+from letta.services.telemetry_manager import NoopTelemetryManager, TelemetryManager
 from letta.services.tool_executor.tool_execution_manager import ToolExecutionManager
-from letta.settings import settings
 from letta.system import package_function_response
-from letta.tracing import log_event, trace_method
+from letta.tracing import log_event, trace_method, tracer
 
 logger = get_logger(__name__)
 
@@ -50,6 +53,8 @@ class LettaAgent(BaseAgent):
         block_manager: BlockManager,
         passage_manager: PassageManager,
         actor: User,
+        step_manager: StepManager = NoopStepManager(),
+        telemetry_manager: TelemetryManager = NoopTelemetryManager(),
     ):
         super().__init__(agent_id=agent_id, openai_client=None, message_manager=message_manager, agent_manager=agent_manager, actor=actor)
 
@@ -57,6 +62,8 @@ class LettaAgent(BaseAgent):
         # Summarizer settings
         self.block_manager = block_manager
         self.passage_manager = passage_manager
+        self.step_manager = step_manager
+        self.telemetry_manager = telemetry_manager
         self.response_messages: List[Message] = []
 
         self.last_function_response = None
@@ -67,17 +74,19 @@ class LettaAgent(BaseAgent):
 
     @trace_method
     async def step(self, input_messages: List[MessageCreate], max_steps: int = 10, use_assistant_message: bool = True) -> LettaResponse:
-        agent_state = await self.agent_manager.get_agent_by_id_async(self.agent_id, actor=self.actor)
-        current_in_context_messages, new_in_context_messages, usage = await self._step(
-            agent_state=agent_state, input_messages=input_messages, max_steps=max_steps
+        agent_state = await self.agent_manager.get_agent_by_id_async(
+            agent_id=self.agent_id, include_relationships=["tools", "memory"], actor=self.actor
         )
+        _, new_in_context_messages, usage = await self._step(agent_state=agent_state, input_messages=input_messages, max_steps=max_steps)
         return _create_letta_response(
             new_in_context_messages=new_in_context_messages, use_assistant_message=use_assistant_message, usage=usage
         )
 
-    async def _step(
-        self, agent_state: AgentState, input_messages: List[MessageCreate], max_steps: int = 10
-    ) -> Tuple[List[Message], List[Message], CompletionUsage]:
+    @trace_method
+    async def step_stream_no_tokens(self, input_messages: List[MessageCreate], max_steps: int = 10, use_assistant_message: bool = True):
+        agent_state = await self.agent_manager.get_agent_by_id_async(
+            agent_id=self.agent_id, include_relationships=["tools", "memory"], actor=self.actor
+        )
         current_in_context_messages, new_in_context_messages = await _prepare_in_context_messages_async(
             input_messages, agent_state, self.message_manager, self.actor
         )
@@ -89,23 +98,81 @@ class LettaAgent(BaseAgent):
         )
         usage = LettaUsageStatistics()
         for _ in range(max_steps):
-            response = await self._get_ai_reply(
+            step_id = generate_step_id()
+
+            in_context_messages = await self._rebuild_memory_async(
+                current_in_context_messages + new_in_context_messages,
+                agent_state,
+                num_messages=self.num_messages,
+                num_archival_memories=self.num_archival_memories,
+            )
+            log_event("agent.stream_no_tokens.messages.refreshed")  # [1^]
+
+            request_data = await self._create_llm_request_data_async(
                 llm_client=llm_client,
-                in_context_messages=current_in_context_messages + new_in_context_messages,
+                in_context_messages=in_context_messages,
                 agent_state=agent_state,
                 tool_rules_solver=tool_rules_solver,
-                stream=False,
-                # TODO: also pass in reasoning content
+                # TODO: pass in reasoning content
             )
+            log_event("agent.stream_no_tokens.llm_request.created")  # [2^]
 
+            try:
+                response_data = await llm_client.request_async(request_data, agent_state.llm_config)
+            except Exception as e:
+                raise llm_client.handle_llm_error(e)
+            log_event("agent.stream_no_tokens.llm_response.received")  # [3^]
+
+            response = llm_client.convert_response_to_chat_completion(response_data, in_context_messages, agent_state.llm_config)
+
+            # update usage
+            # TODO: add run_id
+            usage.step_count += 1
+            usage.completion_tokens += response.usage.completion_tokens
+            usage.prompt_tokens += response.usage.prompt_tokens
+            usage.total_tokens += response.usage.total_tokens
+
+            if not response.choices[0].message.tool_calls:
+                # TODO: make into a real error
+                raise ValueError("No tool calls found in response, model must make a tool call")
             tool_call = response.choices[0].message.tool_calls[0]
-            reasoning = [TextContent(text=response.choices[0].message.content)]  # reasoning placed into content for legacy reasons
+            if response.choices[0].message.reasoning_content:
+                reasoning = [
+                    ReasoningContent(
+                        reasoning=response.choices[0].message.reasoning_content,
+                        is_native=True,
+                        signature=response.choices[0].message.reasoning_content_signature,
+                    )
+                ]
+            else:
+                reasoning = [TextContent(text=response.choices[0].message.content)]  # reasoning placed into content for legacy reasons
 
             persisted_messages, should_continue = await self._handle_ai_response(
-                tool_call, agent_state, tool_rules_solver, reasoning_content=reasoning
+                tool_call, agent_state, tool_rules_solver, response.usage, reasoning_content=reasoning
             )
             self.response_messages.extend(persisted_messages)
             new_in_context_messages.extend(persisted_messages)
+            log_event("agent.stream_no_tokens.llm_response.processed")  # [4^]
+
+            # Log LLM Trace
+            await self.telemetry_manager.create_provider_trace_async(
+                actor=self.actor,
+                provider_trace_create=ProviderTraceCreate(
+                    request_json=request_data,
+                    response_json=response_data,
+                    step_id=step_id,
+                    organization_id=self.actor.organization_id,
+                ),
+            )
+
+            # stream step
+            # TODO: improve TTFT
+            filter_user_messages = [m for m in persisted_messages if m.role != "user"]
+            letta_messages = Message.to_letta_messages_from_list(
+                filter_user_messages, use_assistant_message=use_assistant_message, reverse=False
+            )
+            for message in letta_messages:
+                yield f"data: {message.model_dump_json()}\n\n"
 
             # update usage
             # TODO: add run_id
@@ -122,17 +189,125 @@ class LettaAgent(BaseAgent):
             message_ids = [m.id for m in (current_in_context_messages + new_in_context_messages)]
             self.agent_manager.set_in_context_messages(agent_id=self.agent_id, message_ids=message_ids, actor=self.actor)
 
+        # Return back usage
+        yield f"data: {usage.model_dump_json()}\n\n"
+
+    async def _step(
+        self, agent_state: AgentState, input_messages: List[MessageCreate], max_steps: int = 10
+    ) -> Tuple[List[Message], List[Message], CompletionUsage]:
+        """
+        Carries out an invocation of the agent loop. In each step, the agent
+            1. Rebuilds its memory
+            2. Generates a request for the LLM
+            3. Fetches a response from the LLM
+            4. Processes the response
+        """
+        current_in_context_messages, new_in_context_messages = await _prepare_in_context_messages_async(
+            input_messages, agent_state, self.message_manager, self.actor
+        )
+        tool_rules_solver = ToolRulesSolver(agent_state.tool_rules)
+        llm_client = LLMClient.create(
+            provider_type=agent_state.llm_config.model_endpoint_type,
+            put_inner_thoughts_first=True,
+            actor=self.actor,
+        )
+        usage = LettaUsageStatistics()
+        for _ in range(max_steps):
+            step_id = generate_step_id()
+
+            in_context_messages = await self._rebuild_memory_async(
+                current_in_context_messages + new_in_context_messages,
+                agent_state,
+                num_messages=self.num_messages,
+                num_archival_memories=self.num_archival_memories,
+            )
+            log_event("agent.step.messages.refreshed")  # [1^]
+
+            request_data = await self._create_llm_request_data_async(
+                llm_client=llm_client,
+                in_context_messages=in_context_messages,
+                agent_state=agent_state,
+                tool_rules_solver=tool_rules_solver,
+                # TODO: pass in reasoning content
+            )
+            log_event("agent.step.llm_request.created")  # [2^]
+
+            try:
+                response_data = await llm_client.request_async(request_data, agent_state.llm_config)
+            except Exception as e:
+                raise llm_client.handle_llm_error(e)
+            log_event("agent.step.llm_response.received")  # [3^]
+
+            response = llm_client.convert_response_to_chat_completion(response_data, in_context_messages, agent_state.llm_config)
+
+            # TODO: add run_id
+            usage.step_count += 1
+            usage.completion_tokens += response.usage.completion_tokens
+            usage.prompt_tokens += response.usage.prompt_tokens
+            usage.total_tokens += response.usage.total_tokens
+
+            if not response.choices[0].message.tool_calls:
+                # TODO: make into a real error
+                raise ValueError("No tool calls found in response, model must make a tool call")
+            tool_call = response.choices[0].message.tool_calls[0]
+            if response.choices[0].message.reasoning_content:
+                reasoning = [
+                    ReasoningContent(
+                        reasoning=response.choices[0].message.reasoning_content,
+                        is_native=True,
+                        signature=response.choices[0].message.reasoning_content_signature,
+                    )
+                ]
+            else:
+                reasoning = [TextContent(text=response.choices[0].message.content)]  # reasoning placed into content for legacy reasons
+
+            persisted_messages, should_continue = await self._handle_ai_response(
+                tool_call, agent_state, tool_rules_solver, response.usage, reasoning_content=reasoning, step_id=step_id
+            )
+            self.response_messages.extend(persisted_messages)
+            new_in_context_messages.extend(persisted_messages)
+            log_event("agent.step.llm_response.processed")  # [4^]
+
+            # Log LLM Trace
+            await self.telemetry_manager.create_provider_trace_async(
+                actor=self.actor,
+                provider_trace_create=ProviderTraceCreate(
+                    request_json=request_data,
+                    response_json=response_data,
+                    step_id=step_id,
+                    organization_id=self.actor.organization_id,
+                ),
+            )
+
+            if not should_continue:
+                break
+
+        # Extend the in context message ids
+        if not agent_state.message_buffer_autoclear:
+            message_ids = [m.id for m in (current_in_context_messages + new_in_context_messages)]
+            self.agent_manager.set_in_context_messages(agent_id=self.agent_id, message_ids=message_ids, actor=self.actor)
+
         return current_in_context_messages, new_in_context_messages, usage
 
     @trace_method
     async def step_stream(
-        self, input_messages: List[MessageCreate], max_steps: int = 10, use_assistant_message: bool = True, stream_tokens: bool = False
+        self,
+        input_messages: List[MessageCreate],
+        max_steps: int = 10,
+        use_assistant_message: bool = True,
+        request_start_timestamp_ns: Optional[int] = None,
     ) -> AsyncGenerator[str, None]:
         """
-        Main streaming loop that yields partial tokens.
-        Whenever we detect a tool call, we yield from _handle_ai_response as well.
+        Carries out an invocation of the agent loop in a streaming fashion that yields partial tokens.
+        Whenever we detect a tool call, we yield from _handle_ai_response as well. At each step, the agent
+            1. Rebuilds its memory
+            2. Generates a request for the LLM
+            3. Fetches a response from the LLM
+            4. Processes the response
         """
-        agent_state = await self.agent_manager.get_agent_by_id_async(self.agent_id, actor=self.actor)
+        agent_state = await self.agent_manager.get_agent_by_id_async(
+            agent_id=self.agent_id, include_relationships=["tools", "memory"], actor=self.actor
+        )
         current_in_context_messages, new_in_context_messages = await _prepare_in_context_messages_async(
             input_messages, agent_state, self.message_manager, self.actor
         )
@@ -145,13 +320,29 @@ class LettaAgent(BaseAgent):
         usage = LettaUsageStatistics()
 
         for _ in range(max_steps):
-            stream = await self._get_ai_reply(
+            step_id = generate_step_id()
+            in_context_messages = await self._rebuild_memory_async(
+                current_in_context_messages + new_in_context_messages,
+                agent_state,
+                num_messages=self.num_messages,
+                num_archival_memories=self.num_archival_memories,
+            )
+            log_event("agent.step.messages.refreshed")  # [1^]
+
+            request_data = await self._create_llm_request_data_async(
                 llm_client=llm_client,
-                in_context_messages=current_in_context_messages + new_in_context_messages,
+                in_context_messages=in_context_messages,
                 agent_state=agent_state,
                 tool_rules_solver=tool_rules_solver,
-                stream=True,
             )
+            log_event("agent.stream.llm_request.created")  # [2^]
+
+            try:
+                stream = await llm_client.stream_async(request_data, agent_state.llm_config)
+            except Exception as e:
+                raise llm_client.handle_llm_error(e)
+            log_event("agent.stream.llm_response.received")  # [3^]
+
             # TODO: THIS IS INCREDIBLY UGLY
             # TODO: THERE ARE MULTIPLE COPIES OF THE LLM_CONFIG EVERYWHERE THAT ARE GETTING MANIPULATED
             if agent_state.llm_config.model_endpoint_type == "anthropic":
@@ -164,7 +355,23 @@ class LettaAgent(BaseAgent):
                     use_assistant_message=use_assistant_message,
                     put_inner_thoughts_in_kwarg=agent_state.llm_config.put_inner_thoughts_in_kwargs,
                 )
+            else:
+                raise ValueError(f"Streaming not supported for {agent_state.llm_config}")
+
+            first_chunk, ttft_span = True, None
+            if request_start_timestamp_ns is not None:
+                ttft_span = tracer.start_span("time_to_first_token", start_time=request_start_timestamp_ns)
+                ttft_span.set_attributes({f"llm_config.{k}": v for k, v in agent_state.llm_config.model_dump().items() if v is not None})
+
             async for chunk in interface.process(stream):
+                # Measure time to first token
+                if first_chunk and ttft_span is not None:
+                    now = get_utc_timestamp_ns()
+                    ttft_ns = now - request_start_timestamp_ns
+                    ttft_span.add_event(name="time_to_first_token_ms", attributes={"ttft_ms": ttft_ns // 1_000_000})
+                    ttft_span.end()
+                    first_chunk = False
+
                 yield f"data: {chunk.model_dump_json()}\n\n"
 
             # update usage
@@ -180,13 +387,46 @@ class LettaAgent(BaseAgent):
                 tool_call,
                 agent_state,
                 tool_rules_solver,
+                UsageStatistics(
+                    completion_tokens=interface.output_tokens,
+                    prompt_tokens=interface.input_tokens,
+                    total_tokens=interface.input_tokens + interface.output_tokens,
+                ),
                 reasoning_content=reasoning_content,
                 pre_computed_assistant_message_id=interface.letta_assistant_message_id,
                 pre_computed_tool_message_id=interface.letta_tool_message_id,
+                step_id=step_id,
             )
             self.response_messages.extend(persisted_messages)
             new_in_context_messages.extend(persisted_messages)
 
+            # TODO (cliandy): the stream POST request span has ended at this point, we should tie this to the stream
+            # log_event("agent.stream.llm_response.processed") # [4^]
+
+            # Log LLM Trace
+            # TODO (cliandy): we are piecing together the streamed response here. Content here does not match the actual response schema.
+            await self.telemetry_manager.create_provider_trace_async(
+                actor=self.actor,
+                provider_trace_create=ProviderTraceCreate(
+                    request_json=request_data,
+                    response_json={
+                        "content": {
+                            "tool_call": tool_call.model_dump_json(),
+                            "reasoning": [content.model_dump_json() for content in reasoning_content],
+                        },
+                        "id": interface.message_id,
+                        "model": interface.model,
+                        "role": "assistant",
+                        # "stop_reason": "",
+                        # "stop_sequence": None,
+                        "type": "message",
+                        "usage": {"input_tokens": interface.input_tokens, "output_tokens": interface.output_tokens},
+                    },
+                    step_id=step_id,
+                    organization_id=self.actor.organization_id,
+                ),
+            )
+
             if not use_assistant_message or should_continue:
                 tool_return = [msg for msg in persisted_messages if msg.role == "tool"][-1].to_letta_messages()[0]
                 yield f"data: {tool_return.model_dump_json()}\n\n"
@@ -209,28 +449,20 @@ class LettaAgent(BaseAgent):
         yield f"data: {MessageStreamStatus.done.model_dump_json()}\n\n"
 
     @trace_method
-    # When raising an error this doesn't show up
-    async def _get_ai_reply(
+    async def _create_llm_request_data_async(
         self,
         llm_client: LLMClientBase,
         in_context_messages: List[Message],
         agent_state: AgentState,
         tool_rules_solver: ToolRulesSolver,
-        stream: bool,
     ) -> ChatCompletion | AsyncStream[ChatCompletionChunk]:
-        if settings.experimental_enable_async_db_engine:
-            self.num_messages = self.num_messages or (await self.message_manager.size_async(actor=self.actor, agent_id=agent_state.id))
-            self.num_archival_memories = self.num_archival_memories or (
-                await self.passage_manager.size_async(actor=self.actor, agent_id=agent_state.id)
-            )
-            in_context_messages = await self._rebuild_memory_async(
-                in_context_messages, agent_state, num_messages=self.num_messages, num_archival_memories=self.num_archival_memories
-            )
-        else:
-            if settings.experimental_skip_rebuild_memory and agent_state.llm_config.model_endpoint_type == "google_vertex":
-                logger.info("Skipping memory rebuild")
-            else:
-                in_context_messages = self._rebuild_memory(in_context_messages, agent_state)
+        self.num_messages = self.num_messages or (await self.message_manager.size_async(actor=self.actor, agent_id=agent_state.id))
+        self.num_archival_memories = self.num_archival_memories or (
+            await self.passage_manager.size_async(actor=self.actor, agent_id=agent_state.id)
+        )
+        in_context_messages = await self._rebuild_memory_async(
+            in_context_messages, agent_state, num_messages=self.num_messages, num_archival_memories=self.num_archival_memories
+        )
 
         tools = [
             t
@@ -243,8 +475,8 @@ class LettaAgent(BaseAgent):
                 ToolType.LETTA_MULTI_AGENT_CORE,
                 ToolType.LETTA_SLEEPTIME_CORE,
                 ToolType.LETTA_VOICE_SLEEPTIME_CORE,
+                ToolType.LETTA_BUILTIN,
             }
-            or (t.tool_type == ToolType.LETTA_MULTI_AGENT_CORE and t.name == "send_message_to_agents_matching_tags")
             or (t.tool_type == ToolType.EXTERNAL_COMPOSIO)
         ]
 
@@ -264,15 +496,7 @@ class LettaAgent(BaseAgent):
 
         allowed_tools = [enable_strict_mode(t.json_schema) for t in tools if t.name in set(valid_tool_names)]
 
-        response = await llm_client.send_llm_request_async(
-            messages=in_context_messages,
-            llm_config=agent_state.llm_config,
-            tools=allowed_tools,
-            force_tool_call=force_tool_call,
-            stream=stream,
-        )
-
-        return response
+        return llm_client.build_request_data(in_context_messages, agent_state.llm_config, allowed_tools, force_tool_call)
 
     @trace_method
     async def _handle_ai_response(
@@ -280,9 +504,11 @@ class LettaAgent(BaseAgent):
         tool_call: ToolCall,
         agent_state: AgentState,
         tool_rules_solver: ToolRulesSolver,
+        usage: UsageStatistics,
         reasoning_content: Optional[List[Union[TextContent, ReasoningContent, RedactedReasoningContent, OmittedReasoningContent]]] = None,
         pre_computed_assistant_message_id: Optional[str] = None,
         pre_computed_tool_message_id: Optional[str] = None,
+        step_id: str | None = None,
     ) -> Tuple[List[Message], bool]:
         """
         Now that streaming is done, handle the final AI response.
@@ -294,8 +520,11 @@ class LettaAgent(BaseAgent):
 
         try:
             tool_args = json.loads(tool_call_args_str)
+            assert isinstance(tool_args, dict), "tool_args must be a dict"
         except json.JSONDecodeError:
             tool_args = {}
+        except AssertionError:
+            tool_args = json.loads(tool_args)
 
         # Get request heartbeats and coerce to bool
         request_heartbeat = tool_args.pop("request_heartbeat", False)
@@ -329,7 +558,25 @@ class LettaAgent(BaseAgent):
         elif tool_rules_solver.is_continue_tool(tool_name=tool_call_name):
             continue_stepping = True
 
-        # 5. Persist to DB
+        # 5a. Persist Steps to DB
+        # Following agent loop to persist this before messages
+        # TODO (cliandy): determine what should match old loop w/provider_id, job_id
+        # TODO (cliandy): UsageStatistics and LettaUsageStatistics are used in many places, but are not the same.
+        logged_step = await self.step_manager.log_step_async(
+            actor=self.actor,
+            agent_id=agent_state.id,
+            provider_name=agent_state.llm_config.model_endpoint_type,
+            provider_category=agent_state.llm_config.provider_category or "base",
+            model=agent_state.llm_config.model,
+            model_endpoint=agent_state.llm_config.model_endpoint,
+            context_window_limit=agent_state.llm_config.context_window,
+            usage=usage,
+            provider_id=None,
+            job_id=None,
+            step_id=step_id,
+        )
+
+        # 5b. Persist Messages to DB
         tool_call_messages = create_letta_messages_from_llm_response(
             agent_id=agent_state.id,
             model=agent_state.llm_config.model,
@@ -343,6 +590,7 @@ class LettaAgent(BaseAgent):
             reasoning_content=reasoning_content,
             pre_computed_assistant_message_id=pre_computed_assistant_message_id,
             pre_computed_tool_message_id=pre_computed_tool_message_id,
+            step_id=logged_step.id if logged_step else None,  # TODO (cliandy): eventually move over other agent loops
         )
         persisted_messages = await self.message_manager.create_many_messages_async(tool_call_messages, actor=self.actor)
         self.last_function_response = function_response
@@ -361,20 +609,21 @@ class LettaAgent(BaseAgent):
 
         # TODO: This temp. Move this logic and code to executors
         try:
-            if target_tool.name == "send_message_to_agents_matching_tags" and target_tool.tool_type == ToolType.LETTA_MULTI_AGENT_CORE:
-                log_event(name="start_send_message_to_agents_matching_tags", attributes=tool_args)
-                results = await self._send_message_to_agents_matching_tags(**tool_args)
-                log_event(name="finish_send_message_to_agents_matching_tags", attributes=tool_args)
-                return json.dumps(results), True
-            else:
-                tool_execution_manager = ToolExecutionManager(agent_state=agent_state, actor=self.actor)
-                # TODO: Integrate sandbox result
-                log_event(name=f"start_{tool_name}_execution", attributes=tool_args)
-                tool_execution_result = await tool_execution_manager.execute_tool_async(
-                    function_name=tool_name, function_args=tool_args, tool=target_tool
-                )
-                log_event(name=f"finish_{tool_name}_execution", attributes=tool_args)
-                return tool_execution_result.func_return, True
+            tool_execution_manager = ToolExecutionManager(
+                agent_state=agent_state,
+                message_manager=self.message_manager,
+                agent_manager=self.agent_manager,
+                block_manager=self.block_manager,
+                passage_manager=self.passage_manager,
+                actor=self.actor,
+            )
+            # TODO: Integrate sandbox result
+            log_event(name=f"start_{tool_name}_execution", attributes=tool_args)
+            tool_execution_result = await tool_execution_manager.execute_tool_async(
+                function_name=tool_name, function_args=tool_args, tool=target_tool
+            )
+            log_event(name=f"finish_{tool_name}_execution", attributes=tool_args)
+            return tool_execution_result.func_return, True
         except Exception as e:
             return f"Failed to call tool. Error: {e}", False
 
@@ -430,6 +679,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)