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
import { megabyte, fileConfig as defaultFileConfig } from 'librechat-data-provider';
import type { EndpointFileConfig, FileConfig } from 'librechat-data-provider';
import type { ExtendedFile } from '~/common';
import { validateFiles, validateFileSizes, partitionUploads } from '../files';
const supportedMimeTypes = defaultFileConfig.endpoints.default.supportedMimeTypes;
function makeEndpointConfig(overrides: Partial<EndpointFileConfig> = {}): EndpointFileConfig {
return {
fileLimit: 10,
fileSizeLimit: 25 * megabyte,
totalSizeLimit: 100 * megabyte,
supportedMimeTypes,
disabled: false,
...overrides,
};
}
function makeFile(name: string, type: string, size: number): File {
const content = new ArrayBuffer(size);
return new File([content], name, { type });
}
/** Stands in for a file of any size without allocating its bytes, which only the size rules read. */
function makeSizedFile(name: string, type: string, size: number): File {
const file = new File(['content'], name, { type });
Object.defineProperty(file, 'size', { value: size });
return file;
}
function makeExtendedFile(overrides: Partial<ExtendedFile> = {}): ExtendedFile {
return {
file_id: 'ext-1',
size: 1024,
progress: 1,
type: 'application/pdf',
...overrides,
};
}
describe('validateFiles', () => {
let setError: jest.Mock;
let files: Map<string, ExtendedFile>;
let endpointFileConfig: EndpointFileConfig;
const fileConfig: FileConfig | null = null;
beforeEach(() => {
setError = jest.fn();
files = new Map();
endpointFileConfig = makeEndpointConfig();
});
it('returns true when all checks pass', () => {
const fileList = [makeFile('doc.pdf', 'application/pdf', 1024)];
const result = validateFiles({ files, fileList, setError, endpointFileConfig, fileConfig });
expect(result).toBe(true);
expect(setError).not.toHaveBeenCalled();
});
it('rejects a type outside a restricted endpoint allowlist in unified mode', () => {
endpointFileConfig = makeEndpointConfig({
supportedMimeTypes: [/^image\/(jpeg|png)$/],
});
const fileList = [makeFile('notes.txt', 'text/plain', 1024)];
const result = validateFiles({
files,
fileList,
setError,
endpointFileConfig,
fileConfig: defaultFileConfig,
});
expect(result).toBe(false);
expect(setError).toHaveBeenCalledWith('Unsupported file type: text/plain');
});
it('accepts a type the restricted endpoint allowlist permits in unified mode', () => {
endpointFileConfig = makeEndpointConfig({
supportedMimeTypes: [/^image\/(jpeg|png)$/],
});
const fileList = [makeFile('shot.png', 'image/png', 1024)];
const result = validateFiles({
files,
fileList,
setError,
endpointFileConfig,
fileConfig: defaultFileConfig,
});
expect(result).toBe(true);
expect(setError).not.toHaveBeenCalled();
});
it('rejects when endpoint is disabled', () => {
endpointFileConfig = makeEndpointConfig({ disabled: true });
const fileList = [makeFile('doc.pdf', 'application/pdf', 1024)];
const result = validateFiles({ files, fileList, setError, endpointFileConfig, fileConfig });
expect(result).toBe(false);
expect(setError).toHaveBeenCalledWith('com_ui_attach_error_disabled');
});
it('rejects empty files (zero bytes)', () => {
const fileList = [makeFile('empty.pdf', 'application/pdf', 0)];
const result = validateFiles({ files, fileList, setError, endpointFileConfig, fileConfig });
expect(result).toBe(false);
expect(setError).toHaveBeenCalledWith('com_error_files_empty');
});
it('rejects when fileLimit would be exceeded', () => {
endpointFileConfig = makeEndpointConfig({ fileLimit: 3 });
files = new Map([
['f1', makeExtendedFile({ file_id: 'f1', filename: 'one.pdf', size: 2048 })],
['f2', makeExtendedFile({ file_id: 'f2', filename: 'two.pdf', size: 3072 })],
]);
const fileList = [
makeFile('a.pdf', 'application/pdf', 1024),
makeFile('b.pdf', 'application/pdf', 2048),
];
const result = validateFiles({ files, fileList, setError, endpointFileConfig, fileConfig });
expect(result).toBe(false);
expect(setError).toHaveBeenCalledWith('File limit reached: 3 files');
});
it('allows upload when exactly at fileLimit boundary', () => {
endpointFileConfig = makeEndpointConfig({ fileLimit: 3 });
files = new Map([
['f1', makeExtendedFile({ file_id: 'f1', filename: 'one.pdf', size: 2048 })],
['f2', makeExtendedFile({ file_id: 'f2', filename: 'two.pdf', size: 3072 })],
]);
const fileList = [makeFile('a.pdf', 'application/pdf', 1024)];
const result = validateFiles({ files, fileList, setError, endpointFileConfig, fileConfig });
expect(result).toBe(true);
});
it('rejects unsupported MIME type', () => {
const fileList = [makeFile('data.xyz', 'application/x-unknown', 1024)];
const result = validateFiles({ files, fileList, setError, endpointFileConfig, fileConfig });
expect(result).toBe(false);
expect(setError).toHaveBeenCalledWith('Unsupported file type: application/x-unknown');
});
it('normalizes Windows ZIP MIME type before validation', () => {
const fileList = [makeFile('archive.zip', 'application/x-zip-compressed', 1024)];
const result = validateFiles({ files, fileList, setError, endpointFileConfig, fileConfig });
expect(result).toBe(true);
expect(fileList[0].type).toBe('application/zip');
expect(setError).not.toHaveBeenCalled();
});
it('infers ZIP MIME type when the browser does not provide one', () => {
const fileList = [makeFile('archive.zip', '', 1024)];
const result = validateFiles({ files, fileList, setError, endpointFileConfig, fileConfig });
expect(result).toBe(true);
expect(fileList[0].type).toBe('application/zip');
expect(setError).not.toHaveBeenCalled();
});
it('rejects when file size equals fileSizeLimit (>= comparison)', () => {
const limit = 5 * megabyte;
endpointFileConfig = makeEndpointConfig({ fileSizeLimit: limit });
const fileList = [makeFile('exact.pdf', 'application/pdf', limit)];
const result = validateFiles({ files, fileList, setError, endpointFileConfig, fileConfig });
expect(result).toBe(false);
expect(setError).toHaveBeenCalledWith(`File size limit exceeded: ${limit / megabyte} MB`);
});
it('allows file just under fileSizeLimit', () => {
const limit = 5 * megabyte;
endpointFileConfig = makeEndpointConfig({ fileSizeLimit: limit });
const fileList = [makeFile('under.pdf', 'application/pdf', limit - 1)];
const result = validateFiles({ files, fileList, setError, endpointFileConfig, fileConfig });
expect(result).toBe(true);
});
it('can defer size validation until after files are transformed', () => {
const limit = 5 * megabyte;
endpointFileConfig = makeEndpointConfig({ fileSizeLimit: limit });
const fileList = [makeFile('photo.jpg', 'image/jpeg', limit + 1)];
const metadataResult = validateFiles({
files,
fileList,
setError,
fileConfig,
endpointFileConfig,
skipSizeValidation: true,
});
const transformedResult = validateFileSizes({
files,
fileList: [makeFile('photo.jpg', 'image/jpeg', limit - 1)],
setError,
endpointFileConfig,
});
expect(metadataResult).toBe(true);
expect(transformedResult).toBe(true);
expect(setError).not.toHaveBeenCalled();
});
it('preserves the individual size error after transformation', () => {
const limit = 5 * megabyte;
endpointFileConfig = makeEndpointConfig({ fileSizeLimit: limit });
const result = validateFileSizes({
files,
fileList: [makeFile('photo.jpg', 'image/jpeg', limit)],
setError,
endpointFileConfig,
});
expect(result).toBe(false);
expect(setError).toHaveBeenCalledWith(`File size limit exceeded: ${limit / megabyte} MB`);
});
it('rejects when totalSizeLimit would be exceeded', () => {
const limit = 10 * megabyte;
endpointFileConfig = makeEndpointConfig({ totalSizeLimit: limit });
files = new Map([['f1', makeExtendedFile({ file_id: 'f1', size: 6 * megabyte })]]);
const fileList = [makeFile('big.pdf', 'application/pdf', 5 * megabyte)];
const result = validateFiles({ files, fileList, setError, endpointFileConfig, fileConfig });
expect(result).toBe(false);
expect(setError).toHaveBeenCalledWith(`Total file size limit exceeded: ${limit / megabyte} MB`);
});
it('allows when totalSizeLimit is exactly met', () => {
const limit = 10 * megabyte;
endpointFileConfig = makeEndpointConfig({ totalSizeLimit: limit });
files = new Map([['f1', makeExtendedFile({ file_id: 'f1', size: 5 * megabyte })]]);
const fileList = [makeFile('fits.pdf', 'application/pdf', 5 * megabyte)];
const result = validateFiles({ files, fileList, setError, endpointFileConfig, fileConfig });
expect(result).toBe(true);
});
it('checks the total size across the transformed batch', () => {
const limit = 10 * megabyte;
endpointFileConfig = makeEndpointConfig({ totalSizeLimit: limit });
const result = validateFileSizes({
files,
fileList: [
makeFile('one.jpg', 'image/jpeg', 6 * megabyte),
makeFile('two.jpg', 'image/jpeg', 5 * megabyte),
],
setError,
endpointFileConfig,
});
expect(result).toBe(false);
expect(setError).toHaveBeenCalledWith(`Total file size limit exceeded: ${limit / megabyte} MB`);
});
it('rejects duplicate files', () => {
files = new Map([
[
'f1',
makeExtendedFile({
file_id: 'f1',
file: makeFile('doc.pdf', 'application/pdf', 1024),
filename: 'doc.pdf',
size: 1024,
type: 'application/pdf',
}),
],
]);
const fileList = [makeFile('doc.pdf', 'application/pdf', 1024)];
const result = validateFiles({ files, fileList, setError, endpointFileConfig, fileConfig });
expect(result).toBe(false);
expect(setError).toHaveBeenCalledWith('com_error_files_dupe');
});
it('enforces check ordering: disabled before fileLimit', () => {
endpointFileConfig = makeEndpointConfig({ disabled: true, fileLimit: 1 });
files = new Map([['f1', makeExtendedFile({ file_id: 'f1', filename: 'existing.pdf' })]]);
const fileList = [makeFile('doc.pdf', 'application/pdf', 1024)];
validateFiles({ files, fileList, setError, endpointFileConfig, fileConfig });
expect(setError).toHaveBeenCalledWith('com_ui_attach_error_disabled');
});
it('enforces check ordering: fileLimit before fileSizeLimit', () => {
const limit = 1;
endpointFileConfig = makeEndpointConfig({ fileLimit: 1, fileSizeLimit: limit });
files = new Map([['f1', makeExtendedFile({ file_id: 'f1', filename: 'existing.pdf' })]]);
const fileList = [makeFile('huge.pdf', 'application/pdf', limit)];
validateFiles({ files, fileList, setError, endpointFileConfig, fileConfig });
expect(setError).toHaveBeenCalledWith('File limit reached: 1 files');
});
});
describe('partitionUploads', () => {
let files: Map<string, ExtendedFile>;
let endpointFileConfig: EndpointFileConfig;
beforeEach(() => {
files = new Map();
endpointFileConfig = makeEndpointConfig();
});
it('keeps the files that fit and skips only the ones over the individual limit', () => {
const limit = 20 * megabyte;
endpointFileConfig = makeEndpointConfig({ fileSizeLimit: limit });
const fileList = [
makeSizedFile('small.pdf', 'application/pdf', 1 * megabyte),
makeSizedFile('huge.pdf', 'application/pdf', 21 * megabyte),
makeSizedFile('medium.pdf', 'application/pdf', 5 * megabyte),
];
const { keptIndices, skipped } = partitionUploads({ files, fileList, endpointFileConfig });
expect(keptIndices).toEqual([0, 2]);
expect(skipped).toEqual([{ index: 1, file: fileList[1], reason: 'fileSize' }]);
});
it('skips every file when all of them are over the individual limit', () => {
endpointFileConfig = makeEndpointConfig({ fileSizeLimit: 1 * megabyte });
const fileList = [
makeSizedFile('one.pdf', 'application/pdf', 2 * megabyte),
makeSizedFile('two.pdf', 'application/pdf', 3 * megabyte),
];
const { keptIndices, skipped } = partitionUploads({ files, fileList, endpointFileConfig });
expect(keptIndices).toEqual([]);
expect(skipped.map(({ reason }) => reason)).toEqual(['fileSize', 'fileSize']);
});
it('treats a file matching an existing attachment as a duplicate without dropping the rest', () => {
files = new Map([
[
'f1',
makeExtendedFile({
file_id: 'f1',
filename: 'report.pdf',
size: 1024,
type: 'application/pdf',
}),
],
]);
const fileList = [
makeSizedFile('report.pdf', 'application/pdf', 1024),
makeSizedFile('notes.pdf', 'application/pdf', 2048),
];
const { keptIndices, skipped } = partitionUploads({ files, fileList, endpointFileConfig });
expect(keptIndices).toEqual([1]);
expect(skipped).toEqual([{ index: 0, file: fileList[0], reason: 'duplicate' }]);
});
it('skips a file repeated within the same selection and keeps the first copy', () => {
const fileList = [
makeSizedFile('report.pdf', 'application/pdf', 1024),
makeSizedFile('report.pdf', 'application/pdf', 1024),
];
const { keptIndices, skipped } = partitionUploads({ files, fileList, endpointFileConfig });
expect(keptIndices).toEqual([0]);
expect(skipped).toEqual([{ index: 1, file: fileList[1], reason: 'duplicate' }]);
});
it('leaves size checks alone when they are deferred until after transformation', () => {
endpointFileConfig = makeEndpointConfig({ fileSizeLimit: 1 * megabyte });
const fileList = [makeSizedFile('huge.pdf', 'application/pdf', 21 * megabyte)];
const { keptIndices, skipped } = partitionUploads({
files,
fileList,
endpointFileConfig,
skipSizeValidation: true,
});
expect(keptIndices).toEqual([0]);
expect(skipped).toEqual([]);
});
it('keeps everything when no individual limit is configured', () => {
endpointFileConfig = makeEndpointConfig({ fileSizeLimit: 0 });
const fileList = [makeSizedFile('huge.pdf', 'application/pdf', 500 * megabyte)];
const { keptIndices, skipped } = partitionUploads({ files, fileList, endpointFileConfig });
expect(keptIndices).toEqual([0]);
expect(skipped).toEqual([]);
});
it('leaves the batch-wide total limit to validateFileSizes', () => {
endpointFileConfig = makeEndpointConfig({
fileSizeLimit: 10 * megabyte,
totalSizeLimit: 7 * megabyte,
});
const fileList = [
makeSizedFile('one.pdf', 'application/pdf', 4 * megabyte),
makeSizedFile('two.pdf', 'application/pdf', 4 * megabyte),
];
const { keptIndices, skipped } = partitionUploads({ files, fileList, endpointFileConfig });
expect(keptIndices).toEqual([0, 1]);
expect(skipped).toEqual([]);
});
});