@mvriu5/payload-ai 1.6.2 → 1.6.4

package/dist/handlers/auditLogHandler.js

@@ -1,10 +1,6 @@
-import { getNumber, getString } from "../payload/shared.js";
-export const createAuditLogHandler = (options)=>async (req)=>{
-        if (!req.user) return Response.json({
-            error: "Unauthorized"
-        }, {
-            status: 401
-        });
+import { getNumber, getString } from "../utils/data.js";
+import { withAuthenticatedHandler } from "./http.js";
+export const createAuditLogHandler = (options)=>withAuthenticatedHandler(async (req)=>{
         const result = await req.payload.find({
             collection: options.changeLogCollection,
             depth: 0,
@@ -36,4 +32,4 @@ export const createAuditLogHandler = (options)=>async (req)=>{
                     url: getString(doc.targetURL)
                 }))
         });
-    };
+    });

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

@@ -0,0 +1,32 @@
+import type { ChatIntent, ToolChoice } from "./types.js";
+export declare const createCollectionAliasMap: (collections: Array<{
+    labels?: {
+        plural?: unknown;
+        singular?: unknown;
+    };
+    slug: string;
+}>) => {
+    [k: string]: string;
+};
+export declare const getLikelyCollectionMatches: ({ aliasMap, prompt }: {
+    aliasMap: Record<string, string>;
+    prompt: string;
+}) => string[];
+export declare const getChatIntent: ({ hasCurrentDocument, hasCurrentGlobal, prompt, }: {
+    hasCurrentDocument: boolean;
+    hasCurrentGlobal: boolean;
+    prompt: string;
+}) => ChatIntent;
+export declare const getIntentToolChoice: ({ hasKnownCollection, hasKnownDocument, hasKnownGlobal, intent, }: {
+    hasKnownCollection: boolean;
+    hasKnownDocument: boolean;
+    hasKnownGlobal: boolean;
+    intent: ChatIntent;
+}) => ToolChoice | undefined;
+export declare const getToolNamesForIntent: ({ hasAttachments, hasKnownCollection, hasCurrentDocument, hasCurrentGlobal, intent, }: {
+    hasAttachments: boolean;
+    hasKnownCollection: boolean;
+    hasCurrentDocument: boolean;
+    hasCurrentGlobal: boolean;
+    intent: ChatIntent;
+}) => Set<string>;

package/dist/handlers/chat/intent.js

@@ -0,0 +1,155 @@
+const regexSpecialCharactersPattern = /[.*+?^${}()|[\]\\]/g;
+export const createCollectionAliasMap = (collections)=>{
+    const aliasMap = new Map();
+    const addAlias = (alias, slug)=>{
+        const normalizedAlias = alias?.trim().toLowerCase();
+        if (!normalizedAlias) return;
+        if (!aliasMap.has(normalizedAlias)) aliasMap.set(normalizedAlias, slug);
+    };
+    for (const collection of collections){
+        addAlias(collection.slug, collection.slug);
+        addAlias(collection.slug.replace(/-/g, " "), collection.slug);
+        const singular = typeof collection.labels?.singular === "string" ? collection.labels.singular : undefined;
+        const plural = typeof collection.labels?.plural === "string" ? collection.labels.plural : undefined;
+        addAlias(singular, collection.slug);
+        addAlias(plural, collection.slug);
+        if (singular?.endsWith("s")) addAlias(singular.slice(0, -1), collection.slug);
+        if (plural?.endsWith("s")) addAlias(plural.slice(0, -1), collection.slug);
+    }
+    return Object.fromEntries(aliasMap.entries());
+};
+export const getLikelyCollectionMatches = ({ aliasMap, prompt })=>{
+    const normalizedPrompt = prompt.toLowerCase();
+    const matches = new Set();
+    const aliases = Object.keys(aliasMap).sort((a, b)=>b.length - a.length);
+    const aliasPattern = aliases.length > 0 ? new RegExp(aliases.map((alias)=>alias.replace(regexSpecialCharactersPattern, "\\$&")).join("|"), "g") : null;
+    if (!aliasPattern) return [];
+    for (const match of normalizedPrompt.matchAll(aliasPattern)){
+        const slug = aliasMap[match[0]];
+        if (slug) matches.add(slug);
+    }
+    return [
+        ...matches
+    ];
+};
+const normalizeIntentText = (prompt)=>prompt.toLowerCase().replace(/ä/g, "ae").replace(/ö/g, "oe").replace(/ü/g, "ue").replace(/ß/g, "ss").normalize("NFKD").replace(/[\u0300-\u036f]/g, "");
+const deleteIntentPattern = /\b(?:delete|remove|erase|destroy|discard|purge|loesch\w*|losch\w*|entfern\w*|rausnehm\w*|wegnehm\w*|verwerf\w*)\b/;
+const createIntentPattern = /\b(?:create|build|generate|draft|compose|author|write|make|new|erstell\w*|anleg\w*|erzeug\w*|generier\w*|entwerf\w*|verfass\w*|schreib\w*|neu)\b/;
+const updateIntentPattern = /\b(?:update|edit|change|modify|revise|refine|rewrite|translate|replace|rename|correct|fix|set|publish|unpublish|aktualisier\w*|aender\w*|bearbeit\w*|anpass\w*|ueberarbeit\w*|uberarbeit\w*|umschreib\w*|uebersetz\w*|ubersetz\w*|ersetz\w*|umbenenn\w*|korrigier\w*|reparier\w*|setz\w*|veroeffentlich\w*|veroffentlich\w*|zurueckzieh\w*|zuruckzieh\w*)\b/;
+const additiveIntentPattern = /\b(?:add|insert|append|attach|assign|link|include|extend|ergaenz\w*|erganz\w*|hinzufueg\w*|hinzufug\w*|einfueg\w*|einfug\w*|anhaeng\w*|anhang\w*|zuweis\w*|verknuepf\w*|verknupf\w*)\b/;
+const searchIntentPattern = /\b(?:search|find|lookup|locate|list|show|fetch|browse|query|such\w*|find\w*|nachschlag\w*|auflist\w*|anzeig\w*|zeig\w*|hol\w*|durchsuch\w*)\b/;
+const separableDeleteIntentPattern = /\b(?:nimm|nehm\w*)\b(?:\s+\w+){0,8}\s+(?:raus|weg)\b/;
+const separableUpdateIntentPattern = /\b(?:pass(?:e|t|en|st)?\b(?:\s+\w+){0,8}\s+an|fueg\w*\b(?:\s+\w+){0,8}\s+(?:ein|hinzu)|haeng\w*\b(?:\s+\w+){0,8}\s+an|weis\w*\b(?:\s+\w+){0,8}\s+zu)\b/;
+export const getChatIntent = ({ hasCurrentDocument, hasCurrentGlobal, prompt })=>{
+    const normalizedPrompt = normalizeIntentText(prompt);
+    if (deleteIntentPattern.test(normalizedPrompt) || separableDeleteIntentPattern.test(normalizedPrompt)) {
+        return hasCurrentGlobal ? "read" : "delete";
+    }
+    if (createIntentPattern.test(normalizedPrompt)) {
+        if (hasCurrentGlobal) return "updateGlobal";
+        if (hasCurrentDocument) return "update";
+        return "create";
+    }
+    if (updateIntentPattern.test(normalizedPrompt) || additiveIntentPattern.test(normalizedPrompt) || separableUpdateIntentPattern.test(normalizedPrompt)) {
+        return hasCurrentGlobal ? "updateGlobal" : "update";
+    }
+    if (searchIntentPattern.test(normalizedPrompt)) return "search";
+    return "read";
+};
+export const getIntentToolChoice = ({ hasKnownCollection, hasKnownDocument, hasKnownGlobal, intent })=>{
+    if (intent === "create" && hasKnownCollection) return {
+        toolName: "proposeCreateDoc",
+        type: "tool"
+    };
+    if (intent === "update" && hasKnownDocument) return {
+        toolName: "proposeUpdateDoc",
+        type: "tool"
+    };
+    if (intent === "delete" && hasKnownDocument) return {
+        toolName: "proposeDeleteDoc",
+        type: "tool"
+    };
+    if (intent === "updateGlobal" && hasKnownGlobal) return {
+        toolName: "proposeUpdateGlobal",
+        type: "tool"
+    };
+    return undefined;
+};
+export const getToolNamesForIntent = ({ hasAttachments, hasKnownCollection, hasCurrentDocument, hasCurrentGlobal, intent })=>{
+    if (hasCurrentGlobal) {
+        return new Set(intent === "updateGlobal" ? [
+            "getGlobal",
+            "listGlobals",
+            "proposeUpdateGlobal"
+        ] : [
+            "getGlobal",
+            "listGlobals"
+        ]);
+    }
+    if (hasCurrentDocument) {
+        if (intent === "delete") return new Set([
+            "getDoc",
+            "proposeDeleteDoc"
+        ]);
+        if (intent === "update" || intent === "create") return new Set([
+            "getDoc",
+            "listCollections",
+            "proposeUpdateDoc"
+        ]);
+        return new Set([
+            "getDoc",
+            "listCollections"
+        ]);
+    }
+    if (hasKnownCollection) {
+        if (intent === "create") return new Set([
+            "getDoc",
+            "listCollections",
+            "proposeCreateDoc",
+            "searchDocs"
+        ]);
+        if (intent === "update") return new Set([
+            "getDoc",
+            "listCollections",
+            "proposeUpdateDoc",
+            "searchDocs"
+        ]);
+        if (intent === "delete") return new Set([
+            "getDoc",
+            "proposeDeleteDoc",
+            "searchDocs"
+        ]);
+        return new Set([
+            "getDoc",
+            "listCollections",
+            "searchDocs"
+        ]);
+    }
+    const toolNames = intent === "create" ? new Set([
+        "getDoc",
+        "listCollections",
+        "proposeCreateDoc",
+        "searchDocs"
+    ]) : intent === "update" ? new Set([
+        "getDoc",
+        "getGlobal",
+        "listCollections",
+        "listGlobals",
+        "proposeUpdateDoc",
+        "proposeUpdateGlobal",
+        "searchDocs"
+    ]) : intent === "delete" ? new Set([
+        "getDoc",
+        "listCollections",
+        "proposeDeleteDoc",
+        "searchDocs"
+    ]) : new Set([
+        "getDoc",
+        "getGlobal",
+        "listCollections",
+        "listGlobals",
+        "searchDocs"
+    ]);
+    if (hasAttachments && (intent === "create" || intent === "update")) toolNames.add("proposeUpdateDoc");
+    return toolNames;
+};

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

@@ -0,0 +1,20 @@
+import type { SystemModelMessage } from "ai";
+import type { AIProvider } from "../../features/providers/options.js";
+import { type PromptCacheProviderOptions } from "../../features/promptCaching.js";
+export declare const createChatPromptContext: ({ chatIntent, collectionAliasMap, focusedRequiredFieldsByCollection, focusedTitleFieldByCollection, intentToolName, likelyCollectionMatches, mentionContext, modelID, promptCaching, provider, scopedToolNames, }: {
+    chatIntent: string;
+    collectionAliasMap: Record<string, string>;
+    focusedRequiredFieldsByCollection: Record<string, unknown>;
+    focusedTitleFieldByCollection: Record<string, unknown>;
+    intentToolName?: string;
+    likelyCollectionMatches: string[];
+    mentionContext: unknown;
+    modelID: string;
+    promptCaching: boolean;
+    provider: AIProvider;
+    scopedToolNames: Set<string>;
+}) => {
+    dynamicMentionContext: Record<string, unknown>[];
+    promptCacheProviderOptions: PromptCacheProviderOptions | undefined;
+    system: SystemModelMessage[];
+};

package/dist/handlers/chat/prompt.js

@@ -0,0 +1,55 @@
+import { createCachedSystemMessages, createPromptCacheProviderOptions, splitPromptCacheContext } from "../../features/promptCaching.js";
+import { redactSensitiveData } from "../../features/sensitiveData.js";
+export const createChatPromptContext = ({ chatIntent, collectionAliasMap, focusedRequiredFieldsByCollection, focusedTitleFieldByCollection, intentToolName, likelyCollectionMatches, mentionContext, modelID, promptCaching, provider, scopedToolNames })=>{
+    const sanitizedMentionContext = redactSensitiveData(mentionContext);
+    const { cacheable: cacheableMentionContext, dynamic: dynamicMentionContext } = splitPromptCacheContext(sanitizedMentionContext);
+    const staticSystemInstructions = [
+        "You are a Payload CMS assistant. Inspect schema/content with tools before proposing writes.",
+        "Mentions define the active CMS scope. Locale mentions define active locale; multiple locales require localizedData keyed by locale.",
+        "Writes are proposals only. Never claim changes were applied before user confirmation.",
+        "Uploaded media attachments appear in context as mediaAttachment entries. Use their exact IDs for upload fields.",
+        "If an uploaded media document has editable descriptive fields, propose an update to that media document with suitable values.",
+        "If a collection has a required `slug` field and the user does not provide it, generate a URL-friendly slug from the title or from the first meaningful word of the prompt.",
+        "For create/update/delete requests, you must use proposal tools. Do not end with plain text if the user asked for a content change.",
+        "If the user asks to create, update, refine, translate, remove, or delete content, produce at least one proposal tool call unless blocked by missing schema information or permissions.",
+        "Put concrete field values only in tool data, not visible text.",
+        "For blocks fields: use exact blockType values from schema, exact field names, and complete objects for required block fields.",
+        "For arrays: every item must be an object matching the child field schema, not free text.",
+        "If schema details are missing, call listCollections/listGlobals with a slug before proposing. If an inferred collection schema is already present in context, use it directly.",
+        "Read tools return compact identity fields by default. Request only the additional fields needed for the current task; full schemas remain available separately.",
+        "If a proposal tool returns retryable=true, correct only repair.issues and call the same proposal tool once more. If retryable=false, do not retry that tool target."
+    ];
+    const cacheableSystemInstructions = [
+        `Collection aliases: ${JSON.stringify(collectionAliasMap)}.`,
+        `Focused required create fields: ${JSON.stringify(focusedRequiredFieldsByCollection)}.`,
+        `Focused title fields: ${JSON.stringify(focusedTitleFieldByCollection)}. Infer concise titles when needed.`
+    ];
+    const dynamicSystemInstructions = [
+        `Likely collection matches for this prompt: ${JSON.stringify(likelyCollectionMatches)}.`,
+        `Request intent: ${chatIntent}. Preferred proposal tool: ${intentToolName || "none"}.`,
+        "Visible response: plain text, under 40 words, no Markdown, no proposed content."
+    ];
+    return {
+        dynamicMentionContext,
+        promptCacheProviderOptions: createPromptCacheProviderOptions({
+            cacheKeyParts: [
+                cacheableMentionContext,
+                cacheableSystemInstructions,
+                [
+                    ...scopedToolNames
+                ].sort()
+            ],
+            enabled: promptCaching,
+            model: modelID,
+            provider
+        }),
+        system: createCachedSystemMessages({
+            cacheableContext: cacheableMentionContext,
+            cacheableInstructions: cacheableSystemInstructions,
+            dynamicInstructions: dynamicSystemInstructions,
+            enabled: promptCaching,
+            provider,
+            staticInstructions: staticSystemInstructions
+        })
+    };
+};

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

@@ -0,0 +1,96 @@
+import type { PayloadHandler } from "payload";
+import type { ActionProposal, LocalizedDataInput } from "../../features/proposals/types.js";
+import type { FieldConfig as ProposalFieldConfig } from "../../features/schema/normalize.js";
+import type { ChatMention, FieldConfig } from "../../features/schema/context.js";
+type RequiredFieldInfo = {
+    defaultValue?: unknown;
+    isTitleField?: boolean;
+    localized: boolean;
+    options?: (string | {
+        label?: unknown;
+        value?: string;
+    })[];
+    path: string;
+    type?: string;
+};
+export type BlockFieldConfig = ProposalFieldConfig & {
+    blocks?: Array<{
+        fields?: ProposalFieldConfig[];
+        slug: string;
+    }>;
+    fields?: ProposalFieldConfig[];
+    name?: string;
+    type?: string;
+};
+type RelationshipTargetReference = {
+    collection: string;
+    id: number | string;
+    path: string;
+};
+export declare const getRequiredFieldInfos: (fields: FieldConfig[], titleFieldName?: string, path?: string) => RequiredFieldInfo[];
+export declare const fillMissingCreateFields: ({ data, label, localizedData, requiredFields, }: {
+    data?: Record<string, unknown>;
+    label: string;
+    localizedData?: LocalizedDataInput;
+    requiredFields: RequiredFieldInfo[];
+}) => {
+    localizedData: {
+        [k: string]: {
+            [x: string]: unknown;
+        };
+    };
+    data?: undefined;
+} | {
+    data: {
+        [x: string]: unknown;
+    };
+    localizedData?: undefined;
+};
+export declare const getMissingCreateFields: ({ data, localizedData, requiredFields, }: {
+    data?: Record<string, unknown>;
+    localizedData?: LocalizedDataInput;
+    requiredFields: RequiredFieldInfo[];
+}) => string[];
+export declare const getProposalSummary: (proposal: ActionProposal) => {
+    action: "create" | "delete" | "update" | "updateGlobal";
+    collection: string | undefined;
+    hasData: boolean;
+    hasLocalizedData: boolean;
+    id: string | undefined;
+    label: string;
+    locale: string | undefined;
+    locales: string[] | undefined;
+    slug: string | undefined;
+};
+export declare const getCollectionBlockTypes: (fields: readonly BlockFieldConfig[]) => string[];
+export declare const getRequestedBlockTypes: ({ availableBlockTypes, mentions, prompt }: {
+    availableBlockTypes: string[];
+    mentions?: ChatMention[];
+    prompt: string;
+}) => string[];
+export declare const collectProposalBlockTypes: ({ data, fields }: {
+    data: Record<string, unknown>;
+    fields: readonly BlockFieldConfig[];
+}) => Set<string>;
+export declare const validateRelationshipTargetsExist: ({ data, fields, req, }: {
+    data: Record<string, unknown>;
+    fields: readonly BlockFieldConfig[];
+    req: Parameters<PayloadHandler>[0];
+}) => Promise<RelationshipTargetReference[]>;
+export declare const getUploadTargetsOutsideAttachments: ({ allowedAttachmentKeys, data, fields, }: {
+    allowedAttachmentKeys: Set<string>;
+    data: Record<string, unknown>;
+    fields: readonly BlockFieldConfig[];
+}) => RelationshipTargetReference[];
+export declare const validateProposalReferences: ({ allowedAttachmentKeys, data, fields, localizedData, priority, req, }: {
+    allowedAttachmentKeys: Set<string>;
+    data?: Record<string, unknown>;
+    fields: readonly BlockFieldConfig[];
+    localizedData?: LocalizedDataInput;
+    priority: "attachments" | "relationships";
+    req: Parameters<PayloadHandler>[0];
+}) => Promise<{
+    invalidRelationshipTargets: RelationshipTargetReference[];
+    uploadTargetsOutsideAttachments: RelationshipTargetReference[];
+}>;
+export {};