@payloadcms/plugin-mcp 4.0.0-internal.e16cf59 → 4.0.0-internal.fa345ef

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

@@ -0,0 +1,217 @@
+import type { JoinQuery, PopulateType, SelectType } from 'payload'
+
+import { z } from 'zod'
+
+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.collectionSlug]?.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(),
+    joins: z
+      .union([z.record(z.string(), z.unknown()), z.literal(false)])
+      .describe('Optional: configure join field queries, or pass false to disable all join fields.')
+      .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),
+    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., {"title": true}',
+      )
+      .optional(),
+    sort: z
+      .string()
+      .describe('Field to sort by (e.g., "createdAt", "-updatedAt" for descending)')
+      .optional(),
+    trash: z
+      .boolean()
+      .describe('Optional: include soft-deleted documents when trash is enabled on the collection')
+      .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 }) => {
+  const payload = req.payload
+  const logger = getLogger({ payload })
+
+  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}` : ''}`,
+  )
+
+  try {
+    if (id) {
+      try {
+        const doc = await payload.findByID({
+          id,
+          collection: collectionSlug,
+          depth,
+          req,
+          ...localAPIDefaults(authorizedMCP),
+          ...(select && { select: select as SelectType }),
+          ...(populate && { populate: populate as PopulateType }),
+          ...(joins !== undefined && { joins: joins as JoinQuery }),
+          ...(locale && { locale }),
+          ...(fallbackLocale && { fallbackLocale }),
+          ...(draft !== undefined && { draft }),
+          ...(trash !== undefined && { trash }),
+        })
+
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `Document from collection "${collectionSlug}":\n${JSON.stringify(doc)}`,
+            },
+          ],
+          doc: doc as Record<string, unknown>,
+        }
+      } catch {
+        logger.warn(`Document not found with ID: ${id} in collection: ${collectionSlug}`)
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `Error: Document with ID "${id}" not found in collection "${collectionSlug}"`,
+            },
+          ],
+        }
+      }
+    }
+
+    const findOptions: Parameters<typeof payload.find>[0] = {
+      collection: collectionSlug,
+      depth,
+      limit,
+      page,
+      req,
+      ...localAPIDefaults(authorizedMCP),
+      ...(select && { select: select as SelectType }),
+      ...(populate && { populate: populate as PopulateType }),
+      ...(joins !== undefined && { joins: joins as JoinQuery }),
+      ...(locale && { locale }),
+      ...(fallbackLocale && { fallbackLocale }),
+      ...(draft !== undefined && { draft }),
+      ...(pagination !== undefined && { pagination }),
+      ...(trash !== undefined && { trash }),
+    }
+
+    if (sort) {
+      findOptions.sort = sort
+    }
+    if (where) {
+      findOptions.where = where
+    }
+
+    const result = await payload.find(findOptions)
+
+    let responseText = `Collection: "${collectionSlug}"\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\`\`\``
+    }
+
+    return {
+      content: [{ type: 'text', text: responseText }],
+      doc: result as unknown as Record<string, unknown>,
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+    logger.error(`Error reading documents from collection ${collectionSlug}: ${errorMessage}`)
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `❌ **Error reading documents from collection "${collectionSlug}":** ${errorMessage}`,
+        },
+      ],
+    }
+  }
+})

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

@@ -0,0 +1,110 @@
+import type { PopulateType, SelectType } from 'payload'
+
+import { z } from 'zod'
+
+import { defaultAccess } from '../../../defaultAccess.js'
+import { defineCollectionTool } from '../../../defineTool.js'
+import { getLogger } from '../../../utils/getLogger.js'
+import { localAPIDefaults } from '../../../utils/localAPIDefaults.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.collectionSlug]?.readVersions),
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+    readOnlyHint: true,
+    title: 'Find Version By ID',
+  },
+  description: DEFAULT_DESCRIPTION,
+  input: z.object({
+    id: z.string().describe('The ID of the version to retrieve'),
+    depth: z
+      .number()
+      .int()
+      .min(0)
+      .max(10)
+      .describe('How many levels deep to populate relationships in the version document')
+      .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 to retrieve data in (e.g., "en", "es"). Use "all" to retrieve all locales for localized fields',
+      )
+      .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 the returned version document')
+      .optional(),
+    trash: z
+      .boolean()
+      .describe('Optional: include soft-deleted version documents when trash is enabled')
+      .optional(),
+  }),
+}).handler(async ({ authorizedMCP, collectionSlug, input, req }) => {
+  const payload = req.payload
+  const logger = getLogger({ payload })
+  const { id, depth, fallbackLocale, locale, populate, select, showHiddenFields, trash } = input
+
+  logger.info(`Finding version in collection: ${collectionSlug} with ID: ${id}`)
+
+  try {
+    const result = await payload.findVersionByID({
+      id,
+      collection: collectionSlug,
+      depth,
+      req,
+      ...localAPIDefaults(authorizedMCP),
+      ...(fallbackLocale ? { fallbackLocale } : {}),
+      ...(locale ? { locale } : {}),
+      ...(populate ? { populate: populate as PopulateType } : {}),
+      ...(select ? { select: select as SelectType } : {}),
+      ...(showHiddenFields !== undefined ? { showHiddenFields } : {}),
+      ...(trash !== undefined ? { trash } : {}),
+    })
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Version "${id}" from collection "${collectionSlug}":\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 ${collectionSlug}: ${errorMessage}`)
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `❌ **Error finding version "${id}" in collection "${collectionSlug}":** ${errorMessage}`,
+        },
+      ],
+      isError: true,
+    }
+  }
+})

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

@@ -0,0 +1,155 @@
+import type { PopulateType, SelectType } from 'payload'
+
+import { z } from 'zod'
+
+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 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),
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+    readOnlyHint: true,
+    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 }) => {
+  const payload = req.payload
+  const logger = getLogger({ payload })
+  const {
+    depth,
+    fallbackLocale,
+    limit,
+    locale,
+    page,
+    pagination,
+    populate,
+    select,
+    showHiddenFields,
+    sort,
+    trash,
+    where,
+  } = input
+
+  logger.info(`Finding versions in collection: ${collectionSlug}, limit: ${limit}, page: ${page}`)
+
+  try {
+    const result = await payload.findVersions({
+      collection: collectionSlug,
+      depth,
+      limit,
+      page,
+      req,
+      ...localAPIDefaults(authorizedMCP),
+      ...(fallbackLocale ? { fallbackLocale } : {}),
+      ...(locale ? { locale } : {}),
+      ...(pagination !== undefined ? { pagination } : {}),
+      ...(populate ? { populate: populate as PopulateType } : {}),
+      ...(select ? { select: select as SelectType } : {}),
+      ...(showHiddenFields !== undefined ? { showHiddenFields } : {}),
+      ...(sort ? { sort } : {}),
+      ...(trash !== undefined ? { trash } : {}),
+      ...(where ? { where } : {}),
+    })
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Versions for collection "${collectionSlug}":\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}`)
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `❌ **Error finding versions in collection "${collectionSlug}":** ${errorMessage}`,
+        },
+      ],
+      isError: true,
+    }
+  }
+})

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

@@ -0,0 +1,84 @@
+import type { CollectionSlug, PayloadRequest } from 'payload'
+
+import type { MCPToolResponse } from '../../../types.js'
+
+import { getCollectionInputSchema } from '../../../utils/schemaConversion/getEntityInputSchema.js'
+
+const getValidationErrors = (error: unknown): undefined | unknown[] => {
+  if (!error || typeof error !== 'object') {
+    return undefined
+  }
+
+  const data = 'data' in error ? error.data : undefined
+  if (!data || typeof data !== 'object' || !('errors' in data) || !Array.isArray(data.errors)) {
+    return undefined
+  }
+
+  return data.errors
+}
+
+const isSchemaError = (error: unknown, message: string): boolean => {
+  if (getValidationErrors(error)) {
+    return true
+  }
+
+  const name = error && typeof error === 'object' && 'name' in error ? error.name : undefined
+
+  return (
+    name === 'CastError' ||
+    name === 'ValidationError' ||
+    message.includes('Cast to ') ||
+    message.includes('validation failed')
+  )
+}
+
+export const formatCollectionError = ({
+  action,
+  collectionSlug,
+  error,
+  req,
+}: {
+  action: 'creating' | 'duplicating' | 'updating'
+  collectionSlug: CollectionSlug
+  error: unknown
+  req: PayloadRequest
+}): MCPToolResponse => {
+  const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+  const errors = getValidationErrors(error) ?? [{ message: errorMessage }]
+
+  if (!isSchemaError(error, errorMessage)) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Error ${action} document in collection "${collectionSlug}": ${errorMessage}`,
+        },
+      ],
+      isError: true,
+    }
+  }
+
+  const schema = getCollectionInputSchema({ collectionSlug, req })
+  const schemaText = schema
+    ? `\n\nUse this schema for data:\n\`\`\`json\n${JSON.stringify(schema)}\n\`\`\``
+    : ''
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: `Error ${action} document in collection "${collectionSlug}": ${errorMessage}${schemaText}`,
+      },
+    ],
+    isError: true,
+    ...(schema
+      ? {
+          structuredContent: {
+            collectionSlug,
+            errors,
+            schema,
+          },
+        }
+      : {}),
+  }
+}

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

@@ -0,0 +1,46 @@
+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]
+
+    return (
+      defaultAccess(args) &&
+      Boolean(
+        permissions?.create || permissions?.delete || permissions?.read || 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 })
+
+  if (!inputSchema) {
+    return {
+      content: [{ type: 'text', text: `Error: Collection "${collectionSlug}" not found` }],
+      isError: true,
+    }
+  }
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: `Schema for collection "${collectionSlug}":\n\`\`\`json\n${JSON.stringify(inputSchema)}\n\`\`\``,
+      },
+    ],
+    structuredContent: {
+      collectionSlug,
+      schema: inputSchema,
+    },
+  }
+})