@kubb/plugin-mcp 5.0.0-alpha.9 → 5.0.0-beta.4

package/src/resolvers/resolverMcp.ts

@@ -0,0 +1,25 @@
+import { camelCase } from '@internals/utils'
+import { defineResolver } from '@kubb/core'
+import type { PluginMcp } from '../types.ts'
+
+/**
+ * Naming convention resolver for MCP plugin.
+ *
+ * Provides default naming helpers using camelCase with a `handler` suffix for functions.
+ *
+ * @example
+ * `resolverMcp.default('addPet', 'function')  // → 'addPetHandler'`
+ */
+export const resolverMcp = defineResolver<PluginMcp>((ctx) => ({
+  name: 'default',
+  pluginName: 'plugin-mcp',
+  default(name, type) {
+    if (type === 'file') {
+      return camelCase(name, { isFile: true })
+    }
+    return camelCase(name, { suffix: 'handler' })
+  },
+  resolveName(name) {
+    return ctx.default(name, 'function')
+  },
+}))

package/src/types.ts

@@ -1,62 +1,80 @@
-import type { Group, Output, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
-
-import type { contentType, Oas } from '@kubb/oas'
+import type { ast, Exclude, Generator, Group, Include, Output, Override, PluginFactoryOptions, Resolver } from '@kubb/core'
 import type { ClientImportPath, PluginClient } from '@kubb/plugin-client'
-import type { Exclude, Include, Override, ResolvePathOptions } from '@kubb/plugin-oas'
-import type { Generator } from '@kubb/plugin-oas/generators'
+
+/**
+ * Resolver for MCP that provides naming methods for handler functions.
+ */
+export type ResolverMcp = Resolver & {
+  /**
+   * Resolves the 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
+   * Specify the export location for the files and define the behavior of the output.
    * @default { path: 'mcp', barrelType: 'named' }
    */
-  output?: Output<Oas>
+  output?: Output
   /**
-   * Define which contentType should be used.
-   * By default, the first JSON valid mediaType is used
+   * Client configuration for HTTP request generation.
    */
-  contentType?: contentType
   client?: ClientImportPath & Pick<PluginClient['options'], 'clientType' | 'dataReturnType' | '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
+   * Apply casing to parameter names to match your configuration.
    */
   paramsCasing?: 'camelcase'
   /**
-   * Group the mcp requests based on the provided name.
+   * Group the MCP requests based on the provided name.
    */
   group?: Group
   /**
-   * Array containing exclude parameters to exclude/skip tags/operations/methods/paths.
+   * Tags, operations, or paths to exclude from generation.
    */
   exclude?: Array<Exclude>
   /**
-   * Array containing include parameters to include tags/operations/methods/paths.
+   * Tags, operations, or paths to include in generation.
    */
   include?: Array<Include>
   /**
-   * Array containing override parameters to override `options` based on tags/operations/methods/paths.
+   * Override options for specific tags, operations, or 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.
+   * Override naming conventions for function names and types.
+   */
+  resolver?: Partial<ResolverMcp> & ThisType<ResolverMcp>
+  /**
+   * AST visitor to transform generated nodes.
+   */
+  transformer?: ast.Visitor
+  /**
+   * Additional generators alongside the default generators.
    */
   generators?: Array<Generator<PluginMcp>>
 }
 
 type ResolvedOptions = {
-  output: Output<Oas>
-  group: Options['group']
+  output: Output
+  exclude: Array<Exclude>
+  include: Array<Include> | undefined
+  override: Array<Override<ResolvedOptions>>
+  group: Group | undefined
   client: Pick<PluginClient['options'], 'client' | 'clientType' | 'dataReturnType' | 'importPath' | 'baseURL' | 'bundle' | 'paramsCasing'>
   paramsCasing: Options['paramsCasing']
+  resolver: ResolverMcp
 }
 
-export type PluginMcp = PluginFactoryOptions<'plugin-mcp', Options, ResolvedOptions, never, ResolvePathOptions>
+export type PluginMcp = PluginFactoryOptions<'plugin-mcp', Options, ResolvedOptions, ResolverMcp>
+
+declare global {
+  namespace Kubb {
+    interface PluginRegistry {
+      'plugin-mcp': PluginMcp
+    }
+  }
+}

package/src/utils.ts

@@ -0,0 +1,113 @@
+import { camelCase } from '@internals/utils'
+import type { ast } from '@kubb/core'
+
+/**
+ * Find the first 2xx response status code from an operation's responses.
+ */
+export function findSuccessStatusCode(responses: Array<{ statusCode: number | string }>): ast.StatusCode | undefined {
+  for (const res of responses) {
+    const code = Number(res.statusCode)
+    if (code >= 200 && code < 300) {
+      return res.statusCode as ast.StatusCode
+    }
+  }
+  return undefined
+}
+
+export type ZodParam = {
+  name: string
+  schemaName: string
+}
+
+/**
+ * Render a group param value — compose individual schemas into `z.object({ ... })`,
+ * or use a schema name string directly.
+ */
+export function zodGroupExpr(entry: string | Array<ZodParam>): string {
+  if (typeof entry === 'string') {
+    return entry
+  }
+  const entries = entry.map((p) => `${JSON.stringify(p.name)}: ${p.schemaName}`)
+  return `z.object({ ${entries.join(', ')} })`
+}
+
+/**
+ * Build JSDoc comment lines from an OperationNode.
+ */
+export function getComments(node: ast.OperationNode): Array<string> {
+  return [
+    node.description && `@description ${node.description}`,
+    node.summary && `@summary ${node.summary}`,
+    node.deprecated && '@deprecated',
+    `{@link ${node.path.replaceAll('{', ':').replaceAll('}', '')}}`,
+  ].filter((x): x is string => Boolean(x))
+}
+
+/**
+ * Build a mapping of original param names → camelCase names.
+ * Returns `undefined` when no names actually change (no remapping needed).
+ */
+export function getParamsMapping(params: Array<{ name: string }>): Record<string, string> | undefined {
+  if (!params.length) {
+    return undefined
+  }
+
+  const mapping: Record<string, string> = {}
+  let hasDifference = false
+
+  for (const p of params) {
+    const camelName = camelCase(p.name)
+    mapping[p.name] = camelName
+    if (p.name !== camelName) {
+      hasDifference = true
+    }
+  }
+
+  return hasDifference ? mapping : undefined
+}
+
+/**
+ * Convert a SchemaNode type to an inline Zod expression string.
+ * Used as fallback when no named zod schema is available for a path parameter.
+ */
+export function zodExprFromSchemaNode(schema: ast.SchemaNode): string {
+  let expr: string
+  switch (schema.type) {
+    case 'enum': {
+      // namedEnumValues takes priority over enumValues
+      const rawValues: Array<string | number | boolean> = schema.namedEnumValues?.length
+        ? schema.namedEnumValues.map((v) => v.value)
+        : (schema.enumValues ?? []).filter((v): v is string | number | boolean => v !== null)
+
+      if (rawValues.length > 0 && rawValues.every((v) => typeof v === 'string')) {
+        expr = `z.enum([${rawValues.map((v) => JSON.stringify(v)).join(', ')}])`
+      } else if (rawValues.length > 0) {
+        const literals = rawValues.map((v) => `z.literal(${JSON.stringify(v)})`)
+        expr = literals.length === 1 ? literals[0]! : `z.union([${literals.join(', ')}])`
+      } else {
+        expr = 'z.string()'
+      }
+      break
+    }
+    case 'integer':
+      expr = 'z.coerce.number()'
+      break
+    case 'number':
+      expr = 'z.number()'
+      break
+    case 'boolean':
+      expr = 'z.boolean()'
+      break
+    case 'array':
+      expr = 'z.array(z.unknown())'
+      break
+    default:
+      expr = 'z.string()'
+  }
+
+  if (schema.nullable) {
+    expr = `${expr}.nullable()`
+  }
+
+  return expr
+}

package/dist/Server-DV9zFrUP.cjs

@@ -1,221 +0,0 @@
-//#region \0rolldown/runtime.js
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", {
-	value,
-	configurable: true
-});
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-//#endregion
-let _kubb_plugin_oas_utils = require("@kubb/plugin-oas/utils");
-let _kubb_react_fabric = require("@kubb/react-fabric");
-let _kubb_react_fabric_jsx_runtime = require("@kubb/react-fabric/jsx-runtime");
-//#region ../../internals/utils/src/casing.ts
-/**
-* Shared implementation for camelCase and PascalCase conversion.
-* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
-* and capitalizes each word according to `pascal`.
-*
-* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
-*/
-function toCamelOrPascal(text, pascal) {
-	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
-		if (word.length > 1 && word === word.toUpperCase()) return word;
-		if (i === 0 && !pascal) return word.charAt(0).toLowerCase() + word.slice(1);
-		return word.charAt(0).toUpperCase() + word.slice(1);
-	}).join("").replace(/[^a-zA-Z0-9]/g, "");
-}
-/**
-* Splits `text` on `.` and applies `transformPart` to each segment.
-* The last segment receives `isLast = true`, all earlier segments receive `false`.
-* Segments are joined with `/` to form a file path.
-*/
-function applyToFileParts(text, transformPart) {
-	const parts = text.split(".");
-	return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
-}
-/**
-* Converts `text` to camelCase.
-* When `isFile` is `true`, dot-separated segments are each cased independently and joined with `/`.
-*
-* @example
-* camelCase('hello-world')                   // 'helloWorld'
-* camelCase('pet.petId', { isFile: true })   // 'pet/petId'
-*/
-function camelCase(text, { isFile, prefix = "", suffix = "" } = {}) {
-	if (isFile) return applyToFileParts(text, (part, isLast) => camelCase(part, isLast ? {
-		prefix,
-		suffix
-	} : {}));
-	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
-}
-//#endregion
-//#region ../../internals/utils/src/reserved.ts
-/**
-* Returns `true` when `name` is a syntactically valid JavaScript variable name.
-*/
-function isValidVarName(name) {
-	try {
-		new Function(`var ${name}`);
-	} catch {
-		return false;
-	}
-	return true;
-}
-//#endregion
-//#region src/components/Server.tsx
-function zodExprFromOasSchema(schema) {
-	const types = Array.isArray(schema.type) ? schema.type : [schema.type];
-	const baseType = types.find((t) => t && t !== "null");
-	const isNullableType = types.includes("null");
-	let expr;
-	switch (baseType) {
-		case "integer":
-			expr = "z.coerce.number()";
-			break;
-		case "number":
-			expr = "z.number()";
-			break;
-		case "boolean":
-			expr = "z.boolean()";
-			break;
-		case "array":
-			expr = "z.array(z.unknown())";
-			break;
-		default: expr = "z.string()";
-	}
-	if (isNullableType) expr = `${expr}.nullable()`;
-	return expr;
-}
-function getParams({ schemas, paramsCasing }) {
-	const pathParamProperties = schemas.pathParams?.schema?.properties ?? {};
-	const requiredFields = Array.isArray(schemas.pathParams?.schema?.required) ? schemas.pathParams.schema.required : [];
-	const pathParamEntries = Object.entries(pathParamProperties).reduce((acc, [originalKey, propSchema]) => {
-		const key = paramsCasing === "camelcase" || !isValidVarName(originalKey) ? camelCase(originalKey) : originalKey;
-		acc[key] = {
-			value: zodExprFromOasSchema(propSchema),
-			optional: !requiredFields.includes(originalKey)
-		};
-		return acc;
-	}, {});
-	return _kubb_react_fabric.FunctionParams.factory({ data: {
-		mode: "object",
-		children: {
-			...pathParamEntries,
-			data: schemas.request?.name ? {
-				value: schemas.request?.name,
-				optional: (0, _kubb_plugin_oas_utils.isOptional)(schemas.request?.schema)
-			} : void 0,
-			params: schemas.queryParams?.name ? {
-				value: schemas.queryParams?.name,
-				optional: (0, _kubb_plugin_oas_utils.isOptional)(schemas.queryParams?.schema)
-			} : void 0,
-			headers: schemas.headerParams?.name ? {
-				value: schemas.headerParams?.name,
-				optional: (0, _kubb_plugin_oas_utils.isOptional)(schemas.headerParams?.schema)
-			} : void 0
-		}
-	} });
-}
-function Server({ name, serverName, serverVersion, paramsCasing, operations }) {
-	return /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsxs)(_kubb_react_fabric.File.Source, {
-		name,
-		isExportable: true,
-		isIndexable: true,
-		children: [
-			/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.Const, {
-				name: "server",
-				export: true,
-				children: `
-          new McpServer({
-  name: '${serverName}',
-  version: '${serverVersion}',
-})
-          `
-			}),
-			operations.map(({ tool, mcp, zod }) => {
-				const paramsClient = getParams({
-					schemas: zod.schemas,
-					paramsCasing
-				});
-				const outputSchema = zod.schemas.response?.name;
-				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 (zod.schemas.request?.name || zod.schemas.headerParams?.name || zod.schemas.queryParams?.name || zod.schemas.pathParams?.name) return `
-server.registerTool(${JSON.stringify(tool.name)}, {
-  ${config},
-  inputSchema: ${paramsClient.toObjectValue()},
-}, async (${paramsClient.toObject()}) => {
-  return ${mcp.name}(${paramsClient.toObject()})
-})
-          `;
-				return `
-server.registerTool(${JSON.stringify(tool.name)}, {
-  ${config},
-}, async () => {
-  return ${mcp.name}(${paramsClient.toObject()})
-})
-          `;
-			}).filter(Boolean),
-			`
-export async function startServer() {
-  try {
-    const transport = new StdioServerTransport()
-    await server.connect(transport)
-
-  } catch (error) {
-    console.error('Failed to start server:', error)
-    process.exit(1)
-  }
-}
-`
-		]
-	});
-}
-//#endregion
-Object.defineProperty(exports, "Server", {
-	enumerable: true,
-	get: function() {
-		return Server;
-	}
-});
-Object.defineProperty(exports, "__name", {
-	enumerable: true,
-	get: function() {
-		return __name;
-	}
-});
-Object.defineProperty(exports, "__toESM", {
-	enumerable: true,
-	get: function() {
-		return __toESM;
-	}
-});
-Object.defineProperty(exports, "camelCase", {
-	enumerable: true,
-	get: function() {
-		return camelCase;
-	}
-});
-
-//# sourceMappingURL=Server-DV9zFrUP.cjs.map

package/dist/Server-DV9zFrUP.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"Server-DV9zFrUP.cjs","names":["FunctionParams","File","Const"],"sources":["../../../internals/utils/src/casing.ts","../../../internals/utils/src/reserved.ts","../src/components/Server.tsx"],"sourcesContent":["type Options = {\n  /** When `true`, dot-separated segments are split on `.` and joined with `/` after casing. */\n  isFile?: boolean\n  /** Text prepended before casing is applied. */\n  prefix?: string\n  /** Text appended before casing is applied. */\n  suffix?: string\n}\n\n/**\n * Shared implementation for camelCase and PascalCase conversion.\n * Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)\n * and capitalizes each word according to `pascal`.\n *\n * When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.\n */\nfunction toCamelOrPascal(text: string, pascal: boolean): string {\n  const normalized = text\n    .trim()\n    .replace(/([a-z\\d])([A-Z])/g, '$1 $2')\n    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')\n    .replace(/(\\d)([a-z])/g, '$1 $2')\n\n  const words = normalized.split(/[\\s\\-_./\\\\:]+/).filter(Boolean)\n\n  return words\n    .map((word, i) => {\n      const allUpper = word.length > 1 && word === word.toUpperCase()\n      if (allUpper) return word\n      if (i === 0 && !pascal) return word.charAt(0).toLowerCase() + word.slice(1)\n      return word.charAt(0).toUpperCase() + word.slice(1)\n    })\n    .join('')\n    .replace(/[^a-zA-Z0-9]/g, '')\n}\n\n/**\n * Splits `text` on `.` and applies `transformPart` to each segment.\n * The last segment receives `isLast = true`, all earlier segments receive `false`.\n * Segments are joined with `/` to form a file path.\n */\nfunction applyToFileParts(text: string, transformPart: (part: string, isLast: boolean) => string): string {\n  const parts = text.split('.')\n  return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join('/')\n}\n\n/**\n * Converts `text` to camelCase.\n * When `isFile` is `true`, dot-separated segments are each cased independently and joined with `/`.\n *\n * @example\n * camelCase('hello-world')                   // 'helloWorld'\n * camelCase('pet.petId', { isFile: true })   // 'pet/petId'\n */\nexport function camelCase(text: string, { isFile, prefix = '', suffix = '' }: Options = {}): string {\n  if (isFile) {\n    return applyToFileParts(text, (part, isLast) => camelCase(part, isLast ? { prefix, suffix } : {}))\n  }\n\n  return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false)\n}\n\n/**\n * Converts `text` to PascalCase.\n * When `isFile` is `true`, the last dot-separated segment is PascalCased and earlier segments are camelCased.\n *\n * @example\n * pascalCase('hello-world')                  // 'HelloWorld'\n * pascalCase('pet.petId', { isFile: true })  // 'pet/PetId'\n */\nexport function pascalCase(text: string, { isFile, prefix = '', suffix = '' }: Options = {}): string {\n  if (isFile) {\n    return applyToFileParts(text, (part, isLast) => (isLast ? pascalCase(part, { prefix, suffix }) : camelCase(part)))\n  }\n\n  return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true)\n}\n\n/**\n * Converts `text` to snake_case.\n *\n * @example\n * snakeCase('helloWorld')  // 'hello_world'\n * snakeCase('Hello-World') // 'hello_world'\n */\nexport function snakeCase(text: string, { prefix = '', suffix = '' }: Omit<Options, 'isFile'> = {}): string {\n  const processed = `${prefix} ${text} ${suffix}`.trim()\n  return processed\n    .replace(/([a-z])([A-Z])/g, '$1_$2')\n    .replace(/[\\s\\-.]+/g, '_')\n    .replace(/[^a-zA-Z0-9_]/g, '')\n    .toLowerCase()\n    .split('_')\n    .filter(Boolean)\n    .join('_')\n}\n\n/**\n * Converts `text` to SCREAMING_SNAKE_CASE.\n *\n * @example\n * screamingSnakeCase('helloWorld') // 'HELLO_WORLD'\n */\nexport function screamingSnakeCase(text: string, { prefix = '', suffix = '' }: Omit<Options, 'isFile'> = {}): string {\n  return snakeCase(text, { prefix, suffix }).toUpperCase()\n}\n","/**\n * JavaScript and Java reserved words.\n * @link https://github.com/jonschlinkert/reserved/blob/master/index.js\n */\nconst reservedWords = new Set([\n  'abstract',\n  'arguments',\n  'boolean',\n  'break',\n  'byte',\n  'case',\n  'catch',\n  'char',\n  'class',\n  'const',\n  'continue',\n  'debugger',\n  'default',\n  'delete',\n  'do',\n  'double',\n  'else',\n  'enum',\n  'eval',\n  'export',\n  'extends',\n  'false',\n  'final',\n  'finally',\n  'float',\n  'for',\n  'function',\n  'goto',\n  'if',\n  'implements',\n  'import',\n  'in',\n  'instanceof',\n  'int',\n  'interface',\n  'let',\n  'long',\n  'native',\n  'new',\n  'null',\n  'package',\n  'private',\n  'protected',\n  'public',\n  'return',\n  'short',\n  'static',\n  'super',\n  'switch',\n  'synchronized',\n  'this',\n  'throw',\n  'throws',\n  'transient',\n  'true',\n  'try',\n  'typeof',\n  'var',\n  'void',\n  'volatile',\n  'while',\n  'with',\n  'yield',\n  'Array',\n  'Date',\n  'hasOwnProperty',\n  'Infinity',\n  'isFinite',\n  'isNaN',\n  'isPrototypeOf',\n  'length',\n  'Math',\n  'name',\n  'NaN',\n  'Number',\n  'Object',\n  'prototype',\n  'String',\n  'toString',\n  'undefined',\n  'valueOf',\n] as const)\n\n/**\n * Prefixes a word with `_` when it is a reserved JavaScript/Java identifier\n * or starts with a digit.\n */\nexport function transformReservedWord(word: string): string {\n  const firstChar = word.charCodeAt(0)\n  if (word && (reservedWords.has(word as 'valueOf') || (firstChar >= 48 && firstChar <= 57))) {\n    return `_${word}`\n  }\n  return word\n}\n\n/**\n * Returns `true` when `name` is a syntactically valid JavaScript variable name.\n */\nexport function isValidVarName(name: string): boolean {\n  try {\n    new Function(`var ${name}`)\n  } catch {\n    return false\n  }\n  return true\n}\n","import { camelCase, isValidVarName } from '@internals/utils'\nimport type { KubbFile } from '@kubb/fabric-core/types'\nimport type { SchemaObject } from '@kubb/oas'\nimport type { OperationSchemas } from '@kubb/plugin-oas'\nimport { isOptional } from '@kubb/plugin-oas/utils'\nimport { Const, File, FunctionParams } from '@kubb/react-fabric'\nimport type { FabricReactNode } from '@kubb/react-fabric/types'\n\ntype Props = {\n  name: string\n  serverName: string\n  serverVersion: string\n  paramsCasing?: 'camelcase'\n  operations: Array<{\n    tool: {\n      name: string\n      title?: string\n      description: string\n    }\n    mcp: {\n      name: string\n      file: KubbFile.File\n    }\n    zod: {\n      name: string\n      file: KubbFile.File\n      schemas: OperationSchemas\n    }\n    type: {\n      schemas: OperationSchemas\n    }\n  }>\n}\n\ntype GetParamsProps = {\n  schemas: OperationSchemas\n  paramsCasing?: 'camelcase'\n}\n\nfunction zodExprFromOasSchema(schema: SchemaObject): string {\n  const types = Array.isArray(schema.type) ? schema.type : [schema.type]\n  const baseType = types.find((t) => t && t !== 'null')\n  const isNullableType = types.includes('null')\n\n  let expr: string\n  switch (baseType) {\n    case 'integer':\n      expr = 'z.coerce.number()'\n      break\n    case 'number':\n      expr = 'z.number()'\n      break\n    case 'boolean':\n      expr = 'z.boolean()'\n      break\n    case 'array':\n      expr = 'z.array(z.unknown())'\n      break\n    default:\n      expr = 'z.string()'\n  }\n\n  if (isNullableType) {\n    expr = `${expr}.nullable()`\n  }\n\n  return expr\n}\n\nfunction getParams({ schemas, paramsCasing }: GetParamsProps) {\n  const pathParamProperties = schemas.pathParams?.schema?.properties ?? {}\n  const requiredFields = Array.isArray(schemas.pathParams?.schema?.required) ? schemas.pathParams.schema.required : []\n\n  const pathParamEntries = Object.entries(pathParamProperties).reduce<Record<string, { value: string; optional: boolean }>>(\n    (acc, [originalKey, propSchema]) => {\n      const key = paramsCasing === 'camelcase' || !isValidVarName(originalKey) ? camelCase(originalKey) : originalKey\n      acc[key] = {\n        value: zodExprFromOasSchema(propSchema as SchemaObject),\n        optional: !requiredFields.includes(originalKey),\n      }\n      return acc\n    },\n    {},\n  )\n\n  return FunctionParams.factory({\n    data: {\n      mode: 'object',\n      children: {\n        ...pathParamEntries,\n        data: schemas.request?.name\n          ? {\n              value: schemas.request?.name,\n              optional: isOptional(schemas.request?.schema),\n            }\n          : undefined,\n        params: schemas.queryParams?.name\n          ? {\n              value: schemas.queryParams?.name,\n              optional: isOptional(schemas.queryParams?.schema),\n            }\n          : undefined,\n        headers: schemas.headerParams?.name\n          ? {\n              value: schemas.headerParams?.name,\n              optional: isOptional(schemas.headerParams?.schema),\n            }\n          : undefined,\n      },\n    },\n  })\n}\n\nexport function Server({ name, serverName, serverVersion, paramsCasing, operations }: Props): FabricReactNode {\n  return (\n    <File.Source name={name} isExportable isIndexable>\n      <Const name={'server'} export>\n        {`\n          new McpServer({\n  name: '${serverName}',\n  version: '${serverVersion}',\n})\n          `}\n      </Const>\n\n      {operations\n        .map(({ tool, mcp, zod }) => {\n          const paramsClient = getParams({ schemas: zod.schemas, paramsCasing })\n          const outputSchema = zod.schemas.response?.name\n\n          const config = [\n            tool.title ? `title: ${JSON.stringify(tool.title)}` : null,\n            `description: ${JSON.stringify(tool.description)}`,\n            outputSchema ? `outputSchema: { data: ${outputSchema} }` : null,\n          ]\n            .filter(Boolean)\n            .join(',\\n  ')\n\n          if (zod.schemas.request?.name || zod.schemas.headerParams?.name || zod.schemas.queryParams?.name || zod.schemas.pathParams?.name) {\n            return `\nserver.registerTool(${JSON.stringify(tool.name)}, {\n  ${config},\n  inputSchema: ${paramsClient.toObjectValue()},\n}, async (${paramsClient.toObject()}) => {\n  return ${mcp.name}(${paramsClient.toObject()})\n})\n          `\n          }\n\n          return `\nserver.registerTool(${JSON.stringify(tool.name)}, {\n  ${config},\n}, async () => {\n  return ${mcp.name}(${paramsClient.toObject()})\n})\n          `\n        })\n        .filter(Boolean)}\n\n      {`\nexport async function startServer() {\n  try {\n    const transport = new StdioServerTransport()\n    await server.connect(transport)\n\n  } catch (error) {\n    console.error('Failed to start server:', error)\n    process.exit(1)\n  }\n}\n`}\n    </File.Source>\n  )\n}\n"],"mappings":"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"}

package/dist/Server-KWLMg0Lm.js

@@ -1,173 +0,0 @@
-import "./chunk--u3MIqq1.js";
-import { isOptional } from "@kubb/plugin-oas/utils";
-import { Const, File, FunctionParams } from "@kubb/react-fabric";
-import { jsx, jsxs } from "@kubb/react-fabric/jsx-runtime";
-//#region ../../internals/utils/src/casing.ts
-/**
-* Shared implementation for camelCase and PascalCase conversion.
-* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
-* and capitalizes each word according to `pascal`.
-*
-* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
-*/
-function toCamelOrPascal(text, pascal) {
-	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
-		if (word.length > 1 && word === word.toUpperCase()) return word;
-		if (i === 0 && !pascal) return word.charAt(0).toLowerCase() + word.slice(1);
-		return word.charAt(0).toUpperCase() + word.slice(1);
-	}).join("").replace(/[^a-zA-Z0-9]/g, "");
-}
-/**
-* Splits `text` on `.` and applies `transformPart` to each segment.
-* The last segment receives `isLast = true`, all earlier segments receive `false`.
-* Segments are joined with `/` to form a file path.
-*/
-function applyToFileParts(text, transformPart) {
-	const parts = text.split(".");
-	return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
-}
-/**
-* Converts `text` to camelCase.
-* When `isFile` is `true`, dot-separated segments are each cased independently and joined with `/`.
-*
-* @example
-* camelCase('hello-world')                   // 'helloWorld'
-* camelCase('pet.petId', { isFile: true })   // 'pet/petId'
-*/
-function camelCase(text, { isFile, prefix = "", suffix = "" } = {}) {
-	if (isFile) return applyToFileParts(text, (part, isLast) => camelCase(part, isLast ? {
-		prefix,
-		suffix
-	} : {}));
-	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
-}
-//#endregion
-//#region ../../internals/utils/src/reserved.ts
-/**
-* Returns `true` when `name` is a syntactically valid JavaScript variable name.
-*/
-function isValidVarName(name) {
-	try {
-		new Function(`var ${name}`);
-	} catch {
-		return false;
-	}
-	return true;
-}
-//#endregion
-//#region src/components/Server.tsx
-function zodExprFromOasSchema(schema) {
-	const types = Array.isArray(schema.type) ? schema.type : [schema.type];
-	const baseType = types.find((t) => t && t !== "null");
-	const isNullableType = types.includes("null");
-	let expr;
-	switch (baseType) {
-		case "integer":
-			expr = "z.coerce.number()";
-			break;
-		case "number":
-			expr = "z.number()";
-			break;
-		case "boolean":
-			expr = "z.boolean()";
-			break;
-		case "array":
-			expr = "z.array(z.unknown())";
-			break;
-		default: expr = "z.string()";
-	}
-	if (isNullableType) expr = `${expr}.nullable()`;
-	return expr;
-}
-function getParams({ schemas, paramsCasing }) {
-	const pathParamProperties = schemas.pathParams?.schema?.properties ?? {};
-	const requiredFields = Array.isArray(schemas.pathParams?.schema?.required) ? schemas.pathParams.schema.required : [];
-	const pathParamEntries = Object.entries(pathParamProperties).reduce((acc, [originalKey, propSchema]) => {
-		const key = paramsCasing === "camelcase" || !isValidVarName(originalKey) ? camelCase(originalKey) : originalKey;
-		acc[key] = {
-			value: zodExprFromOasSchema(propSchema),
-			optional: !requiredFields.includes(originalKey)
-		};
-		return acc;
-	}, {});
-	return FunctionParams.factory({ data: {
-		mode: "object",
-		children: {
-			...pathParamEntries,
-			data: schemas.request?.name ? {
-				value: schemas.request?.name,
-				optional: isOptional(schemas.request?.schema)
-			} : void 0,
-			params: schemas.queryParams?.name ? {
-				value: schemas.queryParams?.name,
-				optional: isOptional(schemas.queryParams?.schema)
-			} : void 0,
-			headers: schemas.headerParams?.name ? {
-				value: schemas.headerParams?.name,
-				optional: isOptional(schemas.headerParams?.schema)
-			} : void 0
-		}
-	} });
-}
-function Server({ name, serverName, serverVersion, paramsCasing, operations }) {
-	return /* @__PURE__ */ jsxs(File.Source, {
-		name,
-		isExportable: true,
-		isIndexable: true,
-		children: [
-			/* @__PURE__ */ jsx(Const, {
-				name: "server",
-				export: true,
-				children: `
-          new McpServer({
-  name: '${serverName}',
-  version: '${serverVersion}',
-})
-          `
-			}),
-			operations.map(({ tool, mcp, zod }) => {
-				const paramsClient = getParams({
-					schemas: zod.schemas,
-					paramsCasing
-				});
-				const outputSchema = zod.schemas.response?.name;
-				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 (zod.schemas.request?.name || zod.schemas.headerParams?.name || zod.schemas.queryParams?.name || zod.schemas.pathParams?.name) return `
-server.registerTool(${JSON.stringify(tool.name)}, {
-  ${config},
-  inputSchema: ${paramsClient.toObjectValue()},
-}, async (${paramsClient.toObject()}) => {
-  return ${mcp.name}(${paramsClient.toObject()})
-})
-          `;
-				return `
-server.registerTool(${JSON.stringify(tool.name)}, {
-  ${config},
-}, async () => {
-  return ${mcp.name}(${paramsClient.toObject()})
-})
-          `;
-			}).filter(Boolean),
-			`
-export async function startServer() {
-  try {
-    const transport = new StdioServerTransport()
-    await server.connect(transport)
-
-  } catch (error) {
-    console.error('Failed to start server:', error)
-    process.exit(1)
-  }
-}
-`
-		]
-	});
-}
-//#endregion
-export { camelCase as n, Server as t };
-
-//# sourceMappingURL=Server-KWLMg0Lm.js.map