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

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} from '@modelcontextprotocol/server'\nimport type {\n  AuthCollectionSlug,\n  CollectionConfig,\n  CollectionSlug,\n  DefaultDocumentIDType,\n  GlobalSlug,\n  MaybePromise,\n  PayloadRequest,\n  TypedUser,\n} from 'payload'\n\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` — the JSON Schema shape the MCP runtime validates against. */\nexport type { JsonSchemaType, StandardSchemaWithJSON }\n\n/**\n * What a tool's `input` (or a prompt's `argsSchema`) can be — either a raw\n * JSON Schema literal, or a Standard Schema instance (Zod, Valibot, …).\n */\nexport type ToolInputSchema = JsonSchemaType | StandardSchemaWithJSON\n\n/**\n * Serializable mirror of `SanitizedMCPPluginConfig` for client components —\n * the full sanitized config carries functions (tool handlers, etc.) that can't\n * cross the server→client boundary. Built by `sanitizeClientPluginConfig` and\n * passed to the `AccessField` component via `clientProps`.\n *\n * @internal\n */\nexport type ClientMCPPluginConfig = {\n  items: Array<{\n    collectionSlug?: string\n    configKey: string\n    description?: string\n    globalSlug?: string\n    /** Admin-UI bucket for collection/global tools: built-in CRUD, auth, or custom. */\n    group?: 'auth' | 'custom' | 'operations'\n    label: string\n    type: 'collectionTool' | 'globalTool' | 'prompt' | 'resource' | 'tool'\n  }>\n}\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\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 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  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  handler: (args: CollectionToolHandlerArgs<TSchema>) => MaybePromise<MCPToolResponse>\n  input?: TSchema\n} & Pick<Tool, 'description' | 'overrideResponse'>\n\nexport type GlobalTool<TSchema extends ToolInputSchema | undefined = ToolInputSchema | undefined> =\n  {\n    handler: (args: GlobalToolHandlerArgs<TSchema>) => MaybePromise<MCPToolResponse>\n    input?: TSchema\n  } & Pick<Tool, '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 MCPBuiltInToolOverride = {\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 | MCPBuiltInToolOverride | undefined\n} & {\n  [K in MCPCollectionBuiltinName]?: false | MCPBuiltInToolOverride\n}\n\nexport type MCPAuthCollectionToolsMap = {\n  [K in MCPCollectionAuthToolName]?: MCPBuiltInToolOverride | 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 | MCPBuiltInToolOverride | undefined\n} & {\n  [K in MCPGlobalBuiltinName]?: false | MCPBuiltInToolOverride\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  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  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 registration. The API key collection is still added (so DB / types stay stable). */\n  disabled?: boolean\n  globals?: {\n    [Slug in GlobalSlug]?: MCPPluginGlobalConfig\n  }\n  mcp?: {\n    serverOptions?: MCPServerOptions\n    verboseLogs?: boolean\n  }\n  overrideApiKeyCollection?: (collection: CollectionConfig) => CollectionConfig\n  /** Replace the default API-key auth with a custom resolver. */\n  overrideAuth?: (args: {\n    getAPIKeyDoc: (overrideApiKey?: string) => Promise<MCPAPIKeysDoc>\n    getAuthorizedMCP: (args: { apiKeyDoc: MCPAPIKeysDoc }) => AuthorizedMCP\n    pluginConfig: SanitizedMCPPluginConfig\n    req: PayloadRequest\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  userCollection?: CollectionSlug\n}\n\nexport type SanitizedMCPPluginConfig = {\n  items: MCPItem[]\n  userCollection: CollectionSlug\n} & Pick<MCPPluginConfig, 'disabled' | 'mcp' | 'overrideApiKeyCollection' | 'overrideAuth'>\n\nexport type MCPServerOptions = {\n  options?: ConstructorParameters<typeof McpServer>[1]\n  serverInfo?: Partial<ConstructorParameters<typeof McpServer>[0]>\n}\n\n/**\n * Nested access tree as stored in the collection.\n * A `false` leaf disables that tool; missing keys defer to\n * defaults (built-in CRUD is on, opt-in tools are off).\n */\nexport type MCPAPIKeysDocAccessTree = {\n  collections?: {\n    [CollectionSlug: CollectionSlug]: {\n      [ToolKey: string]: boolean\n    }\n  }\n  globals?: {\n    [GlobalSlug: GlobalSlug]: {\n      [ToolKey: string]: boolean\n    }\n  }\n  prompts?: {\n    [PromptKey: string]: boolean\n  }\n  resources?: {\n    [ResourceKey: string]: boolean\n  }\n  tools?: {\n    [ToolKey: string]: boolean\n  }\n}\n\n/**\n * Stored on `payload-mcp-api-keys` docs\n */\nexport type MCPAPIKeysDoc = {\n  access: MCPAPIKeysDocAccessTree\n  apiKey?: string\n  apiKeyIndex?: string\n  id: DefaultDocumentIDType\n  lastUsed?: string\n  overrideAccess?: boolean\n  user: null | TypedUser\n}\n\n/**\n * One MCP primitive plus the metadata needed for access checks, admin UI, and\n * registration.\n *\n * - `configKey`: the config/API-key identifier, e.g. `find` or `echo`.\n * - `mcpName`: the MCP wire name, e.g. `findDocuments` or `echo`.\n * - `label`: human-readable admin checkbox 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 caller's identity + the MCP items they can use for this request. Returned\n * by `getAuthorizedMCP`; denied items are simply absent from `items`. Handlers\n * receive this via `args.authorizedMCP` so they can spread\n * `localAPIDefaults(authorizedMCP)` into every local API call.\n */\nexport type AuthorizedMCP = {\n  items: MCPItem[]\n  overrideAccess: boolean\n  user: null | TypedUser\n}\n"],"names":[],"mappings":"AAgVA;;;;;CAKC,GACD,WAIC"}
+{"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  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    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"}

package/dist/utils/camelCase.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"camelCase.d.ts","sourceRoot":"","sources":["../../src/utils/camelCase.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,GAAI,KAAK,MAAM,KAAG,MAIzC,CAAA"}
+{"version":3,"file":"camelCase.d.ts","sourceRoot":"","sources":["../../src/utils/camelCase.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,QAAS,MAAM,KAAG,MAIzC,CAAA"}

package/dist/utils/getPluginConfig.d.ts

@@ -3,7 +3,7 @@ import type { SanitizedMCPPluginConfig } from '../types.js';
 /**
  * Returns the sanitized plugin config — the form produced by
  * `sanitizeMCPConfig` and stashed back on the plugin's `options` during init.
- * Callers downstream of plugin init can rely on `items`, `userCollection`, etc.
+ * Callers downstream of plugin init can rely on `items` and other defaults
  * being fully resolved.
  */
 export declare const getPluginConfig: (args: {

package/dist/utils/getPluginConfig.js

@@ -1,7 +1,7 @@
 /**
  * Returns the sanitized plugin config — the form produced by
  * `sanitizeMCPConfig` and stashed back on the plugin's `options` during init.
- * Callers downstream of plugin init can rely on `items`, `userCollection`, etc.
+ * Callers downstream of plugin init can rely on `items` and other defaults
  * being fully resolved.
  */ export const getPluginConfig = ({ config })=>{
     const plugin = config.plugins?.find((plugin)=>plugin.slug === '@payloadcms/plugin-mcp');

package/dist/utils/getPluginConfig.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/getPluginConfig.ts"],"sourcesContent":["import type { PluginsMap, SanitizedConfig } from 'payload'\n\nimport type { SanitizedMCPPluginConfig } from '../types.js'\n\n/**\n * Returns the sanitized plugin config — the form produced by\n * `sanitizeMCPConfig` and stashed back on the plugin's `options` during init.\n * Callers downstream of plugin init can rely on `items`, `userCollection`, etc.\n * being fully resolved.\n */\nexport const getPluginConfig: (args: { config: SanitizedConfig }) => SanitizedMCPPluginConfig = ({\n  config,\n}) => {\n  const plugin = config.plugins?.find(\n    (plugin) => plugin.slug === '@payloadcms/plugin-mcp',\n  ) as PluginsMap['@payloadcms/plugin-mcp']\n\n  if (!plugin) {\n    throw new Error('MCP Plugin not found in config.plugins.')\n  }\n\n  // @ts-expect-error\n  return plugin.sanitizedOptions\n}\n"],"names":["getPluginConfig","config","plugin","plugins","find","slug","Error","sanitizedOptions"],"mappings":"AAIA;;;;;CAKC,GACD,OAAO,MAAMA,kBAAmF,CAAC,EAC/FC,MAAM,EACP;IACC,MAAMC,SAASD,OAAOE,OAAO,EAAEC,KAC7B,CAACF,SAAWA,OAAOG,IAAI,KAAK;IAG9B,IAAI,CAACH,QAAQ;QACX,MAAM,IAAII,MAAM;IAClB;IAEA,mBAAmB;IACnB,OAAOJ,OAAOK,gBAAgB;AAChC,EAAC"}
+{"version":3,"sources":["../../src/utils/getPluginConfig.ts"],"sourcesContent":["import type { PluginsMap, SanitizedConfig } from 'payload'\n\nimport type { SanitizedMCPPluginConfig } from '../types.js'\n\n/**\n * Returns the sanitized plugin config — the form produced by\n * `sanitizeMCPConfig` and stashed back on the plugin's `options` during init.\n * Callers downstream of plugin init can rely on `items` and other defaults\n * being fully resolved.\n */\nexport const getPluginConfig: (args: { config: SanitizedConfig }) => SanitizedMCPPluginConfig = ({\n  config,\n}) => {\n  const plugin = config.plugins?.find(\n    (plugin) => plugin.slug === '@payloadcms/plugin-mcp',\n  ) as PluginsMap['@payloadcms/plugin-mcp']\n\n  if (!plugin) {\n    throw new Error('MCP Plugin not found in config.plugins.')\n  }\n\n  // @ts-expect-error\n  return plugin.sanitizedOptions\n}\n"],"names":["getPluginConfig","config","plugin","plugins","find","slug","Error","sanitizedOptions"],"mappings":"AAIA;;;;;CAKC,GACD,OAAO,MAAMA,kBAAmF,CAAC,EAC/FC,MAAM,EACP;IACC,MAAMC,SAASD,OAAOE,OAAO,EAAEC,KAC7B,CAACF,SAAWA,OAAOG,IAAI,KAAK;IAG9B,IAAI,CAACH,QAAQ;QACX,MAAM,IAAII,MAAM;IAClB;IAEA,mBAAmB;IACnB,OAAOJ,OAAOK,gBAAgB;AAChC,EAAC"}

package/dist/utils/resolveProjectRoot.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolveProjectRoot.d.ts","sourceRoot":"","sources":["../../src/utils/resolveProjectRoot.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,GAAI,UAAU,MAAM,KAAG,IAAI,GAAG,MAS5D,CAAA"}
+{"version":3,"file":"resolveProjectRoot.d.ts","sourceRoot":"","sources":["../../src/utils/resolveProjectRoot.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,aAAc,MAAM,KAAG,IAAI,GAAG,MAS5D,CAAA"}

package/dist/utils/toStandardSchema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toStandardSchema.d.ts","sourceRoot":"","sources":["../../src/utils/toStandardSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,sBAAsB,EAAE,MAAM,8BAA8B,CAAA;AAE1F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAElD,gIAAgI;AAChI,eAAO,MAAM,gBAAgB,GAAI,QAAQ,eAAe,KAAG,sBAG/B,CAAA"}
+{"version":3,"file":"toStandardSchema.d.ts","sourceRoot":"","sources":["../../src/utils/toStandardSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,sBAAsB,EAAE,MAAM,8BAA8B,CAAA;AAE1F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAElD,gIAAgI;AAChI,eAAO,MAAM,gBAAgB,WAAY,eAAe,KAAG,sBAG/B,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@payloadcms/plugin-mcp",
-  "version": "4.0.0-internal.688c4d0",
+  "version": "4.0.0-internal.77191e5",
   "description": "MCP (Model Context Protocol) capabilities with Payload",
   "keywords": [
     "plugin",
@@ -21,9 +21,6 @@
       "url": "https://payloadcms.com"
     }
   ],
-  "sideEffects": [
-    "*.css"
-  ],
   "type": "module",
   "exports": {
     ".": {
@@ -40,6 +37,11 @@
       "import": "./dist/stdio.js",
       "types": "./dist/stdio.d.ts",
       "default": "./dist/stdio.js"
+    },
+    "./internal": {
+      "import": "./dist/exports/internal.js",
+      "types": "./dist/exports/internal.d.ts",
+      "default": "./dist/exports/internal.js"
     }
   },
   "main": "./dist/index.js",
@@ -53,27 +55,17 @@
     "bin.js"
   ],
   "dependencies": {
-    "@cfworker/json-schema": "^4.1.1",
-    "@modelcontextprotocol/server": "2.0.0-alpha.2",
-    "tsx": "4.22.4",
-    "zod": "^4.0.0",
-    "@payloadcms/translations": "4.0.0-internal.688c4d0"
+    "@modelcontextprotocol/server": "2.0.0",
+    "tsx": "4.22.4"
   },
   "devDependencies": {
-    "@types/react": "19.2.14",
-    "react": "^19.0.1 || ^19.1.2 || ^19.2.1",
-    "payload": "4.0.0-internal.688c4d0",
     "@payloadcms/eslint-config": "3.28.0",
-    "@payloadcms/ui": "4.0.0-internal.688c4d0"
+    "payload": "4.0.0-internal.77191e5"
   },
   "peerDependencies": {
-    "react": "^19.0.1 || ^19.1.2 || ^19.2.1",
-    "@payloadcms/ui": "4.0.0-internal.688c4d0",
-    "payload": "4.0.0-internal.688c4d0"
+    "payload": "4.0.0-internal.77191e5"
   },
   "//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.",
-    "@cfworker/json-schema": "Should be able to remove in next @modelcontextprotocol/server alpha release. Marked as an optional peer of @modelcontextprotocol/server, but its bundle does an eager top-level `import { Validator } from '@cfworker/json-schema'`, so it must be installed even when only zod-registered tools are used. Drop once upstream lazy-loads the validator. See: https://github.com/modelcontextprotocol/typescript-sdk",
     "tsx": "Required by the `bin.js` stdio mcp. Keep the version pinned to whatever `payload` ships to avoid duplicate installs."
   },
   "homepage:": "https://payloadcms.com",
@@ -83,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/defaultAccess.ts

@@ -0,0 +1,3 @@
+import type { MCPAccessArgs } from './types.js'
+
+export const defaultAccess = ({ req }: MCPAccessArgs): boolean => Boolean(req.user)

package/src/endpoint/access.ts

@@ -1,144 +1,111 @@
-import type { DefaultDocumentIDType, PayloadRequest, TypedUser } from 'payload'
+import type { PayloadRequest, SanitizedPermissions } from 'payload'
 
-import crypto from 'crypto'
-import { UnauthorizedError } from 'payload'
+import { getAccessResults, UnauthorizedError } from 'payload'
 
-import type { AuthorizedMCP, MCPAPIKeysDoc } from '../types.js'
+import type { AuthorizedMCP, MCPItem } from '../types.js'
 
-import { getLogger } from '../utils/getLogger.js'
 import { getPluginConfig } from '../utils/getPluginConfig.js'
 
+export type GetAuthorizedMCPArgs = {
+  overrideAccess: boolean
+  req: PayloadRequest
+}
+
 /**
- * Resolves the API key (or dev-mode session) and returns the items the caller
- * may use. Denied items are dropped from the array.
+ * Authenticates an MCP request and removes items the user cannot access.
+ * `overrideAccess` skips Payload and MCP item access checks.
  */
-export const getAuthorizedMCP: (args: { req: PayloadRequest }) => Promise<AuthorizedMCP> = async ({
+export const getAuthorizedMCP: (args: GetAuthorizedMCPArgs) => Promise<AuthorizedMCP> = async ({
+  overrideAccess,
   req,
 }) => {
-  const logger = getLogger({ payload: req.payload })
   const pluginConfig = getPluginConfig({ config: req.payload.config })
 
-  const authHeader = req.headers.get('Authorization')
-  const hasBearerToken = authHeader?.startsWith('Bearer ')
-
-  const buildAuthorized = (apiKeyDoc: MCPAPIKeysDoc): AuthorizedMCP => ({
-    items: pluginConfig.items.filter((item) => {
-      switch (item.type) {
-        case 'collectionTool':
-          return apiKeyDoc.access.collections?.[item.collectionSlug]?.[item.configKey] !== false
-        case 'globalTool':
-          return apiKeyDoc.access.globals?.[item.globalSlug]?.[item.configKey] !== false
-        case 'prompt':
-          return apiKeyDoc.access.prompts?.[item.configKey] !== false
-        case 'resource':
-          return apiKeyDoc.access.resources?.[item.configKey] !== false
-        case 'tool':
-          return apiKeyDoc.access.tools?.[item.configKey] !== false
-      }
-    }),
-    overrideAccess:
-      typeof apiKeyDoc.overrideAccess === 'boolean' ? apiKeyDoc.overrideAccess : false,
-    user: apiKeyDoc.user,
-  })
-
-  if (pluginConfig.overrideAuth) {
-    return await pluginConfig.overrideAuth({
-      getAPIKeyDoc: (overrideApiKey) => getAPIKeyDoc({ logger, overrideApiKey, pluginConfig, req }),
-      getAuthorizedMCP: ({ apiKeyDoc }) => buildAuthorized(apiKeyDoc),
+  if (pluginConfig.overrideGetAuthorizedMCP) {
+    return await pluginConfig.overrideGetAuthorizedMCP({
+      overrideAccess,
       pluginConfig,
       req,
     })
   }
 
-  if (process.env.NODE_ENV === 'development' && !hasBearerToken) {
-    logger.info('Dev mode: skipping API key check, using session user')
-    return buildAuthorized({
-      id: -1,
-      access: {},
-      overrideAccess: true,
-      user: req.user ?? null,
-    })
+  if (req.headers) {
+    const headers = new Headers(req.headers)
+    const hasAuthorization = headers.has('Authorization')
+
+    headers.set('DisableAutologin', 'true')
+    req.user = (await req.payload.auth({ headers, req })).user
+
+    if (hasAuthorization && !req.user) {
+      throw new UnauthorizedError(req.t)
+    }
   }
 
-  return buildAuthorized(await getAPIKeyDoc({ logger, pluginConfig, req }))
+  return {
+    items: await filterMCPItems({
+      items: pluginConfig.items,
+      overrideAccess,
+      req,
+    }),
+    overrideAccess,
+  }
 }
 
-const getAPIKeyDoc = async ({
-  logger,
-  overrideApiKey,
-  pluginConfig,
+export const filterMCPItems = async ({
+  items,
+  overrideAccess,
   req,
 }: {
-  logger: ReturnType<typeof getLogger>
-  overrideApiKey?: string
-  pluginConfig: ReturnType<typeof getPluginConfig>
+  items: MCPItem[]
+  overrideAccess: boolean
   req: PayloadRequest
-}): Promise<MCPAPIKeysDoc> => {
-  const authHeader = req.headers.get('Authorization')
-  const hasBearerToken = authHeader?.startsWith('Bearer ')
-
-  const apiKey =
-    overrideApiKey ?? (hasBearerToken ? authHeader?.replace('Bearer ', '').trim() || null : null)
-
-  if (!apiKey) {
-    throw new UnauthorizedError()
+}): Promise<MCPItem[]> => {
+  // Match Payload core: overrideAccess bypasses access evaluation
+  if (overrideAccess) {
+    return items
   }
 
-  const sha256APIKeyIndex = crypto
-    .createHmac('sha256', req.payload.secret)
-    .update(apiKey)
-    .digest('hex')
-
-  const doc = await req.payload.db.findOne<MCPAPIKeysDoc>({
-    collection: 'payload-mcp-api-keys',
-    req,
-    where: {
-      apiKeyIndex: { equals: sha256APIKeyIndex },
-    },
-  })
-
-  if (!doc || !doc.user) {
-    throw new UnauthorizedError()
-  }
-
-  logger.info('API Key is valid')
+  const authorizedItems: MCPItem[] = []
 
-  const userRef = doc.user
-  const userID =
-    typeof userRef === 'object' && userRef !== null && 'id' in userRef
-      ? userRef.id
-      : (userRef as unknown as DefaultDocumentIDType)
+  const permissions = await getAccessResults({ req })
 
-  const user = (await req.payload.findByID({
-    id: userID,
-    collection: pluginConfig.userCollection,
-    depth: 0,
-    disableErrors: true,
-    req,
-  })) as null | TypedUser
-
-  if (!user) {
-    throw new UnauthorizedError()
+  for (const item of items) {
+    if (!(await checkItemAccess({ item, permissions, req }))) {
+      continue
+    }
+    authorizedItems.push(item)
   }
 
-  try {
-    await req.payload.db.updateOne({
-      id: doc.id,
-      collection: 'payload-mcp-api-keys',
-      data: { lastUsed: new Date().toISOString() },
-      req,
-      returning: false,
-    })
-  } catch (err) {
-    logger.warn({ err, msg: 'Failed to update MCP API key last-used timestamp' })
-  }
+  return authorizedItems
+}
 
-  return {
-    ...doc,
-    user: {
-      ...user,
-      _strategy: 'mcp-api-key' as const,
-      collection: pluginConfig.userCollection,
-    },
+/**
+ * Runs MCP item access callbacks
+ */
+const checkItemAccess = async ({
+  item,
+  permissions,
+  req,
+}: {
+  item: MCPItem
+  permissions?: SanitizedPermissions
+  req: PayloadRequest
+}): Promise<boolean> => {
+  switch (item.type) {
+    case 'collectionTool':
+      return (
+        !item.tool.access ||
+        (await item.tool.access({ slug: item.collectionSlug, permissions, req }))
+      )
+    case 'globalTool':
+      return (
+        !item.tool.access || (await item.tool.access({ slug: item.globalSlug, permissions, req }))
+      )
+    case 'prompt':
+      return !item.prompt.access || (await item.prompt.access({ permissions, req }))
+    case 'resource':
+      return !item.resource.access || (await item.resource.access({ permissions, req }))
+    case 'tool':
+      return !item.tool.access || (await item.tool.access({ permissions, req }))
   }
 }

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.