@kubb/plugin-mcp 5.0.0-beta.10 → 5.0.0-beta.103

package/src/components/Server.tsx

@@ -1,154 +0,0 @@
-import { getOperationParameters } from '@internals/shared'
-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'
-import type { PluginMcp } from '../types.ts'
-import type { ZodParam } from '../utils.ts'
-import { zodExprFromSchemaNode, zodGroupExpr } from '../utils.ts'
-
-type Props = {
-  /**
-   * Variable name for the MCP server instance (e.g. 'server').
-   */
-  name: string
-  /**
-   * Human-readable server name passed to `new McpServer({ name })`.
-   */
-  serverName: string
-  /**
-   * Semantic version string passed to `new McpServer({ version })`.
-   */
-  serverVersion: string
-  /**
-   * How to style your params.
-   */
-  paramsCasing?: PluginMcp['resolvedOptions']['paramsCasing']
-  /**
-   * Operations to register as MCP tools, each carrying its handler,
-   * zod schema, and AST node metadata.
-   */
-  operations: Array<{
-    tool: {
-      name: string
-      title?: string
-      description: string
-    }
-    mcp: {
-      name: string
-      file: ast.FileNode
-    }
-    zod: {
-      pathParams: Array<ZodParam>
-      /**
-       * Query params — individual schemas to compose into `z.object({ ... })`.
-       */
-      queryParams?: string | Array<ZodParam>
-      /**
-       * Header params — individual schemas to compose into `z.object({ ... })`.
-       */
-      headerParams?: string | Array<ZodParam>
-      requestName?: string
-      responseName?: string
-    }
-    node: ast.OperationNode
-  }>
-}
-
-const keysPrinter = functionPrinter({ mode: 'keys' })
-
-export function Server({ name, serverName, serverVersion, paramsCasing, operations }: Props): KubbReactNode {
-  return (
-    <File.Source name={name} isExportable isIndexable>
-      <Const name={'server'} export>
-        {`
-          new McpServer({
-  name: '${serverName}',
-  version: '${serverVersion}',
-})
-          `}
-      </Const>
-
-      {operations
-        .map(({ tool, mcp, zod, node }) => {
-          const { path: pathParams } = getOperationParameters(node, { paramsCasing })
-
-          const pathEntries: Array<{ key: string; value: string }> = []
-          const otherEntries: Array<{ key: string; value: string }> = []
-
-          for (const p of pathParams) {
-            const zodParam = zod.pathParams.find((zp) => zp.name === p.name)
-            pathEntries.push({ key: p.name, value: zodParam ? zodParam.schemaName : zodExprFromSchemaNode(p.schema) })
-          }
-
-          if (zod.requestName) {
-            otherEntries.push({ key: 'data', value: zod.requestName })
-          }
-
-          if (zod.queryParams) {
-            otherEntries.push({ key: 'params', value: zodGroupExpr(zod.queryParams) })
-          }
-
-          if (zod.headerParams) {
-            otherEntries.push({ key: 'headers', value: zodGroupExpr(zod.headerParams) })
-          }
-
-          otherEntries.sort((a, b) => a.key.localeCompare(b.key))
-          const entries = [...pathEntries, ...otherEntries]
-
-          const paramsNode = entries.length
-            ? ast.createFunctionParameters({
-                params: [
-                  ast.createParameterGroup({
-                    properties: entries.map((e) => ast.createFunctionParameter({ name: e.key, optional: false })),
-                  }),
-                ],
-              })
-            : undefined
-
-          const destructured = paramsNode ? (keysPrinter.print(paramsNode) ?? '') : ''
-          const inputSchema = entries.length ? `{ ${entries.map((e) => `${e.key}: ${e.value}`).join(', ')} }` : undefined
-          const outputSchema = zod.responseName
-
-          const config = [
-            tool.title ? `title: ${JSON.stringify(tool.title)}` : null,
-            `description: ${JSON.stringify(tool.description)}`,
-            outputSchema ? `outputSchema: { data: ${outputSchema} }` : null,
-          ]
-            .filter(Boolean)
-            .join(',\n  ')
-
-          if (inputSchema) {
-            return `
-server.registerTool(${JSON.stringify(tool.name)}, {
-  ${config},
-  inputSchema: ${inputSchema},
-}, async (${destructured}, request) => {
-  return ${mcp.name}(${destructured}, request)
-})
-          `
-          }
-
-          return `
-server.registerTool(${JSON.stringify(tool.name)}, {
-  ${config},
-}, async (request) => {
-  return ${mcp.name}(request)
-})
-          `
-        })
-        .filter(Boolean)}
-
-      <Function name="startServer" async export>
-        {`try {
-    const transport = new StdioServerTransport()
-    await server.connect(transport)
-
-  } catch (error) {
-    console.error('Failed to start server:', error)
-    process.exit(1)
-  }`}
-      </Function>
-    </File.Source>
-  )
-}

package/src/generators/mcpGenerator.tsx

@@ -1,79 +0,0 @@
-import path from 'node:path'
-import { resolveOperationTypeNames } from '@internals/shared'
-import { defineGenerator } from '@kubb/core'
-import { pluginTsName } from '@kubb/plugin-ts'
-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',
-  renderer: jsxRenderer,
-  operation(node, ctx) {
-    const { resolver, driver, root } = ctx
-    const { output, client, paramsCasing, group } = ctx.options
-
-    const pluginTs = driver.getPlugin(pluginTsName)
-
-    if (!pluginTs) {
-      return null
-    }
-
-    const tsResolver = driver.getResolver(pluginTsName)
-
-    const importedTypeNames = resolveOperationTypeNames(node, tsResolver, { paramsCasing, responseStatusNames: 'error' })
-
-    const meta = {
-      name: resolver.resolveHandlerName(node),
-      file: resolver.resolveFile({ name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path }, { root, output, group }),
-      fileTs: tsResolver.resolveFile(
-        { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
-        {
-          root,
-          output: pluginTs.options?.output ?? output,
-          group: pluginTs.options?.group,
-        },
-      ),
-    } as const
-
-    return (
-      <File baseName={meta.file.baseName} path={meta.file.path} meta={meta.file.meta}>
-        {meta.fileTs && importedTypeNames.length > 0 && (
-          <File.Import name={Array.from(new Set(importedTypeNames)).sort()} root={meta.file.path} path={meta.fileTs.path} isTypeOnly />
-        )}
-        <File.Import name={['CallToolResult', 'ServerNotification', 'ServerRequest']} path={'@modelcontextprotocol/sdk/types'} isTypeOnly />
-        <File.Import name={['RequestHandlerExtra']} path={'@modelcontextprotocol/sdk/shared/protocol'} isTypeOnly />
-        <File.Import name={['buildFormData']} root={meta.file.path} path={path.resolve(root, '.kubb/config.ts')} />
-        {client.importPath ? (
-          <>
-            <File.Import name={['Client', 'RequestConfig', 'ResponseErrorConfig']} path={client.importPath} isTypeOnly />
-            <File.Import name={'fetch'} path={client.importPath} />
-            {client.dataReturnType === 'full' && <File.Import name={['ResponseConfig']} path={client.importPath} isTypeOnly />}
-          </>
-        ) : (
-          <>
-            <File.Import
-              name={['Client', 'RequestConfig', 'ResponseErrorConfig']}
-              root={meta.file.path}
-              path={path.resolve(root, '.kubb/fetch.ts')}
-              isTypeOnly
-            />
-            <File.Import name={['fetch']} root={meta.file.path} path={path.resolve(root, '.kubb/fetch.ts')} />
-            {client.dataReturnType === 'full' && (
-              <File.Import name={['ResponseConfig']} root={meta.file.path} path={path.resolve(root, '.kubb/fetch.ts')} isTypeOnly />
-            )}
-          </>
-        )}
-
-        <McpHandler
-          name={meta.name}
-          node={node}
-          resolver={tsResolver}
-          baseURL={client.baseURL}
-          dataReturnType={client.dataReturnType || 'data'}
-          paramsCasing={paramsCasing}
-        />
-      </File>
-    )
-  },
-})

package/src/generators/serverGenerator.tsx

@@ -1,146 +0,0 @@
-import path from 'node:path'
-import { findSuccessStatusCode, getOperationParameters } from '@internals/shared'
-import { defineGenerator } from '@kubb/core'
-import { pluginZodName } from '@kubb/plugin-zod'
-import { File, jsxRenderer } from '@kubb/renderer-jsx'
-import { Server } from '../components/Server.tsx'
-import type { PluginMcp } from '../types.ts'
-
-/**
- * Default v5 server generator for `@kubb/plugin-mcp`.
- *
- * Uses individual zod schemas for each param (e.g. `createPetsPathUuidSchema`, `createPetsQueryOffsetSchema`)
- * and `resolveResponseStatusName` for per-status response schemas.
- * Query and header params are composed into `z.object({ ... })` from individual schemas.
- */
-export const serverGenerator = defineGenerator<PluginMcp>({
-  name: 'operations',
-  renderer: jsxRenderer,
-  operations(nodes, ctx) {
-    const { adapter, config, resolver, plugin, driver, root } = ctx
-    const { output, paramsCasing, group } = ctx.options
-
-    const pluginZod = driver.getPlugin(pluginZodName)
-
-    if (!pluginZod) {
-      return
-    }
-
-    const zodResolver = driver.getResolver(pluginZodName)
-
-    const name = 'server'
-    const serverFilePath = path.resolve(root, output.path, 'server.ts')
-    const serverFile = {
-      baseName: 'server.ts' as const,
-      path: serverFilePath,
-      meta: { pluginName: plugin.name },
-    }
-
-    const jsonFilePath = path.resolve(root, output.path, '.mcp.json')
-    const jsonFile = {
-      baseName: '.mcp.json' as const,
-      path: jsonFilePath,
-      meta: { pluginName: plugin.name },
-    }
-
-    const operationsMapped = nodes.map((node) => {
-      const { path: pathParams, query: queryParams, header: headerParams } = getOperationParameters(node, { paramsCasing })
-
-      const mcpFile = resolver.resolveFile({ name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path }, { root, output, group })
-
-      const zodFile = zodResolver.resolveFile(
-        { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
-        {
-          root,
-          output: pluginZod.options?.output ?? output,
-          group: pluginZod.options?.group,
-        },
-      )
-
-      const requestName = node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName(node) : undefined
-      const successStatus = findSuccessStatusCode(node.responses)
-      const responseName = successStatus ? zodResolver.resolveResponseStatusName(node, successStatus) : undefined
-
-      const resolveParams = (params: typeof pathParams) => params.map((p) => ({ name: p.name, schemaName: zodResolver.resolveParamName(node, p) }))
-
-      return {
-        tool: {
-          name: node.operationId,
-          title: node.summary || undefined,
-          description: node.description || `Make a ${node.method.toUpperCase()} request to ${node.path}`,
-        },
-        mcp: {
-          name: resolver.resolveHandlerName(node),
-          file: mcpFile,
-        },
-        zod: {
-          pathParams: resolveParams(pathParams),
-          queryParams: queryParams.length ? resolveParams(queryParams) : undefined,
-          headerParams: headerParams.length ? resolveParams(headerParams) : undefined,
-          requestName,
-          responseName,
-          file: zodFile,
-        },
-        node: node,
-      }
-    })
-
-    const imports = operationsMapped.flatMap(({ mcp, zod }) => {
-      const zodNames = [
-        ...zod.pathParams.map((p) => p.schemaName),
-        ...(zod.queryParams ?? []).map((p) => p.schemaName),
-        ...(zod.headerParams ?? []).map((p) => p.schemaName),
-        zod.requestName,
-        zod.responseName,
-      ].filter((name): name is string => Boolean(name))
-
-      const uniqueNames = [...new Set(zodNames)].sort()
-
-      return [
-        <File.Import key={mcp.name} name={[mcp.name]} root={serverFile.path} path={mcp.file.path} />,
-        uniqueNames.length > 0 && <File.Import key={`zod-${mcp.name}`} name={uniqueNames} root={serverFile.path} path={zod.file.path} />,
-      ].filter(Boolean)
-    })
-
-    return (
-      <>
-        <File
-          baseName={serverFile.baseName}
-          path={serverFile.path}
-          meta={serverFile.meta}
-          banner={resolver.resolveBanner(adapter.inputNode, { output, config })}
-          footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
-        >
-          <File.Import name={['McpServer']} path={'@modelcontextprotocol/sdk/server/mcp'} />
-          <File.Import name={['z']} path={'zod'} />
-          <File.Import name={['StdioServerTransport']} path={'@modelcontextprotocol/sdk/server/stdio'} />
-
-          {imports}
-          <Server
-            name={name}
-            serverName={adapter.inputNode?.meta?.title ?? 'server'}
-            serverVersion={adapter.inputNode?.meta?.version ?? '0.0.0'}
-            paramsCasing={paramsCasing}
-            operations={operationsMapped}
-          />
-        </File>
-
-        <File baseName={jsonFile.baseName} path={jsonFile.path} meta={jsonFile.meta}>
-          <File.Source name={name}>
-            {`
-          {
-            "mcpServers": {
-              "${adapter.inputNode?.meta?.title || 'server'}": {
-                "type": "stdio",
-                "command": "npx",
-                "args": ["tsx", "${path.relative(path.dirname(jsonFile.path), serverFile.path)}"]
-              }
-            }
-          }
-          `}
-          </File.Source>
-        </File>
-      </>
-    )
-  },
-})

package/src/index.ts

@@ -1,11 +0,0 @@
-export { McpHandler } from './components/McpHandler.tsx'
-export { Server } from './components/Server.tsx'
-
-export { mcpGenerator } from './generators/mcpGenerator.tsx'
-export { serverGenerator } from './generators/serverGenerator.tsx'
-
-export { default, pluginMcp, pluginMcpName } from './plugin.ts'
-
-export { resolverMcp } from './resolvers/resolverMcp.ts'
-
-export type { PluginMcp, ResolverMcp } from './types.ts'

package/src/plugin.ts

@@ -1,122 +0,0 @@
-import path from 'node:path'
-import { camelCase } from '@internals/utils'
-
-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 { mcpGenerator } from './generators/mcpGenerator.tsx'
-import { serverGenerator } from './generators/serverGenerator.tsx'
-import { resolverMcp } from './resolvers/resolverMcp.ts'
-import type { PluginMcp } from './types.ts'
-
-export const pluginMcpName = 'plugin-mcp' satisfies PluginMcp['name']
-
-export const pluginMcp = definePlugin<PluginMcp>((options) => {
-  const {
-    output = { path: 'mcp', barrelType: 'named' },
-    group,
-    exclude = [],
-    include,
-    override = [],
-    paramsCasing,
-    client,
-    resolver: userResolver,
-    transformer: userTransformer,
-    generators: userGenerators = [],
-  } = options
-
-  const clientName = client?.client ?? 'axios'
-  const clientImportPath = client?.importPath ?? (!client?.bundle ? `@kubb/plugin-client/clients/${clientName}` : undefined)
-
-  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,
-    options,
-    dependencies: [pluginTsName, pluginZodName],
-    hooks: {
-      'kubb:plugin:setup'(ctx) {
-        const resolver = userResolver ? { ...resolverMcp, ...userResolver } : resolverMcp
-
-        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(serverGenerator)
-        for (const gen of userGenerators) {
-          ctx.addGenerator(gen)
-        }
-
-        const root = path.resolve(ctx.config.root, ctx.config.output.path)
-        const hasClientPlugin = ctx.config.plugins?.some((p) => p.name === pluginClientName)
-
-        if (client?.bundle && !hasClientPlugin && !clientImportPath) {
-          ctx.injectFile({
-            baseName: 'fetch.ts',
-            path: path.resolve(root, '.kubb/fetch.ts'),
-            sources: [
-              ast.createSource({
-                name: 'fetch',
-                nodes: [ast.createText(clientName === 'fetch' ? fetchClientSource : axiosClientSource)],
-                isExportable: true,
-                isIndexable: true,
-              }),
-            ],
-          })
-        }
-
-        if (!hasClientPlugin) {
-          ctx.injectFile({
-            baseName: 'config.ts',
-            path: path.resolve(root, '.kubb/config.ts'),
-            sources: [
-              ast.createSource({
-                name: 'config',
-                nodes: [ast.createText(configSource)],
-                isExportable: false,
-                isIndexable: false,
-              }),
-            ],
-          })
-        }
-      },
-    },
-  }
-})
-
-export default pluginMcp

package/src/resolvers/resolverMcp.ts

@@ -1,31 +0,0 @@
-import { camelCase } from '@internals/utils'
-import { defineResolver } from '@kubb/core'
-import type { PluginMcp } from '../types.ts'
-
-/**
- * Naming convention resolver for MCP plugin.
- *
- * Provides default naming helpers using camelCase with a `handler` suffix for functions.
- *
- * @example
- * `resolverMcp.default('addPet', 'function')  // → 'addPetHandler'`
- */
-export const resolverMcp = defineResolver<PluginMcp>(() => ({
-  name: 'default',
-  pluginName: 'plugin-mcp',
-  default(name, type) {
-    if (type === 'file') {
-      return camelCase(name, { isFile: true })
-    }
-    return camelCase(name, { suffix: 'handler' })
-  },
-  resolveName(name) {
-    return this.default(name, 'function')
-  },
-  resolvePathName(name, type) {
-    return this.default(name, type)
-  },
-  resolveHandlerName(node) {
-    return this.resolveName(node.operationId)
-  },
-}))

package/src/types.ts

@@ -1,88 +0,0 @@
-import type { ast, Exclude, Generator, Group, Include, Output, Override, PluginFactoryOptions, Resolver } from '@kubb/core'
-import type { ClientImportPath, PluginClient } from '@kubb/plugin-client'
-
-/**
- * Resolver for MCP that provides naming methods for handler functions.
- */
-export type ResolverMcp = Resolver & {
-  /**
-   * Resolves the base handler function name for an operation.
-   *
-   * @example Resolving handler function names
-   * `resolver.resolveName('show pet by id') // -> 'showPetByIdHandler'`
-   */
-  resolveName(this: ResolverMcp, name: string): string
-  /**
-   * Resolves the output file name for an MCP module.
-   */
-  resolvePathName(this: ResolverMcp, name: string, type?: 'file' | 'function' | 'type' | 'const'): string
-  /**
-   * Resolves the handler function name for an operation.
-   */
-  resolveHandlerName(this: ResolverMcp, node: ast.OperationNode): string
-}
-
-export type Options = {
-  /**
-   * Specify the export location for the files and define the behavior of the output.
-   * @default { path: 'mcp', barrelType: 'named' }
-   */
-  output?: Output
-  /**
-   * Client configuration for HTTP request generation.
-   */
-  client?: ClientImportPath & Pick<PluginClient['options'], 'clientType' | 'dataReturnType' | 'baseURL' | 'bundle' | 'paramsCasing'>
-  /**
-   * Apply casing to parameter names to match your configuration.
-   */
-  paramsCasing?: 'camelcase'
-  /**
-   * Group the MCP requests based on the provided name.
-   */
-  group?: Group
-  /**
-   * Tags, operations, or paths to exclude from generation.
-   */
-  exclude?: Array<Exclude>
-  /**
-   * Tags, operations, or paths to include in generation.
-   */
-  include?: Array<Include>
-  /**
-   * Override options for specific tags, operations, or paths.
-   */
-  override?: Array<Override<ResolvedOptions>>
-  /**
-   * Override naming conventions for function names and types.
-   */
-  resolver?: Partial<ResolverMcp> & ThisType<ResolverMcp>
-  /**
-   * AST visitor to transform generated nodes.
-   */
-  transformer?: ast.Visitor
-  /**
-   * Additional generators alongside the default generators.
-   */
-  generators?: Array<Generator<PluginMcp>>
-}
-
-type ResolvedOptions = {
-  output: Output
-  exclude: Array<Exclude>
-  include: Array<Include> | undefined
-  override: Array<Override<ResolvedOptions>>
-  group: Group | undefined
-  client: Pick<PluginClient['options'], 'client' | 'clientType' | 'dataReturnType' | 'importPath' | 'baseURL' | 'bundle' | 'paramsCasing'>
-  paramsCasing: Options['paramsCasing']
-  resolver: ResolverMcp
-}
-
-export type PluginMcp = PluginFactoryOptions<'plugin-mcp', Options, ResolvedOptions, ResolverMcp>
-
-declare global {
-  namespace Kubb {
-    interface PluginRegistry {
-      'plugin-mcp': PluginMcp
-    }
-  }
-}