@mvriu5/payload-ai 1.6.2 → 1.6.4

package/dist/features/proposals/optionInference.d.ts

@@ -0,0 +1,13 @@
+import type { FieldConfig } from "../schema/normalize.js";
+export declare const getFieldOptionValues: (field: FieldConfig) => string[];
+export declare const inferOptionValueFromText: ({ field, requireFieldMention, text, }: {
+    field: FieldConfig;
+    requireFieldMention?: boolean;
+    text?: string;
+}) => string | undefined;
+export declare const getDefaultFieldValue: ({ field, inferenceText, label, titleFieldName, }: {
+    field: FieldConfig;
+    inferenceText?: string;
+    label: string;
+    titleFieldName?: string;
+}) => {} | null | undefined;

package/dist/features/proposals/optionInference.js

@@ -0,0 +1,46 @@
+import { getOptionValue, getSafeProposalLabel } from "../../utils/data.js";
+const isTitleLikeField = (field, titleFieldName)=>{
+    const normalizedName = field.name?.toLowerCase();
+    return Boolean(field.name && (field.name === titleFieldName || normalizedName === "title" || normalizedName === "name" || normalizedName === "label" || normalizedName === "headline"));
+};
+export const getFieldOptionValues = (field)=>(field.options || []).map((option)=>getOptionValue(option)).filter((option)=>Boolean(option));
+const escapeRegExp = (value)=>value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const getFieldNameVariants = (fieldName)=>{
+    if (!fieldName) return [];
+    const spacedName = fieldName.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").toLowerCase();
+    return Array.from(new Set([
+        fieldName.toLowerCase(),
+        spacedName
+    ])).filter(Boolean);
+};
+export const inferOptionValueFromText = ({ field, requireFieldMention = false, text })=>{
+    const normalizedText = text?.trim().toLowerCase();
+    if (!normalizedText) return undefined;
+    if (requireFieldMention && !getFieldNameVariants(field.name).some((variant)=>new RegExp(`\\b${escapeRegExp(variant)}\\b`, "i").test(normalizedText))) {
+        return undefined;
+    }
+    return getFieldOptionValues(field).sort((left, right)=>right.length - left.length).find((optionValue)=>new RegExp(`\\b${escapeRegExp(optionValue.toLowerCase())}\\b`, "i").test(normalizedText));
+};
+export const getDefaultFieldValue = ({ field, inferenceText, label, titleFieldName })=>{
+    if (field.name === "_status") return "draft";
+    if (field.type === "checkbox") return false;
+    if (field.type === "select" || field.type === "radio") {
+        const inferredOptionValue = inferOptionValueFromText({
+            field,
+            requireFieldMention: true,
+            text: inferenceText || label
+        });
+        if (inferredOptionValue !== undefined) return inferredOptionValue;
+        if (field.defaultValue !== undefined) return field.defaultValue;
+        return getOptionValue(field.options?.[0]);
+    }
+    if (field.defaultValue !== undefined) return field.defaultValue;
+    if ([
+        "email",
+        "text",
+        "textarea"
+    ].includes(field.type || "") && isTitleLikeField(field, titleFieldName)) {
+        return getSafeProposalLabel(label);
+    }
+    return undefined;
+};

package/dist/features/proposals/recordNormalization.d.ts

@@ -0,0 +1,6 @@
+import { type FieldConfig } from "../schema/normalize.js";
+import type { NormalizationState } from "./normalizationTypes.js";
+export declare const prepareSingleLocaleData: ({ data, fields, ...state }: NormalizationState & {
+    data: Record<string, unknown>;
+    fields: readonly FieldConfig[];
+}) => Record<string, unknown>;

package/dist/features/proposals/recordNormalization.js

@@ -0,0 +1,78 @@
+import { normalizeDataForFields } from "../schema/normalize.js";
+import { normalizeFieldValue } from "./fieldNormalization.js";
+import { getDefaultFieldValue, inferOptionValueFromText } from "./optionInference.js";
+const normalizeRecordForFields = ({ allowSafeFallback, coercedFields, enforceRequiredChildren, fields, inferenceText, issues, label, mode, path, titleFieldName, value })=>{
+    const normalizedData = {};
+    const fieldsByName = new Map(fields.filter((field)=>Boolean(field.name)).map((field)=>[
+            field.name,
+            field
+        ]));
+    for (const [key, fieldValue] of Object.entries(value)){
+        const field = fieldsByName.get(key);
+        const fieldPath = path ? `${path}.${key}` : key;
+        if (!field) {
+            issues.push({
+                code: "unknown_field",
+                message: "Field does not exist in the schema.",
+                path: fieldPath
+            });
+            continue;
+        }
+        const normalizedValue = normalizeFieldValue({
+            coercedFields,
+            enforceRequiredChildren,
+            field,
+            inferenceText,
+            issues,
+            label,
+            mode,
+            normalizeRecord: normalizeRecordForFields,
+            path: fieldPath,
+            titleFieldName,
+            value: fieldValue
+        });
+        if (normalizedValue !== undefined) normalizedData[key] = normalizedValue;
+    }
+    if (mode === "create" || enforceRequiredChildren) {
+        for (const field of fields.filter((candidate)=>Boolean(candidate.name) && candidate.required === true)){
+            const fieldPath = path ? `${path}.${field.name}` : field.name;
+            if (normalizedData[field.name] !== undefined) continue;
+            const fallbackValue = allowSafeFallback ? getDefaultFieldValue({
+                field,
+                inferenceText,
+                label,
+                titleFieldName
+            }) : undefined;
+            if (fallbackValue !== undefined) {
+                normalizedData[field.name] = fallbackValue;
+                continue;
+            }
+            issues.push({
+                code: "missing_required_field",
+                message: "Required field is missing.",
+                path: fieldPath
+            });
+        }
+    }
+    for (const field of fields.filter((candidate)=>Boolean(candidate.name))){
+        if (normalizedData[field.name] !== undefined || field.type !== "select" && field.type !== "radio") continue;
+        const inferredOptionValue = inferOptionValueFromText({
+            field,
+            requireFieldMention: true,
+            text: inferenceText || label
+        });
+        if (inferredOptionValue !== undefined) {
+            normalizedData[field.name] = inferredOptionValue;
+            coercedFields.push(path ? `${path}.${field.name}` : field.name);
+        }
+    }
+    return normalizedData;
+};
+export const prepareSingleLocaleData = ({ data, fields, ...state })=>normalizeDataForFields(fields, normalizeRecordForFields({
+        ...state,
+        allowSafeFallback: true,
+        enforceRequiredChildren: false,
+        fields,
+        path: "",
+        value: data
+    })).data;

package/dist/features/proposals/relationshipNormalization.d.ts

@@ -0,0 +1,8 @@
+import type { FieldConfig } from "../schema/normalize.js";
+import type { ProposalValidationIssue } from "./normalizationTypes.js";
+export declare const normalizeRelationshipValue: ({ field, issues, path, value, }: {
+    field: FieldConfig;
+    issues: ProposalValidationIssue[];
+    path: string;
+    value: unknown;
+}) => unknown;

package/dist/features/proposals/relationshipNormalization.js

@@ -0,0 +1,71 @@
+import { isRecord } from "../../utils/data.js";
+const normalizeRelationshipScalar = (value)=>{
+    if (typeof value === "number") {
+        if (!Number.isInteger(value) || value <= 0) return undefined;
+        return value;
+    }
+    const trimmedValue = value.trim();
+    if (!trimmedValue || /\s/.test(trimmedValue)) return undefined;
+    if (/^\d+$/.test(trimmedValue)) {
+        const numericValue = Number(trimmedValue);
+        return numericValue > 0 ? numericValue : undefined;
+    }
+    return trimmedValue;
+};
+export const normalizeRelationshipValue = ({ field, issues, path, value })=>{
+    const allowedRelationTargets = Array.isArray(field.relationTo) ? field.relationTo.filter((item)=>typeof item === "string") : typeof field.relationTo === "string" ? [
+        field.relationTo
+    ] : [];
+    const addInvalidRelationship = (message, itemPath)=>{
+        issues.push({
+            code: "invalid_relationship",
+            message,
+            path: itemPath
+        });
+    };
+    const normalizeSingle = (item, itemPath)=>{
+        if (typeof item === "number" || typeof item === "string") {
+            const normalizedValue = normalizeRelationshipScalar(item);
+            if (normalizedValue !== undefined) return normalizedValue;
+            addInvalidRelationship(typeof item === "string" ? "Relationship and upload fields must use a valid document ID, not free text." : "Relationship and upload fields must use a valid document ID.", itemPath);
+            return undefined;
+        }
+        if (!isRecord(item)) {
+            addInvalidRelationship("Relationship and upload fields must use a document ID or an object with id/value.", itemPath);
+            return undefined;
+        }
+        if (typeof item.id === "string" || typeof item.id === "number") {
+            const normalizedValue = normalizeRelationshipScalar(item.id);
+            if (normalizedValue !== undefined) return normalizedValue;
+            addInvalidRelationship("Relationship and upload fields must use a valid document ID.", itemPath);
+            return undefined;
+        }
+        if (typeof item.value === "string" || typeof item.value === "number") {
+            const normalizedValue = normalizeRelationshipScalar(item.value);
+            if (normalizedValue === undefined) {
+                addInvalidRelationship("Relationship and upload fields must use a valid document ID.", itemPath);
+                return undefined;
+            }
+            if (allowedRelationTargets.length > 1) {
+                const relationTo = typeof item.relationTo === "string" ? item.relationTo : null;
+                if (!relationTo || !allowedRelationTargets.includes(relationTo)) {
+                    addInvalidRelationship(`Relationship must include one of: ${allowedRelationTargets.join(", ")}.`, itemPath);
+                    return undefined;
+                }
+                return {
+                    relationTo,
+                    value: normalizedValue
+                };
+            }
+            return normalizedValue;
+        }
+        addInvalidRelationship("Relationship and upload fields must use a document ID or an object with id/value.", itemPath);
+        return undefined;
+    };
+    if (!field.hasMany) return normalizeSingle(value, path);
+    if (!Array.isArray(value)) {
+        addInvalidRelationship("Relationship field expects an array of document IDs.", path);
+        return undefined;
+    }
+    return value.map((item, index)=>normalizeSingle(item, `${path}.${index}`)).filter((item)=>item !== undefined);
+};

package/dist/{ai/proposalRepair.d.ts → features/proposals/repair.d.ts}

@@ -1,4 +1,4 @@
-import type { ProposalValidationIssue } from "../payload/proposalData.js";
+import type { ProposalValidationIssue } from "./data.js";
 export declare const maxProposalRepairAttempts = 1;
 export type CompactProposalRepairIssue = {
     code: string;

package/dist/{ai/proposalSigning.d.ts → features/proposals/signing.d.ts}

@@ -1,7 +1,5 @@
-export type AIActionSignature = {
-    expiresAt: string;
-    value: string;
-};
+import type { AIActionSignature } from "./types.js";
+export type { AIActionSignature } from "./types.js";
 type SignableProposal = Record<string, unknown> & {
     _aiSignature?: AIActionSignature;
 };
@@ -9,4 +7,3 @@ export declare const signAIActionProposal: <Proposal extends SignableProposal>(p
     _aiSignature: AIActionSignature;
 };
 export declare const verifyActionProposal: (proposal: SignableProposal) => boolean;
-export {};

package/dist/{ai/proposalSigning.js → features/proposals/signing.js}

@@ -1,5 +1,5 @@
 import { createHmac, timingSafeEqual } from "node:crypto";
-import { isRecord } from "../payload/shared.js";
+import { isRecord } from "../../utils/data.js";
 const signatureTTL = 10 * 60 * 1000;
 const stableStringify = (value)=>{
     if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;

package/dist/features/proposals/target.d.ts

@@ -0,0 +1,52 @@
+import type { PayloadHandler } from "payload";
+import type { CollectionConfig, FieldConfig } from "../schema/normalize.js";
+import { type PreparedProposalData } from "./data.js";
+import type { ActionProposal, LocalizedDataInput } from "./types.js";
+type Request = Parameters<PayloadHandler>[0];
+type WriteProposal = Exclude<ActionProposal, {
+    action: "delete";
+}>;
+type ReadOptions = {
+    fallbackLocale?: false;
+    locale?: string;
+};
+type BaseProposalTarget = {
+    fields: FieldConfig[];
+    read: (options?: ReadOptions) => Promise<Record<string, unknown>>;
+    schema: CollectionConfig;
+    update: (data: Record<string, unknown>, locale?: string, documentID?: string) => Promise<Record<string, unknown>>;
+};
+export type CollectionProposalTarget = BaseProposalTarget & {
+    collection: string;
+    create: (data: Record<string, unknown>, locale?: string) => Promise<Record<string, unknown>>;
+    delete: () => Promise<Record<string, unknown>>;
+    documentID?: string;
+    type: "collection";
+};
+export type GlobalProposalTarget = BaseProposalTarget & {
+    slug: string;
+    type: "global";
+};
+export type ProposalTarget = CollectionProposalTarget | GlobalProposalTarget;
+export declare const resolveProposalTarget: ({ proposal, req }: {
+    proposal: ActionProposal;
+    req: Request;
+}) => ProposalTarget | null;
+export declare const prepareProposalTargetData: ({ inferenceText, proposal, target, }: {
+    inferenceText?: string;
+    proposal: WriteProposal;
+    target: ProposalTarget;
+}) => PreparedProposalData;
+export declare const prepareLocalizedTargetUpdates: ({ defaultLocale, localizedData, target, }: {
+    defaultLocale?: string;
+    localizedData: LocalizedDataInput;
+    target: ProposalTarget;
+}) => Promise<{
+    after: Record<string, unknown>;
+    before: Record<string, unknown>;
+    data: {
+        [x: string]: unknown;
+    };
+    locale: string;
+}[]>;
+export {};

package/dist/features/proposals/target.js

@@ -0,0 +1,125 @@
+import { getSchemaFields } from "../schema/normalize.js";
+import { applyLocalizedRequiredFallbackToPreparedData, prepareProposalWriteData } from "./data.js";
+import { mergeData } from "../../utils/data.js";
+const getLocaleOptions = ({ fallbackLocale, locale } = {})=>({
+        ...fallbackLocale === false ? {
+            fallbackLocale: false
+        } : {},
+        ...locale ? {
+            locale
+        } : {}
+    });
+export const resolveProposalTarget = ({ proposal, req })=>{
+    if (proposal.action === "updateGlobal") {
+        const config = req.payload.config.globals?.find((global)=>global.slug === proposal.slug);
+        if (!config) return null;
+        const schema = {
+            fields: config.fields || [],
+            slug: proposal.slug
+        };
+        return {
+            fields: getSchemaFields(schema),
+            read: async (options)=>await req.payload.findGlobal({
+                    depth: 2,
+                    ...getLocaleOptions(options),
+                    overrideAccess: false,
+                    req,
+                    slug: proposal.slug
+                }),
+            schema,
+            slug: proposal.slug,
+            type: "global",
+            update: async (data, locale)=>await req.payload.updateGlobal({
+                    data,
+                    ...locale ? {
+                        locale
+                    } : {},
+                    overrideAccess: false,
+                    req,
+                    slug: proposal.slug
+                })
+        };
+    }
+    const config = req.payload.config.collections.find((collection)=>collection.slug === proposal.collection);
+    if (!config) return null;
+    const documentID = proposal.action === "create" ? undefined : proposal.id;
+    const requireDocumentID = (overrideDocumentID)=>{
+        const resolvedDocumentID = overrideDocumentID || documentID;
+        if (!resolvedDocumentID) throw new Error(`Proposal target ${proposal.collection} requires a document id.`);
+        return resolvedDocumentID;
+    };
+    return {
+        collection: proposal.collection,
+        create: async (data, locale)=>await req.payload.create({
+                collection: proposal.collection,
+                data,
+                ...locale ? {
+                    locale
+                } : {},
+                overrideAccess: false,
+                req
+            }),
+        delete: async ()=>await req.payload.delete({
+                collection: proposal.collection,
+                id: requireDocumentID(),
+                overrideAccess: false,
+                req
+            }),
+        documentID,
+        fields: getSchemaFields(config),
+        read: async (options)=>await req.payload.findByID({
+                collection: proposal.collection,
+                depth: 2,
+                id: requireDocumentID(),
+                ...getLocaleOptions(options),
+                overrideAccess: false,
+                req
+            }),
+        schema: config,
+        type: "collection",
+        update: async (data, locale, updateDocumentID)=>await req.payload.update({
+                collection: proposal.collection,
+                data,
+                id: requireDocumentID(updateDocumentID),
+                ...locale ? {
+                    locale
+                } : {},
+                overrideAccess: false,
+                req
+            })
+    };
+};
+export const prepareProposalTargetData = ({ inferenceText, proposal, target })=>prepareProposalWriteData({
+        collectionConfig: target.schema,
+        ..."localizedData" in proposal ? {
+            localizedData: proposal.localizedData
+        } : {
+            data: proposal.data
+        },
+        inferenceText,
+        label: proposal.label,
+        mode: proposal.action === "create" ? "create" : "update"
+    });
+export const prepareLocalizedTargetUpdates = async ({ defaultLocale, localizedData, target })=>{
+    const defaultLocaleDoc = defaultLocale ? await target.read({
+        fallbackLocale: false,
+        locale: defaultLocale
+    }) : null;
+    return Promise.all(Object.entries(localizedData).map(async ([locale, localeData])=>{
+        const before = locale === defaultLocale && defaultLocaleDoc ? defaultLocaleDoc : await target.read({
+            fallbackLocale: false,
+            locale
+        });
+        const completedData = applyLocalizedRequiredFallbackToPreparedData({
+            fallbackSource: locale === defaultLocale ? before : defaultLocaleDoc || before,
+            fields: target.fields,
+            preparedData: localeData
+        });
+        return {
+            after: mergeData(before, completedData),
+            before,
+            data: completedData,
+            locale
+        };
+    }));
+};

package/dist/features/proposals/types.d.ts

@@ -0,0 +1,49 @@
+export type AIActionSignature = {
+    expiresAt: string;
+    value: string;
+};
+export type LocalizedDataInput = Record<string, Record<string, unknown>>;
+export type ProposalWritePayload = {
+    data: Record<string, unknown>;
+    localizedData?: never;
+} | {
+    data?: never;
+    localizedData: LocalizedDataInput;
+};
+export type ActionProposal = (({
+    action: "create";
+    collection: string;
+    label: string;
+} & ProposalWritePayload) | {
+    action: "delete";
+    collection: string;
+    id: string;
+    label: string;
+} | ({
+    action: "update";
+    collection: string;
+    id: string;
+    label: string;
+} & ProposalWritePayload) | ({
+    action: "updateGlobal";
+    label: string;
+    slug: string;
+} & ProposalWritePayload)) & {
+    _aiSignature?: AIActionSignature;
+    collection?: string;
+    id?: string;
+    locale?: string;
+    slug?: string;
+};
+export type ActionProposalReference = {
+    action: ActionProposal["action"];
+    collection?: string;
+    id?: string;
+    label: string;
+    locale?: string;
+    slug?: string;
+};
+export type ProposalDiff = {
+    after: unknown;
+    before: unknown;
+};

package/dist/features/proposals/types.js

@@ -0,0 +1 @@
+export { };

package/dist/features/proposals/validation.d.ts

@@ -0,0 +1,12 @@
+import type { ActionProposal } from "./types.js";
+type ProposalValidationError = "invalid_shape" | "invalid_signature" | "missing";
+export type SignedProposalValidation = {
+    error: ProposalValidationError;
+    ok: false;
+    proposal?: Partial<ActionProposal>;
+} | {
+    ok: true;
+    proposal: ActionProposal;
+};
+export declare const validateSignedProposal: (value: unknown) => SignedProposalValidation;
+export {};

package/dist/features/proposals/validation.js

@@ -0,0 +1,26 @@
+import { isActionProposal, isRecord } from "../../utils/data.js";
+import { verifyActionProposal } from "./signing.js";
+export const validateSignedProposal = (value)=>{
+    if (value === undefined || value === null) return {
+        error: "missing",
+        ok: false
+    };
+    if (!isRecord(value)) return {
+        error: "invalid_shape",
+        ok: false
+    };
+    if (!verifyActionProposal(value)) return {
+        error: "invalid_signature",
+        ok: false,
+        proposal: value
+    };
+    if (!isActionProposal(value)) return {
+        error: "invalid_shape",
+        ok: false,
+        proposal: value
+    };
+    return {
+        ok: true,
+        proposal: value
+    };
+};

package/dist/features/providers/requestContext.d.ts

@@ -0,0 +1,53 @@
+import type { LanguageModel } from "ai";
+import type { PayloadHandler } from "payload";
+import { type AIModelConfig, type AIProvider, type ResolvedAIProviderConfig } from "./options.js";
+import { type ResolvedMaxTokenUsageOptions, type TokenUsageData, type TokenUsageLimit } from "../tokenUsage.js";
+export type AIRequestOptions = {
+    allowUserApiKeys?: boolean;
+    maxTokenUsage?: ResolvedMaxTokenUsageOptions;
+    models?: AIModelConfig;
+    providers?: ResolvedAIProviderConfig[];
+};
+export type AIRequestUser = {
+    aiApiKey?: string | null;
+    aiProvider?: AIProvider | string | null;
+    id: number | string;
+};
+type AIRequestFailure = {
+    code: "missing_api_key";
+    managedProvider: boolean;
+    message: string;
+    modelID: string;
+    provider: AIProvider;
+    providerID: string;
+} | {
+    code: "token_limit";
+    message: string;
+    tokenLimit: TokenUsageLimit;
+} | {
+    code: "unsupported_model" | "unsupported_provider";
+    message: string;
+};
+export type AIRequestContext = {
+    loadModel: () => Promise<LanguageModel>;
+    managedProvider: ResolvedAIProviderConfig | null;
+    modelID: string;
+    provider: AIProvider;
+    providerID: string;
+    recordUsage: (usage: TokenUsageData) => Promise<void>;
+};
+export type AIRequestResolution = {
+    context: AIRequestContext;
+    ok: true;
+} | {
+    error: AIRequestFailure;
+    ok: false;
+};
+export declare const resolveAIRequestContext: ({ options, req, requestedModel, requestedProvider, user, }: {
+    options: AIRequestOptions;
+    req: Parameters<PayloadHandler>[0];
+    requestedModel?: string | null;
+    requestedProvider?: string | null;
+    user: AIRequestUser;
+}) => Promise<AIRequestResolution>;
+export {};

package/dist/features/providers/requestContext.js

@@ -0,0 +1,90 @@
+import { isAIProvider } from "./options.js";
+import { getModel, getProviderConfig } from "./runtime.js";
+import { getExceededTokenUsageLimit, recordTokenUsage } from "../tokenUsage.js";
+export const resolveAIRequestContext = async ({ options, req, requestedModel, requestedProvider, user })=>{
+    const tokenLimit = await getExceededTokenUsageLimit({
+        maxTokenUsage: options.maxTokenUsage,
+        req,
+        userID: user.id
+    });
+    if (tokenLimit) {
+        return {
+            error: {
+                code: "token_limit",
+                message: "AI token usage limit reached.",
+                tokenLimit
+            },
+            ok: false
+        };
+    }
+    const managedProviders = options.providers?.length ? options.providers : null;
+    const providerSelection = requestedProvider || (managedProviders ? managedProviders[0].id : user.aiProvider || "openai");
+    const managedProvider = managedProviders?.find((providerConfig)=>providerConfig.id === providerSelection) || null;
+    if (managedProviders && !managedProvider || !managedProvider && !isAIProvider(providerSelection)) {
+        return {
+            error: {
+                code: "unsupported_provider",
+                message: `Unsupported AI provider: ${providerSelection}`
+            },
+            ok: false
+        };
+    }
+    const provider = managedProvider?.provider || providerSelection;
+    const modelSelection = requestedModel || managedProvider?.defaultModel;
+    if (managedProvider && modelSelection && !managedProvider.models.some((model)=>model.value === modelSelection)) {
+        return {
+            error: {
+                code: "unsupported_model",
+                message: `Unsupported model "${modelSelection}" for AI provider "${managedProvider.id}".`
+            },
+            ok: false
+        };
+    }
+    const providerConfig = getProviderConfig({
+        apiKey: managedProvider ? managedProvider.apiKey : options.allowUserApiKeys === false ? null : user.aiApiKey,
+        defaultModels: options.models?.defaults,
+        model: modelSelection,
+        provider
+    });
+    const providerID = managedProvider?.id || provider;
+    if (!providerConfig.apiKey) {
+        return {
+            error: {
+                code: "missing_api_key",
+                managedProvider: Boolean(managedProvider),
+                message: "Configure an AI provider API key first.",
+                modelID: providerConfig.modelID,
+                provider,
+                providerID
+            },
+            ok: false
+        };
+    }
+    return {
+        context: {
+            loadModel: ()=>getModel({
+                    apiKey: providerConfig.apiKey,
+                    ...managedProvider?.baseURL ? {
+                        baseURL: managedProvider.baseURL
+                    } : {},
+                    model: providerConfig.modelID,
+                    provider
+                }),
+            managedProvider,
+            modelID: providerConfig.modelID,
+            provider,
+            providerID,
+            recordUsage: async (usage)=>{
+                if (!options.maxTokenUsage) return;
+                await recordTokenUsage({
+                    model: providerConfig.modelID,
+                    provider: providerID,
+                    req,
+                    usage,
+                    userID: user.id
+                });
+            }
+        },
+        ok: true
+    };
+};