@payloadcms/plugin-mcp 4.0.0-internal.688c4d0 → 4.0.0-internal.77191e5

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

@@ -0,0 +1,127 @@
+import type { CollectionSlug, File, PayloadRequest } from 'payload'
+
+import { APIError, z } from 'payload'
+import {
+  externalURLInputSchema,
+  getFileFromUploadInstructions,
+  resolveURLUploadInput,
+} from 'payload/internal'
+import { sanitizeFilename } from 'payload/shared'
+
+const mimeTypeSchema = z
+  .string()
+  .check(
+    z.regex(
+      /^[!#$%&'*+.^`|~\w-]+\/[!#$%&'*+.^`|~\w-]+$/,
+      'MIME type must use the type/subtype format',
+    ),
+  )
+
+const uploadFileSchema = z.strictObject({
+  filename: z.string(),
+  mimeType: z.string(),
+  size: z.int().check(z.nonnegative()),
+  uploadReference: z.record(z.string(), z.unknown()),
+})
+
+export const fileInputSchema = z
+  .discriminatedUnion('source', [
+    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'),
+    }),
+    externalURLInputSchema,
+    z.strictObject({
+      file: uploadFileSchema.check(z.describe('getUploadInstructions file field post-upload.')),
+      source: z.literal('uploadReference'),
+    }),
+  ])
+  .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({
+  slug,
+  input,
+  req,
+}: {
+  input?: FileInput
+  req: PayloadRequest
+  slug: CollectionSlug
+}): Promise<File | undefined> {
+  if (!input) {
+    return undefined
+  }
+
+  if (input.source === 'uploadReference') {
+    try {
+      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(
+          'Staged upload not found. Complete the upload action first, or use base64 for small local files.',
+          400,
+        )
+      }
+      throw error
+    }
+  }
+
+  if (input.source === 'externalURL') {
+    return resolveURLUploadInput({ slug, input, req })
+  }
+
+  const uploadConfig = req.payload.collections[slug]?.config.upload
+
+  if (!uploadConfig) {
+    throw new APIError(`Collection "${slug}" does not support file uploads.`, 400)
+  }
+
+  const maxFileSize = req.payload.config.upload.limits?.fileSize
+  const data = decodeBase64({ maxFileSize, value: input.data })
+  const file: File = {
+    name: sanitizeFilename(input.name),
+    data,
+    mimetype: input.mimeType,
+    size: data.length,
+  }
+
+  if (maxFileSize !== undefined && Number.isFinite(maxFileSize) && file.size > maxFileSize) {
+    throw new APIError(`File exceeds the ${maxFileSize} byte upload limit.`, 400)
+  }
+
+  return file
+}
+
+function decodeBase64({ maxFileSize, value }: { maxFileSize?: number; value: string }): Buffer {
+  const normalized = value.replace(/\s/g, '')
+
+  if (!/^[a-z0-9+/]*={0,2}$/i.test(normalized) || normalized.length % 4 === 1) {
+    throw new APIError('File data must be valid base64.', 400)
+  }
+
+  if (maxFileSize !== undefined && Number.isFinite(maxFileSize)) {
+    const paddingLength = normalized.endsWith('==') ? 2 : normalized.endsWith('=') ? 1 : 0
+    const decodedSize = Math.floor((normalized.length * 3) / 4) - paddingLength
+
+    if (decodedSize > maxFileSize) {
+      throw new APIError(`File exceeds the ${maxFileSize} byte upload limit.`, 400)
+    }
+  }
+
+  const data = Buffer.from(normalized, 'base64')
+
+  if (data.toString('base64').replace(/=+$/, '') !== normalized.replace(/=+$/, '')) {
+    throw new APIError('File data must be valid base64.', 400)
+  }
+
+  return data
+}

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

@@ -0,0 +1,67 @@
+import { findDistinctInputSchema } from 'payload'
+
+import { defaultAccess } from '../../../defaultAccess.js'
+import { defineCollectionTool } from '../../../defineTool.js'
+import { getLogger } from '../../../utils/getLogger.js'
+
+const DEFAULT_DESCRIPTION =
+  'Find distinct values for a field in any collection by passing the collection slug and field path.'
+
+export const findDistinctTool = defineCollectionTool({
+  access: (args) =>
+    defaultAccess(args) && Boolean(args.permissions?.collections?.[args.slug]?.read),
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+    readOnlyHint: true,
+    title: 'Find Distinct',
+  },
+  description: DEFAULT_DESCRIPTION,
+  input: findDistinctInputSchema,
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
+  const payload = req.payload
+  const logger = getLogger({ payload })
+  const { depth, field, limit, locale, page, populate, sort, trash, where } = input
+
+  logger.info(`Finding distinct values in collection: ${slug}, field: ${field}`)
+
+  try {
+    const result = await payload.findDistinct({
+      collection: slug,
+      depth,
+      field,
+      overrideAccess: authorizedMCP.overrideAccess,
+      req,
+      ...(limit ? { limit } : {}),
+      ...(locale ? { locale } : {}),
+      ...(page ? { page } : {}),
+      ...(populate ? { populate } : {}),
+      ...(sort ? { sort } : {}),
+      ...(trash !== undefined ? { trash } : {}),
+      ...(where ? { where } : {}),
+    })
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Distinct values for "${field}" in 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 distinct values in ${slug}: ${errorMessage}`)
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `❌ **Error finding distinct values in collection "${slug}":** ${errorMessage}`,
+        },
+      ],
+      isError: true,
+    }
+  }
+})

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

@@ -1,130 +1,83 @@
-import type { SelectType } from 'payload'
-
-import { z } from 'zod'
+import { findDocumentsInputSchema, 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 =
   'Find documents in any collection by passing the collection slug and optional ID or where clause.'
 
 export const findDocumentsTool = defineCollectionTool({
+  access: (args) =>
+    defaultAccess(args) && Boolean(args.permissions?.collections?.[args.slug]?.read),
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+    readOnlyHint: true,
+    title: 'Find Documents',
+  },
   description: DEFAULT_DESCRIPTION,
-  input: z.object({
-    id: z
-      .union([z.string(), z.number()])
-      .describe(
-        'Optional: specific document ID to retrieve. If not provided, returns all documents',
-      )
-      .optional(),
-    depth: z
-      .number()
-      .int()
-      .min(0)
-      .max(10)
-      .describe('How many levels deep to populate relationships (default: 0)')
-      .optional()
-      .default(0),
-    draft: z
-      .boolean()
-      .describe(
-        'Optional: whether the document should be queried from the versions table/collection or not.',
-      )
-      .optional(),
-    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 documents 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),
-    select: z
-      .string()
-      .describe(
-        "Optional: define exactly which fields you'd like to return in the response (JSON), e.g., '{\"title\": true}'",
-      )
-      .optional(),
-    sort: z
-      .string()
-      .describe('Field to sort by (e.g., "createdAt", "-updatedAt" for descending)')
-      .optional(),
-    where: whereSchema
-      .describe(
-        'Optional: where clause for filtering. Use field names with Payload operators, and/or arrays for grouping. Example: {"title":{"contains":"test"}}',
-      )
-      .optional(),
-  }),
-}).handler(async ({ authorizedMCP, collectionSlug, input, req }) => {
+  input: findDocumentsInputSchema,
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
   const payload = req.payload
   const logger = getLogger({ payload })
 
-  const { id, depth, draft, fallbackLocale, limit, locale, page, select, sort, where } = input
+  const {
+    id,
+    depth,
+    draft,
+    fallbackLocale,
+    joins,
+    limit,
+    locale,
+    page,
+    pagination,
+    populate,
+    select,
+    sort,
+    trash,
+    where,
+  } = input
 
   logger.info(
-    `Reading document from collection: ${collectionSlug}${id ? ` with ID: ${id}` : ''}, limit: ${limit}, page: ${page}${locale ? `, locale: ${locale}` : ''}`,
+    `Reading document from collection: ${slug}${id ? ` with ID: ${id}` : ''}, limit: ${limit}, page: ${page}${locale ? `, locale: ${locale}` : ''}`,
   )
 
   try {
-    let selectClause: SelectType | undefined
-    if (select) {
-      try {
-        selectClause = JSON.parse(select) as SelectType
-      } catch {
-        logger.warn(`Invalid select clause JSON: ${select}`)
-        return { content: [{ type: 'text', text: 'Error: Invalid JSON in select clause' }] }
-      }
-    }
-
-    if (id) {
+    if (id !== undefined) {
       try {
         const doc = await payload.findByID({
-          id,
-          collection: collectionSlug,
+          id: parseDocumentID({ id, collectionSlug: slug, payload }),
+          collection: slug,
           depth,
+          overrideAccess: authorizedMCP.overrideAccess,
           req,
-          ...localAPIDefaults(authorizedMCP),
-          ...(selectClause && { select: selectClause }),
+          ...(select && { select }),
+          ...(populate && { populate }),
+          ...(joins !== undefined && { joins }),
           ...(locale && { locale }),
-          ...(fallbackLocale && { fallbackLocale }),
+          ...(fallbackLocale !== undefined && { fallbackLocale }),
           ...(draft !== undefined && { draft }),
+          ...(trash !== undefined && { trash }),
         })
 
         return {
           content: [
             {
               type: 'text',
-              text: `Document from collection "${collectionSlug}":\n${JSON.stringify(doc)}`,
+              text: `Document from collection "${slug}":\n${JSON.stringify(doc)}`,
             },
           ],
           doc: doc as Record<string, unknown>,
         }
       } catch {
-        logger.warn(`Document not found with ID: ${id} in collection: ${collectionSlug}`)
+        logger.warn(`Document not found with ID: ${id} in collection: ${slug}`)
         return {
           content: [
             {
               type: 'text',
-              text: `Error: Document with ID "${id}" not found in collection "${collectionSlug}"`,
+              text: `Error: Document with ID "${id}" not found in collection "${slug}"`,
             },
           ],
         }
@@ -132,16 +85,20 @@ export const findDocumentsTool = defineCollectionTool({
     }
 
     const findOptions: Parameters<typeof payload.find>[0] = {
-      collection: collectionSlug,
+      collection: slug,
       depth,
       limit,
+      overrideAccess: authorizedMCP.overrideAccess,
       page,
       req,
-      ...localAPIDefaults(authorizedMCP),
-      ...(selectClause && { select: selectClause }),
+      ...(select && { select }),
+      ...(populate && { populate }),
+      ...(joins !== undefined && { joins }),
       ...(locale && { locale }),
-      ...(fallbackLocale && { fallbackLocale }),
+      ...(fallbackLocale !== undefined && { fallbackLocale }),
       ...(draft !== undefined && { draft }),
+      ...(pagination !== undefined && { pagination }),
+      ...(trash !== undefined && { trash }),
     }
 
     if (sort) {
@@ -153,7 +110,7 @@ export const findDocumentsTool = defineCollectionTool({
 
     const result = await payload.find(findOptions)
 
-    let responseText = `Collection: "${collectionSlug}"\nTotal: ${result.totalDocs} documents\nPage: ${result.page} of ${result.totalPages}\n`
+    let responseText = `Collection: "${slug}"\nTotal: ${result.totalDocs} documents\nPage: ${result.page} of ${result.totalPages}\n`
     for (const doc of result.docs) {
       responseText += `\n\`\`\`json\n${JSON.stringify(doc)}\n\`\`\``
     }
@@ -164,12 +121,12 @@ export const findDocumentsTool = defineCollectionTool({
     }
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : 'Unknown error'
-    logger.error(`Error reading documents from collection ${collectionSlug}: ${errorMessage}`)
+    logger.error(`Error reading documents from collection ${slug}: ${errorMessage}`)
     return {
       content: [
         {
           type: 'text',
-          text: `❌ **Error reading documents from collection "${collectionSlug}":** ${errorMessage}`,
+          text: `❌ **Error reading documents from collection "${slug}":** ${errorMessage}`,
         },
       ],
     }

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

@@ -0,0 +1,66 @@
+import { findVersionByIDInputSchema } from 'payload'
+
+import { defaultAccess } from '../../../defaultAccess.js'
+import { defineCollectionTool } from '../../../defineTool.js'
+import { getLogger } from '../../../utils/getLogger.js'
+
+const DEFAULT_DESCRIPTION =
+  'Find a specific document version in any version-enabled collection by passing the collection slug and version ID.'
+
+export const findVersionByIDTool = defineCollectionTool({
+  access: (args) =>
+    defaultAccess(args) && Boolean(args.permissions?.collections?.[args.slug]?.readVersions),
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+    readOnlyHint: true,
+    title: 'Find Version By ID',
+  },
+  description: DEFAULT_DESCRIPTION,
+  input: findVersionByIDInputSchema,
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
+  const payload = req.payload
+  const logger = getLogger({ payload })
+  const { id, depth, draft, fallbackLocale, locale, populate, select, trash } = input
+
+  logger.info(`Finding version in collection: ${slug} with ID: ${id}`)
+
+  try {
+    const result = await payload.findVersionByID({
+      id: String(id),
+      collection: slug,
+      depth,
+      overrideAccess: authorizedMCP.overrideAccess,
+      req,
+      ...(draft !== undefined ? { draft } : {}),
+      ...(fallbackLocale !== undefined ? { fallbackLocale } : {}),
+      ...(locale ? { locale } : {}),
+      ...(populate ? { populate } : {}),
+      ...(select ? { select } : {}),
+      ...(trash !== undefined ? { trash } : {}),
+    })
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Version "${id}" from 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 version ${id} in ${slug}: ${errorMessage}`)
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `❌ **Error finding version "${id}" in collection "${slug}":** ${errorMessage}`,
+        },
+      ],
+      isError: true,
+    }
+  }
+})

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

@@ -0,0 +1,83 @@
+import { findVersionsInputSchema } from 'payload'
+
+import { defaultAccess } from '../../../defaultAccess.js'
+import { defineCollectionTool } from '../../../defineTool.js'
+import { getLogger } from '../../../utils/getLogger.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.slug]?.readVersions),
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+    readOnlyHint: true,
+    title: 'Find Versions',
+  },
+  description: DEFAULT_DESCRIPTION,
+  input: findVersionsInputSchema,
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
+  const payload = req.payload
+  const logger = getLogger({ payload })
+  const {
+    depth,
+    draft,
+    fallbackLocale,
+    limit,
+    locale,
+    page,
+    pagination,
+    populate,
+    select,
+    sort,
+    trash,
+    where,
+  } = input
+
+  logger.info(`Finding versions in collection: ${slug}, limit: ${limit}, page: ${page}`)
+
+  try {
+    const result = await payload.findVersions({
+      collection: slug,
+      depth,
+      limit,
+      overrideAccess: authorizedMCP.overrideAccess,
+      page,
+      req,
+      ...(draft !== undefined ? { draft } : {}),
+      ...(fallbackLocale !== undefined ? { fallbackLocale } : {}),
+      ...(locale ? { locale } : {}),
+      ...(pagination !== undefined ? { pagination } : {}),
+      ...(populate ? { populate } : {}),
+      ...(select ? { select } : {}),
+      ...(sort ? { sort } : {}),
+      ...(trash !== undefined ? { trash } : {}),
+      ...(where ? { where } : {}),
+    })
+
+    return {
+      content: [
+        {
+          type: 'text',
+          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 ${slug}: ${errorMessage}`)
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `❌ **Error finding versions in collection "${slug}":** ${errorMessage}`,
+        },
+      ],
+      isError: true,
+    }
+  }
+})

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

@@ -1,28 +1,80 @@
+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.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 for creating or updating documents in a collection.',
-}).handler(({ collectionSlug, req }) => {
-  const inputSchema = getCollectionInputSchema({ collectionSlug, req })
+  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 "${collectionSlug}" not found` }],
+      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 }
+
   return {
     content: [
       {
         type: 'text',
-        text: `Schema for collection "${collectionSlug}":\n\`\`\`json\n${JSON.stringify(inputSchema)}\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,
     },
   }
 })