@librechat/data-schemas 0.0.10 → 0.0.11

package/dist/index.es.js

@@ -425,10 +425,23 @@ const conversationPreset = {
     max_tokens: {
         type: Number,
     },
-    /** omni models only */
+    useResponsesApi: {
+        type: Boolean,
+    },
+    /** OpenAI Responses API / Anthropic API / Google API */
+    web_search: {
+        type: Boolean,
+    },
+    disableStreaming: {
+        type: Boolean,
+    },
+    /** Reasoning models only */
     reasoning_effort: {
         type: String,
     },
+    reasoning_summary: {
+        type: String,
+    },
 };
 
 const convoSchema = new Schema({
@@ -881,7 +894,9 @@ const promptGroupSchema = new Schema({
 });
 promptGroupSchema.index({ createdAt: 1, updatedAt: 1 });
 
-// Create a sub-schema for permissions. Notice we disable _id for this subdocument.
+/**
+ * Uses a sub-schema for permissions. Notice we disable `_id` for this subdocument.
+ */
 const rolePermissionsSchema = new Schema({
     [PermissionTypes.BOOKMARKS]: {
         [Permissions.USE]: { type: Boolean, default: true },
@@ -915,6 +930,9 @@ const rolePermissionsSchema = new Schema({
     [PermissionTypes.WEB_SEARCH]: {
         [Permissions.USE]: { type: Boolean, default: true },
     },
+    [PermissionTypes.FILE_SEARCH]: {
+        [Permissions.USE]: { type: Boolean, default: true },
+    },
 }, { _id: false });
 const roleSchema = new Schema({
     name: { type: String, required: true, unique: true, index: true },
@@ -942,6 +960,7 @@ const roleSchema = new Schema({
             [PermissionTypes.TEMPORARY_CHAT]: { [Permissions.USE]: true },
             [PermissionTypes.RUN_CODE]: { [Permissions.USE]: true },
             [PermissionTypes.WEB_SEARCH]: { [Permissions.USE]: true },
+            [PermissionTypes.FILE_SEARCH]: { [Permissions.USE]: true },
         }),
     },
 });
@@ -1336,6 +1355,13 @@ const searchEnabled = process.env.SEARCH != null && process.env.SEARCH.toLowerCa
  * Flag to indicate if MeiliSearch is enabled based on required environment variables.
  */
 const meiliEnabled = process.env.MEILI_HOST != null && process.env.MEILI_MASTER_KEY != null && searchEnabled;
+/**
+ * Get sync configuration from environment variables
+ */
+const getSyncConfig = () => ({
+    batchSize: parseInt(process.env.MEILI_SYNC_BATCH_SIZE || '100', 10),
+    delayMs: parseInt(process.env.MEILI_SYNC_DELAY_MS || '100', 10),
+});
 /**
  * Local implementation of parseTextParts to avoid dependency on librechat-data-provider
  * Extracts text content from an array of content items
@@ -1367,6 +1393,19 @@ const validateOptions = (options) => {
         }
     });
 };
+/**
+ * Helper function to process documents in batches with rate limiting
+ */
+const processBatch = async (items, batchSize, delayMs, processor) => {
+    for (let i = 0; i < items.length; i += batchSize) {
+        const batch = items.slice(i, i + batchSize);
+        await processor(batch);
+        // Add delay between batches to prevent overwhelming resources
+        if (i + batchSize < items.length && delayMs > 0) {
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
+        }
+    }
+};
 /**
  * Factory function to create a MeiliMongooseModel class which extends a Mongoose model.
  * This class contains static and instance methods to synchronize and manage the MeiliSearch index
@@ -1375,97 +1414,148 @@ const validateOptions = (options) => {
  * @param config - Configuration object.
  * @param config.index - The MeiliSearch index object.
  * @param config.attributesToIndex - List of attributes to index.
+ * @param config.syncOptions - Sync configuration options.
  * @returns A class definition that will be loaded into the Mongoose schema.
  */
-const createMeiliMongooseModel = ({ index, attributesToIndex, }) => {
+const createMeiliMongooseModel = ({ index, attributesToIndex, syncOptions, }) => {
     const primaryKey = attributesToIndex[0];
+    const syncConfig = { ...getSyncConfig(), ...syncOptions };
     class MeiliMongooseModel {
+        /**
+         * Get the current sync progress
+         */
+        static async getSyncProgress() {
+            const totalDocuments = await this.countDocuments();
+            const indexedDocuments = await this.countDocuments({ _meiliIndex: true });
+            return {
+                totalProcessed: indexedDocuments,
+                totalDocuments,
+                isComplete: indexedDocuments === totalDocuments,
+            };
+        }
         /**
          * Synchronizes the data between the MongoDB collection and the MeiliSearch index.
-         *
-         * The synchronization process involves:
-         *   1. Fetching all documents from the MongoDB collection and MeiliSearch index.
-         *   2. Comparing documents from both sources.
-         *   3. Deleting documents from MeiliSearch that no longer exist in MongoDB.
-         *   4. Adding documents to MeiliSearch that exist in MongoDB but not in the index.
-         *   5. Updating documents in MeiliSearch if key fields (such as `text` or `title`) differ.
-         *   6. Updating the `_meiliIndex` field in MongoDB to indicate the indexing status.
-         *
-         * Note: The function processes documents in batches because MeiliSearch's
-         * `index.getDocuments` requires an exact limit and `index.addDocuments` does not handle
-         * partial failures in a batch.
-         *
-         * @returns {Promise<void>} Resolves when the synchronization is complete.
+         * Now uses streaming and batching to reduce memory usage.
          */
-        static async syncWithMeili() {
+        static async syncWithMeili(options) {
             try {
-                let moreDocuments = true;
-                const mongoDocuments = await this.find().lean();
+                const startTime = Date.now();
+                const { batchSize, delayMs } = syncConfig;
+                logger$1.info(`[syncWithMeili] Starting sync for ${primaryKey === 'messageId' ? 'messages' : 'conversations'} with batch size ${batchSize}`);
+                // Build query with resume capability
+                const query = {};
+                if (options === null || options === void 0 ? void 0 : options.resumeFromId) {
+                    query._id = { $gt: options.resumeFromId };
+                }
+                // Get total count for progress tracking
+                const totalCount = await this.countDocuments(query);
+                let processedCount = 0;
+                // First, handle documents that need to be removed from Meili
+                await this.cleanupMeiliIndex(index, primaryKey, batchSize, delayMs);
+                // Process MongoDB documents in batches using cursor
+                const cursor = this.find(query)
+                    .select(attributesToIndex.join(' ') + ' _meiliIndex')
+                    .sort({ _id: 1 })
+                    .batchSize(batchSize)
+                    .cursor();
                 const format = (doc) => _.omitBy(_.pick(doc, attributesToIndex), (v, k) => k.startsWith('$'));
-                const mongoMap = new Map(mongoDocuments.map((doc) => {
-                    const typedDoc = doc;
-                    return [typedDoc[primaryKey], format(typedDoc)];
-                }));
-                const indexMap = new Map();
+                let documentBatch = [];
+                let updateOps = [];
+                // Process documents in streaming fashion
+                for await (const doc of cursor) {
+                    const typedDoc = doc.toObject();
+                    const formatted = format(typedDoc);
+                    // Check if document needs indexing
+                    if (!typedDoc._meiliIndex) {
+                        documentBatch.push(formatted);
+                        updateOps.push({
+                            updateOne: {
+                                filter: { _id: typedDoc._id },
+                                update: { $set: { _meiliIndex: true } },
+                            },
+                        });
+                    }
+                    processedCount++;
+                    // Process batch when it reaches the configured size
+                    if (documentBatch.length >= batchSize) {
+                        await this.processSyncBatch(index, documentBatch, updateOps);
+                        documentBatch = [];
+                        updateOps = [];
+                        // Log progress
+                        const progress = Math.round((processedCount / totalCount) * 100);
+                        logger$1.info(`[syncWithMeili] Progress: ${progress}% (${processedCount}/${totalCount})`);
+                        // Add delay to prevent overwhelming resources
+                        if (delayMs > 0) {
+                            await new Promise((resolve) => setTimeout(resolve, delayMs));
+                        }
+                    }
+                }
+                // Process remaining documents
+                if (documentBatch.length > 0) {
+                    await this.processSyncBatch(index, documentBatch, updateOps);
+                }
+                const duration = Date.now() - startTime;
+                logger$1.info(`[syncWithMeili] Completed sync for ${primaryKey === 'messageId' ? 'messages' : 'conversations'} in ${duration}ms`);
+            }
+            catch (error) {
+                logger$1.error('[syncWithMeili] Error during sync:', error);
+                throw error;
+            }
+        }
+        /**
+         * Process a batch of documents for syncing
+         */
+        static async processSyncBatch(index, documents, updateOps) {
+            if (documents.length === 0) {
+                return;
+            }
+            try {
+                // Add documents to MeiliSearch
+                await index.addDocuments(documents);
+                // Update MongoDB to mark documents as indexed
+                if (updateOps.length > 0) {
+                    await this.collection.bulkWrite(updateOps);
+                }
+            }
+            catch (error) {
+                logger$1.error('[processSyncBatch] Error processing batch:', error);
+                // Don't throw - allow sync to continue with other documents
+            }
+        }
+        /**
+         * Clean up documents in MeiliSearch that no longer exist in MongoDB
+         */
+        static async cleanupMeiliIndex(index, primaryKey, batchSize, delayMs) {
+            try {
                 let offset = 0;
-                const batchSize = 1000;
+                let moreDocuments = true;
                 while (moreDocuments) {
                     const batch = await index.getDocuments({ limit: batchSize, offset });
                     if (batch.results.length === 0) {
                         moreDocuments = false;
+                        break;
                     }
-                    for (const doc of batch.results) {
-                        indexMap.set(doc[primaryKey], format(doc));
+                    const meiliIds = batch.results.map((doc) => doc[primaryKey]);
+                    const query = {};
+                    query[primaryKey] = { $in: meiliIds };
+                    // Find which documents exist in MongoDB
+                    const existingDocs = await this.find(query).select(primaryKey).lean();
+                    const existingIds = new Set(existingDocs.map((doc) => doc[primaryKey]));
+                    // Delete documents that don't exist in MongoDB
+                    const toDelete = meiliIds.filter((id) => !existingIds.has(id));
+                    if (toDelete.length > 0) {
+                        await Promise.all(toDelete.map((id) => index.deleteDocument(id)));
+                        logger$1.debug(`[cleanupMeiliIndex] Deleted ${toDelete.length} orphaned documents`);
                     }
                     offset += batchSize;
-                }
-                logger$1.debug('[syncWithMeili]', { indexMap: indexMap.size, mongoMap: mongoMap.size });
-                const updateOps = [];
-                // Process documents present in the MeiliSearch index
-                for (const [id, doc] of indexMap) {
-                    const update = {};
-                    update[primaryKey] = id;
-                    if (mongoMap.has(id)) {
-                        const mongoDoc = mongoMap.get(id);
-                        if ((doc.text && doc.text !== (mongoDoc === null || mongoDoc === void 0 ? void 0 : mongoDoc.text)) ||
-                            (doc.title && doc.title !== (mongoDoc === null || mongoDoc === void 0 ? void 0 : mongoDoc.title))) {
-                            logger$1.debug(`[syncWithMeili] ${id} had document discrepancy in ${doc.text ? 'text' : 'title'} field`);
-                            updateOps.push({
-                                updateOne: { filter: update, update: { $set: { _meiliIndex: true } } },
-                            });
-                            await index.addDocuments([doc]);
-                        }
-                    }
-                    else {
-                        await index.deleteDocument(id);
-                        updateOps.push({
-                            updateOne: { filter: update, update: { $set: { _meiliIndex: false } } },
-                        });
-                    }
-                }
-                // Process documents present in MongoDB
-                for (const [id, doc] of mongoMap) {
-                    const update = {};
-                    update[primaryKey] = id;
-                    if (!indexMap.has(id)) {
-                        await index.addDocuments([doc]);
-                        updateOps.push({
-                            updateOne: { filter: update, update: { $set: { _meiliIndex: true } } },
-                        });
-                    }
-                    else if (doc._meiliIndex === false) {
-                        updateOps.push({
-                            updateOne: { filter: update, update: { $set: { _meiliIndex: true } } },
-                        });
+                    // Add delay between batches
+                    if (delayMs > 0) {
+                        await new Promise((resolve) => setTimeout(resolve, delayMs));
                     }
                 }
-                if (updateOps.length > 0) {
-                    await this.collection.bulkWrite(updateOps);
-                    logger$1.debug(`[syncWithMeili] Finished indexing ${primaryKey === 'messageId' ? 'messages' : 'conversations'}`);
-                }
             }
             catch (error) {
-                logger$1.error('[syncWithMeili] Error adding document to Meili:', error);
+                logger$1.error('[cleanupMeiliIndex] Error during cleanup:', error);
             }
         }
         /**
@@ -1521,16 +1611,26 @@ const createMeiliMongooseModel = ({ index, attributesToIndex, }) => {
             return object;
         }
         /**
-         * Adds the current document to the MeiliSearch index
+         * Adds the current document to the MeiliSearch index with retry logic
          */
         async addObjectToMeili(next) {
             const object = this.preprocessObjectForIndex();
-            try {
-                await index.addDocuments([object]);
-            }
-            catch (error) {
-                logger$1.error('[addObjectToMeili] Error adding document to Meili:', error);
-                return next();
+            const maxRetries = 3;
+            let retryCount = 0;
+            while (retryCount < maxRetries) {
+                try {
+                    await index.addDocuments([object]);
+                    break;
+                }
+                catch (error) {
+                    retryCount++;
+                    if (retryCount >= maxRetries) {
+                        logger$1.error('[addObjectToMeili] Error adding document to Meili after retries:', error);
+                        return next();
+                    }
+                    // Exponential backoff
+                    await new Promise((resolve) => setTimeout(resolve, Math.pow(2, retryCount) * 1000));
+                }
             }
             try {
                 await this.collection.updateMany({ _id: this._id }, { $set: { _meiliIndex: true } });
@@ -1631,6 +1731,8 @@ const createMeiliMongooseModel = ({ index, attributesToIndex, }) => {
  * @param options.apiKey - The MeiliSearch API key.
  * @param options.indexName - The name of the MeiliSearch index.
  * @param options.primaryKey - The primary key field for indexing.
+ * @param options.syncBatchSize - Batch size for sync operations.
+ * @param options.syncDelayMs - Delay between batches in milliseconds.
  */
 function mongoMeili(schema, options) {
     const mongoose = options.mongoose;
@@ -1645,9 +1747,37 @@ function mongoMeili(schema, options) {
         },
     });
     const { host, apiKey, indexName, primaryKey } = options;
+    const syncOptions = {
+        batchSize: options.syncBatchSize || getSyncConfig().batchSize,
+        delayMs: options.syncDelayMs || getSyncConfig().delayMs,
+    };
     const client = new MeiliSearch({ host, apiKey });
-    client.createIndex(indexName, { primaryKey });
+    /** Create index only if it doesn't exist */
     const index = client.index(indexName);
+    // Check if index exists and create if needed
+    (async () => {
+        try {
+            await index.getRawInfo();
+            logger$1.debug(`[mongoMeili] Index ${indexName} already exists`);
+        }
+        catch (error) {
+            const errorCode = error === null || error === void 0 ? void 0 : error.code;
+            if (errorCode === 'index_not_found') {
+                try {
+                    logger$1.info(`[mongoMeili] Creating new index: ${indexName}`);
+                    await client.createIndex(indexName, { primaryKey });
+                    logger$1.info(`[mongoMeili] Successfully created index: ${indexName}`);
+                }
+                catch (createError) {
+                    // Index might have been created by another instance
+                    logger$1.debug(`[mongoMeili] Index ${indexName} may already exist:`, createError);
+                }
+            }
+            else {
+                logger$1.error(`[mongoMeili] Error checking index ${indexName}:`, error);
+            }
+        }
+    })();
     // Collect attributes from the schema that should be indexed
     const attributesToIndex = [
         ...Object.entries(schema.obj).reduce((results, [key, value]) => {
@@ -1655,7 +1785,7 @@ function mongoMeili(schema, options) {
             return schemaValue.meiliIndex ? [...results, key] : results;
         }, []),
     ];
-    schema.loadClass(createMeiliMongooseModel({ index, attributesToIndex }));
+    schema.loadClass(createMeiliMongooseModel({ index, attributesToIndex, syncOptions }));
     // Register Mongoose hooks
     schema.post('save', function (doc, next) {
         var _a;
@@ -1676,29 +1806,38 @@ function mongoMeili(schema, options) {
         }
         try {
             const conditions = this.getQuery();
+            const { batchSize, delayMs } = syncOptions;
             if (Object.prototype.hasOwnProperty.call(schema.obj, 'messages')) {
                 const convoIndex = client.index('convos');
                 const deletedConvos = await mongoose
                     .model('Conversation')
                     .find(conditions)
+                    .select('conversationId')
                     .lean();
-                const promises = deletedConvos.map((convo) => convoIndex.deleteDocument(convo.conversationId));
-                await Promise.all(promises);
+                // Process deletions in batches
+                await processBatch(deletedConvos, batchSize, delayMs, async (batch) => {
+                    const promises = batch.map((convo) => convoIndex.deleteDocument(convo.conversationId));
+                    await Promise.all(promises);
+                });
             }
             if (Object.prototype.hasOwnProperty.call(schema.obj, 'messageId')) {
                 const messageIndex = client.index('messages');
                 const deletedMessages = await mongoose
                     .model('Message')
                     .find(conditions)
+                    .select('messageId')
                     .lean();
-                const promises = deletedMessages.map((message) => messageIndex.deleteDocument(message.messageId));
-                await Promise.all(promises);
+                // Process deletions in batches
+                await processBatch(deletedMessages, batchSize, delayMs, async (batch) => {
+                    const promises = batch.map((message) => messageIndex.deleteDocument(message.messageId));
+                    await Promise.all(promises);
+                });
             }
             return next();
         }
         catch (error) {
             if (meiliEnabled) {
-                logger$1.error('[MeiliMongooseModel.deleteMany] There was an issue deleting conversation indexes upon deletion. Next startup may be slow due to syncing.', error);
+                logger$1.error('[MeiliMongooseModel.deleteMany] There was an issue deleting conversation indexes upon deletion. Next startup may trigger syncing.', error);
             }
             return next();
         }
@@ -2372,12 +2511,9 @@ class SessionError extends Error {
     }
 }
 const { REFRESH_TOKEN_EXPIRY } = (_a = process.env) !== null && _a !== void 0 ? _a : {};
-const expires = REFRESH_TOKEN_EXPIRY
-    ? eval(REFRESH_TOKEN_EXPIRY)
-    : 1000 * 60 * 60 * 24 * 7; // 7 days default
+const expires = REFRESH_TOKEN_EXPIRY ? eval(REFRESH_TOKEN_EXPIRY) : 1000 * 60 * 60 * 24 * 7; // 7 days default
 // Factory function that takes mongoose instance and returns the methods
 function createSessionMethods(mongoose) {
-    const Session = mongoose.models.Session;
     /**
      * Creates a new session for a user
      */
@@ -2386,12 +2522,13 @@ function createSessionMethods(mongoose) {
             throw new SessionError('User ID is required', 'INVALID_USER_ID');
         }
         try {
-            const session = new Session({
+            const Session = mongoose.models.Session;
+            const currentSession = new Session({
                 user: userId,
                 expiration: options.expiration || new Date(Date.now() + expires),
             });
-            const refreshToken = await generateRefreshToken(session);
-            return { session, refreshToken };
+            const refreshToken = await generateRefreshToken(currentSession);
+            return { session: currentSession, refreshToken };
         }
         catch (error) {
             logger.error('[createSession] Error creating session:', error);
@@ -2403,6 +2540,7 @@ function createSessionMethods(mongoose) {
      */
     async function findSession(params, options = { lean: true }) {
         try {
+            const Session = mongoose.models.Session;
             const query = {};
             if (!params.refreshToken && !params.userId && !params.sessionId) {
                 throw new SessionError('At least one search parameter is required', 'INVALID_SEARCH_PARAMS');
@@ -2443,6 +2581,7 @@ function createSessionMethods(mongoose) {
      */
     async function updateExpiration(session, newExpiration) {
         try {
+            const Session = mongoose.models.Session;
             const sessionDoc = typeof session === 'string' ? await Session.findById(session) : session;
             if (!sessionDoc) {
                 throw new SessionError('Session not found', 'SESSION_NOT_FOUND');
@@ -2460,6 +2599,7 @@ function createSessionMethods(mongoose) {
      */
     async function deleteSession(params) {
         try {
+            const Session = mongoose.models.Session;
             if (!params.refreshToken && !params.sessionId) {
                 throw new SessionError('Either refreshToken or sessionId is required', 'INVALID_DELETE_PARAMS');
             }
@@ -2486,6 +2626,7 @@ function createSessionMethods(mongoose) {
      */
     async function deleteAllUserSessions(userId, options = {}) {
         try {
+            const Session = mongoose.models.Session;
             if (!userId) {
                 throw new SessionError('User ID is required', 'INVALID_USER_ID');
             }
@@ -2542,6 +2683,7 @@ function createSessionMethods(mongoose) {
      */
     async function countActiveSessions(userId) {
         try {
+            const Session = mongoose.models.Session;
             if (!userId) {
                 throw new SessionError('User ID is required', 'INVALID_USER_ID');
             }
@@ -2712,7 +2854,6 @@ const formatDate = (date) => {
 };
 // Factory function that takes mongoose instance and returns the methods
 function createMemoryMethods(mongoose) {
-    const MemoryEntry = mongoose.models.MemoryEntry;
     /**
      * Creates a new memory entry for a user
      * Throws an error if a memory with the same key already exists
@@ -2722,6 +2863,7 @@ function createMemoryMethods(mongoose) {
             if ((key === null || key === void 0 ? void 0 : key.toLowerCase()) === 'nothing') {
                 return { ok: false };
             }
+            const MemoryEntry = mongoose.models.MemoryEntry;
             const existingMemory = await MemoryEntry.findOne({ userId, key });
             if (existingMemory) {
                 throw new Error('Memory with this key already exists');
@@ -2747,6 +2889,7 @@ function createMemoryMethods(mongoose) {
             if ((key === null || key === void 0 ? void 0 : key.toLowerCase()) === 'nothing') {
                 return { ok: false };
             }
+            const MemoryEntry = mongoose.models.MemoryEntry;
             await MemoryEntry.findOneAndUpdate({ userId, key }, {
                 value,
                 tokenCount,
@@ -2766,6 +2909,7 @@ function createMemoryMethods(mongoose) {
      */
     async function deleteMemory({ userId, key }) {
         try {
+            const MemoryEntry = mongoose.models.MemoryEntry;
             const result = await MemoryEntry.findOneAndDelete({ userId, key });
             return { ok: !!result };
         }
@@ -2778,6 +2922,7 @@ function createMemoryMethods(mongoose) {
      */
     async function getAllUserMemories(userId) {
         try {
+            const MemoryEntry = mongoose.models.MemoryEntry;
             return (await MemoryEntry.find({ userId }).lean());
         }
         catch (error) {
@@ -3188,12 +3333,12 @@ function createShareMethods(mongoose) {
 
 // Factory function that takes mongoose instance and returns the methods
 function createPluginAuthMethods(mongoose) {
-    const PluginAuth = mongoose.models.PluginAuth;
     /**
      * Finds a single plugin auth entry by userId and authField
      */
     async function findOnePluginAuth({ userId, authField, }) {
         try {
+            const PluginAuth = mongoose.models.PluginAuth;
             return await PluginAuth.findOne({ userId, authField }).lean();
         }
         catch (error) {
@@ -3208,6 +3353,7 @@ function createPluginAuthMethods(mongoose) {
             if (!pluginKeys || pluginKeys.length === 0) {
                 return [];
             }
+            const PluginAuth = mongoose.models.PluginAuth;
             return await PluginAuth.find({
                 userId,
                 pluginKey: { $in: pluginKeys },
@@ -3222,6 +3368,7 @@ function createPluginAuthMethods(mongoose) {
      */
     async function updatePluginAuth({ userId, authField, pluginKey, value, }) {
         try {
+            const PluginAuth = mongoose.models.PluginAuth;
             const existingAuth = await PluginAuth.findOne({ userId, pluginKey, authField }).lean();
             if (existingAuth) {
                 return await PluginAuth.findOneAndUpdate({ userId, pluginKey, authField }, { $set: { value } }, { new: true, upsert: true }).lean();
@@ -3246,6 +3393,7 @@ function createPluginAuthMethods(mongoose) {
      */
     async function deletePluginAuth({ userId, authField, pluginKey, all = false, }) {
         try {
+            const PluginAuth = mongoose.models.PluginAuth;
             if (all) {
                 const filter = { userId };
                 if (pluginKey) {
@@ -3267,6 +3415,7 @@ function createPluginAuthMethods(mongoose) {
      */
     async function deleteAllUserPluginAuths(userId) {
         try {
+            const PluginAuth = mongoose.models.PluginAuth;
             return await PluginAuth.deleteMany({ userId });
         }
         catch (error) {