Skip to content

Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active

🫢 fix: Keep OAuth Credentials Out of Logs (#17409)

lia-by-librechat[bot]ba78cf5f5f65
diff --git a/api/server/routes/__tests__/mcp.spec.js b/api/server/routes/__tests__/mcp.spec.js
index 96404b776c..977a12eb75 100644
--- a/api/server/routes/__tests__/mcp.spec.js
+++ b/api/server/routes/__tests__/mcp.spec.js
@@ -1,4 +1,5 @@
const crypto = require('crypto');
+const { inspect } = require('util');
const express = require('express');
const request = require('supertest');
const mongoose = require('mongoose');
@@ -470,6 +471,8 @@ describe('MCP Routes', () => {
});
it('should initiate OAuth flow when stored authorization URL is missing', async () => {
+ const nonce = 'sentinel-authorization-nonce';
+ const authorizationUrl = `https://oauth.example.com/auth?state=${nonce}&code_challenge=sentinel-pkce-challenge`;
const mockFlowManager = {
getFlowState: jest.fn().mockResolvedValue({
status: 'PENDING',
@@ -486,9 +489,9 @@ describe('MCP Routes', () => {
require('~/config').getFlowStateManager.mockReturnValue(mockFlowManager);
MCPOAuthHandler.initiateOAuthFlow.mockResolvedValue({
- authorizationUrl: 'https://oauth.example.com/auth',
+ authorizationUrl,
flowId: 'test-user-id:test-server',
- flowMetadata: { state: 'random-state-value' },
+ flowMetadata: { state: nonce },
});
MCPOAuthHandler.storeStateMapping.mockResolvedValue();
mockFlowManager.initFlow = jest.fn().mockResolvedValue();
@@ -499,7 +502,7 @@ describe('MCP Routes', () => {
});
expect(response.status).toBe(302);
- expect(response.headers.location).toBe('https://oauth.example.com/auth');
+ expect(response.headers.location).toBe(authorizationUrl);
expect(MCPOAuthHandler.initiateOAuthFlow).toHaveBeenCalledWith(
'test-server',
serverUrl,
@@ -519,16 +522,20 @@ describe('MCP Routes', () => {
'test-user-id:test-server',
'mcp_oauth',
expect.objectContaining({
- state: 'random-state-value',
- authorizationUrl: 'https://oauth.example.com/auth',
+ state: nonce,
+ authorizationUrl,
serverGeneration: `config:${JSON.stringify({ url: serverUrl })}`,
}),
);
expect(MCPOAuthHandler.storeStateMapping).toHaveBeenCalledWith(
- 'random-state-value',
+ nonce,
'test-user-id:test-server',
mockFlowManager,
);
+ const { logger } = require('@librechat/data-schemas');
+ const diagnostics = inspect(logger.debug.mock.calls, { depth: null });
+ expect(diagnostics).not.toContain(nonce);
+ expect(diagnostics).not.toContain('sentinel-pkce-challenge');
});
describe('when the server is no longer one the user can use', () => {
@@ -690,8 +697,13 @@ describe('MCP Routes', () => {
});
it('should return 500 when OAuth initiation throws unexpected error', async () => {
+ const secret = 'sentinel-initiation-credential';
+ const error = Object.assign(new Error(secret), {
+ config: { headers: { Authorization: secret }, data: secret },
+ response: { status: 401, data: { client_secret: secret } },
+ });
const mockFlowManager = {
- getFlowState: jest.fn().mockRejectedValue(new Error('Database error')),
+ getFlowState: jest.fn().mockRejectedValue(error),
};
getLogStores.mockReturnValue({});
@@ -704,6 +716,12 @@ describe('MCP Routes', () => {
expect(response.status).toBe(500);
expect(response.body).toEqual({ error: 'Failed to initiate OAuth' });
+ const { logger } = require('@librechat/data-schemas');
+ expect(logger.error).toHaveBeenCalledWith('[MCP OAuth] Failed to initiate OAuth', {
+ type: 'Error',
+ status: 401,
+ });
+ expect(inspect(logger.error.mock.calls, { depth: null })).not.toContain(secret);
});
it('should return 400 when flow state metadata is null', async () => {
@@ -802,6 +820,28 @@ describe('MCP Routes', () => {
expect(response.headers.location).toBe(`${basePath}/oauth/error?error=access_denied`);
});
+ it.each([undefined, 'sentinel-provider-error'])(
+ 'keeps callback query values out of diagnostics, provider error: %s',
+ async (error) => {
+ const nonce = 'sentinel-callback-nonce';
+ MCPOAuthHandler.resolveStateToFlowId.mockResolvedValueOnce(null);
+ const response = await request(app).get('/api/mcp/test-server/oauth/callback').query({
+ code: 'sentinel-authorization-code',
+ state: nonce,
+ error,
+ });
+ const { logger } = require('@librechat/data-schemas');
+ const diagnostics = inspect(
+ [logger.debug, logger.info, logger.warn, logger.error].map((log) => log.mock.calls),
+ { depth: null },
+ );
+ expect(response.status).toBe(302);
+ expect(diagnostics).not.toContain(nonce);
+ expect(diagnostics).not.toContain('sentinel-authorization-code');
+ expect(diagnostics).not.toContain('sentinel-provider-error');
+ },
+ );
+
describe('OAuth error callback failFlow', () => {
it('should fail the flow when OAuth error is received with valid CSRF cookie', async () => {
const flowId = 'test-user-id:test-server';
@@ -2064,7 +2104,12 @@ describe('MCP Routes', () => {
});
it('should redirect to error page when callback processing fails', async () => {
- MCPOAuthHandler.getFlowState.mockRejectedValue(new Error('Callback error'));
+ const secret = 'sentinel-callback-credential';
+ const error = Object.assign(new Error(secret), {
+ config: { data: secret, headers: { Authorization: secret } },
+ response: { status: 401, data: { refresh_token: secret } },
+ });
+ MCPOAuthHandler.getFlowState.mockRejectedValue(error);
const flowId = 'test-user-id:test-server';
const csrfToken = generateTestCsrfToken(flowId);
@@ -2079,6 +2124,12 @@ describe('MCP Routes', () => {
expect(response.status).toBe(302);
expect(response.headers.location).toBe(`${basePath}/oauth/error?error=callback_failed`);
+ const { logger } = require('@librechat/data-schemas');
+ expect(logger.error).toHaveBeenCalledWith('[MCP OAuth] OAuth callback error', {
+ type: 'Error',
+ status: 401,
+ });
+ expect(inspect(logger.error.mock.calls, { depth: null })).not.toContain(secret);
});
it('should handle system-level OAuth completion', async () => {
diff --git a/api/server/routes/mcp.js b/api/server/routes/mcp.js
index f9c45b6a57..e81bbcd98a 100644
--- a/api/server/routes/mcp.js
+++ b/api/server/routes/mcp.js
@@ -10,6 +10,7 @@ const {
} = require('librechat-data-provider');
const {
getBasePath,
+ getSafeErrorMetadata,
createSafeUser,
createAuthIdentityContext,
MCPOAuthHandler,
@@ -249,7 +250,7 @@ router.get('/:serverName/oauth/initiate', requireJwtAuth, setOAuthSession, async
getTenantId(),
);
- logger.debug('[MCP OAuth] OAuth flow initiated', { oauthFlowId, authorizationUrl });
+ logger.debug('[MCP OAuth] OAuth flow initiated', { oauthFlowId });
const oldState = flowState.metadata?.state;
if (typeof oldState === 'string') {
@@ -266,7 +267,7 @@ router.get('/:serverName/oauth/initiate', requireJwtAuth, setOAuthSession, async
setOAuthCsrfCookie(res, oauthFlowId, OAUTH_CSRF_COOKIE_PATH);
res.redirect(authorizationUrl);
} catch (error) {
- logger.error('[MCP OAuth] Failed to initiate OAuth', error);
+ logger.error('[MCP OAuth] Failed to initiate OAuth', getSafeErrorMetadata(error));
res.status(500).json({ error: 'Failed to initiate OAuth' });
}
});
@@ -284,12 +285,12 @@ router.get('/:serverName/oauth/callback', async (req, res) => {
logger.debug('[MCP OAuth] Callback received', {
serverName,
code: code ? 'present' : 'missing',
- state,
- error: oauthError,
+ hasState: !!state,
+ hasError: !!oauthError,
});
if (oauthError) {
- logger.error('[MCP OAuth] OAuth error received', { error: oauthError });
+ logger.error('[MCP OAuth] OAuth error received');
// Gate failFlow behind callback validation to prevent DoS via leaked state
if (state && typeof state === 'string') {
try {
@@ -321,7 +322,6 @@ router.get('/:serverName/oauth/callback', async (req, res) => {
);
logger.debug('[MCP OAuth] Marked flow as FAILED with OAuth error', {
flowId,
- error: oauthError,
});
} else {
logger.warn('[MCP OAuth] Skipping failFlow for superseded OAuth error callback', {
@@ -332,7 +332,7 @@ router.get('/:serverName/oauth/callback', async (req, res) => {
}
}
} catch (err) {
- logger.debug('[MCP OAuth] Could not mark flow as failed', err);
+ logger.debug('[MCP OAuth] Could not mark flow as failed', getSafeErrorMetadata(err));
}
}
return res.redirect(
@@ -355,7 +355,7 @@ router.get('/:serverName/oauth/callback', async (req, res) => {
const flowId = await MCPOAuthHandler.resolveStateToFlowId(state, flowManager);
if (!flowId) {
- logger.error('[MCP OAuth] Could not resolve state to flow ID', { state });
+ logger.error('[MCP OAuth] Could not resolve state to flow ID');
return res.redirect(`${basePath}/oauth/error?error=invalid_state`);
}
logger.debug('[MCP OAuth] Resolved flow ID from state', { flowId });
@@ -494,7 +494,7 @@ router.get('/:serverName/oauth/callback', async (req, res) => {
} catch (error) {
logger.warn(
`[MCP OAuth] Failed to revoke ${tokenType} token after callback cancellation:`,
- error,
+ getSafeErrorMetadata(error),
);
}
}
@@ -570,7 +570,7 @@ router.get('/:serverName/oauth/callback', async (req, res) => {
phase === 'prepare'
? '[MCP OAuth] Failed to clear cached token flow state'
: '[MCP OAuth] Failed to wake a pending token flow',
- error,
+ getSafeErrorMetadata(error),
),
},
);
@@ -579,7 +579,10 @@ router.get('/:serverName/oauth/callback', async (req, res) => {
userId: flowState.userId,
});
} catch (error) {
- logger.error('[MCP OAuth] Failed to store OAuth tokens before flow completion', error);
+ logger.error(
+ '[MCP OAuth] Failed to store OAuth tokens before flow completion',
+ getSafeErrorMetadata(error),
+ );
throw error;
}
@@ -604,7 +607,7 @@ router.get('/:serverName/oauth/callback', async (req, res) => {
} catch (error) {
logger.warn(
`[MCP OAuth] Could not resolve server config for ${serverName} before reconnecting:`,
- error,
+ getSafeErrorMetadata(error),
);
}
@@ -640,7 +643,7 @@ router.get('/:serverName/oauth/callback', async (req, res) => {
} catch (error) {
logger.warn(
`[MCP OAuth] Could not resolve customUserVars for ${serverName} before reconnecting:`,
- error,
+ getSafeErrorMetadata(error),
);
}
}
@@ -708,7 +711,7 @@ router.get('/:serverName/oauth/callback', async (req, res) => {
} catch (error) {
logger.warn(
`[MCP OAuth] Failed to reconnect ${serverName} after OAuth, but tokens are saved:`,
- error,
+ getSafeErrorMetadata(error),
);
}
@@ -730,7 +733,7 @@ router.get('/:serverName/oauth/callback', async (req, res) => {
const redirectUrl = `${basePath}/oauth/success?serverName=${encodeURIComponent(serverName)}`;
res.redirect(redirectUrl);
} catch (error) {
- logger.error('[MCP OAuth] OAuth callback error', error);
+ logger.error('[MCP OAuth] OAuth callback error', getSafeErrorMetadata(error));
res.redirect(`${basePath}/oauth/error?error=callback_failed`);
}
});
@@ -766,7 +769,7 @@ router.get('/oauth/tokens/:flowId', requireJwtAuth, async (req, res) => {
res.json({ tokens: flowState.result });
} catch (error) {
- logger.error('[MCP OAuth] Failed to get tokens', error);
+ logger.error('[MCP OAuth] Failed to get tokens', getSafeErrorMetadata(error));
res.status(500).json({ error: 'Failed to get tokens' });
}
});
@@ -790,7 +793,7 @@ router.post('/:serverName/oauth/bind', requireJwtAuth, setOAuthSession, async (r
res.json({ success: true });
} catch (error) {
- logger.error('[MCP OAuth] Failed to set CSRF binding cookie', error);
+ logger.error('[MCP OAuth] Failed to set CSRF binding cookie', getSafeErrorMetadata(error));
res.status(500).json({ error: 'Failed to bind OAuth flow' });
}
});
@@ -827,7 +830,7 @@ router.get('/oauth/status/:flowId', requireJwtAuth, async (req, res) => {
error: flowState.error,
});
} catch (error) {
- logger.error('[MCP OAuth] Failed to get flow status', error);
+ logger.error('[MCP OAuth] Failed to get flow status', getSafeErrorMetadata(error));
res.status(500).json({ error: 'Failed to get flow status' });
}
});
@@ -874,7 +877,7 @@ router.post('/oauth/cancel/:serverName', requireJwtAuth, async (req, res) => {
message: `OAuth flow for ${serverName} cancelled successfully`,
});
} catch (error) {
- logger.error('[MCP OAuth Cancel] Failed to cancel OAuth flow', error);
+ logger.error('[MCP OAuth Cancel] Failed to cancel OAuth flow', getSafeErrorMetadata(error));
res.status(500).json({ error: 'Failed to cancel OAuth flow' });
}
});
diff --git a/api/server/services/ActionService.js b/api/server/services/ActionService.js
index d46b9e9dd8..072512a079 100644
--- a/api/server/services/ActionService.js
+++ b/api/server/services/ActionService.js
@@ -9,6 +9,7 @@ const {
logAxiosError,
detachOnAbort,
getTokenExpiresAt,
+ getSafeErrorMetadata,
getOAuthCallbackUrl,
refreshAccessToken,
GenerationJobManager,
@@ -320,7 +321,7 @@ async function createActionTool({
throw error;
}
const errorMessage = 'Failed to authenticate OAuth tool';
- logger.error(errorMessage, error);
+ logger.error(errorMessage, getSafeErrorMetadata(error));
throw new Error(errorMessage);
}
};
@@ -395,7 +396,10 @@ async function createActionTool({
if (isAbortError(error)) {
throw error;
}
- logger.error('Failed to refresh token, requesting new login:', error);
+ logger.error(
+ 'Failed to refresh token, requesting new login:',
+ getSafeErrorMetadata(error),
+ );
await requestLogin();
}
} else {
diff --git a/api/server/services/ActionService.spec.js b/api/server/services/ActionService.spec.js
index 5ec4bf62ee..58b37d79fc 100644
--- a/api/server/services/ActionService.spec.js
+++ b/api/server/services/ActionService.spec.js
@@ -1,3 +1,4 @@
+const { inspect } = require('util');
const dataSchemas = require('@librechat/data-schemas');
const { logger } = dataSchemas;
const { Constants, actionDelimiter, actionDomainSeparator } = require('librechat-data-provider');
@@ -557,6 +558,56 @@ describe('createActionTool OAuth abort identity', () => {
};
}
+ it.each(['oauth', 'oauth_refresh'])('does not log raw %s failures', async (flowType) => {
+ const secret = 'sentinel-oauth-credential';
+ const error = Object.assign(new Error(secret), {
+ config: { data: `client_secret=${secret}&refresh_token=${secret}` },
+ response: { status: 400, data: { refresh_token: secret } },
+ });
+ const { requestBuilder, preparedExecutor } = oauthToolFixture();
+ const refreshToken = await dataSchemas.encryptV2('refresh-token');
+ mockFindToken.mockImplementation(async ({ type }) =>
+ flowType === 'oauth_refresh' && type === 'oauth_refresh' ? { token: refreshToken } : null,
+ );
+ mockActionFlowManager.createFlowWithHandler.mockImplementation(
+ async (_flowId, type, handler) => {
+ if (type === 'oauth_refresh') {
+ throw error;
+ }
+ return handler();
+ },
+ );
+ mockActionFlowManager.createFlow.mockRejectedValue(error);
+
+ const actionTool = await createActionTool({
+ userId: 'action-user',
+ res: {},
+ action: oauthAction,
+ requestBuilder,
+ encrypted: {
+ oauth_client_id: 'encrypted-client-id',
+ oauth_client_secret: 'encrypted-client-secret',
+ },
+ streamId: 'action-oauth-stream',
+ });
+
+ const result = await actionTool._call({}, callConfig(new AbortController().signal));
+
+ expect(result).toContain('Failed to authenticate OAuth tool');
+ expect(logger.error).toHaveBeenCalledWith('Failed to authenticate OAuth tool', {
+ type: 'Error',
+ status: 400,
+ });
+ if (flowType === 'oauth_refresh') {
+ expect(logger.error).toHaveBeenCalledWith('Failed to refresh token, requesting new login:', {
+ type: 'Error',
+ status: 400,
+ });
+ }
+ expect(inspect(logger.error.mock.calls, { depth: null })).not.toContain(secret);
+ expect(preparedExecutor.execute).not.toHaveBeenCalled();
+ });
+
it('does not request a fresh login when a stopped run detaches from a refresh', async () => {
const { requestBuilder, preparedExecutor } = oauthToolFixture();
/** No access token but a live refresh token: the branch that waits on the
diff --git a/packages/api/src/mcp/__tests__/MCPConnectionFactory.oauthSdk.integration.test.ts b/packages/api/src/mcp/__tests__/MCPConnectionFactory.oauthSdk.integration.test.ts
index 5481754026..0537709e1a 100644
--- a/packages/api/src/mcp/__tests__/MCPConnectionFactory.oauthSdk.integration.test.ts
+++ b/packages/api/src/mcp/__tests__/MCPConnectionFactory.oauthSdk.integration.test.ts
@@ -1,4 +1,6 @@
import { Keyv } from 'keyv';
+import { inspect } from 'util';
+import { logger } from '@librechat/data-schemas';
import type { TokenMethods, IUser } from '@librechat/data-schemas';
import type {
OAuthClientInformation,
@@ -546,9 +548,13 @@ describe('MCPConnectionFactory OAuth against real SDK Streamable HTTP server', (
it.each(['invalid_client', 'invalid_grant'])(
'still requests consent for a permanent HTTP 400 %s',
async (error) => {
+ const secret = 'sentinel-provider-refresh-credential';
server = await createOAuthMCPServer({
issueRefreshTokens: true,
- refreshFailure: () => ({ status: 400, body: JSON.stringify({ error }) }),
+ refreshFailure: () => ({
+ status: 400,
+ body: JSON.stringify({ error, error_description: secret }),
+ }),
});
const initial = await issueTokens(server);
await storeTokens(tokenStore, server, { ...initial, expires_at: Date.now() - 1000 });
@@ -578,6 +584,9 @@ describe('MCPConnectionFactory OAuth against real SDK Streamable HTTP server', (
),
).rejects.toThrow('OAuth flow initiated');
expect(oauthStart).toHaveBeenCalledTimes(1);
+ expect(inspect(jest.mocked(logger.error).mock.calls, { depth: null })).not.toContain(
+ secret,
+ );
} finally {
await flowManager.deleteFlow(
MCPOAuthHandler.generateFlowId(USER_ID, SERVER_NAME),
diff --git a/packages/api/src/mcp/__tests__/MCPOAuthTokenExpiry.test.ts b/packages/api/src/mcp/__tests__/MCPOAuthTokenExpiry.test.ts
index 001ab42f62..39c686b90a 100644
--- a/packages/api/src/mcp/__tests__/MCPOAuthTokenExpiry.test.ts
+++ b/packages/api/src/mcp/__tests__/MCPOAuthTokenExpiry.test.ts
@@ -876,7 +876,7 @@ describe('MCP OAuth Token Expiry Scenarios', () => {
expect(result).toBeNull();
expect(logger.error).toHaveBeenCalledWith(
expect.stringContaining('Failed to refresh tokens'),
- expect.any(Error),
+ { type: 'Error' },
);
} finally {
await server.close();
diff --git a/packages/api/src/mcp/__tests__/MCPOAuthTokenStorage.test.ts b/packages/api/src/mcp/__tests__/MCPOAuthTokenStorage.test.ts
index 3d12cf4f67..48658b277d 100644
--- a/packages/api/src/mcp/__tests__/MCPOAuthTokenStorage.test.ts
+++ b/packages/api/src/mcp/__tests__/MCPOAuthTokenStorage.test.ts
@@ -6,6 +6,8 @@
*/
import { Keyv } from 'keyv';
+import { inspect } from 'util';
+import { logger } from '@librechat/data-schemas';
import type { TokenMethods } from '@librechat/data-schemas';
import type { MCPOAuthTokens } from '~/mcp/oauth';
import type { FlowLease } from '~/flow/manager';
@@ -1365,6 +1367,51 @@ describe('MCPTokenStorage', () => {
} satisfies Partial<MCPTokenRefreshUnavailableError>);
});
+ it('keeps refresh credentials out of downstream logs and wrapped failures', async () => {
+ const secret = 'sentinel-refresh-credential';
+ await createBoundToken(store, {
+ userId: 'u1',
+ type: 'mcp_oauth_refresh',
+ identifier: 'mcp:srv1:refresh',
+ token: `enc:${secret}`,
+ expiresIn: 86400,
+ });
+ const error = Object.assign(new Error(`Provider echoed ${secret}`), {
+ response: { status: 400, data: { refresh_token: secret } },
+ config: { headers: { Authorization: secret } },
+ });
+ const refreshTokens = jest.fn().mockRejectedValue(error);
+ const failure = await MCPTokenStorage.getTokens({
+ userId: 'u1',
+ serverName: 'srv1',
+ findToken: store.findToken,
+ createToken: store.createToken,
+ refreshTokens,
+ }).catch((error: unknown) => error);
+
+ expect(refreshTokens).toHaveBeenCalledTimes(1);
+ expect(failure).toBeInstanceOf(MCPTokenRefreshUnavailableError);
+ expect(failure).toMatchObject({
+ cause: { message: 'OAuth token refresh failed', status: 400 },
+ });
+ expect(logger.error).toHaveBeenCalledWith(
+ expect.stringContaining('Failed to refresh tokens'),
+ {
+ type: 'Error',
+ status: 400,
+ },
+ );
+ expect(inspect(jest.mocked(logger.error).mock.calls, { depth: null })).not.toContain(secret);
+ expect(inspect(failure, { depth: null })).not.toContain(secret);
+ expect(
+ await store.findToken({
+ userId: 'u1',
+ type: 'mcp_oauth_refresh',
+ identifier: 'mcp:srv1:refresh',
+ }),
+ ).toMatchObject({ token: `enc:${secret}` });
+ });
+
it('should return null when no refreshTokens callback provided', async () => {
await createBoundToken(store, {
userId: 'u1',
diff --git a/packages/api/src/mcp/__tests__/handler.test.ts b/packages/api/src/mcp/__tests__/handler.test.ts
index fab70866e7..f3101f14f3 100644
--- a/packages/api/src/mcp/__tests__/handler.test.ts
+++ b/packages/api/src/mcp/__tests__/handler.test.ts
@@ -1,3 +1,5 @@
+import { inspect } from 'util';
+import { logger } from '@librechat/data-schemas';
import { TokenExchangeMethodEnum } from 'librechat-data-provider';
import type { AuthorizationServerMetadata } from '@modelcontextprotocol/sdk/shared/auth.js';
import type { MCPOptions } from 'librechat-data-provider';
@@ -103,6 +105,156 @@ describe('MCPOAuthHandler - Configurable OAuth Metadata', () => {
});
});
+ describe('credential-safe diagnostics', () => {
+ const secret = 'sentinel-client-secret';
+ const verifier = 'sentinel-pkce-verifier';
+ const header = 'sentinel-oauth-header';
+ const config: MCPOptions['oauth'] = {
+ authorization_url: 'https://auth.example.com/oauth/authorize',
+ token_url: 'https://auth.example.com/oauth/token',
+ client_id: 'test-client',
+ client_secret: secret,
+ };
+
+ beforeEach(() => {
+ mockDiscoverOAuthProtectedResourceMetadata.mockResolvedValue({
+ resource: mockServerUrl,
+ authorization_servers: ['https://auth.example.com'],
+ });
+ mockDiscoverAuthorizationServerMetadata.mockResolvedValue({
+ issuer: 'https://auth.example.com',
+ authorization_endpoint: config.authorization_url,
+ token_endpoint: config.token_url,
+ registration_endpoint: 'https://auth.example.com/register',
+ response_types_supported: ['code'],
+ } as AuthorizationServerMetadata);
+ mockRegisterClient.mockResolvedValue({
+ client_id: 'test-client',
+ client_secret: secret,
+ redirect_uris: [],
+ logo_uri: undefined,
+ tos_uri: undefined,
+ });
+ mockStartAuthorization.mockResolvedValue({
+ authorizationUrl: new URL('https://auth.example.com/oauth/authorize'),
+ codeVerifier: verifier,
+ });
+ });
+
+ afterEach(() => {
+ mockDiscoverOAuthProtectedResourceMetadata.mockReset();
+ mockDiscoverAuthorizationServerMetadata.mockReset();
+ mockRegisterClient.mockReset();
+ });
+
+ function loggedDiagnostics() {
+ return inspect(
+ [logger.debug, logger.info, logger.warn, logger.error].map(
+ (log) => jest.mocked(log).mock.calls,
+ ),
+ { depth: null },
+ );
+ }
+
+ it.each([true, false])(
+ 'keeps credentials in the flow but not logs, configured: %s',
+ async (configured) => {
+ const result = await MCPOAuthHandler.initiateOAuthFlow(
+ mockServerName,
+ mockServerUrl,
+ mockUserId,
+ { Authorization: header },
+ configured ? config : undefined,
+ );
+
+ expect(result.flowMetadata.clientInfo?.client_secret).toBe(secret);
+ expect(result.flowMetadata.codeVerifier).toBe(verifier);
+ expect(result.flowMetadata.oauthHeaders).toEqual({ Authorization: header });
+ expect(new URL(result.authorizationUrl).searchParams.get('state')).toBe(
+ result.flowMetadata.state,
+ );
+ for (const value of [secret, verifier, header, result.flowMetadata.state]) {
+ expect(loggedDiagnostics()).not.toContain(value);
+ }
+ },
+ );
+
+ it.each([true, false])('omits raw initiation failures, configured: %s', async (configured) => {
+ const error = Object.assign(new Error(secret), {
+ response: { status: 400, data: { client_secret: secret } },
+ });
+ mockStartAuthorization.mockRejectedValueOnce(error);
+
+ await expect(
+ MCPOAuthHandler.initiateOAuthFlow(
+ mockServerName,
+ mockServerUrl,
+ mockUserId,
+ {},
+ configured ? config : undefined,
+ ),
+ ).rejects.toBe(error);
+ expect(logger.error).toHaveBeenCalledWith('[MCPOAuth] Failed to initiate OAuth flow', {
+ error: { type: 'Error', status: 400 },
+ serverName: mockServerName,
+ userId: mockUserId,
+ });
+ expect(loggedDiagnostics()).not.toContain(secret);
+ });
+
+ it('sanitizes token-exchange errors before persisting or propagating the failure', async () => {
+ const error = Object.assign(new Error(secret), {
+ config: { data: secret, headers: { Authorization: header } },
+ response: { status: 401, data: { refresh_token: secret } },
+ });
+ const failFlowIfCurrent = jest.fn().mockResolvedValue('updated');
+ const flowManager = {
+ getFlowState: jest.fn().mockResolvedValue({
+ createdAt: 123,
+ metadata: {
+ serverName: mockServerName,
+ serverUrl: mockServerUrl,
+ state: 'flow-state',
+ codeVerifier: verifier,
+ clientInfo: { client_id: 'test-client', client_secret: secret },
+ metadata: {},
+ },
+ }),
+ failFlowIfCurrent,
+ } as unknown as FlowStateManager<MCPOAuthTokens>;
+ mockExchangeAuthorization.mockRejectedValueOnce(error);
+
+ const failure = await MCPOAuthHandler.completeOAuthFlow(
+ 'test-flow',
+ 'auth-code',
+ flowManager,
+ {},
+ ).catch((error: unknown) => error);
+ expect(failure).toEqual(
+ expect.objectContaining({
+ message: 'OAuth token exchange failed',
+ status: 401,
+ }),
+ );
+ expect(failure).not.toBe(error);
+ expect(inspect(failure, { depth: null })).not.toContain(secret);
+ expect(inspect(failure, { depth: null })).not.toContain(header);
+ expect(failFlowIfCurrent).toHaveBeenCalledWith(
+ 'test-flow',
+ 'mcp_oauth',
+ 123,
+ 'flow-state',
+ failure,
+ );
+ expect(logger.error).toHaveBeenCalledWith('[MCPOAuth] Failed to complete OAuth flow', {
+ error: { type: 'Error', status: 401 },
+ flowId: 'test-flow',
+ });
+ expect(loggedDiagnostics()).not.toContain(secret);
+ expect(loggedDiagnostics()).not.toContain(header);
+ });
+ });
+
describe('Pre-configured OAuth Metadata Fields', () => {
const baseConfig: MCPOptions['oauth'] = {
authorization_url: 'https://auth.example.com/oauth/authorize',
@@ -1129,6 +1281,10 @@ describe('MCPOAuthHandler - Configurable OAuth Metadata', () => {
).rejects.toThrow(
'Token refresh failed: 400 Bad Request - {"error":"invalid_request","error_description":"refresh_token.client_id: Field required"}',
);
+ expect(logger.error).toHaveBeenCalledWith(
+ '[MCPOAuth] Failed to refresh tokens for test-server',
+ { type: 'Error' },
+ );
});
describe('stored token endpoint binding', () => {
diff --git a/packages/api/src/mcp/oauth/errors.spec.ts b/packages/api/src/mcp/oauth/errors.spec.ts
new file mode 100644
index 0000000000..207ffdff89
--- /dev/null
+++ b/packages/api/src/mcp/oauth/errors.spec.ts
@@ -0,0 +1,53 @@
+import { inspect } from 'util';
+import {
+ ServerError,
+ InvalidGrantError,
+ InvalidClientError,
+ InvalidRequestError,
+ UnauthorizedClientError,
+} from '@modelcontextprotocol/sdk/server/auth/errors.js';
+import { getSafeOAuthError } from './errors';
+
+const secret = 'sentinel-provider-credential';
+
+describe('getSafeOAuthError', () => {
+ it.each([
+ new Error(secret),
+ Object.assign(new Error(secret), {
+ config: { data: secret },
+ response: { status: 401, data: { refresh_token: secret } },
+ cause: new Error(secret),
+ }),
+ secret,
+ ])('drops provider text, request metadata and causes', (error) => {
+ const safe = getSafeOAuthError(error, 'OAuth token exchange failed');
+ expect(safe.message).toBe('OAuth token exchange failed');
+ expect(safe.cause).toBeUndefined();
+ expect(inspect(safe, { depth: null })).not.toContain(secret);
+ });
+
+ it.each([
+ [new InvalidClientError(secret, `https://example.com/${secret}`), 'invalid_client'],
+ [new UnauthorizedClientError(secret), 'unauthorized_client'],
+ [new Error(`client_id mismatch: ${secret}`), 'invalid_client'],
+ [new Error(`invalid_grant: ${secret}`), 'invalid_grant'],
+ [new ServerError(`unknown client: ${secret}`), 'invalid_client'],
+ [new InvalidRequestError(`client_id mismatch: ${secret}`), 'invalid_client'],
+ [new InvalidGrantError(`client not found: ${secret}`), 'invalid_client'],
+ [new ServerError(`client not found: ${secret}`), 'invalid_client'],
+ [new ServerError(`client_id mismatch: ${secret}`), 'invalid_client'],
+ ])('retains only allowlisted recovery codes', (error, code) => {
+ const safe = getSafeOAuthError(error, 'OAuth token exchange failed');
+ expect(safe.message).toBe(`OAuth token exchange failed (${code})`);
+ expect(inspect(safe, { depth: null })).not.toContain(secret);
+ });
+
+ it('retains bounded HTTP status', () => {
+ expect(
+ getSafeOAuthError(
+ Object.assign(new Error(secret), { response: { status: 401 } }),
+ 'OAuth token exchange failed',
+ ),
+ ).toMatchObject({ status: 401 });
+ });
+});
diff --git a/packages/api/src/mcp/oauth/errors.ts b/packages/api/src/mcp/oauth/errors.ts
new file mode 100644
index 0000000000..b593b5b12e
--- /dev/null
+++ b/packages/api/src/mcp/oauth/errors.ts
@@ -0,0 +1,33 @@
+import { OAuthError } from '@modelcontextprotocol/sdk/server/auth/errors.js';
+import { getSafeErrorMetadata } from '~/utils/errors';
+import { isInvalidClientMessage } from '~/mcp/utils';
+
+const OAUTH_ERROR_CODES = [
+ 'invalid_client',
+ 'unauthorized_client',
+ 'invalid_grant',
+ 'invalid_request',
+ 'invalid_scope',
+ 'invalid_target',
+ 'access_denied',
+ 'unsupported_grant_type',
+ 'server_error',
+ 'temporarily_unavailable',
+] as const;
+
+/** Keep recovery codes without propagating provider text, payloads, or causes. */
+export function getSafeOAuthError(error: unknown, message: string): Error {
+ const text = error instanceof Error ? error.message.toLowerCase() : '';
+ const sdkCode =
+ error instanceof OAuthError
+ ? OAUTH_ERROR_CODES.find((code) => code === error.errorCode)
+ : undefined;
+ const code = isInvalidClientMessage(text)
+ ? 'invalid_client'
+ : (sdkCode ?? OAUTH_ERROR_CODES.find((code) => text.includes(code)));
+
+ return Object.assign(
+ new Error(code ? `${message} (${code})` : message),
+ getSafeErrorMetadata(error),
+ );
+}
diff --git a/packages/api/src/mcp/oauth/handler.ts b/packages/api/src/mcp/oauth/handler.ts
index cc4d6a6d61..28edf8993e 100644
--- a/packages/api/src/mcp/oauth/handler.ts
+++ b/packages/api/src/mcp/oauth/handler.ts
@@ -36,8 +36,10 @@ import { isSSRFTarget, resolveHostnameSSRF, isOAuthUrlAllowed } from '~/auth';
import { MCPTokenStorage, MCPTokenRefreshUnavailableError } from './tokens';
import { probeResourceMetadataHint } from './resourceHint';
import { createHardenedOAuthFetch } from './hardenedFetch';
+import { getSafeErrorMetadata } from '~/utils/errors';
import { sanitizeUrlForLogging } from '~/mcp/utils';
import { getOAuthCallbackUrl } from '~/oauth/url';
+import { getSafeOAuthError } from './errors';
import { getOAuthUrlPort } from './url';
/** Type for the OAuth metadata from the SDK */
@@ -268,7 +270,7 @@ export class MCPOAuthHandler {
} catch (error) {
logger.warn(
`[MCPOAuth] Rejecting untrusted resource_metadata hint from ${sanitizeUrlForLogging(serverUrl)}; falling back to path-aware discovery`,
- { error },
+ { error: getSafeErrorMetadata(error) },
);
}
}
@@ -284,7 +286,7 @@ export class MCPOAuthHandler {
);
} catch (error) {
logger.debug('[MCPOAuth] Resource metadata discovery failed, continuing with server URL', {
- error,
+ error: getSafeErrorMetadata(error),
});
}
@@ -310,7 +312,7 @@ export class MCPOAuthHandler {
);
const authServerUrl = new URL(discoveredAuthServer);
logger.debug(
- `[MCPOAuth] Found authorization server from resource metadata: ${authServerUrl}`,
+ `[MCPOAuth] Found authorization server from resource metadata: ${sanitizeUrlForLogging(authServerUrl)}`,
);
return { resourceMetadata, authServerUrl };
} else {
@@ -415,7 +417,7 @@ export class MCPOAuthHandler {
} catch (error) {
logger.warn(
`[MCPOAuth] Authorization server metadata discovery failed for pre-configured client; using configured endpoints and defaults`,
- { error },
+ { error: getSafeErrorMetadata(error) },
);
return partialResult;
}
@@ -452,7 +454,7 @@ export class MCPOAuthHandler {
const baseUrl = new URL(serverUrl.origin);
logger.debug(
`[MCPOAuth] Discovery threw for path URL, trying base URL: ${sanitizeUrlForLogging(baseUrl)}`,
- { error: err },
+ { error: getSafeErrorMetadata(err) },
);
return discoverAuthorizationServerMetadata(baseUrl, { fetchFn });
}
@@ -737,7 +739,7 @@ export class MCPOAuthHandler {
if (supportedGrantTypes.includes('refresh_token')) {
requestedGrantTypes.push('refresh_token');
logger.debug(
- `[MCPOAuth] Server ${serverUrl} supports \`refresh_token\` grant type, adding to request`,
+ `[MCPOAuth] Server ${sanitizeUrlForLogging(serverUrl)} supports \`refresh_token\` grant type, adding to request`,
);
} else {
logger.debug(
@@ -813,7 +815,7 @@ export class MCPOAuthHandler {
const flowId = this.generateFlowId(userId, serverName, tenantId);
const state = this.generateState();
- logger.debug(`[MCPOAuth] Generated flowId: ${flowId}, state: ${state}`);
+ logger.debug(`[MCPOAuth] Generated flowId: ${flowId}`);
try {
this.assertNoUnpinnedClientSecret(config);
@@ -882,7 +884,7 @@ export class MCPOAuthHandler {
/** Preserve compatibility with OAuth providers that do not publish metadata. */
logger.warn(
`[MCPOAuth] OAuth metadata discovery failed for pre-configured client ${serverName}; using configured endpoints and defaults`,
- { error },
+ { error: getSafeErrorMetadata(error) },
);
}
@@ -949,7 +951,7 @@ export class MCPOAuthHandler {
config.revocation_endpoint_auth_methods_supported ??
discoveredMetadata?.revocation_endpoint_auth_methods_supported,
};
- logger.debug(`[MCPOAuth] metadata for "${serverName}": ${JSON.stringify(metadata)}`);
+ logger.debug(`[MCPOAuth] OAuth metadata resolved for "${serverName}"`);
const redirectUri = this.getDefaultRedirectUri(serverName);
const clientInfo: OAuthClientInformation = {
client_id: config.client_id,
@@ -1202,7 +1204,7 @@ export class MCPOAuthHandler {
logger.debug(`[MCPOAuth] Added audience parameter (discovered flow): ${config.audience}`);
}
} catch (error) {
- logger.error(`[MCPOAuth] startAuthorization failed:`, error);
+ logger.error(`[MCPOAuth] startAuthorization failed:`, getSafeErrorMetadata(error));
throw error;
}
@@ -1226,7 +1228,7 @@ export class MCPOAuthHandler {
};
logger.debug(
- `[MCPOAuth] Authorization URL generated for ${serverName}: ${authorizationUrl.toString()}`,
+ `[MCPOAuth] Authorization URL generated for ${serverName}: ${sanitizeUrlForLogging(authorizationUrl.toString())}`,
);
const result = {
@@ -1237,11 +1239,14 @@ export class MCPOAuthHandler {
logger.debug(
`[MCPOAuth] Returning from initiateOAuthFlow with result ${flowId} for ${serverName}`,
- result,
);
return result;
} catch (error) {
- logger.error('[MCPOAuth] Failed to initiate OAuth flow', { error, serverName, userId });
+ logger.error('[MCPOAuth] Failed to initiate OAuth flow', {
+ error: getSafeErrorMetadata(error),
+ serverName,
+ userId,
+ });
throw error;
}
}
@@ -1339,6 +1344,8 @@ export class MCPOAuthHandler {
metadata.allowedDomains,
metadata.allowedAddresses,
),
+ }).catch((error: unknown) => {
+ throw getSafeOAuthError(error, 'OAuth token exchange failed');
});
logger.debug('[MCPOAuth] Token exchange successful', {
@@ -1401,7 +1408,10 @@ export class MCPOAuthHandler {
return mcpTokens;
} catch (error) {
- logger.error('[MCPOAuth] Failed to complete OAuth flow', { error, flowId });
+ logger.error('[MCPOAuth] Failed to complete OAuth flow', {
+ error: getSafeErrorMetadata(error),
+ flowId,
+ });
if (observedFlowState) {
const observedMetadata = observedFlowState.metadata as MCPOAuthFlowMetadata | undefined;
await flowManager.failFlowIfCurrent(
@@ -2218,7 +2228,10 @@ export class MCPOAuthHandler {
const tokens = await response.json();
return this.processRefreshResponse(tokens, metadata.serverName, 'auto-discovered OAuth');
} catch (error) {
- logger.error(`[MCPOAuth] Failed to refresh tokens for ${metadata.serverName}`, error);
+ logger.error(
+ `[MCPOAuth] Failed to refresh tokens for ${metadata.serverName}`,
+ getSafeErrorMetadata(error),
+ );
throw error;
}
}
diff --git a/packages/api/src/mcp/oauth/tokens.ts b/packages/api/src/mcp/oauth/tokens.ts
index d3f7bc7c8f..5fb6d1d600 100644
--- a/packages/api/src/mcp/oauth/tokens.ts
+++ b/packages/api/src/mcp/oauth/tokens.ts
@@ -11,7 +11,9 @@ import type {
import type { OAuthTokens, OAuthClientInformation } from '@modelcontextprotocol/sdk/shared/auth.js';
import type { MCPOAuthTokens, ExtendedOAuthTokens, OAuthStoredClientMetadata } from './types';
import type { FlowLease, FlowStateManager } from '~/flow/manager';
+import { getSafeErrorMetadata } from '~/utils/errors';
import { isInvalidClientMessage } from '~/mcp/utils';
+import { getSafeOAuthError } from './errors';
import { isSystemUserId } from '~/mcp/enum';
export class ReauthenticationRequiredError extends Error {
@@ -1836,7 +1838,7 @@ export class MCPTokenStorage {
logger.info(`${logPrefix} Successfully refreshed and stored OAuth tokens`);
return storedTokens;
} catch (refreshError) {
- logger.error(`${logPrefix} Failed to refresh tokens`, refreshError);
+ logger.error(`${logPrefix} Failed to refresh tokens`, getSafeErrorMetadata(refreshError));
if (
refreshError instanceof ReauthenticationRequiredError ||
refreshError instanceof MCPTokenRefreshUnavailableError
@@ -1898,7 +1900,10 @@ export class MCPTokenStorage {
);
return null;
}
- throw new MCPTokenRefreshUnavailableError(serverName, refreshError);
+ throw new MCPTokenRefreshUnavailableError(
+ serverName,
+ getSafeOAuthError(refreshError, 'OAuth token refresh failed'),
+ );
}
}
diff --git a/packages/api/src/oauth/tokens.spec.ts b/packages/api/src/oauth/tokens.spec.ts
index 0ac2303724..5930c61b10 100644
--- a/packages/api/src/oauth/tokens.spec.ts
+++ b/packages/api/src/oauth/tokens.spec.ts
@@ -1,5 +1,6 @@
import axios from 'axios';
-import { decryptV2 } from '@librechat/data-schemas';
+import { inspect } from 'util';
+import { logger, decryptV2 } from '@librechat/data-schemas';
import { TokenExchangeMethodEnum } from 'librechat-data-provider';
import type { AxiosRequestConfig } from 'axios';
import { getAccessToken, refreshAccessToken } from './tokens';
@@ -78,6 +79,76 @@ describe('action OAuth token exchange validation', () => {
mockedAxios.mockResolvedValue({ data: tokenResponse });
});
+ describe.each(['exchange', 'refresh'] as const)('%s credential-safe diagnostics', (operation) => {
+ const message =
+ operation === 'exchange' ? 'Error exchanging OAuth code' : 'Error refreshing OAuth tokens';
+
+ function requestTokens() {
+ const fields = {
+ ...baseFields,
+ token_exchange_method: TokenExchangeMethodEnum.DefaultPost,
+ };
+ const methods = createTokenMethods();
+ return {
+ methods,
+ request:
+ operation === 'exchange'
+ ? getAccessToken(
+ {
+ ...fields,
+ code: 'authorization-code',
+ redirect_uri: 'https://chat.example.com/api/actions/action-1/oauth/callback',
+ },
+ methods,
+ )
+ : refreshAccessToken({ ...fields, refresh_token: 'refresh-token' }, methods),
+ };
+ }
+
+ it.each([true, false])('omits raw errors with an HTTP response: %s', async (hasResponse) => {
+ const secret = 'sentinel-oauth-credential';
+ const error = Object.assign(new Error(`Provider echoed ${secret}`), {
+ isAxiosError: true,
+ config: {
+ data: `client_secret=${secret}&refresh_token=${secret}`,
+ headers: { Authorization: `Basic ${secret}` },
+ url: `${baseFields.client_url}?secret=${secret}`,
+ },
+ request: { body: secret },
+ ...(hasResponse && {
+ response: {
+ status: 400,
+ data: { error_description: secret, refresh_token: secret },
+ headers: { 'set-cookie': secret },
+ },
+ }),
+ });
+ mockedAxios.mockRejectedValueOnce(error);
+ const { request, methods } = requestTokens();
+
+ await expect(request).rejects.toThrow(message);
+ expect(logger.error).toHaveBeenCalledWith(message, {
+ type: 'Error',
+ ...(hasResponse && { status: 400 }),
+ });
+ expect(inspect(jest.mocked(logger.error).mock.calls, { depth: null })).not.toContain(secret);
+ expect(methods.findToken).not.toHaveBeenCalled();
+ expect(methods.createToken).not.toHaveBeenCalled();
+ });
+
+ it('does not log or store a token response missing its access token', async () => {
+ const secret = 'sentinel-refresh-token';
+ mockedAxios.mockResolvedValueOnce({ data: { refresh_token: secret, extra: secret } });
+ const { request, methods } = requestTokens();
+
+ await expect(request).rejects.toThrow(message);
+ expect(logger.error).toHaveBeenCalledWith('Access token not found');
+ expect(inspect(jest.mocked(logger.error).mock.calls, { depth: null })).not.toContain(secret);
+ expect(methods.findToken).not.toHaveBeenCalled();
+ expect(methods.createToken).not.toHaveBeenCalled();
+ });
+ });
+
it.each([
'http://93.184.216.34/oauth/token',
'https://localhost/oauth/token',
diff --git a/packages/api/src/oauth/tokens.ts b/packages/api/src/oauth/tokens.ts
index e23e20c9ae..e1f677c7fc 100644
--- a/packages/api/src/oauth/tokens.ts
+++ b/packages/api/src/oauth/tokens.ts
@@ -2,8 +2,7 @@ import axios from 'axios';
import { logger, encryptV2 } from '@librechat/data-schemas';
import { TokenExchangeMethodEnum } from 'librechat-data-provider';
import type { IToken, TokenMethods } from '@librechat/data-schemas';
-import type { AxiosError } from 'axios';
-import { logAxiosError, outboundRequestBudget, DEFAULT_OUTBOUND_TIMEOUTS_MS } from '~/utils';
+import { getSafeErrorMetadata, outboundRequestBudget, DEFAULT_OUTBOUND_TIMEOUTS_MS } from '~/utils';
import { DEFAULT_OAUTH_TOKEN_TTL_SECONDS, normalizeExpiresIn } from './expiry';
import { validateActionOAuthEndpoint } from './validation';
import { decryptSensitiveValue } from '~/actions/crypto';
@@ -113,7 +112,7 @@ async function processAccessTokens(
) {
const { access_token, expires_in = 3600, refresh_token, refresh_token_expires_in } = tokenData;
if (!access_token) {
- logger.error('Access token not found: ', tokenData);
+ logger.error('Access token not found');
throw new Error('Access token not found');
}
const handleOAuthToken = createHandleOAuthToken({
@@ -239,12 +238,8 @@ export async function refreshAccessToken(
return response.data;
} catch (error) {
const message = 'Error refreshing OAuth tokens';
- throw new Error(
- logAxiosError({
- message,
- error: error as AxiosError,
- }),
- );
+ logger.error(message, getSafeErrorMetadata(error));
+ throw new Error(message);
}
}
@@ -351,11 +346,7 @@ export async function getAccessToken(
return response.data;
} catch (error) {
const message = 'Error exchanging OAuth code';
- throw new Error(
- logAxiosError({
- message,
- error: error as AxiosError,
- }),
- );
+ logger.error(message, getSafeErrorMetadata(error));
+ throw new Error(message);
}
}