@payloadcms/plugin-mcp 4.0.0-internal.c2b57ce → 4.0.0-internal.c6494b5

package/dist/utils/getVirtualFieldNames.js

@@ -1,35 +0,0 @@
-import { fieldIsVirtual } from 'payload/shared';
-/**
- * Returns the names of all top-level virtual fields for a given collection slug.
- */ export function getCollectionVirtualFieldNames(config, slug) {
-    const collection = config.collections.find((c)=>c.slug === slug);
-    if (!collection) {
-        return [];
-    }
-    return collection.flattenedFields.filter((field)=>'name' in field && fieldIsVirtual(field)).map((field)=>field.name);
-}
-/**
- * Returns the names of all top-level virtual fields for a given global slug.
- */ export function getGlobalVirtualFieldNames(config, slug) {
-    const global = config.globals.find((g)=>g.slug === slug);
-    if (!global) {
-        return [];
-    }
-    return global.flattenedFields.filter((field)=>'name' in field && fieldIsVirtual(field)).map((field)=>field.name);
-}
-/**
- * Strips virtual field values from a data object given a list of virtual field names.
- */ export function stripVirtualFields(data, virtualFieldNames) {
-    if (virtualFieldNames.length === 0) {
-        return data;
-    }
-    const stripped = {
-        ...data
-    };
-    for (const name of virtualFieldNames){
-        delete stripped[name];
-    }
-    return stripped;
-}
-
-//# sourceMappingURL=getVirtualFieldNames.js.map

package/dist/utils/getVirtualFieldNames.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/utils/getVirtualFieldNames.ts"],"sourcesContent":["import type { SanitizedConfig } from 'payload'\n\nimport { fieldIsVirtual } from 'payload/shared'\n\n/**\n * Returns the names of all top-level virtual fields for a given collection slug.\n */\nexport function getCollectionVirtualFieldNames(config: SanitizedConfig, slug: string): string[] {\n  const collection = config.collections.find((c) => c.slug === slug)\n\n  if (!collection) {\n    return []\n  }\n\n  return collection.flattenedFields\n    .filter((field) => 'name' in field && fieldIsVirtual(field))\n    .map((field) => (field as { name: string }).name)\n}\n\n/**\n * Returns the names of all top-level virtual fields for a given global slug.\n */\nexport function getGlobalVirtualFieldNames(config: SanitizedConfig, slug: string): string[] {\n  const global = config.globals.find((g) => g.slug === slug)\n\n  if (!global) {\n    return []\n  }\n\n  return global.flattenedFields\n    .filter((field) => 'name' in field && fieldIsVirtual(field))\n    .map((field) => (field as { name: string }).name)\n}\n\n/**\n * Strips virtual field values from a data object given a list of virtual field names.\n */\nexport function stripVirtualFields(\n  data: Record<string, unknown>,\n  virtualFieldNames: string[],\n): Record<string, unknown> {\n  if (virtualFieldNames.length === 0) {\n    return data\n  }\n\n  const stripped = { ...data }\n\n  for (const name of virtualFieldNames) {\n    delete stripped[name]\n  }\n\n  return stripped\n}\n"],"names":["fieldIsVirtual","getCollectionVirtualFieldNames","config","slug","collection","collections","find","c","flattenedFields","filter","field","map","name","getGlobalVirtualFieldNames","global","globals","g","stripVirtualFields","data","virtualFieldNames","length","stripped"],"mappings":"AAEA,SAASA,cAAc,QAAQ,iBAAgB;AAE/C;;CAEC,GACD,OAAO,SAASC,+BAA+BC,MAAuB,EAAEC,IAAY;IAClF,MAAMC,aAAaF,OAAOG,WAAW,CAACC,IAAI,CAAC,CAACC,IAAMA,EAAEJ,IAAI,KAAKA;IAE7D,IAAI,CAACC,YAAY;QACf,OAAO,EAAE;IACX;IAEA,OAAOA,WAAWI,eAAe,CAC9BC,MAAM,CAAC,CAACC,QAAU,UAAUA,SAASV,eAAeU,QACpDC,GAAG,CAAC,CAACD,QAAU,AAACA,MAA2BE,IAAI;AACpD;AAEA;;CAEC,GACD,OAAO,SAASC,2BAA2BX,MAAuB,EAAEC,IAAY;IAC9E,MAAMW,SAASZ,OAAOa,OAAO,CAACT,IAAI,CAAC,CAACU,IAAMA,EAAEb,IAAI,KAAKA;IAErD,IAAI,CAACW,QAAQ;QACX,OAAO,EAAE;IACX;IAEA,OAAOA,OAAON,eAAe,CAC1BC,MAAM,CAAC,CAACC,QAAU,UAAUA,SAASV,eAAeU,QACpDC,GAAG,CAAC,CAACD,QAAU,AAACA,MAA2BE,IAAI;AACpD;AAEA;;CAEC,GACD,OAAO,SAASK,mBACdC,IAA6B,EAC7BC,iBAA2B;IAE3B,IAAIA,kBAAkBC,MAAM,KAAK,GAAG;QAClC,OAAOF;IACT;IAEA,MAAMG,WAAW;QAAE,GAAGH,IAAI;IAAC;IAE3B,KAAK,MAAMN,QAAQO,kBAAmB;QACpC,OAAOE,QAAQ,CAACT,KAAK;IACvB;IAEA,OAAOS;AACT"}

package/dist/utils/localAPIDefaults.d.ts

@@ -1,20 +0,0 @@
-import type { AuthorizedMCP } from '../types.js';
-/**
- * Returns the `user` and `overrideAccess` arguments every Payload local API call
- * should receive when initiated from an MCP request. Spread the result into the
- * call's arg object so the two pieces of caller state can't drift apart.
- *
- * @example
- * ```ts
- * await req.payload.create({
- *   collection: 'posts',
- *   data,
- *   ...localAPIDefaults(authorizedMCP),
- * })
- * ```
- */
-export declare const localAPIDefaults: (authorizedMCP: AuthorizedMCP) => {
-    overrideAccess: boolean;
-    user: AuthorizedMCP["user"];
-};
-//# sourceMappingURL=localAPIDefaults.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"localAPIDefaults.d.ts","sourceRoot":"","sources":["../../src/utils/localAPIDefaults.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEhD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gBAAgB,GAC3B,eAAe,aAAa,KAC3B;IAAE,cAAc,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CAGvD,CAAA"}

package/dist/utils/localAPIDefaults.js

@@ -1,19 +0,0 @@
-/**
- * Returns the `user` and `overrideAccess` arguments every Payload local API call
- * should receive when initiated from an MCP request. Spread the result into the
- * call's arg object so the two pieces of caller state can't drift apart.
- *
- * @example
- * ```ts
- * await req.payload.create({
- *   collection: 'posts',
- *   data,
- *   ...localAPIDefaults(authorizedMCP),
- * })
- * ```
- */ export const localAPIDefaults = (authorizedMCP)=>({
-        overrideAccess: authorizedMCP.overrideAccess,
-        user: authorizedMCP.user
-    });
-
-//# sourceMappingURL=localAPIDefaults.js.map

package/dist/utils/localAPIDefaults.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/utils/localAPIDefaults.ts"],"sourcesContent":["import type { AuthorizedMCP } from '../types.js'\n\n/**\n * Returns the `user` and `overrideAccess` arguments every Payload local API call\n * should receive when initiated from an MCP request. Spread the result into the\n * call's arg object so the two pieces of caller state can't drift apart.\n *\n * @example\n * ```ts\n * await req.payload.create({\n *   collection: 'posts',\n *   data,\n *   ...localAPIDefaults(authorizedMCP),\n * })\n * ```\n */\nexport const localAPIDefaults = (\n  authorizedMCP: AuthorizedMCP,\n): { overrideAccess: boolean; user: AuthorizedMCP['user'] } => ({\n  overrideAccess: authorizedMCP.overrideAccess,\n  user: authorizedMCP.user,\n})\n"],"names":["localAPIDefaults","authorizedMCP","overrideAccess","user"],"mappings":"AAEA;;;;;;;;;;;;;CAaC,GACD,OAAO,MAAMA,mBAAmB,CAC9BC,gBAC8D,CAAA;QAC9DC,gBAAgBD,cAAcC,cAAc;QAC5CC,MAAMF,cAAcE,IAAI;IAC1B,CAAA,EAAE"}

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

@@ -1,7 +0,0 @@
-import type { JsonSchemaType } from '../../types.js';
-/**
- * Sanitizes Payload's auto-generated collection JSON Schema so it can be safely
- * fed into the MCP server's `fromJsonSchema()` adapter (no zod intermediate step).
- */
-export declare const prepareCollectionSchema: (schema: JsonSchemaType) => JsonSchemaType;
-//# sourceMappingURL=prepareCollectionSchema.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"prepareCollectionSchema.d.ts","sourceRoot":"","sources":["../../../src/utils/schemaConversion/prepareCollectionSchema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAapD;;;GAGG;AACH,eAAO,MAAM,uBAAuB,GAAI,QAAQ,cAAc,KAAG,cAqBhE,CAAA"}

package/dist/utils/schemaConversion/prepareCollectionSchema.js

@@ -1,37 +0,0 @@
-import { sanitizeJsonSchema } from './sanitizeJsonSchema.js';
-import { simplifyRelationshipFields } from './simplifyRelationshipFields.js';
-import { transformPointFieldsForMCP } from './transformPointFields.js';
-/**
- * Fields Payload manages automatically — clients should never be required to provide
- * them. Stripped from `required` and `properties` so they don't appear in tool
- * inputs.
- */ const PAYLOAD_MANAGED_FIELDS = new Set([
-    '_status',
-    'createdAt',
-    'id',
-    'updatedAt'
-]);
-/**
- * Sanitizes Payload's auto-generated collection JSON Schema so it can be safely
- * fed into the MCP server's `fromJsonSchema()` adapter (no zod intermediate step).
- */ export const prepareCollectionSchema = (schema)=>{
-    // 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 simplified = simplifyRelationshipFields(pointTransformed);
-    if (simplified.properties) {
-        for (const field of PAYLOAD_MANAGED_FIELDS){
-            delete simplified.properties[field];
-        }
-    }
-    if (Array.isArray(simplified.required)) {
-        simplified.required = simplified.required.filter((name)=>!PAYLOAD_MANAGED_FIELDS.has(name));
-        if (simplified.required.length === 0) {
-            delete simplified.required;
-        }
-    }
-    return simplified;
-};
-
-//# sourceMappingURL=prepareCollectionSchema.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/utils/schemaConversion/prepareCollectionSchema.ts"],"sourcesContent":["import type { JsonSchemaType } from '../../types.js'\n\nimport { sanitizeJsonSchema } from './sanitizeJsonSchema.js'\nimport { simplifyRelationshipFields } from './simplifyRelationshipFields.js'\nimport { transformPointFieldsForMCP } from './transformPointFields.js'\n\n/**\n * Fields Payload manages automatically — clients should never be required to provide\n * them. Stripped from `required` and `properties` so they don't appear in tool\n * inputs.\n */\nconst PAYLOAD_MANAGED_FIELDS = new Set(['_status', 'createdAt', 'id', 'updatedAt'])\n\n/**\n * Sanitizes Payload's auto-generated collection JSON Schema so it can be safely\n * fed into the MCP server's `fromJsonSchema()` adapter (no zod intermediate step).\n */\nexport const prepareCollectionSchema = (schema: JsonSchemaType): JsonSchemaType => {\n  // Clone to avoid mutating the original schema (used elsewhere for tool listing)\n  const schemaClone = JSON.parse(JSON.stringify(schema)) as JsonSchemaType\n\n  const sanitized = sanitizeJsonSchema(schemaClone)\n  const pointTransformed = transformPointFieldsForMCP(sanitized)\n  const simplified = simplifyRelationshipFields(pointTransformed)\n\n  if (simplified.properties) {\n    for (const field of PAYLOAD_MANAGED_FIELDS) {\n      delete simplified.properties[field]\n    }\n  }\n  if (Array.isArray(simplified.required)) {\n    simplified.required = simplified.required.filter((name) => !PAYLOAD_MANAGED_FIELDS.has(name))\n    if (simplified.required.length === 0) {\n      delete simplified.required\n    }\n  }\n\n  return simplified\n}\n"],"names":["sanitizeJsonSchema","simplifyRelationshipFields","transformPointFieldsForMCP","PAYLOAD_MANAGED_FIELDS","Set","prepareCollectionSchema","schema","schemaClone","JSON","parse","stringify","sanitized","pointTransformed","simplified","properties","field","Array","isArray","required","filter","name","has","length"],"mappings":"AAEA,SAASA,kBAAkB,QAAQ,0BAAyB;AAC5D,SAASC,0BAA0B,QAAQ,kCAAiC;AAC5E,SAASC,0BAA0B,QAAQ,4BAA2B;AAEtE;;;;CAIC,GACD,MAAMC,yBAAyB,IAAIC,IAAI;IAAC;IAAW;IAAa;IAAM;CAAY;AAElF;;;CAGC,GACD,OAAO,MAAMC,0BAA0B,CAACC;IACtC,gFAAgF;IAChF,MAAMC,cAAcC,KAAKC,KAAK,CAACD,KAAKE,SAAS,CAACJ;IAE9C,MAAMK,YAAYX,mBAAmBO;IACrC,MAAMK,mBAAmBV,2BAA2BS;IACpD,MAAME,aAAaZ,2BAA2BW;IAE9C,IAAIC,WAAWC,UAAU,EAAE;QACzB,KAAK,MAAMC,SAASZ,uBAAwB;YAC1C,OAAOU,WAAWC,UAAU,CAACC,MAAM;QACrC;IACF;IACA,IAAIC,MAAMC,OAAO,CAACJ,WAAWK,QAAQ,GAAG;QACtCL,WAAWK,QAAQ,GAAGL,WAAWK,QAAQ,CAACC,MAAM,CAAC,CAACC,OAAS,CAACjB,uBAAuBkB,GAAG,CAACD;QACvF,IAAIP,WAAWK,QAAQ,CAACI,MAAM,KAAK,GAAG;YACpC,OAAOT,WAAWK,QAAQ;QAC5B;IACF;IAEA,OAAOL;AACT,EAAC"}

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

@@ -1,7 +0,0 @@
-import type { JsonSchemaType } from '../../types.js';
-/**
- * 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: JsonSchemaType, virtualFieldNames: string[]): JsonSchemaType;
-//# 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,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAEpD;;;GAGG;AACH,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,cAAc,EACtB,iBAAiB,EAAE,MAAM,EAAE,GAC1B,cAAc,CAiBhB"}

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 { JsonSchemaType } from '../../types.js'\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: JsonSchemaType,\n  virtualFieldNames: string[],\n): JsonSchemaType {\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,MAAsB,EACtBC,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 { JsonSchemaType } from '../../types.js';
-/**
- * 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: JsonSchemaType): JsonSchemaType;
-//# 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,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAEpD;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,cAAc,GAAG,cAAc,CA6BzE"}

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 { JsonSchemaType } from '../../types.js'\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: JsonSchemaType): JsonSchemaType {\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 JsonSchemaType\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: JsonSchemaType): 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,MAAsB;IACvD,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,MAAsB;IACnD,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 { JsonSchemaType } from '../../types.js';
-/**
- * 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: JsonSchemaType): JsonSchemaType;
-//# 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,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAEpD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,cAAc,GAAG,cAAc,CAkDjF"}

package/dist/utils/schemaConversion/simplifyRelationshipFields.js

@@ -1,56 +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);
-        const recurse = (option)=>typeof option === 'object' ? simplifyRelationshipFields(option) : option;
-        if (hasRef) {
-            const nonRefOptions = processed.oneOf.filter((option)=>!(option && typeof option === 'object' && '$ref' in option)).map(recurse);
-            if (nonRefOptions.length === 1) {
-                const single = nonRefOptions[0];
-                delete processed.oneOf;
-                if (typeof single === 'object') {
-                    Object.assign(processed, single);
-                }
-            } else if (nonRefOptions.length > 1) {
-                delete processed.oneOf;
-                processed.anyOf = nonRefOptions;
-            }
-        } else {
-            processed.anyOf = processed.oneOf.map(recurse);
-            delete processed.oneOf;
-        }
-    }
-    if (processed.properties && typeof processed.properties === 'object') {
-        processed.properties = Object.fromEntries(Object.entries(processed.properties).map(([key, value])=>[
-                key,
-                typeof value === 'object' ? simplifyRelationshipFields(value) : 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 { JsonSchemaType } from '../../types.js'\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: JsonSchemaType): JsonSchemaType {\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    const recurse = (option: boolean | JsonSchemaType): boolean | JsonSchemaType =>\n      typeof option === 'object' ? simplifyRelationshipFields(option) : option\n\n    if (hasRef) {\n      const nonRefOptions = processed.oneOf\n        .filter((option) => !(option && typeof option === 'object' && '$ref' in option))\n        .map(recurse)\n\n      if (nonRefOptions.length === 1) {\n        const single = nonRefOptions[0]!\n        delete processed.oneOf\n        if (typeof single === 'object') {\n          Object.assign(processed, single)\n        }\n      } else if (nonRefOptions.length > 1) {\n        delete processed.oneOf\n        processed.anyOf = nonRefOptions\n      }\n    } else {\n      processed.anyOf = processed.oneOf.map(recurse)\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        typeof value === 'object' ? simplifyRelationshipFields(value) : 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","recurse","nonRefOptions","filter","map","length","single","Object","assign","anyOf","properties","fromEntries","entries","key","value","items"],"mappings":"AAEA;;;;;;;;;;;;;;;;CAgBC,GACD,OAAO,SAASA,2BAA2BC,MAAsB;IAC/D,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,MAAMC,UAAU,CAACD,SACf,OAAOA,WAAW,WAAWR,2BAA2BQ,UAAUA;QAEpE,IAAIF,QAAQ;YACV,MAAMI,gBAAgBR,UAAUG,KAAK,CAClCM,MAAM,CAAC,CAACH,SAAW,CAAEA,CAAAA,UAAU,OAAOA,WAAW,YAAY,UAAUA,MAAK,GAC5EI,GAAG,CAACH;YAEP,IAAIC,cAAcG,MAAM,KAAK,GAAG;gBAC9B,MAAMC,SAASJ,aAAa,CAAC,EAAE;gBAC/B,OAAOR,UAAUG,KAAK;gBACtB,IAAI,OAAOS,WAAW,UAAU;oBAC9BC,OAAOC,MAAM,CAACd,WAAWY;gBAC3B;YACF,OAAO,IAAIJ,cAAcG,MAAM,GAAG,GAAG;gBACnC,OAAOX,UAAUG,KAAK;gBACtBH,UAAUe,KAAK,GAAGP;YACpB;QACF,OAAO;YACLR,UAAUe,KAAK,GAAGf,UAAUG,KAAK,CAACO,GAAG,CAACH;YACtC,OAAOP,UAAUG,KAAK;QACxB;IACF;IAEA,IAAIH,UAAUgB,UAAU,IAAI,OAAOhB,UAAUgB,UAAU,KAAK,UAAU;QACpEhB,UAAUgB,UAAU,GAAGH,OAAOI,WAAW,CACvCJ,OAAOK,OAAO,CAAClB,UAAUgB,UAAU,EAAEN,GAAG,CAAC,CAAC,CAACS,KAAKC,MAAM,GAAK;gBACzDD;gBACA,OAAOC,UAAU,WAAWtB,2BAA2BsB,SAASA;aACjE;IAEL;IAEA,IAAIpB,UAAUqB,KAAK,IAAI,OAAOrB,UAAUqB,KAAK,KAAK,YAAY,CAACpB,MAAMC,OAAO,CAACF,UAAUqB,KAAK,GAAG;QAC7FrB,UAAUqB,KAAK,GAAGvB,2BAA2BE,UAAUqB,KAAK;IAC9D;IAEA,OAAOrB;AACT"}

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

@@ -1,3 +0,0 @@
-import type { JsonSchemaType } from '../../types.js';
-export declare function transformPointFieldsForMCP(schema: JsonSchemaType): JsonSchemaType;
-//# 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,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAEpD,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,cAAc,GAAG,cAAc,CAqDjF"}

package/dist/utils/schemaConversion/transformPointFields.js

@@ -1,57 +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])=>{
-            if (!value || typeof value !== 'object') {
-                return [
-                    key,
-                    value
-                ];
-            }
-            const isArrayType = value.type === 'array' || Array.isArray(value.type) && value.type.includes('array');
-            if (isArrayType && Array.isArray(value.items) && value.items.length === 2 && value.items.every((item)=>item && typeof item === 'object' && 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 { JsonSchemaType } from '../../types.js'\n\nexport function transformPointFieldsForMCP(schema: JsonSchemaType): JsonSchemaType {\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        if (!value || typeof value !== 'object') {\n          return [key, value]\n        }\n        const isArrayType =\n          value.type === 'array' || (Array.isArray(value.type) && value.type.includes('array'))\n\n        if (\n          isArrayType &&\n          Array.isArray(value.items) &&\n          value.items.length === 2 &&\n          value.items.every((item) => item && typeof item === 'object' && 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,MAAsB;IAC/D,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,IAAI,CAACA,SAAS,OAAOA,UAAU,UAAU;gBACvC,OAAO;oBAACD;oBAAKC;iBAAM;YACrB;YACA,MAAMC,cACJD,MAAME,IAAI,KAAK,WAAYC,MAAMC,OAAO,CAACJ,MAAME,IAAI,KAAKF,MAAME,IAAI,CAACG,QAAQ,CAAC;YAE9E,IACEJ,eACAE,MAAMC,OAAO,CAACJ,MAAMM,KAAK,KACzBN,MAAMM,KAAK,CAACC,MAAM,KAAK,KACvBP,MAAMM,KAAK,CAACE,KAAK,CAAC,CAACC,OAASA,QAAQ,OAAOA,SAAS,YAAYA,KAAKP,IAAI,KAAK,WAC9E;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"}

package/src/collection/getAccessField.ts

@@ -1,64 +0,0 @@
-import type { JSONField } from 'payload'
-
-import type { ClientMCPPluginConfig, MCPItem, SanitizedMCPPluginConfig } from '../types.js'
-
-/**
- * Returns the API key collection's `access` field — a JSON field whose value
- * is the `MCPAPIKeysDocAccessTree` the endpoint consults. The actual UI is
- * a custom client component (`AccessField`) which renders a permissions
- * matrix; the field's stored shape is just the runtime access tree.
- */
-export const getAccessField = ({
-  pluginConfig,
-}: {
-  pluginConfig: SanitizedMCPPluginConfig
-}): JSONField => {
-  const clientPluginConfig = sanitizeClientPluginConfig(pluginConfig)
-
-  return {
-    name: 'access',
-    type: 'json',
-    admin: {
-      components: {
-        Field: {
-          clientProps: { pluginConfig: clientPluginConfig },
-          path: '@payloadcms/plugin-mcp/client#AccessField',
-        },
-      },
-      // TODO: needs i18n once design is finalized
-      description: 'Access for this API key — uncheck to revoke individual tools.',
-      position: 'sidebar',
-    },
-    defaultValue: {},
-    // TODO: needs i18n once design is finalized
-    label: 'Access',
-  }
-}
-
-/**
- * Strips the non-serializable parts of `SanitizedMCPPluginConfig` (handlers,
- * input/argsSchema functions, etc.) so the result is safe to thread to a
- * client component via `clientProps`.
- */
-const sanitizeClientPluginConfig = (
-  pluginConfig: SanitizedMCPPluginConfig,
-): ClientMCPPluginConfig => ({
-  items: pluginConfig.items.map((item) => ({
-    ...(item.type === 'collectionTool' ? { collectionSlug: item.collectionSlug } : {}),
-    ...(item.type === 'globalTool' ? { globalSlug: item.globalSlug } : {}),
-    type: item.type,
-    description: itemDescription(item),
-    key: item.key,
-    label: item.label,
-  })),
-})
-
-const itemDescription = (item: MCPItem): string => {
-  if (item.type === 'prompt') {
-    return item.prompt.description
-  }
-  if (item.type === 'resource') {
-    return item.resource.description
-  }
-  return item.tool.description
-}

package/src/collection/index.ts

@@ -1,63 +0,0 @@
-import type { CollectionConfig } from 'payload'
-
-import type { SanitizedMCPPluginConfig } from '../types.js'
-
-import { getAccessField } from './getAccessField.js'
-
-export const getAPIKeysCollection = ({
-  pluginConfig,
-}: {
-  pluginConfig: SanitizedMCPPluginConfig
-}): CollectionConfig => {
-  const collection: CollectionConfig = {
-    slug: 'payload-mcp-api-keys',
-    admin: {
-      description:
-        'API keys control which collections, resources, tools, and prompts MCP clients can access',
-      group: 'MCP',
-      useAsTitle: 'label',
-    },
-    auth: {
-      disableLocalStrategy: true,
-      useAPIKey: true,
-    },
-    fields: [
-      {
-        name: 'user',
-        type: 'relationship',
-        admin: { description: 'The user that the API key is associated with.' },
-        relationTo: pluginConfig.userCollection,
-        required: true,
-      },
-      {
-        name: 'label',
-        type: 'text',
-        admin: { description: 'A useful label for the API key.' },
-      },
-      {
-        name: 'description',
-        type: 'text',
-        admin: { description: 'The purpose of the API key.' },
-      },
-      {
-        name: 'overrideAccess',
-        type: 'checkbox',
-        admin: {
-          description:
-            'When checked, this key bypasses Payload access control on every operation it performs. Leave unchecked unless you have a specific reason.',
-        },
-        defaultValue: false,
-        label: 'Override access control',
-      },
-      getAccessField({ pluginConfig }),
-    ],
-    labels: {
-      plural: 'API Keys',
-      singular: 'API Key',
-    },
-  }
-
-  return pluginConfig.overrideApiKeyCollection
-    ? pluginConfig.overrideApiKeyCollection(collection)
-    : collection
-}