@kubb/plugin-mcp 5.0.0-beta.4 → 5.0.0-beta.42

package/dist/index.cjs

@@ -247,16 +247,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);
@@ -274,7 +274,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(`"`, "");
@@ -290,12 +290,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.
@@ -304,17 +305,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.
 	*
@@ -328,82 +329,144 @@ 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 node.path ? `{@link ${node.path.replaceAll("{", ":").replaceAll("}", "")}}` : null;
 }
-/**
-* 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;
+function getOperationParameters(node, options = {}) {
+	const params = _kubb_core.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")
+	};
+}
+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);
 	}
-	return hasDifference ? mapping : void 0;
+	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/group.ts
 /**
-* Convert a SchemaNode type to an inline Zod expression string.
-* Used as fallback when no named zod schema is available for a path parameter.
+* 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 `${camelCase(group)}${suffix}` (e.g. `petController`).
+*
+* 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.
+* @param options.suffix - Appended to non-`path` group names, e.g. `'Controller'` or `'Requests'`.
+*
+* @example
+* ```ts
+* createGroupConfig(group, { suffix: 'Controller' }) // plugin-ts, plugin-client, …
+* createGroupConfig(group, { suffix: 'Requests' })   // plugin-cypress, plugin-mcp
+* ```
 */
-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()";
-	}
-	if (schema.nullable) expr = `${expr}.nullable()`;
-	return expr;
+function createGroupConfig(group, options) {
+	if (!group) return null;
+	const defaultName = (ctx) => {
+		if (group.type === "path") return `${ctx.group.split("/")[1]}`;
+		return `${camelCase(ctx.group)}${options.suffix}`;
+	};
+	return {
+		...group,
+		name: group.name ? group.name : defaultName
+	};
+}
+//#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
@@ -415,16 +478,13 @@ function buildRemappingCode(mapping, varName, sourceName) {
 }
 const declarationPrinter = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
 function McpHandler({ name, node, resolver, baseURL, dataReturnType, paramsCasing }) {
+	if (!_kubb_core.ast.isHttpOperationNode(node)) return null;
 	const urlPath = new URLPath(node.path);
 	const contentType = node.requestBody?.content?.[0]?.contentType;
 	const isFormData = contentType === "multipart/form-data";
-	const casedParams = _kubb_core.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 = [
@@ -440,11 +500,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}`);
@@ -478,7 +538,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: [
 				"",
@@ -500,7 +560,7 @@ function McpHandler({ name, node, resolver, baseURL, dataReturnType, paramsCasin
 				/* @__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)`,
+				`const res = await client<${generics.join(", ")}>({ ${fetchConfig.join(", ")} }, request)`,
 				/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)("br", {}),
 				callToolResult
 			]
@@ -508,62 +568,80 @@ 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 = (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 pathParams = _kubb_core.ast.caseParams(node.parameters, paramsCasing).filter((p) => p.in === "path");
-				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 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)
+			});
+		}
+		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
+		})) })] }) : 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},
@@ -571,14 +649,34 @@ 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),
+	}).filter(Boolean).join("\n");
+	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.Function, {
+				name: "getServer",
+				export: true,
+				children: `const server = new McpServer({
+  name: '${serverName}',
+  version: '${serverVersion}',
+})
+${registrations}
+return server`
+			}),
+			/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.Const, {
+				name: "server",
+				export: true,
+				children: "getServer()"
+			}),
 			/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.Function, {
 				name: "startServer",
 				async: true,
@@ -597,29 +695,28 @@ 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 = (0, _kubb_core.defineGenerator)({
 	name: "mcp",
-	renderer: _kubb_renderer_jsx.jsxRenderer,
+	renderer: _kubb_renderer_jsx.jsxRendererSync,
 	operation(node, ctx) {
+		if (!_kubb_core.ast.isHttpOperationNode(node)) return null;
 		const { resolver, driver, root } = ctx;
 		const { output, client, paramsCasing, group } = ctx.options;
 		const pluginTs = driver.getPlugin(_kubb_plugin_ts.pluginTsName);
 		if (!pluginTs) return null;
 		const tsResolver = driver.getResolver(_kubb_plugin_ts.pluginTsName);
-		const casedParams = _kubb_core.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",
@@ -628,7 +725,7 @@ const mcpGenerator = (0, _kubb_core.defineGenerator)({
 			}, {
 				root,
 				output,
-				group
+				group: group ?? void 0
 			}),
 			fileTs: tsResolver.resolveFile({
 				name: node.operationId,
@@ -638,7 +735,7 @@ const mcpGenerator = (0, _kubb_core.defineGenerator)({
 			}, {
 				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, {
@@ -682,7 +779,7 @@ const mcpGenerator = (0, _kubb_core.defineGenerator)({
 						isTypeOnly: true
 					}),
 					/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
-						name: "fetch",
+						name: "client",
 						path: client.importPath
 					}),
 					client.dataReturnType === "full" && /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
@@ -698,18 +795,18 @@ const mcpGenerator = (0, _kubb_core.defineGenerator)({
 							"ResponseErrorConfig"
 						],
 						root: meta.file.path,
-						path: node_path.default.resolve(root, ".kubb/fetch.ts"),
+						path: node_path.default.resolve(root, ".kubb/client.ts"),
 						isTypeOnly: true
 					}),
 					/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
-						name: ["fetch"],
+						name: ["client"],
 						root: meta.file.path,
-						path: node_path.default.resolve(root, ".kubb/fetch.ts")
+						path: node_path.default.resolve(root, ".kubb/client.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"),
+						path: node_path.default.resolve(root, ".kubb/client.ts"),
 						isTypeOnly: true
 					})
 				] }),
@@ -736,9 +833,9 @@ const mcpGenerator = (0, _kubb_core.defineGenerator)({
 */
 const serverGenerator = (0, _kubb_core.defineGenerator)({
 	name: "operations",
-	renderer: _kubb_renderer_jsx.jsxRenderer,
+	renderer: _kubb_renderer_jsx.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(_kubb_plugin_zod.pluginZodName);
 		if (!pluginZod) return;
@@ -754,11 +851,8 @@ 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 casedParams = _kubb_core.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 operationsMapped = nodes.filter(_kubb_core.ast.isHttpOperationNode).map((node) => {
+			const { path: pathParams, query: queryParams, header: headerParams } = getOperationParameters(node, { paramsCasing });
 			const mcpFile = resolver.resolveFile({
 				name: node.operationId,
 				extname: ".ts",
@@ -767,7 +861,7 @@ const serverGenerator = (0, _kubb_core.defineGenerator)({
 			}, {
 				root,
 				output,
-				group
+				group: group ?? void 0
 			});
 			const zodFile = zodResolver.resolveFile({
 				name: node.operationId,
@@ -777,11 +871,11 @@ const serverGenerator = (0, _kubb_core.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)
@@ -793,13 +887,13 @@ const serverGenerator = (0, _kubb_core.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
@@ -814,7 +908,7 @@ const serverGenerator = (0, _kubb_core.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__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
 				name: [mcp.name],
@@ -830,13 +924,21 @@ const serverGenerator = (0, _kubb_core.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__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
@@ -854,8 +956,8 @@ const serverGenerator = (0, _kubb_core.defineGenerator)({
 				imports,
 				/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.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
 				})
@@ -869,7 +971,7 @@ const serverGenerator = (0, _kubb_core.defineGenerator)({
 				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)}"]
@@ -884,14 +986,18 @@ 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.default('addPet', 'function') // 'addPetHandler'
+* ```
 */
-const resolverMcp = (0, _kubb_core.defineResolver)((ctx) => ({
+const resolverMcp = (0, _kubb_core.defineResolver)(() => ({
 	name: "default",
 	pluginName: "plugin-mcp",
 	default(name, type) {
@@ -899,12 +1005,50 @@ const resolverMcp = (0, _kubb_core.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 = (0, _kubb_core.definePlugin)((options) => {
 	const { output = {
 		path: "mcp",
@@ -912,13 +1056,7 @@ const pluginMcp = (0, _kubb_core.definePlugin)((options) => {
 	}, 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;
+	const groupConfig = createGroupConfig(group, { suffix: "Requests" });
 	return {
 		name: pluginMcpName,
 		options,
@@ -954,10 +1092,10 @@ const pluginMcp = (0, _kubb_core.definePlugin)((options) => {
 			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"),
+				baseName: "client.ts",
+				path: node_path$1.default.resolve(root, ".kubb/client.ts"),
 				sources: [_kubb_core.ast.createSource({
-					name: "fetch",
+					name: "client",
 					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