letta-nightly 0.11.6.dev20250903104037__py3-none-any.whl → 0.11.7.dev20250904045700__py3-none-any.whl

letta/__init__.py

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

letta/agent.py

@@ -1,6 +1,5 @@
 import asyncio
 import json
-import os
 import time
 import traceback
 import warnings
@@ -50,9 +49,7 @@ from letta.schemas.enums import MessageRole, ProviderType, StepStatus, ToolType
 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
-from letta.schemas.openai.chat_completion_response import Message as ChatCompletionMessage
-from letta.schemas.openai.chat_completion_response import UsageStatistics
+from letta.schemas.openai.chat_completion_response import ChatCompletionResponse, Message as ChatCompletionMessage, UsageStatistics
 from letta.schemas.response_format import ResponseFormatType
 from letta.schemas.tool import Tool
 from letta.schemas.tool_execution_result import ToolExecutionResult
@@ -71,7 +68,7 @@ from letta.services.step_manager import StepManager
 from letta.services.telemetry_manager import NoopTelemetryManager, TelemetryManager
 from letta.services.tool_executor.tool_execution_sandbox import ToolExecutionSandbox
 from letta.services.tool_manager import ToolManager
-from letta.settings import settings, summarizer_settings
+from letta.settings import model_settings, settings, summarizer_settings
 from letta.streaming_interface import StreamingRefreshCLIInterface
 from letta.system import get_heartbeat, get_token_limit_warning, package_function_response, package_summarize_message, package_user_message
 from letta.utils import count_tokens, get_friendly_error_msg, get_tool_call_id, log_telemetry, parse_json, validate_function_response
@@ -872,7 +869,6 @@ class Agent(BaseAgent):
     ) -> AgentStepResponse:
         """Runs a single step in the agent loop (generates at most one LLM call)"""
         try:
-
             # Extract job_id from metadata if present
             job_id = metadata.get("job_id") if metadata else None
 
@@ -1085,9 +1081,9 @@ class Agent(BaseAgent):
         -> agent.step(messages=[Message(role='user', text=...)])
         """
         # Wrap with metadata, dumps to JSON
-        assert user_message_str and isinstance(
-            user_message_str, str
-        ), f"user_message_str should be a non-empty string, got {type(user_message_str)}"
+        assert user_message_str and isinstance(user_message_str, str), (
+            f"user_message_str should be a non-empty string, got {type(user_message_str)}"
+        )
         user_message_json_str = package_user_message(user_message_str, self.agent_state.timezone)
 
         # Validate JSON via save/load
@@ -1110,7 +1106,7 @@ class Agent(BaseAgent):
 
     def summarize_messages_inplace(self):
         in_context_messages = self.agent_manager.get_in_context_messages(agent_id=self.agent_state.id, actor=self.user)
-        in_context_messages_openai = [m.to_openai_dict() for m in in_context_messages]
+        in_context_messages_openai = Message.to_openai_dicts_from_list(in_context_messages)
         in_context_messages_openai_no_system = in_context_messages_openai[1:]
         token_counts = get_token_counts_for_messages(in_context_messages)
         logger.info(f"System message token count={token_counts[0]}")
@@ -1216,7 +1212,7 @@ class Agent(BaseAgent):
         # Grab the in-context messages
         # conversion of messages to OpenAI dict format, which is passed to the token counter
         in_context_messages = self.agent_manager.get_in_context_messages(agent_id=self.agent_state.id, actor=self.user)
-        in_context_messages_openai = [m.to_openai_dict() for m in in_context_messages]
+        in_context_messages_openai = Message.to_openai_dicts_from_list(in_context_messages)
 
         # Check if there's a summary message in the message queue
         if (
@@ -1304,7 +1300,7 @@ class Agent(BaseAgent):
         )
 
     async def get_context_window_async(self) -> ContextWindowOverview:
-        if os.getenv("LETTA_ENVIRONMENT") == "PRODUCTION" and os.getenv("ANTHROPIC_API_KEY"):
+        if settings.environment == "PRODUCTION" and model_settings.anthropic_api_key:
             return await self.get_context_window_from_anthropic_async()
         return await self.get_context_window_from_tiktoken_async()
 
@@ -1316,7 +1312,7 @@ class Agent(BaseAgent):
         )
 
         # conversion of messages to OpenAI dict format, which is passed to the token counter
-        in_context_messages_openai = [m.to_openai_dict() for m in in_context_messages]
+        in_context_messages_openai = Message.to_openai_dicts_from_list(in_context_messages)
 
         # Extract system, memory and external summary
         if (
@@ -1446,7 +1442,7 @@ class Agent(BaseAgent):
         )
 
         # conversion of messages to anthropic dict format, which is passed to the token counter
-        in_context_messages_anthropic = [m.to_anthropic_dict() for m in in_context_messages]
+        in_context_messages_anthropic = Message.to_anthropic_dicts_from_list(in_context_messages)
 
         # Extract system, memory and external summary
         if (

letta/agents/base_agent.py

@@ -102,6 +102,23 @@ class BaseAgent(ABC):
             if tool_rules_solver is not None:
                 tool_constraint_block = tool_rules_solver.compile_tool_rule_prompts()
 
+            # compile archive tags if there's an attached archive
+            from letta.services.archive_manager import ArchiveManager
+
+            archive_manager = ArchiveManager()
+            archive = await archive_manager.get_default_archive_for_agent_async(
+                agent_id=agent_state.id,
+                actor=self.actor,
+            )
+
+            if archive:
+                archive_tags = await self.passage_manager.get_unique_tags_for_archive_async(
+                    archive_id=archive.id,
+                    actor=self.actor,
+                )
+            else:
+                archive_tags = None
+
             # TODO: This is a pretty brittle pattern established all over our code, need to get rid of this
             curr_system_message = in_context_messages[0]
             curr_system_message_text = curr_system_message.content[0].text
@@ -149,6 +166,7 @@ class BaseAgent(ABC):
                 timezone=agent_state.timezone,
                 previous_message_count=num_messages - len(in_context_messages),
                 archival_memory_size=num_archival_memories,
+                archive_tags=archive_tags,
             )
 
             diff = united_diff(curr_system_message_text, new_system_message_str)

letta/agents/helpers.py

@@ -9,11 +9,11 @@ from letta.schemas.agent import AgentState
 from letta.schemas.letta_message import MessageType
 from letta.schemas.letta_response import LettaResponse
 from letta.schemas.letta_stop_reason import LettaStopReason, StopReasonType
-from letta.schemas.message import Message, MessageCreate
+from letta.schemas.message import Message, MessageCreate, MessageCreateBase
 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_input_messages
+from letta.server.rest_api.utils import create_approval_response_message_from_input, create_input_messages
 from letta.services.message_manager import MessageManager
 
 logger = get_logger(__name__)
@@ -36,6 +36,8 @@ def _create_letta_response(
     response_messages = Message.to_letta_messages_from_list(
         messages=filter_user_messages, use_assistant_message=use_assistant_message, reverse=False
     )
+    # Filter approval response messages
+    response_messages = [m for m in response_messages if m.message_type != "approval_response_message"]
 
     # Apply message type filtering if specified
     if include_return_message_types is not None:
@@ -115,13 +117,14 @@ async def _prepare_in_context_messages_async(
     new_in_context_messages = await message_manager.create_many_messages_async(
         create_input_messages(input_messages=input_messages, agent_id=agent_state.id, timezone=agent_state.timezone, actor=actor),
         actor=actor,
+        embedding_config=agent_state.embedding_config,
     )
 
     return current_in_context_messages, new_in_context_messages
 
 
 async def _prepare_in_context_messages_no_persist_async(
-    input_messages: List[MessageCreate],
+    input_messages: List[MessageCreateBase],
     agent_state: AgentState,
     message_manager: MessageManager,
     actor: User,
@@ -148,10 +151,32 @@ async def _prepare_in_context_messages_no_persist_async(
         # Otherwise, include the full list of messages by ID for context
         current_in_context_messages = await message_manager.get_messages_by_ids_async(message_ids=agent_state.message_ids, actor=actor)
 
-    # Create a new user message from the input but dont store it yet
-    new_in_context_messages = create_input_messages(
-        input_messages=input_messages, agent_id=agent_state.id, timezone=agent_state.timezone, actor=actor
-    )
+    # 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":
+            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])
+    else:
+        # User is trying to send a regular message
+        if current_in_context_messages[-1].role == "approval":
+            raise ValueError(
+                "Cannot send a new message: The agent is waiting for approval on a tool call. "
+                "Please approve or deny the pending request before continuing."
+            )
+
+        # Create a new user message from the input but dont store it yet
+        new_in_context_messages = create_input_messages(
+            input_messages=input_messages, agent_id=agent_state.id, timezone=agent_state.timezone, actor=actor
+        )
 
     return current_in_context_messages, new_in_context_messages