wingbot 3.42.0 → 3.43.0

package/package.json

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

package/plugins/ai.wingbot.slotsContinue/plugin.js

@@ -11,10 +11,12 @@ const { vars } = require('../../src/utils/stateVariables');
 /**
  * @param {object} params
  * @param {string} [params.skip]
+ * @param {string} [params.fill]
  * @returns {SlotsResolver}
  */
 function slotsContinue ({
-    skip
+    skip,
+    fill
 }) {
 
     /**
@@ -39,6 +41,10 @@ function slotsContinue ({
             .split(',')
             .map((e) => e.trim());
 
+        const fillEntities = compileWithState(req, res, fill)
+            .split(',')
+            .map((e) => e.trim());
+
         const clear = {};
 
         slotState = slotState.map((s) => {
@@ -52,7 +58,7 @@ function slotsContinue ({
                 return { ...s, s: StepState.INITIALIZED };
             }
 
-            return s.e === step.entity
+            return s.e === step.entity || fillEntities.includes(s.e)
                 ? { ...s, s: StepState.FILLED }
                 : s;
         });

package/plugins/plugins.json

@@ -415,7 +415,7 @@
                         {
                             "type": "select",
                             "name": "type",
-                            "label": "Question",
+                            "label": "Type",
                             "options": [
                                 { "label": "Required", "value": "req" },
                                 { "label": "Multi value", "value": "mul" },
@@ -454,6 +454,18 @@
                     "validations": [
                         { "type": "regexp", "value": "^\\s*@[a-zA-Z0-9-]+\\s*(,\\s*@[a-zA-Z0-9-]+\\s*)*$", "message": "the entity for the slot filling should be valid" }
                     ]
+                },
+                {
+                    "name": "fill",
+                    "label": "Skip entity (mark as filled)",
+                    "type": "text",
+                    "validations": [
+                        {
+                            "type": "regexp",
+                            "value": "^(\\s*@[a-zA-Z0-9-]+\\s*,?)*$",
+                            "message": "the entity to skip should be valid"
+                        }
+                    ]
                 }
             ],
             "items": [

package/src/Ai.js

@@ -7,12 +7,15 @@ const { WingbotModel } = require('./wingbot');
 const AiMatching = require('./AiMatching');
 const { vars } = require('./utils/stateVariables');
 const { deepEqual } = require('./utils/deepMapTools');
+const systemEntities = require('./systemEntities');
 const CustomEntityDetectionModel = require('./wingbot/CustomEntityDetectionModel');
 
 const DEFAULT_PREFIX = 'default';
 
 let uq = 1;
 
+/** @typedef {import('./AiMatching').Compare} Compare */
+
 /**
  * @typedef {object} EntityExpression
  * @prop {string} entity - the requested entity
@@ -43,6 +46,8 @@ let uq = 1;
 /** @typedef {import('./Responder')} Responder */
 /** @typedef {import('./wingbot/CachedModel').Result} Result */
 /** @typedef {import('./wingbot/CustomEntityDetectionModel').Phrases} Phrases */
+/** @typedef {import('./wingbot/CustomEntityDetectionModel').EntityDetector} EntityDetector */
+/** @typedef {import('./wingbot/CustomEntityDetectionModel').DetectorOptions} DetectorOptions */
 
 /**
  * @class Ai
@@ -50,8 +55,20 @@ let uq = 1;
 class Ai {
 
     constructor () {
+        /**
+         * @private
+         * @type {Map<string,CustomEntityDetectionModel>}
+         */
         this._keyworders = new Map();
 
+        /**
+         * @private
+         * @type {Map<string,[string,EntityDetector|RegExp,DetectorOptions]>}
+         */
+        this._detectors = new Map(
+            systemEntities.map((a) => [a[0], a])
+        );
+
         /**
          * Upper threshold - for match method and for navigate method
          *
@@ -157,29 +174,86 @@ class Ai {
     /**
      * Registers Wingbot AI model
      *
-     * @template T
+     * @template {CustomEntityDetectionModel} T
      * @param {string|WingbotModel|T} model - wingbot model name or AI plugin
      * @param {string} prefix - model prefix
      *
-     * @returns {WingbotModel|T}
+     * @returns {T}
      * @memberOf Ai
      */
     register (model, prefix = 'default') {
+        /** @type {T} */
         let modelObj;
 
         if (typeof model === 'string') {
+            // @ts-ignore
             modelObj = new WingbotModel({
                 model
             }, this.logger);
         } else {
+            // @ts-ignore
             modelObj = model;
         }
 
         this._keyworders.set(prefix, modelObj);
 
+        for (const entityArgs of this._detectors.values()) {
+            modelObj.setEntityDetector(...entityArgs);
+        }
+
         return modelObj;
     }
 
+    /**
+     *
+     * @param {string} name
+     * @param {EntityDetector|RegExp} detector
+     * @param {object} [options]
+     * @param {boolean} [options.anonymize] - if true, value will not be sent to NLP
+     * @param {Function|string} [options.extractValue] - entity extractor
+     * @param {boolean} [options.matchWholeWords] - match whole words at regular expression
+     * @param {boolean} [options.replaceDiacritics] - keep diacritics when matching regexp
+     * @param {string[]} [options.dependencies] - array of dependent entities
+     * @param {boolean} [options.clearOverlaps] - let longer entities from NLP to replace entity
+     * @returns {this}
+     */
+    registerEntityDetector (name, detector, options = {}) {
+        const useOptions = { clearOverlaps: true, ...options };
+
+        this._detectors.set(name, [name, detector, useOptions]);
+
+        for (const model of this._keyworders.values()) {
+            model.setEntityDetector(name, detector, useOptions);
+        }
+
+        return this;
+    }
+
+    /**
+     * Sets options to entity detector.
+     * Useful for disabling anonymization of local system entities.
+     *
+     * @param {string} name
+     * @param {object} options
+     * @param {boolean} [options.anonymize]
+     * @returns {this}
+     * @example
+     *
+     * ai.register('wingbot-model-name')
+     *     .setDetectorOptions('phone', { anonymize: false })
+     *     .setDetectorOptions('email', { anonymize: false })
+     */
+    configureEntityDetector (name, options) {
+        if (!this._detectors.has(name)) {
+            throw new Error(`Can't set entity detector options. Entity "${name}" does not exist.`);
+        }
+        Object.assign(this._detectors.get(name)[2], options);
+        for (const model of this._keyworders.values()) {
+            model.setDetectorOptions(name, options);
+        }
+        return this;
+    }
+
     /**
      * Remove registered model
      *
@@ -194,7 +268,7 @@ class Ai {
      *
      * @param {string} prefix - model prefix
      *
-     * @returns {WingbotModel}
+     * @returns {CustomEntityDetectionModel}
      * @memberOf Ai
      */
     getModel (prefix = 'default') {

package/src/Processor.js

@@ -529,6 +529,7 @@ class Processor extends EventEmitter {
             ];
             const options = {
                 ...this.options,
+                state: Object.freeze({ ...state }),
                 features
             };
 

package/src/Responder.js

@@ -63,6 +63,12 @@ Object.freeze(ExpectedInput);
  * @prop {string} [voice]
  */
 
+/**
+ * @callback VoiceControlFactory
+ * @param {object} state
+ * @returns {VoiceControl}
+ */
+
 /** @typedef {import('./ReturnSender').UploadResult} UploadResult */
 
 /**
@@ -91,6 +97,7 @@ class Responder {
         this._bookmark = null;
 
         this.options = {
+            state: Object.freeze({}),
             translator: (w) => w,
             appUrl: ''
         };
@@ -149,9 +156,9 @@ class Responder {
         this.startedOutput = false;
 
         /**
-         * @type {VoiceControl}
+         * @type {VoiceControl|VoiceControlFactory}
          */
-        this.voiceControl = {};
+        this.voiceControl = null;
 
         this._trackAsAction = null;
 
@@ -477,11 +484,15 @@ class Responder {
         }
 
         if (this._features.includes(FEATURE_VOICE)
-            && (voice || Object.keys(this.voiceControl).length)) {
+            && (voice || this.voiceControl)) {
 
             Object.assign(messageData.message, {
                 voice: {
-                    ...this.voiceControl,
+                    ...(typeof this.voiceControl === 'function'
+                        ? this.voiceControl(Object.freeze({
+                            ...this.options.state, ...this.newState
+                        }))
+                        : this.voiceControl),
                     ...voice
                 }
             });

package/src/systemEntities/email.js

@@ -3,6 +3,11 @@
  */
 'use strict';
 
+/** @typedef {import('../wingbot/CustomEntityDetectionModel').EntityDetector} EntityDetector */
+/** @typedef {import('../wingbot/CustomEntityDetectionModel').DetectorOptions} DetectorOptions */
+
+/** @type {[string,EntityDetector|RegExp,DetectorOptions]} */
 module.exports = ['email', /(?<=(\s|^|:))[a-zA-Z0-9!#$%&'*+\-=?^_`{|}~"][^@:\s]*@[^.@\s]+\.[^@\s,]+/, {
-    anonymize: true
+    anonymize: true,
+    clearOverlaps: true
 }];

package/src/systemEntities/phone.js

@@ -3,11 +3,16 @@
  */
 'use strict';
 
+/** @typedef {import('../wingbot/CustomEntityDetectionModel').EntityDetector} EntityDetector */
+/** @typedef {import('../wingbot/CustomEntityDetectionModel').DetectorOptions} DetectorOptions */
+
+/** @type {[string,EntityDetector|RegExp,DetectorOptions]} */
 module.exports = [
     'phone',
     /((00|\+)[\s-]?[0-9]{1,4}[\s-]?)?([0-9]{3,4}[\s-]?([0-9]{2,3}[\s-]?[0-9]{2}[\s-]?[0-9]{2,3}|[0-9]{3,4}[\s-]?[0-9]{3,4}))(?=(\s|$|[,!.?\-:]))/,
     {
         anonymize: true,
+        clearOverlaps: true,
         extractValue: (match) => {
             let [, internat,, number] = match;
 

package/src/wingbot/CachedModel.js

@@ -35,7 +35,7 @@ class CachedModel extends CustomEntityDetectionModel {
      * @param {object} options
      * @param {number} [options.cacheSize]
      * @param {number} [options.cachePhrasesTime]
-     * @param {{ warn: Function, error: Function }} [log]
+     * @param {{ warn: Function, error: Function, log: Function }} [log]
      */
     constructor (options, log = console) {
         super(options, log);
@@ -88,11 +88,19 @@ class CachedModel extends CustomEntityDetectionModel {
         const res = await promise;
         let { intents = [], entities = [] } = Array.isArray(res) ? { intents: res } : res;
 
-        entities = [...entities, ...local.entities];
-        intents = intents.map((i) => ({
-            ...i,
-            entities: [...(i.entities || []), ...local.entities]
-        }));
+        const expectedEntities = req ? req.expectedEntities() : [];
+
+        const before = local.entities
+            .filter((e) => this._entityDetectors.has(e.entity)
+                && this._entityDetectors.get(e.entity).clearOverlaps);
+
+        [intents, entities] = this._attachEntities(intents, entities, before, expectedEntities);
+
+        const after = local.entities
+            .filter((e) => !this._entityDetectors.has(e.entity)
+                || !this._entityDetectors.get(e.entity).clearOverlaps);
+
+        [intents, entities] = this._attachEntities(intents, entities, after);
 
         return {
             text: local.text,
@@ -101,6 +109,26 @@ class CachedModel extends CustomEntityDetectionModel {
         };
     }
 
+    _attachEntities (intents, entities, attachEntities, expectedEntities = null) {
+        const retEntities = [...entities, ...attachEntities];
+        const retIntents = intents
+            .map((i) => {
+                const ents = [...(i.entities || []), ...attachEntities];
+
+                return {
+                    ...i,
+                    entities: expectedEntities
+                        ? this.nonOverlapping(ents, expectedEntities)
+                        : ents
+                };
+            });
+
+        return [
+            retIntents,
+            expectedEntities ? this.nonOverlapping(retEntities, expectedEntities) : retEntities
+        ];
+    }
+
     async getPhrases () {
         if (this._phrasesCachedAt > (Date.now() - this.phrasesCacheTime)) {
             return this._phrasesCache;

package/src/wingbot/CustomEntityDetectionModel.js

@@ -51,6 +51,16 @@ const { replaceDiacritics } = require('../utils');
  * @prop {Intent[]} intents
  */
 
+/**
+ * @typedef {object} DetectorOptions
+ * @prop {boolean} [anonymize] - if true, value will not be sent to NLP
+ * @prop {Function|string} [extractValue] - entity extractor
+ * @prop {boolean} [matchWholeWords] - match whole words at regular expression
+ * @prop {boolean} [replaceDiacritics] - keep diacritics when matching regexp
+ * @prop {string[]} [dependencies] - array of dependent entities
+ * @prop {boolean} [clearOverlaps] - let longer entities from NLP to replace entity
+ */
+
 /**
  * @typedef {object} Phrases
  * @prop {Map<string,string[]>} phrases
@@ -70,7 +80,7 @@ class CustomEntityDetectionModel {
 
     /**
      * @param {object} options
-     * @param {{ warn: Function, error: Function }} [log]
+     * @param {{ warn: Function, error: Function, log: Function }} [log]
      */
     constructor (options, log = console) {
         this._options = options;
@@ -582,12 +592,7 @@ class CustomEntityDetectionModel {
      *
      * @param {string} name
      * @param {EntityDetector|RegExp} detector
-     * @param {object} [options]
-     * @param {boolean} [options.anonymize] - if true, value will not be sent to NLP
-     * @param {Function|string} [options.extractValue] - entity extractor
-     * @param {boolean} [options.matchWholeWords] - match whole words at regular expression
-     * @param {boolean} [options.replaceDiacritics] - keep diacritics when matching regexp
-     * @param {string[]} [options.dependencies] - array of dependent entities
+     * @param {DetectorOptions} [options]
      * @returns {this}
      */
     setEntityDetector (name, detector, options = {}) {
@@ -610,7 +615,8 @@ class CustomEntityDetectionModel {
             entityDetector,
             detector,
             dependencies,
-            anonymize: !!options.anonymize
+            anonymize: !!options.anonymize,
+            clearOverlaps: !!options.clearOverlaps
         });
 
         return this;
@@ -623,6 +629,7 @@ class CustomEntityDetectionModel {
      * @param {string} name
      * @param {object} options
      * @param {boolean} [options.anonymize]
+     * @param {boolean} [options.clearOverlaps]
      * @returns {this}
      * @example
      *
@@ -632,7 +639,7 @@ class CustomEntityDetectionModel {
      */
     setDetectorOptions (name, options) {
         if (!this._entityDetectors.has(name)) {
-            throw new Error('Can\'t set entity detector options. Entity "name" does not exist.');
+            throw new Error(`Can't set entity detector options. Entity "${name}" does not exist.`);
         }
         Object.assign(this._entityDetectors.get(name), options);
         return this;

package/src/wingbot/WingbotModel.js

@@ -3,7 +3,6 @@
 const { default: fetch } = require('node-fetch');
 const assert = require('assert');
 const CachedModel = require('./CachedModel');
-const systemEntities = require('../systemEntities');
 
 const DEFAULT_MATCHES = 3;
 const SERVICE_URL = 'https://model.wingbot.ai';
@@ -42,7 +41,7 @@ class WingbotModel extends CachedModel {
      * @param {number} [options.cacheSize]
      * @param {number} [options.matches]
      * @param {Function} [options.fetch]
-     * @param {{ warn: Function, log: Function }} [log]
+     * @param {{ warn: Function, log: Function, error: Function }} [log]
      */
     constructor (options, log = console) {
         super(options, log);
@@ -60,11 +59,6 @@ class WingbotModel extends CachedModel {
         this._serviceUrl = options.serviceUrl || SERVICE_URL;
         this._trainingUrl = options.trainingUrl || TRAINING_URL;
         this._model = options.model;
-
-        // apply default entities
-        systemEntities
-            // @ts-ignore
-            .forEach(([name, d, opts = {}]) => this.setEntityDetector(name, d, opts));
     }
 
     async _getPhrases () {