@librechat/data-schemas 0.0.8 → 0.0.11

package/dist/index.cjs

@@ -11,6 +11,7 @@ var winston = require('winston');
 require('winston-daily-rotate-file');
 var klona = require('klona');
 var traverse = require('traverse');
+var nanoid = require('nanoid');
 
 async function signPayload({ payload, secret, expirationTime, }) {
     return jwt.sign(payload, secret, { expiresIn: expirationTime });
@@ -426,10 +427,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 mongoose.Schema({
@@ -870,7 +884,7 @@ const promptGroupSchema = new mongoose.Schema({
             validator: function (v) {
                 return v === undefined || v === null || v === '' || /^[a-z0-9-]+$/.test(v);
             },
-            message: (props) => `${props.value} is not a valid command. Only lowercase alphanumeric characters and hyphens are allowed.`,
+            message: (props) => { var _a; return `${(_a = props === null || props === void 0 ? void 0 : props.value) !== null && _a !== void 0 ? _a : 'Value'} is not a valid command. Only lowercase alphanumeric characters and hyphens are allowed.`; },
         },
         maxlength: [
             librechatDataProvider.Constants.COMMANDS_MAX_LENGTH,
@@ -882,7 +896,9 @@ const promptGroupSchema = new mongoose.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 mongoose.Schema({
     [librechatDataProvider.PermissionTypes.BOOKMARKS]: {
         [librechatDataProvider.Permissions.USE]: { type: Boolean, default: true },
@@ -892,6 +908,13 @@ const rolePermissionsSchema = new mongoose.Schema({
         [librechatDataProvider.Permissions.USE]: { type: Boolean, default: true },
         [librechatDataProvider.Permissions.CREATE]: { type: Boolean, default: true },
     },
+    [librechatDataProvider.PermissionTypes.MEMORIES]: {
+        [librechatDataProvider.Permissions.USE]: { type: Boolean, default: true },
+        [librechatDataProvider.Permissions.CREATE]: { type: Boolean, default: true },
+        [librechatDataProvider.Permissions.UPDATE]: { type: Boolean, default: true },
+        [librechatDataProvider.Permissions.READ]: { type: Boolean, default: true },
+        [librechatDataProvider.Permissions.OPT_OUT]: { type: Boolean, default: true },
+    },
     [librechatDataProvider.PermissionTypes.AGENTS]: {
         [librechatDataProvider.Permissions.SHARED_GLOBAL]: { type: Boolean, default: false },
         [librechatDataProvider.Permissions.USE]: { type: Boolean, default: true },
@@ -909,6 +932,9 @@ const rolePermissionsSchema = new mongoose.Schema({
     [librechatDataProvider.PermissionTypes.WEB_SEARCH]: {
         [librechatDataProvider.Permissions.USE]: { type: Boolean, default: true },
     },
+    [librechatDataProvider.PermissionTypes.FILE_SEARCH]: {
+        [librechatDataProvider.Permissions.USE]: { type: Boolean, default: true },
+    },
 }, { _id: false });
 const roleSchema = new mongoose.Schema({
     name: { type: String, required: true, unique: true, index: true },
@@ -921,6 +947,12 @@ const roleSchema = new mongoose.Schema({
                 [librechatDataProvider.Permissions.USE]: true,
                 [librechatDataProvider.Permissions.CREATE]: true,
             },
+            [librechatDataProvider.PermissionTypes.MEMORIES]: {
+                [librechatDataProvider.Permissions.USE]: true,
+                [librechatDataProvider.Permissions.CREATE]: true,
+                [librechatDataProvider.Permissions.UPDATE]: true,
+                [librechatDataProvider.Permissions.READ]: true,
+            },
             [librechatDataProvider.PermissionTypes.AGENTS]: {
                 [librechatDataProvider.Permissions.SHARED_GLOBAL]: false,
                 [librechatDataProvider.Permissions.USE]: true,
@@ -930,6 +962,7 @@ const roleSchema = new mongoose.Schema({
             [librechatDataProvider.PermissionTypes.TEMPORARY_CHAT]: { [librechatDataProvider.Permissions.USE]: true },
             [librechatDataProvider.PermissionTypes.RUN_CODE]: { [librechatDataProvider.Permissions.USE]: true },
             [librechatDataProvider.PermissionTypes.WEB_SEARCH]: { [librechatDataProvider.Permissions.USE]: true },
+            [librechatDataProvider.PermissionTypes.FILE_SEARCH]: { [librechatDataProvider.Permissions.USE]: true },
         }),
     },
 });
@@ -1198,8 +1231,46 @@ const userSchema = new mongoose.Schema({
         type: Boolean,
         default: false,
     },
+    personalization: {
+        type: {
+            memories: {
+                type: Boolean,
+                default: true,
+            },
+        },
+        default: {},
+    },
 }, { timestamps: true });
 
+const MemoryEntrySchema = new mongoose.Schema({
+    userId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'User',
+        index: true,
+        required: true,
+    },
+    key: {
+        type: String,
+        required: true,
+        validate: {
+            validator: (v) => /^[a-z_]+$/.test(v),
+            message: 'Key must only contain lowercase letters and underscores',
+        },
+    },
+    value: {
+        type: String,
+        required: true,
+    },
+    tokenCount: {
+        type: Number,
+        default: 0,
+    },
+    updated_at: {
+        type: Date,
+        default: Date.now,
+    },
+});
+
 /**
  * Creates or returns the User model using the provided mongoose instance and schema
  */
@@ -1228,7 +1299,7 @@ function createBalanceModel(mongoose) {
     return mongoose.models.Balance || mongoose.model('Balance', balanceSchema);
 }
 
-const logDir$1 = path.join(__dirname, '..', 'logs');
+const logDir$1 = path.join(__dirname, '..', '..', '..', 'api', 'logs');
 const { NODE_ENV: NODE_ENV$1, DEBUG_LOGGING: DEBUG_LOGGING$1 = 'false' } = process.env;
 const useDebugLogging$1 = (typeof DEBUG_LOGGING$1 === 'string' && DEBUG_LOGGING$1.toLowerCase() === 'true') ||
     DEBUG_LOGGING$1 === 'true';
@@ -1286,6 +1357,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
@@ -1317,6 +1395,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
@@ -1325,97 +1416,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);
             }
         }
         /**
@@ -1471,32 +1613,64 @@ 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() {
+        async addObjectToMeili(next) {
             const object = this.preprocessObjectForIndex();
+            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 index.addDocuments([object]);
+                await this.collection.updateMany({ _id: this._id }, { $set: { _meiliIndex: true } });
             }
             catch (error) {
-                logger$1.error('[addObjectToMeili] Error adding document to Meili', error);
+                logger$1.error('[addObjectToMeili] Error updating _meiliIndex field:', error);
+                return next();
             }
-            await this.collection.updateMany({ _id: this._id }, { $set: { _meiliIndex: true } });
+            next();
         }
         /**
          * Updates the current document in the MeiliSearch index
          */
-        async updateObjectToMeili() {
-            const object = _.omitBy(_.pick(this.toJSON(), attributesToIndex), (v, k) => k.startsWith('$'));
-            await index.updateDocuments([object]);
+        async updateObjectToMeili(next) {
+            try {
+                const object = _.omitBy(_.pick(this.toJSON(), attributesToIndex), (v, k) => k.startsWith('$'));
+                await index.updateDocuments([object]);
+                next();
+            }
+            catch (error) {
+                logger$1.error('[updateObjectToMeili] Error updating document in Meili:', error);
+                return next();
+            }
         }
         /**
          * Deletes the current document from the MeiliSearch index.
          *
          * @returns {Promise<void>}
          */
-        async deleteObjectFromMeili() {
-            await index.deleteDocument(this._id);
+        async deleteObjectFromMeili(next) {
+            try {
+                await index.deleteDocument(this._id);
+                next();
+            }
+            catch (error) {
+                logger$1.error('[deleteObjectFromMeili] Error deleting document from Meili:', error);
+                return next();
+            }
         }
         /**
          * Post-save hook to synchronize the document with MeiliSearch.
@@ -1504,12 +1678,12 @@ const createMeiliMongooseModel = ({ index, attributesToIndex, }) => {
          * If the document is already indexed (i.e. `_meiliIndex` is true), it updates it;
          * otherwise, it adds the document to the index.
          */
-        postSaveHook() {
+        postSaveHook(next) {
             if (this._meiliIndex) {
-                this.updateObjectToMeili();
+                this.updateObjectToMeili(next);
             }
             else {
-                this.addObjectToMeili();
+                this.addObjectToMeili(next);
             }
         }
         /**
@@ -1518,9 +1692,12 @@ const createMeiliMongooseModel = ({ index, attributesToIndex, }) => {
          * This hook is triggered after a document update, ensuring that changes are
          * propagated to the MeiliSearch index if the document is indexed.
          */
-        postUpdateHook() {
+        postUpdateHook(next) {
             if (this._meiliIndex) {
-                this.updateObjectToMeili();
+                this.updateObjectToMeili(next);
+            }
+            else {
+                next();
             }
         }
         /**
@@ -1529,9 +1706,12 @@ const createMeiliMongooseModel = ({ index, attributesToIndex, }) => {
          * This hook is triggered after a document is removed, ensuring that the document
          * is also removed from the MeiliSearch index if it was previously indexed.
          */
-        postRemoveHook() {
+        postRemoveHook(next) {
             if (this._meiliIndex) {
-                this.deleteObjectFromMeili();
+                this.deleteObjectFromMeili(next);
+            }
+            else {
+                next();
             }
         }
     }
@@ -1553,6 +1733,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;
@@ -1567,9 +1749,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.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]) => {
@@ -1577,19 +1787,19 @@ 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) {
+    schema.post('save', function (doc, next) {
         var _a;
-        (_a = doc.postSaveHook) === null || _a === void 0 ? void 0 : _a.call(doc);
+        (_a = doc.postSaveHook) === null || _a === void 0 ? void 0 : _a.call(doc, next);
     });
-    schema.post('updateOne', function (doc) {
+    schema.post('updateOne', function (doc, next) {
         var _a;
-        (_a = doc.postUpdateHook) === null || _a === void 0 ? void 0 : _a.call(doc);
+        (_a = doc.postUpdateHook) === null || _a === void 0 ? void 0 : _a.call(doc, next);
     });
-    schema.post('deleteOne', function (doc) {
+    schema.post('deleteOne', function (doc, next) {
         var _a;
-        (_a = doc.postRemoveHook) === null || _a === void 0 ? void 0 : _a.call(doc);
+        (_a = doc.postRemoveHook) === null || _a === void 0 ? void 0 : _a.call(doc, next);
     });
     // Pre-deleteMany hook: remove corresponding documents from MeiliSearch when multiple documents are deleted.
     schema.pre('deleteMany', async function (next) {
@@ -1598,41 +1808,50 @@ 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();
         }
     });
     // Post-findOneAndUpdate hook
-    schema.post('findOneAndUpdate', async function (doc) {
+    schema.post('findOneAndUpdate', async function (doc, next) {
         var _a;
         if (!meiliEnabled) {
-            return;
+            return next();
         }
         if (doc.unfinished) {
-            return;
+            return next();
         }
         let meiliDoc;
         if (doc.messages) {
@@ -1645,9 +1864,9 @@ function mongoMeili(schema, options) {
             }
         }
         if (meiliDoc && meiliDoc.title === doc.title) {
-            return;
+            return next();
         }
-        (_a = doc.postSaveHook) === null || _a === void 0 ? void 0 : _a.call(doc);
+        (_a = doc.postSaveHook) === null || _a === void 0 ? void 0 : _a.call(doc, next);
     });
 }
 
@@ -1798,6 +2017,10 @@ function createToolCallModel(mongoose) {
     return mongoose.models.ToolCall || mongoose.model('ToolCall', toolCallSchema);
 }
 
+function createMemoryModel(mongoose) {
+    return mongoose.models.MemoryEntry || mongoose.model('MemoryEntry', MemoryEntrySchema);
+}
+
 /**
  * Creates all database models for all collections
  */
@@ -1825,6 +2048,7 @@ function createModels(mongoose) {
         ConversationTag: createConversationTagModel(mongoose),
         SharedLink: createSharedLinkModel(mongoose),
         ToolCall: createToolCallModel(mongoose),
+        MemoryEntry: createMemoryModel(mongoose),
     };
 }
 
@@ -1960,6 +2184,28 @@ function createUserMethods(mongoose) {
             expirationTime: expires / 1000,
         });
     }
+    /**
+     * Update a user's personalization memories setting.
+     * Handles the edge case where the personalization object doesn't exist.
+     */
+    async function toggleUserMemories(userId, memoriesEnabled) {
+        const User = mongoose.models.User;
+        // First, ensure the personalization object exists
+        const user = await User.findById(userId);
+        if (!user) {
+            return null;
+        }
+        // Use $set to update the nested field, which will create the personalization object if it doesn't exist
+        const updateOperation = {
+            $set: {
+                'personalization.memories': memoriesEnabled,
+            },
+        };
+        return (await User.findByIdAndUpdate(userId, updateOperation, {
+            new: true,
+            runValidators: true,
+        }).lean());
+    }
     // Return all methods
     return {
         findUser,
@@ -1969,6 +2215,7 @@ function createUserMethods(mongoose) {
         getUserById,
         deleteUserById,
         generateToken,
+        toggleUserMemories,
     };
 }
 
@@ -2173,14 +2420,11 @@ const jsonTruncateFormat = winston.format((info) => {
     return truncateObject(info);
 });
 
-// Define log directory
-const logDir = path.join(__dirname, '..', 'logs');
-// Type-safe environment variables
+const logDir = path.join(__dirname, '..', '..', '..', 'api', 'logs');
 const { NODE_ENV, DEBUG_LOGGING, CONSOLE_JSON, DEBUG_CONSOLE } = process.env;
 const useConsoleJson = typeof CONSOLE_JSON === 'string' && CONSOLE_JSON.toLowerCase() === 'true';
 const useDebugConsole = typeof DEBUG_CONSOLE === 'string' && DEBUG_CONSOLE.toLowerCase() === 'true';
 const useDebugLogging = typeof DEBUG_LOGGING === 'string' && DEBUG_LOGGING.toLowerCase() === 'true';
-// Define custom log levels
 const levels = {
     error: 0,
     warn: 1,
@@ -2260,7 +2504,7 @@ const logger = winston.createLogger({
     transports,
 });
 
-var _a, _b;
+var _a;
 class SessionError extends Error {
     constructor(message, code = 'SESSION_ERROR') {
         super(message);
@@ -2269,10 +2513,9 @@ class SessionError extends Error {
     }
 }
 const { REFRESH_TOKEN_EXPIRY } = (_a = process.env) !== null && _a !== void 0 ? _a : {};
-const expires = (_b = eval(REFRESH_TOKEN_EXPIRY !== null && REFRESH_TOKEN_EXPIRY !== void 0 ? REFRESH_TOKEN_EXPIRY : '0')) !== null && _b !== void 0 ? _b : 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
      */
@@ -2281,12 +2524,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);
@@ -2298,6 +2542,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');
@@ -2338,6 +2583,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');
@@ -2355,6 +2601,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');
             }
@@ -2381,6 +2628,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');
             }
@@ -2437,6 +2685,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');
             }
@@ -2599,6 +2848,591 @@ function createRoleMethods(mongoose) {
     };
 }
 
+/**
+ * Formats a date in YYYY-MM-DD format
+ */
+const formatDate = (date) => {
+    return date.toISOString().split('T')[0];
+};
+// Factory function that takes mongoose instance and returns the methods
+function createMemoryMethods(mongoose) {
+    /**
+     * Creates a new memory entry for a user
+     * Throws an error if a memory with the same key already exists
+     */
+    async function createMemory({ userId, key, value, tokenCount = 0, }) {
+        try {
+            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');
+            }
+            await MemoryEntry.create({
+                userId,
+                key,
+                value,
+                tokenCount,
+                updated_at: new Date(),
+            });
+            return { ok: true };
+        }
+        catch (error) {
+            throw new Error(`Failed to create memory: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Sets or updates a memory entry for a user
+     */
+    async function setMemory({ userId, key, value, tokenCount = 0, }) {
+        try {
+            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,
+                updated_at: new Date(),
+            }, {
+                upsert: true,
+                new: true,
+            });
+            return { ok: true };
+        }
+        catch (error) {
+            throw new Error(`Failed to set memory: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Deletes a specific memory entry for a user
+     */
+    async function deleteMemory({ userId, key }) {
+        try {
+            const MemoryEntry = mongoose.models.MemoryEntry;
+            const result = await MemoryEntry.findOneAndDelete({ userId, key });
+            return { ok: !!result };
+        }
+        catch (error) {
+            throw new Error(`Failed to delete memory: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Gets all memory entries for a user
+     */
+    async function getAllUserMemories(userId) {
+        try {
+            const MemoryEntry = mongoose.models.MemoryEntry;
+            return (await MemoryEntry.find({ userId }).lean());
+        }
+        catch (error) {
+            throw new Error(`Failed to get all memories: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Gets and formats all memories for a user in two different formats
+     */
+    async function getFormattedMemories({ userId, }) {
+        try {
+            const memories = await getAllUserMemories(userId);
+            if (!memories || memories.length === 0) {
+                return { withKeys: '', withoutKeys: '', totalTokens: 0 };
+            }
+            const sortedMemories = memories.sort((a, b) => new Date(a.updated_at).getTime() - new Date(b.updated_at).getTime());
+            const totalTokens = sortedMemories.reduce((sum, memory) => {
+                return sum + (memory.tokenCount || 0);
+            }, 0);
+            const withKeys = sortedMemories
+                .map((memory, index) => {
+                const date = formatDate(new Date(memory.updated_at));
+                const tokenInfo = memory.tokenCount ? ` [${memory.tokenCount} tokens]` : '';
+                return `${index + 1}. [${date}]. ["key": "${memory.key}"]${tokenInfo}. ["value": "${memory.value}"]`;
+            })
+                .join('\n\n');
+            const withoutKeys = sortedMemories
+                .map((memory, index) => {
+                const date = formatDate(new Date(memory.updated_at));
+                return `${index + 1}. [${date}]. ${memory.value}`;
+            })
+                .join('\n\n');
+            return { withKeys, withoutKeys, totalTokens };
+        }
+        catch (error) {
+            logger.error('Failed to get formatted memories:', error);
+            return { withKeys: '', withoutKeys: '', totalTokens: 0 };
+        }
+    }
+    return {
+        setMemory,
+        createMemory,
+        deleteMemory,
+        getAllUserMemories,
+        getFormattedMemories,
+    };
+}
+
+class ShareServiceError extends Error {
+    constructor(message, code) {
+        super(message);
+        this.name = 'ShareServiceError';
+        this.code = code;
+    }
+}
+function memoizedAnonymizeId(prefix) {
+    const memo = new Map();
+    return (id) => {
+        if (!memo.has(id)) {
+            memo.set(id, `${prefix}_${nanoid.nanoid()}`);
+        }
+        return memo.get(id);
+    };
+}
+const anonymizeConvoId = memoizedAnonymizeId('convo');
+const anonymizeAssistantId = memoizedAnonymizeId('a');
+const anonymizeMessageId = (id) => id === librechatDataProvider.Constants.NO_PARENT ? id : memoizedAnonymizeId('msg')(id);
+function anonymizeConvo(conversation) {
+    if (!conversation) {
+        return null;
+    }
+    const newConvo = { ...conversation };
+    if (newConvo.assistant_id) {
+        newConvo.assistant_id = anonymizeAssistantId(newConvo.assistant_id);
+    }
+    return newConvo;
+}
+function anonymizeMessages(messages, newConvoId) {
+    if (!Array.isArray(messages)) {
+        return [];
+    }
+    const idMap = new Map();
+    return messages.map((message) => {
+        var _a, _b;
+        const newMessageId = anonymizeMessageId(message.messageId);
+        idMap.set(message.messageId, newMessageId);
+        const anonymizedAttachments = (_a = message.attachments) === null || _a === void 0 ? void 0 : _a.map((attachment) => {
+            return {
+                ...attachment,
+                messageId: newMessageId,
+                conversationId: newConvoId,
+            };
+        });
+        return {
+            ...message,
+            messageId: newMessageId,
+            parentMessageId: idMap.get(message.parentMessageId || '') ||
+                anonymizeMessageId(message.parentMessageId || ''),
+            conversationId: newConvoId,
+            model: ((_b = message.model) === null || _b === void 0 ? void 0 : _b.startsWith('asst_'))
+                ? anonymizeAssistantId(message.model)
+                : message.model,
+            attachments: anonymizedAttachments,
+        };
+    });
+}
+/** Factory function that takes mongoose instance and returns the methods */
+function createShareMethods(mongoose) {
+    /**
+     * Get shared messages for a public share link
+     */
+    async function getSharedMessages(shareId) {
+        try {
+            const SharedLink = mongoose.models.SharedLink;
+            const share = (await SharedLink.findOne({ shareId, isPublic: true })
+                .populate({
+                path: 'messages',
+                select: '-_id -__v -user',
+            })
+                .select('-_id -__v -user')
+                .lean());
+            if (!(share === null || share === void 0 ? void 0 : share.conversationId) || !share.isPublic) {
+                return null;
+            }
+            const newConvoId = anonymizeConvoId(share.conversationId);
+            const result = {
+                shareId: share.shareId || shareId,
+                title: share.title,
+                isPublic: share.isPublic,
+                createdAt: share.createdAt,
+                updatedAt: share.updatedAt,
+                conversationId: newConvoId,
+                messages: anonymizeMessages(share.messages, newConvoId),
+            };
+            return result;
+        }
+        catch (error) {
+            logger.error('[getSharedMessages] Error getting share link', {
+                error: error instanceof Error ? error.message : 'Unknown error',
+                shareId,
+            });
+            throw new ShareServiceError('Error getting share link', 'SHARE_FETCH_ERROR');
+        }
+    }
+    /**
+     * Get shared links for a specific user with pagination and search
+     */
+    async function getSharedLinks(user, pageParam, pageSize = 10, isPublic = true, sortBy = 'createdAt', sortDirection = 'desc', search) {
+        var _a;
+        try {
+            const SharedLink = mongoose.models.SharedLink;
+            const Conversation = mongoose.models.Conversation;
+            const query = { user, isPublic };
+            if (pageParam) {
+                if (sortDirection === 'desc') {
+                    query[sortBy] = { $lt: pageParam };
+                }
+                else {
+                    query[sortBy] = { $gt: pageParam };
+                }
+            }
+            if (search && search.trim()) {
+                try {
+                    const searchResults = await Conversation.meiliSearch(search);
+                    if (!((_a = searchResults === null || searchResults === void 0 ? void 0 : searchResults.hits) === null || _a === void 0 ? void 0 : _a.length)) {
+                        return {
+                            links: [],
+                            nextCursor: undefined,
+                            hasNextPage: false,
+                        };
+                    }
+                    const conversationIds = searchResults.hits.map((hit) => hit.conversationId);
+                    query['conversationId'] = { $in: conversationIds };
+                }
+                catch (searchError) {
+                    logger.error('[getSharedLinks] Meilisearch error', {
+                        error: searchError instanceof Error ? searchError.message : 'Unknown error',
+                        user,
+                    });
+                    return {
+                        links: [],
+                        nextCursor: undefined,
+                        hasNextPage: false,
+                    };
+                }
+            }
+            const sort = {};
+            sort[sortBy] = sortDirection === 'desc' ? -1 : 1;
+            const sharedLinks = await SharedLink.find(query)
+                .sort(sort)
+                .limit(pageSize + 1)
+                .select('-__v -user')
+                .lean();
+            const hasNextPage = sharedLinks.length > pageSize;
+            const links = sharedLinks.slice(0, pageSize);
+            const nextCursor = hasNextPage
+                ? links[links.length - 1][sortBy]
+                : undefined;
+            return {
+                links: links.map((link) => ({
+                    shareId: link.shareId || '',
+                    title: (link === null || link === void 0 ? void 0 : link.title) || 'Untitled',
+                    isPublic: link.isPublic,
+                    createdAt: link.createdAt || new Date(),
+                    conversationId: link.conversationId,
+                })),
+                nextCursor,
+                hasNextPage,
+            };
+        }
+        catch (error) {
+            logger.error('[getSharedLinks] Error getting shares', {
+                error: error instanceof Error ? error.message : 'Unknown error',
+                user,
+            });
+            throw new ShareServiceError('Error getting shares', 'SHARES_FETCH_ERROR');
+        }
+    }
+    /**
+     * Delete all shared links for a user
+     */
+    async function deleteAllSharedLinks(user) {
+        try {
+            const SharedLink = mongoose.models.SharedLink;
+            const result = await SharedLink.deleteMany({ user });
+            return {
+                message: 'All shared links deleted successfully',
+                deletedCount: result.deletedCount,
+            };
+        }
+        catch (error) {
+            logger.error('[deleteAllSharedLinks] Error deleting shared links', {
+                error: error instanceof Error ? error.message : 'Unknown error',
+                user,
+            });
+            throw new ShareServiceError('Error deleting shared links', 'BULK_DELETE_ERROR');
+        }
+    }
+    /**
+     * Create a new shared link for a conversation
+     */
+    async function createSharedLink(user, conversationId) {
+        if (!user || !conversationId) {
+            throw new ShareServiceError('Missing required parameters', 'INVALID_PARAMS');
+        }
+        try {
+            const Message = mongoose.models.Message;
+            const SharedLink = mongoose.models.SharedLink;
+            const Conversation = mongoose.models.Conversation;
+            const [existingShare, conversationMessages] = await Promise.all([
+                SharedLink.findOne({ conversationId, user, isPublic: true })
+                    .select('-_id -__v -user')
+                    .lean(),
+                Message.find({ conversationId, user }).sort({ createdAt: 1 }).lean(),
+            ]);
+            if (existingShare && existingShare.isPublic) {
+                logger.error('[createSharedLink] Share already exists', {
+                    user,
+                    conversationId,
+                });
+                throw new ShareServiceError('Share already exists', 'SHARE_EXISTS');
+            }
+            else if (existingShare) {
+                await SharedLink.deleteOne({ conversationId, user });
+            }
+            const conversation = (await Conversation.findOne({ conversationId, user }).lean());
+            // Check if user owns the conversation
+            if (!conversation) {
+                throw new ShareServiceError('Conversation not found or access denied', 'CONVERSATION_NOT_FOUND');
+            }
+            // Check if there are any messages to share
+            if (!conversationMessages || conversationMessages.length === 0) {
+                throw new ShareServiceError('No messages to share', 'NO_MESSAGES');
+            }
+            const title = conversation.title || 'Untitled';
+            const shareId = nanoid.nanoid();
+            await SharedLink.create({
+                shareId,
+                conversationId,
+                messages: conversationMessages,
+                title,
+                user,
+            });
+            return { shareId, conversationId };
+        }
+        catch (error) {
+            if (error instanceof ShareServiceError) {
+                throw error;
+            }
+            logger.error('[createSharedLink] Error creating shared link', {
+                error: error instanceof Error ? error.message : 'Unknown error',
+                user,
+                conversationId,
+            });
+            throw new ShareServiceError('Error creating shared link', 'SHARE_CREATE_ERROR');
+        }
+    }
+    /**
+     * Get a shared link for a conversation
+     */
+    async function getSharedLink(user, conversationId) {
+        if (!user || !conversationId) {
+            throw new ShareServiceError('Missing required parameters', 'INVALID_PARAMS');
+        }
+        try {
+            const SharedLink = mongoose.models.SharedLink;
+            const share = (await SharedLink.findOne({ conversationId, user, isPublic: true })
+                .select('shareId -_id')
+                .lean());
+            if (!share) {
+                return { shareId: null, success: false };
+            }
+            return { shareId: share.shareId || null, success: true };
+        }
+        catch (error) {
+            logger.error('[getSharedLink] Error getting shared link', {
+                error: error instanceof Error ? error.message : 'Unknown error',
+                user,
+                conversationId,
+            });
+            throw new ShareServiceError('Error getting shared link', 'SHARE_FETCH_ERROR');
+        }
+    }
+    /**
+     * Update a shared link with new messages
+     */
+    async function updateSharedLink(user, shareId) {
+        if (!user || !shareId) {
+            throw new ShareServiceError('Missing required parameters', 'INVALID_PARAMS');
+        }
+        try {
+            const SharedLink = mongoose.models.SharedLink;
+            const Message = mongoose.models.Message;
+            const share = (await SharedLink.findOne({ shareId, user })
+                .select('-_id -__v -user')
+                .lean());
+            if (!share) {
+                throw new ShareServiceError('Share not found', 'SHARE_NOT_FOUND');
+            }
+            const updatedMessages = await Message.find({ conversationId: share.conversationId, user })
+                .sort({ createdAt: 1 })
+                .lean();
+            const newShareId = nanoid.nanoid();
+            const update = {
+                messages: updatedMessages,
+                user,
+                shareId: newShareId,
+            };
+            const updatedShare = (await SharedLink.findOneAndUpdate({ shareId, user }, update, {
+                new: true,
+                upsert: false,
+                runValidators: true,
+            }).lean());
+            if (!updatedShare) {
+                throw new ShareServiceError('Share update failed', 'SHARE_UPDATE_ERROR');
+            }
+            anonymizeConvo(updatedShare);
+            return { shareId: newShareId, conversationId: updatedShare.conversationId };
+        }
+        catch (error) {
+            logger.error('[updateSharedLink] Error updating shared link', {
+                error: error instanceof Error ? error.message : 'Unknown error',
+                user,
+                shareId,
+            });
+            throw new ShareServiceError(error instanceof ShareServiceError ? error.message : 'Error updating shared link', error instanceof ShareServiceError ? error.code : 'SHARE_UPDATE_ERROR');
+        }
+    }
+    /**
+     * Delete a shared link
+     */
+    async function deleteSharedLink(user, shareId) {
+        if (!user || !shareId) {
+            throw new ShareServiceError('Missing required parameters', 'INVALID_PARAMS');
+        }
+        try {
+            const SharedLink = mongoose.models.SharedLink;
+            const result = await SharedLink.findOneAndDelete({ shareId, user }).lean();
+            if (!result) {
+                return null;
+            }
+            return {
+                success: true,
+                shareId,
+                message: 'Share deleted successfully',
+            };
+        }
+        catch (error) {
+            logger.error('[deleteSharedLink] Error deleting shared link', {
+                error: error instanceof Error ? error.message : 'Unknown error',
+                user,
+                shareId,
+            });
+            throw new ShareServiceError('Error deleting shared link', 'SHARE_DELETE_ERROR');
+        }
+    }
+    // Return all methods
+    return {
+        getSharedLink,
+        getSharedLinks,
+        createSharedLink,
+        updateSharedLink,
+        deleteSharedLink,
+        getSharedMessages,
+        deleteAllSharedLinks,
+    };
+}
+
+// Factory function that takes mongoose instance and returns the methods
+function createPluginAuthMethods(mongoose) {
+    /**
+     * 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) {
+            throw new Error(`Failed to find plugin auth: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Finds multiple plugin auth entries by userId and pluginKeys
+     */
+    async function findPluginAuthsByKeys({ userId, pluginKeys, }) {
+        try {
+            if (!pluginKeys || pluginKeys.length === 0) {
+                return [];
+            }
+            const PluginAuth = mongoose.models.PluginAuth;
+            return await PluginAuth.find({
+                userId,
+                pluginKey: { $in: pluginKeys },
+            }).lean();
+        }
+        catch (error) {
+            throw new Error(`Failed to find plugin auths: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Updates or creates a plugin auth entry
+     */
+    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();
+            }
+            else {
+                const newPluginAuth = await new PluginAuth({
+                    userId,
+                    authField,
+                    value,
+                    pluginKey,
+                });
+                await newPluginAuth.save();
+                return newPluginAuth.toObject();
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to update plugin auth: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Deletes plugin auth entries based on provided parameters
+     */
+    async function deletePluginAuth({ userId, authField, pluginKey, all = false, }) {
+        try {
+            const PluginAuth = mongoose.models.PluginAuth;
+            if (all) {
+                const filter = { userId };
+                if (pluginKey) {
+                    filter.pluginKey = pluginKey;
+                }
+                return await PluginAuth.deleteMany(filter);
+            }
+            if (!authField) {
+                throw new Error('authField is required when all is false');
+            }
+            return await PluginAuth.deleteOne({ userId, authField });
+        }
+        catch (error) {
+            throw new Error(`Failed to delete plugin auth: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Deletes all plugin auth entries for a user
+     */
+    async function deleteAllUserPluginAuths(userId) {
+        try {
+            const PluginAuth = mongoose.models.PluginAuth;
+            return await PluginAuth.deleteMany({ userId });
+        }
+        catch (error) {
+            throw new Error(`Failed to delete all user plugin auths: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    return {
+        findOnePluginAuth,
+        findPluginAuthsByKeys,
+        updatePluginAuth,
+        deletePluginAuth,
+        deleteAllUserPluginAuths,
+    };
+}
+
 /**
  * Creates all database methods for all collections
  */
@@ -2608,6 +3442,9 @@ function createMethods(mongoose) {
         ...createSessionMethods(mongoose),
         ...createTokenMethods(mongoose),
         ...createRoleMethods(mongoose),
+        ...createMemoryMethods(mongoose),
+        ...createShareMethods(mongoose),
+        ...createPluginAuthMethods(mongoose),
     };
 }
 
@@ -2626,6 +3463,7 @@ exports.hashToken = hashToken;
 exports.keySchema = keySchema;
 exports.logger = logger;
 exports.meiliLogger = logger$1;
+exports.memorySchema = MemoryEntrySchema;
 exports.messageSchema = messageSchema;
 exports.pluginAuthSchema = pluginAuthSchema;
 exports.presetSchema = presetSchema;