@kubb/plugin-mcp 5.0.0-beta.4 → 5.0.0-beta.56

package/src/components/Server.tsx

@@ -1,3 +1,4 @@
+import { getOperationParameters } from '@internals/shared'
 import { ast } from '@kubb/core'
 import { functionPrinter } from '@kubb/plugin-ts'
 import { Const, File, Function } from '@kubb/renderer-jsx'
@@ -42,13 +43,13 @@ type Props = {
       /**
        * Query params — individual schemas to compose into `z.object({ ... })`.
        */
-      queryParams?: string | Array<ZodParam>
+      queryParams?: string | Array<ZodParam> | null
       /**
        * Header params — individual schemas to compose into `z.object({ ... })`.
        */
-      headerParams?: string | Array<ZodParam>
-      requestName?: string
-      responseName?: string
+      headerParams?: string | Array<ZodParam> | null
+      requestName?: string | null
+      responseName?: string | null
     }
     node: ast.OperationNode
   }>
@@ -57,69 +58,57 @@ type Props = {
 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 casedParams = ast.caseParams(node.parameters, paramsCasing)
-          const pathParams = casedParams.filter((p) => p.in === 'path')
-
-          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 `
+  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},
@@ -127,17 +116,33 @@ server.registerTool(${JSON.stringify(tool.name)}, {
   return ${mcp.name}(${destructured}, request)
 })
           `
-          }
+      }
 
-          return `
+      return `
 server.registerTool(${JSON.stringify(tool.name)}, {
   ${config},
 }, async (request) => {
   return ${mcp.name}(request)
 })
           `
-        })
-        .filter(Boolean)}
+    })
+    .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 {

package/src/generators/mcpGenerator.tsx

@@ -1,14 +1,22 @@
 import path from 'node:path'
+import { resolveOperationTypeNames } from '@internals/shared'
 import { ast, 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'
 
+/**
+ * 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: jsxRenderer,
   operation(node, ctx) {
+    if (!ast.isHttpOperationNode(node)) return null
     const { resolver, driver, root } = ctx
     const { output, client, paramsCasing, group } = ctx.options
 
@@ -20,30 +28,20 @@ export const mcpGenerator = defineGenerator<PluginMcp>({
 
     const tsResolver = driver.getResolver(pluginTsName)
 
-    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')
-
-    const importedTypeNames = [
-      ...pathParams.map((p) => tsResolver.resolvePathParamsName(node, p)),
-      ...queryParams.map((p) => tsResolver.resolveQueryParamsName(node, p)),
-      ...headerParams.map((p) => tsResolver.resolveHeaderParamsName(node, p)),
-      node.requestBody?.content?.[0]?.schema ? tsResolver.resolveDataName(node) : undefined,
-      tsResolver.resolveResponseName(node),
-      ...node.responses.filter((r) => Number(r.statusCode) >= 400).map((r) => tsResolver.resolveResponseStatusName(node, r.statusCode)),
-    ].filter(Boolean)
+    const importedTypeNames = resolveOperationTypeNames(node, tsResolver, { paramsCasing, responseStatusNames: 'error' })
 
     const meta = {
-      name: resolver.resolveName(node.operationId),
-      file: resolver.resolveFile({ name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path }, { root, output, group }),
+      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,
+          group: pluginTs.options?.group ?? undefined,
         },
       ),
     } as const
@@ -59,7 +57,7 @@ export const mcpGenerator = defineGenerator<PluginMcp>({
         {client.importPath ? (
           <>
             <File.Import name={['Client', 'RequestConfig', 'ResponseErrorConfig']} path={client.importPath} isTypeOnly />
-            <File.Import name={'fetch'} path={client.importPath} />
+            <File.Import name={'client'} path={client.importPath} />
             {client.dataReturnType === 'full' && <File.Import name={['ResponseConfig']} path={client.importPath} isTypeOnly />}
           </>
         ) : (
@@ -67,12 +65,12 @@ export const mcpGenerator = defineGenerator<PluginMcp>({
             <File.Import
               name={['Client', 'RequestConfig', 'ResponseErrorConfig']}
               root={meta.file.path}
-              path={path.resolve(root, '.kubb/fetch.ts')}
+              path={path.resolve(root, '.kubb/client.ts')}
               isTypeOnly
             />
-            <File.Import name={['fetch']} root={meta.file.path} path={path.resolve(root, '.kubb/fetch.ts')} />
+            <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/fetch.ts')} isTypeOnly />
+              <File.Import name={['ResponseConfig']} root={meta.file.path} path={path.resolve(root, '.kubb/client.ts')} isTypeOnly />
             )}
           </>
         )}

package/src/generators/serverGenerator.tsx

@@ -1,10 +1,10 @@
 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, jsxRenderer } from '@kubb/renderer-jsx'
 import { Server } from '../components/Server.tsx'
 import type { PluginMcp } from '../types.ts'
-import { findSuccessStatusCode } from '../utils.ts'
 
 /**
  * Default v5 server generator for `@kubb/plugin-mcp`.
@@ -17,7 +17,7 @@ export const serverGenerator = defineGenerator<PluginMcp>({
   name: 'operations',
   renderer: jsxRenderer,
   operations(nodes, ctx) {
-    const { adapter, config, resolver, plugin, driver, root } = ctx
+    const { config, resolver, plugin, driver, root } = ctx
     const { output, paramsCasing, group } = ctx.options
 
     const pluginZod = driver.getPlugin(pluginZodName)
@@ -43,26 +43,26 @@ export const serverGenerator = defineGenerator<PluginMcp>({
       meta: { pluginName: plugin.name },
     }
 
-    const operationsMapped = nodes.map((node) => {
-      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')
+    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 })
+      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,
+          group: pluginZod.options?.group ?? undefined,
         },
       )
 
-      const requestName = node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName(node) : undefined
+      const requestName = node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName(node) : null
       const successStatus = findSuccessStatusCode(node.responses)
-      const responseName = successStatus ? zodResolver.resolveResponseStatusName(node, successStatus) : undefined
+      const responseName = successStatus ? zodResolver.resolveResponseStatusName(node, successStatus) : null
 
       const resolveParams = (params: typeof pathParams) => params.map((p) => ({ name: p.name, schemaName: zodResolver.resolveParamName(node, p) }))
 
@@ -73,13 +73,13 @@ export const serverGenerator = defineGenerator<PluginMcp>({
           description: node.description || `Make a ${node.method.toUpperCase()} request to ${node.path}`,
         },
         mcp: {
-          name: resolver.resolveName(node.operationId),
+          name: resolver.resolveHandlerName(node),
           file: mcpFile,
         },
         zod: {
           pathParams: resolveParams(pathParams),
-          queryParams: queryParams.length ? resolveParams(queryParams) : undefined,
-          headerParams: headerParams.length ? resolveParams(headerParams) : undefined,
+          queryParams: queryParams.length ? resolveParams(queryParams) : null,
+          headerParams: headerParams.length ? resolveParams(headerParams) : null,
           requestName,
           responseName,
           file: zodFile,
@@ -95,7 +95,7 @@ export const serverGenerator = defineGenerator<PluginMcp>({
         ...(zod.headerParams ?? []).map((p) => p.schemaName),
         zod.requestName,
         zod.responseName,
-      ].filter(Boolean)
+      ].filter((name): name is string => Boolean(name))
 
       const uniqueNames = [...new Set(zodNames)].sort()
 
@@ -111,8 +111,8 @@ export const serverGenerator = defineGenerator<PluginMcp>({
           baseName={serverFile.baseName}
           path={serverFile.path}
           meta={serverFile.meta}
-          banner={resolver.resolveBanner(adapter.inputNode, { output, config })}
-          footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
+          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'} />
@@ -121,8 +121,8 @@ export const serverGenerator = defineGenerator<PluginMcp>({
           {imports}
           <Server
             name={name}
-            serverName={adapter.inputNode?.meta?.title ?? 'server'}
-            serverVersion={adapter.inputNode?.meta?.version ?? '0.0.0'}
+            serverName={ctx.meta.title ?? 'server'}
+            serverVersion={ctx.meta.version ?? '0.0.0'}
             paramsCasing={paramsCasing}
             operations={operationsMapped}
           />
@@ -133,7 +133,7 @@ export const serverGenerator = defineGenerator<PluginMcp>({
             {`
           {
             "mcpServers": {
-              "${adapter.inputNode?.meta?.title || 'server'}": {
+              "${ctx.meta.title || 'server'}": {
                 "type": "stdio",
                 "command": "npx",
                 "args": ["tsx", "${path.relative(path.dirname(jsonFile.path), serverFile.path)}"]

package/src/plugin.ts

@@ -1,7 +1,7 @@
 import path from 'node:path'
-import { camelCase } from '@internals/utils'
+import { createGroupConfig } from '@internals/shared'
 
-import { ast, definePlugin, type Group } from '@kubb/core'
+import { ast, definePlugin } 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'
@@ -13,11 +13,43 @@ import { serverGenerator } from './generators/serverGenerator.tsx'
 import { resolverMcp } from './resolvers/resolverMcp.ts'
 import type { PluginMcp } from './types.ts'
 
+/**
+ * Canonical plugin name for `@kubb/plugin-mcp`. Used for driver lookups and
+ * cross-plugin dependency references.
+ */
 export const pluginMcpName = 'plugin-mcp' satisfies PluginMcp['name']
 
+/**
+ * Generates a Model Context Protocol (MCP) server from an OpenAPI spec. Every
+ * operation becomes a typed MCP tool that AI assistants (Claude Desktop, Claude
+ * Code, MCP-compatible clients) can call directly.
+ *
+ * @example
+ * ```ts
+ * import { defineConfig } from 'kubb'
+ * import { pluginTs } from '@kubb/plugin-ts'
+ * import { pluginClient } from '@kubb/plugin-client'
+ * import { pluginZod } from '@kubb/plugin-zod'
+ * import { pluginMcp } from '@kubb/plugin-mcp'
+ *
+ * export default defineConfig({
+ *   input: { path: './petStore.yaml' },
+ *   output: { path: './src/gen' },
+ *   plugins: [
+ *     pluginTs(),
+ *     pluginClient(),
+ *     pluginZod(),
+ *     pluginMcp({
+ *       output: { path: './mcp' },
+ *       client: { baseURL: 'https://petstore.swagger.io/v2' },
+ *     }),
+ *   ],
+ * })
+ * ```
+ */
 export const pluginMcp = definePlugin<PluginMcp>((options) => {
   const {
-    output = { path: 'mcp', barrelType: 'named' },
+    output = { path: 'mcp', barrel: { type: 'named' } },
     group,
     exclude = [],
     include,
@@ -32,19 +64,7 @@ export const pluginMcp = definePlugin<PluginMcp>((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
+  const groupConfig = createGroupConfig(group)
 
   return {
     name: pluginMcpName,
@@ -87,11 +107,11 @@ export const pluginMcp = definePlugin<PluginMcp>((options) => {
 
         if (client?.bundle && !hasClientPlugin && !clientImportPath) {
           ctx.injectFile({
-            baseName: 'fetch.ts',
-            path: path.resolve(root, '.kubb/fetch.ts'),
+            baseName: 'client.ts',
+            path: path.resolve(root, '.kubb/client.ts'),
             sources: [
               ast.createSource({
-                name: 'fetch',
+                name: 'client',
                 nodes: [ast.createText(clientName === 'fetch' ? fetchClientSource : axiosClientSource)],
                 isExportable: true,
                 isIndexable: true,

package/src/resolvers/resolverMcp.ts

@@ -1,25 +1,35 @@
-import { camelCase } from '@internals/utils'
+import { camelCase, toFilePath } from '@internals/utils'
 import { defineResolver } from '@kubb/core'
 import type { PluginMcp } from '../types.ts'
 
 /**
- * Naming convention resolver for MCP plugin.
+ * Default resolver used by `@kubb/plugin-mcp`. Decides the names and file
+ * paths for every generated MCP tool handler. Function names get a `Handler`
+ * suffix so an operation `addPet` becomes `addPetHandler`.
  *
- * Provides default naming helpers using camelCase with a `handler` suffix for functions.
+ * @example Resolve a handler name
+ * ```ts
+ * import { resolverMcp } from '@kubb/plugin-mcp'
  *
- * @example
- * `resolverMcp.default('addPet', 'function')  // → 'addPetHandler'`
+ * resolverMcp.default('addPet', 'function') // 'addPetHandler'
+ * ```
  */
-export const resolverMcp = defineResolver<PluginMcp>((ctx) => ({
+export const resolverMcp = defineResolver<PluginMcp>(() => ({
   name: 'default',
   pluginName: 'plugin-mcp',
   default(name, type) {
     if (type === 'file') {
-      return camelCase(name, { isFile: true })
+      return toFilePath(name)
     }
     return camelCase(name, { suffix: 'handler' })
   },
   resolveName(name) {
-    return ctx.default(name, 'function')
+    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,4 +1,4 @@
-import type { ast, Exclude, Generator, Group, Include, Output, Override, PluginFactoryOptions, Resolver } from '@kubb/core'
+import type { ast, Exclude, Generator, Group, Include, Output, OutputOptions, Override, PluginFactoryOptions, Resolver } from '@kubb/core'
 import type { ClientImportPath, PluginClient } from '@kubb/plugin-client'
 
 /**
@@ -6,54 +6,64 @@ import type { ClientImportPath, PluginClient } from '@kubb/plugin-client'
  */
 export type ResolverMcp = Resolver & {
   /**
-   * Resolves the handler function name for an operation.
+   * 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
-}
-
-export type Options = {
   /**
-   * Specify the export location for the files and define the behavior of the output.
-   * @default { path: 'mcp', barrelType: 'named' }
+   * Resolves the output file name for an MCP module.
    */
-  output?: Output
+  resolvePathName(this: ResolverMcp, name: string, type?: 'file' | 'function' | 'type' | 'const'): string
   /**
-   * Client configuration for HTTP request generation.
+   * Resolves the handler function name for an operation.
    */
-  client?: ClientImportPath & Pick<PluginClient['options'], 'clientType' | 'dataReturnType' | 'baseURL' | 'bundle' | 'paramsCasing'>
+  resolveHandlerName(this: ResolverMcp, node: ast.OperationNode): string
+}
+
+/**
+ * Where the generated MCP tool handlers are written and how they are exported, plus the optional
+ * `group` strategy. The `group` option organizes `output.mode: 'directory'` output into per-tag or per-path subdirectories.
+ *
+ * @default { path: 'mcp', barrel: { type: 'named' } }
+ */
+export type Options = OutputOptions & {
   /**
-   * Apply casing to parameter names to match your configuration.
+   * HTTP client used by each MCP handler to call the underlying API. Mirrors a
+   * subset of `pluginClient` options.
    */
-  paramsCasing?: 'camelcase'
+  client?: ClientImportPath & Pick<PluginClient['options'], 'clientType' | 'dataReturnType' | 'baseURL' | 'bundle' | 'paramsCasing'>
   /**
-   * Group the MCP requests based on the provided name.
+   * Rename parameter properties in the generated handlers. The HTTP layer still
+   * uses the original spec names; Kubb writes the mapping for you.
+   *
+   * @note Must match the value of `paramsCasing` on `@kubb/plugin-ts`.
    */
-  group?: Group
+  paramsCasing?: 'camelcase'
   /**
-   * Tags, operations, or paths to exclude from generation.
+   * Skip operations matching at least one entry in the list.
    */
   exclude?: Array<Exclude>
   /**
-   * Tags, operations, or paths to include in generation.
+   * Restrict generation to operations matching at least one entry in the list.
    */
   include?: Array<Include>
   /**
-   * Override options for specific tags, operations, or paths.
+   * Apply a different options object to operations matching a pattern.
    */
   override?: Array<Override<ResolvedOptions>>
   /**
-   * Override naming conventions for function names and types.
+   * Override how handler names and file paths are built. Methods you omit fall
+   * back to the default `resolverMcp`.
    */
   resolver?: Partial<ResolverMcp> & ThisType<ResolverMcp>
   /**
-   * AST visitor to transform generated nodes.
+   * AST visitor applied to each operation node before printing.
    */
   transformer?: ast.Visitor
   /**
-   * Additional generators alongside the default generators.
+   * Custom generators that run alongside the built-in MCP generators.
    */
   generators?: Array<Generator<PluginMcp>>
 }
@@ -63,7 +73,7 @@ type ResolvedOptions = {
   exclude: Array<Exclude>
   include: Array<Include> | undefined
   override: Array<Override<ResolvedOptions>>
-  group: Group | undefined
+  group: Group | null
   client: Pick<PluginClient['options'], 'client' | 'clientType' | 'dataReturnType' | 'importPath' | 'baseURL' | 'bundle' | 'paramsCasing'>
   paramsCasing: Options['paramsCasing']
   resolver: ResolverMcp