@payloadcms/plugin-mcp 4.0.0-internal.fa183d3 → 4.0.0-internal.fec2230

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

@@ -1,19 +1,15 @@
-import type { PopulateType, SelectType } from 'payload'
-
-import { z } from 'zod'
+import { findVersionsInputSchema } 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 =
   '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),
+    defaultAccess(args) && Boolean(args.permissions?.collections?.[args.slug]?.readVersions),
   annotations: {
     destructiveHint: false,
     idempotentHint: true,
@@ -22,79 +18,13 @@ export const findVersionsTool = defineCollectionTool({
     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 }) => {
+  input: findVersionsInputSchema,
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
   const payload = req.payload
   const logger = getLogger({ payload })
   const {
     depth,
+    draft,
     fallbackLocale,
     limit,
     locale,
@@ -102,28 +32,27 @@ export const findVersionsTool = defineCollectionTool({
     pagination,
     populate,
     select,
-    showHiddenFields,
     sort,
     trash,
     where,
   } = input
 
-  logger.info(`Finding versions in collection: ${collectionSlug}, limit: ${limit}, page: ${page}`)
+  logger.info(`Finding versions in collection: ${slug}, limit: ${limit}, page: ${page}`)
 
   try {
     const result = await payload.findVersions({
-      collection: collectionSlug,
+      collection: slug,
       depth,
       limit,
       overrideAccess: authorizedMCP.overrideAccess,
       page,
       req,
-      ...(fallbackLocale ? { fallbackLocale } : {}),
+      ...(draft !== undefined ? { draft } : {}),
+      ...(fallbackLocale !== undefined ? { fallbackLocale } : {}),
       ...(locale ? { locale } : {}),
       ...(pagination !== undefined ? { pagination } : {}),
-      ...(populate ? { populate: populate as PopulateType } : {}),
-      ...(select ? { select: select as SelectType } : {}),
-      ...(showHiddenFields !== undefined ? { showHiddenFields } : {}),
+      ...(populate ? { populate } : {}),
+      ...(select ? { select } : {}),
       ...(sort ? { sort } : {}),
       ...(trash !== undefined ? { trash } : {}),
       ...(where ? { where } : {}),
@@ -133,19 +62,19 @@ export const findVersionsTool = defineCollectionTool({
       content: [
         {
           type: 'text',
-          text: `Versions for collection "${collectionSlug}":\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
+          text: `Versions for collection "${slug}":\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}`)
+    logger.error(`Error finding versions in ${slug}: ${errorMessage}`)
     return {
       content: [
         {
           type: 'text',
-          text: `❌ **Error finding versions in collection "${collectionSlug}":** ${errorMessage}`,
+          text: `❌ **Error finding versions in collection "${slug}":** ${errorMessage}`,
         },
       ],
       isError: true,

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

@@ -1,12 +1,11 @@
-import { getAccessResults } from 'payload'
+import { getAccessResults, getCollectionInputSchema, getCollectionSchemaInputSchema } 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]
+    const permissions = args.permissions?.collections?.[args.slug]
 
     return defaultAccess(args) && Boolean(permissions?.create || permissions?.update)
   },
@@ -18,17 +17,18 @@ export const getCollectionSchemaTool = defineCollectionTool({
     title: 'Get Collection Schema',
   },
   description: 'Get the input schema for creating or updating documents in a collection.',
-}).handler(async ({ authorizedMCP, collectionSlug, req }) => {
+  input: getCollectionSchemaInputSchema,
+}).handler(async ({ slug, authorizedMCP, req }) => {
   const permissions = authorizedMCP.overrideAccess
     ? null
-    : (await getAccessResults({ req })).collections?.[collectionSlug]
+    : (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 "${collectionSlug}"`,
+          text: `Error: MCP access to "getCollectionSchema" is not enabled for collection "${slug}"`,
         },
       ],
       isError: true,
@@ -36,26 +36,30 @@ export const getCollectionSchemaTool = defineCollectionTool({
   }
 
   const inputSchema = getCollectionInputSchema({
-    collectionSlug,
+    collectionSlug: slug,
     req,
     ...(permissions ? { permissions } : {}),
   })
 
   if (!inputSchema) {
     return {
-      content: [{ type: 'text', text: `Error: Collection "${collectionSlug}" not found` }],
+      content: [{ type: 'text', text: `Error: Collection "${slug}" not found` }],
       isError: true,
     }
   }
 
-  const uploadConfig = req.payload.collections[collectionSlug]?.config.upload
+  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 ? ['url'] : []), 'base64'],
+        sources: [
+          ...(uploadConfig.pasteURL !== false ? ['externalURL'] : []),
+          'base64',
+          'uploadReference',
+        ],
         ...(typeof maxFileSize === 'number' && Number.isFinite(maxFileSize) ? { maxFileSize } : {}),
       }
     : { enabled: false }
@@ -64,11 +68,11 @@ export const getCollectionSchemaTool = defineCollectionTool({
     content: [
       {
         type: 'text',
-        text: `Schema for collection "${collectionSlug}":\n\`\`\`json\n${JSON.stringify(inputSchema)}\n\`\`\`\nUpload configuration:\n\`\`\`json\n${JSON.stringify(upload)}\n\`\`\``,
+        text: `Schema for collection "${slug}":\n\`\`\`json\n${JSON.stringify(inputSchema)}\n\`\`\`\nUpload configuration:\n\`\`\`json\n${JSON.stringify(upload)}\n\`\`\``,
       },
     ],
     structuredContent: {
-      collectionSlug,
+      slug,
       schema: inputSchema,
       upload,
     },

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

@@ -1,6 +1,4 @@
-import type { PopulateType, SelectType } from 'payload'
-
-import { z } from 'zod'
+import { restoreVersionInputSchema } from 'payload'
 
 import { defaultAccess } from '../../../defaultAccess.js'
 import { defineCollectionTool } from '../../../defineTool.js'
@@ -11,7 +9,7 @@ const DEFAULT_DESCRIPTION =
 
 export const restoreVersionTool = defineCollectionTool({
   access: (args) =>
-    defaultAccess(args) && Boolean(args.permissions?.collections?.[args.collectionSlug]?.update),
+    defaultAccess(args) && Boolean(args.permissions?.collections?.[args.slug]?.update),
   annotations: {
     destructiveHint: true,
     idempotentHint: false,
@@ -20,85 +18,45 @@ export const restoreVersionTool = defineCollectionTool({
     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 }) => {
+  input: restoreVersionInputSchema,
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
   const payload = req.payload
   const logger = getLogger({ payload })
-  const { id, depth, draft, fallbackLocale, locale, populate, select, showHiddenFields } = input
+  const { id, depth, draft, fallbackLocale, locale, populate, select } = input
 
-  logger.info(`Restoring version in collection: ${collectionSlug} with ID: ${id}`)
+  logger.info(`Restoring version in collection: ${slug} with ID: ${id}`)
 
   try {
     const result = await payload.restoreVersion({
-      id,
-      collection: collectionSlug,
+      id: String(id),
+      collection: slug,
       depth,
       draft,
       overrideAccess: authorizedMCP.overrideAccess,
       req,
-      ...(fallbackLocale ? { fallbackLocale } : {}),
+      ...(fallbackLocale !== undefined ? { fallbackLocale } : {}),
       ...(locale ? { locale } : {}),
-      ...(populate ? { populate: populate as PopulateType } : {}),
-      ...(select ? { select: select as SelectType } : {}),
-      ...(showHiddenFields !== undefined ? { showHiddenFields } : {}),
+      ...(populate ? { populate } : {}),
+      ...(select ? { select } : {}),
     })
 
     return {
       content: [
         {
           type: 'text',
-          text: `Version "${id}" restored successfully in collection "${collectionSlug}"!\nRestored document:\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
+          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 ${collectionSlug}: ${errorMessage}`)
+    logger.error(`Error restoring version ${id} in ${slug}: ${errorMessage}`)
     return {
       content: [
         {
           type: 'text',
-          text: `❌ **Error restoring version "${id}" in collection "${collectionSlug}":** ${errorMessage}`,
+          text: `❌ **Error restoring version "${id}" in collection "${slug}":** ${errorMessage}`,
         },
       ],
       isError: true,

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

@@ -1,27 +1,27 @@
-import type { SelectType, Where } from 'payload'
+import type { Where } from 'payload'
 
-import { z } from 'zod'
+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 {
-  getCollectionVirtualFieldNames,
-  stripVirtualFields,
-} from '../../../utils/getVirtualFieldNames.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'
+import { formatEntityError } from '../formatEntityError.js'
+import { fileInputSchema, resolveFile } from './fileInput.js'
 
 const DEFAULT_DESCRIPTION =
-  'Update documents in any collection by passing the collection slug and data.'
+  '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.collectionSlug]?.update),
+    defaultAccess(args) && Boolean(args.permissions?.collections?.[args.slug]?.update),
   annotations: {
     destructiveHint: true,
     idempotentHint: false,
@@ -30,65 +30,8 @@ export const updateDocumentTool = defineCollectionTool({
     title: 'Update Document',
   },
   description: DEFAULT_DESCRIPTION,
-  input: z.object({
-    id: z.union([z.string(), z.number()]).describe('The ID of the document to update').optional(),
-    data: z
-      .record(z.string(), z.unknown())
-      .describe(
-        'The fields to update. Only include fields permitted by the schema returned by getCollectionSchema.',
-      ),
-    depth: z
-      .number()
-      .describe('How many levels deep to populate relationships')
-      .optional()
-      .default(0),
-    draft: z
-      .boolean()
-      .describe(
-        'Only if getCollectionSchema includes _status; otherwise _status does not exist. true saves only a draft version; false updates main and versions. data._status: "published" overrides true.',
-      )
-      .optional()
-      .default(false),
-    fallbackLocale: z
-      .string()
-      .describe('Optional: fallback locale code to use when requested locale is not available')
-      .optional(),
-    file: fileInputSchema.optional(),
-    locale: z
-      .string()
-      .describe(
-        'Optional: locale code to update the document in (e.g., "en", "es"). Defaults to the default locale',
-      )
-      .optional(),
-    overrideLock: z
-      .boolean()
-      .describe('Whether to override document locks')
-      .optional()
-      .default(true),
-    overwriteExistingFiles: z
-      .boolean()
-      .describe('Whether to overwrite existing files')
-      .optional()
-      .default(false),
-    publishAllLocales: z
-      .boolean()
-      .describe(
-        'For collections with localized publishing status, whether publishing should affect every locale. Set false with locale to publish only that locale.',
-      )
-      .optional(),
-    select: z
-      .record(z.string(), z.unknown())
-      .describe(
-        'Optional: define exactly which fields you\'d like to return in the response, e.g., {"title": true}',
-      )
-      .optional(),
-    where: whereSchema
-      .describe(
-        'Where clause to update multiple documents. Use field names with Payload operators, and/or arrays for grouping. Example: {"title":{"contains":"test"}}',
-      )
-      .optional(),
-  }),
-}).handler(async ({ authorizedMCP, collectionSlug, input, req }) => {
+  input: updateDocumentInputSchema({ file: fileInputSchema }),
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
   const payload = req.payload
   const logger = getLogger({ payload })
 
@@ -99,100 +42,103 @@ export const updateDocumentTool = defineCollectionTool({
     draft,
     fallbackLocale,
     file: fileInput,
+    limit,
     locale,
     overrideLock,
-    overwriteExistingFiles,
+    populate,
     publishAllLocales,
+    returning,
     select,
+    sort,
+    trash,
+    unpublishAllLocales,
     where,
   } = input
 
   logger.info(
-    `Updating document in collection: ${collectionSlug}${id ? ` with ID: ${id}` : ' with where clause'}, draft: ${draft}${locale ? `, locale: ${locale}` : ''}`,
+    `Updating document in collection: ${slug}${id ? ` with ID: ${id}` : ' with where clause'}, draft: ${draft}${locale ? `, locale: ${locale}` : ''}`,
   )
 
   try {
-    if (!id && !where) {
-      return {
-        content: [{ type: 'text', text: 'Error: Either id or where clause must be provided' }],
-      }
-    }
-
-    const virtualFieldNames = getCollectionVirtualFieldNames(payload.config, collectionSlug)
+    const virtualFieldNames = getCollectionVirtualFieldNames(payload.config, slug)
     const inputData = stripVirtualFields(data, virtualFieldNames)
-    const validationError = validateCollectionData({
-      collectionSlug,
+    validateCollectionData({
+      slug,
       data: inputData,
       partial: true,
       req,
     })
 
-    if (validationError) {
-      return validationError
-    }
-
     const parsedData = transformPointDataToPayload(inputData)
-    const file = await resolveFileInput({ collectionSlug, input: fileInput, req })
+    const file = await resolveFile({ slug, input: fileInput, req })
 
     const whereClause: Where = where ?? {}
 
-    if (id) {
+    if (id !== undefined) {
       const result = await payload.update({
-        id,
-        collection: collectionSlug,
+        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 } : {}),
-        ...(overwriteExistingFiles ? { overwriteExistingFiles } : {}),
-        ...(publishAllLocales !== undefined ? { publishAllLocales } : {}),
-        ...(locale ? { locale } : {}),
-        ...(fallbackLocale ? { fallbackLocale } : {}),
-        ...(select ? { select: select as SelectType } : {}),
       })
 
+      const responseResult = returning ? result : { id: result.id }
+
       return {
         content: [
           {
             type: 'text',
-            text: `Document updated successfully in collection "${collectionSlug}"!\nUpdated document:\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
+            text: `Document updated successfully in collection "${slug}"!\nResult:\n\`\`\`json\n${JSON.stringify(responseResult)}\n\`\`\``,
           },
         ],
-        doc: result as Record<string, unknown>,
+        doc: responseResult as Record<string, unknown>,
       }
     }
 
     const result = await payload.update({
-      collection: collectionSlug,
+      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 } : {}),
-      ...(overwriteExistingFiles ? { overwriteExistingFiles } : {}),
-      ...(publishAllLocales !== undefined ? { publishAllLocales } : {}),
-      ...(locale ? { locale } : {}),
-      ...(fallbackLocale ? { fallbackLocale } : {}),
-      ...(select ? { select: select as SelectType } : {}),
     })
 
-    const docs = result.docs || []
+    const docs = returning ? result.docs : result.docs.map(({ id }) => ({ id }))
     const errors = result.errors || []
 
-    let responseText = `Multiple documents updated in collection "${collectionSlug}"!\nUpdated: ${docs.length} documents\nErrors: ${errors.length}\n---`
+    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, req })
+      const errorSchema = getCollectionInputSchema({ collectionSlug: slug, req })
 
       if (errorSchema) {
         responseText += `\n\nUse this schema for data:\n\`\`\`json\n${JSON.stringify(errorSchema)}\n\`\`\``
@@ -205,7 +151,7 @@ export const updateDocumentTool = defineCollectionTool({
         ...(errorSchema
           ? {
               structuredContent: {
-                collectionSlug,
+                slug,
                 docs,
                 errors,
                 schema: errorSchema,
@@ -221,7 +167,7 @@ export const updateDocumentTool = defineCollectionTool({
     }
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : 'Unknown error'
-    logger.error(`Error updating document in ${collectionSlug}: ${errorMessage}`)
-    return formatCollectionError({ action: 'updating', collectionSlug, error, req })
+    logger.error(`Error updating document in ${slug}: ${errorMessage}`)
+    return formatEntityError({ slug, action: 'updating', entity: 'collection', error, req })
   }
 })