resume_webhook

Instructions

Implementation Reference

• src/tools.ts:89-95 (handler)

  Handler for resume_webhook: sends a POST request to /api/v1/webhooks/{webhook_id}/resume using the FeedbagelClient, with input schema WebhookIdInput (requires webhook_id string).

    name: "resume_webhook",
    description: "Resume deliveries for a paused webhook subscription.",
    scope: "write",
    inputSchema: WebhookIdInput,
    handler: ({ webhook_id }: any, c) =>
      c.request("POST", `/api/v1/webhooks/${webhook_id}/resume`),
  },

• dist/tools.js:69-74 (handler)

  Compiled handler for resume_webhook (same logic as src/tools.ts).

      name: "resume_webhook",
      description: "Resume deliveries for a paused webhook subscription.",
      scope: "write",
      inputSchema: WebhookIdInput,
      handler: ({ webhook_id }, c) => c.request("POST", `/api/v1/webhooks/${webhook_id}/resume`),
  },

• src/tools.ts:23-25 (schema)

  WebhookIdInput schema: requires a webhook_id string (UUID). Used as the inputSchema for resume_webhook.

  const WebhookIdInput = z.object({
    webhook_id: z.string().describe("Webhook subscriber UUID"),
  });

• src/index.ts:45-86 (registration)

  MCP CallToolRequestSchema handler that looks up tools by name (including resume_webhook) from the TOOLS array, parses input, and invokes the handler.

  server.setRequestHandler(CallToolRequestSchema, async (req) => {
    const tool = TOOLS.find((t) => t.name === req.params.name);
    if (!tool) {
      return {
        isError: true,
        content: [{ type: "text", text: `Unknown tool: ${req.params.name}` }],
      };
    }
    const parsed = tool.inputSchema.safeParse(req.params.arguments ?? {});
    if (!parsed.success) {
      return {
        isError: true,
        content: [
          {
            type: "text",
            text: `Invalid arguments: ${parsed.error.message}`,
          },
        ],
      };
    }
    try {
      const result = await tool.handler(parsed.data, client);
      return {
        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
      };
    } catch (err) {
      const e = err as Error & { status?: number; body?: unknown };
      return {
        isError: true,
        content: [
          {
            type: "text",
            text: JSON.stringify(
              { error: e.message, status: e.status, body: e.body },
              null,
              2,
            ),
          },
        ],
      };
    }
  });

• src/client.ts:13-41 (helper)

  FeedbagelClient class with request() method that performs the actual HTTP call for resume_webhook's handler.

  export class FeedbagelClient {
    private apiKey: string;
    private baseUrl: string;
  
    constructor(opts: ClientOptions) {
      if (!opts.apiKey) throw new Error("FEEDBAGEL_API_KEY is required");
      this.apiKey = opts.apiKey;
      this.baseUrl = (opts.baseUrl ?? DEFAULT_BASE).replace(/\/$/, "");
    }
  
    async request(
      method: string,
      path: string,
      body?: unknown,
    ): Promise<unknown> {
      const res = await fetch(`${this.baseUrl}${path}`, {
        method,
        headers: {
          Authorization: `Bearer ${this.apiKey}`,
          ...(body !== undefined ? { "content-type": "application/json" } : {}),
        },
        body: body !== undefined ? JSON.stringify(body) : undefined,
      });
  
      const text = await res.text();
      let json: unknown = undefined;
      try {
        json = text ? JSON.parse(text) : undefined;
      } catch {