@mvriu5/payload-ai 1.6.3 → 1.6.4

package/dist/handlers/generateFieldHandler.d.ts

@@ -1,14 +1,9 @@
 import type { PayloadHandler } from "payload";
-import { type ResolvedMaxTokenUsageOptions } from "../ai/tokenUsage.js";
-import { type AIModelConfig, type ResolvedAIProviderConfig } from "../ai/providerOptions.js";
-import type { TextGenerationPageContext } from "../payload/textFieldGeneration.js";
-type GenerateFieldOptions = {
-    allowUserApiKeys?: boolean;
+import { type AIRequestOptions } from "../features/providers/requestContext.js";
+import type { TextGenerationPageContext } from "../features/content/fieldGeneration.js";
+type GenerateFieldOptions = AIRequestOptions & {
     maxOutputTokens?: number;
-    maxTokenUsage?: ResolvedMaxTokenUsageOptions;
-    models?: AIModelConfig;
     pageContexts: Map<string, TextGenerationPageContext>;
-    providers?: ResolvedAIProviderConfig[];
 };
 export declare const createGenerateFieldHandler: (options: GenerateFieldOptions) => PayloadHandler;
 export {};

package/dist/handlers/generateFieldHandler.js

@@ -1,8 +1,7 @@
 import { generateText } from "ai";
-import { getExceededTokenUsageLimit, recordTokenUsage } from "../ai/tokenUsage.js";
-import { isAIProvider } from "../ai/providerOptions.js";
-import { getModel, getProviderConfig } from "../ai/providerRuntime.js";
-import { redactSensitiveData } from "../ai/sensitiveData.js";
+import { resolveAIRequestContext } from "../features/providers/requestContext.js";
+import { redactSensitiveData } from "../features/sensitiveData.js";
+import { jsonError, logHandlerError, readJSONBody, withAuthenticatedHandler } from "./http.js";
 const maxContextLength = 12000;
 const getCompactContext = (context)=>{
     const redacted = redactSensitiveData(context);
@@ -47,94 +46,33 @@ const parseGeneratedValue = (fieldType, text)=>{
     const withoutFence = value.replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/, "");
     return JSON.parse(withoutFence);
 };
-export const createGenerateFieldHandler = (options)=>async (req)=>{
-        if (!req.user) return Response.json({
-            error: "Unauthorized"
-        }, {
-            status: 401
-        });
-        const body = req.json ? await req.json().catch(()=>null) : null;
+export const createGenerateFieldHandler = (options)=>withAuthenticatedHandler(async (req)=>{
+        const body = await readJSONBody(req);
         const scopeType = body?.scope?.type;
         const scopeSlug = body?.scope?.slug?.trim();
         const fieldKey = body?.fieldKey?.trim();
         if (!scopeType || !scopeSlug || !fieldKey) {
-            return Response.json({
-                error: "Page scope and field are required."
-            }, {
-                status: 400
-            });
+            return jsonError("Page scope and field are required.");
         }
         const pageContext = options.pageContexts.get(`${scopeType}:${scopeSlug}`);
         const fieldContext = pageContext?.fields.find((field)=>field.key === fieldKey);
         if (!pageContext || !fieldContext) {
-            return Response.json({
-                error: "This field is not available for AI generation."
-            }, {
-                status: 400
-            });
+            return jsonError("This field is not available for AI generation.");
         }
-        const user = req.user;
-        const exceededLimit = await getExceededTokenUsageLimit({
-            maxTokenUsage: options.maxTokenUsage,
+        const aiRequestResolution = await resolveAIRequestContext({
+            options,
             req,
-            userID: user.id
+            requestedModel: body?.model,
+            requestedProvider: body?.provider,
+            user: req.user
         });
-        if (exceededLimit) {
-            return Response.json({
-                error: "AI token usage limit reached."
-            }, {
-                status: 429
-            });
-        }
-        const managedProviders = options.providers?.length ? options.providers : null;
-        const requestedProvider = body?.provider || (managedProviders ? managedProviders[0].id : user.aiProvider || "openai");
-        const managedProvider = managedProviders?.find((provider)=>provider.id === requestedProvider);
-        if (managedProviders && !managedProvider) {
-            return Response.json({
-                error: `Unsupported AI provider: ${requestedProvider}`
-            }, {
-                status: 400
-            });
-        }
-        if (!managedProvider && !isAIProvider(requestedProvider)) {
-            return Response.json({
-                error: `Unsupported AI provider: ${requestedProvider}`
-            }, {
-                status: 400
-            });
-        }
-        const provider = managedProvider?.provider || requestedProvider;
-        const requestedModel = body?.model || managedProvider?.defaultModel;
-        if (managedProvider && requestedModel && !managedProvider.models.some((model)=>model.value === requestedModel)) {
-            return Response.json({
-                error: `Unsupported model "${requestedModel}" for AI provider "${managedProvider.id}".`
-            }, {
-                status: 400
-            });
-        }
-        const providerConfig = getProviderConfig({
-            apiKey: managedProvider ? managedProvider.apiKey : options.allowUserApiKeys === false ? null : user.aiApiKey,
-            defaultModels: options.models?.defaults,
-            model: requestedModel,
-            provider
-        });
-        if (!providerConfig.apiKey) {
-            return Response.json({
-                error: "Configure an AI provider API key first."
-            }, {
-                status: 400
-            });
+        if (!aiRequestResolution.ok) {
+            return jsonError(aiRequestResolution.error.message, aiRequestResolution.error.code === "token_limit" ? 429 : 400);
         }
+        const aiRequest = aiRequestResolution.context;
         try {
             const blockContext = getBlockContext(body?.context, body?.fieldPath);
-            const model = await getModel({
-                apiKey: providerConfig.apiKey,
-                ...managedProvider?.baseURL ? {
-                    baseURL: managedProvider.baseURL
-                } : {},
-                model: providerConfig.modelID,
-                provider
-            });
+            const model = await aiRequest.loadModel();
             const result = await generateText({
                 maxOutputTokens: Math.min(options.maxOutputTokens || 300, 600),
                 model,
@@ -159,29 +97,20 @@ export const createGenerateFieldHandler = (options)=>async (req)=>{
                     "Return no labels or explanation. For JSON fields, return strict JSON; for all other fields, return plain text without quotes or Markdown."
                 ].join(" ")
             });
-            if (result.usage && options.maxTokenUsage) {
-                await recordTokenUsage({
-                    model: providerConfig.modelID,
-                    provider: managedProvider?.id || provider,
-                    req,
-                    usage: result.usage,
-                    userID: user.id
-                });
-            }
+            if (result.usage) await aiRequest.recordUsage(result.usage);
             const value = parseGeneratedValue(fieldContext.fieldType, result.text);
             return Response.json({
                 value: fieldContext.maxLength && typeof value === "string" ? value.slice(0, fieldContext.maxLength) : value
             });
         } catch (error) {
-            req.payload.logger.error({
-                err: error,
-                fieldKey,
-                msg: "AI field generation failed"
-            });
-            return Response.json({
-                error: "AI field generation failed."
-            }, {
-                status: 500
+            return logHandlerError({
+                details: {
+                    fieldKey
+                },
+                error,
+                logMessage: "AI field generation failed",
+                publicMessage: "AI field generation failed.",
+                req
             });
         }
-    };
+    });

package/dist/handlers/http.d.ts

@@ -0,0 +1,17 @@
+import type { PayloadHandler } from "payload";
+type HandlerRequest = Parameters<PayloadHandler>[0];
+type AuthenticatedRequest = HandlerRequest & {
+    user: NonNullable<HandlerRequest["user"]>;
+};
+export declare const jsonError: (error: string, status?: number) => Response;
+export declare const readJSONBody: <Body>(req: HandlerRequest) => Promise<Body | null>;
+export declare const withAuthenticatedHandler: (handler: (req: AuthenticatedRequest) => Promise<Response> | Response) => PayloadHandler;
+export declare const logHandlerError: ({ details, error, logMessage, publicMessage, req, status, }: {
+    details?: Record<string, unknown>;
+    error: unknown;
+    logMessage: string;
+    publicMessage: string;
+    req: HandlerRequest;
+    status?: number;
+}) => Response;
+export {};

package/dist/handlers/http.js

@@ -0,0 +1,21 @@
+export const jsonError = (error, status = 400)=>Response.json({
+        error
+    }, {
+        status
+    });
+export const readJSONBody = async (req)=>{
+    if (!req.json) return null;
+    return await req.json().catch(()=>null);
+};
+export const withAuthenticatedHandler = (handler)=>async (req)=>{
+        if (!req.user) return jsonError("Unauthorized", 401);
+        return handler(req);
+    };
+export const logHandlerError = ({ details, error, logMessage, publicMessage, req, status = 500 })=>{
+    req.payload.logger.error({
+        ...details,
+        err: error,
+        msg: logMessage
+    });
+    return jsonError(publicMessage, status);
+};

package/dist/handlers/mediaUploadHandler.js

@@ -1,5 +1,6 @@
 import { addDataAndFileToRequest } from "payload";
-import { getNumber, getString, isRecord } from "../payload/shared.js";
+import { getNumber, getString, isRecord } from "../utils/data.js";
+import { jsonError, logHandlerError } from "./http.js";
 const mimeTypeMatches = (mimeType, acceptedMimeType)=>{
     if (acceptedMimeType === mimeType) return true;
     if (!acceptedMimeType.endsWith("/*")) return false;
@@ -33,42 +34,22 @@ export const createMediaUploadHandler = ({ acceptedMimeTypes, collectionSlug, ma
             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
-                });
+                return jsonError(`Upload collection not found: ${collectionSlug}`);
             }
             if (!collectionConfig.upload) {
-                return Response.json({
-                    error: `Collection is not upload-enabled: ${collectionSlug}`
-                }, {
-                    status: 400
-                });
+                return jsonError(`Collection is not upload-enabled: ${collectionSlug}`);
             }
             const file = uploadReq.file;
             if (!file) {
-                return Response.json({
-                    error: "File is required"
-                }, {
-                    status: 400
-                });
+                return jsonError("File is required");
             }
             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
-                });
+                return jsonError(`File exceeds max size of ${maxFileSize} bytes`, 413);
             }
             const mimeType = file.mimetype || "";
             if (mimeType && !isAcceptedMimeType(mimeType, acceptedMimeTypes)) {
-                return Response.json({
-                    error: `File type is not accepted: ${mimeType}`
-                }, {
-                    status: 415
-                });
+                return jsonError(`File type is not accepted: ${mimeType}`, 415);
             }
             const doc = await uploadReq.payload.create({
                 collection: collectionSlug,
@@ -86,14 +67,11 @@ export const createMediaUploadHandler = ({ acceptedMimeTypes, collectionSlug, ma
                 doc
             });
         } catch (err) {
-            uploadReq.payload.logger.error({
-                err,
-                msg: "AI media upload failed"
-            });
-            return Response.json({
-                error: "Media upload failed."
-            }, {
-                status: 500
+            return logHandlerError({
+                error: err,
+                logMessage: "AI media upload failed",
+                publicMessage: "Media upload failed.",
+                req: uploadReq
             });
         }
     };

package/dist/handlers/mentionSuggestionHandler.d.ts

@@ -1,5 +1,5 @@
 import type { PayloadHandler } from "payload";
-import { type ResolvedCollectionPermissionMap } from "../payload/collectionPermissions.js";
+import { type ResolvedCollectionPermissionMap } from "../features/collectionPermissions.js";
 type MentionSuggestionsOptions = {
     collections?: ResolvedCollectionPermissionMap;
 };

package/dist/handlers/mentionSuggestionHandler.js

@@ -1,5 +1,6 @@
-import { isCollectionActionAllowed } from "../payload/collectionPermissions.js";
-import { getDocLabel } from "../payload/shared.js";
+import { isCollectionActionAllowed } from "../features/collectionPermissions.js";
+import { getDocLabel } from "../utils/data.js";
+import { readJSONBody, withAuthenticatedHandler } from "./http.js";
 const getLocaleCodes = (req)=>{
     const localization = req.payload.config.localization;
     if (!localization) return [];
@@ -20,13 +21,8 @@ const hasLocalizedFields = (fields)=>{
         return Boolean(field.localized) || Boolean(field.fields?.length && hasLocalizedFields(field.fields)) || Boolean(field.tabs?.some((tab)=>hasLocalizedFields(tab.fields || [])));
     });
 };
-export const createMentionSuggestionHandler = (options = {})=>async (req)=>{
-        if (!req.user) return Response.json({
-            error: "Unauthorized"
-        }, {
-            status: 401
-        });
-        const body = req.json ? await req.json().catch(()=>null) : null;
+export const createMentionSuggestionHandler = (options = {})=>withAuthenticatedHandler(async (req)=>{
+        const body = await readJSONBody(req);
         const query = body?.query?.trim();
         const collectionSlug = body?.collectionSlug?.trim();
         if (!query && !collectionSlug) return Response.json({
@@ -96,4 +92,4 @@ export const createMentionSuggestionHandler = (options = {})=>async (req)=>{
         return Response.json({
             suggestions: suggestions.slice(0, 5)
         });
-    };
+    });

package/dist/handlers/proposalDiffHandler.d.ts

@@ -1,5 +1,5 @@
 import type { PayloadHandler } from "payload";
-import { type ResolvedCollectionPermissionMap } from "../payload/collectionPermissions.js";
+import { type ResolvedCollectionPermissionMap } from "../features/collectionPermissions.js";
 type ProposalDiffOptions = {
     collections?: ResolvedCollectionPermissionMap;
 };