@payloadcms/plugin-mcp 4.0.0-canary.0 → 4.0.0-canary.2

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' | '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,28 @@
+import { defineCollectionTool } from '../../../defineTool.js'
+import { getCollectionInputSchema } from '../../../utils/schemaConversion/getEntityInputSchema.js'
+
+export const getCollectionSchemaTool = defineCollectionTool({
+  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,
+    },
+  }
+})

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

@@ -1,4 +1,4 @@
-import type { SelectType } from 'payload'
+import type { SelectType, Where } from 'payload'
 
 import { z } from 'zod'
 
@@ -9,70 +9,63 @@ import {
   stripVirtualFields,
 } from '../../../utils/getVirtualFieldNames.js'
 import { localAPIDefaults } from '../../../utils/localAPIDefaults.js'
-import { prepareCollectionSchema } from '../../../utils/schemaConversion/prepareCollectionSchema.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 { formatCollectionError } from './formatCollectionError.js'
 
-const DEFAULT_DESCRIPTION = 'Update documents in a collection by ID or where clause.'
+const DEFAULT_DESCRIPTION =
+  'Update documents in any collection by passing the collection slug and data.'
 
-export const updateCollectionTool = defineCollectionTool({
+export const updateDocumentTool = defineCollectionTool({
   description: DEFAULT_DESCRIPTION,
-  input: ({ collectionSchema }) => {
-    const partialSchema = prepareCollectionSchema(collectionSchema)
-
-    // Collection updates do not require all required fields to be passed => delete .required.
-    //
-    // Local API equivalent: packages/payload/src/collections/operations/local/update.ts#BaseOptions#data:
-    // data: DeepPartial<RequiredDataFromCollectionSlug<TSlug>>
-    delete partialSchema.required
-
-    return z.object({
-      id: z.union([z.string(), z.number()]).describe('The ID of the document to update').optional(),
-      data: z
-        .fromJSONSchema(partialSchema as unknown as z.core.JSONSchema.JSONSchema)
-        .describe('The fields to update'),
-      depth: z
-        .number()
-        .describe('How many levels deep to populate relationships')
-        .optional()
-        .default(0),
-      draft: z
-        .boolean()
-        .describe('Whether to update 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(),
-      filePath: z.string().describe('File path for file uploads').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),
-      select: z
-        .string()
-        .describe(
-          'Optional: define exactly which fields you\'d like to return in the response (JSON), e.g., \'{"title": "My Post"}\'',
-        )
-        .optional(),
-      where: z
-        .string()
-        .describe('JSON string for where clause to update multiple documents')
-        .optional(),
-    })
-  },
+  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'),
+    depth: z
+      .number()
+      .describe('How many levels deep to populate relationships')
+      .optional()
+      .default(0),
+    draft: z
+      .boolean()
+      .describe('Whether to update 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(),
+    filePath: z.string().describe('File path for file uploads').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),
+    select: z
+      .string()
+      .describe(
+        "Optional: define exactly which fields you'd like to return in the response (JSON), 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 }) => {
   const payload = req.payload
   const logger = getLogger({ payload })
@@ -102,20 +95,23 @@ export const updateCollectionTool = defineCollectionTool({
       }
     }
 
-    let parsedData = transformPointDataToPayload(data as Record<string, unknown>)
     const virtualFieldNames = getCollectionVirtualFieldNames(payload.config, collectionSlug)
-    parsedData = stripVirtualFields(parsedData, virtualFieldNames)
+    const inputData = stripVirtualFields(data, virtualFieldNames)
+    const validationError = validateCollectionData({
+      collectionSlug,
+      data: inputData,
+      partial: true,
+      req,
+    })
 
-    let whereClause: Record<string, unknown> = {}
-    if (where) {
-      try {
-        whereClause = JSON.parse(where) as Record<string, unknown>
-      } catch {
-        logger.error(`Invalid where clause JSON: ${where}`)
-        return { content: [{ type: 'text', text: 'Error: Invalid JSON in where clause' }] }
-      }
+    if (validationError) {
+      return validationError
     }
 
+    const parsedData = transformPointDataToPayload(inputData)
+
+    const whereClause: Where = where ?? {}
+
     let selectClause: SelectType | undefined
     if (select) {
       try {
@@ -127,7 +123,7 @@ export const updateCollectionTool = defineCollectionTool({
     }
 
     if (id) {
-      const updateOptions = {
+      const result = await payload.update({
         id,
         collection: collectionSlug,
         data: parsedData,
@@ -141,9 +137,7 @@ export const updateCollectionTool = defineCollectionTool({
         ...(locale ? { locale } : {}),
         ...(fallbackLocale ? { fallbackLocale } : {}),
         ...(selectClause ? { select: selectClause } : {}),
-      }
-
-      const result = await payload.update(updateOptions as any)
+      })
 
       return {
         content: [
@@ -156,27 +150,24 @@ export const updateCollectionTool = defineCollectionTool({
       }
     }
 
-    const updateOptions = {
+    const result = await payload.update({
       collection: collectionSlug,
       data: parsedData,
       depth,
       draft,
       overrideLock,
       req,
-      ...localAPIDefaults(authorizedMCP),
       where: whereClause,
+      ...localAPIDefaults(authorizedMCP),
       ...(filePath ? { filePath } : {}),
       ...(overwriteExistingFiles ? { overwriteExistingFiles } : {}),
       ...(locale ? { locale } : {}),
       ...(fallbackLocale ? { fallbackLocale } : {}),
       ...(selectClause ? { select: selectClause } : {}),
-    }
-
-    const result = await payload.update(updateOptions as any)
+    })
 
-    const bulkResult = result as { docs?: unknown[]; errors?: unknown[] }
-    const docs = bulkResult.docs || []
-    const errors = bulkResult.errors || []
+    const docs = result.docs || []
+    const errors = result.errors || []
 
     let responseText = `Multiple documents updated in collection "${collectionSlug}"!\nUpdated: ${docs.length} documents\nErrors: ${errors.length}\n---`
     if (docs.length > 0) {
@@ -184,6 +175,28 @@ export const updateCollectionTool = defineCollectionTool({
     }
     if (errors.length > 0) {
       responseText += `\n\nErrors:\n\`\`\`json\n${JSON.stringify(errors)}\n\`\`\``
+
+      const errorSchema = getCollectionInputSchema({ collectionSlug, req })
+
+      if (errorSchema) {
+        responseText += `\n\nUse this schema for data:\n\`\`\`json\n${JSON.stringify(errorSchema)}\n\`\`\``
+      }
+
+      return {
+        content: [{ type: 'text', text: responseText }],
+        doc: { docs, errors } as unknown as Record<string, unknown>,
+        isError: true,
+        ...(errorSchema
+          ? {
+              structuredContent: {
+                collectionSlug,
+                docs,
+                errors,
+                schema: errorSchema,
+              },
+            }
+          : {}),
+      }
     }
 
     return {
@@ -193,13 +206,6 @@ export const updateCollectionTool = defineCollectionTool({
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : 'Unknown error'
     logger.error(`Error updating document in ${collectionSlug}: ${errorMessage}`)
-    return {
-      content: [
-        {
-          type: 'text',
-          text: `Error updating document in collection "${collectionSlug}": ${errorMessage}`,
-        },
-      ],
-    }
+    return formatCollectionError({ action: 'updating', collectionSlug, error, req })
   }
 })

package/src/mcp/builtin/getConfigInfoTool.ts

@@ -0,0 +1,44 @@
+import { getAccessResults, isEntityHidden } from 'payload'
+
+import { defineTool } from '../../defineTool.js'
+
+export const getConfigInfoTool = defineTool({
+  description: 'List the Payload collection and global slugs visible to this MCP client.',
+}).handler(async ({ authorizedMCP, req }) => {
+  const user = authorizedMCP.user ?? req.user ?? null
+  const permissions = user ? await getAccessResults({ req: { ...req, user } }) : null
+
+  const collections: string[] = []
+  const globals: string[] = []
+
+  for (const collection of req.payload.config.collections) {
+    if (user && isEntityHidden({ hidden: collection.admin.hidden, user })) {
+      continue
+    }
+    if (user && !permissions?.collections?.[collection.slug]?.read) {
+      continue
+    }
+
+    collections.push(collection.slug)
+  }
+
+  for (const global of req.payload.config.globals) {
+    if (user && isEntityHidden({ hidden: global.admin.hidden, user })) {
+      continue
+    }
+    if (user && !permissions?.globals?.[global.slug]?.read) {
+      continue
+    }
+
+    globals.push(global.slug)
+  }
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: `Collections: ${collections.join(', ') || 'none'}\nGlobals: ${globals.join(', ') || 'none'}`,
+      },
+    ],
+  }
+})

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

@@ -6,7 +6,7 @@ import { defineGlobalTool } from '../../../defineTool.js'
 import { getLogger } from '../../../utils/getLogger.js'
 import { localAPIDefaults } from '../../../utils/localAPIDefaults.js'
 
-const DEFAULT_DESCRIPTION = 'Find a Payload global singleton configuration.'
+const DEFAULT_DESCRIPTION = 'Find any Payload global by passing the global slug.'
 
 export const findGlobalTool = defineGlobalTool({
   description: DEFAULT_DESCRIPTION,

package/src/mcp/builtin/globals/getGlobalSchemaTool.ts

@@ -0,0 +1,28 @@
+import { defineGlobalTool } from '../../../defineTool.js'
+import { getGlobalInputSchema } from '../../../utils/schemaConversion/getEntityInputSchema.js'
+
+export const getGlobalSchemaTool = defineGlobalTool({
+  description: 'Get the input schema for updating a global.',
+}).handler(({ globalSlug, req }) => {
+  const inputSchema = getGlobalInputSchema({ globalSlug, req })
+
+  if (!inputSchema) {
+    return {
+      content: [{ type: 'text', text: `Error: Global "${globalSlug}" not found` }],
+      isError: true,
+    }
+  }
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: `Schema for global "${globalSlug}":\n\`\`\`json\n${JSON.stringify(inputSchema)}\n\`\`\``,
+      },
+    ],
+    structuredContent: {
+      globalSlug,
+      schema: inputSchema,
+    },
+  }
+})

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

@@ -9,52 +9,42 @@ import {
   stripVirtualFields,
 } from '../../../utils/getVirtualFieldNames.js'
 import { localAPIDefaults } from '../../../utils/localAPIDefaults.js'
-import { prepareCollectionSchema } from '../../../utils/schemaConversion/prepareCollectionSchema.js'
+import { transformPointDataToPayload } from '../../../utils/transformPointDataToPayload.js'
+import { validateGlobalData } from '../validateEntityData.js'
 
-const DEFAULT_DESCRIPTION = 'Update a Payload global singleton configuration.'
+const DEFAULT_DESCRIPTION = 'Update any Payload global by passing the global slug and data.'
 
 export const updateGlobalTool = defineGlobalTool({
   description: DEFAULT_DESCRIPTION,
-  input: ({ globalSchema }) => {
-    const partialSchema = prepareCollectionSchema(globalSchema)
-    // Global updates do not require all required fields to be passed => delete .required.
-    //
-    // Local API equivalent: packages/payload/src/global/operations/local/update.ts#BaseOptions#data:
-    // data: DeepPartial<Omit<DataFromGlobalSlug<TSlug>, 'id'>>
-    delete partialSchema.required
-
-    return z.object({
-      data: z
-        .fromJSONSchema(partialSchema as unknown as z.core.JSONSchema.JSONSchema)
-        .describe('The fields to update'),
-      depth: z
-        .number()
-        .describe('Optional: Depth of relationships to populate')
-        .optional()
-        .default(0),
-      draft: z
-        .boolean()
-        .describe('Optional: Whether to save as draft (default: false)')
-        .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 update data in (e.g., "en", "es"). Use "all" to update all locales for localized fields',
-        )
-        .optional(),
-      select: z
-        .string()
-        .describe(
-          'Optional: define exactly which fields you\'d like to return in the response (JSON), e.g., \'{"siteName": "My Site"}\'',
-        )
-        .optional(),
-    })
-  },
+  input: z.object({
+    data: z.record(z.string(), z.unknown()).describe('The global fields to update'),
+    depth: z
+      .number()
+      .describe('Optional: Depth of relationships to populate')
+      .optional()
+      .default(0),
+    draft: z
+      .boolean()
+      .describe('Optional: Whether to save as draft (default: false)')
+      .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 update data in (e.g., "en", "es"). Use "all" to update all locales for localized fields',
+      )
+      .optional(),
+    select: z
+      .string()
+      .describe(
+        "Optional: define exactly which fields you'd like to return in the response (JSON), e.g., '{\"siteName\": true}'",
+      )
+      .optional(),
+  }),
 }).handler(async ({ authorizedMCP, globalSlug, input, req }) => {
   const payload = req.payload
   const logger = getLogger({ payload })
@@ -67,7 +57,14 @@ export const updateGlobalTool = defineGlobalTool({
 
   try {
     const virtualFieldNames = getGlobalVirtualFieldNames(payload.config, globalSlug)
-    const parsedData = stripVirtualFields(data as Record<string, unknown>, virtualFieldNames)
+    const inputData = stripVirtualFields(data, virtualFieldNames)
+    const validationError = validateGlobalData({ data: inputData, globalSlug, req })
+
+    if (validationError) {
+      return validationError
+    }
+
+    const parsedData = transformPointDataToPayload(inputData)
 
     let selectClause: SelectType | undefined
     if (select) {