@payloadcms/plugin-mcp 4.0.0-internal.c7d5de4 → 4.0.0-internal.cb69780

package/src/mcp/builtin/globals/restoreVersionTool.ts

@@ -1,6 +1,4 @@
-import type { PopulateType } from 'payload'
-
-import { z } from 'zod'
+import { restoreGlobalVersionInputSchema } from 'payload'
 
 import { defaultAccess } from '../../../defaultAccess.js'
 import { defineGlobalTool } from '../../../defineTool.js'
@@ -10,8 +8,7 @@ const DEFAULT_DESCRIPTION =
   'Restore a global from a previous version in any version-enabled global.'
 
 export const restoreGlobalVersionTool = defineGlobalTool({
-  access: (args) =>
-    defaultAccess(args) && Boolean(args.permissions?.globals?.[args.globalSlug]?.update),
+  access: (args) => defaultAccess(args) && Boolean(args.permissions?.globals?.[args.slug]?.update),
   annotations: {
     destructiveHint: true,
     idempotentHint: false,
@@ -20,53 +17,25 @@ export const restoreGlobalVersionTool = defineGlobalTool({
     title: 'Restore Global Version',
   },
   description: DEFAULT_DESCRIPTION,
-  input: z.object({
-    id: z.string().describe('The ID of the global version to restore'),
-    depth: z
-      .number()
-      .int()
-      .min(0)
-      .max(10)
-      .describe('How many levels deep to populate relationships in response')
-      .optional()
-      .default(0),
-    fallbackLocale: z
-      .string()
-      .describe('Optional: fallback locale code to use when requested locale is not available')
-      .optional(),
-    locale: z
-      .string()
-      .describe('Optional: locale code to restore in (e.g., "en", "es")')
-      .optional(),
-    populate: z
-      .record(z.string(), z.unknown())
-      .describe(
-        'Optional: control which fields to include from populated relationship or upload documents.',
-      )
-      .optional(),
-    showHiddenFields: z
-      .boolean()
-      .describe('Optional: include hidden fields in the restored global response')
-      .optional(),
-  }),
-}).handler(async ({ authorizedMCP, globalSlug, input, req }) => {
+  input: restoreGlobalVersionInputSchema,
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
   const payload = req.payload
   const logger = getLogger({ payload })
-  const { id, depth, fallbackLocale, locale, populate, showHiddenFields } = input
+  const { id, depth, fallbackLocale, locale, populate, select } = input
 
-  logger.info(`Restoring version for global: ${globalSlug} with ID: ${id}`)
+  logger.info(`Restoring version for global: ${slug} with ID: ${id}`)
 
   try {
     const result = await payload.restoreGlobalVersion({
-      id,
-      slug: globalSlug,
+      id: String(id),
+      slug,
       depth,
       overrideAccess: authorizedMCP.overrideAccess,
       req,
-      ...(fallbackLocale ? { fallbackLocale } : {}),
+      ...(fallbackLocale !== undefined ? { fallbackLocale } : {}),
       ...(locale ? { locale } : {}),
-      ...(populate ? { populate: populate as PopulateType } : {}),
-      ...(showHiddenFields !== undefined ? { showHiddenFields } : {}),
+      ...(populate ? { populate } : {}),
+      ...(select ? { select } : {}),
     })
     const resultObject = result as Record<string, unknown>
     const restoredGlobal =
@@ -78,19 +47,19 @@ export const restoreGlobalVersionTool = defineGlobalTool({
       content: [
         {
           type: 'text',
-          text: `Version "${id}" restored successfully for global "${globalSlug}"!\nRestored global:\n\`\`\`json\n${JSON.stringify(restoredGlobal)}\n\`\`\``,
+          text: `Version "${id}" restored successfully for global "${slug}"!\nRestored global:\n\`\`\`json\n${JSON.stringify(restoredGlobal)}\n\`\`\``,
         },
       ],
       doc: restoredGlobal,
     }
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : 'Unknown error'
-    logger.error(`Error restoring version ${id} for global ${globalSlug}: ${errorMessage}`)
+    logger.error(`Error restoring version ${id} for global ${slug}: ${errorMessage}`)
     return {
       content: [
         {
           type: 'text',
-          text: `❌ **Error restoring version "${id}" for global "${globalSlug}":** ${errorMessage}`,
+          text: `❌ **Error restoring version "${id}" for global "${slug}":** ${errorMessage}`,
         },
       ],
       isError: true,

package/src/mcp/builtin/globals/updateTool.ts

@@ -1,22 +1,20 @@
-import type { SelectType } from 'payload'
-
-import { z } from 'zod'
+import {
+  getGlobalVirtualFieldNames,
+  stripVirtualFields,
+  transformPointDataToPayload,
+  updateGlobalInputSchema,
+  validateGlobalData,
+} from 'payload'
 
 import { defaultAccess } from '../../../defaultAccess.js'
 import { defineGlobalTool } from '../../../defineTool.js'
 import { getLogger } from '../../../utils/getLogger.js'
-import {
-  getGlobalVirtualFieldNames,
-  stripVirtualFields,
-} from '../../../utils/getVirtualFieldNames.js'
-import { transformPointDataToPayload } from '../../../utils/transformPointDataToPayload.js'
-import { validateGlobalData } from '../validateEntityData.js'
+import { formatEntityError } from '../formatEntityError.js'
 
 const DEFAULT_DESCRIPTION = 'Update any Payload global by passing the global slug and data.'
 
 export const updateGlobalTool = defineGlobalTool({
-  access: (args) =>
-    defaultAccess(args) && Boolean(args.permissions?.globals?.[args.globalSlug]?.update),
+  access: (args) => defaultAccess(args) && Boolean(args.permissions?.globals?.[args.slug]?.update),
   annotations: {
     destructiveHint: true,
     idempotentHint: false,
@@ -25,73 +23,54 @@ export const updateGlobalTool = defineGlobalTool({
     title: 'Update Global',
   },
   description: DEFAULT_DESCRIPTION,
-  input: z.object({
-    data: z.record(z.string(), z.unknown()).describe('The global fields to update'),
-    depth: z
-      .number()
-      .describe('Optional: Depth of relationships to populate')
-      .optional()
-      .default(0),
-    draft: z
-      .boolean()
-      .describe('Optional: Whether to save as draft (default: false)')
-      .optional()
-      .default(false),
-    fallbackLocale: z
-      .string()
-      .describe('Optional: fallback locale code to use when requested locale is not available')
-      .optional(),
-    locale: z
-      .string()
-      .describe(
-        'Optional: locale code to update data in (e.g., "en", "es"). Use "all" to update all locales for localized fields',
-      )
-      .optional(),
-    select: z
-      .record(z.string(), z.unknown())
-      .describe(
-        'Optional: define exactly which fields you\'d like to return in the response, e.g., {"siteName": true}',
-      )
-      .optional(),
-  }),
-}).handler(async ({ authorizedMCP, globalSlug, input, req }) => {
+  input: updateGlobalInputSchema,
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
   const payload = req.payload
   const logger = getLogger({ payload })
 
-  const { data, depth, draft, fallbackLocale, locale, select } = input
+  const {
+    data,
+    depth,
+    draft,
+    fallbackLocale,
+    locale,
+    overrideLock,
+    populate,
+    publishAllLocales,
+    select,
+    unpublishAllLocales,
+  } = input
 
-  logger.info(
-    `Updating global: ${globalSlug}, draft: ${draft}${locale ? `, locale: ${locale}` : ''}`,
-  )
+  logger.info(`Updating global: ${slug}, draft: ${draft}${locale ? `, locale: ${locale}` : ''}`)
 
   try {
-    const virtualFieldNames = getGlobalVirtualFieldNames(payload.config, globalSlug)
+    const virtualFieldNames = getGlobalVirtualFieldNames(payload.config, slug)
     const inputData = stripVirtualFields(data, virtualFieldNames)
-    const validationError = validateGlobalData({ data: inputData, globalSlug, req })
-
-    if (validationError) {
-      return validationError
-    }
+    validateGlobalData({ slug, data: inputData, req })
 
     const parsedData = transformPointDataToPayload(inputData)
 
     const updateOptions: Parameters<typeof payload.updateGlobal>[0] = {
-      slug: globalSlug,
+      slug,
       data: parsedData,
       depth,
       draft,
       overrideAccess: authorizedMCP.overrideAccess,
+      overrideLock,
+      populate,
+      publishAllLocales,
       req,
+      unpublishAllLocales,
     }
 
     if (locale) {
       updateOptions.locale = locale
     }
-    if (fallbackLocale) {
+    if (fallbackLocale !== undefined) {
       updateOptions.fallbackLocale = fallbackLocale
     }
     if (select) {
-      updateOptions.select = select as SelectType
+      updateOptions.select = select
     }
 
     const result = await payload.updateGlobal(updateOptions)
@@ -100,16 +79,14 @@ export const updateGlobalTool = defineGlobalTool({
       content: [
         {
           type: 'text',
-          text: `Global "${globalSlug}" updated successfully!\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
+          text: `Global "${slug}" updated successfully!\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
         },
       ],
       doc: result as Record<string, unknown>,
     }
   } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : 'Unknown error'
-    logger.error(`Error updating global ${globalSlug}: ${errorMessage}`)
-    return {
-      content: [{ type: 'text', text: `Error updating global "${globalSlug}": ${errorMessage}` }],
-    }
+    const message = error instanceof Error ? error.message : 'Unknown error'
+    logger.error(`Error updating global ${slug}: ${message}`)
+    return formatEntityError({ slug, action: 'updating', entity: 'global', error, req })
   }
 })

package/src/mcp/builtinTools.ts

@@ -10,7 +10,7 @@ import {
 } from './builtin/collections/authTools.js'
 import { countDocumentsTool } from './builtin/collections/countTool.js'
 import { countVersionsTool } from './builtin/collections/countVersionsTool.js'
-import { createDocumentTool } from './builtin/collections/createTool.js'
+import { createDocumentsTool } from './builtin/collections/createTool.js'
 import { deleteDocumentsTool } from './builtin/collections/deleteTool.js'
 import { duplicateDocumentTool } from './builtin/collections/duplicateTool.js'
 import { findDistinctTool } from './builtin/collections/findDistinctTool.js'
@@ -20,6 +20,7 @@ import { findVersionsTool } from './builtin/collections/findVersionsTool.js'
 import { getCollectionSchemaTool } from './builtin/collections/getCollectionSchemaTool.js'
 import { restoreVersionTool } from './builtin/collections/restoreVersionTool.js'
 import { updateDocumentTool } from './builtin/collections/updateTool.js'
+import { getUploadInstructionsTool } from './builtin/collections/uploadInstructionsTool.js'
 import { getConfigInfoTool } from './builtin/getConfigInfoTool.js'
 import { countGlobalVersionsTool } from './builtin/globals/countVersionsTool.js'
 import { findGlobalTool } from './builtin/globals/findTool.js'
@@ -32,6 +33,7 @@ import { updateGlobalTool } from './builtin/globals/updateTool.js'
 type CollectionBuiltin = {
   mcpName: string
   requiresDuplicateEnabled?: boolean
+  requiresUpload?: boolean
   requiresVersions?: boolean
   tool: CollectionTool
 }
@@ -54,7 +56,7 @@ export const TOOL_BUILTINS = {
 export const COLLECTION_BUILTINS = {
   count: { mcpName: 'countDocuments', tool: countDocumentsTool },
   countVersions: { mcpName: 'countVersions', requiresVersions: true, tool: countVersionsTool },
-  create: { mcpName: 'createDocument', tool: createDocumentTool },
+  create: { mcpName: 'createDocuments', tool: createDocumentsTool },
   delete: { mcpName: 'deleteDocuments', tool: deleteDocumentsTool },
   duplicate: {
     mcpName: 'duplicateDocument',
@@ -70,6 +72,11 @@ export const COLLECTION_BUILTINS = {
   },
   findVersions: { mcpName: 'findVersions', requiresVersions: true, tool: findVersionsTool },
   getCollectionSchema: { mcpName: 'getCollectionSchema', tool: getCollectionSchemaTool },
+  getUploadInstructions: {
+    mcpName: 'getUploadInstructions',
+    requiresUpload: true,
+    tool: getUploadInstructionsTool,
+  },
   restoreVersion: { mcpName: 'restoreVersion', requiresVersions: true, tool: restoreVersionTool },
   update: { mcpName: 'updateDocument', tool: updateDocumentTool },
 } satisfies Record<string, CollectionBuiltin>

package/src/mcp/sanitizeMCPConfig.ts

@@ -127,7 +127,7 @@ const sanitizeCollectionConfig = ({
 
   for (const [
     toolKey,
-    { mcpName, requiresDuplicateEnabled, requiresVersions, tool },
+    { mcpName, requiresDuplicateEnabled, requiresUpload, requiresVersions, tool },
   ] of COLLECTION_BUILTIN_ENTRIES) {
     if (requiresVersions && !collection.versions) {
       continue
@@ -135,6 +135,9 @@ const sanitizeCollectionConfig = ({
     if (requiresDuplicateEnabled && isDuplicateDisabled) {
       continue
     }
+    if (requiresUpload && !collection.upload) {
+      continue
+    }
     const matchedConfigEntry = collectionPluginConfig?.tools?.[toolKey]
     if (matchedConfigEntry === false) {
       continue

package/src/stdio.ts

@@ -3,8 +3,8 @@ import type { Config, Plugin, SanitizedConfig } from 'payload'
 /* eslint-disable no-console */
 import { serveStdio } from '@modelcontextprotocol/server/stdio'
 import { fileURLToPath, pathToFileURL } from 'node:url'
-import { createLocalReq, getPayload } from 'payload'
-import { findConfig } from 'payload/node'
+import { createPayloadRequest, getPayload } from 'payload'
+import { findConfig, loadEnv } from 'payload/node'
 
 import type { SanitizedMCPPluginConfig } from './types.js'
 
@@ -28,6 +28,7 @@ export const runMcpStdio = async (): Promise<void> => {
     process.chdir(projectRoot)
   }
 
+  loadEnv()
   const configPath = findConfig()
   const configModule = await import(pathToFileURL(configPath).toString())
   const config = (await (configModule.default ?? configModule)) as SanitizedConfig
@@ -90,7 +91,7 @@ export const runMcpStdio = async (): Promise<void> => {
     headers.set('Authorization', process.env.PAYLOAD_MCP_AUTHORIZATION)
   }
 
-  const req = await createLocalReq({ req: { headers } }, payload)
+  const req = await createPayloadRequest({ payload, req: { headers } })
   req.payloadAPI = 'MCP' as const
   const authorizedMCP = await getAuthorizedMCP({ overrideAccess, req })
 

package/src/types.ts

@@ -75,11 +75,11 @@ export type MCPAccessArgs = {
 }
 
 export type CollectionMCPAccessArgs = {
-  collectionSlug: CollectionSlug
+  slug: CollectionSlug
 } & MCPAccessArgs
 
 export type GlobalMCPAccessArgs = {
-  globalSlug: GlobalSlug
+  slug: GlobalSlug
 } & MCPAccessArgs
 
 export type ToolHandlerArgs<TSchema = undefined> = {
@@ -90,11 +90,11 @@ export type ToolHandlerArgs<TSchema = undefined> = {
 }
 
 export type CollectionToolHandlerArgs<TSchema = undefined> = {
-  collectionSlug: CollectionSlug
+  slug: CollectionSlug
 } & ToolHandlerArgs<TSchema>
 
 export type GlobalToolHandlerArgs<TSchema = undefined> = {
-  globalSlug: GlobalSlug
+  slug: GlobalSlug
 } & ToolHandlerArgs<TSchema>
 
 export type Tool<TSchema extends ToolInputSchema | undefined = ToolInputSchema | undefined> = {

package/dist/mcp/builtin/collections/fileInput.spec.js

@@ -1,72 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { fileInputSchema, resolveFileInput } from './fileInput.js';
-describe('MCP file input', ()=>{
-    it('should reject malformed MIME types', ()=>{
-        const result = fileInputSchema.safeParse({
-            data: 'aGVsbG8=',
-            mimeType: 'text/plain\r\nx-test: value',
-            name: 'hello.txt',
-            source: 'base64'
-        });
-        expect(result.success).toBe(false);
-    });
-    it('should reject oversized base64 files', async ()=>{
-        const req = createRequest({
-            maxFileSize: 4
-        });
-        await expect(resolveFileInput({
-            collectionSlug: 'media',
-            input: {
-                data: Buffer.from('hello').toString('base64'),
-                mimeType: 'text/plain',
-                name: 'hello.txt',
-                source: 'base64'
-            },
-            req
-        })).rejects.toThrow('File exceeds the 4 byte upload limit.');
-    });
-    it('should reject URLs outside the collection allowlist', async ()=>{
-        const req = createRequest({
-            allowList: [
-                {
-                    hostname: 'assets.example.com',
-                    protocol: 'https'
-                }
-            ]
-        });
-        await expect(resolveFileInput({
-            collectionSlug: 'media',
-            input: {
-                source: 'url',
-                url: 'https://example.com/image.png'
-            },
-            req
-        })).rejects.toThrow('The provided file URL is not allowed.');
-    });
-});
-function createRequest({ allowList, maxFileSize }) {
-    return {
-        payload: {
-            collections: {
-                media: {
-                    config: {
-                        upload: allowList ? {
-                            pasteURL: {
-                                allowList
-                            }
-                        } : {}
-                    }
-                }
-            },
-            config: {
-                upload: {
-                    limits: {
-                        fileSize: maxFileSize
-                    }
-                }
-            }
-        }
-    };
-}
-
-//# sourceMappingURL=fileInput.spec.js.map

package/dist/mcp/builtin/collections/fileInput.spec.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/mcp/builtin/collections/fileInput.spec.ts"],"sourcesContent":["import type { PayloadRequest } from 'payload'\n\nimport { describe, expect, it } from 'vitest'\n\nimport { fileInputSchema, resolveFileInput } from './fileInput.js'\n\ndescribe('MCP file input', () => {\n  it('should reject malformed MIME types', () => {\n    const result = fileInputSchema.safeParse({\n      data: 'aGVsbG8=',\n      mimeType: 'text/plain\\r\\nx-test: value',\n      name: 'hello.txt',\n      source: 'base64',\n    })\n\n    expect(result.success).toBe(false)\n  })\n\n  it('should reject oversized base64 files', async () => {\n    const req = createRequest({ maxFileSize: 4 })\n\n    await expect(\n      resolveFileInput({\n        collectionSlug: 'media',\n        input: {\n          data: Buffer.from('hello').toString('base64'),\n          mimeType: 'text/plain',\n          name: 'hello.txt',\n          source: 'base64',\n        },\n        req,\n      }),\n    ).rejects.toThrow('File exceeds the 4 byte upload limit.')\n  })\n\n  it('should reject URLs outside the collection allowlist', async () => {\n    const req = createRequest({\n      allowList: [{ hostname: 'assets.example.com', protocol: 'https' }],\n    })\n\n    await expect(\n      resolveFileInput({\n        collectionSlug: 'media',\n        input: {\n          source: 'url',\n          url: 'https://example.com/image.png',\n        },\n        req,\n      }),\n    ).rejects.toThrow('The provided file URL is not allowed.')\n  })\n})\n\nfunction createRequest({\n  allowList,\n  maxFileSize,\n}: {\n  allowList?: Array<{ hostname: string; protocol: 'http' | 'https' }>\n  maxFileSize?: number\n}): PayloadRequest {\n  return {\n    payload: {\n      collections: {\n        media: {\n          config: {\n            upload: allowList ? { pasteURL: { allowList } } : {},\n          },\n        },\n      },\n      config: {\n        upload: {\n          limits: {\n            fileSize: maxFileSize,\n          },\n        },\n      },\n    },\n  } as unknown as PayloadRequest\n}\n"],"names":["describe","expect","it","fileInputSchema","resolveFileInput","result","safeParse","data","mimeType","name","source","success","toBe","req","createRequest","maxFileSize","collectionSlug","input","Buffer","from","toString","rejects","toThrow","allowList","hostname","protocol","url","payload","collections","media","config","upload","pasteURL","limits","fileSize"],"mappings":"AAEA,SAASA,QAAQ,EAAEC,MAAM,EAAEC,EAAE,QAAQ,SAAQ;AAE7C,SAASC,eAAe,EAAEC,gBAAgB,QAAQ,iBAAgB;AAElEJ,SAAS,kBAAkB;IACzBE,GAAG,sCAAsC;QACvC,MAAMG,SAASF,gBAAgBG,SAAS,CAAC;YACvCC,MAAM;YACNC,UAAU;YACVC,MAAM;YACNC,QAAQ;QACV;QAEAT,OAAOI,OAAOM,OAAO,EAAEC,IAAI,CAAC;IAC9B;IAEAV,GAAG,wCAAwC;QACzC,MAAMW,MAAMC,cAAc;YAAEC,aAAa;QAAE;QAE3C,MAAMd,OACJG,iBAAiB;YACfY,gBAAgB;YAChBC,OAAO;gBACLV,MAAMW,OAAOC,IAAI,CAAC,SAASC,QAAQ,CAAC;gBACpCZ,UAAU;gBACVC,MAAM;gBACNC,QAAQ;YACV;YACAG;QACF,IACAQ,OAAO,CAACC,OAAO,CAAC;IACpB;IAEApB,GAAG,uDAAuD;QACxD,MAAMW,MAAMC,cAAc;YACxBS,WAAW;gBAAC;oBAAEC,UAAU;oBAAsBC,UAAU;gBAAQ;aAAE;QACpE;QAEA,MAAMxB,OACJG,iBAAiB;YACfY,gBAAgB;YAChBC,OAAO;gBACLP,QAAQ;gBACRgB,KAAK;YACP;YACAb;QACF,IACAQ,OAAO,CAACC,OAAO,CAAC;IACpB;AACF;AAEA,SAASR,cAAc,EACrBS,SAAS,EACTR,WAAW,EAIZ;IACC,OAAO;QACLY,SAAS;YACPC,aAAa;gBACXC,OAAO;oBACLC,QAAQ;wBACNC,QAAQR,YAAY;4BAAES,UAAU;gCAAET;4BAAU;wBAAE,IAAI,CAAC;oBACrD;gBACF;YACF;YACAO,QAAQ;gBACNC,QAAQ;oBACNE,QAAQ;wBACNC,UAAUnB;oBACZ;gBACF;YACF;QACF;IACF;AACF"}

package/dist/mcp/builtin/collections/formatCollectionError.d.ts

@@ -1,9 +0,0 @@
-import type { CollectionSlug, PayloadRequest } from 'payload';
-import type { MCPToolResponse } from '../../../types.js';
-export declare const formatCollectionError: ({ action, collectionSlug, error, req, }: {
-    action: 'creating' | 'duplicating' | 'updating';
-    collectionSlug: CollectionSlug;
-    error: unknown;
-    req: PayloadRequest;
-}) => MCPToolResponse;
-//# sourceMappingURL=formatCollectionError.d.ts.map

package/dist/mcp/builtin/collections/formatCollectionError.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"formatCollectionError.d.ts","sourceRoot":"","sources":["../../../../src/mcp/builtin/collections/formatCollectionError.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAgCxD,eAAO,MAAM,qBAAqB,4CAK/B;IACD,MAAM,EAAE,UAAU,GAAG,aAAa,GAAG,UAAU,CAAA;IAC/C,cAAc,EAAE,cAAc,CAAA;IAC9B,KAAK,EAAE,OAAO,CAAA;IACd,GAAG,EAAE,cAAc,CAAA;CACpB,KAAG,eAuCH,CAAA"}

package/dist/mcp/builtin/collections/formatCollectionError.js

@@ -1,60 +0,0 @@
-import { getCollectionInputSchema } from '../../../utils/schemaConversion/getEntityInputSchema.js';
-const getValidationErrors = (error)=>{
-    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, message)=>{
-    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 })=>{
-    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
-            }
-        } : {}
-    };
-};
-
-//# sourceMappingURL=formatCollectionError.js.map

package/dist/mcp/builtin/collections/formatCollectionError.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/mcp/builtin/collections/formatCollectionError.ts"],"sourcesContent":["import type { CollectionSlug, PayloadRequest } from 'payload'\n\nimport type { MCPToolResponse } from '../../../types.js'\n\nimport { getCollectionInputSchema } from '../../../utils/schemaConversion/getEntityInputSchema.js'\n\nconst getValidationErrors = (error: unknown): undefined | unknown[] => {\n  if (!error || typeof error !== 'object') {\n    return undefined\n  }\n\n  const data = 'data' in error ? error.data : undefined\n  if (!data || typeof data !== 'object' || !('errors' in data) || !Array.isArray(data.errors)) {\n    return undefined\n  }\n\n  return data.errors\n}\n\nconst isSchemaError = (error: unknown, message: string): boolean => {\n  if (getValidationErrors(error)) {\n    return true\n  }\n\n  const name = error && typeof error === 'object' && 'name' in error ? error.name : undefined\n\n  return (\n    name === 'CastError' ||\n    name === 'ValidationError' ||\n    message.includes('Cast to ') ||\n    message.includes('validation failed')\n  )\n}\n\nexport const formatCollectionError = ({\n  action,\n  collectionSlug,\n  error,\n  req,\n}: {\n  action: 'creating' | 'duplicating' | 'updating'\n  collectionSlug: CollectionSlug\n  error: unknown\n  req: PayloadRequest\n}): MCPToolResponse => {\n  const errorMessage = error instanceof Error ? error.message : 'Unknown error'\n  const errors = getValidationErrors(error) ?? [{ message: errorMessage }]\n\n  if (!isSchemaError(error, errorMessage)) {\n    return {\n      content: [\n        {\n          type: 'text',\n          text: `Error ${action} document in collection \"${collectionSlug}\": ${errorMessage}`,\n        },\n      ],\n      isError: true,\n    }\n  }\n\n  const schema = getCollectionInputSchema({ collectionSlug, req })\n  const schemaText = schema\n    ? `\\n\\nUse this schema for data:\\n\\`\\`\\`json\\n${JSON.stringify(schema)}\\n\\`\\`\\``\n    : ''\n\n  return {\n    content: [\n      {\n        type: 'text',\n        text: `Error ${action} document in collection \"${collectionSlug}\": ${errorMessage}${schemaText}`,\n      },\n    ],\n    isError: true,\n    ...(schema\n      ? {\n          structuredContent: {\n            collectionSlug,\n            errors,\n            schema,\n          },\n        }\n      : {}),\n  }\n}\n"],"names":["getCollectionInputSchema","getValidationErrors","error","undefined","data","Array","isArray","errors","isSchemaError","message","name","includes","formatCollectionError","action","collectionSlug","req","errorMessage","Error","content","type","text","isError","schema","schemaText","JSON","stringify","structuredContent"],"mappings":"AAIA,SAASA,wBAAwB,QAAQ,0DAAyD;AAElG,MAAMC,sBAAsB,CAACC;IAC3B,IAAI,CAACA,SAAS,OAAOA,UAAU,UAAU;QACvC,OAAOC;IACT;IAEA,MAAMC,OAAO,UAAUF,QAAQA,MAAME,IAAI,GAAGD;IAC5C,IAAI,CAACC,QAAQ,OAAOA,SAAS,YAAY,CAAE,CAAA,YAAYA,IAAG,KAAM,CAACC,MAAMC,OAAO,CAACF,KAAKG,MAAM,GAAG;QAC3F,OAAOJ;IACT;IAEA,OAAOC,KAAKG,MAAM;AACpB;AAEA,MAAMC,gBAAgB,CAACN,OAAgBO;IACrC,IAAIR,oBAAoBC,QAAQ;QAC9B,OAAO;IACT;IAEA,MAAMQ,OAAOR,SAAS,OAAOA,UAAU,YAAY,UAAUA,QAAQA,MAAMQ,IAAI,GAAGP;IAElF,OACEO,SAAS,eACTA,SAAS,qBACTD,QAAQE,QAAQ,CAAC,eACjBF,QAAQE,QAAQ,CAAC;AAErB;AAEA,OAAO,MAAMC,wBAAwB,CAAC,EACpCC,MAAM,EACNC,cAAc,EACdZ,KAAK,EACLa,GAAG,EAMJ;IACC,MAAMC,eAAed,iBAAiBe,QAAQf,MAAMO,OAAO,GAAG;IAC9D,MAAMF,SAASN,oBAAoBC,UAAU;QAAC;YAAEO,SAASO;QAAa;KAAE;IAExE,IAAI,CAACR,cAAcN,OAAOc,eAAe;QACvC,OAAO;YACLE,SAAS;gBACP;oBACEC,MAAM;oBACNC,MAAM,CAAC,MAAM,EAAEP,OAAO,yBAAyB,EAAEC,eAAe,GAAG,EAAEE,cAAc;gBACrF;aACD;YACDK,SAAS;QACX;IACF;IAEA,MAAMC,SAAStB,yBAAyB;QAAEc;QAAgBC;IAAI;IAC9D,MAAMQ,aAAaD,SACf,CAAC,2CAA2C,EAAEE,KAAKC,SAAS,CAACH,QAAQ,QAAQ,CAAC,GAC9E;IAEJ,OAAO;QACLJ,SAAS;YACP;gBACEC,MAAM;gBACNC,MAAM,CAAC,MAAM,EAAEP,OAAO,yBAAyB,EAAEC,eAAe,GAAG,EAAEE,eAAeO,YAAY;YAClG;SACD;QACDF,SAAS;QACT,GAAIC,SACA;YACEI,mBAAmB;gBACjBZ;gBACAP;gBACAe;YACF;QACF,IACA,CAAC,CAAC;IACR;AACF,EAAC"}

package/dist/mcp/builtin/validateEntityData.d.ts

@@ -1,14 +0,0 @@
-import type { CollectionSlug, GlobalSlug, PayloadRequest } from 'payload';
-import type { MCPToolResponse } from '../../types.js';
-export declare const validateCollectionData: ({ collectionSlug, data, partial, req, }: {
-    collectionSlug: CollectionSlug;
-    data: Record<string, unknown>;
-    partial?: boolean;
-    req: PayloadRequest;
-}) => MCPToolResponse | null;
-export declare const validateGlobalData: ({ data, globalSlug, req, }: {
-    data: Record<string, unknown>;
-    globalSlug: GlobalSlug;
-    req: PayloadRequest;
-}) => MCPToolResponse | null;
-//# sourceMappingURL=validateEntityData.d.ts.map

package/dist/mcp/builtin/validateEntityData.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"validateEntityData.d.ts","sourceRoot":"","sources":["../../../src/mcp/builtin/validateEntityData.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,cAAc,EAAmB,MAAM,SAAS,CAAA;AAI1F,OAAO,KAAK,EAAkB,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAuBrE,eAAO,MAAM,sBAAsB,4CAKhC;IACD,cAAc,EAAE,cAAc,CAAA;IAC9B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC7B,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,GAAG,EAAE,cAAc,CAAA;CACpB,KAAG,eAAe,GAAG,IAQlB,CAAA;AAEJ,eAAO,MAAM,kBAAkB,+BAI5B;IACD,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC7B,UAAU,EAAE,UAAU,CAAA;IACtB,GAAG,EAAE,cAAc,CAAA;CACpB,KAAG,eAAe,GAAG,IAQlB,CAAA"}

package/dist/mcp/builtin/validateEntityData.js

@@ -1,82 +0,0 @@
-import { CfWorkerJsonSchemaValidator } from '@modelcontextprotocol/server/validators/cf-worker';
-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
-});
-/**
- * - 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();
-export const validateCollectionData = ({ collectionSlug, data, partial, req })=>validateData({
-        slug: collectionSlug,
-        buildSchema: ()=>getCollectionInputSchema({
-                collectionSlug,
-                req
-            }),
-        data,
-        entity: 'collection',
-        partial,
-        req
-    });
-export const validateGlobalData = ({ data, globalSlug, req })=>validateData({
-        slug: globalSlug,
-        buildSchema: ()=>getGlobalInputSchema({
-                globalSlug,
-                req
-            }),
-        data,
-        entity: 'global',
-        partial: true,
-        req
-    });
-const validateData = ({ slug, buildSchema, data, entity, partial, req })=>{
-    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)=>{
-    const { required: _required, ...rest } = schema;
-    return rest;
-};
-
-//# sourceMappingURL=validateEntityData.js.map