@payloadcms/plugin-mcp 4.0.0-internal.c3ac604 → 4.0.0-internal.cc18726

package/src/mcp/builtin/collections/findDistinctTool.ts

@@ -1,18 +1,15 @@
-import type { PopulateType } from 'payload'
-
-import { z } from 'zod'
+import { findDistinctInputSchema } from 'payload'
 
 import { defaultAccess } from '../../../defaultAccess.js'
 import { defineCollectionTool } from '../../../defineTool.js'
 import { getLogger } from '../../../utils/getLogger.js'
-import { whereSchema } from '../../../utils/whereSchema.js'
 
 const DEFAULT_DESCRIPTION =
   'Find distinct values for a field in any collection by passing the collection slug and field path.'
 
 export const findDistinctTool = defineCollectionTool({
   access: (args) =>
-    defaultAccess(args) && Boolean(args.permissions?.collections?.[args.collectionSlug]?.read),
+    defaultAccess(args) && Boolean(args.permissions?.collections?.[args.slug]?.read),
   annotations: {
     destructiveHint: false,
     idempotentHint: true,
@@ -21,65 +18,17 @@ export const findDistinctTool = defineCollectionTool({
     title: 'Find Distinct',
   },
   description: DEFAULT_DESCRIPTION,
-  input: z.object({
-    depth: z
-      .number()
-      .int()
-      .min(0)
-      .max(10)
-      .describe('How many levels deep to populate relationships in distinct values')
-      .optional()
-      .default(0),
-    field: z.string().describe('The field path to get distinct values for'),
-    limit: z
-      .number()
-      .int()
-      .min(1)
-      .max(100)
-      .describe('Maximum number of distinct values to return (max: 100)')
-      .optional(),
-    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').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 distinct query')
-      .optional(),
-    sort: z
-      .string()
-      .describe('Field to sort by (e.g., "createdAt", "-updatedAt" for descending)')
-      .optional(),
-    trash: z
-      .boolean()
-      .describe('Optional: include soft-deleted documents when trash is enabled on the collection')
-      .optional(),
-    where: whereSchema
-      .describe(
-        'Optional: where clause for filtering. Use field names with Payload operators, and/or arrays for grouping. Example: {"title":{"contains":"test"}}',
-      )
-      .optional(),
-  }),
-}).handler(async ({ authorizedMCP, collectionSlug, input, req }) => {
+  input: findDistinctInputSchema,
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
   const payload = req.payload
   const logger = getLogger({ payload })
-  const { depth, field, limit, locale, page, populate, showHiddenFields, sort, trash, where } =
-    input
+  const { depth, field, limit, locale, page, populate, sort, trash, where } = input
 
-  logger.info(`Finding distinct values in collection: ${collectionSlug}, field: ${field}`)
+  logger.info(`Finding distinct values in collection: ${slug}, field: ${field}`)
 
   try {
     const result = await payload.findDistinct({
-      collection: collectionSlug,
+      collection: slug,
       depth,
       field,
       overrideAccess: authorizedMCP.overrideAccess,
@@ -87,8 +36,7 @@ export const findDistinctTool = defineCollectionTool({
       ...(limit ? { limit } : {}),
       ...(locale ? { locale } : {}),
       ...(page ? { page } : {}),
-      ...(populate ? { populate: populate as PopulateType } : {}),
-      ...(showHiddenFields !== undefined ? { showHiddenFields } : {}),
+      ...(populate ? { populate } : {}),
       ...(sort ? { sort } : {}),
       ...(trash !== undefined ? { trash } : {}),
       ...(where ? { where } : {}),
@@ -98,19 +46,19 @@ export const findDistinctTool = defineCollectionTool({
       content: [
         {
           type: 'text',
-          text: `Distinct values for "${field}" in collection "${collectionSlug}":\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
+          text: `Distinct values for "${field}" in collection "${slug}":\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 distinct values in ${collectionSlug}: ${errorMessage}`)
+    logger.error(`Error finding distinct values in ${slug}: ${errorMessage}`)
     return {
       content: [
         {
           type: 'text',
-          text: `❌ **Error finding distinct values in collection "${collectionSlug}":** ${errorMessage}`,
+          text: `❌ **Error finding distinct values in collection "${slug}":** ${errorMessage}`,
         },
       ],
       isError: true,

package/src/mcp/builtin/collections/findTool.ts

@@ -1,18 +1,15 @@
-import type { JoinQuery, PopulateType, SelectType } from 'payload'
-
-import { z } from 'zod'
+import { findDocumentsInputSchema } from 'payload'
 
 import { defaultAccess } from '../../../defaultAccess.js'
 import { defineCollectionTool } from '../../../defineTool.js'
 import { getLogger } from '../../../utils/getLogger.js'
-import { whereSchema } from '../../../utils/whereSchema.js'
 
 const DEFAULT_DESCRIPTION =
   'Find documents in any collection by passing the collection slug and optional ID or where clause.'
 
 export const findDocumentsTool = defineCollectionTool({
   access: (args) =>
-    defaultAccess(args) && Boolean(args.permissions?.collections?.[args.collectionSlug]?.read),
+    defaultAccess(args) && Boolean(args.permissions?.collections?.[args.slug]?.read),
   annotations: {
     destructiveHint: false,
     idempotentHint: true,
@@ -21,87 +18,8 @@ export const findDocumentsTool = defineCollectionTool({
     title: 'Find Documents',
   },
   description: DEFAULT_DESCRIPTION,
-  input: z.object({
-    id: z
-      .union([z.string(), z.number()])
-      .describe(
-        'Optional: specific document ID to retrieve. If not provided, returns all documents',
-      )
-      .optional(),
-    depth: z
-      .number()
-      .int()
-      .min(0)
-      .max(10)
-      .describe('How many levels deep to populate relationships (default: 0)')
-      .optional()
-      .default(0),
-    draft: z
-      .boolean()
-      .describe(
-        'For versioned collections, true returns the latest draft version when available. False reads the main document.',
-      )
-      .optional(),
-    fallbackLocale: z
-      .string()
-      .describe('Optional: fallback locale code to use when requested locale is not available')
-      .optional(),
-    joins: z
-      .union([z.record(z.string(), z.unknown()), z.literal(false)])
-      .describe('Optional: configure join field queries, or pass false to disable all join fields.')
-      .optional(),
-    limit: z
-      .number()
-      .int()
-      .min(1)
-      .max(100)
-      .describe('Maximum number of documents 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., {"title": true}',
-      )
-      .optional(),
-    sort: z
-      .string()
-      .describe('Field to sort by (e.g., "createdAt", "-updatedAt" for descending)')
-      .optional(),
-    trash: z
-      .boolean()
-      .describe('Optional: include soft-deleted documents when trash is enabled on the collection')
-      .optional(),
-    where: whereSchema
-      .describe(
-        'Optional: where clause for filtering. Use field names with Payload operators, and/or arrays for grouping. Example: {"title":{"contains":"test"}}',
-      )
-      .optional(),
-  }),
-}).handler(async ({ authorizedMCP, collectionSlug, input, req }) => {
+  input: findDocumentsInputSchema,
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
   const payload = req.payload
   const logger = getLogger({ payload })
 
@@ -123,7 +41,7 @@ export const findDocumentsTool = defineCollectionTool({
   } = input
 
   logger.info(
-    `Reading document from collection: ${collectionSlug}${id ? ` with ID: ${id}` : ''}, limit: ${limit}, page: ${page}${locale ? `, locale: ${locale}` : ''}`,
+    `Reading document from collection: ${slug}${id ? ` with ID: ${id}` : ''}, limit: ${limit}, page: ${page}${locale ? `, locale: ${locale}` : ''}`,
   )
 
   try {
@@ -131,15 +49,15 @@ export const findDocumentsTool = defineCollectionTool({
       try {
         const doc = await payload.findByID({
           id,
-          collection: collectionSlug,
+          collection: slug,
           depth,
           overrideAccess: authorizedMCP.overrideAccess,
           req,
-          ...(select && { select: select as SelectType }),
-          ...(populate && { populate: populate as PopulateType }),
-          ...(joins !== undefined && { joins: joins as JoinQuery }),
+          ...(select && { select }),
+          ...(populate && { populate }),
+          ...(joins !== undefined && { joins }),
           ...(locale && { locale }),
-          ...(fallbackLocale && { fallbackLocale }),
+          ...(fallbackLocale !== undefined && { fallbackLocale }),
           ...(draft !== undefined && { draft }),
           ...(trash !== undefined && { trash }),
         })
@@ -148,18 +66,18 @@ export const findDocumentsTool = defineCollectionTool({
           content: [
             {
               type: 'text',
-              text: `Document from collection "${collectionSlug}":\n${JSON.stringify(doc)}`,
+              text: `Document from collection "${slug}":\n${JSON.stringify(doc)}`,
             },
           ],
           doc: doc as Record<string, unknown>,
         }
       } catch {
-        logger.warn(`Document not found with ID: ${id} in collection: ${collectionSlug}`)
+        logger.warn(`Document not found with ID: ${id} in collection: ${slug}`)
         return {
           content: [
             {
               type: 'text',
-              text: `Error: Document with ID "${id}" not found in collection "${collectionSlug}"`,
+              text: `Error: Document with ID "${id}" not found in collection "${slug}"`,
             },
           ],
         }
@@ -167,17 +85,17 @@ export const findDocumentsTool = defineCollectionTool({
     }
 
     const findOptions: Parameters<typeof payload.find>[0] = {
-      collection: collectionSlug,
+      collection: slug,
       depth,
       limit,
       overrideAccess: authorizedMCP.overrideAccess,
       page,
       req,
-      ...(select && { select: select as SelectType }),
-      ...(populate && { populate: populate as PopulateType }),
-      ...(joins !== undefined && { joins: joins as JoinQuery }),
+      ...(select && { select }),
+      ...(populate && { populate }),
+      ...(joins !== undefined && { joins }),
       ...(locale && { locale }),
-      ...(fallbackLocale && { fallbackLocale }),
+      ...(fallbackLocale !== undefined && { fallbackLocale }),
       ...(draft !== undefined && { draft }),
       ...(pagination !== undefined && { pagination }),
       ...(trash !== undefined && { trash }),
@@ -192,7 +110,7 @@ export const findDocumentsTool = defineCollectionTool({
 
     const result = await payload.find(findOptions)
 
-    let responseText = `Collection: "${collectionSlug}"\nTotal: ${result.totalDocs} documents\nPage: ${result.page} of ${result.totalPages}\n`
+    let responseText = `Collection: "${slug}"\nTotal: ${result.totalDocs} documents\nPage: ${result.page} of ${result.totalPages}\n`
     for (const doc of result.docs) {
       responseText += `\n\`\`\`json\n${JSON.stringify(doc)}\n\`\`\``
     }
@@ -203,12 +121,12 @@ export const findDocumentsTool = defineCollectionTool({
     }
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : 'Unknown error'
-    logger.error(`Error reading documents from collection ${collectionSlug}: ${errorMessage}`)
+    logger.error(`Error reading documents from collection ${slug}: ${errorMessage}`)
     return {
       content: [
         {
           type: 'text',
-          text: `❌ **Error reading documents from collection "${collectionSlug}":** ${errorMessage}`,
+          text: `❌ **Error reading documents from collection "${slug}":** ${errorMessage}`,
         },
       ],
     }

package/src/mcp/builtin/collections/findVersionByIDTool.ts

@@ -1,6 +1,4 @@
-import type { PopulateType, SelectType } from 'payload'
-
-import { z } from 'zod'
+import { findVersionByIDInputSchema } from 'payload'
 
 import { defaultAccess } from '../../../defaultAccess.js'
 import { defineCollectionTool } from '../../../defineTool.js'
@@ -11,8 +9,7 @@ const DEFAULT_DESCRIPTION =
 
 export const findVersionByIDTool = defineCollectionTool({
   access: (args) =>
-    defaultAccess(args) &&
-    Boolean(args.permissions?.collections?.[args.collectionSlug]?.readVersions),
+    defaultAccess(args) && Boolean(args.permissions?.collections?.[args.slug]?.readVersions),
   annotations: {
     destructiveHint: false,
     idempotentHint: true,
@@ -21,66 +18,26 @@ export const findVersionByIDTool = defineCollectionTool({
     title: 'Find Version By ID',
   },
   description: DEFAULT_DESCRIPTION,
-  input: z.object({
-    id: z.string().describe('The ID of the version to retrieve'),
-    depth: z
-      .number()
-      .int()
-      .min(0)
-      .max(10)
-      .describe('How many levels deep to populate relationships in the version document')
-      .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 retrieve data in (e.g., "en", "es"). Use "all" to retrieve all locales for localized fields',
-      )
-      .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.title": true}',
-      )
-      .optional(),
-    showHiddenFields: z
-      .boolean()
-      .describe('Optional: include hidden fields in the returned version document')
-      .optional(),
-    trash: z
-      .boolean()
-      .describe('Optional: include soft-deleted version documents when trash is enabled')
-      .optional(),
-  }),
-}).handler(async ({ authorizedMCP, collectionSlug, input, req }) => {
+  input: findVersionByIDInputSchema,
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
   const payload = req.payload
   const logger = getLogger({ payload })
-  const { id, depth, fallbackLocale, locale, populate, select, showHiddenFields, trash } = input
+  const { id, depth, draft, fallbackLocale, locale, populate, select, trash } = input
 
-  logger.info(`Finding version in collection: ${collectionSlug} with ID: ${id}`)
+  logger.info(`Finding version in collection: ${slug} with ID: ${id}`)
 
   try {
     const result = await payload.findVersionByID({
-      id,
-      collection: collectionSlug,
+      id: String(id),
+      collection: slug,
       depth,
       overrideAccess: authorizedMCP.overrideAccess,
       req,
-      ...(fallbackLocale ? { fallbackLocale } : {}),
+      ...(draft !== undefined ? { draft } : {}),
+      ...(fallbackLocale !== undefined ? { fallbackLocale } : {}),
       ...(locale ? { locale } : {}),
-      ...(populate ? { populate: populate as PopulateType } : {}),
-      ...(select ? { select: select as SelectType } : {}),
-      ...(showHiddenFields !== undefined ? { showHiddenFields } : {}),
+      ...(populate ? { populate } : {}),
+      ...(select ? { select } : {}),
       ...(trash !== undefined ? { trash } : {}),
     })
 
@@ -88,19 +45,19 @@ export const findVersionByIDTool = defineCollectionTool({
       content: [
         {
           type: 'text',
-          text: `Version "${id}" from collection "${collectionSlug}":\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
+          text: `Version "${id}" from collection "${slug}":\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 version ${id} in ${collectionSlug}: ${errorMessage}`)
+    logger.error(`Error finding version ${id} in ${slug}: ${errorMessage}`)
     return {
       content: [
         {
           type: 'text',
-          text: `❌ **Error finding version "${id}" in collection "${collectionSlug}":** ${errorMessage}`,
+          text: `❌ **Error finding version "${id}" in collection "${slug}":** ${errorMessage}`,
         },
       ],
       isError: true,

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

@@ -1,19 +1,15 @@
-import type { PopulateType, SelectType } from 'payload'
-
-import { z } from 'zod'
+import { findVersionsInputSchema } from 'payload'
 
 import { defaultAccess } from '../../../defaultAccess.js'
 import { defineCollectionTool } from '../../../defineTool.js'
 import { getLogger } from '../../../utils/getLogger.js'
-import { whereSchema } from '../../../utils/whereSchema.js'
 
 const DEFAULT_DESCRIPTION =
   'Find document versions in any version-enabled collection by passing the collection slug and optional where clause.'
 
 export const findVersionsTool = defineCollectionTool({
   access: (args) =>
-    defaultAccess(args) &&
-    Boolean(args.permissions?.collections?.[args.collectionSlug]?.readVersions),
+    defaultAccess(args) && Boolean(args.permissions?.collections?.[args.slug]?.readVersions),
   annotations: {
     destructiveHint: false,
     idempotentHint: true,
@@ -22,79 +18,13 @@ export const findVersionsTool = defineCollectionTool({
     title: 'Find Versions',
   },
   description: DEFAULT_DESCRIPTION,
-  input: z.object({
-    depth: z
-      .number()
-      .int()
-      .min(0)
-      .max(10)
-      .describe('How many levels deep to populate relationships in 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.title": true}',
-      )
-      .optional(),
-    showHiddenFields: z
-      .boolean()
-      .describe('Optional: include hidden fields in returned version documents')
-      .optional(),
-    sort: z
-      .string()
-      .describe('Field to sort by (e.g., "-updatedAt", "-version.updatedAt" for descending)')
-      .optional(),
-    trash: z
-      .boolean()
-      .describe('Optional: include versions for soft-deleted documents when trash is enabled')
-      .optional(),
-    where: whereSchema
-      .describe(
-        'Optional: where clause for filtering versions. Version document fields are usually under "version". Example: {"version.title":{"contains":"test"}}',
-      )
-      .optional(),
-  }),
-}).handler(async ({ authorizedMCP, collectionSlug, input, req }) => {
+  input: findVersionsInputSchema,
+}).handler(async ({ slug, authorizedMCP, input, req }) => {
   const payload = req.payload
   const logger = getLogger({ payload })
   const {
     depth,
+    draft,
     fallbackLocale,
     limit,
     locale,
@@ -102,28 +32,27 @@ export const findVersionsTool = defineCollectionTool({
     pagination,
     populate,
     select,
-    showHiddenFields,
     sort,
     trash,
     where,
   } = input
 
-  logger.info(`Finding versions in collection: ${collectionSlug}, limit: ${limit}, page: ${page}`)
+  logger.info(`Finding versions in collection: ${slug}, limit: ${limit}, page: ${page}`)
 
   try {
     const result = await payload.findVersions({
-      collection: collectionSlug,
+      collection: slug,
       depth,
       limit,
       overrideAccess: authorizedMCP.overrideAccess,
       page,
       req,
-      ...(fallbackLocale ? { fallbackLocale } : {}),
+      ...(draft !== undefined ? { draft } : {}),
+      ...(fallbackLocale !== undefined ? { fallbackLocale } : {}),
       ...(locale ? { locale } : {}),
       ...(pagination !== undefined ? { pagination } : {}),
-      ...(populate ? { populate: populate as PopulateType } : {}),
-      ...(select ? { select: select as SelectType } : {}),
-      ...(showHiddenFields !== undefined ? { showHiddenFields } : {}),
+      ...(populate ? { populate } : {}),
+      ...(select ? { select } : {}),
       ...(sort ? { sort } : {}),
       ...(trash !== undefined ? { trash } : {}),
       ...(where ? { where } : {}),
@@ -133,19 +62,19 @@ export const findVersionsTool = defineCollectionTool({
       content: [
         {
           type: 'text',
-          text: `Versions for collection "${collectionSlug}":\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
+          text: `Versions for collection "${slug}":\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 in ${collectionSlug}: ${errorMessage}`)
+    logger.error(`Error finding versions in ${slug}: ${errorMessage}`)
     return {
       content: [
         {
           type: 'text',
-          text: `❌ **Error finding versions in collection "${collectionSlug}":** ${errorMessage}`,
+          text: `❌ **Error finding versions in collection "${slug}":** ${errorMessage}`,
         },
       ],
       isError: true,

package/src/mcp/builtin/collections/formatCollectionError.ts

@@ -1,8 +1,8 @@
 import type { CollectionSlug, PayloadRequest } from 'payload'
 
-import type { MCPToolResponse } from '../../../types.js'
+import { getCollectionInputSchema } from 'payload'
 
-import { getCollectionInputSchema } from '../../../utils/schemaConversion/getEntityInputSchema.js'
+import type { MCPToolResponse } from '../../../types.js'
 
 const getValidationErrors = (error: unknown): undefined | unknown[] => {
   if (!error || typeof error !== 'object') {
@@ -33,15 +33,15 @@ const isSchemaError = (error: unknown, message: string): boolean => {
 }
 
 export const formatCollectionError = ({
+  slug,
   action,
-  collectionSlug,
   error,
   req,
 }: {
   action: 'creating' | 'duplicating' | 'updating'
-  collectionSlug: CollectionSlug
   error: unknown
   req: PayloadRequest
+  slug: CollectionSlug
 }): MCPToolResponse => {
   const errorMessage = error instanceof Error ? error.message : 'Unknown error'
   const errors = getValidationErrors(error) ?? [{ message: errorMessage }]
@@ -51,14 +51,14 @@ export const formatCollectionError = ({
       content: [
         {
           type: 'text',
-          text: `Error ${action} document in collection "${collectionSlug}": ${errorMessage}`,
+          text: `Error ${action} document in collection "${slug}": ${errorMessage}`,
         },
       ],
       isError: true,
     }
   }
 
-  const schema = getCollectionInputSchema({ collectionSlug, req })
+  const schema = getCollectionInputSchema({ collectionSlug: slug, req })
   const schemaText = schema
     ? `\n\nUse this schema for data:\n\`\`\`json\n${JSON.stringify(schema)}\n\`\`\``
     : ''
@@ -67,14 +67,14 @@ export const formatCollectionError = ({
     content: [
       {
         type: 'text',
-        text: `Error ${action} document in collection "${collectionSlug}": ${errorMessage}${schemaText}`,
+        text: `Error ${action} document in collection "${slug}": ${errorMessage}${schemaText}`,
       },
     ],
     isError: true,
     ...(schema
       ? {
           structuredContent: {
-            collectionSlug,
+            slug,
             errors,
             schema,
           },