🛜 refactor: Streamline App Config Usage (#9234)

* WIP: app.locals refactoring

WIP: appConfig

fix: update memory configuration retrieval to use getAppConfig based on user role

fix: update comment for AppConfig interface to clarify purpose

🏷️ refactor: Update tests to use getAppConfig for endpoint configurations

ci: Update AppService tests to initialize app config instead of app.locals

ci: Integrate getAppConfig into remaining tests

refactor: Update multer storage destination to use promise-based getAppConfig and improve error handling in tests

refactor: Rename initializeAppConfig to setAppConfig and update related tests

ci: Mock getAppConfig in various tests to provide default configurations

refactor: Update convertMCPToolsToPlugins to use mcpManager for server configuration and adjust related tests

chore: rename `Config/getAppConfig` -> `Config/app`

fix: streamline OpenAI image tools configuration by removing direct appConfig dependency and using function parameters

chore: correct parameter documentation for imageOutputType in ToolService.js

refactor: remove `getCustomConfig` dependency in config route

refactor: update domain validation to use appConfig for allowed domains

refactor: use appConfig registration property

chore: remove app parameter from AppService invocation

refactor: update AppConfig interface to correct registration and turnstile configurations

refactor: remove getCustomConfig dependency and use getAppConfig in PluginController, multer, and MCP services

refactor: replace getCustomConfig with getAppConfig in STTService, TTSService, and related files

refactor: replace getCustomConfig with getAppConfig in Conversation and Message models, update tempChatRetention functions to use AppConfig type

refactor: update getAppConfig calls in Conversation and Message models to include user role for temporary chat expiration

ci: update related tests

refactor: update getAppConfig call in getCustomConfigSpeech to include user role

fix: update appConfig usage to access allowedDomains from actions instead of registration

refactor: enhance AppConfig to include fileStrategies and update related file strategy logic

refactor: update imports to use normalizeEndpointName from @librechat/api and remove redundant definitions

chore: remove deprecated unused RunManager

refactor: get balance config primarily from appConfig

refactor: remove customConfig dependency for appConfig and streamline loadConfigModels logic

refactor: remove getCustomConfig usage and use app config in file citations

refactor: consolidate endpoint loading logic into loadEndpoints function

refactor: update appConfig access to use endpoints structure across various services

refactor: implement custom endpoints configuration and streamline endpoint loading logic

refactor: update getAppConfig call to include user role parameter

refactor: streamline endpoint configuration and enhance appConfig usage across services

refactor: replace getMCPAuthMap with getUserMCPAuthMap and remove unused getCustomConfig file

refactor: add type annotation for loadedEndpoints in loadEndpoints function

refactor: move /services/Files/images/parse to TS API

chore: add missing FILE_CITATIONS permission to IRole interface

refactor: restructure toolkits to TS API

refactor: separate manifest logic into its own module

refactor: consolidate tool loading logic into a new tools module for startup logic

refactor: move interface config logic to TS API

refactor: migrate checkEmailConfig to TypeScript and update imports

refactor: add FunctionTool interface and availableTools to AppConfig

refactor: decouple caching and DB operations from AppService, make part of consolidated `getAppConfig`

WIP: fix tests

* fix: rebase conflicts

* refactor: remove app.locals references

* refactor: replace getBalanceConfig with getAppConfig in various strategies and middleware

* refactor: replace appConfig?.balance with getBalanceConfig in various controllers and clients

* test: add balance configuration to titleConvo method in AgentClient tests

* chore: remove unused `openai-chat-tokens` package

* chore: remove unused imports in initializeMCPs.js

* refactor: update balance configuration to use getAppConfig instead of getBalanceConfig

* refactor: integrate configMiddleware for centralized configuration handling

* refactor: optimize email domain validation by removing unnecessary async calls

* refactor: simplify multer storage configuration by removing async calls

* refactor: reorder imports for better readability in user.js

* refactor: replace getAppConfig calls with req.config for improved performance

* chore: replace getAppConfig calls with req.config in tests for centralized configuration handling

* chore: remove unused override config

* refactor: add configMiddleware to endpoint route and replace getAppConfig with req.config

* chore: remove customConfig parameter from TTSService constructor

* refactor: pass appConfig from request to processFileCitations for improved configuration handling

* refactor: remove configMiddleware from endpoint route and retrieve appConfig directly in getEndpointsConfig if not in `req.config`

* test: add mockAppConfig to processFileCitations tests for improved configuration handling

* fix: pass req.config to hasCustomUserVars and call without await after synchronous refactor

* fix: type safety in useExportConversation

* refactor: retrieve appConfig using getAppConfig in PluginController and remove configMiddleware from plugins route, to avoid always retrieving when plugins are cached

* chore: change `MongoUser` typedef to `IUser`

* fix: Add `user` and `config` fields to ServerRequest and update JSDoc type annotations from Express.Request to ServerRequest

* fix: remove unused setAppConfig mock from Server configuration tests

packages/api/src/app/config.ts

@@ -0,0 +1,43 @@
+import { EModelEndpoint, removeNullishValues } from 'librechat-data-provider';
+import type { TCustomConfig, TEndpoint } from 'librechat-data-provider';
+import type { AppConfig } from '~/types';
+import { isEnabled, normalizeEndpointName } from '~/utils';
+
+/**
+ * Retrieves the balance configuration object
+ * */
+export function getBalanceConfig(appConfig?: AppConfig): Partial<TCustomConfig['balance']> | null {
+  const isLegacyEnabled = isEnabled(process.env.CHECK_BALANCE);
+  const startBalance = process.env.START_BALANCE;
+  /** @type {} */
+  const config: Partial<TCustomConfig['balance']> = removeNullishValues({
+    enabled: isLegacyEnabled,
+    startBalance: startBalance != null && startBalance ? parseInt(startBalance, 10) : undefined,
+  });
+  if (!appConfig) {
+    return config;
+  }
+  return { ...config, ...(appConfig?.['balance'] ?? {}) };
+}
+
+export const getCustomEndpointConfig = ({
+  endpoint,
+  appConfig,
+}: {
+  endpoint: string | EModelEndpoint;
+  appConfig?: AppConfig;
+}): Partial<TEndpoint> | undefined => {
+  if (!appConfig) {
+    throw new Error(`Config not found for the ${endpoint} custom endpoint.`);
+  }
+
+  const customEndpoints = appConfig.endpoints?.[EModelEndpoint.custom] ?? [];
+  return customEndpoints.find(
+    (endpointConfig) => normalizeEndpointName(endpointConfig.name) === endpoint,
+  );
+};
+
+export function hasCustomUserVars(appConfig?: AppConfig): boolean {
+  const mcpServers = appConfig?.mcpConfig;
+  return Object.values(mcpServers ?? {}).some((server) => server.customUserVars);
+}

packages/api/src/app/index.ts

@@ -0,0 +1,3 @@
+export * from './config';
+export * from './interface';
+export * from './permissions';

packages/api/src/app/interface.ts

@@ -0,0 +1,108 @@
+import { logger } from '@librechat/data-schemas';
+import { removeNullishValues } from 'librechat-data-provider';
+import type { TCustomConfig, TConfigDefaults } from 'librechat-data-provider';
+import type { AppConfig } from '~/types/config';
+import { isMemoryEnabled } from '~/memory/config';
+
+/**
+ * Loads the default interface object.
+ * @param params - The loaded custom configuration.
+ * @param params.config - The loaded custom configuration.
+ * @param params.configDefaults - The custom configuration default values.
+ * @returns default interface object.
+ */
+export async function loadDefaultInterface({
+  config,
+  configDefaults,
+}: {
+  config?: Partial<TCustomConfig>;
+  configDefaults: TConfigDefaults;
+}): Promise<AppConfig['interfaceConfig']> {
+  const { interface: interfaceConfig } = config ?? {};
+  const { interface: defaults } = configDefaults;
+  const hasModelSpecs = (config?.modelSpecs?.list?.length ?? 0) > 0;
+  const includesAddedEndpoints = (config?.modelSpecs?.addedEndpoints?.length ?? 0) > 0;
+
+  const memoryConfig = config?.memory;
+  const memoryEnabled = isMemoryEnabled(memoryConfig);
+  /** Only disable memories if memory config is present but disabled/invalid */
+  const shouldDisableMemories = memoryConfig && !memoryEnabled;
+
+  const loadedInterface: AppConfig['interfaceConfig'] = removeNullishValues({
+    // UI elements - use schema defaults
+    endpointsMenu:
+      interfaceConfig?.endpointsMenu ?? (hasModelSpecs ? false : defaults.endpointsMenu),
+    modelSelect:
+      interfaceConfig?.modelSelect ??
+      (hasModelSpecs ? includesAddedEndpoints : defaults.modelSelect),
+    parameters: interfaceConfig?.parameters ?? (hasModelSpecs ? false : defaults.parameters),
+    presets: interfaceConfig?.presets ?? (hasModelSpecs ? false : defaults.presets),
+    sidePanel: interfaceConfig?.sidePanel ?? defaults.sidePanel,
+    privacyPolicy: interfaceConfig?.privacyPolicy ?? defaults.privacyPolicy,
+    termsOfService: interfaceConfig?.termsOfService ?? defaults.termsOfService,
+    mcpServers: interfaceConfig?.mcpServers ?? defaults.mcpServers,
+    customWelcome: interfaceConfig?.customWelcome ?? defaults.customWelcome,
+
+    // Permissions - only include if explicitly configured
+    bookmarks: interfaceConfig?.bookmarks,
+    memories: shouldDisableMemories ? false : interfaceConfig?.memories,
+    prompts: interfaceConfig?.prompts,
+    multiConvo: interfaceConfig?.multiConvo,
+    agents: interfaceConfig?.agents,
+    temporaryChat: interfaceConfig?.temporaryChat,
+    runCode: interfaceConfig?.runCode,
+    webSearch: interfaceConfig?.webSearch,
+    fileSearch: interfaceConfig?.fileSearch,
+    fileCitations: interfaceConfig?.fileCitations,
+    peoplePicker: interfaceConfig?.peoplePicker,
+    marketplace: interfaceConfig?.marketplace,
+  });
+
+  let i = 0;
+  const logSettings = () => {
+    // log interface object and model specs object (without list) for reference
+    logger.warn(`\`interface\` settings:\n${JSON.stringify(loadedInterface, null, 2)}`);
+    logger.warn(
+      `\`modelSpecs\` settings:\n${JSON.stringify(
+        { ...(config?.modelSpecs ?? {}), list: undefined },
+        null,
+        2,
+      )}`,
+    );
+  };
+
+  // warn about config.modelSpecs.prioritize if true and presets are enabled, that default presets will conflict with prioritizing model specs.
+  if (config?.modelSpecs?.prioritize && loadedInterface.presets) {
+    logger.warn(
+      "Note: Prioritizing model specs can conflict with default presets if a default preset is set. It's recommended to disable presets from the interface or disable use of a default preset.",
+    );
+    if (i === 0) i++;
+  }
+
+  // warn about config.modelSpecs.enforce if true and if any of these, endpointsMenu, modelSelect, presets, or parameters are enabled, that enforcing model specs can conflict with these options.
+  if (
+    config?.modelSpecs?.enforce &&
+    (loadedInterface.endpointsMenu ||
+      loadedInterface.modelSelect ||
+      loadedInterface.presets ||
+      loadedInterface.parameters)
+  ) {
+    logger.warn(
+      "Note: Enforcing model specs can conflict with the interface options: endpointsMenu, modelSelect, presets, and parameters. It's recommended to disable these options from the interface or disable enforcing model specs.",
+    );
+    if (i === 0) i++;
+  }
+  // warn if enforce is true and prioritize is not, that enforcing model specs without prioritizing them can lead to unexpected behavior.
+  if (config?.modelSpecs?.enforce && !config?.modelSpecs?.prioritize) {
+    logger.warn(
+      "Note: Enforcing model specs without prioritizing them can lead to unexpected behavior. It's recommended to enable prioritizing model specs if enforcing them.",
+    );
+    if (i === 0) i++;
+  }
+
+  if (i > 0) {
+    logSettings();
+  }
+
+  return loadedInterface;
+}

packages/api/src/app/permissions.ts

@@ -0,0 +1,234 @@
+import { logger } from '@librechat/data-schemas';
+import {
+  SystemRoles,
+  Permissions,
+  roleDefaults,
+  PermissionTypes,
+  getConfigDefaults,
+} from 'librechat-data-provider';
+import type { IRole } from '@librechat/data-schemas';
+import type { AppConfig } from '~/types/config';
+import { isMemoryEnabled } from '~/memory/config';
+
+/**
+ * Checks if a permission type has explicit configuration
+ */
+function hasExplicitConfig(
+  interfaceConfig: AppConfig['interfaceConfig'],
+  permissionType: PermissionTypes,
+) {
+  switch (permissionType) {
+    case PermissionTypes.PROMPTS:
+      return interfaceConfig?.prompts !== undefined;
+    case PermissionTypes.BOOKMARKS:
+      return interfaceConfig?.bookmarks !== undefined;
+    case PermissionTypes.MEMORIES:
+      return interfaceConfig?.memories !== undefined;
+    case PermissionTypes.MULTI_CONVO:
+      return interfaceConfig?.multiConvo !== undefined;
+    case PermissionTypes.AGENTS:
+      return interfaceConfig?.agents !== undefined;
+    case PermissionTypes.TEMPORARY_CHAT:
+      return interfaceConfig?.temporaryChat !== undefined;
+    case PermissionTypes.RUN_CODE:
+      return interfaceConfig?.runCode !== undefined;
+    case PermissionTypes.WEB_SEARCH:
+      return interfaceConfig?.webSearch !== undefined;
+    case PermissionTypes.PEOPLE_PICKER:
+      return interfaceConfig?.peoplePicker !== undefined;
+    case PermissionTypes.MARKETPLACE:
+      return interfaceConfig?.marketplace !== undefined;
+    case PermissionTypes.FILE_SEARCH:
+      return interfaceConfig?.fileSearch !== undefined;
+    case PermissionTypes.FILE_CITATIONS:
+      return interfaceConfig?.fileCitations !== undefined;
+    default:
+      return false;
+  }
+}
+
+export async function updateInterfacePermissions({
+  appConfig,
+  getRoleByName,
+  updateAccessPermissions,
+}: {
+  appConfig: AppConfig;
+  getRoleByName: (roleName: string, fieldsToSelect?: string | string[]) => Promise<IRole | null>;
+  updateAccessPermissions: (
+    roleName: string,
+    permissionsUpdate: Partial<Record<PermissionTypes, Record<string, boolean | undefined>>>,
+
+    roleData?: IRole | null,
+  ) => Promise<void>;
+}) {
+  const loadedInterface = appConfig?.interfaceConfig;
+  if (!loadedInterface) {
+    return;
+  }
+  /** Configured values for interface object structure */
+  const interfaceConfig = appConfig?.config?.interface;
+  const memoryConfig = appConfig?.config?.memory;
+  const memoryEnabled = isMemoryEnabled(memoryConfig);
+  /** Check if personalization is enabled (defaults to true if memory is configured and enabled) */
+  const isPersonalizationEnabled =
+    memoryConfig && memoryEnabled && memoryConfig.personalize !== false;
+
+  /** Helper to get permission value with proper precedence */
+  const getPermissionValue = (
+    configValue?: boolean,
+    roleDefault?: boolean,
+    schemaDefault?: boolean,
+  ) => {
+    if (configValue !== undefined) return configValue;
+    if (roleDefault !== undefined) return roleDefault;
+    return schemaDefault;
+  };
+
+  const defaults = getConfigDefaults().interface;
+
+  // Permission precedence order:
+  // 1. Explicit user configuration (from librechat.yaml)
+  // 2. Role-specific defaults (from roleDefaults)
+  // 3. Interface schema defaults (from interfaceSchema.default())
+  for (const roleName of [SystemRoles.USER, SystemRoles.ADMIN]) {
+    const defaultPerms = roleDefaults[roleName]?.permissions;
+
+    const existingRole = await getRoleByName(roleName);
+    const existingPermissions = existingRole?.permissions;
+    const permissionsToUpdate: Partial<
+      Record<PermissionTypes, Record<string, boolean | undefined>>
+    > = {};
+
+    /**
+     * Helper to add permission if it should be updated
+     */
+    const addPermissionIfNeeded = (
+      permType: PermissionTypes,
+      permissions: Record<string, boolean | undefined>,
+    ) => {
+      const permTypeExists = existingPermissions?.[permType];
+      const isExplicitlyConfigured =
+        interfaceConfig && hasExplicitConfig(interfaceConfig, permType);
+
+      // Only update if: doesn't exist OR explicitly configured
+      if (!permTypeExists || isExplicitlyConfigured) {
+        permissionsToUpdate[permType] = permissions;
+        if (!permTypeExists) {
+          logger.debug(`Role '${roleName}': Setting up default permissions for '${permType}'`);
+        } else if (isExplicitlyConfigured) {
+          logger.debug(`Role '${roleName}': Applying explicit config for '${permType}'`);
+        }
+      } else {
+        logger.debug(`Role '${roleName}': Preserving existing permissions for '${permType}'`);
+      }
+    };
+
+    const allPermissions: Partial<Record<PermissionTypes, Record<string, boolean | undefined>>> = {
+      [PermissionTypes.PROMPTS]: {
+        [Permissions.USE]: getPermissionValue(
+          loadedInterface.prompts,
+          defaultPerms[PermissionTypes.PROMPTS]?.[Permissions.USE],
+          defaults.prompts,
+        ),
+      },
+      [PermissionTypes.BOOKMARKS]: {
+        [Permissions.USE]: getPermissionValue(
+          loadedInterface.bookmarks,
+          defaultPerms[PermissionTypes.BOOKMARKS]?.[Permissions.USE],
+          defaults.bookmarks,
+        ),
+      },
+      [PermissionTypes.MEMORIES]: {
+        [Permissions.USE]: getPermissionValue(
+          loadedInterface.memories,
+          defaultPerms[PermissionTypes.MEMORIES]?.[Permissions.USE],
+          defaults.memories,
+        ),
+        [Permissions.OPT_OUT]: isPersonalizationEnabled,
+      },
+      [PermissionTypes.MULTI_CONVO]: {
+        [Permissions.USE]: getPermissionValue(
+          loadedInterface.multiConvo,
+          defaultPerms[PermissionTypes.MULTI_CONVO]?.[Permissions.USE],
+          defaults.multiConvo,
+        ),
+      },
+      [PermissionTypes.AGENTS]: {
+        [Permissions.USE]: getPermissionValue(
+          loadedInterface.agents,
+          defaultPerms[PermissionTypes.AGENTS]?.[Permissions.USE],
+          defaults.agents,
+        ),
+      },
+      [PermissionTypes.TEMPORARY_CHAT]: {
+        [Permissions.USE]: getPermissionValue(
+          loadedInterface.temporaryChat,
+          defaultPerms[PermissionTypes.TEMPORARY_CHAT]?.[Permissions.USE],
+          defaults.temporaryChat,
+        ),
+      },
+      [PermissionTypes.RUN_CODE]: {
+        [Permissions.USE]: getPermissionValue(
+          loadedInterface.runCode,
+          defaultPerms[PermissionTypes.RUN_CODE]?.[Permissions.USE],
+          defaults.runCode,
+        ),
+      },
+      [PermissionTypes.WEB_SEARCH]: {
+        [Permissions.USE]: getPermissionValue(
+          loadedInterface.webSearch,
+          defaultPerms[PermissionTypes.WEB_SEARCH]?.[Permissions.USE],
+          defaults.webSearch,
+        ),
+      },
+      [PermissionTypes.PEOPLE_PICKER]: {
+        [Permissions.VIEW_USERS]: getPermissionValue(
+          loadedInterface.peoplePicker?.users,
+          defaultPerms[PermissionTypes.PEOPLE_PICKER]?.[Permissions.VIEW_USERS],
+          defaults.peoplePicker?.users,
+        ),
+        [Permissions.VIEW_GROUPS]: getPermissionValue(
+          loadedInterface.peoplePicker?.groups,
+          defaultPerms[PermissionTypes.PEOPLE_PICKER]?.[Permissions.VIEW_GROUPS],
+          defaults.peoplePicker?.groups,
+        ),
+        [Permissions.VIEW_ROLES]: getPermissionValue(
+          loadedInterface.peoplePicker?.roles,
+          defaultPerms[PermissionTypes.PEOPLE_PICKER]?.[Permissions.VIEW_ROLES],
+          defaults.peoplePicker?.roles,
+        ),
+      },
+      [PermissionTypes.MARKETPLACE]: {
+        [Permissions.USE]: getPermissionValue(
+          loadedInterface.marketplace?.use,
+          defaultPerms[PermissionTypes.MARKETPLACE]?.[Permissions.USE],
+          defaults.marketplace?.use,
+        ),
+      },
+      [PermissionTypes.FILE_SEARCH]: {
+        [Permissions.USE]: getPermissionValue(
+          loadedInterface.fileSearch,
+          defaultPerms[PermissionTypes.FILE_SEARCH]?.[Permissions.USE],
+          defaults.fileSearch,
+        ),
+      },
+      [PermissionTypes.FILE_CITATIONS]: {
+        [Permissions.USE]: getPermissionValue(
+          loadedInterface.fileCitations,
+          defaultPerms[PermissionTypes.FILE_CITATIONS]?.[Permissions.USE],
+          defaults.fileCitations,
+        ),
+      },
+    };
+
+    // Check and add each permission type if needed
+    for (const [permType, permissions] of Object.entries(allPermissions)) {
+      addPermissionIfNeeded(permType as PermissionTypes, permissions);
+    }
+
+    // Update permissions if any need updating
+    if (Object.keys(permissionsToUpdate).length > 0) {
+      await updateAccessPermissions(roleName, permissionsToUpdate, existingRole);
+    }
+  }
+}