@kubb/plugin-mcp 5.0.0-alpha.9 → 5.0.0-beta.15

package/dist/index.js

@@ -1,122 +1,1017 @@
 import "./chunk--u3MIqq1.js";
-import { n as camelCase } from "./Server-KWLMg0Lm.js";
-import { n as mcpGenerator, t as serverGenerator } from "./generators-TtEOkDB1.js";
 import path from "node:path";
-import { createPlugin, getBarrelFiles, getMode } from "@kubb/core";
+import { ast, defineGenerator, definePlugin, defineResolver } from "@kubb/core";
+import { functionPrinter, pluginTsName } from "@kubb/plugin-ts";
+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";
 import { source } from "@kubb/plugin-client/templates/clients/axios.source";
 import { source as source$1 } from "@kubb/plugin-client/templates/clients/fetch.source";
 import { source as source$2 } from "@kubb/plugin-client/templates/config.source";
-import { OperationGenerator, pluginOasName } from "@kubb/plugin-oas";
-import { pluginTsName } from "@kubb/plugin-ts";
-import { pluginZodName } from "@kubb/plugin-zod";
+//#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;
+		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, "");
+}
+/**
+* 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.
+*
+* Only splits on dots followed by a letter so that version numbers
+* embedded in operationIds (e.g. `v2025.0`) are kept intact.
+*/
+function applyToFileParts(text, transformPart) {
+	const parts = text.split(/\.(?=[a-zA-Z])/);
+	return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
+}
+/**
+* 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'
+*/
+function camelCase(text, { isFile, prefix = "", suffix = "" } = {}) {
+	if (isFile) return applyToFileParts(text, (part, isLast) => camelCase(part, isLast ? {
+		prefix,
+		suffix
+	} : {}));
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
+}
+//#endregion
+//#region ../../internals/utils/src/reserved.ts
+/**
+* JavaScript and Java reserved words.
+* @link https://github.com/jonschlinkert/reserved/blob/master/index.js
+*/
+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"
+]);
+/**
+* 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)
+* ```
+*/
+function isValidVarName(name) {
+	if (!name || reservedWords.has(name)) return false;
+	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+}
+//#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}`'
+*/
+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 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",
+		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));
+}
+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")
+	};
+}
+function getStatusCodeNumber(statusCode) {
+	const code = Number(statusCode);
+	return Number.isNaN(code) ? void 0 : 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;
+}
+function resolveErrorNames(node, resolver) {
+	return node.responses.filter((response) => isErrorStatusCode(response.statusCode)).map((response) => resolver.resolveResponseStatusName(node, response.statusCode));
+}
+function resolveStatusCodeNames(node, resolver) {
+	return node.responses.map((response) => resolver.resolveResponseStatusName(node, response.statusCode));
+}
+const typeNamesByResolver = /* @__PURE__ */ new WeakMap();
+function resolveOperationTypeNames(node, resolver, options = {}) {
+	const cacheKey = `${node.operationId}\0${options.paramsCasing ?? ""}\0${options.order ?? ""}\0${options.responseStatusNames ?? ""}\0${(options.exclude ?? []).join(",")}`;
+	let byResolver = typeNamesByResolver.get(resolver);
+	if (byResolver) {
+		const cached = byResolver.get(cacheKey);
+		if (cached) return cached;
+	} else {
+		byResolver = /* @__PURE__ */ new Map();
+		typeNamesByResolver.set(resolver, byResolver);
+	}
+	const { path, query, header } = getOperationParameters(node, { paramsCasing: options.paramsCasing });
+	const responseStatusNames = options.responseStatusNames === "error" ? resolveErrorNames(node, resolver) : options.responseStatusNames === false ? [] : resolveStatusCodeNames(node, resolver);
+	const exclude = new Set(options.exclude ?? []);
+	const paramNames = [
+		...path.map((param) => resolver.resolvePathParamsName(node, param)),
+		...query.map((param) => resolver.resolveQueryParamsName(node, param)),
+		...header.map((param) => resolver.resolveHeaderParamsName(node, param))
+	];
+	const bodyAndResponseNames = [node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : void 0, 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;
+}
+//#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;
+}
+function buildTransformedParamsMapping(params, transformName) {
+	if (!params.length) return;
+	return buildParamsMapping(params, params.map((param) => ({
+		...param,
+		name: transformName(param.name)
+	})));
+}
+//#endregion
+//#region src/components/McpHandler.tsx
+/**
+* Generate a remapping statement: `const mappedX = x ? { "orig": x.camel, ... } : undefined`
+*/
+function buildRemappingCode(mapping, varName, sourceName) {
+	return `const ${varName} = ${sourceName} ? { ${Object.entries(mapping).map(([orig, camel]) => `"${orig}": ${sourceName}.${camel}`).join(", ")} } : undefined`;
+}
+const declarationPrinter = functionPrinter({ mode: "declaration" });
+function McpHandler({ name, node, resolver, baseURL, dataReturnType, paramsCasing }) {
+	const 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 = 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__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ jsxs(Function, {
+			name,
+			async: true,
+			export: true,
+			params: paramsSignature,
+			JSDoc: { comments: buildOperationComments(node) },
+			returnType: "Promise<CallToolResult>",
+			children: [
+				"",
+				/* @__PURE__ */ jsx("br", {}),
+				/* @__PURE__ */ jsx("br", {}),
+				pathParamsMapping && Object.entries(pathParamsMapping).filter(([originalName, camelCaseName]) => originalName !== camelCaseName && isValidVarName(originalName)).map(([originalName, camelCaseName]) => `const ${originalName} = ${camelCaseName}`).join("\n"),
+				pathParamsMapping && /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("br", {}), /* @__PURE__ */ jsx("br", {})] }),
+				queryParamsMapping && queryParams.length > 0 && /* @__PURE__ */ jsxs(Fragment, { children: [
+					buildRemappingCode(queryParamsMapping, "mappedParams", "params"),
+					/* @__PURE__ */ jsx("br", {}),
+					/* @__PURE__ */ jsx("br", {})
+				] }),
+				headerParamsMapping && headerParams.length > 0 && /* @__PURE__ */ jsxs(Fragment, { children: [
+					buildRemappingCode(headerParamsMapping, "mappedHeaders", "headers"),
+					/* @__PURE__ */ jsx("br", {}),
+					/* @__PURE__ */ jsx("br", {})
+				] }),
+				requestName && "const requestData = data",
+				/* @__PURE__ */ jsx("br", {}),
+				isFormData && requestName && "const formData = buildFormData(requestData)",
+				/* @__PURE__ */ jsx("br", {}),
+				`const res = await fetch<${generics.join(", ")}>({ ${fetchConfig.join(", ")} }, request)`,
+				/* @__PURE__ */ jsx("br", {}),
+				callToolResult
+			]
+		})
+	});
+}
+//#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) {
+	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;
+}
+//#endregion
+//#region src/components/Server.tsx
+const keysPrinter = functionPrinter({ mode: "keys" });
+function Server({ name, serverName, serverVersion, paramsCasing, operations }) {
+	return /* @__PURE__ */ jsxs(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: [
+			/* @__PURE__ */ 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 ? ast.createFunctionParameters({ params: [ast.createParameterGroup({ properties: entries.map((e) => 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 `
+server.registerTool(${JSON.stringify(tool.name)}, {
+  ${config},
+  inputSchema: ${inputSchema},
+}, async (${destructured}, request) => {
+  return ${mcp.name}(${destructured}, request)
+})
+          `;
+				return `
+server.registerTool(${JSON.stringify(tool.name)}, {
+  ${config},
+}, async (request) => {
+  return ${mcp.name}(request)
+})
+          `;
+			}).filter(Boolean),
+			/* @__PURE__ */ jsx(Function, {
+				name: "startServer",
+				async: true,
+				export: true,
+				children: `try {
+    const transport = new StdioServerTransport()
+    await server.connect(transport)
+
+  } catch (error) {
+    console.error('Failed to start server:', error)
+    process.exit(1)
+  }`
+			})
+		]
+	});
+}
+//#endregion
+//#region src/generators/mcpGenerator.tsx
+const mcpGenerator = defineGenerator({
+	name: "mcp",
+	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 importedTypeNames = resolveOperationTypeNames(node, tsResolver, {
+			paramsCasing,
+			responseStatusNames: "error"
+		});
+		const meta = {
+			name: resolver.resolveHandlerName(node),
+			file: resolver.resolveFile({
+				name: node.operationId,
+				extname: ".ts",
+				tag: node.tags[0] ?? "default",
+				path: node.path
+			}, {
+				root,
+				output,
+				group
+			}),
+			fileTs: tsResolver.resolveFile({
+				name: node.operationId,
+				extname: ".ts",
+				tag: node.tags[0] ?? "default",
+				path: node.path
+			}, {
+				root,
+				output: pluginTs.options?.output ?? output,
+				group: pluginTs.options?.group
+			})
+		};
+		return /* @__PURE__ */ jsxs(File, {
+			baseName: meta.file.baseName,
+			path: meta.file.path,
+			meta: meta.file.meta,
+			children: [
+				meta.fileTs && importedTypeNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
+					name: Array.from(new Set(importedTypeNames)).sort(),
+					root: meta.file.path,
+					path: meta.fileTs.path,
+					isTypeOnly: true
+				}),
+				/* @__PURE__ */ jsx(File.Import, {
+					name: [
+						"CallToolResult",
+						"ServerNotification",
+						"ServerRequest"
+					],
+					path: "@modelcontextprotocol/sdk/types",
+					isTypeOnly: true
+				}),
+				/* @__PURE__ */ jsx(File.Import, {
+					name: ["RequestHandlerExtra"],
+					path: "@modelcontextprotocol/sdk/shared/protocol",
+					isTypeOnly: true
+				}),
+				/* @__PURE__ */ jsx(File.Import, {
+					name: ["buildFormData"],
+					root: meta.file.path,
+					path: path.resolve(root, ".kubb/config.ts")
+				}),
+				client.importPath ? /* @__PURE__ */ jsxs(Fragment, { children: [
+					/* @__PURE__ */ jsx(File.Import, {
+						name: [
+							"Client",
+							"RequestConfig",
+							"ResponseErrorConfig"
+						],
+						path: client.importPath,
+						isTypeOnly: true
+					}),
+					/* @__PURE__ */ jsx(File.Import, {
+						name: "fetch",
+						path: client.importPath
+					}),
+					client.dataReturnType === "full" && /* @__PURE__ */ jsx(File.Import, {
+						name: ["ResponseConfig"],
+						path: client.importPath,
+						isTypeOnly: true
+					})
+				] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+					/* @__PURE__ */ jsx(File.Import, {
+						name: [
+							"Client",
+							"RequestConfig",
+							"ResponseErrorConfig"
+						],
+						root: meta.file.path,
+						path: path.resolve(root, ".kubb/fetch.ts"),
+						isTypeOnly: true
+					}),
+					/* @__PURE__ */ jsx(File.Import, {
+						name: ["fetch"],
+						root: meta.file.path,
+						path: path.resolve(root, ".kubb/fetch.ts")
+					}),
+					client.dataReturnType === "full" && /* @__PURE__ */ jsx(File.Import, {
+						name: ["ResponseConfig"],
+						root: meta.file.path,
+						path: path.resolve(root, ".kubb/fetch.ts"),
+						isTypeOnly: true
+					})
+				] }),
+				/* @__PURE__ */ jsx(McpHandler, {
+					name: meta.name,
+					node,
+					resolver: tsResolver,
+					baseURL: client.baseURL,
+					dataReturnType: client.dataReturnType || "data",
+					paramsCasing
+				})
+			]
+		});
+	}
+});
+//#endregion
+//#region src/generators/serverGenerator.tsx
+/**
+* Default v5 server generator for `@kubb/plugin-mcp`.
+*
+* Uses individual zod schemas for each param (e.g. `createPetsPathUuidSchema`, `createPetsQueryOffsetSchema`)
+* and `resolveResponseStatusName` for per-status response schemas.
+* Query and header params are composed into `z.object({ ... })` from individual schemas.
+*/
+const serverGenerator = defineGenerator({
+	name: "operations",
+	renderer: jsxRendererSync,
+	operations(nodes, ctx) {
+		const { config, resolver, plugin, driver, root, inputNode } = ctx;
+		const { output, paramsCasing, group } = ctx.options;
+		const pluginZod = driver.getPlugin(pluginZodName);
+		if (!pluginZod) return;
+		const zodResolver = driver.getResolver(pluginZodName);
+		const name = "server";
+		const serverFile = {
+			baseName: "server.ts",
+			path: path.resolve(root, output.path, "server.ts"),
+			meta: { pluginName: plugin.name }
+		};
+		const jsonFile = {
+			baseName: ".mcp.json",
+			path: path.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({
+				name: node.operationId,
+				extname: ".ts",
+				tag: node.tags[0] ?? "default",
+				path: node.path
+			}, {
+				root,
+				output,
+				group
+			});
+			const zodFile = zodResolver.resolveFile({
+				name: node.operationId,
+				extname: ".ts",
+				tag: node.tags[0] ?? "default",
+				path: node.path
+			}, {
+				root,
+				output: pluginZod.options?.output ?? output,
+				group: pluginZod.options?.group
+			});
+			const requestName = node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName(node) : void 0;
+			const successStatus = findSuccessStatusCode(node.responses);
+			const responseName = successStatus ? zodResolver.resolveResponseStatusName(node, successStatus) : void 0;
+			const resolveParams = (params) => params.map((p) => ({
+				name: p.name,
+				schemaName: zodResolver.resolveParamName(node, p)
+			}));
+			return {
+				tool: {
+					name: node.operationId,
+					title: node.summary || void 0,
+					description: node.description || `Make a ${node.method.toUpperCase()} request to ${node.path}`
+				},
+				mcp: {
+					name: resolver.resolveHandlerName(node),
+					file: mcpFile
+				},
+				zod: {
+					pathParams: resolveParams(pathParams),
+					queryParams: queryParams.length ? resolveParams(queryParams) : void 0,
+					headerParams: headerParams.length ? resolveParams(headerParams) : void 0,
+					requestName,
+					responseName,
+					file: zodFile
+				},
+				node
+			};
+		});
+		const imports = operationsMapped.flatMap(({ mcp, zod }) => {
+			const zodNames = [
+				...zod.pathParams.map((p) => p.schemaName),
+				...(zod.queryParams ?? []).map((p) => p.schemaName),
+				...(zod.headerParams ?? []).map((p) => p.schemaName),
+				zod.requestName,
+				zod.responseName
+			].filter((name) => Boolean(name));
+			const uniqueNames = [...new Set(zodNames)].sort();
+			return [/* @__PURE__ */ jsx(File.Import, {
+				name: [mcp.name],
+				root: serverFile.path,
+				path: mcp.file.path
+			}, mcp.name), uniqueNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
+				name: uniqueNames,
+				root: serverFile.path,
+				path: zod.file.path
+			}, `zod-${mcp.name}`)].filter(Boolean);
+		});
+		return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsxs(File, {
+			baseName: serverFile.baseName,
+			path: serverFile.path,
+			meta: serverFile.meta,
+			banner: resolver.resolveBanner(inputNode, {
+				output,
+				config
+			}),
+			footer: resolver.resolveFooter(inputNode, {
+				output,
+				config
+			}),
+			children: [
+				/* @__PURE__ */ jsx(File.Import, {
+					name: ["McpServer"],
+					path: "@modelcontextprotocol/sdk/server/mcp"
+				}),
+				/* @__PURE__ */ jsx(File.Import, {
+					name: ["z"],
+					path: "zod"
+				}),
+				/* @__PURE__ */ jsx(File.Import, {
+					name: ["StdioServerTransport"],
+					path: "@modelcontextprotocol/sdk/server/stdio"
+				}),
+				imports,
+				/* @__PURE__ */ jsx(Server, {
+					name,
+					serverName: inputNode.meta?.title ?? "server",
+					serverVersion: inputNode.meta?.version ?? "0.0.0",
+					paramsCasing,
+					operations: operationsMapped
+				})
+			]
+		}), /* @__PURE__ */ jsx(File, {
+			baseName: jsonFile.baseName,
+			path: jsonFile.path,
+			meta: jsonFile.meta,
+			children: /* @__PURE__ */ jsx(File.Source, {
+				name,
+				children: `
+          {
+            "mcpServers": {
+              "${inputNode.meta?.title || "server"}": {
+                "type": "stdio",
+                "command": "npx",
+                "args": ["tsx", "${path.relative(path.dirname(jsonFile.path), serverFile.path)}"]
+              }
+            }
+          }
+          `
+			})
+		})] });
+	}
+});
+//#endregion
+//#region src/resolvers/resolverMcp.ts
+/**
+* Naming convention resolver for MCP plugin.
+*
+* Provides default naming helpers using camelCase with a `handler` suffix for functions.
+*
+* @example
+* `resolverMcp.default('addPet', 'function')  // → 'addPetHandler'`
+*/
+const resolverMcp = defineResolver(() => ({
+	name: "default",
+	pluginName: "plugin-mcp",
+	default(name, type) {
+		if (type === "file") return camelCase(name, { isFile: true });
+		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);
+	}
+}));
+//#endregion
 //#region src/plugin.ts
 const pluginMcpName = "plugin-mcp";
-const pluginMcp = createPlugin((options) => {
+const pluginMcp = definePlugin((options) => {
 	const { output = {
 		path: "mcp",
 		barrelType: "named"
-	}, group, exclude = [], include, override = [], transformers = {}, generators = [mcpGenerator, serverGenerator].filter(Boolean), contentType, paramsCasing, client } = 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;
 	return {
 		name: pluginMcpName,
-		options: {
-			output,
-			group,
-			paramsCasing,
-			client: {
-				client: clientName,
-				clientType: client?.clientType ?? "function",
-				importPath: clientImportPath,
-				dataReturnType: client?.dataReturnType ?? "data",
-				bundle: client?.bundle,
-				baseURL: client?.baseURL,
-				paramsCasing: client?.paramsCasing
-			}
-		},
-		pre: [
-			pluginOasName,
-			pluginTsName,
-			pluginZodName
-		].filter(Boolean),
-		resolvePath(baseName, pathMode, options) {
-			const root = path.resolve(this.config.root, this.config.output.path);
-			if ((pathMode ?? getMode(path.resolve(root, output.path))) === "single")
- /**
-			* when output is a file then we will always append to the same file(output file), see fileManager.addOrAppend
-			* Other plugins then need to call addOrAppend instead of just add from the fileManager class
-			*/
-			return path.resolve(root, output.path);
-			if (group && (options?.group?.path || options?.group?.tag)) {
-				const groupName = group?.name ? group.name : (ctx) => {
-					if (group?.type === "path") return `${ctx.group.split("/")[1]}`;
-					return `${camelCase(ctx.group)}Requests`;
-				};
-				return path.resolve(root, output.path, groupName({ group: group.type === "path" ? options.group.path : options.group.tag }), baseName);
-			}
-			return path.resolve(root, output.path, baseName);
-		},
-		resolveName(name, type) {
-			const resolvedName = camelCase(name, { isFile: type === "file" });
-			if (type) return transformers?.name?.(resolvedName, type) || resolvedName;
-			return resolvedName;
-		},
-		async install() {
-			const root = path.resolve(this.config.root, this.config.output.path);
-			const mode = getMode(path.resolve(root, output.path));
-			const oas = await this.getOas();
-			const baseURL = await this.getBaseURL();
-			if (baseURL) this.plugin.options.client.baseURL = baseURL;
-			const hasClientPlugin = !!this.driver.getPluginByName(pluginClientName);
-			if (this.plugin.options.client.bundle && !hasClientPlugin && !this.plugin.options.client.importPath) await this.addFile({
+		options,
+		dependencies: [pluginTsName, pluginZodName],
+		hooks: { "kubb:plugin:setup"(ctx) {
+			const resolver = userResolver ? {
+				...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
+				},
+				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 = 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"),
-				sources: [{
+				sources: [ast.createSource({
 					name: "fetch",
-					value: this.plugin.options.client.client === "fetch" ? source$1 : source,
+					nodes: [ast.createText(clientName === "fetch" ? source$1 : source)],
 					isExportable: true,
 					isIndexable: true
-				}],
-				imports: [],
-				exports: []
+				})]
 			});
-			if (!hasClientPlugin) await this.addFile({
+			if (!hasClientPlugin) ctx.injectFile({
 				baseName: "config.ts",
 				path: path.resolve(root, ".kubb/config.ts"),
-				sources: [{
+				sources: [ast.createSource({
 					name: "config",
-					value: source$2,
+					nodes: [ast.createText(source$2)],
 					isExportable: false,
 					isIndexable: false
-				}],
-				imports: [],
-				exports: []
+				})]
 			});
-			const files = await new OperationGenerator(this.plugin.options, {
-				fabric: this.fabric,
-				oas,
-				driver: this.driver,
-				events: this.events,
-				plugin: this.plugin,
-				contentType,
-				exclude,
-				include,
-				override,
-				mode
-			}).build(...generators);
-			await this.upsertFile(...files);
-			const barrelFiles = await getBarrelFiles(this.fabric.files, {
-				type: output.barrelType ?? "named",
-				root,
-				output,
-				meta: { pluginName: this.plugin.name }
-			});
-			await this.upsertFile(...barrelFiles);
-		}
+		} }
 	};
 });
 //#endregion
-export { pluginMcp, pluginMcpName };
+export { McpHandler, Server, pluginMcp as default, pluginMcp, mcpGenerator, pluginMcpName, resolverMcp, serverGenerator };
 
 //# sourceMappingURL=index.js.map