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, MessageFilterPiiConfig } from 'librechat-data-provider';
import type { ModelBoundContentInput } from './middleware/modelBoundContent';
import type { GetCanonicalFilesForInspection } from './protection/files';
import { ContentTraversalLimitError } from './protection/adapters/nested';
import { assertConversationImportContentAllowed } from './imports';
const pattern = {
id: 'import-secret',
label: 'restricted import value',
regex: 'IMPORT-SECRET',
};
function messageFilters(
fields: NonNullable<NonNullable<FiltersConfig['messages']>['pii']>['fields'],
) {
return {
messages: {
pii: {
fields,
starterPatterns: [],
customPatterns: [pattern],
},
},
} satisfies FiltersConfig;
}
function deepValue(depth = 30): string | { nested: ReturnType<typeof deepValue> } {
let value: string | { nested: ReturnType<typeof deepValue> } = 'safe';
for (let index = 0; index < depth; index++) {
value = { nested: value };
}
return value;
}
describe('conversation import protection', () => {
it('reports incomplete locator hydration through the import context', async () => {
const onTraversalFailure = jest.fn();
await assertConversationImportContentAllowed(
{ files: { pii: { fields: ['name'], starterPatterns: ['sk_prefix'] } } },
{
conversations: [],
messages: [
{
files: [{ file_id: 'owned' }],
content: Array.from({ length: 4200 }, () => ({ type: 'text', text: 'safe' })),
},
],
},
{
user: { id: 'user-1' },
onTraversalFailure,
getFiles: jest.fn().mockResolvedValue([{ file_id: 'owned', filename: 'safe.txt' }]),
},
);
expect(onTraversalFailure).toHaveBeenCalledWith(
expect.objectContaining({
operation: 'omit_resolved_file_locators',
reason: 'array_length',
messageCount: 1,
resolvedFileCount: 1,
}),
);
});
it('returns without resolving or revalidating when protection is disabled', async () => {
const getFiles = jest.fn<
ReturnType<GetCanonicalFilesForInspection>,
Parameters<GetCanonicalFilesForInspection>
>();
const assertModelBoundContent = jest.fn<void, [ModelBoundContentInput]>();
await assertConversationImportContentAllowed(
undefined,
{
conversations: [{ title: 'IMPORT-SECRET' }],
messages: [{ isCreatedByUser: true, text: 'IMPORT-SECRET' }],
},
{ getFiles, assertModelBoundContent },
);
expect(getFiles).not.toHaveBeenCalled();
expect(assertModelBoundContent).not.toHaveBeenCalled();
});
it('extracts and blocks normalized conversation metadata before message revalidation', async () => {
const assertModelBoundContent = jest.fn<void, [ModelBoundContentInput]>();
const filters = {
conversationTitles: {
pii: {
fields: ['title'],
starterPatterns: [],
customPatterns: [pattern],
},
},
} satisfies FiltersConfig;
await expect(
assertConversationImportContentAllowed(
filters,
{
conversations: [{ title: 'Imported IMPORT-SECRET' }],
messages: [{ isCreatedByUser: true, text: 'safe' }],
},
{ assertModelBoundContent },
),
).rejects.toMatchObject({
code: 'content_filter_block',
body: { source: 'conversation_title', field: 'title' },
});
expect(assertModelBoundContent).not.toHaveBeenCalled();
});
it('uses partial conversation fragments before enforcing a selected traversal scope', async () => {
const filters = {
prompts: {
pii: {
fields: ['instructions'],
starterPatterns: [],
customPatterns: [pattern],
},
},
} satisfies FiltersConfig;
await expect(
assertConversationImportContentAllowed(filters, {
conversations: [
{
presetOverride: { instructions: 'later IMPORT-SECRET prompt' },
options: { provider_option: deepValue() },
},
],
messages: [],
}),
).rejects.toMatchObject({
code: 'content_filter_block',
body: { source: 'prompt', field: 'instructions' },
});
});
it('fails closed when a selected conversation traversal scope is incomplete', async () => {
const filters = {
modelParameters: {
pii: {
fields: ['request_fields'],
starterPatterns: [],
customPatterns: [pattern],
},
},
} satisfies FiltersConfig;
await expect(
assertConversationImportContentAllowed(filters, {
conversations: [{ options: { provider_option: deepValue() } }],
messages: [],
}),
).rejects.toBeInstanceOf(ContentTraversalLimitError);
});
it('resolves canonical files for the owner without mutating the pending snapshot', async () => {
const filters = {
files: {
pii: {
fields: ['extracted_text'],
uninspectable: 'block',
},
},
} satisfies FiltersConfig;
const snapshot = {
conversations: [{ title: 'safe' }],
messages: [
{
isCreatedByUser: true,
text: 'safe',
files: [{ file_id: 'owner-file-1' }],
},
],
};
const originalSnapshot = structuredClone(snapshot);
const canonicalFile = {
file_id: 'owner-file-1',
filename: 'notes.txt',
text: 'safe extracted text',
};
const getFiles = jest
.fn<ReturnType<GetCanonicalFilesForInspection>, Parameters<GetCanonicalFilesForInspection>>()
.mockResolvedValue([canonicalFile]);
const assertModelBoundContent = jest.fn<void, [ModelBoundContentInput]>();
await assertConversationImportContentAllowed(filters, snapshot, {
user: { id: 'user-123', tenantId: 'tenant-1' },
getFiles,
assertModelBoundContent,
});
expect(getFiles).toHaveBeenCalledWith(
{
file_id: { $in: ['owner-file-1'] },
user: 'user-123',
tenantId: 'tenant-1',
},
{},
{},
);
expect(assertModelBoundContent).toHaveBeenNthCalledWith(1, {
filters,
resolvedFiles: [canonicalFile],
});
expect(assertModelBoundContent).toHaveBeenNthCalledWith(2, {
filters,
legacyPii: undefined,
storedMessages: [expect.any(Object)],
});
expect(assertModelBoundContent.mock.calls[1][0].storedMessages).not.toEqual(snapshot.messages);
expect(snapshot).toEqual(originalSnapshot);
});
it('keeps legacy-only inspection active for submitted imported rows', async () => {
const legacyPii = {
starterPatterns: [],
customPatterns: [pattern],
} satisfies MessageFilterPiiConfig;
await expect(
assertConversationImportContentAllowed(
undefined,
{
conversations: [],
messages: [{ isCreatedByUser: true, text: 'Imported IMPORT-SECRET' }],
},
{ legacyPii },
),
).rejects.toMatchObject({
code: 'content_filter_block',
body: { source: 'message', field: 'text' },
});
});
it('inspects traversal partials from model-bound revalidation', async () => {
const filters = messageFilters(['content_part']);
const traversalError = new ContentTraversalLimitError(
[
{
id: 'stored-message.content',
path: '/content/0/text',
text: 'nested IMPORT-SECRET',
source: 'message',
field: 'content_part',
format: 'plain',
treatment: 'inspect_only',
provenance: 'user',
},
],
[{ source: 'message', fields: ['content_part'] }],
);
const assertModelBoundContent = jest.fn<void, [ModelBoundContentInput]>(() => {
throw traversalError;
});
await expect(
assertConversationImportContentAllowed(
filters,
{
conversations: [],
messages: [{ isCreatedByUser: true, content: [{ text: 'safe' }] }],
},
{ assertModelBoundContent },
),
).rejects.toMatchObject({
code: 'content_filter_block',
body: { source: 'message', field: 'content_part' },
});
});
it('preserves exact HITL traversal scopes from model-bound revalidation', async () => {
const filters = messageFilters(['answer']);
const traversalError = new ContentTraversalLimitError(
[],
[{ source: 'message', fields: ['answer'] }],
);
const assertModelBoundContent = jest.fn<void, [ModelBoundContentInput]>(() => {
throw traversalError;
});
await expect(
assertConversationImportContentAllowed(
filters,
{
conversations: [],
messages: [
{
role: 'assistant',
content: [{ type: 'tool_call', tool_call: { output: 'safe' } }],
userSubmittedMessageFieldPaths: [
{ path: '/content/0/tool_call/output', field: 'answer' },
],
},
],
},
{ assertModelBoundContent },
),
).rejects.toBe(traversalError);
});
it('revalidates messages independently after the one-time file pass', async () => {
const filters = messageFilters(['text']);
const messages = [
{ isCreatedByUser: true, text: 'first safe message' },
{ isCreatedByUser: true, text: 'second safe message' },
];
const assertModelBoundContent = jest.fn<void, [ModelBoundContentInput]>();
await assertConversationImportContentAllowed(
filters,
{ conversations: [], messages },
{ assertModelBoundContent },
);
expect(assertModelBoundContent.mock.calls).toEqual([
[{ filters, legacyPii: undefined, storedMessages: [messages[0]] }],
[{ filters, legacyPii: undefined, storedMessages: [messages[1]] }],
]);
});
});