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 { RequestHandler, Request, Response } from 'express';
import type { MessageMethods } from '@librechat/data-schemas';
import type { PrivateTextCipher } from './crypto';
import { ContentFilterError, isContentFilterError } from '../../middleware/contentFilter';
import { createPiiTextTransformer } from '../transform';
import { createPrivateTextCipher } from './crypto';
import { inspectContent } from '../runtime';
interface PrivateTextMessage {
messageId?: string;
conversationId?: string | null;
isCreatedByUser?: boolean;
text?: string;
privacyRevision?: string;
privateTextTokens?: readonly string[];
}
interface Capture {
readonly userId: string;
readonly tenantId: string;
readonly revision: string;
readonly text: string;
readonly envelope: string;
readonly cipher: PrivateTextCipher;
readonly admission: Promise<boolean>;
readonly admit: (allowed: boolean) => void;
readonly admissionState: () => boolean | undefined;
}
const captures = new WeakMap<object, Capture>();
const CONTROL_ROUTES = new Set([
'abort',
'steer',
'queued-turns',
'stream',
'status',
'active',
'resume',
]);
/** Every submitted text path can be denied before its route-specific filter runs. */
export function isPreDenialTextSubmission(req: Request): boolean {
return req.method === 'POST' && typeof req.body?.text === 'string';
}
/** Only actual interactive chat POSTs have an owner-view text sidecar in this slice. */
export function isPrivateTextChatSubmission(req: Request): boolean {
if (req.method !== 'POST' || typeof req.body?.text !== 'string') {
return false;
}
const path = req.originalUrl?.split('?', 1)[0]?.replace(/\/$/, '');
const base = '/api/agents/chat';
if (path === base) {
return true;
}
if (path == null || !path.startsWith(`${base}/`)) {
return false;
}
const child = path.slice(base.length + 1);
return child.length > 0 && !child.includes('/') && !CONTROL_ROUTES.has(child.toLowerCase());
}
function unavailable(): ContentFilterError {
return new ContentFilterError({
detectorId: 'pii-pattern',
ruleId: 'private-text',
label: 'private value that could not be protected',
source: 'message',
field: 'text',
provenance: 'user',
fragmentId: 'chat.text',
fragmentPath: '/text',
});
}
type PrivateTextRequest = Request & {
config?: { filters?: FiltersConfig; messageFilter?: { pii?: MessageFilterPiiConfig } };
};
/** A denial may persist a turn before the regular message filter runs. Never store unfiltered PII. */
export function rejectUnprotectedDeniedMessage(req: PrivateTextRequest, res: Response): boolean {
const filters = req.config?.filters;
const legacyPii = req.config?.messageFilter?.pii;
const text = req.body?.text;
if (
typeof text === 'string' &&
req.config == null &&
req.originalUrl?.split('?', 1)[0]?.startsWith('/api/agents/chat')
) {
res.status(400).json({
error: 'content_filter_block',
message: 'Private details could not be protected. Nothing was sent to the model.',
});
return true;
}
if (
typeof text !== 'string' ||
(filters?.messages?.pii == null && legacyPii == null) ||
captures.get(req)?.text === text
) {
return false;
}
try {
const finding = inspectContent(
[
{
id: 'chat.text',
path: '/text',
text,
source: 'message',
field: 'text',
format: 'plain',
treatment: 'replaceable',
provenance: 'user',
},
],
{ filters, legacyPii },
);
if (finding == null) {
return false;
}
} catch {
// A broken policy must not turn a denial into unfiltered storage.
}
res.status(400).json({
error: 'content_filter_block',
message: 'Private details could not be protected. Nothing was sent to the model.',
});
return true;
}
export function privateTextBinding(
userId: string,
tenantId: string,
message: PrivateTextMessage,
): string[] {
return [
userId,
tenantId,
message.conversationId ?? '',
message.messageId ?? '',
message.privacyRevision ?? '',
message.text ?? '',
];
}
/** Installed only on the authenticated interactive Agent chat router, before any content consumer. */
export function createPrivateTextIngress(options: {
getFilters(req: Request): FiltersConfig | undefined;
getLegacyPii(req: Request): MessageFilterPiiConfig | undefined;
getKey(): string;
}): RequestHandler {
return (req, res, next) => {
const rule = options.getFilters(req)?.messages?.pii;
if (rule?.action !== 'redact' || typeof req.body?.text !== 'string') {
next();
return;
}
const body = req.body as {
text: string;
clientRequestId?: string;
files?: object[];
quotes?: string[];
isEdited?: boolean;
isContinued?: boolean;
isRegenerate?: boolean;
compact?: boolean;
overrideParentMessageId?: string;
overrideConvoId?: string;
addedConvo?: boolean;
editedContent?: unknown;
recoverySteerId?: string;
responseMessageId?: string;
};
const request = req as Request & {
user?: { id?: string; tenantId?: string | null };
_isAgentTrigger?: boolean;
};
if (
req.path === '/resume' ||
request._isAgentTrigger === true ||
body.isEdited ||
body.isContinued ||
body.isRegenerate ||
body.compact ||
body.editedContent != null ||
body.recoverySteerId != null ||
(typeof body.clientRequestId === 'string' &&
body.clientRequestId.startsWith('steer-recovery:')) ||
body.overrideParentMessageId ||
body.overrideConvoId ||
body.addedConvo ||
body.files?.length ||
body.quotes?.length
) {
next();
return;
}
try {
const fragment = {
id: 'chat.text',
path: '/text',
text: body.text,
source: 'message',
field: 'text',
format: 'plain',
treatment: 'replaceable',
provenance: 'user',
} as const;
const legacy = inspectContent([fragment], { legacyPii: options.getLegacyPii(req) });
if (legacy != null) {
throw new ContentFilterError(legacy);
}
const result = createPiiTextTransformer(rule).createSession().transform(fragment);
if (result.replacements === 0) {
next();
return;
}
const userId = request.user?.id;
const tenantId = request.user?.tenantId ?? '';
if (
!userId ||
typeof body.clientRequestId !== 'string' ||
body.clientRequestId.length > 256
) {
throw unavailable();
}
const cipher = createPrivateTextCipher(options.getKey());
const revision = cipher.revision([userId, tenantId, body.clientRequestId, body.text]);
// A keyed, turn-specific namespace prevents unrelated historical placeholders aliasing.
const text = result.content.replace(
/\[(EMAIL|PHONE|NAME|CREDENTIAL|CUSTOM)_(\d+)\]/g,
(marker, category: string, index: string) =>
body.text.includes(marker) ? marker : `[${category}_${index}_${revision}]`,
);
const envelope = cipher.seal(body.text, [userId, tenantId, revision]);
let resolveAdmission!: (allowed: boolean) => void;
let admissionResult: boolean | undefined;
const admission = new Promise<boolean>((resolve) => {
resolveAdmission = resolve;
});
const admit = (allowed: boolean) => {
if (admissionResult === undefined) {
admissionResult = allowed;
resolveAdmission(allowed);
}
};
captures.set(req, {
userId,
tenantId,
revision,
text,
envelope,
cipher,
admission,
admit,
admissionState: () => admissionResult,
});
body.text = text;
next();
} catch {
res.status(400).json({
error: 'content_filter_block',
message: 'Private details could not be protected. Nothing was sent to the model.',
});
}
};
}
/** Only a user turn that will persist its sidecar advertises an owner-readable revision. */
export function stampPrivateTextMessage<T extends PrivateTextMessage>(
req: object | undefined,
message: T,
willPersist = true,
): T & { privacyRevision?: string } {
const capture = req == null ? undefined : captures.get(req);
if (
willPersist &&
capture != null &&
message.isCreatedByUser === true &&
message.text === capture.text
) {
message.privacyRevision = capture.revision;
}
return message;
}
/** Only the request that ran ingress may skip its exact, already-inspected submitted text. */
export function getPreinspectedPrivateText(req: Request): string | undefined {
const capture = captures.get(req);
return capture != null && req.body?.text === capture.text ? capture.text : undefined;
}
/** Only call with server-owned canonical rows; generic writes strip their private revision. */
export function getPrivateTextInspectionTokens(
messages: readonly (PrivateTextMessage | null | undefined)[],
): ReadonlySet<string> {
const tokens = new Set<string>();
// Mirror the existing provider work and maximum transformed-text ceilings.
if (messages.length > 4096) {
return tokens;
}
for (const message of messages) {
if (message?.isCreatedByUser !== true || typeof message.text !== 'string') {
continue;
}
if (message.text.length > 524288) {
return new Set();
}
if ((message.privateTextTokens?.length ?? 0) > 4096) {
return new Set();
}
for (const token of message.privateTextTokens ?? []) {
if (
/^\[(?:EMAIL|PHONE|NAME|CREDENTIAL|CUSTOM)_\d+_[a-f0-9]{32}\]$/.test(token) &&
message.text.includes(token)
) {
tokens.add(token);
if (tokens.size > 4096) {
return new Set();
}
}
}
for (const match of message.text.matchAll(
/\[(?:EMAIL|PHONE|NAME|CREDENTIAL|CUSTOM)_\d+_([a-f0-9]{32})\]/g,
)) {
if (match[1] === message.privacyRevision) {
tokens.add(match[0]);
if (tokens.size > 4096) {
return new Set();
}
}
}
}
return tokens;
}
/** The preliminary job record precedes the created event and may be read by Stop. */
export function stampPreliminaryPrivateTextMessage<T extends PrivateTextMessage>(
req: object | undefined,
message: T | null,
): (T & { privacyRevision?: string }) | null {
if (message == null) {
return null;
}
const capture = req == null ? undefined : captures.get(req);
if (capture != null && capture.text === message.text) {
return { ...message, privacyRevision: capture.revision };
}
return message;
}
/** Encrypts against final server-resolved message identity, then commits both views in one write. */
export async function savePrivateTextMessage(
save: MessageMethods['saveMessage'],
req: object | undefined,
...args: Parameters<MessageMethods['saveMessage']>
): ReturnType<MessageMethods['saveMessage']> {
const [ctx, message, metadata] = args;
const capture = req == null ? undefined : captures.get(req);
if (capture == null || message.isCreatedByUser !== true) {
return save(...args);
}
if (capture.admissionState() === false || message.text !== capture.text) {
throw unavailable();
}
if (
ctx.userId !== capture.userId ||
!message.messageId ||
!message.conversationId ||
message.newMessageId
) {
throw unavailable();
}
const revision = capture.revision;
const original = capture.cipher.open(capture.envelope, [
capture.userId,
capture.tenantId,
revision,
]);
const envelope = capture.cipher.seal(
original,
privateTextBinding(capture.userId, capture.tenantId, { ...message, privacyRevision: revision }),
);
const saved = await save(
ctx,
{ ...message, tenantId: capture.tenantId || undefined },
{
...metadata,
privateText: { envelope, revision },
},
);
if (
saved?.privacyRevision !== revision ||
saved.text !== capture.text ||
saved.messageId !== message.messageId ||
saved.conversationId !== message.conversationId
) {
throw unavailable();
}
return saved;
}
/** Must complete before sendCompletion. Existing cancellation/deletion still owns the run. */
export async function requirePrivateTextPersistence(
req: object | undefined,
start: () => Promise<{ message?: PrivateTextMessage | null } | undefined>,
onPersisted?: () => void,
): Promise<void> {
const capture = req == null ? undefined : captures.get(req);
if (capture == null) {
return;
}
try {
if (capture.admissionState() === false) {
throw unavailable();
}
const result = await start();
if (
capture.admissionState() === false ||
result?.message?.privacyRevision !== capture.revision ||
result.message.text !== capture.text
) {
throw unavailable();
}
capture.admit(true);
onPersisted?.();
} catch (error) {
capture.admit(false);
throw error;
}
}
/** Optional model side effects share the turn's admission decision, without starting its write. */
export async function requirePrivateTextAdmission(
req: object | undefined,
signal?: AbortSignal,
): Promise<void> {
const capture = req == null ? undefined : captures.get(req);
if (capture == null) {
return;
}
if (signal?.aborted) {
throw unavailable();
}
let abort!: () => void;
const cancelled = new Promise<boolean>((resolve) => {
abort = () => resolve(false);
signal?.addEventListener('abort', abort, { once: true });
});
try {
if (!(await Promise.race([capture.admission, cancelled])) || signal?.aborted) {
throw unavailable();
}
} finally {
signal?.removeEventListener('abort', abort);
}
}
export function rejectPrivateTextAdmission(req: object | undefined): void {
if (req != null) {
captures.get(req)?.admit(false);
}
}
/** Stop before protected admission owns no persisted turn. Ordinary Stop retains its writer. */
export function bindPrivateTextPersistenceAbort(
req: object | undefined,
signal: AbortSignal | undefined,
start: () => unknown,
cancel: () => unknown,
): () => void {
const abort = () => {
const capture = req == null ? undefined : captures.get(req);
if (capture != null && capture.admissionState() !== true) {
capture.admit(false);
cancel();
return;
}
start();
};
if (signal?.aborted) {
abort();
return () => {};
}
signal?.addEventListener('abort', abort, { once: true });
return () => signal?.removeEventListener('abort', abort);
}
/** Recovery may retain ordinary failures, but cannot revive an unadmitted protected turn. */
export async function savePrivateTextErrorTurn(
req: object | undefined,
error: unknown,
save: () => Promise<void>,
): Promise<void> {
const capture = req == null ? undefined : captures.get(req);
if (capture != null) {
if (capture.admissionState() !== true && isContentFilterError(error)) {
capture.admit(false);
}
if (capture.admissionState() === false) {
return;
}
}
await save();
}
/** Ordinary startup stays immediate; protected revisions are announced only after admission. */
export function deferPrivateTextStart(
req: object | undefined,
onStart: ((message: PrivateTextMessage, responseId: string, isNew: boolean) => void) | undefined,
message: PrivateTextMessage,
responseId: string,
isNew: boolean,
): (() => void) | undefined {
if (typeof onStart !== 'function') {
return;
}
if (req == null || !captures.has(req)) {
onStart(message, responseId, isNew);
return;
}
let announced = false;
return () => {
if (!announced) {
announced = true;
onStart(message, responseId, isNew);
}
};
}
/** Runs only after the exact native payload passes its policy callback. */
export function getPrivateTextAdmission(
req: object | undefined,
start: (() => Promise<{ message?: PrivateTextMessage | null } | undefined>) | undefined,
onPersisted?: () => void,
): (() => Promise<void>) | undefined {
if (req == null || !captures.has(req)) {
return;
}
if (start == null) {
throw unavailable();
}
return () => requirePrivateTextPersistence(req, start, onPersisted);
}
/**
* Stop has a different request and cannot retrieve the original plaintext. Verify
* protected rows instead of rewriting their canonical text. Older job records may
* omit the revision, so their prerequisite is an insert-only write.
*/
export async function saveAbortedUserMessage(
store: Pick<MessageMethods, 'saveMessage' | 'getPersistedPrivateTextId'>,
ctx: Parameters<MessageMethods['saveMessage']>[0],
message: Parameters<MessageMethods['saveMessage']>[1],
metadata: Parameters<MessageMethods['saveMessage']>[2],
tenantId?: string,
finalEvent?: { requestMessage?: { privacyRevision?: string } | null },
): Promise<{ _id?: unknown }> {
const revision = message.privacyRevision;
if (typeof revision !== 'string' || revision.length === 0) {
if (!message.messageId || !message.conversationId) {
throw unavailable();
}
const saved = await store.saveMessage(ctx, message, { ...metadata, insertOnly: true });
if (
saved == null ||
saved.messageId !== message.messageId ||
saved.conversationId !== message.conversationId ||
saved.text !== message.text
) {
throw unavailable();
}
if (typeof saved.privacyRevision === 'string' && saved.privacyRevision.length > 0) {
if (typeof saved.text !== 'string') {
throw unavailable();
}
const exists = await store.getPersistedPrivateTextId({
userId: ctx.userId,
tenantId,
conversationId: message.conversationId,
messageId: message.messageId,
text: saved.text,
privacyRevision: saved.privacyRevision,
});
if (!exists) {
throw unavailable();
}
if (finalEvent?.requestMessage != null) {
finalEvent.requestMessage.privacyRevision = saved.privacyRevision;
}
}
return { _id: saved._id };
}
if (!message.messageId || !message.conversationId || typeof message.text !== 'string') {
throw unavailable();
}
const persisted = await store.getPersistedPrivateTextId({
userId: ctx.userId,
tenantId,
conversationId: message.conversationId,
messageId: message.messageId,
text: message.text,
privacyRevision: revision,
});
if (!persisted) {
throw unavailable();
}
return { _id: persisted };
}