@payloadcms/plugin-mcp 4.0.0-internal.4cbdd50 → 4.0.0-internal.4e1f822

package/dist/utils/schemaConversion/sanitizeEntitySchema.spec.js

@@ -1,158 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { sanitizeEntitySchema } from './sanitizeEntitySchema.js';
-describe('sanitizeEntitySchema', ()=>{
-    it('keeps a Lexical node union strict (oneOf) while simplifying relationship values to IDs', ()=>{
-        // Shaped like the schema the MCP server prepares for a collection with a Lexical richText field:
-        // a `$defs` node union (a `oneOf` of node shapes) where a relationship node's `value` is either
-        // an ID or a `$ref` to the populated related collection.
-        const standalone = {
-            type: 'object',
-            $defs: {
-                LexicalNodes_ABCDEF12: {
-                    oneOf: [
-                        {
-                            type: 'object',
-                            additionalProperties: false,
-                            properties: {
-                                type: {
-                                    const: 'paragraph'
-                                }
-                            },
-                            required: [
-                                'type'
-                            ]
-                        },
-                        {
-                            type: 'object',
-                            additionalProperties: false,
-                            properties: {
-                                type: {
-                                    const: 'relationship'
-                                },
-                                value: {
-                                    oneOf: [
-                                        {
-                                            type: 'string'
-                                        },
-                                        {
-                                            $ref: '#/$defs/posts'
-                                        }
-                                    ]
-                                }
-                            },
-                            required: [
-                                'type'
-                            ]
-                        }
-                    ]
-                },
-                posts: {
-                    type: 'object',
-                    additionalProperties: false,
-                    properties: {
-                        id: {
-                            type: 'string'
-                        },
-                        title: {
-                            type: 'string'
-                        }
-                    }
-                }
-            },
-            properties: {
-                id: {
-                    type: 'string'
-                },
-                content: {
-                    type: 'object',
-                    properties: {
-                        root: {
-                            type: 'object',
-                            properties: {
-                                children: {
-                                    type: 'array',
-                                    items: {
-                                        $ref: '#/$defs/LexicalNodes_ABCDEF12'
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        };
-        expect(sanitizeEntitySchema(standalone)).toStrictEqual({
-            type: 'object',
-            $defs: {
-                // The node union is renamed to a short, readable `node`, and stays a strict discriminated
-                // `oneOf` - not loosened to `anyOf`...
-                node: {
-                    oneOf: [
-                        {
-                            type: 'object',
-                            additionalProperties: false,
-                            properties: {
-                                type: {
-                                    const: 'paragraph'
-                                }
-                            },
-                            required: [
-                                'type'
-                            ]
-                        },
-                        {
-                            type: 'object',
-                            additionalProperties: false,
-                            properties: {
-                                type: {
-                                    const: 'relationship'
-                                },
-                                // ...while the relationship `value` is simplified to a bare ID (the populated-doc `$ref` is dropped).
-                                value: {
-                                    type: 'string',
-                                    description: 'The ID of the related "posts" document.'
-                                }
-                            },
-                            required: [
-                                'type'
-                            ]
-                        }
-                    ]
-                },
-                posts: {
-                    type: 'object',
-                    additionalProperties: false,
-                    properties: {
-                        id: {
-                            type: 'string'
-                        },
-                        title: {
-                            type: 'string'
-                        }
-                    }
-                }
-            },
-            properties: {
-                // `id` is dropped - it's a Payload-managed field MCP clients never set.
-                content: {
-                    type: 'object',
-                    properties: {
-                        root: {
-                            type: 'object',
-                            properties: {
-                                children: {
-                                    type: 'array',
-                                    items: {
-                                        $ref: '#/$defs/node'
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        });
-    });
-});
-
-//# sourceMappingURL=sanitizeEntitySchema.spec.js.map

package/dist/utils/schemaConversion/sanitizeEntitySchema.spec.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/utils/schemaConversion/sanitizeEntitySchema.spec.ts"],"sourcesContent":["import { describe, expect, it } from 'vitest'\n\nimport type { JsonSchemaType } from '../../types.js'\n\nimport { sanitizeEntitySchema } from './sanitizeEntitySchema.js'\n\ndescribe('sanitizeEntitySchema', () => {\n  it('keeps a Lexical node union strict (oneOf) while simplifying relationship values to IDs', () => {\n    // Shaped like the schema the MCP server prepares for a collection with a Lexical richText field:\n    // a `$defs` node union (a `oneOf` of node shapes) where a relationship node's `value` is either\n    // an ID or a `$ref` to the populated related collection.\n    const standalone: JsonSchemaType = {\n      type: 'object',\n      $defs: {\n        LexicalNodes_ABCDEF12: {\n          oneOf: [\n            {\n              type: 'object',\n              additionalProperties: false,\n              properties: { type: { const: 'paragraph' } },\n              required: ['type'],\n            },\n            {\n              type: 'object',\n              additionalProperties: false,\n              properties: {\n                type: { const: 'relationship' },\n                value: { oneOf: [{ type: 'string' }, { $ref: '#/$defs/posts' }] },\n              },\n              required: ['type'],\n            },\n          ],\n        },\n        posts: {\n          type: 'object',\n          additionalProperties: false,\n          properties: { id: { type: 'string' }, title: { type: 'string' } },\n        },\n      },\n      properties: {\n        id: { type: 'string' },\n        content: {\n          type: 'object',\n          properties: {\n            root: {\n              type: 'object',\n              properties: {\n                children: { type: 'array', items: { $ref: '#/$defs/LexicalNodes_ABCDEF12' } },\n              },\n            },\n          },\n        },\n      },\n    }\n\n    expect(sanitizeEntitySchema(standalone)).toStrictEqual({\n      type: 'object',\n      $defs: {\n        // The node union is renamed to a short, readable `node`, and stays a strict discriminated\n        // `oneOf` - not loosened to `anyOf`...\n        node: {\n          oneOf: [\n            {\n              type: 'object',\n              additionalProperties: false,\n              properties: { type: { const: 'paragraph' } },\n              required: ['type'],\n            },\n            {\n              type: 'object',\n              additionalProperties: false,\n              properties: {\n                type: { const: 'relationship' },\n                // ...while the relationship `value` is simplified to a bare ID (the populated-doc `$ref` is dropped).\n                value: { type: 'string', description: 'The ID of the related \"posts\" document.' },\n              },\n              required: ['type'],\n            },\n          ],\n        },\n        posts: {\n          type: 'object',\n          additionalProperties: false,\n          properties: { id: { type: 'string' }, title: { type: 'string' } },\n        },\n      },\n      properties: {\n        // `id` is dropped - it's a Payload-managed field MCP clients never set.\n        content: {\n          type: 'object',\n          properties: {\n            root: {\n              type: 'object',\n              properties: {\n                children: { type: 'array', items: { $ref: '#/$defs/node' } },\n              },\n            },\n          },\n        },\n      },\n    })\n  })\n})\n"],"names":["describe","expect","it","sanitizeEntitySchema","standalone","type","$defs","LexicalNodes_ABCDEF12","oneOf","additionalProperties","properties","const","required","value","$ref","posts","id","title","content","root","children","items","toStrictEqual","node","description"],"mappings":"AAAA,SAASA,QAAQ,EAAEC,MAAM,EAAEC,EAAE,QAAQ,SAAQ;AAI7C,SAASC,oBAAoB,QAAQ,4BAA2B;AAEhEH,SAAS,wBAAwB;IAC/BE,GAAG,0FAA0F;QAC3F,iGAAiG;QACjG,gGAAgG;QAChG,yDAAyD;QACzD,MAAME,aAA6B;YACjCC,MAAM;YACNC,OAAO;gBACLC,uBAAuB;oBACrBC,OAAO;wBACL;4BACEH,MAAM;4BACNI,sBAAsB;4BACtBC,YAAY;gCAAEL,MAAM;oCAAEM,OAAO;gCAAY;4BAAE;4BAC3CC,UAAU;gCAAC;6BAAO;wBACpB;wBACA;4BACEP,MAAM;4BACNI,sBAAsB;4BACtBC,YAAY;gCACVL,MAAM;oCAAEM,OAAO;gCAAe;gCAC9BE,OAAO;oCAAEL,OAAO;wCAAC;4CAAEH,MAAM;wCAAS;wCAAG;4CAAES,MAAM;wCAAgB;qCAAE;gCAAC;4BAClE;4BACAF,UAAU;gCAAC;6BAAO;wBACpB;qBACD;gBACH;gBACAG,OAAO;oBACLV,MAAM;oBACNI,sBAAsB;oBACtBC,YAAY;wBAAEM,IAAI;4BAAEX,MAAM;wBAAS;wBAAGY,OAAO;4BAAEZ,MAAM;wBAAS;oBAAE;gBAClE;YACF;YACAK,YAAY;gBACVM,IAAI;oBAAEX,MAAM;gBAAS;gBACrBa,SAAS;oBACPb,MAAM;oBACNK,YAAY;wBACVS,MAAM;4BACJd,MAAM;4BACNK,YAAY;gCACVU,UAAU;oCAAEf,MAAM;oCAASgB,OAAO;wCAAEP,MAAM;oCAAgC;gCAAE;4BAC9E;wBACF;oBACF;gBACF;YACF;QACF;QAEAb,OAAOE,qBAAqBC,aAAakB,aAAa,CAAC;YACrDjB,MAAM;YACNC,OAAO;gBACL,0FAA0F;gBAC1F,uCAAuC;gBACvCiB,MAAM;oBACJf,OAAO;wBACL;4BACEH,MAAM;4BACNI,sBAAsB;4BACtBC,YAAY;gCAAEL,MAAM;oCAAEM,OAAO;gCAAY;4BAAE;4BAC3CC,UAAU;gCAAC;6BAAO;wBACpB;wBACA;4BACEP,MAAM;4BACNI,sBAAsB;4BACtBC,YAAY;gCACVL,MAAM;oCAAEM,OAAO;gCAAe;gCAC9B,sGAAsG;gCACtGE,OAAO;oCAAER,MAAM;oCAAUmB,aAAa;gCAA0C;4BAClF;4BACAZ,UAAU;gCAAC;6BAAO;wBACpB;qBACD;gBACH;gBACAG,OAAO;oBACLV,MAAM;oBACNI,sBAAsB;oBACtBC,YAAY;wBAAEM,IAAI;4BAAEX,MAAM;wBAAS;wBAAGY,OAAO;4BAAEZ,MAAM;wBAAS;oBAAE;gBAClE;YACF;YACAK,YAAY;gBACV,wEAAwE;gBACxEQ,SAAS;oBACPb,MAAM;oBACNK,YAAY;wBACVS,MAAM;4BACJd,MAAM;4BACNK,YAAY;gCACVU,UAAU;oCAAEf,MAAM;oCAASgB,OAAO;wCAAEP,MAAM;oCAAe;gCAAE;4BAC7D;wBACF;oBACF;gBACF;YACF;QACF;IACF;AACF"}

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/dist/utils/whereSchema.d.ts

@@ -1,9 +0,0 @@
-import type { Where } from 'payload';
-import { z } from 'zod';
-/**
- * - Validates the `where` input of collection tools against Payload's `Where` shape
- * - Field keys map to operator objects restricted to `validOperators`
- * - `and` / `or` nest recursively
- */
-export declare const whereSchema: z.ZodType<Where>;
-//# sourceMappingURL=whereSchema.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"whereSchema.d.ts","sourceRoot":"","sources":["../../src/utils/whereSchema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAGpC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB;;;;GAIG;AACH,eAAO,MAAM,WAAW,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,CASqD,CAAA"}

package/dist/utils/whereSchema.js

@@ -1,13 +0,0 @@
-import { validOperators } from 'payload/shared';
-import { z } from 'zod';
-const whereFieldSchema = z.partialRecord(z.enum(validOperators), z.unknown()).describe('Field query operators');
-/**
- * - Validates the `where` input of collection tools against Payload's `Where` shape
- * - Field keys map to operator objects restricted to `validOperators`
- * - `and` / `or` nest recursively
- */ export const whereSchema = z.lazy(()=>z.object({
-        and: z.array(whereSchema).optional(),
-        or: z.array(whereSchema).optional()
-    }).catchall(whereFieldSchema)).describe('Where clause using field names with Payload query operators, plus and/or groups');
-
-//# sourceMappingURL=whereSchema.js.map

package/dist/utils/whereSchema.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/utils/whereSchema.ts"],"sourcesContent":["import type { Where } from 'payload'\n\nimport { validOperators } from 'payload/shared'\nimport { z } from 'zod'\n\nconst whereFieldSchema = z\n  .partialRecord(z.enum(validOperators), z.unknown())\n  .describe('Field query operators')\n\n/**\n * - Validates the `where` input of collection tools against Payload's `Where` shape\n * - Field keys map to operator objects restricted to `validOperators`\n * - `and` / `or` nest recursively\n */\nexport const whereSchema: z.ZodType<Where> = z\n  .lazy(() =>\n    z\n      .object({\n        and: z.array(whereSchema).optional(),\n        or: z.array(whereSchema).optional(),\n      })\n      .catchall(whereFieldSchema),\n  )\n  .describe('Where clause using field names with Payload query operators, plus and/or groups')\n"],"names":["validOperators","z","whereFieldSchema","partialRecord","enum","unknown","describe","whereSchema","lazy","object","and","array","optional","or","catchall"],"mappings":"AAEA,SAASA,cAAc,QAAQ,iBAAgB;AAC/C,SAASC,CAAC,QAAQ,MAAK;AAEvB,MAAMC,mBAAmBD,EACtBE,aAAa,CAACF,EAAEG,IAAI,CAACJ,iBAAiBC,EAAEI,OAAO,IAC/CC,QAAQ,CAAC;AAEZ;;;;CAIC,GACD,OAAO,MAAMC,cAAgCN,EAC1CO,IAAI,CAAC,IACJP,EACGQ,MAAM,CAAC;QACNC,KAAKT,EAAEU,KAAK,CAACJ,aAAaK,QAAQ;QAClCC,IAAIZ,EAAEU,KAAK,CAACJ,aAAaK,QAAQ;IACnC,GACCE,QAAQ,CAACZ,mBAEbI,QAAQ,CAAC,mFAAkF"}

package/src/@types/assets.d.ts

@@ -1,3 +0,0 @@
-declare module '*.css'
-
-declare module '*.scss'

package/src/mcp/builtin/collections/formatCollectionError.ts

@@ -1,84 +0,0 @@
-import type { CollectionSlug, PayloadRequest } from 'payload'
-
-import type { MCPToolResponse } from '../../../types.js'
-
-import { getCollectionInputSchema } from '../../../utils/schemaConversion/getEntityInputSchema.js'
-
-const getValidationErrors = (error: unknown): undefined | unknown[] => {
-  if (!error || typeof error !== 'object') {
-    return undefined
-  }
-
-  const data = 'data' in error ? error.data : undefined
-  if (!data || typeof data !== 'object' || !('errors' in data) || !Array.isArray(data.errors)) {
-    return undefined
-  }
-
-  return data.errors
-}
-
-const isSchemaError = (error: unknown, message: string): boolean => {
-  if (getValidationErrors(error)) {
-    return true
-  }
-
-  const name = error && typeof error === 'object' && 'name' in error ? error.name : undefined
-
-  return (
-    name === 'CastError' ||
-    name === 'ValidationError' ||
-    message.includes('Cast to ') ||
-    message.includes('validation failed')
-  )
-}
-
-export const formatCollectionError = ({
-  action,
-  collectionSlug,
-  error,
-  req,
-}: {
-  action: 'creating' | 'duplicating' | 'updating'
-  collectionSlug: CollectionSlug
-  error: unknown
-  req: PayloadRequest
-}): MCPToolResponse => {
-  const errorMessage = error instanceof Error ? error.message : 'Unknown error'
-  const errors = getValidationErrors(error) ?? [{ message: errorMessage }]
-
-  if (!isSchemaError(error, errorMessage)) {
-    return {
-      content: [
-        {
-          type: 'text',
-          text: `Error ${action} document in collection "${collectionSlug}": ${errorMessage}`,
-        },
-      ],
-      isError: true,
-    }
-  }
-
-  const schema = getCollectionInputSchema({ collectionSlug, req })
-  const schemaText = schema
-    ? `\n\nUse this schema for data:\n\`\`\`json\n${JSON.stringify(schema)}\n\`\`\``
-    : ''
-
-  return {
-    content: [
-      {
-        type: 'text',
-        text: `Error ${action} document in collection "${collectionSlug}": ${errorMessage}${schemaText}`,
-      },
-    ],
-    isError: true,
-    ...(schema
-      ? {
-          structuredContent: {
-            collectionSlug,
-            errors,
-            schema,
-          },
-        }
-      : {}),
-  }
-}

package/src/mcp/builtin/validateEntityData.ts

@@ -1,132 +0,0 @@
-import type { CollectionSlug, GlobalSlug, PayloadRequest, SanitizedConfig } from 'payload'
-
-import { CfWorkerJsonSchemaValidator } from '@modelcontextprotocol/server'
-
-import type { JsonSchemaType, MCPToolResponse } from '../../types.js'
-
-import {
-  getCollectionInputSchema,
-  getGlobalInputSchema,
-} from '../../utils/schemaConversion/getEntityInputSchema.js'
-
-/**
- * Keep the default `shortcircuit: true` - `false` makes validating nested rich text exponentially slow.
- */
-const validator = new CfWorkerJsonSchemaValidator({ shortcircuit: true })
-
-type EntityValidator = {
-  schema: JsonSchemaType
-  validate: ReturnType<(typeof validator)['getValidator']>
-}
-
-/**
- * - Caches each entity's schema and validator, so both are only built on the first request.
- * - Keyed by payload config, then by entity type, slug, partial and language.
- */
-const validatorCache = new WeakMap<SanitizedConfig, Map<string, EntityValidator>>()
-
-export const validateCollectionData = ({
-  collectionSlug,
-  data,
-  partial,
-  req,
-}: {
-  collectionSlug: CollectionSlug
-  data: Record<string, unknown>
-  partial?: boolean
-  req: PayloadRequest
-}): MCPToolResponse | null =>
-  validateData({
-    slug: collectionSlug,
-    buildSchema: () => getCollectionInputSchema({ collectionSlug, req }),
-    data,
-    entity: 'collection',
-    partial,
-    req,
-  })
-
-export const validateGlobalData = ({
-  data,
-  globalSlug,
-  req,
-}: {
-  data: Record<string, unknown>
-  globalSlug: GlobalSlug
-  req: PayloadRequest
-}): MCPToolResponse | null =>
-  validateData({
-    slug: globalSlug,
-    buildSchema: () => getGlobalInputSchema({ globalSlug, req }),
-    data,
-    entity: 'global',
-    partial: true,
-    req,
-  })
-
-const validateData = ({
-  slug,
-  buildSchema,
-  data,
-  entity,
-  partial,
-  req,
-}: {
-  buildSchema: () => JsonSchemaType | null
-  data: Record<string, unknown>
-  entity: 'collection' | 'global'
-  partial?: boolean
-  req: PayloadRequest
-  slug: string
-}): MCPToolResponse | null => {
-  let cache = validatorCache.get(req.payload.config)
-  if (!cache) {
-    cache = new Map()
-    validatorCache.set(req.payload.config, cache)
-  }
-
-  const cacheKey = `${entity}:${slug}:${partial ? 'partial' : 'full'}:${req.i18n.language}`
-  let entityValidator = cache.get(cacheKey)
-
-  if (!entityValidator) {
-    const schema = buildSchema()
-
-    if (!schema) {
-      return null
-    }
-
-    entityValidator = {
-      schema,
-      validate: validator.getValidator(partial ? withoutRequired(schema) : schema),
-    }
-    cache.set(cacheKey, entityValidator)
-  }
-
-  const result = entityValidator.validate(data)
-
-  if (result.valid) {
-    return null
-  }
-
-  const { schema } = entityValidator
-
-  return {
-    content: [
-      {
-        type: 'text',
-        text: `Invalid data for ${entity} "${slug}": ${result.errorMessage}\n\nUse this schema for data:\n\`\`\`json\n${JSON.stringify(schema)}\n\`\`\``,
-      },
-    ],
-    isError: true,
-    structuredContent: {
-      [`${entity}Slug`]: slug,
-      errors: [{ message: result.errorMessage }],
-      schema,
-    },
-  }
-}
-
-/** Updates are partial — drop the schema's top-level `required` before validating. */
-const withoutRequired = (schema: JsonSchemaType): JsonSchemaType => {
-  const { required: _required, ...rest } = schema
-  return rest
-}

package/src/utils/getVirtualFieldNames.ts

@@ -1,53 +0,0 @@
-import type { SanitizedConfig } from 'payload'
-
-import { fieldIsVirtual } from 'payload/shared'
-
-/**
- * Returns the names of all top-level virtual fields for a given collection slug.
- */
-export function getCollectionVirtualFieldNames(config: SanitizedConfig, slug: string): string[] {
-  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 as { name: string }).name)
-}
-
-/**
- * Returns the names of all top-level virtual fields for a given global slug.
- */
-export function getGlobalVirtualFieldNames(config: SanitizedConfig, slug: string): string[] {
-  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 as { name: string }).name)
-}
-
-/**
- * Strips virtual field values from a data object given a list of virtual field names.
- */
-export function stripVirtualFields(
-  data: Record<string, unknown>,
-  virtualFieldNames: string[],
-): Record<string, unknown> {
-  if (virtualFieldNames.length === 0) {
-    return data
-  }
-
-  const stripped = { ...data }
-
-  for (const name of virtualFieldNames) {
-    delete stripped[name]
-  }
-
-  return stripped
-}

package/src/utils/localAPIDefaults.ts

@@ -1,22 +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 const localAPIDefaults = (
-  authorizedMCP: AuthorizedMCP,
-): { overrideAccess: boolean; user: AuthorizedMCP['user'] } => ({
-  overrideAccess: authorizedMCP.overrideAccess,
-  user: authorizedMCP.user,
-})

package/src/utils/schemaConversion/getEntityInputSchema.ts

@@ -1,78 +0,0 @@
-import {
-  type CollectionSlug,
-  entityToStandaloneJSONSchema,
-  type GlobalSlug,
-  type PayloadRequest,
-  type SanitizedCollectionConfig,
-  type SanitizedGlobalConfig,
-} from 'payload'
-
-import type { JsonSchemaType } from '../../types.js'
-
-import {
-  getCollectionVirtualFieldNames,
-  getGlobalVirtualFieldNames,
-} from '../getVirtualFieldNames.js'
-import { removeVirtualFieldsFromSchema } from './removeVirtualFieldsFromSchema.js'
-import { sanitizeEntitySchema } from './sanitizeEntitySchema.js'
-
-export const getCollectionInputSchema = ({
-  collectionSlug,
-  req,
-}: {
-  collectionSlug: CollectionSlug
-  req: PayloadRequest
-}): JsonSchemaType | null => {
-  const collection = req.payload.collections[collectionSlug]?.config
-
-  if (!collection) {
-    return null
-  }
-
-  return buildEntityInputSchema({
-    entity: collection,
-    req,
-    virtualFieldNames: getCollectionVirtualFieldNames(req.payload.config, collectionSlug),
-  })
-}
-
-export const getGlobalInputSchema = ({
-  globalSlug,
-  req,
-}: {
-  globalSlug: GlobalSlug
-  req: PayloadRequest
-}): JsonSchemaType | null => {
-  const global = req.payload.config.globals.find((globalConfig) => globalConfig.slug === globalSlug)
-
-  if (!global) {
-    return null
-  }
-
-  return buildEntityInputSchema({
-    entity: global,
-    req,
-    virtualFieldNames: getGlobalVirtualFieldNames(req.payload.config, globalSlug),
-  })
-}
-
-const buildEntityInputSchema = ({
-  entity,
-  req,
-  virtualFieldNames,
-}: {
-  entity: SanitizedCollectionConfig | SanitizedGlobalConfig
-  req: PayloadRequest
-  virtualFieldNames: string[]
-}): JsonSchemaType =>
-  sanitizeEntitySchema(
-    removeVirtualFieldsFromSchema(
-      entityToStandaloneJSONSchema({
-        config: req.payload.config,
-        defaultIDType: req.payload.db.defaultIDType,
-        entity,
-        i18n: req.i18n,
-      }) as unknown as JsonSchemaType,
-      virtualFieldNames,
-    ),
-  )

package/src/utils/schemaConversion/removeVirtualFieldsFromSchema.ts

@@ -1,27 +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 function removeVirtualFieldsFromSchema(
-  schema: JsonSchemaType,
-  virtualFieldNames: string[],
-): JsonSchemaType {
-  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
-}