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

6.2 KB
Raw Blame
/**
 * Real-SDK coverage for disposal landing mid-connect.
 *
 * A discovery caller that gives up on a slow `connect()` disposes immediately, so it can dispose
 * while `constructTransport()` is still pending. `dispose()` then finds no transport to close, and
 * without a post-await check the abandoned attempt goes on to connect, leaving a live session
 * nobody owns. Only transport construction is delayed here; the client, transport, and server are
 * real SDK objects, so the assertions are about a genuinely open or closed session rather than
 * about which mock was called.
 */
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';
import {
  ListToolsRequestSchema,
  InitializeRequestSchema,
} from '@modelcontextprotocol/sdk/types.js';
import { MCPConnection } from '~/mcp/connection';

jest.setTimeout(10_000);

jest.mock('@librechat/data-schemas', () => ({
  logger: {
    info: jest.fn(),
    warn: jest.fn(),
    error: jest.fn(),
    debug: jest.fn(),
  },
}));

jest.mock('~/auth', () => ({
  createSSRFSafeUndiciConnect: jest.fn(() => undefined),
  isOAuthUrlAllowed: jest.fn(() => false),
  isSSRFTarget: jest.fn(() => false),
  resolveHostnameSSRF: jest.fn(async () => false),
}));

describe('MCPConnection disposal during connect', () => {
  let server: Server | undefined;

  afterEach(async () => {
    await server?.close().catch(() => undefined);
    server = undefined;
  });

  it('does not charge a disposed initialize attempt to connection health', async () => {
    server = new Server({ name: 'cancelled-initialize', version: '1.0.0' }, { capabilities: {} });
    let started: (() => void) | undefined;
    const initializeStarted = new Promise<void>((resolve) => {
      started = resolve;
    });
    let finish: (() => void) | undefined;
    const gate = new Promise<void>((resolve) => {
      finish = resolve;
    });
    server.setRequestHandler(InitializeRequestSchema, async (request) => {
      started?.();
      await gate;
      return {
        protocolVersion: request.params.protocolVersion,
        capabilities: {},
        serverInfo: { name: 'cancelled-initialize', version: '1.0.0' },
      };
    });
    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
    await server.connect(serverTransport);
    const connection = new MCPConnection({
      serverName: 'cancelled-initialize',
      serverConfig: { type: 'streamable-http', url: 'http://localhost/mcp' },
      useSSRFProtection: false,
      directBearerRecoveryEnabled: true,
    });
    jest
      .spyOn(
        connection as unknown as { constructTransport: () => Promise<unknown> },
        'constructTransport',
      )
      .mockResolvedValue(clientTransport);
    const recordFailedRound = jest.spyOn(
      connection as unknown as { recordFailedRound: () => void },
      'recordFailedRound',
    );
    const connecting = connection.connectClient().catch((error: Error) => error);
    await initializeStarted;
    await connection.dispose();
    finish?.();
    await connecting;
    expect(recordFailedRound).not.toHaveBeenCalled();
    expect(await connection.isConnected()).toBe(false);
  });

  it('leaves no live session when disposal lands while the transport is being constructed', async () => {
    server = new Server(
      { name: 'dispose-race-server', version: '1.0.0' },
      { capabilities: { tools: {} } },
    );
    server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: [] }));

    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
    await server.connect(serverTransport);

    const connection = new MCPConnection({
      serverName: 'dispose-race',
      serverConfig: { type: 'streamable-http', url: 'http://localhost/mcp' },
      useSSRFProtection: false,
    });

    let serverSawClose = false;
    serverTransport.onclose = () => {
      serverSawClose = true;
    };

    /** The only stub: hold construction open so disposal can land inside this window. */
    let releaseTransport: (() => void) | undefined;
    const transportPending = new Promise<void>((resolve) => {
      releaseTransport = resolve;
    });
    jest
      .spyOn(
        connection as unknown as { constructTransport: () => Promise<unknown> },
        'constructTransport',
      )
      .mockImplementation(async () => {
        await transportPending;
        return clientTransport;
      });

    const connecting = connection.connectClient();
    await connection.dispose();
    releaseTransport?.();
    await connecting;

    /** A real `tools/list` is the honest probe: it succeeds over any session left open. */
    await expect(connection.client.listTools()).rejects.toThrow();
    expect(await connection.isConnected()).toBe(false);
    expect(serverSawClose).toBe(true);
  });
});

it('detaches a noncooperative header resolver on disposal without retiring another connection', async () => {
  let release!: () => void;
  const stalled = new Promise<void>((resolve) => {
    release = resolve;
  });
  const signals: AbortSignal[] = [];
  const headers = jest.fn(async (signal?: AbortSignal) => {
    signals.push(signal!);
    await stalled;
    return { authorization: 'Bearer waiter-only' };
  });
  const first = new MCPConnection({
    serverName: 'local-first',
    serverConfig: { type: 'streamable-http', url: 'https://resource.example/mcp' },
    resolveRequestHeaders: headers,
  });
  const second = new MCPConnection({
    serverName: 'local-second',
    serverConfig: { type: 'streamable-http', url: 'https://resource.example/mcp' },
    resolveRequestHeaders: headers,
  });
  const rejected = first['trackRequest'](() => first['authorizeRequestHeaders']()).catch(
    (error) => error,
  );
  const sibling = second['trackRequest'](() => second['authorizeRequestHeaders']());
  try {
    await first.dispose();
    await expect(rejected).resolves.toMatchObject({ name: 'AbortError' });
    expect(signals[0].aborted).toBe(true);
    expect(signals[1].aborted).toBe(false);
    release();
    await expect(sibling).resolves.toEqual({ authorization: 'Bearer waiter-only' });
    expect(Reflect.get(first, 'pendingRequests').size).toBe(0);
  } finally {
    release();
    await rejected;
    await sibling;
    await first.dispose();
    await second.dispose();
  }
});