Skip to content

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

🖼️ feat: File Size and MIME Type Filtering at Agent level (#10446)

Danny Avila937563f645d8
diff --git a/api/server/services/Files/images/encode.js b/api/server/services/Files/images/encode.js
index ea9dc9f521..e719e58af3 100644
--- a/api/server/services/Files/images/encode.js
+++ b/api/server/services/Files/images/encode.js
@@ -1,12 +1,14 @@
const axios = require('axios');
-const { logAxiosError } = require('@librechat/api');
const { logger } = require('@librechat/data-schemas');
+const { logAxiosError, validateImage } = require('@librechat/api');
const {
FileSources,
VisionModes,
ImageDetail,
ContentTypes,
EModelEndpoint,
+ mergeFileConfig,
+ getEndpointFileConfig,
} = require('librechat-data-provider');
const { getStrategyFunctions } = require('~/server/services/Files/strategies');
@@ -152,6 +154,17 @@ async function encodeAndFormat(req, files, params, mode) {
const formattedImages = await Promise.all(promises);
promises.length = 0;
+ /** Extract configured file size limit from fileConfig for this endpoint */
+ let configuredFileSizeLimit;
+ if (req.config?.fileConfig) {
+ const fileConfig = mergeFileConfig(req.config.fileConfig);
+ const endpointConfig = getEndpointFileConfig({
+ fileConfig,
+ endpoint: effectiveEndpoint,
+ });
+ configuredFileSizeLimit = endpointConfig?.fileSizeLimit;
+ }
+
for (const [file, imageContent] of formattedImages) {
const fileMetadata = {
type: file.type,
@@ -172,6 +185,26 @@ async function encodeAndFormat(req, files, params, mode) {
continue;
}
+ /** Validate image buffer against size limits */
+ if (file.height && file.width) {
+ const imageBuffer = imageContent.startsWith('http')
+ ? null
+ : Buffer.from(imageContent, 'base64');
+
+ if (imageBuffer) {
+ const validation = await validateImage(
+ imageBuffer,
+ imageBuffer.length,
+ effectiveEndpoint,
+ configuredFileSizeLimit,
+ );
+
+ if (!validation.isValid) {
+ throw new Error(`Image validation failed for ${file.filename}: ${validation.error}`);
+ }
+ }
+ }
+
const imagePart = {
type: ContentTypes.IMAGE_URL,
image_url: {
diff --git a/packages/api/src/files/filter.spec.ts b/packages/api/src/files/filter.spec.ts
index efcd3b4f89..e7858f486f 100644
--- a/packages/api/src/files/filter.spec.ts
+++ b/packages/api/src/files/filter.spec.ts
@@ -689,4 +689,625 @@ describe('filterFilesByEndpointConfig', () => {
expect(result).toEqual([]);
});
});
+
+ describe('file size filtering', () => {
+ it('should filter out files exceeding fileSizeLimit', () => {
+ const req = {
+ config: {
+ fileConfig: {
+ endpoints: {
+ [Providers.OPENAI]: {
+ disabled: false,
+ fileSizeLimit: 5 /** 5 MB in config (gets converted to bytes) */,
+ },
+ },
+ },
+ },
+ } as unknown as ServerRequest;
+
+ const smallFile = {
+ ...createMockFile('small.pdf'),
+ bytes: 1024 * 1024 * 3 /** 3 MB */,
+ } as IMongoFile;
+
+ const largeFile = {
+ ...createMockFile('large.pdf'),
+ bytes: 1024 * 1024 * 10 /** 10 MB */,
+ } as IMongoFile;
+
+ const files = [smallFile, largeFile];
+
+ const result = filterFilesByEndpointConfig(req, {
+ files,
+ endpoint: Providers.OPENAI,
+ });
+
+ /** Only small file should pass */
+ expect(result).toEqual([smallFile]);
+ });
+
+ it('should keep all files when no fileSizeLimit is set', () => {
+ const req = {
+ config: {
+ fileConfig: {
+ endpoints: {
+ [Providers.OPENAI]: {
+ disabled: false,
+ },
+ },
+ },
+ },
+ } as unknown as ServerRequest;
+
+ const files = [
+ { ...createMockFile('file1.pdf'), bytes: 1024 * 1024 * 100 } as IMongoFile,
+ { ...createMockFile('file2.pdf'), bytes: 1024 * 1024 * 200 } as IMongoFile,
+ ];
+
+ const result = filterFilesByEndpointConfig(req, {
+ files,
+ endpoint: Providers.OPENAI,
+ });
+
+ expect(result).toEqual(files);
+ });
+
+ it('should filter all files if all exceed fileSizeLimit', () => {
+ const req = {
+ config: {
+ fileConfig: {
+ endpoints: {
+ [Providers.OPENAI]: {
+ disabled: false,
+ fileSizeLimit: 1 /** 1 MB */,
+ },
+ },
+ },
+ },
+ } as unknown as ServerRequest;
+
+ const files = [
+ { ...createMockFile('file1.pdf'), bytes: 1024 * 1024 * 5 } as IMongoFile,
+ { ...createMockFile('file2.pdf'), bytes: 1024 * 1024 * 10 } as IMongoFile,
+ ];
+
+ const result = filterFilesByEndpointConfig(req, {
+ files,
+ endpoint: Providers.OPENAI,
+ });
+
+ expect(result).toEqual([]);
+ });
+
+ it('should handle fileSizeLimit of 0 as unlimited', () => {
+ const req = {
+ config: {
+ fileConfig: {
+ endpoints: {
+ [Providers.OPENAI]: {
+ disabled: false,
+ fileSizeLimit: 0,
+ totalSizeLimit: 0 /** Also set total limit to 0 for unlimited */,
+ },
+ },
+ },
+ },
+ } as unknown as ServerRequest;
+
+ const files = [{ ...createMockFile('huge.pdf'), bytes: 1024 * 1024 * 1000 } as IMongoFile];
+
+ const result = filterFilesByEndpointConfig(req, {
+ files,
+ endpoint: Providers.OPENAI,
+ });
+
+ /** 0 means no limit, so file should pass */
+ expect(result).toEqual(files);
+ });
+ });
+
+ describe('MIME type filtering', () => {
+ it('should filter out files with unsupported MIME types', () => {
+ const req = {
+ config: {
+ fileConfig: {
+ endpoints: {
+ [Providers.OPENAI]: {
+ disabled: false,
+ supportedMimeTypes: ['^application/pdf$', '^image/png$'],
+ },
+ },
+ },
+ },
+ } as unknown as ServerRequest;
+
+ const pdfFile = {
+ ...createMockFile('doc.pdf'),
+ type: 'application/pdf',
+ } as IMongoFile;
+
+ const pngFile = {
+ ...createMockFile('image.png'),
+ type: 'image/png',
+ } as IMongoFile;
+
+ const videoFile = {
+ ...createMockFile('video.mp4'),
+ type: 'video/mp4',
+ } as IMongoFile;
+
+ const files = [pdfFile, pngFile, videoFile];
+
+ const result = filterFilesByEndpointConfig(req, {
+ files,
+ endpoint: Providers.OPENAI,
+ });
+
+ /** Only PDF and PNG should pass */
+ expect(result).toEqual([pdfFile, pngFile]);
+ });
+
+ it('should keep all files when supportedMimeTypes is not set', () => {
+ const req = {
+ config: {
+ fileConfig: {
+ endpoints: {
+ [Providers.OPENAI]: {
+ disabled: false,
+ },
+ },
+ },
+ },
+ } as unknown as ServerRequest;
+
+ const files = [
+ { ...createMockFile('doc.pdf'), type: 'application/pdf' } as IMongoFile,
+ { ...createMockFile('video.mp4'), type: 'video/mp4' } as IMongoFile,
+ { ...createMockFile('audio.mp3'), type: 'audio/mp3' } as IMongoFile,
+ ];
+
+ const result = filterFilesByEndpointConfig(req, {
+ files,
+ endpoint: Providers.OPENAI,
+ });
+
+ expect(result).toEqual(files);
+ });
+
+ it('should handle regex patterns for MIME type matching', () => {
+ const req = {
+ config: {
+ fileConfig: {
+ endpoints: {
+ [Providers.OPENAI]: {
+ disabled: false,
+ supportedMimeTypes: ['^image/.*$'] /** All image types */,
+ },
+ },
+ },
+ },
+ } as unknown as ServerRequest;
+
+ const jpegFile = {
+ ...createMockFile('photo.jpg'),
+ type: 'image/jpeg',
+ } as IMongoFile;
+
+ const pngFile = {
+ ...createMockFile('graphic.png'),
+ type: 'image/png',
+ } as IMongoFile;
+
+ const gifFile = {
+ ...createMockFile('animation.gif'),
+ type: 'image/gif',
+ } as IMongoFile;
+
+ const pdfFile = {
+ ...createMockFile('doc.pdf'),
+ type: 'application/pdf',
+ } as IMongoFile;
+
+ const files = [jpegFile, pngFile, gifFile, pdfFile];
+
+ const result = filterFilesByEndpointConfig(req, {
+ files,
+ endpoint: Providers.OPENAI,
+ });
+
+ /** Only image files should pass */
+ expect(result).toEqual([jpegFile, pngFile, gifFile]);
+ });
+
+ it('should filter all files if none match supported MIME types', () => {
+ const req = {
+ config: {
+ fileConfig: {
+ endpoints: {
+ [Providers.OPENAI]: {
+ disabled: false,
+ supportedMimeTypes: ['^application/pdf$'],
+ },
+ },
+ },
+ },
+ } as unknown as ServerRequest;
+
+ const files = [
+ { ...createMockFile('video.mp4'), type: 'video/mp4' } as IMongoFile,
+ { ...createMockFile('audio.mp3'), type: 'audio/mp3' } as IMongoFile,
+ ];
+
+ const result = filterFilesByEndpointConfig(req, {
+ files,
+ endpoint: Providers.OPENAI,
+ });
+
+ expect(result).toEqual([]);
+ });
+
+ it('should handle empty supportedMimeTypes array', () => {
+ const req = {
+ config: {
+ fileConfig: {
+ endpoints: {
+ [Providers.OPENAI]: {
+ disabled: false,
+ supportedMimeTypes: [],
+ },
+ },
+ },
+ },
+ } as unknown as ServerRequest;
+
+ const files = [{ ...createMockFile('doc.pdf'), type: 'application/pdf' } as IMongoFile];
+
+ const result = filterFilesByEndpointConfig(req, {
+ files,
+ endpoint: Providers.OPENAI,
+ });
+
+ /** Empty array means allow all */
+ expect(result).toEqual(files);
+ });
+ });
+
+ describe('total size limit filtering', () => {
+ it('should filter files when total size exceeds totalSizeLimit', () => {
+ const req = {
+ config: {
+ fileConfig: {
+ endpoints: {
+ [Providers.OPENAI]: {
+ disabled: false,
+ totalSizeLimit: 10 /** 10 MB total */,
+ },
+ },
+ },
+ },
+ } as unknown as ServerRequest;
+
+ const file1 = {
+ ...createMockFile('file1.pdf'),
+ bytes: 1024 * 1024 * 4 /** 4 MB */,
+ } as IMongoFile;
+
+ const file2 = {
+ ...createMockFile('file2.pdf'),
+ bytes: 1024 * 1024 * 4 /** 4 MB */,
+ } as IMongoFile;
+
+ const file3 = {
+ ...createMockFile('file3.pdf'),
+ bytes: 1024 * 1024 * 4 /** 4 MB */,
+ } as IMongoFile;
+
+ const files = [file1, file2, file3];
+
+ const result = filterFilesByEndpointConfig(req, {
+ files,
+ endpoint: Providers.OPENAI,
+ });
+
+ /** Only first two files should pass (8 MB total) */
+ expect(result).toEqual([file1, file2]);
+ });
+
+ it('should keep all files when totalSizeLimit is not exceeded', () => {
+ const req = {
+ config: {
+ fileConfig: {
+ endpoints: {
+ [Providers.OPENAI]: {
+ disabled: false,
+ totalSizeLimit: 20 /** 20 MB total */,
+ },
+ },
+ },
+ },
+ } as unknown as ServerRequest;
+
+ const files = [
+ { ...createMockFile('file1.pdf'), bytes: 1024 * 1024 * 5 } as IMongoFile,
+ { ...createMockFile('file2.pdf'), bytes: 1024 * 1024 * 5 } as IMongoFile,
+ ];
+
+ const result = filterFilesByEndpointConfig(req, {
+ files,
+ endpoint: Providers.OPENAI,
+ });
+
+ expect(result).toEqual(files);
+ });
+
+ it('should handle totalSizeLimit of 0 as unlimited', () => {
+ const req = {
+ config: {
+ fileConfig: {
+ endpoints: {
+ [Providers.OPENAI]: {
+ disabled: false,
+ totalSizeLimit: 0,
+ },
+ },
+ },
+ },
+ } as unknown as ServerRequest;
+
+ const files = [
+ { ...createMockFile('file1.pdf'), bytes: 1024 * 1024 * 100 } as IMongoFile,
+ { ...createMockFile('file2.pdf'), bytes: 1024 * 1024 * 100 } as IMongoFile,
+ ];
+
+ const result = filterFilesByEndpointConfig(req, {
+ files,
+ endpoint: Providers.OPENAI,
+ });
+
+ /** 0 means no limit */
+ expect(result).toEqual(files);
+ });
+
+ it('should skip files that exceed totalSizeLimit and continue with remaining files', () => {
+ const req = {
+ config: {
+ fileConfig: {
+ endpoints: {
+ [Providers.OPENAI]: {
+ disabled: false,
+ totalSizeLimit: 5 /** 5 MB total */,
+ },
+ },
+ },
+ },
+ } as unknown as ServerRequest;
+
+ const files = [
+ { ...createMockFile('large.pdf'), bytes: 1024 * 1024 * 10 } as IMongoFile,
+ { ...createMockFile('small.pdf'), bytes: 1024 * 1024 * 1 } as IMongoFile,
+ ];
+
+ const result = filterFilesByEndpointConfig(req, {
+ files,
+ endpoint: Providers.OPENAI,
+ });
+
+ /** First file exceeds total limit, so it's skipped. Small file fits and is included. */
+ expect(result).toEqual([files[1]]);
+ });
+
+ it('should keep files in order until total size limit is reached', () => {
+ const req = {
+ config: {
+ fileConfig: {
+ endpoints: {
+ [Providers.OPENAI]: {
+ disabled: false,
+ totalSizeLimit: 7 /** 7 MB total */,
+ },
+ },
+ },
+ },
+ } as unknown as ServerRequest;
+
+ const file1 = {
+ ...createMockFile('file1.pdf'),
+ bytes: 1024 * 1024 * 2 /** 2 MB */,
+ } as IMongoFile;
+
+ const file2 = {
+ ...createMockFile('file2.pdf'),
+ bytes: 1024 * 1024 * 3 /** 3 MB */,
+ } as IMongoFile;
+
+ const file3 = {
+ ...createMockFile('file3.pdf'),
+ bytes: 1024 * 1024 * 2 /** 2 MB */,
+ } as IMongoFile;
+
+ const file4 = {
+ ...createMockFile('file4.pdf'),
+ bytes: 1024 * 1024 * 1 /** 1 MB */,
+ } as IMongoFile;
+
+ const files = [file1, file2, file3, file4];
+
+ const result = filterFilesByEndpointConfig(req, {
+ files,
+ endpoint: Providers.OPENAI,
+ });
+
+ /** file1 (2MB) + file2 (3MB) = 5MB ✓, + file3 (2MB) = 7MB ✓, + file4 would exceed */
+ expect(result).toEqual([file1, file2, file3]);
+ });
+ });
+
+ describe('combined filtering scenarios', () => {
+ it('should apply size and MIME type filters together', () => {
+ const req = {
+ config: {
+ fileConfig: {
+ endpoints: {
+ [Providers.OPENAI]: {
+ disabled: false,
+ fileSizeLimit: 5 /** 5 MB per file */,
+ supportedMimeTypes: ['^application/pdf$', '^image/.*$'],
+ },
+ },
+ },
+ },
+ } as unknown as ServerRequest;
+
+ const validPdf = {
+ ...createMockFile('valid.pdf'),
+ type: 'application/pdf',
+ bytes: 1024 * 1024 * 3 /** 3 MB */,
+ } as IMongoFile;
+
+ const validImage = {
+ ...createMockFile('valid.png'),
+ type: 'image/png',
+ bytes: 1024 * 1024 * 2 /** 2 MB */,
+ } as IMongoFile;
+
+ const tooLargePdf = {
+ ...createMockFile('large.pdf'),
+ type: 'application/pdf',
+ bytes: 1024 * 1024 * 10 /** 10 MB - exceeds size limit */,
+ } as IMongoFile;
+
+ const wrongTypeVideo = {
+ ...createMockFile('video.mp4'),
+ type: 'video/mp4',
+ bytes: 1024 * 1024 * 2 /** 2 MB - wrong MIME type */,
+ } as IMongoFile;
+
+ const files = [validPdf, validImage, tooLargePdf, wrongTypeVideo];
+
+ const result = filterFilesByEndpointConfig(req, {
+ files,
+ endpoint: Providers.OPENAI,
+ });
+
+ /** Only validPdf and validImage should pass both filters */
+ expect(result).toEqual([validPdf, validImage]);
+ });
+
+ it('should apply all three filters together', () => {
+ const req = {
+ config: {
+ fileConfig: {
+ endpoints: {
+ [Providers.OPENAI]: {
+ disabled: false,
+ fileSizeLimit: 5 /** 5 MB per file */,
+ totalSizeLimit: 8 /** 8 MB total */,
+ supportedMimeTypes: ['^application/pdf$'],
+ },
+ },
+ },
+ },
+ } as unknown as ServerRequest;
+
+ const pdf1 = {
+ ...createMockFile('pdf1.pdf'),
+ type: 'application/pdf',
+ bytes: 1024 * 1024 * 3 /** 3 MB */,
+ } as IMongoFile;
+
+ const pdf2 = {
+ ...createMockFile('pdf2.pdf'),
+ type: 'application/pdf',
+ bytes: 1024 * 1024 * 4 /** 4 MB */,
+ } as IMongoFile;
+
+ const pdf3 = {
+ ...createMockFile('pdf3.pdf'),
+ type: 'application/pdf',
+ bytes: 1024 * 1024 * 2 /** 2 MB */,
+ } as IMongoFile;
+
+ const largePdf = {
+ ...createMockFile('large.pdf'),
+ type: 'application/pdf',
+ bytes: 1024 * 1024 * 10 /** 10 MB - exceeds individual size limit */,
+ } as IMongoFile;
+
+ const wrongType = {
+ ...createMockFile('image.png'),
+ type: 'image/png',
+ bytes: 1024 * 1024 * 1 /** Wrong type */,
+ } as IMongoFile;
+
+ const files = [pdf1, pdf2, pdf3, largePdf, wrongType];
+
+ const result = filterFilesByEndpointConfig(req, {
+ files,
+ endpoint: Providers.OPENAI,
+ });
+
+ /**
+ * largePdf filtered by size (10MB > 5MB limit)
+ * wrongType filtered by MIME type
+ * Remaining: pdf1 (3MB) + pdf2 (4MB) = 7MB ✓
+ * pdf3 (2MB) would make total 9MB > 8MB limit, so filtered by total
+ */
+ expect(result).toEqual([pdf1, pdf2]);
+ });
+
+ it('should handle mixed validation with some files passing all checks', () => {
+ const req = {
+ config: {
+ fileConfig: {
+ endpoints: {
+ [Providers.ANTHROPIC]: {
+ disabled: false,
+ fileSizeLimit: 10,
+ totalSizeLimit: 20,
+ supportedMimeTypes: ['^application/.*$', '^text/.*$'],
+ },
+ },
+ },
+ },
+ } as unknown as ServerRequest;
+
+ const file1 = {
+ ...createMockFile('doc.pdf'),
+ type: 'application/pdf',
+ bytes: 1024 * 1024 * 5,
+ } as IMongoFile;
+
+ const file2 = {
+ ...createMockFile('text.txt'),
+ type: 'text/plain',
+ bytes: 1024 * 1024 * 8,
+ } as IMongoFile;
+
+ const file3 = {
+ ...createMockFile('data.json'),
+ type: 'application/json',
+ bytes: 1024 * 1024 * 6,
+ } as IMongoFile;
+
+ const file4 = {
+ ...createMockFile('video.mp4'),
+ type: 'video/mp4',
+ bytes: 1024 * 1024 * 3 /** Wrong MIME type */,
+ } as IMongoFile;
+
+ const files = [file1, file2, file3, file4];
+
+ const result = filterFilesByEndpointConfig(req, {
+ files,
+ endpoint: Providers.ANTHROPIC,
+ });
+
+ /**
+ * file4 filtered by MIME type
+ * file1 (5MB) + file2 (8MB) = 13MB ✓
+ * file3 (6MB) would make 19MB < 20MB ✓
+ */
+ expect(result).toEqual([file1, file2, file3]);
+ });
+ });
});
diff --git a/packages/api/src/files/filter.ts b/packages/api/src/files/filter.ts
index eaf2a6fe90..4597dc987e 100644
--- a/packages/api/src/files/filter.ts
+++ b/packages/api/src/files/filter.ts
@@ -1,15 +1,32 @@
-import { getEndpointFileConfig, mergeFileConfig } from 'librechat-data-provider';
+import { getEndpointFileConfig, mergeFileConfig, fileConfig } from 'librechat-data-provider';
import type { IMongoFile } from '@librechat/data-schemas';
import type { ServerRequest } from '~/types';
/**
- * Filters out files if the endpoint/provider has file uploads disabled
+ * Checks if a MIME type is supported by the endpoint configuration
+ * @param mimeType - The MIME type to check
+ * @param supportedMimeTypes - Array of RegExp patterns to match against
+ * @returns True if the MIME type matches any pattern
+ */
+function isMimeTypeSupported(mimeType: string, supportedMimeTypes?: RegExp[]): boolean {
+ if (!supportedMimeTypes || supportedMimeTypes.length === 0) {
+ return true;
+ }
+ return fileConfig.checkType(mimeType, supportedMimeTypes);
+}
+
+/**
+ * Filters out files based on endpoint configuration including:
+ * - Disabled status
+ * - File size limits
+ * - MIME type restrictions
+ * - Total size limits
* @param req - The server request object containing config
* @param params - Object containing files, endpoint, and endpointType
* @param params.files - Array of processed file documents from MongoDB
* @param params.endpoint - The endpoint name to check configuration for
* @param params.endpointType - The endpoint type to check configuration for
- * @returns Filtered array of files (empty if disabled)
+ * @returns Filtered array of files
*/
export function filterFilesByEndpointConfig(
req: ServerRequest,
@@ -25,9 +42,9 @@ export function filterFilesByEndpointConfig(
return [];
}
- const fileConfig = mergeFileConfig(req.config?.fileConfig);
+ const mergedFileConfig = mergeFileConfig(req.config?.fileConfig);
const endpointFileConfig = getEndpointFileConfig({
- fileConfig,
+ fileConfig: mergedFileConfig,
endpoint,
endpointType,
});
@@ -40,5 +57,40 @@ export function filterFilesByEndpointConfig(
return [];
}
- return files;
+ const { fileSizeLimit, supportedMimeTypes, totalSizeLimit } = endpointFileConfig;
+
+ /** Filter files based on individual file size and MIME type */
+ let filteredFiles = files;
+
+ /** Filter by individual file size limit */
+ if (fileSizeLimit !== undefined && fileSizeLimit > 0) {
+ filteredFiles = filteredFiles.filter((file) => {
+ return file.bytes <= fileSizeLimit;
+ });
+ }
+
+ /** Filter by MIME type */
+ if (supportedMimeTypes && supportedMimeTypes.length > 0) {
+ filteredFiles = filteredFiles.filter((file) => {
+ return isMimeTypeSupported(file.type, supportedMimeTypes);
+ });
+ }
+
+ /** Filter by total size limit - keep files until total exceeds limit */
+ if (totalSizeLimit !== undefined && totalSizeLimit > 0) {
+ let totalSize = 0;
+ const withinTotalLimit: IMongoFile[] = [];
+
+ for (let i = 0; i < filteredFiles.length; i++) {
+ const file = filteredFiles[i];
+ if (totalSize + file.bytes <= totalSizeLimit) {
+ withinTotalLimit.push(file);
+ totalSize += file.bytes;
+ }
+ }
+
+ filteredFiles = withinTotalLimit;
+ }
+
+ return filteredFiles;
}
diff --git a/packages/api/src/files/validation.ts b/packages/api/src/files/validation.ts
index 7c1eccd8ed..4b36ac0bff 100644
--- a/packages/api/src/files/validation.ts
+++ b/packages/api/src/files/validation.ts
@@ -16,6 +16,11 @@ export interface AudioValidationResult {
error?: string;
}
+export interface ImageValidationResult {
+ isValid: boolean;
+ error?: string;
+}
+
export async function validatePdf(
pdfBuffer: Buffer,
fileSize: number,
@@ -229,3 +234,53 @@ export async function validateAudio(
return { isValid: true };
}
+
+/**
+ * Validates image files for different providers
+ * @param imageBuffer - The image file as a buffer
+ * @param fileSize - The file size in bytes
+ * @param provider - The provider to validate for
+ * @param configuredFileSizeLimit - Optional configured file size limit from fileConfig (in bytes)
+ * @returns Promise that resolves to validation result
+ */
+export async function validateImage(
+ imageBuffer: Buffer,
+ fileSize: number,
+ provider: Providers | string,
+ configuredFileSizeLimit?: number,
+): Promise<ImageValidationResult> {
+ if (provider === Providers.GOOGLE || provider === Providers.VERTEXAI) {
+ const providerLimit = mbToBytes(20);
+ const effectiveLimit = configuredFileSizeLimit ?? providerLimit;
+
+ if (fileSize > effectiveLimit) {
+ const limitMB = Math.round(effectiveLimit / (1024 * 1024));
+ return {
+ isValid: false,
+ error: `Image file size (${Math.round(fileSize / (1024 * 1024))}MB) exceeds the ${limitMB}MB limit`,
+ };
+ }
+ }
+
+ if (provider === Providers.ANTHROPIC) {
+ const providerLimit = mbToBytes(5);
+ const effectiveLimit = configuredFileSizeLimit ?? providerLimit;
+
+ if (fileSize > effectiveLimit) {
+ const limitMB = Math.round(effectiveLimit / (1024 * 1024));
+ return {
+ isValid: false,
+ error: `Image file size (${Math.round(fileSize / (1024 * 1024))}MB) exceeds the ${limitMB}MB limit`,
+ };
+ }
+ }
+
+ if (!imageBuffer || imageBuffer.length < 10) {
+ return {
+ isValid: false,
+ error: 'Invalid image file: too small or corrupted',
+ };
+ }
+
+ return { isValid: true };
+}