nuxt-ai-ready 1.5.8 → 1.6.0

package/README.md

@@ -21,7 +21,8 @@ Nuxt AI Ready implements both. It converts your pages to markdown, generates llm
 - 📝 **[Nuxt Content](https://content.nuxt.com) Integration**: Routes backed by a page collection serve source markdown directly, skipping HTML→markdown conversion
 - 📡 **Content Signals**: Configure AI training/search/input permissions via [Nuxt Robots](https://nuxtseo.com/robots)
 - 🌐 **Sitemap Integration**: Index AI-allowed pages via [Nuxt Sitemap](https://nuxtseo.com/sitemap)
-- ⚡ **MCP Server**: `list_pages` and `search_pages` tools with FTS5 full-text search
+- ⚡ **MCP Server**: List, search and read indexed pages through `@nuxtjs/mcp-toolkit`
+- 🧩 **[WebMCP](https://nuxtseo.com/ai-ready/guides/webmcp)**: Give browser agents access to built-in site tools or your own tools with `useWebMcpTool()`
 - 🗄️ **Runtime Indexing**: Index pages on-demand without prerendering, with SQLite/D1/LibSQL support
 - 🔔 **[IndexNow](https://nuxtseo.com/ai-ready/guides/indexnow)**: Instantly notify Bing, Yandex, and other search engines when pages change
 - 🌏 **[i18n Aware](https://nuxtseo.com/ai-ready/guides/i18n)**: Auto-detects [`@nuxtjs/i18n`](https://i18n.nuxtjs.org/) for hreflang `Link` headers, locale-tagged frontmatter, and an Available Languages section in `llms.txt`

package/dist/cli.mjs

@@ -17,6 +17,19 @@ async function getSecret(cwd) {
 function authHeaders(secret) {
   return { Authorization: `Bearer ${secret}` };
 }
+async function requireSecret(cwd, hint = "") {
+  const secret = await getSecret(cwd);
+  if (!secret) {
+    consola.error(`No secret found. Run \`nuxi dev\` or \`nuxi build\` first${hint}.`);
+  }
+  return secret;
+}
+async function fetchJson(url, init, errorLabel = "Failed") {
+  return fetch(url, init).then((r) => r.json()).catch((err) => {
+    consola.error(`${errorLabel}: ${err.message}`);
+    return null;
+  });
+}
 const main = defineCommand({
   meta: {
     name: "nuxt-ai-ready",
@@ -44,17 +57,12 @@ const main = defineCommand({
       },
       async run({ args }) {
         const cwd = resolve(args.cwd || ".");
-        const secret = await getSecret(cwd);
-        if (!secret) {
-          consola.error("No secret found. Run `nuxi dev` or `nuxi build` first to generate one.");
+        const secret = await requireSecret(cwd, " to generate one");
+        if (!secret)
           return;
-        }
         const url = `${args.url}/__ai-ready/status`;
         consola.info(`Fetching status from ${args.url}...`);
-        const res = await fetch(url, { headers: authHeaders(secret) }).then((r) => r.json()).catch((err) => {
-          consola.error(`Failed to connect: ${err.message}`);
-          return null;
-        });
+        const res = await fetchJson(url, { headers: authHeaders(secret) }, "Failed to connect");
         if (!res)
           return;
         consola.box("AI Ready Status");
@@ -146,11 +154,9 @@ const main = defineCommand({
       },
       async run({ args }) {
         const cwd = resolve(args.cwd || ".");
-        const secret = await getSecret(cwd);
-        if (!secret) {
-          consola.error("No secret found. Run `nuxi dev` or `nuxi build` first.");
+        const secret = await requireSecret(cwd);
+        if (!secret)
           return;
-        }
         const params = new URLSearchParams();
         if (args.all) {
           params.set("all", "true");
@@ -159,10 +165,7 @@ const main = defineCommand({
         }
         const url = `${args.url}/__ai-ready/poll?${params}`;
         consola.info(`Triggering poll at ${args.url}...`);
-        const res = await fetch(url, { method: "POST", headers: authHeaders(secret) }).then((r) => r.json()).catch((err) => {
-          consola.error(`Failed: ${err.message}`);
-          return null;
-        });
+        const res = await fetchJson(url, { method: "POST", headers: authHeaders(secret) });
         if (!res)
           return;
         consola.success(`Indexed: ${colors.green(res.indexed?.toString() || "0")} pages`);
@@ -201,21 +204,16 @@ const main = defineCommand({
       },
       async run({ args }) {
         const cwd = resolve(args.cwd || ".");
-        const secret = await getSecret(cwd);
-        if (!secret) {
-          consola.error("No secret found. Run `nuxi dev` or `nuxi build` first.");
+        const secret = await requireSecret(cwd);
+        if (!secret)
           return;
-        }
         const params = new URLSearchParams();
         if (!args.clear) {
           params.set("clear", "false");
         }
         const url = `${args.url}/__ai-ready/restore?${params}`;
         consola.info(`Restoring database at ${args.url}...`);
-        const res = await fetch(url, { method: "POST", headers: authHeaders(secret) }).then((r) => r.json()).catch((err) => {
-          consola.error(`Failed: ${err.message}`);
-          return null;
-        });
+        const res = await fetchJson(url, { method: "POST", headers: authHeaders(secret) });
         if (!res)
           return;
         consola.success(`Restored: ${colors.green(res.restored?.toString() || "0")} pages`);
@@ -265,12 +263,9 @@ const main = defineCommand({
           params.set("ttl", args.ttl);
         const url = `${args.url}/__ai-ready/prune?${params}`;
         consola.info(`${args.dry ? "Previewing" : "Pruning"} stale routes at ${args.url}...`);
-        const res = await fetch(url, {
+        const res = await fetchJson(url, {
           method: "POST",
           headers: secret ? authHeaders(secret) : void 0
-        }).then((r) => r.json()).catch((err) => {
-          consola.error(`Failed: ${err.message}`);
-          return null;
         });
         if (!res)
           return;
@@ -315,20 +310,15 @@ const main = defineCommand({
       },
       async run({ args }) {
         const cwd = resolve(args.cwd || ".");
-        const secret = await getSecret(cwd);
-        if (!secret) {
-          consola.error("No secret found. Run `nuxi dev` or `nuxi build` first.");
+        const secret = await requireSecret(cwd);
+        if (!secret)
           return;
-        }
         const params = new URLSearchParams({
           limit: args.limit || "100"
         });
         const url = `${args.url}/__ai-ready/indexnow?${params}`;
         consola.info(`Triggering IndexNow sync at ${args.url}...`);
-        const res = await fetch(url, { method: "POST", headers: authHeaders(secret) }).then((r) => r.json()).catch((err) => {
-          consola.error(`Failed: ${err.message}`);
-          return null;
-        });
+        const res = await fetchJson(url, { method: "POST", headers: authHeaders(secret) });
         if (!res)
           return;
         if (res.success) {

package/dist/module.d.mts

@@ -1,6 +1,8 @@
 import * as _nuxt_schema from '@nuxt/schema';
-import { LlmsTxtConfig, ModuleOptions } from '../dist/runtime/types.js';
+import { LlmsTxtConfig, ContentNegotiationPolicy, ModuleOptions } from '../dist/runtime/types.js';
 export { ModuleOptions } from '../dist/runtime/types.js';
+import { ResolvedWebMcpToolsConfig } from '../dist/runtime/site-tool-config.js';
+export { GetPageMarkdownToolOptions, ListPagesToolOptions, McpSiteToolAttachmentOptions, SearchPagesToolOptions, SiteToolOptions, SiteToolsConfig, WebMcpSiteToolAttachmentOptions } from '../dist/runtime/site-tool-config.js';
 
 interface ParsedMarkdownResult {
     markdown: string;
@@ -11,6 +13,11 @@ interface ParsedMarkdownResult {
     updatedAt?: string;
 }
 
+interface ResolvedWebMcpConfig {
+    tools: ResolvedWebMcpToolsConfig;
+    exposedTo?: string[];
+}
+
 interface ModuleHooks {
     /**
      * Hook called when page markdown is generated during prerendering.
@@ -36,6 +43,7 @@ declare module '@nuxt/schema' {
 interface ModulePublicRuntimeConfig {
     debug: boolean;
     debugCron: boolean;
+    contentNegotiation: ContentNegotiationPolicy;
     version: string;
     mdreamOptions: ModuleOptions['mdreamOptions'];
     markdownCacheHeaders: Required<NonNullable<ModuleOptions['markdownCacheHeaders']>>;
@@ -67,7 +75,11 @@ interface ModulePublicRuntimeConfig {
     } | null;
     ftsTokenizer?: string;
 }
+/** Runtime config exposed to the browser, only set when WebMCP is enabled. */
+interface ModuleAppRuntimeConfig {
+    webmcp: ResolvedWebMcpConfig;
+}
 declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
 
 export { _default as default };
-export type { ModuleHooks, ModulePublicRuntimeConfig };
+export type { ModuleAppRuntimeConfig, ModuleHooks, ModulePublicRuntimeConfig };

package/dist/module.json

@@ -4,9 +4,9 @@
     "nuxt": ">=4.0.0"
   },
   "configKey": "aiReady",
-  "version": "1.5.8",
+  "version": "1.6.0",
   "builder": {
-    "@nuxt/module-builder": "1.0.2",
+    "@nuxt/module-builder": "1.0.3",
     "unbuild": "3.6.1"
   }
 }

package/dist/module.mjs

@@ -1,14 +1,14 @@
 import { createHash, randomBytes } from 'node:crypto';
 import { mkdir, writeFile, appendFile, stat, readdir, access, readFile } from 'node:fs/promises';
 import { join, dirname, relative, resolve } from 'node:path';
-import { useLogger, useNuxt, resolveFiles, addTypeTemplate, addTemplate, defineNuxtModule, createResolver, hasNuxtModule, addServerPlugin, addServerHandler, addPlugin } from '@nuxt/kit';
+import { useLogger, useNuxt, hasNuxtModule, resolveFiles, addTypeTemplate, addTemplate, defineNuxtModule, createResolver, addServerPlugin, addServerHandler, addPlugin, addImports, extendRouteRules } from '@nuxt/kit';
 import defu from 'defu';
 import { installNuxtSiteConfig, useSiteConfig, withSiteUrl } from 'nuxt-site-config/kit';
 import { setupDevToolsUI } from 'nuxtseo-shared/devtools';
 import { resolveNuxtContentVersion } from 'nuxtseo-shared/kit';
 import { readPackageJSON, resolvePackageJSON } from 'pkg-types';
-import { parseSitemapXml } from '@nuxtjs/sitemap/utils';
 import { colorize } from 'consola/utils';
+import { collectSitemap } from 'sitemapd/parse';
 import { withLeadingSlash, withBase, joinURL } from 'ufo';
 import { normalizePagePath, toMarkdownPath } from '../dist/runtime/markdown-path.js';
 import { toLogicalRoute, toDeployedRoute } from '../dist/runtime/route-path.js';
@@ -249,11 +249,13 @@ async function crawlSitemapEntries(state, nuxt, nitro, entries) {
 }
 async function crawlSitemapContent(state, nuxt, nitro, sitemapContent) {
   logger.debug(`Parsing sitemap XML (${sitemapContent.length} bytes)`);
-  const result = await parseSitemapXml(sitemapContent).catch((e) => {
-    logger.debug(`Skipping sitemap: ${e.message}`);
-    return null;
-  });
-  const urls = result?.urls || [];
+  const result = await collectSitemap(sitemapContent);
+  if (result._tag !== "document" || result.document._tag !== "urlset") {
+    const issues = result.issues.map((issue) => issue.message).join("; ");
+    logger.debug(`Skipping sitemap: ${issues || "document is not a URL set"}`);
+    return 0;
+  }
+  const urls = result.document.entries;
   logger.debug(`Found ${urls.length} URLs in sitemap`);
   return crawlSitemapEntries(state, nuxt, nitro, urls);
 }
@@ -269,10 +271,8 @@ function includesSitemapRoot(sitemapName, routes) {
 function detectSitemapPrerender(sitemapName = "sitemap.xml") {
   const nuxt = useNuxt();
   const prerenderedRoutes = nuxt.options.nitro.prerender?.routes || [];
-  const hasSitemapModule = nuxt.options._installedModules?.some(
-    (m) => m.meta?.name === "@nuxtjs/sitemap"
-  );
-  let prerenderSitemap = hasSitemapModule || isNuxtGenerate() || includesSitemapRoot(sitemapName, prerenderedRoutes);
+  const hasSitemapModule = hasNuxtModule("@nuxtjs/sitemap", nuxt);
+  let prerenderSitemap = isNuxtGenerate() || includesSitemapRoot(sitemapName, prerenderedRoutes);
   if (resolveNitroPreset() === "vercel-edge")
     prerenderSitemap = true;
   const hasPrerender = !!(nuxt.options.nitro.prerender?.routes?.length || nuxt.options.nitro.prerender?.crawlLinks);
@@ -491,7 +491,48 @@ function setupPrerenderHandler(options, dbPath, siteInfo, llmsTxtConfig, indexNo
   });
 }
 
-function registerTypeTemplates(_ctx) {
+const declarativeWebMcpTypes = `
+import type { WebMcpToolsContext } from 'nuxt-ai-ready/webmcp'
+
+declare module '#app' {
+  interface RuntimeNuxtHooks {
+    /** Mutate built-in browser tools and their registration options before registration. */
+    'ai-ready:webmcp:tools': (context: WebMcpToolsContext) => void | Promise<void>
+  }
+}
+
+declare module '@vue/runtime-dom' {
+  interface HTMLAttributes {
+    /** Names the tool this form exposes to agents. */
+    toolname?: string
+    /** Describes what submitting this form does. */
+    tooldescription?: string
+    /** Describes this field as a tool parameter. */
+    toolparamdescription?: string
+    /** Submit the form as soon as an agent fills it in. */
+    toolautosubmit?: boolean | ''
+  }
+}
+
+declare global {
+  interface SubmitEvent {
+    /** Whether an agent triggered this submit through a tool call. */
+    readonly agentInvoked?: boolean
+    /** Return a result to the agent. Call preventDefault() first. */
+    respondWith?: (result: Promise<unknown>) => void
+  }
+
+  interface WebMcpToolEvent extends Event {
+    readonly toolName: string
+  }
+
+  interface WindowEventMap {
+    toolactivated: WebMcpToolEvent
+    toolcancel: WebMcpToolEvent
+  }
+}
+`;
+function registerTypeTemplates(ctx) {
   addTypeTemplate({
     filename: "types/nuxt-ai-ready-augments.d.ts",
     getContents: () => `// Generated by nuxt-ai-ready
@@ -506,7 +547,7 @@ declare module 'nitropack/types' {
     'ai-ready:page:indexed': (context: PageIndexedContext) => void | Promise<void>
   }
 }
-
+${ctx.config.webmcp ? declarativeWebMcpTypes : ""}
 export {}
 `
   });
@@ -625,6 +666,26 @@ async function detectI18n(opts = {}) {
   return toRuntimeI18nConfig(auto);
 }
 
+function hasConfiguredNuxtModule(modules, name) {
+  return modules.some((entry) => {
+    const module = Array.isArray(entry) ? entry[0] : entry;
+    if (typeof module === "string")
+      return module === name;
+    if ((typeof module === "function" || typeof module === "object" && module !== null) && "meta" in module)
+      return module.meta?.name === name;
+    return false;
+  });
+}
+function resolveMcpToolkitState(input) {
+  if (!input.installed)
+    return { _tag: "Absent" };
+  if (input.options === false || input.options?.enabled === false)
+    return { _tag: "Disabled" };
+  if (input.static || input.generating)
+    return { _tag: "Static" };
+  return { _tag: "Enabled", route: input.options?.route || "/mcp" };
+}
+
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -656,6 +717,110 @@ function ensureStaticHeader(contents, route, name, value) {
   return `${contents.slice(0, blockStart)}${prefix}  ${name}: ${value}${eol}${contents.slice(blockStart)}`;
 }
 
+const DEFAULT_MAX_OUTPUT_CHARS = 1500;
+const DEFAULT_LIST_LIMIT = 20;
+const DEFAULT_SEARCH_LIMIT = 10;
+const MAX_TOOL_LIMIT = 50;
+function parsePositiveInteger(value, fallback, name, warnings, max) {
+  if (value === void 0)
+    return fallback;
+  const integer = Math.trunc(value);
+  if (!Number.isFinite(value) || integer < 1) {
+    warnings.push(`\`aiReady.${name}\` must be a positive finite integer. Using ${fallback}.`);
+    return fallback;
+  }
+  if (max && integer > max) {
+    warnings.push(`\`aiReady.${name}\` cannot exceed ${max}. Using ${max}.`);
+    return max;
+  }
+  if (integer !== value)
+    warnings.push(`\`aiReady.${name}\` must be an integer. Using ${integer}.`);
+  return integer;
+}
+function resolveWebMcpAttachment(options, path, warnings) {
+  if (options?.enabled === false)
+    return { enabled: false };
+  return {
+    enabled: true,
+    maxOutputChars: parsePositiveInteger(
+      options?.maxOutputChars,
+      DEFAULT_MAX_OUTPUT_CHARS,
+      `${path}.webmcp.maxOutputChars`,
+      warnings
+    ),
+    exposedTo: options?.exposedTo === void 0 ? void 0 : [...options.exposedTo]
+  };
+}
+function resolveSiteToolsConfig(input) {
+  const warnings = [];
+  return {
+    config: {
+      listPages: {
+        defaultLimit: parsePositiveInteger(
+          input?.listPages?.defaultLimit,
+          DEFAULT_LIST_LIMIT,
+          "tools.listPages.defaultLimit",
+          warnings,
+          MAX_TOOL_LIMIT
+        ),
+        mcp: { enabled: input?.listPages?.mcp?.enabled !== false },
+        webmcp: resolveWebMcpAttachment(input?.listPages?.webmcp, "tools.listPages", warnings)
+      },
+      searchPages: {
+        defaultLimit: parsePositiveInteger(
+          input?.searchPages?.defaultLimit,
+          DEFAULT_SEARCH_LIMIT,
+          "tools.searchPages.defaultLimit",
+          warnings,
+          MAX_TOOL_LIMIT
+        ),
+        mcp: { enabled: input?.searchPages?.mcp?.enabled !== false },
+        webmcp: resolveWebMcpAttachment(input?.searchPages?.webmcp, "tools.searchPages", warnings)
+      },
+      getPageMarkdown: {
+        mcp: { enabled: input?.getPageMarkdown?.mcp?.enabled !== false },
+        webmcp: resolveWebMcpAttachment(input?.getPageMarkdown?.webmcp, "tools.getPageMarkdown", warnings)
+      }
+    },
+    warnings
+  };
+}
+function resolveWebMcpConfig(input, toolsConfig) {
+  if (!input)
+    return { _tag: "Disabled" };
+  const options = input === true ? {} : input;
+  const tools = {};
+  if (options.tools !== false) {
+    if (toolsConfig.listPages.webmcp.enabled) {
+      tools.listPages = {
+        defaultLimit: toolsConfig.listPages.defaultLimit,
+        maxOutputChars: toolsConfig.listPages.webmcp.maxOutputChars,
+        exposedTo: toolsConfig.listPages.webmcp.exposedTo
+      };
+    }
+    if (toolsConfig.searchPages.webmcp.enabled) {
+      tools.searchPages = {
+        defaultLimit: toolsConfig.searchPages.defaultLimit,
+        maxOutputChars: toolsConfig.searchPages.webmcp.maxOutputChars,
+        exposedTo: toolsConfig.searchPages.webmcp.exposedTo
+      };
+    }
+    if (toolsConfig.getPageMarkdown.webmcp.enabled) {
+      tools.getPageMarkdown = {
+        maxOutputChars: toolsConfig.getPageMarkdown.webmcp.maxOutputChars,
+        exposedTo: toolsConfig.getPageMarkdown.webmcp.exposedTo
+      };
+    }
+  }
+  return {
+    _tag: "Enabled",
+    config: {
+      tools,
+      exposedTo: options.exposedTo?.length ? [...options.exposedTo] : void 0
+    }
+  };
+}
+
 const module$1 = defineNuxtModule({
   meta: {
     name: "nuxt-ai-ready",
@@ -715,13 +880,17 @@ const module$1 = defineNuxtModule({
     if (rawConfig.mdreamOptions?.preset) {
       logger.warn("`mdreamOptions.preset` is deprecated. Use `mdreamOptions: { minimal: true }` instead. See https://github.com/harlan-zw/nuxt-ai-ready/releases/tag/v1.0.0");
     }
+    const siteToolsResult = resolveSiteToolsConfig(config.tools);
+    for (const warning of siteToolsResult.warnings)
+      logger.warn(warning);
+    const siteToolsConfig = siteToolsResult.config;
+    const hasMcpSiteTools = Object.values(siteToolsConfig).some((tool) => tool.mcp.enabled);
     await installNuxtSiteConfig();
     const i18nConfig = await detectI18n({ autoI18n: config.autoI18n });
     if (i18nConfig) {
       logger.info(`i18n detected: ${i18nConfig.locales.length} locales (default: ${i18nConfig.defaultLocale}, strategy: ${i18nConfig.strategy})`);
     }
     const ftsTokenizer = i18nConfig && hasCjkLocale(i18nConfig) ? "trigram" : "unicode61 remove_diacritics 2";
-    nuxt.options.nitro.alias = nuxt.options.nitro.alias || {};
     nuxt.options.alias["#ai-ready"] = resolve("./runtime");
     const preset = String(nuxt.options.nitro.preset || "");
     const isCloudflare = preset.startsWith("cloudflare");
@@ -755,7 +924,14 @@ const module$1 = defineNuxtModule({
         );
       }
     }
-    if (nuxt.options.mcp !== false && !nuxt.options.mcp?.name) {
+    const mcpToolkitState = resolveMcpToolkitState({
+      installed: hasNuxtModule("@nuxtjs/mcp-toolkit") || hasConfiguredNuxtModule(nuxt.options.modules, "@nuxtjs/mcp-toolkit"),
+      options: nuxt.options.mcp,
+      static: nuxt.options.nitro.static === true,
+      generating: nuxt.options._generate === true
+    });
+    const mcpAvailable = mcpToolkitState._tag === "Enabled";
+    if (mcpAvailable && nuxt.options.mcp !== false && !nuxt.options.mcp?.name) {
       nuxt.options.mcp = nuxt.options.mcp || {};
       nuxt.options.mcp.name = useSiteConfig().name;
     }
@@ -780,7 +956,7 @@ const module$1 = defineNuxtModule({
         group.contentUsage = [`train-ai=${config.contentSignal.aiTrain ? "y" : "n"}`];
       groups.push(group);
     }
-    registerTypeTemplates();
+    registerTypeTemplates({ config });
     const defaultLlmsTxtSections = [];
     const llmsFullRoute = withSiteUrl("llms-full.txt", { withBase: true });
     defaultLlmsTxtSections.push({
@@ -793,19 +969,19 @@ const module$1 = defineNuxtModule({
         }
       ]
     });
-    const hasMCP = hasNuxtModule("@nuxtjs/mcp-toolkit");
-    if (hasMCP) {
+    if (mcpAvailable) {
+      addServerPlugin(resolve("./runtime/server/plugins/mcp-data"));
       nuxt.hook("mcp:definitions:paths", (paths) => {
         const mcpRuntimeDir = resolve(`./runtime/server/mcp`);
         const mcpConfig = config.mcp || {};
-        if (mcpConfig.tools !== false)
+        if (mcpConfig.tools !== false && hasMcpSiteTools)
           (paths.tools ||= []).push(`${mcpRuntimeDir}/tools`);
         if (mcpConfig.resources !== false)
           (paths.resources ||= []).push(`${mcpRuntimeDir}/resources`);
       });
       const mcpLink = {
         title: "MCP",
-        href: withSiteUrl(nuxt.options.mcp !== false && nuxt.options.mcp?.route || "/mcp", { withBase: true }),
+        href: withSiteUrl(mcpToolkitState.route, { withBase: true }),
         description: "Model Context Protocol server endpoint for AI agent integration."
       };
       if (defaultLlmsTxtSections[0]) {
@@ -836,12 +1012,15 @@ const module$1 = defineNuxtModule({
     const buildDbPath = join(nuxt.options.buildDir, ".data/ai-ready/build.db");
     const runtimeSyncConfig = typeof config.runtimeSync === "object" ? config.runtimeSync : {};
     const runtimeSyncEnabled = !!config.runtimeSync || !!config.cron;
+    const webmcpResult = resolveWebMcpConfig(config.webmcp, siteToolsConfig);
+    const webmcpConfig = webmcpResult._tag === "Enabled" ? webmcpResult.config : null;
     const indexNow = config.indexNow === true ? createHash("sha256").update(useSiteConfig().url || "nuxt-ai-ready").digest("hex").slice(0, 32) : config.indexNow || process.env.NUXT_AI_READY_INDEX_NOW_KEY;
     nuxt.hooks.hook("nuxt-seo-pro:modules", (modules) => {
       const mod = modules.find((m) => m.name === "nuxt-ai-ready");
       if (mod) {
         mod.features = {
-          mcp: hasMCP,
+          mcp: mcpAvailable,
+          webmcp: !!webmcpConfig,
           runtimeSync: runtimeSyncEnabled,
           cron: !!config.cron,
           indexNow: !!indexNow,
@@ -868,10 +1047,12 @@ const module$1 = defineNuxtModule({
     nuxt.hooks.hook("nitro:config", (nitroConfig) => {
       nitroConfig.experimental = nitroConfig.experimental || {};
       nitroConfig.experimental.asyncContext = true;
+      nitroConfig.externals = nitroConfig.externals || {};
+      nitroConfig.externals.inline = nitroConfig.externals.inline || [];
+      nitroConfig.externals.inline.push("sitemapd");
       const preset2 = String(nitroConfig.preset || "");
       const isEdgePreset = ["cloudflare", "vercel-edge", "netlify-edge", "deno"].some((p) => preset2.startsWith(p));
       if (!isEdgePreset) {
-        nitroConfig.externals = nitroConfig.externals || {};
         nitroConfig.externals.external = nitroConfig.externals.external || [];
         nitroConfig.externals.external.push("mdream");
       }
@@ -913,6 +1094,7 @@ const module$1 = defineNuxtModule({
         }
       }
       nitroConfig.virtual = nitroConfig.virtual || {};
+      nitroConfig.virtual["#ai-ready-virtual/site-tools.mjs"] = `export default ${JSON.stringify(siteToolsConfig)}`;
       const markdownLinkAvailabilityPath = join(dirname(buildDbPath), MARKDOWN_LINK_AVAILABILITY_FILE);
       nitroConfig.virtual["#ai-ready-virtual/read-page-data.mjs"] = nuxt.options.dev ? `
 export async function readPageDataFromFilesystem() { return { pages: [], errorRoutes: [] } }
@@ -983,11 +1165,8 @@ export async function readPageDataFromFilesystem() {
       nitroConfig.virtual["#ai-ready-virtual/page-data.mjs"] = `export const pages = []
 export const errorRoutes = []`;
       nitroConfig.virtual["#ai-ready-virtual/logger.mjs"] = `
-import { createConsola } from 'consola'
-export const logger = createConsola({
-  defaults: { tag: 'nuxt-ai-ready' },
-  level: ${config.debug ? 4 : 3},
-})
+import { createModuleLogger } from 'nuxtseo-shared/utils'
+export const logger = createModuleLogger('nuxt-ai-ready', ${!!config.debug})
 `;
       const providerMap = {
         sqlite: "#ai-ready/server/db/drizzle/providers/sqlite",
@@ -1002,7 +1181,7 @@ export const logger = createConsola({
       nitroConfig.virtual["#ai-ready-virtual/db-schema.mjs"] = `export * from '${schemaPath}'`;
       nitroConfig.virtual["#ai-ready-virtual/devtools-meta.mjs"] = `export const devtoolsMeta = ${JSON.stringify({
         contentSignal: config.contentSignal || false,
-        mcp: { enabled: hasMCP, tools: hasMCP && config.mcp?.tools !== false, resources: hasMCP && config.mcp?.resources !== false },
+        mcp: { enabled: mcpAvailable, tools: mcpAvailable && config.mcp?.tools !== false && hasMcpSiteTools, resources: mcpAvailable && config.mcp?.resources !== false },
         cron: !!config.cron
       })}`;
       nitroConfig.virtual["#ai-ready-virtual/content-lookup.mjs"] = hasNuxtContentV3 ? `
@@ -1039,6 +1218,7 @@ export async function lookupContentPage(event, path) {
       version: version || "0.0.0",
       debug: config.debug || false,
       debugCron: config.debugCron || false,
+      contentNegotiation: config.contentNegotiation === void 0 ? "auto" : config.contentNegotiation ? "enabled" : "disabled",
       mdreamOptions: config.mdreamOptions || {},
       markdownCacheHeaders: defu(config.markdownCacheHeaders, {
         maxAge: 3600,
@@ -1081,6 +1261,19 @@ export async function lookupContentPage(event, path) {
     });
     addServerHandler({ route: "/llms.txt", handler: resolve("./runtime/server/routes/llms.txt.get") });
     addServerHandler({ route: "/llms-full.txt", handler: resolve("./runtime/server/routes/llms-full.txt.get") });
+    if (webmcpConfig) {
+      addImports(["useWebMcpSupported", "useWebMcpTool"].map((name) => ({
+        name,
+        from: resolve("./runtime/app/composables/webmcp")
+      })));
+      nuxt.options.runtimeConfig.public["nuxt-ai-ready"] = {
+        webmcp: webmcpConfig
+      };
+      addPlugin({ mode: "client", src: resolve("./runtime/app/plugins/webmcp.client") });
+      if (Object.keys(webmcpConfig.tools).length) {
+        addServerHandler({ route: "/__ai-ready/pages", handler: resolve("./runtime/server/routes/__ai-ready/pages.get") });
+      }
+    }
     addServerHandler({ route: "/__ai-ready__/debug.json", handler: resolve("./runtime/server/routes/__ai-ready/devtools.get") });
     if (config.debug) {
       addServerHandler({ route: "/__ai-ready-debug", handler: resolve("./runtime/server/routes/__ai-ready-debug.get") });
@@ -1128,12 +1321,8 @@ export async function lookupContentPage(event, path) {
       title: "AI Ready",
       icon: "carbon:ai-label"
     }, resolve, nuxt);
-    nuxt.options.nitro.routeRules = nuxt.options.nitro.routeRules || {};
     for (const route of ["/llms.txt", "/llms-full.txt"]) {
-      nuxt.options.nitro.routeRules[route] = defu(
-        nuxt.options.nitro.routeRules[route],
-        { headers: { "Content-Type": "text/plain; charset=utf-8" } }
-      );
+      extendRouteRules(route, { headers: { "Content-Type": "text/plain; charset=utf-8" } });
     }
     nuxt.hooks.hook("nitro:build:before", (nitro) => {
       nitro.hooks.hook("compiled", async () => {

package/dist/runtime/app/composables/webmcp.d.ts

@@ -0,0 +1,24 @@
+import type { ComputedRef, MaybeRefOrGetter, ShallowRef } from 'vue';
+import type { InferWebMcpInput, WebMcpInputSchema, WebMcpRegisterOptions, WebMcpTool, WebMcpToolRegistrationState } from '../../webmcp.js';
+export interface UseWebMcpToolOptions extends WebMcpRegisterOptions {
+    /** Register only while this reactive value is true. */
+    enabled?: MaybeRefOrGetter<boolean>;
+}
+export interface UseWebMcpToolReturn {
+    /** Whether the mounted client supports `document.modelContext`. */
+    supported: ComputedRef<boolean>;
+    /** Registration lifecycle, including browser rejections. */
+    state: Readonly<ShallowRef<WebMcpToolRegistrationState>>;
+    /** Remove the tool permanently for this composable instance. */
+    unregister: () => void;
+}
+/**
+ * Hydration-safe WebMCP support. It stays false through SSR and the first client
+ * render, then updates after mount.
+ */
+export declare function useWebMcpSupported(): ComputedRef<boolean>;
+/**
+ * Register a WebMCP tool while its component is mounted, active and enabled.
+ */
+export declare function useWebMcpTool<const Schema extends WebMcpInputSchema, Output>(tool: WebMcpTool<InferWebMcpInput<NoInfer<Schema>>, Output, Schema>, options?: UseWebMcpToolOptions): UseWebMcpToolReturn;
+export declare function useWebMcpTool<Input extends Record<string, unknown>, Output>(tool: WebMcpTool<Input, Output>, options?: UseWebMcpToolOptions): UseWebMcpToolReturn;