🧠 feat: Prompt caching switch, prompt query params; refactor: static cache, prompt/markdown styling, trim copied code, switch new chat to convo URL (#3784)

* refactor: Update staticCache to use oneDayInSeconds for sMaxAge and maxAge

* refactor: role updates

* style: first pass cursor

* style: Update nested list styles in style.css

* feat: setIsSubmitting to true in message handler to prevent edge case where submitting turns false during message stream

* feat: Add logic to redirect to conversation page after creating a new conversation

* refactor: Trim code string before copying in CodeBlock component

* feat: configSchema bookmarks and presets defaults

* feat: Update loadDefaultInterface to handle undefined config

* refactor: use  for compression check

* feat: first pass, query params

* fix: styling issues for prompt cards

* feat: anthropic prompt caching UI switch

* chore: Update static file cache control defaults/comments in .env.example

* ci: fix tests

* ci: fix tests

* chore:  use "submitting" class server error connection suspense fallback

api/app/clients/AnthropicClient.js

@@ -94,7 +94,8 @@ class AnthropicClient extends BaseClient {
     const modelMatch = matchModelName(this.modelOptions.model, EModelEndpoint.anthropic);
     this.isClaude3 = modelMatch.startsWith('claude-3');
     this.isLegacyOutput = !modelMatch.startsWith('claude-3-5-sonnet');
-    this.supportsCacheControl = this.checkPromptCacheSupport(modelMatch);
+    this.supportsCacheControl =
+      this.options.promptCache && this.checkPromptCacheSupport(modelMatch);
 
     if (
       this.isLegacyOutput &&
@@ -821,6 +822,7 @@ class AnthropicClient extends BaseClient {
       maxContextTokens: this.options.maxContextTokens,
       promptPrefix: this.options.promptPrefix,
       modelLabel: this.options.modelLabel,
+      promptCache: this.options.promptCache,
       resendFiles: this.options.resendFiles,
       iconURL: this.options.iconURL,
       greeting: this.options.greeting,

api/app/clients/specs/AnthropicClient.test.js

@@ -206,7 +206,7 @@ describe('AnthropicClient', () => {
       const modelOptions = {
         model: 'claude-3-5-sonnet-20240307',
       };
-      client.setOptions({ modelOptions });
+      client.setOptions({ modelOptions, promptCache: true });
       const anthropicClient = client.getClient(modelOptions);
       expect(anthropicClient._options.defaultHeaders).toBeDefined();
       expect(anthropicClient._options.defaultHeaders).toHaveProperty('anthropic-beta');
@@ -220,7 +220,7 @@ describe('AnthropicClient', () => {
       const modelOptions = {
         model: 'claude-3-haiku-2028',
       };
-      client.setOptions({ modelOptions });
+      client.setOptions({ modelOptions, promptCache: true });
       const anthropicClient = client.getClient(modelOptions);
       expect(anthropicClient._options.defaultHeaders).toBeDefined();
       expect(anthropicClient._options.defaultHeaders).toHaveProperty('anthropic-beta');

api/models/Role.js

@@ -76,46 +76,57 @@ const permissionSchemas = {
 };
 
 /**
- * Updates access permissions for a specific role and permission type.
+ * Updates access permissions for a specific role and multiple permission types.
  * @param {SystemRoles} roleName - The role to update.
- * @param {PermissionTypes} permissionType - The type of permission to update.
- * @param {Object.<Permissions, boolean>} permissions - Permissions to update and their values.
+ * @param {Object.<PermissionTypes, Object.<Permissions, boolean>>} permissionsUpdate - Permissions to update and their values.
  */
-async function updateAccessPermissions(roleName, permissionType, _permissions) {
-  const permissions = removeNullishValues(_permissions);
-  if (Object.keys(permissions).length === 0) {
+async function updateAccessPermissions(roleName, permissionsUpdate) {
+  const updates = {};
+  for (const [permissionType, permissions] of Object.entries(permissionsUpdate)) {
+    if (permissionSchemas[permissionType]) {
+      updates[permissionType] = removeNullishValues(permissions);
+    }
+  }
+
+  if (Object.keys(updates).length === 0) {
     return;
   }
 
   try {
     const role = await getRoleByName(roleName);
-    if (!role || !permissionSchemas[permissionType]) {
+    if (!role) {
       return;
     }
 
-    await updateRoleByName(roleName, {
-      [permissionType]: {
-        ...role[permissionType],
-        ...permissionSchemas[permissionType].partial().parse(permissions),
-      },
-    });
+    const updatedPermissions = {};
+    let hasChanges = false;
 
-    Object.entries(permissions).forEach(([permission, value]) =>
-      logger.info(
-        `Updated '${roleName}' role ${permissionType} '${permission}' permission to: ${value}`,
-      ),
-    );
+    for (const [permissionType, permissions] of Object.entries(updates)) {
+      const currentPermissions = role[permissionType] || {};
+      updatedPermissions[permissionType] = { ...currentPermissions };
+
+      for (const [permission, value] of Object.entries(permissions)) {
+        if (currentPermissions[permission] !== value) {
+          updatedPermissions[permissionType][permission] = value;
+          hasChanges = true;
+          logger.info(
+            `Updating '${roleName}' role ${permissionType} '${permission}' permission from ${currentPermissions[permission]} to: ${value}`,
+          );
+        }
+      }
+    }
+
+    if (hasChanges) {
+      await updateRoleByName(roleName, updatedPermissions);
+      logger.info(`Updated '${roleName}' role permissions`);
+    } else {
+      logger.info(`No changes needed for '${roleName}' role permissions`);
+    }
   } catch (error) {
-    logger.error(`Failed to update ${roleName} role ${permissionType} permissions:`, error);
+    logger.error(`Failed to update ${roleName} role permissions:`, error);
   }
 }
 
-const updatePromptsAccess = (roleName, permissions) =>
-  updateAccessPermissions(roleName, PermissionTypes.PROMPTS, permissions);
-
-const updateBookmarksAccess = (roleName, permissions) =>
-  updateAccessPermissions(roleName, PermissionTypes.BOOKMARKS, permissions);
-
 /**
  * Initialize default roles in the system.
  * Creates the default roles (ADMIN, USER) if they don't exist in the database.
@@ -138,6 +149,5 @@ module.exports = {
   getRoleByName,
   initializeRoles,
   updateRoleByName,
-  updatePromptsAccess,
-  updateBookmarksAccess,
+  updateAccessPermissions,
 };

api/models/Role.spec.js

@@ -0,0 +1,197 @@
+const mongoose = require('mongoose');
+const { MongoMemoryServer } = require('mongodb-memory-server');
+const { SystemRoles, PermissionTypes } = require('librechat-data-provider');
+const Role = require('~/models/schema/roleSchema');
+const { updateAccessPermissions } = require('~/models/Role');
+const getLogStores = require('~/cache/getLogStores');
+
+// Mock the cache
+jest.mock('~/cache/getLogStores', () => {
+  return jest.fn().mockReturnValue({
+    get: jest.fn(),
+    set: jest.fn(),
+    del: jest.fn(),
+  });
+});
+
+let mongoServer;
+
+beforeAll(async () => {
+  mongoServer = await MongoMemoryServer.create();
+  const mongoUri = mongoServer.getUri();
+  await mongoose.connect(mongoUri);
+});
+
+afterAll(async () => {
+  await mongoose.disconnect();
+  await mongoServer.stop();
+});
+
+beforeEach(async () => {
+  await Role.deleteMany({});
+  getLogStores.mockClear();
+});
+
+describe('updateAccessPermissions', () => {
+  it('should update permissions when changes are needed', async () => {
+    await new Role({
+      name: SystemRoles.USER,
+      [PermissionTypes.PROMPTS]: {
+        CREATE: true,
+        USE: true,
+        SHARED_GLOBAL: false,
+      },
+    }).save();
+
+    await updateAccessPermissions(SystemRoles.USER, {
+      [PermissionTypes.PROMPTS]: {
+        CREATE: true,
+        USE: true,
+        SHARED_GLOBAL: true,
+      },
+    });
+
+    const updatedRole = await Role.findOne({ name: SystemRoles.USER }).lean();
+    expect(updatedRole[PermissionTypes.PROMPTS]).toEqual({
+      CREATE: true,
+      USE: true,
+      SHARED_GLOBAL: true,
+    });
+  });
+
+  it('should not update permissions when no changes are needed', async () => {
+    await new Role({
+      name: SystemRoles.USER,
+      [PermissionTypes.PROMPTS]: {
+        CREATE: true,
+        USE: true,
+        SHARED_GLOBAL: false,
+      },
+    }).save();
+
+    await updateAccessPermissions(SystemRoles.USER, {
+      [PermissionTypes.PROMPTS]: {
+        CREATE: true,
+        USE: true,
+        SHARED_GLOBAL: false,
+      },
+    });
+
+    const updatedRole = await Role.findOne({ name: SystemRoles.USER }).lean();
+    expect(updatedRole[PermissionTypes.PROMPTS]).toEqual({
+      CREATE: true,
+      USE: true,
+      SHARED_GLOBAL: false,
+    });
+  });
+
+  it('should handle non-existent roles', async () => {
+    await updateAccessPermissions('NON_EXISTENT_ROLE', {
+      [PermissionTypes.PROMPTS]: {
+        CREATE: true,
+      },
+    });
+
+    const role = await Role.findOne({ name: 'NON_EXISTENT_ROLE' });
+    expect(role).toBeNull();
+  });
+
+  it('should update only specified permissions', async () => {
+    await new Role({
+      name: SystemRoles.USER,
+      [PermissionTypes.PROMPTS]: {
+        CREATE: true,
+        USE: true,
+        SHARED_GLOBAL: false,
+      },
+    }).save();
+
+    await updateAccessPermissions(SystemRoles.USER, {
+      [PermissionTypes.PROMPTS]: {
+        SHARED_GLOBAL: true,
+      },
+    });
+
+    const updatedRole = await Role.findOne({ name: SystemRoles.USER }).lean();
+    expect(updatedRole[PermissionTypes.PROMPTS]).toEqual({
+      CREATE: true,
+      USE: true,
+      SHARED_GLOBAL: true,
+    });
+  });
+
+  it('should handle partial updates', async () => {
+    await new Role({
+      name: SystemRoles.USER,
+      [PermissionTypes.PROMPTS]: {
+        CREATE: true,
+        USE: true,
+        SHARED_GLOBAL: false,
+      },
+    }).save();
+
+    await updateAccessPermissions(SystemRoles.USER, {
+      [PermissionTypes.PROMPTS]: {
+        USE: false,
+      },
+    });
+
+    const updatedRole = await Role.findOne({ name: SystemRoles.USER }).lean();
+    expect(updatedRole[PermissionTypes.PROMPTS]).toEqual({
+      CREATE: true,
+      USE: false,
+      SHARED_GLOBAL: false,
+    });
+  });
+
+  it('should update multiple permission types at once', async () => {
+    await new Role({
+      name: SystemRoles.USER,
+      [PermissionTypes.PROMPTS]: {
+        CREATE: true,
+        USE: true,
+        SHARED_GLOBAL: false,
+      },
+      [PermissionTypes.BOOKMARKS]: {
+        USE: true,
+      },
+    }).save();
+
+    await updateAccessPermissions(SystemRoles.USER, {
+      [PermissionTypes.PROMPTS]: { USE: false, SHARED_GLOBAL: true },
+      [PermissionTypes.BOOKMARKS]: { USE: false },
+    });
+
+    const updatedRole = await Role.findOne({ name: SystemRoles.USER }).lean();
+    expect(updatedRole[PermissionTypes.PROMPTS]).toEqual({
+      CREATE: true,
+      USE: false,
+      SHARED_GLOBAL: true,
+    });
+    expect(updatedRole[PermissionTypes.BOOKMARKS]).toEqual({
+      USE: false,
+    });
+  });
+
+  it('should handle updates for a single permission type', async () => {
+    await new Role({
+      name: SystemRoles.USER,
+      [PermissionTypes.PROMPTS]: {
+        CREATE: true,
+        USE: true,
+        SHARED_GLOBAL: false,
+      },
+    }).save();
+
+    await updateAccessPermissions(SystemRoles.USER, {
+      [PermissionTypes.PROMPTS]: { USE: false, SHARED_GLOBAL: true },
+    });
+
+    const updatedRole = await Role.findOne({ name: SystemRoles.USER }).lean();
+    expect(updatedRole[PermissionTypes.PROMPTS]).toEqual({
+      CREATE: true,
+      USE: false,
+      SHARED_GLOBAL: true,
+    });
+  });
+});

api/models/schema/defaults.js

@@ -74,6 +74,10 @@ const conversationPreset = {
   resendImages: {
     type: Boolean,
   },
+  /* Anthropic only */
+  promptCache: {
+    type: Boolean,
+  },
   // files
   resendFiles: {
     type: Boolean,

api/server/index.js

@@ -16,9 +16,9 @@ const validateImageRequest = require('./middleware/validateImageRequest');
 const errorController = require('./controllers/ErrorController');
 const configureSocialLogins = require('./socialLogins');
 const AppService = require('./services/AppService');
+const staticCache = require('./utils/staticCache');
 const noIndex = require('./middleware/noIndex');
 const routes = require('./routes');
-const staticCache = require('./utils/staticCache');
 
 const { PORT, HOST, ALLOW_SOCIAL_LOGIN, DISABLE_COMPRESSION } = process.env ?? {};
 
@@ -51,7 +51,7 @@ const startServer = async () => {
   app.set('trust proxy', 1); /* trust first proxy */
   app.use(cors());
 
-  if (DISABLE_COMPRESSION !== 'true') {
+  if (!isEnabled(DISABLE_COMPRESSION)) {
     app.use(compression());
   }
 

api/server/services/AppService.interface.spec.js

@@ -1,6 +1,6 @@
 jest.mock('~/models/Role', () => ({
   initializeRoles: jest.fn(),
-  updatePromptsAccess: jest.fn(),
+  updateAccessPermissions: jest.fn(),
   getRoleByName: jest.fn(),
   updateRoleByName: jest.fn(),
 }));
@@ -30,7 +30,7 @@ jest.mock('./start/checks', () => ({
 const AppService = require('./AppService');
 const { loadDefaultInterface } = require('./start/interface');
 
-describe('AppService interface.prompts configuration', () => {
+describe('AppService interface configuration', () => {
   let app;
   let mockLoadCustomConfig;
 
@@ -41,33 +41,47 @@ describe('AppService interface.prompts configuration', () => {
     mockLoadCustomConfig = require('./Config/loadCustomConfig');
   });
 
-  it('should set prompts to true when loadDefaultInterface returns true', async () => {
+  it('should set prompts and bookmarks to true when loadDefaultInterface returns true for both', async () => {
     mockLoadCustomConfig.mockResolvedValue({});
-    loadDefaultInterface.mockResolvedValue({ prompts: true });
+    loadDefaultInterface.mockResolvedValue({ prompts: true, bookmarks: true });
 
     await AppService(app);
 
     expect(app.locals.interfaceConfig.prompts).toBe(true);
+    expect(app.locals.interfaceConfig.bookmarks).toBe(true);
     expect(loadDefaultInterface).toHaveBeenCalled();
   });
 
-  it('should set prompts to false when loadDefaultInterface returns false', async () => {
-    mockLoadCustomConfig.mockResolvedValue({ interface: { prompts: false } });
-    loadDefaultInterface.mockResolvedValue({ prompts: false });
+  it('should set prompts and bookmarks to false when loadDefaultInterface returns false for both', async () => {
+    mockLoadCustomConfig.mockResolvedValue({ interface: { prompts: false, bookmarks: false } });
+    loadDefaultInterface.mockResolvedValue({ prompts: false, bookmarks: false });
 
     await AppService(app);
 
     expect(app.locals.interfaceConfig.prompts).toBe(false);
+    expect(app.locals.interfaceConfig.bookmarks).toBe(false);
     expect(loadDefaultInterface).toHaveBeenCalled();
   });
 
-  it('should not set prompts when loadDefaultInterface returns undefined', async () => {
+  it('should not set prompts and bookmarks when loadDefaultInterface returns undefined for both', async () => {
     mockLoadCustomConfig.mockResolvedValue({});
     loadDefaultInterface.mockResolvedValue({});
 
     await AppService(app);
 
     expect(app.locals.interfaceConfig.prompts).toBeUndefined();
+    expect(app.locals.interfaceConfig.bookmarks).toBeUndefined();
+    expect(loadDefaultInterface).toHaveBeenCalled();
+  });
+
+  it('should set prompts and bookmarks to different values when loadDefaultInterface returns different values', async () => {
+    mockLoadCustomConfig.mockResolvedValue({ interface: { prompts: true, bookmarks: false } });
+    loadDefaultInterface.mockResolvedValue({ prompts: true, bookmarks: false });
+
+    await AppService(app);
+
+    expect(app.locals.interfaceConfig.prompts).toBe(true);
+    expect(app.locals.interfaceConfig.bookmarks).toBe(false);
     expect(loadDefaultInterface).toHaveBeenCalled();
   });
 });

api/server/services/AppService.spec.js

@@ -23,8 +23,7 @@ jest.mock('./Files/Firebase/initialize', () => ({
 }));
 jest.mock('~/models/Role', () => ({
   initializeRoles: jest.fn(),
-  updatePromptsAccess: jest.fn(),
-  updateBookmarksAccess: jest.fn(),
+  updateAccessPermissions: jest.fn(),
 }));
 jest.mock('./ToolService', () => ({
   loadAndFormatTools: jest.fn().mockReturnValue({

api/server/services/Endpoints/anthropic/buildOptions.js

@@ -6,6 +6,7 @@ const buildOptions = (endpoint, parsedBody) => {
     promptPrefix,
     maxContextTokens,
     resendFiles = true,
+    promptCache = true,
     iconURL,
     greeting,
     spec,
@@ -17,6 +18,7 @@ const buildOptions = (endpoint, parsedBody) => {
     modelLabel,
     promptPrefix,
     resendFiles,
+    promptCache,
     iconURL,
     greeting,
     spec,

api/server/services/start/interface.js

@@ -1,5 +1,10 @@
-const { SystemRoles, Permissions, removeNullishValues } = require('librechat-data-provider');
-const { updatePromptsAccess, updateBookmarksAccess } = require('~/models/Role');
+const {
+  SystemRoles,
+  Permissions,
+  PermissionTypes,
+  removeNullishValues,
+} = require('librechat-data-provider');
+const { updateAccessPermissions } = require('~/models/Role');
 const { logger } = require('~/config');
 
 /**
@@ -28,8 +33,10 @@ async function loadDefaultInterface(config, configDefaults, roleName = SystemRol
     prompts: interfaceConfig?.prompts ?? defaults.prompts,
   });
 
-  await updatePromptsAccess(roleName, { [Permissions.USE]: loadedInterface.prompts });
-  await updateBookmarksAccess(roleName, { [Permissions.USE]: loadedInterface.bookmarks });
+  await updateAccessPermissions(roleName, {
+    [PermissionTypes.PROMPTS]: { [Permissions.USE]: loadedInterface.prompts },
+    [PermissionTypes.BOOKMARKS]: { [Permissions.USE]: loadedInterface.bookmarks },
+  });
 
   let i = 0;
   const logSettings = () => {

api/server/services/start/interface.spec.js

@@ -1,52 +1,81 @@
-const { SystemRoles, Permissions } = require('librechat-data-provider');
-const { updatePromptsAccess } = require('~/models/Role');
+const { SystemRoles, Permissions, PermissionTypes } = require('librechat-data-provider');
+const { updateAccessPermissions } = require('~/models/Role');
 const { loadDefaultInterface } = require('./interface');
 
 jest.mock('~/models/Role', () => ({
-  updatePromptsAccess: jest.fn(),
-  updateBookmarksAccess: jest.fn(),
+  updateAccessPermissions: jest.fn(),
 }));
 
 describe('loadDefaultInterface', () => {
-  it('should call updatePromptsAccess with the correct parameters when prompts is true', async () => {
-    const config = { interface: { prompts: true } };
+  it('should call updateAccessPermissions with the correct parameters when prompts and bookmarks are true', async () => {
+    const config = { interface: { prompts: true, bookmarks: true } };
     const configDefaults = { interface: {} };
 
     await loadDefaultInterface(config, configDefaults);
 
-    expect(updatePromptsAccess).toHaveBeenCalledWith(SystemRoles.USER, { [Permissions.USE]: true });
-  });
-
-  it('should call updatePromptsAccess with false when prompts is false', async () => {
-    const config = { interface: { prompts: false } };
-    const configDefaults = { interface: {} };
-
-    await loadDefaultInterface(config, configDefaults);
-
-    expect(updatePromptsAccess).toHaveBeenCalledWith(SystemRoles.USER, {
-      [Permissions.USE]: false,
+    expect(updateAccessPermissions).toHaveBeenCalledWith(SystemRoles.USER, {
+      [PermissionTypes.PROMPTS]: { [Permissions.USE]: true },
+      [PermissionTypes.BOOKMARKS]: { [Permissions.USE]: true },
     });
   });
 
-  it('should call updatePromptsAccess with undefined when prompts is not specified in config', async () => {
+  it('should call updateAccessPermissions with false when prompts and bookmarks are false', async () => {
+    const config = { interface: { prompts: false, bookmarks: false } };
+    const configDefaults = { interface: {} };
+
+    await loadDefaultInterface(config, configDefaults);
+
+    expect(updateAccessPermissions).toHaveBeenCalledWith(SystemRoles.USER, {
+      [PermissionTypes.PROMPTS]: { [Permissions.USE]: false },
+      [PermissionTypes.BOOKMARKS]: { [Permissions.USE]: false },
+    });
+  });
+
+  it('should call updateAccessPermissions with undefined when prompts and bookmarks are not specified in config', async () => {
     const config = {};
     const configDefaults = { interface: {} };
 
     await loadDefaultInterface(config, configDefaults);
 
-    expect(updatePromptsAccess).toHaveBeenCalledWith(SystemRoles.USER, {
-      [Permissions.USE]: undefined,
+    expect(updateAccessPermissions).toHaveBeenCalledWith(SystemRoles.USER, {
+      [PermissionTypes.PROMPTS]: { [Permissions.USE]: undefined },
+      [PermissionTypes.BOOKMARKS]: { [Permissions.USE]: undefined },
     });
   });
 
-  it('should call updatePromptsAccess with undefined when prompts is explicitly undefined', async () => {
-    const config = { interface: { prompts: undefined } };
+  it('should call updateAccessPermissions with undefined when prompts and bookmarks are explicitly undefined', async () => {
+    const config = { interface: { prompts: undefined, bookmarks: undefined } };
     const configDefaults = { interface: {} };
 
     await loadDefaultInterface(config, configDefaults);
 
-    expect(updatePromptsAccess).toHaveBeenCalledWith(SystemRoles.USER, {
-      [Permissions.USE]: undefined,
+    expect(updateAccessPermissions).toHaveBeenCalledWith(SystemRoles.USER, {
+      [PermissionTypes.PROMPTS]: { [Permissions.USE]: undefined },
+      [PermissionTypes.BOOKMARKS]: { [Permissions.USE]: undefined },
+    });
+  });
+
+  it('should call updateAccessPermissions with mixed values for prompts and bookmarks', async () => {
+    const config = { interface: { prompts: true, bookmarks: false } };
+    const configDefaults = { interface: {} };
+
+    await loadDefaultInterface(config, configDefaults);
+
+    expect(updateAccessPermissions).toHaveBeenCalledWith(SystemRoles.USER, {
+      [PermissionTypes.PROMPTS]: { [Permissions.USE]: true },
+      [PermissionTypes.BOOKMARKS]: { [Permissions.USE]: false },
+    });
+  });
+
+  it('should call updateAccessPermissions with true when config is undefined', async () => {
+    const config = undefined;
+    const configDefaults = { interface: { prompts: true, bookmarks: true } };
+
+    await loadDefaultInterface(config, configDefaults);
+
+    expect(updateAccessPermissions).toHaveBeenCalledWith(SystemRoles.USER, {
+      [PermissionTypes.PROMPTS]: { [Permissions.USE]: true },
+      [PermissionTypes.BOOKMARKS]: { [Permissions.USE]: true },
     });
   });
 });

api/server/utils/staticCache.js

@@ -1,9 +1,9 @@
 const express = require('express');
 
-const oneWeekInSeconds = 24 * 60 * 60 * 7;
+const oneDayInSeconds = 24 * 60 * 60;
 
-const sMaxAge = process.env.STATIC_CACHE_S_MAX_AGE || oneWeekInSeconds;
-const maxAge = process.env.STATIC_CACHE_MAX_AGE || oneWeekInSeconds * 4;
+const sMaxAge = process.env.STATIC_CACHE_S_MAX_AGE || oneDayInSeconds;
+const maxAge = process.env.STATIC_CACHE_MAX_AGE || oneDayInSeconds * 2;
 
 const staticCache = (staticPath) =>
   express.static(staticPath, {