letta-nightly 0.6.45.dev20250328104141__py3-none-any.whl → 0.6.46.dev20250330050944__py3-none-any.whl

letta/server/server.py

@@ -90,7 +90,7 @@ from letta.services.provider_manager import ProviderManager
 from letta.services.sandbox_config_manager import SandboxConfigManager
 from letta.services.source_manager import SourceManager
 from letta.services.step_manager import StepManager
-from letta.services.tool_execution_sandbox import ToolExecutionSandbox
+from letta.services.tool_executor.tool_execution_sandbox import ToolExecutionSandbox
 from letta.services.tool_manager import ToolManager
 from letta.services.user_manager import UserManager
 from letta.settings import model_settings, settings, tool_settings
@@ -367,6 +367,9 @@ class SyncServer(Server):
     def load_multi_agent(
         self, group: Group, actor: User, interface: Union[AgentInterface, None] = None, agent_state: Optional[AgentState] = None
     ) -> Agent:
+        if len(group.agent_ids) == 0:
+            raise ValueError("Empty group: group must have at least one agent")
+
         match group.manager_type:
             case ManagerType.round_robin:
                 agent_state = agent_state or self.agent_manager.get_agent_by_id(agent_id=group.agent_ids[0], actor=actor)
@@ -862,6 +865,7 @@ class SyncServer(Server):
         after: Optional[str] = None,
         before: Optional[str] = None,
         limit: Optional[int] = 100,
+        group_id: Optional[str] = None,
         reverse: Optional[bool] = False,
         return_message_object: bool = True,
         use_assistant_message: bool = True,
@@ -879,6 +883,7 @@ class SyncServer(Server):
             before=before,
             limit=limit,
             ascending=not reverse,
+            group_id=group_id,
         )
 
         if not return_message_object:
@@ -1591,88 +1596,76 @@ class SyncServer(Server):
     ) -> Union[StreamingResponse, LettaResponse]:
         include_final_message = True
         if not stream_steps and stream_tokens:
-            raise HTTPException(status_code=400, detail="stream_steps must be 'true' if stream_tokens is 'true'")
-
-        try:
-            # fetch the group
-            group = self.group_manager.retrieve_group(group_id=group_id, actor=actor)
-            letta_multi_agent = self.load_multi_agent(group=group, actor=actor)
-
-            llm_config = letta_multi_agent.agent_state.llm_config
-            supports_token_streaming = ["openai", "anthropic", "deepseek"]
-            if stream_tokens and (
-                llm_config.model_endpoint_type not in supports_token_streaming or "inference.memgpt.ai" in llm_config.model_endpoint
-            ):
-                warnings.warn(
-                    f"Token streaming is only supported for models with type {' or '.join(supports_token_streaming)} in the model_endpoint: agent has endpoint type {llm_config.model_endpoint_type} and {llm_config.model_endpoint}. Setting stream_tokens to False."
-                )
-                stream_tokens = False
-
-            # Create a new interface per request
-            letta_multi_agent.interface = StreamingServerInterface(
-                use_assistant_message=use_assistant_message,
-                assistant_message_tool_name=assistant_message_tool_name,
-                assistant_message_tool_kwarg=assistant_message_tool_kwarg,
-                inner_thoughts_in_kwargs=(
-                    llm_config.put_inner_thoughts_in_kwargs if llm_config.put_inner_thoughts_in_kwargs is not None else False
-                ),
+            raise ValueError("stream_steps must be 'true' if stream_tokens is 'true'")
+
+        group = self.group_manager.retrieve_group(group_id=group_id, actor=actor)
+        letta_multi_agent = self.load_multi_agent(group=group, actor=actor)
+
+        llm_config = letta_multi_agent.agent_state.llm_config
+        supports_token_streaming = ["openai", "anthropic", "deepseek"]
+        if stream_tokens and (
+            llm_config.model_endpoint_type not in supports_token_streaming or "inference.memgpt.ai" in llm_config.model_endpoint
+        ):
+            warnings.warn(
+                f"Token streaming is only supported for models with type {' or '.join(supports_token_streaming)} in the model_endpoint: agent has endpoint type {llm_config.model_endpoint_type} and {llm_config.model_endpoint}. Setting stream_tokens to False."
             )
-            streaming_interface = letta_multi_agent.interface
-            if not isinstance(streaming_interface, StreamingServerInterface):
-                raise ValueError(f"Agent has wrong type of interface: {type(streaming_interface)}")
-            streaming_interface.streaming_mode = stream_tokens
-            streaming_interface.streaming_chat_completion_mode = chat_completion_mode
-            if metadata and hasattr(streaming_interface, "metadata"):
-                streaming_interface.metadata = metadata
-
-            streaming_interface.stream_start()
-            task = asyncio.create_task(
-                asyncio.to_thread(
-                    letta_multi_agent.step,
-                    messages=messages,
-                    chaining=self.chaining,
-                    max_chaining_steps=self.max_chaining_steps,
-                )
+            stream_tokens = False
+
+        # Create a new interface per request
+        letta_multi_agent.interface = StreamingServerInterface(
+            use_assistant_message=use_assistant_message,
+            assistant_message_tool_name=assistant_message_tool_name,
+            assistant_message_tool_kwarg=assistant_message_tool_kwarg,
+            inner_thoughts_in_kwargs=(
+                llm_config.put_inner_thoughts_in_kwargs if llm_config.put_inner_thoughts_in_kwargs is not None else False
+            ),
+        )
+        streaming_interface = letta_multi_agent.interface
+        if not isinstance(streaming_interface, StreamingServerInterface):
+            raise ValueError(f"Agent has wrong type of interface: {type(streaming_interface)}")
+        streaming_interface.streaming_mode = stream_tokens
+        streaming_interface.streaming_chat_completion_mode = chat_completion_mode
+        if metadata and hasattr(streaming_interface, "metadata"):
+            streaming_interface.metadata = metadata
+
+        streaming_interface.stream_start()
+        task = asyncio.create_task(
+            asyncio.to_thread(
+                letta_multi_agent.step,
+                messages=messages,
+                chaining=self.chaining,
+                max_chaining_steps=self.max_chaining_steps,
             )
+        )
 
-            if stream_steps:
-                # return a stream
-                return StreamingResponse(
-                    sse_async_generator(
-                        streaming_interface.get_generator(),
-                        usage_task=task,
-                        finish_message=include_final_message,
-                    ),
-                    media_type="text/event-stream",
-                )
-
-            else:
-                # buffer the stream, then return the list
-                generated_stream = []
-                async for message in streaming_interface.get_generator():
-                    assert (
-                        isinstance(message, LettaMessage)
-                        or isinstance(message, LegacyLettaMessage)
-                        or isinstance(message, MessageStreamStatus)
-                    ), type(message)
-                    generated_stream.append(message)
-                    if message == MessageStreamStatus.done:
-                        break
+        if stream_steps:
+            # return a stream
+            return StreamingResponse(
+                sse_async_generator(
+                    streaming_interface.get_generator(),
+                    usage_task=task,
+                    finish_message=include_final_message,
+                ),
+                media_type="text/event-stream",
+            )
 
-                # Get rid of the stream status messages
-                filtered_stream = [d for d in generated_stream if not isinstance(d, MessageStreamStatus)]
-                usage = await task
+        else:
+            # buffer the stream, then return the list
+            generated_stream = []
+            async for message in streaming_interface.get_generator():
+                assert (
+                    isinstance(message, LettaMessage) or isinstance(message, LegacyLettaMessage) or isinstance(message, MessageStreamStatus)
+                ), type(message)
+                generated_stream.append(message)
+                if message == MessageStreamStatus.done:
+                    break
 
-                # By default the stream will be messages of type LettaMessage or LettaLegacyMessage
-                # If we want to convert these to Message, we can use the attached IDs
-                # NOTE: we will need to de-duplicate the Messsage IDs though (since Assistant->Inner+Func_Call)
-                # TODO: eventually update the interface to use `Message` and `MessageChunk` (new) inside the deque instead
-                return LettaResponse(messages=filtered_stream, usage=usage)
-        except HTTPException:
-            raise
-        except Exception as e:
-            print(e)
-            import traceback
+            # Get rid of the stream status messages
+            filtered_stream = [d for d in generated_stream if not isinstance(d, MessageStreamStatus)]
+            usage = await task
 
-            traceback.print_exc()
-            raise HTTPException(status_code=500, detail=f"{e}")
+            # By default the stream will be messages of type LettaMessage or LettaLegacyMessage
+            # If we want to convert these to Message, we can use the attached IDs
+            # NOTE: we will need to de-duplicate the Messsage IDs though (since Assistant->Inner+Func_Call)
+            # TODO: eventually update the interface to use `Message` and `MessageChunk` (new) inside the deque instead
+            return LettaResponse(messages=filtered_stream, usage=usage)

letta/server/startup.sh

@@ -73,6 +73,6 @@ cleanup() {
 }
 trap cleanup EXIT
 
-echo "Starting Letta server at http://$HOST:$PORT..."
+echo "Starting Letta Server at http://$HOST:$PORT..."
 echo "Executing: $CMD"
 exec $CMD

letta/services/agent_manager.py

@@ -773,6 +773,13 @@ class AgentManager:
 
         return agent_state
 
+    @enforce_types
+    def refresh_memory(self, agent_state: PydanticAgentState, actor: PydanticUser) -> PydanticAgentState:
+        agent_state.memory.blocks = self.block_manager.get_all_blocks_by_ids(
+            block_ids=[b.id for b in agent_state.memory.blocks], actor=actor
+        )
+        return agent_state
+
     # ======================================================================================================================
     # Source Management
     # ======================================================================================================================

letta/services/group_manager.py

@@ -7,7 +7,9 @@ from letta.orm.errors import NoResultFound
 from letta.orm.group import Group as GroupModel
 from letta.orm.message import Message as MessageModel
 from letta.schemas.group import Group as PydanticGroup
-from letta.schemas.group import GroupCreate, ManagerType
+from letta.schemas.group import GroupCreate, GroupUpdate, ManagerType
+from letta.schemas.letta_message import LettaMessage
+from letta.schemas.message import Message as PydanticMessage
 from letta.schemas.user import User as PydanticUser
 from letta.utils import enforce_types
 
@@ -22,12 +24,12 @@ class GroupManager:
     @enforce_types
     def list_groups(
         self,
+        actor: PydanticUser,
         project_id: Optional[str] = None,
         manager_type: Optional[ManagerType] = None,
         before: Optional[str] = None,
         after: Optional[str] = None,
         limit: Optional[int] = 50,
-        actor: PydanticUser = None,
     ) -> list[PydanticGroup]:
         with self.session_maker() as session:
             filters = {"organization_id": actor.organization_id}
@@ -56,26 +58,65 @@ class GroupManager:
             new_group = GroupModel()
             new_group.organization_id = actor.organization_id
             new_group.description = group.description
+
+            match group.manager_config.manager_type:
+                case ManagerType.round_robin:
+                    new_group.manager_type = ManagerType.round_robin
+                    new_group.max_turns = group.manager_config.max_turns
+                case ManagerType.dynamic:
+                    new_group.manager_type = ManagerType.dynamic
+                    new_group.manager_agent_id = group.manager_config.manager_agent_id
+                    new_group.max_turns = group.manager_config.max_turns
+                    new_group.termination_token = group.manager_config.termination_token
+                case ManagerType.supervisor:
+                    new_group.manager_type = ManagerType.supervisor
+                    new_group.manager_agent_id = group.manager_config.manager_agent_id
+                case _:
+                    raise ValueError(f"Unsupported manager type: {group.manager_config.manager_type}")
+
             self._process_agent_relationship(session=session, group=new_group, agent_ids=group.agent_ids, allow_partial=False)
-            if group.manager_config is None:
-                new_group.manager_type = ManagerType.round_robin
-            else:
-                match group.manager_config.manager_type:
+
+            new_group.create(session, actor=actor)
+            return new_group.to_pydantic()
+
+    @enforce_types
+    def modify_group(self, group_id: str, group_update: GroupUpdate, actor: PydanticUser) -> PydanticGroup:
+        with self.session_maker() as session:
+            group = GroupModel.read(db_session=session, identifier=group_id, actor=actor)
+
+            max_turns = None
+            termination_token = None
+            manager_agent_id = None
+            if group_update.manager_config:
+                if group_update.manager_config.manager_type != group.manager_type:
+                    raise ValueError(f"Cannot change group pattern after creation")
+                match group_update.manager_config.manager_type:
                     case ManagerType.round_robin:
-                        new_group.manager_type = ManagerType.round_robin
-                        new_group.max_turns = group.manager_config.max_turns
+                        max_turns = group_update.manager_config.max_turns
                     case ManagerType.dynamic:
-                        new_group.manager_type = ManagerType.dynamic
-                        new_group.manager_agent_id = group.manager_config.manager_agent_id
-                        new_group.max_turns = group.manager_config.max_turns
-                        new_group.termination_token = group.manager_config.termination_token
+                        manager_agent_id = group_update.manager_config.manager_agent_id
+                        max_turns = group_update.manager_config.max_turns
+                        termination_token = group_update.manager_config.termination_token
                     case ManagerType.supervisor:
-                        new_group.manager_type = ManagerType.supervisor
-                        new_group.manager_agent_id = group.manager_config.manager_agent_id
+                        manager_agent_id = group_update.manager_config.manager_agent_id
                     case _:
-                        raise ValueError(f"Unsupported manager type: {group.manager_config.manager_type}")
-            new_group.create(session, actor=actor)
-            return new_group.to_pydantic()
+                        raise ValueError(f"Unsupported manager type: {group_update.manager_config.manager_type}")
+
+            if max_turns:
+                group.max_turns = max_turns
+            if termination_token:
+                group.termination_token = termination_token
+            if manager_agent_id:
+                group.manager_agent_id = manager_agent_id
+            if group_update.description:
+                group.description = group_update.description
+            if group_update.agent_ids:
+                self._process_agent_relationship(
+                    session=session, group=group, agent_ids=group_update.agent_ids, allow_partial=False, replace=True
+                )
+
+            group.update(session, actor=actor)
+            return group.to_pydantic()
 
     @enforce_types
     def delete_group(self, group_id: str, actor: PydanticUser) -> None:
@@ -87,23 +128,19 @@ class GroupManager:
     @enforce_types
     def list_group_messages(
         self,
+        actor: PydanticUser,
         group_id: Optional[str] = None,
         before: Optional[str] = None,
         after: Optional[str] = None,
         limit: Optional[int] = 50,
-        actor: PydanticUser = None,
         use_assistant_message: bool = True,
         assistant_message_tool_name: str = "send_message",
         assistant_message_tool_kwarg: str = "message",
-    ) -> list[PydanticGroup]:
+    ) -> list[LettaMessage]:
         with self.session_maker() as session:
-            group = GroupModel.read(db_session=session, identifier=group_id, actor=actor)
-            agent_id = group.manager_agent_id if group.manager_agent_id else group.agent_ids[0]
-
             filters = {
                 "organization_id": actor.organization_id,
                 "group_id": group_id,
-                "agent_id": agent_id,
             }
             messages = MessageModel.list(
                 db_session=session,
@@ -114,21 +151,39 @@ class GroupManager:
             )
 
             messages = PydanticMessage.to_letta_messages_from_list(
-                messages=messages,
+                messages=[msg.to_pydantic() for msg in messages],
                 use_assistant_message=use_assistant_message,
                 assistant_message_tool_name=assistant_message_tool_name,
                 assistant_message_tool_kwarg=assistant_message_tool_kwarg,
             )
 
+            # TODO: filter messages to return a clean conversation history
+
             return messages
 
+    @enforce_types
+    def reset_messages(self, group_id: str, actor: PydanticUser) -> None:
+        with self.session_maker() as session:
+            # Ensure group is loadable by user
+            group = GroupModel.read(db_session=session, identifier=group_id, actor=actor)
+
+            # Delete all messages in the group
+            session.query(MessageModel).filter(
+                MessageModel.organization_id == actor.organization_id, MessageModel.group_id == group_id
+            ).delete(synchronize_session=False)
+
+            session.commit()
+
     def _process_agent_relationship(self, session: Session, group: GroupModel, agent_ids: List[str], allow_partial=False, replace=True):
-        current_relationship = getattr(group, "agents", [])
         if not agent_ids:
             if replace:
                 setattr(group, "agents", [])
+                setattr(group, "agent_ids", [])
             return
 
+        if group.manager_type == ManagerType.dynamic and len(agent_ids) != len(set(agent_ids)):
+            raise ValueError("Duplicate agent ids found in list")
+
         # Retrieve models for the provided IDs
         found_items = session.query(AgentModel).filter(AgentModel.id.in_(agent_ids)).all()
 
@@ -137,11 +192,14 @@ class GroupManager:
             missing = set(agent_ids) - {item.id for item in found_items}
             raise NoResultFound(f"Items not found in agents: {missing}")
 
+        if group.manager_type == ManagerType.dynamic:
+            names = [item.name for item in found_items]
+            if len(names) != len(set(names)):
+                raise ValueError("Duplicate agent names found in the provided agent IDs.")
+
         if replace:
             # Replace the relationship
             setattr(group, "agents", found_items)
+            setattr(group, "agent_ids", agent_ids)
         else:
-            # Extend the relationship (only add new items)
-            current_ids = {item.id for item in current_relationship}
-            new_items = [item for item in found_items if item.id not in current_ids]
-            current_relationship.extend(new_items)
+            raise ValueError("Extend relationship is not supported for groups.")

letta/services/message_manager.py

@@ -264,6 +264,7 @@ class MessageManager:
         roles: Optional[Sequence[MessageRole]] = None,
         limit: Optional[int] = 50,
         ascending: bool = True,
+        group_id: Optional[str] = None,
     ) -> List[PydanticMessage]:
         """
         Most performant query to list messages for an agent by directly querying the Message table.
@@ -296,6 +297,10 @@ class MessageManager:
             # Build a query that directly filters the Message table by agent_id.
             query = session.query(MessageModel).filter(MessageModel.agent_id == agent_id)
 
+            # If group_id is provided, filter messages by group_id.
+            if group_id:
+                query = query.filter(MessageModel.group_id == group_id)
+
             # If query_text is provided, filter messages using subquery.
             if query_text:
                 content_element = func.json_array_elements(MessageModel.content).alias("content_element")