MCP NPX Fetch

Instructions

Implementation Reference

• src/Fetcher.ts:45-58 (handler)

  The static method `Fetcher.json` that executes the core logic of the `fetch_json` tool: fetches the JSON from the provided URL, parses it, stringifies it, and returns it in the expected MCP response format.

  static async json(requestPayload: RequestPayload) {
    try {
      const response = await this._fetch(requestPayload);
      const json = await response.json();
      return {
        content: [{ type: "text", text: JSON.stringify(json) }],
        isError: false,
      };
    } catch (error) {
      return {
        content: [{ type: "text", text: (error as Error).message }],
        isError: true,
      };
    }

• src/index.ts:105-122 (registration)

  Registers the `fetch_json` tool in the `ListToolsRequestHandler` with its name, description, and input schema.

  {
    name: "fetch_json",
    description: "Fetch a JSON file from a URL",
    inputSchema: {
      type: "object",
      properties: {
        url: {
          type: "string",
          description: "URL of the JSON to fetch",
        },
        headers: {
          type: "object",
          description: "Optional headers to include in the request",
        },
      },
      required: ["url"],
    },
  },

• src/index.ts:136-138 (handler)

  Dispatches the `CallToolRequest` for `fetch_json` by calling `Fetcher.json` after validation.

  if (request.params.name === "fetch_json") {
    const fetchResult = await Fetcher.json(validatedArgs);
    return fetchResult;

• src/types.ts:1-8 (schema)

  Shared Zod schema `RequestPayloadSchema` used to validate the input arguments for the `fetch_json` tool (and others) in the `CallToolRequestHandler`.

  import { z } from "zod";
  
  export const RequestPayloadSchema = z.object({
    url: z.string().url(),
    headers: z.record(z.string()).optional(),
  });
  
  export type RequestPayload = z.infer<typeof RequestPayloadSchema>;

• src/Fetcher.ts:6-29 (helper)

  Private helper method `_fetch` used by `Fetcher.json` (and other methods) to perform the actual HTTP fetch with error handling and default User-Agent.

  private static async _fetch({
    url,
    headers,
  }: RequestPayload): Promise<Response> {
    try {
      const response = await fetch(url, {
        headers: {
          "User-Agent":
            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
          ...headers,
        },
      });
  
      if (!response.ok) {
        throw new Error(`HTTP error: ${response.status}`);
      }
      return response;
    } catch (e: unknown) {
      if (e instanceof Error) {
        throw new Error(`Failed to fetch ${url}: ${e.message}`);
      } else {
        throw new Error(`Failed to fetch ${url}: Unknown error`);
      }
    }