@kubb/mcp 5.0.0-beta.7 → 5.0.0-beta.71

package/dist/index.cjs

@@ -21,28 +21,25 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	enumerable: true
 }) : target, mod));
 //#endregion
-let node_http = require("node:http");
-node_http = __toESM(node_http, 1);
-let _remix_run_node_fetch_server = require("@remix-run/node-fetch-server");
 let _tmcp_adapter_valibot = require("@tmcp/adapter-valibot");
-let _tmcp_transport_http = require("@tmcp/transport-http");
 let _tmcp_transport_stdio = require("@tmcp/transport-stdio");
 let tmcp = require("tmcp");
 let node_events = require("node:events");
-let node_fs = require("node:fs");
-node_fs = __toESM(node_fs, 1);
-let node_path = require("node:path");
-node_path = __toESM(node_path, 1);
 let _kubb_core = require("@kubb/core");
 let tmcp_tool = require("tmcp/tool");
 let tmcp_utils = require("tmcp/utils");
 let valibot = require("valibot");
 valibot = __toESM(valibot, 1);
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs, 1);
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
+let node_url = require("node:url");
 let jiti = require("jiti");
 let node_process = require("node:process");
 node_process = __toESM(node_process, 1);
 //#region package.json
-var version = "5.0.0-beta.7";
+var version = "5.0.0-beta.71";
 //#endregion
 //#region ../../internals/utils/src/errors.ts
 /**
@@ -90,9 +87,12 @@ var AsyncEventEmitter = class {
 	* await emitter.emit('build', 'petstore')
 	* ```
 	*/
-	async emit(eventName, ...eventArgs) {
+	emit(eventName, ...eventArgs) {
 		const listeners = this.#emitter.listeners(eventName);
 		if (listeners.length === 0) return;
+		return this.#emitAll(eventName, listeners, eventArgs);
+	}
+	async #emitAll(eventName, listeners, eventArgs) {
 		for (const listener of listeners) try {
 			await listener(...eventArgs);
 		} catch (err) {
@@ -155,6 +155,24 @@ var AsyncEventEmitter = class {
 		return this.#emitter.listenerCount(eventName);
 	}
 	/**
+	* Raises or lowers the per-event listener ceiling before Node warns about a memory leak.
+	* Set this above the expected listener count when many listeners attach by design.
+	*
+	* @example
+	* ```ts
+	* emitter.setMaxListeners(40)
+	* ```
+	*/
+	setMaxListeners(max) {
+		this.#emitter.setMaxListeners(max);
+	}
+	/**
+	* Returns the current per-event listener ceiling.
+	*/
+	getMaxListeners() {
+		return this.#emitter.getMaxListeners();
+	}
+	/**
 	* Removes all listeners from every event channel.
 	*
 	* @example
@@ -180,31 +198,103 @@ function isPromise(result) {
 	return result !== null && result !== void 0 && typeof result["then"] === "function";
 }
 //#endregion
-//#region src/schemas/generateSchema.ts
-const generateSchema = valibot.object({
-	config: valibot.optional(valibot.pipe(valibot.string(), valibot.minLength(1), valibot.description("Path to kubb.config file (supports .ts, .js, .cjs). If not provided, will look for kubb.config.{ts,js,cjs} in current directory"))),
-	input: valibot.optional(valibot.pipe(valibot.string(), valibot.minLength(1), valibot.description("Path to OpenAPI/Swagger spec file (overrides config)"))),
-	output: valibot.optional(valibot.pipe(valibot.string(), valibot.minLength(1), valibot.description("Output directory path (overrides config)"))),
-	logLevel: valibot.optional(valibot.pipe(valibot.picklist([
-		"silent",
-		"error",
-		"warn",
-		"info",
-		"verbose",
-		"debug"
-	]), valibot.description("Log level for build output")), "info")
-});
+//#region ../../internals/utils/src/runtime.ts
+/**
+* Detects the JavaScript runtime executing the current process and exposes its name and version.
+*
+* Prefer the shared {@link runtime} instance over constructing your own.
+*/
+var Runtime = class {
+	/**
+	* `true` when the current process is running under Bun.
+	*
+	* Detection keys off the global `Bun` object rather than `process.versions`,
+	* because Bun polyfills `process.versions.node` for Node compatibility and would
+	* otherwise look like Node.
+	*
+	* @example
+	* ```ts
+	* if (runtime.isBun) {
+	*   await Bun.write(path, data)
+	* }
+	* ```
+	*/
+	get isBun() {
+		return typeof Bun !== "undefined";
+	}
+	/**
+	* `true` when the current process is running under Deno.
+	*/
+	get isDeno() {
+		return typeof globalThis.Deno !== "undefined";
+	}
+	/**
+	* `true` when the current process is running under Node.
+	*
+	* Bun and Deno are excluded first so a polyfilled `process` does not register as Node.
+	*/
+	get isNode() {
+		return !this.isBun && !this.isDeno && typeof process !== "undefined" && process.versions?.node != null;
+	}
+	/**
+	* Name of the runtime executing the current process.
+	*
+	* @example
+	* ```ts
+	* runtime.name // 'bun' when run with `bun kubb`, 'node' otherwise
+	* ```
+	*/
+	get name() {
+		if (this.isBun) return "bun";
+		if (this.isDeno) return "deno";
+		return "node";
+	}
+	/**
+	* Version of the active runtime, or an empty string when it cannot be read.
+	*
+	* @example
+	* ```ts
+	* runtime.version // '1.3.11' under Bun, '22.22.2' under Node
+	* ```
+	*/
+	get version() {
+		if (this.isBun) return process.versions.bun ?? "";
+		if (this.isDeno) return globalThis.Deno?.version?.deno ?? "";
+		return process.versions?.node ?? "";
+	}
+};
+/**
+* Shared {@link Runtime} instance describing the JavaScript runtime executing the current process.
+*/
+const runtime = new Runtime();
 //#endregion
-//#region src/types.ts
+//#region src/constants.ts
+/**
+* File extensions a Kubb config is allowed to use. A config path with any other
+* extension is rejected before it is loaded.
+*/
+const ALLOWED_CONFIG_EXTENSIONS = new Set([
+	".ts",
+	".mts",
+	".cts",
+	".js",
+	".mjs",
+	".cjs"
+]);
+/**
+* Notification kinds reported back to the MCP client while loading config and
+* running generation, covering progress, results, and errors.
+*/
 const NotifyTypes = {
 	INFO: "INFO",
 	SUCCESS: "SUCCESS",
 	ERROR: "ERROR",
 	WARN: "WARN",
+	DIAGNOSTIC: "DIAGNOSTIC",
 	PLUGIN_START: "PLUGIN_START",
 	PLUGIN_END: "PLUGIN_END",
 	FILES_START: "FILES_START",
-	FILE_UPDATE: "FILE_UPDATE",
+	FILES_UPDATE: "FILES_UPDATE",
 	FILES_END: "FILES_END",
 	GENERATION_START: "GENERATION_START",
 	GENERATION_END: "GENERATION_END",
@@ -216,37 +306,198 @@ const NotifyTypes = {
 	BUILD_START: "BUILD_START",
 	BUILD_END: "BUILD_END",
 	BUILD_FAILED: "BUILD_FAILED",
-	BUILD_SUCCESS: "BUILD_SUCCESS",
-	FATAL_ERROR: "FATAL_ERROR"
+	BUILD_SUCCESS: "BUILD_SUCCESS"
 };
 //#endregion
-//#region src/constants.ts
-const ALLOWED_CONFIG_EXTENSIONS = new Set([
-	".ts",
-	".mts",
-	".cts",
-	".js",
-	".mjs",
-	".cjs"
-]);
+//#region src/schemas/generateSchema.ts
+const generateSchema = valibot.object({
+	config: valibot.optional(valibot.pipe(valibot.string(), valibot.minLength(1), valibot.description("Path to kubb.config file (supports .ts, .js, .cjs). If not provided, will look for kubb.config.{ts,js,cjs} in current directory"))),
+	input: valibot.optional(valibot.pipe(valibot.string(), valibot.minLength(1), valibot.description("Path to OpenAPI/Swagger spec file (overrides config)"))),
+	output: valibot.optional(valibot.pipe(valibot.string(), valibot.minLength(1), valibot.description("Output directory path (overrides config)"))),
+	logLevel: valibot.optional(valibot.pipe(valibot.picklist([
+		"silent",
+		"info",
+		"verbose"
+	]), valibot.description("Log level for build output")), "info")
+});
+//#endregion
+//#region ../../internals/shared/src/constants.ts
+const KUBB_CONFIG_FILENAME = "kubb.config.ts";
+const availablePlugins = [
+	{
+		value: "plugin-ts",
+		label: "TypeScript",
+		hint: "Recommended",
+		packageName: "@kubb/plugin-ts",
+		importName: "pluginTs",
+		category: "types"
+	},
+	{
+		value: "plugin-client",
+		label: "Client (Fetch/Axios)",
+		packageName: "@kubb/plugin-client",
+		importName: "pluginClient",
+		category: "client"
+	},
+	{
+		value: "plugin-react-query",
+		label: "React Query / TanStack Query",
+		packageName: "@kubb/plugin-react-query",
+		importName: "pluginReactQuery",
+		category: "framework"
+	},
+	{
+		value: "plugin-vue-query",
+		label: "Vue Query",
+		packageName: "@kubb/plugin-vue-query",
+		importName: "pluginVueQuery",
+		category: "framework"
+	},
+	{
+		value: "plugin-zod",
+		label: "Zod Schemas",
+		packageName: "@kubb/plugin-zod",
+		importName: "pluginZod",
+		category: "validation"
+	},
+	{
+		value: "plugin-faker",
+		label: "Faker.js Mocks",
+		packageName: "@kubb/plugin-faker",
+		importName: "pluginFaker",
+		category: "mocks"
+	},
+	{
+		value: "plugin-msw",
+		label: "MSW Handlers",
+		packageName: "@kubb/plugin-msw",
+		importName: "pluginMsw",
+		category: "mocks"
+	},
+	{
+		value: "plugin-cypress",
+		label: "Cypress Tests",
+		packageName: "@kubb/plugin-cypress",
+		importName: "pluginCypress",
+		category: "testing"
+	},
+	{
+		value: "plugin-mcp",
+		label: "MCP Server (AI / Model Context Protocol)",
+		packageName: "@kubb/plugin-mcp",
+		importName: "pluginMcp",
+		category: "ai"
+	},
+	{
+		value: "plugin-redoc",
+		label: "ReDoc Documentation",
+		packageName: "@kubb/plugin-redoc",
+		importName: "pluginRedoc",
+		category: "documentation"
+	}
+];
 //#endregion
-//#region src/utils/loadUserConfig.ts
-const jiti$1 = (0, jiti.createJiti)(require("url").pathToFileURL(__filename).href, {
+//#region ../../internals/shared/src/init.ts
+function generateConfigFile({ selectedPlugins, inputPath, outputPath }) {
+	return `import { defineConfig } from 'kubb'
+${selectedPlugins.map((plugin) => `import { ${plugin.importName} } from '${plugin.packageName}'`).join("\n")}
+
+export default defineConfig({
+  root: '.',
+  input: {
+    path: '${inputPath}',
+  },
+  output: {
+    path: '${outputPath}',
+    clean: true,
+  },
+  plugins: [
+${selectedPlugins.map((plugin) => `    ${plugin.importName}(),`).join("\n")}
+  ],
+})
+`;
+}
+//#endregion
+//#region ../../internals/shared/src/loader.ts
+/**
+* jiti options for loading Kubb config modules: the automatic JSX runtime pointed at
+* `@kubb/renderer-jsx`, and `moduleCache` off so a re-load re-evaluates the file.
+*/
+const JITI_OPTIONS = {
 	jsx: {
 		runtime: "automatic",
 		importSource: "@kubb/renderer-jsx"
 	},
 	moduleCache: false
-});
+};
+/**
+* Creates a runtime-aware loader for Kubb's TypeScript and JavaScript config modules.
+*
+* On Bun and Deno it imports the file natively, skipping jiti's transform step, and falls back to
+* jiti only when the native import throws. On Node it always uses jiti, which transpiles TypeScript
+* and the `@kubb/renderer-jsx` JSX runtime on the fly. The jiti instance is created lazily, so the
+* Bun/Deno happy path never pays for it.
+*
+* @example
+* ```ts
+* const config = await createModuleLoader().load('/abs/kubb.config.ts', { default: true })
+* ```
+*/
+function createModuleLoader() {
+	let jiti$1;
+	const getJiti = () => jiti$1 ??= (0, jiti.createJiti)(require("url").pathToFileURL(__filename).href, JITI_OPTIONS);
+	const viaJiti = (filePath, options) => options?.default ? getJiti().import(filePath, { default: true }) : getJiti().import(filePath);
+	const viaNative = async (filePath, options) => {
+		const href = (0, node_url.pathToFileURL)(filePath).href;
+		const mod = await (options?.bust != null ? import(`${href}?t=${options.bust}`) : import(href));
+		return options?.default ? mod.default ?? mod : mod;
+	};
+	return { async load(filePath, options) {
+		if (runtime.isBun || runtime.isDeno) try {
+			return await viaNative(filePath, options);
+		} catch {
+			return viaJiti(filePath, options);
+		}
+		return viaJiti(filePath, options);
+	} };
+}
+//#endregion
+//#region src/utils.ts
+/**
+* Renders serialized diagnostics as a plain-text block for an AI assistant. Each entry
+* keeps the stable `code`, the source pointer, the suggested fix, and the docs link, so
+* the agent can act on the problem rather than parsing a bare message. No ANSI styling,
+* unlike the CLI renderer.
+*/
+function formatDiagnostics(diagnostics) {
+	return diagnostics.map((diagnostic) => formatDiagnostic(diagnostic)).join("\n\n");
+}
+function formatDiagnostic(diagnostic) {
+	const { code, message, location, help, plugin, docsUrl } = diagnostic;
+	const lines = [plugin ? `[${code}] ${plugin}: ${message}` : `[${code}]: ${message}`];
+	if (location && "pointer" in location) lines.push(`  at: ${location.pointer}`);
+	if (help) lines.push(`  fix: ${help}`);
+	if (docsUrl) lines.push(`  see: ${docsUrl}`);
+	return lines.join("\n");
+}
+const loader = createModuleLoader();
 const loadedModules = /* @__PURE__ */ new Map();
 async function loadModule(filePath) {
 	const ext = node_path.default.extname(filePath);
 	if (!ALLOWED_CONFIG_EXTENSIONS.has(ext)) throw new Error(`Invalid config file extension "${ext}". Allowed: ${[...ALLOWED_CONFIG_EXTENSIONS].join(", ")}`);
 	if (loadedModules.has(filePath)) return loadedModules.get(filePath);
-	const mod = await jiti$1.import(filePath, { default: true });
+	const mod = await loader.load(filePath, { default: true });
 	loadedModules.set(filePath, mod);
 	return mod;
 }
+/**
+* Loads the user's Kubb config and returns it with the directory it was found in.
+*
+* When `configPath` is given it must use an allowed extension and resolve inside
+* the current working directory, otherwise loading throws. When omitted, the
+* known `kubb.config.*` file names are tried in the current directory. Every
+* outcome is reported through `notify` before the function returns or throws.
+*/
 async function loadUserConfig(configPath, { notify }) {
 	if (configPath) {
 		const ext = node_path.default.extname(configPath);
@@ -302,8 +553,6 @@ async function loadUserConfig(configPath, { notify }) {
 	await notify(NotifyTypes.CONFIG_ERROR, "No config file found");
 	throw new Error(`No config file found. Please provide a config path or create one of: ${configFileNames.join(", ")}`);
 }
-//#endregion
-//#region src/utils/resolveCwd.ts
 /**
 * Determine the root directory based on userConfig.root and resolvedConfigDir
 * 1. If userConfig.root exists and is absolute, use it as-is
@@ -317,8 +566,12 @@ function resolveCwd(userConfig, cwd) {
 	}
 	return cwd;
 }
-//#endregion
-//#region src/utils/resolveUserConfig.ts
+/**
+* Normalizes a possible config into a single resolved `Config`.
+*
+* Calls the config when it is a function, awaits it when it is a promise, and
+* picks the first entry when it resolves to an array.
+*/
 async function resolveUserConfig(config, options) {
 	const result = typeof config === "function" ? config({
 		logLevel: options.logLevel,
@@ -338,8 +591,8 @@ const generateTool = (0, tmcp_tool.defineTool)({
 	try {
 		const hooks = new AsyncEventEmitter();
 		const messages = [];
-		const notify = async (type, message, _data) => {
-			messages.push(`${type}: ${message}`);
+		const notify = async (type, message, data) => {
+			messages.push(data ? `${type}: ${message} ${JSON.stringify(data)}` : `${type}: ${message}`);
 		};
 		hooks.on("kubb:info", async ({ message }) => {
 			await notify(NotifyTypes.INFO, message);
@@ -353,6 +606,9 @@ const generateTool = (0, tmcp_tool.defineTool)({
 		hooks.on("kubb:warn", async ({ message }) => {
 			await notify(NotifyTypes.WARN, message);
 		});
+		hooks.on("kubb:diagnostic", async ({ diagnostic }) => {
+			await notify(NotifyTypes.DIAGNOSTIC, diagnostic.message, _kubb_core.Diagnostics.serialize(diagnostic));
+		});
 		hooks.on("kubb:plugin:start", async ({ plugin }) => {
 			await notify(NotifyTypes.PLUGIN_START, `Plugin starting: ${plugin.name}`);
 		});
@@ -362,8 +618,8 @@ const generateTool = (0, tmcp_tool.defineTool)({
 		hooks.on("kubb:files:processing:start", async () => {
 			await notify(NotifyTypes.FILES_START, "Starting file processing");
 		});
-		hooks.on("kubb:file:processing:update", async ({ file }) => {
-			await notify(NotifyTypes.FILE_UPDATE, `Processing file: ${file.name}`);
+		hooks.on("kubb:files:processing:update", async ({ files }) => {
+			await notify(NotifyTypes.FILES_UPDATE, `Processing ${files.length} files`);
 		});
 		hooks.on("kubb:files:processing:end", async () => {
 			await notify(NotifyTypes.FILES_END, "File processing complete");
@@ -409,152 +665,23 @@ const generateTool = (0, tmcp_tool.defineTool)({
 		await kubb.setup();
 		await notify(NotifyTypes.SETUP_END, "Kubb setup complete");
 		await notify(NotifyTypes.BUILD_START, "Starting build");
-		const { files, failedPlugins, error } = await kubb.safeBuild();
+		const { files, diagnostics } = await kubb.safeBuild();
 		await notify(NotifyTypes.BUILD_END, `Build complete - Generated ${files.length} files`);
-		if (error || failedPlugins.size > 0) {
-			const allErrors = [error, ...Array.from(failedPlugins).filter((it) => it.error).map((it) => it.error)].filter(Boolean);
-			await notify(NotifyTypes.BUILD_FAILED, `Build failed with ${allErrors.length} error(s)`);
-			return tmcp_utils.tool.error(`Build failed:\n${allErrors.map((err) => err.message).join("\n")}\n\n${messages.join("\n")}`);
+		const problems = diagnostics.filter(_kubb_core.Diagnostics.isProblem);
+		const errors = problems.filter((diagnostic) => diagnostic.severity === "error");
+		if (errors.length > 0) {
+			await notify(NotifyTypes.BUILD_FAILED, `Build failed with ${errors.length} diagnostic(s)`);
+			const serialized = problems.map((diagnostic) => _kubb_core.Diagnostics.serialize(diagnostic));
+			return tmcp_utils.tool.error(`Build failed:\n${formatDiagnostics(serialized)}\n\n\`\`\`json\n${JSON.stringify(serialized, null, 2)}\n\`\`\``);
 		}
 		await notify(NotifyTypes.BUILD_SUCCESS, `Build completed successfully - Generated ${files.length} files`);
 		return tmcp_utils.tool.text(`Build completed successfully!\n\nGenerated ${files.length} files\n\n${messages.join("\n")}`);
 	} catch (caughtError) {
-		const error = toError(caughtError);
-		return tmcp_utils.tool.error(`Build error: ${error.message}\n${error.stack ?? ""}`);
+		const serialized = _kubb_core.Diagnostics.serialize(_kubb_core.Diagnostics.from(caughtError));
+		return tmcp_utils.tool.error(`Build error:\n${formatDiagnostics([serialized])}\n\n\`\`\`json\n${JSON.stringify(serialized, null, 2)}\n\`\`\``);
 	}
 });
 //#endregion
-//#region ../../internals/shared/src/constants.ts
-const KUBB_CONFIG_FILENAME = "kubb.config.ts";
-const availablePlugins = [
-	{
-		value: "plugin-ts",
-		label: "TypeScript",
-		hint: "Recommended",
-		packageName: "@kubb/plugin-ts",
-		importName: "pluginTs",
-		category: "types"
-	},
-	{
-		value: "plugin-client",
-		label: "Client (Fetch/Axios)",
-		packageName: "@kubb/plugin-client",
-		importName: "pluginClient",
-		category: "client"
-	},
-	{
-		value: "plugin-react-query",
-		label: "React Query / TanStack Query",
-		packageName: "@kubb/plugin-react-query",
-		importName: "pluginReactQuery",
-		category: "framework"
-	},
-	{
-		value: "plugin-vue-query",
-		label: "Vue Query",
-		packageName: "@kubb/plugin-vue-query",
-		importName: "pluginVueQuery",
-		category: "framework"
-	},
-	{
-		value: "plugin-zod",
-		label: "Zod Schemas",
-		packageName: "@kubb/plugin-zod",
-		importName: "pluginZod",
-		category: "validation"
-	},
-	{
-		value: "plugin-faker",
-		label: "Faker.js Mocks",
-		packageName: "@kubb/plugin-faker",
-		importName: "pluginFaker",
-		category: "mocks"
-	},
-	{
-		value: "plugin-msw",
-		label: "MSW Handlers",
-		packageName: "@kubb/plugin-msw",
-		importName: "pluginMsw",
-		category: "mocks"
-	},
-	{
-		value: "plugin-cypress",
-		label: "Cypress Tests",
-		packageName: "@kubb/plugin-cypress",
-		importName: "pluginCypress",
-		category: "testing"
-	},
-	{
-		value: "plugin-mcp",
-		label: "MCP Server (AI / Model Context Protocol)",
-		packageName: "@kubb/plugin-mcp",
-		importName: "pluginMcp",
-		category: "ai"
-	},
-	{
-		value: "plugin-redoc",
-		label: "ReDoc Documentation",
-		packageName: "@kubb/plugin-redoc",
-		importName: "pluginRedoc",
-		category: "documentation"
-	}
-];
-const pluginDefaultConfigs = {
-	"plugin-ts": `pluginTs({
-      output: { path: 'models' },
-    })`,
-	"plugin-client": `pluginClient({
-      output: { path: 'clients' },
-    })`,
-	"plugin-react-query": `pluginReactQuery({
-      output: { path: 'hooks' },
-    })`,
-	"plugin-vue-query": `pluginVueQuery({
-      output: { path: 'hooks' },
-    })`,
-	"plugin-zod": `pluginZod({
-      output: { path: 'zod' },
-    })`,
-	"plugin-faker": `pluginFaker({
-      output: { path: 'mocks' },
-    })`,
-	"plugin-msw": `pluginMsw({
-      output: { path: 'msw' },
-    })`,
-	"plugin-cypress": `pluginCypress({
-      output: { path: 'cypress' },
-    })`,
-	"plugin-mcp": `pluginMcp({
-      output: { path: 'mcp' },
-    })`,
-	"plugin-redoc": `pluginRedoc({
-      output: { path: 'redoc' },
-    })`
-};
-//#endregion
-//#region ../../internals/shared/src/init.ts
-function generateConfigFile({ selectedPlugins, inputPath, outputPath }) {
-	return `import { defineConfig } from 'kubb'
-${selectedPlugins.map((plugin) => `import { ${plugin.importName} } from '${plugin.packageName}'`).join("\n")}
-
-export default defineConfig({
-  root: '.',
-  input: {
-    path: '${inputPath}',
-  },
-  output: {
-    path: '${outputPath}',
-    clean: true,
-  },
-  plugins: [
-${selectedPlugins.map((plugin) => {
-		return `    ${pluginDefaultConfigs[plugin.value] ?? `${plugin.importName}()`},`;
-	}).join("\n")}
-  ],
-})
-`;
-}
-//#endregion
 //#region src/schemas/initSchema.ts
 const initSchema = valibot.object({
 	input: valibot.optional(valibot.pipe(valibot.string(), valibot.minLength(1), valibot.description("Path to OpenAPI spec (default: ./openapi.yaml)"))),
@@ -563,6 +690,10 @@ const initSchema = valibot.object({
 });
 //#endregion
 //#region src/tools/init.ts
+/**
+* Resolves a comma-separated plugin flag into the matching known plugin options.
+* Unrecognized names are dropped, and a missing flag yields an empty list.
+*/
 function resolvePlugins(pluginsFlag) {
 	if (!pluginsFlag) return [];
 	const requested = pluginsFlag.split(",").map((v) => v.trim()).filter(Boolean);
@@ -605,11 +736,18 @@ const validateTool = (0, tmcp_tool.defineTool)({
 		await mod.adapterOas().validate(input, { throwOnError: true });
 		return tmcp_utils.tool.text(`Validation successful: ${input}`);
 	} catch (err) {
-		return tmcp_utils.tool.error(`Validation failed:\n${err instanceof Error ? err.message : String(err)}`);
+		const serialized = _kubb_core.Diagnostics.serialize(_kubb_core.Diagnostics.from(err));
+		return tmcp_utils.tool.error(`Validation failed:\n${formatDiagnostics([serialized])}\n\n\`\`\`json\n${JSON.stringify(serialized, null, 2)}\n\`\`\``);
 	}
 });
 //#endregion
 //#region src/server.ts
+/**
+* Builds the Kubb MCP server with the generate, validate, and init tools registered.
+*
+* @example
+* `const server = createMcpServer()`
+*/
 function createMcpServer() {
 	const server = new tmcp.McpServer({
 		name: "Kubb",
@@ -625,23 +763,21 @@ function createMcpServer() {
 	]);
 	return server;
 }
-async function startServer({ port, host = "localhost" } = {}) {
-	const server = createMcpServer();
-	if (port === void 0) {
-		new _tmcp_transport_stdio.StdioTransport(server).listen();
-		return;
-	}
-	const transport = new _tmcp_transport_http.HttpTransport(server, { path: "/mcp" });
-	node_http.default.createServer((0, _remix_run_node_fetch_server.createRequestListener)(async (request) => {
-		return await transport.respond(request) ?? new Response("Not Found", { status: 404 });
-	})).listen(port, host, () => {
-		console.log(`Kubb MCP server on http://${host}:${port}`);
-	});
+/**
+* Starts the Kubb MCP server over stdio, the transport every local MCP client
+* (Claude, Copilot, editors) uses when it launches the server as a subprocess.
+*/
+async function startServer() {
+	new _tmcp_transport_stdio.StdioTransport(createMcpServer()).listen();
 }
 //#endregion
 //#region src/index.ts
-async function run(_argv, options) {
-	await startServer(options);
+/**
+* Entry point that starts the MCP server over stdio. The argument is accepted
+* for CLI parity but ignored.
+*/
+async function run(_argv) {
+	await startServer();
 }
 //#endregion
 exports.createMcpServer = createMcpServer;