letta-nightly 0.8.5.dev20250625104328__py3-none-any.whl → 0.8.6.dev20250625222533__py3-none-any.whl

letta/agents/letta_agent_batch.py

@@ -18,14 +18,14 @@ from letta.local_llm.constants import INNER_THOUGHTS_KWARG
 from letta.log import get_logger
 from letta.orm.enums import ToolType
 from letta.otel.tracing import log_event, trace_method
-from letta.schemas.agent import AgentState, AgentStepState
+from letta.schemas.agent import AgentState
 from letta.schemas.enums import AgentStepStatus, JobStatus, MessageStreamStatus, ProviderType
 from letta.schemas.job import JobUpdate
 from letta.schemas.letta_message import LegacyLettaMessage, LettaMessage
 from letta.schemas.letta_message_content import OmittedReasoningContent, ReasoningContent, RedactedReasoningContent, TextContent
 from letta.schemas.letta_request import LettaBatchRequest
 from letta.schemas.letta_response import LettaBatchResponse, LettaResponse
-from letta.schemas.llm_batch_job import LLMBatchItem
+from letta.schemas.llm_batch_job import AgentStepState, LLMBatchItem
 from letta.schemas.message import Message, MessageCreate
 from letta.schemas.openai.chat_completion_response import ToolCall as OpenAIToolCall
 from letta.schemas.sandbox_config import SandboxConfig, SandboxType
@@ -548,8 +548,9 @@ class LettaAgentBatch(BaseAgent):
             function_call_success=success_flag,
             function_response=tool_exec_result,
             tool_execution_result=tool_exec_result_obj,
+            timezone=agent_state.timezone,
             actor=self.actor,
-            add_heartbeat_request_system_message=False,
+            continue_stepping=False,
             reasoning_content=reasoning_content,
             pre_computed_assistant_message_id=None,
             llm_batch_item_id=llm_batch_item_id,

letta/agents/voice_agent.py

@@ -38,6 +38,7 @@ from letta.server.rest_api.utils import (
 from letta.services.agent_manager import AgentManager
 from letta.services.block_manager import BlockManager
 from letta.services.helpers.agent_manager_helper import compile_system_message
+from letta.services.job_manager import JobManager
 from letta.services.message_manager import MessageManager
 from letta.services.passage_manager import PassageManager
 from letta.services.summarizer.enums import SummarizationMode
@@ -64,6 +65,7 @@ class VoiceAgent(BaseAgent):
         message_manager: MessageManager,
         agent_manager: AgentManager,
         block_manager: BlockManager,
+        job_manager: JobManager,
         passage_manager: PassageManager,
         actor: User,
     ):
@@ -73,6 +75,7 @@ class VoiceAgent(BaseAgent):
 
         # Summarizer settings
         self.block_manager = block_manager
+        self.job_manager = job_manager
         self.passage_manager = passage_manager
         # TODO: This is not guaranteed to exist!
         self.summary_block_label = "human"
@@ -98,6 +101,7 @@ class VoiceAgent(BaseAgent):
                 agent_manager=self.agent_manager,
                 actor=self.actor,
                 block_manager=self.block_manager,
+                job_manager=self.job_manager,
                 passage_manager=self.passage_manager,
                 target_block_label=self.summary_block_label,
             ),
@@ -146,10 +150,13 @@ class VoiceAgent(BaseAgent):
             system_prompt=agent_state.system,
             in_context_memory=agent_state.memory,
             in_context_memory_last_edit=memory_edit_timestamp,
+            timezone=agent_state.timezone,
             previous_message_count=self.num_messages,
             archival_memory_size=self.num_archival_memories,
         )
-        letta_message_db_queue = create_input_messages(input_messages=input_messages, agent_id=agent_state.id, actor=self.actor)
+        letta_message_db_queue = create_input_messages(
+            input_messages=input_messages, agent_id=agent_state.id, timezone=agent_state.timezone, actor=self.actor
+        )
         in_memory_message_history = self.pre_process_input_message(input_messages)
 
         # TODO: Define max steps here
@@ -208,6 +215,7 @@ class VoiceAgent(BaseAgent):
                 agent_id=agent_state.id,
                 model=agent_state.llm_config.model,
                 actor=self.actor,
+                timezone=agent_state.timezone,
             )
             letta_message_db_queue.extend(assistant_msgs)
 
@@ -268,8 +276,9 @@ class VoiceAgent(BaseAgent):
                 function_call_success=success_flag,
                 function_response=tool_result,
                 tool_execution_result=tool_execution_result,
+                timezone=agent_state.timezone,
                 actor=self.actor,
-                add_heartbeat_request_system_message=True,
+                continue_stepping=True,
             )
             letta_message_db_queue.extend(tool_call_messages)
 
@@ -439,6 +448,7 @@ class VoiceAgent(BaseAgent):
             message_manager=self.message_manager,
             agent_manager=self.agent_manager,
             block_manager=self.block_manager,
+            job_manager=self.job_manager,
             passage_manager=self.passage_manager,
             sandbox_env_vars=sandbox_env_vars,
             actor=self.actor,

letta/agents/voice_sleeptime_agent.py

@@ -15,6 +15,7 @@ from letta.schemas.tool_rule import ChildToolRule, ContinueToolRule, InitToolRul
 from letta.schemas.user import User
 from letta.services.agent_manager import AgentManager
 from letta.services.block_manager import BlockManager
+from letta.services.job_manager import JobManager
 from letta.services.message_manager import MessageManager
 from letta.services.passage_manager import PassageManager
 from letta.services.summarizer.enums import SummarizationMode
@@ -34,6 +35,7 @@ class VoiceSleeptimeAgent(LettaAgent):
         message_manager: MessageManager,
         agent_manager: AgentManager,
         block_manager: BlockManager,
+        job_manager: JobManager,
         passage_manager: PassageManager,
         target_block_label: str,
         actor: User,
@@ -43,6 +45,7 @@ class VoiceSleeptimeAgent(LettaAgent):
             message_manager=message_manager,
             agent_manager=agent_manager,
             block_manager=block_manager,
+            job_manager=job_manager,
             passage_manager=passage_manager,
             actor=actor,
         )
@@ -64,7 +67,9 @@ class VoiceSleeptimeAgent(LettaAgent):
         self,
         input_messages: List[MessageCreate],
         max_steps: int = DEFAULT_MAX_STEPS,
+        run_id: Optional[str] = None,
         use_assistant_message: bool = True,
+        request_start_timestamp_ns: Optional[int] = None,
         include_return_message_types: Optional[List[MessageType]] = None,
     ) -> LettaResponse:
         """
@@ -82,7 +87,7 @@ class VoiceSleeptimeAgent(LettaAgent):
         ]
 
         # Summarize
-        current_in_context_messages, new_in_context_messages, usage, stop_reason = await super()._step(
+        current_in_context_messages, new_in_context_messages, stop_reason, usage = await super()._step(
             agent_state=agent_state, input_messages=input_messages, max_steps=max_steps
         )
         new_in_context_messages, updated = self.summarizer.summarize(
@@ -172,7 +177,12 @@ 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 = DEFAULT_MAX_STEPS, use_assistant_message: bool = True
+        self,
+        input_messages: List[MessageCreate],
+        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,
     ) -> AsyncGenerator[Union[LettaMessage, LegacyLettaMessage, MessageStreamStatus], None]:
         """
         This agent is synchronous-only. If called in an async context, raise an error.

letta/constants.py

@@ -6,6 +6,7 @@ LETTA_DIR = os.path.join(os.path.expanduser("~"), ".letta")
 LETTA_TOOL_EXECUTION_DIR = os.path.join(LETTA_DIR, "tool_execution_dir")
 
 LETTA_MODEL_ENDPOINT = "https://inference.letta.com"
+DEFAULT_TIMEZONE = "UTC"
 
 ADMIN_PREFIX = "/v1/admin"
 API_PREFIX = "/v1"
@@ -113,7 +114,7 @@ BASE_VOICE_SLEEPTIME_TOOLS = [
     "finish_rethinking_memory",
 ]
 # Multi agent tools
-MULTI_AGENT_TOOLS = ["send_message_to_agent_and_wait_for_reply", "send_message_to_agents_matching_tags", "send_message_to_agent_async"]
+MULTI_AGENT_TOOLS = ["send_message_to_agent_and_wait_for_reply", "send_message_to_agents_matching_tags"]
 
 # Used to catch if line numbers are pushed in
 # MEMORY_TOOLS_LINE_NUMBER_PREFIX_REGEX = re.compile(r"^Line \d+: ", re.MULTILINE)
@@ -130,6 +131,11 @@ BUILTIN_TOOLS = ["run_code", "web_search"]
 # Built in tools
 FILES_TOOLS = ["open_file", "close_file", "grep", "search_files"]
 
+FILE_MEMORY_EXISTS_MESSAGE = "The following files are currently accessible in memory:"
+FILE_MEMORY_EMPTY_MESSAGE = (
+    "There are no files currently available in memory. Files will appear here once they are uploaded directly to your system."
+)
+
 # Set of all built-in Letta tools
 LETTA_TOOL_SET = set(
     BASE_TOOLS
@@ -192,10 +198,21 @@ CORE_MEMORY_LINE_NUMBER_WARNING = (
 # Constants to do with summarization / conversation length window
 # The max amount of tokens supported by the underlying model (eg 8k for gpt-4 and Mistral 7B)
 LLM_MAX_TOKENS = {
-    "DEFAULT": 8192,
+    "DEFAULT": 30000,
+    # deepseek
     "deepseek-chat": 64000,
     "deepseek-reasoner": 64000,
     ## OpenAI models: https://platform.openai.com/docs/models/overview
+    # reasoners
+    "o1": 200000,
+    # "o1-pro": 200000,  # responses API only
+    "o1-2024-12-17": 200000,
+    "o3": 200000,
+    "o3-2025-04-16": 200000,
+    "o3-mini": 200000,
+    "o3-mini-2025-01-31": 200000,
+    # "o3-pro": 200000,  # responses API only
+    # "o3-pro-2025-06-10": 200000,
     "gpt-4.1": 1047576,
     "gpt-4.1-2025-04-14": 1047576,
     "gpt-4.1-mini": 1047576,
@@ -209,6 +226,7 @@ LLM_MAX_TOKENS = {
     "chatgpt-4o-latest": 128000,
     # "o1-preview-2024-09-12
     "gpt-4o-2024-08-06": 128000,
+    "gpt-4o-2024-11-20": 128000,
     "gpt-4-turbo-preview": 128000,
     "gpt-4o": 128000,
     "gpt-3.5-turbo-instruct": 16385,
@@ -218,7 +236,7 @@ LLM_MAX_TOKENS = {
     # "davinci-002": 128000,
     "gpt-4-turbo-2024-04-09": 128000,
     # "gpt-4o-realtime-preview-2024-10-01
-    "gpt-4-turbo": 8192,
+    "gpt-4-turbo": 128000,
     "gpt-4o-2024-05-13": 128000,
     # "o1-mini
     # "o1-mini-2024-09-12
@@ -338,3 +356,6 @@ REDIS_INCLUDE = "include"
 REDIS_EXCLUDE = "exclude"
 REDIS_SET_DEFAULT_VAL = "None"
 REDIS_DEFAULT_CACHE_PREFIX = "letta_cache"
+
+# TODO: This is temporary, eventually use token-based eviction
+MAX_FILES_OPEN = 5

letta/data_sources/redis_client.py

@@ -283,6 +283,12 @@ class NoopAsyncRedisClient(AsyncRedisClient):
     async def scard(self, key: str) -> int:
         return 0
 
+    async def smembers(self, key: str) -> Set[str]:
+        return set()
+
+    async def srem(self, key: str, *members: Union[str, int, float]) -> int:
+        return 0
+
 
 async def get_redis_client() -> AsyncRedisClient:
     global _client_instance

letta/errors.py

@@ -17,6 +17,7 @@ class ErrorCode(Enum):
     INTERNAL_SERVER_ERROR = "INTERNAL_SERVER_ERROR"
     CONTEXT_WINDOW_EXCEEDED = "CONTEXT_WINDOW_EXCEEDED"
     RATE_LIMIT_EXCEEDED = "RATE_LIMIT_EXCEEDED"
+    TIMEOUT = "TIMEOUT"
 
 
 class LettaError(Exception):
@@ -101,6 +102,10 @@ class LLMServerError(LLMError):
     while processing the request."""
 
 
+class LLMTimeoutError(LLMError):
+    """Error when LLM request times out"""
+
+
 class BedrockPermissionError(LettaError):
     """Exception raised for errors in the Bedrock permission process."""
 

letta/functions/function_sets/files.py

@@ -32,16 +32,23 @@ async def close_file(agent_state: "AgentState", file_name: str) -> str:
     raise NotImplementedError("Tool not implemented. Please contact the Letta team.")
 
 
-async def grep(agent_state: "AgentState", pattern: str, include: Optional[str] = None) -> str:
+async def grep(
+    agent_state: "AgentState",
+    pattern: str,
+    include: Optional[str] = None,
+    context_lines: Optional[int] = 3,
+) -> str:
     """
-    Grep tool to search files across data sources with a keyword or regex pattern.
+    Grep tool to search files across data sources using a keyword or regex pattern.
 
     Args:
         pattern (str): Keyword or regex pattern to search within file contents.
         include (Optional[str]): Optional keyword or regex pattern to filter filenames to include in the search.
+        context_lines (Optional[int]): Number of lines of context to show before and after each match.
+                                       Equivalent to `-C` in grep. Defaults to 3.
 
     Returns:
-        str: Matching lines or summary output.
+        str: Matching lines with optional surrounding context or a summary output.
     """
     raise NotImplementedError("Tool not implemented. Please contact the Letta team.")
 

letta/functions/function_sets/multi_agent.py

@@ -7,7 +7,6 @@ from letta.functions.helpers import (
     _send_message_to_all_agents_in_group_async,
     execute_send_message_to_agent,
     extract_send_message_from_steps_messages,
-    fire_and_forget_send_to_agent,
 )
 from letta.schemas.enums import MessageRole
 from letta.schemas.message import MessageCreate
@@ -44,37 +43,6 @@ def send_message_to_agent_and_wait_for_reply(self: "Agent", message: str, other_
     )
 
 
-def send_message_to_agent_async(self: "Agent", message: str, other_agent_id: str) -> str:
-    """
-    Sends a message to a specific Letta agent within the same organization. The sender's identity is automatically included, so no explicit introduction is required in the message. This function does not expect a response from the target agent, making it suitable for notifications or one-way communication.
-
-    Args:
-        message (str): The content of the message to be sent to the target agent.
-        other_agent_id (str): The unique identifier of the target Letta agent.
-
-    Returns:
-        str: A confirmation message indicating the message was successfully sent.
-    """
-    message = (
-        f"[Incoming message from agent with ID '{self.agent_state.id}' - to reply to this message, "
-        f"make sure to use the 'send_message_to_agent_async' tool, or the agent will not receive your message] "
-        f"{message}"
-    )
-    messages = [MessageCreate(role=MessageRole.system, content=message, name=self.agent_state.name)]
-
-    # Do the actual fire-and-forget
-    fire_and_forget_send_to_agent(
-        sender_agent=self,
-        messages=messages,
-        other_agent_id=other_agent_id,
-        log_prefix="[send_message_to_agent_async]",
-        use_retries=False,  # or True if you want to use _async_send_message_with_retries
-    )
-
-    # Immediately return to caller
-    return "Successfully sent message"
-
-
 def send_message_to_agents_matching_tags(self: "Agent", message: str, match_all: List[str], match_some: List[str]) -> List[str]:
     """
     Sends a message to all agents within the same organization that match the specified tag criteria. Agents must possess *all* of the tags in `match_all` and *at least one* of the tags in `match_some` to receive the message.

letta/groups/sleeptime_multi_agent_v2.py

@@ -63,6 +63,7 @@ class SleeptimeMultiAgentV2(BaseAgent):
         self,
         input_messages: List[MessageCreate],
         max_steps: int = DEFAULT_MAX_STEPS,
+        run_id: Optional[str] = None,
         use_assistant_message: bool = True,
         request_start_timestamp_ns: Optional[int] = None,
         include_return_message_types: Optional[List[MessageType]] = None,
@@ -83,6 +84,7 @@ class SleeptimeMultiAgentV2(BaseAgent):
             message_manager=self.message_manager,
             agent_manager=self.agent_manager,
             block_manager=self.block_manager,
+            job_manager=self.job_manager,
             passage_manager=self.passage_manager,
             actor=self.actor,
             step_manager=self.step_manager,
@@ -92,6 +94,7 @@ class SleeptimeMultiAgentV2(BaseAgent):
         response = await foreground_agent.step(
             input_messages=new_messages,
             max_steps=max_steps,
+            run_id=run_id,
             use_assistant_message=use_assistant_message,
             include_return_message_types=include_return_message_types,
         )
@@ -170,6 +173,7 @@ class SleeptimeMultiAgentV2(BaseAgent):
             message_manager=self.message_manager,
             agent_manager=self.agent_manager,
             block_manager=self.block_manager,
+            job_manager=self.job_manager,
             passage_manager=self.passage_manager,
             actor=self.actor,
             step_manager=self.step_manager,
@@ -283,6 +287,7 @@ class SleeptimeMultiAgentV2(BaseAgent):
                 message_manager=self.message_manager,
                 agent_manager=self.agent_manager,
                 block_manager=self.block_manager,
+                job_manager=self.job_manager,
                 passage_manager=self.passage_manager,
                 actor=self.actor,
                 step_manager=self.step_manager,
@@ -296,6 +301,7 @@ class SleeptimeMultiAgentV2(BaseAgent):
             result = await sleeptime_agent.step(
                 input_messages=sleeptime_agent_messages,
                 use_assistant_message=use_assistant_message,
+                run_id=run_id,
             )
 
             # Update job status

letta/helpers/converters.py

@@ -8,7 +8,6 @@ from openai.types.chat.chat_completion_message_tool_call import Function as Open
 from sqlalchemy import Dialect
 
 from letta.functions.mcp_client.types import StdioServerConfig
-from letta.schemas.agent import AgentStepState
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.enums import ProviderType, ToolRuleType
 from letta.schemas.letta_message_content import (
@@ -23,6 +22,7 @@ from letta.schemas.letta_message_content import (
     ToolCallContent,
     ToolReturnContent,
 )
+from letta.schemas.llm_batch_job import AgentStepState
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.message import ToolReturn
 from letta.schemas.response_format import (
@@ -39,6 +39,7 @@ from letta.schemas.tool_rule import (
     InitToolRule,
     MaxCountPerStepToolRule,
     ParentToolRule,
+    RequiredBeforeExitToolRule,
     TerminalToolRule,
     ToolRule,
 )
@@ -131,6 +132,8 @@ def deserialize_tool_rule(
         return MaxCountPerStepToolRule(**data)
     elif rule_type == ToolRuleType.parent_last_tool:
         return ParentToolRule(**data)
+    elif rule_type == ToolRuleType.required_before_exit:
+        return RequiredBeforeExitToolRule(**data)
     raise ValueError(f"Unknown ToolRule type: {rule_type}")
 
 

letta/helpers/datetime_helpers.py

@@ -2,11 +2,12 @@ import re
 import time
 from datetime import datetime, timedelta
 from datetime import timezone as dt_timezone
-from time import strftime
 from typing import Callable
 
 import pytz
 
+from letta.constants import DEFAULT_TIMEZONE
+
 
 def parse_formatted_time(formatted_time):
     # parse times returned by letta.utils.get_formatted_time()
@@ -18,33 +19,22 @@ def datetime_to_timestamp(dt):
     return int(dt.timestamp())
 
 
-def get_local_time_military():
-    # Get the current time in UTC
+def get_local_time_fast(timezone):
+    # Get current UTC time and convert to the specified timezone
+    if not timezone:
+        return datetime.now().strftime("%Y-%m-%d %I:%M:%S %p %Z%z")
     current_time_utc = datetime.now(pytz.utc)
-
-    # Convert to San Francisco's time zone (PST/PDT)
-    sf_time_zone = pytz.timezone("America/Los_Angeles")
-    local_time = current_time_utc.astimezone(sf_time_zone)
-
-    # You may format it as you desire
-    formatted_time = local_time.strftime("%Y-%m-%d %H:%M:%S %Z%z")
-
-    return formatted_time
-
-
-def get_local_time_fast():
-    formatted_time = strftime("%Y-%m-%d %I:%M:%S %p %Z%z")
+    local_time = current_time_utc.astimezone(pytz.timezone(timezone))
+    formatted_time = local_time.strftime("%Y-%m-%d %I:%M:%S %p %Z%z")
 
     return formatted_time
 
 
-def get_local_time_timezone(timezone="America/Los_Angeles"):
+def get_local_time_timezone(timezone=DEFAULT_TIMEZONE):
     # Get the current time in UTC
     current_time_utc = datetime.now(pytz.utc)
 
-    # Convert to San Francisco's time zone (PST/PDT)
-    sf_time_zone = pytz.timezone(timezone)
-    local_time = current_time_utc.astimezone(sf_time_zone)
+    local_time = current_time_utc.astimezone(pytz.timezone(timezone))
 
     # You may format it as you desire, including AM/PM
     formatted_time = local_time.strftime("%Y-%m-%d %I:%M:%S %p %Z%z")
@@ -52,7 +42,7 @@ def get_local_time_timezone(timezone="America/Los_Angeles"):
     return formatted_time
 
 
-def get_local_time(timezone=None):
+def get_local_time(timezone=DEFAULT_TIMEZONE):
     if timezone is not None:
         time_str = get_local_time_timezone(timezone)
     else:
@@ -89,8 +79,11 @@ def timestamp_to_datetime(timestamp_seconds: int) -> datetime:
     return datetime.fromtimestamp(timestamp_seconds, tz=dt_timezone.utc)
 
 
-def format_datetime(dt):
-    return dt.strftime("%Y-%m-%d %I:%M:%S %p %Z%z")
+def format_datetime(dt, timezone):
+    if not timezone:
+        # use local timezone
+        return dt.strftime("%Y-%m-%d %I:%M:%S %p %Z%z")
+    return dt.astimezone(pytz.timezone(timezone)).strftime("%Y-%m-%d %I:%M:%S %p %Z%z")
 
 
 def validate_date_format(date_str):

letta/helpers/message_helper.py

@@ -12,6 +12,7 @@ from letta.schemas.message import Message, MessageCreate
 def convert_message_creates_to_messages(
     message_creates: list[MessageCreate],
     agent_id: str,
+    timezone: str,
     wrap_user_message: bool = True,
     wrap_system_message: bool = True,
 ) -> list[Message]:
@@ -19,6 +20,7 @@ def convert_message_creates_to_messages(
         _convert_message_create_to_message(
             message_create=create,
             agent_id=agent_id,
+            timezone=timezone,
             wrap_user_message=wrap_user_message,
             wrap_system_message=wrap_system_message,
         )
@@ -29,6 +31,7 @@ def convert_message_creates_to_messages(
 def _convert_message_create_to_message(
     message_create: MessageCreate,
     agent_id: str,
+    timezone: str,
     wrap_user_message: bool = True,
     wrap_system_message: bool = True,
 ) -> Message:
@@ -50,9 +53,9 @@ def _convert_message_create_to_message(
         if isinstance(content, TextContent):
             # Apply wrapping if needed
             if message_create.role == MessageRole.user and wrap_user_message:
-                content.text = system.package_user_message(user_message=content.text)
+                content.text = system.package_user_message(user_message=content.text, timezone=timezone)
             elif message_create.role == MessageRole.system and wrap_system_message:
-                content.text = system.package_system_message(system_message=content.text)
+                content.text = system.package_system_message(system_message=content.text, timezone=timezone)
         elif isinstance(content, ImageContent):
             if content.source.type == ImageSourceType.url:
                 # Convert URL image to Base64Image if needed

letta/helpers/tool_rule_solver.py

@@ -12,6 +12,7 @@ from letta.schemas.tool_rule import (
     InitToolRule,
     MaxCountPerStepToolRule,
     ParentToolRule,
+    RequiredBeforeExitToolRule,
     TerminalToolRule,
 )
 
@@ -41,6 +42,9 @@ class ToolRulesSolver(BaseModel):
     terminal_tool_rules: List[TerminalToolRule] = Field(
         default_factory=list, description="Terminal tool rules that end the agent loop if called."
     )
+    required_before_exit_tool_rules: List[RequiredBeforeExitToolRule] = Field(
+        default_factory=list, description="Tool rules that must be called before the agent can exit."
+    )
     tool_call_history: List[str] = Field(default_factory=list, description="History of tool calls, updated with each tool call.")
 
     def __init__(
@@ -51,6 +55,7 @@ class ToolRulesSolver(BaseModel):
         child_based_tool_rules: Optional[List[Union[ChildToolRule, ConditionalToolRule, MaxCountPerStepToolRule]]] = None,
         parent_tool_rules: Optional[List[ParentToolRule]] = None,
         terminal_tool_rules: Optional[List[TerminalToolRule]] = None,
+        required_before_exit_tool_rules: Optional[List[RequiredBeforeExitToolRule]] = None,
         tool_call_history: Optional[List[str]] = None,
         **kwargs,
     ):
@@ -60,6 +65,7 @@ class ToolRulesSolver(BaseModel):
             child_based_tool_rules=child_based_tool_rules or [],
             parent_tool_rules=parent_tool_rules or [],
             terminal_tool_rules=terminal_tool_rules or [],
+            required_before_exit_tool_rules=required_before_exit_tool_rules or [],
             tool_call_history=tool_call_history or [],
             **kwargs,
         )
@@ -88,6 +94,9 @@ class ToolRulesSolver(BaseModel):
                 elif rule.type == ToolRuleType.parent_last_tool:
                     assert isinstance(rule, ParentToolRule)
                     self.parent_tool_rules.append(rule)
+                elif rule.type == ToolRuleType.required_before_exit:
+                    assert isinstance(rule, RequiredBeforeExitToolRule)
+                    self.required_before_exit_tool_rules.append(rule)
 
     def register_tool_call(self, tool_name: str):
         """Update the internal state to track tool call history."""
@@ -131,7 +140,7 @@ class ToolRulesSolver(BaseModel):
             return list(final_allowed_tools)
 
     def is_terminal_tool(self, tool_name: str) -> bool:
-        """Check if the tool is defined as a terminal tool in the terminal tool rules."""
+        """Check if the tool is defined as a terminal tool in the terminal tool rules or required-before-exit tool rules."""
         return any(rule.tool_name == tool_name for rule in self.terminal_tool_rules)
 
     def has_children_tools(self, tool_name):
@@ -142,6 +151,24 @@ class ToolRulesSolver(BaseModel):
         """Check if the tool is defined as a continue tool in the tool rules."""
         return any(rule.tool_name == tool_name for rule in self.continue_tool_rules)
 
+    def has_required_tools_been_called(self) -> bool:
+        """Check if all required-before-exit tools have been called."""
+        return len(self.get_uncalled_required_tools()) == 0
+
+    def get_uncalled_required_tools(self) -> List[str]:
+        """Get the list of required-before-exit tools that have not been called yet."""
+        if not self.required_before_exit_tool_rules:
+            return []  # No required tools means no uncalled tools
+
+        required_tool_names = {rule.tool_name for rule in self.required_before_exit_tool_rules}
+        called_tool_names = set(self.tool_call_history)
+
+        return list(required_tool_names - called_tool_names)
+
+    def get_ending_tool_names(self) -> List[str]:
+        """Get the names of tools that are required before exit."""
+        return [rule.tool_name for rule in self.required_before_exit_tool_rules]
+
     def compile_tool_rule_prompts(self) -> Optional[Block]:
         """
         Compile prompt templates from all tool rules into an ephemeral Block.
@@ -168,7 +195,7 @@ class ToolRulesSolver(BaseModel):
             return Block(
                 label="tool_usage_rules",
                 value="\n".join(compiled_prompts),
-                description="The following constraints define rules for tool usage and guide desired behavior. These rules must be followed to ensure proper tool execution and workflow.",
+                description="The 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.",
             )
         return None
 

letta/interfaces/openai_streaming_interface.py

@@ -6,11 +6,12 @@ from openai.types.chat.chat_completion_chunk import ChatCompletionChunk
 
 from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
 from letta.helpers.datetime_helpers import get_utc_timestamp_ns, ns_to_ms
+from letta.llm_api.openai_client import is_openai_reasoning_model
 from letta.log import get_logger
 from letta.otel.context import get_ctx_attributes
 from letta.otel.metric_registry import MetricRegistry
 from letta.schemas.letta_message import AssistantMessage, LettaMessage, ReasoningMessage, ToolCallDelta, ToolCallMessage
-from letta.schemas.letta_message_content import TextContent
+from letta.schemas.letta_message_content import OmittedReasoningContent, TextContent
 from letta.schemas.letta_stop_reason import LettaStopReason, StopReasonType
 from letta.schemas.message import Message
 from letta.schemas.openai.chat_completion_response import FunctionCall, ToolCall
@@ -61,7 +62,13 @@ class OpenAIStreamingInterface:
 
     def get_reasoning_content(self) -> List[TextContent]:
         content = "".join(self.reasoning_messages).strip()
-        return [TextContent(text=content)]
+
+        # Right now we assume that all models omit reasoning content for OAI,
+        # if this changes, we should return the reasoning content
+        if is_openai_reasoning_model(self.model):
+            return [OmittedReasoningContent()]
+        else:
+            return [TextContent(text=content)]
 
     def get_tool_call_object(self) -> ToolCall:
         """Useful for agent loop"""