@mvriu5/payload-ai 1.2.0 → 1.4.0

package/dist/handlers/mediaUploadHandler.d.ts

@@ -0,0 +1,7 @@
+import { type PayloadHandler } from "payload";
+export type MediaUploadOptions = {
+    acceptedMimeTypes?: string[];
+    collectionSlug: string;
+    maxFileSize?: number;
+};
+export declare const createMediaUploadHandler: ({ acceptedMimeTypes, collectionSlug, maxFileSize }: MediaUploadOptions) => PayloadHandler;

package/dist/handlers/mediaUploadHandler.js

@@ -0,0 +1,99 @@
+import { addDataAndFileToRequest } from "payload";
+import { getNumber, getString, isRecord } from "../payload/shared.js";
+const mimeTypeMatches = (mimeType, acceptedMimeType)=>{
+    if (acceptedMimeType === mimeType) return true;
+    if (!acceptedMimeType.endsWith("/*")) return false;
+    return mimeType.startsWith(`${acceptedMimeType.slice(0, -2)}/`);
+};
+const isAcceptedMimeType = (mimeType, acceptedMimeTypes)=>{
+    if (!acceptedMimeTypes || acceptedMimeTypes.length === 0) return true;
+    return acceptedMimeTypes.some((acceptedMimeType)=>mimeTypeMatches(mimeType, acceptedMimeType));
+};
+const getUploadData = (data)=>{
+    if (!isRecord(data)) return {};
+    const { collection: _collection, file: _file, ...uploadData } = data;
+    return uploadData;
+};
+const getMediaAttachment = ({ collectionSlug, doc, file })=>{
+    const record = isRecord(doc) ? doc : {};
+    const id = record.id;
+    return {
+        collection: collectionSlug,
+        filename: getString(record.filename) || file.name || "",
+        filesize: getNumber(record.filesize) || file.size || 0,
+        id: typeof id === "string" || typeof id === "number" ? String(id) : "",
+        mimeType: getString(record.mimeType) || file.mimetype || "",
+        type: "media",
+        url: getString(record.url)
+    };
+};
+export const createMediaUploadHandler = ({ acceptedMimeTypes, collectionSlug, maxFileSize })=>async (req)=>{
+        const uploadReq = req;
+        try {
+            await addDataAndFileToRequest(uploadReq);
+            const collectionConfig = uploadReq.payload.config.collections.find((collection)=>collection.slug === collectionSlug);
+            if (!collectionConfig) {
+                return Response.json({
+                    error: `Upload collection not found: ${collectionSlug}`
+                }, {
+                    status: 400
+                });
+            }
+            if (!collectionConfig.upload) {
+                return Response.json({
+                    error: `Collection is not upload-enabled: ${collectionSlug}`
+                }, {
+                    status: 400
+                });
+            }
+            const file = uploadReq.file;
+            if (!file) {
+                return Response.json({
+                    error: "File is required"
+                }, {
+                    status: 400
+                });
+            }
+            const fileSize = typeof file.size === "number" && Number.isFinite(file.size) ? file.size : 0;
+            if (maxFileSize && fileSize > maxFileSize) {
+                return Response.json({
+                    error: `File exceeds max size of ${maxFileSize} bytes`
+                }, {
+                    status: 413
+                });
+            }
+            const mimeType = file.mimetype || "";
+            if (mimeType && !isAcceptedMimeType(mimeType, acceptedMimeTypes)) {
+                return Response.json({
+                    error: `File type is not accepted: ${mimeType}`
+                }, {
+                    status: 415
+                });
+            }
+            const doc = await uploadReq.payload.create({
+                collection: collectionSlug,
+                data: getUploadData(uploadReq.data),
+                file: file,
+                overrideAccess: false,
+                req: uploadReq
+            });
+            return Response.json({
+                attachment: getMediaAttachment({
+                    collectionSlug,
+                    doc,
+                    file
+                }),
+                doc
+            });
+        } catch (err) {
+            uploadReq.payload.logger.error({
+                err,
+                msg: "AI media upload failed"
+            });
+            return Response.json({
+                error: "Media upload failed."
+            }, {
+                status: 500
+            });
+        }
+    };

package/dist/handlers/mentionSuggestionHandler.js

@@ -61,16 +61,13 @@ export const createMentionSuggestionHandler = (options = {})=>async (req)=>{
                 type: "doc"
             });
         };
-        for (const collection of collections){
-            if (suggestions.length >= 5) break;
+        const searchResults = await Promise.all(collections.flatMap((collection)=>{
             const collectionFields = collection.fields;
             const localeCodes = query && hasLocalizedFields(collectionFields) ? getLocaleCodes(req) : [];
             const localesToSearch = localeCodes.length > 0 ? localeCodes : [
                 null
             ];
-            for (const locale of localesToSearch){
-                if (suggestions.length >= 5) break;
-                const result = await req.payload.find({
+            return localesToSearch.map((locale)=>req.payload.find({
                     collection: collection.slug,
                     depth: 0,
                     limit: query ? 100 : 10,
@@ -79,16 +76,21 @@ export const createMentionSuggestionHandler = (options = {})=>async (req)=>{
                     } : {},
                     overrideAccess: false,
                     req
+                }).then((result)=>({
+                        collection,
+                        result
+                    })));
+        }));
+        for (const { collection, result } of searchResults){
+            if (suggestions.length >= 5) break;
+            for (const doc of result.docs){
+                if (suggestions.length >= 5) break;
+                addSuggestion({
+                    collectionSlug: collection.slug,
+                    doc,
+                    requireLabelMatch: Boolean(normalizedQuery),
+                    useAsTitle: collection.admin?.useAsTitle
                 });
-                for (const doc of result.docs){
-                    if (suggestions.length >= 5) break;
-                    addSuggestion({
-                        collectionSlug: collection.slug,
-                        doc,
-                        requireLabelMatch: Boolean(normalizedQuery),
-                        useAsTitle: collection.admin?.useAsTitle
-                    });
-                }
             }
         }
         return Response.json({

package/dist/handlers/proposalDiffHandler.js

@@ -69,7 +69,7 @@ export const createProposalDiffHandler = (options = {})=>async (req)=>{
                         req,
                         slug: proposal.slug
                     }) : null;
-                    for (const [locale, localeData] of Object.entries(preparedData.localizedData)){
+                    const localizedResults = await Promise.all(Object.entries(preparedData.localizedData).map(async ([locale, localeData])=>{
                         const doc = await req.payload.findGlobal({
                             depth: 2,
                             fallbackLocale: false,
@@ -83,9 +83,16 @@ export const createProposalDiffHandler = (options = {})=>async (req)=>{
                             fields: globalFields,
                             preparedData: localeData
                         });
+                        return {
+                            completedData,
+                            doc,
+                            locale
+                        };
+                    }));
+                    localizedResults.forEach(({ completedData, doc, locale })=>{
                         beforeByLocale[locale] = redactSensitiveData(doc);
                         afterByLocale[locale] = redactSensitiveData(mergeData(doc, completedData));
-                    }
+                    });
                     return Response.json({
                         after: afterByLocale,
                         before: beforeByLocale
@@ -177,38 +184,43 @@ export const createProposalDiffHandler = (options = {})=>async (req)=>{
                     req
                 }) : null;
                 let createFallbackSource = null;
-                for (const [locale, localeData] of Object.entries(preparedData.localizedData)){
-                    const fallbackSource = proposal.action === "create" ? createFallbackSource || {} : locale === defaultLocale ? await req.payload.findByID({
-                        collection: proposal.collection,
-                        depth: 2,
-                        fallbackLocale: false,
-                        id: proposal.id,
-                        locale,
-                        overrideAccess: false,
-                        req
-                    }) : defaultLocaleDoc || {};
-                    const completedData = applyLocalizedRequiredFallbackToPreparedData({
-                        fallbackSource,
-                        fields: collectionFields,
-                        preparedData: localeData
-                    });
-                    if (proposal.action === "create") {
+                if (proposal.action === "create") {
+                    for (const [locale, localeData] of Object.entries(preparedData.localizedData)){
+                        const completedData = applyLocalizedRequiredFallbackToPreparedData({
+                            fallbackSource: createFallbackSource || {},
+                            fields: collectionFields,
+                            preparedData: localeData
+                        });
                         beforeByLocale[locale] = {};
                         afterByLocale[locale] = redactSensitiveData(completedData);
                         createFallbackSource = mergeData(createFallbackSource || {}, completedData);
-                        continue;
                     }
-                    const doc = await req.payload.findByID({
-                        collection: proposal.collection,
-                        depth: 2,
-                        fallbackLocale: false,
-                        id: proposal.id,
-                        locale,
-                        overrideAccess: false,
-                        req
+                } else {
+                    const localizedResults = await Promise.all(Object.entries(preparedData.localizedData).map(async ([locale, localeData])=>{
+                        const doc = await req.payload.findByID({
+                            collection: proposal.collection,
+                            depth: 2,
+                            fallbackLocale: false,
+                            id: proposal.id,
+                            locale,
+                            overrideAccess: false,
+                            req
+                        });
+                        const completedData = applyLocalizedRequiredFallbackToPreparedData({
+                            fallbackSource: locale === defaultLocale ? doc : defaultLocaleDoc || {},
+                            fields: collectionFields,
+                            preparedData: localeData
+                        });
+                        return {
+                            completedData,
+                            doc,
+                            locale
+                        };
+                    }));
+                    localizedResults.forEach(({ completedData, doc, locale })=>{
+                        beforeByLocale[locale] = redactSensitiveData(doc);
+                        afterByLocale[locale] = redactSensitiveData(mergeData(doc, completedData));
                     });
-                    beforeByLocale[locale] = redactSensitiveData(doc);
-                    afterByLocale[locale] = redactSensitiveData(mergeData(doc, completedData));
                 }
                 return Response.json({
                     after: afterByLocale,

package/dist/index.d.ts

@@ -1,11 +1,22 @@
 import type { Config } from "payload";
-import { type AIModelConfig } from "./ai/providerOptions.js";
+import { type AIModelConfig, type AIProviderConfig } from "./ai/providerOptions.js";
+import { type MaxTokenUsageOptions } from "./ai/tokenUsage.js";
 import { type CollectionPermissionMap } from "./payload/collectionPermissions.js";
+export type { AIModelConfig, AIProviderConfig, AIProviderModelOption } from "./ai/providerOptions.js";
+export type { MaxTokenUsageOptions } from "./ai/tokenUsage.js";
 export type PayloadAIPluginOptions = {
     allowUserApiKeys?: boolean;
     collections?: CollectionPermissionMap;
     disabled?: boolean;
     maxOutputTokens?: number;
+    media?: {
+        acceptedMimeTypes?: string[];
+        collectionSlug?: string;
+        enabled?: boolean;
+        maxFileSize?: number;
+    };
     models?: AIModelConfig;
+    maxTokenUsage?: MaxTokenUsageOptions;
+    providers?: AIProviderConfig[];
 };
 export declare const payloadAiPlugin: (pluginOptions: PayloadAIPluginOptions) => (config: Config) => Config;

package/dist/index.js

@@ -1,14 +1,27 @@
-import { aiProviders, getResolvedAIModelConfig } from "./ai/providerOptions.js";
+import { aiProviders, getResolvedAIModelConfig, resolveAIProviderConfigs, toClientAIProviderProfiles } from "./ai/providerOptions.js";
+import { resolveMaxTokenUsageOptions, tokenUsageCollectionSlug } from "./ai/tokenUsage.js";
 import { createApplyActionHandler } from "./handlers/applyActionHandler.js";
 import { createChatHandler } from "./handlers/chatHandler.js";
 import { createMentionSuggestionHandler } from "./handlers/mentionSuggestionHandler.js";
+import { createMediaUploadHandler } from "./handlers/mediaUploadHandler.js";
 import { createProposalDiffHandler } from "./handlers/proposalDiffHandler.js";
 import { createAuditLogHandler } from "./handlers/auditLogHandler.js";
 import { resolveCollectionPermissions } from "./payload/collectionPermissions.js";
 import { isInternalCollection } from "./payload/shared.js";
-const auditLogCollectionSlug = "payload-ai-auditlog";
+const resolveMediaUploadOptions = (media)=>{
+    if (!media || media.enabled === false) return null;
+    return {
+        ...media.acceptedMimeTypes ? {
+            acceptedMimeTypes: media.acceptedMimeTypes
+        } : {},
+        collectionSlug: media.collectionSlug || "media",
+        ...typeof media.maxFileSize === "number" && Number.isFinite(media.maxFileSize) && media.maxFileSize > 0 ? {
+            maxFileSize: Math.floor(media.maxFileSize)
+        } : {}
+    };
+};
 const createAIChangesCollection = ()=>({
-        slug: auditLogCollectionSlug,
+        slug: "payload-ai-auditlog",
         access: {
             create: ()=>false,
             delete: ()=>false,
@@ -125,6 +138,56 @@ const createAIChangesCollection = ()=>({
         ],
         timestamps: true
     });
+const createAITokenUsageCollection = ()=>({
+        slug: tokenUsageCollectionSlug,
+        access: {
+            create: ()=>false,
+            delete: ()=>false,
+            read: ()=>false,
+            update: ()=>false
+        },
+        admin: {
+            hidden: true
+        },
+        fields: [
+            {
+                name: "userID",
+                type: "text",
+                index: true,
+                required: true
+            },
+            {
+                name: "provider",
+                type: "text",
+                required: true
+            },
+            {
+                name: "model",
+                type: "text",
+                required: true
+            },
+            {
+                name: "inputTokens",
+                type: "number"
+            },
+            {
+                name: "outputTokens",
+                type: "number"
+            },
+            {
+                name: "totalTokens",
+                type: "number",
+                required: true
+            },
+            {
+                name: "recordedAt",
+                type: "date",
+                index: true,
+                required: true
+            }
+        ],
+        timestamps: true
+    });
 const addAccountFields = ({ allowUserApiKeys, config })=>{
     const adminUserSlug = config.admin?.user;
     if (!adminUserSlug || !config.collections) return;
@@ -151,22 +214,60 @@ const addAccountFields = ({ allowUserApiKeys, config })=>{
         });
     }
 };
+const aiField = {
+    name: "payloadAi",
+    type: "ui",
+    admin: {
+        components: {
+            Field: "@mvriu5/payload-ai/client#AIInput"
+        }
+    }
+};
+const addAIFieldToDocumentsAndGlobals = (config)=>{
+    for (const collection of config.collections || []){
+        if (isInternalCollection(collection.slug)) continue;
+        if (collection.slug === "payload-ai-auditlog") continue;
+        collection.fields = [
+            aiField,
+            ...collection.fields || []
+        ];
+    }
+    for (const global of config.globals || []){
+        global.fields = [
+            aiField,
+            ...global.fields || []
+        ];
+    }
+};
 export const payloadAiPlugin = (pluginOptions)=>(config)=>{
         const incomingOnInit = config.onInit;
         const collectionPermissions = resolveCollectionPermissions(pluginOptions.collections);
-        const allowUserApiKeys = pluginOptions.allowUserApiKeys !== false;
+        const providerConfigs = resolveAIProviderConfigs(pluginOptions.providers);
+        const managedProviders = providerConfigs.length > 0;
+        const allowUserApiKeys = !managedProviders && pluginOptions.allowUserApiKeys !== false;
         const modelConfig = getResolvedAIModelConfig(pluginOptions.models);
+        const maxTokenUsage = resolveMaxTokenUsageOptions(pluginOptions.maxTokenUsage);
+        const mediaUploadOptions = resolveMediaUploadOptions(pluginOptions.media);
         const maxOutputTokens = typeof pluginOptions.maxOutputTokens === "number" && Number.isFinite(pluginOptions.maxOutputTokens) && pluginOptions.maxOutputTokens > 0 ? Math.floor(pluginOptions.maxOutputTokens) : undefined;
         if (!config.collections) config.collections = [];
-        if (!config.collections.some((collection)=>collection.slug === auditLogCollectionSlug)) {
+        if (!config.collections.some((collection)=>collection.slug === "payload-ai-auditlog")) {
             config.collections.push(createAIChangesCollection());
         }
-        addAccountFields({
+        if (maxTokenUsage && !config.collections.some((collection)=>collection.slug === tokenUsageCollectionSlug)) {
+            config.collections.push(createAITokenUsageCollection());
+        }
+        if (!managedProviders) addAccountFields({
             allowUserApiKeys,
             config
         });
         if (pluginOptions.disabled) return config;
-        const mentionCollectionSlugs = config.collections.filter((collection)=>!isInternalCollection(collection.slug)).filter((collection)=>collectionPermissions ? Boolean(collectionPermissions[collection.slug]?.read) : true).map((collection)=>collection.slug);
+        const mentionCollectionSlugs = config.collections.flatMap((collection)=>{
+            if (isInternalCollection(collection.slug)) return [];
+            if (collectionPermissions && !collectionPermissions[collection.slug]?.read) return [];
+            return [
+                collection.slug
+            ];
+        });
         if (!config.endpoints) config.endpoints = [];
         if (!config.admin) config.admin = {};
         config.admin.custom = {
@@ -175,25 +276,35 @@ export const payloadAiPlugin = (pluginOptions)=>(config)=>{
                 ...config.admin.custom?.payloadAiPlugin || {},
                 collectionSlugs: mentionCollectionSlugs,
                 allowUserApiKeys,
-                models: modelConfig
+                managedProviders,
+                ...mediaUploadOptions ? {
+                    media: {
+                        ...mediaUploadOptions,
+                        enabled: true
+                    }
+                } : {},
+                models: modelConfig,
+                providers: toClientAIProviderProfiles(providerConfigs)
             }
         };
         if (!config.admin.components) config.admin.components = {};
         if (!config.admin.components.beforeDashboard) config.admin.components.beforeDashboard = [];
-        config.admin.components.beforeDashboard.push(`@mvriu5/payload-ai/client#AIInput`);
+        config.admin.components.beforeDashboard.push(`@mvriu5/payload-ai/client#Dashboard`);
         config.endpoints.push({
             handler: createChatHandler({
                 allowUserApiKeys,
                 collections: collectionPermissions,
                 maxOutputTokens,
-                models: modelConfig
+                maxTokenUsage,
+                models: modelConfig,
+                providers: providerConfigs
             }),
             method: "post",
             path: "/ai-chat"
         });
         config.endpoints.push({
             handler: createApplyActionHandler({
-                changeLogCollection: auditLogCollectionSlug,
+                changeLogCollection: "payload-ai-auditlog",
                 collections: collectionPermissions
             }),
             method: "post",
@@ -201,7 +312,7 @@ export const payloadAiPlugin = (pluginOptions)=>(config)=>{
         });
         config.endpoints.push({
             handler: createAuditLogHandler({
-                changeLogCollection: auditLogCollectionSlug
+                changeLogCollection: "payload-ai-auditlog"
             }),
             method: "get",
             path: "/ai-audit-log"
@@ -220,10 +331,18 @@ export const payloadAiPlugin = (pluginOptions)=>(config)=>{
             method: "post",
             path: "/ai-mention-suggestion"
         });
+        if (mediaUploadOptions) {
+            config.endpoints.push({
+                handler: createMediaUploadHandler(mediaUploadOptions),
+                method: "post",
+                path: "/ai-upload-media"
+            });
+        }
         if (incomingOnInit) {
             config.onInit = async (payload)=>{
                 await incomingOnInit(payload);
             };
         }
+        addAIFieldToDocumentsAndGlobals(config);
         return config;
     };

package/dist/payload/collectionPermissions.js

@@ -6,7 +6,9 @@ const allActions = [
     "update"
 ];
 const getKnownCollectionSlugs = (req)=>{
-    return req.payload.config.collections.map((collection)=>collection.slug).filter((slug)=>!isInternalCollection(slug));
+    return req.payload.config.collections.flatMap((collection)=>isInternalCollection(collection.slug) ? [] : [
+            collection.slug
+        ]);
 };
 export const resolveCollectionPermissions = (collections)=>{
     if (!collections) return undefined;

package/dist/payload/normalizeData.d.ts

@@ -33,15 +33,9 @@ export type NormalizedData = {
     droppedFields: string[];
 };
 export declare const isAuthCollection: (collectionConfig?: CollectionConfig | null) => boolean;
-export declare const getCollectionFields: (collectionConfig?: CollectionConfig | null) => FieldConfig[];
 export declare const hasDrafts: (collectionConfig?: CollectionConfig | null) => boolean;
 export declare const getSchemaFields: (collectionConfig?: CollectionConfig | null) => FieldConfig[];
 export declare const createLexicalText: (value: unknown) => Record<string, unknown>;
 export declare const normalizeAuthData: (collectionConfig: CollectionConfig | undefined, normalized: NormalizedData) => NormalizedData;
 export declare const normalizeDataForFields: (fields: readonly FieldConfig[], data: Record<string, unknown>) => NormalizedData;
-export declare const getLocalizedRequiredFallbackData: ({ fields, source, target, }: {
-    fields: readonly FieldConfig[];
-    source: Record<string, unknown>;
-    target: Record<string, unknown>;
-}) => Record<string, unknown>;
 export {};

package/dist/payload/normalizeData.js

@@ -6,7 +6,7 @@ const getNamedFields = (fields)=>{
 export const isAuthCollection = (collectionConfig)=>{
     return Boolean(collectionConfig?.auth);
 };
-export const getCollectionFields = (collectionConfig)=>{
+const getCollectionFields = (collectionConfig)=>{
     const fields = [
         ...collectionConfig?.fields || []
     ];
@@ -45,7 +45,12 @@ export const getSchemaFields = (collectionConfig)=>{
 export const createLexicalText = (value)=>{
     if (isRecord(value) && isRecord(value.root)) return value;
     const text = Array.isArray(value) ? value.join("\n") : String(value || "");
-    const lines = text.split("\n").map((line)=>line.trim()).filter(Boolean);
+    const lines = text.split("\n").flatMap((line)=>{
+        const trimmedLine = line.trim();
+        return trimmedLine ? [
+            trimmedLine
+        ] : [];
+    });
     return {
         root: {
             children: (lines.length ? lines : [
@@ -89,7 +94,12 @@ const normalizeArrayValue = (field, value)=>{
     });
 };
 const getOptionValues = (field)=>{
-    return (field.options || []).map((option)=>typeof option === "string" ? option : option.value).filter((option)=>Boolean(option));
+    return (field.options || []).flatMap((option)=>{
+        const value = typeof option === "string" ? option : option.value;
+        return value ? [
+            value
+        ] : [];
+    });
 };
 const normalizeOptionValue = (field, value)=>{
     const optionValues = getOptionValues(field);
@@ -101,19 +111,21 @@ const normalizeOptionValue = (field, value)=>{
 };
 const normalizeBlocksValue = (field, value)=>{
     if (!Array.isArray(value)) return value;
-    return value.map((item)=>{
-        if (!isRecord(item)) return null;
+    return value.flatMap((item)=>{
+        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 null;
+        if (!blockType) return [];
         const block = field.blocks?.find((candidate)=>candidate.slug === blockType);
-        if (!block) return null;
+        if (!block) return [];
         const { blockType: _blockType, type: _type, slug: _slug, ...data } = item;
         const normalizedBlock = normalizeDataForFields(block.fields || [], data).data;
-        return {
-            ...normalizedBlock,
-            blockType
-        };
-    }).filter(Boolean);
+        return [
+            {
+                ...normalizedBlock,
+                blockType
+            }
+        ];
+    });
 };
 const normalizeFieldValue = (field, value)=>{
     if (value === undefined) return value;
@@ -209,7 +221,7 @@ export const normalizeDataForFields = (fields, data)=>{
         droppedFields
     };
 };
-export const getLocalizedRequiredFallbackData = ({ fields, source, target })=>{
+const getLocalizedRequiredFallbackData = ({ fields, source, target })=>{
     const fallbackData = {};
     for (const field of getNamedFields(fields)){
         const targetValue = target[field.name];

package/dist/payload/proposalData.js

@@ -69,7 +69,10 @@ const normalizeRelationshipScalar = (value)=>{
     }
     const trimmedValue = value.trim();
     if (!trimmedValue || /\s/.test(trimmedValue)) return undefined;
-    if (/^\d+$/.test(trimmedValue) && Number(trimmedValue) <= 0) return undefined;
+    if (/^\d+$/.test(trimmedValue)) {
+        const numericValue = Number(trimmedValue);
+        return numericValue > 0 ? numericValue : undefined;
+    }
     return trimmedValue;
 };
 const normalizeRelationshipValue = ({ field, issues, path, value })=>{