@librechat/data-schemas 0.0.7 → 0.0.10

package/dist/index.cjs

@@ -1,7 +1,26 @@
 'use strict';
 
+var jwt = require('jsonwebtoken');
+var node_crypto = require('node:crypto');
 var mongoose = require('mongoose');
 var librechatDataProvider = require('librechat-data-provider');
+var _ = require('lodash');
+var meilisearch = require('meilisearch');
+var path = require('path');
+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 });
+}
+async function hashToken(str) {
+    const data = new TextEncoder().encode(str);
+    const hashBuffer = await node_crypto.webcrypto.subtle.digest('SHA-256', data);
+    return Buffer.from(hashBuffer).toString('hex');
+}
 
 // Define the Auth sub-schema with type-safety.
 const AuthSchema = new mongoose.Schema({
@@ -133,6 +152,10 @@ const agentSchema = new mongoose.Schema({
         ref: 'Project',
         index: true,
     },
+    versions: {
+        type: [mongoose.Schema.Types.Mixed],
+        default: [],
+    },
 }, {
     timestamps: true,
 });
@@ -619,6 +642,25 @@ const messageSchema = new mongoose.Schema({
     finish_reason: {
         type: String,
     },
+    feedback: {
+        type: {
+            rating: {
+                type: String,
+                enum: ['thumbsUp', 'thumbsDown'],
+                required: true,
+            },
+            tag: {
+                type: mongoose.Schema.Types.Mixed,
+                required: false,
+            },
+            text: {
+                type: String,
+                required: false,
+            },
+        },
+        default: undefined,
+        required: false,
+    },
     _meiliIndex: {
         type: Boolean,
         required: false,
@@ -829,7 +871,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,
@@ -851,6 +893,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 },
@@ -865,6 +914,9 @@ const rolePermissionsSchema = new mongoose.Schema({
     [librechatDataProvider.PermissionTypes.RUN_CODE]: {
         [librechatDataProvider.Permissions.USE]: { type: Boolean, default: true },
     },
+    [librechatDataProvider.PermissionTypes.WEB_SEARCH]: {
+        [librechatDataProvider.Permissions.USE]: { type: Boolean, default: true },
+    },
 }, { _id: false });
 const roleSchema = new mongoose.Schema({
     name: { type: String, required: true, unique: true, index: true },
@@ -877,6 +929,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,
@@ -885,6 +943,7 @@ const roleSchema = new mongoose.Schema({
             [librechatDataProvider.PermissionTypes.MULTI_CONVO]: { [librechatDataProvider.Permissions.USE]: true },
             [librechatDataProvider.PermissionTypes.TEMPORARY_CHAT]: { [librechatDataProvider.Permissions.USE]: true },
             [librechatDataProvider.PermissionTypes.RUN_CODE]: { [librechatDataProvider.Permissions.USE]: true },
+            [librechatDataProvider.PermissionTypes.WEB_SEARCH]: { [librechatDataProvider.Permissions.USE]: true },
         }),
     },
 });
@@ -1048,7 +1107,7 @@ const BackupCodeSchema = new mongoose.Schema({
     used: { type: Boolean, default: false },
     usedAt: { type: Date, default: null },
 }, { _id: false });
-const User = new mongoose.Schema({
+const userSchema = new mongoose.Schema({
     name: {
         type: String,
     },
@@ -1059,7 +1118,7 @@ const User = new mongoose.Schema({
     },
     email: {
         type: String,
-        required: [true, 'can\'t be blank'],
+        required: [true, "can't be blank"],
         lowercase: true,
         unique: true,
         match: [/\S+@\S+\.\S+/, 'is invalid'],
@@ -1104,6 +1163,11 @@ const User = new mongoose.Schema({
         unique: true,
         sparse: true,
     },
+    samlId: {
+        type: String,
+        unique: true,
+        sparse: true,
+    },
     ldapId: {
         type: String,
         unique: true,
@@ -1148,8 +1212,2093 @@ const User = 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
+ */
+function createUserModel(mongoose) {
+    return mongoose.models.User || mongoose.model('User', userSchema);
+}
+
+/**
+ * Creates or returns the Token model using the provided mongoose instance and schema
+ */
+function createTokenModel(mongoose) {
+    return mongoose.models.Token || mongoose.model('Token', tokenSchema);
+}
+
+/**
+ * Creates or returns the Session model using the provided mongoose instance and schema
+ */
+function createSessionModel(mongoose) {
+    return mongoose.models.Session || mongoose.model('Session', sessionSchema);
+}
+
+/**
+ * Creates or returns the Balance model using the provided mongoose instance and schema
+ */
+function createBalanceModel(mongoose) {
+    return mongoose.models.Balance || mongoose.model('Balance', balanceSchema);
+}
+
+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';
+const levels$1 = {
+    error: 0,
+    warn: 1,
+    info: 2,
+    http: 3,
+    verbose: 4,
+    debug: 5,
+    activity: 6,
+    silly: 7,
+};
+winston.addColors({
+    info: 'green',
+    warn: 'italic yellow',
+    error: 'red',
+    debug: 'blue',
+});
+const level$1 = () => {
+    const env = NODE_ENV$1 || 'development';
+    const isDevelopment = env === 'development';
+    return isDevelopment ? 'debug' : 'warn';
+};
+const fileFormat$1 = winston.format.combine(winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }), winston.format.errors({ stack: true }), winston.format.splat());
+const logLevel = useDebugLogging$1 ? 'debug' : 'error';
+const transports$1 = [
+    new winston.transports.DailyRotateFile({
+        level: logLevel,
+        filename: `${logDir$1}/meiliSync-%DATE%.log`,
+        datePattern: 'YYYY-MM-DD',
+        zippedArchive: true,
+        maxSize: '20m',
+        maxFiles: '14d',
+        format: fileFormat$1,
+    }),
+];
+const consoleFormat$1 = winston.format.combine(winston.format.colorize({ all: true }), winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }), winston.format.printf((info) => `${info.timestamp} ${info.level}: ${info.message}`));
+transports$1.push(new winston.transports.Console({
+    level: 'info',
+    format: consoleFormat$1,
+}));
+const logger$1 = winston.createLogger({
+    level: level$1(),
+    levels: levels$1,
+    transports: transports$1,
+});
+
+// Environment flags
+/**
+ * Flag to indicate if search is enabled based on environment variables.
+ */
+const searchEnabled = process.env.SEARCH != null && process.env.SEARCH.toLowerCase() === 'true';
+/**
+ * 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;
+/**
+ * Local implementation of parseTextParts to avoid dependency on librechat-data-provider
+ * Extracts text content from an array of content items
+ */
+const parseTextParts = (content) => {
+    if (!Array.isArray(content)) {
+        return '';
+    }
+    return content
+        .filter((item) => item.type === 'text' && typeof item.text === 'string')
+        .map((item) => item.text)
+        .join(' ')
+        .trim();
+};
+/**
+ * Local implementation to handle Bing convoId conversion
+ */
+const cleanUpPrimaryKeyValue = (value) => {
+    return value.replace(/--/g, '|');
+};
+/**
+ * Validates the required options for configuring the mongoMeili plugin.
+ */
+const validateOptions = (options) => {
+    const requiredKeys = ['host', 'apiKey', 'indexName'];
+    requiredKeys.forEach((key) => {
+        if (!options[key]) {
+            throw new Error(`Missing mongoMeili Option: ${key}`);
+        }
+    });
+};
+/**
+ * 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
+ * corresponding to the MongoDB collection.
+ *
+ * @param config - Configuration object.
+ * @param config.index - The MeiliSearch index object.
+ * @param config.attributesToIndex - List of attributes to index.
+ * @returns A class definition that will be loaded into the Mongoose schema.
+ */
+const createMeiliMongooseModel = ({ index, attributesToIndex, }) => {
+    const primaryKey = attributesToIndex[0];
+    class MeiliMongooseModel {
+        /**
+         * 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.
+         */
+        static async syncWithMeili() {
+            try {
+                let moreDocuments = true;
+                const mongoDocuments = await this.find().lean();
+                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 offset = 0;
+                const batchSize = 1000;
+                while (moreDocuments) {
+                    const batch = await index.getDocuments({ limit: batchSize, offset });
+                    if (batch.results.length === 0) {
+                        moreDocuments = false;
+                    }
+                    for (const doc of batch.results) {
+                        indexMap.set(doc[primaryKey], format(doc));
+                    }
+                    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 } } },
+                        });
+                    }
+                }
+                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);
+            }
+        }
+        /**
+         * Updates settings for the MeiliSearch index
+         */
+        static async setMeiliIndexSettings(settings) {
+            return await index.updateSettings(settings);
+        }
+        /**
+         * Searches the MeiliSearch index and optionally populates results
+         */
+        static async meiliSearch(q, params, populate) {
+            const data = await index.search(q, params);
+            if (populate) {
+                const query = {};
+                query[primaryKey] = _.map(data.hits, (hit) => cleanUpPrimaryKeyValue(hit[primaryKey]));
+                const projection = Object.keys(this.schema.obj).reduce((results, key) => {
+                    if (!key.startsWith('$')) {
+                        results[key] = 1;
+                    }
+                    return results;
+                }, { _id: 1, __v: 1 });
+                const hitsFromMongoose = await this.find(query, projection).lean();
+                const populatedHits = data.hits.map((hit) => {
+                    hit[primaryKey];
+                    const originalHit = _.find(hitsFromMongoose, (item) => {
+                        const typedItem = item;
+                        return typedItem[primaryKey] === hit[primaryKey];
+                    });
+                    return {
+                        ...(originalHit && typeof originalHit === 'object' ? originalHit : {}),
+                        ...hit,
+                    };
+                });
+                data.hits = populatedHits;
+            }
+            return data;
+        }
+        /**
+         * Preprocesses the current document for indexing
+         */
+        preprocessObjectForIndex() {
+            const object = _.omitBy(_.pick(this.toJSON(), attributesToIndex), (v, k) => k.startsWith('$'));
+            if (object.conversationId &&
+                typeof object.conversationId === 'string' &&
+                object.conversationId.includes('|')) {
+                object.conversationId = object.conversationId.replace(/\|/g, '--');
+            }
+            if (object.content && Array.isArray(object.content)) {
+                object.text = parseTextParts(object.content);
+                delete object.content;
+            }
+            return object;
+        }
+        /**
+         * Adds the current document to the MeiliSearch index
+         */
+        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();
+            }
+            try {
+                await this.collection.updateMany({ _id: this._id }, { $set: { _meiliIndex: true } });
+            }
+            catch (error) {
+                logger$1.error('[addObjectToMeili] Error updating _meiliIndex field:', error);
+                return next();
+            }
+            next();
+        }
+        /**
+         * Updates the current document in the MeiliSearch index
+         */
+        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(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.
+         *
+         * If the document is already indexed (i.e. `_meiliIndex` is true), it updates it;
+         * otherwise, it adds the document to the index.
+         */
+        postSaveHook(next) {
+            if (this._meiliIndex) {
+                this.updateObjectToMeili(next);
+            }
+            else {
+                this.addObjectToMeili(next);
+            }
+        }
+        /**
+         * Post-update hook to update the document in MeiliSearch.
+         *
+         * This hook is triggered after a document update, ensuring that changes are
+         * propagated to the MeiliSearch index if the document is indexed.
+         */
+        postUpdateHook(next) {
+            if (this._meiliIndex) {
+                this.updateObjectToMeili(next);
+            }
+            else {
+                next();
+            }
+        }
+        /**
+         * Post-remove hook to delete the document from MeiliSearch.
+         *
+         * 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(next) {
+            if (this._meiliIndex) {
+                this.deleteObjectFromMeili(next);
+            }
+            else {
+                next();
+            }
+        }
+    }
+    return MeiliMongooseModel;
+};
+/**
+ * Mongoose plugin to synchronize MongoDB collections with a MeiliSearch index.
+ *
+ * This plugin:
+ *   - Validates the provided options.
+ *   - Adds a `_meiliIndex` field to the schema to track indexing status.
+ *   - Sets up a MeiliSearch client and creates an index if it doesn't already exist.
+ *   - Loads class methods for syncing, searching, and managing documents in MeiliSearch.
+ *   - Registers Mongoose hooks (post-save, post-update, post-remove, etc.) to maintain index consistency.
+ *
+ * @param schema - The Mongoose schema to which the plugin is applied.
+ * @param options - Configuration options.
+ * @param options.host - The MeiliSearch host.
+ * @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.
+ */
+function mongoMeili(schema, options) {
+    const mongoose = options.mongoose;
+    validateOptions(options);
+    // Add _meiliIndex field to the schema to track if a document has been indexed in MeiliSearch.
+    schema.add({
+        _meiliIndex: {
+            type: Boolean,
+            required: false,
+            select: false,
+            default: false,
+        },
+    });
+    const { host, apiKey, indexName, primaryKey } = options;
+    const client = new meilisearch.MeiliSearch({ host, apiKey });
+    client.createIndex(indexName, { primaryKey });
+    const index = client.index(indexName);
+    // Collect attributes from the schema that should be indexed
+    const attributesToIndex = [
+        ...Object.entries(schema.obj).reduce((results, [key, value]) => {
+            const schemaValue = value;
+            return schemaValue.meiliIndex ? [...results, key] : results;
+        }, []),
+    ];
+    schema.loadClass(createMeiliMongooseModel({ index, attributesToIndex }));
+    // Register Mongoose hooks
+    schema.post('save', function (doc, next) {
+        var _a;
+        (_a = doc.postSaveHook) === null || _a === void 0 ? void 0 : _a.call(doc, next);
+    });
+    schema.post('updateOne', function (doc, next) {
+        var _a;
+        (_a = doc.postUpdateHook) === null || _a === void 0 ? void 0 : _a.call(doc, next);
+    });
+    schema.post('deleteOne', function (doc, next) {
+        var _a;
+        (_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) {
+        if (!meiliEnabled) {
+            return next();
+        }
+        try {
+            const conditions = this.getQuery();
+            if (Object.prototype.hasOwnProperty.call(schema.obj, 'messages')) {
+                const convoIndex = client.index('convos');
+                const deletedConvos = await mongoose
+                    .model('Conversation')
+                    .find(conditions)
+                    .lean();
+                const promises = deletedConvos.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)
+                    .lean();
+                const promises = deletedMessages.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);
+            }
+            return next();
+        }
+    });
+    // Post-findOneAndUpdate hook
+    schema.post('findOneAndUpdate', async function (doc, next) {
+        var _a;
+        if (!meiliEnabled) {
+            return next();
+        }
+        if (doc.unfinished) {
+            return next();
+        }
+        let meiliDoc;
+        if (doc.messages) {
+            try {
+                meiliDoc = await client.index('convos').getDocument(doc.conversationId);
+            }
+            catch (error) {
+                logger$1.debug('[MeiliMongooseModel.findOneAndUpdate] Convo not found in MeiliSearch and will index ' +
+                    doc.conversationId, error);
+            }
+        }
+        if (meiliDoc && meiliDoc.title === doc.title) {
+            return next();
+        }
+        (_a = doc.postSaveHook) === null || _a === void 0 ? void 0 : _a.call(doc, next);
+    });
+}
+
+/**
+ * Creates or returns the Conversation model using the provided mongoose instance and schema
+ */
+function createConversationModel(mongoose) {
+    if (process.env.MEILI_HOST && process.env.MEILI_MASTER_KEY) {
+        convoSchema.plugin(mongoMeili, {
+            mongoose,
+            host: process.env.MEILI_HOST,
+            apiKey: process.env.MEILI_MASTER_KEY,
+            /** Note: Will get created automatically if it doesn't exist already */
+            indexName: 'convos',
+            primaryKey: 'conversationId',
+        });
+    }
+    return (mongoose.models.Conversation || mongoose.model('Conversation', convoSchema));
+}
+
+/**
+ * Creates or returns the Message model using the provided mongoose instance and schema
+ */
+function createMessageModel(mongoose) {
+    if (process.env.MEILI_HOST && process.env.MEILI_MASTER_KEY) {
+        messageSchema.plugin(mongoMeili, {
+            mongoose,
+            host: process.env.MEILI_HOST,
+            apiKey: process.env.MEILI_MASTER_KEY,
+            indexName: 'messages',
+            primaryKey: 'messageId',
+        });
+    }
+    return mongoose.models.Message || mongoose.model('Message', messageSchema);
+}
+
+/**
+ * Creates or returns the Agent model using the provided mongoose instance and schema
+ */
+function createAgentModel(mongoose) {
+    return mongoose.models.Agent || mongoose.model('Agent', agentSchema);
+}
+
+/**
+ * Creates or returns the Role model using the provided mongoose instance and schema
+ */
+function createRoleModel(mongoose) {
+    return mongoose.models.Role || mongoose.model('Role', roleSchema);
+}
+
+/**
+ * Creates or returns the Action model using the provided mongoose instance and schema
+ */
+function createActionModel(mongoose) {
+    return mongoose.models.Action || mongoose.model('Action', Action);
+}
+
+/**
+ * Creates or returns the Assistant model using the provided mongoose instance and schema
+ */
+function createAssistantModel(mongoose) {
+    return mongoose.models.Assistant || mongoose.model('Assistant', assistantSchema);
+}
+
+/**
+ * Creates or returns the File model using the provided mongoose instance and schema
+ */
+function createFileModel(mongoose) {
+    return mongoose.models.File || mongoose.model('File', file);
+}
+
+/**
+ * Creates or returns the Banner model using the provided mongoose instance and schema
+ */
+function createBannerModel(mongoose) {
+    return mongoose.models.Banner || mongoose.model('Banner', bannerSchema);
+}
+
+/**
+ * Creates or returns the Project model using the provided mongoose instance and schema
+ */
+function createProjectModel(mongoose) {
+    return mongoose.models.Project || mongoose.model('Project', projectSchema);
+}
+
+/**
+ * Creates or returns the Key model using the provided mongoose instance and schema
+ */
+function createKeyModel(mongoose) {
+    return mongoose.models.Key || mongoose.model('Key', keySchema);
+}
+
+/**
+ * Creates or returns the PluginAuth model using the provided mongoose instance and schema
+ */
+function createPluginAuthModel(mongoose) {
+    return mongoose.models.PluginAuth || mongoose.model('PluginAuth', pluginAuthSchema);
+}
+
+/**
+ * Creates or returns the Transaction model using the provided mongoose instance and schema
+ */
+function createTransactionModel(mongoose) {
+    return (mongoose.models.Transaction || mongoose.model('Transaction', transactionSchema));
+}
+
+/**
+ * Creates or returns the Preset model using the provided mongoose instance and schema
+ */
+function createPresetModel(mongoose) {
+    return mongoose.models.Preset || mongoose.model('Preset', presetSchema);
+}
+
+/**
+ * Creates or returns the Prompt model using the provided mongoose instance and schema
+ */
+function createPromptModel(mongoose) {
+    return mongoose.models.Prompt || mongoose.model('Prompt', promptSchema);
+}
+
+/**
+ * Creates or returns the PromptGroup model using the provided mongoose instance and schema
+ */
+function createPromptGroupModel(mongoose) {
+    return (mongoose.models.PromptGroup ||
+        mongoose.model('PromptGroup', promptGroupSchema));
+}
+
+/**
+ * Creates or returns the ConversationTag model using the provided mongoose instance and schema
+ */
+function createConversationTagModel(mongoose) {
+    return (mongoose.models.ConversationTag ||
+        mongoose.model('ConversationTag', conversationTag));
+}
+
+/**
+ * Creates or returns the SharedLink model using the provided mongoose instance and schema
+ */
+function createSharedLinkModel(mongoose) {
+    return mongoose.models.SharedLink || mongoose.model('SharedLink', shareSchema);
+}
+
+/**
+ * Creates or returns the ToolCall model using the provided mongoose instance and schema
+ */
+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
+ */
+function createModels(mongoose) {
+    return {
+        User: createUserModel(mongoose),
+        Token: createTokenModel(mongoose),
+        Session: createSessionModel(mongoose),
+        Balance: createBalanceModel(mongoose),
+        Conversation: createConversationModel(mongoose),
+        Message: createMessageModel(mongoose),
+        Agent: createAgentModel(mongoose),
+        Role: createRoleModel(mongoose),
+        Action: createActionModel(mongoose),
+        Assistant: createAssistantModel(mongoose),
+        File: createFileModel(mongoose),
+        Banner: createBannerModel(mongoose),
+        Project: createProjectModel(mongoose),
+        Key: createKeyModel(mongoose),
+        PluginAuth: createPluginAuthModel(mongoose),
+        Transaction: createTransactionModel(mongoose),
+        Preset: createPresetModel(mongoose),
+        Prompt: createPromptModel(mongoose),
+        PromptGroup: createPromptGroupModel(mongoose),
+        ConversationTag: createConversationTagModel(mongoose),
+        SharedLink: createSharedLinkModel(mongoose),
+        ToolCall: createToolCallModel(mongoose),
+        MemoryEntry: createMemoryModel(mongoose),
+    };
+}
+
+/** Factory function that takes mongoose instance and returns the methods */
+function createUserMethods(mongoose) {
+    /**
+     * Search for a single user based on partial data and return matching user document as plain object.
+     */
+    async function findUser(searchCriteria, fieldsToSelect) {
+        const User = mongoose.models.User;
+        const query = User.findOne(searchCriteria);
+        if (fieldsToSelect) {
+            query.select(fieldsToSelect);
+        }
+        return (await query.lean());
+    }
+    /**
+     * Count the number of user documents in the collection based on the provided filter.
+     */
+    async function countUsers(filter = {}) {
+        const User = mongoose.models.User;
+        return await User.countDocuments(filter);
+    }
+    /**
+     * Creates a new user, optionally with a TTL of 1 week.
+     */
+    async function createUser(data, balanceConfig, disableTTL = true, returnUser = false) {
+        const User = mongoose.models.User;
+        const Balance = mongoose.models.Balance;
+        const userData = {
+            ...data,
+            expiresAt: disableTTL ? undefined : new Date(Date.now() + 604800 * 1000), // 1 week in milliseconds
+        };
+        if (disableTTL) {
+            delete userData.expiresAt;
+        }
+        const user = await User.create(userData);
+        // If balance is enabled, create or update a balance record for the user
+        if ((balanceConfig === null || balanceConfig === void 0 ? void 0 : balanceConfig.enabled) && (balanceConfig === null || balanceConfig === void 0 ? void 0 : balanceConfig.startBalance)) {
+            const update = {
+                $inc: { tokenCredits: balanceConfig.startBalance },
+            };
+            if (balanceConfig.autoRefillEnabled &&
+                balanceConfig.refillIntervalValue != null &&
+                balanceConfig.refillIntervalUnit != null &&
+                balanceConfig.refillAmount != null) {
+                update.$set = {
+                    autoRefillEnabled: true,
+                    refillIntervalValue: balanceConfig.refillIntervalValue,
+                    refillIntervalUnit: balanceConfig.refillIntervalUnit,
+                    refillAmount: balanceConfig.refillAmount,
+                };
+            }
+            await Balance.findOneAndUpdate({ user: user._id }, update, {
+                upsert: true,
+                new: true,
+            }).lean();
+        }
+        if (returnUser) {
+            return user.toObject();
+        }
+        return user._id;
+    }
+    /**
+     * Update a user with new data without overwriting existing properties.
+     */
+    async function updateUser(userId, updateData) {
+        const User = mongoose.models.User;
+        const updateOperation = {
+            $set: updateData,
+            $unset: { expiresAt: '' }, // Remove the expiresAt field to prevent TTL
+        };
+        return (await User.findByIdAndUpdate(userId, updateOperation, {
+            new: true,
+            runValidators: true,
+        }).lean());
+    }
+    /**
+     * Retrieve a user by ID and convert the found user document to a plain object.
+     */
+    async function getUserById(userId, fieldsToSelect) {
+        const User = mongoose.models.User;
+        const query = User.findById(userId);
+        if (fieldsToSelect) {
+            query.select(fieldsToSelect);
+        }
+        return (await query.lean());
+    }
+    /**
+     * Delete a user by their unique ID.
+     */
+    async function deleteUserById(userId) {
+        try {
+            const User = mongoose.models.User;
+            const result = await User.deleteOne({ _id: userId });
+            if (result.deletedCount === 0) {
+                return { deletedCount: 0, message: 'No user found with that ID.' };
+            }
+            return { deletedCount: result.deletedCount, message: 'User was deleted successfully.' };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            throw new Error('Error deleting user: ' + errorMessage);
+        }
+    }
+    /**
+     * Generates a JWT token for a given user.
+     */
+    async function generateToken(user) {
+        if (!user) {
+            throw new Error('No user provided');
+        }
+        let expires = 1000 * 60 * 15;
+        if (process.env.SESSION_EXPIRY !== undefined && process.env.SESSION_EXPIRY !== '') {
+            try {
+                const evaluated = eval(process.env.SESSION_EXPIRY);
+                if (evaluated) {
+                    expires = evaluated;
+                }
+            }
+            catch (error) {
+                console.warn('Invalid SESSION_EXPIRY expression, using default:', error);
+            }
+        }
+        return await signPayload({
+            payload: {
+                id: user._id,
+                username: user.username,
+                provider: user.provider,
+                email: user.email,
+            },
+            secret: process.env.JWT_SECRET,
+            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,
+        countUsers,
+        createUser,
+        updateUser,
+        getUserById,
+        deleteUserById,
+        generateToken,
+        toggleUserMemories,
+    };
+}
+
+const SPLAT_SYMBOL = Symbol.for('splat');
+const MESSAGE_SYMBOL = Symbol.for('message');
+const CONSOLE_JSON_STRING_LENGTH = parseInt(process.env.CONSOLE_JSON_STRING_LENGTH || '', 10) || 255;
+const sensitiveKeys = [
+    /^(sk-)[^\s]+/, // OpenAI API key pattern
+    /(Bearer )[^\s]+/, // Header: Bearer token pattern
+    /(api-key:? )[^\s]+/, // Header: API key pattern
+    /(key=)[^\s]+/, // URL query param: sensitive key pattern (Google)
+];
+/**
+ * Determines if a given value string is sensitive and returns matching regex patterns.
+ *
+ * @param valueStr - The value string to check.
+ * @returns An array of regex patterns that match the value string.
+ */
+function getMatchingSensitivePatterns(valueStr) {
+    if (valueStr) {
+        // Filter and return all regex patterns that match the value string
+        return sensitiveKeys.filter((regex) => regex.test(valueStr));
+    }
+    return [];
+}
+/**
+ * Redacts sensitive information from a console message and trims it to a specified length if provided.
+ * @param str - The console message to be redacted.
+ * @param trimLength - The optional length at which to trim the redacted message.
+ * @returns The redacted and optionally trimmed console message.
+ */
+function redactMessage(str, trimLength) {
+    if (!str) {
+        return '';
+    }
+    const patterns = getMatchingSensitivePatterns(str);
+    patterns.forEach((pattern) => {
+        str = str.replace(pattern, '$1[REDACTED]');
+    });
+    return str;
+}
+/**
+ * Redacts sensitive information from log messages if the log level is 'error'.
+ * Note: Intentionally mutates the object.
+ * @param info - The log information object.
+ * @returns The modified log information object.
+ */
+const redactFormat = winston.format((info) => {
+    if (info.level === 'error') {
+        // Type guard to ensure message is a string
+        if (typeof info.message === 'string') {
+            info.message = redactMessage(info.message);
+        }
+        // Handle MESSAGE_SYMBOL with type safety
+        const symbolValue = info[MESSAGE_SYMBOL];
+        if (typeof symbolValue === 'string') {
+            info[MESSAGE_SYMBOL] = redactMessage(symbolValue);
+        }
+    }
+    return info;
+});
+/**
+ * Truncates long strings, especially base64 image data, within log messages.
+ *
+ * @param value - The value to be inspected and potentially truncated.
+ * @param length - The length at which to truncate the value. Default: 100.
+ * @returns The truncated or original value.
+ */
+const truncateLongStrings = (value, length = 100) => {
+    if (typeof value === 'string') {
+        return value.length > length ? value.substring(0, length) + '... [truncated]' : value;
+    }
+    return value;
+};
+/**
+ * An array mapping function that truncates long strings (objects converted to JSON strings).
+ * @param item - The item to be condensed.
+ * @returns The condensed item.
+ */
+const condenseArray = (item) => {
+    if (typeof item === 'string') {
+        return truncateLongStrings(JSON.stringify(item));
+    }
+    else if (typeof item === 'object') {
+        return truncateLongStrings(JSON.stringify(item));
+    }
+    return item;
+};
+/**
+ * Formats log messages for debugging purposes.
+ * - Truncates long strings within log messages.
+ * - Condenses arrays by truncating long strings and objects as strings within array items.
+ * - Redacts sensitive information from log messages if the log level is 'error'.
+ * - Converts log information object to a formatted string.
+ *
+ * @param options - The options for formatting log messages.
+ * @returns The formatted log message.
+ */
+const debugTraverse = winston.format.printf(({ level, message, timestamp, ...metadata }) => {
+    if (!message) {
+        return `${timestamp} ${level}`;
+    }
+    // Type-safe version of the CJS logic: !message?.trim || typeof message !== 'string'
+    if (typeof message !== 'string' || !message.trim) {
+        return `${timestamp} ${level}: ${JSON.stringify(message)}`;
+    }
+    let msg = `${timestamp} ${level}: ${truncateLongStrings(message.trim(), 150)}`;
+    try {
+        if (level !== 'debug') {
+            return msg;
+        }
+        if (!metadata) {
+            return msg;
+        }
+        // Type-safe access to SPLAT_SYMBOL using bracket notation
+        const metadataRecord = metadata;
+        const splatArray = metadataRecord[SPLAT_SYMBOL];
+        const debugValue = Array.isArray(splatArray) ? splatArray[0] : undefined;
+        if (!debugValue) {
+            return msg;
+        }
+        if (debugValue && Array.isArray(debugValue)) {
+            msg += `\n${JSON.stringify(debugValue.map(condenseArray))}`;
+            return msg;
+        }
+        if (typeof debugValue !== 'object') {
+            return (msg += ` ${debugValue}`);
+        }
+        msg += '\n{';
+        const copy = klona.klona(metadata);
+        traverse(copy).forEach(function (value) {
+            var _a;
+            if (typeof (this === null || this === void 0 ? void 0 : this.key) === 'symbol') {
+                return;
+            }
+            let _parentKey = '';
+            const parent = this.parent;
+            if (typeof (parent === null || parent === void 0 ? void 0 : parent.key) !== 'symbol' && (parent === null || parent === void 0 ? void 0 : parent.key)) {
+                _parentKey = parent.key;
+            }
+            const parentKey = `${parent && parent.notRoot ? _parentKey + '.' : ''}`;
+            const tabs = `${parent && parent.notRoot ? '    ' : '  '}`;
+            const currentKey = (_a = this === null || this === void 0 ? void 0 : this.key) !== null && _a !== void 0 ? _a : 'unknown';
+            if (this.isLeaf && typeof value === 'string') {
+                const truncatedText = truncateLongStrings(value);
+                msg += `\n${tabs}${parentKey}${currentKey}: ${JSON.stringify(truncatedText)},`;
+            }
+            else if (this.notLeaf && Array.isArray(value) && value.length > 0) {
+                const currentMessage = `\n${tabs}// ${value.length} ${currentKey.replace(/s$/, '')}(s)`;
+                this.update(currentMessage, true);
+                msg += currentMessage;
+                const stringifiedArray = value.map(condenseArray);
+                msg += `\n${tabs}${parentKey}${currentKey}: [${stringifiedArray}],`;
+            }
+            else if (this.isLeaf && typeof value === 'function') {
+                msg += `\n${tabs}${parentKey}${currentKey}: function,`;
+            }
+            else if (this.isLeaf) {
+                msg += `\n${tabs}${parentKey}${currentKey}: ${value},`;
+            }
+        });
+        msg += '\n}';
+        return msg;
+    }
+    catch (e) {
+        const errorMessage = e instanceof Error ? e.message : 'Unknown error';
+        return (msg += `\n[LOGGER PARSING ERROR] ${errorMessage}`);
+    }
+});
+/**
+ * Truncates long string values in JSON log objects.
+ * Prevents outputting extremely long values (e.g., base64, blobs).
+ */
+const jsonTruncateFormat = winston.format((info) => {
+    const truncateLongStrings = (str, maxLength) => str.length > maxLength ? str.substring(0, maxLength) + '...' : str;
+    const seen = new WeakSet();
+    const truncateObject = (obj) => {
+        if (typeof obj !== 'object' || obj === null) {
+            return obj;
+        }
+        // Handle circular references - now with proper object type
+        if (seen.has(obj)) {
+            return '[Circular]';
+        }
+        seen.add(obj);
+        if (Array.isArray(obj)) {
+            return obj.map((item) => truncateObject(item));
+        }
+        // We know this is an object at this point
+        const objectRecord = obj;
+        const newObj = {};
+        Object.entries(objectRecord).forEach(([key, value]) => {
+            if (typeof value === 'string') {
+                newObj[key] = truncateLongStrings(value, CONSOLE_JSON_STRING_LENGTH);
+            }
+            else {
+                newObj[key] = truncateObject(value);
+            }
+        });
+        return newObj;
+    };
+    return truncateObject(info);
+});
+
+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';
+const levels = {
+    error: 0,
+    warn: 1,
+    info: 2,
+    http: 3,
+    verbose: 4,
+    debug: 5,
+    activity: 6,
+    silly: 7,
+};
+winston.addColors({
+    info: 'green',
+    warn: 'italic yellow',
+    error: 'red',
+    debug: 'blue',
+});
+const level = () => {
+    const env = NODE_ENV || 'development';
+    return env === 'development' ? 'debug' : 'warn';
+};
+const fileFormat = winston.format.combine(redactFormat(), winston.format.timestamp({ format: () => new Date().toISOString() }), winston.format.errors({ stack: true }), winston.format.splat());
+const transports = [
+    new winston.transports.DailyRotateFile({
+        level: 'error',
+        filename: `${logDir}/error-%DATE%.log`,
+        datePattern: 'YYYY-MM-DD',
+        zippedArchive: true,
+        maxSize: '20m',
+        maxFiles: '14d',
+        format: fileFormat,
+    }),
+];
+if (useDebugLogging) {
+    transports.push(new winston.transports.DailyRotateFile({
+        level: 'debug',
+        filename: `${logDir}/debug-%DATE%.log`,
+        datePattern: 'YYYY-MM-DD',
+        zippedArchive: true,
+        maxSize: '20m',
+        maxFiles: '14d',
+        format: winston.format.combine(fileFormat, debugTraverse),
+    }));
+}
+const consoleFormat = winston.format.combine(redactFormat(), winston.format.colorize({ all: true }), winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }), winston.format.printf((info) => {
+    const message = `${info.timestamp} ${info.level}: ${info.message}`;
+    return info.level.includes('error') ? redactMessage(message) : message;
+}));
+let consoleLogLevel = 'info';
+if (useDebugConsole) {
+    consoleLogLevel = 'debug';
+}
+// Add console transport
+if (useDebugConsole) {
+    transports.push(new winston.transports.Console({
+        level: consoleLogLevel,
+        format: useConsoleJson
+            ? winston.format.combine(fileFormat, jsonTruncateFormat(), winston.format.json())
+            : winston.format.combine(fileFormat, debugTraverse),
+    }));
+}
+else if (useConsoleJson) {
+    transports.push(new winston.transports.Console({
+        level: consoleLogLevel,
+        format: winston.format.combine(fileFormat, jsonTruncateFormat(), winston.format.json()),
+    }));
+}
+else {
+    transports.push(new winston.transports.Console({
+        level: consoleLogLevel,
+        format: consoleFormat,
+    }));
+}
+// Create logger
+const logger = winston.createLogger({
+    level: level(),
+    levels,
+    transports,
+});
+
+var _a;
+class SessionError extends Error {
+    constructor(message, code = 'SESSION_ERROR') {
+        super(message);
+        this.name = 'SessionError';
+        this.code = code;
+    }
+}
+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
+// 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
+     */
+    async function createSession(userId, options = {}) {
+        if (!userId) {
+            throw new SessionError('User ID is required', 'INVALID_USER_ID');
+        }
+        try {
+            const session = new Session({
+                user: userId,
+                expiration: options.expiration || new Date(Date.now() + expires),
+            });
+            const refreshToken = await generateRefreshToken(session);
+            return { session, refreshToken };
+        }
+        catch (error) {
+            logger.error('[createSession] Error creating session:', error);
+            throw new SessionError('Failed to create session', 'CREATE_SESSION_FAILED');
+        }
+    }
+    /**
+     * Finds a session by various parameters
+     */
+    async function findSession(params, options = { lean: true }) {
+        try {
+            const query = {};
+            if (!params.refreshToken && !params.userId && !params.sessionId) {
+                throw new SessionError('At least one search parameter is required', 'INVALID_SEARCH_PARAMS');
+            }
+            if (params.refreshToken) {
+                const tokenHash = await hashToken(params.refreshToken);
+                query.refreshTokenHash = tokenHash;
+            }
+            if (params.userId) {
+                query.user = params.userId;
+            }
+            if (params.sessionId) {
+                const sessionId = typeof params.sessionId === 'object' &&
+                    params.sessionId !== null &&
+                    'sessionId' in params.sessionId
+                    ? params.sessionId.sessionId
+                    : params.sessionId;
+                if (!mongoose.Types.ObjectId.isValid(sessionId)) {
+                    throw new SessionError('Invalid session ID format', 'INVALID_SESSION_ID');
+                }
+                query._id = sessionId;
+            }
+            // Add expiration check to only return valid sessions
+            query.expiration = { $gt: new Date() };
+            const sessionQuery = Session.findOne(query);
+            if (options.lean) {
+                return (await sessionQuery.lean());
+            }
+            return await sessionQuery.exec();
+        }
+        catch (error) {
+            logger.error('[findSession] Error finding session:', error);
+            throw new SessionError('Failed to find session', 'FIND_SESSION_FAILED');
+        }
+    }
+    /**
+     * Updates session expiration
+     */
+    async function updateExpiration(session, newExpiration) {
+        try {
+            const sessionDoc = typeof session === 'string' ? await Session.findById(session) : session;
+            if (!sessionDoc) {
+                throw new SessionError('Session not found', 'SESSION_NOT_FOUND');
+            }
+            sessionDoc.expiration = newExpiration || new Date(Date.now() + expires);
+            return await sessionDoc.save();
+        }
+        catch (error) {
+            logger.error('[updateExpiration] Error updating session:', error);
+            throw new SessionError('Failed to update session expiration', 'UPDATE_EXPIRATION_FAILED');
+        }
+    }
+    /**
+     * Deletes a session by refresh token or session ID
+     */
+    async function deleteSession(params) {
+        try {
+            if (!params.refreshToken && !params.sessionId) {
+                throw new SessionError('Either refreshToken or sessionId is required', 'INVALID_DELETE_PARAMS');
+            }
+            const query = {};
+            if (params.refreshToken) {
+                query.refreshTokenHash = await hashToken(params.refreshToken);
+            }
+            if (params.sessionId) {
+                query._id = params.sessionId;
+            }
+            const result = await Session.deleteOne(query);
+            if (result.deletedCount === 0) {
+                logger.warn('[deleteSession] No session found to delete');
+            }
+            return result;
+        }
+        catch (error) {
+            logger.error('[deleteSession] Error deleting session:', error);
+            throw new SessionError('Failed to delete session', 'DELETE_SESSION_FAILED');
+        }
+    }
+    /**
+     * Deletes all sessions for a user
+     */
+    async function deleteAllUserSessions(userId, options = {}) {
+        try {
+            if (!userId) {
+                throw new SessionError('User ID is required', 'INVALID_USER_ID');
+            }
+            const userIdString = typeof userId === 'object' && userId !== null ? userId.userId : userId;
+            if (!mongoose.Types.ObjectId.isValid(userIdString)) {
+                throw new SessionError('Invalid user ID format', 'INVALID_USER_ID_FORMAT');
+            }
+            const query = { user: userIdString };
+            if (options.excludeCurrentSession && options.currentSessionId) {
+                query._id = { $ne: options.currentSessionId };
+            }
+            const result = await Session.deleteMany(query);
+            if (result.deletedCount && result.deletedCount > 0) {
+                logger.debug(`[deleteAllUserSessions] Deleted ${result.deletedCount} sessions for user ${userIdString}.`);
+            }
+            return result;
+        }
+        catch (error) {
+            logger.error('[deleteAllUserSessions] Error deleting user sessions:', error);
+            throw new SessionError('Failed to delete user sessions', 'DELETE_ALL_SESSIONS_FAILED');
+        }
+    }
+    /**
+     * Generates a refresh token for a session
+     */
+    async function generateRefreshToken(session) {
+        if (!session || !session.user) {
+            throw new SessionError('Invalid session object', 'INVALID_SESSION');
+        }
+        try {
+            const expiresIn = session.expiration ? session.expiration.getTime() : Date.now() + expires;
+            if (!session.expiration) {
+                session.expiration = new Date(expiresIn);
+            }
+            const refreshToken = await signPayload({
+                payload: {
+                    id: session.user,
+                    sessionId: session._id,
+                },
+                secret: process.env.JWT_REFRESH_SECRET,
+                expirationTime: Math.floor((expiresIn - Date.now()) / 1000),
+            });
+            session.refreshTokenHash = await hashToken(refreshToken);
+            await session.save();
+            return refreshToken;
+        }
+        catch (error) {
+            logger.error('[generateRefreshToken] Error generating refresh token:', error);
+            throw new SessionError('Failed to generate refresh token', 'GENERATE_TOKEN_FAILED');
+        }
+    }
+    /**
+     * Counts active sessions for a user
+     */
+    async function countActiveSessions(userId) {
+        try {
+            if (!userId) {
+                throw new SessionError('User ID is required', 'INVALID_USER_ID');
+            }
+            return await Session.countDocuments({
+                user: userId,
+                expiration: { $gt: new Date() },
+            });
+        }
+        catch (error) {
+            logger.error('[countActiveSessions] Error counting active sessions:', error);
+            throw new SessionError('Failed to count active sessions', 'COUNT_SESSIONS_FAILED');
+        }
+    }
+    return {
+        findSession,
+        SessionError,
+        deleteSession,
+        createSession,
+        updateExpiration,
+        countActiveSessions,
+        generateRefreshToken,
+        deleteAllUserSessions,
+    };
+}
+
+// Factory function that takes mongoose instance and returns the methods
+function createTokenMethods(mongoose) {
+    /**
+     * Creates a new Token instance.
+     */
+    async function createToken(tokenData) {
+        try {
+            const Token = mongoose.models.Token;
+            const currentTime = new Date();
+            const expiresAt = new Date(currentTime.getTime() + tokenData.expiresIn * 1000);
+            const newTokenData = {
+                ...tokenData,
+                createdAt: currentTime,
+                expiresAt,
+            };
+            return await Token.create(newTokenData);
+        }
+        catch (error) {
+            logger.debug('An error occurred while creating token:', error);
+            throw error;
+        }
+    }
+    /**
+     * Updates a Token document that matches the provided query.
+     */
+    async function updateToken(query, updateData) {
+        try {
+            const Token = mongoose.models.Token;
+            return await Token.findOneAndUpdate(query, updateData, { new: true });
+        }
+        catch (error) {
+            logger.debug('An error occurred while updating token:', error);
+            throw error;
+        }
+    }
+    /**
+     * Deletes all Token documents that match the provided token, user ID, or email.
+     */
+    async function deleteTokens(query) {
+        try {
+            const Token = mongoose.models.Token;
+            return await Token.deleteMany({
+                $or: [
+                    { userId: query.userId },
+                    { token: query.token },
+                    { email: query.email },
+                    { identifier: query.identifier },
+                ],
+            });
+        }
+        catch (error) {
+            logger.debug('An error occurred while deleting tokens:', error);
+            throw error;
+        }
+    }
+    /**
+     * Finds a Token document that matches the provided query.
+     */
+    async function findToken(query) {
+        try {
+            const Token = mongoose.models.Token;
+            const conditions = [];
+            if (query.userId) {
+                conditions.push({ userId: query.userId });
+            }
+            if (query.token) {
+                conditions.push({ token: query.token });
+            }
+            if (query.email) {
+                conditions.push({ email: query.email });
+            }
+            if (query.identifier) {
+                conditions.push({ identifier: query.identifier });
+            }
+            const token = await Token.findOne({
+                $and: conditions,
+            }).lean();
+            return token;
+        }
+        catch (error) {
+            logger.debug('An error occurred while finding token:', error);
+            throw error;
+        }
+    }
+    // Return all methods
+    return {
+        findToken,
+        createToken,
+        updateToken,
+        deleteTokens,
+    };
+}
+
+// Factory function that takes mongoose instance and returns the methods
+function createRoleMethods(mongoose) {
+    /**
+     * Initialize default roles in the system.
+     * Creates the default roles (ADMIN, USER) if they don't exist in the database.
+     * Updates existing roles with new permission types if they're missing.
+     */
+    async function initializeRoles() {
+        const Role = mongoose.models.Role;
+        for (const roleName of [librechatDataProvider.SystemRoles.ADMIN, librechatDataProvider.SystemRoles.USER]) {
+            let role = await Role.findOne({ name: roleName });
+            const defaultPerms = librechatDataProvider.roleDefaults[roleName].permissions;
+            if (!role) {
+                // Create new role if it doesn't exist.
+                role = new Role(librechatDataProvider.roleDefaults[roleName]);
+            }
+            else {
+                // Ensure role.permissions is defined.
+                role.permissions = role.permissions || {};
+                // For each permission type in defaults, add it if missing.
+                for (const permType of Object.keys(defaultPerms)) {
+                    if (role.permissions[permType] == null) {
+                        role.permissions[permType] = defaultPerms[permType];
+                    }
+                }
+            }
+            await role.save();
+        }
+    }
+    /**
+     * List all roles in the system (for testing purposes)
+     * Returns an array of all roles with their names and permissions
+     */
+    async function listRoles() {
+        const Role = mongoose.models.Role;
+        return await Role.find({}).select('name permissions').lean();
+    }
+    // Return all methods you want to expose
+    return {
+        listRoles,
+        initializeRoles,
+    };
+}
+
+/**
+ * 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) {
+    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
+     */
+    async function createMemory({ userId, key, value, tokenCount = 0, }) {
+        try {
+            if ((key === null || key === void 0 ? void 0 : key.toLowerCase()) === 'nothing') {
+                return { ok: false };
+            }
+            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 };
+            }
+            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 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 {
+            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) {
+    const PluginAuth = mongoose.models.PluginAuth;
+    /**
+     * Finds a single plugin auth entry by userId and authField
+     */
+    async function findOnePluginAuth({ userId, authField, }) {
+        try {
+            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 [];
+            }
+            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 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 {
+            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 {
+            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
+ */
+function createMethods(mongoose) {
+    return {
+        ...createUserMethods(mongoose),
+        ...createSessionMethods(mongoose),
+        ...createTokenMethods(mongoose),
+        ...createRoleMethods(mongoose),
+        ...createMemoryMethods(mongoose),
+        ...createShareMethods(mongoose),
+        ...createPluginAuthMethods(mongoose),
+    };
+}
+
 exports.actionSchema = Action;
 exports.agentSchema = agentSchema;
 exports.assistantSchema = assistantSchema;
@@ -1158,8 +3307,14 @@ exports.bannerSchema = bannerSchema;
 exports.categoriesSchema = categoriesSchema;
 exports.conversationTagSchema = conversationTag;
 exports.convoSchema = convoSchema;
+exports.createMethods = createMethods;
+exports.createModels = createModels;
 exports.fileSchema = file;
+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;
@@ -1169,8 +3324,9 @@ exports.promptSchema = promptSchema;
 exports.roleSchema = roleSchema;
 exports.sessionSchema = sessionSchema;
 exports.shareSchema = shareSchema;
+exports.signPayload = signPayload;
 exports.tokenSchema = tokenSchema;
 exports.toolCallSchema = toolCallSchema;
 exports.transactionSchema = transactionSchema;
-exports.userSchema = User;
+exports.userSchema = userSchema;
 //# sourceMappingURL=index.cjs.map