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 { MEMORY_FILTER_FIELDS, hasActivePiiPatterns } from 'librechat-data-provider';
import type { FiltersConfig, MemoryFilterField } from 'librechat-data-provider';
import type { ContentTraversalLimitError } from '../protection/adapters/nested';
import type { MemoryContentInput } from '../protection/adapters/submissions';
import type { TextContentFragment } from '../protection/types';
import {
getContentTraversalScopes,
getContentTraversalFragments,
isContentTraversalProtected,
isContentTraversalLimitError,
} from '../protection/adapters/nested';
import { extractMemoryContent } from '../protection/adapters/submissions';
import { inspectContent } from '../protection/runtime';
export type ProjectedStoredMemory<T extends MemoryContentInput> = T & {
readonly contentFilterBlocked?: true;
};
interface StoredMemoryProjectionDeps {
readonly extract?: (memory: MemoryContentInput) => Iterable<TextContentFragment>;
}
interface ExtractedMemoryFragments {
readonly fragments: readonly TextContentFragment[];
readonly traversalError: ContentTraversalLimitError | null;
}
function extractStoredMemoryFragments(
memory: MemoryContentInput,
extract: StoredMemoryProjectionDeps['extract'],
): ExtractedMemoryFragments {
try {
return {
fragments: [...(extract?.(memory) ?? extractMemoryContent(memory))],
traversalError: null,
};
} catch (error) {
if (!isContentTraversalLimitError(error)) {
throw error;
}
return { fragments: getContentTraversalFragments(error), traversalError: error };
}
}
function getBlockedMemoryFields(
memory: MemoryContentInput,
filters: FiltersConfig,
extract: StoredMemoryProjectionDeps['extract'],
selectedFields: readonly MemoryFilterField[],
selectedFieldSet: ReadonlySet<MemoryFilterField>,
): ReadonlySet<MemoryFilterField> {
const fragmentsByField = new Map<MemoryFilterField, TextContentFragment[]>();
const blockedFields = new Set<MemoryFilterField>();
const { fragments, traversalError } = extractStoredMemoryFragments(memory, extract);
for (const fragment of fragments) {
if (fragment.source !== 'memory' || !selectedFieldSet.has(fragment.field)) {
continue;
}
const fieldFragments = fragmentsByField.get(fragment.field) ?? [];
fieldFragments.push(fragment);
fragmentsByField.set(fragment.field, fieldFragments);
}
for (const field of selectedFields) {
if (inspectContent(fragmentsByField.get(field) ?? [], { filters }) != null) {
blockedFields.add(field);
}
}
if (traversalError != null && isContentTraversalProtected({ error: traversalError, filters })) {
for (const scope of getContentTraversalScopes(traversalError)) {
if (scope.source !== 'memory') {
continue;
}
for (const field of scope.fields) {
if (selectedFieldSet.has(field)) {
blockedFields.add(field);
}
}
}
}
return blockedFields;
}
function redactStoredMemory<T extends MemoryContentInput>(
memory: T,
blockedFields: ReadonlySet<MemoryFilterField>,
): ProjectedStoredMemory<T> {
const redactKey = blockedFields.has('key');
const redactValue = blockedFields.has('value');
const redactSummary = blockedFields.has('summary') && memory.summary !== undefined;
return {
...memory,
...(redactKey ? { key: '' } : {}),
...(redactValue ? { value: '' } : {}),
...(redactSummary ? { summary: '' } : {}),
contentFilterBlocked: true,
};
}
/** Reapplies current memory policy while preserving structural management fields. */
export function projectStoredMemories<T extends MemoryContentInput>(
memories: readonly T[],
filters?: FiltersConfig,
deps: StoredMemoryProjectionDeps = {},
): ProjectedStoredMemory<T>[] {
if (filters == null) {
return [...memories];
}
const pii = filters.memories?.pii;
if (pii == null || !hasActivePiiPatterns(pii) || pii.fields?.length === 0) {
return [...memories];
}
const extract = deps.extract ?? extractMemoryContent;
const selectedFieldSet = new Set<MemoryFilterField>(pii.fields ?? MEMORY_FILTER_FIELDS);
const selectedFields = [...selectedFieldSet];
return memories.map((memory) => {
const blockedFields = getBlockedMemoryFields(
memory,
filters,
extract,
selectedFields,
selectedFieldSet,
);
if (blockedFields.size === 0) {
return memory;
}
return redactStoredMemory(memory, blockedFields);
});
}