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: Keep OpenID Metadata Out of Logs and Traces (#15470)
Danny Avila67e2107d74d2
diff --git a/api/strategies/openidStrategy.js b/api/strategies/openidStrategy.jsindex 5eda5c4514..3f2f9c22d1 100644--- a/api/strategies/openidStrategy.js+++ b/api/strategies/openidStrategy.js@@ -9,7 +9,7 @@ const { CacheKeys, ErrorTypes, SystemRoles } = require('librechat-data-provider'const {isEnabled,logHeaders,- safeStringify,+ logOpenIdRequestBody,findOpenIDUser,getOpenIdEmail,getOpenIdIssuer,@@ -49,15 +49,7 @@ async function customFetch(url, options) {logger.debug(`[openidStrategy] Request method: ${options.method || 'GET'}`);logger.debug(`[openidStrategy] Request headers: ${logHeaders(options.headers)}`);if (options.body) {- let bodyForLogging = '';- if (options.body instanceof URLSearchParams) {- bodyForLogging = options.body.toString();- } else if (typeof options.body === 'string') {- bodyForLogging = options.body;- } else {- bodyForLogging = safeStringify(options.body);- }- logger.debug(`[openidStrategy] Request body: ${bodyForLogging}`);+ logger.debug(`[openidStrategy] Request body: ${logOpenIdRequestBody(options.body)}`);}}diff --git a/packages/api/src/agents/startup.spec.ts b/packages/api/src/agents/startup.spec.tsindex 42416cec89..f84599a272 100644--- a/packages/api/src/agents/startup.spec.ts+++ b/packages/api/src/agents/startup.spec.ts@@ -143,7 +143,7 @@ describe('createAgentStartupTelemetry', () => {mockTracer(span);let now = 10;const telemetry = createAgentStartupTelemetry({ now: () => now })!;- const error = new Error('startup failed');+ const error = new TypeError('startup failed: sk-secret-canary');now = 25;telemetry.end('error', error);@@ -151,7 +151,11 @@ describe('createAgentStartupTelemetry', () => {telemetry.end('aborted');telemetry.mark('client_initialized');- expect(span.recordException).toHaveBeenCalledWith(error);+ expect(span.recordException).toHaveBeenCalledWith({+ message: 'Error details withheld',+ name: 'TypeError',+ });+ expect(JSON.stringify(span.recordException.mock.calls)).not.toContain('sk-secret-canary');expect(span.setStatus).toHaveBeenCalledWith({ code: SpanStatusCode.ERROR });expect(recordAgentStartupResult).toHaveBeenCalledTimes(1);expect(recordAgentStartupResult).toHaveBeenCalledWith('error');diff --git a/packages/api/src/agents/startup.ts b/packages/api/src/agents/startup.tsindex af70e61ea4..11043f3d76 100644--- a/packages/api/src/agents/startup.ts+++ b/packages/api/src/agents/startup.ts@@ -10,6 +10,7 @@ import {recordAgentStartupResult,} from '~/app/metrics';import { agentStartupMilestones, agentStartupResults } from './phases';+import { getSafeSpanException } from '~/telemetry/safeException';const SPAN_NAME = 'librechat.agent.startup';const MILESTONES = new Set<string>(agentStartupMilestones);@@ -170,7 +171,7 @@ export function createAgentStartupTelemetry(}if (tracingEnabled && error) {- span.recordException(error);+ span.recordException(getSafeSpanException(error));}if (tracingEnabled && (normalizedResult === 'aborted' || normalizedResult === 'error')) {span.setStatus({ code: SpanStatusCode.ERROR });diff --git a/packages/api/src/telemetry/middleware.spec.ts b/packages/api/src/telemetry/middleware.spec.tsindex d723372beb..8be4bea321 100644--- a/packages/api/src/telemetry/middleware.spec.ts+++ b/packages/api/src/telemetry/middleware.spec.ts@@ -338,15 +338,25 @@ describe('telemetryErrorMiddleware', () => {jest.restoreAllMocks();});- it('records exceptions and forwards the error', () => {+ it('records safe exception metadata and forwards the original error', () => {const span = createSpan();- const error = new TypeError('boom');+ const error = new TypeError('Bearer exception-token-canary');+ error.name = 'refresh_token=error-name-canary';+ Object.defineProperty(error, 'constructor', {+ value: { name: 'client_secret=constructor-canary' },+ });const next = jest.fn();jest.spyOn(trace, 'getActiveSpan').mockReturnValue(span);telemetryErrorMiddleware(error, createRequest(), createResponse() as Response, next);- expect(span.recordException).toHaveBeenCalledWith(error);+ expect(span.recordException).toHaveBeenCalledWith({+ message: 'Error details withheld',+ name: 'TypeError',+ });+ expect(JSON.stringify(span.recordException.mock.calls)).not.toContain('exception-token-canary');+ expect(JSON.stringify(span.recordException.mock.calls)).not.toContain('error-name-canary');+ expect(JSON.stringify(span.recordException.mock.calls)).not.toContain('constructor-canary');expect(span.setStatus).toHaveBeenCalledWith({ code: SpanStatusCode.ERROR });expect(span.setAttributes).toHaveBeenCalledWith({'enduser.id': 'user-1',@@ -359,6 +369,24 @@ describe('telemetryErrorMiddleware', () => {expect(next).toHaveBeenCalledWith(error);});+ it('falls back to Error for untrusted custom error prototypes', () => {+ const span = createSpan();+ const SecretNamedError = class refresh_token_supersecret extends Error {};+ const error = new SecretNamedError('client_secret=message-canary');+ const next = jest.fn();+ jest.spyOn(trace, 'getActiveSpan').mockReturnValue(span);++ telemetryErrorMiddleware(error, createRequest(), createResponse() as Response, next);++ expect(span.recordException).toHaveBeenCalledWith({+ message: 'Error details withheld',+ name: 'Error',+ });+ expect(JSON.stringify(span.recordException.mock.calls)).not.toContain('supersecret');+ expect(JSON.stringify(span.recordException.mock.calls)).not.toContain('message-canary');+ expect(next).toHaveBeenCalledWith(error);+ });+it('records exceptions on the stored request span when available', () => {const activeSpan = createSpan();const requestSpan = createSpan();@@ -371,7 +399,10 @@ describe('telemetryErrorMiddleware', () => {expect(trace.getActiveSpan).not.toHaveBeenCalled();expect(activeSpan.recordException).not.toHaveBeenCalled();- expect(requestSpan.recordException).toHaveBeenCalledWith(error);+ expect(requestSpan.recordException).toHaveBeenCalledWith({+ message: 'Error details withheld',+ name: 'TypeError',+ });expect(requestSpan.setStatus).toHaveBeenCalledWith({ code: SpanStatusCode.ERROR });expect(next).toHaveBeenCalledWith(error);});@@ -381,9 +412,18 @@ describe('telemetryErrorMiddleware', () => {const next = jest.fn();jest.spyOn(trace, 'getActiveSpan').mockReturnValue(span);- telemetryErrorMiddleware('boom', createRequest(), createResponse() as Response, next);+ telemetryErrorMiddleware(+ 'refresh_token=non-error-token-canary',+ createRequest(),+ createResponse() as Response,+ next,+ );- expect(span.recordException).toHaveBeenCalledWith('boom');+ expect(span.recordException).toHaveBeenCalledWith({+ message: 'Error details withheld',+ name: 'string',+ });+ expect(JSON.stringify(span.recordException.mock.calls)).not.toContain('non-error-token-canary');expect(span.setStatus).toHaveBeenCalledWith({ code: SpanStatusCode.ERROR });expect(span.setAttributes).toHaveBeenCalledWith(expect.objectContaining({@@ -391,7 +431,7 @@ describe('telemetryErrorMiddleware', () => {'http.route': '/api/messages/:conversationId',}),);- expect(next).toHaveBeenCalledWith('boom');+ expect(next).toHaveBeenCalledWith('refresh_token=non-error-token-canary');});it('handles null error values without throwing', () => {diff --git a/packages/api/src/telemetry/middleware.ts b/packages/api/src/telemetry/middleware.tsindex 7362f45b65..cd912f2806 100644--- a/packages/api/src/telemetry/middleware.ts+++ b/packages/api/src/telemetry/middleware.ts@@ -7,6 +7,7 @@ import {finishRedisRequestTelemetry,runWithRedisRequestTelemetry,} from '~/cache/redisTelemetry';+import { getErrorType, getSafeSpanException } from './safeException';import { getTelemetryRequestSpan } from './sdk';import { DEFAULT_HEALTH_PATH } from './config';@@ -153,7 +154,7 @@ export function telemetryErrorMiddleware(if (span) {const routePath = getRoutePath(req);if (err) {- span.recordException(err instanceof Error ? err : String(err));+ span.recordException(getSafeSpanException(err));}span.setStatus({ code: SpanStatusCode.ERROR });setIdentityAttributes(span, req);@@ -165,15 +166,3 @@ export function telemetryErrorMiddleware(next(err);}--function getErrorType(err: ExpressErrorValue): string {- if (err instanceof Error) {- return err.name || err.constructor.name;- }-- if (err === null) {- return 'null';- }-- return typeof err;-}diff --git a/packages/api/src/telemetry/safeException.ts b/packages/api/src/telemetry/safeException.tsnew file mode 100644index 0000000000..e7b4b59391--- /dev/null+++ b/packages/api/src/telemetry/safeException.ts@@ -0,0 +1,47 @@+const SAFE_EXCEPTION_MESSAGE = 'Error details withheld';++export interface SafeSpanException {+ message: string;+ name: string;+}++const TRUSTED_ERROR_TYPES = new Map<object, string>([+ [Error.prototype, 'Error'],+ [EvalError.prototype, 'EvalError'],+ [RangeError.prototype, 'RangeError'],+ [ReferenceError.prototype, 'ReferenceError'],+ [SyntaxError.prototype, 'SyntaxError'],+ [TypeError.prototype, 'TypeError'],+ [URIError.prototype, 'URIError'],+]);++function getErrorConstructorName(error: Error): string {+ try {+ return TRUSTED_ERROR_TYPES.get(Object.getPrototypeOf(error) as object) ?? 'Error';+ } catch {+ return 'Error';+ }+}++export function getErrorType(error: unknown): string {+ try {+ if (error instanceof Error) {+ return getErrorConstructorName(error);+ }+ } catch {+ return 'object';+ }++ if (error === null) {+ return 'null';+ }++ return typeof error;+}++export function getSafeSpanException(error: unknown): SafeSpanException {+ return {+ message: SAFE_EXCEPTION_MESSAGE,+ name: getErrorType(error),+ };+}diff --git a/packages/api/src/utils/openid.spec.ts b/packages/api/src/utils/openid.spec.tsnew file mode 100644index 0000000000..36b745afbd--- /dev/null+++ b/packages/api/src/utils/openid.spec.ts@@ -0,0 +1,85 @@+import { logHeaders, logOpenIdRequestBody, safeStringify } from './openid';++describe('OpenID logging helpers', () => {+ it('fully masks secret-bearing object fields', () => {+ const output = safeStringify({+ client_secret: 'client-secret-canary',+ code: 'authorization-code-canary',+ code_verifier: 'pkce-verifier-canary',+ nested: {+ refresh_token: 'refresh-token-canary',+ connectionString: 'mongodb://user:[email protected]/db',+ },+ });++ expect(output).not.toContain('client-secret-canary');+ expect(output).not.toContain('authorization-code-canary');+ expect(output).not.toContain('pkce-verifier-canary');+ expect(output).not.toContain('refresh-token-canary');+ expect(output).not.toContain('mongodb://');+ expect(output).toContain('***MASKED***');+ });++ it('masks credential-bearing headers case-insensitively', () => {+ const output = logHeaders(+ new Headers({+ Authorization: 'Bearer authorization-canary',+ Cookie: 'session=cookie-canary',+ Location: 'https://example.test/callback?code=location-code-canary',+ 'Set-Cookie': 'refreshToken=set-cookie-canary',+ 'X-Amz-Security-Token': 'aws-token-canary',+ 'X-API-Key': 'api-key-canary',+ 'Content-Type': 'application/json',+ }),+ );++ expect(output).not.toContain('authorization-canary');+ expect(output).not.toContain('cookie-canary');+ expect(output).not.toContain('set-cookie-canary');+ expect(output).not.toContain('aws-token-canary');+ expect(output).not.toContain('location-code-canary');+ expect(output).not.toContain('api-key-canary');+ expect(output).toContain('application/json');+ });++ it('logs URL-encoded request shape without logging values', () => {+ const body = new URLSearchParams({+ grant_type: 'authorization_code',+ code: 'authorization-code-canary',+ code_verifier: 'pkce-verifier-canary',+ client_secret: 'client-secret-canary',+ });++ const output = logOpenIdRequestBody(body);++ expect(output).toContain('URLSearchParams');+ expect(output).toContain('fieldCount');+ expect(output).not.toContain('grant_type');+ expect(output).not.toContain('client_secret');+ expect(output).not.toContain('authorization-code-canary');+ expect(output).not.toContain('pkce-verifier-canary');+ expect(output).not.toContain('client-secret-canary');+ });++ it('logs opaque string body metadata without logging content', () => {+ const output = logOpenIdRequestBody('refresh_token=refresh-token-canary');++ expect(output).toContain('string');+ expect(output).toContain('length');+ expect(output).not.toContain('refresh-token-canary');+ });++ it('never lets hostile debug values interrupt an OpenID request', () => {+ const hostileBody = new Proxy(+ {},+ {+ ownKeys() {+ throw new Error('refresh_token=proxy-canary');+ },+ },+ );++ expect(() => logOpenIdRequestBody(hostileBody)).not.toThrow();+ expect(logOpenIdRequestBody(hostileBody)).not.toContain('proxy-canary');+ });+});diff --git a/packages/api/src/utils/openid.ts b/packages/api/src/utils/openid.tsindex 48c54c7926..a4e156fd14 100644--- a/packages/api/src/utils/openid.ts+++ b/packages/api/src/utils/openid.ts@@ -1,3 +1,25 @@+const MASKED_VALUE = '***MASKED***';+const SAFE_OPENID_HEADER_VALUES = new Set(['content-length', 'content-type']);++function isSensitiveFieldName(key: string): boolean {+ const normalized = key.toLowerCase().replace(/[^a-z0-9]/g, '');+ return (+ normalized === 'code' ||+ normalized.includes('authorization') ||+ normalized.includes('assertion') ||+ normalized.includes('clientid') ||+ normalized.includes('connectionstring') ||+ normalized.includes('cookie') ||+ normalized.includes('credential') ||+ normalized.includes('password') ||+ normalized.includes('signature') ||+ normalized.includes('secret') ||+ normalized.includes('token') ||+ normalized.includes('verifier') ||+ normalized.includes('apikey')+ );+}+/*** Helper function to safely log sensitive data when debug mode is enabled* @param obj - Object to stringify@@ -7,26 +29,40 @@export function safeStringify(obj: unknown, maxLength = 1000): string {try {const str = JSON.stringify(obj, (key, value) => {- // Mask sensitive values- if (- key === 'client_secret' ||- key === 'Authorization' ||- key.toLowerCase().includes('token') ||- key.toLowerCase().includes('password')- ) {- return typeof value === 'string' && value.length > 6- ? `${value.substring(0, 3)}...${value.substring(value.length - 3)}`- : '***MASKED***';+ if (isSensitiveFieldName(key)) {+ return MASKED_VALUE;}return value;});- if (str && str.length > maxLength) {- return `${str.substring(0, maxLength)}... (truncated)`;+ const serialized = str ?? '[Unserializable value]';+ if (serialized.length > maxLength) {+ return `${serialized.substring(0, maxLength)}... (truncated)`;+ }+ return serialized;+ } catch {+ return '[Error stringifying object]';+ }+}++/**+ * Describes an OpenID request body without serializing any values. OAuth form+ * bodies routinely contain authorization codes, refresh tokens, PKCE verifiers,+ * and client secrets, so even partially masked values are unsafe to log.+ */+export function logOpenIdRequestBody(body: unknown): string {+ try {+ if (body instanceof URLSearchParams) {+ return safeStringify({ type: 'URLSearchParams', fieldCount: body.size });+ }++ if (typeof body === 'string') {+ return safeStringify({ type: 'string', length: body.length });}- return str;- } catch (error) {- return `[Error stringifying object: ${(error as Error).message}]`;++ return safeStringify({ type: body == null ? typeof body : 'object' });+ } catch {+ return '[OpenID request body metadata unavailable]';}}@@ -36,16 +72,16 @@ export function safeStringify(obj: unknown, maxLength = 1000): string {* @returns Stringified headers with sensitive data masked*/export function logHeaders(headers: Headers | undefined | null): string {- const headerObj: Record<string, string> = {};- if (!headers || typeof headers.entries !== 'function') {- return 'No headers available';- }- for (const [key, value] of headers.entries()) {- if (key.toLowerCase() === 'authorization' || key.toLowerCase().includes('secret')) {- headerObj[key] = '***MASKED***';- } else {- headerObj[key] = value;+ try {+ const headerObj: Record<string, string> = {};+ if (!headers || typeof headers.entries !== 'function') {+ return 'No headers available';+ }+ for (const [key, value] of headers.entries()) {+ headerObj[key] = SAFE_OPENID_HEADER_VALUES.has(key.toLowerCase()) ? value : MASKED_VALUE;}+ return safeStringify(headerObj);+ } catch {+ return '[OpenID request headers unavailable]';}- return safeStringify(headerObj);}diff --git a/packages/data-schemas/src/config/parsers.spec.ts b/packages/data-schemas/src/config/parsers.spec.tsindex 5dbf8d9cbc..fcee84d78a 100644--- a/packages/data-schemas/src/config/parsers.spec.ts+++ b/packages/data-schemas/src/config/parsers.spec.ts@@ -48,6 +48,9 @@ describe('redactMessage', () => {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('Authorization: Basic basic-credentials')).toBe(+ 'Authorization: [REDACTED]',+ );expect(redactMessage('https://example.test/?key=secretvalue&next=true')).toBe('https://example.test/?key=[REDACTED]&next=true',);@@ -61,6 +64,53 @@ describe('redactMessage', () => {expect(redactMessage('mask-value computed')).toBe('mask-value computed');expect(redactMessage('monkey=10 bananas')).toBe('monkey=10 bananas');});++ it('redacts OAuth and signed URL parameters', () => {+ const message =+ 'https://example.test/callback?code=auth-code&code_verifier=pkce-secret&client_secret=oauth-secret&X-Amz-Signature=aws-signature&X-Amz-Security-Token=session-token&next=true';++ expect(redactMessage(message)).toBe(+ 'https://example.test/callback?code=[REDACTED]&code_verifier=[REDACTED]&client_secret=[REDACTED]&X-Amz-Signature=[REDACTED]&X-Amz-Security-Token=[REDACTED]&next=true',+ );+ });++ it('redacts OAuth secrets in JSON-formatted strings', () => {+ const message =+ 'oauth failed: {"refresh_token":"refresh-json-canary","client_secret": "client-json-canary","client_assertion":"assertion-json-canary","code":"code-json-canary","safe":"visible"}';++ expect(redactMessage(message)).toBe(+ 'oauth failed: {"refresh_token":"[REDACTED]","client_secret": "[REDACTED]","client_assertion":"[REDACTED]","code":"[REDACTED]","safe":"visible"}',+ );+ });++ it('redacts escaped JSON OAuth secret values through the closing quote', () => {+ const secret = 'prefix"secret-tail\\suffix';+ const message = `oauth failed: ${JSON.stringify({ refresh_token: secret, safe: 'visible' })}`;+ const redacted = redactMessage(message);++ expect(redacted).toBe('oauth failed: {"refresh_token":"[REDACTED]","safe":"visible"}');+ expect(redacted).not.toContain('secret-tail');+ expect(redacted).not.toContain('suffix');+ });++ it('redacts complete JWTs, cookies, and URI userinfo', () => {+ const jwt = 'eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJzZWNyZXQtdXNlciJ9.c2lnbmF0dXJlLXNlY3JldA';+ const message =+ `token=${jwt} Cookie: session=cookie-secret; refresh=refresh-secret\n` ++ 'database=postgresql://service-user:[email protected]/app\n' ++ 'cache=redis://:[email protected]:6379';+ const redacted = redactMessage(message);++ expect(redacted).not.toContain(jwt);+ expect(redacted).not.toContain('cookie-secret');+ expect(redacted).not.toContain('refresh-secret');+ expect(redacted).not.toContain('database-secret');+ expect(redacted).not.toContain('password-only-canary');+ expect(redacted).toContain('token=[REDACTED]');+ expect(redacted).toContain('Cookie: [REDACTED]');+ expect(redacted).toContain('postgresql://[REDACTED]@example.test/app');+ expect(redacted).toContain('redis://[REDACTED]@example.test:6379');+ });});describe('redactFormat', () => {@@ -114,6 +164,9 @@ describe('redactFormat', () => {nested: { token: 'secretvalue' },safe: 'secretvalue','x-api-key': 'secretvalue',+ cookie: 'session=secretvalue',+ code_verifier: 'secretvalue',+ connectionString: 'postgresql://user:[email protected]/db',};const info = runRedactFormat({level: 'info',@@ -126,6 +179,9 @@ describe('redactFormat', () => {expect(splat[0].authorization).toBe('[REDACTED]');expect(splat[0].nested.token).toBe('[REDACTED]');expect(splat[0]['x-api-key']).toBe('[REDACTED]');+ expect(splat[0].cookie).toBe('[REDACTED]');+ expect(splat[0].code_verifier).toBe('[REDACTED]');+ expect(splat[0].connectionString).toBe('[REDACTED]');expect(splat[0].safe).toBe('secretvalue');expect(metadata.apiKey).toBe('secretvalue');expect(metadata.nested.token).toBe('secretvalue');@@ -240,6 +296,24 @@ describe('redactFormat', () => {expect(error.stack).toContain('Bearer secretvalue');});+ it('redacts JSON OAuth bodies and password-only URIs inside errors', () => {+ const error = new Error(+ 'OAuth failed: {"refresh_token":"error-json-canary"} redis://:[email protected]',+ );++ const info = runRedactFormat({+ level: 'error',+ message: 'token refresh failed',+ [SPLAT_SYMBOL]: [error],+ });+ const redactedError = (info[SPLAT_SYMBOL] as Error[])[0];++ expect(redactedError.message).toContain('"refresh_token":"[REDACTED]"');+ expect(redactedError.message).toContain('redis://[REDACTED]@example.test');+ expect(redactedError.message).not.toContain('error-json-canary');+ expect(redactedError.message).not.toContain('error-uri-canary');+ });+it('preserves contextual messages when redacting error splat arguments', () => {const error = new Error('Bearer secretvalue');diff --git a/packages/data-schemas/src/config/parsers.ts b/packages/data-schemas/src/config/parsers.tsindex e54b30f3c5..3a2bab5208 100644--- a/packages/data-schemas/src/config/parsers.ts+++ b/packages/data-schemas/src/config/parsers.ts@@ -44,10 +44,16 @@ const sensitiveKeys: RegExp[] = [/\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+ /(\b(?:access_token|assertion|client_assertion|client_secret|code|code_verifier|credential|id_token|refresh_token|sig|signature|x-amz-security-token|x-amz-signature|x-goog-signature)\b"?\s*:\s*")(?:\\.|[^"\\])*/gi,+ /\b((?:access_token|assertion|client_assertion|client_secret|code|code_verifier|credential|id_token|refresh_token|sig|signature|x-amz-security-token|x-amz-signature|x-goog-signature)=)[^\s"'&]+/gi,+ /(\b)eyJ[a-zA-Z0-9_-]{5,}\.[a-zA-Z0-9_-]{5,}\.[a-zA-Z0-9_-]+/g,+ /\b((?:Proxy-)?Authorization:\s*)[^\r\n]+/gi,+ /\b((?:Cookie|Set-Cookie):\s*)[^\r\n]+/gi,+ /([a-z][a-z0-9+.-]*:\/\/)[^/\s:@]*:[^/\s@]+(?=@)/gi,];const sensitiveMetadataKey =- /^(authorization|proxy-authorization|x-api-key|api[-_]?key|access[-_]?token|refresh[-_]?token|id[-_]?token|token|secret|password)$/i;+ /^(authorization|proxy-authorization|cookie|set-cookie|x-api-key|api[-_]?key|access[-_]?token|refresh[-_]?token|id[-_]?token|token|secret|password|assertion|client[-_]?assertion|client[-_]?secret|code[-_]?verifier|credential|signature|connection[-_]?string)$/i;const errorStringProperties = new Set(['name', 'message', 'stack']);/**