feat: nav optimization

api/app/clients/OpenAIClient.js

@@ -1469,6 +1469,11 @@ ${convo}
           });
       }
 
+      if (openai.abortHandler && abortController.signal) {
+        abortController.signal.removeEventListener('abort', openai.abortHandler);
+        openai.abortHandler = undefined;
+      }
+
       if (!chatCompletion && UnexpectedRoleError) {
         throw new Error(
           'OpenAI error: Invalid final message: OpenAI expects final message to include role=assistant',

api/models/Conversation.js

@@ -88,11 +88,13 @@ module.exports = {
    */
   saveConvo: async (req, { conversationId, newConversationId, ...convo }, metadata) => {
     try {
-      if (metadata && metadata?.context) {
+      if (metadata?.context) {
         logger.debug(`[saveConvo] ${metadata.context}`);
       }
+
       const messages = await getMessages({ conversationId }, '_id');
       const update = { ...convo, messages, user: req.user.id };
+
       if (newConversationId) {
         update.conversationId = newConversationId;
       }
@@ -148,75 +150,100 @@ module.exports = {
       throw new Error('Failed to save conversations in bulk.');
     }
   },
-  getConvosByPage: async (user, pageNumber = 1, pageSize = 25, isArchived = false, tags) => {
-    const query = { user };
+  getConvosByCursor: async (
+    user,
+    { cursor, limit = 25, isArchived = false, tags, search, order = 'desc' } = {},
+  ) => {
+    const filters = [{ user }];
+
     if (isArchived) {
-      query.isArchived = true;
+      filters.push({ isArchived: true });
     } else {
-      query.$or = [{ isArchived: false }, { isArchived: { $exists: false } }];
+      filters.push({ $or: [{ isArchived: false }, { isArchived: { $exists: false } }] });
     }
+
     if (Array.isArray(tags) && tags.length > 0) {
-      query.tags = { $in: tags };
+      filters.push({ tags: { $in: tags } });
     }
 
-    query.$and = [{ $or: [{ expiredAt: null }, { expiredAt: { $exists: false } }] }];
+    filters.push({ $or: [{ expiredAt: null }, { expiredAt: { $exists: false } }] });
+
+    if (search) {
+      try {
+        const meiliResults = await Conversation.meiliSearch(search);
+        const matchingIds = Array.isArray(meiliResults.hits)
+          ? meiliResults.hits.map((result) => result.conversationId)
+          : [];
+        if (!matchingIds.length) {
+          return { conversations: [], nextCursor: null };
+        }
+        filters.push({ conversationId: { $in: matchingIds } });
+      } catch (error) {
+        logger.error('[getConvosByCursor] Error during meiliSearch', error);
+        return { message: 'Error during meiliSearch' };
+      }
+    }
+
+    if (cursor) {
+      filters.push({ updatedAt: { $lt: new Date(cursor) } });
+    }
+
+    const query = filters.length === 1 ? filters[0] : { $and: filters };
 
     try {
-      const totalConvos = (await Conversation.countDocuments(query)) || 1;
-      const totalPages = Math.ceil(totalConvos / pageSize);
       const convos = await Conversation.find(query)
-        .sort({ updatedAt: -1 })
-        .skip((pageNumber - 1) * pageSize)
-        .limit(pageSize)
+        .select('conversationId endpoint title createdAt updatedAt user')
+        .sort({ updatedAt: order === 'asc' ? 1 : -1 })
+        .limit(limit + 1)
         .lean();
-      return { conversations: convos, pages: totalPages, pageNumber, pageSize };
+
+      let nextCursor = null;
+      if (convos.length > limit) {
+        const lastConvo = convos.pop();
+        nextCursor = lastConvo.updatedAt.toISOString();
+      }
+
+      return { conversations: convos, nextCursor };
     } catch (error) {
-      logger.error('[getConvosByPage] Error getting conversations', error);
+      logger.error('[getConvosByCursor] Error getting conversations', error);
       return { message: 'Error getting conversations' };
     }
   },
-  getConvosQueried: async (user, convoIds, pageNumber = 1, pageSize = 25) => {
+  getConvosQueried: async (user, convoIds, cursor = null, limit = 25) => {
     try {
-      if (!convoIds || convoIds.length === 0) {
-        return { conversations: [], pages: 1, pageNumber, pageSize };
+      if (!convoIds?.length) {
+        return { conversations: [], nextCursor: null, convoMap: {} };
       }
 
-      const cache = {};
-      const convoMap = {};
-      const promises = [];
-
-      convoIds.forEach((convo) =>
-        promises.push(
-          Conversation.findOne({
-            user,
-            conversationId: convo.conversationId,
-            $or: [{ expiredAt: { $exists: false } }, { expiredAt: null }],
-          }).lean(),
-        ),
-      );
+      const conversationIds = convoIds.map((convo) => convo.conversationId);
 
-      const results = (await Promise.all(promises)).filter(Boolean);
+      const results = await Conversation.find({
+        user,
+        conversationId: { $in: conversationIds },
+        $or: [{ expiredAt: { $exists: false } }, { expiredAt: null }],
+      }).lean();
 
-      results.forEach((convo, i) => {
-        const page = Math.floor(i / pageSize) + 1;
-        if (!cache[page]) {
-          cache[page] = [];
-        }
-        cache[page].push(convo);
+      results.sort((a, b) => new Date(b.updatedAt) - new Date(a.updatedAt));
+
+      let filtered = results;
+      if (cursor && cursor !== 'start') {
+        const cursorDate = new Date(cursor);
+        filtered = results.filter((convo) => new Date(convo.updatedAt) < cursorDate);
+      }
+
+      const limited = filtered.slice(0, limit + 1);
+      let nextCursor = null;
+      if (limited.length > limit) {
+        const lastConvo = limited.pop();
+        nextCursor = lastConvo.updatedAt.toISOString();
+      }
+
+      const convoMap = {};
+      limited.forEach((convo) => {
         convoMap[convo.conversationId] = convo;
       });
 
-      const totalPages = Math.ceil(results.length / pageSize);
-      cache.pages = totalPages;
-      cache.pageSize = pageSize;
-      return {
-        cache,
-        conversations: cache[pageNumber] || [],
-        pages: totalPages || 1,
-        pageNumber,
-        pageSize,
-        convoMap,
-      };
+      return { conversations: limited, nextCursor, convoMap };
     } catch (error) {
       logger.error('[getConvosQueried] Error getting conversations', error);
       return { message: 'Error fetching conversations' };
@@ -257,10 +284,26 @@ module.exports = {
    * logger.error(result); // { n: 5, ok: 1, deletedCount: 5, messages: { n: 10, ok: 1, deletedCount: 10 } }
    */
   deleteConvos: async (user, filter) => {
-    let toRemove = await Conversation.find({ ...filter, user }).select('conversationId');
-    const ids = toRemove.map((instance) => instance.conversationId);
-    let deleteCount = await Conversation.deleteMany({ ...filter, user });
-    deleteCount.messages = await deleteMessages({ conversationId: { $in: ids } });
-    return deleteCount;
+    try {
+      const userFilter = { ...filter, user };
+
+      const conversations = await Conversation.find(userFilter).select('conversationId');
+      const conversationIds = conversations.map((c) => c.conversationId);
+
+      if (!conversationIds.length) {
+        throw new Error('Conversation not found or already deleted.');
+      }
+
+      const deleteConvoResult = await Conversation.deleteMany(userFilter);
+
+      const deleteMessagesResult = await deleteMessages({
+        conversationId: { $in: conversationIds },
+      });
+
+      return { ...deleteConvoResult, messages: deleteMessagesResult };
+    } catch (error) {
+      logger.error('[deleteConvos] Error deleting conversations and messages', error);
+      throw error;
+    }
   },
 };

api/package.json

@@ -39,7 +39,7 @@
     "@aws-sdk/s3-request-presigner": "^3.758.0",
     "@azure/identity": "^4.7.0",
     "@azure/search-documents": "^12.0.0",
-    "@azure/storage-blob": "^12.26.0",
+    "@azure/storage-blob": "^12.27.0",
     "@google/generative-ai": "^0.23.0",
     "@googleapis/youtube": "^20.0.0",
     "@keyv/redis": "^4.3.3",
@@ -48,7 +48,7 @@
     "@langchain/google-genai": "^0.2.2",
     "@langchain/google-vertexai": "^0.2.3",
     "@langchain/textsplitters": "^0.1.0",
-    "@librechat/agents": "^2.4.17",
+    "@librechat/agents": "^2.4.20",
     "@librechat/data-schemas": "*",
     "@waylaidwanderer/fetch-event-source": "^3.0.1",
     "axios": "^1.8.2",

api/server/middleware/abortMiddleware.js

@@ -108,8 +108,8 @@ async function abortMessage(req, res) {
   res.send(JSON.stringify(finalEvent));
 }
 
-const handleAbort = () => {
-  return async (req, res) => {
+const handleAbort = function () {
+  return async function (req, res) {
     try {
       if (isEnabled(process.env.LIMIT_CONCURRENT_MESSAGES)) {
         await clearPendingReq({ userId: req.user.id });

api/server/routes/convos.js

@@ -1,16 +1,17 @@
 const multer = require('multer');
 const express = require('express');
 const { CacheKeys, EModelEndpoint } = require('librechat-data-provider');
-const { getConvosByPage, deleteConvos, getConvo, saveConvo } = require('~/models/Conversation');
+const { getConvosByCursor, deleteConvos, getConvo, saveConvo } = require('~/models/Conversation');
 const { forkConversation, duplicateConversation } = require('~/server/utils/import/fork');
 const { storage, importFileFilter } = require('~/server/routes/files/multer');
 const requireJwtAuth = require('~/server/middleware/requireJwtAuth');
 const { importConversations } = require('~/server/utils/import');
 const { createImportLimiters } = require('~/server/middleware');
 const { deleteToolCalls } = require('~/models/ToolCall');
+const { isEnabled, sleep } = require('~/server/utils');
 const getLogStores = require('~/cache/getLogStores');
-const { sleep } = require('~/server/utils');
 const { logger } = require('~/config');
+
 const assistantClients = {
   [EModelEndpoint.azureAssistants]: require('~/server/services/Endpoints/azureAssistants'),
   [EModelEndpoint.assistants]: require('~/server/services/Endpoints/assistants'),
@@ -20,28 +21,30 @@ const router = express.Router();
 router.use(requireJwtAuth);
 
 router.get('/', async (req, res) => {
-  let pageNumber = req.query.pageNumber || 1;
-  pageNumber = parseInt(pageNumber, 10);
-
-  if (isNaN(pageNumber) || pageNumber < 1) {
-    return res.status(400).json({ error: 'Invalid page number' });
-  }
-
-  let pageSize = req.query.pageSize || 25;
-  pageSize = parseInt(pageSize, 10);
+  const limit = parseInt(req.query.limit, 10) || 25;
+  const cursor = req.query.cursor;
+  const isArchived = isEnabled(req.query.isArchived);
+  const search = req.query.search ? decodeURIComponent(req.query.search) : undefined;
+  const order = req.query.order || 'desc';
 
-  if (isNaN(pageSize) || pageSize < 1) {
-    return res.status(400).json({ error: 'Invalid page size' });
-  }
-  const isArchived = req.query.isArchived === 'true';
   let tags;
   if (req.query.tags) {
     tags = Array.isArray(req.query.tags) ? req.query.tags : [req.query.tags];
-  } else {
-    tags = undefined;
   }
 
-  res.status(200).send(await getConvosByPage(req.user.id, pageNumber, pageSize, isArchived, tags));
+  try {
+    const result = await getConvosByCursor(req.user.id, {
+      cursor,
+      limit,
+      isArchived,
+      tags,
+      search,
+      order,
+    });
+    res.status(200).json(result);
+  } catch (error) {
+    res.status(500).json({ error: 'Error fetching conversations' });
+  }
 });
 
 router.get('/:conversationId', async (req, res) => {
@@ -76,22 +79,28 @@ router.post('/gen_title', async (req, res) => {
   }
 });
 
-router.post('/clear', async (req, res) => {
+router.delete('/', async (req, res) => {
   let filter = {};
   const { conversationId, source, thread_id, endpoint } = req.body.arg;
-  if (conversationId) {
-    filter = { conversationId };
+
+  // Prevent deletion of all conversations
+  if (!conversationId && !source && !thread_id && !endpoint) {
+    return res.status(400).json({
+      error: 'no parameters provided',
+    });
   }
 
-  if (source === 'button' && !conversationId) {
+  if (conversationId) {
+    filter = { conversationId };
+  } else if (source === 'button') {
     return res.status(200).send('No conversationId provided');
   }
 
   if (
-    typeof endpoint != 'undefined' &&
+    typeof endpoint !== 'undefined' &&
     Object.prototype.propertyIsEnumerable.call(assistantClients, endpoint)
   ) {
-    /** @type {{ openai: OpenAI}} */
+    /** @type {{ openai: OpenAI }} */
     const { openai } = await assistantClients[endpoint].initializeClient({ req, res });
     try {
       const response = await openai.beta.threads.del(thread_id);
@@ -101,9 +110,6 @@ router.post('/clear', async (req, res) => {
     }
   }
 
-  // for debugging deletion source
-  // logger.debug('source:', source);
-
   try {
     const dbResponse = await deleteConvos(req.user.id, filter);
     await deleteToolCalls(req.user.id, filter.conversationId);
@@ -114,6 +120,17 @@ router.post('/clear', async (req, res) => {
   }
 });
 
+router.delete('/all', async (req, res) => {
+  try {
+    const dbResponse = await deleteConvos(req.user.id, {});
+    await deleteToolCalls(req.user.id);
+    res.status(201).json(dbResponse);
+  } catch (error) {
+    logger.error('Error clearing conversations', error);
+    res.status(500).send('Error clearing conversations');
+  }
+});
+
 router.post('/update', async (req, res) => {
   const update = req.body.arg;