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

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

@@ -1,112 +1,145 @@
-import type { SelectType } from 'payload'
-
-import { z } from 'zod'
+import {
+  createDocumentsInputSchema,
+  getCollectionVirtualFieldNames,
+  hasDraftValidationEnabled,
+  stripVirtualFields,
+  transformPointDataToPayload,
+  validateCollectionData,
+} from 'payload'
 
 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 { transformPointDataToPayload } from '../../../utils/transformPointDataToPayload.js'
-import { validateCollectionData } from '../validateEntityData.js'
-import { formatCollectionError } from './formatCollectionError.js'
+import { formatEntityError } from '../formatEntityError.js'
+import { fileInputSchema, resolveFile } from './fileInput.js'
 
 const DEFAULT_DESCRIPTION =
-  'Create a document in any collection by passing the collection slug and data.'
+  'Create one or more documents. Each can have different data or a file. Prefer uploadReference after upload, externalURL for URLs, or base64 for small local files.'
 
-export const createDocumentTool = defineCollectionTool({
+export const createDocumentsTool = defineCollectionTool({
   access: (args) =>
-    defaultAccess(args) && Boolean(args.permissions?.collections?.[args.collectionSlug]?.create),
+    defaultAccess(args) && Boolean(args.permissions?.collections?.[args.slug]?.create),
   annotations: {
     destructiveHint: false,
     idempotentHint: false,
     openWorldHint: false,
     readOnlyHint: false,
-    title: 'Create Document',
+    title: 'Create Documents',
   },
   description: DEFAULT_DESCRIPTION,
-  input: z.object({
-    data: z.record(z.string(), z.unknown()).describe('The document fields to create'),
-    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 create 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(),
-    locale: z
-      .string()
-      .describe(
-        'Optional: locale code to create the document in (e.g., "en", "es"). Defaults to the default locale',
-      )
-      .optional(),
-    select: z
-      .record(z.string(), z.unknown())
-      .describe(
-        'Optional: define exactly which fields you\'d like to return, e.g., {"title": true}',
-      )
-      .optional(),
-  }),
-}).handler(async ({ authorizedMCP, collectionSlug, input, req }) => {
+  input: createDocumentsInputSchema({ file: fileInputSchema }),
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
   const payload = req.payload
+  const collectionConfig = payload.collections[slug]?.config
   const logger = getLogger({ payload })
+  const {
+    depth,
+    documents,
+    draft,
+    fallbackLocale,
+    locale,
+    populate,
+    publishAllLocales,
+    returning,
+    select,
+  } = input
+  const shouldUsePartialSchema =
+    draft === true && collectionConfig !== undefined && !hasDraftValidationEnabled(collectionConfig)
 
-  const { data, depth, draft, fallbackLocale, locale, select } = input
-
-  logger.info(
-    `Creating document in collection: ${collectionSlug}${locale ? ` with locale: ${locale}` : ''}`,
-  )
+  logger.info(`Creating ${documents.length} documents in collection: ${slug}`)
 
   try {
-    const virtualFieldNames = getCollectionVirtualFieldNames(payload.config, collectionSlug)
-    const inputData = stripVirtualFields(data, virtualFieldNames)
-    const validationError = validateCollectionData({ collectionSlug, data: inputData, req })
+    const virtualFieldNames = getCollectionVirtualFieldNames(payload.config, slug)
+    const docs: Array<
+      { doc: Record<string, unknown>; index: number } | { id: number | string; index: number }
+    > = []
+    const errors: Array<{ index: number; message: string }> = []
+    let validationSchema: Record<string, unknown> | undefined
 
-    if (validationError) {
-      return validationError
-    }
+    for (const [index, document] of documents.entries()) {
+      try {
+        const inputData = stripVirtualFields(document.data, virtualFieldNames)
+        validateCollectionData({
+          slug,
+          data: inputData,
+          partial: shouldUsePartialSchema,
+          req,
+        })
 
-    const parsedData = transformPointDataToPayload(inputData)
+        const parsedData = transformPointDataToPayload(inputData)
+        const file = await resolveFile({ slug, input: document.file, req })
+        const result = await payload.create({
+          collection: slug,
+          data: parsedData,
+          depth,
+          draft,
+          overrideAccess: authorizedMCP.overrideAccess,
+          populate,
+          publishAllLocales,
+          req,
+          ...(file ? { file } : {}),
+          ...(locale ? { locale } : {}),
+          ...(fallbackLocale !== undefined ? { fallbackLocale } : {}),
+          select: returning ? select : { id: true },
+        })
 
-    const result = await payload.create({
-      collection: collectionSlug,
-      data: parsedData,
-      depth,
-      draft,
-      req,
-      ...localAPIDefaults(authorizedMCP),
-      ...(locale ? { locale } : {}),
-      ...(fallbackLocale ? { fallbackLocale } : {}),
-      ...(select ? { select: select as SelectType } : {}),
-    })
+        docs.push(
+          returning ? { doc: result as Record<string, unknown>, index } : { id: result.id, index },
+        )
+      } catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error'
+        const formattedError = formatEntityError({
+          slug,
+          action: 'creating',
+          entity: 'collection',
+          error,
+          req,
+        })
+        const structuredContent = formattedError.structuredContent as
+          | { schema?: unknown }
+          | undefined
+        const schema = structuredContent?.schema
+        const errorContent = formattedError.content[0]
+        const formattedMessage =
+          errorContent?.type === 'text'
+            ? (errorContent.text.split('\n\nUse this schema')[0] ?? message)
+            : message
 
-    logger.info(`Successfully created document in ${collectionSlug} with ID: ${result.id}`)
+        if (!validationSchema && schema && typeof schema === 'object') {
+          validationSchema = schema as Record<string, unknown>
+        }
+
+        logger.error(`Error creating document at index ${index} in ${slug}: ${message}`)
+        errors.push({ index, message: formattedMessage })
+      }
+    }
+
+    const batchResult = { docs, errors }
+    const retryMessage = errors.length > 0 ? '\nRetry failed indexes only.' : ''
+    const schemaMessage = validationSchema
+      ? `\n\nUse this schema for data:\n\`\`\`json\n${JSON.stringify(validationSchema)}\n\`\`\``
+      : ''
+    const structuredContent = validationSchema
+      ? { ...batchResult, schema: validationSchema }
+      : batchResult
+
+    logger.info(`Created ${docs.length} of ${documents.length} documents in ${slug}`)
 
     return {
       content: [
         {
           type: 'text',
-          text: `Document created successfully in collection "${collectionSlug}"!\nCreated document:\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
+          text: `Created ${docs.length} of ${documents.length} documents in collection "${slug}".${retryMessage}\nResults:\n\`\`\`json\n${JSON.stringify(batchResult)}\n\`\`\`${schemaMessage}`,
         },
       ],
-      doc: result as Record<string, unknown>,
+      doc: structuredContent as unknown as Record<string, unknown>,
+      isError: docs.length === 0 && errors.length > 0,
+      structuredContent,
     }
   } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : 'Unknown error'
-    logger.error(`Error creating document in ${collectionSlug}: ${errorMessage}`)
-    return formatCollectionError({ action: 'creating', collectionSlug, error, req })
+    const message = error instanceof Error ? error.message : 'Unknown error'
+
+    logger.error(`Error creating documents in ${slug}: ${message}`)
+    return formatEntityError({ slug, action: 'creating', entity: 'collection', error, req })
   }
 })

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

@@ -1,17 +1,15 @@
-import { z } from 'zod'
+import { deleteDocumentsInputSchema, parseDocumentID } from 'payload'
 
 import { defaultAccess } from '../../../defaultAccess.js'
 import { defineCollectionTool } from '../../../defineTool.js'
 import { getLogger } from '../../../utils/getLogger.js'
-import { localAPIDefaults } from '../../../utils/localAPIDefaults.js'
-import { whereSchema } from '../../../utils/whereSchema.js'
 
 const DEFAULT_DESCRIPTION =
   'Delete documents in any collection by passing the collection slug and ID or where clause.'
 
 export const deleteDocumentsTool = defineCollectionTool({
   access: (args) =>
-    defaultAccess(args) && Boolean(args.permissions?.collections?.[args.collectionSlug]?.delete),
+    defaultAccess(args) && Boolean(args.permissions?.collections?.[args.slug]?.delete),
   annotations: {
     destructiveHint: true,
     idempotentHint: false,
@@ -20,86 +18,59 @@ export const deleteDocumentsTool = defineCollectionTool({
     title: 'Delete Documents',
   },
   description: DEFAULT_DESCRIPTION,
-  input: z.object({
-    id: z
-      .union([z.string(), z.number()])
-      .describe('Optional: specific document ID to delete')
-      .optional(),
-    depth: z
-      .number()
-      .int()
-      .min(0)
-      .max(10)
-      .describe('Depth of population for 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 for the operation (e.g., "en", "es"). Defaults to the default locale',
-      )
-      .optional(),
-    where: whereSchema
-      .describe(
-        'Optional: where clause to delete multiple documents. Use field names with Payload operators, and/or arrays for grouping. Example: {"title":{"contains":"test"}}',
-      )
-      .optional(),
-  }),
-}).handler(async ({ authorizedMCP, collectionSlug, input, req }) => {
+  input: deleteDocumentsInputSchema,
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
   const payload = req.payload
   const logger = getLogger({ payload })
 
   const { id, depth, fallbackLocale, locale, where } = input
 
   logger.info(
-    `Deleting document from collection: ${collectionSlug}${id ? ` with ID: ${id}` : ' with where clause'}${locale ? `, locale: ${locale}` : ''}`,
+    `Deleting document from collection: ${slug}${id ? ` with ID: ${id}` : ' with where clause'}${locale ? `, locale: ${locale}` : ''}`,
   )
 
   try {
-    if (!id && !where) {
-      return {
-        content: [{ type: 'text', text: 'Error: Either id or where clause must be provided' }],
-      }
-    }
-
-    const deleteOptions: Record<string, unknown> = {
-      collection: collectionSlug,
-      depth,
-      req,
-      ...localAPIDefaults(authorizedMCP),
-      ...(locale && { locale }),
-      ...(fallbackLocale && { fallbackLocale }),
-    }
-
-    if (id) {
-      deleteOptions.id = id
-    } else {
-      deleteOptions.where = where
-    }
-
-    const result = await payload.delete(deleteOptions as Parameters<typeof payload.delete>[0])
+    if (id !== undefined) {
+      const result = await payload.delete({
+        id: parseDocumentID({ id, collectionSlug: slug, payload }),
+        collection: slug,
+        depth,
+        overrideAccess: authorizedMCP.overrideAccess,
+        req,
+        ...(locale && { locale }),
+        ...(fallbackLocale !== undefined && { fallbackLocale }),
+      })
 
-    if (id) {
       return {
         content: [
           {
             type: 'text',
-            text: `Document deleted successfully from collection "${collectionSlug}"!\nDeleted document:\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
+            text: `Document deleted successfully from collection "${slug}"!\nDeleted document:\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
           },
         ],
         doc: result as Record<string, unknown>,
       }
     }
 
-    const bulkResult = result as { docs?: unknown[]; errors?: unknown[] }
-    const docs = bulkResult.docs || []
-    const errors = bulkResult.errors || []
+    if (where === undefined) {
+      return {
+        content: [{ type: 'text', text: 'Error: Either id or where clause must be provided' }],
+      }
+    }
+
+    const result = await payload.delete({
+      collection: slug,
+      depth,
+      overrideAccess: authorizedMCP.overrideAccess,
+      req,
+      where,
+      ...(locale && { locale }),
+      ...(fallbackLocale !== undefined && { fallbackLocale }),
+    })
+    const docs = result.docs || []
+    const errors = result.errors || []
 
-    let responseText = `Document deleted successfully from collection "${collectionSlug}"!\nDeleted: ${docs.length} documents\nErrors: ${errors.length}\n---`
+    let responseText = `Document deleted successfully from collection "${slug}"!\nDeleted: ${docs.length} documents\nErrors: ${errors.length}\n---`
     if (docs.length > 0) {
       responseText += `\n\nDeleted documents:\n\`\`\`json\n${JSON.stringify(docs)}\n\`\`\``
     }
@@ -113,12 +84,12 @@ export const deleteDocumentsTool = defineCollectionTool({
     }
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : 'Unknown error'
-    logger.error(`Error deleting document from ${collectionSlug}: ${errorMessage}`)
+    logger.error(`Error deleting document from ${slug}: ${errorMessage}`)
     return {
       content: [
         {
           type: 'text',
-          text: `Error deleting document from collection "${collectionSlug}": ${errorMessage}`,
+          text: `Error deleting document from collection "${slug}": ${errorMessage}`,
         },
       ],
     }

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

@@ -1,24 +1,23 @@
-import type { PopulateType, SelectType } from 'payload'
-
-import { z } from 'zod'
+import {
+  duplicateDocumentInputSchema,
+  getCollectionVirtualFieldNames,
+  parseDocumentID,
+  stripVirtualFields,
+  transformPointDataToPayload,
+  validateCollectionData,
+} from 'payload'
 
 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 { transformPointDataToPayload } from '../../../utils/transformPointDataToPayload.js'
-import { formatCollectionError } from './formatCollectionError.js'
+import { formatEntityError } from '../formatEntityError.js'
 
 const DEFAULT_DESCRIPTION =
   'Duplicate a document in any collection by passing the collection slug and source document ID.'
 
 export const duplicateDocumentTool = defineCollectionTool({
   access: (args) =>
-    defaultAccess(args) && Boolean(args.permissions?.collections?.[args.collectionSlug]?.create),
+    defaultAccess(args) && Boolean(args.permissions?.collections?.[args.slug]?.create),
   annotations: {
     destructiveHint: false,
     idempotentHint: false,
@@ -27,109 +26,59 @@ export const duplicateDocumentTool = defineCollectionTool({
     title: 'Duplicate Document',
   },
   description: DEFAULT_DESCRIPTION,
-  input: z.object({
-    id: z.union([z.string(), z.number()]).describe('The ID of the document to duplicate'),
-    data: z
-      .record(z.string(), z.unknown())
-      .describe('Optional: fields to override on the duplicated document')
-      .optional(),
-    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 create the duplicate 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 duplicate in (e.g., "en", "es"). Defaults to the default locale',
-      )
-      .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(),
-    selectedLocales: z
-      .array(z.string())
-      .describe('Optional: localized field locales to include in the duplicated document')
-      .optional(),
-    showHiddenFields: z
-      .boolean()
-      .describe('Optional: include hidden fields in the duplicated document response')
-      .optional(),
-  }),
-}).handler(async ({ authorizedMCP, collectionSlug, input, req }) => {
+  input: duplicateDocumentInputSchema,
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
   const payload = req.payload
   const logger = getLogger({ payload })
-  const {
-    id,
-    data,
-    depth,
-    draft,
-    fallbackLocale,
-    locale,
-    populate,
-    select,
-    selectedLocales,
-    showHiddenFields,
-  } = input
+  const { id, data, depth, draft, fallbackLocale, locale, populate, select, selectedLocales } =
+    input
 
-  logger.info(`Duplicating document in collection: ${collectionSlug} with ID: ${id}`)
+  logger.info(`Duplicating document in collection: ${slug} with ID: ${id}`)
 
   try {
-    const virtualFieldNames = getCollectionVirtualFieldNames(payload.config, collectionSlug)
+    const virtualFieldNames = getCollectionVirtualFieldNames(payload.config, slug)
     const inputData = data ? stripVirtualFields(data, virtualFieldNames) : undefined
+
+    if (inputData) {
+      validateCollectionData({
+        slug,
+        data: inputData,
+        partial: true,
+        req,
+      })
+    }
+
     const parsedData = inputData ? transformPointDataToPayload(inputData) : undefined
 
     const result = await payload.duplicate({
-      id,
-      collection: collectionSlug,
+      id: parseDocumentID({ id, collectionSlug: slug, payload }),
+      collection: slug,
       depth,
       draft,
+      overrideAccess: authorizedMCP.overrideAccess,
       req,
-      ...localAPIDefaults(authorizedMCP),
       ...(parsedData ? { data: parsedData } : {}),
       ...(locale ? { locale } : {}),
-      ...(fallbackLocale ? { fallbackLocale } : {}),
-      ...(populate ? { populate: populate as PopulateType } : {}),
-      ...(select ? { select: select as SelectType } : {}),
+      ...(fallbackLocale !== undefined ? { fallbackLocale } : {}),
+      ...(populate ? { populate } : {}),
+      ...(select ? { select } : {}),
       ...(selectedLocales ? { selectedLocales } : {}),
-      ...(showHiddenFields !== undefined ? { showHiddenFields } : {}),
     })
 
-    logger.info(`Successfully duplicated document in ${collectionSlug} from ID: ${id}`)
+    logger.info(`Successfully duplicated document in ${slug} from ID: ${id}`)
 
     return {
       content: [
         {
           type: 'text',
-          text: `Document duplicated successfully in collection "${collectionSlug}"!\nDuplicated document:\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
+          text: `Document duplicated successfully in collection "${slug}"!\nDuplicated 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 duplicating document in ${collectionSlug}: ${errorMessage}`)
-    return formatCollectionError({ action: 'duplicating', collectionSlug, error, req })
+    logger.error(`Error duplicating document in ${slug}: ${errorMessage}`)
+    return formatEntityError({ slug, action: 'duplicating', entity: 'collection', error, req })
   }
 })

package/src/mcp/builtin/collections/fileInput.spec.ts

@@ -0,0 +1,93 @@
+import type { PayloadRequest } from 'payload'
+
+import { describe, expect, it } from 'vitest'
+
+import { fileInputSchema, resolveFile } 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 accept a prepared upload', () => {
+    const result = fileInputSchema.safeParse({
+      file: {
+        filename: 'image.png',
+        mimeType: 'image/png',
+        size: 123,
+        uploadReference: { uploadId: 'upload-id' },
+      },
+      source: 'uploadReference',
+    })
+
+    expect(result.success).toBe(true)
+  })
+
+  it('should reject oversized base64 files', async () => {
+    const req = createRequest({ maxFileSize: 4 })
+
+    await expect(
+      resolveFile({
+        slug: '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(
+      resolveFile({
+        slug: 'media',
+        input: {
+          source: 'externalURL',
+          url: 'https://example.com/image.png',
+        },
+        req,
+      }),
+    ).rejects.toThrow('The provided file URL is not allowed.')
+  })
+})
+
+function createRequest({
+  allowList,
+  maxFileSize,
+}: {
+  allowList?: Array<{ hostname: string; protocol: 'http' | 'https' }>
+  maxFileSize?: number
+}): PayloadRequest {
+  return {
+    payload: {
+      collections: {
+        media: {
+          config: {
+            upload: allowList ? { pasteURL: { allowList } } : {},
+          },
+        },
+      },
+      config: {
+        upload: {
+          limits: {
+            fileSize: maxFileSize,
+          },
+        },
+      },
+    },
+  } as unknown as PayloadRequest
+}