@kubb/plugin-mcp 0.0.0-canary-20250414193247

package/dist/types-B4DlUSkU.d.cts

@@ -0,0 +1,54 @@
+import { Output, Group, PluginFactoryOptions, ResolveNameParams } from '@kubb/core';
+import { Oas, contentType } from '@kubb/oas';
+import { Exclude, Include, Override, ResolvePathOptions, Generator } from '@kubb/plugin-oas';
+import { PluginClient } from '@kubb/plugin-client';
+
+type Options = {
+    /**
+     * Specify the export location for the files and define the behavior of the output
+     * @default { path: 'mcp', barrelType: 'named' }
+     */
+    output?: Output<Oas>;
+    /**
+     * Define which contentType should be used.
+     * By default, the first JSON valid mediaType will be used
+     */
+    contentType?: contentType;
+    client?: Pick<PluginClient['options'], 'dataReturnType' | 'importPath' | 'baseURL'>;
+    /**
+     * Group the mcp requests based on the provided name.
+     */
+    group?: Group;
+    /**
+     * Array containing exclude parameters to exclude/skip tags/operations/methods/paths.
+     */
+    exclude?: Array<Exclude>;
+    /**
+     * Array containing include parameters to include tags/operations/methods/paths.
+     */
+    include?: Array<Include>;
+    /**
+     * Array containing override parameters to override `options` based on tags/operations/methods/paths.
+     */
+    override?: Array<Override<ResolvedOptions>>;
+    transformers?: {
+        /**
+         * Customize the names based on the type that is provided by the plugin.
+         */
+        name?: (name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string;
+    };
+    /**
+     * Define some generators next to the Mcp generators.
+     */
+    generators?: Array<Generator<PluginMcp>>;
+};
+type ResolvedOptions = {
+    output: Output<Oas>;
+    group: Options['group'];
+    client: Required<Omit<NonNullable<PluginMcp['options']['client']>, 'baseURL'>> & {
+        baseURL?: string;
+    };
+};
+type PluginMcp = PluginFactoryOptions<'plugin-mcp', Options, ResolvedOptions, never, ResolvePathOptions>;
+
+export type { Options as O, PluginMcp as P };

package/dist/types-B4DlUSkU.d.ts

@@ -0,0 +1,54 @@
+import { Output, Group, PluginFactoryOptions, ResolveNameParams } from '@kubb/core';
+import { Oas, contentType } from '@kubb/oas';
+import { Exclude, Include, Override, ResolvePathOptions, Generator } from '@kubb/plugin-oas';
+import { PluginClient } from '@kubb/plugin-client';
+
+type Options = {
+    /**
+     * Specify the export location for the files and define the behavior of the output
+     * @default { path: 'mcp', barrelType: 'named' }
+     */
+    output?: Output<Oas>;
+    /**
+     * Define which contentType should be used.
+     * By default, the first JSON valid mediaType will be used
+     */
+    contentType?: contentType;
+    client?: Pick<PluginClient['options'], 'dataReturnType' | 'importPath' | 'baseURL'>;
+    /**
+     * Group the mcp requests based on the provided name.
+     */
+    group?: Group;
+    /**
+     * Array containing exclude parameters to exclude/skip tags/operations/methods/paths.
+     */
+    exclude?: Array<Exclude>;
+    /**
+     * Array containing include parameters to include tags/operations/methods/paths.
+     */
+    include?: Array<Include>;
+    /**
+     * Array containing override parameters to override `options` based on tags/operations/methods/paths.
+     */
+    override?: Array<Override<ResolvedOptions>>;
+    transformers?: {
+        /**
+         * Customize the names based on the type that is provided by the plugin.
+         */
+        name?: (name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string;
+    };
+    /**
+     * Define some generators next to the Mcp generators.
+     */
+    generators?: Array<Generator<PluginMcp>>;
+};
+type ResolvedOptions = {
+    output: Output<Oas>;
+    group: Options['group'];
+    client: Required<Omit<NonNullable<PluginMcp['options']['client']>, 'baseURL'>> & {
+        baseURL?: string;
+    };
+};
+type PluginMcp = PluginFactoryOptions<'plugin-mcp', Options, ResolvedOptions, never, ResolvePathOptions>;
+
+export type { Options as O, PluginMcp as P };

package/package.json

@@ -0,0 +1,117 @@
+{
+  "name": "@kubb/plugin-mcp",
+  "version": "0.0.0-canary-20250414193247",
+  "description": "Generator mcp",
+  "keywords": [
+    "typescript",
+    "plugins",
+    "kubb",
+    "codegen",
+    "mcp",
+    "ai",
+    "claude",
+    "openapi"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kubb-labs/kubb.git",
+    "directory": "packages/plugin-mcp"
+  },
+  "license": "MIT",
+  "author": "stijnvanhulle",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.cjs"
+    },
+    "./utils": {
+      "import": "./dist/utils.js",
+      "require": "./dist/utils.cjs",
+      "default": "./dist/utils.cjs"
+    },
+    "./hooks": {
+      "import": "./dist/hooks.js",
+      "require": "./dist/hooks.cjs",
+      "default": "./dist/hooks.cjs"
+    },
+    "./components": {
+      "import": "./dist/components.js",
+      "require": "./dist/components.cjs",
+      "default": "./dist/components.cjs"
+    },
+    "./generators": {
+      "import": "./dist/generators.js",
+      "require": "./dist/generators.cjs",
+      "default": "./dist/generators.cjs"
+    },
+    "./package.json": "./package.json",
+    "./*": "./*"
+  },
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "./dist/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "utils": [
+        "./dist/utils.d.ts"
+      ],
+      "hooks": [
+        "./dist/hooks.d.ts"
+      ],
+      "components": [
+        "./dist/components.d.ts"
+      ],
+      "generators": [
+        "./dist/generators.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "src",
+    "dist",
+    "!/**/**.test.**",
+    "!/**/__tests__/**"
+  ],
+  "dependencies": {
+    "@kubb/fs": "0.0.0-canary-20250414193247",
+    "@kubb/core": "0.0.0-canary-20250414193247",
+    "@kubb/oas": "0.0.0-canary-20250414193247",
+    "@kubb/plugin-client": "0.0.0-canary-20250414193247",
+    "@kubb/plugin-oas": "0.0.0-canary-20250414193247",
+    "@kubb/plugin-ts": "0.0.0-canary-20250414193247",
+    "@kubb/react": "0.0.0-canary-20250414193247",
+    "@kubb/plugin-zod": "0.0.0-canary-20250414193247"
+  },
+  "devDependencies": {
+    "@types/react": "^18.3.20",
+    "react": "^18.3.1",
+    "tsup": "^8.4.0",
+    "typescript": "^5.8.3",
+    "@kubb/config-ts": "0.0.0-canary-20250414193247",
+    "@kubb/config-tsup": "0.0.0-canary-20250414193247"
+  },
+  "peerDependencies": {
+    "@kubb/react": "0.0.0-canary-20250414193247"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "tsup",
+    "clean": "npx rimraf ./dist",
+    "lint": "bun biome lint .",
+    "lint:fix": "bun biome lint --apply-unsafe .",
+    "release": "pnpm publish --no-git-check",
+    "release:canary": "bash ../../.github/canary.sh && node ../../scripts/build.js canary && pnpm publish --no-git-check",
+    "start": "tsup --watch",
+    "test": "vitest --passWithNoTests",
+    "typecheck": "tsc -p ./tsconfig.json --noEmit --emitDeclarationOnly false"
+  }
+}

package/src/components/Server.tsx

@@ -0,0 +1,141 @@
+import type * as KubbFile from '@kubb/fs/types'
+
+import { Const, File, FunctionParams } from '@kubb/react'
+import type { OperationSchemas } from '@kubb/plugin-oas'
+import { getPathParams, isOptional } from '@kubb/plugin-oas/utils'
+import { isNullable, isReference } from '@kubb/oas'
+import { camelCase } from '@kubb/core/transformers'
+
+type Props = {
+  name: string
+  serverName: string
+  serverVersion: string
+  operations: Array<{
+    operationId: string
+    description?: string
+    mcp: {
+      name: string
+      file: KubbFile.File
+    }
+    zod: {
+      name: string
+      file: KubbFile.File
+      schemas: OperationSchemas
+    }
+    type: {
+      schemas: OperationSchemas
+    }
+  }>
+}
+
+type GetParamsProps = {
+  schemas: OperationSchemas
+}
+
+function getParams({ schemas }: GetParamsProps) {
+  const pathParams = getPathParams(schemas.pathParams, {
+    typed: false,
+  })
+
+  return FunctionParams.factory({
+    data: {
+      mode: 'object',
+      children: {
+        ...Object.entries(pathParams).reduce((acc, [key, param]) => {
+          if (param && schemas.pathParams?.name) {
+            let suffix = '.shape'
+
+            if (isNullable(schemas.pathParams.schema)) {
+              if (isReference(schemas.pathParams)) {
+                suffix = '.unwrap().schema.unwrap().shape'
+              } else {
+                suffix = '.unwrap().shape'
+              }
+            } else {
+              if (isReference(schemas.pathParams)) {
+                suffix = '.schema.shape'
+              }
+            }
+
+            param.value = `${schemas.pathParams?.name}${suffix}['${key}']`
+          }
+
+          return {
+            ...acc,
+            [camelCase(key)]: param,
+          }
+        }, {}),
+        data: schemas.request?.name
+          ? {
+              value: schemas.request?.name,
+              optional: isOptional(schemas.request?.schema),
+            }
+          : undefined,
+        params: schemas.queryParams?.name
+          ? {
+              value: schemas.queryParams?.name,
+              optional: isOptional(schemas.queryParams?.schema),
+            }
+          : undefined,
+        headers: schemas.headerParams?.name
+          ? {
+              value: schemas.headerParams?.name,
+              optional: isOptional(schemas.headerParams?.schema),
+            }
+          : undefined,
+      },
+    },
+  })
+}
+
+export function Server({ name, serverName, serverVersion, operations }: Props) {
+  return (
+    <>
+      <File.Source name={name} isExportable isIndexable>
+        <Const name={'server'} export>
+          {`
+          new McpServer({
+  name: '${serverName}',
+  version: '${serverVersion}',
+})
+          `}
+        </Const>
+
+        {operations
+          .map(({ operationId, mcp, zod, description = '' }) => {
+            const paramsClient = getParams({ schemas: zod.schemas })
+
+            if (zod.schemas.request?.name || zod.schemas.headerParams?.name || zod.schemas.queryParams?.name || zod.schemas.pathParams?.name) {
+              return `
+server.tool('${operationId}', '${description}', ${paramsClient.toObjectValue()}, async (${paramsClient.toObject()}) => {
+  return ${mcp.name}(${paramsClient.toObject()})
+})
+          `
+            }
+
+            return `
+server.tool('${operationId}', '${description}', async () => {
+  return ${mcp.name}(${paramsClient.toObject()})
+})
+          `
+          })
+          .filter(Boolean)}
+
+        {`
+async function startServer() {
+  try {
+    const transport = new StdioServerTransport()
+    await server.connect(transport)
+    console.error('Server started and listening on stdio')
+  } catch (error) {
+    console.error('Failed to start server:', error)
+    process.exit(1)
+  }
+}
+
+startServer()
+`}
+      </File.Source>
+    </>
+  )
+}

package/src/components/index.ts

@@ -0,0 +1 @@
+export { Server } from './Server.tsx'

package/src/generators/__snapshots__/.mcp.json

@@ -0,0 +1,9 @@
+{
+            "mcpServers": {
+              "Swagger Petstore": {
+                "type": "stdio",
+                "command": "npx",
+                "args": ["tsx", "server.ts"]
+              }
+            }
+          }

package/src/generators/__snapshots__/createPet.ts

@@ -0,0 +1,19 @@
+import client from '@kubb/plugin-client/clients/axios'
+import type { ResponseErrorConfig } from '@kubb/plugin-client/clients/axios'
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types'
+
+/**
+ * @summary Create a pet
+ * {@link /pets}
+ */
+export async function createPetsHandler({ data }: { data: CreatePetsMutationRequest }): Promise<Promise<CallToolResult>> {
+  const res = await client<CreatePetsMutationResponse, ResponseErrorConfig<Error>, CreatePetsMutationRequest>({ method: 'POST', url: `/pets`, data })
+  return {
+    content: [
+      {
+        type: 'text',
+        text: JSON.stringify(res.data),
+      },
+    ],
+  }
+}

package/src/generators/__snapshots__/deletePet.ts

@@ -0,0 +1,18 @@
+import client from '@kubb/plugin-client/clients/axios'
+import type { ResponseErrorConfig } from '@kubb/plugin-client/clients/axios'
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types'
+
+/**
+ * {@link /pets/:petId}
+ */
+export async function deletePetsPetidHandler(): Promise<Promise<CallToolResult>> {
+  const res = await client<DeletePetsPetidMutationResponse, ResponseErrorConfig<Error>, unknown>({ method: 'DELETE', url: `/pets/${petId}` })
+  return {
+    content: [
+      {
+        type: 'text',
+        text: JSON.stringify(res.data),
+      },
+    ],
+  }
+}

package/src/generators/__snapshots__/getPets.ts

@@ -0,0 +1,19 @@
+import client from '@kubb/plugin-client/clients/axios'
+import type { ResponseErrorConfig } from '@kubb/plugin-client/clients/axios'
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types'
+
+/**
+ * @summary List all pets
+ * {@link /pets}
+ */
+export async function listPetsHandler({ params }: { params?: ListPetsQueryParams }): Promise<Promise<CallToolResult>> {
+  const res = await client<ListPetsQueryResponse, ResponseErrorConfig<Error>, unknown>({ method: 'GET', url: `/pets`, params })
+  return {
+    content: [
+      {
+        type: 'text',
+        text: JSON.stringify(res.data),
+      },
+    ],
+  }
+}

package/src/generators/__snapshots__/server.ts

@@ -0,0 +1,37 @@
+/**
+ * Generated by Kubb (https://kubb.dev/).
+ * Do not edit manually.
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp'
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio'
+import { listPetsHandler, listPetsQueryParams, createPetsHandler, createPetsMutationRequest, showPetByIdHandler, showPetByIdPathParams } from './showPetById'
+
+export const server = new McpServer({
+  name: 'Swagger Petstore',
+  version: '3.0.0',
+})
+
+server.tool('listPets', '', { params: listPetsQueryParams }, async ({ params }) => {
+  return listPetsHandler({ params })
+})
+
+server.tool('createPets', '', { data: createPetsMutationRequest }, async ({ data }) => {
+  return createPetsHandler({ data })
+})
+
+server.tool('showPetById', '', { petId: showPetByIdPathParams.shape['petId'], testId: showPetByIdPathParams.shape['testId'] }, async ({ petId, testId }) => {
+  return showPetByIdHandler({ petId, testId })
+})
+
+async function startServer() {
+  try {
+    const transport = new StdioServerTransport()
+    await server.connect(transport)
+    console.error('Server started and listening on stdio')
+  } catch (error) {
+    console.error('Failed to start server:', error)
+    process.exit(1)
+  }
+}
+
+startServer()

package/src/generators/__snapshots__/showPetById.ts

@@ -0,0 +1,25 @@
+import client from '@kubb/plugin-client/clients/axios'
+import type { ResponseErrorConfig } from '@kubb/plugin-client/clients/axios'
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types'
+
+/**
+ * @summary Info for a specific pet
+ * {@link /pets/:petId}
+ */
+export async function showPetByIdHandler({
+  petId,
+  testId,
+}: {
+  petId: ShowPetByIdPathParams['petId']
+  testId: ShowPetByIdPathParams['testId']
+}): Promise<Promise<CallToolResult>> {
+  const res = await client<ShowPetByIdQueryResponse, ResponseErrorConfig<Error>, unknown>({ method: 'GET', url: `/pets/${petId}` })
+  return {
+    content: [
+      {
+        type: 'text',
+        text: JSON.stringify(res.data),
+      },
+    ],
+  }
+}

package/src/generators/index.ts

@@ -0,0 +1,2 @@
+export { mcpGenerator } from './mcpGenerator.tsx'
+export { serverGenerator } from './serverGenerator.tsx'

package/src/generators/mcpGenerator.tsx

@@ -0,0 +1,89 @@
+import { createReactGenerator } from '@kubb/plugin-oas'
+import { useOas, useOperationManager } from '@kubb/plugin-oas/hooks'
+import { getBanner, getFooter } from '@kubb/plugin-oas/utils'
+import { pluginTsName } from '@kubb/plugin-ts'
+import { File, useApp } from '@kubb/react'
+import type { PluginMcp } from '../types'
+import { Client } from '@kubb/plugin-client/components'
+
+export const mcpGenerator = createReactGenerator<PluginMcp>({
+  name: 'mcp',
+  Operation({ operation }) {
+    const {
+      plugin: { options },
+    } = useApp<PluginMcp>()
+    const oas = useOas()
+    const { getSchemas, getName, getFile } = useOperationManager()
+
+    const mcp = {
+      name: getName(operation, { type: 'function', suffix: 'handler' }),
+      file: getFile(operation),
+    }
+
+    const type = {
+      file: getFile(operation, { pluginKey: [pluginTsName] }),
+      schemas: getSchemas(operation, { pluginKey: [pluginTsName], type: 'type' }),
+    }
+
+    return (
+      <File
+        baseName={mcp.file.baseName}
+        path={mcp.file.path}
+        meta={mcp.file.meta}
+        banner={getBanner({ oas, output: options.output })}
+        footer={getFooter({ oas, output: options.output })}
+      >
+        <File.Import name={['CallToolResult']} path={'@modelcontextprotocol/sdk/types'} isTypeOnly />
+        <File.Import name={'client'} path={options.client.importPath} />
+        <File.Import name={['RequestConfig', 'ResponseErrorConfig']} path={options.client.importPath} isTypeOnly />
+        <File.Import
+          name={[
+            type.schemas.request?.name,
+            type.schemas.response.name,
+            type.schemas.pathParams?.name,
+            type.schemas.queryParams?.name,
+            type.schemas.headerParams?.name,
+            ...(type.schemas.statusCodes?.map((item) => item.name) || []),
+          ].filter(Boolean)}
+          root={mcp.file.path}
+          path={type.file.path}
+          isTypeOnly
+        />
+
+        <Client
+          name={mcp.name}
+          isConfigurable={false}
+          returnType={'Promise<CallToolResult>'}
+          baseURL={options.client.baseURL}
+          operation={operation}
+          typeSchemas={type.schemas}
+          zodSchemas={undefined}
+          dataReturnType={options.client.dataReturnType}
+          paramsType={'object'}
+          paramsCasing={'camelcase'}
+          pathParamsType={'object'}
+          parser={'client'}
+        >
+          {options.client.dataReturnType === 'data' &&
+            `return {
+            content: [
+              {
+                type: 'text',
+                text: JSON.stringify(res.data)
+              }
+            ]
+           }`}
+          {options.client.dataReturnType === 'full' &&
+            `return {
+            content: [
+              {
+                type: 'text',
+                text: JSON.stringify(res)
+              }
+            ]
+           }`}
+        </Client>
+      </File>
+    )
+  },
+})