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

letta/services/group_manager.py

@@ -0,0 +1,147 @@
+from typing import List, Optional
+
+from sqlalchemy.orm import Session
+
+from letta.orm.agent import Agent as AgentModel
+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.user import User as PydanticUser
+from letta.utils import enforce_types
+
+
+class GroupManager:
+
+    def __init__(self):
+        from letta.server.db import db_context
+
+        self.session_maker = db_context
+
+    @enforce_types
+    def list_groups(
+        self,
+        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}
+            if project_id:
+                filters["project_id"] = project_id
+            if manager_type:
+                filters["manager_type"] = manager_type
+            groups = GroupModel.list(
+                db_session=session,
+                before=before,
+                after=after,
+                limit=limit,
+                **filters,
+            )
+            return [group.to_pydantic() for group in groups]
+
+    @enforce_types
+    def retrieve_group(self, group_id: str, actor: PydanticUser) -> PydanticGroup:
+        with self.session_maker() as session:
+            group = GroupModel.read(db_session=session, identifier=group_id, actor=actor)
+            return group.to_pydantic()
+
+    @enforce_types
+    def create_group(self, group: GroupCreate, actor: PydanticUser) -> PydanticGroup:
+        with self.session_maker() as session:
+            new_group = GroupModel()
+            new_group.organization_id = actor.organization_id
+            new_group.description = group.description
+            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:
+                    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}")
+            new_group.create(session, actor=actor)
+            return new_group.to_pydantic()
+
+    @enforce_types
+    def delete_group(self, group_id: str, actor: PydanticUser) -> None:
+        with self.session_maker() as session:
+            # Retrieve the agent
+            group = GroupModel.read(db_session=session, identifier=group_id, actor=actor)
+            group.hard_delete(session)
+
+    @enforce_types
+    def list_group_messages(
+        self,
+        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]:
+        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,
+                before=before,
+                after=after,
+                limit=limit,
+                **filters,
+            )
+
+            messages = PydanticMessage.to_letta_messages_from_list(
+                messages=messages,
+                use_assistant_message=use_assistant_message,
+                assistant_message_tool_name=assistant_message_tool_name,
+                assistant_message_tool_kwarg=assistant_message_tool_kwarg,
+            )
+
+            return messages
+
+    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", [])
+            return
+
+        # Retrieve models for the provided IDs
+        found_items = session.query(AgentModel).filter(AgentModel.id.in_(agent_ids)).all()
+
+        # Validate all items are found if allow_partial is False
+        if not allow_partial and len(found_items) != len(agent_ids):
+            missing = set(agent_ids) - {item.id for item in found_items}
+            raise NoResultFound(f"Items not found in agents: {missing}")
+
+        if replace:
+            # Replace the relationship
+            setattr(group, "agents", found_items)
+        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)

letta/services/helpers/agent_manager_helper.py

@@ -1,6 +1,8 @@
 import datetime
 from typing import List, Literal, Optional
 
+from sqlalchemy import and_, func, literal, or_, select
+
 from letta import system
 from letta.constants import IN_CONTEXT_MEMORY_KEYWORD, STRUCTURED_OUTPUT_MODELS
 from letta.helpers import ToolRulesSolver
@@ -8,11 +10,13 @@ from letta.helpers.datetime_helpers import get_local_time
 from letta.orm.agent import Agent as AgentModel
 from letta.orm.agents_tags import AgentsTags
 from letta.orm.errors import NoResultFound
+from letta.orm.identity import Identity
 from letta.prompts import gpt_system
 from letta.schemas.agent import AgentState, AgentType
 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, MessageCreate, TextContent
+from letta.schemas.message import Message, MessageCreate
 from letta.schemas.passage import Passage as PydanticPassage
 from letta.schemas.tool_rule import ToolRule
 from letta.schemas.user import User
@@ -293,3 +297,149 @@ def check_supports_structured_output(model: str, tool_rules: List[ToolRule]) ->
         return False
     else:
         return True
+
+
+def _apply_pagination(query, before: Optional[str], after: Optional[str], session) -> any:
+    """
+    Apply cursor-based pagination filters using the agent's created_at timestamp with id as a tie-breaker.
+
+    Instead of relying on the UUID ordering, this function uses the agent's creation time
+    (and id for tie-breaking) to paginate the results. It performs a minimal lookup to fetch
+    only the created_at and id for the agent corresponding to the provided cursor.
+
+    Args:
+        query: The SQLAlchemy query object to modify.
+        before (Optional[str]): Cursor (agent id) to return agents created before this agent.
+        after (Optional[str]): Cursor (agent id) to return agents created after this agent.
+        session: The active database session used to execute the minimal lookup.
+
+    Returns:
+        The modified query with pagination filters applied and ordered by created_at and id.
+    """
+    if after:
+        # Retrieve only the created_at and id for the agent corresponding to the 'after' cursor.
+        result = session.execute(select(AgentModel.created_at, AgentModel.id).where(AgentModel.id == after)).first()
+        if result:
+            after_created_at, after_id = result
+            # Filter: include agents created after the reference, or at the same time but with a greater id.
+            query = query.where(
+                or_(
+                    AgentModel.created_at > after_created_at,
+                    and_(
+                        AgentModel.created_at == after_created_at,
+                        AgentModel.id > after_id,
+                    ),
+                )
+            )
+    if before:
+        # Retrieve only the created_at and id for the agent corresponding to the 'before' cursor.
+        result = session.execute(select(AgentModel.created_at, AgentModel.id).where(AgentModel.id == before)).first()
+        if result:
+            before_created_at, before_id = result
+            # Filter: include agents created before the reference, or at the same time but with a smaller id.
+            query = query.where(
+                or_(
+                    AgentModel.created_at < before_created_at,
+                    and_(
+                        AgentModel.created_at == before_created_at,
+                        AgentModel.id < before_id,
+                    ),
+                )
+            )
+    # Enforce a deterministic ordering: first by created_at, then by id.
+    query = query.order_by(AgentModel.created_at.asc(), AgentModel.id.asc())
+    return query
+
+
+def _apply_tag_filter(query, tags: Optional[List[str]], match_all_tags: bool):
+    """
+    Apply tag-based filtering to the agent query.
+
+    This helper function creates a subquery that groups agent IDs by their tags.
+    If `match_all_tags` is True, it filters agents that have all of the specified tags.
+    Otherwise, it filters agents that have any of the tags.
+
+    Args:
+        query: The SQLAlchemy query object to be modified.
+        tags (Optional[List[str]]): A list of tags to filter agents.
+        match_all_tags (bool): If True, only return agents that match all provided tags.
+
+    Returns:
+        The modified query with tag filters applied.
+    """
+    if tags:
+        # Build a subquery to select agent IDs that have the specified tags.
+        subquery = select(AgentsTags.agent_id).where(AgentsTags.tag.in_(tags)).group_by(AgentsTags.agent_id)
+        # If all tags must match, add a HAVING clause to ensure the count of tags equals the number provided.
+        if match_all_tags:
+            subquery = subquery.having(func.count(AgentsTags.tag) == literal(len(tags)))
+        # Filter the main query to include only agents present in the subquery.
+        query = query.where(AgentModel.id.in_(subquery))
+    return query
+
+
+def _apply_identity_filters(query, identity_id: Optional[str], identifier_keys: Optional[List[str]]):
+    """
+    Apply identity-related filters to the agent query.
+
+    This helper function joins the identities relationship and filters the agents based on
+    a specific identity ID and/or a list of identifier keys.
+
+    Args:
+        query: The SQLAlchemy query object to be modified.
+        identity_id (Optional[str]): The identity ID to filter by.
+        identifier_keys (Optional[List[str]]): A list of identifier keys to filter agents.
+
+    Returns:
+        The modified query with identity filters applied.
+    """
+    # Join the identities relationship and filter by a specific identity ID.
+    if identity_id:
+        query = query.join(AgentModel.identities).where(Identity.id == identity_id)
+    # Join the identities relationship and filter by a set of identifier keys.
+    if identifier_keys:
+        query = query.join(AgentModel.identities).where(Identity.identifier_key.in_(identifier_keys))
+    return query
+
+
+def _apply_filters(
+    query,
+    name: Optional[str],
+    query_text: Optional[str],
+    project_id: Optional[str],
+    template_id: Optional[str],
+    base_template_id: Optional[str],
+):
+    """
+    Apply basic filtering criteria to the agent query.
+
+    This helper function adds WHERE clauses based on provided parameters such as
+    exact name, partial name match (using ILIKE), project ID, template ID, and base template ID.
+
+    Args:
+        query: The SQLAlchemy query object to be modified.
+        name (Optional[str]): Exact name to filter by.
+        query_text (Optional[str]): Partial text to search in the agent's name (case-insensitive).
+        project_id (Optional[str]): Filter for agents belonging to a specific project.
+        template_id (Optional[str]): Filter for agents using a specific template.
+        base_template_id (Optional[str]): Filter for agents using a specific base template.
+
+    Returns:
+        The modified query with the applied filters.
+    """
+    # Filter by exact agent name if provided.
+    if name:
+        query = query.where(AgentModel.name == name)
+    # Apply a case-insensitive partial match for the agent's name.
+    if query_text:
+        query = query.where(AgentModel.name.ilike(f"%{query_text}%"))
+    # Filter agents by project ID.
+    if project_id:
+        query = query.where(AgentModel.project_id == project_id)
+    # Filter agents by template ID.
+    if template_id:
+        query = query.where(AgentModel.template_id == template_id)
+    # Filter agents by base template ID.
+    if base_template_id:
+        query = query.where(AgentModel.base_template_id == base_template_id)
+    return query

letta/services/message_manager.py

@@ -1,7 +1,7 @@
 import json
 from typing import List, Optional
 
-from sqlalchemy import and_, or_
+from sqlalchemy import and_, exists, func, or_, select, text
 
 from letta.log import get_logger
 from letta.orm.agent import Agent as AgentModel
@@ -233,9 +233,17 @@ 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 query_text is provided, filter messages by partial match on text.
+            # If query_text is provided, filter messages using subquery.
             if query_text:
-                query = query.filter(MessageModel.text.ilike(f"%{query_text}%"))
+                content_element = func.json_array_elements(MessageModel.content).alias("content_element")
+                query = query.filter(
+                    exists(
+                        select(1)
+                        .select_from(content_element)
+                        .where(text("content_element->>'type' = 'text' AND content_element->>'text' ILIKE :query_text"))
+                        .params(query_text=f"%{query_text}%")
+                    )
+                )
 
             # If role is provided, filter messages by role.
             if role:

letta/services/passage_manager.py

@@ -203,3 +203,18 @@ class PassageManager:
         for passage in passages:
             self.delete_passage_by_id(passage_id=passage.id, actor=actor)
         return True
+
+    @enforce_types
+    def size(
+        self,
+        actor: PydanticUser,
+        agent_id: Optional[str] = None,
+    ) -> int:
+        """Get the total count of messages with optional filters.
+
+        Args:
+            actor: The user requesting the count
+            agent_id: The agent ID of the messages
+        """
+        with self.session_maker() as session:
+            return AgentPassage.size(db_session=session, actor=actor, agent_id=agent_id)

letta/settings.py

@@ -174,6 +174,11 @@ class Settings(BaseSettings):
     # telemetry logging
     verbose_telemetry_logging: bool = False
 
+    # uvicorn settings
+    uvicorn_workers: int = 1
+    uvicorn_reload: bool = False
+    uvicorn_timeout_keep_alive: int = 5
+
     @property
     def letta_pg_uri(self) -> str:
         if self.pg_uri:

letta/supervisor_multi_agent.py

@@ -0,0 +1,103 @@
+from typing import List, Optional
+
+from letta.agent import Agent, AgentState
+from letta.constants import DEFAULT_MESSAGE_TOOL
+from letta.functions.function_sets.multi_agent import send_message_to_all_agents_in_group
+from letta.interface import AgentInterface
+from letta.orm import User
+from letta.orm.enums import ToolType
+from letta.schemas.letta_message_content import TextContent
+from letta.schemas.message import Message, MessageCreate
+from letta.schemas.tool_rule import ChildToolRule, InitToolRule, TerminalToolRule
+from letta.schemas.usage import LettaUsageStatistics
+from letta.services.agent_manager import AgentManager
+from letta.services.tool_manager import ToolManager
+from tests.helpers.utils import create_tool_from_func
+
+
+class SupervisorMultiAgent(Agent):
+    def __init__(
+        self,
+        interface: AgentInterface,
+        agent_state: AgentState,
+        user: User = None,
+        # custom
+        group_id: str = "",
+        agent_ids: List[str] = [],
+        description: str = "",
+    ):
+        super().__init__(interface, agent_state, user)
+        self.group_id = group_id
+        self.agent_ids = agent_ids
+        self.description = description
+        self.agent_manager = AgentManager()
+        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,
+        assistant_message_tool_name: str = DEFAULT_MESSAGE_TOOL,
+        **kwargs,
+    ) -> LettaUsageStatistics:
+        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
+
+        # add multi agent tool
+        if self.tool_manager.get_tool_by_name(tool_name="send_message_to_all_agents_in_group", actor=self.user) is None:
+            multi_agent_tool = create_tool_from_func(send_message_to_all_agents_in_group)
+            multi_agent_tool.tool_type = ToolType.LETTA_MULTI_AGENT_CORE
+            multi_agent_tool = self.tool_manager.create_or_update_tool(
+                pydantic_tool=multi_agent_tool,
+                actor=self.user,
+            )
+            self.agent_state = self.agent_manager.attach_tool(agent_id=self.agent_state.id, tool_id=multi_agent_tool.id, actor=self.user)
+
+        # override tool rules
+        self.agent_state.tool_rules = [
+            InitToolRule(
+                tool_name="send_message_to_all_agents_in_group",
+            ),
+            TerminalToolRule(
+                tool_name=assistant_message_tool_name,
+            ),
+            ChildToolRule(
+                tool_name="send_message_to_all_agents_in_group",
+                children=[assistant_message_tool_name],
+            ),
+        ]
+
+        supervisor_messages = [
+            Message(
+                agent_id=self.agent_state.id,
+                role="user",
+                content=[TextContent(text=message.content)],
+                name=None,
+                model=None,
+                tool_calls=None,
+                tool_call_id=None,
+                group_id=self.group_id,
+            )
+            for message in messages
+        ]
+        try:
+            supervisor_agent = Agent(agent_state=self.agent_state, interface=self.interface, user=self.user)
+            usage_stats = supervisor_agent.step(
+                messages=supervisor_messages,
+                chaining=chaining,
+                max_chaining_steps=max_chaining_steps,
+                stream=token_streaming,
+                skip_verify=True,
+                metadata=metadata,
+                put_inner_thoughts_first=put_inner_thoughts_first,
+            )
+        except Exception as e:
+            raise e
+        finally:
+            self.interface.step_yield()
+
+        self.interface.step_complete()
+
+        return usage_stats

{letta_nightly-0.6.39.dev20250314104053.dist-info → letta_nightly-0.6.40.dev20250314173529.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.6.39.dev20250314104053
+Version: 0.6.40.dev20250314173529
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team
@@ -32,7 +32,6 @@ Requires-Dist: colorama (>=0.4.6,<0.5.0)
 Requires-Dist: composio-core (>=0.7.7,<0.8.0)
 Requires-Dist: composio-langchain (>=0.7.7,<0.8.0)
 Requires-Dist: datamodel-code-generator[http] (>=0.25.0,<0.26.0) ; extra == "desktop" or extra == "all"
-Requires-Dist: datasets (>=2.14.6,<3.0.0)
 Requires-Dist: demjson3 (>=3.0.6,<4.0.0)
 Requires-Dist: docker (>=7.1.0,<8.0.0) ; extra == "external-tools" or extra == "desktop" or extra == "all"
 Requires-Dist: docstring-parser (>=0.16,<0.17)