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 type { FiltersConfig } from 'librechat-data-provider';
import type { SerializedSharedFile } from './protection';
import {
CONTENT_TRAVERSAL_MAX_NODES,
ContentTraversalLimitError,
} from '../protection/adapters/nested';
import { assertSharedFileMetadataAllowed, createShareContentPreflight } from './protection';
import { ContentFilterError } from '../middleware/contentFilter';
import { UninspectableFileError } from '../protection/files';
const BLOCK_PATTERN = {
id: 'private',
label: 'private value',
regex: 'PRIVATE-[A-Z]+',
};
function capturePolicyError(
run: () => void,
): ContentFilterError | ContentTraversalLimitError | UninspectableFileError {
try {
run();
} catch (error) {
if (
error instanceof ContentFilterError ||
error instanceof ContentTraversalLimitError ||
error instanceof UninspectableFileError
) {
return error;
}
throw error;
}
throw new Error('Expected content policy to reject the shared metadata');
}
describe('native protected message sharing', () => {
it('inspects the remainder of canonical messages without matching generated revision tokens', async () => {
const revision = 'a'.repeat(32);
const message = {
isCreatedByUser: true,
text: `Email [EMAIL_1_${revision}]`,
privacyRevision: revision,
};
const preflight = createShareContentPreflight({
messages: {
pii: {
action: 'redact',
fields: ['text'],
starterPatterns: [],
customPatterns: [
{ id: 'hex', label: 'Credential', regex: '[a-f0-9]{32}', category: 'credential' },
],
},
},
});
await expect(preflight!({ title: 'Safe', messages: [message] })).resolves.toBeUndefined();
const publicMessage = { isCreatedByUser: true, text: message.text };
await expect(
preflight!({ title: 'Safe', messages: [publicMessage] }, { canonicalMessages: [message] }),
).resolves.toBeUndefined();
expect(publicMessage).not.toHaveProperty('privacyRevision');
await expect(
preflight!({
title: 'Safe',
messages: [{ ...message, text: `${message.text} ${'f'.repeat(32)}` }],
}),
).rejects.toThrow();
await expect(
preflight!({ title: 'Safe', messages: [{ ...message, privacyRevision: undefined }] }),
).rejects.toThrow();
});
});
describe('shared file metadata protection', () => {
const attachmentFilters: FiltersConfig = {
messages: {
pii: {
fields: ['attachment_reference'],
starterPatterns: [],
customPatterns: [BLOCK_PATTERN],
},
},
};
const fileUriFilters: FiltersConfig = {
files: {
pii: {
fields: ['uri'],
starterPatterns: [],
customPatterns: [BLOCK_PATTERN],
},
},
};
const fileContentFilters: FiltersConfig = {
files: {
pii: {
fields: ['content'],
starterPatterns: [],
customPatterns: [BLOCK_PATTERN],
},
},
};
const contentPartFilters: FiltersConfig = {
messages: {
pii: {
fields: ['content_part'],
starterPatterns: [],
customPatterns: [BLOCK_PATTERN],
},
},
};
const skillNameFilters: FiltersConfig = {
skills: {
pii: {
fields: ['name'],
starterPatterns: [],
customPatterns: [BLOCK_PATTERN],
},
},
};
const toolOutputFilters: FiltersConfig = {
toolArguments: {
pii: {
fields: ['output'],
starterPatterns: [],
customPatterns: [BLOCK_PATTERN],
},
},
};
it.each([
['files', { files: [{ filename: 'PRIVATE-SENTINEL.pdf' }] }],
['attachments', { attachments: [{ filename: 'PRIVATE-SENTINEL.pdf' }] }],
[
'steer files',
{
content: [
{
type: 'steer',
files: [{ filename: 'PRIVATE-SENTINEL.pdf' }],
},
],
},
],
])('checks serialized %s under message attachment-reference policy', (_label, message) => {
const error = capturePolicyError(() =>
assertSharedFileMetadataAllowed({
filters: attachmentFilters,
messages: [message],
shareId: 'share-123',
}),
);
expect(error).toBeInstanceOf(ContentFilterError);
expect(error.body).toMatchObject({
error: 'content_filter_block',
source: 'message',
field: 'attachment_reference',
});
expect(JSON.stringify(error.body)).not.toContain('PRIVATE-SENTINEL');
});
it.each([
[
'image_file names',
{
files: {
pii: {
fields: ['name'],
starterPatterns: [],
customPatterns: [BLOCK_PATTERN],
},
},
} satisfies FiltersConfig,
{ type: 'image_file', image_file: { filename: 'PRIVATE-SENTINEL.png' } },
'name',
],
[
'input_file names',
{
files: {
pii: {
fields: ['name'],
starterPatterns: [],
customPatterns: [BLOCK_PATTERN],
},
},
} satisfies FiltersConfig,
{ type: 'input_file', filename: 'PRIVATE-SENTINEL.pdf', file_data: 'safe' },
'name',
],
[
'file URIs',
fileUriFilters,
{ type: 'file', file: { url: 'https://example.test/PRIVATE-SENTINEL' } },
'uri',
],
[
'input_image URLs',
fileUriFilters,
{ type: 'input_image', image_url: 'https://example.test/PRIVATE-SENTINEL' },
'uri',
],
[
'input_audio payloads',
fileContentFilters,
{ type: 'input_audio', input_audio: { data: 'PRIVATE-SENTINEL', format: 'wav' } },
'content',
],
[
'Google media payloads',
fileContentFilters,
{ type: 'media', mimeType: 'text/plain', data: 'PRIVATE-SENTINEL' },
'content',
],
[
'Google inlineData payloads',
fileContentFilters,
{
type: 'image_url',
inlineData: {
mimeType: 'text/plain',
data: Buffer.from('PRIVATE-SENTINEL '.repeat(10)).toString('base64'),
},
},
'content',
],
[
'Google fileData URIs',
fileUriFilters,
{
fileData: {
fileUri: 'gs://private-bucket/PRIVATE-SENTINEL',
mimeType: 'video/mp4',
},
},
'uri',
],
[
'Google snake-case file_data URIs',
fileUriFilters,
{
file_data: {
file_uri: 'gs://private-bucket/PRIVATE-SENTINEL',
mime_type: 'video/mp4',
},
},
'uri',
],
[
'Google top-level fileUri values',
fileUriFilters,
{
type: 'media',
fileUri: 'https://example.test/PRIVATE-SENTINEL',
mimeType: 'video/mp4',
},
'uri',
],
[
'Mistral document_url values',
fileUriFilters,
{
type: 'document_url',
document_url: 'https://example.test/PRIVATE-SENTINEL',
},
'uri',
],
[
'nested Mistral document_url values',
fileUriFilters,
{
type: 'document_url',
document_url: { url: 'https://example.test/PRIVATE-SENTINEL' },
},
'uri',
],
[
'Anthropic document sources',
fileContentFilters,
{
type: 'document',
source: {
type: 'base64',
media_type: 'text/plain',
data: 'PRIVATE-SENTINEL',
},
},
'content',
],
[
'Bedrock document names',
{
files: {
pii: {
fields: ['name'],
starterPatterns: [],
customPatterns: [BLOCK_PATTERN],
},
},
} satisfies FiltersConfig,
{
type: 'document',
document: {
name: 'PRIVATE-SENTINEL',
format: 'pdf',
source: { bytes: Buffer.from('safe') },
},
},
'name',
],
])('checks non-steer content-part %s under file policy', (_label, filters, part, field) => {
const error = capturePolicyError(() =>
assertSharedFileMetadataAllowed({
filters,
messages: [{ isCreatedByUser: false, isUserSubmitted: false, content: [part] }],
shareId: 'share-123',
}),
);
expect(error).toBeInstanceOf(ContentFilterError);
expect(error.body).toMatchObject({
error: 'content_filter_block',
source: 'file',
field,
});
expect(JSON.stringify(error.body)).not.toContain('PRIVATE-SENTINEL');
});
it.each([
['OpenAI input files', { type: 'input_file', file_data: 'opaque-file-data' }],
['OpenAI input images', { type: 'input_image', file_id: 'unsnapshotted-file' }],
['OpenAI image files', { type: 'image_file', file_id: 'unsnapshotted-file' }],
['Google media', { type: 'media', mimeType: 'application/pdf', data: 'opaque-media' }],
[
'Google inlineData',
{
type: 'image_url',
inlineData: { mimeType: 'image/png', data: 'opaque-inline-image' },
},
],
[
'Google fileData',
{
fileData: { fileUri: 'gs://private-bucket/video', mimeType: 'video/mp4' },
},
],
[
'Mistral document_url',
{
type: 'document_url',
document_url: 'https://example.test/private-report.pdf',
},
],
[
'Anthropic sources',
{
type: 'document',
source: {
type: 'base64',
media_type: 'application/pdf',
data: 'opaque-document',
},
},
],
[
'Bedrock document bytes',
{
type: 'document',
document: {
name: 'report',
format: 'pdf',
source: { bytes: Buffer.from('opaque-document') },
},
},
],
])('applies fail-close file policy to non-steer content-part %s', (_label, part) => {
const error = capturePolicyError(() =>
assertSharedFileMetadataAllowed({
filters: {
files: {
pii: {
fields: ['content'],
starterPatterns: [],
customPatterns: [],
uninspectable: 'block',
},
},
},
messages: [
{
isCreatedByUser: false,
isUserSubmitted: false,
content: [part],
},
],
shareId: 'share-123',
}),
);
expect(error).toBeInstanceOf(UninspectableFileError);
expect(error.body).toMatchObject({
error: 'content_filter_uninspectable',
source: 'file',
field: 'content',
});
});
it('preserves explicit content-part provenance for attachment-reference policy', () => {
const part = {
type: 'input_file',
filename: 'PRIVATE-SENTINEL.pdf',
file_data: 'safe',
};
expect(() =>
assertSharedFileMetadataAllowed({
filters: attachmentFilters,
messages: [{ isCreatedByUser: false, isUserSubmitted: false, content: [part] }],
shareId: 'share-123',
}),
).not.toThrow();
expect(() =>
assertSharedFileMetadataAllowed({
filters: attachmentFilters,
messages: [
{
isCreatedByUser: false,
isUserSubmitted: false,
userSubmittedPaths: ['/content/0'],
content: [part],
},
],
shareId: 'share-123',
}),
).toThrow(ContentFilterError);
});
it('preserves nested file field granularity in provider content parts', () => {
expect(() =>
assertSharedFileMetadataAllowed({
filters: fileContentFilters,
messages: [
{
isCreatedByUser: false,
isUserSubmitted: false,
content: [
{
type: 'file',
file: { filename: 'PRIVATE-SENTINEL.pdf', file_data: 'safe' },
},
{
type: 'input_file',
filename: 'safe.pdf',
file_id: 'safe-file-id',
vendor_metadata: 'PRIVATE-SENTINEL',
},
{
fileData: {
fileUri: 'gs://private-bucket/PRIVATE-SENTINEL',
mimeType: 'video/mp4',
},
},
{
file_data: {
file_uri: 'gs://private-bucket/PRIVATE-SENTINEL',
mime_type: 'video/mp4',
},
},
{
type: 'document_url',
document_url: 'https://example.test/PRIVATE-SENTINEL',
},
],
},
],
shareId: 'share-123',
}),
).not.toThrow();
});
it('does not treat generic content-part source metadata as a file carrier', () => {
expect(() =>
assertSharedFileMetadataAllowed({
filters: fileContentFilters,
messages: [
{
isCreatedByUser: false,
isUserSubmitted: false,
content: [
{
type: 'tool_call',
source: { data: 'PRIVATE-SENTINEL' },
},
],
},
],
shareId: 'share-123',
}),
).not.toThrow();
});
it.each([
[
'iconURL',
attachmentFilters,
{ iconURL: 'https://example.test/PRIVATE-SENTINEL' },
'message',
'attachment_reference',
],
[
'finish_reason',
contentPartFilters,
{ finish_reason: 'PRIVATE-SENTINEL' },
'message',
'content_part',
],
['manualSkills', skillNameFilters, { manualSkills: ['PRIVATE-SENTINEL'] }, 'skill', 'name'],
[
'alwaysAppliedSkills',
skillNameFilters,
{ alwaysAppliedSkills: ['PRIVATE-SENTINEL'] },
'skill',
'name',
],
])(
'checks serialized public %s metadata at the response boundary',
(_label, filters, metadata, source, field) => {
const error = capturePolicyError(() =>
assertSharedFileMetadataAllowed({
filters,
messages: [{ isCreatedByUser: true, ...metadata }],
shareId: 'share-123',
}),
);
expect(error).toBeInstanceOf(ContentFilterError);
expect(error.body).toMatchObject({
error: 'content_filter_block',
source,
field,
});
expect(JSON.stringify(error.body)).not.toContain('PRIVATE-SENTINEL');
},
);
it('rechecks unmarked legacy shared metadata conservatively', () => {
const error = capturePolicyError(() =>
assertSharedFileMetadataAllowed({
filters: attachmentFilters,
messages: [{ iconURL: 'https://example.test/PRIVATE-SENTINEL' }],
shareId: 'share-123',
}),
);
expect(error.body).toMatchObject({
source: 'message',
field: 'attachment_reference',
});
});
it('does not let ineffective provenance paths suppress conservative shared metadata checks', () => {
const error = capturePolicyError(() =>
assertSharedFileMetadataAllowed({
filters: attachmentFilters,
messages: [
{
isCreatedByUser: false,
userSubmittedPaths: ['/missing'],
iconURL: 'https://example.test/PRIVATE-SENTINEL',
},
],
shareId: 'share-123',
}),
);
expect(error.body).toMatchObject({
source: 'message',
field: 'attachment_reference',
});
});
it('applies the configured attribution policy to legacy assistant metadata', () => {
const compatibilityError = capturePolicyError(() =>
assertSharedFileMetadataAllowed({
filters: attachmentFilters,
messages: [
{
isCreatedByUser: false,
iconURL: 'https://example.test/PRIVATE-SENTINEL',
},
],
shareId: 'share-123',
}),
);
expect(compatibilityError.body).toMatchObject({
source: 'message',
field: 'attachment_reference',
});
const strictError = capturePolicyError(() =>
assertSharedFileMetadataAllowed({
filters: {
messages: {
...attachmentFilters.messages,
unattributedAssistantContent: 'inspect',
},
},
messages: [
{
isCreatedByUser: false,
iconURL: 'https://example.test/PRIVATE-SENTINEL',
},
],
shareId: 'share-123',
}),
);
expect(strictError.body).toMatchObject({
source: 'message',
field: 'attachment_reference',
});
expect(() =>
assertSharedFileMetadataAllowed({
filters: {
messages: {
...attachmentFilters.messages,
unattributedAssistantContent: 'inspect',
},
},
messages: [
{
isCreatedByUser: false,
isUserSubmitted: false,
iconURL: 'https://example.test/PRIVATE-SENTINEL',
},
],
shareId: 'share-123',
}),
).not.toThrow();
const error = capturePolicyError(() =>
assertSharedFileMetadataAllowed({
filters: {
messages: {
...attachmentFilters.messages,
unattributedAssistantContent: 'inspect',
},
},
messages: [
{
isCreatedByUser: false,
userSubmittedPaths: ['/iconURL'],
iconURL: 'https://example.test/PRIVATE-SENTINEL',
},
],
shareId: 'share-123',
}),
);
expect(error.body).toMatchObject({
source: 'message',
field: 'attachment_reference',
});
});
it('applies legacy attribution to shared assistant attachment projections', () => {
const legacyAttachment = {
reference: { label: 'PRIVATE-SENTINEL' },
};
const strictFilters: FiltersConfig = {
messages: {
...attachmentFilters.messages,
unattributedAssistantContent: 'inspect',
},
};
expect(() =>
assertSharedFileMetadataAllowed({
filters: attachmentFilters,
messages: [{ isCreatedByUser: false, attachments: [legacyAttachment] }],
shareId: 'share-123',
}),
).not.toThrow();
expect(() =>
assertSharedFileMetadataAllowed({
filters: strictFilters,
messages: [{ isCreatedByUser: false, attachments: [legacyAttachment] }],
shareId: 'share-123',
}),
).toThrow(ContentFilterError);
expect(() =>
assertSharedFileMetadataAllowed({
filters: strictFilters,
messages: [
{
isCreatedByUser: false,
isUserSubmitted: false,
attachments: [legacyAttachment],
},
],
shareId: 'share-123',
}),
).not.toThrow();
expect(() =>
assertSharedFileMetadataAllowed({
filters: strictFilters,
messages: [
{
isCreatedByUser: false,
isUserSubmitted: false,
userSubmittedPaths: ['/attachments/0'],
attachments: [legacyAttachment],
},
],
shareId: 'share-123',
}),
).toThrow(ContentFilterError);
});
it('preserves conservative attachment attribution for role-only legacy rows', () => {
expect(() =>
assertSharedFileMetadataAllowed({
filters: attachmentFilters,
messages: [
{
role: 'assistant',
attachments: [{ reference: { label: 'PRIVATE-SENTINEL' } }],
},
],
shareId: 'share-123',
}),
).toThrow(ContentFilterError);
});
it.each(['/missing', '/role', '/__proto__/polluted'])(
'does not let ineffective shared provenance path %s suppress strict attribution',
(userSubmittedPath) => {
expect(() =>
assertSharedFileMetadataAllowed({
filters: {
messages: {
...attachmentFilters.messages,
unattributedAssistantContent: 'inspect',
},
},
messages: [
{
isCreatedByUser: false,
role: 'assistant',
userSubmittedPaths: [userSubmittedPath],
attachments: [{ reference: { label: 'PRIVATE-SENTINEL' } }],
},
],
shareId: 'share-123',
}),
).toThrow(ContentFilterError);
},
);
it('keeps shared response metadata protection default-off', () => {
expect(() =>
assertSharedFileMetadataAllowed({
messages: [
{
iconURL: 'https://example.test/PRIVATE-SENTINEL',
finish_reason: 'PRIVATE-SENTINEL',
manualSkills: ['PRIVATE-SENTINEL'],
alwaysAppliedSkills: ['PRIVATE-SENTINEL'],
},
],
shareId: 'share-123',
}),
).not.toThrow();
});
it.each([
['uri', 'message', attachmentFilters, 'message', 'attachment_reference'],
['filepath', 'message', attachmentFilters, 'message', 'attachment_reference'],
['url', 'message', attachmentFilters, 'message', 'attachment_reference'],
['preview', 'message', attachmentFilters, 'message', 'attachment_reference'],
['uri', 'file', fileUriFilters, 'file', 'uri'],
['filepath', 'file', fileUriFilters, 'file', 'uri'],
['url', 'file', fileUriFilters, 'file', 'uri'],
['preview', 'file', fileUriFilters, 'file', 'uri'],
])(
'checks serialized %s aliases under the configured %s policy',
(key, _policy, filters, source, field) => {
const error = capturePolicyError(() =>
assertSharedFileMetadataAllowed({
filters,
messages: [
{
files: [
{
filename: 'safe-report.pdf',
[key]: 'https://example.test/PRIVATE-SENTINEL',
},
],
},
],
shareId: 'share-123',
}),
);
expect(error).toBeInstanceOf(ContentFilterError);
expect(error.body).toMatchObject({
error: 'content_filter_block',
source,
field,
});
expect(JSON.stringify(error.body)).not.toContain('PRIVATE-SENTINEL');
},
);
it.each([
['message', attachmentFilters, 'message', 'attachment_reference'],
['file', fileUriFilters, 'file', 'uri'],
])(
'checks bounded percent-decoded locators under the configured %s policy',
(_label, filters, source, field) => {
const error = capturePolicyError(() =>
assertSharedFileMetadataAllowed({
filters,
messages: [
{
files: [{ url: 'https://example.test/PRIVATE%2DSENTINEL' }],
},
],
shareId: 'share-123',
}),
);
expect(error).toBeInstanceOf(ContentFilterError);
expect(error.body).toMatchObject({
error: 'content_filter_block',
source,
field,
});
},
);
it('preserves file field granularity for serialized names', () => {
const filters: FiltersConfig = {
files: {
pii: {
fields: ['name'],
starterPatterns: [],
customPatterns: [BLOCK_PATTERN],
uninspectable: 'block',
},
},
};
const error = capturePolicyError(() =>
assertSharedFileMetadataAllowed({
filters,
messages: [{ files: [{ file_id: 'file-1', filename: 'PRIVATE-SENTINEL.pdf' }] }],
shareId: 'share-123',
}),
);
expect(error).toBeInstanceOf(ContentFilterError);
expect(error.body).toMatchObject({
error: 'content_filter_block',
source: 'file',
field: 'name',
});
expect(JSON.stringify(error.body)).not.toContain('PRIVATE-SENTINEL');
});
it.each([
[
'file locator',
fileUriFilters,
{
files: [{ url: { nested: 'PRIVATE-SENTINEL' } as never }],
},
'file',
'uri',
],
[
'user attachment',
attachmentFilters,
{
isCreatedByUser: true,
attachments: [{ filename: { nested: 'PRIVATE-SENTINEL' } as never }],
},
'message',
'attachment_reference',
],
[
'tool attachment',
toolOutputFilters,
{
isCreatedByUser: false,
attachments: [
{
toolCallId: 'call-search',
content: { nested: 'PRIVATE-SENTINEL' } as never,
},
],
},
'tool_argument',
'output',
],
])(
'traverses malformed standard %s metadata under its semantic provenance',
(_label, filters, message, source, field) => {
const error = capturePolicyError(() =>
assertSharedFileMetadataAllowed({
filters,
messages: [message],
shareId: 'share-123',
}),
);
expect(error).toBeInstanceOf(ContentFilterError);
expect(error.body).toMatchObject({
error: 'content_filter_block',
source,
field,
});
expect(JSON.stringify(error.body)).not.toContain('PRIVATE-SENTINEL');
},
);
it.each([
[
'file status',
fileContentFilters,
{
isCreatedByUser: true,
files: [{ status: 'PRIVATE-SENTINEL' }],
},
'file',
'content',
],
[
'attachment preview error',
attachmentFilters,
{
isCreatedByUser: true,
attachments: [{ previewError: 'PRIVATE-SENTINEL' }],
},
'message',
'attachment_reference',
],
[
'tool call identifier',
toolOutputFilters,
{
isCreatedByUser: false,
attachments: [{ toolCallId: 'PRIVATE-SENTINEL' }],
},
'tool_argument',
'output',
],
])(
'checks a standard serialized %s under its semantic provenance',
(_label, filters, message, source, field) => {
const error = capturePolicyError(() =>
assertSharedFileMetadataAllowed({
filters,
messages: [message],
shareId: 'share-123',
}),
);
expect(error).toBeInstanceOf(ContentFilterError);
expect(error.body).toMatchObject({
error: 'content_filter_block',
source,
field,
});
expect(JSON.stringify(error.body)).not.toContain('PRIVATE-SENTINEL');
},
);
it('keeps a user-submitted toolCallId under message provenance', () => {
const error = capturePolicyError(() =>
assertSharedFileMetadataAllowed({
filters: attachmentFilters,
messages: [
{
isCreatedByUser: true,
attachments: [{ toolCallId: 'PRIVATE-SENTINEL' }],
},
],
shareId: 'share-123',
}),
);
expect(error).toBeInstanceOf(ContentFilterError);
expect(error.body).toMatchObject({
error: 'content_filter_block',
source: 'message',
field: 'attachment_reference',
});
});
it('preserves field granularity for standard serialized strings', () => {
expect(() =>
assertSharedFileMetadataAllowed({
filters: {
files: {
pii: {
fields: ['name'],
starterPatterns: [],
customPatterns: [BLOCK_PATTERN],
},
},
},
messages: [
{
isCreatedByUser: true,
files: [{ status: 'PRIVATE-SENTINEL' }],
},
],
shareId: 'share-123',
}),
).not.toThrow();
});
it('keeps standard serialized string protection default-off', () => {
expect(() =>
assertSharedFileMetadataAllowed({
filters: {},
messages: [
{
isCreatedByUser: true,
files: [{ status: 'PRIVATE-SENTINEL' }],
attachments: [
{
previewError: 'PRIVATE-SENTINEL',
toolCallId: 'PRIVATE-SENTINEL',
},
],
},
],
shareId: 'share-123',
}),
).not.toThrow();
});
it.each([
[
'web-search result',
{
type: 'web_search',
toolCallId: 'call-search',
web_search: {
results: [{ title: 'PRIVATE-SENTINEL', link: 'https://example.test/safe' }],
},
},
],
[
'generated UI resource',
{
type: 'ui_resources',
toolCallId: 'call-ui',
ui_resources: {
components: [{ type: 'chart', props: { label: 'PRIVATE-SENTINEL' } }],
},
},
],
])('checks a nested serialized %s as tool output', (_label, attachment) => {
const error = capturePolicyError(() =>
assertSharedFileMetadataAllowed({
filters: toolOutputFilters,
messages: [{ isCreatedByUser: false, attachments: [attachment] }],
shareId: 'share-123',
}),
);
expect(error).toBeInstanceOf(ContentFilterError);
expect(error.body).toMatchObject({
error: 'content_filter_block',
source: 'tool_argument',
field: 'output',
});
expect(JSON.stringify(error.body)).not.toContain('PRIVATE-SENTINEL');
});
it.each([
['user-created message', { isCreatedByUser: true }],
['user-submitted message', { isUserSubmitted: true }],
['marked attachment path', { isCreatedByUser: false, userSubmittedPaths: ['/attachments/0'] }],
])('does not let a %s self-label nested metadata as tool output', (_label, provenance) => {
const error = capturePolicyError(() =>
assertSharedFileMetadataAllowed({
filters: attachmentFilters,
messages: [
{
...provenance,
attachments: [
{
type: 'web_search',
toolCallId: 'forged-tool-call',
web_search: { results: [{ title: 'PRIVATE-SENTINEL' }] },
},
],
},
],
shareId: 'share-123',
}),
);
expect(error).toBeInstanceOf(ContentFilterError);
expect(error.body).toMatchObject({
source: 'message',
field: 'attachment_reference',
});
});
it('keeps model tool payloads out of attachment-reference policy', () => {
expect(() =>
assertSharedFileMetadataAllowed({
filters: attachmentFilters,
messages: [
{
isCreatedByUser: false,
attachments: [
{
type: 'web_search',
toolCallId: 'call-search',
web_search: { results: [{ title: 'PRIVATE-SENTINEL' }] },
},
],
},
],
shareId: 'share-123',
}),
).not.toThrow();
});
it('inspects nested dynamic URLs under their semantic payload policy', () => {
const toolError = capturePolicyError(() =>
assertSharedFileMetadataAllowed({
filters: toolOutputFilters,
messages: [
{
isCreatedByUser: false,
attachments: [
{
type: 'web_search',
toolCallId: 'call-search',
web_search: {
results: [{ url: 'https://example.test/PRIVATE-SENTINEL' }],
},
},
],
},
],
shareId: 'share-123',
}),
);
const attachmentError = capturePolicyError(() =>
assertSharedFileMetadataAllowed({
filters: attachmentFilters,
messages: [
{
isCreatedByUser: true,
attachments: [
{
reference: {
url: 'https://example.test/PRIVATE-SENTINEL',
},
},
],
},
],
shareId: 'share-123',
}),
);
expect(toolError.body).toMatchObject({
source: 'tool_argument',
field: 'output',
});
expect(attachmentError.body).toMatchObject({
source: 'message',
field: 'attachment_reference',
});
});
it('checks raw encoded payloads and still fails closed when they cannot be decoded', () => {
const attachment = {
type: 'web_search',
toolCallId: 'call-search',
web_search: {
results: [{ data: 'data:application/pdf;base64,PRIVATE-SENTINEL' }],
},
};
const rawError = capturePolicyError(() =>
assertSharedFileMetadataAllowed({
filters: toolOutputFilters,
messages: [{ isCreatedByUser: false, attachments: [attachment] }],
shareId: 'share-123',
}),
);
expect(rawError).toBeInstanceOf(ContentFilterError);
expect(rawError.body).toMatchObject({
source: 'tool_argument',
field: 'output',
});
const error = capturePolicyError(() =>
assertSharedFileMetadataAllowed({
filters: {
files: {
pii: {
fields: ['content'],
starterPatterns: [],
uninspectable: 'block',
},
},
},
messages: [{ isCreatedByUser: false, attachments: [attachment] }],
shareId: 'share-123',
}),
);
expect(error).toBeInstanceOf(UninspectableFileError);
expect(error.body).toMatchObject({
source: 'file',
field: 'content',
});
});
it.each([
[
'file content',
fileContentFilters,
{
files: [
{
content: `data:text/plain;base64,${Buffer.from('PRIVATE-SENTINEL').toString('base64')}`,
},
],
},
'file',
'content',
],
[
'tool output',
toolOutputFilters,
{
isCreatedByUser: false,
attachments: [
{
toolCallId: 'call-search',
result: {
data: `data:application/json;base64,${Buffer.from(
'{"label":"PRIVATE-SENTINEL"}',
).toString('base64')}`,
},
},
],
},
'tool_argument',
'output',
],
[
'user attachment',
attachmentFilters,
{
isCreatedByUser: true,
attachments: [
{
result: {
data: 'data:text/plain,PRIVATE%2DSENTINEL',
},
},
],
},
'message',
'attachment_reference',
],
])(
'checks bounded decoded textual data URI payloads as %s',
(_label, filters, message, source, field) => {
const error = capturePolicyError(() =>
assertSharedFileMetadataAllowed({
filters,
messages: [message],
shareId: 'share-123',
}),
);
expect(error).toBeInstanceOf(ContentFilterError);
expect(error.body).toMatchObject({
error: 'content_filter_block',
source,
field,
});
expect(JSON.stringify(error.body)).not.toContain('PRIVATE-SENTINEL');
},
);
it('checks bounded decoded bare base64 payloads', () => {
const error = capturePolicyError(() =>
assertSharedFileMetadataAllowed({
filters: fileContentFilters,
messages: [
{
files: [
{
type: 'base64',
file_data: Buffer.from('PRIVATE-SENTINEL').toString('base64'),
},
],
},
],
shareId: 'share-123',
}),
);
expect(error).toBeInstanceOf(ContentFilterError);
expect(error.body).toMatchObject({
source: 'file',
field: 'content',
});
});
it('treats a bounded textual data URI as inspectable under strict file policy', () => {
const value = `data:text/plain;base64,${Buffer.from('safe content').toString('base64')}`;
const file = { content: value };
const filters: FiltersConfig = {
files: {
pii: {
fields: ['content'],
starterPatterns: [],
customPatterns: [],
uninspectable: 'block',
},
},
};
expect(() =>
assertSharedFileMetadataAllowed({
filters,
messages: [{ files: [file] }],
shareId: 'share-123',
}),
).not.toThrow();
expect(file.content).toBe(value);
expect(filters.files?.pii?.uninspectable).toBe('block');
});
it.each([
['malformed percent encoding', 'data:text/plain,SAFE%ZZ'],
['malformed base64', 'data:text/plain;base64,%%%'],
[
'oversized base64',
`data:text/plain;base64,${Buffer.alloc(256 * 1024 + 1, 0x41).toString('base64')}`,
],
['non-textual data', 'data:application/octet-stream;base64,QUJD'],
])('applies files.pii.uninspectable to %s', (_label, content) => {
const strictFilters: FiltersConfig = {
files: {
pii: {
fields: ['content'],
starterPatterns: [],
customPatterns: [],
uninspectable: 'block',
},
},
};
const compatibilityFilters: FiltersConfig = {
files: {
pii: {
fields: ['content'],
starterPatterns: [],
customPatterns: [],
uninspectable: 'allow',
},
},
};
const messages = [{ files: [{ content }] }];
const error = capturePolicyError(() =>
assertSharedFileMetadataAllowed({
filters: strictFilters,
messages,
shareId: 'share-123',
}),
);
expect(error).toBeInstanceOf(UninspectableFileError);
expect(error.body).toMatchObject({
error: 'content_filter_uninspectable',
source: 'file',
field: 'content',
});
expect(() =>
assertSharedFileMetadataAllowed({
filters: compatibilityFilters,
messages,
shareId: 'share-123',
}),
).not.toThrow();
});
it('keeps encoded and cyclic serialized metadata default-off', () => {
const cycle: Record<string, unknown> = {};
cycle.self = cycle;
expect(() =>
assertSharedFileMetadataAllowed({
messages: [
{
files: [
{
content: `data:text/plain;base64,${Buffer.alloc(256 * 1024 + 1, 0x41).toString(
'base64',
)}`,
url: cycle as never,
},
],
},
],
shareId: 'share-123',
}),
).not.toThrow();
});
it('does not traverse deep dynamic metadata for an inactive target policy', () => {
let payload: Record<string, unknown> = { label: 'PRIVATE-SENTINEL' };
for (let index = 0; index < 30; index++) {
payload = { nested: payload };
}
expect(() =>
assertSharedFileMetadataAllowed({
filters: {
messages: {
pii: {
fields: ['content_part'],
starterPatterns: [],
customPatterns: [BLOCK_PATTERN],
},
},
},
messages: [
{
isCreatedByUser: false,
attachments: [
{
type: 'web_search',
toolCallId: 'call-search',
web_search: payload,
},
],
},
],
shareId: 'share-123',
}),
).not.toThrow();
});
it('does not enumerate wide file metadata for an inactive target policy', () => {
const file = Object.fromEntries(
Array.from({ length: CONTENT_TRAVERSAL_MAX_NODES }, (_, index) => [
`dynamic_${index}`,
'safe',
]),
) as SerializedSharedFile;
let overflowValueRead = false;
Object.defineProperty(file, 'overflow_value', {
enumerable: true,
get() {
overflowValueRead = true;
return 'PRIVATE-OVERFLOW';
},
});
expect(() =>
assertSharedFileMetadataAllowed({
filters: contentPartFilters,
messages: [{ isCreatedByUser: false, attachments: [file] }],
shareId: 'share-123',
}),
).not.toThrow();
expect(overflowValueRead).toBe(false);
});
it('handles cycles while inspecting malformed standard metadata', () => {
const malformedUrl: Record<string, unknown> = {
label: 'PRIVATE-SENTINEL',
};
malformedUrl.self = malformedUrl;
const error = capturePolicyError(() =>
assertSharedFileMetadataAllowed({
filters: fileUriFilters,
messages: [{ files: [{ url: malformedUrl as never }] }],
shareId: 'share-123',
}),
);
expect(error).toBeInstanceOf(ContentFilterError);
expect(error.body).toMatchObject({
source: 'file',
field: 'uri',
});
const safeCycle: Record<string, unknown> = { label: 'safe' };
safeCycle.self = safeCycle;
expect(() =>
assertSharedFileMetadataAllowed({
filters: fileUriFilters,
messages: [{ files: [{ url: safeCycle as never }] }],
shareId: 'share-123',
}),
).not.toThrow();
});
it('fails closed with the malformed standard field provenance at the depth limit', () => {
let malformedUrl: Record<string, unknown> = { label: 'safe' };
for (let index = 0; index < 30; index++) {
malformedUrl = { nested: malformedUrl };
}
const error = capturePolicyError(() =>
assertSharedFileMetadataAllowed({
filters: fileUriFilters,
messages: [{ files: [{ url: malformedUrl as never }] }],
shareId: 'share-123',
}),
);
expect(error).toBeInstanceOf(ContentTraversalLimitError);
expect(error.body).toMatchObject({
error: 'content_filter_uninspectable',
source: 'file',
field: 'uri',
});
});
it('allows malformed metadata traversal failures for an audit-only policy', () => {
let malformedUrl: Record<string, unknown> = { label: 'safe' };
for (let index = 0; index < 30; index++) {
malformedUrl = { nested: malformedUrl };
}
expect(() =>
assertSharedFileMetadataAllowed({
filters: {
files: {
pii: {
action: 'audit',
fields: ['uri'],
starterPatterns: [],
customPatterns: [BLOCK_PATTERN],
},
},
},
messages: [{ files: [{ url: malformedUrl as never }] }],
shareId: 'share-123',
}),
).not.toThrow();
});
it('does not read serialized metadata beyond the traversal budget', () => {
const file = Object.fromEntries(
Array.from({ length: CONTENT_TRAVERSAL_MAX_NODES }, (_, index) => [
`dynamic_${index}`,
'safe',
]),
) as SerializedSharedFile;
let overflowValueRead = false;
Object.defineProperty(file, 'overflow_value', {
enumerable: true,
get() {
overflowValueRead = true;
return 'PRIVATE-OVERFLOW';
},
});
expect(() =>
assertSharedFileMetadataAllowed({
filters: fileContentFilters,
messages: [{ files: [file] }],
shareId: 'share-123',
}),
).toThrow(ContentTraversalLimitError);
expect(overflowValueRead).toBe(false);
});
it('checks arbitrary nested attachment metadata as an attachment reference', () => {
const error = capturePolicyError(() =>
assertSharedFileMetadataAllowed({
filters: attachmentFilters,
messages: [
{
attachments: [
{
filename: 'safe-result.json',
citation: { display: { label: 'PRIVATE-SENTINEL' } },
},
],
},
],
shareId: 'share-123',
}),
);
expect(error).toBeInstanceOf(ContentFilterError);
expect(error.body).toMatchObject({
source: 'message',
field: 'attachment_reference',
});
});
it('checks arbitrary nested serialized file payloads as file content', () => {
const filters: FiltersConfig = {
files: {
pii: {
fields: ['content'],
starterPatterns: [],
customPatterns: [BLOCK_PATTERN],
},
},
};
const error = capturePolicyError(() =>
assertSharedFileMetadataAllowed({
filters,
messages: [
{
files: [
{
filename: 'safe-generated.json',
generated: { payload: { label: 'PRIVATE-SENTINEL' } },
},
],
},
],
shareId: 'share-123',
}),
);
expect(error).toBeInstanceOf(ContentFilterError);
expect(error.body).toMatchObject({
source: 'file',
field: 'content',
});
});
it('does not classify nested model tool output as user message content', () => {
const filters: FiltersConfig = {
messages: {
pii: {
fields: ['content_part'],
starterPatterns: [],
customPatterns: [BLOCK_PATTERN],
},
},
};
expect(() =>
assertSharedFileMetadataAllowed({
filters,
messages: [
{
isCreatedByUser: false,
attachments: [
{
type: 'web_search',
toolCallId: 'call-search',
web_search: { results: [{ title: 'PRIVATE-SENTINEL' }] },
},
],
},
],
shareId: 'share-123',
}),
).not.toThrow();
});
it('permits absent bytes behind a server-issued shared-file locator', () => {
const filters: FiltersConfig = {
files: {
pii: {
fields: ['content'],
starterPatterns: [],
customPatterns: [],
uninspectable: 'block',
},
},
};
expect(() =>
assertSharedFileMetadataAllowed({
filters,
messages: [
{
files: [
{
file_id: 'file-1',
filename: 'safe-report.pdf',
uri: '/api/share/share-123/files/file-1',
filepath: '/api/share/share-123/files/file-1',
url: '/api/share/share-123/files/file-1',
preview: '/api/share/share-123/files/file-1',
},
],
},
],
shareId: 'share-123',
}),
).not.toThrow();
expect(filters.files?.pii?.uninspectable).toBe('block');
});
it.each([
['file_data', { file_data: 'data:application/pdf;base64,PRIVATE-SENTINEL' }],
['data URI content', { content: 'data:application/pdf;base64,PRIVATE-SENTINEL' }],
['nested data', { type: 'document', data: 'PRIVATE-SENTINEL' }],
['remote URL alias', { url: 'https://example.test/PRIVATE-SENTINEL' }],
['remote preview alias', { preview: 'https://example.test/PRIVATE-SENTINEL' }],
])('retains fail-close for serialized opaque %s payloads', (_label, payload) => {
const filters: FiltersConfig = {
files: {
pii: {
fields: ['content'],
starterPatterns: [],
customPatterns: [],
uninspectable: 'block',
},
},
};
const error = capturePolicyError(() =>
assertSharedFileMetadataAllowed({
filters,
messages: [
{
attachments: [
{
file_id: 'file-1',
filename: 'safe-report.pdf',
filepath: '/api/share/share-123/files/file-1',
...payload,
},
],
},
],
shareId: 'share-123',
}),
);
expect(error).toBeInstanceOf(UninspectableFileError);
expect(error.body).toEqual({
error: 'content_filter_uninspectable',
message: 'Submitted file content could not be inspected before processing.',
source: 'file',
field: 'content',
});
expect(JSON.stringify(error.body)).not.toContain('PRIVATE-SENTINEL');
});
});
describe('shared content preflight', () => {
const titleFilters: FiltersConfig = {
conversationTitles: {
pii: { starterPatterns: [], customPatterns: [BLOCK_PATTERN] },
},
};
const fileNameFilters: FiltersConfig = {
files: {
pii: { fields: ['name'], starterPatterns: [], customPatterns: [BLOCK_PATTERN] },
},
};
const fileMessage = {
isCreatedByUser: true,
files: [{ file_id: 'file-1', filename: 'PRIVATE-REPORT.pdf' }],
};
it('avoids allocating a callback when no source-aware or legacy policy exists', () => {
expect(createShareContentPreflight(undefined)).toBeUndefined();
});
it('applies conversation policy to the exact shared snapshot', async () => {
const preflight = createShareContentPreflight(titleFilters);
await expect(
preflight?.({ title: 'PRIVATE-TITLE', messages: [], shareId: 'share-123' }),
).rejects.toBeInstanceOf(ContentFilterError);
});
it('omits opted-out file references before snapshot inspection', async () => {
const preflight = createShareContentPreflight(fileNameFilters, { snapshotFiles: false });
await expect(
preflight?.({ title: 'Safe title', messages: [fileMessage], shareId: 'share-123' }),
).resolves.toBeUndefined();
});
it('keeps shared metadata policy separate from canonical snapshot hydration', async () => {
const preflight = createShareContentPreflight(fileNameFilters, {
snapshotFiles: true,
sharedFileMetadata: true,
});
await expect(
preflight?.({ title: 'Safe title', messages: [fileMessage], shareId: 'share-123' }),
).rejects.toBeInstanceOf(ContentFilterError);
});
});