wingbot 3.24.1 → 3.24.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wingbot",
-  "version": "3.24.1",
+  "version": "3.24.5",
   "description": "Enterprise Messaging Bot Conversation Engine",
   "main": "index.js",
   "scripts": {

package/src/Ai.js

@@ -363,7 +363,6 @@ class Ai {
             return null;
         }
 
-        const aboveConfidence = winningIntent.score >= this.confidence;
         const usedEntities = this.matcher.parseEntitiesFromIntentRule(intent, true);
         const setState = this._getSetStateForEntities(
             usedEntities,
@@ -372,10 +371,56 @@ class Ai {
             req.state
         );
 
+        const alterScoreMax = (1 - ((1 - this.confidence) / 2));
+        const alterEntities = winningIntent.entities
+            .filter((e) => alterScoreMax >= e.score && e.alternatives && e.alternatives.length > 0);
+
+        let alternatives = [];
+        if (alterEntities.length === 1) {
+            const [alterEntity] = alterEntities;
+            alternatives = alterEntity.alternatives
+                .map((alternative) => {
+                    if (alternative.value === alterEntity.value
+                        && alternative.entity === alterEntity.entity) {
+                        return null;
+                    }
+                    const reqEntities = req.entities
+                        .map((reqEntity) => {
+                            if (reqEntity.entity === alterEntity.entity
+                                && reqEntity.value === alterEntity.value) {
+
+                                return alternative;
+                            }
+                            return reqEntity;
+                        });
+
+                    const winner = this.matcher.match(req, rules, stateless, reqEntities);
+
+                    if (!winner || winner.score < this.threshold) {
+                        return null;
+                    }
+
+                    const alterSetState = this._getSetStateForEntities(
+                        this.matcher.parseEntitiesFromIntentRule(intent, true),
+                        winner.entities,
+                        reqEntities,
+                        req.state
+                    );
+
+                    return {
+                        ...winner,
+                        setState: alterSetState,
+                        aboveConfidence: winner.score >= this.confidence
+                    };
+                })
+                .filter((alt) => alt !== null);
+        }
+
         return {
             ...winningIntent,
             setState,
-            aboveConfidence
+            aboveConfidence: winningIntent.score >= this.confidence,
+            alternatives
         };
     }
 
@@ -570,13 +615,29 @@ class Ai {
     /**
      *
      * @param {IntentAction[]} aiActions
+     * @param {boolean} [forQuickReplies]
      * @returns {boolean}
      */
-    shouldDisambiguate (aiActions) {
-        if (aiActions.length === 0 || aiActions[0].aboveConfidence === false) {
+    shouldDisambiguate (aiActions, forQuickReplies = false) {
+        if (aiActions.length === 0
+            || aiActions[0].aboveConfidence === false
+            || (forQuickReplies && !aiActions[0].hasAiTitle)) {
+
             return false;
         }
 
+        // if (aiActions[0].intent) {
+        //     const { entities = [] } = aiActions[0].intent;
+        //     const [{ score = 0, alternatives = [] } = {}] = entities;
+
+        //     if (entities.length === 1
+        //         && score < (1 - ((1 - this.confidence) / 2))
+        //         && alternatives.length) {
+
+        //         return true;
+        //     }
+        // }
+
         // there will be no winner, if there are two different intents
         if (aiActions.length > 1 && aiActions[1].aboveConfidence !== false) {
 
@@ -588,14 +649,27 @@ class Ai {
             const margin = 1 - (secondScore / firstScore);
             const bothHaveTitle = first.title && second.title;
             const similarScore = margin < (1 - Ai.ai.confidence);
+            const hasAititles = !forQuickReplies || second.hasAiTitle;
 
-            const intentIsNotTheSame = !first.intent || !second.intent
-                || !first.intent.intent
-                || first.intent.intent !== second.intent.intent;
+            let intentsDiffers = true;
+            if (first.intent && second.intent && first.intent.intent === second.intent.intent) {
+                let { entities: firstEntities = [] } = first.intent;
+                let { entities: secondEntities = [] } = second.intent;
+
+                if (firstEntities.length > secondEntities.length) {
+                    [firstEntities, secondEntities] = [secondEntities, firstEntities];
+                }
+
+                const entitiesDiffers = secondEntities.some((f) => !firstEntities
+                    .some((s) => s.entity === f.entity && s.value === f.value));
+
+                intentsDiffers = entitiesDiffers;
+            }
 
             if (bothHaveTitle
                 && similarScore
-                && intentIsNotTheSame) {
+                && hasAititles
+                && intentsDiffers) {
 
                 return true;
             }

package/src/AiMatching.js

@@ -356,10 +356,11 @@ class AiMatching {
      *
      * @param {AIRequest} req
      * @param {PreprocessorOutput} rule
-     * @param {boolean} stateless
+     * @param {boolean} [stateless]
+     * @param {Entity[]} [reqEntities]
      * @returns {Intent|null}
      */
-    match (req, rule, stateless = false) {
+    match (req, rule, stateless = false, reqEntities = req.entities) {
         const { regexps, intents, entities } = rule;
 
         const noIntentHandicap = req.intents.length === 0 ? 0 : this.redundantIntentHandicap;
@@ -371,7 +372,7 @@ class AiMatching {
                 if (regexpScore === 0) {
                     return null;
                 }
-                const handicap = req.entities.length * this.redundantEntityHandicap;
+                const handicap = reqEntities.length * this.redundantEntityHandicap;
                 return {
                     intent: null,
                     entities: [],
@@ -381,7 +382,7 @@ class AiMatching {
             const { score, handicap, matched } = this
                 ._entityMatching(
                     entities,
-                    req.entities,
+                    reqEntities,
                     stateless || intents.length === 0
                         ? {}
                         : req.state

package/src/Request.js

@@ -42,6 +42,7 @@ function makeTimestamp () {
  * @prop {string} entity
  * @prop {string} value
  * @prop {number} score
+ * @prop {Entity[]} [alternatives]
  */
 
 /**
@@ -70,6 +71,7 @@ function makeTimestamp () {
  * @prop {object} [setState]
  * @prop {boolean} [winner]
  * @prop {string|Function} [title]
+ * @prop {boolean} [hasAiTitle]
  * @prop {object} meta
  * @prop {string} [meta.targetAppId]
  * @prop {string|null} [meta.targetAction]
@@ -320,6 +322,7 @@ class Request {
         }
 
         const text = this.text();
+        const knownTexts = new Set();
 
         return (aiActions || this._aiActions)
             .filter((a) => a.title)
@@ -336,16 +339,22 @@ class Request {
 
                 const entities = intent.entities || [];
 
-                const templateData = {
+                let templateData = {
                     ...stateData(this),
                     ...getSetState(setState || {}, this),
                     intent: intent.intent,
-                    entities,
-                    ...entities.reduceRight((o, e) => ({
-                        ...o,
-                        [`@${e.entity}`]: e.value
-                    }), {})
+                    entities
                 };
+                Object.keys(templateData)
+                    .forEach((key) => {
+                        if (key.match(/^@/)) {
+                            delete templateData[key];
+                        }
+                    });
+                templateData = entities.reduceRight((o, e) => ({
+                    ...o,
+                    [`@${e.entity}`]: e.value
+                }), templateData);
 
                 const textTemplate = typeof title === 'function'
                     ? title
@@ -355,6 +364,10 @@ class Request {
                     title: textTemplate(templateData),
                     action: overrideAction || action,
                     templateData,
+                    ...entities.reduceRight((o, e) => ({
+                        ...o,
+                        [`@${e.entity}`]: e.value
+                    }), {}),
                     data: {
                         ...data,
                         _senderMeta: {
@@ -369,6 +382,13 @@ class Request {
                 if (match) Object.assign(res, { match });
 
                 return res;
+            })
+            .filter((qr) => {
+                if (knownTexts.has(qr.title)) {
+                    return false;
+                }
+                knownTexts.add(qr.title);
+                return true;
             });
     }
 
@@ -1064,7 +1084,7 @@ class Request {
         }
 
         if (!res && this.state._expectedKeywords) {
-            res = this._actionByExpectedKeywords();
+            res = this._actionByExpectedKeywords(this.state._expected);
         }
 
         if (!res && this.state._expected) {
@@ -1225,17 +1245,23 @@ class Request {
         return aiActions[0];
     }
 
-    _actionByExpectedKeywords () {
-        let res = null;
+    _actionByExpectedKeywords (expected) {
+        if (!this.state._expectedKeywords) {
+            return null;
+        }
 
-        if (this.state._expectedKeywords) {
-            const [payload] = this._resolveQuickReplyActions();
-            if (payload && payload.aboveConfidence) {
-                res = parseActionPayload(payload);
-            }
+        const actions = this._resolveQuickReplyActions();
+
+        if (expected && Ai.ai.shouldDisambiguate(actions, true)) {
+            return parseActionPayload(expected);
         }
 
-        return res;
+        const [payload] = actions;
+        if (!payload || !payload.aboveConfidence) {
+            return null;
+        }
+
+        return parseActionPayload(payload);
     }
 
     _resolveQuickReplyActions () {

package/src/Responder.js

@@ -596,7 +596,7 @@ class Responder {
         }
 
         if (aiTitle) {
-            Object.assign(push, { title: aiTitle });
+            Object.assign(push, { title: aiTitle, hasAiTitle: true });
         }
 
         this._addExpectedIntents([push]);

package/src/Tester.js

@@ -158,6 +158,12 @@ class Tester {
      * @returns {Promise<any>}
      */
     async processMessage (message, senderId = this.senderId, pageId = this.pageId, data = {}) {
+        if (!message.sender && !message.optin) {
+            Object.assign(message, {
+                sender: { id: senderId }
+            });
+        }
+
         const messageSender = new ReturnSender({}, senderId, message, this.senderLogger);
         messageSender.simulatesOptIn = true;
 

package/src/utils/getUpdate.js

@@ -168,8 +168,13 @@ function getSetState (setState = {}, req, res = null, useState = null) {
                     if (entity && (!rear || req.entities.some((e) => e.entity === entity))) {
                         values = req.entities.filter((e) => e.entity === entity)
                             .map((e) => e.value);
+                        if (values.length === 0 && useState && useState[`@${entity}`]) {
+                            values = [useState[`@${entity}`]];
+                        }
                     } else if (variable) {
                         values = toArray(getValue(variable, state));
+                    } else if (value === '' || value === null || value === undefined) {
+                        values = [];
                     } else {
                         const useValue = typeof value === 'string'
                             ? handlebars.compile(value)(stateData(req, res))

package/src/utils/quickReplies.js

@@ -11,6 +11,26 @@ const { checkSetState } = require('./stateVariables');
 /** @typedef {import('../Request')} Request */
 /** @typedef {import('../Ai')} Ai */
 
+/**
+ * @typedef {object} ExpectedKeyword
+ * @prop {string} action
+ * @prop {string} title
+ * @prop {null|string|string[]} match
+ * @prop {object} data
+ * @prop {boolean} [hasAiTitle]
+ * @prop {object} [setState]
+ */
+
+/**
+ *
+ * @param {string} action
+ * @param {string} title
+ * @param {RegExp|string|string[]} [matcher]
+ * @param {object} [payloadData]
+ * @param {object} [setState]
+ * @param {string} [aiTitle]
+ * @returns {ExpectedKeyword}
+ */
 function makeExpectedKeyword (
     action, title, matcher = null, payloadData = {}, setState = null, aiTitle = null
 ) {
@@ -37,7 +57,7 @@ function makeExpectedKeyword (
     };
 
     if (setState) Object.assign(ret, { setState });
-    if (aiTitle) Object.assign(ret, { title: aiTitle });
+    if (aiTitle) Object.assign(ret, { title: aiTitle, hasAiTitle: true });
 
     return ret;
 }
@@ -229,13 +249,33 @@ function makeQuickReplies (replies, path = '', translate = (w) => w, quickReplyC
     };
 }
 
+/** @typedef {import('../Request').Intent} Intent */
+
+/**
+ * @typedef {object} QuickReplyAction
+ * @prop {boolean} aboveConfidence
+ *
+ * @prop {string} action
+ * @prop {string} title
+ * @prop {null|string|string[]} match
+ * @prop {object} data
+ * @prop {number} score
+ * @prop {number} sort
+ *
+ * @prop {string} [title]
+ * @prop {object} [setState]
+ *
+ * @prop {string[]} [_aiKeys]
+ * @prop {Intent} [intent]
+ */
+
 /**
  *
  * @ignore
- * @param {object[]} expectedKeywords
+ * @param {ExpectedKeyword[]} expectedKeywords
  * @param {Request} req
  * @param {Ai} ai
- * @returns {object[]}
+ * @returns {QuickReplyAction[]}
  */
 function quickReplyAction (expectedKeywords, req, ai) {
     const text = req.text();
@@ -249,6 +289,8 @@ function quickReplyAction (expectedKeywords, req, ai) {
             return [
                 {
                     ...lowerCaseMatch[0],
+                    score: 1,
+                    sort: 1,
                     aboveConfidence: true
                 }
             ];
@@ -261,6 +303,8 @@ function quickReplyAction (expectedKeywords, req, ai) {
             return exactMatch
                 .map((e) => ({
                     ...e,
+                    score: 1,
+                    sort: 1,
                     aboveConfidence: true
                 }));
         }
@@ -280,16 +324,31 @@ function quickReplyAction (expectedKeywords, req, ai) {
                     ...keyword,
                     intent,
                     score,
+                    sort: score,
                     _aiKeys,
                     aboveConfidence,
                     setState: keyword.setState
                         ? { ...keyword.setState, ...setState }
                         : { ...setState }
                 });
+
+                for (const alternative of intent.alternatives) {
+                    found.push({
+                        ...keyword,
+                        intent: alternative,
+                        score: alternative.score,
+                        sort: alternative.score - 0.0001,
+                        _aiKeys: Object.keys(alternative.setState),
+                        aboveConfidence: alternative.aboveConfidence,
+                        setState: keyword.setState
+                            ? { ...keyword.setState, ...alternative.setState }
+                            : { ...alternative.setState }
+                    });
+                }
             }
         });
 
-    found.sort(({ score: a }, { score: z }) => z - a);
+    found.sort(({ sort: a }, { sort: z }) => z - a);
 
     return found;
 }