@nuxtjs/mcp-toolkit 0.5.1 → 0.6.0

package/README.md

@@ -93,6 +93,16 @@ export default defineMcpTool({
 
 The tool will be automatically discovered and registered. No imports needed - all helpers are auto-imported!
 
+## ☁️ Cloudflare Workers
+
+For Cloudflare Workers/Pages deployment, install the [`agents`](https://developers.cloudflare.com/agents/model-context-protocol/mcp-handler-api/) package:
+
+```bash
+pnpm add agents
+```
+
+The module automatically detects Cloudflare presets and uses the native MCP handler.
+
 ## 📚 Documentation
 
 📖 **[Full Documentation →](https://mcp-toolkit.nuxt.dev)**
@@ -132,3 +142,15 @@ Made by [@HugoRCD](https://github.com/HugoRCD) and [community](https://github.co
 </a>
 
 <!-- /automd -->
+
+<!-- automd:fetch url="gh:hugorcd/markdown/main/src/sponsors.md" -->
+
+## Sponsors
+
+<p align="center">
+  <a href="https://github.com/sponsors/HugoRCD">
+    <img src='https://cdn.jsdelivr.net/gh/hugorcd/static/sponsors.svg' alt="HugoRCD sponsors" />
+  </a>
+</p>
+
+<!-- /automd -->

package/dist/module.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuxtjs/mcp-toolkit",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "configKey": "mcp",
   "docs": "https://mcp-toolkit.nuxt.dev/getting-started/installation",
   "mcp": "https://mcp-toolkit.nuxt.dev/mcp",

package/dist/module.mjs

@@ -1,5 +1,5 @@
 import { execSync } from 'node:child_process';
-import { logger, createResolver, defineNuxtModule, addComponent, addServerHandler, addServerImports } from '@nuxt/kit';
+import { logger, createResolver, defineNuxtModule, addComponent, addServerHandler, addServerTemplate, addServerImports } from '@nuxt/kit';
 import { defu } from 'defu';
 import { loadAllDefinitions } from '../dist/runtime/server/mcp/loaders/index.js';
 import { defaultMcpConfig } from '../dist/runtime/server/mcp/config.js';
@@ -7,7 +7,7 @@ import { ROUTES } from '../dist/runtime/server/mcp/constants.js';
 import { addDevToolsCustomTabs } from '../dist/runtime/server/mcp/devtools/index.js';
 
 const name = "@nuxtjs/mcp-toolkit";
-const version = "0.5.1";
+const version = "0.6.0";
 
 const log = logger.withTag("@nuxtjs/mcp-toolkit");
 const { resolve } = createResolver(import.meta.url);
@@ -21,6 +21,10 @@ const module$1 = defineNuxtModule({
   },
   defaults: defaultMcpConfig,
   async setup(options, nuxt) {
+    if (nuxt.options.nitro.static || nuxt.options._generate) {
+      log.warn("@nuxtjs/mcp-toolkit is not compatible with `nuxt generate` as it needs a server to run.");
+      return;
+    }
     const resolver = createResolver(import.meta.url);
     nuxt.options.runtimeConfig.mcp = defu(
       nuxt.options.runtimeConfig.mcp,
@@ -97,6 +101,18 @@ const module$1 = defineNuxtModule({
     nuxt.options.nitro.typescript.tsConfig ??= {};
     nuxt.options.nitro.typescript.tsConfig.include ??= [];
     nuxt.options.nitro.typescript.tsConfig.include.push(resolver.resolve("runtime/server/types.server.d.ts"));
+    let isCloudflare = false;
+    nuxt.hook("nitro:config", (nitroConfig) => {
+      const preset = nitroConfig.preset || process.env.NITRO_PRESET || "";
+      isCloudflare = preset.includes("cloudflare");
+    });
+    addServerTemplate({
+      filename: "#nuxt-mcp/transport.mjs",
+      getContents: () => {
+        const provider = isCloudflare ? "cloudflare" : "node";
+        return `export { default } from '${resolver.resolve(`runtime/server/mcp/providers/${provider}`)}'`;
+      }
+    });
     const mcpDefinitionsPath = resolver.resolve("runtime/server/mcp/definitions");
     addServerImports([
       "defineMcpTool",

package/dist/runtime/server/mcp/definitions/handlers.d.ts

@@ -1,36 +1,109 @@
+import type { H3Event } from 'h3';
 import type { McpToolDefinition } from './tools.js';
 import type { McpResourceDefinition } from './resources.js';
 import type { McpPromptDefinition } from './prompts.js';
+/**
+ * MCP middleware function that runs before/after MCP request processing.
+ *
+ * If you don't call `next()`, it will be called automatically after your middleware.
+ * Call `next()` explicitly if you need to run code after the handler or modify the response.
+ *
+ * @param event - The H3 event object
+ * @param next - Function to call the MCP handler
+ *
+ * @example Simple middleware (next() called automatically)
+ * ```ts
+ * middleware: async (event) => {
+ *   // Just set context - next() is called automatically
+ *   event.context.userId = 'user-123'
+ * }
+ * ```
+ *
+ * @example Full control middleware
+ * ```ts
+ * middleware: async (event, next) => {
+ *   const start = Date.now()
+ *   const response = await next()
+ *   console.log(`Request took ${Date.now() - start}ms`)
+ *   return response
+ * }
+ * ```
+ */
+export type McpMiddleware = (event: H3Event, next: () => Promise<Response | undefined>) => Promise<Response | undefined | void> | Response | undefined | void;
 /**
  * Options for defining a custom MCP handler
  * @see https://mcp-toolkit.nuxt.dev/core-concepts/handlers
  */
 export interface McpHandlerOptions {
-    name: string;
+    /**
+     * The name of the handler. Required for custom handlers accessed via /mcp/:handler.
+     * Optional for default handler override (server/mcp/index.ts).
+     */
+    name?: string;
     version?: string;
+    /**
+     * Custom route for the handler.
+     * Only used for custom handlers (not for default handler override in index.ts).
+     * To change the default route, use `mcp.route` in nuxt.config.ts.
+     */
     route?: string;
     browserRedirect?: string;
+    /**
+     * Middleware to run before/after MCP request processing.
+     * If you don't call next(), it will be called automatically.
+     *
+     * @example Simple (next() auto-called)
+     * ```ts
+     * middleware: async (event) => {
+     *   event.context.userId = 'user-123'
+     * }
+     * ```
+     *
+     * @example Full control
+     * ```ts
+     * middleware: async (event, next) => {
+     *   const start = Date.now()
+     *   const response = await next()
+     *   console.log(`Took ${Date.now() - start}ms`)
+     *   return response
+     * }
+     * ```
+     */
+    middleware?: McpMiddleware;
     tools?: Array<McpToolDefinition<any, any>>;
     resources?: McpResourceDefinition[];
     prompts?: McpPromptDefinition[];
 }
-export interface McpHandlerDefinition extends Required<Omit<McpHandlerOptions, 'tools' | 'resources' | 'prompts'>> {
+export interface McpHandlerDefinition extends Required<Omit<McpHandlerOptions, 'tools' | 'resources' | 'prompts' | 'middleware'>> {
     tools: Array<McpToolDefinition<any, any>>;
     resources: McpResourceDefinition[];
     prompts: McpPromptDefinition[];
+    middleware?: McpMiddleware;
 }
 /**
  * Define a custom MCP handler with specific tools, resources, and prompts.
  *
  * @see https://mcp-toolkit.nuxt.dev/core-concepts/handlers
  *
- * @example
+ * @example Custom handler (accessible via /mcp/:handler)
  * ```ts
+ * // server/mcp/my-handler.ts
  * export default defineMcpHandler({
  *   name: 'my-handler',
  *   tools: [myTool],
  *   resources: [myResource]
  * })
  * ```
+ *
+ * @example Default handler override (server/mcp/index.ts)
+ * ```ts
+ * // server/mcp/index.ts - overrides the default /mcp handler config
+ * export default defineMcpHandler({
+ *   version: '2.0.0',
+ *   browserRedirect: '/docs',
+ *   // Note: 'route' is ignored here. Use mcp.route in nuxt.config.ts instead.
+ *   // If tools/resources/prompts not specified, uses global definitions
+ * })
+ * ```
  */
 export declare function defineMcpHandler(options: McpHandlerOptions): McpHandlerOptions;

package/dist/runtime/server/mcp/definitions/tools.d.ts

@@ -37,7 +37,7 @@ export interface McpToolDefinition<InputSchema extends ZodRawShape | undefined =
  * Register a tool from a McpToolDefinition
  * @internal
  */
-export declare function registerToolFromDefinition<InputSchema extends ZodRawShape | undefined = ZodRawShape, OutputSchema extends ZodRawShape = ZodRawShape>(server: McpServer, tool: McpToolDefinition<InputSchema, OutputSchema>): import("@modelcontextprotocol/sdk/server/mcp.js").RegisteredTool;
+export declare function registerToolFromDefinition(server: McpServer, tool: McpToolDefinition): import("@modelcontextprotocol/sdk/server/mcp.js").RegisteredTool;
 /**
  * Define an MCP tool that will be automatically registered.
  *

package/dist/runtime/server/mcp/definitions/tools.js

@@ -19,32 +19,15 @@ export function registerToolFromDefinition(server, tool) {
       cacheOptions
     );
   }
-  if (tool.inputSchema) {
-    return server.registerTool(
-      name,
-      {
-        title,
-        description: tool.description,
-        inputSchema: tool.inputSchema,
-        outputSchema: tool.outputSchema,
-        annotations: tool.annotations,
-        _meta: tool._meta
-      },
-      handler
-    );
-  } else {
-    return server.registerTool(
-      name,
-      {
-        title,
-        description: tool.description,
-        outputSchema: tool.outputSchema,
-        annotations: tool.annotations,
-        _meta: tool._meta
-      },
-      handler
-    );
-  }
+  const options = {
+    title,
+    description: tool.description,
+    inputSchema: tool.inputSchema,
+    outputSchema: tool.outputSchema,
+    annotations: tool.annotations,
+    _meta: tool._meta
+  };
+  return server.registerTool(name, options, handler);
 }
 export function defineMcpTool(definition) {
   return definition;

package/dist/runtime/server/mcp/handler.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void>>;
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
 export default _default;

package/dist/runtime/server/mcp/handler.js

@@ -4,6 +4,7 @@ import { tools } from "#nuxt-mcp/tools.mjs";
 import { resources } from "#nuxt-mcp/resources.mjs";
 import { prompts } from "#nuxt-mcp/prompts.mjs";
 import { handlers } from "#nuxt-mcp/handlers.mjs";
+import { defaultHandler } from "#nuxt-mcp/default-handler.mjs";
 import { createMcpHandler } from "./utils.js";
 import { getMcpConfig } from "./config.js";
 export default createMcpHandler((event) => {
@@ -18,12 +19,26 @@ export default createMcpHandler((event) => {
       throw new Error(`Handler "${handlerName}" not found`);
     }
     return {
-      name: handlerDef.name,
+      name: handlerDef.name ?? handlerName,
       version: handlerDef.version ?? config.version,
       browserRedirect: handlerDef.browserRedirect ?? config.browserRedirect,
       tools: handlerDef.tools,
       resources: handlerDef.resources,
-      prompts: handlerDef.prompts
+      prompts: handlerDef.prompts,
+      middleware: handlerDef.middleware
+    };
+  }
+  const defaultHandlerDef = defaultHandler;
+  if (defaultHandlerDef) {
+    return {
+      name: defaultHandlerDef.name ?? config.name ?? "MCP Server",
+      version: defaultHandlerDef.version ?? config.version,
+      browserRedirect: defaultHandlerDef.browserRedirect ?? config.browserRedirect,
+      // Use handler's definitions if specified, otherwise use global definitions
+      tools: defaultHandlerDef.tools ?? tools,
+      resources: defaultHandlerDef.resources ?? resources,
+      prompts: defaultHandlerDef.prompts ?? prompts,
+      middleware: defaultHandlerDef.middleware
     };
   }
   return {

package/dist/runtime/server/mcp/loaders/index.d.ts

@@ -20,6 +20,7 @@ export declare function loadAllDefinitions(paths: LoaderPaths): Promise<{
     resources: LoadResult;
     prompts: LoadResult;
     handlers: LoadResult;
+    hasDefaultHandler: boolean;
 }>;
 /**
  * Get handler route information from loaded handlers

package/dist/runtime/server/mcp/loaders/index.js

@@ -2,6 +2,7 @@ import { addServerTemplate, logger } from "@nuxt/kit";
 import {
   createExcludePatterns,
   createTemplateContent,
+  findIndexFile,
   loadDefinitionFiles,
   toIdentifier
 } from "./utils.js";
@@ -47,7 +48,9 @@ async function loadHandlers(paths = []) {
       excludePatterns,
       filter: (filePath) => {
         const relativePath = filePath.replace(/.*\/server\//, "");
-        return !relativePath.includes("/tools/") && !relativePath.includes("/resources/") && !relativePath.includes("/prompts/");
+        const filename = filePath.split("/").pop();
+        const isIndexFile = /^index\.(?:ts|js|mts|mjs)$/.test(filename);
+        return !relativePath.includes("/tools/") && !relativePath.includes("/resources/") && !relativePath.includes("/prompts/") && !isIndexFile;
       }
     });
     addServerTemplate({
@@ -83,19 +86,48 @@ export async function loadPrompts(paths) {
   return loadMcpDefinitions("prompts", "#nuxt-mcp/prompts.mjs", paths);
 }
 export { loadHandlers };
+async function loadDefaultHandler(paths = []) {
+  try {
+    const indexFile = await findIndexFile(paths);
+    addServerTemplate({
+      filename: "#nuxt-mcp/default-handler.mjs",
+      getContents: () => {
+        if (!indexFile) {
+          return `export const defaultHandler = null
+`;
+        }
+        return `import handler from '${indexFile}'
+export const defaultHandler = handler
+`;
+      }
+    });
+    return indexFile !== null;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    log.error(`Failed to load default handler: ${errorMessage}`);
+    addServerTemplate({
+      filename: "#nuxt-mcp/default-handler.mjs",
+      getContents: () => `export const defaultHandler = null
+`
+    });
+    return false;
+  }
+}
 export async function loadAllDefinitions(paths) {
   try {
-    const [tools, resources, prompts, handlers] = await Promise.all([
+    const [tools, resources, prompts, handlers, hasDefaultHandler] = await Promise.all([
       loadTools(paths.tools),
       loadResources(paths.resources),
       loadPrompts(paths.prompts),
-      loadHandlers(paths.handlers ?? [])
+      loadHandlers(paths.handlers ?? []),
+      loadDefaultHandler(paths.handlers ?? [])
     ]);
     const results = {
       tools,
       resources,
       prompts,
-      handlers
+      handlers,
+      hasDefaultHandler
     };
     return {
       ...results,

package/dist/runtime/server/mcp/loaders/utils.d.ts

@@ -11,6 +11,11 @@ export declare function createLayerFilePatterns(layerServer: string, paths: stri
 export declare function createExcludePatterns(paths: string[], subdirs: string[]): string[];
 export declare function toIdentifier(filename: string): string;
 export declare function createTemplateContent(type: string, entries: Array<[string, string]>): string;
+/**
+ * Find index files (index.ts, index.js, etc.) in the given paths
+ * Returns the file path from the highest priority layer (app overrides extended layers)
+ */
+export declare function findIndexFile(paths: string[], extensions?: string[]): Promise<string | null>;
 export declare function loadDefinitionFiles(paths: string[], options?: {
     excludePatterns?: string[];
     filter?: (filePath: string) => boolean;

package/dist/runtime/server/mcp/loaders/utils.js

@@ -114,6 +114,25 @@ export const ${type} = [
 ]
 `;
 }
+export async function findIndexFile(paths, extensions = ["ts", "js", "mts", "mjs"]) {
+  if (paths.length === 0) {
+    return null;
+  }
+  const layerDirectories = getLayerDirectories();
+  for (const layer of layerDirectories) {
+    const indexPatterns = paths.flatMap(
+      (pathPattern) => extensions.map((ext) => resolvePath(layer.server, `${pathPattern}/index.${ext}`))
+    );
+    const indexFiles = await glob(indexPatterns, {
+      absolute: true,
+      onlyFiles: true
+    });
+    if (indexFiles.length > 0) {
+      return indexFiles[0];
+    }
+  }
+  return null;
+}
 export async function loadDefinitionFiles(paths, options = {}) {
   if (paths.length === 0) {
     return { count: 0, files: [], overriddenCount: 0 };
@@ -127,7 +146,7 @@ export async function loadDefinitionFiles(paths, options = {}) {
     const layerFiles = await glob(layerPatterns, {
       absolute: true,
       onlyFiles: true,
-      ignore: options.excludePatterns
+      ignore: [...options.excludePatterns || [], "**/*.d.ts"]
     });
     const filteredFiles = options.filter ? layerFiles.filter(options.filter) : layerFiles;
     for (const filePath of filteredFiles) {

package/dist/runtime/server/mcp/providers/cloudflare.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("./types.js").McpTransportHandler;
+export default _default;

package/dist/runtime/server/mcp/providers/cloudflare.js

@@ -0,0 +1,15 @@
+import { createMcpHandler } from "agents/mcp";
+import { toWebRequest } from "h3";
+import { createMcpTransportHandler } from "./types.js";
+const fallbackCtx = {
+  waitUntil: () => {
+  },
+  passThroughOnException: () => {
+  }
+};
+export default createMcpTransportHandler((server, event) => {
+  const handler = createMcpHandler(server);
+  const request = toWebRequest(event);
+  const cf = event.context.cloudflare;
+  return handler(request, cf?.env ?? {}, cf?.ctx ?? fallbackCtx);
+});

package/dist/runtime/server/mcp/providers/node.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("./types.js").McpTransportHandler;
+export default _default;

package/dist/runtime/server/mcp/providers/node.js

@@ -0,0 +1,13 @@
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { readBody } from "h3";
+import { createMcpTransportHandler } from "./types.js";
+export default createMcpTransportHandler(async (server, event) => {
+  const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: void 0 });
+  event.node.res.on("close", () => {
+    transport.close();
+    server.close();
+  });
+  await server.connect(transport);
+  const body = await readBody(event);
+  await transport.handleRequest(event.node.req, event.node.res, body);
+});

package/dist/runtime/server/mcp/providers/types.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { H3Event } from 'h3';
+export type McpTransportHandler = (server: McpServer, event: H3Event) => Promise<Response | void> | Response | void;
+export declare const createMcpTransportHandler: (handler: McpTransportHandler) => McpTransportHandler;

package/dist/runtime/server/mcp/providers/types.js

@@ -0,0 +1 @@
+export const createMcpTransportHandler = (handler) => handler;

package/dist/runtime/server/mcp/utils.d.ts

@@ -1,18 +1,17 @@
-import type { McpToolDefinition, McpResourceDefinition, McpPromptDefinition } from './definitions/index.js';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { H3Event } from 'h3';
-export type CreateMcpHandlerConfig = {
+import type { McpToolDefinition, McpResourceDefinition, McpPromptDefinition, McpMiddleware } from './definitions/index.js';
+export type { McpTransportHandler } from './providers/types.js';
+export { createMcpTransportHandler } from './providers/types.js';
+export interface ResolvedMcpConfig {
     name: string;
     version: string;
     browserRedirect: string;
     tools?: McpToolDefinition[];
     resources?: McpResourceDefinition[];
     prompts?: McpPromptDefinition[];
-} | ((event: H3Event) => {
-    name: string;
-    version: string;
-    browserRedirect: string;
-    tools?: McpToolDefinition[];
-    resources?: McpResourceDefinition[];
-    prompts?: McpPromptDefinition[];
-});
-export declare function createMcpHandler(config: CreateMcpHandlerConfig): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void>>;
+    middleware?: McpMiddleware;
+}
+export type CreateMcpHandlerConfig = ResolvedMcpConfig | ((event: H3Event) => ResolvedMcpConfig);
+export declare function createMcpServer(config: ResolvedMcpConfig): McpServer;
+export declare function createMcpHandler(config: CreateMcpHandlerConfig): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;

package/dist/runtime/server/mcp/utils.js

@@ -1,11 +1,12 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { sendRedirect, getHeader, defineEventHandler } from "h3";
 import { registerToolFromDefinition, registerResourceFromDefinition, registerPromptFromDefinition } from "./definitions/index.js";
-import { sendRedirect, getHeader, readBody, defineEventHandler } from "h3";
+import handleMcpRequest from "#nuxt-mcp/transport.mjs";
+export { createMcpTransportHandler } from "./providers/types.js";
 function resolveConfig(config, event) {
   return typeof config === "function" ? config(event) : config;
 }
-function createMcpServer(config) {
+export function createMcpServer(config) {
   const server = new McpServer({
     name: config.name,
     version: config.version
@@ -27,16 +28,27 @@ export function createMcpHandler(config) {
     if (getHeader(event, "accept")?.includes("text/html")) {
       return sendRedirect(event, resolvedConfig.browserRedirect);
     }
-    const server = createMcpServer(resolvedConfig);
-    const transport = new StreamableHTTPServerTransport({
-      sessionIdGenerator: void 0
-    });
-    event.node.res.on("close", () => {
-      transport.close();
-      server.close();
-    });
-    await server.connect(transport);
-    const body = await readBody(event);
-    await transport.handleRequest(event.node.req, event.node.res, body);
+    const handler = async () => {
+      const server = createMcpServer(resolvedConfig);
+      return handleMcpRequest(server, event);
+    };
+    if (resolvedConfig.middleware) {
+      let nextCalled = false;
+      let handlerResult;
+      const next = async () => {
+        nextCalled = true;
+        handlerResult = await handler();
+        return handlerResult;
+      };
+      const middlewareResult = await resolvedConfig.middleware(event, next);
+      if (middlewareResult !== void 0) {
+        return middlewareResult;
+      }
+      if (nextCalled) {
+        return handlerResult;
+      }
+      return handler();
+    }
+    return handler();
   });
 }

package/dist/runtime/server/types.server.d.ts

@@ -12,3 +12,10 @@ declare module '#nuxt-mcp/resources.mjs' {
 declare module '#nuxt-mcp/prompts.mjs' {
   export const prompts: McpPromptDefinition[]
 }
+
+declare module '#nuxt-mcp/transport.mjs' {
+  import type { McpTransportHandler } from './mcp/providers/types'
+
+  const handleMcpRequest: McpTransportHandler
+  export default handleMcpRequest
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuxtjs/mcp-toolkit",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "Create MCP servers directly in your Nuxt application. Define tools, resources, and prompts with a simple and intuitive API.",
   "repository": {
     "type": "git",
@@ -33,10 +33,10 @@
   ],
   "dependencies": {
     "@clack/prompts": "^0.11.0",
-    "@modelcontextprotocol/sdk": "^1.23.0",
-    "@nuxt/kit": "^4.2.1",
+    "@modelcontextprotocol/sdk": "^1.25.1",
+    "@nuxt/kit": "^4.2.2",
     "automd": "^0.4.2",
-    "chokidar": "^4.0.3",
+    "chokidar": "^5.0.0",
     "defu": "^6.1.4",
     "ms": "^2.1.3",
     "pathe": "^2.0.3",
@@ -45,26 +45,30 @@
     "tinyglobby": "^0.2.15"
   },
   "peerDependencies": {
-    "zod": "^4.1.13"
+    "zod": "^4.1.13",
+    "agents": ">=0.2.32"
   },
   "peerDependenciesMeta": {
     "zod": {
       "optional": false
+    },
+    "agents": {
+      "optional": true
     }
   },
   "devDependencies": {
-    "@nuxt/devtools": "^3.1.0",
-    "@nuxt/eslint-config": "^1.10.0",
+    "@nuxt/devtools": "^3.1.1",
+    "@nuxt/eslint-config": "^1.12.1",
     "@nuxt/module-builder": "^1.0.2",
-    "@nuxt/schema": "^4.2.1",
-    "@nuxt/test-utils": "^3.20.1",
+    "@nuxt/schema": "^4.2.2",
+    "@nuxt/test-utils": "^3.21.0",
     "@types/node": "latest",
     "changelogen": "^0.6.2",
-    "eslint": "^9.39.1",
-    "nuxt": "^4.2.1",
+    "eslint": "^9.39.2",
+    "nuxt": "^4.2.2",
     "typescript": "~5.9.3",
-    "vitest": "^4.0.10",
-    "vue-tsc": "^3.1.4"
+    "vitest": "^4.0.16",
+    "vue-tsc": "^3.1.8"
   },
   "publishConfig": {
     "access": "public"