@payloadcms/plugin-mcp 4.0.0-internal.c3ac604 → 4.0.0-internal.cc18726

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

@@ -1,15 +1,13 @@
-import type { SelectType } from 'payload'
-
-import { z } from 'zod'
+import {
+  createDocumentsInputSchema,
+  getCollectionVirtualFieldNames,
+  stripVirtualFields,
+  transformPointDataToPayload,
+} 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 { transformPointDataToPayload } from '../../../utils/transformPointDataToPayload.js'
 import { validateCollectionData } from '../validateEntityData.js'
 import { fileInputSchema, resolveFile } from './fileInput.js'
 import { formatCollectionError } from './formatCollectionError.js'
@@ -19,7 +17,7 @@ const DEFAULT_DESCRIPTION =
 
 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,
@@ -28,61 +26,17 @@ export const createDocumentsTool = defineCollectionTool({
     title: 'Create Documents',
   },
   description: DEFAULT_DESCRIPTION,
-  input: z.object({
-    depth: z
-      .number()
-      .int()
-      .min(0)
-      .max(10)
-      .describe('How many levels deep to populate relationships in response')
-      .optional()
-      .default(0),
-    documents: z
-      .array(
-        z.object({
-          data: z
-            .record(z.string(), z.unknown())
-            .describe(
-              'The document fields to create. Only include fields permitted by the schema returned by getCollectionSchema.',
-            ),
-          file: fileInputSchema.optional(),
-        }),
-      )
-      .min(1)
-      .describe('The documents to create, in order'),
-    draft: z
-      .boolean()
-      .describe(
-        'Only if getCollectionSchema includes _status; otherwise _status does not exist. true forces data._status to "draft"; with false, data._status controls draft or published.',
-      )
-      .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 documents 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 logger = getLogger({ payload })
-  const { depth, documents, draft, fallbackLocale, locale, select } = input
+  const { depth, documents, draft, fallbackLocale, locale, populate, publishAllLocales, select } =
+    input
 
-  logger.info(`Creating ${documents.length} documents in collection: ${collectionSlug}`)
+  logger.info(`Creating ${documents.length} documents in collection: ${slug}`)
 
   try {
-    const virtualFieldNames = getCollectionVirtualFieldNames(payload.config, collectionSlug)
+    const virtualFieldNames = getCollectionVirtualFieldNames(payload.config, slug)
     const docs: Array<{ doc: Record<string, unknown>; index: number }> = []
     const errors: Array<{ index: number; message: string }> = []
     let validationSchema: Record<string, unknown> | undefined
@@ -90,7 +44,7 @@ export const createDocumentsTool = defineCollectionTool({
     for (const [index, document] of documents.entries()) {
       try {
         const inputData = stripVirtualFields(document.data, virtualFieldNames)
-        const validationError = validateCollectionData({ collectionSlug, data: inputData, req })
+        const validationError = validateCollectionData({ slug, data: inputData, req })
 
         if (validationError) {
           const firstContent = validationError.content[0]
@@ -114,25 +68,27 @@ export const createDocumentsTool = defineCollectionTool({
         }
 
         const parsedData = transformPointDataToPayload(inputData)
-        const file = await resolveFile({ collectionSlug, input: document.file, req })
+        const file = await resolveFile({ slug, input: document.file, req })
         const result = await payload.create({
-          collection: collectionSlug,
+          collection: slug,
           data: parsedData,
           depth,
           draft,
           overrideAccess: authorizedMCP.overrideAccess,
+          populate,
+          publishAllLocales,
           req,
           ...(file ? { file } : {}),
           ...(locale ? { locale } : {}),
-          ...(fallbackLocale ? { fallbackLocale } : {}),
-          ...(select ? { select: select as SelectType } : {}),
+          ...(fallbackLocale !== undefined ? { fallbackLocale } : {}),
+          ...(select ? { select } : {}),
         })
 
         docs.push({ doc: result as Record<string, unknown>, index })
       } catch (error) {
         const message = error instanceof Error ? error.message : 'Unknown error'
 
-        logger.error(`Error creating document at index ${index} in ${collectionSlug}: ${message}`)
+        logger.error(`Error creating document at index ${index} in ${slug}: ${message}`)
         errors.push({ index, message })
       }
     }
@@ -146,13 +102,13 @@ export const createDocumentsTool = defineCollectionTool({
       ? { ...batchResult, schema: validationSchema }
       : batchResult
 
-    logger.info(`Created ${docs.length} of ${documents.length} documents in ${collectionSlug}`)
+    logger.info(`Created ${docs.length} of ${documents.length} documents in ${slug}`)
 
     return {
       content: [
         {
           type: 'text',
-          text: `Created ${docs.length} of ${documents.length} documents in collection "${collectionSlug}".${retryMessage}\nResults:\n\`\`\`json\n${JSON.stringify(batchResult)}\n\`\`\`${schemaMessage}`,
+          text: `Created ${docs.length} of ${documents.length} documents in collection "${slug}".${retryMessage}\nResults:\n\`\`\`json\n${JSON.stringify(batchResult)}\n\`\`\`${schemaMessage}`,
         },
       ],
       doc: structuredContent as unknown as Record<string, unknown>,
@@ -162,7 +118,7 @@ export const createDocumentsTool = defineCollectionTool({
   } catch (error) {
     const message = error instanceof Error ? error.message : 'Unknown error'
 
-    logger.error(`Error creating documents in ${collectionSlug}: ${message}`)
-    return formatCollectionError({ action: 'creating', collectionSlug, error, req })
+    logger.error(`Error creating documents in ${slug}: ${message}`)
+    return formatCollectionError({ slug, action: 'creating', error, req })
   }
 })

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

@@ -1,16 +1,15 @@
-import { z } from 'zod'
+import { deleteDocumentsInputSchema } from 'payload'
 
 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 =
   '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,
@@ -19,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,
-      overrideAccess: authorizedMCP.overrideAccess,
-      req,
-      ...(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,
+        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\`\`\``
     }
@@ -112,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,15 +1,13 @@
-import type { PopulateType, SelectType } from 'payload'
-
-import { z } from 'zod'
+import {
+  duplicateDocumentInputSchema,
+  getCollectionVirtualFieldNames,
+  stripVirtualFields,
+  transformPointDataToPayload,
+} 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 { transformPointDataToPayload } from '../../../utils/transformPointDataToPayload.js'
 import { formatCollectionError } from './formatCollectionError.js'
 
 const DEFAULT_DESCRIPTION =
@@ -17,7 +15,7 @@ const DEFAULT_DESCRIPTION =
 
 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,
@@ -26,109 +24,49 @@ 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
     const parsedData = inputData ? transformPointDataToPayload(inputData) : undefined
 
     const result = await payload.duplicate({
       id,
-      collection: collectionSlug,
+      collection: slug,
       depth,
       draft,
       overrideAccess: authorizedMCP.overrideAccess,
       req,
       ...(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 formatCollectionError({ slug, action: 'duplicating', error, req })
   }
 })

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

@@ -35,7 +35,7 @@ describe('MCP file input', () => {
 
     await expect(
       resolveFile({
-        collectionSlug: 'media',
+        slug: 'media',
         input: {
           data: Buffer.from('hello').toString('base64'),
           mimeType: 'text/plain',
@@ -54,7 +54,7 @@ describe('MCP file input', () => {
 
     await expect(
       resolveFile({
-        collectionSlug: 'media',
+        slug: 'media',
         input: {
           source: 'externalURL',
           url: 'https://example.com/image.png',

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

@@ -1,53 +1,61 @@
 import type { CollectionSlug, File, FileData, PayloadRequest } from 'payload'
 
-import { APIError } from 'payload'
+import { APIError, z } from 'payload'
 import { getExternalFile, getFileFromUploadInstructions, isURLAllowed } from 'payload/internal'
 import { sanitizeFilename } from 'payload/shared'
-import { z } from 'zod'
 
 const mimeTypeSchema = z
   .string()
-  .regex(/^[!#$%&'*+.^`|~\w-]+\/[!#$%&'*+.^`|~\w-]+$/, 'MIME type must use the type/subtype format')
+  .check(
+    z.regex(
+      /^[!#$%&'*+.^`|~\w-]+\/[!#$%&'*+.^`|~\w-]+$/,
+      'MIME type must use the type/subtype format',
+    ),
+  )
 
-const uploadFileSchema = z.object({
+const uploadFileSchema = z.strictObject({
   filename: z.string(),
   mimeType: z.string(),
-  size: z.number().int().nonnegative(),
+  size: z.int().check(z.nonnegative()),
   uploadReference: z.record(z.string(), z.unknown()),
 })
 
 export const fileInputSchema = z
   .discriminatedUnion('source', [
-    z.object({
-      name: z.string().min(1).describe('The file name, including its extension'),
-      data: z.string().describe('The base64-encoded file bytes, without a data URL prefix'),
-      mimeType: mimeTypeSchema.describe('The file MIME type, for example image/png'),
+    z.strictObject({
+      name: z.string().check(z.minLength(1), z.describe('The file name, including its extension.')),
+      data: z
+        .string()
+        .check(z.describe('The base64-encoded file bytes, without a data URL prefix.')),
+      mimeType: mimeTypeSchema.check(z.describe('The file MIME type, for example image/png.')),
       source: z.literal('base64'),
     }),
-    z.object({
-      name: z.string().min(1).describe('Optional file name override').optional(),
+    z.strictObject({
+      name: z.optional(z.string().check(z.minLength(1))).check(z.describe('File name override.')),
       source: z.literal('externalURL'),
-      url: z.url().describe('The http or https URL to download'),
+      url: z.url().check(z.describe('The http or https URL to download.')),
     }),
-    z.object({
-      file: uploadFileSchema.describe('getUploadInstructions file field post-upload'),
+    z.strictObject({
+      file: uploadFileSchema.check(z.describe('getUploadInstructions file field post-upload.')),
       source: z.literal('uploadReference'),
     }),
   ])
-  .describe(
-    'A file for an upload collection. Prefer uploadReference after its upload succeeds; use base64 only for small local files or externalURL for an online file.',
+  .check(
+    z.describe(
+      'A file for an upload collection. Prefer uploadReference after its upload succeeds; use base64 only for small local files or externalURL for an online file.',
+    ),
   )
 
 type FileInput = z.infer<typeof fileInputSchema>
 
 export async function resolveFile({
-  collectionSlug,
+  slug,
   input,
   req,
 }: {
-  collectionSlug: CollectionSlug
   input?: FileInput
   req: PayloadRequest
+  slug: CollectionSlug
 }): Promise<File | undefined> {
   if (!input) {
     return undefined
@@ -55,7 +63,7 @@ export async function resolveFile({
 
   if (input.source === 'uploadReference') {
     try {
-      return await getFileFromUploadInstructions({ collectionSlug, file: input.file, req })
+      return await getFileFromUploadInstructions({ collectionSlug: slug, file: input.file, req })
     } catch (error) {
       if (error instanceof Error && error.message === 'Staged upload was not found.') {
         throw new APIError(
@@ -67,10 +75,10 @@ export async function resolveFile({
     }
   }
 
-  const uploadConfig = req.payload.collections[collectionSlug]?.config.upload
+  const uploadConfig = req.payload.collections[slug]?.config.upload
 
   if (!uploadConfig) {
-    throw new APIError(`Collection "${collectionSlug}" does not support file uploads.`, 400)
+    throw new APIError(`Collection "${slug}" does not support file uploads.`, 400)
   }
 
   const maxFileSize = req.payload.config.upload.limits?.fileSize
@@ -87,10 +95,7 @@ export async function resolveFile({
     }
   } else {
     if (uploadConfig.pasteURL === false) {
-      throw new APIError(
-        `Uploading files from URLs is disabled for collection "${collectionSlug}".`,
-        400,
-      )
+      throw new APIError(`Uploading files from URLs is disabled for collection "${slug}".`, 400)
     }
 
     const url = new URL(input.url)