letta-nightly 0.6.14.dev20250123041709__py3-none-any.whl → 0.6.15.dev20250124054224__py3-none-any.whl

letta/server/server.py

@@ -1,5 +1,6 @@
 # inspecting tools
 import asyncio
+import json
 import os
 import traceback
 import warnings
@@ -38,7 +39,7 @@ from letta.schemas.letta_message import LegacyLettaMessage, LettaMessage, ToolRe
 from letta.schemas.letta_response import LettaResponse
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.memory import ArchivalMemorySummary, ContextWindowOverview, Memory, RecallMemorySummary
-from letta.schemas.message import Message, MessageCreate, MessageRole, MessageUpdate
+from letta.schemas.message import Message, MessageCreate, MessageRole, MessageUpdate, TextContent
 from letta.schemas.organization import Organization
 from letta.schemas.passage import Passage
 from letta.schemas.providers import (
@@ -616,14 +617,14 @@ class SyncServer(Server):
                 message = Message(
                     agent_id=agent_id,
                     role="user",
-                    text=packaged_user_message,
+                    content=[TextContent(text=packaged_user_message)],
                     created_at=timestamp,
                 )
             else:
                 message = Message(
                     agent_id=agent_id,
                     role="user",
-                    text=packaged_user_message,
+                    content=[TextContent(text=packaged_user_message)],
                 )
 
         # Run the agent state forward
@@ -666,14 +667,14 @@ class SyncServer(Server):
                 message = Message(
                     agent_id=agent_id,
                     role="system",
-                    text=packaged_system_message,
+                    content=[TextContent(text=packaged_system_message)],
                     created_at=timestamp,
                 )
             else:
                 message = Message(
                     agent_id=agent_id,
                     role="system",
-                    text=packaged_system_message,
+                    content=[TextContent(text=packaged_system_message)],
                 )
 
         if isinstance(message, Message):
@@ -720,9 +721,9 @@ class SyncServer(Server):
 
                 # If wrapping is eanbled, wrap with metadata before placing content inside the Message object
                 if message.role == MessageRole.user and wrap_user_message:
-                    message.text = system.package_user_message(user_message=message.text)
+                    message.content = system.package_user_message(user_message=message.content)
                 elif message.role == MessageRole.system and wrap_system_message:
-                    message.text = system.package_system_message(system_message=message.text)
+                    message.content = system.package_system_message(system_message=message.content)
                 else:
                     raise ValueError(f"Invalid message role: {message.role}")
 
@@ -731,7 +732,7 @@ class SyncServer(Server):
                     Message(
                         agent_id=agent_id,
                         role=message.role,
-                        text=message.text,
+                        content=[TextContent(text=message.content)],
                         name=message.name,
                         # assigned later?
                         model=None,
@@ -804,20 +805,12 @@ class SyncServer(Server):
     def get_recall_memory_summary(self, agent_id: str, actor: User) -> RecallMemorySummary:
         return RecallMemorySummary(size=self.message_manager.size(actor=actor, agent_id=agent_id))
 
-    def get_agent_archival(self, user_id: str, agent_id: str, cursor: Optional[str] = None, limit: int = 50) -> List[Passage]:
-        """Paginated query of all messages in agent archival memory"""
-        # TODO: Thread actor directly through this function, since the top level caller most likely already retrieved the user
-        actor = self.user_manager.get_user_or_default(user_id=user_id)
-
-        passages = self.agent_manager.list_passages(agent_id=agent_id, actor=actor)
-
-        return passages
-
-    def get_agent_archival_cursor(
+    def get_agent_archival(
         self,
         user_id: str,
         agent_id: str,
-        cursor: Optional[str] = None,
+        after: Optional[str] = None,
+        before: Optional[str] = None,
         limit: Optional[int] = 100,
         order_by: Optional[str] = "created_at",
         reverse: Optional[bool] = False,
@@ -829,7 +822,8 @@ class SyncServer(Server):
         records = self.agent_manager.list_passages(
             actor=actor,
             agent_id=agent_id,
-            cursor=cursor,
+            after=after,
+            before=before,
             limit=limit,
             ascending=not reverse,
         )
@@ -851,7 +845,7 @@ class SyncServer(Server):
 
         # TODO: return archival memory
 
-    def get_agent_recall_cursor(
+    def get_agent_recall(
         self,
         user_id: str,
         agent_id: str,
@@ -1047,13 +1041,14 @@ class SyncServer(Server):
 
     def list_llm_models(self) -> List[LLMConfig]:
         """List available models"""
-
         llm_models = []
         for provider in self.get_enabled_providers():
             try:
                 llm_models.extend(provider.list_llm_models())
             except Exception as e:
                 warnings.warn(f"An error occurred while listing LLM models for provider {provider}: {e}")
+
+        llm_models.extend(self.get_local_llm_configs())
         return llm_models
 
     def list_embedding_models(self) -> List[EmbeddingConfig]:
@@ -1073,12 +1068,22 @@ class SyncServer(Server):
         return {**providers_from_env, **providers_from_db}.values()
 
     def get_llm_config_from_handle(self, handle: str, context_window_limit: Optional[int] = None) -> LLMConfig:
-        provider_name, model_name = handle.split("/", 1)
-        provider = self.get_provider_from_name(provider_name)
-
-        llm_configs = [config for config in provider.list_llm_models() if config.model == model_name]
-        if not llm_configs:
-            raise ValueError(f"LLM model {model_name} is not supported by {provider_name}")
+        try:
+            provider_name, model_name = handle.split("/", 1)
+            provider = self.get_provider_from_name(provider_name)
+
+            llm_configs = [config for config in provider.list_llm_models() if config.handle == handle]
+            if not llm_configs:
+                llm_configs = [config for config in provider.list_llm_models() if config.model == model_name]
+            if not llm_configs:
+                raise ValueError(f"LLM model {model_name} is not supported by {provider_name}")
+        except ValueError as e:
+            llm_configs = [config for config in self.get_local_llm_configs() if config.handle == handle]
+            if not llm_configs:
+                raise e
+
+        if len(llm_configs) == 1:
+            llm_config = llm_configs[0]
         elif len(llm_configs) > 1:
             raise ValueError(f"Multiple LLM models with name {model_name} supported by {provider_name}")
         else:
@@ -1097,13 +1102,17 @@ class SyncServer(Server):
         provider_name, model_name = handle.split("/", 1)
         provider = self.get_provider_from_name(provider_name)
 
-        embedding_configs = [config for config in provider.list_embedding_models() if config.embedding_model == model_name]
-        if not embedding_configs:
-            raise ValueError(f"Embedding model {model_name} is not supported by {provider_name}")
-        elif len(embedding_configs) > 1:
-            raise ValueError(f"Multiple embedding models with name {model_name} supported by {provider_name}")
-        else:
+        embedding_configs = [config for config in provider.list_embedding_models() if config.handle == handle]
+        if len(embedding_configs) == 1:
             embedding_config = embedding_configs[0]
+        else:
+            embedding_configs = [config for config in provider.list_embedding_models() if config.embedding_model == model_name]
+            if not embedding_configs:
+                raise ValueError(f"Embedding model {model_name} is not supported by {provider_name}")
+            elif len(embedding_configs) > 1:
+                raise ValueError(f"Multiple embedding models with name {model_name} supported by {provider_name}")
+            else:
+                embedding_config = embedding_configs[0]
 
         if embedding_chunk_size:
             embedding_config.embedding_chunk_size = embedding_chunk_size
@@ -1121,6 +1130,25 @@ class SyncServer(Server):
 
         return provider
 
+    def get_local_llm_configs(self):
+        llm_models = []
+        try:
+            llm_configs_dir = os.path.expanduser("~/.letta/llm_configs")
+            if os.path.exists(llm_configs_dir):
+                for filename in os.listdir(llm_configs_dir):
+                    if filename.endswith(".json"):
+                        filepath = os.path.join(llm_configs_dir, filename)
+                        try:
+                            with open(filepath, "r") as f:
+                                config_data = json.load(f)
+                                llm_config = LLMConfig(**config_data)
+                                llm_models.append(llm_config)
+                        except (json.JSONDecodeError, ValueError) as e:
+                            warnings.warn(f"Error parsing LLM config file {filename}: {e}")
+        except Exception as e:
+            warnings.warn(f"Error reading LLM configs directory: {e}")
+        return llm_models
+
     def add_llm_model(self, request: LLMConfig) -> LLMConfig:
         """Add a new LLM model"""
 

letta/services/agent_manager.py

@@ -2,7 +2,7 @@ from datetime import datetime
 from typing import Dict, List, Optional
 
 import numpy as np
-from sqlalchemy import Select, func, literal, select, union_all
+from sqlalchemy import Select, and_, func, literal, or_, select, union_all
 
 from letta.constants import BASE_MEMORY_TOOLS, BASE_TOOLS, MAX_EMBEDDING_DIM, MULTI_AGENT_TOOLS
 from letta.embeddings import embedding_model
@@ -271,10 +271,11 @@ class AgentManager:
     def list_agents(
         self,
         actor: PydanticUser,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        limit: Optional[int] = 50,
         tags: Optional[List[str]] = None,
         match_all_tags: bool = False,
-        cursor: Optional[str] = None,
-        limit: Optional[int] = 50,
         query_text: Optional[str] = None,
         **kwargs,
     ) -> List[PydanticAgentState]:
@@ -284,10 +285,11 @@ class AgentManager:
         with self.session_maker() as session:
             agents = AgentModel.list(
                 db_session=session,
+                before=before,
+                after=after,
+                limit=limit,
                 tags=tags,
                 match_all_tags=match_all_tags,
-                cursor=cursor,
-                limit=limit,
                 organization_id=actor.organization_id if actor else None,
                 query_text=query_text,
                 **kwargs,
@@ -723,7 +725,8 @@ class AgentManager:
         query_text: Optional[str] = None,
         start_date: Optional[datetime] = None,
         end_date: Optional[datetime] = None,
-        cursor: Optional[str] = None,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
         source_id: Optional[str] = None,
         embed_query: bool = False,
         ascending: bool = True,
@@ -731,6 +734,7 @@ class AgentManager:
         agent_only: bool = False,
     ) -> Select:
         """Helper function to build the base passage query with all filters applied.
+        Supports both before and after pagination across merged source and agent passages.
 
         Returns the query before any limit or count operations are applied.
         """
@@ -818,30 +822,69 @@ class AgentManager:
                 else:
                     # SQLite with custom vector type
                     query_embedding_binary = adapt_array(embedded_text)
-                    if ascending:
-                        main_query = main_query.order_by(
-                            func.cosine_distance(combined_query.c.embedding, query_embedding_binary).asc(),
-                            combined_query.c.created_at.asc(),
-                            combined_query.c.id.asc(),
-                        )
-                    else:
-                        main_query = main_query.order_by(
-                            func.cosine_distance(combined_query.c.embedding, query_embedding_binary).asc(),
-                            combined_query.c.created_at.desc(),
-                            combined_query.c.id.asc(),
-                        )
+                    main_query = main_query.order_by(
+                        func.cosine_distance(combined_query.c.embedding, query_embedding_binary).asc(),
+                        combined_query.c.created_at.asc() if ascending else combined_query.c.created_at.desc(),
+                        combined_query.c.id.asc(),
+                    )
             else:
                 if query_text:
                     main_query = main_query.where(func.lower(combined_query.c.text).contains(func.lower(query_text)))
 
-            # Handle cursor-based pagination
-            if cursor:
-                cursor_query = select(combined_query.c.created_at).where(combined_query.c.id == cursor).scalar_subquery()
+            # Handle pagination
+            if before or after:
+                # Create reference CTEs
+                if before:
+                    before_ref = (
+                        select(combined_query.c.created_at, combined_query.c.id).where(combined_query.c.id == before).cte("before_ref")
+                    )
+                if after:
+                    after_ref = (
+                        select(combined_query.c.created_at, combined_query.c.id).where(combined_query.c.id == after).cte("after_ref")
+                    )
 
-                if ascending:
-                    main_query = main_query.where(combined_query.c.created_at > cursor_query)
+                if before and after:
+                    # Window-based query (get records between before and after)
+                    main_query = main_query.where(
+                        or_(
+                            combined_query.c.created_at < select(before_ref.c.created_at).scalar_subquery(),
+                            and_(
+                                combined_query.c.created_at == select(before_ref.c.created_at).scalar_subquery(),
+                                combined_query.c.id < select(before_ref.c.id).scalar_subquery(),
+                            ),
+                        )
+                    )
+                    main_query = main_query.where(
+                        or_(
+                            combined_query.c.created_at > select(after_ref.c.created_at).scalar_subquery(),
+                            and_(
+                                combined_query.c.created_at == select(after_ref.c.created_at).scalar_subquery(),
+                                combined_query.c.id > select(after_ref.c.id).scalar_subquery(),
+                            ),
+                        )
+                    )
                 else:
-                    main_query = main_query.where(combined_query.c.created_at < cursor_query)
+                    # Pure pagination (only before or only after)
+                    if before:
+                        main_query = main_query.where(
+                            or_(
+                                combined_query.c.created_at < select(before_ref.c.created_at).scalar_subquery(),
+                                and_(
+                                    combined_query.c.created_at == select(before_ref.c.created_at).scalar_subquery(),
+                                    combined_query.c.id < select(before_ref.c.id).scalar_subquery(),
+                                ),
+                            )
+                        )
+                    if after:
+                        main_query = main_query.where(
+                            or_(
+                                combined_query.c.created_at > select(after_ref.c.created_at).scalar_subquery(),
+                                and_(
+                                    combined_query.c.created_at == select(after_ref.c.created_at).scalar_subquery(),
+                                    combined_query.c.id > select(after_ref.c.id).scalar_subquery(),
+                                ),
+                            )
+                        )
 
             # Add ordering if not already ordered by similarity
             if not embed_query:
@@ -856,7 +899,7 @@ class AgentManager:
                         combined_query.c.id.asc(),
                     )
 
-            return main_query
+        return main_query
 
     @enforce_types
     def list_passages(
@@ -868,7 +911,8 @@ class AgentManager:
         query_text: Optional[str] = None,
         start_date: Optional[datetime] = None,
         end_date: Optional[datetime] = None,
-        cursor: Optional[str] = None,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
         source_id: Optional[str] = None,
         embed_query: bool = False,
         ascending: bool = True,
@@ -884,7 +928,8 @@ class AgentManager:
                 query_text=query_text,
                 start_date=start_date,
                 end_date=end_date,
-                cursor=cursor,
+                before=before,
+                after=after,
                 source_id=source_id,
                 embed_query=embed_query,
                 ascending=ascending,
@@ -924,7 +969,8 @@ class AgentManager:
         query_text: Optional[str] = None,
         start_date: Optional[datetime] = None,
         end_date: Optional[datetime] = None,
-        cursor: Optional[str] = None,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
         source_id: Optional[str] = None,
         embed_query: bool = False,
         ascending: bool = True,
@@ -940,7 +986,8 @@ class AgentManager:
                 query_text=query_text,
                 start_date=start_date,
                 end_date=end_date,
-                cursor=cursor,
+                before=before,
+                after=after,
                 source_id=source_id,
                 embed_query=embed_query,
                 ascending=ascending,
@@ -1044,14 +1091,14 @@ class AgentManager:
     # ======================================================================================================================
     @enforce_types
     def list_tags(
-        self, actor: PydanticUser, cursor: Optional[str] = None, limit: Optional[int] = 50, query_text: Optional[str] = None
+        self, actor: PydanticUser, after: Optional[str] = None, limit: Optional[int] = 50, query_text: Optional[str] = None
     ) -> List[str]:
         """
         Get all tags a user has created, ordered alphabetically.
 
         Args:
             actor: User performing the action.
-            cursor: Cursor for pagination.
+            after: Cursor for forward pagination.
             limit: Maximum number of tags to return.
             query_text: Query text to filter tags by.
 
@@ -1069,8 +1116,8 @@ class AgentManager:
             if query_text:
                 query = query.filter(AgentsTags.tag.ilike(f"%{query_text}%"))
 
-            if cursor:
-                query = query.filter(AgentsTags.tag > cursor)
+            if after:
+                query = query.filter(AgentsTags.tag > after)
 
             query = query.order_by(AgentsTags.tag).limit(limit)
             results = [tag[0] for tag in query.all()]

letta/services/block_manager.py

@@ -3,6 +3,7 @@ from typing import List, Optional
 
 from letta.orm.block import Block as BlockModel
 from letta.orm.errors import NoResultFound
+from letta.schemas.agent import AgentState as PydanticAgentState
 from letta.schemas.block import Block
 from letta.schemas.block import Block as PydanticBlock
 from letta.schemas.block import BlockUpdate, Human, Persona
@@ -64,7 +65,7 @@ class BlockManager:
         is_template: Optional[bool] = None,
         template_name: Optional[str] = None,
         id: Optional[str] = None,
-        cursor: Optional[str] = None,
+        after: Optional[str] = None,
         limit: Optional[int] = 50,
     ) -> List[PydanticBlock]:
         """Retrieve blocks based on various optional filters."""
@@ -80,7 +81,7 @@ class BlockManager:
             if id:
                 filters["id"] = id
 
-            blocks = BlockModel.list(db_session=session, cursor=cursor, limit=limit, **filters)
+            blocks = BlockModel.list(db_session=session, after=after, limit=limit, **filters)
 
             return [block.to_pydantic() for block in blocks]
 
@@ -114,3 +115,15 @@ class BlockManager:
             text = open(human_file, "r", encoding="utf-8").read()
             name = os.path.basename(human_file).replace(".txt", "")
             self.create_or_update_block(Human(template_name=name, value=text, is_template=True), actor=actor)
+
+    @enforce_types
+    def get_agents_for_block(self, block_id: str, actor: PydanticUser) -> List[PydanticAgentState]:
+        """
+        Retrieve all agents associated with a given block.
+        """
+        with self.session_maker() as session:
+            block = BlockModel.read(db_session=session, identifier=block_id, actor=actor)
+            agents_orm = block.agents
+            agents_pydantic = [agent.to_pydantic() for agent in agents_orm]
+
+            return agents_pydantic

letta/services/helpers/agent_manager_helper.py

@@ -11,7 +11,7 @@ from letta.prompts import gpt_system
 from letta.schemas.agent import AgentState, AgentType
 from letta.schemas.enums import MessageRole
 from letta.schemas.memory import Memory
-from letta.schemas.message import Message, MessageCreate
+from letta.schemas.message import Message, MessageCreate, TextContent
 from letta.schemas.tool_rule import ToolRule
 from letta.schemas.user import User
 from letta.system import get_initial_boot_messages, get_login_event
@@ -234,17 +234,24 @@ def package_initial_message_sequence(
 
         if message_create.role == MessageRole.user:
             packed_message = system.package_user_message(
-                user_message=message_create.text,
+                user_message=message_create.content,
             )
         elif message_create.role == MessageRole.system:
             packed_message = system.package_system_message(
-                system_message=message_create.text,
+                system_message=message_create.content,
             )
         else:
             raise ValueError(f"Invalid message role: {message_create.role}")
 
         init_messages.append(
-            Message(role=message_create.role, text=packed_message, organization_id=actor.organization_id, agent_id=agent_id, model=model)
+            Message(
+                role=message_create.role,
+                content=[TextContent(text=packed_message)],
+                name=message_create.name,
+                organization_id=actor.organization_id,
+                agent_id=agent_id,
+                model=model,
+            )
         )
     return init_messages
 

letta/services/job_manager.py

@@ -78,10 +78,12 @@ class JobManager:
     def list_jobs(
         self,
         actor: PydanticUser,
-        cursor: Optional[str] = None,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
         limit: Optional[int] = 50,
         statuses: Optional[List[JobStatus]] = None,
         job_type: JobType = JobType.JOB,
+        ascending: bool = True,
     ) -> List[PydanticJob]:
         """List all jobs with optional pagination and status filter."""
         with self.session_maker() as session:
@@ -93,8 +95,10 @@ class JobManager:
 
             jobs = JobModel.list(
                 db_session=session,
-                cursor=cursor,
+                before=before,
+                after=after,
                 limit=limit,
+                ascending=ascending,
                 **filter_kwargs,
             )
             return [job.to_pydantic() for job in jobs]
@@ -112,7 +116,8 @@ class JobManager:
         self,
         job_id: str,
         actor: PydanticUser,
-        cursor: Optional[str] = None,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
         limit: Optional[int] = 100,
         role: Optional[MessageRole] = None,
         ascending: bool = True,
@@ -123,7 +128,8 @@ class JobManager:
         Args:
             job_id: The ID of the job to get messages for
             actor: The user making the request
-            cursor: Cursor for pagination
+            before: Cursor for pagination
+            after: Cursor for pagination
             limit: Maximum number of messages to return
             role: Optional filter for message role
             ascending: Optional flag to sort in ascending order
@@ -143,7 +149,8 @@ class JobManager:
             # Get messages
             messages = MessageModel.list(
                 db_session=session,
-                cursor=cursor,
+                before=before,
+                after=after,
                 ascending=ascending,
                 limit=limit,
                 actor=actor,
@@ -255,11 +262,12 @@ class JobManager:
             session.commit()
 
     @enforce_types
-    def get_run_messages_cursor(
+    def get_run_messages(
         self,
         run_id: str,
         actor: PydanticUser,
-        cursor: Optional[str] = None,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
         limit: Optional[int] = 100,
         role: Optional[MessageRole] = None,
         ascending: bool = True,
@@ -271,7 +279,8 @@ class JobManager:
         Args:
             job_id: The ID of the job to get messages for
             actor: The user making the request
-            cursor: Message ID to get messages after or before
+            before: Message ID to get messages after
+            after: Message ID to get messages before
             limit: Maximum number of messages to return
             ascending: Whether to return messages in ascending order
             role: Optional role filter
@@ -285,7 +294,8 @@ class JobManager:
         messages = self.get_job_messages(
             job_id=run_id,
             actor=actor,
-            cursor=cursor,
+            before=before,
+            after=after,
             limit=limit,
             role=role,
             ascending=ascending,

letta/services/message_manager.py

@@ -49,7 +49,7 @@ class MessageManager:
         with self.session_maker() as session:
             # Set the organization id of the Pydantic message
             pydantic_msg.organization_id = actor.organization_id
-            msg_data = pydantic_msg.model_dump()
+            msg_data = pydantic_msg.model_dump(to_orm=True)
             msg = MessageModel(**msg_data)
             msg.create(session, actor=actor)  # Persist to database
             return msg.to_pydantic()
@@ -83,7 +83,7 @@ class MessageManager:
                 )
 
             # get update dictionary
-            update_data = message_update.model_dump(exclude_unset=True, exclude_none=True)
+            update_data = message_update.model_dump(to_orm=True, exclude_unset=True, exclude_none=True)
             # Remove redundant update fields
             update_data = {key: value for key, value in update_data.items() if getattr(message, key) != value}
 
@@ -128,7 +128,8 @@ class MessageManager:
         self,
         agent_id: str,
         actor: Optional[PydanticUser] = None,
-        cursor: Optional[str] = None,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
         start_date: Optional[datetime] = None,
         end_date: Optional[datetime] = None,
         limit: Optional[int] = 50,
@@ -139,7 +140,8 @@ class MessageManager:
         """List user messages with flexible filtering and pagination options.
 
         Args:
-            cursor: Cursor-based pagination - return records after this ID (exclusive)
+            before: Cursor-based pagination - return records before this ID (exclusive)
+            after: Cursor-based pagination - return records after this ID (exclusive)
             start_date: Filter records created after this date
             end_date: Filter records created before this date
             limit: Maximum number of records to return
@@ -156,7 +158,8 @@ class MessageManager:
         return self.list_messages_for_agent(
             agent_id=agent_id,
             actor=actor,
-            cursor=cursor,
+            before=before,
+            after=after,
             start_date=start_date,
             end_date=end_date,
             limit=limit,
@@ -170,7 +173,8 @@ class MessageManager:
         self,
         agent_id: str,
         actor: Optional[PydanticUser] = None,
-        cursor: Optional[str] = None,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
         start_date: Optional[datetime] = None,
         end_date: Optional[datetime] = None,
         limit: Optional[int] = 50,
@@ -181,7 +185,8 @@ class MessageManager:
         """List messages with flexible filtering and pagination options.
 
         Args:
-            cursor: Cursor-based pagination - return records after this ID (exclusive)
+            before: Cursor-based pagination - return records before this ID (exclusive)
+            after: Cursor-based pagination - return records after this ID (exclusive)
             start_date: Filter records created after this date
             end_date: Filter records created before this date
             limit: Maximum number of records to return
@@ -201,7 +206,8 @@ class MessageManager:
 
             results = MessageModel.list(
                 db_session=session,
-                cursor=cursor,
+                before=before,
+                after=after,
                 start_date=start_date,
                 end_date=end_date,
                 limit=limit,