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

letta/agent.py

@@ -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/helpers/converters.py

@@ -8,6 +8,16 @@ from sqlalchemy import Dialect
 
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.enums import ToolRuleType
+from letta.schemas.letta_message_content import (
+    MessageContent,
+    MessageContentType,
+    OmittedReasoningContent,
+    ReasoningContent,
+    RedactedReasoningContent,
+    TextContent,
+    ToolCallContent,
+    ToolReturnContent,
+)
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.message import ToolReturn
 from letta.schemas.tool_rule import ChildToolRule, ConditionalToolRule, ContinueToolRule, InitToolRule, TerminalToolRule, ToolRule
@@ -80,10 +90,13 @@ def deserialize_tool_rule(data: Dict) -> Union[ChildToolRule, InitToolRule, Term
     rule_type = ToolRuleType(data.get("type"))
 
     if rule_type == ToolRuleType.run_first or rule_type == ToolRuleType.InitToolRule:
+        data["type"] = ToolRuleType.run_first
         return InitToolRule(**data)
     elif rule_type == ToolRuleType.exit_loop or rule_type == ToolRuleType.TerminalToolRule:
+        data["type"] = ToolRuleType.exit_loop
         return TerminalToolRule(**data)
     elif rule_type == ToolRuleType.constrain_child_tools or rule_type == ToolRuleType.ToolRule:
+        data["type"] = ToolRuleType.constrain_child_tools
         return ChildToolRule(**data)
     elif rule_type == ToolRuleType.conditional:
         return ConditionalToolRule(**data)
@@ -163,6 +176,60 @@ def deserialize_tool_returns(data: Optional[List[Dict]]) -> List[ToolReturn]:
     return tool_returns
 
 
+# ----------------------------
+# MessageContent Serialization
+# ----------------------------
+
+
+def serialize_message_content(message_content: Optional[List[Union[MessageContent, dict]]]) -> List[Dict]:
+    """Convert a list of MessageContent objects into JSON-serializable format."""
+    if not message_content:
+        return []
+
+    serialized_message_content = []
+    for content in message_content:
+        if isinstance(content, MessageContent):
+            serialized_message_content.append(content.model_dump())
+        elif isinstance(content, dict):
+            serialized_message_content.append(content)  # Already a dictionary, leave it as-is
+        else:
+            raise TypeError(f"Unexpected message content type: {type(content)}")
+
+    return serialized_message_content
+
+
+def deserialize_message_content(data: Optional[List[Dict]]) -> List[MessageContent]:
+    """Convert a JSON list back into MessageContent objects."""
+    if not data:
+        return []
+
+    message_content = []
+    for item in data:
+        if not item:
+            continue
+
+        content_type = item.get("type")
+        if content_type == MessageContentType.text:
+            content = TextContent(**item)
+        elif content_type == MessageContentType.tool_call:
+            content = ToolCallContent(**item)
+        elif content_type == MessageContentType.tool_return:
+            content = ToolReturnContent(**item)
+        elif content_type == MessageContentType.reasoning:
+            content = ReasoningContent(**item)
+        elif content_type == MessageContentType.redacted_reasoning:
+            content = RedactedReasoningContent(**item)
+        elif content_type == MessageContentType.omitted_reasoning:
+            content = OmittedReasoningContent(**item)
+        else:
+            # Skip invalid content
+            continue
+
+        message_content.append(content)
+
+    return message_content
+
+
 # --------------------------
 # Vector Serialization
 # --------------------------

letta/helpers/mcp_helpers.py

@@ -11,6 +11,9 @@ from letta.log import get_logger
 
 logger = get_logger(__name__)
 
+# see: https://modelcontextprotocol.io/quickstart/user
+MCP_CONFIG_TOPLEVEL_KEY = "mcpServers"
+
 
 class MCPTool(Tool):
     """A simple wrapper around MCP's tool definition (to avoid conflict with our own)"""
@@ -18,7 +21,7 @@ class MCPTool(Tool):
 
 class MCPServerType(str, Enum):
     SSE = "sse"
-    LOCAL = "local"
+    STDIO = "stdio"
 
 
 class BaseServerConfig(BaseModel):
@@ -30,11 +33,29 @@ class SSEServerConfig(BaseServerConfig):
     type: MCPServerType = MCPServerType.SSE
     server_url: str = Field(..., description="The URL of the server (MCP SSE client will connect to this URL)")
 
+    def to_dict(self) -> dict:
+        values = {
+            "transport": "sse",
+            "url": self.server_url,
+        }
+        return values
+
 
-class LocalServerConfig(BaseServerConfig):
-    type: MCPServerType = MCPServerType.LOCAL
+class StdioServerConfig(BaseServerConfig):
+    type: MCPServerType = MCPServerType.STDIO
     command: str = Field(..., description="The command to run (MCP 'local' client will run this command)")
     args: List[str] = Field(..., description="The arguments to pass to the command")
+    env: Optional[dict[str, str]] = Field(None, description="Environment variables to set")
+
+    def to_dict(self) -> dict:
+        values = {
+            "transport": "stdio",
+            "command": self.command,
+            "args": self.args,
+        }
+        if self.env is not None:
+            values["env"] = self.env
+        return values
 
 
 class BaseMCPClient:
@@ -83,8 +104,8 @@ class BaseMCPClient:
             logger.info("Cleaned up MCP clients on shutdown.")
 
 
-class LocalMCPClient(BaseMCPClient):
-    def _initialize_connection(self, server_config: LocalServerConfig):
+class StdioMCPClient(BaseMCPClient):
+    def _initialize_connection(self, server_config: StdioServerConfig):
         server_params = StdioServerParameters(command=server_config.command, args=server_config.args)
         stdio_cm = stdio_client(server_params)
         stdio_transport = self.loop.run_until_complete(stdio_cm.__aenter__())

letta/llm_api/openai.py

@@ -221,7 +221,7 @@ def openai_chat_completions_process_stream(
     # TODO(sarah): add message ID generation function
     dummy_message = _Message(
         role=_MessageRole.assistant,
-        text="",
+        content=[],
         agent_id="",
         model="",
         name=None,

letta/memory.py

@@ -5,8 +5,9 @@ from letta.llm_api.llm_api_tools import create
 from letta.prompts.gpt_summarize import SYSTEM as SUMMARY_PROMPT_SYSTEM
 from letta.schemas.agent import AgentState
 from letta.schemas.enums import MessageRole
+from letta.schemas.letta_message_content import TextContent
 from letta.schemas.memory import Memory
-from letta.schemas.message import Message, TextContent
+from letta.schemas.message import Message
 from letta.settings import summarizer_settings
 from letta.utils import count_tokens, printd
 

letta/orm/__init__.py

@@ -4,6 +4,8 @@ from letta.orm.base import Base
 from letta.orm.block import Block
 from letta.orm.blocks_agents import BlocksAgents
 from letta.orm.file import FileMetadata
+from letta.orm.group import Group
+from letta.orm.groups_agents import GroupsAgents
 from letta.orm.identities_agents import IdentitiesAgents
 from letta.orm.identities_blocks import IdentitiesBlocks
 from letta.orm.identity import Identity