letta-nightly 0.12.1.dev20251023104211__py3-none-any.whl → 0.13.0.dev20251024223017__py3-none-any.whl

letta/__init__.py

@@ -5,7 +5,7 @@ try:
     __version__ = version("letta")
 except PackageNotFoundError:
     # Fallback for development installations
-    __version__ = "0.12.1"
+    __version__ = "0.13.0"
 
 if os.environ.get("LETTA_VERSION"):
     __version__ = os.environ["LETTA_VERSION"]
@@ -28,8 +28,7 @@ from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.enums import JobStatus
 from letta.schemas.file import FileMetadata
 from letta.schemas.job import Job
-from letta.schemas.letta_message import LettaMessage
-from letta.schemas.letta_ping import LettaPing
+from letta.schemas.letta_message import LettaMessage, LettaPing
 from letta.schemas.letta_stop_reason import LettaStopReason
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.memory import ArchivalMemorySummary, BasicBlockMemory, ChatMemory, Memory, RecallMemorySummary

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

letta/adapters/simple_llm_request_adapter.py

@@ -38,7 +38,11 @@ class SimpleLLMRequestAdapter(LettaLLMRequestAdapter):
         self.request_data = request_data
 
         # Make the blocking LLM request
-        self.response_data = await self.llm_client.request_async(request_data, self.llm_config)
+        try:
+            self.response_data = await self.llm_client.request_async(request_data, self.llm_config)
+        except Exception as e:
+            raise self.llm_client.handle_llm_error(e)
+
         self.llm_request_finish_timestamp_ns = get_utc_timestamp_ns()
 
         # Convert response to chat completion format
@@ -71,10 +75,9 @@ class SimpleLLMRequestAdapter(LettaLLMRequestAdapter):
             self.content = self.reasoning_content + (self.content or [])
 
         # Extract tool call
-        if self.chat_completions_response.choices[0].message.tool_calls:
-            self.tool_call = self.chat_completions_response.choices[0].message.tool_calls[0]
-        else:
-            self.tool_call = None
+        tool_calls = self.chat_completions_response.choices[0].message.tool_calls or []
+        self.tool_calls = list(tool_calls)
+        self.tool_call = self.tool_calls[0] if self.tool_calls else None
 
         # Extract usage statistics
         self.usage.step_count = 1

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"?

letta/agents/agent_loop.py

@@ -4,6 +4,7 @@ from letta.agents.base_agent_v2 import BaseAgentV2
 from letta.agents.letta_agent_v2 import LettaAgentV2
 from letta.agents.letta_agent_v3 import LettaAgentV3
 from letta.groups.sleeptime_multi_agent_v3 import SleeptimeMultiAgentV3
+from letta.groups.sleeptime_multi_agent_v4 import SleeptimeMultiAgentV4
 from letta.schemas.agent import AgentState
 from letta.schemas.enums import AgentType
 
@@ -16,13 +17,19 @@ class AgentLoop:
 
     @staticmethod
     def load(agent_state: AgentState, actor: "User") -> BaseAgentV2:
-        if agent_state.enable_sleeptime and agent_state.agent_type != AgentType.voice_convo_agent:
-            return SleeptimeMultiAgentV3(agent_state=agent_state, actor=actor, group=agent_state.multi_agent_group)
-        elif agent_state.agent_type == AgentType.letta_v1_agent:
+        if agent_state.agent_type == AgentType.letta_v1_agent:
+            if agent_state.enable_sleeptime:
+                return SleeptimeMultiAgentV4(
+                    agent_state=agent_state,
+                    actor=actor,
+                    group=agent_state.multi_agent_group,
+                )
             return LettaAgentV3(
                 agent_state=agent_state,
                 actor=actor,
             )
+        elif agent_state.enable_sleeptime and agent_state.agent_type != AgentType.voice_convo_agent:
+            return SleeptimeMultiAgentV3(agent_state=agent_state, actor=actor, group=agent_state.multi_agent_group)
         else:
             return LettaAgentV2(
                 agent_state=agent_state,

letta/agents/base_agent.py

@@ -140,7 +140,10 @@ class BaseAgent(ABC):
 
             # generate just the memory string with current state for comparison
             curr_memory_str = agent_state.memory.compile(
-                tool_usage_rules=tool_constraint_block, sources=agent_state.sources, max_files_open=agent_state.max_files_open
+                tool_usage_rules=tool_constraint_block,
+                sources=agent_state.sources,
+                max_files_open=agent_state.max_files_open,
+                llm_config=agent_state.llm_config,
             )
             new_dynamic_section = extract_dynamic_section(curr_memory_str)
 

letta/agents/helpers.py

@@ -13,7 +13,7 @@ from letta.schemas.letta_message import MessageType
 from letta.schemas.letta_message_content import TextContent
 from letta.schemas.letta_response import LettaResponse
 from letta.schemas.letta_stop_reason import LettaStopReason, StopReasonType
-from letta.schemas.message import Message, MessageCreate, MessageCreateBase
+from letta.schemas.message import ApprovalCreate, Message, MessageCreate, MessageCreateBase
 from letta.schemas.tool_execution_result import ToolExecutionResult
 from letta.schemas.usage import LettaUsageStatistics
 from letta.schemas.user import User
@@ -135,6 +135,24 @@ async def _prepare_in_context_messages_async(
     return current_in_context_messages, new_in_context_messages
 
 
+def validate_approval_tool_call_ids(approval_request_message: Message, approval_response_message: ApprovalCreate):
+    approval_requests = approval_request_message.tool_calls
+    approval_request_tool_call_ids = [approval_request.id for approval_request in approval_requests]
+
+    approval_responses = approval_response_message.approvals
+    approval_response_tool_call_ids = [approval_response.tool_call_id for approval_response in approval_responses]
+
+    request_response_diff = set(approval_request_tool_call_ids).symmetric_difference(set(approval_response_tool_call_ids))
+    if request_response_diff:
+        if len(approval_request_tool_call_ids) == 1 and approval_response_tool_call_ids[0] == approval_request_message.id:
+            # legacy case where we used to use message id instead of tool call id
+            return
+
+        raise ValueError(
+            f"Invalid tool call IDs. Expected '{approval_request_tool_call_ids}', but received '{approval_response_tool_call_ids}'."
+        )
+
+
 async def _prepare_in_context_messages_no_persist_async(
     input_messages: List[MessageCreateBase],
     agent_state: AgentState,
@@ -168,20 +186,18 @@ async def _prepare_in_context_messages_no_persist_async(
     # Check for approval-related message validation
     if len(input_messages) == 1 and input_messages[0].type == "approval":
         # User is trying to send an approval response
-        if current_in_context_messages[-1].role != "approval":
+        if current_in_context_messages and current_in_context_messages[-1].role != "approval":
             raise ValueError(
                 "Cannot process approval response: No tool call is currently awaiting approval. "
                 "Please send a regular message to interact with the agent."
             )
-        if input_messages[0].approval_request_id != current_in_context_messages[-1].id:
-            raise ValueError(
-                f"Invalid approval request ID. Expected '{current_in_context_messages[-1].id}' "
-                f"but received '{input_messages[0].approval_request_id}'."
-            )
-        new_in_context_messages = create_approval_response_message_from_input(agent_state=agent_state, input_message=input_messages[0])
+        validate_approval_tool_call_ids(current_in_context_messages[-1], input_messages[0])
+        new_in_context_messages = create_approval_response_message_from_input(
+            agent_state=agent_state, input_message=input_messages[0], run_id=run_id
+        )
     else:
         # User is trying to send a regular message
-        if current_in_context_messages[-1].role == "approval":
+        if current_in_context_messages and current_in_context_messages[-1].role == "approval":
             raise PendingApprovalError(pending_request_id=current_in_context_messages[-1].id)
 
         # Create a new user message from the input but dont store it yet
@@ -400,3 +416,19 @@ def _maybe_get_approval_messages(messages: list[Message]) -> Tuple[Message | Non
         if maybe_approval_request.role == "approval" and maybe_approval_response.role == "approval":
             return maybe_approval_request, maybe_approval_response
     return None, None
+
+
+def _maybe_get_pending_tool_call_message(messages: list[Message]) -> Message | None:
+    """
+    Only used in the case where hitl is invoked with parallel tool calling,
+    where agent calls some tools that require approval, and others that don't.
+    """
+    if len(messages) >= 3:
+        maybe_tool_call_message = messages[-3]
+        if (
+            maybe_tool_call_message.role == "assistant"
+            and maybe_tool_call_message.tool_calls is not None
+            and len(maybe_tool_call_message.tool_calls) > 0
+        ):
+            return maybe_tool_call_message
+    return None

letta/agents/letta_agent.py

@@ -1,3 +1,4 @@
+import json
 import uuid
 from collections.abc import AsyncGenerator
 from datetime import datetime
@@ -18,7 +19,7 @@ from letta.agents.helpers import (
     _safe_load_tool_call_str,
     generate_step_id,
 )
-from letta.constants import DEFAULT_MAX_STEPS, NON_USER_MSG_PREFIX
+from letta.constants import DEFAULT_MAX_STEPS, NON_USER_MSG_PREFIX, REQUEST_HEARTBEAT_PARAM
 from letta.errors import ContextWindowExceededError
 from letta.helpers import ToolRulesSolver
 from letta.helpers.datetime_helpers import AsyncTimer, get_utc_time, get_utc_timestamp_ns, ns_to_ms
@@ -41,7 +42,7 @@ from letta.schemas.letta_response import LettaResponse
 from letta.schemas.letta_stop_reason import LettaStopReason, StopReasonType
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.message import Message, MessageCreateBase
-from letta.schemas.openai.chat_completion_response import ToolCall, UsageStatistics
+from letta.schemas.openai.chat_completion_response import FunctionCall, ToolCall, UsageStatistics
 from letta.schemas.provider_trace import ProviderTraceCreate
 from letta.schemas.step import StepProgression
 from letta.schemas.step_metrics import StepMetrics
@@ -1698,19 +1699,18 @@ class LettaAgent(BaseAgent):
             request_heartbeat=request_heartbeat,
         )
         if not is_approval and tool_rules_solver.is_requires_approval_tool(tool_call_name):
-            approval_message = create_approval_request_message_from_llm_response(
+            tool_args[REQUEST_HEARTBEAT_PARAM] = request_heartbeat
+            approval_messages = create_approval_request_message_from_llm_response(
                 agent_id=agent_state.id,
                 model=agent_state.llm_config.model,
-                function_name=tool_call_name,
-                function_arguments=tool_args,
-                tool_call_id=tool_call_id,
-                actor=self.actor,
-                continue_stepping=request_heartbeat,
+                requested_tool_calls=[
+                    ToolCall(id=tool_call_id, function=FunctionCall(name=tool_call_name, arguments=json.dumps(tool_args)))
+                ],
                 reasoning_content=reasoning_content,
                 pre_computed_assistant_message_id=pre_computed_assistant_message_id,
                 step_id=step_id,
             )
-            messages_to_persist = (initial_messages or []) + [approval_message]
+            messages_to_persist = (initial_messages or []) + approval_messages
             continue_stepping = False
             stop_reason = LettaStopReason(stop_reason=StopReasonType.requires_approval.value)
         else:
@@ -1868,7 +1868,8 @@ class LettaAgent(BaseAgent):
             start_time = get_utc_timestamp_ns()
             agent_step_span.add_event(name="tool_execution_started")
 
-        sandbox_env_vars = {var.key: var.value for var in agent_state.secrets}
+        # Decrypt environment variable values
+        sandbox_env_vars = {var.key: var.get_value_secret().get_plaintext() for var in agent_state.secrets}
         tool_execution_manager = ToolExecutionManager(
             agent_state=agent_state,
             message_manager=self.message_manager,

letta/agents/letta_agent_v2.py

@@ -1,4 +1,4 @@
-import asyncio
+import json
 import uuid
 from datetime import datetime
 from typing import AsyncGenerator, Optional, Tuple
@@ -19,7 +19,7 @@ from letta.agents.helpers import (
     _safe_load_tool_call_str,
     generate_step_id,
 )
-from letta.constants import DEFAULT_MAX_STEPS, NON_USER_MSG_PREFIX
+from letta.constants import DEFAULT_MAX_STEPS, NON_USER_MSG_PREFIX, REQUEST_HEARTBEAT_PARAM
 from letta.errors import ContextWindowExceededError, LLMError
 from letta.helpers import ToolRulesSolver
 from letta.helpers.datetime_helpers import get_utc_time, get_utc_timestamp_ns, ns_to_ms
@@ -37,9 +37,10 @@ from letta.schemas.letta_message_content import OmittedReasoningContent, Reasoni
 from letta.schemas.letta_response import LettaResponse
 from letta.schemas.letta_stop_reason import LettaStopReason, StopReasonType
 from letta.schemas.message import Message, MessageCreate, MessageUpdate
-from letta.schemas.openai.chat_completion_response import ToolCall, UsageStatistics
+from letta.schemas.openai.chat_completion_response import FunctionCall, ToolCall, UsageStatistics
 from letta.schemas.step import Step, StepProgression
 from letta.schemas.step_metrics import StepMetrics
+from letta.schemas.tool import Tool
 from letta.schemas.tool_execution_result import ToolExecutionResult
 from letta.schemas.usage import LettaUsageStatistics
 from letta.schemas.user import User
@@ -470,7 +471,7 @@ class LettaAgentV2(BaseAgentV2):
             # Handle the AI response with the extracted data
             if tool_call is None and llm_adapter.tool_call is None:
                 self.stop_reason = LettaStopReason(stop_reason=StopReasonType.no_tool_call.value)
-                raise ValueError("No tool calls found in response, model must make a tool call")
+                raise LLMError("No tool calls found in response, model must make a tool call")
 
             # TODO: how should be associate input messages with runs?
             ## Set run_id on input messages before persisting
@@ -535,7 +536,7 @@ class LettaAgentV2(BaseAgentV2):
                 )
             step_progression, step_metrics = await self._step_checkpoint_finish(step_metrics, agent_step_span, logged_step)
         except Exception as e:
-            self.logger.error(f"Error during step processing: {e}")
+            self.logger.warning(f"Error during step processing: {e}")
             self.job_update_metadata = {"error": str(e)}
 
             # This indicates we failed after we decided to stop stepping, which indicates a bug with our flow.
@@ -699,7 +700,10 @@ class LettaAgentV2(BaseAgentV2):
 
         # generate just the memory string with current state for comparison
         curr_memory_str = agent_state.memory.compile(
-            tool_usage_rules=tool_constraint_block, sources=agent_state.sources, max_files_open=agent_state.max_files_open
+            tool_usage_rules=tool_constraint_block,
+            sources=agent_state.sources,
+            max_files_open=agent_state.max_files_open,
+            llm_config=agent_state.llm_config,
         )
         new_dynamic_section = extract_dynamic_section(curr_memory_str)
 
@@ -933,20 +937,19 @@ class LettaAgentV2(BaseAgentV2):
         )
 
         if not is_approval and tool_rules_solver.is_requires_approval_tool(tool_call_name):
-            approval_message = create_approval_request_message_from_llm_response(
+            tool_args[REQUEST_HEARTBEAT_PARAM] = request_heartbeat
+            approval_messages = create_approval_request_message_from_llm_response(
                 agent_id=agent_state.id,
                 model=agent_state.llm_config.model,
-                function_name=tool_call_name,
-                function_arguments=tool_args,
-                tool_call_id=tool_call_id,
-                actor=self.actor,
-                continue_stepping=request_heartbeat,
+                requested_tool_calls=[
+                    ToolCall(id=tool_call_id, function=FunctionCall(name=tool_call_name, arguments=json.dumps(tool_args)))
+                ],
                 reasoning_content=reasoning_content,
                 pre_computed_assistant_message_id=pre_computed_assistant_message_id,
                 step_id=step_id,
                 run_id=run_id,
             )
-            messages_to_persist = (initial_messages or []) + [approval_message]
+            messages_to_persist = (initial_messages or []) + approval_messages
             continue_stepping = False
             stop_reason = LettaStopReason(stop_reason=StopReasonType.requires_approval.value)
         else:
@@ -957,8 +960,10 @@ class LettaAgentV2(BaseAgentV2):
             else:
                 # Track tool execution time
                 tool_start_time = get_utc_timestamp_ns()
+                target_tool = next((x for x in agent_state.tools if x.name == tool_call_name), None)
+
                 tool_execution_result = await self._execute_tool(
-                    tool_name=tool_call_name,
+                    target_tool=target_tool,
                     tool_args=tool_args,
                     agent_state=agent_state,
                     agent_step_span=agent_step_span,
@@ -1079,20 +1084,20 @@ class LettaAgentV2(BaseAgentV2):
     @trace_method
     async def _execute_tool(
         self,
-        tool_name: str,
+        target_tool: Tool,
         tool_args: JsonDict,
         agent_state: AgentState,
         agent_step_span: Span | None = None,
         step_id: str | None = None,
-        run_id: str = None,
     ) -> "ToolExecutionResult":
         """
         Executes a tool and returns the ToolExecutionResult.
         """
         from letta.schemas.tool_execution_result import ToolExecutionResult
 
+        tool_name = target_tool.name
+
         # Special memory case
-        target_tool = next((x for x in agent_state.tools if x.name == tool_name), None)
         if not target_tool:
             # TODO: fix this error message
             return ToolExecutionResult(
@@ -1106,7 +1111,8 @@ class LettaAgentV2(BaseAgentV2):
             start_time = get_utc_timestamp_ns()
             agent_step_span.add_event(name="tool_execution_started")
 
-        sandbox_env_vars = {var.key: var.value for var in agent_state.secrets}
+        # Decrypt environment variable values
+        sandbox_env_vars = {var.key: var.get_value_secret().get_plaintext() for var in agent_state.secrets}
         tool_execution_manager = ToolExecutionManager(
             agent_state=agent_state,
             message_manager=self.message_manager,
@@ -1158,25 +1164,29 @@ class LettaAgentV2(BaseAgentV2):
         # TODO: This can be broken by bad configs, e.g. lower bound too high, initial messages too fat, etc.
         # TODO: `force` and `clear` seem to no longer be used, we should remove
         if not skip_summarization:
-            if force or (total_tokens and total_tokens > self.agent_state.llm_config.context_window):
-                self.logger.warning(
-                    f"Total tokens {total_tokens} exceeds configured max tokens {self.agent_state.llm_config.context_window}, forcefully clearing message history."
-                )
-                new_in_context_messages, updated = await self.summarizer.summarize(
-                    in_context_messages=in_context_messages,
-                    new_letta_messages=new_letta_messages,
-                    force=True,
-                    clear=True,
-                )
-            else:
-                # NOTE (Sarah): Seems like this is doing nothing?
-                self.logger.info(
-                    f"Total tokens {total_tokens} does not exceed configured max tokens {self.agent_state.llm_config.context_window}, passing summarizing w/o force."
-                )
-                new_in_context_messages, updated = await self.summarizer.summarize(
-                    in_context_messages=in_context_messages,
-                    new_letta_messages=new_letta_messages,
-                )
+            try:
+                if force or (total_tokens and total_tokens > self.agent_state.llm_config.context_window):
+                    self.logger.warning(
+                        f"Total tokens {total_tokens} exceeds configured max tokens {self.agent_state.llm_config.context_window}, forcefully clearing message history."
+                    )
+                    new_in_context_messages, updated = await self.summarizer.summarize(
+                        in_context_messages=in_context_messages,
+                        new_letta_messages=new_letta_messages,
+                        force=True,
+                        clear=True,
+                    )
+                else:
+                    # NOTE (Sarah): Seems like this is doing nothing?
+                    self.logger.info(
+                        f"Total tokens {total_tokens} does not exceed configured max tokens {self.agent_state.llm_config.context_window}, passing summarizing w/o force."
+                    )
+                    new_in_context_messages, updated = await self.summarizer.summarize(
+                        in_context_messages=in_context_messages,
+                        new_letta_messages=new_letta_messages,
+                    )
+            except Exception as e:
+                self.logger.error(f"Failed to summarize conversation history: {e}")
+                new_in_context_messages = in_context_messages + new_letta_messages
         else:
             new_in_context_messages = in_context_messages + new_letta_messages