letta-nightly 0.8.0.dev20250606195656__py3-none-any.whl → 0.8.3.dev20250607000559__py3-none-any.whl

letta/__init__.py

@@ -1,6 +1,6 @@
 import os
 
-__version__ = "0.8.0"
+__version__ = "0.8.3"
 
 if os.environ.get("LETTA_VERSION"):
     __version__ = os.environ["LETTA_VERSION"]

letta/agent.py

@@ -41,6 +41,7 @@ from letta.log import get_logger
 from letta.memory import summarize_messages
 from letta.orm import User
 from letta.orm.enums import ToolType
+from letta.otel.tracing import log_event, trace_method
 from letta.schemas.agent import AgentState, AgentStepResponse, UpdateAgent, get_prompt_template_for_agent_type
 from letta.schemas.block import BlockUpdate
 from letta.schemas.embedding_config import EmbeddingConfig
@@ -69,10 +70,9 @@ from letta.services.step_manager import StepManager
 from letta.services.telemetry_manager import NoopTelemetryManager, TelemetryManager
 from letta.services.tool_executor.tool_execution_sandbox import ToolExecutionSandbox
 from letta.services.tool_manager import ToolManager
-from letta.settings import settings, summarizer_settings, model_settings
+from letta.settings import settings, summarizer_settings
 from letta.streaming_interface import StreamingRefreshCLIInterface
 from letta.system import get_heartbeat, get_token_limit_warning, package_function_response, package_summarize_message, package_user_message
-from letta.tracing import log_event, trace_method
 from letta.utils import count_tokens, get_friendly_error_msg, get_tool_call_id, log_telemetry, parse_json, validate_function_response
 
 logger = get_logger(__name__)
@@ -503,7 +503,7 @@ class Agent(BaseAgent):
                 response_message.function_call if response_message.function_call is not None else response_message.tool_calls[0].function
             )
             function_name = function_call.name
-            self.logger.debug(f"Request to call function {function_name} with tool_call_id: {tool_call_id}")
+            self.logger.info(f"Request to call function {function_name} with tool_call_id: {tool_call_id}")
 
             # Failure case 1: function name is wrong (not in agent_state.tools)
             target_letta_tool = None
@@ -1282,7 +1282,7 @@ class Agent(BaseAgent):
         )
 
     async def get_context_window_async(self) -> ContextWindowOverview:
-        if os.getenv("LETTA_ENVIRONMENT") == "PRODUCTION" and model_settings.anthropic_api_key is not None:
+        if os.getenv("LETTA_ENVIRONMENT") == "PRODUCTION":
             return await self.get_context_window_from_anthropic_async()
         return await self.get_context_window_from_tiktoken_async()
 
@@ -1291,8 +1291,8 @@ class Agent(BaseAgent):
         # Grab the in-context messages
         # conversion of messages to OpenAI dict format, which is passed to the token counter
         (in_context_messages, passage_manager_size, message_manager_size) = await asyncio.gather(
-            self.agent_manager.get_in_context_messages_async(agent_id=self.agent_state.id, actor=self.user),
-            self.passage_manager.size_async(actor=self.user, agent_id=self.agent_state.id),
+            self.message_manager.get_messages_by_ids_async(message_ids=self.agent_state.message_ids, actor=self.user),
+            self.passage_manager.agent_passage_size_async(actor=self.user, agent_id=self.agent_state.id),
             self.message_manager.size_async(actor=self.user, agent_id=self.agent_state.id),
         )
         in_context_messages_openai = [m.to_openai_dict() for m in in_context_messages]
@@ -1315,11 +1315,13 @@ class Agent(BaseAgent):
                 core_memory = system_message[core_memory_marker_pos:].strip()
             else:
                 # if no markers found, put everything in system message
+                self.logger.info("No markers found in system message, core_memory and external_memory_summary will not be loaded")
                 system_prompt = system_message
                 external_memory_summary = ""
                 core_memory = ""
         else:
             # if no system message, fall back on agent's system prompt
+            self.logger.info("No system message found in history, core_memory and external_memory_summary will not be loaded")
             system_prompt = self.agent_state.system
             external_memory_summary = ""
             core_memory = ""
@@ -1411,8 +1413,8 @@ class Agent(BaseAgent):
         # Grab the in-context messages
         # conversion of messages to anthropic dict format, which is passed to the token counter
         (in_context_messages, passage_manager_size, message_manager_size) = await asyncio.gather(
-            self.agent_manager.get_in_context_messages_async(agent_id=self.agent_state.id, actor=self.user),
-            self.passage_manager.size_async(actor=self.user, agent_id=self.agent_state.id),
+            self.message_manager.get_messages_by_ids_async(message_ids=self.agent_state.message_ids, actor=self.user),
+            self.passage_manager.agent_passage_size_async(actor=self.user, agent_id=self.agent_state.id),
             self.message_manager.size_async(actor=self.user, agent_id=self.agent_state.id),
         )
         in_context_messages_anthropic = [m.to_anthropic_dict() for m in in_context_messages]
@@ -1435,14 +1437,16 @@ class Agent(BaseAgent):
                 core_memory = system_message[core_memory_marker_pos:].strip()
             else:
                 # if no markers found, put everything in system message
+                self.logger.info("No markers found in system message, core_memory and external_memory_summary will not be loaded")
                 system_prompt = system_message
-                external_memory_summary = None
-                core_memory = None
+                external_memory_summary = ""
+                core_memory = ""
         else:
             # if no system message, fall back on agent's system prompt
+            self.logger.info("No system message found in history, core_memory and external_memory_summary will not be loaded")
             system_prompt = self.agent_state.system
-            external_memory_summary = None
-            core_memory = None
+            external_memory_summary = ""
+            core_memory = ""
 
         num_tokens_system_coroutine = anthropic_client.count_tokens(model=model, messages=[{"role": "user", "content": system_prompt}])
         num_tokens_core_memory_coroutine = (

letta/agents/base_agent.py

@@ -104,7 +104,7 @@ class BaseAgent(ABC):
             if num_messages is None:
                 num_messages = await self.message_manager.size_async(actor=self.actor, agent_id=agent_state.id)
             if num_archival_memories is None:
-                num_archival_memories = await self.passage_manager.size_async(actor=self.actor, agent_id=agent_state.id)
+                num_archival_memories = await self.passage_manager.agent_passage_size_async(actor=self.actor, agent_id=agent_state.id)
 
             new_system_message_str = compile_system_message(
                 system_prompt=agent_state.system,

letta/agents/helpers.py

@@ -1,8 +1,9 @@
 import uuid
 import xml.etree.ElementTree as ET
-from typing import List, Tuple
+from typing import List, Optional, Tuple
 
 from letta.schemas.agent import AgentState
+from letta.schemas.letta_message import MessageType
 from letta.schemas.letta_response import LettaResponse
 from letta.schemas.message import Message, MessageCreate
 from letta.schemas.usage import LettaUsageStatistics
@@ -12,16 +13,26 @@ from letta.services.message_manager import MessageManager
 
 
 def _create_letta_response(
-    new_in_context_messages: list[Message], use_assistant_message: bool, usage: LettaUsageStatistics
+    new_in_context_messages: list[Message],
+    use_assistant_message: bool,
+    usage: LettaUsageStatistics,
+    include_return_message_types: Optional[List[MessageType]] = None,
 ) -> LettaResponse:
     """
     Converts the newly created/persisted messages into a LettaResponse.
     """
     # NOTE: hacky solution to avoid returning heartbeat messages and the original user message
     filter_user_messages = [m for m in new_in_context_messages if m.role != "user"]
+
+    # Convert to Letta messages first
     response_messages = Message.to_letta_messages_from_list(
         messages=filter_user_messages, use_assistant_message=use_assistant_message, reverse=False
     )
+
+    # Apply message type filtering if specified
+    if include_return_message_types is not None:
+        response_messages = [msg for msg in response_messages if msg.message_type in include_return_message_types]
+
     return LettaResponse(messages=response_messages, usage=usage)
 
 

letta/agents/letta_agent.py

@@ -14,9 +14,9 @@ from letta.agents.helpers import (
     _prepare_in_context_messages_no_persist_async,
     generate_step_id,
 )
-from letta.errors import LLMContextWindowExceededError
+from letta.errors import ContextWindowExceededError
 from letta.helpers import ToolRulesSolver
-from letta.helpers.datetime_helpers import get_utc_timestamp_ns
+from letta.helpers.datetime_helpers import AsyncTimer, get_utc_timestamp_ns, ns_to_ms
 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
@@ -25,8 +25,12 @@ from letta.llm_api.llm_client_base import LLMClientBase
 from letta.local_llm.constants import INNER_THOUGHTS_KWARG
 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 log_event, trace_method, tracer
 from letta.schemas.agent import AgentState
 from letta.schemas.enums import MessageRole, MessageStreamStatus
+from letta.schemas.letta_message import MessageType
 from letta.schemas.letta_message_content import OmittedReasoningContent, ReasoningContent, RedactedReasoningContent, TextContent
 from letta.schemas.letta_response import LettaResponse
 from letta.schemas.llm_config import LLMConfig
@@ -48,7 +52,7 @@ from letta.services.telemetry_manager import NoopTelemetryManager, TelemetryMana
 from letta.services.tool_executor.tool_execution_manager import ToolExecutionManager
 from letta.settings import model_settings
 from letta.system import package_function_response
-from letta.tracing import log_event, trace_method, tracer
+from letta.types import JsonDict
 from letta.utils import log_telemetry, validate_function_response
 
 logger = get_logger(__name__)
@@ -118,6 +122,7 @@ class LettaAgent(BaseAgent):
         max_steps: int = 10,
         use_assistant_message: bool = True,
         request_start_timestamp_ns: Optional[int] = None,
+        include_return_message_types: Optional[List[MessageType]] = None,
     ) -> LettaResponse:
         agent_state = await self.agent_manager.get_agent_by_id_async(
             agent_id=self.agent_id, include_relationships=["tools", "memory", "tool_exec_environment_variables"], actor=self.actor
@@ -129,7 +134,10 @@ class LettaAgent(BaseAgent):
             request_start_timestamp_ns=request_start_timestamp_ns,
         )
         return _create_letta_response(
-            new_in_context_messages=new_in_context_messages, use_assistant_message=use_assistant_message, usage=usage
+            new_in_context_messages=new_in_context_messages,
+            use_assistant_message=use_assistant_message,
+            usage=usage,
+            include_return_message_types=include_return_message_types,
         )
 
     @trace_method
@@ -139,6 +147,7 @@ class LettaAgent(BaseAgent):
         max_steps: int = 10,
         use_assistant_message: bool = True,
         request_start_timestamp_ns: Optional[int] = None,
+        include_return_message_types: Optional[List[MessageType]] = None,
     ):
         agent_state = await self.agent_manager.get_agent_by_id_async(
             agent_id=self.agent_id, include_relationships=["tools", "memory", "tool_exec_environment_variables"], actor=self.actor
@@ -178,7 +187,7 @@ class LettaAgent(BaseAgent):
             # log llm request time
             now = get_utc_timestamp_ns()
             llm_request_ns = now - step_start
-            agent_step_span.add_event(name="llm_request_ms", attributes={"duration_ms": llm_request_ns // 1_000_000})
+            agent_step_span.add_event(name="llm_request_ms", attributes={"duration_ms": ns_to_ms(llm_request_ns)})
 
             response = llm_client.convert_response_to_chat_completion(response_data, in_context_messages, agent_state.llm_config)
 
@@ -210,7 +219,7 @@ class LettaAgent(BaseAgent):
             # log LLM request time
             now = get_utc_timestamp_ns()
             llm_request_ns = now - step_start
-            agent_step_span.add_event(name="llm_request_ms", attributes={"duration_ms": llm_request_ns // 1_000_000})
+            agent_step_span.add_event(name="llm_request_ms", attributes={"duration_ms": ns_to_ms(llm_request_ns)})
 
             persisted_messages, should_continue = await self._handle_ai_response(
                 tool_call,
@@ -227,7 +236,7 @@ class LettaAgent(BaseAgent):
             # log step time
             now = get_utc_timestamp_ns()
             step_ns = now - step_start
-            agent_step_span.add_event(name="step_ms", attributes={"duration_ms": step_ns // 1_000_000})
+            agent_step_span.add_event(name="step_ms", attributes={"duration_ms": ns_to_ms(step_ns)})
             agent_step_span.end()
 
             # Log LLM Trace
@@ -247,8 +256,12 @@ class LettaAgent(BaseAgent):
             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"
+                if not include_return_message_types:
+                    yield f"data: {message.model_dump_json()}\n\n"
+                elif include_return_message_types and message.message_type in include_return_message_types:
+                    yield f"data: {message.model_dump_json()}\n\n"
 
             if not should_continue:
                 break
@@ -267,7 +280,7 @@ class LettaAgent(BaseAgent):
         if request_start_timestamp_ns:
             now = get_utc_timestamp_ns()
             request_ns = now - request_start_timestamp_ns
-            request_span.add_event(name="letta_request_ms", attributes={"duration_ms": request_ns // 1_000_000})
+            request_span.add_event(name="letta_request_ms", attributes={"duration_ms": ns_to_ms(request_ns)})
         request_span.end()
 
         # Return back usage
@@ -321,7 +334,7 @@ class LettaAgent(BaseAgent):
             # log LLM request time
             now = get_utc_timestamp_ns()
             llm_request_ns = now - step_start
-            agent_step_span.add_event(name="llm_request_ms", attributes={"duration_ms": llm_request_ns // 1_000_000})
+            agent_step_span.add_event(name="llm_request_ms", attributes={"duration_ms": ns_to_ms(llm_request_ns)})
 
             # TODO: add run_id
             usage.step_count += 1
@@ -363,7 +376,7 @@ class LettaAgent(BaseAgent):
             # log step time
             now = get_utc_timestamp_ns()
             step_ns = now - step_start
-            agent_step_span.add_event(name="step_ms", attributes={"duration_ms": step_ns // 1_000_000})
+            agent_step_span.add_event(name="step_ms", attributes={"duration_ms": ns_to_ms(step_ns)})
             agent_step_span.end()
 
             # Log LLM Trace
@@ -384,7 +397,7 @@ class LettaAgent(BaseAgent):
         if request_start_timestamp_ns:
             now = get_utc_timestamp_ns()
             request_ns = now - request_start_timestamp_ns
-            request_span.add_event(name="request_ms", attributes={"duration_ms": request_ns // 1_000_000})
+            request_span.add_event(name="request_ms", attributes={"duration_ms": ns_to_ms(request_ns)})
         request_span.end()
 
         # Extend the in context message ids
@@ -406,6 +419,7 @@ class LettaAgent(BaseAgent):
         max_steps: int = 10,
         use_assistant_message: bool = True,
         request_start_timestamp_ns: Optional[int] = None,
+        include_return_message_types: Optional[List[MessageType]] = None,
     ) -> AsyncGenerator[str, None]:
         """
         Carries out an invocation of the agent loop in a streaming fashion that yields partial tokens.
@@ -480,16 +494,24 @@ class LettaAgent(BaseAgent):
                 if first_chunk and request_span is not None:
                     now = get_utc_timestamp_ns()
                     ttft_ns = now - request_start_timestamp_ns
-                    request_span.add_event(name="time_to_first_token_ms", attributes={"ttft_ms": ttft_ns // 1_000_000})
+                    request_span.add_event(name="time_to_first_token_ms", attributes={"ttft_ms": ns_to_ms(ttft_ns)})
                     first_chunk = False
 
-                yield f"data: {chunk.model_dump_json()}\n\n"
+                if include_return_message_types is None:
+                    # return all data
+                    yield f"data: {chunk.model_dump_json()}\n\n"
+                elif include_return_message_types and chunk.message_type in include_return_message_types:
+                    # filter down returned data
+                    yield f"data: {chunk.model_dump_json()}\n\n"
 
             # update usage
             usage.step_count += 1
             usage.completion_tokens += interface.output_tokens
             usage.prompt_tokens += interface.input_tokens
             usage.total_tokens += interface.input_tokens + interface.output_tokens
+            MetricRegistry().message_output_tokens.record(
+                interface.output_tokens, dict(get_ctx_attributes(), **{"model.name": agent_state.llm_config.model})
+            )
 
             # Persist input messages if not already
             # Special strategy to lower TTFT
@@ -500,7 +522,7 @@ class LettaAgent(BaseAgent):
             # log LLM request time
             now = get_utc_timestamp_ns()
             llm_request_ns = now - step_start
-            agent_step_span.add_event(name="llm_request_ms", attributes={"duration_ms": llm_request_ns // 1_000_000})
+            agent_step_span.add_event(name="llm_request_ms", attributes={"duration_ms": ns_to_ms(llm_request_ns)})
 
             # Process resulting stream content
             tool_call = interface.get_tool_call_object()
@@ -515,8 +537,7 @@ class LettaAgent(BaseAgent):
                     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,
+                pre_computed_assistant_message_id=interface.letta_message_id,
                 step_id=step_id,
                 agent_step_span=agent_step_span,
             )
@@ -526,7 +547,7 @@ class LettaAgent(BaseAgent):
             # log total step time
             now = get_utc_timestamp_ns()
             step_ns = now - step_start
-            agent_step_span.add_event(name="step_ms", attributes={"duration_ms": step_ns // 1_000_000})
+            agent_step_span.add_event(name="step_ms", attributes={"duration_ms": ns_to_ms(step_ns)})
             agent_step_span.end()
 
             # TODO (cliandy): the stream POST request span has ended at this point, we should tie this to the stream
@@ -556,9 +577,11 @@ class LettaAgent(BaseAgent):
                 ),
             )
 
-            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"
+            tool_return = [msg for msg in persisted_messages if msg.role == "tool"][-1].to_letta_messages()[0]
+            if not (use_assistant_message and tool_return.name == "send_message"):
+                # Apply message type filtering if specified
+                if include_return_message_types is None or tool_return.message_type in include_return_message_types:
+                    yield f"data: {tool_return.model_dump_json()}\n\n"
 
             if not should_continue:
                 break
@@ -577,7 +600,7 @@ class LettaAgent(BaseAgent):
         if request_start_timestamp_ns:
             now = get_utc_timestamp_ns()
             request_ns = now - request_start_timestamp_ns
-            request_span.add_event(name="letta_request_ms", attributes={"duration_ms": request_ns // 1_000_000})
+            request_span.add_event(name="letta_request_ms", attributes={"duration_ms": ns_to_ms(request_ns)})
         request_span.end()
 
         # TODO: Also yield out a letta usage stats SSE
@@ -604,10 +627,16 @@ class LettaAgent(BaseAgent):
                 )
                 log_event("agent.stream_no_tokens.llm_request.created")
 
+                async with AsyncTimer() as timer:
+                    response = await llm_client.request_async(request_data, agent_state.llm_config)
+                MetricRegistry().llm_execution_time_ms_histogram.record(
+                    timer.elapsed_ms,
+                    dict(get_ctx_attributes(), **{"model.name": agent_state.llm_config.model}),
+                )
                 # Attempt LLM request
                 return (
                     request_data,
-                    await llm_client.request_async(request_data, agent_state.llm_config),
+                    response,
                     current_in_context_messages,
                     new_in_context_messages,
                 )
@@ -654,9 +683,7 @@ class LettaAgent(BaseAgent):
                 if first_chunk and ttft_span is not None:
                     provider_request_start_timestamp_ns = get_utc_timestamp_ns()
                     provider_req_start_ns = provider_request_start_timestamp_ns - request_start_timestamp_ns
-                    ttft_span.add_event(
-                        name="provider_req_start_ns", attributes={"provider_req_start_ms": provider_req_start_ns // 1_000_000}
-                    )
+                    ttft_span.add_event(name="provider_req_start_ns", attributes={"provider_req_start_ms": ns_to_ms(provider_req_start_ns)})
 
                 # Attempt LLM request
                 return (
@@ -692,7 +719,7 @@ class LettaAgent(BaseAgent):
         llm_config: LLMConfig,
         force: bool,
     ) -> List[Message]:
-        if isinstance(e, LLMContextWindowExceededError):
+        if isinstance(e, ContextWindowExceededError):
             return await self._rebuild_context_window(
                 in_context_messages=in_context_messages, new_letta_messages=new_letta_messages, llm_config=llm_config, force=force
             )
@@ -754,7 +781,7 @@ class LettaAgent(BaseAgent):
                 else asyncio.sleep(0, result=self.num_messages)
             ),
             (
-                self.passage_manager.size_async(actor=self.actor, agent_id=agent_state.id)
+                self.passage_manager.agent_passage_size_async(actor=self.actor, agent_id=agent_state.id)
                 if self.num_archival_memories is None
                 else asyncio.sleep(0, result=self.num_archival_memories)
             ),
@@ -775,6 +802,7 @@ class LettaAgent(BaseAgent):
                 ToolType.LETTA_SLEEPTIME_CORE,
                 ToolType.LETTA_VOICE_SLEEPTIME_CORE,
                 ToolType.LETTA_BUILTIN,
+                ToolType.LETTA_FILES_CORE,
                 ToolType.EXTERNAL_COMPOSIO,
                 ToolType.EXTERNAL_MCP,
             }
@@ -810,7 +838,6 @@ class LettaAgent(BaseAgent):
         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,
         new_in_context_messages: Optional[List[Message]] = None,
         agent_step_span: Optional["Span"] = None,
@@ -822,6 +849,9 @@ class LettaAgent(BaseAgent):
         """
         tool_call_name = tool_call.function.name
         tool_call_args_str = tool_call.function.arguments
+        # Temp hack to gracefully handle parallel tool calling attempt, only take first one
+        if "}{" in tool_call_args_str:
+            tool_call_args_str = tool_call_args_str.split("}{", 1)[0] + "}"
 
         try:
             tool_args = json.loads(tool_call_args_str)
@@ -859,6 +889,7 @@ class LettaAgent(BaseAgent):
             tool_args=tool_args,
             agent_state=agent_state,
             agent_step_span=agent_step_span,
+            step_id=step_id,
         )
         log_telemetry(
             self.logger, "_handle_ai_response execute tool finish", tool_execution_result=tool_execution_result, tool_call_id=tool_call_id
@@ -926,7 +957,6 @@ class LettaAgent(BaseAgent):
             add_heartbeat_request_system_message=continue_stepping,
             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
         )
 
@@ -937,10 +967,15 @@ class LettaAgent(BaseAgent):
 
     @trace_method
     async def _execute_tool(
-        self, tool_name: str, tool_args: dict, agent_state: AgentState, agent_step_span: Optional["Span"] = None
+        self,
+        tool_name: str,
+        tool_args: JsonDict,
+        agent_state: AgentState,
+        agent_step_span: Optional["Span"] = None,
+        step_id: str | None = None,
     ) -> "ToolExecutionResult":
         """
-        Executes a tool and returns (result, success_flag).
+        Executes a tool and returns the ToolExecutionResult.
         """
         from letta.schemas.tool_execution_result import ToolExecutionResult
 
@@ -972,7 +1007,10 @@ class LettaAgent(BaseAgent):
         # 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
+            function_name=tool_name,
+            function_args=tool_args,
+            tool=target_tool,
+            step_id=step_id,
         )
         if agent_step_span:
             end_time = get_utc_timestamp_ns()
@@ -980,7 +1018,7 @@ class LettaAgent(BaseAgent):
                 name="tool_execution_completed",
                 attributes={
                     "tool_name": target_tool.name,
-                    "duration_ms": (end_time - start_time) // 1_000_000,
+                    "duration_ms": ns_to_ms((end_time - start_time)),
                     "success": tool_execution_result.success_flag,
                     "tool_type": target_tool.tool_type,
                     "tool_id": target_tool.id,

letta/agents/letta_agent_batch.py

@@ -16,6 +16,7 @@ from letta.llm_api.llm_client import LLMClient
 from letta.local_llm.constants import INNER_THOUGHTS_KWARG
 from letta.log import get_logger
 from letta.orm.enums import ToolType
+from letta.otel.tracing import log_event, trace_method
 from letta.schemas.agent import AgentState, AgentStepState
 from letta.schemas.enums import AgentStepStatus, JobStatus, MessageStreamStatus, ProviderType
 from letta.schemas.job import JobUpdate
@@ -39,7 +40,6 @@ from letta.services.passage_manager import PassageManager
 from letta.services.sandbox_config_manager import SandboxConfigManager
 from letta.services.tool_executor.tool_execution_manager import ToolExecutionManager
 from letta.settings import tool_settings
-from letta.tracing import log_event, trace_method
 
 logger = get_logger(__name__)
 
@@ -551,7 +551,6 @@ class LettaAgentBatch(BaseAgent):
             add_heartbeat_request_system_message=False,
             reasoning_content=reasoning_content,
             pre_computed_assistant_message_id=None,
-            pre_computed_tool_message_id=None,
             llm_batch_item_id=llm_batch_item_id,
         )
 

letta/agents/voice_agent.py

@@ -1,3 +1,4 @@
+import asyncio
 import json
 import uuid
 from datetime import datetime, timedelta, timezone
@@ -81,8 +82,8 @@ class VoiceAgent(BaseAgent):
         self.summary_block_label = "human"
 
         # Cached archival memory/message size
-        self.num_messages = self.message_manager.size(actor=self.actor, agent_id=agent_id)
-        self.num_archival_memories = self.passage_manager.size(actor=self.actor, agent_id=agent_id)
+        self.num_messages = None
+        self.num_archival_memories = None
 
     def init_summarizer(self, agent_state: AgentState) -> Summarizer:
         if not agent_state.multi_agent_group:
@@ -118,13 +119,12 @@ class VoiceAgent(BaseAgent):
         Main streaming loop that yields partial tokens.
         Whenever we detect a tool call, we yield from _handle_ai_response as well.
         """
-        print("CALL STREAM")
         if len(input_messages) != 1 or input_messages[0].role != MessageRole.user:
             raise ValueError(f"Voice Agent was invoked with multiple input messages or message did not have role `user`: {input_messages}")
 
         user_query = input_messages[0].content[0].text
 
-        agent_state = self.agent_manager.get_agent_by_id(self.agent_id, actor=self.actor)
+        agent_state = await self.agent_manager.get_agent_by_id_async(self.agent_id, actor=self.actor)
 
         # TODO: Refactor this so it uses our in-house clients
         # TODO: For now, piggyback off of OpenAI client for ease
@@ -140,7 +140,7 @@ class VoiceAgent(BaseAgent):
 
         summarizer = self.init_summarizer(agent_state=agent_state)
 
-        in_context_messages = self.message_manager.get_messages_by_ids(message_ids=agent_state.message_ids, actor=self.actor)
+        in_context_messages = await self.message_manager.get_messages_by_ids_async(message_ids=agent_state.message_ids, actor=self.actor)
         memory_edit_timestamp = get_utc_time()
         in_context_messages[0].content[0].text = compile_system_message(
             system_prompt=agent_state.system,
@@ -183,10 +183,6 @@ class VoiceAgent(BaseAgent):
         # Rebuild context window if desired
         await self._rebuild_context_window(summarizer, in_context_messages, letta_message_db_queue)
 
-        # TODO: This may be out of sync, if in between steps users add files
-        self.num_messages = self.message_manager.size(actor=self.actor, agent_id=agent_state.id)
-        self.num_archival_memories = self.passage_manager.size(actor=self.actor, agent_id=agent_state.id)
-
         yield "data: [DONE]\n\n"
 
     async def _handle_ai_response(
@@ -286,14 +282,14 @@ class VoiceAgent(BaseAgent):
     async def _rebuild_context_window(
         self, summarizer: Summarizer, in_context_messages: List[Message], letta_message_db_queue: List[Message]
     ) -> None:
-        new_letta_messages = self.message_manager.create_many_messages(letta_message_db_queue, actor=self.actor)
+        new_letta_messages = await self.message_manager.create_many_messages_async(letta_message_db_queue, actor=self.actor)
 
         # TODO: Make this more general and configurable, less brittle
         new_in_context_messages, updated = summarizer.summarize(
             in_context_messages=in_context_messages, new_letta_messages=new_letta_messages
         )
 
-        self.agent_manager.set_in_context_messages(
+        await self.agent_manager.set_in_context_messages_async(
             agent_id=self.agent_id, message_ids=[m.id for m in new_in_context_messages], actor=self.actor
         )
 
@@ -301,9 +297,19 @@ class VoiceAgent(BaseAgent):
         self,
         in_context_messages: List[Message],
         agent_state: AgentState,
-        num_messages: int | None = None,
-        num_archival_memories: int | None = None,
     ) -> List[Message]:
+        self.num_messages, self.num_archival_memories = await asyncio.gather(
+            (
+                self.message_manager.size_async(actor=self.actor, agent_id=agent_state.id)
+                if self.num_messages is None
+                else asyncio.sleep(0, result=self.num_messages)
+            ),
+            (
+                self.passage_manager.agent_passage_size_async(actor=self.actor, agent_id=agent_state.id)
+                if self.num_archival_memories is None
+                else asyncio.sleep(0, result=self.num_archival_memories)
+            ),
+        )
         return await super()._rebuild_memory_async(
             in_context_messages, agent_state, num_messages=self.num_messages, num_archival_memories=self.num_archival_memories
         )