@kubb/plugin-mcp 4.21.2 → 4.22.1

package/dist/generators.d.ts

@@ -1,7 +1,462 @@
 import { t as __name } from "./chunk-eQyhnF5A.js";
-import { n as ReactGenerator } from "./index-DNBGPN7Z.js";
-import { n as PluginMcp } from "./types-BtFvu11q.js";
+import { n as PluginMcp } from "./types-Bg_tbyZc.js";
+import { BaseGenerator, Config, FileMetaBase, Group, KubbEvents, Output, Plugin, PluginFactoryOptions, PluginManager, ResolveNameParams } from "@kubb/core";
+import { AsyncEventEmitter } from "@kubb/core/utils";
+import { Fabric } from "@kubb/react-fabric";
+import { HttpMethod, Oas, Operation, SchemaObject, contentType } from "@kubb/oas";
+import { KubbFile } from "@kubb/fabric-core/types";
+import { FabricReactNode } from "@kubb/react-fabric/types";
 
+//#region ../plugin-oas/src/types.d.ts
+type GetOasOptions = {
+  validate?: boolean;
+};
+type Context$2 = {
+  getOas(options?: GetOasOptions): Promise<Oas>;
+  getBaseURL(): Promise<string | undefined>;
+};
+declare global {
+  namespace Kubb {
+    interface PluginContext extends Context$2 {}
+  }
+}
+/**
+ * `propertyName` is the ref name + resolved with the nameResolver
+ *  @example import { Pet } from './Pet'
+ *
+ * `originalName` is the original name used(in PascalCase), only used to remove duplicates
+ *
+ * `pluginKey` can be used to override the current plugin being used, handy when you want to import a type/schema out of another plugin
+ * @example import a type(plugin-ts) for a mock file(swagger-faker)
+ */
+type Ref = {
+  propertyName: string;
+  originalName: string;
+  path: KubbFile.Path;
+  pluginKey?: Plugin['key'];
+};
+type Refs = Record<string, Ref>;
+type OperationSchema = {
+  /**
+   * Converted name, contains already `PathParams`, `QueryParams`, ...
+   */
+  name: string;
+  schema: SchemaObject;
+  operation?: Operation;
+  /**
+   * OperationName in PascalCase, only being used in OperationGenerator
+   */
+  operationName: string;
+  description?: string;
+  statusCode?: number;
+  keys?: string[];
+  keysToOmit?: string[];
+  withData?: boolean;
+};
+type OperationSchemas = {
+  pathParams?: OperationSchema & {
+    keysToOmit?: never;
+  };
+  queryParams?: OperationSchema & {
+    keysToOmit?: never;
+  };
+  headerParams?: OperationSchema & {
+    keysToOmit?: never;
+  };
+  request?: OperationSchema;
+  response: OperationSchema;
+  responses: Array<OperationSchema>;
+  statusCodes?: Array<OperationSchema>;
+  errors?: Array<OperationSchema>;
+};
+type ByTag = {
+  type: 'tag';
+  pattern: string | RegExp;
+};
+type ByOperationId = {
+  type: 'operationId';
+  pattern: string | RegExp;
+};
+type ByPath = {
+  type: 'path';
+  pattern: string | RegExp;
+};
+type ByMethod = {
+  type: 'method';
+  pattern: HttpMethod | RegExp;
+};
+type BySchemaName = {
+  type: 'schemaName';
+  pattern: string | RegExp;
+};
+type ByContentType = {
+  type: 'contentType';
+  pattern: string | RegExp;
+};
+type Exclude = ByTag | ByOperationId | ByPath | ByMethod | ByContentType;
+type Include = ByTag | ByOperationId | ByPath | ByMethod | ByContentType;
+type Override<TOptions> = (ByTag | ByOperationId | ByPath | ByMethod | BySchemaName | ByContentType) & {
+  options: Partial<TOptions>;
+};
+//#endregion
+//#region ../plugin-oas/src/OperationGenerator.d.ts
+type Context$1<TOptions, TPluginOptions extends PluginFactoryOptions> = {
+  fabric: Fabric;
+  oas: Oas;
+  exclude: Array<Exclude> | undefined;
+  include: Array<Include> | undefined;
+  override: Array<Override<TOptions>> | undefined;
+  contentType: contentType | undefined;
+  pluginManager: PluginManager;
+  events?: AsyncEventEmitter<KubbEvents>;
+  /**
+   * Current plugin
+   */
+  plugin: Plugin<TPluginOptions>;
+  mode: KubbFile.Mode;
+  UNSTABLE_NAMING?: true;
+};
+declare class OperationGenerator<TPluginOptions extends PluginFactoryOptions = PluginFactoryOptions, TFileMeta extends FileMetaBase = FileMetaBase> extends BaseGenerator<TPluginOptions['resolvedOptions'], Context$1<TPluginOptions['resolvedOptions'], TPluginOptions>> {
+  #private;
+  getOptions(operation: Operation, method: HttpMethod): Partial<TPluginOptions['resolvedOptions']>;
+  getSchemas(operation: Operation, {
+    resolveName
+  }?: {
+    resolveName?: (name: string) => string;
+  }): OperationSchemas;
+  getOperations(): Promise<Array<{
+    path: string;
+    method: HttpMethod;
+    operation: Operation;
+  }>>;
+  build(...generators: Array<Generator<TPluginOptions>>): Promise<Array<KubbFile.File<TFileMeta>>>;
+}
+//#endregion
+//#region ../plugin-oas/src/SchemaMapper.d.ts
+type SchemaKeywordMapper = {
+  object: {
+    keyword: 'object';
+    args: {
+      properties: {
+        [x: string]: Schema[];
+      };
+      additionalProperties: Schema[];
+      patternProperties?: Record<string, Schema[]>;
+      strict?: boolean;
+    };
+  };
+  url: {
+    keyword: 'url';
+  };
+  readOnly: {
+    keyword: 'readOnly';
+  };
+  writeOnly: {
+    keyword: 'writeOnly';
+  };
+  uuid: {
+    keyword: 'uuid';
+  };
+  email: {
+    keyword: 'email';
+  };
+  firstName: {
+    keyword: 'firstName';
+  };
+  lastName: {
+    keyword: 'lastName';
+  };
+  phone: {
+    keyword: 'phone';
+  };
+  password: {
+    keyword: 'password';
+  };
+  date: {
+    keyword: 'date';
+    args: {
+      type?: 'date' | 'string';
+    };
+  };
+  time: {
+    keyword: 'time';
+    args: {
+      type?: 'date' | 'string';
+    };
+  };
+  datetime: {
+    keyword: 'datetime';
+    args: {
+      offset?: boolean;
+      local?: boolean;
+    };
+  };
+  tuple: {
+    keyword: 'tuple';
+    args: {
+      items: Schema[];
+      min?: number;
+      max?: number;
+      rest?: Schema;
+    };
+  };
+  array: {
+    keyword: 'array';
+    args: {
+      items: Schema[];
+      min?: number;
+      max?: number;
+      unique?: boolean;
+    };
+  };
+  enum: {
+    keyword: 'enum';
+    args: {
+      name: string;
+      typeName: string;
+      asConst: boolean;
+      items: Array<{
+        name: string | number;
+        format: 'string' | 'number' | 'boolean';
+        value?: string | number | boolean;
+      }>;
+    };
+  };
+  and: {
+    keyword: 'and';
+    args: Schema[];
+  };
+  const: {
+    keyword: 'const';
+    args: {
+      name: string | number;
+      format: 'string' | 'number' | 'boolean';
+      value?: string | number | boolean;
+    };
+  };
+  union: {
+    keyword: 'union';
+    args: Schema[];
+  };
+  ref: {
+    keyword: 'ref';
+    args: {
+      name: string;
+      $ref: string;
+      /**
+       * Full qualified path.
+       */
+      path: KubbFile.Path;
+      /**
+       * When true `File.Import` is used.
+       * When false a reference is used inside the current file.
+       */
+      isImportable: boolean;
+    };
+  };
+  matches: {
+    keyword: 'matches';
+    args?: string;
+  };
+  boolean: {
+    keyword: 'boolean';
+  };
+  default: {
+    keyword: 'default';
+    args: string | number | boolean;
+  };
+  string: {
+    keyword: 'string';
+  };
+  integer: {
+    keyword: 'integer';
+  };
+  number: {
+    keyword: 'number';
+  };
+  max: {
+    keyword: 'max';
+    args: number;
+  };
+  min: {
+    keyword: 'min';
+    args: number;
+  };
+  exclusiveMaximum: {
+    keyword: 'exclusiveMaximum';
+    args: number;
+  };
+  exclusiveMinimum: {
+    keyword: 'exclusiveMinimum';
+    args: number;
+  };
+  describe: {
+    keyword: 'describe';
+    args: string;
+  };
+  example: {
+    keyword: 'example';
+    args: string;
+  };
+  deprecated: {
+    keyword: 'deprecated';
+  };
+  optional: {
+    keyword: 'optional';
+  };
+  undefined: {
+    keyword: 'undefined';
+  };
+  nullish: {
+    keyword: 'nullish';
+  };
+  nullable: {
+    keyword: 'nullable';
+  };
+  null: {
+    keyword: 'null';
+  };
+  any: {
+    keyword: 'any';
+  };
+  unknown: {
+    keyword: 'unknown';
+  };
+  void: {
+    keyword: 'void';
+  };
+  blob: {
+    keyword: 'blob';
+  };
+  schema: {
+    keyword: 'schema';
+    args: {
+      type: 'string' | 'number' | 'integer' | 'boolean' | 'array' | 'object';
+      format?: string;
+    };
+  };
+  name: {
+    keyword: 'name';
+    args: string;
+  };
+  catchall: {
+    keyword: 'catchall';
+  };
+  interface: {
+    keyword: 'interface';
+  };
+};
+type Schema = {
+  keyword: string;
+} | SchemaKeywordMapper[keyof SchemaKeywordMapper];
+//#endregion
+//#region ../plugin-oas/src/SchemaGenerator.d.ts
+type Context<TOptions, TPluginOptions extends PluginFactoryOptions> = {
+  fabric: Fabric;
+  oas: Oas;
+  pluginManager: PluginManager;
+  events?: AsyncEventEmitter<KubbEvents>;
+  /**
+   * Current plugin
+   */
+  plugin: Plugin<TPluginOptions>;
+  mode: KubbFile.Mode;
+  include?: Array<'schemas' | 'responses' | 'requestBodies'>;
+  override: Array<Override<TOptions>> | undefined;
+  contentType?: contentType;
+  output?: string;
+};
+type SchemaGeneratorOptions = {
+  dateType: false | 'string' | 'stringOffset' | 'stringLocal' | 'date';
+  unknownType: 'any' | 'unknown' | 'void';
+  emptySchemaType: 'any' | 'unknown' | 'void';
+  enumType?: 'enum' | 'asConst' | 'asPascalConst' | 'constEnum' | 'literal' | 'inlineLiteral';
+  enumSuffix?: string;
+  /**
+   * @deprecated Will be removed in v5. Use `collisionDetection: true` instead to prevent enum name collisions.
+   * When `collisionDetection` is enabled, the rootName-based approach eliminates the need for numeric suffixes.
+   * @internal
+   */
+  usedEnumNames?: Record<string, number>;
+  mapper?: Record<string, string>;
+  typed?: boolean;
+  transformers: {
+    /**
+     * Customize the names based on the type that is provided by the plugin.
+     */
+    name?: (name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string;
+    /**
+     * Receive schema and name(propertyName) and return FakerMeta array
+     * TODO TODO add docs
+     * @beta
+     */
+    schema?: (schemaProps: SchemaProps$1, defaultSchemas: Schema[]) => Array<Schema> | undefined;
+  };
+};
+type SchemaProps$1 = {
+  schema: SchemaObject | null;
+  name: string | null;
+  parentName: string | null;
+  rootName?: string | null;
+};
+declare class SchemaGenerator<TOptions extends SchemaGeneratorOptions = SchemaGeneratorOptions, TPluginOptions extends PluginFactoryOptions = PluginFactoryOptions, TFileMeta extends FileMetaBase = FileMetaBase> extends BaseGenerator<TOptions, Context<TOptions, TPluginOptions>> {
+  #private;
+  refs: Refs;
+  /**
+   * Creates a type node from a given schema.
+   * Delegates to getBaseTypeFromSchema internally and
+   * optionally adds a union with null.
+   */
+  parse(props: SchemaProps$1): Schema[];
+  static deepSearch<T extends keyof SchemaKeywordMapper>(tree: Schema[] | undefined, keyword: T): Array<SchemaKeywordMapper[T]>;
+  static find<T extends keyof SchemaKeywordMapper>(tree: Schema[] | undefined, keyword: T): SchemaKeywordMapper[T] | undefined;
+  static combineObjects(tree: Schema[] | undefined): Schema[];
+  build(...generators: Array<Generator<TPluginOptions>>): Promise<Array<KubbFile.File<TFileMeta>>>;
+}
+//#endregion
+//#region ../plugin-oas/src/generators/createGenerator.d.ts
+type CoreGenerator<TOptions extends PluginFactoryOptions> = {
+  name: string;
+  type: 'core';
+  operations: (props: OperationsProps<TOptions>) => Promise<KubbFile.File[]>;
+  operation: (props: OperationProps<TOptions>) => Promise<KubbFile.File[]>;
+  schema: (props: SchemaProps<TOptions>) => Promise<KubbFile.File[]>;
+};
+//#endregion
+//#region ../plugin-oas/src/generators/types.d.ts
+type OperationsProps<TOptions extends PluginFactoryOptions> = {
+  config: Config;
+  generator: Omit<OperationGenerator<TOptions>, 'build'>;
+  plugin: Plugin<TOptions>;
+  operations: Array<Operation>;
+};
+type OperationProps<TOptions extends PluginFactoryOptions> = {
+  config: Config;
+  generator: Omit<OperationGenerator<TOptions>, 'build'>;
+  plugin: Plugin<TOptions>;
+  operation: Operation;
+};
+type SchemaProps<TOptions extends PluginFactoryOptions> = {
+  config: Config;
+  generator: Omit<SchemaGenerator<SchemaGeneratorOptions, TOptions>, 'build'>;
+  plugin: Plugin<TOptions>;
+  schema: {
+    name: string;
+    tree: Array<Schema>;
+    value: SchemaObject;
+  };
+};
+type Generator<TOptions extends PluginFactoryOptions> = CoreGenerator<TOptions> | ReactGenerator<TOptions>;
+//#endregion
+//#region ../plugin-oas/src/generators/createReactGenerator.d.ts
+type ReactGenerator<TOptions extends PluginFactoryOptions> = {
+  name: string;
+  type: 'react';
+  Operations: (props: OperationsProps<TOptions>) => FabricReactNode;
+  Operation: (props: OperationProps<TOptions>) => FabricReactNode;
+  Schema: (props: SchemaProps<TOptions>) => FabricReactNode;
+};
+//#endregion
 //#region src/generators/mcpGenerator.d.ts
 declare const mcpGenerator: ReactGenerator<PluginMcp>;
 //#endregion

package/dist/generators.js

@@ -1,3 +1,3 @@
-import { n as mcpGenerator, t as serverGenerator } from "./generators-CrC1R2wh.js";
+import { n as mcpGenerator, t as serverGenerator } from "./generators-CIGzlv3P.js";
 
 export { mcpGenerator, serverGenerator };

package/dist/index.cjs

@@ -1,5 +1,5 @@
 const require_Server = require('./Server-9nmuwHl0.cjs');
-const require_generators = require('./generators-DOGoAPGT.cjs');
+const require_generators = require('./generators-BLuJpiEp.cjs');
 let node_path = require("node:path");
 node_path = require_Server.__toESM(node_path);
 let _kubb_core = require("@kubb/core");

package/dist/index.d.cts

@@ -1,5 +1,5 @@
-import { u as __name } from "./index-RsNfvceH.cjs";
-import { n as PluginMcp, t as Options } from "./types-Bw-588-z.cjs";
+import { t as __name } from "./chunk-DHUGjThq.cjs";
+import { n as PluginMcp, t as Options } from "./types-Cb1Tkjj0.cjs";
 import * as _kubb_core0 from "@kubb/core";
 
 //#region src/plugin.d.ts

package/dist/index.d.ts

@@ -1,6 +1,5 @@
 import { t as __name } from "./chunk-eQyhnF5A.js";
-import "./index-DNBGPN7Z.js";
-import { n as PluginMcp, t as Options } from "./types-BtFvu11q.js";
+import { n as PluginMcp, t as Options } from "./types-Bg_tbyZc.js";
 import * as _kubb_core0 from "@kubb/core";
 
 //#region src/plugin.d.ts

package/dist/index.js

@@ -1,5 +1,5 @@
 import { t as __name } from "./chunk-eQyhnF5A.js";
-import { n as mcpGenerator, t as serverGenerator } from "./generators-CrC1R2wh.js";
+import { n as mcpGenerator, t as serverGenerator } from "./generators-CIGzlv3P.js";
 import path from "node:path";
 import { definePlugin, getBarrelFiles, getMode } from "@kubb/core";
 import { camelCase } from "@kubb/core/transformers";

package/dist/types-Bg_tbyZc.d.ts

@@ -0,0 +1,64 @@
+import { t as __name } from "./chunk-eQyhnF5A.js";
+import { Group, Output, PluginFactoryOptions, ResolveNameParams } from "@kubb/core";
+import { PluginClient } from "@kubb/plugin-client";
+import { Exclude, Include, Override, ResolvePathOptions } from "@kubb/plugin-oas";
+import { Generator } from "@kubb/plugin-oas/generators";
+import { Oas, contentType } from "@kubb/oas";
+
+//#region src/types.d.ts
+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 is used
+   */
+  contentType?: contentType;
+  client?: Pick<PluginClient['options'], 'client' | 'clientType' | 'dataReturnType' | 'importPath' | 'baseURL' | 'bundle' | 'paramsCasing'>;
+  /**
+   * Transform parameter names to a specific casing format.
+   * When set to 'camelcase', parameter names in path, query, and header params will be transformed to camelCase.
+   * This should match the paramsCasing setting used in @kubb/plugin-ts.
+   * @default undefined
+   */
+  paramsCasing?: 'camelcase';
+  /**
+   * 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: NonNullable<PluginMcp['options']['client']>;
+  paramsCasing: Options['paramsCasing'];
+};
+type PluginMcp = PluginFactoryOptions<'plugin-mcp', Options, ResolvedOptions, never, ResolvePathOptions>;
+//#endregion
+export { PluginMcp as n, Options as t };
+//# sourceMappingURL=types-Bg_tbyZc.d.ts.map

package/dist/types-Cb1Tkjj0.d.cts

@@ -0,0 +1,64 @@
+import { t as __name } from "./chunk-DHUGjThq.cjs";
+import { Exclude, Include, Override, ResolvePathOptions } from "@kubb/plugin-oas";
+import { Group, Output, PluginFactoryOptions, ResolveNameParams } from "@kubb/core";
+import { Oas, contentType } from "@kubb/oas";
+import { PluginClient } from "@kubb/plugin-client";
+import { Generator } from "@kubb/plugin-oas/generators";
+
+//#region src/types.d.ts
+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 is used
+   */
+  contentType?: contentType;
+  client?: Pick<PluginClient['options'], 'client' | 'clientType' | 'dataReturnType' | 'importPath' | 'baseURL' | 'bundle' | 'paramsCasing'>;
+  /**
+   * Transform parameter names to a specific casing format.
+   * When set to 'camelcase', parameter names in path, query, and header params will be transformed to camelCase.
+   * This should match the paramsCasing setting used in @kubb/plugin-ts.
+   * @default undefined
+   */
+  paramsCasing?: 'camelcase';
+  /**
+   * 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: NonNullable<PluginMcp['options']['client']>;
+  paramsCasing: Options['paramsCasing'];
+};
+type PluginMcp = PluginFactoryOptions<'plugin-mcp', Options, ResolvedOptions, never, ResolvePathOptions>;
+//#endregion
+export { PluginMcp as n, Options as t };
+//# sourceMappingURL=types-Cb1Tkjj0.d.cts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-mcp",
-  "version": "4.21.2",
+  "version": "4.22.1",
   "description": "Model Context Protocol (MCP) plugin for Kubb, generating MCP-compatible tools and schemas from OpenAPI specifications for AI assistants.",
   "keywords": [
     "mcp",
@@ -75,12 +75,12 @@
   ],
   "dependencies": {
     "@kubb/react-fabric": "0.12.11",
-    "@kubb/core": "4.21.2",
-    "@kubb/oas": "4.21.2",
-    "@kubb/plugin-client": "4.21.2",
-    "@kubb/plugin-oas": "4.21.2",
-    "@kubb/plugin-ts": "4.21.2",
-    "@kubb/plugin-zod": "4.21.2"
+    "@kubb/core": "4.22.1",
+    "@kubb/oas": "4.22.1",
+    "@kubb/plugin-client": "4.22.1",
+    "@kubb/plugin-oas": "4.22.1",
+    "@kubb/plugin-ts": "4.22.1",
+    "@kubb/plugin-zod": "4.22.1"
   },
   "devDependencies": {},
   "engines": {

package/src/generators/mcpGenerator.tsx

@@ -36,14 +36,14 @@ export const mcpGenerator = createReactGenerator<PluginMcp>({
         {options.client.importPath ? (
           <>
             <File.Import name={'fetch'} path={options.client.importPath} />
-            <File.Import name={['RequestConfig', 'ResponseErrorConfig']} path={options.client.importPath} isTypeOnly />
+            <File.Import name={['Client', 'RequestConfig', 'ResponseErrorConfig']} path={options.client.importPath} isTypeOnly />
             {options.client.dataReturnType === 'full' && <File.Import name={['ResponseConfig']} path={options.client.importPath} isTypeOnly />}
           </>
         ) : (
           <>
             <File.Import name={['fetch']} root={mcp.file.path} path={path.resolve(config.root, config.output.path, '.kubb/fetch.ts')} />
             <File.Import
-              name={['RequestConfig', 'ResponseErrorConfig']}
+              name={['Client', 'RequestConfig', 'ResponseErrorConfig']}
               root={mcp.file.path}
               path={path.resolve(config.root, config.output.path, '.kubb/fetch.ts')}
               isTypeOnly