@payloadcms/plugin-mcp 3.86.0-internal.ac46214 → 4.0.0-canary.1

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

@@ -0,0 +1,211 @@
+import type { SelectType, Where } from 'payload'
+
+import { z } from 'zod'
+
+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 { 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 any collection by passing the collection slug and data.'
+
+export const updateDocumentTool = defineCollectionTool({
+  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'),
+    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 })
+
+  const {
+    id,
+    data,
+    depth,
+    draft,
+    fallbackLocale,
+    filePath,
+    locale,
+    overrideLock,
+    overwriteExistingFiles,
+    select,
+    where,
+  } = input
+
+  logger.info(
+    `Updating document in collection: ${collectionSlug}${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 inputData = stripVirtualFields(data, virtualFieldNames)
+    const validationError = validateCollectionData({
+      collectionSlug,
+      data: inputData,
+      partial: true,
+      req,
+    })
+
+    if (validationError) {
+      return validationError
+    }
+
+    const parsedData = transformPointDataToPayload(inputData)
+
+    const whereClause: Where = where ?? {}
+
+    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) {
+      const result = await payload.update({
+        id,
+        collection: collectionSlug,
+        data: parsedData,
+        depth,
+        draft,
+        overrideLock,
+        req,
+        ...localAPIDefaults(authorizedMCP),
+        ...(filePath ? { filePath } : {}),
+        ...(overwriteExistingFiles ? { overwriteExistingFiles } : {}),
+        ...(locale ? { locale } : {}),
+        ...(fallbackLocale ? { fallbackLocale } : {}),
+        ...(selectClause ? { select: selectClause } : {}),
+      })
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `Document updated successfully in collection "${collectionSlug}"!\nUpdated document:\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
+          },
+        ],
+        doc: result as Record<string, unknown>,
+      }
+    }
+
+    const result = await payload.update({
+      collection: collectionSlug,
+      data: parsedData,
+      depth,
+      draft,
+      overrideLock,
+      req,
+      where: whereClause,
+      ...localAPIDefaults(authorizedMCP),
+      ...(filePath ? { filePath } : {}),
+      ...(overwriteExistingFiles ? { overwriteExistingFiles } : {}),
+      ...(locale ? { locale } : {}),
+      ...(fallbackLocale ? { fallbackLocale } : {}),
+      ...(selectClause ? { select: selectClause } : {}),
+    })
+
+    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) {
+      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 })
+
+      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 {
+      content: [{ type: 'text', text: responseText }],
+      doc: { docs, errors } as unknown as Record<string, unknown>,
+    }
+  } 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 })
+  }
+})

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

@@ -0,0 +1,96 @@
+import type { SelectType } from 'payload'
+
+import { z } from 'zod'
+
+import { defineGlobalTool } from '../../../defineTool.js'
+import { getLogger } from '../../../utils/getLogger.js'
+import { localAPIDefaults } from '../../../utils/localAPIDefaults.js'
+
+const DEFAULT_DESCRIPTION = 'Find any Payload global by passing the global slug.'
+
+export const findGlobalTool = defineGlobalTool({
+  description: DEFAULT_DESCRIPTION,
+  input: z.object({
+    depth: z
+      .number()
+      .int()
+      .min(0)
+      .max(10)
+      .describe('Depth of population for relationships')
+      .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(),
+    select: z
+      .string()
+      .describe(
+        "Optional: define exactly which fields you'd like to return in the response (JSON), e.g., '{\"title\": true}'",
+      )
+      .optional(),
+  }),
+}).handler(async ({ authorizedMCP, globalSlug, input, req }) => {
+  const payload = req.payload
+  const logger = getLogger({ payload })
+
+  const { depth, fallbackLocale, locale, select } = input
+
+  logger.info(
+    `Reading global: ${globalSlug}, depth: ${depth}${locale ? `, locale: ${locale}` : ''}`,
+  )
+
+  try {
+    const findOptions: Parameters<typeof payload.findGlobal>[0] = {
+      slug: globalSlug,
+      depth,
+      ...localAPIDefaults(authorizedMCP),
+    }
+
+    let selectClause: SelectType | undefined
+    if (select) {
+      try {
+        selectClause = JSON.parse(select) as SelectType
+      } catch {
+        logger.warn(`Invalid select clause JSON for global: ${select}`)
+        return { content: [{ type: 'text', text: 'Error: Invalid JSON in select clause' }] }
+      }
+    }
+
+    if (locale) {
+      findOptions.locale = locale
+    }
+    if (fallbackLocale) {
+      findOptions.fallbackLocale = fallbackLocale
+    }
+    if (selectClause) {
+      findOptions.select = selectClause
+    }
+
+    const result = await payload.findGlobal(findOptions)
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Global "${globalSlug}":\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 reading global ${globalSlug}: ${errorMessage}`)
+    return {
+      content: [
+        { type: 'text', text: `❌ **Error reading global "${globalSlug}":** ${errorMessage}` },
+      ],
+    }
+  }
+})

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

@@ -0,0 +1,115 @@
+import type { SelectType } from 'payload'
+
+import { z } from 'zod'
+
+import { defineGlobalTool } from '../../../defineTool.js'
+import { getLogger } from '../../../utils/getLogger.js'
+import {
+  getGlobalVirtualFieldNames,
+  stripVirtualFields,
+} from '../../../utils/getVirtualFieldNames.js'
+import { localAPIDefaults } from '../../../utils/localAPIDefaults.js'
+import { transformPointDataToPayload } from '../../../utils/transformPointDataToPayload.js'
+import { validateGlobalData } from '../validateEntityData.js'
+
+const DEFAULT_DESCRIPTION = 'Update any Payload global by passing the global slug and data.'
+
+export const updateGlobalTool = defineGlobalTool({
+  description: DEFAULT_DESCRIPTION,
+  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 })
+
+  const { data, depth, draft, fallbackLocale, locale, select } = input
+
+  logger.info(
+    `Updating global: ${globalSlug}, draft: ${draft}${locale ? `, locale: ${locale}` : ''}`,
+  )
+
+  try {
+    const virtualFieldNames = getGlobalVirtualFieldNames(payload.config, globalSlug)
+    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) {
+      try {
+        selectClause = JSON.parse(select) as SelectType
+      } catch {
+        logger.warn(`Invalid select clause JSON for global: ${select}`)
+        return { content: [{ type: 'text', text: 'Error: Invalid JSON in select clause' }] }
+      }
+    }
+
+    const updateOptions: Parameters<typeof payload.updateGlobal>[0] = {
+      slug: globalSlug,
+      data: parsedData,
+      depth,
+      draft,
+      ...localAPIDefaults(authorizedMCP),
+    }
+
+    if (locale) {
+      updateOptions.locale = locale
+    }
+    if (fallbackLocale) {
+      updateOptions.fallbackLocale = fallbackLocale
+    }
+    if (selectClause) {
+      updateOptions.select = selectClause
+    }
+
+    const result = await payload.updateGlobal(updateOptions)
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Global "${globalSlug}" updated successfully!\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 updating global ${globalSlug}: ${errorMessage}`)
+    return {
+      content: [{ type: 'text', text: `Error updating global "${globalSlug}": ${errorMessage}` }],
+    }
+  }
+})

package/src/mcp/builtin/validateEntityData.ts

@@ -0,0 +1,132 @@
+import type { CollectionSlug, GlobalSlug, PayloadRequest, SanitizedConfig } from 'payload'
+
+import { CfWorkerJsonSchemaValidator } from '@modelcontextprotocol/server'
+
+import type { JsonSchemaType, MCPToolResponse } from '../../types.js'
+
+import {
+  getCollectionInputSchema,
+  getGlobalInputSchema,
+} from '../../utils/schemaConversion/getEntityInputSchema.js'
+
+/**
+ * Keep the default `shortcircuit: true` - `false` makes validating nested rich text exponentially slow.
+ */
+const validator = new CfWorkerJsonSchemaValidator({ shortcircuit: true })
+
+type EntityValidator = {
+  schema: JsonSchemaType
+  validate: ReturnType<(typeof validator)['getValidator']>
+}
+
+/**
+ * - Caches each entity's schema and validator, so both are only built on the first request.
+ * - Keyed by payload config, then by entity type, slug, partial and language.
+ */
+const validatorCache = new WeakMap<SanitizedConfig, Map<string, EntityValidator>>()
+
+export const validateCollectionData = ({
+  collectionSlug,
+  data,
+  partial,
+  req,
+}: {
+  collectionSlug: CollectionSlug
+  data: Record<string, unknown>
+  partial?: boolean
+  req: PayloadRequest
+}): MCPToolResponse | null =>
+  validateData({
+    slug: collectionSlug,
+    buildSchema: () => getCollectionInputSchema({ collectionSlug, req }),
+    data,
+    entity: 'collection',
+    partial,
+    req,
+  })
+
+export const validateGlobalData = ({
+  data,
+  globalSlug,
+  req,
+}: {
+  data: Record<string, unknown>
+  globalSlug: GlobalSlug
+  req: PayloadRequest
+}): MCPToolResponse | null =>
+  validateData({
+    slug: globalSlug,
+    buildSchema: () => getGlobalInputSchema({ globalSlug, req }),
+    data,
+    entity: 'global',
+    partial: true,
+    req,
+  })
+
+const validateData = ({
+  slug,
+  buildSchema,
+  data,
+  entity,
+  partial,
+  req,
+}: {
+  buildSchema: () => JsonSchemaType | null
+  data: Record<string, unknown>
+  entity: 'collection' | 'global'
+  partial?: boolean
+  req: PayloadRequest
+  slug: string
+}): MCPToolResponse | null => {
+  let cache = validatorCache.get(req.payload.config)
+  if (!cache) {
+    cache = new Map()
+    validatorCache.set(req.payload.config, cache)
+  }
+
+  const cacheKey = `${entity}:${slug}:${partial ? 'partial' : 'full'}:${req.i18n.language}`
+  let entityValidator = cache.get(cacheKey)
+
+  if (!entityValidator) {
+    const schema = buildSchema()
+
+    if (!schema) {
+      return null
+    }
+
+    entityValidator = {
+      schema,
+      validate: validator.getValidator(partial ? withoutRequired(schema) : schema),
+    }
+    cache.set(cacheKey, entityValidator)
+  }
+
+  const result = entityValidator.validate(data)
+
+  if (result.valid) {
+    return null
+  }
+
+  const { schema } = entityValidator
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: `Invalid data for ${entity} "${slug}": ${result.errorMessage}\n\nUse this schema for data:\n\`\`\`json\n${JSON.stringify(schema)}\n\`\`\``,
+      },
+    ],
+    isError: true,
+    structuredContent: {
+      [`${entity}Slug`]: slug,
+      errors: [{ message: result.errorMessage }],
+      schema,
+    },
+  }
+}
+
+/** Updates are partial — drop the schema's top-level `required` before validating. */
+const withoutRequired = (schema: JsonSchemaType): JsonSchemaType => {
+  const { required: _required, ...rest } = schema
+  return rest
+}