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

package/src/mcp/builtin/globals/findVersionsTool.ts

@@ -0,0 +1,148 @@
+import type { PopulateType, SelectType } from 'payload'
+
+import { z } from 'zod'
+
+import { defaultAccess } from '../../../defaultAccess.js'
+import { defineGlobalTool } from '../../../defineTool.js'
+import { getLogger } from '../../../utils/getLogger.js'
+import { localAPIDefaults } from '../../../utils/localAPIDefaults.js'
+import { whereSchema } from '../../../utils/whereSchema.js'
+
+const DEFAULT_DESCRIPTION =
+  'Find global versions in any version-enabled global by passing the global slug and optional where clause.'
+
+export const findGlobalVersionsTool = defineGlobalTool({
+  access: (args) =>
+    defaultAccess(args) && Boolean(args.permissions?.globals?.[args.globalSlug]?.readVersions),
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+    readOnlyHint: true,
+    title: 'Find Global Versions',
+  },
+  description: DEFAULT_DESCRIPTION,
+  input: z.object({
+    depth: z
+      .number()
+      .int()
+      .min(0)
+      .max(10)
+      .describe('How many levels deep to populate relationships in global version documents')
+      .optional()
+      .default(0),
+    fallbackLocale: z
+      .string()
+      .describe('Optional: fallback locale code to use when requested locale is not available')
+      .optional(),
+    limit: z
+      .number()
+      .int()
+      .min(1)
+      .max(100)
+      .describe('Maximum number of versions to return (default: 10, max: 100)')
+      .optional()
+      .default(10),
+    locale: z
+      .string()
+      .describe(
+        'Optional: locale code to retrieve data in (e.g., "en", "es"). Use "all" to retrieve all locales for localized fields',
+      )
+      .optional(),
+    page: z
+      .number()
+      .int()
+      .min(1)
+      .describe('Page number for pagination (default: 1)')
+      .optional()
+      .default(1),
+    pagination: z
+      .boolean()
+      .describe('Optional: set to false to skip the count query overhead')
+      .optional(),
+    populate: z
+      .record(z.string(), z.unknown())
+      .describe(
+        'Optional: control which fields to include from populated relationship or upload documents.',
+      )
+      .optional(),
+    select: z
+      .record(z.string(), z.unknown())
+      .describe(
+        'Optional: define exactly which fields you\'d like to return in the response, e.g., {"version.siteName": true}',
+      )
+      .optional(),
+    showHiddenFields: z
+      .boolean()
+      .describe('Optional: include hidden fields in returned global version documents')
+      .optional(),
+    sort: z
+      .string()
+      .describe('Field to sort by (e.g., "-updatedAt", "-version.updatedAt" for descending)')
+      .optional(),
+    where: whereSchema
+      .describe(
+        'Optional: where clause for filtering versions. Version document fields are usually under "version". Example: {"version.siteName":{"contains":"test"}}',
+      )
+      .optional(),
+  }),
+}).handler(async ({ authorizedMCP, globalSlug, input, req }) => {
+  const payload = req.payload
+  const logger = getLogger({ payload })
+  const {
+    depth,
+    fallbackLocale,
+    limit,
+    locale,
+    page,
+    pagination,
+    populate,
+    select,
+    showHiddenFields,
+    sort,
+    where,
+  } = input
+
+  logger.info(`Finding versions for global: ${globalSlug}, limit: ${limit}, page: ${page}`)
+
+  try {
+    const result = await payload.findGlobalVersions({
+      slug: globalSlug,
+      depth,
+      limit,
+      page,
+      req,
+      ...localAPIDefaults(authorizedMCP),
+      ...(fallbackLocale ? { fallbackLocale } : {}),
+      ...(locale ? { locale } : {}),
+      ...(pagination !== undefined ? { pagination } : {}),
+      ...(populate ? { populate: populate as PopulateType } : {}),
+      ...(select ? { select: select as SelectType } : {}),
+      ...(showHiddenFields !== undefined ? { showHiddenFields } : {}),
+      ...(sort ? { sort } : {}),
+      ...(where ? { where } : {}),
+    })
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Versions for global "${globalSlug}":\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
+        },
+      ],
+      doc: result as unknown as Record<string, unknown>,
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+    logger.error(`Error finding versions for global ${globalSlug}: ${errorMessage}`)
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `❌ **Error finding versions for global "${globalSlug}":** ${errorMessage}`,
+        },
+      ],
+      isError: true,
+    }
+  }
+})

package/src/mcp/builtin/globals/getGlobalSchemaTool.ts

@@ -1,7 +1,20 @@
+import { defaultAccess } from '../../../defaultAccess.js'
 import { defineGlobalTool } from '../../../defineTool.js'
 import { getGlobalInputSchema } from '../../../utils/schemaConversion/getEntityInputSchema.js'
 
 export const getGlobalSchemaTool = defineGlobalTool({
+  access: (args) => {
+    const permissions = args.permissions?.globals?.[args.globalSlug]
+
+    return defaultAccess(args) && Boolean(permissions?.read || permissions?.update)
+  },
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+    readOnlyHint: true,
+    title: 'Get Global Schema',
+  },
   description: 'Get the input schema for updating a global.',
 }).handler(({ globalSlug, req }) => {
   const inputSchema = getGlobalInputSchema({ globalSlug, req })

package/src/mcp/builtin/globals/restoreVersionTool.ts

@@ -0,0 +1,100 @@
+import type { PopulateType } from 'payload'
+
+import { z } from 'zod'
+
+import { defaultAccess } from '../../../defaultAccess.js'
+import { defineGlobalTool } from '../../../defineTool.js'
+import { getLogger } from '../../../utils/getLogger.js'
+import { localAPIDefaults } from '../../../utils/localAPIDefaults.js'
+
+const DEFAULT_DESCRIPTION =
+  'Restore a global from a previous version in any version-enabled global.'
+
+export const restoreGlobalVersionTool = defineGlobalTool({
+  access: (args) =>
+    defaultAccess(args) && Boolean(args.permissions?.globals?.[args.globalSlug]?.update),
+  annotations: {
+    destructiveHint: true,
+    idempotentHint: false,
+    openWorldHint: false,
+    readOnlyHint: false,
+    title: 'Restore Global Version',
+  },
+  description: DEFAULT_DESCRIPTION,
+  input: z.object({
+    id: z.string().describe('The ID of the global version to restore'),
+    depth: z
+      .number()
+      .int()
+      .min(0)
+      .max(10)
+      .describe('How many levels deep to populate relationships in response')
+      .optional()
+      .default(0),
+    fallbackLocale: z
+      .string()
+      .describe('Optional: fallback locale code to use when requested locale is not available')
+      .optional(),
+    locale: z
+      .string()
+      .describe('Optional: locale code to restore in (e.g., "en", "es")')
+      .optional(),
+    populate: z
+      .record(z.string(), z.unknown())
+      .describe(
+        'Optional: control which fields to include from populated relationship or upload documents.',
+      )
+      .optional(),
+    showHiddenFields: z
+      .boolean()
+      .describe('Optional: include hidden fields in the restored global response')
+      .optional(),
+  }),
+}).handler(async ({ authorizedMCP, globalSlug, input, req }) => {
+  const payload = req.payload
+  const logger = getLogger({ payload })
+  const { id, depth, fallbackLocale, locale, populate, showHiddenFields } = input
+
+  logger.info(`Restoring version for global: ${globalSlug} with ID: ${id}`)
+
+  try {
+    const result = await payload.restoreGlobalVersion({
+      id,
+      slug: globalSlug,
+      depth,
+      req,
+      ...localAPIDefaults(authorizedMCP),
+      ...(fallbackLocale ? { fallbackLocale } : {}),
+      ...(locale ? { locale } : {}),
+      ...(populate ? { populate: populate as PopulateType } : {}),
+      ...(showHiddenFields !== undefined ? { showHiddenFields } : {}),
+    })
+    const resultObject = result as Record<string, unknown>
+    const restoredGlobal =
+      resultObject.version && typeof resultObject.version === 'object'
+        ? (resultObject.version as Record<string, unknown>)
+        : resultObject
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Version "${id}" restored successfully for global "${globalSlug}"!\nRestored global:\n\`\`\`json\n${JSON.stringify(restoredGlobal)}\n\`\`\``,
+        },
+      ],
+      doc: restoredGlobal,
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+    logger.error(`Error restoring version ${id} for global ${globalSlug}: ${errorMessage}`)
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `❌ **Error restoring version "${id}" for global "${globalSlug}":** ${errorMessage}`,
+        },
+      ],
+      isError: true,
+    }
+  }
+})

package/src/mcp/builtin/globals/updateTool.ts

@@ -2,6 +2,7 @@ import type { SelectType } from 'payload'
 
 import { z } from 'zod'
 
+import { defaultAccess } from '../../../defaultAccess.js'
 import { defineGlobalTool } from '../../../defineTool.js'
 import { getLogger } from '../../../utils/getLogger.js'
 import {
@@ -15,6 +16,15 @@ import { validateGlobalData } from '../validateEntityData.js'
 const DEFAULT_DESCRIPTION = 'Update any Payload global by passing the global slug and data.'
 
 export const updateGlobalTool = defineGlobalTool({
+  access: (args) =>
+    defaultAccess(args) && Boolean(args.permissions?.globals?.[args.globalSlug]?.update),
+  annotations: {
+    destructiveHint: true,
+    idempotentHint: false,
+    openWorldHint: false,
+    readOnlyHint: false,
+    title: 'Update Global',
+  },
   description: DEFAULT_DESCRIPTION,
   input: z.object({
     data: z.record(z.string(), z.unknown()).describe('The global fields to update'),
@@ -39,9 +49,9 @@ export const updateGlobalTool = defineGlobalTool({
       )
       .optional(),
     select: z
-      .string()
+      .record(z.string(), z.unknown())
       .describe(
-        "Optional: define exactly which fields you'd like to return in the response (JSON), e.g., '{\"siteName\": true}'",
+        'Optional: define exactly which fields you\'d like to return in the response, e.g., {"siteName": true}',
       )
       .optional(),
   }),
@@ -66,16 +76,6 @@ export const updateGlobalTool = defineGlobalTool({
 
     const parsedData = transformPointDataToPayload(inputData)
 
-    let selectClause: SelectType | undefined
-    if (select) {
-      try {
-        selectClause = JSON.parse(select) as SelectType
-      } catch {
-        logger.warn(`Invalid select clause JSON for global: ${select}`)
-        return { content: [{ type: 'text', text: 'Error: Invalid JSON in select clause' }] }
-      }
-    }
-
     const updateOptions: Parameters<typeof payload.updateGlobal>[0] = {
       slug: globalSlug,
       data: parsedData,
@@ -90,8 +90,8 @@ export const updateGlobalTool = defineGlobalTool({
     if (fallbackLocale) {
       updateOptions.fallbackLocale = fallbackLocale
     }
-    if (selectClause) {
-      updateOptions.select = selectClause
+    if (select) {
+      updateOptions.select = select as SelectType
     }
 
     const result = await payload.updateGlobal(updateOptions)

package/src/mcp/builtinTools.ts

@@ -8,19 +8,43 @@ import {
   unlockCollectionTool,
   verifyCollectionTool,
 } from './builtin/collections/authTools.js'
+import { countDocumentsTool } from './builtin/collections/countTool.js'
+import { countVersionsTool } from './builtin/collections/countVersionsTool.js'
 import { createDocumentTool } from './builtin/collections/createTool.js'
 import { deleteDocumentsTool } from './builtin/collections/deleteTool.js'
+import { duplicateDocumentTool } from './builtin/collections/duplicateTool.js'
+import { findDistinctTool } from './builtin/collections/findDistinctTool.js'
 import { findDocumentsTool } from './builtin/collections/findTool.js'
+import { findVersionByIDTool } from './builtin/collections/findVersionByIDTool.js'
+import { findVersionsTool } from './builtin/collections/findVersionsTool.js'
 import { getCollectionSchemaTool } from './builtin/collections/getCollectionSchemaTool.js'
+import { restoreVersionTool } from './builtin/collections/restoreVersionTool.js'
 import { updateDocumentTool } from './builtin/collections/updateTool.js'
 import { getConfigInfoTool } from './builtin/getConfigInfoTool.js'
+import { countGlobalVersionsTool } from './builtin/globals/countVersionsTool.js'
 import { findGlobalTool } from './builtin/globals/findTool.js'
+import { findGlobalVersionByIDTool } from './builtin/globals/findVersionByIDTool.js'
+import { findGlobalVersionsTool } from './builtin/globals/findVersionsTool.js'
 import { getGlobalSchemaTool } from './builtin/globals/getGlobalSchemaTool.js'
+import { restoreGlobalVersionTool } from './builtin/globals/restoreVersionTool.js'
 import { updateGlobalTool } from './builtin/globals/updateTool.js'
 
+type CollectionBuiltin = {
+  mcpName: string
+  requiresDuplicateEnabled?: boolean
+  requiresVersions?: boolean
+  tool: CollectionTool
+}
+
+type GlobalBuiltin = {
+  mcpName: string
+  requiresVersions?: boolean
+  tool: GlobalTool
+}
+
 export const TOOL_BUILTINS = {
-  getConfigInfo: { label: 'Config Info', mcpName: 'getConfigInfo', tool: getConfigInfoTool },
-} satisfies Record<string, { label: string; mcpName: string; tool: Tool }>
+  getConfigInfo: { mcpName: 'getConfigInfo', tool: getConfigInfoTool },
+} satisfies Record<string, { mcpName: string; tool: Tool }>
 
 /**
  * The static built-in collection CRUD tools. Keys here are the source of truth
@@ -28,44 +52,76 @@ export const TOOL_BUILTINS = {
  * automatically.
  */
 export const COLLECTION_BUILTINS = {
+  count: { mcpName: 'countDocuments', tool: countDocumentsTool },
+  countVersions: { mcpName: 'countVersions', requiresVersions: true, tool: countVersionsTool },
   create: { mcpName: 'createDocument', tool: createDocumentTool },
   delete: { mcpName: 'deleteDocuments', tool: deleteDocumentsTool },
+  duplicate: {
+    mcpName: 'duplicateDocument',
+    requiresDuplicateEnabled: true,
+    tool: duplicateDocumentTool,
+  },
   find: { mcpName: 'findDocuments', tool: findDocumentsTool },
+  findDistinct: { mcpName: 'findDistinct', tool: findDistinctTool },
+  findVersionByID: {
+    mcpName: 'findVersionByID',
+    requiresVersions: true,
+    tool: findVersionByIDTool,
+  },
+  findVersions: { mcpName: 'findVersions', requiresVersions: true, tool: findVersionsTool },
   getCollectionSchema: { mcpName: 'getCollectionSchema', tool: getCollectionSchemaTool },
+  restoreVersion: { mcpName: 'restoreVersion', requiresVersions: true, tool: restoreVersionTool },
   update: { mcpName: 'updateDocument', tool: updateDocumentTool },
-} satisfies Record<string, { mcpName: string; tool: CollectionTool }>
+} satisfies Record<string, CollectionBuiltin>
 
 /**
- * The static auth tools surfaced under auth-enabled collections. Each entry
- * carries the admin-UI label alongside the tool. Keys are the source of truth
- * for `MCPCollectionAuthToolName`.
+ * The static auth tools surfaced under auth-enabled collections. Keys are the
+ * source of truth for `MCPCollectionAuthToolName`.
  */
 export const COLLECTION_AUTH_BUILTINS = {
-  auth: { label: 'Check Auth Status', mcpName: 'auth', tool: authCollectionTool },
+  auth: { mcpName: 'auth', tool: authCollectionTool },
   forgotPassword: {
-    label: 'Forgot Password',
     mcpName: 'forgotPassword',
     tool: forgotPasswordCollectionTool,
   },
-  login: { label: 'User Login', mcpName: 'login', tool: loginCollectionTool },
+  login: { mcpName: 'login', tool: loginCollectionTool },
   resetPassword: {
-    label: 'Reset Password',
     mcpName: 'resetPassword',
     tool: resetPasswordCollectionTool,
   },
-  unlock: { label: 'Unlock Account', mcpName: 'unlock', tool: unlockCollectionTool },
-  verify: { label: 'Email Verification', mcpName: 'verify', tool: verifyCollectionTool },
-} satisfies Record<string, { label: string; mcpName: string; tool: CollectionTool }>
+  unlock: { mcpName: 'unlock', tool: unlockCollectionTool },
+  verify: { mcpName: 'verify', tool: verifyCollectionTool },
+} satisfies Record<string, { mcpName: string; tool: CollectionTool }>
 
 /**
  * The static built-in global tools. Keys are the source of truth for
  * `MCPGlobalBuiltinName`.
  */
 export const GLOBAL_BUILTINS = {
+  countGlobalVersions: {
+    mcpName: 'countGlobalVersions',
+    requiresVersions: true,
+    tool: countGlobalVersionsTool,
+  },
   find: { mcpName: 'findGlobal', tool: findGlobalTool },
+  findGlobalVersionByID: {
+    mcpName: 'findGlobalVersionByID',
+    requiresVersions: true,
+    tool: findGlobalVersionByIDTool,
+  },
+  findGlobalVersions: {
+    mcpName: 'findGlobalVersions',
+    requiresVersions: true,
+    tool: findGlobalVersionsTool,
+  },
   getGlobalSchema: { mcpName: 'getGlobalSchema', tool: getGlobalSchemaTool },
+  restoreGlobalVersion: {
+    mcpName: 'restoreGlobalVersion',
+    requiresVersions: true,
+    tool: restoreGlobalVersionTool,
+  },
   update: { mcpName: 'updateGlobal', tool: updateGlobalTool },
-} satisfies Record<string, { mcpName: string; tool: GlobalTool }>
+} satisfies Record<string, GlobalBuiltin>
 
 export type MCPCollectionBuiltinName = keyof typeof COLLECTION_BUILTINS
 
@@ -86,7 +142,7 @@ export const TOOL_BUILTIN_ENTRIES = Object.entries(TOOL_BUILTINS) as Array<
 >
 
 export const COLLECTION_BUILTIN_ENTRIES = Object.entries(COLLECTION_BUILTINS) as Array<
-  [MCPCollectionBuiltinName, (typeof COLLECTION_BUILTINS)[MCPCollectionBuiltinName]]
+  [MCPCollectionBuiltinName, CollectionBuiltin]
 >
 
 export const COLLECTION_AUTH_BUILTIN_ENTRIES = Object.entries(COLLECTION_AUTH_BUILTINS) as Array<
@@ -94,5 +150,5 @@ export const COLLECTION_AUTH_BUILTIN_ENTRIES = Object.entries(COLLECTION_AUTH_BU
 >
 
 export const GLOBAL_BUILTIN_ENTRIES = Object.entries(GLOBAL_BUILTINS) as Array<
-  [MCPGlobalBuiltinName, (typeof GLOBAL_BUILTINS)[MCPGlobalBuiltinName]]
+  [MCPGlobalBuiltinName, GlobalBuiltin]
 >

package/src/mcp/sanitizeMCPConfig.ts

@@ -17,6 +17,7 @@ import type {
   SanitizedMCPPluginConfig,
 } from '../types.js'
 
+import { defaultAccess } from '../defaultAccess.js'
 import {
   COLLECTION_AUTH_BUILTIN_ENTRIES,
   COLLECTION_AUTH_BUILTINS,
@@ -33,7 +34,6 @@ import {
  *  - Flattens `tools` / `prompts` / `resources` / per-collection / per-global
  *    tool maps into a single `items` array.
  *  - Applies built-in tools for collections and globals, respecting opt-out user overrides.
- *  - Applies the `userCollection` default
  *
  * Called once during plugin init. After that, `plugins['@payloadcms/plugin-mcp']
  * ?.options` holds the sanitized result
@@ -55,13 +55,13 @@ export const sanitizeMCPConfig = ({
     items.push(...sanitizeGlobalConfig({ global, pluginConfig }))
   }
 
-  for (const [configKey, { label, mcpName, tool }] of TOOL_BUILTIN_ENTRIES) {
+  for (const [configKey, { mcpName, tool }] of TOOL_BUILTIN_ENTRIES) {
     items.push({
       type: 'tool',
       configKey,
-      label,
+      label: tool.annotations?.title ?? configKey,
       mcpName,
-      tool,
+      tool: { ...tool, access: tool.access ?? defaultAccess },
     })
   }
 
@@ -72,9 +72,9 @@ export const sanitizeMCPConfig = ({
     items.push({
       type: 'tool',
       configKey,
-      label: configKey,
+      label: tool.annotations?.title ?? configKey,
       mcpName: configKey,
-      tool,
+      tool: { ...tool, access: tool.access ?? defaultAccess },
     })
   }
 
@@ -84,7 +84,7 @@ export const sanitizeMCPConfig = ({
       configKey,
       label: prompt.title ?? configKey,
       mcpName: configKey,
-      prompt,
+      prompt: { ...prompt, access: prompt.access ?? defaultAccess },
     })
   }
 
@@ -94,21 +94,15 @@ export const sanitizeMCPConfig = ({
       configKey,
       label: resource.title ?? configKey,
       mcpName: configKey,
-      resource,
+      resource: { ...resource, access: resource.access ?? defaultAccess },
     })
   }
 
-  // Mirror Payload's own admin.user detection (sanitize.ts) since plugins run first.
-  const firstCollectionWithAuth = config.collections!.find(({ auth }) => Boolean(auth))
-
   return {
     disabled: pluginConfig.disabled,
     items,
     mcp: pluginConfig.mcp,
-    overrideApiKeyCollection: pluginConfig.overrideApiKeyCollection,
-    overrideAuth: pluginConfig.overrideAuth,
-    userCollection:
-      pluginConfig.userCollection ?? config.admin?.user ?? firstCollectionWithAuth?.slug ?? 'users',
+    overrideGetAuthorizedMCP: pluginConfig.overrideGetAuthorizedMCP,
   }
 }
 
@@ -119,27 +113,43 @@ const sanitizeCollectionConfig = ({
   collection: CollectionConfig | SanitizedCollectionConfig
   pluginConfig: MCPPluginConfig
 }): CollectionMCPItem[] => {
-  if (collection.slug === 'payload-mcp-api-keys') {
-    return []
-  }
   const slug = collection.slug
   const collectionPluginConfig = pluginConfig.collections?.[slug]
   const items: CollectionMCPItem[] = []
+  /**
+   * Payload disables duplicate for auth collections by default unless the
+   * collection explicitly opts back in with `disableDuplicate: false`.
+   */
+  const isDuplicateDisabled =
+    collection.disableDuplicate === true ||
+    (Boolean(collection.auth) && collection.disableDuplicate !== false)
 
-  for (const [toolKey, { mcpName, tool }] of COLLECTION_BUILTIN_ENTRIES) {
+  for (const [
+    toolKey,
+    { mcpName, requiresDuplicateEnabled, requiresVersions, tool },
+  ] of COLLECTION_BUILTIN_ENTRIES) {
+    if (requiresVersions && !collection.versions) {
+      continue
+    }
+    if (requiresDuplicateEnabled && isDuplicateDisabled) {
+      continue
+    }
     const matchedConfigEntry = collectionPluginConfig?.tools?.[toolKey]
     if (matchedConfigEntry === false) {
       continue
     }
     const override = typeof matchedConfigEntry === 'object' ? matchedConfigEntry : undefined
+    const annotations = { ...tool.annotations, ...override?.annotations }
     items.push({
       type: 'collectionTool',
       collectionSlug: slug,
       configKey: toolKey,
-      label: capitalize(toolKey),
+      label: annotations.title ?? toolKey,
       mcpName,
       tool: {
         ...tool,
+        access: override?.access ?? tool.access ?? defaultAccess,
+        annotations,
         description: override?.description ?? tool.description,
         overrideResponse:
           override?.overrideResponse ??
@@ -150,21 +160,24 @@ const sanitizeCollectionConfig = ({
   }
 
   if (collection.auth) {
-    for (const [authToolKey, { label, mcpName, tool }] of COLLECTION_AUTH_BUILTIN_ENTRIES) {
+    for (const [authToolKey, { mcpName, tool }] of COLLECTION_AUTH_BUILTIN_ENTRIES) {
       const matchedConfigEntry = collectionPluginConfig?.tools?.[authToolKey]
       if (!matchedConfigEntry) {
         continue
       }
       // `true` means "enable, no override"; only the object form carries fields.
       const override = typeof matchedConfigEntry === 'object' ? matchedConfigEntry : undefined
+      const annotations = { ...tool.annotations, ...override?.annotations }
       items.push({
         type: 'collectionTool',
         collectionSlug: slug,
         configKey: authToolKey,
-        label,
+        label: annotations.title ?? authToolKey,
         mcpName,
         tool: {
           ...tool,
+          access: override?.access ?? tool.access ?? defaultAccess,
+          annotations,
           description: override?.description ?? tool.description,
           overrideResponse:
             override?.overrideResponse ??
@@ -191,9 +204,9 @@ const sanitizeCollectionConfig = ({
       type: 'collectionTool',
       collectionSlug: slug,
       configKey,
-      label: configKey,
+      label: customTool.annotations?.title ?? configKey,
       mcpName: configKey,
-      tool: customTool,
+      tool: { ...customTool, access: customTool.access ?? defaultAccess },
     })
   }
 
@@ -211,20 +224,26 @@ const sanitizeGlobalConfig = ({
   const globalPluginConfig = pluginConfig.globals?.[slug]
   const items: GlobalMCPItem[] = []
 
-  for (const [toolKey, { mcpName, tool }] of GLOBAL_BUILTIN_ENTRIES) {
+  for (const [toolKey, { mcpName, requiresVersions, tool }] of GLOBAL_BUILTIN_ENTRIES) {
+    if (requiresVersions && !global.versions) {
+      continue
+    }
     const matchedConfigEntry = globalPluginConfig?.tools?.[toolKey]
     if (matchedConfigEntry === false) {
       continue
     }
     const override = typeof matchedConfigEntry === 'object' ? matchedConfigEntry : undefined
+    const annotations = { ...tool.annotations, ...override?.annotations }
     items.push({
       type: 'globalTool',
       configKey: toolKey,
       globalSlug: slug,
-      label: capitalize(toolKey),
+      label: annotations.title ?? toolKey,
       mcpName,
       tool: {
         ...tool,
+        access: override?.access ?? tool.access ?? defaultAccess,
+        annotations,
         description: override?.description ?? tool.description,
         overrideResponse:
           override?.overrideResponse ??
@@ -248,13 +267,11 @@ const sanitizeGlobalConfig = ({
       type: 'globalTool',
       configKey,
       globalSlug: slug,
-      label: configKey,
+      label: customTool.annotations?.title ?? configKey,
       mcpName: configKey,
-      tool: customTool,
+      tool: { ...customTool, access: customTool.access ?? defaultAccess },
     })
   }
 
   return items
 }
-
-const capitalize = (s: string): string => s.charAt(0).toUpperCase() + s.slice(1)