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: Add Structured Logging Context (#13110)
Danny Avila7f58e4c2ede9
diff --git a/api/config/__tests__/parsers.spec.js b/api/config/__tests__/parsers.spec.jsindex f54675ce3a..4c78360953 100644--- a/api/config/__tests__/parsers.spec.js+++ b/api/config/__tests__/parsers.spec.js@@ -30,6 +30,18 @@ describe('formatConsoleMeta', () => {expect(meta).toContain('"messagesToRefineCount":42');});+ it('omits the system tenant sentinel from metadata trailers', () => {+ const meta = formatConsoleMeta({+ level: 'warn',+ message: 'system task',+ timestamp: 'ts',+ tenantId: '__SYSTEM__',+ userId: 'user-1',+ });++ expect(meta).toBe('{"userId":"user-1"}');+ });+it('ignores reserved winston keys but preserves legitimate fields like _id', () => {const meta = formatConsoleMeta({level: 'error',@@ -315,6 +327,66 @@ describe('debugTraverse', () => {expect(tenantMatches.length).toBe(1);});+ it('appends request context metadata for non-debug lines', () => {+ const out = runFormatter(+ buildInfo('info', {+ tenantId: 'tenant-1',+ userId: 'user-1',+ requestId: 'req-1',+ }),+ );++ expect(out).toContain('"tenantId":"tenant-1"');+ expect(out).toContain('"userId":"user-1"');+ expect(out).toContain('"requestId":"req-1"');+ });++ it('does not append the system tenant sentinel as tenantId', () => {+ const out = runFormatter(+ buildInfo('info', {+ tenantId: '__SYSTEM__',+ userId: 'user-1',+ requestId: 'req-1',+ }),+ );++ expect(out).not.toContain('__SYSTEM__');+ expect(out).not.toContain('"tenantId"');+ expect(out).toContain('"userId":"user-1"');+ expect(out).toContain('"requestId":"req-1"');+ });++ it('omits the system tenant sentinel from debug object metadata', () => {+ const out = runFormatter(+ buildInfo('debug', {+ tenantId: '__SYSTEM__',+ userId: 'user-1',+ }),+ );++ expect(out).not.toContain('__SYSTEM__');+ expect(out).not.toMatch(/tenantId:/);+ expect(out).toContain('userId');+ });++ it('appends request context metadata for debug lines without object metadata', () => {+ const info = {+ level: 'debug',+ message: 'prefix:',+ timestamp: 'ts',+ tenantId: 'tenant-1',+ userId: 'user-1',+ requestId: 'req-1',+ [SPLAT_SYMBOL]: ['detailValueXYZ'],+ };+ const out = runFormatter(info);++ expect(out).toContain('detailValueXYZ');+ expect(out).toContain('"tenantId":"tenant-1"');+ expect(out).toContain('"userId":"user-1"');+ expect(out).toContain('"requestId":"req-1"');+ });+it('omits numeric splat-artifact keys from the traversed output', () => {const info = {level: 'error',diff --git a/api/config/parsers.js b/api/config/parsers.jsindex 111f3f6a7d..477e371253 100644--- a/api/config/parsers.js+++ b/api/config/parsers.js@@ -18,6 +18,8 @@ const sensitiveKeys = [];const NUMERIC_KEY_RE = /^\d+$/;+const LOG_CONTEXT_KEYS = ['tenantId', 'userId', 'requestId'];+const SYSTEM_TENANT_ID = '__SYSTEM__';/*** Redacts sensitive information from a console message and trims it to a specified length if provided.@@ -122,6 +124,9 @@ function extractMetaObject(source) {continue;}const value = source[key];+ if (key === 'tenantId' && value === SYSTEM_TENANT_ID) {+ continue;+ }if (value === undefined || value === null || value === '') {continue;}@@ -197,6 +202,23 @@ function formatConsoleMeta(info) {}}+function formatRequestContext(info) {+ if (info == null || typeof info !== 'object') {+ return '';+ }+ const context = {};+ for (const key of LOG_CONTEXT_KEYS) {+ const value = info[key];+ if (key === 'tenantId' && value === SYSTEM_TENANT_ID) {+ continue;+ }+ if (typeof value === 'string' && value) {+ context[key] = value;+ }+ }+ return Object.keys(context).length > 0 ? JSON.stringify(context) : '';+}+/*** Formats log messages for file and debug-console transports. Three paths:* - `warn` / `error`: append a compact single-line JSON metadata trailer@@ -207,7 +229,7 @@ function formatConsoleMeta(info) {* Redaction on this path is not applied here (debug-file consumers* historically accept raw detail).* - Other levels: return the truncated `"<timestamp> <level>: <message>"`- * line with no metadata.+ * line with request context metadata when present.** @param {Object} options - The options for formatting log messages.* @param {string} options.level - The log level.@@ -245,31 +267,41 @@ const debugTraverse = winston.format.printf(({ level, message, timestamp, ...mettry {if (level !== 'debug') {- return msg;+ const trailer = formatRequestContext(metadata);+ return trailer ? `${msg} ${trailer}` : msg;}if (!metadata) {return msg;}+ const appendMetadataTrailer = (line) => {+ const trailer = formatRequestContext(metadata);+ return trailer ? `${line} ${trailer}` : line;+ };+const debugValue = metadata[SPLAT_SYMBOL]?.[0];if (!debugValue) {- return msg;+ return appendMetadataTrailer(msg);}if (debugValue && Array.isArray(debugValue)) {msg += `\n${JSON.stringify(debugValue.map(condenseArray))}`;- return msg;+ return appendMetadataTrailer(msg);}if (typeof debugValue !== 'object') {- return (msg += ` ${debugValue}`);+ msg += ` ${debugValue}`;+ return appendMetadataTrailer(msg);}msg += '\n{';const copy = klona(metadata);+ if (copy.tenantId === SYSTEM_TENANT_ID) {+ delete copy.tenantId;+ }traverse(copy).forEach(function (value) {if (typeof this?.key === 'symbol') {return;diff --git a/api/config/winston.js b/api/config/winston.jsindex c077cf5bf8..163e0b4eab 100644--- a/api/config/winston.js+++ b/api/config/winston.js@@ -2,6 +2,12 @@ const path = require('path');const fs = require('fs');const winston = require('winston');require('winston-daily-rotate-file');+const {+ getTenantId,+ getUserId,+ getRequestId,+ SYSTEM_TENANT_ID,+} = require('@librechat/data-schemas');const {redactFormat,redactMessage,@@ -63,6 +69,44 @@ const levels = {silly: 7,};+const LOG_CONTEXT_KEYS = ['tenantId', 'userId', 'requestId'];++const getLogTenantId = () => {+ const tenantId = getTenantId();+ return tenantId === SYSTEM_TENANT_ID ? undefined : tenantId;+};++const requestContextFormat = winston.format((info) => {+ if (info.tenantId === SYSTEM_TENANT_ID) {+ delete info.tenantId;+ }+ const context = {+ tenantId: getLogTenantId(),+ userId: getUserId(),+ requestId: getRequestId(),+ };+ LOG_CONTEXT_KEYS.forEach((key) => {+ if (context[key] && info[key] == null) {+ info[key] = context[key];+ }+ });+ return info;+});++const formatRequestContext = (info) => {+ const context = {};+ LOG_CONTEXT_KEYS.forEach((key) => {+ const value = info[key];+ if (key === 'tenantId' && value === SYSTEM_TENANT_ID) {+ return;+ }+ if (typeof value === 'string' && value) {+ context[key] = value;+ }+ });+ return Object.keys(context).length > 0 ? JSON.stringify(context) : '';+};+winston.addColors({info: 'green', // fontStyle colorwarn: 'italic yellow',@@ -81,6 +125,7 @@ const fileFormat = winston.format.combine(winston.format.timestamp({ format: () => new Date().toISOString() }),winston.format.errors({ stack: true }),winston.format.splat(),+ requestContextFormat(),// redactErrors(),);@@ -112,20 +157,16 @@ if (useDebugLogging) {const consoleFormat = winston.format.combine(redactFormat(),+ requestContextFormat(),winston.format.colorize({ all: true }),winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),// redactErrors(),winston.format.printf((info) => {const base = `${info.timestamp} ${info.level}: ${info.message}`;const isErrorOrWarn = info.level.includes('error') || info.level.includes('warn');-- if (isErrorOrWarn) {- const metaTrailer = formatConsoleMeta(info);- const line = metaTrailer ? `${base} ${metaTrailer}` : base;- return redactMessage(line);- }-- return base;+ const metaTrailer = isErrorOrWarn ? formatConsoleMeta(info) : formatRequestContext(info);+ const line = metaTrailer ? `${base} ${metaTrailer}` : base;+ return isErrorOrWarn ? redactMessage(line) : line;}),);diff --git a/api/server/middleware/__tests__/requireJwtAuth.spec.js b/api/server/middleware/__tests__/requireJwtAuth.spec.jsindex 7f0963398d..4059be2409 100644--- a/api/server/middleware/__tests__/requireJwtAuth.spec.js+++ b/api/server/middleware/__tests__/requireJwtAuth.spec.js@@ -41,25 +41,42 @@ jest.mock('@librechat/data-schemas', () => {const tenantStorage = new AsyncLocalStorage();return {getTenantId: () => tenantStorage.getStore()?.tenantId,+ getUserId: () => tenantStorage.getStore()?.userId,+ getRequestId: () => tenantStorage.getStore()?.requestId,tenantStorage,};});// Mock @librechat/api — the real tenantContextMiddleware is TS and cannot be// required directly from CJS tests. This thin wrapper mirrors the real logic-// (read req.user.tenantId, call tenantStorage.run) using the same data-schemas+// (read request context, call tenantStorage.run) using the same data-schemas// primitives. The real implementation is covered by packages/api tenant.spec.ts.jest.mock('@librechat/api', () => {const { tenantStorage } = require('@librechat/data-schemas');+ const normalizeContextValue = (value) => {+ const trimmed = value?.trim?.();+ return trimmed || undefined;+ };+ const getUserId = (user) =>+ normalizeContextValue(user?.id?.toString?.()) ?? normalizeContextValue(user?._id?.toString?.());+ const getRequestId = (req) =>+ normalizeContextValue(req.requestId) ??+ normalizeContextValue(req.id) ??+ normalizeContextValue(req.headers?.['x-request-id']) ??+ normalizeContextValue(req.headers?.['x-correlation-id']);return {isEnabled: jest.fn(() => false),maybeRefreshCloudFrontAuthCookiesMiddleware: jest.fn((req, res, next) => next()),tenantContextMiddleware: (req, res, next) => {- const tenantId = req.user?.tenantId;- if (!tenantId) {+ const context = {+ tenantId: normalizeContextValue(req.user?.tenantId),+ userId: getUserId(req.user),+ requestId: getRequestId(req),+ };+ if (!context.tenantId && !context.userId && !context.requestId) {return next();}- return tenantStorage.run({ tenantId }, async () => next());+ return tenantStorage.run(context, async () => next());},};});@@ -67,7 +84,7 @@ jest.mock('@librechat/api', () => {// ── Helpers ─────────────────────────────────────────────────────────────const requireJwtAuth = require('../requireJwtAuth');-const { getTenantId } = require('@librechat/data-schemas');+const { getTenantId, getUserId } = require('@librechat/data-schemas');const { isEnabled, maybeRefreshCloudFrontAuthCookiesMiddleware } = require('@librechat/api');const passport = require('passport');@@ -151,6 +168,27 @@ describe('requireJwtAuth tenant context chaining', () => {expect(next).toHaveBeenCalled();});+ it('refreshes CloudFront auth cookies inside the request context', () => {+ let observedContext;+ maybeRefreshCloudFrontAuthCookiesMiddleware.mockImplementationOnce(+ (_req, _res, middlewareNext) => {+ observedContext = {+ tenantId: getTenantId(),+ userId: getUserId(),+ };+ middlewareNext();+ },+ );+ const req = mockReq({ id: 'user-123', tenantId: 'tenant-abc', role: 'user' });+ const res = mockRes();+ const next = jest.fn();++ requireJwtAuth(req, res, next);++ expect(observedContext).toEqual({ tenantId: 'tenant-abc', userId: 'user-123' });+ expect(next).toHaveBeenCalled();+ });+it('ALS tenant context is NOT set when user has no tenantId', async () => {const tenantId = await runAuth({ role: 'user' });expect(tenantId).toBeUndefined();diff --git a/api/server/middleware/requireJwtAuth.js b/api/server/middleware/requireJwtAuth.jsindex e9abbc7fa8..935957e913 100644--- a/api/server/middleware/requireJwtAuth.js+++ b/api/server/middleware/requireJwtAuth.js@@ -35,8 +35,8 @@ const refreshCloudFrontCookies =* Switches between JWT and OpenID authentication based on cookies and environment settings.** After successful authentication (req.user populated), automatically chains into- * `tenantContextMiddleware` to propagate `req.user.tenantId` into AsyncLocalStorage- * for downstream Mongoose tenant isolation.+ * `tenantContextMiddleware` to propagate request context into AsyncLocalStorage+ * for downstream Mongoose tenant isolation and structured logging.*/const requireJwtAuth = (req, res, next) => {const cookieHeader = req.headers.cookie;@@ -71,12 +71,11 @@ const requireJwtAuth = (req, res, next) => {}req.user = user;req.authStrategy = strategy;- refreshCloudFrontCookies(req, res, (refreshErr) => {- if (refreshErr) {- return next(refreshErr);+ tenantContextMiddleware(req, res, (tenantErr) => {+ if (tenantErr) {+ return next(tenantErr);}- // req.user is now populated by passport — set up tenant ALS context- tenantContextMiddleware(req, res, next);+ refreshCloudFrontCookies(req, res, next);});})(req, res, next);};diff --git a/api/server/services/AuthService.js b/api/server/services/AuthService.jsindex 943c5a81f6..24374ef4c6 100644--- a/api/server/services/AuthService.js+++ b/api/server/services/AuthService.js@@ -448,6 +448,8 @@ const getCloudFrontAuthCookieSkipReason = (scope) => {return null;};+const shouldLogCloudFrontAuthCookieSkip = (reason) => reason !== 'cloudfront_disabled';+/*** Refreshes CloudFront signed cookies for authenticated image/avatar access.* @param {ServerRequest | null} req@@ -477,15 +479,17 @@ const setCloudFrontAuthCookies = (req, res, user, options = {}) => {};const skipReason = getCloudFrontAuthCookieSkipReason(scope);if (skipReason) {- logger.debug('[setCloudFrontAuthCookies] CloudFront auth cookies skipped', {- attempted: false,- set: false,- reason: skipReason,- has_user_id: Boolean(scope.userId),- has_tenant_scope: Boolean(scope.tenantId),- has_storage_region: Boolean(scope.storageRegion),- has_previous_scope: Boolean(getPreviousCloudFrontScope(req)?.userId),- });+ if (shouldLogCloudFrontAuthCookieSkip(skipReason)) {+ logger.debug('[setCloudFrontAuthCookies] CloudFront auth cookies skipped', {+ attempted: false,+ set: false,+ reason: skipReason,+ has_user_id: Boolean(scope.userId),+ has_tenant_scope: Boolean(scope.tenantId),+ has_storage_region: Boolean(scope.storageRegion),+ has_previous_scope: Boolean(getPreviousCloudFrontScope(req)?.userId),+ });+ }return false;}diff --git a/api/server/services/AuthService.spec.js b/api/server/services/AuthService.spec.jsindex c81b78e8e1..95a208c5c8 100644--- a/api/server/services/AuthService.spec.js+++ b/api/server/services/AuthService.spec.js@@ -576,13 +576,9 @@ describe('CloudFront cookie integration', () => {expect(result).toBe(false);expect(setCloudFrontCookies).not.toHaveBeenCalled();- expect(logger.debug).toHaveBeenCalledWith(+ expect(logger.debug).not.toHaveBeenCalledWith('[setCloudFrontAuthCookies] CloudFront auth cookies skipped',- expect.objectContaining({- attempted: false,- set: false,- reason: 'cloudfront_disabled',- }),+ expect.any(Object),);});diff --git a/packages/api/src/cdn/__tests__/cloudfront-cookies.test.ts b/packages/api/src/cdn/__tests__/cloudfront-cookies.test.tsindex b9d22048e3..940dece049 100644--- a/packages/api/src/cdn/__tests__/cloudfront-cookies.test.ts+++ b/packages/api/src/cdn/__tests__/cloudfront-cookies.test.ts@@ -840,6 +840,10 @@ describe('maybeRefreshCloudFrontAuthCookies', () => {expect(result).toMatchObject({ enabled: false, attempted: false, refreshed: false });expect(mockGetSignedCookies).not.toHaveBeenCalled();+ expect(mockLogger.debug).not.toHaveBeenCalledWith(+ '[maybeRefreshCloudFrontAuthCookies] CloudFront auth cookies skipped',+ expect.any(Object),+ );});it('does not refresh when imageSigning is not cookies', () => {@@ -851,6 +855,10 @@ describe('maybeRefreshCloudFrontAuthCookies', () => {expect(result).toMatchObject({ enabled: false, attempted: false, refreshed: false });expect(mockGetSignedCookies).not.toHaveBeenCalled();+ expect(mockLogger.debug).not.toHaveBeenCalledWith(+ '[maybeRefreshCloudFrontAuthCookies] CloudFront auth cookies skipped',+ expect.any(Object),+ );});it('force-refreshes even when the scope cookie is fresh without calling OIDC refresh', () => {diff --git a/packages/api/src/cdn/cloudfront-cookies.ts b/packages/api/src/cdn/cloudfront-cookies.tsindex 98de321043..8f1add221b 100644--- a/packages/api/src/cdn/cloudfront-cookies.ts+++ b/packages/api/src/cdn/cloudfront-cookies.ts@@ -312,6 +312,10 @@ function getCloudFrontCookieSkipReason(scope: CloudFrontCookieScope): string | nreturn null;}+function shouldLogCloudFrontCookieSkip(reason: string): boolean {+ return reason !== 'cloudfront_disabled';+}+function getScopeRefreshReason(previousScope: CloudFrontCookieScope | null,currentScope: CloudFrontCookieScope,@@ -540,14 +544,16 @@ export function maybeRefreshCloudFrontAuthCookies(const timing = getCloudFrontCookieTiming();if (skipReason) {- logger.debug('[maybeRefreshCloudFrontAuthCookies] CloudFront auth cookies skipped', {- attempted: false,- refreshed: false,- reason: skipReason,- has_user_id: Boolean(scope.userId),- has_tenant_scope: Boolean(scope.tenantId),- has_storage_region: Boolean(scope.storageRegion),- });+ if (shouldLogCloudFrontCookieSkip(skipReason)) {+ logger.debug('[maybeRefreshCloudFrontAuthCookies] CloudFront auth cookies skipped', {+ attempted: false,+ refreshed: false,+ reason: skipReason,+ has_user_id: Boolean(scope.userId),+ has_tenant_scope: Boolean(scope.tenantId),+ has_storage_region: Boolean(scope.storageRegion),+ });+ }return {enabled: false,attempted: false,diff --git a/packages/api/src/middleware/__tests__/tenant.spec.ts b/packages/api/src/middleware/__tests__/tenant.spec.tsindex d393cdfe0d..6a78ad3098 100644--- a/packages/api/src/middleware/__tests__/tenant.spec.ts+++ b/packages/api/src/middleware/__tests__/tenant.spec.ts@@ -1,5 +1,11 @@import { unlink } from 'fs/promises';-import { getTenantId, SYSTEM_TENANT_ID } from '@librechat/data-schemas';+import {+ getTenantId,+ getUserId,+ getRequestId,+ SYSTEM_TENANT_ID,+ logger,+} from '@librechat/data-schemas';import type { Response, NextFunction } from 'express';import type { ServerRequest } from '~/types/http';// Import directly from source file — _resetTenantMiddlewareStrictCache is intentionally@@ -18,11 +24,18 @@ jest.mock('fs/promises', () => ({const unlinkMock = unlink as jest.MockedFunction<typeof unlink>;function mockReq(user?: Record<string, unknown>): ServerRequest {- return { user } as unknown as ServerRequest;+ return { headers: {}, user } as unknown as ServerRequest;}function mockTenantReq(user?: Record<string, unknown>, tenantId?: string): ServerRequest {- return { user, tenantId } as unknown as ServerRequest;+ return { headers: {}, user, tenantId } as unknown as ServerRequest;+}++function mockReqWithHeaders(+ user: Record<string, unknown> | undefined,+ headers: Record<string, string>,+): ServerRequest {+ return { headers, user } as unknown as ServerRequest;}function mockRes(): Response {@@ -43,11 +56,32 @@ function runMiddleware(req: ServerRequest, res: Response): Promise<string | unde});}+function runMiddlewareContext(+ req: ServerRequest,+ res: Response,+): Promise<{+ tenantId?: string;+ userId?: string;+ requestId?: string;+}> {+ return new Promise((resolve) => {+ const next: NextFunction = () => {+ resolve({+ tenantId: getTenantId(),+ userId: getUserId(),+ requestId: getRequestId(),+ });+ };+ tenantContextMiddleware(req, res, next);+ });+}+describe('tenantContextMiddleware', () => {afterEach(() => {_resetTenantMiddlewareStrictCache();delete process.env.TENANT_ISOLATION_STRICT;unlinkMock.mockClear();+ jest.restoreAllMocks();});it('sets ALS tenant context for authenticated requests with tenantId', async () => {@@ -58,6 +92,22 @@ describe('tenantContextMiddleware', () => {expect(tenantId).toBe('tenant-x');});+ it('sets ALS user and request context for authenticated tenant requests', async () => {+ const req = mockReqWithHeaders(+ { id: 'user-123', tenantId: 'tenant-x', role: 'user' },+ { 'x-request-id': 'req-abc' },+ );+ const res = mockRes();++ const context = await runMiddlewareContext(req, res);++ expect(context).toEqual({+ tenantId: 'tenant-x',+ userId: 'user-123',+ requestId: 'req-abc',+ });+ });+it('is a no-op for unauthenticated requests (no user)', async () => {const req = mockReq();const res = mockRes();@@ -74,6 +124,22 @@ describe('tenantContextMiddleware', () => {expect(tenantId).toBeUndefined();});+ it('keeps user context in non-strict single-tenant mode', async () => {+ const req = mockReqWithHeaders(+ { id: 'single-user', role: 'user' },+ { 'x-request-id': 'req-1' },+ );+ const res = mockRes();++ const context = await runMiddlewareContext(req, res);++ expect(context).toEqual({+ tenantId: undefined,+ userId: 'single-user',+ requestId: 'req-1',+ });+ });+it('returns 403 when user has no tenantId in strict mode', async () => {process.env.TENANT_ISOLATION_STRICT = 'true';_resetTenantMiddlewareStrictCache();@@ -122,6 +188,7 @@ describe('restoreTenantContextFromReq', () => {_resetTenantMiddlewareStrictCache();delete process.env.TENANT_ISOLATION_STRICT;unlinkMock.mockClear();+ jest.restoreAllMocks();});it('restores ALS tenant context from req.user.tenantId', async () => {@@ -139,6 +206,34 @@ describe('restoreTenantContextFromReq', () => {expect(tenantId).toBe('tenant-user');});+ it('restores user and request context alongside tenant context', async () => {+ const req = mockReqWithHeaders(+ { id: 'restore-user', tenantId: 'tenant-user', role: 'user' },+ { 'x-correlation-id': 'corr-123' },+ );+ const res = mockRes();++ const context = await new Promise<{+ tenantId?: string;+ userId?: string;+ requestId?: string;+ }>((resolve) => {+ restoreTenantContextFromReq(req, res, () => {+ resolve({+ tenantId: getTenantId(),+ userId: getUserId(),+ requestId: getRequestId(),+ });+ });+ });++ expect(context).toEqual({+ tenantId: 'tenant-user',+ userId: 'restore-user',+ requestId: 'corr-123',+ });+ });+it('prefers server-resolved req.tenantId over req.user.tenantId', async () => {const req = mockTenantReq({ tenantId: 'tenant-user', role: 'user' }, 'tenant-request');const res = mockRes();@@ -187,6 +282,37 @@ describe('restoreTenantContextFromReq', () => {expect(next).not.toHaveBeenCalled();});+ it('keeps request context while cleaning up rejected strict-mode uploads', async () => {+ process.env.TENANT_ISOLATION_STRICT = 'true';+ _resetTenantMiddlewareStrictCache();+ unlinkMock.mockRejectedValueOnce(new Error('unlink failed'));+ let observedContext: { userId?: string; requestId?: string } | undefined;+ jest.spyOn(logger, 'error').mockImplementation(() => {+ observedContext = {+ userId: getUserId(),+ requestId: getRequestId(),+ };+ return logger;+ });++ const req = {+ ...mockReqWithHeaders({ id: 'strict-user', role: 'user' }, { 'x-request-id': 'req-strict' }),+ file: { path: '/tmp/no-tenant-upload' },+ } as ServerRequest;+ const res = mockRes();+ const next: NextFunction = jest.fn();++ await restoreTenantContextFromReq(req, res, next);++ expect(logger.error).toHaveBeenCalledWith(+ '[restoreTenantContextFromReq] Failed to delete rejected upload:',+ expect.objectContaining({ path: '/tmp/no-tenant-upload' }),+ );+ expect(observedContext).toEqual({ userId: 'strict-user', requestId: 'req-strict' });+ expect(res.status).toHaveBeenCalledWith(403);+ expect(next).not.toHaveBeenCalled();+ });+it('rejects the system tenant sentinel for request-owned work', async () => {const req = mockReq({ tenantId: SYSTEM_TENANT_ID, role: 'user' });const res = mockRes();@@ -198,6 +324,37 @@ describe('restoreTenantContextFromReq', () => {expect(next).not.toHaveBeenCalled();});+ it('rejects a normalized system tenant sentinel for request-owned work', async () => {+ const req = mockTenantReq({ role: 'user' }, ` ${SYSTEM_TENANT_ID} `);+ const res = mockRes();+ const next: NextFunction = jest.fn();++ await restoreTenantContextFromReq(req, res, next);++ expect(res.status).toHaveBeenCalledWith(403);+ expect(res.json).toHaveBeenCalledWith({+ error: 'System tenant is not allowed for request-scoped routes',+ });+ expect(next).not.toHaveBeenCalled();+ });++ it('rejects blank server-resolved tenant IDs in strict mode', async () => {+ process.env.TENANT_ISOLATION_STRICT = 'true';+ _resetTenantMiddlewareStrictCache();++ const req = mockTenantReq({ role: 'user' }, ' ');+ const res = mockRes();+ const next: NextFunction = jest.fn();++ await restoreTenantContextFromReq(req, res, next);++ expect(res.status).toHaveBeenCalledWith(403);+ expect(res.json).toHaveBeenCalledWith(+ expect.objectContaining({ error: expect.stringContaining('Tenant context required') }),+ );+ expect(next).not.toHaveBeenCalled();+ });+it('deletes uploaded temp files before rejecting system-tenant requests', async () => {const req = {...mockReq({ tenantId: SYSTEM_TENANT_ID, role: 'user' }),diff --git a/packages/api/src/middleware/preAuthTenant.spec.ts b/packages/api/src/middleware/preAuthTenant.spec.tsindex 669a43c84f..8aeb8b93ba 100644--- a/packages/api/src/middleware/preAuthTenant.spec.ts+++ b/packages/api/src/middleware/preAuthTenant.spec.ts@@ -1,4 +1,4 @@-import { getTenantId, logger } from '@librechat/data-schemas';+import { getTenantId, getRequestId, logger } from '@librechat/data-schemas';import { preAuthTenantMiddleware } from './preAuthTenant';import type { Request, Response, NextFunction } from 'express';@@ -54,6 +54,17 @@ describe('preAuthTenantMiddleware', () => {expect(capturedTenantId).toBe('acme-corp');});+ it('propagates request ID from pre-auth routes', () => {+ req.headers = { 'x-request-id': 'req-preauth' };+ let capturedRequestId: string | undefined;+ const capturedNext: NextFunction = () => {+ capturedRequestId = getRequestId();+ };++ preAuthTenantMiddleware(req as Request, res as Response, capturedNext);+ expect(capturedRequestId).toBe('req-preauth');+ });+it('ignores __SYSTEM__ sentinel and logs warning', () => {req.headers = { 'x-tenant-id': '__SYSTEM__' };req.ip = '10.0.0.1';diff --git a/packages/api/src/middleware/preAuthTenant.ts b/packages/api/src/middleware/preAuthTenant.tsindex bab91f3a18..5d59cd8ae9 100644--- a/packages/api/src/middleware/preAuthTenant.ts+++ b/packages/api/src/middleware/preAuthTenant.ts@@ -1,5 +1,6 @@-import { tenantStorage, logger, SYSTEM_TENANT_ID } from '@librechat/data-schemas';+import { logger, SYSTEM_TENANT_ID } from '@librechat/data-schemas';import type { Request, Response, NextFunction } from 'express';+import { buildTenantContext, runWithTenantContext } from './tenant';/*** Pre-authentication tenant context middleware for unauthenticated routes.@@ -27,46 +28,49 @@ import type { Request, Response, NextFunction } from 'express';* 3. Layer additional resolution on top (e.g., OpenID `tenant` claim → header).** If no header is present, downstream runs without tenant ALS context (same as- * single-tenant mode). This preserves backward compatibility.+ * single-tenant mode), while request logging context can still propagate.*/const MAX_TENANT_ID_LENGTH = 128;const VALID_TENANT_ID = /^[-a-zA-Z0-9_.]+$/;export function preAuthTenantMiddleware(req: Request, res: Response, next: NextFunction): void {const raw = req.headers['x-tenant-id'];+ const requestContext = buildTenantContext({ headers: req.headers });if (!raw || typeof raw !== 'string') {- next();+ runWithTenantContext(requestContext, next);return;}const tenantId = raw.trim();if (!tenantId) {- next();+ runWithTenantContext(requestContext, next);return;}if (tenantId === SYSTEM_TENANT_ID) {- logger.warn('[preAuthTenant] Rejected __SYSTEM__ sentinel in X-Tenant-Id header', {- ip: req.ip,- path: req.path,+ runWithTenantContext(requestContext, () => {+ logger.warn('[preAuthTenant] Rejected __SYSTEM__ sentinel in X-Tenant-Id header', {+ ip: req.ip,+ path: req.path,+ });+ next();});- next();return;}if (tenantId.length > MAX_TENANT_ID_LENGTH || !VALID_TENANT_ID.test(tenantId)) {- logger.warn('[preAuthTenant] Rejected malformed X-Tenant-Id header', {- ip: req.ip,- length: tenantId.length,- path: req.path,+ runWithTenantContext(requestContext, () => {+ logger.warn('[preAuthTenant] Rejected malformed X-Tenant-Id header', {+ ip: req.ip,+ length: tenantId.length,+ path: req.path,+ });+ next();});- next();return;}- return void tenantStorage.run({ tenantId }, async () => {- next();- });+ runWithTenantContext(buildTenantContext({ headers: req.headers }, tenantId), next);}diff --git a/packages/api/src/middleware/tenant.ts b/packages/api/src/middleware/tenant.tsindex d0907e0d65..41af195584 100644--- a/packages/api/src/middleware/tenant.ts+++ b/packages/api/src/middleware/tenant.ts@@ -1,9 +1,26 @@import { unlink } from 'fs/promises';import { isMainThread } from 'worker_threads';-import { getTenantId, tenantStorage, logger, SYSTEM_TENANT_ID } from '@librechat/data-schemas';+import { tenantStorage, logger, SYSTEM_TENANT_ID } from '@librechat/data-schemas';+import type { TenantContext } from '@librechat/data-schemas';import type { Response, NextFunction } from 'express';import type { ServerRequest } from '~/types/http';+type ContextUser = {+ tenantId?: string;+ id?: string;+ _id?: { toString: () => string };+} | null;++type ContextRequest = {+ headers: ServerRequest['headers'];+ tenantId?: string;+ user?: ContextUser;+ id?: string;+ requestId?: string;+};++const REQUEST_ID_HEADERS = ['x-request-id', 'x-correlation-id'] as const;+let _checkedThread = false;let _strictMode: boolean | undefined;@@ -17,20 +34,73 @@ export function _resetTenantMiddlewareStrictCache(): void {_strictMode = undefined;}+function normalizeContextValue(value?: string): string | undefined {+ const trimmed = value?.trim();+ return trimmed || undefined;+}++function getHeaderValue(value: string | string[] | undefined): string | undefined {+ return normalizeContextValue(Array.isArray(value) ? value[0] : value);+}++function getRequestId(req: ContextRequest): string | undefined {+ const requestId = normalizeContextValue(req.requestId) ?? normalizeContextValue(req.id);+ if (requestId) {+ return requestId;+ }+ for (const header of REQUEST_ID_HEADERS) {+ const value = getHeaderValue(req.headers[header]);+ if (value) {+ return value;+ }+ }+ return undefined;+}++function getUserId(user: ContextUser): string | undefined {+ return normalizeContextValue(user?.id) ?? normalizeContextValue(user?._id?.toString());+}++function hasTenantContext(context: TenantContext): boolean {+ return Boolean(context.tenantId || context.userId || context.requestId);+}++export function buildTenantContext(+ req: ContextRequest,+ tenantId = req.tenantId ?? req.user?.tenantId,+): TenantContext {+ return {+ tenantId: normalizeContextValue(tenantId),+ userId: getUserId(req.user ?? null),+ requestId: getRequestId(req),+ };+}++export function runWithTenantContext(context: TenantContext, next: NextFunction): void {+ if (!hasTenantContext(context)) {+ next();+ return;+ }+ return void tenantStorage.run(context, async () => {+ next();+ });+}+/*** Express middleware that propagates the authenticated user's `tenantId` into- * the AsyncLocalStorage context used by the Mongoose tenant-isolation plugin.+ * the AsyncLocalStorage context used by the Mongoose tenant-isolation plugin+ * and request-scoped logging.** **Placement**: Chained automatically by `requireJwtAuth` after successful* passport authentication (req.user is populated). Must NOT be registered at* global `app.use()` scope — `req.user` is undefined at that stage.** Behaviour:- * - Authenticated request with `tenantId` → wraps downstream in `tenantStorage.run({ tenantId })`+ * - Authenticated request with context → wraps downstream in `tenantStorage.run(context)`* - Authenticated request **without** `tenantId`:* - Strict mode (`TENANT_ISOLATION_STRICT=true`) → responds 403- * - Non-strict (default) → passes through without ALS context (backward compat)- * - Unauthenticated request → no-op (calls `next()` directly)+ * - Non-strict (default) → passes through with user/request context only+ * - Unauthenticated request → propagates request context when available*/export function tenantContextMiddleware(req: ServerRequest,@@ -47,27 +117,26 @@ export function tenantContextMiddleware(}}- const user = req.user as { tenantId?: string } | undefined;+ const user = req.user;+ const context = buildTenantContext(req);if (!user) {- next();+ runWithTenantContext(context, next);return;}- const tenantId = user.tenantId;+ const { tenantId } = context;if (!tenantId) {if (isStrict()) {res.status(403).json({ error: 'Tenant context required in strict isolation mode' });return;}- next();+ runWithTenantContext(context, next);return;}- return void tenantStorage.run({ tenantId }, async () => {- next();- });+ runWithTenantContext(context, next);}export type RequestTenantSource = {@@ -137,6 +206,19 @@ async function rejectRequestWithUploadCleanup(res.status(403).json({ error: message });}+function rejectRequestWithUploadCleanupInContext(+ context: TenantContext,+ req: ServerRequest,+ res: Response,+ message: string,+): Promise<void> {+ const rejectRequest = () => rejectRequestWithUploadCleanup(req, res, message);+ if (!hasTenantContext(context)) {+ return rejectRequest();+ }+ return tenantStorage.run(context, rejectRequest);+}+/*** Re-enters tenant ALS from the server-resolved request tenant.*@@ -150,20 +232,23 @@ export function restoreTenantContextFromReq(next: NextFunction,): void | Promise<void> {const tenantId = resolveRequestTenantId(req as RequestTenantSource);+ const context = buildTenantContext(req, tenantId);+ const resolvedTenantId = context.tenantId;- if (!tenantId) {+ if (!resolvedTenantId) {if (isStrict()) {- return rejectRequestWithUploadCleanup(+ return rejectRequestWithUploadCleanupInContext(+ context,req,res,'Tenant context required in strict isolation mode',);}- next();+ runWithTenantContext(context, next);return;}- if (tenantId === SYSTEM_TENANT_ID) {+ if (resolvedTenantId === SYSTEM_TENANT_ID) {logger.warn('[restoreTenantContextFromReq] Rejected system tenant for request route', {path: req.path,});@@ -174,12 +259,15 @@ export function restoreTenantContextFromReq();}- if (getTenantId() === tenantId) {+ const currentContext = tenantStorage.getStore();+ if (+ currentContext?.tenantId === context.tenantId &&+ currentContext?.userId === context.userId &&+ currentContext?.requestId === context.requestId+ ) {next();return;}- return void tenantStorage.run({ tenantId }, async () => {- next();- });+ return runWithTenantContext(context, next);}diff --git a/packages/data-schemas/src/config/parsers.spec.ts b/packages/data-schemas/src/config/parsers.spec.tsnew file mode 100644index 0000000000..188f42db3c--- /dev/null+++ b/packages/data-schemas/src/config/parsers.spec.ts@@ -0,0 +1,73 @@+import { debugTraverse } from './parsers';++const SPLAT_SYMBOL = Symbol.for('splat');+const MESSAGE_SYMBOL = Symbol.for('message');++type FormatterInfo = Record<string | symbol, unknown> & {+ level: string;+ message: string;+ timestamp: string;+};++function runFormatter(info: FormatterInfo): string {+ const transformed = debugTraverse.transform(info);+ if (transformed && typeof transformed === 'object') {+ const message = (transformed as Record<string | symbol, unknown>)[MESSAGE_SYMBOL];+ return typeof message === 'string' ? message : String(transformed);+ }+ return String(transformed);+}++function buildInfo(level: string, meta: Record<string, unknown>): FormatterInfo {+ return {+ level,+ message: 'test',+ timestamp: 'ts',+ ...meta,+ [SPLAT_SYMBOL]: [meta],+ };+}++describe('debugTraverse request context', () => {+ it('appends request context metadata for non-debug lines', () => {+ const out = runFormatter(+ buildInfo('info', {+ tenantId: 'tenant-1',+ userId: 'user-1',+ requestId: 'req-1',+ }),+ );++ expect(out).toContain('"tenantId":"tenant-1"');+ expect(out).toContain('"userId":"user-1"');+ expect(out).toContain('"requestId":"req-1"');+ });++ it('does not append the system tenant sentinel as tenantId', () => {+ const out = runFormatter(+ buildInfo('info', {+ tenantId: '__SYSTEM__',+ userId: 'user-1',+ requestId: 'req-1',+ }),+ );++ expect(out).not.toContain('__SYSTEM__');+ expect(out).not.toContain('"tenantId"');+ expect(out).toContain('"userId":"user-1"');+ expect(out).toContain('"requestId":"req-1"');+ });++ it('omits the system tenant sentinel from debug object metadata', () => {+ const out = runFormatter(+ buildInfo('debug', {+ tenantId: '__SYSTEM__',+ userId: 'user-1',+ }),+ );++ expect(out).not.toContain('__SYSTEM__');+ expect(out).not.toMatch(/tenantId:/);+ expect(out).toContain('userId');+ });+});diff --git a/packages/data-schemas/src/config/parsers.ts b/packages/data-schemas/src/config/parsers.tsindex 80dd9b767c..e21927a72b 100644--- a/packages/data-schemas/src/config/parsers.ts+++ b/packages/data-schemas/src/config/parsers.ts@@ -1,6 +1,7 @@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';const SPLAT_SYMBOL = Symbol.for('splat');@@ -8,6 +9,7 @@ const MESSAGE_SYMBOL = Symbol.for('message');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 sensitiveKeys: RegExp[] = [/^(sk-)[^\s]+/, // OpenAI API key pattern@@ -104,6 +106,25 @@ const condenseArray = (item: unknown): string | unknown => {return item;};+function formatRequestContext(metadata: Record<string, unknown>): string {+ const context: Partial<Record<(typeof LOG_CONTEXT_KEYS)[number], string>> = {};+ LOG_CONTEXT_KEYS.forEach((key) => {+ const value = metadata[key];+ if (key === 'tenantId' && value === SYSTEM_TENANT_ID) {+ return;+ }+ if (typeof value === 'string' && value) {+ context[key] = value;+ }+ });+ return Object.keys(context).length > 0 ? JSON.stringify(context) : '';+}++function appendRequestContext(line: string, metadata: Record<string, unknown>): string {+ const context = formatRequestContext(metadata);+ return context ? `${line} ${context}` : line;+}+/*** Formats log messages for debugging purposes.* - Truncates long strings within log messages.@@ -131,7 +152,7 @@ const debugTraverse = winston.format.printf(try {if (level !== 'debug') {- return msgParts[0];+ return appendRequestContext(msgParts[0], metadata);}if (!metadata) {@@ -144,22 +165,25 @@ const debugTraverse = winston.format.printf(const debugValue = Array.isArray(splatArray) ? splatArray[0] : undefined;if (!debugValue) {- return msgParts[0];+ return appendRequestContext(msgParts[0], metadata);}if (debugValue && Array.isArray(debugValue)) {msgParts.push(`\n${JSON.stringify(debugValue.map(condenseArray))}`);- return msgParts.join('');+ return appendRequestContext(msgParts.join(''), metadata);}if (typeof debugValue !== 'object') {msgParts.push(` ${debugValue}`);- return msgParts.join('');+ return appendRequestContext(msgParts.join(''), metadata);}msgParts.push('\n{');const copy = klona(metadata);+ if (copy.tenantId === SYSTEM_TENANT_ID) {+ delete copy.tenantId;+ }try {const traversal = traverse(copy);traversal.forEach(function (this: TraverseContext, value: unknown) {diff --git a/packages/data-schemas/src/config/tenantContext.spec.ts b/packages/data-schemas/src/config/tenantContext.spec.tsindex 7e6cc0748d..a01e01ff76 100644--- a/packages/data-schemas/src/config/tenantContext.spec.ts+++ b/packages/data-schemas/src/config/tenantContext.spec.ts@@ -1,4 +1,4 @@-import { tenantStorage, runAsSystem, scopedCacheKey } from './tenantContext';+import { tenantStorage, getUserId, getRequestId, runAsSystem, scopedCacheKey } from './tenantContext';describe('scopedCacheKey', () => {it('returns base key when no ALS context is set', () => {@@ -23,4 +23,21 @@ describe('scopedCacheKey', () => {});expect(scopedCacheKey('KEY')).toBe('KEY');});++ it('reads user and request IDs from ALS context', async () => {+ await tenantStorage.run({ userId: 'user-1', requestId: 'req-1' }, async () => {+ expect(getUserId()).toBe('user-1');+ expect(getRequestId()).toBe('req-1');+ });+ });++ it('preserves user and request context inside system tenant operations', async () => {+ await tenantStorage.run({ tenantId: 'acme', userId: 'user-1', requestId: 'req-1' }, async () => {+ await runAsSystem(async () => {+ expect(getUserId()).toBe('user-1');+ expect(getRequestId()).toBe('req-1');+ expect(scopedCacheKey('KEY')).toBe('KEY');+ });+ });+ });});diff --git a/packages/data-schemas/src/config/tenantContext.ts b/packages/data-schemas/src/config/tenantContext.tsindex eb77edb27d..9dc73f972b 100644--- a/packages/data-schemas/src/config/tenantContext.ts+++ b/packages/data-schemas/src/config/tenantContext.ts@@ -2,6 +2,8 @@ import { AsyncLocalStorage } from 'async_hooks';export interface TenantContext {tenantId?: string;+ userId?: string;+ requestId?: string;}/** Sentinel value for deliberate cross-tenant system operations */@@ -19,12 +21,23 @@ export function getTenantId(): string | undefined {return tenantStorage.getStore()?.tenantId;}+/** Returns the current user ID from async context, or undefined if none is set */+export function getUserId(): string | undefined {+ return tenantStorage.getStore()?.userId;+}++/** Returns the current request ID from async context, or undefined if none is set */+export function getRequestId(): string | undefined {+ return tenantStorage.getStore()?.requestId;+}+/*** Runs a function in an explicit cross-tenant system context (bypasses tenant filtering).* The callback MUST be async — sync callbacks returning Mongoose thenables will lose context.*/export function runAsSystem<T>(fn: () => Promise<T>): Promise<T> {- return tenantStorage.run({ tenantId: SYSTEM_TENANT_ID }, fn);+ const { requestId, userId } = tenantStorage.getStore() ?? {};+ return tenantStorage.run({ tenantId: SYSTEM_TENANT_ID, requestId, userId }, fn);}/**diff --git a/packages/data-schemas/src/config/winston.ts b/packages/data-schemas/src/config/winston.tsindex 24a2c6c987..9bc7652415 100644--- a/packages/data-schemas/src/config/winston.ts+++ b/packages/data-schemas/src/config/winston.ts@@ -1,6 +1,7 @@import winston from 'winston';import 'winston-daily-rotate-file';import { redactFormat, redactMessage, debugTraverse, jsonTruncateFormat } from './parsers';+import { getTenantId, getUserId, getRequestId, SYSTEM_TENANT_ID } from './tenantContext';import { getLogDirectory } from './utils';const logDir = getLogDirectory();@@ -24,6 +25,49 @@ const levels: winston.config.AbstractConfigSetLevels = {silly: 7,};+const LOG_CONTEXT_KEYS = ['tenantId', 'userId', 'requestId'] as const;++function getLogTenantId(): string | undefined {+ const tenantId = getTenantId();+ return tenantId === SYSTEM_TENANT_ID ? undefined : tenantId;+}++const requestContextFormat = winston.format((info: winston.Logform.TransformableInfo) => {+ if (info.tenantId === SYSTEM_TENANT_ID) {+ delete info.tenantId;+ }+ const context = {+ tenantId: getLogTenantId(),+ userId: getUserId(),+ requestId: getRequestId(),+ };+ LOG_CONTEXT_KEYS.forEach((key) => {+ if (context[key] && info[key] == null) {+ info[key] = context[key];+ }+ });+ return info;+});++function formatRequestContext(info: winston.Logform.TransformableInfo): string {+ const context: Partial<Record<(typeof LOG_CONTEXT_KEYS)[number], string>> = {};+ LOG_CONTEXT_KEYS.forEach((key) => {+ const value = info[key];+ if (key === 'tenantId' && value === SYSTEM_TENANT_ID) {+ return;+ }+ if (typeof value === 'string' && value) {+ context[key] = value;+ }+ });+ return Object.keys(context).length > 0 ? JSON.stringify(context) : '';+}++function appendRequestContext(line: string, info: winston.Logform.TransformableInfo): string {+ const context = formatRequestContext(info);+ return context ? `${line} ${context}` : line;+}+winston.addColors({info: 'green',warn: 'italic yellow',@@ -41,6 +85,7 @@ const fileFormat = winston.format.combine(winston.format.timestamp({ format: () => new Date().toISOString() }),winston.format.errors({ stack: true }),winston.format.splat(),+ requestContextFormat(),);const transports: winston.transport[] = [@@ -71,11 +116,13 @@ if (useDebugLogging) {const consoleFormat = winston.format.combine(redactFormat(),+ requestContextFormat(),winston.format.colorize({ all: true }),winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),winston.format.printf((info) => {const message = `${info.timestamp} ${info.level}: ${info.message}`;- return info.level.includes('error') ? redactMessage(message) : message;+ const line = appendRequestContext(message, info);+ return info.level.includes('error') ? redactMessage(line) : line;}),);diff --git a/packages/data-schemas/src/index.ts b/packages/data-schemas/src/index.tsindex 4156559658..8c95d7f9cc 100644--- a/packages/data-schemas/src/index.ts+++ b/packages/data-schemas/src/index.ts@@ -23,6 +23,8 @@ export { default as meiliLogger } from './config/meiliLogger';export {tenantStorage,getTenantId,+ getUserId,+ getRequestId,runAsSystem,scopedCacheKey,SYSTEM_TENANT_ID,