@payloadcms/plugin-mcp 4.0.0-canary.1 → 4.0.0-canary.11

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

@@ -0,0 +1,109 @@
+import type { PopulateType, SelectType } from 'payload'
+
+import { z } from 'zod'
+
+import { defaultAccess } from '../../../defaultAccess.js'
+import { defineCollectionTool } from '../../../defineTool.js'
+import { getLogger } from '../../../utils/getLogger.js'
+
+const DEFAULT_DESCRIPTION =
+  'Find a specific document version in any version-enabled collection by passing the collection slug and version ID.'
+
+export const findVersionByIDTool = defineCollectionTool({
+  access: (args) =>
+    defaultAccess(args) &&
+    Boolean(args.permissions?.collections?.[args.collectionSlug]?.readVersions),
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+    readOnlyHint: true,
+    title: 'Find Version By ID',
+  },
+  description: DEFAULT_DESCRIPTION,
+  input: z.object({
+    id: z.string().describe('The ID of the version to retrieve'),
+    depth: z
+      .number()
+      .int()
+      .min(0)
+      .max(10)
+      .describe('How many levels deep to populate relationships in the 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.title": true}',
+      )
+      .optional(),
+    showHiddenFields: z
+      .boolean()
+      .describe('Optional: include hidden fields in the returned version document')
+      .optional(),
+    trash: z
+      .boolean()
+      .describe('Optional: include soft-deleted version documents when trash is enabled')
+      .optional(),
+  }),
+}).handler(async ({ authorizedMCP, collectionSlug, input, req }) => {
+  const payload = req.payload
+  const logger = getLogger({ payload })
+  const { id, depth, fallbackLocale, locale, populate, select, showHiddenFields, trash } = input
+
+  logger.info(`Finding version in collection: ${collectionSlug} with ID: ${id}`)
+
+  try {
+    const result = await payload.findVersionByID({
+      id,
+      collection: collectionSlug,
+      depth,
+      overrideAccess: authorizedMCP.overrideAccess,
+      req,
+      ...(fallbackLocale ? { fallbackLocale } : {}),
+      ...(locale ? { locale } : {}),
+      ...(populate ? { populate: populate as PopulateType } : {}),
+      ...(select ? { select: select as SelectType } : {}),
+      ...(showHiddenFields !== undefined ? { showHiddenFields } : {}),
+      ...(trash !== undefined ? { trash } : {}),
+    })
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Version "${id}" from collection "${collectionSlug}":\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} in ${collectionSlug}: ${errorMessage}`)
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `❌ **Error finding version "${id}" in collection "${collectionSlug}":** ${errorMessage}`,
+        },
+      ],
+      isError: true,
+    }
+  }
+})

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

@@ -0,0 +1,154 @@
+import type { PopulateType, SelectType } from 'payload'
+
+import { z } from 'zod'
+
+import { defaultAccess } from '../../../defaultAccess.js'
+import { defineCollectionTool } from '../../../defineTool.js'
+import { getLogger } from '../../../utils/getLogger.js'
+import { whereSchema } from '../../../utils/whereSchema.js'
+
+const DEFAULT_DESCRIPTION =
+  'Find document versions in any version-enabled collection by passing the collection slug and optional where clause.'
+
+export const findVersionsTool = defineCollectionTool({
+  access: (args) =>
+    defaultAccess(args) &&
+    Boolean(args.permissions?.collections?.[args.collectionSlug]?.readVersions),
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+    readOnlyHint: true,
+    title: 'Find Versions',
+  },
+  description: DEFAULT_DESCRIPTION,
+  input: z.object({
+    depth: z
+      .number()
+      .int()
+      .min(0)
+      .max(10)
+      .describe('How many levels deep to populate relationships in 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.title": true}',
+      )
+      .optional(),
+    showHiddenFields: z
+      .boolean()
+      .describe('Optional: include hidden fields in returned version documents')
+      .optional(),
+    sort: z
+      .string()
+      .describe('Field to sort by (e.g., "-updatedAt", "-version.updatedAt" for descending)')
+      .optional(),
+    trash: z
+      .boolean()
+      .describe('Optional: include versions for soft-deleted documents when trash is enabled')
+      .optional(),
+    where: whereSchema
+      .describe(
+        'Optional: where clause for filtering versions. Version document fields are usually under "version". Example: {"version.title":{"contains":"test"}}',
+      )
+      .optional(),
+  }),
+}).handler(async ({ authorizedMCP, collectionSlug, input, req }) => {
+  const payload = req.payload
+  const logger = getLogger({ payload })
+  const {
+    depth,
+    fallbackLocale,
+    limit,
+    locale,
+    page,
+    pagination,
+    populate,
+    select,
+    showHiddenFields,
+    sort,
+    trash,
+    where,
+  } = input
+
+  logger.info(`Finding versions in collection: ${collectionSlug}, limit: ${limit}, page: ${page}`)
+
+  try {
+    const result = await payload.findVersions({
+      collection: collectionSlug,
+      depth,
+      limit,
+      overrideAccess: authorizedMCP.overrideAccess,
+      page,
+      req,
+      ...(fallbackLocale ? { fallbackLocale } : {}),
+      ...(locale ? { locale } : {}),
+      ...(pagination !== undefined ? { pagination } : {}),
+      ...(populate ? { populate: populate as PopulateType } : {}),
+      ...(select ? { select: select as SelectType } : {}),
+      ...(showHiddenFields !== undefined ? { showHiddenFields } : {}),
+      ...(sort ? { sort } : {}),
+      ...(trash !== undefined ? { trash } : {}),
+      ...(where ? { where } : {}),
+    })
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Versions for collection "${collectionSlug}":\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 in ${collectionSlug}: ${errorMessage}`)
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `❌ **Error finding versions in collection "${collectionSlug}":** ${errorMessage}`,
+        },
+      ],
+      isError: true,
+    }
+  }
+})

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

@@ -38,7 +38,7 @@ export const formatCollectionError = ({
   error,
   req,
 }: {
-  action: 'creating' | 'updating'
+  action: 'creating' | 'duplicating' | 'updating'
   collectionSlug: CollectionSlug
   error: unknown
   req: PayloadRequest

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

@@ -1,10 +1,45 @@
+import { getAccessResults } from 'payload'
+
+import { defaultAccess } from '../../../defaultAccess.js'
 import { defineCollectionTool } from '../../../defineTool.js'
 import { getCollectionInputSchema } from '../../../utils/schemaConversion/getEntityInputSchema.js'
 
 export const getCollectionSchemaTool = defineCollectionTool({
+  access: (args) => {
+    const permissions = args.permissions?.collections?.[args.collectionSlug]
+
+    return defaultAccess(args) && Boolean(permissions?.create || permissions?.update)
+  },
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+    readOnlyHint: true,
+    title: 'Get Collection Schema',
+  },
   description: 'Get the input schema for creating or updating documents in a collection.',
-}).handler(({ collectionSlug, req }) => {
-  const inputSchema = getCollectionInputSchema({ collectionSlug, req })
+}).handler(async ({ authorizedMCP, collectionSlug, req }) => {
+  const permissions = authorizedMCP.overrideAccess
+    ? null
+    : (await getAccessResults({ req })).collections?.[collectionSlug]
+
+  if (!authorizedMCP.overrideAccess && !permissions?.create && !permissions?.update) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Error: MCP access to "getCollectionSchema" is not enabled for collection "${collectionSlug}"`,
+        },
+      ],
+      isError: true,
+    }
+  }
+
+  const inputSchema = getCollectionInputSchema({
+    collectionSlug,
+    req,
+    ...(permissions ? { permissions } : {}),
+  })
 
   if (!inputSchema) {
     return {
@@ -13,16 +48,29 @@ export const getCollectionSchemaTool = defineCollectionTool({
     }
   }
 
+  const uploadConfig = req.payload.collections[collectionSlug]?.config.upload
+  const maxFileSize = req.payload.config.upload.limits?.fileSize
+  const upload = uploadConfig
+    ? {
+        enabled: true,
+        filesRequiredOnCreate: uploadConfig.filesRequiredOnCreate !== false,
+        mimeTypes: uploadConfig.mimeTypes ?? ['*/*'],
+        sources: [...(uploadConfig.pasteURL !== false ? ['url'] : []), 'base64'],
+        ...(typeof maxFileSize === 'number' && Number.isFinite(maxFileSize) ? { maxFileSize } : {}),
+      }
+    : { enabled: false }
+
   return {
     content: [
       {
         type: 'text',
-        text: `Schema for collection "${collectionSlug}":\n\`\`\`json\n${JSON.stringify(inputSchema)}\n\`\`\``,
+        text: `Schema for collection "${collectionSlug}":\n\`\`\`json\n${JSON.stringify(inputSchema)}\n\`\`\`\nUpload configuration:\n\`\`\`json\n${JSON.stringify(upload)}\n\`\`\``,
       },
     ],
     structuredContent: {
       collectionSlug,
       schema: inputSchema,
+      upload,
     },
   }
 })

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

@@ -0,0 +1,107 @@
+import type { PopulateType, SelectType } from 'payload'
+
+import { z } from 'zod'
+
+import { defaultAccess } from '../../../defaultAccess.js'
+import { defineCollectionTool } from '../../../defineTool.js'
+import { getLogger } from '../../../utils/getLogger.js'
+
+const DEFAULT_DESCRIPTION =
+  'Restore a document from a previous version in any version-enabled collection.'
+
+export const restoreVersionTool = defineCollectionTool({
+  access: (args) =>
+    defaultAccess(args) && Boolean(args.permissions?.collections?.[args.collectionSlug]?.update),
+  annotations: {
+    destructiveHint: true,
+    idempotentHint: false,
+    openWorldHint: false,
+    readOnlyHint: false,
+    title: 'Restore Version',
+  },
+  description: DEFAULT_DESCRIPTION,
+  input: z.object({
+    id: z.string().describe('The ID of the version to restore'),
+    depth: z
+      .number()
+      .int()
+      .min(0)
+      .max(10)
+      .describe('How many levels deep to populate relationships in response')
+      .optional()
+      .default(0),
+    draft: z
+      .boolean()
+      .describe('Whether to restore the version as a draft')
+      .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 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(),
+    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(),
+    showHiddenFields: z
+      .boolean()
+      .describe('Optional: include hidden fields in the restored document response')
+      .optional(),
+  }),
+}).handler(async ({ authorizedMCP, collectionSlug, input, req }) => {
+  const payload = req.payload
+  const logger = getLogger({ payload })
+  const { id, depth, draft, fallbackLocale, locale, populate, select, showHiddenFields } = input
+
+  logger.info(`Restoring version in collection: ${collectionSlug} with ID: ${id}`)
+
+  try {
+    const result = await payload.restoreVersion({
+      id,
+      collection: collectionSlug,
+      depth,
+      draft,
+      overrideAccess: authorizedMCP.overrideAccess,
+      req,
+      ...(fallbackLocale ? { fallbackLocale } : {}),
+      ...(locale ? { locale } : {}),
+      ...(populate ? { populate: populate as PopulateType } : {}),
+      ...(select ? { select: select as SelectType } : {}),
+      ...(showHiddenFields !== undefined ? { showHiddenFields } : {}),
+    })
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Version "${id}" restored successfully in collection "${collectionSlug}"!\nRestored document:\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 restoring version ${id} in ${collectionSlug}: ${errorMessage}`)
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `❌ **Error restoring version "${id}" in collection "${collectionSlug}":** ${errorMessage}`,
+        },
+      ],
+      isError: true,
+    }
+  }
+})

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

@@ -2,27 +2,41 @@ 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 { getCollectionInputSchema } from '../../../utils/schemaConversion/getEntityInputSchema.js'
 import { transformPointDataToPayload } from '../../../utils/transformPointDataToPayload.js'
 import { whereSchema } from '../../../utils/whereSchema.js'
 import { validateCollectionData } from '../validateEntityData.js'
+import { fileInputSchema, resolveFileInput } from './fileInput.js'
 import { formatCollectionError } from './formatCollectionError.js'
 
 const DEFAULT_DESCRIPTION =
   'Update documents in any collection by passing the collection slug and data.'
 
 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'),
+    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')
@@ -30,14 +44,16 @@ export const updateDocumentTool = defineCollectionTool({
       .default(0),
     draft: z
       .boolean()
-      .describe('Whether to update the document as a draft')
+      .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(),
-    filePath: z.string().describe('File path for file uploads').optional(),
+    file: fileInputSchema.optional(),
     locale: z
       .string()
       .describe(
@@ -54,10 +70,16 @@ export const updateDocumentTool = defineCollectionTool({
       .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
-      .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(),
     where: whereSchema
@@ -76,10 +98,11 @@ export const updateDocumentTool = defineCollectionTool({
     depth,
     draft,
     fallbackLocale,
-    filePath,
+    file: fileInput,
     locale,
     overrideLock,
     overwriteExistingFiles,
+    publishAllLocales,
     select,
     where,
   } = input
@@ -109,19 +132,10 @@ export const updateDocumentTool = defineCollectionTool({
     }
 
     const parsedData = transformPointDataToPayload(inputData)
+    const file = await resolveFileInput({ collectionSlug, input: fileInput, req })
 
     const whereClause: Where = where ?? {}
 
-    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 (id) {
       const result = await payload.update({
         id,
@@ -129,14 +143,15 @@ export const updateDocumentTool = defineCollectionTool({
         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 } : {}),
+        ...(select ? { select: select as SelectType } : {}),
       })
 
       return {
@@ -155,15 +170,16 @@ export const updateDocumentTool = defineCollectionTool({
       data: parsedData,
       depth,
       draft,
+      overrideAccess: authorizedMCP.overrideAccess,
       overrideLock,
       req,
       where: whereClause,
-      ...localAPIDefaults(authorizedMCP),
-      ...(filePath ? { filePath } : {}),
+      ...(file ? { file } : {}),
       ...(overwriteExistingFiles ? { overwriteExistingFiles } : {}),
+      ...(publishAllLocales !== undefined ? { publishAllLocales } : {}),
       ...(locale ? { locale } : {}),
       ...(fallbackLocale ? { fallbackLocale } : {}),
-      ...(selectClause ? { select: selectClause } : {}),
+      ...(select ? { select: select as SelectType } : {}),
     })
 
     const docs = result.docs || []

package/src/mcp/builtin/getConfigInfoTool.ts

@@ -3,19 +3,39 @@ 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 = authorizedMCP.user ?? req.user ?? null
-  const permissions = user ? await getAccessResults({ req: { ...req, user } }) : null
+  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 (user && !permissions?.collections?.[collection.slug]?.read) {
+    if (!authorizedMCP.overrideAccess && !permissions?.collections?.[collection.slug]?.read) {
       continue
     }
 
@@ -23,10 +43,13 @@ export const getConfigInfoTool = defineTool({
   }
 
   for (const global of req.payload.config.globals) {
+    if (!authorizedGlobalSlugs.has(global.slug)) {
+      continue
+    }
     if (user && isEntityHidden({ hidden: global.admin.hidden, user })) {
       continue
     }
-    if (user && !permissions?.globals?.[global.slug]?.read) {
+    if (!authorizedMCP.overrideAccess && !permissions?.globals?.[global.slug]?.read) {
       continue
     }