@payloadcms/plugin-mcp 4.0.0-internal.5b1e7cd → 4.0.0-internal.5e065b3

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

@@ -0,0 +1,91 @@
+import { getAccessResults, getCollectionInputSchema, getCollectionSchemaInputSchema } from 'payload'
+import { getLLMInstructions } from 'payload/internal'
+
+import { defaultAccess } from '../../../defaultAccess.js'
+import { defineCollectionTool } from '../../../defineTool.js'
+
+export const getCollectionSchemaTool = defineCollectionTool({
+  access: (args) => {
+    const permissions = args.permissions?.collections?.[args.slug]
+
+    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 and LLM instructions before creating or updating documents in a collection.',
+  input: getCollectionSchemaInputSchema,
+}).handler(async ({ slug, authorizedMCP, req }) => {
+  const permissions = authorizedMCP.overrideAccess
+    ? null
+    : (await getAccessResults({ req })).collections?.[slug]
+
+  if (!authorizedMCP.overrideAccess && !permissions?.create && !permissions?.update) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Error: MCP access to "getCollectionSchema" is not enabled for collection "${slug}"`,
+        },
+      ],
+      isError: true,
+    }
+  }
+
+  const inputSchema = getCollectionInputSchema({
+    collectionSlug: slug,
+    req,
+    ...(permissions ? { permissions } : {}),
+  })
+
+  if (!inputSchema) {
+    return {
+      content: [{ type: 'text', text: `Error: Collection "${slug}" not found` }],
+      isError: true,
+    }
+  }
+
+  const uploadConfig = req.payload.collections[slug]?.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 ? ['externalURL'] : []),
+          'base64',
+          'uploadReference',
+        ],
+        ...(typeof maxFileSize === 'number' && Number.isFinite(maxFileSize) ? { maxFileSize } : {}),
+      }
+    : { enabled: false }
+
+  const instructions = await getLLMInstructions({
+    slug,
+    type: 'collection',
+    overrideAccess: authorizedMCP.overrideAccess,
+    req,
+  })
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: `Schema for collection "${slug}":\n\`\`\`json\n${JSON.stringify(inputSchema)}\n\`\`\`\nUpload configuration:\n\`\`\`json\n${JSON.stringify(upload)}\n\`\`\``,
+      },
+      ...(instructions ? [{ type: 'text' as const, text: instructions }] : []),
+    ],
+    structuredContent: {
+      slug,
+      schema: inputSchema,
+      upload,
+      ...(instructions ? { instructions } : {}),
+    },
+  }
+})

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

@@ -0,0 +1,65 @@
+import { restoreVersionInputSchema } from 'payload'
+
+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.slug]?.update),
+  annotations: {
+    destructiveHint: true,
+    idempotentHint: false,
+    openWorldHint: false,
+    readOnlyHint: false,
+    title: 'Restore Version',
+  },
+  description: DEFAULT_DESCRIPTION,
+  input: restoreVersionInputSchema,
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
+  const payload = req.payload
+  const logger = getLogger({ payload })
+  const { id, depth, draft, fallbackLocale, locale, populate, select } = input
+
+  logger.info(`Restoring version in collection: ${slug} with ID: ${id}`)
+
+  try {
+    const result = await payload.restoreVersion({
+      id: String(id),
+      collection: slug,
+      depth,
+      draft,
+      overrideAccess: authorizedMCP.overrideAccess,
+      req,
+      ...(fallbackLocale !== undefined ? { fallbackLocale } : {}),
+      ...(locale ? { locale } : {}),
+      ...(populate ? { populate } : {}),
+      ...(select ? { select } : {}),
+    })
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Version "${id}" restored successfully in collection "${slug}"!\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 ${slug}: ${errorMessage}`)
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `❌ **Error restoring version "${id}" in collection "${slug}":** ${errorMessage}`,
+        },
+      ],
+      isError: true,
+    }
+  }
+})

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

@@ -0,0 +1,173 @@
+import type { Where } from 'payload'
+
+import {
+  getCollectionInputSchema,
+  getCollectionVirtualFieldNames,
+  parseDocumentID,
+  stripVirtualFields,
+  transformPointDataToPayload,
+  updateDocumentInputSchema,
+  validateCollectionData,
+} from 'payload'
+
+import { defaultAccess } from '../../../defaultAccess.js'
+import { defineCollectionTool } from '../../../defineTool.js'
+import { getLogger } from '../../../utils/getLogger.js'
+import { formatEntityError } from '../formatEntityError.js'
+import { fileInputSchema, resolveFile } from './fileInput.js'
+
+const DEFAULT_DESCRIPTION =
+  'Update documents. Prefer uploadReference after upload, externalURL for URLs, or base64 for small local files.'
+
+export const updateDocumentTool = defineCollectionTool({
+  access: (args) =>
+    defaultAccess(args) && Boolean(args.permissions?.collections?.[args.slug]?.update),
+  annotations: {
+    destructiveHint: true,
+    idempotentHint: false,
+    openWorldHint: false,
+    readOnlyHint: false,
+    title: 'Update Document',
+  },
+  description: DEFAULT_DESCRIPTION,
+  input: updateDocumentInputSchema({ file: fileInputSchema }),
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
+  const payload = req.payload
+  const logger = getLogger({ payload })
+
+  const {
+    id,
+    data,
+    depth,
+    draft,
+    fallbackLocale,
+    file: fileInput,
+    limit,
+    locale,
+    overrideLock,
+    populate,
+    publishAllLocales,
+    returning,
+    select,
+    sort,
+    trash,
+    unpublishAllLocales,
+    where,
+  } = input
+
+  logger.info(
+    `Updating document in collection: ${slug}${id ? ` with ID: ${id}` : ' with where clause'}, draft: ${draft}${locale ? `, locale: ${locale}` : ''}`,
+  )
+
+  try {
+    const virtualFieldNames = getCollectionVirtualFieldNames(payload.config, slug)
+    const inputData = stripVirtualFields(data, virtualFieldNames)
+    validateCollectionData({
+      slug,
+      data: inputData,
+      partial: true,
+      req,
+    })
+
+    const parsedData = transformPointDataToPayload(inputData)
+    const file = await resolveFile({ slug, input: fileInput, req })
+
+    const whereClause: Where = where ?? {}
+
+    if (id !== undefined) {
+      const result = await payload.update({
+        id: parseDocumentID({ id, collectionSlug: slug, payload }),
+        collection: slug,
+        data: parsedData,
+        depth,
+        draft,
+        fallbackLocale,
+        locale,
+        overrideAccess: authorizedMCP.overrideAccess,
+        overrideLock,
+        populate,
+        publishAllLocales,
+        req,
+        select: returning ? select : { id: true },
+        trash,
+        unpublishAllLocales,
+        ...(file ? { file } : {}),
+      })
+
+      const responseResult = returning ? result : { id: result.id }
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `Document updated successfully in collection "${slug}"!\nResult:\n\`\`\`json\n${JSON.stringify(responseResult)}\n\`\`\``,
+          },
+        ],
+        doc: responseResult as Record<string, unknown>,
+      }
+    }
+
+    const result = await payload.update({
+      collection: slug,
+      data: parsedData,
+      depth,
+      draft,
+      fallbackLocale,
+      limit,
+      locale,
+      overrideAccess: authorizedMCP.overrideAccess,
+      overrideLock,
+      populate,
+      publishAllLocales,
+      req,
+      select: returning ? select : { id: true },
+      sort,
+      trash,
+      unpublishAllLocales,
+      where: whereClause,
+      ...(file ? { file } : {}),
+    })
+
+    const docs = returning ? result.docs : result.docs.map(({ id }) => ({ id }))
+    const errors = result.errors || []
+
+    let responseText = `Multiple documents updated in collection "${slug}"!\nUpdated: ${docs.length} documents\nErrors: ${errors.length}\n---`
+    if (docs.length > 0) {
+      responseText += `\n\nUpdated documents:\n\`\`\`json\n${JSON.stringify(docs)}\n\`\`\``
+    }
+    if (errors.length > 0) {
+      responseText += `\n\nErrors:\n\`\`\`json\n${JSON.stringify(errors)}\n\`\`\``
+
+      const errorSchema = getCollectionInputSchema({ collectionSlug: slug, 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: {
+                slug,
+                docs,
+                errors,
+                schema: errorSchema,
+              },
+            }
+          : {}),
+      }
+    }
+
+    return {
+      content: [{ type: 'text', text: responseText }],
+      doc: { docs, errors } as unknown as Record<string, unknown>,
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+    logger.error(`Error updating document in ${slug}: ${errorMessage}`)
+    return formatEntityError({ slug, action: 'updating', entity: 'collection', error, req })
+  }
+})

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

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

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

@@ -0,0 +1,66 @@
+import { findGlobalInputSchema } from 'payload'
+
+import { defaultAccess } from '../../../defaultAccess.js'
+import { defineGlobalTool } from '../../../defineTool.js'
+import { getLogger } from '../../../utils/getLogger.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.slug]?.read),
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+    readOnlyHint: true,
+    title: 'Find Global',
+  },
+  description: DEFAULT_DESCRIPTION,
+  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: ${slug}, depth: ${depth}${locale ? `, locale: ${locale}` : ''}`)
+
+  try {
+    const findOptions: Parameters<typeof payload.findGlobal>[0] = {
+      slug,
+      depth,
+      overrideAccess: authorizedMCP.overrideAccess,
+      req,
+    }
+
+    if (locale) {
+      findOptions.locale = locale
+    }
+    if (fallbackLocale !== undefined) {
+      findOptions.fallbackLocale = fallbackLocale
+    }
+    if (select) {
+      findOptions.select = select
+    }
+    if (populate) {
+      findOptions.populate = populate
+    }
+    const result = await payload.findGlobal(findOptions)
+
+    return {
+      content: [
+        {
+          type: 'text',
+          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 ${slug}: ${errorMessage}`)
+    return {
+      content: [{ type: 'text', text: `❌ **Error reading global "${slug}":** ${errorMessage}` }],
+    }
+  }
+})