wingbot 3.35.0 → 3.36.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wingbot",
-  "version": "3.35.0",
+  "version": "3.36.1",
   "description": "Enterprise Messaging Bot Conversation Engine",
   "main": "index.js",
   "scripts": {
@@ -46,7 +46,7 @@
     "eslint-plugin-react": "^7.29.4",
     "graphql-markdown": "^6.0.0",
     "jsdoc-to-markdown": "^7.1.1",
-    "mocha": "^9.2.2",
+    "mocha": "^10.0.0",
     "nyc": "^15.1.0",
     "rimraf": "^3.0.2",
     "sinon": "^13.0.1",

package/src/Ai.js

@@ -40,6 +40,8 @@ let uq = 1;
 
 /** @typedef {import('./Request').IntentAction} IntentAction */
 /** @typedef {import('./Request')} Request */
+/** @typedef {import('./Responder')} Responder */
+/** @typedef {import('./wingbot/CachedModel').Result} Result */
 /** @typedef {import('./wingbot/CustomEntityDetectionModel').Phrases} Phrases */
 
 /**
@@ -203,6 +205,10 @@ class Ai {
         return model;
     }
 
+    get localEnhancement () {
+        return (1 - this.confidence) / 2;
+    }
+
     async processSetStateEntities (req, setState) {
         const keys = Object.keys(setState);
 
@@ -348,13 +354,13 @@ class Ai {
         const rules = this.matcher.preprocessRule(intent);
         const matcher = this._createIntentMatcher(rules, usedEntities);
 
-        return async (req) => {
+        return async (req, res) => {
             if (!req.isTextOrIntent()) {
                 return false;
             }
 
             if (!req.intents) {
-                await this._loadIntents(req);
+                await this._loadIntents(req, res);
             }
 
             const winningIntent = matcher(req);
@@ -523,9 +529,10 @@ class Ai {
     /**
      *
      * @param {Request} req
+     * @param {Responder} [res]
      * @returns {Promise}
      */
-    async preloadAi (req) {
+    async preloadAi (req, res = null) {
         if (req.supportsFeature(req.FEATURE_PHRASES)) {
             const model = this._getModelForRequest(req, false);
 
@@ -534,7 +541,7 @@ class Ai {
                     .catch(() => {});
             }
         }
-        return this._preloadIntent(req);
+        return this._preloadIntent(req, res);
     }
 
     /**
@@ -552,12 +559,43 @@ class Ai {
         return CustomEntityDetectionModel.getEmptyPhrasesObject();
     }
 
-    async _preloadIntent (req) {
+    /**
+     *
+     * @param {Request} req
+     * @param {Responder} res
+     * @param {Result} result
+     * @returns {void}
+     */
+    _setResultToReqRes (req, res, result) {
+        const { text = null, intents, entities = [] } = result;
+        Object.assign(req, { intents, entities, _anonymizedText: text });
+
+        if (!res) {
+            return;
+        }
+
+        const entitiesObj = (entities || []).reduce((o, { entity, value }) => {
+            const list = o[entity] || [];
+            list.push(value);
+            return Object.assign(o, { [entity]: list });
+        }, {});
+
+        res.setData({
+            '@': entitiesObj
+        });
+    }
+
+    /**
+     *
+     * @param {Request} req
+     * @param {Responder} [res]
+     * @returns {Promise}
+     */
+    async _preloadIntent (req, res = null) {
         const mockIntent = this._getMockIntent(req);
 
         if (mockIntent) {
-            req.intents = mockIntent.intents;
-            req.entities = mockIntent.entities;
+            this._setResultToReqRes(req, res, mockIntent);
             return;
         }
 
@@ -571,15 +609,15 @@ class Ai {
                 req.intents = [];
                 return;
             }
-            await this._loadIntents(req, model);
+            await this._loadIntents(req, res, model);
         } else {
             req.intents = [];
         }
     }
 
-    async _loadIntents (req, model = null) {
-        const { text = null, intents, entities = [] } = await this._queryModel(req, model);
-        Object.assign(req, { intents, entities, _anonymizedText: text });
+    async _loadIntents (req, res = null, model = null) {
+        const result = await this._queryModel(req, model);
+        this._setResultToReqRes(req, res, result);
     }
 
     async _queryModel (req, useModel = null) {

package/src/AiMatching.js

@@ -132,6 +132,12 @@ class AiMatching {
          * @type {number}
          */
         this.multiMatchGain = 1.2;
+
+        /**
+         * Score of a context entity within a conversation state
+         * (1 by default)
+         */
+        this.stateEntityScore = 1;
     }
 
     get redundantHandicap () {
@@ -480,6 +486,10 @@ class AiMatching {
         return winningIntent;
     }
 
+    _getMultiMatchGain (entitiesScore, matchedCount, fromState = 0) {
+        return (this.multiMatchGain * entitiesScore) ** (matchedCount - fromState);
+    }
+
     /**
      *
      * @private
@@ -505,7 +515,7 @@ class AiMatching {
         }
 
         const {
-            score: entitiesScore, handicap, matched, minScore
+            score: entitiesScore, handicap, matched, minScore, fromState
         } = this
             ._entityMatching(
                 wantedEntities,
@@ -516,13 +526,20 @@ class AiMatching {
                     : (x) => x
             );
 
+        // console.log({ entitiesScore, handicap, matched, minScore, requestIntent })
+
         const allOptional = wantedEntities.every((e) => e.optional);
         if (entitiesScore === 0 && !allOptional) {
             return { score: 0, entities: [] };
         }
 
-        const score = (Math.min(minScore + (handicap / 2), requestIntent.score) - handicap)
-            * ((this.multiMatchGain * entitiesScore) ** matched.length);
+        const normalizedScore = Math.min(minScore + (handicap / 2), requestIntent.score);
+        const scoreWithHandicap = normalizedScore - handicap;
+        const multiMatchGain = this._getMultiMatchGain(entitiesScore, matched.length, fromState);
+
+        const score = scoreWithHandicap * multiMatchGain;
+
+        // console.log({ IMS: score, normalizedScore, scoreWithHandicap, multiMatchGain });
 
         return {
             score,
@@ -537,7 +554,7 @@ class AiMatching {
      * @param {Entity[]} requestEntities
      * @param {object} [requestState]
      * @param {Function} [scoreFn]
-     * @returns {{score: number, handicap: number, matched: Entity[], minScore: number }}
+     * @returns {{score:number,handicap:number, matched:Entity[],minScore:number,fromState:number}}
      */
     _entityMatching (wantedEntities, requestEntities = [], requestState = {}, scoreFn = (x) => x) {
         const occurences = new Map();
@@ -546,6 +563,7 @@ class AiMatching {
         let handicap = 0;
         let sum = 0;
         let minScore = 1;
+        let fromState = 0;
 
         for (const wanted of wantedEntities) {
             const usedIndexes = occurences.has(wanted.entity)
@@ -579,9 +597,11 @@ class AiMatching {
                     requestEntity = {
                         value: requestState[`@${wanted.entity}`],
                         entity: wanted.entity,
-                        score: 1
+                        score: this.stateEntityScore
                     };
 
+                    fromState += 1;
+
                     matching = this._entityIsMatching(
                         wanted.op,
                         wanted.compare,
@@ -596,7 +616,7 @@ class AiMatching {
 
             if (!matching && !wanted.optional) {
                 return {
-                    score: 0, handicap: 0, matched: [], minScore
+                    score: 0, handicap: 0, matched: [], minScore, fromState
                 };
             }
 
@@ -636,11 +656,15 @@ class AiMatching {
             }
         }
 
-        handicap += (requestEntities.length - matched.length) * this.redundantEntityHandicap;
+        // console.log({ sum, handicap, rl: requestEntities.length, ml: matched.length });
+
+        // @todo - neni mozne, by doslo k negativnimu handicapu
+        handicap += (requestEntities.length + fromState - matched.length)
+            * this.redundantEntityHandicap;
         const score = matched.length === 0 ? 0 : sum / matched.length;
 
         return {
-            score, handicap, matched, minScore
+            score, handicap, matched, minScore, fromState
         };
     }
 

package/src/BotApp.js

@@ -248,7 +248,7 @@ class BotApp {
             };
         }
 
-        const sender = await this.createSender(senderId, pageId, message);
+        const sender = await this.createSender(senderId, pageId, message, secret, appId);
         const res = await this._processor.processMessage(message, pageId, sender, { appId });
         await this._processSenderResponses(sender, senderId, pageId, headers);
 
@@ -266,13 +266,15 @@ class BotApp {
      * @param {string} pageId
      * @param {object} [message]
      * @param {string|Promise<string>} [secret]
+     * @param {string} appId
      * @returns {Promise<BotAppSender>}
      */
     async createSender (
         senderId,
         pageId,
         message = defaultMsg(senderId, pageId),
-        secret = this._secret
+        secret = this._secret,
+        appId = this._appId
     ) {
         const useSecret = await Promise.resolve(secret);
 
@@ -282,7 +284,7 @@ class BotApp {
             ...this._returnSenderOptions,
             apiUrl: this._apiUrl,
             pageId,
-            appId: this._appId,
+            appId,
             secret: useSecret,
             mid: setResponseToMid,
             fetch: this._fetch,

package/src/Processor.js

@@ -541,7 +541,7 @@ class Processor extends EventEmitter {
                 }
             }
 
-            await Ai.ai.preloadAi(req);
+            await Ai.ai.preloadAi(req, res);
 
             // @deprecated backward compatibility
             const aByAi = req.actionByAi();

package/src/Request.js

@@ -1227,7 +1227,6 @@ class Request {
         // to match the local context intent
         const localRegexToMatch = this._getLocalPathRegexp();
 
-        const localEnhancement = (1 - Ai.ai.confidence) / 2;
         for (const gi of this.globalIntents.values()) {
             const pathMatches = localRegexToMatch && localRegexToMatch.exec(gi.action);
             if (gi.local && !pathMatches) {
@@ -1235,7 +1234,9 @@ class Request {
             }
             const intent = gi.matcher(this, null, true);
             if (intent !== null) {
-                const sort = intent.score + (pathMatches ? localEnhancement : 0);
+                const sort = intent.score + (pathMatches
+                    ? Ai.ai.localEnhancement
+                    : 0);
                 // console.log(sort, wi.intent);
                 aiActions.push({
                     ...gi,

package/src/utils/stateData.js

@@ -3,8 +3,19 @@
  */
 'use strict';
 
+/** @typedef {import('../Request')} Request */
+/** @typedef {import('../Responder')} Responder */
+
+/**
+ *
+ * @param {Request} req
+ * @param {Responder} res
+ * @param {object} configuration
+ * @returns {object}
+ */
 module.exports = function stateData (req, res = null, configuration = null) {
     const c = configuration || req.configuration;
+
     return {
         ...req.state,
         ...(res ? res.newState : {}),