@payloadcms/plugin-mcp 4.0.0-internal.688c4d0 → 4.0.0-internal.77191e5

package/src/mcp/buildMcpServer.ts

@@ -1,6 +1,7 @@
+import type { PayloadRequest } from 'payload'
+
 import { McpServer, type ServerContext } from '@modelcontextprotocol/server'
-import { APIError, type PayloadRequest } from 'payload'
-import { z } from 'zod'
+import { APIError, strictObject, z } from 'payload'
 
 import type {
   AuthorizedMCP,
@@ -17,10 +18,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
@@ -35,6 +36,8 @@ export const buildMcpServer = ({
   pluginConfig: SanitizedMCPPluginConfig
   req: PayloadRequest
 }): McpServer => {
+  z.config(z.locales.en())
+
   const serverOptions = pluginConfig.mcp?.serverOptions || {}
   const server = new McpServer(
     { name: 'Payload MCP Server', version: '1.0.0', ...serverOptions.serverInfo },
@@ -47,18 +50,28 @@ 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
   }
 
   /**
    * Runs a collection/global tool call:
-   * - reads `collectionSlug` / `globalSlug` from the input
+   * - reads `slug` from the input
    * - runs access control: errors if `authorizedMCP.items` has no entry for this tool + slug
    * - runs the tool handler and finalizes its response
    */
@@ -72,16 +85,15 @@ export const buildMcpServer = ({
     serverContext: ServerContext
   }): Promise<MCPToolResponse> => {
     const entity = item.type === 'collectionTool' ? 'collection' : 'global'
-    const slugKey = item.type === 'collectionTool' ? 'collectionSlug' : 'globalSlug'
     const toolInput = (input ?? {}) as Record<string, unknown>
-    const slug = toolInput[slugKey] as string | undefined
+    const slug = toolInput.slug as string | undefined
 
     if (!slug) {
       return {
         content: [
           {
             type: 'text',
-            text: `Error: "${item.mcpName}" requires ${slugKey}. Use getConfigInfo to inspect ${entity} slugs.`,
+            text: `Error: "${item.mcpName}" requires slug. Use getConfigInfo to inspect ${entity} slugs.`,
           },
         ],
         isError: true,
@@ -109,12 +121,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 }))
+      ? match.tool.handler({ ...handlerArgs, slug })
+      : match.tool.handler({ ...handlerArgs, slug }))
 
-    return finalizeToolResponse(response, match.tool.overrideResponse)
+    return finalizeToolResponse({
+      input: toolInput,
+      overrideResponse: match.tool.overrideResponse,
+      response,
+      toolName: match.mcpName,
+    })
   }
 
   try {
@@ -129,14 +151,12 @@ export const buildMcpServer = ({
           }
           registeredEntityTools.add(item.mcpName)
 
-          const inputSchema = withSlugInput({
-            name: item.type === 'collectionTool' ? 'collectionSlug' : 'globalSlug',
-            input: item.tool.input,
-          })
+          const inputSchema = withSlugInput({ input: item.tool.input })
 
           server.registerTool(
             item.mcpName,
             {
+              annotations: item.tool.annotations,
               description: item.tool.description,
               inputSchema: toStandardSchema(inputSchema),
             },
@@ -193,19 +213,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
@@ -219,39 +245,50 @@ export const buildMcpServer = ({
   return server
 }
 
-const withSlugInput = ({
-  name,
-  input,
-}: {
-  input?: ToolInputSchema
-  name: 'collectionSlug' | 'globalSlug'
-}): ToolInputSchema => {
-  const description = name === 'collectionSlug' ? 'The collection slug' : 'The global slug'
-  const slugSchema = z.string().describe(description)
+const withSlugInput = ({ input }: { input?: ToolInputSchema }): ToolInputSchema => {
+  const description = 'The target slug.'
+  const slugSchema = z.string().check(z.describe(description))
 
   if (!input) {
-    return z.object({ [name]: slugSchema })
+    return strictObject({ slug: slugSchema }) as unknown as ToolInputSchema
   }
 
-  if (input instanceof z.ZodObject) {
-    return input.extend({ [name]: slugSchema })
+  if (typeof input === 'object' && input !== null && '~standard' in input) {
+    const schema = input['~standard'].jsonSchema.input({ target: 'draft-2020-12' })
+    const properties = schema.properties as Record<string, unknown> | undefined
+
+    if (properties?.slug) {
+      return input
+    }
+
+    return addSlugToJSONSchema({ description, schema: schema as JsonSchemaType })
   }
 
-  const schema = input as {
+  return addSlugToJSONSchema({ description, schema: input })
+}
+
+const addSlugToJSONSchema = ({
+  description,
+  schema,
+}: {
+  description: string
+  schema: JsonSchemaType
+}): JsonSchemaType => {
+  const objectSchema = schema as {
     properties?: Record<string, JsonSchemaType>
     required?: string[]
   } & JsonSchemaType
 
   return {
-    ...schema,
+    ...objectSchema,
     type: 'object',
     properties: {
-      ...schema.properties,
-      [name]: {
+      ...objectSchema.properties,
+      slug: {
         type: 'string',
         description,
       },
     },
-    required: Array.from(new Set([name, ...(schema.required ?? [])])),
+    required: Array.from(new Set(['slug', ...(objectSchema.required ?? [])])),
   }
 }

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

@@ -1,7 +1,8 @@
-import { z } from 'zod'
+import { createLocalReq, strictObject, z } from 'payload'
 
 import type { MCPToolResponse } from '../../../types.js'
 
+import { defaultAccess } from '../../../defaultAccess.js'
 import { defineCollectionTool } from '../../../defineTool.js'
 import { getLogger } from '../../../utils/getLogger.js'
 
@@ -16,43 +17,62 @@ import { getLogger } from '../../../utils/getLogger.js'
  * users collection so all auth-shaped tools live in one place.
  */
 
-const emailSchema = z.string().email().describe('The user email address')
+const emailSchema = z.email().check(z.describe('The user email address.'))
 
 const wrapError =
   (name: string) =>
-  ({ collectionSlug, message }: { collectionSlug: string; message: string }): MCPToolResponse => {
+  ({ slug, message }: { message: string; slug: string }): MCPToolResponse => {
     return {
       content: [
         {
           type: 'text',
-          text: `❌ **Error in ${name}** on ${collectionSlug}: ${message}`,
+          text: `❌ **Error in ${name}** on ${slug}: ${message}`,
         },
       ],
     }
   }
 
 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({
+  input: strictObject({
     headers: z
-      .string()
-      .describe(
-        'Optional JSON string containing custom headers to send with the authentication request',
-      )
-      .optional(),
+      .optional(z.record(z.string(), z.string()))
+      .check(z.describe('Custom headers to send with the authentication request.')),
   }),
-}).handler(async ({ collectionSlug, input, req }) => {
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
   const logger = getLogger({ payload: req.payload })
   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 authReq = await createLocalReq({ req: { headers: authHeaders } }, req.payload)
+    const result = await req.payload.auth({ headers: authHeaders, req: authReq })
+
+    if (result.user) {
+      const authenticatedUser = result.user
+      // Auth strategies read users with trusted Local API access. Re-read the user with the MCP
+      // caller's access level before returning it to the client.
+      const user = await req.payload.findByID({
+        id: authenticatedUser.id,
+        collection: authenticatedUser.collection,
+        overrideAccess: authorizedMCP.overrideAccess,
+        req: authReq,
+      })
+      result.user = {
+        ...user,
+        _sid: authenticatedUser._sid,
+        _strategy: authenticatedUser._strategy,
+        collection: authenticatedUser.collection,
       }
     }
-    const result = await req.payload.auth({ headers: authHeaders })
     return {
       content: [
         {
@@ -64,170 +84,194 @@ export const authCollectionTool = defineCollectionTool({
     }
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : 'Unknown error'
-    logger.error(`Error in auth tool on ${collectionSlug}: ${errorMessage}`)
-    return wrapError('auth')({ collectionSlug, message: errorMessage })
+    logger.error(`Error in auth tool on ${slug}: ${errorMessage}`)
+    return wrapError('auth')({ slug, message: errorMessage })
   }
 })
 
 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
-      .boolean()
-      .describe('Whether to disable sending the email (for testing)')
-      .optional()
-      .default(false),
+  input: strictObject({
     email: emailSchema,
   }),
-}).handler(async ({ collectionSlug, input, req }) => {
+}).handler(async ({ slug, input, req }) => {
   const logger = getLogger({ payload: req.payload })
   try {
-    const result = await req.payload.forgotPassword({
-      collection: collectionSlug,
+    await req.payload.forgotPassword({
+      collection: slug,
       data: { email: input.email },
-      disableEmail: input.disableEmail,
+      disableEmail: false,
+      overrideAccess: false,
+      req,
     })
     return {
       content: [
         {
           type: 'text',
-          text: `# Forgot Password Email Sent\n\n**Collection:** ${collectionSlug}\n**Email:** ${input.email}\n\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
+          text: 'If an account matches that email, password reset instructions have been sent.',
         },
       ],
-      doc: { result } as Record<string, unknown>,
     }
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : 'Unknown error'
-    logger.error(`Error in forgotPassword tool on ${collectionSlug}: ${errorMessage}`)
-    return wrapError('forgotPassword')({ collectionSlug, message: errorMessage })
+    logger.error(`Error in forgotPassword tool on ${slug}: ${errorMessage}`)
+    return wrapError('forgotPassword')({ slug, message: errorMessage })
   }
 })
 
 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({
+  input: strictObject({
     depth: z
-      .number()
-      .int()
-      .min(0)
-      .max(10)
-      .describe('Depth of population for relationships')
-      .optional()
-      .default(0),
+      ._default(z.int().check(z.minimum(0), z.maximum(10)), 0)
+      .check(z.describe('Depth of population for relationships.')),
     email: emailSchema,
-    password: z.string().describe('The user password'),
-    showHiddenFields: z
-      .boolean()
-      .describe('Whether to show hidden fields in the response')
-      .optional()
-      .default(false),
+    password: z.string().check(z.describe('The user password.')),
   }),
-}).handler(async ({ collectionSlug, input, req }) => {
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
   const logger = getLogger({ payload: req.payload })
   try {
     const result = await req.payload.login({
-      collection: collectionSlug,
+      collection: slug,
       data: { email: input.email, password: input.password },
       depth: input.depth,
-      showHiddenFields: input.showHiddenFields,
+      overrideAccess: authorizedMCP.overrideAccess,
     })
     return {
       content: [
         {
           type: 'text',
-          text: `# Login Successful\n\n**User:** ${input.email}\n**Collection:** ${collectionSlug}\n\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
+          text: `# Login Successful\n\n**User:** ${input.email}\n**Collection:** ${slug}\n\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 in login tool on ${collectionSlug}: ${errorMessage}`)
-    return wrapError('login')({ collectionSlug, message: errorMessage })
+    logger.error(`Error in login tool on ${slug}: ${errorMessage}`)
+    return wrapError('login')({ slug, message: errorMessage })
   }
 })
 
 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'),
-    token: z.string().describe('The password reset token sent to the user email'),
+  input: strictObject({
+    password: z.string().check(z.describe('The new password for the user.')),
+    token: z.string().check(z.describe('The password reset token sent to the user email.')),
   }),
-}).handler(async ({ collectionSlug, input, req }) => {
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
   const logger = getLogger({ payload: req.payload })
   try {
     const result = await req.payload.resetPassword({
-      collection: collectionSlug,
+      collection: slug,
       data: { password: input.password, token: input.token },
-      overrideAccess: true,
+      overrideAccess: authorizedMCP.overrideAccess,
     })
     return {
       content: [
         {
           type: 'text',
-          text: `# Password Reset Successful\n\n**Collection:** ${collectionSlug}\n\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
+          text: `# Password Reset Successful\n\n**Collection:** ${slug}\n\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 in resetPassword tool on ${collectionSlug}: ${errorMessage}`)
-    return wrapError('resetPassword')({ collectionSlug, message: errorMessage })
+    logger.error(`Error in resetPassword tool on ${slug}: ${errorMessage}`)
+    return wrapError('resetPassword')({ slug, message: errorMessage })
   }
 })
 
 export const unlockCollectionTool = defineCollectionTool({
+  access: (args) =>
+    defaultAccess(args) && Boolean(args.permissions?.collections?.[args.slug]?.unlock),
+  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 }) => {
+  input: strictObject({ email: emailSchema }),
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
   const logger = getLogger({ payload: req.payload })
   try {
     const result = await req.payload.unlock({
-      collection: collectionSlug,
+      collection: slug,
       data: { email: input.email },
-      overrideAccess: true,
+      overrideAccess: authorizedMCP.overrideAccess,
+      req,
     })
     return {
       content: [
         {
           type: 'text',
-          text: `# Account Unlocked\n\n**Collection:** ${collectionSlug}\n**Email:** ${input.email}\n**Result:** ${result ? 'Success' : 'Failed'}`,
+          text: `# Account Unlocked\n\n**Collection:** ${slug}\n**Email:** ${input.email}\n**Result:** ${result ? 'Success' : 'Failed'}`,
         },
       ],
       doc: { result } as Record<string, unknown>,
     }
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : 'Unknown error'
-    logger.error(`Error in unlock tool on ${collectionSlug}: ${errorMessage}`)
-    return wrapError('unlock')({ collectionSlug, message: errorMessage })
+    logger.error(`Error in unlock tool on ${slug}: ${errorMessage}`)
+    return wrapError('unlock')({ slug, message: errorMessage })
   }
 })
 
 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'),
+  input: strictObject({
+    token: z.string().check(z.describe('The verification token sent to the user email.')),
   }),
-}).handler(async ({ collectionSlug, input, req }) => {
+}).handler(async ({ slug, input, req }) => {
   const logger = getLogger({ payload: req.payload })
   try {
     const result = await req.payload.verifyEmail({
-      collection: collectionSlug,
+      collection: slug,
       token: input.token,
     })
     return {
       content: [
         {
           type: 'text',
-          text: `# Email Verification Successful\n\n**Collection:** ${collectionSlug}\n**Result:** ${result ? 'Success' : 'Failed'}`,
+          text: `# Email Verification Successful\n\n**Collection:** ${slug}\n**Result:** ${result ? 'Success' : 'Failed'}`,
         },
       ],
       doc: { result } as Record<string, unknown>,
     }
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : 'Unknown error'
-    logger.error(`Error in verify tool on ${collectionSlug}: ${errorMessage}`)
-    return wrapError('verify')({ collectionSlug, message: errorMessage })
+    logger.error(`Error in verify tool on ${slug}: ${errorMessage}`)
+    return wrapError('verify')({ slug, message: errorMessage })
   }
 })

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

@@ -0,0 +1,61 @@
+import { countDocumentsInputSchema } from 'payload'
+
+import { defaultAccess } from '../../../defaultAccess.js'
+import { defineCollectionTool } from '../../../defineTool.js'
+import { getLogger } from '../../../utils/getLogger.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.slug]?.read),
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+    readOnlyHint: true,
+    title: 'Count Documents',
+  },
+  description: DEFAULT_DESCRIPTION,
+  input: countDocumentsInputSchema,
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
+  const payload = req.payload
+  const logger = getLogger({ payload })
+  const { locale, trash, where } = input
+
+  logger.info(`Counting documents in collection: ${slug}`)
+
+  try {
+    const result = await payload.count({
+      collection: slug,
+      overrideAccess: authorizedMCP.overrideAccess,
+      req,
+      ...(locale ? { locale } : {}),
+      ...(trash !== undefined ? { trash } : {}),
+      ...(where ? { where } : {}),
+    })
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Collection "${slug}" 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 ${slug}: ${errorMessage}`)
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `❌ **Error counting documents in collection "${slug}":** ${errorMessage}`,
+        },
+      ],
+      isError: true,
+    }
+  }
+})