📂 refactor: Cleanup File Filtering Logic, Improve Validation (#10414)

* feat: add filterFilesByEndpointConfig to filter disabled file processing by provider

* chore: explicit define of endpointFileConfig for better debugging

* refactor: move `normalizeEndpointName` to data-provider as used app-wide

* chore: remove overrideEndpoint from useFileHandling

* refactor: improve endpoint file config selection

* refactor: update filterFilesByEndpointConfig to accept structured parameters and improve endpoint file config handling

* refactor: replace defaultFileConfig with getEndpointFileConfig for improved file configuration handling across components

* test: add comprehensive unit tests for getEndpointFileConfig to validate endpoint configuration handling

* refactor: streamline agent endpoint assignment and improve file filtering logic

* feat: add error handling for disabled file uploads in endpoint configuration

* refactor: update encodeAndFormat functions to accept structured parameters for provider and endpoint

* refactor: streamline requestFiles handling in initializeAgent function

* fix: getEndpointFileConfig partial config merging scenarios

* refactor: enhance mergeWithDefault function to support document-supported providers with comprehensive MIME types

* refactor: user-configured default file config in getEndpointFileConfig

* fix: prevent file handling when endpoint is disabled and file is dragged to chat

* refactor: move `getEndpointField` to `data-provider` and update usage across components and hooks

* fix: prioritize endpointType based on agent.endpoint in file filtering logic

* fix: prioritize agent.endpoint in file filtering logic and remove unnecessary endpointType defaulting

packages/api/src/files/encode/audio.ts

@@ -9,16 +9,19 @@ import { validateAudio } from '~/files/validation';
  * Encodes and formats audio files for different providers
  * @param req - The request object
  * @param files - Array of audio files
- * @param provider - The provider to format for (currently only google is supported)
+ * @param params - Object containing provider and optional endpoint
+ * @param params.provider - The provider to format for (currently only google is supported)
+ * @param params.endpoint - Optional endpoint name for file config lookup
  * @param getStrategyFunctions - Function to get strategy functions
  * @returns Promise that resolves to audio and file metadata
  */
 export async function encodeAndFormatAudios(
   req: ServerRequest,
   files: IMongoFile[],
-  provider: Providers,
+  params: { provider: Providers; endpoint?: string },
   getStrategyFunctions: (source: string) => StrategyFunctions,
 ): Promise<AudioResult> {
+  const { provider, endpoint } = params;
   if (!files?.length) {
     return { audios: [], files: [] };
   }
@@ -54,7 +57,10 @@ export async function encodeAndFormatAudios(
     const audioBuffer = Buffer.from(content, 'base64');
 
     /** Extract configured file size limit from fileConfig for this endpoint */
-    const configuredFileSizeLimit = getConfiguredFileSizeLimit(req, provider);
+    const configuredFileSizeLimit = getConfiguredFileSizeLimit(req, {
+      provider,
+      endpoint,
+    });
 
     const validation = await validateAudio(
       audioBuffer,

packages/api/src/files/encode/document.spec.ts

@@ -31,14 +31,16 @@ describe('encodeAndFormatDocuments - fileConfig integration', () => {
   beforeEach(() => {
     jest.clearAllMocks();
     /** Default mock implementation for getConfiguredFileSizeLimit */
-    mockedGetConfiguredFileSizeLimit.mockImplementation((req, provider) => {
+    mockedGetConfiguredFileSizeLimit.mockImplementation((req, params) => {
       if (!req.config?.fileConfig) {
         return undefined;
       }
+      const { provider, endpoint } = params;
+      const lookupKey = endpoint ?? provider;
       const fileConfig = req.config.fileConfig;
       const endpoints = fileConfig.endpoints;
-      if (endpoints?.[provider]) {
-        const limit = endpoints[provider].fileSizeLimit;
+      if (endpoints?.[lookupKey]) {
+        const limit = endpoints[lookupKey].fileSizeLimit;
         return limit !== undefined ? mbToBytes(limit) : undefined;
       }
       if (endpoints?.default) {

packages/api/src/files/encode/document.ts

@@ -14,16 +14,20 @@ import { validatePdf } from '~/files/validation';
  * Processes and encodes document files for various providers
  * @param req - Express request object
  * @param files - Array of file objects to process
- * @param provider - The provider name
+ * @param params - Object containing provider, endpoint, and other options
+ * @param params.provider - The provider name
+ * @param params.endpoint - Optional endpoint name for file config lookup
+ * @param params.useResponsesApi - Whether to use responses API format
  * @param getStrategyFunctions - Function to get strategy functions
  * @returns Promise that resolves to documents and file metadata
  */
 export async function encodeAndFormatDocuments(
   req: ServerRequest,
   files: IMongoFile[],
-  { provider, useResponsesApi }: { provider: Providers; useResponsesApi?: boolean },
+  params: { provider: Providers; endpoint?: string; useResponsesApi?: boolean },
   getStrategyFunctions: (source: string) => StrategyFunctions,
 ): Promise<DocumentResult> {
+  const { provider, endpoint, useResponsesApi } = params;
   if (!files?.length) {
     return { documents: [], files: [] };
   }
@@ -68,7 +72,10 @@ export async function encodeAndFormatDocuments(
       const pdfBuffer = Buffer.from(content, 'base64');
 
       /** Extract configured file size limit from fileConfig for this endpoint */
-      const configuredFileSizeLimit = getConfiguredFileSizeLimit(req, provider);
+      const configuredFileSizeLimit = getConfiguredFileSizeLimit(req, {
+        provider,
+        endpoint,
+      });
 
       const validation = await validatePdf(
         pdfBuffer,

packages/api/src/files/encode/utils.ts

@@ -1,24 +1,33 @@
 import getStream from 'get-stream';
 import { Providers } from '@librechat/agents';
-import { FileSources, mergeFileConfig } from 'librechat-data-provider';
+import { FileSources, mergeFileConfig, getEndpointFileConfig } from 'librechat-data-provider';
 import type { IMongoFile } from '@librechat/data-schemas';
 import type { ServerRequest, StrategyFunctions, ProcessedFile } from '~/types';
 
 /**
  * Extracts the configured file size limit for a specific provider from fileConfig
  * @param req - The server request object containing config
- * @param provider - The provider to get the limit for
+ * @param params - Object containing provider and optional endpoint
+ * @param params.provider - The provider to get the limit for
+ * @param params.endpoint - Optional endpoint name for lookup
  * @returns The configured file size limit in bytes, or undefined if not configured
  */
 export const getConfiguredFileSizeLimit = (
   req: ServerRequest,
-  provider: Providers,
+  params: {
+    provider: Providers;
+    endpoint?: string;
+  },
 ): number | undefined => {
   if (!req.config?.fileConfig) {
     return undefined;
   }
+  const { provider, endpoint } = params;
   const fileConfig = mergeFileConfig(req.config.fileConfig);
-  const endpointConfig = fileConfig.endpoints[provider] ?? fileConfig.endpoints.default;
+  const endpointConfig = getEndpointFileConfig({
+    fileConfig,
+    endpoint: endpoint ?? provider,
+  });
   return endpointConfig?.fileSizeLimit;
 };
 

packages/api/src/files/encode/video.ts

@@ -9,16 +9,19 @@ import { validateVideo } from '~/files/validation';
  * Encodes and formats video files for different providers
  * @param req - The request object
  * @param files - Array of video files
- * @param provider - The provider to format for
+ * @param params - Object containing provider and optional endpoint
+ * @param params.provider - The provider to format for
+ * @param params.endpoint - Optional endpoint name for file config lookup
  * @param getStrategyFunctions - Function to get strategy functions
  * @returns Promise that resolves to videos and file metadata
  */
 export async function encodeAndFormatVideos(
   req: ServerRequest,
   files: IMongoFile[],
-  provider: Providers,
+  params: { provider: Providers; endpoint?: string },
   getStrategyFunctions: (source: string) => StrategyFunctions,
 ): Promise<VideoResult> {
+  const { provider, endpoint } = params;
   if (!files?.length) {
     return { videos: [], files: [] };
   }
@@ -54,7 +57,10 @@ export async function encodeAndFormatVideos(
     const videoBuffer = Buffer.from(content, 'base64');
 
     /** Extract configured file size limit from fileConfig for this endpoint */
-    const configuredFileSizeLimit = getConfiguredFileSizeLimit(req, provider);
+    const configuredFileSizeLimit = getConfiguredFileSizeLimit(req, {
+      provider,
+      endpoint,
+    });
 
     const validation = await validateVideo(
       videoBuffer,