@librechat/data-schemas 0.0.7 → 0.0.8

package/dist/index.es.js

@@ -1,5 +1,23 @@
+import jwt from 'jsonwebtoken';
+import { webcrypto } from 'node:crypto';
 import mongoose, { Schema } from 'mongoose';
-import { FileSources, Constants, PermissionTypes, Permissions, SystemRoles } from 'librechat-data-provider';
+import { FileSources, Constants, PermissionTypes, Permissions, SystemRoles, roleDefaults } from 'librechat-data-provider';
+import _ from 'lodash';
+import { MeiliSearch } from 'meilisearch';
+import path from 'path';
+import winston from 'winston';
+import 'winston-daily-rotate-file';
+import { klona } from 'klona';
+import traverse from 'traverse';
+
+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 webcrypto.subtle.digest('SHA-256', data);
+    return Buffer.from(hashBuffer).toString('hex');
+}
 
 // Define the Auth sub-schema with type-safety.
 const AuthSchema = new Schema({
@@ -131,6 +149,10 @@ const agentSchema = new Schema({
         ref: 'Project',
         index: true,
     },
+    versions: {
+        type: [Schema.Types.Mixed],
+        default: [],
+    },
 }, {
     timestamps: true,
 });
@@ -425,9 +447,9 @@ const convoSchema = new Schema({
         type: String,
         index: true,
     },
-    messages: [{ type: mongoose.Schema.Types.ObjectId, ref: 'Message' }],
+    messages: [{ type: Schema.Types.ObjectId, ref: 'Message' }],
     agentOptions: {
-        type: mongoose.Schema.Types.Mixed,
+        type: Schema.Types.Mixed,
     },
     ...conversationPreset,
     agent_id: {
@@ -617,6 +639,25 @@ const messageSchema = new 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,
@@ -863,6 +904,9 @@ const rolePermissionsSchema = new Schema({
     [PermissionTypes.RUN_CODE]: {
         [Permissions.USE]: { type: Boolean, default: true },
     },
+    [PermissionTypes.WEB_SEARCH]: {
+        [Permissions.USE]: { type: Boolean, default: true },
+    },
 }, { _id: false });
 const roleSchema = new Schema({
     name: { type: String, required: true, unique: true, index: true },
@@ -883,6 +927,7 @@ const roleSchema = new Schema({
             [PermissionTypes.MULTI_CONVO]: { [Permissions.USE]: true },
             [PermissionTypes.TEMPORARY_CHAT]: { [Permissions.USE]: true },
             [PermissionTypes.RUN_CODE]: { [Permissions.USE]: true },
+            [PermissionTypes.WEB_SEARCH]: { [Permissions.USE]: true },
         }),
     },
 });
@@ -1046,7 +1091,7 @@ const BackupCodeSchema = new Schema({
     used: { type: Boolean, default: false },
     usedAt: { type: Date, default: null },
 }, { _id: false });
-const User = new Schema({
+const userSchema = new Schema({
     name: {
         type: String,
     },
@@ -1057,7 +1102,7 @@ const User = new 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'],
@@ -1102,6 +1147,11 @@ const User = new Schema({
         unique: true,
         sparse: true,
     },
+    samlId: {
+        type: String,
+        unique: true,
+        sparse: true,
+    },
     ldapId: {
         type: String,
         unique: true,
@@ -1148,5 +1198,1416 @@ const User = new Schema({
     },
 }, { timestamps: true });
 
-export { Action as actionSchema, agentSchema, assistantSchema, balanceSchema, bannerSchema, categoriesSchema, conversationTag as conversationTagSchema, convoSchema, file as fileSchema, keySchema, messageSchema, pluginAuthSchema, presetSchema, projectSchema, promptGroupSchema, promptSchema, roleSchema, sessionSchema, shareSchema, tokenSchema, toolCallSchema, transactionSchema, User as userSchema };
+/**
+ * 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, '..', '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() {
+            const object = this.preprocessObjectForIndex();
+            try {
+                await index.addDocuments([object]);
+            }
+            catch (error) {
+                logger$1.error('[addObjectToMeili] Error adding document to Meili', error);
+            }
+            await this.collection.updateMany({ _id: this._id }, { $set: { _meiliIndex: true } });
+        }
+        /**
+         * 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]);
+        }
+        /**
+         * Deletes the current document from the MeiliSearch index.
+         *
+         * @returns {Promise<void>}
+         */
+        async deleteObjectFromMeili() {
+            await index.deleteDocument(this._id);
+        }
+        /**
+         * 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() {
+            if (this._meiliIndex) {
+                this.updateObjectToMeili();
+            }
+            else {
+                this.addObjectToMeili();
+            }
+        }
+        /**
+         * 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() {
+            if (this._meiliIndex) {
+                this.updateObjectToMeili();
+            }
+        }
+        /**
+         * 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() {
+            if (this._meiliIndex) {
+                this.deleteObjectFromMeili();
+            }
+        }
+    }
+    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({ 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) {
+        var _a;
+        (_a = doc.postSaveHook) === null || _a === void 0 ? void 0 : _a.call(doc);
+    });
+    schema.post('updateOne', function (doc) {
+        var _a;
+        (_a = doc.postUpdateHook) === null || _a === void 0 ? void 0 : _a.call(doc);
+    });
+    schema.post('deleteOne', function (doc) {
+        var _a;
+        (_a = doc.postRemoveHook) === null || _a === void 0 ? void 0 : _a.call(doc);
+    });
+    // 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) {
+        var _a;
+        if (!meiliEnabled) {
+            return;
+        }
+        if (doc.unfinished) {
+            return;
+        }
+        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;
+        }
+        (_a = doc.postSaveHook) === null || _a === void 0 ? void 0 : _a.call(doc);
+    });
+}
+
+/**
+ * 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);
+}
+
+/**
+ * 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),
+    };
+}
+
+/** 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,
+        });
+    }
+    // Return all methods
+    return {
+        findUser,
+        countUsers,
+        createUser,
+        updateUser,
+        getUserById,
+        deleteUserById,
+        generateToken,
+    };
+}
+
+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(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);
+});
+
+// Define log directory
+const logDir = path.join(__dirname, '..', 'logs');
+// Type-safe environment variables
+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,
+    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, _b;
+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 = (_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
+// 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 [SystemRoles.ADMIN, SystemRoles.USER]) {
+            let role = await Role.findOne({ name: roleName });
+            const defaultPerms = roleDefaults[roleName].permissions;
+            if (!role) {
+                // Create new role if it doesn't exist.
+                role = new Role(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,
+    };
+}
+
+/**
+ * Creates all database methods for all collections
+ */
+function createMethods(mongoose) {
+    return {
+        ...createUserMethods(mongoose),
+        ...createSessionMethods(mongoose),
+        ...createTokenMethods(mongoose),
+        ...createRoleMethods(mongoose),
+    };
+}
+
+export { Action as actionSchema, agentSchema, assistantSchema, balanceSchema, bannerSchema, categoriesSchema, conversationTag as conversationTagSchema, convoSchema, createMethods, createModels, file as fileSchema, hashToken, keySchema, logger, logger$1 as meiliLogger, messageSchema, pluginAuthSchema, presetSchema, projectSchema, promptGroupSchema, promptSchema, roleSchema, sessionSchema, shareSchema, signPayload, tokenSchema, toolCallSchema, transactionSchema, userSchema };
 //# sourceMappingURL=index.es.js.map