@mvriu5/payload-ai 1.6.2 → 1.6.4

package/dist/handlers/chat/proposalTools.js

@@ -0,0 +1,451 @@
+import { getOptionValue, getSafeProposalLabel, hasValueAtPath, isRecord, setValueAtPath } from "../../utils/data.js";
+export const getRequiredFieldInfos = (fields, titleFieldName, path = "")=>{
+    return fields.flatMap((field)=>{
+        const fieldPath = field.name ? path ? `${path}.${field.name}` : field.name : path;
+        const requiredField = field.required && fieldPath ? [
+            {
+                defaultValue: field.defaultValue,
+                isTitleField: field.name === titleFieldName,
+                localized: Boolean(field.localized),
+                options: field.options,
+                path: fieldPath,
+                type: field.type
+            }
+        ] : [];
+        const nestedFields = field.fields?.length ? getRequiredFieldInfos(field.fields, titleFieldName, fieldPath) : [];
+        const nestedBlocks = field.blocks?.length ? field.blocks.flatMap((block)=>getRequiredFieldInfos(block.fields || [], titleFieldName, `${fieldPath}.${block.slug}`)) : [];
+        return [
+            ...requiredField,
+            ...nestedFields,
+            ...nestedBlocks
+        ];
+    });
+};
+const getCreateFallbackValue = ({ field, label })=>{
+    if (field.defaultValue !== undefined) return field.defaultValue;
+    if (field.path === "_status") return "draft";
+    if (field.type === "checkbox") return false;
+    if (field.type === "select" || field.type === "radio") {
+        return getOptionValue(field.options?.[0]);
+    }
+    const terminalSegment = field.path.split(".").at(-1)?.toLowerCase();
+    if ((field.isTitleField || [
+        "title",
+        "name",
+        "label",
+        "headline"
+    ].includes(terminalSegment || "")) && [
+        "text",
+        "textarea"
+    ].includes(field.type || "")) {
+        return getSafeProposalLabel(label);
+    }
+    return undefined;
+};
+export const fillMissingCreateFields = ({ data, label, localizedData, requiredFields })=>{
+    if (localizedData) {
+        const completedLocalizedData = Object.fromEntries(Object.entries(localizedData).map(([locale, localeData])=>[
+                locale,
+                {
+                    ...localeData
+                }
+            ]));
+        const localeEntries = Object.entries(completedLocalizedData);
+        const [firstLocale, firstLocaleData] = localeEntries[0] || [];
+        for (const [locale, localeData] of localeEntries){
+            for (const field of requiredFields.filter((item)=>item.localized)){
+                if (hasValueAtPath(localeData, field.path)) continue;
+                const fallbackValue = getCreateFallbackValue({
+                    field,
+                    label
+                });
+                if (fallbackValue !== undefined) {
+                    setValueAtPath(localeData, field.path, fallbackValue);
+                }
+            }
+        }
+        if (firstLocale && firstLocaleData) {
+            for (const field of requiredFields.filter((item)=>!item.localized)){
+                if (hasValueAtPath(firstLocaleData, field.path)) continue;
+                const fallbackValue = getCreateFallbackValue({
+                    field,
+                    label
+                });
+                if (fallbackValue !== undefined) {
+                    setValueAtPath(firstLocaleData, field.path, fallbackValue);
+                }
+            }
+        }
+        return {
+            localizedData: completedLocalizedData
+        };
+    }
+    const completedData = {
+        ...data || {}
+    };
+    for (const field of requiredFields){
+        if (hasValueAtPath(completedData, field.path)) continue;
+        const fallbackValue = getCreateFallbackValue({
+            field,
+            label
+        });
+        if (fallbackValue !== undefined) {
+            setValueAtPath(completedData, field.path, fallbackValue);
+        }
+    }
+    return {
+        data: completedData
+    };
+};
+export const getMissingCreateFields = ({ data, localizedData, requiredFields })=>{
+    if (localizedData) {
+        const locales = Object.entries(localizedData);
+        const firstLocale = locales[0];
+        if (!firstLocale) {
+            return [
+                "localizedData must include at least one locale entry"
+            ];
+        }
+        const missing = [];
+        const localizedRequiredFields = [];
+        const sharedRequiredFields = [];
+        for (const field of requiredFields){
+            if (field.localized) {
+                localizedRequiredFields.push(field);
+            } else {
+                sharedRequiredFields.push(field);
+            }
+        }
+        for (const [locale, localeData] of locales){
+            for (const field of localizedRequiredFields){
+                if (!hasValueAtPath(localeData, field.path)) {
+                    missing.push(`${locale}:${field.path}`);
+                }
+            }
+        }
+        for (const field of sharedRequiredFields){
+            if (!hasValueAtPath(firstLocale[1], field.path)) {
+                missing.push(`${firstLocale[0]}:${field.path}`);
+            }
+        }
+        return missing;
+    }
+    if (!data) return [
+        "data is required"
+    ];
+    return requiredFields.flatMap((field)=>hasValueAtPath(data, field.path) ? [] : [
+            field.path
+        ]);
+};
+export const getProposalSummary = (proposal)=>({
+        action: proposal.action,
+        collection: "collection" in proposal ? proposal.collection : undefined,
+        hasData: "data" in proposal && Boolean(proposal.data),
+        hasLocalizedData: "localizedData" in proposal && Boolean(proposal.localizedData),
+        id: "id" in proposal ? proposal.id : undefined,
+        label: proposal.label,
+        locale: proposal.locale,
+        locales: "localizedData" in proposal && proposal.localizedData ? Object.keys(proposal.localizedData) : undefined,
+        slug: "slug" in proposal ? proposal.slug : undefined
+    });
+export const getCollectionBlockTypes = (fields)=>{
+    const blockTypes = new Set();
+    const visitFields = (items)=>{
+        for (const field of items){
+            if (field.type === "blocks" && field.blocks) {
+                for (const block of field.blocks){
+                    blockTypes.add(block.slug);
+                    if (block.fields?.length) {
+                        visitFields(block.fields);
+                    }
+                }
+            }
+            if (field.fields?.length) {
+                visitFields(field.fields);
+            }
+        }
+    };
+    visitFields(fields);
+    return [
+        ...blockTypes
+    ];
+};
+const regexSpecialCharactersPattern = /[.*+?^${}()|[\]\\]/g;
+export const getRequestedBlockTypes = ({ availableBlockTypes, mentions, prompt })=>{
+    const requestedBlockTypes = new Set();
+    const normalizedPrompt = prompt.toLowerCase();
+    const availableBlockTypeSet = new Set(availableBlockTypes);
+    const blockTypesByNormalizedSlug = new Map(availableBlockTypes.map((blockType)=>[
+            blockType.toLowerCase(),
+            blockType
+        ]));
+    const escapedBlockTypes = availableBlockTypes.map((blockType)=>blockType.replace(regexSpecialCharactersPattern, "\\$&")).join("|");
+    const blockPattern = escapedBlockTypes ? new RegExp(`\\b(${escapedBlockTypes})\\b(?:\\s+block)?`, "gi") : null;
+    for (const mention of mentions || []){
+        if (mention.type === "block" && mention.slug && availableBlockTypeSet.has(mention.slug)) {
+            requestedBlockTypes.add(mention.slug);
+        }
+    }
+    if (blockPattern) {
+        for (const match of normalizedPrompt.matchAll(blockPattern)){
+            const blockType = match[1] ? blockTypesByNormalizedSlug.get(match[1].toLowerCase()) : null;
+            if (blockType) {
+                requestedBlockTypes.add(blockType);
+            }
+        }
+    }
+    return [
+        ...requestedBlockTypes
+    ];
+};
+export const collectProposalBlockTypes = ({ data, fields })=>{
+    const foundBlockTypes = new Set();
+    const visitFields = (items, value)=>{
+        for (const field of items){
+            if (!field.name) continue;
+            const fieldValue = value[field.name];
+            if (fieldValue === undefined || fieldValue === null) continue;
+            if (field.type === "blocks" && Array.isArray(fieldValue)) {
+                const blocksBySlug = new Map(field.blocks?.map((block)=>[
+                        block.slug,
+                        block
+                    ]));
+                for (const blockItem of fieldValue){
+                    if (!isRecord(blockItem)) continue;
+                    const blockType = typeof blockItem.blockType === "string" ? blockItem.blockType : typeof blockItem.type === "string" ? blockItem.type : typeof blockItem.slug === "string" ? blockItem.slug : null;
+                    if (blockType) {
+                        foundBlockTypes.add(blockType);
+                    }
+                    if (blockType) {
+                        const blockConfig = blocksBySlug.get(blockType);
+                        if (blockConfig?.fields?.length) {
+                            visitFields(blockConfig.fields, blockItem);
+                        }
+                    }
+                }
+                continue;
+            }
+            if (field.type === "group" && isRecord(fieldValue) && field.fields?.length) {
+                visitFields(field.fields, fieldValue);
+                continue;
+            }
+            if (field.type === "array" && Array.isArray(fieldValue) && field.fields?.length) {
+                for (const item of fieldValue){
+                    if (isRecord(item)) {
+                        visitFields(field.fields, item);
+                    }
+                }
+            }
+        }
+    };
+    visitFields(fields, data);
+    return foundBlockTypes;
+};
+const collectRelationshipTargets = ({ data, fields, path = "" })=>{
+    const targets = [];
+    for (const field of fields){
+        if (!field.name) continue;
+        const fieldPath = path ? `${path}.${field.name}` : field.name;
+        const fieldValue = data[field.name];
+        if (fieldValue === undefined || fieldValue === null) continue;
+        if (field.type === "relationship" || field.type === "upload") {
+            const relationTargets = Array.isArray(field.relationTo) ? field.relationTo.filter((item)=>typeof item === "string") : typeof field.relationTo === "string" ? [
+                field.relationTo
+            ] : [];
+            const collectSingle = (value, itemPath)=>{
+                if (typeof value === "string" || typeof value === "number") {
+                    if (relationTargets.length === 1) {
+                        targets.push({
+                            collection: relationTargets[0],
+                            id: value,
+                            path: itemPath
+                        });
+                    }
+                    return;
+                }
+                if (!isRecord(value)) return;
+                const relationTo = typeof value.relationTo === "string" ? value.relationTo : relationTargets[0];
+                const id = typeof value.id === "string" || typeof value.id === "number" ? value.id : typeof value.value === "string" || typeof value.value === "number" ? value.value : undefined;
+                if (!relationTo || id === undefined) return;
+                targets.push({
+                    collection: relationTo,
+                    id,
+                    path: itemPath
+                });
+            };
+            if (field.hasMany && Array.isArray(fieldValue)) {
+                fieldValue.forEach((item, index)=>collectSingle(item, `${fieldPath}.${index}`));
+            } else {
+                collectSingle(fieldValue, fieldPath);
+            }
+            continue;
+        }
+        if (field.type === "group" && isRecord(fieldValue) && field.fields?.length) {
+            targets.push(...collectRelationshipTargets({
+                data: fieldValue,
+                fields: field.fields,
+                path: fieldPath
+            }));
+            continue;
+        }
+        if (field.type === "array" && Array.isArray(fieldValue) && field.fields?.length) {
+            fieldValue.forEach((item, index)=>{
+                if (!isRecord(item)) return;
+                targets.push(...collectRelationshipTargets({
+                    data: item,
+                    fields: field.fields,
+                    path: `${fieldPath}.${index}`
+                }));
+            });
+            continue;
+        }
+        if (field.type === "blocks" && Array.isArray(fieldValue) && field.blocks?.length) {
+            const blocksBySlug = new Map(field.blocks.map((block)=>[
+                    block.slug,
+                    block
+                ]));
+            fieldValue.forEach((item, index)=>{
+                if (!isRecord(item)) return;
+                const blockType = typeof item.blockType === "string" ? item.blockType : typeof item.type === "string" ? item.type : typeof item.slug === "string" ? item.slug : null;
+                if (!blockType) return;
+                const blockConfig = blocksBySlug.get(blockType);
+                if (!blockConfig?.fields?.length) return;
+                targets.push(...collectRelationshipTargets({
+                    data: item,
+                    fields: blockConfig.fields,
+                    path: `${fieldPath}.${index}`
+                }));
+            });
+        }
+    }
+    return targets;
+};
+const collectUploadTargets = ({ data, fields, path = "" })=>{
+    const targets = [];
+    for (const field of fields){
+        if (!field.name) continue;
+        const fieldPath = path ? `${path}.${field.name}` : field.name;
+        const fieldValue = data[field.name];
+        if (fieldValue === undefined || fieldValue === null) continue;
+        if (field.type === "upload") {
+            const relationTargets = Array.isArray(field.relationTo) ? field.relationTo.filter((item)=>typeof item === "string") : typeof field.relationTo === "string" ? [
+                field.relationTo
+            ] : [];
+            const collectSingle = (value, itemPath)=>{
+                if (typeof value === "string" || typeof value === "number") {
+                    if (relationTargets.length === 1) {
+                        targets.push({
+                            collection: relationTargets[0],
+                            id: value,
+                            path: itemPath
+                        });
+                    }
+                    return;
+                }
+                if (!isRecord(value)) return;
+                const relationTo = typeof value.relationTo === "string" ? value.relationTo : relationTargets[0];
+                const id = typeof value.id === "string" || typeof value.id === "number" ? value.id : typeof value.value === "string" || typeof value.value === "number" ? value.value : undefined;
+                if (!relationTo || id === undefined) return;
+                targets.push({
+                    collection: relationTo,
+                    id,
+                    path: itemPath
+                });
+            };
+            if (field.hasMany && Array.isArray(fieldValue)) {
+                fieldValue.forEach((item, index)=>collectSingle(item, `${fieldPath}.${index}`));
+            } else {
+                collectSingle(fieldValue, fieldPath);
+            }
+            continue;
+        }
+        if (field.type === "group" && isRecord(fieldValue) && field.fields?.length) {
+            targets.push(...collectUploadTargets({
+                data: fieldValue,
+                fields: field.fields,
+                path: fieldPath
+            }));
+            continue;
+        }
+        if (field.type === "array" && Array.isArray(fieldValue) && field.fields?.length) {
+            fieldValue.forEach((item, index)=>{
+                if (!isRecord(item)) return;
+                targets.push(...collectUploadTargets({
+                    data: item,
+                    fields: field.fields,
+                    path: `${fieldPath}.${index}`
+                }));
+            });
+            continue;
+        }
+        if (field.type === "blocks" && Array.isArray(fieldValue) && field.blocks?.length) {
+            const blocksBySlug = new Map(field.blocks.map((block)=>[
+                    block.slug,
+                    block
+                ]));
+            fieldValue.forEach((item, index)=>{
+                if (!isRecord(item)) return;
+                const blockType = typeof item.blockType === "string" ? item.blockType : typeof item.type === "string" ? item.type : typeof item.slug === "string" ? item.slug : null;
+                if (!blockType) return;
+                const blockConfig = blocksBySlug.get(blockType);
+                if (!blockConfig?.fields?.length) return;
+                targets.push(...collectUploadTargets({
+                    data: item,
+                    fields: blockConfig.fields,
+                    path: `${fieldPath}.${index}`
+                }));
+            });
+        }
+    }
+    return targets;
+};
+export const validateRelationshipTargetsExist = async ({ data, fields, req })=>{
+    const targets = collectRelationshipTargets({
+        data,
+        fields
+    });
+    const targetResults = await Promise.all(targets.map(async (target)=>{
+        try {
+            await req.payload.findByID({
+                collection: target.collection,
+                depth: 0,
+                id: String(target.id),
+                overrideAccess: false,
+                req
+            });
+            return null;
+        } catch  {
+            return target;
+        }
+    }));
+    return targetResults.filter((target)=>Boolean(target));
+};
+export const getUploadTargetsOutsideAttachments = ({ allowedAttachmentKeys, data, fields })=>{
+    if (allowedAttachmentKeys.size === 0) return [];
+    return collectUploadTargets({
+        data,
+        fields
+    }).filter((target)=>!allowedAttachmentKeys.has(`${target.collection}:${String(target.id)}`));
+};
+export const validateProposalReferences = async ({ allowedAttachmentKeys, data, fields, localizedData, priority, req })=>{
+    const records = [
+        ...data ? [
+            data
+        ] : [],
+        ...Object.values(localizedData || {})
+    ];
+    const uploadTargetsOutsideAttachments = records.flatMap((record)=>getUploadTargetsOutsideAttachments({
+            allowedAttachmentKeys,
+            data: record,
+            fields
+        }));
+    const invalidRelationshipTargets = priority === "attachments" && uploadTargetsOutsideAttachments.length > 0 ? [] : (await Promise.all(records.map((record)=>validateRelationshipTargetsExist({
+            data: record,
+            fields,
+            req
+        })))).flat();
+    return {
+        invalidRelationshipTargets,
+        uploadTargetsOutsideAttachments
+    };
+};

package/dist/handlers/chat/streaming.d.ts

@@ -0,0 +1,38 @@
+import type { ChatDebug, TokenUsage, ToolFailure } from "./types.js";
+type ChatDebugPayload = {
+    activeLocale?: string;
+    model: string;
+    proposalCount: number;
+    provider: string;
+    reason: "model_did_not_call_tool" | "proposal_created" | "tool_validation_failed" | "write_intent_without_tool_call";
+    selectedLocales: string[];
+    toolFailures: ToolFailure[];
+    usage?: TokenUsage | null;
+};
+export declare const createInitialChatDebug: ({ model, provider }: {
+    model: string;
+    provider: string;
+}) => ChatDebug;
+export declare const createSSEEventStream: (events: Array<{
+    data: unknown;
+    event: string;
+}>) => ReadableStream<Uint8Array<ArrayBufferLike>>;
+export declare const getChatCompletionReason: ({ proposalCount, toolFailures, writeIntent, }: {
+    proposalCount: number;
+    toolFailures: ToolFailure[];
+    writeIntent: boolean;
+}) => "model_did_not_call_tool" | "proposal_created" | "tool_validation_failed" | "write_intent_without_tool_call";
+export declare const createDebugPayload: ({ activeLocale, debug, proposalCount, selectedLocales, toolFailures, usage, writeIntent, }: {
+    activeLocale?: string;
+    debug: ChatDebug;
+    proposalCount: number;
+    selectedLocales: string[];
+    toolFailures: ToolFailure[];
+    usage?: TokenUsage | null;
+    writeIntent: boolean;
+}) => ChatDebugPayload;
+export declare const createE2EChatResponse: ({ prompt, selectedLocales }: {
+    prompt: string;
+    selectedLocales: string[];
+}) => Response;
+export {};

package/dist/handlers/chat/streaming.js

@@ -0,0 +1,136 @@
+import { signAIActionProposal } from "../../features/proposals/signing.js";
+export const createInitialChatDebug = ({ model, provider })=>({
+        model,
+        provider,
+        tools: [
+            "getDoc",
+            "getGlobal",
+            "listCollections",
+            "listGlobals",
+            "proposeCreateDoc",
+            "proposeDeleteDoc",
+            "proposeUpdateDoc",
+            "proposeUpdateGlobal",
+            "searchDocs"
+        ]
+    });
+export const createSSEEventStream = (events)=>{
+    const encoder = new TextEncoder();
+    return new ReadableStream({
+        start (controller) {
+            for (const { data, event } of events){
+                controller.enqueue(encoder.encode(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`));
+            }
+            controller.close();
+        }
+    });
+};
+export const getChatCompletionReason = ({ proposalCount, toolFailures, writeIntent })=>{
+    if (proposalCount > 0) return "proposal_created";
+    if (toolFailures.length > 0) return "tool_validation_failed";
+    if (writeIntent) return "write_intent_without_tool_call";
+    return "model_did_not_call_tool";
+};
+export const createDebugPayload = ({ activeLocale, debug, proposalCount, selectedLocales, toolFailures, usage, writeIntent })=>({
+        activeLocale,
+        model: debug.model,
+        proposalCount,
+        provider: debug.provider,
+        reason: getChatCompletionReason({
+            proposalCount,
+            toolFailures,
+            writeIntent
+        }),
+        selectedLocales,
+        toolFailures,
+        usage
+    });
+export const createE2EChatResponse = ({ prompt, selectedLocales })=>{
+    const normalizedPrompt = prompt.toLowerCase();
+    const wantsCreatePost = normalizedPrompt.includes("post") && (normalizedPrompt.includes("create") || normalizedPrompt.includes("erstell") || normalizedPrompt.includes("apply flow") || normalizedPrompt.includes("locale review") || normalizedPrompt.includes("proposal review"));
+    const mentionsMars = normalizedPrompt.includes("mars");
+    const multipleLocales = selectedLocales.length > 1;
+    const activeLocale = selectedLocales.at(-1);
+    const proposalLabel = multipleLocales ? normalizedPrompt.includes("locale review") ? "Create localized locale review draft post about Mars" : "Create localized draft post about Mars" : normalizedPrompt.includes("apply flow") ? "Create apply flow draft post about Mars" : normalizedPrompt.includes("proposal review") ? "Create proposal review draft post about Mars" : "Create draft post about Mars";
+    const proposal = wantsCreatePost && mentionsMars ? signAIActionProposal(multipleLocales ? {
+        action: "create",
+        collection: "posts",
+        label: proposalLabel,
+        localizedData: Object.fromEntries(selectedLocales.map((locale)=>[
+                locale,
+                {
+                    content: locale === "de" ? "Mars ist der vierte Planet von der Sonne." : "Mars is the fourth planet from the Sun.",
+                    excerpt: locale === "de" ? "Ein kurzer Entwurf ueber Mars." : "A short draft about Mars.",
+                    title: locale === "de" ? "Mars im Ueberblick" : "Mars Overview"
+                }
+            ])),
+        ...activeLocale ? {
+            locale: activeLocale
+        } : {}
+    } : {
+        action: "create",
+        collection: "posts",
+        data: {
+            content: "Mars is the fourth planet from the Sun.",
+            excerpt: "A short draft about Mars.",
+            status: "draft",
+            title: "Mars Overview"
+        },
+        label: proposalLabel,
+        ...activeLocale ? {
+            locale: activeLocale
+        } : {}
+    }) : null;
+    const responseText = proposal ? "Prepared one draft post proposal." : "No content change was proposed.";
+    const debugPayload = createDebugPayload({
+        debug: {
+            model: "e2e-model",
+            provider: "openai",
+            tools: []
+        },
+        proposalCount: proposal ? 1 : 0,
+        selectedLocales,
+        toolFailures: [],
+        usage: {
+            inputTokens: 42,
+            outputTokens: 27,
+            totalTokens: 69
+        },
+        writeIntent: wantsCreatePost
+    });
+    return new Response(createSSEEventStream([
+        {
+            data: {
+                delta: responseText
+            },
+            event: "text"
+        },
+        {
+            data: {
+                proposals: proposal ? [
+                    proposal
+                ] : [],
+                usage: {
+                    inputTokens: 42,
+                    outputTokens: 27,
+                    totalTokens: 69
+                }
+            },
+            event: "proposals"
+        },
+        {
+            data: debugPayload,
+            event: "debug"
+        },
+        {
+            data: {},
+            event: "done"
+        }
+    ]), {
+        headers: {
+            "Cache-Control": "no-cache, no-transform",
+            Connection: "keep-alive",
+            "Content-Type": "text/event-stream; charset=utf-8"
+        }
+    });
+};