@payloadcms/plugin-mcp 4.0.0-internal.fa345ef → 4.0.0-internal.fec2230

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

@@ -1,133 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { sanitizeEntitySchema } from './sanitizeEntitySchema.js';
-describe('sanitizeEntitySchema', ()=>{
-    it('renames the Lexical node-union definition to a short name and keeps it a strict oneOf', ()=>{
-        // Shaped like the schema the MCP server prepares for a collection with a Lexical richText field
-        // (Payload's `input` variant): a `$defs` node union (a `oneOf` of node shapes). The input variant
-        // already types the relationship node's `value` as a bare ID - there is no populated-doc `$ref` to
-        // reduce here (the variant did that upstream), so sanitize leaves the value untouched.
-        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: {
-                                    type: 'string',
-                                    description: 'The related document ID.'
-                                }
-                            },
-                            required: [
-                                'type'
-                            ]
-                        }
-                    ]
-                }
-            },
-            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'
-                                },
-                                // The value is already ID-only from the input variant - left as-is.
-                                value: {
-                                    type: 'string',
-                                    description: 'The related document ID.'
-                                }
-                            },
-                            required: [
-                                'type'
-                            ]
-                        }
-                    ]
-                }
-            },
-            properties: {
-                // Managed fields (createdAt/updatedAt/_status) are excluded upstream by the `input` variant;
-                // `id` stays because it's a valid optional input (a client may supply a custom ID).
-                id: {
-                    type: 'string'
-                },
-                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('renames the Lexical node-union definition to a short name and keeps it a strict oneOf', () => {\n    // Shaped like the schema the MCP server prepares for a collection with a Lexical richText field\n    // (Payload's `input` variant): a `$defs` node union (a `oneOf` of node shapes). The input variant\n    // already types the relationship node's `value` as a bare ID - there is no populated-doc `$ref` to\n    // reduce here (the variant did that upstream), so sanitize leaves the value untouched.\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: { type: 'string', description: 'The related document ID.' },\n              },\n              required: ['type'],\n            },\n          ],\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                // The value is already ID-only from the input variant - left as-is.\n                value: { type: 'string', description: 'The related document ID.' },\n              },\n              required: ['type'],\n            },\n          ],\n        },\n      },\n      properties: {\n        // Managed fields (createdAt/updatedAt/_status) are excluded upstream by the `input` variant;\n        // `id` stays because it's a valid optional input (a client may supply a custom ID).\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/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","description","id","content","root","children","items","$ref","toStrictEqual","node"],"mappings":"AAAA,SAASA,QAAQ,EAAEC,MAAM,EAAEC,EAAE,QAAQ,SAAQ;AAI7C,SAASC,oBAAoB,QAAQ,4BAA2B;AAEhEH,SAAS,wBAAwB;IAC/BE,GAAG,yFAAyF;QAC1F,gGAAgG;QAChG,kGAAkG;QAClG,mGAAmG;QACnG,uFAAuF;QACvF,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;oCAAER,MAAM;oCAAUS,aAAa;gCAA2B;4BACnE;4BACAF,UAAU;gCAAC;6BAAO;wBACpB;qBACD;gBACH;YACF;YACAF,YAAY;gBACVK,IAAI;oBAAEV,MAAM;gBAAS;gBACrBW,SAAS;oBACPX,MAAM;oBACNK,YAAY;wBACVO,MAAM;4BACJZ,MAAM;4BACNK,YAAY;gCACVQ,UAAU;oCAAEb,MAAM;oCAASc,OAAO;wCAAEC,MAAM;oCAAgC;gCAAE;4BAC9E;wBACF;oBACF;gBACF;YACF;QACF;QAEAnB,OAAOE,qBAAqBC,aAAaiB,aAAa,CAAC;YACrDhB,MAAM;YACNC,OAAO;gBACL,0FAA0F;gBAC1F,qCAAqC;gBACrCgB,MAAM;oBACJd,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,oEAAoE;gCACpEE,OAAO;oCAAER,MAAM;oCAAUS,aAAa;gCAA2B;4BACnE;4BACAF,UAAU;gCAAC;6BAAO;wBACpB;qBACD;gBACH;YACF;YACAF,YAAY;gBACV,6FAA6F;gBAC7F,oFAAoF;gBACpFK,IAAI;oBAAEV,MAAM;gBAAS;gBACrBW,SAAS;oBACPX,MAAM;oBACNK,YAAY;wBACVO,MAAM;4BACJZ,MAAM;4BACNK,YAAY;gCACVQ,UAAU;oCAAEb,MAAM;oCAASc,OAAO;wCAAEC,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/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/validators/cf-worker'
-
-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,62 +0,0 @@
-import {
-  type CollectionSlug,
-  entityToStandaloneJSONSchema,
-  type GlobalSlug,
-  type PayloadRequest,
-  type SanitizedCollectionConfig,
-  type SanitizedGlobalConfig,
-} from 'payload'
-
-import type { JsonSchemaType } from '../../types.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 })
-}
-
-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 })
-}
-
-const buildEntityInputSchema = ({
-  entity,
-  req,
-}: {
-  entity: SanitizedCollectionConfig | SanitizedGlobalConfig
-  req: PayloadRequest
-}): JsonSchemaType =>
-  // The `input` variant is already the write shape; sanitizeEntitySchema only adds MCP-specific passes.
-  sanitizeEntitySchema(
-    entityToStandaloneJSONSchema({
-      config: req.payload.config,
-      defaultIDType: req.payload.db.defaultIDType,
-      entity,
-      i18n: req.i18n,
-      variant: 'input',
-    }) as unknown as JsonSchemaType,
-  )