wingbot 3.52.1 → 3.52.2-alpha.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wingbot",
-  "version": "3.52.1",
+  "version": "3.52.2-alpha.2",
   "description": "Enterprise Messaging Bot Conversation Engine",
   "main": "index.js",
   "scripts": {

package/src/AiMatching.js

@@ -127,11 +127,19 @@ class AiMatching {
     constructor (ai = { confidence: 0.8 }) {
         /**
          * When the entity is optional, the final score should be little bit lower
+         * (0.002 by default)
+         *
+         * @type {number}
+         */
+        this.optionalHandicap = 0.002;
+
+        /**
+         * When the entity is equal-optional, the final score should be little bit lower
          * (0.001 by default)
          *
          * @type {number}
          */
-        this.optionalHandicap = 0.001;
+        this.optionalEqualityHandicap = 0.001;
 
         /**
          * When there are additional entities then required add a handicap for each unmatched entity
@@ -476,8 +484,10 @@ class AiMatching {
                     useState
                 );
 
-            const allOptional = entities.every((e) => e.optional);
-            if (score === 0 && !allOptional) {
+            const allOptional = entities.every((e) => e.optional
+                && (!e.op || reqEntities.every((n) => n.entity !== e.entity)));
+
+            if (score <= 0 && !allOptional) {
                 return null;
             }
             const countOfAdditionalItems = Math.max(
@@ -489,6 +499,8 @@ class AiMatching {
                 ? score - noIntentHandicap
                 : (regexpScore + score) / 2;
 
+            // console.log({ baseScore, score, allOptional, entities, reqEntities });
+
             const matchedEntitiesTextLength = matched.reduce((tot, entity) => (
                 typeof entity.end === 'number' && typeof entity.start === 'number' && tot !== null
                     ? (tot + (entity.end - entity.start))
@@ -508,6 +520,10 @@ class AiMatching {
                 finalScore -= (matchedEntitiesTextLength / textLength) * remainingScore;
             }
 
+            if (finalScore <= 0) {
+                return null;
+            }
+
             return {
                 intent: null,
                 entities: matched,
@@ -586,10 +602,11 @@ class AiMatching {
                     : (x) => x
             );
 
-        // console.log({ entitiesScore, handicap, matched, minScore, requestIntent })
+        // console.log({ entitiesScore, handicap, matched, minScore, requestIntent });
 
-        const allOptional = wantedEntities.every((e) => e.optional);
-        if (entitiesScore === 0 && !allOptional) {
+        const allOptional = wantedEntities.every((e) => e.optional
+            && (!e.op || useEntities.every((n) => n.entity !== e.entity)));
+        if (entitiesScore <= 0 && !allOptional) {
             return { score: 0, entities: [] };
         }
 
@@ -597,7 +614,7 @@ class AiMatching {
         const scoreWithHandicap = normalizedScore - handicap;
         const multiMatchGain = this._getMultiMatchGain(entitiesScore, matched.length, fromState);
 
-        const score = scoreWithHandicap * multiMatchGain;
+        const score = Math.round((scoreWithHandicap * multiMatchGain) * 10000) / 10000;
 
         // console.log({ IMS: score, normalizedScore, scoreWithHandicap, multiMatchGain });
 
@@ -674,19 +691,21 @@ class AiMatching {
                     ._entityIsMatching(wanted.op, wanted.compare, undefined, requestState);
             }
 
-            if (!matching && !wanted.optional) {
+            if (!matching && (!wanted.optional || entityExists)) {
                 return {
                     score: 0, handicap: 0, matched: [], minScore, fromState
                 };
             }
 
-            if (!matching) { // optional
+            if (!matching) { // && optional && !entityExists
                 handicap += this.redundantEntityHandicap;
                 continue;
             }
 
             if (wanted.optional) {
-                handicap += this.optionalHandicap;
+                handicap += wanted.op
+                    ? this.optionalEqualityHandicap
+                    : this.optionalHandicap;
             }
 
             if (wanted.op === COMPARE.NOT_EQUAL) {