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

package/dist/index.cjs

@@ -24,316 +24,137 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	enumerable: true
 }) : target, mod));
 //#endregion
+let kubb_kit = require("kubb/kit");
 let node_path = require("node:path");
-let node_path$1 = __toESM(node_path, 1);
-node_path = __toESM(node_path);
-let _kubb_core = require("@kubb/core");
+node_path = __toESM(node_path, 1);
+let kubb_jsx = require("kubb/jsx");
+let kubb_jsx_jsx_runtime = require("kubb/jsx/jsx-runtime");
 let _kubb_plugin_ts = require("@kubb/plugin-ts");
-let _kubb_renderer_jsx = require("@kubb/renderer-jsx");
-let _kubb_renderer_jsx_jsx_runtime = require("@kubb/renderer-jsx/jsx-runtime");
 let _kubb_plugin_zod = require("@kubb/plugin-zod");
-let _kubb_plugin_client = require("@kubb/plugin-client");
-let _kubb_plugin_client_templates_clients_axios_source = require("@kubb/plugin-client/templates/clients/axios.source");
-let _kubb_plugin_client_templates_clients_fetch_source = require("@kubb/plugin-client/templates/clients/fetch.source");
-let _kubb_plugin_client_templates_config_source = require("@kubb/plugin-client/templates/config.source");
-//#region ../../internals/utils/src/casing.ts
+//#region ../../internals/shared/src/params.ts
 /**
-* Shared implementation for camelCase and PascalCase conversion.
-* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
-* and capitalizes each word according to `pascal`.
+* Drops parameters that share the same name, keeping the first.
 *
-* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
+* A malformed spec can declare the same parameter name twice within one `in` location. Both would
+* resolve to the same output property, so emitting both would yield an object type with a duplicate
+* member, which TypeScript rejects. This is a defensive guard against that case, not a casing guard:
+* parameter names flow through unchanged, so no two distinct names ever collide here anymore.
 */
-function toCamelOrPascal(text, pascal) {
-	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
-		if (word.length > 1 && word === word.toUpperCase()) return word;
-		if (i === 0 && !pascal) return word.charAt(0).toLowerCase() + word.slice(1);
-		return word.charAt(0).toUpperCase() + word.slice(1);
-	}).join("").replace(/[^a-zA-Z0-9]/g, "");
+function dedupeParams(params) {
+	const seen = /* @__PURE__ */ new Set();
+	return params.filter((param) => {
+		if (seen.has(param.name)) return false;
+		seen.add(param.name);
+		return true;
+	});
 }
+//#endregion
+//#region ../../internals/shared/src/operation.ts
 /**
-* Splits `text` on `.` and applies `transformPart` to each segment.
-* The last segment receives `isLast = true`, all earlier segments receive `false`.
-* Segments are joined with `/` to form a file path.
+* Builds the `ResolverFileParams` every operation generator passes to
+* `resolver.file`: 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.
 *
-* Only splits on dots followed by a letter so that version numbers
-* embedded in operationIds (e.g. `v2025.0`) are kept intact.
+* @example
+* ```ts
+* resolver.file(operationFileEntry(node, node.operationId), { root, output, group })
+* ```
 */
-function applyToFileParts(text, transformPart) {
-	const parts = text.split(/\.(?=[a-zA-Z])/);
-	return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
+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;
+	return node.path ? `{@link ${kubb_kit.Url.toPath(node.path)}}` : null;
 }
 /**
-* Converts `text` to camelCase.
-* When `isFile` is `true`, dot-separated segments are each cased independently and joined with `/`.
-*
-* @example
-* camelCase('hello-world')                   // 'helloWorld'
-* camelCase('pet.petId', { isFile: true })   // 'pet/petId'
+* Derives the shared `ContentTypeInfo` shape from a list of content types, tracking whether several
+* are present and the union, default, and form-data flags the client uses to pick one.
 */
-function camelCase(text, { isFile, prefix = "", suffix = "" } = {}) {
-	if (isFile) return applyToFileParts(text, (part, isLast) => camelCase(part, isLast ? {
-		prefix,
-		suffix
-	} : {}));
-	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
+function buildContentTypeInfo(contentTypes) {
+	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 getContentTypeInfo(node) {
+	return buildContentTypeInfo(node.requestBody?.content?.map((e) => e.contentType) ?? []);
 }
-//#endregion
-//#region ../../internals/utils/src/reserved.ts
 /**
-* JavaScript and Java reserved words.
-* @link https://github.com/jonschlinkert/reserved/blob/master/index.js
+* The request-body counterpart for the primary success response: the content types it documents and
+* whether several are present, so the client can let a caller pick which one to accept.
 */
-const reservedWords = new Set([
-	"abstract",
-	"arguments",
-	"boolean",
-	"break",
-	"byte",
-	"case",
-	"catch",
-	"char",
-	"class",
-	"const",
-	"continue",
-	"debugger",
-	"default",
-	"delete",
-	"do",
-	"double",
-	"else",
-	"enum",
-	"eval",
-	"export",
-	"extends",
-	"false",
-	"final",
-	"finally",
-	"float",
-	"for",
-	"function",
-	"goto",
-	"if",
-	"implements",
-	"import",
-	"in",
-	"instanceof",
-	"int",
-	"interface",
-	"let",
-	"long",
-	"native",
-	"new",
-	"null",
-	"package",
-	"private",
-	"protected",
-	"public",
-	"return",
-	"short",
-	"static",
-	"super",
-	"switch",
-	"synchronized",
-	"this",
-	"throw",
-	"throws",
-	"transient",
-	"true",
-	"try",
-	"typeof",
-	"var",
-	"void",
-	"volatile",
-	"while",
-	"with",
-	"yield",
-	"Array",
-	"Date",
-	"hasOwnProperty",
-	"Infinity",
-	"isFinite",
-	"isNaN",
-	"isPrototypeOf",
-	"length",
-	"Math",
-	"name",
-	"NaN",
-	"Number",
-	"Object",
-	"prototype",
-	"String",
-	"toString",
-	"undefined",
-	"valueOf"
-]);
+function getResponseContentTypeInfo(node) {
+	return buildContentTypeInfo(getPrimarySuccessResponse(node)?.content?.map((e) => e.contentType) ?? []);
+}
+function buildRequestConfigType(node) {
+	const request = getContentTypeInfo(node);
+	const response = getResponseContentTypeInfo(node);
+	const configType = `Partial<Omit<RequestConfig, 'path' | 'query' | 'body' | 'headers' | 'url'>>`;
+	const members = [request.isMultipleContentTypes ? `request?: ${request.contentTypeUnion}` : null, response.isMultipleContentTypes ? `response?: ${response.contentTypeUnion}` : null].filter(Boolean);
+	return members.length ? `${configType} & { contentType?: { ${members.join("; ")} } }` : configType;
+}
 /**
-* Returns `true` when `name` is a syntactically valid JavaScript variable name.
-*
-* @example
-* ```ts
-* isValidVarName('status')  // true
-* isValidVarName('class')   // false (reserved word)
-* isValidVarName('42foo')   // false (starts with digit)
-* ```
+* Which of the grouped request options an operation carries.
 */
-function isValidVarName(name) {
-	if (!name || reservedWords.has(name)) return false;
-	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+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
+	};
 }
-//#endregion
-//#region ../../internals/utils/src/urlPath.ts
 /**
-* Parses and transforms an OpenAPI/Swagger path string into various URL formats.
-*
-* @example
-* const p = new URLPath('/pet/{petId}')
-* p.URL      // '/pet/:petId'
-* p.template // '`/pet/${petId}`'
+* 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.
 */
-var URLPath = class {
-	/**
-	* The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`.
-	*/
-	path;
-	#options;
-	constructor(path, options = {}) {
-		this.path = path;
-		this.#options = options;
-	}
-	/** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`.
-	*
-	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}').URL // '/pet/:petId'
-	* ```
-	*/
-	get URL() {
-		return this.toURLPath();
-	}
-	/** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`).
-	*
-	* @example
-	* ```ts
-	* new URLPath('https://petstore.swagger.io/v2/pet').isURL // true
-	* new URLPath('/pet/{petId}').isURL                       // false
-	* ```
-	*/
-	get isURL() {
-		try {
-			return !!new URL(this.path).href;
-		} catch {
-			return false;
-		}
-	}
-	/**
-	* Converts the OpenAPI path to a TypeScript template literal string.
-	*
-	* @example
-	* new URLPath('/pet/{petId}').template              // '`/pet/${petId}`'
-	* new URLPath('/account/monetary-accountID').template // '`/account/${monetaryAccountId}`'
-	*/
-	get template() {
-		return this.toTemplateString();
-	}
-	/** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set.
-	*
-	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}').object
-	* // { url: '/pet/:petId', params: { petId: 'petId' } }
-	* ```
-	*/
-	get object() {
-		return this.toObject();
-	}
-	/** Returns a map of path parameter names, or `undefined` when the path has no parameters.
-	*
-	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}').params // { petId: 'petId' }
-	* new URLPath('/pet').params         // undefined
-	* ```
-	*/
-	get params() {
-		return this.toParamsObject();
-	}
-	#transformParam(raw) {
-		const param = isValidVarName(raw) ? raw : camelCase(raw);
-		return this.#options.casing === "camelcase" ? camelCase(param) : param;
-	}
-	/**
-	* Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name.
-	*/
-	#eachParam(fn) {
-		for (const match of this.path.matchAll(/\{([^}]+)\}/g)) {
-			const raw = match[1];
-			fn(raw, this.#transformParam(raw));
-		}
-	}
-	toObject({ type = "path", replacer, stringify } = {}) {
-		const object = {
-			url: type === "path" ? this.toURLPath() : this.toTemplateString({ replacer }),
-			params: this.toParamsObject()
-		};
-		if (stringify) {
-			if (type === "template") return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
-			if (object.params) return `{ url: '${object.url}', params: ${JSON.stringify(object.params).replaceAll("'", "").replaceAll(`"`, "")} }`;
-			return `{ url: '${object.url}' }`;
-		}
-		return object;
-	}
-	/**
-	* Converts the OpenAPI path to a TypeScript template literal string.
-	* An optional `replacer` can transform each extracted parameter name before interpolation.
-	*
-	* @example
-	* new URLPath('/pet/{petId}').toTemplateString() // '`/pet/${petId}`'
-	*/
-	toTemplateString({ prefix = "", replacer } = {}) {
-		return `\`${prefix}${this.path.split(/\{([^}]+)\}/).map((part, i) => {
-			if (i % 2 === 0) return part;
-			const param = this.#transformParam(part);
-			return `\${${replacer ? replacer(param) : param}}`;
-		}).join("")}\``;
-	}
-	/**
-	* Extracts all `{param}` segments from the path and returns them as a key-value map.
-	* An optional `replacer` transforms each parameter name in both key and value positions.
-	* Returns `undefined` when no path parameters are found.
-	*
-	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}/tag/{tagId}').toParamsObject()
-	* // { petId: 'petId', tagId: 'tagId' }
-	* ```
-	*/
-	toParamsObject(replacer) {
-		const params = {};
-		this.#eachParam((_raw, param) => {
-			const key = replacer ? replacer(param) : param;
-			params[key] = key;
-		});
-		return Object.keys(params).length > 0 ? params : void 0;
-	}
-	/** Converts the OpenAPI path to Express-style colon syntax.
-	*
-	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}').toURLPath() // '/pet/:petId'
-	* ```
-	*/
-	toURLPath() {
-		return this.path.replace(/\{([^}]+)\}/g, ":$1");
-	}
-};
-//#endregion
-//#region ../../internals/shared/src/operation.ts
-function getOperationLink(node, link) {
-	if (!link) return;
-	if (typeof link === "function") return link(node);
-	if (link === "urlPath") return node.path ? `{@link ${new URLPath(node.path).URL}}` : void 0;
-	return `{@link ${node.path.replaceAll("{", ":").replaceAll("}", "")}}`;
+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 `Options` (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.response.options(node)}${isOptional ? " = {}" : ""}` : null, isConfigurable ? `config: ${buildRequestConfigType(node)} = {}` : null].filter(Boolean).join(", "),
+		groups
+	};
 }
 function buildOperationComments(node, options = {}) {
 	const { link = "pathTemplate", linkPosition = "afterDeprecated", splitLines = false } = options;
@@ -352,140 +173,112 @@ function buildOperationComments(node, options = {}) {
 	if (!splitLines) return filteredComments;
 	return filteredComments.flatMap((text) => text.split(/\r?\n/).map((line) => line.trim())).filter((comment) => Boolean(comment));
 }
-function getOperationParameters(node, options = {}) {
-	const params = _kubb_core.ast.caseParams(node.parameters, options.paramsCasing);
+function getOperationParameters(node) {
 	return {
-		path: params.filter((param) => param.in === "path"),
-		query: params.filter((param) => param.in === "query"),
-		header: params.filter((param) => param.in === "header"),
-		cookie: params.filter((param) => param.in === "cookie")
+		path: dedupeParams(node.parameters.filter((param) => param.in === "path")),
+		query: dedupeParams(node.parameters.filter((param) => param.in === "query")),
+		header: dedupeParams(node.parameters.filter((param) => param.in === "header")),
+		cookie: dedupeParams(node.parameters.filter((param) => param.in === "cookie"))
 	};
 }
 function getStatusCodeNumber(statusCode) {
 	const code = Number(statusCode);
-	return Number.isNaN(code) ? void 0 : code;
+	return Number.isNaN(code) ? null : code;
 }
 function isSuccessStatusCode(statusCode) {
 	const code = getStatusCodeNumber(statusCode);
-	return code !== void 0 && code >= 200 && code < 300;
-}
-function isErrorStatusCode(statusCode) {
-	const code = getStatusCodeNumber(statusCode);
-	return code !== void 0 && code >= 400;
+	return code !== null && code >= 200 && code < 300;
 }
-function resolveErrorNames(node, resolver) {
-	return node.responses.filter((response) => isErrorStatusCode(response.statusCode)).map((response) => resolver.resolveResponseStatusName(node, response.statusCode));
+function getSuccessResponses(responses) {
+	return responses.filter((response) => isSuccessStatusCode(response.statusCode));
 }
-function resolveStatusCodeNames(node, resolver) {
-	return node.responses.map((response) => resolver.resolveResponseStatusName(node, response.statusCode));
+function getOperationSuccessResponses(node) {
+	return getSuccessResponses(node.responses);
 }
-function resolveOperationTypeNames(node, resolver, options = {}) {
-	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) : void 0, resolver.resolveResponseName(node)];
-	return (options.order === "body-response-first" ? [
-		...bodyAndResponseNames,
-		...paramNames,
-		...responseStatusNames
-	] : [
-		...paramNames,
-		...bodyAndResponseNames,
-		...responseStatusNames
-	]).filter((name) => Boolean(name) && !exclude.has(name));
+function getPrimarySuccessResponse(node) {
+	return getOperationSuccessResponses(node)[0] ?? null;
 }
 function findSuccessStatusCode(responses) {
 	for (const response of responses) if (isSuccessStatusCode(response.statusCode)) return response.statusCode;
+	return null;
 }
 //#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 : void 0;
+//#region ../../internals/utils/src/casing.ts
+/**
+* Shared implementation for camelCase and PascalCase conversion.
+* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
+* and capitalizes each word according to `pascal`.
+*
+* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
+*/
+function toCamelOrPascal(text, pascal) {
+	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
+		if (word.length > 1 && word === word.toUpperCase()) return word;
+		return (i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()) + word.slice(1);
+	}).join("").replace(/[^a-zA-Z0-9]/g, "");
 }
-function buildTransformedParamsMapping(params, transformName) {
-	if (!params.length) return;
-	return buildParamsMapping(params, params.map((param) => ({
-		...param,
-		name: transformName(param.name)
-	})));
+/**
+* Converts `text` to camelCase.
+*
+* @example Word boundaries
+* `camelCase('hello-world') // 'helloWorld'`
+*
+* @example With a prefix
+* `camelCase('tag', { prefix: 'create' }) // 'createTag'`
+*/
+function camelCase(text, { prefix = "", suffix = "" } = {}) {
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
 }
 //#endregion
-//#region src/components/McpHandler.tsx
+//#region ../../internals/shared/src/group.ts
 /**
-* Generate a remapping statement: `const mappedX = x ? { "orig": x.camel, ... } : undefined`
+* Builds the `group` config a Kubb plugin passes to `ctx.setOptions`, applying the
+* shared default naming so every plugin groups output consistently:
+*
+* - `path` groups use the second path segment (`/pet/findByStatus` → `pet`).
+* - other groups use the camelCased group (`pet store` → `petStore`).
+*
+* A user-provided `group.name` always wins over the default namer, so callers stay in
+* control of their output folders. Returns `null` when grouping is disabled, matching the
+* per-plugin convention.
+*
+* @param group - The user-supplied group option, or `undefined` to disable grouping.
+*
+* @example
+* ```ts
+* createGroupConfig(group) // shared across every plugin
+* ```
 */
-function buildRemappingCode(mapping, varName, sourceName) {
-	return `const ${varName} = ${sourceName} ? { ${Object.entries(mapping).map(([orig, camel]) => `"${orig}": ${sourceName}.${camel}`).join(", ")} } : undefined`;
+function createGroupConfig(group) {
+	if (!group) return null;
+	const defaultName = (ctx) => {
+		if (group.type === "path") return `${ctx.group.split("/")[1]}`;
+		return camelCase(ctx.group);
+	};
+	return {
+		...group,
+		name: group.name ? group.name : defaultName
+	};
 }
-const declarationPrinter = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
-function McpHandler({ name, node, resolver, baseURL, dataReturnType, paramsCasing }) {
-	const urlPath = new URLPath(node.path);
-	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) : void 0;
-	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 = _kubb_core.ast.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) : void 0;
-	const queryParamsMapping = paramsCasing ? buildTransformedParamsMapping(originalQueryParams, camelCase) : void 0;
-	const headerParamsMapping = paramsCasing ? buildTransformedParamsMapping(originalHeaderParams, camelCase) : void 0;
-	const contentTypeHeader = contentType && contentType !== "application/json" && contentType !== "multipart/form-data" ? `'Content-Type': '${contentType}'` : void 0;
-	const headers = [headerParams.length ? headerParamsMapping ? "...mappedHeaders" : "...headers" : void 0, contentTypeHeader].filter(Boolean);
-	const fetchConfig = [];
-	fetchConfig.push(`method: ${JSON.stringify(node.method.toUpperCase())}`);
-	fetchConfig.push(`url: ${urlPath.template}`);
-	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 = dataReturnType === "data" ? `return {
-            content: [
-              {
-                type: 'text',
-                text: JSON.stringify(res.data)
-              }
-            ],
-            structuredContent: { data: res.data }
-           }` : `return {
-            content: [
-              {
-                type: 'text',
-                text: JSON.stringify(res)
-              }
-            ],
-            structuredContent: { data: res.data }
-           }`;
-	return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Source, {
+//#endregion
+//#region src/components/McpHandler.tsx
+const requestGroupOrder = [
+	"path",
+	"query",
+	"headers",
+	"body"
+];
+function McpHandler({ name, clientName, node, resolver }) {
+	if (!kubb_kit.ast.isHttpOperationNode(node)) return null;
+	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__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Source, {
 		name,
 		isExportable: true,
 		isIndexable: true,
-		children: /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx.Function, {
+		children: /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx.Function, {
 			name,
 			async: true,
 			export: true,
@@ -493,28 +286,17 @@ function McpHandler({ name, node, resolver, baseURL, dataReturnType, paramsCasin
 			JSDoc: { comments: buildOperationComments(node) },
 			returnType: "Promise<CallToolResult>",
 			children: [
-				"",
-				/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)("br", {}),
-				/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)("br", {}),
-				pathParamsMapping && Object.entries(pathParamsMapping).filter(([originalName, camelCaseName]) => originalName !== camelCaseName && isValidVarName(originalName)).map(([originalName, camelCaseName]) => `const ${originalName} = ${camelCaseName}`).join("\n"),
-				pathParamsMapping && /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)("br", {}), /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)("br", {})] }),
-				queryParamsMapping && queryParams.length > 0 && /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx_jsx_runtime.Fragment, { children: [
-					buildRemappingCode(queryParamsMapping, "mappedParams", "params"),
-					/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)("br", {}),
-					/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)("br", {})
-				] }),
-				headerParamsMapping && headerParams.length > 0 && /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx_jsx_runtime.Fragment, { children: [
-					buildRemappingCode(headerParamsMapping, "mappedHeaders", "headers"),
-					/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)("br", {}),
-					/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)("br", {})
-				] }),
-				requestName && "const requestData = data",
-				/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)("br", {}),
-				isFormData && requestName && "const formData = buildFormData(requestData)",
-				/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)("br", {}),
-				`const res = await fetch<${generics.join(", ")}>({ ${fetchConfig.join(", ")} }, request)`,
-				/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)("br", {}),
-				callToolResult
+				`const res = await ${clientName}(${callConfig})`,
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)("br", {}),
+				`return {
+  content: [
+    {
+      type: 'text',
+      text: JSON.stringify(res.data)
+    }
+  ],
+  structuredContent: { data: res.data }
+}`
 			]
 		})
 	});
@@ -534,91 +316,66 @@ function zodGroupExpr(entry) {
 * Used as fallback when no named zod schema is available for a path parameter.
 */
 function zodExprFromSchemaNode(schema) {
-	let expr;
-	switch (schema.type) {
-		case "enum": {
+	const baseExpr = (() => {
+		if (schema.type === "enum") {
 			const rawValues = schema.namedEnumValues?.length ? schema.namedEnumValues.map((v) => v.value) : (schema.enumValues ?? []).filter((v) => v !== null);
-			if (rawValues.length > 0 && rawValues.every((v) => typeof v === "string")) expr = `z.enum([${rawValues.map((v) => JSON.stringify(v)).join(", ")}])`;
-			else if (rawValues.length > 0) {
+			if (rawValues.length > 0 && rawValues.every((v) => typeof v === "string")) return `z.enum([${rawValues.map((v) => JSON.stringify(v)).join(", ")}])`;
+			if (rawValues.length > 0) {
 				const literals = rawValues.map((v) => `z.literal(${JSON.stringify(v)})`);
-				expr = literals.length === 1 ? literals[0] : `z.union([${literals.join(", ")}])`;
-			} else expr = "z.string()";
-			break;
+				return literals.length === 1 ? literals[0] : `z.union([${literals.join(", ")}])`;
+			}
+			return "z.string()";
 		}
-		case "integer":
-			expr = "z.coerce.number()";
-			break;
-		case "number":
-			expr = "z.number()";
-			break;
-		case "boolean":
-			expr = "z.boolean()";
-			break;
-		case "array":
-			expr = "z.array(z.unknown())";
-			break;
-		default: expr = "z.string()";
-	}
-	if (schema.nullable) expr = `${expr}.nullable()`;
-	return expr;
+		if (schema.type === "integer") return "z.coerce.number()";
+		if (schema.type === "number") return "z.number()";
+		if (schema.type === "boolean") return "z.boolean()";
+		if (schema.type === "array") return "z.array(z.unknown())";
+		return "z.string()";
+	})();
+	return schema.nullable ? `${baseExpr}.nullable()` : baseExpr;
 }
 //#endregion
 //#region src/components/Server.tsx
-const keysPrinter = (0, _kubb_plugin_ts.functionPrinter)({ mode: "keys" });
-function Server({ name, serverName, serverVersion, paramsCasing, operations }) {
-	return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx.File.Source, {
-		name,
-		isExportable: true,
-		isIndexable: true,
-		children: [
-			/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.Const, {
-				name: "server",
-				export: true,
-				children: `
-          new McpServer({
-  name: '${serverName}',
-  version: '${serverVersion}',
-})
-          `
-			}),
-			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)
-					});
-				}
-				if (zod.requestName) otherEntries.push({
-					key: "data",
-					value: zod.requestName
-				});
-				if (zod.queryParams) otherEntries.push({
-					key: "params",
-					value: zodGroupExpr(zod.queryParams)
-				});
-				if (zod.headerParams) otherEntries.push({
-					key: "headers",
-					value: zodGroupExpr(zod.headerParams)
-				});
-				otherEntries.sort((a, b) => a.key.localeCompare(b.key));
-				const entries = [...pathEntries, ...otherEntries];
-				const paramsNode = entries.length ? _kubb_core.ast.createFunctionParameters({ params: [_kubb_core.ast.createParameterGroup({ properties: entries.map((e) => _kubb_core.ast.createFunctionParameter({
-					name: e.key,
-					optional: false
-				})) })] }) : void 0;
-				const destructured = paramsNode ? keysPrinter.print(paramsNode) ?? "" : "";
-				const inputSchema = entries.length ? `{ ${entries.map((e) => `${e.key}: ${e.value}`).join(", ")} }` : void 0;
-				const outputSchema = zod.responseName;
-				const config = [
-					tool.title ? `title: ${JSON.stringify(tool.title)}` : null,
-					`description: ${JSON.stringify(tool.description)}`,
-					outputSchema ? `outputSchema: { data: ${outputSchema} }` : null
-				].filter(Boolean).join(",\n  ");
-				if (inputSchema) return `
+const keysPrinter = (0, _kubb_plugin_ts.functionPrinter)({ mode: "call" });
+function Server({ name, serverName, serverVersion, operations }) {
+	const registrations = operations.map(({ tool, mcp, zod, node }) => {
+		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.queryParams) entries.push({
+			key: "query",
+			value: zodGroupExpr(zod.queryParams)
+		});
+		if (zod.headerParams) entries.push({
+			key: "headers",
+			value: zodGroupExpr(zod.headerParams)
+		});
+		if (zod.requestName) entries.push({
+			key: "body",
+			value: zod.requestName
+		});
+		const paramsNode = entries.length ? (0, _kubb_plugin_ts.createFunctionParameters)({ params: [(0, _kubb_plugin_ts.createFunctionParameter)({
+			name: (0, _kubb_plugin_ts.createObjectBindingPattern)({ elements: entries.map((e) => ({ name: e.key })) }),
+			optional: false
+		})] }) : null;
+		const destructured = paramsNode ? keysPrinter.print(paramsNode) ?? "" : "";
+		const inputSchema = entries.length ? `{ ${entries.map((e) => `${e.key}: ${e.value}`).join(", ")} }` : null;
+		const outputSchema = zod.responseName;
+		const config = [
+			tool.title ? `title: ${JSON.stringify(tool.title)}` : null,
+			`description: ${JSON.stringify(tool.description)}`,
+			outputSchema ? `outputSchema: { data: ${outputSchema} }` : null
+		].filter(Boolean).join(",\n  ");
+		if (inputSchema) return `
 server.registerTool(${JSON.stringify(tool.name)}, {
   ${config},
   inputSchema: ${inputSchema},
@@ -626,15 +383,35 @@ server.registerTool(${JSON.stringify(tool.name)}, {
   return ${mcp.name}(${destructured}, request)
 })
           `;
-				return `
+		return `
 server.registerTool(${JSON.stringify(tool.name)}, {
   ${config},
 }, async (request) => {
   return ${mcp.name}(request)
 })
           `;
-			}).filter(Boolean),
-			/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.Function, {
+	}).filter(Boolean).join("\n");
+	return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx.File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: [
+			/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.Function, {
+				name: "getServer",
+				export: true,
+				children: `const server = new McpServer({
+  name: '${serverName}',
+  version: '${serverVersion}',
+})
+${registrations}
+return server`
+			}),
+			/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.Const, {
+				name: "server",
+				export: true,
+				children: "getServer()"
+			}),
+			/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.Function, {
 				name: "startServer",
 				async: true,
 				export: true,
@@ -651,55 +428,172 @@ server.registerTool(${JSON.stringify(tool.name)}, {
 	});
 }
 //#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."
+	};
+}
+/**
+* Resolves the contract client during a consumer plugin's setup hook. Extracts the plugin names
+* from the raw `plugins` config, applies {@link resolveClient}, and throws the diagnostic on a
+* misconfiguration so every consumer fails fast with the same message.
+*/
+function resolveContractClient(options) {
+	const { client, plugins = [] } = options;
+	const resolved = resolveClient({
+		client,
+		pluginNames: plugins.map((plugin) => plugin.name).filter((name) => Boolean(name))
+	});
+	if (resolved.kind === "error") throw new Error(resolved.message);
+	return resolved;
+}
+//#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);
+	const plugin = driver.getPlugin(clientPlugin.pluginName);
+	const file = resolver.file({
+		...operationFileEntry(node, node.operationId),
+		root,
+		output: plugin?.options?.output ?? output,
+		group: plugin?.options?.group ?? void 0
+	});
+	return {
+		name: resolver.name(node.operationId),
+		path: file.path,
+		clientPath: node_path.default.resolve(root, ".kubb/client.ts")
+	};
+}
+//#endregion
 //#region src/generators/mcpGenerator.tsx
-const mcpGenerator = (0, _kubb_core.defineGenerator)({
+/**
+* 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.
+*/
+const mcpGenerator = (0, kubb_kit.defineGenerator)({
 	name: "mcp",
-	renderer: _kubb_renderer_jsx.jsxRenderer,
+	renderer: kubb_jsx.jsxRenderer,
 	operation(node, ctx) {
+		if (!kubb_kit.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(_kubb_plugin_ts.pluginTsName);
 		if (!pluginTs) return null;
 		const tsResolver = driver.getResolver(_kubb_plugin_ts.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 optionsName = tsResolver.response.options(node);
 		const meta = {
-			name: resolver.resolveHandlerName(node),
-			file: resolver.resolveFile({
+			name: resolver.handler.name(node),
+			file: resolver.file({
 				name: node.operationId,
 				extname: ".ts",
 				tag: node.tags[0] ?? "default",
-				path: node.path
-			}, {
+				path: node.path,
 				root,
 				output,
-				group
+				group: group ?? void 0
 			}),
-			fileTs: tsResolver.resolveFile({
+			fileTs: tsResolver.file({
 				name: node.operationId,
 				extname: ".ts",
 				tag: node.tags[0] ?? "default",
-				path: node.path
-			}, {
+				path: node.path,
 				root,
 				output: pluginTs.options?.output ?? output,
-				group: pluginTs.options?.group
+				group: pluginTs.options?.group ?? void 0
 			})
 		};
-		return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx.File, {
+		return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx.File, {
 			baseName: meta.file.baseName,
 			path: meta.file.path,
 			meta: meta.file.meta,
 			children: [
-				meta.fileTs && importedTypeNames.length > 0 && /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
-					name: Array.from(new Set(importedTypeNames)).sort(),
+				meta.fileTs && optionsName && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: [optionsName],
 					root: meta.file.path,
 					path: meta.fileTs.path,
 					isTypeOnly: true
 				}),
-				/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
 					name: [
 						"CallToolResult",
 						"ServerNotification",
@@ -708,65 +602,21 @@ const mcpGenerator = (0, _kubb_core.defineGenerator)({
 					path: "@modelcontextprotocol/sdk/types",
 					isTypeOnly: true
 				}),
-				/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
 					name: ["RequestHandlerExtra"],
 					path: "@modelcontextprotocol/sdk/shared/protocol",
 					isTypeOnly: true
 				}),
-				/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
-					name: ["buildFormData"],
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: [contractOp.name],
 					root: meta.file.path,
-					path: node_path.default.resolve(root, ".kubb/config.ts")
+					path: contractOp.path
 				}),
-				client.importPath ? /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx_jsx_runtime.Fragment, { children: [
-					/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
-						name: [
-							"Client",
-							"RequestConfig",
-							"ResponseErrorConfig"
-						],
-						path: client.importPath,
-						isTypeOnly: true
-					}),
-					/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
-						name: "fetch",
-						path: client.importPath
-					}),
-					client.dataReturnType === "full" && /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
-						name: ["ResponseConfig"],
-						path: client.importPath,
-						isTypeOnly: true
-					})
-				] }) : /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx_jsx_runtime.Fragment, { children: [
-					/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
-						name: [
-							"Client",
-							"RequestConfig",
-							"ResponseErrorConfig"
-						],
-						root: meta.file.path,
-						path: node_path.default.resolve(root, ".kubb/fetch.ts"),
-						isTypeOnly: true
-					}),
-					/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
-						name: ["fetch"],
-						root: meta.file.path,
-						path: node_path.default.resolve(root, ".kubb/fetch.ts")
-					}),
-					client.dataReturnType === "full" && /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
-						name: ["ResponseConfig"],
-						root: meta.file.path,
-						path: node_path.default.resolve(root, ".kubb/fetch.ts"),
-						isTypeOnly: true
-					})
-				] }),
-				/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(McpHandler, {
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(McpHandler, {
 					name: meta.name,
+					clientName: contractOp.name,
 					node,
-					resolver: tsResolver,
-					baseURL: client.baseURL,
-					dataReturnType: client.dataReturnType || "data",
-					paramsCasing
+					resolver: tsResolver
 				})
 			]
 		});
@@ -781,12 +631,12 @@ const mcpGenerator = (0, _kubb_core.defineGenerator)({
 * and `resolveResponseStatusName` for per-status response schemas.
 * Query and header params are composed into `z.object({ ... })` from individual schemas.
 */
-const serverGenerator = (0, _kubb_core.defineGenerator)({
+const serverGenerator = (0, kubb_kit.defineGenerator)({
 	name: "operations",
-	renderer: _kubb_renderer_jsx.jsxRenderer,
+	renderer: kubb_jsx.jsxRenderer,
 	operations(nodes, ctx) {
-		const { adapter, config, resolver, plugin, driver, root } = ctx;
-		const { output, paramsCasing, group } = ctx.options;
+		const { config, resolver, plugin, driver, root } = ctx;
+		const { output, group } = ctx.options;
 		const pluginZod = driver.getPlugin(_kubb_plugin_zod.pluginZodName);
 		if (!pluginZod) return;
 		const zodResolver = driver.getResolver(_kubb_plugin_zod.pluginZodName);
@@ -801,34 +651,32 @@ const serverGenerator = (0, _kubb_core.defineGenerator)({
 			path: node_path.default.resolve(root, output.path, ".mcp.json"),
 			meta: { pluginName: plugin.name }
 		};
-		const operationsMapped = nodes.map((node) => {
-			const { path: pathParams, query: queryParams, header: headerParams } = getOperationParameters(node, { paramsCasing });
-			const mcpFile = resolver.resolveFile({
+		const operationsMapped = nodes.filter(kubb_kit.ast.isHttpOperationNode).map((node) => {
+			const { path: pathParams, query: queryParams, header: headerParams } = getOperationParameters(node);
+			const mcpFile = resolver.file({
 				name: node.operationId,
 				extname: ".ts",
 				tag: node.tags[0] ?? "default",
-				path: node.path
-			}, {
+				path: node.path,
 				root,
 				output,
-				group
+				group: group ?? void 0
 			});
-			const zodFile = zodResolver.resolveFile({
+			const zodFile = zodResolver.file({
 				name: node.operationId,
 				extname: ".ts",
 				tag: node.tags[0] ?? "default",
-				path: node.path
-			}, {
+				path: node.path,
 				root,
 				output: pluginZod.options?.output ?? output,
-				group: pluginZod.options?.group
+				group: pluginZod.options?.group ?? void 0
 			});
-			const requestName = node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName(node) : void 0;
+			const requestName = node.requestBody?.content?.[0]?.schema ? zodResolver.response.body(node) : null;
 			const successStatus = findSuccessStatusCode(node.responses);
-			const responseName = successStatus ? zodResolver.resolveResponseStatusName(node, successStatus) : void 0;
+			const responseName = successStatus ? zodResolver.response.status(node, successStatus) : null;
 			const resolveParams = (params) => params.map((p) => ({
 				name: p.name,
-				schemaName: zodResolver.resolveParamName(node, p)
+				schemaName: zodResolver.param.name(node, p)
 			}));
 			return {
 				tool: {
@@ -837,13 +685,13 @@ const serverGenerator = (0, _kubb_core.defineGenerator)({
 					description: node.description || `Make a ${node.method.toUpperCase()} request to ${node.path}`
 				},
 				mcp: {
-					name: resolver.resolveHandlerName(node),
+					name: resolver.handler.name(node),
 					file: mcpFile
 				},
 				zod: {
 					pathParams: resolveParams(pathParams),
-					queryParams: queryParams.length ? resolveParams(queryParams) : void 0,
-					headerParams: headerParams.length ? resolveParams(headerParams) : void 0,
+					queryParams: queryParams.length ? resolveParams(queryParams) : null,
+					headerParams: headerParams.length ? resolveParams(headerParams) : null,
 					requestName,
 					responseName,
 					file: zodFile
@@ -860,60 +708,67 @@ const serverGenerator = (0, _kubb_core.defineGenerator)({
 				zod.responseName
 			].filter((name) => Boolean(name));
 			const uniqueNames = [...new Set(zodNames)].sort();
-			return [/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
+			return [/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
 				name: [mcp.name],
 				root: serverFile.path,
 				path: mcp.file.path
-			}, mcp.name), uniqueNames.length > 0 && /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
+			}, mcp.name), uniqueNames.length > 0 && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
 				name: uniqueNames,
 				root: serverFile.path,
 				path: zod.file.path
 			}, `zod-${mcp.name}`)].filter(Boolean);
 		});
-		return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx.File, {
+		return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx.File, {
 			baseName: serverFile.baseName,
 			path: serverFile.path,
 			meta: serverFile.meta,
-			banner: resolver.resolveBanner(adapter.inputNode, {
+			banner: resolver.default.banner(ctx.meta, {
 				output,
-				config
+				config,
+				file: {
+					path: serverFile.path,
+					baseName: serverFile.baseName
+				}
 			}),
-			footer: resolver.resolveFooter(adapter.inputNode, {
+			footer: resolver.default.footer(ctx.meta, {
 				output,
-				config
+				config,
+				file: {
+					path: serverFile.path,
+					baseName: serverFile.baseName
+				}
 			}),
 			children: [
-				/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
 					name: ["McpServer"],
 					path: "@modelcontextprotocol/sdk/server/mcp"
 				}),
-				/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
 					name: ["z"],
 					path: "zod"
 				}),
-				/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
 					name: ["StdioServerTransport"],
 					path: "@modelcontextprotocol/sdk/server/stdio"
 				}),
 				imports,
-				/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(Server, {
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(Server, {
 					name,
-					serverName: adapter.inputNode?.meta?.title ?? "server",
-					serverVersion: adapter.inputNode?.meta?.version ?? "0.0.0",
-					paramsCasing,
+					serverName: ctx.meta.title ?? "server",
+					serverVersion: ctx.meta.version ?? "0.0.0",
 					operations: operationsMapped
 				})
 			]
-		}), /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File, {
+		}), /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File, {
 			baseName: jsonFile.baseName,
 			path: jsonFile.path,
 			meta: jsonFile.meta,
-			children: /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Source, {
+			children: /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Source, {
 				name,
 				children: `
           {
             "mcpServers": {
-              "${adapter.inputNode?.meta?.title || "server"}": {
+              "${ctx.meta.title || "server"}": {
                 "type": "stdio",
                 "command": "npx",
                 "args": ["tsx", "${node_path.default.relative(node_path.default.dirname(jsonFile.path), serverFile.path)}"]
@@ -928,101 +783,87 @@ const serverGenerator = (0, _kubb_core.defineGenerator)({
 //#endregion
 //#region src/resolvers/resolverMcp.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'
+* ```
 */
-const resolverMcp = (0, _kubb_core.defineResolver)(() => ({
-	name: "default",
+const resolverMcp = (0, kubb_kit.createResolver)({
 	pluginName: "plugin-mcp",
-	default(name, type) {
-		if (type === "file") return camelCase(name, { isFile: true });
+	name(name) {
 		return camelCase(name, { suffix: "handler" });
 	},
-	resolveName(name) {
-		return this.default(name, "function");
-	},
-	resolvePathName(name, type) {
-		return this.default(name, type);
-	},
-	resolveHandlerName(node) {
-		return this.resolveName(node.operationId);
-	}
-}));
+	handler: { name(node) {
+		return this.name(node.operationId);
+	} }
+});
 //#endregion
 //#region src/plugin.ts
+/**
+* Canonical plugin name for `@kubb/plugin-mcp`. Used for driver lookups and
+* cross-plugin dependency references.
+*/
 const pluginMcpName = "plugin-mcp";
-const pluginMcp = (0, _kubb_core.definePlugin)((options) => {
+/**
+* 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',
+*     }),
+*   ],
+* })
+* ```
+*/
+const pluginMcp = (0, kubb_kit.definePlugin)((options) => {
 	const { output = {
 		path: "mcp",
-		barrelType: "named"
-	}, group, exclude = [], include, override = [], paramsCasing, client, resolver: userResolver, transformer: userTransformer, generators: userGenerators = [] } = options;
-	const clientName = client?.client ?? "axios";
-	const clientImportPath = client?.importPath ?? (!client?.bundle ? `@kubb/plugin-client/clients/${clientName}` : void 0);
-	const groupConfig = group ? {
-		...group,
-		name: group.name ? group.name : (ctx) => {
-			if (group.type === "path") return `${ctx.group.split("/")[1]}`;
-			return `${camelCase(ctx.group)}Requests`;
-		}
-	} : void 0;
+		barrel: { type: "named" }
+	}, group, exclude = [], include, override = [], client, resolver: userResolver, macros: userMacros } = options;
+	const groupConfig = createGroupConfig(group);
 	return {
 		name: pluginMcpName,
 		options,
 		dependencies: [_kubb_plugin_ts.pluginTsName, _kubb_plugin_zod.pluginZodName],
 		hooks: { "kubb:plugin:setup"(ctx) {
-			const resolver = userResolver ? {
-				...resolverMcp,
-				...userResolver
-			} : resolverMcp;
+			const resolver = userResolver ? kubb_kit.Resolver.merge(resolverMcp, userResolver) : resolverMcp;
 			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: resolveContractClient({
+					client,
+					plugins: ctx.config.plugins
+				}),
 				resolver
 			});
 			ctx.setResolver(resolver);
-			if (userTransformer) ctx.setTransformer(userTransformer);
-			ctx.addGenerator(mcpGenerator);
-			ctx.addGenerator(serverGenerator);
-			for (const gen of userGenerators) ctx.addGenerator(gen);
-			const root = node_path$1.default.resolve(ctx.config.root, ctx.config.output.path);
-			const hasClientPlugin = ctx.config.plugins?.some((p) => p.name === _kubb_plugin_client.pluginClientName);
-			if (client?.bundle && !hasClientPlugin && !clientImportPath) ctx.injectFile({
-				baseName: "fetch.ts",
-				path: node_path$1.default.resolve(root, ".kubb/fetch.ts"),
-				sources: [_kubb_core.ast.createSource({
-					name: "fetch",
-					nodes: [_kubb_core.ast.createText(clientName === "fetch" ? _kubb_plugin_client_templates_clients_fetch_source.source : _kubb_plugin_client_templates_clients_axios_source.source)],
-					isExportable: true,
-					isIndexable: true
-				})]
-			});
-			if (!hasClientPlugin) ctx.injectFile({
-				baseName: "config.ts",
-				path: node_path$1.default.resolve(root, ".kubb/config.ts"),
-				sources: [_kubb_core.ast.createSource({
-					name: "config",
-					nodes: [_kubb_core.ast.createText(_kubb_plugin_client_templates_config_source.source)],
-					isExportable: false,
-					isIndexable: false
-				})]
-			});
+			if (userMacros?.length) ctx.setMacros(userMacros);
+			ctx.addGenerator(mcpGenerator, serverGenerator);
 		} }
 	};
 });