@websolutespa/payload-plugin-bowl-llm/dist/api/invoke.handler.js

LLM plugin for Bowl PayloadCms plugin

import { ResponseSuccess } from '@websolutespa/payload-utils/server';
import { addDataAndFileToRequest } from 'payload';
import { v4 as uuid } from 'uuid';
import { appHandler } from './app.handler';
import { errorHandler } from './error.handler';
import { pythonInvokeHandler } from './python/pythonInvoke.handler';
export const invokeHandler = async (req)=>{
    try {
        await addDataAndFileToRequest(req);
        const app = await appHandler(req);
        const systemMessage = app.settings.llmConfig.prompt.prompt?.systemMessage || app.settings.llmConfig.prompt.systemMessage;
        if (!systemMessage) {
            throw {
                status: 500,
                message: 'The application is not configured correctly: systemMessage is missing'
            };
        }
        let requestTools = [];
        const appTools = app.settings.appTools?.filter((x)=>x.isActive) || [];
        if (appTools.length > 0) {
            requestTools = appTools.map((tool)=>{
                // Merge mcpSettings into secrets for mcp_tool
                let secrets = tool.secrets || [];
                if (tool.functionName === 'mcp_tool' && tool.mcpSettings) {
                    const mcpSecrets = [
                        {
                            secretId: 'mcp_url',
                            secretValue: tool.mcpSettings.mcpUrl || ''
                        },
                        {
                            secretId: 'mcp_tool_name',
                            secretValue: tool.mcpSettings.mcpToolName || ''
                        },
                        {
                            secretId: 'mcp_auth_token',
                            secretValue: tool.mcpSettings.mcpAuthToken || ''
                        }
                    ];
                    secrets = [
                        ...secrets,
                        ...mcpSecrets
                    ];
                }
                return {
                    name: tool.name,
                    description: tool.description,
                    type: tool.type,
                    functionId: tool.functionId,
                    functionName: tool.functionName,
                    functionDescription: tool.functionDescription,
                    secrets,
                    llmChainSettings: tool.llmChainSettings,
                    searchSettings: tool.searchSettings,
                    dataSource: tool.dataSource,
                    dbSettings: tool.dbSettings,
                    apiSettings: tool.apiSettings,
                    integrations: tool.knowledgeBase?.integrations || [],
                    waitingMessage: tool.waitingMessage,
                    vectorDbType: tool.knowledgeBase?.vectorDbType || '',
                    vectorDbFile: tool.knowledgeBase?.vectorDbFile?.filename,
                    rulesVectorDb: app.settings.rules.vectorDbFile?.filename
                };
            });
        }
        const request = {
            mode: app.mode,
            provider: app.settings.llmConfig.provider,
            model: app.settings.llmConfig.model,
            secrets: app.settings.llmConfig.secrets,
            systemMessage: systemMessage,
            systemContext: req.data?.systemContext || null,
            tools: app.settings.llmConfig.tools,
            appTools: requestTools,
            vectorDb: app.settings.knowledgeBase.vectorDbFile?.filename,
            rules: {
                vectorDbFile: app.settings.rules.vectorDbFile?.filename,
                threshold: app.settings.rules.threshold
            },
            fineTunedModel: app.settings?.fineTuning?.fineTunedModelName ?? '',
            langChainTracing: app.settings?.llmConfig?.langChainTracing ?? false,
            langChainProject: app.settings?.llmConfig?.langChainProject ?? '',
            outputStructure: app.settings.llmConfig.outputStructure || null,
            messages: [
                {
                    role: 'user',
                    content: JSON.stringify((({ appKey, apiKey, ...o })=>o)(req.data))
                }
            ],
            threadId: uuid()
        };
        const response = await pythonInvokeHandler(request);
        return ResponseSuccess(response);
    } catch (error) {
        return errorHandler(error);
    }
};

//# sourceMappingURL=invoke.handler.js.map