letta-nightly 0.11.7.dev20251007104119__py3-none-any.whl → 0.11.7.dev20251008104128__py3-none-any.whl

letta/services/group_manager.py

@@ -60,13 +60,6 @@ class GroupManager:
             groups = result.scalars().all()
             return [group.to_pydantic() for group in groups]
 
-    @enforce_types
-    @trace_method
-    def retrieve_group(self, group_id: str, actor: PydanticUser) -> PydanticGroup:
-        with db_registry.session() as session:
-            group = GroupModel.read(db_session=session, identifier=group_id, actor=actor)
-            return group.to_pydantic()
-
     @enforce_types
     @trace_method
     async def retrieve_group_async(self, group_id: str, actor: PydanticUser) -> PydanticGroup:
@@ -74,57 +67,6 @@ class GroupManager:
             group = await GroupModel.read_async(db_session=session, identifier=group_id, actor=actor)
             return group.to_pydantic()
 
-    @enforce_types
-    @trace_method
-    def create_group(self, group: Union[GroupCreate, InternalTemplateGroupCreate], actor: PydanticUser) -> PydanticGroup:
-        with db_registry.session() as session:
-            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 ManagerType.sleeptime:
-                    new_group.manager_type = ManagerType.sleeptime
-                    new_group.manager_agent_id = group.manager_config.manager_agent_id
-                    new_group.sleeptime_agent_frequency = group.manager_config.sleeptime_agent_frequency
-                    if new_group.sleeptime_agent_frequency:
-                        new_group.turns_counter = -1
-                case ManagerType.voice_sleeptime:
-                    new_group.manager_type = ManagerType.voice_sleeptime
-                    new_group.manager_agent_id = group.manager_config.manager_agent_id
-                    max_message_buffer_length = group.manager_config.max_message_buffer_length
-                    min_message_buffer_length = group.manager_config.min_message_buffer_length
-                    # Safety check for buffer length range
-                    self.ensure_buffer_length_range_valid(max_value=max_message_buffer_length, min_value=min_message_buffer_length)
-                    new_group.max_message_buffer_length = max_message_buffer_length
-                    new_group.min_message_buffer_length = min_message_buffer_length
-                case _:
-                    raise ValueError(f"Unsupported manager type: {group.manager_config.manager_type}")
-
-            if isinstance(group, InternalTemplateGroupCreate):
-                new_group.base_template_id = group.base_template_id
-                new_group.template_id = group.template_id
-                new_group.deployment_id = group.deployment_id
-
-            self._process_agent_relationship(session=session, group=new_group, agent_ids=group.agent_ids, allow_partial=False)
-
-            if group.shared_block_ids:
-                self._process_shared_block_relationship(session=session, group=new_group, block_ids=group.shared_block_ids)
-
-            new_group.create(session, actor=actor)
-            return new_group.to_pydantic()
-
     @enforce_types
     async def create_group_async(self, group: Union[GroupCreate, InternalTemplateGroupCreate], actor: PydanticUser) -> PydanticGroup:
         async with db_registry.async_session() as session:
@@ -238,14 +180,6 @@ class GroupManager:
             await group.update_async(session, actor=actor)
             return group.to_pydantic()
 
-    @enforce_types
-    @trace_method
-    def delete_group(self, group_id: str, actor: PydanticUser) -> None:
-        with db_registry.session() as session:
-            # Retrieve the agent
-            group = GroupModel.read(db_session=session, identifier=group_id, actor=actor)
-            group.hard_delete(session)
-
     @enforce_types
     @trace_method
     async def delete_group_async(self, group_id: str, actor: PydanticUser) -> None:
@@ -253,43 +187,6 @@ class GroupManager:
             group = await GroupModel.read_async(db_session=session, identifier=group_id, actor=actor)
             await group.hard_delete_async(session)
 
-    @enforce_types
-    @trace_method
-    def list_group_messages(
-        self,
-        actor: PydanticUser,
-        group_id: Optional[str] = None,
-        before: Optional[str] = None,
-        after: Optional[str] = None,
-        limit: Optional[int] = 50,
-        use_assistant_message: bool = True,
-        assistant_message_tool_name: str = "send_message",
-        assistant_message_tool_kwarg: str = "message",
-    ) -> list[LettaMessage]:
-        with db_registry.session() as session:
-            filters = {
-                "organization_id": actor.organization_id,
-                "group_id": group_id,
-            }
-            messages = MessageModel.list(
-                db_session=session,
-                before=before,
-                after=after,
-                limit=limit,
-                **filters,
-            )
-
-            messages = PydanticMessage.to_letta_messages_from_list(
-                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
     @trace_method
     async def list_group_messages_async(
@@ -327,20 +224,6 @@ class GroupManager:
 
             return messages
 
-    @enforce_types
-    @trace_method
-    def reset_messages(self, group_id: str, actor: PydanticUser) -> None:
-        with db_registry.session() 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()
-
     @enforce_types
     @trace_method
     async def reset_messages_async(self, group_id: str, actor: PydanticUser) -> None:
@@ -356,18 +239,6 @@ class GroupManager:
 
             await session.commit()
 
-    @enforce_types
-    @trace_method
-    def bump_turns_counter(self, group_id: str, actor: PydanticUser) -> int:
-        with db_registry.session() as session:
-            # Ensure group is loadable by user
-            group = GroupModel.read(db_session=session, identifier=group_id, actor=actor)
-
-            # Update turns counter
-            group.turns_counter = (group.turns_counter + 1) % group.sleeptime_agent_frequency
-            group.update(session, actor=actor)
-            return group.turns_counter
-
     @enforce_types
     @trace_method
     async def bump_turns_counter_async(self, group_id: str, actor: PydanticUser) -> int:
@@ -380,19 +251,6 @@ class GroupManager:
             await group.update_async(session, actor=actor)
             return group.turns_counter
 
-    @enforce_types
-    def get_last_processed_message_id_and_update(self, group_id: str, last_processed_message_id: str, actor: PydanticUser) -> str:
-        with db_registry.session() as session:
-            # Ensure group is loadable by user
-            group = GroupModel.read(db_session=session, identifier=group_id, actor=actor)
-
-            # Update last processed message id
-            prev_last_processed_message_id = group.last_processed_message_id
-            group.last_processed_message_id = last_processed_message_id
-            group.update(session, actor=actor)
-
-            return prev_last_processed_message_id
-
     @enforce_types
     @trace_method
     async def get_last_processed_message_id_and_update_async(

letta/services/helpers/agent_manager_helper.py

@@ -19,6 +19,7 @@ from letta.constants import (
     MULTI_AGENT_TOOLS,
     STRUCTURED_OUTPUT_MODELS,
 )
+from letta.errors import LettaAgentNotFoundError
 from letta.helpers import ToolRulesSolver
 from letta.helpers.datetime_helpers import get_local_time
 from letta.llm_api.llm_client import LLMClient
@@ -206,6 +207,10 @@ def derive_system_message(agent_type: AgentType, enable_sleeptime: Optional[bool
         elif agent_type == AgentType.react_agent:
             system = gpt_system.get_system_text("react")
 
+        # Letta v1
+        elif agent_type == AgentType.letta_v1_agent:
+            system = gpt_system.get_system_text("letta_v1")
+
         # Workflow
         elif agent_type == AgentType.workflow_agent:
             system = gpt_system.get_system_text("workflow")
@@ -419,7 +424,7 @@ async def initialize_message_sequence_async(
         # Some LMStudio models (e.g. ministral) require the tool call ID to be 9 alphanumeric characters
         tool_call_id = uuid_str[:9] if llm_config.provider_name == "lmstudio_openai" else uuid_str
 
-        if agent_state.agent_type == AgentType.sleeptime_agent:
+        if agent_state.agent_type == AgentType.sleeptime_agent or agent_state.agent_type == AgentType.letta_v1_agent:
             initial_boot_messages = []
         elif llm_config.model is not None and "gpt-3.5" in llm_config.model:
             initial_boot_messages = get_initial_boot_messages("startup_with_send_message_gpt35", agent_state.timezone, tool_call_id)
@@ -1238,4 +1243,4 @@ async def validate_agent_exists_async(session, agent_id: str, actor: User) -> No
     result = await session.execute(agent_exists_query)
 
     if not result.scalar():
-        raise NoResultFound(f"Agent with ID {agent_id} not found")
+        raise LettaAgentNotFoundError(f"Agent with ID {agent_id} not found")

letta/services/helpers/run_manager_helper.py

@@ -0,0 +1,85 @@
+from datetime import datetime
+from typing import Optional
+
+from sqlalchemy import asc, desc, nulls_last, select
+from letta.settings import DatabaseChoice, settings
+
+from letta.orm.run import Run as RunModel
+from letta.settings import DatabaseChoice, settings
+from sqlalchemy import asc, desc
+from typing import Optional
+
+from letta.services.helpers.agent_manager_helper import _cursor_filter
+
+
+async def _apply_pagination_async(
+    query,
+    before: Optional[str],
+    after: Optional[str],
+    session,
+    ascending: bool = True,
+    sort_by: str = "created_at",
+) -> any:
+    # Determine the sort column
+    if sort_by == "last_run_completion":
+        sort_column = RunModel.last_run_completion
+        sort_nulls_last = True  # TODO: handle this as a query param eventually
+    else:
+        sort_column = RunModel.created_at
+        sort_nulls_last = False
+
+    if after:
+        result = (
+            await session.execute(
+                select(sort_column, RunModel.id).where(RunModel.id == after)
+            )
+        ).first()
+        if result:
+            after_sort_value, after_id = result
+            # SQLite does not support as granular timestamping, so we need to round the timestamp
+            if settings.database_engine is DatabaseChoice.SQLITE and isinstance(
+                after_sort_value, datetime
+            ):
+                after_sort_value = after_sort_value.strftime("%Y-%m-%d %H:%M:%S")
+            query = query.where(
+                _cursor_filter(
+                    sort_column,
+                    RunModel.id,
+                    after_sort_value,
+                    after_id,
+                    forward=ascending,
+                    nulls_last=sort_nulls_last,
+                )
+            )
+
+    if before:
+        result = (
+            await session.execute(
+                select(sort_column, RunModel.id).where(RunModel.id == before)
+            )
+        ).first()
+        if result:
+            before_sort_value, before_id = result
+            # SQLite does not support as granular timestamping, so we need to round the timestamp
+            if settings.database_engine is DatabaseChoice.SQLITE and isinstance(
+                before_sort_value, datetime
+            ):
+                before_sort_value = before_sort_value.strftime("%Y-%m-%d %H:%M:%S")
+            query = query.where(
+                _cursor_filter(
+                    sort_column,
+                    RunModel.id,
+                    before_sort_value,
+                    before_id,
+                    forward=not ascending,
+                    nulls_last=sort_nulls_last,
+                )
+            )
+
+    # Apply ordering
+    order_fn = asc if ascending else desc
+    query = query.order_by(
+        nulls_last(order_fn(sort_column)) if sort_nulls_last else order_fn(sort_column),
+        order_fn(RunModel.id),
+    )
+    return query