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 { EToolResources, mergeFileConfig } from 'librechat-data-provider';
import type { FiltersConfig } from 'librechat-data-provider';
import {
canInspectUploadExtractedTextAfterProcessing,
getBlockedUploadTranscriptField,
contentFilterUninspectableResponse,
getBlockedOpaqueFileField,
getBlockedUninspectableFileField,
getBlockedUninspectableSkillFileField,
getCanonicalFileInspectionCoverage,
getUploadExtractedTextPlan,
hasActiveFileFieldPolicy,
hasActiveFilePolicy,
omitResolvedCanonicalFileLocators,
resolveCanonicalFileReferences,
resolveCanonicalFileReferenceUnits,
UPLOAD_EXTRACTED_TEXT_PLANS,
UninspectableFileError,
} from './files';
import { ContentTraversalLimitError } from './adapters/nested';
describe('file content inspection policy', () => {
it('defers extracted-text fail-close only to supported agent context extraction paths', () => {
const noConfiguredExtraction = mergeFileConfig({
ocr: { supportedMimeTypes: [] },
text: { supportedMimeTypes: [] },
});
const baseInput = {
endpoint: 'agents',
toolResource: EToolResources.context,
fileConfig: noConfiguredExtraction,
ocrConfigured: false,
ragConfigured: false,
};
expect(
canInspectUploadExtractedTextAfterProcessing({
...baseInput,
mimeType: 'application/pdf',
}),
).toBe(true);
expect(
canInspectUploadExtractedTextAfterProcessing({
...baseInput,
mimeType: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
}),
).toBe(true);
expect(
canInspectUploadExtractedTextAfterProcessing({
...baseInput,
endpoint: 'assistants',
mimeType: 'application/pdf',
}),
).toBe(false);
expect(
canInspectUploadExtractedTextAfterProcessing({
...baseInput,
toolResource: EToolResources.file_search,
mimeType: 'application/pdf',
}),
).toBe(false);
expect(
canInspectUploadExtractedTextAfterProcessing({
...baseInput,
mimeType: 'application/x-unsupported',
}),
).toBe(false);
/* An explicitly narrowed text list names types the built-in parser does not handle.
* Processing sends those to RAG with native fallback off and passes the result
* through extractInspectableFileText, so the extraction step exists and fail-closing
* here would reject an upload that does get inspected. */
const configuredNonDocumentText = mergeFileConfig({
ocr: { supportedMimeTypes: [] },
text: { supportedMimeTypes: ['application/x-rag-document'] },
});
expect(
canInspectUploadExtractedTextAfterProcessing({
...baseInput,
mimeType: 'application/x-rag-document',
fileConfig: configuredNonDocumentText,
ragConfigured: true,
}),
).toBe(true);
/* Only when RAG is actually configured: without it nothing extracts the type. */
expect(
canInspectUploadExtractedTextAfterProcessing({
...baseInput,
mimeType: 'application/x-rag-document',
fileConfig: configuredNonDocumentText,
ragConfigured: false,
}),
).toBe(false);
const defaultExtraction = mergeFileConfig(undefined);
expect(
canInspectUploadExtractedTextAfterProcessing({
...baseInput,
mimeType: 'application/octet-stream',
fileConfig: defaultExtraction,
ragConfigured: true,
}),
).toBe(false);
expect(
canInspectUploadExtractedTextAfterProcessing({
...baseInput,
mimeType: 'audio/mpeg',
fileConfig: defaultExtraction,
ragConfigured: true,
}),
).toBe(false);
const configuredDocumentRAG = mergeFileConfig({
ocr: { supportedMimeTypes: [] },
text: { supportedMimeTypes: ['application/pdf'] },
});
expect(
getUploadExtractedTextPlan({
...baseInput,
mimeType: 'application/pdf',
fileConfig: configuredDocumentRAG,
ragConfigured: true,
}),
).toBe(UPLOAD_EXTRACTED_TEXT_PLANS.configuredRAG);
expect(
getUploadExtractedTextPlan({
...baseInput,
mimeType: 'application/pdf',
fileConfig: configuredDocumentRAG,
}),
).toBe(UPLOAD_EXTRACTED_TEXT_PLANS.documentParser);
const configuredOCR = mergeFileConfig({
ocr: { supportedMimeTypes: ['application/x-ocr-document'] },
text: { supportedMimeTypes: [] },
});
expect(
canInspectUploadExtractedTextAfterProcessing({
...baseInput,
mimeType: 'application/x-ocr-document',
fileConfig: configuredOCR,
}),
).toBe(false);
expect(
canInspectUploadExtractedTextAfterProcessing({
...baseInput,
mimeType: 'application/x-ocr-document',
fileConfig: configuredOCR,
ocrConfigured: true,
}),
).toBe(true);
});
it('treats a text-delivery audio file as carrying its own transcript', () => {
const coverage = getCanonicalFileInspectionCoverage({
type: 'audio/mpeg',
source: 'local',
llmDeliveryPath: 'text',
text: 'spoken words',
});
expect(coverage.transcript).toBe('spoken words');
expect(coverage.textProvidesTranscript).toBe(true);
});
it('still requires provenance before treating audio text as a transcript', () => {
const coverage = getCanonicalFileInspectionCoverage({
type: 'audio/mpeg',
source: 'local',
text: 'spoken words',
});
expect(coverage.transcript).toBeUndefined();
});
it('keeps recognizing the legacy text source as provenance', () => {
const coverage = getCanonicalFileInspectionCoverage({
type: 'audio/mpeg',
source: 'text',
text: 'spoken words',
});
expect(coverage.transcript).toBe('spoken words');
});
it('rejects applicable audio when no downstream transcript inspection is available', () => {
const filters = {
files: { pii: { fields: ['transcript'], uninspectable: 'block' } },
} as FiltersConfig;
const baseInput = {
filters,
endpoint: 'agents',
toolResource: EToolResources.context,
};
expect(
getBlockedUploadTranscriptField({
...baseInput,
mimeType: 'audio/x-unsupported',
sttSupported: false,
}),
).toBe('transcript');
expect(
getBlockedUploadTranscriptField({
...baseInput,
mimeType: 'application/ogg',
sttSupported: false,
}),
).toBe('transcript');
expect(
getBlockedUploadTranscriptField({
...baseInput,
mimeType: 'audio/webm',
sttSupported: true,
}),
).toBeNull();
expect(
getBlockedUploadTranscriptField({
...baseInput,
mimeType: 'text/plain',
sttSupported: false,
}),
).toBeNull();
});
it('activates canonical file work only for patterns or selected fail-close content', () => {
expect(hasActiveFilePolicy(undefined)).toBe(false);
expect(
hasActiveFilePolicy({
files: { pii: { starterPatterns: [] } },
} as FiltersConfig),
).toBe(false);
expect(
hasActiveFilePolicy({
files: {
pii: {
fields: ['name'],
starterPatterns: [],
uninspectable: 'block',
},
},
} as FiltersConfig),
).toBe(false);
expect(
hasActiveFilePolicy({
files: {
pii: {
fields: ['name'],
starterPatterns: [],
customPatterns: [{ id: 'private', label: 'private', regex: 'PRIVATE' }],
},
},
} as FiltersConfig),
).toBe(true);
expect(
hasActiveFilePolicy({
files: {
pii: {
fields: ['extracted_text'],
starterPatterns: [],
uninspectable: 'block',
},
},
} as FiltersConfig),
).toBe(true);
});
it('activates only the selected enforceable file fields', () => {
const nameOnly = {
files: {
pii: {
fields: ['name'],
starterPatterns: [],
customPatterns: [{ id: 'private', label: 'private', regex: 'PRIVATE' }],
},
},
} as FiltersConfig;
expect(hasActiveFileFieldPolicy(nameOnly, ['name'])).toBe(true);
expect(hasActiveFileFieldPolicy(nameOnly, ['content'])).toBe(false);
expect(
hasActiveFileFieldPolicy(
{
files: {
pii: {
fields: ['extracted_text'],
starterPatterns: [],
uninspectable: 'block',
},
},
} as FiltersConfig,
['extracted_text'],
),
).toBe(true);
});
it('does not resolve canonical files for an explicitly inactive file policy', async () => {
const getFiles = jest.fn().mockResolvedValue([]);
const input = { files: [{ file_id: 'owned-file' }] };
await expect(
resolveCanonicalFileReferences({
filters: {
files: { pii: { starterPatterns: [] } },
messages: {
pii: {
fields: ['text'],
starterPatterns: [],
customPatterns: [{ id: 'private', label: 'private', regex: 'PRIVATE' }],
},
},
},
input,
user: { id: 'user-1' },
getFiles,
}),
).resolves.toEqual({
sanitizedInput: input,
hydratedFiles: [],
hydratedFilters: expect.any(Object),
});
expect(getFiles).not.toHaveBeenCalled();
});
it('treats omitted fields as every registered file field', () => {
const filters = {
files: { pii: { uninspectable: 'block' } },
} as FiltersConfig;
expect(getBlockedUninspectableFileField(filters, ['content', 'extracted_text'])).toBe(
'content',
);
});
it('honors field granularity and the default allow policy', () => {
const filters = {
files: {
pii: {
fields: ['name'],
uninspectable: 'block',
},
},
} as FiltersConfig;
expect(getBlockedUninspectableFileField(filters, ['content', 'transcript'])).toBeNull();
expect(
getBlockedUninspectableFileField(
{ files: { pii: { fields: ['content'] } } } as FiltersConfig,
['content'],
),
).toBeNull();
});
it('fails closed for selected skill file text independently of file compatibility mode', () => {
const filters = {
skills: {
pii: {
fields: ['file_text'],
},
},
files: {
pii: {
fields: ['content'],
uninspectable: 'allow',
},
},
} as FiltersConfig;
expect(getBlockedUninspectableSkillFileField(filters)).toBe('content');
expect(
getBlockedUninspectableSkillFileField({
skills: { pii: { fields: ['file_name'] } },
} as FiltersConfig),
).toBeNull();
expect(
getBlockedUninspectableSkillFileField({
skills: { pii: { fields: ['file_text'], starterPatterns: [] } },
} as FiltersConfig),
).toBeNull();
expect(
getBlockedUninspectableSkillFileField({
skills: { pii: { action: 'audit', fields: ['file_text'] } },
} as FiltersConfig),
).toBeNull();
expect(
getBlockedUninspectableSkillFileField({
skills: { pii: { action: 'audit', fields: ['file_text'] } },
files: { pii: { fields: ['content'], uninspectable: 'block' } },
} as FiltersConfig),
).toBe('content');
});
it('returns a stable raw-free block response', () => {
expect(contentFilterUninspectableResponse('transcript')).toEqual({
error: 'content_filter_uninspectable',
message: 'Submitted file content could not be inspected before processing.',
source: 'file',
field: 'transcript',
});
});
it.each([
{
name: 'inline image data',
input: { image_url: { url: 'data:image/png;base64,SECRET-IMAGE' } },
field: 'content',
},
{
name: 'remote image',
input: { type: 'input_image', image_url: 'https://example.test/private.png' },
field: 'content',
},
{
name: 'file identifier',
input: { type: 'input_file', file_id: 'file-private' },
field: 'content',
},
{
name: 'inline file data',
input: { type: 'input_file', file_data: 'private-file-data' },
field: 'content',
},
{
name: 'inline audio',
input: { type: 'input_audio', input_audio: { data: 'private-audio', format: 'wav' } },
field: 'content',
},
{
name: 'base64 document source',
input: {
type: 'document',
source: { type: 'base64', media_type: 'application/pdf', data: 'private-document' },
},
field: 'content',
},
{
name: 'untyped encoded data',
input: { payload: { data: 'a'.repeat(128) } },
field: 'content',
},
{
name: 'Google fileData URI',
input: {
fileData: {
fileUri: 'https://www.youtube.com/watch?v=dQw4w9WgXcQ',
mimeType: 'video/mp4',
},
},
field: 'content',
},
{
name: 'Google snake-case file_data URI',
input: {
file_data: {
file_uri: 'gs://private-bucket/video',
mime_type: 'video/mp4',
},
},
field: 'content',
},
{
name: 'Mistral document URL',
input: { type: 'document_url', document_url: 'https://example.test/report.pdf' },
field: 'content',
},
{
name: 'nested Mistral document URL',
input: {
type: 'document_url',
document_url: { url: 'https://example.test/report.pdf' },
},
field: 'content',
},
{
name: 'short provider-native audio media',
input: { type: 'media', mimeType: 'audio/wav', data: 'short-audio' },
field: 'content',
},
])('detects opaque $name', ({ input, field }) => {
const filters = {
files: { pii: { uninspectable: 'block' } },
} as FiltersConfig;
expect(getBlockedOpaqueFileField(filters, input)).toBe(field);
});
it.each([
['file_ids', { tool_resources: { code_interpreter: { file_ids: ['file-1'] } } }],
[
'vector_store_ids',
{ tool_resources: { file_search: { vector_store_ids: ['vector-store-1'] } } },
],
])('detects opaque %s arrays', (_field, input) => {
const filters = {
files: {
pii: {
fields: ['extracted_text'],
uninspectable: 'block',
},
},
} as FiltersConfig;
expect(getBlockedOpaqueFileField(filters, input)).toBe('extracted_text');
});
it('preserves default allow behavior and explicit file-field granularity', () => {
const remoteImage = { type: 'input_image', image_url: 'https://example.test/image.png' };
const imageFile = { type: 'input_image', file_id: 'image-file-id' };
const fileData = { type: 'input_file', file_data: 'private-file-data' };
const inputAudio = { type: 'input_audio', input_audio: { data: 'private-audio' } };
expect(
getBlockedOpaqueFileField(
{ files: { pii: { fields: ['content'] } } } as FiltersConfig,
remoteImage,
),
).toBeNull();
expect(
getBlockedOpaqueFileField(
{
files: {
pii: { fields: ['transcript'], uninspectable: 'block' },
},
} as FiltersConfig,
imageFile,
),
).toBeNull();
expect(
getBlockedOpaqueFileField(
{
files: {
pii: { fields: ['extracted_text'], uninspectable: 'block' },
},
} as FiltersConfig,
remoteImage,
),
).toBeNull();
expect(
getBlockedOpaqueFileField(
{
files: {
pii: { fields: ['extracted_text'], uninspectable: 'block' },
},
} as FiltersConfig,
fileData,
),
).toBe('extracted_text');
expect(
getBlockedOpaqueFileField(
{
files: {
pii: { fields: ['transcript'], uninspectable: 'block' },
},
} as FiltersConfig,
{ type: 'media', mimeType: 'audio/wav', data: 'short-audio' },
),
).toBe('transcript');
expect(
getBlockedOpaqueFileField(
{
files: {
pii: { fields: ['extracted_text'], uninspectable: 'block' },
},
} as FiltersConfig,
{ fileData: { fileUri: 'gs://bucket/file' } },
),
).toBe('extracted_text');
expect(
getBlockedOpaqueFileField(
{
files: {
pii: { fields: ['transcript'], uninspectable: 'block' },
},
} as FiltersConfig,
{ fileData: { fileUri: 'gs://bucket/video', mimeType: 'video/mp4' } },
),
).toBeNull();
expect(
getBlockedOpaqueFileField(
{
files: {
pii: { fields: ['transcript'], uninspectable: 'block' },
},
} as FiltersConfig,
{ file_data: { file_uri: 'gs://bucket/video', MIMEType: 'video/mp4' } },
),
).toBeNull();
expect(
getBlockedOpaqueFileField(
{
files: {
pii: { fields: ['transcript'], uninspectable: 'block' },
},
} as FiltersConfig,
inputAudio,
),
).toBe('transcript');
expect(
getBlockedOpaqueFileField(
{
files: {
pii: { fields: ['transcript'], uninspectable: 'block' },
},
} as FiltersConfig,
'data:audio/wav;base64,opaque-root-audio',
),
).toBe('transcript');
expect(
getBlockedOpaqueFileField(
{
files: {
pii: { fields: ['extracted_text'], uninspectable: 'block' },
},
} as FiltersConfig,
[
{ image_url: 'data:image/png;base64,irrelevant-for-extracted-text' },
{ file_data: 'opaque-file-data' },
],
),
).toBe('extracted_text');
});
it('is cycle-safe and keeps the thrown response raw-free', () => {
const input: { file?: unknown; file_id?: string } = {};
input.file = input;
input.file_id = 'file-do-not-echo';
const filters = {
files: { pii: { fields: ['extracted_text'], uninspectable: 'block' } },
} as FiltersConfig;
const field = getBlockedOpaqueFileField(filters, input);
expect(field).toBe('extracted_text');
const error = new UninspectableFileError(field ?? 'content');
expect(error.body).toEqual({
error: 'content_filter_uninspectable',
message: 'Submitted file content could not be inspected before processing.',
source: 'file',
field: 'extracted_text',
});
expect(JSON.stringify(error.body)).not.toContain('file-do-not-echo');
});
it('fails closed when an opaque-content traversal exceeds its depth budget', () => {
const input: { nested?: unknown } = {};
let cursor = input;
for (let index = 0; index < 30; index++) {
const nested: { nested?: unknown } = {};
cursor.nested = nested;
cursor = nested;
}
const filters = {
files: {
pii: {
fields: ['extracted_text'],
uninspectable: 'block',
},
},
} as FiltersConfig;
expect(getBlockedOpaqueFileField(filters, input)).toBe('extracted_text');
});
it('fails closed without materializing or scheduling an over-wide opaque object', () => {
const input: Record<string, unknown> = {};
for (let index = 0; index < 4_200; index++) {
input[`field_${index}`] = { value: index };
}
const filters = {
files: {
pii: {
fields: ['extracted_text'],
uninspectable: 'block',
},
},
} as FiltersConfig;
expect(getBlockedOpaqueFileField(filters, input)).toBe('extracted_text');
});
it('does not read opaque file ID arrays beyond the traversal budget', () => {
const fileIds: unknown[] = Array.from({ length: 4_200 }, () => null);
let overflowValueRead = false;
Object.defineProperty(fileIds, '4096', {
enumerable: true,
get() {
overflowValueRead = true;
return 'PRIVATE-OVERFLOW';
},
});
const filters = {
files: {
pii: {
fields: ['extracted_text'],
uninspectable: 'block',
},
},
} as FiltersConfig;
expect(getBlockedOpaqueFileField(filters, { file_ids: fileIds })).toBe('extracted_text');
expect(overflowValueRead).toBe(false);
});
it('fails closed for invalid opaque file-array lengths without dispatching iterators', () => {
let iteratorReads = 0;
const fileIds = new Proxy(['unread-file'], {
get(target, property, receiver) {
if (property === 'length') {
return Number.NaN;
}
if (property === Symbol.iterator) {
iteratorReads++;
throw new Error('file iterator must not run');
}
return Reflect.get(target, property, receiver);
},
});
const filters = {
files: {
pii: {
fields: ['extracted_text'],
uninspectable: 'block',
},
},
} as FiltersConfig;
expect(getBlockedOpaqueFileField(filters, { file_ids: fileIds })).toBe('extracted_text');
expect(iteratorReads).toBe(0);
});
it('reads canonical file arrays numerically without dispatching custom iterators', async () => {
let iteratorReads = 0;
let numericReads = 0;
const fileIds = new Proxy(['owned-file'], {
get(target, property, receiver) {
if (property === Symbol.iterator) {
iteratorReads++;
throw new Error('file iterator must not run');
}
if (typeof property === 'string' && /^\d+$/.test(property)) {
numericReads++;
}
return Reflect.get(target, property, receiver);
},
});
const filters = {
files: {
pii: {
fields: ['extracted_text'],
uninspectable: 'block',
},
},
} as FiltersConfig;
await expect(
resolveCanonicalFileReferences({
filters,
input: { file_ids: fileIds },
user: { id: 'user-1' },
getFiles: jest
.fn()
.mockResolvedValue([{ file_id: 'owned-file', text: 'Safe extracted text' }]),
}),
).resolves.toMatchObject({ sanitizedInput: {} });
expect(iteratorReads).toBe(0);
expect(numericReads).toBeLessThanOrEqual(2);
});
it('rejects invalid canonical file-reference lengths before owner lookup', async () => {
const fileIds = new Proxy(['owned-file'], {
get(target, property, receiver) {
return property === 'length' ? -1 : Reflect.get(target, property, receiver);
},
});
const getFiles = jest.fn();
const filters = {
files: {
pii: {
fields: ['extracted_text'],
uninspectable: 'block',
},
},
} as FiltersConfig;
await expect(
resolveCanonicalFileReferences({
filters,
input: { file_ids: fileIds },
user: { id: 'user-1' },
getFiles,
}),
).rejects.toMatchObject({ code: 'content_filter_uninspectable' });
expect(getFiles).not.toHaveBeenCalled();
});
it('rejects an over-wide canonical-reference input before an owner lookup', async () => {
const files = Array.from({ length: 4_200 }, (_, index) => ({
file_id: `file-${index}`,
}));
const getFiles = jest.fn().mockResolvedValue([]);
const filters = {
files: {
pii: {
fields: ['extracted_text'],
starterPatterns: [],
uninspectable: 'block',
},
},
} as FiltersConfig;
await expect(
resolveCanonicalFileReferences({
filters,
input: { files },
user: { id: 'user-1' },
getFiles,
}),
).rejects.toMatchObject({
code: 'content_filter_uninspectable',
body: { source: 'file', field: 'extracted_text' },
});
expect(getFiles).not.toHaveBeenCalled();
});
it.each(['name', 'uri'] as const)(
'does not let an oversized non-file subtree reject %s-only file policy',
async (field) => {
const input = {
messages: Array.from({ length: 4_200 }, (_, index) => ({
text: `ordinary message ${index}`,
})),
};
const getFiles = jest.fn();
const filters = {
files: {
pii: {
fields: [field],
starterPatterns: [],
customPatterns: [
{
id: 'private-file-field',
label: 'private file field',
regex: 'PRIVATE-FILE-[A-Z]+',
},
],
uninspectable: 'block',
},
},
} as FiltersConfig;
await expect(
resolveCanonicalFileReferences({
filters,
input,
user: { id: 'user-1' },
getFiles,
}),
).resolves.toMatchObject({
sanitizedInput: input,
hydratedFiles: [],
});
expect(getFiles).not.toHaveBeenCalled();
},
);
it.each(['name', 'uri'] as const)(
'fails closed when an actual file subtree exceeds %s-only inspection bounds',
async (field) => {
const getFiles = jest.fn();
const filters = {
files: {
pii: {
fields: [field],
starterPatterns: [],
customPatterns: [
{
id: 'private-file-field',
label: 'private file field',
regex: 'PRIVATE-FILE-[A-Z]+',
},
],
},
},
} as FiltersConfig;
await expect(
resolveCanonicalFileReferences({
filters,
input: {
files: Array.from({ length: 4_200 }, (_, index) => ({
file_id: `file-${index}`,
})),
},
user: { id: 'user-1' },
getFiles,
}),
).rejects.toMatchObject({
code: 'content_filter_uninspectable',
body: { source: 'file', field },
});
expect(getFiles).not.toHaveBeenCalled();
},
);
it('allows an oversized canonical file subtree for an audit-only policy', async () => {
const input = {
files: Array.from({ length: 4_200 }, (_, index) => ({
file_id: `file-${index}`,
})),
};
const getFiles = jest.fn();
await expect(
resolveCanonicalFileReferences({
filters: {
files: {
pii: {
action: 'audit',
fields: ['uri'],
starterPatterns: [],
customPatterns: [
{
id: 'private-file-field',
label: 'private file field',
regex: 'PRIVATE-FILE-[A-Z]+',
},
],
},
},
},
input,
user: { id: 'user-1' },
getFiles,
}),
).resolves.toMatchObject({ sanitizedInput: input, hydratedFiles: [] });
expect(getFiles).not.toHaveBeenCalled();
});
it('hydrates discovered file names without rejecting an unrelated oversized subtree', async () => {
const onTraversalFailure = jest.fn();
const canonicalFile = {
file_id: 'owned-file',
filename: 'safe-report.txt',
};
const input = {
files: [{ file_id: canonicalFile.file_id }],
messages: Array.from({ length: 4_200 }, (_, index) => ({
text: `ordinary message ${index}`,
})),
};
const getFiles = jest.fn().mockResolvedValue([canonicalFile]);
const filters = {
files: {
pii: {
fields: ['name'],
starterPatterns: [],
customPatterns: [
{
id: 'private-name',
label: 'private name',
regex: 'PRIVATE-NAME-[A-Z]+',
},
],
},
},
} as FiltersConfig;
await expect(
resolveCanonicalFileReferences({
filters,
input,
user: { id: 'user-1' },
getFiles,
onTraversalFailure,
messageCount: input.messages.length,
}),
).resolves.toMatchObject({
sanitizedInput: input,
hydratedFiles: [canonicalFile],
});
expect(onTraversalFailure).toHaveBeenCalledWith(
expect.objectContaining({
operation: 'omit_resolved_file_locators',
reason: 'array_length',
messageCount: 4200,
resolvedFileCount: 1,
}),
);
expect(getFiles).toHaveBeenCalledWith(
{ file_id: { $in: ['owned-file'] }, user: 'user-1' },
{},
{},
);
});
it('fails closed when opaque-content enumeration fails', () => {
const hostile = new Proxy(
{},
{
ownKeys() {
throw new Error('blocked enumeration');
},
},
);
const filters = {
files: {
pii: {
fields: ['extracted_text'],
uninspectable: 'block',
},
},
} as FiltersConfig;
expect(getBlockedOpaqueFileField(filters, { content: hostile })).toBe('extracted_text');
expect(
getBlockedOpaqueFileField(
{
files: {
pii: {
fields: ['name'],
uninspectable: 'block',
},
},
} as FiltersConfig,
{ content: hostile },
),
).toBeNull();
});
it('owner-scopes and hydrates durable file references before opaque checks', async () => {
const filters = {
files: {
pii: {
fields: ['extracted_text'],
uninspectable: 'block',
},
},
} as FiltersConfig;
const getFiles = jest.fn().mockResolvedValue([
{
file_id: 'owned-file',
filename: 'report.txt',
filepath: '/uploads/report.txt',
text: 'safe extracted text',
},
]);
const inspection = await resolveCanonicalFileReferences({
filters,
input: {
files: [
{
file_id: 'owned-file',
filepath: '/uploads/report.txt',
type: 'text/plain',
},
],
},
user: { id: 'user-1', tenantId: 'tenant-1' },
getFiles,
});
expect(getFiles).toHaveBeenCalledWith(
{
file_id: { $in: ['owned-file'] },
user: 'user-1',
tenantId: 'tenant-1',
},
{},
{},
);
expect(inspection.sanitizedInput).toEqual({
files: [{ type: 'text/plain' }],
});
expect(inspection.hydratedFiles).toEqual([
expect.objectContaining({
file_id: 'owned-file',
text: 'safe extracted text',
}),
]);
expect(inspection.hydratedFilters?.files?.pii?.uninspectable).toBe('allow');
expect(getBlockedOpaqueFileField(filters, inspection.sanitizedInput)).toBeNull();
});
it('ignores owner-query rows that were not referenced by the inspected input', async () => {
const filters = {
files: {
pii: {
fields: ['extracted_text'],
uninspectable: 'block',
},
},
} as FiltersConfig;
const ownedFile = {
file_id: 'owned-file',
filename: 'report.txt',
text: 'safe extracted text',
};
await expect(
resolveCanonicalFileReferences({
filters,
input: { files: [{ file_id: 'owned-file' }] },
user: { id: 'user-1' },
getFiles: jest.fn().mockResolvedValue([
ownedFile,
{
file_id: 'unrequested-file',
filename: 'unrequested.pdf',
},
]),
}),
).resolves.toMatchObject({
hydratedFiles: [ownedFile],
});
});
it('does not authorize an unresolved live file identifier', async () => {
const filters = {
files: {
pii: {
fields: ['extracted_text'],
starterPatterns: [],
uninspectable: 'block',
},
},
} as FiltersConfig;
const getFiles = jest.fn().mockResolvedValue([]);
await expect(
resolveCanonicalFileReferences({
filters,
input: { files: [{ file_id: 'foreign-file' }] },
user: { id: 'user-1', tenantId: 'tenant-1' },
trustedLiveFiles: [
{
file_id: 'foreign-file',
filepath: '/uploads/foreign.txt',
text: 'apparently inspectable text',
},
],
getFiles,
}),
).rejects.toMatchObject({
code: 'content_filter_uninspectable',
body: {
source: 'file',
field: 'extracted_text',
},
});
expect(getFiles).toHaveBeenCalledWith(
{
file_id: { $in: ['foreign-file'] },
user: 'user-1',
tenantId: 'tenant-1',
},
{},
{},
);
});
it('keeps unresolved live identifiers visible in compatibility mode', async () => {
const filters = {
files: {
pii: {
fields: ['extracted_text'],
starterPatterns: [],
uninspectable: 'allow',
},
},
} as FiltersConfig;
const input = { files: [{ file_id: 'foreign-file' }] };
const inspection = await resolveCanonicalFileReferences({
filters,
input,
user: { id: 'user-1' },
trustedLiveFiles: [{ file_id: 'foreign-file', text: 'untrusted supplemental text' }],
getFiles: jest.fn().mockResolvedValue([]),
});
expect(inspection.sanitizedInput).toBe(input);
expect(inspection.hydratedFiles).toEqual([]);
});
it('supplements only an owner-resolved row without trusting live identity or locators', async () => {
const filters = {
files: {
pii: {
fields: ['extracted_text'],
starterPatterns: [],
uninspectable: 'block',
},
},
} as FiltersConfig;
const canonicalFile = {
file_id: 'owned-file',
filename: 'canonical.pdf',
filepath: '/uploads/canonical.pdf',
uri: '/api/files/owned-file',
url: 'https://cdn.example.test/canonical.pdf',
type: 'application/pdf',
source: 'local',
};
const inspection = await resolveCanonicalFileReferences({
filters,
input: {
files: [{ file_id: canonicalFile.file_id, filepath: canonicalFile.filepath }],
},
user: { id: 'user-1' },
trustedLiveFiles: [
{
file_id: canonicalFile.file_id,
filename: 'forged.txt',
filepath: '/api/files/untrusted',
uri: '/api/files/untrusted',
url: '/api/files/untrusted',
preview: '/api/files/untrusted',
type: 'text/plain',
source: 'text',
extractedText: 'safe supplemental text',
},
],
getFiles: jest.fn().mockResolvedValue([canonicalFile]),
});
expect(inspection.sanitizedInput).toEqual({ files: [{}] });
expect(inspection.hydratedFiles).toEqual([
expect.objectContaining({
...canonicalFile,
extractedText: 'safe supplemental text',
}),
]);
expect(inspection.hydratedFiles[0]).not.toHaveProperty('preview');
});
it('prefers trusted runtime extraction fields while keeping canonical identity and locators', async () => {
const filters = {
files: {
pii: {
fields: ['extracted_text'],
starterPatterns: [],
uninspectable: 'block',
},
},
} as FiltersConfig;
const canonicalFile = {
file_id: 'owned-file',
filename: 'canonical.pdf',
filepath: '/uploads/canonical.pdf',
type: 'application/pdf',
source: 'local',
extractedText: 'stale durable text',
};
const inspection = await resolveCanonicalFileReferences({
filters,
input: { files: [{ file_id: canonicalFile.file_id }] },
user: { id: 'user-1' },
trustedLiveFiles: [
{
file_id: canonicalFile.file_id,
filename: 'forged.txt',
filepath: '/api/files/untrusted',
type: 'text/plain',
source: 'text',
extractedText: 'new runtime text',
},
],
getFiles: jest.fn().mockResolvedValue([canonicalFile]),
});
expect(inspection.hydratedFiles).toEqual([
{
...canonicalFile,
extractedText: 'new runtime text',
},
]);
});
it('lets trusted runtime nulls clear stale durable extraction coverage', async () => {
const filters = {
files: {
pii: {
fields: ['extracted_text'],
starterPatterns: [],
uninspectable: 'block',
},
},
} as FiltersConfig;
await expect(
resolveCanonicalFileReferences({
filters,
input: { files: [{ file_id: 'owned-file' }] },
user: { id: 'user-1' },
trustedLiveFiles: [
{
file_id: 'owned-file',
extractedText: null,
text: null,
},
],
getFiles: jest.fn().mockResolvedValue([
{
file_id: 'owned-file',
filename: 'report.pdf',
type: 'application/pdf',
extractedText: 'stale durable text',
},
]),
}),
).rejects.toMatchObject({
code: 'content_filter_uninspectable',
body: { source: 'file', field: 'extracted_text' },
});
});
it('keeps live files without identifiers inspectable', async () => {
const filters = {
files: {
pii: {
fields: ['extracted_text'],
starterPatterns: [],
uninspectable: 'block',
},
},
} as FiltersConfig;
const liveFile = {
filename: 'pending.txt',
type: 'text/plain',
source: 'text',
text: 'safe pending text',
};
await expect(
resolveCanonicalFileReferences({
filters,
input: {},
user: { id: 'user-1' },
trustedLiveFiles: [liveFile],
getFiles: jest.fn().mockResolvedValue([]),
}),
).resolves.toMatchObject({
hydratedFiles: [liveFile],
});
});
it.each([
[
'max_depth',
() => {
let value: object = {};
for (let i = 0; i < 26; i++) value = { child: value };
return value;
},
],
['max_nodes', () => [...Array.from({ length: 2047 }, () => ({ child: {} })), {}, {}]],
['array_length', () => new Array(4096)],
[
'object_entries',
() => Object.fromEntries(Array.from({ length: 4096 }, (_, i) => [i, 'safe'])),
],
[
'reflection_error',
() =>
Object.defineProperty({}, 'payload', {
enumerable: true,
get() {
throw new Error('PRIVATE-CONTENT');
},
}),
],
[
'reflection_error',
() =>
Object.defineProperty([], '0', {
get() {
throw new Error('PRIVATE-CONTENT');
},
}),
],
[
'reflection_error',
() => {
const { proxy, revoke } = Proxy.revocable({}, {});
revoke();
return proxy;
},
],
] as const)('reports safe %s diagnostics for locator sanitization', (reason, makeInput) => {
const report = jest.fn();
let failure: ContentTraversalLimitError | undefined;
try {
omitResolvedCanonicalFileLocators(makeInput(), new Map([['owned', { file_id: 'owned' }]]), {
onTraversalFailure: report,
messageCount: 58,
});
} catch (error) {
expect(error).toBeInstanceOf(ContentTraversalLimitError);
failure = error as ContentTraversalLimitError;
}
expect(failure).toBeDefined();
expect(failure?.diagnostics).toEqual({
operation: 'omit_resolved_file_locators',
reason,
visitedNodes: expect.any(Number),
depth: expect.any(Number),
});
expect(failure?.body).not.toHaveProperty('diagnostics');
expect(report).toHaveBeenCalledTimes(1);
expect(report).toHaveBeenCalledWith({
...failure?.diagnostics,
messageCount: 58,
resolvedFileCount: 1,
});
expect(JSON.stringify(report.mock.calls)).not.toContain('PRIVATE-CONTENT');
});
it('preserves own __proto__ opaque payloads in a null-prototype inspection copy', () => {
const input = JSON.parse('{"file_id":"owned","__proto__":{"file_id":"unresolved"}}');
const sanitized = omitResolvedCanonicalFileLocators(
input,
new Map([['owned', { file_id: 'owned' }]]),
);
expect(Object.getPrototypeOf(sanitized)).toBeNull();
expect(Object.prototype.hasOwnProperty.call(sanitized, '__proto__')).toBe(true);
expect(
getBlockedOpaqueFileField({ files: { pii: { uninspectable: 'block' } } }, sanitized),
).not.toBeNull();
});
it('omits only locators that exactly match the resolved canonical row', () => {
const canonicalFile = {
file_id: 'owned-file',
filepath: '/uploads/report.txt',
uri: 'https://files.example.test/report.txt',
url: 'https://cdn.example.test/report.txt',
preview: '/api/files/owned-file/preview',
};
const input = {
files: [
{
file_id: canonicalFile.file_id,
filepath: canonicalFile.filepath,
uri: canonicalFile.uri,
url: canonicalFile.url,
preview: canonicalFile.preview,
type: 'text/plain',
},
],
};
const sanitized = omitResolvedCanonicalFileLocators(
input,
new Map([[canonicalFile.file_id, canonicalFile]]),
);
expect(sanitized).toEqual({
files: [{ type: 'text/plain' }],
});
expect(input.files[0]).toEqual({
file_id: 'owned-file',
filepath: '/uploads/report.txt',
uri: 'https://files.example.test/report.txt',
url: 'https://cdn.example.test/report.txt',
preview: '/api/files/owned-file/preview',
type: 'text/plain',
});
});
it.each([
['uri alias for preview', { uri: '/api/files/owned-file/preview' }],
['url alias for preview', { url: '/api/files/owned-file/preview' }],
['filepath alias for preview', { filepath: '/api/files/owned-file/preview' }],
['preview alias', { preview: '/api/files/owned-file/preview' }],
])('omits an exact canonical preview through the %s', (_name, locator) => {
const canonicalFile = {
file_id: 'owned-file',
preview: '/api/files/owned-file/preview',
};
const input = {
files: [{ file_id: canonicalFile.file_id, ...locator }],
};
expect(
omitResolvedCanonicalFileLocators(input, new Map([[canonicalFile.file_id, canonicalFile]])),
).toEqual({ files: [{}] });
});
it.each([
['remote uri', { uri: 'https://attacker.example/private.txt' }],
['remote url', { url: 'https://attacker.example/private.txt' }],
['relative url', { url: '/api/files/untrusted' }],
['remote filepath', { filepath: 'https://attacker.example/private.txt' }],
['remote preview', { preview: 'https://attacker.example/private.txt' }],
['data URI', { uri: 'data:text/plain;base64,U0VDUkVU' }],
])('keeps a conflicting sibling %s visible to fail-close', async (_name, locator) => {
const filters = {
files: {
pii: {
starterPatterns: [],
uninspectable: 'block',
},
},
} as FiltersConfig;
const canonicalFile = {
file_id: 'owned-file',
filename: 'report.txt',
filepath: '/uploads/report.txt',
type: 'text/plain',
source: 'text',
text: 'safe canonical content',
};
const input = {
files: [{ file_id: canonicalFile.file_id, ...locator }],
};
const inspection = await resolveCanonicalFileReferences({
filters,
input,
user: { id: 'user-1' },
getFiles: jest.fn().mockResolvedValue([canonicalFile]),
});
expect(inspection.sanitizedInput).toEqual({
files: [locator],
});
expect(getBlockedOpaqueFileField(filters, inspection.sanitizedInput)).toBe('content');
expect(input.files[0]).toEqual({ file_id: 'owned-file', ...locator });
});
it('preserves conflicting locators without resolving an inactive allow policy', async () => {
const filters = {
files: {
pii: {
starterPatterns: [],
},
},
} as FiltersConfig;
const canonicalFile = {
file_id: 'owned-file',
filename: 'report.txt',
filepath: '/uploads/report.txt',
text: 'safe canonical content',
};
const input = {
files: [
{
file_id: canonicalFile.file_id,
uri: 'https://attacker.example/private.txt',
},
],
};
const getFiles = jest.fn().mockResolvedValue([canonicalFile]);
const inspection = await resolveCanonicalFileReferences({
filters,
input,
user: { id: 'user-1' },
getFiles,
});
expect(inspection.sanitizedInput).toBe(input);
expect(getFiles).not.toHaveBeenCalled();
expect(getBlockedOpaqueFileField(filters, inspection.sanitizedInput)).toBeNull();
});
it('remains cycle-safe and does not mutate locator-bearing input', () => {
const file: {
file_id: string;
filepath: string;
uri: string;
self?: unknown;
} = {
file_id: 'owned-file',
filepath: '/uploads/report.txt',
uri: 'https://attacker.example/private.txt',
};
file.self = file;
const input = { file };
const sanitized = omitResolvedCanonicalFileLocators(
input,
new Map([
[
'owned-file',
{
file_id: 'owned-file',
filepath: '/uploads/report.txt',
},
],
]),
);
expect(sanitized).not.toBe(input);
expect(sanitized.file).not.toBe(file);
expect(sanitized.file).toMatchObject({
uri: 'https://attacker.example/private.txt',
});
expect(sanitized.file.self).toBe(sanitized.file);
expect(file).toMatchObject({
file_id: 'owned-file',
filepath: '/uploads/report.txt',
uri: 'https://attacker.example/private.txt',
});
expect(file.self).toBe(file);
});
it('always omits resolved IDs from file_ids arrays while preserving unresolved IDs', () => {
const input = {
tool_resources: {
file_search: {
file_ids: ['owned-file', 'unresolved-file'],
},
},
};
expect(
omitResolvedCanonicalFileLocators(
input,
new Map([['owned-file', { file_id: 'owned-file' }]]),
),
).toEqual({
tool_resources: {
file_search: {
file_ids: ['unresolved-file'],
},
},
});
expect(input.tool_resources.file_search.file_ids).toEqual(['owned-file', 'unresolved-file']);
});
it('reuses an inspected text upload when every file field is enabled fail-closed', async () => {
const filters = {
files: {
pii: {
uninspectable: 'block',
},
},
} as FiltersConfig;
const canonicalTextFile = {
file_id: 'owned-text-file',
filename: 'notes.txt',
filepath: '/uploads/notes.txt',
type: 'text/plain',
source: 'text',
text: 'safe submitted text',
};
await expect(
resolveCanonicalFileReferences({
filters,
input: {
files: [{ file_id: canonicalTextFile.file_id }],
},
user: { id: 'user-1' },
getFiles: jest.fn().mockResolvedValue([canonicalTextFile]),
}),
).resolves.toMatchObject({
sanitizedInput: { files: [{}] },
hydratedFiles: [canonicalTextFile],
});
});
it('keeps raw binary content fail-closed when a legacy preview text is present', async () => {
const filters = {
files: {
pii: {
fields: ['content'],
uninspectable: 'block',
},
},
} as FiltersConfig;
await expect(
resolveCanonicalFileReferences({
filters,
input: { files: [{ file_id: 'legacy-binary-file' }] },
user: { id: 'user-1' },
getFiles: jest.fn().mockResolvedValue([
{
file_id: 'legacy-binary-file',
filename: 'report.pdf',
type: 'application/pdf',
source: 'local',
text: 'legacy preview text',
},
]),
}),
).rejects.toMatchObject({
code: 'content_filter_uninspectable',
body: {
source: 'file',
field: 'content',
},
});
});
it.each([
['empty canonical extracted text', { extractedText: '' }],
['whitespace-only canonical extracted text', { extractedText: ' \n\t' }],
['empty canonical text fallback', { text: '' }],
['whitespace-only canonical text fallback', { text: ' \n\t' }],
])('keeps %s fail-closed for persisted document reuse', async (_label, extractionFields) => {
const filters = {
files: {
pii: {
fields: ['extracted_text'],
starterPatterns: [],
uninspectable: 'block',
},
},
} as FiltersConfig;
await expect(
resolveCanonicalFileReferences({
filters,
input: { files: [{ file_id: 'blank-extraction-document' }] },
user: { id: 'user-1' },
getFiles: jest.fn().mockResolvedValue([
{
file_id: 'blank-extraction-document',
filename: 'report.pdf',
type: 'application/pdf',
...extractionFields,
},
]),
}),
).rejects.toMatchObject({
code: 'content_filter_uninspectable',
body: {
source: 'file',
field: 'extracted_text',
},
});
});
it('keeps audio transcripts fail-closed without text-extraction provenance', async () => {
const filters = {
files: {
pii: {
fields: ['transcript'],
uninspectable: 'block',
},
},
} as FiltersConfig;
await expect(
resolveCanonicalFileReferences({
filters,
input: { files: [{ file_id: 'legacy-audio-file' }] },
user: { id: 'user-1' },
getFiles: jest.fn().mockResolvedValue([
{
file_id: 'legacy-audio-file',
filename: 'recording.webm',
type: 'audio/webm',
source: 'local',
text: 'unclassified legacy text',
},
]),
}),
).rejects.toMatchObject({
code: 'content_filter_uninspectable',
body: {
source: 'file',
field: 'transcript',
},
});
});
it.each([
['empty canonical transcript', { transcript: '' }],
['whitespace-only canonical transcript', { transcript: ' \n\t' }],
['empty canonical text fallback', { source: 'text', text: '' }],
['whitespace-only canonical text fallback', { source: 'text', text: ' \n\t' }],
])('keeps %s fail-closed for persisted audio reuse', async (_label, transcriptFields) => {
const filters = {
files: {
pii: {
fields: ['transcript'],
starterPatterns: [],
uninspectable: 'block',
},
},
} as FiltersConfig;
await expect(
resolveCanonicalFileReferences({
filters,
input: { files: [{ file_id: 'blank-transcript-audio' }] },
user: { id: 'user-1' },
getFiles: jest.fn().mockResolvedValue([
{
file_id: 'blank-transcript-audio',
filename: 'recording.webm',
type: 'audio/webm',
...transcriptFields,
},
]),
}),
).rejects.toMatchObject({
code: 'content_filter_uninspectable',
body: {
source: 'file',
field: 'transcript',
},
});
});
it('treats application/ogg text provenance as an inspectable audio transcript', async () => {
const filters = {
files: {
pii: {
fields: ['transcript'],
starterPatterns: [],
uninspectable: 'block',
},
},
} as FiltersConfig;
await expect(
resolveCanonicalFileReferences({
filters,
input: { files: [{ file_id: 'ogg-audio-file' }] },
user: { id: 'user-1' },
getFiles: jest.fn().mockResolvedValue([
{
file_id: 'ogg-audio-file',
filename: 'recording.ogg',
type: 'application/ogg',
source: 'text',
text: 'safe transcript',
},
]),
}),
).resolves.toMatchObject({
hydratedFiles: [expect.objectContaining({ text: 'safe transcript' })],
});
});
it.each([undefined, '', 'not-a-mime'])(
'keeps transcript policy fail-closed for unknown MIME %p',
async (type) => {
const filters = {
files: {
pii: {
fields: ['transcript'],
starterPatterns: [],
uninspectable: 'block',
},
},
} as FiltersConfig;
await expect(
resolveCanonicalFileReferences({
filters,
input: { files: [{ file_id: 'unknown-media' }] },
user: { id: 'user-1' },
getFiles: jest.fn().mockResolvedValue([
{
file_id: 'unknown-media',
filename: 'media.bin',
type,
},
]),
}),
).rejects.toMatchObject({
code: 'content_filter_uninspectable',
body: { source: 'file', field: 'transcript' },
});
},
);
it('exempts a known non-audio MIME from transcript coverage', async () => {
const filters = {
files: {
pii: {
fields: ['transcript'],
starterPatterns: [],
uninspectable: 'block',
},
},
} as FiltersConfig;
await expect(
resolveCanonicalFileReferences({
filters,
input: { files: [{ file_id: 'known-document' }] },
user: { id: 'user-1' },
getFiles: jest.fn().mockResolvedValue([
{
file_id: 'known-document',
filename: 'report.pdf',
type: 'application/pdf',
},
]),
}),
).resolves.toMatchObject({
sanitizedInput: { files: [{}] },
});
});
it('resolves canonical file_ids arrays but leaves unresolved opaque IDs fail-closed', async () => {
const filters = {
files: {
pii: {
fields: ['extracted_text'],
uninspectable: 'block',
},
},
} as FiltersConfig;
const getFiles = jest.fn().mockResolvedValue([
{
file_id: 'owned-file',
filename: 'report.txt',
filepath: '/uploads/report.txt',
text: 'safe extracted text',
},
]);
await expect(
resolveCanonicalFileReferences({
filters,
input: {
tool_resources: {
file_search: {
file_ids: ['owned-file', 'unresolved-file'],
},
},
},
user: { id: 'user-1' },
getFiles,
}),
).rejects.toMatchObject({
code: 'content_filter_uninspectable',
body: {
source: 'file',
field: 'extracted_text',
},
});
});
it('does not let a resolved file ID hide a sibling opaque payload', async () => {
const filters = {
files: {
pii: {
fields: ['extracted_text'],
uninspectable: 'block',
},
},
} as FiltersConfig;
const inspection = await resolveCanonicalFileReferences({
filters,
input: {
files: [{ file_id: 'owned-file' }, { file_data: 'opaque-file-data' }],
},
user: { id: 'user-1' },
getFiles: jest.fn().mockResolvedValue([
{
file_id: 'owned-file',
filename: 'report.txt',
filepath: '/uploads/report.txt',
text: 'safe extracted text',
},
]),
});
expect(getBlockedOpaqueFileField(filters, inspection.sanitizedInput)).toBe('extracted_text');
});
});
describe('canonical file inspection units', () => {
const filters: FiltersConfig = {
files: {
pii: {
fields: ['extracted_text'],
starterPatterns: [],
uninspectable: 'block',
},
},
};
it('retains a single oversized-unit rejection before owner lookup', async () => {
const getFiles = jest.fn(async () => [{ file_id: 'owned', text: 'safe' }]);
await expect(
resolveCanonicalFileReferenceUnits({
filters,
user: { id: 'owner' },
getFiles,
input: [
{
files: [{ file_id: 'owned' }],
content: Array.from({ length: 4200 }, () => ({ text: 'safe' })),
},
],
}),
).rejects.toMatchObject({ code: 'content_filter_uninspectable' });
expect(getFiles).not.toHaveBeenCalled();
});
it('does not dispatch array map or iterators while sanitizing units', async () => {
const units = [{ file_id: 'owned' }, { file_id: 'missing' }];
const map = jest.fn(() => []);
const iterator = jest.fn(() => {
throw new Error('iterator must not execute');
});
Object.defineProperty(units, 'map', { value: map });
Object.defineProperty(units, Symbol.iterator, { value: iterator });
const input = {
filters,
input: units,
user: { id: 'owner' },
getFiles: jest.fn(async () => [{ file_id: 'owned', text: 'safe' }]),
};
await expect(resolveCanonicalFileReferenceUnits(input)).rejects.toMatchObject({
code: 'content_filter_uninspectable',
});
units.pop();
await expect(resolveCanonicalFileReferenceUnits(input)).resolves.toMatchObject({
sanitizedInput: [{}],
});
expect(map).not.toHaveBeenCalled();
expect(iterator).not.toHaveBeenCalled();
});
});