botium-core 1.14.1 → 1.14.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "botium-core",
-  "version": "1.14.1",
+  "version": "1.14.3",
   "description": "The Selenium for Chatbots",
   "main": "index.js",
   "module": "dist/botium-es.js",
@@ -31,12 +31,12 @@
   },
   "homepage": "https://www.botium.ai",
   "dependencies": {
-    "@babel/runtime": "^7.23.2",
+    "@babel/runtime": "^7.23.5",
     "async": "^3.2.5",
     "body-parser": "^1.20.2",
     "boolean": "^3.2.0",
     "bottleneck": "^2.19.5",
-    "csv-parse": "^5.5.2",
+    "csv-parse": "^5.5.3",
     "debug": "^4.3.4",
     "express": "^4.18.2",
     "globby": "11.0.4",
@@ -45,7 +45,7 @@
     "is-json": "^2.0.1",
     "jsonpath": "^1.1.1",
     "lodash": "^4.17.21",
-    "markdown-it": "^13.0.2",
+    "markdown-it": "^14.0.0",
     "mime-types": "^2.1.35",
     "mkdirp": "^3.0.1",
     "moment": "^2.29.4",
@@ -71,23 +71,23 @@
     "yaml": "^2.3.4"
   },
   "devDependencies": {
-    "@babel/core": "^7.23.3",
+    "@babel/core": "^7.23.5",
     "@babel/node": "^7.22.19",
-    "@babel/plugin-transform-runtime": "^7.23.3",
-    "@babel/preset-env": "^7.23.3",
+    "@babel/plugin-transform-runtime": "^7.23.4",
+    "@babel/preset-env": "^7.23.5",
     "chai": "^4.3.10",
     "chai-as-promised": "^7.1.1",
     "cross-env": "^7.0.3",
-    "eslint": "^8.53.0",
+    "eslint": "^8.55.0",
     "eslint-config-standard": "^17.1.0",
     "eslint-plugin-import": "^2.29.0",
     "eslint-plugin-mocha": "^10.2.0",
-    "eslint-plugin-n": "^16.3.1",
+    "eslint-plugin-n": "^16.4.0",
     "eslint-plugin-promise": "^6.1.1",
     "eslint-plugin-standard": "^4.1.0",
     "mocha": "^10.2.0",
-    "nock": "^13.3.8",
-    "npm-check-updates": "^16.14.6",
+    "nock": "^13.4.0",
+    "npm-check-updates": "^16.14.11",
     "nyc": "^15.1.0",
     "rollup": "2.79.1",
     "rollup-plugin-babel": "^4.4.0",

package/src/Capabilities.js

@@ -157,6 +157,8 @@ module.exports = {
   // varnames, testcasenames
   SCRIPTING_MEMORY_COLUMN_MODE: 'SCRIPTING_MEMORY_COLUMN_MODE',
   // Botium Lifecycle Hooks
+  SCRIPTING_CONVO_STEP_PARAMETERS: 'SCRIPTING_CONVO_STEP_PARAMETERS',
+  // Botium Lifecycle Hooks
   CUSTOMHOOK_ONBUILD: 'CUSTOMHOOK_ONBUILD',
   CUSTOMHOOK_ONSTART: 'CUSTOMHOOK_ONSTART',
   CUSTOMHOOK_ONUSERSAYS: 'CUSTOMHOOK_ONUSERSAYS',

package/src/scripting/BotiumError.js

@@ -90,6 +90,43 @@ const BotiumError = class BotiumError extends Error {
       return null
     }
   }
+
+  hasError ({ type, source }) {
+    if (this.context) {
+      const errArr = _.isArray(this.context) ? this.context : [this.context]
+      for (const err of errArr) {
+        if (err.type === 'list') {
+          for (const internal of err.errors) {
+            if ((!type || internal.type === type) && (!source || internal.source === source)) {
+              return true
+            }
+          }
+        }
+        if ((!type || err.type === type) && (!source || err.source === source)) {
+          return true
+        }
+      }
+    } else {
+      return false
+    }
+  }
+
+  toArray () {
+    if (this.context) {
+      let result = []
+      const errArr = _.isArray(this.context) ? this.context : [this.context]
+      for (const err of errArr) {
+        if (err.type === 'list') {
+          result = result.concat(err.errors)
+        } else {
+          result.push(err)
+        }
+      }
+      return result
+    } else {
+      return []
+    }
+  }
 }
 
 const _getChildErrorsFromContext = (context) => {
@@ -99,11 +136,11 @@ const _getChildErrorsFromContext = (context) => {
   return false
 }
 
-const botiumErrorFromErr = (message, err) => {
+const botiumErrorFromErr = (message, err, context = {}) => {
   if (err instanceof BotiumError) {
-    return new BotiumError(message, err.context, true)
+    return new BotiumError(message, { ...err.context, ...context }, true)
   } else {
-    return new BotiumError(message, { err }, true)
+    return new BotiumError(message, { err, ...context }, true)
   }
 }
 

package/src/scripting/Convo.js

@@ -277,8 +277,55 @@ class Convo {
       let skipTranscriptStep = false
       let conditionalGroupId = null
       let conditionMetInGroup = false
-      for (let i = 0; i < this.conversation.length; i++) {
+      let globalConvoStepParameters = container.caps[Capabilities.SCRIPTING_CONVO_STEP_PARAMETERS] || {}
+      let retryBotMessageTimeoutEnd = null
+      let retryBotMessageConvoId = null
+      let retryBotMessageDropBotResponse = false
+      for (let i = 0; i < this.conversation.length; i = (retryBotMessageDropBotResponse ? i : i + 1)) {
+        retryBotMessageDropBotResponse = false
         const convoStep = this.conversation[i]
+        const rawConvoStepParameters = convoStep.logicHooks.find(lh => lh.name === 'CONVO_STEP_PARAMETERS')?.args
+        let convoStepParameters = {}
+        if (rawConvoStepParameters && rawConvoStepParameters.length) {
+          let params
+          if (rawConvoStepParameters[0].trim().startsWith('{')) {
+            try {
+              params = JSON.parse(rawConvoStepParameters[0])
+            } catch (e) {
+              debug(`${this.header.name}/${convoStep.stepTag}: Failed to parse convo step parameters from JSON ${rawConvoStepParameters[0]}`)
+            }
+          }
+          if (!params || !Object.keys(params).length) {
+            params = {}
+            for (const param of rawConvoStepParameters) {
+              const semicolon = param.indexOf(':')
+              if (semicolon) {
+                try {
+                  const name = param.substring(0, semicolon)
+                  const value = param.substring(semicolon + 1)
+                  params[name] = value
+                } catch (e) {
+                  debug(`${this.header.name}/${convoStep.stepTag}: Failed to parse convo step parameter from arg ${param}`)
+                }
+              }
+            }
+          }
+
+          if (convoStep.sender === 'begin') {
+            globalConvoStepParameters = Object.assign({}, globalConvoStepParameters || {}, params)
+          } else {
+            convoStepParameters = Object.assign({}, globalConvoStepParameters || {}, params)
+          }
+        } else {
+          if (convoStep.sender !== 'begin') {
+            convoStepParameters = globalConvoStepParameters
+          }
+        }
+
+        if (Object.keys(convoStepParameters).length) {
+          debug(`${this.header.name}: using convo step parameters ${JSON.stringify(convoStepParameters)}`)
+        }
+
         const currentStepIndex = i
         container.eventEmitter.emit(Events.CONVO_STEP_NEXT, container, convoStep, i)
         skipTranscriptStep = false
@@ -319,8 +366,8 @@ class Convo {
               const coreMsg = _.omit(removeBuffers(meMsg), ['sourceData'])
               debug(`${this.header.name}/${convoStep.stepTag}: user says (cleaned by binary and base64 data and sourceData) ${JSON.stringify(coreMsg, null, 2)}`)
               await new Promise(resolve => {
-                if (container.caps.SIMULATE_WRITING_SPEED && meMsg.messageText && meMsg.messageText.length) {
-                  setTimeout(() => resolve(), container.caps.SIMULATE_WRITING_SPEED * meMsg.messageText.length)
+                if (container.caps[Capabilities.SIMULATE_WRITING_SPEED] && meMsg.messageText && meMsg.messageText.length) {
+                  setTimeout(() => resolve(), container.caps[Capabilities.SIMULATE_WRITING_SPEED] * meMsg.messageText.length)
                 } else {
                   resolve()
                 }
@@ -453,11 +500,32 @@ class Convo {
             }
             const isErrorHandledWithOptionConvoStep = (err) => {
               const nextConvoStep = this.conversation[i + 1]
+              const retryConfig = convoStepParameters?.ignoreNotMatchedBotResponses
+              const retryOn = convoStep.sender === 'bot' && retryConfig && retryConfig.timeout && retryConfig.mainAsserter
               if (convoStep.optional && nextConvoStep && nextConvoStep.sender === 'bot') {
+                if (retryOn) {
+                  debug(`${this.header.name}/${convoStep.stepTag}: Retry failed asserter is ignored on optional convo`)
+                }
                 waitForBotSays = false
                 skipTranscriptStep = true
                 return true
+              } else if (retryOn) {
+                if (!retryBotMessageTimeoutEnd || retryBotMessageConvoId !== convoStep.stepTag) {
+                  retryBotMessageTimeoutEnd = transcriptStep.stepBegin.getTime() + +retryConfig.timeout
+                  retryBotMessageConvoId = convoStep.stepTag
+                }
+
+                const now = new Date().getTime()
+                const timeoutRemaining = retryBotMessageTimeoutEnd - now
+                if (timeoutRemaining > 0) {
+                  debug(`${this.header.name}/${convoStep.stepTag}: Convo step retry on, timeout remaining: ${timeoutRemaining}, error: "${err.message}"`)
+                  retryBotMessageDropBotResponse = true
+                  return false
+                } else {
+                  debug(`${this.header.name}/${convoStep.stepTag}: Convo step retry on, but timeout is over. error: "${err.message}"`)
+                }
               }
+
               if (container.caps[Capabilities.SCRIPTING_ENABLE_MULTIPLE_ASSERT_ERRORS]) {
                 assertErrors.push(err)
                 return false
@@ -474,7 +542,7 @@ class Convo {
               const tomatch = this._resolveUtterancesToMatch(container, Object.assign({}, scriptingMemoryUpdate, scriptingMemory), messageText, botMsg)
               if (convoStep.not) {
                 try {
-                  this.scriptingEvents.assertBotNotResponse(response, tomatch, `${this.header.name}/${convoStep.stepTag}`, lastMeConvoStep)
+                  this.scriptingEvents.assertBotNotResponse(response, tomatch, `${this.header.name}/${convoStep.stepTag}`, lastMeConvoStep, convoStepParameters)
                 } catch (err) {
                   if (isErrorHandledWithOptionConvoStep(err)) {
                     continue
@@ -482,7 +550,7 @@ class Convo {
                 }
               } else {
                 try {
-                  this.scriptingEvents.assertBotResponse(response, tomatch, `${this.header.name}/${convoStep.stepTag}`, lastMeConvoStep)
+                  this.scriptingEvents.assertBotResponse(response, tomatch, `${this.header.name}/${convoStep.stepTag}`, lastMeConvoStep, convoStepParameters)
                 } catch (err) {
                   if (isErrorHandledWithOptionConvoStep(err)) {
                     continue
@@ -491,7 +559,7 @@ class Convo {
               }
             } else if (convoStep.sourceData) {
               try {
-                this._compareObject(container, scriptingMemory, convoStep, botMsg.sourceData, convoStep.sourceData, botMsg)
+                this._compareObject(container, scriptingMemory, convoStep, botMsg.sourceData, convoStep.sourceData, botMsg, convoStepParameters)
               } catch (err) {
                 if (isErrorHandledWithOptionConvoStep(err)) {
                   continue
@@ -509,20 +577,46 @@ class Convo {
                 skipTranscriptStep = true
                 continue
               }
-              const failErr = botiumErrorFromErr(`${this.header.name}/${convoStep.stepTag}: assertion error - ${err.message || err}`, err)
-              debug(failErr)
-              try {
-                this.scriptingEvents.fail && this.scriptingEvents.fail(failErr, lastMeConvoStep)
-              } catch (failErr) {
+
+              const errors = err.toArray ? err.toArray() : []
+              const retryConfig = convoStepParameters?.ignoreNotMatchedBotResponses
+              const retryOn =
+                convoStep.sender === 'bot' &&
+                retryConfig &&
+                retryConfig.timeout &&
+                errors.length &&
+                errors.filter(({ type, source, asserter }) => type === 'asserter' && (retryConfig.allAsserters || (retryConfig.asserters && retryConfig.asserters.includes(asserter)))).length
+              if (retryOn && (!retryBotMessageTimeoutEnd || retryBotMessageConvoId !== convoStep.stepTag)) {
+                retryBotMessageTimeoutEnd = transcriptStep.stepBegin.getTime() + +retryConfig.timeout
+                retryBotMessageConvoId = convoStep.stepTag
               }
-              if (container.caps[Capabilities.SCRIPTING_ENABLE_MULTIPLE_ASSERT_ERRORS] && err instanceof BotiumError) {
-                assertErrors.push(err)
+
+              const now = new Date().getTime()
+              const timeoutRemaining = retryOn && (retryBotMessageTimeoutEnd - now)
+              if (retryOn && timeoutRemaining > 0) {
+                debug(`${this.header.name}/${convoStep.stepTag}: Convo step retry on, timeout remaining: ${timeoutRemaining}, error: "${err.message}"`)
+                retryBotMessageDropBotResponse = true
               } else {
-                throw failErr
+                if (retryOn && timeoutRemaining <= 0) {
+                  debug(`${this.header.name}/${convoStep.stepTag}: Convo step retry on, but timeout is over. error: "${err.message}"`)
+                }
+                const failErr = botiumErrorFromErr(`${this.header.name}/${convoStep.stepTag}: assertion error - ${err.message || err}`, err)
+                debug(failErr)
+                try {
+                  this.scriptingEvents.fail && this.scriptingEvents.fail(failErr, lastMeConvoStep)
+                } catch (failErr) {
+                }
+                if (container.caps[Capabilities.SCRIPTING_ENABLE_MULTIPLE_ASSERT_ERRORS] && err instanceof BotiumError) {
+                  assertErrors.push(err)
+                } else {
+                  throw failErr
+                }
               }
             }
             if (container.caps[Capabilities.SCRIPTING_ENABLE_MULTIPLE_ASSERT_ERRORS]) {
               if (assertErrors.length > 0) {
+                // this has no effect, but logically it has to be false
+                retryBotMessageDropBotResponse = false
                 throw botiumErrorFromList(assertErrors, {})
               }
             } else {
@@ -580,7 +674,7 @@ class Convo {
     }
   }
 
-  _compareObject (container, scriptingMemory, convoStep, result, expected, botMsg) {
+  _compareObject (container, scriptingMemory, convoStep, result, expected, botMsg, convoStepParameters) {
     if (expected === null || expected === undefined) return
 
     if (_.isArray(expected)) {
@@ -591,12 +685,12 @@ class Convo {
         throw new BotiumError(`${this.header.name}/${convoStep.stepTag}: bot response expected array length ${expected.length}, got ${result.length}`)
       }
       for (let i = 0; i < expected.length; i++) {
-        this._compareObject(container, scriptingMemory, convoStep, result[i], expected[i])
+        this._compareObject(container, scriptingMemory, convoStep, result[i], expected[i], null, convoStepParameters)
       }
     } else if (_.isObject(expected)) {
       _.forOwn(expected, (value, key) => {
         if (Object.prototype.hasOwnProperty.call(result, key)) {
-          this._compareObject(container, scriptingMemory, convoStep, result[key], expected[key])
+          this._compareObject(container, scriptingMemory, convoStep, result[key], expected[key], null, convoStepParameters)
         } else {
           throw new BotiumError(`${this.header.name}/${convoStep.stepTag}: bot response "${result}" missing expected property: ${key}`)
         }
@@ -605,7 +699,7 @@ class Convo {
       ScriptingMemory.fill(container, scriptingMemory, result, expected, this.scriptingEvents)
       const response = this._checkNormalizeText(container, result)
       const tomatch = this._resolveUtterancesToMatch(container, scriptingMemory, expected, botMsg)
-      this.scriptingEvents.assertBotResponse(response, tomatch, `${this.header.name}/${convoStep.stepTag}`)
+      this.scriptingEvents.assertBotResponse(response, tomatch, `${this.header.name}/${convoStep.stepTag}`, null, convoStepParameters)
     }
   }
 
@@ -673,7 +767,7 @@ class Convo {
   }
 
   _checkBotRepliesConsumed (container) {
-    if (container.caps.SCRIPTING_FORCE_BOT_CONSUMED) {
+    if (container.caps[Capabilities.SCRIPTING_FORCE_BOT_CONSUMED]) {
       const queueLength = container._QueueLength()
       if (queueLength === 1) {
         throw new Error('There is an unread bot reply in queue')

package/src/scripting/ScriptingMemory.js

@@ -261,6 +261,13 @@ const _apply = (scriptingMemory, str, caps, mockMsg) => {
                 return arg
               }
             })
+            args = args.map(arg => {
+              const argStr = `${arg}`
+              if (argStr.startsWith('$')) {
+                return scriptingMemory[argStr.substring(1)] || arg
+              }
+              return arg
+            })
             str = str.replace(match, SCRIPTING_FUNCTIONS[key].handler(caps, ...args, mockMsg))
           } else {
             str = str.replace(match, SCRIPTING_FUNCTIONS[key].handler(caps))

package/src/scripting/ScriptingProvider.js

@@ -92,37 +92,37 @@ module.exports = class ScriptingProvider {
 
     this.scriptingEvents = {
       onConvoBegin: ({ convo, convoStep, scriptingMemory, ...rest }) => {
-        return this._createLogicHookPromises({ hookType: 'onConvoBegin', logicHooks: (convo.beginLogicHook || []), convo, convoStep, scriptingMemory, ...rest })
+        return this._createLogicHookPromises({ hookType: 'onConvoBegin', logicHooks: (convo?.beginLogicHook || []), convo, convoStep, scriptingMemory, ...rest })
       },
       onConvoEnd: ({ convo, convoStep, scriptingMemory, ...rest }) => {
-        return this._createLogicHookPromises({ hookType: 'onConvoEnd', logicHooks: (convo.endLogicHook || []), convo, convoStep, scriptingMemory, ...rest })
+        return this._createLogicHookPromises({ hookType: 'onConvoEnd', logicHooks: (convo?.endLogicHook || []), convo, convoStep, scriptingMemory, ...rest })
       },
       onMeStart: ({ convo, convoStep, scriptingMemory, ...rest }) => {
-        return this._createLogicHookPromises({ hookType: 'onMeStart', logicHooks: (convoStep.logicHooks || []), convo, convoStep, scriptingMemory, ...rest })
+        return this._createLogicHookPromises({ hookType: 'onMeStart', logicHooks: (convoStep?.logicHooks || []), convo, convoStep, scriptingMemory, ...rest })
       },
       onMePrepare: ({ convo, convoStep, scriptingMemory, ...rest }) => {
-        return this._createLogicHookPromises({ hookType: 'onMePrepare', logicHooks: (convoStep.logicHooks || []), convo, convoStep, scriptingMemory, ...rest })
+        return this._createLogicHookPromises({ hookType: 'onMePrepare', logicHooks: (convoStep?.logicHooks || []), convo, convoStep, scriptingMemory, ...rest })
       },
       onMeEnd: ({ convo, convoStep, scriptingMemory, ...rest }) => {
-        return this._createLogicHookPromises({ hookType: 'onMeEnd', logicHooks: (convoStep.logicHooks || []), convo, convoStep, scriptingMemory, ...rest })
+        return this._createLogicHookPromises({ hookType: 'onMeEnd', logicHooks: (convoStep?.logicHooks || []), convo, convoStep, scriptingMemory, ...rest })
       },
       onBotStart: ({ convo, convoStep, scriptingMemory, ...rest }) => {
-        return this._createLogicHookPromises({ hookType: 'onBotStart', logicHooks: (convoStep.logicHooks || []), convo, convoStep, scriptingMemory, ...rest })
+        return this._createLogicHookPromises({ hookType: 'onBotStart', logicHooks: (convoStep?.logicHooks || []), convo, convoStep, scriptingMemory, ...rest })
       },
       onBotPrepare: ({ convo, convoStep, scriptingMemory, ...rest }) => {
-        return this._createLogicHookPromises({ hookType: 'onBotPrepare', logicHooks: (convoStep.logicHooks || []), convo, convoStep, scriptingMemory, ...rest })
+        return this._createLogicHookPromises({ hookType: 'onBotPrepare', logicHooks: (convoStep?.logicHooks || []), convo, convoStep, scriptingMemory, ...rest })
       },
       onBotEnd: ({ convo, convoStep, scriptingMemory, ...rest }) => {
-        return this._createLogicHookPromises({ hookType: 'onBotEnd', logicHooks: (convoStep.logicHooks || []), convo, convoStep, scriptingMemory, ...rest })
+        return this._createLogicHookPromises({ hookType: 'onBotEnd', logicHooks: (convoStep?.logicHooks || []), convo, convoStep, scriptingMemory, ...rest })
       },
       assertConvoBegin: ({ convo, convoStep, scriptingMemory, ...rest }) => {
-        return this._createAsserterPromises({ asserterType: 'assertConvoBegin', asserters: (convo.beginAsserter || []), convo, convoStep, scriptingMemory, ...rest })
+        return this._createAsserterPromises({ asserterType: 'assertConvoBegin', asserters: (convo?.beginAsserter || []), convo, convoStep, scriptingMemory, ...rest })
       },
       assertConvoStep: ({ convo, convoStep, scriptingMemory, ...rest }) => {
-        return this._createAsserterPromises({ asserterType: 'assertConvoStep', asserters: (convoStep.asserters || []), convo, convoStep, scriptingMemory, ...rest })
+        return this._createAsserterPromises({ asserterType: 'assertConvoStep', asserters: (convoStep?.asserters || []), convo, convoStep, scriptingMemory, ...rest })
       },
       assertConvoEnd: ({ convo, convoStep, scriptingMemory, ...rest }) => {
-        return this._createAsserterPromises({ asserterType: 'assertConvoEnd', asserters: (convo.endAsserter || []), convo, convoStep, scriptingMemory, ...rest })
+        return this._createAsserterPromises({ asserterType: 'assertConvoEnd', asserters: (convo?.endAsserter || []), convo, convoStep, scriptingMemory, ...rest })
       },
       setUserInput: ({ convo, convoStep, scriptingMemory, ...rest }) => {
         return this._createUserInputPromises({ convo, convoStep, scriptingMemory, ...rest })
@@ -130,12 +130,13 @@ module.exports = class ScriptingProvider {
       resolveUtterance: ({ utterance, resolveEmptyIfUnknown }) => {
         return this._resolveUtterance({ utterance, resolveEmptyIfUnknown })
       },
-      assertBotResponse: (botresponse, tomatch, stepTag, meMsg) => {
+      assertBotResponse: (botresponse, tomatch, stepTag, meMsg, convoStepParameters) => {
         if (!_.isArray(tomatch)) {
           tomatch = [tomatch]
         }
         debug(`assertBotResponse ${stepTag} ${meMsg ? `(${meMsg}) ` : ''}BOT: ${botresponse} = ${tomatch} ...`)
-        const found = _.find(tomatch, (utt) => this.matchFn(botresponse, utt, this.caps[Capabilities.SCRIPTING_MATCHING_MODE_ARGS]))
+        const matchFn = convoStepParameters.matchingMode ? (getMatchFunction(convoStepParameters.matchingMode) || this.matchFn) : this.matchFn
+        const found = _.find(tomatch, (utt) => matchFn(botresponse, utt, this.caps[Capabilities.SCRIPTING_MATCHING_MODE_ARGS]))
         const asserterType = this.caps[Capabilities.SCRIPTING_MATCHING_MODE] === 'wer' ? 'Word Error Rate Asserter' : 'Text Match Asserter'
         if (_.isNil(found)) {
           if (this.caps[Capabilities.SCRIPTING_MATCHING_MODE] === 'wer') {
@@ -191,12 +192,13 @@ module.exports = class ScriptingProvider {
           }
         }
       },
-      assertBotNotResponse: (botresponse, nottomatch, stepTag, meMsg) => {
+      assertBotNotResponse: (botresponse, nottomatch, stepTag, meMsg, convoStepParameters) => {
         if (!_.isArray(nottomatch)) {
           nottomatch = [nottomatch]
         }
         debug(`assertBotNotResponse ${stepTag} ${meMsg ? `(${meMsg}) ` : ''}BOT: ${botresponse} != ${nottomatch} ...`)
-        const found = _.find(nottomatch, (utt) => this.matchFn(botresponse, utt, this.caps[Capabilities.SCRIPTING_MATCHING_MODE_ARGS]))
+        const matchFn = convoStepParameters.matchingMode ? (getMatchFunction(convoStepParameters.matchingMode) || this.matchFn) : this.matchFn
+        const found = _.find(nottomatch, (utt) => matchFn(botresponse, utt, this.caps[Capabilities.SCRIPTING_MATCHING_MODE_ARGS]))
         const asserterType = this.caps[Capabilities.SCRIPTING_MATCHING_MODE] === 'wer' ? 'Word Error Rate Asserter' : 'Text Match Asserter'
         if (!_.isNil(found)) {
           if (this.caps[Capabilities.SCRIPTING_MATCHING_MODE] === 'wer') {
@@ -270,6 +272,22 @@ module.exports = class ScriptingProvider {
       assertConvoStep: 'assertNotConvoStep',
       assertConvoEnd: 'assertNotConvoEnd'
     }
+    const updateExceptionContext = (promise, asserter) => {
+      const updateError = (err) => {
+        if (err instanceof BotiumError) {
+          if (!err.context) {
+            err.context = {}
+          }
+
+          err.context.asserter = asserter.name
+
+          throw err
+        } else {
+          throw botiumErrorFromErr(_.isString(err) ? err : err.message, err, { asserter: asserter.name })
+        }
+      }
+      return promise.catch(err => updateError(err))
+    }
     const callAsserter = (asserterSpec, asserter, params) => {
       if (asserterSpec.not) {
         const notAsserterType = mapNot[asserterType]
@@ -301,18 +319,35 @@ module.exports = class ScriptingProvider {
 
     const convoAsserter = asserters
       .filter(a => this.asserters[a.name][asserterType])
-      .map(a => callAsserter(a, this.asserters[a.name], {
-        convo,
-        convoStep,
-        scriptingMemory,
-        container,
-        args: ScriptingMemory.applyToArgs(a.args, scriptingMemory, container.caps, rest.botMsg),
-        isGlobal: false,
-        ...rest
+      .map(a => ({
+        asserter: a,
+        promise: callAsserter(a, this.asserters[a.name], {
+          convo,
+          convoStep,
+          scriptingMemory,
+          container,
+          args: ScriptingMemory.applyToArgs(a.args, scriptingMemory, container.caps, rest.botMsg),
+          isGlobal: false,
+          ...rest
+        })
       }))
+      .map(({ promise, asserter }) => updateExceptionContext(promise, asserter))
+
     const globalAsserter = Object.values(this.globalAsserter)
       .filter(a => a[asserterType])
-      .map(a => p(this.retryHelperAsserter, () => a[asserterType]({ convo, convoStep, scriptingMemory, container, args: [], isGlobal: true, ...rest })))
+      .map(a => ({
+        asserter: a,
+        promise: p(this.retryHelperAsserter, () => a[asserterType]({
+          convo,
+          convoStep,
+          scriptingMemory,
+          container,
+          args: [],
+          isGlobal: true,
+          ...rest
+        }))
+      }))
+      .map(({ promise, asserter }) => updateExceptionContext(promise, asserter))
 
     const allPromises = [...convoAsserter, ...globalAsserter]
     if (this.caps[Capabilities.SCRIPTING_ENABLE_MULTIPLE_ASSERT_ERRORS]) {
@@ -335,8 +370,10 @@ module.exports = class ScriptingProvider {
       throw Error(`Unknown hookType ${hookType}`)
     }
 
-    const convoStepPromises = (logicHooks || [])
+    const localHooks = (logicHooks || [])
       .filter(l => this.logicHooks[l.name][hookType])
+
+    const convoStepPromises = localHooks
       .map(l => p(this.retryHelperLogicHook, () => this.logicHooks[l.name][hookType]({
         convo,
         convoStep,
@@ -347,17 +384,24 @@ module.exports = class ScriptingProvider {
         ...rest
       })))
 
-    const globalPromises = Object.values(this.globalLogicHook)
-      .filter(l => l[hookType])
-      .map(l => p(this.retryHelperLogicHook, () => l[hookType]({ convo, convoStep, scriptingMemory, container, args: [], isGlobal: true, ...rest })))
+    const globalHooks = Object.values(this.globalLogicHook).filter(l => l[hookType])
+    const globalPromises = globalHooks.map(l => p(this.retryHelperLogicHook, () => l[hookType]({ convo, convoStep, scriptingMemory, container, args: [], isGlobal: true, ...rest })))
 
     const allPromises = [...convoStepPromises, ...globalPromises]
-    if (allPromises.length > 0) return Promise.all(allPromises).then(() => true)
+
+    if (allPromises.length > 0) {
+      return Promise.all(allPromises).then(() => {
+        return {
+          // just returning some humanreadable
+          hooks: [...localHooks, ...globalHooks].map(h => h.name || h.context?.ref || JSON.stringify(h))
+        }
+      })
+    }
     return Promise.resolve(false)
   }
 
   _createUserInputPromises ({ convo, convoStep, scriptingMemory, container, ...rest }) {
-    const convoStepPromises = (convoStep.userInputs || [])
+    const convoStepPromises = (convoStep?.userInputs || [])
       .filter(ui => this.userInputs[ui.name])
       .map(ui => p(this.retryHelperUserInput, () => this.userInputs[ui.name].setUserInput({
         convo,
@@ -424,6 +468,11 @@ module.exports = class ScriptingProvider {
     }
   }
 
+  // Livechat, and crawler using logichooks too. So they need script context
+  BuildScriptContext () {
+    return this._buildScriptContext()
+  }
+
   Build () {
     const CompilerXlsx = require('./CompilerXlsx')
     this.compilers[Constants.SCRIPTING_FORMAT_XSLX] = new CompilerXlsx(this._buildScriptContext(), this.caps)

package/src/scripting/logichook/LogicHookConsts.js

@@ -61,11 +61,14 @@ module.exports = {
     { name: 'CONDITIONAL_STEP_TIME_BASED', className: 'ConditionalTimeBasedLogicHook' },
     { name: 'CONDITIONAL_STEP_BUSINESS_HOURS', className: 'ConditionalBusinessHoursLogicHook' },
     { name: 'CONDITIONAL_STEP_CAPABILITY_VALUE_BASED', className: 'ConditionalCapabilityValueBasedLogicHook' },
-    { name: 'CONDITIONAL_STEP_JSON_PATH_BASED', className: 'ConditionalJsonPathBasedLogicHook.js' }
+    { name: 'CONDITIONAL_STEP_JSON_PATH_BASED', className: 'ConditionalJsonPathBasedLogicHook.js' },
+    { name: 'CONVO_STEP_PARAMETERS', className: 'ConvoStepParametersLogicHook.js' },
+    { name: 'ORDERED_LIST_TO_BUTTON', className: 'OrderedListToButtonLogicHook' }
   ],
   DEFAULT_USER_INPUTS: [
     { name: 'BUTTON', className: 'ButtonInput' },
     { name: 'MEDIA', className: 'MediaInput' },
     { name: 'FORM', className: 'FormInput' }
-  ]
+  ],
+  LOGIC_HOOK_EVENTS: ['onConvoBegin', 'onMeStart', 'onMePrepare', 'onMeEnd', 'onBotStart', 'onBotEnd', 'onBotPrepare', 'onConvoEnd']
 }

package/src/scripting/logichook/LogicHookUtils.js

@@ -147,19 +147,21 @@ module.exports = class LogicHookUtils {
       }
     }
 
+    const typeAsText = hookType === 'asserter' ? 'Asserter' : hookType === 'logichook' ? 'Logic Hook' : hookType === 'userinput' ? 'User Input' : 'Unknown'
+
     if (isClass(src)) {
       try {
         const CheckClass = src
         return new CheckClass({ ref, ...this.buildScriptContext }, this.caps, args)
       } catch (err) {
-        throw new Error(`Logic Hook specification ${ref} from class invalid: ${err.message}`)
+        throw new Error(`${typeAsText} specification ${ref} from class invalid: ${err.message}`)
       }
     }
     if (_.isFunction(src)) {
       try {
         return src({ ref, ...this.buildScriptContext }, this.caps, args)
       } catch (err) {
-        throw new Error(`Logic Hook specification ${ref} from function invalid: ${err.message}`)
+        throw new Error(`${typeAsText} specification ${ref} from function invalid: ${err.message}`)
       }
     }
     if (_.isObject(src) && !_.isString(src)) {
@@ -177,7 +179,7 @@ module.exports = class LogicHookUtils {
         }, {})
         return hookObject
       } catch (err) {
-        throw new Error(`Logic Hook specification ${ref} ${hookType} from provided src (${util.inspect(src)}) invalid: ${err.message}`)
+        throw new Error(`${typeAsText} specification ${ref} ${hookType} from provided src (${util.inspect(src)}) invalid: ${err.message}`)
       }
     }
 
@@ -230,7 +232,7 @@ module.exports = class LogicHookUtils {
               try {
                 return tryLoadFromSource(tryLoadFile, tryLoad.tryLoadAsserterByName)
               } catch (err) {
-                loadErr.push(`Logic Hook specification ${ref} ${hookType} from "${src}" invalid: ${err.message} `)
+                loadErr.push(`${typeAsText} specification ${ref} ${hookType} from "${src}" invalid: ${err.message} `)
               }
             }
           }
@@ -239,13 +241,13 @@ module.exports = class LogicHookUtils {
           try {
             return tryLoadFromSource(tryLoad.tryLoadPackageName, tryLoad.tryLoadAsserterByName)
           } catch (err) {
-            loadErr.push(`Logic Hook specification ${ref} ${hookType} from "${src}" invalid: ${err.message} `)
+            loadErr.push(`${typeAsText} specification ${ref} ${hookType} from "${src}" invalid: ${err.message} `)
           }
         }
       }
 
       loadErr.forEach(debug)
     }
-    throw new Error(`Logic Hook specification ${ref} ${hookType} from "${util.inspect(src)}" invalid : no loader available`)
+    throw new Error(`${typeAsText} specification ${ref} ${hookType} from "${util.inspect(src)}" invalid : no loader available`)
   }
 }

package/src/scripting/logichook/logichooks/ConvoStepParametersLogicHook.js

@@ -0,0 +1,6 @@
+/**
+ * This LogicHook is just a marker. It is used Convo Step parameters
+ * @type {module.ConvoStepParametersLogicHook}
+ */
+module.exports = class ConvoStepParametersLogicHook {
+}