@kubb/mcp 5.0.0-alpha.9 → 5.0.0-beta.10

package/dist/index.cjs

@@ -21,40 +21,40 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	enumerable: true
 }) : target, mod));
 //#endregion
-let node_process = require("node:process");
-node_process = __toESM(node_process);
-let _modelcontextprotocol_sdk_server_mcp_js = require("@modelcontextprotocol/sdk/server/mcp.js");
-let _modelcontextprotocol_sdk_server_stdio_js = require("@modelcontextprotocol/sdk/server/stdio.js");
-let zod = require("zod");
+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);
+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 jiti = require("jiti");
-jiti = __toESM(jiti);
+let node_process = require("node:process");
+node_process = __toESM(node_process, 1);
 //#region package.json
-var version = "5.0.0-alpha.9";
-//#endregion
-//#region src/schemas/generateSchema.ts
-const generateSchema = zod.z.object({
-	config: zod.z.string().optional().describe("Path to kubb.config file (supports .ts, .js, .cjs). If not provided, will look for kubb.config.{ts,js,cjs} in current directory"),
-	input: zod.z.string().optional().describe("Path to OpenAPI/Swagger spec file (overrides config)"),
-	output: zod.z.string().optional().describe("Output directory path (overrides config)"),
-	logLevel: zod.z.enum([
-		"silent",
-		"error",
-		"warn",
-		"info",
-		"verbose",
-		"debug"
-	]).optional().default("info").describe("Log level for build output")
-});
+var version = "5.0.0-beta.10";
 //#endregion
 //#region ../../internals/utils/src/errors.ts
 /**
 * Coerces an unknown thrown value to an `Error` instance.
-* When the value is already an `Error` it is returned as-is;
-* otherwise a new `Error` is created whose message is `String(value)`.
+* Returns the value as-is when it is already an `Error`; otherwise wraps it with `String(value)`.
+*
+* @example
+* ```ts
+* try { ... } catch(err) {
+*   throw new BuildError('Build failed', { cause: toError(err), errors: [] })
+* }
+* ```
 */
 function toError(value) {
 	return value instanceof Error ? value : new Error(String(value));
@@ -62,12 +62,19 @@ function toError(value) {
 //#endregion
 //#region ../../internals/utils/src/asyncEventEmitter.ts
 /**
-* A typed EventEmitter that awaits all async listeners before resolving.
+* Typed `EventEmitter` that awaits all async listeners before resolving.
 * Wraps Node's `EventEmitter` with full TypeScript event-map inference.
+*
+* @example
+* ```ts
+* const emitter = new AsyncEventEmitter<{ build: [name: string] }>()
+* emitter.on('build', async (name) => { console.log(name) })
+* await emitter.emit('build', 'petstore') // all listeners awaited
+* ```
 */
 var AsyncEventEmitter = class {
 	/**
-	* `maxListener` controls the maximum number of listeners per event before Node emits a memory-leak warning.
+	* Maximum number of listeners per event before Node emits a memory-leak warning.
 	* @default 10
 	*/
 	constructor(maxListener = 10) {
@@ -75,31 +82,48 @@ var AsyncEventEmitter = class {
 	}
 	#emitter = new node_events.EventEmitter();
 	/**
-	* Emits an event and awaits all registered listeners in parallel.
+	* Emits `eventName` and awaits all registered listeners sequentially.
 	* Throws if any listener rejects, wrapping the cause with the event name and serialized arguments.
+	*
+	* @example
+	* ```ts
+	* await emitter.emit('build', 'petstore')
+	* ```
 	*/
 	async emit(eventName, ...eventArgs) {
 		const listeners = this.#emitter.listeners(eventName);
 		if (listeners.length === 0) return;
-		await Promise.all(listeners.map(async (listener) => {
+		for (const listener of listeners) try {
+			await listener(...eventArgs);
+		} catch (err) {
+			let serializedArgs;
 			try {
-				return await listener(...eventArgs);
-			} catch (err) {
-				let serializedArgs;
-				try {
-					serializedArgs = JSON.stringify(eventArgs);
-				} catch {
-					serializedArgs = String(eventArgs);
-				}
-				throw new Error(`Error in async listener for "${eventName}" with eventArgs ${serializedArgs}`, { cause: toError(err) });
+				serializedArgs = JSON.stringify(eventArgs);
+			} catch {
+				serializedArgs = String(eventArgs);
 			}
-		}));
+			throw new Error(`Error in async listener for "${eventName}" with eventArgs ${serializedArgs}`, { cause: toError(err) });
+		}
 	}
-	/** Registers a persistent listener for the given event. */
+	/**
+	* Registers a persistent listener for `eventName`.
+	*
+	* @example
+	* ```ts
+	* emitter.on('build', async (name) => { console.log(name) })
+	* ```
+	*/
 	on(eventName, handler) {
 		this.#emitter.on(eventName, handler);
 	}
-	/** Registers a one-shot listener that removes itself after the first invocation. */
+	/**
+	* Registers a one-shot listener that removes itself after the first invocation.
+	*
+	* @example
+	* ```ts
+	* emitter.onOnce('build', async (name) => { console.log(name) })
+	* ```
+	*/
 	onOnce(eventName, handler) {
 		const wrapper = (...args) => {
 			this.off(eventName, wrapper);
@@ -107,22 +131,70 @@ var AsyncEventEmitter = class {
 		};
 		this.on(eventName, wrapper);
 	}
-	/** Removes a previously registered listener. */
+	/**
+	* Removes a previously registered listener.
+	*
+	* @example
+	* ```ts
+	* emitter.off('build', handler)
+	* ```
+	*/
 	off(eventName, handler) {
 		this.#emitter.off(eventName, handler);
 	}
-	/** Removes all listeners from every event channel. */
+	/**
+	* Returns the number of listeners registered for `eventName`.
+	*
+	* @example
+	* ```ts
+	* emitter.on('build', handler)
+	* emitter.listenerCount('build') // 1
+	* ```
+	*/
+	listenerCount(eventName) {
+		return this.#emitter.listenerCount(eventName);
+	}
+	/**
+	* Removes all listeners from every event channel.
+	*
+	* @example
+	* ```ts
+	* emitter.removeAll()
+	* ```
+	*/
 	removeAll() {
 		this.#emitter.removeAllListeners();
 	}
 };
 //#endregion
 //#region ../../internals/utils/src/promise.ts
-/** Returns `true` when `result` is a thenable `Promise`. */
+/** Returns `true` when `result` is a thenable `Promise`.
+*
+* @example
+* ```ts
+* isPromise(Promise.resolve(1)) // true
+* isPromise(42)                 // false
+* ```
+*/
 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")
+});
+//#endregion
 //#region src/types.ts
 const NotifyTypes = {
 	INFO: "INFO",
@@ -148,45 +220,87 @@ const NotifyTypes = {
 	FATAL_ERROR: "FATAL_ERROR"
 };
 //#endregion
+//#region src/constants.ts
+const ALLOWED_CONFIG_EXTENSIONS = new Set([
+	".ts",
+	".mts",
+	".cts",
+	".js",
+	".mjs",
+	".cjs"
+]);
+//#endregion
 //#region src/utils/loadUserConfig.ts
-const jiti$1 = (0, jiti.default)(require("url").pathToFileURL(__filename).href, { sourceMaps: true });
-/**
-* Load the user configuration from the specified path or current directory
-*/
+const jiti$1 = (0, jiti.createJiti)(require("url").pathToFileURL(__filename).href, {
+	jsx: {
+		runtime: "automatic",
+		importSource: "@kubb/renderer-jsx"
+	},
+	moduleCache: false
+});
+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 });
+	loadedModules.set(filePath, mod);
+	return mod;
+}
 async function loadUserConfig(configPath, { notify }) {
-	let userConfig;
-	let cwd;
 	if (configPath) {
-		cwd = node_path.default.dirname(node_path.default.resolve(configPath));
+		const ext = node_path.default.extname(configPath);
+		if (!ALLOWED_CONFIG_EXTENSIONS.has(ext)) {
+			const msg = `Invalid config file extension "${ext}". Allowed: ${[...ALLOWED_CONFIG_EXTENSIONS].join(", ")}`;
+			await notify(NotifyTypes.CONFIG_ERROR, msg);
+			throw new Error(msg);
+		}
+		const base = node_path.default.resolve(process.cwd());
+		const resolvedConfigPath = node_path.default.resolve(base, configPath);
+		const relative = node_path.default.relative(base, resolvedConfigPath);
+		if (relative.startsWith("..") || node_path.default.isAbsolute(relative)) {
+			const msg = "Invalid config file path: must be within the current working directory";
+			await notify(NotifyTypes.CONFIG_ERROR, msg);
+			throw new Error(msg);
+		}
+		const cwd = node_path.default.dirname(resolvedConfigPath);
 		try {
-			userConfig = await jiti$1.import(configPath, { default: true });
-			await notify(NotifyTypes.CONFIG_LOADED, `Loaded config from ${configPath}`);
+			const userConfig = await loadModule(resolvedConfigPath);
+			await notify(NotifyTypes.CONFIG_LOADED, `Loaded config from ${resolvedConfigPath}`);
+			return {
+				userConfig,
+				cwd
+			};
 		} catch (error) {
-			await notify(NotifyTypes.CONFIG_ERROR, `Failed to load config: ${error instanceof Error ? error.message : String(error)}`);
-			throw new Error(`Failed to load config: ${error instanceof Error ? error.message : String(error)}`);
+			const msg = `Failed to load config: ${error instanceof Error ? error.message : String(error)}`;
+			await notify(NotifyTypes.CONFIG_ERROR, msg);
+			throw new Error(msg);
 		}
-	} else {
-		cwd = process.cwd();
-		const configFileNames = [
-			"kubb.config.ts",
-			"kubb.config.js",
-			"kubb.config.cjs"
-		];
-		for (const configFileName of configFileNames) try {
-			const configFilePath = node_path.default.resolve(process.cwd(), configFileName);
-			userConfig = await jiti$1.import(configFilePath, { default: true });
+	}
+	const cwd = process.cwd();
+	const configFileNames = [
+		"kubb.config.ts",
+		"kubb.config.mts",
+		"kubb.config.cts",
+		"kubb.config.js",
+		"kubb.config.cjs"
+	];
+	for (const configFileName of configFileNames) {
+		const configFilePath = node_path.default.resolve(process.cwd(), configFileName);
+		if (!(0, node_fs.existsSync)(configFilePath)) continue;
+		try {
+			const userConfig = await loadModule(configFilePath);
 			await notify(NotifyTypes.CONFIG_LOADED, `Loaded ${configFileName} from current directory`);
-			break;
-		} catch {}
-		if (!userConfig) {
-			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(", ")}`);
+			return {
+				userConfig,
+				cwd
+			};
+		} catch (err) {
+			await notify(NotifyTypes.CONFIG_ERROR, `Failed to load ${configFileName}: ${err instanceof Error ? err.message : String(err)}`);
 		}
 	}
-	return {
-		userConfig,
-		cwd
-	};
+	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
@@ -205,72 +319,59 @@ function resolveCwd(userConfig, cwd) {
 }
 //#endregion
 //#region src/utils/resolveUserConfig.ts
-/**
-* Resolve the config by handling function configs and returning the final configuration
-*/
-async function resolveUserConfig(userConfig, options) {
-	let kubbUserConfig = Promise.resolve(userConfig);
-	if (typeof userConfig === "function") {
-		const possiblePromise = userConfig({
-			logLevel: options.logLevel,
-			config: options.configPath
-		});
-		if (isPromise(possiblePromise)) kubbUserConfig = possiblePromise;
-		else kubbUserConfig = Promise.resolve(possiblePromise);
-	}
-	return await kubbUserConfig;
+async function resolveUserConfig(config, options) {
+	const result = typeof config === "function" ? config({
+		logLevel: options.logLevel,
+		config: options.configPath
+	}) : config;
+	const resolved = isPromise(result) ? await result : result;
+	return Array.isArray(resolved) ? resolved[0] : resolved;
 }
 //#endregion
 //#region src/tools/generate.ts
-/**
-* Build tool that generates code from OpenAPI specs using Kubb.
-* Sends real-time notifications of build progress and events.
-*/
-async function generate(schema, handler) {
+const generateTool = (0, tmcp_tool.defineTool)({
+	name: "generate",
+	description: "Generate OpenAPI spec helpers using Kubb configuration",
+	schema: generateSchema
+}, async function generate(schema) {
 	const { config: configPath, input, output, logLevel } = schema;
 	try {
-		const events = new AsyncEventEmitter();
+		const hooks = new AsyncEventEmitter();
 		const messages = [];
-		const notify = async (type, message, data) => {
+		const notify = async (type, message, _data) => {
 			messages.push(`${type}: ${message}`);
-			await handler.sendNotification("kubb/progress", {
-				type,
-				message,
-				timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-				...data
-			});
 		};
-		events.on("info", async (message) => {
+		hooks.on("kubb:info", async ({ message }) => {
 			await notify(NotifyTypes.INFO, message);
 		});
-		events.on("success", async (message) => {
+		hooks.on("kubb:success", async ({ message }) => {
 			await notify(NotifyTypes.SUCCESS, message);
 		});
-		events.on("error", async (error) => {
-			await notify(NotifyTypes.ERROR, error.message, { stack: error.stack });
+		hooks.on("kubb:error", async ({ error }) => {
+			await notify(NotifyTypes.ERROR, error.message);
 		});
-		events.on("warn", async (message) => {
+		hooks.on("kubb:warn", async ({ message }) => {
 			await notify(NotifyTypes.WARN, message);
 		});
-		events.on("plugin:start", async ({ name }) => {
-			await notify(NotifyTypes.PLUGIN_START, `Plugin starting: ${name}`);
+		hooks.on("kubb:plugin:start", async ({ plugin }) => {
+			await notify(NotifyTypes.PLUGIN_START, `Plugin starting: ${plugin.name}`);
 		});
-		events.on("plugin:end", async ({ name, duration }) => {
-			await notify(NotifyTypes.PLUGIN_END, `Plugin finished: ${name}`, { duration });
+		hooks.on("kubb:plugin:end", async ({ plugin, duration }) => {
+			await notify(NotifyTypes.PLUGIN_END, `Plugin finished: ${plugin.name}`, { duration });
 		});
-		events.on("files:processing:start", async () => {
+		hooks.on("kubb:files:processing:start", async () => {
 			await notify(NotifyTypes.FILES_START, "Starting file processing");
 		});
-		events.on("file:processing:update", async ({ file }) => {
+		hooks.on("kubb:file:processing:update", async ({ file }) => {
 			await notify(NotifyTypes.FILE_UPDATE, `Processing file: ${file.name}`);
 		});
-		events.on("files:processing:end", async () => {
+		hooks.on("kubb:files:processing:end", async () => {
 			await notify(NotifyTypes.FILES_END, "File processing complete");
 		});
-		events.on("generation:start", async () => {
+		hooks.on("kubb:generation:start", async () => {
 			await notify(NotifyTypes.GENERATION_START, "Generation started");
 		});
-		events.on("generation:end", async () => {
+		hooks.on("kubb:generation:end", async () => {
 			await notify(NotifyTypes.GENERATION_END, "Generation ended");
 		});
 		let userConfig;
@@ -279,7 +380,7 @@ async function generate(schema, handler) {
 			const configResult = await loadUserConfig(configPath, { notify });
 			userConfig = configResult.userConfig;
 			cwd = configResult.cwd;
-			if (Array.isArray(userConfig) && userConfig.length) throw new Error("Array type in kubb.config.ts is not supported in this tool. Please provide a single configuration object.");
+			if (Array.isArray(userConfig)) throw new Error("Array type in kubb.config.ts is not supported in this tool. Please provide a single configuration object.");
 			userConfig = await resolveUserConfig(userConfig, {
 				configPath,
 				logLevel
@@ -287,15 +388,9 @@ async function generate(schema, handler) {
 		} catch (error) {
 			const errorMessage = error instanceof Error ? error.message : String(error);
 			await notify(NotifyTypes.CONFIG_ERROR, errorMessage);
-			return {
-				content: [{
-					type: "text",
-					text: errorMessage
-				}],
-				isError: true
-			};
+			return tmcp_utils.tool.error(errorMessage);
 		}
-		const inputPath = input ?? ("path" in userConfig.input ? userConfig.input.path : void 0);
+		const inputPath = input ?? (userConfig.input && "path" in userConfig.input ? userConfig.input.path : void 0);
 		const config = {
 			...userConfig,
 			root: resolveCwd(userConfig, cwd),
@@ -308,99 +403,248 @@ async function generate(schema, handler) {
 				path: output
 			} : userConfig.output
 		};
-		await notify(NotifyTypes.CONFIG_READY, "Configuration ready", { root: config.root });
+		await notify(NotifyTypes.CONFIG_READY, "Configuration ready");
 		await notify(NotifyTypes.SETUP_START, "Setting up Kubb");
-		const { fabric, driver, sources } = await (0, _kubb_core.setup)({
-			config,
-			events
-		});
+		const kubb = (0, _kubb_core.createKubb)(config, { hooks });
+		await kubb.setup();
 		await notify(NotifyTypes.SETUP_END, "Kubb setup complete");
 		await notify(NotifyTypes.BUILD_START, "Starting build");
-		const { files, failedPlugins, error } = await (0, _kubb_core.safeBuild)({
-			config,
-			events
-		}, {
-			driver,
-			fabric,
-			events,
-			sources
-		});
+		const { files, failedPlugins, error } = 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)`, {
-				errorCount: allErrors.length,
-				errors: allErrors.map((err) => err.message)
-			});
-			return {
-				content: [{
-					type: "text",
-					text: `Build failed:\n${allErrors.map((err) => err.message).join("\n")}\n\n${messages.join("\n")}`
-				}],
-				isError: true
-			};
+			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")}`);
 		}
-		await notify(NotifyTypes.BUILD_SUCCESS, `Build completed successfully - Generated ${files.length} files`, { filesCount: files.length });
-		return { content: [{
-			type: "text",
-			text: `Build completed successfully!\n\nGenerated ${files.length} files\n\n${messages.join("\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 = caughtError;
-		await handler.sendNotification("kubb/progress", {
-			type: NotifyTypes.FATAL_ERROR,
-			message: error.message,
-			stack: error.stack,
-			timestamp: (/* @__PURE__ */ new Date()).toISOString()
-		});
-		return {
-			content: [{
-				type: "text",
-				text: `Build error: ${error.message}\n${error.stack || ""}`
-			}],
-			isError: true
-		};
+		const error = toError(caughtError);
+		return tmcp_utils.tool.error(`Build error: ${error.message}\n${error.stack ?? ""}`);
+	}
+});
+//#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/server.ts
-/**
-* Kubb MCP Server
-*
-* Provides tools for building OpenAPI specifications using Kubb.
-*/
-async function startServer() {
+//#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)"))),
+	output: valibot.optional(valibot.pipe(valibot.string(), valibot.minLength(1), valibot.description("Output directory (default: ./src/gen)"))),
+	plugins: valibot.optional(valibot.pipe(valibot.string(), valibot.minLength(1), valibot.description("Comma-separated list of plugins: plugin-ts,plugin-zod,...")))
+});
+//#endregion
+//#region src/tools/init.ts
+function resolvePlugins(pluginsFlag) {
+	if (!pluginsFlag) return [];
+	const requested = pluginsFlag.split(",").map((v) => v.trim()).filter(Boolean);
+	return availablePlugins.filter((p) => requested.includes(p.value));
+}
+const initTool = (0, tmcp_tool.defineTool)({
+	name: "init",
+	description: "Scaffold a kubb.config.ts in the current directory (non-interactive). Does not install packages.",
+	schema: initSchema
+}, async ({ input = "./openapi.yaml", output = "./src/gen", plugins }) => {
+	const selected = resolvePlugins(plugins);
+	const content = generateConfigFile({
+		selectedPlugins: selected,
+		inputPath: input,
+		outputPath: output
+	});
+	const dest = node_path.default.join(node_process.default.cwd(), KUBB_CONFIG_FILENAME);
+	if (node_fs.default.existsSync(dest)) return tmcp_utils.tool.error(`${KUBB_CONFIG_FILENAME} already exists at ${dest}. Delete it first before running init again.`);
+	node_fs.default.writeFileSync(dest, content, "utf-8");
+	const packageList = ["kubb", ...selected.map((p) => p.packageName)].join(" ");
+	return tmcp_utils.tool.text(`Created kubb.config.ts\n\nInstall packages:\n  npm install ${packageList}\n\nThen run:\n  npx kubb generate`);
+});
+//#endregion
+//#region src/schemas/validateSchema.ts
+const validateSchema = valibot.object({ input: valibot.pipe(valibot.string(), valibot.minLength(1), valibot.description("Path or URL to the OpenAPI/Swagger specification")) });
+//#endregion
+//#region src/tools/validate.ts
+const validateTool = (0, tmcp_tool.defineTool)({
+	name: "validate",
+	description: "Validate an OpenAPI/Swagger specification file or URL",
+	schema: validateSchema
+}, async ({ input }) => {
+	let mod;
 	try {
-		const transport = new _modelcontextprotocol_sdk_server_stdio_js.StdioServerTransport();
-		const server = new _modelcontextprotocol_sdk_server_mcp_js.McpServer({
-			name: "Kubb",
-			version
-		});
-		server.tool("generate", "Generate OpenAPI spec helpers using Kubb configuration", generateSchema.shape, async (args) => {
-			return generate(args, { sendNotification: async (method, params) => {
-				try {
-					await transport.send({
-						jsonrpc: "2.0",
-						method,
-						params
-					});
-				} catch (error) {
-					console.error("Failed to send notification:", error);
-				}
-			} });
-		});
-		await server.connect(transport);
-	} catch (error) {
-		console.error("Failed to start MCP server:", error);
-		node_process.default.exit(1);
+		mod = await import("@kubb/adapter-oas");
+	} catch {
+		return tmcp_utils.tool.error("The validate tool requires @kubb/adapter-oas.\nInstall: npm install @kubb/adapter-oas");
+	}
+	try {
+		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)}`);
+	}
+});
+//#endregion
+//#region src/server.ts
+function createMcpServer() {
+	const server = new tmcp.McpServer({
+		name: "Kubb",
+		version
+	}, {
+		adapter: new _tmcp_adapter_valibot.ValibotJsonSchemaAdapter(),
+		capabilities: { tools: {} }
+	});
+	server.tools([
+		generateTool,
+		validateTool,
+		initTool
+	]);
+	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}`);
+	});
 }
 //#endregion
 //#region src/index.ts
-async function run(_argv) {
-	await startServer();
+async function run(_argv, options) {
+	await startServer(options);
 }
 //#endregion
+exports.createMcpServer = createMcpServer;
 exports.run = run;
 
 //# sourceMappingURL=index.cjs.map