@botonic/plugin-flow-builder/src/lib/content-fields/flow-ai-agent-base.js

Botonic plugin for **Hubtype Flow Builder**: run and bridge flow-driven logic from bots on the **current** line.

import { __awaiter } from "tslib";
import { OutputAiAgentMessageType, VerbosityLevel, } from '@botonic/shared';
import { getFlowBuilderPlugin, HubtypeAssistantContent } from '../utils';
import { ContentFieldsBase } from './content-fields-base';
import { FlowCarousel } from './flow-carousel';
import { FlowText } from './flow-text';
export class FlowAiAgentBase extends ContentFieldsBase {
    constructor() {
        super(...arguments);
        this.name = '';
        this.instructions = '';
        this.model = '';
        this.verbosity = VerbosityLevel.Medium;
        this.inputGuardrailRules = [];
        this.messages = [];
    }
    resolveAIAgentResponse(botonicContext, previousContents) {
        return __awaiter(this, void 0, void 0, function* () {
            const aiAgentResponse = yield this.getAIAgentResponse(botonicContext, previousContents);
            if (aiAgentResponse) {
                this.aiAgentResponse = aiAgentResponse;
                yield this.trackAiAgentResponse(botonicContext);
                this.messages = aiAgentResponse.messages;
            }
            return aiAgentResponse;
        });
    }
    trackFlow() {
        return __awaiter(this, void 0, void 0, function* () {
            return;
        });
    }
    getFlowContentsByContentId(botonicContext, contentId) {
        return __awaiter(this, void 0, void 0, function* () {
            const flowBuilderPlugin = getFlowBuilderPlugin(botonicContext.plugins);
            const cmsApi = flowBuilderPlugin.cmsApi;
            const node = cmsApi.getNodeByContentID(contentId);
            const flowContents = yield flowBuilderPlugin.getContentsByNode(node);
            return flowContents;
        });
    }
    processContent(botonicContext, previousContents) {
        return __awaiter(this, void 0, void 0, function* () {
            if (this.messages.length === 0) {
                yield this.resolveAIAgentResponse(botonicContext, previousContents);
            }
            yield this.filterContent(botonicContext, this);
        });
    }
    toBotonic(botonicContext) {
        return __awaiter(this, void 0, void 0, function* () {
            const botonicMessages = [];
            for (const message of this.messages) {
                if (message.type === OutputAiAgentMessageType.Text ||
                    message.type === OutputAiAgentMessageType.TextWithButtons ||
                    message.type === OutputAiAgentMessageType.BotExecutor) {
                    botonicMessages.push(FlowText.fromAIAgent(this.id, message));
                }
                if (message.type === OutputAiAgentMessageType.Carousel) {
                    botonicMessages.push(yield FlowCarousel.fromAIAgent(this.id, message, botonicContext));
                }
                if (message.type === OutputAiAgentMessageType.FlowBuilderContent) {
                    const flowContents = yield this.getFlowContentsByContentId(botonicContext, message.contentId);
                    for (const content of flowContents) {
                        yield content.processContent(botonicContext);
                        const flowContents = yield content.toBotonic(botonicContext);
                        if (Array.isArray(flowContents)) {
                            botonicMessages.push(...flowContents);
                        }
                        else if (flowContents) {
                            botonicMessages.push(flowContents);
                        }
                    }
                }
            }
            return botonicMessages;
        });
    }
    getPreviousHubtypeContents(previousContents) {
        return ((previousContents === null || previousContents === void 0 ? void 0 : previousContents.map(content => ({
            role: 'assistant',
            content: HubtypeAssistantContent.adapt(content),
        }))) || []);
    }
    getActiveInputGuardrailRules(inputGuardrailRules) {
        var _a;
        return (((_a = inputGuardrailRules === null || inputGuardrailRules === void 0 ? void 0 : inputGuardrailRules.filter(rule => rule.is_active)) === null || _a === void 0 ? void 0 : _a.map(rule => ({
            name: rule.name,
            description: rule.description,
        }))) || []);
    }
}
//# sourceMappingURL=flow-ai-agent-base.js.map