chore: bump v0.11.5 (#2777)

Author: carenthomas

.github/workflows/send-message-integration-tests.yaml

@@ -41,6 +41,15 @@ jobs:
           --health-interval 10s
           --health-timeout 5s
           --health-retries 5
+      redis:
+        image: redis:7
+        ports:
+          - 6379:6379
+        options: >-
+          --health-cmd "redis-cli ping"
+          --health-interval 5s
+          --health-timeout 5s
+          --health-retries 10
 
     steps:
       # Ensure secrets don't leak
@@ -138,6 +147,8 @@ jobs:
           LETTA_PG_PASSWORD: postgres
           LETTA_PG_DB: postgres
           LETTA_PG_HOST: localhost
+          LETTA_REDIS_HOST: localhost
+          LETTA_REDIS_PORT: 6379
           LETTA_SERVER_PASS: test_server_token
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}

letta/__init__.py

@@ -5,7 +5,7 @@
     __version__ = version("letta")
 except PackageNotFoundError:
     # Fallback for development installations
-    __version__ = "0.11.4"
+    __version__ = "0.11.5"
 
 if os.environ.get("LETTA_VERSION"):
     __version__ = os.environ["LETTA_VERSION"]

letta/agent.py

@@ -42,6 +42,7 @@
 from letta.memory import summarize_messages
 from letta.orm import User
 from letta.otel.tracing import log_event, trace_method
+from letta.prompts.prompt_generator import PromptGenerator
 from letta.schemas.agent import AgentState, AgentStepResponse, UpdateAgent, get_prompt_template_for_agent_type
 from letta.schemas.block import BlockUpdate
 from letta.schemas.embedding_config import EmbeddingConfig
@@ -59,7 +60,7 @@
 from letta.schemas.usage import LettaUsageStatistics
 from letta.services.agent_manager import AgentManager
 from letta.services.block_manager import BlockManager
-from letta.services.helpers.agent_manager_helper import check_supports_structured_output, compile_memory_metadata_block
+from letta.services.helpers.agent_manager_helper import check_supports_structured_output
 from letta.services.helpers.tool_parser_helper import runtime_override_tool_json_schema
 from letta.services.job_manager import JobManager
 from letta.services.mcp.base_client import AsyncBaseMCPClient
@@ -330,8 +331,13 @@ def _get_ai_reply(
                 return None
 
         allowed_functions = [func for func in agent_state_tool_jsons if func["name"] in allowed_tool_names]
+        # Extract terminal tool names from tool rules
+        terminal_tool_names = {rule.tool_name for rule in self.tool_rules_solver.terminal_tool_rules}
         allowed_functions = runtime_override_tool_json_schema(
-            tool_list=allowed_functions, response_format=self.agent_state.response_format, request_heartbeat=True
+            tool_list=allowed_functions,
+            response_format=self.agent_state.response_format,
+            request_heartbeat=True,
+            terminal_tools=terminal_tool_names,
         )
 
         # For the first message, force the initial tool if one is specified
@@ -1246,7 +1252,7 @@ def get_context_window(self) -> ContextWindowOverview:
 
         agent_manager_passage_size = self.agent_manager.passage_size(actor=self.user, agent_id=self.agent_state.id)
         message_manager_size = self.message_manager.size(actor=self.user, agent_id=self.agent_state.id)
-        external_memory_summary = compile_memory_metadata_block(
+        external_memory_summary = PromptGenerator.compile_memory_metadata_block(
             memory_edit_timestamp=get_utc_time(),
             timezone=self.agent_state.timezone,
             previous_message_count=self.message_manager.size(actor=self.user, agent_id=self.agent_state.id),

letta/agents/base_agent.py

@@ -7,6 +7,7 @@
 from letta.helpers import ToolRulesSolver
 from letta.helpers.datetime_helpers import get_utc_time
 from letta.log import get_logger
+from letta.prompts.prompt_generator import PromptGenerator
 from letta.schemas.agent import AgentState
 from letta.schemas.enums import MessageStreamStatus
 from letta.schemas.letta_message import LegacyLettaMessage, LettaMessage
@@ -17,7 +18,6 @@
 from letta.schemas.usage import LettaUsageStatistics
 from letta.schemas.user import User
 from letta.services.agent_manager import AgentManager
-from letta.services.helpers.agent_manager_helper import get_system_message_from_compiled_memory
 from letta.services.message_manager import MessageManager
 from letta.services.passage_manager import PassageManager
 from letta.utils import united_diff
@@ -142,7 +142,7 @@ def extract_dynamic_section(text):
             if num_archival_memories is None:
                 num_archival_memories = await self.passage_manager.agent_passage_size_async(actor=self.actor, agent_id=agent_state.id)
 
-            new_system_message_str = get_system_message_from_compiled_memory(
+            new_system_message_str = PromptGenerator.get_system_message_from_compiled_memory(
                 system_prompt=agent_state.system,
                 memory_with_sources=curr_memory_str,
                 in_context_memory_last_edit=memory_edit_timestamp,

letta/agents/letta_agent.py

@@ -137,6 +137,10 @@ def __init__(
             message_buffer_limit=message_buffer_limit,
             message_buffer_min=message_buffer_min,
             partial_evict_summarizer_percentage=partial_evict_summarizer_percentage,
+            agent_manager=self.agent_manager,
+            message_manager=self.message_manager,
+            actor=self.actor,
+            agent_id=self.agent_id,
         )
 
     async def _check_run_cancellation(self) -> bool:
@@ -345,16 +349,17 @@ async def step_stream_no_tokens(
                 agent_step_span.end()
 
                 # Log LLM Trace
-                await self.telemetry_manager.create_provider_trace_async(
-                    actor=self.actor,
-                    provider_trace_create=ProviderTraceCreate(
-                        request_json=request_data,
-                        response_json=response_data,
-                        step_id=step_id,  # Use original step_id for telemetry
-                        organization_id=self.actor.organization_id,
-                    ),
-                )
-                step_progression = StepProgression.LOGGED_TRACE
+                if settings.track_provider_trace:
+                    await self.telemetry_manager.create_provider_trace_async(
+                        actor=self.actor,
+                        provider_trace_create=ProviderTraceCreate(
+                            request_json=request_data,
+                            response_json=response_data,
+                            step_id=step_id,  # Use original step_id for telemetry
+                            organization_id=self.actor.organization_id,
+                        ),
+                    )
+                    step_progression = StepProgression.LOGGED_TRACE
 
                 # stream step
                 # TODO: improve TTFT
@@ -642,17 +647,18 @@ async def _step(
                 agent_step_span.end()
 
                 # Log LLM Trace
-                await self.telemetry_manager.create_provider_trace_async(
-                    actor=self.actor,
-                    provider_trace_create=ProviderTraceCreate(
-                        request_json=request_data,
-                        response_json=response_data,
-                        step_id=step_id,  # Use original step_id for telemetry
-                        organization_id=self.actor.organization_id,
-                    ),
-                )
+                if settings.track_provider_trace:
+                    await self.telemetry_manager.create_provider_trace_async(
+                        actor=self.actor,
+                        provider_trace_create=ProviderTraceCreate(
+                            request_json=request_data,
+                            response_json=response_data,
+                            step_id=step_id,  # Use original step_id for telemetry
+                            organization_id=self.actor.organization_id,
+                        ),
+                    )
+                    step_progression = StepProgression.LOGGED_TRACE
 
-                step_progression = StepProgression.LOGGED_TRACE
                 MetricRegistry().step_execution_time_ms_histogram.record(get_utc_timestamp_ns() - step_start, get_ctx_attributes())
                 step_progression = StepProgression.FINISHED
 
@@ -1003,31 +1009,32 @@ async def step_stream(
                 # Log LLM Trace
                 # We are piecing together the streamed response here.
                 # Content here does not match the actual response schema as streams come in chunks.
-                await self.telemetry_manager.create_provider_trace_async(
-                    actor=self.actor,
-                    provider_trace_create=ProviderTraceCreate(
-                        request_json=request_data,
-                        response_json={
-                            "content": {
-                                "tool_call": tool_call.model_dump_json(),
-                                "reasoning": [content.model_dump_json() for content in reasoning_content],
+                if settings.track_provider_trace:
+                    await self.telemetry_manager.create_provider_trace_async(
+                        actor=self.actor,
+                        provider_trace_create=ProviderTraceCreate(
+                            request_json=request_data,
+                            response_json={
+                                "content": {
+                                    "tool_call": tool_call.model_dump_json(),
+                                    "reasoning": [content.model_dump_json() for content in reasoning_content],
+                                },
+                                "id": interface.message_id,
+                                "model": interface.model,
+                                "role": "assistant",
+                                # "stop_reason": "",
+                                # "stop_sequence": None,
+                                "type": "message",
+                                "usage": {
+                                    "input_tokens": usage.prompt_tokens,
+                                    "output_tokens": usage.completion_tokens,
+                                },
                             },
-                            "id": interface.message_id,
-                            "model": interface.model,
-                            "role": "assistant",
-                            # "stop_reason": "",
-                            # "stop_sequence": None,
-                            "type": "message",
-                            "usage": {
-                                "input_tokens": usage.prompt_tokens,
-                                "output_tokens": usage.completion_tokens,
-                            },
-                        },
-                        step_id=step_id,  # Use original step_id for telemetry
-                        organization_id=self.actor.organization_id,
-                    ),
-                )
-                step_progression = StepProgression.LOGGED_TRACE
+                            step_id=step_id,  # Use original step_id for telemetry
+                            organization_id=self.actor.organization_id,
+                        ),
+                    )
+                    step_progression = StepProgression.LOGGED_TRACE
 
                 # yields tool response as this is handled from Letta and not the response from the LLM provider
                 tool_return = [msg for msg in persisted_messages if msg.role == "tool"][-1].to_letta_messages()[0]
@@ -1352,6 +1359,7 @@ async def _rebuild_context_window(
     ) -> list[Message]:
         # If total tokens is reached, we truncate down
         # 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 force or (total_tokens and total_tokens > llm_config.context_window):
             self.logger.warning(
                 f"Total tokens {total_tokens} exceeds configured max tokens {llm_config.context_window}, forcefully clearing message history."
@@ -1363,6 +1371,7 @@ async def _rebuild_context_window(
                 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 {llm_config.context_window}, passing summarizing w/o force."
             )
@@ -1453,8 +1462,10 @@ async def _create_llm_request_data_async(
             force_tool_call = valid_tool_names[0]
 
         allowed_tools = [enable_strict_mode(t.json_schema) for t in tools if t.name in set(valid_tool_names)]
+        # Extract terminal tool names from tool rules
+        terminal_tool_names = {rule.tool_name for rule in tool_rules_solver.terminal_tool_rules}
         allowed_tools = runtime_override_tool_json_schema(
-            tool_list=allowed_tools, response_format=agent_state.response_format, request_heartbeat=True
+            tool_list=allowed_tools, response_format=agent_state.response_format, request_heartbeat=True, terminal_tools=terminal_tool_names
         )
 
         return (

letta/agents/voice_agent.py

@@ -13,6 +13,7 @@
 from letta.helpers.tool_execution_helper import add_pre_execution_message, enable_strict_mode, remove_request_heartbeat
 from letta.interfaces.openai_chat_completions_streaming_interface import OpenAIChatCompletionsStreamingInterface
 from letta.log import get_logger
+from letta.prompts.prompt_generator import PromptGenerator
 from letta.schemas.agent import AgentState, AgentType
 from letta.schemas.enums import MessageRole, ToolType
 from letta.schemas.letta_response import LettaResponse
@@ -35,7 +36,6 @@
 )
 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_async
 from letta.services.job_manager import JobManager
 from letta.services.message_manager import MessageManager
 from letta.services.passage_manager import PassageManager
@@ -144,7 +144,7 @@ async def step_stream(self, input_messages: List[MessageCreate], max_steps: int
 
         in_context_messages = await self.message_manager.get_messages_by_ids_async(message_ids=agent_state.message_ids, actor=self.actor)
         memory_edit_timestamp = get_utc_time()
-        in_context_messages[0].content[0].text = await compile_system_message_async(
+        in_context_messages[0].content[0].text = await PromptGenerator.compile_system_message_async(
             system_prompt=agent_state.system,
             in_context_memory=agent_state.memory,
             in_context_memory_last_edit=memory_edit_timestamp,