letta-nightly 0.6.39.dev20250314104053__py3-none-any.whl → 0.6.40.dev20250314222759__py3-none-any.whl

letta/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.6.39"
+__version__ = "0.6.40"
 
 # import clients
 from letta.client.client import LocalClient, RESTClient, create_client

letta/agent.py

@@ -22,11 +22,11 @@ from letta.errors import ContextWindowExceededError
 from letta.functions.ast_parsers import coerce_dict_args_by_annotations, get_function_annotations_from_source
 from letta.functions.functions import get_function_from_module
 from letta.functions.helpers import execute_composio_action, generate_composio_action_from_func_name
+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
 from letta.helpers.json_helpers import json_dumps, json_loads
-from letta.helpers.mcp_helpers import BaseMCPClient
 from letta.interface import AgentInterface
 from letta.llm_api.helpers import calculate_summarizer_cutoff, get_token_counts_for_messages, is_context_overflow_error
 from letta.llm_api.llm_api_tools import create
@@ -39,7 +39,8 @@ from letta.orm.enums import ToolType
 from letta.schemas.agent import AgentState, AgentStepResponse, UpdateAgent
 from letta.schemas.block import BlockUpdate
 from letta.schemas.embedding_config import EmbeddingConfig
-from letta.schemas.enums import MessageContentType, MessageRole
+from letta.schemas.enums import MessageRole
+from letta.schemas.letta_message_content import TextContent
 from letta.schemas.memory import ContextWindowOverview, Memory
 from letta.schemas.message import Message, ToolReturn
 from letta.schemas.openai.chat_completion_response import ChatCompletionResponse
@@ -95,6 +96,7 @@ class Agent(BaseAgent):
         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,
+        save_last_response: bool = False,
     ):
         assert isinstance(agent_state.memory, Memory), f"Memory object is not of type Memory: {type(agent_state.memory)}"
         # Hold a copy of the state that was used to init the agent
@@ -149,6 +151,10 @@ class Agent(BaseAgent):
         # Load last function response from message history
         self.last_function_response = self.load_last_function_response()
 
+        # Save last responses in memory
+        self.save_last_response = save_last_response
+        self.last_response_messages = []
+
         # Logger that the Agent specifically can use, will also report the agent_state ID with the logs
         self.logger = get_logger(agent_state.id)
 
@@ -160,7 +166,7 @@ class Agent(BaseAgent):
         in_context_messages = self.agent_manager.get_in_context_messages(agent_id=self.agent_state.id, actor=self.user)
         for i in range(len(in_context_messages) - 1, -1, -1):
             msg = in_context_messages[i]
-            if msg.role == MessageRole.tool and msg.content and len(msg.content) == 1 and msg.content[0].type == MessageContentType.text:
+            if msg.role == MessageRole.tool and msg.content and len(msg.content) == 1 and isinstance(msg.content[0], TextContent):
                 text_content = msg.content[0].text
                 try:
                     response_json = json.loads(text_content)
@@ -926,6 +932,9 @@ class Agent(BaseAgent):
             else:
                 all_new_messages = all_response_messages
 
+            if self.save_last_response:
+                self.last_response_messages = all_response_messages
+
             # Check the memory pressure and potentially issue a memory pressure warning
             current_total_tokens = response.usage.total_tokens
             active_memory_warning = False
@@ -1052,6 +1061,7 @@ class Agent(BaseAgent):
 
             else:
                 logger.error(f"step() failed with an unrecognized exception: '{str(e)}'")
+                traceback.print_exc()
                 raise e
 
     def step_user_message(self, user_message_str: str, **kwargs) -> AgentStepResponse:
@@ -1201,7 +1211,7 @@ class Agent(BaseAgent):
             and in_context_messages[1].role == MessageRole.user
             and in_context_messages[1].content
             and len(in_context_messages[1].content) == 1
-            and in_context_messages[1].content[0].type == MessageContentType.text
+            and isinstance(in_context_messages[1].content[0], TextContent)
             # TODO remove hardcoding
             and "The following is a summary of the previous " in in_context_messages[1].content[0].text
         ):

letta/agents/ephemeral_agent.py

@@ -5,7 +5,8 @@ import openai
 from letta.agents.base_agent import BaseAgent
 from letta.schemas.agent import AgentState
 from letta.schemas.enums import MessageRole
-from letta.schemas.letta_message import TextContent, UserMessage
+from letta.schemas.letta_message import UserMessage
+from letta.schemas.letta_message_content import TextContent
 from letta.schemas.message import Message
 from letta.schemas.openai.chat_completion_request import ChatCompletionRequest
 from letta.schemas.user import User

letta/agents/low_latency_agent.py

@@ -40,6 +40,7 @@ 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.message_manager import MessageManager
+from letta.services.passage_manager import PassageManager
 from letta.services.summarizer.enums import SummarizationMode
 from letta.services.summarizer.summarizer import Summarizer
 from letta.utils import united_diff
@@ -75,6 +76,7 @@ class LowLatencyAgent(BaseAgent):
         # TODO: Make this more general, factorable
         # Summarizer settings
         self.block_manager = block_manager
+        self.passage_manager = PassageManager()  # TODO: pass this in
         # TODO: This is not guaranteed to exist!
         self.summary_block_label = "human"
         self.summarizer = Summarizer(
@@ -246,10 +248,16 @@ class LowLatencyAgent(BaseAgent):
             return in_context_messages
 
         memory_edit_timestamp = get_utc_time()
+
+        num_messages = self.message_manager.size(actor=actor, agent_id=agent_id)
+        num_archival_memories = self.passage_manager.size(actor=actor, agent_id=agent_id)
+
         new_system_message_str = compile_system_message(
             system_prompt=agent_state.system,
             in_context_memory=agent_state.memory,
             in_context_memory_last_edit=memory_edit_timestamp,
+            previous_message_count=num_messages,
+            archival_memory_size=num_archival_memories,
         )
 
         diff = united_diff(curr_system_message_text, new_system_message_str)

letta/dynamic_multi_agent.py

@@ -0,0 +1,274 @@
+from typing import List, Optional
+
+from letta.agent import Agent, AgentState
+from letta.interface import AgentInterface
+from letta.orm import User
+from letta.schemas.block import Block
+from letta.schemas.letta_message_content import TextContent
+from letta.schemas.message import Message, MessageCreate
+from letta.schemas.openai.chat_completion_response import UsageStatistics
+from letta.schemas.usage import LettaUsageStatistics
+from letta.services.tool_manager import ToolManager
+
+
+class DynamicMultiAgent(Agent):
+    def __init__(
+        self,
+        interface: AgentInterface,
+        agent_state: AgentState,
+        user: User = None,
+        # custom
+        group_id: str = "",
+        agent_ids: List[str] = [],
+        description: str = "",
+        max_turns: Optional[int] = None,
+        termination_token: str = "DONE!",
+    ):
+        super().__init__(interface, agent_state, user)
+        self.group_id = group_id
+        self.agent_ids = agent_ids
+        self.description = description
+        self.max_turns = max_turns or len(agent_ids)
+        self.termination_token = termination_token
+
+        self.tool_manager = ToolManager()
+
+    def step(
+        self,
+        messages: List[MessageCreate],
+        chaining: bool = True,
+        max_chaining_steps: Optional[int] = None,
+        put_inner_thoughts_first: bool = True,
+        **kwargs,
+    ) -> LettaUsageStatistics:
+        total_usage = UsageStatistics()
+        step_count = 0
+
+        token_streaming = self.interface.streaming_mode if hasattr(self.interface, "streaming_mode") else False
+        metadata = self.interface.metadata if hasattr(self.interface, "metadata") else None
+
+        agents = {}
+        message_index = {self.agent_state.id: 0}
+        agents[self.agent_state.id] = self.load_manager_agent()
+        for agent_id in self.agent_ids:
+            agents[agent_id] = self.load_participant_agent(agent_id=agent_id)
+            message_index[agent_id] = 0
+
+        chat_history: List[Message] = []
+        new_messages = messages
+        speaker_id = None
+        try:
+            for _ in range(self.max_turns):
+                agent_id_options = [agent_id for agent_id in self.agent_ids if agent_id != speaker_id]
+                manager_message = self.ask_manager_to_choose_participant_message(new_messages, chat_history, agent_id_options)
+                manager_agent = agents[self.agent_state.id]
+                usage_stats = manager_agent.step(
+                    messages=[manager_message],
+                    chaining=chaining,
+                    max_chaining_steps=max_chaining_steps,
+                    stream=token_streaming,
+                    skip_verify=True,
+                    metadata=metadata,
+                    put_inner_thoughts_first=put_inner_thoughts_first,
+                )
+                responses = Message.to_letta_messages_from_list(manager_agent.last_response_messages)
+                assistant_message = [response for response in responses if response.message_type == "assistant_message"][0]
+                for name, agent_id in [(agents[agent_id].agent_state.name, agent_id) for agent_id in agent_id_options]:
+                    if name.lower() in assistant_message.content.lower():
+                        speaker_id = agent_id
+
+                # sum usage
+                total_usage.prompt_tokens += usage_stats.prompt_tokens
+                total_usage.completion_tokens += usage_stats.completion_tokens
+                total_usage.total_tokens += usage_stats.total_tokens
+                step_count += 1
+
+                # initialize input messages
+                for message in chat_history[message_index[speaker_id] :]:
+                    message.id = Message.generate_id()
+                    message.agent_id = speaker_id
+
+                for message in new_messages:
+                    chat_history.append(
+                        Message(
+                            agent_id=speaker_id,
+                            role=message.role,
+                            content=[TextContent(text=message.content)],
+                            name=message.name,
+                            model=None,
+                            tool_calls=None,
+                            tool_call_id=None,
+                            group_id=self.group_id,
+                        )
+                    )
+
+                # load agent and perform step
+                participant_agent = agents[speaker_id]
+                usage_stats = participant_agent.step(
+                    messages=chat_history[message_index[speaker_id] :],
+                    chaining=chaining,
+                    max_chaining_steps=max_chaining_steps,
+                    stream=token_streaming,
+                    skip_verify=True,
+                    metadata=metadata,
+                    put_inner_thoughts_first=put_inner_thoughts_first,
+                )
+
+                # parse new messages for next step
+                responses = Message.to_letta_messages_from_list(
+                    participant_agent.last_response_messages,
+                )
+
+                assistant_messages = [response for response in responses if response.message_type == "assistant_message"]
+                new_messages = [
+                    MessageCreate(
+                        role="system",
+                        content=message.content,
+                        name=participant_agent.agent_state.name,
+                    )
+                    for message in assistant_messages
+                ]
+                message_index[agent_id] = len(chat_history) + len(new_messages)
+
+                # sum usage
+                total_usage.prompt_tokens += usage_stats.prompt_tokens
+                total_usage.completion_tokens += usage_stats.completion_tokens
+                total_usage.total_tokens += usage_stats.total_tokens
+                step_count += 1
+
+                # check for termination token
+                if any(self.termination_token in message.content for message in new_messages):
+                    break
+
+            # persist remaining chat history
+            for message in new_messages:
+                chat_history.append(
+                    Message(
+                        agent_id=agent_id,
+                        role=message.role,
+                        content=[TextContent(text=message.content)],
+                        name=message.name,
+                        model=None,
+                        tool_calls=None,
+                        tool_call_id=None,
+                        group_id=self.group_id,
+                    )
+                )
+            for agent_id, index in message_index.items():
+                if agent_id == speaker_id:
+                    continue
+                for message in chat_history[index:]:
+                    message.id = Message.generate_id()
+                    message.agent_id = agent_id
+                self.message_manager.create_many_messages(chat_history[index:], actor=self.user)
+
+        except Exception as e:
+            raise e
+        finally:
+            self.interface.step_yield()
+
+        self.interface.step_complete()
+
+        return LettaUsageStatistics(**total_usage.model_dump(), step_count=step_count)
+
+    def load_manager_agent(self) -> Agent:
+        for participant_agent_id in self.agent_ids:
+            participant_agent_state = self.agent_manager.get_agent_by_id(agent_id=participant_agent_id, actor=self.user)
+            participant_persona_block = participant_agent_state.memory.get_block(label="persona")
+            new_block = self.block_manager.create_or_update_block(
+                block=Block(
+                    label=participant_agent_id,
+                    value=participant_persona_block.value,
+                ),
+                actor=self.user,
+            )
+            self.agent_state = self.agent_manager.update_block_with_label(
+                agent_id=self.agent_state.id,
+                block_label=participant_agent_id,
+                new_block_id=new_block.id,
+                actor=self.user,
+            )
+
+        persona_block = self.agent_state.memory.get_block(label="persona")
+        group_chat_manager_persona = (
+            f"You are overseeing a group chat with {len(self.agent_ids) - 1} agents and "
+            f"one user. Description of the group: {self.description}\n"
+            "On each turn, you will be provided with the chat history and latest message. "
+            "Your task is to decide which participant should speak next in the chat based "
+            "on the chat history. Each agent has a memory block labeled with their ID which "
+            "holds info about them, and you should use this context to inform your decision."
+        )
+        self.agent_state.memory.update_block_value(label="persona", value=persona_block.value + group_chat_manager_persona)
+        return Agent(
+            agent_state=self.agent_state,
+            interface=self.interface,
+            user=self.user,
+            save_last_response=True,
+        )
+
+    def load_participant_agent(self, agent_id: str) -> Agent:
+        agent_state = self.agent_manager.get_agent_by_id(agent_id=agent_id, actor=self.user)
+        persona_block = agent_state.memory.get_block(label="persona")
+        group_chat_participant_persona = (
+            f"You are a participant in a group chat with {len(self.agent_ids) - 1} other "
+            "agents and one user. Respond to new messages in the group chat when prompted. "
+            f"Description of the group: {self.description}. About you: "
+        )
+        agent_state.memory.update_block_value(label="persona", value=group_chat_participant_persona + persona_block.value)
+        return Agent(
+            agent_state=agent_state,
+            interface=self.interface,
+            user=self.user,
+            save_last_response=True,
+        )
+
+    '''
+    def attach_choose_next_participant_tool(self) -> AgentState:
+        def choose_next_participant(next_speaker_agent_id: str) -> str:
+            """
+            Returns ID of the agent in the group chat that should reply to the latest message in the conversation. The agent ID will always be in the format: `agent-{UUID}`.
+            Args:
+              next_speaker_agent_id (str): The ID of the agent that is most suitable to be the next speaker.
+            Returns:
+              str: The ID of the agent that should be the next speaker.
+            """
+            return next_speaker_agent_id
+        source_code = parse_source_code(choose_next_participant)
+        tool = self.tool_manager.create_or_update_tool(
+            Tool(
+                source_type="python",
+                source_code=source_code,
+                name="choose_next_participant",
+            ),
+            actor=self.user,
+        )
+        return self.agent_manager.attach_tool(agent_id=self.agent_state.id, tool_id=tool.id, actor=self.user)
+    '''
+
+    def ask_manager_to_choose_participant_message(
+        self,
+        new_messages: List[MessageCreate],
+        chat_history: List[Message],
+        agent_id_options: List[str],
+    ) -> Message:
+        chat_history = [f"{message.name or 'user'}: {message.content[0].text}" for message in chat_history]
+        for message in new_messages:
+            chat_history.append(f"{message.name or 'user'}: {message.content}")
+        context_messages = "\n".join(chat_history)
+
+        message_text = (
+            "Choose the most suitable agent to reply to the latest message in the "
+            f"group chat from the following options: {agent_id_options}. Do not "
+            "respond to the messages yourself, your task is only to decide the "
+            f"next speaker, not to participate. \nChat history:\n{context_messages}"
+        )
+        return Message(
+            agent_id=self.agent_state.id,
+            role="user",
+            content=[TextContent(text=message_text)],
+            name=None,
+            model=None,
+            tool_calls=None,
+            tool_call_id=None,
+            group_id=self.group_id,
+        )

letta/functions/function_sets/base.py

@@ -77,6 +77,7 @@ def archival_memory_insert(self: "Agent", content: str) -> Optional[str]:
         text=content,
         actor=self.user,
     )
+    self.agent_manager.rebuild_system_prompt(agent_id=self.agent_state.id, actor=self.user, force=True)
     return None
 
 

letta/functions/function_sets/extras.py

@@ -7,7 +7,8 @@ import requests
 from letta.constants import MESSAGE_CHATGPT_FUNCTION_MODEL, MESSAGE_CHATGPT_FUNCTION_SYSTEM_MESSAGE
 from letta.helpers.json_helpers import json_dumps, json_loads
 from letta.llm_api.llm_api_tools import create
-from letta.schemas.message import Message, TextContent
+from letta.schemas.letta_message_content import TextContent
+from letta.schemas.message import Message
 
 
 def message_chatgpt(self, message: str):

letta/functions/function_sets/multi_agent.py

@@ -3,6 +3,7 @@ from typing import TYPE_CHECKING, List
 
 from letta.functions.helpers import (
     _send_message_to_agents_matching_tags_async,
+    _send_message_to_all_agents_in_group_async,
     execute_send_message_to_agent,
     fire_and_forget_send_to_agent,
 )
@@ -86,3 +87,19 @@ def send_message_to_agents_matching_tags(self: "Agent", message: str, match_all:
     """
 
     return asyncio.run(_send_message_to_agents_matching_tags_async(self, message, match_all, match_some))
+
+
+def send_message_to_all_agents_in_group(self: "Agent", message: str) -> List[str]:
+    """
+    Sends a message to all agents within the same multi-agent group.
+
+    Args:
+        message (str): The content of the message to be sent to each matching agent.
+
+    Returns:
+        List[str]: A list of responses from the agents that matched the filtering criteria. Each
+        response corresponds to a single agent. Agents that do not respond will not have an entry
+        in the returned list.
+    """
+
+    return asyncio.run(_send_message_to_all_agents_in_group_async(self, message))

letta/functions/helpers.py

@@ -604,6 +604,47 @@ async def _send_message_to_agents_matching_tags_async(
     return final
 
 
+async def _send_message_to_all_agents_in_group_async(sender_agent: "Agent", message: str) -> List[str]:
+    server = get_letta_server()
+
+    augmented_message = (
+        f"[Incoming message from agent with ID '{sender_agent.agent_state.id}' - to reply to this message, "
+        f"make sure to use the 'send_message' at the end, and the system will notify the sender of your response] "
+        f"{message}"
+    )
+
+    worker_agents_ids = sender_agent.agent_state.multi_agent_group.agent_ids
+    worker_agents = [server.agent_manager.get_agent_by_id(agent_id=agent_id, actor=sender_agent.user) for agent_id in worker_agents_ids]
+
+    # Create a system message
+    messages = [MessageCreate(role=MessageRole.system, content=augmented_message, name=sender_agent.agent_state.name)]
+
+    # Possibly limit concurrency to avoid meltdown:
+    sem = asyncio.Semaphore(settings.multi_agent_concurrent_sends)
+
+    async def _send_single(agent_state):
+        async with sem:
+            return await async_send_message_with_retries(
+                server=server,
+                sender_agent=sender_agent,
+                target_agent_id=agent_state.id,
+                messages=messages,
+                max_retries=3,
+                timeout=settings.multi_agent_send_message_timeout,
+            )
+
+    tasks = [asyncio.create_task(_send_single(agent_state)) for agent_state in worker_agents]
+    results = await asyncio.gather(*tasks, return_exceptions=True)
+    final = []
+    for r in results:
+        if isinstance(r, Exception):
+            final.append(str(r))
+        else:
+            final.append(r)
+
+    return final
+
+
 def generate_model_from_args_json_schema(schema: Dict[str, Any]) -> Type[BaseModel]:
     """Creates a Pydantic model from a JSON schema.
 

letta/functions/mcp_client/base_client.py

@@ -0,0 +1,61 @@
+import asyncio
+from typing import List, Optional, Tuple
+
+from mcp import ClientSession, Tool
+
+from letta.functions.mcp_client.types import BaseServerConfig
+from letta.log import get_logger
+
+logger = get_logger(__name__)
+
+
+class BaseMCPClient:
+    def __init__(self):
+        self.session: Optional[ClientSession] = None
+        self.stdio = None
+        self.write = None
+        self.initialized = False
+        self.loop = asyncio.new_event_loop()
+        self.cleanup_funcs = []
+
+    def connect_to_server(self, server_config: BaseServerConfig):
+        asyncio.set_event_loop(self.loop)
+        success = self._initialize_connection(server_config)
+
+        if success:
+            self.loop.run_until_complete(self.session.initialize())
+            self.initialized = True
+        else:
+            raise RuntimeError(
+                f"Connecting to MCP server failed. Please review your server config: {server_config.model_dump_json(indent=4)}"
+            )
+
+    def _initialize_connection(self, server_config: BaseServerConfig) -> bool:
+        raise NotImplementedError("Subclasses must implement _initialize_connection")
+
+    def list_tools(self) -> List[Tool]:
+        self._check_initialized()
+        response = self.loop.run_until_complete(self.session.list_tools())
+        return response.tools
+
+    def execute_tool(self, tool_name: str, tool_args: dict) -> Tuple[str, bool]:
+        self._check_initialized()
+        result = self.loop.run_until_complete(self.session.call_tool(tool_name, tool_args))
+        return str(result.content), result.isError
+
+    def _check_initialized(self):
+        if not self.initialized:
+            logger.error("MCPClient has not been initialized")
+            raise RuntimeError("MCPClient has not been initialized")
+
+    def cleanup(self):
+        try:
+            for cleanup_func in self.cleanup_funcs:
+                cleanup_func()
+            self.initialized = False
+            if not self.loop.is_closed():
+                self.loop.close()
+        except Exception as e:
+            logger.warning(e)
+        finally:
+            logger.info("Cleaned up MCP clients on shutdown.")

letta/functions/mcp_client/sse_client.py

@@ -0,0 +1,21 @@
+from mcp import ClientSession
+from mcp.client.sse import sse_client
+
+from letta.functions.mcp_client.base_client import BaseMCPClient
+from letta.functions.mcp_client.types import SSEServerConfig
+
+# see: https://modelcontextprotocol.io/quickstart/user
+MCP_CONFIG_TOPLEVEL_KEY = "mcpServers"
+
+
+class SSEMCPClient(BaseMCPClient):
+    def _initialize_connection(self, server_config: SSEServerConfig) -> bool:
+        sse_cm = sse_client(url=server_config.server_url)
+        sse_transport = self.loop.run_until_complete(sse_cm.__aenter__())
+        self.stdio, self.write = sse_transport
+        self.cleanup_funcs.append(lambda: self.loop.run_until_complete(sse_cm.__aexit__(None, None, None)))
+
+        session_cm = ClientSession(self.stdio, self.write)
+        self.session = self.loop.run_until_complete(session_cm.__aenter__())
+        self.cleanup_funcs.append(lambda: self.loop.run_until_complete(session_cm.__aexit__(None, None, None)))
+        return True