@sonordev/site-kit 6.5.0 → 7.0.1

package/dist/mcp/index.js

@@ -1,276 +1,12 @@
-'use strict';
-
-require('../chunk-SNAQBZPT.js');
+import { MCP_SUPPORTED_PROTOCOL_VERSIONS, dispatch, errorOutcome, JSONRPC_INVALID_REQUEST, META_CLIENT_INFO, JSONRPC_PARSE_ERROR, MCP_PROTOCOL_VERSION_MODERN } from '../chunk-FYAB6CXS.js';
+export { JSONRPC_METHOD_NOT_FOUND, MCP_ERROR_HEADER_MISMATCH, MCP_ERROR_UNSUPPORTED_PROTOCOL_VERSION, MCP_PROTOCOL_VERSIONS_LEGACY, MCP_PROTOCOL_VERSION_MODERN, MCP_SUPPORTED_PROTOCOL_VERSIONS, META_CLIENT_INFO, META_PROTOCOL_VERSION, META_SERVER_INFO, dispatch, isSupportedVersion, toToolDescriptor, toToolResult, toolErrorResult, validateArgs } from '../chunk-FYAB6CXS.js';
+import '../chunk-PKBMQBKP.js';
 
 // src/mcp/types.ts
 function defineMcpTool(tool) {
   return tool;
 }
 
-// src/mcp/protocol.ts
-var MCP_PROTOCOL_VERSION_MODERN = "2026-07-28";
-var MCP_PROTOCOL_VERSIONS_LEGACY = ["2025-11-25", "2025-06-18", "2025-03-26"];
-var MCP_SUPPORTED_PROTOCOL_VERSIONS = [
-  MCP_PROTOCOL_VERSION_MODERN,
-  ...MCP_PROTOCOL_VERSIONS_LEGACY
-];
-var META_PROTOCOL_VERSION = "io.modelcontextprotocol/protocolVersion";
-var META_CLIENT_INFO = "io.modelcontextprotocol/clientInfo";
-var META_SERVER_INFO = "io.modelcontextprotocol/serverInfo";
-var JSONRPC_PARSE_ERROR = -32700;
-var JSONRPC_INVALID_REQUEST = -32600;
-var JSONRPC_METHOD_NOT_FOUND = -32601;
-var JSONRPC_INVALID_PARAMS = -32602;
-var MCP_ERROR_HEADER_MISMATCH = -32020;
-var MCP_ERROR_UNSUPPORTED_PROTOCOL_VERSION = -32022;
-var MAX_JSON_TEXT = 6e4;
-function isToolResult(value) {
-  return typeof value === "object" && value !== null && Array.isArray(value.content);
-}
-function toToolResult(value) {
-  if (isToolResult(value)) return value;
-  if (typeof value === "string") {
-    return { content: [{ type: "text", text: value }] };
-  }
-  if (value === void 0 || value === null) {
-    return { content: [{ type: "text", text: "(no result)" }] };
-  }
-  let text;
-  try {
-    text = JSON.stringify(value, null, 2);
-  } catch {
-    text = String(value);
-  }
-  if (text.length > MAX_JSON_TEXT) {
-    text = `${text.slice(0, MAX_JSON_TEXT)}
-\u2026 (truncated)`;
-  }
-  return {
-    content: [{ type: "text", text }],
-    structuredContent: value
-  };
-}
-function toolErrorResult(message) {
-  return { content: [{ type: "text", text: message }], isError: true };
-}
-function toToolDescriptor(tool) {
-  const descriptor = {
-    name: tool.name,
-    description: tool.description,
-    inputSchema: tool.inputSchema
-  };
-  if (tool.title) descriptor.title = tool.title;
-  if (tool.outputSchema) descriptor.outputSchema = tool.outputSchema;
-  if (tool.annotations) descriptor.annotations = tool.annotations;
-  return descriptor;
-}
-function validateArgs(tool, args) {
-  const required = tool.inputSchema.required ?? [];
-  const missing = required.filter((key) => {
-    const value = args[key];
-    return value === void 0 || value === null || value === "";
-  });
-  if (missing.length > 0) {
-    return `Missing required argument${missing.length > 1 ? "s" : ""}: ${missing.join(", ")}.`;
-  }
-  for (const [key, schema] of Object.entries(tool.inputSchema.properties ?? {})) {
-    const value = args[key];
-    if (value === void 0 || value === null) continue;
-    if (schema.enum && !schema.enum.includes(value)) {
-      return `Invalid value for "${key}": ${JSON.stringify(value)}. Expected one of: ${schema.enum.map((v) => JSON.stringify(v)).join(", ")}.`;
-    }
-  }
-  return null;
-}
-function capabilities() {
-  return { tools: { listChanged: false } };
-}
-function serverInfoBlock(info) {
-  return { name: info.name, version: info.version, ...info.title ? { title: info.title } : {} };
-}
-function isSupportedVersion(version) {
-  return MCP_SUPPORTED_PROTOCOL_VERSIONS.includes(version);
-}
-function unsupportedVersionError(id, requested) {
-  return {
-    status: 400,
-    response: {
-      jsonrpc: "2.0",
-      id,
-      error: {
-        code: MCP_ERROR_UNSUPPORTED_PROTOCOL_VERSION,
-        message: "Unsupported protocol version",
-        data: { supported: [...MCP_SUPPORTED_PROTOCOL_VERSIONS], requested }
-      }
-    }
-  };
-}
-function errorOutcome(id, code, message, status, data) {
-  return {
-    status,
-    response: { jsonrpc: "2.0", id, error: { code, message, ...data ? { data } : {} } }
-  };
-}
-async function dispatch(message, options) {
-  const { server } = options;
-  const id = message.id ?? null;
-  const isNotification = message.id === void 0;
-  const params = message.params ?? {};
-  const meta = params._meta ?? {};
-  const bodyVersion = typeof meta[META_PROTOCOL_VERSION] === "string" ? meta[META_PROTOCOL_VERSION] : null;
-  const headerVersion = options.headerProtocolVersion || null;
-  if (bodyVersion && headerVersion && bodyVersion !== headerVersion) {
-    return errorOutcome(
-      id,
-      MCP_ERROR_HEADER_MISMATCH,
-      `Header mismatch: MCP-Protocol-Version header value '${headerVersion}' does not match body value '${bodyVersion}'`,
-      400
-    );
-  }
-  const requestedVersion = bodyVersion || headerVersion;
-  if (requestedVersion && !isSupportedVersion(requestedVersion)) {
-    return unsupportedVersionError(id, requestedVersion);
-  }
-  if (options.headerMethod && options.headerMethod !== message.method) {
-    return errorOutcome(
-      id,
-      MCP_ERROR_HEADER_MISMATCH,
-      `Header mismatch: Mcp-Method header value '${options.headerMethod}' does not match body value '${message.method}'`,
-      400
-    );
-  }
-  if (options.headerName) {
-    const bodyName = typeof params.name === "string" ? params.name : typeof params.uri === "string" ? params.uri : null;
-    if (bodyName && options.headerName !== bodyName) {
-      return errorOutcome(
-        id,
-        MCP_ERROR_HEADER_MISMATCH,
-        `Header mismatch: Mcp-Name header value '${options.headerName}' does not match body value '${bodyName}'`,
-        400
-      );
-    }
-  }
-  if (options.strictHeaders && bodyVersion) {
-    if (!headerVersion) {
-      return errorOutcome(
-        id,
-        MCP_ERROR_HEADER_MISMATCH,
-        "Header mismatch: required MCP-Protocol-Version header is missing",
-        400
-      );
-    }
-    if (!options.headerMethod) {
-      return errorOutcome(
-        id,
-        MCP_ERROR_HEADER_MISMATCH,
-        "Header mismatch: required Mcp-Method header is missing",
-        400
-      );
-    }
-  }
-  const negotiated = requestedVersion || MCP_PROTOCOL_VERSION_MODERN;
-  switch (message.method) {
-    // ── Modern discovery (MUST implement) ──────────────────────────────────
-    case "server/discover": {
-      return {
-        status: 200,
-        response: {
-          jsonrpc: "2.0",
-          id,
-          result: {
-            resultType: "complete",
-            supportedVersions: [...MCP_SUPPORTED_PROTOCOL_VERSIONS],
-            capabilities: capabilities(),
-            ...server.info.instructions ? { instructions: server.info.instructions } : {},
-            ttlMs: server.discoverTtlMs ?? 36e5,
-            cacheScope: "public",
-            _meta: { [META_SERVER_INFO]: serverInfoBlock(server.info) }
-          }
-        }
-      };
-    }
-    // ── Legacy handshake ───────────────────────────────────────────────────
-    case "initialize": {
-      const asked = typeof params.protocolVersion === "string" ? params.protocolVersion : "";
-      const agreed = isSupportedVersion(asked) ? asked : MCP_PROTOCOL_VERSIONS_LEGACY[0];
-      return {
-        status: 200,
-        response: {
-          jsonrpc: "2.0",
-          id,
-          result: {
-            protocolVersion: agreed,
-            capabilities: capabilities(),
-            serverInfo: serverInfoBlock(server.info),
-            ...server.info.instructions ? { instructions: server.info.instructions } : {}
-          }
-        }
-      };
-    }
-    case "notifications/initialized":
-    case "initialized":
-      return { status: 202, response: null };
-    case "ping":
-      return { status: 200, response: { jsonrpc: "2.0", id, result: {} } };
-    // ── Tools ──────────────────────────────────────────────────────────────
-    case "tools/list": {
-      const tools = server.tools.filter((t) => t.exposeToHttp !== false).map((t) => toToolDescriptor(t));
-      return { status: 200, response: { jsonrpc: "2.0", id, result: { tools } } };
-    }
-    case "tools/call": {
-      const name = typeof params.name === "string" ? params.name : "";
-      const tool = server.tools.find((t) => t.name === name && t.exposeToHttp !== false);
-      if (!tool) {
-        return errorOutcome(
-          id,
-          JSONRPC_INVALID_PARAMS,
-          `Unknown tool: ${name || "(none)"}`,
-          400,
-          {
-            available: server.tools.filter((t) => t.exposeToHttp !== false).map((t) => t.name)
-          }
-        );
-      }
-      const args = params.arguments ?? {};
-      const invalid = validateArgs(tool, args);
-      if (invalid) {
-        return {
-          status: 200,
-          response: { jsonrpc: "2.0", id, result: toolErrorResult(invalid) }
-        };
-      }
-      try {
-        const raw = await tool.handler(args, {
-          ...options.context,
-          surface: "http",
-          protocolVersion: negotiated
-        });
-        return { status: 200, response: { jsonrpc: "2.0", id, result: toToolResult(raw) } };
-      } catch (error) {
-        const detail = error instanceof Error ? error.message : String(error);
-        return {
-          status: 200,
-          response: {
-            jsonrpc: "2.0",
-            id,
-            result: toolErrorResult(`Tool "${tool.name}" failed: ${detail}`)
-          }
-        };
-      }
-    }
-    // Declared unsupported rather than left to fall through, so the error names
-    // the reason instead of looking like a typo'd method.
-    case "resources/list":
-      return { status: 200, response: { jsonrpc: "2.0", id, result: { resources: [] } } };
-    case "prompts/list":
-      return { status: 200, response: { jsonrpc: "2.0", id, result: { prompts: [] } } };
-    default: {
-      if (isNotification) return { status: 202, response: null };
-      return errorOutcome(id, JSONRPC_METHOD_NOT_FOUND, `Method not found: ${message.method}`, 404);
-    }
-  }
-}
-
 // src/mcp/serverCard.ts
 var MCP_SERVER_CARD_SCHEMA = "https://static.modelcontextprotocol.io/schemas/v1/server-card.schema.json";
 var MCP_SERVER_CARD_PATH = "/.well-known/mcp-server-card";
@@ -343,7 +79,9 @@ var MCP_REQUEST_HEADERS = [
   "Mcp-Method",
   "Mcp-Name",
   "Mcp-Session-Id",
-  "Last-Event-ID"
+  "Last-Event-ID",
+  // WebMcpTools marks the calls it proxies (WEBMCP_SURFACE_HEADER).
+  "x-sk-webmcp"
 ];
 function corsHeaders(origin) {
   return {
@@ -369,6 +107,41 @@ function decodeHeaderValue(value) {
     return value;
   }
 }
+var WEBMCP_SURFACE_HEADER = "x-sk-webmcp";
+function agentOf(message, request) {
+  const params = message.params ?? {};
+  const meta = params._meta ?? {};
+  const info = meta[META_CLIENT_INFO];
+  const userAgent = request.headers.get("user-agent")?.slice(0, 256) || void 0;
+  return {
+    name: typeof info?.name === "string" ? info.name.slice(0, 120) : userAgent?.split(/[\s/]/)[0]?.slice(0, 120) || void 0,
+    version: typeof info?.version === "string" ? info.version.slice(0, 60) : void 0,
+    userAgent
+  };
+}
+function toolCallRecord(message, outcome, request, durationMs, protocolVersion) {
+  if (!message || message.method !== "tools/call") return null;
+  const params = message.params ?? {};
+  const result = outcome.response && "result" in outcome.response ? outcome.response.result : void 0;
+  const failed = !outcome.response || "error" in outcome.response;
+  return {
+    tool: typeof params.name === "string" ? params.name.slice(0, 120) : "",
+    surface: request.headers.get(WEBMCP_SURFACE_HEADER) === "1" ? "webmcp" : "http",
+    outcome: failed ? "protocol_error" : result?.isError ? "tool_error" : "ok",
+    durationMs: Math.max(0, Math.round(durationMs)),
+    protocolVersion: protocolVersion || void 0,
+    agent: agentOf(message, request)
+  };
+}
+function notifyToolCall(options, record) {
+  if (!record || !options.onToolCall) return;
+  try {
+    const pending = options.onToolCall(record);
+    if (pending && typeof pending.catch === "function") pending.catch(() => {
+    });
+  } catch {
+  }
+}
 function resolveOrigin(request, allowed) {
   const origin = request.headers.get("origin");
   if (!allowed || allowed === "*") return "*";
@@ -424,7 +197,12 @@ function createMcpHandler(options) {
     };
     if (Array.isArray(payload)) {
       const outcomes = await Promise.all(
-        payload.map((m) => dispatch(m, dispatchOptions))
+        payload.map(async (m) => {
+          const startedAt2 = performance.now();
+          const outcome2 = await dispatch(m, dispatchOptions);
+          notifyToolCall(options, toolCallRecord(m, outcome2, request, performance.now() - startedAt2, headerProtocolVersion));
+          return outcome2;
+        })
       );
       const responses = outcomes.map((o) => o.response).filter(Boolean);
       if (responses.length === 0) return new Response(null, { status: 202, headers: cors });
@@ -438,7 +216,9 @@ function createMcpHandler(options) {
       const bad = errorOutcome(null, JSONRPC_INVALID_REQUEST, "Invalid Request", 400);
       return json(bad.response, bad.status, cors);
     }
+    const startedAt = performance.now();
     const outcome = await dispatch(message, dispatchOptions);
+    notifyToolCall(options, toolCallRecord(message, outcome, request, performance.now() - startedAt, headerProtocolVersion));
     if (outcome.response === null) {
       return new Response(null, { status: 202, headers: cors });
     }
@@ -506,32 +286,4 @@ function declarativeToolField(description) {
   return { toolparamdescription: description };
 }
 
-exports.JSONRPC_METHOD_NOT_FOUND = JSONRPC_METHOD_NOT_FOUND;
-exports.MCP_ERROR_HEADER_MISMATCH = MCP_ERROR_HEADER_MISMATCH;
-exports.MCP_ERROR_UNSUPPORTED_PROTOCOL_VERSION = MCP_ERROR_UNSUPPORTED_PROTOCOL_VERSION;
-exports.MCP_PROTOCOL_VERSIONS_LEGACY = MCP_PROTOCOL_VERSIONS_LEGACY;
-exports.MCP_PROTOCOL_VERSION_MODERN = MCP_PROTOCOL_VERSION_MODERN;
-exports.MCP_SERVER_CARD_LEGACY_PATH = MCP_SERVER_CARD_LEGACY_PATH;
-exports.MCP_SERVER_CARD_PATH = MCP_SERVER_CARD_PATH;
-exports.MCP_SERVER_CARD_SCHEMA = MCP_SERVER_CARD_SCHEMA;
-exports.MCP_SUPPORTED_PROTOCOL_VERSIONS = MCP_SUPPORTED_PROTOCOL_VERSIONS;
-exports.META_CLIENT_INFO = META_CLIENT_INFO;
-exports.META_PROTOCOL_VERSION = META_PROTOCOL_VERSION;
-exports.META_SERVER_INFO = META_SERVER_INFO;
-exports.SITE_KIT_CARD_META_KEY = SITE_KIT_CARD_META_KEY;
-exports.buildMcpServerCard = buildMcpServerCard;
-exports.createMcpHandler = createMcpHandler;
-exports.createMcpServerCardHandler = createMcpServerCardHandler;
-exports.declarativeToolField = declarativeToolField;
-exports.declarativeToolForm = declarativeToolForm;
-exports.decodeHeaderValue = decodeHeaderValue;
-exports.defineMcpTool = defineMcpTool;
-exports.dispatch = dispatch;
-exports.isSupportedVersion = isSupportedVersion;
-exports.toToolDescriptor = toToolDescriptor;
-exports.toToolResult = toToolResult;
-exports.toolErrorResult = toolErrorResult;
-exports.validateArgs = validateArgs;
-exports.validateMcpServerCard = validateMcpServerCard;
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+export { MCP_SERVER_CARD_LEGACY_PATH, MCP_SERVER_CARD_PATH, MCP_SERVER_CARD_SCHEMA, SITE_KIT_CARD_META_KEY, WEBMCP_SURFACE_HEADER, buildMcpServerCard, createMcpHandler, createMcpServerCardHandler, declarativeToolField, declarativeToolForm, decodeHeaderValue, defineMcpTool, toolCallRecord, validateMcpServerCard };

package/dist/mcp/protocol.d.ts

@@ -137,4 +137,3 @@ export interface DispatchOptions {
     strictHeaders?: boolean;
 }
 export declare function dispatch(message: JsonRpcRequest, options: DispatchOptions): Promise<DispatchOutcome>;
-//# sourceMappingURL=protocol.d.ts.map

package/dist/mcp/report.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Sends each MCP tool call to Sonor, so the dashboard can say which agents
+ * used a site, which tools, and whether they worked (CLAUDE.md "every agent
+ * gets a badge": the record carries the agent's own name).
+ *
+ * Fire-and-forget, after the response: Next's `after()` keeps a serverless
+ * function alive for it without the agent waiting. It carries no person's
+ * data, only the tool's name, how it went and who called (the client's name
+ * and version, or its User-Agent). Nothing a tool was asked or answered.
+ */
+import 'server-only';
+import type { McpToolCallRecord } from './types';
+export interface ReportToolCallsOptions {
+    /** Sub-site host on a multi-site project. Default: resolved from NEXT_PUBLIC_SITE_URL. */
+    site?: string;
+    /** Default: SONOR_API_KEY. */
+    apiKey?: string;
+    /** Default: SONOR_API_URL or https://api.sonor.io. */
+    apiUrl?: string;
+}
+/** The body Sonor's tool-call ingest takes. */
+export declare function toolCallBody(call: McpToolCallRecord, site: string | undefined): Record<string, unknown>;
+/**
+ * An `onToolCall` for createMcpHandler that reports to Sonor. A failed report
+ * is dropped silently: it must never cost the agent anything.
+ */
+export declare function reportToolCallsToSonor(options?: ReportToolCallsOptions): (call: McpToolCallRecord) => void;

package/dist/mcp/serverCard.d.ts

@@ -74,4 +74,3 @@ export declare function buildMcpServerCard(options: BuildMcpServerCardOptions):
  * Used by the module's tests and worth calling in a site's own build check.
  */
 export declare function validateMcpServerCard(card: McpServerCard): string[];
-//# sourceMappingURL=serverCard.d.ts.map

package/dist/mcp/sonor.d.ts

@@ -0,0 +1,99 @@
+/**
+ * @sonordev/site-kit/mcp/sonor — the tools every Sonor site can give an agent,
+ * with no code of its own.
+ *
+ * Ten sites wrote the same MCP tools by hand (firm info, practice areas, FAQ
+ * search, reviews), each a copy of data Sonor already serves. These are those
+ * tools once, as thin wrappers over the fetchers the site's own pages use
+ * (llms, articles, reputation, commerce, sync, forms), so an agent reads what
+ * a visitor reads and nothing drifts:
+ *
+ *   get_business_profile  who the business is, how to reach it, hours, area
+ *   list_services         what it offers, with links
+ *   search_faq            its answered questions
+ *   find_pages            which page covers a topic
+ *   list_articles         its articles, newest first
+ *   get_article           one article in full
+ *   get_reviews           verbatim reviews and the rating summary
+ *   list_offerings        priced products, services and events (opt-in)
+ *   check_availability    open appointment times (opt-in)
+ *   get_inquiry_form      what an inquiry needs (opt-in, with send_inquiry)
+ *   send_inquiry          a person's inquiry, filed by a named agent (opt-in)
+ *
+ * send_inquiry goes through Sonor's agent-inquiry door, not the browser form
+ * endpoint: the form must opt in (embed_config.agent_inquiries in Sonor), the
+ * call carries the agent's badge (`agent_identity`) and `human_approved`, and
+ * the row lands in Forms as an agent inquiry. See sonor-api
+ * src/modules/forms/agent-inquiry.ts.
+ *
+ * @example
+ * ```ts
+ * // app/api/mcp/route.ts
+ * import { createMcpHandler } from '@sonordev/site-kit/mcp'
+ * import { sonorMcpServer, reportToolCallsToSonor } from '@sonordev/site-kit/mcp/sonor'
+ *
+ * export const { POST, GET, DELETE, OPTIONS } = createMcpHandler({
+ *   server: sonorMcpServer({ businessName: 'Heinrich Law', inquiry: { form: 'contact' } }),
+ *   baseUrl: process.env.NEXT_PUBLIC_SITE_URL,
+ *   onToolCall: reportToolCallsToSonor(),
+ * })
+ * ```
+ */
+import 'server-only';
+import { type McpServerDefinition } from './protocol';
+import type { McpServerInfo, SiteKitMcpTool } from './types';
+export { reportToolCallsToSonor } from './report';
+export type { ReportToolCallsOptions } from './report';
+export type SonorMcpToolName = 'get_business_profile' | 'list_services' | 'search_faq' | 'find_pages' | 'list_articles' | 'get_article' | 'get_reviews' | 'list_offerings' | 'check_availability' | 'get_inquiry_form' | 'send_inquiry';
+export interface SonorMcpOptions {
+    /** The business, as tool descriptions name it ("…at Heinrich Law"). */
+    businessName: string;
+    /** Absolute site origin for links. Default: NEXT_PUBLIC_SITE_URL. */
+    siteUrl?: string;
+    /** Sub-site host on a multi-site project. Default: resolved from NEXT_PUBLIC_SITE_URL. */
+    site?: string;
+    /** Articles live under this path (`/blog/<slug>`). `false` drops the article tools. Default '/blog'. */
+    articles?: {
+        path?: string;
+    } | false;
+    /** `false` drops get_reviews (a site with no reviews in Sonor). */
+    reviews?: boolean;
+    /** Add list_offerings: priced products, services and events from Commerce. */
+    offerings?: {
+        path?: string;
+    };
+    /** Add check_availability: open times from Sync. `path` is the booking page agents send people to. */
+    booking?: {
+        path: string;
+    };
+    /**
+     * Add get_inquiry_form and send_inquiry for this managed form. The form
+     * must accept agent inquiries (Sonor: the form's "Agent inquiries" switch,
+     * embed_config.agent_inquiries), or every send is refused.
+     */
+    inquiry?: {
+        form: string;
+        purpose?: string;
+    };
+    /** Drop individual tools. */
+    exclude?: SonorMcpToolName[];
+}
+/**
+ * Rank items against a query: every word of the query that appears counts,
+ * a hit in the primary field twice. No query keeps the given order.
+ */
+export declare function rankByQuery<T>(items: T[], query: string, fields: (item: T) => [primary: string, secondary: string], limit: number): T[];
+/** `<host> MCP <tool> via <assistant>`: the badge an agent's write carries (CLAUDE.md "every agent gets a badge"). */
+export declare function formatAgentIdentity(host: string, tool: string, assistant: string): string;
+/** The built-in tools for this site, in the order agents should reach for them. */
+export declare function sonorMcpTools(options: SonorMcpOptions): SiteKitMcpTool[];
+/** `heinrichlaw.com` → `com.heinrichlaw/site`, the reverse-DNS server name SEP-2127 asks for. */
+export declare function serverNameForHost(host: string): string;
+export interface SonorMcpServerOptions extends SonorMcpOptions {
+    /** Override any of the server card's fields. */
+    info?: Partial<McpServerInfo>;
+    /** The site's own tools, served beside the built-in ones. */
+    tools?: SiteKitMcpTool[];
+}
+/** A whole MCP server for the site: its info plus the built-in tools (and any of its own). */
+export declare function sonorMcpServer(options: SonorMcpServerOptions): McpServerDefinition;