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

package/dist/index.js

@@ -1,122 +1,847 @@
-import "./chunk--u3MIqq1.js";
-import { n as camelCase } from "./Server-KWLMg0Lm.js";
-import { n as mcpGenerator, t as serverGenerator } from "./generators-TtEOkDB1.js";
+import "./rolldown-runtime-C0LytTxp.js";
+import { Resolver, Url, ast, createResolver, defineGenerator, definePlugin } from "kubb/kit";
 import path from "node:path";
-import { createPlugin, getBarrelFiles, getMode } from "@kubb/core";
-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 { Const, File, Function, jsxRenderer } from "kubb/jsx";
+import { Fragment, jsx, jsxs } from "kubb/jsx/jsx-runtime";
+import { createFunctionParameter, createFunctionParameters, createObjectBindingPattern, functionPrinter, pluginTsName } from "@kubb/plugin-ts";
 import { pluginZodName } from "@kubb/plugin-zod";
+//#region ../../internals/shared/src/params.ts
+/**
+* Drops parameters that share the same name, keeping the first.
+*
+* A malformed spec can declare the same parameter name twice within one `in` location. Both would
+* resolve to the same output property, so emitting both would yield an object type with a duplicate
+* member, which TypeScript rejects. This is a defensive guard against that case, not a casing guard:
+* parameter names flow through unchanged, so no two distinct names ever collide here anymore.
+*/
+function dedupeParams(params) {
+	const seen = /* @__PURE__ */ new Set();
+	return params.filter((param) => {
+		if (seen.has(param.name)) return false;
+		seen.add(param.name);
+		return true;
+	});
+}
+//#endregion
+//#region ../../internals/shared/src/operation.ts
+/**
+* Builds the `ResolverFileParams` every operation generator passes to
+* `resolver.file`: a file named `name`, tagged by the operation's first
+* tag (or `'default'`), at the operation's path. Centralizes the entry object
+* that was repeated at dozens of call sites across the client and query plugins.
+*
+* @example
+* ```ts
+* resolver.file(operationFileEntry(node, node.operationId), { root, output, group })
+* ```
+*/
+function operationFileEntry(node, name, extname = ".ts") {
+	return {
+		name,
+		extname,
+		tag: node.tags[0] ?? "default",
+		path: node.path
+	};
+}
+function getOperationLink(node, link) {
+	if (!link) return null;
+	if (typeof link === "function") return link(node) ?? null;
+	return node.path ? `{@link ${Url.toPath(node.path)}}` : null;
+}
+/**
+* Derives the shared `ContentTypeInfo` shape from a list of content types, tracking whether several
+* are present and the union, default, and form-data flags the client uses to pick one.
+*/
+function buildContentTypeInfo(contentTypes) {
+	const isMultipleContentTypes = contentTypes.length > 1;
+	return {
+		contentTypes,
+		isMultipleContentTypes,
+		contentTypeUnion: isMultipleContentTypes ? contentTypes.map((ct) => JSON.stringify(ct)).join(" | ") : "",
+		defaultContentType: contentTypes[0] ?? "application/json",
+		hasFormData: contentTypes.some((ct) => ct === "multipart/form-data")
+	};
+}
+function getContentTypeInfo(node) {
+	return buildContentTypeInfo(node.requestBody?.content?.map((e) => e.contentType) ?? []);
+}
+/**
+* The request-body counterpart for the primary success response: the content types it documents and
+* whether several are present, so the client can let a caller pick which one to accept.
+*/
+function getResponseContentTypeInfo(node) {
+	return buildContentTypeInfo(getPrimarySuccessResponse(node)?.content?.map((e) => e.contentType) ?? []);
+}
+function buildRequestConfigType(node) {
+	const request = getContentTypeInfo(node);
+	const response = getResponseContentTypeInfo(node);
+	const configType = `Partial<Omit<RequestConfig, 'path' | 'query' | 'body' | 'headers' | 'url'>>`;
+	const members = [request.isMultipleContentTypes ? `request?: ${request.contentTypeUnion}` : null, response.isMultipleContentTypes ? `response?: ${response.contentTypeUnion}` : null].filter(Boolean);
+	return members.length ? `${configType} & { contentType?: { ${members.join("; ")} } }` : configType;
+}
+/**
+* Which of the grouped request options an operation carries.
+*/
+function getRequestGroups(node) {
+	const { path, query, header } = getOperationParameters(node);
+	return {
+		path: path.length > 0,
+		query: query.length > 0,
+		body: Boolean(node.requestBody?.content?.[0]?.schema),
+		headers: header.length > 0
+	};
+}
+/**
+* Resolves which grouped request options an operation carries together with whether each group
+* holds a required member. The grouped parameter stays optional only when nothing inside it is
+* required, matching the generated `RequestConfig` type.
+*/
+function getRequestGroupOptionality(node) {
+	const groups = getRequestGroups(node);
+	const { path, query, header } = getOperationParameters(node);
+	const hasRequiredPath = path.some((param) => param.required);
+	const hasRequiredQuery = query.some((param) => param.required);
+	const hasRequiredHeader = header.some((param) => param.required);
+	return {
+		groups,
+		hasRequiredPath,
+		hasRequiredQuery,
+		hasRequiredHeader,
+		isOptional: !hasRequiredPath && !hasRequiredQuery && !hasRequiredHeader && !groups.body
+	};
+}
+/**
+* Builds the grouped `{ path, query, body, headers }` parameter for a generated client
+* function, typed from the operation's `Options` (minus `url`). Only the groups the
+* operation actually has are destructured. The trailing `config` parameter carries the
+* runtime `RequestConfig` overrides plus `client`.
+*/
+function buildRequestParamsSignature(node, resolver, options = {}) {
+	const { isConfigurable = true } = options;
+	const { groups, isOptional } = getRequestGroupOptionality(node);
+	const names = [
+		"path",
+		"query",
+		"body",
+		"headers"
+	].filter((key) => groups[key]);
+	return {
+		signature: [names.length > 0 ? `{ ${names.join(", ")} }: ${resolver.response.options(node)}${isOptional ? " = {}" : ""}` : null, isConfigurable ? `config: ${buildRequestConfigType(node)} = {}` : null].filter(Boolean).join(", "),
+		groups
+	};
+}
+function buildOperationComments(node, options = {}) {
+	const { link = "pathTemplate", linkPosition = "afterDeprecated", splitLines = false } = options;
+	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) {
+	return {
+		path: dedupeParams(node.parameters.filter((param) => param.in === "path")),
+		query: dedupeParams(node.parameters.filter((param) => param.in === "query")),
+		header: dedupeParams(node.parameters.filter((param) => param.in === "header")),
+		cookie: dedupeParams(node.parameters.filter((param) => param.in === "cookie"))
+	};
+}
+function getStatusCodeNumber(statusCode) {
+	const code = Number(statusCode);
+	return Number.isNaN(code) ? null : code;
+}
+function isSuccessStatusCode(statusCode) {
+	const code = getStatusCodeNumber(statusCode);
+	return code !== null && code >= 200 && code < 300;
+}
+function getSuccessResponses(responses) {
+	return responses.filter((response) => isSuccessStatusCode(response.statusCode));
+}
+function getOperationSuccessResponses(node) {
+	return getSuccessResponses(node.responses);
+}
+function getPrimarySuccessResponse(node) {
+	return getOperationSuccessResponses(node)[0] ?? null;
+}
+function findSuccessStatusCode(responses) {
+	for (const response of responses) if (isSuccessStatusCode(response.statusCode)) return response.statusCode;
+	return null;
+}
+//#endregion
+//#region ../../internals/utils/src/casing.ts
+/**
+* Shared implementation for camelCase and PascalCase conversion.
+* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
+* and capitalizes each word according to `pascal`.
+*
+* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
+*/
+function toCamelOrPascal(text, pascal) {
+	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
+		if (word.length > 1 && word === word.toUpperCase()) return word;
+		return (i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()) + word.slice(1);
+	}).join("").replace(/[^a-zA-Z0-9]/g, "");
+}
+/**
+* Converts `text` to camelCase.
+*
+* @example Word boundaries
+* `camelCase('hello-world') // 'helloWorld'`
+*
+* @example With a prefix
+* `camelCase('tag', { prefix: 'create' }) // 'createTag'`
+*/
+function camelCase(text, { prefix = "", suffix = "" } = {}) {
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
+}
+//#endregion
+//#region ../../internals/shared/src/group.ts
+/**
+* Builds the `group` config a Kubb plugin passes to `ctx.setOptions`, applying the
+* shared default naming so every plugin groups output consistently:
+*
+* - `path` groups use the second path segment (`/pet/findByStatus` → `pet`).
+* - other groups use the camelCased group (`pet store` → `petStore`).
+*
+* A user-provided `group.name` always wins over the default namer, so callers stay in
+* control of their output folders. Returns `null` when grouping is disabled, matching the
+* per-plugin convention.
+*
+* @param group - The user-supplied group option, or `undefined` to disable grouping.
+*
+* @example
+* ```ts
+* createGroupConfig(group) // shared across every plugin
+* ```
+*/
+function createGroupConfig(group) {
+	if (!group) return null;
+	const defaultName = (ctx) => {
+		if (group.type === "path") return `${ctx.group.split("/")[1]}`;
+		return camelCase(ctx.group);
+	};
+	return {
+		...group,
+		name: group.name ? group.name : defaultName
+	};
+}
+//#endregion
+//#region src/components/McpHandler.tsx
+const requestGroupOrder = [
+	"path",
+	"query",
+	"headers",
+	"body"
+];
+function McpHandler({ name, clientName, node, resolver }) {
+	if (!ast.isHttpOperationNode(node)) return null;
+	const { signature, groups } = buildRequestParamsSignature(node, resolver, { isConfigurable: false });
+	const paramsSignature = [signature, "request: RequestHandlerExtra<ServerRequest, ServerNotification>"].filter(Boolean).join(", ");
+	const callArgs = requestGroupOrder.filter((key) => groups[key]);
+	const callConfig = callArgs.length ? `{ ${callArgs.join(", ")} }` : "{}";
+	return /* @__PURE__ */ 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: [
+				`const res = await ${clientName}(${callConfig})`,
+				/* @__PURE__ */ jsx("br", {}),
+				`return {
+  content: [
+    {
+      type: 'text',
+      text: JSON.stringify(res.data)
+    }
+  ],
+  structuredContent: { data: res.data }
+}`
+			]
+		})
+	});
+}
+//#endregion
+//#region src/utils.ts
+/**
+* Render a group param value — compose individual schemas into `z.object({ ... })`,
+* or use a schema name string directly.
+*/
+function zodGroupExpr(entry) {
+	if (typeof entry === "string") return entry;
+	return `z.object({ ${entry.map((p) => `${JSON.stringify(p.name)}: ${p.schemaName}`).join(", ")} })`;
+}
+/**
+* Convert a SchemaNode type to an inline Zod expression string.
+* Used as fallback when no named zod schema is available for a path parameter.
+*/
+function zodExprFromSchemaNode(schema) {
+	const baseExpr = (() => {
+		if (schema.type === "enum") {
+			const rawValues = schema.namedEnumValues?.length ? schema.namedEnumValues.map((v) => v.value) : (schema.enumValues ?? []).filter((v) => v !== null);
+			if (rawValues.length > 0 && rawValues.every((v) => typeof v === "string")) return `z.enum([${rawValues.map((v) => JSON.stringify(v)).join(", ")}])`;
+			if (rawValues.length > 0) {
+				const literals = rawValues.map((v) => `z.literal(${JSON.stringify(v)})`);
+				return literals.length === 1 ? literals[0] : `z.union([${literals.join(", ")}])`;
+			}
+			return "z.string()";
+		}
+		if (schema.type === "integer") return "z.coerce.number()";
+		if (schema.type === "number") return "z.number()";
+		if (schema.type === "boolean") return "z.boolean()";
+		if (schema.type === "array") return "z.array(z.unknown())";
+		return "z.string()";
+	})();
+	return schema.nullable ? `${baseExpr}.nullable()` : baseExpr;
+}
+//#endregion
+//#region src/components/Server.tsx
+const keysPrinter = functionPrinter({ mode: "call" });
+function Server({ name, serverName, serverVersion, operations }) {
+	const registrations = operations.map(({ tool, mcp, zod, node }) => {
+		const { path: pathParams } = getOperationParameters(node);
+		const entries = [];
+		if (pathParams.length) {
+			const pathFields = pathParams.map((p) => {
+				const zodParam = zod.pathParams.find((zp) => zp.name === p.name);
+				return `${JSON.stringify(p.name)}: ${zodParam ? zodParam.schemaName : zodExprFromSchemaNode(p.schema)}`;
+			}).join(", ");
+			entries.push({
+				key: "path",
+				value: `z.object({ ${pathFields} })`
+			});
+		}
+		if (zod.queryParams) entries.push({
+			key: "query",
+			value: zodGroupExpr(zod.queryParams)
+		});
+		if (zod.headerParams) entries.push({
+			key: "headers",
+			value: zodGroupExpr(zod.headerParams)
+		});
+		if (zod.requestName) entries.push({
+			key: "body",
+			value: zod.requestName
+		});
+		const paramsNode = entries.length ? createFunctionParameters({ params: [createFunctionParameter({
+			name: createObjectBindingPattern({ elements: entries.map((e) => ({ name: e.key })) }),
+			optional: false
+		})] }) : null;
+		const destructured = paramsNode ? keysPrinter.print(paramsNode) ?? "" : "";
+		const inputSchema = entries.length ? `{ ${entries.map((e) => `${e.key}: ${e.value}`).join(", ")} }` : null;
+		const outputSchema = zod.responseName;
+		const config = [
+			tool.title ? `title: ${JSON.stringify(tool.title)}` : null,
+			`description: ${JSON.stringify(tool.description)}`,
+			outputSchema ? `outputSchema: { data: ${outputSchema} }` : null
+		].filter(Boolean).join(",\n  ");
+		if (inputSchema) return `
+server.registerTool(${JSON.stringify(tool.name)}, {
+  ${config},
+  inputSchema: ${inputSchema},
+}, async (${destructured}, request) => {
+  return ${mcp.name}(${destructured}, request)
+})
+          `;
+		return `
+server.registerTool(${JSON.stringify(tool.name)}, {
+  ${config},
+}, async (request) => {
+  return ${mcp.name}(request)
+})
+          `;
+	}).filter(Boolean).join("\n");
+	return /* @__PURE__ */ jsxs(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: [
+			/* @__PURE__ */ jsx(Function, {
+				name: "getServer",
+				export: true,
+				children: `const server = new McpServer({
+  name: '${serverName}',
+  version: '${serverVersion}',
+})
+${registrations}
+return server`
+			}),
+			/* @__PURE__ */ jsx(Const, {
+				name: "server",
+				export: true,
+				children: "getServer()"
+			}),
+			/* @__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 ../../internals/client/src/resolveClient.ts
+/**
+* Resolves which client plugin a consumer (react-query, vue-query, swr, mcp) should call for an
+* operation, shared so the selection rules and diagnostics stay in one place.
+*
+* Every client runtime lives in a dedicated client plugin, so a consumer always calls a registered
+* contract client plugin (plugin-fetch or plugin-axios) and never emits its own inline client:
+*
+* - `contract` — a registered contract client plugin owns the `<op>` functions and the consumer
+*   imports and calls them.
+* - `error` — no client plugin is registered, several are registered without a selector, or the
+*   requested one is missing.
+*
+* The `client` string selects explicitly (`'fetch'` / `'axios'`); when it is unset a lone registered
+* contract client plugin is picked up automatically.
+*/
+const pluginFetchName = "plugin-fetch";
+const pluginAxiosName = "plugin-axios";
+const selectorToPlugin = {
+	fetch: pluginFetchName,
+	axios: pluginAxiosName
+};
+const contractPlugins = [pluginFetchName, pluginAxiosName];
+/**
+* Applies the `client` resolution rules. See the module comment for the strategy shape.
+*
+* @example
+* ```ts
+* resolveClient({ client: 'fetch', pluginNames: ['plugin-ts', 'plugin-fetch'] })
+* // { kind: 'contract', pluginName: 'plugin-fetch' }
+* ```
+*
+* @example
+* ```ts
+* resolveClient({ client: undefined, pluginNames: ['plugin-ts'] })
+* // { kind: 'error', message: 'No client plugin is registered…' }
+* ```
+*/
+function resolveClient(options) {
+	const { client, pluginNames } = options;
+	const has = (name) => pluginNames.includes(name);
+	if (client === "fetch" || client === "axios") {
+		const pluginName = selectorToPlugin[client];
+		if (!has(pluginName)) return {
+			kind: "error",
+			message: `\`client: '${client}'\` is set but \`@kubb/plugin-${client}\` is not registered in \`plugins\`. Add it, or drop \`client\` to use a different client plugin.`
+		};
+		return {
+			kind: "contract",
+			pluginName
+		};
+	}
+	const registered = contractPlugins.filter(has);
+	if (registered.length === 1) return {
+		kind: "contract",
+		pluginName: registered[0]
+	};
+	if (registered.length > 1) return {
+		kind: "error",
+		message: `Multiple client plugins are registered (${registered.map((name) => `\`@kubb/${name}\``).join(", ")}). Set \`client: 'fetch' | 'axios'\` to choose which client the hooks call, or register a single client plugin.`
+	};
+	return {
+		kind: "error",
+		message: "No client plugin is registered. Add `@kubb/plugin-axios` or `@kubb/plugin-fetch` to `plugins` so the generated code has an HTTP client to call."
+	};
+}
+/**
+* Resolves the contract client during a consumer plugin's setup hook. Extracts the plugin names
+* from the raw `plugins` config, applies {@link resolveClient}, and throws the diagnostic on a
+* misconfiguration so every consumer fails fast with the same message.
+*/
+function resolveContractClient(options) {
+	const { client, plugins = [] } = options;
+	const resolved = resolveClient({
+		client,
+		pluginNames: plugins.map((plugin) => plugin.name).filter((name) => Boolean(name))
+	});
+	if (resolved.kind === "error") throw new Error(resolved.message);
+	return resolved;
+}
+//#endregion
+//#region ../../internals/client/src/resolveClientOperation.ts
+/**
+* Resolves the contract client `<op>` a consumer (query hook, MCP handler) imports, by looking up
+* the registered contract client plugin's resolver and output. Works for any contract client plugin
+* (plugin-fetch or plugin-axios). Returns `null` when no contract plugin is in play (the inline
+* path). The plugin injects `.kubb/client.ts` at the global output root, the same path consumers
+* read `RequestConfig` / `ResponseErrorConfig` from.
+*/
+function resolveClientOperation(options) {
+	const { clientPlugin, driver, node, root, output } = options;
+	if (!clientPlugin) return null;
+	const resolver = driver.getResolver(clientPlugin.pluginName);
+	const plugin = driver.getPlugin(clientPlugin.pluginName);
+	const file = resolver.file({
+		...operationFileEntry(node, node.operationId),
+		root,
+		output: plugin?.options?.output ?? output,
+		group: plugin?.options?.group ?? void 0
+	});
+	return {
+		name: resolver.name(node.operationId),
+		path: file.path,
+		clientPath: path.resolve(root, ".kubb/client.ts")
+	};
+}
+//#endregion
+//#region src/generators/mcpGenerator.tsx
+/**
+* Built-in operation generator for `@kubb/plugin-mcp`. Emits one MCP tool
+* handler per OpenAPI operation. The handler takes the grouped `{ path, query,
+* headers, body }` config and forwards it to the registered client plugin's
+* (`@kubb/plugin-axios` / `@kubb/plugin-fetch`) `<op>` function.
+*/
+const mcpGenerator = defineGenerator({
+	name: "mcp",
+	renderer: jsxRenderer,
+	operation(node, ctx) {
+		if (!ast.isHttpOperationNode(node)) return null;
+		const { resolver, driver, root } = ctx;
+		const { output, client, group } = ctx.options;
+		const pluginTs = driver.getPlugin(pluginTsName);
+		if (!pluginTs) return null;
+		const tsResolver = driver.getResolver(pluginTsName);
+		const contractOp = resolveClientOperation({
+			clientPlugin: { pluginName: client.pluginName },
+			driver,
+			node,
+			root,
+			output
+		});
+		if (!contractOp) return null;
+		const optionsName = tsResolver.response.options(node);
+		const meta = {
+			name: resolver.handler.name(node),
+			file: resolver.file({
+				name: node.operationId,
+				extname: ".ts",
+				tag: node.tags[0] ?? "default",
+				path: node.path,
+				root,
+				output,
+				group: group ?? void 0
+			}),
+			fileTs: tsResolver.file({
+				name: node.operationId,
+				extname: ".ts",
+				tag: node.tags[0] ?? "default",
+				path: node.path,
+				root,
+				output: pluginTs.options?.output ?? output,
+				group: pluginTs.options?.group ?? void 0
+			})
+		};
+		return /* @__PURE__ */ jsxs(File, {
+			baseName: meta.file.baseName,
+			path: meta.file.path,
+			meta: meta.file.meta,
+			children: [
+				meta.fileTs && optionsName && /* @__PURE__ */ jsx(File.Import, {
+					name: [optionsName],
+					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: [contractOp.name],
+					root: meta.file.path,
+					path: contractOp.path
+				}),
+				/* @__PURE__ */ jsx(McpHandler, {
+					name: meta.name,
+					clientName: contractOp.name,
+					node,
+					resolver: tsResolver
+				})
+			]
+		});
+	}
+});
+//#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: jsxRenderer,
+	operations(nodes, ctx) {
+		const { config, resolver, plugin, driver, root } = ctx;
+		const { output, 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.filter(ast.isHttpOperationNode).map((node) => {
+			const { path: pathParams, query: queryParams, header: headerParams } = getOperationParameters(node);
+			const mcpFile = resolver.file({
+				name: node.operationId,
+				extname: ".ts",
+				tag: node.tags[0] ?? "default",
+				path: node.path,
+				root,
+				output,
+				group: group ?? void 0
+			});
+			const zodFile = zodResolver.file({
+				name: node.operationId,
+				extname: ".ts",
+				tag: node.tags[0] ?? "default",
+				path: node.path,
+				root,
+				output: pluginZod.options?.output ?? output,
+				group: pluginZod.options?.group ?? void 0
+			});
+			const requestName = node.requestBody?.content?.[0]?.schema ? zodResolver.response.body(node) : null;
+			const successStatus = findSuccessStatusCode(node.responses);
+			const responseName = successStatus ? zodResolver.response.status(node, successStatus) : null;
+			const resolveParams = (params) => params.map((p) => ({
+				name: p.name,
+				schemaName: zodResolver.param.name(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.handler.name(node),
+					file: mcpFile
+				},
+				zod: {
+					pathParams: resolveParams(pathParams),
+					queryParams: queryParams.length ? resolveParams(queryParams) : null,
+					headerParams: headerParams.length ? resolveParams(headerParams) : null,
+					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.default.banner(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: serverFile.path,
+					baseName: serverFile.baseName
+				}
+			}),
+			footer: resolver.default.footer(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: serverFile.path,
+					baseName: serverFile.baseName
+				}
+			}),
+			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: ctx.meta.title ?? "server",
+					serverVersion: ctx.meta.version ?? "0.0.0",
+					operations: operationsMapped
+				})
+			]
+		}), /* @__PURE__ */ jsx(File, {
+			baseName: jsonFile.baseName,
+			path: jsonFile.path,
+			meta: jsonFile.meta,
+			children: /* @__PURE__ */ jsx(File.Source, {
+				name,
+				children: `
+          {
+            "mcpServers": {
+              "${ctx.meta.title || "server"}": {
+                "type": "stdio",
+                "command": "npx",
+                "args": ["tsx", "${path.relative(path.dirname(jsonFile.path), serverFile.path)}"]
+              }
+            }
+          }
+          `
+			})
+		})] });
+	}
+});
+//#endregion
+//#region src/resolvers/resolverMcp.ts
+/**
+* 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`.
+*
+* @example Resolve a handler name
+* ```ts
+* import { resolverMcp } from '@kubb/plugin-mcp'
+*
+* resolverMcp.name('addPet') // 'addPetHandler'
+* ```
+*/
+const resolverMcp = createResolver({
+	pluginName: "plugin-mcp",
+	name(name) {
+		return camelCase(name, { suffix: "handler" });
+	},
+	handler: { name(node) {
+		return this.name(node.operationId);
+	} }
+});
+//#endregion
 //#region src/plugin.ts
+/**
+* Canonical plugin name for `@kubb/plugin-mcp`. Used for driver lookups and
+* cross-plugin dependency references.
+*/
 const pluginMcpName = "plugin-mcp";
-const pluginMcp = createPlugin((options) => {
+/**
+* Generates a Model Context Protocol (MCP) server from an OpenAPI spec. Every
+* operation becomes a typed MCP tool that AI assistants (Claude Desktop, Claude
+* Code, MCP-compatible clients) can call directly. Each handler calls a contract
+* client `<op>` from a registered `@kubb/plugin-axios` or `@kubb/plugin-fetch`.
+*
+* @example
+* ```ts
+* import { defineConfig } from 'kubb/config'
+* import { pluginTs } from '@kubb/plugin-ts'
+* import { pluginZod } from '@kubb/plugin-zod'
+* import { pluginMcp } from '@kubb/plugin-mcp'
+*
+* export default defineConfig({
+*   input: './petStore.yaml',
+*   output: { path: './src/gen' },
+*   plugins: [
+*     pluginTs(),
+*     pluginZod(),
+*     pluginMcp({
+*       output: { path: './mcp' },
+*       baseURL: 'https://petstore.swagger.io/v2',
+*     }),
+*   ],
+* })
+* ```
+*/
+const pluginMcp = definePlugin((options) => {
 	const { output = {
 		path: "mcp",
-		barrelType: "named"
-	}, group, exclude = [], include, override = [], transformers = {}, generators = [mcpGenerator, serverGenerator].filter(Boolean), contentType, paramsCasing, client } = options;
-	const clientName = client?.client ?? "axios";
-	const clientImportPath = client?.importPath ?? (!client?.bundle ? `@kubb/plugin-client/clients/${clientName}` : void 0);
+		barrel: { type: "named" }
+	}, group, exclude = [], include, override = [], client, resolver: userResolver, macros: userMacros } = options;
+	const groupConfig = createGroupConfig(group);
 	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({
-				baseName: "fetch.ts",
-				path: path.resolve(root, ".kubb/fetch.ts"),
-				sources: [{
-					name: "fetch",
-					value: this.plugin.options.client.client === "fetch" ? source$1 : source,
-					isExportable: true,
-					isIndexable: true
-				}],
-				imports: [],
-				exports: []
-			});
-			if (!hasClientPlugin) await this.addFile({
-				baseName: "config.ts",
-				path: path.resolve(root, ".kubb/config.ts"),
-				sources: [{
-					name: "config",
-					value: 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,
+		options,
+		dependencies: [pluginTsName, pluginZodName],
+		hooks: { "kubb:plugin:setup"(ctx) {
+			const resolver = userResolver ? Resolver.merge(resolverMcp, userResolver) : resolverMcp;
+			ctx.setOptions({
+				output,
 				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 }
+				group: groupConfig,
+				client: resolveContractClient({
+					client,
+					plugins: ctx.config.plugins
+				}),
+				resolver
 			});
-			await this.upsertFile(...barrelFiles);
-		}
+			ctx.setResolver(resolver);
+			if (userMacros?.length) ctx.setMacros(userMacros);
+			ctx.addGenerator(mcpGenerator, serverGenerator);
+		} }
 	};
 });
 //#endregion
-export { pluginMcp, pluginMcpName };
+export { McpHandler, Server, pluginMcp as default, pluginMcp, mcpGenerator, pluginMcpName, resolverMcp, serverGenerator };
 
 //# sourceMappingURL=index.js.map