@kubb/plugin-mcp 5.0.0-beta.10 → 5.0.0-beta.100

package/dist/index.d.ts

@@ -1,99 +1,18 @@
-import { t as __name } from "./chunk--u3MIqq1.js";
-import * as _$_kubb_core0 from "@kubb/core";
-import { Exclude, Generator, Group, Include, Output, Override, PluginFactoryOptions, Resolver, ast } from "@kubb/core";
+import { t as __name } from "./rolldown-runtime-C0LytTxp.js";
+import { Exclude, Group, Include, Output, OutputOptions, Override, PluginFactoryOptions, Resolver, ResolverPatch, ast } from "kubb/kit";
+import { KubbReactNode } from "kubb/jsx";
 import { ResolverTs } from "@kubb/plugin-ts";
-import { ClientImportPath, PluginClient } from "@kubb/plugin-client";
-import { KubbReactNode } from "@kubb/renderer-jsx/types";
-
-//#region src/types.d.ts
-/**
- * Resolver for MCP that provides naming methods for handler functions.
- */
-type ResolverMcp = Resolver & {
-  /**
-   * Resolves the base handler function name for an operation.
-   *
-   * @example Resolving handler function names
-   * `resolver.resolveName('show pet by id') // -> 'showPetByIdHandler'`
-   */
-  resolveName(this: ResolverMcp, name: string): string;
-  /**
-   * Resolves the output file name for an MCP module.
-   */
-  resolvePathName(this: ResolverMcp, name: string, type?: 'file' | 'function' | 'type' | 'const'): string;
-  /**
-   * Resolves the handler function name for an operation.
-   */
-  resolveHandlerName(this: ResolverMcp, node: ast.OperationNode): string;
-};
-type Options = {
-  /**
-   * Specify the export location for the files and define the behavior of the output.
-   * @default { path: 'mcp', barrelType: 'named' }
-   */
-  output?: Output;
-  /**
-   * Client configuration for HTTP request generation.
-   */
-  client?: ClientImportPath & Pick<PluginClient['options'], 'clientType' | 'dataReturnType' | 'baseURL' | 'bundle' | 'paramsCasing'>;
-  /**
-   * Apply casing to parameter names to match your configuration.
-   */
-  paramsCasing?: 'camelcase';
-  /**
-   * Group the MCP requests based on the provided name.
-   */
-  group?: Group;
-  /**
-   * Tags, operations, or paths to exclude from generation.
-   */
-  exclude?: Array<Exclude>;
-  /**
-   * Tags, operations, or paths to include in generation.
-   */
-  include?: Array<Include>;
-  /**
-   * Override options for specific tags, operations, or paths.
-   */
-  override?: Array<Override<ResolvedOptions>>;
-  /**
-   * Override naming conventions for function names and types.
-   */
-  resolver?: Partial<ResolverMcp> & ThisType<ResolverMcp>;
-  /**
-   * AST visitor to transform generated nodes.
-   */
-  transformer?: ast.Visitor;
-  /**
-   * Additional generators alongside the default generators.
-   */
-  generators?: Array<Generator<PluginMcp>>;
-};
-type ResolvedOptions = {
-  output: Output;
-  exclude: Array<Exclude>;
-  include: Array<Include> | undefined;
-  override: Array<Override<ResolvedOptions>>;
-  group: Group | undefined;
-  client: Pick<PluginClient['options'], 'client' | 'clientType' | 'dataReturnType' | 'importPath' | 'baseURL' | 'bundle' | 'paramsCasing'>;
-  paramsCasing: Options['paramsCasing'];
-  resolver: ResolverMcp;
-};
-type PluginMcp = PluginFactoryOptions<'plugin-mcp', Options, ResolvedOptions, ResolverMcp>;
-declare global {
-  namespace Kubb {
-    interface PluginRegistry {
-      'plugin-mcp': PluginMcp;
-    }
-  }
-}
-//#endregion
+import "@kubb/plugin-zod";
 //#region src/components/McpHandler.d.ts
 type Props$1 = {
   /**
    * Name of the handler function.
    */
   name: string;
+  /**
+   * Name of the contract client `<op>` the handler calls.
+   */
+  clientName: string;
   /**
    * AST operation node.
    */
@@ -102,30 +21,8 @@ type Props$1 = {
    * TypeScript resolver for resolving param/data/response type names.
    */
   resolver: ResolverTs;
-  /**
-   * Base URL prepended to every generated request URL.
-   */
-  baseURL: string | undefined;
-  /**
-   * Return type when calling fetch.
-   * - 'data' returns response data only.
-   * - 'full' returns the full response object.
-   * @default 'data'
-   */
-  dataReturnType: PluginMcp['resolvedOptions']['client']['dataReturnType'];
-  /**
-   * How to style your params.
-   */
-  paramsCasing?: PluginMcp['resolvedOptions']['paramsCasing'];
 };
-declare function McpHandler({
-  name,
-  node,
-  resolver,
-  baseURL,
-  dataReturnType,
-  paramsCasing
-}: Props$1): KubbReactNode;
+declare function McpHandler({ name, clientName, node, resolver }: Props$1): KubbReactNode;
 //#endregion
 //#region src/utils.d.ts
 type ZodParam = {
@@ -147,10 +44,6 @@ type Props = {
    * Semantic version string passed to `new McpServer({ version })`.
    */
   serverVersion: string;
-  /**
-   * How to style your params.
-   */
-  paramsCasing?: PluginMcp['resolvedOptions']['paramsCasing'];
   /**
    * Operations to register as MCP tools, each carrying its handler,
    * zod schema, and AST node metadata.
@@ -170,27 +63,136 @@ type Props = {
       /**
        * Query params — individual schemas to compose into `z.object({ ... })`.
        */
-      queryParams?: string | Array<ZodParam>;
+      queryParams?: string | Array<ZodParam> | null;
       /**
        * Header params — individual schemas to compose into `z.object({ ... })`.
        */
-      headerParams?: string | Array<ZodParam>;
-      requestName?: string;
-      responseName?: string;
+      headerParams?: string | Array<ZodParam> | null;
+      requestName?: string | null;
+      responseName?: string | null;
     };
     node: ast.OperationNode;
   }>;
 };
-declare function Server({
-  name,
-  serverName,
-  serverVersion,
-  paramsCasing,
-  operations
-}: Props): KubbReactNode;
+declare function Server({ name, serverName, serverVersion, operations }: Props): KubbReactNode;
+//#endregion
+//#region ../../internals/client/src/resolveClient.d.ts
+/**
+ * Resolves which client plugin a consumer (react-query, vue-query, swr, mcp) should call for an
+ * operation, shared so the selection rules and diagnostics stay in one place.
+ *
+ * Every client runtime lives in a dedicated client plugin, so a consumer always calls a registered
+ * contract client plugin (plugin-fetch or plugin-axios) and never emits its own inline client:
+ *
+ * - `contract` — a registered contract client plugin owns the `<op>` functions and the consumer
+ *   imports and calls them.
+ * - `error` — no client plugin is registered, several are registered without a selector, or the
+ *   requested one is missing.
+ *
+ * The `client` string selects explicitly (`'fetch'` / `'axios'`); when it is unset a lone registered
+ * contract client plugin is picked up automatically.
+ */
+/**
+ * The client selector accepted by a consumer's `client` option. Both call a registered contract
+ * client plugin.
+ */
+type ClientSelector = 'fetch' | 'axios';
+//#endregion
+//#region src/types.d.ts
+/**
+ * Resolver for MCP that provides naming methods for handler functions.
+ */
+type ResolverMcp = Resolver & {
+  /**
+   * Naming for the generated MCP tool handler functions.
+   */
+  handler: {
+    /**
+     * Resolves the handler function name for an operation.
+     *
+     * @example Resolving handler function names
+     * `resolver.handler.name(operationNode) // -> 'showPetByIdHandler'`
+     */
+    name(node: ast.OperationNode): string;
+  };
+};
+/**
+ * Where the generated MCP tool handlers are written and how they are exported, plus the optional
+ * `group` strategy. The `group` option organizes `output.mode: 'directory'` output into per-tag or per-path subdirectories.
+ *
+ * @default { path: 'mcp', barrel: { type: 'named' } }
+ */
+type Options = OutputOptions & {
+  /**
+   * Selects the HTTP client each MCP handler calls. Every client plugin speaks the `RequestResult`
+   * contract, so each handler calls a contract `<op>` that takes one grouped `{ path, query, headers,
+   * body }` object.
+   *
+   * `'fetch'` / `'axios'` calls the `@kubb/plugin-fetch` / `@kubb/plugin-axios` functions. When a
+   * single client plugin (plugin-fetch or plugin-axios) is registered it is auto-detected, so the
+   * string is only needed to disambiguate several client plugins. Register one of those plugins.
+   * Options such as `baseURL` live there.
+   */
+  client?: ClientSelector;
+  /**
+   * Skip operations matching at least one entry in the list.
+   */
+  exclude?: Array<Exclude>;
+  /**
+   * Restrict generation to operations matching at least one entry in the list.
+   */
+  include?: Array<Include>;
+  /**
+   * Apply a different options object to operations matching a pattern.
+   */
+  override?: Array<Override<ResolvedOptions>>;
+  /**
+   * Override how handler names and file paths are built. Methods you omit fall
+   * back to the default `resolverMcp`.
+   */
+  resolver?: ResolverPatch<ResolverMcp>;
+  /**
+   * Macros applied to each operation node before printing.
+   */
+  macros?: Array<ast.Macro>;
+};
+/**
+ * The resolved client strategy for the generated handlers, computed once during setup. The handlers
+ * always import and call a registered contract client plugin's `<op>`.
+ */
+type ResolvedClient = {
+  kind: 'contract';
+  pluginName: string;
+};
+type ResolvedOptions = {
+  output: Output;
+  exclude: Array<Exclude>;
+  include: Array<Include> | undefined;
+  override: Array<Override<ResolvedOptions>>;
+  group: Group | null;
+  /**
+   * The resolved client strategy the generators branch on.
+   */
+  client: ResolvedClient;
+  resolver: ResolverMcp;
+};
+type PluginMcp = PluginFactoryOptions<'plugin-mcp', Options, ResolvedOptions, ResolverMcp>;
+declare global {
+  namespace Kubb {
+    interface PluginRegistry {
+      'plugin-mcp': PluginMcp;
+    }
+  }
+}
 //#endregion
 //#region src/generators/mcpGenerator.d.ts
-declare const mcpGenerator: _$_kubb_core0.Generator<PluginMcp, unknown>;
+/**
+ * Built-in operation generator for `@kubb/plugin-mcp`. Emits one MCP tool
+ * handler per OpenAPI operation. The handler takes the grouped `{ path, query,
+ * headers, body }` config and forwards it to the registered client plugin's
+ * (`@kubb/plugin-axios` / `@kubb/plugin-fetch`) `<op>` function.
+ */
+declare const mcpGenerator: import("kubb/kit").Generator<PluginMcp, unknown>;
 //#endregion
 //#region src/generators/serverGenerator.d.ts
 /**
@@ -200,20 +202,55 @@ declare const mcpGenerator: _$_kubb_core0.Generator<PluginMcp, unknown>;
  * and `resolveResponseStatusName` for per-status response schemas.
  * Query and header params are composed into `z.object({ ... })` from individual schemas.
  */
-declare const serverGenerator: _$_kubb_core0.Generator<PluginMcp, unknown>;
+declare const serverGenerator: import("kubb/kit").Generator<PluginMcp, unknown>;
 //#endregion
 //#region src/plugin.d.ts
+/**
+ * Canonical plugin name for `@kubb/plugin-mcp`. Used for driver lookups and
+ * cross-plugin dependency references.
+ */
 declare const pluginMcpName = "plugin-mcp";
-declare const pluginMcp: (options?: Options | undefined) => _$_kubb_core0.Plugin<PluginMcp>;
+/**
+ * Generates a Model Context Protocol (MCP) server from an OpenAPI spec. Every
+ * operation becomes a typed MCP tool that AI assistants (Claude Desktop, Claude
+ * Code, MCP-compatible clients) can call directly. Each handler calls a contract
+ * client `<op>` from a registered `@kubb/plugin-axios` or `@kubb/plugin-fetch`.
+ *
+ * @example
+ * ```ts
+ * import { defineConfig } from 'kubb/config'
+ * import { pluginTs } from '@kubb/plugin-ts'
+ * import { pluginZod } from '@kubb/plugin-zod'
+ * import { pluginMcp } from '@kubb/plugin-mcp'
+ *
+ * export default defineConfig({
+ *   input: './petStore.yaml',
+ *   output: { path: './src/gen' },
+ *   plugins: [
+ *     pluginTs(),
+ *     pluginZod(),
+ *     pluginMcp({
+ *       output: { path: './mcp' },
+ *       baseURL: 'https://petstore.swagger.io/v2',
+ *     }),
+ *   ],
+ * })
+ * ```
+ */
+declare const pluginMcp: (options?: Options | undefined) => import("kubb/kit").Plugin<PluginMcp>;
 //#endregion
 //#region src/resolvers/resolverMcp.d.ts
 /**
- * Naming convention resolver for MCP plugin.
+ * Default resolver used by `@kubb/plugin-mcp`. Decides the names and file
+ * paths for every generated MCP tool handler. Function names get a `Handler`
+ * suffix so an operation `addPet` becomes `addPetHandler`.
  *
- * Provides default naming helpers using camelCase with a `handler` suffix for functions.
+ * @example Resolve a handler name
+ * ```ts
+ * import { resolverMcp } from '@kubb/plugin-mcp'
  *
- * @example
- * `resolverMcp.default('addPet', 'function')  // → 'addPetHandler'`
+ * resolverMcp.name('addPet') // 'addPetHandler'
+ * ```
  */
 declare const resolverMcp: ResolverMcp;
 //#endregion