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

97.5 KB
Raw Blame
/**
 * Integration tests for MCP SSRF protections.
 *
 * These tests spin up real in-process HTTP servers and verify that MCPConnection:
 *
 * 1. Does NOT follow 301/302 redirects from SSE/StreamableHTTP transports
 *    (redirect: 'manual' prevents SSRF via server-controlled 301/302)
 * 2. DOES follow 307/308 redirects (method-preserving) with a depth limit of 5,
 *    as required by servers like Coda that route doc-scoped tool calls via 308
 * 3. Blocks WebSocket connections to hosts that DNS-resolve to private IPs,
 *    regardless of whether useSSRFProtection is enabled (allowlist scenario)
 */

import * as net from 'net';
import * as http from 'http';
import { randomUUID } from 'crypto';
import { Request as UndiciRequest } from 'undici';
import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
import type {
  RequestInfo as UndiciRequestInfo,
  RequestInit as UndiciRequestInit,
  Response as UndiciResponse,
} from 'undici';
import type { Socket } from 'net';
import { createSSRFSafeUndiciConnect, resolveHostnameSSRF } from '~/auth';
import { ScheduledMCPBearerError } from '~/mcp/errors';
import { MCPConnection } from '~/mcp/connection';

type CustomFetch = (input: UndiciRequestInfo, init?: UndiciRequestInit) => Promise<UndiciResponse>;
type LookupAddress = string | Array<{ address: string; family: number }>;
type LookupCallback = (
  err: NodeJS.ErrnoException | null,
  address: LookupAddress,
  family?: number,
) => void;

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

jest.mock('~/auth', () => ({
  createSSRFSafeUndiciConnect: jest.fn(() => ({
    lookup: (_hostname: string, optionsOrCallback: unknown, maybeCallback?: LookupCallback) => {
      const callback =
        typeof optionsOrCallback === 'function'
          ? (optionsOrCallback as LookupCallback)
          : maybeCallback;
      if (!callback) {
        throw new Error('lookup callback missing');
      }
      if (
        typeof optionsOrCallback === 'object' &&
        optionsOrCallback != null &&
        'all' in optionsOrCallback &&
        optionsOrCallback.all === true
      ) {
        callback(null, [{ address: '127.0.0.1', family: 4 }]);
        return;
      }
      callback(null, '127.0.0.1', 4);
    },
  })),
  isOAuthUrlAllowed: jest.fn(() => false),
  isSSRFTarget: jest.fn(() => false),
  resolveHostnameSSRF: jest.fn(async () => false),
}));

jest.mock('~/mcp/mcpConfig', () => ({
  mcpConfig: {
    CONNECTION_CHECK_TTL: 0,
    TOOLS_LIST_MAX_PAGES: 50,
    TOOLS_LIST_MAX_TOOLS: 1000,
    TOOLS_LIST_MAX_BYTES: 5 * 1024 * 1024,
    TOOLS_LIST_TIMEOUT_MS: 30000,
  },
}));

const mockedResolveHostnameSSRF = resolveHostnameSSRF as jest.MockedFunction<
  typeof resolveHostnameSSRF
>;
const mockedCreateSSRFSafeUndiciConnect = createSSRFSafeUndiciConnect as jest.MockedFunction<
  typeof createSSRFSafeUndiciConnect
>;

function getLookupCallback(
  optionsOrCallback: unknown,
  maybeCallback?: LookupCallback,
): LookupCallback {
  if (typeof optionsOrCallback === 'function') {
    return optionsOrCallback as LookupCallback;
  }
  if (maybeCallback) {
    return maybeCallback;
  }
  throw new Error('lookup callback missing');
}

function createRebindBlockingLookup(): jest.Mock {
  return jest.fn((hostname: string, optionsOrCallback: unknown, maybeCallback?: LookupCallback) => {
    const callback = getLookupCallback(optionsOrCallback, maybeCallback);
    if (hostname !== 'rebind.test') {
      callback(null, '127.0.0.1', 4);
      return;
    }
    const err = Object.assign(
      new Error('SSRF protection: rebind.test resolved to blocked address 127.0.0.1'),
      { code: 'ESSRF' },
    ) as NodeJS.ErrnoException;
    callback(err, '127.0.0.1', 4);
  });
}

function collectErrorMessages(error: unknown): string[] {
  const messages: string[] = [];
  let current: unknown = error;
  while (current instanceof Error) {
    messages.push(current.message);
    current = (current as { cause?: unknown }).cause;
  }
  return messages;
}

async function expectRebindSSRFRejection(promise: Promise<unknown>): Promise<void> {
  let caught: unknown;
  let didReject = false;
  try {
    await promise;
  } catch (error) {
    didReject = true;
    caught = error;
  }
  if (!didReject) {
    throw new Error('Expected promise to reject with SSRF error, but it resolved');
  }
  expect(
    collectErrorMessages(caught).some((message) => /SSRF protection: rebind\.test/.test(message)),
  ).toBe(true);
}

async function safeDisconnect(conn: MCPConnection | null): Promise<void> {
  if (!conn) {
    return;
  }
  (conn as unknown as { shouldStopReconnecting: boolean }).shouldStopReconnecting = true;
  conn.removeAllListeners();
  await conn.disconnect();
}

interface TestServer {
  url: string;
  redirectHit: boolean;
  close: () => Promise<void>;
}

function getFreePort(): Promise<number> {
  return new Promise((resolve, reject) => {
    const srv = net.createServer();
    srv.listen(0, '127.0.0.1', () => {
      const addr = srv.address() as net.AddressInfo;
      srv.close((err) => (err ? reject(err) : resolve(addr.port)));
    });
  });
}

function trackSockets(httpServer: http.Server): () => Promise<void> {
  const sockets = new Set<Socket>();
  httpServer.on('connection', (socket: Socket) => {
    sockets.add(socket);
    socket.once('close', () => sockets.delete(socket));
  });
  return () =>
    new Promise<void>((resolve) => {
      for (const socket of sockets) {
        socket.destroy();
      }
      sockets.clear();
      httpServer.close(() => resolve());
    });
}

/**
 * Creates an HTTP server that responds with a 301 redirect to a target URL.
 * A second server is spun up at the redirect target to detect whether the
 * redirect was actually followed.
 */
async function createRedirectingServer(redirectTarget: string): Promise<TestServer> {
  const state = { redirectHit: false };

  const targetPort = new URL(redirectTarget).port || '80';
  const targetServer = http.createServer((_req, res) => {
    state.redirectHit = true;
    res.writeHead(200, { 'Content-Type': 'text/plain' });
    res.end('You should not be here');
  });
  const destroyTargetSockets = trackSockets(targetServer);
  await new Promise<void>((resolve) =>
    targetServer.listen(parseInt(targetPort), '127.0.0.1', resolve),
  );

  const httpServer = http.createServer((_req, res) => {
    res.writeHead(301, { Location: redirectTarget });
    res.end();
  });

  const destroySockets = trackSockets(httpServer);
  const port = await getFreePort();
  await new Promise<void>((resolve) => httpServer.listen(port, '127.0.0.1', resolve));

  return {
    url: `http://127.0.0.1:${port}/`,
    get redirectHit() {
      return state.redirectHit;
    },
    close: async () => {
      await destroySockets();
      await destroyTargetSockets();
    },
  };
}

/**
 * Builds an HTTP request handler that routes incoming requests to (per-session)
 * `StreamableHTTPServerTransport` instances backed by an `McpServer`. Sessions
 * are stored in the caller-provided `sessions` Map so the caller can drain them
 * during teardown.
 */
function createMCPRequestHandler(
  sessions: Map<string, StreamableHTTPServerTransport>,
  serverName: string,
): http.RequestListener {
  return async (req, res) => {
    const sid = req.headers['mcp-session-id'] as string | undefined;
    let transport = sid ? sessions.get(sid) : undefined;

    if (!transport) {
      transport = new StreamableHTTPServerTransport({ sessionIdGenerator: () => randomUUID() });
      const mcp = new McpServer({ name: serverName, version: '0.0.1' });
      await mcp.connect(transport);
    }

    await transport.handleRequest(req, res);

    if (transport.sessionId && !sessions.has(transport.sessionId)) {
      sessions.set(transport.sessionId, transport);
      transport.onclose = () => sessions.delete(transport!.sessionId!);
    }
  };
}

async function closeMCPSessions(
  sessions: Map<string, StreamableHTTPServerTransport>,
): Promise<void> {
  const closing = [...sessions.values()].map((t) => t.close().catch(() => undefined));
  sessions.clear();
  await Promise.all(closing);
}

/**
 * Creates a real StreamableHTTP MCP server for baseline connectivity tests.
 */
async function createStreamableServer(): Promise<Omit<TestServer, 'redirectHit'>> {
  const sessions = new Map<string, StreamableHTTPServerTransport>();
  const httpServer = http.createServer(createMCPRequestHandler(sessions, 'test-ssrf'));

  const destroySockets = trackSockets(httpServer);
  const port = await getFreePort();
  await new Promise<void>((resolve) => httpServer.listen(port, '127.0.0.1', resolve));

  return {
    url: `http://127.0.0.1:${port}/`,
    close: async () => {
      await closeMCPSessions(sessions);
      await destroySockets();
    },
  };
}

async function createOversizedToolResultStreamableServer(
  payloadSize: number,
): Promise<Omit<TestServer, 'redirectHit'>> {
  const sessions = new Map<string, StreamableHTTPServerTransport>();

  const httpServer = http.createServer(async (req, res) => {
    const sid = req.headers['mcp-session-id'] as string | undefined;
    let transport = sid ? sessions.get(sid) : undefined;

    if (!transport) {
      transport = new StreamableHTTPServerTransport({ sessionIdGenerator: () => randomUUID() });
      const mcp = new McpServer({ name: 'oversized-tool-result', version: '0.0.1' });
      mcp.tool('oversized', 'Returns an oversized text payload', {}, async () => ({
        content: [{ type: 'text', text: 'x'.repeat(payloadSize) }],
      }));
      await mcp.connect(transport);
    }

    await transport.handleRequest(req, res);

    if (transport.sessionId && !sessions.has(transport.sessionId)) {
      sessions.set(transport.sessionId, transport);
      transport.onclose = () => sessions.delete(transport!.sessionId!);
    }
  });

  const destroySockets = trackSockets(httpServer);
  const port = await getFreePort();
  await new Promise<void>((resolve) => httpServer.listen(port, '127.0.0.1', resolve));

  return {
    url: `http://127.0.0.1:${port}/`,
    close: async () => {
      await closeMCPSessions(sessions);
      await destroySockets();
    },
  };
}

describe('direct bearer HTTP rejection', () => {
  it.each([
    ['sse', 401],
    ['sse', 403],
    ['streamable-http', 401],
    ['streamable-http', 403],
  ] as const)('preserves a structured %s POST status %s', async (type, status) => {
    const server = http.createServer((_req, res) => {
      res.writeHead(status);
      res.end('credential rejected');
    });
    const close = trackSockets(server);
    await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
    const url = `http://127.0.0.1:${(server.address() as net.AddressInfo).port}/mcp`;
    const connection = new MCPConnection({
      serverName: 'direct-bearer',
      serverConfig: { type, url },
      useSSRFProtection: false,
      directBearerRecoveryEnabled: true,
    });
    const createFetch = Reflect.get(connection, 'createFetchFunction') as (
      getHeaders: () => Record<string, string>,
    ) => CustomFetch;
    try {
      await expect(
        createFetch.call(connection, () => ({ Authorization: 'Bearer token' }))(url, {
          method: 'POST',
          body: '{}',
        }),
      ).rejects.toMatchObject({ name: 'MCPTransportAuthenticationError', status });
    } finally {
      await connection.dispose();
      await close();
    }
  });
});

describe('MCP SSRF protection – redirect blocking', () => {
  let redirectServer: TestServer;
  let conn: MCPConnection | null;

  afterEach(async () => {
    await safeDisconnect(conn);
    conn = null;
    if (redirectServer) {
      await redirectServer.close();
    }
    jest.restoreAllMocks();
  });

  it('should not follow redirects from streamable-http to a private IP', async () => {
    const targetPort = await getFreePort();
    redirectServer = await createRedirectingServer(
      `http://127.0.0.1:${targetPort}/latest/meta-data/`,
    );

    conn = new MCPConnection({
      serverName: 'redirect-test',
      serverConfig: { type: 'streamable-http', url: redirectServer.url },
      useSSRFProtection: false,
    });

    await expect(conn.connect()).rejects.toThrow();
    expect(redirectServer.redirectHit).toBe(false);
  });

  it('should not follow redirects even with SSRF protection off (allowlist scenario)', async () => {
    const targetPort = await getFreePort();
    redirectServer = await createRedirectingServer(`http://127.0.0.1:${targetPort}/admin`);

    conn = new MCPConnection({
      serverName: 'redirect-test-2',
      serverConfig: { type: 'streamable-http', url: redirectServer.url },
      useSSRFProtection: false,
    });

    await expect(conn.connect()).rejects.toThrow();
    expect(redirectServer.redirectHit).toBe(false);
  });

  it('should connect normally to a non-redirecting streamable-http server', async () => {
    const realServer = await createStreamableServer();
    try {
      conn = new MCPConnection({
        serverName: 'legit-server',
        serverConfig: { type: 'streamable-http', url: realServer.url },
        useSSRFProtection: false,
      });

      await conn.connect();
      const tools = await conn.fetchTools();
      expect(tools).toBeDefined();
    } finally {
      await safeDisconnect(conn);
      conn = null;
      await realServer.close();
    }
  });
});

/**
 * Creates a single HTTP server that 307/308-redirects from the root path to
 * `/mcp`, where a real MCP server is mounted. The redirect stays on the same
 * origin (Coda-style doc-scoped routing), so credential-bearing headers like
 * `mcp-session-id` survive the cross-path hop and the MCP session keeps state.
 */
async function createRedirectingMCPServer(
  statusCode: 307 | 308,
): Promise<TestServer & { close: () => Promise<void> }> {
  const sessions = new Map<string, StreamableHTTPServerTransport>();
  const state = { redirectHit: false };
  const mcpPath = '/mcp';
  const port = await getFreePort();
  const mcpHandler = createMCPRequestHandler(sessions, 'redirect-target');

  const server = http.createServer(async (req, res) => {
    if ((req.url ?? '').startsWith(mcpPath)) {
      state.redirectHit = true;
      await mcpHandler(req, res);
      return;
    }

    res.writeHead(statusCode, { Location: `http://127.0.0.1:${port}${mcpPath}` });
    res.end();
  });

  const destroySockets = trackSockets(server);
  await new Promise<void>((resolve) => server.listen(port, '127.0.0.1', resolve));

  return {
    url: `http://127.0.0.1:${port}/`,
    get redirectHit() {
      return state.redirectHit;
    },
    close: async () => {
      await closeMCPSessions(sessions);
      await destroySockets();
    },
  };
}

/**
 * Creates a single HTTP server with `depth` chained 307/308 redirects on
 * `/hop/N → /hop/N-1 → … → /hop/0`, where `/hop/0` returns a plain 200.
 * Same-origin throughout, so the chain exercises only redirect-depth limits
 * (not cross-origin header behavior).
 */
async function createRedirectChain(depth: number, statusCode: 307 | 308): Promise<TestServer> {
  const state = { redirectHit: false };
  const port = await getFreePort();

  const server = http.createServer((req, res) => {
    const match = (req.url ?? '/').match(/^\/hop\/(\d+)/);
    const n = match ? parseInt(match[1], 10) : -1;
    if (n > 0) {
      res.writeHead(statusCode, {
        Location: `http://127.0.0.1:${port}/hop/${n - 1}`,
      });
      res.end();
      return;
    }
    state.redirectHit = true;
    res.writeHead(200, { 'Content-Type': 'text/plain' });
    res.end('final');
  });

  const destroySockets = trackSockets(server);
  await new Promise<void>((resolve) => server.listen(port, '127.0.0.1', resolve));

  return {
    url: `http://127.0.0.1:${port}/hop/${depth}`,
    get redirectHit() {
      return state.redirectHit;
    },
    close: destroySockets,
  };
}

/**
 * Same-origin redirect chain ending at a real MCP server at `/mcp`. URL
 * `/hop/N-1` redirects through N hops total, with the final hop landing on
 * `/mcp`. Used to verify MCP traffic survives the maximum allowed redirect
 * depth.
 */
async function createRedirectChainToMCP(depth: number, statusCode: 307 | 308): Promise<TestServer> {
  const sessions = new Map<string, StreamableHTTPServerTransport>();
  const state = { redirectHit: false };
  const mcpPath = '/mcp';
  const port = await getFreePort();
  const mcpHandler = createMCPRequestHandler(sessions, 'mcp-via-chain');

  const server = http.createServer(async (req, res) => {
    const url = req.url ?? '/';

    if (url.startsWith(mcpPath)) {
      state.redirectHit = true;
      await mcpHandler(req, res);
      return;
    }

    const match = url.match(/^\/hop\/(\d+)/);
    const n = match ? parseInt(match[1], 10) : 0;
    const nextLocation =
      n > 0 ? `http://127.0.0.1:${port}/hop/${n - 1}` : `http://127.0.0.1:${port}${mcpPath}`;
    res.writeHead(statusCode, { Location: nextLocation });
    res.end();
  });

  const destroySockets = trackSockets(server);
  await new Promise<void>((resolve) => server.listen(port, '127.0.0.1', resolve));

  return {
    url: `http://127.0.0.1:${port}/hop/${depth - 1}`,
    get redirectHit() {
      return state.redirectHit;
    },
    close: async () => {
      await closeMCPSessions(sessions);
      await destroySockets();
    },
  };
}

interface CapturedRequest {
  method: string;
  headers: http.IncomingHttpHeaders;
  body: string;
}

interface HeaderCaptureServer {
  url: string;
  receivedHeaders: http.IncomingHttpHeaders[];
  receivedRequests: CapturedRequest[];
  close: () => Promise<void>;
}

interface RawResponseServer {
  url: string;
  close: () => Promise<void>;
}

/**
 * Captures every incoming request's headers, method, and body, then replies
 * with a benign 200 so tests can assert what actually crossed a redirect
 * boundary (header stripping, 307/308 method preservation, payload survival).
 */
async function createHeaderCaptureServer(): Promise<HeaderCaptureServer> {
  const headers: http.IncomingHttpHeaders[] = [];
  const requests: CapturedRequest[] = [];
  const server = http.createServer((req, res) => {
    headers.push({ ...req.headers });
    const chunks: Buffer[] = [];
    req.on('data', (chunk: Buffer) => chunks.push(chunk));
    req.on('end', () => {
      requests.push({
        method: req.method ?? '',
        headers: { ...req.headers },
        body: Buffer.concat(chunks).toString('utf8'),
      });
      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.end('{}');
    });
  });
  const destroySockets = trackSockets(server);
  const port = await getFreePort();
  await new Promise<void>((resolve) => server.listen(port, '127.0.0.1', resolve));
  return {
    url: `http://127.0.0.1:${port}/`,
    receivedHeaders: headers,
    receivedRequests: requests,
    close: destroySockets,
  };
}

async function createTunnelProxyCaptureServer(): Promise<HeaderCaptureServer> {
  const headers: http.IncomingHttpHeaders[] = [];
  const requests: CapturedRequest[] = [];
  const server = http.createServer((_req, res) => {
    res.writeHead(502);
    res.end();
  });
  server.on('connect', (req, clientSocket, head) => {
    headers.push({ ...req.headers });
    requests.push({
      method: 'CONNECT',
      headers: { ...req.headers },
      body: req.url ?? '',
    });

    let buffer = Buffer.from(head);
    let responded = false;
    const respondIfRequestComplete = () => {
      if (responded || !buffer.includes('\r\n\r\n')) {
        return;
      }
      responded = true;
      const requestLine = buffer.toString('utf8').split('\r\n')[0] ?? '';
      requests.push({
        method: requestLine.split(' ')[0] ?? '',
        headers: {},
        body: requestLine,
      });
      clientSocket.write(
        'HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: 2\r\nConnection: close\r\n\r\n{}',
      );
      clientSocket.end();
    };

    clientSocket.on('error', () => undefined);
    clientSocket.write('HTTP/1.1 200 Connection Established\r\n\r\n');
    clientSocket.on('data', (chunk: Buffer) => {
      buffer = Buffer.concat([buffer, chunk]);
      respondIfRequestComplete();
    });
    respondIfRequestComplete();
  });

  const destroySockets = trackSockets(server);
  const port = await getFreePort();
  await new Promise<void>((resolve) => server.listen(port, '127.0.0.1', resolve));
  return {
    url: `http://127.0.0.1:${port}/`,
    receivedHeaders: headers,
    receivedRequests: requests,
    close: destroySockets,
  };
}

async function createRawResponseServer(handler: http.RequestListener): Promise<RawResponseServer> {
  const server = http.createServer(handler);
  const destroySockets = trackSockets(server);
  const port = await getFreePort();
  await new Promise<void>((resolve) => server.listen(port, '127.0.0.1', resolve));
  return {
    url: `http://127.0.0.1:${port}/`,
    close: destroySockets,
  };
}

/**
 * Issues a single 307/308 redirect to `redirectTarget` (which lives on a
 * different port and is therefore a different origin). Used to verify
 * cross-origin credential-stripping behavior.
 */
async function createCrossOriginRedirectingServer(
  redirectTarget: string,
  statusCode: 307 | 308,
): Promise<TestServer> {
  const state = { redirectHit: false };
  const server = http.createServer((_req, res) => {
    state.redirectHit = true;
    res.writeHead(statusCode, { Location: redirectTarget });
    res.end();
  });
  const destroySockets = trackSockets(server);
  const port = await getFreePort();
  await new Promise<void>((resolve) => server.listen(port, '127.0.0.1', resolve));
  return {
    url: `http://127.0.0.1:${port}/`,
    get redirectHit() {
      return state.redirectHit;
    },
    close: destroySockets,
  };
}

describe('scheduled dispatch authority across redirect hops', () => {
  it('refreshes only live credentials on a healthy redirected catalog without changing routing', async () => {
    const seen: Array<{ authorization?: string; route?: string }> = [];
    let resolutions = 0;
    const authorize = jest.fn(async () => ({
      authorization: `Bearer occurrence-${++resolutions}`,
    }));
    const server = await createRawResponseServer((req, res) => {
      seen.push({
        authorization: req.headers.authorization,
        route: req.headers['x-route'] as string,
      });
      res.writeHead(req.url === '/start' ? 307 : 200, { Location: '/target' });
      res.end('{}');
    });
    const connection = new MCPConnection({
      serverName: 'healthy-redirect',
      serverConfig: { type: 'streamable-http', url: server.url },
      resolveRequestHeaders: authorize,
    });
    try {
      const fetch = connection['createFetchFunction'](
        () => ({ 'X-Route': 'unchanged' }),
        5000,
        undefined,
        undefined,
        server.url,
      );
      const response = await fetch(new URL('start', server.url).href, {
        method: 'POST',
        body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'tools/list' }),
      });
      await response.body?.cancel();
      expect(response.status).toBe(200);
      expect(seen).toEqual([
        { authorization: 'Bearer occurrence-1', route: 'unchanged' },
        { authorization: 'Bearer occurrence-2', route: 'unchanged' },
      ]);
      expect(authorize).toHaveBeenCalledTimes(2);
    } finally {
      await connection.dispose();
      await server.close();
    }
  });

  it.each([307, 308] as const)(
    'reauthorizes before a same-origin %s catalog dispatch',
    async (status) => {
      let allowed = true;
      const paths: string[] = [];
      const denial = new ScheduledMCPBearerError('consent_revoked', 'Files');
      const authorize = jest.fn(async () => {
        if (!allowed) throw denial;
        return { authorization: 'Bearer occurrence' };
      });
      const server = await createRawResponseServer((req, res) => {
        paths.push(req.url!);
        if (req.url === '/start') {
          allowed = false;
          res.writeHead(status, { Location: '/target' });
        } else res.writeHead(200);
        res.end('{}');
      });
      const connection = new MCPConnection({
        serverName: 'redirect-authority',
        serverConfig: { type: 'streamable-http', url: server.url },
        resolveRequestHeaders: authorize,
      });
      try {
        const fetch = connection['createFetchFunction'](
          () => ({ 'X-Route': 'unchanged' }),
          5000,
          undefined,
          undefined,
          server.url,
        );
        const attempt = fetch(new URL('start', server.url).href, {
          method: 'POST',
          body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'tools/list' }),
        });
        await expect(attempt).rejects.toBe(denial);
        expect(paths).toEqual(['/start']);
        expect(authorize).toHaveBeenCalledTimes(2);
      } finally {
        await connection.dispose();
        await server.close();
      }
    },
  );

  it.each([307, 308] as const)(
    'never automatically repeats tools/call through a %s redirect',
    async (status) => {
      const paths: string[] = [];
      const authorize = jest.fn(async () => ({ authorization: 'Bearer occurrence' }));
      const server = await createRawResponseServer((req, res) => {
        paths.push(req.url!);
        res.writeHead(req.url === '/start' ? status : 200, { Location: '/target' });
        res.end('{}');
      });
      const connection = new MCPConnection({
        serverName: 'redirect-no-replay',
        serverConfig: { type: 'streamable-http', url: server.url },
        resolveRequestHeaders: authorize,
      });
      try {
        const fetch = connection['createFetchFunction'](
          () => undefined,
          5000,
          undefined,
          undefined,
          server.url,
        );
        const response = await fetch(new URL('start', server.url).href, {
          method: 'POST',
          body: JSON.stringify({
            jsonrpc: '2.0',
            id: 1,
            method: 'tools/call',
            params: { name: 'read' },
          }),
        });
        await response.body?.cancel();
        expect(response.status).toBe(status);
        expect(paths).toEqual(['/start']);
      } finally {
        await connection.dispose();
        await server.close();
      }
    },
  );
});

/**
 * The SDK transports follow same-origin redirects themselves unless `redirectPolicy` leaves them
 * to the fetch. These run the real transports so a redirect `createFetchFunction` declined can
 * never be re-issued by the SDK.
 */
describe('SDK transports defer redirects to the connection fetch', () => {
  let conn: MCPConnection | null = null;
  let server: RawResponseServer | undefined;

  afterEach(async () => {
    await safeDisconnect(conn);
    conn = null;
    await server?.close();
    server = undefined;
  });

  it.each([307, 308] as const)(
    'does not let the streamable-http transport repeat a tools/call answered with %s',
    async (status) => {
      const sessions = new Map<string, StreamableHTTPServerTransport>();
      const toolCallPaths: string[] = [];
      server = await createRawResponseServer(async (req, res) => {
        const chunks: Buffer[] = [];
        for await (const chunk of req) chunks.push(chunk as Buffer);
        const body: { method?: string } | undefined = chunks.length
          ? JSON.parse(Buffer.concat(chunks).toString())
          : undefined;
        if (body?.method === 'tools/call') {
          toolCallPaths.push(req.url!);
          res.writeHead(status, { Location: '/replayed' });
          res.end();
          return;
        }
        const sid = req.headers['mcp-session-id'] as string | undefined;
        let transport = sid ? sessions.get(sid) : undefined;
        if (!transport) {
          transport = new StreamableHTTPServerTransport({ sessionIdGenerator: () => randomUUID() });
          const mcp = new McpServer({ name: 'no-replay', version: '0.0.1' });
          mcp.tool('read', 'Reads once', {}, async () => ({
            content: [{ type: 'text', text: 'read' }],
          }));
          await mcp.connect(transport);
        }
        await transport.handleRequest(req, res, body);
        if (transport.sessionId && !sessions.has(transport.sessionId)) {
          sessions.set(transport.sessionId, transport);
        }
      });
      conn = new MCPConnection({
        serverName: 'sdk-no-replay',
        serverConfig: { type: 'streamable-http', url: new URL('mcp', server.url).href },
        resolveRequestHeaders: jest.fn(async () => ({ authorization: 'Bearer occurrence' })),
        useSSRFProtection: false,
      });

      try {
        await conn.connect();
        await expect(
          conn.client.callTool({ name: 'read', arguments: {} }, undefined, { timeout: 3000 }),
        ).rejects.toThrow();
        expect(toolCallPaths).toEqual(['/mcp']);
      } finally {
        await closeMCPSessions(sessions);
      }
    },
  );

  it('does not let the SSE transport follow a same-origin redirect of its stream', async () => {
    const paths: string[] = [];
    server = await createRawResponseServer((req, res) => {
      paths.push(req.url!);
      if (req.url === '/sse') {
        res.writeHead(302, { Location: '/moved' });
        res.end();
        return;
      }
      res.writeHead(200, { 'Content-Type': 'text/event-stream' });
      res.end();
    });
    conn = new MCPConnection({
      serverName: 'sse-no-follow',
      serverConfig: { type: 'sse', url: new URL('sse', server.url).href },
      useSSRFProtection: false,
    });

    await expect(conn.connect()).rejects.toThrow();
    expect(paths.length).toBeGreaterThan(0);
    expect(paths.every((path) => path === '/sse')).toBe(true);
  });
});

describe('MCP SSRF protection – 307/308 redirect following', () => {
  let server: TestServer | undefined;
  let conn: MCPConnection | null;

  afterEach(async () => {
    await safeDisconnect(conn);
    conn = null;
    if (server) {
      await server.close();
      server = undefined;
    }
    jest.restoreAllMocks();
  });

  it('should follow a 308 redirect and connect to the target MCP server', async () => {
    server = await createRedirectingMCPServer(308);

    conn = new MCPConnection({
      serverName: 'redirect-308',
      serverConfig: { type: 'streamable-http', url: server.url },
      useSSRFProtection: false,
    });

    await conn.connect();
    const tools = await conn.fetchTools();
    expect(tools).toBeDefined();
    expect(server.redirectHit).toBe(true);
  });

  it('should follow a 307 redirect and connect to the target MCP server', async () => {
    server = await createRedirectingMCPServer(307);

    conn = new MCPConnection({
      serverName: 'redirect-307',
      serverConfig: { type: 'streamable-http', url: server.url },
      useSSRFProtection: false,
    });

    await conn.connect();
    const tools = await conn.fetchTools();
    expect(tools).toBeDefined();
    expect(server.redirectHit).toBe(true);
  });

  it('should stop following redirects after 5 hops', async () => {
    server = await createRedirectChain(6, 308);

    conn = new MCPConnection({
      serverName: 'redirect-too-deep',
      serverConfig: { type: 'streamable-http', url: server.url },
      useSSRFProtection: false,
    });

    await expect(conn.connect()).rejects.toThrow();
    expect(server.redirectHit).toBe(false);
  });

  it('should reach the target after exactly 5 redirect hops (at the limit)', async () => {
    server = await createRedirectChain(5, 308);

    conn = new MCPConnection({
      serverName: 'redirect-at-limit',
      serverConfig: { type: 'streamable-http', url: server.url },
      useSSRFProtection: false,
    });

    await expect(conn.connect()).rejects.toThrow();
    expect(server.redirectHit).toBe(true);
  });

  it('should complete an MCP request through 5 same-origin redirect hops', async () => {
    server = await createRedirectChainToMCP(5, 308);

    conn = new MCPConnection({
      serverName: 'redirect-chain-mcp',
      serverConfig: { type: 'streamable-http', url: server.url },
      useSSRFProtection: false,
    });

    await conn.connect();
    const tools = await conn.fetchTools();
    expect(tools).toBeDefined();
    expect(server.redirectHit).toBe(true);
  });
});

describe('MCP SSRF protection – 307/308 redirect to private IP', () => {
  let server: TestServer | undefined;
  let conn: MCPConnection | null;

  afterEach(async () => {
    await safeDisconnect(conn);
    conn = null;
    if (server) {
      await server.close();
      server = undefined;
    }
    jest.restoreAllMocks();
  });

  it('should block a 308 redirect whose target resolves to a private IP (allowlist scenario)', async () => {
    const capture = await createHeaderCaptureServer();
    try {
      server = await createCrossOriginRedirectingServer(capture.url, 308);
      mockedResolveHostnameSSRF.mockResolvedValueOnce(true);

      conn = new MCPConnection({
        serverName: 'redirect-ssrf-block',
        serverConfig: { type: 'streamable-http', url: server.url },
        useSSRFProtection: false,
      });

      await expect(conn.connect()).rejects.toThrow();
      expect(server.redirectHit).toBe(true);
      expect(capture.receivedHeaders).toHaveLength(0);
    } finally {
      await capture.close();
    }
  });

  it('should block a 307 redirect whose target resolves to a private IP (SSRF protection on)', async () => {
    const capture = await createHeaderCaptureServer();
    try {
      server = await createCrossOriginRedirectingServer(capture.url, 307);
      mockedResolveHostnameSSRF.mockResolvedValueOnce(true);

      conn = new MCPConnection({
        serverName: 'redirect-ssrf-block-on',
        serverConfig: { type: 'streamable-http', url: server.url },
        useSSRFProtection: true,
      });

      await expect(conn.connect()).rejects.toThrow();
      expect(server.redirectHit).toBe(true);
      expect(capture.receivedHeaders).toHaveLength(0);
    } finally {
      await capture.close();
    }
  });

  it('should block DNS rebinding between redirect pre-check and connect-time lookup', async () => {
    const capture = await createHeaderCaptureServer();
    try {
      const rebindUrl = new URL(capture.url);
      rebindUrl.hostname = 'rebind.test';
      server = await createCrossOriginRedirectingServer(rebindUrl.href, 308);
      mockedResolveHostnameSSRF.mockResolvedValueOnce(false);
      mockedCreateSSRFSafeUndiciConnect.mockClear();
      const lookup = createRebindBlockingLookup();
      mockedCreateSSRFSafeUndiciConnect.mockReturnValueOnce({
        lookup,
      } as ReturnType<typeof createSSRFSafeUndiciConnect>);

      conn = new MCPConnection({
        serverName: 'redirect-rebinding-block',
        serverConfig: { type: 'streamable-http', url: server.url },
        useSSRFProtection: false,
      });

      await expectRebindSSRFRejection(conn.connect());
      expect(server.redirectHit).toBe(true);
      expect(mockedCreateSSRFSafeUndiciConnect).toHaveBeenCalledTimes(1);
      expect(lookup).toHaveBeenCalled();
      expect(lookup.mock.calls[0]?.[0]).toBe('rebind.test');
      expect(capture.receivedHeaders).toHaveLength(0);
    } finally {
      await capture.close();
    }
  });

  it('should switch to a no-exemption SSRF-safe dispatcher when protection is already on', async () => {
    const capture = await createHeaderCaptureServer();
    try {
      const rebindUrl = new URL(capture.url);
      rebindUrl.hostname = 'rebind.test';
      server = await createCrossOriginRedirectingServer(rebindUrl.href, 308);
      mockedResolveHostnameSSRF.mockResolvedValueOnce(false);
      mockedCreateSSRFSafeUndiciConnect.mockClear();
      const lookup = createRebindBlockingLookup();
      mockedCreateSSRFSafeUndiciConnect
        .mockReturnValueOnce({
          lookup,
        } as ReturnType<typeof createSSRFSafeUndiciConnect>)
        .mockReturnValueOnce({
          lookup,
        } as ReturnType<typeof createSSRFSafeUndiciConnect>);

      conn = new MCPConnection({
        serverName: 'redirect-rebinding-block-protection-on',
        serverConfig: { type: 'streamable-http', url: server.url },
        useSSRFProtection: true,
      });

      await expectRebindSSRFRejection(conn.connect());
      expect(server.redirectHit).toBe(true);
      expect(mockedCreateSSRFSafeUndiciConnect).toHaveBeenCalledTimes(2);
      expect(mockedCreateSSRFSafeUndiciConnect.mock.calls[1]).toEqual([]);
      expect(lookup).toHaveBeenCalled();
      expect(lookup.mock.calls.some(([hostname]) => hostname === 'rebind.test')).toBe(true);
      expect(capture.receivedHeaders).toHaveLength(0);
    } finally {
      await capture.close();
    }
  });
});

describe('MCP SSRF protection – cross-origin credential stripping on redirect', () => {
  let server: TestServer | undefined;
  let conn: MCPConnection | null;

  afterEach(async () => {
    await safeDisconnect(conn);
    conn = null;
    if (server) {
      await server.close();
      server = undefined;
    }
    jest.restoreAllMocks();
  });

  it('should strip Authorization, runtime headers, and config headers when 308-redirecting cross-origin', async () => {
    const capture = await createHeaderCaptureServer();
    try {
      server = await createCrossOriginRedirectingServer(capture.url, 308);

      conn = new MCPConnection({
        serverName: 'cross-origin-strip',
        serverConfig: {
          type: 'streamable-http',
          url: server.url,
          headers: {
            'X-Config-Api-Key': 'config-level-secret',
            'X-Internal-Token': 'config-internal-token',
          },
        },
        oauthTokens: {
          access_token: 'super-secret-bearer-token',
          token_type: 'Bearer',
          obtained_at: Date.now(),
        },
        useSSRFProtection: false,
      });
      conn.setRequestHeaders({ 'X-Runtime-Api-Key': 'runtime-private-api-key' });

      await expect(conn.connect()).rejects.toThrow();
      expect(server.redirectHit).toBe(true);
      expect(capture.receivedHeaders.length).toBeGreaterThan(0);

      for (const headers of capture.receivedHeaders) {
        expect(headers['authorization']).toBeUndefined();
        expect(headers['x-runtime-api-key']).toBeUndefined();
        expect(headers['x-config-api-key']).toBeUndefined();
        expect(headers['x-internal-token']).toBeUndefined();
        expect(headers['mcp-session-id']).toBeUndefined();
        expect(headers['cookie']).toBeUndefined();
        /** Non-credential protocol headers must survive — guards against a
         * regression that strips everything indiscriminately. */
        expect(headers['accept']).toBeDefined();
        expect(headers['content-type']).toBeDefined();
      }
    } finally {
      await capture.close();
    }
  });

  it('should preserve credential headers on same-origin 308 redirects (Coda-style flow)', async () => {
    server = await createRedirectingMCPServer(308);

    conn = new MCPConnection({
      serverName: 'same-origin-preserve',
      serverConfig: { type: 'streamable-http', url: server.url },
      oauthTokens: {
        access_token: 'preserved-bearer',
        token_type: 'Bearer',
        obtained_at: Date.now(),
      },
      useSSRFProtection: false,
    });

    /** Same-origin redirect → MCP session continuity must hold across hops. */
    await conn.connect();
    const tools = await conn.fetchTools();
    expect(tools).toBeDefined();
  });

  it('treats a protocol downgrade as cross-origin (URL.origin contract)', () => {
    /**
     * The cross-origin strip path keys off `targetUrl.origin !== originalOrigin`.
     * `URL.origin` is defined as `scheme + "://" + host + ":" + port`, so a
     * same-host `https → http` redirect produces a different origin and trips
     * the strip path through the existing logic — no separate code path is
     * needed for protocol downgrade. Pin the URL contract here instead of
     * standing up a TLS fixture just to re-prove the spec.
     */
    expect(new URL('https://example.com/a').origin).not.toBe(
      new URL('http://example.com/a').origin,
    );
    expect(new URL('https://example.com:443/a').origin).not.toBe(
      new URL('http://example.com:80/a').origin,
    );
  });
});

describe('MCP SSRF protection – customFetch input shapes', () => {
  let target: Omit<TestServer, 'redirectHit'> | undefined;
  let conn: MCPConnection | null;
  const originalMaxResponseBytes = process.env.MCP_STREAMABLE_HTTP_MAX_RESPONSE_BYTES;
  const originalMaxLineBytes = process.env.MCP_STREAMABLE_HTTP_MAX_LINE_BYTES;

  it.each([true, false])(
    'uses the live bearer on SSE stream reconnect only in direct mode: %s',
    async (directBearerRecoveryEnabled) => {
      const requests: http.IncomingHttpHeaders[] = [];
      let stream: http.ServerResponse | undefined;
      let reconnected!: () => void;
      const reconnect = new Promise<void>((resolve) => {
        reconnected = resolve;
      });
      const server = http.createServer((req, res) => {
        requests.push(req.headers);
        stream = res;
        res.writeHead(200, { 'Content-Type': 'text/event-stream' });
        res.write('retry: 10\nevent: endpoint\ndata: /messages\n\n');
        if (requests.length === 2) {
          reconnected();
        }
      });
      const close = trackSockets(server);
      const port = await getFreePort();
      await new Promise<void>((resolve) => server.listen(port, '127.0.0.1', resolve));
      const config = {
        type: 'sse' as const,
        url: `http://127.0.0.1:${port}/sse`,
        headers: {
          Authorization: 'Bearer old-token',
          'X-Access-Token': 'old-token',
          'X-Operator': 'configured',
        },
      };
      conn = new MCPConnection({
        serverName: 'sse-live-bearer',
        serverConfig: config,
        useSSRFProtection: false,
        directBearerRecoveryEnabled,
      });
      const transport = await conn['constructTransport'](config);
      try {
        await transport.start();
        conn.setRequestHeaders({
          AUTHORIZATION: 'Bearer fresh-token',
          'X-Access-Token': 'fresh-token',
          'X-Request': 'private',
        });
        stream?.end();
        await reconnect;
        expect(requests[0].authorization).toBe('Bearer old-token');
        expect(requests[1].authorization).toBe(
          directBearerRecoveryEnabled ? 'Bearer fresh-token' : 'Bearer old-token',
        );
        expect(requests[1]['x-operator']).toBe('configured');
        expect(requests[1]['x-access-token']).toBe(
          directBearerRecoveryEnabled ? 'fresh-token' : 'old-token',
        );
        expect(requests[1]['x-request']).toBeUndefined();
      } finally {
        await transport.close();
        await close();
      }
    },
  );

  afterEach(async () => {
    if (originalMaxResponseBytes == null) {
      delete process.env.MCP_STREAMABLE_HTTP_MAX_RESPONSE_BYTES;
    } else {
      process.env.MCP_STREAMABLE_HTTP_MAX_RESPONSE_BYTES = originalMaxResponseBytes;
    }
    if (originalMaxLineBytes == null) {
      delete process.env.MCP_STREAMABLE_HTTP_MAX_LINE_BYTES;
    } else {
      process.env.MCP_STREAMABLE_HTTP_MAX_LINE_BYTES = originalMaxLineBytes;
    }
    await safeDisconnect(conn);
    conn = null;
    if (target) {
      await target.close();
      target = undefined;
    }
    jest.restoreAllMocks();
  });

  /**
   * Reach into the private fetch factory to exercise it with each
   * `RequestInfo` shape undici accepts. `Request.toString()` returns
   * `"[object Request]"`, so a naive `new URL(input.toString())` for origin
   * derivation would throw before any network call — this test pins that
   * regression.
   */
  function getCustomFetch(connection: MCPConnection): CustomFetch {
    const factory = (
      connection as unknown as {
        createFetchFunction: (
          getHeaders: () => Record<string, string> | null | undefined,
          timeout?: number,
          sseBodyTimeout?: number,
          configuredSecretHeaderKeys?: ReadonlySet<string>,
          baseUrl?: string,
          guardStreamableHTTPResponses?: boolean,
        ) => CustomFetch;
      }
    ).createFetchFunction;
    return factory.call(connection, () => null);
  }

  function getGuardedStreamableHTTPCustomFetch(connection: MCPConnection): CustomFetch {
    const factory = (
      connection as unknown as {
        createFetchFunction: (
          getHeaders: () => Record<string, string> | null | undefined,
          timeout?: number,
          sseBodyTimeout?: number,
          configuredSecretHeaderKeys?: ReadonlySet<string>,
          baseUrl?: string,
          guardStreamableHTTPResponses?: boolean,
        ) => CustomFetch;
      }
    ).createFetchFunction;
    return factory.call(connection, () => null, undefined, undefined, undefined, undefined, true);
  }

  function createBaseUrlFetch(connection: MCPConnection, baseUrl: string): CustomFetch {
    const factory = (
      connection as unknown as {
        createFetchFunction: (
          getHeaders: () => Record<string, string> | null | undefined,
          timeout?: number,
          sseBodyTimeout?: number,
          configuredSecretHeaderKeys?: ReadonlySet<string>,
          baseUrl?: string,
        ) => CustomFetch;
      }
    ).createFetchFunction;
    return factory.call(connection, () => null, undefined, 300000, undefined, baseUrl);
  }

  function createBaseUrlDispatchers(connection: MCPConnection, baseUrl: string): string[] {
    const privateSelf = connection as unknown as {
      agents: Array<{ constructor: { name: string } }>;
    };
    createBaseUrlFetch(connection, baseUrl);
    return privateSelf.agents.map((agent) => agent.constructor.name);
  }

  const proxyEnvKeys = [
    'PROXY',
    'HTTP_PROXY',
    'HTTPS_PROXY',
    'NO_PROXY',
    'http_proxy',
    'https_proxy',
    'no_proxy',
  ] as const;
  type ProxyEnvKey = (typeof proxyEnvKeys)[number];

  function snapshotProxyEnv(): Partial<Record<ProxyEnvKey, string>> {
    const snapshot: Partial<Record<ProxyEnvKey, string>> = {};
    for (const key of proxyEnvKeys) {
      if (process.env[key] != null) {
        snapshot[key] = process.env[key];
      }
    }
    return snapshot;
  }

  function restoreProxyEnv(snapshot: Partial<Record<ProxyEnvKey, string>>): void {
    for (const key of proxyEnvKeys) {
      if (snapshot[key] == null) {
        delete process.env[key];
      } else {
        process.env[key] = snapshot[key];
      }
    }
  }

  function clearProxyEnv(): void {
    for (const key of proxyEnvKeys) {
      delete process.env[key];
    }
  }

  it('should allocate proxy dispatchers for streamable-http when proxy is configured', () => {
    conn = new MCPConnection({
      serverName: 'customfetch-proxy-dispatchers',
      serverConfig: {
        type: 'streamable-http',
        url: 'https://mcp.example.com/mcp',
        proxy: 'http://proxy.example.com:8080',
      },
      useSSRFProtection: false,
    });

    const privateSelf = conn as unknown as {
      agents: Array<{ constructor: { name: string } }>;
      createFetchFunction: (
        getHeaders: () => Record<string, string> | null | undefined,
        timeout?: number,
        sseBodyTimeout?: number,
        configuredSecretHeaderKeys?: ReadonlySet<string>,
        baseUrl?: string,
      ) => CustomFetch;
    };
    privateSelf.createFetchFunction.call(
      conn,
      () => null,
      undefined,
      300000,
      undefined,
      'https://mcp.example.com/mcp',
    );

    expect(privateSelf.agents.map((agent) => agent.constructor.name)).toEqual([
      'ProxyAgent',
      'ProxyAgent',
    ]);
  });

  it('should use the PROXY env var for streamable-http when server proxy is not configured', () => {
    const originalProxy = process.env.PROXY;
    process.env.PROXY = 'http://env-proxy.example.com:8080';
    try {
      conn = new MCPConnection({
        serverName: 'customfetch-env-proxy-dispatchers',
        serverConfig: {
          type: 'streamable-http',
          url: 'https://mcp.example.com/mcp',
        },
        useSSRFProtection: false,
      });

      const privateSelf = conn as unknown as {
        agents: Array<{ constructor: { name: string } }>;
        createFetchFunction: (
          getHeaders: () => Record<string, string> | null | undefined,
          timeout?: number,
          sseBodyTimeout?: number,
          configuredSecretHeaderKeys?: ReadonlySet<string>,
          baseUrl?: string,
        ) => CustomFetch;
      };
      privateSelf.createFetchFunction.call(
        conn,
        () => null,
        undefined,
        300000,
        undefined,
        'https://mcp.example.com/mcp',
      );

      expect(privateSelf.agents.map((agent) => agent.constructor.name)).toEqual([
        'ProxyAgent',
        'ProxyAgent',
      ]);
    } finally {
      if (originalProxy == null) {
        delete process.env.PROXY;
      } else {
        process.env.PROXY = originalProxy;
      }
    }
  });

  it('should use standard HTTP proxy env vars for streamable-http when PROXY is absent', () => {
    const originalProxy = process.env.PROXY;
    const originalHttpProxy = process.env.HTTP_PROXY;
    const originalHttpsProxy = process.env.HTTPS_PROXY;
    const originalNoProxy = process.env.NO_PROXY;
    const originalLowerHttpProxy = process.env.http_proxy;
    const originalLowerHttpsProxy = process.env.https_proxy;
    const originalLowerNoProxy = process.env.no_proxy;

    delete process.env.PROXY;
    delete process.env.http_proxy;
    delete process.env.https_proxy;
    delete process.env.no_proxy;
    process.env.HTTP_PROXY = 'http://http-proxy.example.com:8080';
    process.env.HTTPS_PROXY = 'http://https-proxy.example.com:8080';
    process.env.NO_PROXY = 'localhost,127.0.0.1';

    try {
      conn = new MCPConnection({
        serverName: 'customfetch-standard-env-proxy-dispatchers',
        serverConfig: {
          type: 'streamable-http',
          url: 'https://mcp.example.com/mcp',
        },
        useSSRFProtection: false,
      });

      const privateSelf = conn as unknown as {
        agents: Array<{ constructor: { name: string } }>;
        createFetchFunction: (
          getHeaders: () => Record<string, string> | null | undefined,
          timeout?: number,
          sseBodyTimeout?: number,
          configuredSecretHeaderKeys?: ReadonlySet<string>,
          baseUrl?: string,
        ) => CustomFetch;
      };
      privateSelf.createFetchFunction.call(
        conn,
        () => null,
        undefined,
        300000,
        undefined,
        'https://mcp.example.com/mcp',
      );

      expect(privateSelf.agents.map((agent) => agent.constructor.name)).toEqual([
        'ProxyAgent',
        'ProxyAgent',
      ]);
    } finally {
      if (originalProxy == null) {
        delete process.env.PROXY;
      } else {
        process.env.PROXY = originalProxy;
      }
      if (originalHttpProxy == null) {
        delete process.env.HTTP_PROXY;
      } else {
        process.env.HTTP_PROXY = originalHttpProxy;
      }
      if (originalHttpsProxy == null) {
        delete process.env.HTTPS_PROXY;
      } else {
        process.env.HTTPS_PROXY = originalHttpsProxy;
      }
      if (originalNoProxy == null) {
        delete process.env.NO_PROXY;
      } else {
        process.env.NO_PROXY = originalNoProxy;
      }
      if (originalLowerHttpProxy == null) {
        delete process.env.http_proxy;
      } else {
        process.env.http_proxy = originalLowerHttpProxy;
      }
      if (originalLowerHttpsProxy == null) {
        delete process.env.https_proxy;
      } else {
        process.env.https_proxy = originalLowerHttpsProxy;
      }
      if (originalLowerNoProxy == null) {
        delete process.env.no_proxy;
      } else {
        process.env.no_proxy = originalLowerNoProxy;
      }
    }
  });

  it('should honor NO_PROXY when standard HTTP proxy env vars are configured', () => {
    const originalProxy = process.env.PROXY;
    const originalHttpsProxy = process.env.HTTPS_PROXY;
    const originalNoProxy = process.env.NO_PROXY;
    const originalLowerHttpsProxy = process.env.https_proxy;
    const originalLowerNoProxy = process.env.no_proxy;

    delete process.env.PROXY;
    delete process.env.https_proxy;
    delete process.env.no_proxy;
    process.env.HTTPS_PROXY = 'http://https-proxy.example.com:8080';
    process.env.NO_PROXY = 'mcp.example.com';

    try {
      conn = new MCPConnection({
        serverName: 'customfetch-standard-env-no-proxy',
        serverConfig: {
          type: 'streamable-http',
          url: 'https://mcp.example.com/mcp',
        },
        useSSRFProtection: false,
      });

      const privateSelf = conn as unknown as {
        agents: Array<{ constructor: { name: string } }>;
        createFetchFunction: (
          getHeaders: () => Record<string, string> | null | undefined,
          timeout?: number,
          sseBodyTimeout?: number,
          configuredSecretHeaderKeys?: ReadonlySet<string>,
          baseUrl?: string,
        ) => CustomFetch;
      };
      privateSelf.createFetchFunction.call(
        conn,
        () => null,
        undefined,
        300000,
        undefined,
        'https://mcp.example.com/mcp',
      );

      expect(privateSelf.agents.map((agent) => agent.constructor.name)).toEqual(['Agent', 'Agent']);
    } finally {
      if (originalProxy == null) {
        delete process.env.PROXY;
      } else {
        process.env.PROXY = originalProxy;
      }
      if (originalHttpsProxy == null) {
        delete process.env.HTTPS_PROXY;
      } else {
        process.env.HTTPS_PROXY = originalHttpsProxy;
      }
      if (originalNoProxy == null) {
        delete process.env.NO_PROXY;
      } else {
        process.env.NO_PROXY = originalNoProxy;
      }
      if (originalLowerHttpsProxy == null) {
        delete process.env.https_proxy;
      } else {
        process.env.https_proxy = originalLowerHttpsProxy;
      }
      if (originalLowerNoProxy == null) {
        delete process.env.no_proxy;
      } else {
        process.env.no_proxy = originalLowerNoProxy;
      }
    }
  });

  it('should honor bare IPv6 NO_PROXY entries without parsing a port suffix', () => {
    const originalProxy = process.env.PROXY;
    const originalHttpProxy = process.env.HTTP_PROXY;
    const originalNoProxy = process.env.NO_PROXY;
    const originalLowerHttpProxy = process.env.http_proxy;
    const originalLowerNoProxy = process.env.no_proxy;

    delete process.env.PROXY;
    delete process.env.http_proxy;
    delete process.env.no_proxy;
    process.env.HTTP_PROXY = 'http://http-proxy.example.com:8080';
    process.env.NO_PROXY = '::1';

    try {
      conn = new MCPConnection({
        serverName: 'customfetch-standard-env-no-proxy-ipv6',
        serverConfig: {
          type: 'streamable-http',
          url: 'http://[::1]:3000/mcp',
        },
        useSSRFProtection: false,
      });

      const privateSelf = conn as unknown as {
        agents: Array<{ constructor: { name: string } }>;
        createFetchFunction: (
          getHeaders: () => Record<string, string> | null | undefined,
          timeout?: number,
          sseBodyTimeout?: number,
          configuredSecretHeaderKeys?: ReadonlySet<string>,
          baseUrl?: string,
        ) => CustomFetch;
      };
      privateSelf.createFetchFunction.call(
        conn,
        () => null,
        undefined,
        300000,
        undefined,
        'http://[::1]:3000/mcp',
      );

      expect(privateSelf.agents.map((agent) => agent.constructor.name)).toEqual(['Agent', 'Agent']);
    } finally {
      if (originalProxy == null) {
        delete process.env.PROXY;
      } else {
        process.env.PROXY = originalProxy;
      }
      if (originalHttpProxy == null) {
        delete process.env.HTTP_PROXY;
      } else {
        process.env.HTTP_PROXY = originalHttpProxy;
      }
      if (originalNoProxy == null) {
        delete process.env.NO_PROXY;
      } else {
        process.env.NO_PROXY = originalNoProxy;
      }
      if (originalLowerHttpProxy == null) {
        delete process.env.http_proxy;
      } else {
        process.env.http_proxy = originalLowerHttpProxy;
      }
      if (originalLowerNoProxy == null) {
        delete process.env.no_proxy;
      } else {
        process.env.no_proxy = originalLowerNoProxy;
      }
    }
  });

  it('should honor wildcard tokens in NO_PROXY lists', () => {
    const originalProxy = process.env.PROXY;
    const originalHttpProxy = process.env.HTTP_PROXY;
    const originalNoProxy = process.env.NO_PROXY;
    const originalLowerHttpProxy = process.env.http_proxy;
    const originalLowerNoProxy = process.env.no_proxy;

    delete process.env.PROXY;
    delete process.env.http_proxy;
    delete process.env.no_proxy;
    process.env.HTTP_PROXY = 'http://http-proxy.example.com:8080';
    process.env.NO_PROXY = 'localhost,*';

    try {
      conn = new MCPConnection({
        serverName: 'customfetch-standard-env-no-proxy-wildcard-list',
        serverConfig: {
          type: 'streamable-http',
          url: 'http://mcp.example.com/mcp',
        },
        useSSRFProtection: false,
      });

      const privateSelf = conn as unknown as {
        agents: Array<{ constructor: { name: string } }>;
        createFetchFunction: (
          getHeaders: () => Record<string, string> | null | undefined,
          timeout?: number,
          sseBodyTimeout?: number,
          configuredSecretHeaderKeys?: ReadonlySet<string>,
          baseUrl?: string,
        ) => CustomFetch;
      };
      privateSelf.createFetchFunction.call(
        conn,
        () => null,
        undefined,
        300000,
        undefined,
        'http://mcp.example.com/mcp',
      );

      expect(privateSelf.agents.map((agent) => agent.constructor.name)).toEqual(['Agent', 'Agent']);
    } finally {
      if (originalProxy == null) {
        delete process.env.PROXY;
      } else {
        process.env.PROXY = originalProxy;
      }
      if (originalHttpProxy == null) {
        delete process.env.HTTP_PROXY;
      } else {
        process.env.HTTP_PROXY = originalHttpProxy;
      }
      if (originalNoProxy == null) {
        delete process.env.NO_PROXY;
      } else {
        process.env.NO_PROXY = originalNoProxy;
      }
      if (originalLowerHttpProxy == null) {
        delete process.env.http_proxy;
      } else {
        process.env.http_proxy = originalLowerHttpProxy;
      }
      if (originalLowerNoProxy == null) {
        delete process.env.no_proxy;
      } else {
        process.env.no_proxy = originalLowerNoProxy;
      }
    }
  });

  it('should honor CIDR and IP range patterns in NO_PROXY lists', async () => {
    const originalEnv = snapshotProxyEnv();
    clearProxyEnv();
    process.env.HTTP_PROXY = 'http://http-proxy.example.com:8080';
    process.env.NO_PROXY = '10.0.0.0/8,192.168.1.10-192.168.1.20';

    const expectDispatcherNamesForUrl = async (
      url: string,
      expectedNames: string[],
    ): Promise<void> => {
      await safeDisconnect(conn);
      conn = new MCPConnection({
        serverName: `customfetch-no-proxy-${url}`,
        serverConfig: {
          type: 'streamable-http',
          url,
        },
        useSSRFProtection: false,
      });
      expect(createBaseUrlDispatchers(conn, url)).toEqual(expectedNames);
    };

    try {
      await expectDispatcherNamesForUrl('http://10.2.3.4/mcp', ['Agent', 'Agent']);
      await expectDispatcherNamesForUrl('http://192.168.1.15/mcp', ['Agent', 'Agent']);
      await expectDispatcherNamesForUrl('http://192.168.1.25/mcp', ['ProxyAgent', 'ProxyAgent']);
    } finally {
      restoreProxyEnv(originalEnv);
    }
  });

  it('should match NO_PROXY host entries like undici env proxy agents', async () => {
    const originalEnv = snapshotProxyEnv();
    clearProxyEnv();
    process.env.HTTPS_PROXY = 'http://https-proxy.example.com:8080';

    const expectDispatcherNamesForUrl = async (
      noProxy: string,
      url: string,
      expectedNames: string[],
    ): Promise<void> => {
      await safeDisconnect(conn);
      process.env.NO_PROXY = noProxy;
      conn = new MCPConnection({
        serverName: `customfetch-no-proxy-host-${noProxy}-${url}`,
        serverConfig: {
          type: 'streamable-http',
          url,
        },
        useSSRFProtection: false,
      });
      expect(createBaseUrlDispatchers(conn, url)).toEqual(expectedNames);
    };

    try {
      await expectDispatcherNamesForUrl('example.com', 'https://example.com/mcp', [
        'Agent',
        'Agent',
      ]);
      await expectDispatcherNamesForUrl('example.com', 'https://api.example.com/mcp', [
        'Agent',
        'Agent',
      ]);
      await expectDispatcherNamesForUrl('*.example.com', 'https://api.example.com/mcp', [
        'Agent',
        'Agent',
      ]);
      await expectDispatcherNamesForUrl('*.example.com', 'https://example.com/mcp', [
        'Agent',
        'Agent',
      ]);
      await expectDispatcherNamesForUrl('.example.com', 'https://example.com/mcp', [
        'Agent',
        'Agent',
      ]);
      await expectDispatcherNamesForUrl('.example.com', 'https://api.example.com/mcp', [
        'Agent',
        'Agent',
      ]);
      await expectDispatcherNamesForUrl('example.com', 'https://badexample.com/mcp', [
        'ProxyAgent',
        'ProxyAgent',
      ]);
    } finally {
      restoreProxyEnv(originalEnv);
    }
  });

  it('should let empty lowercase proxy env vars disable uppercase fallbacks', () => {
    const originalProxy = process.env.PROXY;
    const originalHttpProxy = process.env.HTTP_PROXY;
    const originalNoProxy = process.env.NO_PROXY;
    const originalLowerHttpProxy = process.env.http_proxy;
    const originalLowerNoProxy = process.env.no_proxy;

    delete process.env.PROXY;
    delete process.env.NO_PROXY;
    delete process.env.no_proxy;
    process.env.HTTP_PROXY = 'http://http-proxy.example.com:8080';
    process.env.http_proxy = '';

    try {
      conn = new MCPConnection({
        serverName: 'customfetch-standard-empty-lowercase-proxy',
        serverConfig: {
          type: 'streamable-http',
          url: 'http://mcp.example.com/mcp',
        },
        useSSRFProtection: false,
      });

      const privateSelf = conn as unknown as {
        agents: Array<{ constructor: { name: string } }>;
        createFetchFunction: (
          getHeaders: () => Record<string, string> | null | undefined,
          timeout?: number,
          sseBodyTimeout?: number,
          configuredSecretHeaderKeys?: ReadonlySet<string>,
          baseUrl?: string,
        ) => CustomFetch;
      };
      privateSelf.createFetchFunction.call(
        conn,
        () => null,
        undefined,
        300000,
        undefined,
        'http://mcp.example.com/mcp',
      );

      expect(privateSelf.agents.map((agent) => agent.constructor.name)).toEqual(['Agent', 'Agent']);
    } finally {
      if (originalProxy == null) {
        delete process.env.PROXY;
      } else {
        process.env.PROXY = originalProxy;
      }
      if (originalHttpProxy == null) {
        delete process.env.HTTP_PROXY;
      } else {
        process.env.HTTP_PROXY = originalHttpProxy;
      }
      if (originalNoProxy == null) {
        delete process.env.NO_PROXY;
      } else {
        process.env.NO_PROXY = originalNoProxy;
      }
      if (originalLowerHttpProxy == null) {
        delete process.env.http_proxy;
      } else {
        process.env.http_proxy = originalLowerHttpProxy;
      }
      if (originalLowerNoProxy == null) {
        delete process.env.no_proxy;
      } else {
        process.env.no_proxy = originalLowerNoProxy;
      }
    }
  });

  it('should let empty lowercase no_proxy disable uppercase fallbacks', () => {
    const originalProxy = process.env.PROXY;
    const originalHttpProxy = process.env.HTTP_PROXY;
    const originalNoProxy = process.env.NO_PROXY;
    const originalLowerHttpProxy = process.env.http_proxy;
    const originalLowerNoProxy = process.env.no_proxy;

    delete process.env.PROXY;
    delete process.env.http_proxy;
    process.env.HTTP_PROXY = 'http://http-proxy.example.com:8080';
    process.env.NO_PROXY = 'mcp.example.com';
    process.env.no_proxy = '';

    try {
      conn = new MCPConnection({
        serverName: 'customfetch-standard-empty-lowercase-no-proxy',
        serverConfig: {
          type: 'streamable-http',
          url: 'http://mcp.example.com/mcp',
        },
        useSSRFProtection: false,
      });

      const privateSelf = conn as unknown as {
        agents: Array<{ constructor: { name: string } }>;
        createFetchFunction: (
          getHeaders: () => Record<string, string> | null | undefined,
          timeout?: number,
          sseBodyTimeout?: number,
          configuredSecretHeaderKeys?: ReadonlySet<string>,
          baseUrl?: string,
        ) => CustomFetch;
      };
      privateSelf.createFetchFunction.call(
        conn,
        () => null,
        undefined,
        300000,
        undefined,
        'http://mcp.example.com/mcp',
      );

      expect(privateSelf.agents.map((agent) => agent.constructor.name)).toEqual([
        'ProxyAgent',
        'ProxyAgent',
      ]);
    } finally {
      if (originalProxy == null) {
        delete process.env.PROXY;
      } else {
        process.env.PROXY = originalProxy;
      }
      if (originalHttpProxy == null) {
        delete process.env.HTTP_PROXY;
      } else {
        process.env.HTTP_PROXY = originalHttpProxy;
      }
      if (originalNoProxy == null) {
        delete process.env.NO_PROXY;
      } else {
        process.env.NO_PROXY = originalNoProxy;
      }
      if (originalLowerHttpProxy == null) {
        delete process.env.http_proxy;
      } else {
        process.env.http_proxy = originalLowerHttpProxy;
      }
      if (originalLowerNoProxy == null) {
        delete process.env.no_proxy;
      } else {
        process.env.no_proxy = originalLowerNoProxy;
      }
    }
  });

  it('should recompute proxy dispatchers from the resolved request URL', async () => {
    const originalEnv = snapshotProxyEnv();
    const capture = await createHeaderCaptureServer();
    clearProxyEnv();
    process.env.HTTP_PROXY = 'http://http-proxy.example.com:8080';
    process.env.NO_PROXY = '127.0.0.1';

    try {
      conn = new MCPConnection({
        serverName: 'customfetch-recompute-proxy-dispatcher',
        serverConfig: {
          type: 'streamable-http',
          url: 'http://mcp.example.com/mcp',
        },
        useSSRFProtection: false,
      });

      const customFetch = createBaseUrlFetch(conn, 'http://mcp.example.com/mcp');
      const response = await customFetch(capture.url);

      expect(response.status).toBe(200);
      await response.body?.cancel();
      expect(capture.receivedRequests).toHaveLength(1);
      expect(
        (conn as unknown as { agents: Array<{ constructor: { name: string } }> }).agents.map(
          (agent) => agent.constructor.name,
        ),
      ).toEqual(['ProxyAgent', 'ProxyAgent', 'Agent']);
    } finally {
      restoreProxyEnv(originalEnv);
      await capture.close();
    }
  });

  it('should preflight proxied IP literal targets before dispatching network requests', async () => {
    mockedResolveHostnameSSRF.mockResolvedValueOnce(true);

    conn = new MCPConnection({
      serverName: 'customfetch-proxy-ssrf',
      serverConfig: {
        type: 'streamable-http',
        url: 'https://mcp.example.com/mcp',
        proxy: 'http://proxy.example.com:8080',
      },
      useSSRFProtection: true,
    });

    const customFetch = getCustomFetch(conn);

    await expect(customFetch('http://203.0.113.10/mcp')).rejects.toThrow(
      /proxied MCP request target/,
    );
    expect(mockedResolveHostnameSSRF).toHaveBeenCalledWith('203.0.113.10', null, '80');
  });

  it('should reject proxied hostname targets unless explicitly allowed when SSRF protection is enabled', async () => {
    mockedResolveHostnameSSRF.mockClear();

    conn = new MCPConnection({
      serverName: 'customfetch-proxy-ssrf-hostname-denied',
      serverConfig: {
        type: 'streamable-http',
        url: 'https://mcp.example.com/mcp',
        proxy: 'http://proxy.example.com:8080',
      },
      useSSRFProtection: true,
    });

    const customFetch = getCustomFetch(conn);

    await expect(customFetch('http://hostname-only.example/mcp')).rejects.toThrow(
      /must be an IP literal or an explicitly allowed host/,
    );
    expect(mockedResolveHostnameSSRF).not.toHaveBeenCalled();
  });

  it('should skip proxied SSRF checks for explicitly allowed target hosts', async () => {
    const proxy = await createTunnelProxyCaptureServer();
    mockedResolveHostnameSSRF.mockClear();

    try {
      conn = new MCPConnection({
        serverName: 'customfetch-proxy-ssrf-allowed-dns',
        serverConfig: {
          type: 'streamable-http',
          url: 'https://mcp.example.com/mcp',
          proxy: proxy.url,
        },
        useSSRFProtection: true,
        allowedAddresses: ['proxy-only.internal:80'],
      });

      const customFetch = getCustomFetch(conn);
      const response = await customFetch('http://proxy-only.internal/mcp');

      expect(response.status).toBe(200);
      await response.body?.cancel().catch(() => undefined);
      expect(proxy.receivedRequests[0]?.method).toBe('CONNECT');
      expect(mockedResolveHostnameSSRF).not.toHaveBeenCalled();
    } finally {
      await proxy.close();
    }
  });

  it('should allow NO_PROXY hostname targets to use direct SSRF-safe dispatchers', async () => {
    const originalEnv = snapshotProxyEnv();
    const capture = await createHeaderCaptureServer();
    clearProxyEnv();
    process.env.HTTP_PROXY = 'http://http-proxy.example.com:8080';
    process.env.NO_PROXY = 'direct.example.com';
    mockedResolveHostnameSSRF.mockClear();

    try {
      conn = new MCPConnection({
        serverName: 'customfetch-no-proxy-hostname-direct',
        serverConfig: {
          type: 'streamable-http',
          url: 'http://mcp.example.com/mcp',
        },
        useSSRFProtection: true,
      });

      const customFetch = createBaseUrlFetch(conn, 'http://mcp.example.com/mcp');
      const directUrl = capture.url.replace('127.0.0.1', 'direct.example.com');
      const response = await customFetch(directUrl);

      expect(response.status).toBe(200);
      await response.body?.cancel().catch(() => undefined);
      expect(capture.receivedRequests).toHaveLength(1);
      expect(mockedResolveHostnameSSRF).not.toHaveBeenCalled();
    } finally {
      restoreProxyEnv(originalEnv);
      await capture.close();
    }
  });

  it.each<['string' | 'URL' | 'Request']>([['string'], ['URL'], ['Request']])(
    'should accept a %s input without throwing on URL derivation',
    async (shape) => {
      target = await createStreamableServer();

      conn = new MCPConnection({
        serverName: `customfetch-${shape.toLowerCase()}`,
        serverConfig: { type: 'streamable-http', url: target.url },
        useSSRFProtection: false,
      });

      const customFetch = getCustomFetch(conn);
      const inputs: Record<typeof shape, () => UndiciRequestInfo> = {
        string: () => target!.url,
        URL: () => new URL(target!.url),
        Request: () => new UndiciRequest(target!.url, { method: 'GET' }),
      };

      const response = await customFetch(inputs[shape]());
      expect(response.status).toBeGreaterThanOrEqual(200);
      await response.body?.cancel().catch(() => undefined);
    },
  );

  it('should preserve headers carried on a Request input when no override headers are supplied', async () => {
    /**
     * Pre-fix regression: `buildFetchInit` unconditionally set `headers: {}`
     * when neither `init.headers` nor runtime headers contributed anything.
     * That overrode the headers attached to the `Request` itself, dropping
     * Authorization / mcp-session-id / protocol negotiation headers that
     * wrappers commonly bake onto the `Request` object directly.
     */
    const capture = await createHeaderCaptureServer();
    try {
      conn = new MCPConnection({
        serverName: 'customfetch-request-headers',
        serverConfig: { type: 'streamable-http', url: capture.url },
        useSSRFProtection: false,
      });

      const customFetch = getCustomFetch(conn);
      const request = new UndiciRequest(capture.url, {
        method: 'GET',
        headers: {
          Authorization: 'Bearer request-input-token',
          'X-Wrapper-Header': 'wrapper-supplied',
        },
      });

      const response = await customFetch(request);
      expect(response.status).toBe(200);
      await response.body?.cancel().catch(() => undefined);

      expect(capture.receivedHeaders.length).toBeGreaterThan(0);
      const headers = capture.receivedHeaders[0];
      expect(headers['authorization']).toBe('Bearer request-input-token');
      expect(headers['x-wrapper-header']).toBe('wrapper-supplied');
    } finally {
      await capture.close();
    }
  });

  it('should preserve POST method and body across a 308 redirect when input is a Request', async () => {
    /**
     * Pre-fix regression: switching `url` to the `Location` string on
     * redirect dropped the original `Request`'s method and body, so a
     * redirected POST silently became a GET with no payload — the exact
     * thing 307/308 are designed to forbid.
     */
    const capture = await createHeaderCaptureServer();
    let server: TestServer | undefined;
    try {
      server = await createCrossOriginRedirectingServer(capture.url, 308);

      conn = new MCPConnection({
        serverName: 'customfetch-request-redirect-post',
        serverConfig: { type: 'streamable-http', url: server.url },
        useSSRFProtection: false,
      });

      const customFetch = getCustomFetch(conn);
      const payload = JSON.stringify({ jsonrpc: '2.0', method: 'ping', id: 1 });
      const request = new UndiciRequest(server.url, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: payload,
      });

      const response = await customFetch(request);
      expect(response.status).toBe(200);
      await response.body?.cancel().catch(() => undefined);

      expect(server.redirectHit).toBe(true);
      expect(capture.receivedRequests.length).toBeGreaterThan(0);
      const last = capture.receivedRequests[capture.receivedRequests.length - 1];
      expect(last.method).toBe('POST');
      expect(last.body).toBe(payload);
    } finally {
      await capture.close();
      if (server) {
        await server.close();
      }
    }
  });

  it("should honor the Request's AbortController.signal even after Request -> (string, init) normalization", async () => {
    /**
     * Pre-fix regression: `resolveFetchInput` copied method/body/headers
     * out of a `Request` input but dropped `Request.signal`. Callers that
     * wired an `AbortController` onto the `Request` for cancellation or
     * timeouts lost that wiring on entry to the redirect loop, so an abort
     * after the request started had no effect.
     */
    target = await createStreamableServer();
    conn = new MCPConnection({
      serverName: 'customfetch-request-signal',
      serverConfig: { type: 'streamable-http', url: target.url },
      useSSRFProtection: false,
    });

    const customFetch = getCustomFetch(conn);
    const controller = new AbortController();
    const request = new UndiciRequest(target.url, {
      method: 'GET',
      signal: controller.signal,
    });
    /** Abort before the fetch lands so we don't race the real socket. */
    controller.abort();

    await expect(customFetch(request)).rejects.toThrow();
  });

  it('should not crash on a cross-origin redirect when no headers are present', async () => {
    /**
     * Pre-fix regression: `buildFetchInit` skips setting `headers` when
     * nothing contributes any, but the cross-origin strip path read
     * `currentInit.headers` unconditionally and called `Object.entries`
     * on `undefined`, throwing `TypeError`. Guarded so a no-headers
     * cross-origin hop returns the response cleanly.
     */
    const capture = await createHeaderCaptureServer();
    let server: TestServer | undefined;
    try {
      server = await createCrossOriginRedirectingServer(capture.url, 307);

      conn = new MCPConnection({
        serverName: 'customfetch-redirect-no-headers',
        serverConfig: { type: 'streamable-http', url: server.url },
        useSSRFProtection: false,
      });

      const customFetch = getCustomFetch(conn);
      const response = await customFetch(server.url);
      expect(response.status).toBe(200);
      await response.body?.cancel().catch(() => undefined);
      expect(server.redirectHit).toBe(true);
    } finally {
      await capture.close();
      if (server) {
        await server.close();
      }
    }
  });

  it('should not apply streamable HTTP response caps unless the transport opts in', async () => {
    process.env.MCP_STREAMABLE_HTTP_MAX_RESPONSE_BYTES = '8';
    const server = await createRawResponseServer((_req, res) => {
      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.end('{"jsonrpc":"2.0","id":1,"result":{"too":"large"}}');
    });
    try {
      conn = new MCPConnection({
        serverName: 'customfetch-unguarded-byte-limit',
        serverConfig: { type: 'sse', url: server.url },
        useSSRFProtection: false,
      });

      const customFetch = getCustomFetch(conn);
      const response = await customFetch(server.url, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ jsonrpc: '2.0', method: 'ping', id: 1 }),
      });

      await expect(response.text()).resolves.toContain('"too":"large"');
    } finally {
      await server.close();
    }
  });

  it('enforces App-profile HTTP response bounds before JSON parsing even when the generic guard is disabled', async () => {
    process.env.MCP_STREAMABLE_HTTP_MAX_RESPONSE_BYTES = '0';
    const server = await createRawResponseServer((_req, res) => {
      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.write('{"jsonrpc":"2.0","id":1,"result":{"text":"');
      res.end('x'.repeat(100) + '"}}');
    });
    try {
      conn = new MCPConnection({
        serverName: 'app-profile-response-cap',
        serverConfig: { type: 'streamable-http', url: server.url },
        useSSRFProtection: false,
        capabilityProfile: 'apps',
        operationLimits: { maxBytes: 64, timeoutMs: 30_000, maxActive: 16 },
      });
      const customFetch = getGuardedStreamableHTTPCustomFetch(conn);
      const response = await customFetch(server.url, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ jsonrpc: '2.0', method: 'resources/read', id: 1 }),
      });
      await expect(response.json()).rejects.toThrow(
        /MCP response exceeded byte limit.*limit=64 bytes/,
      );
    } finally {
      await server.close();
    }
  });

  it('honors an operator-raised App cap for a valid response above the 4 MiB default', async () => {
    const text = 'x'.repeat(4 * 1024 * 1024 + 1024);
    const server = await createRawResponseServer((_req, res) => {
      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ jsonrpc: '2.0', id: 1, result: { text } }));
    });
    try {
      conn = new MCPConnection({
        serverName: 'app-profile-raised-byte-cap',
        serverConfig: { type: 'streamable-http', url: server.url },
        useSSRFProtection: false,
        capabilityProfile: 'apps',
        operationLimits: { maxBytes: 6 * 1024 * 1024, timeoutMs: 30_000, maxActive: 16 },
      });
      const response = await getGuardedStreamableHTTPCustomFetch(conn)(server.url, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ jsonrpc: '2.0', method: 'resources/read', id: 1 }),
      });
      const result = (await response.json()) as { result: { text: string } };
      expect(result.result.text).toHaveLength(text.length);
    } finally {
      await server.close();
    }
  });

  it('honors an operator-raised App cap for an SSE event above the generic 5 MiB line limit', async () => {
    const event = `data: ${'x'.repeat(5 * 1024 * 1024 + 1024)}\n\n`;
    const server = await createRawResponseServer((_req, res) => {
      res.writeHead(200, { 'Content-Type': 'text/event-stream' });
      res.write(event.slice(0, 2 * 1024 * 1024));
      res.end(event.slice(2 * 1024 * 1024));
    });
    try {
      conn = new MCPConnection({
        serverName: 'app-profile-raised-sse-cap',
        serverConfig: { type: 'streamable-http', url: server.url },
        useSSRFProtection: false,
        capabilityProfile: 'apps',
        operationLimits: { maxBytes: 6 * 1024 * 1024, timeoutMs: 30_000, maxActive: 16 },
      });
      const response = await getGuardedStreamableHTTPCustomFetch(conn)(server.url, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ jsonrpc: '2.0', method: 'resources/read', id: 1 }),
      });
      expect((await response.text()).length).toBe(event.length);
    } finally {
      await server.close();
    }
  });

  it('allows a long App SSE POST with cumulative bytes above the per-event cap', async () => {
    const data = Array.from({ length: 4 }, (_, i) => `data: {"event":${i},"ok":true}\n\n`).join('');
    expect(Buffer.byteLength(data)).toBeGreaterThan(64);
    const server = await createRawResponseServer((_req, res) => {
      res.writeHead(200, { 'Content-Type': 'text/event-stream' });
      const half = Math.floor(data.length / 2);
      res.write(data.slice(0, half));
      res.end(data.slice(half));
    });
    try {
      conn = new MCPConnection({
        serverName: 'app-profile-sse-long-lived',
        serverConfig: { type: 'streamable-http', url: server.url },
        useSSRFProtection: false,
        capabilityProfile: 'apps',
        operationLimits: { maxBytes: 64, timeoutMs: 30_000, maxActive: 16 },
      });
      const response = await getGuardedStreamableHTTPCustomFetch(conn)(server.url, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ jsonrpc: '2.0', method: 'notifications/cancelled' }),
      });
      await expect(response.text()).resolves.toBe(data);
    } finally {
      await server.close();
    }
  });

  it('rejects an App SSE POST event built from individually small data lines', async () => {
    const server = await createRawResponseServer((_req, res) => {
      res.writeHead(200, { 'Content-Type': 'text/event-stream' });
      res.write(`data: ${'x'.repeat(30)}\n`);
      res.end(`data: ${'y'.repeat(30)}\n\n`);
    });
    try {
      conn = new MCPConnection({
        serverName: 'app-profile-sse-multiline-cap',
        serverConfig: { type: 'streamable-http', url: server.url },
        useSSRFProtection: false,
        capabilityProfile: 'apps',
        operationLimits: { maxBytes: 64, timeoutMs: 30_000, maxActive: 16 },
      });
      const response = await getGuardedStreamableHTTPCustomFetch(conn)(server.url, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ jsonrpc: '2.0', method: 'notifications/cancelled' }),
      });
      await expect(response.text()).rejects.toThrow(
        /MCP response exceeded byte limit.*limit=64 bytes/,
      );
    } finally {
      await server.close();
    }
  });

  it('blocks a chunked standalone SSE App event before the SDK delivers it', async () => {
    let sentOversize = false;
    let getRequests = 0;
    const server = await createRawResponseServer((req, res) => {
      if (req.method !== 'GET') {
        res.writeHead(404);
        res.end();
        return;
      }
      getRequests++;
      res.writeHead(200, { 'Content-Type': 'text/event-stream' });
      res.write('retry: 10\nevent: endpoint\ndata: /messages\n\n');
      setImmediate(() => {
        sentOversize = true;
        res.write('data: {"jsonrpc":"2.0","id":1,"result":{"text":"');
        res.write('x'.repeat(256));
        res.write('"}}\n\n');
      });
    });
    conn = new MCPConnection({
      serverName: 'app-profile-sse-event-cap',
      serverConfig: { type: 'sse', url: server.url },
      useSSRFProtection: false,
      capabilityProfile: 'apps',
      operationLimits: { maxBytes: 128, timeoutMs: 30_000, maxActive: 16 },
    });
    const transport = await (
      conn as unknown as {
        constructTransport(options: { type: 'sse'; url: string }): Promise<{
          start(): Promise<void>;
          close(): Promise<void>;
          onmessage?: (message: unknown) => void;
          onerror?: (error: Error) => void;
        }>;
      }
    ).constructTransport({ type: 'sse', url: server.url });
    const delivered: unknown[] = [];
    transport.onmessage = (message) => delivered.push(message);
    let timeout: ReturnType<typeof setTimeout> | undefined;
    const originalClose = transport.close.bind(transport);
    const closedOnOversize = new Promise<void>((resolve, reject) => {
      timeout = setTimeout(
        () => reject(new Error('SSE oversize did not close the SDK session')),
        3000,
      );
      transport.close = async () => {
        resolve();
        await originalClose();
      };
    });
    try {
      const startupSettled = transport.start().then(
        () => 'connected',
        () => 'rejected',
      );
      await Promise.all([startupSettled, closedOnOversize]);
      expect(sentOversize).toBe(true);
      expect(delivered).toEqual([]);
      const requestsWhenClosed = getRequests;
      await new Promise<void>((resolve) => setTimeout(resolve, 100));
      expect(getRequests).toBe(requestsWhenClosed);
    } finally {
      clearTimeout(timeout);
      await server.close();
    }
  });

  it.each(['GET', 'POST'] as const)(
    'bounds SSE-typed non-2xx %s App error bodies cumulatively',
    async (method) => {
      const errorEvent = 'data: {"error":"temporary"}\n\n';
      const server = await createRawResponseServer((_req, res) => {
        res.writeHead(503, { 'Content-Type': 'text/event-stream' });
        res.write(errorEvent);
        res.write(errorEvent);
        res.end(errorEvent);
      });
      try {
        conn = new MCPConnection({
          serverName: 'app-profile-sse-error-cap',
          serverConfig: { type: 'streamable-http', url: server.url },
          useSSRFProtection: false,
          capabilityProfile: 'apps',
          operationLimits: { maxBytes: 64, timeoutMs: 30_000, maxActive: 16 },
        });
        const response = await getGuardedStreamableHTTPCustomFetch(conn)(server.url, {
          method,
          ...(method === 'POST' && {
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({ jsonrpc: '2.0', method: 'notifications/cancelled' }),
          }),
        });
        await expect(response.text()).rejects.toThrow(
          /MCP response exceeded byte limit.*limit=64 bytes/,
        );
      } finally {
        await server.close();
      }
    },
  );

  it('bounds App-profile HTTP GET error bodies before the SDK reads them', async () => {
    process.env.MCP_STREAMABLE_HTTP_MAX_RESPONSE_BYTES = '0';
    const server = await createRawResponseServer((_req, res) => {
      res.writeHead(503, { 'Content-Type': 'text/plain' });
      res.end('x'.repeat(100));
    });
    try {
      conn = new MCPConnection({
        serverName: 'app-profile-get-error-cap',
        serverConfig: { type: 'streamable-http', url: server.url },
        useSSRFProtection: false,
        capabilityProfile: 'apps',
        operationLimits: { maxBytes: 64, timeoutMs: 30_000, maxActive: 16 },
      });
      const response = await getGuardedStreamableHTTPCustomFetch(conn)(server.url, {
        method: 'GET',
      });
      await expect(response.text()).rejects.toThrow(
        /MCP response exceeded byte limit.*limit=64 bytes/,
      );
    } finally {
      await server.close();
    }
  });

  it('refuses App-profile WebSocket sessions with no pre-parse SDK payload hook', async () => {
    const config = { type: 'websocket' as const, url: 'wss://mcp.example.com/' };
    conn = new MCPConnection({
      serverName: 'app-profile-websocket-denied',
      serverConfig: config,
      useSSRFProtection: false,
      capabilityProfile: 'apps',
    });
    await expect(
      (
        conn as unknown as { constructTransport(options: typeof config): Promise<unknown> }
      ).constructTransport(config),
    ).rejects.toThrow(/pre-parse response size limit/);
  });

  it('passes the App profile byte budget to the real SDK stdio ReadBuffer', async () => {
    const config = { type: 'stdio' as const, command: 'node', args: ['-e', ''] };
    conn = new MCPConnection({
      serverName: 'app-profile-stdio-cap',
      serverConfig: config,
      useSSRFProtection: false,
      capabilityProfile: 'apps',
      operationLimits: { maxBytes: 64, timeoutMs: 30_000, maxActive: 16 },
    });
    const transport = await (
      conn as unknown as {
        constructTransport(options: {
          type: 'stdio';
          command: string;
          args: string[];
        }): Promise<{ _readBuffer: { append(chunk: Buffer): void } }>;
      }
    ).constructTransport(config);
    expect(() => transport._readBuffer.append(Buffer.alloc(65))).toThrow(
      /maximum size of 64 bytes/,
    );
  });

  it('should reject oversized JSON POST responses with the streamable HTTP byte cap', async () => {
    process.env.MCP_STREAMABLE_HTTP_MAX_RESPONSE_BYTES = '8';
    const server = await createRawResponseServer((_req, res) => {
      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.end('{"jsonrpc":"2.0","id":1,"result":{"too":"large"}}');
    });
    try {
      conn = new MCPConnection({
        serverName: 'customfetch-json-byte-limit',
        serverConfig: { type: 'streamable-http', url: server.url },
        useSSRFProtection: false,
      });

      const customFetch = getGuardedStreamableHTTPCustomFetch(conn);
      const response = await customFetch(server.url, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ jsonrpc: '2.0', method: 'ping', id: 1 }),
      });

      await expect(response.text()).rejects.toThrow(
        /MCP response exceeded byte limit.*limit=8 bytes/,
      );
    } finally {
      await server.close();
    }
  });

  /**
   * A `Content-Type` whose parameters mention the SSE type is not an SSE response. Classifying
   * it by substring made the guard hand the caller a synthetic SSE error frame — parsed as a
   * successful response body — instead of throwing, so an oversized body arrived looking well
   * formed.
   */
  it('should not treat a content type that merely mentions the SSE type as an event stream', async () => {
    process.env.MCP_STREAMABLE_HTTP_MAX_RESPONSE_BYTES = '8';
    const server = await createRawResponseServer((_req, res) => {
      res.writeHead(200, { 'Content-Type': 'text/plain; boundary=text/event-stream' });
      res.end('{"jsonrpc":"2.0","id":1,"result":{"too":"large"}}');
    });
    try {
      conn = new MCPConnection({
        serverName: 'customfetch-deceptive-content-type',
        serverConfig: { type: 'streamable-http', url: server.url },
        useSSRFProtection: false,
      });

      const customFetch = getGuardedStreamableHTTPCustomFetch(conn);
      const response = await customFetch(server.url, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ jsonrpc: '2.0', method: 'ping', id: 1 }),
      });

      await expect(response.text()).rejects.toThrow(
        /MCP response exceeded byte limit.*limit=8 bytes/,
      );
    } finally {
      await server.close();
    }
  });

  it('should still guard a genuine event stream whose content type carries parameters', async () => {
    process.env.MCP_STREAMABLE_HTTP_MAX_LINE_BYTES = '16';
    const server = await createRawResponseServer((_req, res) => {
      res.writeHead(200, { 'Content-Type': 'TEXT/EVENT-STREAM; charset=utf-8' });
      res.end(`data: ${'x'.repeat(256)}\n\n`);
    });
    try {
      conn = new MCPConnection({
        serverName: 'customfetch-parameterized-sse',
        serverConfig: { type: 'streamable-http', url: server.url },
        useSSRFProtection: false,
      });

      const customFetch = getGuardedStreamableHTTPCustomFetch(conn);
      const response = await customFetch(server.url, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ jsonrpc: '2.0', method: 'ping', id: 1 }),
      });

      await expect(response.text()).resolves.toContain(
        'MCP response contained an oversized SSE line',
      );
    } finally {
      await server.close();
    }
  });

  it('should reject a POST response with an oversized SSE line before the SSE parser can grow it', async () => {
    process.env.MCP_STREAMABLE_HTTP_MAX_LINE_BYTES = '16';
    const server = await createRawResponseServer((_req, res) => {
      res.writeHead(200, { 'Content-Type': 'text/event-stream' });
      res.end(`data: ${'x'.repeat(64)}\n\n`);
    });
    try {
      conn = new MCPConnection({
        serverName: 'customfetch-sse-line-limit',
        serverConfig: { type: 'streamable-http', url: server.url },
        useSSRFProtection: false,
      });

      const customFetch = getGuardedStreamableHTTPCustomFetch(conn);
      const response = await customFetch(server.url, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ jsonrpc: '2.0', method: 'notifications/cancelled' }),
      });
      await expect(response.text()).rejects.toThrow(
        /MCP response contained an oversized SSE line.*lineLimit=16 bytes.*observedLine=17 bytes/,
      );
    } finally {
      await server.close();
    }
  });

  it('should allow SSE lines above the old 1 MiB default when no line override is set', async () => {
    delete process.env.MCP_STREAMABLE_HTTP_MAX_LINE_BYTES;
    const payload = 'x'.repeat(2 * 1024 * 1024);
    const server = await createRawResponseServer((_req, res) => {
      res.writeHead(200, { 'Content-Type': 'text/event-stream' });
      res.end(`data: ${payload}\n\n`);
    });
    try {
      conn = new MCPConnection({
        serverName: 'customfetch-sse-default-line-limit',
        serverConfig: { type: 'streamable-http', url: server.url },
        useSSRFProtection: false,
      });

      const customFetch = getGuardedStreamableHTTPCustomFetch(conn);
      const response = await customFetch(server.url, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ jsonrpc: '2.0', method: 'notifications/cancelled' }),
      });

      await expect(response.text()).resolves.toContain(payload.slice(0, 128));
    } finally {
      await server.close();
    }
  });

  it('should fail an actual streamable HTTP tool call promptly with a clear oversized SSE line error', async () => {
    process.env.MCP_STREAMABLE_HTTP_MAX_LINE_BYTES = '512';
    target = await createOversizedToolResultStreamableServer(2048);
    conn = new MCPConnection({
      serverName: 'streamable-http-tool-call-sse-line-limit',
      serverConfig: { type: 'streamable-http', url: target.url },
      useSSRFProtection: false,
    });

    await conn.connect();
    const startedAt = Date.now();

    await expect(
      conn.client.callTool({ name: 'oversized', arguments: {} }, undefined, { timeout: 3000 }),
    ).rejects.toThrow(/MCP response contained an oversized SSE line/);
    expect(Date.now() - startedAt).toBeLessThan(1500);
  });

  it('should stream valid SSE POST responses without waiting for EOF', async () => {
    process.env.MCP_STREAMABLE_HTTP_MAX_LINE_BYTES = '4096';
    let finish!: () => void;
    const finished = new Promise<void>((resolve) => {
      finish = resolve;
    });
    const server = await createRawResponseServer((_req, res) => {
      res.writeHead(200, { 'Content-Type': 'text/event-stream' });
      res.write('data: {"jsonrpc":"2.0","id":1,"result":{}}\n\n');
      finished.then(() => res.end()).catch(() => res.end());
    });
    try {
      conn = new MCPConnection({
        serverName: 'customfetch-sse-streaming',
        serverConfig: { type: 'streamable-http', url: server.url },
        useSSRFProtection: false,
      });

      const customFetch = getGuardedStreamableHTTPCustomFetch(conn);
      const response = await customFetch(server.url, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ jsonrpc: '2.0', method: 'ping', id: 1 }),
      });
      const reader = response.body!.getReader();
      const { value, done } = await reader.read();

      expect(done).toBe(false);
      expect(Buffer.from(value as Uint8Array).toString('utf8')).toContain('"result":{}');
      await reader.cancel().catch(() => undefined);
      finish();
    } finally {
      finish();
      await server.close();
    }
  });
});

describe('MCP SSRF protection – WebSocket DNS resolution', () => {
  let conn: MCPConnection | null;

  afterEach(async () => {
    await safeDisconnect(conn);
    conn = null;
    jest.restoreAllMocks();
  });

  it('should block WebSocket to host resolving to private IP when SSRF protection is on', async () => {
    mockedResolveHostnameSSRF.mockResolvedValueOnce(true);

    conn = new MCPConnection({
      serverName: 'ws-ssrf-test',
      serverConfig: { type: 'websocket', url: 'ws://evil.example.com:8080/mcp' },
      useSSRFProtection: true,
    });

    await expect(conn.connect()).rejects.toThrow(/SSRF protection/);
    expect(mockedResolveHostnameSSRF).toHaveBeenCalledWith(
      expect.stringContaining('evil.example.com'),
      null,
      '8080',
    );
  });

  it('should block WebSocket to host resolving to private IP even with SSRF protection off', async () => {
    mockedResolveHostnameSSRF.mockResolvedValueOnce(true);

    conn = new MCPConnection({
      serverName: 'ws-ssrf-allowlist',
      serverConfig: { type: 'websocket', url: 'ws://allowlisted.example.com:8080/mcp' },
      useSSRFProtection: false,
    });

    await expect(conn.connect()).rejects.toThrow(/SSRF protection/);
    expect(mockedResolveHostnameSSRF).toHaveBeenCalledWith(
      expect.stringContaining('allowlisted.example.com'),
      null,
      '8080',
    );
  });

  it('should allow WebSocket to host resolving to public IP', async () => {
    mockedResolveHostnameSSRF.mockResolvedValueOnce(false);

    conn = new MCPConnection({
      serverName: 'ws-public-test',
      serverConfig: { type: 'websocket', url: 'ws://public.example.com:8080/mcp' },
      useSSRFProtection: true,
    });

    /** Fails on connect (no real server), but the error must not be an SSRF rejection. */
    await expect(conn.connect()).rejects.not.toThrow(/SSRF protection/);
  });
});