@payloadcms/plugin-mcp 4.0.0-internal.40de3ec → 4.0.0-internal.4c792ad

package/src/types.ts

@@ -6,18 +6,19 @@ import type {
   ResourceTemplate,
   ServerContext,
   StandardSchemaWithJSON,
+  ToolAnnotations,
 } from '@modelcontextprotocol/server'
 import type {
   AuthCollectionSlug,
-  CollectionConfig,
   CollectionSlug,
-  DefaultDocumentIDType,
   GlobalSlug,
   MaybePromise,
   PayloadRequest,
+  SanitizedPermissions,
   TypedUser,
 } from 'payload'
 
+import type { GetAuthorizedMCPArgs } from './endpoint/access.js'
 import type {
   MCPCollectionAuthToolName,
   MCPCollectionBuiltinName,
@@ -26,8 +27,8 @@ import type {
 
 export type { MCPCollectionAuthToolName, MCPCollectionBuiltinName, MCPGlobalBuiltinName }
 
-/** Re-exported from `@modelcontextprotocol/server` — the JSON Schema shape the MCP runtime validates against. */
-export type { JsonSchemaType, StandardSchemaWithJSON }
+/** Re-exported from `@modelcontextprotocol/server` — common MCP types used in plugin config. */
+export type { JsonSchemaType, StandardSchemaWithJSON, ToolAnnotations }
 
 /**
  * What a tool's `input` (or a prompt's `argsSchema`) can be — either a raw
@@ -35,25 +36,6 @@ export type { JsonSchemaType, StandardSchemaWithJSON }
  */
 export type ToolInputSchema = JsonSchemaType | StandardSchemaWithJSON
 
-/**
- * Serializable mirror of `SanitizedMCPPluginConfig` for client components —
- * the full sanitized config carries functions (tool handlers, etc.) that can't
- * cross the server→client boundary. Built by `sanitizeClientPluginConfig` and
- * passed to the `AccessField` component via `clientProps`.
- *
- * @internal
- */
-export type ClientMCPPluginConfig = {
-  items: Array<{
-    collectionSlug?: string
-    description: string
-    globalSlug?: string
-    key: string
-    label: string
-    type: 'collectionTool' | 'globalTool' | 'prompt' | 'resource' | 'tool'
-  }>
-}
-
 export type MCPToolResponse = {
   content: ContentBlock[]
   /**
@@ -80,6 +62,19 @@ export type TypedInput<TSchema> = TSchema extends StandardSchemaWithJSON
     : StandardSchemaWithJSON.InferOutput<TSchema>
   : Record<string, unknown>
 
+export type MCPAccessArgs = {
+  permissions?: SanitizedPermissions
+  req: PayloadRequest
+}
+
+export type CollectionMCPAccessArgs = {
+  collectionSlug: CollectionSlug
+} & MCPAccessArgs
+
+export type GlobalMCPAccessArgs = {
+  globalSlug: GlobalSlug
+} & MCPAccessArgs
+
 export type ToolHandlerArgs<TSchema = undefined> = {
   authorizedMCP: AuthorizedMCP
   input: TypedInput<TSchema>
@@ -96,6 +91,8 @@ export type GlobalToolHandlerArgs<TSchema = undefined> = {
 } & ToolHandlerArgs<TSchema>
 
 export type Tool<TSchema extends ToolInputSchema | undefined = ToolInputSchema | undefined> = {
+  access?: (args: MCPAccessArgs) => MaybePromise<boolean>
+  annotations?: ToolAnnotations
   description: string
   handler: (args: ToolHandlerArgs<TSchema>) => MaybePromise<MCPToolResponse>
   input?: TSchema
@@ -105,30 +102,37 @@ export type Tool<TSchema extends ToolInputSchema | undefined = ToolInputSchema |
   overrideResponse?: MCPResponseOverride
 }
 
-/**
- * `TSchema` is the schema itself (Standard Schema, raw JSON Schema, or undefined).
- * The function-form variant of `input` carries a concrete `{ collectionSchema: JsonSchemaType }`
- * parameter type so callers can write `({ collectionSchema }) => …` without annotating it.
- */
 export type CollectionTool<
   TSchema extends ToolInputSchema | undefined = ToolInputSchema | undefined,
 > = {
+  access?: (args: CollectionMCPAccessArgs) => MaybePromise<boolean>
   handler: (args: CollectionToolHandlerArgs<TSchema>) => MaybePromise<MCPToolResponse>
-  input?: ((args: { collectionSchema: JsonSchemaType }) => TSchema) | TSchema
-} & Pick<Tool, 'description' | 'overrideResponse'>
+  input?: TSchema
+} & Pick<Tool, 'annotations' | 'description' | 'overrideResponse'>
 
 export type GlobalTool<TSchema extends ToolInputSchema | undefined = ToolInputSchema | undefined> =
   {
+    access?: (args: GlobalMCPAccessArgs) => MaybePromise<boolean>
     handler: (args: GlobalToolHandlerArgs<TSchema>) => MaybePromise<MCPToolResponse>
-    input?: ((args: { globalSchema: JsonSchemaType }) => TSchema) | TSchema
-  } & Pick<Tool, 'description' | 'overrideResponse'>
+    input?: TSchema
+  } & Pick<Tool, 'annotations' | 'description' | 'overrideResponse'>
 
 /**
  * Configures (or disables) a built-in tool without replacing it.
  * `handler?: never` prevents a full `CollectionTool`/`GlobalTool` (which has a
  * required handler) from being silently accepted at a built-in key slot.
  */
-export type MCPBuiltInToolOverride = {
+export type MCPBuiltInCollectionToolOverride = {
+  access?: (args: CollectionMCPAccessArgs) => MaybePromise<boolean>
+  annotations?: ToolAnnotations
+  description?: string
+  handler?: never
+  overrideResponse?: MCPResponseOverride
+}
+
+export type MCPBuiltInGlobalToolOverride = {
+  access?: (args: GlobalMCPAccessArgs) => MaybePromise<boolean>
+  annotations?: ToolAnnotations
   description?: string
   handler?: never
   overrideResponse?: MCPResponseOverride
@@ -142,13 +146,13 @@ export type MCPBuiltInToolOverride = {
 export type MCPTopLevelToolEntry = Tool
 
 export type MCPCollectionToolsMap = {
-  [customToolName: string]: boolean | CollectionTool | MCPBuiltInToolOverride | undefined
+  [customToolName: string]: boolean | CollectionTool | MCPBuiltInCollectionToolOverride | undefined
 } & {
-  [K in MCPCollectionBuiltinName]?: false | MCPBuiltInToolOverride
+  [K in MCPCollectionBuiltinName]?: false | MCPBuiltInCollectionToolOverride
 }
 
 export type MCPAuthCollectionToolsMap = {
-  [K in MCPCollectionAuthToolName]?: MCPBuiltInToolOverride | true
+  [K in MCPCollectionAuthToolName]?: MCPBuiltInCollectionToolOverride | true
 } & MCPCollectionToolsMap
 
 /** Auth-enabled collections get auth-tool name autocomplete; others get CRUD-only. */
@@ -157,9 +161,9 @@ export type MCPToolsMapForCollection<Slug extends CollectionSlug> = Slug extends
   : MCPCollectionToolsMap
 
 export type MCPGlobalToolsMap = {
-  [customToolName: string]: boolean | GlobalTool | MCPBuiltInToolOverride | undefined
+  [customToolName: string]: boolean | GlobalTool | MCPBuiltInGlobalToolOverride | undefined
 } & {
-  [K in MCPGlobalBuiltinName]?: false | MCPBuiltInToolOverride
+  [K in MCPGlobalBuiltinName]?: false | MCPBuiltInGlobalToolOverride
 }
 
 export type MCPTopLevelToolsMap = Record<string, Tool>
@@ -171,6 +175,7 @@ export type PromptHandlerArgs<TSchema = undefined> = {
 }
 
 export type Prompt<TSchema extends ToolInputSchema = ToolInputSchema> = {
+  access?: (args: MCPAccessArgs) => MaybePromise<boolean>
   argsSchema: TSchema
   description: string
   handler: (args: PromptHandlerArgs<TSchema>) => MaybePromise<{
@@ -188,6 +193,7 @@ export type ResourceHandlerArgs = {
 }
 
 export type Resource = {
+  access?: (args: MCPAccessArgs) => MaybePromise<boolean>
   description: string
   handler: (args: ResourceHandlerArgs) => MaybePromise<{
     contents: Array<{ text: string; uri: string }>
@@ -221,7 +227,7 @@ export type MCPPluginConfig = {
   collections?: {
     [Slug in CollectionSlug]?: MCPPluginCollectionConfig<Slug>
   }
-  /** Skip MCP registration. The API key collection is still added (so DB / types stay stable). */
+  /** Skip MCP endpoint registration. */
   disabled?: boolean
   globals?: {
     [Slug in GlobalSlug]?: MCPPluginGlobalConfig
@@ -230,25 +236,21 @@ export type MCPPluginConfig = {
     serverOptions?: MCPServerOptions
     verboseLogs?: boolean
   }
-  overrideApiKeyCollection?: (collection: CollectionConfig) => CollectionConfig
-  /** Replace the default API-key auth with a custom resolver. */
-  overrideAuth?: (args: {
-    getAPIKeyDoc: (overrideApiKey?: string) => Promise<MCPAPIKeysDoc>
-    getAuthorizedMCP: (args: { apiKeyDoc: MCPAPIKeysDoc }) => AuthorizedMCP
-    pluginConfig: SanitizedMCPPluginConfig
-    req: PayloadRequest
-  }) => MaybePromise<AuthorizedMCP>
+  /** Replace the default MCP authorization resolver. */
+  overrideGetAuthorizedMCP?: (
+    args: {
+      pluginConfig: SanitizedMCPPluginConfig
+    } & GetAuthorizedMCPArgs,
+  ) => MaybePromise<AuthorizedMCP>
   prompts?: Record<string, Prompt>
   resources?: Record<string, Resource>
   /** Cross-cutting tools (not scoped to any collection or global). */
   tools?: MCPTopLevelToolsMap
-  userCollection?: CollectionSlug
 }
 
 export type SanitizedMCPPluginConfig = {
   items: MCPItem[]
-  userCollection: CollectionSlug
-} & Pick<MCPPluginConfig, 'disabled' | 'mcp' | 'overrideApiKeyCollection' | 'overrideAuth'>
+} & Pick<MCPPluginConfig, 'disabled' | 'mcp' | 'overrideGetAuthorizedMCP'>
 
 export type MCPServerOptions = {
   options?: ConstructorParameters<typeof McpServer>[1]
@@ -256,71 +258,32 @@ export type MCPServerOptions = {
 }
 
 /**
- * Nested access tree as stored in the collection.
- * A `false` leaf disables that tool; missing keys defer to
- * defaults (built-in CRUD is on, opt-in tools are off).
- */
-export type MCPAPIKeysDocAccessTree = {
-  collections?: {
-    [CollectionSlug: CollectionSlug]: {
-      [ToolKey: string]: boolean
-    }
-  }
-  globals?: {
-    [GlobalSlug: GlobalSlug]: {
-      [ToolKey: string]: boolean
-    }
-  }
-  prompts?: {
-    [PromptKey: string]: boolean
-  }
-  resources?: {
-    [ResourceKey: string]: boolean
-  }
-  tools?: {
-    [ToolKey: string]: boolean
-  }
-}
-
-/**
- * Stored on `payload-mcp-api-keys` docs
- */
-export type MCPAPIKeysDoc = {
-  access: MCPAPIKeysDocAccessTree
-  id: DefaultDocumentIDType
-  overrideAccess?: boolean
-  user: null | TypedUser
-}
-
-/**
- * One MCP primitive — tool, prompt, or resource — paired with the metadata both
- * the endpoint and the API key collection need. Built by `sanitizeMCPConfig`,
- * filtered by `getAuthorizedMCP`, registered by the MCP endpoint.
+ * One MCP primitive plus the metadata needed for config-driven filtering and
+ * registration.
  *
- *  - `key`: the config identifier (`find`, `echo`). Used for the API-key deny
- *    lookup and as the admin checkbox field name. For collection/global tools,
- *    the MCP wire name (`findPosts`) is derived from `key + slug` at
- *    registration time.
- *  - `label`: human-readable admin-UI display text for the checkbox.
- *  - `tool` / `prompt` / `resource`: the live primitive (its own
- *    `description` is what both MCP clients and the admin UI surface).
+ * - `configKey`: the config identifier, e.g. `find` or `echo`.
+ * - `mcpName`: the MCP wire name, e.g. `findDocuments` or `echo`.
+ * - `label`: human-readable display text.
  */
 export type MCPItemBase = {
-  key: string
+  configKey: string
   label: string
+  mcpName: string
 }
 
+export type CollectionMCPItem = {
+  collectionSlug: CollectionSlug
+  tool: CollectionTool
+  type: 'collectionTool'
+} & MCPItemBase
+
+export type GlobalMCPItem = {
+  globalSlug: GlobalSlug
+  tool: GlobalTool
+  type: 'globalTool'
+} & MCPItemBase
+
 export type MCPItem =
-  | ({
-      collectionSlug: CollectionSlug
-      tool: CollectionTool
-      type: 'collectionTool'
-    } & MCPItemBase)
-  | ({
-      globalSlug: GlobalSlug
-      tool: GlobalTool
-      type: 'globalTool'
-    } & MCPItemBase)
   | ({
       prompt: Prompt
       type: 'prompt'
@@ -333,12 +296,14 @@ export type MCPItem =
       tool: Tool
       type: 'tool'
     } & MCPItemBase)
+  | CollectionMCPItem
+  | GlobalMCPItem
 
 /**
- * The caller's identity + the MCP items they can use for this request. Returned
- * by `getAuthorizedMCP`; denied items are simply absent from `items`. Handlers
- * receive this via `args.authorizedMCP` so they can spread
- * `localAPIDefaults(authorizedMCP)` into every local API call.
+ * The caller's identity + the MCP items authorized for this request. Disabled
+ * items and items blocked by access callbacks or Payload operation access are
+ * absent from `items`. Tool handlers receive this via `args.authorizedMCP` so
+ * they can spread `localAPIDefaults(authorizedMCP)` into every local API call.
  */
 export type AuthorizedMCP = {
   items: MCPItem[]

package/src/utils/getPluginConfig.ts

@@ -5,7 +5,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 const getPluginConfig: (args: { config: SanitizedConfig }) => SanitizedMCPPluginConfig = ({

package/src/utils/schemaConversion/getEntityInputSchema.ts

@@ -0,0 +1,78 @@
+import {
+  type CollectionSlug,
+  entityToStandaloneJSONSchema,
+  type GlobalSlug,
+  type PayloadRequest,
+  type SanitizedCollectionConfig,
+  type SanitizedGlobalConfig,
+} from 'payload'
+
+import type { JsonSchemaType } from '../../types.js'
+
+import {
+  getCollectionVirtualFieldNames,
+  getGlobalVirtualFieldNames,
+} from '../getVirtualFieldNames.js'
+import { removeVirtualFieldsFromSchema } from './removeVirtualFieldsFromSchema.js'
+import { sanitizeEntitySchema } from './sanitizeEntitySchema.js'
+
+export const getCollectionInputSchema = ({
+  collectionSlug,
+  req,
+}: {
+  collectionSlug: CollectionSlug
+  req: PayloadRequest
+}): JsonSchemaType | null => {
+  const collection = req.payload.collections[collectionSlug]?.config
+
+  if (!collection) {
+    return null
+  }
+
+  return buildEntityInputSchema({
+    entity: collection,
+    req,
+    virtualFieldNames: getCollectionVirtualFieldNames(req.payload.config, collectionSlug),
+  })
+}
+
+export const getGlobalInputSchema = ({
+  globalSlug,
+  req,
+}: {
+  globalSlug: GlobalSlug
+  req: PayloadRequest
+}): JsonSchemaType | null => {
+  const global = req.payload.config.globals.find((globalConfig) => globalConfig.slug === globalSlug)
+
+  if (!global) {
+    return null
+  }
+
+  return buildEntityInputSchema({
+    entity: global,
+    req,
+    virtualFieldNames: getGlobalVirtualFieldNames(req.payload.config, globalSlug),
+  })
+}
+
+const buildEntityInputSchema = ({
+  entity,
+  req,
+  virtualFieldNames,
+}: {
+  entity: SanitizedCollectionConfig | SanitizedGlobalConfig
+  req: PayloadRequest
+  virtualFieldNames: string[]
+}): JsonSchemaType =>
+  sanitizeEntitySchema(
+    removeVirtualFieldsFromSchema(
+      entityToStandaloneJSONSchema({
+        config: req.payload.config,
+        defaultIDType: req.payload.db.defaultIDType,
+        entity,
+        i18n: req.i18n,
+      }) as unknown as JsonSchemaType,
+      virtualFieldNames,
+    ),
+  )

package/src/utils/whereSchema.ts

@@ -0,0 +1,24 @@
+import type { Where } from 'payload'
+
+import { validOperators } from 'payload/shared'
+import { z } from 'zod'
+
+const whereFieldSchema = z
+  .partialRecord(z.enum(validOperators), z.unknown())
+  .describe('Field query operators')
+
+/**
+ * - Validates the `where` input of collection tools against Payload's `Where` shape
+ * - Field keys map to operator objects restricted to `validOperators`
+ * - `and` / `or` nest recursively
+ */
+export const whereSchema: z.ZodType<Where> = z
+  .lazy(() =>
+    z
+      .object({
+        and: z.array(whereSchema).optional(),
+        or: z.array(whereSchema).optional(),
+      })
+      .catchall(whereFieldSchema),
+  )
+  .describe('Where clause using field names with Payload query operators, plus and/or groups')

package/dist/collection/getAccessField.d.ts

@@ -1,12 +0,0 @@
-import type { JSONField } from 'payload';
-import type { SanitizedMCPPluginConfig } from '../types.js';
-/**
- * Returns the API key collection's `access` field — a JSON field whose value
- * is the `MCPAPIKeysDocAccessTree` the endpoint consults. The actual UI is
- * a custom client component (`AccessField`) which renders a permissions
- * matrix; the field's stored shape is just the runtime access tree.
- */
-export declare const getAccessField: ({ pluginConfig, }: {
-    pluginConfig: SanitizedMCPPluginConfig;
-}) => JSONField;
-//# sourceMappingURL=getAccessField.d.ts.map

package/dist/collection/getAccessField.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getAccessField.d.ts","sourceRoot":"","sources":["../../src/collection/getAccessField.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAExC,OAAO,KAAK,EAAkC,wBAAwB,EAAE,MAAM,aAAa,CAAA;AAE3F;;;;;GAKG;AACH,eAAO,MAAM,cAAc,GAAI,mBAE5B;IACD,YAAY,EAAE,wBAAwB,CAAA;CACvC,KAAG,SAqBH,CAAA"}

package/dist/collection/getAccessField.js

@@ -1,57 +0,0 @@
-/**
- * Returns the API key collection's `access` field — a JSON field whose value
- * is the `MCPAPIKeysDocAccessTree` the endpoint consults. The actual UI is
- * a custom client component (`AccessField`) which renders a permissions
- * matrix; the field's stored shape is just the runtime access tree.
- */ export const getAccessField = ({ pluginConfig })=>{
-    const clientPluginConfig = sanitizeClientPluginConfig(pluginConfig);
-    return {
-        name: 'access',
-        type: 'json',
-        admin: {
-            components: {
-                Field: {
-                    clientProps: {
-                        pluginConfig: clientPluginConfig
-                    },
-                    path: '@payloadcms/plugin-mcp/client#AccessField'
-                }
-            },
-            // TODO: needs i18n once design is finalized
-            description: 'Access for this API key — uncheck to revoke individual tools.',
-            position: 'sidebar'
-        },
-        defaultValue: {},
-        // TODO: needs i18n once design is finalized
-        label: 'Access'
-    };
-};
-/**
- * Strips the non-serializable parts of `SanitizedMCPPluginConfig` (handlers,
- * input/argsSchema functions, etc.) so the result is safe to thread to a
- * client component via `clientProps`.
- */ const sanitizeClientPluginConfig = (pluginConfig)=>({
-        items: pluginConfig.items.map((item)=>({
-                ...item.type === 'collectionTool' ? {
-                    collectionSlug: item.collectionSlug
-                } : {},
-                ...item.type === 'globalTool' ? {
-                    globalSlug: item.globalSlug
-                } : {},
-                type: item.type,
-                description: itemDescription(item),
-                key: item.key,
-                label: item.label
-            }))
-    });
-const itemDescription = (item)=>{
-    if (item.type === 'prompt') {
-        return item.prompt.description;
-    }
-    if (item.type === 'resource') {
-        return item.resource.description;
-    }
-    return item.tool.description;
-};
-
-//# sourceMappingURL=getAccessField.js.map

package/dist/collection/getAccessField.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/collection/getAccessField.ts"],"sourcesContent":["import type { JSONField } from 'payload'\n\nimport type { ClientMCPPluginConfig, MCPItem, SanitizedMCPPluginConfig } from '../types.js'\n\n/**\n * Returns the API key collection's `access` field — a JSON field whose value\n * is the `MCPAPIKeysDocAccessTree` the endpoint consults. The actual UI is\n * a custom client component (`AccessField`) which renders a permissions\n * matrix; the field's stored shape is just the runtime access tree.\n */\nexport const getAccessField = ({\n  pluginConfig,\n}: {\n  pluginConfig: SanitizedMCPPluginConfig\n}): JSONField => {\n  const clientPluginConfig = sanitizeClientPluginConfig(pluginConfig)\n\n  return {\n    name: 'access',\n    type: 'json',\n    admin: {\n      components: {\n        Field: {\n          clientProps: { pluginConfig: clientPluginConfig },\n          path: '@payloadcms/plugin-mcp/client#AccessField',\n        },\n      },\n      // TODO: needs i18n once design is finalized\n      description: 'Access for this API key — uncheck to revoke individual tools.',\n      position: 'sidebar',\n    },\n    defaultValue: {},\n    // TODO: needs i18n once design is finalized\n    label: 'Access',\n  }\n}\n\n/**\n * Strips the non-serializable parts of `SanitizedMCPPluginConfig` (handlers,\n * input/argsSchema functions, etc.) so the result is safe to thread to a\n * client component via `clientProps`.\n */\nconst sanitizeClientPluginConfig = (\n  pluginConfig: SanitizedMCPPluginConfig,\n): ClientMCPPluginConfig => ({\n  items: pluginConfig.items.map((item) => ({\n    ...(item.type === 'collectionTool' ? { collectionSlug: item.collectionSlug } : {}),\n    ...(item.type === 'globalTool' ? { globalSlug: item.globalSlug } : {}),\n    type: item.type,\n    description: itemDescription(item),\n    key: item.key,\n    label: item.label,\n  })),\n})\n\nconst itemDescription = (item: MCPItem): string => {\n  if (item.type === 'prompt') {\n    return item.prompt.description\n  }\n  if (item.type === 'resource') {\n    return item.resource.description\n  }\n  return item.tool.description\n}\n"],"names":["getAccessField","pluginConfig","clientPluginConfig","sanitizeClientPluginConfig","name","type","admin","components","Field","clientProps","path","description","position","defaultValue","label","items","map","item","collectionSlug","globalSlug","itemDescription","key","prompt","resource","tool"],"mappings":"AAIA;;;;;CAKC,GACD,OAAO,MAAMA,iBAAiB,CAAC,EAC7BC,YAAY,EAGb;IACC,MAAMC,qBAAqBC,2BAA2BF;IAEtD,OAAO;QACLG,MAAM;QACNC,MAAM;QACNC,OAAO;YACLC,YAAY;gBACVC,OAAO;oBACLC,aAAa;wBAAER,cAAcC;oBAAmB;oBAChDQ,MAAM;gBACR;YACF;YACA,4CAA4C;YAC5CC,aAAa;YACbC,UAAU;QACZ;QACAC,cAAc,CAAC;QACf,4CAA4C;QAC5CC,OAAO;IACT;AACF,EAAC;AAED;;;;CAIC,GACD,MAAMX,6BAA6B,CACjCF,eAC2B,CAAA;QAC3Bc,OAAOd,aAAac,KAAK,CAACC,GAAG,CAAC,CAACC,OAAU,CAAA;gBACvC,GAAIA,KAAKZ,IAAI,KAAK,mBAAmB;oBAAEa,gBAAgBD,KAAKC,cAAc;gBAAC,IAAI,CAAC,CAAC;gBACjF,GAAID,KAAKZ,IAAI,KAAK,eAAe;oBAAEc,YAAYF,KAAKE,UAAU;gBAAC,IAAI,CAAC,CAAC;gBACrEd,MAAMY,KAAKZ,IAAI;gBACfM,aAAaS,gBAAgBH;gBAC7BI,KAAKJ,KAAKI,GAAG;gBACbP,OAAOG,KAAKH,KAAK;YACnB,CAAA;IACF,CAAA;AAEA,MAAMM,kBAAkB,CAACH;IACvB,IAAIA,KAAKZ,IAAI,KAAK,UAAU;QAC1B,OAAOY,KAAKK,MAAM,CAACX,WAAW;IAChC;IACA,IAAIM,KAAKZ,IAAI,KAAK,YAAY;QAC5B,OAAOY,KAAKM,QAAQ,CAACZ,WAAW;IAClC;IACA,OAAOM,KAAKO,IAAI,CAACb,WAAW;AAC9B"}

package/dist/collection/index.d.ts

@@ -1,6 +0,0 @@
-import type { CollectionConfig } from 'payload';
-import type { SanitizedMCPPluginConfig } from '../types.js';
-export declare const getAPIKeysCollection: ({ pluginConfig, }: {
-    pluginConfig: SanitizedMCPPluginConfig;
-}) => CollectionConfig;
-//# sourceMappingURL=index.d.ts.map

package/dist/collection/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/collection/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAE/C,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAA;AAI3D,eAAO,MAAM,oBAAoB,GAAI,mBAElC;IACD,YAAY,EAAE,wBAAwB,CAAA;CACvC,KAAG,gBAqDH,CAAA"}

package/dist/collection/index.js

@@ -1,60 +0,0 @@
-import { getAccessField } from './getAccessField.js';
-export const getAPIKeysCollection = ({ pluginConfig })=>{
-    const collection = {
-        slug: 'payload-mcp-api-keys',
-        admin: {
-            description: 'API keys control which collections, resources, tools, and prompts MCP clients can access',
-            group: 'MCP',
-            useAsTitle: 'label'
-        },
-        auth: {
-            disableLocalStrategy: true,
-            useAPIKey: true
-        },
-        fields: [
-            {
-                name: 'user',
-                type: 'relationship',
-                admin: {
-                    description: 'The user that the API key is associated with.'
-                },
-                relationTo: pluginConfig.userCollection,
-                required: true
-            },
-            {
-                name: 'label',
-                type: 'text',
-                admin: {
-                    description: 'A useful label for the API key.'
-                }
-            },
-            {
-                name: 'description',
-                type: 'text',
-                admin: {
-                    description: 'The purpose of the API key.'
-                }
-            },
-            {
-                name: 'overrideAccess',
-                type: 'checkbox',
-                admin: {
-                    description: 'When checked, this key bypasses Payload access control on every operation it performs. Leave unchecked unless you have a specific reason.'
-                },
-                defaultValue: false,
-                label: 'Override access control'
-            },
-            getAccessField({
-                pluginConfig
-            })
-        ],
-        labels: {
-            plural: 'API Keys',
-            singular: 'API Key'
-        },
-        versions: false
-    };
-    return pluginConfig.overrideApiKeyCollection ? pluginConfig.overrideApiKeyCollection(collection) : collection;
-};
-
-//# sourceMappingURL=index.js.map

package/dist/collection/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/collection/index.ts"],"sourcesContent":["import type { CollectionConfig } from 'payload'\n\nimport type { SanitizedMCPPluginConfig } from '../types.js'\n\nimport { getAccessField } from './getAccessField.js'\n\nexport const getAPIKeysCollection = ({\n  pluginConfig,\n}: {\n  pluginConfig: SanitizedMCPPluginConfig\n}): CollectionConfig => {\n  const collection: CollectionConfig = {\n    slug: 'payload-mcp-api-keys',\n    admin: {\n      description:\n        'API keys control which collections, resources, tools, and prompts MCP clients can access',\n      group: 'MCP',\n      useAsTitle: 'label',\n    },\n    auth: {\n      disableLocalStrategy: true,\n      useAPIKey: true,\n    },\n    fields: [\n      {\n        name: 'user',\n        type: 'relationship',\n        admin: { description: 'The user that the API key is associated with.' },\n        relationTo: pluginConfig.userCollection,\n        required: true,\n      },\n      {\n        name: 'label',\n        type: 'text',\n        admin: { description: 'A useful label for the API key.' },\n      },\n      {\n        name: 'description',\n        type: 'text',\n        admin: { description: 'The purpose of the API key.' },\n      },\n      {\n        name: 'overrideAccess',\n        type: 'checkbox',\n        admin: {\n          description:\n            'When checked, this key bypasses Payload access control on every operation it performs. Leave unchecked unless you have a specific reason.',\n        },\n        defaultValue: false,\n        label: 'Override access control',\n      },\n      getAccessField({ pluginConfig }),\n    ],\n    labels: {\n      plural: 'API Keys',\n      singular: 'API Key',\n    },\n    versions: false,\n  }\n\n  return pluginConfig.overrideApiKeyCollection\n    ? pluginConfig.overrideApiKeyCollection(collection)\n    : collection\n}\n"],"names":["getAccessField","getAPIKeysCollection","pluginConfig","collection","slug","admin","description","group","useAsTitle","auth","disableLocalStrategy","useAPIKey","fields","name","type","relationTo","userCollection","required","defaultValue","label","labels","plural","singular","versions","overrideApiKeyCollection"],"mappings":"AAIA,SAASA,cAAc,QAAQ,sBAAqB;AAEpD,OAAO,MAAMC,uBAAuB,CAAC,EACnCC,YAAY,EAGb;IACC,MAAMC,aAA+B;QACnCC,MAAM;QACNC,OAAO;YACLC,aACE;YACFC,OAAO;YACPC,YAAY;QACd;QACAC,MAAM;YACJC,sBAAsB;YACtBC,WAAW;QACb;QACAC,QAAQ;YACN;gBACEC,MAAM;gBACNC,MAAM;gBACNT,OAAO;oBAAEC,aAAa;gBAAgD;gBACtES,YAAYb,aAAac,cAAc;gBACvCC,UAAU;YACZ;YACA;gBACEJ,MAAM;gBACNC,MAAM;gBACNT,OAAO;oBAAEC,aAAa;gBAAkC;YAC1D;YACA;gBACEO,MAAM;gBACNC,MAAM;gBACNT,OAAO;oBAAEC,aAAa;gBAA8B;YACtD;YACA;gBACEO,MAAM;gBACNC,MAAM;gBACNT,OAAO;oBACLC,aACE;gBACJ;gBACAY,cAAc;gBACdC,OAAO;YACT;YACAnB,eAAe;gBAAEE;YAAa;SAC/B;QACDkB,QAAQ;YACNC,QAAQ;YACRC,UAAU;QACZ;QACAC,UAAU;IACZ;IAEA,OAAOrB,aAAasB,wBAAwB,GACxCtB,aAAasB,wBAAwB,CAACrB,cACtCA;AACN,EAAC"}

package/dist/components/AccessField/index.client.d.ts

@@ -1,10 +0,0 @@
-import type { JSONFieldClientProps } from 'payload';
-import React from 'react';
-import type { ClientMCPPluginConfig } from '../../types.js';
-import './index.css';
-type Props = {
-    pluginConfig: ClientMCPPluginConfig;
-} & JSONFieldClientProps;
-export declare const AccessField: React.FC<Props>;
-export {};
-//# sourceMappingURL=index.client.d.ts.map

package/dist/components/AccessField/index.client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.client.d.ts","sourceRoot":"","sources":["../../../src/components/AccessField/index.client.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA;AAGnD,OAAO,KAAK,MAAM,OAAO,CAAA;AAEzB,OAAO,KAAK,EAAE,qBAAqB,EAA2B,MAAM,gBAAgB,CAAA;AAEpF,OAAO,aAAa,CAAA;AAQpB,KAAK,KAAK,GAAG;IACX,YAAY,EAAE,qBAAqB,CAAA;CACpC,GAAG,oBAAoB,CAAA;AAoBxB,eAAO,MAAM,WAAW,EAAE,KAAK,CAAC,EAAE,CAAC,KAAK,CA0QvC,CAAA"}