Skip to content

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

📔 feat: Preserve Owner Text During PII Redaction (#16311)

lia-by-librechat[bot]73d704656e39
diff --git a/api/app/clients/BaseClient.js b/api/app/clients/BaseClient.js
index dc37997ffe..f02af652d4 100644
--- a/api/app/clients/BaseClient.js
+++ b/api/app/clients/BaseClient.js
@@ -32,6 +32,12 @@ const {
announceReply,
needsRetentionConversation,
getConversationWriteContext,
+ savePrivateTextMessage,
+ stampPrivateTextMessage,
+ deferPrivateTextStart,
+ requirePrivateTextPersistence,
+ rejectPrivateTextAdmission,
+ bindPrivateTextPersistenceAbort,
persistedReasoningOverrideFields,
} = require('@librechat/api');
const {
@@ -589,13 +595,16 @@ class BaseClient {
} = await this.setMessageOptions(opts);
this.options.startupTelemetry?.mark('history_loaded');
- const userMessage = this.resolveStartUserMessage({
- opts,
- message,
- userMessageId,
- parentMessageId,
- conversationId,
- });
+ const userMessage = stampPrivateTextMessage(
+ this.options.req,
+ this.resolveStartUserMessage({
+ opts,
+ message,
+ userMessageId,
+ parentMessageId,
+ conversationId,
+ }),
+ );
/**
* Attach quoted excerpts (the "Add to chat" selections from `req.body.quotes`)
@@ -630,10 +639,13 @@ class BaseClient {
});
}
- if (typeof opts?.onStart === 'function') {
- const isNewConvo = !requestConvoId && parentMessageId === Constants.NO_PARENT;
- opts.onStart(userMessage, responseMessageId, isNewConvo);
- }
+ this.privateTextStart = deferPrivateTextStart(
+ this.options.req,
+ opts?.onStart,
+ userMessage,
+ responseMessageId,
+ !requestConvoId && parentMessageId === Constants.NO_PARENT,
+ );
return {
...opts,
@@ -985,17 +997,12 @@ class BaseClient {
start,
cancel,
});
- const requestAbortSignal = this.abortController?.signal;
- if (requestAbortSignal?.aborted) {
- /** Preserve the historical durability contract for Stop: abort
- * persistence may publish the partial assistant response before the
- * provider unwinds, so its parent write must already be underway. */
- start();
- } else if (requestAbortSignal != null) {
- const startOnAbort = () => start();
- requestAbortSignal.addEventListener('abort', startOnAbort, { once: true });
- removeAbortListener = () => requestAbortSignal.removeEventListener('abort', startOnAbort);
- }
+ removeAbortListener = bindPrivateTextPersistenceAbort(
+ this.options.req,
+ this.abortController?.signal,
+ start,
+ cancel,
+ );
this.modelBoundUserMessagePersistence = userMessagePersistence;
userMessagePromise = persistencePromise;
} else {
@@ -1043,6 +1050,7 @@ class BaseClient {
completionResult = await this.sendCompletion(payload, opts);
} catch (error) {
+ rejectPrivateTextAdmission(this.options.req);
if (userMessagePersistence?.isPending()) {
if (isContentFilterError(error)) {
userMessagePersistence.cancel();
@@ -1054,6 +1062,11 @@ class BaseClient {
}
/** A safe no-model completion (or a runtime that cannot expose the
* admission callback) must not leave the parent-write gate pending. */
+ await requirePrivateTextPersistence(
+ this.options.req,
+ () => (userMessagePersistence != null ? userMessagePersistence.start() : userMessagePromise),
+ this.privateTextStart,
+ );
userMessagePersistence?.start();
const { completion, metadata } = completionResult;
if (this.abortController) {
@@ -1272,7 +1285,8 @@ class BaseClient {
return [];
}
- const messages = (await db.getMessages({ conversationId, user: this.user })) ?? [];
+ const messages =
+ (await db.getMessages({ conversationId, user: this.user }, '+privateTextTokens')) ?? [];
/** A client that reads beyond the walk below (which stops at a checkpoint
* summary) receives every row here; the rest keep nothing. */
this.onHistoryLoaded?.(messages);
@@ -1361,7 +1375,9 @@ class BaseClient {
req.resolvedConversation = await db.getConvo(req.user.id, message.conversationId);
}
const reqCtx = getConversationWriteContext(req);
- const savedMessage = await db.saveMessage(
+ const savedMessage = await savePrivateTextMessage(
+ db.saveMessage,
+ req,
reqCtx,
{
...message,
diff --git a/api/app/clients/specs/BaseClient.test.js b/api/app/clients/specs/BaseClient.test.js
index d6e1549ade..e6578ed3af 100644
--- a/api/app/clients/specs/BaseClient.test.js
+++ b/api/app/clients/specs/BaseClient.test.js
@@ -2,6 +2,11 @@ const { Constants, ContentTypes, EModelEndpoint } = require('librechat-data-prov
const BaseClientClass = require('../BaseClient');
const {
ContentFilterError,
+ createPrivateTextIngress,
+ createModelBoundChatModelCallback,
+ getPrivateTextAdmission,
+ getPrivateTextInspectionTokens,
+ assertModelBoundContent,
resolveTurnDeliveryRouting,
buildSteerMedia,
Tokenizer,
@@ -1597,7 +1602,7 @@ describe('BaseClient', () => {
const chatMessages = await TestClient.loadHistory(conversationId, '1');
- expect(getMessages).toHaveBeenCalledWith({ conversationId, user });
+ expect(getMessages).toHaveBeenCalledWith({ conversationId, user }, '+privateTextTokens');
expect(chatMessages).toHaveLength(1);
expect(chatMessages[0].text).toBe('Hello');
});
@@ -1734,6 +1739,195 @@ describe('BaseClient', () => {
);
});
+ function protectedClient(history = [], legacyPii) {
+ const filters = {
+ messages: {
+ pii: {
+ action: 'redact',
+ fields: ['text'],
+ starterPatterns: [],
+ customPatterns: [
+ { id: 'email', label: 'Email', regex: 'alice@example\\.com', category: 'email' },
+ ],
+ },
+ },
+ };
+ const req = {
+ user: { id: 'owner' },
+ path: '/',
+ body: { text: '[email protected]', clientRequestId: 'created-privacy' },
+ config: { filters, messageFilter: { pii: legacyPii } },
+ };
+ const next = jest.fn();
+ createPrivateTextIngress({
+ getFilters: () => filters,
+ getLegacyPii: () => legacyPii,
+ getKey: () => 'ab'.repeat(32),
+ })(req, { status: jest.fn().mockReturnThis(), json: jest.fn() }, next);
+ expect(next).toHaveBeenCalledTimes(1);
+ const client = initializeFakeClient(apiKey, { ...options, req }, history);
+ client.shouldDeferUserMessagePersistence = () => true;
+ client.assertStoredModelBoundContent = () =>
+ assertModelBoundContent({
+ legacyPii,
+ storedMessages: client.modelBoundStoredMessages,
+ });
+ client.assertBuiltModelBoundContent = () => {};
+ client.saveMessageToDatabase = jest.fn(async (message) => ({ message }));
+ const provider = jest.fn();
+ client.sendCompletion = jest.fn(async (payload) => {
+ const callback = createModelBoundChatModelCallback(
+ {
+ filters,
+ legacyPii,
+ storedMessages: client.modelBoundStoredMessages,
+ privateTextTokens: getPrivateTextInspectionTokens(client.modelBoundStoredMessages),
+ },
+ {
+ onContentRejected: client.modelBoundUserMessagePersistence?.cancel,
+ onContentAllowed: getPrivateTextAdmission(
+ req,
+ client.modelBoundUserMessagePersistence?.start,
+ client.privateTextStart,
+ ),
+ },
+ );
+ await callback.handleChatModelStart(undefined, [payload]);
+ provider();
+ return { completion: 'Safe reply' };
+ });
+ return { client, req, provider };
+ }
+
+ test('protected startup remains deferred until exact admission and the atomic write finishes', async () => {
+ const { client, req, provider } = protectedClient();
+ const committed = deferred();
+ let written;
+ client.saveMessageToDatabase.mockImplementationOnce((message) => {
+ written = message;
+ return committed.promise;
+ });
+ const onStart = jest.fn();
+ const sent = client.sendMessage(req.body.text, { onStart });
+ // Wait for the admission callback to begin the real deferred write.
+ for (let i = 0; i < 30 && !written; i++) {
+ await Promise.resolve();
+ }
+ expect(written).toBeDefined();
+ expect(onStart).not.toHaveBeenCalled();
+ expect(provider).not.toHaveBeenCalled();
+ committed.resolve({ message: written });
+ await sent;
+ expect(onStart).toHaveBeenCalledTimes(1);
+ expect(provider).toHaveBeenCalledTimes(1);
+ expect(onStart.mock.invocationCallOrder[0]).toBeLessThan(
+ provider.mock.invocationCallOrder[0],
+ );
+ });
+
+ test('protected write failure prevents created and the provider call', async () => {
+ const { client, req, provider } = protectedClient();
+ client.saveMessageToDatabase.mockResolvedValueOnce({});
+ const onStart = jest.fn();
+ await expect(client.sendMessage(req.body.text, { onStart })).rejects.toThrow();
+ expect(onStart).not.toHaveBeenCalled();
+ expect(provider).not.toHaveBeenCalled();
+ });
+
+ test.each([false, true])(
+ 'cancels protected Stop before native admission, pre-aborted: %s',
+ async (preAborted) => {
+ const { client, req, provider } = protectedClient();
+ const controller = new AbortController();
+ if (preAborted) {
+ controller.abort();
+ }
+ const ready = deferred();
+ const completion = deferred();
+ const onStart = jest.fn();
+ client.sendCompletion = jest.fn(async () => {
+ ready.resolve();
+ return completion.promise;
+ });
+ const sent = client.sendMessage(req.body.text, { abortController: controller, onStart });
+ const observed = sent.catch((error) => error);
+ await ready.promise;
+ if (!preAborted) {
+ controller.abort();
+ }
+ completion.resolve({ completion: 'Stopped before model' });
+ expect(await observed).toEqual(expect.objectContaining({ code: 'content_filter_block' }));
+ expect(client.saveMessageToDatabase).not.toHaveBeenCalled();
+ expect(onStart).not.toHaveBeenCalled();
+ expect(provider).not.toHaveBeenCalled();
+ },
+ );
+
+ test.each(['user-id', 'user-id__1', 'user-id__invalid'])(
+ 'rejects a protected persistence-skipping override %s before model invocation',
+ async (overrideUserMessageId) => {
+ const { client, req, provider } = protectedClient();
+ req.body.overrideUserMessageId = overrideUserMessageId;
+ const onStart = jest.fn();
+ await expect(client.sendMessage(req.body.text, { onStart })).rejects.toMatchObject({
+ code: 'content_filter_block',
+ });
+ expect(client.skipSaveUserMessage).toBe(true);
+ expect(client.saveMessageToDatabase).not.toHaveBeenCalled();
+ expect(onStart).not.toHaveBeenCalled();
+ expect(provider).not.toHaveBeenCalled();
+ },
+ );
+
+ test('retains protected admission for the normal browser override with writer index zero', async () => {
+ const { client, req, provider } = protectedClient();
+ req.body.overrideUserMessageId = 'normal-user-id__0';
+ const onStart = jest.fn();
+ await expect(client.sendMessage(req.body.text, { onStart })).resolves.toBeDefined();
+ expect(client.skipSaveUserMessage).toBe(false);
+ expect(onStart).toHaveBeenCalledWith(
+ expect.objectContaining({
+ messageId: 'normal-user-id',
+ privacyRevision: expect.any(String),
+ }),
+ expect.any(String),
+ true,
+ );
+ expect(provider).toHaveBeenCalledTimes(1);
+ });
+
+ test('a legacy history rejection leaves a transformed turn and conversation unsaved', async () => {
+ const history = [{ messageId: 'prior', text: 'LEGACY-SECRET', isCreatedByUser: true }];
+ const { client, req, provider } = protectedClient(history, {
+ starterPatterns: [],
+ customPatterns: [{ id: 'legacy', label: 'Legacy', regex: 'LEGACY-SECRET' }],
+ });
+ const onStart = jest.fn();
+ await expect(
+ client.sendMessage(req.body.text, {
+ conversationId: 'conversation',
+ parentMessageId: 'prior',
+ onStart,
+ }),
+ ).rejects.toThrow();
+ expect(client.saveMessageToDatabase).not.toHaveBeenCalled();
+ expect(onStart).not.toHaveBeenCalled();
+ expect(provider).not.toHaveBeenCalled();
+ });
+
+ test('an exact model-input rejection cancels the protected deferred write before created', async () => {
+ const { client, req, provider } = protectedClient();
+ const onStart = jest.fn();
+ client.buildMessages.mockResolvedValueOnce({
+ prompt: [{ role: 'user', content: '[email protected]' }],
+ });
+ await expect(client.sendMessage(req.body.text, { onStart })).rejects.toThrow();
+ expect(client.saveMessageToDatabase).not.toHaveBeenCalled();
+ expect(onStart).not.toHaveBeenCalled();
+ expect(provider).not.toHaveBeenCalled();
+ expect(client.modelBoundUserMessagePersistence.isPending()).toBe(false);
+ });
+
test('onStart is called with the correct arguments', async () => {
const onStart = jest.fn();
const opts = { onStart };
diff --git a/api/server/controllers/agents/__tests__/request.partialDisconnect.spec.js b/api/server/controllers/agents/__tests__/request.partialDisconnect.spec.js
index 05f4e55b7d..18a8828497 100644
--- a/api/server/controllers/agents/__tests__/request.partialDisconnect.spec.js
+++ b/api/server/controllers/agents/__tests__/request.partialDisconnect.spec.js
@@ -47,6 +47,10 @@ jest.mock('@librechat/data-schemas', () => ({
}));
jest.mock('@librechat/api', () => ({
+ savePrivateTextMessage: (save, _req, ...args) => save(...args),
+ savePrivateTextErrorTurn: (...args) =>
+ jest.requireActual('@librechat/api').savePrivateTextErrorTurn(...args),
+ stampPreliminaryPrivateTextMessage: (_req, message) => message,
getAgentErrorMetadata: (...args) =>
jest.requireActual('@librechat/api').getAgentErrorMetadata(...args),
applyForcedTemporaryRequest: jest.fn(),
diff --git a/api/server/controllers/agents/__tests__/request.resumeMetadata.spec.js b/api/server/controllers/agents/__tests__/request.resumeMetadata.spec.js
index f4090c6766..c8dcd02f81 100644
--- a/api/server/controllers/agents/__tests__/request.resumeMetadata.spec.js
+++ b/api/server/controllers/agents/__tests__/request.resumeMetadata.spec.js
@@ -256,6 +256,10 @@ jest.mock('@librechat/data-schemas', () => ({
}));
jest.mock('@librechat/api', () => ({
+ savePrivateTextMessage: (save, _req, ...args) => save(...args),
+ savePrivateTextErrorTurn: (...args) =>
+ jest.requireActual('@librechat/api').savePrivateTextErrorTurn(...args),
+ stampPreliminaryPrivateTextMessage: (_req, message) => message,
getSteerRecoveryFailure: jest.requireActual(
'../../../../../packages/api/src/stream/SteerRecovery',
).getSteerRecoveryFailure,
@@ -3685,6 +3689,71 @@ describe('ResumableAgentController resume metadata', () => {
}
}
+ it.each(['history', 'exact-model'])(
+ 'does not persist a protected turn rejected by %s policy during terminal recovery',
+ async (boundary) => {
+ const api = jest.requireActual('@librechat/api');
+ const req = createFailedRequest({
+ clientRequestId: `private-error-${boundary}`,
+ });
+ req.path = '/';
+ const filters = {
+ messages: {
+ pii: {
+ action: 'redact',
+ fields: ['text'],
+ starterPatterns: [],
+ customPatterns: [
+ { id: 'email', label: 'Email', regex: 'alice@example\\.com', category: 'email' },
+ ],
+ },
+ },
+ };
+ const next = jest.fn();
+ api.createPrivateTextIngress({
+ getFilters: () => filters,
+ getLegacyPii: () => undefined,
+ getKey: () => 'ab'.repeat(32),
+ })(req, { status: jest.fn().mockReturnThis(), json: jest.fn() }, next);
+ expect(next).toHaveBeenCalledTimes(1);
+ const rejection = new api.ContentFilterError({
+ detectorId: 'pii-pattern',
+ ruleId: 'secret',
+ label: 'secret',
+ source: 'message',
+ field: 'text',
+ provenance: 'user',
+ fragmentId: boundary,
+ fragmentPath: '/text',
+ });
+ const client = {
+ options: {},
+ sendMessage: jest.fn(async () => {
+ throw rejection;
+ }),
+ };
+ await AgentController(
+ req,
+ createResumableResponse(),
+ jest.fn(),
+ jest.fn().mockResolvedValue({ client }),
+ null,
+ );
+ await flushBackgroundGeneration();
+ expect(client.sendMessage).toHaveBeenCalledTimes(1);
+ expect(mockGenerationJobManager.completeJob).toHaveBeenCalledWith(
+ conversationId,
+ rejection.message,
+ 1000,
+ expect.objectContaining({ beforeErrorPublication: expect.any(Function) }),
+ );
+ expect(mockSaveMessage).not.toHaveBeenCalled();
+ expect(mockSaveConvo).not.toHaveBeenCalled();
+ expect(mockStampConvoLastResponse).not.toHaveBeenCalled();
+ },
+ );
+
it('persists an initialization failure before terminal error publication', async () => {
const events = [];
mockSaveConvo.mockImplementation(async () => {
diff --git a/api/server/controllers/agents/client.js b/api/server/controllers/agents/client.js
index 960e7269ab..6b8818d593 100644
--- a/api/server/controllers/agents/client.js
+++ b/api/server/controllers/agents/client.js
@@ -158,6 +158,12 @@ const {
reportLocatorTraversalFailure,
filterFilesByEndpointRuntimeConfig,
createModelBoundChatModelCallback: createModelBoundContentCallback,
+ getPrivateTextInspectionTokens,
+ getPrivateTextModelHooks,
+ createPrivateTextInitialAdmissionCallback,
+ withPrivateTextAdmissionConfig,
+ requirePrivateTextAdmission,
+ rejectPrivateTextAdmission,
createInitialModelBoundAdmissionCallback,
hasModelBoundContentProtection,
assertResumeRuntimeContentAllowed,
@@ -2012,6 +2018,7 @@ class AgentClient extends BaseClient {
onTraversalFailure: reportLocatorTraversalFailure,
legacyPii,
storedMessages: this.modelBoundStoredMessages,
+ privateTextTokens: getPrivateTextInspectionTokens(this.modelBoundStoredMessages ?? []),
});
}
@@ -2021,7 +2028,7 @@ class AgentClient extends BaseClient {
* at every chat-model call instead. */
assertBuiltModelBoundContent() {}
- createModelBoundChatModelCallback() {
+ createModelBoundChatModelCallback(initialAdmission) {
const fileProjection = BaseClient.prototype.getModelBoundFileProjection.call(this);
const persistence = BaseClient.prototype.getModelBoundUserMessagePersistence.call(this);
return createModelBoundContentCallback(
@@ -2030,18 +2037,33 @@ class AgentClient extends BaseClient {
filters: this.options.req?.config?.filters,
legacyPii: this.options.req?.config?.messageFilter?.pii,
storedMessages: this.modelBoundStoredMessages,
+ privateTextTokens: getPrivateTextInspectionTokens(this.modelBoundStoredMessages ?? []),
fileIdsBySourceMessageId: fileProjection.fileIdsBySourceMessageId,
resolvedFiles: fileProjection.resolvedFiles,
sourceFileProjectionOverflowed: fileProjection.overflowed,
},
- {
- onContentRejected: persistence?.cancel,
- },
+ getPrivateTextModelHooks(
+ this.options.req,
+ initialAdmission,
+ persistence?.start,
+ persistence?.cancel,
+ this.privateTextStart,
+ ),
);
}
createInitialModelBoundAdmissionCallback(startingAgentIds) {
const persistence = BaseClient.prototype.getModelBoundUserMessagePersistence.call(this);
+ const protectedAdmission = createPrivateTextInitialAdmissionCallback(this.options.req, {
+ agentIds: startingAgentIds,
+ start: persistence?.start,
+ cancel: persistence?.cancel,
+ onPersisted: this.privateTextStart,
+ signal: this.abortController?.signal,
+ });
+ if (protectedAdmission != null) {
+ return protectedAdmission;
+ }
if (persistence == null || !persistence.isPending() || startingAgentIds.length === 0) {
return undefined;
}
@@ -2747,6 +2769,7 @@ class AgentClient extends BaseClient {
filters: this.options.req.config?.filters,
legacyPii: this.options.req.config?.messageFilter?.pii,
submittedMessages: [{ role: 'user', content: latestFormatted.content }],
+ privateTextTokens: getPrivateTextInspectionTokens([latestOrdered]),
});
/** Google rejects an unusable video with a generic `INVALID_ARGUMENT` that names no cause,
* so `#sendCompletion` can only attribute one by knowing this turn carried a video. */
@@ -3495,6 +3518,7 @@ class AgentClient extends BaseClient {
*/
async runMemory(messages) {
try {
+ await requirePrivateTextAdmission(this.options.req, this.abortController?.signal);
if (this.processMemory == null) {
return;
}
@@ -3566,7 +3590,12 @@ class AgentClient extends BaseClient {
});
}
const bufferMessage = new HumanMessage(limitedMemoryInput);
- return await this.processMemory([bufferMessage], filteredMessages);
+ return await this.processMemory(
+ [bufferMessage],
+ filteredMessages,
+ getPrivateTextInspectionTokens(this.modelBoundStoredMessages ?? []),
+ this.abortController?.signal,
+ );
} catch (error) {
logger.error('Memory Agent failed to process memory', getSafeErrorMetadata(error));
}
@@ -4808,16 +4837,16 @@ class AgentClient extends BaseClient {
if (this.agentConfigs && this.agentConfigs.size > 0) {
agents.push(...this.agentConfigs.values());
}
- const modelBoundCallback =
- AgentClient.prototype.createModelBoundChatModelCallback.call(this);
const initialModelBoundAdmission =
AgentClient.prototype.createInitialModelBoundAdmissionCallback.call(
this,
AgentClient.getStartingAgentIds(agents),
);
- if (initialModelBoundAdmission != null) {
- config.callbacks = [initialModelBoundAdmission];
- }
+ const modelBoundCallback = AgentClient.prototype.createModelBoundChatModelCallback.call(
+ this,
+ initialModelBoundAdmission,
+ );
+ config = withPrivateTextAdmissionConfig(config, initialModelBoundAdmission);
// TODO: needs to be added as part of AgentContext initialization
// const noSystemModelRegex = [/\b(o1-preview|o1-mini|amazon\.titan-text)\b/gi];
@@ -5200,6 +5229,7 @@ class AgentClient extends BaseClient {
});
}
} finally {
+ rejectPrivateTextAdmission(this.options.req);
/** An aborted/erroring run can still have completed compaction before
* the failure; retain that model-visible state for actor reconciliation. */
await this.options.runFiles?.close();
@@ -6123,6 +6153,7 @@ class AgentClient extends BaseClient {
});
try {
+ await requirePrivateTextAdmission(req, abortController.signal);
const titleResult = await this.run.generateTitle({
provider,
clientOptions,
diff --git a/api/server/controllers/agents/client.test.js b/api/server/controllers/agents/client.test.js
index a6a3991c42..7a62a1c31b 100644
--- a/api/server/controllers/agents/client.test.js
+++ b/api/server/controllers/agents/client.test.js
@@ -3956,6 +3956,65 @@ describe('AgentClient - titleConvo', () => {
expect(mockRun.generateTitle).toHaveBeenCalled();
});
+ it.each(['success', 'write-failure', 'policy-rejection', 'abort'])(
+ 'waits for protected persistence before an immediate title model call: %s',
+ async (outcome) => {
+ const api = jest.requireActual('@librechat/api');
+ const filters = {
+ messages: {
+ pii: {
+ action: 'redact',
+ fields: ['text'],
+ starterPatterns: [],
+ customPatterns: [
+ { id: 'email', label: 'Email', regex: 'alice@example\\.com', category: 'email' },
+ ],
+ },
+ },
+ };
+ mockReq.path = '/';
+ mockReq.body.text = '[email protected]';
+ mockReq.body.clientRequestId = 'protected-title';
+ const next = jest.fn();
+ api.createPrivateTextIngress({
+ getFilters: () => filters,
+ getLegacyPii: () => undefined,
+ getKey: () => 'ab'.repeat(32),
+ })(mockReq, { status: jest.fn().mockReturnThis(), json: jest.fn() }, next);
+ expect(next).toHaveBeenCalledTimes(1);
+ const message = api.stampPrivateTextMessage(mockReq, {
+ messageId: 'title-user',
+ conversationId: 'title-conversation',
+ text: mockReq.body.text,
+ isCreatedByUser: true,
+ });
+ const abortController = new AbortController();
+ const title = client.titleConvo({ text: message.text, abortController, immediate: true });
+ await new Promise((resolve) => setImmediate(resolve));
+ expect(mockRun.generateTitle).not.toHaveBeenCalled();
+ expect(client.recordCollectedUsage).not.toHaveBeenCalled();
+ if (outcome === 'abort') {
+ abortController.abort();
+ } else if (outcome === 'policy-rejection') {
+ api.rejectPrivateTextAdmission(mockReq);
+ } else if (outcome === 'write-failure') {
+ await expect(
+ api.requirePrivateTextPersistence(mockReq, async () => ({})),
+ ).rejects.toThrow();
+ } else {
+ const write = deferred();
+ const admission = api.requirePrivateTextPersistence(mockReq, () => write.promise);
+ await Promise.resolve();
+ expect(mockRun.generateTitle).not.toHaveBeenCalled();
+ write.resolve({ message });
+ await admission;
+ }
+ await title;
+ expect(mockRun.generateTitle).toHaveBeenCalledTimes(outcome === 'success' ? 1 : 0);
+ expect(client.recordCollectedUsage).toHaveBeenCalledTimes(outcome === 'success' ? 1 : 0);
+ },
+ );
+
it('passes empty contentParts in immediate mode (title from the user input only)', async () => {
client.contentParts = [{ type: 'text', text: 'Streaming response so far' }];
const abortController = new AbortController();
@@ -7335,6 +7394,47 @@ describe('AgentClient - titleConvo', () => {
require('~/models').getUserMemories.mockReset().mockResolvedValue([]);
});
+ it.each([Providers.GOOGLE, Providers.VERTEXAI])(
+ 'allows protected text through the late %s urlContext preflight without exempting raw content',
+ async (provider) => {
+ const filters = {
+ messages: {
+ pii: {
+ action: 'redact',
+ fields: ['text', 'content_part'],
+ starterPatterns: [],
+ customPatterns: [
+ { id: 'email', label: 'Email', regex: 'alice@example\\.com', category: 'email' },
+ { id: 'hex', label: 'Credential', regex: '[a-f0-9]{32}', category: 'credential' },
+ ],
+ },
+ },
+ };
+ const { client, invokeModel } = createClient({ provider, filters });
+ const req = client.options.req;
+ req.body.text = 'Email [email protected]';
+ req.body.clientRequestId = 'google-private-text';
+ require('@librechat/api').createPrivateTextIngress({
+ getFilters: () => filters,
+ getLegacyPii: () => undefined,
+ getKey: () => 'ab'.repeat(32),
+ })(req, { status: jest.fn().mockReturnThis(), json: jest.fn() }, jest.fn());
+ client.skipSaveUserMessage = false;
+ client.saveMessageToDatabase.mockImplementation(async (message) => ({
+ message: { ...message },
+ }));
+ await expect(
+ client.sendMessage(req.body.text, {
+ conversationId: 'protected-google',
+ parentMessageId: Constants.NO_PARENT,
+ user: 'user-123',
+ }),
+ ).resolves.toBeDefined();
+ expect(invokeModel).toHaveBeenCalledTimes(1);
+ expect(req.body.text).not.toContain('[email protected]');
+ },
+ );
+
it.each([Providers.GOOGLE, Providers.VERTEXAI])(
'blocks a late %s fileUri before model invocation under strict content policy',
async (provider) => {
@@ -7468,6 +7568,61 @@ describe('AgentClient - titleConvo', () => {
client.responseMessageId = 'response-123';
});
+ it.each(['failure', 'reject', 'abort', 'success'])(
+ 'gates automatic extraction on protected admission: %s',
+ async (outcome) => {
+ const { HumanMessage } = require('@librechat/agents/langchain/messages');
+ const api = require('@librechat/api');
+ const filters = {
+ messages: {
+ pii: {
+ action: 'redact',
+ fields: ['text'],
+ starterPatterns: [],
+ customPatterns: [
+ { id: 'email', label: 'Email', regex: 'alice@example\\.com', category: 'email' },
+ ],
+ },
+ },
+ };
+ mockReq.body = { text: 'Remember [email protected]', clientRequestId: 'memory-private' };
+ mockReq.path = '/';
+ api.createPrivateTextIngress({
+ getFilters: () => filters,
+ getLegacyPii: () => undefined,
+ getKey: () => 'ab'.repeat(32),
+ })(mockReq, { status: jest.fn().mockReturnThis(), json: jest.fn() }, jest.fn());
+ const message = api.stampPrivateTextMessage(mockReq, {
+ text: mockReq.body.text,
+ isCreatedByUser: true,
+ conversationId: 'conversation',
+ messageId: 'user-message',
+ });
+ client.setModelBoundStoredMessages([message]);
+ client.abortController = new AbortController();
+ const extraction = client.runMemory([new HumanMessage(message.text)]);
+ await Promise.resolve();
+ expect(mockProcessMemory).not.toHaveBeenCalled();
+ if (outcome === 'abort') {
+ client.abortController.abort();
+ } else if (outcome === 'reject') {
+ api.rejectPrivateTextAdmission(mockReq);
+ } else if (outcome === 'failure') {
+ await expect(api.getPrivateTextAdmission(mockReq, async () => ({}))()).rejects.toThrow();
+ } else {
+ await api.getPrivateTextAdmission(mockReq, async () => ({ message }))();
+ }
+ await extraction;
+ expect(mockProcessMemory).toHaveBeenCalledTimes(outcome === 'success' ? 1 : 0);
+ if (outcome === 'success') {
+ expect(mockProcessMemory.mock.calls[0][2]).toEqual(
+ api.getPrivateTextInspectionTokens([message]),
+ );
+ expect(mockProcessMemory.mock.calls[0][3]).toBe(client.abortController.signal);
+ }
+ },
+ );
+
it('should filter out image URLs from message content', async () => {
const { HumanMessage, AIMessage } = require('@librechat/agents/langchain/messages');
const messages = [
diff --git a/api/server/controllers/agents/request.js b/api/server/controllers/agents/request.js
index 04f1ec40a0..f378f1ad83 100644
--- a/api/server/controllers/agents/request.js
+++ b/api/server/controllers/agents/request.js
@@ -58,6 +58,9 @@ const {
resolvePersistableCodeEnvironmentDecision,
getFailedTurnTraceFields,
resolveFailedTurnContent,
+ savePrivateTextMessage,
+ savePrivateTextErrorTurn,
+ stampPreliminaryPrivateTextMessage,
announceReply,
announceErrorTurn,
} = require('@librechat/api');
@@ -487,7 +490,9 @@ async function saveErrorTurn(
const iconURL = getEndpointIconURL(req, endpointOption);
if (userMessage) {
- const savedUserMessage = await saveMessage(
+ const savedUserMessage = await savePrivateTextMessage(
+ saveMessage,
+ req,
reqCtx,
{
...userMessage,
@@ -1648,10 +1653,13 @@ const ResumableAgentController = async (req, res, next, initializeClient, addTit
const responseModel = getAgentResponseModel(req, endpointOption);
const preliminaryUserMessage = isCompaction
? projectCompactionAnchor({ messageId: parentMessageId, conversationId })
- : getPreliminaryUserMessage(
- { ...req.body, messageId: preallocatedUserMessageId },
- conversationId,
- req._agentEventTriggerProjection,
+ : stampPreliminaryPrivateTextMessage(
+ req,
+ getPreliminaryUserMessage(
+ { ...req.body, messageId: preallocatedUserMessageId },
+ conversationId,
+ req._agentEventTriggerProjection,
+ ),
);
const job = await GenerationJobManager.createJob(streamId, userId, conversationId, {
startupTelemetry,
@@ -2345,6 +2353,7 @@ const ResumableAgentController = async (req, res, next, initializeClient, addTit
conversationId: userMsg.conversationId,
text: userMsg.text,
quotes: userMsg.quotes,
+ privacyRevision: userMsg.privacyRevision,
reasoningOverride: userMsg.reasoningOverride,
// Persist the turn's uploaded files here (authoritative job metadata) so a
// HITL resume sources them from the job, not the user DB row — which the
@@ -2772,7 +2781,9 @@ const ResumableAgentController = async (req, res, next, initializeClient, addTit
convoSignal.observeMessageWrite(Promise.resolve(savedUserTurn));
} else {
// Custom clients used by integrations/tests may not inherit BaseClient.
- const savedUserMessage = await saveMessage(
+ const savedUserMessage = await savePrivateTextMessage(
+ saveMessage,
+ req,
{
userId,
isTemporary:
@@ -3026,9 +3037,15 @@ const ResumableAgentController = async (req, res, next, initializeClient, addTit
if (!userMessage) {
throw new Error('User message was unavailable before terminal persistence');
}
- const savedUserMessage = await saveMessage(reqCtx, userMessage, {
- context: 'api/server/controllers/agents/request.js - resumable user message',
- });
+ const savedUserMessage = await savePrivateTextMessage(
+ saveMessage,
+ req,
+ reqCtx,
+ userMessage,
+ {
+ context: 'api/server/controllers/agents/request.js - resumable user message',
+ },
+ );
if (!savedUserMessage) {
throw new Error('User message could not be persisted before terminal publication');
}
@@ -3353,17 +3370,19 @@ const ResumableAgentController = async (req, res, next, initializeClient, addTit
ownsScheduledFailure =
(await GenerationJobManager.completeJob(streamId, generationError, jobCreatedAt, {
beforeErrorPublication: () =>
- saveErrorTurn(req, {
- conversationId,
- endpointOption,
- isNewConvo,
- errorText: generationError,
- liveUserMessage: userMessage,
- liveResponseMessageId,
- runCreated: client?.run != null,
- sender: client?.sender,
- initialAgentId: verifiedInitialAgentId,
- }),
+ savePrivateTextErrorTurn(req, error, () =>
+ saveErrorTurn(req, {
+ conversationId,
+ endpointOption,
+ isNewConvo,
+ errorText: generationError,
+ liveUserMessage: userMessage,
+ liveResponseMessageId,
+ runCreated: client?.run != null,
+ sender: client?.sender,
+ initialAgentId: verifiedInitialAgentId,
+ }),
+ ),
})) === true;
/** A true completion means this owner won the terminal CAS and
* the beforeErrorPublication barrier above finished. Only that
@@ -3565,13 +3584,15 @@ const ResumableAgentController = async (req, res, next, initializeClient, addTit
const completionPromise = persistInitializationError
? GenerationJobManager.completeJob(streamId, initializationError, jobCreatedAt, {
beforeErrorPublication: () =>
- saveErrorTurn(req, {
- conversationId,
- endpointOption,
- isNewConvo,
- errorText: initializationError,
- initialAgentId: verifiedInitialAgentId,
- }),
+ savePrivateTextErrorTurn(req, error, () =>
+ saveErrorTurn(req, {
+ conversationId,
+ endpointOption,
+ isNewConvo,
+ errorText: initializationError,
+ initialAgentId: verifiedInitialAgentId,
+ }),
+ ),
})
: GenerationJobManager.completeJob(streamId, initializationError, jobCreatedAt);
initializationFinalized =
diff --git a/api/server/middleware/denyRequest.js b/api/server/middleware/denyRequest.js
index 521603a6d9..2d45372244 100644
--- a/api/server/middleware/denyRequest.js
+++ b/api/server/middleware/denyRequest.js
@@ -1,5 +1,10 @@
const crypto = require('crypto');
-const { sendEvent } = require('@librechat/api');
+const {
+ sendEvent,
+ rejectUnprotectedDeniedMessage,
+ stampPrivateTextMessage,
+ savePrivateTextMessage,
+} = require('@librechat/api');
const { getResponseSender, Constants } = require('librechat-data-provider');
const { sendError } = require('~/server/middleware/error');
const { saveMessage } = require('~/models');
@@ -21,6 +26,10 @@ const { saveMessage } = require('~/models');
* @throws {Error} Throws an error if there's an issue saving the message or sending the error.
*/
const denyRequest = async (req, res, errorMessage) => {
+ if (rejectUnprotectedDeniedMessage(req, res)) {
+ return;
+ }
+
let responseText = errorMessage;
if (typeof errorMessage === 'object') {
responseText = JSON.stringify(errorMessage);
@@ -28,21 +37,27 @@ const denyRequest = async (req, res, errorMessage) => {
const { messageId, conversationId: _convoId, parentMessageId, text } = req.body;
const conversationId = _convoId ?? crypto.randomUUID();
+ const shouldSaveMessage = Boolean(
+ _convoId && parentMessageId && parentMessageId !== Constants.NO_PARENT,
+ );
- const userMessage = {
- sender: 'User',
- messageId: messageId ?? crypto.randomUUID(),
- parentMessageId,
- conversationId,
- isCreatedByUser: true,
- text,
- };
- sendEvent(res, { message: userMessage, created: true });
-
- const shouldSaveMessage = _convoId && parentMessageId && parentMessageId !== Constants.NO_PARENT;
+ const userMessage = stampPrivateTextMessage(
+ req,
+ {
+ sender: 'User',
+ messageId: messageId ?? crypto.randomUUID(),
+ parentMessageId,
+ conversationId,
+ isCreatedByUser: true,
+ text,
+ },
+ shouldSaveMessage,
+ );
if (shouldSaveMessage) {
- await saveMessage(
+ await savePrivateTextMessage(
+ saveMessage,
+ req,
{
userId: req?.user?.id,
isTemporary: req?.resolvedConversation?.isTemporary ?? req?.body?.isTemporary,
@@ -54,6 +69,7 @@ const denyRequest = async (req, res, errorMessage) => {
);
}
+ sendEvent(res, { message: userMessage, created: true });
return await sendError(req, res, {
sender: getResponseSender(req.body),
messageId: crypto.randomUUID(),
diff --git a/api/server/middleware/denyRequest.privateText.spec.js b/api/server/middleware/denyRequest.privateText.spec.js
new file mode 100644
index 0000000000..41084da62a
--- /dev/null
+++ b/api/server/middleware/denyRequest.privateText.spec.js
@@ -0,0 +1,240 @@
+const { v4: uuidv4 } = require('uuid');
+const mockSaveMessage = jest.fn();
+const mockSendEvent = jest.fn();
+const mockSendError = jest.fn().mockResolvedValue(undefined);
+
+jest.mock('@librechat/api', () => ({
+ ...jest.requireActual('@librechat/api'),
+ sendEvent: (...args) => mockSendEvent(...args),
+}));
+jest.mock('~/models', () => ({
+ saveMessage: (...args) => mockSaveMessage(...args),
+}));
+jest.mock('~/server/middleware/error', () => ({
+ sendError: (...args) => mockSendError(...args),
+}));
+
+const { createPrivateTextIngress } = require('@librechat/api');
+const denyRequest = require('./denyRequest');
+const original = '[email protected]';
+
+beforeEach(() => {
+ jest.clearAllMocks();
+ mockSaveMessage.mockImplementation(async (_ctx, message, metadata) => ({
+ ...message,
+ ...(metadata?.privateText && { privacyRevision: metadata.privateText.revision }),
+ }));
+});
+
+it('encrypts denied PII for an existing conversation and sends only the filtered view', async () => {
+ const req = {
+ method: 'POST',
+ path: '/',
+ originalUrl: '/api/agents/chat',
+ config: {
+ filters: {
+ messages: {
+ pii: {
+ action: 'redact',
+ fields: ['text'],
+ starterPatterns: [],
+ customPatterns: [
+ { id: 'email', label: 'Email', regex: 'alice@example\\.com', category: 'email' },
+ ],
+ },
+ },
+ },
+ },
+ user: { id: 'owner', tenantId: 'tenant-a' },
+ body: {
+ text: `Email ${original}`,
+ messageId: uuidv4(),
+ conversationId: uuidv4(),
+ parentMessageId: uuidv4(),
+ clientRequestId: uuidv4(),
+ },
+ };
+ const res = {};
+ const next = jest.fn();
+ createPrivateTextIngress({
+ getFilters: () => req.config.filters,
+ getLegacyPii: () => undefined,
+ getKey: () => 'ab'.repeat(32),
+ })(req, res, next);
+ expect(next).toHaveBeenCalledTimes(1);
+ await denyRequest(req, res, { type: 'message_limit' });
+
+ expect(mockSendEvent).toHaveBeenCalledTimes(1);
+ const event = mockSendEvent.mock.calls[0][1];
+ const [ctx, saved, metadata] = mockSaveMessage.mock.calls[0];
+ expect(mockSaveMessage).toHaveBeenCalledTimes(1);
+ expect(mockSaveMessage.mock.invocationCallOrder[0]).toBeLessThan(
+ mockSendEvent.mock.invocationCallOrder[0],
+ );
+ expect(ctx.userId).toBe('owner');
+ expect(saved.text).toMatch(/^Email \[EMAIL_1_[a-f0-9]{32}\]$/);
+ expect(saved.privacyRevision).toBe(event.message.privacyRevision);
+ expect(metadata.privateText).toMatchObject({ revision: event.message.privacyRevision });
+ expect(metadata.privateText.envelope).toMatch(/^v1:/);
+ expect(event.message.text).toBe(saved.text);
+ expect(JSON.stringify({ event, ctx, saved, metadata })).not.toContain(original);
+ expect(mockSendError).toHaveBeenCalledWith(
+ req,
+ res,
+ expect.objectContaining({ shouldSaveMessage: true }),
+ );
+});
+
+it('does not advertise an original on a denied first turn that is never persisted', async () => {
+ const req = {
+ method: 'POST',
+ path: '/',
+ originalUrl: '/api/agents/chat',
+ config: {
+ filters: {
+ messages: {
+ pii: {
+ action: 'redact',
+ fields: ['text'],
+ starterPatterns: [],
+ customPatterns: [
+ { id: 'email', label: 'Email', regex: 'alice@example\\.com', category: 'email' },
+ ],
+ },
+ },
+ },
+ },
+ user: { id: 'owner', tenantId: 'tenant-a' },
+ body: { text: `Email ${original}`, clientRequestId: uuidv4() },
+ };
+ const res = { status: jest.fn().mockReturnThis(), json: jest.fn() };
+ const next = jest.fn();
+ createPrivateTextIngress({
+ getFilters: () => req.config.filters,
+ getLegacyPii: () => undefined,
+ getKey: () => 'ab'.repeat(32),
+ })(req, res, next);
+ expect(next).toHaveBeenCalledTimes(1);
+ await denyRequest(req, res, { type: 'ban' });
+
+ expect(mockSaveMessage).not.toHaveBeenCalled();
+ expect(mockSendEvent).toHaveBeenCalledTimes(1);
+ expect(mockSendEvent.mock.calls[0][1].message).toMatchObject({
+ text: expect.stringMatching(/^Email \[EMAIL_1_[a-f0-9]{32}\]$/),
+ isCreatedByUser: true,
+ });
+ expect(mockSendEvent.mock.calls[0][1].message).not.toHaveProperty('privacyRevision');
+ expect(JSON.stringify(mockSendEvent.mock.calls)).not.toContain(original);
+ expect(mockSendError).toHaveBeenCalledWith(
+ req,
+ res,
+ expect.objectContaining({ shouldSaveMessage: false }),
+ );
+});
+
+it('fails closed before event or storage when denial hits untransformed private text', async () => {
+ const req = {
+ path: '/',
+ user: { id: 'owner', tenantId: 'tenant-a' },
+ config: {
+ filters: {
+ messages: {
+ pii: {
+ action: 'redact',
+ fields: ['text'],
+ starterPatterns: [],
+ customPatterns: [
+ { id: 'email', label: 'Email', regex: 'alice@example\\.com', category: 'email' },
+ ],
+ },
+ },
+ },
+ },
+ body: {
+ text: `Email ${original}`,
+ files: [{}],
+ messageId: uuidv4(),
+ conversationId: uuidv4(),
+ parentMessageId: uuidv4(),
+ clientRequestId: uuidv4(),
+ },
+ };
+ const res = { status: jest.fn().mockReturnThis(), json: jest.fn() };
+ const next = jest.fn();
+ createPrivateTextIngress({
+ getFilters: () => req.config.filters,
+ getLegacyPii: () => undefined,
+ getKey: () => 'ab'.repeat(32),
+ })(req, res, next);
+ expect(next).toHaveBeenCalledTimes(1);
+ await denyRequest(req, res, { type: 'message_limit' });
+ expect(res.status).toHaveBeenCalledWith(400);
+ expect(JSON.stringify(res.json.mock.calls)).not.toContain(original);
+ expect(mockSendEvent).not.toHaveBeenCalled();
+ expect(mockSaveMessage).not.toHaveBeenCalled();
+ expect(mockSendError).not.toHaveBeenCalled();
+});
+
+it.each(['redact', 'block'])(
+ 'rejects a queued-turn denial before events or storage with %s policy',
+ async (action) => {
+ const req = {
+ method: 'POST',
+ originalUrl: '/api/agents/chat/queued-turns',
+ user: { id: 'owner', tenantId: 'tenant-a' },
+ config: {
+ filters: {
+ messages: {
+ pii: {
+ action,
+ fields: ['text'],
+ starterPatterns: [],
+ customPatterns: [
+ { id: 'email', label: 'Email', regex: 'alice@example\\.com', category: 'email' },
+ ],
+ },
+ },
+ },
+ },
+ body: { text: `Email ${original}`, conversationId: uuidv4(), parentMessageId: uuidv4() },
+ };
+ const res = { status: jest.fn().mockReturnThis(), json: jest.fn() };
+ await denyRequest(req, res, { type: 'ban' });
+ expect(res.status).toHaveBeenCalledWith(400);
+ expect(JSON.stringify(res.json.mock.calls)).not.toContain(original);
+ expect(mockSendEvent).not.toHaveBeenCalled();
+ expect(mockSaveMessage).not.toHaveBeenCalled();
+ },
+);
+
+it('fails closed on a denied Agent submission when its policy was not loaded', async () => {
+ const req = {
+ method: 'POST',
+ originalUrl: '/api/agents/chat/queued-turns',
+ user: { id: 'owner' },
+ body: { text: original, conversationId: uuidv4(), parentMessageId: uuidv4() },
+ };
+ const res = { status: jest.fn().mockReturnThis(), json: jest.fn() };
+ await denyRequest(req, res, { type: 'ban' });
+ expect(res.status).toHaveBeenCalledWith(400);
+ expect(mockSendEvent).not.toHaveBeenCalled();
+ expect(mockSaveMessage).not.toHaveBeenCalled();
+});
+
+it('retains the existing denial behavior when no PII transformer ran', async () => {
+ const req = {
+ user: { id: 'owner' },
+ body: {
+ text: 'ordinary message',
+ messageId: uuidv4(),
+ conversationId: uuidv4(),
+ parentMessageId: uuidv4(),
+ },
+ };
+ await denyRequest(req, {}, { type: 'message_limit' });
+ expect(mockSaveMessage).toHaveBeenCalledWith(
+ expect.objectContaining({ userId: 'owner' }),
+ expect.objectContaining({ text: 'ordinary message' }),
+ expect.not.objectContaining({ privateText: expect.anything() }),
+ );
+});
diff --git a/api/server/routes/__tests__/messages-content-edit.spec.js b/api/server/routes/__tests__/messages-content-edit.spec.js
index 29d98761aa..48e2320c1f 100644
--- a/api/server/routes/__tests__/messages-content-edit.spec.js
+++ b/api/server/routes/__tests__/messages-content-edit.spec.js
@@ -9,6 +9,7 @@ jest.mock('@librechat/agents', () => ({
jest.mock('@librechat/api', () => ({
unescapeLaTeX: jest.fn((value) => value),
countTokens: jest.fn().mockResolvedValue(2),
+ createPrivateTextView: jest.fn(() => (_req, _res, next) => next()),
createContentFilter: jest.fn(() => (_req, _res, next) => next()),
sendFeedbackScore: jest.fn().mockResolvedValue(undefined),
traceIdForMessage: jest.fn((messageId) => `trace-${messageId}`),
diff --git a/api/server/routes/__tests__/messages-delete.spec.js b/api/server/routes/__tests__/messages-delete.spec.js
index a0c27b62b9..c817425619 100644
--- a/api/server/routes/__tests__/messages-delete.spec.js
+++ b/api/server/routes/__tests__/messages-delete.spec.js
@@ -9,6 +9,7 @@ jest.mock('@librechat/agents', () => ({
}));
jest.mock('@librechat/api', () => ({
+ createPrivateTextView: jest.fn(() => (_req, _res, next) => next()),
createContentFilter: jest.fn(() => (req, res, next) => next()),
inspectContent: jest.fn(() => null),
extractFeedbackContent: jest.fn(() => []),
diff --git a/api/server/routes/__tests__/messages-feedback.spec.js b/api/server/routes/__tests__/messages-feedback.spec.js
index ca38a895ef..1174518fc5 100644
--- a/api/server/routes/__tests__/messages-feedback.spec.js
+++ b/api/server/routes/__tests__/messages-feedback.spec.js
@@ -8,6 +8,7 @@ jest.mock('@librechat/agents', () => ({
jest.mock('@librechat/api', () => ({
unescapeLaTeX: jest.fn((value) => value),
countTokens: jest.fn().mockResolvedValue(10),
+ createPrivateTextView: jest.fn(() => (_req, _res, next) => next()),
createContentFilter: jest.fn(() => (req, res, next) => next()),
sendFeedbackScore: jest.fn().mockResolvedValue(undefined),
traceIdForMessage: jest.fn((messageId) => `trace-${messageId}`),
diff --git a/api/server/routes/__tests__/messages-get-real-validation.spec.js b/api/server/routes/__tests__/messages-get-real-validation.spec.js
index 46daa50fc0..a7d7e4a4d9 100644
--- a/api/server/routes/__tests__/messages-get-real-validation.spec.js
+++ b/api/server/routes/__tests__/messages-get-real-validation.spec.js
@@ -21,6 +21,7 @@ jest.mock('@librechat/agents', () => ({
}));
jest.mock('@librechat/api', () => ({
+ createPrivateTextView: jest.fn(() => (_req, _res, next) => next()),
createContentFilter: jest.fn(() => (req, res, next) => next()),
inspectContent: jest.fn(() => null),
extractFeedbackContent: jest.fn(() => []),
diff --git a/api/server/routes/__tests__/messages-get.spec.js b/api/server/routes/__tests__/messages-get.spec.js
index 1062058232..de858ac410 100644
--- a/api/server/routes/__tests__/messages-get.spec.js
+++ b/api/server/routes/__tests__/messages-get.spec.js
@@ -54,6 +54,10 @@ jest.mock('@librechat/api', () => {
/** The real helper, without loading the rest of the package this suite mocks around. */
withoutTraceRefs: jest.requireActual('../../../../packages/api/src/langfuse/trace.ts')
.withoutTraceRefs,
+ createPrivateTextView: jest.fn(() => (_req, _res, next) => next()),
+ stripPrivateMessageFields: jest.requireActual(
+ '../../../../packages/api/src/protection/private/view',
+ ).stripPrivateMessageFields,
createContentFilter: jest.fn(() => (req, res, next) => next()),
inspectContent,
extractChatContent,
@@ -641,6 +645,8 @@ describe('message route conversation ownership filters', () => {
messageId: 'hit-1',
conversationId: 'convo-1',
text: 'needle in a haystack',
+ privateText: 'v1:encrypted-original',
+ privacyRevision: 'public-revision',
contextMeta: {
calibrationRatio: 1.2,
encoding: 'claude',
@@ -662,6 +668,8 @@ describe('message route conversation ownership filters', () => {
expect(response.body.messages).toHaveLength(1);
expect(response.body.messages[0]).toMatchObject({ messageId: 'hit-1', title: 'Found' });
expect(response.body.messages[0]).not.toHaveProperty('contextMeta');
+ expect(response.body.messages[0]).not.toHaveProperty('privateText');
+ expect(response.body.messages[0].privacyRevision).toBe('public-revision');
});
it('returns indistinguishable not-found responses for child and missing query reads', async () => {
diff --git a/api/server/routes/__tests__/messages-retention.spec.js b/api/server/routes/__tests__/messages-retention.spec.js
index fc79658054..9bbbc0ce9d 100644
--- a/api/server/routes/__tests__/messages-retention.spec.js
+++ b/api/server/routes/__tests__/messages-retention.spec.js
@@ -7,6 +7,10 @@ jest.mock('@librechat/agents', () => ({
}));
jest.mock('@librechat/api', () => ({
+ createPrivateTextView: jest.fn(() => (_req, _res, next) => next()),
+ stripPrivateMessageFields: jest.requireActual(
+ '../../../../packages/api/src/protection/private/view',
+ ).stripPrivateMessageFields,
unescapeLaTeX: jest.fn((value) => value),
countTokens: jest.fn().mockResolvedValue(10),
createContentFilter: jest.fn(() => (_req, _res, next) => next()),
diff --git a/api/server/routes/__tests__/messages-subagent-thread.spec.js b/api/server/routes/__tests__/messages-subagent-thread.spec.js
index 3c7ee69e75..574a1435e3 100644
--- a/api/server/routes/__tests__/messages-subagent-thread.spec.js
+++ b/api/server/routes/__tests__/messages-subagent-thread.spec.js
@@ -7,6 +7,7 @@ jest.mock('@librechat/agents', () => ({ sleep: jest.fn() }));
jest.mock('@librechat/api', () => ({
withoutTraceRefs: jest.fn((message) => message),
+ createPrivateTextView: jest.fn(() => (_req, _res, next) => next()),
createContentFilter: jest.fn(() => (_req, _res, next) => next()),
unescapeLaTeX: jest.fn((value) => value),
countTokens: jest.fn().mockResolvedValue(1),
diff --git a/api/server/routes/__tests__/messages-update.spec.js b/api/server/routes/__tests__/messages-update.spec.js
index a58e3cd475..5394b49cb4 100644
--- a/api/server/routes/__tests__/messages-update.spec.js
+++ b/api/server/routes/__tests__/messages-update.spec.js
@@ -7,6 +7,10 @@ jest.mock('@librechat/agents', () => ({
}));
jest.mock('@librechat/api', () => ({
+ createPrivateTextView: jest.fn(() => (_req, _res, next) => next()),
+ stripPrivateMessageFields: jest.requireActual(
+ '../../../../packages/api/src/protection/private/view',
+ ).stripPrivateMessageFields,
unescapeLaTeX: jest.fn((value) => value),
countTokens: jest.fn().mockResolvedValue(10),
createContentFilter: jest.fn(() => (_req, _res, next) => next()),
diff --git a/api/server/routes/agents/__tests__/abort.spec.js b/api/server/routes/agents/__tests__/abort.spec.js
index 2e210520df..93d3d4e04e 100644
--- a/api/server/routes/agents/__tests__/abort.spec.js
+++ b/api/server/routes/agents/__tests__/abort.spec.js
@@ -24,6 +24,8 @@ const mockGenerationJobManager = {
};
const mockSaveMessage = jest.fn();
+const mockHasPersistedPrivateText = jest.fn();
+const mockGetPrivateMessageTexts = jest.fn();
const mockSaveConvo = jest.fn();
const mockRecordScheduleOutcome = jest.fn();
@@ -49,6 +51,9 @@ jest.mock('@librechat/api', () => ({
jest.mock('~/models', () => ({
initializeMessageBudget: jest.fn(),
saveMessage: (...args) => mockSaveMessage(...args),
+ getPersistedPrivateTextId: async (...args) =>
+ (await mockHasPersistedPrivateText(...args)) ? 'protected-row-id' : null,
+ getPrivateMessageTexts: (...args) => mockGetPrivateMessageTexts(...args),
saveConvo: (...args) => mockSaveConvo(...args),
}));
@@ -102,6 +107,10 @@ describe('Agent Abort Endpoint', () => {
mockGenerationJobManager.getActiveJobIdsForUser.mockReset();
mockSaveMessage.mockReset();
mockSaveMessage.mockImplementation(async (_context, message) => message);
+ mockHasPersistedPrivateText.mockReset();
+ mockHasPersistedPrivateText.mockResolvedValue(true);
+ mockGetPrivateMessageTexts.mockReset();
+ mockGetPrivateMessageTexts.mockResolvedValue([]);
mockSaveConvo.mockReset();
mockSaveConvo.mockResolvedValue({});
mockRecordScheduleOutcome.mockReset();
@@ -374,6 +383,100 @@ describe('Agent Abort Endpoint', () => {
});
describe('Partial Response Saving', () => {
+ it('does not overwrite a persisted protected user sidecar while stopping a run', async () => {
+ const conversationId = 'test-stream-123';
+ const userMessageId = 'protected-user-msg';
+ const privacyRevision = 'protected-revision';
+ const text = 'Email [EMAIL_1_protected]';
+ const abortResult = {
+ success: true,
+ jobData: {
+ userMessage: { messageId: userMessageId, privacyRevision, text },
+ responseMessageId: 'protected-response',
+ conversationId,
+ endpoint: 'agents',
+ },
+ content: [{ type: 'text', text: 'Partial answer' }],
+ text: 'Partial answer',
+ };
+ mockGenerationJobManager.getJob.mockResolvedValue({
+ metadata: { userId: 'test-user-123' },
+ });
+ mockGenerationJobManager.abortJob.mockImplementation(async (_streamId, options) => {
+ await options.beforePublish(abortResult);
+ return abortResult;
+ });
+
+ const response = await request(app).post('/api/agents/chat/abort').send({ conversationId });
+
+ expect(response.status).toBe(200);
+ expect(mockHasPersistedPrivateText).toHaveBeenCalledWith(
+ expect.objectContaining({
+ userId: 'test-user-123',
+ messageId: userMessageId,
+ conversationId,
+ privacyRevision,
+ text,
+ }),
+ );
+ expect(mockSaveMessage).toHaveBeenCalledTimes(1);
+ expect(mockSaveMessage).toHaveBeenCalledWith(
+ expect.anything(),
+ expect.objectContaining({ messageId: 'protected-response', isCreatedByUser: false }),
+ expect.anything(),
+ );
+ });
+
+ it('recovers an older revisionless job from its exact protected row without unsetting it', async () => {
+ const conversationId = 'test-stream-revisionless';
+ const userMessageId = 'protected-user';
+ const text = `Email [EMAIL_1_${'a'.repeat(32)}]`;
+ const abortResult = {
+ success: true,
+ jobData: {
+ createdEventEmitted: true,
+ userMessage: { messageId: userMessageId, text },
+ responseMessageId: 'protected-response',
+ conversationId,
+ endpoint: 'agents',
+ },
+ finalEvent: { requestMessage: { messageId: userMessageId, text } },
+ content: [],
+ text: '',
+ };
+ mockGenerationJobManager.getJob.mockResolvedValue({
+ metadata: { userId: 'test-user-123' },
+ });
+ mockGenerationJobManager.abortJob.mockImplementation(async (_id, options) => {
+ await options.beforePublish(abortResult);
+ return abortResult;
+ });
+ mockSaveMessage.mockImplementationOnce(async (_ctx, message, metadata) => {
+ expect(metadata.insertOnly).toBe(true);
+ return { ...message, _id: 'protected-parent', privacyRevision: 'recovered-revision' };
+ });
+
+ const response = await request(app).post('/api/agents/chat/abort').send({ conversationId });
+ expect(response.status).toBe(200);
+ expect(mockGetPrivateMessageTexts).not.toHaveBeenCalled();
+ expect(mockHasPersistedPrivateText).toHaveBeenCalledWith(
+ expect.objectContaining({
+ userId: 'test-user-123',
+ conversationId,
+ messageId: userMessageId,
+ privacyRevision: 'recovered-revision',
+ text,
+ }),
+ );
+ expect(abortResult.finalEvent.requestMessage.privacyRevision).toBe('recovered-revision');
+ expect(mockSaveMessage).toHaveBeenCalledTimes(2);
+ expect(mockSaveMessage).toHaveBeenCalledWith(
+ expect.anything(),
+ expect.objectContaining({ messageId: 'protected-response' }),
+ expect.anything(),
+ );
+ });
+
it('should save partial response when both userMessage and responseMessageId exist', async () => {
const jobStreamId = 'test-stream-123';
const userMessageId = 'user-msg-123';
diff --git a/api/server/routes/agents/__tests__/idempotencyLimiter.spec.js b/api/server/routes/agents/__tests__/idempotencyLimiter.spec.js
index d911f4d0f2..62b1120837 100644
--- a/api/server/routes/agents/__tests__/idempotencyLimiter.spec.js
+++ b/api/server/routes/agents/__tests__/idempotencyLimiter.spec.js
@@ -8,6 +8,19 @@ const mockRetryLimiter = jest.fn((_req, _res, next) => next());
const mockRetryProbeLimiter = jest.fn((_req, _res, next) => next());
const mockExemptAgentTrigger = jest.fn(() => false);
const mockExemptSchedule = jest.fn(() => false);
+const mockIngress = jest.fn((req, _res, next) => {
+ if (req.config?.filters?.messages?.pii?.action === 'redact') {
+ req.body.text = '[EMAIL_1]';
+ }
+ next();
+});
+const mockCheckBan = jest.fn((_req, _res, next) => next());
+const mockConfigMiddleware = jest.fn((req, _res, next) => {
+ if (req.headers['x-test-private'] === 'yes') {
+ req.config = { filters: { messages: { pii: { action: 'redact' } } } };
+ }
+ next();
+});
jest.mock('@librechat/data-schemas', () => ({
logger: {
@@ -35,18 +48,28 @@ jest.mock('@librechat/api', () => ({
exemptAgentTriggerFromIpLimiter: (...args) => mockExemptAgentTrigger(...args),
exemptFromUserLimiter: (...args) => mockExemptSchedule(...args),
createMessageFilterPii: jest.fn(() => (_req, _res, next) => next()),
+ createPrivateTextIngress: jest.fn(
+ () =>
+ (...args) =>
+ mockIngress(...args),
+ ),
+ isPreDenialTextSubmission: (req) => req.method === 'POST' && typeof req.body?.text === 'string',
+ isPrivateTextChatSubmission: (req) =>
+ req.method === 'POST' &&
+ req.originalUrl === '/agents/chat' &&
+ typeof req.body?.text === 'string',
}));
jest.mock('~/server/middleware', () => ({
uaParser: (_req, _res, next) => next(),
- checkBan: (_req, _res, next) => next(),
+ checkBan: (...args) => mockCheckBan(...args),
requireJwtAuth: (req, _res, next) => {
req.user = { id: 'user-1' };
next();
},
moderateText: (_req, _res, next) => next(),
messageIpLimiter: (...args) => mockIpLimiter(...args),
- configMiddleware: (_req, _res, next) => next(),
+ configMiddleware: (...args) => mockConfigMiddleware(...args),
messageUserLimiter: (...args) => mockUserLimiter(...args),
}));
@@ -103,6 +126,74 @@ describe('start-generation idempotency before message limiters', () => {
mockExemptSchedule.mockReturnValue(false);
});
+ it('filters before a ban denial, IP limit, and user limit without charging config twice', async () => {
+ mockHasGenerationClaim.mockResolvedValue(false);
+ const payload = { text: '[email protected]', clientRequestId: 'request-privacy' };
+ mockCheckBan.mockImplementationOnce((req, res) => {
+ expect(req.body.text).toBe('[EMAIL_1]');
+ res.status(403).json({ banned: true });
+ });
+ const banned = await request(app)
+ .post('/agents/chat')
+ .set('X-Test-Private', 'yes')
+ .send(payload);
+ expect(banned.status).toBe(403);
+ expect(mockIpLimiter).not.toHaveBeenCalled();
+
+ mockIpLimiter.mockImplementationOnce((req, res) => {
+ expect(req.body.text).toBe('[EMAIL_1]');
+ res.status(429).json({ limited: 'ip' });
+ });
+ const ipLimited = await request(app)
+ .post('/agents/chat')
+ .set('X-Test-Private', 'yes')
+ .send(payload);
+ expect(ipLimited.status).toBe(429);
+ expect(mockUserLimiter).not.toHaveBeenCalled();
+
+ mockIpLimiter.mockImplementationOnce((_req, _res, next) => next());
+ mockUserLimiter.mockImplementationOnce((req, res) => {
+ expect(req.body.text).toBe('[EMAIL_1]');
+ res.status(429).json({ limited: 'user' });
+ });
+ const userLimited = await request(app)
+ .post('/agents/chat')
+ .set('X-Test-Private', 'yes')
+ .send(payload);
+ expect(userLimited.status).toBe(429);
+ expect(mockIngress).toHaveBeenCalledTimes(3);
+ expect(mockConfigMiddleware).toHaveBeenCalledTimes(3);
+ });
+
+ it.each(['/agents/chat/queued-turns', '/agents/chat/queued-turns/v2', '/agents/chat/steer'])(
+ 'loads policy once ahead of a banned text submission to %s without transforming it',
+ async (path) => {
+ mockCheckBan.mockImplementationOnce((req, res) => {
+ expect(req.config?.filters?.messages?.pii?.action).toBe('redact');
+ expect(req.body.text).toBe('[email protected]');
+ res.status(403).json({ banned: true });
+ });
+ const response = await request(app)
+ .post(path)
+ .set('X-Test-Private', 'yes')
+ .send({ text: '[email protected]' });
+ expect(response.status).toBe(403);
+ expect(mockConfigMiddleware).toHaveBeenCalledTimes(1);
+ expect(mockIngress).not.toHaveBeenCalled();
+ },
+ );
+
+ it('does not reload pre-denial config on an admitted queued submission', async () => {
+ mockIpLimiter.mockImplementationOnce((_req, _res, next) => next());
+ mockUserLimiter.mockImplementationOnce((_req, _res, next) => next());
+ const response = await request(app)
+ .post('/agents/chat/queued-turns')
+ .set('X-Test-Private', 'yes')
+ .send({ text: 'clean queued turn' });
+ expect(response.status).toBe(202);
+ expect(mockConfigMiddleware).toHaveBeenCalledTimes(1);
+ });
+
it('keeps a confirmed retry behind the shared IP limiter', async () => {
mockHasGenerationClaim.mockResolvedValue(true);
mockIpLimiter.mockImplementationOnce((_req, _res, next) => next());
diff --git a/api/server/routes/agents/__tests__/streamTenant.spec.js b/api/server/routes/agents/__tests__/streamTenant.spec.js
index 1003e99ea7..abb6f1240c 100644
--- a/api/server/routes/agents/__tests__/streamTenant.spec.js
+++ b/api/server/routes/agents/__tests__/streamTenant.spec.js
@@ -90,7 +90,10 @@ describe('SSE stream tenant isolation', () => {
checkpointIds: ['checkpoint-a'],
});
mockDeleteAgentCheckpoint.mockResolvedValue(undefined);
- mockSaveMessage.mockResolvedValue({ persisted: true });
+ mockSaveMessage.mockImplementation(async (_context, message) => ({
+ ...message,
+ persisted: true,
+ }));
mockGenerationJobManager.getActiveJobIdsForUser.mockResolvedValue([]);
mockGenerationJobManager.steering.claim.mockResolvedValue([]);
mockGenerationJobManager.steering.claimDetailed.mockResolvedValue({
@@ -1002,7 +1005,7 @@ describe('SSE stream tenant isolation', () => {
1,
expect.any(Object),
expect.objectContaining({ messageId: 'user-1', isCreatedByUser: true }),
- expect.any(Object),
+ expect.objectContaining({ insertOnly: true }),
);
expect(mockSaveMessage).toHaveBeenNthCalledWith(
2,
diff --git a/api/server/routes/agents/chat.js b/api/server/routes/agents/chat.js
index 6f64883aec..1a1fff7ae7 100644
--- a/api/server/routes/agents/chat.js
+++ b/api/server/routes/agents/chat.js
@@ -2,6 +2,7 @@ const express = require('express');
const { logger } = require('@librechat/data-schemas');
const {
createMessageFilterPii,
+ getPreinspectedPrivateText,
reportLocatorTraversalFailure,
generateCheckAccess,
skipAgentCheck,
@@ -66,6 +67,7 @@ router.use(
onTraversalFailure: reportLocatorTraversalFailure,
getConfig: (req) => req.config?.messageFilter?.pii,
getFilters: (req) => req.config?.filters,
+ getPreinspectedText: getPreinspectedPrivateText,
getFiles,
}),
);
diff --git a/api/server/routes/agents/index.js b/api/server/routes/agents/index.js
index 2442868e5d..8c6308fa78 100644
--- a/api/server/routes/agents/index.js
+++ b/api/server/routes/agents/index.js
@@ -16,6 +16,10 @@ const {
attachAskUserQuestionAnswers,
attachAskUserQuestionArgs,
createMessageFilterPii,
+ createPrivateTextIngress,
+ isPrivateTextChatSubmission,
+ isPreDenialTextSubmission,
+ saveAbortedUserMessage,
isAgentTriggerRequest,
exemptAgentTriggerFromIpLimiter,
captureScheduleFireContext,
@@ -50,7 +54,13 @@ const {
getServerGenerationProtocol,
negotiateExistingGenerationProtocol,
} = require('~/server/controllers/agents/protocol');
-const { getFiles, saveConvo, saveMessage } = require('~/models');
+const {
+ getFiles,
+ saveMessage,
+ saveConvo,
+ getPersistedPrivateTextId,
+ getPrivateMessageTexts,
+} = require('~/models');
const {
recordScheduleOutcome,
beginScheduledStop,
@@ -147,6 +157,19 @@ router.use((req, _res, next) => {
captureScheduleFireContext(req);
next();
});
+// Denials may persist submitted text on chat control routes too. Load policy before
+// any such denial; transformation remains limited to fresh interactive turns.
+const privateTextIngress = createPrivateTextIngress({
+ getFilters: (req) => req.config?.filters,
+ getLegacyPii: (req) => req.config?.messageFilter?.pii,
+ getKey: () => process.env.CREDS_KEY ?? '',
+});
+const chatConfigMiddleware = unless((req) => req.config != null, configMiddleware);
+router.use(
+ '/chat',
+ unless((req) => !isPreDenialTextSubmission(req), configMiddleware),
+ unless((req) => !isPrivateTextChatSubmission(req), privateTextIngress),
+);
router.use(checkBan);
router.use(uaParser);
@@ -569,7 +592,7 @@ router.get('/chat/status/:conversationId', async (req, res) => {
* @access Private
* @description Mounted before chatRouter to bypass buildEndpointOption middleware
*/
-router.post('/chat/abort', configMiddleware, async (req, res, next) => {
+router.post('/chat/abort', chatConfigMiddleware, async (req, res, next) => {
logger.debug(`[AgentStream] ========== ABORT ENDPOINT HIT ==========`);
logger.debug(`[AgentStream] Method: ${req.method}, Path: ${req.path}`);
@@ -832,9 +855,14 @@ router.post('/chat/abort', configMiddleware, async (req, res, next) => {
* operation gets a chance to succeed. */
let persistedRequestId;
try {
- const persistedRequest = await saveMessage(messageContext, requestMessage, {
- context: 'api/server/routes/agents/index.js - abort user prerequisite',
- });
+ const persistedRequest = await saveAbortedUserMessage(
+ { saveMessage, getPersistedPrivateTextId, getPrivateMessageTexts },
+ messageContext,
+ requestMessage,
+ { context: 'api/server/routes/agents/index.js - abort user prerequisite' },
+ req.user?.tenantId,
+ pendingAbortResult.finalEvent,
+ );
if (!persistedRequest) {
throw new Error('Abort user prerequisite was not persisted');
}
@@ -1079,7 +1107,7 @@ if (isEnabled(LIMIT_MESSAGE_USER)) {
}
router.post(
'/chat/steer',
- configMiddleware,
+ chatConfigMiddleware,
...steerLimiters,
createMessageFilterPii({
onTraversalFailure: reportLocatorTraversalFailure,
@@ -1100,7 +1128,7 @@ router.post(
*/
router.post(
'/chat/steer/deliver',
- configMiddleware,
+ chatConfigMiddleware,
...steerLimiters,
createMessageFilterPii({
onTraversalFailure: reportLocatorTraversalFailure,
@@ -1120,7 +1148,7 @@ router.post(
*/
router.post(
'/chat/steer/cancel',
- configMiddleware,
+ chatConfigMiddleware,
...steerLimiters,
SteerController.SteerCancelController,
);
@@ -1133,14 +1161,14 @@ router.post(
*/
router.post(
'/chat/steer/arm',
- configMiddleware,
+ chatConfigMiddleware,
...steerLimiters,
SteerController.SteerArmController,
);
router.post(
'/chat/queued-turns',
- configMiddleware,
+ chatConfigMiddleware,
...steerLimiters,
createMessageFilterPii({
onTraversalFailure: reportLocatorTraversalFailure,
@@ -1153,7 +1181,7 @@ router.post(
);
router.post(
'/chat/queued-turns/v2',
- configMiddleware,
+ chatConfigMiddleware,
...steerLimiters,
createMessageFilterPii({
onTraversalFailure: reportLocatorTraversalFailure,
@@ -1166,10 +1194,10 @@ router.post(
);
/** Synchronizing durable queue state is read-only and polled while work is
* pending. It must not consume the model-submission admission budget. */
-router.get('/chat/queued-turns', configMiddleware, AgentQueuedTurnListController);
+router.get('/chat/queued-turns', chatConfigMiddleware, AgentQueuedTurnListController);
router.delete(
'/chat/queued-turns/:queuedTurnId',
- configMiddleware,
+ chatConfigMiddleware,
...steerLimiters,
AgentQueuedTurnCancelController,
);
@@ -1179,7 +1207,7 @@ router.use('/', v1);
const chatRouter = express.Router();
const useMessageIpLimiter = isEnabled(LIMIT_MESSAGE_IP);
const useMessageUserLimiter = isEnabled(LIMIT_MESSAGE_USER);
-chatRouter.use(configMiddleware);
+chatRouter.use(chatConfigMiddleware);
if (useMessageIpLimiter || useMessageUserLimiter) {
chatRouter.use(
unless(
diff --git a/api/server/routes/messages.js b/api/server/routes/messages.js
index b07e37c01d..f652e8523b 100644
--- a/api/server/routes/messages.js
+++ b/api/server/routes/messages.js
@@ -27,6 +27,8 @@ const {
mergeUserSubmittedMessageFieldPaths,
isContentFilterError,
withoutTraceRefs,
+ createPrivateTextView,
+ stripPrivateMessageFields,
applyForcedRetention,
} = require('@librechat/api');
const subagentThreadTaskStore = require('~/server/services/Endpoints/agents/subagentThreadStore');
@@ -66,6 +68,13 @@ const storedMessageMutationMiddleware = [
];
router.use(requireJwtAuth);
+router.post(
+ '/:conversationId/owner-text',
+ createPrivateTextView({
+ read: db.getPrivateMessageTexts,
+ getKey: () => process.env.CREDS_KEY ?? '',
+ }),
+);
async function rejectSubagentThreadWrite(req, res, conversationId) {
const blocked = await isSubagentThreadWriteBlocked(
@@ -194,9 +203,8 @@ router.get('/', async (req, res) => {
for (const message of cleanedMessages) {
const convo = result.convoMap[message.conversationId];
const dbMessage = dbMessageMap[message.messageId];
- /** Search hydrates every schema field; server-private state never leaves. */
- const publicHit = { ...message };
- delete publicHit.contextMeta;
+ /** Search may hydrate server-private fields; only a public projection leaves. */
+ const publicHit = stripPrivateMessageFields(message);
activeMessages.push({
...publicHit,
@@ -238,9 +246,7 @@ router.get('/', async (req, res) => {
* @returns {TMessage}
*/
function toClientMessage(message) {
- const clientMessage = { ...message };
- delete clientMessage.contextMeta;
- return clientMessage;
+ return stripPrivateMessageFields(message);
}
router.post('/branch', configMiddleware, async (req, res) => {
diff --git a/api/server/utils/import/fork.js b/api/server/utils/import/fork.js
index 861e612e22..dc141a6319 100644
--- a/api/server/utils/import/fork.js
+++ b/api/server/utils/import/fork.js
@@ -1,9 +1,12 @@
const { v4: uuidv4 } = require('uuid');
const {
cloneLineage,
+ saveCopiedMessage,
+ createNativeCopyPreflight,
withoutTraceRefs,
isTemporaryRecord,
getAllMessagesUpToParent,
+ transferNativeCopyProvenance,
} = require('@librechat/api');
const { logger, tenantStorage } = require('@librechat/data-schemas');
const { EModelEndpoint, Constants, ForkOptions } = require('librechat-data-provider');
@@ -24,7 +27,7 @@ const BaseClient = require('~/app/clients/BaseClient');
function cloneMessagesWithTimestamps(
messagesToClone,
importBatchBuilder,
- { detachSubagentRuntime = false } = {},
+ { detachSubagentRuntime = false, nativeCopy = false } = {},
) {
const { entries, idMapping } = cloneLineage(messagesToClone, uuidv4);
for (const { source, messageId, parentMessageId, createdAt } of entries) {
@@ -34,12 +37,15 @@ function cloneMessagesWithTimestamps(
parentMessageId,
createdAt,
};
+ delete clonedMessage.privateText;
+ delete clonedMessage.privacyRevision;
+ delete clonedMessage.privateTextTokens;
if (detachSubagentRuntime) {
delete clonedMessage.subagentTask;
delete clonedMessage.subagentTranscript;
}
- importBatchBuilder.saveMessage(clonedMessage);
+ saveCopiedMessage(importBatchBuilder, source, clonedMessage, nativeCopy);
}
return idMapping;
@@ -78,10 +84,13 @@ async function forkConversation({
}) {
try {
const originalConvo = await getConvo(requestUserId, originalConvoId);
- let originalMessages = await getMessages({
- user: requestUserId,
- conversationId: originalConvoId,
- });
+ let originalMessages = await getMessages(
+ {
+ user: requestUserId,
+ conversationId: originalConvoId,
+ },
+ '+privateTextTokens',
+ );
let targetMessageId = targetId;
if (splitAtTarget && !latestMessageId) {
@@ -119,6 +128,7 @@ async function forkConversation({
* durable child executor. Preserve visible history while dropping the
* task protocol and private serialized model transcript. */
detachSubagentRuntime: originalConvo.subagentThread != null,
+ nativeCopy: true,
});
const result = importBatchBuilder.finishConversation(
@@ -138,10 +148,13 @@ async function forkConversation({
}
const conversation = await getConvo(requestUserId, result.conversation.conversationId);
- const messages = await getMessages({
- user: requestUserId,
- conversationId: conversation.conversationId,
- });
+ const messages = await getMessages(
+ {
+ user: requestUserId,
+ conversationId: conversation.conversationId,
+ },
+ '-privateTextTokens',
+ );
return {
conversation,
@@ -371,7 +384,7 @@ async function forkSharedConversation({
// or share file URLs into the new conversation while file serving is off.
const share = await getSharedMessages(shareId, shareResourceId, {
snapshotFiles,
- preflight: sharedContentPreflight,
+ preflight: createNativeCopyPreflight(sharedContentPreflight),
});
if (!share?.messages?.length) {
return null;
@@ -417,14 +430,18 @@ async function forkSharedConversation({
}
const messageIds = new Set(sourceMessages.map((message) => message.messageId));
- const messagesToClone = sourceMessages.map(({ model: _model, ...message }) =>
- stripSharedFileIds({
- ...message,
- parentMessageId:
- message.parentMessageId != null && messageIds.has(message.parentMessageId)
- ? message.parentMessageId
- : Constants.NO_PARENT,
- }),
+ const messagesToClone = sourceMessages.map((source) =>
+ transferNativeCopyProvenance(
+ source,
+ stripSharedFileIds({
+ ...source,
+ model: undefined,
+ parentMessageId:
+ source.parentMessageId != null && messageIds.has(source.parentMessageId)
+ ? source.parentMessageId
+ : Constants.NO_PARENT,
+ }),
+ ),
);
/**
@@ -458,7 +475,7 @@ async function forkSharedConversation({
);
importBatchBuilder.startConversation(endpoint);
- cloneMessagesWithTimestamps(messagesToClone, importBatchBuilder);
+ cloneMessagesWithTimestamps(messagesToClone, importBatchBuilder, { nativeCopy: true });
const result = importBatchBuilder.finishConversation(share.title, new Date(), {}, model);
await importBatchBuilder.saveBatch();
@@ -469,10 +486,13 @@ async function forkSharedConversation({
});
const conversation = await getConvo(requestUserId, result.conversation.conversationId);
- const messages = await getMessages({
- user: requestUserId,
- conversationId: conversation.conversationId,
- });
+ const messages = await getMessages(
+ {
+ user: requestUserId,
+ conversationId: conversation.conversationId,
+ },
+ '-privateTextTokens',
+ );
return {
conversation,
@@ -507,10 +527,13 @@ async function duplicateConversation({
throw new Error('Conversation not found');
}
- const originalMessages = await getMessages({
- user: userId,
- conversationId,
- });
+ const originalMessages = await getMessages(
+ {
+ user: userId,
+ conversationId,
+ },
+ '+privateTextTokens',
+ );
const messagesToClone = getMessagesUpToTargetLevel(
originalMessages,
@@ -524,7 +547,7 @@ async function duplicateConversation({
importBatchBuilder.sourceIsTemporary = isTemporaryRecord(originalConvo);
importBatchBuilder.startConversation(originalConvo.endpoint ?? EModelEndpoint.openAI);
- cloneMessagesWithTimestamps(messagesToClone, importBatchBuilder);
+ cloneMessagesWithTimestamps(messagesToClone, importBatchBuilder, { nativeCopy: true });
const duplicateTitle = title || originalConvo.title;
const result = importBatchBuilder.finishConversation(duplicateTitle, new Date(), originalConvo);
@@ -537,10 +560,13 @@ async function duplicateConversation({
});
const conversation = await getConvo(userId, result.conversation.conversationId);
- const messages = await getMessages({
- user: userId,
- conversationId: conversation.conversationId,
- });
+ const messages = await getMessages(
+ {
+ user: userId,
+ conversationId: conversation.conversationId,
+ },
+ '-privateTextTokens',
+ );
return {
conversation,
diff --git a/api/server/utils/import/fork.spec.js b/api/server/utils/import/fork.spec.js
index 2273ef2fc5..8bf578fcfe 100644
--- a/api/server/utils/import/fork.spec.js
+++ b/api/server/utils/import/fork.spec.js
@@ -755,7 +755,7 @@ describe('forkSharedConversation', () => {
expect(getSharedMessages).toHaveBeenCalledWith('share123', 'resource123', {
snapshotFiles: undefined,
- preflight: undefined,
+ preflight: expect.any(Function),
});
const savedMessages = bulkSaveMessages.mock.calls[0][0];
@@ -891,7 +891,7 @@ describe('forkSharedConversation', () => {
expect(getSharedMessages).toHaveBeenCalledWith('share123', 'resource123', {
snapshotFiles: false,
- preflight: undefined,
+ preflight: expect.any(Function),
});
});
@@ -905,9 +905,12 @@ describe('forkSharedConversation', () => {
sharedContentPreflight,
});
+ const options = getSharedMessages.mock.calls[0][2];
+ await options.preflight(mockShare, { canonicalMessages: [] });
+ expect(sharedContentPreflight).toHaveBeenCalledWith(mockShare, { canonicalMessages: [] });
expect(getSharedMessages).toHaveBeenCalledWith('share123', 'resource123', {
snapshotFiles: undefined,
- preflight: sharedContentPreflight,
+ preflight: expect.any(Function),
});
});
@@ -1544,6 +1547,27 @@ describe('splitAtTargetLevel', () => {
});
describe('cloneMessagesWithTimestamps', () => {
+ test('does not carry private owner metadata into a new message identity', () => {
+ const importBatchBuilder = createImportBatchBuilder('owner');
+ importBatchBuilder.startConversation();
+ cloneMessagesWithTimestamps(
+ [
+ {
+ messageId: 'source',
+ parentMessageId: Constants.NO_PARENT,
+ text: '[EMAIL_1]',
+ isCreatedByUser: true,
+ privateText: 'v1:ciphertext',
+ privacyRevision: 'source-revision',
+ },
+ ],
+ importBatchBuilder,
+ );
+ const cloned = importBatchBuilder.messages[0];
+ expect(cloned.text).toBe('[EMAIL_1]');
+ expect(cloned).not.toHaveProperty('privateText');
+ expect(cloned).not.toHaveProperty('privacyRevision');
+ });
test('should preserve user-submitted provenance without marking untouched model output', () => {
const messagesToClone = [
{
@@ -1890,3 +1914,105 @@ describe('cloneMessagesWithTimestamps', () => {
expect(clonedMessages.length).toBe(complexMessages.length);
});
});
+
+describe('native copy protected token admission', () => {
+ beforeEach(() => jest.clearAllMocks());
+ const revision = 'a'.repeat(32);
+ const token = `[EMAIL_1_${revision}]`;
+ const filters = {
+ messages: {
+ pii: {
+ fields: ['text'],
+ starterPatterns: [],
+ customPatterns: [{ id: 'hex', label: 'Credential', regex: '[a-f0-9]{32}' }],
+ },
+ },
+ };
+ const source = {
+ messageId: 'protected-source',
+ conversationId: 'source',
+ parentMessageId: Constants.NO_PARENT,
+ text: token,
+ isCreatedByUser: true,
+ privacyRevision: revision,
+ };
+ it.each(['fork', 'duplicate'])(
+ 'admits %s with exact trusted tokens and persists only canonical provenance',
+ async (kind) => {
+ getConvo.mockResolvedValue({
+ conversationId: 'source',
+ endpoint: 'agents',
+ title: 'Safe copy',
+ });
+ getMessages.mockResolvedValue([source]);
+ const result =
+ kind === 'fork'
+ ? await forkConversation({
+ originalConvoId: 'source',
+ targetMessageId: source.messageId,
+ requestUserId: 'owner',
+ filters,
+ })
+ : await duplicateConversation({ conversationId: 'source', userId: 'owner', filters });
+ expect(result).toBeDefined();
+ const call = bulkSaveMessages.mock.calls.at(-1);
+ expect(call[0][0]).not.toHaveProperty('privacyRevision');
+ expect(call[0][0]).not.toHaveProperty('privateTextTokens');
+ expect(call[2].privateTextTokens.get(call[0][0].messageId)).toEqual([token]);
+ },
+ );
+ it("retains a copied row's server-only token provenance across a second native copy", async () => {
+ getConvo.mockResolvedValue({
+ conversationId: 'copy',
+ endpoint: 'agents',
+ title: 'Second copy',
+ });
+ getMessages.mockResolvedValue([
+ { ...source, privacyRevision: undefined, privateTextTokens: [token] },
+ ]);
+ await duplicateConversation({ conversationId: 'copy', userId: 'owner', filters });
+ const [rows, , metadata] = bulkSaveMessages.mock.calls.at(-1);
+ expect(metadata.privateTextTokens.get(rows[0].messageId)).toEqual([token]);
+ expect(rows[0]).not.toHaveProperty('privateTextTokens');
+ });
+
+ it('uses share-authorized canonical provenance without putting it in the shared DTO', async () => {
+ const share = {
+ title: 'Shared',
+ messages: [{ ...source, privacyRevision: undefined }],
+ conversationId: 'anonymous',
+ shareId: 'shared',
+ };
+ getSharedMessages.mockImplementationOnce(async (_id, _resource, options) => {
+ await options.preflight(share, { canonicalMessages: [source] });
+ return share;
+ });
+ getConvo.mockResolvedValue({ conversationId: 'copy', endpoint: 'agents' });
+ getMessages.mockResolvedValue([]);
+ const loadAppConfig = jest.fn(async () => ({ filters }));
+ await forkSharedConversation({ shareId: 'shared', requestUserId: 'viewer', loadAppConfig });
+ const [rows, , metadata] = bulkSaveMessages.mock.calls.at(-1);
+ expect(metadata.privateTextTokens.get(rows[0].messageId)).toEqual([token]);
+ expect(JSON.stringify(share)).not.toContain('privateTextTokens');
+ expect(rows[0]).not.toHaveProperty('privacyRevision');
+ });
+
+ it('does not grant token trust to untrusted use of the generic clone helper', async () => {
+ const builder = createImportBatchBuilder('owner', undefined, filters);
+ builder.startConversation();
+ cloneMessagesWithTimestamps([source], builder);
+ builder.finishConversation('Safe title');
+ await expect(builder.saveBatch()).rejects.toMatchObject({ code: 'content_filter_block' });
+ });
+ it('rejects raw credentials adjacent to native-copy placeholders', async () => {
+ getConvo.mockResolvedValue({
+ conversationId: 'source',
+ endpoint: 'agents',
+ title: 'Safe copy',
+ });
+ getMessages.mockResolvedValue([{ ...source, text: `${token} ${'b'.repeat(32)}` }]);
+ await expect(
+ duplicateConversation({ conversationId: 'source', userId: 'owner', filters }),
+ ).rejects.toMatchObject({ code: 'content_filter_block' });
+ });
+});
diff --git a/api/server/utils/import/importBatchBuilder.js b/api/server/utils/import/importBatchBuilder.js
index f7421fce57..3ab878f298 100644
--- a/api/server/utils/import/importBatchBuilder.js
+++ b/api/server/utils/import/importBatchBuilder.js
@@ -7,6 +7,8 @@ const {
executeConversationImportWrites,
resolveImportRetentionFields,
resolveImportTagCounts,
+ getNativeCopyInspectionTokens,
+ saveNativeCopyMessages,
} = require('@librechat/api');
const {
getTenantId,
@@ -202,6 +204,7 @@ class ImportBatchBuilder {
{
user: { id: this.requestUserId },
getFiles,
+ privateTextTokens: getNativeCopyInspectionTokens(this.messages),
...(this.legacyPii == null ? {} : { legacyPii: this.legacyPii }),
},
);
@@ -220,7 +223,7 @@ class ImportBatchBuilder {
try {
await executeConversationImportWrites({
saveConversations: () => bulkSaveConvos(this.conversations),
- saveMessages: () => bulkSaveMessages(this.messages, true),
+ saveMessages: () => saveNativeCopyMessages(bulkSaveMessages, this.messages),
updateTagCounts: () => bulkIncrementTagCounts(this.requestUserId, tags),
deleteMessages: () => deleteImportedMessages(cleanupScope),
deleteConversations: () => deleteImportedConversations(cleanupScope),
diff --git a/api/server/utils/import/importers.js b/api/server/utils/import/importers.js
index d496749e5c..9a995257c8 100644
--- a/api/server/utils/import/importers.js
+++ b/api/server/utils/import/importers.js
@@ -68,6 +68,9 @@ function sanitizeImportedMessage(message) {
/** Server-private run state and trace sampling records never come from an import. */
const importable = withoutTraceRefs({ ...message });
delete importable.contextMeta;
+ delete importable.privateText;
+ delete importable.privacyRevision;
+ delete importable.privateTextTokens;
return {
...importable,
isUserSubmitted: true,
diff --git a/api/server/utils/import/importers.spec.js b/api/server/utils/import/importers.spec.js
index b4b2062ed8..ca6e0686fa 100644
--- a/api/server/utils/import/importers.spec.js
+++ b/api/server/utils/import/importers.spec.js
@@ -38,6 +38,28 @@ afterEach(() => {
jest.clearAllMocks();
});
+it('strips server-private owner metadata from untrusted LibreChat imports', async () => {
+ const jsonData = {
+ conversationId: 'imported',
+ title: 'Imported',
+ messages: [
+ {
+ messageId: 'source',
+ parentMessageId: Constants.NO_PARENT,
+ text: '[EMAIL_1]',
+ isCreatedByUser: true,
+ privateText: 'v1:forged',
+ privacyRevision: 'forged',
+ },
+ ],
+ };
+ const importBatchBuilder = new ImportBatchBuilder('owner');
+ await getImporter(jsonData)(jsonData, 'owner', () => importBatchBuilder);
+ expect(importBatchBuilder.messages[0].text).toBe('[EMAIL_1]');
+ expect(importBatchBuilder.messages[0]).not.toHaveProperty('privateText');
+ expect(importBatchBuilder.messages[0]).not.toHaveProperty('privacyRevision');
+});
+
describe('importChatGptConvo', () => {
it('should import conversation correctly', async () => {
const expectedNumberOfMessages = 19;
diff --git a/api/test/server/middleware/checkBan.test.js b/api/test/server/middleware/checkBan.test.js
index 86024bd82d..2166c55922 100644
--- a/api/test/server/middleware/checkBan.test.js
+++ b/api/test/server/middleware/checkBan.test.js
@@ -307,6 +307,19 @@ describe('checkBan middleware', () => {
},
);
+ it('treats a banned queued-turn POST as an early text-saving denial', async () => {
+ mockBanCacheGet.mockResolvedValueOnce({ expiresAt: Date.now() + 60000 });
+ const req = createReq({
+ method: 'POST',
+ baseUrl: '/api/agents',
+ originalUrl: '/api/agents/chat/queued-turns',
+ body: { text: 'submitted text' },
+ });
+ const res = createRes();
+ await checkBan(req, res, jest.fn());
+ expect(denyRequest).toHaveBeenCalledWith(req, res, { type: ViolationTypes.BAN });
+ });
+
it('preserves SSE denial for a banned browser interactive chat request', async () => {
mockBanCacheGet.mockResolvedValueOnce({ expiresAt: Date.now() + 60000 });
const req = createReq({
diff --git a/client/src/components/Chat/ChatView.tsx b/client/src/components/Chat/ChatView.tsx
index 92db695e29..aef8fd047f 100644
--- a/client/src/components/Chat/ChatView.tsx
+++ b/client/src/components/Chat/ChatView.tsx
@@ -31,6 +31,7 @@ import { pendingApprovalActionFamily } from './approval/state';
import ProjectBadge from '~/components/Projects/ProjectBadge';
import { composerLiftFamily } from './Input/Composer/state';
import { showComposerTipsAtom } from '~/store/composerTips';
+import { OwnerTextProvider } from './Messages/PrivateText';
import { useGetMessagesByConvoId } from '~/data-provider';
import Footer, { useConfiguredFooter } from './Footer';
import { AskAnswerHostProvider } from './ask/state';
@@ -228,7 +229,13 @@ function ChatView({
!isLandingPage && chatProjectId && 'pt-9',
)}
>
- {content}
+ <OwnerTextProvider
+ messages={messages}
+ conversationId={conversationId}
+ isSubmitting={chatHelpers.isSubmitting}
+ >
+ {content}
+ </OwnerTextProvider>
{/* Named + opaque so a view transition (the ask_user_question
popover ⇄ chat-card morph) paints the whole composer band
over the travelling card instead of letting it show
diff --git a/client/src/components/Chat/Messages/Content/EditMessage.tsx b/client/src/components/Chat/Messages/Content/EditMessage.tsx
index 58499fb1ce..5047845775 100644
--- a/client/src/components/Chat/Messages/Content/EditMessage.tsx
+++ b/client/src/components/Chat/Messages/Content/EditMessage.tsx
@@ -164,6 +164,7 @@ const EditMessage = ({
);
if (!isInMessages) {
message.text = data.text;
+ message.privacyRevision = undefined;
} else {
setMessages(
messages.map((msg) =>
@@ -171,6 +172,7 @@ const EditMessage = ({
? {
...msg,
text: data.text,
+ privacyRevision: undefined,
}
: msg,
),
diff --git a/client/src/components/Chat/Messages/Content/MessageContent.tsx b/client/src/components/Chat/Messages/Content/MessageContent.tsx
index 090a1e45a3..6cea94d3ac 100644
--- a/client/src/components/Chat/Messages/Content/MessageContent.tsx
+++ b/client/src/components/Chat/Messages/Content/MessageContent.tsx
@@ -98,7 +98,7 @@ export const ErrorMessage = ({
);
};
-const DisplayMessage = ({ text, isCreatedByUser, message, showCursor }: TDisplayProps) => {
+export const DisplayMessage = ({ text, isCreatedByUser, message, showCursor }: TDisplayProps) => {
const { isSubmitting = false, isLatestMessage = false } = useMessageContext();
const enableUserMsgMarkdown = useRecoilValue(store.enableUserMsgMarkdown);
const collapseLongUserMessages = useRecoilValue(store.collapseLongUserMessages);
diff --git a/client/src/components/Chat/Messages/Content/__tests__/EditMessage.spec.tsx b/client/src/components/Chat/Messages/Content/__tests__/EditMessage.spec.tsx
index 6cb0126658..7a89390656 100644
--- a/client/src/components/Chat/Messages/Content/__tests__/EditMessage.spec.tsx
+++ b/client/src/components/Chat/Messages/Content/__tests__/EditMessage.spec.tsx
@@ -129,6 +129,28 @@ describe('EditMessage', () => {
expect(enterEdit).toHaveBeenCalledWith(true);
});
+ it('clears the private revision when a protected message is saved', async () => {
+ const protectedMessage = { ...message, privacyRevision: 'previous-revision' };
+ mockGetMessages.mockReturnValue([protectedMessage]);
+ const user = userEvent.setup();
+ renderEditor({ editedMessage: protectedMessage });
+
+ await user.clear(screen.getByTestId('message-text-editor'));
+ await user.type(screen.getByTestId('message-text-editor'), 'Clean edited message');
+ await user.click(screen.getByRole('button', { name: 'com_ui_save' }));
+
+ await waitFor(() =>
+ expect(mockSetMessages).toHaveBeenCalledWith([
+ expect.objectContaining({
+ messageId: message.messageId,
+ text: 'Clean edited message',
+ privacyRevision: undefined,
+ }),
+ ]),
+ );
+ expect(protectedMessage.privacyRevision).toBe('previous-revision');
+ });
+
it('writes the save onto the thread as it stands when the request resolves', async () => {
const user = userEvent.setup();
const streamedAnswer = {
diff --git a/client/src/components/Chat/Messages/MessagesView.tsx b/client/src/components/Chat/Messages/MessagesView.tsx
index 8e0e80c961..97b4dd9cc8 100644
--- a/client/src/components/Chat/Messages/MessagesView.tsx
+++ b/client/src/components/Chat/Messages/MessagesView.tsx
@@ -161,7 +161,12 @@ function MessagesViewContent({
</div>
) : (
<>
- <div ref={screenshotTargetRef} data-testid="screenshot-target">
+ <div
+ key={treeConversationId}
+ ref={screenshotTargetRef}
+ data-conversation-id={treeConversationId}
+ data-testid="screenshot-target"
+ >
<RowMountProvider mountWindow={mountWindow}>
{FLAT_THREAD && threadRows ? (
<ThreadList
diff --git a/client/src/components/Chat/Messages/PrivateText.spec.tsx b/client/src/components/Chat/Messages/PrivateText.spec.tsx
new file mode 100644
index 0000000000..dab3c2f8f6
--- /dev/null
+++ b/client/src/components/Chat/Messages/PrivateText.spec.tsx
@@ -0,0 +1,360 @@
+import { dataService } from 'librechat-data-provider';
+import { render, screen, waitFor, act } from '@testing-library/react';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import type { TMessage } from 'librechat-data-provider';
+import type { ReactNode } from 'react';
+import { getOwnerQueryClient } from '~/data-provider/Messages/private';
+import { OwnerTextProvider, PrivateText } from './PrivateText';
+
+let mockOwnerId = 'owner';
+let mockTenantId = 'tenant-a';
+jest.mock('~/hooks/AuthContext', () => ({
+ useAuthContext: () => ({ user: { id: mockOwnerId, tenantId: mockTenantId } }),
+}));
+jest.mock('~/hooks', () => ({ useLocalize: () => (key: string) => key }));
+jest.mock('librechat-data-provider', () => ({
+ ...jest.requireActual('librechat-data-provider'),
+ dataService: { getOwnerMessageTexts: jest.fn() },
+}));
+jest.mock('./Content/MessageContent', () => ({
+ DisplayMessage: ({ text, message }: { text: string; message: TMessage }) => (
+ <div data-testid="standard-user-renderer" data-canonical={message.text} dir="auto">
+ {text}
+ </div>
+ ),
+}));
+
+const canonical = Object.freeze({
+ messageId: 'message',
+ conversationId: 'conversation',
+ isCreatedByUser: true,
+ text: '[EMAIL_1_turn]',
+ privacyRevision: 'turn',
+}) as TMessage;
+const load = dataService.getOwnerMessageTexts as jest.Mock;
+let applicationClient: QueryClient;
+function Wrapper({ children }: { children: ReactNode }) {
+ return <QueryClientProvider client={applicationClient}>{children}</QueryClientProvider>;
+}
+function renderView(ui: ReactNode) {
+ return render(ui, { wrapper: Wrapper });
+}
+const original = {
+ canonicalText: canonical.text,
+ messageId: 'message',
+ revision: 'turn',
+};
+function View({
+ conversationId = 'conversation',
+ messages = [canonical],
+ displayIndex = 0,
+ isSubmitting = false,
+}: {
+ conversationId?: string;
+ messages?: TMessage[];
+ displayIndex?: number;
+ isSubmitting?: boolean;
+}) {
+ return (
+ <OwnerTextProvider
+ messages={messages}
+ conversationId={conversationId}
+ isSubmitting={isSubmitting}
+ >
+ <PrivateText message={messages[displayIndex]} />
+ <pre data-testid="canonical">{JSON.stringify(messages)}</pre>
+ </OwnerTextProvider>
+ );
+}
+beforeEach(() => {
+ mockOwnerId = 'owner';
+ mockTenantId = 'tenant-a';
+ load.mockReset();
+ applicationClient = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+});
+
+it('renders originals without mutating canonical model/export input, and reloads from the private API', async () => {
+ load.mockResolvedValue({ messages: [original] });
+ const first = renderView(<View />);
+ expect(await screen.findByText('[email protected]')).toBeInTheDocument();
+ expect(screen.getByTestId('canonical')).not.toHaveTextContent('[email protected]');
+ expect(screen.getByTestId('standard-user-renderer')).toHaveAttribute(
+ 'data-canonical',
+ canonical.text,
+ );
+ expect(canonical.text).toBe('[EMAIL_1_turn]');
+ expect(screen.getByRole('status')).toHaveTextContent('com_ui_private_text_hidden');
+ first.unmount();
+ await waitFor(() =>
+ expect(getOwnerQueryClient(applicationClient).getQueryCache().getAll()).toHaveLength(0),
+ );
+ renderView(<View />);
+ expect(await screen.findByText('[email protected]')).toBeInTheDocument();
+ expect(load).toHaveBeenCalledTimes(2);
+});
+
+it('loads the acknowledged first-turn owner text before navigating away from /new', async () => {
+ const firstTurn = {
+ ...canonical,
+ conversationId: '11111111-1111-4111-8111-111111111111',
+ };
+ load.mockResolvedValue({ messages: [{ ...original, canonicalText: firstTurn.text }] });
+ const view = renderView(<View conversationId="new" messages={[firstTurn]} isSubmitting />);
+ expect(await screen.findByText(original.text)).toBeInTheDocument();
+ expect(load).toHaveBeenCalledWith(firstTurn.conversationId, ['message']);
+ expect(load).not.toHaveBeenCalledWith('new', expect.anything());
+
+ view.rerender(
+ <View conversationId={firstTurn.conversationId} messages={[firstTurn]} isSubmitting />,
+ );
+ expect(screen.getByText(original.text)).toBeInTheDocument();
+ expect(load).toHaveBeenCalledTimes(1);
+});
+
+it('never mixes protected rows from stale conversations into a first-turn owner read', async () => {
+ const old = {
+ ...canonical,
+ messageId: 'old-message',
+ conversationId: '11111111-1111-4111-8111-111111111111',
+ };
+ const fresh = {
+ ...canonical,
+ messageId: 'fresh-message',
+ conversationId: '22222222-2222-4222-8222-222222222222',
+ };
+ load.mockResolvedValue({ messages: [{ ...original, messageId: 'fresh-message' }] });
+ renderView(<View conversationId="new" messages={[old, fresh]} displayIndex={1} isSubmitting />);
+ expect(await screen.findByText(original.text)).toBeInTheDocument();
+ expect(load).toHaveBeenCalledTimes(1);
+ expect(load).toHaveBeenCalledWith(fresh.conversationId, ['fresh-message']);
+});
+
+it('does not fetch originals for an ordinary transcript', () => {
+ const plain = { ...canonical, privacyRevision: undefined };
+ renderView(
+ <OwnerTextProvider messages={[plain]} conversationId="conversation" isSubmitting={false}>
+ <span data-testid="ordinary-transcript" />
+ </OwnerTextProvider>,
+ );
+ expect(screen.getByTestId('ordinary-transcript')).toBeInTheDocument();
+ expect(load).not.toHaveBeenCalled();
+});
+
+it('renders only filtered text without an owner provider, as on external viewers', () => {
+ renderView(<PrivateText message={canonical} />);
+ expect(screen.getByText(canonical.text)).toBeInTheDocument();
+ expect(load).not.toHaveBeenCalled();
+});
+
+it('shows loading then safe unavailable text when decryption or authorization fails', async () => {
+ let finish!: (value: { messages: [] }) => void;
+ load.mockReturnValue(
+ new Promise((resolve) => {
+ finish = resolve;
+ }),
+ );
+ renderView(<View />);
+ expect(screen.getByRole('status')).toHaveTextContent('com_ui_private_text_loading');
+ await act(async () => {
+ finish({ messages: [] });
+ });
+ expect(screen.getByText(canonical.text)).toBeInTheDocument();
+ await waitFor(() =>
+ expect(screen.getByRole('status')).toHaveTextContent('com_ui_private_text_unavailable'),
+ );
+});
+
+it('retries a provisional empty owner read once on turn completion, without repeatedly polling', async () => {
+ load.mockResolvedValueOnce({ messages: [] });
+ load.mockResolvedValueOnce({ messages: [original] });
+ const view = renderView(<View isSubmitting />);
+ await waitFor(() =>
+ expect(screen.getByRole('status')).toHaveTextContent('com_ui_private_text_unavailable'),
+ );
+ expect(load).toHaveBeenCalledTimes(1);
+ view.rerender(<View isSubmitting />);
+ expect(load).toHaveBeenCalledTimes(1);
+ view.rerender(<View isSubmitting={false} />);
+ expect(await screen.findByText(original.text)).toBeInTheDocument();
+ expect(load).toHaveBeenCalledTimes(2);
+ view.rerender(<View isSubmitting={false} />);
+ expect(load).toHaveBeenCalledTimes(2);
+});
+
+it('does not automatically retry an old missing owner row on unrelated submission transitions', async () => {
+ load.mockResolvedValue({ messages: [] });
+ const view = renderView(<View />);
+ await waitFor(() =>
+ expect(screen.getByRole('status')).toHaveTextContent('com_ui_private_text_unavailable'),
+ );
+ view.rerender(<View isSubmitting />);
+ view.rerender(<View isSubmitting={false} />);
+ expect(load).toHaveBeenCalledTimes(1);
+});
+
+it('offers a safe retry after a transient owner-text request failure', async () => {
+ load.mockRejectedValueOnce(new Error('temporary outage'));
+ load.mockResolvedValueOnce({ messages: [original] });
+ renderView(<View />);
+
+ const retry = await screen.findByRole('button', { name: 'com_ui_private_text_retry' });
+ expect(screen.getByText(canonical.text)).toBeInTheDocument();
+ expect(screen.getByTestId('canonical')).not.toHaveTextContent(original.text);
+ await act(async () => {
+ retry.click();
+ });
+ expect(await screen.findByText(original.text)).toBeInTheDocument();
+ expect(load).toHaveBeenCalledTimes(2);
+ expect(screen.queryByRole('button', { name: 'com_ui_private_text_retry' })).toBeNull();
+});
+
+it('does not cache a failed decryption as if it contained a usable original', async () => {
+ load.mockResolvedValueOnce({ messages: [{ ...original, text: undefined }] });
+ load.mockResolvedValueOnce({ messages: [original] });
+ renderView(<View />);
+ const retry = await screen.findByRole('button', { name: 'com_ui_private_text_retry' });
+ expect(screen.getByText(canonical.text)).toBeInTheDocument();
+ await act(async () => retry.click());
+ expect(await screen.findByText(original.text)).toBeInTheDocument();
+ expect(load).toHaveBeenCalledTimes(2);
+});
+
+it('rejects stale revisions instead of restoring a previous original', async () => {
+ load.mockResolvedValue({ messages: [{ ...original, revision: 'old-revision' }] });
+ renderView(<View />);
+ await waitFor(() =>
+ expect(screen.getByRole('status')).toHaveTextContent('com_ui_private_text_unavailable'),
+ );
+ expect(screen.queryByText(original.text)).not.toBeInTheDocument();
+});
+
+it('clears the visible original immediately on account switching, ignoring late responses', async () => {
+ let finish!: (value: { messages: (typeof original)[] }) => void;
+ load.mockImplementationOnce(
+ () =>
+ new Promise((resolve) => {
+ finish = resolve;
+ }),
+ );
+ load.mockResolvedValue({ messages: [] });
+ const view = renderView(<View />);
+ mockOwnerId = 'another-owner';
+ view.rerender(<View />);
+ await act(async () => {
+ finish({ messages: [original] });
+ });
+ expect(screen.queryByText(original.text)).not.toBeInTheDocument();
+ expect(screen.getByText(canonical.text)).toBeInTheDocument();
+});
+
+it('batches selected private rows and never loads ordinary messages', async () => {
+ load.mockResolvedValue({ messages: [] });
+ const messages: TMessage[] = Array.from({ length: 51 }, (_, index) => ({
+ ...canonical,
+ messageId: `message-${index}`,
+ }));
+ messages.push({ ...canonical, messageId: 'plain', privacyRevision: undefined });
+ renderView(<View messages={messages} />);
+ await waitFor(() => expect(load).toHaveBeenCalledTimes(2));
+ expect(load.mock.calls.map(([, ids]) => ids.length)).toEqual([50, 1]);
+ expect(load.mock.calls.flatMap(([, ids]) => ids)).not.toContain('plain');
+});
+
+it('loads batches concurrently, publishes completed batches, and only fetches new revisions', async () => {
+ let finishFirst!: (value: { messages: (typeof original)[] }) => void;
+ load.mockImplementationOnce(
+ () =>
+ new Promise((resolve) => {
+ finishFirst = resolve;
+ }),
+ );
+ load.mockResolvedValue({ messages: [{ ...original, messageId: 'message-9' }] });
+ const messages: TMessage[] = Array.from({ length: 51 }, (_, index) => ({
+ ...canonical,
+ messageId: `message-${index}`,
+ }));
+ const view = renderView(<View messages={messages} displayIndex={9} />);
+ await waitFor(() => expect(load).toHaveBeenCalledTimes(2));
+ expect(await screen.findByText(original.text)).toBeInTheDocument();
+ await act(async () => {
+ finishFirst({
+ messages: load.mock.calls[0][1].map((id: string) => ({ ...original, messageId: id })),
+ });
+ });
+ view.rerender(
+ <View messages={[...messages, { ...canonical, messageId: 'message-51' }]} displayIndex={9} />,
+ );
+ await waitFor(() => expect(load).toHaveBeenCalledTimes(3));
+ expect(load.mock.calls[2][1]).toEqual(['message-51']);
+ expect(screen.getByText(original.text)).toBeInTheDocument();
+});
+
+it('invalidates an already rendered original when the canonical message changes', async () => {
+ load.mockResolvedValue({ messages: [original] });
+ const view = renderView(<View />);
+ expect(await screen.findByText(original.text)).toBeInTheDocument();
+ view.rerender(<View messages={[{ ...canonical, text: 'edited canonical' }]} />);
+ expect(screen.queryByText(original.text)).not.toBeInTheDocument();
+ await waitFor(() =>
+ expect(screen.getByRole('status')).toHaveTextContent('com_ui_private_text_unavailable'),
+ );
+});
+
+it('clears originals when tenant identity changes even if the user ID is unchanged', async () => {
+ load.mockResolvedValueOnce({ messages: [original] });
+ const view = renderView(<View />);
+ expect(await screen.findByText(original.text)).toBeInTheDocument();
+ load.mockResolvedValue({ messages: [] });
+ mockTenantId = 'tenant-b';
+ view.rerender(<View />);
+ expect(screen.queryByText(original.text)).not.toBeInTheDocument();
+ await waitFor(() => expect(load).toHaveBeenCalledTimes(2));
+});
+
+it('deduplicates concurrent panes and keeps originals out of the application query cache', async () => {
+ let finish!: (value: { messages: (typeof original)[] }) => void;
+ load.mockReturnValue(
+ new Promise((resolve) => {
+ finish = resolve;
+ }),
+ );
+ const panes = renderView(
+ <>
+ <View />
+ <View />
+ </>,
+ );
+ await waitFor(() => expect(load).toHaveBeenCalledTimes(1));
+ await act(async () => finish({ messages: [original] }));
+ expect(await screen.findAllByText(original.text)).toHaveLength(2);
+ expect(
+ JSON.stringify(
+ applicationClient
+ .getQueryCache()
+ .getAll()
+ .map((query) => query.state.data),
+ ),
+ ).not.toContain(original.text);
+ panes.unmount();
+ await waitFor(() =>
+ expect(getOwnerQueryClient(applicationClient).getQueryCache().getAll()).toHaveLength(0),
+ );
+});
+
+it('bounds active requests to three batches and cancels queued work on unmount', async () => {
+ const finishers: Array<(value: { messages: [] }) => void> = [];
+ load.mockImplementation(() => new Promise((resolve) => finishers.push(resolve)));
+ const messages = Array.from({ length: 201 }, (_, index) => ({
+ ...canonical,
+ messageId: `bounded-${index}`,
+ }));
+ const view = renderView(<View messages={messages} />);
+ await waitFor(() => expect(load).toHaveBeenCalledTimes(3));
+ view.unmount();
+ await act(async () => finishers.forEach((finish) => finish({ messages: [] })));
+ expect(load).toHaveBeenCalledTimes(3);
+ await waitFor(() =>
+ expect(getOwnerQueryClient(applicationClient).getQueryCache().getAll()).toHaveLength(0),
+ );
+});
diff --git a/client/src/components/Chat/Messages/PrivateText.tsx b/client/src/components/Chat/Messages/PrivateText.tsx
new file mode 100644
index 0000000000..95e3fee300
--- /dev/null
+++ b/client/src/components/Chat/Messages/PrivateText.tsx
@@ -0,0 +1,116 @@
+import { createContext, lazy, Suspense, useContext } from 'react';
+import { QueryClientProvider, useQueryClient } from '@tanstack/react-query';
+import type { TMessage } from 'librechat-data-provider';
+import type { ReactNode } from 'react';
+import {
+ OwnerQueryContext,
+ getOwnerQueryClient,
+ useOwnerMessageTexts,
+} from '~/data-provider/Messages/private';
+import { useAuthContext } from '~/hooks/AuthContext';
+import { useLocalize } from '~/hooks';
+const DisplayMessage = lazy(async () => ({
+ default: (await import('./Content/MessageContent')).DisplayMessage,
+}));
+
+interface Original {
+ canonicalText: string;
+ revision: string;
+ text?: string;
+}
+interface OwnerTextState {
+ messages: ReadonlyMap<string, Original>;
+ loading: boolean;
+ retry?: () => void;
+}
+const empty: OwnerTextState = { messages: new Map(), loading: false };
+const OwnerTextContext = createContext<OwnerTextState>(empty);
+
+interface OwnerTextProviderProps {
+ messages: readonly TMessage[] | null;
+ conversationId?: string;
+ isSubmitting: boolean;
+ children: ReactNode;
+}
+
+export function OwnerTextProvider(props: OwnerTextProviderProps) {
+ const protectedMessage = props.messages?.findLast(
+ (message) => message.isCreatedByUser && message.privacyRevision && message.conversationId,
+ );
+ if (protectedMessage == null) {
+ return <>{props.children}</>;
+ }
+ const conversationId =
+ props.conversationId === 'new' &&
+ typeof protectedMessage.conversationId === 'string' &&
+ protectedMessage.conversationId !== 'new'
+ ? protectedMessage.conversationId
+ : props.conversationId;
+ return <OwnerQueries {...props} conversationId={conversationId} />;
+}
+
+function OwnerQueries(props: OwnerTextProviderProps) {
+ const applicationClient = useQueryClient();
+ return (
+ <QueryClientProvider
+ client={getOwnerQueryClient(applicationClient)}
+ context={OwnerQueryContext}
+ >
+ <ActiveOwnerTextProvider {...props} />
+ </QueryClientProvider>
+ );
+}
+
+function ActiveOwnerTextProvider({
+ messages,
+ conversationId,
+ isSubmitting,
+ children,
+}: OwnerTextProviderProps) {
+ const { user } = useAuthContext();
+ const state = useOwnerMessageTexts({
+ messages,
+ conversationId,
+ isSubmitting,
+ userId: user?.id,
+ tenantId: user?.tenantId,
+ });
+ return <OwnerTextContext.Provider value={state}>{children}</OwnerTextContext.Provider>;
+}
+
+/** No owner-view data is passed to edit, copy/export, retry, or prompt-building callbacks. */
+export function PrivateText({ message }: { message: TMessage }) {
+ const localize = useLocalize();
+ const state = useContext(OwnerTextContext);
+ const original = state.messages.get(message.messageId);
+ const text =
+ original != null &&
+ original.revision === message.privacyRevision &&
+ original.canonicalText === message.text
+ ? original.text
+ : undefined;
+ return (
+ <div>
+ <Suspense fallback={null}>
+ <DisplayMessage text={text ?? message.text} isCreatedByUser={true} message={message} />
+ </Suspense>
+ <p className="text-text-secondary mt-1 text-xs" role="status">
+ {localize('com_ui_private_text_hidden')}
+ {text == null && (
+ <span>
+ {' '}
+ ·{' '}
+ {localize(
+ state.loading ? 'com_ui_private_text_loading' : 'com_ui_private_text_unavailable',
+ )}
+ </span>
+ )}
+ </p>
+ {text == null && !state.loading && state.retry != null && (
+ <button type="button" onClick={state.retry} className="text-text-primary text-xs underline">
+ {localize('com_ui_private_text_retry')}
+ </button>
+ )}
+ </div>
+ );
+}
diff --git a/client/src/components/Chat/Messages/__tests__/MessagesView.spec.tsx b/client/src/components/Chat/Messages/__tests__/MessagesView.spec.tsx
index 370e1aac15..710dbecfbf 100644
--- a/client/src/components/Chat/Messages/__tests__/MessagesView.spec.tsx
+++ b/client/src/components/Chat/Messages/__tests__/MessagesView.spec.tsx
@@ -157,6 +157,18 @@ describe('MessagesView pending steers', () => {
expect(screen.getByTestId('pending-steers')).toHaveAttribute('data-conversation-id', 'convo-2');
});
+ it('pins the screenshot identity to the rendered transcript and replaces it on navigation', () => {
+ const view = render(<MessagesView messagesTree={messageTree} messages={messageTree} />);
+ const initialTarget = screen.getByTestId('screenshot-target');
+ expect(initialTarget).toHaveAttribute('data-conversation-id', 'convo-1');
+ const destinationTree = [{ ...messageTree[0], conversationId: 'convo-2' }];
+ view.rerender(<MessagesView messagesTree={destinationTree} messages={destinationTree} />);
+ const destinationTarget = screen.getByTestId('screenshot-target');
+ expect(destinationTarget).toHaveAttribute('data-conversation-id', 'convo-2');
+ expect(destinationTarget).not.toBe(initialTarget);
+ expect(initialTarget.isConnected).toBe(false);
+ });
+
it('keeps recovery visible while the message tree is temporarily empty', () => {
render(<MessagesView messagesTree={[]} messages={[]} />);
diff --git a/client/src/components/Chat/Messages/ui/MessageRender.tsx b/client/src/components/Chat/Messages/ui/MessageRender.tsx
index 35f98a2a5b..63f9dcf2ff 100644
--- a/client/src/components/Chat/Messages/ui/MessageRender.tsx
+++ b/client/src/components/Chat/Messages/ui/MessageRender.tsx
@@ -16,6 +16,7 @@ import { getHeaderHoverLabel } from '~/components/Chat/Messages/ui/HeaderLabel';
import MessageContent from '~/components/Chat/Messages/Content/MessageContent';
import { useLocalize, useMessageActions, useContentMetadata } from '~/hooks';
import SiblingSwitch from '~/components/Chat/Messages/SiblingSwitch';
+import { PrivateText } from '~/components/Chat/Messages/PrivateText';
import HoverButtons from '~/components/Chat/Messages/HoverButtons';
import MessageRow from '~/components/Chat/Messages/ui/MessageRow';
import MessageIcon from '~/components/Chat/Messages/MessageIcon';
@@ -158,6 +159,8 @@ const MessageRender = memo(function MessageRender({
return null;
}
+ const showOwnerText = !edit && msg.isCreatedByUser && Boolean(msg.privacyRevision);
+
return (
<MessageRow
id={msg.messageId}
@@ -225,24 +228,26 @@ const MessageRender = memo(function MessageRender({
}
>
<MessageContext.Provider value={messageContextValue}>
- {wakeupDisplay != null && !edit ? (
- <Wakeup display={wakeupDisplay} conversationId={conversation?.conversationId} />
- ) : (
- <MessageContent
- ask={ask}
- edit={edit}
- isLast={isLast}
- text={msg.text || ''}
- message={msg}
- enterEdit={enterEdit}
- error={!!(msg.error ?? false)}
- isSubmitting={isSubmitting}
- unfinished={msg.unfinished ?? false}
- isCreatedByUser={msg.isCreatedByUser ?? true}
- siblingIdx={siblingIdx ?? 0}
- setSiblingIdx={setSiblingIdx ?? (() => ({}))}
- />
- )}
+ {showOwnerText && <PrivateText message={msg} />}
+ {!showOwnerText &&
+ (wakeupDisplay != null && !edit ? (
+ <Wakeup display={wakeupDisplay} conversationId={conversation?.conversationId} />
+ ) : (
+ <MessageContent
+ ask={ask}
+ edit={edit}
+ isLast={isLast}
+ text={msg.text || ''}
+ message={msg}
+ enterEdit={enterEdit}
+ error={!!(msg.error ?? false)}
+ isSubmitting={isSubmitting}
+ unfinished={msg.unfinished ?? false}
+ isCreatedByUser={msg.isCreatedByUser ?? true}
+ siblingIdx={siblingIdx ?? 0}
+ setSiblingIdx={setSiblingIdx ?? (() => ({}))}
+ />
+ ))}
</MessageContext.Provider>
</MessageRow>
);
diff --git a/client/src/components/Messages/ContentRender.tsx b/client/src/components/Messages/ContentRender.tsx
index e02312457a..799a919899 100644
--- a/client/src/components/Messages/ContentRender.tsx
+++ b/client/src/components/Messages/ContentRender.tsx
@@ -19,6 +19,7 @@ import { ErrorSourceProvider } from '~/components/Messages/Content/Error/source'
import Elapsed, { shouldShowElapsed } from '~/components/Chat/Messages/Elapsed';
import { getHeaderHoverLabel } from '~/components/Chat/Messages/ui/HeaderLabel';
import ContentParts from '~/components/Chat/Messages/Content/ContentParts';
+import { PrivateText } from '~/components/Chat/Messages/PrivateText';
import SiblingSwitch from '~/components/Chat/Messages/SiblingSwitch';
import HoverButtons from '~/components/Chat/Messages/HoverButtons';
import MessageRow from '~/components/Chat/Messages/ui/MessageRow';
@@ -226,26 +227,30 @@ const ContentRender = memo(function ContentRender({
>
<AuthorContext.Provider value={author}>
<ErrorSourceProvider message={msg}>
- <ContentParts
- edit={edit}
- isLast={isLast}
- enterEdit={enterEdit}
- siblingIdx={siblingIdx}
- messageId={msg.messageId}
- attachments={attachments}
- searchResults={searchResults}
- manualSkills={msg.manualSkills}
- authorHeader={msg.isCreatedByUser === true ? undefined : RESUME_AUTHOR_HEADER}
- setSiblingIdx={setSiblingIdx}
- isLatestMessage={isLatestMessage}
- isSubmitting={isSubmitting}
- isCreatedByUser={msg.isCreatedByUser}
- createdAt={msg.createdAt ?? msg.clientTimestamp}
- foldLiveActivity={!autoExpandTools}
- showThinking={showThinking}
- conversationId={conversation?.conversationId}
- content={msg.content as Array<TMessageContentParts | undefined>}
- />
+ {!edit && msg.isCreatedByUser && msg.privacyRevision ? (
+ <PrivateText message={msg} />
+ ) : (
+ <ContentParts
+ edit={edit}
+ isLast={isLast}
+ enterEdit={enterEdit}
+ siblingIdx={siblingIdx}
+ messageId={msg.messageId}
+ attachments={attachments}
+ searchResults={searchResults}
+ manualSkills={msg.manualSkills}
+ authorHeader={msg.isCreatedByUser === true ? undefined : RESUME_AUTHOR_HEADER}
+ setSiblingIdx={setSiblingIdx}
+ isLatestMessage={isLatestMessage}
+ isSubmitting={isSubmitting}
+ isCreatedByUser={msg.isCreatedByUser}
+ createdAt={msg.createdAt ?? msg.clientTimestamp}
+ foldLiveActivity={!autoExpandTools}
+ showThinking={showThinking}
+ conversationId={conversation?.conversationId}
+ content={msg.content as Array<TMessageContentParts | undefined>}
+ />
+ )}
</ErrorSourceProvider>
</AuthorContext.Provider>
{/** A turn that ran out of agent steps is incomplete, not broken. Rendered
diff --git a/client/src/data-provider/Messages/private.ts b/client/src/data-provider/Messages/private.ts
new file mode 100644
index 0000000000..3f4f05e4d1
--- /dev/null
+++ b/client/src/data-provider/Messages/private.ts
@@ -0,0 +1,153 @@
+import { createContext, useEffect, useMemo } from 'react';
+import { QueryKeys, dataService } from 'librechat-data-provider';
+import { QueryClient, useQuery, useQueryClient } from '@tanstack/react-query';
+import type { TMessage } from 'librechat-data-provider';
+
+export const OwnerQueryContext = createContext<QueryClient | undefined>(undefined);
+const clients = new WeakMap<QueryClient, QueryClient>();
+
+/** Shared by panes, but excluded from ordinary caches, devtools and persistence. */
+export function getOwnerQueryClient(applicationClient: QueryClient): QueryClient {
+ let client = clients.get(applicationClient);
+ if (client == null) {
+ client = new QueryClient({
+ defaultOptions: { queries: { cacheTime: 0, retry: false, networkMode: 'always' } },
+ });
+ clients.set(applicationClient, client);
+ }
+ return client;
+}
+
+interface Original {
+ messageId: string;
+ canonicalText: string;
+ revision: string;
+ text: string;
+}
+interface OwnerTexts {
+ messages: Original[];
+ provisional: boolean;
+}
+
+export function useOwnerMessageTexts({
+ messages,
+ userId,
+ tenantId,
+ conversationId,
+ isSubmitting,
+}: {
+ messages: readonly TMessage[] | null;
+ userId?: string;
+ tenantId?: string;
+ conversationId?: string;
+ isSubmitting: boolean;
+}) {
+ const client = useQueryClient({ context: OwnerQueryContext });
+ const selected = useMemo(
+ () =>
+ (messages ?? [])
+ .filter(
+ (message) =>
+ message.isCreatedByUser &&
+ message.privacyRevision &&
+ typeof message.text === 'string' &&
+ message.conversationId === conversationId,
+ )
+ .map((message) => ({
+ messageId: message.messageId,
+ revision: message.privacyRevision!,
+ canonicalText: message.text,
+ }))
+ .sort((a, b) => a.messageId.localeCompare(b.messageId)),
+ [messages, conversationId],
+ );
+ const scope = [QueryKeys.ownerMessageTexts, userId, tenantId ?? '', conversationId];
+ const queryKey = [...scope, selected];
+ const query = useQuery<OwnerTexts>({
+ context: OwnerQueryContext,
+ queryKey,
+ enabled: Boolean(userId && conversationId && selected.length),
+ cacheTime: 0,
+ staleTime: Infinity,
+ retry: false,
+ refetchOnWindowFocus: false,
+ refetchOnReconnect: false,
+ queryFn: async ({ signal }) => {
+ const expected = new Map(selected.map((message) => [message.messageId, message]));
+ const originals = new Map<string, Original>();
+ // Reuse only validated rows still held by active queries in this exact owner scope.
+ for (const [, prior] of client.getQueriesData<OwnerTexts>(scope)) {
+ for (const message of prior?.messages ?? []) {
+ const match = expected.get(message.messageId);
+ if (
+ match?.revision === message.revision &&
+ match.canonicalText === message.canonicalText
+ ) {
+ originals.set(message.messageId, message);
+ }
+ }
+ }
+ const pending = selected.filter((message) => !originals.has(message.messageId));
+ const result = (): OwnerTexts => ({
+ messages: [...originals.values()],
+ provisional: isSubmitting && originals.size < selected.length,
+ });
+ const publish = () => {
+ if (!signal?.aborted) {
+ client.setQueryData(queryKey, result());
+ }
+ };
+ publish();
+ let next = 0;
+ let failed = false;
+ // Transport batches are bounded; React Query owns deduplication, cancellation and retry.
+ await Promise.all(
+ Array.from({ length: Math.min(3, Math.ceil(pending.length / 50)) }, async () => {
+ while (next < pending.length && !signal?.aborted) {
+ const batch = pending.slice(next, (next += 50));
+ try {
+ const response = await dataService.getOwnerMessageTexts(
+ conversationId!,
+ batch.map((message) => message.messageId),
+ );
+ if (signal?.aborted) {
+ return;
+ }
+ const batchIds = new Set(batch.map((message) => message.messageId));
+ for (const message of response.messages) {
+ const match = expected.get(message.messageId);
+ if (
+ batchIds.has(message.messageId) &&
+ match?.revision === message.revision &&
+ match.canonicalText === message.canonicalText &&
+ typeof message.text === 'string'
+ ) {
+ originals.set(message.messageId, { ...message, text: message.text });
+ }
+ }
+ publish();
+ } catch {
+ failed = true;
+ }
+ }
+ }),
+ );
+ if (failed) {
+ // Never retain HTTP payloads or upstream error text in a query error.
+ throw new Error('owner_text_unavailable');
+ }
+ return result();
+ },
+ });
+ const { data, isFetching, refetch } = query;
+ useEffect(() => {
+ if (!isSubmitting && data?.provisional && !isFetching) {
+ void refetch();
+ }
+ }, [isSubmitting, data?.provisional, isFetching, refetch]);
+ const originals = useMemo(
+ () => new Map((data?.messages ?? []).map((message) => [message.messageId, message])),
+ [data],
+ );
+ return { messages: originals, loading: isFetching, retry: () => void refetch() };
+}
diff --git a/client/src/hooks/Chat/useChatFunctions.ts b/client/src/hooks/Chat/useChatFunctions.ts
index f44e76cd8c..a60131535a 100644
--- a/client/src/hooks/Chat/useChatFunctions.ts
+++ b/client/src/hooks/Chat/useChatFunctions.ts
@@ -69,7 +69,14 @@ const STALE_SEND_REVALIDATION_MS = 5_000;
const logChatRequest = (request: Record<string, unknown>) => {
logger.log('=====================================\nAsk function called with:');
- logger.dir(request);
+ logger.dir({
+ conversationId: request.conversationId,
+ messageId: request.messageId,
+ parentMessageId: request.parentMessageId,
+ isEdited: request.isEdited,
+ isContinued: request.isContinued,
+ isRegenerate: request.isRegenerate,
+ });
logger.log('=====================================');
};
@@ -891,7 +898,14 @@ export default function useChatFunctions({
askInFlightRef.current = true;
setSubmissionStart(Date.now());
setSubmission(submission);
- logger.dir('message_stream', submission, { depth: null });
+ logger.dir('message_stream', {
+ conversationId,
+ messageId: currentMsg.messageId,
+ parentMessageId: currentMsg.parentMessageId,
+ isEdited: isEditOrContinue,
+ isRegenerate: regenerateShaped,
+ isContinued,
+ });
};
const regenerate = (
diff --git a/client/src/hooks/Conversations/__tests__/screenshot.spec.tsx b/client/src/hooks/Conversations/__tests__/screenshot.spec.tsx
new file mode 100644
index 0000000000..3a287d9244
--- /dev/null
+++ b/client/src/hooks/Conversations/__tests__/screenshot.spec.tsx
@@ -0,0 +1,238 @@
+import { Provider } from 'jotai';
+import download from 'downloadjs';
+import { toCanvas } from 'html-to-image';
+import { QueryKeys } from 'librechat-data-provider';
+import { act, renderHook } from '@testing-library/react';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { MemoryRouter, Route, Routes, useNavigate, useParams } from 'react-router-dom';
+import type { TMessage, TConversation } from 'librechat-data-provider';
+import type { ReactNode } from 'react';
+import { completeProgressiveRowMounts } from '~/hooks/Messages/useProgressiveRowMount';
+import { ScreenshotProvider, useScreenshot } from '~/hooks/ScreenshotContext';
+import useExportConversation from '../useExportConversation';
+
+const mockShowToast = jest.fn();
+jest.mock('@librechat/client', () => ({
+ ...jest.requireActual('@librechat/client'),
+ useToastContext: () => ({ showToast: mockShowToast }),
+}));
+jest.mock('~/hooks', () => ({ useLocalize: () => (key: string) => key }));
+jest.mock('downloadjs', () => jest.fn());
+jest.mock('html-to-image', () => ({ toCanvas: jest.fn() }));
+jest.mock('~/hooks/Messages/useProgressiveRowMount', () => ({
+ completeProgressiveRowMounts: jest.fn(),
+}));
+
+const sourceId = '11111111-1111-4111-8111-111111111111';
+const destinationId = '22222222-2222-4222-8222-222222222222';
+const clean = {
+ conversationId: sourceId,
+ messageId: 'safe',
+ text: 'Safe text',
+ isCreatedByUser: true,
+ createdAt: '2026-10-02T11:00:00',
+} as TMessage;
+
+function Target() {
+ const { conversationId } = useParams();
+ const { screenshotTargetRef } = useScreenshot();
+ return (
+ <div key={conversationId} ref={screenshotTargetRef} data-conversation-id={conversationId} />
+ );
+}
+function setup() {
+ const client = new QueryClient();
+ client.setQueryData([QueryKeys.messages, sourceId], [clean]);
+ client.setQueryData(
+ [QueryKeys.messages, destinationId],
+ [{ ...clean, conversationId: destinationId, privacyRevision: 'protected' }],
+ );
+ const hook = renderHook(
+ () => {
+ const { conversationId } = useParams();
+ const navigate = useNavigate();
+ const { exportConversation } = useExportConversation({
+ conversation: { conversationId } as TConversation,
+ filename: 'screenshot',
+ type: 'screenshot',
+ includeOptions: false,
+ exportBranches: false,
+ recursive: false,
+ });
+ return { navigate, exportConversation };
+ },
+ {
+ wrapper: ({ children }: { children: ReactNode }) => (
+ <MemoryRouter initialEntries={[`/c/${sourceId}`]}>
+ <QueryClientProvider client={client}>
+ <Provider>
+ <ScreenshotProvider>
+ <Routes>
+ <Route
+ path="/c/:conversationId"
+ element={
+ <>
+ <Target />
+ {children}
+ </>
+ }
+ />
+ </Routes>
+ </ScreenshotProvider>
+ </Provider>
+ </QueryClientProvider>
+ </MemoryRouter>
+ ),
+ },
+ );
+ const target = document.querySelector<HTMLDivElement>('[data-conversation-id]')!;
+ Object.defineProperties(target, {
+ scrollWidth: { value: 100 },
+ scrollHeight: { value: 100 },
+ });
+ return { ...hook, client, target };
+}
+function canvas() {
+ const element = document.createElement('canvas');
+ jest.spyOn(element, 'toBlob').mockImplementation((callback) => {
+ callback(new Blob(['image'], { type: 'image/png' }));
+ });
+ return element;
+}
+beforeEach(() => {
+ jest.mocked(completeProgressiveRowMounts).mockResolvedValue(undefined);
+ jest.mocked(toCanvas).mockResolvedValue(canvas());
+});
+
+it('downloads an unchanged unprotected capture', async () => {
+ const { result, target } = setup();
+ await act(async () => {
+ await result.current.exportConversation();
+ });
+ expect(toCanvas).toHaveBeenCalledWith(target, expect.anything());
+ expect(download).toHaveBeenCalledTimes(1);
+});
+
+it('rejects navigation to a protected transcript during progressive mounting', async () => {
+ let finish!: () => void;
+ jest.mocked(completeProgressiveRowMounts).mockReturnValueOnce(
+ new Promise((resolve) => {
+ finish = resolve;
+ }),
+ );
+ const { result, target } = setup();
+ const exporting = result.current.exportConversation();
+ act(() => result.current.navigate(`/c/${destinationId}`));
+ const destination = document.querySelector<HTMLDivElement>('[data-conversation-id]')!;
+ Object.defineProperties(destination, {
+ scrollWidth: { value: 100 },
+ scrollHeight: { value: 100 },
+ });
+ expect(target.isConnected).toBe(false);
+ await act(async () => {
+ finish();
+ await exporting;
+ });
+ expect(toCanvas).not.toHaveBeenCalled();
+ expect(download).not.toHaveBeenCalled();
+ expect(mockShowToast).toHaveBeenCalled();
+});
+
+it('discards a capture when the target changes during image cloning', async () => {
+ let finish!: (result: HTMLCanvasElement) => void;
+ jest.mocked(toCanvas).mockReturnValueOnce(
+ new Promise((resolve) => {
+ finish = resolve;
+ }),
+ );
+ const { result } = setup();
+ const exporting = result.current.exportConversation();
+ await act(async () => {
+ await Promise.resolve();
+ });
+ expect(toCanvas).toHaveBeenCalledTimes(1);
+ act(() => result.current.navigate(`/c/${destinationId}`));
+ await act(async () => {
+ finish(canvas());
+ await exporting;
+ });
+ expect(download).not.toHaveBeenCalled();
+});
+
+it('checks newly protected text after progressive mounting and before cloning', async () => {
+ let finish!: () => void;
+ jest.mocked(completeProgressiveRowMounts).mockReturnValueOnce(
+ new Promise((resolve) => {
+ finish = resolve;
+ }),
+ );
+ const { result, client } = setup();
+ const exporting = result.current.exportConversation();
+ act(() =>
+ client.setQueryData(
+ [QueryKeys.messages, sourceId],
+ [{ ...clean, privacyRevision: 'protected' }],
+ ),
+ );
+ await act(async () => {
+ finish();
+ await exporting;
+ });
+ expect(toCanvas).not.toHaveBeenCalled();
+ expect(download).not.toHaveBeenCalled();
+ expect(mockShowToast).toHaveBeenCalledWith(
+ expect.objectContaining({
+ message: 'com_nav_export_screenshot_private_text',
+ }),
+ );
+});
+
+it('refuses a target whose rendered conversation differs from the export scope', async () => {
+ const { result, target } = setup();
+ target.dataset.conversationId = destinationId;
+ await act(async () => {
+ await result.current.exportConversation();
+ });
+ expect(toCanvas).not.toHaveBeenCalled();
+ expect(download).not.toHaveBeenCalled();
+});
+
+it('refuses a reused DOM node when its transcript identity changes during mounting', async () => {
+ let finish!: () => void;
+ jest.mocked(completeProgressiveRowMounts).mockReturnValueOnce(
+ new Promise((resolve) => {
+ finish = resolve;
+ }),
+ );
+ const { result, target } = setup();
+ const exporting = result.current.exportConversation();
+ target.dataset.conversationId = destinationId;
+ await act(async () => {
+ finish();
+ await exporting;
+ });
+ expect(toCanvas).not.toHaveBeenCalled();
+ expect(download).not.toHaveBeenCalled();
+});
+
+it('does not revive a cancelled capture after navigating away and back', async () => {
+ let finish!: (result: HTMLCanvasElement) => void;
+ jest.mocked(toCanvas).mockReturnValueOnce(
+ new Promise((resolve) => {
+ finish = resolve;
+ }),
+ );
+ const { result, target } = setup();
+ const exporting = result.current.exportConversation();
+ await act(async () => {
+ await Promise.resolve();
+ });
+ act(() => result.current.navigate(`/c/${destinationId}`));
+ act(() => result.current.navigate(`/c/${sourceId}`));
+ expect(document.querySelector('[data-conversation-id]')).not.toBe(target);
+ await act(async () => {
+ finish(canvas());
+ await exporting;
+ });
+ expect(download).not.toHaveBeenCalled();
+});
diff --git a/client/src/hooks/Conversations/__tests__/useExportConversation.spec.tsx b/client/src/hooks/Conversations/__tests__/useExportConversation.spec.tsx
new file mode 100644
index 0000000000..715739472c
--- /dev/null
+++ b/client/src/hooks/Conversations/__tests__/useExportConversation.spec.tsx
@@ -0,0 +1,186 @@
+import { Provider } from 'jotai';
+import download from 'downloadjs';
+import exportFromJSON from 'export-from-json';
+import { act, renderHook } from '@testing-library/react';
+import { MemoryRouter, Route, Routes } from 'react-router-dom';
+import { Constants, QueryKeys } from 'librechat-data-provider';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import type { TConversation, TMessage } from 'librechat-data-provider';
+import type { ReactNode } from 'react';
+import useExportConversation from '../useExportConversation';
+
+const mockGetMessages = jest.fn();
+const mockShowToast = jest.fn();
+const mockCaptureScreenshot = jest.fn();
+const mockScreenshotRef = { current: document.createElement('div') };
+
+jest.mock('librechat-data-provider', () => {
+ const actual = jest.requireActual('librechat-data-provider');
+ return {
+ ...actual,
+ dataService: {
+ ...actual.dataService,
+ getMessagesByConvoId: (...args: unknown[]) => mockGetMessages(...args),
+ },
+ };
+});
+jest.mock('@librechat/client', () => ({
+ ...jest.requireActual('@librechat/client'),
+ useToastContext: () => ({ showToast: mockShowToast }),
+}));
+jest.mock('~/hooks', () => ({ useLocalize: () => (key: string) => key }));
+jest.mock('~/hooks/ScreenshotContext', () => ({
+ useScreenshot: () => ({
+ captureScreenshot: mockCaptureScreenshot,
+ screenshotTargetRef: mockScreenshotRef,
+ }),
+ ScreenshotLimitError: class ScreenshotLimitError extends Error {},
+ ScreenshotTargetError: class ScreenshotTargetError extends Error {},
+}));
+jest.mock('downloadjs', () => jest.fn());
+jest.mock('export-from-json', () =>
+ Object.assign(jest.fn(), { types: { csv: 'csv', txt: 'txt' } }),
+);
+
+const conversationId = '11111111-1111-4111-8111-111111111111';
+const conversation = { conversationId, title: 'Protected chat' } as TConversation;
+const submitted = {
+ conversationId,
+ messageId: 'user-1',
+ parentMessageId: Constants.NO_PARENT,
+ isCreatedByUser: true,
+ clientTimestamp: '2026-09-28T15:00:00',
+ text: 'Email [email protected]',
+} as TMessage;
+const canonical = {
+ ...submitted,
+ text: 'Email [EMAIL_1_revision]',
+ privacyRevision: 'revision',
+} as TMessage;
+
+function setup(type: string, pending: TMessage[] = [submitted]) {
+ const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+ queryClient.setQueryData([QueryKeys.messages, conversationId], pending);
+ const hook = renderHook(
+ () =>
+ useExportConversation({
+ conversation,
+ filename: 'protected',
+ type,
+ includeOptions: false,
+ exportBranches: false,
+ recursive: false,
+ }),
+ {
+ wrapper: function Wrapper({ children }: { children: ReactNode }) {
+ return (
+ <MemoryRouter initialEntries={[`/c/${conversationId}`]}>
+ <QueryClientProvider client={queryClient}>
+ <Provider>
+ <Routes>
+ <Route path="/c/:conversationId" element={children} />
+ </Routes>
+ </Provider>
+ </QueryClientProvider>
+ </MemoryRouter>
+ );
+ },
+ },
+ );
+ return { ...hook, queryClient };
+}
+
+async function readBlob(blob: Blob): Promise<string> {
+ return new Promise((resolve, reject) => {
+ const reader = new FileReader();
+ reader.onload = () => resolve(String(reader.result));
+ reader.onerror = () => reject(reader.error);
+ reader.readAsText(blob);
+ });
+}
+
+beforeEach(() => {
+ jest.clearAllMocks();
+ mockScreenshotRef.current.dataset.conversationId = conversationId;
+ document.body.append(mockScreenshotRef.current);
+});
+
+it('exports acknowledged canonical text rather than a pending private cache value', async () => {
+ mockGetMessages.mockResolvedValueOnce([canonical]);
+ const { result } = setup('json');
+ await act(async () => {
+ await result.current.exportConversation();
+ });
+ expect(mockGetMessages).toHaveBeenCalledWith(conversationId);
+ const saved = (download as jest.Mock).mock.calls[0]?.[0] as Blob;
+ expect(saved).toBeInstanceOf(Blob);
+ const fileText = await readBlob(saved);
+ expect(fileText).toContain(canonical.text);
+ expect(fileText).not.toContain('[email protected]');
+ expect(mockShowToast).not.toHaveBeenCalled();
+});
+
+it.each(['csv', 'markdown', 'text'])(
+ 'uses the canonical server response for %s exports',
+ async (type) => {
+ mockGetMessages.mockResolvedValueOnce([canonical]);
+ const { result } = setup(type);
+ await act(async () => {
+ await result.current.exportConversation();
+ });
+ expect(mockGetMessages).toHaveBeenCalledWith(conversationId);
+ expect(exportFromJSON).toHaveBeenCalledTimes(1);
+ const payload = JSON.stringify(jest.mocked(exportFromJSON).mock.calls[0][0]);
+ expect(payload).toContain(canonical.text);
+ expect(payload).not.toContain('[email protected]');
+ },
+);
+
+it('does not fall back to the unfiltered cache when the canonical read fails', async () => {
+ mockGetMessages.mockRejectedValueOnce(new Error('Temporary outage'));
+ const { result } = setup('json');
+ await act(async () => {
+ await result.current.exportConversation();
+ });
+ expect(download).not.toHaveBeenCalled();
+ expect(mockShowToast).toHaveBeenCalledWith(
+ expect.objectContaining({ message: 'com_nav_export_unavailable' }),
+ );
+});
+
+it('does not download a screenshot when a protected row arrives during capture', async () => {
+ const clean = { ...canonical, privacyRevision: undefined, createdAt: '2026-09-28T15:00:01' };
+ let finish!: (result: Blob) => void;
+ mockCaptureScreenshot.mockReturnValueOnce(
+ new Promise<Blob>((resolve) => {
+ finish = resolve;
+ }),
+ );
+ const { result, queryClient } = setup('screenshot', [clean]);
+ const exportAction = result.current.exportConversation();
+ expect(mockCaptureScreenshot).toHaveBeenCalledTimes(1);
+ act(() => queryClient.setQueryData([QueryKeys.messages, conversationId], [canonical]));
+ finish(new Blob(['captured original'], { type: 'image/png' }));
+ await act(async () => {
+ await exportAction;
+ });
+ expect(download).not.toHaveBeenCalled();
+ expect(mockShowToast).toHaveBeenCalledWith(
+ expect.objectContaining({ message: 'com_nav_export_screenshot_private_text' }),
+ );
+});
+
+it.each([
+ { kind: 'unsent', message: submitted },
+ { kind: 'protected', message: canonical },
+])('does not screenshot $kind text', async ({ message }) => {
+ const { result } = setup('screenshot', [message]);
+ await act(async () => {
+ await result.current.exportConversation();
+ });
+ expect(mockCaptureScreenshot).not.toHaveBeenCalled();
+ expect(download).not.toHaveBeenCalled();
+ expect(mockShowToast).toHaveBeenCalledWith(
+ expect.objectContaining({ message: 'com_nav_export_screenshot_private_text' }),
+ );
+});
diff --git a/client/src/hooks/Conversations/useExportConversation.ts b/client/src/hooks/Conversations/useExportConversation.ts
index 2ea3d31a16..5fa8986ee3 100644
--- a/client/src/hooks/Conversations/useExportConversation.ts
+++ b/client/src/hooks/Conversations/useExportConversation.ts
@@ -4,10 +4,15 @@ import { useParams } from 'react-router-dom';
import exportFromJSON from 'export-from-json';
import { useToastContext } from '@librechat/client';
import { useQueryClient } from '@tanstack/react-query';
-import { buildTree, QueryKeys } from 'librechat-data-provider';
+import { buildTree, Constants, dataService, QueryKeys } from 'librechat-data-provider';
import type { TConversation, TMessage, TPreset } from 'librechat-data-provider';
-import { ScreenshotLimitError, useScreenshot } from '~/hooks/ScreenshotContext';
+import {
+ ScreenshotLimitError,
+ ScreenshotTargetError,
+ useScreenshot,
+} from '~/hooks/ScreenshotContext';
import useBuildMessageTree from '~/hooks/Messages/useBuildMessageTree';
+import { isUnacknowledgedUserMessage } from '~/utils/messages';
import { NotificationSeverity } from '~/common';
import { formatMessageText } from './format';
import { cleanupPreset } from '~/utils';
@@ -36,26 +41,77 @@ export default function useExportConversation({
}) {
const queryClient = useQueryClient();
const { showToast } = useToastContext();
- const { captureScreenshot } = useScreenshot();
+ const { captureScreenshot, screenshotTargetRef } = useScreenshot();
const buildMessageTree = useBuildMessageTree();
const localize = useLocalize();
const { conversationId: paramId } = useParams();
- const getMessageTree = useCallback(() => {
- const queryParam =
- paramId === 'new' ? paramId : (conversation?.conversationId ?? paramId ?? '');
- const messages = queryClient.getQueryData<TMessage[]>([QueryKeys.messages, queryParam]) ?? [];
+ const screenshotConversationId =
+ paramId === 'new' ? paramId : (conversation?.conversationId ?? paramId ?? '');
+ const getCachedMessages = useCallback(() => {
+ return (
+ queryClient.getQueryData<TMessage[]>([QueryKeys.messages, screenshotConversationId]) ?? []
+ );
+ }, [screenshotConversationId, queryClient]);
+
+ const getMessageTree = useCallback(async () => {
+ const conversationId = conversation?.conversationId;
+ if (
+ !conversationId ||
+ conversationId === Constants.NEW_CONVO ||
+ conversationId === Constants.PENDING_CONVO ||
+ conversationId === Constants.SEARCH
+ ) {
+ throw new Error('Conversation is unavailable for export');
+ }
+ const messages = await dataService.getMessagesByConvoId(conversationId);
const dataTree = buildTree({ messages });
return dataTree?.length === 0 ? null : (dataTree ?? null);
- }, [paramId, conversation?.conversationId, queryClient]);
+ }, [conversation?.conversationId]);
+
+ const screenshotWouldExposePrivateText = () =>
+ getCachedMessages().some(
+ (message) => message.privacyRevision != null || isUnacknowledgedUserMessage(message),
+ );
+
+ const refuseUnsafeScreenshot = () => {
+ if (!screenshotWouldExposePrivateText()) {
+ return false;
+ }
+ showToast({
+ message: localize('com_nav_export_screenshot_private_text'),
+ severity: NotificationSeverity.ERROR,
+ showIcon: true,
+ });
+ return true;
+ };
const exportScreenshot = async () => {
+ if (refuseUnsafeScreenshot()) {
+ return;
+ }
+ const target = screenshotTargetRef?.current;
let data: Blob;
try {
- data = await captureScreenshot();
+ data = await captureScreenshot(
+ (node) =>
+ node === target &&
+ node.dataset.conversationId === screenshotConversationId &&
+ !screenshotWouldExposePrivateText(),
+ );
+ if (
+ !target?.isConnected ||
+ screenshotTargetRef?.current !== target ||
+ target.dataset.conversationId !== screenshotConversationId
+ ) {
+ throw new ScreenshotTargetError();
+ }
} catch (err) {
- console.error('Failed to capture screenshot', err);
+ if (refuseUnsafeScreenshot()) {
+ return;
+ }
+ console.error('Failed to capture screenshot');
showToast({
message: localize(
err instanceof ScreenshotLimitError
@@ -67,6 +123,9 @@ export default function useExportConversation({
});
return;
}
+ if (refuseUnsafeScreenshot()) {
+ return;
+ }
download(data, `${filename}.png`, 'image/png');
};
@@ -76,7 +135,7 @@ export default function useExportConversation({
const messages = await buildMessageTree({
messageId: conversation?.conversationId,
message: null,
- messages: getMessageTree(),
+ messages: await getMessageTree(),
branches: Boolean(exportBranches),
recursive: false,
});
@@ -154,7 +213,7 @@ export default function useExportConversation({
const messages = await buildMessageTree({
messageId: conversation?.conversationId,
message: null,
- messages: getMessageTree(),
+ messages: await getMessageTree(),
branches: false,
recursive: false,
});
@@ -210,7 +269,7 @@ export default function useExportConversation({
const messages = await buildMessageTree({
messageId: conversation?.conversationId,
message: null,
- messages: getMessageTree(),
+ messages: await getMessageTree(),
branches: false,
recursive: false,
});
@@ -262,7 +321,7 @@ export default function useExportConversation({
const messages = await buildMessageTree({
messageId: conversation?.conversationId,
message: null,
- messages: getMessageTree(),
+ messages: await getMessageTree(),
branches: Boolean(exportBranches),
recursive: Boolean(recursive),
});
@@ -279,17 +338,25 @@ export default function useExportConversation({
download(blob, `${filename}.json`, 'application/json');
};
- const exportConversation = () => {
- if (type === 'json') {
- exportJSON();
- } else if (type == 'text') {
- exportText();
- } else if (type == 'markdown') {
- exportMarkdown();
- } else if (type == 'csv') {
- exportCSV();
- } else if (type == 'screenshot') {
- exportScreenshot();
+ const exportConversation = async () => {
+ try {
+ if (type === 'json') {
+ await exportJSON();
+ } else if (type == 'text') {
+ await exportText();
+ } else if (type == 'markdown') {
+ await exportMarkdown();
+ } else if (type == 'csv') {
+ await exportCSV();
+ } else if (type == 'screenshot') {
+ await exportScreenshot();
+ }
+ } catch {
+ showToast({
+ message: localize('com_nav_export_unavailable'),
+ severity: NotificationSeverity.ERROR,
+ showIcon: true,
+ });
}
};
diff --git a/client/src/hooks/ScreenshotContext.tsx b/client/src/hooks/ScreenshotContext.tsx
index e99c177a5c..6a0ddc43d6 100644
--- a/client/src/hooks/ScreenshotContext.tsx
+++ b/client/src/hooks/ScreenshotContext.tsx
@@ -23,6 +23,13 @@ export class ScreenshotLimitError extends Error {
}
}
+export class ScreenshotTargetError extends Error {
+ constructor() {
+ super('Screenshot target changed or is unavailable.');
+ this.name = 'ScreenshotTargetError';
+ }
+}
+
const ScreenshotContext = createContext<ScreenshotContextType>({});
export const useScreenshot = () => {
@@ -78,17 +85,33 @@ export const useScreenshot = () => {
return blob;
};
- const captureScreenshot = async (): Promise<Blob> => {
+ const captureScreenshot = async (canCapture?: (node: HTMLElement) => boolean): Promise<Blob> => {
if (ref instanceof Function) {
throw new Error('Ref callback is not supported.');
}
- /** A capture taken while a long thread is still progressively mounting
- * would clone a truncated DOM; force the remaining rows in first. */
- await completeProgressiveRowMounts();
- if (ref?.current) {
- return takeScreenShot(ref.current);
+ const node = ref?.current;
+ if (!node) {
+ throw new ScreenshotTargetError();
}
- throw new Error('Ref is not attached to any element.');
+ const conversationId = node.dataset.conversationId;
+ const assertTarget = () => {
+ if (
+ !conversationId ||
+ !node.isConnected ||
+ ref?.current !== node ||
+ node.dataset.conversationId !== conversationId ||
+ canCapture?.(node) === false
+ ) {
+ throw new ScreenshotTargetError();
+ }
+ };
+ assertTarget();
+ /** Pin the transcript before mounting or cloning can yield to navigation. */
+ await completeProgressiveRowMounts();
+ assertTarget();
+ const image = await takeScreenShot(node);
+ assertTarget();
+ return image;
};
return { screenshotTargetRef: ref, captureScreenshot };
diff --git a/client/src/locales/en/translation.json b/client/src/locales/en/translation.json
index f961fa280e..db1c9239db 100644
--- a/client/src/locales/en/translation.json
+++ b/client/src/locales/en/translation.json
@@ -1,4 +1,8 @@
{
+ "com_ui_private_text_hidden": "Private details hidden from the model",
+ "com_ui_private_text_loading": "Loading your original message…",
+ "com_ui_private_text_retry": "Retry loading original",
+ "com_ui_private_text_unavailable": "Original unavailable. Showing the filtered message.",
"com_ui_attachments": "Attachments",
"com_ui_no_schedules_match": "No schedules match your search",
"com_ui_background_tasks": "Background tasks",
@@ -769,8 +773,10 @@
"com_nav_export_recursive": "Recursive",
"com_nav_export_recursive_or_sequential": "Recursive or sequential?",
"com_nav_export_screenshot_error": "Couldn't capture the screenshot. Try a different export type.",
+ "com_nav_export_screenshot_private_text": "Screenshots can't be exported while a chat contains protected or unsent text. Export as text or JSON instead.",
"com_nav_export_screenshot_too_large": "This conversation is too large to export as a screenshot. Try a different export type.",
"com_nav_export_type": "Type",
+ "com_nav_export_unavailable": "Couldn't load this conversation for export. Try again.",
"com_nav_external": "External",
"com_nav_font_size": "Message Font Size",
"com_nav_font_size_base": "Medium",
diff --git a/client/src/utils/messages.spec.ts b/client/src/utils/messages.spec.ts
index b06f3e5a48..33f17b5d38 100644
--- a/client/src/utils/messages.spec.ts
+++ b/client/src/utils/messages.spec.ts
@@ -1,6 +1,10 @@
import { ContentTypes } from 'librechat-data-provider';
import type { TMessage, TMessageContentParts } from 'librechat-data-provider';
-import { preserveStreamedContentIdentity, stripStreamedIndexStamps } from './messages';
+import {
+ preserveStreamedContentIdentity,
+ isUnacknowledgedUserMessage,
+ stripStreamedIndexStamps,
+} from './messages';
const text = (value: string, extra: Record<string, unknown> = {}): TMessageContentParts =>
({ type: ContentTypes.TEXT, text: value, ...extra }) as TMessageContentParts;
@@ -20,6 +24,34 @@ const label = (value: string, extra: Record<string, unknown> = {}): TMessageCont
const streamedIndexes = (content: TMessage['content']): Array<number | undefined> =>
(content ?? []).map((part) => part?.streamedIndex);
+describe('private screenshot admission', () => {
+ it('identifies unsent user text without classifying acknowledged messages as pending', () => {
+ const optimistic = {
+ messageId: 'pending',
+ isCreatedByUser: true,
+ clientTimestamp: '2026-09-28T15:00:00',
+ } as TMessage;
+ const assistant = {
+ messageId: 'previous-answer',
+ isCreatedByUser: false,
+ text: 'Safe',
+ } as TMessage;
+ const canonical = {
+ ...optimistic,
+ privacyRevision: 'accepted-revision',
+ text: '[EMAIL_1_accepted-revision]',
+ };
+ const persisted = { ...optimistic, createdAt: '2026-09-28T15:00:01' };
+
+ expect(isUnacknowledgedUserMessage(optimistic)).toBe(true);
+ expect(isUnacknowledgedUserMessage(canonical)).toBe(false);
+ expect(isUnacknowledgedUserMessage(persisted)).toBe(false);
+ expect(isUnacknowledgedUserMessage(assistant)).toBe(false);
+ expect(optimistic.text).toBe('[email protected]');
+ });
+});
+
describe('preserveStreamedContentIdentity', () => {
it('stamps every part shifted by compacted holes with its streamed index', () => {
const streamed = [
diff --git a/client/src/utils/messages.ts b/client/src/utils/messages.ts
index 1547e986db..b244a45197 100644
--- a/client/src/utils/messages.ts
+++ b/client/src/utils/messages.ts
@@ -21,6 +21,16 @@ import type { LocalizeFunction, TMessageProps } from '~/common';
export const TEXT_KEY_DIVIDER = '|||';
export const STREAM_START_FAILED_METADATA_KEY = 'streamStartFailed';
+/** A locally submitted user row is not canonical until the server acknowledges it. */
+export function isUnacknowledgedUserMessage(message: TMessage): boolean {
+ return (
+ message.isCreatedByUser === true &&
+ message.clientTimestamp != null &&
+ message.createdAt == null &&
+ !message.privacyRevision
+ );
+}
+
type SiblingIndexLookup = (parentMessageId: string | null | undefined) => number;
export type BranchSiblingIndex = {
@@ -886,6 +896,7 @@ export function areMessageFieldsEqual(
return (
prevMsg.messageId === nextMsg.messageId &&
prevMsg.text === nextMsg.text &&
+ prevMsg.privacyRevision === nextMsg.privacyRevision &&
prevMsg.error === nextMsg.error &&
prevMsg.unfinished === nextMsg.unfinished &&
/** Read by the row: `useGenerationsByLatest` gates the Continue button on it and
diff --git a/e2e/setup/fake-model.js b/e2e/setup/fake-model.js
index 3c41b6bf39..e0743d68ae 100644
--- a/e2e/setup/fake-model.js
+++ b/e2e/setup/fake-model.js
@@ -3392,6 +3392,22 @@ function resolveResponses({ graph, messages, text, toolNames }) {
return askUserQuestionResponses(askUserQuestionLabel, toolNames);
}
+ if (text.includes('E2E_PRIVATE_TEXT:')) {
+ return {
+ responses: [MOCK_REPLY],
+ resolveOnStream: (streamMessages) => {
+ const prompt = JSON.stringify(streamMessages);
+ const protectedText =
+ !prompt.includes('[email protected]') && /EMAIL_1_[a-f0-9]{32}/.test(prompt);
+ return {
+ responses: [
+ protectedText ? 'E2E private model input verified' : 'E2E private model input failed',
+ ],
+ };
+ },
+ };
+ }
+
if (text.includes(ASSERT_PROJECT_CONTEXT_MARKER)) {
return {
responses: [MOCK_REPLY],
diff --git a/e2e/specs/mock/private-text.spec.ts b/e2e/specs/mock/private-text.spec.ts
new file mode 100644
index 0000000000..93ebe49382
--- /dev/null
+++ b/e2e/specs/mock/private-text.spec.ts
@@ -0,0 +1,490 @@
+import { readFile } from 'node:fs/promises';
+import { expect, test } from '@playwright/test';
+import type { TMessage } from 'librechat-data-provider';
+import { withMongo } from './db';
+import {
+ loginAdmin,
+ setRuntimeFilters,
+ restoreRuntimeFilters,
+ requestResult,
+} from './content-filters.helpers';
+import {
+ MOCK_ENDPOINTS,
+ selectMockEndpoint,
+ sendMessage,
+ sendMessageAndWaitForCompletion,
+ messagesView,
+ fetchJson,
+} from './helpers';
+
+const original = 'E2E_PRIVATE_TEXT: [email protected]';
+
+test('owner sees original after reload while provider, sharing, and canonical reads stay filtered', async ({
+ page,
+ request,
+}, testInfo) => {
+ test.setTimeout(120000);
+ const token = await loginAdmin(request);
+ await setRuntimeFilters(request, token, {
+ messages: {
+ pii: {
+ action: 'redact',
+ fields: ['text'],
+ starterPatterns: [],
+ customPatterns: [
+ { id: 'email', label: 'Email', regex: 'alice@example\\.com', category: 'email' },
+ { id: 'hex', label: 'Credential', regex: '[a-f0-9]{32}', category: 'credential' },
+ ],
+ },
+ },
+ });
+ let conversationId: string | undefined;
+ try {
+ await page.goto('/c/new');
+ await selectMockEndpoint(page, MOCK_ENDPOINTS[0]);
+ const response = await sendMessageAndWaitForCompletion(page, original);
+ conversationId = (await response.json()).conversationId as string;
+ expect(conversationId).toBeTruthy();
+ await expect(
+ messagesView(page).getByText('E2E private model input verified', { exact: true }),
+ ).toBeVisible();
+ const ownerText = messagesView(page).getByText(original, { exact: true });
+ await expect(ownerText).toBeVisible();
+ const standardContainer = ownerText.locator(
+ 'xpath=ancestor::div[contains(@class,"text-message")][1]',
+ );
+ await expect(standardContainer).toHaveAttribute('dir', 'auto');
+ await expect(
+ messagesView(page).getByText('Private details hidden from the model', { exact: true }),
+ ).toBeVisible();
+
+ const replay = await requestResult(request, {
+ path: new URL(response.url()).pathname,
+ token,
+ method: 'POST',
+ data: response.request().postDataJSON(),
+ });
+ expect(replay.ok).toBe(true);
+ expect((replay.body as { conversationId: string }).conversationId).toBe(conversationId);
+
+ const canonical = await fetchJson<TMessage[]>(page, `/api/messages/${conversationId}`, token);
+ expect(JSON.stringify(canonical)).not.toContain('[email protected]');
+ expect(JSON.stringify(canonical)).not.toContain('privateText');
+ const user = canonical.find((message) => message.isCreatedByUser)!;
+ expect(user.text).toMatch(/\[EMAIL_1_[a-f0-9]{32}\]/);
+ await withMongo(async (db) => {
+ const row = await db
+ .collection('messages')
+ .findOne({ conversationId, messageId: user.messageId });
+ expect(row?.privateText).toMatch(/^v1:/);
+ expect(JSON.stringify(row)).not.toContain('[email protected]');
+ });
+
+ await page.reload();
+ await expect(messagesView(page).getByText(original, { exact: true })).toBeVisible();
+ await expect(
+ ownerText.locator('xpath=ancestor::div[contains(@class,"text-message")][1]'),
+ ).toHaveAttribute('dir', 'auto');
+ for (const theme of ['light', 'dark']) {
+ await page.evaluate(
+ (dark) => document.documentElement.classList.toggle('dark', dark),
+ theme === 'dark',
+ );
+ await page.screenshot({
+ path: testInfo.outputPath(`owner-text-${theme}.png`),
+ fullPage: true,
+ });
+ }
+ const share = await requestResult(request, {
+ path: `/api/share/${conversationId}`,
+ token,
+ method: 'POST',
+ data: {},
+ });
+ expect(share.ok).toBe(true);
+ const shared = await requestResult(request, {
+ path: `/api/share/${(share.body as { shareId: string }).shareId}`,
+ token,
+ });
+ expect(shared.ok).toBe(true);
+ expect(shared.text).not.toContain('[email protected]');
+ expect(shared.text).not.toContain('privateText');
+ expect(shared.text).toContain('EMAIL_1_');
+
+ const openExport = async () => {
+ await page.getByRole('button', { name: 'Export/Share' }).click();
+ await page.getByRole('menuitem', { name: 'Export' }).click();
+ return page.getByRole('dialog', { name: 'Export conversation' });
+ };
+ const selectType = async (label: string) => {
+ const dialog = page.getByRole('dialog', { name: 'Export conversation' });
+ await dialog.getByTestId('dropdown-menu').click();
+ await page.getByRole('option', { name: label }).click();
+ return dialog;
+ };
+ let exportDialog = await openExport();
+ exportDialog = await selectType('json (.json)');
+ const [canonicalDownload] = await Promise.all([
+ page.waitForEvent('download'),
+ exportDialog.getByRole('button', { name: 'Export', exact: true }).click(),
+ ]);
+ const exported = await readFile(await canonicalDownload.path(), 'utf8');
+ expect(exported).not.toContain('[email protected]');
+ expect(exported).toContain('EMAIL_1_');
+
+ exportDialog = await selectType('screenshot (.png)');
+ await exportDialog.getByRole('button', { name: 'Export', exact: true }).click();
+ await expect(
+ page
+ .getByText("Screenshots can't be exported while a chat contains protected or unsent text.")
+ .first(),
+ ).toBeVisible();
+ await page.keyboard.press('Escape');
+ await expect(exportDialog).toBeHidden();
+
+ const pending = 'Unacknowledged private export: [email protected]';
+ const delayedPath = '**/api/agents/chat/**';
+ let releasePending!: () => void;
+ const pendingGate = new Promise<void>((resolve) => {
+ releasePending = resolve;
+ });
+ await page.route(delayedPath, async (route) => {
+ if (route.request().method() !== 'POST' || route.request().postDataJSON()?.text !== pending) {
+ await route.continue();
+ return;
+ }
+ await pendingGate;
+ await route.continue();
+ });
+ const pendingRequest = (requestToCheck: {
+ method(): string;
+ url(): string;
+ postDataJSON(): { text?: string };
+ }) =>
+ requestToCheck.method() === 'POST' &&
+ new URL(requestToCheck.url()).pathname.startsWith('/api/agents/chat/') &&
+ requestToCheck.postDataJSON()?.text === pending;
+ const requestSeen = page.waitForRequest(pendingRequest);
+ const pendingResponse = page.waitForResponse((result) => pendingRequest(result.request()));
+ try {
+ const input = page.getByRole('textbox', { name: 'Message input' });
+ await input.fill(pending);
+ await input.press('Enter');
+ await requestSeen;
+ exportDialog = await openExport();
+ exportDialog = await selectType('json (.json)');
+ const [pendingDownload] = await Promise.all([
+ page.waitForEvent('download'),
+ exportDialog.getByRole('button', { name: 'Export', exact: true }).click(),
+ ]);
+ const pendingExport = await readFile(await pendingDownload.path(), 'utf8');
+ expect(pendingExport).not.toContain(pending);
+ expect(pendingExport).not.toContain('[email protected]');
+ expect(pendingExport).toContain('EMAIL_1_');
+ } finally {
+ releasePending();
+ await pendingResponse.catch(() => undefined);
+ await page.unroute(delayedPath);
+ }
+ expect((await pendingResponse).ok()).toBe(true);
+ await expect
+ .poll(
+ async () =>
+ (await fetchJson<TMessage[]>(page, `/api/messages/${conversationId}`, token)).length,
+ )
+ .toBeGreaterThanOrEqual(4);
+
+ const unauthorized = await request.post(`/api/messages/${conversationId}/owner-text`, {
+ data: { messageIds: [user.messageId] },
+ });
+ expect(unauthorized.status()).toBe(401);
+ } finally {
+ await restoreRuntimeFilters(request, token);
+ if (conversationId) {
+ await requestResult(request, {
+ path: '/api/convos',
+ token,
+ method: 'DELETE',
+ data: { arg: { conversationId } },
+ });
+ await withMongo(async (db) => {
+ expect(await db.collection('messages').countDocuments({ conversationId })).toBe(0);
+ });
+ }
+ }
+});
+
+test('the first protected owner view loads from its server ID while generation is streaming', async ({
+ page,
+ request,
+}) => {
+ test.setTimeout(90000);
+ const token = await loginAdmin(request);
+ await setRuntimeFilters(request, token, {
+ messages: {
+ pii: {
+ action: 'redact',
+ fields: ['text'],
+ starterPatterns: [],
+ customPatterns: [
+ { id: 'email', label: 'Email', regex: 'alice@example\\.com', category: 'email' },
+ ],
+ },
+ },
+ });
+ let conversationId: string | undefined;
+ const text = 'E2E_SLOW_REPLY:owner-stream [email protected]';
+ try {
+ await page.goto('/c/new');
+ await selectMockEndpoint(page, MOCK_ENDPOINTS[0]);
+ const ownerRead = page.waitForResponse(
+ (response) =>
+ response.request().method() === 'POST' &&
+ /\/api\/messages\/[^/]+\/owner-text$/.test(new URL(response.url()).pathname),
+ );
+ const started = await sendMessage(page, text);
+ conversationId = (await started.json()).conversationId as string;
+ expect(conversationId).toMatch(/^[0-9a-f-]{36}$/);
+ const owner = await ownerRead;
+ expect(owner.status()).toBe(200);
+ expect(new URL(owner.url()).pathname).toBe(`/api/messages/${conversationId}/owner-text`);
+ expect((await owner.json()).messages[0].text).toBe(text);
+ await expect(
+ messagesView(page).getByText('Private details hidden from the model'),
+ ).toBeVisible();
+ await expect(messagesView(page).getByText(text, { exact: true })).toBeVisible();
+ await expect(page.getByTestId('stop-generation-button')).toBeVisible();
+ await expect(page.getByTestId('stop-generation-button')).toBeHidden({ timeout: 60000 });
+ } finally {
+ await restoreRuntimeFilters(request, token);
+ if (conversationId) {
+ await requestResult(request, {
+ path: '/api/convos',
+ token,
+ method: 'DELETE',
+ data: { arg: { conversationId } },
+ });
+ }
+ }
+});
+
+test('an unchanged unprotected transcript still downloads a PNG screenshot', async ({
+ page,
+ request,
+}) => {
+ const token = await loginAdmin(request);
+ let conversationId: string | undefined;
+ try {
+ await page.goto('/c/new');
+ await selectMockEndpoint(page, MOCK_ENDPOINTS[0]);
+ const response = await sendMessageAndWaitForCompletion(page, 'Ordinary screenshot capture');
+ conversationId = (await response.json()).conversationId as string;
+ await expect(page.getByTestId('screenshot-target')).toHaveAttribute(
+ 'data-conversation-id',
+ conversationId!,
+ );
+ await page.getByRole('button', { name: 'Export/Share' }).click();
+ await page.getByRole('menuitem', { name: 'Export' }).click();
+ const dialog = page.getByRole('dialog', { name: 'Export conversation' });
+ await dialog.getByTestId('dropdown-menu').click();
+ await page.getByRole('option', { name: 'screenshot (.png)' }).click();
+ const [image] = await Promise.all([
+ page.waitForEvent('download'),
+ dialog.getByRole('button', { name: 'Export', exact: true }).click(),
+ ]);
+ expect(image.suggestedFilename()).toMatch(/\.png$/);
+ const bytes = await readFile(await image.path());
+ expect([...bytes.subarray(0, 8)]).toEqual([137, 80, 78, 71, 13, 10, 26, 10]);
+ } finally {
+ if (conversationId) {
+ await requestResult(request, {
+ path: '/api/convos',
+ token,
+ method: 'DELETE',
+ data: { arg: { conversationId } },
+ });
+ }
+ }
+});
+
+test('native copies retain canonical token trust without copying owner originals', async ({
+ page,
+ request,
+}) => {
+ test.setTimeout(120000);
+ const token = await loginAdmin(request);
+ const copies: string[] = [];
+ await setRuntimeFilters(request, token, {
+ messages: {
+ pii: {
+ action: 'redact',
+ fields: ['text'],
+ starterPatterns: [],
+ customPatterns: [
+ { id: 'email', label: 'Email', regex: 'alice@example\\.com', category: 'email' },
+ { id: 'hex', label: 'Credential', regex: '[a-f0-9]{32}', category: 'credential' },
+ ],
+ },
+ },
+ });
+ try {
+ await page.goto('/c/new');
+ await selectMockEndpoint(page, MOCK_ENDPOINTS[0]);
+ const response = await sendMessageAndWaitForCompletion(page, original);
+ const source = (await response.json()).conversationId as string;
+ copies.push(source);
+ const sourceMessages = await fetchJson<TMessage[]>(page, `/api/messages/${source}`, token);
+ const sourceUser = sourceMessages.find((message) => message.isCreatedByUser)!;
+ const duplicate = await requestResult(request, {
+ path: '/api/convos/duplicate',
+ token,
+ method: 'POST',
+ data: { conversationId: source },
+ });
+ expect(duplicate.ok).toBe(true);
+ const copied = duplicate.body as {
+ conversation: { conversationId: string };
+ messages: TMessage[];
+ };
+ const duplicateId = copied.conversation.conversationId;
+ copies.push(duplicateId);
+ const fork = await requestResult(request, {
+ path: '/api/convos/fork',
+ token,
+ method: 'POST',
+ data: { conversationId: source, messageId: sourceMessages.at(-1)!.messageId },
+ });
+ expect(fork.ok).toBe(true);
+ copies.push((fork.body as typeof copied).conversation.conversationId);
+ expect(JSON.stringify([duplicate.body, fork.body])).not.toContain('[email protected]');
+ expect(JSON.stringify([duplicate.body, fork.body])).not.toContain('privateText');
+ expect(JSON.stringify([duplicate.body, fork.body])).not.toContain('privacyRevision');
+ await withMongo(async (db) => {
+ const row = await db
+ .collection('messages')
+ .findOne({ conversationId: duplicateId, isCreatedByUser: true });
+ expect(row?.text).toBe(sourceUser.text);
+ expect(row?.privateTextTokens).toEqual([
+ sourceUser.text.match(/\[(?:EMAIL|PHONE|NAME|CREDENTIAL|CUSTOM)_\d+_[a-f0-9]{32}\]/)![0],
+ ]);
+ expect(row?.privacyRevision).toBeUndefined();
+ expect(row?.privateText).toBeUndefined();
+ });
+ await page.goto(`/c/${duplicateId}`);
+ await sendMessageAndWaitForCompletion(page, 'Safe copied-history follow-up');
+ await expect(
+ messagesView(page).getByText('E2E private model input verified', { exact: true }).last(),
+ ).toBeVisible();
+ const canonical = await fetchJson<TMessage[]>(page, `/api/messages/${duplicateId}`, token);
+ expect(JSON.stringify(canonical)).not.toContain('privateText');
+ expect(JSON.stringify(canonical)).not.toContain('[email protected]');
+ const share = await requestResult(request, {
+ path: `/api/share/${duplicateId}`,
+ token,
+ method: 'POST',
+ data: {},
+ });
+ expect(share.ok).toBe(true);
+ const shareId = (share.body as { shareId: string }).shareId;
+ const published = await requestResult(request, { path: `/api/share/${shareId}`, token });
+ expect(published.ok).toBe(true);
+ expect(published.text).not.toContain('privateText');
+ const sharedFork = await requestResult(request, {
+ path: `/api/share/${shareId}/fork`,
+ token,
+ method: 'POST',
+ data: {},
+ });
+ expect(sharedFork.ok).toBe(true);
+ copies.push((sharedFork.body as typeof copied).conversation.conversationId);
+ expect(sharedFork.text).not.toContain('privateText');
+ const repeated = await requestResult(request, {
+ path: '/api/convos/duplicate',
+ token,
+ method: 'POST',
+ data: { conversationId: duplicateId },
+ });
+ expect(repeated.ok).toBe(true);
+ copies.push((repeated.body as typeof copied).conversation.conversationId);
+ } finally {
+ await restoreRuntimeFilters(request, token);
+ for (const conversationId of copies) {
+ await requestResult(request, {
+ path: '/api/convos',
+ token,
+ method: 'DELETE',
+ data: { arg: { conversationId } },
+ });
+ }
+ }
+});
+
+test('a later history-policy rejection never persists the transformed protected turn', async ({
+ page,
+ request,
+}) => {
+ test.setTimeout(90000);
+ const token = await loginAdmin(request);
+ let conversationId: string | undefined;
+ try {
+ await page.goto('/c/new');
+ await selectMockEndpoint(page, MOCK_ENDPOINTS[0]);
+ const seeded = await sendMessageAndWaitForCompletion(page, 'Safe admission-history seed');
+ conversationId = (await seeded.json()).conversationId as string;
+ const prior = await fetchJson<TMessage[]>(page, `/api/messages/${conversationId}`, token);
+ const user = prior.find((message) => message.isCreatedByUser)!;
+ await withMongo(async (db) => {
+ await db.collection('messages').updateOne(
+ { conversationId, messageId: user.messageId },
+ {
+ $set: { text: 'FORBIDDEN_HISTORICAL_MARKER' },
+ },
+ );
+ });
+ await page.reload();
+ await setRuntimeFilters(request, token, {
+ messages: {
+ pii: {
+ action: 'redact',
+ fields: ['text'],
+ starterPatterns: [],
+ customPatterns: [
+ { id: 'email', label: 'Email', regex: 'alice@example\\.com', category: 'email' },
+ { id: 'history', label: 'Restricted history', regex: 'FORBIDDEN_HISTORICAL_MARKER' },
+ ],
+ },
+ },
+ });
+ const completion = page.waitForResponse(async (response) => {
+ if (
+ response.request().method() !== 'GET' ||
+ !new URL(response.url()).pathname.includes('/api/agents/chat/stream/')
+ ) {
+ return false;
+ }
+ return true;
+ });
+ const admitted = await sendMessage(page, 'E2E_REJECTED_PRIVATE_TEXT: [email protected]');
+ expect(admitted.ok()).toBe(true);
+ const stream = await completion;
+ const eventText = await stream.text();
+ expect(eventText).toContain('error');
+ await withMongo(async (db) => {
+ const rows = await db.collection('messages').find({ conversationId }).toArray();
+ expect(rows).toHaveLength(prior.length);
+ expect(JSON.stringify(rows)).not.toContain('E2E_REJECTED_PRIVATE_TEXT');
+ expect(JSON.stringify(rows)).not.toContain('[email protected]');
+ expect(rows.every((row) => row.privateText == null)).toBe(true);
+ });
+ } finally {
+ await restoreRuntimeFilters(request, token);
+ if (conversationId) {
+ await requestResult(request, {
+ path: '/api/convos',
+ token,
+ method: 'DELETE',
+ data: { arg: { conversationId } },
+ });
+ }
+ }
+});
diff --git a/librechat.example.yaml b/librechat.example.yaml
index dd4669e625..978046c90e 100644
--- a/librechat.example.yaml
+++ b/librechat.example.yaml
@@ -1531,8 +1531,12 @@ endpoints:
# messages:
# unattributedAssistantContent: model_output # `model_output` (default) or `inspect`
# pii:
-# action: audit # `block` (default), `audit`, or `redact` (reserved for transformation-aware ingress; current routes still block)
-# # `redact` requires the later encrypted owner-view and canonical-message integration.
+# action: audit # `block` (default), `audit`, or opt-in `redact`
+# # `redact` transforms fresh, text-only interactive Agent chat submissions with a clientRequestId.
+# # Edits, resumes, files, quotes, other endpoints, and other fields still use blocking checks.
+# # Requires a valid CREDS_KEY. Preserve that key for owner-original recovery; changing it
+# # makes existing originals unavailable. Text remains canonical/filtered in ordinary exports.
+# # Originals are an encrypted, unindexed sidecar field, deleted/expired with the message.
# # maxCharacters: 65536 # bounded total inspected text per transformation session
# # maxMatches: 256 # bounded matches per transformation session
# # Custom patterns may set category: email, phone, name, credential, or custom.
diff --git a/packages/api/src/agents/memory.spec.ts b/packages/api/src/agents/memory.spec.ts
index 3f1285207a..70cfe0ba70 100644
--- a/packages/api/src/agents/memory.spec.ts
+++ b/packages/api/src/agents/memory.spec.ts
@@ -1292,3 +1292,89 @@ describe('memory model-bound content preflight', () => {
expect(Run.create).not.toHaveBeenCalled();
});
});
+
+describe('automatic memory canonical token trust', () => {
+ const token = `[EMAIL_1_${'a'.repeat(32)}]`;
+ const filters: FiltersConfig = {
+ messages: {
+ pii: {
+ fields: ['text', 'content_part'],
+ starterPatterns: [],
+ customPatterns: [{ id: 'hex', label: 'Credential', regex: '[a-f0-9]{32}' }],
+ },
+ },
+ };
+ it.each([true, false])('admits only verified generated tokens, trusted: %s', async (trusted) => {
+ await processMemory({
+ res: {} as Response,
+ userId: 'owner',
+ messageId: 'response',
+ conversationId: 'conversation',
+ messages: [new HumanMessage(token)],
+ inspectionMessages: [new HumanMessage(token)],
+ privateTextTokens: trusted ? new Set([token]) : undefined,
+ memory: '',
+ instructions: 'Extract explicitly requested memories',
+ filters,
+ setMemory: jest.fn(),
+ deleteMemory: jest.fn(),
+ });
+ expect(Run.create).toHaveBeenCalledTimes(trusted ? 1 : 0);
+ });
+ it('still rejects raw credentials surrounding a trusted token', async () => {
+ await processMemory({
+ res: {} as Response,
+ userId: 'owner',
+ messageId: 'response',
+ conversationId: 'conversation',
+ messages: [new HumanMessage(`${token} ${'b'.repeat(32)}`)],
+ privateTextTokens: new Set([token]),
+ memory: '',
+ instructions: 'Extract',
+ filters,
+ setMemory: jest.fn(),
+ deleteMemory: jest.fn(),
+ });
+ expect(Run.create).not.toHaveBeenCalled();
+ });
+});
+
+it('does not invoke automatic extraction when its generation has already aborted', async () => {
+ const controller = new AbortController();
+ controller.abort();
+ await processMemory({
+ res: {} as Response,
+ userId: 'owner',
+ messageId: 'response',
+ conversationId: 'conversation',
+ messages: [new HumanMessage('Safe')],
+ memory: '',
+ instructions: 'Extract',
+ signal: controller.signal,
+ setMemory: jest.fn(),
+ deleteMemory: jest.fn(),
+ });
+ expect(Run.create).not.toHaveBeenCalled();
+});
+
+it('forwards generation cancellation into the automatic memory SDK run', async () => {
+ const controller = new AbortController();
+ const processStream = jest.fn(async () => 'success');
+ (Run.create as jest.Mock).mockReturnValueOnce({ processStream });
+ await processMemory({
+ res: {} as Response,
+ userId: 'owner',
+ messageId: 'response',
+ conversationId: 'conversation',
+ messages: [new HumanMessage('Safe')],
+ memory: '',
+ instructions: 'Extract',
+ signal: controller.signal,
+ setMemory: jest.fn(),
+ deleteMemory: jest.fn(),
+ });
+ expect(processStream).toHaveBeenCalledWith(
+ expect.anything(),
+ expect.objectContaining({ signal: controller.signal }),
+ );
+});
diff --git a/packages/api/src/agents/memory.ts b/packages/api/src/agents/memory.ts
index 97f62332a7..1e4db22263 100644
--- a/packages/api/src/agents/memory.ts
+++ b/packages/api/src/agents/memory.ts
@@ -761,6 +761,8 @@ export async function processMemory({
deleteMemory,
messages,
inspectionMessages,
+ privateTextTokens,
+ signal,
memory,
memoryEntries,
messageId,
@@ -788,6 +790,8 @@ export async function processMemory({
conversationId: string;
messages: BaseMessage[];
inspectionMessages?: BaseMessage[];
+ privateTextTokens?: ReadonlySet<string>;
+ signal?: AbortSignal;
validKeys?: string[];
instructions: string;
/** Canonical rows preserve key/value granularity for field-scoped policy. */
@@ -807,6 +811,7 @@ export async function processMemory({
tenantId?: string;
}): Promise<(TAttachment | null)[] | undefined> {
try {
+ signal?.throwIfAborted();
const submittedMessages = (inspectionMessages ?? messages).filter(
(message) => message._getType() !== 'ai',
);
@@ -821,6 +826,7 @@ export async function processMemory({
}
assertModelBoundContent({
filters,
+ privateTextTokens,
submittedMessages,
agents: [{ instructions, model_parameters: llmConfig }],
memories,
@@ -994,7 +1000,9 @@ ${memory ?? 'No existing memories'}`;
returnContent: true,
});
+ signal?.throwIfAborted();
const config = {
+ ...(signal != null && { signal }),
runName: 'MemoryRun',
configurable: {
user_id: userId,
@@ -1066,6 +1074,8 @@ export async function createMemoryProcessor({
(
messages: BaseMessage[],
inspectionMessages?: BaseMessage[],
+ privateTextTokens?: ReadonlySet<string>,
+ signal?: AbortSignal,
) => Promise<(TAttachment | null)[] | undefined>,
]
> {
@@ -1101,6 +1111,8 @@ export async function createMemoryProcessor({
async function (
messages: BaseMessage[],
inspectionMessages?: BaseMessage[],
+ privateTextTokens?: ReadonlySet<string>,
+ signal?: AbortSignal,
): Promise<(TAttachment | null)[] | undefined> {
try {
return await processMemory({
@@ -1109,6 +1121,8 @@ export async function createMemoryProcessor({
agentId,
messages,
inspectionMessages,
+ privateTextTokens,
+ signal,
validKeys,
llmConfig,
messageId,
diff --git a/packages/api/src/imports.ts b/packages/api/src/imports.ts
index d216ce5a5b..4f26093832 100644
--- a/packages/api/src/imports.ts
+++ b/packages/api/src/imports.ts
@@ -56,6 +56,8 @@ export interface ConversationImportProtectionContext {
readonly getFiles?: GetCanonicalFilesForInspection;
readonly trustedLiveFiles?: readonly CanonicalFileInspectionFile[];
readonly legacyPii?: MessageFilterPiiConfig | null;
+ /** Supplied only by native canonical-copy/share callers, never parsed from an import. */
+ readonly privateTextTokens?: ReadonlySet<string>;
/** Injectable only at the legacy package boundary and in focused tests. */
readonly assertModelBoundContent?: (input: ModelBoundContentInput) => void;
}
@@ -161,6 +163,7 @@ async function inspectConversationImportContent(
onTraversalFailure: context.onTraversalFailure,
filters: activeFilters,
legacyPii,
+ privateTextTokens: context.privateTextTokens,
storedMessages: [message],
});
} catch (error) {
diff --git a/packages/api/src/middleware/messageFilterPii.ts b/packages/api/src/middleware/messageFilterPii.ts
index a9cd123c05..4d2626e0da 100644
--- a/packages/api/src/middleware/messageFilterPii.ts
+++ b/packages/api/src/middleware/messageFilterPii.ts
@@ -147,6 +147,7 @@ export interface CreateMessageFilterPiiOptions {
getConfig: (req: ServerRequest) => MessageFilterPiiConfig | undefined;
getFilters?: (req: ServerRequest) => FiltersConfig | undefined;
getFiles?: GetCanonicalFilesForInspection;
+ getPreinspectedText?: (req: ServerRequest) => string | undefined;
}
export function createMessageFilterPii(options: CreateMessageFilterPiiOptions): RequestHandler {
@@ -241,7 +242,18 @@ export function createMessageFilterPii(options: CreateMessageFilterPiiOptions):
if (filters != null && !collect(() => extractStoredMessageContent(req.body))) {
return;
}
- const finding = inspectContent(fragments, { filters, legacyPii });
+ const preinspectedText = options.getPreinspectedText?.(req);
+ const inspectable =
+ preinspectedText == null
+ ? fragments
+ : fragments.filter(
+ (fragment) =>
+ fragment.source !== 'message' ||
+ fragment.field !== 'text' ||
+ fragment.path !== '/text' ||
+ fragment.text !== preinspectedText,
+ );
+ const finding = inspectContent(inspectable, { filters, legacyPii });
if (finding != null) {
if (finding.detectorId !== 'legacy-pattern') {
res.status(400).json(contentFilterBlockResponse(finding));
diff --git a/packages/api/src/middleware/modelBoundContent.spec.ts b/packages/api/src/middleware/modelBoundContent.spec.ts
index e708eedbb0..17388cc3a0 100644
--- a/packages/api/src/middleware/modelBoundContent.spec.ts
+++ b/packages/api/src/middleware/modelBoundContent.spec.ts
@@ -6197,3 +6197,40 @@ describe('assertModelBoundProviderContent', () => {
expect(onAllowed).not.toHaveBeenCalled();
});
});
+
+it('admits only after every native batch passes and awaits the protected commit', async () => {
+ const onContentAllowed = jest.fn(async () => {});
+ const callback = createModelBoundChatModelCallback(
+ {
+ filters: {
+ messages: {
+ pii: {
+ fields: ['text', 'content_part'],
+ starterPatterns: [],
+ customPatterns: [{ id: 'secret', label: 'Secret', regex: 'BLOCK-ME' }],
+ },
+ },
+ },
+ },
+ { onContentAllowed },
+ );
+ expect(() =>
+ callback.handleChatModelStart(undefined, [
+ [{ role: 'user', content: 'safe' }],
+ [{ role: 'user', content: 'BLOCK-ME' }],
+ ]),
+ ).toThrow();
+ expect(onContentAllowed).not.toHaveBeenCalled();
+ let finish!: () => void;
+ onContentAllowed.mockImplementationOnce(
+ () =>
+ new Promise<void>((resolve) => {
+ finish = resolve;
+ }),
+ );
+ const pending = callback.handleChatModelStart(undefined, [[{ role: 'user', content: 'safe' }]]);
+ expect(pending).toBeInstanceOf(Promise);
+ finish();
+ await pending;
+ expect(onContentAllowed).toHaveBeenCalledTimes(1);
+});
diff --git a/packages/api/src/middleware/modelBoundContent.ts b/packages/api/src/middleware/modelBoundContent.ts
index 212acc3ea1..b89d510166 100644
--- a/packages/api/src/middleware/modelBoundContent.ts
+++ b/packages/api/src/middleware/modelBoundContent.ts
@@ -264,6 +264,8 @@ export interface ModelBoundProviderContentInput {
readonly onTraversalFailure?: LocatorTraversalReporter;
readonly filters?: FiltersConfig;
readonly legacyPii?: MessageFilterPiiConfig;
+ /** Exact generated tokens from server-owned canonical user rows, never request metadata. */
+ readonly privateTextTokens?: ReadonlySet<string>;
readonly providerMessages: readonly ModelBoundProviderMessage[];
readonly storedMessages?: readonly (StoredModelBoundMessage | null | undefined)[];
readonly resolvedFiles?: readonly (ModelBoundCanonicalFile | null | undefined)[];
@@ -679,7 +681,12 @@ export interface ModelBoundChatModelCallback {
readonly handleChatModelStart: (
llm: object | undefined,
messageBatches: readonly (readonly ModelBoundProviderMessage[])[],
- ) => void;
+ runId?: string,
+ parentRunId?: string,
+ extraParams?: Record<string, unknown>,
+ tags?: string[],
+ metadata?: Record<string, unknown>,
+ ) => void | Promise<void>;
}
export interface InitialModelBoundAdmissionCallback {
@@ -725,6 +732,8 @@ export interface ModelBoundContentInput {
readonly onTraversalFailure?: LocatorTraversalReporter;
readonly filters?: FiltersConfig;
readonly legacyPii?: MessageFilterPiiConfig;
+ /** Exact generated tokens from server-owned canonical user rows, never request metadata. */
+ readonly privateTextTokens?: ReadonlySet<string>;
/** Fresh API input: every role is caller-submitted. */
readonly submittedMessages?: readonly ModelBoundMessage[];
/** Persisted chat history: user rows plus structured tool fragments are re-inspected. */
@@ -3146,6 +3155,7 @@ function assertIndexedModelBoundProviderContent(
onTraversalFailure: input.onTraversalFailure,
filters: input.filters,
legacyPii: input.legacyPii,
+ privateTextTokens: input.privateTextTokens,
storedMessages: projection.storedMessages,
resolvedFiles: projection.resolvedFiles,
deferredTraversalErrors: projection.deferredTraversalErrors,
@@ -3233,7 +3243,14 @@ function snapshotBoundedSourceFileIds(
/** Creates a run-stable callback shared by root, summary, and subagent model clients. */
export function createModelBoundChatModelCallback(
input: Omit<ModelBoundProviderContentInput, 'providerMessages'>,
- options: { readonly onContentRejected?: (error: unknown) => void } = {},
+ options: {
+ readonly onContentRejected?: (error: unknown) => void;
+ readonly onContentAllowed?: (context: {
+ runId?: string;
+ parentRunId?: string;
+ metadata?: Record<string, unknown>;
+ }) => void | Promise<void>;
+ } = {},
): ModelBoundChatModelCallback {
const storedMessageSnapshot = snapshotBoundedProviderArray(input.storedMessages);
const resolvedFileSnapshot = snapshotBoundedProviderArray(input.resolvedFiles);
@@ -3242,6 +3259,7 @@ export function createModelBoundChatModelCallback(
onTraversalFailure: input.onTraversalFailure,
filters: input.filters,
legacyPii: input.legacyPii,
+ privateTextTokens: input.privateTextTokens,
storedMessages: storedMessageSnapshot.values,
resolvedFiles: resolvedFileSnapshot.values,
fileIdsBySourceMessageId: sourceFileIdSnapshot.values,
@@ -3260,6 +3278,11 @@ export function createModelBoundChatModelCallback(
handleChatModelStart: (
_llm: object | undefined,
messageBatches: readonly (readonly ModelBoundProviderMessage[])[],
+ runId?: string,
+ parentRunId?: string,
+ _extraParams?: Record<string, unknown>,
+ _tags?: string[],
+ metadata?: Record<string, unknown>,
) => {
let messageBatchCount = 0;
let messageBatchesOverflowed = false;
@@ -3317,6 +3340,7 @@ export function createModelBoundChatModelCallback(
options.onContentRejected?.(error);
throw new FatalModelBoundPolicyError(error);
}
+ return options.onContentAllowed?.({ runId, parentRunId, metadata });
},
});
return callback;
@@ -3492,16 +3516,29 @@ function inspectModelBoundContent(
const inspectionSession = inspector?.createSession();
const shouldContinueAfterFinding = inspectionSession?.hasAuditRules === true;
let finding: ReturnType<NonNullable<typeof inspectionSession>['inspect']> = null;
- const inspectFragments = (fragments: Iterable<TextContentFragment>): void => {
- if (finding == null || shouldContinueAfterFinding) {
- const nextFinding = inspectionSession?.inspect(fragments) ?? null;
- finding ??= nextFinding;
+ const inspectFragment = (fragment: TextContentFragment): void => {
+ if (finding != null && !shouldContinueAfterFinding) {
+ return;
}
+ const inspectableText =
+ input.privateTextTokens?.size &&
+ (fragment.source === 'message' || fragment.source === 'assembled_context')
+ ? fragment.text.replace(
+ /\[(?:EMAIL|PHONE|NAME|CREDENTIAL|CUSTOM)_\d+_[a-f0-9]{32}\]/g,
+ (token) => (input.privateTextTokens!.has(token) ? '' : token),
+ )
+ : fragment.text;
+ const inspected =
+ inspectableText === fragment.text ? fragment : { ...fragment, text: inspectableText };
+ const nextFinding = inspectionSession?.inspectFragment(inspected) ?? null;
+ finding ??= nextFinding;
};
- const inspectFragment = (fragment: TextContentFragment): void => {
- if (finding == null || shouldContinueAfterFinding) {
- const nextFinding = inspectionSession?.inspectFragment(fragment) ?? null;
- finding ??= nextFinding;
+ const inspectFragments = (fragments: Iterable<TextContentFragment>): void => {
+ for (const fragment of fragments) {
+ inspectFragment(fragment);
+ if (finding != null && !shouldContinueAfterFinding) {
+ return;
+ }
}
};
const traversalErrors: ContentTraversalLimitError[] = [
diff --git a/packages/api/src/protection/index.ts b/packages/api/src/protection/index.ts
index 264f49b381..18efce9a68 100644
--- a/packages/api/src/protection/index.ts
+++ b/packages/api/src/protection/index.ts
@@ -10,3 +10,7 @@ export * from './adapters/chat';
export * from './adapters/nested';
export * from './adapters/messages';
export * from './adapters/submissions';
+export * from './private/submission';
+export * from './private/view';
+export * from './private/copy';
+export * from './private/admission';
diff --git a/packages/api/src/protection/private/admission.spec.ts b/packages/api/src/protection/private/admission.spec.ts
new file mode 100644
index 0000000000..c90fbb7252
--- /dev/null
+++ b/packages/api/src/protection/private/admission.spec.ts
@@ -0,0 +1,385 @@
+import { Run, Providers, FakeChatModel } from '@librechat/agents';
+import { HumanMessage } from '@librechat/agents/langchain/messages';
+import { CallbackManager } from '@langchain/core/callbacks/manager';
+import { BaseCallbackHandler } from '@langchain/core/callbacks/base';
+import type { Request } from 'express';
+import {
+ createPrivateTextIngress,
+ stampPrivateTextMessage,
+ requirePrivateTextAdmission,
+ savePrivateTextErrorTurn,
+ bindPrivateTextPersistenceAbort,
+} from './submission';
+import {
+ createPrivateTextInitialAdmissionCallback,
+ getPrivateTextModelHooks,
+ withPrivateTextAdmissionConfig,
+} from './admission';
+import { createModelBoundChatModelCallback } from '../../middleware/modelBoundContent';
+
+function turn() {
+ const filters = {
+ messages: {
+ pii: {
+ action: 'redact' as const,
+ fields: ['text' as const, 'content_part' as const],
+ starterPatterns: [],
+ customPatterns: [
+ { id: 'email', label: 'Email', regex: 'alice@example\\.com', category: 'email' as const },
+ { id: 'history', label: 'History', regex: 'RESTRICTED-HISTORY' },
+ ],
+ },
+ },
+ };
+ const req = {
+ path: '/',
+ user: { id: 'owner' },
+ body: {
+ clientRequestId: 'parallel-private',
+ },
+ } as unknown as Request;
+ createPrivateTextIngress({
+ getFilters: () => filters,
+ getLegacyPii: () => undefined,
+ getKey: () => 'ab'.repeat(32),
+ })(req, {} as never, jest.fn());
+ const message = stampPrivateTextMessage(req, {
+ messageId: 'user',
+ conversationId: 'conversation',
+ text: req.body.text,
+ isCreatedByUser: true,
+ });
+ return { filters, req, message };
+}
+function setup(roots = ['a', 'b']) {
+ const { req, message, filters } = turn();
+ const controller = new AbortController();
+ const start = jest.fn(async () => ({ message }));
+ const cancel = jest.fn();
+ const created = jest.fn();
+ const initial = createPrivateTextInitialAdmissionCallback(req, {
+ agentIds: roots,
+ start,
+ cancel,
+ onPersisted: created,
+ signal: controller.signal,
+ })!;
+ const content = createModelBoundChatModelCallback(
+ { filters },
+ getPrivateTextModelHooks(req, initial, start, cancel, created),
+ );
+ const manager = new CallbackManager();
+ manager.addHandler(
+ Object.assign(
+ BaseCallbackHandler.fromMethods({
+ handleChainStart: initial.handleChainStart,
+ handleChainEnd: initial.handleChainEnd,
+ handleChainError: initial.handleChainError,
+ handleLLMError: initial.handleLLMError,
+ }),
+ {
+ raiseError: true,
+ awaitHandlers: true,
+ },
+ ),
+ true,
+ );
+ const graph = manager.handleChainStart(
+ { lc: 1, type: 'not_implemented', id: ['graph'] },
+ {},
+ 'graph',
+ );
+ const model = async (agent: string, text = 'Safe native input') => {
+ const graphRun = await graph;
+ const nodeManager = graphRun.getChild();
+ const metadata = { agentId: agent, langgraph_node: `agent=${agent}` };
+ nodeManager.addMetadata(metadata, true);
+ const node = await nodeManager.handleChainStart(
+ { lc: 1, type: 'not_implemented', id: ['agent'] },
+ {},
+ `node-${agent}`,
+ undefined,
+ undefined,
+ metadata,
+ `agent=${agent}`,
+ );
+ const modelManager = node.getChild();
+ modelManager.addHandler(
+ Object.assign(
+ BaseCallbackHandler.fromMethods({
+ handleChatModelStart: (llm, batches, runId, parentRunId, extra, tags, metadata) =>
+ content.handleChatModelStart(
+ llm,
+ batches.map((batch) =>
+ batch.map((message) => ({
+ role: message.getType(),
+ content: message.content,
+ })),
+ ),
+ runId,
+ parentRunId,
+ extra,
+ tags,
+ metadata,
+ ),
+ }),
+ {
+ raiseError: true,
+ awaitHandlers: true,
+ },
+ ),
+ true,
+ );
+ // Actual LangChain dispatch supplies ancestry and metadata to intrinsic callbacks.
+ return modelManager.handleChatModelStart(
+ { lc: 1, type: 'not_implemented', id: ['model'] },
+ [[new HumanMessage(text)]],
+ `model-${agent}`,
+ undefined,
+ undefined,
+ undefined,
+ metadata,
+ );
+ };
+ return { req, message, start, cancel, created, initial, content, controller, model };
+}
+
+it('holds a safe root until a sibling input passes, then commits once before either model', async () => {
+ const state = setup();
+ const invoke = jest.fn();
+ const first = state.model('a').then(invoke);
+ await new Promise((resolve) => setImmediate(resolve));
+ expect(state.start).not.toHaveBeenCalled();
+ expect(invoke).not.toHaveBeenCalled();
+ await state.model('b').then(invoke);
+ await first;
+ expect(state.start).toHaveBeenCalledTimes(1);
+ expect(state.created).toHaveBeenCalledTimes(1);
+ expect(invoke).toHaveBeenCalledTimes(2);
+ expect(state.created.mock.invocationCallOrder[0]).toBeLessThan(
+ invoke.mock.invocationCallOrder[0],
+ );
+});
+
+it('a sibling rejection releases every waiting root without saving, invoking, or recovery', async () => {
+ const state = setup();
+ const invoke = jest.fn();
+ const first = state.model('a').then(invoke);
+ const observed = first.catch((error) => error);
+ await new Promise((resolve) => setImmediate(resolve));
+ await expect(state.model('b', 'RESTRICTED-HISTORY')).rejects.toThrow();
+ expect(await observed).toBeInstanceOf(Error);
+ expect(state.start).not.toHaveBeenCalled();
+ expect(state.created).not.toHaveBeenCalled();
+ expect(invoke).not.toHaveBeenCalled();
+ const recover = jest.fn(async () => {});
+ await savePrivateTextErrorTurn(state.req, new Error('rejected'), recover);
+ expect(recover).not.toHaveBeenCalled();
+ await expect(requirePrivateTextAdmission(state.req)).rejects.toThrow();
+});
+
+it('cancels a waiting parallel root on Stop, without beginning protected persistence', async () => {
+ const state = setup();
+ const invoke = jest.fn();
+ const first = state.model('a').then(invoke);
+ const observed = first.catch((error) => error);
+ await new Promise((resolve) => setImmediate(resolve));
+ state.controller.abort();
+ expect(await observed).toBeInstanceOf(Error);
+ expect(state.start).not.toHaveBeenCalled();
+ expect(invoke).not.toHaveBeenCalled();
+});
+
+it('does not accept a summary or unidentified model as initial-root admission', async () => {
+ const state = setup();
+ await expect(
+ state.content.handleChatModelStart(
+ undefined,
+ [[{ role: 'user', content: 'Safe' }]],
+ 'summary',
+ 'graph',
+ undefined,
+ undefined,
+ { summarization: true },
+ ),
+ ).rejects.toThrow();
+ expect(state.start).not.toHaveBeenCalled();
+});
+
+it('releases waiting roots when a peer needs a later summarization superstep', async () => {
+ const state = setup();
+ const waiting = state.model('a').catch((error) => error);
+ await new Promise((resolve) => setImmediate(resolve));
+ state.initial.handleChainStart(
+ undefined,
+ {},
+ 'b-detour',
+ 'graph',
+ undefined,
+ { langgraph_node: 'agent=b' },
+ undefined,
+ 'agent=b',
+ );
+ state.initial.handleChainEnd({ summarizationRequest: {} }, 'b-detour');
+ expect(await waiting).toBeInstanceOf(Error);
+ expect(state.start).not.toHaveBeenCalled();
+});
+
+it('raises concurrency to the root-wave size without changing ordinary run configuration', () => {
+ const state = setup(['a', 'b', 'c']);
+ expect(withPrivateTextAdmissionConfig({ maxConcurrency: 1 }, state.initial).maxConcurrency).toBe(
+ 3,
+ );
+ expect(withPrivateTextAdmissionConfig({}, state.initial).maxConcurrency).toBeUndefined();
+ expect(withPrivateTextAdmissionConfig({ maxConcurrency: 8 }, state.initial).maxConcurrency).toBe(
+ 8,
+ );
+ const ordinary = { maxConcurrency: 1 };
+ expect(withPrivateTextAdmissionConfig(ordinary)).toBe(ordinary);
+});
+
+it.each([false, true])(
+ 'cancels an unadmitted protected write on Stop, pre-aborted: %s',
+ (aborted) => {
+ const { req } = turn();
+ const controller = new AbortController();
+ const start = jest.fn();
+ const cancel = jest.fn();
+ if (aborted) {
+ controller.abort();
+ }
+ bindPrivateTextPersistenceAbort(req, controller.signal, start, cancel);
+ if (!aborted) {
+ controller.abort();
+ }
+ expect(start).not.toHaveBeenCalled();
+ expect(cancel).toHaveBeenCalledTimes(1);
+ },
+);
+
+it('retains ordinary Stop durability', () => {
+ const controller = new AbortController();
+ const start = jest.fn();
+ const cancel = jest.fn();
+ bindPrivateTextPersistenceAbort({}, controller.signal, start, cancel);
+ controller.abort();
+ expect(start).toHaveBeenCalledTimes(1);
+ expect(cancel).not.toHaveBeenCalled();
+});
+
+it.each([false, true])(
+ 'coordinates the actual SDK parallel graph, rejected sibling: %s',
+ async (rejectSibling) => {
+ const { req, message, filters } = turn();
+ const start = jest.fn(async () => ({ message }));
+ const created = jest.fn();
+ const cancel = jest.fn();
+ const initial = createPrivateTextInitialAdmissionCallback(req, {
+ agentIds: ['a', 'b'],
+ start,
+ cancel,
+ onPersisted: created,
+ })!;
+ const inspect = createModelBoundChatModelCallback(
+ {
+ filters: {
+ ...filters,
+ agentInstructions: {
+ pii: {
+ starterPatterns: [],
+ customPatterns: [{ id: 'history', label: 'Restricted', regex: 'RESTRICTED-HISTORY' }],
+ },
+ },
+ },
+ },
+ getPrivateTextModelHooks(req, initial, start, cancel, created),
+ );
+ const invoke = jest.fn();
+ const model = new FakeChatModel({ responses: ['Safe reply'], sleep: 0 });
+ const stream = model._streamResponseChunks.bind(model);
+ jest.spyOn(model, '_streamResponseChunks').mockImplementation(async function* (...args) {
+ expect(created).toHaveBeenCalledTimes(1);
+ invoke();
+ yield* stream(...args);
+ });
+ // Same registration adapter used by the production model-client boundary.
+ model.callbacks = [
+ Object.assign(
+ BaseCallbackHandler.fromMethods({
+ handleChatModelStart: (llm, batches, runId, parentRunId, extra, tags, metadata) =>
+ inspect.handleChatModelStart(
+ llm,
+ batches.map((batch) =>
+ batch.map((entry) => ({
+ role: entry.getType(),
+ content:
+ rejectSibling && metadata?.agentId === 'b'
+ ? 'RESTRICTED-HISTORY'
+ : entry.content,
+ })),
+ ),
+ runId,
+ parentRunId,
+ extra,
+ tags,
+ metadata,
+ ),
+ }),
+ { raiseError: true, awaitHandlers: true },
+ ),
+ ];
+ const run = await Run.create({
+ runId: `private-parallel-${rejectSibling}`,
+ skipCleanup: true,
+ tokenCounter: () => 1,
+ graphConfig: {
+ type: 'multi-agent',
+ edges: [],
+ agents: ['a', 'b'].map((agentId) => ({
+ agentId,
+ provider: Providers.OPENAI,
+ tools: [],
+ instructions:
+ rejectSibling && agentId === 'b' ? 'RESTRICTED-HISTORY' : 'Safe instructions',
+ maxContextTokens: 100_000,
+ clientOptions: { apiKey: 'fixture-key', streaming: false },
+ })),
+ },
+ });
+ if (run.Graph == null) {
+ throw new Error('SDK graph was not initialized');
+ }
+ run.Graph.overrideModel = model;
+ const config = withPrivateTextAdmissionConfig(
+ { configurable: { thread_id: 'private-parallel' }, version: 'v2' as const },
+ initial,
+ );
+ const execution = run.processStream(
+ { messages: [new HumanMessage('Safe turn')] },
+ {
+ ...config,
+ callbacks: [
+ Object.assign(
+ BaseCallbackHandler.fromMethods({
+ handleChainStart: initial.handleChainStart,
+ handleChainEnd: initial.handleChainEnd,
+ handleChainError: initial.handleChainError,
+ handleLLMError: initial.handleLLMError,
+ }),
+ { raiseError: true, awaitHandlers: true },
+ ),
+ ],
+ },
+ );
+ if (rejectSibling) {
+ await execution.catch(() => undefined);
+ expect(start).not.toHaveBeenCalled();
+ expect(invoke).not.toHaveBeenCalled();
+ } else {
+ await execution;
+ expect(start).toHaveBeenCalledTimes(1);
+ expect(invoke).toHaveBeenCalledTimes(2);
+ }
+ },
+);
diff --git a/packages/api/src/protection/private/admission.ts b/packages/api/src/protection/private/admission.ts
new file mode 100644
index 0000000000..246a00b83a
--- /dev/null
+++ b/packages/api/src/protection/private/admission.ts
@@ -0,0 +1,188 @@
+import type { InitialModelBoundAdmissionCallback } from '../../middleware/modelBoundContent';
+import type { getPrivateTextAdmission } from './submission';
+import { getPrivateTextAdmission as getAdmission, rejectPrivateTextAdmission } from './submission';
+import { ContentFilterError } from '../../middleware/contentFilter';
+
+type ModelContext = {
+ runId?: string;
+ parentRunId?: string;
+ metadata?: Record<string, unknown>;
+};
+export interface ProtectedInitialAdmission extends InitialModelBoundAdmissionCallback {
+ readonly requiredConcurrency: number;
+ readonly admitModel: (context: ModelContext) => Promise<void> | void;
+ readonly reject: (error?: unknown) => void;
+}
+function blocked(): 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',
+ });
+}
+
+/** Every starting root must pass its exact native input before any root can invoke its model. */
+export function createPrivateTextInitialAdmissionCallback(
+ req: object | undefined,
+ options: {
+ agentIds: readonly string[];
+ start: Parameters<typeof getPrivateTextAdmission>[1];
+ cancel?: () => unknown;
+ onPersisted?: () => void;
+ signal?: AbortSignal;
+ },
+): ProtectedInitialAdmission | undefined {
+ const commit = getAdmission(req, options.start, options.onPersisted);
+ if (commit == null) {
+ return;
+ }
+ const pending = new Set(options.agentIds);
+ const parents = new Map<string, string>();
+ const rootNodes = new Map<string, string>();
+ let settle!: () => void;
+ let fail!: (error: unknown) => void;
+ const ready = new Promise<void>((resolve, reject) => {
+ settle = resolve;
+ fail = reject;
+ });
+ // A chain can fail before any model handler waits on the barrier.
+ void ready.catch(() => {});
+ let state: 'pending' | 'committing' | 'admitted' | 'rejected' = 'pending';
+ const detach = () => {
+ options.signal?.removeEventListener('abort', abort);
+ parents.clear();
+ rootNodes.clear();
+ };
+ const reject = (error: unknown = blocked()) => {
+ if (state === 'admitted' || state === 'rejected') {
+ return;
+ }
+ state = 'rejected';
+ rejectPrivateTextAdmission(req);
+ options.cancel?.();
+ detach();
+ fail(error);
+ };
+ const abort = () => reject();
+ options.signal?.addEventListener('abort', abort, { once: true });
+ if (options.signal?.aborted || pending.size === 0) {
+ reject();
+ }
+ const findRoot = (parentRunId: string | undefined): string | undefined => {
+ const seen = new Set<string>();
+ let id = parentRunId;
+ while (id != null && !seen.has(id)) {
+ seen.add(id);
+ const agent = rootNodes.get(id);
+ if (agent != null) {
+ return agent;
+ }
+ id = parents.get(id);
+ }
+ return;
+ };
+ const admitModel = ({ parentRunId, metadata }: ModelContext) => {
+ if (state === 'admitted') {
+ return;
+ }
+ // Summary detours need a later graph superstep. Waiting would deadlock roots
+ // already at their native boundary; invoking would bypass turn admission.
+ if (metadata?.summarization === true) {
+ reject();
+ return ready;
+ }
+ const agentId = findRoot(parentRunId);
+ if (
+ !agentId ||
+ metadata?.agentId !== agentId ||
+ metadata.langgraph_node !== `agent=${agentId}`
+ ) {
+ reject();
+ return ready;
+ }
+ pending.delete(agentId);
+ if (pending.size === 0 && state === 'pending') {
+ state = 'committing';
+ void commit().then(() => {
+ if (state !== 'rejected') {
+ state = 'admitted';
+ detach();
+ settle();
+ }
+ }, reject);
+ }
+ return ready;
+ };
+ return Object.freeze({
+ name: 'librechat-initial-model-bound-admission',
+ raiseError: true,
+ awaitHandlers: true,
+ requiredConcurrency: pending.size,
+ admitModel,
+ reject,
+ handleChainStart: (_chain, _inputs, runId, parentRunId, _tags, metadata, _runType, runName) => {
+ if (state !== 'pending') {
+ return;
+ }
+ if (parentRunId != null) {
+ parents.set(runId, parentRunId);
+ }
+ for (const agentId of pending) {
+ if (runName === `agent=${agentId}` && metadata?.langgraph_node === runName) {
+ rootNodes.set(runId, agentId);
+ break;
+ }
+ }
+ },
+ handleChatModelStart: () => {},
+ handleLLMEnd: () => {},
+ handleLLMError: (error) => reject(error),
+ handleChainEnd: (_output, runId) => {
+ const agentId = rootNodes.get(runId);
+ if (agentId != null && pending.has(agentId)) {
+ reject();
+ }
+ rootNodes.delete(runId);
+ parents.delete(runId);
+ },
+ handleChainError: (error) => reject(error),
+ } satisfies ProtectedInitialAdmission);
+}
+
+/** Ordinary resumed runs retain their legacy hook; captured runs use the coordinated barrier. */
+export function getPrivateTextModelHooks(
+ req: object | undefined,
+ initial: InitialModelBoundAdmissionCallback | ProtectedInitialAdmission | undefined,
+ start: Parameters<typeof getPrivateTextAdmission>[1],
+ cancel?: () => unknown,
+ onPersisted?: () => void,
+): {
+ onContentAllowed?: (context: ModelContext) => void | Promise<void>;
+ onContentRejected?: (error: unknown) => void;
+} {
+ if (initial != null && 'admitModel' in initial) {
+ return { onContentAllowed: initial.admitModel, onContentRejected: initial.reject };
+ }
+ return { onContentAllowed: getAdmission(req, start, onPersisted), onContentRejected: cancel };
+}
+
+export function withPrivateTextAdmissionConfig<T extends object>(
+ config: T & { maxConcurrency?: number },
+ initial?: InitialModelBoundAdmissionCallback | ProtectedInitialAdmission,
+): T & { callbacks?: InitialModelBoundAdmissionCallback[]; maxConcurrency?: number } {
+ return initial == null
+ ? config
+ : {
+ ...config,
+ callbacks: [initial],
+ ...('requiredConcurrency' in initial &&
+ config.maxConcurrency != null && {
+ maxConcurrency: Math.max(config.maxConcurrency, initial.requiredConcurrency),
+ }),
+ };
+}
diff --git a/packages/api/src/protection/private/copy.ts b/packages/api/src/protection/private/copy.ts
new file mode 100644
index 0000000000..4ec88e8ea2
--- /dev/null
+++ b/packages/api/src/protection/private/copy.ts
@@ -0,0 +1,99 @@
+import type { MessageMethods } from '@librechat/data-schemas';
+import type { ShareContentPreflight } from '../../shared-links/protection';
+import { getPrivateTextInspectionTokens } from './submission';
+
+type CopyMessage = {
+ readonly isCreatedByUser?: boolean;
+ readonly messageId?: string;
+ readonly text?: string;
+ readonly privacyRevision?: string;
+ readonly privateTextTokens?: readonly string[];
+};
+const copiedTokens = new WeakMap<object, readonly string[]>();
+
+/** Only native callers supply server-loaded source rows. External imports use the default. */
+export function saveCopiedMessage<T extends object>(
+ builder: { saveMessage: (message: T) => CopyMessage },
+ source: CopyMessage,
+ clone: T,
+ nativeCopy = false,
+): void {
+ const message = builder.saveMessage(clone);
+ if (!nativeCopy) {
+ return;
+ }
+ const trusted = copiedTokens.get(source) ?? [...getPrivateTextInspectionTokens([source])];
+ const tokens = trusted.filter((token) => message.text?.includes(token));
+ if (tokens.length > 0) {
+ copiedTokens.set(message, tokens);
+ }
+}
+
+export function getNativeCopyProvenance(messages: readonly CopyMessage[]): {
+ privateTextTokens: ReadonlyMap<string, readonly string[]>;
+} {
+ const tokens = new Map<string, readonly string[]>();
+ for (const message of messages) {
+ const trusted = copiedTokens.get(message);
+ if (message.messageId && trusted != null) {
+ tokens.set(message.messageId, trusted);
+ }
+ }
+ return { privateTextTokens: tokens };
+}
+
+export function getNativeCopyInspectionTokens(
+ messages: readonly CopyMessage[],
+): ReadonlySet<string> {
+ const tokens = new Set<string>();
+ for (const message of messages) {
+ for (const token of copiedTokens.get(message) ?? []) {
+ tokens.add(token);
+ }
+ }
+ return tokens;
+}
+
+/** No extra metadata or persistence work for ordinary imports. */
+export function saveNativeCopyMessages(
+ save: MessageMethods['bulkSaveMessages'],
+ messages: Parameters<MessageMethods['bulkSaveMessages']>[0],
+): Promise<unknown> {
+ const provenance = getNativeCopyProvenance(messages);
+ return provenance.privateTextTokens.size > 0
+ ? save(messages, true, provenance)
+ : save(messages, true);
+}
+
+export function transferNativeCopyProvenance<T extends object>(source: object, target: T): T {
+ const tokens = copiedTokens.get(source);
+ if (tokens != null) {
+ copiedTokens.set(target, tokens);
+ }
+ return target;
+}
+
+/** Public snapshots gain only internal provenance from their authorized canonical read. */
+export function createNativeCopyPreflight(
+ preflight?: ShareContentPreflight,
+): ShareContentPreflight {
+ return async (snapshot, context) => {
+ await preflight?.(snapshot, context);
+ const trusted = getPrivateTextInspectionTokens(context?.canonicalMessages ?? []);
+ for (const message of snapshot.messages) {
+ const tokens: string[] = [];
+ if (message.isCreatedByUser === true && typeof message.text === 'string') {
+ for (const match of message.text.matchAll(
+ /\[(?:EMAIL|PHONE|NAME|CREDENTIAL|CUSTOM)_\d+_[a-f0-9]{32}\]/g,
+ )) {
+ if (trusted.has(match[0])) {
+ tokens.push(match[0]);
+ }
+ }
+ }
+ if (tokens.length > 0) {
+ copiedTokens.set(message, tokens);
+ }
+ }
+ };
+}
diff --git a/packages/api/src/protection/private/crypto.ts b/packages/api/src/protection/private/crypto.ts
new file mode 100644
index 0000000000..20aa47451c
--- /dev/null
+++ b/packages/api/src/protection/private/crypto.ts
@@ -0,0 +1,53 @@
+import { createCipheriv, createDecipheriv, createHmac, hkdfSync, randomBytes } from 'node:crypto';
+
+export interface PrivateTextCipher {
+ seal(text: string, binding: readonly string[]): string;
+ open(envelope: string, binding: readonly string[]): string;
+ revision(value: readonly string[]): string;
+}
+
+/** Uses the deployment credential key, domain-separated from credential encryption. */
+export function createPrivateTextCipher(hexKey: string): PrivateTextCipher {
+ if (!/^[a-fA-F0-9]{64}$/.test(hexKey)) {
+ throw new Error('Private message encryption is unavailable.');
+ }
+ const key = Buffer.from(
+ hkdfSync('sha256', Buffer.from(hexKey, 'hex'), '', 'librechat-owner-text-v1', 32),
+ );
+ const aad = (binding: readonly string[]) =>
+ Buffer.from(JSON.stringify(['owner-text-v1', ...binding]));
+ return {
+ revision(value) {
+ return createHmac('sha256', key).update(aad(value)).digest('hex').slice(0, 32);
+ },
+ seal(text, binding) {
+ const nonce = randomBytes(12);
+ const cipher = createCipheriv('aes-256-gcm', key, nonce);
+ cipher.setAAD(aad(binding));
+ const ciphertext = Buffer.concat([cipher.update(text, 'utf8'), cipher.final()]);
+ return [
+ 'v1',
+ nonce.toString('base64'),
+ cipher.getAuthTag().toString('base64'),
+ ciphertext.toString('base64'),
+ ].join(':');
+ },
+ open(envelope, binding) {
+ try {
+ const [version, nonce, tag, ciphertext, extra] = envelope.split(':');
+ if (version !== 'v1' || extra != null || !nonce || !tag || ciphertext == null) {
+ throw new Error();
+ }
+ const decipher = createDecipheriv('aes-256-gcm', key, Buffer.from(nonce, 'base64'));
+ decipher.setAAD(aad(binding));
+ decipher.setAuthTag(Buffer.from(tag, 'base64'));
+ return Buffer.concat([
+ decipher.update(Buffer.from(ciphertext, 'base64')),
+ decipher.final(),
+ ]).toString('utf8');
+ } catch {
+ throw new Error('Private message text is unavailable.');
+ }
+ },
+ };
+}
diff --git a/packages/api/src/protection/private/submission.spec.ts b/packages/api/src/protection/private/submission.spec.ts
new file mode 100644
index 0000000000..808c6340c9
--- /dev/null
+++ b/packages/api/src/protection/private/submission.spec.ts
@@ -0,0 +1,641 @@
+import type { MessageMethods, IMessage } from '@librechat/data-schemas';
+import type { FiltersConfig } from 'librechat-data-provider';
+import type { Request, Response } from 'express';
+import {
+ createPrivateTextIngress,
+ savePrivateTextMessage,
+ stampPrivateTextMessage,
+ stampPreliminaryPrivateTextMessage,
+ requirePrivateTextPersistence,
+ saveAbortedUserMessage,
+ isPreDenialTextSubmission,
+ isPrivateTextChatSubmission,
+ getPreinspectedPrivateText,
+ getPrivateTextAdmission,
+ requirePrivateTextAdmission,
+ rejectPrivateTextAdmission,
+ savePrivateTextErrorTurn,
+ getPrivateTextInspectionTokens,
+ privateTextBinding,
+} from './submission';
+import {
+ createModelBoundChatModelCallback,
+ assertModelBoundContent,
+} from '../../middleware/modelBoundContent';
+import { createMessageFilterPii } from '../../middleware/messageFilterPii';
+import { ContentFilterError } from '../../middleware/contentFilter';
+import { createPrivateTextCipher } from './crypto';
+import { createPrivateTextView } from './view';
+
+jest.mock('@librechat/data-schemas', () => ({
+ logger: { warn: jest.fn(), info: jest.fn(), error: jest.fn(), debug: jest.fn() },
+}));
+
+const key = 'ab'.repeat(32);
+const original = 'Email [email protected]';
+const filters: FiltersConfig = {
+ messages: {
+ pii: {
+ action: 'redact',
+ fields: ['text'],
+ starterPatterns: [],
+ customPatterns: [
+ { id: 'email', label: 'Email', regex: '[a-z]+@[a-z]+\\.[a-z]+', category: 'email' },
+ ],
+ },
+ },
+};
+function submit(overrides: object = {}, encryptionKey = key) {
+ const req = {
+ path: '/',
+ user: { id: 'owner', tenantId: 'tenant-a' },
+ body: { text: original, clientRequestId: 'request-1', ...overrides },
+ } as unknown as Request;
+ const res = { status: jest.fn().mockReturnThis(), json: jest.fn(), setHeader: jest.fn() };
+ const next = jest.fn();
+ createPrivateTextIngress({
+ getFilters: () => filters,
+ getLegacyPii: () => undefined,
+ getKey: () => encryptionKey,
+ })(req, res as unknown as Response, next);
+ const message = stampPrivateTextMessage(req, {
+ messageId: 'message-1',
+ conversationId: 'conversation-1',
+ isCreatedByUser: true,
+ text: req.body.text,
+ });
+ return { req, res, next, message };
+}
+
+describe('private text submission boundary', () => {
+ it('limits early processing to interactive POSTs, excluding controls and queued work', () => {
+ for (const path of ['/api/agents/chat', '/api/agents/chat/safe-ephemeral']) {
+ expect(
+ isPrivateTextChatSubmission({
+ method: 'POST',
+ originalUrl: path,
+ body: { text: original },
+ } as Request),
+ ).toBe(true);
+ }
+ for (const path of [
+ '/api/agents/chat/abort',
+ '/api/agents/chat/resume',
+ '/api/agents/chat/queued-turns',
+ '/api/agents/chat/steer',
+ '/api/agents/chat/status/one',
+ ]) {
+ expect(
+ isPrivateTextChatSubmission({
+ method: 'POST',
+ originalUrl: path,
+ body: { text: original },
+ } as Request),
+ ).toBe(false);
+ }
+ expect(
+ isPreDenialTextSubmission({
+ method: 'POST',
+ body: { text: original },
+ } as Request),
+ ).toBe(true);
+ expect(
+ isPrivateTextChatSubmission({
+ method: 'GET',
+ originalUrl: '/api/agents/chat',
+ body: { text: original },
+ } as Request),
+ ).toBe(false);
+ });
+
+ it('preserves the exact encrypted user row on Stop and fails closed when missing', async () => {
+ const saveMessage: MessageMethods['saveMessage'] = jest.fn(
+ async (_ctx, message) => message as IMessage,
+ );
+ const hasPersistedPrivateText = jest.fn(
+ async (_input: Parameters<MessageMethods['hasPersistedPrivateText']>[0]) => true,
+ );
+ const getPrivateMessageTexts = jest.fn(async (): Promise<never[]> => []);
+ const store = {
+ saveMessage,
+ getPersistedPrivateTextId: async (
+ input: Parameters<MessageMethods['hasPersistedPrivateText']>[0],
+ ) => ((await hasPersistedPrivateText(input)) ? 'protected-row-id' : null),
+ getPrivateMessageTexts,
+ };
+ const { message } = submit();
+ expect(
+ await saveAbortedUserMessage(
+ store,
+ { userId: 'owner' },
+ message,
+ { context: 'Stop' },
+ 'tenant-a',
+ ),
+ ).toEqual({ _id: 'protected-row-id' });
+ expect(hasPersistedPrivateText).toHaveBeenCalledWith({
+ userId: 'owner',
+ tenantId: 'tenant-a',
+ conversationId: message.conversationId,
+ messageId: message.messageId,
+ text: message.text,
+ privacyRevision: message.privacyRevision,
+ });
+ expect(saveMessage).not.toHaveBeenCalled();
+ hasPersistedPrivateText.mockResolvedValueOnce(false);
+ await expect(
+ saveAbortedUserMessage(store, { userId: 'owner' }, message, { context: 'Stop' }, 'tenant-a'),
+ ).rejects.toThrow('private value');
+ expect(saveMessage).not.toHaveBeenCalled();
+ expect(
+ await saveAbortedUserMessage(
+ store,
+ { userId: 'owner' },
+ {
+ ...message,
+ text: 'ordinary turn without private values',
+ privacyRevision: undefined,
+ },
+ { context: 'ordinary Stop' },
+ 'tenant-a',
+ ),
+ ).toEqual({ _id: undefined });
+ expect(saveMessage).toHaveBeenCalledTimes(1);
+ });
+
+ it('checks old revisionless protected jobs against storage instead of overwriting them', async () => {
+ const { message } = submit();
+ const saveMessage = jest.fn(async () => message as IMessage);
+ const getPrivateMessageTexts = jest.fn(async () => [
+ {
+ messageId: message.messageId!,
+ text: message.text!,
+ privacyRevision: message.privacyRevision!,
+ privateText: 'v1:encrypted',
+ },
+ ]);
+ const store = {
+ saveMessage,
+ getPersistedPrivateTextId: jest.fn(async (): Promise<string | null> => 'protected-row-id'),
+ getPrivateMessageTexts,
+ };
+ const finalEvent = { requestMessage: { messageId: message.messageId, privacyRevision: '' } };
+ const older = { ...message, privacyRevision: undefined };
+ expect(
+ await saveAbortedUserMessage(
+ store,
+ { userId: 'owner' },
+ older,
+ undefined,
+ 'tenant-a',
+ finalEvent,
+ ),
+ ).toEqual({ _id: undefined });
+ expect(saveMessage).toHaveBeenCalledWith({ userId: 'owner' }, older, { insertOnly: true });
+ expect(finalEvent.requestMessage.privacyRevision).toBe(message.privacyRevision);
+ store.getPersistedPrivateTextId.mockResolvedValueOnce(null);
+ await expect(
+ saveAbortedUserMessage(store, { userId: 'owner' }, older, undefined, 'tenant-a'),
+ ).rejects.toThrow('private value');
+ expect(saveMessage).toHaveBeenCalledTimes(2);
+ });
+
+ it.each([true, false])(
+ 'stops a revisionless literal placeholder, existing row: %s',
+ async (existing) => {
+ const message = {
+ messageId: 'literal-token',
+ conversationId: 'conversation',
+ isCreatedByUser: true,
+ text: `[EMAIL_1_${'a'.repeat(32)}]`,
+ };
+ const saveMessage = jest.fn(async () =>
+ Object.assign(message as IMessage, { _id: existing ? 'existing' : 'inserted' }),
+ );
+ const getPersistedPrivateTextId = jest.fn(async () => null);
+ expect(
+ await saveAbortedUserMessage(
+ { saveMessage, getPersistedPrivateTextId },
+ { userId: 'owner' },
+ message,
+ undefined,
+ ),
+ ).toEqual({ _id: existing ? 'existing' : 'inserted' });
+ expect(saveMessage).toHaveBeenCalledWith({ userId: 'owner' }, message, { insertOnly: true });
+ expect(getPersistedPrivateTextId).not.toHaveBeenCalled();
+ },
+ );
+
+ it('stamps a protected preliminary job message before the created event', () => {
+ const { req, message } = submit();
+ const preliminary = stampPreliminaryPrivateTextMessage(req, {
+ messageId: message.messageId,
+ conversationId: message.conversationId,
+ text: message.text,
+ });
+ expect(preliminary?.privacyRevision).toBe(message.privacyRevision);
+ expect(JSON.stringify(preliminary)).not.toContain(original);
+ expect(stampPreliminaryPrivateTextMessage(req, null)).toBeNull();
+ });
+
+ it('replaces request text before consumers and exposes no original in metadata or serialization', () => {
+ const { req, message, next } = submit();
+ expect(next).toHaveBeenCalledTimes(1);
+ expect(req.body.text).toMatch(/^Email \[EMAIL_1_[a-f0-9]{32}\]$/);
+ expect(message).toHaveProperty('privacyRevision');
+ expect(JSON.stringify({ req, message })).not.toContain('[email protected]');
+ });
+
+ it('skips only the verified, preinspected text in the second PII pass', async () => {
+ const patterns: FiltersConfig = {
+ messages: {
+ pii: {
+ action: 'redact',
+ fields: ['text'],
+ starterPatterns: [],
+ customPatterns: [
+ { id: 'email', label: 'Email', regex: 'alice@example\\.com', category: 'email' },
+ { id: 'revision', label: 'Credential', regex: '[a-f0-9]{32}', category: 'credential' },
+ ],
+ },
+ },
+ };
+ const req = {
+ path: '/',
+ user: { id: 'owner', tenantId: 'tenant-a' },
+ body: {
+ text: original,
+ clientRequestId: 'hex-rule-1',
+ input: undefined as string | undefined,
+ },
+ } as unknown as Request;
+ const res = { status: jest.fn().mockReturnThis(), json: jest.fn() };
+ const ingressNext = jest.fn();
+ createPrivateTextIngress({
+ getFilters: () => patterns,
+ getLegacyPii: () => undefined,
+ getKey: () => key,
+ })(req, res as unknown as Response, ingressNext);
+ expect(ingressNext).toHaveBeenCalledTimes(1);
+ expect(req.body.text).toMatch(/\[EMAIL_1_[a-f0-9]{32}\]/);
+ expect(getPreinspectedPrivateText(req)).toBe(req.body.text);
+
+ const secondPass = createMessageFilterPii({
+ getConfig: () => undefined,
+ getFilters: () => patterns,
+ getPreinspectedText: getPreinspectedPrivateText,
+ });
+ const next = jest.fn();
+ await secondPass(req, res as unknown as Response, next);
+ expect(next).toHaveBeenCalledTimes(1);
+ expect(res.status).not.toHaveBeenCalled();
+
+ req.body.input = original;
+ await secondPass(req, res as unknown as Response, next);
+ expect(res.status).toHaveBeenCalledWith(400);
+ expect(next).toHaveBeenCalledTimes(1);
+ req.body.input = undefined;
+ req.body.text = original;
+ expect(getPreinspectedPrivateText(req)).toBeUndefined();
+ await secondPass(req, res as unknown as Response, next);
+ expect(res.status).toHaveBeenCalledTimes(2);
+ });
+
+ it('keeps trusted placeholders safe through every provider call, including restored history', () => {
+ const { message } = submit();
+ const patterns: FiltersConfig = {
+ messages: {
+ pii: {
+ action: 'redact',
+ fields: ['text', 'content_part', 'assembled_context'],
+ starterPatterns: [],
+ customPatterns: [
+ { id: 'email', label: 'Email', regex: 'alice@example\\.com', category: 'email' },
+ { id: 'hex', label: 'Credential', regex: '[a-f0-9]{32}', category: 'credential' },
+ ],
+ },
+ },
+ };
+ const privateTextTokens = getPrivateTextInspectionTokens([message]);
+ expect(privateTextTokens.size).toBe(1);
+ const providerMessage = { role: 'user', content: message.text };
+ const storedMessages = [{ ...message, role: 'user' }];
+ const callback = createModelBoundChatModelCallback({
+ filters: patterns,
+ storedMessages,
+ privateTextTokens,
+ });
+ expect(() => callback.handleChatModelStart(undefined, [[providerMessage]])).not.toThrow();
+ expect(() =>
+ callback.handleChatModelStart(undefined, [
+ [providerMessage, { role: 'user', content: 'Follow up' }],
+ ]),
+ ).not.toThrow();
+ const restored = createModelBoundChatModelCallback({
+ filters: patterns,
+ storedMessages: JSON.parse(JSON.stringify(storedMessages)) as typeof storedMessages,
+ privateTextTokens: getPrivateTextInspectionTokens(
+ JSON.parse(JSON.stringify(storedMessages)) as typeof storedMessages,
+ ),
+ });
+ expect(() => restored.handleChatModelStart(undefined, [[providerMessage]])).not.toThrow();
+ for (const unsafe of [
+ original,
+ `${message.text} ${'f'.repeat(32)}`,
+ `Email [EMAIL_1_${'f'.repeat(32)}]`,
+ ]) {
+ expect(() =>
+ callback.handleChatModelStart(undefined, [[{ role: 'user', content: unsafe }]]),
+ ).toThrow();
+ }
+ expect(getPrivateTextInspectionTokens([{ ...message, privacyRevision: undefined }]).size).toBe(
+ 0,
+ );
+ expect(
+ getPrivateTextInspectionTokens([{ ...message, privacyRevision: 'f'.repeat(32) }]).size,
+ ).toBe(0);
+ const untrusted = createModelBoundChatModelCallback({
+ filters: patterns,
+ storedMessages: [],
+ privateTextTokens: new Set(),
+ });
+ expect(() => untrusted.handleChatModelStart(undefined, [[providerMessage]])).toThrow();
+ expect(() =>
+ assertModelBoundContent({
+ filters: {
+ ...patterns,
+ agentInstructions: {
+ pii: { customPatterns: [{ id: 'hex', label: 'Credential', regex: '[a-f0-9]{32}' }] },
+ },
+ },
+ privateTextTokens,
+ agents: [{ instructions: message.text }],
+ }),
+ ).toThrow();
+ });
+
+ it('uses stable retry revisions and distinct namespaces for different turns or originals', () => {
+ const first = submit().message;
+ expect(submit().message).toEqual(first);
+ expect(submit({ clientRequestId: 'request-2' }).message.text).not.toBe(first.text);
+ expect(submit({ text: 'Email [email protected]' }).message.text).not.toBe(first.text);
+ });
+
+ it.each([
+ { files: [{}] },
+ { quotes: ['quote'] },
+ { isRegenerate: true },
+ { isEdited: true },
+ { isContinued: true },
+ { editedContent: {} },
+ { recoverySteerId: 'steer' },
+ ])('leaves unsupported submissions to the existing blocking inspector: %j', (extra) => {
+ const { req, next, message } = submit(extra);
+ expect(req.body.text).toBe(original);
+ expect(message).not.toHaveProperty('privacyRevision');
+ expect(next).toHaveBeenCalledTimes(1);
+ });
+
+ it('fails closed without a valid key and does not echo matched text', () => {
+ const { next, res } = submit({}, '');
+ expect(next).not.toHaveBeenCalled();
+ expect(res.status).toHaveBeenCalledWith(400);
+ expect(JSON.stringify(res.json.mock.calls)).not.toContain(original);
+ });
+
+ it('commits canonical text and ciphertext together and binds the owner view to final identity', async () => {
+ const { req, message } = submit();
+ let envelope = '';
+ const save: MessageMethods['saveMessage'] = jest.fn(async (_ctx, value, metadata) => {
+ envelope = metadata?.privateText?.envelope ?? '';
+ expect(JSON.stringify({ value, metadata })).not.toContain(original);
+ return { ...value, privacyRevision: metadata?.privateText?.revision } as IMessage;
+ });
+ const stored = await savePrivateTextMessage(save, req, { userId: 'owner' }, message);
+ expect(save).toHaveBeenCalledTimes(1);
+ const cipher = createPrivateTextCipher(key);
+ const binding = privateTextBinding('owner', 'tenant-a', stored!);
+ expect(cipher.open(envelope, binding)).toBe(original);
+ for (let index = 0; index < binding.length; index++) {
+ const tampered = [...binding];
+ tampered[index] += '-changed';
+ expect(() => cipher.open(envelope, tampered)).toThrow('Private message text is unavailable.');
+ }
+ expect(() => createPrivateTextCipher('cd'.repeat(32)).open(envelope, binding)).toThrow();
+ expect(() => cipher.open(envelope.slice(0, -4) + 'abcd', binding)).toThrow();
+ await expect(savePrivateTextMessage(save, req, { userId: 'other' }, message)).rejects.toThrow();
+ });
+
+ it('does not release main provider admission until persistence finishes', async () => {
+ const { req, message } = submit();
+ let finish!: (result: { message: typeof message }) => void;
+ const pending = new Promise<{ message: typeof message }>((resolve) => {
+ finish = resolve;
+ });
+ const provider = jest.fn();
+ const started = requirePrivateTextPersistence(req, () => pending).then(provider);
+ await Promise.resolve();
+ expect(provider).not.toHaveBeenCalled();
+ finish({ message });
+ await started;
+ expect(provider).toHaveBeenCalledTimes(1);
+ await expect(requirePrivateTextPersistence(req, async () => ({}))).rejects.toThrow();
+ await expect(
+ requirePrivateTextPersistence(req, async () => {
+ throw new Error('write failed');
+ }),
+ ).rejects.toThrow();
+ });
+
+ it('requires a persistence gate for a captured turn before allowing any model callback', () => {
+ const { req } = submit();
+ expect(() => getPrivateTextAdmission(req, undefined)).toThrow(
+ expect.objectContaining({ code: 'content_filter_block' }),
+ );
+ expect(getPrivateTextAdmission(undefined, undefined)).toBeUndefined();
+ expect(getPrivateTextAdmission({}, undefined)).toBeUndefined();
+ });
+
+ it.each(['failure', 'rejection', 'abort'])(
+ 'suppresses side effects on protected %s',
+ async (outcome) => {
+ const { req, message } = submit();
+ const abortController = new AbortController();
+ const sideEffect = jest.fn();
+ const pending = requirePrivateTextAdmission(req, abortController.signal).then(sideEffect);
+ await Promise.resolve();
+ expect(sideEffect).not.toHaveBeenCalled();
+ if (outcome === 'abort') {
+ abortController.abort();
+ } else {
+ rejectPrivateTextAdmission(req);
+ }
+ await expect(pending).rejects.toThrow();
+ expect(sideEffect).not.toHaveBeenCalled();
+ expect(message.text).not.toContain(original);
+ },
+ );
+
+ it('holds optional side effects until the admitted atomic write finishes', async () => {
+ const { req, message } = submit();
+ const sideEffect = jest.fn();
+ const waiting = requirePrivateTextAdmission(req).then(sideEffect);
+ let finish!: (result: { message: typeof message }) => void;
+ const write = new Promise<{ message: typeof message }>((resolve) => {
+ finish = resolve;
+ });
+ const admitted = getPrivateTextAdmission(req, () => write)!();
+ await Promise.resolve();
+ expect(sideEffect).not.toHaveBeenCalled();
+ finish({ message });
+ await admitted;
+ await waiting;
+ expect(sideEffect).toHaveBeenCalledTimes(1);
+ });
+
+ function policyError() {
+ return new ContentFilterError({
+ detectorId: 'pii-pattern',
+ ruleId: 'secret',
+ label: 'secret',
+ source: 'message',
+ field: 'text',
+ provenance: 'user',
+ fragmentId: 'history',
+ fragmentPath: '/text',
+ });
+ }
+
+ it('rejects terminal recovery before any write when protected content admission failed', async () => {
+ const { req, message } = submit();
+ const saveErrorTurn = jest.fn(async () => {});
+ await savePrivateTextErrorTurn(req, policyError(), saveErrorTurn);
+ expect(saveErrorTurn).not.toHaveBeenCalled();
+ const save = jest.fn(async () => message as IMessage);
+ await expect(savePrivateTextMessage(save, req, { userId: 'owner' }, message)).rejects.toThrow();
+ expect(save).not.toHaveBeenCalled();
+ const start = jest.fn(async () => ({ message }));
+ await expect(requirePrivateTextPersistence(req, start)).rejects.toThrow();
+ expect(start).not.toHaveBeenCalled();
+ });
+
+ it('cannot revive failed persistence through terminal recovery or a later admission', async () => {
+ const { req, message } = submit();
+ await expect(requirePrivateTextPersistence(req, async () => ({}))).rejects.toThrow();
+ const recovery = jest.fn(async () => {});
+ await savePrivateTextErrorTurn(req, new Error('persistence failure'), recovery);
+ expect(recovery).not.toHaveBeenCalled();
+ await expect(requirePrivateTextPersistence(req, async () => ({ message }))).rejects.toThrow();
+ });
+
+ it('does not announce a write that resolves after an admission rejection', async () => {
+ const { req, message } = submit();
+ let finish!: (result: { message: typeof message }) => void;
+ const write = new Promise<{ message: typeof message }>((resolve) => {
+ finish = resolve;
+ });
+ const announce = jest.fn();
+ const admission = requirePrivateTextPersistence(req, () => write, announce);
+ rejectPrivateTextAdmission(req);
+ finish({ message });
+ await expect(admission).rejects.toThrow();
+ expect(announce).not.toHaveBeenCalled();
+ });
+
+ it('retains ordinary error recovery and already-admitted protected turns', async () => {
+ const ordinary = jest.fn(async () => {});
+ await savePrivateTextErrorTurn({}, policyError(), ordinary);
+ expect(ordinary).toHaveBeenCalledTimes(1);
+ const { req, message } = submit();
+ await requirePrivateTextPersistence(req, async () => ({ message }));
+ rejectPrivateTextAdmission(req); // Terminal cleanup cannot undo a committed admission.
+ const recovery = jest.fn(async () => {});
+ await savePrivateTextErrorTurn(req, policyError(), recovery);
+ expect(recovery).toHaveBeenCalledTimes(1);
+ await expect(requirePrivateTextAdmission(req)).resolves.toBeUndefined();
+ });
+
+ it('rejects stale or swallowed persistence results, including a duplicate ID with different text', async () => {
+ const { req, message } = submit();
+ const save: MessageMethods['saveMessage'] = jest.fn(async () => undefined);
+ await expect(savePrivateTextMessage(save, req, { userId: 'owner' }, message)).rejects.toThrow();
+ await expect(
+ requirePrivateTextPersistence(req, async () => ({ message: { ...message, text: 'stale' } })),
+ ).rejects.toThrow();
+ });
+
+ it('returns original text only from the authenticated private view, with no-store headers', async () => {
+ const { req, message } = submit();
+ const cipher = createPrivateTextCipher(key);
+ const row = {
+ ...message,
+ privacyRevision: message.privacyRevision!,
+ privateText: cipher.seal(original, privateTextBinding('owner', 'tenant-a', message)),
+ };
+ const read = jest.fn(async () => [row]);
+ const handler = createPrivateTextView({ read, getKey: () => key });
+ req.params = { conversationId: 'conversation-1' };
+ req.body = { messageIds: ['message-1'] };
+ const res = { status: jest.fn().mockReturnThis(), json: jest.fn(), setHeader: jest.fn() };
+ await handler(req, res as unknown as Response, jest.fn());
+ expect(read).toHaveBeenCalledWith({
+ userId: 'owner',
+ tenantId: 'tenant-a',
+ conversationId: 'conversation-1',
+ messageIds: ['message-1'],
+ });
+ expect(res.setHeader).toHaveBeenCalledWith('Cache-Control', 'private, no-store');
+ expect(res.json).toHaveBeenCalledWith({
+ messages: [
+ {
+ messageId: 'message-1',
+ revision: row.privacyRevision,
+ canonicalText: row.text,
+ text: original,
+ },
+ ],
+ });
+ req.body.messageIds = Array(51).fill('message-1');
+ await handler(req, res as unknown as Response, jest.fn());
+ expect(res.status).toHaveBeenLastCalledWith(400);
+ expect(read).toHaveBeenCalledTimes(1);
+ await handler(
+ { params: req.params, body: { messageIds: ['message-1'] } } as Request,
+ res as unknown as Response,
+ jest.fn(),
+ );
+ expect(res.status).toHaveBeenLastCalledWith(401);
+ expect(read).toHaveBeenCalledTimes(1);
+ });
+
+ it('returns no original when a stored row has changed canonical text or the key is unavailable', async () => {
+ const { message, req } = submit();
+ const cipher = createPrivateTextCipher(key);
+ const privateText = cipher.seal(original, privateTextBinding('owner', 'tenant-a', message));
+ const read = jest.fn(async () => [
+ {
+ ...message,
+ text: 'edited canonical',
+ privacyRevision: message.privacyRevision!,
+ privateText,
+ },
+ ]);
+ req.params = { conversationId: 'conversation-1' };
+ req.body = { messageIds: ['message-1'] };
+ const res = { status: jest.fn().mockReturnThis(), json: jest.fn(), setHeader: jest.fn() };
+ await createPrivateTextView({ read, getKey: () => key })(
+ req,
+ res as unknown as Response,
+ jest.fn(),
+ );
+ expect(JSON.stringify(res.json.mock.calls)).not.toContain(original);
+ expect(res.status).toHaveBeenLastCalledWith(200);
+ await createPrivateTextView({ read, getKey: () => '' })(
+ req,
+ res as unknown as Response,
+ jest.fn(),
+ );
+ expect(res.status).toHaveBeenLastCalledWith(503);
+ expect(JSON.stringify(res.json.mock.calls)).not.toContain(original);
+ });
+});
diff --git a/packages/api/src/protection/private/submission.ts b/packages/api/src/protection/private/submission.ts
new file mode 100644
index 0000000000..5921f901a3
--- /dev/null
+++ b/packages/api/src/protection/private/submission.ts
@@ -0,0 +1,612 @@
+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 };
+}
diff --git a/packages/api/src/protection/private/view.ts b/packages/api/src/protection/private/view.ts
new file mode 100644
index 0000000000..76ebd57b0e
--- /dev/null
+++ b/packages/api/src/protection/private/view.ts
@@ -0,0 +1,73 @@
+import { z } from 'zod';
+import type { MessageMethods } from '@librechat/data-schemas';
+import type { RequestHandler, Request } from 'express';
+import { createPrivateTextCipher } from './crypto';
+import { privateTextBinding } from './submission';
+
+/** Defense in depth for search hits and mutation responses that bypass normal Mongo projections. */
+export function stripPrivateMessageFields<
+ T extends { privateText?: unknown; contextMeta?: unknown },
+>(message: T): Omit<T, 'privateText' | 'contextMeta'> {
+ const { privateText: _privateText, contextMeta: _contextMeta, ...publicMessage } = message;
+ return publicMessage;
+}
+
+const inputSchema = z
+ .object({
+ messageIds: z.array(z.string().min(1).max(256)).min(1).max(50),
+ })
+ .strict();
+
+export function createPrivateTextView(options: {
+ read: MessageMethods['getPrivateMessageTexts'];
+ getKey(): string;
+}): RequestHandler {
+ return async (req, res) => {
+ res.setHeader('Cache-Control', 'private, no-store');
+ const request = req as Request & { user?: { id?: string; tenantId?: string | null } };
+ const userId = request.user?.id;
+ if (!userId) {
+ res.status(401).json({ error: 'Unauthorized' });
+ return;
+ }
+ const input = inputSchema.safeParse(req.body);
+ const conversationId = req.params.conversationId;
+ if (!input.success || typeof conversationId !== 'string') {
+ res.status(400).json({ error: 'Invalid private message request' });
+ return;
+ }
+ try {
+ const tenantId = request.user?.tenantId ?? '';
+ const rows = await options.read({
+ userId,
+ tenantId: tenantId || undefined,
+ conversationId,
+ messageIds: input.data.messageIds,
+ });
+ const cipher = createPrivateTextCipher(options.getKey());
+ const messages = rows.map((row) => {
+ try {
+ const text = cipher.open(
+ row.privateText,
+ privateTextBinding(userId, tenantId, { ...row, conversationId }),
+ );
+ return {
+ messageId: row.messageId,
+ revision: row.privacyRevision,
+ canonicalText: row.text,
+ text,
+ };
+ } catch {
+ return {
+ messageId: row.messageId,
+ revision: row.privacyRevision,
+ canonicalText: row.text,
+ };
+ }
+ });
+ res.status(200).json({ messages });
+ } catch {
+ res.status(503).json({ error: 'Private message text is unavailable.' });
+ }
+ };
+}
diff --git a/packages/api/src/shared-links/protection.spec.ts b/packages/api/src/shared-links/protection.spec.ts
index 86cf9eee6e..f6690f2b35 100644
--- a/packages/api/src/shared-links/protection.spec.ts
+++ b/packages/api/src/shared-links/protection.spec.ts
@@ -32,6 +32,44 @@ function capturePolicyError(
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: {
diff --git a/packages/api/src/shared-links/protection.ts b/packages/api/src/shared-links/protection.ts
index 5a788a28b1..dafe96032f 100644
--- a/packages/api/src/shared-links/protection.ts
+++ b/packages/api/src/shared-links/protection.ts
@@ -33,6 +33,7 @@ import {
extractFileContent,
extractStoredMessageContent,
} from '../protection/adapters/submissions';
+import { getPrivateTextInspectionTokens } from '../protection/private/submission';
import { assertModelBoundContent } from '../middleware/modelBoundContent';
import { getUserSubmittedPathState } from '../protection/provenance';
import { assertConversationImportContentAllowed } from '../imports';
@@ -69,6 +70,7 @@ interface SerializedSharedMessagePart {
}
export interface SerializedSharedMessage {
+ readonly privacyRevision?: string;
readonly isCreatedByUser?: boolean;
readonly isUserSubmitted?: boolean;
readonly userSubmittedPaths?: readonly string[];
@@ -111,7 +113,17 @@ export interface ShareContentPreflightOptions {
readonly sharedFileMetadataFiles?: boolean;
}
-export type ShareContentPreflight = (input: ShareContentPreflightInput) => Promise<void>;
+export type ShareContentPreflight = (
+ input: ShareContentPreflightInput,
+ context?: {
+ readonly canonicalMessages: readonly {
+ readonly text?: string;
+ readonly isCreatedByUser?: boolean;
+ readonly privacyRevision?: string;
+ readonly privateTextTokens?: readonly string[];
+ }[];
+ },
+) => Promise<void>;
function omitUnsharedMessageFiles(
messages: readonly ShareContentPreflightMessage[],
@@ -142,11 +154,10 @@ export function createShareContentPreflight(
return undefined;
}
- const inspectSharedContent = async ({
- title,
- messages,
- shareId,
- }: ShareContentPreflightInput): Promise<void> => {
+ const inspectSharedContent = async (
+ { title, messages, shareId }: ShareContentPreflightInput,
+ context?: Parameters<ShareContentPreflight>[1],
+ ): Promise<void> => {
const inspectSharedFileMetadata = options.sharedFileMetadata === true;
const inspectSharedFiles =
inspectSharedFileMetadata && options.sharedFileMetadataFiles !== false;
@@ -165,6 +176,9 @@ export function createShareContentPreflight(
user: options.user,
getFiles: options.getFiles,
onTraversalFailure: options.onTraversalFailure,
+ privateTextTokens: getPrivateTextInspectionTokens(
+ context?.canonicalMessages ?? snapshotMessages,
+ ),
},
);
if (!inspectSharedFileMetadata) {
@@ -178,7 +192,7 @@ export function createShareContentPreflight(
});
};
- return (input) => aggregateAuditFindings(() => inspectSharedContent(input));
+ return (input, context) => aggregateAuditFindings(() => inspectSharedContent(input, context));
}
const SERIALIZED_LOCATOR_KEYS = [
diff --git a/packages/api/src/stream/GenerationJobManager.ts b/packages/api/src/stream/GenerationJobManager.ts
index 4588a440ce..40869e850f 100644
--- a/packages/api/src/stream/GenerationJobManager.ts
+++ b/packages/api/src/stream/GenerationJobManager.ts
@@ -4832,6 +4832,7 @@ class GenerationJobManagerClass {
conversationId: jobData.conversationId,
text: jobData.userMessage.text ?? '',
quotes: jobData.userMessage.quotes,
+ privacyRevision: jobData.userMessage.privacyRevision,
isCreatedByUser: true,
}
: null,
@@ -7954,6 +7955,7 @@ class GenerationJobManagerClass {
conversationId: message.conversationId,
text: message.text,
quotes: message.quotes,
+ privacyRevision: message.privacyRevision,
// Persist the turn's uploaded files so a HITL resume sources them from the job
// (this authoritative writer), not a user DB row whose save can still be racing
// the approval prompt.
diff --git a/packages/api/src/stream/__tests__/startup.spec.ts b/packages/api/src/stream/__tests__/startup.spec.ts
index f85cb84d53..90197a343e 100644
--- a/packages/api/src/stream/__tests__/startup.spec.ts
+++ b/packages/api/src/stream/__tests__/startup.spec.ts
@@ -637,6 +637,59 @@ describe('GenerationJobManager startup telemetry', () => {
await manager.destroy();
});
+ it('carries only canonical protected text and revision from created through abort', async () => {
+ const manager = createManager();
+ const streamId = 'stream-protected-stop';
+ const text = 'Email [EMAIL_1_0123456789abcdef0123456789abcdef]';
+ const revision = '0123456789abcdef0123456789abcdef';
+ const job = await manager.createJob(streamId, 'owner', streamId, {
+ initialMetadata: {
+ responseMessageId: 'response-1',
+ userMessage: {
+ messageId: 'user-1',
+ conversationId: streamId,
+ text,
+ privacyRevision: revision,
+ },
+ },
+ });
+ const created: ServerSentEvent = {
+ created: true,
+ streamId,
+ message: {
+ messageId: 'user-1',
+ conversationId: streamId,
+ sender: 'User',
+ isCreatedByUser: true,
+ text,
+ privacyRevision: revision,
+ },
+ };
+ try {
+ await manager.emitChunk(streamId, created, { expectedCreatedAt: job.createdAt });
+ expect((await manager.getJob(streamId))?.metadata.userMessage).toMatchObject({
+ messageId: 'user-1',
+ text,
+ privacyRevision: revision,
+ });
+ const result = await manager.abortJob(streamId, {
+ expectedCreatedAt: job.createdAt,
+ beforePublish: async (pending) => {
+ expect(pending.jobData?.userMessage).toMatchObject({ text, privacyRevision: revision });
+ expect(pending.finalEvent).toMatchObject({
+ requestMessage: { text, privacyRevision: revision },
+ });
+ },
+ });
+ expect(result.finalEvent).toMatchObject({
+ requestMessage: { messageId: 'user-1', text, privacyRevision: revision },
+ });
+ expect(JSON.stringify(result)).not.toContain('[email protected]');
+ } finally {
+ await manager.destroy();
+ }
+ });
+
it('ends an active startup when the manager shuts down', async () => {
const manager = createManager();
const telemetry = createTelemetry();
diff --git a/packages/api/src/stream/interfaces/IJobStore.ts b/packages/api/src/stream/interfaces/IJobStore.ts
index 2e7d471b36..5f1681979c 100644
--- a/packages/api/src/stream/interfaces/IJobStore.ts
+++ b/packages/api/src/stream/interfaces/IJobStore.ts
@@ -153,6 +153,7 @@ export interface SerializableJobData {
parentMessageId?: string;
conversationId?: string;
text?: string;
+ privacyRevision?: string;
/** Quoted excerpts referenced on this turn, carried so resumable/aborted
* reconstructions of the user message keep their `MessageQuotes`. */
quotes?: string[];
diff --git a/packages/api/src/types/events.ts b/packages/api/src/types/events.ts
index 90194b9e51..c32b11b148 100644
--- a/packages/api/src/types/events.ts
+++ b/packages/api/src/types/events.ts
@@ -14,6 +14,7 @@ export type CreatedEvent = {
parentMessageId?: string;
conversationId?: string;
text?: string;
+ privacyRevision?: string;
sender: string;
isCreatedByUser: boolean;
/** Quoted excerpts referenced on this turn, carried through resumable job
diff --git a/packages/data-provider/src/data-service.ts b/packages/data-provider/src/data-service.ts
index 4b2087e2de..42f273add2 100644
--- a/packages/data-provider/src/data-service.ts
+++ b/packages/data-provider/src/data-service.ts
@@ -1139,6 +1139,21 @@ export const branchMessage = async (
return request.post(endpoints.messagesBranch(), payload);
};
+export interface OwnerMessageText {
+ canonicalText: string;
+ messageId: string;
+ revision: string;
+ text?: string;
+}
+
+/** Private display data; never merge into ordinary message/query-cache objects. */
+export function getOwnerMessageTexts(
+ conversationId: string,
+ messageIds: string[],
+): Promise<{ messages: OwnerMessageText[] }> {
+ return request.post(`${endpoints.messages({ conversationId })}/owner-text`, { messageIds });
+}
+
export function getMessagesByConvoId(conversationId: string): Promise<s.TMessage[]> {
if (
conversationId === config.Constants.NEW_CONVO ||
diff --git a/packages/data-provider/src/keys.ts b/packages/data-provider/src/keys.ts
index 73e5816521..2d7a60f4a3 100644
--- a/packages/data-provider/src/keys.ts
+++ b/packages/data-provider/src/keys.ts
@@ -1,5 +1,6 @@
export enum QueryKeys {
messages = 'messages',
+ ownerMessageTexts = 'ownerMessageTexts',
sharedMessages = 'sharedMessages',
sharedStartupConfig = 'sharedStartupConfig',
sharedLinks = 'sharedLinks',
diff --git a/packages/data-provider/src/schemas.ts b/packages/data-provider/src/schemas.ts
index cfc0c38b99..c3960e60f0 100644
--- a/packages/data-provider/src/schemas.ts
+++ b/packages/data-provider/src/schemas.ts
@@ -944,6 +944,8 @@ export const tMessageSchema = z.object({
/** @deprecated */
generation: z.string().nullable().optional(),
isCreatedByUser: z.boolean(),
+ /** Opaque revision of the separately authorized owner display. */
+ privacyRevision: z.string().optional(),
/** True when the complete stored row came from outside the model. */
isUserSubmitted: z.boolean().optional(),
/** JSON pointers to caller-authored fields in an otherwise mixed model response. */
diff --git a/packages/data-provider/src/types/agents.ts b/packages/data-provider/src/types/agents.ts
index 86c5fc4620..6ac03ee631 100644
--- a/packages/data-provider/src/types/agents.ts
+++ b/packages/data-provider/src/types/agents.ts
@@ -298,6 +298,8 @@ export namespace Agents {
/** User message metadata for rebuilding submission on reconnect */
export interface UserMessageMeta {
+ /** Canonical, nonsecret revision used to verify owner-only private text. */
+ privacyRevision?: string;
messageId: string;
parentMessageId?: string;
conversationId?: string;
diff --git a/packages/data-schemas/src/methods/message.privateText.spec.ts b/packages/data-schemas/src/methods/message.privateText.spec.ts
new file mode 100644
index 0000000000..816e1b8198
--- /dev/null
+++ b/packages/data-schemas/src/methods/message.privateText.spec.ts
@@ -0,0 +1,434 @@
+import mongoose from 'mongoose';
+import { v4 as uuid } from 'uuid';
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import { createMessageMethods, CLIENT_MESSAGE_SELECT } from './message';
+import { tenantStorage, runAsSystem } from '~/config/tenantContext';
+import { createModels } from '../models';
+
+jest.mock('~/config/winston', () => ({
+ error: jest.fn(),
+ warn: jest.fn(),
+ info: jest.fn(),
+ debug: jest.fn(),
+}));
+
+let server: MongoMemoryServer;
+const methods = createMessageMethods(mongoose);
+const tenant = <T>(id: string, fn: () => T) => tenantStorage.run({ tenantId: id }, fn);
+
+beforeAll(async () => {
+ server = await MongoMemoryServer.create();
+ Object.assign(mongoose.models, createModels(mongoose));
+ await mongoose.connect(server.getUri());
+ await mongoose.models.Message.createIndexes();
+});
+afterAll(async () => {
+ await mongoose.disconnect();
+ await server?.stop();
+});
+afterEach(async () => {
+ await runAsSystem(() => mongoose.models.Message.deleteMany({}));
+});
+
+it('stores both views atomically and excludes ciphertext from ordinary and client reads', async () => {
+ const conversationId = uuid();
+ const messageId = uuid();
+ await tenant('tenant-a', async () => {
+ const saved = await methods.saveMessage(
+ { userId: 'owner' },
+ {
+ messageId,
+ conversationId,
+ text: '[EMAIL_1_turn]',
+ isCreatedByUser: true,
+ },
+ { privateText: { envelope: 'v1:ciphertext', revision: 'turn' } },
+ );
+ expect(saved?.privacyRevision).toBe('turn');
+ expect(saved).not.toHaveProperty('privateText');
+ for (const projection of [undefined, CLIENT_MESSAGE_SELECT]) {
+ const rows = await methods.getMessages({ conversationId, user: 'owner' }, projection);
+ expect(rows[0].text).toBe('[EMAIL_1_turn]');
+ expect(rows[0]).not.toHaveProperty('privateText');
+ }
+ const own = await methods.getPrivateMessageTexts({
+ userId: 'owner',
+ tenantId: 'tenant-a',
+ conversationId,
+ messageIds: [messageId],
+ });
+ expect(own[0]).toMatchObject({
+ privateText: 'v1:ciphertext',
+ privacyRevision: 'turn',
+ text: '[EMAIL_1_turn]',
+ });
+ const protectedRow = {
+ userId: 'owner',
+ tenantId: 'tenant-a',
+ conversationId,
+ messageId,
+ text: '[EMAIL_1_turn]',
+ privacyRevision: 'turn',
+ };
+ expect(await methods.hasPersistedPrivateText(protectedRow)).toBe(true);
+ expect(await methods.getPersistedPrivateTextId(protectedRow)).toBe(String(saved?._id));
+ for (const mismatch of [
+ { userId: 'other' },
+ { tenantId: 'tenant-b' },
+ { conversationId: uuid() },
+ { messageId: uuid() },
+ { text: 'changed text' },
+ { privacyRevision: 'wrong' },
+ ]) {
+ expect(await methods.hasPersistedPrivateText({ ...protectedRow, ...mismatch })).toBe(false);
+ }
+
+ expect(
+ await methods.getPrivateMessageTexts({
+ userId: 'other',
+ tenantId: 'tenant-a',
+ conversationId,
+ messageIds: [messageId],
+ }),
+ ).toEqual([]);
+ expect(
+ await methods.getPrivateMessageTexts({
+ userId: 'owner',
+ tenantId: 'tenant-b',
+ conversationId,
+ messageIds: [messageId],
+ }),
+ ).toEqual([]);
+ });
+ expect(
+ await tenant('tenant-b', () =>
+ methods.getPrivateMessageTexts({
+ userId: 'owner',
+ tenantId: 'tenant-b',
+ conversationId,
+ messageIds: [messageId],
+ }),
+ ),
+ ).toEqual([]);
+ await tenant('tenant-a', async () => {
+ await methods.deleteMessages({ conversationId, user: 'owner' });
+ expect(
+ await methods.getPrivateMessageTexts({
+ userId: 'owner',
+ tenantId: 'tenant-a',
+ conversationId,
+ messageIds: [messageId],
+ }),
+ ).toEqual([]);
+ });
+});
+
+it('inserts a missing Stop prerequisite once without overwriting a stored or concurrent protected row', async () => {
+ await tenant('tenant-a', async () => {
+ const conversationId = uuid();
+ const messageId = uuid();
+ const context = { userId: 'owner', expiredAt: new Date(Date.now() + 60_000) };
+ const user = {
+ messageId,
+ conversationId,
+ isCreatedByUser: true,
+ text: '[EMAIL_1_turn]',
+ };
+ const inserted = await methods.saveMessage(context, user, { insertOnly: true });
+ expect(inserted?.text).toBe(user.text);
+ expect(inserted?.expiredAt).toEqual(context.expiredAt);
+ await methods.saveMessage(context, user, {
+ privateText: { envelope: 'v1:owner', revision: 'turn' },
+ });
+ const retry = await methods.saveMessage(context, user, { insertOnly: true });
+ expect(retry?.privacyRevision).toBe('turn');
+ expect(retry).not.toHaveProperty('privateText');
+ const stored = await mongoose.models.Message.findOne({ messageId })
+ .select('+privateText')
+ .lean();
+ expect(stored).toMatchObject({
+ text: user.text,
+ privateText: 'v1:owner',
+ privacyRevision: 'turn',
+ });
+
+ const concurrentId = uuid();
+ await Promise.all([
+ methods.saveMessage(context, { ...user, messageId: concurrentId }, { insertOnly: true }),
+ methods.saveMessage(
+ context,
+ { ...user, messageId: concurrentId },
+ {
+ privateText: { envelope: 'v1:concurrent', revision: 'turn' },
+ },
+ ),
+ ]);
+ expect(await mongoose.models.Message.countDocuments({ messageId: concurrentId })).toBe(1);
+ const concurrent = await mongoose.models.Message.findOne({ messageId: concurrentId })
+ .select('+privateText')
+ .lean();
+ expect(concurrent).toMatchObject({ privateText: 'v1:concurrent', privacyRevision: 'turn' });
+ });
+});
+
+it('does not accept sidecar writes from message parameters or generic edits', async () => {
+ await tenant('tenant-a', async () => {
+ const messageId = uuid();
+ const conversationId = uuid();
+ const saved = await methods.saveMessage(
+ { userId: 'owner' },
+ {
+ messageId,
+ conversationId,
+ isCreatedByUser: true,
+ text: 'clean',
+ privateText: 'untrusted',
+ privacyRevision: 'untrusted',
+ },
+ );
+ expect(saved).not.toHaveProperty('privateText');
+ expect(saved).not.toHaveProperty('privacyRevision');
+ await methods.updateMessage('owner', {
+ messageId,
+ privateText: 'forged',
+ privacyRevision: 'forged',
+ });
+ expect(
+ await methods.getPrivateMessageTexts({
+ userId: 'owner',
+ tenantId: 'tenant-a',
+ conversationId,
+ messageIds: [messageId],
+ }),
+ ).toEqual([]);
+ });
+});
+
+it('invalidates an encrypted original when an untyped canonical edit sets text to null', async () => {
+ await tenant('tenant-a', async () => {
+ const conversationId = uuid();
+ const messageId = uuid();
+ await methods.saveMessage(
+ { userId: 'owner' },
+ { conversationId, messageId, text: '[EMAIL_1]', isCreatedByUser: true },
+ { privateText: { envelope: 'v1:owner', revision: 'original' } },
+ );
+ await methods.updateMessage('owner', { messageId, text: null as unknown as string });
+ const stored = await mongoose.models.Message.findOne({ messageId })
+ .select('+privateText')
+ .lean();
+ expect(stored).toMatchObject({ text: null });
+ expect(stored).not.toHaveProperty('privateText');
+ expect(stored).not.toHaveProperty('privacyRevision');
+ });
+});
+
+it('does not return expired originals even before the TTL sweeper runs', async () => {
+ await tenant('tenant-a', async () => {
+ const messageId = uuid();
+ const conversationId = uuid();
+ await methods.saveMessage(
+ { userId: 'owner', expiredAt: new Date(0), isTemporary: true },
+ {
+ messageId,
+ conversationId,
+ text: '[EMAIL_1]',
+ isCreatedByUser: true,
+ },
+ { privateText: { envelope: 'v1:ciphertext', revision: 'turn' } },
+ );
+ expect(
+ await methods.getPrivateMessageTexts({
+ userId: 'owner',
+ tenantId: 'tenant-a',
+ conversationId,
+ messageIds: [messageId],
+ }),
+ ).toEqual([]);
+ });
+});
+
+it('strips private fields from bulk copies, including overwrites of protected rows', async () => {
+ await tenant('tenant-a', async () => {
+ const conversationId = uuid();
+ const messageId = uuid();
+ await methods.saveMessage(
+ { userId: 'owner' },
+ { conversationId, messageId, text: '[EMAIL_1]', isCreatedByUser: true },
+ { privateText: { envelope: 'v1:owner', revision: 'original' } },
+ );
+ await methods.bulkSaveMessages([
+ {
+ user: 'owner',
+ conversationId,
+ messageId,
+ text: 'clean copied',
+ isCreatedByUser: true,
+ privateText: 'forged',
+ privacyRevision: 'forged',
+ },
+ {
+ user: 'owner',
+ conversationId,
+ messageId: uuid(),
+ text: 'fresh copied',
+ isCreatedByUser: true,
+ privateText: 'forged',
+ privacyRevision: 'forged',
+ },
+ ]);
+ const rows = await mongoose.models.Message.find({ conversationId })
+ .select('+privateText')
+ .lean();
+ expect(rows).toHaveLength(2);
+ for (const row of rows) {
+ expect(row).not.toHaveProperty('privateText');
+ expect(row).not.toHaveProperty('privacyRevision');
+ }
+ });
+});
+
+it.each([
+ 'updateMessage',
+ 'updateMessageWithProvenance',
+ 'updateMessageText',
+ 'saveMessage',
+ 'recordMessage',
+])('removes stored private text atomically when %s rewrites text', async (method) => {
+ await tenant('tenant-a', async () => {
+ const conversationId = uuid();
+ const messageId = uuid();
+ await methods.saveMessage(
+ { userId: 'owner' },
+ { conversationId, messageId, text: '[EMAIL_1]', isCreatedByUser: true },
+ { privateText: { envelope: 'v1:owner', revision: 'original' } },
+ );
+ if (method === 'updateMessage' || method === 'updateMessageWithProvenance') {
+ const updated = await methods.updateMessage('owner', {
+ messageId,
+ text: 'clean edited',
+ ...(method === 'updateMessageWithProvenance' && { userSubmittedPaths: ['/text'] }),
+ });
+ expect(updated).not.toHaveProperty('privacyRevision');
+ } else if (method === 'updateMessageText') {
+ await methods.updateMessageText('owner', { messageId, text: 'clean edited' });
+ } else if (method === 'recordMessage') {
+ await methods.recordMessage({
+ user: 'owner',
+ conversationId,
+ messageId,
+ text: 'clean edited',
+ isCreatedByUser: true,
+ });
+ } else {
+ await methods.saveMessage(
+ { userId: 'owner' },
+ {
+ conversationId,
+ messageId,
+ text: 'clean edited',
+ isCreatedByUser: true,
+ },
+ );
+ }
+ const stored = await mongoose.models.Message.findOne({ conversationId, messageId })
+ .select('+privateText')
+ .lean();
+ expect(stored).toMatchObject({ text: 'clean edited' });
+ expect(stored).not.toHaveProperty('privateText');
+ expect(stored).not.toHaveProperty('privacyRevision');
+ expect(
+ await methods.getPrivateMessageTexts({
+ userId: 'owner',
+ tenantId: 'tenant-a',
+ conversationId,
+ messageIds: [messageId],
+ }),
+ ).toEqual([]);
+ expect(
+ await methods.hasPersistedPrivateText({
+ userId: 'owner',
+ tenantId: 'tenant-a',
+ conversationId,
+ messageId,
+ text: '[EMAIL_1]',
+ privacyRevision: 'turn',
+ }),
+ ).toBe(false);
+ });
+});
+
+it('persists native-copy token provenance only from metadata and clears it on canonical edits', async () => {
+ const token = `[EMAIL_1_${'a'.repeat(32)}]`;
+ const conversationId = uuid();
+ const messageId = uuid();
+ const message = {
+ messageId,
+ conversationId,
+ user: 'owner',
+ text: token,
+ isCreatedByUser: true,
+ privateTextTokens: [token],
+ privacyRevision: 'forged',
+ privateText: 'forged',
+ };
+ await tenant('tenant-a', async () => {
+ await methods.bulkSaveMessages([message]);
+ expect(
+ (await methods.getMessages({ messageId, user: 'owner' }, '+privateTextTokens'))[0],
+ ).not.toHaveProperty('privateTextTokens');
+ await methods.bulkSaveMessages([message], true, {
+ privateTextTokens: new Map([[messageId, [token]]]),
+ });
+ const internal = (
+ await methods.getMessages({ messageId, user: 'owner' }, '+privateTextTokens')
+ )[0];
+ expect(internal.privateTextTokens).toEqual([token]);
+ expect(internal).not.toHaveProperty('privacyRevision');
+ expect(internal).not.toHaveProperty('privateText');
+ for (const select of [undefined, CLIENT_MESSAGE_SELECT]) {
+ expect(
+ (await methods.getMessages({ messageId, user: 'owner' }, select))[0],
+ ).not.toHaveProperty('privateTextTokens');
+ }
+ await methods.updateMessageText('owner', { messageId, text: 'Clean edit' });
+ expect(
+ (await methods.getMessages({ messageId, user: 'owner' }, '+privateTextTokens'))[0],
+ ).not.toHaveProperty('privateTextTokens');
+ });
+});
+
+it.each(['saveMessage', 'recordMessage', 'updateMessage', 'bulkSaveMessages'] as const)(
+ 'clears native-copy provenance when %s overwrites canonical text',
+ async (writer) => {
+ const token = `[EMAIL_1_${'a'.repeat(32)}]`;
+ const messageId = uuid();
+ const conversationId = uuid();
+ await tenant('tenant-a', async () => {
+ await methods.bulkSaveMessages(
+ [{ user: 'owner', conversationId, messageId, text: token, isCreatedByUser: true }],
+ true,
+ { privateTextTokens: new Map([[messageId, [token]]]) },
+ );
+ const edited = {
+ conversationId,
+ messageId,
+ text: 'Edited text',
+ isCreatedByUser: true,
+ privateTextTokens: [token],
+ };
+ if (writer === 'saveMessage') {
+ await methods.saveMessage({ userId: 'owner' }, edited);
+ } else if (writer === 'recordMessage') {
+ await methods.recordMessage({ user: 'owner', ...edited });
+ } else if (writer === 'updateMessage') {
+ await methods.updateMessage('owner', edited);
+ } else {
+ await methods.bulkSaveMessages([{ user: 'owner', ...edited }]);
+ }
+ expect(
+ (await methods.getMessages({ user: 'owner', messageId }, '+privateTextTokens'))[0],
+ ).not.toHaveProperty('privateTextTokens');
+ });
+ },
+);
diff --git a/packages/data-schemas/src/methods/message.spec.ts b/packages/data-schemas/src/methods/message.spec.ts
index 8d87221150..5e029e423a 100644
--- a/packages/data-schemas/src/methods/message.spec.ts
+++ b/packages/data-schemas/src/methods/message.spec.ts
@@ -703,7 +703,7 @@ describe('Message Operations', () => {
expect(findOneAndUpdate).toHaveBeenCalledTimes(1);
expect(findOneAndUpdate).toHaveBeenCalledWith(
expect.anything(),
- expect.objectContaining({ $unset: { contextMeta: 1 } }),
+ expect.objectContaining({ $unset: expect.objectContaining({ contextMeta: 1 }) }),
expect.anything(),
);
expect(updateOne).not.toHaveBeenCalled();
@@ -737,7 +737,7 @@ describe('Message Operations', () => {
expect(findOneAndUpdate).toHaveBeenCalledTimes(1);
expect(findOneAndUpdate).toHaveBeenCalledWith(
expect.anything(),
- expect.objectContaining({ $unset: { contextMeta: 1 } }),
+ expect.objectContaining({ $unset: expect.objectContaining({ contextMeta: 1 }) }),
expect.anything(),
);
} finally {
diff --git a/packages/data-schemas/src/methods/message.ts b/packages/data-schemas/src/methods/message.ts
index 762950c1c6..5d0ec86234 100644
--- a/packages/data-schemas/src/methods/message.ts
+++ b/packages/data-schemas/src/methods/message.ts
@@ -13,6 +13,7 @@ import { createChatExpirationDate, createTempChatExpirationDate } from '~/utils/
import { activeExpirationFilter, createFallbackRetentionDate } from '~/utils/retention';
import { fitBoundAppSnapshots, hasBoundAppSnapshots } from './appSnapshots';
import { tenantSafeBulkWrite } from '~/utils/tenantBulkWrite';
+import { tenantStorage } from '~/config/tenantContext';
import logger from '~/config/winston';
/** Simple UUID v4 regex to replace zod validation */
@@ -293,6 +294,7 @@ function buildMessageSaveUpdate(
options: {
stampModelOutputOnInsert: boolean;
unsetContextMeta: boolean;
+ unsetPrivateText?: boolean;
retentionOnInsert?: { expiredAt: Date; isTemporary: false };
},
): UpdateQuery<IMessage> {
@@ -305,7 +307,16 @@ function buildMessageSaveUpdate(
...options.retentionOnInsert,
},
}),
- ...(options.unsetContextMeta && { $unset: { contextMeta: 1 } }),
+ ...((options.unsetContextMeta || options.unsetPrivateText) && {
+ $unset: {
+ ...(options.unsetContextMeta && { contextMeta: 1 }),
+ ...(options.unsetPrivateText && {
+ privateText: 1,
+ privacyRevision: 1,
+ ...(update.privateTextTokens === undefined && { privateTextTokens: 1 }),
+ }),
+ },
+ }),
};
}
@@ -319,6 +330,7 @@ async function findOneAndMergeMessageProvenance(
upsert: boolean;
stampModelOutputOnInsert?: boolean;
unsetContextMeta?: boolean;
+ unsetPrivateText?: boolean;
retentionOnInsert?: { expiredAt: Date; isTemporary: false };
prepareAppUpdate?: (
current: Record<string, unknown> | null,
@@ -392,7 +404,16 @@ async function findOneAndMergeMessageProvenance(
$inc: { __v: 1 },
...(current == null &&
options.retentionOnInsert != null && { $setOnInsert: options.retentionOnInsert }),
- ...(options.unsetContextMeta && { $unset: { contextMeta: 1 } }),
+ ...((options.unsetContextMeta || options.unsetPrivateText) && {
+ $unset: {
+ ...(options.unsetContextMeta && { contextMeta: 1 }),
+ ...(options.unsetPrivateText && {
+ privateText: 1,
+ privacyRevision: 1,
+ ...(update.privateTextTokens === undefined && { privateTextTokens: 1 }),
+ }),
+ },
+ }),
},
{ upsert: options.upsert && current == null, new: true, timestamps: options.timestamps },
);
@@ -499,6 +520,8 @@ export const CLIENT_MESSAGE_SELECT: string = [
'-conversationSignature',
'-summary',
'-summaryTokenCount',
+ '-privateText',
+ '-privateTextTokens',
'-contextMeta',
'-langfuseSampled',
'-langfuseDestinationIds',
@@ -682,7 +705,37 @@ function toSettledAt(value: unknown): Date | undefined {
return undefined;
}
+export interface PrivateTextWrite {
+ readonly envelope: string;
+ readonly revision: string;
+}
+
+export interface PrivateTextRead {
+ readonly _id?: unknown;
+ readonly messageId: string;
+ readonly text: string;
+ readonly privacyRevision: string;
+ readonly privateText: string;
+}
+
export interface MessageMethods {
+ getPersistedPrivateTextId(
+ input: Parameters<MessageMethods['hasPersistedPrivateText']>[0],
+ ): Promise<string | null>;
+ hasPersistedPrivateText(input: {
+ userId: string;
+ tenantId?: string;
+ conversationId: string;
+ messageId: string;
+ privacyRevision: string;
+ text: string;
+ }): Promise<boolean>;
+ getPrivateMessageTexts(input: {
+ userId: string;
+ tenantId?: string;
+ conversationId: string;
+ messageIds: readonly string[];
+ }): Promise<PrivateTextRead[]>;
saveMessage(
ctx: {
userId: string;
@@ -694,7 +747,7 @@ export interface MessageMethods {
newMessageId?: string;
contextMeta?: IMessage['contextMeta'] | null;
},
- metadata?: { context?: string },
+ metadata?: { context?: string; privateText?: PrivateTextWrite; insertOnly?: boolean },
): Promise<IMessage | null | undefined>;
/**
* Reads the references a trace viewer needs for one of the user's
@@ -759,6 +812,7 @@ export interface MessageMethods {
bulkSaveMessages(
messages: Array<Partial<IMessage>>,
overrideTimestamp?: boolean,
+ provenance?: { privateTextTokens: ReadonlyMap<string, readonly string[]> },
): Promise<unknown>;
recordMessage(params: {
user: string;
@@ -1007,6 +1061,7 @@ export function createMessageMethods(
stampModelOutputOnInsert?: boolean;
unsetContextMeta?: boolean;
retentionOnInsert?: { expiredAt: Date; isTemporary: false };
+ unsetPrivateText?: boolean;
timestamps?: boolean;
onWrite?: (inserted: boolean, id: unknown) => void;
},
@@ -1027,6 +1082,7 @@ export function createMessageMethods(
stampModelOutputOnInsert: options.stampModelOutputOnInsert ?? false,
unsetContextMeta: options.unsetContextMeta ?? false,
retentionOnInsert: options.retentionOnInsert,
+ unsetPrivateText: options.unsetPrivateText,
}),
{
upsert: options.upsert,
@@ -1071,7 +1127,7 @@ export function createMessageMethods(
/** `null` unsets a previously stored value; omission leaves it in place. */
contextMeta?: IMessage['contextMeta'] | null;
},
- metadata?: { context?: string },
+ metadata?: { context?: string; privateText?: PrivateTextWrite; insertOnly?: boolean },
) {
if (!userId) {
throw new Error('User not authenticated');
@@ -1092,6 +1148,16 @@ export function createMessageMethods(
user: userId,
messageId: params.newMessageId || params.messageId,
};
+ delete update.privateText;
+ delete update.privacyRevision;
+ delete update.privateTextTokens;
+ if (metadata?.privateText != null) {
+ if (params.isCreatedByUser !== true || typeof params.text !== 'string') {
+ throw new Error('Private text requires a user message.');
+ }
+ update.privateText = metadata.privateText.envelope;
+ update.privacyRevision = metadata.privateText.revision;
+ }
delete update.isTemporary;
delete update.expiredAt;
let retentionOnInsert: { expiredAt: Date; isTemporary: false } | undefined;
@@ -1184,10 +1250,38 @@ export function createMessageMethods(
delete update.__v;
const stampModelOutputOnInsert =
params.isCreatedByUser === false && params.isUserSubmitted === undefined;
+ if (metadata?.insertOnly === true) {
+ if (metadata.privateText != null) {
+ throw new Error('A private message cannot use the ordinary insert-only writer.');
+ }
+ const now = new Date();
+ const existingOrInserted = await Message.findOneAndUpdate(
+ { messageId: params.messageId, user: userId },
+ {
+ $setOnInsert: {
+ ...update,
+ ...(userSubmittedPaths.length > 0 && { userSubmittedPaths }),
+ ...(userSubmittedMessageFieldPaths.length > 0 && { userSubmittedMessageFieldPaths }),
+ ...retentionOnInsert,
+ createdAt: now,
+ updatedAt: now,
+ },
+ },
+ { upsert: true, new: true, timestamps: false },
+ );
+ return existingOrInserted?.toObject();
+ }
const message = await writeMessage(
{ messageId: params.messageId, user: userId },
{ ...update, userSubmittedPaths, userSubmittedMessageFieldPaths },
- { upsert: true, stampModelOutputOnInsert, unsetContextMeta, retentionOnInsert },
+ {
+ upsert: true,
+ stampModelOutputOnInsert,
+ unsetContextMeta,
+ retentionOnInsert,
+ unsetPrivateText:
+ metadata?.privateText == null && Object.prototype.hasOwnProperty.call(update, 'text'),
+ },
);
if (message == null) {
@@ -1268,27 +1362,45 @@ export function createMessageMethods(
async function bulkSaveMessages(
messages: Array<Record<string, unknown>>,
overrideTimestamp = false,
+ provenance?: { privateTextTokens: ReadonlyMap<string, readonly string[]> },
) {
try {
const Message = mongoose.models.Message as Model<IMessage>;
const bulkOps = messages.map((message) => {
const normalizedMessage = sanitizeMessageUpdate(message);
- const provenance = capNormalizedProvenance(
+ delete normalizedMessage.privateText;
+ delete normalizedMessage.privacyRevision;
+ delete normalizedMessage.privateTextTokens;
+ const tokens = provenance?.privateTextTokens.get(String(message.messageId));
+ const text = message.text;
+ if (
+ tokens?.length &&
+ tokens.length <= 4096 &&
+ message.isCreatedByUser === true &&
+ typeof text === 'string'
+ ) {
+ normalizedMessage.privateTextTokens = tokens.filter(
+ (token) =>
+ /^\[(?:EMAIL|PHONE|NAME|CREDENTIAL|CUSTOM)_\d+_[a-f0-9]{32}\]$/.test(token) &&
+ text.includes(token),
+ );
+ }
+ const submittedProvenance = capNormalizedProvenance(
normalizeUserSubmittedPaths(message.userSubmittedPaths),
normalizeUserSubmittedMessageFieldPaths(message.userSubmittedMessageFieldPaths),
);
- if (provenance.userSubmittedPaths.length > 0) {
- normalizedMessage.userSubmittedPaths = provenance.userSubmittedPaths;
+ if (submittedProvenance.userSubmittedPaths.length > 0) {
+ normalizedMessage.userSubmittedPaths = submittedProvenance.userSubmittedPaths;
} else {
delete normalizedMessage.userSubmittedPaths;
}
- if (provenance.userSubmittedMessageFieldPaths.length > 0) {
+ if (submittedProvenance.userSubmittedMessageFieldPaths.length > 0) {
normalizedMessage.userSubmittedMessageFieldPaths =
- provenance.userSubmittedMessageFieldPaths;
+ submittedProvenance.userSubmittedMessageFieldPaths;
} else {
delete normalizedMessage.userSubmittedMessageFieldPaths;
}
- if (provenance.promoteWholeMessage) {
+ if (submittedProvenance.promoteWholeMessage) {
normalizedMessage.isUserSubmitted = true;
}
return {
@@ -1297,7 +1409,15 @@ export function createMessageMethods(
messageId: message.messageId,
...(message.user != null ? { user: message.user } : {}),
},
- update: { $set: normalizedMessage, $inc: { __v: 1 } },
+ update: {
+ $set: normalizedMessage,
+ $inc: { __v: 1 },
+ $unset: {
+ privateText: 1,
+ privacyRevision: 1,
+ ...(normalizedMessage.privateTextTokens == null && { privateTextTokens: 1 }),
+ },
+ },
timestamps: !overrideTimestamp,
upsert: true,
},
@@ -1357,6 +1477,7 @@ export function createMessageMethods(
for (const op of guarded) {
await writeMessage(op.updateOne.filter, op.updateOne.update.$set, {
upsert: true,
+ unsetPrivateText: true,
timestamps: !overrideTimestamp,
onWrite: (inserted, id) => {
if (inserted) {
@@ -1417,6 +1538,9 @@ export function createMessageMethods(
userSubmittedMessageFieldPaths: _userSubmittedMessageFieldPaths,
...safeRest
} = rest;
+ delete safeRest.privateText;
+ delete safeRest.privacyRevision;
+ delete safeRest.privateTextTokens;
const message = {
user,
endpoint,
@@ -1434,6 +1558,7 @@ export function createMessageMethods(
};
return await writeMessage({ user, messageId }, message, {
upsert: true,
+ unsetPrivateText: Object.prototype.hasOwnProperty.call(safeRest, 'text'),
stampModelOutputOnInsert:
rest.isCreatedByUser === false && rest.isUserSubmitted === undefined,
});
@@ -1451,7 +1576,11 @@ export function createMessageMethods(
{ messageId, text }: { messageId: string; text: string },
) {
try {
- await writeMessage({ messageId, user: userId }, { text }, { upsert: false });
+ await writeMessage(
+ { messageId, user: userId },
+ { text },
+ { upsert: false, unsetPrivateText: true },
+ );
} catch (err) {
logger.error('Error updating message text:', err);
throw err;
@@ -2363,8 +2492,12 @@ export function createMessageMethods(
) {
try {
const { messageId, ...update } = message;
+ delete update.privateText;
+ delete update.privacyRevision;
+ delete update.privateTextTokens;
const updatedMessage = await writeMessage({ messageId, user: userId }, update, {
upsert: false,
+ unsetPrivateText: Object.prototype.hasOwnProperty.call(update, 'text'),
});
if (!updatedMessage) {
@@ -4038,7 +4171,78 @@ export function createMessageMethods(
return Message.meiliSearch(query, searchOptions, hydrate);
}
+ async function getPersistedPrivateTextId(input: {
+ userId: string;
+ tenantId?: string;
+ conversationId: string;
+ messageId: string;
+ privacyRevision: string;
+ text: string;
+ }): Promise<string | null> {
+ if (
+ !input.userId ||
+ !input.messageId ||
+ !input.privacyRevision ||
+ !UUID_REGEX.test(input.conversationId)
+ ) {
+ return null;
+ }
+ const activeTenant = tenantStorage.getStore()?.tenantId;
+ if (activeTenant != null && activeTenant !== input.tenantId) {
+ return null;
+ }
+ const Message = mongoose.models.Message as Model<IMessage>;
+ const stored = await Message.exists({
+ user: input.userId,
+ ...traceTenantScope(input.tenantId),
+ conversationId: input.conversationId,
+ messageId: input.messageId,
+ text: input.text,
+ privacyRevision: input.privacyRevision,
+ privateText: { $exists: true },
+ $or: [{ expiredAt: null }, { expiredAt: { $gt: new Date() } }],
+ });
+ return stored == null ? null : String(stored._id);
+ }
+
+ async function hasPersistedPrivateText(
+ input: Parameters<MessageMethods['hasPersistedPrivateText']>[0],
+ ): Promise<boolean> {
+ return (await getPersistedPrivateTextId(input)) != null;
+ }
+
+ async function getPrivateMessageTexts(input: {
+ userId: string;
+ tenantId?: string;
+ conversationId: string;
+ messageIds: readonly string[];
+ }): Promise<PrivateTextRead[]> {
+ if (!input.userId || !UUID_REGEX.test(input.conversationId) || input.messageIds.length > 50) {
+ throw new Error('Invalid private message read.');
+ }
+ const activeTenant = tenantStorage.getStore()?.tenantId;
+ if (activeTenant != null && activeTenant !== input.tenantId) {
+ return [];
+ }
+ const Message = mongoose.models.Message as Model<IMessage>;
+ return Message.find({
+ user: input.userId,
+ ...traceTenantScope(input.tenantId),
+ conversationId: input.conversationId,
+ messageId: { $in: input.messageIds },
+ isCreatedByUser: true,
+ privateText: { $exists: true },
+ $or: [{ expiredAt: null }, { expiredAt: { $gt: new Date() } }],
+ })
+ .select('messageId text privacyRevision +privateText')
+ .limit(50)
+ .lean<PrivateTextRead[]>();
+ }
+
return {
+ hasPersistedPrivateText,
+ getPersistedPrivateTextId,
+ getPrivateMessageTexts,
saveMessage,
bulkSaveMessages,
recordMessage,
diff --git a/packages/data-schemas/src/methods/share.test.ts b/packages/data-schemas/src/methods/share.test.ts
index 868b276f0a..a004e4695b 100644
--- a/packages/data-schemas/src/methods/share.test.ts
+++ b/packages/data-schemas/src/methods/share.test.ts
@@ -77,6 +77,7 @@ describe('Share Methods', () => {
conversationId: { type: String, required: true },
user: { type: String, required: true },
text: String,
+ privateTextTokens: { type: [String], select: false, default: undefined },
isCreatedByUser: Boolean,
isUserSubmitted: Boolean,
userSubmittedPaths: {
diff --git a/packages/data-schemas/src/methods/share.ts b/packages/data-schemas/src/methods/share.ts
index 1849be8f13..bd8f7e0ddc 100644
--- a/packages/data-schemas/src/methods/share.ts
+++ b/packages/data-schemas/src/methods/share.ts
@@ -75,7 +75,17 @@ export type SharedLinkContentPreflight = (
snapshot: SharedLinkContentSnapshot,
) => void | Promise<void>;
-export type SharedMessagesPreflight = (snapshot: t.SharedMessagesResult) => void | Promise<void>;
+export type SharedMessagesPreflight = (
+ snapshot: t.SharedMessagesResult,
+ context?: {
+ readonly canonicalMessages: readonly {
+ readonly text?: string;
+ readonly isCreatedByUser?: boolean;
+ readonly privacyRevision?: string;
+ readonly privateTextTokens?: readonly string[];
+ }[];
+ },
+) => void | Promise<void>;
export interface GetSharedMessagesOptions {
readonly snapshotFiles?: boolean;
@@ -956,7 +966,7 @@ export function createShareMethods(mongoose: typeof import('mongoose')): {
const share = (await query
.populate({
path: 'messages',
- select: CLIENT_MESSAGE_SELECT,
+ select: `${CLIENT_MESSAGE_SELECT.replace(' -privateTextTokens', '')} +privateTextTokens`,
})
.select('-__v')
.lean()) as (t.ISharedLink & { messages: t.IMessage[] }) | null;
@@ -1048,7 +1058,7 @@ export function createShareMethods(mongoose: typeof import('mongoose')): {
};
try {
- await options?.preflight?.(result);
+ await options?.preflight?.(result, { canonicalMessages: messagesToShare });
} catch (error) {
preflightFailed = true;
throw error;
@@ -1273,7 +1283,10 @@ export function createShareMethods(mongoose: typeof import('mongoose')): {
})
.select('-_id -__v -user')
.lean() as Promise<t.ISharedLink | null>,
- Message.find({ conversationId, user }).sort({ createdAt: 1 }).lean(),
+ Message.find({ conversationId, user })
+ .select('+privateTextTokens')
+ .sort({ createdAt: 1 })
+ .lean(),
]);
if (existingShare) {
@@ -1448,6 +1461,7 @@ export function createShareMethods(mongoose: typeof import('mongoose')): {
}
const updatedMessages = await Message.find({ conversationId: share.conversationId, user })
+ .select('+privateTextTokens')
.sort({ createdAt: 1 })
.lean();
diff --git a/packages/data-schemas/src/models/plugins/mongoMeili.spec.ts b/packages/data-schemas/src/models/plugins/mongoMeili.spec.ts
index 4c9a7511ca..9be20e6e0d 100644
--- a/packages/data-schemas/src/models/plugins/mongoMeili.spec.ts
+++ b/packages/data-schemas/src/models/plugins/mongoMeili.spec.ts
@@ -83,6 +83,7 @@ const mockAddDocumentsInBatches = jest.fn();
const mockUpdateDocuments = jest.fn();
const mockDeleteDocument = jest.fn();
const mockDeleteDocuments = jest.fn();
+const mockSearch = jest.fn();
const mockGetDocument = jest.fn();
const mockGetDocuments = jest.fn().mockResolvedValue({ results: [] });
const mockWaitForTask = jest.fn().mockResolvedValue({ status: 'succeeded' });
@@ -96,6 +97,7 @@ const mockIndex = jest.fn().mockReturnValue({
deleteDocuments: mockDeleteDocuments,
getDocument: mockGetDocument,
getDocuments: mockGetDocuments,
+ search: mockSearch,
});
jest.mock('meilisearch', () => {
return {
@@ -134,6 +136,7 @@ describe('Meilisearch Mongoose plugin', () => {
mockDeleteDocuments.mockReset().mockResolvedValue({ taskUid: 1 });
mockGetDocument.mockClear();
mockGetDocuments.mockReset().mockResolvedValue({ results: [] });
+ mockSearch.mockReset().mockResolvedValue({ hits: [] });
mockWaitForTask.mockReset().mockResolvedValue({ status: 'succeeded' });
});
@@ -164,6 +167,28 @@ describe('Meilisearch Mongoose plugin', () => {
}
});
+ test('hydrated message search excludes encrypted originals and all schema-hidden fields', async () => {
+ const Message = createMessageModel(mongoose) as unknown as SchemaWithMeiliMethods;
+ const messageId = new mongoose.Types.ObjectId().toString();
+ const conversationId = new mongoose.Types.ObjectId().toString();
+ await Message.collection.insertOne({
+ messageId,
+ conversationId,
+ user: 'search-owner',
+ text: '[EMAIL_1_private]',
+ isCreatedByUser: true,
+ privacyRevision: 'private',
+ privateText: 'v1:encrypted-original',
+ });
+ mockSearch.mockResolvedValueOnce({ hits: [{ messageId, text: '[EMAIL_1_private]' }] });
+
+ const result = await Message.meiliSearch('EMAIL', { filter: 'user = "search-owner"' }, true);
+ expect(result.hits).toHaveLength(1);
+ expect(result.hits[0]).toMatchObject({ messageId, privacyRevision: 'private' });
+ expect(result.hits[0]).not.toHaveProperty('privateText');
+ expect(result.hits[0]).not.toHaveProperty('_meiliIndex');
+ });
+
test('saving conversation indexes w/ meilisearch', async () => {
await createConversationModel(mongoose).create({
conversationId: new mongoose.Types.ObjectId(),
diff --git a/packages/data-schemas/src/models/plugins/mongoMeili.ts b/packages/data-schemas/src/models/plugins/mongoMeili.ts
index 20e4498a73..f543fc47b6 100644
--- a/packages/data-schemas/src/models/plugins/mongoMeili.ts
+++ b/packages/data-schemas/src/models/plugins/mongoMeili.ts
@@ -767,7 +767,7 @@ const createMeiliMongooseModel = ({
const projection = Object.keys(this.schema.obj).reduce<Record<string, number>>(
(results, key) => {
- if (!key.startsWith('$')) {
+ if (!key.startsWith('$') && this.schema.path(key)?.options?.select !== false) {
results[key] = 1;
}
return results;
diff --git a/packages/data-schemas/src/schema/message.ts b/packages/data-schemas/src/schema/message.ts
index 6ca371ed4b..6f0552fb5a 100644
--- a/packages/data-schemas/src/schema/message.ts
+++ b/packages/data-schemas/src/schema/message.ts
@@ -59,6 +59,9 @@ const messageSchema: Schema<IMessage> = new Schema(
summary: {
type: String,
},
+ privateText: { type: String, select: false },
+ privacyRevision: { type: String },
+ privateTextTokens: { type: [String], select: false, default: undefined },
isCreatedByUser: {
type: Boolean,
required: true,
diff --git a/packages/data-schemas/src/types/message.ts b/packages/data-schemas/src/types/message.ts
index 679f9e9b80..f6fcd3f8d3 100644
--- a/packages/data-schemas/src/types/message.ts
+++ b/packages/data-schemas/src/types/message.ts
@@ -60,6 +60,10 @@ export interface IMessage extends Document {
sender?: string;
text?: string;
summary?: string;
+ /** Authenticated ciphertext, available only through the owner-view read. */
+ privateText?: string;
+ privacyRevision?: string;
+ privateTextTokens?: string[];
isCreatedByUser: boolean;
/** True when the complete stored row came from outside the model. */
isUserSubmitted?: boolean;