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.

feat: Add parallel tool call streaming for anthropic [LET-4601] (#5225)

Matthew Zhoubb8a7889e086
diff --git a/letta/adapters/letta_llm_adapter.py b/letta/adapters/letta_llm_adapter.py
index f6ba57a69..69ac2ab1c 100644
--- a/letta/adapters/letta_llm_adapter.py
+++ b/letta/adapters/letta_llm_adapter.py
@@ -30,6 +30,7 @@ class LettaLLMAdapter(ABC):
self.reasoning_content: list[TextContent | ReasoningContent | RedactedReasoningContent] | None = None
self.content: list[TextContent | ReasoningContent | RedactedReasoningContent] | None = None
self.tool_call: ToolCall | None = None
+ self.tool_calls: list[ToolCall] = []
self.usage: LettaUsageStatistics = LettaUsageStatistics()
self.telemetry_manager: TelemetryManager = TelemetryManager()
self.llm_request_finish_timestamp_ns: int | None = None
diff --git a/letta/adapters/simple_llm_stream_adapter.py b/letta/adapters/simple_llm_stream_adapter.py
index 7cbad2a2d..ed6c1e515 100644
--- a/letta/adapters/simple_llm_stream_adapter.py
+++ b/letta/adapters/simple_llm_stream_adapter.py
@@ -25,6 +25,24 @@ class SimpleLLMStreamAdapter(LettaLLMStreamAdapter):
specific streaming formats.
"""
+ def _extract_tool_calls(self) -> list:
+ """extract tool calls from interface, trying parallel API first then single API"""
+ # try multi-call api if available
+ if hasattr(self.interface, "get_tool_call_objects"):
+ try:
+ calls = self.interface.get_tool_call_objects()
+ if calls:
+ return calls
+ except Exception:
+ pass
+
+ # fallback to single-call api
+ try:
+ single = self.interface.get_tool_call_object()
+ return [single] if single else []
+ except Exception:
+ return []
+
async def invoke_llm(
self,
request_data: dict,
@@ -102,12 +120,10 @@ class SimpleLLMStreamAdapter(LettaLLMStreamAdapter):
# After streaming completes, extract the accumulated data
self.llm_request_finish_timestamp_ns = get_utc_timestamp_ns()
- # Extract tool call from the interface
- try:
- self.tool_call = self.interface.get_tool_call_object()
- except ValueError as e:
- # No tool call, handle upstream
- self.tool_call = None
+ # extract tool calls from interface (supports both single and parallel calls)
+ self.tool_calls = self._extract_tool_calls()
+ # preserve legacy single-call field for existing consumers
+ self.tool_call = self.tool_calls[-1] if self.tool_calls else None
# Extract reasoning content from the interface
# TODO this should probably just be called "content"?
diff --git a/letta/agents/letta_agent_v3.py b/letta/agents/letta_agent_v3.py
index 497ec468f..2d1cf841b 100644
--- a/letta/agents/letta_agent_v3.py
+++ b/letta/agents/letta_agent_v3.py
@@ -1,3 +1,4 @@
+import asyncio
import uuid
from typing import AsyncGenerator, Optional
@@ -34,7 +35,11 @@ from letta.schemas.openai.chat_completion_response import ToolCall, UsageStatist
from letta.schemas.step import StepProgression
from letta.schemas.step_metrics import StepMetrics
from letta.schemas.tool_execution_result import ToolExecutionResult
-from letta.server.rest_api.utils import create_approval_request_message_from_llm_response, create_letta_messages_from_llm_response
+from letta.server.rest_api.utils import (
+ create_approval_request_message_from_llm_response,
+ create_letta_messages_from_llm_response,
+ create_parallel_tool_messages_from_llm_response,
+)
from letta.services.helpers.tool_parser_helper import runtime_override_tool_json_schema
from letta.settings import settings, summarizer_settings
from letta.system import package_function_response
@@ -324,6 +329,28 @@ class LettaAgentV3(LettaAgentV2):
force_tool_call=force_tool_call,
requires_subsequent_tool_call=self._require_tool_call,
)
+ # TODO: Extend to more providers, and also approval tool rules
+ # Enable Anthropic parallel tool use when no tool rules are attached
+ try:
+ if self.agent_state.llm_config.model_endpoint_type in ["anthropic", "bedrock"]:
+ no_tool_rules = not self.agent_state.tool_rules or len(self.agent_state.tool_rules) == 0
+ requires_approval = self.tool_rules_solver.get_requires_approval_tools(
+ set([t["name"] for t in valid_tools])
+ )
+ has_approval_tools = len(requires_approval) > 0
+ if (
+ isinstance(request_data.get("tool_choice"), dict)
+ and "disable_parallel_tool_use" in request_data["tool_choice"]
+ ):
+ # Gate parallel tool use on both: no tool rules and no approval-required tools
+ if no_tool_rules and not has_approval_tools:
+ request_data["tool_choice"]["disable_parallel_tool_use"] = False
+ else:
+ # Explicitly disable when approvals exist (TODO support later) or tool rules present
+ request_data["tool_choice"]["disable_parallel_tool_use"] = True
+ except Exception:
+ # if this fails, we simply don't enable parallel tool use
+ pass
if dry_run:
yield request_data
return
@@ -372,12 +399,31 @@ class LettaAgentV3(LettaAgentV2):
self._update_global_usage_stats(llm_adapter.usage)
- # Handle the AI response with the extracted data
- # NOTE: in v3 loop, no tool call is OK
- # if tool_call is None and llm_adapter.tool_call is None:
+ # Handle the AI response with the extracted data (supports multiple tool calls)
+ # Gather tool calls. Approval paths specify a single tool call.
+ tool_calls_list: list[ToolCall] = []
+ if tool_call is not None:
+ tool_calls_list = [tool_call]
+ else:
+ # Prefer the new multi-call field from streaming adapters
+ if hasattr(llm_adapter, "tool_calls") and llm_adapter.tool_calls:
+ tool_calls_list = llm_adapter.tool_calls
+ elif llm_adapter.tool_call is not None:
+ tool_calls_list = [llm_adapter.tool_call]
+ else:
+ tool_calls_list = []
+
+ aggregated_persisted: list[Message] = []
+ tool_return_payload = (
+ approval_response.approvals[0]
+ if approval_response and approval_response.approvals and isinstance(approval_response.approvals[0], ToolReturn)
+ else None
+ )
+ primary_tool_call = tool_calls_list[0] if len(tool_calls_list) == 1 else None
persisted_messages, self.should_continue, self.stop_reason = await self._handle_ai_response(
- tool_call=tool_call or llm_adapter.tool_call,
+ tool_call=primary_tool_call,
+ tool_calls=tool_calls_list,
valid_tool_names=[tool["name"] for tool in valid_tools],
agent_state=self.agent_state,
tool_rules_solver=self.tool_rules_solver,
@@ -386,7 +432,6 @@ class LettaAgentV3(LettaAgentV2):
prompt_tokens=self.usage.prompt_tokens,
total_tokens=self.usage.total_tokens,
),
- # reasoning_content=reasoning_content or llm_adapter.reasoning_content,
content=content or llm_adapter.content,
pre_computed_assistant_message_id=llm_adapter.message_id,
step_id=step_id,
@@ -398,26 +443,26 @@ class LettaAgentV3(LettaAgentV2):
is_approval=approval_response.approve if approval_response is not None else False,
is_denial=(approval_response.approve == False) if approval_response is not None else False,
denial_reason=approval_response.denial_reason if approval_response is not None else None,
- tool_return=approval_response.approvals[0]
- if approval_response and approval_response.approvals and isinstance(approval_response.approvals[0], ToolReturn)
- else None,
+ tool_return=tool_return_payload,
)
+ aggregated_persisted.extend(persisted_messages)
# NOTE: there is an edge case where persisted_messages is empty (the LLM did a "no-op")
new_message_idx = len(input_messages_to_persist) if input_messages_to_persist else 0
- self.response_messages.extend(persisted_messages[new_message_idx:])
+ self.response_messages.extend(aggregated_persisted[new_message_idx:])
if llm_adapter.supports_token_streaming():
- # Stream the tool return if a tool was actually executed.
- # In the normal streaming path, the tool call is surfaced via the streaming interface
- # (llm_adapter.tool_call), so don't rely solely on the local `tool_call` variable.
- has_tool_return = any(m.role == "tool" for m in persisted_messages)
- if len(persisted_messages) > 0 and persisted_messages[-1].role != "approval" and has_tool_return:
- tool_return = [msg for msg in persisted_messages if msg.role == "tool"][-1].to_letta_messages()[0]
- if include_return_message_types is None or tool_return.message_type in include_return_message_types:
- yield tool_return
+ # Stream each tool return if tools were executed
+ tool_returns = [msg for msg in aggregated_persisted if msg.role == "tool"]
+ for tr in tool_returns:
+ # Skip streaming for aggregated parallel tool returns (no per-call tool_call_id)
+ if tr.tool_call_id is None and tr.tool_returns:
+ continue
+ tool_return_letta = tr.to_letta_messages()[0]
+ if include_return_message_types is None or tool_return_letta.message_type in include_return_message_types:
+ yield tool_return_letta
else:
- filter_user_messages = [m for m in persisted_messages[new_message_idx:] if m.role != "user"]
+ filter_user_messages = [m for m in aggregated_persisted[new_message_idx:] if m.role != "user"]
letta_messages = Message.to_letta_messages_from_list(
filter_user_messages,
use_assistant_message=False, # NOTE: set to false
@@ -527,12 +572,10 @@ class LettaAgentV3(LettaAgentV2):
@trace_method
async def _handle_ai_response(
self,
- tool_call: Optional[ToolCall], # NOTE: should only be None for react agents
valid_tool_names: list[str],
agent_state: AgentState,
tool_rules_solver: ToolRulesSolver,
usage: UsageStatistics,
- # reasoning_content: list[TextContent | ReasoningContent | RedactedReasoningContent | OmittedReasoningContent] | None = None,
content: list[TextContent | ReasoningContent | RedactedReasoningContent | OmittedReasoningContent] | None = None,
pre_computed_assistant_message_id: str | None = None,
step_id: str | None = None,
@@ -544,57 +587,76 @@ class LettaAgentV3(LettaAgentV2):
is_approval: bool | None = None,
is_denial: bool | None = None,
denial_reason: str | None = None,
+ tool_call: ToolCall | None = None,
+ tool_calls: Optional[list[ToolCall]] = None,
tool_return: ToolReturn | None = None,
) -> tuple[list[Message], bool, LettaStopReason | None]:
"""
- Handle the final AI response once streaming completes, execute / validate the
- tool call, decide whether we should keep stepping, and persist state.
+ Handle the final AI response once streaming completes, execute / validate tool calls,
+ decide whether we should keep stepping, and persist state.
+
+ Unified approach: treats single and multi-tool calls uniformly to reduce code duplication.
"""
- if tool_call is None:
- # NOTE: in v3 loop, no tool call is OK
- tool_call_id = None
- else:
- tool_call_id: str = tool_call.id or f"call_{uuid.uuid4().hex[:8]}"
+ tool_calls = list(tool_calls) if tool_calls else []
+ if tool_call is not None and not tool_calls:
+ tool_calls = [tool_call]
+ first_tool_call = tool_calls[0] if tool_calls else tool_call
- if is_denial or tool_return is not None:
+ if tool_return is not None:
continue_stepping = True
stop_reason = None
- if tool_return is not None:
- tool_call_messages = [
- Message(
- role=MessageRole.tool,
- content=[TextContent(text=tool_return.func_response)],
- agent_id=agent_state.id,
- model=agent_state.llm_config.model,
- tool_calls=[],
- tool_call_id=tool_return.tool_call_id,
- created_at=get_utc_time(),
- tool_returns=[tool_return],
- run_id=run_id,
- step_id=step_id,
- )
- ]
- else:
- tool_call_messages = create_letta_messages_from_llm_response(
+ tool_call_messages = [
+ Message(
+ role=MessageRole.tool,
+ content=[TextContent(text=tool_return.func_response)],
agent_id=agent_state.id,
model=agent_state.llm_config.model,
- function_name=tool_call.function.name,
- function_arguments={},
- tool_execution_result=ToolExecutionResult(status="error"),
- tool_call_id=tool_call_id,
- function_response=f"Error: request to call tool denied. User reason: {denial_reason}",
- timezone=agent_state.timezone,
- continue_stepping=continue_stepping,
- # NOTE: we may need to change this to not have a "heartbeat" prefix for v3?
- heartbeat_reason=f"{NON_USER_MSG_PREFIX}Continuing: user denied request to call tool.",
- reasoning_content=None,
- pre_computed_assistant_message_id=None,
- step_id=step_id,
+ tool_calls=[],
+ tool_call_id=tool_return.tool_call_id,
+ created_at=get_utc_time(),
+ tool_returns=[tool_return],
run_id=run_id,
- is_approval_response=True,
- force_set_request_heartbeat=False,
- add_heartbeat_on_continue=False,
+ step_id=step_id,
)
+ ]
+ messages_to_persist = (initial_messages or []) + tool_call_messages
+ for message in messages_to_persist:
+ if message.run_id is None:
+ message.run_id = run_id
+
+ persisted_messages = await self.message_manager.create_many_messages_async(
+ messages_to_persist,
+ actor=self.actor,
+ run_id=run_id,
+ project_id=agent_state.project_id,
+ template_id=agent_state.template_id,
+ )
+ return persisted_messages, continue_stepping, stop_reason
+
+ # Handle denial case first (special case that bypasses normal flow)
+ if is_denial and first_tool_call is not None:
+ tool_call_id = first_tool_call.id or f"call_{uuid.uuid4().hex[:8]}"
+ continue_stepping = True
+ stop_reason = None
+ tool_call_messages = create_letta_messages_from_llm_response(
+ agent_id=agent_state.id,
+ model=agent_state.llm_config.model,
+ function_name=first_tool_call.function.name,
+ function_arguments={},
+ tool_execution_result=ToolExecutionResult(status="error"),
+ tool_call_id=tool_call_id,
+ function_response=f"Error: request to call tool denied. User reason: {denial_reason}",
+ timezone=agent_state.timezone,
+ continue_stepping=continue_stepping,
+ heartbeat_reason=f"{NON_USER_MSG_PREFIX}Continuing: user denied request to call tool.",
+ reasoning_content=None,
+ pre_computed_assistant_message_id=None,
+ step_id=step_id,
+ run_id=run_id,
+ is_approval_response=True,
+ force_set_request_heartbeat=False,
+ add_heartbeat_on_continue=False,
+ )
messages_to_persist = (initial_messages or []) + tool_call_messages
# Set run_id on all messages before persisting
@@ -611,97 +673,94 @@ class LettaAgentV3(LettaAgentV2):
)
return persisted_messages, continue_stepping, stop_reason
- # -1. no tool call, no content
- if tool_call is None and (content is None or len(content) == 0):
- # Edge case is when there's also no content - basically, the LLM "no-op'd"
- # If RequiredBeforeExitToolRule exists and not all required tools have been called,
- # inject a rule-violation heartbeat to keep looping and inform the model.
- uncalled = tool_rules_solver.get_uncalled_required_tools(available_tools=set([t.name for t in agent_state.tools]))
- if uncalled:
- # TODO: we may need to change this to not have a "heartbeat" prefix for v3?
- heartbeat_reason = (
- f"{NON_USER_MSG_PREFIX}ToolRuleViolated: You must call {', '.join(uncalled)} at least once to exit the loop."
- )
- from letta.server.rest_api.utils import create_heartbeat_system_message
+ # 3. Handle no-tool cases (content-only or no-op)
+ if not tool_calls:
+ # Case 3a: No tool call, no content (LLM no-op)
+ if content is None or len(content) == 0:
+ # Check if there are required-before-exit tools that haven't been called
+ uncalled = tool_rules_solver.get_uncalled_required_tools(available_tools=set([t.name for t in agent_state.tools]))
+ if uncalled:
+ heartbeat_reason = (
+ f"{NON_USER_MSG_PREFIX}ToolRuleViolated: You must call {', '.join(uncalled)} at least once to exit the loop."
+ )
+ from letta.server.rest_api.utils import create_heartbeat_system_message
+
+ heartbeat_msg = create_heartbeat_system_message(
+ agent_id=agent_state.id,
+ model=agent_state.llm_config.model,
+ function_call_success=True,
+ timezone=agent_state.timezone,
+ heartbeat_reason=heartbeat_reason,
+ run_id=run_id,
+ )
+ messages_to_persist = (initial_messages or []) + [heartbeat_msg]
+ continue_stepping, stop_reason = True, None
+ else:
+ # No required tools remaining, end turn without persisting no-op
+ continue_stepping = False
+ stop_reason = LettaStopReason(stop_reason=StopReasonType.end_turn.value)
+ messages_to_persist = initial_messages or []
- heartbeat_msg = create_heartbeat_system_message(
+ # Case 3b: No tool call but has content
+ else:
+ continue_stepping, heartbeat_reason, stop_reason = self._decide_continuation(
+ agent_state=agent_state,
+ tool_call_name=None,
+ tool_rule_violated=False,
+ tool_rules_solver=tool_rules_solver,
+ is_final_step=is_final_step,
+ )
+ assistant_message = create_letta_messages_from_llm_response(
agent_id=agent_state.id,
model=agent_state.llm_config.model,
- function_call_success=True,
+ function_name=None,
+ function_arguments=None,
+ tool_execution_result=None,
+ tool_call_id=None,
+ function_response=None,
timezone=agent_state.timezone,
+ continue_stepping=continue_stepping,
heartbeat_reason=heartbeat_reason,
+ reasoning_content=content,
+ pre_computed_assistant_message_id=pre_computed_assistant_message_id,
+ step_id=step_id,
run_id=run_id,
+ is_approval_response=is_approval or is_denial,
+ force_set_request_heartbeat=False,
+ add_heartbeat_on_continue=bool(heartbeat_reason),
)
- messages_to_persist = (initial_messages or []) + [heartbeat_msg]
- continue_stepping, stop_reason = True, None
- else:
- # In this case, we actually do not want to persist the no-op message
- continue_stepping, heartbeat_reason, stop_reason = False, None, LettaStopReason(stop_reason=StopReasonType.end_turn.value)
- messages_to_persist = initial_messages or []
-
- # 0. If there's no tool call, we can early exit
- elif tool_call is None:
- # TODO could just hardcode the line here instead of calling the function...
- continue_stepping, heartbeat_reason, stop_reason = self._decide_continuation(
- agent_state=agent_state,
- tool_call_name=None,
- tool_rule_violated=False,
- tool_rules_solver=tool_rules_solver,
- is_final_step=is_final_step,
- )
- assistant_message = create_letta_messages_from_llm_response(
- agent_id=agent_state.id,
- model=agent_state.llm_config.model,
- function_name=None,
- function_arguments=None,
- tool_execution_result=None,
- tool_call_id=None,
- function_response=None,
- timezone=agent_state.timezone,
- continue_stepping=continue_stepping,
- heartbeat_reason=heartbeat_reason,
- # NOTE: should probably rename this to `content`?
- reasoning_content=content,
- pre_computed_assistant_message_id=pre_computed_assistant_message_id,
- step_id=step_id,
- run_id=run_id,
- is_approval_response=is_approval or is_denial,
- force_set_request_heartbeat=False,
- # If we're continuing due to a required-before-exit rule, include a heartbeat to guide the model
- add_heartbeat_on_continue=bool(heartbeat_reason),
+ messages_to_persist = (initial_messages or []) + assistant_message
+
+ # Persist messages for no-tool cases
+ for message in messages_to_persist:
+ if message.run_id is None:
+ message.run_id = run_id
+
+ persisted_messages = await self.message_manager.create_many_messages_async(
+ messages_to_persist, actor=self.actor, run_id=run_id, project_id=agent_state.project_id, template_id=agent_state.template_id
)
- messages_to_persist = (initial_messages or []) + assistant_message
+ return persisted_messages, continue_stepping, stop_reason
- else:
- # 1. Parse and validate the tool-call envelope
- tool_call_name: str = tool_call.function.name
+ # 4. Unified tool execution path (works for both single and multiple tools)
- tool_args = _safe_load_tool_call_str(tool_call.function.arguments)
- # NOTE: these are failsafes - for v3, we should eventually be able to remove these
- # request_heartbeat: bool = _pop_heartbeat(tool_args)
+ # 4a. Check for single tool approval case (special handling required)
+ if len(tool_calls) == 1 and not is_approval:
+ single_tool = tool_calls[0]
+ tool_name = single_tool.function.name
+ tool_args = _safe_load_tool_call_str(single_tool.function.arguments)
tool_args.pop(REQUEST_HEARTBEAT_PARAM, None)
tool_args.pop(INNER_THOUGHTS_KWARG, None)
- log_telemetry(
- self.logger,
- "_handle_ai_response execute tool start",
- tool_name=tool_call_name,
- tool_args=tool_args,
- tool_call_id=tool_call_id,
- # request_heartbeat=request_heartbeat,
- )
-
- if not is_approval and tool_rules_solver.is_requires_approval_tool(tool_call_name):
+ if tool_rules_solver.is_requires_approval_tool(tool_name):
+ tool_call_id = single_tool.id or f"call_{uuid.uuid4().hex[:8]}"
approval_message = create_approval_request_message_from_llm_response(
agent_id=agent_state.id,
model=agent_state.llm_config.model,
- function_name=tool_call_name,
+ function_name=tool_name,
function_arguments=tool_args,
tool_call_id=tool_call_id,
actor=self.actor,
- # continue_stepping=request_heartbeat,
continue_stepping=True,
- # reasoning_content=reasoning_content,
reasoning_content=content,
pre_computed_assistant_message_id=pre_computed_assistant_message_id,
step_id=step_id,
@@ -709,155 +768,220 @@ class LettaAgentV3(LettaAgentV2):
append_request_heartbeat=False,
)
messages_to_persist = (initial_messages or []) + [approval_message]
- continue_stepping = False
- stop_reason = LettaStopReason(stop_reason=StopReasonType.requires_approval.value)
- else:
- # 2. Execute the tool (or synthesize an error result if disallowed)
- tool_rule_violated = tool_call_name not in valid_tool_names and not is_approval
- if tool_rule_violated:
- tool_execution_result = _build_rule_violation_result(tool_call_name, valid_tool_names, tool_rules_solver)
- else:
- # Prefill + validate args if a rule provided them
- prefill_args = self.tool_rules_solver.last_prefilled_args_by_tool.get(tool_call_name)
- if prefill_args:
- # Find tool object for schema validation
- target_tool = next((t for t in agent_state.tools if t.name == tool_call_name), None)
- provenance = self.tool_rules_solver.last_prefilled_args_provenance.get(tool_call_name)
- try:
- tool_args = merge_and_validate_prefilled_args(
- tool=target_tool,
- llm_args=tool_args,
- prefilled_args=prefill_args,
- )
- except ValueError as ve:
- # Treat invalid prefilled args as user error and end the step
- error_prefix = "Invalid prefilled tool arguments from tool rules"
- prov_suffix = f" (source={provenance})" if provenance else ""
- err_msg = f"{error_prefix}{prov_suffix}: {str(ve)}"
- tool_execution_result = ToolExecutionResult(status="error", func_return=err_msg)
-
- # Create messages and early return persistence path below
- continue_stepping, heartbeat_reason, stop_reason = (
- False,
- None,
- LettaStopReason(stop_reason=StopReasonType.invalid_tool_call.value),
- )
- tool_call_messages = create_letta_messages_from_llm_response(
- agent_id=agent_state.id,
- model=agent_state.llm_config.model,
- function_name=tool_call_name,
- function_arguments=tool_args,
- tool_execution_result=tool_execution_result,
- tool_call_id=tool_call_id,
- function_response=tool_execution_result.func_return,
- timezone=agent_state.timezone,
- continue_stepping=continue_stepping,
- heartbeat_reason=None,
- reasoning_content=content,
- pre_computed_assistant_message_id=pre_computed_assistant_message_id,
- step_id=step_id,
- run_id=run_id,
- is_approval_response=is_approval or is_denial,
- force_set_request_heartbeat=False,
- add_heartbeat_on_continue=False,
- )
- messages_to_persist = (initial_messages or []) + tool_call_messages
-
- # Set run_id on all messages before persisting
- for message in messages_to_persist:
- if message.run_id is None:
- message.run_id = run_id
-
- persisted_messages = await self.message_manager.create_many_messages_async(
- messages_to_persist,
- actor=self.actor,
- run_id=run_id,
- project_id=agent_state.project_id,
- template_id=agent_state.template_id,
- )
- return persisted_messages, continue_stepping, stop_reason
-
- # Track tool execution time
- tool_start_time = get_utc_timestamp_ns()
- tool_execution_result = await self._execute_tool(
- tool_name=tool_call_name,
- tool_args=tool_args,
- agent_state=agent_state,
- agent_step_span=agent_step_span,
- step_id=step_id,
- )
- tool_end_time = get_utc_timestamp_ns()
- # Store tool execution time in metrics
- step_metrics.tool_execution_ns = tool_end_time - tool_start_time
+ for message in messages_to_persist:
+ if message.run_id is None:
+ message.run_id = run_id
- log_telemetry(
- self.logger,
- "_handle_ai_response execute tool finish",
- tool_execution_result=tool_execution_result,
- tool_call_id=tool_call_id,
+ persisted_messages = await self.message_manager.create_many_messages_async(
+ messages_to_persist,
+ actor=self.actor,
+ run_id=run_id,
+ project_id=agent_state.project_id,
+ template_id=agent_state.template_id,
)
-
- # 3. Prepare the function-response payload
- truncate = tool_call_name not in {"conversation_search", "conversation_search_date", "archival_memory_search"}
- return_char_limit = next(
- (t.return_char_limit for t in agent_state.tools if t.name == tool_call_name),
- None,
+ return persisted_messages, False, LettaStopReason(stop_reason=StopReasonType.requires_approval.value)
+
+ # 4b. Validate parallel tool calling constraints
+ if len(tool_calls) > 1:
+ # No parallel tool calls with tool rules
+ if agent_state.tool_rules and len(agent_state.tool_rules) > 0:
+ raise ValueError(
+ "Parallel tool calling is not allowed when tool rules are present. Disable tool rules to use parallel tool calls."
)
- function_response_string = validate_function_response(
- tool_execution_result.func_return,
- return_char_limit=return_char_limit,
- truncate=truncate,
+ # No parallel tool calls with approval-required tools
+ if any(tool_rules_solver.is_requires_approval_tool(tc.function.name) for tc in tool_calls):
+ raise ValueError("Parallel tool calling is not allowed when any tool requires approval.")
+
+ # 4c. Prepare execution specs for all tools
+ exec_specs = []
+ for tc in tool_calls:
+ call_id = tc.id or f"call_{uuid.uuid4().hex[:8]}"
+ name = tc.function.name
+ args = _safe_load_tool_call_str(tc.function.arguments)
+ args.pop(REQUEST_HEARTBEAT_PARAM, None)
+ args.pop(INNER_THOUGHTS_KWARG, None)
+
+ # Validate against allowed tools
+ tool_rule_violated = name not in valid_tool_names and not is_approval
+
+ # Handle prefilled args if present
+ if not tool_rule_violated:
+ prefill_args = tool_rules_solver.last_prefilled_args_by_tool.get(name)
+ if prefill_args:
+ target_tool = next((t for t in agent_state.tools if t.name == name), None)
+ provenance = tool_rules_solver.last_prefilled_args_provenance.get(name)
+ try:
+ args = merge_and_validate_prefilled_args(
+ tool=target_tool,
+ llm_args=args,
+ prefilled_args=prefill_args,
+ )
+ except ValueError as ve:
+ # Invalid prefilled args - create error result
+ error_prefix = "Invalid prefilled tool arguments from tool rules"
+ prov_suffix = f" (source={provenance})" if provenance else ""
+ err_msg = f"{error_prefix}{prov_suffix}: {str(ve)}"
+
+ exec_specs.append(
+ {
+ "id": call_id,
+ "name": name,
+ "args": args,
+ "violated": False,
+ "error": err_msg,
+ }
+ )
+ continue
+
+ exec_specs.append(
+ {
+ "id": call_id,
+ "name": name,
+ "args": args,
+ "violated": tool_rule_violated,
+ "error": None,
+ }
+ )
+
+ # 4d. Execute tools (sequentially for single, parallel for multiple)
+ if len(exec_specs) == 1:
+ # Single tool - execute directly without asyncio.gather overhead
+ spec = exec_specs[0]
+ if spec.get("error"):
+ # Prefill arg validation error
+ result = ToolExecutionResult(status="error", func_return=spec["error"])
+ exec_time = 0
+ elif spec["violated"]:
+ result = _build_rule_violation_result(spec["name"], valid_tool_names, tool_rules_solver)
+ exec_time = 0
+ else:
+ t0 = get_utc_timestamp_ns()
+ result = await self._execute_tool(
+ tool_name=spec["name"],
+ tool_args=spec["args"],
+ agent_state=agent_state,
+ agent_step_span=agent_step_span,
+ step_id=step_id,
)
- self.last_function_response = package_function_response(
- was_success=tool_execution_result.success_flag,
- response_string=function_response_string,
- timezone=agent_state.timezone,
+ exec_time = get_utc_timestamp_ns() - t0
+ results = [(result, exec_time)]
+ else:
+ # Multiple tools - execute in parallel
+ async def _run_one(spec):
+ if spec.get("error"):
+ return ToolExecutionResult(status="error", func_return=spec["error"]), 0
+ if spec["violated"]:
+ result = _build_rule_violation_result(spec["name"], valid_tool_names, tool_rules_solver)
+ return result, 0
+ t0 = get_utc_timestamp_ns()
+ res = await self._execute_tool(
+ tool_name=spec["name"],
+ tool_args=spec["args"],
+ agent_state=agent_state,
+ agent_step_span=agent_step_span,
+ step_id=step_id,
)
+ dt = get_utc_timestamp_ns() - t0
+ return res, dt
+
+ results = await asyncio.gather(*[_run_one(s) for s in exec_specs])
+
+ # Update metrics with execution time
+ if step_metrics is not None and results:
+ step_metrics.tool_execution_ns = max(dt for _, dt in results)
+
+ # 4e. Process results and compute function responses
+ function_responses: list[Optional[str]] = []
+ persisted_continue_flags: list[bool] = []
+ persisted_stop_reasons: list[LettaStopReason | None] = []
+
+ for idx, spec in enumerate(exec_specs):
+ tool_execution_result, _ = results[idx]
+ has_prefill_error = bool(spec.get("error"))
+
+ # Validate and format function response
+ truncate = spec["name"] not in {"conversation_search", "conversation_search_date", "archival_memory_search"}
+ return_char_limit = next((t.return_char_limit for t in agent_state.tools if t.name == spec["name"]), None)
+ function_response_string = validate_function_response(
+ tool_execution_result.func_return,
+ return_char_limit=return_char_limit,
+ truncate=truncate,
+ )
+ function_responses.append(function_response_string)
- # 4. Decide whether to keep stepping (focal section simplified)
- continue_stepping, heartbeat_reason, stop_reason = self._decide_continuation(
+ # Update last function response (for tool rules)
+ self.last_function_response = package_function_response(
+ was_success=tool_execution_result.success_flag,
+ response_string=function_response_string,
+ timezone=agent_state.timezone,
+ )
+
+ # Register successful tool call with solver
+ if not spec["violated"] and not has_prefill_error:
+ tool_rules_solver.register_tool_call(spec["name"])
+
+ # Decide continuation for this tool
+ if has_prefill_error:
+ cont = False
+ hb_reason = None
+ sr = LettaStopReason(stop_reason=StopReasonType.invalid_tool_call.value)
+ else:
+ cont, hb_reason, sr = self._decide_continuation(
agent_state=agent_state,
- tool_call_name=tool_call_name,
- tool_rule_violated=tool_rule_violated,
+ tool_call_name=spec["name"],
+ tool_rule_violated=spec["violated"],
tool_rules_solver=tool_rules_solver,
- is_final_step=is_final_step,
+ is_final_step=(is_final_step and idx == len(exec_specs) - 1),
)
+ persisted_continue_flags.append(cont)
+ persisted_stop_reasons.append(sr)
+
+ # 4f. Create messages using parallel message creation (works for both single and multi)
+ tool_call_specs = [{"name": s["name"], "arguments": s["args"], "id": s["id"]} for s in exec_specs]
+ tool_execution_results = [res for (res, _) in results]
+
+ # Use the parallel message creation function for both single and multiple tools
+ parallel_messages = create_parallel_tool_messages_from_llm_response(
+ agent_id=agent_state.id,
+ model=agent_state.llm_config.model,
+ tool_call_specs=tool_call_specs,
+ tool_execution_results=tool_execution_results,
+ function_responses=function_responses,
+ timezone=agent_state.timezone,
+ run_id=run_id,
+ step_id=step_id,
+ reasoning_content=content,
+ pre_computed_assistant_message_id=pre_computed_assistant_message_id,
+ is_approval_response=(is_approval or is_denial),
+ )
- # 5. Create messages (step was already created at the beginning)
- tool_call_messages = create_letta_messages_from_llm_response(
- agent_id=agent_state.id,
- model=agent_state.llm_config.model,
- function_name=tool_call_name,
- function_arguments=tool_args,
- tool_execution_result=tool_execution_result,
- tool_call_id=tool_call_id,
- function_response=function_response_string,
- timezone=agent_state.timezone,
- continue_stepping=continue_stepping,
- # heartbeat_reason=heartbeat_reason,
- heartbeat_reason=None,
- # reasoning_content=reasoning_content,
- reasoning_content=content,
- pre_computed_assistant_message_id=pre_computed_assistant_message_id,
- step_id=step_id,
- run_id=run_id,
- is_approval_response=is_approval or is_denial,
- force_set_request_heartbeat=False,
- add_heartbeat_on_continue=False,
- )
- messages_to_persist = (initial_messages or []) + tool_call_messages
+ messages_to_persist: list[Message] = (initial_messages or []) + parallel_messages
# Set run_id on all messages before persisting
for message in messages_to_persist:
if message.run_id is None:
message.run_id = run_id
+ # Persist all messages
persisted_messages = await self.message_manager.create_many_messages_async(
- messages_to_persist, actor=self.actor, run_id=run_id, project_id=agent_state.project_id, template_id=agent_state.template_id
+ messages_to_persist,
+ actor=self.actor,
+ run_id=run_id,
+ project_id=agent_state.project_id,
+ template_id=agent_state.template_id,
)
- return persisted_messages, continue_stepping, stop_reason
+ # 4g. Aggregate continuation decisions
+ # For multiple tools: continue if ANY says continue, use last non-None stop_reason
+ # For single tool: use its decision directly
+ aggregate_continue = any(persisted_continue_flags) if persisted_continue_flags else False
+ aggregate_stop_reason = None
+ for sr in persisted_stop_reasons:
+ if sr is not None:
+ aggregate_stop_reason = sr
+
+ return persisted_messages, aggregate_continue, aggregate_stop_reason
@trace_method
def _decide_continuation(
diff --git a/letta/schemas/message.py b/letta/schemas/message.py
index 36d592cc7..d5d90286a 100644
--- a/letta/schemas/message.py
+++ b/letta/schemas/message.py
@@ -1514,6 +1514,7 @@ class Message(BaseMessage):
}
],
}
+
else:
raise ValueError(self.role)
diff --git a/letta/server/rest_api/utils.py b/letta/server/rest_api/utils.py
index 1b7e5dcde..efd5f06c0 100644
--- a/letta/server/rest_api/utils.py
+++ b/letta/server/rest_api/utils.py
@@ -3,7 +3,7 @@ import json
import os
import uuid
from enum import Enum
-from typing import AsyncGenerator, Dict, Iterable, List, Optional, Union, cast
+from typing import Any, AsyncGenerator, Dict, Iterable, List, Optional, Union, cast
from fastapi import Header, HTTPException
from openai.types.chat import ChatCompletionMessageParam
@@ -377,6 +377,117 @@ def create_letta_messages_from_llm_response(
return messages
+def create_parallel_tool_messages_from_llm_response(
+ agent_id: str,
+ model: str,
+ tool_call_specs: List[Dict[str, Any]], # List of tool call specs: {"name": str, "arguments": Dict, "id": Optional[str]}
+ tool_execution_results: List[ToolExecutionResult],
+ function_responses: List[Optional[str]],
+ timezone: str,
+ run_id: Optional[str] = None,
+ step_id: Optional[str] = None,
+ reasoning_content: Optional[
+ List[Union[TextContent, ReasoningContent, RedactedReasoningContent, OmittedReasoningContent | SummarizedReasoningContent]]
+ ] = None,
+ pre_computed_assistant_message_id: Optional[str] = None,
+ llm_batch_item_id: Optional[str] = None,
+ is_approval_response: bool = False,
+) -> List[Message]:
+ """
+ Build two messages representing a parallel tool-call step:
+ - One assistant message with ALL tool_calls populated (tool_call_id left empty)
+ - One tool message with ALL tool_returns populated (tool_call_id left empty)
+
+ Notes:
+ - Consumers should read tool_calls/tool_returns arrays for per-call details.
+ - The tool message's content includes only the first call's packaged response for
+ backward-compatibility with legacy renderers. UIs should prefer tool_returns.
+ - When invoked for an approval response, the assistant message is omitted (the approval
+ tool call was previously surfaced).
+ """
+
+ # Construct OpenAI-style tool_calls for the assistant message
+ openai_tool_calls: List[OpenAIToolCall] = []
+ for spec in tool_call_specs:
+ name = spec.get("name")
+ args = spec.get("arguments", {})
+ call_id = spec.get("id") or str(uuid.uuid4())
+ # Ensure the spec carries the resolved id so returns/content can reference it
+ if not spec.get("id"):
+ spec["id"] = call_id
+ openai_tool_calls.append(
+ OpenAIToolCall(
+ id=call_id,
+ function=OpenAIFunction(name=name, arguments=json.dumps(args)),
+ type="function",
+ )
+ )
+
+ messages: List[Message] = []
+
+ if not is_approval_response:
+ # Assistant message with all tool_calls (no single tool_call_id)
+ # Safeguard against empty text messages
+ content: List[
+ Union[TextContent, ReasoningContent, RedactedReasoningContent, OmittedReasoningContent, SummarizedReasoningContent]
+ ] = []
+ if reasoning_content:
+ for content_part in reasoning_content:
+ if isinstance(content_part, TextContent) and content_part.text == "":
+ continue
+ content.append(content_part)
+
+ assistant_message = Message(
+ role=MessageRole.assistant,
+ content=content,
+ agent_id=agent_id,
+ model=model,
+ tool_calls=openai_tool_calls,
+ tool_call_id=None,
+ created_at=get_utc_time(),
+ batch_item_id=llm_batch_item_id,
+ run_id=run_id,
+ )
+ if step_id:
+ assistant_message.step_id = step_id
+ if pre_computed_assistant_message_id:
+ assistant_message.id = pre_computed_assistant_message_id
+ messages.append(assistant_message)
+
+ content: List[TextContent] = []
+ tool_returns: List[ToolReturn] = []
+ for spec, exec_result, response in zip(tool_call_specs, tool_execution_results, function_responses):
+ packaged = package_function_response(exec_result.success_flag, response, timezone)
+ content.append(TextContent(text=packaged))
+ tool_returns.append(
+ ToolReturn(
+ tool_call_id=spec.get("id"),
+ status=exec_result.status,
+ stdout=exec_result.stdout,
+ stderr=exec_result.stderr,
+ func_response=packaged,
+ )
+ )
+
+ tool_message = Message(
+ role=MessageRole.tool,
+ content=content,
+ agent_id=agent_id,
+ model=model,
+ tool_calls=[],
+ tool_call_id=tool_returns[0].tool_call_id, # For legacy reasons, set to first one
+ created_at=get_utc_time(),
+ batch_item_id=llm_batch_item_id,
+ tool_returns=tool_returns,
+ run_id=run_id,
+ )
+ if step_id:
+ tool_message.step_id = step_id
+
+ messages.append(tool_message)
+ return messages
+
+
def create_heartbeat_system_message(
agent_id: str,
model: str,
diff --git a/tests/test_agent_files/test_basic_agent_with_blocks_tools_messages_v2.af b/tests/test_agent_files/test_basic_agent_with_blocks_tools_messages_v2.af
index 9ebbaf4c7..026d6f827 100644
--- a/tests/test_agent_files/test_basic_agent_with_blocks_tools_messages_v2.af
+++ b/tests/test_agent_files/test_basic_agent_with_blocks_tools_messages_v2.af
@@ -1,7 +1,7 @@
{
"agents": [
{
- "name": "test_export_import_57426498-f708-4228-a331-5efc0087b895",
+ "name": "test_export_import_42fbdcec-58ce-4e27-b6e5-938b3bcd57aa",
"memory_blocks": [],
"tools": [],
"tool_ids": [
@@ -21,22 +21,22 @@
],
"tool_rules": [
{
- "tool_name": "send_message",
- "type": "exit_loop",
+ "tool_name": "memory_insert",
+ "type": "continue_loop",
"prompt_template": null
},
{
- "tool_name": "memory_insert",
- "type": "continue_loop",
+ "tool_name": "send_message",
+ "type": "exit_loop",
"prompt_template": null
},
{
- "tool_name": "memory_replace",
+ "tool_name": "conversation_search",
"type": "continue_loop",
"prompt_template": null
},
{
- "tool_name": "conversation_search",
+ "tool_name": "memory_replace",
"type": "continue_loop",
"prompt_template": null
}
@@ -129,7 +129,7 @@
"content": [
{
"type": "text",
- "text": "You are a helpful assistant specializing in data analysis and mathematical computations.\n\n<memory_blocks>\nThe following memory blocks are currently engaged in your core memory unit:\n\n<project_context>\n<description>\n\n</description>\n<metadata>\n- chars_current=210\n- chars_limit=6000\n</metadata>\n<value>\n# NOTE: Line numbers shown below are to help during editing. Do NOT include line number prefixes in your memory edit tool calls.\nLine 1: Current project: Building predictive models for financial markets. Sarah is working on sequence analysis and pattern recognition. Recently interested in mathematical sequences like Fibonacci for trend analysis.\n</value>\n</project_context>\n\n<human>\n<description>\nThe human block: Stores key details about the person you are conversing with, allowing for more personalized and friend-like conversation.\n</description>\n<metadata>\n- chars_current=175\n- chars_limit=4000\n</metadata>\n<value>\n# NOTE: Line numbers shown below are to help during editing. Do NOT include line number prefixes in your memory edit tool calls.\nLine 1: username: sarah_researcher\nLine 2: occupation: data scientist\nLine 3: interests: machine learning, statistics, fibonacci sequences\nLine 4: preferred_communication: detailed explanations with examples\n</value>\n</human>\n\n<persona>\n<description>\nThe persona block: Stores details about your current persona, guiding how you behave and respond. This helps you to maintain consistency and personality in your interactions.\n</description>\n<metadata>\n- chars_current=195\n- chars_limit=8000\n</metadata>\n<value>\n# NOTE: Line numbers shown below are to help during editing. Do NOT include line number prefixes in your memory edit tool calls.\nLine 1: You are Alex, a data analyst and mathematician who helps users with calculations and insights. You have extensive experience in statistical analysis and prefer to provide clear, accurate results.\n</value>\n</persona>\n\n</memory_blocks>\n\n<tool_usage_rules>\nThe following constraints define rules for tool usage and guide desired behavior. These rules must be followed to ensure proper tool execution and workflow. A single response may contain multiple tool calls.\n\n<tool_rule>\nmemory_insert requires continuing your response when called\n</tool_rule>\n<tool_rule>\nmemory_replace requires continuing your response when called\n</tool_rule>\n<tool_rule>\nconversation_search requires continuing your response when called\n</tool_rule>\n<tool_rule>\nsend_message ends your response (yields control) when called\n</tool_rule>\n</tool_usage_rules>\n\n<memory_metadata>\n- The current system date is: October 10, 2025\n- Memory blocks were last modified: 2025-10-10 12:21:30 AM UTC+0000\n- -1 previous messages between you and the user are stored in recall memory (use tools to access them)\n- 2 total memories you created are stored in archival memory (use tools to access them)\n</memory_metadata>",
+ "text": "You are a helpful assistant specializing in data analysis and mathematical computations.\n\n<memory_blocks>\nThe following memory blocks are currently engaged in your core memory unit:\n\n<project_context>\n<description>\n\n</description>\n<metadata>\n- chars_current=210\n- chars_limit=6000\n</metadata>\n<value>\n# NOTE: Line numbers shown below are to help during editing. Do NOT include line number prefixes in your memory edit tool calls.\nLine 1: Current project: Building predictive models for financial markets. Sarah is working on sequence analysis and pattern recognition. Recently interested in mathematical sequences like Fibonacci for trend analysis.\n</value>\n</project_context>\n\n<human>\n<description>\nThe human block: Stores key details about the person you are conversing with, allowing for more personalized and friend-like conversation.\n</description>\n<metadata>\n- chars_current=175\n- chars_limit=4000\n</metadata>\n<value>\n# NOTE: Line numbers shown below are to help during editing. Do NOT include line number prefixes in your memory edit tool calls.\nLine 1: username: sarah_researcher\nLine 2: occupation: data scientist\nLine 3: interests: machine learning, statistics, fibonacci sequences\nLine 4: preferred_communication: detailed explanations with examples\n</value>\n</human>\n\n<persona>\n<description>\nThe persona block: Stores details about your current persona, guiding how you behave and respond. This helps you to maintain consistency and personality in your interactions.\n</description>\n<metadata>\n- chars_current=195\n- chars_limit=8000\n</metadata>\n<value>\n# NOTE: Line numbers shown below are to help during editing. Do NOT include line number prefixes in your memory edit tool calls.\nLine 1: You are Alex, a data analyst and mathematician who helps users with calculations and insights. You have extensive experience in statistical analysis and prefer to provide clear, accurate results.\n</value>\n</persona>\n\n</memory_blocks>\n\n<tool_usage_rules>\nThe following constraints define rules for tool usage and guide desired behavior. These rules must be followed to ensure proper tool execution and workflow. A single response may contain multiple tool calls.\n\n<tool_rule>\nmemory_insert requires continuing your response when called\n</tool_rule>\n<tool_rule>\nconversation_search requires continuing your response when called\n</tool_rule>\n<tool_rule>\nmemory_replace requires continuing your response when called\n</tool_rule>\n<tool_rule>\nsend_message ends your response (yields control) when called\n</tool_rule>\n</tool_usage_rules>\n\n<memory_metadata>\n- The current system date is: October 10, 2025\n- Memory blocks were last modified: 2025-10-10 07:14:31 AM UTC+0000\n- -1 previous messages between you and the user are stored in recall memory (use tools to access them)\n- 2 total memories you created are stored in archival memory (use tools to access them)\n</memory_metadata>",
"signature": null
}
],
@@ -144,7 +144,7 @@
"tool_calls": null,
"tool_call_id": null,
"tool_returns": [],
- "created_at": "2025-10-10T00:21:29.139951+00:00",
+ "created_at": "2025-10-10T07:14:29.912336+00:00",
"approve": null,
"approval_request_id": null,
"denial_reason": null
@@ -169,7 +169,7 @@
"agent_id": "agent-0",
"tool_calls": [
{
- "id": "9b3e8290-a336-4e3b-851e-2472ccd6fe91",
+ "id": "f9a9765f-9285-4056-9916-d5bafb729bef",
"function": {
"arguments": "{\n \"message\": \"More human than human is our motto.\"\n}",
"name": "send_message"
@@ -179,7 +179,7 @@
],
"tool_call_id": null,
"tool_returns": [],
- "created_at": "2025-10-10T00:21:29.139990+00:00",
+ "created_at": "2025-10-10T07:14:29.912379+00:00",
"approve": null,
"approval_request_id": null,
"denial_reason": null
@@ -190,7 +190,7 @@
"content": [
{
"type": "text",
- "text": "{\n \"status\": \"OK\",\n \"message\": null,\n \"time\": \"2025-10-10 12:21:29 AM UTC+0000\"\n}",
+ "text": "{\n \"status\": \"OK\",\n \"message\": null,\n \"time\": \"2025-10-10 07:14:29 AM UTC+0000\"\n}",
"signature": null
}
],
@@ -203,9 +203,9 @@
"model": "gpt-4.1-mini",
"agent_id": "agent-0",
"tool_calls": null,
- "tool_call_id": "9b3e8290-a336-4e3b-851e-2472ccd6fe91",
+ "tool_call_id": "f9a9765f-9285-4056-9916-d5bafb729bef",
"tool_returns": [],
- "created_at": "2025-10-10T00:21:29.140013+00:00",
+ "created_at": "2025-10-10T07:14:29.912403+00:00",
"approve": null,
"approval_request_id": null,
"denial_reason": null
@@ -216,7 +216,7 @@
"content": [
{
"type": "text",
- "text": "{\n \"type\": \"login\",\n \"last_login\": \"Never (first login)\",\n \"time\": \"2025-10-10 12:21:29 AM UTC+0000\"\n}",
+ "text": "{\n \"type\": \"login\",\n \"last_login\": \"Never (first login)\",\n \"time\": \"2025-10-10 07:14:29 AM UTC+0000\"\n}",
"signature": null
}
],
@@ -231,7 +231,7 @@
"tool_calls": null,
"tool_call_id": null,
"tool_returns": [],
- "created_at": "2025-10-10T00:21:29.140024+00:00",
+ "created_at": "2025-10-10T07:14:29.912415+00:00",
"approve": null,
"approval_request_id": null,
"denial_reason": null
@@ -257,7 +257,7 @@
"tool_calls": null,
"tool_call_id": null,
"tool_returns": [],
- "created_at": "2025-10-10T00:21:30.360611+00:00",
+ "created_at": "2025-10-10T07:14:31.639749+00:00",
"approve": null,
"approval_request_id": null,
"denial_reason": null
@@ -268,7 +268,7 @@
"content": [
{
"type": "text",
- "text": "Responding to test message for export.",
+ "text": "Responding to test message for export with confirmation.",
"signature": null
}
],
@@ -282,17 +282,17 @@
"agent_id": "agent-0",
"tool_calls": [
{
- "id": "call_mNAOnZ212k0eehF005T5s6Wn",
+ "id": "call_tB2kJPFgSD5Ldk8VaUYwkMCF",
"function": {
- "arguments": "{\"message\": \"Received your test message for export. Everything is working fine on my end. How can I assist you further today?\", \"request_heartbeat\": false}",
+ "arguments": "{\"message\": \"Test message received successfully. Ready for further instructions or queries.\", \"request_heartbeat\": false}",
"name": "send_message"
},
"type": "function"
}
],
- "tool_call_id": "call_mNAOnZ212k0eehF005T5s6Wn",
+ "tool_call_id": "call_tB2kJPFgSD5Ldk8VaUYwkMCF",
"tool_returns": [],
- "created_at": "2025-10-10T00:21:31.900813+00:00",
+ "created_at": "2025-10-10T07:14:33.049314+00:00",
"approve": null,
"approval_request_id": null,
"denial_reason": null
@@ -303,7 +303,7 @@
"content": [
{
"type": "text",
- "text": "{\n \"status\": \"OK\",\n \"message\": \"Sent message successfully.\",\n \"time\": \"2025-10-10 12:21:31 AM UTC+0000\"\n}",
+ "text": "{\n \"status\": \"OK\",\n \"message\": \"Sent message successfully.\",\n \"time\": \"2025-10-10 07:14:33 AM UTC+0000\"\n}",
"signature": null
}
],
@@ -316,17 +316,17 @@
"model": "gpt-4.1-mini",
"agent_id": "agent-0",
"tool_calls": null,
- "tool_call_id": "call_mNAOnZ212k0eehF005T5s6Wn",
+ "tool_call_id": "call_tB2kJPFgSD5Ldk8VaUYwkMCF",
"tool_returns": [
{
- "tool_call_id": "call_mNAOnZ212k0eehF005T5s6Wn",
+ "tool_call_id": "call_tB2kJPFgSD5Ldk8VaUYwkMCF",
"status": "success",
"stdout": null,
"stderr": null,
- "func_response": "{\n \"status\": \"OK\",\n \"message\": \"Sent message successfully.\",\n \"time\": \"2025-10-10 12:21:31 AM UTC+0000\"\n}"
+ "func_response": "{\n \"status\": \"OK\",\n \"message\": \"Sent message successfully.\",\n \"time\": \"2025-10-10 07:14:33 AM UTC+0000\"\n}"
}
],
- "created_at": "2025-10-10T00:21:31.900994+00:00",
+ "created_at": "2025-10-10T07:14:33.049503+00:00",
"approve": null,
"approval_request_id": null,
"denial_reason": null
@@ -477,7 +477,7 @@
"metadata_": {}
},
{
- "id": "tool-4",
+ "id": "tool-5",
"tool_type": "letta_core",
"description": "Search prior conversation history using hybrid search (text + semantic similarity).\n\nExamples:\n # Search all messages\n conversation_search(query=\"project updates\")\n\n # Search only assistant messages\n conversation_search(query=\"error handling\", roles=[\"assistant\"])\n\n # Search with date range (inclusive of both dates)\n conversation_search(query=\"meetings\", start_date=\"2024-01-15\", end_date=\"2024-01-20\")\n # This includes all messages from Jan 15 00:00:00 through Jan 20 23:59:59\n\n # Search messages from a specific day (inclusive)\n conversation_search(query=\"bug reports\", start_date=\"2024-09-04\", end_date=\"2024-09-04\")\n # This includes ALL messages from September 4, 2024\n\n # Search with specific time boundaries\n conversation_search(query=\"deployment\", start_date=\"2024-01-15T09:00\", end_date=\"2024-01-15T17:30\")\n # This includes messages from 9 AM to 5:30 PM on Jan 15\n\n # Search with limit\n conversation_search(query=\"debugging\", limit=10)\n\n Returns:\n str: Query result string containing matching messages with timestamps and content.",
"source_type": "python",
@@ -536,7 +536,7 @@
"metadata_": {}
},
{
- "id": "tool-1",
+ "id": "tool-0",
"tool_type": "custom",
"description": "Get user preferences for a specific category.",
"source_type": "json",
@@ -572,7 +572,7 @@
"metadata_": {}
},
{
- "id": "tool-0",
+ "id": "tool-6",
"tool_type": "letta_sleeptime_core",
"description": "The memory_insert command allows you to insert text at a specific location in a memory block.\n\nExamples:\n # Update a block containing information about the user (append to the end of the block)\n memory_insert(label=\"customer\", new_str=\"The customer's ticket number is 12345\")\n\n # Update a block containing information about the user (insert at the beginning of the block)\n memory_insert(label=\"customer\", new_str=\"The customer's ticket number is 12345\", insert_line=0)\n\n Returns:\n Optional[str]: None is always returned as this function does not produce a response.",
"source_type": "python",
@@ -616,7 +616,7 @@
"metadata_": {}
},
{
- "id": "tool-5",
+ "id": "tool-1",
"tool_type": "letta_sleeptime_core",
"description": "The memory_replace command allows you to replace a specific string in a memory block with a new string. This is used for making precise edits.\n\nExamples:\n # Update a block containing information about the user\n memory_replace(label=\"human\", old_str=\"Their name is Alice\", new_str=\"Their name is Bob\")\n\n # Update a block containing a todo list\n memory_replace(label=\"todos\", old_str=\"- [ ] Step 5: Search the web\", new_str=\"- [x] Step 5: Search the web\")\n\n # Pass an empty string to\n memory_replace(label=\"human\", old_str=\"Their name is Alice\", new_str=\"\")\n\n # Bad example - do NOT add (view-only) line numbers to the args\n memory_replace(label=\"human\", old_str=\"Line 1: Their name is Alice\", new_str=\"Line 1: Their name is Bob\")\n\n # Bad example - do NOT include the number number warning either\n memory_replace(label=\"human\", old_str=\"# NOTE: Line numbers shown below are to help during editing. Do NOT include line number prefixes in your memory edit tool calls.\\nLine 1: Their name is Alice\", new_str=\"Line 1: Their name is Bob\")\n\n # Good example - no line numbers or line number warning (they are view-only), just the text\n memory_replace(label=\"human\", old_str=\"Their name is Alice\", new_str=\"Their name is Bob\")\n\n Returns:\n str: The success message",
"source_type": "python",
@@ -661,7 +661,7 @@
"metadata_": {}
},
{
- "id": "tool-6",
+ "id": "tool-4",
"tool_type": "letta_core",
"description": "Sends a message to the human user.",
"source_type": "python",
@@ -698,7 +698,7 @@
],
"mcp_servers": [],
"metadata": {
- "revision_id": "c734cfc0d595"
+ "revision_id": "066857381578"
},
- "created_at": "2025-10-10T00:21:32.284067+00:00"
+ "created_at": "2025-10-10T07:14:33.457962+00:00"
}