@payloadcms/plugin-mcp 4.0.0-internal.1f9ae9a → 4.0.0-internal.2fddfc0

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/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
-}