@kubb/plugin-mcp 5.0.0-beta.64 → 5.0.0-beta.74

package/dist/index.d.ts

@@ -1,100 +1,18 @@
-import { t as __name } from "./chunk-C0LytTxp.js";
-import { Exclude, Generator, Group, Include, Output, OutputOptions, 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, ast } from "@kubb/core";
 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;
-};
-/**
- * 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 & {
-  /**
-   * HTTP client used by each MCP handler to call the underlying API. Mirrors a
-   * subset of `pluginClient` options.
-   */
-  client?: ClientImportPath & Pick<PluginClient['options'], 'clientType' | 'dataReturnType' | 'baseURL' | 'bundle' | 'paramsCasing'>;
-  /**
-   * Rename parameter properties in the generated handlers. The HTTP layer still
-   * uses the original spec names; Kubb writes the mapping for you.
-   *
-   * @note Must match the value of `paramsCasing` on `@kubb/plugin-ts`.
-   */
-  paramsCasing?: 'camelcase';
-  /**
-   * 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?: Partial<ResolverMcp> & ThisType<ResolverMcp>;
-  /**
-   * Macros applied to each operation node before printing.
-   */
-  macros?: Array<ast.Macro>;
-  /**
-   * Custom generators that run alongside the built-in MCP generators.
-   */
-  generators?: Array<Generator<PluginMcp>>;
-};
-type ResolvedOptions = {
-  output: Output;
-  exclude: Array<Exclude>;
-  include: Array<Include> | undefined;
-  override: Array<Override<ResolvedOptions>>;
-  group: Group | null;
-  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
 //#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.
    */
@@ -103,29 +21,12 @@ type Props$1 = {
    * TypeScript resolver for resolving param/data/response type names.
    */
   resolver: ResolverTs;
-  /**
-   * Base URL prepended to every generated request URL.
-   */
-  baseURL: string | null | 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,
+  clientName,
   node,
-  resolver,
-  baseURL,
-  dataReturnType,
-  paramsCasing
+  resolver
 }: Props$1): KubbReactNode;
 //#endregion
 //#region src/utils.d.ts
@@ -148,10 +49,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.
@@ -186,16 +83,127 @@ declare function Server({
   name,
   serverName,
   serverVersion,
-  paramsCasing,
   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 & {
+  /**
+   * 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;
+};
+/**
+ * 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?: Partial<ResolverMcp> & ThisType<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
 /**
  * Built-in operation generator for `@kubb/plugin-mcp`. Emits one MCP tool
- * handler per OpenAPI operation, wiring the input Zod schema, the HTTP call,
- * and the response shape into a single function that an MCP server can
- * register as a callable 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/core").Generator<PluginMcp, unknown>;
 //#endregion
@@ -218,13 +226,13 @@ declare const pluginMcpName = "plugin-mcp";
 /**
  * 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.
+ * 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'
  * import { pluginTs } from '@kubb/plugin-ts'
- * import { pluginClient } from '@kubb/plugin-client'
  * import { pluginZod } from '@kubb/plugin-zod'
  * import { pluginMcp } from '@kubb/plugin-mcp'
  *
@@ -233,11 +241,10 @@ declare const pluginMcpName = "plugin-mcp";
  *   output: { path: './src/gen' },
  *   plugins: [
  *     pluginTs(),
- *     pluginClient(),
  *     pluginZod(),
  *     pluginMcp({
  *       output: { path: './mcp' },
- *       client: { baseURL: 'https://petstore.swagger.io/v2' },
+ *       baseURL: 'https://petstore.swagger.io/v2',
  *     }),
  *   ],
  * })