botium-core 1.13.1 → 1.13.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "botium-core",
-  "version": "1.13.1",
+  "version": "1.13.4",
   "description": "The Selenium for Chatbots",
   "main": "index.js",
   "module": "dist/botium-es.js",
@@ -66,6 +66,7 @@
     "swagger-ui-express": "^4.4.0",
     "uuid": "^8.3.2",
     "vm2": "^3.9.10",
+    "word-error-rate": "0.0.7",
     "write-yaml": "^1.0.0",
     "xlsx": "^0.18.5",
     "xregexp": "^5.1.1",
@@ -82,6 +83,7 @@
     "eslint": "^8.19.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-standard": "^4.1.0",

package/src/Capabilities.js

@@ -126,12 +126,15 @@ module.exports = {
   SCRIPTING_ENABLE_MULTIPLE_ASSERT_ERRORS: 'SCRIPTING_ENABLE_MULTIPLE_ASSERT_ERRORS',
   SCRIPTING_ENABLE_SKIP_ASSERT_ERRORS: 'SCRIPTING_ENABLE_SKIP_ASSERT_ERRORS',
   SCRIPTING_FORCE_BOT_CONSUMED: 'SCRIPTING_FORCE_BOT_CONSUMED',
-  // regexp, regexpIgnoreCase, wildcard, wildcardIgnoreCase, wildcardExact, wildcardExactIgnoreCase, include, includeIgnoreCase, equals, equalsIgnoreCase
+  // regexp, regexpIgnoreCase, wildcard, wildcardIgnoreCase, wildcardExact, wildcardExactIgnoreCase, include, includeIgnoreCase, equals, equalsIgnoreCase, wer
   SCRIPTING_MATCHING_MODE: 'SCRIPTING_MATCHING_MODE',
+  SCRIPTING_MATCHING_MODE_ARGS: 'SCRIPTING_MATCHING_MODE_ARGS',
   // all, first, random
   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',

package/src/Defaults.js

@@ -49,6 +49,10 @@ module.exports = {
     [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,

package/src/containers/plugins/SimpleRestContainer.js

@@ -42,7 +42,7 @@ module.exports = class SimpleRestContainer {
           return qr[0]
         })
         for (const event of sortedEvents) {
-          setTimeout(() => this._processBodyAsync(event.body, true, !!this.caps[Capabilities.SIMPLEREST_INBOUND_UPDATE_CONTEXT]), 0)
+          setTimeout(() => this._processBodyAsync(event.body, event.headers, true, !!this.caps[Capabilities.SIMPLEREST_INBOUND_UPDATE_CONTEXT]), 0)
         }
       }, debounceTimeout)
     }
@@ -142,13 +142,13 @@ module.exports = class SimpleRestContainer {
         (pingComplete) => {
           if (this.caps[Capabilities.SIMPLEREST_PING_URL]) {
             this._makeCall('SIMPLEREST_PING')
-              .then(body => {
+              .then(({ body, headers }) => {
                 if (this.caps[Capabilities.SIMPLEREST_PING_UPDATE_CONTEXT] || this.caps[Capabilities.SIMPLEREST_PING_PROCESS_RESPONSE]) {
                   return this._parseResponseBody(body)
                     .then(body => {
                       if (body) {
                         debug(`Ping Uri ${this.caps[Capabilities.SIMPLEREST_PING_URL]} returned JSON response: ${botiumUtils.shortenJsonString(body)}`)
-                        return this._processBodyAsync(body, !!this.caps[Capabilities.SIMPLEREST_PING_PROCESS_RESPONSE], !!this.caps[Capabilities.SIMPLEREST_PING_UPDATE_CONTEXT])
+                        return this._processBodyAsync(body, headers, !!this.caps[Capabilities.SIMPLEREST_PING_PROCESS_RESPONSE], !!this.caps[Capabilities.SIMPLEREST_PING_UPDATE_CONTEXT])
                       } else {
                         debug(`Ping Uri ${this.caps[Capabilities.SIMPLEREST_PING_URL]} didn't return JSON response, ignoring it.`)
                       }
@@ -178,13 +178,13 @@ module.exports = class SimpleRestContainer {
           this.processInbound = true
           if (this.caps[Capabilities.SIMPLEREST_START_URL]) {
             this._makeCall('SIMPLEREST_START')
-              .then(body => {
+              .then(({ body, headers }) => {
                 if (this.caps[Capabilities.SIMPLEREST_START_UPDATE_CONTEXT] || this.caps[Capabilities.SIMPLEREST_START_PROCESS_RESPONSE]) {
                   return this._parseResponseBody(body)
                     .then(body => {
                       if (body) {
                         debug(`Start Uri ${this.caps[Capabilities.SIMPLEREST_START_URL]} returned JSON response: ${botiumUtils.shortenJsonString(body)}`)
-                        return this._processBodyAsync(body, !!this.caps[Capabilities.SIMPLEREST_START_PROCESS_RESPONSE], !!this.caps[Capabilities.SIMPLEREST_START_UPDATE_CONTEXT])
+                        return this._processBodyAsync(body, headers, !!this.caps[Capabilities.SIMPLEREST_START_PROCESS_RESPONSE], !!this.caps[Capabilities.SIMPLEREST_START_UPDATE_CONTEXT])
                       } else {
                         debug(`Start Uri ${this.caps[Capabilities.SIMPLEREST_START_URL]} didn't return JSON response, ignoring it.`)
                       }
@@ -235,10 +235,10 @@ module.exports = class SimpleRestContainer {
   }
 
   // Separated just for better module testing
-  async _processBodyAsync (body, isFromUser, updateContext) {
+  async _processBodyAsync (body, headers, isFromUser, updateContext) {
     const p = async () => {
       try {
-        const results = await this._processBodyAsyncImpl(body, isFromUser, updateContext)
+        const results = await this._processBodyAsyncImpl(body, headers, isFromUser, updateContext)
         if (results) {
           for (const result of results) {
             setTimeout(() => this.queueBotSays(result), 0)
@@ -266,7 +266,8 @@ module.exports = class SimpleRestContainer {
   }
 
   // Separated just for better module testing
-  async _processBodyAsyncImpl (body, isFromUser, updateContext) {
+  async _processBodyAsyncImpl (body, headers, isFromUser, updateContext) {
+    this.view.response = { body, headers }
     if (updateContext) {
       const mergeMode = this.caps[Capabilities.SIMPLEREST_CONTEXT_MERGE_OR_REPLACE]
       const jsonPathsContext = getAllCapValues(Capabilities.SIMPLEREST_CONTEXT_JSONPATH, this.caps)
@@ -451,7 +452,7 @@ module.exports = class SimpleRestContainer {
             }
 
             if (body) {
-              debug(`got response code: ${response.statusCode}, body: ${botiumUtils.shortenJsonString(body)}`)
+              debug(`got response code: ${response.statusCode}, body: ${botiumUtils.shortenJsonString(body)}, headers: ${botiumUtils.shortenJsonString(response.headers)}`)
               this._storeCookiesFromResponse(response)
               try {
                 body = await this._parseResponseBody(body)
@@ -463,7 +464,7 @@ module.exports = class SimpleRestContainer {
               }
 
               if (body) {
-                this._processBodyAsync(body, isFromUser, updateContext).then(() => resolve(this)).then(() => this._emptyWaitProcessQueue())
+                this._processBodyAsync(body, response.headers, isFromUser, updateContext).then(() => resolve(this)).then(() => this._emptyWaitProcessQueue())
               } else {
                 debug('ignoring response body (no string and no JSON object)')
                 resolve(this)
@@ -520,6 +521,9 @@ module.exports = class SimpleRestContainer {
       try {
         requestOptions.body = this._getMustachedCap(Capabilities.SIMPLEREST_BODY_TEMPLATE, !bodyRaw)
         requestOptions.json = !bodyRaw
+        if (requestOptions.json && (!requestOptions.body || Object.keys(requestOptions.body).length === 0)) {
+          debug(`warning: requestOptions.body content seems to be empty - ${requestOptions.body} - capability: "${this.caps[Capabilities.SIMPLEREST_BODY_TEMPLATE]}"`)
+        }
       } catch (err) {
         throw new Error(`composing body from SIMPLEREST_BODY_TEMPLATE failed (${err.message})`)
       }
@@ -596,9 +600,9 @@ module.exports = class SimpleRestContainer {
         debug(`_waitForUrlResponse success on url check ${pingConfig.uri}: ${response.statusCode}/${response.statusMessage}`)
         this._storeCookiesFromResponse(response)
         if (debug.enabled && body) {
-          debug(botiumUtils.shortenJsonString(body))
+          debug(`body: ${botiumUtils.shortenJsonString(body)}, headers: ${botiumUtils.shortenJsonString(response.headers)}`)
         }
-        return body
+        return { body, headers: response.headers }
       }
     }
   }
@@ -635,7 +639,10 @@ module.exports = class SimpleRestContainer {
       try {
         return JSON.parse(raw)
       } catch (err) {
-        return new Error(`JSON parsing failed - try to use {{#fnc.jsonify}}{{xxx}}{{/fnc.jsonify}} to escape JSON special characters (ERR: ${err.message})`)
+        if (debug.enabled) {
+          debug(`JSON parsing failed (${err.message}) for: ${botiumUtils.shortenJsonString(raw)}`)
+        }
+        throw new Error(`JSON parsing failed - try to use {{#fnc.jsonify}}{{xxx}}{{/fnc.jsonify}} to escape JSON special characters (ERR: ${err.message})`)
       }
     } else {
       return raw
@@ -673,7 +680,7 @@ module.exports = class SimpleRestContainer {
       this.inboundEvents.push(event)
       this._processOrderedInboundEventsArrayAsync()
     } else {
-      setTimeout(() => this._processBodyAsync(event.body, true, !!this.caps[Capabilities.SIMPLEREST_INBOUND_UPDATE_CONTEXT]), 0)
+      setTimeout(() => this._processBodyAsync(event.body, event.headers, true, !!this.caps[Capabilities.SIMPLEREST_INBOUND_UPDATE_CONTEXT]), 0)
     }
   }
 
@@ -797,7 +804,7 @@ module.exports = class SimpleRestContainer {
               debug(botiumUtils.shortenJsonString(body))
             }
           } else if (body) {
-            debug(`_runPolling: got response code: ${response.statusCode}, body: ${botiumUtils.shortenJsonString(body)}`)
+            debug(`_runPolling: got response code: ${response.statusCode}, body: ${botiumUtils.shortenJsonString(body)}, headers: ${botiumUtils.shortenJsonString(response.headers)}`)
             this._storeCookiesFromResponse(response)
             try {
               body = await this._parseResponseBody(body)
@@ -806,7 +813,7 @@ module.exports = class SimpleRestContainer {
               return
             }
             if (body) {
-              setTimeout(() => this._processBodyAsync(body, true, !!this.caps[Capabilities.SIMPLEREST_POLL_UPDATE_CONTEXT]), 0)
+              setTimeout(() => this._processBodyAsync(body, response.headers, true, !!this.caps[Capabilities.SIMPLEREST_POLL_UPDATE_CONTEXT]), 0)
             } else {
               debug('_runPolling: ignoring response body (no string and no JSON object)')
             }

package/src/grid/inbound/proxy.js

@@ -29,7 +29,8 @@ const setupEndpoints = ({ app, endpoint, middleware, processEvent }) => {
       processEvent({
         originalUrl: req.originalUrl,
         originalMethod: req.method,
-        body: req.body
+        body: req.body,
+        headers: req.headers
       })
       res.status(200).json({}).end()
     } else {

package/src/mocks/BotiumMockScripting.js

@@ -4,6 +4,7 @@ class BotiumMockAsserter {
   constructor (fromJson = {}) {
     this.name = fromJson.name
     this.args = _.cloneDeep(fromJson.args)
+    this.not = fromJson.not
   }
 }
 class BotiumMockUserInput {

package/src/scripting/Convo.js

@@ -91,9 +91,9 @@ class ConvoStep {
       '#' + this.sender +
       ' - ' + (this.optional ? '?' : '') + (this.not ? '!' : '') +
       (this.messageText || '') +
-      (this.asserters && this.asserters.length > 0 ? ' ' + this.asserters.map(a => a.toString()).join(' ASS: ') : '') +
-      (this.logicHooks && this.logicHooks.length > 0 ? ' ' + this.logicHooks.map(l => l.toString()).join(' LH: ') : '') +
-      (this.userInputs && this.userInputs.length > 0 ? ' ' + this.userInputs.map(u => u.toString()).join(' UI: ') : '')
+      (this.asserters && this.asserters.length > 0 ? ' ' + this.asserters.map(a => a.toString()).join(' ') : '') +
+      (this.logicHooks && this.logicHooks.length > 0 ? ' ' + this.logicHooks.map(l => l.toString()).join(' ') : '') +
+      (this.userInputs && this.userInputs.length > 0 ? ' ' + this.userInputs.map(u => u.toString()).join(' ') : '')
   }
 }
 
@@ -119,7 +119,7 @@ class Transcript {
   }
 }
 
-class TranscriptAttachment { // eslint-disable-line no-unused-vars
+class TranscriptAttachment {
   constructor (fromJson = {}) {
     this.name = fromJson.name
     this.mimeType = fromJson.mimeType
@@ -714,9 +714,15 @@ class Convo {
   }
 }
 
-module
-  .exports = {
-    ConvoHeader,
-    Convo,
-    ConvoStep
-  }
+module.exports = {
+  Convo,
+  ConvoHeader,
+  ConvoStep,
+  ConvoStepAssert,
+  ConvoStepLogicHook,
+  ConvoStepUserInput,
+  Transcript,
+  TranscriptAttachment,
+  TranscriptStep,
+  TranscriptError
+}

package/src/scripting/MatchFunctions.js

@@ -1,4 +1,5 @@
 const _ = require('lodash')
+const speechScorer = require('word-error-rate')
 
 const { toString, quoteRegexpString } = require('./helper')
 
@@ -79,6 +80,12 @@ const equals = (ignoreCase) => (botresponse, utterance) => {
   return botresponse === utterance
 }
 
+const wer = () => (botresponse, utterance, args) => {
+  botresponse = _normalize(botresponse || '')
+  utterance = toString(utterance || '')
+  return speechScorer.wordErrorRate(botresponse, utterance) <= args[0]
+}
+
 const getMatchFunction = (matchingMode) => {
   if (matchingMode === 'regexp' || matchingMode === 'regexpIgnoreCase') {
     return regexp(matchingMode === 'regexpIgnoreCase')
@@ -90,6 +97,8 @@ const getMatchFunction = (matchingMode) => {
     return include(matchingMode === 'includeIgnoreCase' || matchingMode === 'includeLowerCase')
   } else if (matchingMode === 'equals' || matchingMode === 'equalsIgnoreCase') {
     return equals(matchingMode === 'equalsIgnoreCase')
+  } else if (matchingMode === 'wer') {
+    return wer()
   } else {
     return equals(false)
   }
@@ -101,5 +110,6 @@ module.exports = {
   wildcardExact,
   include,
   equals,
+  wer,
   getMatchFunction
 }

package/src/scripting/ScriptingProvider.js

@@ -134,7 +134,8 @@ module.exports = class ScriptingProvider {
           tomatch = [tomatch]
         }
         debug(`assertBotResponse ${stepTag} ${meMsg ? `(${meMsg}) ` : ''}BOT: ${botresponse} = ${tomatch} ...`)
-        const found = _.find(tomatch, (utt) => this.matchFn(botresponse, utt))
+        const found = _.find(tomatch, (utt) => this.matchFn(botresponse, utt, this.caps[Capabilities.SCRIPTING_MATCHING_MODE_ARGS]))
+        const asserterType = this.caps[Capabilities.SCRIPTING_MATCHING_MODE] === 'wer' ? 'WerAsserter' : 'TextMatchAsserter'
         if (_.isNil(found)) {
           let message = `${stepTag}: Bot response `
           message += meMsg ? `(on ${meMsg}) ` : ''
@@ -146,7 +147,7 @@ module.exports = class ScriptingProvider {
             message,
             {
               type: 'asserter',
-              source: 'TextMatchAsserter',
+              source: asserterType,
               context: {
                 stepTag
               },
@@ -164,7 +165,8 @@ module.exports = class ScriptingProvider {
           nottomatch = [nottomatch]
         }
         debug(`assertBotNotResponse ${stepTag} ${meMsg ? `(${meMsg}) ` : ''}BOT: ${botresponse} != ${nottomatch} ...`)
-        const found = _.find(nottomatch, (utt) => this.matchFn(botresponse, utt))
+        const found = _.find(nottomatch, (utt) => this.matchFn(botresponse, utt, this.caps[Capabilities.SCRIPTING_MATCHING_MODE_ARGS]))
+        const asserterType = this.caps[Capabilities.SCRIPTING_MATCHING_MODE] === 'wer' ? 'WerAsserter' : 'TextMatchAsserter'
         if (!_.isNil(found)) {
           let message = `${stepTag}: Bot response `
           message += meMsg ? `(on ${meMsg}) ` : ''
@@ -176,7 +178,7 @@ module.exports = class ScriptingProvider {
             message,
             {
               type: 'asserter',
-              source: 'TextMatchAsserter',
+              source: asserterType,
               context: {
                 stepTag
               },
@@ -401,7 +403,7 @@ module.exports = class ScriptingProvider {
   }
 
   Match (botresponse, utterance) {
-    return this.matchFn(botresponse, utterance)
+    return this.matchFn(botresponse, utterance, this.caps[Capabilities.SCRIPTING_MATCHING_MODE_ARGS])
   }
 
   Compile (scriptBuffer, scriptFormat, scriptType) {
@@ -768,31 +770,79 @@ module.exports = class ScriptingProvider {
     this._sortConvos()
   }
 
-  ExpandUtterancesToConvos ({ useNameAsIntent, incomprehensionUtt } = {}) {
+  ExpandUtterancesToConvos ({ useNameAsIntent, incomprehensionIntents, incomprehensionUtts, incomprehensionUtt } = {}) {
     const expandedConvos = []
 
     if (_.isUndefined(useNameAsIntent)) {
       useNameAsIntent = !!this.caps[Capabilities.SCRIPTING_UTTEXPANSION_USENAMEASINTENT]
     }
+    if (_.isUndefined(incomprehensionIntents)) {
+      incomprehensionIntents = this.caps[Capabilities.SCRIPTING_UTTEXPANSION_INCOMPREHENSIONINTENTS]
+    }
+    if (_.isUndefined(incomprehensionUtts)) {
+      incomprehensionUtts = this.caps[Capabilities.SCRIPTING_UTTEXPANSION_INCOMPREHENSIONUTTS]
+    }
     if (_.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('ExpandUtterancesToConvos - Using utterance name as NLU intent')
-    } else if (incomprehensionUtt) {
-      debug(`ExpandUtterancesToConvos - Using incomprehension utterance expansion mode: ${incomprehensionUtt}`)
+    }
+    if (incomprehensionIntents && incomprehensionIntents.length > 0) {
+      debug(`ExpandUtterancesToConvos - Using ${incomprehensionIntents.length} incomprehension NLU intent(s)`)
+    }
+    if (incomprehensionUtt) {
+      debug(`ExpandUtterancesToConvos - Using incomprehension utterance expansion mode: ${incomprehensionUtt}, ${this.utterances[incomprehensionUtt].utterances.length} user example(s)`)
     }
 
     _.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,
@@ -809,31 +859,7 @@ module.exports = 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 })
       }))
@@ -859,9 +885,10 @@ module.exports = class ScriptingProvider {
    * @param currentConvo
    * @param convoStepIndex
    * @param convoStepsStack list of ConvoSteps
+   * @param context {width: }
    * @private
    */
-  _expandConvo (expandedConvos, currentConvo, convoStepIndex = 0, convoStepsStack = []) {
+  _expandConvo (expandedConvos, currentConvo, convoStepIndex = 0, convoStepsStack = [], context = {}) {
     const utterancePostfix = (lineTag, uttOrUserInput) => {
       const naming = this.caps[Capabilities.SCRIPTING_UTTEXPANSION_NAMING_MODE] || Defaults.capabilities[Capabilities.SCRIPTING_UTTEXPANSION_NAMING_MODE]
       if (naming === 'justLineTag') {
@@ -881,7 +908,7 @@ module.exports = class ScriptingProvider {
       if (currentStep.sender === 'bot' || currentStep.sender === 'begin' || currentStep.sender === 'end') {
         const currentStepsStack = convoStepsStack.slice()
         currentStepsStack.push(_.cloneDeep(currentStep))
-        this._expandConvo(expandedConvos, currentConvo, convoStepIndex + 1, currentStepsStack)
+        this._expandConvo(expandedConvos, currentConvo, convoStepIndex + 1, currentStepsStack, context)
       } else if (currentStep.sender === 'me') {
         let useUnexpanded = true
         if (currentStep.messageText) {
@@ -898,29 +925,61 @@ module.exports = class ScriptingProvider {
           }
           if (this.utterances[uttName]) {
             const allutterances = this.utterances[uttName].utterances
-            let sampleutterances = allutterances
-            if (this.caps[Capabilities.SCRIPTING_UTTEXPANSION_MODE] === 'first') {
-              sampleutterances = [allutterances[0]]
-            } else if (this.caps[Capabilities.SCRIPTING_UTTEXPANSION_MODE] === 'random') {
-              sampleutterances = 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])
+            const processSampleUtterances = (sampleutterances, myContext) => {
+              sampleutterances.forEach((utt, index) => {
+                processSampleUtterance(utt, sampleutterances.length, index, Object.assign({ indexExpansionModeIndex: index }, myContext || context))
+              })
             }
-            sampleutterances.forEach((utt, index) => {
-              const lineTag = `${index + 1}`.padStart(`${sampleutterances.length}`.length, '0')
+            const processSampleUtterance = (sampleutterance, length, index, myContext) => {
+              const lineTag = `${index + 1}`.padStart(`${length}`.length, '0')
               const currentStepsStack = convoStepsStack.slice()
               if (uttArgs) {
-                utt = util.format(utt, ...uttArgs)
+                sampleutterance = util.format(sampleutterance, ...uttArgs)
               }
-              currentStepsStack.push(Object.assign(_.cloneDeep(currentStep), { messageText: utt }))
+              currentStepsStack.push(Object.assign(_.cloneDeep(currentStep), { messageText: sampleutterance }))
               const currentConvoLabeled = _.cloneDeep(currentConvo)
-              Object.assign(currentConvoLabeled.header, { name: `${currentConvo.header.name}/${uttName}-${utterancePostfix(lineTag, utt)}` })
+              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
-              this._expandConvo(expandedConvos, currentConvoLabeled, convoStepIndex + 1, currentStepsStack)
-            })
+              this._expandConvo(expandedConvos, currentConvoLabeled, convoStepIndex + 1, currentStepsStack, myContext || context)
+            }
+            if (this.caps[Capabilities.SCRIPTING_UTTEXPANSION_MODE] === 'index') {
+              if (_.isNil(context.indexExpansionModeWidth)) {
+                // executed for the first found utterance
+                processSampleUtterances(allutterances, Object.assign({}, context, { indexExpansionModeWidth: allutterances.length }))
+              } else {
+                if (_.isNil(context.indexExpansionModeIndex)) {
+                  throw new Error('indexExpansionModeIndex must be set!')
+                }
+                // executing the current 'thread', if current utterance has no example to current index, fallback to the last one
+                const localIndex = Math.min(context.indexExpansionModeIndex, allutterances.length - 1)
+                if (localIndex < context.indexExpansionModeIndex && context.indexExpansionModeIndex === context.indexExpansionModeWidth - 1) {
+                  debug(`While expanding convos by index found in utterance "${uttName}" less examples (${allutterances.length}) as expected (${context.indexExpansionModeWidth})`)
+                }
+                const myContext = Object.assign({}, context, { indexExpansionModeWidth: Math.max(allutterances.length, context.indexExpansionModeWidth) })
+                processSampleUtterance(allutterances[localIndex], allutterances.length, localIndex, myContext)
+                if (allutterances.length > context.indexExpansionModeWidth && context.indexExpansionModeIndex + 1 === context.indexExpansionModeWidth) {
+                  debug(`While expanding convos by index found in utterance "${uttName}" more examples (${allutterances.length}) as expected (${context.indexExpansionModeWidth})`)
+                  for (let i = context.indexExpansionModeWidth; i < allutterances.length; i++) {
+                    // if we found a utterance with more examples as any utterances before, we have to start new 'thread'
+                    const myContext = Object.assign({}, context, { indexExpansionModeWidth: allutterances.length, indexExpansionModeIndex: i })
+                    processSampleUtterance(allutterances[i], allutterances.length, i, myContext)
+                  }
+                }
+              }
+            } else {
+              if (this.caps[Capabilities.SCRIPTING_UTTEXPANSION_MODE] === 'first') {
+                processSampleUtterances([allutterances[0]])
+              } else if (this.caps[Capabilities.SCRIPTING_UTTEXPANSION_MODE] === 'random') {
+                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]))
+              } else {
+                processSampleUtterances(allutterances)
+              }
+            }
             useUnexpanded = false
           }
         }
@@ -930,18 +989,14 @@ module.exports = class ScriptingProvider {
             if (userInput && userInput.expandConvo) {
               const expandedUserInputs = userInput.expandConvo({ convo: currentConvo, convoStep: currentStep, args: ui.args })
               if (expandedUserInputs && expandedUserInputs.length > 0) {
-                let sampleinputs = expandedUserInputs
-                if (this.caps[Capabilities.SCRIPTING_UTTEXPANSION_MODE] === 'first') {
-                  sampleinputs = [expandedUserInputs[0]]
-                } else if (this.caps[Capabilities.SCRIPTING_UTTEXPANSION_MODE] === 'random') {
-                  sampleinputs = 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])
+                // let sampleinputs = expandedUserInputs
+                const processSampleInputs = (sampleinputs, myContext, uiIndex) => {
+                  sampleinputs.forEach((input, index) => {
+                    processSampleInput(input, sampleinputs.length, index, Object.assign({ indexExpansionModeIndex: index }, myContext || context), uiIndex)
+                  })
                 }
-                sampleinputs.forEach((sampleinput, index) => {
-                  const lineTag = `${index + 1}`.padStart(`${sampleinputs.length}`.length, '0')
+                const processSampleInput = (sampleinput, length, index, myContext, uiIndex) => {
+                  const lineTag = `${index + 1}`.padStart(`${length}`.length, '0')
                   const currentStepsStack = convoStepsStack.slice()
                   const currentStepMod = _.cloneDeep(currentStep)
                   currentStepMod.userInputs[uiIndex] = sampleinput
@@ -949,8 +1004,46 @@ module.exports = class ScriptingProvider {
                   currentStepsStack.push(currentStepMod)
                   const currentConvoLabeled = _.cloneDeep(currentConvo)
                   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)
-                })
+                  this._expandConvo(expandedConvos, currentConvoLabeled, convoStepIndex + 1, currentStepsStack, myContext || context)
+                }
+                if (this.caps[Capabilities.SCRIPTING_UTTEXPANSION_MODE] === 'index') {
+                  if (_.isNil(context.indexExpansionModeWidth)) {
+                    processSampleInputs(expandedUserInputs, Object.assign({}, context, { indexExpansionModeWidth: expandedUserInputs.length }), uiIndex)
+                  } else {
+                    if (_.isNil(context.indexExpansionModeIndex)) {
+                      throw new Error('indexExpansionModeIndex must be set!')
+                    }
+                    // executing the current 'thread', if current utterance has no example to current index, fallback to the last one
+                    const localIndex = Math.min(context.indexExpansionModeIndex, expandedUserInputs.length - 1)
+                    if (localIndex < context.indexExpansionModeIndex && context.indexExpansionModeIndex === context.indexExpansionModeWidth - 1) {
+                      debug(`While expanding convos by index found user input "${ui.name}, ${ui.args}" less examples (${expandedUserInputs.length}) as expected (${context.indexExpansionModeWidth})`)
+                    }
+                    const myContext = Object.assign({}, context, { indexExpansionModeWidth: Math.max(expandedUserInputs.length, context.indexExpansionModeWidth) })
+                    processSampleInput(expandedUserInputs[localIndex], expandedUserInputs.length, localIndex, myContext, uiIndex)
+                    if (expandedUserInputs.length > context.indexExpansionModeWidth && context.indexExpansionModeIndex + 1 === context.indexExpansionModeWidth) {
+                      debug(`While expanding convos by index found user input "${ui.name}, ${ui.args}" more examples (${expandedUserInputs.length}) as expected (${context.indexExpansionModeWidth})`)
+                      for (let i = context.indexExpansionModeWidth; i < expandedUserInputs.length; i++) {
+                        const myContext = Object.assign({}, context, { indexExpansionModeWidth: expandedUserInputs.length, indexExpansionModeIndex: i })
+                        processSampleInput(expandedUserInputs[i], expandedUserInputs.length, i, myContext, uiIndex)
+                      }
+                    }
+                  }
+                } else {
+                  if (this.caps[Capabilities.SCRIPTING_UTTEXPANSION_MODE] === 'first') {
+                    processSampleInputs([expandedUserInputs[0]], context, uiIndex)
+                  } else if (this.caps[Capabilities.SCRIPTING_UTTEXPANSION_MODE] === 'random') {
+                    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)
+                  }
+                }
                 useUnexpanded = false
               }
             }
@@ -959,7 +1052,7 @@ module.exports = class ScriptingProvider {
         if (useUnexpanded) {
           const currentStepsStack = convoStepsStack.slice()
           currentStepsStack.push(_.cloneDeep(currentStep))
-          this._expandConvo(expandedConvos, currentConvo, convoStepIndex + 1, currentStepsStack)
+          this._expandConvo(expandedConvos, currentConvo, convoStepIndex + 1, currentStepsStack, context)
         }
       }
     } else {

package/src/scripting/logichook/LogicHookConsts.js

@@ -45,7 +45,7 @@ module.exports = {
     { name: 'TEXT_EQUALS_IC', className: 'TextEqualsAnyICAsserter' },
     { name: 'TEXT', className: 'TextEqualsAnyAsserter' },
     { name: 'TEXT_IC', className: 'TextEqualsAnyICAsserter' },
-
+    { name: 'TEXT_WER', className: 'WerAsserter' },
     { name: 'BOT_CONSUMED', className: 'BotRepliesConsumedAsserter' },
     { name: 'BOT_UNCONSUMED_COUNT', className: 'BotRepliesUnconsumedCountAsserter' }
   ],