@simmalugnt-se/payload-editor-assistant 0.6.0 → 0.8.0

package/dist/form/diff.js

@@ -1,5 +1,6 @@
 import { isLexical, lexicalPlaintext } from "./lexical.js";
 import { getAtPath, parseFieldPath } from "./path.js";
+import { richTextDiff } from "./rich-text.js";
 const COPY = {
     en: {
         empty: "empty",
@@ -12,6 +13,9 @@ const COPY = {
         removeBlock: (n, field) => `Remove block ${n} from ${field}`,
         moveBlock: (from, to) => `Move block ${from} to ${to}`,
         replaceBlock: (n, block) => `Replace block ${n} with ${block}`,
+        part: (field, n) => `${field}, part ${n}`,
+        addPart: (field, n) => `${field}, new part ${n}`,
+        removePart: (field, n) => `${field}, part ${n} removed`,
         unknown: "Unknown change",
     },
     sv: {
@@ -25,20 +29,31 @@ const COPY = {
         removeBlock: (n, field) => `Ta bort block ${n} från ${field}`,
         moveBlock: (from, to) => `Flytta block ${from} till ${to}`,
         replaceBlock: (n, block) => `Ersätt block ${n} med ${block}`,
+        part: (field, n) => `${field}, del ${n}`,
+        addPart: (field, n) => `${field}, ny del ${n}`,
+        removePart: (field, n) => `${field}, del ${n} tas bort`,
         unknown: "Okänd ändring",
     },
 };
 const HEADER_PREVIEW = 80;
 const FIELD_PREVIEW = 300;
-export function humanDiff(current, operations, language = "en") {
+/**
+ * `labels` names related documents by id (see `labelRelations`), so a chosen image reads as its
+ * filename or alt text instead of an id. Rich text is listed by `richTextLines` instead.
+ */
+export function humanDiff(current, operations, language = "en", labels) {
     const copy = COPY[language];
+    const named = (value) => {
+        const id = typeof value === "string" || typeof value === "number" ? String(value) : undefined;
+        return id !== undefined && labels?.has(id) ? labels.get(id) : value;
+    };
     return operations.map((operation) => {
         switch (operation.op) {
             case "set": {
                 const before = getAtPath(current, parseFieldPath(operation.path));
                 return {
                     path: operation.path,
-                    text: `${label(operation.path)}: ${preview(before, copy)} → ${preview(operation.value, copy)}`,
+                    text: `${label(operation.path)}: ${preview(named(before), copy)} → ${preview(named(operation.value), copy)}`,
                 };
             }
             case "unset":
@@ -85,6 +100,33 @@ export function humanDiff(current, operations, language = "en") {
         }
     });
 }
+/**
+ * The parts of a rich text field that changed: `before` as the model read it (Markdown blocks),
+ * `after` as compiled, where `{ keep: i }` is block `i` unchanged.
+ */
+export function richTextLines(path, before, after, language = "en") {
+    const copy = COPY[language];
+    const field = label(path);
+    const part = (block) => typeof block === "string"
+        ? preview(block, copy, FIELD_PREVIEW)
+        : `[${block.type ?? "?"}]`;
+    return richTextDiff(before, after).map((change) => {
+        switch (change.kind) {
+            case "changed":
+                return {
+                    path,
+                    text: `${copy.part(field, change.index + 1)}: ${part(change.before)} → ${part(change.after)}`,
+                };
+            case "added":
+                return { path, text: `${copy.addPart(field, change.index + 1)}: ${part(change.after)}` };
+            default:
+                return {
+                    path,
+                    text: `${copy.removePart(field, change.index + 1)}: ${part(change.before)}`,
+                };
+        }
+    });
+}
 /** Sub-lines are indented two spaces; the approval panel nests them under the header. */
 export const DIFF_SUBLINE_INDENT = "  ";
 function withFields(header, value, copy) {

package/dist/form/rich-text.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Rich text for the model: Lexical editor state becomes a list of Markdown blocks, one per top-level
+ * node, and back. Payload's own converters do the work, with each field's own editor config, so the
+ * model can only write what the field allows. `{ keep: i }` stands for stored block `i` as it is:
+ * the model sends it for every block it leaves alone, and gets it for what Markdown cannot say
+ * (uploads, relationships, custom blocks), which it may move or drop but never create or change.
+ * A kept block, or one sent back unchanged, reuses the stored node exactly, keeping alignment,
+ * indent and styles.
+ *
+ * `@payloadcms/richtext-lexical` is an optional peer: without it, rich text stays as it was (plain
+ * text in, paragraphs out). Call `loadRichText` before converting.
+ */
+export type KeptBlock = {
+    keep: number;
+    type?: string;
+};
+export type RichTextBlock = string | KeptBlock;
+export type RichTextLink = {
+    collection: string;
+    id: string;
+};
+type LexicalNode = Record<string, unknown> & {
+    type?: unknown;
+    children?: unknown;
+};
+type LexicalState = {
+    root: Record<string, unknown> & {
+        children: LexicalNode[];
+    };
+};
+/** Loads Payload's converters once; false when `@payloadcms/richtext-lexical` is not installed. */
+export declare function loadRichText(): Promise<boolean>;
+export declare function isLexicalState(value: unknown): value is LexicalState;
+export declare function isRichTextBlocks(value: unknown): value is RichTextBlock[];
+/**
+ * The model's view of stored rich text, or null when it cannot be converted (no converters, no
+ * editor config). An empty field is `""`, so it reads as an empty text to fill.
+ */
+export declare function toBlocks(value: unknown, editor: unknown): RichTextBlock[] | "" | null;
+/**
+ * Rich text from what the model sent: blocks (see `toBlocks`) or a Markdown string. `original` is
+ * the stored value the blocks were made from. `links` are the internal links in rebuilt blocks, to
+ * check against the editor's access; links in reused blocks were there already.
+ */
+export declare function fromBlocks(value: RichTextBlock[] | string, original: unknown, editor: unknown): {
+    ok: true;
+    state: LexicalState;
+    links: RichTextLink[];
+} | {
+    ok: false;
+    error: string;
+};
+export type BlockChange = {
+    kind: "changed";
+    index: number;
+    before: RichTextBlock;
+    after: RichTextBlock;
+} | {
+    kind: "added";
+    index: number;
+    after: RichTextBlock;
+} | {
+    kind: "removed";
+    index: number;
+    before: RichTextBlock;
+};
+/**
+ * Which blocks changed between two block lists, by position in the new list for added and changed
+ * blocks and in the old list for removed ones. A removal next to an addition reads as a change.
+ */
+export declare function richTextDiff(before: unknown[], sent: unknown[]): BlockChange[];
+export {};

package/dist/form/rich-text.js

@@ -0,0 +1,254 @@
+/**
+ * Rich text for the model: Lexical editor state becomes a list of Markdown blocks, one per top-level
+ * node, and back. Payload's own converters do the work, with each field's own editor config, so the
+ * model can only write what the field allows. `{ keep: i }` stands for stored block `i` as it is:
+ * the model sends it for every block it leaves alone, and gets it for what Markdown cannot say
+ * (uploads, relationships, custom blocks), which it may move or drop but never create or change.
+ * A kept block, or one sent back unchanged, reuses the stored node exactly, keeping alignment,
+ * indent and styles.
+ *
+ * `@payloadcms/richtext-lexical` is an optional peer: without it, rich text stays as it was (plain
+ * text in, paragraphs out). Call `loadRichText` before converting.
+ */
+/** Top-level nodes whose Markdown round trip keeps them as they are. */
+const MARKDOWN_NODES = new Set(["paragraph", "heading", "list", "quote", "horizontalrule"]);
+/** Inline nodes Markdown can carry; a block holding anything else is kept whole. */
+const MARKDOWN_INLINE = new Set(["text", "link", "autolink", "linebreak", "tab", "listitem"]);
+/** How the model writes an internal link: `[text](doc:pages/12)`. */
+const DOC_LINK = /^doc:([\w-]+)\/(.+)$/;
+/**
+ * Payload's Markdown export drops unknown URL schemes, so internal links leave as this address and
+ * become `doc:` in the Markdown. Its import keeps `doc:` as written.
+ */
+const DOC_EXPORT = "https://doc.invalid/";
+let converters;
+/** Loads Payload's converters once; false when `@payloadcms/richtext-lexical` is not installed. */
+export async function loadRichText() {
+    if (converters === undefined) {
+        try {
+            const lexical = await import("@payloadcms/richtext-lexical");
+            converters = {
+                toMarkdown: lexical.convertLexicalToMarkdown,
+                toLexical: lexical.convertMarkdownToLexical,
+            };
+        }
+        catch {
+            converters = null;
+        }
+    }
+    return converters !== null;
+}
+export function isLexicalState(value) {
+    const root = value?.root;
+    return Boolean(root && typeof root === "object" && Array.isArray(root.children));
+}
+export function isRichTextBlocks(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string" || isKept(item));
+}
+/**
+ * The model's view of stored rich text, or null when it cannot be converted (no converters, no
+ * editor config). An empty field is `""`, so it reads as an empty text to fill.
+ */
+export function toBlocks(value, editor) {
+    const editorConfig = editorConfigOf(editor);
+    if (!converters || !editorConfig || !isLexicalState(value)) {
+        return null;
+    }
+    const blocks = value.root.children.map((node, index) => canWrite(node)
+        ? nodeMarkdown(node, value.root, editorConfig)
+        : { keep: index, type: String(node.type ?? "node") });
+    const empty = blocks.every((block) => block === "");
+    return empty ? "" : blocks;
+}
+/**
+ * Rich text from what the model sent: blocks (see `toBlocks`) or a Markdown string. `original` is
+ * the stored value the blocks were made from. `links` are the internal links in rebuilt blocks, to
+ * check against the editor's access; links in reused blocks were there already.
+ */
+export function fromBlocks(value, original, editor) {
+    const editorConfig = editorConfigOf(editor);
+    if (!converters || !editorConfig) {
+        return { ok: false, error: "Rich text cannot be converted here." };
+    }
+    const stored = isLexicalState(original) ? original : undefined;
+    const storedBlocks = stored ? (toBlocks(stored, editor) ?? []) : [];
+    const blocks = typeof value === "string" ? [value] : value;
+    if (typeof value === "string" && Array.isArray(storedBlocks) && storedBlocks.some(isKept)) {
+        return {
+            ok: false,
+            error: "This rich text holds parts plain text would drop. Send it as a list of blocks, with { keep: i } for each block you leave as it is.",
+        };
+    }
+    const children = [];
+    const used = new Set();
+    const links = [];
+    const allowed = linkCollections(editorConfig);
+    for (const block of blocks) {
+        if (isKept(block)) {
+            const node = stored?.root.children[block.keep];
+            if (!node || used.has(block.keep)) {
+                return {
+                    ok: false,
+                    error: `{ keep: ${block.keep} } is not a block of this rich text, or appears twice.`,
+                };
+            }
+            used.add(block.keep);
+            children.push(node);
+            continue;
+        }
+        const reused = Array.isArray(storedBlocks)
+            ? storedBlocks.findIndex((entry, index) => entry === block && !used.has(index))
+            : -1;
+        const storedNode = reused >= 0 ? stored?.root.children[reused] : undefined;
+        if (storedNode) {
+            used.add(reused);
+            children.push(storedNode);
+            continue;
+        }
+        if (!block.trim()) {
+            continue;
+        }
+        const converted = converters.toLexical({ markdown: block, editorConfig });
+        const nodes = isLexicalState(converted) ? converted.root.children : [];
+        for (const node of nodes) {
+            const error = internalLinks(node, allowed, links);
+            if (error) {
+                return { ok: false, error };
+            }
+            children.push(node);
+        }
+    }
+    const root = stored?.root ?? {
+        type: "root",
+        format: "",
+        indent: 0,
+        version: 1,
+        direction: "ltr",
+    };
+    return { ok: true, state: { root: { ...root, children } }, links };
+}
+/**
+ * Which blocks changed between two block lists, by position in the new list for added and changed
+ * blocks and in the old list for removed ones. A removal next to an addition reads as a change.
+ */
+export function richTextDiff(before, sent) {
+    // { keep: i } in what the model sent stands for block i as it was.
+    const after = sent.map((block) => (isKept(block) ? (before[block.keep] ?? block) : block));
+    const key = (block) => (typeof block === "string" ? block : JSON.stringify(block));
+    const a = before.map(key);
+    const b = after.map(key);
+    // Longest common subsequence, small enough for the blocks of one field.
+    const lengths = Array.from({ length: a.length + 1 }, () => new Array(b.length + 1).fill(0));
+    for (let i = a.length - 1; i >= 0; i--) {
+        for (let j = b.length - 1; j >= 0; j--) {
+            lengths[i][j] =
+                a[i] === b[j] ? lengths[i + 1][j + 1] + 1 : Math.max(lengths[i + 1][j], lengths[i][j + 1]);
+        }
+    }
+    const changes = [];
+    let i = 0;
+    let j = 0;
+    while (i < a.length || j < b.length) {
+        if (i < a.length && j < b.length && a[i] === b[j]) {
+            i++;
+            j++;
+        }
+        else if (i < a.length &&
+            j < b.length &&
+            lengths[i + 1][j] === lengths[i][j + 1] &&
+            lengths[i + 1][j + 1] === lengths[i][j]) {
+            changes.push({
+                kind: "changed",
+                index: j,
+                before: before[i],
+                after: after[j],
+            });
+            i++;
+            j++;
+        }
+        else if (j < b.length && (i >= a.length || lengths[i][j + 1] >= lengths[i + 1][j])) {
+            changes.push({ kind: "added", index: j, after: after[j] });
+            j++;
+        }
+        else {
+            changes.push({ kind: "removed", index: i, before: before[i] });
+            i++;
+        }
+    }
+    return changes;
+}
+function canWrite(node) {
+    if (!MARKDOWN_NODES.has(String(node.type))) {
+        return false;
+    }
+    const inline = (child) => {
+        const record = child;
+        return (MARKDOWN_INLINE.has(String(record?.type)) &&
+            (!Array.isArray(record.children) || record.children.every(inline)));
+    };
+    return !Array.isArray(node.children) || node.children.every(inline);
+}
+/** One top-level node as Markdown, with internal links written as `doc:` links. */
+function nodeMarkdown(node, root, editorConfig) {
+    const data = { root: { ...root, children: [withDocLinks(node)] } };
+    const markdown = converters?.toMarkdown({ data, editorConfig }).trim() ?? "";
+    return markdown.replaceAll(`](${DOC_EXPORT}`, "](doc:");
+}
+function withDocLinks(node) {
+    const fields = node.fields;
+    const next = { ...node };
+    if (node.type === "link" && fields?.linkType === "internal") {
+        const doc = fields.doc;
+        const id = doc?.value && typeof doc.value === "object" ? doc.value.id : doc?.value;
+        next.fields = {
+            ...fields,
+            linkType: "custom",
+            url: `${DOC_EXPORT}${String(doc?.relationTo)}/${String(id)}`,
+        };
+    }
+    if (Array.isArray(node.children)) {
+        next.children = node.children.map((child) => withDocLinks(child));
+    }
+    return next;
+}
+/** Turns `doc:` links into Payload's internal links, collecting them; an error names the rule. */
+function internalLinks(node, allowed, into) {
+    const fields = node.fields;
+    const match = node.type === "link" && typeof fields?.url === "string" ? DOC_LINK.exec(fields.url) : null;
+    if (match) {
+        const [, collection = "", id = ""] = match;
+        // Without enabledCollections, Payload lets links point at any collection; access decides.
+        if (allowed && !allowed.includes(collection)) {
+            return allowed.length
+                ? `Links in this text can only point at ${allowed.join(", ")}.`
+                : "Links in this text cannot point at documents.";
+        }
+        node.fields = {
+            linkType: "internal",
+            doc: { relationTo: collection, value: /^\d+$/.test(id) ? Number(id) : id },
+            newTab: fields?.newTab === true,
+        };
+        into.push({ collection, id });
+    }
+    for (const child of Array.isArray(node.children) ? node.children : []) {
+        const error = internalLinks(child, allowed, into);
+        if (error) {
+            return error;
+        }
+    }
+    return undefined;
+}
+function linkCollections(editorConfig) {
+    const features = editorConfig
+        .resolvedFeatureMap;
+    const link = features?.get("link");
+    const enabled = link?.sanitizedServerFeatureProps?.enabledCollections;
+    return Array.isArray(enabled) ? enabled.filter((slug) => typeof slug === "string") : undefined;
+}
+function editorConfigOf(editor) {
+    return editor?.editorConfig;
+}
+function isKept(value) {
+    const record = value;
+    return Boolean(record && typeof record === "object" && Number.isInteger(record.keep));
+}

package/dist/form/shape.d.ts

@@ -1,11 +1,20 @@
 import type { FieldNode } from "../schema/fields.ts";
+import { type RichTextLink } from "./rich-text.ts";
 /**
- * Make compiled data safe to store: plain text in rich text fields becomes editor state,
- * then every block must be typed. Mutates `data`.
+ * A copy of `data` where each rich text field the converters can read is a list of `{ keep: i }`,
+ * one per stored block, so operations can set, insert or remove single blocks (`layout.1.content.2`)
+ * while every other block stays exactly as it was. `finalizeCompiled` turns the lists back.
  */
-export declare function finalizeCompiled(data: Record<string, unknown>, fields: FieldNode[]): {
+export declare function openRichText(data: Record<string, unknown>, fields: FieldNode[]): Record<string, unknown>;
+/**
+ * Make compiled data safe to store: rich text written as Markdown blocks or text becomes editor
+ * state, reusing what `original` (the form before the change) held, then every block must be
+ * typed. Mutates `data`. `links` are internal links in rewritten rich text, to check for access.
+ */
+export declare function finalizeCompiled(data: Record<string, unknown>, fields: FieldNode[], original?: Record<string, unknown>): {
     ok: true;
     data: Record<string, unknown>;
+    links: RichTextLink[];
 } | {
     ok: false;
     error: string;

package/dist/form/shape.js

@@ -1,11 +1,48 @@
+import { fromBlocks, isLexicalState, isRichTextBlocks, toBlocks, } from "./rich-text.js";
 /**
- * Make compiled data safe to store: plain text in rich text fields becomes editor state,
- * then every block must be typed. Mutates `data`.
+ * A copy of `data` where each rich text field the converters can read is a list of `{ keep: i }`,
+ * one per stored block, so operations can set, insert or remove single blocks (`layout.1.content.2`)
+ * while every other block stays exactly as it was. `finalizeCompiled` turns the lists back.
  */
-export function finalizeCompiled(data, fields) {
-    coerceRichText(data, fields);
+export function openRichText(data, fields) {
+    const opened = { ...data };
+    for (const field of fields) {
+        const value = data[field.name];
+        if (field.type === "richText" &&
+            isLexicalState(value) &&
+            toBlocks(value, field.editor) !== null) {
+            opened[field.name] = value.root.children.map((_, index) => ({ keep: index }));
+        }
+        else if (field.type === "blocks" && Array.isArray(value)) {
+            opened[field.name] = value.map((item) => {
+                const block = isRecord(item)
+                    ? field.blocks?.find((entry) => entry.slug === item.blockType)
+                    : undefined;
+                return block && isRecord(item) ? openRichText(item, block.fields) : item;
+            });
+        }
+        else if (field.fields && Array.isArray(value)) {
+            opened[field.name] = value.map((item) => isRecord(item) ? openRichText(item, field.fields ?? []) : item);
+        }
+        else if (field.fields && isRecord(value)) {
+            opened[field.name] = openRichText(value, field.fields);
+        }
+    }
+    return opened;
+}
+/**
+ * Make compiled data safe to store: rich text written as Markdown blocks or text becomes editor
+ * state, reusing what `original` (the form before the change) held, then every block must be
+ * typed. Mutates `data`. `links` are internal links in rewritten rich text, to check for access.
+ */
+export function finalizeCompiled(data, fields, original) {
+    const links = [];
+    const richTextError = coerceRichText(data, fields, original, links, "");
+    if (richTextError) {
+        return { ok: false, error: richTextError };
+    }
     const error = blockShapeError(data, fields);
-    return error ? { ok: false, error } : { ok: true, data };
+    return error ? { ok: false, error } : { ok: true, data, links };
 }
 /**
  * Check that every blocks field in compiled data holds typed blocks the schema knows.
@@ -68,33 +105,75 @@ function checkField(field, value, path) {
     }
     return isRecord(value) ? checkFields(value, field.fields, path) : null;
 }
-function coerceRichText(data, fields) {
+function coerceRichText(data, fields, original, links, prefix) {
     for (const field of fields) {
         const value = data[field.name];
-        if (field.type === "richText" && typeof value === "string") {
-            data[field.name] = plainTextToLexical(value);
+        const before = original?.[field.name];
+        const path = prefix ? `${prefix}.${field.name}` : field.name;
+        if (field.type === "richText" && Array.isArray(value) && !isRichTextBlocks(value)) {
+            return `"${path}" must be a list of Markdown strings and { keep: i } entries.`;
+        }
+        if (field.type === "richText" && (typeof value === "string" || isRichTextBlocks(value))) {
+            if (typeof value === "string" && !field.editor) {
+                data[field.name] = plainTextToLexical(value);
+                continue;
+            }
+            const converted = fromBlocks(value, before, field.editor);
+            if (!converted.ok) {
+                // Without the converters, text still becomes plain paragraphs as before.
+                if (typeof value === "string") {
+                    data[field.name] = plainTextToLexical(value);
+                    continue;
+                }
+                return `"${path}": ${converted.error}`;
+            }
+            data[field.name] = converted.state;
+            links.push(...converted.links);
         }
         else if (field.type === "blocks" && Array.isArray(value)) {
-            for (const item of value) {
+            for (const [index, item] of value.entries()) {
                 const block = isRecord(item)
                     ? field.blocks?.find((entry) => entry.slug === item.blockType)
                     : undefined;
                 if (block && isRecord(item)) {
-                    coerceRichText(item, block.fields);
+                    const error = coerceRichText(item, block.fields, sameRow(before, item, index), links, `${path}.${index}`);
+                    if (error)
+                        return error;
                 }
             }
         }
         else if (field.fields && Array.isArray(value)) {
-            for (const item of value) {
+            for (const [index, item] of value.entries()) {
                 if (isRecord(item)) {
-                    coerceRichText(item, field.fields);
+                    const error = coerceRichText(item, field.fields, sameRow(before, item, index), links, `${path}.${index}`);
+                    if (error)
+                        return error;
                 }
             }
         }
         else if (field.fields && isRecord(value)) {
-            coerceRichText(value, field.fields);
+            const error = coerceRichText(value, field.fields, isRecord(before) ? before : undefined, links, path);
+            if (error)
+                return error;
         }
     }
+    return null;
+}
+/**
+ * The row of `rows` that `item` was: by id, since rows move. Rows without ids (data not from a
+ * form) fall back to the same position with the same block type.
+ */
+function sameRow(rows, item, index) {
+    if (!Array.isArray(rows)) {
+        return undefined;
+    }
+    const row = item.id === undefined
+        ? rows[index]
+        : rows.find((entry) => isRecord(entry) && entry.id === item.id);
+    if (!isRecord(row) || (item.id === undefined && row.id !== undefined)) {
+        return undefined;
+    }
+    return row.blockType === item.blockType ? row : undefined;
 }
 /** Minimal Lexical editor state: one paragraph per blank-line-separated chunk. */
 export function plainTextToLexical(text) {

package/dist/runtime/agent.js

@@ -1,3 +1,4 @@
+import { loadRichText } from "../form/rich-text.js";
 import { PACKAGE_NAME } from "../package-name.js";
 import { loadTurnContext } from "./context.js";
 import { needsProposeRetry } from "./propose-loop.js";
@@ -18,6 +19,8 @@ const STEP_FOR_TOOL = {
     "admin.navigate": "navigating",
 };
 export async function runAgentTurn(req, options, input) {
+    // Rich text reaches the model as Markdown blocks when Payload's converters are installed.
+    await loadRichText();
     const result = await generateTurn(req, options, input);
     if (!result.ok || result.pendingApproval?.capability !== "form.propose") {
         return result;
@@ -230,7 +233,7 @@ function buildSdkTools(ai, ctx, captured, previews, emit) {
                         step: executed.ok && executed.pendingApproval ? "writing" : "thinking",
                     });
                     // The image goes to the model through toModelOutput; Admin never needs the bytes.
-                    captured.push(outcome.ok ? { ...outcome, image: undefined } : outcome);
+                    captured.push(outcome.ok ? { ...outcome, images: undefined } : outcome);
                     return outcome;
                 }
                 catch {

package/dist/runtime/context.d.ts

@@ -1,25 +1,28 @@
 import type { PayloadRequest } from "payload";
 import type { ValidatedEditorAssistantOptions } from "../config/validate.ts";
+import { type DiscoveredEntity } from "../schema/discover.ts";
 import type { AdminView } from "../view.ts";
 import { type Selection } from "./selection.ts";
 import { type ToolBridge } from "./tools.ts";
+/** A field as the model sees it; uploads and relations say which collection they point at. */
+type CompactField = {
+    name: string;
+    type: string;
+    required?: boolean;
+    relationTo?: string[];
+};
 export type TurnContext = {
     allowlist: Array<{
         kind: "collection" | "global";
         slug: string;
         label?: string;
         capabilities: string[];
-        fields: Array<{
-            name: string;
-            type: string;
-            required?: boolean;
+        fields: Array<CompactField & {
+            /** A group's fields, one level down (`meta.image`). */
+            fields?: CompactField[];
             blocks?: Array<{
                 slug: string;
-                fields: Array<{
-                    name: string;
-                    type: string;
-                    required?: boolean;
-                }>;
+                fields: CompactField[];
             }>;
         }>;
     }>;
@@ -38,3 +41,5 @@ export type TurnContext = {
     documents: Record<string, unknown>[];
 };
 export declare function loadTurnContext(req: PayloadRequest, options: ValidatedEditorAssistantOptions, bridge: ToolBridge, formData?: Record<string, unknown>): Promise<TurnContext>;
+export declare function compactEntity(entity: DiscoveredEntity): TurnContext["allowlist"][number];
+export {};

package/dist/runtime/context.js

@@ -76,24 +76,27 @@ async function readOtherLanguages(req, options, bridge) {
     }
     return Object.keys(otherLanguages).length > 0 ? otherLanguages : undefined;
 }
-function compactEntity(entity) {
+export function compactEntity(entity) {
     return {
         kind: entity.kind,
         slug: entity.slug,
         label: entity.label,
         capabilities: entity.capabilities,
         fields: entity.fields.map((field) => ({
-            name: field.name,
-            type: field.type,
-            required: field.required || undefined,
+            ...compactField(field),
             blocks: field.blocks?.map((block) => ({
                 slug: block.slug,
-                fields: block.fields.map((child) => ({
-                    name: child.name,
-                    type: child.type,
-                    required: child.required || undefined,
-                })),
+                fields: block.fields.map(compactField),
             })),
+            ...(field.type === "group" ? { fields: field.fields?.map(compactField) } : {}),
         })),
     };
 }
+function compactField(field) {
+    return {
+        name: field.name,
+        type: field.type,
+        required: field.required || undefined,
+        relationTo: field.type === "upload" || field.type === "relationship" ? field.relationTo : undefined,
+    };
+}