@payloadcms/plugin-mcp 4.0.0-internal.d28e9fb → 4.0.0-internal.d7d662c

package/dist/utils/schemaConversion/convertCollectionSchemaToZod.js

@@ -1,43 +0,0 @@
-import { jsonSchemaToZod } from 'json-schema-to-zod';
-import * as ts from 'typescript';
-import { z } from 'zod';
-import { sanitizeJsonSchema } from './sanitizeJsonSchema.js';
-import { simplifyRelationshipFields } from './simplifyRelationshipFields.js';
-import { transformPointFieldsForMCP } from './transformPointFields.js';
-export const convertCollectionSchemaToZod = (schema)=>{
-    try {
-        // Clone to avoid mutating the original schema (used elsewhere for tool listing)
-        const schemaClone = JSON.parse(JSON.stringify(schema));
-        const sanitized = sanitizeJsonSchema(schemaClone);
-        const pointTransformed = transformPointFieldsForMCP(sanitized);
-        const zodSchemaAsString = jsonSchemaToZod(simplifyRelationshipFields(pointTransformed));
-        // Transpile TypeScript to JavaScript
-        const transpileResult = ts.transpileModule(zodSchemaAsString, {
-            compilerOptions: {
-                module: ts.ModuleKind.CommonJS,
-                removeComments: true,
-                strict: false,
-                target: ts.ScriptTarget.ES2018
-            }
-        });
-        /**
-     * This Function evaluation is safe because:
-     * 1. The input schema comes from Payload's collection configuration, which is controlled by the application developer
-     * 2. The jsonSchemaToZod library converts JSON Schema to Zod schema definitions, producing only type validation code
-     * 3. The transpiled output contains only Zod schema definitions (z.string(), z.number(), etc.) - no executable logic
-     * 4. The resulting Zod schema is used only for parameter validation in MCP tools, not for data processing
-     * 5. No user input or external data is involved in the schema generation process
-     */ // eslint-disable-next-line @typescript-eslint/no-implied-eval
-        return new Function('z', `return ${transpileResult.outputText}`)(z);
-    } catch (error) {
-        // If schema conversion fails (e.g., due to Zod v4 toJSONSchema null-check bug
-        // with record schemas that have undefined valueType, or bundler transforms
-        // stripping Zod internals), return a permissive schema so tools/list doesn't
-        // crash entirely. The tool will still be listed but without strict validation.
-        // See: https://github.com/colinhacks/zod/issues/5821
-        console.warn(`[plugin-mcp] Schema conversion failed, using permissive fallback:`, error instanceof Error ? error.message : error);
-        return z.record(z.any());
-    }
-};
-
-//# sourceMappingURL=convertCollectionSchemaToZod.js.map

package/dist/utils/schemaConversion/convertCollectionSchemaToZod.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/utils/schemaConversion/convertCollectionSchemaToZod.ts"],"sourcesContent":["import type { JSONSchema4 } from 'json-schema'\n\nimport { jsonSchemaToZod } from 'json-schema-to-zod'\nimport * as ts from 'typescript'\nimport { z } from 'zod'\n\nimport { sanitizeJsonSchema } from './sanitizeJsonSchema.js'\nimport { simplifyRelationshipFields } from './simplifyRelationshipFields.js'\nimport { transformPointFieldsForMCP } from './transformPointFields.js'\n\nexport const convertCollectionSchemaToZod = (schema: JSONSchema4) => {\n  try {\n    // Clone to avoid mutating the original schema (used elsewhere for tool listing)\n    const schemaClone = JSON.parse(JSON.stringify(schema)) as JSONSchema4\n\n    const sanitized = sanitizeJsonSchema(schemaClone)\n    const pointTransformed = transformPointFieldsForMCP(sanitized)\n    const zodSchemaAsString = jsonSchemaToZod(simplifyRelationshipFields(pointTransformed))\n\n    // Transpile TypeScript to JavaScript\n    const transpileResult = ts.transpileModule(zodSchemaAsString, {\n      compilerOptions: {\n        module: ts.ModuleKind.CommonJS,\n        removeComments: true,\n        strict: false,\n        target: ts.ScriptTarget.ES2018,\n      },\n    })\n\n    /**\n     * This Function evaluation is safe because:\n     * 1. The input schema comes from Payload's collection configuration, which is controlled by the application developer\n     * 2. The jsonSchemaToZod library converts JSON Schema to Zod schema definitions, producing only type validation code\n     * 3. The transpiled output contains only Zod schema definitions (z.string(), z.number(), etc.) - no executable logic\n     * 4. The resulting Zod schema is used only for parameter validation in MCP tools, not for data processing\n     * 5. No user input or external data is involved in the schema generation process\n     */\n    // eslint-disable-next-line @typescript-eslint/no-implied-eval\n    return new Function('z', `return ${transpileResult.outputText}`)(z)\n  } catch (error) {\n    // If schema conversion fails (e.g., due to Zod v4 toJSONSchema null-check bug\n    // with record schemas that have undefined valueType, or bundler transforms\n    // stripping Zod internals), return a permissive schema so tools/list doesn't\n    // crash entirely. The tool will still be listed but without strict validation.\n    // See: https://github.com/colinhacks/zod/issues/5821\n    console.warn(\n      `[plugin-mcp] Schema conversion failed, using permissive fallback:`,\n      error instanceof Error ? error.message : error,\n    )\n    return z.record(z.any())\n  }\n}\n"],"names":["jsonSchemaToZod","ts","z","sanitizeJsonSchema","simplifyRelationshipFields","transformPointFieldsForMCP","convertCollectionSchemaToZod","schema","schemaClone","JSON","parse","stringify","sanitized","pointTransformed","zodSchemaAsString","transpileResult","transpileModule","compilerOptions","module","ModuleKind","CommonJS","removeComments","strict","target","ScriptTarget","ES2018","Function","outputText","error","console","warn","Error","message","record","any"],"mappings":"AAEA,SAASA,eAAe,QAAQ,qBAAoB;AACpD,YAAYC,QAAQ,aAAY;AAChC,SAASC,CAAC,QAAQ,MAAK;AAEvB,SAASC,kBAAkB,QAAQ,0BAAyB;AAC5D,SAASC,0BAA0B,QAAQ,kCAAiC;AAC5E,SAASC,0BAA0B,QAAQ,4BAA2B;AAEtE,OAAO,MAAMC,+BAA+B,CAACC;IAC3C,IAAI;QACF,gFAAgF;QAChF,MAAMC,cAAcC,KAAKC,KAAK,CAACD,KAAKE,SAAS,CAACJ;QAE9C,MAAMK,YAAYT,mBAAmBK;QACrC,MAAMK,mBAAmBR,2BAA2BO;QACpD,MAAME,oBAAoBd,gBAAgBI,2BAA2BS;QAErE,qCAAqC;QACrC,MAAME,kBAAkBd,GAAGe,eAAe,CAACF,mBAAmB;YAC5DG,iBAAiB;gBACfC,QAAQjB,GAAGkB,UAAU,CAACC,QAAQ;gBAC9BC,gBAAgB;gBAChBC,QAAQ;gBACRC,QAAQtB,GAAGuB,YAAY,CAACC,MAAM;YAChC;QACF;QAEA;;;;;;;KAOC,GACD,8DAA8D;QAC9D,OAAO,IAAIC,SAAS,KAAK,CAAC,OAAO,EAAEX,gBAAgBY,UAAU,EAAE,EAAEzB;IACnE,EAAE,OAAO0B,OAAO;QACd,8EAA8E;QAC9E,2EAA2E;QAC3E,6EAA6E;QAC7E,+EAA+E;QAC/E,qDAAqD;QACrDC,QAAQC,IAAI,CACV,CAAC,iEAAiE,CAAC,EACnEF,iBAAiBG,QAAQH,MAAMI,OAAO,GAAGJ;QAE3C,OAAO1B,EAAE+B,MAAM,CAAC/B,EAAEgC,GAAG;IACvB;AACF,EAAC"}

package/dist/utils/schemaConversion/removeVirtualFieldsFromSchema.d.ts

@@ -1,7 +0,0 @@
-import type { JSONSchema4 } from 'json-schema';
-/**
- * Removes virtual fields from a JSON Schema by name so they don't appear
- * in the generated MCP tool input schema.
- */
-export declare function removeVirtualFieldsFromSchema(schema: JSONSchema4, virtualFieldNames: string[]): JSONSchema4;
-//# sourceMappingURL=removeVirtualFieldsFromSchema.d.ts.map

package/dist/utils/schemaConversion/removeVirtualFieldsFromSchema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"removeVirtualFieldsFromSchema.d.ts","sourceRoot":"","sources":["../../../src/utils/schemaConversion/removeVirtualFieldsFromSchema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAE9C;;;GAGG;AACH,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,WAAW,EACnB,iBAAiB,EAAE,MAAM,EAAE,GAC1B,WAAW,CAiBb"}

package/dist/utils/schemaConversion/removeVirtualFieldsFromSchema.js

@@ -1,20 +0,0 @@
-/**
- * Removes virtual fields from a JSON Schema by name so they don't appear
- * in the generated MCP tool input schema.
- */ export function removeVirtualFieldsFromSchema(schema, virtualFieldNames) {
-    if (virtualFieldNames.length === 0) {
-        return schema;
-    }
-    for (const name of virtualFieldNames){
-        delete schema?.properties?.[name];
-    }
-    if (Array.isArray(schema.required)) {
-        schema.required = schema.required.filter((field)=>!virtualFieldNames.includes(field));
-        if (schema.required.length === 0) {
-            delete schema.required;
-        }
-    }
-    return schema;
-}
-
-//# sourceMappingURL=removeVirtualFieldsFromSchema.js.map

package/dist/utils/schemaConversion/removeVirtualFieldsFromSchema.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/utils/schemaConversion/removeVirtualFieldsFromSchema.ts"],"sourcesContent":["import type { JSONSchema4 } from 'json-schema'\n\n/**\n * Removes virtual fields from a JSON Schema by name so they don't appear\n * in the generated MCP tool input schema.\n */\nexport function removeVirtualFieldsFromSchema(\n  schema: JSONSchema4,\n  virtualFieldNames: string[],\n): JSONSchema4 {\n  if (virtualFieldNames.length === 0) {\n    return schema\n  }\n\n  for (const name of virtualFieldNames) {\n    delete schema?.properties?.[name]\n  }\n\n  if (Array.isArray(schema.required)) {\n    schema.required = schema.required.filter((field) => !virtualFieldNames.includes(field))\n    if (schema.required.length === 0) {\n      delete schema.required\n    }\n  }\n\n  return schema\n}\n"],"names":["removeVirtualFieldsFromSchema","schema","virtualFieldNames","length","name","properties","Array","isArray","required","filter","field","includes"],"mappings":"AAEA;;;CAGC,GACD,OAAO,SAASA,8BACdC,MAAmB,EACnBC,iBAA2B;IAE3B,IAAIA,kBAAkBC,MAAM,KAAK,GAAG;QAClC,OAAOF;IACT;IAEA,KAAK,MAAMG,QAAQF,kBAAmB;QACpC,OAAOD,QAAQI,YAAY,CAACD,KAAK;IACnC;IAEA,IAAIE,MAAMC,OAAO,CAACN,OAAOO,QAAQ,GAAG;QAClCP,OAAOO,QAAQ,GAAGP,OAAOO,QAAQ,CAACC,MAAM,CAAC,CAACC,QAAU,CAACR,kBAAkBS,QAAQ,CAACD;QAChF,IAAIT,OAAOO,QAAQ,CAACL,MAAM,KAAK,GAAG;YAChC,OAAOF,OAAOO,QAAQ;QACxB;IACF;IAEA,OAAOP;AACT"}

package/dist/utils/schemaConversion/sanitizeJsonSchema.d.ts

@@ -1,13 +0,0 @@
-import type { JSONSchema4 } from 'json-schema';
-/**
- * Removes internal Payload properties (id, createdAt, updatedAt) from a
- * JSON Schema so they don't appear in the generated Zod validation schema.
- * Also strips `id` from the `required` array when present.
- *
- * Additionally normalizes nullable type arrays (e.g. `['array', 'null']` →
- * `'array'`) throughout the schema tree. Without this, `json-schema-to-zod`
- * emits a Zod union which the MCP SDK serialises back as `anyOf`, stripping
- * the concrete `type` from the output and breaking schema introspection.
- */
-export declare function sanitizeJsonSchema(schema: JSONSchema4): JSONSchema4;
-//# sourceMappingURL=sanitizeJsonSchema.d.ts.map

package/dist/utils/schemaConversion/sanitizeJsonSchema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sanitizeJsonSchema.d.ts","sourceRoot":"","sources":["../../../src/utils/schemaConversion/sanitizeJsonSchema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAE9C;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,WAAW,GAAG,WAAW,CA6BnE"}

package/dist/utils/schemaConversion/sanitizeJsonSchema.js

@@ -1,56 +0,0 @@
-/**
- * Removes internal Payload properties (id, createdAt, updatedAt) from a
- * JSON Schema so they don't appear in the generated Zod validation schema.
- * Also strips `id` from the `required` array when present.
- *
- * Additionally normalizes nullable type arrays (e.g. `['array', 'null']` →
- * `'array'`) throughout the schema tree. Without this, `json-schema-to-zod`
- * emits a Zod union which the MCP SDK serialises back as `anyOf`, stripping
- * the concrete `type` from the output and breaking schema introspection.
- */ export function sanitizeJsonSchema(schema) {
-    delete schema?.properties?.id;
-    delete schema?.properties?.createdAt;
-    delete schema?.properties?.updatedAt;
-    if (Array.isArray(schema.required)) {
-        schema.required = schema.required.filter((field)=>field !== 'id');
-        if (schema.required.length === 0) {
-            delete schema.required;
-        }
-    }
-    if (schema.properties && typeof schema.properties === 'object') {
-        for (const key of Object.keys(schema.properties)){
-            const prop = schema.properties[key];
-            if (!prop || typeof prop !== 'object') {
-                continue;
-            }
-            normalizeNullableType(prop);
-            if (prop.properties) {
-                sanitizeJsonSchema(prop);
-            }
-            if (prop.items && typeof prop.items === 'object' && !Array.isArray(prop.items)) {
-                sanitizeJsonSchema(prop.items);
-            }
-        }
-    }
-    return schema;
-}
-/**
- * Strips `'null'` from a `type` array only when the remaining type is a
- * complex structural type (`array` or `object`).
- *
- * Simple scalar types (`string`, `number`, `boolean`) are intentionally
- * preserved as `['string', 'null']` so that the MCP SDK serialises them as a
- * compact inline `type` array. Complex types however cause `zodToJsonSchema`
- * to emit `anyOf: [{ type: 'array', items: ... }, { type: 'null' }]`, which
- * has no top-level `type` property and breaks schema introspection by clients.
- */ function normalizeNullableType(schema) {
-    if (!Array.isArray(schema.type)) {
-        return;
-    }
-    const nonNullTypes = schema.type.filter((t)=>t !== 'null');
-    if (nonNullTypes.length === 1 && (nonNullTypes[0] === 'array' || nonNullTypes[0] === 'object')) {
-        schema.type = nonNullTypes[0];
-    }
-}
-
-//# sourceMappingURL=sanitizeJsonSchema.js.map

package/dist/utils/schemaConversion/sanitizeJsonSchema.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/utils/schemaConversion/sanitizeJsonSchema.ts"],"sourcesContent":["import type { JSONSchema4 } from 'json-schema'\n\n/**\n * Removes internal Payload properties (id, createdAt, updatedAt) from a\n * JSON Schema so they don't appear in the generated Zod validation schema.\n * Also strips `id` from the `required` array when present.\n *\n * Additionally normalizes nullable type arrays (e.g. `['array', 'null']` →\n * `'array'`) throughout the schema tree. Without this, `json-schema-to-zod`\n * emits a Zod union which the MCP SDK serialises back as `anyOf`, stripping\n * the concrete `type` from the output and breaking schema introspection.\n */\nexport function sanitizeJsonSchema(schema: JSONSchema4): JSONSchema4 {\n  delete schema?.properties?.id\n  delete schema?.properties?.createdAt\n  delete schema?.properties?.updatedAt\n\n  if (Array.isArray(schema.required)) {\n    schema.required = schema.required.filter((field) => field !== 'id')\n    if (schema.required.length === 0) {\n      delete schema.required\n    }\n  }\n\n  if (schema.properties && typeof schema.properties === 'object') {\n    for (const key of Object.keys(schema.properties)) {\n      const prop = schema.properties[key] as JSONSchema4\n      if (!prop || typeof prop !== 'object') {\n        continue\n      }\n      normalizeNullableType(prop)\n      if (prop.properties) {\n        sanitizeJsonSchema(prop)\n      }\n      if (prop.items && typeof prop.items === 'object' && !Array.isArray(prop.items)) {\n        sanitizeJsonSchema(prop.items)\n      }\n    }\n  }\n\n  return schema\n}\n\n/**\n * Strips `'null'` from a `type` array only when the remaining type is a\n * complex structural type (`array` or `object`).\n *\n * Simple scalar types (`string`, `number`, `boolean`) are intentionally\n * preserved as `['string', 'null']` so that the MCP SDK serialises them as a\n * compact inline `type` array. Complex types however cause `zodToJsonSchema`\n * to emit `anyOf: [{ type: 'array', items: ... }, { type: 'null' }]`, which\n * has no top-level `type` property and breaks schema introspection by clients.\n */\nfunction normalizeNullableType(schema: JSONSchema4): void {\n  if (!Array.isArray(schema.type)) {\n    return\n  }\n  const nonNullTypes = schema.type.filter((t) => t !== 'null')\n  if (nonNullTypes.length === 1 && (nonNullTypes[0] === 'array' || nonNullTypes[0] === 'object')) {\n    schema.type = nonNullTypes[0]\n  }\n}\n"],"names":["sanitizeJsonSchema","schema","properties","id","createdAt","updatedAt","Array","isArray","required","filter","field","length","key","Object","keys","prop","normalizeNullableType","items","type","nonNullTypes","t"],"mappings":"AAEA;;;;;;;;;CASC,GACD,OAAO,SAASA,mBAAmBC,MAAmB;IACpD,OAAOA,QAAQC,YAAYC;IAC3B,OAAOF,QAAQC,YAAYE;IAC3B,OAAOH,QAAQC,YAAYG;IAE3B,IAAIC,MAAMC,OAAO,CAACN,OAAOO,QAAQ,GAAG;QAClCP,OAAOO,QAAQ,GAAGP,OAAOO,QAAQ,CAACC,MAAM,CAAC,CAACC,QAAUA,UAAU;QAC9D,IAAIT,OAAOO,QAAQ,CAACG,MAAM,KAAK,GAAG;YAChC,OAAOV,OAAOO,QAAQ;QACxB;IACF;IAEA,IAAIP,OAAOC,UAAU,IAAI,OAAOD,OAAOC,UAAU,KAAK,UAAU;QAC9D,KAAK,MAAMU,OAAOC,OAAOC,IAAI,CAACb,OAAOC,UAAU,EAAG;YAChD,MAAMa,OAAOd,OAAOC,UAAU,CAACU,IAAI;YACnC,IAAI,CAACG,QAAQ,OAAOA,SAAS,UAAU;gBACrC;YACF;YACAC,sBAAsBD;YACtB,IAAIA,KAAKb,UAAU,EAAE;gBACnBF,mBAAmBe;YACrB;YACA,IAAIA,KAAKE,KAAK,IAAI,OAAOF,KAAKE,KAAK,KAAK,YAAY,CAACX,MAAMC,OAAO,CAACQ,KAAKE,KAAK,GAAG;gBAC9EjB,mBAAmBe,KAAKE,KAAK;YAC/B;QACF;IACF;IAEA,OAAOhB;AACT;AAEA;;;;;;;;;CASC,GACD,SAASe,sBAAsBf,MAAmB;IAChD,IAAI,CAACK,MAAMC,OAAO,CAACN,OAAOiB,IAAI,GAAG;QAC/B;IACF;IACA,MAAMC,eAAelB,OAAOiB,IAAI,CAACT,MAAM,CAAC,CAACW,IAAMA,MAAM;IACrD,IAAID,aAAaR,MAAM,KAAK,KAAMQ,CAAAA,YAAY,CAAC,EAAE,KAAK,WAAWA,YAAY,CAAC,EAAE,KAAK,QAAO,GAAI;QAC9FlB,OAAOiB,IAAI,GAAGC,YAAY,CAAC,EAAE;IAC/B;AACF"}

package/dist/utils/schemaConversion/simplifyRelationshipFields.d.ts

@@ -1,20 +0,0 @@
-import type { JSONSchema4 } from 'json-schema';
-/**
- * Recursively processes JSON schema properties to simplify relationship fields
- * and convert `oneOf` constructs into MCP-friendly schemas.
- *
- * For create/update validation we only need to accept IDs (string/number),
- * not populated objects. `$ref` options pointing to full entity definitions
- * are removed entirely from `oneOf` unions. When a single option remains the
- * `oneOf` is unwrapped; otherwise it is converted to `anyOf`.
- *
- * This matters because `json-schema-to-zod` converts `oneOf` into a strict
- * `z.any().superRefine(...)` validator whose base type is `z.any()`, causing
- * `zodToJsonSchema` to emit `{}` and losing all type information in the MCP
- * tool input schema. `anyOf` instead produces a clean `z.union([...])`.
- *
- * NOTE: This function must operate on a cloned schema to avoid mutating
- * the original JSON schema used for tool listing.
- */
-export declare function simplifyRelationshipFields(schema: JSONSchema4): JSONSchema4;
-//# sourceMappingURL=simplifyRelationshipFields.d.ts.map

package/dist/utils/schemaConversion/simplifyRelationshipFields.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"simplifyRelationshipFields.d.ts","sourceRoot":"","sources":["../../../src/utils/schemaConversion/simplifyRelationshipFields.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAE9C;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,WAAW,GAAG,WAAW,CA6C3E"}

package/dist/utils/schemaConversion/simplifyRelationshipFields.js

@@ -1,53 +0,0 @@
-/**
- * Recursively processes JSON schema properties to simplify relationship fields
- * and convert `oneOf` constructs into MCP-friendly schemas.
- *
- * For create/update validation we only need to accept IDs (string/number),
- * not populated objects. `$ref` options pointing to full entity definitions
- * are removed entirely from `oneOf` unions. When a single option remains the
- * `oneOf` is unwrapped; otherwise it is converted to `anyOf`.
- *
- * This matters because `json-schema-to-zod` converts `oneOf` into a strict
- * `z.any().superRefine(...)` validator whose base type is `z.any()`, causing
- * `zodToJsonSchema` to emit `{}` and losing all type information in the MCP
- * tool input schema. `anyOf` instead produces a clean `z.union([...])`.
- *
- * NOTE: This function must operate on a cloned schema to avoid mutating
- * the original JSON schema used for tool listing.
- */ export function simplifyRelationshipFields(schema) {
-    if (!schema || typeof schema !== 'object') {
-        return schema;
-    }
-    const processed = {
-        ...schema
-    };
-    if (Array.isArray(processed.oneOf)) {
-        const hasRef = processed.oneOf.some((option)=>option && typeof option === 'object' && '$ref' in option);
-        if (hasRef) {
-            const nonRefOptions = processed.oneOf.filter((option)=>!(option && typeof option === 'object' && '$ref' in option)).map((option)=>simplifyRelationshipFields(option));
-            if (nonRefOptions.length === 1) {
-                const single = nonRefOptions[0];
-                delete processed.oneOf;
-                Object.assign(processed, single);
-            } else if (nonRefOptions.length > 1) {
-                delete processed.oneOf;
-                processed.anyOf = nonRefOptions;
-            }
-        } else {
-            processed.anyOf = processed.oneOf.map((option)=>simplifyRelationshipFields(option));
-            delete processed.oneOf;
-        }
-    }
-    if (processed.properties && typeof processed.properties === 'object') {
-        processed.properties = Object.fromEntries(Object.entries(processed.properties).map(([key, value])=>[
-                key,
-                simplifyRelationshipFields(value)
-            ]));
-    }
-    if (processed.items && typeof processed.items === 'object' && !Array.isArray(processed.items)) {
-        processed.items = simplifyRelationshipFields(processed.items);
-    }
-    return processed;
-}
-
-//# sourceMappingURL=simplifyRelationshipFields.js.map

package/dist/utils/schemaConversion/simplifyRelationshipFields.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/utils/schemaConversion/simplifyRelationshipFields.ts"],"sourcesContent":["import type { JSONSchema4 } from 'json-schema'\n\n/**\n * Recursively processes JSON schema properties to simplify relationship fields\n * and convert `oneOf` constructs into MCP-friendly schemas.\n *\n * For create/update validation we only need to accept IDs (string/number),\n * not populated objects. `$ref` options pointing to full entity definitions\n * are removed entirely from `oneOf` unions. When a single option remains the\n * `oneOf` is unwrapped; otherwise it is converted to `anyOf`.\n *\n * This matters because `json-schema-to-zod` converts `oneOf` into a strict\n * `z.any().superRefine(...)` validator whose base type is `z.any()`, causing\n * `zodToJsonSchema` to emit `{}` and losing all type information in the MCP\n * tool input schema. `anyOf` instead produces a clean `z.union([...])`.\n *\n * NOTE: This function must operate on a cloned schema to avoid mutating\n * the original JSON schema used for tool listing.\n */\nexport function simplifyRelationshipFields(schema: JSONSchema4): JSONSchema4 {\n  if (!schema || typeof schema !== 'object') {\n    return schema\n  }\n\n  const processed = { ...schema }\n\n  if (Array.isArray(processed.oneOf)) {\n    const hasRef = processed.oneOf.some(\n      (option) => option && typeof option === 'object' && '$ref' in option,\n    )\n\n    if (hasRef) {\n      const nonRefOptions = processed.oneOf\n        .filter((option) => !(option && typeof option === 'object' && '$ref' in option))\n        .map((option) => simplifyRelationshipFields(option))\n\n      if (nonRefOptions.length === 1) {\n        const single = nonRefOptions[0]!\n        delete processed.oneOf\n        Object.assign(processed, single)\n      } else if (nonRefOptions.length > 1) {\n        delete processed.oneOf\n        processed.anyOf = nonRefOptions\n      }\n    } else {\n      processed.anyOf = processed.oneOf.map((option) => simplifyRelationshipFields(option))\n      delete processed.oneOf\n    }\n  }\n\n  if (processed.properties && typeof processed.properties === 'object') {\n    processed.properties = Object.fromEntries(\n      Object.entries(processed.properties).map(([key, value]) => [\n        key,\n        simplifyRelationshipFields(value),\n      ]),\n    )\n  }\n\n  if (processed.items && typeof processed.items === 'object' && !Array.isArray(processed.items)) {\n    processed.items = simplifyRelationshipFields(processed.items)\n  }\n\n  return processed\n}\n"],"names":["simplifyRelationshipFields","schema","processed","Array","isArray","oneOf","hasRef","some","option","nonRefOptions","filter","map","length","single","Object","assign","anyOf","properties","fromEntries","entries","key","value","items"],"mappings":"AAEA;;;;;;;;;;;;;;;;CAgBC,GACD,OAAO,SAASA,2BAA2BC,MAAmB;IAC5D,IAAI,CAACA,UAAU,OAAOA,WAAW,UAAU;QACzC,OAAOA;IACT;IAEA,MAAMC,YAAY;QAAE,GAAGD,MAAM;IAAC;IAE9B,IAAIE,MAAMC,OAAO,CAACF,UAAUG,KAAK,GAAG;QAClC,MAAMC,SAASJ,UAAUG,KAAK,CAACE,IAAI,CACjC,CAACC,SAAWA,UAAU,OAAOA,WAAW,YAAY,UAAUA;QAGhE,IAAIF,QAAQ;YACV,MAAMG,gBAAgBP,UAAUG,KAAK,CAClCK,MAAM,CAAC,CAACF,SAAW,CAAEA,CAAAA,UAAU,OAAOA,WAAW,YAAY,UAAUA,MAAK,GAC5EG,GAAG,CAAC,CAACH,SAAWR,2BAA2BQ;YAE9C,IAAIC,cAAcG,MAAM,KAAK,GAAG;gBAC9B,MAAMC,SAASJ,aAAa,CAAC,EAAE;gBAC/B,OAAOP,UAAUG,KAAK;gBACtBS,OAAOC,MAAM,CAACb,WAAWW;YAC3B,OAAO,IAAIJ,cAAcG,MAAM,GAAG,GAAG;gBACnC,OAAOV,UAAUG,KAAK;gBACtBH,UAAUc,KAAK,GAAGP;YACpB;QACF,OAAO;YACLP,UAAUc,KAAK,GAAGd,UAAUG,KAAK,CAACM,GAAG,CAAC,CAACH,SAAWR,2BAA2BQ;YAC7E,OAAON,UAAUG,KAAK;QACxB;IACF;IAEA,IAAIH,UAAUe,UAAU,IAAI,OAAOf,UAAUe,UAAU,KAAK,UAAU;QACpEf,UAAUe,UAAU,GAAGH,OAAOI,WAAW,CACvCJ,OAAOK,OAAO,CAACjB,UAAUe,UAAU,EAAEN,GAAG,CAAC,CAAC,CAACS,KAAKC,MAAM,GAAK;gBACzDD;gBACApB,2BAA2BqB;aAC5B;IAEL;IAEA,IAAInB,UAAUoB,KAAK,IAAI,OAAOpB,UAAUoB,KAAK,KAAK,YAAY,CAACnB,MAAMC,OAAO,CAACF,UAAUoB,KAAK,GAAG;QAC7FpB,UAAUoB,KAAK,GAAGtB,2BAA2BE,UAAUoB,KAAK;IAC9D;IAEA,OAAOpB;AACT"}

package/dist/utils/schemaConversion/transformPointFields.d.ts

@@ -1,3 +0,0 @@
-import type { JSONSchema4 } from 'json-schema';
-export declare function transformPointFieldsForMCP(schema: JSONSchema4): JSONSchema4;
-//# sourceMappingURL=transformPointFields.d.ts.map

package/dist/utils/schemaConversion/transformPointFields.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"transformPointFields.d.ts","sourceRoot":"","sources":["../../../src/utils/schemaConversion/transformPointFields.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAE9C,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,WAAW,GAAG,WAAW,CAoD3E"}

package/dist/utils/schemaConversion/transformPointFields.js

@@ -1,51 +0,0 @@
-export function transformPointFieldsForMCP(schema) {
-    if (!schema || typeof schema !== 'object') {
-        return schema;
-    }
-    const transformed = {
-        ...schema
-    };
-    if (transformed.properties && typeof transformed.properties === 'object') {
-        transformed.properties = Object.fromEntries(Object.entries(transformed.properties).map(([key, value])=>{
-            const isArrayType = value.type === 'array' || Array.isArray(value.type) && value.type.includes('array');
-            if (value && typeof value === 'object' && isArrayType && Array.isArray(value.items) && value.items.length === 2 && value.items.every((item)=>item?.type === 'number')) {
-                // Transform to object format
-                const isNullable = Array.isArray(value.type) && value.type.includes('null');
-                return [
-                    key,
-                    {
-                        type: isNullable ? [
-                            'object',
-                            'null'
-                        ] : 'object',
-                        description: value.description || 'Geographic coordinates (longitude, latitude)',
-                        properties: {
-                            latitude: {
-                                type: 'number',
-                                description: 'Latitude coordinate'
-                            },
-                            longitude: {
-                                type: 'number',
-                                description: 'Longitude coordinate'
-                            }
-                        },
-                        required: [
-                            'longitude',
-                            'latitude'
-                        ]
-                    }
-                ];
-            }
-            return [
-                key,
-                transformPointFieldsForMCP(value)
-            ];
-        }));
-    }
-    if (transformed.items && typeof transformed.items === 'object' && !Array.isArray(transformed.items)) {
-        transformed.items = transformPointFieldsForMCP(transformed.items);
-    }
-    return transformed;
-}
-
-//# sourceMappingURL=transformPointFields.js.map

package/dist/utils/schemaConversion/transformPointFields.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/utils/schemaConversion/transformPointFields.ts"],"sourcesContent":["import type { JSONSchema4 } from 'json-schema'\n\nexport function transformPointFieldsForMCP(schema: JSONSchema4): JSONSchema4 {\n  if (!schema || typeof schema !== 'object') {\n    return schema\n  }\n\n  const transformed = { ...schema }\n\n  if (transformed.properties && typeof transformed.properties === 'object') {\n    transformed.properties = Object.fromEntries(\n      Object.entries(transformed.properties).map(([key, value]) => {\n        const isArrayType =\n          value.type === 'array' || (Array.isArray(value.type) && value.type.includes('array'))\n\n        if (\n          value &&\n          typeof value === 'object' &&\n          isArrayType &&\n          Array.isArray(value.items) &&\n          value.items.length === 2 &&\n          value.items.every((item: JSONSchema4) => item?.type === 'number')\n        ) {\n          // Transform to object format\n          const isNullable = Array.isArray(value.type) && value.type.includes('null')\n\n          return [\n            key,\n            {\n              type: isNullable ? ['object', 'null'] : 'object',\n              description: value.description || 'Geographic coordinates (longitude, latitude)',\n              properties: {\n                latitude: { type: 'number', description: 'Latitude coordinate' },\n                longitude: { type: 'number', description: 'Longitude coordinate' },\n              },\n              required: ['longitude', 'latitude'],\n            },\n          ]\n        }\n\n        return [key, transformPointFieldsForMCP(value)]\n      }),\n    )\n  }\n\n  if (\n    transformed.items &&\n    typeof transformed.items === 'object' &&\n    !Array.isArray(transformed.items)\n  ) {\n    transformed.items = transformPointFieldsForMCP(transformed.items)\n  }\n\n  return transformed\n}\n"],"names":["transformPointFieldsForMCP","schema","transformed","properties","Object","fromEntries","entries","map","key","value","isArrayType","type","Array","isArray","includes","items","length","every","item","isNullable","description","latitude","longitude","required"],"mappings":"AAEA,OAAO,SAASA,2BAA2BC,MAAmB;IAC5D,IAAI,CAACA,UAAU,OAAOA,WAAW,UAAU;QACzC,OAAOA;IACT;IAEA,MAAMC,cAAc;QAAE,GAAGD,MAAM;IAAC;IAEhC,IAAIC,YAAYC,UAAU,IAAI,OAAOD,YAAYC,UAAU,KAAK,UAAU;QACxED,YAAYC,UAAU,GAAGC,OAAOC,WAAW,CACzCD,OAAOE,OAAO,CAACJ,YAAYC,UAAU,EAAEI,GAAG,CAAC,CAAC,CAACC,KAAKC,MAAM;YACtD,MAAMC,cACJD,MAAME,IAAI,KAAK,WAAYC,MAAMC,OAAO,CAACJ,MAAME,IAAI,KAAKF,MAAME,IAAI,CAACG,QAAQ,CAAC;YAE9E,IACEL,SACA,OAAOA,UAAU,YACjBC,eACAE,MAAMC,OAAO,CAACJ,MAAMM,KAAK,KACzBN,MAAMM,KAAK,CAACC,MAAM,KAAK,KACvBP,MAAMM,KAAK,CAACE,KAAK,CAAC,CAACC,OAAsBA,MAAMP,SAAS,WACxD;gBACA,6BAA6B;gBAC7B,MAAMQ,aAAaP,MAAMC,OAAO,CAACJ,MAAME,IAAI,KAAKF,MAAME,IAAI,CAACG,QAAQ,CAAC;gBAEpE,OAAO;oBACLN;oBACA;wBACEG,MAAMQ,aAAa;4BAAC;4BAAU;yBAAO,GAAG;wBACxCC,aAAaX,MAAMW,WAAW,IAAI;wBAClCjB,YAAY;4BACVkB,UAAU;gCAAEV,MAAM;gCAAUS,aAAa;4BAAsB;4BAC/DE,WAAW;gCAAEX,MAAM;gCAAUS,aAAa;4BAAuB;wBACnE;wBACAG,UAAU;4BAAC;4BAAa;yBAAW;oBACrC;iBACD;YACH;YAEA,OAAO;gBAACf;gBAAKR,2BAA2BS;aAAO;QACjD;IAEJ;IAEA,IACEP,YAAYa,KAAK,IACjB,OAAOb,YAAYa,KAAK,KAAK,YAC7B,CAACH,MAAMC,OAAO,CAACX,YAAYa,KAAK,GAChC;QACAb,YAAYa,KAAK,GAAGf,2BAA2BE,YAAYa,KAAK;IAClE;IAEA,OAAOb;AACT"}

package/dist/utils/transformPointDataToPayload.d.ts

@@ -1,7 +0,0 @@
-/**
- * Transforms incoming MCP tool data from object format to tuple array format.
- * Converts { longitude: number, latitude: number } back to [longitude, latitude]
- * for Payload's internal point field representation.
- */
-export declare function transformPointDataToPayload(data: Record<string, unknown>): Record<string, unknown>;
-//# sourceMappingURL=transformPointDataToPayload.d.ts.map

package/dist/utils/transformPointDataToPayload.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"transformPointDataToPayload.d.ts","sourceRoot":"","sources":["../../src/utils/transformPointDataToPayload.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC5B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAgCzB"}

package/dist/utils/transformPointDataToPayload.js

@@ -1,28 +0,0 @@
-/**
- * Transforms incoming MCP tool data from object format to tuple array format.
- * Converts { longitude: number, latitude: number } back to [longitude, latitude]
- * for Payload's internal point field representation.
- */ export function transformPointDataToPayload(data) {
-    if (!data || typeof data !== 'object') {
-        return data;
-    }
-    const transformed = {};
-    for (const [key, value] of Object.entries(data)){
-        if (value && typeof value === 'object' && 'longitude' in value && 'latitude' in value && typeof value.longitude === 'number' && typeof value.latitude === 'number') {
-            // Transform to tuple array [longitude, latitude]
-            transformed[key] = [
-                value.longitude,
-                value.latitude
-            ];
-        } else if (Array.isArray(value)) {
-            transformed[key] = value.map((item)=>typeof item === 'object' ? transformPointDataToPayload(item) : item);
-        } else if (value && typeof value === 'object') {
-            transformed[key] = transformPointDataToPayload(value);
-        } else {
-            transformed[key] = value;
-        }
-    }
-    return transformed;
-}
-
-//# sourceMappingURL=transformPointDataToPayload.js.map

package/dist/utils/transformPointDataToPayload.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/utils/transformPointDataToPayload.ts"],"sourcesContent":["/**\n * Transforms incoming MCP tool data from object format to tuple array format.\n * Converts { longitude: number, latitude: number } back to [longitude, latitude]\n * for Payload's internal point field representation.\n */\nexport function transformPointDataToPayload(\n  data: Record<string, unknown>,\n): Record<string, unknown> {\n  if (!data || typeof data !== 'object') {\n    return data\n  }\n\n  const transformed: Record<string, unknown> = {}\n\n  for (const [key, value] of Object.entries(data)) {\n    if (\n      value &&\n      typeof value === 'object' &&\n      'longitude' in value &&\n      'latitude' in value &&\n      typeof value.longitude === 'number' &&\n      typeof value.latitude === 'number'\n    ) {\n      // Transform to tuple array [longitude, latitude]\n      transformed[key] = [value.longitude, value.latitude]\n    } else if (Array.isArray(value)) {\n      transformed[key] = value.map((item) =>\n        typeof item === 'object'\n          ? transformPointDataToPayload(item as Record<string, unknown>)\n          : item,\n      )\n    } else if (value && typeof value === 'object') {\n      transformed[key] = transformPointDataToPayload(value as Record<string, unknown>)\n    } else {\n      transformed[key] = value\n    }\n  }\n\n  return transformed\n}\n"],"names":["transformPointDataToPayload","data","transformed","key","value","Object","entries","longitude","latitude","Array","isArray","map","item"],"mappings":"AAAA;;;;CAIC,GACD,OAAO,SAASA,4BACdC,IAA6B;IAE7B,IAAI,CAACA,QAAQ,OAAOA,SAAS,UAAU;QACrC,OAAOA;IACT;IAEA,MAAMC,cAAuC,CAAC;IAE9C,KAAK,MAAM,CAACC,KAAKC,MAAM,IAAIC,OAAOC,OAAO,CAACL,MAAO;QAC/C,IACEG,SACA,OAAOA,UAAU,YACjB,eAAeA,SACf,cAAcA,SACd,OAAOA,MAAMG,SAAS,KAAK,YAC3B,OAAOH,MAAMI,QAAQ,KAAK,UAC1B;YACA,iDAAiD;YACjDN,WAAW,CAACC,IAAI,GAAG;gBAACC,MAAMG,SAAS;gBAAEH,MAAMI,QAAQ;aAAC;QACtD,OAAO,IAAIC,MAAMC,OAAO,CAACN,QAAQ;YAC/BF,WAAW,CAACC,IAAI,GAAGC,MAAMO,GAAG,CAAC,CAACC,OAC5B,OAAOA,SAAS,WACZZ,4BAA4BY,QAC5BA;QAER,OAAO,IAAIR,SAAS,OAAOA,UAAU,UAAU;YAC7CF,WAAW,CAACC,IAAI,GAAGH,4BAA4BI;QACjD,OAAO;YACLF,WAAW,CAACC,IAAI,GAAGC;QACrB;IACF;IAEA,OAAOF;AACT"}