@librechat/data-schemas 0.0.8 → 0.0.10

package/dist/index.es.js

@@ -9,6 +9,7 @@ import winston from 'winston';
 import 'winston-daily-rotate-file';
 import { klona } from 'klona';
 import traverse from 'traverse';
+import { nanoid } from 'nanoid';
 
 async function signPayload({ payload, secret, expirationTime, }) {
     return jwt.sign(payload, secret, { expiresIn: expirationTime });
@@ -868,7 +869,7 @@ const promptGroupSchema = new 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: [
             Constants.COMMANDS_MAX_LENGTH,
@@ -890,6 +891,13 @@ const rolePermissionsSchema = new Schema({
         [Permissions.USE]: { type: Boolean, default: true },
         [Permissions.CREATE]: { type: Boolean, default: true },
     },
+    [PermissionTypes.MEMORIES]: {
+        [Permissions.USE]: { type: Boolean, default: true },
+        [Permissions.CREATE]: { type: Boolean, default: true },
+        [Permissions.UPDATE]: { type: Boolean, default: true },
+        [Permissions.READ]: { type: Boolean, default: true },
+        [Permissions.OPT_OUT]: { type: Boolean, default: true },
+    },
     [PermissionTypes.AGENTS]: {
         [Permissions.SHARED_GLOBAL]: { type: Boolean, default: false },
         [Permissions.USE]: { type: Boolean, default: true },
@@ -919,6 +927,12 @@ const roleSchema = new Schema({
                 [Permissions.USE]: true,
                 [Permissions.CREATE]: true,
             },
+            [PermissionTypes.MEMORIES]: {
+                [Permissions.USE]: true,
+                [Permissions.CREATE]: true,
+                [Permissions.UPDATE]: true,
+                [Permissions.READ]: true,
+            },
             [PermissionTypes.AGENTS]: {
                 [Permissions.SHARED_GLOBAL]: false,
                 [Permissions.USE]: true,
@@ -1196,8 +1210,46 @@ const userSchema = new Schema({
         type: Boolean,
         default: false,
     },
+    personalization: {
+        type: {
+            memories: {
+                type: Boolean,
+                default: true,
+            },
+        },
+        default: {},
+    },
 }, { timestamps: true });
 
+const MemoryEntrySchema = new Schema({
+    userId: {
+        type: 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
  */
@@ -1226,7 +1278,7 @@ function createBalanceModel(mongoose) {
     return mongoose.models.Balance || mongoose.model('Balance', balanceSchema);
 }
 
-const logDir$1 = path.join(__dirname, '..', 'logs');
+const logDir$1 = path.join(__dirname, '..', '..', '..', 'api', 'logs');
 const { NODE_ENV: NODE_ENV$1, DEBUG_LOGGING: DEBUG_LOGGING$1 = 'false' } = process.env;
 const useDebugLogging$1 = (typeof DEBUG_LOGGING$1 === 'string' && DEBUG_LOGGING$1.toLowerCase() === 'true') ||
     DEBUG_LOGGING$1 === 'true';
@@ -1413,7 +1465,7 @@ const createMeiliMongooseModel = ({ index, attributesToIndex, }) => {
                 }
             }
             catch (error) {
-                logger$1.error('[syncWithMeili] Error adding document to Meili', error);
+                logger$1.error('[syncWithMeili] Error adding document to Meili:', error);
             }
         }
         /**
@@ -1471,30 +1523,52 @@ const createMeiliMongooseModel = ({ index, attributesToIndex, }) => {
         /**
          * Adds the current document to the MeiliSearch index
          */
-        async addObjectToMeili() {
+        async addObjectToMeili(next) {
             const object = this.preprocessObjectForIndex();
             try {
                 await index.addDocuments([object]);
             }
             catch (error) {
-                logger$1.error('[addObjectToMeili] Error adding document to Meili', error);
+                logger$1.error('[addObjectToMeili] Error adding document to Meili:', error);
+                return next();
             }
-            await this.collection.updateMany({ _id: this._id }, { $set: { _meiliIndex: true } });
+            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() {
-            const object = _.omitBy(_.pick(this.toJSON(), attributesToIndex), (v, k) => k.startsWith('$'));
-            await index.updateDocuments([object]);
+        async updateObjectToMeili(next) {
+            try {
+                const object = _.omitBy(_.pick(this.toJSON(), attributesToIndex), (v, k) => k.startsWith('$'));
+                await index.updateDocuments([object]);
+                next();
+            }
+            catch (error) {
+                logger$1.error('[updateObjectToMeili] Error updating document in Meili:', error);
+                return next();
+            }
         }
         /**
          * Deletes the current document from the MeiliSearch index.
          *
          * @returns {Promise<void>}
          */
-        async deleteObjectFromMeili() {
-            await index.deleteDocument(this._id);
+        async deleteObjectFromMeili(next) {
+            try {
+                await index.deleteDocument(this._id);
+                next();
+            }
+            catch (error) {
+                logger$1.error('[deleteObjectFromMeili] Error deleting document from Meili:', error);
+                return next();
+            }
         }
         /**
          * Post-save hook to synchronize the document with MeiliSearch.
@@ -1502,12 +1576,12 @@ const createMeiliMongooseModel = ({ index, attributesToIndex, }) => {
          * If the document is already indexed (i.e. `_meiliIndex` is true), it updates it;
          * otherwise, it adds the document to the index.
          */
-        postSaveHook() {
+        postSaveHook(next) {
             if (this._meiliIndex) {
-                this.updateObjectToMeili();
+                this.updateObjectToMeili(next);
             }
             else {
-                this.addObjectToMeili();
+                this.addObjectToMeili(next);
             }
         }
         /**
@@ -1516,9 +1590,12 @@ const createMeiliMongooseModel = ({ index, attributesToIndex, }) => {
          * This hook is triggered after a document update, ensuring that changes are
          * propagated to the MeiliSearch index if the document is indexed.
          */
-        postUpdateHook() {
+        postUpdateHook(next) {
             if (this._meiliIndex) {
-                this.updateObjectToMeili();
+                this.updateObjectToMeili(next);
+            }
+            else {
+                next();
             }
         }
         /**
@@ -1527,9 +1604,12 @@ const createMeiliMongooseModel = ({ index, attributesToIndex, }) => {
          * This hook is triggered after a document is removed, ensuring that the document
          * is also removed from the MeiliSearch index if it was previously indexed.
          */
-        postRemoveHook() {
+        postRemoveHook(next) {
             if (this._meiliIndex) {
-                this.deleteObjectFromMeili();
+                this.deleteObjectFromMeili(next);
+            }
+            else {
+                next();
             }
         }
     }
@@ -1577,17 +1657,17 @@ function mongoMeili(schema, options) {
     ];
     schema.loadClass(createMeiliMongooseModel({ index, attributesToIndex }));
     // Register Mongoose hooks
-    schema.post('save', function (doc) {
+    schema.post('save', function (doc, next) {
         var _a;
-        (_a = doc.postSaveHook) === null || _a === void 0 ? void 0 : _a.call(doc);
+        (_a = doc.postSaveHook) === null || _a === void 0 ? void 0 : _a.call(doc, next);
     });
-    schema.post('updateOne', function (doc) {
+    schema.post('updateOne', function (doc, next) {
         var _a;
-        (_a = doc.postUpdateHook) === null || _a === void 0 ? void 0 : _a.call(doc);
+        (_a = doc.postUpdateHook) === null || _a === void 0 ? void 0 : _a.call(doc, next);
     });
-    schema.post('deleteOne', function (doc) {
+    schema.post('deleteOne', function (doc, next) {
         var _a;
-        (_a = doc.postRemoveHook) === null || _a === void 0 ? void 0 : _a.call(doc);
+        (_a = doc.postRemoveHook) === null || _a === void 0 ? void 0 : _a.call(doc, next);
     });
     // Pre-deleteMany hook: remove corresponding documents from MeiliSearch when multiple documents are deleted.
     schema.pre('deleteMany', async function (next) {
@@ -1624,13 +1704,13 @@ function mongoMeili(schema, options) {
         }
     });
     // Post-findOneAndUpdate hook
-    schema.post('findOneAndUpdate', async function (doc) {
+    schema.post('findOneAndUpdate', async function (doc, next) {
         var _a;
         if (!meiliEnabled) {
-            return;
+            return next();
         }
         if (doc.unfinished) {
-            return;
+            return next();
         }
         let meiliDoc;
         if (doc.messages) {
@@ -1643,9 +1723,9 @@ function mongoMeili(schema, options) {
             }
         }
         if (meiliDoc && meiliDoc.title === doc.title) {
-            return;
+            return next();
         }
-        (_a = doc.postSaveHook) === null || _a === void 0 ? void 0 : _a.call(doc);
+        (_a = doc.postSaveHook) === null || _a === void 0 ? void 0 : _a.call(doc, next);
     });
 }
 
@@ -1796,6 +1876,10 @@ function createToolCallModel(mongoose) {
     return mongoose.models.ToolCall || mongoose.model('ToolCall', toolCallSchema);
 }
 
+function createMemoryModel(mongoose) {
+    return mongoose.models.MemoryEntry || mongoose.model('MemoryEntry', MemoryEntrySchema);
+}
+
 /**
  * Creates all database models for all collections
  */
@@ -1823,6 +1907,7 @@ function createModels(mongoose) {
         ConversationTag: createConversationTagModel(mongoose),
         SharedLink: createSharedLinkModel(mongoose),
         ToolCall: createToolCallModel(mongoose),
+        MemoryEntry: createMemoryModel(mongoose),
     };
 }
 
@@ -1958,6 +2043,28 @@ function createUserMethods(mongoose) {
             expirationTime: expires / 1000,
         });
     }
+    /**
+     * Update a user's personalization memories setting.
+     * Handles the edge case where the personalization object doesn't exist.
+     */
+    async function toggleUserMemories(userId, memoriesEnabled) {
+        const User = mongoose.models.User;
+        // First, ensure the personalization object exists
+        const user = await User.findById(userId);
+        if (!user) {
+            return null;
+        }
+        // Use $set to update the nested field, which will create the personalization object if it doesn't exist
+        const updateOperation = {
+            $set: {
+                'personalization.memories': memoriesEnabled,
+            },
+        };
+        return (await User.findByIdAndUpdate(userId, updateOperation, {
+            new: true,
+            runValidators: true,
+        }).lean());
+    }
     // Return all methods
     return {
         findUser,
@@ -1967,6 +2074,7 @@ function createUserMethods(mongoose) {
         getUserById,
         deleteUserById,
         generateToken,
+        toggleUserMemories,
     };
 }
 
@@ -2171,14 +2279,11 @@ const jsonTruncateFormat = winston.format((info) => {
     return truncateObject(info);
 });
 
-// Define log directory
-const logDir = path.join(__dirname, '..', 'logs');
-// Type-safe environment variables
+const logDir = path.join(__dirname, '..', '..', '..', 'api', 'logs');
 const { NODE_ENV, DEBUG_LOGGING, CONSOLE_JSON, DEBUG_CONSOLE } = process.env;
 const useConsoleJson = typeof CONSOLE_JSON === 'string' && CONSOLE_JSON.toLowerCase() === 'true';
 const useDebugConsole = typeof DEBUG_CONSOLE === 'string' && DEBUG_CONSOLE.toLowerCase() === 'true';
 const useDebugLogging = typeof DEBUG_LOGGING === 'string' && DEBUG_LOGGING.toLowerCase() === 'true';
-// Define custom log levels
 const levels = {
     error: 0,
     warn: 1,
@@ -2258,7 +2363,7 @@ const logger = winston.createLogger({
     transports,
 });
 
-var _a, _b;
+var _a;
 class SessionError extends Error {
     constructor(message, code = 'SESSION_ERROR') {
         super(message);
@@ -2267,7 +2372,9 @@ class SessionError extends Error {
     }
 }
 const { REFRESH_TOKEN_EXPIRY } = (_a = process.env) !== null && _a !== void 0 ? _a : {};
-const expires = (_b = eval(REFRESH_TOKEN_EXPIRY !== null && REFRESH_TOKEN_EXPIRY !== void 0 ? REFRESH_TOKEN_EXPIRY : '0')) !== null && _b !== void 0 ? _b : 1000 * 60 * 60 * 24 * 7; // 7 days default
+const expires = REFRESH_TOKEN_EXPIRY
+    ? eval(REFRESH_TOKEN_EXPIRY)
+    : 1000 * 60 * 60 * 24 * 7; // 7 days default
 // Factory function that takes mongoose instance and returns the methods
 function createSessionMethods(mongoose) {
     const Session = mongoose.models.Session;
@@ -2597,6 +2704,584 @@ function createRoleMethods(mongoose) {
     };
 }
 
+/**
+ * Formats a date in YYYY-MM-DD format
+ */
+const formatDate = (date) => {
+    return date.toISOString().split('T')[0];
+};
+// Factory function that takes mongoose instance and returns the methods
+function createMemoryMethods(mongoose) {
+    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()}`);
+        }
+        return memo.get(id);
+    };
+}
+const anonymizeConvoId = memoizedAnonymizeId('convo');
+const anonymizeAssistantId = memoizedAnonymizeId('a');
+const anonymizeMessageId = (id) => id === 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();
+            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();
+            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
  */
@@ -2606,8 +3291,11 @@ function createMethods(mongoose) {
         ...createSessionMethods(mongoose),
         ...createTokenMethods(mongoose),
         ...createRoleMethods(mongoose),
+        ...createMemoryMethods(mongoose),
+        ...createShareMethods(mongoose),
+        ...createPluginAuthMethods(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 };
+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, MemoryEntrySchema as memorySchema, messageSchema, pluginAuthSchema, presetSchema, projectSchema, promptGroupSchema, promptSchema, roleSchema, sessionSchema, shareSchema, signPayload, tokenSchema, toolCallSchema, transactionSchema, userSchema };
 //# sourceMappingURL=index.es.js.map