@kubb/plugin-mcp 5.0.0-alpha.34 → 5.0.0-alpha.35

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-mcp",
-  "version": "5.0.0-alpha.34",
+  "version": "5.0.0-alpha.35",
   "description": "Model Context Protocol (MCP) plugin for Kubb, generating MCP-compatible tools and schemas from OpenAPI specifications for AI assistants.",
   "keywords": [
     "mcp",
@@ -49,12 +49,11 @@
     }
   ],
   "dependencies": {
-    "@kubb/ast": "5.0.0-alpha.34",
-    "@kubb/core": "5.0.0-alpha.34",
-    "@kubb/plugin-client": "5.0.0-alpha.34",
-    "@kubb/plugin-ts": "5.0.0-alpha.34",
-    "@kubb/plugin-zod": "5.0.0-alpha.34",
-    "@kubb/renderer-jsx": "5.0.0-alpha.34"
+    "@kubb/core": "5.0.0-alpha.35",
+    "@kubb/plugin-client": "5.0.0-alpha.35",
+    "@kubb/plugin-ts": "5.0.0-alpha.35",
+    "@kubb/renderer-jsx": "5.0.0-alpha.35",
+    "@kubb/plugin-zod": "5.0.0-alpha.35"
   },
   "devDependencies": {
     "@internals/utils": "0.0.0"
@@ -69,7 +68,7 @@
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "peerDependencies": {
-    "@kubb/renderer-jsx": "5.0.0-alpha.34"
+    "@kubb/renderer-jsx": "5.0.0-alpha.35"
   },
   "scripts": {
     "build": "tsdown && size-limit",

package/src/components/McpHandler.tsx

@@ -1,6 +1,5 @@
 import { isValidVarName, URLPath } from '@internals/utils'
-import { caseParams, createOperationParams } from '@kubb/ast'
-import type { OperationNode } from '@kubb/ast/types'
+import { ast } from '@kubb/core'
 import type { ResolverTs } from '@kubb/plugin-ts'
 import { functionPrinter } from '@kubb/plugin-ts'
 import { File, Function } from '@kubb/renderer-jsx'
@@ -16,7 +15,7 @@ type Props = {
   /**
    * AST operation node.
    */
-  node: OperationNode
+  node: ast.OperationNode
   /**
    * TypeScript resolver for resolving param/data/response type names.
    */
@@ -55,7 +54,7 @@ export function McpHandler({ name, node, resolver, baseURL, dataReturnType, para
   const contentType = node.requestBody?.contentType
   const isFormData = contentType === 'multipart/form-data'
 
-  const casedParams = caseParams(node.parameters, paramsCasing)
+  const casedParams = ast.caseParams(node.parameters, paramsCasing)
   const queryParams = casedParams.filter((p) => p.in === 'query')
   const headerParams = casedParams.filter((p) => p.in === 'header')
 
@@ -73,7 +72,7 @@ export function McpHandler({ name, node, resolver, baseURL, dataReturnType, para
   const TError = `ResponseErrorConfig<${errorType}>`
   const generics = [responseName, TError, requestName || 'unknown'].filter(Boolean)
 
-  const paramsNode = createOperationParams(node, {
+  const paramsNode = ast.createOperationParams(node, {
     paramsType: 'object',
     pathParamsType: 'inline',
     resolver,

package/src/components/Server.tsx

@@ -1,5 +1,4 @@
-import { caseParams, createFunctionParameter, createFunctionParameters, createParameterGroup } from '@kubb/ast'
-import type { FileNode, OperationNode } from '@kubb/ast/types'
+import { ast } from '@kubb/core'
 import { functionPrinter } from '@kubb/plugin-ts'
 import { Const, File, Function } from '@kubb/renderer-jsx'
 import type { KubbReactNode } from '@kubb/renderer-jsx/types'
@@ -36,7 +35,7 @@ type Props = {
     }
     mcp: {
       name: string
-      file: FileNode
+      file: ast.FileNode
     }
     zod: {
       pathParams: Array<ZodParam>
@@ -51,7 +50,7 @@ type Props = {
       requestName?: string
       responseName?: string
     }
-    node: OperationNode
+    node: ast.OperationNode
   }>
 }
 
@@ -71,7 +70,7 @@ export function Server({ name, serverName, serverVersion, paramsCasing, operatio
 
       {operations
         .map(({ tool, mcp, zod, node }) => {
-          const casedParams = caseParams(node.parameters, paramsCasing)
+          const casedParams = ast.caseParams(node.parameters, paramsCasing)
           const pathParams = casedParams.filter((p) => p.in === 'path')
 
           const pathEntries: Array<{ key: string; value: string }> = []
@@ -98,10 +97,10 @@ export function Server({ name, serverName, serverVersion, paramsCasing, operatio
           const entries = [...pathEntries, ...otherEntries]
 
           const paramsNode = entries.length
-            ? createFunctionParameters({
+            ? ast.createFunctionParameters({
                 params: [
-                  createParameterGroup({
-                    properties: entries.map((e) => createFunctionParameter({ name: e.key, optional: false })),
+                  ast.createParameterGroup({
+                    properties: entries.map((e) => ast.createFunctionParameter({ name: e.key, optional: false })),
                   }),
                 ],
               })

package/src/generators/mcpGenerator.tsx

@@ -1,16 +1,17 @@
 import path from 'node:path'
-import { caseParams } from '@kubb/ast'
-import { defineGenerator } from '@kubb/core'
+
+import { ast, defineGenerator } from '@kubb/core'
 import { pluginTsName } from '@kubb/plugin-ts'
-import { File } from '@kubb/renderer-jsx'
+import { File, jsxRenderer } from '@kubb/renderer-jsx'
 import { McpHandler } from '../components/McpHandler.tsx'
 import type { PluginMcp } from '../types.ts'
 
 export const mcpGenerator = defineGenerator<PluginMcp>({
   name: 'mcp',
-  operation(node, options) {
-    const { resolver, driver, root } = this
-    const { output, client, paramsCasing, group } = options
+  renderer: jsxRenderer,
+  operation(node, ctx) {
+    const { resolver, driver, root } = ctx
+    const { output, client, paramsCasing, group } = ctx.options
 
     const pluginTs = driver.getPlugin(pluginTsName)
 
@@ -18,7 +19,7 @@ export const mcpGenerator = defineGenerator<PluginMcp>({
       return null
     }
 
-    const casedParams = caseParams(node.parameters, paramsCasing)
+    const casedParams = ast.caseParams(node.parameters, paramsCasing)
 
     const pathParams = casedParams.filter((p) => p.in === 'path')
     const queryParams = casedParams.filter((p) => p.in === 'query')

package/src/generators/serverGenerator.tsx

@@ -1,8 +1,8 @@
 import path from 'node:path'
-import { caseParams } from '@kubb/ast'
-import { defineGenerator } from '@kubb/core'
+
+import { ast, defineGenerator } from '@kubb/core'
 import { pluginZodName } from '@kubb/plugin-zod'
-import { File } from '@kubb/renderer-jsx'
+import { File, jsxRenderer } from '@kubb/renderer-jsx'
 import { Server } from '../components/Server.tsx'
 import type { PluginMcp } from '../types.ts'
 import { findSuccessStatusCode } from '../utils.ts'
@@ -16,9 +16,10 @@ import { findSuccessStatusCode } from '../utils.ts'
  */
 export const serverGenerator = defineGenerator<PluginMcp>({
   name: 'operations',
-  operations(nodes, options) {
-    const { adapter, config, resolver, plugin, driver, root } = this
-    const { output, paramsCasing, group } = options
+  renderer: jsxRenderer,
+  operations(nodes, ctx) {
+    const { adapter, config, resolver, plugin, driver, root } = ctx
+    const { output, paramsCasing, group } = ctx.options
 
     const pluginZod = driver.getPlugin(pluginZodName)
 
@@ -42,7 +43,7 @@ export const serverGenerator = defineGenerator<PluginMcp>({
     }
 
     const operationsMapped = nodes.map((node) => {
-      const casedParams = caseParams(node.parameters, paramsCasing)
+      const casedParams = ast.caseParams(node.parameters, paramsCasing)
       const pathParams = casedParams.filter((p) => p.in === 'path')
       const queryParams = casedParams.filter((p) => p.in === 'query')
       const headerParams = casedParams.filter((p) => p.in === 'header')

package/src/generators/serverGeneratorLegacy.tsx

@@ -1,8 +1,8 @@
 import path from 'node:path'
-import { caseParams } from '@kubb/ast'
-import { defineGenerator } from '@kubb/core'
+
+import { ast, defineGenerator } from '@kubb/core'
 import { pluginZodName } from '@kubb/plugin-zod'
-import { File } from '@kubb/renderer-jsx'
+import { File, jsxRenderer } from '@kubb/renderer-jsx'
 import { Server } from '../components/Server.tsx'
 import type { PluginMcp } from '../types.ts'
 
@@ -15,9 +15,10 @@ import type { PluginMcp } from '../types.ts'
  */
 export const serverGeneratorLegacy = defineGenerator<PluginMcp>({
   name: 'operations',
-  operations(nodes, options) {
-    const { adapter, config, resolver, plugin, driver, root } = this
-    const { output, paramsCasing, group } = options
+  renderer: jsxRenderer,
+  operations(nodes, ctx) {
+    const { adapter, config, resolver, plugin, driver, root } = ctx
+    const { output, paramsCasing, group } = ctx.options
 
     const pluginZod = driver.getPlugin(pluginZodName)
 
@@ -41,7 +42,7 @@ export const serverGeneratorLegacy = defineGenerator<PluginMcp>({
     }
 
     const operationsMapped = nodes.map((node) => {
-      const casedParams = caseParams(node.parameters, paramsCasing)
+      const casedParams = ast.caseParams(node.parameters, paramsCasing)
       const queryParams = casedParams.filter((p) => p.in === 'query')
       const headerParams = casedParams.filter((p) => p.in === 'header')
 

package/src/plugin.ts

@@ -1,20 +1,22 @@
 import path from 'node:path'
 import { camelCase } from '@internals/utils'
-import { createFile, createSource, createText } from '@kubb/ast'
-import { createPlugin, type Group, getPreset, mergeGenerators } from '@kubb/core'
+
+import { ast, definePlugin, type Group } from '@kubb/core'
 import { pluginClientName } from '@kubb/plugin-client'
 import { source as axiosClientSource } from '@kubb/plugin-client/templates/clients/axios.source'
 import { source as fetchClientSource } from '@kubb/plugin-client/templates/clients/fetch.source'
 import { source as configSource } from '@kubb/plugin-client/templates/config.source'
 import { pluginTsName } from '@kubb/plugin-ts'
 import { pluginZodName } from '@kubb/plugin-zod'
-import { version } from '../package.json'
-import { presets } from './presets.ts'
+import { mcpGenerator } from './generators/mcpGenerator.tsx'
+import { serverGenerator } from './generators/serverGenerator.tsx'
+import { serverGeneratorLegacy } from './generators/serverGeneratorLegacy.tsx'
+import { resolverMcp } from './resolvers/resolverMcp.ts'
 import type { PluginMcp } from './types.ts'
 
 export const pluginMcpName = 'plugin-mcp' satisfies PluginMcp['name']
 
-export const pluginMcp = createPlugin<PluginMcp>((options) => {
+export const pluginMcp = definePlugin<PluginMcp>((options) => {
   const {
     output = { path: 'mcp', barrelType: 'named' },
     group,
@@ -23,127 +25,100 @@ export const pluginMcp = createPlugin<PluginMcp>((options) => {
     override = [],
     paramsCasing,
     client,
-    compatibilityPreset = 'default',
     resolver: userResolver,
     transformer: userTransformer,
     generators: userGenerators = [],
+    compatibilityPreset = 'default',
   } = options
 
+  const defaultServerGenerator = compatibilityPreset === 'kubbV4' ? serverGeneratorLegacy : serverGenerator
+
   const clientName = client?.client ?? 'axios'
   const clientImportPath = client?.importPath ?? (!client?.bundle ? `@kubb/plugin-client/clients/${clientName}` : undefined)
 
-  const preset = getPreset({
-    preset: compatibilityPreset,
-    presets,
-    resolver: userResolver,
-    transformer: userTransformer,
-    generators: userGenerators,
-  })
-
-  const generators = preset.generators ?? []
-  const mergedGenerator = mergeGenerators(generators)
+  const groupConfig = group
+    ? ({
+        ...group,
+        name: group.name
+          ? group.name
+          : (ctx: { group: string }) => {
+              if (group.type === 'path') {
+                return `${ctx.group.split('/')[1]}`
+              }
+              return `${camelCase(ctx.group)}Requests`
+            },
+      } satisfies Group)
+    : undefined
 
   return {
     name: pluginMcpName,
-    version,
-    get resolver() {
-      return preset.resolver
-    },
-    get transformer() {
-      return preset.transformer
-    },
-    get options() {
-      return {
-        output,
-        exclude,
-        include,
-        override,
-        group: group
-          ? ({
-              ...group,
-              name: group.name
-                ? group.name
-                : (ctx: { group: string }) => {
-                    if (group.type === 'path') {
-                      return `${ctx.group.split('/')[1]}`
-                    }
-                    return `${camelCase(ctx.group)}Requests`
-                  },
-            } satisfies Group)
-          : undefined,
-        paramsCasing,
-        client: {
-          client: clientName,
-          clientType: client?.clientType ?? 'function',
-          importPath: clientImportPath,
-          dataReturnType: client?.dataReturnType ?? 'data',
-          bundle: client?.bundle,
-          baseURL: client?.baseURL,
-          paramsCasing: client?.paramsCasing,
-        },
-        resolver: preset.resolver,
-      }
-    },
-    pre: [pluginTsName, pluginZodName].filter(Boolean),
-    async schema(node, options) {
-      return mergedGenerator.schema?.call(this, node, options)
-    },
-    async operation(node, options) {
-      return mergedGenerator.operation?.call(this, node, options)
-    },
-    async operations(nodes, options) {
-      return mergedGenerator.operations?.call(this, nodes, options)
-    },
-    async buildStart() {
-      const { adapter, driver } = this
-      const root = this.root
+    options,
+    dependencies: [pluginTsName, pluginZodName],
+    hooks: {
+      'kubb:plugin:setup'(ctx) {
+        const resolver = userResolver ? { ...resolverMcp, ...userResolver } : resolverMcp
 
-      const baseURL = adapter?.inputNode?.meta?.baseURL
-      if (baseURL) {
-        this.plugin.options.client.baseURL = this.plugin.options.client.baseURL || baseURL
-      }
+        ctx.setOptions({
+          output,
+          exclude,
+          include,
+          override,
+          group: groupConfig,
+          paramsCasing,
+          client: {
+            client: clientName,
+            clientType: client?.clientType ?? 'function',
+            importPath: clientImportPath,
+            dataReturnType: client?.dataReturnType ?? 'data',
+            bundle: client?.bundle,
+            baseURL: client?.baseURL,
+            paramsCasing: client?.paramsCasing,
+          },
+          resolver,
+        })
+        ctx.setResolver(resolver)
+        if (userTransformer) {
+          ctx.setTransformer(userTransformer)
+        }
+        ctx.addGenerator(mcpGenerator)
+        ctx.addGenerator(defaultServerGenerator)
+        for (const gen of userGenerators) {
+          ctx.addGenerator(gen)
+        }
 
-      const hasClientPlugin = !!driver.getPlugin(pluginClientName)
+        const root = path.resolve(ctx.config.root, ctx.config.output.path)
+        const hasClientPlugin = ctx.config.plugins?.some((p) => p.name === pluginClientName)
 
-      if (this.plugin.options.client.bundle && !hasClientPlugin && !this.plugin.options.client.importPath) {
-        await this.addFile(
-          createFile({
+        if (client?.bundle && !hasClientPlugin && !clientImportPath) {
+          ctx.injectFile({
             baseName: 'fetch.ts',
             path: path.resolve(root, '.kubb/fetch.ts'),
             sources: [
-              createSource({
+              ast.createSource({
                 name: 'fetch',
-                nodes: [createText(this.plugin.options.client.client === 'fetch' ? fetchClientSource : axiosClientSource)],
+                nodes: [ast.createText(clientName === 'fetch' ? fetchClientSource : axiosClientSource)],
                 isExportable: true,
                 isIndexable: true,
               }),
             ],
-            imports: [],
-            exports: [],
-          }),
-        )
-      }
+          })
+        }
 
-      if (!hasClientPlugin) {
-        await this.addFile(
-          createFile({
+        if (!hasClientPlugin) {
+          ctx.injectFile({
             baseName: 'config.ts',
             path: path.resolve(root, '.kubb/config.ts'),
             sources: [
-              createSource({
+              ast.createSource({
                 name: 'config',
-                nodes: [createText(configSource)],
+                nodes: [ast.createText(configSource)],
                 isExportable: false,
                 isIndexable: false,
               }),
             ],
-            imports: [],
-            exports: [],
-          }),
-        )
-      }
-
-      await this.openInStudio({ ast: true })
+          })
+        }
+      },
     },
   }
 })

package/src/types.ts

@@ -1,5 +1,5 @@
-import type { Visitor } from '@kubb/ast/types'
 import type {
+  ast,
   CompatibilityPreset,
   Exclude,
   Generator,
@@ -74,7 +74,7 @@ export type Options = {
    * A single AST visitor applied before printing.
    * When a visitor method returns `null` or `undefined`, the preset transformer's result is used instead.
    */
-  transformer?: Visitor
+  transformer?: ast.Visitor
   /**
    * Define some generators next to the default MCP generators.
    */

package/src/utils.ts

@@ -1,14 +1,14 @@
 import { camelCase } from '@internals/utils'
-import type { OperationNode, SchemaNode, StatusCode } from '@kubb/ast/types'
+import type { ast } from '@kubb/core'
 
 /**
  * Find the first 2xx response status code from an operation's responses.
  */
-export function findSuccessStatusCode(responses: Array<{ statusCode: number | string }>): StatusCode | undefined {
+export function findSuccessStatusCode(responses: Array<{ statusCode: number | string }>): ast.StatusCode | undefined {
   for (const res of responses) {
     const code = Number(res.statusCode)
     if (code >= 200 && code < 300) {
-      return res.statusCode as StatusCode
+      return res.statusCode as ast.StatusCode
     }
   }
   return undefined
@@ -34,7 +34,7 @@ export function zodGroupExpr(entry: string | Array<ZodParam>): string {
 /**
  * Build JSDoc comment lines from an OperationNode.
  */
-export function getComments(node: OperationNode): Array<string> {
+export function getComments(node: ast.OperationNode): Array<string> {
   return [
     node.description && `@description ${node.description}`,
     node.summary && `@summary ${node.summary}`,
@@ -70,7 +70,7 @@ export function getParamsMapping(params: Array<{ name: string }>): Record<string
  * Convert a SchemaNode type to an inline Zod expression string.
  * Used as fallback when no named zod schema is available for a path parameter.
  */
-export function zodExprFromSchemaNode(schema: SchemaNode): string {
+export function zodExprFromSchemaNode(schema: ast.SchemaNode): string {
   let expr: string
   switch (schema.type) {
     case 'enum': {

package/src/presets.ts

@@ -1,25 +0,0 @@
-import { definePresets } from '@kubb/core'
-import { mcpGenerator } from './generators/mcpGenerator.tsx'
-import { serverGenerator } from './generators/serverGenerator.tsx'
-import { serverGeneratorLegacy } from './generators/serverGeneratorLegacy.tsx'
-import { resolverMcp } from './resolvers/resolverMcp.ts'
-import type { ResolverMcp } from './types.ts'
-
-/**
- * Built-in preset registry for `@kubb/plugin-mcp`.
- *
- * - `default` — v5 naming with individual zod schemas and per-status responses.
- * - `kubbV4`  — legacy naming with grouped zod schemas and combined responses.
- */
-export const presets = definePresets<ResolverMcp>({
-  default: {
-    name: 'default',
-    resolver: resolverMcp,
-    generators: [mcpGenerator, serverGenerator],
-  },
-  kubbV4: {
-    name: 'kubbV4',
-    resolver: resolverMcp,
-    generators: [mcpGenerator, serverGeneratorLegacy],
-  },
-})