@kubb/plugin-mcp 5.0.0-alpha.27 → 5.0.0-alpha.29

package/dist/index.cjs

@@ -1,75 +1,1033 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_Server = require("./Server-EjbvNRYy.cjs");
-const require_generators = require("./generators-CzP7VKQw.cjs");
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
 let node_path = require("node:path");
-node_path = require_Server.__toESM(node_path);
+node_path = __toESM(node_path);
+let _kubb_ast = require("@kubb/ast");
+let _kubb_plugin_ts = require("@kubb/plugin-ts");
+let _kubb_react_fabric = require("@kubb/react-fabric");
+let _kubb_react_fabric_jsx_runtime = require("@kubb/react-fabric/jsx-runtime");
 let _kubb_core = require("@kubb/core");
+let _kubb_plugin_zod = require("@kubb/plugin-zod");
 let _kubb_plugin_client = require("@kubb/plugin-client");
 let _kubb_plugin_client_templates_clients_axios_source = require("@kubb/plugin-client/templates/clients/axios.source");
 let _kubb_plugin_client_templates_clients_fetch_source = require("@kubb/plugin-client/templates/clients/fetch.source");
 let _kubb_plugin_client_templates_config_source = require("@kubb/plugin-client/templates/config.source");
-let _kubb_plugin_oas = require("@kubb/plugin-oas");
-let _kubb_plugin_ts = require("@kubb/plugin-ts");
-let _kubb_plugin_zod = require("@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
+/**
+* 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) {
+	try {
+		new Function(`var ${name}`);
+	} catch {
+		return false;
+	}
+	return true;
+}
+//#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.getParams();
+	}
+	#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.getParams()
+		};
+		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}').getParams()
+	* // { petId: 'petId', tagId: 'tagId' }
+	* ```
+	*/
+	getParams(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 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;
+	}
+}
+/**
+* Render a group param value — either a group schema name directly (kubbV4),
+* or compose individual schemas into `z.object({ ... })` (v5).
+*/
+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 [
+		node.description && `@description ${node.description}`,
+		node.summary && `@summary ${node.summary}`,
+		node.deprecated && "@deprecated",
+		`{@link ${node.path.replaceAll("{", ":").replaceAll("}", "")}}`
+	].filter((x) => Boolean(x));
+}
+/**
+* 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;
+}
+/**
+* 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 "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/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 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
+function McpHandler({ name, node, resolver, baseURL, dataReturnType, paramsCasing }) {
+	const urlPath = new URLPath(node.path);
+	const contentType = node.requestBody?.contentType;
+	const isFormData = contentType === "multipart/form-data";
+	const casedParams = (0, _kubb_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?.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 = (0, _kubb_ast.createOperationParams)(node, {
+		paramsType: "object",
+		pathParamsType: "inline",
+		resolver,
+		paramsCasing
+	});
+	const paramsSignature = declarationPrinter.print(paramsNode) ?? "";
+	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 fetchConfig = [];
+	fetchConfig.push(`method: ${JSON.stringify(node.method.toUpperCase())}`);
+	fetchConfig.push(`url: ${urlPath.template}`);
+	if (baseURL) fetchConfig.push(`baseURL: \`${baseURL}\``);
+	if (queryParams.length) fetchConfig.push(queryParamsMapping ? "params: mappedParams" : "params");
+	if (requestName) fetchConfig.push(`data: ${isFormData ? "formData as FormData" : "requestData"}`);
+	if (headers.length) fetchConfig.push(`headers: { ${headers.join(", ")} }`);
+	const callToolResult = dataReturnType === "data" ? `return {
+            content: [
+              {
+                type: 'text',
+                text: JSON.stringify(res.data)
+              }
+            ],
+            structuredContent: { data: res.data }
+           }` : `return {
+            content: [
+              {
+                type: 'text',
+                text: JSON.stringify(res)
+              }
+            ],
+            structuredContent: { data: res.data }
+           }`;
+	return /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsxs)(_kubb_react_fabric.Function, {
+			name,
+			async: true,
+			export: true,
+			params: paramsSignature,
+			JSDoc: { comments: getComments(node) },
+			returnType: "Promise<CallToolResult>",
+			children: [
+				"",
+				/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)("br", {}),
+				/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)("br", {}),
+				pathParamsMapping && Object.entries(pathParamsMapping).filter(([originalName, camelCaseName]) => originalName !== camelCaseName && isValidVarName(originalName)).map(([originalName, camelCaseName]) => `const ${originalName} = ${camelCaseName}`).join("\n"),
+				pathParamsMapping && /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsxs)(_kubb_react_fabric_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)("br", {}), /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)("br", {})] }),
+				queryParamsMapping && queryParams.length > 0 && /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsxs)(_kubb_react_fabric_jsx_runtime.Fragment, { children: [
+					buildRemappingCode(queryParamsMapping, "mappedParams", "params"),
+					/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)("br", {}),
+					/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)("br", {})
+				] }),
+				headerParamsMapping && headerParams.length > 0 && /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsxs)(_kubb_react_fabric_jsx_runtime.Fragment, { children: [
+					buildRemappingCode(headerParamsMapping, "mappedHeaders", "headers"),
+					/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)("br", {}),
+					/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)("br", {})
+				] }),
+				requestName && "const requestData = data",
+				/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)("br", {}),
+				isFormData && requestName && "const formData = buildFormData(requestData)",
+				/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)("br", {}),
+				`const res = await fetch<${generics.join(", ")}>({ ${fetchConfig.join(", ")} })`,
+				/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)("br", {}),
+				callToolResult
+			]
+		})
+	});
+}
+//#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_react_fabric_jsx_runtime.jsxs)(_kubb_react_fabric.File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: [
+			/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.Const, {
+				name: "server",
+				export: true,
+				children: `
+          new McpServer({
+  name: '${serverName}',
+  version: '${serverVersion}',
+})
+          `
+			}),
+			operations.map(({ tool, mcp, zod, node }) => {
+				const pathParams = (0, _kubb_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 ? (0, _kubb_ast.createFunctionParameters)({ params: [(0, _kubb_ast.createParameterGroup)({ properties: entries.map((e) => (0, _kubb_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}) => {
+  return ${mcp.name}(${destructured})
+})
+          `;
+				return `
+server.registerTool(${JSON.stringify(tool.name)}, {
+  ${config},
+}, async () => {
+  return ${mcp.name}()
+})
+          `;
+			}).filter(Boolean),
+			/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.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 = (0, _kubb_core.defineGenerator)({
+	name: "mcp",
+	type: "react",
+	Operation({ node, options, config, driver, resolver, plugin }) {
+		const { output, client, paramsCasing, group } = options;
+		const root = node_path.default.resolve(config.root, config.output.path);
+		const pluginTs = driver.getPlugin(_kubb_plugin_ts.pluginTsName);
+		if (!pluginTs?.resolver) return null;
+		const transformedNode = plugin.transformer ? (0, _kubb_ast.transform)(node, plugin.transformer) : node;
+		const casedParams = (0, _kubb_ast.caseParams)(transformedNode.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) => pluginTs.resolver.resolvePathParamsName(transformedNode, p)),
+			...queryParams.map((p) => pluginTs.resolver.resolveQueryParamsName(transformedNode, p)),
+			...headerParams.map((p) => pluginTs.resolver.resolveHeaderParamsName(transformedNode, p)),
+			transformedNode.requestBody?.schema ? pluginTs.resolver.resolveDataName(transformedNode) : void 0,
+			pluginTs.resolver.resolveResponseName(transformedNode),
+			...transformedNode.responses.filter((r) => Number(r.statusCode) >= 400).map((r) => pluginTs.resolver.resolveResponseStatusName(transformedNode, r.statusCode))
+		].filter(Boolean);
+		const meta = {
+			name: resolver.resolveName(transformedNode.operationId),
+			file: resolver.resolveFile({
+				name: transformedNode.operationId,
+				extname: ".ts",
+				tag: transformedNode.tags[0] ?? "default",
+				path: transformedNode.path
+			}, {
+				root,
+				output,
+				group
+			}),
+			fileTs: pluginTs.resolver.resolveFile({
+				name: transformedNode.operationId,
+				extname: ".ts",
+				tag: transformedNode.tags[0] ?? "default",
+				path: transformedNode.path
+			}, {
+				root,
+				output: pluginTs.options?.output ?? output,
+				group: pluginTs.options?.group
+			})
+		};
+		return /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsxs)(_kubb_react_fabric.File, {
+			baseName: meta.file.baseName,
+			path: meta.file.path,
+			meta: meta.file.meta,
+			children: [
+				meta.fileTs && importedTypeNames.length > 0 && /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Import, {
+					name: Array.from(new Set(importedTypeNames)).sort(),
+					root: meta.file.path,
+					path: meta.fileTs.path,
+					isTypeOnly: true
+				}),
+				/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Import, {
+					name: ["CallToolResult"],
+					path: "@modelcontextprotocol/sdk/types",
+					isTypeOnly: true
+				}),
+				/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Import, {
+					name: ["buildFormData"],
+					root: meta.file.path,
+					path: node_path.default.resolve(root, ".kubb/config.ts")
+				}),
+				client.importPath ? /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsxs)(_kubb_react_fabric_jsx_runtime.Fragment, { children: [
+					/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Import, {
+						name: [
+							"Client",
+							"RequestConfig",
+							"ResponseErrorConfig"
+						],
+						path: client.importPath,
+						isTypeOnly: true
+					}),
+					/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Import, {
+						name: "fetch",
+						path: client.importPath
+					}),
+					client.dataReturnType === "full" && /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Import, {
+						name: ["ResponseConfig"],
+						path: client.importPath,
+						isTypeOnly: true
+					})
+				] }) : /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsxs)(_kubb_react_fabric_jsx_runtime.Fragment, { children: [
+					/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Import, {
+						name: [
+							"Client",
+							"RequestConfig",
+							"ResponseErrorConfig"
+						],
+						root: meta.file.path,
+						path: node_path.default.resolve(root, ".kubb/fetch.ts"),
+						isTypeOnly: true
+					}),
+					/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Import, {
+						name: ["fetch"],
+						root: meta.file.path,
+						path: node_path.default.resolve(root, ".kubb/fetch.ts")
+					}),
+					client.dataReturnType === "full" && /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Import, {
+						name: ["ResponseConfig"],
+						root: meta.file.path,
+						path: node_path.default.resolve(root, ".kubb/fetch.ts"),
+						isTypeOnly: true
+					})
+				] }),
+				/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(McpHandler, {
+					name: meta.name,
+					node: transformedNode,
+					resolver: pluginTs.resolver,
+					baseURL: client.baseURL,
+					dataReturnType: client.dataReturnType || "data",
+					paramsCasing
+				})
+			]
+		});
+	}
+});
+//#endregion
+//#region src/generators/serverGenerator.tsx
+/**
+* Default server generator for `compatibilityPreset: 'default'` (v5).
+*
+* 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 = (0, _kubb_core.defineGenerator)({
+	name: "operations",
+	type: "react",
+	Operations({ nodes, adapter, options, config, driver, resolver, plugin }) {
+		const { output, paramsCasing, group } = options;
+		const root = node_path.default.resolve(config.root, config.output.path);
+		const pluginZod = driver.getPlugin(_kubb_plugin_zod.pluginZodName);
+		if (!pluginZod?.resolver) return;
+		const name = "server";
+		const serverFile = {
+			baseName: "server.ts",
+			path: node_path.default.resolve(root, output.path, "server.ts"),
+			meta: { pluginName: plugin.name }
+		};
+		const jsonFile = {
+			baseName: ".mcp.json",
+			path: node_path.default.resolve(root, output.path, ".mcp.json"),
+			meta: { pluginName: plugin.name }
+		};
+		const operationsMapped = nodes.map((node) => {
+			const transformedNode = plugin.transformer ? (0, _kubb_ast.transform)(node, plugin.transformer) : node;
+			const casedParams = (0, _kubb_ast.caseParams)(transformedNode.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 mcpFile = resolver.resolveFile({
+				name: transformedNode.operationId,
+				extname: ".ts",
+				tag: transformedNode.tags[0] ?? "default",
+				path: transformedNode.path
+			}, {
+				root,
+				output,
+				group
+			});
+			const zodFile = pluginZod.resolver.resolveFile({
+				name: transformedNode.operationId,
+				extname: ".ts",
+				tag: transformedNode.tags[0] ?? "default",
+				path: transformedNode.path
+			}, {
+				root,
+				output: pluginZod.options?.output ?? output,
+				group: pluginZod.options?.group
+			});
+			const requestName = transformedNode.requestBody?.schema ? pluginZod.resolver.resolveDataName(transformedNode) : void 0;
+			const successStatus = findSuccessStatusCode(transformedNode.responses);
+			const responseName = successStatus ? pluginZod.resolver.resolveResponseStatusName(transformedNode, successStatus) : void 0;
+			const resolveParams = (params) => params.map((p) => ({
+				name: p.name,
+				schemaName: pluginZod.resolver.resolveParamName(transformedNode, p)
+			}));
+			return {
+				tool: {
+					name: transformedNode.operationId,
+					title: transformedNode.summary || void 0,
+					description: transformedNode.description || `Make a ${transformedNode.method.toUpperCase()} request to ${transformedNode.path}`
+				},
+				mcp: {
+					name: resolver.resolveName(transformedNode.operationId),
+					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: transformedNode
+			};
+		});
+		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(Boolean);
+			const uniqueNames = [...new Set(zodNames)].sort();
+			return [/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Import, {
+				name: [mcp.name],
+				root: serverFile.path,
+				path: mcp.file.path
+			}, mcp.name), uniqueNames.length > 0 && /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Import, {
+				name: uniqueNames,
+				root: serverFile.path,
+				path: zod.file.path
+			}, `zod-${mcp.name}`)].filter(Boolean);
+		});
+		return /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsxs)(_kubb_react_fabric_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsxs)(_kubb_react_fabric.File, {
+			baseName: serverFile.baseName,
+			path: serverFile.path,
+			meta: serverFile.meta,
+			banner: resolver.resolveBanner(adapter.rootNode, {
+				output,
+				config
+			}),
+			footer: resolver.resolveFooter(adapter.rootNode, {
+				output,
+				config
+			}),
+			children: [
+				/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Import, {
+					name: ["McpServer"],
+					path: "@modelcontextprotocol/sdk/server/mcp"
+				}),
+				/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Import, {
+					name: ["z"],
+					path: "zod"
+				}),
+				/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Import, {
+					name: ["StdioServerTransport"],
+					path: "@modelcontextprotocol/sdk/server/stdio"
+				}),
+				imports,
+				/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(Server, {
+					name,
+					serverName: adapter.rootNode?.meta?.title ?? "server",
+					serverVersion: adapter.rootNode?.meta?.version ?? "0.0.0",
+					paramsCasing,
+					operations: operationsMapped
+				})
+			]
+		}), /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File, {
+			baseName: jsonFile.baseName,
+			path: jsonFile.path,
+			meta: jsonFile.meta,
+			children: /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Source, {
+				name,
+				children: `
+          {
+            "mcpServers": {
+              "${adapter.rootNode?.meta?.title || "server"}": {
+                "type": "stdio",
+                "command": "npx",
+                "args": ["tsx", "${node_path.default.relative(node_path.default.dirname(jsonFile.path), serverFile.path)}"]
+              }
+            }
+          }
+          `
+			})
+		})] });
+	}
+});
+//#endregion
+//#region src/generators/serverGeneratorLegacy.tsx
+/**
+* Legacy server generator for `compatibilityPreset: 'kubbV4'`.
+*
+* Uses grouped zod schemas for query/header params (e.g. `createPetsQueryParamsSchema`)
+* and `resolveResponseName` for the combined response schema.
+* Path params are always rendered inline (no named imports).
+*/
+const serverGeneratorLegacy = (0, _kubb_core.defineGenerator)({
+	name: "operations",
+	type: "react",
+	Operations({ nodes, adapter, options, config, driver, resolver, plugin }) {
+		const { output, paramsCasing, group } = options;
+		const root = node_path.default.resolve(config.root, config.output.path);
+		const pluginZod = driver.getPlugin(_kubb_plugin_zod.pluginZodName);
+		if (!pluginZod?.resolver) return;
+		const name = "server";
+		const serverFile = {
+			baseName: "server.ts",
+			path: node_path.default.resolve(root, output.path, "server.ts"),
+			meta: { pluginName: plugin.name }
+		};
+		const jsonFile = {
+			baseName: ".mcp.json",
+			path: node_path.default.resolve(root, output.path, ".mcp.json"),
+			meta: { pluginName: plugin.name }
+		};
+		const operationsMapped = nodes.map((node) => {
+			const transformedNode = plugin.transformer ? (0, _kubb_ast.transform)(node, plugin.transformer) : node;
+			const casedParams = (0, _kubb_ast.caseParams)(transformedNode.parameters, paramsCasing);
+			const queryParams = casedParams.filter((p) => p.in === "query");
+			const headerParams = casedParams.filter((p) => p.in === "header");
+			const mcpFile = resolver.resolveFile({
+				name: transformedNode.operationId,
+				extname: ".ts",
+				tag: transformedNode.tags[0] ?? "default",
+				path: transformedNode.path
+			}, {
+				root,
+				output,
+				group
+			});
+			const zodFile = pluginZod?.resolver.resolveFile({
+				name: transformedNode.operationId,
+				extname: ".ts",
+				tag: transformedNode.tags[0] ?? "default",
+				path: transformedNode.path
+			}, {
+				root,
+				output: pluginZod?.options?.output ?? output,
+				group: pluginZod?.options?.group
+			});
+			const requestName = transformedNode.requestBody?.schema ? pluginZod?.resolver.resolveDataName(transformedNode) : void 0;
+			const responseName = pluginZod?.resolver.resolveResponseName(transformedNode);
+			const zodQueryParams = queryParams.length ? pluginZod?.resolver.resolveQueryParamsName(transformedNode, queryParams[0]) : void 0;
+			const zodHeaderParams = headerParams.length ? pluginZod?.resolver.resolveHeaderParamsName(transformedNode, headerParams[0]) : void 0;
+			return {
+				tool: {
+					name: transformedNode.operationId,
+					title: transformedNode.summary || void 0,
+					description: transformedNode.description || `Make a ${transformedNode.method.toUpperCase()} request to ${transformedNode.path}`
+				},
+				mcp: {
+					name: resolver.resolveName(transformedNode.operationId),
+					file: mcpFile
+				},
+				zod: {
+					pathParams: [],
+					queryParams: zodQueryParams,
+					headerParams: zodHeaderParams,
+					requestName,
+					responseName,
+					file: zodFile
+				},
+				node: transformedNode
+			};
+		});
+		const imports = operationsMapped.flatMap(({ mcp, zod }) => {
+			const zodNames = [
+				zod.queryParams,
+				zod.headerParams,
+				zod.requestName,
+				zod.responseName
+			].filter(Boolean);
+			return [/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Import, {
+				name: [mcp.name],
+				root: serverFile.path,
+				path: mcp.file.path
+			}, mcp.name), zod.file && zodNames.length > 0 && /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Import, {
+				name: zodNames.sort(),
+				root: serverFile.path,
+				path: zod.file.path
+			}, `zod-${mcp.name}`)].filter(Boolean);
+		});
+		return /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsxs)(_kubb_react_fabric_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsxs)(_kubb_react_fabric.File, {
+			baseName: serverFile.baseName,
+			path: serverFile.path,
+			meta: serverFile.meta,
+			banner: resolver.resolveBanner(adapter.rootNode, {
+				output,
+				config
+			}),
+			footer: resolver.resolveFooter(adapter.rootNode, {
+				output,
+				config
+			}),
+			children: [
+				/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Import, {
+					name: ["McpServer"],
+					path: "@modelcontextprotocol/sdk/server/mcp"
+				}),
+				/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Import, {
+					name: ["z"],
+					path: "zod"
+				}),
+				/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Import, {
+					name: ["StdioServerTransport"],
+					path: "@modelcontextprotocol/sdk/server/stdio"
+				}),
+				imports,
+				/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(Server, {
+					name,
+					serverName: adapter.rootNode?.meta?.title ?? "server",
+					serverVersion: adapter.document?.openapi ?? adapter.rootNode?.meta?.version ?? "0.0.0",
+					paramsCasing,
+					operations: operationsMapped
+				})
+			]
+		}), /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File, {
+			baseName: jsonFile.baseName,
+			path: jsonFile.path,
+			meta: jsonFile.meta,
+			children: /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Source, {
+				name,
+				children: `
+          {
+            "mcpServers": {
+              "${adapter.rootNode?.meta?.title || "server"}": {
+                "type": "stdio",
+                "command": "npx",
+                "args": ["tsx", "${node_path.default.relative(node_path.default.dirname(jsonFile.path), serverFile.path)}"]
+              }
+            }
+          }
+          `
+			})
+		})] });
+	}
+});
+//#endregion
+//#region src/resolvers/resolverMcp.ts
+/**
+* Resolver for `@kubb/plugin-mcp` that provides the default naming
+* and path-resolution helpers used by the plugin.
+*
+* @example
+* ```ts
+* import { resolverMcp } from '@kubb/plugin-mcp'
+*
+* resolverMcp.default('addPet', 'function') // -> 'addPetHandler'
+* resolverMcp.resolveName('show pet by id')  // -> 'showPetByIdHandler'
+* ```
+*/
+const resolverMcp = (0, _kubb_core.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");
+	}
+}));
+//#endregion
+//#region src/presets.ts
+/**
+* Built-in preset registry for `@kubb/plugin-mcp`.
+*
+* - `default` — v5 naming with individual zod schemas and per-status responses.
+* - `kubbV4`  — legacy naming with grouped zod schemas and combined responses.
+*/
+const presets = (0, _kubb_core.definePresets)({
+	default: {
+		name: "default",
+		resolver: resolverMcp,
+		generators: [mcpGenerator, serverGenerator]
+	},
+	kubbV4: {
+		name: "kubbV4",
+		resolver: resolverMcp,
+		generators: [mcpGenerator, serverGeneratorLegacy]
+	}
+});
+//#endregion
 //#region src/plugin.ts
 const pluginMcpName = "plugin-mcp";
 const pluginMcp = (0, _kubb_core.createPlugin)((options) => {
 	const { output = {
 		path: "mcp",
 		barrelType: "named"
-	}, group, exclude = [], include, override = [], transformers = {}, generators = [require_generators.mcpGenerator, require_generators.serverGenerator].filter(Boolean), contentType, paramsCasing, client } = options;
+	}, group, exclude = [], include, override = [], paramsCasing, client, compatibilityPreset = "default", 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 preset = (0, _kubb_core.getPreset)({
+		preset: compatibilityPreset,
+		presets,
+		resolver: userResolver,
+		transformer: userTransformer,
+		generators: userGenerators
+	});
 	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
-			}
+		get resolver() {
+			return preset.resolver;
 		},
-		pre: [
-			_kubb_plugin_oas.pluginOasName,
-			_kubb_plugin_ts.pluginTsName,
-			_kubb_plugin_zod.pluginZodName
-		].filter(Boolean),
-		resolvePath(baseName, pathMode, options) {
-			const root = node_path.default.resolve(this.config.root, this.config.output.path);
-			if ((pathMode ?? (0, _kubb_core.getMode)(node_path.default.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 node_path.default.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 `${require_Server.camelCase(ctx.group)}Requests`;
-				};
-				return node_path.default.resolve(root, output.path, groupName({ group: group.type === "path" ? options.group.path : options.group.tag }), baseName);
-			}
-			return node_path.default.resolve(root, output.path, baseName);
+		get transformer() {
+			return preset.transformer;
 		},
-		resolveName(name, type) {
-			const resolvedName = require_Server.camelCase(name, { isFile: type === "file" });
-			if (type) return transformers?.name?.(resolvedName, type) || resolvedName;
-			return resolvedName;
+		get options() {
+			return {
+				output,
+				group: group ? {
+					...group,
+					name: group.name ? group.name : (ctx) => {
+						if (group.type === "path") return `${ctx.group.split("/")[1]}`;
+						return `${camelCase(ctx.group)}Requests`;
+					}
+				} : void 0,
+				paramsCasing,
+				client: {
+					client: clientName,
+					clientType: client?.clientType ?? "function",
+					importPath: clientImportPath,
+					dataReturnType: client?.dataReturnType ?? "data",
+					bundle: client?.bundle,
+					baseURL: client?.baseURL,
+					paramsCasing: client?.paramsCasing
+				},
+				resolver: preset.resolver
+			};
 		},
+		pre: [_kubb_plugin_ts.pluginTsName, _kubb_plugin_zod.pluginZodName].filter(Boolean),
 		async install() {
-			const root = node_path.default.resolve(this.config.root, this.config.output.path);
-			const mode = (0, _kubb_core.getMode)(node_path.default.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.getPlugin(_kubb_plugin_client.pluginClientName);
+			const { config, fabric, plugin, adapter, rootNode, driver } = this;
+			const root = node_path.default.resolve(config.root, config.output.path);
+			const resolver = preset.resolver;
+			if (!adapter) throw new Error("Plugin cannot work without adapter being set");
+			const baseURL = adapter.rootNode?.meta?.baseURL;
+			if (baseURL) this.plugin.options.client.baseURL = this.plugin.options.client.baseURL || baseURL;
+			const hasClientPlugin = !!driver.getPlugin(_kubb_plugin_client.pluginClientName);
 			if (this.plugin.options.client.bundle && !hasClientPlugin && !this.plugin.options.client.importPath) await this.addFile({
 				baseName: "fetch.ts",
 				path: node_path.default.resolve(root, ".kubb/fetch.ts"),
@@ -94,19 +1052,35 @@ const pluginMcp = (0, _kubb_core.createPlugin)((options) => {
 				imports: [],
 				exports: []
 			});
-			const files = await new _kubb_plugin_oas.OperationGenerator(this.plugin.options, {
-				fabric: this.fabric,
-				oas,
-				driver: this.driver,
-				events: this.events,
-				plugin: this.plugin,
-				contentType,
+			const collectedOperations = [];
+			const generatorContext = {
+				generators: preset.generators,
+				plugin,
+				resolver,
 				exclude,
 				include,
 				override,
-				mode
-			}).build(...generators);
-			await this.upsertFile(...files);
+				fabric,
+				adapter,
+				config,
+				driver
+			};
+			await (0, _kubb_ast.walk)(rootNode, {
+				depth: "shallow",
+				async schema(schemaNode) {
+					await (0, _kubb_core.runGeneratorSchema)(schemaNode, generatorContext);
+				},
+				async operation(operationNode) {
+					if (resolver.resolveOptions(operationNode, {
+						options: plugin.options,
+						exclude,
+						include,
+						override
+					}) !== null) collectedOperations.push(operationNode);
+					await (0, _kubb_core.runGeneratorOperation)(operationNode, generatorContext);
+				}
+			});
+			await (0, _kubb_core.runGeneratorOperations)(collectedOperations, generatorContext);
 			const barrelFiles = await (0, _kubb_core.getBarrelFiles)(this.fabric.files, {
 				type: output.barrelType ?? "named",
 				root,
@@ -118,7 +1092,13 @@ const pluginMcp = (0, _kubb_core.createPlugin)((options) => {
 	};
 });
 //#endregion
+exports.McpHandler = McpHandler;
+exports.Server = Server;
+exports.mcpGenerator = mcpGenerator;
 exports.pluginMcp = pluginMcp;
 exports.pluginMcpName = pluginMcpName;
+exports.resolverMcp = resolverMcp;
+exports.serverGenerator = serverGenerator;
+exports.serverGeneratorLegacy = serverGeneratorLegacy;
 
 //# sourceMappingURL=index.cjs.map