wingbot 3.74.7 → 3.75.9-alpha.1

package/src/LLMDispatcher.js

@@ -0,0 +1,508 @@
+/**
+ * @author David Menger
+ */
+'use strict';
+
+const LLMRouter = require('./LLMRouter');
+const { parseActionPayload } = require('./utils');
+const { quickReplyAction } = require('./utils/quickReplies');
+const stateData = require('./utils/stateData');
+const { checkSetState } = require('./utils/stateVariables');
+
+/** @typedef {import('./Request')} Request */
+/** @typedef {import('./Responder')} Responder */
+/** @typedef {import('./GlobalIntents').GlobalIntentsMap} GlobalIntentsMap */
+/** @typedef {import('./GlobalIntents').ResolvedGlobalIntentsMap} ResolvedGlobalIntentsMap */
+/** @typedef {import('./GlobalIntents').GlobalIntent} GlobalIntent */
+/** @typedef {import('./LLMRouter').RouterResolver} RouterResolver */
+/** @typedef {import('./Ai')} Ai */
+/** @typedef {import('./LLM')} LLM */
+/** @typedef {import('./LLMRouter').LLMRouting} LLMRouting */
+/** @typedef {import('./LLMRouter').RoutingAction} RoutingAction */
+/** @typedef {import('./utils/quickReplies').QuickReplyAction} QuickReplyAction */
+/** @typedef {import('./LLMRouter').LLMRoutingCache} LLMRoutingCache */
+
+const BASE64_REGEX = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+
+/**
+ * @typedef {object} DispatcherRouting
+ * @prop {Map<string, GlobalIntent>} giByAction
+ * @prop {GlobalIntent[]} nlpMatchers
+ */
+
+/**
+ * @typedef {LLMRouting & DispatcherRouting} Routing
+ */
+
+/**
+ * @typedef {object} ILLMRouter
+ * @prop {RouterResolver} resolve
+ */
+
+/**
+ * @typedef {object} Logger
+ * @prop {Function} log
+ * @prop {Function} error
+ */
+
+/**
+ * @typedef {object} DispatcherOptions
+ * @prop {Logger} [log]
+ */
+
+/**
+ * @class LLMDispatcher
+ */
+class LLMDispatcher {
+
+    /**
+     *
+     * @param {Ai} ai
+     * @param {Routing} routing
+     * @param {LLM} [llm]
+     * @param {DispatcherOptions} options
+     */
+    constructor (ai, routing = null, llm = null, options = {}) {
+        this._ai = ai;
+        this._llm = llm;
+
+        /** @type {Routing} */
+        this._routing = routing || {
+            router: null,
+            nlpMatchers: [],
+            giByAction: new Map(),
+            globals: {
+                actionListString: null,
+                actionList: [],
+                router: null,
+                byAction: new Map()
+            },
+            locals: new Map()
+        };
+
+        /** @type {QuickReplyAction[]} */
+        this._quickReplyActions = null;
+
+        /** @type {RoutingAction} */
+        this._action = null;
+
+        /** @type {RoutingAction[]} */
+        this._aiActions = null;
+
+        /** @type {Request} */
+        this._req = null;
+
+        this._log = options.log || console;
+
+        this._dispatched = false;
+
+        this._overrideAction = null;
+    }
+
+    /**
+     *
+     * @param {RoutingAction} action
+     */
+    overrideAction (action) {
+        this._overrideAction = action;
+    }
+
+    /**
+     *
+     * @param {Request} req
+     * @param {Responder} [res]
+     * @returns {Promise<RoutingAction>}
+     */
+    async dispatch (req, res) {
+        this._req = req;
+
+        try {
+            this._action = await this._postbackAction(res);
+        } catch (e) {
+            // console.log('DISPATCH FAILED -----\n\n', e);
+            this._log.error('LLMDispatch failed', e);
+            throw e;
+        }
+
+        // console.log('DISPATCHed -----\n\n');
+        this._dispatched = true;
+        return this._action;
+    }
+
+    /**
+     *
+     * @param {Responder} [responder]
+     * @returns {Promise<RoutingAction>}
+     */
+    async _postbackAction (responder = null) {
+        let res;
+        if (this._req.referral !== null && this._req.referral.ref) {
+            res = parseActionPayload({ payload: this._req.referral.ref });
+        }
+
+        if (!res && this._req.postback !== null) {
+            res = parseActionPayload(this._req.postback);
+        }
+
+        if (!res && this._req.optin !== null && this._req.optin.ref) {
+            res = this._base64Ref(this._req.optin);
+        }
+
+        if (!res && this._req.optin !== null && this._req.optin.payload) {
+            res = parseActionPayload(this._req.optin);
+        }
+
+        if (!res && this._req.message !== null && this._req.message.quick_reply) {
+            res = parseActionPayload(this._req.message.quick_reply);
+        }
+
+        /**
+         * TADY MUSI BYT HOTOVE AI
+         * - jsou nasazeny handlery s AI?
+         * - nepustíme už rovnou LLM?
+         * - AI vždy-s-textem/jen-s-handlery/
+         */
+
+        await this._ai.preloadAi(this._req, responder);
+
+        if (!res && this._req.state._expectedKeywords) {
+            res = this._actionByExpectedKeywords(this._req.state._expected);
+        }
+
+        let bounceAllow = false;
+        if (!res && this._req.state._expected) {
+            res = parseActionPayload(this._req.state._expected);
+            bounceAllow = !!(res
+                && this._req.state._expected.bounce === 'allow');
+        }
+
+        this._aiActions = this._resolveAiActions();
+
+        const routing = this._localLLmRoutingForState(this._req.state);
+
+        let aiRes;
+        let llmRes;
+        if ((!res || bounceAllow) && routing?.router) {
+            aiRes = await routing.router.resolve(this._llm, this._req, routing);
+        }
+
+        if ((!res || bounceAllow) && !aiRes) {
+            llmRes = this._getAiWinnerResAfterResolved();
+        }
+
+        if (aiRes || llmRes) {
+            res = aiRes || llmRes;
+        }
+
+        if (!res
+            && routing.keepUserInInteractionsWithBounceAllowed
+            && this._req.state.lastAction
+            && !this._req.state.lastAction.match(/\*$/)) {
+
+            return {
+                action: this._req.state.lastAction
+            };
+        }
+
+        return this._applySetStateToDetectedAction(res);
+    }
+
+    _getAiWinnerResAfterResolved () {
+        const [winner] = this._aiActions;
+
+        if (!winner?.winner) {
+            return null;
+        }
+
+        const _aiKeys = winner.setState ? Object.keys(winner.setState) : [];
+
+        return {
+            action: winner.action, data: {}, setState: winner.setState, _aiKeys
+        };
+    }
+
+    /**
+     *
+     * @param {*} state
+     * @returns {LLMRoutingCache}
+     */
+    _localLLmRoutingForState (state) {
+        const { lastAction } = state;
+
+        /** @type {LLMRoutingCache} */
+        let routing = this._routing.globals;
+
+        if (lastAction) {
+            let normalized = lastAction.replace(/\/$/, '');
+
+            if (this._routing.locals.has(normalized)) {
+                routing = this._routing.locals.get(normalized);
+            } else {
+                normalized = normalized.replace(/\/[^/]+$/, '');
+                if (this._routing.locals.has(normalized)) {
+                    routing = this._routing.locals.get(normalized);
+                }
+            }
+        }
+
+        const router = routing?.router || this._routing.router;
+
+        if (!routing) {
+            return null;
+        }
+
+        return {
+            ...routing,
+            router
+        };
+    }
+
+    /**
+     *
+     * - dokonce i na "expectedKeywords"
+     *
+     * @param {RoutingAction} res
+     * @returns {RoutingAction}
+     */
+    _applySetStateToDetectedAction (res) {
+        // find global intent
+        if (!res) {
+            return res;
+        }
+        let { setState = {} } = res;
+        let entitiesSetState = {};
+        const gi = this._routing.giByAction.get(res.action);
+        if (gi && gi.action === res.action) {
+            entitiesSetState = { ...gi.entitiesSetState };
+
+            const values = Array.from(Object.values(entitiesSetState));
+
+            for (const value of values) {
+                if (typeof value === 'function') {
+                    Object.assign(entitiesSetState, value(stateData(this._req)));
+                }
+            }
+        }
+        const newState = {
+            ...entitiesSetState,
+            ...setState
+        };
+        checkSetState(setState, newState);
+        setState = newState;
+        const aiKeysSet = new Set([
+            ...(res._aiKeys || []),
+            ...Object.keys(entitiesSetState)
+        ]);
+        const aiKeys = Array.from(aiKeysSet)
+            .filter((k) => typeof setState[k] !== 'undefined' && k.startsWith('@'));
+
+        return {
+            ...res,
+            setState,
+            _aiKeys: aiKeys
+        };
+    }
+
+    /**
+     * Returns resolved action
+     *
+     * @returns {RoutingAction}
+     */
+    action () {
+        if (this._overrideAction) {
+            return this._overrideAction;
+        }
+        // if (!this._dispatched) {
+        //     throw new Error('LLM dispatcher wansn\'t dispatched!');
+        // }
+        return this._action;
+    }
+
+    /**
+     * Returns full detected AI actions
+     *
+     * @returns {RoutingAction[]}
+     */
+    aiActions () {
+        if (!this._dispatched) {
+            return [];
+        }
+        return this._aiActions;
+    }
+
+    /**
+     * Returns full detected AI action
+     *
+     * @returns {RoutingAction}
+     */
+    aiActionWinner () {
+        // if (!this._dispatched) {
+        //     throw new Error('LLM dispatcher wansn\'t dispatched!');
+        // }
+        return this._aiActions[0]?.winner ? this._aiActions[0] : null;
+    }
+
+    /**
+     * Yields global intents at the current request path.
+     *
+     * @returns {Generator<[GlobalIntent, boolean]>}
+     */
+    * globalIntentsAtPath () {
+        // to match the local context intent
+        const localRegexToMatch = this._req.getLocalPathRegexp();
+
+        for (const gi of this._routing.nlpMatchers) {
+            const pathMatches = localRegexToMatch && localRegexToMatch.exec(gi.action);
+            if (gi.local && !pathMatches) {
+                continue;
+            }
+            yield [gi, !!pathMatches];
+        }
+    }
+
+    /**
+     * Returns full detected AI action
+     *
+     * @returns {RoutingAction[]}
+     */
+    _resolveAiActions () {
+        if (!this._req.isTextOrIntent()) {
+            return [];
+        }
+
+        /**
+         * @typedef {object} ExtendRoutingAction
+         * @prop {number} sort
+         */
+
+        /** @type {(RoutingAction & ExtendRoutingAction)[]} */
+        const aiActions = [];
+
+        const iterator = this.globalIntentsAtPath();
+
+        for (const [gi, pathMatches] of iterator) {
+            const intent = gi.matcher(this._req); // , null, true
+            if (intent !== null) {
+                const sort = intent.score + (pathMatches
+                    ? this._ai.localEnhancement
+                    : 0);
+                // console.log(sort, wi.intent);
+                aiActions.push({
+                    action: gi.action,
+                    ...gi,
+                    intent,
+                    setState: intent.setState,
+                    aboveConfidence: intent.aboveConfidence,
+                    sort,
+                    winner: false
+                });
+            }
+        }
+
+        aiActions.sort((l, r) => r.sort - l.sort);
+        this._setWinner(aiActions);
+        return aiActions;
+    }
+
+    _setWinner (aiActions) {
+        if (aiActions.length === 0 || !aiActions[0].aboveConfidence) {
+            return null;
+        }
+
+        // there will be no winner, if there are two different intents
+        if (this._ai.shouldDisambiguate(aiActions)) {
+            return null;
+        }
+
+        if (aiActions[0]) {
+            // eslint-disable-next-line no-param-reassign
+            aiActions[0].winner = true;
+        }
+
+        return aiActions[0];
+    }
+
+    _actionByExpectedKeywords (expected) {
+        // @ts-ignore
+        if (!this._req.state._expectedKeywords) {
+            return null;
+        }
+
+        const actions = this.resolveQuickReplyActions();
+
+        // @ts-ignore
+        if (expected && this._ai.shouldDisambiguate(actions, true)) {
+            return parseActionPayload(expected);
+        }
+
+        const [payload] = actions;
+        if (!payload || !payload.aboveConfidence) {
+            return null;
+        }
+
+        return parseActionPayload(payload);
+    }
+
+    /**
+     *
+     * @returns {QuickReplyAction[]}
+     */
+    resolveQuickReplyActions () {
+        if (this._quickReplyActions === null) {
+            if (this._req.state._expectedKeywords) {
+                this._quickReplyActions = quickReplyAction(
+                    this._req.state._expectedKeywords,
+                    this._req,
+                    this._ai
+                );
+            } else {
+                this._quickReplyActions = [];
+            }
+        }
+        return this._quickReplyActions;
+    }
+
+    _base64Ref (object = {}) {
+        let process = {};
+
+        if (object && object.ref) {
+            let payload = object.ref;
+
+            if (typeof payload === 'string' && payload.match(BASE64_REGEX)) {
+                payload = Buffer.from(payload, 'base64').toString('utf8');
+            }
+
+            process = { payload };
+        }
+
+        return parseActionPayload(process);
+    }
+
+    /**
+     *
+     * @param {ResolvedGlobalIntentsMap} globalIntents
+     * @returns {Routing}
+     */
+    static prepareRouting (globalIntents) {
+        /** @type {Map<string,GlobalIntent>} */
+        const giByAction = new Map();
+        const giMatchersByAction = new Map();
+        for (const gi of globalIntents.values()) {
+            if (gi.action) {
+                giByAction.set(gi.action, gi);
+                if (gi.matcher) {
+                    giMatchersByAction.set(gi.action, gi);
+                }
+            }
+        }
+
+        return {
+            ...LLMRouter.prepareRouting(globalIntents),
+            nlpMatchers: Array.from(giMatchersByAction.values()),
+            giByAction
+        };
+    }
+
+}
+
+module.exports = LLMDispatcher;

package/src/LLMMockProvider.js

@@ -8,6 +8,18 @@ const LLM = require('./LLM');
 /** @typedef {import('./LLM').LLMChatProvider} LLMChatProvider */
 /** @typedef {import('./LLM').LLMMessage} LLMMessage */
 /** @typedef {import('./LLM').LLMProviderOptions} LLMProviderOptions */
+/** @typedef {import('./LLM').LLMPresetName} LLMPresetName */
+
+/**
+ * @template {object|string} [C=object|string]
+ * @typedef {object} LLMMockResponse
+ * @prop {LLMPresetName} preset
+ * @prop {C} content
+ */
+
+/**
+ * @typedef {LLMMockResponse<{action:string}>} LLMRoutingResponse
+ */
 
 /**
  * @class LLMMockProvider
@@ -17,7 +29,12 @@ class LLMMockProvider {
 
     static DEFAULT_MODEL = 'mockmodel';
 
-    constructor () {
+    /**
+     *
+     * @param {LLMMockResponse[]} [mocks]
+     */
+    constructor (mocks = []) {
+        this._mocks = mocks || [];
         this._index = 0;
         this._sequence = [
             'lorem',
@@ -28,6 +45,26 @@ class LLMMockProvider {
         ];
     }
 
+    /**
+     *
+     * @param {string} preset
+     * @returns {LLMMessage}
+     */
+    _mockResponseForPreset (preset) {
+        const found = this._mocks.find((mock) => mock.preset === preset);
+
+        if (!found) {
+            return null;
+        }
+
+        return {
+            role: LLM.ROLE_ASSISTANT,
+            content: typeof found.content === 'object'
+                ? JSON.stringify(found.content)
+                : found.content
+        };
+    }
+
     /**
      * @param {LLMMessage[]} prompt
      * @param {LLMProviderOptions} [options]
@@ -65,6 +102,12 @@ class LLMMockProvider {
             };
         }
 
+        // simple for now
+        const mockResponse = this._mockResponseForPreset(options.preset || 'default');
+        if (mockResponse) {
+            return mockResponse;
+        }
+
         // const stats = prompt.reduce((o, m) => Object.assign(o, {
         //    [m.role]: (o[m.role] || 0) + 1
         // }), { system: 0, assistant: 0, user: 0 });