@payloadcms/plugin-mcp 4.0.0-internal.bc5cf8c → 4.0.0-internal.bf4bcce

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

@@ -1,12 +1,14 @@
+import { getAccessResults, getGlobalInputSchema, getGlobalSchemaInputSchema } from 'payload'
+import { getLLMInstructions } from 'payload/internal'
+
 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?.read || permissions?.update)
+    return defaultAccess(args) && Boolean(permissions?.update)
   },
   annotations: {
     destructiveHint: false,
@@ -15,27 +17,57 @@ export const getGlobalSchemaTool = defineGlobalTool({
     readOnlyHint: true,
     title: 'Get Global Schema',
   },
-  description: 'Get the input schema for updating a global.',
-}).handler(({ globalSlug, req }) => {
-  const inputSchema = getGlobalInputSchema({ globalSlug, req })
+  description: 'Get the input schema and LLM instructions before updating a global.',
+  input: getGlobalSchemaInputSchema,
+}).handler(async ({ slug, authorizedMCP, req }) => {
+  const permissions = authorizedMCP.overrideAccess
+    ? null
+    : (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 "${slug}"`,
+        },
+      ],
+      isError: true,
+    }
+  }
+
+  const inputSchema = getGlobalInputSchema({
+    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,
     }
   }
 
+  const instructions = await getLLMInstructions({
+    slug,
+    type: 'global',
+    overrideAccess: authorizedMCP.overrideAccess,
+    req,
+  })
+
   return {
     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\`\`\``,
       },
+      ...(instructions ? [{ type: 'text' as const, text: instructions }] : []),
     ],
     structuredContent: {
-      globalSlug,
+      slug,
       schema: inputSchema,
+      ...(instructions ? { instructions } : {}),
     },
   }
 })

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

@@ -1,18 +1,14 @@
-import type { PopulateType } from 'payload'
-
-import { z } from 'zod'
+import { restoreGlobalVersionInputSchema } from 'payload'
 
 import { defaultAccess } from '../../../defaultAccess.js'
 import { defineGlobalTool } from '../../../defineTool.js'
 import { getLogger } from '../../../utils/getLogger.js'
-import { localAPIDefaults } from '../../../utils/localAPIDefaults.js'
 
 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,
@@ -21,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,
-      ...localAPIDefaults(authorizedMCP),
-      ...(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 =
@@ -79,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,23 +1,20 @@
-import type { SelectType } from 'payload'
-
-import { z } from 'zod'
+import {
+  getGlobalVirtualFieldNames,
+  stripVirtualFields,
+  transformPointDataToPayload,
+  updateGlobalInputSchema,
+  validateGlobalData,
+} 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 { localAPIDefaults } from '../../../utils/localAPIDefaults.js'
-import { transformPointDataToPayload } from '../../../utils/transformPointDataToPayload.js'
-import { validateGlobalData } from '../validateEntityData.js'
+import { formatEntityError } from '../formatEntityError.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,
@@ -26,72 +23,54 @@ 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 })
-
-    if (validationError) {
-      return validationError
-    }
+    validateGlobalData({ slug, data: inputData, req })
 
     const parsedData = transformPointDataToPayload(inputData)
 
     const updateOptions: Parameters<typeof payload.updateGlobal>[0] = {
-      slug: globalSlug,
+      slug,
       data: parsedData,
       depth,
       draft,
-      ...localAPIDefaults(authorizedMCP),
+      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 +79,14 @@ 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}`)
-    return {
-      content: [{ type: 'text', text: `Error updating global "${globalSlug}": ${errorMessage}` }],
-    }
+    const message = error instanceof Error ? error.message : 'Unknown error'
+    logger.error(`Error updating global ${slug}: ${message}`)
+    return formatEntityError({ slug, action: 'updating', entity: 'global', error, req })
   }
 })

package/src/mcp/builtinTools.ts

@@ -10,7 +10,7 @@ import {
 } from './builtin/collections/authTools.js'
 import { countDocumentsTool } from './builtin/collections/countTool.js'
 import { countVersionsTool } from './builtin/collections/countVersionsTool.js'
-import { createDocumentTool } from './builtin/collections/createTool.js'
+import { createDocumentsTool } from './builtin/collections/createTool.js'
 import { deleteDocumentsTool } from './builtin/collections/deleteTool.js'
 import { duplicateDocumentTool } from './builtin/collections/duplicateTool.js'
 import { findDistinctTool } from './builtin/collections/findDistinctTool.js'
@@ -20,6 +20,7 @@ import { findVersionsTool } from './builtin/collections/findVersionsTool.js'
 import { getCollectionSchemaTool } from './builtin/collections/getCollectionSchemaTool.js'
 import { restoreVersionTool } from './builtin/collections/restoreVersionTool.js'
 import { updateDocumentTool } from './builtin/collections/updateTool.js'
+import { getUploadInstructionsTool } from './builtin/collections/uploadInstructionsTool.js'
 import { getConfigInfoTool } from './builtin/getConfigInfoTool.js'
 import { countGlobalVersionsTool } from './builtin/globals/countVersionsTool.js'
 import { findGlobalTool } from './builtin/globals/findTool.js'
@@ -32,6 +33,7 @@ import { updateGlobalTool } from './builtin/globals/updateTool.js'
 type CollectionBuiltin = {
   mcpName: string
   requiresDuplicateEnabled?: boolean
+  requiresUpload?: boolean
   requiresVersions?: boolean
   tool: CollectionTool
 }
@@ -54,7 +56,7 @@ export const TOOL_BUILTINS = {
 export const COLLECTION_BUILTINS = {
   count: { mcpName: 'countDocuments', tool: countDocumentsTool },
   countVersions: { mcpName: 'countVersions', requiresVersions: true, tool: countVersionsTool },
-  create: { mcpName: 'createDocument', tool: createDocumentTool },
+  create: { mcpName: 'createDocuments', tool: createDocumentsTool },
   delete: { mcpName: 'deleteDocuments', tool: deleteDocumentsTool },
   duplicate: {
     mcpName: 'duplicateDocument',
@@ -70,6 +72,11 @@ export const COLLECTION_BUILTINS = {
   },
   findVersions: { mcpName: 'findVersions', requiresVersions: true, tool: findVersionsTool },
   getCollectionSchema: { mcpName: 'getCollectionSchema', tool: getCollectionSchemaTool },
+  getUploadInstructions: {
+    mcpName: 'getUploadInstructions',
+    requiresUpload: true,
+    tool: getUploadInstructionsTool,
+  },
   restoreVersion: { mcpName: 'restoreVersion', requiresVersions: true, tool: restoreVersionTool },
   update: { mcpName: 'updateDocument', tool: updateDocumentTool },
 } satisfies Record<string, CollectionBuiltin>

package/src/mcp/sanitizeMCPConfig.ts

@@ -100,8 +100,10 @@ export const sanitizeMCPConfig = ({
 
   return {
     disabled: pluginConfig.disabled,
+    hooks: pluginConfig.hooks,
     items,
     mcp: pluginConfig.mcp,
+    oauth: pluginConfig.oauth,
     overrideGetAuthorizedMCP: pluginConfig.overrideGetAuthorizedMCP,
   }
 }
@@ -126,7 +128,7 @@ const sanitizeCollectionConfig = ({
 
   for (const [
     toolKey,
-    { mcpName, requiresDuplicateEnabled, requiresVersions, tool },
+    { mcpName, requiresDuplicateEnabled, requiresUpload, requiresVersions, tool },
   ] of COLLECTION_BUILTIN_ENTRIES) {
     if (requiresVersions && !collection.versions) {
       continue
@@ -134,6 +136,9 @@ const sanitizeCollectionConfig = ({
     if (requiresDuplicateEnabled && isDuplicateDisabled) {
       continue
     }
+    if (requiresUpload && !collection.upload) {
+      continue
+    }
     const matchedConfigEntry = collectionPluginConfig?.tools?.[toolKey]
     if (matchedConfigEntry === false) {
       continue

package/src/stdio.ts

@@ -1,10 +1,10 @@
-import type { MaybePromise, Plugin, SanitizedConfig } from 'payload'
+import type { Config, Plugin, SanitizedConfig } from 'payload'
 
 /* eslint-disable no-console */
-import { StdioServerTransport } from '@modelcontextprotocol/server'
+import { serveStdio } from '@modelcontextprotocol/server/stdio'
 import { fileURLToPath, pathToFileURL } from 'node:url'
-import { createLocalReq, getPayload } from 'payload'
-import { findConfig } from 'payload/node'
+import { createPayloadRequest, getPayload } from 'payload'
+import { findConfig, loadEnv } from 'payload/node'
 
 import type { SanitizedMCPPluginConfig } from './types.js'
 
@@ -15,53 +15,62 @@ import { getPluginConfig } from './utils/getPluginConfig.js'
 import { resolveProjectRoot } from './utils/resolveProjectRoot.js'
 
 /**
- * Stdio adapter for the Payload MCP server.
+ * Starts Payload's MCP server over stdin and stdout.
  *
- * Pass PAYLOAD_MCP_AUTHORIZATION when stdio should authenticate with the same
- * Payload auth header as HTTP. In development, PAYLOAD_MCP_OVERRIDE_ACCESS=true
- * skips access control for local setup.
+ * Set `PAYLOAD_MCP_AUTHORIZATION` to authenticate. In development,
+ * `PAYLOAD_MCP_OVERRIDE_ACCESS=true` skips access checks.
  */
 export const runMcpStdio = async (): Promise<void> => {
-  /**
-   * If MCP clients spawn stdio servers from an arbitrary working directory,
-   * Payload's cwd-anchored `findConfig()` can't locate the project on
-   * its own. This module always lives inside the project's `node_modules`, so
-   * we derive the project root from its own path and `chdir` into it.
-   *
-   * An absolute `PAYLOAD_CONFIG_PATH` still overrides everything; unusual
-   * layouts (e.g. a monorepo where the package is hoisted above the app) can
-   * fall back to it. See the implementation of findConfig for details.
-   */
+  // MCP clients may start this command from another folder. Move to the Payload
+  // project so findConfig() can find the config.
   const projectRoot = resolveProjectRoot(fileURLToPath(import.meta.url))
   if (projectRoot) {
     process.chdir(projectRoot)
   }
 
+  loadEnv()
   const configPath = findConfig()
   const configModule = await import(pathToFileURL(configPath).toString())
-  const config = (await (configModule.default ?? configModule)) as MaybePromise<SanitizedConfig>
-
-  const payload = await getPayload({ config })
+  const config = (await (configModule.default ?? configModule)) as SanitizedConfig
 
   /**
-   * If the user added `mcpPlugin({...})` to their `plugins` array, read the
-   * sanitized config they registered. Otherwise fall back to the defaults. That way,
-   * the mcp works on any project that has `@payloadcms/plugin-mcp` installed,
-   * even if the plugin is not added to the plugins array.
+   * stdout is only for MCP messages. The spec says the server must not write
+   * logs there and may write them to stderr instead.
+   *
+   * The 2.0 client library recovers from stray stdout logs, but that behavior is not
+   * guaranteed. Move Payload logs to stderr so Payload does not add invalid data
+   * to stdout. Keep options from configurable loggers. Replace pre-built loggers
+   * because their output cannot be redirected.
+   *
+   * @see https://modelcontextprotocol.io/specification/2025-11-25/basic/transports#stdio
    */
+  const loggerConfig: { logger?: Config['logger'] } = config
+  if (
+    loggerConfig.logger &&
+    typeof loggerConfig.logger === 'object' &&
+    'options' in loggerConfig.logger
+  ) {
+    loggerConfig.logger.destination = process.stderr
+  } else {
+    loggerConfig.logger = { destination: process.stderr, options: {} }
+  }
+
+  const payload = await getPayload({ config, cron: false, disableOnInit: true })
+
   let pluginConfig: SanitizedMCPPluginConfig
   try {
     pluginConfig = getPluginConfig({ config: payload.config })
   } catch {
+    // The command also works when mcpPlugin() is not in the Payload config.
     pluginConfig = sanitizeMCPConfig({ config: payload.config, pluginConfig: {} })
 
-    const fakePluginFn: Plugin = (config) => config
-    fakePluginFn.slug = '@payloadcms/plugin-mcp'
-    // @ts-expect-error
-    fakePluginFn.sanitizedOptions = pluginConfig
-
-    // Push to payload config, to ensure consecutive calls to `getPluginConfig()` work
-    ;(payload.config.plugins ??= []).push(fakePluginFn)
+    const fallbackPlugin: Plugin = (config) => config
+    Object.assign(fallbackPlugin, {
+      slug: '@payloadcms/plugin-mcp',
+      sanitizedOptions: pluginConfig,
+    })
+    payload.config.plugins ??= []
+    payload.config.plugins.push(fallbackPlugin)
   }
 
   const overrideAccessEnv = process.env.PAYLOAD_MCP_OVERRIDE_ACCESS
@@ -82,32 +91,41 @@ export const runMcpStdio = async (): Promise<void> => {
     headers.set('Authorization', process.env.PAYLOAD_MCP_AUTHORIZATION)
   }
 
-  const req = await createLocalReq({ req: { headers } }, payload)
+  const req = await createPayloadRequest({ payload, req: { headers } })
   req.payloadAPI = 'MCP' as const
   const authorizedMCP = await getAuthorizedMCP({ overrideAccess, req })
 
-  const server = buildMcpServer({ authorizedMCP, pluginConfig, req })
-
-  const transport = new StdioServerTransport()
-  await server.connect(transport)
+  const stdioServer = serveStdio(() => buildMcpServer({ authorizedMCP, pluginConfig, req }), {
+    onerror: (err) => {
+      // MCP messages use stdout, so write SDK errors to stderr.
+      console.error('[payload-mcp] error serving MCP over stdio:', err)
+    },
+  })
+
+  // Close the MCP server and Payload when the client disconnects or the process stops.
+  let isShuttingDown = false
+  const shutdown = async () => {
+    if (isShuttingDown) {
+      return
+    }
+    isShuttingDown = true
 
-  // Process now lives until stdin closes. Wire graceful shutdown so DB
-  // connections (and any other Payload-managed resources) get released.
-  const shutdown = async (code = 0) => {
     try {
-      await server.close()
+      await stdioServer.close()
     } catch (err) {
       console.error('[payload-mcp] error closing server:', err)
     }
+
     try {
       await payload.destroy()
     } catch (err) {
       console.error('[payload-mcp] error destroying payload:', err)
     }
-    process.exit(code)
+
+    process.exit(0)
   }
 
-  process.on('SIGINT', () => void shutdown(0))
-  process.on('SIGTERM', () => void shutdown(0))
-  process.stdin.on('close', () => void shutdown(0))
+  process.once('SIGINT', () => void shutdown())
+  process.once('SIGTERM', () => void shutdown())
+  process.stdin.once('close', () => void shutdown())
 }