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
🧼 fix: Prevent Shared Link Caching and Strengthen Log Redaction (#13561)
Danny Avila4b871a11ada0
diff --git a/api/server/routes/__tests__/share.spec.js b/api/server/routes/__tests__/share.spec.jsindex 02941c8453..e26dd9be6c 100644--- a/api/server/routes/__tests__/share.spec.js+++ b/api/server/routes/__tests__/share.spec.js@@ -66,7 +66,12 @@ jest.mock('~/server/middleware/requireJwtAuth', () => (req, res, next) => next()const { RetentionMode } = require('librechat-data-provider');const { createTempChatExpirationDate, logger } = require('@librechat/data-schemas');const { deleteSharedLinkWithCleanup } = require('@librechat/api');-const { createSharedLink, updateSharedLink, getRoleByName } = require('~/models');+const {+ getSharedMessages,+ createSharedLink,+ updateSharedLink,+ getRoleByName,+} = require('~/models');const shareRouter = require('../share');const activeExpiration = new Date('2030-01-01T00:00:00.000Z');@@ -101,6 +106,15 @@ describe('share routes retention', () => {mockGrantCreationPermissions.mockResolvedValue(undefined);});+ it('prevents successful shared message responses from being cached', async () => {+ getSharedMessages.mockResolvedValue({ shareId: 'share-123', messages: [] });++ const response = await request(buildApp()).get('/api/share/share-123');++ expect(response.status).toBe(200);+ expect(response.headers['cache-control']).toBe('private, no-store');+ });+it('expires new shares for retained non-temporary conversations', async () => {mockGetSharedLinkExpiration.mockResolvedValue(activeExpiration);createSharedLink.mockResolvedValue({ _id: 'link-123', shareId: 'share-123' });diff --git a/api/server/routes/share.js b/api/server/routes/share.jsindex 19c760007a..03cc00fbc2 100644--- a/api/server/routes/share.js+++ b/api/server/routes/share.js@@ -58,6 +58,7 @@ if (allowSharedLinks) {try {const share = await getSharedMessages(req.params.shareId, req.shareResourceId);if (share) {+ res.set('Cache-Control', 'private, no-store');res.status(200).json(share);} else {res.status(404).end();diff --git a/packages/data-schemas/src/config/parsers.spec.ts b/packages/data-schemas/src/config/parsers.spec.tsindex 188f42db3c..b008c0aeb9 100644--- a/packages/data-schemas/src/config/parsers.spec.ts+++ b/packages/data-schemas/src/config/parsers.spec.ts@@ -1,4 +1,5 @@-import { debugTraverse } from './parsers';+import winston from 'winston';+import { debugTraverse, redactFormat, redactMessage } from './parsers';const SPLAT_SYMBOL = Symbol.for('splat');const MESSAGE_SYMBOL = Symbol.for('message');@@ -9,6 +10,20 @@ type FormatterInfo = Record<string | symbol, unknown> & {timestamp: string;};+type RedactInfo = Record<string | symbol, unknown> & {+ level: string;+ message: unknown;+};++function runRedactFormat(info: RedactInfo): RedactInfo {+ return (redactFormat().transform(info) || info) as RedactInfo;+}++function runRedactSplatFormat(info: RedactInfo): RedactInfo {+ const format = winston.format.combine(redactFormat(), winston.format.splat());+ return (format.transform(info) || info) as RedactInfo;+}+function runFormatter(info: FormatterInfo): string {const transformed = debugTraverse.transform(info);if (transformed && typeof transformed === 'object') {@@ -28,6 +43,240 @@ function buildInfo(level: string, meta: Record<string, unknown>): FormatterInfo};}+describe('redactMessage', () => {+ it('redacts sensitive token patterns anywhere in a message', () => {+ expect(redactMessage('token: sk-abc123def')).toBe('token: sk-[REDACTED]');+ expect(redactMessage('auth Bearer secretvalue')).toBe('auth Bearer [REDACTED]');+ expect(redactMessage('api-key: secretvalue')).toBe('api-key: [REDACTED]');+ expect(redactMessage('https://example.test/?key=secretvalue&next=true')).toBe(+ 'https://example.test/?key=[REDACTED]&next=true',+ );+ expect(redactMessage('https://example.test/?api_key=secretvalue&next=true')).toBe(+ 'https://example.test/?api_key=[REDACTED]&next=true',+ );+ });++ it('does not redact ordinary words containing sensitive prefixes', () => {+ expect(redactMessage('task-runner failed')).toBe('task-runner failed');+ expect(redactMessage('mask-value computed')).toBe('mask-value computed');+ expect(redactMessage('monkey=10 bananas')).toBe('monkey=10 bananas');+ });+});++describe('redactFormat', () => {+ it.each(['error', 'warn', 'info', 'debug'])('redacts info.message for %s level', (level) => {+ const info = runRedactFormat({ level, message: 'Bearer secretvalue' });+ expect(info.message).toBe('Bearer [REDACTED]');+ });++ it('redacts the winston message symbol', () => {+ const info = runRedactFormat({+ level: 'info',+ message: 'visible',+ [MESSAGE_SYMBOL]: 'token: sk-abc123def',+ });++ expect(info[MESSAGE_SYMBOL]).toBe('token: sk-[REDACTED]');+ });++ it('redacts splat arguments before winston interpolates them', () => {+ const info = runRedactSplatFormat({+ level: 'info',+ message: 'token %s',+ [SPLAT_SYMBOL]: ['sk-abc123def'],+ });++ expect(info.message).toBe('token sk-[REDACTED]');+ });++ it('redacts string values in splat metadata', () => {+ const metadata = {+ auth: 'Bearer secretvalue',+ nested: { url: 'https://example.test/?key=secretvalue&next=true' },+ };+ const info = runRedactFormat({+ level: 'info',+ message: 'visible',+ [SPLAT_SYMBOL]: [metadata],+ });+ const splat = info[SPLAT_SYMBOL] as Array<{ auth: string; nested: { url: string } }>;++ expect(splat[0].auth).toBe('Bearer [REDACTED]');+ expect(splat[0].nested.url).toBe('https://example.test/?key=[REDACTED]&next=true');+ expect(metadata.auth).toBe('Bearer secretvalue');+ expect(metadata.nested.url).toBe('https://example.test/?key=secretvalue&next=true');+ });++ it('redacts values under sensitive splat metadata keys', () => {+ const metadata = {+ apiKey: 'secretvalue',+ authorization: 'secretvalue',+ nested: { token: 'secretvalue' },+ safe: 'secretvalue',+ 'x-api-key': 'secretvalue',+ };+ const info = runRedactFormat({+ level: 'info',+ message: 'visible',+ [SPLAT_SYMBOL]: [metadata],+ });+ const splat = info[SPLAT_SYMBOL] as Array<typeof metadata>;++ expect(splat[0].apiKey).toBe('[REDACTED]');+ expect(splat[0].authorization).toBe('[REDACTED]');+ expect(splat[0].nested.token).toBe('[REDACTED]');+ expect(splat[0]['x-api-key']).toBe('[REDACTED]');+ expect(splat[0].safe).toBe('secretvalue');+ expect(metadata.apiKey).toBe('secretvalue');+ expect(metadata.nested.token).toBe('secretvalue');+ });++ it('redacts object messages before serialization', () => {+ const message = {+ apiKey: 'secretvalue',+ nested: { url: 'https://example.test/?api_key=secretvalue&next=true' },+ };+ const info = runRedactFormat({+ level: 'debug',+ message,+ });++ expect(info.message).toEqual({+ apiKey: '[REDACTED]',+ nested: { url: 'https://example.test/?api_key=[REDACTED]&next=true' },+ });+ expect(message.apiKey).toBe('secretvalue');+ expect(message.nested.url).toBe('https://example.test/?api_key=secretvalue&next=true');+ });++ it('redacts serializable non-plain splat values before interpolation', () => {+ const info = runRedactSplatFormat({+ level: 'info',+ message: 'values %s %s',+ [SPLAT_SYMBOL]: [+ new URL('https://example.test/?api_key=secretvalue&next=true'),+ Buffer.from('sk-abc123def'),+ ],+ });++ expect(info.message).toBe(+ 'values https://example.test/?api_key=[REDACTED]&next=true sk-[REDACTED]',+ );+ });++ it('summarizes large buffer splats instead of scanning the whole payload', () => {+ const buffer = Buffer.concat([Buffer.alloc(9000, 'a'), Buffer.from('sk-abc123def')]);++ const info = runRedactSplatFormat({+ level: 'info',+ message: 'payload %s',+ [SPLAT_SYMBOL]: [buffer],+ });++ expect(info.message).toBe(`payload [REDACTED Buffer ${buffer.length} bytes]`);+ expect(info.message).not.toContain('sk-abc123def');+ });++ it('bounds large object and array redaction work', () => {+ const metadata: Record<string, unknown> = {};+ Array.from({ length: 60 }).forEach((_, index) => {+ metadata[`field${index}`] = index === 59 ? 'sk-abc123def' : `safe-${index}`;+ });++ const info = runRedactFormat({+ level: 'info',+ message: 'visible',+ [SPLAT_SYMBOL]: [[metadata, ...Array.from({ length: 60 }, (_, index) => `safe-${index}`)]],+ });+ const splat = info[SPLAT_SYMBOL] as Array<Array<Record<string, unknown> | string>>;+ const redactedObject = splat[0][0] as Record<string, unknown>;++ expect(Object.keys(redactedObject)).toHaveLength(51);+ expect(redactedObject.field49).toBe('safe-49');+ expect(redactedObject.field59).toBeUndefined();+ expect(redactedObject.__redaction_truncated__).toBe('Additional object properties omitted');+ expect(splat[0]).toHaveLength(51);+ expect(splat[0][50]).toBe('Additional array values omitted');+ expect(JSON.stringify(splat)).not.toContain('sk-abc123def');+ });++ it('redacts over-deep object subtrees instead of traversing indefinitely', () => {+ const root: Record<string, unknown> = {};+ let current = root;+ Array.from({ length: 12 }).forEach((_, index) => {+ current.child = { label: `level-${index}` };+ current = current.child as Record<string, unknown>;+ });+ current.apiKey = 'secretvalue';++ const info = runRedactFormat({+ level: 'info',+ message: root,+ });++ const serialized = JSON.stringify(info.message);+ expect(serialized).toContain('[REDACTED]');+ expect(serialized).not.toContain('secretvalue');+ });++ it('redacts error splat arguments without mutating the original error', () => {+ const error = new Error('Bearer secretvalue');+ error.stack = 'Error: Bearer secretvalue\n at request';++ const info = runRedactFormat({+ level: 'warn',+ message: 'request failed',+ [SPLAT_SYMBOL]: [error],+ });+ const splat = info[SPLAT_SYMBOL] as Error[];++ expect(splat[0]).toBeInstanceOf(Error);+ expect(splat[0]).not.toBe(error);+ expect(splat[0].message).toBe('Bearer [REDACTED]');+ expect(splat[0].stack).toContain('Bearer [REDACTED]');+ expect(Object.prototype.propertyIsEnumerable.call(splat[0], 'message')).toBe(false);+ expect(Object.prototype.propertyIsEnumerable.call(splat[0], 'stack')).toBe(false);+ expect(error.message).toBe('Bearer secretvalue');+ expect(error.stack).toContain('Bearer secretvalue');+ });++ it('preserves contextual messages when redacting error splat arguments', () => {+ const error = new Error('Bearer secretvalue');++ const info = runRedactSplatFormat({+ level: 'warn',+ message: 'request failed',+ [SPLAT_SYMBOL]: [error],+ });++ expect(info.message).toBe('request failed');+ });++ it('preserves and redacts non-enumerable error causes when cloning errors', () => {+ const cause = new Error('Bearer cause-secret');+ const error = new Error('outer');+ Object.defineProperty(error, 'cause', {+ value: cause,+ writable: true,+ enumerable: false,+ configurable: true,+ });++ const info = runRedactFormat({+ level: 'warn',+ message: 'request failed',+ [SPLAT_SYMBOL]: [error],+ });+ const splat = info[SPLAT_SYMBOL] as Array<Error & { cause?: Error }>;++ expect(splat[0].cause).toBeInstanceOf(Error);+ expect(splat[0].cause).not.toBe(cause);+ expect(splat[0].cause?.message).toBe('Bearer [REDACTED]');+ expect(Object.prototype.propertyIsEnumerable.call(splat[0], 'cause')).toBe(false);+ expect(cause.message).toBe('Bearer cause-secret');+ });+});+describe('debugTraverse request context', () => {it('appends request context metadata for non-debug lines', () => {const out = runFormatter(diff --git a/packages/data-schemas/src/config/parsers.ts b/packages/data-schemas/src/config/parsers.tsindex e21927a72b..0558759474 100644--- a/packages/data-schemas/src/config/parsers.ts+++ b/packages/data-schemas/src/config/parsers.ts@@ -1,8 +1,8 @@import { klona } from 'klona';import winston from 'winston';-import traverse from '../utils/object-traverse';-import { SYSTEM_TENANT_ID } from './tenantContext';import type { TraverseContext } from '../utils/object-traverse';+import { SYSTEM_TENANT_ID } from './tenantContext';+import traverse from '../utils/object-traverse';const SPLAT_SYMBOL = Symbol.for('splat');const MESSAGE_SYMBOL = Symbol.for('message');@@ -10,27 +10,28 @@ const CONSOLE_JSON_STRING_LENGTH: number =parseInt(process.env.CONSOLE_JSON_STRING_LENGTH || '', 10) || 255;const DEBUG_MESSAGE_LENGTH: number = parseInt(process.env.DEBUG_MESSAGE_LENGTH || '', 10) || 150;const LOG_CONTEXT_KEYS = ['tenantId', 'userId', 'requestId'] as const;+const REDACTED_VALUE = '[REDACTED]';+const REDACTION_TRUNCATED_KEY = '__redaction_truncated__';+const MAX_REDACTION_DEPTH = 8;+const MAX_REDACTION_ENTRIES = 50;+const DEFAULT_REDACTION_STRING_LENGTH = 8192;+const MAX_REDACTION_STRING_LENGTH = Math.max(+ CONSOLE_JSON_STRING_LENGTH,+ DEFAULT_REDACTION_STRING_LENGTH,+);+const MAX_REDACTION_BUFFER_BYTES = MAX_REDACTION_STRING_LENGTH;const sensitiveKeys: RegExp[] = [- /^(sk-)[^\s]+/, // OpenAI API key pattern- /(Bearer )[^\s]+/, // Header: Bearer token pattern- /(api-key:? )[^\s]+/, // Header: API key pattern- /(key=)[^\s]+/, // URL query param: sensitive key pattern (Google)+ /\b(sk-)[a-zA-Z0-9_-]+/g, // OpenAI API key pattern+ /\b(Bearer )[^\s"']+/g, // Header: Bearer token pattern+ /\b(api-key:? )[^\s"']+/gi, // Header: API key pattern+ /\b(api_key=)[^\s"'&]+/gi, // URL query param: API key pattern+ /\b(key=)[^\s"'&]+/g, // URL query param: sensitive key pattern];-/**- * Determines if a given value string is sensitive and returns matching regex patterns.- *- * @param valueStr - The value string to check.- * @returns An array of regex patterns that match the value string.- */-function getMatchingSensitivePatterns(valueStr: string): RegExp[] {- if (valueStr) {- // Filter and return all regex patterns that match the value string- return sensitiveKeys.filter((regex) => regex.test(valueStr));- }- return [];-}+const sensitiveMetadataKey =+ /^(authorization|proxy-authorization|x-api-key|api[-_]?key|access[-_]?token|refresh[-_]?token|id[-_]?token|token|secret|password)$/i;+const errorStringProperties = new Set(['name', 'message', 'stack']);/*** Redacts sensitive information from a console message and trims it to a specified length if provided.@@ -43,36 +44,306 @@ function redactMessage(str: string, trimLength?: number): string {return '';}- const patterns = getMatchingSensitivePatterns(str);- patterns.forEach((pattern) => {- str = str.replace(pattern, '$1[REDACTED]');+ const redacted = sensitiveKeys.reduce(+ (currentMessage, pattern) => currentMessage.replace(pattern, '$1[REDACTED]'),+ str,+ );++ if (trimLength !== undefined && redacted.length > trimLength) {+ return `${redacted.substring(0, trimLength)}...`;+ }++ return redacted;+}++function redactLogString(str: string): string {+ if (str.length <= MAX_REDACTION_STRING_LENGTH) {+ return redactMessage(str);+ }++ const redacted = redactMessage(str.substring(0, MAX_REDACTION_STRING_LENGTH));+ return `${redacted}... [truncated ${str.length - MAX_REDACTION_STRING_LENGTH} chars]`;+}++function isPlainRecord(value: object): value is Record<string, unknown> {+ const prototype = Object.getPrototypeOf(value);+ return prototype === Object.prototype || prototype === null;+}++function isSensitiveMetadataKey(key: string): boolean {+ return sensitiveMetadataKey.test(key);+}++function redactRecordValue(+ key: string,+ value: unknown,+ seen: WeakMap<object, unknown>,+ depth: number,+): unknown {+ return isSensitiveMetadataKey(key) ? REDACTED_VALUE : redactLogValue(value, seen, depth);+}++function defineRedactedErrorProperty(+ error: Error & Record<string, unknown>,+ key: 'name' | 'message' | 'stack',+ value: string | undefined,+): void {+ if (value === undefined) {+ return;+ }++ Object.defineProperty(error, key, {+ value: redactLogString(value),+ writable: true,+ enumerable: false,+ configurable: true,+ });+}++function defineRedactedDescriptor(+ target: Error & Record<string, unknown>,+ key: string | symbol,+ descriptor: PropertyDescriptor,+ seen: WeakMap<object, unknown>,+ depth: number,+): void {+ if (!('value' in descriptor)) {+ Object.defineProperty(target, key, descriptor);+ return;+ }++ Object.defineProperty(target, key, {+ ...descriptor,+ value:+ typeof key === 'string'+ ? redactRecordValue(key, descriptor.value, seen, depth)+ : redactLogValue(descriptor.value, seen, depth),+ });+}++function redactErrorValue(error: Error, seen: WeakMap<object, unknown>, depth: number): Error {+ const redacted = Object.create(Object.getPrototypeOf(error)) as Error & Record<string, unknown>;+ seen.set(error, redacted);++ defineRedactedErrorProperty(redacted, 'name', error.name);+ defineRedactedErrorProperty(redacted, 'message', error.message);+ defineRedactedErrorProperty(redacted, 'stack', error.stack);++ Reflect.ownKeys(error).forEach((key) => {+ if (typeof key === 'string' && errorStringProperties.has(key)) {+ return;+ }+ const descriptor = Object.getOwnPropertyDescriptor(error, key);+ if (descriptor === undefined) {+ return;+ }+ defineRedactedDescriptor(redacted, key, descriptor, seen, depth + 1);});+ return redacted;+}++function isBufferValue(value: object): value is Buffer {+ return typeof Buffer !== 'undefined' && Buffer.isBuffer(value);+}++function getJsonValue(value: object): unknown {+ const toJSON = (value as { toJSON?: unknown }).toJSON;+ if (typeof toJSON !== 'function') {+ return undefined;+ }++ try {+ const jsonValue = toJSON.call(value);+ return jsonValue === value ? undefined : jsonValue;+ } catch {+ return undefined;+ }+}++function getCustomStringValue(value: object): string | undefined {+ const toString = (value as { toString?: unknown }).toString;+ if (typeof toString !== 'function' || toString === Object.prototype.toString) {+ return undefined;+ }++ try {+ const stringValue = toString.call(value);+ return typeof stringValue === 'string' ? stringValue : undefined;+ } catch {+ return undefined;+ }+}++function redactMapValue(+ value: Map<unknown, unknown>,+ seen: WeakMap<object, unknown>,+ depth: number,+): Map<unknown, unknown> {+ const redacted = new Map<unknown, unknown>();+ seen.set(value, redacted);+ let count = 0;+ for (const [mapKey, mapValue] of value) {+ if (count >= MAX_REDACTION_ENTRIES) {+ redacted.set(REDACTION_TRUNCATED_KEY, 'Additional map entries omitted');+ break;+ }+ redacted.set(+ mapKey,+ typeof mapKey === 'string'+ ? redactRecordValue(mapKey, mapValue, seen, depth + 1)+ : redactLogValue(mapValue, seen, depth + 1),+ );+ count += 1;+ }+ return redacted;+}++function redactSetValue(+ value: Set<unknown>,+ seen: WeakMap<object, unknown>,+ depth: number,+): Set<unknown> {+ const redacted = new Set<unknown>();+ seen.set(value, redacted);+ let count = 0;+ for (const setValue of value) {+ if (count >= MAX_REDACTION_ENTRIES) {+ redacted.add('Additional set values omitted');+ break;+ }+ redacted.add(redactLogValue(setValue, seen, depth + 1));+ count += 1;+ }+ return redacted;+}++function redactObjectEntries(+ value: object,+ seen: WeakMap<object, unknown>,+ depth: number,+): Record<string, unknown> | undefined {+ const record = value as Record<string, unknown>;+ let redacted: Record<string, unknown> | undefined;+ let count = 0;++ for (const key in record) {+ if (!Object.prototype.hasOwnProperty.call(record, key)) {+ continue;+ }+ if (redacted === undefined) {+ redacted = {};+ seen.set(value, redacted);+ }+ if (count >= MAX_REDACTION_ENTRIES) {+ redacted[REDACTION_TRUNCATED_KEY] = 'Additional object properties omitted';+ break;+ }+ redacted[key] = redactRecordValue(key, record[key], seen, depth + 1);+ count += 1;+ }++ return redacted;+}++function redactNonPlainValue(+ value: object,+ seen: WeakMap<object, unknown>,+ depth: number,+): unknown {+ if (isBufferValue(value)) {+ return value.length > MAX_REDACTION_BUFFER_BYTES+ ? `[REDACTED Buffer ${value.length} bytes]`+ : redactLogString(value.toString('utf8'));+ }++ if (value instanceof URL || value instanceof URLSearchParams) {+ return redactLogString(value.toString());+ }++ if (value instanceof Map) {+ return redactMapValue(value, seen, depth);+ }++ if (value instanceof Set) {+ return redactSetValue(value, seen, depth);+ }++ const jsonValue = getJsonValue(value);+ if (jsonValue !== undefined) {+ return redactLogValue(jsonValue, seen, depth + 1);+ }++ const redactedEntries = redactObjectEntries(value, seen, depth);+ if (redactedEntries !== undefined) {+ return redactedEntries;+ }++ const stringValue = getCustomStringValue(value);+ return stringValue !== undefined ? redactLogString(stringValue) : value;+}++function redactLogValue(value: unknown, seen = new WeakMap<object, unknown>(), depth = 0): unknown {+ if (typeof value === 'string') {+ return redactLogString(value);+ }++ if (value === null || typeof value !== 'object') {+ return value;+ }++ const cached = seen.get(value);+ if (cached !== undefined) {+ return cached;+ }++ if (depth >= MAX_REDACTION_DEPTH) {+ return REDACTED_VALUE;+ }++ if (Array.isArray(value)) {+ const redacted: unknown[] = [];+ seen.set(value, redacted);+ const length = Math.min(value.length, MAX_REDACTION_ENTRIES);+ for (let index = 0; index < length; index++) {+ redacted.push(redactLogValue(value[index], seen, depth + 1));+ }+ if (value.length > MAX_REDACTION_ENTRIES) {+ redacted.push('Additional array values omitted');+ }+ return redacted;+ }++ if (value instanceof Error) {+ return redactErrorValue(value, seen, depth);+ }- if (trimLength !== undefined && str.length > trimLength) {- return `${str.substring(0, trimLength)}...`;+ if (!isPlainRecord(value)) {+ return redactNonPlainValue(value, seen, depth);}- return str;+ return redactObjectEntries(value, seen, depth) ?? {};}/**- * Redacts sensitive information from log messages if the log level is 'error'.+ * Redacts sensitive information from log messages at every level.* Note: Intentionally mutates the object.* @param info - The log information object.* @returns The modified log information object.*/const redactFormat = winston.format((info: winston.Logform.TransformableInfo) => {- if (info.level === 'error') {- // Type guard to ensure message is a string- if (typeof info.message === 'string') {- info.message = redactMessage(info.message);- }+ const infoRecord = info as Record<string | symbol, unknown>;- // Handle MESSAGE_SYMBOL with type safety- const symbolValue = (info as Record<string | symbol, unknown>)[MESSAGE_SYMBOL];- if (typeof symbolValue === 'string') {- (info as Record<string | symbol, unknown>)[MESSAGE_SYMBOL] = redactMessage(symbolValue);- }+ if (info.message !== undefined) {+ info.message = redactLogValue(info.message);+ }++ const symbolValue = infoRecord[MESSAGE_SYMBOL];+ if (symbolValue !== undefined) {+ infoRecord[MESSAGE_SYMBOL] = redactLogValue(symbolValue);+ }++ if (infoRecord[SPLAT_SYMBOL] !== undefined) {+ infoRecord[SPLAT_SYMBOL] = redactLogValue(infoRecord[SPLAT_SYMBOL]);}return info;});@@ -129,7 +400,7 @@ function appendRequestContext(line: string, metadata: Record<string, unknown>):* Formats log messages for debugging purposes.* - Truncates long strings within log messages.* - Condenses arrays by truncating long strings and objects as strings within array items.- * - Redacts sensitive information from log messages if the log level is 'error'.+ * - Message redaction is applied by redactFormat before this formatter.* - Converts log information object to a formatted string.** @param options - The options for formatting log messages.diff --git a/packages/data-schemas/src/methods/message.spec.ts b/packages/data-schemas/src/methods/message.spec.tsindex 98b02dd19d..3c3986de93 100644--- a/packages/data-schemas/src/methods/message.spec.ts+++ b/packages/data-schemas/src/methods/message.spec.ts@@ -3,9 +3,12 @@ import { v4 as uuidv4 } from 'uuid';import { RetentionMode } from 'librechat-data-provider';import { MongoMemoryServer } from 'mongodb-memory-server';import type { IMessage } from '..';-import { createMessageMethods } from './message';import { tenantStorage, runAsSystem } from '~/config/tenantContext';+import { createMessageMethods } from './message';import { createModels } from '../models';+import logger from '~/config/winston';++const waitForTimestampTick = () => new Promise((resolve) => setTimeout(resolve, 2));jest.mock('~/config/winston', () => ({error: jest.fn(),@@ -65,6 +68,8 @@ describe('Message Operations', () => {};beforeEach(async () => {+ jest.clearAllMocks();+// Clear databaseawait Message.deleteMany({});@@ -107,6 +112,18 @@ describe('Message Operations', () => {const result = await saveMessage(mockCtx, mockMessageData);expect(result).toBeUndefined();});++ it('should not log message params for invalid conversation IDs', async () => {+ mockMessageData.conversationId = 'invalid-id';+ mockMessageData.text = 'Sensitive prompt text';++ await saveMessage(mockCtx, mockMessageData, { context: 'message-save-test' });++ expect(logger.warn).toHaveBeenCalledWith(+ 'Invalid conversation ID: invalid-id (context: message-save-test)',+ );+ expect(logger.info).not.toHaveBeenCalled();+ });});describe('updateMessageText', () => {@@ -167,6 +184,8 @@ describe('Message Operations', () => {user: 'user123',});+ await waitForTimestampTick();+await saveMessage(mockCtx, {messageId: 'msg3',conversationId,diff --git a/packages/data-schemas/src/methods/message.ts b/packages/data-schemas/src/methods/message.tsindex acaff7c778..dc3ab6d5b2 100644--- a/packages/data-schemas/src/methods/message.ts+++ b/packages/data-schemas/src/methods/message.ts@@ -1,10 +1,10 @@-import type { DeleteResult, FilterQuery, Model } from 'mongoose';import { RetentionMode } from 'librechat-data-provider';-import logger from '~/config/winston';+import type { DeleteResult, FilterQuery, Model } from 'mongoose';+import type { AppConfig, IMessage } from '~/types';import { createTempChatExpirationDate } from '~/utils/tempChatRetention';import { createFallbackRetentionDate } from '~/utils/retention';import { tenantSafeBulkWrite } from '~/utils/tenantBulkWrite';-import type { AppConfig, IMessage } from '~/types';+import logger from '~/config/winston';/** Simple UUID v4 regex to replace zod validation */const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;@@ -79,9 +79,9 @@ export function createMessageMethods(mongoose: typeof import('mongoose')): Messaconst conversationId = params.conversationId as string | undefined;if (!conversationId || !UUID_REGEX.test(conversationId)) {- logger.warn(`Invalid conversation ID: ${conversationId}`);- logger.info(`---\`saveMessage\` context: ${metadata?.context}`);- logger.info(`---Invalid conversation ID Params: ${JSON.stringify(params, null, 2)}`);+ logger.warn(+ `Invalid conversation ID: ${conversationId} (context: ${metadata?.context ?? 'n/a'})`,+ );return;}