@kubb/plugin-mcp 5.2.0-canary.20261014T071450 → 5.2.1

package/dist/index.js

@@ -1,28 +1,10 @@
 import "./rolldown-runtime-C0LytTxp.js";
-import { Resolver, Url, addGenerator, ast, createResolver, defineExtension, defineGenerator, setMacros, setResolver, useConfig } from "kubb/kit";
+import { Diagnostics, Resolver, Url, addGenerator, ast, createResolver, defineExtension, defineGenerator, setMacros, setResolver, useConfig } from "kubb/kit";
 import path, { posix } from "node:path";
 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
+import { pluginTsName } from "@kubb/plugin-ts";
 //#region ../../internals/shared/src/operation.ts
 /**
 * Builds the `ResolverFileParams` every operation generator passes to
@@ -92,12 +74,12 @@ function getContentTypeInfo(node) {
 function getResponseContentTypeInfo(node) {
 	return buildContentTypeInfo(getPrimarySuccessResponse(node)?.content?.map((e) => e.contentType) ?? []);
 }
+const requestConfigBaseType = `Partial<Omit<RequestConfig, 'path' | 'query' | 'body' | 'headers' | 'url'>>`;
 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;
+	return members.length ? `${requestConfigBaseType} & { contentType?: { ${members.join("; ")} } }` : requestConfigBaseType;
 }
 /**
 * Which of the grouped request options an operation carries.
@@ -177,11 +159,19 @@ const operationParameterGroupsByNode = /* @__PURE__ */ new WeakMap();
 function getOperationParameters(node) {
 	const cached = operationParameterGroupsByNode.get(node);
 	if (cached) return cached;
+	const group = (location) => {
+		const seen = /* @__PURE__ */ new Set();
+		return node.parameters.filter((param) => {
+			if (param.in !== location || seen.has(param.name)) return false;
+			seen.add(param.name);
+			return true;
+		});
+	};
 	const groups = {
-		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"))
+		path: group("path"),
+		query: group("query"),
+		header: group("header"),
+		cookie: group("cookie")
 	};
 	operationParameterGroupsByNode.set(node, groups);
 	return groups;
@@ -203,10 +193,6 @@ function getOperationSuccessResponses(node) {
 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
 /**
@@ -251,7 +237,6 @@ function toSlash(p) {
 * ```
 */
 function getRelativePath(rootDir, filePath) {
-	if (!rootDir || !filePath) throw new Error(`Root and file should be filled in when retrieving the relativePath, ${rootDir || ""} ${filePath || ""}`);
 	const relativePath = posix.relative(toSlash(rootDir), toSlash(filePath));
 	return relativePath.startsWith("../") ? relativePath : `./${relativePath}`;
 }
@@ -295,7 +280,6 @@ const requestGroupOrder = [
 	"body"
 ];
 function McpHandler({ name, clientName, node, resolver, returnType = "full" }) {
-	if (!ast.isHttpOperationNode(node)) return null;
 	const { signature, groups } = buildRequestParamsSignature(node, resolver, { isConfigurable: false });
 	const paramsSignature = [signature, "ctx: ServerContext"].filter(Boolean).join(", ");
 	const callConfig = `{ ${[
@@ -333,72 +317,31 @@ function McpHandler({ name, clientName, node, resolver, returnType = "full" }) {
 	});
 }
 //#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(", ")} })`;
-}
+//#region src/components/Server.tsx
 /**
-* Convert a SchemaNode type to an inline Zod expression string.
-* Used as fallback when no named zod schema is available for a path parameter.
+* Composes individual param schemas into `z.object({ ... })`.
 */
-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" });
+const zodObject = (params) => `z.object({ ${params.map((p) => `${JSON.stringify(p.name)}: ${p.schemaName}`).join(", ")} })`;
 function Server({ serverName, serverVersion, operations }) {
-	const registrations = operations.map(({ tool, mcp, zod, node }) => {
-		const { path: pathParams } = getOperationParameters(node);
+	const registrations = operations.map(({ tool, mcp, zod }) => {
 		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.pathParams.length) entries.push({
+			key: "path",
+			value: zodObject(zod.pathParams)
+		});
 		if (zod.queryParams) entries.push({
 			key: "query",
-			value: zodGroupExpr(zod.queryParams)
+			value: zodObject(zod.queryParams)
 		});
 		if (zod.headerParams) entries.push({
 			key: "headers",
-			value: zodGroupExpr(zod.headerParams)
+			value: zodObject(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 destructured = `{ ${entries.map((e) => e.key).join(", ")} }`;
 		const inputSchema = entries.length ? `z.object({ ${entries.map((e) => `${e.key}: ${e.value}`).join(", ")} })` : null;
 		const outputSchema = zod.responseName;
 		const config = [
@@ -470,23 +413,30 @@ return server`
 * 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 client plugin (plugin-fetch, plugin-axios, or plugin-client) 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, the
 *   requested one is missing, or `client` is not a known selector.
 *
-* The `client` string selects explicitly (`'fetch'` / `'axios'`); when it is unset a lone registered
-* contract client plugin is picked up automatically.
+* The `client` string selects explicitly (`'fetch'` / `'axios'` / `'client'`); when it is unset a
+* lone registered contract client plugin is picked up automatically.
 */
 const pluginFetchName = "plugin-fetch";
 const pluginAxiosName = "plugin-axios";
+const pluginClientName = "plugin-client";
 const selectorToPlugin = {
 	fetch: pluginFetchName,
-	axios: pluginAxiosName
+	axios: pluginAxiosName,
+	client: pluginClientName
 };
-const contractPlugins = [pluginFetchName, pluginAxiosName];
+const contractPlugins = [
+	pluginFetchName,
+	pluginAxiosName,
+	pluginClientName
+];
 /**
 * Applies the `client` resolution rules. See the module comment for the strategy shape.
 *
@@ -499,17 +449,19 @@ const contractPlugins = [pluginFetchName, pluginAxiosName];
 * @example
 * ```ts
 * resolveClient({ client: undefined, pluginNames: ['plugin-ts'] })
-* // { kind: 'error', message: 'No client plugin is registered…' }
+* // { kind: 'error', code: 'KUBB_MISSING_DEPENDENCY', message: 'No client plugin is registered.', help: 'Add …' }
 * ```
 */
 function resolveClient(options) {
 	const { client, pluginNames } = options;
 	const has = (name) => pluginNames.includes(name);
-	if (client === "fetch" || client === "axios") {
+	if (client === "fetch" || client === "axios" || client === "client") {
 		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.`
+			code: Diagnostics.code.missingDependency,
+			message: `\`client: '${client}'\` is set but \`@kubb/plugin-${client}\` is not registered in \`plugins\`.`,
+			help: `Add \`@kubb/plugin-${client}\` to \`plugins\`, or drop \`client\` to use a different client plugin.`
 		};
 		return {
 			kind: "contract",
@@ -518,7 +470,9 @@ function resolveClient(options) {
 	}
 	if (client !== void 0) return {
 		kind: "error",
-		message: `Option \`client\` is ${typeof client === "string" ? `'${client}'` : String(client)}, but it must be one of 'fetch', 'axios'. Drop \`client\` to use the registered client plugin.`
+		code: Diagnostics.code.invalidPluginOptions,
+		message: `Option \`client\` is ${typeof client === "string" ? `'${client}'` : String(client)}, but it must be one of 'fetch', 'axios', 'client'.`,
+		help: "Set `client` to one of those values, or drop it to use the registered client plugin."
 	};
 	const registered = contractPlugins.filter(has);
 	if (registered.length === 1) return {
@@ -527,36 +481,59 @@ function resolveClient(options) {
 	};
 	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.`
+		code: Diagnostics.code.invalidPluginOptions,
+		message: `Multiple client plugins are registered (${registered.map((name) => `\`@kubb/${name}\``).join(", ")}) and \`client\` is not set.`,
+		help: "Set `client: 'fetch' | 'axios' | 'client'` 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."
+		code: Diagnostics.code.missingDependency,
+		message: "No client plugin is registered.",
+		help: "Add `@kubb/plugin-fetch`, `@kubb/plugin-axios`, or `@kubb/plugin-client` 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.
+* Resolves the contract client during a consumer plugin's setup hook.
+* It extracts the plugin names from the raw `plugins` config and applies {@link resolveClient}.
+* On a misconfiguration it throws a config diagnostic tagged with `plugin`, so every consumer
+* fails fast with the same message.
 */
 function resolveContractClient(options) {
-	const { client, plugins = [] } = options;
+	const { plugin, 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);
+	if (resolved.kind === "error") {
+		const { code, message, help } = resolved;
+		throw new Diagnostics.Error({
+			code,
+			severity: "error",
+			message,
+			help,
+			location: { kind: "config" },
+			plugin
+		});
+	}
 	return resolved;
 }
 //#endregion
 //#region ../../internals/client/src/resolveClientOperation.ts
+function isRelativeImport(importPath) {
+	return importPath.startsWith(".");
+}
+function resolveImportPath(options) {
+	const { importPath, operationFile } = options;
+	return isRelativeImport(importPath) ? path.resolve(path.dirname(operationFile), importPath) : importPath;
+}
 /**
 * 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
+* (plugin-fetch, plugin-axios, or plugin-client). Returns `null` when no contract plugin is in play (the inline
 * path), or when the client plugin's `exclude` / `include` leaves this operation out, since it then
-* emits no `<op>` to import. The plugin injects `.kubb/client.ts` at the global output root, the
-* same path consumers read `RequestConfig` / `ResponseErrorConfig` from.
+* emits no `<op>` to import. plugin-fetch / plugin-axios inject `.kubb/client.ts` at the global
+* output root, the same path consumers read `RequestConfig` / `ResponseErrorConfig` from.
+* With plugin-client they come from the user's `importPath` module instead.
 *
 * The result is cached in the current node's `cache` (`ctx.cache`) under the client plugin's name,
 * so several dependents reading the same client plugin for one operation in a single pass
@@ -587,10 +564,15 @@ function resolveClientOperation(options) {
 			output: operationOptions.output ?? output,
 			group: operationOptions.group ?? void 0
 		});
+		const { importPath } = operationOptions;
 		return {
 			name: resolver.name(node.operationId),
 			path: file.path,
-			clientPath: path.resolve(root, ".kubb/client.ts"),
+			clientPath: importPath === void 0 ? path.resolve(root, ".kubb/client.ts") : resolveImportPath({
+				importPath,
+				operationFile: file.path
+			}),
+			clientPathIsFile: importPath === void 0 || isRelativeImport(importPath),
 			returnType: operationOptions.returnType ?? "full"
 		};
 	});
@@ -625,10 +607,7 @@ const mcpGenerator = defineGenerator({
 		const meta = {
 			name: resolver.handler.name(node),
 			file: resolver.file({
-				name: node.operationId,
-				extname: ".ts",
-				tag: node.tags[0] ?? "default",
-				path: node.path,
+				...operationFileEntry(node, node.operationId),
 				root,
 				output,
 				group: group ?? void 0
@@ -707,22 +686,14 @@ const serverGenerator = defineGenerator({
 		const { output, group } = ctx.options;
 		const pluginZod = ctx.requirePlugin(pluginZodName);
 		const zodResolver = driver.getResolver(pluginZodName);
-		const name = "server";
-		const serverFile = {
-			baseName: "server.ts",
-			path: path.resolve(root, output.path, "server.ts"),
+		const fileAt = (baseName) => ({
+			baseName,
+			path: path.resolve(root, output.path, baseName),
 			meta: { pluginName: plugin.name }
-		};
-		const startFile = {
-			baseName: "start.ts",
-			path: path.resolve(root, output.path, "start.ts"),
-			meta: { pluginName: plugin.name }
-		};
-		const jsonFile = {
-			baseName: ".mcp.json",
-			path: path.resolve(root, output.path, ".mcp.json"),
-			meta: { pluginName: plugin.name }
-		};
+		});
+		const serverFile = fileAt("server.ts");
+		const startFile = fileAt("start.ts");
+		const jsonFile = fileAt(".mcp.json");
 		const mcpConfig = { mcpServers: { [ctx.meta.title || "server"]: {
 			type: "stdio",
 			command: "npx",
@@ -730,26 +701,21 @@ const serverGenerator = defineGenerator({
 		} } };
 		const operationsMapped = nodes.filter(ast.isHttpOperationNode).map((node) => {
 			const { path: pathParams, query: queryParams, header: headerParams } = getOperationParameters(node);
+			const fileEntry = operationFileEntry(node, node.operationId);
 			const mcpFile = resolver.file({
-				name: node.operationId,
-				extname: ".ts",
-				tag: node.tags[0] ?? "default",
-				path: node.path,
+				...fileEntry,
 				root,
 				output,
 				group: group ?? void 0
 			});
 			const zodFile = zodResolver.file({
-				name: node.operationId,
-				extname: ".ts",
-				tag: node.tags[0] ?? "default",
-				path: node.path,
+				...fileEntry,
 				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 successStatus = getPrimarySuccessResponse(node)?.statusCode;
 			const responseName = successStatus ? zodResolver.response.status(node, successStatus) : null;
 			const resolveParams = (params) => params.map((p) => ({
 				name: p.name,
@@ -772,8 +738,7 @@ const serverGenerator = defineGenerator({
 					requestName,
 					responseName,
 					file: zodFile
-				},
-				node
+				}
 			};
 		});
 		const imports = operationsMapped.flatMap(({ mcp, zod }) => {
@@ -871,7 +836,7 @@ const serverGenerator = defineGenerator({
 				path: jsonFile.path,
 				meta: jsonFile.meta,
 				children: /* @__PURE__ */ jsx(File.Source, {
-					name,
+					name: "server",
 					children: `${JSON.stringify(mcpConfig, null, 2)}\n`
 				})
 			})
@@ -886,7 +851,7 @@ var compatibility = {
 };
 //#endregion
 //#region package.json
-var version = "5.2.0-canary.20261014T071450";
+var version = "5.2.1";
 //#endregion
 //#region src/resolvers/resolverMcp.ts
 /**
@@ -972,6 +937,7 @@ const pluginMcp = defineExtension({
 			override,
 			group: createGroupConfig(group),
 			client: resolveContractClient({
+				plugin: pluginMcpName,
 				client,
 				plugins: useConfig().plugins
 			}),