@payloadcms/plugin-mcp 4.0.0-internal.cd69eef → 4.0.0-internal.ce66a41

package/dist/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/types.ts"],"sourcesContent":["import type {\n  CallToolResult,\n  ContentBlock,\n  JsonSchemaType,\n  McpServer,\n  ResourceTemplate,\n  ServerContext,\n  StandardSchemaWithJSON,\n  ToolAnnotations,\n} from '@modelcontextprotocol/server'\nimport type {\n  AuthCollectionSlug,\n  CollectionSlug,\n  GlobalSlug,\n  MaybePromise,\n  PayloadRequest,\n  SanitizedPermissions,\n} from 'payload'\n\nimport type { GetAuthorizedMCPArgs } from './endpoint/access.js'\nimport type {\n  MCPCollectionAuthToolName,\n  MCPCollectionBuiltinName,\n  MCPGlobalBuiltinName,\n} from './mcp/builtinTools.js'\n\nexport type { MCPCollectionAuthToolName, MCPCollectionBuiltinName, MCPGlobalBuiltinName }\n\n/** Re-exported from `@modelcontextprotocol/server` — common MCP types used in plugin config. */\nexport type { JsonSchemaType, StandardSchemaWithJSON, ToolAnnotations }\n\n/**\n * What a tool's `input` (or a prompt's `argsSchema`) can be — either a raw\n * JSON Schema 2020-12 literal, or a Standard Schema instance (Zod, Valibot, …).\n * Raw schemas may omit `$schema`; when present it must declare the 2020-12 dialect.\n */\nexport type ToolInputSchema = JsonSchemaType | StandardSchemaWithJSON\n\nexport type MCPToolResponse = {\n  content: ContentBlock[]\n  /**\n   * If available, return the document fetched within the\n   * mcp tool. This is threaded as an additional argument to\n   * overrideResponse functions and stripped before going on the wire.\n   */\n  doc?: Record<string, unknown>\n} & Pick<CallToolResult, '_meta' | 'isError' | 'structuredContent'>\n\nexport type MCPResponseOverride = (\n  response: MCPToolResponse,\n  doc: Record<string, unknown>,\n  req: PayloadRequest,\n) => MCPToolResponse\n\nexport type MCPAfterToolCallHook = (args: {\n  input: unknown\n  req: PayloadRequest\n  response: MCPToolResponse\n  toolName: string\n}) => MaybePromise<MCPToolResponse>\n\n/**\n * The handler's `input` type. A specific Standard Schema (Zod, Valibot, …) gets\n * its inferred output; anything else falls back to `Record<string, unknown>`.\n */\nexport type TypedInput<TSchema> = TSchema extends StandardSchemaWithJSON\n  ? StandardSchemaWithJSON extends TSchema\n    ? Record<string, unknown>\n    : StandardSchemaWithJSON.InferOutput<TSchema>\n  : Record<string, unknown>\n\nexport type MCPAccessArgs = {\n  permissions?: SanitizedPermissions\n  req: PayloadRequest\n}\n\nexport type CollectionMCPAccessArgs = {\n  collectionSlug: CollectionSlug\n} & MCPAccessArgs\n\nexport type GlobalMCPAccessArgs = {\n  globalSlug: GlobalSlug\n} & MCPAccessArgs\n\nexport type ToolHandlerArgs<TSchema = undefined> = {\n  authorizedMCP: AuthorizedMCP\n  input: TypedInput<TSchema>\n  req: PayloadRequest\n  serverContext: ServerContext\n}\n\nexport type CollectionToolHandlerArgs<TSchema = undefined> = {\n  collectionSlug: CollectionSlug\n} & ToolHandlerArgs<TSchema>\n\nexport type GlobalToolHandlerArgs<TSchema = undefined> = {\n  globalSlug: GlobalSlug\n} & ToolHandlerArgs<TSchema>\n\nexport type Tool<TSchema extends ToolInputSchema | undefined = ToolInputSchema | undefined> = {\n  /**\n   * Runs while authorizing each MCP request, before the tool is advertised or called. Return\n   * `false` to make the tool unavailable for that request. This is skipped when `overrideAccess`\n   * is enabled.\n   */\n  access?: (args: MCPAccessArgs) => MaybePromise<boolean>\n  annotations?: ToolAnnotations\n  description: string\n  handler: (args: ToolHandlerArgs<TSchema>) => MaybePromise<MCPToolResponse>\n  input?: TSchema\n  /**\n   * Override the return value of the tool handler\n   */\n  overrideResponse?: MCPResponseOverride\n}\n\nexport type CollectionTool<\n  TSchema extends ToolInputSchema | undefined = ToolInputSchema | undefined,\n> = {\n  /**\n   * Runs while authorizing each MCP request for this collection. Return `false` to reject calls\n   * to this tool for the collection. The shared tool is not advertised when no collections allow\n   * it, but can remain advertised when it is available for another collection. This is skipped\n   * when `overrideAccess` is enabled.\n   */\n  access?: (args: CollectionMCPAccessArgs) => MaybePromise<boolean>\n  handler: (args: CollectionToolHandlerArgs<TSchema>) => MaybePromise<MCPToolResponse>\n  input?: TSchema\n} & Pick<Tool, 'annotations' | 'description' | 'overrideResponse'>\n\nexport type GlobalTool<TSchema extends ToolInputSchema | undefined = ToolInputSchema | undefined> =\n  {\n    /**\n     * Runs while authorizing each MCP request for this global. Return `false` to reject calls to\n     * this tool for the global. The shared tool is not advertised when no globals allow it, but\n     * can remain advertised when it is available for another global. This is skipped when\n     * `overrideAccess` is enabled.\n     */\n    access?: (args: GlobalMCPAccessArgs) => MaybePromise<boolean>\n    handler: (args: GlobalToolHandlerArgs<TSchema>) => MaybePromise<MCPToolResponse>\n    input?: TSchema\n  } & Pick<Tool, 'annotations' | 'description' | 'overrideResponse'>\n\n/**\n * Configures (or disables) a built-in tool without replacing it.\n * `handler?: never` prevents a full `CollectionTool`/`GlobalTool` (which has a\n * required handler) from being silently accepted at a built-in key slot.\n */\nexport type MCPBuiltInCollectionToolOverride = {\n  /**\n   * Replaces the built-in tool's access check. Return `false` to make the tool unavailable for\n   * this collection. This is skipped when `overrideAccess` is enabled.\n   */\n  access?: (args: CollectionMCPAccessArgs) => MaybePromise<boolean>\n  annotations?: ToolAnnotations\n  description?: string\n  handler?: never\n  overrideResponse?: MCPResponseOverride\n}\n\nexport type MCPBuiltInGlobalToolOverride = {\n  /**\n   * Replaces the built-in tool's access check. Return `false` to make the tool unavailable for\n   * this global. This is skipped when `overrideAccess` is enabled.\n   */\n  access?: (args: GlobalMCPAccessArgs) => MaybePromise<boolean>\n  annotations?: ToolAnnotations\n  description?: string\n  handler?: never\n  overrideResponse?: MCPResponseOverride\n}\n\n/**\n * Value at a custom (non-built-in) tool key. Either the tool itself, or `false`\n * to disable it (useful when one plugin defines a custom tool and another\n * wants to opt out per-collection).\n */\nexport type MCPTopLevelToolEntry = Tool\n\nexport type MCPCollectionToolsMap = {\n  [customToolName: string]: boolean | CollectionTool | MCPBuiltInCollectionToolOverride | undefined\n} & {\n  [K in MCPCollectionBuiltinName]?: false | MCPBuiltInCollectionToolOverride\n}\n\nexport type MCPAuthCollectionToolsMap = {\n  [K in MCPCollectionAuthToolName]?: MCPBuiltInCollectionToolOverride | true\n} & MCPCollectionToolsMap\n\n/** Auth-enabled collections get auth-tool name autocomplete; others get CRUD-only. */\nexport type MCPToolsMapForCollection<Slug extends CollectionSlug> = Slug extends AuthCollectionSlug\n  ? MCPAuthCollectionToolsMap\n  : MCPCollectionToolsMap\n\nexport type MCPGlobalToolsMap = {\n  [customToolName: string]: boolean | GlobalTool | MCPBuiltInGlobalToolOverride | undefined\n} & {\n  [K in MCPGlobalBuiltinName]?: false | MCPBuiltInGlobalToolOverride\n}\n\nexport type MCPTopLevelToolsMap = Record<string, Tool>\n\nexport type PromptHandlerArgs<TSchema = undefined> = {\n  input: TypedInput<TSchema>\n  req: PayloadRequest\n  serverContext: ServerContext\n}\n\nexport type Prompt<TSchema extends ToolInputSchema = ToolInputSchema> = {\n  /**\n   * Runs while authorizing each MCP request, before the prompt is advertised or used. Return\n   * `false` to make the prompt unavailable for that request. This is skipped when\n   * `overrideAccess` is enabled.\n   */\n  access?: (args: MCPAccessArgs) => MaybePromise<boolean>\n  argsSchema: TSchema\n  description: string\n  handler: (args: PromptHandlerArgs<TSchema>) => MaybePromise<{\n    messages: Array<{ content: { text: string; type: 'text' }; role: 'assistant' | 'user' }>\n  }>\n  title: string\n}\n\nexport type ResourceHandlerArgs = {\n  /** Variables extracted from a `ResourceTemplate` URI. Empty for static-URI resources. */\n  params: Record<string, string>\n  req: PayloadRequest\n  serverContext: ServerContext\n  uri: URL\n}\n\nexport type Resource = {\n  /**\n   * Runs while authorizing each MCP request, before the resource is advertised or read. Return\n   * `false` to make the resource unavailable for that request. This is skipped when\n   * `overrideAccess` is enabled.\n   */\n  access?: (args: MCPAccessArgs) => MaybePromise<boolean>\n  description: string\n  handler: (args: ResourceHandlerArgs) => MaybePromise<{\n    contents: Array<{ text: string; uri: string }>\n  }>\n  mimeType: string\n  title: string\n  uri: ResourceTemplate | string\n}\n\nexport type MCPPluginCollectionConfig<TSlug extends CollectionSlug> = {\n  description?: string\n  /** Fallback for built-in tools that don't set their own `overrideResponse`. */\n  overrideResponse?: MCPResponseOverride\n  tools?: MCPToolsMapForCollection<TSlug>\n}\n\nexport type MCPPluginGlobalConfig = {\n  description?: string\n  overrideResponse?: MCPResponseOverride\n  tools?: MCPGlobalToolsMap\n}\n\n/**\n * The user-facing config shape passed to `mcpPlugin({ ... })`. Tools, prompts,\n * resources, and per-collection/global tool maps live in their own nested\n * fields. `sanitizeMCPConfig` flattens those into `items` and applies defaults\n * to produce a `SanitizedMCPPluginConfig` — the form every internal consumer\n * actually works with.\n */\nexport type MCPPluginConfig = {\n  collections?: {\n    [Slug in CollectionSlug]?: MCPPluginCollectionConfig<Slug>\n  }\n  /** Skip MCP endpoint registration. */\n  disabled?: boolean\n  globals?: {\n    [Slug in GlobalSlug]?: MCPPluginGlobalConfig\n  }\n  hooks?: {\n    /** Transform a tool response after its handler returns */\n    afterToolCall?: MCPAfterToolCallHook[]\n  }\n  mcp?: {\n    serverOptions?: MCPServerOptions\n    verboseLogs?: boolean\n  }\n  /**\n   * Replace the default MCP authorization resolver.\n   *\n   * This hook replaces the default authentication flow. It must set `req.user` to the\n   * authenticated Payload user, or to `null` for an anonymous caller, before returning.\n   */\n  overrideGetAuthorizedMCP?: (\n    args: {\n      pluginConfig: SanitizedMCPPluginConfig\n    } & GetAuthorizedMCPArgs,\n  ) => MaybePromise<AuthorizedMCP>\n  prompts?: Record<string, Prompt>\n  resources?: Record<string, Resource>\n  /** Cross-cutting tools (not scoped to any collection or global). */\n  tools?: MCPTopLevelToolsMap\n}\n\nexport type SanitizedMCPPluginConfig = {\n  items: MCPItem[]\n} & Pick<MCPPluginConfig, 'disabled' | 'hooks' | 'mcp' | 'overrideGetAuthorizedMCP'>\n\nexport type MCPServerOptions = {\n  options?: ConstructorParameters<typeof McpServer>[1]\n  serverInfo?: Partial<ConstructorParameters<typeof McpServer>[0]>\n}\n\n/**\n * One MCP primitive plus the metadata needed for config-driven filtering and\n * registration.\n *\n * - `configKey`: the config identifier, e.g. `find` or `echo`.\n * - `mcpName`: the MCP wire name, e.g. `findDocuments` or `echo`.\n * - `label`: human-readable display text.\n */\nexport type MCPItemBase = {\n  configKey: string\n  label: string\n  mcpName: string\n}\n\nexport type CollectionMCPItem = {\n  collectionSlug: CollectionSlug\n  tool: CollectionTool\n  type: 'collectionTool'\n} & MCPItemBase\n\nexport type GlobalMCPItem = {\n  globalSlug: GlobalSlug\n  tool: GlobalTool\n  type: 'globalTool'\n} & MCPItemBase\n\nexport type MCPItem =\n  | ({\n      prompt: Prompt\n      type: 'prompt'\n    } & MCPItemBase)\n  | ({\n      resource: Resource\n      type: 'resource'\n    } & MCPItemBase)\n  | ({\n      tool: Tool\n      type: 'tool'\n    } & MCPItemBase)\n  | CollectionMCPItem\n  | GlobalMCPItem\n\n/**\n * The MCP items and access mode authorized for this request. The authenticated user is available\n * as `req.user`.\n */\nexport type AuthorizedMCP = {\n  items: MCPItem[]\n  overrideAccess: boolean\n}\n"],"names":[],"mappings":"AAgWA;;;CAGC,GACD,WAGC"}
+{"version":3,"sources":["../src/types.ts"],"sourcesContent":["import type {\n  CallToolResult,\n  ContentBlock,\n  Implementation,\n  JsonSchemaType,\n  McpServerOptions,\n  ResourceTemplate,\n  ServerContext,\n  StandardSchemaWithJSON,\n  ToolAnnotations,\n} from '@modelcontextprotocol/server'\nimport type {\n  AuthCollectionSlug,\n  CollectionSlug,\n  GlobalSlug,\n  MaybePromise,\n  PayloadRequest,\n  SanitizedPermissions,\n} from 'payload'\n\nimport type { GetAuthorizedMCPArgs } from './endpoint/access.js'\nimport type {\n  MCPCollectionAuthToolName,\n  MCPCollectionBuiltinName,\n  MCPGlobalBuiltinName,\n} from './mcp/builtinTools.js'\n\nexport type { MCPCollectionAuthToolName, MCPCollectionBuiltinName, MCPGlobalBuiltinName }\n\n/** Re-exported from `@modelcontextprotocol/server` — common MCP types used in plugin config. */\nexport type { JsonSchemaType, StandardSchemaWithJSON, ToolAnnotations }\n\n/**\n * What a tool's `input` (or a prompt's `argsSchema`) can be — either a raw\n * JSON Schema 2020-12 literal, or a Standard Schema instance (Zod, Valibot, …).\n * Raw schemas may omit `$schema`; when present it must declare the 2020-12 dialect.\n */\nexport type ToolInputSchema = JsonSchemaType | StandardSchemaWithJSON\n\nexport type MCPToolResponse = {\n  content: ContentBlock[]\n  /**\n   * If available, return the document fetched within the\n   * mcp tool. This is threaded as an additional argument to\n   * overrideResponse functions and stripped before going on the wire.\n   */\n  doc?: Record<string, unknown>\n} & Pick<CallToolResult, '_meta' | 'isError' | 'structuredContent'>\n\nexport type MCPResponseOverride = (\n  response: MCPToolResponse,\n  doc: Record<string, unknown>,\n  req: PayloadRequest,\n) => MCPToolResponse\n\nexport type MCPAfterToolCallHook = (args: {\n  input: unknown\n  req: PayloadRequest\n  response: MCPToolResponse\n  toolName: string\n}) => MaybePromise<MCPToolResponse>\n\n/**\n * The handler's `input` type. A specific Standard Schema (Zod, Valibot, …) gets\n * its inferred output; anything else falls back to `Record<string, unknown>`.\n */\nexport type TypedInput<TSchema> = TSchema extends StandardSchemaWithJSON\n  ? StandardSchemaWithJSON extends TSchema\n    ? Record<string, unknown>\n    : StandardSchemaWithJSON.InferOutput<TSchema>\n  : Record<string, unknown>\n\nexport type MCPAccessArgs = {\n  permissions?: SanitizedPermissions\n  req: PayloadRequest\n}\n\nexport type CollectionMCPAccessArgs = {\n  slug: CollectionSlug\n} & MCPAccessArgs\n\nexport type GlobalMCPAccessArgs = {\n  slug: GlobalSlug\n} & MCPAccessArgs\n\nexport type ToolHandlerArgs<TSchema = undefined> = {\n  authorizedMCP: AuthorizedMCP\n  input: TypedInput<TSchema>\n  req: PayloadRequest\n  serverContext: ServerContext\n}\n\nexport type CollectionToolHandlerArgs<TSchema = undefined> = {\n  slug: CollectionSlug\n} & ToolHandlerArgs<TSchema>\n\nexport type GlobalToolHandlerArgs<TSchema = undefined> = {\n  slug: GlobalSlug\n} & ToolHandlerArgs<TSchema>\n\nexport type Tool<TSchema extends ToolInputSchema | undefined = ToolInputSchema | undefined> = {\n  /**\n   * Runs while authorizing each MCP request, before the tool is advertised or called. Return\n   * `false` to make the tool unavailable for that request. This is skipped when `overrideAccess`\n   * is enabled.\n   */\n  access?: (args: MCPAccessArgs) => MaybePromise<boolean>\n  annotations?: ToolAnnotations\n  description: string\n  handler: (args: ToolHandlerArgs<TSchema>) => MaybePromise<MCPToolResponse>\n  input?: TSchema\n  /**\n   * Override the return value of the tool handler\n   */\n  overrideResponse?: MCPResponseOverride\n}\n\nexport type CollectionTool<\n  TSchema extends ToolInputSchema | undefined = ToolInputSchema | undefined,\n> = {\n  /**\n   * Runs while authorizing each MCP request for this collection. Return `false` to reject calls\n   * to this tool for the collection. The shared tool is not advertised when no collections allow\n   * it, but can remain advertised when it is available for another collection. This is skipped\n   * when `overrideAccess` is enabled.\n   */\n  access?: (args: CollectionMCPAccessArgs) => MaybePromise<boolean>\n  handler: (args: CollectionToolHandlerArgs<TSchema>) => MaybePromise<MCPToolResponse>\n  input?: TSchema\n} & Pick<Tool, 'annotations' | 'description' | 'overrideResponse'>\n\nexport type GlobalTool<TSchema extends ToolInputSchema | undefined = ToolInputSchema | undefined> =\n  {\n    /**\n     * Runs while authorizing each MCP request for this global. Return `false` to reject calls to\n     * this tool for the global. The shared tool is not advertised when no globals allow it, but\n     * can remain advertised when it is available for another global. This is skipped when\n     * `overrideAccess` is enabled.\n     */\n    access?: (args: GlobalMCPAccessArgs) => MaybePromise<boolean>\n    handler: (args: GlobalToolHandlerArgs<TSchema>) => MaybePromise<MCPToolResponse>\n    input?: TSchema\n  } & Pick<Tool, 'annotations' | 'description' | 'overrideResponse'>\n\n/**\n * Configures (or disables) a built-in tool without replacing it.\n * `handler?: never` prevents a full `CollectionTool`/`GlobalTool` (which has a\n * required handler) from being silently accepted at a built-in key slot.\n */\nexport type MCPBuiltInCollectionToolOverride = {\n  /**\n   * Replaces the built-in tool's access check. Return `false` to make the tool unavailable for\n   * this collection. This is skipped when `overrideAccess` is enabled.\n   */\n  access?: (args: CollectionMCPAccessArgs) => MaybePromise<boolean>\n  annotations?: ToolAnnotations\n  description?: string\n  handler?: never\n  overrideResponse?: MCPResponseOverride\n}\n\nexport type MCPBuiltInGlobalToolOverride = {\n  /**\n   * Replaces the built-in tool's access check. Return `false` to make the tool unavailable for\n   * this global. This is skipped when `overrideAccess` is enabled.\n   */\n  access?: (args: GlobalMCPAccessArgs) => MaybePromise<boolean>\n  annotations?: ToolAnnotations\n  description?: string\n  handler?: never\n  overrideResponse?: MCPResponseOverride\n}\n\n/**\n * Value at a custom (non-built-in) tool key. Either the tool itself, or `false`\n * to disable it (useful when one plugin defines a custom tool and another\n * wants to opt out per-collection).\n */\nexport type MCPTopLevelToolEntry = Tool\n\nexport type MCPCollectionToolsMap = {\n  [customToolName: string]: boolean | CollectionTool | MCPBuiltInCollectionToolOverride | undefined\n} & {\n  [K in MCPCollectionBuiltinName]?: false | MCPBuiltInCollectionToolOverride\n}\n\nexport type MCPAuthCollectionToolsMap = {\n  [K in MCPCollectionAuthToolName]?: MCPBuiltInCollectionToolOverride | true\n} & MCPCollectionToolsMap\n\n/** Auth-enabled collections get auth-tool name autocomplete; others get CRUD-only. */\nexport type MCPToolsMapForCollection<Slug extends CollectionSlug> = Slug extends AuthCollectionSlug\n  ? MCPAuthCollectionToolsMap\n  : MCPCollectionToolsMap\n\nexport type MCPGlobalToolsMap = {\n  [customToolName: string]: boolean | GlobalTool | MCPBuiltInGlobalToolOverride | undefined\n} & {\n  [K in MCPGlobalBuiltinName]?: false | MCPBuiltInGlobalToolOverride\n}\n\nexport type MCPTopLevelToolsMap = Record<string, Tool>\n\nexport type PromptHandlerArgs<TSchema = undefined> = {\n  input: TypedInput<TSchema>\n  req: PayloadRequest\n  serverContext: ServerContext\n}\n\nexport type Prompt<TSchema extends ToolInputSchema = ToolInputSchema> = {\n  /**\n   * Runs while authorizing each MCP request, before the prompt is advertised or used. Return\n   * `false` to make the prompt unavailable for that request. This is skipped when\n   * `overrideAccess` is enabled.\n   */\n  access?: (args: MCPAccessArgs) => MaybePromise<boolean>\n  argsSchema: TSchema\n  description: string\n  handler: (args: PromptHandlerArgs<TSchema>) => MaybePromise<{\n    messages: Array<{ content: { text: string; type: 'text' }; role: 'assistant' | 'user' }>\n  }>\n  title: string\n}\n\nexport type ResourceHandlerArgs = {\n  /** Variables extracted from a `ResourceTemplate` URI. Empty for static-URI resources. */\n  params: Record<string, string>\n  req: PayloadRequest\n  serverContext: ServerContext\n  uri: URL\n}\n\nexport type Resource = {\n  /**\n   * Runs while authorizing each MCP request, before the resource is advertised or read. Return\n   * `false` to make the resource unavailable for that request. This is skipped when\n   * `overrideAccess` is enabled.\n   */\n  access?: (args: MCPAccessArgs) => MaybePromise<boolean>\n  description: string\n  handler: (args: ResourceHandlerArgs) => MaybePromise<{\n    contents: Array<{ text: string; uri: string }>\n  }>\n  mimeType: string\n  title: string\n  uri: ResourceTemplate | string\n}\n\nexport type MCPPluginCollectionConfig<TSlug extends CollectionSlug> = {\n  description?: string\n  /** Fallback for built-in tools that don't set their own `overrideResponse`. */\n  overrideResponse?: MCPResponseOverride\n  tools?: MCPToolsMapForCollection<TSlug>\n}\n\nexport type MCPPluginGlobalConfig = {\n  description?: string\n  overrideResponse?: MCPResponseOverride\n  tools?: MCPGlobalToolsMap\n}\n\n/**\n * The user-facing config shape passed to `mcpPlugin({ ... })`. Tools, prompts,\n * resources, and per-collection/global tool maps live in their own nested\n * fields. `sanitizeMCPConfig` flattens those into `items` and applies defaults\n * to produce a `SanitizedMCPPluginConfig` — the form every internal consumer\n * actually works with.\n */\nexport type MCPPluginConfig = {\n  collections?: {\n    [Slug in CollectionSlug]?: MCPPluginCollectionConfig<Slug>\n  }\n  /** Skip MCP endpoint registration. */\n  disabled?: boolean\n  globals?: {\n    [Slug in GlobalSlug]?: MCPPluginGlobalConfig\n  }\n  hooks?: {\n    /** Transform a tool response after its handler returns */\n    afterToolCall?: MCPAfterToolCallHook[]\n  }\n  mcp?: {\n    /**\n     * Largest HTTP request body, in bytes, that the MCP endpoint accepts. Larger requests\n     * are answered with `413`. Base64 file uploads count toward this limit.\n     *\n     * @default 4194304 (4 MiB, the MCP SDK default)\n     */\n    maxRequestBodySize?: number\n    serverOptions?: MCPServerOptions\n    verboseLogs?: boolean\n  }\n  /**\n   * Replace the default MCP authorization resolver.\n   *\n   * This hook replaces the default authentication flow. It must set `req.user` to the\n   * authenticated Payload user, or to `null` for an anonymous caller, before returning.\n   */\n  overrideGetAuthorizedMCP?: (\n    args: {\n      pluginConfig: SanitizedMCPPluginConfig\n    } & GetAuthorizedMCPArgs,\n  ) => MaybePromise<AuthorizedMCP>\n  prompts?: Record<string, Prompt>\n  resources?: Record<string, Resource>\n  /** Cross-cutting tools (not scoped to any collection or global). */\n  tools?: MCPTopLevelToolsMap\n}\n\nexport type SanitizedMCPPluginConfig = {\n  items: MCPItem[]\n} & Pick<MCPPluginConfig, 'disabled' | 'hooks' | 'mcp' | 'overrideGetAuthorizedMCP'>\n\nexport type MCPServerOptions = {\n  options?: McpServerOptions\n  serverInfo?: Partial<Implementation>\n}\n\n/**\n * One MCP primitive plus the metadata needed for config-driven filtering and\n * registration.\n *\n * - `configKey`: the config identifier, e.g. `find` or `echo`.\n * - `mcpName`: the MCP wire name, e.g. `findDocuments` or `echo`.\n * - `label`: human-readable display text.\n */\nexport type MCPItemBase = {\n  configKey: string\n  label: string\n  mcpName: string\n}\n\nexport type CollectionMCPItem = {\n  collectionSlug: CollectionSlug\n  tool: CollectionTool\n  type: 'collectionTool'\n} & MCPItemBase\n\nexport type GlobalMCPItem = {\n  globalSlug: GlobalSlug\n  tool: GlobalTool\n  type: 'globalTool'\n} & MCPItemBase\n\nexport type MCPItem =\n  | ({\n      prompt: Prompt\n      type: 'prompt'\n    } & MCPItemBase)\n  | ({\n      resource: Resource\n      type: 'resource'\n    } & MCPItemBase)\n  | ({\n      tool: Tool\n      type: 'tool'\n    } & MCPItemBase)\n  | CollectionMCPItem\n  | GlobalMCPItem\n\n/**\n * The MCP items and access mode authorized for this request. The authenticated user is available\n * as `req.user`.\n */\nexport type AuthorizedMCP = {\n  items: MCPItem[]\n  overrideAccess: boolean\n}\n"],"names":[],"mappings":"AAwWA;;;CAGC,GACD,WAGC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@payloadcms/plugin-mcp",
-  "version": "4.0.0-internal.cd69eef",
+  "version": "4.0.0-internal.ce66a41",
   "description": "MCP (Model Context Protocol) capabilities with Payload",
   "keywords": [
     "plugin",
@@ -55,19 +55,17 @@
     "bin.js"
   ],
   "dependencies": {
-    "@modelcontextprotocol/server": "2.0.0-beta.3",
-    "tsx": "4.22.4",
-    "zod": "^4.2.0"
+    "@modelcontextprotocol/server": "2.3.1",
+    "tsx": "4.23.15"
   },
   "devDependencies": {
-    "payload": "4.0.0-internal.cd69eef",
-    "@payloadcms/eslint-config": "3.28.0"
+    "@payloadcms/eslint-config": "3.28.0",
+    "payload": "4.0.0-internal.ce66a41"
   },
   "peerDependencies": {
-    "payload": "4.0.0-internal.cd69eef"
+    "payload": "4.0.0-internal.ce66a41"
   },
   "//deps_notes": {
-    "zod": "zod is a hard dependency of @modelcontextprotocol/server, thus we can safely use it without it impacting bundle size. Make extra sure the zod version here matches exactly what's defined in the dependencies of @modelcontextprotocol/server to avoid duplicate versions being installed.",
     "tsx": "Required by the `bin.js` stdio mcp. Keep the version pinned to whatever `payload` ships to avoid duplicate installs."
   },
   "homepage:": "https://payloadcms.com",
@@ -77,7 +75,7 @@
     "build:swc": "swc ./src -d ./dist --config-file .swcrc --strip-leading-paths",
     "build:types": "tsc --emitDeclarationOnly --outDir dist",
     "clean": "rimraf {dist,*.tsbuildinfo}",
-    "copyfiles": "copyfiles -u 1 \"src/**/*.{html,css,scss,ttf,woff,woff2,eot,svg,jpg,png,json}\" dist/",
+    "copyfiles": "copyfiles -u 1 -e \"**/*.spec.*\" \"src/**/*.{html,css,scss,ttf,woff,woff2,eot,svg,jpg,png,json}\" dist/",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "pack:plugin": "pnpm build && pnpm pack"

package/src/endpoint/access.ts

@@ -95,12 +95,11 @@ const checkItemAccess = async ({
     case 'collectionTool':
       return (
         !item.tool.access ||
-        (await item.tool.access({ collectionSlug: item.collectionSlug, permissions, req }))
+        (await item.tool.access({ slug: item.collectionSlug, permissions, req }))
       )
     case 'globalTool':
       return (
-        !item.tool.access ||
-        (await item.tool.access({ globalSlug: item.globalSlug, permissions, req }))
+        !item.tool.access || (await item.tool.access({ slug: item.globalSlug, permissions, req }))
       )
     case 'prompt':
       return !item.prompt.access || (await item.prompt.access({ permissions, req }))

package/src/endpoint/index.ts

@@ -3,6 +3,7 @@ import type { PayloadHandler, PayloadRequest } from 'payload'
 import {
   createMcpHandler,
   isLegacyRequest,
+  readRequestBody,
   WebStandardStreamableHTTPServerTransport,
 } from '@modelcontextprotocol/server'
 import { APIError } from 'payload'
@@ -33,14 +34,17 @@ export const mcpEndpoint: PayloadHandler = async (req) => {
   }
 
   const authorizedMCP = await getAuthorizedMCP({ overrideAccess, req })
+  const maxRequestBodySize = pluginConfig.mcp?.maxRequestBodySize
   // Payload augments the original web-standard Request in place.
   const mcpRequest = req as PayloadRequest & Request
+  const parsedBody = await parseRequestBody({ maxRequestBodySize, request: mcpRequest })
 
   // Keep the old JSON-only, stateless behavior because the SDK's 2025 fallback uses SSE.
-  if (await isLegacyRequest(mcpRequest)) {
+  if (await isLegacyRequest(mcpRequest, parsedBody, { maxRequestBodySize })) {
     const server = buildMcpServer({ authorizedMCP, pluginConfig, req })
     const transport = new WebStandardStreamableHTTPServerTransport({
       enableJsonResponse: true,
+      maxRequestBodySize,
       sessionIdGenerator: undefined, // stateless mode
     })
     transport.onerror = (err) => {
@@ -49,7 +53,7 @@ export const mcpEndpoint: PayloadHandler = async (req) => {
 
     try {
       await server.connect(transport)
-      return await transport.handleRequest(mcpRequest)
+      return await transport.handleRequest(mcpRequest, { parsedBody })
     } finally {
       await server.close().catch((err) => {
         req.payload.logger.error({ err, msg: 'Error closing MCP server' })
@@ -59,6 +63,7 @@ export const mcpEndpoint: PayloadHandler = async (req) => {
 
   const handler = createMcpHandler(() => buildMcpServer({ authorizedMCP, pluginConfig, req }), {
     legacy: 'reject',
+    maxRequestBodySize,
     // SDK subscriptions always use SSE, so disable them to keep every response JSON-only.
     maxSubscriptions: 0,
     onerror: (err) => {
@@ -68,10 +73,35 @@ export const mcpEndpoint: PayloadHandler = async (req) => {
   })
 
   try {
-    return await handler.fetch(mcpRequest)
+    return await handler.fetch(mcpRequest, { parsedBody })
   } finally {
     await handler.close().catch((err) => {
       req.payload.logger.error({ err, msg: 'Error closing modern MCP handler' })
     })
   }
 }
+
+/**
+ * Parses a POST body once so the era check and the SDK handler can share it. The SDK
+ * skips its size limit for a pre-parsed body, so this reads with the same limit. It reads
+ * a clone and returns `undefined` for any body the SDK should reject (too large, unreadable,
+ * or not JSON), leaving the original request for the SDK to read and answer.
+ */
+const parseRequestBody = async ({
+  maxRequestBodySize,
+  request,
+}: {
+  maxRequestBodySize?: number
+  request: Request
+}): Promise<unknown> => {
+  if (request.method.toUpperCase() !== 'POST') {
+    return undefined
+  }
+
+  try {
+    const body = await readRequestBody(request.clone(), maxRequestBodySize)
+    return body.tooLarge ? undefined : JSON.parse(body.text)
+  } catch {
+    return undefined
+  }
+}

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,
@@ -24,7 +25,7 @@ import { toStandardSchema } from '../utils/toStandardSchema.js'
  *
  * `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
- * synthesized one built via `createLocalReq`.
+ * synthesized one built via `createPayloadRequest`.
  */
 export const buildMcpServer = ({
   authorizedMCP,
@@ -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 },
@@ -68,7 +71,7 @@ export const buildMcpServer = ({
 
   /**
    * 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
    */
@@ -82,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,
@@ -126,8 +128,8 @@ export const buildMcpServer = ({
       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({
       input: toolInput,
@@ -149,10 +151,7 @@ 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,
@@ -246,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 { createPayloadRequest, 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,16 +17,16 @@ 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}`,
         },
       ],
     }
@@ -40,20 +41,41 @@ export const authCollectionTool = defineCollectionTool({
     title: 'Check Auth Status',
   },
   description: 'Checks authentication status for the current user.',
-  input: z.object({
+  input: strictObject({
     headers: z
-      .record(z.string(), z.string())
-      .describe('Optional 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) {
       authHeaders = new Headers(input.headers)
     }
-    const result = await req.payload.auth({ headers: authHeaders })
+    const authReq = await createPayloadRequest({
+      payload: req.payload,
+      req: { headers: authHeaders },
+    })
+    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,
+      }
+    }
     return {
       content: [
         {
@@ -65,8 +87,8 @@ 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 })
   }
 })
 
@@ -79,35 +101,31 @@ export const forgotPasswordCollectionTool = defineCollectionTool({
     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 })
   }
 })
 
@@ -120,45 +138,35 @@ export const loginCollectionTool = defineCollectionTool({
     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 })
   }
 })
 
@@ -171,35 +179,37 @@ export const resetPasswordCollectionTool = defineCollectionTool({
     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,
@@ -208,28 +218,29 @@ export const unlockCollectionTool = defineCollectionTool({
     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 })
   }
 })
 
@@ -242,28 +253,28 @@ export const verifyCollectionTool = defineCollectionTool({
     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 })
   }
 })