@kubb/plugin-mcp 5.0.0-beta.3 → 5.0.0-beta.30

package/dist/index.js

@@ -2,7 +2,7 @@ import "./chunk--u3MIqq1.js";
 import path from "node:path";
 import { ast, defineGenerator, definePlugin, defineResolver } from "@kubb/core";
 import { functionPrinter, pluginTsName } from "@kubb/plugin-ts";
-import { Const, File, Function, jsxRenderer } from "@kubb/renderer-jsx";
+import { Const, File, Function, jsxRendererSync } from "@kubb/renderer-jsx";
 import { Fragment, jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
 import { pluginZodName } from "@kubb/plugin-zod";
 import { pluginClientName } from "@kubb/plugin-client";
@@ -220,16 +220,16 @@ var URLPath = class {
 	get object() {
 		return this.toObject();
 	}
-	/** Returns a map of path parameter names, or `undefined` when the path has no parameters.
+	/** Returns a map of path parameter names, or `null` when the path has no parameters.
 	*
 	* @example
 	* ```ts
 	* new URLPath('/pet/{petId}').params // { petId: 'petId' }
-	* new URLPath('/pet').params         // undefined
+	* new URLPath('/pet').params         // null
 	* ```
 	*/
 	get params() {
-		return this.getParams();
+		return this.toParamsObject();
 	}
 	#transformParam(raw) {
 		const param = isValidVarName(raw) ? raw : camelCase(raw);
@@ -247,7 +247,7 @@ var URLPath = class {
 	toObject({ type = "path", replacer, stringify } = {}) {
 		const object = {
 			url: type === "path" ? this.toURLPath() : this.toTemplateString({ replacer }),
-			params: this.getParams()
+			params: this.toParamsObject()
 		};
 		if (stringify) {
 			if (type === "template") return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
@@ -263,12 +263,13 @@ var URLPath = class {
 	* @example
 	* new URLPath('/pet/{petId}').toTemplateString() // '`/pet/${petId}`'
 	*/
-	toTemplateString({ prefix = "", replacer } = {}) {
-		return `\`${prefix}${this.path.split(/\{([^}]+)\}/).map((part, i) => {
+	toTemplateString({ prefix, replacer } = {}) {
+		const result = this.path.split(/\{([^}]+)\}/).map((part, i) => {
 			if (i % 2 === 0) return part;
 			const param = this.#transformParam(part);
 			return `\${${replacer ? replacer(param) : param}}`;
-		}).join("")}\``;
+		}).join("");
+		return `\`${prefix ?? ""}${result}\``;
 	}
 	/**
 	* Extracts all `{param}` segments from the path and returns them as a key-value map.
@@ -277,17 +278,17 @@ var URLPath = class {
 	*
 	* @example
 	* ```ts
-	* new URLPath('/pet/{petId}/tag/{tagId}').getParams()
+	* new URLPath('/pet/{petId}/tag/{tagId}').toParamsObject()
 	* // { petId: 'petId', tagId: 'tagId' }
 	* ```
 	*/
-	getParams(replacer) {
+	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;
+		return Object.keys(params).length > 0 ? params : null;
 	}
 	/** Converts the OpenAPI path to Express-style colon syntax.
 	*
@@ -301,82 +302,111 @@ var URLPath = class {
 	}
 };
 //#endregion
-//#region src/utils.ts
-/**
-* Find the first 2xx response status code from an operation's responses.
-*/
-function findSuccessStatusCode(responses) {
-	for (const res of responses) {
-		const code = Number(res.statusCode);
-		if (code >= 200 && code < 300) return res.statusCode;
-	}
+//#region ../../internals/shared/src/operation.ts
+function getOperationLink(node, link) {
+	if (!link) return null;
+	if (typeof link === "function") return link(node) ?? null;
+	if (link === "urlPath") return node.path ? `{@link ${new URLPath(node.path).URL}}` : null;
+	return `{@link ${node.path.replaceAll("{", ":").replaceAll("}", "")}}`;
 }
-/**
-* Render a group param value — compose individual schemas into `z.object({ ... })`,
-* or use a schema name string directly.
-*/
-function zodGroupExpr(entry) {
-	if (typeof entry === "string") return entry;
-	return `z.object({ ${entry.map((p) => `${JSON.stringify(p.name)}: ${p.schemaName}`).join(", ")} })`;
-}
-/**
-* Build JSDoc comment lines from an OperationNode.
-*/
-function getComments(node) {
-	return [
+function buildOperationComments(node, options = {}) {
+	const { link = "pathTemplate", linkPosition = "afterDeprecated", splitLines = false } = options;
+	const linkComment = getOperationLink(node, link);
+	const filteredComments = (linkPosition === "beforeDeprecated" ? [
+		node.description && `@description ${node.description}`,
+		node.summary && `@summary ${node.summary}`,
+		linkComment,
+		node.deprecated && "@deprecated"
+	] : [
 		node.description && `@description ${node.description}`,
 		node.summary && `@summary ${node.summary}`,
 		node.deprecated && "@deprecated",
-		`{@link ${node.path.replaceAll("{", ":").replaceAll("}", "")}}`
-	].filter((x) => Boolean(x));
+		linkComment
+	]).filter((comment) => Boolean(comment));
+	if (!splitLines) return filteredComments;
+	return filteredComments.flatMap((text) => text.split(/\r?\n/).map((line) => line.trim())).filter((comment) => Boolean(comment));
 }
-/**
-* Build a mapping of original param names → camelCase names.
-* Returns `undefined` when no names actually change (no remapping needed).
-*/
-function getParamsMapping(params) {
-	if (!params.length) return;
-	const mapping = {};
-	let hasDifference = false;
-	for (const p of params) {
-		const camelName = camelCase(p.name);
-		mapping[p.name] = camelName;
-		if (p.name !== camelName) hasDifference = true;
-	}
-	return hasDifference ? mapping : void 0;
+function getOperationParameters(node, options = {}) {
+	const params = ast.caseParams(node.parameters, options.paramsCasing);
+	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")
+	};
 }
-/**
-* Convert a SchemaNode type to an inline Zod expression string.
-* 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 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) {
-				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;
-		}
-		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()";
+function getStatusCodeNumber(statusCode) {
+	const code = Number(statusCode);
+	return Number.isNaN(code) ? null : code;
+}
+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);
 	}
-	if (schema.nullable) expr = `${expr}.nullable()`;
-	return expr;
+	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;
+}
+//#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
@@ -391,13 +421,9 @@ function McpHandler({ name, node, resolver, baseURL, dataReturnType, paramsCasin
 	const urlPath = new URLPath(node.path);
 	const contentType = node.requestBody?.content?.[0]?.contentType;
 	const isFormData = contentType === "multipart/form-data";
-	const casedParams = ast.caseParams(node.parameters, paramsCasing);
-	const queryParams = casedParams.filter((p) => p.in === "query");
-	const headerParams = casedParams.filter((p) => p.in === "header");
-	const originalPathParams = node.parameters.filter((p) => p.in === "path");
-	const originalQueryParams = node.parameters.filter((p) => p.in === "query");
-	const originalHeaderParams = node.parameters.filter((p) => p.in === "header");
-	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : void 0;
+	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 = [
@@ -413,11 +439,11 @@ function McpHandler({ name, node, resolver, baseURL, dataReturnType, paramsCasin
 	});
 	const baseParamsSignature = declarationPrinter.print(paramsNode) ?? "";
 	const paramsSignature = baseParamsSignature ? `${baseParamsSignature}, request: RequestHandlerExtra<ServerRequest, ServerNotification>` : "request: RequestHandlerExtra<ServerRequest, ServerNotification>";
-	const pathParamsMapping = paramsCasing ? getParamsMapping(originalPathParams) : void 0;
-	const queryParamsMapping = paramsCasing ? getParamsMapping(originalQueryParams) : void 0;
-	const headerParamsMapping = paramsCasing ? getParamsMapping(originalHeaderParams) : 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 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: ${urlPath.template}`);
@@ -451,7 +477,7 @@ function McpHandler({ name, node, resolver, baseURL, dataReturnType, paramsCasin
 			async: true,
 			export: true,
 			params: paramsSignature,
-			JSDoc: { comments: getComments(node) },
+			JSDoc: { comments: buildOperationComments(node) },
 			returnType: "Promise<CallToolResult>",
 			children: [
 				"",
@@ -473,7 +499,7 @@ function McpHandler({ name, node, resolver, baseURL, dataReturnType, paramsCasin
 				/* @__PURE__ */ jsx("br", {}),
 				isFormData && requestName && "const formData = buildFormData(requestData)",
 				/* @__PURE__ */ jsx("br", {}),
-				`const res = await fetch<${generics.join(", ")}>({ ${fetchConfig.join(", ")} }, request)`,
+				`const res = await client<${generics.join(", ")}>({ ${fetchConfig.join(", ")} }, request)`,
 				/* @__PURE__ */ jsx("br", {}),
 				callToolResult
 			]
@@ -481,6 +507,39 @@ function McpHandler({ name, node, resolver, baseURL, dataReturnType, paramsCasin
 	});
 }
 //#endregion
+//#region src/utils.ts
+/**
+* Render a group param value — compose individual schemas into `z.object({ ... })`,
+* or use a schema name string directly.
+*/
+function zodGroupExpr(entry) {
+	if (typeof entry === "string") return entry;
+	return `z.object({ ${entry.map((p) => `${JSON.stringify(p.name)}: ${p.schemaName}`).join(", ")} })`;
+}
+/**
+* Convert a SchemaNode type to an inline Zod expression string.
+* Used as fallback when no named zod schema is available for a path parameter.
+*/
+function zodExprFromSchemaNode(schema) {
+	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")) return `z.enum([${rawValues.map((v) => JSON.stringify(v)).join(", ")}])`;
+			if (rawValues.length > 0) {
+				const literals = rawValues.map((v) => `z.literal(${JSON.stringify(v)})`);
+				return literals.length === 1 ? literals[0] : `z.union([${literals.join(", ")}])`;
+			}
+			return "z.string()";
+		}
+		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 = functionPrinter({ mode: "keys" });
 function Server({ name, serverName, serverVersion, paramsCasing, operations }) {
@@ -500,7 +559,7 @@ function Server({ name, serverName, serverVersion, paramsCasing, operations }) {
           `
 			}),
 			operations.map(({ tool, mcp, zod, node }) => {
-				const pathParams = ast.caseParams(node.parameters, paramsCasing).filter((p) => p.in === "path");
+				const { path: pathParams } = getOperationParameters(node, { paramsCasing });
 				const pathEntries = [];
 				const otherEntries = [];
 				for (const p of pathParams) {
@@ -527,9 +586,9 @@ function Server({ name, serverName, serverVersion, paramsCasing, operations }) {
 				const paramsNode = entries.length ? ast.createFunctionParameters({ params: [ast.createParameterGroup({ properties: entries.map((e) => ast.createFunctionParameter({
 					name: e.key,
 					optional: false
-				})) })] }) : void 0;
+				})) })] }) : null;
 				const destructured = paramsNode ? keysPrinter.print(paramsNode) ?? "" : "";
-				const inputSchema = entries.length ? `{ ${entries.map((e) => `${e.key}: ${e.value}`).join(", ")} }` : void 0;
+				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,
@@ -570,29 +629,27 @@ server.registerTool(${JSON.stringify(tool.name)}, {
 }
 //#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.
+*/
 const mcpGenerator = defineGenerator({
 	name: "mcp",
-	renderer: jsxRenderer,
+	renderer: jsxRendererSync,
 	operation(node, ctx) {
 		const { resolver, driver, root } = ctx;
 		const { output, client, paramsCasing, group } = ctx.options;
 		const pluginTs = driver.getPlugin(pluginTsName);
 		if (!pluginTs) return null;
 		const tsResolver = driver.getResolver(pluginTsName);
-		const casedParams = ast.caseParams(node.parameters, paramsCasing);
-		const pathParams = casedParams.filter((p) => p.in === "path");
-		const queryParams = casedParams.filter((p) => p.in === "query");
-		const headerParams = casedParams.filter((p) => p.in === "header");
-		const importedTypeNames = [
-			...pathParams.map((p) => tsResolver.resolvePathParamsName(node, p)),
-			...queryParams.map((p) => tsResolver.resolveQueryParamsName(node, p)),
-			...headerParams.map((p) => tsResolver.resolveHeaderParamsName(node, p)),
-			node.requestBody?.content?.[0]?.schema ? tsResolver.resolveDataName(node) : void 0,
-			tsResolver.resolveResponseName(node),
-			...node.responses.filter((r) => Number(r.statusCode) >= 400).map((r) => tsResolver.resolveResponseStatusName(node, r.statusCode))
-		].filter(Boolean);
+		const importedTypeNames = resolveOperationTypeNames(node, tsResolver, {
+			paramsCasing,
+			responseStatusNames: "error"
+		});
 		const meta = {
-			name: resolver.resolveName(node.operationId),
+			name: resolver.resolveHandlerName(node),
 			file: resolver.resolveFile({
 				name: node.operationId,
 				extname: ".ts",
@@ -601,7 +658,7 @@ const mcpGenerator = defineGenerator({
 			}, {
 				root,
 				output,
-				group
+				group: group ?? void 0
 			}),
 			fileTs: tsResolver.resolveFile({
 				name: node.operationId,
@@ -611,7 +668,7 @@ const mcpGenerator = defineGenerator({
 			}, {
 				root,
 				output: pluginTs.options?.output ?? output,
-				group: pluginTs.options?.group
+				group: pluginTs.options?.group ?? void 0
 			})
 		};
 		return /* @__PURE__ */ jsxs(File, {
@@ -655,7 +712,7 @@ const mcpGenerator = defineGenerator({
 						isTypeOnly: true
 					}),
 					/* @__PURE__ */ jsx(File.Import, {
-						name: "fetch",
+						name: "client",
 						path: client.importPath
 					}),
 					client.dataReturnType === "full" && /* @__PURE__ */ jsx(File.Import, {
@@ -671,18 +728,18 @@ const mcpGenerator = defineGenerator({
 							"ResponseErrorConfig"
 						],
 						root: meta.file.path,
-						path: path.resolve(root, ".kubb/fetch.ts"),
+						path: path.resolve(root, ".kubb/client.ts"),
 						isTypeOnly: true
 					}),
 					/* @__PURE__ */ jsx(File.Import, {
-						name: ["fetch"],
+						name: ["client"],
 						root: meta.file.path,
-						path: path.resolve(root, ".kubb/fetch.ts")
+						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/fetch.ts"),
+						path: path.resolve(root, ".kubb/client.ts"),
 						isTypeOnly: true
 					})
 				] }),
@@ -709,9 +766,9 @@ const mcpGenerator = defineGenerator({
 */
 const serverGenerator = defineGenerator({
 	name: "operations",
-	renderer: jsxRenderer,
+	renderer: jsxRendererSync,
 	operations(nodes, ctx) {
-		const { adapter, config, resolver, plugin, driver, root } = ctx;
+		const { config, resolver, plugin, driver, root } = ctx;
 		const { output, paramsCasing, group } = ctx.options;
 		const pluginZod = driver.getPlugin(pluginZodName);
 		if (!pluginZod) return;
@@ -728,10 +785,7 @@ const serverGenerator = defineGenerator({
 			meta: { pluginName: plugin.name }
 		};
 		const operationsMapped = nodes.map((node) => {
-			const casedParams = ast.caseParams(node.parameters, paramsCasing);
-			const pathParams = casedParams.filter((p) => p.in === "path");
-			const queryParams = casedParams.filter((p) => p.in === "query");
-			const headerParams = casedParams.filter((p) => p.in === "header");
+			const { path: pathParams, query: queryParams, header: headerParams } = getOperationParameters(node, { paramsCasing });
 			const mcpFile = resolver.resolveFile({
 				name: node.operationId,
 				extname: ".ts",
@@ -740,7 +794,7 @@ const serverGenerator = defineGenerator({
 			}, {
 				root,
 				output,
-				group
+				group: group ?? void 0
 			});
 			const zodFile = zodResolver.resolveFile({
 				name: node.operationId,
@@ -750,11 +804,11 @@ const serverGenerator = defineGenerator({
 			}, {
 				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.resolveDataName(node) : null;
 			const successStatus = findSuccessStatusCode(node.responses);
-			const responseName = successStatus ? zodResolver.resolveResponseStatusName(node, successStatus) : void 0;
+			const responseName = successStatus ? zodResolver.resolveResponseStatusName(node, successStatus) : null;
 			const resolveParams = (params) => params.map((p) => ({
 				name: p.name,
 				schemaName: zodResolver.resolveParamName(node, p)
@@ -766,13 +820,13 @@ const serverGenerator = defineGenerator({
 					description: node.description || `Make a ${node.method.toUpperCase()} request to ${node.path}`
 				},
 				mcp: {
-					name: resolver.resolveName(node.operationId),
+					name: resolver.resolveHandlerName(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
@@ -787,7 +841,7 @@ const serverGenerator = defineGenerator({
 				...(zod.headerParams ?? []).map((p) => p.schemaName),
 				zod.requestName,
 				zod.responseName
-			].filter(Boolean);
+			].filter((name) => Boolean(name));
 			const uniqueNames = [...new Set(zodNames)].sort();
 			return [/* @__PURE__ */ jsx(File.Import, {
 				name: [mcp.name],
@@ -803,13 +857,21 @@ const serverGenerator = defineGenerator({
 			baseName: serverFile.baseName,
 			path: serverFile.path,
 			meta: serverFile.meta,
-			banner: resolver.resolveBanner(adapter.inputNode, {
+			banner: resolver.resolveBanner(ctx.meta, {
 				output,
-				config
+				config,
+				file: {
+					path: serverFile.path,
+					baseName: serverFile.baseName
+				}
 			}),
-			footer: resolver.resolveFooter(adapter.inputNode, {
+			footer: resolver.resolveFooter(ctx.meta, {
 				output,
-				config
+				config,
+				file: {
+					path: serverFile.path,
+					baseName: serverFile.baseName
+				}
 			}),
 			children: [
 				/* @__PURE__ */ jsx(File.Import, {
@@ -827,8 +889,8 @@ const serverGenerator = defineGenerator({
 				imports,
 				/* @__PURE__ */ jsx(Server, {
 					name,
-					serverName: adapter.inputNode?.meta?.title ?? "server",
-					serverVersion: adapter.inputNode?.meta?.version ?? "0.0.0",
+					serverName: ctx.meta.title ?? "server",
+					serverVersion: ctx.meta.version ?? "0.0.0",
 					paramsCasing,
 					operations: operationsMapped
 				})
@@ -842,7 +904,7 @@ const serverGenerator = defineGenerator({
 				children: `
           {
             "mcpServers": {
-              "${adapter.inputNode?.meta?.title || "server"}": {
+              "${ctx.meta.title || "server"}": {
                 "type": "stdio",
                 "command": "npx",
                 "args": ["tsx", "${path.relative(path.dirname(jsonFile.path), serverFile.path)}"]
@@ -857,14 +919,18 @@ const serverGenerator = 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.default('addPet', 'function') // 'addPetHandler'
+* ```
 */
-const resolverMcp = defineResolver((ctx) => ({
+const resolverMcp = defineResolver(() => ({
 	name: "default",
 	pluginName: "plugin-mcp",
 	default(name, type) {
@@ -872,12 +938,50 @@ const resolverMcp = defineResolver((ctx) => ({
 		return camelCase(name, { suffix: "handler" });
 	},
 	resolveName(name) {
-		return ctx.default(name, "function");
+		return this.default(name, "function");
+	},
+	resolvePathName(name, type) {
+		return this.default(name, type);
+	},
+	resolveHandlerName(node) {
+		return this.resolveName(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";
+/**
+* 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.
+*
+* @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'
+*
+* export default defineConfig({
+*   input: { path: './petStore.yaml' },
+*   output: { path: './src/gen' },
+*   plugins: [
+*     pluginTs(),
+*     pluginClient(),
+*     pluginZod(),
+*     pluginMcp({
+*       output: { path: './mcp' },
+*       client: { baseURL: 'https://petstore.swagger.io/v2' },
+*     }),
+*   ],
+* })
+* ```
+*/
 const pluginMcp = definePlugin((options) => {
 	const { output = {
 		path: "mcp",
@@ -891,7 +995,7 @@ const pluginMcp = definePlugin((options) => {
 			if (group.type === "path") return `${ctx.group.split("/")[1]}`;
 			return `${camelCase(ctx.group)}Requests`;
 		}
-	} : void 0;
+	} : null;
 	return {
 		name: pluginMcpName,
 		options,
@@ -927,10 +1031,10 @@ const pluginMcp = definePlugin((options) => {
 			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: "fetch.ts",
-				path: path.resolve(root, ".kubb/fetch.ts"),
+				baseName: "client.ts",
+				path: path.resolve(root, ".kubb/client.ts"),
 				sources: [ast.createSource({
-					name: "fetch",
+					name: "client",
 					nodes: [ast.createText(clientName === "fetch" ? source$1 : source)],
 					isExportable: true,
 					isIndexable: true