botium-core 1.13.3 → 1.13.5

package/dist/botium-es.js

@@ -37,7 +37,7 @@ import express from 'express';
 import bodyParser from 'body-parser';
 
 var name = "botium-core";
-var version$1 = "1.13.3";
+var version$1 = "1.13.5";
 var description = "The Selenium for Chatbots";
 var main = "index.js";
 var module = "dist/botium-es.js";
@@ -69,7 +69,7 @@ var bugs = {
 };
 var homepage = "https://www.botium.ai";
 var dependencies = {
-	"@babel/runtime": "^7.18.6",
+	"@babel/runtime": "^7.19.0",
 	async: "^3.2.4",
 	"body-parser": "^1.20.0",
 	boolean: "^3.2.0",
@@ -79,7 +79,7 @@ var dependencies = {
 	esprima: "^4.0.1",
 	express: "^4.18.1",
 	globby: "11.0.4",
-	ioredis: "^5.1.0",
+	ioredis: "^5.2.3",
 	"is-class": "^0.0.9",
 	"is-json": "^2.0.1",
 	jsonpath: "^1.1.1",
@@ -96,13 +96,13 @@ var dependencies = {
 	rimraf: "^3.0.2",
 	"sanitize-filename": "^1.6.3",
 	slugify: "^1.6.5",
-	"socket.io": "^4.5.1",
-	"socket.io-client": "^4.5.1",
+	"socket.io": "^4.5.2",
+	"socket.io-client": "^4.5.2",
 	"socketio-auth": "^0.1.1",
-	"swagger-jsdoc": "^6.2.1",
-	"swagger-ui-express": "^4.4.0",
-	uuid: "^8.3.2",
-	vm2: "^3.9.10",
+	"swagger-jsdoc": "^6.2.5",
+	"swagger-ui-express": "^4.5.0",
+	uuid: "^9.0.0",
+	vm2: "^3.9.11",
 	"word-error-rate": "0.0.7",
 	"write-yaml": "^1.0.0",
 	xlsx: "^0.18.5",
@@ -110,27 +110,27 @@ var dependencies = {
 	yaml: "^2.1.1"
 };
 var devDependencies = {
-	"@babel/core": "^7.18.6",
-	"@babel/node": "^7.18.6",
-	"@babel/plugin-transform-runtime": "^7.18.6",
-	"@babel/preset-env": "^7.18.6",
+	"@babel/core": "^7.19.3",
+	"@babel/node": "^7.19.1",
+	"@babel/plugin-transform-runtime": "^7.19.1",
+	"@babel/preset-env": "^7.19.3",
 	chai: "^4.3.6",
 	"chai-as-promised": "^7.1.1",
 	"cross-env": "^7.0.3",
-	eslint: "^8.19.0",
+	eslint: "^8.24.0",
 	"eslint-config-standard": "^17.0.0",
 	"eslint-plugin-import": "^2.26.0",
 	"eslint-plugin-mocha": "^10.1.0",
-	"eslint-plugin-n": "^15.2.4",
-	"eslint-plugin-promise": "^6.0.0",
+	"eslint-plugin-n": "^15.3.0",
+	"eslint-plugin-promise": "^6.0.1",
 	"eslint-plugin-standard": "^4.1.0",
 	"license-checker": "^25.0.1",
 	"license-compatibility-checker": "^0.3.5",
 	mocha: "^10.0.0",
-	nock: "^13.2.8",
-	"npm-check-updates": "^15.2.6",
+	nock: "^13.2.9",
+	"npm-check-updates": "^16.3.4",
 	nyc: "^15.1.0",
-	rollup: "^2.76.0",
+	rollup: "^2.79.1",
 	"rollup-plugin-babel": "^4.4.0",
 	"rollup-plugin-commonjs": "^10.1.0",
 	"rollup-plugin-json": "^4.0.0",
@@ -307,6 +307,8 @@ var Capabilities = {
   SCRIPTING_UTTEXPANSION_MODE: 'SCRIPTING_UTTEXPANSION_MODE',
   SCRIPTING_UTTEXPANSION_RANDOM_COUNT: 'SCRIPTING_UTTEXPANSION_RANDOM_COUNT',
   SCRIPTING_UTTEXPANSION_INCOMPREHENSION: 'SCRIPTING_UTTEXPANSION_INCOMPREHENSION',
+  SCRIPTING_UTTEXPANSION_INCOMPREHENSIONINTENTS: 'SCRIPTING_UTTEXPANSION_INCOMPREHENSIONINTENTS',
+  SCRIPTING_UTTEXPANSION_INCOMPREHENSIONUTTS: 'SCRIPTING_UTTEXPANSION_INCOMPREHENSIONUTTS',
   SCRIPTING_UTTEXPANSION_USENAMEASINTENT: 'SCRIPTING_UTTEXPANSION_USENAMEASINTENT',
   // justLineTag, utterance
   SCRIPTING_UTTEXPANSION_NAMING_MODE: 'SCRIPTING_UTTEXPANSION_NAMING_MODE',
@@ -460,6 +462,8 @@ Capabilities.SCRIPTING_MATCHING_MODE_ARGS;
 Capabilities.SCRIPTING_UTTEXPANSION_MODE;
 Capabilities.SCRIPTING_UTTEXPANSION_RANDOM_COUNT;
 Capabilities.SCRIPTING_UTTEXPANSION_INCOMPREHENSION;
+Capabilities.SCRIPTING_UTTEXPANSION_INCOMPREHENSIONINTENTS;
+Capabilities.SCRIPTING_UTTEXPANSION_INCOMPREHENSIONUTTS;
 Capabilities.SCRIPTING_UTTEXPANSION_USENAMEASINTENT;
 Capabilities.SCRIPTING_UTTEXPANSION_NAMING_MODE;
 Capabilities.SCRIPTING_UTTEXPANSION_NAMING_UTTERANCE_MAX;
@@ -544,6 +548,10 @@ var Defaults$1 = {
     [Capabilities.SCRIPTING_UTTEXPANSION_RANDOM_COUNT]: 1,
     [Capabilities.SCRIPTING_UTTEXPANSION_NAMING_MODE]: 'justLineTag',
     [Capabilities.SCRIPTING_UTTEXPANSION_NAMING_UTTERANCE_MAX]: '16',
+    [Capabilities.SCRIPTING_UTTEXPANSION_INCOMPREHENSION]: null,
+    [Capabilities.SCRIPTING_UTTEXPANSION_INCOMPREHENSIONINTENTS]: [],
+    [Capabilities.SCRIPTING_UTTEXPANSION_INCOMPREHENSIONUTTS]: [],
+    [Capabilities.SCRIPTING_UTTEXPANSION_USENAMEASINTENT]: false,
     [Capabilities.SCRIPTING_MEMORYEXPANSION_KEEP_ORIG]: false,
     [Capabilities.SCRIPTING_ENABLE_SKIP_ASSERT_ERRORS]: false,
     [Capabilities.SCRIPTING_FORCE_BOT_CONSUMED]: false,
@@ -1681,6 +1689,7 @@ class BotiumMockAsserter$1 {
   constructor(fromJson = {}) {
     this.name = fromJson.name;
     this.args = lodash.cloneDeep(fromJson.args);
+    this.not = fromJson.not;
   }
 
 }
@@ -2262,6 +2271,8 @@ const convoStepToLines$2 = step => {
       lines.push('MEDIA ' + step.media[0].mediaUri);
     } else if (step.messageText) {
       lines.push(step.messageText);
+    } else if (step.sourceData) {
+      lines.push(JSON.stringify(step.sourceData, null, 2));
     }
 
     step.userInputs && step.userInputs.forEach(userInput => {
@@ -2454,6 +2465,34 @@ const SCRIPTING_FUNCTIONS_RAW = {
   $timestamp: () => {
     return Date.now();
   },
+  $tomorrow: pattern => {
+    if (pattern) {
+      return moment().add(1, 'day').format(pattern);
+    }
+
+    return moment().add(1, 'day').toDate().toLocaleDateString();
+  },
+  $yesterday: pattern => {
+    if (pattern) {
+      return moment().subtract(1, 'day').format(pattern);
+    }
+
+    return moment().subtract(1, 'day').toDate().toLocaleDateString();
+  },
+  $date_add: (amount, unit, pattern) => {
+    if (pattern) {
+      return moment().add(amount, unit).format(pattern);
+    }
+
+    return moment().add(amount, unit).toDate().toLocaleDateString();
+  },
+  $date_subtract: (amount, unit, pattern) => {
+    if (pattern) {
+      return moment().subtract(amount, unit).format(pattern);
+    }
+
+    return moment().subtract(amount, unit).toDate().toLocaleDateString();
+  },
   $year: () => {
     return new Date().getFullYear();
   },
@@ -2545,7 +2584,8 @@ const SCRIPTING_FUNCTIONS_RAW = {
           require: false,
           env: caps[Capabilities.SECURITY_ALLOW_UNSAFE] ? process.env : {},
           sandbox: {
-            caps
+            caps,
+            moment
           }
         });
         return vm.run(`module.exports = (${code})`);
@@ -2623,7 +2663,22 @@ const _apply = (scriptingMemory, str, caps, mockMsg) => {
         for (const match of matches) {
           if (match.indexOf('(') > 0) {
             const arg = match.substring(match.indexOf('(') + 1, match.lastIndexOf(')')).replace(/\\\)/g, ')');
-            str = str.replace(match, SCRIPTING_FUNCTIONS$1[key].handler(caps, arg, mockMsg));
+            let args = [arg];
+
+            if (SCRIPTING_FUNCTIONS$1[key].numberOfArguments > 1) {
+              args = arg.split(',');
+            }
+
+            args = args.map(arg => {
+              arg = arg.trim();
+
+              if (arg.startsWith('"') && arg.endsWith('"')) {
+                return arg.substring(1, arg.length - 1);
+              } else {
+                return arg;
+              }
+            });
+            str = str.replace(match, SCRIPTING_FUNCTIONS$1[key].handler(caps, ...args, mockMsg));
           } else {
             str = str.replace(match, SCRIPTING_FUNCTIONS$1[key].handler(caps));
           }
@@ -4822,7 +4877,8 @@ var CompilerXlsx_1 = class CompilerXlsx extends CompilerBase_1 {
           convoResults.forEach(convo => {
             if (!convo.header.name) {
               convo.header.name = `${convo.header.sheetname}-${this.colnames[convo.header.colindex]}${formatRowIndex(convo.header.rowindex)}`;
-            }
+            } // it is not used anymore?
+
 
             convo.header.sort = convo.header.name;
             scriptResults.push(convo);
@@ -6888,6 +6944,8 @@ var ScriptingProvider_1 = class ScriptingProvider {
 
   ExpandUtterancesToConvos({
     useNameAsIntent,
+    incomprehensionIntents,
+    incomprehensionUtts,
     incomprehensionUtt
   } = {}) {
     const expandedConvos = [];
@@ -6896,26 +6954,81 @@ var ScriptingProvider_1 = class ScriptingProvider {
       useNameAsIntent = !!this.caps[Capabilities.SCRIPTING_UTTEXPANSION_USENAMEASINTENT];
     }
 
+    if (lodash.isUndefined(incomprehensionIntents)) {
+      incomprehensionIntents = this.caps[Capabilities.SCRIPTING_UTTEXPANSION_INCOMPREHENSIONINTENTS];
+    }
+
+    if (lodash.isUndefined(incomprehensionUtts)) {
+      incomprehensionUtts = this.caps[Capabilities.SCRIPTING_UTTEXPANSION_INCOMPREHENSIONUTTS];
+    }
+
     if (lodash.isUndefined(incomprehensionUtt)) {
       incomprehensionUtt = this.caps[Capabilities.SCRIPTING_UTTEXPANSION_INCOMPREHENSION];
     }
 
-    if (useNameAsIntent && incomprehensionUtt) {
-      throw new Error('ExpandUtterancesToConvos - SCRIPTING_UTTEXPANSION_USENAMEASINTENT and SCRIPTING_UTTEXPANSION_INCOMPREHENSION are incompatible');
+    if (incomprehensionUtt && (!incomprehensionUtts || incomprehensionUtts.length === 0) && !this.utterances[incomprehensionUtt]) {
+      throw new Error(`ExpandUtterancesToConvos - incomprehension utterance '${incomprehensionUtt}' undefined (and no user examples given)`);
     }
 
-    if (incomprehensionUtt && !this.utterances[incomprehensionUtt]) {
-      throw new Error(`ExpandUtterancesToConvos - incomprehension utterance '${incomprehensionUtt}' undefined`);
+    if (incomprehensionUtts && incomprehensionUtts.length > 0) {
+      if (!incomprehensionUtt) {
+        incomprehensionUtt = 'UTT_INCOMPREHENSION';
+      }
+
+      if (this.utterances[incomprehensionUtt]) {
+        this.utterances[incomprehensionUtt].utterances.push(...incomprehensionUtts);
+      } else {
+        this.utterances[incomprehensionUtt] = {
+          name: incomprehensionUtt,
+          utterances: [...incomprehensionUtts]
+        };
+      }
     }
 
     if (useNameAsIntent) {
       debug$9('ExpandUtterancesToConvos - Using utterance name as NLU intent');
-    } else if (incomprehensionUtt) {
-      debug$9(`ExpandUtterancesToConvos - Using incomprehension utterance expansion mode: ${incomprehensionUtt}`);
+    }
+
+    if (incomprehensionIntents && incomprehensionIntents.length > 0) {
+      debug$9(`ExpandUtterancesToConvos - Using ${incomprehensionIntents.length} incomprehension NLU intent(s)`);
+    }
+
+    if (incomprehensionUtt) {
+      debug$9(`ExpandUtterancesToConvos - Using incomprehension utterance expansion mode: ${incomprehensionUtt}, ${this.utterances[incomprehensionUtt].utterances.length} user example(s)`);
     }
 
     lodash.keys(this.utterances).filter(u => u !== incomprehensionUtt).forEach(uttName => {
       const utt = this.utterances[uttName];
+      const responseStep = {
+        sender: 'bot',
+        messageText: '',
+        asserters: [],
+        stepTag: 'Step 2 - check bot response',
+        not: false
+      };
+
+      if (useNameAsIntent) {
+        responseStep.asserters.push({
+          name: 'INTENT',
+          args: [utt.name]
+        });
+      }
+
+      if (incomprehensionIntents && incomprehensionIntents.length > 0) {
+        incomprehensionIntents.forEach(ii => {
+          responseStep.asserters.push({
+            name: 'INTENT',
+            args: [ii],
+            not: true
+          });
+        });
+      }
+
+      if (incomprehensionUtt) {
+        responseStep.messageText = incomprehensionUtt;
+        responseStep.not = true;
+      }
+
       expandedConvos.push(new Convo(this._buildScriptContext(), {
         header: {
           name: utt.name,
@@ -6928,25 +7041,7 @@ var ScriptingProvider_1 = class ScriptingProvider {
           }],
           messageText: utt.name,
           stepTag: 'Step 1 - tell utterance'
-        }, useNameAsIntent ? {
-          sender: 'bot',
-          asserters: [{
-            name: 'INTENT',
-            args: [utt.name]
-          }],
-          stepTag: 'Step 2 - check intent',
-          not: false
-        } : incomprehensionUtt ? {
-          sender: 'bot',
-          messageText: incomprehensionUtt,
-          stepTag: 'Step 2 - check incomprehension',
-          not: true
-        } : {
-          sender: 'bot',
-          messageText: '',
-          stepTag: 'Step 2 - check bot response',
-          not: false
-        }],
+        }, responseStep],
         sourceTag: Object.assign({}, utt.sourceTag, {
           origUttName: utt.name
         })
@@ -6958,30 +7053,77 @@ var ScriptingProvider_1 = class ScriptingProvider {
     this._sortConvos();
   }
 
-  ExpandConvos() {
+  ExpandConvos(options = {}) {
+    options = Object.assign({
+      // use skip and keep, or justHeader
+      justHeader: false,
+      // drop unwanted convos
+      convoFilter: null
+    }, options);
+    const context = {
+      count: 0
+    };
     const expandedConvos = [];
     debug$9(`ExpandConvos - Using utterances expansion mode: ${this.caps[Capabilities.SCRIPTING_UTTEXPANSION_MODE]}`);
     this.convos.forEach(convo => {
       convo.expandPartialConvos();
 
-      this._expandConvo(expandedConvos, convo);
+      for (const expanded of this._expandConvo(convo, options, context)) {
+        expanded.header.assertionCount = this.GetAssertionCount(expanded);
+
+        if (options.justHeader) {
+          const ConvoWithOnlyHeader = {
+            header: {
+              name: expanded.header.name,
+              assertionCount: expanded.header.assertionCount
+            }
+          };
+          expandedConvos.push(ConvoWithOnlyHeader);
+        } else {
+          expandedConvos.push(expanded);
+        }
+      }
     });
     this.convos = expandedConvos;
 
-    this._sortConvos();
+    if (!options.justHeader) {
+      this._sortConvos();
+    } else {
+      this._updateConvos();
+    }
+  }
+
+  ExpandConvosIterable(options = {}) {
+    options = Object.assign({
+      // drop unwanted convos
+      convoFilter: null
+    }, options);
+    debug$9(`ExpandConvos - Using utterances expansion mode: ${this.caps[Capabilities.SCRIPTING_UTTEXPANSION_MODE]}`); // creating a nested generator, calling the other.
+    // We hope this.convos does not changes while this iterator is used
+
+    const _convosIterable = function* (options) {
+      const context = {
+        count: 0
+      };
+
+      for (const convo of this.convos) {
+        convo.expandPartialConvos();
+        yield* this._expandConvo(convo, options, context);
+      }
+    }.bind(this);
+
+    this.convosIterable = _convosIterable(options);
   }
   /**
-   *
-   * @param expandedConvos
+   * This is a generator function with yield
    * @param currentConvo
    * @param convoStepIndex
    * @param convoStepsStack list of ConvoSteps
-   * @param context {width: }
    * @private
    */
 
 
-  _expandConvo(expandedConvos, currentConvo, convoStepIndex = 0, convoStepsStack = [], context = {}) {
+  *_expandConvo(currentConvo, options, context, convoStepIndex = 0, convoStepsStack = []) {
     const utterancePostfix = (lineTag, uttOrUserInput) => {
       const naming = this.caps[Capabilities.SCRIPTING_UTTEXPANSION_NAMING_MODE] || Defaults$1.capabilities[Capabilities.SCRIPTING_UTTEXPANSION_NAMING_MODE];
 
@@ -7007,8 +7149,7 @@ var ScriptingProvider_1 = class ScriptingProvider {
       if (currentStep.sender === 'bot' || currentStep.sender === 'begin' || currentStep.sender === 'end') {
         const currentStepsStack = convoStepsStack.slice();
         currentStepsStack.push(lodash.cloneDeep(currentStep));
-
-        this._expandConvo(expandedConvos, currentConvo, convoStepIndex + 1, currentStepsStack, context);
+        yield* this._expandConvo(currentConvo, options, context, convoStepIndex + 1, currentStepsStack);
       } else if (currentStep.sender === 'me') {
         let useUnexpanded = true;
 
@@ -7030,16 +7171,15 @@ var ScriptingProvider_1 = class ScriptingProvider {
           if (this.utterances[uttName]) {
             const allutterances = this.utterances[uttName].utterances;
 
-            const processSampleUtterances = (sampleutterances, myContext) => {
-              sampleutterances.forEach((utt, index) => {
-                processSampleUtterance(utt, sampleutterances.length, index, Object.assign({
+            const processSampleUtterances = function* (sampleutterances, myContext) {
+              for (let index = 0; index < sampleutterances.length; index++) {
+                yield* processSampleUtterance(sampleutterances[index], sampleutterances.length, index, Object.assign({
                   indexExpansionModeIndex: index
                 }, myContext || context));
-              });
+              }
             };
 
-            const processSampleUtterance = (sampleutterance, length, index, myContext) => {
-              const lineTag = `${index + 1}`.padStart(`${length}`.length, '0');
+            const processSampleUtterance = function* (sampleutterance, length, index, myContext) {
               const currentStepsStack = convoStepsStack.slice();
 
               if (uttArgs) {
@@ -7052,19 +7192,24 @@ var ScriptingProvider_1 = class ScriptingProvider {
 
               const currentConvoLabeled = lodash.cloneDeep(currentConvo);
 
-              Object.assign(currentConvoLabeled.header, {
-                name: `${currentConvo.header.name}/${uttName}-${utterancePostfix(lineTag, sampleutterance)}`
-              });
+              if (length > 1) {
+                const lineTag = `${index + 1}`.padStart(`${length}`.length, '0');
+                Object.assign(currentConvoLabeled.header, {
+                  name: `${currentConvo.header.name}/${uttName}-${utterancePostfix(lineTag, sampleutterance)}`
+                });
+              }
+
               if (!currentConvoLabeled.sourceTag) currentConvoLabeled.sourceTag = {};
               if (!currentConvoLabeled.sourceTag.origConvoName) currentConvoLabeled.sourceTag.origConvoName = currentConvo.header.name;
+              yield* this._expandConvo(currentConvoLabeled, options, myContext || context, convoStepIndex + 1, currentStepsStack);
+            }.bind(this);
 
-              this._expandConvo(expandedConvos, currentConvoLabeled, convoStepIndex + 1, currentStepsStack, myContext || context);
-            };
-
-            if (this.caps[Capabilities.SCRIPTING_UTTEXPANSION_MODE] === 'index') {
+            if (allutterances.length === 1) {
+              yield* processSampleUtterances([allutterances[0]], context);
+            } else if (this.caps[Capabilities.SCRIPTING_UTTEXPANSION_MODE] === 'index') {
               if (lodash.isNil(context.indexExpansionModeWidth)) {
                 // executed for the first found utterance
-                processSampleUtterances(allutterances, Object.assign({}, context, {
+                yield* processSampleUtterances(allutterances, Object.assign({}, context, {
                   indexExpansionModeWidth: allutterances.length
                 }));
               } else {
@@ -7082,7 +7227,7 @@ var ScriptingProvider_1 = class ScriptingProvider {
                 const myContext = Object.assign({}, context, {
                   indexExpansionModeWidth: Math.max(allutterances.length, context.indexExpansionModeWidth)
                 });
-                processSampleUtterance(allutterances[localIndex], allutterances.length, localIndex, myContext);
+                yield* processSampleUtterance(allutterances[localIndex], allutterances.length, localIndex, myContext);
 
                 if (allutterances.length > context.indexExpansionModeWidth && context.indexExpansionModeIndex + 1 === context.indexExpansionModeWidth) {
                   debug$9(`While expanding convos by index found in utterance "${uttName}" more examples (${allutterances.length}) as expected (${context.indexExpansionModeWidth})`);
@@ -7093,20 +7238,20 @@ var ScriptingProvider_1 = class ScriptingProvider {
                       indexExpansionModeWidth: allutterances.length,
                       indexExpansionModeIndex: i
                     });
-                    processSampleUtterance(allutterances[i], allutterances.length, i, myContext);
+                    yield* processSampleUtterance(allutterances[i], allutterances.length, i, myContext);
                   }
                 }
               }
             } else {
               if (this.caps[Capabilities.SCRIPTING_UTTEXPANSION_MODE] === 'first') {
-                processSampleUtterances([allutterances[0]]);
+                yield* processSampleUtterances([allutterances[0]], context);
               } else if (this.caps[Capabilities.SCRIPTING_UTTEXPANSION_MODE] === 'random') {
-                processSampleUtterances(allutterances.map(x => ({
+                yield* processSampleUtterances(allutterances.map(x => ({
                   x,
                   r: Math.random()
-                })).sort((a, b) => a.r - b.r).map(a => a.x).slice(0, this.caps[Capabilities.SCRIPTING_UTTEXPANSION_RANDOM_COUNT]));
+                })).sort((a, b) => a.r - b.r).map(a => a.x).slice(0, this.caps[Capabilities.SCRIPTING_UTTEXPANSION_RANDOM_COUNT]), context);
               } else {
-                processSampleUtterances(allutterances);
+                yield* processSampleUtterances(allutterances, context);
               }
             }
 
@@ -7115,7 +7260,8 @@ var ScriptingProvider_1 = class ScriptingProvider {
         }
 
         if (currentStep.userInputs && currentStep.userInputs.length > 0) {
-          currentStep.userInputs.forEach((ui, uiIndex) => {
+          for (let uiIndex = 0; uiIndex < currentStep.userInputs.length; uiIndex++) {
+            const ui = currentStep.userInputs[uiIndex];
             const userInput = this.userInputs[ui.name];
 
             if (userInput && userInput.expandConvo) {
@@ -7127,16 +7273,15 @@ var ScriptingProvider_1 = class ScriptingProvider {
 
               if (expandedUserInputs && expandedUserInputs.length > 0) {
                 // let sampleinputs = expandedUserInputs
-                const processSampleInputs = (sampleinputs, myContext, uiIndex) => {
-                  sampleinputs.forEach((input, index) => {
-                    processSampleInput(input, sampleinputs.length, index, Object.assign({
+                const processSampleInputs = function* (sampleinputs, myContext, uiIndex) {
+                  for (let index = 0; index < sampleinputs.length; index++) {
+                    yield* processSampleInput(sampleinputs[index], sampleinputs.length, index, Object.assign({
                       indexExpansionModeIndex: index
                     }, myContext || context), uiIndex);
-                  });
+                  }
                 };
 
-                const processSampleInput = (sampleinput, length, index, myContext, uiIndex) => {
-                  const lineTag = `${index + 1}`.padStart(`${length}`.length, '0');
+                const processSampleInput = function* (sampleinput, length, index, myContext, uiIndex) {
                   const currentStepsStack = convoStepsStack.slice();
 
                   const currentStepMod = lodash.cloneDeep(currentStep);
@@ -7146,16 +7291,27 @@ var ScriptingProvider_1 = class ScriptingProvider {
 
                   const currentConvoLabeled = lodash.cloneDeep(currentConvo);
 
-                  Object.assign(currentConvoLabeled.header, {
-                    name: `${currentConvo.header.name}/${ui.name}-${utterancePostfix(lineTag, sampleinput.args && sampleinput.args.length ? sampleinput.args.join(', ') : 'no-args')}`
-                  });
+                  if (length > 1) {
+                    if (sampleinput.convoPostfix) {
+                      Object.assign(currentConvoLabeled.header, {
+                        name: `${currentConvo.header.name}/${ui.name}-${sampleinput.convoPostfix}`
+                      });
+                    } else {
+                      const lineTag = `${index + 1}`.padStart(`${length}`.length, '0');
+                      Object.assign(currentConvoLabeled.header, {
+                        name: `${currentConvo.header.name}/${ui.name}-${utterancePostfix(lineTag, sampleinput.args && sampleinput.args.length ? sampleinput.args.join(', ') : 'no-args')}`
+                      });
+                    }
+                  }
 
-                  this._expandConvo(expandedConvos, currentConvoLabeled, convoStepIndex + 1, currentStepsStack, myContext || context);
-                };
+                  yield* this._expandConvo(currentConvoLabeled, options, myContext || context, convoStepIndex + 1, currentStepsStack);
+                }.bind(this);
 
-                if (this.caps[Capabilities.SCRIPTING_UTTEXPANSION_MODE] === 'index') {
+                if (expandedUserInputs.length === 1) {
+                  yield* processSampleInputs([expandedUserInputs[0]], context, uiIndex);
+                } else if (this.caps[Capabilities.SCRIPTING_UTTEXPANSION_MODE] === 'index') {
                   if (lodash.isNil(context.indexExpansionModeWidth)) {
-                    processSampleInputs(expandedUserInputs, Object.assign({}, context, {
+                    yield* processSampleInputs(expandedUserInputs, Object.assign({}, context, {
                       indexExpansionModeWidth: expandedUserInputs.length
                     }), uiIndex);
                   } else {
@@ -7173,7 +7329,7 @@ var ScriptingProvider_1 = class ScriptingProvider {
                     const myContext = Object.assign({}, context, {
                       indexExpansionModeWidth: Math.max(expandedUserInputs.length, context.indexExpansionModeWidth)
                     });
-                    processSampleInput(expandedUserInputs[localIndex], expandedUserInputs.length, localIndex, myContext, uiIndex);
+                    yield* processSampleInput(expandedUserInputs[localIndex], expandedUserInputs.length, localIndex, myContext, uiIndex);
 
                     if (expandedUserInputs.length > context.indexExpansionModeWidth && context.indexExpansionModeIndex + 1 === context.indexExpansionModeWidth) {
                       debug$9(`While expanding convos by index found user input "${ui.name}, ${ui.args}" more examples (${expandedUserInputs.length}) as expected (${context.indexExpansionModeWidth})`);
@@ -7183,55 +7339,72 @@ var ScriptingProvider_1 = class ScriptingProvider {
                           indexExpansionModeWidth: expandedUserInputs.length,
                           indexExpansionModeIndex: i
                         });
-                        processSampleInput(expandedUserInputs[i], expandedUserInputs.length, i, myContext, uiIndex);
+                        yield* processSampleInput(expandedUserInputs[i], expandedUserInputs.length, i, myContext, uiIndex);
                       }
                     }
                   }
                 } else {
                   if (this.caps[Capabilities.SCRIPTING_UTTEXPANSION_MODE] === 'first') {
-                    processSampleInputs([expandedUserInputs[0]], context, uiIndex);
+                    yield* processSampleInputs([expandedUserInputs[0]], context, uiIndex);
                   } else if (this.caps[Capabilities.SCRIPTING_UTTEXPANSION_MODE] === 'random') {
-                    processSampleInputs(expandedUserInputs.map(x => ({
+                    yield* processSampleInputs(expandedUserInputs.map(x => ({
                       x,
                       r: Math.random()
                     })).sort((a, b) => a.r - b.r).map(a => a.x).slice(0, this.caps[Capabilities.SCRIPTING_UTTEXPANSION_RANDOM_COUNT]), context, uiIndex);
                   } else {
-                    processSampleInputs(expandedUserInputs, context, uiIndex);
+                    yield* processSampleInputs(expandedUserInputs, context, uiIndex);
                   }
                 }
 
                 useUnexpanded = false;
               }
             }
-          });
+          }
         }
 
         if (useUnexpanded) {
           const currentStepsStack = convoStepsStack.slice();
           currentStepsStack.push(lodash.cloneDeep(currentStep));
-
-          this._expandConvo(expandedConvos, currentConvo, convoStepIndex + 1, currentStepsStack, context);
+          yield* this._expandConvo(currentConvo, options, context, convoStepIndex + 1, currentStepsStack);
         }
       }
     } else {
-      expandedConvos.push(Object.assign(lodash.cloneDeep(currentConvo), {
+      const expanded = Object.assign(lodash.cloneDeep(currentConvo), {
         conversation: lodash.cloneDeep(convoStepsStack)
-      }));
+      });
+
+      if (!options.convoFilter || options.convoFilter(expanded)) {
+        context.count++;
+        const logPerEntry = context.count < 10 ? 1 : context.count < 100 ? 10 : context.count < 1000 ? 100 : context.count < 10000 ? 1000 : 10000;
+
+        if (context.count % logPerEntry === 0) {
+          debug$9(`Convo #${context.count} expanded (${expanded.header.name})`);
+        }
+
+        yield expanded;
+      }
     }
   }
 
   _sortConvos() {
     this.convos = lodash.sortBy(this.convos, [convo => convo.header.sort || convo.header.name]);
+
+    this._updateConvos();
+  }
+
+  _updateConvos() {
     let i = 0;
     this.convos.forEach(convo => {
-      convo.header.order = ++i;
+      if (convo) {
+        convo.header.order = ++i;
 
-      if (!convo.header.projectname) {
-        convo.header.projectname = this.caps[Capabilities.PROJECTNAME];
-      }
+        if (!convo.header.projectname) {
+          convo.header.projectname = this.caps[Capabilities.PROJECTNAME];
+        }
 
-      if (!convo.header.testsessionname) {
-        convo.header.testsessionname = this.caps[Capabilities.TESTSESSIONNAME];
+        if (!convo.header.testsessionname) {
+          convo.header.testsessionname = this.caps[Capabilities.TESTSESSIONNAME];
+        }
       }
     });
   }
@@ -7243,7 +7416,11 @@ var ScriptingProvider_1 = class ScriptingProvider {
       this.convos.push(convos);
     }
 
-    this._sortConvos();
+    if (this.convos.filter(c => lodash.isNil(c))) {
+      this._updateConvos();
+    } else {
+      this._sortConvos();
+    }
   }
 
   AddUtterances(utterances) {
@@ -7519,6 +7696,37 @@ var ScriptingProvider_1 = class ScriptingProvider {
     return ['digraph {', ...nodes, ...lines, '}'].join('\r\n');
   }
 
+  GetAssertionCount(convo) {
+    if (!convo) {
+      return 0;
+    }
+
+    let counter = 0;
+
+    for (const step of convo.conversation) {
+      if (step.sender === 'bot') {
+        let stepCounter = step.asserters ? step.asserters.length : 0;
+
+        if (step.messageText) {
+          stepCounter++;
+        }
+
+        stepCounter = stepCounter === 0 ? 1 : stepCounter;
+        counter += stepCounter;
+      }
+    }
+
+    if (convo.convoBegin && convo.convoBegin.asserters) {
+      counter += convo.convoBegin.asserters.length;
+    }
+
+    if (convo.convoEnd && convo.convoEnd.asserters) {
+      counter += convo.convoEnd.asserters.length;
+    }
+
+    return counter === 0 ? 1 : counter;
+  }
+
 };
 
 var BaseRepo_1 = class BaseRepo {