@payloadcms/plugin-mcp 4.0.0-internal.a0ef1b8 → 4.0.0-internal.add4c47

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

@@ -1,83 +1,93 @@
-import type { SelectType } from 'payload'
+import type { SelectType, Where } from 'payload'
 
 import { z } from 'zod'
 
+import { defaultAccess } from '../../../defaultAccess.js'
 import { defineCollectionTool } from '../../../defineTool.js'
 import { getLogger } from '../../../utils/getLogger.js'
 import {
   getCollectionVirtualFieldNames,
   stripVirtualFields,
 } from '../../../utils/getVirtualFieldNames.js'
-import { localAPIDefaults } from '../../../utils/localAPIDefaults.js'
-import { buildToolInput } from '../../../utils/schemaConversion/buildToolInput.js'
-import { sanitizeEntitySchema } from '../../../utils/schemaConversion/sanitizeEntitySchema.js'
+import { getCollectionInputSchema } from '../../../utils/schemaConversion/getEntityInputSchema.js'
 import { transformPointDataToPayload } from '../../../utils/transformPointDataToPayload.js'
-
-const DEFAULT_DESCRIPTION = 'Update documents in a collection by ID or where clause.'
-
-export const updateCollectionTool = defineCollectionTool({
-  description: DEFAULT_DESCRIPTION,
-  input: ({ collectionSchema }) => {
-    const partialSchema = sanitizeEntitySchema(collectionSchema)
-
-    // Collection updates do not require all required fields to be passed => delete .required.
-    //
-    // Local API equivalent: packages/payload/src/collections/operations/local/update.ts#BaseOptions#data:
-    // data: DeepPartial<RequiredDataFromCollectionSlug<TSlug>>
-    delete partialSchema.required
-
-    return buildToolInput({
-      controls: {
-        id: z
-          .union([z.string(), z.number()])
-          .describe('The ID of the document to update')
-          .optional(),
-        depth: z
-          .number()
-          .describe('How many levels deep to populate relationships')
-          .optional()
-          .default(0),
-        draft: z
-          .boolean()
-          .describe('Whether to update the document as a draft')
-          .optional()
-          .default(false),
-        fallbackLocale: z
-          .string()
-          .describe('Optional: fallback locale code to use when requested locale is not available')
-          .optional(),
-        filePath: z.string().describe('File path for file uploads').optional(),
-        locale: z
-          .string()
-          .describe(
-            'Optional: locale code to update the document in (e.g., "en", "es"). Defaults to the default locale',
-          )
-          .optional(),
-        overrideLock: z
-          .boolean()
-          .describe('Whether to override document locks')
-          .optional()
-          .default(true),
-        overwriteExistingFiles: z
-          .boolean()
-          .describe('Whether to overwrite existing files')
-          .optional()
-          .default(false),
-        select: z
-          .string()
-          .describe(
-            'Optional: define exactly which fields you\'d like to return in the response (JSON), e.g., \'{"title": "My Post"}\'',
-          )
-          .optional(),
-        where: z
-          .string()
-          .describe('JSON string for where clause to update multiple documents')
-          .optional(),
-      },
-      dataDescription: 'The fields to update',
-      dataSchema: partialSchema,
-    })
+import { whereSchema } from '../../../utils/whereSchema.js'
+import { validateCollectionData } from '../validateEntityData.js'
+import { fileInputSchema, resolveFile } from './fileInput.js'
+import { formatCollectionError } from './formatCollectionError.js'
+
+const DEFAULT_DESCRIPTION =
+  'Update documents in any collection. Files can use a URL, base64, or an upload prepared by getUploadInstructions.'
+
+export const updateDocumentTool = defineCollectionTool({
+  access: (args) =>
+    defaultAccess(args) && Boolean(args.permissions?.collections?.[args.collectionSlug]?.update),
+  annotations: {
+    destructiveHint: true,
+    idempotentHint: false,
+    openWorldHint: false,
+    readOnlyHint: false,
+    title: 'Update Document',
   },
+  description: DEFAULT_DESCRIPTION,
+  input: z.object({
+    id: z.union([z.string(), z.number()]).describe('The ID of the document to update').optional(),
+    data: z
+      .record(z.string(), z.unknown())
+      .describe(
+        'The fields to update. Only include fields permitted by the schema returned by getCollectionSchema.',
+      ),
+    depth: z
+      .number()
+      .describe('How many levels deep to populate relationships')
+      .optional()
+      .default(0),
+    draft: z
+      .boolean()
+      .describe(
+        'Only if getCollectionSchema includes _status; otherwise _status does not exist. true saves only a draft version; false updates main and versions. data._status: "published" overrides true.',
+      )
+      .optional()
+      .default(false),
+    fallbackLocale: z
+      .string()
+      .describe('Optional: fallback locale code to use when requested locale is not available')
+      .optional(),
+    file: fileInputSchema.optional(),
+    locale: z
+      .string()
+      .describe(
+        'Optional: locale code to update the document in (e.g., "en", "es"). Defaults to the default locale',
+      )
+      .optional(),
+    overrideLock: z
+      .boolean()
+      .describe('Whether to override document locks')
+      .optional()
+      .default(true),
+    overwriteExistingFiles: z
+      .boolean()
+      .describe('Whether to overwrite existing files')
+      .optional()
+      .default(false),
+    publishAllLocales: z
+      .boolean()
+      .describe(
+        'For collections with localized publishing status, whether publishing should affect every locale. Set false with locale to publish only that locale.',
+      )
+      .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(),
+    where: whereSchema
+      .describe(
+        'Where clause to update multiple documents. Use field names with Payload operators, and/or arrays for grouping. Example: {"title":{"contains":"test"}}',
+      )
+      .optional(),
+  }),
 }).handler(async ({ authorizedMCP, collectionSlug, input, req }) => {
   const payload = req.payload
   const logger = getLogger({ payload })
@@ -88,10 +98,11 @@ export const updateCollectionTool = defineCollectionTool({
     depth,
     draft,
     fallbackLocale,
-    filePath,
+    file: fileInput,
     locale,
     overrideLock,
     overwriteExistingFiles,
+    publishAllLocales,
     select,
     where,
   } = input
@@ -107,48 +118,41 @@ export const updateCollectionTool = defineCollectionTool({
       }
     }
 
-    let parsedData = transformPointDataToPayload(data)
     const virtualFieldNames = getCollectionVirtualFieldNames(payload.config, collectionSlug)
-    parsedData = stripVirtualFields(parsedData, virtualFieldNames)
-
-    let whereClause: Record<string, unknown> = {}
-    if (where) {
-      try {
-        whereClause = JSON.parse(where) as Record<string, unknown>
-      } catch {
-        logger.error(`Invalid where clause JSON: ${where}`)
-        return { content: [{ type: 'text', text: 'Error: Invalid JSON in where clause' }] }
-      }
-    }
+    const inputData = stripVirtualFields(data, virtualFieldNames)
+    const validationError = validateCollectionData({
+      collectionSlug,
+      data: inputData,
+      partial: true,
+      req,
+    })
 
-    let selectClause: SelectType | undefined
-    if (select) {
-      try {
-        selectClause = JSON.parse(select) as SelectType
-      } catch {
-        logger.warn(`Invalid select clause JSON: ${select}`)
-        return { content: [{ type: 'text', text: 'Error: Invalid JSON in select clause' }] }
-      }
+    if (validationError) {
+      return validationError
     }
 
+    const parsedData = transformPointDataToPayload(inputData)
+    const file = await resolveFile({ collectionSlug, input: fileInput, req })
+
+    const whereClause: Where = where ?? {}
+
     if (id) {
-      const updateOptions = {
+      const result = await payload.update({
         id,
         collection: collectionSlug,
         data: parsedData,
         depth,
         draft,
+        overrideAccess: authorizedMCP.overrideAccess,
         overrideLock,
         req,
-        ...localAPIDefaults(authorizedMCP),
-        ...(filePath ? { filePath } : {}),
+        ...(file ? { file } : {}),
         ...(overwriteExistingFiles ? { overwriteExistingFiles } : {}),
+        ...(publishAllLocales !== undefined ? { publishAllLocales } : {}),
         ...(locale ? { locale } : {}),
         ...(fallbackLocale ? { fallbackLocale } : {}),
-        ...(selectClause ? { select: selectClause } : {}),
-      }
-
-      const result = await payload.update(updateOptions as any)
+        ...(select ? { select: select as SelectType } : {}),
+      })
 
       return {
         content: [
@@ -161,27 +165,25 @@ export const updateCollectionTool = defineCollectionTool({
       }
     }
 
-    const updateOptions = {
+    const result = await payload.update({
       collection: collectionSlug,
       data: parsedData,
       depth,
       draft,
+      overrideAccess: authorizedMCP.overrideAccess,
       overrideLock,
       req,
-      ...localAPIDefaults(authorizedMCP),
       where: whereClause,
-      ...(filePath ? { filePath } : {}),
+      ...(file ? { file } : {}),
       ...(overwriteExistingFiles ? { overwriteExistingFiles } : {}),
+      ...(publishAllLocales !== undefined ? { publishAllLocales } : {}),
       ...(locale ? { locale } : {}),
       ...(fallbackLocale ? { fallbackLocale } : {}),
-      ...(selectClause ? { select: selectClause } : {}),
-    }
-
-    const result = await payload.update(updateOptions as any)
+      ...(select ? { select: select as SelectType } : {}),
+    })
 
-    const bulkResult = result as { docs?: unknown[]; errors?: unknown[] }
-    const docs = bulkResult.docs || []
-    const errors = bulkResult.errors || []
+    const docs = result.docs || []
+    const errors = result.errors || []
 
     let responseText = `Multiple documents updated in collection "${collectionSlug}"!\nUpdated: ${docs.length} documents\nErrors: ${errors.length}\n---`
     if (docs.length > 0) {
@@ -189,6 +191,28 @@ export const updateCollectionTool = defineCollectionTool({
     }
     if (errors.length > 0) {
       responseText += `\n\nErrors:\n\`\`\`json\n${JSON.stringify(errors)}\n\`\`\``
+
+      const errorSchema = getCollectionInputSchema({ collectionSlug, req })
+
+      if (errorSchema) {
+        responseText += `\n\nUse this schema for data:\n\`\`\`json\n${JSON.stringify(errorSchema)}\n\`\`\``
+      }
+
+      return {
+        content: [{ type: 'text', text: responseText }],
+        doc: { docs, errors } as unknown as Record<string, unknown>,
+        isError: true,
+        ...(errorSchema
+          ? {
+              structuredContent: {
+                collectionSlug,
+                docs,
+                errors,
+                schema: errorSchema,
+              },
+            }
+          : {}),
+      }
     }
 
     return {
@@ -198,13 +222,6 @@ export const updateCollectionTool = defineCollectionTool({
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : 'Unknown error'
     logger.error(`Error updating document in ${collectionSlug}: ${errorMessage}`)
-    return {
-      content: [
-        {
-          type: 'text',
-          text: `Error updating document in collection "${collectionSlug}": ${errorMessage}`,
-        },
-      ],
-    }
+    return formatCollectionError({ action: 'updating', collectionSlug, error, req })
   }
 })

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

@@ -0,0 +1,64 @@
+import { getUploadInstructions as getPayloadUploadInstructions } from 'payload/internal'
+import { z } from 'zod'
+
+import { defaultAccess } from '../../../defaultAccess.js'
+import { defineCollectionTool } from '../../../defineTool.js'
+
+export const getUploadInstructionsTool = defineCollectionTool({
+  access: (args) =>
+    defaultAccess(args) &&
+    Boolean(
+      args.permissions?.collections?.[args.collectionSlug]?.create ||
+        args.permissions?.collections?.[args.collectionSlug]?.update,
+    ),
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true,
+    readOnlyHint: false,
+    title: 'Get Upload Instructions',
+  },
+  description:
+    'Prepare a file upload before createDocument or updateDocument. Pass file metadata only, without base64 or file contents.',
+  input: z.object({
+    docPrefix: z.string().describe('Optional document folder or prefix').optional(),
+    filename: z.string().describe('The original file name'),
+    filesize: z.number().int().nonnegative().describe('The file size in bytes'),
+    mimeType: z.string().describe('The file MIME type'),
+  }),
+}).handler(async ({ authorizedMCP, collectionSlug, input, req }) => {
+  try {
+    const instructions = await getPayloadUploadInstructions({
+      ...input,
+      collectionSlug,
+      overrideAccess: authorizedMCP.overrideAccess,
+      req,
+    })
+
+    const nextStep =
+      instructions.type === 'http'
+        ? 'Send the exact file bytes using request, then pass { source: "uploadReference", file } to createDocument or updateDocument.'
+        : `Call the local MCP tool named "${instructions.name}" with the file and data, then pass { source: "uploadReference", file } to createDocument or updateDocument.`
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Upload instructions for collection "${collectionSlug}":\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 "${collectionSlug}": ${message}`,
+        },
+      ],
+      isError: true,
+    }
+  }
+})

package/src/mcp/builtin/getConfigInfoTool.ts

@@ -0,0 +1,67 @@
+import { getAccessResults, isEntityHidden } from 'payload'
+
+import { defineTool } from '../../defineTool.js'
+
+export const getConfigInfoTool = defineTool({
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+    readOnlyHint: true,
+    title: 'Config Info',
+  },
+  description: 'List the Payload collection and global slugs visible to this MCP client.',
+}).handler(async ({ authorizedMCP, req }) => {
+  const user = req.user
+  const permissions = authorizedMCP.overrideAccess ? null : await getAccessResults({ req })
+  const authorizedCollectionSlugs = new Set<string>()
+  const authorizedGlobalSlugs = new Set<string>()
+
+  for (const item of authorizedMCP.items) {
+    if (item.type === 'collectionTool') {
+      authorizedCollectionSlugs.add(item.collectionSlug)
+    } else if (item.type === 'globalTool') {
+      authorizedGlobalSlugs.add(item.globalSlug)
+    }
+  }
+
+  const collections: string[] = []
+  const globals: string[] = []
+
+  for (const collection of req.payload.config.collections) {
+    if (!authorizedCollectionSlugs.has(collection.slug)) {
+      continue
+    }
+    if (user && isEntityHidden({ hidden: collection.admin.hidden, user })) {
+      continue
+    }
+    if (!authorizedMCP.overrideAccess && !permissions?.collections?.[collection.slug]?.read) {
+      continue
+    }
+
+    collections.push(collection.slug)
+  }
+
+  for (const global of req.payload.config.globals) {
+    if (!authorizedGlobalSlugs.has(global.slug)) {
+      continue
+    }
+    if (user && isEntityHidden({ hidden: global.admin.hidden, user })) {
+      continue
+    }
+    if (!authorizedMCP.overrideAccess && !permissions?.globals?.[global.slug]?.read) {
+      continue
+    }
+
+    globals.push(global.slug)
+  }
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: `Collections: ${collections.join(', ') || 'none'}\nGlobals: ${globals.join(', ') || 'none'}`,
+      },
+    ],
+  }
+})

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

@@ -0,0 +1,68 @@
+import { z } from 'zod'
+
+import { defaultAccess } from '../../../defaultAccess.js'
+import { defineGlobalTool } from '../../../defineTool.js'
+import { getLogger } from '../../../utils/getLogger.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),
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+    readOnlyHint: true,
+    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 }) => {
+  const payload = req.payload
+  const logger = getLogger({ payload })
+  const { locale, where } = input
+
+  logger.info(`Counting versions for global: ${globalSlug}`)
+
+  try {
+    const result = await payload.countGlobalVersions({
+      global: globalSlug,
+      overrideAccess: authorizedMCP.overrideAccess,
+      req,
+      ...(locale ? { locale } : {}),
+      ...(where ? { where } : {}),
+    })
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Global "${globalSlug}" 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}`)
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `❌ **Error counting versions for global "${globalSlug}":** ${errorMessage}`,
+        },
+      ],
+      isError: true,
+    }
+  }
+})

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

@@ -1,14 +1,23 @@
-import type { SelectType } from 'payload'
+import type { PopulateType, SelectType } from 'payload'
 
 import { z } from 'zod'
 
+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 Payload global singleton configuration.'
+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),
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+    readOnlyHint: true,
+    title: 'Find Global',
+  },
   description: DEFAULT_DESCRIPTION,
   input: z.object({
     depth: z
@@ -29,10 +38,16 @@ export const findGlobalTool = defineGlobalTool({
         '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
-      .string()
+      .record(z.string(), z.unknown())
       .describe(
-        "Optional: define exactly which fields you'd like to return in the response (JSON), e.g., '{\"title\": true}'",
+        'Optional: define exactly which fields you\'d like to return in the response, e.g., {"title": true}',
       )
       .optional(),
   }),
@@ -40,7 +55,7 @@ export const findGlobalTool = defineGlobalTool({
   const payload = req.payload
   const logger = getLogger({ payload })
 
-  const { depth, fallbackLocale, locale, select } = input
+  const { depth, fallbackLocale, locale, populate, select } = input
 
   logger.info(
     `Reading global: ${globalSlug}, depth: ${depth}${locale ? `, locale: ${locale}` : ''}`,
@@ -50,17 +65,8 @@ export const findGlobalTool = defineGlobalTool({
     const findOptions: Parameters<typeof payload.findGlobal>[0] = {
       slug: globalSlug,
       depth,
-      ...localAPIDefaults(authorizedMCP),
-    }
-
-    let selectClause: SelectType | undefined
-    if (select) {
-      try {
-        selectClause = JSON.parse(select) as SelectType
-      } catch {
-        logger.warn(`Invalid select clause JSON for global: ${select}`)
-        return { content: [{ type: 'text', text: 'Error: Invalid JSON in select clause' }] }
-      }
+      overrideAccess: authorizedMCP.overrideAccess,
+      req,
     }
 
     if (locale) {
@@ -69,8 +75,11 @@ export const findGlobalTool = defineGlobalTool({
     if (fallbackLocale) {
       findOptions.fallbackLocale = fallbackLocale
     }
-    if (selectClause) {
-      findOptions.select = selectClause
+    if (select) {
+      findOptions.select = select as SelectType
+    }
+    if (populate) {
+      findOptions.populate = populate as PopulateType
     }
 
     const result = await payload.findGlobal(findOptions)