🦺 fix: Skip Redundant MCP OAuth Probes and Teardown Cancellations (#16298)

* 🦺 fix: Skip Redundant MCP OAuth Probes and Teardown Cancellations

* 🧪 test: Complete OAuth Discovery Token Method Fixture

---------

Co-authored-by: Lia <lia@librechat.ai>
This commit is contained in:
lia-by-librechat[bot] 2026-09-24 07:44:52 -04:00 • committed by GitHub
parent 290e37e5c5
commit 8fb4056e8a
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
9 changed files with 250 additions and 27 deletions

View file

@ -403,6 +403,10 @@ export class MCPConnectionFactory {
return { tools: null, connection: null, oauthRequired: false, oauthUrl: null };
}
oauthTokens = loaded.value;
if (!oauthTokens && !this.usesObo && isOAuthServer(this.serverConfig)) {
oauthRequired = true;
shouldAttemptAuthenticatedDiscovery = false;
}
}
let connection: MCPConnection | null = null;

View file

@ -44,6 +44,7 @@ import { processMCPEnv, isPluginSourced } from '~/utils/env';
import { OAuthLifecycleRelay } from './oauth/pending';
import { preProcessGraphTokens } from '~/utils/graph';
import { isOwnedAbortError } from '~/utils/errors';
import { withMCPRequestSignal } from './signal';
import { formatToolContent } from './parsers';
import { MCPConnection } from './connection';
import { mcpConfig } from './mcpConfig';
@ -1526,20 +1527,23 @@ Please follow these instructions when using tools from the respective MCP server
}
const requestTool = () =>
connection!.client.request(
{
method: 'tools/call',
params: {
name: toolName,
arguments: toolArguments,
withMCPRequestSignal(options?.signal, (signal) =>
connection!.client.request(
{
method: 'tools/call',
params: {
name: toolName,
arguments: toolArguments,
},
},
},
CallToolResultSchema,
{
timeout: connection!.timeout,
resetTimeoutOnProgress: true,
...options,
},
CallToolResultSchema,
{
timeout: connection!.timeout,
resetTimeoutOnProgress: true,
...options,
signal,
},
),
);
const requestedCredentialSetId = connection.getOAuthCredentialSetId?.();

View file

@ -200,6 +200,95 @@ describe('MCPConnectionFactory OAuth against real SDK Streamable HTTP server', (
jest.clearAllMocks();
});
it('tries unauthenticated public tool listing only once when an OAuth server has no token', async () => {
const postHeaders: Array<string | undefined> = [];
server = await createOAuthMCPServer({
onResourceRequest: (request) => {
if (request.method === 'POST') postHeaders.push(request.headers.authorization);
},
});
const result = await MCPConnectionFactory.discoverTools(
{
serverName: SERVER_NAME,
serverConfig: { type: 'streamable-http', url: server.url, requiresOAuth: true },
},
{
useOAuth: true,
user: { id: USER_ID } as IUser,
flowManager: createFlowManager(),
tokenMethods: {
findToken: tokenStore.findToken,
createToken: tokenStore.createToken,
updateToken: tokenStore.updateToken,
deleteTokens: tokenStore.deleteTokens,
},
},
);
expect(result).toMatchObject({ tools: null, connection: null, oauthRequired: true });
expect(postHeaders).toEqual([undefined]);
});
it('does not cancel finished SDK requests when a shared run signal is aborted', async () => {
let resourcePosts = 0;
server = await createOAuthMCPServer({
onResourceRequest: (request) => {
if (request.method === 'POST') resourcePosts += 1;
},
});
const tokens = await issueTokens(server);
await storeTokens(tokenStore, server, tokens);
const flowManager = createFlowManager();
const tokenMethods = {
findToken: tokenStore.findToken,
createToken: tokenStore.createToken,
updateToken: tokenStore.updateToken,
deleteTokens: tokenStore.deleteTokens,
};
const serverConfig = {
type: 'streamable-http' as const,
url: server.url,
requiresOAuth: true,
};
connection = await MCPConnectionFactory.create(
{ serverName: SERVER_NAME, serverConfig },
{ useOAuth: true, user: { id: USER_ID } as IUser, flowManager, tokenMethods },
);
const manager = new MCPManager();
jest.spyOn(manager, 'getConnection').mockResolvedValue(connection);
const registrySpy = jest.spyOn(MCPServersRegistry, 'getInstance').mockReturnValue({
resolveAllowlists: jest.fn().mockResolvedValue({
allowedDomains: null,
allowedAddresses: null,
useSSRFProtection: false,
}),
} as unknown as MCPServersRegistry);
const controller = new AbortController();
try {
for (let index = 0; index < 3; index += 1) {
await expect(
manager.callTool({
user: { id: USER_ID } as IUser,
serverName: SERVER_NAME,
serverConfig,
toolName: 'echo',
toolArguments: { message: `call ${index}` },
provider: 'openai',
flowManager,
tokenMethods,
options: { signal: controller.signal },
}),
).resolves.toBeDefined();
}
const completedPosts = resourcePosts;
controller.abort(new Error('Run ended'));
await new Promise((resolve) => setTimeout(resolve, 30));
expect(resourcePosts).toBe(completedPosts);
} finally {
registrySpy.mockRestore();
}
});
it('refreshes an expired callback for the active connection and token waiter after publication settles', async () => {
server = await createOAuthMCPServer({
issueRefreshTokens: true,

View file

@ -4873,6 +4873,42 @@ describe('MCPConnectionFactory', () => {
{ name: 'tool2', description: 'Second tool', inputSchema: { type: 'object' } },
];
it('preserves public tool listing without a redundant OAuth connect when tokens are absent', async () => {
const serverConfig = {
type: 'streamable-http' as const,
url: 'https://mcp.example.com',
requiresOAuth: true,
};
mockProcessMCPEnv.mockImplementation(({ options }) => options);
mockFlowManager.createFlowWithHandler.mockResolvedValue(null);
mockConnectionInstance.connect.mockResolvedValue(undefined);
mockConnectionInstance.isConnected.mockResolvedValue(true);
mockConnectionInstance.fetchOrderedToolsSnapshot = jest.fn().mockResolvedValue({
tools: mockTools,
complete: true,
});
const result = await MCPConnectionFactory.discoverTools(
{ serverName: 'public-oauth', serverConfig },
{
useOAuth: true,
user: mockUser!,
flowManager: mockFlowManager,
tokenMethods: {
findToken: jest.fn(),
createToken: jest.fn(),
updateToken: jest.fn(),
deleteTokens: jest.fn(),
},
},
);
expect(result.tools).toEqual(mockTools);
expect(result.oauthRequired).toBe(true);
expect(mockMCPConnection).toHaveBeenCalledTimes(1);
expect(mockConnectionInstance.connect).toHaveBeenCalledTimes(1);
});
it('should discover tools from a successfully connected server', async () => {
const basicOptions = {
serverName: 'test-server',
@ -6165,7 +6201,7 @@ describe('MCPConnectionFactory', () => {
);
expect(result.tools).toEqual(mockTools);
expect(result.oauthRequired).toBe(false);
expect(result.oauthRequired).toBe(true);
expect(oauthOptions.oauthStart).not.toHaveBeenCalled();
expect(mockMCPOAuthHandler.initiateOAuthFlow).not.toHaveBeenCalled();
});

View file

@ -379,15 +379,18 @@ describe('MCPConnection.fetchTools pagination', () => {
expect(reserve).not.toHaveBeenCalled();
});
it('hands the caller signal to the SDK so an in-flight page is cancellable', async () => {
it('detaches a completed SDK page request from its caller signal', async () => {
const listTools = jest.fn().mockResolvedValue({ tools: [makeTool('a')] });
const conn = createConnectionWithListTools(listTools);
const signal = AbortSignal.timeout(5000);
const controller = new AbortController();
await conn.fetchToolsSnapshot(Date.now() + 5000, signal);
await conn.fetchToolsSnapshot(Date.now() + 5000, controller.signal);
const options = listTools.mock.calls[0][1]!;
expect(options.signal).toBe(signal);
expect(options.signal === controller.signal).toBe(false);
expect(options.signal?.aborted).toBe(false);
controller.abort();
expect(options.signal?.aborted).toBe(false);
});
it('makes no request and no reservation when the signal is already aborted', async () => {

View file

@ -81,6 +81,8 @@ export interface OAuthTestServerOptions {
refreshGate?: () => Promise<void> | undefined;
/** Optional test hook for controlling echo-tool completion. */
echoHandler?: (message: string) => string | Promise<string>;
/** Observes MCP resource requests, including unauthenticated and cancellation POSTs. */
onResourceRequest?: (request: http.IncomingMessage) => void;
}
export interface OAuthTokenRequestRecord {
@ -149,6 +151,7 @@ export async function createOAuthMCPServer(
requireResourceParameter = false,
rejectRefreshTokens = 0,
echoHandler,
onResourceRequest,
refreshFailure,
refreshGate,
} = options;
@ -466,6 +469,7 @@ export async function createOAuthMCPServer(
}
// All other paths require Bearer token auth
onResourceRequest?.(req);
const authHeader = req.headers.authorization;
if (!authHeader || !authHeader.startsWith('Bearer ')) {
writeBearerChallenge(res, 401, 'invalid_token', 'Missing Authorization header');

View file

@ -35,6 +35,7 @@ import { reserveMCPToolsChangedRevision } from './toolsChanged';
import { runOutsideTracing } from '~/utils/tracing';
import { mediaTypeEssence } from '~/utils/headers';
import { isAddressAllowed } from '~/auth/domain';
import { withMCPRequestSignal } from './signal';
import { withTimeout } from '~/utils/promise';
import { isOAuthServer } from './utils';
import { mcpConfig } from './mcpConfig';
@ -2740,11 +2741,13 @@ export class MCPConnection extends EventEmitter {
signal?: AbortSignal,
): Promise<MCPListToolsResult> {
try {
return await this.client.listTools(cursor != null ? { cursor } : undefined, {
timeout: timeoutMs,
maxTotalTimeout: timeoutMs,
signal,
});
return await withMCPRequestSignal(signal, (requestSignal) =>
this.client.listTools(cursor != null ? { cursor } : undefined, {
timeout: timeoutMs,
maxTotalTimeout: timeoutMs,
signal: requestSignal,
}),
);
} catch (error) {
this.emitError(error, 'Failed to fetch tools');
throw error;
@ -2793,7 +2796,9 @@ export class MCPConnection extends EventEmitter {
try {
// Try ping first as it's the lightest check
await this.client.ping({ signal });
await withMCPRequestSignal(signal, (requestSignal) =>
this.client.ping({ signal: requestSignal }),
);
return this.connectionState === 'connected';
} catch (error) {
if (probeAborted()) {
@ -2827,13 +2832,19 @@ export class MCPConnection extends EventEmitter {
// If we have capabilities, try calling a supported method to verify connection
if (capabilities?.tools) {
await this.client.listTools(undefined, { signal });
await withMCPRequestSignal(signal, (requestSignal) =>
this.client.listTools(undefined, { signal: requestSignal }),
);
return this.connectionState === 'connected';
} else if (capabilities?.resources) {
await this.client.listResources(undefined, { signal });
await withMCPRequestSignal(signal, (requestSignal) =>
this.client.listResources(undefined, { signal: requestSignal }),
);
return this.connectionState === 'connected';
} else if (capabilities?.prompts) {
await this.client.listPrompts(undefined, { signal });
await withMCPRequestSignal(signal, (requestSignal) =>
this.client.listPrompts(undefined, { signal: requestSignal }),
);
return this.connectionState === 'connected';
} else {
// No capabilities to test, but we're in connected state and initialization succeeded

View file

@ -0,0 +1,49 @@
import { withMCPRequestSignal } from './signal';
describe('withMCPRequestSignal', () => {
it('relays cancellation to an in-flight request and detaches on rejection', async () => {
const parent = new AbortController();
const reason = new Error('Stop');
const remove = jest.spyOn(parent.signal, 'removeEventListener');
const request = jest.fn(
(signal?: AbortSignal) =>
new Promise<never>((_resolve, reject) => {
signal?.addEventListener('abort', () => reject(signal.reason), { once: true });
}),
);
const pending = withMCPRequestSignal(parent.signal, request);
expect(request).toHaveBeenCalledTimes(1);
expect(request.mock.calls[0][0]).not.toBe(parent.signal);
parent.abort(reason);
await expect(pending).rejects.toBe(reason);
expect(remove).toHaveBeenCalledWith('abort', expect.any(Function));
});
it('does not abort a completed request when its parent is aborted later', async () => {
const parent = new AbortController();
const request = jest.fn(async (signal?: AbortSignal) => signal);
const child = await withMCPRequestSignal(parent.signal, request);
expect(child).toBeDefined();
parent.abort();
expect(child?.aborted).toBe(false);
});
it('does not start a request whose parent is already aborted', async () => {
const parent = new AbortController();
const reason = new Error('Stop');
parent.abort(reason);
const request = jest.fn(async () => undefined);
await expect(withMCPRequestSignal(parent.signal, request)).rejects.toBe(reason);
expect(request).not.toHaveBeenCalled();
});
it('passes through requests without a parent signal', async () => {
const request = jest.fn(async (signal?: AbortSignal) => signal);
await expect(withMCPRequestSignal(undefined, request)).resolves.toBeUndefined();
expect(request).toHaveBeenCalledWith(undefined);
});
});

View file

@ -0,0 +1,23 @@
/** The MCP SDK retains its abort listener after a response; never give it a long-lived run signal. */
export async function withMCPRequestSignal<T>(
parent: AbortSignal | undefined,
request: (signal: AbortSignal | undefined) => Promise<T>,
): Promise<T> {
if (!parent) {
return request(undefined);
}
parent.throwIfAborted();
const controller = new AbortController();
const onAbort = () => controller.abort(parent.reason);
parent.addEventListener('abort', onAbort, { once: true });
try {
if (parent.aborted) {
onAbort();
parent.throwIfAborted();
}
return await request(controller.signal);
} finally {
parent.removeEventListener('abort', onAbort);
}
}