Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
♻️ refactor: Native Prompts Behind a Shared Service and Adapter (#16506)
Atef Bellaaj7c4cfa868452
diff --git a/api/server/controllers/UserController.spec.js b/api/server/controllers/UserController.spec.jsindex 4b283ae4a4..34d932263d 100644--- a/api/server/controllers/UserController.spec.js+++ b/api/server/controllers/UserController.spec.js@@ -160,16 +160,19 @@ jest.mock('~/cache', () => ({let mongoServer;beforeAll(async () => {- mongoServer = await MongoMemoryServer.create();+ mongoServer = await MongoMemoryServer.create({ instance: { launchTimeout: 30_000 } });await mongoose.connect(mongoServer.getUri());-});+}, 60_000);afterAll(async () => {await mongoose.disconnect();- await mongoServer.stop();+ await mongoServer?.stop();});afterEach(async () => {+ if (mongoose.connection.readyState !== 1) {+ return;+ }const collections = mongoose.connection.collections;for (const key in collections) {await collections[key].deleteMany({});diff --git a/api/server/middleware/accessResources/canAccessPromptGroupResource.js b/api/server/middleware/accessResources/canAccessPromptGroupResource.jsindex 9da1994a77..ab82251a03 100644--- a/api/server/middleware/accessResources/canAccessPromptGroupResource.js+++ b/api/server/middleware/accessResources/canAccessPromptGroupResource.js@@ -1,43 +1,18 @@const { ResourceType } = require('librechat-data-provider');+const { createPromptAccessResolvers } = require('@librechat/api');const { canAccessResource } = require('./canAccessResource');-const { getPromptGroup } = require('~/models');+const db = require('~/models');-/**- * PromptGroup ID resolver function- * Resolves promptGroup ID to MongoDB ObjectId- *- * @param {string} groupId - PromptGroup ID from route parameter- * @returns {Promise<Object|null>} PromptGroup document with _id field, or null if not found- */-const resolvePromptGroupId = async (groupId) => {- return await getPromptGroup({ _id: groupId });-};+const { resolvePromptGroup } = createPromptAccessResolvers(db);/*** PromptGroup-specific middleware factory that creates middleware to check promptGroup access permissions.- * This middleware extends the generic canAccessResource to handle promptGroup ID resolution.+ * On success, the loaded group is available as `req.resourceAccess.resourceInfo`.** @param {Object} options - Configuration options* @param {number} options.requiredPermission - The permission bit required (1=view, 2=edit, 4=delete, 8=share)* @param {string} [options.resourceIdParam='groupId'] - The name of the route parameter containing the promptGroup ID* @returns {Function} Express middleware function- *- * @example- * // Basic usage for viewing promptGroups- * router.get('/prompts/groups/:groupId',- * canAccessPromptGroupResource({ requiredPermission: 1 }),- * getPromptGroup- * );- *- * @example- * // Custom resource ID parameter and edit permission- * router.patch('/prompts/groups/:id',- * canAccessPromptGroupResource({- * requiredPermission: 2,- * resourceIdParam: 'id'- * }),- * updatePromptGroup- * );*/const canAccessPromptGroupResource = (options) => {const { requiredPermission, resourceIdParam = 'groupId' } = options;@@ -52,7 +27,7 @@ const canAccessPromptGroupResource = (options) => {resourceType: ResourceType.PROMPTGROUP,requiredPermission,resourceIdParam,- idResolver: resolvePromptGroupId,+ idResolver: resolvePromptGroup,});};diff --git a/api/server/middleware/accessResources/canAccessPromptViaGroup.js b/api/server/middleware/accessResources/canAccessPromptViaGroup.jsindex 534db3d6c6..306c0fdafa 100644--- a/api/server/middleware/accessResources/canAccessPromptViaGroup.js+++ b/api/server/middleware/accessResources/canAccessPromptViaGroup.js@@ -1,39 +1,20 @@const { ResourceType } = require('librechat-data-provider');+const { createPromptAccessResolvers } = require('@librechat/api');const { canAccessResource } = require('./canAccessResource');-const { getPrompt } = require('~/models');+const db = require('~/models');-/**- * Prompt to PromptGroup ID resolver function- * Resolves prompt ID to its parent promptGroup ID- *- * @param {string} promptId - Prompt ID from route parameter- * @returns {Promise<Object|null>} Object with promptGroup's _id field, or null if not found- */-const resolvePromptToGroupId = async (promptId) => {- const prompt = await getPrompt({ _id: promptId });- if (!prompt || !prompt.groupId) {- return null;- }- // Return an object with _id that matches the promptGroup ID- return { _id: prompt.groupId };-};+const { resolvePromptViaGroup } = createPromptAccessResolvers(db);/*** Middleware factory that checks promptGroup permissions when accessing individual prompts.* This allows permission management at the promptGroup level while still supporting- * individual prompt access patterns.+ * individual prompt access patterns. On success, the loaded revision is available as+ * `req.resourceAccess.resourceInfo.prompt`.** @param {Object} options - Configuration options* @param {number} options.requiredPermission - The permission bit required (1=view, 2=edit, 4=delete, 8=share)* @param {string} [options.resourceIdParam='promptId'] - The name of the route parameter containing the prompt ID* @returns {Function} Express middleware function- *- * @example- * // Check promptGroup permissions when viewing a prompt- * router.get('/prompts/:promptId',- * canAccessPromptViaGroup({ requiredPermission: 1 }),- * getPrompt- * );*/const canAccessPromptViaGroup = (options) => {const { requiredPermission, resourceIdParam = 'promptId' } = options;@@ -46,7 +27,7 @@ const canAccessPromptViaGroup = (options) => {resourceType: ResourceType.PROMPTGROUP,requiredPermission,resourceIdParam,- idResolver: resolvePromptToGroupId,+ idResolver: resolvePromptViaGroup,});};diff --git a/api/server/routes/files/files.agents.test.js b/api/server/routes/files/files.agents.test.jsindex 45b082601d..d1afe54056 100644--- a/api/server/routes/files/files.agents.test.js+++ b/api/server/routes/files/files.agents.test.js@@ -98,7 +98,7 @@ describe('File Routes - Agent Files Endpoint', () => {let modelsToCleanup = [];beforeAll(async () => {- mongoServer = await MongoMemoryServer.create();+ mongoServer = await MongoMemoryServer.create({ instance: { launchTimeout: 30_000 } });const mongoUri = mongoServer.getUri();await mongoose.connect(mongoUri);@@ -137,13 +137,15 @@ describe('File Routes - Agent Files Endpoint', () => {});app.use('/files', router);- });+ }, 60_000);afterAll(async () => {// Clean up all collections before disconnecting- const collections = mongoose.connection.collections;- for (const key in collections) {- await collections[key].deleteMany({});+ if (mongoose.connection.readyState === 1) {+ const collections = mongoose.connection.collections;+ for (const key in collections) {+ await collections[key].deleteMany({});+ }}// Clear only the models we added@@ -154,7 +156,7 @@ describe('File Routes - Agent Files Endpoint', () => {}await mongoose.disconnect();- await mongoServer.stop();+ await mongoServer?.stop();});beforeEach(async () => {diff --git a/api/server/routes/prompts.js b/api/server/routes/prompts.jsindex f166a907e3..e2d7a947cd 100644--- a/api/server/routes/prompts.js+++ b/api/server/routes/prompts.js@@ -1,44 +1,10 @@const express = require('express');-const { ObjectId } = require('mongodb');-const { logger, isValidObjectIdString } = require('@librechat/data-schemas');const {generateCheckAccess,- markPublicPromptGroups,- buildPromptGroupFilter,- formatPromptGroupsResponse,- safeValidatePromptGroupUpdate,- createEmptyPromptGroupsResponse,- filterAccessibleIdsBySharedLogic,- inspectPromptContent,- projectStoredPrompts,- projectStoredPromptGroup,- projectStoredPromptGroups,- contentFilterBlockResponse,+ createPromptService,+ createPromptHandlers,} = require('@librechat/api');-const {- Permissions,- ResourceType,- AccessRoleIds,- PrincipalType,- PermissionBits,- PermissionTypes,-} = require('librechat-data-provider');-const { SystemCapabilities } = require('@librechat/data-schemas');-const {- getListPromptGroupsByAccess,- getPromptGroupAccessContext,- incrementPromptGroupUsage,- makePromptProduction,- updatePromptGroup,- deletePromptGroup,- createPromptGroup,- getPromptGroup,- getRoleByName,- deletePrompt,- getPrompts,- savePrompt,- getPrompt,-} = require('~/models');+const { Permissions, PermissionBits, PermissionTypes } = require('librechat-data-provider');const {canAccessPromptGroupResource,canAccessPromptViaGroup,@@ -47,18 +13,16 @@ const {configMiddleware,} = require('~/server/middleware');const { getEffectivePermissions, grantPermission } = require('~/server/services/PermissionService');-const { hasCapability } = require('~/server/middleware/roles/capabilities');+const db = require('~/models');+const { getRoleByName } = db;const router = express.Router();-const blockFilteredPromptContent = (req, res, promptData) => {- const finding = inspectPromptContent(promptData, req.config?.filters);- if (finding == null) {- return false;- }- res.status(400).json(contentFilterBlockResponse(finding));- return true;-};+const handlers = createPromptHandlers({+ service: createPromptService({ db, grantPermission }),+ getPromptGroupAccessContext: db.getPromptGroupAccessContext,+ getEffectivePermissions,+});const checkPromptAccess = generateCheckAccess({permissionType: PermissionTypes.PROMPTS,@@ -74,502 +38,52 @@ const checkPromptCreate = generateCheckAccess({router.use(requireJwtAuth);router.use(checkPromptAccess);-const checkGlobalPromptShare = generateCheckAccess({- permissionType: PermissionTypes.PROMPTS,- permissions: [Permissions.USE, Permissions.CREATE],- getRoleByName,-});--/**- * Route to get single prompt group by its ID- * GET /groups/:groupId- */router.get('/groups/:groupId',- canAccessPromptGroupResource({- requiredPermission: PermissionBits.VIEW,- }),+ canAccessPromptGroupResource({ requiredPermission: PermissionBits.VIEW }),configMiddleware,- async (req, res) => {- const { groupId } = req.params;-- try {- const group = await getPromptGroup({ _id: groupId });-- if (!group) {- return res.status(404).send({ message: 'Prompt group not found' });- }-- if (blockFilteredPromptContent(req, res, { group })) {- return;- }-- res.status(200).send(projectStoredPromptGroup(group, req.config?.filters));- } catch (error) {- logger.error('Error getting prompt group', error);- res.status(500).send({ message: 'Error getting prompt group' });- }- },+ handlers.getPromptGroup,);+router.get('/all', configMiddleware, handlers.listAllPromptGroups);+router.get('/groups', configMiddleware, handlers.listPromptGroups);-/**- * Route to fetch all prompt groups (ACL-aware)- * GET /all- */-router.get('/all', configMiddleware, async (req, res) => {- try {- const userId = req.user.id;- const { name, category } = req.query;- const { filter, searchShared, searchSharedOnly } = buildPromptGroupFilter({- name,- category,- });-- const { accessibleIds, publiclyAccessibleIds, ownedPromptGroupIds } =- await getPromptGroupAccessContext({ userId, role: req.user.role });-- const filteredAccessibleIds = await filterAccessibleIdsBySharedLogic({- accessibleIds,- searchShared,- searchSharedOnly,- publicPromptGroupIds: publiclyAccessibleIds,- ownedPromptGroupIds,- });-- const result = await getListPromptGroupsByAccess({- accessibleIds: filteredAccessibleIds,- otherParams: filter,- });-- if (!result) {- return res.status(200).send([]);- }-- const { data: promptGroups = [] } = result;- if (!promptGroups.length) {- return res.status(200).send([]);- }-- const readablePromptGroups = projectStoredPromptGroups(promptGroups, req.config?.filters, {- forReuse: true,- });- const groupsWithPublicFlag = markPublicPromptGroups(- readablePromptGroups,- publiclyAccessibleIds,- );- res.status(200).send(groupsWithPublicFlag);- } catch (error) {- logger.error(error);- res.status(500).send({ error: 'Error getting prompt groups' });- }-});--/**- * Route to fetch paginated prompt groups with filters (ACL-aware)- * GET /groups- */-router.get('/groups', configMiddleware, async (req, res) => {- try {- const userId = req.user.id;- const { pageSize, limit, cursor, name, category } = req.query;-- const { filter, searchShared, searchSharedOnly } = buildPromptGroupFilter({- name,- category,- });-- let actualLimit = limit;- let actualCursor = cursor;-- if (pageSize && !limit) {- actualLimit = parseInt(pageSize, 10);- }-- if (- actualCursor &&- (actualCursor === 'undefined' || actualCursor === 'null' || actualCursor.length === 0)- ) {- actualCursor = null;- }-- const { accessibleIds, publiclyAccessibleIds, ownedPromptGroupIds } =- await getPromptGroupAccessContext({ userId, role: req.user.role });-- const filteredAccessibleIds = await filterAccessibleIdsBySharedLogic({- accessibleIds,- searchShared,- searchSharedOnly,- publicPromptGroupIds: publiclyAccessibleIds,- ownedPromptGroupIds,- });-- // Cursor-based pagination only- const result = await getListPromptGroupsByAccess({- accessibleIds: filteredAccessibleIds,- otherParams: filter,- limit: actualLimit,- after: actualCursor,- });-- if (!result) {- const emptyResponse = createEmptyPromptGroupsResponse({- pageNumber: '1',- pageSize: actualLimit,- actualLimit,- });- return res.status(200).send(emptyResponse);- }-- const { data: promptGroups = [], has_more = false, after = null } = result;- const readablePromptGroups = projectStoredPromptGroups(promptGroups, req.config?.filters);- const groupsWithPublicFlag = markPublicPromptGroups(- readablePromptGroups,- publiclyAccessibleIds,- );-- const response = formatPromptGroupsResponse({- promptGroups: groupsWithPublicFlag,- pageNumber: '1', // Always 1 for cursor-based pagination- pageSize: actualLimit.toString(),- hasMore: has_more,- after,- });-- res.status(200).send(response);- } catch (error) {- logger.error(error);- res.status(500).send({ error: 'Error getting prompt groups' });- }-});--/**- * Creates a new prompt group with initial prompt- * @param {object} req- * @param {TCreatePrompt} req.body- * @param {Express.Response} res- */-const createNewPromptGroup = async (req, res) => {- try {- const { prompt, group } = req.body;-- if (!prompt || !group || !group.name) {- return res.status(400).send({ error: 'Prompt and group name are required' });- }-- if (blockFilteredPromptContent(req, res, { prompt, group })) {- return;- }-- const saveData = {- prompt,- group,- author: req.user.id,- authorName: req.user.name,- };-- const result = await createPromptGroup(saveData);-- if (result.prompt && result.prompt._id && result.prompt.groupId) {- try {- await grantPermission({- principalType: PrincipalType.USER,- principalId: req.user.id,- resourceType: ResourceType.PROMPTGROUP,- resourceId: result.prompt.groupId,- accessRoleId: AccessRoleIds.PROMPTGROUP_OWNER,- grantedBy: req.user.id,- });- logger.debug(- `[createPromptGroup] Granted owner permissions to user ${req.user.id} for promptGroup ${result.prompt.groupId}`,- );- } catch (permissionError) {- logger.error(- `[createPromptGroup] Failed to grant owner permissions for promptGroup ${result.prompt.groupId}:`,- permissionError,- );- }- }-- res.status(200).send(result);- } catch (error) {- logger.error(error);- res.status(500).send({ error: 'Error creating prompt group' });- }-};--/**- * Adds a new prompt to an existing prompt group- * @param {object} req- * @param {TCreatePrompt} req.body- * @param {Express.Response} res- */-const addPromptToGroup = async (req, res) => {- try {- const { groupId } = req.params;- const { prompt } = req.body;-- if (!prompt) {- return res.status(400).send({ error: 'Prompt is required' });- }-- if (typeof prompt.prompt !== 'string' || !prompt.prompt.trim()) {- return res- .status(400)- .send({ error: 'Prompt text is required and must be a non-empty string' });- }-- if (prompt.type !== 'text' && prompt.type !== 'chat') {- return res.status(400).send({ error: 'Prompt type must be "text" or "chat"' });- }-- if (blockFilteredPromptContent(req, res, { prompt })) {- return;- }-- // Ensure the prompt is associated with the correct group- prompt.groupId = groupId;-- const saveData = {- prompt,- author: req.user.id,- authorName: req.user.name,- };-- const result = await savePrompt(saveData);- res.status(200).send(result);- } catch (error) {- logger.error(error);- res.status(500).send({ error: 'Error adding prompt to group' });- }-};--// Create new prompt group (requires CREATE permission)-router.post('/', checkPromptCreate, configMiddleware, createNewPromptGroup);--// Add prompt to existing group (requires EDIT permission on the group)+router.post('/', checkPromptCreate, configMiddleware, handlers.createPromptGroup);router.post('/groups/:groupId/prompts',checkPromptAccess,- canAccessPromptGroupResource({- requiredPermission: PermissionBits.EDIT,- }),+ canAccessPromptGroupResource({ requiredPermission: PermissionBits.EDIT }),configMiddleware,- addPromptToGroup,+ handlers.savePrompt,);--/**- * Records a prompt group usage (increments numberOfGenerations)- * POST /groups/:groupId/use- */router.post('/groups/:groupId/use',promptUsageLimiter,- canAccessPromptGroupResource({- requiredPermission: PermissionBits.VIEW,- }),- async (req, res) => {- try {- const { groupId } = req.params;- if (!isValidObjectIdString(groupId)) {- return res.status(400).send({ error: 'Invalid groupId' });- }- const result = await incrementPromptGroupUsage(groupId);- res.status(200).send(result);- } catch (error) {- logger.error('[recordPromptUsage]', error);- if (error.message === 'Invalid groupId') {- return res.status(400).send({ error: 'Invalid groupId' });- }- if (error.message === 'Prompt group not found') {- return res.status(404).send({ error: 'Prompt group not found' });- }- res.status(500).send({ error: 'Error recording prompt usage' });- }- },+ canAccessPromptGroupResource({ requiredPermission: PermissionBits.VIEW }),+ handlers.recordPromptUsage,);-/**- * Updates a prompt group- * @param {object} req- * @param {object} req.params - The request parameters- * @param {string} req.params.groupId - The group ID- * @param {TUpdatePromptGroupPayload} req.body - The request body- * @param {Express.Response} res- */-const patchPromptGroup = async (req, res) => {- try {- const { groupId } = req.params;- // Don't pass author - permissions are now checked by middleware- const filter = { _id: groupId };-- const validationResult = safeValidatePromptGroupUpdate(req.body);- if (!validationResult.success) {- return res.status(400).send({- error: 'Invalid request body',- details: validationResult.error.errors,- });- }-- if (blockFilteredPromptContent(req, res, { group: validationResult.data })) {- return;- }-- const promptGroup = await updatePromptGroup(filter, validationResult.data);- res.status(200).send(promptGroup);- } catch (error) {- logger.error(error);- res.status(500).send({ error: 'Error updating prompt group' });- }-};-router.patch('/groups/:groupId',- checkGlobalPromptShare,- canAccessPromptGroupResource({- requiredPermission: PermissionBits.EDIT,- }),+ checkPromptCreate,+ canAccessPromptGroupResource({ requiredPermission: PermissionBits.EDIT }),configMiddleware,- patchPromptGroup,+ handlers.updatePromptGroup,);-router.patch('/:promptId/tags/production',checkPromptCreate,- canAccessPromptViaGroup({- requiredPermission: PermissionBits.EDIT,- resourceIdParam: 'promptId',- }),+ canAccessPromptViaGroup({ requiredPermission: PermissionBits.EDIT, resourceIdParam: 'promptId' }),configMiddleware,- async (req, res) => {- try {- const { promptId } = req.params;- const prompt = await getPrompt({ _id: promptId });- if (blockFilteredPromptContent(req, res, { prompt })) {- return;- }- const result = await makePromptProduction(promptId);- res.status(200).send(result);- } catch (error) {- logger.error(error);- res.status(500).send({ error: 'Error updating prompt production' });- }- },+ handlers.makePromptProduction,);router.get('/:promptId',- canAccessPromptViaGroup({- requiredPermission: PermissionBits.VIEW,- resourceIdParam: 'promptId',- }),+ canAccessPromptViaGroup({ requiredPermission: PermissionBits.VIEW, resourceIdParam: 'promptId' }),configMiddleware,- async (req, res) => {- const { promptId } = req.params;- const prompt = await getPrompt({ _id: promptId });- if (blockFilteredPromptContent(req, res, { prompt })) {- return;- }- res.status(200).send(prompt);- },+ handlers.getPrompt,);--router.get('/', configMiddleware, async (req, res) => {- try {- const author = req.user.id;- const { groupId } = req.query;-- // If requesting prompts for a specific group, check permissions- if (groupId) {- if (!isValidObjectIdString(groupId)) {- return res.status(400).send({ error: 'Invalid groupId' });- }-- const permissions = await getEffectivePermissions({- userId: req.user.id,- role: req.user.role,- resourceType: ResourceType.PROMPTGROUP,- resourceId: groupId,- });-- if (!(permissions & PermissionBits.VIEW)) {- return res- .status(403)- .send({ error: 'Insufficient permissions to view prompts in this group' });- }-- // If user has access, fetch all prompts in the group (not just their own)- const prompts = await getPrompts({ groupId: new ObjectId(groupId) });- const readablePrompts = Array.isArray(prompts)- ? projectStoredPrompts(prompts, req.config?.filters)- : prompts;- return res.status(200).send(readablePrompts);- }-- // If no groupId, return user's own prompts- const query = { author };- let canReadPrompts = false;- try {- canReadPrompts = await hasCapability(req.user, SystemCapabilities.READ_PROMPTS);- } catch (err) {- logger.warn(`[GET /prompts] capability check failed, denying bypass: ${err.message}`);- }- if (canReadPrompts) {- logger.debug(`[GET /prompts] READ_PROMPTS bypass for user ${req.user.id}`);- delete query.author;- }- const prompts = await getPrompts(query);- const readablePrompts = Array.isArray(prompts)- ? projectStoredPrompts(prompts, req.config?.filters)- : prompts;- res.status(200).send(readablePrompts);- } catch (error) {- logger.error(error);- res.status(500).send({ error: 'Error getting prompts' });- }-});--/**- * Deletes a prompt- *- * @param {ServerRequest} req - The request object.- * @param {TDeletePromptVariables} req.params - The request parameters- * @param {import('mongoose').ObjectId} req.params.promptId - The prompt ID- * @param {Express.Response} res - The response object.- * @return {TDeletePromptResponse} A promise that resolves when the prompt is deleted.- */-const deletePromptController = async (req, res) => {- try {- const { promptId } = req.params;- const { groupId } = req.query;- if (!groupId || !isValidObjectIdString(groupId)) {- return res.status(400).send({ error: 'Invalid or missing groupId' });- }- const query = { promptId, groupId };- const result = await deletePrompt(query);- res.status(200).send(result);- } catch (error) {- logger.error(error);- res.status(500).send({ error: 'Error deleting prompt' });- }-};--/**- * Delete a prompt group- * @param {ServerRequest} req- * @param {ServerResponse} res- * @returns {Promise<TDeletePromptGroupResponse>}- */-const deletePromptGroupController = async (req, res) => {- try {- const { groupId: _id } = req.params;- // Don't pass author or role - permissions are checked by ACL middleware- const message = await deletePromptGroup({ _id });- res.send(message);- } catch (error) {- logger.error('Error deleting prompt group', error);- res.status(500).send({ message: 'Error deleting prompt group' });- }-};+router.get('/', configMiddleware, handlers.getPrompts);router.delete('/:promptId',@@ -578,15 +92,13 @@ router.delete(requiredPermission: PermissionBits.DELETE,resourceIdParam: 'promptId',}),- deletePromptController,+ handlers.deletePrompt,);router.delete('/groups/:groupId',checkPromptCreate,- canAccessPromptGroupResource({- requiredPermission: PermissionBits.DELETE,- }),- deletePromptGroupController,+ canAccessPromptGroupResource({ requiredPermission: PermissionBits.DELETE }),+ handlers.deletePromptGroup,);module.exports = router;diff --git a/api/server/routes/prompts.test.js b/api/server/routes/prompts.test.jsindex b8e06f8094..41040cf2f6 100644--- a/api/server/routes/prompts.test.js+++ b/api/server/routes/prompts.test.js@@ -344,7 +344,7 @@ describe('Prompt Routes - ACL Permissions', () => {const promptData = {prompt: {prompt: 'Group prompt content',- // Remove 'name' from prompt - it's not in the schema+ type: 'text',},group: {name: 'Test Group',@@ -1328,3 +1328,337 @@ describe('Prompt Routes - ACL Permissions', () => {});});});++async function responseOf(pending) {+ const { status, body } = await pending;+ return { status, body };+}++describe('Prompt Routes - response and failure compatibility', () => {+ let consoleErrorSpy;+ let group;+ let revision;++ beforeEach(async () => {+ consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();+ ({ group, prompt: revision } = await createAccessiblePromptGroup({+ name: 'Compatibility Group',+ prompt: 'Compatibility prompt',+ }));+ });++ afterEach(async () => {+ consoleErrorSpy.mockRestore();+ jest.restoreAllMocks();+ await Prompt.deleteMany({});+ await PromptGroup.deleteMany({});+ await AclEntry.deleteMany({});+ });++ it('rejects a group whose initial prompt has no type', async () => {+ await request(app)+ .post('/api/prompts')+ .send({ prompt: { prompt: 'Untyped prompt' }, group: { name: 'Untyped Group' } })+ .expect(400, { error: 'Prompt type must be "text" or "chat"' });++ await expect(PromptGroup.countDocuments({ name: 'Untyped Group' })).resolves.toBe(0);+ });++ it('sends 404 from the access check for a malformed ID', async () => {+ const notFound = (resourceType) => ({+ status: 404,+ body: { error: 'Not Found', message: `${resourceType} not found` },+ });+ expect(await responseOf(request(app).get('/api/prompts/groups/not-an-id'))).toEqual(+ notFound(ResourceType.PROMPTGROUP),+ );+ expect(await responseOf(request(app).get('/api/prompts/not-an-id'))).toEqual(+ notFound(ResourceType.PROMPTGROUP),+ );+ });++ it('sends 500 from the access check when the database read fails', async () => {+ const accessFailure = {+ status: 500,+ body: {+ error: 'Internal Server Error',+ message: 'Failed to check resource access permissions',+ },+ };+ jest.spyOn(PromptGroup, 'aggregate').mockImplementationOnce(() => {+ throw new Error('database unavailable');+ });+ expect(await responseOf(request(app).get(`/api/prompts/groups/${group._id}`))).toEqual(+ accessFailure,+ );++ jest.spyOn(Prompt, 'findOne').mockImplementationOnce(() => {+ throw new Error('database unavailable');+ });+ expect(await responseOf(request(app).get(`/api/prompts/${revision._id}`))).toEqual(+ accessFailure,+ );+ });++ it('adds a revision from the editor payload, which includes groupId', async () => {+ const response = await request(app)+ .post(`/api/prompts/groups/${group._id}/prompts`)+ .send({ prompt: { prompt: 'Second revision', type: 'chat', groupId: group._id.toString() } })+ .expect(200);++ expect(response.body.prompt).toEqual(+ expect.objectContaining({+ prompt: 'Second revision',+ type: 'chat',+ groupId: group._id.toString(),+ author: testUsers.owner._id.toString(),+ }),+ );+ await expect(Prompt.countDocuments({ groupId: group._id })).resolves.toBe(2);+ });++ it('sends the legacy 200 message when saving a revision fails', async () => {+ jest.spyOn(Prompt, 'create').mockRejectedValueOnce(new Error('database unavailable'));++ const response = await request(app)+ .post(`/api/prompts/groups/${group._id}/prompts`)+ .send({ prompt: { prompt: 'Lost revision', type: 'text' } })+ .expect(200);++ expect(response.body).toEqual({ message: 'Error saving prompt' });+ });++ it('returns the group detail with its full Production revision', async () => {+ const response = await request(app).get(`/api/prompts/groups/${group._id}`).expect(200);++ expect(response.body._id).toBe(group._id.toString());+ expect(response.body.productionPrompt).toEqual(+ expect.objectContaining({+ _id: revision._id.toString(),+ prompt: 'Compatibility prompt',+ type: 'text',+ groupId: group._id.toString(),+ }),+ );+ });++ it('returns 404 from the handler when a capability bypass reads a missing group', async () => {+ setTestUser(app, testUsers.admin);++ const response = await request(app).get(`/api/prompts/groups/${new ObjectId()}`).expect(404);++ expect(response.body).toEqual({ message: 'Prompt group not found' });+ });++ it('returns an empty 200 when a capability bypass reads a missing revision', async () => {+ setTestUser(app, testUsers.admin);++ const response = await request(app).get(`/api/prompts/${new ObjectId()}`).expect(200);++ expect(response.text).toBe('');+ });++ it('returns revision history newest first with management fields', async () => {+ const newer = await Prompt.create({+ prompt: 'Newer revision',+ author: testUsers.owner._id,+ type: 'text',+ groupId: group._id,+ createdAt: new Date(Date.now() + 1000),+ });++ const response = await request(app)+ .get('/api/prompts')+ .query({ groupId: group._id.toString() })+ .expect(200);++ expect(response.body.map((item) => item._id)).toEqual([+ newer._id.toString(),+ revision._id.toString(),+ ]);+ expect(response.body[0]).toEqual(+ expect.objectContaining({ author: testUsers.owner._id.toString(), type: 'text' }),+ );+ });++ it('keeps the malformed and denied revision-history responses', async () => {+ expect(+ await responseOf(request(app).get('/api/prompts').query({ groupId: 'not-an-id' })),+ ).toEqual({ status: 400, body: { error: 'Invalid groupId' } });++ setTestUser(app, testUsers.noAccess);+ expect(+ await responseOf(request(app).get('/api/prompts').query({ groupId: group._id.toString() })),+ ).toEqual({+ status: 403,+ body: { error: 'Insufficient permissions to view prompts in this group' },+ });+ });++ it('sends the legacy 200 message when revision history fails', async () => {+ jest.spyOn(Prompt, 'find').mockImplementationOnce(() => {+ throw new Error('database unavailable');+ });++ const response = await request(app)+ .get('/api/prompts')+ .query({ groupId: group._id.toString() })+ .expect(200);++ expect(response.body).toEqual({ message: 'Error getting prompts' });+ });++ it('returns the updated group document fields from a metadata update', async () => {+ const response = await request(app)+ .patch(`/api/prompts/groups/${group._id}`)+ .send({ name: 'Renamed Group', command: 'renamed' })+ .expect(200);++ expect(Object.keys(response.body).sort()).toEqual(+ [+ '__v',+ '_id',+ 'author',+ 'authorName',+ 'category',+ 'command',+ 'createdAt',+ 'name',+ 'numberOfGenerations',+ 'oneliner',+ 'productionId',+ 'updatedAt',+ ].sort(),+ );+ expect(response.body).toEqual(+ expect.objectContaining({ name: 'Renamed Group', command: 'renamed' }),+ );+ });++ it('sends the legacy 200 message when a metadata update fails', async () => {+ jest.spyOn(PromptGroup, 'findOneAndUpdate').mockImplementationOnce(() => {+ throw new Error('database unavailable');+ });++ const response = await request(app)+ .patch(`/api/prompts/groups/${group._id}`)+ .send({ name: 'Renamed Group' })+ .expect(200);++ expect(response.body).toEqual({ message: 'Error updating prompt group' });+ });++ it('sends the legacy 200 message when a capability bypass promotes a missing revision', async () => {+ setTestUser(app, testUsers.admin);++ const response = await request(app)+ .patch(`/api/prompts/${new ObjectId()}/tags/production`)+ .expect(200);++ expect(response.body).toEqual({ message: 'Error making prompt production' });+ });++ it('does not promote when the preliminary read of a capability bypass fails', async () => {+ const candidate = await Prompt.create({+ prompt: 'Candidate revision',+ author: testUsers.owner._id,+ type: 'text',+ groupId: group._id,+ });+ setTestUser(app, testUsers.admin);+ jest.spyOn(Prompt, 'findOne').mockImplementationOnce(() => {+ throw new Error('database unavailable');+ });+ const promote = jest.spyOn(PromptGroup, 'findByIdAndUpdate');++ await request(app)+ .patch(`/api/prompts/${candidate._id}/tags/production`)+ .expect(500, { error: 'Error updating prompt production' });++ expect(promote).not.toHaveBeenCalled();+ const stored = await PromptGroup.findById(group._id).lean();+ expect(stored.productionId.toString()).toBe(revision._id.toString());+ });++ it('requires groupId for revision history, including READ_PROMPTS callers', async () => {+ const missingGroupId = { status: 400, body: { error: 'Invalid or missing groupId' } };+ expect(await responseOf(request(app).get('/api/prompts'))).toEqual(missingGroupId);++ setTestUser(app, testUsers.admin);+ expect(await responseOf(request(app).get('/api/prompts'))).toEqual(missingGroupId);+ });++ it('reuses the records that the access check loaded', async () => {+ const readGroup = jest.spyOn(PromptGroup, 'aggregate');+ await request(app).get(`/api/prompts/groups/${group._id}`).expect(200);+ expect(readGroup).toHaveBeenCalledTimes(1);++ const readRevision = jest.spyOn(Prompt, 'findOne');+ await request(app).get(`/api/prompts/${revision._id}`).expect(200);+ expect(readRevision).toHaveBeenCalledTimes(1);++ readRevision.mockClear();+ await request(app).patch(`/api/prompts/${revision._id}/tags/production`).expect(200);+ // The access check reads once; the mutation's own `findById` is the second call.+ expect(readRevision).toHaveBeenCalledTimes(2);+ });++ it('returns 500 for GET /groups without limit or pageSize', async () => {+ expect(await responseOf(request(app).get('/api/prompts/groups'))).toEqual({+ status: 500,+ body: { error: 'Error getting prompt groups' },+ });+ });++ it('returns the full catalog array from GET /all with the public flag', async () => {+ const response = await request(app).get('/api/prompts/all').expect(200);++ expect(response.body).toEqual([+ expect.objectContaining({+ _id: group._id.toString(),+ productionPrompt: { _id: revision._id.toString(), prompt: 'Compatibility prompt' },+ }),+ ]);+ expect(response.body[0].isPublic).toBeUndefined();+ });++ it('keeps the Usage responses', async () => {+ const recordUsage = () => request(app).post(`/api/prompts/groups/${group._id}/use`);+ expect(await responseOf(recordUsage())).toEqual({+ status: 200,+ body: { numberOfGenerations: 1 },+ });++ jest.spyOn(PromptGroup, 'findByIdAndUpdate').mockImplementationOnce(() => {+ throw new Error('database unavailable');+ });+ expect(await responseOf(recordUsage())).toEqual({+ status: 500,+ body: { error: 'Error recording prompt usage' },+ });+ });++ it('keeps the revision and group deletion responses', async () => {+ await request(app)+ .delete(`/api/prompts/${revision._id}`)+ .expect(400, { error: 'Invalid or missing groupId' });++ const response = await request(app)+ .delete(`/api/prompts/${revision._id}`)+ .query({ groupId: group._id.toString() })+ .expect(200);++ expect(response.body).toEqual({+ prompt: 'Prompt deleted successfully',+ promptGroup: { message: 'Prompt group deleted successfully', id: group._id.toString() },+ });+ await expect(PromptGroup.countDocuments({ _id: group._id })).resolves.toBe(0);+ });++ it('keeps the group deletion response', async () => {+ expect(await responseOf(request(app).delete(`/api/prompts/groups/${group._id}`))).toEqual({+ status: 200,+ body: { message: 'Prompt group deleted successfully' },+ });+ });+});diff --git a/packages/api/src/prompts/access.spec.ts b/packages/api/src/prompts/access.spec.tsnew file mode 100644index 0000000000..a5cb1b27d3--- /dev/null+++ b/packages/api/src/prompts/access.spec.ts@@ -0,0 +1,82 @@+import mongoose, { Types } from 'mongoose';+import { MongoMemoryServer } from 'mongodb-memory-server';+import { createModels, createMethods } from '@librechat/data-schemas';+import type { PromptDatabase, PromptRecord } from './types';+import { createPromptAccessResolvers } from './access';+import { createNativePromptAdapter } from './native';++let mongo: MongoMemoryServer;+let db: PromptDatabase;+let revision: PromptRecord;++beforeAll(async () => {+ mongo = await MongoMemoryServer.create({ instance: { args: ['--nounixsocket'] } });+ await mongoose.connect(mongo.getUri());+ createModels(mongoose);+ db = createMethods(mongoose);+});++beforeEach(async () => {+ const created = await createNativePromptAdapter(db).createPromptGroup({+ prompt: { prompt: 'Prompt', type: 'text' },+ group: { name: 'Access group' },+ author: new Types.ObjectId().toString(),+ authorName: 'Author',+ });+ revision = created.prompt as PromptRecord;+});++afterEach(async () => {+ jest.restoreAllMocks();+ await mongoose.models.Prompt.deleteMany({});+ await mongoose.models.PromptGroup.deleteMany({});+});++afterAll(async () => {+ await mongoose.disconnect();+ await mongo?.stop();+});++describe('createPromptAccessResolvers', () => {+ it('resolves a group and a revision with string IDs', async () => {+ const resolvers = createPromptAccessResolvers(db);++ await expect(resolvers.resolvePromptGroup(revision.groupId)).resolves.toMatchObject({+ _id: revision.groupId,+ productionId: revision._id,+ });+ await expect(resolvers.resolvePromptViaGroup(revision._id)).resolves.toEqual({+ _id: revision.groupId,+ prompt: expect.objectContaining({ _id: revision._id, groupId: revision.groupId }),+ });+ });++ it('returns null for a missing record', async () => {+ const resolvers = createPromptAccessResolvers(db);+ const missing = new Types.ObjectId().toString();++ await expect(resolvers.resolvePromptGroup(missing)).resolves.toBeNull();+ await expect(resolvers.resolvePromptViaGroup(missing)).resolves.toBeNull();+ });++ it('returns null for a malformed ID without a read', async () => {+ const resolvers = createPromptAccessResolvers(db);+ const readGroup = jest.spyOn(db, 'getPromptGroup');+ const readPrompt = jest.spyOn(db, 'getPrompt');++ await expect(resolvers.resolvePromptGroup('test-404')).resolves.toBeNull();+ await expect(resolvers.resolvePromptViaGroup('test-404')).resolves.toBeNull();+ expect(readGroup).not.toHaveBeenCalled();+ expect(readPrompt).not.toHaveBeenCalled();+ });++ it('propagates a read failure', async () => {+ const resolvers = createPromptAccessResolvers(db);+ const failure = new Error('database unavailable');+ jest.spyOn(db, 'getPromptGroup').mockRejectedValueOnce(failure);+ jest.spyOn(db, 'getPrompt').mockRejectedValueOnce(failure);++ await expect(resolvers.resolvePromptGroup(revision.groupId)).rejects.toBe(failure);+ await expect(resolvers.resolvePromptViaGroup(revision._id)).rejects.toBe(failure);+ });+});diff --git a/packages/api/src/prompts/access.ts b/packages/api/src/prompts/access.tsnew file mode 100644index 0000000000..fd33758943--- /dev/null+++ b/packages/api/src/prompts/access.ts@@ -0,0 +1,43 @@+import { isValidObjectIdString } from '@librechat/data-schemas';+import type { PromptDatabase, PromptGroupRecord, PromptRecord } from './types';+import { toPromptGroupRecord, toPromptRecord } from './records';++export interface PromptViaGroupResource {+ /** The parent group ID, which the access check uses for the ACL lookup. */+ readonly _id: string;+ readonly prompt: PromptRecord;+}++/**+ * Resolvers for the prompt access middleware. A malformed ID or a missing record returns+ * null, so the access check sends its resource 404. A read failure throws, so the access+ * check sends its 500. On success the record becomes `req.resourceAccess.resourceInfo`,+ * which the handlers reuse.+ */+export function createPromptAccessResolvers(+ db: Pick<PromptDatabase, 'getPromptGroup' | 'getPrompt'>,+): {+ resolvePromptGroup(groupId: string): Promise<PromptGroupRecord | null>;+ resolvePromptViaGroup(promptId: string): Promise<PromptViaGroupResource | null>;+} {+ return {+ async resolvePromptGroup(groupId) {+ if (!isValidObjectIdString(groupId)) {+ return null;+ }+ const group = await db.getPromptGroup({ _id: groupId });+ return group == null ? null : toPromptGroupRecord(group);+ },+ async resolvePromptViaGroup(promptId) {+ if (!isValidObjectIdString(promptId)) {+ return null;+ }+ const record = await db.getPrompt({ _id: promptId });+ if (record == null) {+ return null;+ }+ const prompt = toPromptRecord(record);+ return prompt.groupId ? { _id: prompt.groupId, prompt } : null;+ },+ };+}diff --git a/packages/api/src/prompts/errors.ts b/packages/api/src/prompts/errors.tsnew file mode 100644index 0000000000..c6e9e07289--- /dev/null+++ b/packages/api/src/prompts/errors.ts@@ -0,0 +1,33 @@+export type PromptStoreStage = 'read' | 'write';++/**+ * Wraps a prompt database failure with the operation stage where it occurred. The HTTP+ * boundary uses the stage to keep each route's existing response for that failure.+ */+export class PromptStoreError extends Error {+ readonly stage: PromptStoreStage;+ readonly cause: unknown;++ constructor(stage: PromptStoreStage, cause: unknown) {+ super(`Prompt ${stage} failed`);+ this.name = 'PromptStoreError';+ this.stage = stage;+ this.cause = cause;+ }+}++export function isPromptStoreError(error: unknown, stage: PromptStoreStage): boolean {+ return error instanceof PromptStoreError && error.stage === stage;+}++/** Runs a database call and tags its failure with the stage. */+export async function withPromptStage<T>(+ stage: PromptStoreStage,+ run: () => Promise<T>,+): Promise<T> {+ try {+ return await run();+ } catch (error) {+ throw new PromptStoreError(stage, error);+ }+}diff --git a/packages/api/src/prompts/format.ts b/packages/api/src/prompts/format.tsindex 63c50247e9..652d1833b7 100644--- a/packages/api/src/prompts/format.ts+++ b/packages/api/src/prompts/format.ts@@ -1,13 +1,11 @@-import { escapeRegExp } from '@librechat/data-schemas';import { SystemCategories } from 'librechat-data-provider';-import type { IPromptGroupDocument as IPromptGroup } from '@librechat/data-schemas';-import type { Types } from 'mongoose';import type { PromptGroupsListResponse } from '~/types';+import type { StoredId } from './types';/*** Formats prompt groups for the paginated /groups endpoint response*/-export function formatPromptGroupsResponse({+export function formatPromptGroupsResponse<T>({promptGroups = [],pageNumber,pageSize,@@ -15,13 +13,13 @@ export function formatPromptGroupsResponse({hasMore = false,after = null,}: {- promptGroups: IPromptGroup[];+ promptGroups: T[];pageNumber?: string;pageSize?: string;actualLimit?: string | number;hasMore?: boolean;after?: string | null;-}): PromptGroupsListResponse {+}): PromptGroupsListResponse<T> {const currentPage = parseInt(pageNumber || '1');// Calculate total pages based on whether there are more results@@ -39,74 +37,53 @@ export function formatPromptGroupsResponse({};}-/**- * Creates an empty response for the paginated /groups endpoint- */-export function createEmptyPromptGroupsResponse({- pageNumber,- pageSize,- actualLimit,-}: {- pageNumber?: string;- pageSize?: string;- actualLimit?: string | number;-}): PromptGroupsListResponse {- return {- promptGroups: [],- pageNumber: pageNumber || '1',- pageSize: pageSize || String(actualLimit) || '10',- pages: '0',- has_more: false,- after: null,- };-}-/*** Marks prompt groups as public based on the publicly accessible IDs*/-export function markPublicPromptGroups(- promptGroups: IPromptGroup[],- publiclyAccessibleIds: Types.ObjectId[],-): IPromptGroup[] {+export function markPublicPromptGroups<T extends { readonly _id?: StoredId }>(+ promptGroups: readonly T[],+ publiclyAccessibleIds: readonly StoredId[],+): T[] {if (!promptGroups.length) {return [];}- return promptGroups.map((group) => {- const isPublic = publiclyAccessibleIds.some((id) => id.equals(group._id?.toString()));- return isPublic ? ({ ...group, isPublic: true } as IPromptGroup) : group;- });+ const publicIds = new Set(publiclyAccessibleIds.map(String));+ return promptGroups.map((group) =>+ group._id != null && publicIds.has(String(group._id)) ? { ...group, isPublic: true } : group,+ );}/**- * Builds filter object for prompt group queries+ * Converts the listing name and category, including system categories, to plain+ * listing inputs and shared-search flags.*/export function buildPromptGroupFilter({ name, category }: { name?: string; category?: string }): {- filter: Record<string, string | number | boolean | RegExp | undefined>;+ name?: string;+ category?: string;searchShared: boolean;searchSharedOnly: boolean;} {- const filter: Record<string, string | number | boolean | RegExp | undefined> = {};let searchShared = true;let searchSharedOnly = false;+ let categoryFilter: string | undefined;- // Handle name filter - convert to regex for case-insensitive search- if (name) {- filter.name = new RegExp(escapeRegExp(name), 'i');- }-- // Handle category filters with special system categoriesif (category === SystemCategories.MY_PROMPTS) {searchShared = false;} else if (category === SystemCategories.NO_CATEGORY) {- filter.category = '';+ categoryFilter = '';} else if (category === SystemCategories.SHARED_PROMPTS) {searchSharedOnly = true;} else if (category) {- filter.category = category;+ categoryFilter = category;}- return { filter, searchShared, searchSharedOnly };+ return {+ name: name || undefined,+ category: categoryFilter,+ searchShared,+ searchSharedOnly,+ };}/**@@ -116,19 +93,19 @@ export function buildPromptGroupFilter({ name, category }: { name?: string; cate* Required for correct MY_PROMPTS and SHARED_PROMPTS filtering. When omitted the* function falls back to the legacy behaviour (public-only filtering).*/-export async function filterAccessibleIdsBySharedLogic({+export async function filterAccessibleIdsBySharedLogic<T extends StoredId>({accessibleIds,searchShared,searchSharedOnly,publicPromptGroupIds,ownedPromptGroupIds,}: {- accessibleIds: Types.ObjectId[];+ accessibleIds: readonly T[];searchShared: boolean;searchSharedOnly: boolean;- publicPromptGroupIds?: Types.ObjectId[];- ownedPromptGroupIds?: Types.ObjectId[];-}): Promise<Types.ObjectId[]> {+ publicPromptGroupIds?: readonly T[];+ ownedPromptGroupIds?: readonly T[];+}): Promise<T[]> {const ownedIdStrings = new Set((ownedPromptGroupIds || []).map((id) => id.toString()));if (!searchShared) {diff --git a/packages/api/src/prompts/handlers.ts b/packages/api/src/prompts/handlers.tsnew file mode 100644index 0000000000..ce55198d48--- /dev/null+++ b/packages/api/src/prompts/handlers.ts@@ -0,0 +1,372 @@+import { PermissionBits, ResourceType } from 'librechat-data-provider';+import { logger, isValidObjectIdString } from '@librechat/data-schemas';+import type { Response } from 'express';+import type { PromptGroupRecord, PromptServiceError, StoredId } from './types';+import type { PromptViaGroupResource } from './access';+import type { PromptService } from './service';+import type { ServerRequest } from '~/types';+import { contentFilterBlockResponse } from '~/middleware/contentFilter';+import { formatPromptGroupsResponse } from './format';+import { isPromptStoreError } from './errors';++/** A request after the prompt access middleware stored the resolved record. */+export type PromptRequest = ServerRequest & {+ resourceAccess?: { resourceInfo?: unknown };+};++type PromptHandler = (req: PromptRequest, res: Response) => Promise<Response | void>;++export interface PromptHandlersDeps {+ readonly service: PromptService;+ getPromptGroupAccessContext(params: { userId: string; role?: string }): Promise<{+ accessibleIds: readonly StoredId[];+ publiclyAccessibleIds: readonly StoredId[];+ ownedPromptGroupIds: readonly StoredId[];+ }>;+ getEffectivePermissions(params: {+ userId: string;+ role?: string;+ resourceType: ResourceType;+ resourceId: string;+ }): Promise<number>;+}++export interface PromptHandlers {+ getPromptGroup: PromptHandler;+ listAllPromptGroups: PromptHandler;+ listPromptGroups: PromptHandler;+ createPromptGroup: PromptHandler;+ savePrompt: PromptHandler;+ recordPromptUsage: PromptHandler;+ updatePromptGroup: PromptHandler;+ makePromptProduction: PromptHandler;+ getPrompt: PromptHandler;+ getPrompts: PromptHandler;+ deletePrompt: PromptHandler;+ deletePromptGroup: PromptHandler;+}++function param(req: PromptRequest, name: string): string {+ return (req.params as Record<string, string>)[name];+}++function query(req: PromptRequest, name: string): string | undefined {+ const value = (req.query as Record<string, unknown>)[name];+ return typeof value === 'string' ? value : undefined;+}++function body(req: PromptRequest): Record<string, unknown> {+ return (req.body ?? {}) as Record<string, unknown>;+}++function loadedGroup(req: PromptRequest): PromptGroupRecord | undefined {+ return req.resourceAccess?.resourceInfo as PromptGroupRecord | undefined;+}++function loadedRevision(req: PromptRequest) {+ return (req.resourceAccess?.resourceInfo as PromptViaGroupResource | undefined)?.prompt;+}++function sendRejection(res: Response, error: PromptServiceError): Response {+ if (error.type === 'blocked_content') {+ return res.status(400).json(contentFilterBlockResponse(error.finding));+ }+ if (error.type === 'invalid_input') {+ return res+ .status(400)+ .send(+ error.details === undefined+ ? { error: error.message }+ : { error: error.message, details: error.details },+ );+ }+ return res.status(400).send({ error: 'Prompt operation is not available' });+}++async function loadAccessContext(deps: PromptHandlersDeps, req: PromptRequest) {+ const context = await deps.getPromptGroupAccessContext({+ userId: req.user?.id ?? '',+ role: req.user?.role,+ });+ return {+ accessibleIds: context.accessibleIds.map(String),+ publiclyAccessibleIds: context.publiclyAccessibleIds.map(String),+ ownedPromptGroupIds: context.ownedPromptGroupIds.map(String),+ };+}++/**+ * HTTP handlers for the prompt routes. The router enforces authentication, role gates+ * and resource access before each handler. The handlers keep the existing status and+ * body for each failure, including the legacy 200 message bodies.+ */+export function createPromptHandlers(deps: PromptHandlersDeps): PromptHandlers {+ const { service } = deps;++ return {+ async getPromptGroup(req, res) {+ const groupId = param(req, 'groupId');+ try {+ const result = await service.getPromptGroup({+ groupId,+ loadedGroup: loadedGroup(req),+ filters: req.config?.filters,+ });+ if (result == null) {+ return res.status(404).send({ message: 'Prompt group not found' });+ }+ if (!result.ok) {+ return sendRejection(res, result.error);+ }+ return res.status(200).send(result.value);+ } catch (error) {+ logger.error('Error getting prompt group', error);+ if (isPromptStoreError(error, 'read')) {+ return res.status(404).send({ message: 'Prompt group not found' });+ }+ return res.status(500).send({ message: 'Error getting prompt group' });+ }+ },++ async listAllPromptGroups(req, res) {+ try {+ const result = await service.getListPromptGroupsByAccess({+ ...(await loadAccessContext(deps, req)),+ name: query(req, 'name'),+ category: query(req, 'category'),+ limit: null,+ after: null,+ forReuse: true,+ filters: req.config?.filters,+ });+ return res.status(200).send(result.data);+ } catch (error) {+ logger.error(error);+ return res.status(500).send({ error: 'Error getting prompt groups' });+ }+ },++ async listPromptGroups(req, res) {+ try {+ const pageSize = query(req, 'pageSize');+ const limit = query(req, 'limit');+ const actualLimit = pageSize && !limit ? parseInt(pageSize, 10) : limit;+ if (actualLimit == null) {+ logger.error('[GET /prompts/groups] limit or pageSize is required');+ return res.status(500).send({ error: 'Error getting prompt groups' });+ }+ let cursor = query(req, 'cursor') ?? null;+ if (cursor === 'undefined' || cursor === 'null' || cursor === '') {+ cursor = null;+ }++ const result = await service.getListPromptGroupsByAccess({+ ...(await loadAccessContext(deps, req)),+ name: query(req, 'name'),+ category: query(req, 'category'),+ limit: actualLimit,+ after: cursor,+ forReuse: false,+ filters: req.config?.filters,+ });+ return res.status(200).send(+ formatPromptGroupsResponse({+ promptGroups: [...result.data],+ pageNumber: '1',+ pageSize: actualLimit.toString(),+ hasMore: result.has_more,+ after: result.after,+ }),+ );+ } catch (error) {+ logger.error(error);+ return res.status(500).send({ error: 'Error getting prompt groups' });+ }+ },++ async createPromptGroup(req, res) {+ try {+ const { prompt, group } = body(req) as Pick<+ Parameters<PromptService['createPromptGroup']>[0],+ 'prompt' | 'group'+ >;+ const result = await service.createPromptGroup({+ prompt,+ group,+ author: req.user?.id ?? '',+ authorName: req.user?.name,+ filters: req.config?.filters,+ });+ if (!result.ok) {+ return sendRejection(res, result.error);+ }+ return res.status(200).send(result.value);+ } catch (error) {+ logger.error(error);+ return res.status(500).send({ error: 'Error creating prompt group' });+ }+ },++ async savePrompt(req, res) {+ try {+ const result = await service.savePrompt({+ groupId: param(req, 'groupId'),+ prompt: body(req).prompt,+ author: req.user?.id ?? '',+ filters: req.config?.filters,+ });+ if (!result.ok) {+ return sendRejection(res, result.error);+ }+ return res.status(200).send(result.value);+ } catch (error) {+ logger.error(error);+ if (isPromptStoreError(error, 'write')) {+ return res.status(200).send({ message: 'Error saving prompt' });+ }+ return res.status(500).send({ error: 'Error adding prompt to group' });+ }+ },++ async recordPromptUsage(req, res) {+ try {+ const groupId = param(req, 'groupId');+ if (!isValidObjectIdString(groupId)) {+ return res.status(400).send({ error: 'Invalid groupId' });+ }+ return res.status(200).send(await service.incrementPromptGroupUsage(groupId));+ } catch (error) {+ logger.error('[recordPromptUsage]', error);+ const message = error instanceof Error ? error.message : undefined;+ if (message === 'Invalid groupId') {+ return res.status(400).send({ error: 'Invalid groupId' });+ }+ if (message === 'Prompt group not found') {+ return res.status(404).send({ error: 'Prompt group not found' });+ }+ return res.status(500).send({ error: 'Error recording prompt usage' });+ }+ },++ async updatePromptGroup(req, res) {+ try {+ const result = await service.updatePromptGroup({+ groupId: param(req, 'groupId'),+ updates: req.body,+ filters: req.config?.filters,+ });+ if (!result.ok) {+ return sendRejection(res, result.error);+ }+ return res.status(200).send(result.value);+ } catch (error) {+ logger.error(error);+ if (isPromptStoreError(error, 'write')) {+ return res.status(200).send({ message: 'Error updating prompt group' });+ }+ return res.status(500).send({ error: 'Error updating prompt group' });+ }+ },++ async makePromptProduction(req, res) {+ try {+ const result = await service.makePromptProduction({+ promptId: param(req, 'promptId'),+ loadedRevision: loadedRevision(req),+ filters: req.config?.filters,+ });+ if (!result.ok) {+ return sendRejection(res, result.error);+ }+ return res.status(200).send(result.value);+ } catch (error) {+ logger.error(error);+ if (isPromptStoreError(error, 'write')) {+ return res.status(200).send({ message: 'Error making prompt production' });+ }+ return res.status(500).send({ error: 'Error updating prompt production' });+ }+ },++ async getPrompt(req, res) {+ try {+ const result = await service.getPrompt({+ promptId: param(req, 'promptId'),+ loadedRevision: loadedRevision(req),+ filters: req.config?.filters,+ });+ if (result == null) {+ return res.status(200).send(null);+ }+ if (!result.ok) {+ return sendRejection(res, result.error);+ }+ return res.status(200).send(result.value);+ } catch (error) {+ logger.error('Error getting prompt', error);+ if (isPromptStoreError(error, 'read')) {+ return res.status(200).send({ message: 'Error getting prompt' });+ }+ return res.status(500).send({ message: 'Error getting prompt' });+ }+ },++ async getPrompts(req, res) {+ try {+ const groupId = query(req, 'groupId');+ if (!groupId) {+ return res.status(400).send({ error: 'Invalid or missing groupId' });+ }+ if (!isValidObjectIdString(groupId)) {+ return res.status(400).send({ error: 'Invalid groupId' });+ }+ const permissions = await deps.getEffectivePermissions({+ userId: req.user?.id ?? '',+ role: req.user?.role,+ resourceType: ResourceType.PROMPTGROUP,+ resourceId: groupId,+ });+ if (!(permissions & PermissionBits.VIEW)) {+ return res+ .status(403)+ .send({ error: 'Insufficient permissions to view prompts in this group' });+ }+ return res+ .status(200)+ .send(await service.getPrompts({ groupId, filters: req.config?.filters }));+ } catch (error) {+ logger.error(error);+ if (isPromptStoreError(error, 'read')) {+ return res.status(200).send({ message: 'Error getting prompts' });+ }+ return res.status(500).send({ error: 'Error getting prompts' });+ }+ },++ async deletePrompt(req, res) {+ try {+ const groupId = query(req, 'groupId');+ if (!groupId || !isValidObjectIdString(groupId)) {+ return res.status(400).send({ error: 'Invalid or missing groupId' });+ }+ const result = await service.deletePrompt({ groupId, promptId: param(req, 'promptId') });+ if (!result.ok) {+ return sendRejection(res, result.error);+ }+ return res.status(200).send(result.value);+ } catch (error) {+ logger.error(error);+ return res.status(500).send({ error: 'Error deleting prompt' });+ }+ },++ async deletePromptGroup(req, res) {+ try {+ return res.send(await service.deletePromptGroup(param(req, 'groupId')));+ } catch (error) {+ logger.error('Error deleting prompt group', error);+ return res.status(500).send({ message: 'Error deleting prompt group' });+ }+ },+ };+}diff --git a/packages/api/src/prompts/index.ts b/packages/api/src/prompts/index.tsindex 2da8a71781..c0215fdd61 100644--- a/packages/api/src/prompts/index.ts+++ b/packages/api/src/prompts/index.ts@@ -1,5 +1,13 @@+export * from './access';export * from './artifacts';+export * from './errors';export * from './format';+export * from './handlers';export * from './migration';+export * from './native';export * from './protection';+export * from './records';export * from './schemas';+export { createPromptService } from './service';+export type { PromptService, PromptServiceDependencies, PromptServiceListResult } from './service';+export * from './types';diff --git a/packages/api/src/prompts/native.spec.ts b/packages/api/src/prompts/native.spec.tsnew file mode 100644index 0000000000..c7e91e7921--- /dev/null+++ b/packages/api/src/prompts/native.spec.ts@@ -0,0 +1,239 @@+import mongoose, { Types } from 'mongoose';+import { MongoMemoryServer } from 'mongodb-memory-server';+import { createModels, createMethods } from '@librechat/data-schemas';+import type { PromptDatabase, PromptGroupRecord, PromptRecord } from './types';+import { createNativePromptAdapter } from './native';++let mongo: MongoMemoryServer;+let db: PromptDatabase;+let group: PromptGroupRecord;+let production: PromptRecord;+let draft: PromptRecord;+const author = new Types.ObjectId().toString();++beforeAll(async () => {+ mongo = await MongoMemoryServer.create({ instance: { args: ['--nounixsocket'] } });+ await mongoose.connect(mongo.getUri());+ createModels(mongoose);+ db = createMethods(mongoose);+});++beforeEach(async () => {+ const adapter = createNativePromptAdapter(db);+ const created = await adapter.createPromptGroup({+ prompt: { prompt: 'Production prompt', type: 'text' },+ group: { name: 'Native group' },+ author,+ authorName: 'Author',+ });+ production = created.prompt as PromptRecord;+ ({ prompt: draft } = (await adapter.savePrompt?.({+ groupId: production.groupId,+ prompt: { prompt: 'Draft prompt', type: 'chat' },+ author,+ })) as { prompt: PromptRecord });+ group = (await adapter.getPromptGroup(production.groupId)) as PromptGroupRecord;+});++afterEach(async () => {+ jest.restoreAllMocks();+ await mongoose.models.Prompt.deleteMany({});+ await mongoose.models.PromptGroup.deleteMany({});+});++afterAll(async () => {+ await mongoose.disconnect();+ await mongo?.stop();+});++describe('createNativePromptAdapter', () => {+ it('returns records with string IDs', () => {+ expect(group).toEqual(+ expect.objectContaining({+ _id: production.groupId,+ author,+ productionId: production._id,+ productionPrompt: expect.objectContaining({+ _id: production._id,+ groupId: production.groupId,+ }),+ }),+ );+ expect(typeof draft._id).toBe('string');+ expect(draft).toEqual(expect.objectContaining({ groupId: group._id, author, type: 'chat' }));+ });++ it('resolves Production from a loaded group without another read', async () => {+ const adapter = createNativePromptAdapter(db);+ const readGroup = jest.spyOn(db, 'getPromptGroup');+ const readPrompt = jest.spyOn(db, 'getPrompt');++ await expect(+ adapter.resolvePrompt({+ groupId: group._id,+ selection: { type: 'production' },+ loadedGroup: group,+ }),+ ).resolves.toEqual({+ groupId: group._id,+ promptId: production._id,+ prompt: 'Production prompt',+ type: 'text',+ });+ expect(readGroup).not.toHaveBeenCalled();+ expect(readPrompt).not.toHaveBeenCalled();+ });++ it('reads the group once to resolve Production when no group is loaded', async () => {+ const adapter = createNativePromptAdapter(db);+ const readGroup = jest.spyOn(db, 'getPromptGroup');+ const readPrompt = jest.spyOn(db, 'getPrompt');++ await expect(+ adapter.resolvePrompt({ groupId: group._id, selection: { type: 'production' } }),+ ).resolves.toMatchObject({ promptId: production._id });+ expect(readGroup).toHaveBeenCalledTimes(1);+ expect(readPrompt).not.toHaveBeenCalled();+ });++ it('reads the group when the loaded group is a different group', async () => {+ const adapter = createNativePromptAdapter(db);+ const readGroup = jest.spyOn(db, 'getPromptGroup');++ await expect(+ adapter.resolvePrompt({+ groupId: group._id,+ selection: { type: 'production' },+ loadedGroup: { ...group, _id: new Types.ObjectId().toString() },+ }),+ ).resolves.toMatchObject({ promptId: production._id });+ expect(readGroup).toHaveBeenCalledTimes(1);+ });++ it('resolves an exact revision from a loaded revision without another read', async () => {+ const adapter = createNativePromptAdapter(db);+ const readPrompt = jest.spyOn(db, 'getPrompt');++ await expect(+ adapter.resolvePrompt({+ groupId: group._id,+ selection: { type: 'exact', promptId: draft._id },+ loadedRevision: draft,+ }),+ ).resolves.toEqual({+ groupId: group._id,+ promptId: draft._id,+ prompt: 'Draft prompt',+ type: 'chat',+ });+ expect(readPrompt).not.toHaveBeenCalled();+ });++ it('reads an exact revision when the loaded revision is a different revision', async () => {+ const adapter = createNativePromptAdapter(db);+ const readPrompt = jest.spyOn(db, 'getPrompt');++ await expect(+ adapter.resolvePrompt({+ groupId: group._id,+ selection: { type: 'exact', promptId: draft._id },+ loadedRevision: production,+ }),+ ).resolves.toMatchObject({ promptId: draft._id });+ expect(readPrompt).toHaveBeenCalledTimes(1);+ });++ it('does not resolve a revision of another group or a missing selection', async () => {+ const adapter = createNativePromptAdapter(db);+ const otherGroupId = new Types.ObjectId().toString();++ await expect(+ adapter.resolvePrompt({+ groupId: otherGroupId,+ selection: { type: 'exact', promptId: draft._id },+ }),+ ).resolves.toBeNull();+ await expect(+ adapter.resolvePrompt({ groupId: otherGroupId, selection: { type: 'production' } }),+ ).resolves.toBeNull();+ await expect(+ adapter.resolvePrompt({+ groupId: group._id,+ selection: { type: 'exact', promptId: new Types.ObjectId().toString() },+ }),+ ).resolves.toBeNull();+ });++ it('resolves a stored revision without a type as text', async () => {+ const adapter = createNativePromptAdapter(db);+ await mongoose.models.Prompt.collection.updateMany(+ { groupId: new Types.ObjectId(group._id) },+ { $unset: { type: '' } },+ );+ const loaded = (await adapter.getPromptGroup(group._id)) as PromptGroupRecord;++ await expect(+ adapter.resolvePrompt({ groupId: group._id, selection: { type: 'production' } }),+ ).resolves.toMatchObject({ promptId: production._id, type: 'text' });+ await expect(+ adapter.resolvePrompt({+ groupId: group._id,+ selection: { type: 'production' },+ loadedGroup: loaded,+ }),+ ).resolves.toMatchObject({ promptId: production._id, type: 'text' });+ await expect(+ adapter.resolvePrompt({+ groupId: group._id,+ selection: { type: 'exact', promptId: draft._id },+ }),+ ).resolves.toMatchObject({ promptId: draft._id, type: 'text' });+ });++ it('returns null for absent records', async () => {+ const adapter = createNativePromptAdapter(db);+ const missing = new Types.ObjectId().toString();++ await expect(adapter.getPromptGroup(missing)).resolves.toBeNull();+ await expect(adapter.getPrompt(missing)).resolves.toBeNull();+ });++ it('returns the group revisions newest first', async () => {+ const adapter = createNativePromptAdapter(db);+ await mongoose.models.Prompt.collection.updateOne(+ { _id: new Types.ObjectId(draft._id) },+ { $set: { createdAt: new Date(Date.now() + 1000) } },+ );++ const revisions = await adapter.getPrompts(group._id);++ expect(revisions.map((revision) => revision._id)).toEqual([draft._id, production._id]);+ });++ it('promotes a revision and throws for a missing revision', async () => {+ const adapter = createNativePromptAdapter(db);++ await adapter.makePromptProduction?.(draft._id);++ await expect(adapter.getPromptGroup(group._id)).resolves.toMatchObject({+ productionId: draft._id,+ });+ await expect(adapter.makePromptProduction?.(new Types.ObjectId().toString())).rejects.toThrow(+ 'Prompt not found',+ );+ });++ it('returns a string group ID when deleting the last revision deletes the group', async () => {+ const adapter = createNativePromptAdapter(db);++ await expect(+ adapter.deletePrompt?.({ groupId: group._id, promptId: draft._id }),+ ).resolves.toEqual({ prompt: 'Prompt deleted successfully' });+ await expect(+ adapter.deletePrompt?.({ groupId: group._id, promptId: production._id }),+ ).resolves.toEqual({+ prompt: 'Prompt deleted successfully',+ promptGroup: { message: 'Prompt group deleted successfully', id: group._id },+ });+ });+});diff --git a/packages/api/src/prompts/native.ts b/packages/api/src/prompts/native.tsnew file mode 100644index 0000000000..12a36ab54e--- /dev/null+++ b/packages/api/src/prompts/native.ts@@ -0,0 +1,151 @@+import type {+ PromptRecord,+ StoredId,+ PromptDatabase,+ ResolvedPrompt,+ PromptProjection,+ PromptSelection,+ PromptGroupRecord,+ PromptCatalogStore,+ PromptSourceAdapter,+} from './types';+import { toPromptGroupRecord, toPromptRecord } from './records';++type ResolvablePrompt = Pick<PromptRecord, '_id' | 'groupId' | 'prompt' | 'type'>;++function isMatchingRevision(+ revision: PromptRecord | PromptProjection | null | undefined,+ groupId: string,+ promptId?: string,+): revision is ResolvablePrompt {+ return (+ revision != null &&+ revision._id != null &&+ revision.groupId === groupId &&+ (promptId == null || revision._id === promptId)+ );+}++/** A revision stored without a type is a text prompt, the same default the client uses. */+function resolveValue(revision: ResolvablePrompt): ResolvedPrompt {+ return {+ groupId: revision.groupId,+ promptId: revision._id,+ prompt: revision.prompt,+ type: revision.type ?? 'text',+ };+}++async function getPrompt(db: PromptDatabase, promptId: string): Promise<PromptRecord | null> {+ const record = await db.getPrompt({ _id: promptId });+ return record == null ? null : toPromptRecord(record);+}++async function getPromptGroup(+ db: PromptDatabase,+ groupId: string,+): Promise<PromptGroupRecord | null> {+ const record = await db.getPromptGroup({ _id: groupId });+ return record == null ? null : toPromptGroupRecord(record);+}++async function resolveExact(+ db: PromptDatabase,+ groupId: string,+ promptId: string,+ loadedRevision?: PromptRecord | null,+): Promise<ResolvedPrompt | null> {+ let revision = loadedRevision;+ if (!isMatchingRevision(revision, groupId, promptId)) {+ revision = await getPrompt(db, promptId);+ }+ return isMatchingRevision(revision, groupId, promptId) ? resolveValue(revision) : null;+}++async function resolveProduction(+ db: PromptDatabase,+ groupId: string,+ loadedGroup?: PromptGroupRecord | null,+): Promise<ResolvedPrompt | null> {+ let group = loadedGroup;+ if (group?._id !== groupId) {+ group = await getPromptGroup(db, groupId);+ }+ if (group == null || group.productionId == null) {+ return null;+ }+ if (isMatchingRevision(group.productionPrompt, groupId, group.productionId)) {+ return resolveValue(group.productionPrompt);+ }+ const revision = await getPrompt(db, group.productionId);+ return isMatchingRevision(revision, groupId, group.productionId) ? resolveValue(revision) : null;+}++function toIdString(id: StoredId): string {+ return typeof id === 'string' ? id : id.toString();+}++/** Native prompts stored in the LibreChat database. */+export function createNativePromptAdapter(db: PromptDatabase): PromptSourceAdapter {+ return {+ resolvePrompt: ({ groupId, selection, loadedGroup, loadedRevision }) => {+ if (selection.type === 'exact') {+ return resolveExact(db, groupId, selection.promptId, loadedRevision);+ }+ return resolveProduction(db, groupId, loadedGroup);+ },+ getPromptGroup: (groupId) => getPromptGroup(db, groupId),+ getPrompt: (promptId) => getPrompt(db, promptId),+ getPrompts: async (groupId) => (await db.getPrompts({ groupId })).map(toPromptRecord),+ createPromptGroup: async ({ prompt, group = {}, author, authorName }) => {+ const result = await db.createPromptGroup({ prompt, group, author, authorName });+ return {+ prompt: result.prompt == null ? null : toPromptRecord(result.prompt),+ group: toPromptGroupRecord(result.group),+ };+ },+ savePrompt: async ({ groupId, prompt, author }) => {+ const result = await db.savePrompt({ prompt: { ...prompt, groupId }, author });+ return { prompt: toPromptRecord(result.prompt) };+ },+ makePromptProduction: (promptId) => db.makePromptProduction(promptId),+ deletePrompt: async ({ groupId, promptId }) => {+ const result = await db.deletePrompt({ groupId, promptId });+ if (result.promptGroup == null) {+ return { prompt: result.prompt };+ }+ return {+ prompt: result.prompt,+ promptGroup: { message: result.promptGroup.message, id: toIdString(result.promptGroup.id) },+ };+ },+ };+}++/** Local catalog operations over the LibreChat prompt group collection. */+export function createPromptCatalogStore(db: PromptDatabase): PromptCatalogStore {+ return {+ getListPromptGroupsByAccess: async ({ accessibleIds, name, category, limit, after }) => {+ const result = await db.getListPromptGroupsByAccess({+ accessibleIds: [...accessibleIds],+ name,+ category,+ limit,+ after,+ });+ return {+ data: result.data.map(toPromptGroupRecord),+ has_more: result.has_more,+ after: result.after,+ };+ },+ updatePromptGroup: async (groupId, updates) =>+ toPromptGroupRecord(await db.updatePromptGroup({ _id: groupId }, updates)),+ incrementPromptGroupUsage: (groupId) => db.incrementPromptGroupUsage(groupId),+ deletePromptGroup: (groupId) => db.deletePromptGroup({ _id: groupId }),+ };+}++export function selectionUnavailableReason(selection: PromptSelection): 'production' | 'revision' {+ return selection.type === 'production' ? 'production' : 'revision';+}diff --git a/packages/api/src/prompts/records.ts b/packages/api/src/prompts/records.tsnew file mode 100644index 0000000000..71f4ddbba7--- /dev/null+++ b/packages/api/src/prompts/records.ts@@ -0,0 +1,32 @@+import type { PromptGroupRecord, PromptRecord } from './types';++const ID_FIELDS = ['_id', 'groupId', 'author', 'productionId'] as const;++function withStringIds(record: object): Record<string, unknown> {+ const plain: Record<string, unknown> = { ...record };+ for (const field of ID_FIELDS) {+ const value = plain[field];+ if (value != null && typeof value !== 'string') {+ plain[field] = String(value);+ }+ }+ return plain;+}++/**+ * Converts a stored revision to plain data with string IDs. Other fields, such as dates,+ * `__v` and `tenantId`, stay as stored, so the JSON response does not change.+ */+export function toPromptRecord(record: object): PromptRecord {+ return withStringIds(record) as unknown as PromptRecord;+}++/** Converts a stored group, and its Production revision when present, to string IDs. */+export function toPromptGroupRecord(record: object): PromptGroupRecord {+ const plain = withStringIds(record);+ const production = plain.productionPrompt;+ if (production != null && typeof production === 'object') {+ plain.productionPrompt = withStringIds(production);+ }+ return plain as unknown as PromptGroupRecord;+}diff --git a/packages/api/src/prompts/schemas.spec.ts b/packages/api/src/prompts/schemas.spec.tsindex 2ba34e17f2..f4de5af111 100644--- a/packages/api/src/prompts/schemas.spec.ts+++ b/packages/api/src/prompts/schemas.spec.ts@@ -1,9 +1,37 @@import {updatePromptGroupSchema,validatePromptGroupUpdate,+ safeValidatePromptPayload,safeValidatePromptGroupUpdate,} from './schemas';+describe('safeValidatePromptPayload', () => {+ it('keeps the prompt fields and removes other fields', () => {+ const result = safeValidatePromptPayload({+ prompt: 'Text',+ type: 'chat',+ groupId: 'group-1',+ author: 'user-1',+ });++ expect(result.success && result.data).toEqual({ prompt: 'Text', type: 'chat' });+ });++ it.each([+ [null, 'Prompt text is required and must be a non-empty string'],+ [{ type: 'text' }, 'Prompt text is required and must be a non-empty string'],+ [{ prompt: 42, type: 'text' }, 'Prompt text is required and must be a non-empty string'],+ [{ prompt: ' ', type: 'text' }, 'Prompt text is required and must be a non-empty string'],+ [{ prompt: 'Text' }, 'Prompt type must be "text" or "chat"'],+ [{ prompt: 'Text', type: 'image' }, 'Prompt type must be "text" or "chat"'],+ ])('rejects %j with the route message', (payload, message) => {+ const result = safeValidatePromptPayload(payload);++ expect(result.success).toBe(false);+ expect(result.success ? undefined : result.error.issues[0]?.message).toBe(message);+ });+});+describe('updatePromptGroupSchema', () => {describe('allowed fields', () => {it('should accept valid name field', () => {diff --git a/packages/api/src/prompts/schemas.ts b/packages/api/src/prompts/schemas.tsindex c9df44bfe7..508a4d2dd3 100644--- a/packages/api/src/prompts/schemas.ts+++ b/packages/api/src/prompts/schemas.ts@@ -1,6 +1,31 @@import { z } from 'zod';import { Constants } from 'librechat-data-provider';+export type TPromptPayloadSchema = {+ prompt: string;+ type: 'text' | 'chat';+};++const PROMPT_TEXT_MESSAGE = 'Prompt text is required and must be a non-empty string';+const PROMPT_TYPE_MESSAGE = 'Prompt type must be "text" or "chat"';++/** Validates a new revision. Unknown keys, such as the editor's `groupId`, are removed. */+const promptPayloadSchema: z.ZodType<TPromptPayloadSchema> = z.object(+ {+ prompt: z+ .string({ required_error: PROMPT_TEXT_MESSAGE, invalid_type_error: PROMPT_TEXT_MESSAGE })+ .refine((value) => value.trim().length > 0, { message: PROMPT_TEXT_MESSAGE }),+ type: z.enum(['text', 'chat'], { errorMap: () => ({ message: PROMPT_TYPE_MESSAGE }) }),+ },+ { invalid_type_error: PROMPT_TEXT_MESSAGE },+);++export function safeValidatePromptPayload(+ data: unknown,+): z.SafeParseReturnType<unknown, TPromptPayloadSchema> {+ return promptPayloadSchema.safeParse(data);+}+/*** Schema for validating prompt group update payloads.* Only allows fields that users should be able to modify.diff --git a/packages/api/src/prompts/service.spec.ts b/packages/api/src/prompts/service.spec.tsnew file mode 100644index 0000000000..47157d13e0--- /dev/null+++ b/packages/api/src/prompts/service.spec.ts@@ -0,0 +1,550 @@+import mongoose, { Types } from 'mongoose';+import { MongoMemoryServer } from 'mongodb-memory-server';+import { logger, createModels, createMethods } from '@librechat/data-schemas';+import { AccessRoleIds, PrincipalType, ResourceType } from 'librechat-data-provider';+import type { FiltersConfig } from 'librechat-data-provider';+import type {+ PromptRecord,+ PromptDatabase,+ PromptGroupRecord,+ CreatePromptGroupInput,+} from './types';+import type { PromptServiceDependencies, PromptService } from './service';+import { createPromptServiceFromAdapters, createPromptService } from './service';+import { createPromptCatalogStore, createNativePromptAdapter } from './native';+import { PromptStoreError } from './errors';++const filters: FiltersConfig = {+ prompts: {+ pii: {+ starterPatterns: [],+ customPatterns: [{ id: 'private', label: 'private value', regex: 'PRIVATE-[A-Z]+' }],+ },+ },+};++let mongo: MongoMemoryServer;+let db: PromptDatabase;+let grantPermission: jest.MockedFunction<PromptServiceDependencies['grantPermission']>;+let service: PromptService;+let group: PromptGroupRecord;+let production: PromptRecord;+const author = new Types.ObjectId().toString();+const missingId = () => new Types.ObjectId().toString();++beforeAll(async () => {+ mongo = await MongoMemoryServer.create({ instance: { args: ['--nounixsocket'] } });+ await mongoose.connect(mongo.getUri());+ createModels(mongoose);+ db = createMethods(mongoose);+});++beforeEach(async () => {+ grantPermission = jest.fn().mockResolvedValue(undefined);+ service = createPromptService({ db, grantPermission });+ const created = await service.createPromptGroup({+ prompt: { prompt: 'Production prompt', type: 'text' },+ group: { name: 'Service group' },+ author,+ authorName: 'Author',+ });+ if (!created.ok || created.value.prompt == null) {+ throw new Error('Test group was not created');+ }+ production = created.value.prompt;+ group = (await createNativePromptAdapter(db).getPromptGroup(+ production.groupId,+ )) as PromptGroupRecord;+ grantPermission.mockClear();+});++afterEach(async () => {+ jest.restoreAllMocks();+ await mongoose.models.Prompt.deleteMany({});+ await mongoose.models.PromptGroup.deleteMany({});+});++afterAll(async () => {+ await mongoose.disconnect();+ await mongo?.stop();+});++async function addRevision(prompt: string): Promise<PromptRecord> {+ const result = await service.savePrompt({+ groupId: group._id,+ prompt: { prompt, type: 'text' },+ author,+ });+ if (!result.ok) {+ throw new Error('Test revision was not saved');+ }+ return result.value.prompt;+}++describe('createPromptService', () => {+ describe('resolvePrompt', () => {+ it('returns the Production revision', async () => {+ await expect(+ service.resolvePrompt({ groupId: group._id, selection: { type: 'production' }, filters }),+ ).resolves.toEqual({+ ok: true,+ value: {+ groupId: group._id,+ promptId: production._id,+ prompt: 'Production prompt',+ type: 'text',+ },+ });+ });++ it('rejects blocked selected content', async () => {+ const blocked = await addRevision('Contains PRIVATE-VALUE');++ await expect(+ service.resolvePrompt({+ groupId: group._id,+ selection: { type: 'exact', promptId: blocked._id },+ filters,+ }),+ ).resolves.toMatchObject({ ok: false, error: { type: 'blocked_content' } });+ });++ it('returns an unavailable result for a missing selection', async () => {+ await expect(+ service.resolvePrompt({+ groupId: group._id,+ selection: { type: 'exact', promptId: missingId() },+ }),+ ).resolves.toEqual({+ ok: false,+ error: { type: 'unavailable_selection', reason: 'revision' },+ });+ await expect(+ service.resolvePrompt({ groupId: missingId(), selection: { type: 'production' } }),+ ).resolves.toEqual({+ ok: false,+ error: { type: 'unavailable_selection', reason: 'production' },+ });+ });+ });++ describe('getListPromptGroupsByAccess', () => {+ it('projects catalog content and marks public groups', async () => {+ const stored = await service.createPromptGroup({+ prompt: { prompt: 'PRIVATE-PROMPT', type: 'text' },+ group: { name: 'Stored before the filter' },+ author,+ });+ const blockedId = stored.ok ? stored.value.prompt?.groupId : undefined;+ expect(blockedId).toEqual(expect.any(String));++ const result = await service.getListPromptGroupsByAccess({+ accessibleIds: [group._id, blockedId as string],+ publiclyAccessibleIds: [group._id],+ ownedPromptGroupIds: [group._id],+ limit: 10,+ after: null,+ forReuse: true,+ filters,+ });++ expect(result).toEqual({+ data: [expect.objectContaining({ _id: group._id, isPublic: true })],+ has_more: false,+ after: null,+ });+ });++ it('filters by name without regular expression input', async () => {+ const input = {+ accessibleIds: [group._id],+ publiclyAccessibleIds: [],+ ownedPromptGroupIds: [group._id],+ limit: null,+ after: null,+ forReuse: false,+ };++ await expect(+ service.getListPromptGroupsByAccess({ ...input, name: 'service' }),+ ).resolves.toMatchObject({ data: [{ _id: group._id }] });+ await expect(+ service.getListPromptGroupsByAccess({ ...input, name: '.*' }),+ ).resolves.toMatchObject({ data: [] });+ });+ });++ describe('getPrompts', () => {+ it('redacts blocked revision history and keeps structural fields', async () => {+ const blocked = await addRevision('Contains PRIVATE-VALUE');++ const history = await service.getPrompts({ groupId: group._id, filters });++ expect(history).toHaveLength(2);+ expect(history).toEqual(+ expect.arrayContaining([+ expect.objectContaining({ _id: blocked._id, prompt: '', contentFilterBlocked: true }),+ expect.objectContaining({ _id: production._id, prompt: 'Production prompt' }),+ ]),+ );+ });++ it('tags a read failure with the read stage', async () => {+ jest.spyOn(db, 'getPrompts').mockRejectedValueOnce(new Error('database unavailable'));++ await expect(service.getPrompts({ groupId: group._id })).rejects.toMatchObject({+ name: 'PromptStoreError',+ stage: 'read',+ });+ });+ });++ describe('createPromptGroup', () => {+ it('rejects a missing prompt or group name before writing', async () => {+ const create = jest.spyOn(db, 'createPromptGroup');++ await expect(+ service.createPromptGroup({+ prompt: { prompt: 'Safe', type: 'text' },+ group: { name: '' },+ author,+ }),+ ).resolves.toEqual({+ ok: false,+ error: { type: 'invalid_input', message: 'Prompt and group name are required' },+ });+ expect(create).not.toHaveBeenCalled();+ });++ it.each([+ [{ prompt: 'Text' }, 'Prompt type must be "text" or "chat"'],+ [{ prompt: 'Text', type: 'image' }, 'Prompt type must be "text" or "chat"'],+ [{ prompt: ' ', type: 'text' }, 'Prompt text is required and must be a non-empty string'],+ ])('rejects the first revision %j before writing', async (prompt, message) => {+ const create = jest.spyOn(db, 'createPromptGroup');++ await expect(+ service.createPromptGroup({+ prompt: prompt as CreatePromptGroupInput['prompt'],+ group: { name: 'New group' },+ author,+ }),+ ).resolves.toEqual({ ok: false, error: { type: 'invalid_input', message } });+ expect(create).not.toHaveBeenCalled();+ });++ it('stores only the prompt fields of the first revision', async () => {+ const otherGroupId = missingId();+ const result = await service.createPromptGroup({+ prompt: { prompt: 'New prompt', type: 'chat', groupId: otherGroupId },+ group: { name: 'New group' },+ author,+ });++ expect(result.ok).toBe(true);+ const prompt = result.ok ? result.value.prompt : null;+ expect(prompt).toMatchObject({ prompt: 'New prompt', type: 'chat', author });+ expect(prompt?.groupId).not.toBe(otherGroupId);+ });++ it('rejects protected content before writing', async () => {+ const create = jest.spyOn(db, 'createPromptGroup');++ await expect(+ service.createPromptGroup({+ prompt: { prompt: 'Safe', type: 'text' },+ group: { name: 'PRIVATE-NAME' },+ author,+ filters,+ }),+ ).resolves.toMatchObject({ ok: false, error: { type: 'blocked_content' } });+ expect(create).not.toHaveBeenCalled();+ });++ it('grants the creator ownership of the new group', async () => {+ const result = await service.createPromptGroup({+ prompt: { prompt: 'New prompt', type: 'text' },+ group: { name: 'New group' },+ author,+ });++ expect(result.ok).toBe(true);+ const groupId = result.ok ? result.value.prompt?.groupId : undefined;+ expect(grantPermission).toHaveBeenCalledWith({+ principalType: PrincipalType.USER,+ principalId: author,+ resourceType: ResourceType.PROMPTGROUP,+ resourceId: groupId,+ accessRoleId: AccessRoleIds.PROMPTGROUP_OWNER,+ grantedBy: author,+ });+ });++ it('logs a failed ownership grant and still returns the new group', async () => {+ grantPermission.mockRejectedValueOnce(new Error('acl unavailable'));+ const logError = jest.spyOn(logger, 'error').mockImplementation(() => logger);++ await expect(+ service.createPromptGroup({+ prompt: { prompt: 'New prompt', type: 'text' },+ group: { name: 'New group' },+ author,+ }),+ ).resolves.toMatchObject({ ok: true });+ expect(logError).toHaveBeenCalledWith(+ expect.stringContaining('[createPromptGroup] Failed to grant owner permissions'),+ expect.any(Error),+ );+ });+ });++ describe('savePrompt', () => {+ it.each([+ [undefined, 'Prompt is required'],+ [{ prompt: ' ', type: 'text' }, 'Prompt text is required and must be a non-empty string'],+ [{ type: 'text' }, 'Prompt text is required and must be a non-empty string'],+ [{ prompt: 'Text', type: 'image' }, 'Prompt type must be "text" or "chat"'],+ ])('rejects the payload %j', async (prompt, message) => {+ const save = jest.spyOn(db, 'savePrompt');++ await expect(service.savePrompt({ groupId: group._id, prompt, author })).resolves.toEqual({+ ok: false,+ error: { type: 'invalid_input', message },+ });+ expect(save).not.toHaveBeenCalled();+ });++ it('saves only the prompt fields into the route group without promoting', async () => {+ const otherGroupId = missingId();+ const result = await service.savePrompt({+ groupId: group._id,+ prompt: { prompt: 'Draft', type: 'chat', groupId: otherGroupId, author: missingId() },+ author,+ });++ expect(result).toMatchObject({+ ok: true,+ value: { prompt: { groupId: group._id, author, prompt: 'Draft', type: 'chat' } },+ });+ await expect(db.getPromptGroup({ _id: group._id })).resolves.toMatchObject({+ productionId: new Types.ObjectId(production._id),+ });+ });++ it('rejects protected content before writing', async () => {+ const save = jest.spyOn(db, 'savePrompt');++ await expect(+ service.savePrompt({+ groupId: group._id,+ prompt: { prompt: 'PRIVATE-VALUE', type: 'text' },+ author,+ filters,+ }),+ ).resolves.toMatchObject({ ok: false, error: { type: 'blocked_content' } });+ expect(save).not.toHaveBeenCalled();+ });++ it('tags a write failure with the write stage', async () => {+ jest.spyOn(db, 'savePrompt').mockRejectedValueOnce(new Error('database unavailable'));++ const error = await service+ .savePrompt({ groupId: group._id, prompt: { prompt: 'Text', type: 'text' }, author })+ .catch((caught: unknown) => caught);++ expect(error).toBeInstanceOf(PromptStoreError);+ expect(error).toMatchObject({ stage: 'write', cause: expect.any(Error) });+ });+ });++ describe('getPromptGroup', () => {+ it('reuses a matching loaded group and redacts a blocked Production revision', async () => {+ const read = jest.spyOn(db, 'getPromptGroup');++ const result = await service.getPromptGroup({+ groupId: group._id,+ loadedGroup: {+ ...group,+ productionPrompt: { ...production, prompt: 'PRIVATE-PROMPT' },+ },+ filters,+ });++ expect(read).not.toHaveBeenCalled();+ expect(result).toMatchObject({+ ok: true,+ value: { productionPrompt: { prompt: '', contentFilterBlocked: true } },+ });+ });++ it('rejects blocked group metadata', async () => {+ await expect(+ service.getPromptGroup({+ groupId: group._id,+ loadedGroup: { ...group, name: 'PRIVATE-GROUP' },+ filters,+ }),+ ).resolves.toMatchObject({ ok: false, error: { type: 'blocked_content' } });+ });++ it('returns null for an absent group and reads when the loaded group differs', async () => {+ const read = jest.spyOn(db, 'getPromptGroup');++ await expect(+ service.getPromptGroup({ groupId: missingId(), loadedGroup: group }),+ ).resolves.toBeNull();+ expect(read).toHaveBeenCalledTimes(1);+ });++ it('tags a read failure with the read stage', async () => {+ jest.spyOn(db, 'getPromptGroup').mockRejectedValueOnce(new Error('database unavailable'));++ await expect(service.getPromptGroup({ groupId: group._id })).rejects.toMatchObject({+ stage: 'read',+ });+ });+ });++ describe('getPrompt', () => {+ it('reuses a matching loaded revision and rejects blocked content', async () => {+ const read = jest.spyOn(db, 'getPrompt');++ await expect(+ service.getPrompt({+ promptId: production._id,+ loadedRevision: { ...production, prompt: 'PRIVATE-PROMPT' },+ filters,+ }),+ ).resolves.toMatchObject({ ok: false, error: { type: 'blocked_content' } });+ expect(read).not.toHaveBeenCalled();+ });++ it('returns the stored revision and null for an absent revision', async () => {+ await expect(service.getPrompt({ promptId: production._id })).resolves.toMatchObject({+ ok: true,+ value: production,+ });+ await expect(service.getPrompt({ promptId: missingId() })).resolves.toBeNull();+ });+ });++ describe('updatePromptGroup', () => {+ it('returns the schema details for an invalid update', async () => {+ const result = await service.updatePromptGroup({+ groupId: group._id,+ updates: { author: missingId() },+ });++ expect(result).toMatchObject({+ ok: false,+ error: {+ type: 'invalid_input',+ message: 'Invalid request body',+ details: [expect.any(Object)],+ },+ });+ });++ it('rejects protected metadata before writing', async () => {+ const update = jest.spyOn(db, 'updatePromptGroup');++ await expect(+ service.updatePromptGroup({+ groupId: group._id,+ updates: { name: 'PRIVATE-NAME' },+ filters,+ }),+ ).resolves.toMatchObject({ ok: false, error: { type: 'blocked_content' } });+ expect(update).not.toHaveBeenCalled();+ });++ it('updates the group and tags a missing group as a write failure', async () => {+ await expect(+ service.updatePromptGroup({ groupId: group._id, updates: { name: 'Renamed' } }),+ ).resolves.toMatchObject({ ok: true, value: { _id: group._id, name: 'Renamed' } });+ await expect(+ service.updatePromptGroup({ groupId: missingId(), updates: { name: 'Renamed' } }),+ ).rejects.toMatchObject({ stage: 'write' });+ });+ });++ describe('makePromptProduction', () => {+ it('promotes a loaded revision without another read', async () => {+ const draft = await addRevision('Draft');+ const read = jest.spyOn(db, 'getPrompt');++ await expect(+ service.makePromptProduction({ promptId: draft._id, loadedRevision: draft }),+ ).resolves.toEqual({ ok: true, value: { message: 'Prompt production made successfully' } });+ expect(read).not.toHaveBeenCalled();+ });++ it('does not promote blocked content', async () => {+ const blocked = await addRevision('Contains PRIVATE-VALUE');+ const promote = jest.spyOn(db, 'makePromptProduction');++ await expect(+ service.makePromptProduction({ promptId: blocked._id, filters }),+ ).resolves.toMatchObject({ ok: false, error: { type: 'blocked_content' } });+ expect(promote).not.toHaveBeenCalled();+ });++ it('does not promote when the preliminary read fails', async () => {+ const draft = await addRevision('Draft');+ jest.spyOn(db, 'getPrompt').mockRejectedValueOnce(new Error('database unavailable'));+ const promote = jest.spyOn(db, 'makePromptProduction');++ await expect(service.makePromptProduction({ promptId: draft._id })).rejects.toMatchObject({+ stage: 'read',+ });+ expect(promote).not.toHaveBeenCalled();+ });++ it('tags a missing revision as a write failure', async () => {+ await expect(service.makePromptProduction({ promptId: missingId() })).rejects.toMatchObject({+ stage: 'write',+ cause: { message: 'Prompt not found' },+ });+ });+ });++ describe('usage and deletion', () => {+ it('records usage and deletes groups', async () => {+ await expect(service.incrementPromptGroupUsage(group._id)).resolves.toEqual({+ numberOfGenerations: 1,+ });+ await expect(service.deletePromptGroup(group._id)).resolves.toEqual({+ message: 'Prompt group deleted successfully',+ });+ });+ });++ describe('a source without mutations', () => {+ it('returns unsupported for each mutation before validating or writing', async () => {+ const {+ savePrompt: _save,+ makePromptProduction: _promote,+ deletePrompt: _delete,+ ...source+ } = createNativePromptAdapter(db);+ const readOnly = createPromptServiceFromAdapters({+ source,+ catalog: createPromptCatalogStore(db),+ grantCreatorOwnership: jest.fn(),+ logger: { error: jest.fn() },+ });++ await expect(+ readOnly.savePrompt({ groupId: group._id, prompt: undefined, author }),+ ).resolves.toEqual({ ok: false, error: { type: 'unsupported', operation: 'savePrompt' } });+ await expect(readOnly.makePromptProduction({ promptId: production._id })).resolves.toEqual({+ ok: false,+ error: { type: 'unsupported', operation: 'makePromptProduction' },+ });+ await expect(+ readOnly.deletePrompt({ groupId: group._id, promptId: production._id }),+ ).resolves.toEqual({ ok: false, error: { type: 'unsupported', operation: 'deletePrompt' } });+ await expect(readOnly.getPrompts({ groupId: group._id })).resolves.toHaveLength(1);+ });+ });+});diff --git a/packages/api/src/prompts/service.ts b/packages/api/src/prompts/service.tsnew file mode 100644index 0000000000..6bacd64c7c--- /dev/null+++ b/packages/api/src/prompts/service.ts@@ -0,0 +1,333 @@+import { logger } from '@librechat/data-schemas';+import { AccessRoleIds, PrincipalType, ResourceType } from 'librechat-data-provider';+import type {+ FiltersConfig,+ TDeletePromptResponse,+ TMakePromptProductionResponse,+} from 'librechat-data-provider';+import type {+ PromptRecord,+ PromptDatabase,+ ResolvedPrompt,+ PromptListInput,+ PromptOperation,+ PromptGroupRecord,+ ResolvePromptInput,+ PromptServiceResult,+ PromptCreationResult,+ CreatePromptGroupInput,+ PromptServiceAdapters,+} from './types';+import type { ProjectedStoredPrompt, ProjectedStoredPromptGroup } from './protection';+import {+ inspectPromptContent,+ projectStoredPrompts,+ projectStoredPromptGroup,+ projectStoredPromptGroups,+} from './protection';+import {+ markPublicPromptGroups,+ buildPromptGroupFilter,+ filterAccessibleIdsBySharedLogic,+} from './format';+import {+ createPromptCatalogStore,+ createNativePromptAdapter,+ selectionUnavailableReason,+} from './native';+import { safeValidatePromptGroupUpdate, safeValidatePromptPayload } from './schemas';+import { withPromptStage } from './errors';++type WithPromptFilters<T> = T & { readonly filters?: FiltersConfig };+type ProjectedGroup = ProjectedStoredPromptGroup<PromptGroupRecord>;++export interface PromptServiceListResult {+ readonly data: readonly ProjectedGroup[];+ readonly has_more: boolean;+ readonly after: string | null;+}++/**+ * Prompt operations for authorized callers. The caller enforces access before each call.+ * Database failures throw `PromptStoreError` with the stage (`read` or `write`) where+ * they occurred, so the HTTP boundary can keep each route's existing response.+ */+export interface PromptService {+ resolvePrompt(input: ResolvePromptInput): Promise<PromptServiceResult<ResolvedPrompt>>;+ getListPromptGroupsByAccess(input: PromptListInput): Promise<PromptServiceListResult>;+ /** Returns the group's revisions, newest first. */+ getPrompts(+ input: WithPromptFilters<{ readonly groupId: string }>,+ ): Promise<readonly ProjectedStoredPrompt<PromptRecord>[]>;+ createPromptGroup(+ input: WithPromptFilters<CreatePromptGroupInput>,+ ): Promise<PromptServiceResult<PromptCreationResult>>;+ savePrompt(+ input: WithPromptFilters<{+ readonly groupId: string;+ readonly prompt: unknown;+ readonly author: string;+ }>,+ ): Promise<PromptServiceResult<{ readonly prompt: PromptRecord }>>;+ /**+ * Returns null when the group does not exist. A successful value of null means that+ * projection removed the group because its metadata is blocked.+ */+ getPromptGroup(+ input: WithPromptFilters<{+ readonly groupId: string;+ readonly loadedGroup?: PromptGroupRecord | null;+ }>,+ ): Promise<PromptServiceResult<ProjectedGroup | null> | null>;+ /** Returns null when the revision does not exist. */+ getPrompt(+ input: WithPromptFilters<{+ readonly promptId: string;+ readonly loadedRevision?: PromptRecord | null;+ }>,+ ): Promise<PromptServiceResult<PromptRecord> | null>;+ incrementPromptGroupUsage(groupId: string): Promise<{ readonly numberOfGenerations: number }>;+ updatePromptGroup(+ input: WithPromptFilters<{ readonly groupId: string; readonly updates: unknown }>,+ ): Promise<PromptServiceResult<PromptGroupRecord>>;+ makePromptProduction(+ input: WithPromptFilters<{+ readonly promptId: string;+ readonly loadedRevision?: PromptRecord | null;+ }>,+ ): Promise<PromptServiceResult<TMakePromptProductionResponse>>;+ deletePrompt(input: {+ readonly groupId: string;+ readonly promptId: string;+ }): Promise<PromptServiceResult<TDeletePromptResponse>>;+ deletePromptGroup(groupId: string): Promise<{ readonly message: string }>;+}++function invalidInput<T>(message: string, details?: unknown): PromptServiceResult<T> {+ return { ok: false, error: { type: 'invalid_input', message, details } };+}++function unsupported<T>(operation: PromptOperation): PromptServiceResult<T> {+ return { ok: false, error: { type: 'unsupported', operation } };+}++function inspect<T>(+ input: Parameters<typeof inspectPromptContent>[0],+ filters: FiltersConfig | undefined,+): PromptServiceResult<T> | null {+ const finding = inspectPromptContent(input, filters);+ return finding == null ? null : { ok: false, error: { type: 'blocked_content', finding } };+}++/** Builds the prompt service from a content source, a catalog store and an ownership grant. */+export function createPromptServiceFromAdapters(adapters: PromptServiceAdapters): PromptService {+ const { source, catalog, grantCreatorOwnership, logger } = adapters;++ const readPrompt = (promptId: string, loaded?: PromptRecord | null) =>+ loaded?._id === promptId+ ? Promise.resolve(loaded)+ : withPromptStage('read', () => source.getPrompt(promptId));++ return {+ async resolvePrompt({ filters, ...input }) {+ const resolved = await source.resolvePrompt(input);+ if (resolved == null) {+ return {+ ok: false,+ error: {+ type: 'unavailable_selection',+ reason: selectionUnavailableReason(input.selection),+ },+ };+ }+ return inspect({ prompt: resolved.prompt }, filters) ?? { ok: true, value: resolved };+ },++ async getListPromptGroupsByAccess(input) {+ const { name, category, searchShared, searchSharedOnly } = buildPromptGroupFilter(input);+ const accessibleIds = await filterAccessibleIdsBySharedLogic({+ accessibleIds: input.accessibleIds,+ searchShared,+ searchSharedOnly,+ publicPromptGroupIds: input.publiclyAccessibleIds,+ ownedPromptGroupIds: input.ownedPromptGroupIds,+ });+ const result = await catalog.getListPromptGroupsByAccess({+ accessibleIds,+ name,+ category,+ limit: input.limit,+ after: input.after,+ });+ const projected = projectStoredPromptGroups(result.data, input.filters, {+ forReuse: input.forReuse,+ });+ return {+ data: markPublicPromptGroups(projected, input.publiclyAccessibleIds),+ has_more: result.has_more,+ after: result.after,+ };+ },++ async getPrompts({ groupId, filters }) {+ const prompts = await withPromptStage('read', () => source.getPrompts(groupId));+ return projectStoredPrompts(prompts, filters);+ },++ async createPromptGroup({ filters, ...input }) {+ if (!input.prompt || !input.group || !input.group.name) {+ return invalidInput('Prompt and group name are required');+ }+ const validation = safeValidatePromptPayload(input.prompt);+ if (!validation.success) {+ return invalidInput(validation.error.issues[0]?.message ?? 'Invalid prompt');+ }+ const rejection = inspect<PromptCreationResult>(+ { prompt: validation.data, group: input.group },+ filters,+ );+ if (rejection != null) {+ return rejection;+ }+ const value = await source.createPromptGroup({ ...input, prompt: validation.data });+ const groupId = value.prompt?.groupId;+ if (value.prompt?._id && groupId) {+ try {+ await grantCreatorOwnership({ userId: input.author, groupId });+ } catch (error) {+ logger.error(+ `[createPromptGroup] Failed to grant owner permissions for promptGroup ${groupId}:`,+ error,+ );+ }+ }+ return { ok: true, value };+ },++ async savePrompt({ groupId, prompt, author, filters }) {+ if (!source.savePrompt) {+ return unsupported('savePrompt');+ }+ if (!prompt) {+ return invalidInput('Prompt is required');+ }+ const validation = safeValidatePromptPayload(prompt);+ if (!validation.success) {+ return invalidInput(validation.error.issues[0]?.message ?? 'Invalid prompt');+ }+ const rejection = inspect<{ prompt: PromptRecord }>({ prompt: validation.data }, filters);+ if (rejection != null) {+ return rejection;+ }+ const save = source.savePrompt;+ const value = await withPromptStage('write', () =>+ save({ groupId, prompt: validation.data, author }),+ );+ return { ok: true, value };+ },++ async getPromptGroup({ groupId, loadedGroup, filters }) {+ const group =+ loadedGroup?._id === groupId+ ? loadedGroup+ : await withPromptStage('read', () => source.getPromptGroup(groupId));+ if (group == null) {+ return null;+ }+ return (+ inspect<ProjectedGroup | null>({ group }, filters) ?? {+ ok: true,+ value: projectStoredPromptGroup(group, filters),+ }+ );+ },++ async getPrompt({ promptId, loadedRevision, filters }) {+ const revision = await readPrompt(promptId, loadedRevision);+ if (revision == null) {+ return null;+ }+ return inspect<PromptRecord>({ prompt: revision }, filters) ?? { ok: true, value: revision };+ },++ incrementPromptGroupUsage: (groupId) => catalog.incrementPromptGroupUsage(groupId),++ async updatePromptGroup({ groupId, updates, filters }) {+ const validation = safeValidatePromptGroupUpdate(updates);+ if (!validation.success) {+ return invalidInput('Invalid request body', validation.error.errors);+ }+ const rejection = inspect<PromptGroupRecord>({ group: validation.data }, filters);+ if (rejection != null) {+ return rejection;+ }+ const value = await withPromptStage('write', () =>+ catalog.updatePromptGroup(groupId, validation.data),+ );+ return { ok: true, value };+ },++ async makePromptProduction({ promptId, loadedRevision, filters }) {+ if (!source.makePromptProduction) {+ return unsupported('makePromptProduction');+ }+ const revision = await readPrompt(promptId, loadedRevision);+ const rejection = inspect<TMakePromptProductionResponse>(+ { prompt: revision ?? undefined },+ filters,+ );+ if (rejection != null) {+ return rejection;+ }+ const promote = source.makePromptProduction;+ const value = await withPromptStage('write', () => promote(promptId));+ return { ok: true, value };+ },++ async deletePrompt(input) {+ if (!source.deletePrompt) {+ return unsupported('deletePrompt');+ }+ return { ok: true, value: await source.deletePrompt(input) };+ },++ deletePromptGroup: (groupId) => catalog.deletePromptGroup(groupId),+ };+}++export interface PromptServiceDependencies {+ readonly db: PromptDatabase;+ readonly grantPermission: (input: {+ principalType: PrincipalType;+ principalId: string;+ resourceType: ResourceType;+ resourceId: string;+ accessRoleId: AccessRoleIds;+ grantedBy: string;+ }) => Promise<unknown>;+}++/** Builds the prompt service from the LibreChat database methods and permission service. */+export function createPromptService({+ db,+ grantPermission,+}: PromptServiceDependencies): PromptService {+ return createPromptServiceFromAdapters({+ source: createNativePromptAdapter(db),+ catalog: createPromptCatalogStore(db),+ grantCreatorOwnership: async ({ userId, groupId }) => {+ await grantPermission({+ principalType: PrincipalType.USER,+ principalId: userId,+ resourceType: ResourceType.PROMPTGROUP,+ resourceId: groupId,+ accessRoleId: AccessRoleIds.PROMPTGROUP_OWNER,+ grantedBy: userId,+ });+ logger.debug(+ `[createPromptGroup] Granted owner permissions to user ${userId} for promptGroup ${groupId}`,+ );+ },+ logger,+ });+}diff --git a/packages/api/src/prompts/types.ts b/packages/api/src/prompts/types.tsnew file mode 100644index 0000000000..999909a39a--- /dev/null+++ b/packages/api/src/prompts/types.ts@@ -0,0 +1,199 @@+import type {+ FiltersConfig,+ TCreatePromptRecord,+ TDeletePromptResponse,+ TMakePromptProductionResponse,+} from 'librechat-data-provider';+import type { ProtectionFinding } from '../protection/types';++export type PromptKind = 'text' | 'chat';+export type PromptTimestamp = string | Date;++/** A stored ID as the database returns it: a string or an ObjectId-like value. */+export interface StoredId {+ toString(): string;+}++export interface PromptRecord {+ readonly _id: string;+ readonly groupId: string;+ readonly author: string;+ readonly prompt: string;+ /** Absent on some stored revisions, because the first revision skipped schema validation. */+ readonly type?: PromptKind;+ readonly createdAt?: PromptTimestamp;+ readonly updatedAt?: PromptTimestamp;+ readonly tenantId?: string;+}++export interface PromptProjection {+ readonly _id?: string;+ readonly prompt: string;+ readonly groupId?: string;+ readonly author?: string;+ readonly type?: PromptKind;+}++export interface PromptGroupRecord {+ readonly _id: string;+ readonly name: string;+ readonly author: string;+ readonly authorName: string;+ readonly numberOfGenerations?: number;+ readonly command?: string | null;+ readonly oneliner?: string;+ readonly category?: string;+ readonly productionId?: string | null;+ readonly productionPrompt?: PromptRecord | PromptProjection | null;+ readonly isPublic?: boolean;+ readonly createdAt?: PromptTimestamp;+ readonly updatedAt?: PromptTimestamp;+ readonly tenantId?: string;+}++export type PromptSelection =+ | { readonly type: 'production' }+ | { readonly type: 'exact'; readonly promptId: string };++export interface ResolvedPrompt {+ readonly groupId: string;+ readonly promptId: string;+ readonly prompt: string;+ readonly type: PromptKind;+}++/** The raw creation body plus the server-supplied creator. */+export type CreatePromptGroupInput = Omit<TCreatePromptRecord, 'authorName'> & {+ readonly authorName?: string;+};++export interface AddPromptRevisionInput {+ readonly groupId: string;+ readonly prompt: { readonly prompt: string; readonly type: PromptKind };+ readonly author: string;+}++export interface PromptCreationResult {+ readonly prompt: PromptRecord | null;+ readonly group: PromptGroupRecord;+}++export interface PromptListResult {+ readonly data: readonly PromptGroupRecord[];+ readonly has_more: boolean;+ readonly after: string | null;+}++export interface PromptListInput {+ readonly accessibleIds: readonly string[];+ readonly publiclyAccessibleIds: readonly string[];+ readonly ownedPromptGroupIds: readonly string[];+ readonly name?: string;+ readonly category?: string;+ /** Page size; null requests the full catalog. */+ readonly limit: number | string | null;+ readonly after: string | null;+ readonly forReuse: boolean;+ readonly filters?: FiltersConfig;+}++export type PromptOperation = 'savePrompt' | 'makePromptProduction' | 'deletePrompt';++export type PromptServiceError =+ | { readonly type: 'invalid_input'; readonly message: string; readonly details?: unknown }+ | { readonly type: 'blocked_content'; readonly finding: ProtectionFinding }+ | {+ readonly type: 'unavailable_selection';+ readonly reason: 'production' | 'revision';+ }+ | { readonly type: 'unsupported'; readonly operation: PromptOperation };++export type PromptServiceResult<T> =+ | { readonly ok: true; readonly value: T }+ | { readonly ok: false; readonly error: PromptServiceError };++export interface ResolvePromptInput {+ readonly groupId: string;+ readonly selection: PromptSelection;+ readonly loadedGroup?: PromptGroupRecord | null;+ readonly loadedRevision?: PromptRecord | null;+ readonly filters?: FiltersConfig;+}++/**+ * Operations that need source content. Mutations are optional: a source that cannot+ * perform one leaves it out, and the service returns an `unsupported` result.+ */+export interface PromptSourceAdapter {+ /** Returns null when the selection is not available in the group. */+ resolvePrompt(input: Omit<ResolvePromptInput, 'filters'>): Promise<ResolvedPrompt | null>;+ getPromptGroup(groupId: string): Promise<PromptGroupRecord | null>;+ getPrompt(promptId: string): Promise<PromptRecord | null>;+ getPrompts(groupId: string): Promise<readonly PromptRecord[]>;+ createPromptGroup(input: CreatePromptGroupInput): Promise<PromptCreationResult>;+ savePrompt?(input: AddPromptRevisionInput): Promise<{ readonly prompt: PromptRecord }>;+ /** Throws when the revision does not exist. */+ makePromptProduction?(promptId: string): Promise<TMakePromptProductionResponse>;+ deletePrompt?(input: {+ readonly groupId: string;+ readonly promptId: string;+ }): Promise<TDeletePromptResponse>;+}++/** Local catalog operations that do not depend on the content source. */+export interface PromptCatalogStore {+ getListPromptGroupsByAccess(+ input: Pick<PromptListInput, 'accessibleIds' | 'name' | 'category' | 'limit' | 'after'>,+ ): Promise<PromptListResult>;+ updatePromptGroup(groupId: string, updates: Record<string, unknown>): Promise<PromptGroupRecord>;+ incrementPromptGroupUsage(groupId: string): Promise<{ readonly numberOfGenerations: number }>;+ deletePromptGroup(groupId: string): Promise<{ readonly message: string }>;+}++/** The data-schemas prompt methods the native adapter and catalog store use. */+export interface PromptDatabase {+ getPromptGroup(filter: { _id: string }): Promise<object | null>;+ getPrompt(filter: { _id: string }): Promise<object | null>;+ getPrompts(filter: { groupId: string }): Promise<readonly object[]>;+ createPromptGroup(input: {+ prompt: Record<string, unknown>;+ group: Record<string, unknown>;+ author: string;+ authorName?: string;+ }): Promise<{ prompt: object | null; group: object }>;+ savePrompt(input: {+ prompt: Record<string, unknown>;+ author: string;+ }): Promise<{ prompt: object }>;+ makePromptProduction(promptId: string): Promise<{ message: string }>;+ deletePrompt(input: {+ promptId: string;+ groupId: string;+ }): Promise<{ prompt: string; promptGroup?: { message: string; id: StoredId } }>;+ getListPromptGroupsByAccess(input: {+ accessibleIds: string[];+ name?: string;+ category?: string;+ limit: number | string | null;+ after: string | null;+ }): Promise<{ data: readonly object[]; has_more: boolean; after: string | null }>;+ updatePromptGroup(filter: { _id: string }, data: Record<string, unknown>): Promise<object>;+ incrementPromptGroupUsage(groupId: string): Promise<{ numberOfGenerations: number }>;+ deletePromptGroup(filter: { _id: string }): Promise<{ message: string }>;+}++export interface PromptServiceAdapters {+ /**+ * The content source for every prompt group. The service does not select a source for+ * each group: a group has no source field, and some operations receive only a revision ID.+ */+ readonly source: PromptSourceAdapter;+ readonly catalog: PromptCatalogStore;+ readonly grantCreatorOwnership: (input: {+ readonly userId: string;+ readonly groupId: string;+ }) => Promise<void>;+ readonly logger: {+ error(message: string, error: unknown): void;+ };+}diff --git a/packages/api/src/protection/adapters/submissions.ts b/packages/api/src/protection/adapters/submissions.tsindex e57f4638b8..86f68e6131 100644--- a/packages/api/src/protection/adapters/submissions.ts+++ b/packages/api/src/protection/adapters/submissions.ts@@ -99,7 +99,7 @@ export interface PromptRecordInput {readonly description?: string;readonly oneliner?: string;readonly category?: string;- readonly command?: string;+ readonly command?: string | null;}interface PromptRecordContentInput extends Omit<PromptRecordInput, 'prompt'> {diff --git a/packages/api/src/types/prompts.ts b/packages/api/src/types/prompts.tsindex f503f688df..17224398da 100644--- a/packages/api/src/types/prompts.ts+++ b/packages/api/src/types/prompts.ts@@ -1,8 +1,8 @@import type { IPromptGroup as IPromptGroup } from '@librechat/data-schemas';import type { Types } from 'mongoose';-export interface PromptGroupsListResponse {- promptGroups: IPromptGroup[];+export interface PromptGroupsListResponse<T = IPromptGroup> {+ promptGroups: T[];pageNumber: string;pageSize: string;pages: string;diff --git a/packages/data-schemas/src/methods/index.ts b/packages/data-schemas/src/methods/index.tsindex 464c662fc3..825fe5a15d 100644--- a/packages/data-schemas/src/methods/index.ts+++ b/packages/data-schemas/src/methods/index.ts@@ -124,7 +124,12 @@ import {} from './tx';import { createTransactionMethods, type TransactionMethods } from './transaction';import { createSpendTokensMethods, type SpendTokensMethods } from './spendTokens';-import { createPromptMethods, type PromptMethods, type PromptDeps } from './prompt';+import {+ createPromptMethods,+ type PromptMethods,+ type PromptDeps,+ type PromptGroupListParams,+} from './prompt';import {createSkillMethods,partitionIssues,@@ -233,6 +238,7 @@ export {export { AUDIT_SCHEMA_VERSION, MAX_AUDIT_EXPORT_ROWS, MAX_AUDIT_LOG_LIMIT, MAX_AUDIT_VERIFY_ROWS };export { MAX_TOOL_FAVORITES };export { AgentTriggerDeliveryConflictError };+export type { PromptGroupListParams };export { AGENT_OWNER_CONTACT_RESOLVED_FIELD, AgentSortCursorError } from './agent';export {AgentQueuedTurnCapacityError,diff --git a/packages/data-schemas/src/methods/prompt.spec.ts b/packages/data-schemas/src/methods/prompt.spec.tsindex 6a02b8bc3b..60e7f36a26 100644--- a/packages/data-schemas/src/methods/prompt.spec.ts+++ b/packages/data-schemas/src/methods/prompt.spec.ts@@ -1,5 +1,6 @@import mongoose from 'mongoose';import { ObjectId } from 'mongodb';+import { logger, createModels } from '..';import { MongoMemoryServer } from 'mongodb-memory-server';import {SystemRoles,@@ -10,7 +11,6 @@ import {} from 'librechat-data-provider';import type { IPromptGroup, AccessRole as TAccessRole, AclEntry as TAclEntry } from '..';import { createAclEntryMethods } from './aclEntry';-import { logger, createModels } from '..';import { createMethods } from './index';// Disable console for tests@@ -623,3 +623,147 @@ describe('Prompt ACL Permissions', () => {});});});++describe('Prompt method failure contracts', () => {+ const dbError = new Error('database unavailable');++ afterEach(() => {+ jest.restoreAllMocks();+ });++ async function createGroupWithPrompt(name: string, category = '') {+ const { prompt, group } = await methods.createPromptGroup({+ prompt: { prompt: `${name} text`, type: 'text' },+ group: { name, category },+ author: String(testUsers.owner._id),+ authorName: testUsers.owner.name ?? '',+ });+ return {+ groupId: String((group as { _id: unknown })._id),+ promptId: String((prompt as { _id: unknown })._id),+ };+ }++ it('returns null for an absent group or revision', async () => {+ await expect(methods.getPromptGroup({ _id: new ObjectId().toString() })).resolves.toBeNull();+ await expect(methods.getPrompt({ _id: new ObjectId() })).resolves.toBeNull();+ });++ it('throws database failures from reads instead of returning data', async () => {+ jest.spyOn(PromptGroup, 'aggregate').mockImplementationOnce(() => {+ throw dbError;+ });+ await expect(methods.getPromptGroup({ _id: new ObjectId().toString() })).rejects.toBe(dbError);++ jest.spyOn(Prompt, 'findOne').mockImplementationOnce(() => {+ throw dbError;+ });+ await expect(methods.getPrompt({ _id: new ObjectId() })).rejects.toBe(dbError);++ jest.spyOn(Prompt, 'find').mockImplementationOnce(() => {+ throw dbError;+ });+ await expect(methods.getPrompts({ groupId: new ObjectId() })).rejects.toBe(dbError);+ });++ it('saves a revision as plain data and throws save failures', async () => {+ const { groupId } = await createGroupWithPrompt('Save contract');+ const { prompt } = await methods.savePrompt({+ prompt: { prompt: 'second', type: 'chat', groupId },+ author: String(testUsers.owner._id),+ });+ expect(prompt).not.toBeInstanceOf(mongoose.Document);+ expect(String(prompt.groupId)).toBe(groupId);++ jest.spyOn(Prompt, 'create').mockImplementationOnce(() => {+ throw dbError;+ });+ await expect(+ methods.savePrompt({+ prompt: { prompt: 'third', type: 'text', groupId },+ author: String(testUsers.owner._id),+ }),+ ).rejects.toBe(dbError);+ });++ it('keeps the index repair retry when saving a revision', async () => {+ const { groupId } = await createGroupWithPrompt('Index repair');+ const dropIndex = jest.fn().mockResolvedValue(undefined);+ jest+ .spyOn(Prompt.db, 'collection')+ .mockReturnValueOnce({ dropIndex } as unknown as ReturnType<typeof Prompt.db.collection>);+ const create = jest.spyOn(Prompt, 'create');+ create.mockImplementationOnce(() => {+ throw new Error('E11000 duplicate key error index: groupId_1_version_1');+ });++ const { prompt } = await methods.savePrompt({+ prompt: { prompt: 'retried', type: 'text', groupId },+ author: String(testUsers.owner._id),+ });++ expect(dropIndex).toHaveBeenCalledWith('groupId_1_version_1');+ expect(create).toHaveBeenCalledTimes(2);+ expect(prompt.prompt).toBe('retried');+ });++ it('returns the updated group as plain data and throws update failures', async () => {+ const { groupId } = await createGroupWithPrompt('Update contract');+ const updated = await methods.updatePromptGroup({ _id: groupId }, { name: 'Renamed' });+ expect(updated).not.toBeInstanceOf(mongoose.Document);+ expect(updated.name).toBe('Renamed');++ await expect(+ methods.updatePromptGroup({ _id: new ObjectId().toString() }, { name: 'Missing' }),+ ).rejects.toThrow('Prompt group not found');++ jest.spyOn(PromptGroup, 'findOneAndUpdate').mockImplementationOnce(() => {+ throw dbError;+ });+ await expect(methods.updatePromptGroup({ _id: groupId }, { name: 'x' })).rejects.toBe(dbError);+ });++ it('distinguishes a missing promotion revision from a database failure', async () => {+ const { groupId, promptId } = await createGroupWithPrompt('Promotion contract');+ const { prompt } = await methods.savePrompt({+ prompt: { prompt: 'next', type: 'text', groupId },+ author: String(testUsers.owner._id),+ });++ await expect(methods.makePromptProduction(String(prompt._id))).resolves.toEqual({+ message: 'Prompt production made successfully',+ });+ const group = (await methods.getPromptGroup({ _id: groupId })) as { productionId: unknown };+ expect(String(group.productionId)).toBe(String(prompt._id));++ await expect(methods.makePromptProduction(new ObjectId().toString())).rejects.toThrow(+ 'Prompt not found',+ );++ jest.spyOn(Prompt, 'findById').mockImplementationOnce(() => {+ throw dbError;+ });+ await expect(methods.makePromptProduction(promptId)).rejects.toBe(dbError);+ });++ it('filters the access listing by plain name and category inputs', async () => {+ const first = await createGroupWithPrompt('Listing Alpha (v1)', 'writing');+ const second = await createGroupWithPrompt('Listing Beta', '');+ const accessibleIds = [first.groupId, second.groupId];++ const byName = await methods.getListPromptGroupsByAccess({+ accessibleIds,+ name: 'alpha (v1',+ });+ expect(byName.data.map((group) => String(group._id))).toEqual([first.groupId]);++ const uncategorized = await methods.getListPromptGroupsByAccess({+ accessibleIds,+ category: '',+ });+ expect(uncategorized.data.map((group) => String(group._id))).toEqual([second.groupId]);++ const all = await methods.getListPromptGroupsByAccess({ accessibleIds });+ expect(all.data).toHaveLength(2);+ });+});diff --git a/packages/data-schemas/src/methods/prompt.ts b/packages/data-schemas/src/methods/prompt.tsindex 40cad9c6b7..a7aba67d98 100644--- a/packages/data-schemas/src/methods/prompt.ts+++ b/packages/data-schemas/src/methods/prompt.ts@@ -7,7 +7,14 @@ import {Time,} from 'librechat-data-provider';import type { Model, Types } from 'mongoose';-import type { IAclEntry, CacheStore, IPrompt, IPromptGroup, IPromptGroupDocument } from '~/types';+import type {+ IAclEntry,+ CacheStore,+ IPrompt,+ IPromptGroup,+ IPromptRecord,+ IPromptGroupDocument,+} from '~/types';import { getTenantId, scopedCacheKey, SYSTEM_TENANT_ID } from '~/config/tenantContext';import { isValidObjectIdString } from '~/utils/objectId';import { escapeRegExp } from '~/utils/string';@@ -91,6 +98,18 @@ async function readAccessGeneration(cache: CacheStore): Promise<string | undefin}}+/**+ * Plain listing inputs. `name` is a case-insensitive substring; `category` is the stored+ * category value, where an empty string selects groups without a category.+ */+export interface PromptGroupListParams {+ accessibleIds?: Array<string | Types.ObjectId>;+ name?: string;+ category?: string;+ limit?: number | string | null;+ after?: string | null;+}+export interface PromptMethods {getPromptGroups(filter: Record<string, unknown>): Promise<| {@@ -105,12 +124,7 @@ export interface PromptMethods {getAllPromptGroups(filter: Record<string, unknown>,): Promise<Record<string, unknown>[] | { message: string }>;- getListPromptGroupsByAccess(params: {- accessibleIds?: Types.ObjectId[];- otherParams?: Record<string, unknown>;- limit?: number | null;- after?: string | null;- }): Promise<{+ getListPromptGroupsByAccess(params: PromptGroupListParams): Promise<{object: 'list';data: Record<string, unknown>[];first_id: string | null;@@ -128,13 +142,9 @@ export interface PromptMethods {savePrompt(saveData: {prompt: Record<string, unknown>;author: string | Types.ObjectId;- }): Promise<{ prompt: IPrompt } | { message: string }>;- getPrompts(- filter: Record<string, unknown>,- ): Promise<Record<string, unknown>[] | { message: string }>;- getPrompt(- filter: Record<string, unknown>,- ): Promise<Record<string, unknown> | null | { message: string }>;+ }): Promise<{ prompt: IPromptRecord }>;+ getPrompts(filter: Record<string, unknown>): Promise<IPromptRecord[]>;+ getPrompt(filter: Record<string, unknown>): Promise<IPromptRecord | null>;getRandomPromptGroups(filter: {skip: number | string;limit: number | string;@@ -158,7 +168,7 @@ export interface PromptMethods {updatePromptGroup(filter: Record<string, unknown>,data: Record<string, unknown>,- ): Promise<IPromptGroupDocument | { message: string }>;+ ): Promise<IPromptGroup>;makePromptProduction(promptId: string): Promise<{ message: string }>;updatePromptLabels(_id: string, labels: unknown): Promise<{ message: string }>;}@@ -365,15 +375,11 @@ export function createPromptMethods(*/async function getListPromptGroupsByAccess({accessibleIds = [],- otherParams = {},+ name,+ category,limit = null,after = null,- }: {- accessibleIds?: Types.ObjectId[];- otherParams?: Record<string, unknown>;- limit?: number | null;- after?: string | null;- }): Promise<{+ }: PromptGroupListParams): Promise<{object: 'list';data: Record<string, unknown>[];first_id: string | null;@@ -388,9 +394,14 @@ export function createPromptMethods(: null;const baseQuery: Record<string, unknown> = {- ...otherParams,_id: { $in: accessibleIds },};+ if (name) {+ baseQuery.name = new RegExp(escapeRegExp(name), 'i');+ }+ if (category != null) {+ baseQuery.category = category;+ }let matchQuery: Record<string, unknown> = baseQuery;@@ -569,58 +580,42 @@ export function createPromptMethods(async function savePrompt(saveData: {prompt: Record<string, unknown>;author: string | Types.ObjectId;- }) {- try {- const Prompt = mongoose.models.Prompt as Model<IPrompt>;- const { prompt, author } = saveData;- const newPromptData = { ...prompt, author };+ }): Promise<{ prompt: IPromptRecord }> {+ const Prompt = mongoose.models.Prompt as Model<IPrompt>;+ const { prompt, author } = saveData;+ const newPromptData = { ...prompt, author };- let newPrompt;- try {- newPrompt = await Prompt.create(newPromptData);- } catch (error: unknown) {- if ((error as 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);+ let newPrompt;+ try {+ newPrompt = await Prompt.create(newPromptData);+ } catch (error: unknown) {+ if (!(error as Error)?.message?.includes('groupId_1_version_1')) {+ throw error;}-- return { prompt: newPrompt };- } catch (error) {- logger.error('Error saving prompt', error);- return { message: 'Error saving prompt' };+ await Prompt.db.collection('prompts').dropIndex('groupId_1_version_1');+ newPrompt = await Prompt.create(newPromptData);}++ return { prompt: newPrompt.toObject<IPromptRecord>() };}/*** Get prompts by filter.*/- async function getPrompts(filter: Record<string, unknown>) {- try {- const Prompt = mongoose.models.Prompt as Model<IPrompt>;- return await Prompt.find(filter).sort({ createdAt: -1 }).lean();- } catch (error) {- logger.error('Error getting prompts', error);- return { message: 'Error getting prompts' };- }+ async function getPrompts(filter: Record<string, unknown>): Promise<IPromptRecord[]> {+ const Prompt = mongoose.models.Prompt as Model<IPrompt>;+ return await Prompt.find(filter).sort({ createdAt: -1 }).lean<IPromptRecord[]>();}/*** Get a single prompt by filter.*/- async function getPrompt(filter: Record<string, unknown>) {- try {- const Prompt = mongoose.models.Prompt as Model<IPrompt>;- if (filter.groupId) {- filter.groupId = new ObjectId(filter.groupId as string);- }- return await Prompt.findOne(filter).lean();- } catch (error) {- logger.error('Error getting prompt', error);- return { message: 'Error getting prompt' };+ async function getPrompt(filter: Record<string, unknown>): Promise<IPromptRecord | null> {+ const Prompt = mongoose.models.Prompt as Model<IPrompt>;+ if (filter.groupId) {+ filter.groupId = new ObjectId(filter.groupId as string);}+ return await Prompt.findOne(filter).lean<IPromptRecord>();}/**@@ -687,44 +682,39 @@ export function createPromptMethods(* Get a single prompt group by filter, with productionPrompt populated via $lookup.*/async function getPromptGroup(filter: Record<string, unknown>) {- try {- const PromptGroup = mongoose.models.PromptGroup as Model<IPromptGroupDocument>;- // Cast string _id to ObjectId for aggregation (findOne auto-casts, aggregate does not)- const matchFilter = { ...filter };- if (typeof matchFilter._id === 'string') {- matchFilter._id = new ObjectId(matchFilter._id);- }- const tenantId = getTenantId();- const useTenantFilter = tenantId && tenantId !== SYSTEM_TENANT_ID;-- const result = await PromptGroup.aggregate([- { $match: matchFilter },- {- $lookup: {- from: 'prompts',- localField: 'productionId',- foreignField: '_id',- as: 'productionPrompt',- },+ const PromptGroup = mongoose.models.PromptGroup as Model<IPromptGroupDocument>;+ // Cast string _id to ObjectId for aggregation (findOne auto-casts, aggregate does not)+ const matchFilter = { ...filter };+ if (typeof matchFilter._id === 'string') {+ matchFilter._id = new ObjectId(matchFilter._id);+ }+ const tenantId = getTenantId();+ const useTenantFilter = tenantId && tenantId !== SYSTEM_TENANT_ID;++ const result = await PromptGroup.aggregate([+ { $match: matchFilter },+ {+ $lookup: {+ from: 'prompts',+ localField: 'productionId',+ foreignField: '_id',+ as: 'productionPrompt',},- { $unwind: { path: '$productionPrompt', preserveNullAndEmptyArrays: true } },- ]);- const group = result[0] || null;- if (- group?.productionPrompt &&- useTenantFilter &&- group.productionPrompt.tenantId !== tenantId- ) {- group.productionPrompt = null;- }- if (group?.author) {- group.author = group.author.toString();- }- return group;- } catch (error) {- logger.error('Error getting prompt group', error);- return null;+ },+ { $unwind: { path: '$productionPrompt', preserveNullAndEmptyArrays: true } },+ ]);+ const group = result[0] || null;+ if (+ group?.productionPrompt &&+ useTenantFilter &&+ group.productionPrompt.tenantId !== tenantId+ ) {+ group.productionPrompt = null;+ }+ if (group?.author) {+ group.author = group.author.toString();}+ return group;}/**@@ -1077,54 +1067,41 @@ export function createPromptMethods(/*** Update a prompt group.*/- async function updatePromptGroup(filter: Record<string, unknown>, data: Record<string, unknown>) {- try {- const PromptGroup = mongoose.models.PromptGroup as Model<IPromptGroupDocument>;- 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');- }+ async function updatePromptGroup(+ filter: Record<string, unknown>,+ data: Record<string, unknown>,+ ): Promise<IPromptGroup> {+ const PromptGroup = mongoose.models.PromptGroup as Model<IPromptGroupDocument>;+ const updatedDoc = await PromptGroup.findOneAndUpdate(filter, data, {+ new: true,+ upsert: false,+ }).lean();- return updatedDoc;- } catch (error) {- logger.error('Error updating prompt group', error);- return { message: 'Error updating prompt group' };+ if (!updatedDoc) {+ throw new Error('Prompt group not found');}++ return updatedDoc as unknown as IPromptGroup;}/*** Make a prompt the production prompt for its group.*/- async function makePromptProduction(promptId: string) {- try {- const Prompt = mongoose.models.Prompt as Model<IPrompt>;- const PromptGroup = mongoose.models.PromptGroup as Model<IPromptGroupDocument>;+ async function makePromptProduction(promptId: string): Promise<{ message: string }> {+ const Prompt = mongoose.models.Prompt as Model<IPrompt>;+ const PromptGroup = mongoose.models.PromptGroup as Model<IPromptGroupDocument>;- const prompt = await Prompt.findById(promptId).lean();+ const prompt = await Prompt.findById(promptId).lean();- if (!prompt) {- throw new Error('Prompt not found');- }+ if (!prompt) {+ throw new Error('Prompt not found');+ }- await PromptGroup.findByIdAndUpdate(- prompt.groupId,- { productionId: prompt._id },- { new: true },- )- .lean()- .exec();+ 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' };- }+ return { message: 'Prompt production made successfully' };}/**diff --git a/packages/data-schemas/src/types/prompts.ts b/packages/data-schemas/src/types/prompts.tsindex 02db35a1be..24150ba27f 100644--- a/packages/data-schemas/src/types/prompts.ts+++ b/packages/data-schemas/src/types/prompts.ts@@ -10,6 +10,12 @@ export interface IPrompt extends Document {tenantId?: string;}+/** A stored prompt revision as plain data, without Mongoose document methods. */+export type IPromptRecord = Pick<+ IPrompt,+ 'groupId' | 'author' | 'prompt' | 'type' | 'createdAt' | 'updatedAt' | 'tenantId'+> & { _id: Types.ObjectId; __v?: number };+export interface IPromptGroup {name: string;numberOfGenerations: number;