@mvriu5/payload-ai 0.5.0

package/dist/payload/normalizeData.d.ts

@@ -0,0 +1,29 @@
+export type FieldConfig = {
+    blocks?: BlockConfig[];
+    defaultValue?: unknown;
+    fields?: FieldConfig[];
+    name?: string;
+    options?: (string | {
+        value?: string;
+    })[];
+    type?: string;
+};
+type BlockConfig = {
+    fields?: FieldConfig[];
+    slug: string;
+};
+export type CollectionConfig = {
+    auth?: unknown;
+    fields: FieldConfig[];
+    slug: string;
+};
+export type NormalizedData = {
+    coercedFields: string[];
+    data: Record<string, unknown>;
+    droppedFields: string[];
+};
+export declare const isAuthCollection: (collectionConfig?: CollectionConfig | null) => boolean;
+export declare const getCollectionFields: (collectionConfig?: CollectionConfig | null) => FieldConfig[];
+export declare const normalizeAuthData: (collectionConfig: CollectionConfig | undefined, normalized: NormalizedData) => NormalizedData;
+export declare const normalizeDataForFields: (fields: FieldConfig[], data: Record<string, unknown>) => NormalizedData;
+export {};

package/dist/payload/normalizeData.js

@@ -0,0 +1,192 @@
+const SKIP_FIELD = Symbol("skipField");
+const isRecord = (value)=>{
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+};
+const getNamedFields = (fields)=>{
+    return fields.filter((field)=>Boolean(field.name));
+};
+export const isAuthCollection = (collectionConfig)=>{
+    return Boolean(collectionConfig?.auth);
+};
+export const getCollectionFields = (collectionConfig)=>{
+    const fields = [
+        ...collectionConfig?.fields || []
+    ];
+    if (isAuthCollection(collectionConfig)) {
+        fields.push({
+            name: "email",
+            type: "email"
+        }, {
+            name: "password",
+            type: "text"
+        });
+    }
+    return fields;
+};
+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);
+    return {
+        root: {
+            children: (lines.length ? lines : [
+                ""
+            ]).map((line)=>({
+                    children: [
+                        {
+                            detail: 0,
+                            format: 0,
+                            mode: "normal",
+                            style: "",
+                            text: line,
+                            type: "text",
+                            version: 1
+                        }
+                    ],
+                    direction: null,
+                    format: "",
+                    indent: 0,
+                    type: "paragraph",
+                    version: 1
+                })),
+            direction: null,
+            format: "",
+            indent: 0,
+            type: "root",
+            version: 1
+        }
+    };
+};
+const normalizeArrayValue = (field, value)=>{
+    if (!Array.isArray(value)) return value;
+    const childFields = getNamedFields(field.fields || []);
+    const itemLabelField = childFields.find((childField)=>childField.name === "label") || childFields.find((childField)=>childField.name === "title") || childFields.find((childField)=>childField.name === "name") || childFields.find((childField)=>childField.name === "value") || childFields[0];
+    if (!itemLabelField) return value;
+    return value.map((item)=>{
+        if (!isRecord(item)) return {
+            [itemLabelField.name]: item
+        };
+        return normalizeDataForFields(childFields, item).data;
+    });
+};
+const getOptionValues = (field)=>{
+    return (field.options || []).map((option)=>typeof option === "string" ? option : option.value).filter((option)=>Boolean(option));
+};
+const normalizeOptionValue = (field, value)=>{
+    const optionValues = getOptionValues(field);
+    const stringValue = value === null ? "" : String(value);
+    const defaultValue = typeof field.defaultValue === "string" ? field.defaultValue : null;
+    if (stringValue && optionValues.includes(stringValue)) return stringValue;
+    if (defaultValue && optionValues.includes(defaultValue)) return defaultValue;
+    return SKIP_FIELD;
+};
+const normalizeBlocksValue = (field, value)=>{
+    if (!Array.isArray(value)) return value;
+    return value.map((item)=>{
+        if (!isRecord(item)) return null;
+        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;
+        const block = field.blocks?.find((candidate)=>candidate.slug === blockType);
+        if (!block) return null;
+        const { blockType: _blockType, type: _type, slug: _slug, ...data } = item;
+        const normalizedBlock = normalizeDataForFields(block.fields || [], data).data;
+        return {
+            ...normalizedBlock,
+            blockType
+        };
+    }).filter(Boolean);
+};
+const normalizeFieldValue = (field, value)=>{
+    if (value === undefined) return value;
+    if (field.type === "array") return normalizeArrayValue(field, value);
+    if (field.type === "blocks") return normalizeBlocksValue(field, value);
+    if (field.type === "checkbox") return typeof value === "boolean" ? value : value === "true";
+    if (field.type === "group" && isRecord(value)) return normalizeDataForFields(field.fields || [], value).data;
+    if (field.type === "richText") return createLexicalText(value);
+    if ([
+        "radio",
+        "select"
+    ].includes(field.type || "")) return normalizeOptionValue(field, value);
+    if ([
+        "email",
+        "text",
+        "textarea"
+    ].includes(field.type || "")) return value === null ? value : String(value);
+    if (field.type === "date") {
+        const date = new Date(String(value));
+        return Number.isNaN(date.getTime()) ? value : date.toISOString();
+    }
+    return value;
+};
+export const normalizeAuthData = (collectionConfig, normalized)=>{
+    if (!isAuthCollection(collectionConfig)) return normalized;
+    const email = normalized.data.email;
+    const password = normalized.data.password;
+    if (email !== undefined && typeof email !== "string") {
+        normalized.data.email = String(email);
+        normalized.coercedFields.push("email");
+    }
+    if (password !== undefined && typeof password !== "string") {
+        normalized.data.password = String(password);
+        normalized.coercedFields.push("password");
+    }
+    if (typeof normalized.data.password === "string" && normalized.data.password.length > 0 && normalized.data.password.length < 8) {
+        throw new Error("Password must be at least 8 characters long.");
+    }
+    return normalized;
+};
+const getAliasFieldName = (key, fieldsByName)=>{
+    if (fieldsByName.has(key)) return key;
+    if (key.endsWith("Date")) {
+        const dateAlias = `${key.slice(0, -4)}At`;
+        if (fieldsByName.has(dateAlias)) return dateAlias;
+    }
+    return null;
+};
+const normalizeLooseKnownFieldValue = (key, value)=>{
+    if (key === "tags" && Array.isArray(value)) {
+        return value.map((item)=>isRecord(item) ? item : {
+                label: item
+            });
+    }
+    return value;
+};
+export const normalizeDataForFields = (fields, data)=>{
+    const namedFields = getNamedFields(fields);
+    const fieldsByName = new Map(namedFields.map((field)=>[
+            field.name,
+            field
+        ]));
+    const normalizedData = {};
+    const droppedFields = [];
+    const coercedFields = [];
+    for (const [key, value] of Object.entries(data)){
+        const fieldName = getAliasFieldName(key, fieldsByName);
+        if (!fieldName) {
+            const looseValue = normalizeLooseKnownFieldValue(key, value);
+            if (looseValue !== value) {
+                normalizedData[key] = looseValue;
+                coercedFields.push(key);
+                continue;
+            }
+            droppedFields.push(key);
+            continue;
+        }
+        const field = fieldsByName.get(fieldName);
+        if (!field) continue;
+        const normalizedValue = normalizeFieldValue(field, value);
+        if (normalizedValue === SKIP_FIELD) {
+            droppedFields.push(key);
+            continue;
+        }
+        if (fieldName !== key || normalizedValue !== value) {
+            coercedFields.push(key);
+        }
+        normalizedData[fieldName] = normalizedValue;
+    }
+    return {
+        coercedFields,
+        data: normalizedData,
+        droppedFields
+    };
+};

package/dist/payload/schemaContext.d.ts

@@ -0,0 +1,52 @@
+import type { PayloadHandler } from "payload";
+export type AIChatMention = {
+    collection?: string;
+    id?: string;
+    label?: string;
+    parent?: string;
+    slug?: string;
+    type?: "block" | "collection" | "doc" | "global";
+};
+export type FieldConfig = {
+    blocks?: BlockConfig[];
+    fields?: FieldConfig[];
+    hasMany?: boolean;
+    label?: unknown;
+    name?: string;
+    relationTo?: unknown;
+    required?: boolean;
+    type?: string;
+};
+type BlockConfig = {
+    fields?: FieldConfig[];
+    labels?: {
+        plural?: unknown;
+        singular?: unknown;
+    };
+    slug: string;
+};
+type MentionContext = {
+    blockContexts: (Record<string, unknown> & {
+        parent: string;
+        slug: string;
+    })[];
+    collectionSlugs: string[];
+    globalSlugs: string[];
+    mentions?: AIChatMention[];
+    req: Parameters<PayloadHandler>[0];
+};
+export declare const describeField: (field: FieldConfig) => Record<string, unknown>;
+export declare const collectBlocks: ({ fields, parent, }: {
+    fields: FieldConfig[];
+    parent: string;
+}) => (Record<string, unknown> & {
+    parent: string;
+    slug: string;
+})[];
+export declare const getAllowedCollectionSlugs: (req: Parameters<PayloadHandler>[0], collections?: string[]) => string[];
+export declare const getMentionContext: ({ blockContexts, collectionSlugs, globalSlugs, mentions, req, }: MentionContext) => Promise<Record<string, unknown>[]>;
+export declare const buildPromptWithMentionContext: ({ mentionContext, prompt, }: {
+    mentionContext: Record<string, unknown>[];
+    prompt: string;
+}) => string;
+export {};

package/dist/payload/schemaContext.js

@@ -0,0 +1,162 @@
+import { getSerializableLabel, isInternalCollection } from "./shared.js";
+const getSerializableRelationTo = (relationTo)=>{
+    if (typeof relationTo === "string") {
+        return relationTo;
+    }
+    if (Array.isArray(relationTo) && relationTo.every((item)=>typeof item === "string")) {
+        return relationTo;
+    }
+    return undefined;
+};
+export const describeField = (field)=>{
+    const label = getSerializableLabel(field.label);
+    const relationTo = getSerializableRelationTo(field.relationTo);
+    return {
+        ...label ? {
+            label
+        } : {},
+        ...field.name ? {
+            name: field.name
+        } : {},
+        ...field.type ? {
+            type: field.type
+        } : {},
+        ...field.required ? {
+            required: field.required
+        } : {},
+        ...field.hasMany ? {
+            hasMany: field.hasMany
+        } : {},
+        ...relationTo ? {
+            relationTo
+        } : {},
+        ...field.fields ? {
+            fields: field.fields.map(describeField)
+        } : {},
+        ...field.blocks ? {
+            blocks: field.blocks.map(describeBlock)
+        } : {}
+    };
+};
+const describeBlock = (block)=>{
+    return {
+        fields: (block.fields || []).map(describeField),
+        label: getSerializableLabel(block.labels?.singular) || block.slug,
+        slug: block.slug
+    };
+};
+export const collectBlocks = ({ fields, parent })=>{
+    const blocks = [];
+    for (const field of fields){
+        if (field.type === "blocks" && field.blocks) {
+            for (const block of field.blocks){
+                blocks.push({
+                    ...describeBlock(block),
+                    parent,
+                    slug: block.slug
+                });
+                blocks.push(...collectBlocks({
+                    fields: block.fields || [],
+                    parent: `${parent}/${block.slug}`
+                }));
+            }
+        }
+        if (field.fields) {
+            blocks.push(...collectBlocks({
+                fields: field.fields,
+                parent
+            }));
+        }
+    }
+    return blocks;
+};
+export const getAllowedCollectionSlugs = (req, collections)=>{
+    const configuredSlugs = req.payload.config.collections.map((collection)=>collection.slug).filter((slug)=>!isInternalCollection(slug));
+    if (!collections) return configuredSlugs;
+    return configuredSlugs.filter((slug)=>collections.includes(slug));
+};
+export const getMentionContext = async ({ blockContexts, collectionSlugs, globalSlugs, mentions, req })=>{
+    if (!mentions || mentions.length === 0) return [];
+    const context = [];
+    const seen = new Set();
+    for (const mention of mentions.slice(0, 8)){
+        if (mention.type === "collection" && mention.slug) {
+            const slug = mention.slug;
+            const key = `collection:${slug}`;
+            if (seen.has(key) || isInternalCollection(slug) || !collectionSlugs.includes(slug)) continue;
+            const collectionConfig = req.payload.config.collections.find((collection)=>collection.slug === slug);
+            if (!collectionConfig) continue;
+            seen.add(key);
+            context.push({
+                fields: collectionConfig.fields.map(describeField),
+                label: collectionConfig.labels?.plural || collectionConfig.labels?.singular || slug,
+                slug,
+                type: "collection"
+            });
+        }
+        if (mention.type === "global" && mention.slug) {
+            const slug = mention.slug;
+            const key = `global:${slug}`;
+            if (seen.has(key) || !globalSlugs.includes(slug)) continue;
+            const globalConfig = req.payload.config.globals?.find((global)=>global.slug === slug);
+            if (!globalConfig) continue;
+            const globalDoc = await req.payload.findGlobal({
+                depth: 2,
+                overrideAccess: false,
+                req,
+                slug: slug
+            }).catch(()=>null);
+            seen.add(key);
+            context.push({
+                doc: globalDoc,
+                fields: globalConfig.fields.map(describeField),
+                label: globalConfig.label || slug,
+                slug,
+                type: "global"
+            });
+        }
+        if (mention.type === "block" && mention.slug) {
+            const matchingBlocks = blockContexts.filter((block)=>block.slug === mention.slug && (!mention.parent || block.parent === mention.parent));
+            for (const block of matchingBlocks){
+                const key = `block:${block.parent}:${block.slug}`;
+                if (seen.has(key)) continue;
+                seen.add(key);
+                context.push({
+                    ...block,
+                    type: "block"
+                });
+            }
+        }
+        if (mention.type === "doc" && mention.collection && mention.id) {
+            const slug = mention.collection;
+            const key = `doc:${slug}:${mention.id}`;
+            if (seen.has(key) || isInternalCollection(slug) || !collectionSlugs.includes(slug)) continue;
+            const doc = await req.payload.findByID({
+                collection: slug,
+                depth: 2,
+                id: mention.id,
+                overrideAccess: false,
+                req
+            }).catch(()=>null);
+            if (!doc) continue;
+            seen.add(key);
+            context.push({
+                collection: slug,
+                doc,
+                id: mention.id,
+                label: mention.label || mention.id,
+                type: "doc"
+            });
+        }
+    }
+    return context;
+};
+export const buildPromptWithMentionContext = ({ mentionContext, prompt })=>{
+    if (mentionContext.length === 0) return prompt;
+    return [
+        "The user selected the following Payload CMS references in the input. Treat inline text like `collection: Name` or `document: Name` as references to this context, not as literal content.",
+        JSON.stringify(mentionContext, null, 2),
+        "User request:",
+        prompt
+    ].join("\n\n");
+};

package/dist/payload/shared.d.ts

@@ -0,0 +1,2 @@
+export declare const getSerializableLabel: (label: unknown, fallback?: string) => string;
+export declare const isInternalCollection: (slug: string) => boolean;

package/dist/payload/shared.js

@@ -0,0 +1,11 @@
+export const getSerializableLabel = (label, fallback = "")=>{
+    if (typeof label === "string") return label;
+    if (label && typeof label === "object") {
+        const firstLabel = Object.values(label).find((value)=>typeof value === "string");
+        if (typeof firstLabel === "string") return firstLabel;
+    }
+    return fallback;
+};
+export const isInternalCollection = (slug)=>{
+    return slug.startsWith("payload-") || slug === "plugin-collection";
+};

package/package.json

@@ -0,0 +1,126 @@
+{
+  "name": "@mvriu5/payload-ai",
+  "version": "0.5.0",
+  "description": "AI assistant plugin for Payload CMS with provider selection, CMS mentions, and signed action proposals.",
+  "keywords": [
+    "payload",
+    "payloadcms",
+    "payload-plugin",
+    "ai",
+    "cms",
+    "openai",
+    "anthropic",
+    "google-generative-ai",
+    "groq",
+    "mistral"
+  ],
+  "author": "Marius",
+  "license": "MIT",
+  "homepage": "https://github.com/mvriu5/payload-ai-plugin#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mvriu5/payload-ai-plugin.git"
+  },
+  "bugs": {
+    "url": "https://github.com/mvriu5/payload-ai-plugin/issues"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./client": {
+      "import": "./dist/exports/client.js",
+      "types": "./dist/exports/client.d.ts",
+      "default": "./dist/exports/client.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "pnpm copyfiles && pnpm build:types && pnpm build:swc",
+    "build:swc": "swc ./src -d ./dist --config-file .swcrc --strip-leading-paths",
+    "build:types": "tsc --outDir dist --rootDir ./src",
+    "clean": "rimraf {dist,*.tsbuildinfo}",
+    "copyfiles": "copyfiles -u 1 \"src/**/*.{html,css,scss,ttf,woff,woff2,eot,svg,jpg,png,json}\" dist/",
+    "dev": "next dev dev --turbo",
+    "dev:generate-importmap": "pnpm dev:payload generate:importmap",
+    "dev:generate-types": "pnpm dev:payload generate:types",
+    "dev:payload": "cross-env PAYLOAD_CONFIG_PATH=./dev/payload.config.ts payload",
+    "generate:importmap": "pnpm dev:generate-importmap",
+    "generate:types": "pnpm dev:generate-types",
+    "lint": "eslint",
+    "lint:fix": "eslint ./src --fix",
+    "prepublishOnly": "pnpm clean && pnpm build"
+  },
+  "devDependencies": {
+    "@payloadcms/db-postgres": "3.84.1",
+    "@payloadcms/next": "3.84.1",
+    "@payloadcms/richtext-lexical": "3.84.1",
+    "@payloadcms/ui": "3.84.1",
+    "@swc/cli": "0.6.0",
+    "@types/node": "22.19.9",
+    "@types/react": "19.2.14",
+    "@types/react-dom": "19.2.3",
+    "copyfiles": "2.4.1",
+    "cross-env": "^7.0.3",
+    "eslint": "^9.23.0",
+    "graphql": "^16.8.1",
+    "knip": "^6.16.1",
+    "next": "16.2.6",
+    "payload": "3.84.1",
+    "react": "19.2.6",
+    "react-dom": "19.2.6",
+    "rimraf": "3.0.2",
+    "sharp": "0.34.2",
+    "typescript": "5.7.3",
+    "vite-tsconfig-paths": "6.0.5",
+    "vitest": "4.0.18"
+  },
+  "peerDependencies": {
+    "payload": "^3.84.1"
+  },
+  "engines": {
+    "node": "^18.20.2 || >=20.9.0",
+    "pnpm": "^9 || ^10"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "sharp",
+      "esbuild",
+      "unrs-resolver"
+    ]
+  },
+  "registry": "https://registry.npmjs.org/",
+  "knip": {
+    "entry": [
+      "dev/payload.config.ts",
+      "dev/next.config.mjs",
+      "dev/app/**/*.{ts,tsx}"
+    ],
+    "ignore": [
+      "dev/payload-types.ts"
+    ],
+    "project": [
+      "src/**/*.{ts,tsx}",
+      "dev/**/*.{ts,tsx,mjs}"
+    ]
+  },
+  "dependencies": {
+    "@ai-sdk/anthropic": "^3.0.81",
+    "@ai-sdk/google": "^3.0.80",
+    "@ai-sdk/groq": "^3.0.39",
+    "@ai-sdk/mistral": "^3.0.37",
+    "@ai-sdk/openai": "^3.0.67",
+    "ai": "^6.0.193",
+    "zod": "^4.4.3"
+  }
+}