Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
📔 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.jsindex 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.jsindex 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-provconst 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.jsindex 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.jsindex 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({+ text: '[email protected]',+ 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.jsindex 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.jsindex 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.jsindex 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, addTitconst 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, addTitconversationId: 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, addTitconvoSignal.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, addTitif (!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, addTitownsScheduledFailure =(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, addTitconst 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.jsindex 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.jsnew file mode 100644index 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.jsindex 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.jsindex 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.jsindex 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.jsindex 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.jsindex 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.jsindex 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.jsindex 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.jsindex 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.jsindex 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.jsindex 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.jsindex 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.jsindex 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.jsindex 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.jsindex 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.jsindex 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.jsindex 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.jsindex 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.jsindex 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.jsindex 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.jsindex 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.tsxindex 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_questionpopover ⇄ chat-card morph) paints the whole composer bandover the travelling card instead of letting it showdiff --git a/client/src/components/Chat/Messages/Content/EditMessage.tsx b/client/src/components/Chat/Messages/Content/EditMessage.tsxindex 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.tsxindex 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.tsxindex 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.tsxindex 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 ? (<ThreadListdiff --git a/client/src/components/Chat/Messages/PrivateText.spec.tsx b/client/src/components/Chat/Messages/PrivateText.spec.tsxnew file mode 100644index 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',+ text: '[email protected]',+};+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.tsxnew file mode 100644index 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.tsxindex 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.tsxindex 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 (<MessageRowid={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.tsxindex 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. Rendereddiff --git a/client/src/data-provider/Messages/private.ts b/client/src/data-provider/Messages/private.tsnew file mode 100644index 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.tsindex 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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsindex 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.tsxindex 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.jsonindex 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.tsindex 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> = {}): TMessageContconst 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',+ text: '[email protected]',+ } 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.tsindex 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 anddiff --git a/e2e/setup/fake-model.js b/e2e/setup/fake-model.jsindex 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.tsnew file mode 100644index 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.yamlindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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: {+ text: '[email protected]',+ 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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 jobdiff --git a/packages/data-provider/src/data-service.ts b/packages/data-provider/src/data-service.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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;