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

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, 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
-
-    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, 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 { 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'

package/src/plugin.ts

@@ -1,142 +0,0 @@
-import path from 'node:path'
-import { createGroupConfig } from '@internals/shared'
-
-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'
-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'
-
-/**
- * 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', barrel: { type: '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 = createGroupConfig(group)
-
-  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: 'client.ts',
-            path: path.resolve(root, '.kubb/client.ts'),
-            sources: [
-              ast.createSource({
-                name: 'client',
-                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,35 +0,0 @@
-import { camelCase, toFilePath } from '@internals/utils'
-import { defineResolver } from '@kubb/core'
-import type { PluginMcp } from '../types.ts'
-
-/**
- * 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`.
- *
- * @example Resolve a handler name
- * ```ts
- * import { resolverMcp } from '@kubb/plugin-mcp'
- *
- * resolverMcp.default('addPet', 'function') // 'addPetHandler'
- * ```
- */
-export const resolverMcp = defineResolver<PluginMcp>(() => ({
-  name: 'default',
-  pluginName: 'plugin-mcp',
-  default(name, type) {
-    if (type === 'file') {
-      return toFilePath(name)
-    }
-    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,90 +0,0 @@
-import type { ast, Exclude, Generator, Group, Include, Output, OutputOptions, 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
-}
-
-/**
- * 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 & {
-  /**
-   * HTTP client used by each MCP handler to call the underlying API. Mirrors a
-   * subset of `pluginClient` options.
-   */
-  client?: ClientImportPath & Pick<PluginClient['options'], 'clientType' | 'dataReturnType' | 'baseURL' | 'bundle' | 'paramsCasing'>
-  /**
-   * 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`.
-   */
-  paramsCasing?: 'camelcase'
-  /**
-   * Skip operations matching at least one entry in the list.
-   */
-  exclude?: Array<Exclude>
-  /**
-   * Restrict generation to operations matching at least one entry in the list.
-   */
-  include?: Array<Include>
-  /**
-   * Apply a different options object to operations matching a pattern.
-   */
-  override?: Array<Override<ResolvedOptions>>
-  /**
-   * 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 applied to each operation node before printing.
-   */
-  transformer?: ast.Visitor
-  /**
-   * Custom generators that run alongside the built-in MCP generators.
-   */
-  generators?: Array<Generator<PluginMcp>>
-}
-
-type ResolvedOptions = {
-  output: Output
-  exclude: Array<Exclude>
-  include: Array<Include> | undefined
-  override: Array<Override<ResolvedOptions>>
-  group: Group | null
-  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
-    }
-  }
-}