Open MCP Server

Implementation Reference

• src/tools/web-tools.ts:30-56 (handler)

  The core handler function for the 'fetch_url' tool that executes the HTTP request using fetchWithTimeout, processes the response text and headers, and returns formatted content and metadata.

  async ({ url, method, headers, body, timeout, followRedirects }) => {
    return wrapToolExecution(async () => {
      const response = await fetchWithTimeout(url, {
        method,
        headers,
        body,
        timeout,
        followRedirects
      });
  
      const responseText = await response.text();
      const responseHeaders = extractHeaders(response);
  
      return {
        content: [{ type: "text" as const, text: responseText }],
        metadata: {
          status: response.status,
          statusText: response.statusText,
          headers: responseHeaders,
          url: response.url
        }
      };
    }, {
      errorCode: ERROR_CODES.HTTP_REQUEST,
      context: "Failed to fetch URL"
    });
  }

• src/tools/web-tools.ts:22-28 (schema)

  Zod schema for input validation of the 'fetch_url' tool parameters: url (required), method, headers, body, timeout, followRedirects.

  {
    url: z.string().url("Valid URL is required"),
    method: z.enum(["GET", "POST", "PUT", "DELETE", "PATCH"]).optional().default(DEFAULTS.HTTP_METHOD),
    headers: z.record(z.string()).optional().default({}),
    body: z.string().optional(),
    timeout: z.number().optional().default(DEFAULT_TIMEOUTS.HTTP_REQUEST),
    followRedirects: z.boolean().optional().default(DEFAULTS.HTTP_FOLLOW_REDIRECTS)

• src/tools/web-tools.ts:20-58 (registration)

  The registerFetchUrl function that directly registers the 'fetch_url' tool on the MCP server using server.tool(), including schema and handler.

  function registerFetchUrl(server: McpServer): void {
    server.tool("fetch_url",
      {
        url: z.string().url("Valid URL is required"),
        method: z.enum(["GET", "POST", "PUT", "DELETE", "PATCH"]).optional().default(DEFAULTS.HTTP_METHOD),
        headers: z.record(z.string()).optional().default({}),
        body: z.string().optional(),
        timeout: z.number().optional().default(DEFAULT_TIMEOUTS.HTTP_REQUEST),
        followRedirects: z.boolean().optional().default(DEFAULTS.HTTP_FOLLOW_REDIRECTS)
      },
      async ({ url, method, headers, body, timeout, followRedirects }) => {
        return wrapToolExecution(async () => {
          const response = await fetchWithTimeout(url, {
            method,
            headers,
            body,
            timeout,
            followRedirects
          });
  
          const responseText = await response.text();
          const responseHeaders = extractHeaders(response);
  
          return {
            content: [{ type: "text" as const, text: responseText }],
            metadata: {
              status: response.status,
              statusText: response.statusText,
              headers: responseHeaders,
              url: response.url
            }
          };
        }, {
          errorCode: ERROR_CODES.HTTP_REQUEST,
          context: "Failed to fetch URL"
        });
      }
    );
  }

• src/index.ts:66-66 (registration)

  Invocation of registerWebTools(server) in the main server initialization, which calls registerFetchUrl to register the tool.

  registerWebTools(server);

• src/tools/web-tools.ts:63-98 (helper)

  Key helper function fetchWithTimeout used by the handler to perform HTTP fetches with configurable timeout, method, headers, body, and redirect handling using AbortController.

  async function fetchWithTimeout(
    url: string,
    options: {
      method: HttpMethod;
      headers?: Record<string, string>;
      body?: string;
      timeout: number;
      followRedirects: boolean;
    }
  ): Promise<Response> {
    const { method, headers, body, timeout, followRedirects } = options;
    const controller = new AbortController();
    const timeoutId = setTimeout(() => controller.abort(), timeout);
  
    const requestInit: RequestInit = {
      method,
      headers,
      signal: controller.signal,
      redirect: followRedirects ? "follow" : "manual"
    };
  
    if (body && ["POST", "PUT", "PATCH"].includes(method)) {
      requestInit.body = body;
    }
  
    try {
      const response = await fetch(url, requestInit);
      return response;
    } catch (error) {
      if (error instanceof Error && error.name === 'AbortError') {
        throw new Error(`Request timeout after ${timeout}ms`);
      }
      throw error;
    } finally {
      clearTimeout(timeoutId);
    }