@payloadcms/plugin-mcp 4.0.0-internal.40de3ec → 4.0.0-internal.41055b1

package/src/utils/schemaConversion/filterFieldsByAccess.ts

@@ -0,0 +1,123 @@
+import type {
+  FlattenedBlock,
+  FlattenedField,
+  Operation,
+  SanitizedDocumentPermissions,
+  SanitizedFieldsPermissions,
+} from 'payload'
+
+type FieldOperation = Exclude<Operation, 'delete'>
+type AllowedFieldOperations = Record<FieldOperation, boolean>
+
+/**
+ * Filters fields using the access results in `permissions`. `shouldExcludeField` receives the
+ * operations allowed by the entity, field, and its parents and decides whether to remove the
+ * field.
+ *
+ * Arrays, groups, named tabs, and blocks are filtered recursively. Rows and unnamed tabs are
+ * flattened by Payload, so their children are filtered at the containing level.
+ *
+ * @example Include fields writable through any collection operation the user can perform.
+ * ```ts
+ * filterFieldsByAccess({
+ *   fields,
+ *   permissions: collectionPermissions,
+ *   shouldExcludeField: ({ create, update }) => !create && !update,
+ * })
+ * ```
+ */
+export const filterFieldsByAccess = ({
+  blocks,
+  fields,
+  permissions,
+  shouldExcludeField,
+}: {
+  blocks?: FlattenedBlock[]
+  fields: FlattenedField[]
+  permissions: SanitizedDocumentPermissions
+  shouldExcludeField: (allowedOperations: AllowedFieldOperations) => boolean
+}): FlattenedField[] => {
+  const filterFields = (
+    nestedFields: FlattenedField[],
+    nestedPermissions: SanitizedFieldsPermissions | undefined,
+    parentAllowedOperations: AllowedFieldOperations,
+  ): FlattenedField[] => {
+    const accessibleFields: FlattenedField[] = []
+
+    for (const field of nestedFields) {
+      const fieldPermissions = nestedPermissions === true ? true : nestedPermissions?.[field.name]
+      const isOperationAllowed = (operation: FieldOperation): boolean =>
+        parentAllowedOperations[operation] &&
+        (fieldPermissions === true || fieldPermissions?.[operation] === true)
+      const allowedOperations: AllowedFieldOperations = {
+        create: isOperationAllowed('create'),
+        read: isOperationAllowed('read'),
+        update: isOperationAllowed('update'),
+      }
+
+      if (shouldExcludeField(allowedOperations)) {
+        continue
+      }
+
+      if (field.type === 'blocks') {
+        const accessibleBlocks: (FlattenedBlock | string)[] = []
+
+        for (const blockOrReference of field.blocks) {
+          const block =
+            typeof blockOrReference === 'string'
+              ? blocks?.find(({ slug }) => slug === blockOrReference)
+              : blockOrReference
+
+          if (!block) {
+            continue
+          }
+
+          const blockPermissions =
+            fieldPermissions === true
+              ? true
+              : fieldPermissions?.blocks === true
+                ? true
+                : fieldPermissions?.blocks?.[block.slug]
+
+          accessibleBlocks.push({
+            ...block,
+            flattenedFields: filterFields(
+              block.flattenedFields,
+              blockPermissions === true ? true : blockPermissions?.fields,
+              allowedOperations,
+            ),
+          })
+        }
+
+        if (accessibleBlocks.length === 0) {
+          continue
+        }
+
+        accessibleFields.push({ ...field, blocks: accessibleBlocks })
+        continue
+      }
+
+      if (field.type === 'array' || field.type === 'group' || field.type === 'tab') {
+        accessibleFields.push({
+          ...field,
+          flattenedFields: filterFields(
+            field.flattenedFields,
+            fieldPermissions === true ? true : fieldPermissions?.fields,
+            allowedOperations,
+          ),
+        })
+        continue
+      }
+
+      accessibleFields.push(field)
+    }
+
+    return accessibleFields
+  }
+
+  return filterFields(fields, permissions.fields, {
+    create: 'create' in permissions && permissions.create === true,
+    read: permissions.read === true,
+    update: permissions.update === true,
+  })
+}

package/src/utils/schemaConversion/getEntityInputSchema.ts

@@ -0,0 +1,96 @@
+import {
+  type CollectionSlug,
+  entityToStandaloneJSONSchema,
+  type FlattenedField,
+  type GlobalSlug,
+  type PayloadRequest,
+  type SanitizedCollectionConfig,
+  type SanitizedCollectionPermission,
+  type SanitizedGlobalConfig,
+  type SanitizedGlobalPermission,
+} from 'payload'
+
+import type { JsonSchemaType } from '../../types.js'
+
+import { filterFieldsByAccess } from './filterFieldsByAccess.js'
+import { sanitizeEntitySchema } from './sanitizeEntitySchema.js'
+
+export const getCollectionInputSchema = ({
+  collectionSlug,
+  permissions,
+  req,
+}: {
+  collectionSlug: CollectionSlug
+  permissions?: SanitizedCollectionPermission
+  req: PayloadRequest
+}): JsonSchemaType | null => {
+  const collection = req.payload.collections[collectionSlug]?.config
+
+  if (!collection) {
+    return null
+  }
+
+  if (!permissions) {
+    return buildEntityInputSchema({ entity: collection, req })
+  }
+
+  const fieldsAllowedByAccess = filterFieldsByAccess({
+    blocks: req.payload.config.blocks,
+    fields: collection.flattenedFields,
+    permissions,
+    shouldExcludeField: ({ create, update }) => !create && !update,
+  })
+
+  return buildEntityInputSchema({ entity: collection, fields: fieldsAllowedByAccess, req })
+}
+
+export const getGlobalInputSchema = ({
+  globalSlug,
+  permissions,
+  req,
+}: {
+  globalSlug: GlobalSlug
+  permissions?: SanitizedGlobalPermission
+  req: PayloadRequest
+}): JsonSchemaType | null => {
+  const global = req.payload.config.globals.find((globalConfig) => globalConfig.slug === globalSlug)
+
+  if (!global) {
+    return null
+  }
+
+  if (!permissions) {
+    return buildEntityInputSchema({ entity: global, req })
+  }
+
+  const fieldsAllowedByAccess = filterFieldsByAccess({
+    blocks: req.payload.config.blocks,
+    fields: global.flattenedFields,
+    permissions,
+    shouldExcludeField: ({ create, update }) => !create && !update,
+  })
+
+  return buildEntityInputSchema({ entity: global, fields: fieldsAllowedByAccess, req })
+}
+
+const buildEntityInputSchema = ({
+  entity,
+  fields = entity.flattenedFields,
+  req,
+}: {
+  entity: SanitizedCollectionConfig | SanitizedGlobalConfig
+  fields?: FlattenedField[]
+  req: PayloadRequest
+}): JsonSchemaType => {
+  // The core schema generator reads flattenedFields from the entity and has no fields argument.
+  const entityForSchema = { ...entity, flattenedFields: fields }
+  const schema = entityToStandaloneJSONSchema({
+    config: req.payload.config,
+    defaultIDType: req.payload.db.defaultIDType,
+    entity: entityForSchema,
+    i18n: req.i18n,
+    variant: 'input',
+  }) as unknown as JsonSchemaType
+
+  return sanitizeEntitySchema(schema)
+}

package/src/utils/schemaConversion/sanitizeEntitySchema.spec.ts

@@ -5,10 +5,11 @@ import type { JsonSchemaType } from '../../types.js'
 import { sanitizeEntitySchema } from './sanitizeEntitySchema.js'
 
 describe('sanitizeEntitySchema', () => {
-  it('keeps a Lexical node union strict (oneOf) while simplifying relationship values to IDs', () => {
-    // Shaped like the schema the MCP server prepares for a collection with a Lexical richText field:
-    // a `$defs` node union (a `oneOf` of node shapes) where a relationship node's `value` is either
-    // an ID or a `$ref` to the populated related collection.
+  it('renames the Lexical node-union definition to a short name and keeps it a strict oneOf', () => {
+    // Shaped like the schema the MCP server prepares for a collection with a Lexical richText field
+    // (Payload's `input` variant): a `$defs` node union (a `oneOf` of node shapes). The input variant
+    // already types the relationship node's `value` as a bare ID - there is no populated-doc `$ref` to
+    // reduce here (the variant did that upstream), so sanitize leaves the value untouched.
     const standalone: JsonSchemaType = {
       type: 'object',
       $defs: {
@@ -25,17 +26,12 @@ describe('sanitizeEntitySchema', () => {
               additionalProperties: false,
               properties: {
                 type: { const: 'relationship' },
-                value: { oneOf: [{ type: 'string' }, { $ref: '#/$defs/posts' }] },
+                value: { type: 'string', description: 'The related document ID.' },
               },
               required: ['type'],
             },
           ],
         },
-        posts: {
-          type: 'object',
-          additionalProperties: false,
-          properties: { id: { type: 'string' }, title: { type: 'string' } },
-        },
       },
       properties: {
         id: { type: 'string' },
@@ -57,7 +53,7 @@ describe('sanitizeEntitySchema', () => {
       type: 'object',
       $defs: {
         // The node union is renamed to a short, readable `node`, and stays a strict discriminated
-        // `oneOf` - not loosened to `anyOf`...
+        // `oneOf` - not loosened to `anyOf`.
         node: {
           oneOf: [
             {
@@ -71,21 +67,18 @@ describe('sanitizeEntitySchema', () => {
               additionalProperties: false,
               properties: {
                 type: { const: 'relationship' },
-                // ...while the relationship `value` is simplified to a bare ID (the populated-doc `$ref` is dropped).
-                value: { type: 'string', description: 'The ID of the related "posts" document.' },
+                // The value is already ID-only from the input variant - left as-is.
+                value: { type: 'string', description: 'The related document ID.' },
               },
               required: ['type'],
             },
           ],
         },
-        posts: {
-          type: 'object',
-          additionalProperties: false,
-          properties: { id: { type: 'string' }, title: { type: 'string' } },
-        },
       },
       properties: {
-        // `id` is dropped - it's a Payload-managed field MCP clients never set.
+        // Managed timestamps are excluded upstream by the `input` variant. `id` stays because it's
+        // a valid optional input (a client may supply a custom ID).
+        id: { type: 'string' },
         content: {
           type: 'object',
           properties: {

package/src/utils/schemaConversion/sanitizeEntitySchema.ts

@@ -1,30 +1,22 @@
 import type { JsonSchemaType } from '../../types.js'
 
 /**
- * Turns the JSON Schema that Payload generates for a collection or global into the input schema for
- * an MCP create/update tool. In short, it:
- *
- * - drops fields a client can't set (`id`, `createdAt`, the draft `_status`, …),
- * - rewrites Payload-specific field shapes (points, relationships) into plain JSON the model can fill,
- * - and shrinks the result so it's cheaper for the model to read,
- *
- * while keeping every node valid JSON Schema draft 2020-12. Each step below is tagged with why it runs -
- * **Correctness** (valid input the API accepts), **Size** (equivalence-preserving shrink), or **LLM
- * ergonomics** (easier for the model to read/fill) - and carries a before/after example on its definition.
+ * Refines Payload's `input`-variant JSON Schema into an MCP create/update tool's input schema. The
+ * variant already covers correctness (ID-only relationships, no managed/virtual/join fields); the
+ * passes here are MCP-specific - reshaping fields for the model and shrinking the result - and keep
+ * every node valid JSON Schema draft 2020-12. Each is tagged **Correctness**, **Size**, or **LLM
+ * ergonomics**, with a before/after example on its definition.
  */
 export const sanitizeEntitySchema = (schema: JsonSchemaType): JsonSchemaType => {
   // Work on a copy — the caller reuses the original schema elsewhere (e.g. when listing tools).
   let result = structuredClone(schema)
 
-  // Correctness — drop the fields a client can't set (id, createdAt, updatedAt, draft _status) + collapse nullable types.
-  result = removeManagedFields(result)
+  // LLM ergonomics — drop the redundant `'null'` from optional arrays/objects (`['array','null']` → `'array'`).
+  result = collapseOptionalContainerTypes(result)
 
   // LLM ergonomics — rewrite point fields from a `[number, number]` tuple into a `{ longitude, latitude }` object.
   result = pointFieldsToObjects(result)
 
-  // Correctness — a relationship value can be an ID or a populated doc; on input only the ID is valid, so keep that.
-  result = relationshipsToIds(result)
-
   // Size — strip inert type-gen leftovers that only bloat the schema (`tsType`, block-collision notes).
   result = removeTypeGenArtifacts(result)
 
@@ -58,26 +50,20 @@ const mapNodes = (node: unknown, visit: (node: JsonSchemaType) => JsonSchemaType
   for (const [key, value] of Object.entries(node)) {
     out[key] = mapNodes(value, visit)
   }
-  return visit(out as JsonSchemaType)
+  return visit(out)
 }
 
-// Payload sets these on every document, so an MCP client never provides them when creating/updating.
-const PAYLOAD_MANAGED_FIELDS = new Set(['_status', 'createdAt', 'id', 'updatedAt'])
-
 /**
- * **Correctness.** Removes the fields a client can't set on create/update - `id`, `createdAt`, `updatedAt`, and the draft
- * `_status` - from every field object's `properties` and `required` (recursing into nested objects and
- * array items). Along the way it also collapses optional array/object types via {@link collapseNullableType}.
+ * **LLM ergonomics.** Collapses optional array/object types (`['array', 'null']` → `'array'`) via
+ * {@link collapseNullableType}, recursing through `properties` and array items. The `required` list
+ * already conveys optionality, so the `'null'` is redundant noise for the model.
  *
  * @example
- * { properties: { id: { type: 'string' }, tags: { type: ['array', 'null'], items: {} } }, required: ['id', 'tags'] }
- * → { properties: { tags: { type: 'array', items: {} } }, required: ['tags'] }
+ * { properties: { tags: { type: ['array', 'null'], items: {} } }, required: [] }
+ * → { properties: { tags: { type: 'array', items: {} } }, required: [] }
  */
-const removeManagedFields = (schema: JsonSchemaType): JsonSchemaType => {
+const collapseOptionalContainerTypes = (schema: JsonSchemaType): JsonSchemaType => {
   if (schema.properties && typeof schema.properties === 'object') {
-    for (const field of PAYLOAD_MANAGED_FIELDS) {
-      delete schema.properties[field]
-    }
     for (const key of Object.keys(schema.properties)) {
       const prop = schema.properties[key] as JsonSchemaType
       if (!prop || typeof prop !== 'object') {
@@ -86,21 +72,14 @@ const removeManagedFields = (schema: JsonSchemaType): JsonSchemaType => {
       const isRequired = Array.isArray(schema.required) && schema.required.includes(key)
       collapseNullableType(prop, isRequired)
       if (prop.properties) {
-        removeManagedFields(prop)
+        collapseOptionalContainerTypes(prop)
       }
       if (prop.items && typeof prop.items === 'object' && !Array.isArray(prop.items)) {
-        removeManagedFields(prop.items)
+        collapseOptionalContainerTypes(prop.items)
       }
     }
   }
 
-  if (Array.isArray(schema.required)) {
-    schema.required = schema.required.filter((name) => !PAYLOAD_MANAGED_FIELDS.has(name))
-    if (schema.required.length === 0) {
-      delete schema.required
-    }
-  }
-
   return schema
 }
 
@@ -193,82 +172,6 @@ const pointFieldsToObjects = (schema: JsonSchemaType): JsonSchemaType => {
   return transformed
 }
 
-/**
- * **Correctness.** Reduces relationship/upload fields to the IDs a client actually sends. Payload types the value as
- * "an ID or the full related document" - but the populated-document form only appears in read responses;
- * on create/update you always reference a relationship by its ID. So we drop that `$ref` option, leaving
- * the bare ID. A single remaining target collapses inline (with a description naming the target
- * collection); several targets become an `anyOf` of IDs.
- *
- * @example
- * { oneOf: [{ type: 'string' }, { $ref: '#/$defs/posts' }] }
- * → { type: 'string', description: 'The ID of the related "posts" document.' }
- */
-const relationshipsToIds = (schema: JsonSchemaType): JsonSchemaType => {
-  if (!schema || typeof schema !== 'object') {
-    return schema
-  }
-
-  const processed = { ...schema }
-
-  if (Array.isArray(processed.oneOf)) {
-    const isRelatedDocRef = (option: unknown): option is { $ref: string } =>
-      !!option && typeof option === 'object' && '$ref' in option
-
-    if (processed.oneOf.some(isRelatedDocRef)) {
-      // A relationship value is "an ID, or the populated related document". Keep the ID option(s) and
-      // drop the `$ref`s to the related collections, since a client only ever sends the ID.
-      const idOptions = processed.oneOf
-        .filter((option) => !isRelatedDocRef(option))
-        .map((option) => (typeof option === 'object' ? relationshipsToIds(option) : option))
-      const targetCollections = processed.oneOf
-        .filter(isRelatedDocRef)
-        .map((option) => option.$ref.replace('#/$defs/', ''))
-
-      if (idOptions.length === 1) {
-        delete processed.oneOf
-        Object.assign(processed, idOptions[0])
-        if (targetCollections.length > 0 && !processed.description) {
-          processed.description = `The ID of the related "${targetCollections.join('" or "')}" document.`
-        }
-      } else if (idOptions.length > 1) {
-        delete processed.oneOf
-        processed.anyOf = idOptions
-      }
-    } else {
-      processed.oneOf = processed.oneOf.map((option) =>
-        typeof option === 'object' ? relationshipsToIds(option) : option,
-      )
-    }
-  }
-
-  if (processed.properties && typeof processed.properties === 'object') {
-    processed.properties = Object.fromEntries(
-      Object.entries(processed.properties).map(([key, value]) => [
-        key,
-        typeof value === 'object' ? relationshipsToIds(value) : value,
-      ]),
-    )
-  }
-
-  if (processed.items && typeof processed.items === 'object' && !Array.isArray(processed.items)) {
-    processed.items = relationshipsToIds(processed.items)
-  }
-
-  // Lexical node unions and blocks live under `$defs` and have their own relationship fields, so walk
-  // those too — otherwise their `$ref`s would dangle once we don't bundle the related collections.
-  if (processed.$defs && typeof processed.$defs === 'object') {
-    processed.$defs = Object.fromEntries(
-      Object.entries(processed.$defs).map(([key, value]) => [
-        key,
-        typeof value === 'object' ? relationshipsToIds(value) : value,
-      ]),
-    )
-  }
-
-  return processed
-}
-
 /**
  * **Size.** Strips type-generation leftovers that bloat the schema without helping the model: the `tsType`
  * hint (a `json-schema-to-typescript` extension; JSON Schema validators just ignore it, they don't reject it)
@@ -448,7 +351,7 @@ const deduplicateIntoDefinitions = (schema: JsonSchemaType): JsonSchemaType => {
         if (!name) {
           name = `shared_${nameByKey.size}`
           nameByKey.set(key, name)
-          sharedEntries[name] = node as JsonSchemaType
+          sharedEntries[name] = node
         }
         return { $ref: `#/$defs/${name}` }
       }

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/@types/assets.d.js

@@ -1,2 +0,0 @@
-
-//# sourceMappingURL=assets.d.js.map

package/dist/@types/assets.d.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/@types/assets.d.ts"],"names":[],"mappings":""}

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