letta-nightly 0.7.30.dev20250603104343__py3-none-any.whl → 0.8.0.dev20250604201135__py3-none-any.whl

letta/__init__.py

@@ -1,4 +1,10 @@
-__version__ = "0.7.29"
+import os
+
+__version__ = "0.8.0"
+
+if os.environ.get("LETTA_VERSION"):
+    __version__ = os.environ["LETTA_VERSION"]
+
 
 # import clients
 from letta.client.client import RESTClient

letta/agent.py

@@ -27,7 +27,6 @@ from letta.errors import ContextWindowExceededError
 from letta.functions.ast_parsers import coerce_dict_args_by_annotations, get_function_annotations_from_source
 from letta.functions.composio_helpers import execute_composio_action, generate_composio_action_from_func_name
 from letta.functions.functions import get_function_from_module
-from letta.functions.mcp_client.base_client import BaseMCPClient
 from letta.helpers import ToolRulesSolver
 from letta.helpers.composio_helpers import get_composio_api_key
 from letta.helpers.datetime_helpers import get_utc_time
@@ -60,7 +59,9 @@ 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.tool_parser_helper import runtime_override_tool_json_schema
 from letta.services.job_manager import JobManager
+from letta.services.mcp.base_client import AsyncBaseMCPClient
 from letta.services.message_manager import MessageManager
 from letta.services.passage_manager import PassageManager
 from letta.services.provider_manager import ProviderManager
@@ -103,7 +104,7 @@ class Agent(BaseAgent):
         # extras
         first_message_verify_mono: bool = True,  # TODO move to config?
         # MCP sessions, state held in-memory in the server
-        mcp_clients: Optional[Dict[str, BaseMCPClient]] = None,
+        mcp_clients: Optional[Dict[str, AsyncBaseMCPClient]] = None,
         save_last_response: bool = False,
     ):
         assert isinstance(agent_state.memory, Memory), f"Memory object is not of type Memory: {type(agent_state.memory)}"
@@ -168,7 +169,11 @@ class Agent(BaseAgent):
         self.logger = get_logger(agent_state.id)
 
         # MCPClient, state/sessions managed by the server
-        self.mcp_clients = mcp_clients
+        # TODO: This is temporary, as a bridge
+        self.mcp_clients = None
+        # TODO: no longer supported
+        # if mcp_clients:
+        #    self.mcp_clients = {client_id: client.to_sync_client() for client_id, client in mcp_clients.items()}
 
     def load_last_function_response(self):
         """Load the last function response from message history"""
@@ -217,6 +222,7 @@ class Agent(BaseAgent):
             # refresh memory from DB (using block ids)
             self.agent_state.memory = Memory(
                 blocks=[self.block_manager.get_block_by_id(block.id, actor=self.user) for block in self.agent_state.memory.get_blocks()],
+                file_blocks=self.agent_state.memory.file_blocks,
                 prompt_template=get_prompt_template_for_agent_type(self.agent_state.agent_type),
             )
 
@@ -226,6 +232,7 @@ class Agent(BaseAgent):
             self.agent_state = self.agent_manager.rebuild_system_prompt(agent_id=self.agent_state.id, actor=self.user)
 
             return True
+
         return False
 
     def _handle_function_error_response(
@@ -323,7 +330,9 @@ class Agent(BaseAgent):
                 return None
 
         allowed_functions = [func for func in agent_state_tool_jsons if func["name"] in allowed_tool_names]
-        allowed_functions = self._runtime_override_tool_json_schema(allowed_functions)
+        allowed_functions = runtime_override_tool_json_schema(
+            tool_list=allowed_functions, response_format=self.agent_state.response_format, request_heartbeat=True
+        )
 
         # For the first message, force the initial tool if one is specified
         force_tool_call = None
@@ -858,6 +867,7 @@ class Agent(BaseAgent):
             # only pulling latest block data if shared memory is being used
             current_persisted_memory = Memory(
                 blocks=[self.block_manager.get_block_by_id(block.id, actor=self.user) for block in self.agent_state.memory.get_blocks()],
+                file_blocks=self.agent_state.memory.file_blocks,
                 prompt_template=get_prompt_template_for_agent_type(self.agent_state.agent_type),
             )  # read blocks from DB
             self.update_memory_if_changed(current_persisted_memory)
@@ -1225,7 +1235,6 @@ class Agent(BaseAgent):
             memory_edit_timestamp=get_utc_time(),
             previous_message_count=self.message_manager.size(actor=self.user, agent_id=self.agent_state.id),
             archival_memory_size=self.agent_manager.passage_size(actor=self.user, agent_id=self.agent_state.id),
-            recent_passages=self.agent_manager.list_passages(actor=self.user, agent_id=self.agent_state.id, ascending=False, limit=10),
         )
         num_tokens_external_memory_summary = count_tokens(external_memory_summary)
 
@@ -1601,8 +1610,6 @@ class Agent(BaseAgent):
                 if server_name not in self.mcp_clients:
                     raise ValueError(f"Unknown MCP server name: {server_name}")
                 mcp_client = self.mcp_clients[server_name]
-                if not isinstance(mcp_client, BaseMCPClient):
-                    raise RuntimeError(f"Expected an MCPClient, but got: {type(mcp_client)}")
 
                 # Check that tool exists
                 available_tools = mcp_client.list_tools()

letta/agents/base_agent.py

@@ -40,6 +40,7 @@ class BaseAgent(ABC):
         self.message_manager = message_manager
         self.agent_manager = agent_manager
         self.actor = actor
+        self.logger = get_logger(agent_id)
 
     @abstractmethod
     async def step(self, input_messages: List[MessageCreate], max_steps: int = 10) -> LettaResponse:

letta/agents/ephemeral_summary_agent.py

@@ -0,0 +1,104 @@
+from pathlib import Path
+from typing import AsyncGenerator, Dict, List
+
+from openai import AsyncOpenAI
+
+from letta.agents.base_agent import BaseAgent
+from letta.orm.errors import NoResultFound
+from letta.schemas.block import Block, BlockUpdate
+from letta.schemas.enums import MessageRole
+from letta.schemas.letta_message_content import TextContent
+from letta.schemas.message import Message, MessageCreate
+from letta.schemas.openai.chat_completion_request import ChatCompletionRequest
+from letta.schemas.user import User
+from letta.services.agent_manager import AgentManager
+from letta.services.block_manager import BlockManager
+from letta.services.message_manager import MessageManager
+
+
+class EphemeralSummaryAgent(BaseAgent):
+    """
+    A stateless summarization agent (thin wrapper around OpenAI)
+
+    # TODO: Extend to more clients
+    """
+
+    def __init__(
+        self,
+        target_block_label: str,
+        agent_id: str,
+        message_manager: MessageManager,
+        agent_manager: AgentManager,
+        block_manager: BlockManager,
+        actor: User,
+    ):
+        super().__init__(
+            agent_id=agent_id,
+            openai_client=AsyncOpenAI(),
+            message_manager=message_manager,
+            agent_manager=agent_manager,
+            actor=actor,
+        )
+        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]:
+        if len(input_messages) > 1:
+            raise ValueError("Can only invoke EphemeralSummaryAgent with a single summarization message.")
+
+        # Check block existence
+        try:
+            block = await self.agent_manager.get_block_with_label_async(
+                agent_id=self.agent_id, block_label=self.target_block_label, actor=self.actor
+            )
+        except NoResultFound:
+            block = await self.block_manager.create_or_update_block_async(
+                block=Block(
+                    value="", label=self.target_block_label, description="Contains recursive summarizations of the conversation so far"
+                ),
+                actor=self.actor,
+            )
+            await self.agent_manager.attach_block_async(agent_id=self.agent_id, block_id=block.id, actor=self.actor)
+
+        if block.value:
+            input_message = input_messages[0]
+            input_message.content[0].text += f"\n\n--- Previous Summary ---\n{block.value}\n"
+
+        openai_messages = self.pre_process_input_message(input_messages=input_messages)
+        request = self._build_openai_request(openai_messages)
+
+        # TODO: Extend to generic client
+        chat_completion = await self.openai_client.chat.completions.create(**request.model_dump(exclude_unset=True))
+        summary = chat_completion.choices[0].message.content.strip()
+
+        await self.block_manager.update_block_async(block_id=block.id, block_update=BlockUpdate(value=summary), actor=self.actor)
+
+        print(block)
+        print(summary)
+
+        return [
+            Message(
+                role=MessageRole.assistant,
+                content=[TextContent(text=summary)],
+            )
+        ]
+
+    def _build_openai_request(self, openai_messages: List[Dict]) -> ChatCompletionRequest:
+        current_dir = Path(__file__).parent
+        file_path = current_dir / "prompts" / "summary_system_prompt.txt"
+        with open(file_path, "r") as file:
+            system = file.read()
+
+        system_message = [{"role": "system", "content": system}]
+
+        openai_request = ChatCompletionRequest(
+            model="gpt-4o",
+            messages=system_message + openai_messages,
+            user=self.actor.id,
+            max_completion_tokens=4096,
+            temperature=0.7,
+        )
+        return openai_request
+
+    async def step_stream(self, input_messages: List[MessageCreate], max_steps: int = 10) -> AsyncGenerator[str, None]:
+        raise NotImplementedError("EphemeralAgent does not support async step.")

letta/agents/helpers.py

@@ -85,9 +85,7 @@ async def _prepare_in_context_messages_async(
 
     if agent_state.message_buffer_autoclear:
         # If autoclear is enabled, only include the most recent system message (usually at index 0)
-        current_in_context_messages = [
-            (await message_manager.get_messages_by_ids_async(message_ids=agent_state.message_ids, actor=actor))[0]
-        ]
+        current_in_context_messages = [await message_manager.get_message_by_id_async(message_id=agent_state.message_ids[0], actor=actor)]
     else:
         # 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)
@@ -100,6 +98,40 @@ async def _prepare_in_context_messages_async(
     return current_in_context_messages, new_in_context_messages
 
 
+async def _prepare_in_context_messages_no_persist_async(
+    input_messages: List[MessageCreate],
+    agent_state: AgentState,
+    message_manager: MessageManager,
+    actor: User,
+) -> Tuple[List[Message], List[Message]]:
+    """
+    Prepares in-context messages for an agent, based on the current state and a new user input.
+
+    Args:
+        input_messages (List[MessageCreate]): The new user input messages to process.
+        agent_state (AgentState): The current state of the agent, including message buffer config.
+        message_manager (MessageManager): The manager used to retrieve and create messages.
+        actor (User): The user performing the action, used for access control and attribution.
+
+    Returns:
+        Tuple[List[Message], List[Message]]: A tuple containing:
+            - The current in-context messages (existing context for the agent).
+            - The new in-context messages (messages created from the new input).
+    """
+
+    if agent_state.message_buffer_autoclear:
+        # If autoclear is enabled, only include the most recent system message (usually at index 0)
+        current_in_context_messages = [await message_manager.get_message_by_id_async(message_id=agent_state.message_ids[0], actor=actor)]
+    else:
+        # 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, actor=actor)
+
+    return current_in_context_messages, new_in_context_messages
+
+
 def serialize_message_history(messages: List[str], context: str) -> str:
     """
     Produce an XML document like: