wingbot 3.71.6 → 3.72.1

package/.github/workflows/deploy.yml

@@ -15,7 +15,7 @@ jobs:
 
     strategy:
       matrix:
-        node-version: [16.x]
+        node-version: [20.x]
 
     steps:
 
@@ -23,7 +23,7 @@ jobs:
         uses: actions/checkout@v2
 
       - name: Node.js ${{ matrix.node-version }} setup
-        uses: actions/setup-node@v2
+        uses: actions/setup-node@v3
         with:
           node-version: ${{ matrix.node-version }}
           cache: 'npm'

package/.github/workflows/pullRequest.yml

@@ -11,7 +11,7 @@ jobs:
 
     strategy:
       matrix:
-        node-version: [16.x]
+        node-version: [20.x]
 
     steps:
 
@@ -19,7 +19,7 @@ jobs:
         uses: actions/checkout@v2
 
       - name: Node.js ${{ matrix.node-version }} setup
-        uses: actions/setup-node@v2
+        uses: actions/setup-node@v3
         with:
           node-version: ${{ matrix.node-version }}
           cache: 'npm'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wingbot",
-  "version": "3.71.6",
+  "version": "3.72.1",
   "description": "Enterprise Messaging Bot Conversation Engine",
   "main": "index.js",
   "type": "commonjs",
@@ -58,7 +58,9 @@
     "compress-json": "^3.0.0",
     "deep-extend": "^0.6.0",
     "form-data": "^4.0.0",
-    "graphql": "^16.8.1",
+    "graphql": "^16.11.0",
+    "graphql-depth-limit": "^1.1.0",
+    "graphql-query-complexity": "^1.1.0",
     "jsonwebtoken": "^9.0.2",
     "node-fetch": "^2.6.7",
     "path-to-regexp": "^6.3.0",

package/src/Ai.js

@@ -41,8 +41,10 @@ let uq = 1;
 
 /** @typedef {import('./Request').IntentAction} IntentAction */
 /** @typedef {import('./Request')} Request */
+/** @typedef {import('./Request').TextAlternative} TextAlternative */
 /** @typedef {import('./Responder')} Responder */
 /** @typedef {import('./Router').Resolver} Resolver */
+/** @typedef {import('./utils/stateData').IStateRequest} IStateRequest */
 /** @typedef {import('./wingbot/CachedModel').Result} Result */
 /** @typedef {import('./wingbot/CustomEntityDetectionModel').Phrases} Phrases */
 /** @typedef {import('./wingbot/CustomEntityDetectionModel').EntityDetector} EntityDetector */
@@ -137,7 +139,7 @@ class Ai {
          * The prefix translator - for request-specific prefixes
          *
          * @param {string} defaultModel
-         * @param {Request} req
+         * @param {IStateRequest} req
          */
         this.getPrefix = (defaultModel, req) => req.state.lang || defaultModel; // eslint-disable-line
 
@@ -857,11 +859,22 @@ class Ai {
             .filter((alt) => alt.score >= this.sttScoreThreshold)
             .slice(0, this.sttMaxAlternatives);
 
-        const altMax = Math.max(0, ...texts.map((t) => t.score));
+        return this._queryModelWithTexts(model, texts, req);
+    }
+
+    /**
+     *
+     * @param {CustomEntityDetectionModel} model
+     * @param {TextAlternative[]} texts
+     * @param {Request} [req]
+     * @returns {Promise<Result>}
+     */
+    async _queryModelWithTexts (model, texts, req = null) {
         const altKoef = (1 - this.confidence);
+        const altMax = Math.max(0, ...texts.map((t) => t.score));
 
         const results = await Promise.all(
-            texts.map(({ text, score }) => model
+            texts.map(({ text, score = 1 }) => model
                 .resolve(this.textFilter(text), req)
                 .then((res) => ({
                     ...res,
@@ -910,6 +923,34 @@ class Ai {
         };
     }
 
+    /**
+     *
+     * @param {string} text
+     * @param {string|IStateRequest} langOrReq
+     * @returns {Promise<Result>}
+     */
+    async queryModel (text, langOrReq = this.DEFAULT_PREFIX) {
+        let model;
+
+        if (typeof langOrReq === 'string') {
+            model = this._keyworders.has(langOrReq)
+                ? this._keyworders.get(langOrReq)
+                : this._keyworders.get(this.DEFAULT_PREFIX);
+        } else {
+            model = this._getModelForRequest(langOrReq);
+        }
+
+        if (!model) {
+            return {
+                text,
+                intents: [],
+                entities: []
+            };
+        }
+
+        return this._queryModelWithTexts(model, [{ text, score: 1 }]);
+    }
+
     /**
      *
      * @param {IntentAction[]} aiActions

package/src/AiMatching.js

@@ -3,11 +3,12 @@
  */
 'use strict';
 
-const { replaceDiacritics } = require('./utils/tokenizer');
+const { replaceDiacritics, tokenize } = require('./utils/tokenizer');
 const { vars } = require('./utils/stateVariables');
 const stateData = require('./utils/stateData');
 
 /** @typedef {import('handlebars')} Handlebars */
+/** @typedef {import('./Ai').Result} Result */
 
 /** @type {Handlebars} */
 let handlebars;
@@ -66,16 +67,18 @@ const COMPARE = {
 
 /**
  * @typedef {object} Entity
- * @param {string} entity
- * @param {string} value
- * @param {number} score
+ * @prop {string} entity
+ * @prop {string} value
+ * @prop {number} score
+ * @prop {number} [start]
+ * @prop {number} [end]
  */
 
 /**
  * @typedef {object} Intent
- * @param {string} [intent]
- * @param {number} score
- * @param {Entity[]} [entities]
+ * @prop {string} [intent]
+ * @prop {number} score
+ * @prop {Entity[]} [entities]
  */
 
 /**
@@ -461,35 +464,35 @@ class AiMatching {
     }
 
     /**
-     * Calculate a matching score of preprocessed rule against the request
      *
-     * @param {AIRequest} req
+     * @param {string} text
      * @param {PreprocessorOutput} rule
-     * @param {boolean} [stateless]
-     * @param {Entity[]} [reqEntities]
-     * @param {boolean} [noEntityThreshold]
+     * @param {Result} nlpResult
+     * @param {{}} state
      * @returns {Intent|null}
      */
-    match (req, rule, stateless = false, reqEntities = req.entities, noEntityThreshold = false) {
-        const { regexps, intents, entities } = rule;
+    matchText (text, rule, nlpResult, state = {}) {
+        return this._match(text, rule, state, nlpResult, true);
+    }
 
-        const noIntentHandicap = req.intents.length === 0 ? 0 : this.redundantIntentHandicap;
-        const regexpScore = this._matchRegexp(req, regexps, noIntentHandicap);
-        const textLength = req.text().trim().length;
+    _match (text, rule, useState, nlpResult, stateless = false, noEntityThreshold = false) {
+        let state = useState;
 
-        let useState;
-        if (stateless || intents.length === 0) {
-            useState = Object.entries(stateData(req))
-                .reduce((o, [k, v]) => {
-                    if (k.startsWith('@')) {
-                        return o;
-                    }
-                    return Object.assign(o, { [k]: v });
-                }, {});
-        } else {
-            useState = stateData(req);
+        if (stateless) {
+            state = Object.fromEntries(
+                Object.entries(state)
+                    .filter(([k]) => !k.startsWith('@'))
+            );
         }
 
+        const { regexps, intents, entities } = rule;
+        const { entities: reqEntities = [], intents: reqIntents = [] } = nlpResult;
+        const tokenized = tokenize(text) || text.trim();
+
+        const noIntentHandicap = reqIntents.length === 0 ? 0 : this.redundantIntentHandicap;
+        const regexpScore = this._matchRegexp(text, tokenized, regexps, noIntentHandicap);
+        const textLength = text.length;
+
         if (regexpScore !== 0 || (intents.length === 0 && regexps.length === 0)) {
 
             if (entities.length === 0) {
@@ -511,7 +514,7 @@ class AiMatching {
                     textLength,
                     entities,
                     reqEntities,
-                    useState,
+                    state,
                     undefined,
                     undefined,
                     noEntityThreshold
@@ -563,7 +566,7 @@ class AiMatching {
             };
         }
 
-        if (!req.intents || req.intents.length === 0) {
+        if (reqIntents.length === 0) {
             return null;
         }
 
@@ -572,15 +575,15 @@ class AiMatching {
         intents
             .reduce((total, wanted) => {
                 let max = total;
-                for (const requestIntent of req.intents) {
+                for (const requestIntent of reqIntents) {
                     const { score, entities: matchedEntities } = this
                         ._intentMatchingScore(
                             textLength,
                             wanted,
                             requestIntent,
                             entities,
-                            req,
-                            useState,
+                            reqEntities,
+                            state,
                             noEntityThreshold
                         );
 
@@ -602,6 +605,27 @@ class AiMatching {
         return winningIntent;
     }
 
+    /**
+     * Calculate a matching score of preprocessed rule against the request
+     *
+     * @param {AIRequest} req
+     * @param {PreprocessorOutput} rule
+     * @param {boolean} [stateless]
+     * @param {Entity[]} [reqEntities]
+     * @param {boolean} [noEntityThreshold]
+     * @returns {Intent|null}
+     */
+    match (req, rule, stateless = false, reqEntities = req.entities, noEntityThreshold = false) {
+        const { intents } = rule;
+
+        const state = stateData(req);
+
+        return this._match(req.text(), rule, state, {
+            intents: req.intents,
+            entities: reqEntities
+        }, stateless || intents.length === 0, noEntityThreshold);
+    }
+
     _getMultiMatchGain (entitiesScore, matchedCount, fromState = 0) {
         return (this.multiMatchGain * entitiesScore) ** Math.max(matchedCount - fromState, 0);
     }
@@ -613,7 +637,7 @@ class AiMatching {
      * @param {string} wantedIntent
      * @param {Intent} requestIntent
      * @param {EntityExpression[]} wantedEntities
-     * @param {AIRequest} req
+     * @param {Entity[]} reqEntities
      * @param {object} useState
      * @param {boolean} [noEntityThreshold]
      * @returns {{score:number,entities:Entity[]}}
@@ -623,7 +647,7 @@ class AiMatching {
         wantedIntent,
         requestIntent,
         wantedEntities,
-        req,
+        reqEntities,
         useState,
         noEntityThreshold = false
     ) {
@@ -631,7 +655,7 @@ class AiMatching {
             return { score: 0, entities: [] };
         }
 
-        const useEntities = requestIntent.entities || req.entities;
+        const useEntities = requestIntent.entities || reqEntities;
 
         if (wantedEntities.length === 0) {
             return {
@@ -651,7 +675,7 @@ class AiMatching {
                 requestIntent.entities
                     ? (x) => Math.atan((x - 0.76) * 40) / Math.atan((1 - 0.76) * 40)
                     : (x) => x,
-                req.entities,
+                reqEntities,
                 noEntityThreshold
             );
 
@@ -941,18 +965,20 @@ class AiMatching {
 
     /**
      *
-     * @param {AIRequest} req
+     * @param {string} text
+     * @param {string} tokenized
      * @param {RegexpComparator[]} regexps
      * @param {number} noIntentHandicap
      * @returns {number}
      */
-    _matchRegexp (req, regexps, noIntentHandicap) {
+    _matchRegexp (text, tokenized, regexps, noIntentHandicap) {
         if (regexps.length === 0) {
             return 0;
         }
 
         const scores = regexps.map(({ r, t, f }) => {
-            const m = req.text(t).match(r);
+            const txt = t ? tokenized : text;
+            const m = txt.match(r);
 
             if (!m) {
                 return 0;

package/src/BotAppSender.js

@@ -41,12 +41,12 @@ class BotAppSender extends ReturnSender {
     /**
      *
      * @param {SenderOptions} options
-     * @param {string} userId
+     * @param {string} senderId
      * @param {object} incommingMessage
      * @param {ChatLogStorage} logger - console like logger
      */
-    constructor (options, userId, incommingMessage, logger = null) {
-        super(options, userId, incommingMessage, logger);
+    constructor (options, senderId, incommingMessage, logger = null) {
+        super(options, senderId, incommingMessage, logger);
 
         this.waits = true;
 
@@ -98,14 +98,16 @@ class BotAppSender extends ReturnSender {
      * @param {Buffer} data
      * @param {string} contentType
      * @param {string} fileName
+     * @param {string} [senderId]
      * @returns {Promise<UploadResult>}
      */
-    async upload (data, contentType, fileName) {
+    async upload (data, contentType, fileName, senderId = this._senderId) {
         const formData = new FormData();
 
         const nonce = Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(36).padEnd(11, '0');
 
         formData.append('nonce', nonce);
+        formData.append('senderId', senderId || '');
         formData.append('f0', data, { filename: fileName, contentType });
 
         const [token, agent] = await Promise.all([

package/src/BuildRouter.js

@@ -162,6 +162,7 @@ const DUMMY_ROUTE = { id: 0, path: null, resolvers: [] };
  * @prop {Block[]} [blocks]
  * @prop {NestedLinksMapFactory} [nestedLinksMapFactory]
  * @prop {object} [BuildRouter]
+ * @prop {Ai} [ai]
  * @prop {string|number} [resolverId] - only for text messages with random characters
  */
 
@@ -928,6 +929,7 @@ class BuildRouter extends Router {
         return resolvers.map((resolver, i) => {
 
             const context = {
+                ai: Ai.ai,
                 ...this._resolvedContext,
                 isLastIndex: lastIndex === i && !buildInfo.expectedToAddResolver,
                 isLastMessage: lastMessageIndex === i && !buildInfo.notLastMessage,

package/src/LLM.js

@@ -3,16 +3,72 @@
  */
 'use strict';
 
+const { getSetState } = require('./utils/getUpdate');
 const { PHONE_REGEX, EMAIL_REGEX } = require('./systemEntities/regexps');
+const getCondition = require('./utils/getCondition');
+const stateData = require('./utils/stateData');
+const Ai = require('./Ai');
+// const getCondition = require('./utils/getCondition');
 
 /** @typedef {import('./Responder')} Responder */
+/** @typedef {import('./AiMatching').PreprocessorOutput} PreprocessorOutput */
+/** @typedef {import('./Request')} Request */
 /** @typedef {import('./Responder').Persona} Persona */
 /** @typedef {import('./Router').BaseConfiguration} BaseConfiguration */
 /** @typedef {import('./LLMSession').LLMMessage<any>} LLMMessage */
 /** @typedef {import('./LLMSession').ToolCall} ToolCall */
 /** @typedef {import('./LLMSession').LLMRole} LLMRole */
+/** @typedef {import('./LLMSession').FilterScope} FilterScope */
 /** @typedef {import('./LLMSession')} LLMSession */
 /** @typedef {import('./transcript/transcriptFromHistory').Transcript} Transcript */
+/** @typedef {import('./utils/getCondition').ConditionDefinition} ConditionDefinition */
+/** @typedef {import('./utils/getCondition').ConditionContext} ConditionContext */
+/** @typedef {import('./utils/stateData').IStateRequest} IStateRequest */
+
+/** @typedef {string|'_DISCARD'} EvaluationRuleAction */
+
+/**
+ * @typedef {object} EvaluationRuleData
+ * @prop {EvaluationRuleAction} [action]
+ * @prop {object} [setState]
+ */
+
+/**
+ * @typedef {object} RuleDefinitionData
+ * @prop {string[]} aiTags
+ * @prop {EvaluationRuleAction} [targetRouteId]
+ */
+
+/**
+ * @typedef {EvaluationRuleData & RuleDefinitionData & ConditionDefinition} EvaluationRule
+ */
+
+/**
+ * @typedef {object} PrepocessedRuleData
+ * @prop {Function} condition
+ * @prop {PreprocessorOutput} rule
+ */
+
+/**
+ * @typedef {EvaluationRuleData & PrepocessedRuleData} PreprocessedRule
+ */
+
+/**
+ * @typedef {object} RuleScore
+ * @prop {number} score
+ */
+
+/**
+ * @typedef {RuleScore & PreprocessedRule} RuleWithScore
+ */
+
+/**
+ * @typedef {object} EvaluationResult
+ * @prop {string} action
+ * @prop {boolean} discard
+ * @prop {RuleWithScore[]} results
+ * @prop {object} setState
+ */
 
 /**
  * @callback LLMChatProviderPrompt
@@ -82,6 +138,13 @@ class LLM {
 
     static GPT_FLAG = 'gpt';
 
+    /** @type {FilterScope} */
+    static FILTER_SCOPE_CONVERSATION = 'conversation';
+
+    static EVALUATION_ACTIONS = {
+        DISCARD: '_DISCARD'
+    };
+
     /** @type {AnonymizeRegexp[]} */
     static anonymizeRegexps = [
         { replacement: '@PHONE', regex: new RegExp(PHONE_REGEX.source, 'g') },
@@ -91,8 +154,9 @@ class LLM {
     /**
      *
      * @param {LLMConfiguration} configuration
+     * @param {Ai} ai
      */
-    constructor (configuration) {
+    constructor (configuration, ai) {
         const { provider, ...rest } = configuration;
 
         this._configuration = {
@@ -107,6 +171,25 @@ class LLM {
 
         /** @type {LLMChatProvider} */
         this._provider = provider;
+
+        this._ai = ai;
+
+        /** @type {LLMMessage} */
+        this._lastResult = null;
+    }
+
+    /**
+     * @returns {Ai}
+     */
+    get ai () {
+        return this._ai;
+    }
+
+    /**
+     * @returns {LLMMessage}
+     */
+    get lastResult () {
+        return this._lastResult;
     }
 
     /**
@@ -148,7 +231,7 @@ class LLM {
             ...options
         };
 
-        const prompt = session.toArray();
+        const prompt = session.toArray(true);
         const result = await this._provider.requestChat(prompt, opts);
         this._logPrompt(prompt, result);
         return result;
@@ -160,6 +243,7 @@ class LLM {
      * @param {LLMMessage} result
      */
     _logPrompt (prompt, result) {
+        this._lastResult = result;
         this._configuration.logger.logPrompt({
             prompt, result
         });
@@ -188,6 +272,103 @@ class LLM {
         }));
     }
 
+    /**
+     *
+     * @param {EvaluationRule[]} rules
+     * @param {ConditionContext} [context]
+     * @returns {PreprocessedRule[]}
+     */
+    static preprocessEvaluationRules (rules, context = {}) {
+        const {
+            linksMap = new Map(),
+            ai = Ai.ai
+        } = context;
+
+        return rules.map((evalRule) => {
+            const { aiTags, targetRouteId, ...rest } = evalRule;
+
+            const condition = getCondition(rest, context);
+            const rule = ai.matcher.preprocessRule(aiTags);
+
+            let { action = null } = evalRule;
+
+            if (!action && targetRouteId && linksMap.has(targetRouteId)) {
+                action = linksMap.get(targetRouteId);
+            }
+
+            return {
+                ...rest,
+                condition,
+                rule
+            };
+        });
+    }
+
+    /**
+     * Returns all actions, which has been recognized
+     * with higher score than threshold, but
+     *
+     * - _DISCARD action discards any other rules (will return all relevant _DISCARD actions)
+     * - only the TOP ranked "interaction" action will be returned
+     * - actions will come in THE SAME order, so the "setState" will be applied in the same order
+     *
+     *
+     * @param {LLMMessage|string} result
+     * @param {PreprocessedRule[]} rules
+     * @param {IStateRequest} req
+     * @param {Responder} res
+     * @returns {Promise<EvaluationResult>}
+     */
+    async evaluateResultWithRules (result, rules, req, res) {
+        const text = typeof result === 'string' ? result : result.content;
+        const nlpResult = await this._ai.queryModel(text, req);
+        const state = stateData(req, res);
+
+        let topRankedAction = null;
+        let topActionScore = 0;
+        let discard = false;
+        const setState = {};
+
+        const sAct = Object.values(LLM.EVALUATION_ACTIONS);
+
+        const results = rules
+            .filter((rule) => rule.condition(req, res))
+            .map((rule) => {
+                const matched = this._ai.matcher
+                    .matchText(text, rule.rule, nlpResult, state);
+
+                if (!matched || matched.score < this._ai.threshold) {
+                    return null;
+                }
+
+                if (rule.action === LLM.EVALUATION_ACTIONS.DISCARD) {
+                    discard = true;
+                } else if (rule.action && topActionScore < matched.score) {
+                    topRankedAction = rule.action;
+                    topActionScore = matched.score;
+                }
+
+                return {
+                    ...rule,
+                    score: matched.score
+                };
+            })
+            .filter((rule) => rule !== null
+                && (!discard || rule.action === LLM.EVALUATION_ACTIONS.DISCARD)
+                && (!rule.action || rule.action === topRankedAction || sAct.includes(rule.action)));
+
+        results.forEach((rule) => {
+            Object.assign(setState, getSetState(rule.setState, req, res, setState));
+        });
+
+        return {
+            setState,
+            results,
+            discard,
+            action: discard ? null : topRankedAction
+        };
+    }
+
 }
 
 module.exports = LLM;