@payloadcms/plugin-mcp 4.0.0-internal.c7d5de4 → 4.0.0-internal.cc18726

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

@@ -1,6 +1,4 @@
-import type { PopulateType, SelectType } from 'payload'
-
-import { z } from 'zod'
+import { findGlobalVersionByIDInputSchema } from 'payload'
 
 import { defaultAccess } from '../../../defaultAccess.js'
 import { defineGlobalTool } from '../../../defineTool.js'
@@ -11,7 +9,7 @@ const DEFAULT_DESCRIPTION =
 
 export const findGlobalVersionByIDTool = defineGlobalTool({
   access: (args) =>
-    defaultAccess(args) && Boolean(args.permissions?.globals?.[args.globalSlug]?.readVersions),
+    defaultAccess(args) && Boolean(args.permissions?.globals?.[args.slug]?.readVersions),
   annotations: {
     destructiveHint: false,
     idempotentHint: true,
@@ -20,81 +18,44 @@ export const findGlobalVersionByIDTool = defineGlobalTool({
     title: 'Find Global Version By ID',
   },
   description: DEFAULT_DESCRIPTION,
-  input: z.object({
-    id: z.string().describe('The ID of the global version to retrieve'),
-    depth: z
-      .number()
-      .int()
-      .min(0)
-      .max(10)
-      .describe('How many levels deep to populate relationships in the global 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.siteName": true}',
-      )
-      .optional(),
-    showHiddenFields: z
-      .boolean()
-      .describe('Optional: include hidden fields in the returned global version document')
-      .optional(),
-  }),
-}).handler(async ({ authorizedMCP, globalSlug, input, req }) => {
+  input: findGlobalVersionByIDInputSchema,
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
   const payload = req.payload
   const logger = getLogger({ payload })
-  const { id, depth, fallbackLocale, locale, populate, select, showHiddenFields } = input
+  const { id, depth, fallbackLocale, locale, populate, select } = input
 
-  logger.info(`Finding version for global: ${globalSlug} with ID: ${id}`)
+  logger.info(`Finding version for global: ${slug} with ID: ${id}`)
 
   try {
     const result = await payload.findGlobalVersionByID({
       id,
-      slug: globalSlug,
+      slug,
       depth,
       overrideAccess: authorizedMCP.overrideAccess,
       req,
-      ...(fallbackLocale ? { fallbackLocale } : {}),
+      ...(fallbackLocale !== undefined ? { fallbackLocale } : {}),
       ...(locale ? { locale } : {}),
-      ...(populate ? { populate: populate as PopulateType } : {}),
-      ...(select ? { select: select as SelectType } : {}),
-      ...(showHiddenFields !== undefined ? { showHiddenFields } : {}),
+      ...(populate ? { populate } : {}),
+      ...(select ? { select } : {}),
     })
 
     return {
       content: [
         {
           type: 'text',
-          text: `Version "${id}" from global "${globalSlug}":\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
+          text: `Version "${id}" from global "${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} for global ${globalSlug}: ${errorMessage}`)
+    logger.error(`Error finding version ${id} for global ${slug}: ${errorMessage}`)
     return {
       content: [
         {
           type: 'text',
-          text: `❌ **Error finding version "${id}" for global "${globalSlug}":** ${errorMessage}`,
+          text: `❌ **Error finding version "${id}" for global "${slug}":** ${errorMessage}`,
         },
       ],
       isError: true,

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

@@ -1,18 +1,15 @@
-import type { PopulateType, SelectType } from 'payload'
-
-import { z } from 'zod'
+import { findGlobalVersionsInputSchema } from 'payload'
 
 import { defaultAccess } from '../../../defaultAccess.js'
 import { defineGlobalTool } from '../../../defineTool.js'
 import { getLogger } from '../../../utils/getLogger.js'
-import { whereSchema } from '../../../utils/whereSchema.js'
 
 const DEFAULT_DESCRIPTION =
   'Find global versions in any version-enabled global by passing the global slug and optional where clause.'
 
 export const findGlobalVersionsTool = defineGlobalTool({
   access: (args) =>
-    defaultAccess(args) && Boolean(args.permissions?.globals?.[args.globalSlug]?.readVersions),
+    defaultAccess(args) && Boolean(args.permissions?.globals?.[args.slug]?.readVersions),
   annotations: {
     destructiveHint: false,
     idempotentHint: true,
@@ -21,103 +18,28 @@ export const findGlobalVersionsTool = defineGlobalTool({
     title: 'Find Global Versions',
   },
   description: DEFAULT_DESCRIPTION,
-  input: z.object({
-    depth: z
-      .number()
-      .int()
-      .min(0)
-      .max(10)
-      .describe('How many levels deep to populate relationships in global 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.siteName": true}',
-      )
-      .optional(),
-    showHiddenFields: z
-      .boolean()
-      .describe('Optional: include hidden fields in returned global version documents')
-      .optional(),
-    sort: z
-      .string()
-      .describe('Field to sort by (e.g., "-updatedAt", "-version.updatedAt" for descending)')
-      .optional(),
-    where: whereSchema
-      .describe(
-        'Optional: where clause for filtering versions. Version document fields are usually under "version". Example: {"version.siteName":{"contains":"test"}}',
-      )
-      .optional(),
-  }),
-}).handler(async ({ authorizedMCP, globalSlug, input, req }) => {
+  input: findGlobalVersionsInputSchema,
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
   const payload = req.payload
   const logger = getLogger({ payload })
-  const {
-    depth,
-    fallbackLocale,
-    limit,
-    locale,
-    page,
-    pagination,
-    populate,
-    select,
-    showHiddenFields,
-    sort,
-    where,
-  } = input
+  const { depth, fallbackLocale, limit, locale, page, pagination, populate, select, sort, where } =
+    input
 
-  logger.info(`Finding versions for global: ${globalSlug}, limit: ${limit}, page: ${page}`)
+  logger.info(`Finding versions for global: ${slug}, limit: ${limit}, page: ${page}`)
 
   try {
     const result = await payload.findGlobalVersions({
-      slug: globalSlug,
+      slug,
       depth,
       limit,
       overrideAccess: authorizedMCP.overrideAccess,
       page,
       req,
-      ...(fallbackLocale ? { fallbackLocale } : {}),
+      ...(fallbackLocale !== undefined ? { fallbackLocale } : {}),
       ...(locale ? { locale } : {}),
       ...(pagination !== undefined ? { pagination } : {}),
-      ...(populate ? { populate: populate as PopulateType } : {}),
-      ...(select ? { select: select as SelectType } : {}),
-      ...(showHiddenFields !== undefined ? { showHiddenFields } : {}),
+      ...(populate ? { populate } : {}),
+      ...(select ? { select } : {}),
       ...(sort ? { sort } : {}),
       ...(where ? { where } : {}),
     })
@@ -126,19 +48,19 @@ export const findGlobalVersionsTool = defineGlobalTool({
       content: [
         {
           type: 'text',
-          text: `Versions for global "${globalSlug}":\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
+          text: `Versions for global "${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 for global ${globalSlug}: ${errorMessage}`)
+    logger.error(`Error finding versions for global ${slug}: ${errorMessage}`)
     return {
       content: [
         {
           type: 'text',
-          text: `❌ **Error finding versions for global "${globalSlug}":** ${errorMessage}`,
+          text: `❌ **Error finding versions for global "${slug}":** ${errorMessage}`,
         },
       ],
       isError: true,

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

@@ -1,12 +1,11 @@
-import { getAccessResults } from 'payload'
+import { getAccessResults, getGlobalInputSchema, getGlobalSchemaInputSchema } from 'payload'
 
 import { defaultAccess } from '../../../defaultAccess.js'
 import { defineGlobalTool } from '../../../defineTool.js'
-import { getGlobalInputSchema } from '../../../utils/schemaConversion/getEntityInputSchema.js'
 
 export const getGlobalSchemaTool = defineGlobalTool({
   access: (args) => {
-    const permissions = args.permissions?.globals?.[args.globalSlug]
+    const permissions = args.permissions?.globals?.[args.slug]
 
     return defaultAccess(args) && Boolean(permissions?.update)
   },
@@ -18,17 +17,18 @@ export const getGlobalSchemaTool = defineGlobalTool({
     title: 'Get Global Schema',
   },
   description: 'Get the input schema for updating a global.',
-}).handler(async ({ authorizedMCP, globalSlug, req }) => {
+  input: getGlobalSchemaInputSchema,
+}).handler(async ({ slug, authorizedMCP, req }) => {
   const permissions = authorizedMCP.overrideAccess
     ? null
-    : (await getAccessResults({ req })).globals?.[globalSlug]
+    : (await getAccessResults({ req })).globals?.[slug]
 
   if (!authorizedMCP.overrideAccess && !permissions?.update) {
     return {
       content: [
         {
           type: 'text',
-          text: `Error: MCP access to "getGlobalSchema" is not enabled for global "${globalSlug}"`,
+          text: `Error: MCP access to "getGlobalSchema" is not enabled for global "${slug}"`,
         },
       ],
       isError: true,
@@ -36,14 +36,14 @@ export const getGlobalSchemaTool = defineGlobalTool({
   }
 
   const inputSchema = getGlobalInputSchema({
-    globalSlug,
+    globalSlug: slug,
     req,
     ...(permissions ? { permissions } : {}),
   })
 
   if (!inputSchema) {
     return {
-      content: [{ type: 'text', text: `Error: Global "${globalSlug}" not found` }],
+      content: [{ type: 'text', text: `Error: Global "${slug}" not found` }],
       isError: true,
     }
   }
@@ -52,11 +52,11 @@ export const getGlobalSchemaTool = defineGlobalTool({
     content: [
       {
         type: 'text',
-        text: `Schema for global "${globalSlug}":\n\`\`\`json\n${JSON.stringify(inputSchema)}\n\`\`\``,
+        text: `Schema for global "${slug}":\n\`\`\`json\n${JSON.stringify(inputSchema)}\n\`\`\``,
       },
     ],
     structuredContent: {
-      globalSlug,
+      slug,
       schema: inputSchema,
     },
   }

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

@@ -1,6 +1,4 @@
-import type { PopulateType } from 'payload'
-
-import { z } from 'zod'
+import { restoreGlobalVersionInputSchema } from 'payload'
 
 import { defaultAccess } from '../../../defaultAccess.js'
 import { defineGlobalTool } from '../../../defineTool.js'
@@ -10,8 +8,7 @@ const DEFAULT_DESCRIPTION =
   'Restore a global from a previous version in any version-enabled global.'
 
 export const restoreGlobalVersionTool = defineGlobalTool({
-  access: (args) =>
-    defaultAccess(args) && Boolean(args.permissions?.globals?.[args.globalSlug]?.update),
+  access: (args) => defaultAccess(args) && Boolean(args.permissions?.globals?.[args.slug]?.update),
   annotations: {
     destructiveHint: true,
     idempotentHint: false,
@@ -20,53 +17,25 @@ export const restoreGlobalVersionTool = defineGlobalTool({
     title: 'Restore Global Version',
   },
   description: DEFAULT_DESCRIPTION,
-  input: z.object({
-    id: z.string().describe('The ID of the global version to restore'),
-    depth: z
-      .number()
-      .int()
-      .min(0)
-      .max(10)
-      .describe('How many levels deep to populate relationships in response')
-      .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 restore in (e.g., "en", "es")')
-      .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 restored global response')
-      .optional(),
-  }),
-}).handler(async ({ authorizedMCP, globalSlug, input, req }) => {
+  input: restoreGlobalVersionInputSchema,
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
   const payload = req.payload
   const logger = getLogger({ payload })
-  const { id, depth, fallbackLocale, locale, populate, showHiddenFields } = input
+  const { id, depth, fallbackLocale, locale, populate, select } = input
 
-  logger.info(`Restoring version for global: ${globalSlug} with ID: ${id}`)
+  logger.info(`Restoring version for global: ${slug} with ID: ${id}`)
 
   try {
     const result = await payload.restoreGlobalVersion({
-      id,
-      slug: globalSlug,
+      id: String(id),
+      slug,
       depth,
       overrideAccess: authorizedMCP.overrideAccess,
       req,
-      ...(fallbackLocale ? { fallbackLocale } : {}),
+      ...(fallbackLocale !== undefined ? { fallbackLocale } : {}),
       ...(locale ? { locale } : {}),
-      ...(populate ? { populate: populate as PopulateType } : {}),
-      ...(showHiddenFields !== undefined ? { showHiddenFields } : {}),
+      ...(populate ? { populate } : {}),
+      ...(select ? { select } : {}),
     })
     const resultObject = result as Record<string, unknown>
     const restoredGlobal =
@@ -78,19 +47,19 @@ export const restoreGlobalVersionTool = defineGlobalTool({
       content: [
         {
           type: 'text',
-          text: `Version "${id}" restored successfully for global "${globalSlug}"!\nRestored global:\n\`\`\`json\n${JSON.stringify(restoredGlobal)}\n\`\`\``,
+          text: `Version "${id}" restored successfully for global "${slug}"!\nRestored global:\n\`\`\`json\n${JSON.stringify(restoredGlobal)}\n\`\`\``,
         },
       ],
       doc: restoredGlobal,
     }
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : 'Unknown error'
-    logger.error(`Error restoring version ${id} for global ${globalSlug}: ${errorMessage}`)
+    logger.error(`Error restoring version ${id} for global ${slug}: ${errorMessage}`)
     return {
       content: [
         {
           type: 'text',
-          text: `❌ **Error restoring version "${id}" for global "${globalSlug}":** ${errorMessage}`,
+          text: `❌ **Error restoring version "${id}" for global "${slug}":** ${errorMessage}`,
         },
       ],
       isError: true,

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

@@ -1,22 +1,19 @@
-import type { SelectType } from 'payload'
-
-import { z } from 'zod'
+import {
+  getGlobalVirtualFieldNames,
+  stripVirtualFields,
+  transformPointDataToPayload,
+  updateGlobalInputSchema,
+} from 'payload'
 
 import { defaultAccess } from '../../../defaultAccess.js'
 import { defineGlobalTool } from '../../../defineTool.js'
 import { getLogger } from '../../../utils/getLogger.js'
-import {
-  getGlobalVirtualFieldNames,
-  stripVirtualFields,
-} from '../../../utils/getVirtualFieldNames.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({
-  access: (args) =>
-    defaultAccess(args) && Boolean(args.permissions?.globals?.[args.globalSlug]?.update),
+  access: (args) => defaultAccess(args) && Boolean(args.permissions?.globals?.[args.slug]?.update),
   annotations: {
     destructiveHint: true,
     idempotentHint: false,
@@ -25,49 +22,30 @@ export const updateGlobalTool = defineGlobalTool({
     title: 'Update Global',
   },
   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
-      .record(z.string(), z.unknown())
-      .describe(
-        'Optional: define exactly which fields you\'d like to return in the response, e.g., {"siteName": true}',
-      )
-      .optional(),
-  }),
-}).handler(async ({ authorizedMCP, globalSlug, input, req }) => {
+  input: updateGlobalInputSchema,
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
   const payload = req.payload
   const logger = getLogger({ payload })
 
-  const { data, depth, draft, fallbackLocale, locale, select } = input
+  const {
+    data,
+    depth,
+    draft,
+    fallbackLocale,
+    locale,
+    overrideLock,
+    populate,
+    publishAllLocales,
+    select,
+    unpublishAllLocales,
+  } = input
 
-  logger.info(
-    `Updating global: ${globalSlug}, draft: ${draft}${locale ? `, locale: ${locale}` : ''}`,
-  )
+  logger.info(`Updating global: ${slug}, draft: ${draft}${locale ? `, locale: ${locale}` : ''}`)
 
   try {
-    const virtualFieldNames = getGlobalVirtualFieldNames(payload.config, globalSlug)
+    const virtualFieldNames = getGlobalVirtualFieldNames(payload.config, slug)
     const inputData = stripVirtualFields(data, virtualFieldNames)
-    const validationError = validateGlobalData({ data: inputData, globalSlug, req })
+    const validationError = validateGlobalData({ slug, data: inputData, req })
 
     if (validationError) {
       return validationError
@@ -76,22 +54,26 @@ export const updateGlobalTool = defineGlobalTool({
     const parsedData = transformPointDataToPayload(inputData)
 
     const updateOptions: Parameters<typeof payload.updateGlobal>[0] = {
-      slug: globalSlug,
+      slug,
       data: parsedData,
       depth,
       draft,
       overrideAccess: authorizedMCP.overrideAccess,
+      overrideLock,
+      populate,
+      publishAllLocales,
       req,
+      unpublishAllLocales,
     }
 
     if (locale) {
       updateOptions.locale = locale
     }
-    if (fallbackLocale) {
+    if (fallbackLocale !== undefined) {
       updateOptions.fallbackLocale = fallbackLocale
     }
     if (select) {
-      updateOptions.select = select as SelectType
+      updateOptions.select = select
     }
 
     const result = await payload.updateGlobal(updateOptions)
@@ -100,16 +82,16 @@ export const updateGlobalTool = defineGlobalTool({
       content: [
         {
           type: 'text',
-          text: `Global "${globalSlug}" updated successfully!\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
+          text: `Global "${slug}" 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}`)
+    logger.error(`Error updating global ${slug}: ${errorMessage}`)
     return {
-      content: [{ type: 'text', text: `Error updating global "${globalSlug}": ${errorMessage}` }],
+      content: [{ type: 'text', text: `Error updating global "${slug}": ${errorMessage}` }],
     }
   }
 })

package/src/mcp/builtin/validateEntityData.ts

@@ -1,14 +1,10 @@
 import type { CollectionSlug, GlobalSlug, PayloadRequest, SanitizedConfig } from 'payload'
 
 import { CfWorkerJsonSchemaValidator } from '@modelcontextprotocol/server/validators/cf-worker'
+import { getCollectionInputSchema, getGlobalInputSchema } from 'payload'
 
 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.
  */
@@ -26,19 +22,20 @@ type EntityValidator = {
 const validatorCache = new WeakMap<SanitizedConfig, Map<string, EntityValidator>>()
 
 export const validateCollectionData = ({
-  collectionSlug,
+  slug,
   data,
   partial,
   req,
 }: {
-  collectionSlug: CollectionSlug
   data: Record<string, unknown>
   partial?: boolean
   req: PayloadRequest
+  slug: CollectionSlug
 }): MCPToolResponse | null =>
   validateData({
-    slug: collectionSlug,
-    buildSchema: () => getCollectionInputSchema({ collectionSlug, req }),
+    slug,
+    buildSchema: () =>
+      getCollectionInputSchema({ collectionSlug: slug, req }) as JsonSchemaType | null,
     data,
     entity: 'collection',
     partial,
@@ -46,17 +43,17 @@ export const validateCollectionData = ({
   })
 
 export const validateGlobalData = ({
+  slug,
   data,
-  globalSlug,
   req,
 }: {
   data: Record<string, unknown>
-  globalSlug: GlobalSlug
   req: PayloadRequest
+  slug: GlobalSlug
 }): MCPToolResponse | null =>
   validateData({
-    slug: globalSlug,
-    buildSchema: () => getGlobalInputSchema({ globalSlug, req }),
+    slug,
+    buildSchema: () => getGlobalInputSchema({ globalSlug: slug, req }) as JsonSchemaType | null,
     data,
     entity: 'global',
     partial: true,