@kubb/plugin-mcp 5.0.0-beta.42 → 5.0.0-beta.64

package/src/components/McpHandler.tsx

@@ -1,168 +0,0 @@
-import { buildOperationComments, buildTransformedParamsMapping, getOperationParameters } from '@internals/shared'
-import { camelCase, isValidVarName, URLPath } from '@internals/utils'
-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'
-import type { KubbReactNode } from '@kubb/renderer-jsx/types'
-import type { PluginMcp } from '../types.ts'
-
-type Props = {
-  /**
-   * Name of the handler function.
-   */
-  name: string
-  /**
-   * AST operation node.
-   */
-  node: ast.OperationNode
-  /**
-   * TypeScript resolver for resolving param/data/response type names.
-   */
-  resolver: ResolverTs
-  /**
-   * Base URL prepended to every generated request URL.
-   */
-  baseURL: string | null | undefined
-  /**
-   * Return type when calling fetch.
-   * - 'data' returns response data only.
-   * - 'full' returns the full response object.
-   * @default 'data'
-   */
-  dataReturnType: PluginMcp['resolvedOptions']['client']['dataReturnType']
-  /**
-   * How to style your params.
-   */
-  paramsCasing?: PluginMcp['resolvedOptions']['paramsCasing']
-}
-
-/**
- * Generate a remapping statement: `const mappedX = x ? { "orig": x.camel, ... } : undefined`
- */
-function buildRemappingCode(mapping: Record<string, string>, varName: string, sourceName: string): string {
-  const pairs = Object.entries(mapping)
-    .map(([orig, camel]) => `"${orig}": ${sourceName}.${camel}`)
-    .join(', ')
-  return `const ${varName} = ${sourceName} ? { ${pairs} } : undefined`
-}
-
-const declarationPrinter = functionPrinter({ mode: 'declaration' })
-
-export function McpHandler({ name, node, resolver, baseURL, dataReturnType, paramsCasing }: Props): KubbReactNode {
-  if (!ast.isHttpOperationNode(node)) return null
-  const urlPath = new URLPath(node.path)
-  const contentType = node.requestBody?.content?.[0]?.contentType
-  const isFormData = contentType === 'multipart/form-data'
-
-  const { query: queryParams, header: headerParams } = getOperationParameters(node, { paramsCasing })
-  const { path: originalPathParams, query: originalQueryParams, header: originalHeaderParams } = getOperationParameters(node)
-
-  const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : null
-  const responseName = resolver.resolveResponseName(node)
-
-  const errorResponses = node.responses.filter((r) => Number(r.statusCode) >= 400).map((r) => resolver.resolveResponseStatusName(node, r.statusCode))
-  const errorType = errorResponses.length > 0 ? errorResponses.join(' | ') : 'Error'
-
-  const TError = `ResponseErrorConfig<${errorType}>`
-  const generics = [responseName, TError, requestName || 'unknown'].filter(Boolean)
-
-  const paramsNode = ast.createOperationParams(node, {
-    paramsType: 'object',
-    pathParamsType: 'inline',
-    resolver,
-    paramsCasing,
-  })
-  const baseParamsSignature = declarationPrinter.print(paramsNode) ?? ''
-  const paramsSignature = baseParamsSignature
-    ? `${baseParamsSignature}, request: RequestHandlerExtra<ServerRequest, ServerNotification>`
-    : 'request: RequestHandlerExtra<ServerRequest, ServerNotification>'
-
-  const pathParamsMapping = paramsCasing ? buildTransformedParamsMapping(originalPathParams, camelCase) : null
-  const queryParamsMapping = paramsCasing ? buildTransformedParamsMapping(originalQueryParams, camelCase) : null
-  const headerParamsMapping = paramsCasing ? buildTransformedParamsMapping(originalHeaderParams, camelCase) : null
-
-  const contentTypeHeader =
-    contentType && contentType !== 'application/json' && contentType !== 'multipart/form-data' ? `'Content-Type': '${contentType}'` : null
-  const headers = [headerParams.length ? (headerParamsMapping ? '...mappedHeaders' : '...headers') : null, contentTypeHeader].filter(Boolean)
-
-  const fetchConfig: Array<string> = []
-  fetchConfig.push(`method: ${JSON.stringify(node.method.toUpperCase())}`)
-  fetchConfig.push(`url: ${urlPath.template}`)
-  if (baseURL) fetchConfig.push(`baseURL: \`${baseURL}\``)
-  if (queryParams.length) fetchConfig.push(queryParamsMapping ? 'params: mappedParams' : 'params')
-  if (requestName) fetchConfig.push(`data: ${isFormData ? 'formData as FormData' : 'requestData'}`)
-  if (headers.length) fetchConfig.push(`headers: { ${headers.join(', ')} }`)
-
-  const callToolResult =
-    dataReturnType === 'data'
-      ? `return {
-            content: [
-              {
-                type: 'text',
-                text: JSON.stringify(res.data)
-              }
-            ],
-            structuredContent: { data: res.data }
-           }`
-      : `return {
-            content: [
-              {
-                type: 'text',
-                text: JSON.stringify(res)
-              }
-            ],
-            structuredContent: { data: res.data }
-           }`
-
-  return (
-    <File.Source name={name} isExportable isIndexable>
-      <Function
-        name={name}
-        async
-        export
-        params={paramsSignature}
-        JSDoc={{
-          comments: buildOperationComments(node),
-        }}
-        returnType={'Promise<CallToolResult>'}
-      >
-        {''}
-        <br />
-        <br />
-        {pathParamsMapping &&
-          Object.entries(pathParamsMapping)
-            .filter(([originalName, camelCaseName]) => originalName !== camelCaseName && isValidVarName(originalName))
-            .map(([originalName, camelCaseName]) => `const ${originalName} = ${camelCaseName}`)
-            .join('\n')}
-        {pathParamsMapping && (
-          <>
-            <br />
-            <br />
-          </>
-        )}
-        {queryParamsMapping && queryParams.length > 0 && (
-          <>
-            {buildRemappingCode(queryParamsMapping, 'mappedParams', 'params')}
-            <br />
-            <br />
-          </>
-        )}
-        {headerParamsMapping && headerParams.length > 0 && (
-          <>
-            {buildRemappingCode(headerParamsMapping, 'mappedHeaders', 'headers')}
-            <br />
-            <br />
-          </>
-        )}
-        {requestName && 'const requestData = data'}
-        <br />
-        {isFormData && requestName && 'const formData = buildFormData(requestData)'}
-        <br />
-        {`const res = await client<${generics.join(', ')}>({ ${fetchConfig.join(', ')} }, request)`}
-        <br />
-        {callToolResult}
-      </Function>
-    </File.Source>
-  )
-}

package/src/components/Server.tsx

@@ -1,159 +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> | null
-      /**
-       * Header params — individual schemas to compose into `z.object({ ... })`.
-       */
-      headerParams?: string | Array<ZodParam> | null
-      requestName?: string | null
-      responseName?: string | null
-    }
-    node: ast.OperationNode
-  }>
-}
-
-const keysPrinter = functionPrinter({ mode: 'keys' })
-
-export function Server({ name, serverName, serverVersion, paramsCasing, operations }: Props): KubbReactNode {
-  const registrations = 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 })),
-              }),
-            ],
-          })
-        : null
-
-      const destructured = paramsNode ? (keysPrinter.print(paramsNode) ?? '') : ''
-      const inputSchema = entries.length ? `{ ${entries.map((e) => `${e.key}: ${e.value}`).join(', ')} }` : null
-      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)
-    .join('\n')
-
-  return (
-    <File.Source name={name} isExportable isIndexable>
-      <Function name="getServer" export>
-        {`const server = new McpServer({
-  name: '${serverName}',
-  version: '${serverVersion}',
-})
-${registrations}
-return server`}
-      </Function>
-
-      <Const name={'server'} export>
-        {'getServer()'}
-      </Const>
-
-      <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,89 +0,0 @@
-import path from 'node:path'
-import { resolveOperationTypeNames } from '@internals/shared'
-import { ast, defineGenerator } from '@kubb/core'
-import { pluginTsName } from '@kubb/plugin-ts'
-import { File, jsxRendererSync } from '@kubb/renderer-jsx'
-import { McpHandler } from '../components/McpHandler.tsx'
-import type { PluginMcp } from '../types.ts'
-
-/**
- * Built-in operation generator for `@kubb/plugin-mcp`. Emits one MCP tool
- * handler per OpenAPI operation, wiring the input Zod schema, the HTTP call,
- * and the response shape into a single function that an MCP server can
- * register as a callable tool.
- */
-export const mcpGenerator = defineGenerator<PluginMcp>({
-  name: 'mcp',
-  renderer: jsxRendererSync,
-  operation(node, ctx) {
-    if (!ast.isHttpOperationNode(node)) return null
-    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: group ?? undefined },
-      ),
-      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 ?? undefined,
-        },
-      ),
-    } 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={'client'} 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/client.ts')}
-              isTypeOnly
-            />
-            <File.Import name={['client']} root={meta.file.path} path={path.resolve(root, '.kubb/client.ts')} />
-            {client.dataReturnType === 'full' && (
-              <File.Import name={['ResponseConfig']} root={meta.file.path} path={path.resolve(root, '.kubb/client.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,149 +0,0 @@
-import path from 'node:path'
-import { findSuccessStatusCode, getOperationParameters } from '@internals/shared'
-import { ast, defineGenerator } from '@kubb/core'
-import { pluginZodName } from '@kubb/plugin-zod'
-import { File, jsxRendererSync } 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: jsxRendererSync,
-  operations(nodes, ctx) {
-    const { 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.filter(ast.isHttpOperationNode).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: group ?? undefined },
-      )
-
-      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 ?? undefined,
-        },
-      )
-
-      const requestName = node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName(node) : null
-      const successStatus = findSuccessStatusCode(node.responses)
-      const responseName = successStatus ? zodResolver.resolveResponseStatusName(node, successStatus) : null
-
-      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) : null,
-          headerParams: headerParams.length ? resolveParams(headerParams) : null,
-          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(ctx.meta, { output, config, file: { path: serverFile.path, baseName: serverFile.baseName } })}
-          footer={resolver.resolveFooter(ctx.meta, { output, config, file: { path: serverFile.path, baseName: serverFile.baseName } })}
-        >
-          <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={ctx.meta.title ?? 'server'}
-            serverVersion={ctx.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": {
-              "${ctx.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'