@webhooks-cc/mcp 1.13.0 → 1.15.0

package/dist/tools.js

@@ -0,0 +1,1827 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/tools.ts
+var tools_exports = {};
+__export(tools_exports, {
+  REMOTE_MAX_WAIT_MS: () => REMOTE_MAX_WAIT_MS,
+  REMOTE_MIN_POLL_MS: () => REMOTE_MIN_POLL_MS,
+  createEndpointShape: () => createEndpointShape,
+  deleteEndpointShape: () => deleteEndpointShape,
+  getEndpointShape: () => getEndpointShape,
+  getRequestShape: () => getRequestShape,
+  jsonContent: () => jsonContent,
+  listEndpointsShape: () => listEndpointsShape,
+  listRequestsShape: () => listRequestsShape,
+  payloadSchemaResult: () => payloadSchemaResult,
+  payloadSchemaShape: () => payloadSchemaShape,
+  registerTools: () => registerTools,
+  textContent: () => textContent,
+  waitForRequestShape: () => waitForRequestShape,
+  withErrorHandling: () => withErrorHandling
+});
+module.exports = __toCommonJS(tools_exports);
+var import_zod = require("zod");
+var import_sdk = require("@webhooks-cc/sdk");
+
+// src/compact.ts
+var MAX_OUTPUT = 32768;
+var MAX_EMAIL_TEXT = 8e3;
+var MAX_EXTRACTS = 10;
+var MAX_LINK_TEXT = 200;
+var MAX_LINK_URL = 2e3;
+var MAX_LIST_ITEMS = 5;
+var EMAIL_LISTS = ["from", "to", "cc", "replyTo", "sender", "inReplyTo", "attachments"];
+var TEXT_FLOOR = 2e3;
+function jsonSize(value) {
+  return JSON.stringify(value, null, 2).length;
+}
+function sliceText(text, end) {
+  if (end <= 0) return "";
+  if (end >= text.length) return text;
+  const last = text.charCodeAt(end - 1);
+  return text.slice(0, last >= 55296 && last <= 56319 ? end - 1 : end);
+}
+function cutEmailText(text) {
+  if (text === null || text.length <= MAX_EMAIL_TEXT) return { text, cut: false };
+  return { text: sliceText(text, MAX_EMAIL_TEXT), cut: true };
+}
+function shrinkToFit(root, budget, steps) {
+  for (const step of steps) {
+    if (jsonSize(root) <= budget) return;
+    step();
+  }
+}
+function omitHeaders(holder) {
+  const headers = holder.headers;
+  if (headers === null || typeof headers !== "object") return;
+  const count = Object.keys(headers).length;
+  if (count === 0) return;
+  holder.headers = {};
+  holder.headersOmitted = `${count} headers left out to fit the output`;
+}
+function trimSpam(holder) {
+  const spam = holder.spam;
+  if (spam && typeof spam === "object" && !Array.isArray(spam)) {
+    const { score, required, action, error } = spam;
+    holder.spam = { score, required, action, error };
+  }
+}
+function capExtracts(holder) {
+  if (Array.isArray(holder.codes) && holder.codes.length > MAX_EXTRACTS) {
+    holder.codes = holder.codes.slice(0, MAX_EXTRACTS);
+    holder.codesTruncated = true;
+  }
+  if (Array.isArray(holder.links)) {
+    if (holder.links.length > MAX_EXTRACTS) {
+      holder.links = holder.links.slice(0, MAX_EXTRACTS);
+      holder.linksTruncated = true;
+    }
+    holder.links = holder.links.map((link) => ({
+      ...link,
+      ...typeof link.url === "string" ? { url: sliceText(link.url, MAX_LINK_URL) } : {},
+      ...typeof link.text === "string" ? { text: sliceText(link.text, MAX_LINK_TEXT) } : {}
+    }));
+  }
+}
+function capLists(holder) {
+  for (const key of EMAIL_LISTS) {
+    const list = holder[key];
+    if (Array.isArray(list) && list.length > MAX_LIST_ITEMS) {
+      holder[key] = list.slice(0, MAX_LIST_ITEMS);
+      holder[`${key}Total`] = list.length;
+    }
+  }
+}
+function keepOnly(holder, keep) {
+  for (const key of Object.keys(holder)) {
+    if (!keep.includes(key)) delete holder[key];
+  }
+  holder.trimmed = "The email was too big for the output, so only these fields are shown.";
+}
+function cutStringToFit(root, holder, key, flag, budget, floor = 0) {
+  const value = holder[key];
+  if (typeof value !== "string" || value.length <= floor) return;
+  const flagged = holder[flag] === true;
+  holder[key] = "";
+  holder[flag] = true;
+  const room = budget - jsonSize(root) + 2;
+  let low = 0;
+  let high = value.length;
+  while (low < high) {
+    const mid = Math.ceil((low + high) / 2);
+    if (JSON.stringify(sliceText(value, mid)).length <= room) low = mid;
+    else high = mid - 1;
+  }
+  const kept = sliceText(value, Math.max(low, floor));
+  holder[key] = kept;
+  if (kept.length === value.length && !flagged) delete holder[flag];
+}
+function keepFirst(holder, key) {
+  const list = holder[key];
+  if (!Array.isArray(list) || list.length <= 1) return;
+  holder[`${key}Total`] = holder[`${key}Total`] ?? list.length;
+  holder[key] = list.slice(0, 1);
+}
+var ESSENTIAL_EMAIL_FIELDS = [
+  "subject",
+  "from",
+  "fromTotal",
+  "tag",
+  "date",
+  "text",
+  "textTruncated",
+  "htmlSize",
+  "spam"
+];
+function compactRequest(request) {
+  if (request.kind !== "email") return request;
+  const compact = { ...request };
+  delete compact.body;
+  delete compact.bodyRaw;
+  compact.rawMessageOmitted = "The raw message and the HTML part are left out; size is the message size in bytes. get_email returns the HTML.";
+  if (!request.email) return compact;
+  const { html, ...rest } = request.email;
+  const { text, cut } = cutEmailText(rest.text);
+  const restoreText = () => {
+    email.text = text;
+    if (cut) email.textTruncated = true;
+    else delete email.textTruncated;
+  };
+  const email = {
+    ...rest,
+    text,
+    ...cut ? { textTruncated: true } : {},
+    htmlSize: html?.length ?? 0
+  };
+  compact.email = email;
+  const root = { items: [compact], truncated: true, total: 1e3, returned: 1e3 };
+  const budget = MAX_OUTPUT - 128;
+  shrinkToFit(root, budget, [
+    () => omitHeaders(compact),
+    () => trimSpam(email),
+    () => capLists(email),
+    () => cutStringToFit(root, email, "text", "textTruncated", budget, TEXT_FLOOR),
+    // Down to the essentials there may be room for more of the text again.
+    () => {
+      keepOnly(email, ESSENTIAL_EMAIL_FIELDS);
+      keepFirst(email, "from");
+      restoreText();
+      cutStringToFit(root, email, "text", "textTruncated", budget);
+    },
+    () => cutStringToFit(root, email, "subject", "subjectTruncated", budget)
+  ]);
+  return compact;
+}
+
+// src/tools.ts
+var MAX_BODY_SIZE = MAX_OUTPUT;
+var HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
+var TIME_SEPARATOR = " \u2014 ";
+var httpUrlSchema = import_zod.z.string().url().refine(
+  (value) => {
+    try {
+      const protocol = new URL(value).protocol;
+      return protocol === "http:" || protocol === "https:";
+    } catch {
+      return false;
+    }
+  },
+  { message: "Only http and https URLs are supported" }
+);
+var methodSchema = import_zod.z.enum(HTTP_METHODS).default("POST").describe("HTTP method (default: POST)");
+var kindSchema = import_zod.z.enum(["http", "email"]).optional().describe('Only HTTP requests ("http") or only captured emails ("email")');
+var EMAIL_SCAN_LIMIT = 100;
+var durationOrTimestampSchema = import_zod.z.union([import_zod.z.string(), import_zod.z.number()]);
+var CONDITION_FIELD_NAMES = Object.keys(import_sdk.CONDITION_FIELDS);
+var CONDITION_OP_NAMES = import_sdk.CONDITION_OPS;
+function conditionSchema(use) {
+  const fields = use === "response" ? CONDITION_FIELD_NAMES.filter((field) => import_sdk.CONDITION_FIELDS[field].response) : CONDITION_FIELD_NAMES;
+  return import_zod.z.object({
+    field: import_zod.z.enum(fields).describe(
+      use === "response" ? "What to read: method, path, header (name), query (name), body (text), body_path (path into a JSON or form body), content_type, size" : "What to read: method, path, header (name), query (name), body, body_path (path), content_type, size, kind (http or email), email (name: subject, from, to, text or tag), spam_score, email_auth (name: spf, dkim or dmarc), signature (verified, failed or missing)"
+    ),
+    op: import_zod.z.enum(CONDITION_OP_NAMES).describe(
+      "eq, neq, contains, not_contains, starts_with, ends_with, matches (glob: * one path segment, ** any, ? one character), regex (RE2, searched anywhere; (?i) ignores case), exists, not_exists, gt, gte, lt, lte (numbers)"
+    ),
+    value: import_zod.z.string().max(import_sdk.MAX_CONDITION_VALUE_LEN).optional().describe(`What to compare with (not for exists and not_exists)`),
+    name: import_zod.z.string().max(import_sdk.MAX_CONDITION_NAME_LEN).optional().describe("Header or query parameter name; the email part; spf, dkim or dmarc"),
+    path: import_zod.z.string().max(import_sdk.MAX_CONDITION_PATH_LEN).optional().describe('Dot path for body_path, e.g. data.object.status or items.0.sku or a["odd.key"]')
+  }).superRefine((condition, ctx) => {
+    for (const issue of (0, import_sdk.conditionIssues)(condition, { use })) {
+      ctx.addIssue({ code: "custom", message: issue });
+    }
+  });
+}
+var ruleConditionSchema = conditionSchema("response");
+var destinationFields = {
+  name: import_zod.z.string().max(100).nullable().optional().describe("A name for the list and the log"),
+  enabled: import_zod.z.boolean().optional().describe("Send to it (default true)"),
+  http: import_zod.z.boolean().optional().describe("Takes HTTP requests (default true)"),
+  email: import_zod.z.boolean().optional().describe("Takes emails (default true)"),
+  filter: import_zod.z.object({
+    logic: import_zod.z.enum(["and", "or"]).optional().describe("and (default): every condition; or: any"),
+    conditions: import_zod.z.array(conditionSchema("filter")).max(10)
+  }).nullable().optional().describe(
+    "Send only captures that match (null: everything it takes). Conditions like response rules plus kind, email (name: subject, from, to, text, tag), spam_score, email_auth (name: spf, dkim, dmarc) and signature (verified, failed, missing)"
+  ),
+  format: import_zod.z.enum([
+    "auto",
+    "as_received",
+    "json",
+    "template",
+    "chat",
+    "postmark",
+    "sendgrid",
+    "mailgun",
+    "cloudmailin"
+  ]).optional().describe(
+    "auto (pick from the URL), as_received (relay HTTP requests unchanged; emails as signed JSON), json (signed JSON envelope), template (your bodyTemplate, signed like json), chat (Slack or Discord message), or an inbound mail provider's shape for emails (postmark, sendgrid, mailgun, cloudmailin; HTTP requests then go as received), to test the inbound handler you wrote for that provider"
+  ),
+  mailgunSigningKey: import_zod.z.string().max(200).nullable().optional().describe(
+    "For format mailgun: your Mailgun HTTP webhook signing key, so the form's signature verifies; null removes it. Write-only."
+  ),
+  bodyTemplate: import_zod.z.unknown().optional().describe(
+    `For format template: any JSON value whose strings hold {{ placeholders }}, e.g. {"event": "{{ json.type }}", "amount": "{{ json.data.amount }}", "code": "{{ codes.0 }}"}. A string that is only a placeholder keeps the value's type; a missing field becomes null. HTTP requests read method, path, query.x, headers.x, body, json.path, id, receivedAt, signature; emails read the email.received fields (subject, from.address, to, text, codes, links, auth, spam, tag)`
+  ),
+  messageTemplate: import_zod.z.string().max(4e3).nullable().optional().describe(
+    "For format chat: the message text with {{ placeholders }}; null sends the standard message"
+  ),
+  headers: import_zod.z.array(
+    import_zod.z.object({
+      name: import_zod.z.string().describe("Header name, e.g. Authorization"),
+      value: import_zod.z.string().nullable().describe("Value, or null to keep the stored one")
+    })
+  ).max(10).optional().describe("Your own headers for every delivery (not chat). Replaces the whole list"),
+  appendPath: import_zod.z.boolean().optional().describe("Append the captured path to the URL (as_received)"),
+  retrySeconds: import_zod.z.union([import_zod.z.literal(0), import_zod.z.literal(3600), import_zod.z.literal(86400)]).optional().describe("Retry failed deliveries for 86400 (default), 3600 or 0 seconds"),
+  keepOrder: import_zod.z.boolean().optional().describe("One delivery at a time, in capture order"),
+  sentField: import_zod.z.string().max(128).nullable().optional().describe("JSON body field with the sender's own timestamp"),
+  throttleSeconds: import_zod.z.number().int().min(0).max(3600).optional().describe(
+    "At most one delivery every N seconds; the rest are not sent (1 makes a heads-up channel)"
+  ),
+  delaySeconds: import_zod.z.number().int().min(0).max(3600).optional().describe("Wait this long after the capture before sending, like a callback")
+};
+var responseRuleSchema = import_zod.z.object({
+  name: import_zod.z.string().max(import_sdk.MAX_RULE_NAME_LEN).optional().describe(`Human-readable rule name (max ${import_sdk.MAX_RULE_NAME_LEN} chars)`),
+  enabled: import_zod.z.boolean().optional().default(true).describe("Whether this rule is active"),
+  logic: import_zod.z.enum(["and", "or"]).optional().default("and").describe('How to combine conditions: "and" (all match) or "or" (any match)'),
+  conditions: import_zod.z.array(ruleConditionSchema).min(1).max(10).describe("Conditions to evaluate (1-10)"),
+  response: import_zod.z.lazy(() => mockResponseSchema).describe("Response when conditions match")
+});
+var responseRulesSchema = import_zod.z.array(responseRuleSchema).max(50).describe("Ordered conditional response rules (first match wins, max 50)");
+var mockResponseSchema = import_zod.z.object({
+  status: import_zod.z.number().int().min(import_sdk.MOCK_RESPONSE_STATUS_MIN).max(import_sdk.MOCK_RESPONSE_STATUS_MAX).describe(`HTTP status code (${import_sdk.MOCK_RESPONSE_STATUS_MIN}-${import_sdk.MOCK_RESPONSE_STATUS_MAX})`),
+  body: import_zod.z.string().default("").describe(
+    'Response body (default: empty). {{ placeholders }} are filled in from the request: {{ json.id }} (a JSON or form body field), {{ body }}, {{ headers.user-agent }}, {{ query.page }}, {{ method }}, {{ path }}, {{ id }}, {{ uuid }}, {{ now }}; filters: | default: "x", | json, | lower, | upper, | truncate: 80'
+  ),
+  headers: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).default({}).describe("Response headers (default: none); values may use {{ placeholders }} too"),
+  delay: import_zod.z.number().int().min(import_sdk.MOCK_RESPONSE_DELAY_MIN).max(import_sdk.MOCK_RESPONSE_DELAY_MAX).optional().describe(
+    `Response delay in milliseconds (${import_sdk.MOCK_RESPONSE_DELAY_MIN}-${import_sdk.MOCK_RESPONSE_DELAY_MAX}, default: none)`
+  )
+});
+var createEndpointShape = {
+  name: import_zod.z.string().optional().describe("Display name for the endpoint"),
+  ephemeral: import_zod.z.boolean().optional().describe("Create a temporary endpoint that auto-expires"),
+  expiresIn: durationOrTimestampSchema.optional().describe('Auto-expire after this duration, for example "12h"'),
+  mockResponse: mockResponseSchema.optional().describe("Optional mock response to return when the endpoint receives a request"),
+  responseRules: responseRulesSchema.optional().describe(
+    "Conditional response rules. Each rule has conditions and a response. First matching rule wins."
+  ),
+  notificationUrl: import_zod.z.string().url().optional().describe(
+    "URL to POST a JSON summary to after each captured request (e.g. Slack/Discord webhook)"
+  ),
+  signingProvider: import_zod.z.string().optional().describe(
+    "Signing provider for automatic signature verification (e.g. stripe, github, shopify)"
+  ),
+  signingSecret: import_zod.z.string().optional().describe(
+    "Signing secret (encrypted server-side, never returned). Required when signingProvider is set."
+  ),
+  signingHeader: import_zod.z.string().optional().describe("Custom signature header name. Only used with generic-hmac provider.")
+};
+var listEndpointsShape = {
+  team: import_zod.z.string().min(1).optional().describe(
+    "Team id or name (case-insensitive). Keeps endpoints shared with you from that team and endpoints you own that are shared with it."
+  )
+};
+var getEndpointShape = { slug: import_zod.z.string().describe("The endpoint slug") };
+var deleteEndpointShape = { slug: import_zod.z.string().describe("The endpoint slug to delete") };
+var listRequestsShape = {
+  endpointSlug: import_zod.z.string().describe("The endpoint slug"),
+  limit: import_zod.z.number().int().min(1).max(100).default(25).describe("Max requests to return"),
+  since: import_zod.z.number().optional().describe("Only return requests after this timestamp in ms"),
+  kind: kindSchema
+};
+var getRequestShape = { requestId: import_zod.z.string().describe("The request ID") };
+var waitForRequestShape = {
+  endpointSlug: import_zod.z.string().describe("The endpoint slug to monitor"),
+  timeout: durationOrTimestampSchema.default("30s").describe('How long to wait, for example "30s"'),
+  pollInterval: durationOrTimestampSchema.optional().describe('Interval between polls, for example "500ms" or "1s"')
+};
+var payloadSchemaShape = {
+  endpointSlug: import_zod.z.string().describe("The endpoint slug"),
+  format: import_zod.z.enum(import_sdk.PAYLOAD_SCHEMA_FORMATS).default("typescript").describe(
+    'Output: "typescript" interfaces, "zod" schemas, "pydantic" models, or "json-schema"'
+  ),
+  name: import_zod.z.string().max(100).optional().describe("Root type name (default: from the detected event, else WebhookPayload)"),
+  event: import_zod.z.string().optional().describe(
+    'Only requests whose detected provider event matches, e.g. "invoice.paid" or "push". One event per schema gives the tightest types.'
+  ),
+  method: import_zod.z.string().optional().describe("Only requests with this HTTP method"),
+  path: import_zod.z.string().optional().describe("Only requests with this path"),
+  requestIds: import_zod.z.array(import_zod.z.string()).min(1).max(50).optional().describe("Use exactly these requests instead of the latest ones"),
+  limit: import_zod.z.number().int().min(1).max(100).default(20).describe("How many of the latest requests to read before filtering")
+};
+function eventName(event) {
+  const words = event.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[^A-Za-z0-9]+/).filter(Boolean);
+  const name = words.map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+  if (!name) return "WebhookPayload";
+  return /^[0-9]/.test(name) ? `Webhook${name}Event` : `${name}Event`;
+}
+function payloadSchemaResult(requests, args) {
+  const method = args.method?.toUpperCase();
+  const matching = requests.filter(
+    (request) => request.kind !== "email" && (!method || request.method.toUpperCase() === method) && (!args.path || request.path === args.path) && (!args.event || (0, import_sdk.detectWebhookInfo)(request)?.event === args.event)
+  );
+  if (matching.length === 0) {
+    throw new Error(
+      `None of the ${requests.length} requests read matched. Capture a request first, or loosen event, method or path.`
+    );
+  }
+  const events = [
+    ...new Set(
+      matching.map((request) => (0, import_sdk.detectWebhookInfo)(request)?.event).filter((e) => !!e)
+    )
+  ];
+  const name = args.name ?? (events.length === 1 ? eventName(events[0]) : void 0);
+  const result = (0, import_sdk.generateRequestSchema)(matching, { format: args.format, name });
+  if (result.samples === 0) {
+    throw new Error(
+      `None of the ${matching.length} matching requests has a JSON or form body to learn from.`
+    );
+  }
+  const output = {
+    format: result.format,
+    name: result.name,
+    samples: result.samples,
+    skipped: result.skipped,
+    ...events.length > 0 ? { events } : {},
+    ...events.length > 1 ? {
+      warning: `The samples mix ${events.length} events, so fields of one event show up as optional. Pass event for one schema per event.`
+    } : {},
+    code: result.code
+  };
+  const size = JSON.stringify(output, null, 2).length;
+  if (size > MAX_OUTPUT) {
+    throw new Error(
+      `The schema is ${result.code.length} characters, more than this tool can return. Narrow it with event or requestIds, or call generateRequestSchema() from @webhooks-cc/sdk in code.`
+    );
+  }
+  return jsonContent(output);
+}
+function textContent(text) {
+  return { content: [{ type: "text", text }] };
+}
+function serializeJson(value, limit = MAX_BODY_SIZE) {
+  const full = JSON.stringify(value, null, 2);
+  if (full.length <= limit) {
+    return full;
+  }
+  if (Array.isArray(value)) {
+    let low = 0;
+    let high = value.length;
+    let best = JSON.stringify(
+      { items: [], truncated: true, total: value.length, returned: 0 },
+      null,
+      2
+    );
+    while (low <= high) {
+      const mid = Math.floor((low + high) / 2);
+      const candidate = JSON.stringify(
+        {
+          items: value.slice(0, mid),
+          truncated: true,
+          total: value.length,
+          returned: mid
+        },
+        null,
+        2
+      );
+      if (candidate.length <= limit) {
+        best = candidate;
+        low = mid + 1;
+      } else {
+        high = mid - 1;
+      }
+    }
+    return best;
+  }
+  return full.slice(0, limit) + `
+... [truncated, ${full.length} chars total]`;
+}
+function fitArrayField(value, key) {
+  const items = value[key];
+  if (!Array.isArray(items) || jsonSize(value) <= MAX_BODY_SIZE) return value;
+  const cut = (count) => ({
+    ...value,
+    [key]: items.slice(0, count),
+    truncated: true,
+    returned: count
+  });
+  let low = 0;
+  let high = items.length;
+  while (low < high) {
+    const mid = Math.ceil((low + high) / 2);
+    if (jsonSize(cut(mid)) <= MAX_BODY_SIZE) low = mid;
+    else high = mid - 1;
+  }
+  return cut(low);
+}
+function jsonContent(value) {
+  return textContent(serializeJson(value));
+}
+async function readBodyTruncated(response, limit = MAX_BODY_SIZE) {
+  const text = await response.text();
+  if (text.length <= limit) return text;
+  return text.slice(0, limit) + `
+... [truncated, ${text.length} chars total]`;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function splitHint(message) {
+  const separatorIndex = message.indexOf(TIME_SEPARATOR);
+  if (separatorIndex === -1) {
+    return { message, hint: null };
+  }
+  return {
+    message: message.slice(0, separatorIndex),
+    hint: message.slice(separatorIndex + TIME_SEPARATOR.length) || null
+  };
+}
+function serializeError(error) {
+  const rawMessage = error instanceof Error ? error.message : String(error);
+  const { message, hint } = splitHint(rawMessage);
+  const payload = {
+    error: true,
+    code: "validation_error",
+    message,
+    hint,
+    retryAfter: null
+  };
+  if (error instanceof import_sdk.UnauthorizedError) {
+    payload.code = "unauthorized";
+  } else if (error instanceof import_sdk.NotFoundError) {
+    payload.code = "not_found";
+  } else if (error instanceof import_sdk.RateLimitError) {
+    payload.code = "rate_limited";
+    payload.retryAfter = error.retryAfter ?? null;
+  } else if (error instanceof import_sdk.TimeoutError) {
+    payload.code = "timeout";
+  } else if (error instanceof import_sdk.WebhooksCCError) {
+    payload.code = error.statusCode >= 500 ? "server_error" : "validation_error";
+  }
+  return JSON.stringify(payload, null, 2);
+}
+function withErrorHandling(handler) {
+  return async (args) => {
+    try {
+      return await handler(args);
+    } catch (error) {
+      return { ...textContent(serializeError(error)), isError: true };
+    }
+  };
+}
+function filterRequestsByMethod(requests, method) {
+  if (!method) {
+    return requests;
+  }
+  const target = method.toUpperCase();
+  return requests.filter((request) => request.method.toUpperCase() === target);
+}
+async function waitForMultipleRequests(client, endpointSlug, options) {
+  const timeoutMs = typeof options.timeout === "number" ? options.timeout : options.timeout ? Number.isNaN(Number(options.timeout)) ? parseDurationLike(options.timeout) : Number(options.timeout) : 3e4;
+  const pollIntervalMs = typeof options.pollInterval === "number" ? options.pollInterval : options.pollInterval ? Number.isNaN(Number(options.pollInterval)) ? parseDurationLike(options.pollInterval) : Number(options.pollInterval) : 500;
+  const startedAt = Date.now();
+  let since = startedAt;
+  const seenIds = /* @__PURE__ */ new Set();
+  const requests = [];
+  while (Date.now() - startedAt < timeoutMs) {
+    const checkTime = Date.now();
+    const page = await client.requests.list(endpointSlug, {
+      since,
+      limit: Math.max(100, options.count * 5)
+    });
+    since = checkTime;
+    const filtered = filterRequestsByMethod(page, options.method).slice().sort((left, right) => left.receivedAt - right.receivedAt);
+    for (const request of filtered) {
+      if (seenIds.has(request.id)) {
+        continue;
+      }
+      seenIds.add(request.id);
+      requests.push(request);
+      if (requests.length >= options.count) {
+        return {
+          requests,
+          complete: true,
+          timedOut: false,
+          expectedCount: options.count
+        };
+      }
+    }
+    await sleep(
+      Math.min(Math.max(10, pollIntervalMs), Math.max(0, timeoutMs - (Date.now() - startedAt)))
+    );
+  }
+  return {
+    requests,
+    complete: requests.length >= options.count,
+    timedOut: true,
+    expectedCount: options.count
+  };
+}
+function parseDurationLike(value) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    throw new Error("Duration value cannot be empty");
+  }
+  const numeric = Number(trimmed);
+  if (!Number.isNaN(numeric)) {
+    return numeric;
+  }
+  const match = trimmed.match(/^(\d+)\s*(ms|s|m|h|d)$/i);
+  if (!match) {
+    throw new Error(`Invalid duration: "${value}"`);
+  }
+  const amount = Number(match[1]);
+  const unit = match[2].toLowerCase();
+  const multiplier = unit === "ms" ? 1 : unit === "s" ? 1e3 : unit === "m" ? 6e4 : unit === "h" ? 36e5 : 864e5;
+  return amount * multiplier;
+}
+function ensureVerifyArgs(args) {
+  if (args.provider === "discord") {
+    const publicKey = args.publicKey?.trim();
+    if (!publicKey) {
+      throw new Error('verify_signature for provider "discord" requires publicKey');
+    }
+    return {
+      provider: "discord",
+      publicKey
+    };
+  }
+  const secret = args.secret?.trim();
+  if (!secret) {
+    throw new Error(`verify_signature for provider "${args.provider}" requires secret`);
+  }
+  return {
+    provider: args.provider,
+    secret,
+    ...args.url ? { url: args.url } : {},
+    ...args.method ? { method: args.method } : {}
+  };
+}
+async function summarizeResponse(response) {
+  return {
+    status: response.status,
+    statusText: response.statusText,
+    body: await readBodyTruncated(response)
+  };
+}
+async function emailEndpointView(client, slug) {
+  const endpoint = await client.endpoints.get(slug);
+  return {
+    endpoint: { slug: endpoint.slug, name: endpoint.name ?? null },
+    includeExtracts: endpoint.showEmailExtracts !== false
+  };
+}
+function emailSlugFromAddress(address) {
+  const local = address.slice(0, Math.max(0, address.lastIndexOf("@")));
+  return local.split("+")[0].toLowerCase();
+}
+var MAX_SUMMARY_LINK = 8e3;
+function boundedLink(link, max) {
+  if (link == null || link.length <= max) return { link: link ?? null };
+  return {
+    link: null,
+    linkOmitted: `The main link is ${link.length} characters long, too long for the output`
+  };
+}
+var MAX_SUMMARY_FIELD = 1e3;
+function summarizeEmail(email, includeExtracts) {
+  const from = email.email.from[0];
+  const sender = from ? from.name ? `${from.name} <${from.address ?? ""}>` : from.address : null;
+  const subject = email.email.subject;
+  return {
+    id: email.id,
+    receivedAt: new Date(email.receivedAt).toISOString(),
+    address: email.path,
+    tag: email.email.tag,
+    subject: subject === null ? null : sliceText(subject, MAX_SUMMARY_FIELD),
+    from: sender == null ? null : sliceText(sender, MAX_SUMMARY_FIELD),
+    ...includeExtracts ? { code: (0, import_sdk.extractCode)(email), ...boundedLink((0, import_sdk.extractLink)(email), MAX_SUMMARY_LINK) } : {},
+    attachments: email.email.attachments.length
+  };
+}
+var ESSENTIAL_DETAIL_FIELDS = [
+  "code",
+  "link",
+  "id",
+  "endpoint",
+  "receivedAt",
+  "address",
+  "tag",
+  "subject",
+  "from",
+  "fields",
+  "replyText",
+  "size",
+  "test",
+  "spam",
+  "text",
+  "textTruncated",
+  "htmlSize",
+  "html",
+  "htmlTruncated"
+];
+function shrinkRendered(rendered, max) {
+  const body = typeof rendered.body === "string" ? rendered.body : "";
+  if (body.length <= max - 1024) return rendered;
+  return { ...rendered, body: body.slice(0, max - 1024), bodyTruncated: true };
+}
+function emailDetail(client, email, view, includeHtml) {
+  const { data } = client.emails.toJson(email, {
+    endpoint: view.endpoint,
+    includeExtracts: view.includeExtracts
+  });
+  const { html, text: fullText, ...rest } = data;
+  const { text, cut } = cutEmailText(fullText ?? null);
+  const restoreText = () => {
+    detail.text = text;
+    if (cut) detail.textTruncated = true;
+    else delete detail.textTruncated;
+  };
+  const detail = {
+    ...view.includeExtracts ? { code: (0, import_sdk.extractCode)(email), link: (0, import_sdk.extractLink)(email) } : {},
+    ...rest,
+    text,
+    ...cut ? { textTruncated: true } : {},
+    htmlSize: html?.length ?? 0,
+    ...includeHtml && html !== null ? { html } : {}
+  };
+  shrinkToFit(detail, MAX_BODY_SIZE, [
+    () => omitHeaders(detail),
+    () => trimSpam(detail),
+    () => capExtracts(detail),
+    () => capLists(detail),
+    () => cutStringToFit(detail, detail, "html", "htmlTruncated", MAX_BODY_SIZE),
+    () => cutStringToFit(detail, detail, "text", "textTruncated", MAX_BODY_SIZE, TEXT_FLOOR),
+    // Down to the essentials (and without a main link too long to use) there
+    // may be room for more of the text again.
+    () => {
+      keepOnly(detail, ESSENTIAL_DETAIL_FIELDS);
+      if (view.includeExtracts) {
+        Object.assign(detail, boundedLink(detail.link, MAX_BODY_SIZE / 2));
+      }
+      restoreText();
+      cutStringToFit(detail, detail, "text", "textTruncated", MAX_BODY_SIZE);
+    },
+    () => cutStringToFit(detail, detail, "subject", "subjectTruncated", MAX_BODY_SIZE)
+  ]);
+  return detail;
+}
+var LOCAL_ONLY_TOOLS = /* @__PURE__ */ new Set(["send_to", "replay_request"]);
+var TARGET_URL_TOOLS = /* @__PURE__ */ new Set(["render_email", "test_webhook_flow"]);
+var REMOTE_MAX_WAIT_MS = 5e4;
+var REMOTE_MIN_POLL_MS = 1e3;
+function durationMs(value) {
+  if (typeof value === "number") return Number.isFinite(value) && value >= 0 ? value : null;
+  if (typeof value !== "string") return null;
+  try {
+    const ms = (0, import_sdk.parseDuration)(value);
+    return Number.isFinite(ms) && ms >= 0 ? ms : null;
+  } catch {
+    return null;
+  }
+}
+function toolTarget(target, remote, handles) {
+  return {
+    tool(name, description, shape, handler) {
+      if (remote && LOCAL_ONLY_TOOLS.has(name)) return { remove() {
+      } };
+      const wrapped = remote ? async (args) => {
+        const input = args;
+        if (TARGET_URL_TOOLS.has(name) && input.targetUrl !== void 0) {
+          return {
+            ...textContent(
+              "targetUrl needs the local MCP server (npx -y @webhooks-cc/mcp): the hosted server cannot reach your machine. Leave it out here."
+            ),
+            isError: true
+          };
+        }
+        const bounded = { ...input };
+        if ("pollInterval" in shape && input.pollInterval === void 0) {
+          bounded.pollInterval = REMOTE_MIN_POLL_MS;
+        }
+        for (const [key, bound] of [
+          ["timeout", (ms) => Math.min(ms, REMOTE_MAX_WAIT_MS)],
+          [
+            "pollInterval",
+            (ms) => Math.min(Math.max(ms, REMOTE_MIN_POLL_MS), REMOTE_MAX_WAIT_MS)
+          ]
+        ]) {
+          if (bounded[key] === void 0) continue;
+          const ms = durationMs(bounded[key]);
+          if (ms === null) {
+            return {
+              ...textContent(`${key} must be a duration such as "30s" or milliseconds.`),
+              isError: true
+            };
+          }
+          bounded[key] = bound(ms);
+        }
+        return handler(bounded);
+      } : handler;
+      const handle = target.tool(name, description, shape, wrapped);
+      handles.push(handle);
+      return handle;
+    }
+  };
+}
+function registerTools(target, client, options = {}) {
+  const handles = [];
+  const server = toolTarget(target, options.remote === true, handles);
+  server.tool(
+    "create_endpoint",
+    "Create a webhook endpoint. Returns the endpoint slug, URL, and metadata.",
+    createEndpointShape,
+    withErrorHandling(
+      async ({
+        name,
+        ephemeral,
+        expiresIn,
+        mockResponse,
+        responseRules,
+        notificationUrl,
+        signingProvider,
+        signingSecret,
+        signingHeader
+      }) => {
+        if (signingProvider) {
+          if (signingProvider !== "discord" && !signingSecret) {
+            throw new Error(`signingSecret is required for provider "${signingProvider}"`);
+          }
+          if (signingProvider === "generic-hmac" && !signingHeader) {
+            throw new Error("signingHeader is required for generic-hmac provider");
+          }
+        }
+        if (signingSecret && !signingProvider) {
+          throw new Error("signingProvider is required when signingSecret is set");
+        }
+        const endpoint = await client.endpoints.create({
+          name,
+          ephemeral,
+          expiresIn,
+          mockResponse,
+          responseRules,
+          notificationUrl
+        });
+        if (signingProvider && signingSecret) {
+          try {
+            await client.endpoints.update(endpoint.slug, {
+              signingProvider,
+              signingSecret,
+              signingHeader
+            });
+          } catch (err) {
+            return jsonContent({
+              ...endpoint,
+              warning: `Endpoint created but signing configuration failed: ${err instanceof Error ? err.message : String(err)}. Update endpoint "${endpoint.slug}" to add signing.`
+            });
+          }
+        }
+        return jsonContent(endpoint);
+      }
+    )
+  );
+  server.tool(
+    "list_endpoints",
+    "List webhook endpoints: those you own (with sharedWith) and those shared with you through teams (with fromTeam). Optionally keep only one team's endpoints.",
+    listEndpointsShape,
+    withErrorHandling(async ({ team }) => {
+      const endpoints = await client.endpoints.list({ team });
+      return jsonContent(endpoints);
+    })
+  );
+  server.tool(
+    "list_teams",
+    "List the teams you own or belong to, with role, seats, pooled request usage (requestsUsed/requestLimit), period end, and whether the team is suspended for lack of a subscription.",
+    {},
+    withErrorHandling(async () => {
+      const teams = await client.teams.list();
+      return jsonContent(
+        teams.map((team) => ({
+          ...team,
+          periodEnd: team.periodEnd ? new Date(team.periodEnd).toISOString() : null
+        }))
+      );
+    })
+  );
+  server.tool(
+    "list_team_members",
+    "List a team's members and pending invites. Any member of the team may call this.",
+    { teamId: import_zod.z.string().min(1).describe("Team id (from list_teams)") },
+    withErrorHandling(async ({ teamId }) => {
+      const result = await client.teams.members(teamId);
+      return jsonContent(result);
+    })
+  );
+  server.tool(
+    "share_endpoint",
+    "Share an endpoint you own with a team so its members can inspect, stream, and edit it. The team needs an active subscription; the endpoint's requests then bill the team's pooled quota.",
+    {
+      slug: import_zod.z.string().describe("Slug of an endpoint you own"),
+      teamId: import_zod.z.string().min(1).describe("Team id (from list_teams)")
+    },
+    withErrorHandling(async ({ slug, teamId }) => {
+      await client.teams.share(teamId, slug);
+      return jsonContent({ shared: true, slug, teamId });
+    })
+  );
+  server.tool(
+    "unshare_endpoint",
+    "Stop sharing an endpoint you own with a team. Works even when the team is suspended.",
+    {
+      slug: import_zod.z.string().describe("Slug of an endpoint you own"),
+      teamId: import_zod.z.string().min(1).describe("Team id (from list_teams)")
+    },
+    withErrorHandling(async ({ slug, teamId }) => {
+      await client.teams.unshare(teamId, slug);
+      return jsonContent({ shared: false, slug, teamId });
+    })
+  );
+  server.tool(
+    "get_endpoint",
+    "Get details for a specific webhook endpoint by slug.",
+    getEndpointShape,
+    withErrorHandling(async ({ slug }) => {
+      const endpoint = await client.endpoints.get(slug);
+      return jsonContent(endpoint);
+    })
+  );
+  server.tool(
+    "update_endpoint",
+    "Update an endpoint name, mock response, conditional response rules, signing configuration, whether codes and links are picked out of its emails, or the named fields picked out of them.",
+    {
+      slug: import_zod.z.string().describe("The endpoint slug to update"),
+      name: import_zod.z.string().optional().describe("New display name"),
+      mockResponse: mockResponseSchema.nullable().optional().describe("Default mock response (used when no rule matches), or null to clear"),
+      responseRules: responseRulesSchema.nullable().optional().describe("Conditional response rules (first match wins), or null to clear"),
+      notificationUrl: import_zod.z.string().url().nullable().optional().describe("Notification webhook URL, or null to clear it"),
+      signingProvider: import_zod.z.string().nullable().optional().describe(
+        "Signing provider for automatic verification (e.g. stripe, github), or null to disable"
+      ),
+      signingSecret: import_zod.z.string().nullable().optional().describe("New signing secret (encrypted server-side). Pass null to clear."),
+      signingHeader: import_zod.z.string().nullable().optional().describe(
+        "Custom signature header name (only for generic-hmac provider), or null to clear"
+      ),
+      showEmailExtracts: import_zod.z.boolean().optional().describe("Pick codes and links out of emails (dashboard and forwarded JSON). Owner only."),
+      emailFields: import_zod.z.array(
+        import_zod.z.object({
+          name: import_zod.z.string().describe("Letters, digits and _, starting with a letter: {{ fields.name }}"),
+          from: import_zod.z.enum(["subject", "text", "html", "from", "to", "header"]).describe("What it reads; html is the HTML as text"),
+          header: import_zod.z.string().optional().describe('The header name, for from "header"'),
+          pattern: import_zod.z.string().describe("RE2 regular expression; the first group is the value (no lookarounds)")
+        })
+      ).max(20).nullable().optional().describe(
+        "Named fields picked out of every email: shown with it, `fields` in its JSON, read by forwarding templates and filters (email_field). Replaces the list; null or [] removes them. Owner only."
+      )
+    },
+    withErrorHandling(
+      async ({
+        slug,
+        name,
+        mockResponse,
+        responseRules,
+        notificationUrl,
+        signingProvider,
+        signingSecret,
+        signingHeader,
+        showEmailExtracts,
+        emailFields
+      }) => {
+        const endpoint = await client.endpoints.update(slug, {
+          name,
+          mockResponse,
+          responseRules,
+          notificationUrl,
+          signingProvider,
+          signingSecret,
+          signingHeader,
+          showEmailExtracts,
+          emailFields
+        });
+        return jsonContent(endpoint);
+      }
+    )
+  );
+  server.tool(
+    "preview_response",
+    "Dry run of an endpoint's responses: which response rule answers a captured request, and the response with its {{ placeholders }} filled in, exactly as the receiver would send it. Nothing is sent. Pass mockResponse or responseRules to try settings before saving them with update_endpoint.",
+    {
+      slug: import_zod.z.string().describe("The endpoint slug"),
+      requestId: import_zod.z.string().optional().describe(
+        "A captured request on the endpoint (default: the newest HTTP request, or a sample)"
+      ),
+      mockResponse: mockResponseSchema.nullable().optional().describe("Try this default response instead of the saved one (null: none)"),
+      responseRules: responseRulesSchema.nullable().optional().describe("Try these rules instead of the saved ones (null: none)")
+    },
+    withErrorHandling(async ({ slug, requestId, mockResponse, responseRules }) => {
+      const preview = await client.endpoints.previewResponse(slug, {
+        ...requestId ? { requestId } : {},
+        ...mockResponse !== void 0 ? { mockResponse } : {},
+        ...responseRules !== void 0 ? { responseRules } : {}
+      });
+      return jsonContent(preview);
+    })
+  );
+  server.tool(
+    "delete_endpoint",
+    "Delete a webhook endpoint and all its captured requests.",
+    deleteEndpointShape,
+    withErrorHandling(async ({ slug }) => {
+      await client.endpoints.delete(slug);
+      return textContent(`Endpoint "${slug}" deleted.`);
+    })
+  );
+  server.tool(
+    "create_endpoints",
+    "Create multiple webhook endpoints in one call.",
+    {
+      count: import_zod.z.number().int().min(1).max(20).describe("Number of endpoints to create"),
+      namePrefix: import_zod.z.string().optional().describe("Optional prefix for endpoint names"),
+      ephemeral: import_zod.z.boolean().optional().describe("Create temporary endpoints that auto-expire"),
+      expiresIn: durationOrTimestampSchema.optional().describe('Auto-expire after this duration, for example "12h"')
+    },
+    withErrorHandling(async ({ count, namePrefix, ephemeral, expiresIn }) => {
+      const endpoints = await Promise.all(
+        Array.from(
+          { length: count },
+          (_, index) => client.endpoints.create({
+            name: namePrefix ? `${namePrefix}-${index + 1}` : void 0,
+            ephemeral,
+            expiresIn
+          })
+        )
+      );
+      return jsonContent({ endpoints });
+    })
+  );
+  server.tool(
+    "delete_endpoints",
+    "Delete multiple webhook endpoints in one call.",
+    {
+      slugs: import_zod.z.array(import_zod.z.string()).min(1).max(100).describe("Endpoint slugs to delete")
+    },
+    withErrorHandling(async ({ slugs }) => {
+      const settled = await Promise.allSettled(
+        slugs.map(async (slug) => {
+          await client.endpoints.delete(slug);
+          return slug;
+        })
+      );
+      return jsonContent({
+        deleted: settled.filter(
+          (result) => result.status === "fulfilled"
+        ).map((result) => result.value),
+        failed: settled.flatMap(
+          (result, index) => result.status === "rejected" ? [
+            {
+              slug: slugs[index],
+              message: result.reason instanceof Error ? result.reason.message : String(result.reason)
+            }
+          ] : []
+        )
+      });
+    })
+  );
+  server.tool(
+    "send_webhook",
+    "Send a test webhook to a hosted endpoint. Supports provider templates and signing.",
+    {
+      slug: import_zod.z.string().describe("The endpoint slug to send to"),
+      method: methodSchema,
+      headers: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional().describe("HTTP headers to include"),
+      body: import_zod.z.unknown().optional().describe("Request body"),
+      provider: import_zod.z.enum(import_sdk.TEMPLATE_PROVIDERS).optional().describe("Optional provider template to send with signed headers"),
+      template: import_zod.z.string().optional().describe("Provider-specific template preset"),
+      event: import_zod.z.string().optional().describe("Provider event or topic name"),
+      secret: import_zod.z.string().optional().describe(
+        "Signing secret. Required for signed provider templates; omit for secretless providers (sendgrid, discord, plaid)."
+      )
+    },
+    withErrorHandling(
+      async ({ slug, method, headers, body, provider, template, event, secret }) => {
+        let response;
+        if (provider) {
+          const templateSecret = secret?.trim();
+          if (!templateSecret && import_sdk.TEMPLATE_METADATA[provider]?.secretRequired !== false) {
+            throw new Error(`send_webhook with provider "${provider}" requires a non-empty secret`);
+          }
+          response = await client.endpoints.sendTemplate(slug, {
+            provider,
+            template,
+            event,
+            secret: templateSecret,
+            method,
+            headers,
+            body
+          });
+        } else {
+          response = await client.endpoints.send(slug, { method, headers, body });
+        }
+        const responseBody = await readBodyTruncated(response);
+        return jsonContent({
+          status: response.status,
+          statusText: response.statusText,
+          body: responseBody
+        });
+      }
+    )
+  );
+  server.tool(
+    "list_requests",
+    "List recent captured requests for an endpoint, HTTP requests and emails together (filter with kind). For emails, list_emails is shorter.",
+    listRequestsShape,
+    withErrorHandling(async ({ endpointSlug, limit, since, kind }) => {
+      const requests = await client.requests.list(endpointSlug, { limit, since, kind });
+      return jsonContent(requests.map(compactRequest));
+    })
+  );
+  server.tool(
+    "search_requests",
+    "Search captured webhook requests across endpoints using retained full-text search.",
+    {
+      slug: import_zod.z.string().optional().describe("Filter to a specific endpoint slug"),
+      method: import_zod.z.string().optional().describe("Filter by HTTP method"),
+      kind: kindSchema,
+      q: import_zod.z.string().optional().describe("Free-text search across path, body, and headers"),
+      from: durationOrTimestampSchema.optional().describe('Start time as a timestamp or duration like "1h" or "7d"'),
+      to: durationOrTimestampSchema.optional().describe('End time as a timestamp or duration like "1h" or "7d"'),
+      limit: import_zod.z.number().int().min(1).max(200).default(50).describe("Max results to return"),
+      offset: import_zod.z.number().int().min(0).max(1e4).default(0).describe("Result offset"),
+      order: import_zod.z.enum(["asc", "desc"]).default("desc").describe("Sort order by received time")
+    },
+    withErrorHandling(async ({ slug, method, kind, q, from, to, limit, offset, order }) => {
+      const results = await client.requests.search({
+        slug,
+        method,
+        kind,
+        q,
+        from,
+        to,
+        limit,
+        offset,
+        order
+      });
+      return jsonContent(results.map(compactRequest));
+    })
+  );
+  server.tool(
+    "count_requests",
+    "Count captured webhook requests that match the given filters.",
+    {
+      slug: import_zod.z.string().optional().describe("Filter to a specific endpoint slug"),
+      method: import_zod.z.string().optional().describe("Filter by HTTP method"),
+      kind: kindSchema,
+      q: import_zod.z.string().optional().describe("Free-text search across path, body, and headers"),
+      from: durationOrTimestampSchema.optional().describe('Start time as a timestamp or duration like "1h" or "7d"'),
+      to: durationOrTimestampSchema.optional().describe('End time as a timestamp or duration like "1h" or "7d"')
+    },
+    withErrorHandling(async ({ slug, method, kind, q, from, to }) => {
+      const count = await client.requests.count({ slug, method, kind, q, from, to });
+      return jsonContent({ count });
+    })
+  );
+  server.tool(
+    "get_request",
+    "Get full details for a specific captured request by ID.",
+    getRequestShape,
+    withErrorHandling(async ({ requestId }) => {
+      const request = await client.requests.get(requestId);
+      return jsonContent(compactRequest(request));
+    })
+  );
+  server.tool(
+    "wait_for_request",
+    "Wait for a request to arrive at an endpoint.",
+    waitForRequestShape,
+    withErrorHandling(async ({ endpointSlug, timeout, pollInterval }) => {
+      const request = await client.requests.waitFor(endpointSlug, { timeout, pollInterval });
+      return jsonContent(compactRequest(request));
+    })
+  );
+  server.tool(
+    "wait_for_requests",
+    "Wait for multiple requests to arrive at an endpoint.",
+    {
+      endpointSlug: import_zod.z.string().describe("The endpoint slug to monitor"),
+      count: import_zod.z.number().int().min(1).max(20).describe("Number of requests to collect"),
+      timeout: durationOrTimestampSchema.default("30s").describe('How long to wait, for example "30s"'),
+      pollInterval: durationOrTimestampSchema.optional().describe('Interval between polls, for example "500ms" or "1s"'),
+      method: import_zod.z.string().optional().describe("Only collect requests with this HTTP method")
+    },
+    withErrorHandling(async ({ endpointSlug, count, timeout, pollInterval, method }) => {
+      const result = await waitForMultipleRequests(client, endpointSlug, {
+        count,
+        timeout,
+        pollInterval,
+        method
+      });
+      return jsonContent(
+        fitArrayField({ ...result, requests: result.requests.map(compactRequest) }, "requests")
+      );
+    })
+  );
+  server.tool(
+    "replay_request",
+    "Replay a previously captured request to a target URL.",
+    {
+      requestId: import_zod.z.string().describe("The captured request ID"),
+      targetUrl: httpUrlSchema.describe("The URL to replay the request to")
+    },
+    withErrorHandling(async ({ requestId, targetUrl }) => {
+      const response = await client.requests.replay(requestId, targetUrl);
+      const responseBody = await readBodyTruncated(response);
+      return jsonContent({
+        status: response.status,
+        statusText: response.statusText,
+        body: responseBody
+      });
+    })
+  );
+  server.tool(
+    "render_email",
+    "A captured email in the shape an inbound mail provider posts it (postmark, sendgrid, mailgun, cloudmailin), to test the inbound handler you wrote for that provider against real mail. Returns the method, headers and body; with targetUrl (your local handler), posts it there and returns the answer. A Mailgun form is signed when you pass the signing key your handler checks.",
+    {
+      requestId: import_zod.z.string().describe("The captured email's request ID"),
+      format: import_zod.z.enum(["postmark", "sendgrid", "mailgun", "cloudmailin", "json"]).describe("Whose shape; json is webhooks.cc's own email.received JSON (unsigned)"),
+      mailgunSigningKey: import_zod.z.string().optional().describe("For mailgun: the signing key your handler verifies with (a test key)"),
+      targetUrl: httpUrlSchema.optional().describe("Post it here, e.g. http://localhost:3000/api/inbound/postmark")
+    },
+    withErrorHandling(async ({ requestId, format, mailgunSigningKey, targetUrl }) => {
+      const rendered = await client.emails.render(requestId, {
+        format,
+        ...mailgunSigningKey ? { mailgunSigningKey } : {}
+      });
+      if (!targetUrl) {
+        return jsonContent(
+          shrinkRendered(rendered, MAX_BODY_SIZE)
+        );
+      }
+      const response = await fetch(targetUrl, {
+        method: "POST",
+        headers: { "content-type": rendered.headers["content-type"] },
+        body: rendered.body,
+        redirect: "manual"
+      });
+      return jsonContent({
+        format,
+        status: response.status,
+        statusText: response.statusText,
+        body: await readBodyTruncated(response)
+      });
+    })
+  );
+  server.tool(
+    "compare_requests",
+    "Compare two captured requests and show the structured differences.",
+    {
+      leftRequestId: import_zod.z.string().describe("The first request ID"),
+      rightRequestId: import_zod.z.string().describe("The second request ID"),
+      ignoreHeaders: import_zod.z.array(import_zod.z.string()).optional().describe("Headers to ignore during comparison")
+    },
+    withErrorHandling(async ({ leftRequestId, rightRequestId, ignoreHeaders }) => {
+      const [leftRequest, rightRequest] = await Promise.all([
+        client.requests.get(leftRequestId),
+        client.requests.get(rightRequestId)
+      ]);
+      const diff = (0, import_sdk.diffRequests)(leftRequest, rightRequest, { ignoreHeaders });
+      return jsonContent(diff);
+    })
+  );
+  server.tool(
+    "generate_payload_schema",
+    "Generate TypeScript interfaces, Zod schemas, Pydantic models, or JSON Schema from captured request bodies. Several requests of one event teach which fields are optional or nullable, so filter with event (or pass requestIds) and write the result into the codebase instead of hand-typing the payload.",
+    payloadSchemaShape,
+    withErrorHandling(async ({ endpointSlug, requestIds, limit, ...args }) => {
+      const requests = requestIds ? await Promise.all(requestIds.map((id) => client.requests.get(id))) : await client.requests.list(endpointSlug, { limit, kind: "http" });
+      return payloadSchemaResult(requests, args);
+    })
+  );
+  server.tool(
+    "extract_from_request",
+    "Extract specific JSON fields from a captured request body.",
+    {
+      requestId: import_zod.z.string().describe("The request ID"),
+      jsonPaths: import_zod.z.array(import_zod.z.string()).min(1).max(50).describe("Dot-notation JSON paths to extract")
+    },
+    withErrorHandling(async ({ requestId, jsonPaths }) => {
+      const request = await client.requests.get(requestId);
+      const extracted = Object.fromEntries(
+        jsonPaths.map((path) => [path, (0, import_sdk.extractJsonField)(request, path) ?? null])
+      );
+      return jsonContent(extracted);
+    })
+  );
+  server.tool(
+    "verify_signature",
+    "Verify the webhook signature on a captured request. When called without provider/secret, returns the server-side pre-computed result (if signing is configured on the endpoint). When called with provider+secret, performs client-side verification.",
+    {
+      requestId: import_zod.z.string().describe("The captured request ID"),
+      provider: import_zod.z.enum(import_sdk.VERIFY_PROVIDERS).optional().describe("Provider whose signature scheme should be verified. Omit to use stored result."),
+      secret: import_zod.z.string().optional().describe(
+        "Provider credential for client-side verification (for example a shared signing secret, Adyen hex HMAC key, or PayPal webhook ID). Required for non-Discord providers."
+      ),
+      publicKey: import_zod.z.string().optional().describe("Discord application public key. Required for provider=discord."),
+      url: httpUrlSchema.optional().describe("Original signed URL. Required for Twilio, Square, and HubSpot verification."),
+      method: import_zod.z.string().optional().describe(
+        "Original HTTP method used when the signature was generated. Used by HubSpot v3 verification; the SDK assumes POST when omitted."
+      )
+    },
+    withErrorHandling(async ({ requestId, provider, secret, publicKey, url, method }) => {
+      const request = await client.requests.get(requestId);
+      if (!provider && !secret && !publicKey) {
+        const verified = request.signatureVerified;
+        if (verified === null || verified === void 0) {
+          return jsonContent({
+            valid: null,
+            details: "No signature verification configured on this endpoint. Pass provider and secret to verify client-side."
+          });
+        }
+        let errorData = null;
+        if (request.signatureError) {
+          try {
+            errorData = JSON.parse(request.signatureError);
+          } catch {
+            errorData = null;
+          }
+        }
+        const isSkipped = !verified && errorData?.code && (errorData.code === "missing_header" || errorData.code === "unsupported");
+        return jsonContent({
+          valid: isSkipped ? null : verified,
+          provider: request.signingProvider ?? null,
+          details: verified ? "Signature verified by server." : isSkipped ? `Verification skipped: ${errorData?.message ?? errorData?.code}` : `Signature invalid: ${request.signatureError ?? "unknown error"}`,
+          error: request.signatureError ?? null,
+          skipped: isSkipped ?? false
+        });
+      }
+      const verificationOptions = ensureVerifyArgs({
+        provider,
+        secret,
+        publicKey,
+        url,
+        method
+      });
+      const result = await (0, import_sdk.verifySignature)(request, verificationOptions);
+      return jsonContent({
+        valid: result.valid,
+        details: result.valid ? "Signature is valid." : "Signature did not match."
+      });
+    })
+  );
+  server.tool(
+    "clear_requests",
+    "Delete captured requests for an endpoint without deleting the endpoint itself.",
+    {
+      slug: import_zod.z.string().describe("The endpoint slug to clear"),
+      before: durationOrTimestampSchema.optional().describe('Only clear requests older than this timestamp or duration like "1h"')
+    },
+    withErrorHandling(async ({ slug, before }) => {
+      await client.requests.clear(slug, { before });
+      return jsonContent({ slug, cleared: true, before: before ?? null });
+    })
+  );
+  server.tool(
+    "send_to",
+    "Send a webhook directly to any URL with optional provider signing.",
+    {
+      url: httpUrlSchema.describe("Target URL"),
+      method: methodSchema,
+      headers: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional().describe("HTTP headers to include"),
+      body: import_zod.z.unknown().optional().describe("Request body"),
+      provider: import_zod.z.enum(import_sdk.TEMPLATE_PROVIDERS).optional().describe("Optional provider template for signing"),
+      template: import_zod.z.string().optional().describe("Provider-specific template preset"),
+      event: import_zod.z.string().optional().describe("Provider event or topic name"),
+      secret: import_zod.z.string().optional().describe(
+        "Signing secret. Required for signed provider templates; omit for secretless providers (sendgrid, discord, plaid)."
+      )
+    },
+    withErrorHandling(async ({ url, method, headers, body, provider, template, event, secret }) => {
+      const response = await client.sendTo(url, {
+        method,
+        headers,
+        body,
+        provider,
+        template,
+        event,
+        secret
+      });
+      const responseBody = await readBodyTruncated(response);
+      return jsonContent({
+        status: response.status,
+        statusText: response.statusText,
+        body: responseBody
+      });
+    })
+  );
+  server.tool(
+    "preview_webhook",
+    "Preview a webhook request without sending it. Returns the exact URL, method, headers, and body.",
+    {
+      url: httpUrlSchema.describe("Target URL"),
+      method: methodSchema,
+      headers: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional().describe("HTTP headers to include"),
+      body: import_zod.z.unknown().optional().describe("Request body"),
+      provider: import_zod.z.enum(import_sdk.TEMPLATE_PROVIDERS).optional().describe("Optional provider template for signing"),
+      template: import_zod.z.string().optional().describe("Provider-specific template preset"),
+      event: import_zod.z.string().optional().describe("Provider event or topic name"),
+      secret: import_zod.z.string().optional().describe(
+        "Signing secret. Required for signed provider templates; omit for secretless providers (sendgrid, discord, plaid)."
+      )
+    },
+    withErrorHandling(async ({ url, method, headers, body, provider, template, event, secret }) => {
+      const preview = await client.buildRequest(url, {
+        method,
+        headers,
+        body,
+        provider,
+        template,
+        event,
+        secret
+      });
+      return jsonContent(preview);
+    })
+  );
+  server.tool(
+    "list_provider_templates",
+    "List supported webhook providers, templates, and signing metadata.",
+    {
+      provider: import_zod.z.enum(import_sdk.TEMPLATE_PROVIDERS).optional().describe("Filter to a single provider")
+    },
+    withErrorHandling(async ({ provider }) => {
+      if (provider) {
+        return jsonContent([client.templates.get(provider)]);
+      }
+      return jsonContent(
+        client.templates.listProviders().map((name) => client.templates.get(name))
+      );
+    })
+  );
+  server.tool(
+    "get_usage",
+    "Check current request usage, remaining quota, plan, and period end, plus the pooled quota of every subscribed team you belong to.",
+    {},
+    withErrorHandling(async () => {
+      const [usageResult, teamsResult] = await Promise.allSettled([
+        client.usage(),
+        client.teams.list()
+      ]);
+      if (usageResult.status === "rejected") throw usageResult.reason;
+      const usage = usageResult.value;
+      const teams = teamsResult.status === "fulfilled" ? teamsResult.value : [];
+      const teamsError = teamsResult.status === "rejected" ? teamsResult.reason instanceof Error ? teamsResult.reason.message : String(teamsResult.reason) : void 0;
+      return jsonContent({
+        ...usage,
+        periodEnd: usage.periodEnd ? new Date(usage.periodEnd).toISOString() : null,
+        ...teamsError ? { teamsError } : {},
+        teams: teams.filter((team) => !team.suspended).map((team) => ({
+          id: team.id,
+          name: team.name,
+          role: team.role,
+          seats: team.seats,
+          used: team.requestsUsed,
+          limit: team.requestLimit,
+          remaining: Math.max(0, team.requestLimit - team.requestsUsed),
+          periodEnd: team.periodEnd ? new Date(team.periodEnd).toISOString() : null
+        }))
+      });
+    })
+  );
+  server.tool(
+    "test_webhook_flow",
+    "Run a full webhook test flow: create endpoint, optionally mock, send, wait, verify, replay, and clean up.",
+    {
+      provider: import_zod.z.enum(import_sdk.TEMPLATE_PROVIDERS).optional().describe("Optional provider template to use when sending the webhook"),
+      event: import_zod.z.string().optional().describe("Optional provider event or topic name"),
+      secret: import_zod.z.string().optional().describe(
+        "Signing secret. Required when provider is set or signature verification is enabled."
+      ),
+      mockStatus: import_zod.z.number().int().min(100).max(599).optional().describe("Optional mock response status to configure before sending"),
+      targetUrl: httpUrlSchema.optional().describe("Optional URL to replay the captured request to after capture"),
+      verifySignature: import_zod.z.boolean().default(false).describe("Verify the captured request signature after capture"),
+      cleanup: import_zod.z.boolean().default(true).describe("Delete the created endpoint after the flow completes")
+    },
+    withErrorHandling(
+      async ({
+        provider,
+        event,
+        secret,
+        mockStatus,
+        targetUrl,
+        verifySignature: shouldVerify,
+        cleanup
+      }) => {
+        const flow = client.flow().createEndpoint({ expiresIn: "1h" }).waitForCapture({ timeout: "30s", pollInterval: "1s" });
+        if (mockStatus !== void 0) {
+          flow.setMock({
+            status: mockStatus,
+            body: "",
+            headers: {}
+          });
+        }
+        if (provider) {
+          const templateSecret = secret?.trim();
+          if (!templateSecret && import_sdk.TEMPLATE_METADATA[provider]?.secretRequired !== false) {
+            throw new Error(
+              `test_webhook_flow with provider "${provider}" requires a non-empty secret`
+            );
+          }
+          flow.sendTemplate({
+            provider,
+            event,
+            secret: templateSecret
+          });
+          if (shouldVerify) {
+            if (provider === "discord") {
+              throw new Error(
+                "test_webhook_flow cannot verify Discord signatures (Ed25519 requires a public key, not a secret)"
+              );
+            }
+            if (!templateSecret) {
+              throw new Error(
+                `test_webhook_flow cannot verify "${provider}" signatures \u2014 this provider's templates are unsigned`
+              );
+            }
+            flow.verifySignature({
+              provider,
+              secret: templateSecret
+            });
+          }
+        } else {
+          if (shouldVerify) {
+            throw new Error("test_webhook_flow cannot verify signatures without a provider");
+          }
+          flow.send();
+        }
+        if (targetUrl) {
+          flow.replayTo(targetUrl);
+        }
+        if (cleanup) {
+          flow.cleanup();
+        }
+        const result = await flow.run();
+        return jsonContent({
+          endpoint: result.endpoint,
+          request: result.request ?? null,
+          verification: result.verification ?? null,
+          replayResponse: result.replayResponse ? await summarizeResponse(result.replayResponse) : null,
+          cleanedUp: result.cleanedUp
+        });
+      }
+    )
+  );
+  server.tool(
+    "list_emails",
+    "List the emails an endpoint received at its mailhooks.cc address, newest first: subject, sender, tag, and the one-time code and main link found in each.",
+    {
+      endpointSlug: import_zod.z.string().describe("The endpoint slug"),
+      limit: import_zod.z.number().int().min(1).max(100).default(25).describe(
+        `Max emails to return. With tag, subject or from, the newest ${EMAIL_SCAN_LIMIT} emails are searched.`
+      ),
+      since: import_zod.z.number().optional().describe("Only emails received after this timestamp in ms"),
+      tag: import_zod.z.string().optional().describe("Only emails sent to {slug}+{tag}@mailhooks.cc (exact, case-sensitive)"),
+      subject: import_zod.z.string().optional().describe("Only emails whose subject contains this text"),
+      from: import_zod.z.string().optional().describe("Only emails from this address (case-insensitive)")
+    },
+    withErrorHandling(async ({ endpointSlug, limit, since, tag, subject, from }) => {
+      const filtered = tag !== void 0 || subject !== void 0 || from !== void 0;
+      const scan = filtered ? Math.max(limit, EMAIL_SCAN_LIMIT) : limit;
+      const [emails, view] = await Promise.all([
+        client.emails.list(endpointSlug, { limit: scan, since, tag, subject, from }),
+        emailEndpointView(client, endpointSlug)
+      ]);
+      return jsonContent(
+        emails.slice(0, limit).map((email) => summarizeEmail(email, view.includeExtracts))
+      );
+    })
+  );
+  server.tool(
+    "get_email",
+    "Get one captured email: by requestId, or the newest at an endpoint (optionally with a tag). Returns the parsed message with its one-time code and main link.",
+    {
+      requestId: import_zod.z.string().optional().describe("The email's request ID"),
+      endpointSlug: import_zod.z.string().optional().describe("Get the newest email at this endpoint instead (with requestId unset)"),
+      tag: import_zod.z.string().optional().describe("With endpointSlug: only emails sent to this +tag"),
+      includeHtml: import_zod.z.boolean().default(false).describe("Include the HTML part (default: false, only its size)")
+    },
+    withErrorHandling(async ({ requestId, endpointSlug, tag, includeHtml }) => {
+      if (requestId === void 0 === (endpointSlug === void 0)) {
+        throw new Error("Pass exactly one of requestId or endpointSlug");
+      }
+      const email = requestId ? await client.emails.get(requestId) : await client.emails.latest(endpointSlug, { tag });
+      if (!email) {
+        throw new import_sdk.NotFoundError(
+          `No email at ${endpointSlug}${tag ? ` with tag "${tag}"` : ""} yet. Send one with send_test_email, or wait with wait_for_email.`
+        );
+      }
+      const view = await emailEndpointView(
+        client,
+        endpointSlug ?? emailSlugFromAddress(email.path)
+      );
+      return jsonContent(emailDetail(client, email, view, includeHtml));
+    })
+  );
+  server.tool(
+    "wait_for_email",
+    "Wait for an email to arrive at an endpoint (for example after triggering a signup), then return it with its one-time code and main link. Use a tag per run to find your own email.",
+    {
+      endpointSlug: import_zod.z.string().describe("The endpoint slug"),
+      tag: import_zod.z.string().optional().describe("Only emails sent to {slug}+{tag}@mailhooks.cc"),
+      subject: import_zod.z.string().optional().describe("Only emails whose subject contains this text"),
+      from: import_zod.z.string().optional().describe("Only emails from this address (case-insensitive)"),
+      timeout: durationOrTimestampSchema.default("30s").describe(
+        `How long to wait (default "30s"). Keep it under your MCP client's request timeout, often 60 seconds.`
+      ),
+      since: import_zod.z.number().optional().describe("Only emails received after this timestamp in ms (default: five minutes ago)"),
+      includeHtml: import_zod.z.boolean().default(false).describe("Include the HTML part (default: false)")
+    },
+    withErrorHandling(async ({ endpointSlug, tag, subject, from, timeout, since, includeHtml }) => {
+      const view = await emailEndpointView(client, endpointSlug);
+      const email = await client.emails.waitFor(endpointSlug, {
+        tag,
+        subject,
+        from,
+        timeout,
+        since
+      });
+      return jsonContent(emailDetail(client, email, view, includeHtml));
+    })
+  );
+  server.tool(
+    "send_test_email",
+    "Deliver a sample email (with a 6-digit code and a link) to an endpoint, optionally to a +tag address. It counts as one request and skips SMTP, so sender checks do not run on it.",
+    {
+      slug: import_zod.z.string().describe("The endpoint slug"),
+      tag: import_zod.z.string().optional().describe("Deliver to {slug}+{tag}@mailhooks.cc")
+    },
+    withErrorHandling(async ({ slug, tag }) => {
+      const result = await client.emails.sendTest(slug, { tag });
+      return jsonContent({ ...result, address: client.emails.address(slug, tag) });
+    })
+  );
+  server.tool(
+    "list_destinations",
+    "List where an endpoint's captures go: its destinations (up to 10) with their URL, kinds, filter, format, templates and timing, and with summary: true their last 24 hours. Owner only.",
+    {
+      slug: import_zod.z.string().describe("The endpoint slug"),
+      summary: import_zod.z.boolean().default(true).describe("Add each destination's last 24 hours")
+    },
+    withErrorHandling(async ({ slug, summary }) => {
+      return jsonContent(await client.destinations.list(slug, { summary }));
+    })
+  );
+  server.tool(
+    "add_destination",
+    "Add a destination for an endpoint's captures: your server (as received or signed JSON), a Slack or Discord channel (chat, optionally your own messageTemplate, throttleSeconds 1 for a heads-up), or a JSON body you shape with bodyTemplate (for Zapier, n8n or your API). filter sends only matching captures; delaySeconds makes it a callback. Each destination gets its own signing secret. Check it with preview_destination before relying on it. Owner only.",
+    {
+      slug: import_zod.z.string().describe("The endpoint slug"),
+      url: httpUrlSchema.describe("https URL on a public host name, or a Slack or Discord webhook"),
+      ...destinationFields
+    },
+    withErrorHandling(async ({ slug, ...input }) => {
+      return jsonContent(await client.destinations.create(slug, input));
+    })
+  );
+  server.tool(
+    "update_destination",
+    "Change a destination: any of its fields; only the ones you pass change. Owner only.",
+    {
+      slug: import_zod.z.string().describe("The endpoint slug"),
+      destinationId: import_zod.z.string().describe("The destination's id (from list_destinations)"),
+      url: httpUrlSchema.optional().describe("A new URL"),
+      ...destinationFields
+    },
+    withErrorHandling(async ({ slug, destinationId, ...input }) => {
+      return jsonContent(await client.destinations.update(slug, destinationId, input));
+    })
+  );
+  server.tool(
+    "remove_destination",
+    "Remove a destination. Deliveries still waiting for it are marked failed; its log stays. Owner only.",
+    {
+      slug: import_zod.z.string().describe("The endpoint slug"),
+      destinationId: import_zod.z.string().describe("The destination's id")
+    },
+    withErrorHandling(async ({ slug, destinationId }) => {
+      await client.destinations.delete(slug, destinationId);
+      return textContent(`Destination ${destinationId} removed.`);
+    })
+  );
+  server.tool(
+    "preview_destination",
+    "Dry run of a destination against a captured request: whether its filter lets the request through and the exact request it would send (method, URL, headers, body with placeholders filled in). Nothing is sent. Use destinationId for a saved destination, destination for unsaved fields (on top of the saved ones, or with a url on their own), or both.",
+    {
+      slug: import_zod.z.string().describe("The endpoint slug"),
+      destinationId: import_zod.z.string().optional().describe("A saved destination"),
+      destination: import_zod.z.object({ url: httpUrlSchema.optional(), ...destinationFields }).optional().describe("Unsaved fields to try"),
+      requestId: import_zod.z.string().optional().describe("A captured request (default: the newest of the kind it takes, or a sample)")
+    },
+    withErrorHandling(async ({ slug, destinationId, destination, requestId }) => {
+      if (!destinationId && !destination?.url) {
+        throw new Error("Pass destinationId, or a destination with a url");
+      }
+      return jsonContent(
+        await client.destinations.preview(slug, {
+          ...destinationId ? { destinationId } : {},
+          ...destination ? { destination } : {},
+          ...requestId ? { requestId } : {}
+        })
+      );
+    })
+  );
+  server.tool(
+    "configure_forwarding",
+    "Change an endpoint's primary forwarding destination (the one the endpoint's forward* fields stand for): the URL, on or off, which kinds, the format, your own headers, and the advanced options. Only the arguments you pass change. Owner only. For several destinations, filters, templates, throttling or delays, use add_destination and update_destination.",
+    {
+      slug: import_zod.z.string().describe("The endpoint slug"),
+      url: httpUrlSchema.nullable().optional().describe("https URL on a public host name, or null to remove it (forwarding must be off)"),
+      enabled: import_zod.z.boolean().optional().describe("Turn forwarding on (needs a URL) or off (fails deliveries still waiting)"),
+      http: import_zod.z.boolean().optional().describe("Forward HTTP requests"),
+      email: import_zod.z.boolean().optional().describe("Forward emails"),
+      format: import_zod.z.enum(["auto", "as_received", "json", "chat"]).optional().describe(
+        "auto (pick from the URL), as_received (relay HTTP requests unchanged; emails as signed JSON), json (signed JSON envelope for both kinds) or chat (Slack or Discord message)"
+      ),
+      headers: import_zod.z.array(
+        import_zod.z.object({
+          name: import_zod.z.string().describe("Header name, e.g. Authorization"),
+          value: import_zod.z.string().nullable().describe("Header value, or null to keep the value stored under this name")
+        })
+      ).max(10).optional().describe(
+        "Your own headers for every delivery (not chat). Replaces the whole list; [] removes them"
+      ),
+      appendPath: import_zod.z.boolean().optional().describe("Add the path after the slug to the URL for relayed requests (default true)"),
+      retrySeconds: import_zod.z.union([import_zod.z.literal(0), import_zod.z.literal(3600), import_zod.z.literal(86400)]).optional().describe("Retry failed deliveries for 86400 (default), 3600 or 0 seconds"),
+      keepOrder: import_zod.z.boolean().optional().describe("One delivery at a time, in capture order (default false)"),
+      sentField: import_zod.z.string().max(128).nullable().optional().describe(
+        "JSON body field with the sender's own timestamp, e.g. publishedAt or data.publishedAt; null clears it"
+      )
+    },
+    withErrorHandling(async ({ slug, ...options2 }) => {
+      const endpoint = await client.forwarding.configure(slug, options2);
+      return jsonContent({
+        slug: endpoint.slug,
+        forwardEnabled: endpoint.forwardEnabled ?? false,
+        forwardUrl: endpoint.forwardUrl ?? null,
+        hasForwardSecret: endpoint.hasForwardSecret ?? false,
+        forwardHttp: endpoint.forwardHttp ?? false,
+        forwardEmail: endpoint.forwardEmail ?? false,
+        forwardFormat: endpoint.forwardFormat ?? "auto",
+        forwardHeaders: endpoint.forwardHeaders ?? [],
+        forwardAppendPath: endpoint.forwardAppendPath ?? true,
+        forwardRetrySeconds: endpoint.forwardRetrySeconds ?? 86400,
+        forwardKeepOrder: endpoint.forwardKeepOrder ?? false,
+        forwardSentField: endpoint.forwardSentField ?? null
+      });
+    })
+  );
+  server.tool(
+    "get_forwarding_secret",
+    "Read (or with rotate: true, replace) the whsec_ secret forwarded deliveries are signed with. Owner only. Treat the value as a credential: put it in the handler's environment, not in code.",
+    {
+      slug: import_zod.z.string().describe("The endpoint slug"),
+      destinationId: import_zod.z.string().optional().describe("A destination (default: the endpoint's primary destination)"),
+      rotate: import_zod.z.boolean().default(false).describe("Replace the secret; every delivery from now on uses the new one")
+    },
+    withErrorHandling(async ({ slug, destinationId, rotate }) => {
+      const secret = destinationId ? rotate ? await client.destinations.rotateSecret(slug, destinationId) : await client.destinations.secret(slug, destinationId) : rotate ? await client.forwarding.rotateSecret(slug) : await client.forwarding.secret(slug);
+      return jsonContent({ secret, rotated: rotate });
+    })
+  );
+  server.tool(
+    "test_forwarding",
+    "Send the endpoint's newest captured request of a kind (or a sample, or requestId) to a destination once, exactly as a delivery would go out, and report the answer. Works whether it is on or off, and whatever its filter says; nothing is retried or logged.",
+    {
+      slug: import_zod.z.string().describe("The endpoint slug"),
+      destinationId: import_zod.z.string().optional().describe("A destination (default: the endpoint's primary destination)"),
+      kind: import_zod.z.enum(["http", "email"]).optional().describe("Which kind to send (default: http when the destination takes HTTP requests)"),
+      requestId: import_zod.z.string().optional().describe("With destinationId: a captured request to send")
+    },
+    withErrorHandling(async ({ slug, destinationId, kind, requestId }) => {
+      if (destinationId) {
+        return jsonContent(
+          await client.destinations.test(slug, destinationId, {
+            ...kind ? { kind } : {},
+            ...requestId ? { requestId } : {}
+          })
+        );
+      }
+      return jsonContent(await client.forwarding.test(slug, kind ? { kind } : {}));
+    })
+  );
+  server.tool(
+    "list_deliveries",
+    "List forwarding deliveries: an endpoint's delivery log with its counts (endpointSlug), or every delivery and try of one captured request or email (requestId). Rows carry senderAt when the request had the sender's own timestamp, so receivedAt - senderAt is the time to reach webhooks.cc.",
+    {
+      endpointSlug: import_zod.z.string().optional().describe("List the endpoint's delivery log"),
+      requestId: import_zod.z.string().optional().describe("List every delivery and try of this request"),
+      limit: import_zod.z.number().int().min(1).max(100).default(20).describe("With endpointSlug: max rows"),
+      status: import_zod.z.enum(["all", "pending", "failed", "skipped"]).default("all").describe(
+        "With endpointSlug: all, pending (queued or retrying), failed or skipped (filtered out)"
+      ),
+      destinationId: import_zod.z.string().optional().describe("With endpointSlug: only this destination"),
+      before: import_zod.z.string().optional().describe("With endpointSlug: a row's cursor, to list older rows")
+    },
+    withErrorHandling(async ({ endpointSlug, requestId, limit, status, destinationId, before }) => {
+      if (requestId === void 0 === (endpointSlug === void 0)) {
+        throw new Error("Pass exactly one of endpointSlug or requestId");
+      }
+      if (requestId) return jsonContent(await client.forwarding.requestDeliveries(requestId));
+      const [summary, deliveries] = await Promise.all([
+        client.forwarding.summary(endpointSlug),
+        client.forwarding.deliveries(endpointSlug, {
+          limit,
+          status,
+          before,
+          ...destinationId ? { destinationId } : {}
+        })
+      ]);
+      return jsonContent({
+        summary,
+        deliveries,
+        nextCursor: deliveries.length === limit ? deliveries[deliveries.length - 1]?.cursor ?? null : null
+      });
+    })
+  );
+  server.tool(
+    "redeliver",
+    "Forward again with the current settings: one captured request or email (requestId; to every destination that takes it, or with destinationId to that one whatever its filter says), or every request whose latest delivery failed (endpointSlug, optionally only destinationId, oldest first, up to 1,000 at a time per destination). Owner only.",
+    {
+      requestId: import_zod.z.string().optional().describe("The request or email to send again"),
+      endpointSlug: import_zod.z.string().optional().describe("Send every failed delivery of this endpoint again"),
+      destinationId: import_zod.z.string().optional().describe("Only this destination")
+    },
+    withErrorHandling(async ({ requestId, endpointSlug, destinationId }) => {
+      if (requestId === void 0 === (endpointSlug === void 0)) {
+        throw new Error("Pass exactly one of requestId or endpointSlug");
+      }
+      const options2 = destinationId ? { destinationId } : {};
+      return jsonContent(
+        requestId ? await client.forwarding.redeliver(requestId, options2) : await client.forwarding.redeliverFailed(endpointSlug, options2)
+      );
+    })
+  );
+  server.tool(
+    "describe",
+    "Describe all available SDK operations, parameters, and types.",
+    {},
+    withErrorHandling(async () => {
+      const description = client.describe();
+      return jsonContent(description);
+    })
+  );
+  return handles;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  REMOTE_MAX_WAIT_MS,
+  REMOTE_MIN_POLL_MS,
+  createEndpointShape,
+  deleteEndpointShape,
+  getEndpointShape,
+  getRequestShape,
+  jsonContent,
+  listEndpointsShape,
+  listRequestsShape,
+  payloadSchemaResult,
+  payloadSchemaShape,
+  registerTools,
+  textContent,
+  waitForRequestShape,
+  withErrorHandling
+});