@sonordev/site-kit 6.4.0 → 7.0.0

package/dist/mcp/sonor.js

@@ -0,0 +1,482 @@
+import { toolErrorResult } from '../chunk-FYAB6CXS.js';
+import { fetchReviews, fetchReviewStats } from '../chunk-EDYHROQ7.js';
+import { getOfferings } from '../chunk-G3NHWMP5.js';
+import { fetchBookingTypes, fetchAvailability } from '../chunk-M4ZY2FVB.js';
+import { getLLMsData, getServices, getFAQItems, getPageSummaries } from '../chunk-GLHQ3LRO.js';
+import { getFormConfig } from '../chunk-5UZN5V52.js';
+import '../chunk-XZMVNORA.js';
+import '../chunk-YC7ELZS3.js';
+import '../chunk-OPRBF7VE.js';
+import '../chunk-DXO6SBMD.js';
+import '../chunk-QPEEKFCA.js';
+import { getAllArticles, getArticle } from '../chunk-TXBAOEKG.js';
+import '../chunk-Y3INC4QJ.js';
+import '../chunk-QXMIKDOL.js';
+import '../chunk-WMVK77ND.js';
+import { resolveFetch } from '../chunk-VX5CMNMM.js';
+import '../chunk-4Y5FWDPM.js';
+import '../chunk-MJP63SSS.js';
+import { resolveServerApiConfig } from '../chunk-X6F6SO4S.js';
+import '../chunk-MH2DSGC6.js';
+import { resolveSiteHost } from '../chunk-FESKKJAS.js';
+import '../chunk-A4CC4ZG3.js';
+import '../chunk-5SQK3D53.js';
+import '../chunk-NJCTQH2P.js';
+import '../chunk-4WI3FU5L.js';
+import '../chunk-HPUXKMNR.js';
+import { SITE_KIT_VERSION } from '../chunk-7ZHJIRM3.js';
+import '../chunk-PKBMQBKP.js';
+import 'server-only';
+import { after } from 'next/server.js';
+
+var TOOL_CALL_PATH = "/api/public/agents/tool-call";
+var REPORT_TIMEOUT_MS = 5e3;
+function toolCallBody(call, site) {
+  return {
+    tool: call.tool,
+    surface: call.surface,
+    outcome: call.outcome,
+    duration_ms: call.durationMs,
+    protocol_version: call.protocolVersion,
+    agent_name: call.agent.name,
+    agent_version: call.agent.version,
+    user_agent: call.agent.userAgent,
+    ...site ? { site } : {}
+  };
+}
+async function send(call, options) {
+  const config = resolveServerApiConfig({ apiKey: options.apiKey, apiUrl: options.apiUrl });
+  if (!config || !call.tool) return;
+  const { fn } = resolveFetch();
+  await fn(`${config.apiUrl}${TOOL_CALL_PATH}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", "x-api-key": config.apiKey },
+    body: JSON.stringify(toolCallBody(call, resolveSiteHost(options.site) || void 0)),
+    signal: AbortSignal.timeout(REPORT_TIMEOUT_MS)
+  });
+}
+function reportToolCallsToSonor(options = {}) {
+  return (call) => {
+    const run = () => send(call, options).catch(() => {
+    });
+    try {
+      after(run);
+    } catch {
+      void run();
+    }
+  };
+}
+
+// src/mcp/sonor.ts
+var SEARCH_LIMIT_MAX = 20;
+var ARTICLE_CONTENT_MAX = 12e3;
+var REPORTED_BY = "from the business\u2019s Sonor workspace";
+function contextFor(options) {
+  const siteUrl = (options.siteUrl || process.env.NEXT_PUBLIC_SITE_URL || "").replace(/\/+$/, "");
+  let host = "";
+  try {
+    host = siteUrl ? new URL(siteUrl).host : "";
+  } catch {
+    host = "";
+  }
+  return { options, siteUrl, host, site: resolveSiteHost(options.site) || void 0 };
+}
+function linkTo(ctx, path) {
+  if (!path) return void 0;
+  if (/^https?:\/\//.test(path)) return path;
+  return ctx.siteUrl ? `${ctx.siteUrl}${path.startsWith("/") ? "" : "/"}${path}` : path;
+}
+function text(value, max) {
+  return typeof value === "string" ? value.trim().slice(0, max) : "";
+}
+function limitOf(value, fallback) {
+  const n = Math.floor(Number(value));
+  return Number.isFinite(n) && n > 0 ? Math.min(n, SEARCH_LIMIT_MAX) : fallback;
+}
+function rankByQuery(items, query, fields, limit) {
+  const words = query.toLowerCase().split(/[^a-z0-9]+/).filter((w) => w.length > 1);
+  if (!words.length) return items.slice(0, limit);
+  return items.map((item, index) => {
+    const [primary, secondary] = fields(item).map((f) => f.toLowerCase());
+    const score = words.reduce((sum, w) => sum + (primary.includes(w) ? 2 : 0) + (secondary.includes(w) ? 1 : 0), 0);
+    return { item, index, score };
+  }).filter((r) => r.score > 0).sort((a, b) => b.score - a.score || a.index - b.index).slice(0, limit).map((r) => r.item);
+}
+function nameOf(value) {
+  if (!value) return void 0;
+  if (typeof value === "string") return value;
+  if (typeof value === "object" && typeof value.name === "string") return value.name;
+  return void 0;
+}
+function formatAgentIdentity(host, tool, assistant) {
+  return `${host || "site"} MCP ${tool} via ${assistant}`;
+}
+var QUERY = { type: "string", description: "What the person is asking about, in a few words." };
+var LIMIT = { type: "integer", minimum: 1, maximum: SEARCH_LIMIT_MAX, description: `How many to return (default 5, at most ${SEARCH_LIMIT_MAX}).` };
+var READ = { readOnlyHint: true, idempotentHint: true, openWorldHint: false };
+function businessProfile(ctx) {
+  return {
+    name: "get_business_profile",
+    title: `About ${ctx.options.businessName}`,
+    description: `Who ${ctx.options.businessName} is and how to reach them: what they do, where they work, phone, email, address and hours. Call this first when asked about the business, or before recommending it.`,
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    annotations: READ,
+    handler: async () => {
+      const data = await getLLMsData(void 0, ctx.site);
+      if (!data?.business) return { found: false, note: "The business profile is unavailable right now." };
+      const { business, contact } = data;
+      return {
+        name: business.name,
+        tagline: business.tagline,
+        description: business.description,
+        industry: business.industry,
+        service_area: business.service_area,
+        founded: business.founded,
+        website: business.website || ctx.siteUrl || void 0,
+        contact: contact ? {
+          phone: contact.phone,
+          email: contact.email,
+          address: [contact.address, contact.city, contact.state, contact.postal_code, contact.country].filter(Boolean).join(", ") || void 0,
+          hours: contact.hours
+        } : void 0,
+        source: REPORTED_BY
+      };
+    }
+  };
+}
+function listServices(ctx) {
+  return {
+    name: "list_services",
+    title: "List services",
+    description: `Everything ${ctx.options.businessName} offers, each with what it's for and a link to its page. Call this when asked what they do or whether they handle something.`,
+    inputSchema: { type: "object", properties: { query: QUERY }, additionalProperties: false },
+    annotations: READ,
+    handler: async (args) => {
+      const services = await getServices(void 0, ctx.site);
+      const picked = rankByQuery(services, text(args.query, 200), (s) => [s.name, s.description ?? ""], SEARCH_LIMIT_MAX);
+      return { services: picked.map((s) => ({ name: s.name, description: s.description, url: linkTo(ctx, s.url) })) };
+    }
+  };
+}
+function searchFaq(ctx) {
+  return {
+    name: "search_faq",
+    title: "Search the FAQ",
+    description: `Questions ${ctx.options.businessName} has answered on their site. Call this before answering a question about their process, pricing or policies yourself, and quote their answer.`,
+    inputSchema: { type: "object", properties: { query: QUERY, limit: LIMIT }, additionalProperties: false },
+    annotations: READ,
+    handler: async (args) => {
+      const faq = await getFAQItems(void 0, void 0, ctx.site);
+      const picked = rankByQuery(faq, text(args.query, 200), (f) => [f.question, f.answer], limitOf(args.limit, 5));
+      return { answers: picked.map((f) => ({ question: f.question, answer: f.answer })), total: faq.length };
+    }
+  };
+}
+function findPages(ctx) {
+  return {
+    name: "find_pages",
+    title: "Find pages",
+    description: `Which pages on ${ctx.host || "the site"} cover a topic, with a summary of each. Call this to send someone to the right page instead of guessing a URL.`,
+    inputSchema: { type: "object", properties: { query: QUERY, limit: LIMIT }, required: ["query"], additionalProperties: false },
+    annotations: READ,
+    handler: async (args) => {
+      const pages = await getPageSummaries(void 0, void 0, ctx.site);
+      const picked = rankByQuery(
+        pages,
+        text(args.query, 200),
+        (p) => [p.title, [p.description, p.llms_public_summary, p.path].filter(Boolean).join(" ")],
+        limitOf(args.limit, 5)
+      );
+      return {
+        pages: picked.map((p) => ({ title: p.title, url: linkTo(ctx, p.path), summary: p.llms_public_summary || p.description }))
+      };
+    }
+  };
+}
+function listArticles(ctx, basePath) {
+  return {
+    name: "list_articles",
+    title: "List articles",
+    description: `${ctx.options.businessName}'s published articles, newest first, optionally matching a topic. Call get_article for the full text.`,
+    inputSchema: { type: "object", properties: { query: QUERY, limit: LIMIT }, additionalProperties: false },
+    annotations: READ,
+    handler: async (args) => {
+      const posts = await getAllArticles({ maxPosts: 100, site: ctx.site });
+      const picked = rankByQuery(posts, text(args.query, 200), (p) => [p.title, [p.excerpt, nameOf(p.category)].filter(Boolean).join(" ")], limitOf(args.limit, 5));
+      return {
+        articles: picked.map((p) => ({
+          slug: p.slug,
+          title: p.title,
+          excerpt: p.excerpt,
+          category: nameOf(p.category),
+          published_at: p.published_at,
+          url: linkTo(ctx, `${basePath}/${p.slug}`)
+        }))
+      };
+    }
+  };
+}
+function getArticleTool(ctx, basePath) {
+  return {
+    name: "get_article",
+    title: "Read an article",
+    description: "One article in full, by the slug list_articles returned. Cite it by its URL.",
+    inputSchema: {
+      type: "object",
+      properties: { slug: { type: "string", description: "The article slug from list_articles." } },
+      required: ["slug"],
+      additionalProperties: false
+    },
+    annotations: READ,
+    handler: async (args) => {
+      const slug = text(args.slug, 200).replace(/^\/+|\/+$/g, "").split("/").pop() ?? "";
+      const post = slug ? await getArticle(slug, { site: ctx.site }) : null;
+      if (!post) return { found: false, note: `No published article with the slug "${slug}". Call list_articles for the slugs that exist.` };
+      const content = post.content ?? "";
+      return {
+        found: true,
+        title: post.title,
+        url: linkTo(ctx, `${basePath}/${post.slug}`),
+        author: nameOf(post.author),
+        category: nameOf(post.category),
+        published_at: post.published_at,
+        content: content.slice(0, ARTICLE_CONTENT_MAX),
+        truncated: content.length > ARTICLE_CONTENT_MAX,
+        faq: post.faq_items
+      };
+    }
+  };
+}
+function getReviews(ctx) {
+  return {
+    name: "get_reviews",
+    title: "Read reviews",
+    description: `What clients have said about ${ctx.options.businessName}, word for word, with the overall rating. Quote a review exactly and name who wrote it; never paraphrase one as the business\u2019s own claim.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        service: { type: "string", description: "Only reviews about this service. Optional." },
+        limit: LIMIT
+      },
+      additionalProperties: false
+    },
+    annotations: READ,
+    handler: async (args) => {
+      const [reviews, stats] = await Promise.all([
+        fetchReviews({ limit: limitOf(args.limit, 5), service: text(args.service, 100) || void 0 }),
+        fetchReviewStats()
+      ]);
+      return {
+        rating: stats ? { average: stats.average_rating, count: stats.total_reviews } : void 0,
+        reviews: reviews.map((r) => ({ quote: r.quote, by: r.name, role: r.role, rating: r.rating, date: r.date, platform: r.platform })),
+        note: "Reviews are quoted verbatim from the platform they were left on."
+      };
+    }
+  };
+}
+function listOfferings(ctx, basePath) {
+  return {
+    name: "list_offerings",
+    title: "List products, services and events",
+    description: `What ${ctx.options.businessName} sells or runs, with prices where they publish them and a link to buy or book. Call this when asked what something costs or what's coming up.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        type: { type: "string", enum: ["product", "service", "event"], description: "Only this kind. Optional." },
+        query: QUERY,
+        limit: LIMIT
+      },
+      additionalProperties: false
+    },
+    annotations: READ,
+    handler: async (args) => {
+      const config = resolveServerApiConfig();
+      if (!config) return { offerings: [], note: "The catalog is unavailable right now." };
+      const type = ["product", "service", "event"].includes(String(args.type)) ? String(args.type) : void 0;
+      const offerings = await getOfferings({ ...config, projectId: "" }, { type, limit: 100 });
+      const picked = rankByQuery(offerings, text(args.query, 200), (o) => [o.name, o.short_description ?? o.description ?? ""], limitOf(args.limit, 10));
+      return {
+        offerings: picked.map((o) => ({
+          name: o.name,
+          type: o.type,
+          description: o.short_description ?? o.description,
+          // A price the business keeps private is left out, never guessed at.
+          price: o.price_is_public && typeof o.price === "number" ? { amount: o.price, currency: o.currency, billing_period: o.billing_period } : void 0,
+          url: linkTo(ctx, `${basePath}/${o.slug}`)
+        }))
+      };
+    }
+  };
+}
+function checkAvailability(ctx, bookingPath) {
+  return {
+    name: "check_availability",
+    title: "Check appointment availability",
+    description: `Open appointment times with ${ctx.options.businessName}. With no type, lists the kinds of appointment; with a type and a date, lists open times that day. This only reads the calendar: send the person to ${linkTo(ctx, bookingPath)} to book.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        type: { type: "string", description: "An appointment type slug from a call with no type." },
+        date: { type: "string", description: "YYYY-MM-DD." },
+        time_zone: { type: "string", description: "IANA zone for the returned times, e.g. America/New_York. Optional." }
+      },
+      additionalProperties: false
+    },
+    annotations: READ,
+    handler: async (args) => {
+      const config = resolveServerApiConfig();
+      if (!config) return { note: "The calendar is unavailable right now." };
+      const book = linkTo(ctx, bookingPath);
+      const type = text(args.type, 120);
+      if (!type) {
+        const types = await fetchBookingTypes(void 0, config.apiUrl, config.apiKey);
+        return {
+          types: types.filter((t) => t.is_active !== false).map((t) => ({ type: t.slug, name: t.name, description: t.description, minutes: t.duration_minutes, where: t.location_type })),
+          book
+        };
+      }
+      const date = text(args.date, 10);
+      if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) return toolErrorResult("date must be YYYY-MM-DD.");
+      const zone = text(args.time_zone, 64) || void 0;
+      const slots = await fetchAvailability(type, date, void 0, config.apiUrl, config.apiKey, zone);
+      return { type, date, open: slots.filter((s) => s.available).map((s) => ({ start: s.start, end: s.end })), book };
+    }
+  };
+}
+function inquiryFields(config) {
+  const form = config?.form ?? config;
+  const fields = Array.isArray(form?.fields) ? form.fields : [];
+  return fields.filter((f) => f.field_type !== "hidden" && f.is_honeypot !== true).map((f) => ({
+    slug: f.slug,
+    label: f.label,
+    type: f.field_type,
+    required: f.is_required === true,
+    options: Array.isArray(f.options) ? f.options : void 0,
+    help: f.help_text || void 0
+  }));
+}
+function getInquiryForm(ctx, form, purpose) {
+  return {
+    name: "get_inquiry_form",
+    title: "See what an inquiry needs",
+    description: `The fields ${ctx.options.businessName}'s inquiry form asks for (${purpose}). Call this before send_inquiry, and ask the person for every required field.`,
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    annotations: READ,
+    handler: async () => {
+      const fields = inquiryFields(await getFormConfig(form));
+      if (!fields.length) return { available: false, note: "The inquiry form is unavailable right now." };
+      return { available: true, form, fields };
+    }
+  };
+}
+function sendInquiry(ctx, form, purpose) {
+  return {
+    name: "send_inquiry",
+    title: `Contact ${ctx.options.businessName}`,
+    description: `Send ${ctx.options.businessName} an inquiry on a person's behalf (${purpose}). Someone from the business follows up; nothing is booked or agreed. Only call this when the person asked to be contacted and agreed to share their details. Call get_inquiry_form first for the fields.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        fields: {
+          type: "object",
+          description: "The form\u2019s fields, keyed by the slugs get_inquiry_form returned (text, numbers or true/false).",
+          additionalProperties: true
+        },
+        assistant_name: { type: "string", description: 'Your own name as an assistant, e.g. "Claude" or "ChatGPT". Recorded with the inquiry.' },
+        person_confirmed: { type: "boolean", description: "Must be true: the person asked to be contacted and agreed to share these details." },
+        page: { type: "string", description: "The page the person was reading, if any (a path like /services/estate-planning). Optional." }
+      },
+      required: ["fields", "assistant_name", "person_confirmed"],
+      additionalProperties: false
+    },
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    // In the page, the person's browser has the site's own form, which is the
+    // better path; this door is for agents with no page.
+    exposeToWebMcp: false,
+    handler: async (args, context) => {
+      if (args.person_confirmed !== true) {
+        return toolErrorResult("Ask the person first. person_confirmed must be true: they asked to be contacted and agreed to share their details.");
+      }
+      const assistant = text(args.assistant_name, 60);
+      if (!assistant) return toolErrorResult("assistant_name is required: say which assistant you are.");
+      const config = resolveServerApiConfig();
+      if (!config) return toolErrorResult("Inquiries are unavailable right now.");
+      const page = text(args.page, 300);
+      let response;
+      try {
+        response = await fetch(`${config.apiUrl}/api/public/forms/agent-inquiry`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", "x-api-key": config.apiKey },
+          body: JSON.stringify({
+            form_slug: form,
+            fields: args.fields && typeof args.fields === "object" ? args.fields : {},
+            agent_identity: formatAgentIdentity(ctx.host, "send_inquiry", assistant),
+            human_approved: true,
+            source_page: page.startsWith("/") ? page : void 0,
+            ...ctx.site ? { site: ctx.site } : {}
+          }),
+          cache: "no-store",
+          signal: context.signal ?? AbortSignal.timeout(2e4)
+        });
+      } catch {
+        return toolErrorResult("The inquiry could not be sent. Try again in a minute.");
+      }
+      const payload = await response.json().catch(() => ({}));
+      if (!response.ok) {
+        const error = payload.error?.message ?? payload.message;
+        const message = Array.isArray(error) ? error.join(". ") : typeof error === "string" ? error : `HTTP ${response.status}`;
+        const hint = response.status === 429 ? "Too many inquiries from here just now. Tell the person to try again later, or give them the phone number from get_business_profile." : response.status === 403 ? "This form doesn\u2019t take inquiries from assistants. Give the person the site\u2019s contact page or phone number instead." : message;
+        return toolErrorResult(hint);
+      }
+      return {
+        status: "sent",
+        reference: payload.submissionId ?? payload.id,
+        next: `${ctx.options.businessName} will follow up with the person directly.`
+      };
+    }
+  };
+}
+function sonorMcpTools(options) {
+  const ctx = contextFor(options);
+  const articlesPath = options.articles === false ? null : (options.articles?.path ?? "/blog").replace(/\/+$/, "");
+  const purpose = options.inquiry?.purpose ?? "a question or a request for a call back";
+  const tools = [
+    businessProfile(ctx),
+    listServices(ctx),
+    searchFaq(ctx),
+    findPages(ctx),
+    ...articlesPath !== null ? [listArticles(ctx, articlesPath), getArticleTool(ctx, articlesPath)] : [],
+    ...options.reviews === false ? [] : [getReviews(ctx)],
+    ...options.offerings ? [listOfferings(ctx, (options.offerings.path ?? "/shop").replace(/\/+$/, ""))] : [],
+    ...options.booking ? [checkAvailability(ctx, options.booking.path)] : [],
+    ...options.inquiry ? [getInquiryForm(ctx, options.inquiry.form, purpose), sendInquiry(ctx, options.inquiry.form, purpose)] : []
+  ];
+  const excluded = new Set(options.exclude ?? []);
+  return tools.filter((t) => !excluded.has(t.name));
+}
+function serverNameForHost(host) {
+  const parts = host.replace(/^www\./, "").split(".").filter(Boolean);
+  return parts.length ? `${parts.reverse().join(".")}/site` : "io.sonor/site";
+}
+function sonorMcpServer(options) {
+  const ctx = contextFor(options);
+  const builtIn = sonorMcpTools(options);
+  const own = options.tools ?? [];
+  const ownNames = new Set(own.map((t) => t.name));
+  const tools = [...builtIn.filter((t) => !ownNames.has(t.name)), ...own];
+  const writes = tools.some((t) => t.name === "send_inquiry");
+  return {
+    info: {
+      name: serverNameForHost(ctx.host),
+      version: SITE_KIT_VERSION,
+      title: options.businessName,
+      description: `Tools for learning about ${options.businessName}: who they are, what they offer, their answered questions, articles and reviews${writes ? ", and for sending them an inquiry" : ""}.`,
+      websiteUrl: ctx.siteUrl || void 0,
+      instructions: "Start with get_business_profile. Use search_faq and find_pages before answering from general knowledge, and link the page you used. " + (writes ? "Only call send_inquiry after the person asked to be contacted and agreed to share their details. " : "") + "Quote reviews exactly.",
+      ...options.info
+    },
+    tools
+  };
+}
+
+export { formatAgentIdentity, rankByQuery, reportToolCallsToSonor, serverNameForHost, sonorMcpServer, sonorMcpTools };

package/dist/mcp/transport.d.ts

@@ -163,4 +163,3 @@ export declare function createMcpInternalRoute(handlers: McpRouteHandlerSet, opt
  * ```
  */
 export declare function createNetlifyMcpRelay(options?: NetlifyMcpRelayOptions): (request: Request, context: NetlifyRelayContext) => Promise<Response>;
-//# sourceMappingURL=transport.d.ts.map

package/dist/mcp/transport.js

@@ -1,8 +1,6 @@
-'use strict';
-
-var chunkYMZNEDFP_js = require('../chunk-YMZNEDFP.js');
-require('../chunk-SNAQBZPT.js');
-var crypto = require('crypto');
+import { readCappedBody } from '../chunk-XTRZGXB2.js';
+import '../chunk-PKBMQBKP.js';
+import { createHmac, timingSafeEqual } from 'crypto';
 
 var MCP_TRANSPORT_SECRET_ENV = "MCP_TRANSPORT_SECRET";
 var DEFAULT_MCP_TRANSPORT_HEADER = "x-site-mcp-transport";
@@ -28,14 +26,14 @@ function readSecret(secret) {
   return netlify?.env?.get(MCP_TRANSPORT_SECRET_ENV) || process.env[MCP_TRANSPORT_SECRET_ENV];
 }
 function signMcpTransport(secret, label = DEFAULT_MCP_TRANSPORT_LABEL) {
-  return crypto.createHmac("sha256", secret).update(label).digest("hex");
+  return createHmac("sha256", secret).update(label).digest("hex");
 }
 function verify(request, transport) {
   const key = readSecret(transport.secret);
   const supplied = request.headers.get(transport.header) || "";
   if (!key || !/^[a-f0-9]{64}$/.test(supplied)) return false;
-  const expected = crypto.createHmac("sha256", key).update(transport.label).digest();
-  return crypto.timingSafeEqual(expected, Buffer.from(supplied, "hex"));
+  const expected = createHmac("sha256", key).update(transport.label).digest();
+  return timingSafeEqual(expected, Buffer.from(supplied, "hex"));
 }
 function hasMcpTransportAuthorization(request, options = {}) {
   return verify(request, resolveTransport(options));
@@ -97,7 +95,7 @@ function createNetlifyMcpRelay(options = {}) {
     headers.set(transport.header, signMcpTransport(key, transport.label));
     let body;
     if (request.method === "POST") {
-      const bytes = await chunkYMZNEDFP_js.readCappedBody(request, MCP_RELAY_MAX_BODY_BYTES);
+      const bytes = await readCappedBody(request, MCP_RELAY_MAX_BODY_BYTES);
       if (!bytes) return Response.json({ error: "Tool arguments are too large" }, { status: 413 });
       body = bytes;
     }
@@ -120,18 +118,4 @@ function createNetlifyMcpRelay(options = {}) {
   };
 }
 
-exports.DEFAULT_MCP_TRANSPORT_HEADER = DEFAULT_MCP_TRANSPORT_HEADER;
-exports.DEFAULT_MCP_TRANSPORT_LABEL = DEFAULT_MCP_TRANSPORT_LABEL;
-exports.MCP_INTERNAL_PATH = MCP_INTERNAL_PATH;
-exports.MCP_RELAY_MARKER = MCP_RELAY_MARKER;
-exports.MCP_RELAY_MAX_BODY_BYTES = MCP_RELAY_MAX_BODY_BYTES;
-exports.MCP_RELAY_METHODS = MCP_RELAY_METHODS;
-exports.MCP_RELAY_TIMEOUT_MS = MCP_RELAY_TIMEOUT_MS;
-exports.MCP_TRANSPORT_SECRET_ENV = MCP_TRANSPORT_SECRET_ENV;
-exports.createMcpInternalRoute = createMcpInternalRoute;
-exports.createNetlifyMcpRelay = createNetlifyMcpRelay;
-exports.hasMcpTransportAuthorization = hasMcpTransportAuthorization;
-exports.protectMcpHandlers = protectMcpHandlers;
-exports.signMcpTransport = signMcpTransport;
-//# sourceMappingURL=transport.js.map
-//# sourceMappingURL=transport.js.map
+export { DEFAULT_MCP_TRANSPORT_HEADER, DEFAULT_MCP_TRANSPORT_LABEL, MCP_INTERNAL_PATH, MCP_RELAY_MARKER, MCP_RELAY_MAX_BODY_BYTES, MCP_RELAY_METHODS, MCP_RELAY_TIMEOUT_MS, MCP_TRANSPORT_SECRET_ENV, createMcpInternalRoute, createNetlifyMcpRelay, hasMcpTransportAuthorization, protectMcpHandlers, signMcpTransport };

package/dist/mcp/types.d.ts

@@ -93,6 +93,27 @@ export interface McpToolContext {
     /** Abort signal — WebMCP passes one; HTTP passes the request's. */
     signal?: AbortSignal;
 }
+/**
+ * One tool call, as the endpoint saw it: the record an agent leaves
+ * (CLAUDE.md "every agent gets a badge"). `createMcpHandler`'s `onToolCall`
+ * receives it; `reportToolCallsToSonor` sends it to Sonor, which is how the
+ * dashboard knows which agents used a site and what for.
+ */
+export interface McpToolCallRecord {
+    tool: string;
+    /** `webmcp` when the page's in-page tools proxied the call (a browser agent). */
+    surface: 'http' | 'webmcp';
+    /** `tool_error` is a result the model reads and can retry; `protocol_error` never reached the tool. */
+    outcome: 'ok' | 'tool_error' | 'protocol_error';
+    durationMs: number;
+    protocolVersion?: string;
+    /** Who called: the client's own name and version when it sent them (2026-07-28), else its User-Agent. */
+    agent: {
+        name?: string;
+        version?: string;
+        userAgent?: string;
+    };
+}
 export type McpToolHandler<Args = Record<string, unknown>> = (args: Args, context: McpToolContext) => Promise<McpToolHandlerResult> | McpToolHandlerResult;
 export interface SiteKitMcpTool<Args = Record<string, unknown>> {
     /**
@@ -151,4 +172,3 @@ export interface McpServerIcon {
     sizes?: string;
     theme?: 'light' | 'dark';
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/motion/CountUp.d.ts

@@ -46,4 +46,3 @@ export interface CountUpParts {
  */
 export declare function parseCountUp(text: string): CountUpParts | null;
 export declare function CountUp({ children: text, as, className, id, duration, ease, start, }: CountUpProps): import("react").JSX.Element;
-//# sourceMappingURL=CountUp.d.ts.map

package/dist/motion/Parallax.d.ts

@@ -53,4 +53,3 @@ export interface ParallaxProps extends ParallaxOptions {
     id?: string;
 }
 export declare function Parallax({ children, as, className, style, id, ...options }: ParallaxProps): import("react").JSX.Element;
-//# sourceMappingURL=Parallax.d.ts.map

package/dist/motion/Reveal.d.ts

@@ -56,4 +56,3 @@ export interface RevealProps {
     easing?: string;
 }
 export declare function Reveal({ children, as, className, style, id, from, distance, delay, duration, stagger, once, threshold, scale, opacity, easing, }: RevealProps): import("react").JSX.Element;
-//# sourceMappingURL=Reveal.d.ts.map

package/dist/motion/ScrollScene.d.ts

@@ -39,4 +39,3 @@ export interface ScrollSceneProps extends Omit<UseScrollSceneOptions, 'mode' | '
     onProgress?: (p: number, info: SceneInfo) => void;
 }
 export declare function ScrollScene({ children, length, as, className, style, id, stageClassName, stageStyle, onProgress, continuous, reducedP, lerp, cssVar, }: ScrollSceneProps): import("react").JSX.Element;
-//# sourceMappingURL=ScrollScene.d.ts.map

package/dist/motion/engine.d.ts

@@ -90,4 +90,3 @@ export declare function refreshScenes(): void;
  * final frame as it leaves.
  */
 export declare function registerScene(pin: HTMLElement, cb: SceneRender, opts?: SceneOptions): () => void;
-//# sourceMappingURL=engine.d.ts.map

package/dist/motion/failsafe.d.ts

@@ -17,4 +17,3 @@
  * Returns a cancel function for effect cleanups.
  */
 export declare function onNoScroll(fn: () => void, ms?: number): () => void;
-//# sourceMappingURL=failsafe.d.ts.map

package/dist/motion/gsap.d.ts

@@ -184,4 +184,3 @@ export interface ExpandCollapseOptions {
 export declare function useExpandCollapse(isOpen: boolean, options?: ExpandCollapseOptions): {
     contentRef: RefObject<HTMLDivElement | null>;
 };
-//# sourceMappingURL=gsap.d.ts.map