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

package/src/endpoint/index.ts

@@ -1,5 +1,11 @@
-import { WebStandardStreamableHTTPServerTransport } from '@modelcontextprotocol/server'
-import { APIError, type PayloadHandler } from 'payload'
+import type { PayloadHandler, PayloadRequest } from 'payload'
+
+import {
+  createMcpHandler,
+  isLegacyRequest,
+  WebStandardStreamableHTTPServerTransport,
+} from '@modelcontextprotocol/server'
+import { APIError } from 'payload'
 
 import { buildMcpServer } from '../mcp/buildMcpServer.js'
 import { getPluginConfig } from '../utils/getPluginConfig.js'
@@ -13,23 +19,59 @@ export const mcpEndpoint: PayloadHandler = async (req) => {
   req.payloadAPI = 'MCP' as const
 
   const pluginConfig = getPluginConfig({ config: req.payload.config })
-  const authorizedMCP = await getAuthorizedMCP({ req })
+  const overrideAccessParam = new URL(req.url).searchParams.get('overrideAccess')
 
-  const server = buildMcpServer({ authorizedMCP, pluginConfig, req })
+  if (overrideAccessParam !== null && process.env.NODE_ENV !== 'development') {
+    throw new APIError('MCP overrideAccess is only available in development.', 400)
+  }
 
-  const transport = new WebStandardStreamableHTTPServerTransport({
-    enableJsonResponse: true,
-    sessionIdGenerator: undefined, // stateless mode
-  })
+  let overrideAccess = false
+  if (overrideAccessParam === 'true') {
+    overrideAccess = true
+  } else if (overrideAccessParam !== null && overrideAccessParam !== 'false') {
+    throw new APIError('MCP overrideAccess must be "true" or "false".', 400)
+  }
 
-  await server.connect(transport)
+  const authorizedMCP = await getAuthorizedMCP({ overrideAccess, req })
+  // Payload augments the original web-standard Request in place.
+  const mcpRequest = req as PayloadRequest & Request
 
-  const mcpRequest = new Request(req.url, {
-    body: req.body,
-    duplex: 'half',
-    headers: req.headers,
-    method: req.method,
-  } as { duplex: 'half' } & RequestInit)
+  // Keep the old JSON-only, stateless behavior because the SDK's 2025 fallback uses SSE.
+  if (await isLegacyRequest(mcpRequest)) {
+    const server = buildMcpServer({ authorizedMCP, pluginConfig, req })
+    const transport = new WebStandardStreamableHTTPServerTransport({
+      enableJsonResponse: true,
+      sessionIdGenerator: undefined, // stateless mode
+    })
+    transport.onerror = (err) => {
+      req.payload.logger.error({ err, msg: 'Error serving legacy MCP request' })
+    }
 
-  return await transport.handleRequest(mcpRequest)
+    try {
+      await server.connect(transport)
+      return await transport.handleRequest(mcpRequest)
+    } finally {
+      await server.close().catch((err) => {
+        req.payload.logger.error({ err, msg: 'Error closing MCP server' })
+      })
+    }
+  }
+
+  const handler = createMcpHandler(() => buildMcpServer({ authorizedMCP, pluginConfig, req }), {
+    legacy: 'reject',
+    // SDK subscriptions always use SSE, so disable them to keep every response JSON-only.
+    maxSubscriptions: 0,
+    onerror: (err) => {
+      req.payload.logger.error({ err, msg: 'Error serving modern MCP request' })
+    },
+    responseMode: 'json',
+  })
+
+  try {
+    return await handler.fetch(mcpRequest)
+  } finally {
+    await handler.close().catch((err) => {
+      req.payload.logger.error({ err, msg: 'Error closing modern MCP handler' })
+    })
+  }
 }

package/src/exports/client.ts

@@ -1,5 +1,3 @@
 'use client'
-export { AccessField } from '../components/AccessField/index.client.js'
-export { APIKeyField } from '../components/APIKeyField/index.client.js'
-export { APIKeysEmptyState } from '../components/APIKeysEmptyState/index.client.js'
-export { MCPSettingsMenu } from '../components/SettingsMenu/index.client.js'
+
+export {}

package/src/exports/internal.ts

@@ -0,0 +1 @@
+export { filterMCPItems, getAuthorizedMCP } from '../endpoint/access.js'

package/src/index.ts

@@ -1,18 +1,13 @@
-import type { AcceptedLanguages } from '@payloadcms/translations'
+import { definePlugin } from 'payload'
 
-import { defaultUserCollection, definePlugin } from 'payload'
-
-import type { PluginDefaultTranslationsObject } from './translations/types.js'
 import type { AuthorizedMCP, MCPPluginConfig, SanitizedMCPPluginConfig } from './types.js'
 
-import { getAPIKeysCollection } from './collection/index.js'
 import { mcpEndpoint } from './endpoint/index.js'
 import { sanitizeMCPConfig } from './mcp/sanitizeMCPConfig.js'
-import { translations } from './translations/index.js'
 
 declare module 'payload' {
-  export interface PayloadRequest {
-    payloadAPI: 'GraphQL' | 'local' | 'MCP' | 'REST'
+  export interface PayloadRequestAPI {
+    MCP: true
   }
   interface RegisteredPlugins {
     /** After the plugin's `plugin` callback runs, `options` holds the sanitized config. */
@@ -27,17 +22,8 @@ export { defineCollectionTool, defineGlobalTool, definePrompt, defineTool } from
 export const mcpPlugin = definePlugin<MCPPluginConfig>({
   slug: '@payloadcms/plugin-mcp',
   order: 10,
-  plugin: ({ config, plugins, ...rawConfig }) => {
-    // If a project has no auth collection yet, add the default users collection
-    // so the relationship target and default `userCollection` exist.
-    if (!config.admin?.user) {
-      const firstCollectionWithAuth = (config.collections ?? []).find(({ auth }) => Boolean(auth))
-      if (!firstCollectionWithAuth) {
-        ;(config.collections ??= []).push(defaultUserCollection)
-      }
-    }
-
-    const pluginConfig = sanitizeMCPConfig({ config, pluginConfig: rawConfig })
+  plugin: ({ config, options, plugins }) => {
+    const pluginConfig = sanitizeMCPConfig({ config, pluginConfig: options })
 
     // Stash the sanitized config on plugin options so `getPluginConfig()` reads it.
     const registered = plugins['@payloadcms/plugin-mcp']
@@ -46,52 +32,12 @@ export const mcpPlugin = definePlugin<MCPPluginConfig>({
       registered.sanitizedOptions = pluginConfig as unknown as typeof registered.options
     }
 
-    ;(config.collections ??= []).push(getAPIKeysCollection({ pluginConfig }))
-
-    if (!config.i18n) {
-      config.i18n = {}
-    }
-
-    if (!config.i18n.translations) {
-      config.i18n.translations = {}
-    }
-
-    const supportedLanguageKeys = config.i18n.supportedLanguages
-      ? Object.keys(config.i18n.supportedLanguages)
-      : ['en']
-
-    for (const lang of supportedLanguageKeys) {
-      const pluginEntry = translations[lang as keyof typeof translations]
-      if (!pluginEntry) {
-        continue
-      }
-
-      const typedLocale = lang as AcceptedLanguages
-      const existing = (config.i18n.translations[typedLocale] ?? {}) as Record<string, unknown>
-      config.i18n.translations[typedLocale] = {
-        ...existing,
-        'plugin-mcp': pluginEntry.translations['plugin-mcp'],
-      } as PluginDefaultTranslationsObject
-    }
-
-    // Keep the API-keys collection registered even when disabled, so DB schema
-    // and generated types don't drift between enabled/disabled environments.
     if (pluginConfig.disabled) {
       return config
     }
 
     return {
       ...config,
-      admin: {
-        ...config.admin,
-        components: {
-          ...config.admin?.components,
-          userMenuSettingsItems: [
-            ...(config.admin?.components?.userMenuSettingsItems ?? []),
-            '@payloadcms/plugin-mcp/client#MCPSettingsMenu',
-          ],
-        },
-      },
       endpoints: [
         ...(config.endpoints ?? []),
         // Payload prefixes /api, so the full path is /api/mcp.

package/src/mcp/buildMcpServer.ts

@@ -17,10 +17,10 @@ import { getLogger } from '../utils/getLogger.js'
 import { toStandardSchema } from '../utils/toStandardSchema.js'
 
 /**
- * Transport-agnostic core: registers every authorized MCP item onto a fresh
- * `McpServer` and returns it. The caller is responsible for picking a transport
- * (`WebStandardStreamableHTTPServerTransport`, `StdioServerTransport`, …) and
- * calling `server.connect(transport)`.
+ * Serving-entry-agnostic core: registers every authorized MCP item onto a fresh
+ * `McpServer` and returns it. The HTTP and stdio entry point callers provide fresh
+ * instances from this builder while they own the transport and protocol-era
+ * decision.
  *
  * `req` is the request context handlers see. For HTTP it's the live
  * `PayloadRequest` derived from the incoming HTTP request; for stdio it's a
@@ -47,11 +47,21 @@ export const buildMcpServer = ({
    * Wrap a tool handler's response with the tool's `overrideResponse`, then
    * strip the internal `doc` field so it doesn't leak onto the wire.
    */
-  const finalizeToolResponse = (
-    response: MCPToolResponse,
-    overrideResponse?: MCPResponseOverride,
-  ): MCPToolResponse => {
-    const overridden = overrideResponse?.(response, response.doc ?? {}, req) ?? response
+  const finalizeToolResponse = async ({
+    input,
+    overrideResponse,
+    response,
+    toolName,
+  }: {
+    input: unknown
+    overrideResponse?: MCPResponseOverride
+    response: MCPToolResponse
+    toolName: string
+  }): Promise<MCPToolResponse> => {
+    let overridden = overrideResponse?.(response, response.doc ?? {}, req) ?? response
+    for (const hook of pluginConfig.hooks?.afterToolCall ?? []) {
+      overridden = await hook({ input, req, response: overridden, toolName })
+    }
     const { doc: _doc, ...rest } = overridden
     return rest
   }
@@ -109,12 +119,22 @@ export const buildMcpServer = ({
       }
     }
 
-    const handlerArgs = { authorizedMCP, input: toolInput, req, serverContext }
+    const handlerArgs = {
+      authorizedMCP,
+      input: toolInput,
+      req,
+      serverContext,
+    }
     const response = await (match.type === 'collectionTool'
       ? match.tool.handler({ ...handlerArgs, collectionSlug: slug })
       : match.tool.handler({ ...handlerArgs, globalSlug: slug }))
 
-    return finalizeToolResponse(response, match.tool.overrideResponse)
+    return finalizeToolResponse({
+      input: toolInput,
+      overrideResponse: match.tool.overrideResponse,
+      response,
+      toolName: match.mcpName,
+    })
   }
 
   try {
@@ -137,6 +157,7 @@ export const buildMcpServer = ({
           server.registerTool(
             item.mcpName,
             {
+              annotations: item.tool.annotations,
               description: item.tool.description,
               inputSchema: toStandardSchema(inputSchema),
             },
@@ -193,19 +214,25 @@ export const buildMcpServer = ({
           server.registerTool(
             item.mcpName,
             {
+              annotations: tool.annotations,
               description: tool.description,
               inputSchema: tool.input ? toStandardSchema(tool.input) : undefined,
             },
-            async (input: unknown, ctx: ServerContext) =>
-              finalizeToolResponse(
-                await tool.handler({
-                  authorizedMCP,
-                  input: (input ?? {}) as Record<string, unknown>,
-                  req,
-                  serverContext: ctx,
-                }),
-                tool.overrideResponse,
-              ),
+            async (input: unknown, ctx: ServerContext) => {
+              const toolInput = (input ?? {}) as Record<string, unknown>
+              const response = await tool.handler({
+                authorizedMCP,
+                input: toolInput,
+                req,
+                serverContext: ctx,
+              })
+              return finalizeToolResponse({
+                input: toolInput,
+                overrideResponse: tool.overrideResponse,
+                response,
+                toolName: item.mcpName,
+              })
+            },
           )
           logger.info(`✅ Tool: ${item.mcpName} Registered.`)
           break

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

@@ -32,13 +32,18 @@ const wrapError =
   }
 
 export const authCollectionTool = defineCollectionTool({
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+    readOnlyHint: true,
+    title: 'Check Auth Status',
+  },
   description: 'Checks authentication status for the current user.',
   input: z.object({
     headers: z
-      .string()
-      .describe(
-        'Optional JSON string containing custom headers to send with the authentication request',
-      )
+      .record(z.string(), z.string())
+      .describe('Optional custom headers to send with the authentication request')
       .optional(),
   }),
 }).handler(async ({ collectionSlug, input, req }) => {
@@ -46,11 +51,7 @@ export const authCollectionTool = defineCollectionTool({
   try {
     let authHeaders = new Headers()
     if (input.headers) {
-      try {
-        authHeaders = new Headers(JSON.parse(input.headers) as Record<string, string>)
-      } catch {
-        logger.warn(`Invalid headers JSON for auth: ${input.headers}, using empty headers`)
-      }
+      authHeaders = new Headers(input.headers)
     }
     const result = await req.payload.auth({ headers: authHeaders })
     return {
@@ -70,6 +71,13 @@ export const authCollectionTool = defineCollectionTool({
 })
 
 export const forgotPasswordCollectionTool = defineCollectionTool({
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true,
+    readOnlyHint: false,
+    title: 'Forgot Password',
+  },
   description: 'Sends a password reset email to a user.',
   input: z.object({
     disableEmail: z
@@ -104,6 +112,13 @@ export const forgotPasswordCollectionTool = defineCollectionTool({
 })
 
 export const loginCollectionTool = defineCollectionTool({
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: false,
+    readOnlyHint: false,
+    title: 'User Login',
+  },
   description: 'Authenticates a user with email and password.',
   input: z.object({
     depth: z
@@ -148,6 +163,13 @@ export const loginCollectionTool = defineCollectionTool({
 })
 
 export const resetPasswordCollectionTool = defineCollectionTool({
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: false,
+    readOnlyHint: false,
+    title: 'Reset Password',
+  },
   description: 'Resets a user password with a reset token.',
   input: z.object({
     password: z.string().describe('The new password for the user'),
@@ -178,6 +200,13 @@ export const resetPasswordCollectionTool = defineCollectionTool({
 })
 
 export const unlockCollectionTool = defineCollectionTool({
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+    readOnlyHint: false,
+    title: 'Unlock Account',
+  },
   description: 'Unlocks a user account that has been locked due to failed login attempts.',
   input: z.object({ email: emailSchema }),
 }).handler(async ({ collectionSlug, input, req }) => {
@@ -205,6 +234,13 @@ export const unlockCollectionTool = defineCollectionTool({
 })
 
 export const verifyCollectionTool = defineCollectionTool({
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: false,
+    readOnlyHint: false,
+    title: 'Email Verification',
+  },
   description: 'Verifies a user email with a verification token.',
   input: z.object({
     token: z.string().describe('The verification token sent to the user email'),

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

@@ -0,0 +1,73 @@
+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 =
+  'Count documents in any collection by passing the collection slug and optional where clause.'
+
+export const countDocumentsTool = defineCollectionTool({
+  access: (args) =>
+    defaultAccess(args) && Boolean(args.permissions?.collections?.[args.collectionSlug]?.read),
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+    readOnlyHint: true,
+    title: 'Count Documents',
+  },
+  description: DEFAULT_DESCRIPTION,
+  input: z.object({
+    locale: z.string().describe('Optional: locale code to count documents in').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 { locale, trash, where } = input
+
+  logger.info(`Counting documents in collection: ${collectionSlug}`)
+
+  try {
+    const result = await payload.count({
+      collection: collectionSlug,
+      overrideAccess: authorizedMCP.overrideAccess,
+      req,
+      ...(locale ? { locale } : {}),
+      ...(trash !== undefined ? { trash } : {}),
+      ...(where ? { where } : {}),
+    })
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Collection "${collectionSlug}" contains ${result.totalDocs} matching documents.\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
+        },
+      ],
+      doc: result,
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+    logger.error(`Error counting documents in ${collectionSlug}: ${errorMessage}`)
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `❌ **Error counting documents in collection "${collectionSlug}":** ${errorMessage}`,
+        },
+      ],
+      isError: true,
+    }
+  }
+})

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

@@ -0,0 +1,69 @@
+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 =
+  'Count document versions in any version-enabled collection by passing the collection slug and optional where clause.'
+
+export const countVersionsTool = defineCollectionTool({
+  access: (args) =>
+    defaultAccess(args) &&
+    Boolean(args.permissions?.collections?.[args.collectionSlug]?.readVersions),
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+    readOnlyHint: true,
+    title: 'Count Versions',
+  },
+  description: DEFAULT_DESCRIPTION,
+  input: z.object({
+    locale: z.string().describe('Optional: locale code to count versions in').optional(),
+    where: whereSchema
+      .describe(
+        'Optional: where clause for filtering versions. Version document fields are usually under "version". Example: {"version.title":{"contains":"test"}}',
+      )
+      .optional(),
+  }),
+}).handler(async ({ authorizedMCP, collectionSlug, input, req }) => {
+  const payload = req.payload
+  const logger = getLogger({ payload })
+  const { locale, where } = input
+
+  logger.info(`Counting versions in collection: ${collectionSlug}`)
+
+  try {
+    const result = await payload.countVersions({
+      collection: collectionSlug,
+      overrideAccess: authorizedMCP.overrideAccess,
+      req,
+      ...(locale ? { locale } : {}),
+      ...(where ? { where } : {}),
+    })
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Collection "${collectionSlug}" contains ${result.totalDocs} matching versions.\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
+        },
+      ],
+      doc: result,
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+    logger.error(`Error counting versions in ${collectionSlug}: ${errorMessage}`)
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `❌ **Error counting versions in collection "${collectionSlug}":** ${errorMessage}`,
+        },
+      ],
+      isError: true,
+    }
+  }
+})