letta-nightly 0.7.0.dev20250423003112__py3-none-any.whl → 0.7.2.dev20250423222439__py3-none-any.whl

letta/client/client.py

@@ -32,6 +32,7 @@ from letta.schemas.message import Message, MessageCreate
 from letta.schemas.openai.chat_completion_response import UsageStatistics
 from letta.schemas.organization import Organization
 from letta.schemas.passage import Passage
+from letta.schemas.response_format import ResponseFormatUnion
 from letta.schemas.run import Run
 from letta.schemas.sandbox_config import E2BSandboxConfig, LocalSandboxConfig, SandboxConfig, SandboxConfigCreate, SandboxConfigUpdate
 from letta.schemas.source import Source, SourceCreate, SourceUpdate
@@ -100,6 +101,7 @@ class AbstractClient(object):
         message_ids: Optional[List[str]] = None,
         memory: Optional[Memory] = None,
         tags: Optional[List[str]] = None,
+        response_format: Optional[ResponseFormatUnion] = None,
     ):
         raise NotImplementedError
 
@@ -553,6 +555,7 @@ class RESTClient(AbstractClient):
         initial_message_sequence: Optional[List[Message]] = None,
         tags: Optional[List[str]] = None,
         message_buffer_autoclear: bool = False,
+        response_format: Optional[ResponseFormatUnion] = None,
     ) -> AgentState:
         """Create an agent
 
@@ -615,6 +618,7 @@ class RESTClient(AbstractClient):
             "include_base_tools": include_base_tools,
             "message_buffer_autoclear": message_buffer_autoclear,
             "include_multi_agent_tools": include_multi_agent_tools,
+            "response_format": response_format,
         }
 
         # Only add name if it's not None
@@ -653,6 +657,7 @@ class RESTClient(AbstractClient):
         embedding_config: Optional[EmbeddingConfig] = None,
         message_ids: Optional[List[str]] = None,
         tags: Optional[List[str]] = None,
+        response_format: Optional[ResponseFormatUnion] = None,
     ) -> AgentState:
         """
         Update an existing agent
@@ -682,6 +687,7 @@ class RESTClient(AbstractClient):
             llm_config=llm_config,
             embedding_config=embedding_config,
             message_ids=message_ids,
+            response_format=response_format,
         )
         response = requests.patch(f"{self.base_url}/{self.api_prefix}/agents/{agent_id}", json=request.model_dump(), headers=self.headers)
         if response.status_code != 200:
@@ -2425,6 +2431,7 @@ class LocalClient(AbstractClient):
         llm_config: Optional[LLMConfig] = None,
         embedding_config: Optional[EmbeddingConfig] = None,
         message_ids: Optional[List[str]] = None,
+        response_format: Optional[ResponseFormatUnion] = None,
     ):
         """
         Update an existing agent
@@ -2458,6 +2465,7 @@ class LocalClient(AbstractClient):
                 llm_config=llm_config,
                 embedding_config=embedding_config,
                 message_ids=message_ids,
+                response_format=response_format,
             ),
             actor=self.user,
         )
@@ -2661,7 +2669,7 @@ class LocalClient(AbstractClient):
             response (LettaResponse): Response from the agent
         """
         self.interface.clear()
-        usage = self.server.send_messages(actor=self.user, agent_id=agent_id, messages=messages)
+        usage = self.server.send_messages(actor=self.user, agent_id=agent_id, input_messages=messages)
 
         # format messages
         return LettaResponse(messages=messages, usage=usage)
@@ -2703,7 +2711,7 @@ class LocalClient(AbstractClient):
         usage = self.server.send_messages(
             actor=self.user,
             agent_id=agent_id,
-            messages=[MessageCreate(role=MessageRole(role), content=message, name=name)],
+            input_messages=[MessageCreate(role=MessageRole(role), content=message, name=name)],
         )
 
         ## TODO: need to make sure date/timestamp is propely passed

letta/constants.py

@@ -47,13 +47,14 @@ DEFAULT_PERSONA = "sam_pov"
 DEFAULT_HUMAN = "basic"
 DEFAULT_PRESET = "memgpt_chat"
 
+SEND_MESSAGE_TOOL_NAME = "send_message"
 # Base tools that cannot be edited, as they access agent state directly
 # Note that we don't include "conversation_search_date" for now
-BASE_TOOLS = ["send_message", "conversation_search", "archival_memory_insert", "archival_memory_search"]
+BASE_TOOLS = [SEND_MESSAGE_TOOL_NAME, "conversation_search", "archival_memory_insert", "archival_memory_search"]
 # Base memory tools CAN be edited, and are added by default by the server
 BASE_MEMORY_TOOLS = ["core_memory_append", "core_memory_replace"]
 # Base tools if the memgpt agent has enable_sleeptime on
-BASE_SLEEPTIME_CHAT_TOOLS = ["send_message", "conversation_search", "archival_memory_search"]
+BASE_SLEEPTIME_CHAT_TOOLS = [SEND_MESSAGE_TOOL_NAME, "conversation_search", "archival_memory_search"]
 # Base memory tools for sleeptime agent
 BASE_SLEEPTIME_TOOLS = [
     "memory_replace",
@@ -72,7 +73,7 @@ LETTA_TOOL_SET = set(BASE_TOOLS + BASE_MEMORY_TOOLS + MULTI_AGENT_TOOLS + BASE_S
 # The name of the tool used to send message to the user
 # May not be relevant in cases where the agent has multiple ways to message to user (send_imessage, send_discord_mesasge, ...)
 # or in cases where the agent has no concept of messaging a user (e.g. a workflow agent)
-DEFAULT_MESSAGE_TOOL = "send_message"
+DEFAULT_MESSAGE_TOOL = SEND_MESSAGE_TOOL_NAME
 DEFAULT_MESSAGE_TOOL_KWARG = "message"
 
 PRE_EXECUTION_MESSAGE_ARG = "pre_exec_msg"

letta/functions/function_sets/multi_agent.py

@@ -9,7 +9,6 @@ from letta.functions.helpers import (
     extract_send_message_from_steps_messages,
     fire_and_forget_send_to_agent,
 )
-from letta.helpers.message_helper import prepare_input_message_create
 from letta.schemas.enums import MessageRole
 from letta.schemas.message import MessageCreate
 from letta.server.rest_api.utils import get_letta_server
@@ -109,11 +108,10 @@ def send_message_to_agents_matching_tags(self: "Agent", message: str, match_all:
 
         # Prepare the message
         messages = [MessageCreate(role=MessageRole.system, content=augmented_message, name=self.agent_state.name)]
-        input_messages = [prepare_input_message_create(m, agent_id) for m in messages]
 
         # Run .step() and return the response
         usage_stats = agent.step(
-            messages=input_messages,
+            input_messages=messages,
             chaining=True,
             max_chaining_steps=None,
             stream=False,

letta/functions/helpers.py

@@ -352,7 +352,7 @@ async def send_message_to_agent_no_stream(
     server: "SyncServer",
     agent_id: str,
     actor: User,
-    messages: Union[List[Message], List[MessageCreate]],
+    messages: List[MessageCreate],
     metadata: Optional[dict] = None,
 ) -> LettaResponse:
     """
@@ -368,7 +368,7 @@ async def send_message_to_agent_no_stream(
         server.send_messages,
         actor=actor,
         agent_id=agent_id,
-        messages=messages,
+        input_messages=messages,
         interface=interface,
         metadata=metadata,
     )
@@ -478,7 +478,7 @@ def fire_and_forget_send_to_agent(
                 await server.send_message_to_agent(
                     agent_id=other_agent_id,
                     actor=sender_agent.user,
-                    messages=messages,
+                    input_messages=messages,
                     stream_steps=False,
                     stream_tokens=False,
                     use_assistant_message=True,

letta/groups/dynamic_multi_agent.py

@@ -35,7 +35,7 @@ class DynamicMultiAgent(Agent):
 
     def step(
         self,
-        messages: List[MessageCreate],
+        input_messages: List[MessageCreate],
         chaining: bool = True,
         max_chaining_steps: Optional[int] = None,
         put_inner_thoughts_first: bool = True,
@@ -43,27 +43,43 @@ class DynamicMultiAgent(Agent):
     ) -> LettaUsageStatistics:
         total_usage = UsageStatistics()
         step_count = 0
+        speaker_id = None
 
+        # Load settings
         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 = {}
+        # Load agents and initialize chat history with indexing
+        agents = {self.agent_state.id: self.load_manager_agent()}
         message_index = {self.agent_state.id: 0}
-        agents[self.agent_state.id] = self.load_manager_agent()
+        chat_history: List[MessageCreate] = []
         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
+        # Prepare new messages
+        new_messages = []
+        for message in input_messages:
+            if isinstance(message.content, str):
+                message.content = [TextContent(text=message.content)]
+            message.group_id = self.group_id
+            new_messages.append(message)
+
         try:
             for _ in range(self.max_turns):
+                # Prepare manager message
                 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_message = self.ask_manager_to_choose_participant_message(
+                    manager_agent_id=self.agent_state.id,
+                    new_messages=new_messages,
+                    chat_history=chat_history,
+                    agent_id_options=agent_id_options,
+                )
+
+                # Perform manager step
                 manager_agent = agents[self.agent_state.id]
                 usage_stats = manager_agent.step(
-                    messages=[manager_message],
+                    input_messages=[manager_message],
                     chaining=chaining,
                     max_chaining_steps=max_chaining_steps,
                     stream=token_streaming,
@@ -71,42 +87,27 @@ class DynamicMultiAgent(Agent):
                     metadata=metadata,
                     put_inner_thoughts_first=put_inner_thoughts_first,
                 )
+
+                # Parse manager response
                 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
+                # 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
+                # Update chat history
+                chat_history.extend(new_messages)
 
-                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,
-                            otid=message.otid,
-                        )
-                    )
-
-                # load agent and perform step
+                # Perform participant step
                 participant_agent = agents[speaker_id]
                 usage_stats = participant_agent.step(
-                    messages=chat_history[message_index[speaker_id] :],
+                    input_messages=chat_history[message_index[speaker_id] :],
                     chaining=chaining,
                     max_chaining_steps=max_chaining_steps,
                     stream=token_streaming,
@@ -115,54 +116,54 @@ class DynamicMultiAgent(Agent):
                     put_inner_thoughts_first=put_inner_thoughts_first,
                 )
 
-                # parse new messages for next step
+                # Parse participant response
                 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,
+                        content=[TextContent(text=message.content)] if isinstance(message.content, str) else message.content,
                         name=participant_agent.agent_state.name,
                         otid=message.otid,
+                        sender_id=participant_agent.agent_state.id,
+                        group_id=self.group_id,
                     )
                     for message in assistant_messages
                 ]
+
+                # Update message index
                 message_index[speaker_id] = len(chat_history) + len(new_messages)
 
-                # sum usage
+                # 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
+                # 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,
-                    )
-                )
+            # Persist remaining chat history
+            chat_history.extend(new_messages)
             for agent_id, index in message_index.items():
                 if agent_id == speaker_id:
                     continue
+                messages_to_persist = []
                 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)
+                    message_to_persist = Message(
+                        role=message.role,
+                        content=message.content,
+                        name=message.name,
+                        otid=message.otid,
+                        sender_id=message.sender_id,
+                        group_id=message.group_id,
+                        agent_id=agent_id,
+                    )
+                    messages_to_persist.append(message_to_persist)
+                self.message_manager.create_many_messages(messages_to_persist, actor=self.user)
 
         except Exception as e:
             raise e
@@ -249,10 +250,11 @@ class DynamicMultiAgent(Agent):
 
     def ask_manager_to_choose_participant_message(
         self,
+        manager_agent_id: str,
         new_messages: List[MessageCreate],
         chat_history: List[Message],
         agent_id_options: List[str],
-    ) -> Message:
+    ) -> MessageCreate:
         text_chat_history = [f"{message.name or 'user'}: {message.content[0].text}" for message in chat_history]
         for message in new_messages:
             text_chat_history.append(f"{message.name or 'user'}: {message.content}")
@@ -264,14 +266,11 @@ class DynamicMultiAgent(Agent):
             "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,
+        return MessageCreate(
             role="user",
             content=[TextContent(text=message_text)],
             name=None,
-            model=None,
-            tool_calls=None,
-            tool_call_id=None,
-            group_id=self.group_id,
             otid=Message.generate_otid(),
+            sender_id=manager_agent_id,
+            group_id=self.group_id,
         )

letta/groups/round_robin_multi_agent.py

@@ -29,7 +29,7 @@ class RoundRobinMultiAgent(Agent):
 
     def step(
         self,
-        messages: List[MessageCreate],
+        input_messages: List[MessageCreate],
         chaining: bool = True,
         max_chaining_steps: Optional[int] = None,
         put_inner_thoughts_first: bool = True,
@@ -37,46 +37,39 @@ class RoundRobinMultiAgent(Agent):
     ) -> LettaUsageStatistics:
         total_usage = UsageStatistics()
         step_count = 0
+        speaker_id = None
 
+        # Load settings
         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 = {}
+        # Load agents and initialize chat history with indexing
+        agents, message_index = {}, {}
+        chat_history: List[MessageCreate] = []
         for agent_id in self.agent_ids:
             agents[agent_id] = self.load_participant_agent(agent_id=agent_id)
+            message_index[agent_id] = 0
+
+        # Prepare new messages
+        new_messages = []
+        for message in input_messages:
+            if isinstance(message.content, str):
+                message.content = [TextContent(text=message.content)]
+            message.group_id = self.group_id
+            new_messages.append(message)
 
-        message_index = {agent_id: 0 for agent_id in self.agent_ids}
-        chat_history: List[Message] = []
-        new_messages = messages
-        speaker_id = None
         try:
             for i in range(self.max_turns):
+                # Select speaker
                 speaker_id = self.agent_ids[i % len(self.agent_ids)]
-                # initialize input messages
-                start_index = message_index[speaker_id] if speaker_id in message_index else 0
-                for message in chat_history[start_index:]:
-                    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,
-                            otid=message.otid,
-                        )
-                    )
 
-                # load agent and perform step
+                # Update chat history
+                chat_history.extend(new_messages)
+
+                # Perform participant step
                 participant_agent = agents[speaker_id]
                 usage_stats = participant_agent.step(
-                    messages=chat_history[start_index:],
+                    input_messages=chat_history[message_index[speaker_id] :],
                     chaining=chaining,
                     max_chaining_steps=max_chaining_steps,
                     stream=token_streaming,
@@ -85,47 +78,48 @@ class RoundRobinMultiAgent(Agent):
                     put_inner_thoughts_first=put_inner_thoughts_first,
                 )
 
-                # parse new messages for next step
+                # Parse participant response
                 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=message.name,
+                        content=[TextContent(text=message.content)] if isinstance(message.content, str) else message.content,
+                        name=participant_agent.agent_state.name,
                         otid=message.otid,
+                        sender_id=participant_agent.agent_state.id,
+                        group_id=self.group_id,
                     )
                     for message in assistant_messages
                 ]
+
+                # Update message index
                 message_index[speaker_id] = len(chat_history) + len(new_messages)
 
-                # sum usage
+                # 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
 
-            # 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,
-                    )
-                )
+            # Persist remaining chat history
+            chat_history.extend(new_messages)
             for agent_id, index in message_index.items():
                 if agent_id == speaker_id:
                     continue
+                messages_to_persist = []
                 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)
+                    message_to_persist = Message(
+                        role=message.role,
+                        content=message.content,
+                        name=message.name,
+                        otid=message.otid,
+                        sender_id=message.sender_id,
+                        group_id=self.group_id,
+                        agent_id=agent_id,
+                    )
+                    messages_to_persist.append(message_to_persist)
+                self.message_manager.create_many_messages(messages_to_persist, actor=self.user)
 
         except Exception as e:
             raise e

letta/groups/sleeptime_multi_agent.py

@@ -143,8 +143,21 @@ class SleeptimeMultiAgent(Agent):
                     group_id=self.group_id,
                 )
             ]
+
+            # Convert Message objects to MessageCreate objects
+            message_creates = [
+                MessageCreate(
+                    role=m.role,
+                    content=m.content[0].text if m.content and len(m.content) == 1 else m.content,
+                    name=m.name,
+                    otid=m.otid,
+                    sender_id=m.sender_id,
+                )
+                for m in participant_agent_messages
+            ]
+
             result = participant_agent.step(
-                messages=participant_agent_messages,
+                input_messages=message_creates,
                 chaining=chaining,
                 max_chaining_steps=max_chaining_steps,
                 stream=token_streaming,
@@ -173,7 +186,7 @@ class SleeptimeMultiAgent(Agent):
 
     def step(
         self,
-        messages: List[MessageCreate],
+        input_messages: List[MessageCreate],
         chaining: bool = True,
         max_chaining_steps: Optional[int] = None,
         put_inner_thoughts_first: bool = True,
@@ -181,33 +194,28 @@ class SleeptimeMultiAgent(Agent):
     ) -> LettaUsageStatistics:
         run_ids = []
 
+        # Load settings
         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
 
-        messages = [
-            Message(
-                id=Message.generate_id(),
-                agent_id=self.agent_state.id,
-                role=message.role,
-                content=[TextContent(text=message.content)] if isinstance(message.content, str) else message.content,
-                name=message.name,
-                model=None,
-                tool_calls=None,
-                tool_call_id=None,
-                group_id=self.group_id,
-                otid=message.otid,
-            )
-            for message in messages
-        ]
+        # Prepare new messages
+        new_messages = []
+        for message in input_messages:
+            if isinstance(message.content, str):
+                message.content = [TextContent(text=message.content)]
+            message.group_id = self.group_id
+            new_messages.append(message)
 
         try:
+            # Load main agent
             main_agent = Agent(
                 agent_state=self.agent_state,
                 interface=self.interface,
                 user=self.user,
             )
+            # Perform main agent step
             usage_stats = main_agent.step(
-                messages=messages,
+                input_messages=new_messages,
                 chaining=chaining,
                 max_chaining_steps=max_chaining_steps,
                 stream=token_streaming,
@@ -216,10 +224,12 @@ class SleeptimeMultiAgent(Agent):
                 put_inner_thoughts_first=put_inner_thoughts_first,
             )
 
+            # Update turns counter
             turns_counter = None
             if self.sleeptime_agent_frequency is not None and self.sleeptime_agent_frequency > 0:
                 turns_counter = self.group_manager.bump_turns_counter(group_id=self.group_id, actor=self.user)
 
+            # Perform participant steps
             if self.sleeptime_agent_frequency is None or (
                 turns_counter is not None and turns_counter % self.sleeptime_agent_frequency == 0
             ):