@ai-stack/payloadcms 3.76.0-beta.0 → 3.76.0-beta.2

package/dist/endpoints/index.js

@@ -1,617 +1,22 @@
-import * as process from 'node:process';
-import { checkAccess } from '../access/checkAccess.js';
-import { filterEditorSchemaByNodes } from '../ai/utils/filterEditorSchemaByNodes.js';
-import { PLUGIN_AI_JOBS_TABLE, PLUGIN_API_ENDPOINT_GENERATE, PLUGIN_API_ENDPOINT_GENERATE_UPLOAD, PLUGIN_API_ENDPOINT_VIDEOGEN_WEBHOOK, PLUGIN_INSTRUCTIONS_TABLE, PLUGIN_NAME } from '../defaults.js';
-import { registerEditorHelper } from '../libraries/handlebars/helpers.js';
-import { replacePlaceholders } from '../libraries/handlebars/replacePlaceholders.js';
-import { buildSmartPrompt, isGenericPrompt } from '../utilities/buildSmartPrompt.js';
-import { extractImageData } from '../utilities/extractImageData.js';
-import { fetchImages } from '../utilities/fetchImages.js';
-import { fieldToJsonSchema } from '../utilities/fieldToJsonSchema.js';
-import { getFieldBySchemaPath } from '../utilities/getFieldBySchemaPath.js';
-import { resolveImageReferences } from '../utilities/resolveImageReferences.js';
-import { assignPrompt, extendContextWithPromptFields } from './buildPromptUtils.js';
+import { PLUGIN_API_ENDPOINT_GENERATE, PLUGIN_API_ENDPOINT_GENERATE_UPLOAD, PLUGIN_API_ENDPOINT_VIDEOGEN_WEBHOOK } from '../defaults.js';
+import { promptMentionsEndpoint } from './promptMentions.js';
+import { generateHandler } from './generate.js';
+import { uploadHandler } from './upload.js';
+import { videogenWebhookHandler } from './videogenWebhook.js';
 export const endpoints = (pluginConfig)=>({
+        promptMentions: promptMentionsEndpoint,
         textarea: {
-            // Text/rich-text generation endpoint using payload.ai.streamObject
-            handler: async (req)=>{
-                try {
-                    // Check authentication and authorization first
-                    await checkAccess(req, pluginConfig);
-                    const data = await req.json?.();
-                    const { allowedEditorNodes = [], locale = 'en', options } = data;
-                    const { action, actionParams, instructionId } = options;
-                    const contextData = data.doc;
-                    if (!instructionId) {
-                        throw new Error(`Instruction ID is required for "${PLUGIN_NAME}" to work, please check your configuration, or try again`);
-                    }
-                    // Verify user has access to the specific instruction
-                    const instructions = await req.payload.findByID({
-                        id: instructionId,
-                        collection: PLUGIN_INSTRUCTIONS_TABLE,
-                        req
-                    });
-                    const { collections } = req.payload.config;
-                    const collection = collections.find((collection)=>collection.slug === PLUGIN_INSTRUCTIONS_TABLE);
-                    if (!collection) {
-                        throw new Error('Collection not found');
-                    }
-                    const { custom: { [PLUGIN_NAME]: { editorConfig = {} } = {} } = {} } = collection.admin;
-                    const { schema: editorSchema = {} } = editorConfig;
-                    let { prompt: promptTemplate = '' } = instructions;
-                    // Smart fallback: if prompt is generic, build a contextual prompt from field metadata
-                    if (isGenericPrompt(promptTemplate)) {
-                        const schemaPath = String(instructions['schema-path']);
-                        promptTemplate = buildSmartPrompt({
-                            documentData: contextData,
-                            payload: req.payload,
-                            schemaPath
-                        });
-                        if (pluginConfig.debugging) {
-                            req.payload.logger.info({
-                                smartPrompt: promptTemplate
-                            }, `— AI Plugin: Using smart fallback prompt for ${schemaPath}`);
-                        }
-                    }
-                    let allowedEditorSchema = editorSchema;
-                    if (allowedEditorNodes.length) {
-                        allowedEditorSchema = filterEditorSchemaByNodes(editorSchema, allowedEditorNodes);
-                        // Debug: Log what nodes were received and what definitions remain
-                        if (pluginConfig.debugging) {
-                            req.payload.logger.info({
-                                receivedNodes: allowedEditorNodes,
-                                remainingDefinitions: Object.keys(allowedEditorSchema.definitions || {})
-                            }, '— AI Plugin: Schema filtering debug');
-                        }
-                    }
-                    const schemaPath = String(instructions['schema-path']);
-                    const parts = (schemaPath || '').split('.') || [];
-                    const collectionName = parts[0];
-                    const fieldName = parts.length > 1 ? parts[parts.length - 1] : '';
-                    registerEditorHelper(req.payload, schemaPath);
-                    const { defaultLocale, locales = [] } = req.payload.config.localization || {};
-                    const localeData = locales.find((l)=>{
-                        return l.code === locale;
-                    });
-                    let localeInfo = locale;
-                    if (localeData && defaultLocale && localeData.label && typeof localeData.label === 'object' && defaultLocale in localeData.label) {
-                        localeInfo = localeData.label[defaultLocale];
-                    }
-                    const prompts = await assignPrompt(action, {
-                        type: String(instructions['field-type']),
-                        actionParams,
-                        collection: collectionName,
-                        context: contextData,
-                        field: fieldName || '',
-                        layout: instructions.layout,
-                        locale: localeInfo,
-                        pluginConfig,
-                        systemPrompt: instructions.system,
-                        template: String(promptTemplate)
-                    });
-                    if (pluginConfig.debugging) {
-                        req.payload.logger.info({
-                            prompts
-                        }, `— AI Plugin: Executing text prompt on ${schemaPath}`);
-                    }
-                    // Build per-field JSON schema for structured generation when applicable
-                    let jsonSchema = allowedEditorSchema;
-                    let targetField;
-                    try {
-                        const targetCollection = req.payload.config.collections.find((c)=>c.slug === collectionName);
-                        if (targetCollection && fieldName) {
-                            targetField = getFieldBySchemaPath(targetCollection, schemaPath);
-                            const supported = [
-                                'array',
-                                'text',
-                                'textarea',
-                                'select',
-                                'number',
-                                'date',
-                                'code',
-                                'email',
-                                'json'
-                            ];
-                            const t = String(targetField?.type || '');
-                            if (targetField && supported.includes(t)) {
-                                // For array fields, use count from array-settings if available
-                                if (t === 'array') {
-                                    const arraySettings = instructions['array-settings'] || {};
-                                    const count = arraySettings.count || 3;
-                                    // Override the field's maxRows with the requested count
-                                    const modifiedField = {
-                                        ...targetField,
-                                        maxRows: count,
-                                        minRows: count
-                                    };
-                                    jsonSchema = fieldToJsonSchema(modifiedField, {
-                                        nameOverride: fieldName
-                                    });
-                                } else {
-                                    jsonSchema = fieldToJsonSchema(targetField, {
-                                        nameOverride: fieldName
-                                    });
-                                }
-                            }
-                        }
-                    } catch (e) {
-                        req.payload.logger.error(e, '— AI Plugin: Error building field JSON schema');
-                    }
-                    // Get model settings from instruction
-                    const settingsName = instructions['model-id'] === 'richtext' ? 'richtext-settings' : instructions['model-id'] === 'text' ? 'text-settings' : instructions['model-id'] === 'array' ? 'array-settings' : undefined;
-                    if (!settingsName) {
-                        throw new Error(`Unsupported model-id: ${instructions['model-id']}`);
-                    }
-                    const modelSettings = instructions[settingsName] || {};
-                    // Resolve @field:filename references from the prompt
-                    const { images: resolvedImages, processedPrompt } = await resolveImageReferences(prompts.prompt, contextData, req, collectionName);
-                    // Extract hardcoded URLs from the processed prompt
-                    const hardcodedImages = extractImageData(processedPrompt);
-                    // Combine images
-                    const allImages = [
-                        ...hardcodedImages,
-                        ...resolvedImages
-                    ];
-                    let images;
-                    if (allImages.length > 0) {
-                        const imageParts = await fetchImages(req, allImages);
-                        if (imageParts.length > 0) {
-                            images = imageParts;
-                        }
-                    }
-                    let promptToUse = processedPrompt;
-                    let systemToUse = prompts.system;
-                    // let messagesToUse: any = undefined
-                    // Execute beforeGenerate hooks
-                    if (targetField && targetField.custom?.ai?.beforeGenerate) {
-                        const beforeHooks = targetField.custom.ai.beforeGenerate;
-                        for (const hook of beforeHooks){
-                            const result = await hook({
-                                doc: contextData,
-                                field: targetField,
-                                headers: req.headers,
-                                instructions,
-                                payload: req.payload,
-                                prompt: promptToUse,
-                                req,
-                                system: systemToUse
-                            });
-                            if (result) {
-                                if (result.prompt) promptToUse = result.prompt;
-                                if (result.system) systemToUse = result.system;
-                            }
-                        }
-                    }
-                    const streamResult = await req.payload.ai.streamObject({
-                        // extractAttachments: modelSettings.extractAttachments as boolean | undefined,
-                        images,
-                        maxTokens: modelSettings.maxTokens,
-                        // messages: messagesToUse,
-                        model: modelSettings.model,
-                        onFinish: async ({ object })=>{
-                            if (targetField && targetField.custom?.ai?.afterGenerate) {
-                                const afterHooks = targetField.custom.ai.afterGenerate;
-                                for (const hook of afterHooks){
-                                    await hook({
-                                        doc: contextData,
-                                        field: targetField,
-                                        headers: req.headers,
-                                        instructions,
-                                        payload: req.payload,
-                                        req,
-                                        result: object
-                                    });
-                                }
-                            }
-                        },
-                        prompt: processedPrompt,
-                        provider: modelSettings.provider,
-                        providerOptions: {
-                            openai: {
-                                strictJsonSchema: true
-                            }
-                        },
-                        schema: jsonSchema,
-                        system: systemToUse,
-                        temperature: modelSettings.temperature
-                    });
-                    return streamResult;
-                } catch (error) {
-                    req.payload.logger.error(error, 'Error generating content: ');
-                    const message = error && typeof error === 'object' && 'message' in error ? error.message : String(error);
-                    return new Response(JSON.stringify({
-                        error: message
-                    }), {
-                        headers: {
-                            'Content-Type': 'application/json'
-                        },
-                        status: message.includes('Authentication required') || message.includes('Insufficient permissions') ? 401 : 500
-                    });
-                }
-            },
+            handler: generateHandler(pluginConfig),
             method: 'post',
             path: PLUGIN_API_ENDPOINT_GENERATE
         },
         upload: {
-            // Image/video generation endpoint using payload.ai.generateMedia
-            handler: async (req)=>{
-                try {
-                    // Check authentication and authorization first
-                    await checkAccess(req, pluginConfig);
-                    const data = await req.json?.();
-                    const { collectionSlug, documentId, options } = data;
-                    const { instructionId } = options;
-                    let docData = {};
-                    if (documentId) {
-                        try {
-                            docData = await req.payload.findByID({
-                                id: documentId,
-                                collection: collectionSlug,
-                                draft: true,
-                                req
-                            });
-                        } catch (e) {
-                            req.payload.logger.error(e, '— AI Plugin: Error fetching document, you should try again after enabling drafts for this collection');
-                        }
-                    }
-                    const contextData = {
-                        ...data.doc,
-                        ...docData
-                    };
-                    let instructions = {
-                        images: [],
-                        'model-id': '',
-                        prompt: ''
-                    };
-                    if (instructionId) {
-                        // Verify user has access to the specific instruction
-                        instructions = await req.payload.findByID({
-                            id: instructionId,
-                            collection: PLUGIN_INSTRUCTIONS_TABLE,
-                            req
-                        });
-                    }
-                    let { prompt: promptTemplate = '' } = instructions;
-                    const { images: sampleImages = [] } = instructions;
-                    const schemaPath = String(instructions['schema-path']);
-                    registerEditorHelper(req.payload, schemaPath);
-                    // Smart fallback: if prompt is generic, build a contextual prompt from field metadata
-                    if (isGenericPrompt(promptTemplate)) {
-                        promptTemplate = buildSmartPrompt({
-                            documentData: contextData,
-                            payload: req.payload,
-                            schemaPath
-                        });
-                        if (pluginConfig.debugging) {
-                            req.payload.logger.info({
-                                smartPrompt: promptTemplate
-                            }, `— AI Plugin: Using smart fallback prompt for ${schemaPath}`);
-                        }
-                    }
-                    const extendedContext = extendContextWithPromptFields(contextData, {
-                        type: String(instructions['field-type']),
-                        collection: collectionSlug
-                    }, pluginConfig);
-                    const text = await replacePlaceholders(promptTemplate, extendedContext);
-                    const uploadCollectionSlug = instructions['relation-to'];
-                    // Resolve @field:filename references from the prompt
-                    const { images: resolvedImages, processedPrompt } = await resolveImageReferences(text, contextData, req, collectionSlug);
-                    // Extract hardcoded URLs from the processed prompt and merge with resolved images and sample images
-                    const images = [
-                        ...extractImageData(processedPrompt),
-                        ...resolvedImages,
-                        ...sampleImages
-                    ];
-                    // Process images - convert to ImagePart format using helper
-                    const editImages = await fetchImages(req, images);
-                    let promptToUse = text;
-                    let targetField;
-                    try {
-                        const targetCollection = req.payload.config.collections.find((c)=>c.slug === collectionSlug);
-                        if (targetCollection && schemaPath) {
-                            targetField = getFieldBySchemaPath(targetCollection, schemaPath);
-                        }
-                    } catch (e) {
-                        req.payload.logger.error(e, '— AI Plugin: Error finding field for hooks');
-                    }
-                    if (targetField && targetField.custom?.ai?.beforeGenerate) {
-                        const beforeHooks = targetField.custom.ai.beforeGenerate;
-                        for (const hook of beforeHooks){
-                            const result = await hook({
-                                doc: contextData,
-                                field: targetField,
-                                headers: req.headers,
-                                instructions,
-                                payload: req.payload,
-                                prompt: promptToUse,
-                                req
-                            });
-                            if (result) {
-                                if (result.prompt) {
-                                    promptToUse = result.prompt;
-                                }
-                                if (result.instructions) {
-                                    instructions = {
-                                        ...instructions,
-                                        ...result.instructions
-                                    };
-                                }
-                            }
-                        }
-                    }
-                    if (pluginConfig.debugging) {
-                        req.payload.logger.info({
-                            text: promptToUse
-                        }, `— AI Plugin: Executing media generation`);
-                    }
-                    // Prepare callback URL for async jobs
-                    const serverURL = req.payload.config?.serverURL || process.env.SERVER_URL || process.env.NEXT_PUBLIC_SERVER_URL;
-                    const callbackUrl = serverURL ? `${serverURL.replace(/\/$/, '')}/api${PLUGIN_API_ENDPOINT_VIDEOGEN_WEBHOOK}?instructionId=${instructionId}` : undefined;
-                    // Get model settings
-                    // Re-evaluate settings name and settings in case instructions changed
-                    const modelId = instructions['model-id'];
-                    const settingsName = modelId === 'image' ? 'image-settings' : modelId === 'video' ? 'video-settings' : modelId === 'tts' ? 'tts-settings' : undefined;
-                    if (!settingsName) {
-                        throw new Error(`Unsupported model-id: ${modelId}`);
-                    }
-                    // Get model settings from instruction
-                    const instructionSettings = instructions[settingsName] || {};
-                    // Fallback to AISettings global defaults if instruction-level settings are missing
-                    let globalDefaults = {};
-                    if (!instructionSettings.provider || !instructionSettings.model) {
-                        try {
-                            const aiSettings = await req.payload.findGlobal({
-                                slug: 'ai-settings',
-                                context: {
-                                    unsafe: true
-                                }
-                            });
-                            // Map modelId to the corresponding default settings key
-                            const defaultsKey = modelId === 'image' ? 'image' : modelId === 'video' ? 'video' : modelId === 'tts' ? 'tts' : undefined;
-                            if (defaultsKey && aiSettings?.defaults?.[defaultsKey]) {
-                                globalDefaults = aiSettings.defaults[defaultsKey];
-                                if (pluginConfig.debugging) {
-                                    req.payload.logger.info({
-                                        globalDefaults
-                                    }, `— AI Plugin: Using AISettings defaults for ${modelId}`);
-                                }
-                            }
-                        } catch (e) {
-                            req.payload.logger.error(e, '— AI Plugin: Error fetching AISettings defaults');
-                        }
-                    }
-                    // Merge: instruction settings take priority over global defaults
-                    // Filter out null/undefined values so they don't overwrite valid defaults
-                    const filteredInstructionSettings = Object.fromEntries(Object.entries(instructionSettings).filter(([_, v])=>v != null));
-                    const modelSettings = {
-                        ...globalDefaults,
-                        ...filteredInstructionSettings
-                    };
-                    // Use payload.ai.generateMedia directly! 🎉
-                    const result = await req.payload.ai.generateMedia({
-                        callbackUrl,
-                        images: editImages,
-                        instructionId,
-                        model: modelSettings.model,
-                        prompt: promptToUse,
-                        provider: modelSettings.provider,
-                        ...modelSettings
-                    });
-                    if (targetField && targetField.custom?.ai?.afterGenerate) {
-                        const afterHooks = targetField.custom.ai.afterGenerate;
-                        for (const hook of afterHooks){
-                            await hook({
-                                doc: contextData,
-                                field: targetField,
-                                headers: req.headers,
-                                instructions,
-                                payload: req.payload,
-                                req,
-                                result
-                            });
-                        }
-                    }
-                    // If model returned a file immediately, proceed with upload
-                    if (result && 'file' in result) {
-                        let assetData;
-                        if (typeof pluginConfig.mediaUpload === 'function') {
-                            assetData = await pluginConfig.mediaUpload(result, {
-                                collection: uploadCollectionSlug,
-                                request: req
-                            });
-                        } else {
-                            assetData = await req.payload.create({
-                                collection: uploadCollectionSlug,
-                                data: {
-                                    alt: text
-                                },
-                                file: result.file,
-                                req
-                            });
-                        }
-                        if (!assetData.id) {
-                            req.payload.logger.error('Error uploading generated media, is your media upload function correct?');
-                            throw new Error('Error uploading generated media!');
-                        }
-                        return new Response(JSON.stringify({
-                            result: {
-                                id: assetData.id,
-                                alt: assetData.alt
-                            }
-                        }));
-                    }
-                    // Otherwise, assume async job launch
-                    if (result && ('jobId' in result || 'taskId' in result)) {
-                        const externalTaskId = result.jobId || result.taskId;
-                        const status = result.status || 'queued';
-                        const progress = result.progress ?? 0;
-                        // Create AI Job doc and return only its id
-                        const createdJob = await req.payload.create({
-                            collection: PLUGIN_AI_JOBS_TABLE,
-                            data: {
-                                instructionId,
-                                progress,
-                                status,
-                                task_id: externalTaskId
-                            },
-                            overrideAccess: true,
-                            req
-                        });
-                        return new Response(JSON.stringify({
-                            job: {
-                                id: createdJob.id
-                            }
-                        }), {
-                            headers: {
-                                'Content-Type': 'application/json'
-                            }
-                        });
-                    }
-                    throw new Error('Unexpected model response.');
-                } catch (error) {
-                    req.payload.logger.error(// @ts-expect-error
-                    error?.type || error.message, 'Error generating upload: ');
-                    const message = error && typeof error === 'object' && 'message' in error ? error.message : String(error);
-                    return new Response(JSON.stringify({
-                        error: message
-                    }), {
-                        headers: {
-                            'Content-Type': 'application/json'
-                        },
-                        status: message.includes('Authentication required') || message.includes('Insufficient permissions') ? 401 : 500
-                    });
-                }
-            },
+            handler: uploadHandler(pluginConfig),
             method: 'post',
             path: PLUGIN_API_ENDPOINT_GENERATE_UPLOAD
         },
         videogenWebhook: {
-            handler: async (req)=>{
-                console.log('videogenWebhook --> ', req);
-                try {
-                    const urlAll = new URL(req.url || '');
-                    const qpSecret = urlAll.searchParams.get('secret') || '';
-                    const headerSecret = req.headers.get('x-webhook-secret') || '';
-                    const falSecret = process.env.FAL_WEBHOOK_SECRET;
-                    const legacySecret = process.env.VIDEOGEN_WEBHOOK_SECRET;
-                    const provided = qpSecret || headerSecret;
-                    // TODO: fal is failing because of auth but webhook seem to work
-                    if (!provided || (falSecret ? provided !== falSecret : provided !== legacySecret)) {
-                        return new Response('Unauthorized', {
-                            status: 401
-                        });
-                    }
-                    const instructionId = urlAll.searchParams.get('instructionId');
-                    if (!instructionId) {
-                        throw new Error('instructionId missing');
-                    }
-                    const body = await req.json?.();
-                    // Normalize fal webhook payload
-                    const status = body && (body.status || body.data?.status || body.response?.status) || undefined;
-                    const progress = (body && (body.progress ?? body.data?.progress ?? body.response?.progress)) ?? undefined;
-                    const requestId = body && (body.taskId || body.request_id || body.gateway_request_id || body.request?.request_id) || undefined;
-                    const error = body?.error || body?.data?.error || body?.response?.error;
-                    // Update AI Job row by task_id (and instructionId)
-                    const jobSearch = await req.payload.find({
-                        collection: PLUGIN_AI_JOBS_TABLE,
-                        depth: 0,
-                        limit: 1,
-                        where: {
-                            and: [
-                                {
-                                    task_id: {
-                                        equals: requestId
-                                    }
-                                },
-                                {
-                                    instructionId: {
-                                        equals: instructionId
-                                    }
-                                }
-                            ]
-                        }
-                    });
-                    const jobDoc = jobSearch.docs?.[0];
-                    if (jobDoc) {
-                        await req.payload.update({
-                            id: jobDoc.id,
-                            collection: PLUGIN_AI_JOBS_TABLE,
-                            data: {
-                                progress,
-                                status,
-                                task_id: requestId
-                            },
-                            overrideAccess: true,
-                            req
-                        });
-                    }
-                    console.log('fal webhook body: ', body);
-                    const videoUrl = body?.outputs?.[0]?.url || body?.data?.outputs?.[0]?.url || body?.video?.url || body?.data?.video?.url || body?.response?.video?.url || body?.videos?.[0]?.url || body?.data?.videos?.[0]?.url;
-                    if (status === 'completed' && videoUrl) {
-                        // Fetch the related instruction to get upload collection
-                        const instructions = await req.payload.findByID({
-                            id: instructionId,
-                            collection: PLUGIN_INSTRUCTIONS_TABLE,
-                            req
-                        });
-                        const uploadCollectionSlug = instructions['relation-to'];
-                        const videoResp = await fetch(videoUrl);
-                        if (!videoResp.ok) {
-                            throw new Error(`Failed to fetch output: ${videoResp.status}`);
-                        }
-                        const buffer = Buffer.from(await videoResp.arrayBuffer());
-                        const created = await req.payload.create({
-                            collection: uploadCollectionSlug,
-                            data: {
-                                alt: 'video generation'
-                            },
-                            file: {
-                                name: 'video_generation.mp4',
-                                data: buffer,
-                                mimetype: 'video/mp4',
-                                size: buffer.byteLength
-                            },
-                            overrideAccess: true,
-                            req
-                        });
-                        // Persist the result on the AI Job record
-                        if (jobDoc) {
-                            await req.payload.update({
-                                id: jobDoc.id,
-                                collection: PLUGIN_AI_JOBS_TABLE,
-                                data: {
-                                    progress: 100,
-                                    result_id: created?.id,
-                                    status: 'completed'
-                                },
-                                overrideAccess: true,
-                                req
-                            });
-                        }
-                    }
-                    if (status === 'failed' && error) {
-                        req.payload.logger.error(error, 'Video generation failed: ');
-                    }
-                    return new Response(JSON.stringify({
-                        ok: true
-                    }), {
-                        headers: {
-                            'Content-Type': 'application/json'
-                        }
-                    });
-                } catch (error) {
-                    req.payload.logger.error(error, 'Error in videogen webhook: ');
-                    const message = error && typeof error === 'object' && 'message' in error ? error.message : String(error);
-                    return new Response(JSON.stringify({
-                        error: message
-                    }), {
-                        headers: {
-                            'Content-Type': 'application/json'
-                        },
-                        status: 500
-                    });
-                }
-            },
+            handler: videogenWebhookHandler,
             method: 'post',
             path: PLUGIN_API_ENDPOINT_VIDEOGEN_WEBHOOK
         }