letta-nightly 0.6.2.dev20241210030252__tar.gz → 0.6.2.dev20241210104242__tar.gz

{letta_nightly-0.6.2.dev20241210030252 → letta_nightly-0.6.2.dev20241210104242}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.6.2.dev20241210030252
+Version: 0.6.2.dev20241210104242
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team

{letta_nightly-0.6.2.dev20241210030252 → letta_nightly-0.6.2.dev20241210104242}/letta/client/client.py

@@ -3128,7 +3128,7 @@ class LocalClient(AbstractClient):
         return self.server.get_agent_recall_cursor(
             user_id=self.user_id,
             agent_id=agent_id,
-            cursor=cursor,
+            before=cursor,
             limit=limit,
             reverse=True,
         )

{letta_nightly-0.6.2.dev20241210030252 → letta_nightly-0.6.2.dev20241210104242}/letta/orm/sqlalchemy_base.py

@@ -2,7 +2,7 @@ from datetime import datetime
 from enum import Enum
 from typing import TYPE_CHECKING, List, Literal, Optional, Type
 
-from sqlalchemy import String, func, select
+from sqlalchemy import String, desc, func, or_, select
 from sqlalchemy.exc import DBAPIError
 from sqlalchemy.orm import Mapped, Session, mapped_column
 
@@ -60,14 +60,25 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         end_date: Optional[datetime] = None,
         limit: Optional[int] = 50,
         query_text: Optional[str] = None,
+        ascending: bool = True,
         **kwargs,
     ) -> List[Type["SqlalchemyBase"]]:
-        """List records with advanced filtering and pagination options."""
+        """
+        List records with cursor-based pagination, ordering by created_at.
+        Cursor is an ID, but pagination is based on the cursor object's created_at value.
+        """
         if start_date and end_date and start_date > end_date:
             raise ValueError("start_date must be earlier than or equal to end_date")
 
         logger.debug(f"Listing {cls.__name__} with kwarg filters {kwargs}")
         with db_session as session:
+            # If cursor provided, get the reference object
+            cursor_obj = None
+            if cursor:
+                cursor_obj = session.get(cls, cursor)
+                if not cursor_obj:
+                    raise NoResultFound(f"No {cls.__name__} found with id {cursor}")
+
             query = select(cls)
 
             # Apply filtering logic
@@ -80,22 +91,38 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
 
             # Date range filtering
             if start_date:
-                query = query.filter(cls.created_at >= start_date)
+                query = query.filter(cls.created_at > start_date)
             if end_date:
-                query = query.filter(cls.created_at <= end_date)
-
-            # Cursor-based pagination
-            if cursor:
-                query = query.where(cls.id > cursor)
+                query = query.filter(cls.created_at < end_date)
+
+            # Cursor-based pagination using created_at
+            # TODO: There is a really nasty race condition issue here with Sqlite
+            # TODO: If they have the same created_at timestamp, this query does NOT match for whatever reason
+            if cursor_obj:
+                if ascending:
+                    query = query.where(cls.created_at >= cursor_obj.created_at).where(
+                        or_(cls.created_at > cursor_obj.created_at, cls.id > cursor_obj.id)
+                    )
+                else:
+                    query = query.where(cls.created_at <= cursor_obj.created_at).where(
+                        or_(cls.created_at < cursor_obj.created_at, cls.id < cursor_obj.id)
+                    )
 
             # Apply text search
             if query_text:
                 query = query.filter(func.lower(cls.text).contains(func.lower(query_text)))
 
-            # Handle ordering and soft deletes
+            # Handle soft deletes
             if hasattr(cls, "is_deleted"):
                 query = query.where(cls.is_deleted == False)
-            query = query.order_by(cls.id).limit(limit)
+
+            # Apply ordering by created_at
+            if ascending:
+                query = query.order_by(cls.created_at, cls.id)
+            else:
+                query = query.order_by(desc(cls.created_at), desc(cls.id))
+
+            query = query.limit(limit)
 
             return list(session.execute(query).scalars())
 

{letta_nightly-0.6.2.dev20241210030252 → letta_nightly-0.6.2.dev20241210104242}/letta/server/rest_api/routers/v1/agents.py

@@ -420,7 +420,7 @@ def get_agent_messages(
     return server.get_agent_recall_cursor(
         user_id=actor.id,
         agent_id=agent_id,
-        cursor=before,
+        before=before,
         limit=limit,
         reverse=True,
         return_message_object=msg_object,

{letta_nightly-0.6.2.dev20241210030252 → letta_nightly-0.6.2.dev20241210104242}/letta/server/server.py

@@ -101,11 +101,6 @@ class Server(object):
         """List all available agents to a user"""
         raise NotImplementedError
 
-    @abstractmethod
-    def get_agent_messages(self, user_id: str, agent_id: str, start: int, count: int) -> list:
-        """Paginated query of in-context messages in agent message queue"""
-        raise NotImplementedError
-
     @abstractmethod
     def get_agent_memory(self, user_id: str, agent_id: str) -> dict:
         """Return the memory of an agent (core memory + non-core statistics)"""
@@ -1173,55 +1168,6 @@ class SyncServer(Server):
         message = agent.message_manager.get_message_by_id(id=message_id, actor=self.default_user)
         return message
 
-    def get_agent_messages(
-        self,
-        agent_id: str,
-        start: int,
-        count: int,
-    ) -> Union[List[Message], List[LettaMessage]]:
-        """Paginated query of all messages in agent message queue"""
-        # Get the agent object (loaded in memory)
-        letta_agent = self.load_agent(agent_id=agent_id)
-
-        if start < 0 or count < 0:
-            raise ValueError("Start and count values should be non-negative")
-
-        if start + count < len(letta_agent._messages):  # messages can be returned from whats in memory
-            # Reverse the list to make it in reverse chronological order
-            reversed_messages = letta_agent._messages[::-1]
-            # Check if start is within the range of the list
-            if start >= len(reversed_messages):
-                raise IndexError("Start index is out of range")
-
-            # Calculate the end index, ensuring it does not exceed the list length
-            end_index = min(start + count, len(reversed_messages))
-
-            # Slice the list for pagination
-            messages = reversed_messages[start:end_index]
-
-        else:
-            # need to access persistence manager for additional messages
-
-            # get messages using message manager
-            page = letta_agent.message_manager.list_user_messages_for_agent(
-                agent_id=agent_id,
-                actor=self.default_user,
-                cursor=start,
-                limit=count,
-            )
-
-            messages = page
-            assert all(isinstance(m, Message) for m in messages)
-
-            ## Convert to json
-            ## Add a tag indicating in-context or not
-            # json_messages = [record.to_json() for record in messages]
-            # in_context_message_ids = [str(m.id) for m in letta_agent._messages]
-            # for d in json_messages:
-            #    d["in_context"] = True if str(d["id"]) in in_context_message_ids else False
-
-        return messages
-
     def get_agent_archival(self, user_id: str, agent_id: str, start: int, count: int) -> List[Passage]:
         """Paginated query of all messages in agent archival memory"""
         if self.user_manager.get_user_by_id(user_id=user_id) is None:
@@ -1303,7 +1249,8 @@ class SyncServer(Server):
         self,
         user_id: str,
         agent_id: str,
-        cursor: Optional[str] = None,
+        after: Optional[str] = None,
+        before: Optional[str] = None,
         limit: Optional[int] = 100,
         reverse: Optional[bool] = False,
         return_message_object: bool = True,
@@ -1320,12 +1267,15 @@ class SyncServer(Server):
         letta_agent = self.load_agent(agent_id=agent_id)
 
         # iterate over records
-        # TODO: Check "order_by", "order"
+        start_date = self.message_manager.get_message_by_id(after, actor=actor).created_at if after else None
+        end_date = self.message_manager.get_message_by_id(before, actor=actor).created_at if before else None
         records = letta_agent.message_manager.list_messages_for_agent(
             agent_id=agent_id,
             actor=actor,
-            cursor=cursor,
+            start_date=start_date,
+            end_date=end_date,
             limit=limit,
+            ascending=not reverse,
         )
 
         assert all(isinstance(m, Message) for m in records)

{letta_nightly-0.6.2.dev20241210030252 → letta_nightly-0.6.2.dev20241210104242}/letta/services/message_manager.py

@@ -119,6 +119,7 @@ class MessageManager:
         limit: Optional[int] = 50,
         filters: Optional[Dict] = None,
         query_text: Optional[str] = None,
+        ascending: bool = True,
     ) -> List[PydanticMessage]:
         """List user messages with flexible filtering and pagination options.
 
@@ -159,6 +160,7 @@ class MessageManager:
         limit: Optional[int] = 50,
         filters: Optional[Dict] = None,
         query_text: Optional[str] = None,
+        ascending: bool = True,
     ) -> List[PydanticMessage]:
         """List messages with flexible filtering and pagination options.
 
@@ -188,6 +190,7 @@ class MessageManager:
                 end_date=end_date,
                 limit=limit,
                 query_text=query_text,
+                ascending=ascending,
                 **message_filters,
             )
 

{letta_nightly-0.6.2.dev20241210030252 → letta_nightly-0.6.2.dev20241210104242}/letta/services/tool_execution_sandbox.py

@@ -459,7 +459,7 @@ class ToolExecutionSandbox:
         Generate the code string to call the function.
 
         Args:
-            inject_agent_state (bool): Whether to inject the agent's state as an input into the tool
+            inject_agent_state (bool): Whether to inject the axgent's state as an input into the tool
 
         Returns:
             str: Generated code string for calling the tool

{letta_nightly-0.6.2.dev20241210030252 → letta_nightly-0.6.2.dev20241210104242}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "letta-nightly"
-version = "0.6.2.dev20241210030252"
+version = "0.6.2.dev20241210104242"
 packages = [
     {include = "letta"}
 ]