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

package/dist/index.js

@@ -1,15 +1,10 @@
-import "./chunk-C0LytTxp.js";
+import "./rolldown-runtime-C0LytTxp.js";
 import path from "node:path";
 import { ast, defineGenerator, definePlugin, defineResolver } from "@kubb/core";
-import { caseParams, createOperationParams } from "@kubb/ast/utils";
-import { functionPrinter, pluginTsName } from "@kubb/plugin-ts";
 import { Const, File, Function, jsxRenderer } from "@kubb/renderer-jsx";
 import { Fragment, jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
+import { createFunctionParameter, createFunctionParameters, createObjectBindingPattern, functionPrinter, pluginTsName } from "@kubb/plugin-ts";
 import { pluginZodName } from "@kubb/plugin-zod";
-import { pluginClientName } from "@kubb/plugin-client";
-import { source } from "@kubb/plugin-client/templates/clients/axios.source";
-import { source as source$1 } from "@kubb/plugin-client/templates/clients/fetch.source";
-import { source as source$2 } from "@kubb/plugin-client/templates/config.source";
 //#region ../../internals/utils/src/casing.ts
 /**
 * Shared implementation for camelCase and PascalCase conversion.
@@ -222,6 +217,22 @@ var Url = class Url {
 		return `\`${prefix ?? ""}${result}\``;
 	}
 	/**
+	* Converts an OpenAPI/Swagger path to a template literal that reads each parameter off the
+	* grouped `path` request option, e.g. `/pet/{petId}` becomes `` `/pet/${path.petId}` ``. Parameter
+	* names are camelCased to match the generated `path` type, and `prefix` is prepended inside the
+	* literal. Shared by the client and cypress generators that pass a grouped `path` object.
+	*
+	* @example
+	* Url.toGroupedTemplateString('/pet/{petId}') // '`/pet/${path.petId}`'
+	*/
+	static toGroupedTemplateString(path, { prefix } = {}) {
+		return Url.toTemplateString(path, {
+			prefix,
+			casing: "camelcase",
+			replacer: (name) => `path.${name}`
+		});
+	}
+	/**
 	* Returns the path and its extracted params as a structured `URLObject`, or as a stringified
 	* expression when `stringify` is set.
 	*
@@ -249,13 +260,121 @@ var Url = class Url {
 	}
 };
 //#endregion
+//#region ../../internals/shared/src/params.ts
+const caseParamsCache = /* @__PURE__ */ new WeakMap();
+/**
+* Applies camelCase to parameter names and returns a new array without mutating the input.
+*
+* Run it before handing parameters to schema builders so output property keys get the right casing
+* while `OperationNode.parameters` stays intact for other consumers. When `casing` is unset, the
+* original array is returned unchanged. Results are cached per input array.
+*/
+function caseParams(params, casing) {
+	if (!casing) return params;
+	const cached = caseParamsCache.get(params);
+	if (cached) return cached;
+	const result = params.map((param) => ({
+		...param,
+		name: camelCase(param.name)
+	}));
+	caseParamsCache.set(params, result);
+	return result;
+}
+//#endregion
 //#region ../../internals/shared/src/operation.ts
+/**
+* Builds the `ResolverFileParams` every operation generator passes to
+* `resolver.resolveFile`: a file named `name`, tagged by the operation's first
+* tag (or `'default'`), at the operation's path. Centralizes the entry object
+* that was repeated at dozens of call sites across the client and query plugins.
+*
+* @example
+* ```ts
+* resolver.resolveFile(operationFileEntry(node, node.operationId), { root, output, group })
+* ```
+*/
+function operationFileEntry(node, name, extname = ".ts") {
+	return {
+		name,
+		extname,
+		tag: node.tags[0] ?? "default",
+		path: node.path
+	};
+}
 function getOperationLink(node, link) {
 	if (!link) return null;
 	if (typeof link === "function") return link(node) ?? null;
 	if (link === "urlPath") return node.path ? `{@link ${Url.toPath(node.path)}}` : null;
 	return node.path ? `{@link ${node.path.replaceAll("{", ":").replaceAll("}", "")}}` : null;
 }
+function getContentTypeInfo(node) {
+	const contentTypes = node.requestBody?.content?.map((e) => e.contentType) ?? [];
+	const isMultipleContentTypes = contentTypes.length > 1;
+	return {
+		contentTypes,
+		isMultipleContentTypes,
+		contentTypeUnion: isMultipleContentTypes ? contentTypes.map((ct) => JSON.stringify(ct)).join(" | ") : "",
+		defaultContentType: contentTypes[0] ?? "application/json",
+		hasFormData: contentTypes.some((ct) => ct === "multipart/form-data")
+	};
+}
+function buildRequestConfigType(node) {
+	const { isMultipleContentTypes, contentTypeUnion } = getContentTypeInfo(node);
+	const configType = `Partial<Omit<RequestConfig, 'path' | 'query' | 'body' | 'headers' | 'url'>>`;
+	const contentTypeProp = isMultipleContentTypes ? `contentType?: ${contentTypeUnion}` : null;
+	return contentTypeProp ? `${configType} & { ${contentTypeProp} }` : configType;
+}
+/**
+* Which of the grouped request options an operation carries.
+*/
+function getRequestGroups(node) {
+	const { path, query, header } = getOperationParameters(node);
+	return {
+		path: path.length > 0,
+		query: query.length > 0,
+		body: Boolean(node.requestBody?.content?.[0]?.schema),
+		headers: header.length > 0
+	};
+}
+/**
+* Resolves which grouped request options an operation carries together with whether each group
+* holds a required member. The grouped parameter stays optional only when nothing inside it is
+* required, matching the generated `RequestConfig` type.
+*/
+function getRequestGroupOptionality(node) {
+	const groups = getRequestGroups(node);
+	const { path, query, header } = getOperationParameters(node);
+	const hasRequiredPath = path.some((param) => param.required);
+	const hasRequiredQuery = query.some((param) => param.required);
+	const hasRequiredHeader = header.some((param) => param.required);
+	return {
+		groups,
+		hasRequiredPath,
+		hasRequiredQuery,
+		hasRequiredHeader,
+		isOptional: !hasRequiredPath && !hasRequiredQuery && !hasRequiredHeader && !groups.body
+	};
+}
+/**
+* Builds the grouped `{ path, query, body, headers }` parameter for a generated client
+* function, typed from the operation's `RequestConfig` (minus `url`). Only the groups the
+* operation actually has are destructured. The trailing `config` parameter carries the
+* runtime `RequestConfig` overrides plus `client`.
+*/
+function buildRequestParamsSignature(node, resolver, options = {}) {
+	const { isConfigurable = true } = options;
+	const { groups, isOptional } = getRequestGroupOptionality(node);
+	const names = [
+		"path",
+		"query",
+		"body",
+		"headers"
+	].filter((key) => groups[key]);
+	return {
+		signature: [names.length > 0 ? `{ ${names.join(", ")} }: ${resolver.resolveRequestConfigName(node)}${isOptional ? " = {}" : ""}` : null, isConfigurable ? `config: ${buildRequestConfigType(node)} = {}` : null].filter(Boolean).join(", "),
+		groups
+	};
+}
 function buildOperationComments(node, options = {}) {
 	const { link = "pathTemplate", linkPosition = "afterDeprecated", splitLines = false } = options;
 	const linkComment = getOperationLink(node, link);
@@ -274,7 +393,7 @@ function buildOperationComments(node, options = {}) {
 	return filteredComments.flatMap((text) => text.split(/\r?\n/).map((line) => line.trim())).filter((comment) => Boolean(comment));
 }
 function getOperationParameters(node, options = {}) {
-	const params = caseParams(node.parameters, options.paramsCasing);
+	const params = caseParams(node.parameters, options.paramsCasing === "original" ? void 0 : "camelcase");
 	return {
 		path: params.filter((param) => param.in === "path"),
 		query: params.filter((param) => param.in === "query"),
@@ -290,48 +409,6 @@ function isSuccessStatusCode(statusCode) {
 	const code = getStatusCodeNumber(statusCode);
 	return code !== null && code >= 200 && code < 300;
 }
-function isErrorStatusCode(statusCode) {
-	const code = getStatusCodeNumber(statusCode);
-	return code !== null && code >= 400;
-}
-function resolveErrorNames(node, resolver) {
-	return node.responses.filter((response) => isErrorStatusCode(response.statusCode)).map((response) => resolver.resolveResponseStatusName(node, response.statusCode));
-}
-function resolveStatusCodeNames(node, resolver) {
-	return node.responses.map((response) => resolver.resolveResponseStatusName(node, response.statusCode));
-}
-const typeNamesByResolver = /* @__PURE__ */ new WeakMap();
-function resolveOperationTypeNames(node, resolver, options = {}) {
-	const cacheKey = `${node.operationId}\0${options.paramsCasing ?? ""}\0${options.order ?? ""}\0${options.responseStatusNames ?? ""}\0${(options.exclude ?? []).join(",")}`;
-	let byResolver = typeNamesByResolver.get(resolver);
-	if (byResolver) {
-		const cached = byResolver.get(cacheKey);
-		if (cached) return cached;
-	} else {
-		byResolver = /* @__PURE__ */ new Map();
-		typeNamesByResolver.set(resolver, byResolver);
-	}
-	const { path, query, header } = getOperationParameters(node, { paramsCasing: options.paramsCasing });
-	const responseStatusNames = options.responseStatusNames === "error" ? resolveErrorNames(node, resolver) : options.responseStatusNames === false ? [] : resolveStatusCodeNames(node, resolver);
-	const exclude = new Set(options.exclude ?? []);
-	const paramNames = [
-		...path.map((param) => resolver.resolvePathParamsName(node, param)),
-		...query.map((param) => resolver.resolveQueryParamsName(node, param)),
-		...header.map((param) => resolver.resolveHeaderParamsName(node, param))
-	];
-	const bodyAndResponseNames = [node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : null, resolver.resolveResponseName(node)];
-	const result = (options.order === "body-response-first" ? [
-		...bodyAndResponseNames,
-		...paramNames,
-		...responseStatusNames
-	] : [
-		...paramNames,
-		...bodyAndResponseNames,
-		...responseStatusNames
-	]).filter((name) => Boolean(name) && !exclude.has(name));
-	byResolver.set(cacheKey, result);
-	return result;
-}
 function findSuccessStatusCode(responses) {
 	for (const response of responses) if (isSuccessStatusCode(response.statusCode)) return response.statusCode;
 	return null;
@@ -368,76 +445,19 @@ function createGroupConfig(group) {
 	};
 }
 //#endregion
-//#region ../../internals/shared/src/params.ts
-function buildParamsMapping(originalParams, mappedParams) {
-	const mapping = {};
-	let hasChanged = false;
-	originalParams.forEach((param, i) => {
-		const mappedName = mappedParams[i]?.name ?? param.name;
-		mapping[param.name] = mappedName;
-		if (param.name !== mappedName) hasChanged = true;
-	});
-	return hasChanged ? mapping : null;
-}
-function buildTransformedParamsMapping(params, transformName) {
-	if (!params.length) return null;
-	return buildParamsMapping(params, params.map((param) => ({
-		...param,
-		name: transformName(param.name)
-	})));
-}
-//#endregion
 //#region src/components/McpHandler.tsx
-/**
-* Generate a remapping statement: `const mappedX = x ? { "orig": x.camel, ... } : undefined`
-*/
-function buildRemappingCode(mapping, varName, sourceName) {
-	return `const ${varName} = ${sourceName} ? { ${Object.entries(mapping).map(([orig, camel]) => `"${orig}": ${sourceName}.${camel}`).join(", ")} } : undefined`;
-}
-const declarationPrinter = functionPrinter({ mode: "declaration" });
-function McpHandler({ name, node, resolver, baseURL, dataReturnType, paramsCasing }) {
+const requestGroupOrder = [
+	"path",
+	"query",
+	"headers",
+	"body"
+];
+function McpHandler({ name, clientName, node, resolver }) {
 	if (!ast.isHttpOperationNode(node)) return null;
-	const contentType = node.requestBody?.content?.[0]?.contentType;
-	const isFormData = contentType === "multipart/form-data";
-	const { query: queryParams, header: headerParams } = getOperationParameters(node, { paramsCasing });
-	const { path: originalPathParams, query: originalQueryParams, header: originalHeaderParams } = getOperationParameters(node);
-	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : null;
-	const responseName = resolver.resolveResponseName(node);
-	const errorResponses = node.responses.filter((r) => Number(r.statusCode) >= 400).map((r) => resolver.resolveResponseStatusName(node, r.statusCode));
-	const generics = [
-		responseName,
-		`ResponseErrorConfig<${errorResponses.length > 0 ? errorResponses.join(" | ") : "Error"}>`,
-		requestName || "unknown"
-	].filter(Boolean);
-	const paramsNode = createOperationParams(node, {
-		paramsType: "object",
-		pathParamsType: "inline",
-		resolver,
-		paramsCasing
-	});
-	const baseParamsSignature = declarationPrinter.print(paramsNode) ?? "";
-	const paramsSignature = baseParamsSignature ? `${baseParamsSignature}, request: RequestHandlerExtra<ServerRequest, ServerNotification>` : "request: RequestHandlerExtra<ServerRequest, ServerNotification>";
-	const pathParamsMapping = paramsCasing ? buildTransformedParamsMapping(originalPathParams, camelCase) : null;
-	const queryParamsMapping = paramsCasing ? buildTransformedParamsMapping(originalQueryParams, camelCase) : null;
-	const headerParamsMapping = paramsCasing ? buildTransformedParamsMapping(originalHeaderParams, camelCase) : null;
-	const contentTypeHeader = contentType && contentType !== "application/json" && contentType !== "multipart/form-data" ? `'Content-Type': '${contentType}'` : null;
-	const headers = [headerParams.length ? headerParamsMapping ? "...mappedHeaders" : "...headers" : null, contentTypeHeader].filter(Boolean);
-	const fetchConfig = [];
-	fetchConfig.push(`method: ${JSON.stringify(node.method.toUpperCase())}`);
-	fetchConfig.push(`url: ${Url.toTemplateString(node.path)}`);
-	if (baseURL) fetchConfig.push(`baseURL: \`${baseURL}\``);
-	if (queryParams.length) fetchConfig.push(queryParamsMapping ? "params: mappedParams" : "params");
-	if (requestName) fetchConfig.push(`data: ${isFormData ? "formData as FormData" : "requestData"}`);
-	if (headers.length) fetchConfig.push(`headers: { ${headers.join(", ")} }`);
-	const callToolResult = `return {
-  content: [
-    {
-      type: 'text',
-      text: JSON.stringify(${dataReturnType === "data" ? "res.data" : "res"})
-    }
-  ],
-  structuredContent: { data: res.data }
-}`;
+	const { signature, groups } = buildRequestParamsSignature(node, resolver, { isConfigurable: false });
+	const paramsSignature = [signature, "request: RequestHandlerExtra<ServerRequest, ServerNotification>"].filter(Boolean).join(", ");
+	const callArgs = requestGroupOrder.filter((key) => groups[key]);
+	const callConfig = callArgs.length ? `{ ${callArgs.join(", ")} }` : "{}";
 	return /* @__PURE__ */ jsx(File.Source, {
 		name,
 		isExportable: true,
@@ -450,28 +470,17 @@ function McpHandler({ name, node, resolver, baseURL, dataReturnType, paramsCasin
 			JSDoc: { comments: buildOperationComments(node) },
 			returnType: "Promise<CallToolResult>",
 			children: [
-				"",
+				`const res = await ${clientName}(${callConfig})`,
 				/* @__PURE__ */ jsx("br", {}),
-				/* @__PURE__ */ jsx("br", {}),
-				pathParamsMapping && Object.entries(pathParamsMapping).filter(([originalName, camelCaseName]) => originalName !== camelCaseName && isValidVarName(originalName)).map(([originalName, camelCaseName]) => `const ${originalName} = ${camelCaseName}`).join("\n"),
-				pathParamsMapping && /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("br", {}), /* @__PURE__ */ jsx("br", {})] }),
-				queryParamsMapping && queryParams.length > 0 && /* @__PURE__ */ jsxs(Fragment, { children: [
-					buildRemappingCode(queryParamsMapping, "mappedParams", "params"),
-					/* @__PURE__ */ jsx("br", {}),
-					/* @__PURE__ */ jsx("br", {})
-				] }),
-				headerParamsMapping && headerParams.length > 0 && /* @__PURE__ */ jsxs(Fragment, { children: [
-					buildRemappingCode(headerParamsMapping, "mappedHeaders", "headers"),
-					/* @__PURE__ */ jsx("br", {}),
-					/* @__PURE__ */ jsx("br", {})
-				] }),
-				requestName && "const requestData = data",
-				/* @__PURE__ */ jsx("br", {}),
-				isFormData && requestName && "const formData = buildFormData(requestData)",
-				/* @__PURE__ */ jsx("br", {}),
-				`const res = await client<${generics.join(", ")}>({ ${fetchConfig.join(", ")} }, request)`,
-				/* @__PURE__ */ jsx("br", {}),
-				callToolResult
+				`return {
+  content: [
+    {
+      type: 'text',
+      text: JSON.stringify(res.data)
+    }
+  ],
+  structuredContent: { data: res.data }
+}`
 			]
 		})
 	});
@@ -512,37 +521,36 @@ function zodExprFromSchemaNode(schema) {
 //#endregion
 //#region src/components/Server.tsx
 const keysPrinter = functionPrinter({ mode: "call" });
-function Server({ name, serverName, serverVersion, paramsCasing, operations }) {
+function Server({ name, serverName, serverVersion, operations }) {
 	const registrations = operations.map(({ tool, mcp, zod, node }) => {
-		const { path: pathParams } = getOperationParameters(node, { paramsCasing });
-		const pathEntries = [];
-		const otherEntries = [];
-		for (const p of pathParams) {
-			const zodParam = zod.pathParams.find((zp) => zp.name === p.name);
-			pathEntries.push({
-				key: p.name,
-				value: zodParam ? zodParam.schemaName : zodExprFromSchemaNode(p.schema)
+		const { path: pathParams } = getOperationParameters(node);
+		const entries = [];
+		if (pathParams.length) {
+			const pathFields = pathParams.map((p) => {
+				const zodParam = zod.pathParams.find((zp) => zp.name === p.name);
+				return `${JSON.stringify(p.name)}: ${zodParam ? zodParam.schemaName : zodExprFromSchemaNode(p.schema)}`;
+			}).join(", ");
+			entries.push({
+				key: "path",
+				value: `z.object({ ${pathFields} })`
 			});
 		}
-		if (zod.requestName) otherEntries.push({
-			key: "data",
-			value: zod.requestName
-		});
-		if (zod.queryParams) otherEntries.push({
-			key: "params",
+		if (zod.queryParams) entries.push({
+			key: "query",
 			value: zodGroupExpr(zod.queryParams)
 		});
-		if (zod.headerParams) otherEntries.push({
+		if (zod.headerParams) entries.push({
 			key: "headers",
 			value: zodGroupExpr(zod.headerParams)
 		});
-		otherEntries.sort((a, b) => a.key.localeCompare(b.key));
-		const entries = [...pathEntries, ...otherEntries];
-		const paramsNode = entries.length ? ast.factory.createFunctionParameters({ params: [{
-			kind: "FunctionParameter",
-			name: ast.factory.createObjectBindingPattern({ elements: entries.map((e) => ({ name: e.key })) }),
+		if (zod.requestName) entries.push({
+			key: "body",
+			value: zod.requestName
+		});
+		const paramsNode = entries.length ? createFunctionParameters({ params: [createFunctionParameter({
+			name: createObjectBindingPattern({ elements: entries.map((e) => ({ name: e.key })) }),
 			optional: false
-		}] }) : null;
+		})] }) : null;
 		const destructured = paramsNode ? keysPrinter.print(paramsNode) ?? "" : "";
 		const inputSchema = entries.length ? `{ ${entries.map((e) => `${e.key}: ${e.value}`).join(", ")} }` : null;
 		const outputSchema = zod.responseName;
@@ -604,12 +612,105 @@ return server`
 	});
 }
 //#endregion
+//#region ../../internals/client/src/resolveClient.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.
+*/
+const pluginFetchName = "plugin-fetch";
+const pluginAxiosName = "plugin-axios";
+const selectorToPlugin = {
+	fetch: pluginFetchName,
+	axios: pluginAxiosName
+};
+const contractPlugins = [pluginFetchName, pluginAxiosName];
+/**
+* Applies the `client` resolution rules. See the module comment for the strategy shape.
+*
+* @example
+* ```ts
+* resolveClient({ client: 'fetch', pluginNames: ['plugin-ts', 'plugin-fetch'] })
+* // { kind: 'contract', pluginName: 'plugin-fetch' }
+* ```
+*
+* @example
+* ```ts
+* resolveClient({ client: undefined, pluginNames: ['plugin-ts'] })
+* // { kind: 'error', message: 'No client plugin is registered…' }
+* ```
+*/
+function resolveClient(options) {
+	const { client, pluginNames } = options;
+	const has = (name) => pluginNames.includes(name);
+	if (client === "fetch" || client === "axios") {
+		const pluginName = selectorToPlugin[client];
+		if (!has(pluginName)) return {
+			kind: "error",
+			message: `\`client: '${client}'\` is set but \`@kubb/plugin-${client}\` is not registered in \`plugins\`. Add it, or drop \`client\` to use a different client plugin.`
+		};
+		return {
+			kind: "contract",
+			pluginName
+		};
+	}
+	const registered = contractPlugins.filter(has);
+	if (registered.length === 1) return {
+		kind: "contract",
+		pluginName: registered[0]
+	};
+	if (registered.length > 1) return {
+		kind: "error",
+		message: `Multiple client plugins are registered (${registered.map((name) => `\`@kubb/${name}\``).join(", ")}). Set \`client: 'fetch' | 'axios'\` to choose which client the hooks call, or register a single client plugin.`
+	};
+	return {
+		kind: "error",
+		message: "No client plugin is registered. Add `@kubb/plugin-axios` or `@kubb/plugin-fetch` to `plugins` so the generated code has an HTTP client to call."
+	};
+}
+//#endregion
+//#region ../../internals/client/src/resolveClientOperation.ts
+/**
+* Resolves the contract client `<op>` a consumer (query hook, MCP handler) imports, by looking up
+* the registered contract client plugin's resolver and output. Works for any contract client plugin
+* (plugin-fetch or plugin-axios). Returns `null` when no contract plugin is in play (the inline
+* path). The plugin injects `.kubb/client.ts` at the global output root, the same path consumers
+* read `RequestConfig` / `ResponseErrorConfig` from.
+*/
+function resolveClientOperation(options) {
+	const { clientPlugin, driver, node, root, output } = options;
+	if (!clientPlugin) return null;
+	const resolver = driver.getResolver(clientPlugin.pluginName);
+	if (!resolver) return null;
+	const plugin = driver.getPlugin(clientPlugin.pluginName);
+	const file = resolver.resolveFile(operationFileEntry(node, node.operationId), {
+		root,
+		output: plugin?.options?.output ?? output,
+		group: plugin?.options?.group ?? void 0
+	});
+	return {
+		name: resolver.resolveName(node.operationId),
+		path: file.path,
+		clientPath: path.resolve(root, ".kubb/client.ts")
+	};
+}
+//#endregion
 //#region src/generators/mcpGenerator.tsx
 /**
 * 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.
 */
 const mcpGenerator = defineGenerator({
 	name: "mcp",
@@ -617,14 +718,19 @@ const mcpGenerator = defineGenerator({
 	operation(node, ctx) {
 		if (!ast.isHttpOperationNode(node)) return null;
 		const { resolver, driver, root } = ctx;
-		const { output, client, paramsCasing, group } = ctx.options;
+		const { output, client, group } = ctx.options;
 		const pluginTs = driver.getPlugin(pluginTsName);
 		if (!pluginTs) return null;
 		const tsResolver = driver.getResolver(pluginTsName);
-		const importedTypeNames = resolveOperationTypeNames(node, tsResolver, {
-			paramsCasing,
-			responseStatusNames: "error"
+		const contractOp = resolveClientOperation({
+			clientPlugin: { pluginName: client.pluginName },
+			driver,
+			node,
+			root,
+			output
 		});
+		if (!contractOp) return null;
+		const requestConfigName = tsResolver.resolveRequestConfigName(node);
 		const meta = {
 			name: resolver.resolveHandlerName(node),
 			file: resolver.resolveFile({
@@ -653,8 +759,8 @@ const mcpGenerator = defineGenerator({
 			path: meta.file.path,
 			meta: meta.file.meta,
 			children: [
-				meta.fileTs && importedTypeNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
-					name: Array.from(new Set(importedTypeNames)).sort(),
+				meta.fileTs && requestConfigName && /* @__PURE__ */ jsx(File.Import, {
+					name: [requestConfigName],
 					root: meta.file.path,
 					path: meta.fileTs.path,
 					isTypeOnly: true
@@ -674,59 +780,15 @@ const mcpGenerator = defineGenerator({
 					isTypeOnly: true
 				}),
 				/* @__PURE__ */ jsx(File.Import, {
-					name: ["buildFormData"],
+					name: [contractOp.name],
 					root: meta.file.path,
-					path: path.resolve(root, ".kubb/config.ts")
+					path: contractOp.path
 				}),
-				client.importPath ? /* @__PURE__ */ jsxs(Fragment, { children: [
-					/* @__PURE__ */ jsx(File.Import, {
-						name: [
-							"Client",
-							"RequestConfig",
-							"ResponseErrorConfig"
-						],
-						path: client.importPath,
-						isTypeOnly: true
-					}),
-					/* @__PURE__ */ jsx(File.Import, {
-						name: "client",
-						path: client.importPath
-					}),
-					client.dataReturnType === "full" && /* @__PURE__ */ jsx(File.Import, {
-						name: ["ResponseConfig"],
-						path: client.importPath,
-						isTypeOnly: true
-					})
-				] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
-					/* @__PURE__ */ jsx(File.Import, {
-						name: [
-							"Client",
-							"RequestConfig",
-							"ResponseErrorConfig"
-						],
-						root: meta.file.path,
-						path: path.resolve(root, ".kubb/client.ts"),
-						isTypeOnly: true
-					}),
-					/* @__PURE__ */ jsx(File.Import, {
-						name: ["client"],
-						root: meta.file.path,
-						path: path.resolve(root, ".kubb/client.ts")
-					}),
-					client.dataReturnType === "full" && /* @__PURE__ */ jsx(File.Import, {
-						name: ["ResponseConfig"],
-						root: meta.file.path,
-						path: path.resolve(root, ".kubb/client.ts"),
-						isTypeOnly: true
-					})
-				] }),
 				/* @__PURE__ */ jsx(McpHandler, {
 					name: meta.name,
+					clientName: contractOp.name,
 					node,
-					resolver: tsResolver,
-					baseURL: client.baseURL,
-					dataReturnType: client.dataReturnType || "data",
-					paramsCasing
+					resolver: tsResolver
 				})
 			]
 		});
@@ -746,7 +808,7 @@ const serverGenerator = defineGenerator({
 	renderer: jsxRenderer,
 	operations(nodes, ctx) {
 		const { config, resolver, plugin, driver, root } = ctx;
-		const { output, paramsCasing, group } = ctx.options;
+		const { output, group } = ctx.options;
 		const pluginZod = driver.getPlugin(pluginZodName);
 		if (!pluginZod) return;
 		const zodResolver = driver.getResolver(pluginZodName);
@@ -762,7 +824,7 @@ const serverGenerator = defineGenerator({
 			meta: { pluginName: plugin.name }
 		};
 		const operationsMapped = nodes.filter(ast.isHttpOperationNode).map((node) => {
-			const { path: pathParams, query: queryParams, header: headerParams } = getOperationParameters(node, { paramsCasing });
+			const { path: pathParams, query: queryParams, header: headerParams } = getOperationParameters(node);
 			const mcpFile = resolver.resolveFile({
 				name: node.operationId,
 				extname: ".ts",
@@ -868,7 +930,6 @@ const serverGenerator = defineGenerator({
 					name,
 					serverName: ctx.meta.title ?? "server",
 					serverVersion: ctx.meta.version ?? "0.0.0",
-					paramsCasing,
 					operations: operationsMapped
 				})
 			]
@@ -934,13 +995,13 @@ 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'
 *
@@ -949,11 +1010,10 @@ 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',
 *     }),
 *   ],
 * })
@@ -963,9 +1023,7 @@ const pluginMcp = definePlugin((options) => {
 	const { output = {
 		path: "mcp",
 		barrel: { type: "named" }
-	}, group, exclude = [], include, override = [], paramsCasing, client, resolver: userResolver, macros: userMacros, generators: userGenerators = [] } = options;
-	const clientName = client?.client ?? "axios";
-	const clientImportPath = client?.importPath ?? (!client?.bundle ? `@kubb/plugin-client/clients/${clientName}` : void 0);
+	}, group, exclude = [], include, override = [], client, resolver: userResolver, macros: userMacros } = options;
 	const groupConfig = createGroupConfig(group);
 	return {
 		name: pluginMcpName,
@@ -976,51 +1034,28 @@ const pluginMcp = definePlugin((options) => {
 				...resolverMcp,
 				...userResolver
 			} : resolverMcp;
+			const resolvedClient = resolveClient({
+				client,
+				pluginNames: (ctx.config.plugins ?? []).map((p) => p.name).filter((name) => Boolean(name))
+			});
+			if (resolvedClient.kind === "error") throw new Error(resolvedClient.message);
+			const resolvedClientDescriptor = {
+				kind: "contract",
+				pluginName: resolvedClient.pluginName
+			};
 			ctx.setOptions({
 				output,
 				exclude,
 				include,
 				override,
 				group: groupConfig,
-				paramsCasing,
-				client: {
-					client: clientName,
-					clientType: client?.clientType ?? "function",
-					importPath: clientImportPath,
-					dataReturnType: client?.dataReturnType ?? "data",
-					bundle: client?.bundle,
-					baseURL: client?.baseURL,
-					paramsCasing: client?.paramsCasing
-				},
+				client: resolvedClientDescriptor,
 				resolver
 			});
 			ctx.setResolver(resolver);
 			if (userMacros?.length) ctx.setMacros(userMacros);
 			ctx.addGenerator(mcpGenerator);
 			ctx.addGenerator(serverGenerator);
-			for (const gen of userGenerators) ctx.addGenerator(gen);
-			const root = path.resolve(ctx.config.root, ctx.config.output.path);
-			const hasClientPlugin = ctx.config.plugins?.some((p) => p.name === pluginClientName);
-			if (client?.bundle && !hasClientPlugin && !clientImportPath) ctx.injectFile({
-				baseName: "client.ts",
-				path: path.resolve(root, ".kubb/client.ts"),
-				sources: [ast.factory.createSource({
-					name: "client",
-					nodes: [ast.factory.createText(clientName === "fetch" ? source$1 : source)],
-					isExportable: true,
-					isIndexable: true
-				})]
-			});
-			if (!hasClientPlugin) ctx.injectFile({
-				baseName: "config.ts",
-				path: path.resolve(root, ".kubb/config.ts"),
-				sources: [ast.factory.createSource({
-					name: "config",
-					nodes: [ast.factory.createText(source$2)],
-					isExportable: false,
-					isIndexable: false
-				})]
-			});
 		} }
 	};
 });