@payloadcms/plugin-mcp 4.0.0-internal.40de3ec → 4.0.0-internal.41055b1

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

@@ -2,57 +2,69 @@ import type { SelectType } from 'payload'
 
 import { z } from 'zod'
 
+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 { buildToolInput } from '../../../utils/schemaConversion/buildToolInput.js'
-import { sanitizeEntitySchema } from '../../../utils/schemaConversion/sanitizeEntitySchema.js'
 import { transformPointDataToPayload } from '../../../utils/transformPointDataToPayload.js'
+import { validateCollectionData } from '../validateEntityData.js'
+import { formatCollectionError } from './formatCollectionError.js'
 
-const DEFAULT_DESCRIPTION = 'Create a document in a collection.'
+const DEFAULT_DESCRIPTION =
+  'Create a document in any collection by passing the collection slug and data.'
 
-export const createCollectionTool = defineCollectionTool({
+export const createDocumentTool = defineCollectionTool({
+  access: (args) =>
+    defaultAccess(args) && Boolean(args.permissions?.collections?.[args.collectionSlug]?.create),
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: false,
+    readOnlyHint: false,
+    title: 'Create Document',
+  },
   description: DEFAULT_DESCRIPTION,
-  input: ({ collectionSchema }) =>
-    buildToolInput({
-      controls: {
-        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
-          .string()
-          .describe(
-            'Optional: define exactly which fields you\'d like to create (JSON), e.g., \'{"title": "My Post"}\'',
-          )
-          .optional(),
-      },
-      dataDescription: 'The document fields to create',
-      dataSchema: sanitizeEntitySchema(collectionSchema),
-    }),
+  input: 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.',
+      ),
+    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(
+        '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 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 }) => {
   const payload = req.payload
   const logger = getLogger({ payload })
@@ -64,30 +76,26 @@ export const createCollectionTool = defineCollectionTool({
   )
 
   try {
-    let parsedData = transformPointDataToPayload(data)
     const virtualFieldNames = getCollectionVirtualFieldNames(payload.config, collectionSlug)
-    parsedData = stripVirtualFields(parsedData, virtualFieldNames)
+    const inputData = stripVirtualFields(data, virtualFieldNames)
+    const validationError = validateCollectionData({ collectionSlug, data: inputData, req })
 
-    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 (validationError) {
+      return validationError
     }
 
+    const parsedData = transformPointDataToPayload(inputData)
+
     const result = await payload.create({
       collection: collectionSlug,
       data: parsedData,
       depth,
       draft,
+      overrideAccess: authorizedMCP.overrideAccess,
       req,
-      ...localAPIDefaults(authorizedMCP),
       ...(locale ? { locale } : {}),
       ...(fallbackLocale ? { fallbackLocale } : {}),
-      ...(selectClause ? { select: selectClause } : {}),
+      ...(select ? { select: select as SelectType } : {}),
     })
 
     logger.info(`Successfully created document in ${collectionSlug} with ID: ${result.id}`)
@@ -104,13 +112,6 @@ export const createCollectionTool = defineCollectionTool({
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : 'Unknown error'
     logger.error(`Error creating document in ${collectionSlug}: ${errorMessage}`)
-    return {
-      content: [
-        {
-          type: 'text',
-          text: `Error creating document in collection "${collectionSlug}": ${errorMessage}`,
-        },
-      ],
-    }
+    return formatCollectionError({ action: 'creating', collectionSlug, error, req })
   }
 })

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

@@ -1,12 +1,23 @@
 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 = 'Delete documents in a collection by ID or where clause.'
+const DEFAULT_DESCRIPTION =
+  'Delete documents in any collection by passing the collection slug and ID or where clause.'
 
-export const deleteCollectionTool = defineCollectionTool({
+export const deleteDocumentsTool = defineCollectionTool({
+  access: (args) =>
+    defaultAccess(args) && Boolean(args.permissions?.collections?.[args.collectionSlug]?.delete),
+  annotations: {
+    destructiveHint: true,
+    idempotentHint: false,
+    openWorldHint: false,
+    readOnlyHint: false,
+    title: 'Delete Documents',
+  },
   description: DEFAULT_DESCRIPTION,
   input: z.object({
     id: z
@@ -31,9 +42,10 @@ export const deleteCollectionTool = defineCollectionTool({
         'Optional: locale code for the operation (e.g., "en", "es"). Defaults to the default locale',
       )
       .optional(),
-    where: z
-      .string()
-      .describe('Optional: JSON string for where clause to delete multiple documents')
+    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 }) => {
@@ -53,21 +65,11 @@ export const deleteCollectionTool = defineCollectionTool({
       }
     }
 
-    let whereClause: Record<string, unknown> = {}
-    if (where) {
-      try {
-        whereClause = JSON.parse(where) as Record<string, unknown>
-      } catch {
-        logger.warn(`Invalid where clause JSON: ${where}`)
-        return { content: [{ type: 'text', text: 'Error: Invalid JSON in where clause' }] }
-      }
-    }
-
     const deleteOptions: Record<string, unknown> = {
       collection: collectionSlug,
       depth,
+      overrideAccess: authorizedMCP.overrideAccess,
       req,
-      ...localAPIDefaults(authorizedMCP),
       ...(locale && { locale }),
       ...(fallbackLocale && { fallbackLocale }),
     }
@@ -75,7 +77,7 @@ export const deleteCollectionTool = defineCollectionTool({
     if (id) {
       deleteOptions.id = id
     } else {
-      deleteOptions.where = whereClause
+      deleteOptions.where = where
     }
 
     const result = await payload.delete(deleteOptions as Parameters<typeof payload.delete>[0])

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

@@ -0,0 +1,134 @@
+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 {
+  getCollectionVirtualFieldNames,
+  stripVirtualFields,
+} from '../../../utils/getVirtualFieldNames.js'
+import { transformPointDataToPayload } from '../../../utils/transformPointDataToPayload.js'
+import { formatCollectionError } from './formatCollectionError.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),
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: false,
+    readOnlyHint: false,
+    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 }) => {
+  const payload = req.payload
+  const logger = getLogger({ payload })
+  const {
+    id,
+    data,
+    depth,
+    draft,
+    fallbackLocale,
+    locale,
+    populate,
+    select,
+    selectedLocales,
+    showHiddenFields,
+  } = input
+
+  logger.info(`Duplicating document in collection: ${collectionSlug} with ID: ${id}`)
+
+  try {
+    const virtualFieldNames = getCollectionVirtualFieldNames(payload.config, collectionSlug)
+    const inputData = data ? stripVirtualFields(data, virtualFieldNames) : undefined
+    const parsedData = inputData ? transformPointDataToPayload(inputData) : undefined
+
+    const result = await payload.duplicate({
+      id,
+      collection: collectionSlug,
+      depth,
+      draft,
+      overrideAccess: authorizedMCP.overrideAccess,
+      req,
+      ...(parsedData ? { data: parsedData } : {}),
+      ...(locale ? { locale } : {}),
+      ...(fallbackLocale ? { fallbackLocale } : {}),
+      ...(populate ? { populate: populate as PopulateType } : {}),
+      ...(select ? { select: select as SelectType } : {}),
+      ...(selectedLocales ? { selectedLocales } : {}),
+      ...(showHiddenFields !== undefined ? { showHiddenFields } : {}),
+    })
+
+    logger.info(`Successfully duplicated document in ${collectionSlug} from ID: ${id}`)
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Document duplicated successfully in collection "${collectionSlug}"!\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 })
+  }
+})

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

@@ -0,0 +1,119 @@
+import type { PopulateType } from 'payload'
+
+import { z } from 'zod'
+
+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 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.collectionSlug]?.read),
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+    readOnlyHint: true,
+    title: 'Find Distinct',
+  },
+  description: DEFAULT_DESCRIPTION,
+  input: z.object({
+    depth: z
+      .number()
+      .int()
+      .min(0)
+      .max(10)
+      .describe('How many levels deep to populate relationships in distinct values')
+      .optional()
+      .default(0),
+    field: z.string().describe('The field path to get distinct values for'),
+    limit: z
+      .number()
+      .int()
+      .min(1)
+      .max(100)
+      .describe('Maximum number of distinct values to return (max: 100)')
+      .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(),
+    page: z.number().int().min(1).describe('Page number for pagination').optional(),
+    populate: z
+      .record(z.string(), z.unknown())
+      .describe(
+        'Optional: control which fields to include from populated relationship or upload documents.',
+      )
+      .optional(),
+    showHiddenFields: z
+      .boolean()
+      .describe('Optional: include hidden fields in the distinct query')
+      .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 { depth, field, limit, locale, page, populate, showHiddenFields, sort, trash, where } =
+    input
+
+  logger.info(`Finding distinct values in collection: ${collectionSlug}, field: ${field}`)
+
+  try {
+    const result = await payload.findDistinct({
+      collection: collectionSlug,
+      depth,
+      field,
+      overrideAccess: authorizedMCP.overrideAccess,
+      req,
+      ...(limit ? { limit } : {}),
+      ...(locale ? { locale } : {}),
+      ...(page ? { page } : {}),
+      ...(populate ? { populate: populate as PopulateType } : {}),
+      ...(showHiddenFields !== undefined ? { showHiddenFields } : {}),
+      ...(sort ? { sort } : {}),
+      ...(trash !== undefined ? { trash } : {}),
+      ...(where ? { where } : {}),
+    })
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Distinct values for "${field}" in 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 distinct values in ${collectionSlug}: ${errorMessage}`)
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `❌ **Error finding distinct values in collection "${collectionSlug}":** ${errorMessage}`,
+        },
+      ],
+      isError: true,
+    }
+  }
+})

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

@@ -1,15 +1,25 @@
-import type { SelectType } from 'payload'
+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 a collection by ID or where clause using Find or FindByID.'
+  'Find documents in any collection by passing the collection slug and optional ID or where clause.'
 
-export const findCollectionTool = defineCollectionTool({
+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
@@ -29,13 +39,17 @@ export const findCollectionTool = defineCollectionTool({
     draft: z
       .boolean()
       .describe(
-        'Optional: whether the document should be queried from the versions table/collection or not.',
+        'For versioned collections, true returns the latest draft version when available. False reads the main document.',
       )
       .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()
@@ -57,20 +71,33 @@ export const findCollectionTool = defineCollectionTool({
       .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
-      .string()
+      .record(z.string(), z.unknown())
       .describe(
-        "Optional: define exactly which fields you'd like to return in the response (JSON), e.g., '{\"title\": true}'",
+        '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(),
-    where: z
-      .string()
+    trash: z
+      .boolean()
+      .describe('Optional: include soft-deleted documents when trash is enabled on the collection')
+      .optional(),
+    where: whereSchema
       .describe(
-        'Optional JSON string for where clause filtering (e.g., \'{"title": {"contains": "test"}}\')',
+        'Optional: where clause for filtering. Use field names with Payload operators, and/or arrays for grouping. Example: {"title":{"contains":"test"}}',
       )
       .optional(),
   }),
@@ -78,45 +105,43 @@ export const findCollectionTool = defineCollectionTool({
   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}` : ''}`,
   )
 
   try {
-    let whereClause: Record<string, unknown> = {}
-    if (where) {
-      try {
-        whereClause = JSON.parse(where) as Record<string, unknown>
-      } catch {
-        logger.warn(`Invalid where clause JSON: ${where}`)
-        return { content: [{ type: 'text', text: 'Error: Invalid JSON in where clause' }] }
-      }
-    }
-
-    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) {
       try {
         const doc = await payload.findByID({
           id,
           collection: collectionSlug,
           depth,
+          overrideAccess: authorizedMCP.overrideAccess,
           req,
-          ...localAPIDefaults(authorizedMCP),
-          ...(selectClause && { select: selectClause }),
+          ...(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 {
@@ -145,20 +170,24 @@ export const findCollectionTool = defineCollectionTool({
       collection: collectionSlug,
       depth,
       limit,
+      overrideAccess: authorizedMCP.overrideAccess,
       page,
       req,
-      ...localAPIDefaults(authorizedMCP),
-      ...(selectClause && { select: selectClause }),
+      ...(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 (Object.keys(whereClause).length > 0) {
-      findOptions.where = whereClause as Parameters<typeof payload.find>[0]['where']
+    if (where) {
+      findOptions.where = where
     }
 
     const result = await payload.find(findOptions)