letta-nightly 0.8.3.dev20250612104349__py3-none-any.whl → 0.8.4.dev20250613104250__py3-none-any.whl

letta/__init__.py

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

letta/agent.py

@@ -46,7 +46,7 @@ from letta.schemas.agent import AgentState, AgentStepResponse, UpdateAgent, get_
 from letta.schemas.block import BlockUpdate
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.enums import MessageRole, ProviderType
-from letta.schemas.letta_message_content import TextContent
+from letta.schemas.letta_message_content import ImageContent, TextContent
 from letta.schemas.memory import ContextWindowOverview, Memory
 from letta.schemas.message import Message, MessageCreate, ToolReturn
 from letta.schemas.openai.chat_completion_response import ChatCompletionResponse
@@ -369,6 +369,16 @@ class Agent(BaseAgent):
                     )
                 else:
                     # Fallback to existing flow
+                    for message in message_sequence:
+                        if isinstance(message.content, list):
+
+                            def get_fallback_text_content(content):
+                                if isinstance(content, ImageContent):
+                                    return TextContent(text="[Image Here]")
+                                return content
+
+                            message.content = [get_fallback_text_content(content) for content in message.content]
+
                     response = create(
                         llm_config=self.agent_state.llm_config,
                         messages=message_sequence,

letta/agents/base_agent.py

@@ -3,6 +3,8 @@ from typing import Any, AsyncGenerator, List, Optional, Union
 
 import openai
 
+from letta.constants import DEFAULT_MAX_STEPS
+from letta.helpers import ToolRulesSolver
 from letta.helpers.datetime_helpers import get_utc_time
 from letta.log import get_logger
 from letta.schemas.agent import AgentState
@@ -15,6 +17,7 @@ from letta.schemas.user import User
 from letta.services.agent_manager import AgentManager
 from letta.services.helpers.agent_manager_helper import compile_system_message
 from letta.services.message_manager import MessageManager
+from letta.services.passage_manager import PassageManager
 from letta.utils import united_diff
 
 logger = get_logger(__name__)
@@ -39,11 +42,13 @@ class BaseAgent(ABC):
         self.openai_client = openai_client
         self.message_manager = message_manager
         self.agent_manager = agent_manager
+        # TODO: Pass this in
+        self.passage_manager = PassageManager()
         self.actor = actor
         self.logger = get_logger(agent_id)
 
     @abstractmethod
-    async def step(self, input_messages: List[MessageCreate], max_steps: int = 10) -> LettaResponse:
+    async def step(self, input_messages: List[MessageCreate], max_steps: int = DEFAULT_MAX_STEPS) -> LettaResponse:
         """
         Main execution loop for the agent.
         """
@@ -51,7 +56,7 @@ class BaseAgent(ABC):
 
     @abstractmethod
     async def step_stream(
-        self, input_messages: List[MessageCreate], max_steps: int = 10
+        self, input_messages: List[MessageCreate], max_steps: int = DEFAULT_MAX_STEPS
     ) -> AsyncGenerator[Union[LettaMessage, LegacyLettaMessage, MessageStreamStatus], None]:
         """
         Main streaming execution loop for the agent.
@@ -77,8 +82,9 @@ class BaseAgent(ABC):
         self,
         in_context_messages: List[Message],
         agent_state: AgentState,
-        num_messages: int | None = None,  # storing these calculations is specific to the voice agent
-        num_archival_memories: int | None = None,
+        tool_rules_solver: Optional[ToolRulesSolver] = None,
+        num_messages: Optional[int] = None,  # storing these calculations is specific to the voice agent
+        num_archival_memories: Optional[int] = None,
     ) -> List[Message]:
         """
         Async version of function above. For now before breaking up components, changes should be made in both places.
@@ -112,6 +118,7 @@ class BaseAgent(ABC):
                 in_context_memory_last_edit=memory_edit_timestamp,
                 previous_message_count=num_messages,
                 archival_memory_size=num_archival_memories,
+                tool_rules_solver=tool_rules_solver,
             )
 
             diff = united_diff(curr_system_message_text, new_system_message_str)

letta/agents/ephemeral_summary_agent.py

@@ -4,6 +4,7 @@ from typing import AsyncGenerator, Dict, List
 from openai import AsyncOpenAI
 
 from letta.agents.base_agent import BaseAgent
+from letta.constants import DEFAULT_MAX_STEPS
 from letta.orm.errors import NoResultFound
 from letta.schemas.block import Block, BlockUpdate
 from letta.schemas.enums import MessageRole
@@ -42,7 +43,7 @@ class EphemeralSummaryAgent(BaseAgent):
         self.target_block_label = target_block_label
         self.block_manager = block_manager
 
-    async def step(self, input_messages: List[MessageCreate], max_steps: int = 10) -> List[Message]:
+    async def step(self, input_messages: List[MessageCreate], max_steps: int = DEFAULT_MAX_STEPS) -> List[Message]:
         if len(input_messages) > 1:
             raise ValueError("Can only invoke EphemeralSummaryAgent with a single summarization message.")
 
@@ -100,5 +101,5 @@ class EphemeralSummaryAgent(BaseAgent):
         )
         return openai_request
 
-    async def step_stream(self, input_messages: List[MessageCreate], max_steps: int = 10) -> AsyncGenerator[str, None]:
+    async def step_stream(self, input_messages: List[MessageCreate], max_steps: int = DEFAULT_MAX_STEPS) -> AsyncGenerator[str, None]:
         raise NotImplementedError("EphemeralAgent does not support async step.")

letta/agents/letta_agent.py

@@ -8,12 +8,8 @@ from openai.types.chat import ChatCompletionChunk
 
 from letta.agents.base_agent import BaseAgent
 from letta.agents.ephemeral_summary_agent import EphemeralSummaryAgent
-from letta.agents.helpers import (
-    _create_letta_response,
-    _prepare_in_context_messages_async,
-    _prepare_in_context_messages_no_persist_async,
-    generate_step_id,
-)
+from letta.agents.helpers import _create_letta_response, _prepare_in_context_messages_no_persist_async, generate_step_id
+from letta.constants import DEFAULT_MAX_STEPS
 from letta.errors import ContextWindowExceededError
 from letta.helpers import ToolRulesSolver
 from letta.helpers.datetime_helpers import AsyncTimer, get_utc_timestamp_ns, ns_to_ms
@@ -37,6 +33,7 @@ from letta.schemas.llm_config import LLMConfig
 from letta.schemas.message import Message, MessageCreate
 from letta.schemas.openai.chat_completion_response import ToolCall, UsageStatistics
 from letta.schemas.provider_trace import ProviderTraceCreate
+from letta.schemas.tool_execution_result import ToolExecutionResult
 from letta.schemas.usage import LettaUsageStatistics
 from letta.schemas.user import User
 from letta.server.rest_api.utils import create_letta_messages_from_llm_response
@@ -119,7 +116,7 @@ class LettaAgent(BaseAgent):
     async def step(
         self,
         input_messages: List[MessageCreate],
-        max_steps: int = 10,
+        max_steps: int = DEFAULT_MAX_STEPS,
         use_assistant_message: bool = True,
         request_start_timestamp_ns: Optional[int] = None,
         include_return_message_types: Optional[List[MessageType]] = None,
@@ -144,7 +141,7 @@ class LettaAgent(BaseAgent):
     async def step_stream_no_tokens(
         self,
         input_messages: List[MessageCreate],
-        max_steps: int = 10,
+        max_steps: int = DEFAULT_MAX_STEPS,
         use_assistant_message: bool = True,
         request_start_timestamp_ns: Optional[int] = None,
         include_return_message_types: Optional[List[MessageType]] = None,
@@ -152,9 +149,10 @@ class LettaAgent(BaseAgent):
         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
         )
-        current_in_context_messages, new_in_context_messages = await _prepare_in_context_messages_async(
+        current_in_context_messages, new_in_context_messages = await _prepare_in_context_messages_no_persist_async(
             input_messages, agent_state, self.message_manager, self.actor
         )
+        initial_messages = new_in_context_messages
         tool_rules_solver = ToolRulesSolver(agent_state.tool_rules)
         llm_client = LLMClient.create(
             provider_type=agent_state.llm_config.model_endpoint_type,
@@ -167,18 +165,20 @@ class LettaAgent(BaseAgent):
         request_span = tracer.start_span("time_to_first_token", start_time=request_start_timestamp_ns)
         request_span.set_attributes({f"llm_config.{k}": v for k, v in agent_state.llm_config.model_dump().items() if v is not None})
 
-        for _ in range(max_steps):
+        for i in range(max_steps):
             step_id = generate_step_id()
             step_start = get_utc_timestamp_ns()
             agent_step_span = tracer.start_span("agent_step", start_time=step_start)
             agent_step_span.set_attributes({"step_id": step_id})
 
-            request_data, response_data, current_in_context_messages, new_in_context_messages = await self._build_and_request_from_llm(
-                current_in_context_messages,
-                new_in_context_messages,
-                agent_state,
-                llm_client,
-                tool_rules_solver,
+            request_data, response_data, current_in_context_messages, new_in_context_messages, valid_tool_names = (
+                await self._build_and_request_from_llm(
+                    current_in_context_messages,
+                    new_in_context_messages,
+                    agent_state,
+                    llm_client,
+                    tool_rules_solver,
+                )
             )
             in_context_messages = current_in_context_messages + new_in_context_messages
 
@@ -223,14 +223,18 @@ class LettaAgent(BaseAgent):
 
             persisted_messages, should_continue = await self._handle_ai_response(
                 tool_call,
+                valid_tool_names,
                 agent_state,
                 tool_rules_solver,
                 response.usage,
                 reasoning_content=reasoning,
+                initial_messages=initial_messages,
                 agent_step_span=agent_step_span,
+                is_final_step=(i == max_steps - 1),
             )
             self.response_messages.extend(persisted_messages)
             new_in_context_messages.extend(persisted_messages)
+            initial_messages = None
             log_event("agent.stream_no_tokens.llm_response.processed")  # [4^]
 
             # log step time
@@ -291,7 +295,7 @@ class LettaAgent(BaseAgent):
         self,
         agent_state: AgentState,
         input_messages: List[MessageCreate],
-        max_steps: int = 10,
+        max_steps: int = DEFAULT_MAX_STEPS,
         request_start_timestamp_ns: Optional[int] = None,
     ) -> Tuple[List[Message], List[Message], LettaUsageStatistics]:
         """
@@ -301,9 +305,10 @@ class LettaAgent(BaseAgent):
             3. Fetches a response from the LLM
             4. Processes the response
         """
-        current_in_context_messages, new_in_context_messages = await _prepare_in_context_messages_async(
+        current_in_context_messages, new_in_context_messages = await _prepare_in_context_messages_no_persist_async(
             input_messages, agent_state, self.message_manager, self.actor
         )
+        initial_messages = new_in_context_messages
         tool_rules_solver = ToolRulesSolver(agent_state.tool_rules)
         llm_client = LLMClient.create(
             provider_type=agent_state.llm_config.model_endpoint_type,
@@ -316,14 +321,16 @@ class LettaAgent(BaseAgent):
         request_span.set_attributes({f"llm_config.{k}": v for k, v in agent_state.llm_config.model_dump().items() if v is not None})
 
         usage = LettaUsageStatistics()
-        for _ in range(max_steps):
+        for i in range(max_steps):
             step_id = generate_step_id()
             step_start = get_utc_timestamp_ns()
             agent_step_span = tracer.start_span("agent_step", start_time=step_start)
             agent_step_span.set_attributes({"step_id": step_id})
 
-            request_data, response_data, current_in_context_messages, new_in_context_messages = await self._build_and_request_from_llm(
-                current_in_context_messages, new_in_context_messages, agent_state, llm_client, tool_rules_solver
+            request_data, response_data, current_in_context_messages, new_in_context_messages, valid_tool_names = (
+                await self._build_and_request_from_llm(
+                    current_in_context_messages, new_in_context_messages, agent_state, llm_client, tool_rules_solver
+                )
             )
             in_context_messages = current_in_context_messages + new_in_context_messages
 
@@ -362,15 +369,19 @@ class LettaAgent(BaseAgent):
 
             persisted_messages, should_continue = await self._handle_ai_response(
                 tool_call,
+                valid_tool_names,
                 agent_state,
                 tool_rules_solver,
                 response.usage,
                 reasoning_content=reasoning,
                 step_id=step_id,
+                initial_messages=initial_messages,
                 agent_step_span=agent_step_span,
+                is_final_step=(i == max_steps - 1),
             )
             self.response_messages.extend(persisted_messages)
             new_in_context_messages.extend(persisted_messages)
+            initial_messages = None
             log_event("agent.step.llm_response.processed")  # [4^]
 
             # log step time
@@ -416,7 +427,7 @@ class LettaAgent(BaseAgent):
     async def step_stream(
         self,
         input_messages: List[MessageCreate],
-        max_steps: int = 10,
+        max_steps: int = DEFAULT_MAX_STEPS,
         use_assistant_message: bool = True,
         request_start_timestamp_ns: Optional[int] = None,
         include_return_message_types: Optional[List[MessageType]] = None,
@@ -435,10 +446,6 @@ class LettaAgent(BaseAgent):
         current_in_context_messages, new_in_context_messages = await _prepare_in_context_messages_no_persist_async(
             input_messages, agent_state, self.message_manager, self.actor
         )
-
-        # Special strategy to lower TTFT
-        # Delay persistence of the initial input message as much as possible
-        persisted_input_messages = False
         initial_messages = new_in_context_messages
 
         tool_rules_solver = ToolRulesSolver(agent_state.tool_rules)
@@ -454,21 +461,23 @@ class LettaAgent(BaseAgent):
             request_span.set_attributes({f"llm_config.{k}": v for k, v in agent_state.llm_config.model_dump().items() if v is not None})
 
         provider_request_start_timestamp_ns = None
-        for _ in range(max_steps):
+        for i in range(max_steps):
             step_id = generate_step_id()
             step_start = get_utc_timestamp_ns()
             agent_step_span = tracer.start_span("agent_step", start_time=step_start)
             agent_step_span.set_attributes({"step_id": step_id})
 
-            request_data, stream, current_in_context_messages, new_in_context_messages = await self._build_and_request_from_llm_streaming(
-                first_chunk,
-                agent_step_span,
-                request_start_timestamp_ns,
-                current_in_context_messages,
-                new_in_context_messages,
-                agent_state,
-                llm_client,
-                tool_rules_solver,
+            request_data, stream, current_in_context_messages, new_in_context_messages, valid_tool_names = (
+                await self._build_and_request_from_llm_streaming(
+                    first_chunk,
+                    agent_step_span,
+                    request_start_timestamp_ns,
+                    current_in_context_messages,
+                    new_in_context_messages,
+                    agent_state,
+                    llm_client,
+                    tool_rules_solver,
+                )
             )
             log_event("agent.stream.llm_response.received")  # [3^]
 
@@ -513,12 +522,6 @@ class LettaAgent(BaseAgent):
                 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
-            if not persisted_input_messages:
-                await self.message_manager.create_many_messages_async(initial_messages, actor=self.actor)
-                persisted_input_messages = True
-
             # log LLM request time
             now = get_utc_timestamp_ns()
             llm_request_ns = now - step_start
@@ -529,6 +532,7 @@ class LettaAgent(BaseAgent):
             reasoning_content = interface.get_reasoning_content()
             persisted_messages, should_continue = await self._handle_ai_response(
                 tool_call,
+                valid_tool_names,
                 agent_state,
                 tool_rules_solver,
                 UsageStatistics(
@@ -539,10 +543,13 @@ class LettaAgent(BaseAgent):
                 reasoning_content=reasoning_content,
                 pre_computed_assistant_message_id=interface.letta_message_id,
                 step_id=step_id,
+                initial_messages=initial_messages,
                 agent_step_span=agent_step_span,
+                is_final_step=(i == max_steps - 1),
             )
             self.response_messages.extend(persisted_messages)
             new_in_context_messages.extend(persisted_messages)
+            initial_messages = None
 
             # log total step time
             now = get_utc_timestamp_ns()
@@ -614,12 +621,12 @@ class LettaAgent(BaseAgent):
         agent_state: AgentState,
         llm_client: LLMClientBase,
         tool_rules_solver: ToolRulesSolver,
-    ) -> Tuple[Dict, Dict, List[Message], List[Message]]:
+    ) -> Tuple[Dict, Dict, List[Message], List[Message], List[str]]:
         for attempt in range(self.max_summarization_retries + 1):
             try:
                 log_event("agent.stream_no_tokens.messages.refreshed")
                 # Create LLM request data
-                request_data = await self._create_llm_request_data_async(
+                request_data, valid_tool_names = await self._create_llm_request_data_async(
                     llm_client=llm_client,
                     in_context_messages=current_in_context_messages + new_in_context_messages,
                     agent_state=agent_state,
@@ -634,12 +641,7 @@ class LettaAgent(BaseAgent):
                     dict(get_ctx_attributes(), **{"model.name": agent_state.llm_config.model}),
                 )
                 # Attempt LLM request
-                return (
-                    request_data,
-                    response,
-                    current_in_context_messages,
-                    new_in_context_messages,
-                )
+                return (request_data, response, current_in_context_messages, new_in_context_messages, valid_tool_names)
 
             except Exception as e:
                 if attempt == self.max_summarization_retries:
@@ -667,12 +669,12 @@ class LettaAgent(BaseAgent):
         agent_state: AgentState,
         llm_client: LLMClientBase,
         tool_rules_solver: ToolRulesSolver,
-    ) -> Tuple[Dict, AsyncStream[ChatCompletionChunk], List[Message], List[Message]]:
+    ) -> Tuple[Dict, AsyncStream[ChatCompletionChunk], List[Message], List[Message], List[str]]:
         for attempt in range(self.max_summarization_retries + 1):
             try:
                 log_event("agent.stream_no_tokens.messages.refreshed")
                 # Create LLM request data
-                request_data = await self._create_llm_request_data_async(
+                request_data, valid_tool_names = await self._create_llm_request_data_async(
                     llm_client=llm_client,
                     in_context_messages=current_in_context_messages + new_in_context_messages,
                     agent_state=agent_state,
@@ -691,6 +693,7 @@ class LettaAgent(BaseAgent):
                     await llm_client.stream_async(request_data, agent_state.llm_config),
                     current_in_context_messages,
                     new_in_context_messages,
+                    valid_tool_names,
                 )
 
             except Exception as e:
@@ -773,7 +776,7 @@ class LettaAgent(BaseAgent):
         in_context_messages: List[Message],
         agent_state: AgentState,
         tool_rules_solver: ToolRulesSolver,
-    ) -> dict:
+    ) -> Tuple[dict, List[str]]:
         self.num_messages, self.num_archival_memories = await asyncio.gather(
             (
                 self.message_manager.size_async(actor=self.actor, agent_id=agent_state.id)
@@ -787,7 +790,11 @@ class LettaAgent(BaseAgent):
             ),
         )
         in_context_messages = await self._rebuild_memory_async(
-            in_context_messages, agent_state, num_messages=self.num_messages, num_archival_memories=self.num_archival_memories
+            in_context_messages,
+            agent_state,
+            num_messages=self.num_messages,
+            num_archival_memories=self.num_archival_memories,
+            tool_rules_solver=tool_rules_solver,
         )
 
         tools = [
@@ -809,8 +816,7 @@ class LettaAgent(BaseAgent):
         ]
 
         # Mirror the sync agent loop: get allowed tools or allow all if none are allowed
-        if self.last_function_response is None:
-            self.last_function_response = self._load_last_function_response(in_context_messages)
+        self.last_function_response = self._load_last_function_response(in_context_messages)
         valid_tool_names = tool_rules_solver.get_allowed_tool_names(
             available_tools=set([t.name for t in tools]),
             last_function_response=self.last_function_response,
@@ -827,28 +833,40 @@ class LettaAgent(BaseAgent):
             tool_list=allowed_tools, response_format=agent_state.response_format, request_heartbeat=True
         )
 
-        return llm_client.build_request_data(in_context_messages, agent_state.llm_config, allowed_tools, force_tool_call)
+        return (
+            llm_client.build_request_data(
+                in_context_messages,
+                agent_state.llm_config,
+                allowed_tools,
+                force_tool_call,
+            ),
+            valid_tool_names,
+        )
 
     @trace_method
     async def _handle_ai_response(
         self,
         tool_call: ToolCall,
+        valid_tool_names: List[str],
         agent_state: AgentState,
         tool_rules_solver: ToolRulesSolver,
         usage: UsageStatistics,
         reasoning_content: Optional[List[Union[TextContent, ReasoningContent, RedactedReasoningContent, OmittedReasoningContent]]] = None,
         pre_computed_assistant_message_id: Optional[str] = None,
         step_id: str | None = None,
-        new_in_context_messages: Optional[List[Message]] = None,
+        initial_messages: Optional[List[Message]] = None,
         agent_step_span: Optional["Span"] = None,
+        is_final_step: Optional[bool] = None,
     ) -> Tuple[List[Message], bool]:
         """
         Now that streaming is done, handle the final AI response.
         This might yield additional SSE tokens if we do stalling.
         At the end, set self._continue_execution accordingly.
         """
+        # Check if the called tool is allowed by tool name:
         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] + "}"
@@ -861,17 +879,21 @@ class LettaAgent(BaseAgent):
         except AssertionError:
             tool_args = json.loads(tool_args)
 
-        # Get request heartbeats and coerce to bool
-        request_heartbeat = tool_args.pop("request_heartbeat", False)
-        # Pre-emptively pop out inner_thoughts
-        tool_args.pop(INNER_THOUGHTS_KWARG, "")
-
-        # So this is necessary, because sometimes non-structured outputs makes mistakes
-        if not isinstance(request_heartbeat, bool):
-            if isinstance(request_heartbeat, str):
-                request_heartbeat = request_heartbeat.lower() == "true"
-            else:
-                request_heartbeat = bool(request_heartbeat)
+        if is_final_step:
+            logger.info("Agent has reached max steps.")
+            request_heartbeat = False
+        else:
+            # Get request heartbeats and coerce to bool
+            request_heartbeat = tool_args.pop("request_heartbeat", False)
+            # Pre-emptively pop out inner_thoughts
+            tool_args.pop(INNER_THOUGHTS_KWARG, "")
+
+            # So this is necessary, because sometimes non-structured outputs makes mistakes
+            if not isinstance(request_heartbeat, bool):
+                if isinstance(request_heartbeat, str):
+                    request_heartbeat = request_heartbeat.lower() == "true"
+                else:
+                    request_heartbeat = bool(request_heartbeat)
 
         tool_call_id = tool_call.id or f"call_{uuid.uuid4().hex[:8]}"
 
@@ -883,14 +905,21 @@ class LettaAgent(BaseAgent):
             tool_call_id=tool_call_id,
             request_heartbeat=request_heartbeat,
         )
-
-        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,
-        )
+        if tool_call_name not in valid_tool_names:
+            base_error_message = f"[ToolConstraintError] Cannot call {tool_call_name}, valid tools to call include: {valid_tool_names}."
+            violated_rule_messages = tool_rules_solver.guess_rule_violation(tool_call_name)
+            if violated_rule_messages:
+                bullet_points = "\n".join(f"\t- {msg}" for msg in violated_rule_messages)
+                base_error_message += f"\n** Hint: Possible rules that were violated:\n{bullet_points}"
+            tool_execution_result = ToolExecutionResult(status="error", func_return=base_error_message)
+        else:
+            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,
+            )
         log_telemetry(
             self.logger, "_handle_ai_response execute tool finish", tool_execution_result=tool_execution_result, tool_call_id=tool_call_id
         )
@@ -960,7 +989,9 @@ class LettaAgent(BaseAgent):
             step_id=logged_step.id if logged_step else None,  # TODO (cliandy): eventually move over other agent loops
         )
 
-        persisted_messages = await self.message_manager.create_many_messages_async(tool_call_messages, actor=self.actor)
+        persisted_messages = await self.message_manager.create_many_messages_async(
+            (initial_messages or []) + tool_call_messages, actor=self.actor
+        )
         self.last_function_response = function_response
 
         return persisted_messages, continue_stepping

letta/agents/letta_agent_batch.py

@@ -8,6 +8,7 @@ from anthropic.types.beta.messages import BetaMessageBatchCanceledResult, BetaMe
 
 from letta.agents.base_agent import BaseAgent
 from letta.agents.helpers import _prepare_in_context_messages_async
+from letta.constants import DEFAULT_MAX_STEPS
 from letta.helpers import ToolRulesSolver
 from letta.helpers.datetime_helpers import get_utc_time
 from letta.helpers.tool_execution_helper import enable_strict_mode
@@ -110,7 +111,7 @@ class LettaAgentBatch(BaseAgent):
         sandbox_config_manager: SandboxConfigManager,
         job_manager: JobManager,
         actor: User,
-        max_steps: int = 10,
+        max_steps: int = DEFAULT_MAX_STEPS,
     ):
         self.message_manager = message_manager
         self.agent_manager = agent_manager
@@ -619,10 +620,10 @@ class LettaAgentBatch(BaseAgent):
         return in_context_messages
 
     # Not used in batch.
-    async def step(self, input_messages: List[MessageCreate], max_steps: int = 10) -> LettaResponse:
+    async def step(self, input_messages: List[MessageCreate], max_steps: int = DEFAULT_MAX_STEPS) -> LettaResponse:
         raise NotImplementedError
 
     async def step_stream(
-        self, input_messages: List[MessageCreate], max_steps: int = 10
+        self, input_messages: List[MessageCreate], max_steps: int = DEFAULT_MAX_STEPS
     ) -> AsyncGenerator[Union[LettaMessage, LegacyLettaMessage, MessageStreamStatus], None]:
         raise NotImplementedError

letta/agents/voice_agent.py

@@ -9,7 +9,7 @@ import openai
 from letta.agents.base_agent import BaseAgent
 from letta.agents.exceptions import IncompatibleAgentType
 from letta.agents.voice_sleeptime_agent import VoiceSleeptimeAgent
-from letta.constants import NON_USER_MSG_PREFIX
+from letta.constants import DEFAULT_MAX_STEPS, NON_USER_MSG_PREFIX
 from letta.helpers.datetime_helpers import get_utc_time
 from letta.helpers.tool_execution_helper import (
     add_pre_execution_message,
@@ -111,10 +111,10 @@ class VoiceAgent(BaseAgent):
 
         return summarizer
 
-    async def step(self, input_messages: List[MessageCreate], max_steps: int = 10) -> LettaResponse:
+    async def step(self, input_messages: List[MessageCreate], max_steps: int = DEFAULT_MAX_STEPS) -> LettaResponse:
         raise NotImplementedError("VoiceAgent does not have a synchronous step implemented currently.")
 
-    async def step_stream(self, input_messages: List[MessageCreate], max_steps: int = 10) -> AsyncGenerator[str, None]:
+    async def step_stream(self, input_messages: List[MessageCreate], max_steps: int = DEFAULT_MAX_STEPS) -> AsyncGenerator[str, None]:
         """
         Main streaming loop that yields partial tokens.
         Whenever we detect a tool call, we yield from _handle_ai_response as well.

letta/agents/voice_sleeptime_agent.py

@@ -2,6 +2,7 @@ from typing import AsyncGenerator, List, Optional, Tuple, Union
 
 from letta.agents.helpers import _create_letta_response, serialize_message_history
 from letta.agents.letta_agent import LettaAgent
+from letta.constants import DEFAULT_MAX_STEPS
 from letta.orm.enums import ToolType
 from letta.otel.tracing import trace_method
 from letta.schemas.agent import AgentState
@@ -62,7 +63,7 @@ class VoiceSleeptimeAgent(LettaAgent):
     async def step(
         self,
         input_messages: List[MessageCreate],
-        max_steps: int = 20,
+        max_steps: int = DEFAULT_MAX_STEPS,
         use_assistant_message: bool = True,
         include_return_message_types: Optional[List[MessageType]] = None,
     ) -> LettaResponse:
@@ -170,7 +171,7 @@ class VoiceSleeptimeAgent(LettaAgent):
             return f"Failed to store memory given start_index {start_index} and end_index {end_index}: {e}", False
 
     async def step_stream(
-        self, input_messages: List[MessageCreate], max_steps: int = 10, use_assistant_message: bool = True
+        self, input_messages: List[MessageCreate], max_steps: int = DEFAULT_MAX_STEPS, use_assistant_message: bool = True
     ) -> AsyncGenerator[Union[LettaMessage, LegacyLettaMessage, MessageStreamStatus], None]:
         """
         This agent is synchronous-only. If called in an async context, raise an error.