fix(api): restore deleted Message/Conversation/Preset/Prompt models (runtime MODULE_NOT_FOUND)

The upstream LibreChat consolidation (#11830) deleted api/models/{Message,
Conversation,Preset,Prompt}.js and moved their logic into @librechat/data-schemas'
createMethods. A later conflict-resolution merge (73d4b423a) reverted the
data-schemas createMethods composition back to the pre-consolidation form (so it
no longer provides message/conversation/preset/prompt methods) but did NOT restore
the deleted api/models/*.js files. The result is a half-applied consolidation:

  - api/models/index.js still requires ./Message, ./Conversation, ./Preset
  - api/server/middleware/error.js, .../abortRun.js, .../fork.js, prompt access
    guards, etc. still require('~/models/Message' | '~/models/Conversation' |
    '~/models/Prompt')
  - but those files no longer exist -> backend crashes at startup with
    MODULE_NOT_FOUND (api/models/index.js:13 -> ./Message), crashlooping the pod.

Frontend build + jest passed because they never exercised this require chain.

Fix: restore the four model files from their last good pre-#11830 revision
(214252d2e, on this branch's own ancestry, so namespaces match HEAD:
@librechat/data-schemas, librechat-data-provider, ~/db/models), updating only the
@librechat/api import to @hanzochat/api to match the forked package (#36).

Verified locally with module-alias registered as the server does:
  require('./models') loads (138 exports, all message/convo/preset present);
  the full crash chain models -> banViolation -> logViolation -> cache ->
  db/indexSync -> server/middleware/error resolves with no MODULE_NOT_FOUND;
  @hanzochat/api still exports handleError/sendEvent/createTempChatExpirationDate/
  escapeRegExp/sanitizeMessageForTransmit.

api/models/Conversation.js

@@ -0,0 +1,373 @@
+const { logger } = require('@librechat/data-schemas');
+const { createTempChatExpirationDate } = require('@hanzochat/api');
+const { getMessages, deleteMessages } = require('./Message');
+const { Conversation } = require('~/db/models');
+
+/**
+ * Searches for a conversation by conversationId and returns a lean document with only conversationId and user.
+ * @param {string} conversationId - The conversation's ID.
+ * @returns {Promise<{conversationId: string, user: string} | null>} The conversation object with selected fields or null if not found.
+ */
+const searchConversation = async (conversationId) => {
+  try {
+    return await Conversation.findOne({ conversationId }, 'conversationId user').lean();
+  } catch (error) {
+    logger.error('[searchConversation] Error searching conversation', error);
+    throw new Error('Error searching conversation');
+  }
+};
+
+/**
+ * Retrieves a single conversation for a given user and conversation ID.
+ * @param {string} user - The user's ID.
+ * @param {string} conversationId - The conversation's ID.
+ * @returns {Promise<TConversation>} The conversation object.
+ */
+const getConvo = async (user, conversationId) => {
+  try {
+    return await Conversation.findOne({ user, conversationId }).lean();
+  } catch (error) {
+    logger.error('[getConvo] Error getting single conversation', error);
+    throw new Error('Error getting single conversation');
+  }
+};
+
+const deleteNullOrEmptyConversations = async () => {
+  try {
+    const filter = {
+      $or: [
+        { conversationId: null },
+        { conversationId: '' },
+        { conversationId: { $exists: false } },
+      ],
+    };
+
+    const result = await Conversation.deleteMany(filter);
+
+    // Delete associated messages
+    const messageDeleteResult = await deleteMessages(filter);
+
+    logger.info(
+      `[deleteNullOrEmptyConversations] Deleted ${result.deletedCount} conversations and ${messageDeleteResult.deletedCount} messages`,
+    );
+
+    return {
+      conversations: result,
+      messages: messageDeleteResult,
+    };
+  } catch (error) {
+    logger.error('[deleteNullOrEmptyConversations] Error deleting conversations', error);
+    throw new Error('Error deleting conversations with null or empty conversationId');
+  }
+};
+
+/**
+ * Searches for a conversation by conversationId and returns associated file ids.
+ * @param {string} conversationId - The conversation's ID.
+ * @returns {Promise<string[] | null>}
+ */
+const getConvoFiles = async (conversationId) => {
+  try {
+    return (await Conversation.findOne({ conversationId }, 'files').lean())?.files ?? [];
+  } catch (error) {
+    logger.error('[getConvoFiles] Error getting conversation files', error);
+    throw new Error('Error getting conversation files');
+  }
+};
+
+module.exports = {
+  getConvoFiles,
+  searchConversation,
+  deleteNullOrEmptyConversations,
+  /**
+   * Saves a conversation to the database.
+   * @param {Object} req - The request object.
+   * @param {string} conversationId - The conversation's ID.
+   * @param {Object} metadata - Additional metadata to log for operation.
+   * @returns {Promise<TConversation>} The conversation object.
+   */
+  saveConvo: async (req, { conversationId, newConversationId, ...convo }, metadata) => {
+    try {
+      if (metadata?.context) {
+        logger.debug(`[saveConvo] ${metadata.context}`);
+      }
+
+      const messages = await getMessages({ conversationId }, '_id');
+      const update = { ...convo, messages, user: req.user.id };
+
+      if (newConversationId) {
+        update.conversationId = newConversationId;
+      }
+
+      if (req?.body?.isTemporary) {
+        try {
+          const appConfig = req.config;
+          update.expiredAt = createTempChatExpirationDate(appConfig?.interfaceConfig);
+        } catch (err) {
+          logger.error('Error creating temporary chat expiration date:', err);
+          logger.info(`---\`saveConvo\` context: ${metadata?.context}`);
+          update.expiredAt = null;
+        }
+      } else {
+        update.expiredAt = null;
+      }
+
+      /** @type {{ $set: Partial<TConversation>; $unset?: Record<keyof TConversation, number> }} */
+      const updateOperation = { $set: update };
+      if (metadata && metadata.unsetFields && Object.keys(metadata.unsetFields).length > 0) {
+        updateOperation.$unset = metadata.unsetFields;
+      }
+
+      /** Note: the resulting Model object is necessary for Meilisearch operations */
+      const conversation = await Conversation.findOneAndUpdate(
+        { conversationId, user: req.user.id },
+        updateOperation,
+        {
+          new: true,
+          upsert: metadata?.noUpsert !== true,
+        },
+      );
+
+      if (!conversation) {
+        logger.debug('[saveConvo] Conversation not found, skipping update');
+        return null;
+      }
+
+      return conversation.toObject();
+    } catch (error) {
+      logger.error('[saveConvo] Error saving conversation', error);
+      if (metadata && metadata?.context) {
+        logger.info(`[saveConvo] ${metadata.context}`);
+      }
+      return { message: 'Error saving conversation' };
+    }
+  },
+  bulkSaveConvos: async (conversations) => {
+    try {
+      const bulkOps = conversations.map((convo) => ({
+        updateOne: {
+          filter: { conversationId: convo.conversationId, user: convo.user },
+          update: convo,
+          upsert: true,
+          timestamps: false,
+        },
+      }));
+
+      const result = await Conversation.bulkWrite(bulkOps);
+      return result;
+    } catch (error) {
+      logger.error('[bulkSaveConvos] Error saving conversations in bulk', error);
+      throw new Error('Failed to save conversations in bulk.');
+    }
+  },
+  getConvosByCursor: async (
+    user,
+    {
+      cursor,
+      limit = 25,
+      isArchived = false,
+      tags,
+      search,
+      sortBy = 'updatedAt',
+      sortDirection = 'desc',
+    } = {},
+  ) => {
+    const filters = [{ user }];
+    if (isArchived) {
+      filters.push({ isArchived: true });
+    } else {
+      filters.push({ $or: [{ isArchived: false }, { isArchived: { $exists: false } }] });
+    }
+
+    if (Array.isArray(tags) && tags.length > 0) {
+      filters.push({ tags: { $in: tags } });
+    }
+
+    filters.push({ $or: [{ expiredAt: null }, { expiredAt: { $exists: false } }] });
+
+    if (search) {
+      try {
+        const meiliResults = await Conversation.meiliSearch(search, { filter: `user = "${user}"` });
+        const matchingIds = Array.isArray(meiliResults.hits)
+          ? meiliResults.hits.map((result) => result.conversationId)
+          : [];
+        if (!matchingIds.length) {
+          return { conversations: [], nextCursor: null };
+        }
+        filters.push({ conversationId: { $in: matchingIds } });
+      } catch (error) {
+        logger.error('[getConvosByCursor] Error during meiliSearch', error);
+        throw new Error('Error during meiliSearch');
+      }
+    }
+
+    const validSortFields = ['title', 'createdAt', 'updatedAt'];
+    if (!validSortFields.includes(sortBy)) {
+      throw new Error(
+        `Invalid sortBy field: ${sortBy}. Must be one of ${validSortFields.join(', ')}`,
+      );
+    }
+    const finalSortBy = sortBy;
+    const finalSortDirection = sortDirection === 'asc' ? 'asc' : 'desc';
+
+    let cursorFilter = null;
+    if (cursor) {
+      try {
+        const decoded = JSON.parse(Buffer.from(cursor, 'base64').toString());
+        const { primary, secondary } = decoded;
+        const primaryValue = finalSortBy === 'title' ? primary : new Date(primary);
+        const secondaryValue = new Date(secondary);
+        const op = finalSortDirection === 'asc' ? '$gt' : '$lt';
+
+        cursorFilter = {
+          $or: [
+            { [finalSortBy]: { [op]: primaryValue } },
+            {
+              [finalSortBy]: primaryValue,
+              updatedAt: { [op]: secondaryValue },
+            },
+          ],
+        };
+      } catch (_err) {
+        logger.warn('[getConvosByCursor] Invalid cursor format, starting from beginning');
+      }
+      if (cursorFilter) {
+        filters.push(cursorFilter);
+      }
+    }
+
+    const query = filters.length === 1 ? filters[0] : { $and: filters };
+
+    try {
+      const sortOrder = finalSortDirection === 'asc' ? 1 : -1;
+      const sortObj = { [finalSortBy]: sortOrder };
+
+      if (finalSortBy !== 'updatedAt') {
+        sortObj.updatedAt = sortOrder;
+      }
+
+      const convos = await Conversation.find(query)
+        .select(
+          'conversationId endpoint title createdAt updatedAt user model agent_id assistant_id spec iconURL',
+        )
+        .sort(sortObj)
+        .limit(limit + 1)
+        .lean();
+
+      let nextCursor = null;
+      if (convos.length > limit) {
+        convos.pop(); // Remove extra item used to detect next page
+        // Create cursor from the last RETURNED item (not the popped one)
+        const lastReturned = convos[convos.length - 1];
+        const primaryValue = lastReturned[finalSortBy];
+        const primaryStr = finalSortBy === 'title' ? primaryValue : primaryValue.toISOString();
+        const secondaryStr = lastReturned.updatedAt.toISOString();
+        const composite = { primary: primaryStr, secondary: secondaryStr };
+        nextCursor = Buffer.from(JSON.stringify(composite)).toString('base64');
+      }
+
+      return { conversations: convos, nextCursor };
+    } catch (error) {
+      logger.error('[getConvosByCursor] Error getting conversations', error);
+      throw new Error('Error getting conversations');
+    }
+  },
+  getConvosQueried: async (user, convoIds, cursor = null, limit = 25) => {
+    try {
+      if (!convoIds?.length) {
+        return { conversations: [], nextCursor: null, convoMap: {} };
+      }
+
+      const conversationIds = convoIds.map((convo) => convo.conversationId);
+
+      const results = await Conversation.find({
+        user,
+        conversationId: { $in: conversationIds },
+        $or: [{ expiredAt: { $exists: false } }, { expiredAt: null }],
+      }).lean();
+
+      results.sort((a, b) => new Date(b.updatedAt) - new Date(a.updatedAt));
+
+      let filtered = results;
+      if (cursor && cursor !== 'start') {
+        const cursorDate = new Date(cursor);
+        filtered = results.filter((convo) => new Date(convo.updatedAt) < cursorDate);
+      }
+
+      const limited = filtered.slice(0, limit + 1);
+      let nextCursor = null;
+      if (limited.length > limit) {
+        limited.pop(); // Remove extra item used to detect next page
+        // Create cursor from the last RETURNED item (not the popped one)
+        nextCursor = limited[limited.length - 1].updatedAt.toISOString();
+      }
+
+      const convoMap = {};
+      limited.forEach((convo) => {
+        convoMap[convo.conversationId] = convo;
+      });
+
+      return { conversations: limited, nextCursor, convoMap };
+    } catch (error) {
+      logger.error('[getConvosQueried] Error getting conversations', error);
+      throw new Error('Error fetching conversations');
+    }
+  },
+  getConvo,
+  /* chore: this method is not properly error handled */
+  getConvoTitle: async (user, conversationId) => {
+    try {
+      const convo = await getConvo(user, conversationId);
+      /* ChatGPT Browser was triggering error here due to convo being saved later */
+      if (convo && !convo.title) {
+        return null;
+      } else {
+        // TypeError: Cannot read properties of null (reading 'title')
+        return convo?.title || 'New Chat';
+      }
+    } catch (error) {
+      logger.error('[getConvoTitle] Error getting conversation title', error);
+      throw new Error('Error getting conversation title');
+    }
+  },
+  /**
+   * Asynchronously deletes conversations and associated messages for a given user and filter.
+   *
+   * @async
+   * @function
+   * @param {string|ObjectId} user - The user's ID.
+   * @param {Object} filter - Additional filter criteria for the conversations to be deleted.
+   * @returns {Promise<{ n: number, ok: number, deletedCount: number, messages: { n: number, ok: number, deletedCount: number } }>}
+   *          An object containing the count of deleted conversations and associated messages.
+   * @throws {Error} Throws an error if there's an issue with the database operations.
+   *
+   * @example
+   * const user = 'someUserId';
+   * const filter = { someField: 'someValue' };
+   * const result = await deleteConvos(user, filter);
+   * logger.error(result); // { n: 5, ok: 1, deletedCount: 5, messages: { n: 10, ok: 1, deletedCount: 10 } }
+   */
+  deleteConvos: async (user, filter) => {
+    try {
+      const userFilter = { ...filter, user };
+      const conversations = await Conversation.find(userFilter).select('conversationId');
+      const conversationIds = conversations.map((c) => c.conversationId);
+
+      if (!conversationIds.length) {
+        throw new Error('Conversation not found or already deleted.');
+      }
+
+      const deleteConvoResult = await Conversation.deleteMany(userFilter);
+
+      const deleteMessagesResult = await deleteMessages({
+        conversationId: { $in: conversationIds },
+        user,
+      });
+
+      return { ...deleteConvoResult, messages: deleteMessagesResult };
+    } catch (error) {
+      logger.error('[deleteConvos] Error deleting conversations and messages', error);
+      throw error;
+    }
+  },
+};

api/models/Message.js

@@ -0,0 +1,372 @@
+const { z } = require('zod');
+const { logger } = require('@librechat/data-schemas');
+const { createTempChatExpirationDate } = require('@hanzochat/api');
+const { Message } = require('~/db/models');
+
+const idSchema = z.string().uuid();
+
+/**
+ * Saves a message in the database.
+ *
+ * @async
+ * @function saveMessage
+ * @param {ServerRequest} req - The request object containing user information.
+ * @param {Object} params - The message data object.
+ * @param {string} params.endpoint - The endpoint where the message originated.
+ * @param {string} params.iconURL - The URL of the sender's icon.
+ * @param {string} params.messageId - The unique identifier for the message.
+ * @param {string} params.newMessageId - The new unique identifier for the message (if applicable).
+ * @param {string} params.conversationId - The identifier of the conversation.
+ * @param {string} [params.parentMessageId] - The identifier of the parent message, if any.
+ * @param {string} params.sender - The identifier of the sender.
+ * @param {string} params.text - The text content of the message.
+ * @param {boolean} params.isCreatedByUser - Indicates if the message was created by the user.
+ * @param {string} [params.error] - Any error associated with the message.
+ * @param {boolean} [params.unfinished] - Indicates if the message is unfinished.
+ * @param {Object[]} [params.files] - An array of files associated with the message.
+ * @param {string} [params.finish_reason] - Reason for finishing the message.
+ * @param {number} [params.tokenCount] - The number of tokens in the message.
+ * @param {string} [params.plugin] - Plugin associated with the message.
+ * @param {string[]} [params.plugins] - An array of plugins associated with the message.
+ * @param {string} [params.model] - The model used to generate the message.
+ * @param {Object} [metadata] - Additional metadata for this operation
+ * @param {string} [metadata.context] - The context of the operation
+ * @returns {Promise<TMessage>} The updated or newly inserted message document.
+ * @throws {Error} If there is an error in saving the message.
+ */
+async function saveMessage(req, params, metadata) {
+  if (!req?.user?.id) {
+    throw new Error('User not authenticated');
+  }
+
+  const validConvoId = idSchema.safeParse(params.conversationId);
+  if (!validConvoId.success) {
+    logger.warn(`Invalid conversation ID: ${params.conversationId}`);
+    logger.info(`---\`saveMessage\` context: ${metadata?.context}`);
+    logger.info(`---Invalid conversation ID Params: ${JSON.stringify(params, null, 2)}`);
+    return;
+  }
+
+  try {
+    const update = {
+      ...params,
+      user: req.user.id,
+      messageId: params.newMessageId || params.messageId,
+    };
+
+    if (req?.body?.isTemporary) {
+      try {
+        const appConfig = req.config;
+        update.expiredAt = createTempChatExpirationDate(appConfig?.interfaceConfig);
+      } catch (err) {
+        logger.error('Error creating temporary chat expiration date:', err);
+        logger.info(`---\`saveMessage\` context: ${metadata?.context}`);
+        update.expiredAt = null;
+      }
+    } else {
+      update.expiredAt = null;
+    }
+
+    if (update.tokenCount != null && isNaN(update.tokenCount)) {
+      logger.warn(
+        `Resetting invalid \`tokenCount\` for message \`${params.messageId}\`: ${update.tokenCount}`,
+      );
+      logger.info(`---\`saveMessage\` context: ${metadata?.context}`);
+      update.tokenCount = 0;
+    }
+    const message = await Message.findOneAndUpdate(
+      { messageId: params.messageId, user: req.user.id },
+      update,
+      { upsert: true, new: true },
+    );
+
+    return message.toObject();
+  } catch (err) {
+    logger.error('Error saving message:', err);
+    logger.info(`---\`saveMessage\` context: ${metadata?.context}`);
+
+    // Check if this is a duplicate key error (MongoDB error code 11000)
+    if (err.code === 11000 && err.message.includes('duplicate key error')) {
+      // Log the duplicate key error but don't crash the application
+      logger.warn(`Duplicate messageId detected: ${params.messageId}. Continuing execution.`);
+
+      try {
+        // Try to find the existing message with this ID
+        const existingMessage = await Message.findOne({
+          messageId: params.messageId,
+          user: req.user.id,
+        });
+
+        // If we found it, return it
+        if (existingMessage) {
+          return existingMessage.toObject();
+        }
+
+        // If we can't find it (unlikely but possible in race conditions)
+        return {
+          ...params,
+          messageId: params.messageId,
+          user: req.user.id,
+        };
+      } catch (findError) {
+        // If the findOne also fails, log it but don't crash
+        logger.warn(
+          `Could not retrieve existing message with ID ${params.messageId}: ${findError.message}`,
+        );
+        return {
+          ...params,
+          messageId: params.messageId,
+          user: req.user.id,
+        };
+      }
+    }
+
+    throw err; // Re-throw other errors
+  }
+}
+
+/**
+ * Saves multiple messages in the database in bulk.
+ *
+ * @async
+ * @function bulkSaveMessages
+ * @param {Object[]} messages - An array of message objects to save.
+ * @param {boolean} [overrideTimestamp=false] - Indicates whether to override the timestamps of the messages. Defaults to false.
+ * @returns {Promise<Object>} The result of the bulk write operation.
+ * @throws {Error} If there is an error in saving messages in bulk.
+ */
+async function bulkSaveMessages(messages, overrideTimestamp = false) {
+  try {
+    const bulkOps = messages.map((message) => ({
+      updateOne: {
+        filter: { messageId: message.messageId },
+        update: message,
+        timestamps: !overrideTimestamp,
+        upsert: true,
+      },
+    }));
+    const result = await Message.bulkWrite(bulkOps);
+    return result;
+  } catch (err) {
+    logger.error('Error saving messages in bulk:', err);
+    throw err;
+  }
+}
+
+/**
+ * Records a message in the database.
+ *
+ * @async
+ * @function recordMessage
+ * @param {Object} params - The message data object.
+ * @param {string} params.user - The identifier of the user.
+ * @param {string} params.endpoint - The endpoint where the message originated.
+ * @param {string} params.messageId - The unique identifier for the message.
+ * @param {string} params.conversationId - The identifier of the conversation.
+ * @param {string} [params.parentMessageId] - The identifier of the parent message, if any.
+ * @param {Partial<TMessage>} rest - Any additional properties from the TMessage typedef not explicitly listed.
+ * @returns {Promise<Object>} The updated or newly inserted message document.
+ * @throws {Error} If there is an error in saving the message.
+ */
+async function recordMessage({
+  user,
+  endpoint,
+  messageId,
+  conversationId,
+  parentMessageId,
+  ...rest
+}) {
+  try {
+    // No parsing of convoId as may use threadId
+    const message = {
+      user,
+      endpoint,
+      messageId,
+      conversationId,
+      parentMessageId,
+      ...rest,
+    };
+
+    return await Message.findOneAndUpdate({ user, messageId }, message, {
+      upsert: true,
+      new: true,
+    });
+  } catch (err) {
+    logger.error('Error recording message:', err);
+    throw err;
+  }
+}
+
+/**
+ * Updates the text of a message.
+ *
+ * @async
+ * @function updateMessageText
+ * @param {Object} params - The update data object.
+ * @param {Object} req - The request object.
+ * @param {string} params.messageId - The unique identifier for the message.
+ * @param {string} params.text - The new text content of the message.
+ * @returns {Promise<void>}
+ * @throws {Error} If there is an error in updating the message text.
+ */
+async function updateMessageText(req, { messageId, text }) {
+  try {
+    await Message.updateOne({ messageId, user: req.user.id }, { text });
+  } catch (err) {
+    logger.error('Error updating message text:', err);
+    throw err;
+  }
+}
+
+/**
+ * Updates a message.
+ *
+ * @async
+ * @function updateMessage
+ * @param {Object} req - The request object.
+ * @param {Object} message - The message object containing update data.
+ * @param {string} message.messageId - The unique identifier for the message.
+ * @param {string} [message.text] - The new text content of the message.
+ * @param {Object[]} [message.files] - The files associated with the message.
+ * @param {boolean} [message.isCreatedByUser] - Indicates if the message was created by the user.
+ * @param {string} [message.sender] - The identifier of the sender.
+ * @param {number} [message.tokenCount] - The number of tokens in the message.
+ * @param {Object} [metadata] - The operation metadata
+ * @param {string} [metadata.context] - The operation metadata
+ * @returns {Promise<TMessage>} The updated message document.
+ * @throws {Error} If there is an error in updating the message or if the message is not found.
+ */
+async function updateMessage(req, message, metadata) {
+  try {
+    const { messageId, ...update } = message;
+    const updatedMessage = await Message.findOneAndUpdate(
+      { messageId, user: req.user.id },
+      update,
+      {
+        new: true,
+      },
+    );
+
+    if (!updatedMessage) {
+      throw new Error('Message not found or user not authorized.');
+    }
+
+    return {
+      messageId: updatedMessage.messageId,
+      conversationId: updatedMessage.conversationId,
+      parentMessageId: updatedMessage.parentMessageId,
+      sender: updatedMessage.sender,
+      text: updatedMessage.text,
+      isCreatedByUser: updatedMessage.isCreatedByUser,
+      tokenCount: updatedMessage.tokenCount,
+      feedback: updatedMessage.feedback,
+    };
+  } catch (err) {
+    logger.error('Error updating message:', err);
+    if (metadata && metadata?.context) {
+      logger.info(`---\`updateMessage\` context: ${metadata.context}`);
+    }
+    throw err;
+  }
+}
+
+/**
+ * Deletes messages in a conversation since a specific message.
+ *
+ * @async
+ * @function deleteMessagesSince
+ * @param {Object} params - The parameters object.
+ * @param {Object} req - The request object.
+ * @param {string} params.messageId - The unique identifier for the message.
+ * @param {string} params.conversationId - The identifier of the conversation.
+ * @returns {Promise<Number>} The number of deleted messages.
+ * @throws {Error} If there is an error in deleting messages.
+ */
+async function deleteMessagesSince(req, { messageId, conversationId }) {
+  try {
+    const message = await Message.findOne({ messageId, user: req.user.id }).lean();
+
+    if (message) {
+      const query = Message.find({ conversationId, user: req.user.id });
+      return await query.deleteMany({
+        createdAt: { $gt: message.createdAt },
+      });
+    }
+    return undefined;
+  } catch (err) {
+    logger.error('Error deleting messages:', err);
+    throw err;
+  }
+}
+
+/**
+ * Retrieves messages from the database.
+ * @async
+ * @function getMessages
+ * @param {Record<string, unknown>} filter - The filter criteria.
+ * @param {string | undefined} [select] - The fields to select.
+ * @returns {Promise<TMessage[]>} The messages that match the filter criteria.
+ * @throws {Error} If there is an error in retrieving messages.
+ */
+async function getMessages(filter, select) {
+  try {
+    if (select) {
+      return await Message.find(filter).select(select).sort({ createdAt: 1 }).lean();
+    }
+
+    return await Message.find(filter).sort({ createdAt: 1 }).lean();
+  } catch (err) {
+    logger.error('Error getting messages:', err);
+    throw err;
+  }
+}
+
+/**
+ * Retrieves a single message from the database.
+ * @async
+ * @function getMessage
+ * @param {{ user: string, messageId: string }} params - The search parameters
+ * @returns {Promise<TMessage | null>} The message that matches the criteria or null if not found
+ * @throws {Error} If there is an error in retrieving the message
+ */
+async function getMessage({ user, messageId }) {
+  try {
+    return await Message.findOne({
+      user,
+      messageId,
+    }).lean();
+  } catch (err) {
+    logger.error('Error getting message:', err);
+    throw err;
+  }
+}
+
+/**
+ * Deletes messages from the database.
+ *
+ * @async
+ * @function deleteMessages
+ * @param {import('mongoose').FilterQuery<import('mongoose').Document>} filter - The filter criteria to find messages to delete.
+ * @returns {Promise<import('mongoose').DeleteResult>} The metadata with count of deleted messages.
+ * @throws {Error} If there is an error in deleting messages.
+ */
+async function deleteMessages(filter) {
+  try {
+    return await Message.deleteMany(filter);
+  } catch (err) {
+    logger.error('Error deleting messages:', err);
+    throw err;
+  }
+}
+
+module.exports = {
+  saveMessage,
+  bulkSaveMessages,
+  recordMessage,
+  updateMessageText,
+  updateMessage,
+  deleteMessagesSince,
+  getMessages,
+  getMessage,
+  deleteMessages,
+};

api/models/Preset.js

@@ -0,0 +1,82 @@
+const { logger } = require('@librechat/data-schemas');
+const { Preset } = require('~/db/models');
+
+const getPreset = async (user, presetId) => {
+  try {
+    return await Preset.findOne({ user, presetId }).lean();
+  } catch (error) {
+    logger.error('[getPreset] Error getting single preset', error);
+    return { message: 'Error getting single preset' };
+  }
+};
+
+module.exports = {
+  getPreset,
+  getPresets: async (user, filter) => {
+    try {
+      const presets = await Preset.find({ ...filter, user }).lean();
+      const defaultValue = 10000;
+
+      presets.sort((a, b) => {
+        let orderA = a.order !== undefined ? a.order : defaultValue;
+        let orderB = b.order !== undefined ? b.order : defaultValue;
+
+        if (orderA !== orderB) {
+          return orderA - orderB;
+        }
+
+        return b.updatedAt - a.updatedAt;
+      });
+
+      return presets;
+    } catch (error) {
+      logger.error('[getPresets] Error getting presets', error);
+      return { message: 'Error retrieving presets' };
+    }
+  },
+  savePreset: async (user, { presetId, newPresetId, defaultPreset, ...preset }) => {
+    try {
+      const setter = { $set: {} };
+      const { user: _, ...cleanPreset } = preset;
+      const update = { presetId, ...cleanPreset };
+      if (preset.tools && Array.isArray(preset.tools)) {
+        update.tools =
+          preset.tools
+            .map((tool) => tool?.pluginKey ?? tool)
+            .filter((toolName) => typeof toolName === 'string') ?? [];
+      }
+      if (newPresetId) {
+        update.presetId = newPresetId;
+      }
+
+      if (defaultPreset) {
+        update.defaultPreset = defaultPreset;
+        update.order = 0;
+
+        const currentDefault = await Preset.findOne({ defaultPreset: true, user });
+
+        if (currentDefault && currentDefault.presetId !== presetId) {
+          await Preset.findByIdAndUpdate(currentDefault._id, {
+            $unset: { defaultPreset: '', order: '' },
+          });
+        }
+      } else if (defaultPreset === false) {
+        update.defaultPreset = undefined;
+        update.order = undefined;
+        setter['$unset'] = { defaultPreset: '', order: '' };
+      }
+
+      setter.$set = update;
+      return await Preset.findOneAndUpdate({ presetId, user }, setter, { new: true, upsert: true });
+    } catch (error) {
+      logger.error('[savePreset] Error saving preset', error);
+      return { message: 'Error saving preset' };
+    }
+  },
+  deletePresets: async (user, filter) => {
+    // let toRemove = await Preset.find({ ...filter, user }).select('presetId');
+    // const ids = toRemove.map((instance) => instance.presetId);
+    let deleteCount = await Preset.deleteMany({ ...filter, user });
+    return deleteCount;
+  },
+};

api/models/Prompt.js

@@ -0,0 +1,588 @@
+const { ObjectId } = require('mongodb');
+const { escapeRegExp } = require('@hanzochat/api');
+const { logger } = require('@librechat/data-schemas');
+const { SystemRoles, ResourceType, SystemCategories } = require('librechat-data-provider');
+const {
+  getSoleOwnedResourceIds,
+  removeAllPermissions,
+} = require('~/server/services/PermissionService');
+const { PromptGroup, Prompt, AclEntry } = require('~/db/models');
+
+/**
+ * Batch-fetches production prompts for an array of prompt groups
+ * and attaches them as `productionPrompt` field.
+ * Replaces $lookup aggregation for FerretDB compatibility.
+ */
+const attachProductionPrompts = async (groups) => {
+  const uniqueIds = [...new Set(groups.map((g) => g.productionId?.toString()).filter(Boolean))];
+  if (uniqueIds.length === 0) {
+    return groups.map((g) => ({ ...g, productionPrompt: null }));
+  }
+
+  const prompts = await Prompt.find({ _id: { $in: uniqueIds } })
+    .select('prompt')
+    .lean();
+  const promptMap = new Map(prompts.map((p) => [p._id.toString(), p]));
+
+  return groups.map((g) => ({
+    ...g,
+    productionPrompt: g.productionId ? (promptMap.get(g.productionId.toString()) ?? null) : null,
+  }));
+};
+
+/**
+ * Get all prompt groups with filters
+ * @param {ServerRequest} req
+ * @param {TPromptGroupsWithFilterRequest} filter
+ * @returns {Promise<PromptGroupListResponse>}
+ */
+const getAllPromptGroups = async (req, filter) => {
+  try {
+    const { name, ...query } = filter;
+
+    if (name) {
+      query.name = new RegExp(escapeRegExp(name), 'i');
+    }
+    if (!query.category) {
+      delete query.category;
+    } else if (query.category === SystemCategories.MY_PROMPTS) {
+      delete query.category;
+    } else if (query.category === SystemCategories.NO_CATEGORY) {
+      query.category = '';
+    } else if (query.category === SystemCategories.SHARED_PROMPTS) {
+      delete query.category;
+    }
+
+    let combinedQuery = query;
+
+    const groups = await PromptGroup.find(combinedQuery)
+      .sort({ createdAt: -1 })
+      .select('name oneliner category author authorName createdAt updatedAt command productionId')
+      .lean();
+    return await attachProductionPrompts(groups);
+  } catch (error) {
+    console.error('Error getting all prompt groups', error);
+    return { message: 'Error getting all prompt groups' };
+  }
+};
+
+/**
+ * Get prompt groups with filters
+ * @param {ServerRequest} req
+ * @param {TPromptGroupsWithFilterRequest} filter
+ * @returns {Promise<PromptGroupListResponse>}
+ */
+const getPromptGroups = async (req, filter) => {
+  try {
+    const { pageNumber = 1, pageSize = 10, name, ...query } = filter;
+
+    const validatedPageNumber = Math.max(parseInt(pageNumber, 10), 1);
+    const validatedPageSize = Math.max(parseInt(pageSize, 10), 1);
+
+    if (name) {
+      query.name = new RegExp(escapeRegExp(name), 'i');
+    }
+    if (!query.category) {
+      delete query.category;
+    } else if (query.category === SystemCategories.MY_PROMPTS) {
+      delete query.category;
+    } else if (query.category === SystemCategories.NO_CATEGORY) {
+      query.category = '';
+    } else if (query.category === SystemCategories.SHARED_PROMPTS) {
+      delete query.category;
+    }
+
+    let combinedQuery = query;
+
+    const skip = (validatedPageNumber - 1) * validatedPageSize;
+    const limit = validatedPageSize;
+
+    const [groups, totalPromptGroups] = await Promise.all([
+      PromptGroup.find(combinedQuery)
+        .sort({ createdAt: -1 })
+        .skip(skip)
+        .limit(limit)
+        .select(
+          'name numberOfGenerations oneliner category productionId author authorName createdAt updatedAt',
+        )
+        .lean(),
+      PromptGroup.countDocuments(combinedQuery),
+    ]);
+
+    const promptGroups = await attachProductionPrompts(groups);
+
+    return {
+      promptGroups,
+      pageNumber: validatedPageNumber.toString(),
+      pageSize: validatedPageSize.toString(),
+      pages: Math.ceil(totalPromptGroups / validatedPageSize).toString(),
+    };
+  } catch (error) {
+    console.error('Error getting prompt groups', error);
+    return { message: 'Error getting prompt groups' };
+  }
+};
+
+/**
+ * @param {Object} fields
+ * @param {string} fields._id
+ * @param {string} fields.author
+ * @param {string} fields.role
+ * @returns {Promise<TDeletePromptGroupResponse>}
+ */
+const deletePromptGroup = async ({ _id, author, role }) => {
+  // Build query - with ACL, author is optional
+  const query = { _id };
+  const groupQuery = { groupId: new ObjectId(_id) };
+
+  // Legacy: Add author filter if provided (backward compatibility)
+  if (author && role !== SystemRoles.ADMIN) {
+    query.author = author;
+    groupQuery.author = author;
+  }
+
+  const response = await PromptGroup.deleteOne(query);
+
+  if (!response || response.deletedCount === 0) {
+    throw new Error('Prompt group not found');
+  }
+
+  await Prompt.deleteMany(groupQuery);
+
+  try {
+    await removeAllPermissions({ resourceType: ResourceType.PROMPTGROUP, resourceId: _id });
+  } catch (error) {
+    logger.error('Error removing promptGroup permissions:', error);
+  }
+
+  return { message: 'Prompt group deleted successfully' };
+};
+
+/**
+ * Get prompt groups by accessible IDs with optional cursor-based pagination.
+ * @param {Object} params - The parameters for getting accessible prompt groups.
+ * @param {Array} [params.accessibleIds] - Array of prompt group ObjectIds the user has ACL access to.
+ * @param {Object} [params.otherParams] - Additional query parameters (including author filter).
+ * @param {number} [params.limit] - Number of prompt groups to return (max 100). If not provided, returns all prompt groups.
+ * @param {string} [params.after] - Cursor for pagination - get prompt groups after this cursor. // base64 encoded JSON string with updatedAt and _id.
+ * @returns {Promise<Object>} A promise that resolves to an object containing the prompt groups data and pagination info.
+ */
+async function getListPromptGroupsByAccess({
+  accessibleIds = [],
+  otherParams = {},
+  limit = null,
+  after = null,
+}) {
+  const isPaginated = limit !== null && limit !== undefined;
+  const normalizedLimit = isPaginated ? Math.min(Math.max(1, parseInt(limit) || 20), 100) : null;
+
+  const baseQuery = { ...otherParams, _id: { $in: accessibleIds } };
+
+  if (after && typeof after === 'string' && after !== 'undefined' && after !== 'null') {
+    try {
+      const cursor = JSON.parse(Buffer.from(after, 'base64').toString('utf8'));
+      const { updatedAt, _id } = cursor;
+
+      const cursorCondition = {
+        $or: [
+          { updatedAt: { $lt: new Date(updatedAt) } },
+          { updatedAt: new Date(updatedAt), _id: { $gt: new ObjectId(_id) } },
+        ],
+      };
+
+      if (Object.keys(baseQuery).length > 0) {
+        baseQuery.$and = [{ ...baseQuery }, cursorCondition];
+        Object.keys(baseQuery).forEach((key) => {
+          if (key !== '$and') delete baseQuery[key];
+        });
+      } else {
+        Object.assign(baseQuery, cursorCondition);
+      }
+    } catch (error) {
+      logger.warn('Invalid cursor:', error.message);
+    }
+  }
+
+  const findQuery = PromptGroup.find(baseQuery)
+    .sort({ updatedAt: -1, _id: 1 })
+    .select(
+      'name numberOfGenerations oneliner category productionId author authorName createdAt updatedAt',
+    );
+
+  if (isPaginated) {
+    findQuery.limit(normalizedLimit + 1);
+  }
+
+  const groups = await findQuery.lean();
+  const promptGroups = await attachProductionPrompts(groups);
+
+  const hasMore = isPaginated ? promptGroups.length > normalizedLimit : false;
+  const data = (isPaginated ? promptGroups.slice(0, normalizedLimit) : promptGroups).map(
+    (group) => {
+      if (group.author) {
+        group.author = group.author.toString();
+      }
+      return group;
+    },
+  );
+
+  let nextCursor = null;
+  if (isPaginated && hasMore && data.length > 0) {
+    const lastGroup = promptGroups[normalizedLimit - 1];
+    nextCursor = Buffer.from(
+      JSON.stringify({
+        updatedAt: lastGroup.updatedAt.toISOString(),
+        _id: lastGroup._id.toString(),
+      }),
+    ).toString('base64');
+  }
+
+  return {
+    object: 'list',
+    data,
+    first_id: data.length > 0 ? data[0]._id.toString() : null,
+    last_id: data.length > 0 ? data[data.length - 1]._id.toString() : null,
+    has_more: hasMore,
+    after: nextCursor,
+  };
+}
+
+module.exports = {
+  getPromptGroups,
+  deletePromptGroup,
+  getAllPromptGroups,
+  getListPromptGroupsByAccess,
+  /**
+   * Create a prompt and its respective group
+   * @param {TCreatePromptRecord} saveData
+   * @returns {Promise<TCreatePromptResponse>}
+   */
+  createPromptGroup: async (saveData) => {
+    try {
+      const { prompt, group, author, authorName } = saveData;
+
+      let newPromptGroup = await PromptGroup.findOneAndUpdate(
+        { ...group, author, authorName, productionId: null },
+        { $setOnInsert: { ...group, author, authorName, productionId: null } },
+        { new: true, upsert: true },
+      )
+        .lean()
+        .select('-__v')
+        .exec();
+
+      const newPrompt = await Prompt.findOneAndUpdate(
+        { ...prompt, author, groupId: newPromptGroup._id },
+        { $setOnInsert: { ...prompt, author, groupId: newPromptGroup._id } },
+        { new: true, upsert: true },
+      )
+        .lean()
+        .select('-__v')
+        .exec();
+
+      newPromptGroup = await PromptGroup.findByIdAndUpdate(
+        newPromptGroup._id,
+        { productionId: newPrompt._id },
+        { new: true },
+      )
+        .lean()
+        .select('-__v')
+        .exec();
+
+      return {
+        prompt: newPrompt,
+        group: {
+          ...newPromptGroup,
+          productionPrompt: { prompt: newPrompt.prompt },
+        },
+      };
+    } catch (error) {
+      logger.error('Error saving prompt group', error);
+      throw new Error('Error saving prompt group');
+    }
+  },
+  /**
+   * Save a prompt
+   * @param {TCreatePromptRecord} saveData
+   * @returns {Promise<TCreatePromptResponse>}
+   */
+  savePrompt: async (saveData) => {
+    try {
+      const { prompt, author } = saveData;
+      const newPromptData = {
+        ...prompt,
+        author,
+      };
+
+      /** @type {TPrompt} */
+      let newPrompt;
+      try {
+        newPrompt = await Prompt.create(newPromptData);
+      } catch (error) {
+        if (error?.message?.includes('groupId_1_version_1')) {
+          await Prompt.db.collection('prompts').dropIndex('groupId_1_version_1');
+        } else {
+          throw error;
+        }
+        newPrompt = await Prompt.create(newPromptData);
+      }
+
+      return { prompt: newPrompt };
+    } catch (error) {
+      logger.error('Error saving prompt', error);
+      return { message: 'Error saving prompt' };
+    }
+  },
+  getPrompts: async (filter) => {
+    try {
+      return await Prompt.find(filter).sort({ createdAt: -1 }).lean();
+    } catch (error) {
+      logger.error('Error getting prompts', error);
+      return { message: 'Error getting prompts' };
+    }
+  },
+  getPrompt: async (filter) => {
+    try {
+      if (filter.groupId) {
+        filter.groupId = new ObjectId(filter.groupId);
+      }
+      return await Prompt.findOne(filter).lean();
+    } catch (error) {
+      logger.error('Error getting prompt', error);
+      return { message: 'Error getting prompt' };
+    }
+  },
+  /**
+   * Get prompt groups with filters
+   * @param {TGetRandomPromptsRequest} filter
+   * @returns {Promise<TGetRandomPromptsResponse>}
+   */
+  getRandomPromptGroups: async (filter) => {
+    try {
+      const categories = await PromptGroup.distinct('category', { category: { $ne: '' } });
+
+      for (let i = categories.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [categories[i], categories[j]] = [categories[j], categories[i]];
+      }
+
+      const skip = +filter.skip;
+      const limit = +filter.limit;
+      const selectedCategories = categories.slice(skip, skip + limit);
+
+      if (selectedCategories.length === 0) {
+        return { prompts: [] };
+      }
+
+      const groups = await PromptGroup.find({ category: { $in: selectedCategories } }).lean();
+
+      const groupByCategory = new Map();
+      for (const group of groups) {
+        if (!groupByCategory.has(group.category)) {
+          groupByCategory.set(group.category, group);
+        }
+      }
+
+      const prompts = selectedCategories.map((cat) => groupByCategory.get(cat)).filter(Boolean);
+
+      return { prompts };
+    } catch (error) {
+      logger.error('Error getting prompt groups', error);
+      return { message: 'Error getting prompt groups' };
+    }
+  },
+  getPromptGroupsWithPrompts: async (filter) => {
+    try {
+      return await PromptGroup.findOne(filter)
+        .populate({
+          path: 'prompts',
+          select: '-_id -__v -user',
+        })
+        .select('-_id -__v -user')
+        .lean();
+    } catch (error) {
+      logger.error('Error getting prompt groups', error);
+      return { message: 'Error getting prompt groups' };
+    }
+  },
+  getPromptGroup: async (filter) => {
+    try {
+      return await PromptGroup.findOne(filter).lean();
+    } catch (error) {
+      logger.error('Error getting prompt group', error);
+      return { message: 'Error getting prompt group' };
+    }
+  },
+  /**
+   * Deletes a prompt and its corresponding prompt group if it is the last prompt in the group.
+   *
+   * @param {Object} options - The options for deleting the prompt.
+   * @param {ObjectId|string} options.promptId - The ID of the prompt to delete.
+   * @param {ObjectId|string} options.groupId - The ID of the prompt's group.
+   * @param {ObjectId|string} options.author - The ID of the prompt's author.
+   * @param {string} options.role - The role of the prompt's author.
+   * @return {Promise<TDeletePromptResponse>} An object containing the result of the deletion.
+   * If the prompt was deleted successfully, the object will have a property 'prompt' with the value 'Prompt deleted successfully'.
+   * If the prompt group was deleted successfully, the object will have a property 'promptGroup' with the message 'Prompt group deleted successfully' and id of the deleted group.
+   * If there was an error deleting the prompt, the object will have a property 'message' with the value 'Error deleting prompt'.
+   */
+  deletePrompt: async ({ promptId, groupId, author, role }) => {
+    const query = { _id: promptId, groupId, author };
+    if (role === SystemRoles.ADMIN) {
+      delete query.author;
+    }
+    const { deletedCount } = await Prompt.deleteOne(query);
+    if (deletedCount === 0) {
+      throw new Error('Failed to delete the prompt');
+    }
+
+    const remainingPrompts = await Prompt.find({ groupId })
+      .select('_id')
+      .sort({ createdAt: 1 })
+      .lean();
+
+    if (remainingPrompts.length === 0) {
+      // Remove all ACL entries for the promptGroup when deleting the last prompt
+      try {
+        await removeAllPermissions({
+          resourceType: ResourceType.PROMPTGROUP,
+          resourceId: groupId,
+        });
+      } catch (error) {
+        logger.error('Error removing promptGroup permissions:', error);
+      }
+
+      await PromptGroup.deleteOne({ _id: groupId });
+
+      return {
+        prompt: 'Prompt deleted successfully',
+        promptGroup: {
+          message: 'Prompt group deleted successfully',
+          id: groupId,
+        },
+      };
+    } else {
+      const promptGroup = await PromptGroup.findById(groupId).lean();
+      if (promptGroup.productionId.toString() === promptId.toString()) {
+        await PromptGroup.updateOne(
+          { _id: groupId },
+          { productionId: remainingPrompts[remainingPrompts.length - 1]._id },
+        );
+      }
+
+      return { prompt: 'Prompt deleted successfully' };
+    }
+  },
+  /**
+   * Delete prompt groups solely owned by the user and clean up their prompts/ACLs.
+   * Groups with other owners are left intact; the caller is responsible for
+   * removing the user's own ACL principal entries separately.
+   *
+   * Also handles legacy (pre-ACL) prompt groups that only have the author field set,
+   * ensuring they are not orphaned if the permission migration has not been run.
+   * @param {string} userId - The ID of the user whose prompts and prompt groups are to be deleted.
+   */
+  deleteUserPrompts: async (userId) => {
+    try {
+      const userObjectId = new ObjectId(userId);
+      const soleOwnedIds = await getSoleOwnedResourceIds(userObjectId, ResourceType.PROMPTGROUP);
+
+      const authoredGroups = await PromptGroup.find({ author: userObjectId }).select('_id').lean();
+      const authoredGroupIds = authoredGroups.map((g) => g._id);
+
+      const migratedEntries =
+        authoredGroupIds.length > 0
+          ? await AclEntry.find({
+              resourceType: ResourceType.PROMPTGROUP,
+              resourceId: { $in: authoredGroupIds },
+            })
+              .select('resourceId')
+              .lean()
+          : [];
+      const migratedIds = new Set(migratedEntries.map((e) => e.resourceId.toString()));
+      const legacyGroupIds = authoredGroupIds.filter((id) => !migratedIds.has(id.toString()));
+
+      const allGroupIdsToDelete = [...soleOwnedIds, ...legacyGroupIds];
+
+      if (allGroupIdsToDelete.length === 0) {
+        return;
+      }
+
+      await AclEntry.deleteMany({
+        resourceType: ResourceType.PROMPTGROUP,
+        resourceId: { $in: allGroupIdsToDelete },
+      });
+
+      await PromptGroup.deleteMany({ _id: { $in: allGroupIdsToDelete } });
+      await Prompt.deleteMany({ groupId: { $in: allGroupIdsToDelete } });
+    } catch (error) {
+      logger.error('[deleteUserPrompts] General error:', error);
+    }
+  },
+  /**
+   * Update prompt group
+   * @param {Partial<MongoPromptGroup>} filter - Filter to find prompt group
+   * @param {Partial<MongoPromptGroup>} data - Data to update
+   * @returns {Promise<TUpdatePromptGroupResponse>}
+   */
+  updatePromptGroup: async (filter, data) => {
+    try {
+      const updateOps = {};
+
+      const updateData = { ...data, ...updateOps };
+      const updatedDoc = await PromptGroup.findOneAndUpdate(filter, updateData, {
+        new: true,
+        upsert: false,
+      });
+
+      if (!updatedDoc) {
+        throw new Error('Prompt group not found');
+      }
+
+      return updatedDoc;
+    } catch (error) {
+      logger.error('Error updating prompt group', error);
+      return { message: 'Error updating prompt group' };
+    }
+  },
+  /**
+   * Function to make a prompt production based on its ID.
+   * @param {String} promptId - The ID of the prompt to make production.
+   * @returns {Object} The result of the production operation.
+   */
+  makePromptProduction: async (promptId) => {
+    try {
+      const prompt = await Prompt.findById(promptId).lean();
+
+      if (!prompt) {
+        throw new Error('Prompt not found');
+      }
+
+      await PromptGroup.findByIdAndUpdate(
+        prompt.groupId,
+        { productionId: prompt._id },
+        { new: true },
+      )
+        .lean()
+        .exec();
+
+      return {
+        message: 'Prompt production made successfully',
+      };
+    } catch (error) {
+      logger.error('Error making prompt production', error);
+      return { message: 'Error making prompt production' };
+    }
+  },
+  updatePromptLabels: async (_id, labels) => {
+    try {
+      const response = await Prompt.updateOne({ _id }, { $set: { labels } });
+      if (response.matchedCount === 0) {
+        return { message: 'Prompt not found' };
+      }
+      return { message: 'Prompt labels updated successfully' };
+    } catch (error) {
+      logger.error('Error updating prompt labels', error);
+      return { message: 'Error updating prompt labels' };
+    }
+  },
+};