payload-mcp-toolkit 0.2.0

package/dist/tools/compose-helpers.js

@@ -0,0 +1,236 @@
+import { z } from 'zod';
+/** Schema for a single leaf block within a section */ export const leafBlockSchema = z.object({
+    blockType: z.string(),
+    fields: z.record(z.string(), z.unknown()).optional()
+});
+/** Schema for a single section in a layout */ export const sectionSchema = z.object({
+    sectionType: z.string(),
+    config: z.record(z.string(), z.unknown()).optional(),
+    /** Leaf blocks for single-content sections */ content: z.array(leafBlockSchema).optional(),
+    /** Left column leaf blocks (for two-column sections) */ leftColumn: z.array(leafBlockSchema).optional(),
+    /** Right column leaf blocks (for two-column sections) */ rightColumn: z.array(leafBlockSchema).optional(),
+    /** Flat field values for fixed sections */ fields: z.record(z.string(), z.unknown()).optional()
+});
+/**
+ * Validate and compose an array of section inputs into block JSON.
+ * Returns either composed blocks or a list of validation errors.
+ */ export function composeSections(sections, catalog) {
+    const sectionMap = new Map(catalog.sections.map((s)=>[
+            s.slug,
+            s
+        ]));
+    const allLeafSlugs = catalog.leaves.map((l)=>l.slug);
+    const blocks = [];
+    const errors = [];
+    for(let i = 0; i < sections.length; i++){
+        const result = composeSingleSection(sections[i], i, sectionMap, allLeafSlugs);
+        if (result.errors.length > 0) {
+            errors.push(...result.errors);
+        } else if (result.block) {
+            blocks.push(result.block);
+        }
+    }
+    return {
+        blocks,
+        errors
+    };
+}
+/** Build a hint payload describing the available section/leaf vocabulary. */ export function buildHint(catalog) {
+    return {
+        availableSections: catalog.sections.map((s)=>s.slug),
+        availableLeaves: catalog.leaves.map((l)=>l.slug),
+        sectionDetails: catalog.sections.map((s)=>({
+                slug: s.slug,
+                nestingType: s.nestingType,
+                acceptedLeaves: s.acceptedLeafSlugs,
+                maxRows: s.maxRows
+            }))
+    };
+}
+/**
+ * Apply a list operation against an existing array of blocks.
+ * `full` always replaces; the rest preserve the existing array.
+ */ export function applyOperation(composedBlocks, operation, insertIndex, existingLayout) {
+    if (operation === 'full' || !existingLayout) {
+        return composedBlocks;
+    }
+    const existing = [
+        ...existingLayout
+    ];
+    if (operation === 'append') {
+        return [
+            ...existing,
+            ...composedBlocks
+        ];
+    }
+    if (operation === 'prepend') {
+        return [
+            ...composedBlocks,
+            ...existing
+        ];
+    }
+    if (operation === 'insertAt') {
+        if (insertIndex === undefined || insertIndex < 0 || insertIndex > existing.length) {
+            return [
+                ...existing,
+                ...composedBlocks
+            ];
+        }
+        existing.splice(insertIndex, 0, ...composedBlocks);
+        return existing;
+    }
+    if (operation === 'replaceAt') {
+        if (insertIndex === undefined || insertIndex < 0 || insertIndex >= existing.length) {
+            return existing;
+        }
+        existing.splice(insertIndex, composedBlocks.length, ...composedBlocks);
+        return existing;
+    }
+    return composedBlocks;
+}
+function composeSingleSection(section, index, sectionMap, allLeafSlugs) {
+    const sectionSchema = sectionMap.get(section.sectionType);
+    if (!sectionSchema) {
+        return {
+            block: null,
+            errors: [
+                {
+                    sectionIndex: index,
+                    message: `Unknown section type: "${section.sectionType}"`,
+                    validAlternatives: [
+                        ...sectionMap.keys()
+                    ]
+                }
+            ]
+        };
+    }
+    if (sectionSchema.nestingType === 'fixed') {
+        return composeFixedSection(section, index, sectionSchema);
+    }
+    // Detect two-column layout by leftColumn block field
+    const hasDualColumns = sectionSchema.fields.some((f)=>f.name === 'leftColumn' && f.type === 'blocks');
+    if (hasDualColumns) {
+        return composeTwoColumnSection(section, index, sectionSchema, allLeafSlugs);
+    }
+    return composeContentSection(section, index, sectionSchema, allLeafSlugs);
+}
+function composeFixedSection(section, index, schema) {
+    const errors = validateRequiredFields(section.fields ?? {}, schema.fields, index);
+    if (errors.length > 0) return {
+        block: null,
+        errors
+    };
+    return {
+        block: {
+            blockType: schema.slug,
+            ...section.fields ?? {},
+            ...section.config ?? {}
+        },
+        errors: []
+    };
+}
+function composeContentSection(section, index, schema, allLeafSlugs) {
+    const content = section.content ?? [];
+    const errors = validateLeafBlocks(content, schema, index, 'content', allLeafSlugs);
+    if (schema.maxRows && content.length > schema.maxRows) {
+        errors.push({
+            sectionIndex: index,
+            message: `Section "${schema.slug}" allows at most ${schema.maxRows} content block(s), got ${content.length}`
+        });
+    }
+    if (errors.length > 0) return {
+        block: null,
+        errors
+    };
+    const blockFieldName = findBlockFieldName(schema, 'content');
+    const composedLeaves = content.map((leaf)=>({
+            blockType: leaf.blockType,
+            ...leaf.fields ?? {}
+        }));
+    return {
+        block: {
+            blockType: schema.slug,
+            [blockFieldName]: composedLeaves,
+            ...section.config ?? {},
+            ...section.fields ?? {}
+        },
+        errors: []
+    };
+}
+function composeTwoColumnSection(section, index, schema, allLeafSlugs) {
+    const leftColumn = section.leftColumn ?? [];
+    const rightColumn = section.rightColumn ?? [];
+    const errors = [
+        ...validateLeafBlocks(leftColumn, schema, index, 'leftColumn', allLeafSlugs),
+        ...validateLeafBlocks(rightColumn, schema, index, 'rightColumn', allLeafSlugs)
+    ];
+    if (errors.length > 0) return {
+        block: null,
+        errors
+    };
+    return {
+        block: {
+            blockType: schema.slug,
+            leftColumn: leftColumn.map((leaf)=>({
+                    blockType: leaf.blockType,
+                    ...leaf.fields ?? {}
+                })),
+            rightColumn: rightColumn.map((leaf)=>({
+                    blockType: leaf.blockType,
+                    ...leaf.fields ?? {}
+                })),
+            ...section.config ?? {}
+        },
+        errors: []
+    };
+}
+function validateLeafBlocks(leaves, sectionSchema, sectionIndex, columnName, allLeafSlugs) {
+    const errors = [];
+    for(let i = 0; i < leaves.length; i++){
+        const leaf = leaves[i];
+        if (!allLeafSlugs.includes(leaf.blockType)) {
+            errors.push({
+                sectionIndex,
+                message: `Unknown leaf block type "${leaf.blockType}" at ${columnName}[${i}]`,
+                validAlternatives: allLeafSlugs
+            });
+            continue;
+        }
+        if (!sectionSchema.acceptedLeafSlugs.includes(leaf.blockType)) {
+            errors.push({
+                sectionIndex,
+                message: `Leaf block "${leaf.blockType}" is not allowed in section "${sectionSchema.slug}" at ${columnName}[${i}]`,
+                validAlternatives: sectionSchema.acceptedLeafSlugs
+            });
+        }
+    }
+    return errors;
+}
+function validateRequiredFields(values, fieldSchemas, sectionIndex) {
+    const errors = [];
+    for (const field of fieldSchemas){
+        if (!field.required) continue;
+        if ([
+            'id',
+            'blockName',
+            'blockType'
+        ].includes(field.name)) continue;
+        const value = values[field.name];
+        if (value === undefined || value === null || value === '') {
+            errors.push({
+                sectionIndex,
+                message: `Required field "${field.name}" is missing`
+            });
+        }
+    }
+    return errors;
+}
+function findBlockFieldName(schema, defaultName) {
+    const hasDefault = schema.fields.some((f)=>f.name === defaultName && f.type === 'blocks');
+    if (hasDefault) return defaultName;
+    const blocksField = schema.fields.find((f)=>f.type === 'blocks');
+    if (blocksField) return blocksField.name;
+    return defaultName;
+}
+
+//# sourceMappingURL=compose-helpers.js.map

package/dist/tools/compose-helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/tools/compose-helpers.ts"],"sourcesContent":["import { z } from 'zod'\nimport type { BlockCatalog, SectionBlockSchema } from '../types'\n\n/** Schema for a single leaf block within a section */\nexport const leafBlockSchema = z.object({\n  blockType: z.string(),\n  fields: z.record(z.string(), z.unknown()).optional(),\n})\n\n/** Schema for a single section in a layout */\nexport const sectionSchema = z.object({\n  sectionType: z.string(),\n  config: z.record(z.string(), z.unknown()).optional(),\n  /** Leaf blocks for single-content sections */\n  content: z.array(leafBlockSchema).optional(),\n  /** Left column leaf blocks (for two-column sections) */\n  leftColumn: z.array(leafBlockSchema).optional(),\n  /** Right column leaf blocks (for two-column sections) */\n  rightColumn: z.array(leafBlockSchema).optional(),\n  /** Flat field values for fixed sections */\n  fields: z.record(z.string(), z.unknown()).optional(),\n})\n\nexport type LeafBlockInput = z.infer<typeof leafBlockSchema>\nexport type SectionInput = z.infer<typeof sectionSchema>\n\nexport interface ValidationError {\n  sectionIndex: number\n  message: string\n  validAlternatives?: string[]\n}\n\nexport interface ComposeResult {\n  blocks: Record<string, unknown>[]\n  errors: ValidationError[]\n}\n\n/**\n * Validate and compose an array of section inputs into block JSON.\n * Returns either composed blocks or a list of validation errors.\n */\nexport function composeSections(\n  sections: SectionInput[],\n  catalog: BlockCatalog,\n): ComposeResult {\n  const sectionMap = new Map(catalog.sections.map((s) => [s.slug, s]))\n  const allLeafSlugs = catalog.leaves.map((l) => l.slug)\n\n  const blocks: Record<string, unknown>[] = []\n  const errors: ValidationError[] = []\n\n  for (let i = 0; i < sections.length; i++) {\n    const result = composeSingleSection(sections[i], i, sectionMap, allLeafSlugs)\n    if (result.errors.length > 0) {\n      errors.push(...result.errors)\n    } else if (result.block) {\n      blocks.push(result.block)\n    }\n  }\n\n  return { blocks, errors }\n}\n\n/** Build a hint payload describing the available section/leaf vocabulary. */\nexport function buildHint(catalog: BlockCatalog) {\n  return {\n    availableSections: catalog.sections.map((s) => s.slug),\n    availableLeaves: catalog.leaves.map((l) => l.slug),\n    sectionDetails: catalog.sections.map((s) => ({\n      slug: s.slug,\n      nestingType: s.nestingType,\n      acceptedLeaves: s.acceptedLeafSlugs,\n      maxRows: s.maxRows,\n    })),\n  }\n}\n\n/**\n * Apply a list operation against an existing array of blocks.\n * `full` always replaces; the rest preserve the existing array.\n */\nexport function applyOperation(\n  composedBlocks: Record<string, unknown>[],\n  operation: 'full' | 'append' | 'prepend' | 'insertAt' | 'replaceAt',\n  insertIndex: number | undefined,\n  existingLayout: Record<string, unknown>[] | undefined,\n): Record<string, unknown>[] {\n  if (operation === 'full' || !existingLayout) {\n    return composedBlocks\n  }\n\n  const existing = [...existingLayout]\n\n  if (operation === 'append') {\n    return [...existing, ...composedBlocks]\n  }\n\n  if (operation === 'prepend') {\n    return [...composedBlocks, ...existing]\n  }\n\n  if (operation === 'insertAt') {\n    if (insertIndex === undefined || insertIndex < 0 || insertIndex > existing.length) {\n      return [...existing, ...composedBlocks]\n    }\n    existing.splice(insertIndex, 0, ...composedBlocks)\n    return existing\n  }\n\n  if (operation === 'replaceAt') {\n    if (insertIndex === undefined || insertIndex < 0 || insertIndex >= existing.length) {\n      return existing\n    }\n    existing.splice(insertIndex, composedBlocks.length, ...composedBlocks)\n    return existing\n  }\n\n  return composedBlocks\n}\n\n// ─── Internal composition logic ──────────────────────────────────\n\ninterface SingleResult {\n  block: Record<string, unknown> | null\n  errors: ValidationError[]\n}\n\nfunction composeSingleSection(\n  section: SectionInput,\n  index: number,\n  sectionMap: Map<string, SectionBlockSchema>,\n  allLeafSlugs: string[],\n): SingleResult {\n  const sectionSchema = sectionMap.get(section.sectionType)\n\n  if (!sectionSchema) {\n    return {\n      block: null,\n      errors: [\n        {\n          sectionIndex: index,\n          message: `Unknown section type: \"${section.sectionType}\"`,\n          validAlternatives: [...sectionMap.keys()],\n        },\n      ],\n    }\n  }\n\n  if (sectionSchema.nestingType === 'fixed') {\n    return composeFixedSection(section, index, sectionSchema)\n  }\n\n  // Detect two-column layout by leftColumn block field\n  const hasDualColumns = sectionSchema.fields.some(\n    (f) => f.name === 'leftColumn' && f.type === 'blocks',\n  )\n\n  if (hasDualColumns) {\n    return composeTwoColumnSection(section, index, sectionSchema, allLeafSlugs)\n  }\n\n  return composeContentSection(section, index, sectionSchema, allLeafSlugs)\n}\n\nfunction composeFixedSection(\n  section: SectionInput,\n  index: number,\n  schema: SectionBlockSchema,\n): SingleResult {\n  const errors = validateRequiredFields(section.fields ?? {}, schema.fields, index)\n  if (errors.length > 0) return { block: null, errors }\n\n  return {\n    block: {\n      blockType: schema.slug,\n      ...(section.fields ?? {}),\n      ...(section.config ?? {}),\n    },\n    errors: [],\n  }\n}\n\nfunction composeContentSection(\n  section: SectionInput,\n  index: number,\n  schema: SectionBlockSchema,\n  allLeafSlugs: string[],\n): SingleResult {\n  const content = section.content ?? []\n  const errors = validateLeafBlocks(content, schema, index, 'content', allLeafSlugs)\n\n  if (schema.maxRows && content.length > schema.maxRows) {\n    errors.push({\n      sectionIndex: index,\n      message: `Section \"${schema.slug}\" allows at most ${schema.maxRows} content block(s), got ${content.length}`,\n    })\n  }\n\n  if (errors.length > 0) return { block: null, errors }\n\n  const blockFieldName = findBlockFieldName(schema, 'content')\n  const composedLeaves = content.map((leaf) => ({\n    blockType: leaf.blockType,\n    ...(leaf.fields ?? {}),\n  }))\n\n  return {\n    block: {\n      blockType: schema.slug,\n      [blockFieldName]: composedLeaves,\n      ...(section.config ?? {}),\n      ...(section.fields ?? {}),\n    },\n    errors: [],\n  }\n}\n\nfunction composeTwoColumnSection(\n  section: SectionInput,\n  index: number,\n  schema: SectionBlockSchema,\n  allLeafSlugs: string[],\n): SingleResult {\n  const leftColumn = section.leftColumn ?? []\n  const rightColumn = section.rightColumn ?? []\n  const errors: ValidationError[] = [\n    ...validateLeafBlocks(leftColumn, schema, index, 'leftColumn', allLeafSlugs),\n    ...validateLeafBlocks(rightColumn, schema, index, 'rightColumn', allLeafSlugs),\n  ]\n\n  if (errors.length > 0) return { block: null, errors }\n\n  return {\n    block: {\n      blockType: schema.slug,\n      leftColumn: leftColumn.map((leaf) => ({\n        blockType: leaf.blockType,\n        ...(leaf.fields ?? {}),\n      })),\n      rightColumn: rightColumn.map((leaf) => ({\n        blockType: leaf.blockType,\n        ...(leaf.fields ?? {}),\n      })),\n      ...(section.config ?? {}),\n    },\n    errors: [],\n  }\n}\n\nfunction validateLeafBlocks(\n  leaves: LeafBlockInput[],\n  sectionSchema: SectionBlockSchema,\n  sectionIndex: number,\n  columnName: string,\n  allLeafSlugs: string[],\n): ValidationError[] {\n  const errors: ValidationError[] = []\n\n  for (let i = 0; i < leaves.length; i++) {\n    const leaf = leaves[i]\n\n    if (!allLeafSlugs.includes(leaf.blockType)) {\n      errors.push({\n        sectionIndex,\n        message: `Unknown leaf block type \"${leaf.blockType}\" at ${columnName}[${i}]`,\n        validAlternatives: allLeafSlugs,\n      })\n      continue\n    }\n\n    if (!sectionSchema.acceptedLeafSlugs.includes(leaf.blockType)) {\n      errors.push({\n        sectionIndex,\n        message: `Leaf block \"${leaf.blockType}\" is not allowed in section \"${sectionSchema.slug}\" at ${columnName}[${i}]`,\n        validAlternatives: sectionSchema.acceptedLeafSlugs,\n      })\n    }\n  }\n\n  return errors\n}\n\nfunction validateRequiredFields(\n  values: Record<string, unknown>,\n  fieldSchemas: Array<{ name: string; type: string; required?: boolean }>,\n  sectionIndex: number,\n): ValidationError[] {\n  const errors: ValidationError[] = []\n\n  for (const field of fieldSchemas) {\n    if (!field.required) continue\n    if (['id', 'blockName', 'blockType'].includes(field.name)) continue\n\n    const value = values[field.name]\n    if (value === undefined || value === null || value === '') {\n      errors.push({\n        sectionIndex,\n        message: `Required field \"${field.name}\" is missing`,\n      })\n    }\n  }\n\n  return errors\n}\n\nfunction findBlockFieldName(\n  schema: SectionBlockSchema,\n  defaultName: string,\n): string {\n  const hasDefault = schema.fields.some((f) => f.name === defaultName && f.type === 'blocks')\n  if (hasDefault) return defaultName\n\n  const blocksField = schema.fields.find((f) => f.type === 'blocks')\n  if (blocksField) return blocksField.name\n\n  return defaultName\n}\n"],"names":["z","leafBlockSchema","object","blockType","string","fields","record","unknown","optional","sectionSchema","sectionType","config","content","array","leftColumn","rightColumn","composeSections","sections","catalog","sectionMap","Map","map","s","slug","allLeafSlugs","leaves","l","blocks","errors","i","length","result","composeSingleSection","push","block","buildHint","availableSections","availableLeaves","sectionDetails","nestingType","acceptedLeaves","acceptedLeafSlugs","maxRows","applyOperation","composedBlocks","operation","insertIndex","existingLayout","existing","undefined","splice","section","index","get","sectionIndex","message","validAlternatives","keys","composeFixedSection","hasDualColumns","some","f","name","type","composeTwoColumnSection","composeContentSection","schema","validateRequiredFields","validateLeafBlocks","blockFieldName","findBlockFieldName","composedLeaves","leaf","columnName","includes","values","fieldSchemas","field","required","value","defaultName","hasDefault","blocksField","find"],"mappings":"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"}

package/dist/tools/compose-layout.d.ts

@@ -0,0 +1,139 @@
+import { z } from 'zod';
+import type { BlockCatalog } from '../types';
+import { type SectionInput } from './compose-helpers';
+/**
+ * Create the composePageLayout MCP tool from the introspected block catalog.
+ *
+ * Validates and composes a layout array from natural section/leaf inputs.
+ * Returns the composed JSON ready to be written to a doc's `layout` field —
+ * use updateDocument or patchLayout to actually persist the result.
+ */
+export declare function createComposeLayoutTool(catalog: BlockCatalog): {
+    name: string;
+    description: string;
+    parameters: z.ZodObject<{
+        sections: z.ZodArray<z.ZodObject<{
+            sectionType: z.ZodString;
+            config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            content: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                blockType: z.ZodString;
+                fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, "strip", z.ZodTypeAny, {
+                blockType: string;
+                fields?: Record<string, unknown> | undefined;
+            }, {
+                blockType: string;
+                fields?: Record<string, unknown> | undefined;
+            }>, "many">>;
+            leftColumn: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                blockType: z.ZodString;
+                fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, "strip", z.ZodTypeAny, {
+                blockType: string;
+                fields?: Record<string, unknown> | undefined;
+            }, {
+                blockType: string;
+                fields?: Record<string, unknown> | undefined;
+            }>, "many">>;
+            rightColumn: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                blockType: z.ZodString;
+                fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, "strip", z.ZodTypeAny, {
+                blockType: string;
+                fields?: Record<string, unknown> | undefined;
+            }, {
+                blockType: string;
+                fields?: Record<string, unknown> | undefined;
+            }>, "many">>;
+            fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            sectionType: string;
+            fields?: Record<string, unknown> | undefined;
+            config?: Record<string, unknown> | undefined;
+            content?: {
+                blockType: string;
+                fields?: Record<string, unknown> | undefined;
+            }[] | undefined;
+            leftColumn?: {
+                blockType: string;
+                fields?: Record<string, unknown> | undefined;
+            }[] | undefined;
+            rightColumn?: {
+                blockType: string;
+                fields?: Record<string, unknown> | undefined;
+            }[] | undefined;
+        }, {
+            sectionType: string;
+            fields?: Record<string, unknown> | undefined;
+            config?: Record<string, unknown> | undefined;
+            content?: {
+                blockType: string;
+                fields?: Record<string, unknown> | undefined;
+            }[] | undefined;
+            leftColumn?: {
+                blockType: string;
+                fields?: Record<string, unknown> | undefined;
+            }[] | undefined;
+            rightColumn?: {
+                blockType: string;
+                fields?: Record<string, unknown> | undefined;
+            }[] | undefined;
+        }>, "many">;
+        operation: z.ZodDefault<z.ZodOptional<z.ZodEnum<["full", "append", "prepend", "insertAt", "replaceAt"]>>>;
+        insertIndex: z.ZodOptional<z.ZodNumber>;
+        existingLayout: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        sections: {
+            sectionType: string;
+            fields?: Record<string, unknown> | undefined;
+            config?: Record<string, unknown> | undefined;
+            content?: {
+                blockType: string;
+                fields?: Record<string, unknown> | undefined;
+            }[] | undefined;
+            leftColumn?: {
+                blockType: string;
+                fields?: Record<string, unknown> | undefined;
+            }[] | undefined;
+            rightColumn?: {
+                blockType: string;
+                fields?: Record<string, unknown> | undefined;
+            }[] | undefined;
+        }[];
+        operation: "full" | "append" | "prepend" | "insertAt" | "replaceAt";
+        insertIndex?: number | undefined;
+        existingLayout?: Record<string, unknown>[] | undefined;
+    }, {
+        sections: {
+            sectionType: string;
+            fields?: Record<string, unknown> | undefined;
+            config?: Record<string, unknown> | undefined;
+            content?: {
+                blockType: string;
+                fields?: Record<string, unknown> | undefined;
+            }[] | undefined;
+            leftColumn?: {
+                blockType: string;
+                fields?: Record<string, unknown> | undefined;
+            }[] | undefined;
+            rightColumn?: {
+                blockType: string;
+                fields?: Record<string, unknown> | undefined;
+            }[] | undefined;
+        }[];
+        operation?: "full" | "append" | "prepend" | "insertAt" | "replaceAt" | undefined;
+        insertIndex?: number | undefined;
+        existingLayout?: Record<string, unknown>[] | undefined;
+    }>;
+    handler: (args: {
+        sections: SectionInput[];
+        operation?: "full" | "append" | "prepend" | "insertAt" | "replaceAt";
+        insertIndex?: number;
+        existingLayout?: Record<string, unknown>[];
+    }) => Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+};

package/dist/tools/compose-layout.js

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+import { applyOperation, buildHint, composeSections, sectionSchema } from './compose-helpers';
+/**
+ * Create the composePageLayout MCP tool from the introspected block catalog.
+ *
+ * Validates and composes a layout array from natural section/leaf inputs.
+ * Returns the composed JSON ready to be written to a doc's `layout` field —
+ * use updateDocument or patchLayout to actually persist the result.
+ */ export function createComposeLayoutTool(catalog) {
+    const sectionSlugs = catalog.sections.map((s)=>s.slug);
+    const leafSlugs = catalog.leaves.map((l)=>l.slug);
+    return {
+        name: 'composePageLayout',
+        description: 'Compose a page layout from section and leaf blocks. Validates nesting rules and required fields. ' + 'Returns block JSON ready for the Payload page layout field. ' + `Available sections: ${sectionSlugs.join(', ')}. Available leaves: ${leafSlugs.join(', ')}.`,
+        parameters: z.object({
+            sections: z.array(sectionSchema).describe('Array of section blocks to compose into a layout'),
+            operation: z.enum([
+                'full',
+                'append',
+                'prepend',
+                'insertAt',
+                'replaceAt'
+            ]).optional().default('full').describe('How to apply sections: full replace, append, prepend, insertAt, or replaceAt'),
+            insertIndex: z.number().optional().describe('Index for insertAt/replaceAt operations'),
+            existingLayout: z.array(z.record(z.string(), z.unknown())).optional().describe('Current page layout JSON for partial update operations')
+        }),
+        handler: async (args)=>{
+            const { sections, operation = 'full', insertIndex, existingLayout } = args;
+            const { blocks, errors } = composeSections(sections, catalog);
+            if (errors.length > 0) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                errors,
+                                hint: buildHint(catalog)
+                            })
+                        }
+                    ]
+                };
+            }
+            const finalLayout = applyOperation(blocks, operation, insertIndex, existingLayout);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            layout: finalLayout,
+                            blockCount: finalLayout.length
+                        })
+                    }
+                ]
+            };
+        }
+    };
+}
+
+//# sourceMappingURL=compose-layout.js.map

package/dist/tools/compose-layout.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/tools/compose-layout.ts"],"sourcesContent":["import { z } from 'zod'\nimport type { BlockCatalog } from '../types'\nimport {\n  applyOperation,\n  buildHint,\n  composeSections,\n  sectionSchema,\n  type SectionInput,\n} from './compose-helpers'\n\n/**\n * Create the composePageLayout MCP tool from the introspected block catalog.\n *\n * Validates and composes a layout array from natural section/leaf inputs.\n * Returns the composed JSON ready to be written to a doc's `layout` field —\n * use updateDocument or patchLayout to actually persist the result.\n */\nexport function createComposeLayoutTool(catalog: BlockCatalog) {\n  const sectionSlugs = catalog.sections.map((s) => s.slug)\n  const leafSlugs = catalog.leaves.map((l) => l.slug)\n\n  return {\n    name: 'composePageLayout',\n    description:\n      'Compose a page layout from section and leaf blocks. Validates nesting rules and required fields. ' +\n      'Returns block JSON ready for the Payload page layout field. ' +\n      `Available sections: ${sectionSlugs.join(', ')}. Available leaves: ${leafSlugs.join(', ')}.`,\n    parameters: z.object({\n      sections: z\n        .array(sectionSchema)\n        .describe('Array of section blocks to compose into a layout'),\n      operation: z\n        .enum(['full', 'append', 'prepend', 'insertAt', 'replaceAt'])\n        .optional()\n        .default('full')\n        .describe('How to apply sections: full replace, append, prepend, insertAt, or replaceAt'),\n      insertIndex: z\n        .number()\n        .optional()\n        .describe('Index for insertAt/replaceAt operations'),\n      existingLayout: z\n        .array(z.record(z.string(), z.unknown()))\n        .optional()\n        .describe('Current page layout JSON for partial update operations'),\n    }),\n    handler: async (args: {\n      sections: SectionInput[]\n      operation?: 'full' | 'append' | 'prepend' | 'insertAt' | 'replaceAt'\n      insertIndex?: number\n      existingLayout?: Record<string, unknown>[]\n    }) => {\n      const { sections, operation = 'full', insertIndex, existingLayout } = args\n\n      const { blocks, errors } = composeSections(sections, catalog)\n\n      if (errors.length > 0) {\n        return {\n          content: [\n            {\n              type: 'text' as const,\n              text: JSON.stringify({\n                success: false,\n                errors,\n                hint: buildHint(catalog),\n              }),\n            },\n          ],\n        }\n      }\n\n      const finalLayout = applyOperation(blocks, operation, insertIndex, existingLayout)\n\n      return {\n        content: [\n          {\n            type: 'text' as const,\n            text: JSON.stringify({\n              success: true,\n              layout: finalLayout,\n              blockCount: finalLayout.length,\n            }),\n          },\n        ],\n      }\n    },\n  }\n}\n"],"names":["z","applyOperation","buildHint","composeSections","sectionSchema","createComposeLayoutTool","catalog","sectionSlugs","sections","map","s","slug","leafSlugs","leaves","l","name","description","join","parameters","object","array","describe","operation","enum","optional","default","insertIndex","number","existingLayout","record","string","unknown","handler","args","blocks","errors","length","content","type","text","JSON","stringify","success","hint","finalLayout","layout","blockCount"],"mappings":"AAAA,SAASA,CAAC,QAAQ,MAAK;AAEvB,SACEC,cAAc,EACdC,SAAS,EACTC,eAAe,EACfC,aAAa,QAER,oBAAmB;AAE1B;;;;;;CAMC,GACD,OAAO,SAASC,wBAAwBC,OAAqB;IAC3D,MAAMC,eAAeD,QAAQE,QAAQ,CAACC,GAAG,CAAC,CAACC,IAAMA,EAAEC,IAAI;IACvD,MAAMC,YAAYN,QAAQO,MAAM,CAACJ,GAAG,CAAC,CAACK,IAAMA,EAAEH,IAAI;IAElD,OAAO;QACLI,MAAM;QACNC,aACE,sGACA,iEACA,CAAC,oBAAoB,EAAET,aAAaU,IAAI,CAAC,MAAM,oBAAoB,EAAEL,UAAUK,IAAI,CAAC,MAAM,CAAC,CAAC;QAC9FC,YAAYlB,EAAEmB,MAAM,CAAC;YACnBX,UAAUR,EACPoB,KAAK,CAAChB,eACNiB,QAAQ,CAAC;YACZC,WAAWtB,EACRuB,IAAI,CAAC;gBAAC;gBAAQ;gBAAU;gBAAW;gBAAY;aAAY,EAC3DC,QAAQ,GACRC,OAAO,CAAC,QACRJ,QAAQ,CAAC;YACZK,aAAa1B,EACV2B,MAAM,GACNH,QAAQ,GACRH,QAAQ,CAAC;YACZO,gBAAgB5B,EACboB,KAAK,CAACpB,EAAE6B,MAAM,CAAC7B,EAAE8B,MAAM,IAAI9B,EAAE+B,OAAO,KACpCP,QAAQ,GACRH,QAAQ,CAAC;QACd;QACAW,SAAS,OAAOC;YAMd,MAAM,EAAEzB,QAAQ,EAAEc,YAAY,MAAM,EAAEI,WAAW,EAAEE,cAAc,EAAE,GAAGK;YAEtE,MAAM,EAAEC,MAAM,EAAEC,MAAM,EAAE,GAAGhC,gBAAgBK,UAAUF;YAErD,IAAI6B,OAAOC,MAAM,GAAG,GAAG;gBACrB,OAAO;oBACLC,SAAS;wBACP;4BACEC,MAAM;4BACNC,MAAMC,KAAKC,SAAS,CAAC;gCACnBC,SAAS;gCACTP;gCACAQ,MAAMzC,UAAUI;4BAClB;wBACF;qBACD;gBACH;YACF;YAEA,MAAMsC,cAAc3C,eAAeiC,QAAQZ,WAAWI,aAAaE;YAEnE,OAAO;gBACLS,SAAS;oBACP;wBACEC,MAAM;wBACNC,MAAMC,KAAKC,SAAS,CAAC;4BACnBC,SAAS;4BACTG,QAAQD;4BACRE,YAAYF,YAAYR,MAAM;wBAChC;oBACF;iBACD;YACH;QACF;IACF;AACF"}

package/dist/tools/patch-layout.d.ts

@@ -0,0 +1,107 @@
+import { z } from 'zod';
+import type { PayloadRequest } from 'payload';
+import type { BlockCatalog } from '../types';
+import { type SectionInput } from './compose-helpers';
+/**
+ * Creates the patchLayout MCP tool — a surgical wrapper around composePageLayout
+ * that mutates a single document's layout-style field directly, never round-tripping
+ * the entire array through updateDocument.
+ *
+ * Why this exists: prompting an LLM to "add a CTA at the bottom of the home page"
+ * via updateDocument forces it to send the entire layout array, which one bad token
+ * can wipe out. patchLayout fetches the current layout itself, applies a scoped
+ * operation, and writes back — the LLM only ever describes the delta.
+ *
+ * Defaults to layoutField "layout" but accepts any block-array field name.
+ */
+export declare function createPatchLayoutTool(catalog: BlockCatalog, draftCollections: Set<string>): {
+    name: string;
+    description: string;
+    parameters: {
+        collection: z.ZodString;
+        documentId: z.ZodString;
+        layoutField: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        sections: z.ZodArray<z.ZodObject<{
+            sectionType: z.ZodString;
+            config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            content: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                blockType: z.ZodString;
+                fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, "strip", z.ZodTypeAny, {
+                blockType: string;
+                fields?: Record<string, unknown> | undefined;
+            }, {
+                blockType: string;
+                fields?: Record<string, unknown> | undefined;
+            }>, "many">>;
+            leftColumn: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                blockType: z.ZodString;
+                fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, "strip", z.ZodTypeAny, {
+                blockType: string;
+                fields?: Record<string, unknown> | undefined;
+            }, {
+                blockType: string;
+                fields?: Record<string, unknown> | undefined;
+            }>, "many">>;
+            rightColumn: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                blockType: z.ZodString;
+                fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, "strip", z.ZodTypeAny, {
+                blockType: string;
+                fields?: Record<string, unknown> | undefined;
+            }, {
+                blockType: string;
+                fields?: Record<string, unknown> | undefined;
+            }>, "many">>;
+            fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            sectionType: string;
+            fields?: Record<string, unknown> | undefined;
+            config?: Record<string, unknown> | undefined;
+            content?: {
+                blockType: string;
+                fields?: Record<string, unknown> | undefined;
+            }[] | undefined;
+            leftColumn?: {
+                blockType: string;
+                fields?: Record<string, unknown> | undefined;
+            }[] | undefined;
+            rightColumn?: {
+                blockType: string;
+                fields?: Record<string, unknown> | undefined;
+            }[] | undefined;
+        }, {
+            sectionType: string;
+            fields?: Record<string, unknown> | undefined;
+            config?: Record<string, unknown> | undefined;
+            content?: {
+                blockType: string;
+                fields?: Record<string, unknown> | undefined;
+            }[] | undefined;
+            leftColumn?: {
+                blockType: string;
+                fields?: Record<string, unknown> | undefined;
+            }[] | undefined;
+            rightColumn?: {
+                blockType: string;
+                fields?: Record<string, unknown> | undefined;
+            }[] | undefined;
+        }>, "many">;
+        operation: z.ZodEnum<["append", "prepend", "insertAt", "replaceAt", "full"]>;
+        insertIndex: z.ZodOptional<z.ZodNumber>;
+    };
+    handler: (args: {
+        collection: string;
+        documentId: string;
+        layoutField?: string;
+        sections: SectionInput[];
+        operation: "append" | "prepend" | "insertAt" | "replaceAt" | "full";
+        insertIndex?: number;
+    }, req: PayloadRequest, _extra: unknown) => Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+};