@payloadcms/plugin-mcp 4.0.0-internal.bc5cf8c → 4.0.0-internal.bf4bcce

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

@@ -0,0 +1,64 @@
+import { strictObject, z } from 'payload'
+import { getUploadInstructions as getPayloadUploadInstructions } from 'payload/internal'
+
+import { defaultAccess } from '../../../defaultAccess.js'
+import { defineCollectionTool } from '../../../defineTool.js'
+
+export const getUploadInstructionsTool = defineCollectionTool({
+  access: (args) =>
+    defaultAccess(args) &&
+    Boolean(
+      args.permissions?.collections?.[args.slug]?.create ||
+        args.permissions?.collections?.[args.slug]?.update,
+    ),
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true,
+    readOnlyHint: false,
+    title: 'Get Upload Instructions',
+  },
+  description:
+    'Prepare uploads for createDocuments or updateDocument. This does not upload bytes; finish the returned action before use.',
+  input: strictObject({
+    docPrefix: z.optional(z.string()).check(z.describe('Document folder or prefix.')),
+    filename: z.string().check(z.describe('The original file name.')),
+    filesize: z.int().check(z.nonnegative(), z.describe('The file size in bytes.')),
+    mimeType: z.string().check(z.describe('The file MIME type.')),
+  }),
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
+  try {
+    const instructions = await getPayloadUploadInstructions({
+      ...input,
+      collectionSlug: slug,
+      overrideAccess: authorizedMCP.overrideAccess,
+      req,
+    })
+
+    const nextStep =
+      instructions.type === 'http'
+        ? 'Upload bytes with instructions.request. After success, pass { source: "uploadReference", file: instructions.file }.'
+        : `Call "${instructions.name}" with file and data. After success, pass { source: "uploadReference", file: instructions.file }.`
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Upload instructions for collection "${slug}":\n\`\`\`json\n${JSON.stringify(instructions)}\n\`\`\`\n${nextStep}`,
+        },
+      ],
+      structuredContent: { instructions },
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : 'Unknown error'
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Error getting upload instructions for collection "${slug}": ${message}`,
+        },
+      ],
+      isError: true,
+    }
+  }
+})

package/src/mcp/builtin/formatEntityError.ts

@@ -0,0 +1,77 @@
+import type { CollectionSlug, GlobalSlug, PayloadRequest } from 'payload'
+
+import { getCollectionInputSchema, getGlobalInputSchema, ValidationError } from 'payload'
+
+import type { MCPToolResponse } from '../../types.js'
+
+export const formatEntityError = ({
+  slug,
+  action,
+  entity,
+  error,
+  req,
+}:
+  | {
+      action: 'creating' | 'duplicating' | 'updating'
+      entity: 'collection'
+      error: unknown
+      req: PayloadRequest
+      slug: CollectionSlug
+    }
+  | {
+      action: 'updating'
+      entity: 'global'
+      error: unknown
+      req: PayloadRequest
+      slug: GlobalSlug
+    }): MCPToolResponse => {
+  const message = error instanceof Error ? error.message : 'Unknown error'
+  const target = entity === 'collection' ? `document in collection "${slug}"` : `global "${slug}"`
+
+  if (!isValidationError(error, message)) {
+    return {
+      content: [{ type: 'text', text: `Error ${action} ${target}: ${message}` }],
+      isError: true,
+    }
+  }
+
+  const schema =
+    entity === 'collection'
+      ? getCollectionInputSchema({ collectionSlug: slug, req })
+      : getGlobalInputSchema({ globalSlug: slug, req })
+  const errors = error instanceof ValidationError ? error.data.errors : [{ message }]
+  const validationMessage = errors
+    .map((issue) => `${'path' in issue ? `${issue.path}: ` : ''}${issue.message}`)
+    .join('\n')
+  const schemaText = schema
+    ? `\n\nUse this schema for data:\n\`\`\`json\n${JSON.stringify(schema)}\n\`\`\``
+    : ''
+
+  return {
+    content: [
+      { type: 'text', text: `Error ${action} ${target}: ${validationMessage}${schemaText}` },
+    ],
+    isError: true,
+    ...(schema
+      ? {
+          structuredContent: {
+            slug,
+            errors,
+            schema,
+          },
+        }
+      : {}),
+  }
+}
+
+const isValidationError = (error: unknown, message: string): boolean => {
+  if (error instanceof ValidationError) {
+    return true
+  }
+
+  const name = error && typeof error === 'object' && 'name' in error ? error.name : undefined
+
+  return (
+    name === 'CastError' || message.includes('Cast to ') || message.includes('validation failed')
+  )
+}

package/src/mcp/builtin/getConfigInfoTool.ts

@@ -1,4 +1,4 @@
-import { getAccessResults, isEntityHidden } from 'payload'
+import { getAccessResults, getConfigInfoInputSchema, isEntityHidden } from 'payload'
 
 import { defineTool } from '../../defineTool.js'
 
@@ -11,11 +11,10 @@ export const getConfigInfoTool = defineTool({
     title: 'Config Info',
   },
   description: 'List the Payload collection and global slugs visible to this MCP client.',
+  input: getConfigInfoInputSchema,
 }).handler(async ({ authorizedMCP, req }) => {
-  const user = authorizedMCP.user
-  const permissions = authorizedMCP.overrideAccess
-    ? null
-    : await getAccessResults({ req: { ...req, user } })
+  const user = req.user
+  const permissions = authorizedMCP.overrideAccess ? null : await getAccessResults({ req })
   const authorizedCollectionSlugs = new Set<string>()
   const authorizedGlobalSlugs = new Set<string>()
 

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

@@ -1,17 +1,15 @@
-import { z } from 'zod'
+import { countGlobalVersionsInputSchema } from 'payload'
 
 import { defaultAccess } from '../../../defaultAccess.js'
 import { defineGlobalTool } from '../../../defineTool.js'
 import { getLogger } from '../../../utils/getLogger.js'
-import { localAPIDefaults } from '../../../utils/localAPIDefaults.js'
-import { whereSchema } from '../../../utils/whereSchema.js'
 
 const DEFAULT_DESCRIPTION =
   'Count global versions in any version-enabled global by passing the global slug and optional where clause.'
 
 export const countGlobalVersionsTool = defineGlobalTool({
   access: (args) =>
-    defaultAccess(args) && Boolean(args.permissions?.globals?.[args.globalSlug]?.readVersions),
+    defaultAccess(args) && Boolean(args.permissions?.globals?.[args.slug]?.readVersions),
   annotations: {
     destructiveHint: false,
     idempotentHint: true,
@@ -20,26 +18,19 @@ export const countGlobalVersionsTool = defineGlobalTool({
     title: 'Count Global Versions',
   },
   description: DEFAULT_DESCRIPTION,
-  input: z.object({
-    locale: z.string().describe('Optional: locale code to count versions in').optional(),
-    where: whereSchema
-      .describe(
-        'Optional: where clause for filtering versions. Version document fields are usually under "version". Example: {"version.siteName":{"contains":"test"}}',
-      )
-      .optional(),
-  }),
-}).handler(async ({ authorizedMCP, globalSlug, input, req }) => {
+  input: countGlobalVersionsInputSchema,
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
   const payload = req.payload
   const logger = getLogger({ payload })
   const { locale, where } = input
 
-  logger.info(`Counting versions for global: ${globalSlug}`)
+  logger.info(`Counting versions for global: ${slug}`)
 
   try {
     const result = await payload.countGlobalVersions({
-      global: globalSlug,
+      global: slug,
+      overrideAccess: authorizedMCP.overrideAccess,
       req,
-      ...localAPIDefaults(authorizedMCP),
       ...(locale ? { locale } : {}),
       ...(where ? { where } : {}),
     })
@@ -48,19 +39,19 @@ export const countGlobalVersionsTool = defineGlobalTool({
       content: [
         {
           type: 'text',
-          text: `Global "${globalSlug}" contains ${result.totalDocs} matching versions.\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
+          text: `Global "${slug}" contains ${result.totalDocs} matching versions.\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
         },
       ],
       doc: result,
     }
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : 'Unknown error'
-    logger.error(`Error counting versions for global ${globalSlug}: ${errorMessage}`)
+    logger.error(`Error counting versions for global ${slug}: ${errorMessage}`)
     return {
       content: [
         {
           type: 'text',
-          text: `❌ **Error counting versions for global "${globalSlug}":** ${errorMessage}`,
+          text: `❌ **Error counting versions for global "${slug}":** ${errorMessage}`,
         },
       ],
       isError: true,

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

@@ -1,17 +1,13 @@
-import type { PopulateType, SelectType } from 'payload'
-
-import { z } from 'zod'
+import { findGlobalInputSchema } from 'payload'
 
 import { defaultAccess } from '../../../defaultAccess.js'
 import { defineGlobalTool } from '../../../defineTool.js'
 import { getLogger } from '../../../utils/getLogger.js'
-import { localAPIDefaults } from '../../../utils/localAPIDefaults.js'
 
 const DEFAULT_DESCRIPTION = 'Find any Payload global by passing the global slug.'
 
 export const findGlobalTool = defineGlobalTool({
-  access: (args) =>
-    defaultAccess(args) && Boolean(args.permissions?.globals?.[args.globalSlug]?.read),
+  access: (args) => defaultAccess(args) && Boolean(args.permissions?.globals?.[args.slug]?.read),
   annotations: {
     destructiveHint: false,
     idempotentHint: true,
@@ -20,86 +16,51 @@ export const findGlobalTool = defineGlobalTool({
     title: 'Find Global',
   },
   description: DEFAULT_DESCRIPTION,
-  input: z.object({
-    depth: z
-      .number()
-      .int()
-      .min(0)
-      .max(10)
-      .describe('Depth of population for relationships')
-      .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 retrieve data in (e.g., "en", "es"). Use "all" to retrieve all locales for localized fields',
-      )
-      .optional(),
-    populate: z
-      .record(z.string(), z.unknown())
-      .describe(
-        'Optional: control which fields to include from populated relationship or upload documents.',
-      )
-      .optional(),
-    select: z
-      .record(z.string(), z.unknown())
-      .describe(
-        'Optional: define exactly which fields you\'d like to return in the response, e.g., {"title": true}',
-      )
-      .optional(),
-  }),
-}).handler(async ({ authorizedMCP, globalSlug, input, req }) => {
+  input: findGlobalInputSchema,
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
   const payload = req.payload
   const logger = getLogger({ payload })
 
   const { depth, fallbackLocale, locale, populate, select } = input
 
-  logger.info(
-    `Reading global: ${globalSlug}, depth: ${depth}${locale ? `, locale: ${locale}` : ''}`,
-  )
+  logger.info(`Reading global: ${slug}, depth: ${depth}${locale ? `, locale: ${locale}` : ''}`)
 
   try {
     const findOptions: Parameters<typeof payload.findGlobal>[0] = {
-      slug: globalSlug,
+      slug,
       depth,
-      ...localAPIDefaults(authorizedMCP),
+      overrideAccess: authorizedMCP.overrideAccess,
+      req,
     }
 
     if (locale) {
       findOptions.locale = locale
     }
-    if (fallbackLocale) {
+    if (fallbackLocale !== undefined) {
       findOptions.fallbackLocale = fallbackLocale
     }
     if (select) {
-      findOptions.select = select as SelectType
+      findOptions.select = select
     }
     if (populate) {
-      findOptions.populate = populate as PopulateType
+      findOptions.populate = populate
     }
-
     const result = await payload.findGlobal(findOptions)
 
     return {
       content: [
         {
           type: 'text',
-          text: `Global "${globalSlug}":\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
+          text: `Global "${slug}":\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 reading global ${globalSlug}: ${errorMessage}`)
+    logger.error(`Error reading global ${slug}: ${errorMessage}`)
     return {
-      content: [
-        { type: 'text', text: `❌ **Error reading global "${globalSlug}":** ${errorMessage}` },
-      ],
+      content: [{ type: 'text', text: `❌ **Error reading global "${slug}":** ${errorMessage}` }],
     }
   }
 })

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

@@ -1,18 +1,15 @@
-import type { PopulateType, SelectType } from 'payload'
-
-import { z } from 'zod'
+import { findGlobalVersionByIDInputSchema } from 'payload'
 
 import { defaultAccess } from '../../../defaultAccess.js'
 import { defineGlobalTool } from '../../../defineTool.js'
 import { getLogger } from '../../../utils/getLogger.js'
-import { localAPIDefaults } from '../../../utils/localAPIDefaults.js'
 
 const DEFAULT_DESCRIPTION =
   'Find a specific global version in any version-enabled global by passing the global slug and version ID.'
 
 export const findGlobalVersionByIDTool = defineGlobalTool({
   access: (args) =>
-    defaultAccess(args) && Boolean(args.permissions?.globals?.[args.globalSlug]?.readVersions),
+    defaultAccess(args) && Boolean(args.permissions?.globals?.[args.slug]?.readVersions),
   annotations: {
     destructiveHint: false,
     idempotentHint: true,
@@ -21,81 +18,44 @@ export const findGlobalVersionByIDTool = defineGlobalTool({
     title: 'Find Global Version By ID',
   },
   description: DEFAULT_DESCRIPTION,
-  input: z.object({
-    id: z.string().describe('The ID of the global version to retrieve'),
-    depth: z
-      .number()
-      .int()
-      .min(0)
-      .max(10)
-      .describe('How many levels deep to populate relationships in the global version document')
-      .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 retrieve data in (e.g., "en", "es"). Use "all" to retrieve all locales for localized fields',
-      )
-      .optional(),
-    populate: z
-      .record(z.string(), z.unknown())
-      .describe(
-        'Optional: control which fields to include from populated relationship or upload documents.',
-      )
-      .optional(),
-    select: z
-      .record(z.string(), z.unknown())
-      .describe(
-        'Optional: define exactly which fields you\'d like to return in the response, e.g., {"version.siteName": true}',
-      )
-      .optional(),
-    showHiddenFields: z
-      .boolean()
-      .describe('Optional: include hidden fields in the returned global version document')
-      .optional(),
-  }),
-}).handler(async ({ authorizedMCP, globalSlug, input, req }) => {
+  input: findGlobalVersionByIDInputSchema,
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
   const payload = req.payload
   const logger = getLogger({ payload })
-  const { id, depth, fallbackLocale, locale, populate, select, showHiddenFields } = input
+  const { id, depth, fallbackLocale, locale, populate, select } = input
 
-  logger.info(`Finding version for global: ${globalSlug} with ID: ${id}`)
+  logger.info(`Finding version for global: ${slug} with ID: ${id}`)
 
   try {
     const result = await payload.findGlobalVersionByID({
       id,
-      slug: globalSlug,
+      slug,
       depth,
+      overrideAccess: authorizedMCP.overrideAccess,
       req,
-      ...localAPIDefaults(authorizedMCP),
-      ...(fallbackLocale ? { fallbackLocale } : {}),
+      ...(fallbackLocale !== undefined ? { fallbackLocale } : {}),
       ...(locale ? { locale } : {}),
-      ...(populate ? { populate: populate as PopulateType } : {}),
-      ...(select ? { select: select as SelectType } : {}),
-      ...(showHiddenFields !== undefined ? { showHiddenFields } : {}),
+      ...(populate ? { populate } : {}),
+      ...(select ? { select } : {}),
     })
 
     return {
       content: [
         {
           type: 'text',
-          text: `Version "${id}" from global "${globalSlug}":\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
+          text: `Version "${id}" from global "${slug}":\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
         },
       ],
       doc: result as unknown as Record<string, unknown>,
     }
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : 'Unknown error'
-    logger.error(`Error finding version ${id} for global ${globalSlug}: ${errorMessage}`)
+    logger.error(`Error finding version ${id} for global ${slug}: ${errorMessage}`)
     return {
       content: [
         {
           type: 'text',
-          text: `❌ **Error finding version "${id}" for global "${globalSlug}":** ${errorMessage}`,
+          text: `❌ **Error finding version "${id}" for global "${slug}":** ${errorMessage}`,
         },
       ],
       isError: true,

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

@@ -1,19 +1,15 @@
-import type { PopulateType, SelectType } from 'payload'
-
-import { z } from 'zod'
+import { findGlobalVersionsInputSchema } from 'payload'
 
 import { defaultAccess } from '../../../defaultAccess.js'
 import { defineGlobalTool } from '../../../defineTool.js'
 import { getLogger } from '../../../utils/getLogger.js'
-import { localAPIDefaults } from '../../../utils/localAPIDefaults.js'
-import { whereSchema } from '../../../utils/whereSchema.js'
 
 const DEFAULT_DESCRIPTION =
   'Find global versions in any version-enabled global by passing the global slug and optional where clause.'
 
 export const findGlobalVersionsTool = defineGlobalTool({
   access: (args) =>
-    defaultAccess(args) && Boolean(args.permissions?.globals?.[args.globalSlug]?.readVersions),
+    defaultAccess(args) && Boolean(args.permissions?.globals?.[args.slug]?.readVersions),
   annotations: {
     destructiveHint: false,
     idempotentHint: true,
@@ -22,103 +18,28 @@ export const findGlobalVersionsTool = defineGlobalTool({
     title: 'Find Global Versions',
   },
   description: DEFAULT_DESCRIPTION,
-  input: z.object({
-    depth: z
-      .number()
-      .int()
-      .min(0)
-      .max(10)
-      .describe('How many levels deep to populate relationships in global version documents')
-      .optional()
-      .default(0),
-    fallbackLocale: z
-      .string()
-      .describe('Optional: fallback locale code to use when requested locale is not available')
-      .optional(),
-    limit: z
-      .number()
-      .int()
-      .min(1)
-      .max(100)
-      .describe('Maximum number of versions to return (default: 10, max: 100)')
-      .optional()
-      .default(10),
-    locale: z
-      .string()
-      .describe(
-        'Optional: locale code to retrieve data in (e.g., "en", "es"). Use "all" to retrieve all locales for localized fields',
-      )
-      .optional(),
-    page: z
-      .number()
-      .int()
-      .min(1)
-      .describe('Page number for pagination (default: 1)')
-      .optional()
-      .default(1),
-    pagination: z
-      .boolean()
-      .describe('Optional: set to false to skip the count query overhead')
-      .optional(),
-    populate: z
-      .record(z.string(), z.unknown())
-      .describe(
-        'Optional: control which fields to include from populated relationship or upload documents.',
-      )
-      .optional(),
-    select: z
-      .record(z.string(), z.unknown())
-      .describe(
-        'Optional: define exactly which fields you\'d like to return in the response, e.g., {"version.siteName": true}',
-      )
-      .optional(),
-    showHiddenFields: z
-      .boolean()
-      .describe('Optional: include hidden fields in returned global version documents')
-      .optional(),
-    sort: z
-      .string()
-      .describe('Field to sort by (e.g., "-updatedAt", "-version.updatedAt" for descending)')
-      .optional(),
-    where: whereSchema
-      .describe(
-        'Optional: where clause for filtering versions. Version document fields are usually under "version". Example: {"version.siteName":{"contains":"test"}}',
-      )
-      .optional(),
-  }),
-}).handler(async ({ authorizedMCP, globalSlug, input, req }) => {
+  input: findGlobalVersionsInputSchema,
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
   const payload = req.payload
   const logger = getLogger({ payload })
-  const {
-    depth,
-    fallbackLocale,
-    limit,
-    locale,
-    page,
-    pagination,
-    populate,
-    select,
-    showHiddenFields,
-    sort,
-    where,
-  } = input
+  const { depth, fallbackLocale, limit, locale, page, pagination, populate, select, sort, where } =
+    input
 
-  logger.info(`Finding versions for global: ${globalSlug}, limit: ${limit}, page: ${page}`)
+  logger.info(`Finding versions for global: ${slug}, limit: ${limit}, page: ${page}`)
 
   try {
     const result = await payload.findGlobalVersions({
-      slug: globalSlug,
+      slug,
       depth,
       limit,
+      overrideAccess: authorizedMCP.overrideAccess,
       page,
       req,
-      ...localAPIDefaults(authorizedMCP),
-      ...(fallbackLocale ? { fallbackLocale } : {}),
+      ...(fallbackLocale !== undefined ? { fallbackLocale } : {}),
       ...(locale ? { locale } : {}),
       ...(pagination !== undefined ? { pagination } : {}),
-      ...(populate ? { populate: populate as PopulateType } : {}),
-      ...(select ? { select: select as SelectType } : {}),
-      ...(showHiddenFields !== undefined ? { showHiddenFields } : {}),
+      ...(populate ? { populate } : {}),
+      ...(select ? { select } : {}),
       ...(sort ? { sort } : {}),
       ...(where ? { where } : {}),
     })
@@ -127,19 +48,19 @@ export const findGlobalVersionsTool = defineGlobalTool({
       content: [
         {
           type: 'text',
-          text: `Versions for global "${globalSlug}":\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
+          text: `Versions for global "${slug}":\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
         },
       ],
       doc: result as unknown as Record<string, unknown>,
     }
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : 'Unknown error'
-    logger.error(`Error finding versions for global ${globalSlug}: ${errorMessage}`)
+    logger.error(`Error finding versions for global ${slug}: ${errorMessage}`)
     return {
       content: [
         {
           type: 'text',
-          text: `❌ **Error finding versions for global "${globalSlug}":** ${errorMessage}`,
+          text: `❌ **Error finding versions for global "${slug}":** ${errorMessage}`,
         },
       ],
       isError: true,