botium-core 1.14.1 → 1.14.3

package/dist/botium-es.js

@@ -35,7 +35,7 @@ import express from 'express';
 import bodyParser from 'body-parser';
 
 var name = "botium-core";
-var version$1 = "1.14.1";
+var version$1 = "1.14.3";
 var description = "The Selenium for Chatbots";
 var main = "index.js";
 var module = "dist/botium-es.js";
@@ -66,12 +66,12 @@ var bugs = {
 };
 var homepage = "https://www.botium.ai";
 var 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",
@@ -80,7 +80,7 @@ var dependencies = {
 	"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",
@@ -106,23 +106,23 @@ var dependencies = {
 	yaml: "^2.3.4"
 };
 var 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",
@@ -325,6 +325,8 @@ var Capabilities = {
   // 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',
@@ -486,6 +488,7 @@ Capabilities.SCRIPTING_UTTEXPANSION_NAMING_UTTERANCE_MAX;
 Capabilities.SCRIPTING_MEMORYEXPANSION_KEEP_ORIG;
 Capabilities.SCRIPTING_MEMORY_MATCHING_MODE;
 Capabilities.SCRIPTING_MEMORY_COLUMN_MODE;
+Capabilities.SCRIPTING_CONVO_STEP_PARAMETERS;
 Capabilities.CUSTOMHOOK_ONBUILD;
 Capabilities.CUSTOMHOOK_ONSTART;
 Capabilities.CUSTOMHOOK_ONUSERSAYS;
@@ -1034,6 +1037,12 @@ var LogicHookConsts = {
   }, {
     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',
@@ -1044,12 +1053,14 @@ var LogicHookConsts = {
   }, {
     name: 'FORM',
     className: 'FormInput'
-  }]
+  }],
+  LOGIC_HOOK_EVENTS: ['onConvoBegin', 'onMeStart', 'onMePrepare', 'onMeEnd', 'onBotStart', 'onBotEnd', 'onBotPrepare', 'onConvoEnd']
 };
 LogicHookConsts.LOGIC_HOOK_INCLUDE;
 LogicHookConsts.DEFAULT_ASSERTERS;
 LogicHookConsts.DEFAULT_LOGIC_HOOKS;
 LogicHookConsts.DEFAULT_USER_INPUTS;
+LogicHookConsts.LOGIC_HOOK_EVENTS;
 
 const debug$m = debug$n('botium-core-asserterUtils');
 const {
@@ -1200,6 +1211,7 @@ var LogicHookUtils_1 = class LogicHookUtils {
         throw new Error(`Logic Hook specification ${ref} ${hookType} (${packageName}) invalid: ${err.message}`);
       }
     }
+    const typeAsText = hookType === 'asserter' ? 'Asserter' : hookType === 'logichook' ? 'Logic Hook' : hookType === 'userinput' ? 'User Input' : 'Unknown';
     if (isClass(src)) {
       try {
         const CheckClass = src;
@@ -1208,7 +1220,7 @@ var LogicHookUtils_1 = class LogicHookUtils {
           ...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 (lodash.isFunction(src)) {
@@ -1218,7 +1230,7 @@ var LogicHookUtils_1 = class LogicHookUtils {
           ...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 (lodash.isObject(src) && !lodash.isString(src)) {
@@ -1236,7 +1248,7 @@ var LogicHookUtils_1 = 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}`);
       }
     }
     if (lodash.isString(src)) {
@@ -1297,7 +1309,7 @@ var LogicHookUtils_1 = 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} `);
               }
             }
           }
@@ -1306,13 +1318,13 @@ var LogicHookUtils_1 = 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$m);
     }
-    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`);
   }
 };
 
@@ -2205,6 +2217,44 @@ const BotiumError$4 = class BotiumError extends Error {
       return null;
     }
   }
+  hasError({
+    type,
+    source
+  }) {
+    if (this.context) {
+      const errArr = lodash.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 = lodash.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 => {
   if (context && context.errors && lodash.isArray(context.errors)) {
@@ -2212,12 +2262,16 @@ const _getChildErrorsFromContext = context => {
   }
   return false;
 };
-const botiumErrorFromErr$2 = (message, err) => {
+const botiumErrorFromErr$2 = (message, err, context = {}) => {
   if (err instanceof BotiumError$4) {
-    return new BotiumError$4(message, err.context, true);
+    return new BotiumError$4(message, {
+      ...err.context,
+      ...context
+    }, true);
   } else {
     return new BotiumError$4(message, {
-      err
+      err,
+      ...context
     }, true);
   }
 };
@@ -2492,6 +2546,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$1[key].handler(caps, ...args, mockMsg));
           } else {
             str = str.replace(match, SCRIPTING_FUNCTIONS$1[key].handler(caps));
@@ -2871,8 +2932,52 @@ class Convo$6 {
       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$j(`${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$j(`${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$j(`${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;
@@ -2936,8 +3041,8 @@ class Convo$6 {
               const coreMsg = lodash.omit(removeBuffers(meMsg), ['sourceData']);
               debug$j(`${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();
                 }
@@ -3091,10 +3196,29 @@ class Convo$6 {
             }
             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$j(`${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$j(`${this.header.name}/${convoStep.stepTag}: Convo step retry on, timeout remaining: ${timeoutRemaining}, error: "${err.message}"`);
+                  retryBotMessageDropBotResponse = true;
+                  return false;
+                } else {
+                  debug$j(`${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);
@@ -3112,7 +3236,7 @@ class Convo$6 {
               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;
@@ -3120,7 +3244,7 @@ class Convo$6 {
                 }
               } 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;
@@ -3129,7 +3253,7 @@ class Convo$6 {
               }
             } 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;
@@ -3163,19 +3287,42 @@ class Convo$6 {
                 skipTranscriptStep = true;
                 continue;
               }
-              const failErr = botiumErrorFromErr$1(`${this.header.name}/${convoStep.stepTag}: assertion error - ${err.message || err}`, err);
-              debug$j(failErr);
-              try {
-                this.scriptingEvents.fail && this.scriptingEvents.fail(failErr, lastMeConvoStep);
-              } catch (failErr) {}
-              if (container.caps[Capabilities.SCRIPTING_ENABLE_MULTIPLE_ASSERT_ERRORS] && err instanceof BotiumError$2) {
-                assertErrors.push(err);
+              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;
+              }
+              const now = new Date().getTime();
+              const timeoutRemaining = retryOn && retryBotMessageTimeoutEnd - now;
+              if (retryOn && timeoutRemaining > 0) {
+                debug$j(`${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$j(`${this.header.name}/${convoStep.stepTag}: Convo step retry on, but timeout is over. error: "${err.message}"`);
+                }
+                const failErr = botiumErrorFromErr$1(`${this.header.name}/${convoStep.stepTag}: assertion error - ${err.message || err}`, err);
+                debug$j(failErr);
+                try {
+                  this.scriptingEvents.fail && this.scriptingEvents.fail(failErr, lastMeConvoStep);
+                } catch (failErr) {}
+                if (container.caps[Capabilities.SCRIPTING_ENABLE_MULTIPLE_ASSERT_ERRORS] && err instanceof BotiumError$2) {
+                  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$1(assertErrors, {});
               }
             } else {
@@ -3235,7 +3382,7 @@ class Convo$6 {
       }
     }
   }
-  _compareObject(container, scriptingMemory, convoStep, result, expected, botMsg) {
+  _compareObject(container, scriptingMemory, convoStep, result, expected, botMsg, convoStepParameters) {
     if (expected === null || expected === undefined) return;
     if (lodash.isArray(expected)) {
       if (!lodash.isArray(result)) {
@@ -3245,12 +3392,12 @@ class Convo$6 {
         throw new BotiumError$2(`${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 (lodash.isObject(expected)) {
       lodash.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$2(`${this.header.name}/${convoStep.stepTag}: bot response "${result}" missing expected property: ${key}`);
         }
@@ -3259,7 +3406,7 @@ class Convo$6 {
       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);
     }
   }
   GetScriptingMemoryAllVariables(container) {
@@ -3319,7 +3466,7 @@ class Convo$6 {
     }, []);
   }
   _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');
@@ -5363,7 +5510,7 @@ var ScriptingProvider_1 = class ScriptingProvider {
       }) => {
         return this._createLogicHookPromises({
           hookType: 'onConvoBegin',
-          logicHooks: convo.beginLogicHook || [],
+          logicHooks: convo?.beginLogicHook || [],
           convo,
           convoStep,
           scriptingMemory,
@@ -5378,7 +5525,7 @@ var ScriptingProvider_1 = class ScriptingProvider {
       }) => {
         return this._createLogicHookPromises({
           hookType: 'onConvoEnd',
-          logicHooks: convo.endLogicHook || [],
+          logicHooks: convo?.endLogicHook || [],
           convo,
           convoStep,
           scriptingMemory,
@@ -5393,7 +5540,7 @@ var ScriptingProvider_1 = class ScriptingProvider {
       }) => {
         return this._createLogicHookPromises({
           hookType: 'onMeStart',
-          logicHooks: convoStep.logicHooks || [],
+          logicHooks: convoStep?.logicHooks || [],
           convo,
           convoStep,
           scriptingMemory,
@@ -5408,7 +5555,7 @@ var ScriptingProvider_1 = class ScriptingProvider {
       }) => {
         return this._createLogicHookPromises({
           hookType: 'onMePrepare',
-          logicHooks: convoStep.logicHooks || [],
+          logicHooks: convoStep?.logicHooks || [],
           convo,
           convoStep,
           scriptingMemory,
@@ -5423,7 +5570,7 @@ var ScriptingProvider_1 = class ScriptingProvider {
       }) => {
         return this._createLogicHookPromises({
           hookType: 'onMeEnd',
-          logicHooks: convoStep.logicHooks || [],
+          logicHooks: convoStep?.logicHooks || [],
           convo,
           convoStep,
           scriptingMemory,
@@ -5438,7 +5585,7 @@ var ScriptingProvider_1 = class ScriptingProvider {
       }) => {
         return this._createLogicHookPromises({
           hookType: 'onBotStart',
-          logicHooks: convoStep.logicHooks || [],
+          logicHooks: convoStep?.logicHooks || [],
           convo,
           convoStep,
           scriptingMemory,
@@ -5453,7 +5600,7 @@ var ScriptingProvider_1 = class ScriptingProvider {
       }) => {
         return this._createLogicHookPromises({
           hookType: 'onBotPrepare',
-          logicHooks: convoStep.logicHooks || [],
+          logicHooks: convoStep?.logicHooks || [],
           convo,
           convoStep,
           scriptingMemory,
@@ -5468,7 +5615,7 @@ var ScriptingProvider_1 = class ScriptingProvider {
       }) => {
         return this._createLogicHookPromises({
           hookType: 'onBotEnd',
-          logicHooks: convoStep.logicHooks || [],
+          logicHooks: convoStep?.logicHooks || [],
           convo,
           convoStep,
           scriptingMemory,
@@ -5483,7 +5630,7 @@ var ScriptingProvider_1 = class ScriptingProvider {
       }) => {
         return this._createAsserterPromises({
           asserterType: 'assertConvoBegin',
-          asserters: convo.beginAsserter || [],
+          asserters: convo?.beginAsserter || [],
           convo,
           convoStep,
           scriptingMemory,
@@ -5498,7 +5645,7 @@ var ScriptingProvider_1 = class ScriptingProvider {
       }) => {
         return this._createAsserterPromises({
           asserterType: 'assertConvoStep',
-          asserters: convoStep.asserters || [],
+          asserters: convoStep?.asserters || [],
           convo,
           convoStep,
           scriptingMemory,
@@ -5513,7 +5660,7 @@ var ScriptingProvider_1 = class ScriptingProvider {
       }) => {
         return this._createAsserterPromises({
           asserterType: 'assertConvoEnd',
-          asserters: convo.endAsserter || [],
+          asserters: convo?.endAsserter || [],
           convo,
           convoStep,
           scriptingMemory,
@@ -5542,12 +5689,13 @@ var ScriptingProvider_1 = class ScriptingProvider {
           resolveEmptyIfUnknown
         });
       },
-      assertBotResponse: (botresponse, tomatch, stepTag, meMsg) => {
+      assertBotResponse: (botresponse, tomatch, stepTag, meMsg, convoStepParameters) => {
         if (!lodash.isArray(tomatch)) {
           tomatch = [tomatch];
         }
         debug$9(`assertBotResponse ${stepTag} ${meMsg ? `(${meMsg}) ` : ''}BOT: ${botresponse} = ${tomatch} ...`);
-        const found = lodash.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 = lodash.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 (lodash.isNil(found)) {
           if (this.caps[Capabilities.SCRIPTING_MATCHING_MODE] === 'wer') {
@@ -5597,12 +5745,13 @@ var ScriptingProvider_1 = class ScriptingProvider {
           }
         }
       },
-      assertBotNotResponse: (botresponse, nottomatch, stepTag, meMsg) => {
+      assertBotNotResponse: (botresponse, nottomatch, stepTag, meMsg, convoStepParameters) => {
         if (!lodash.isArray(nottomatch)) {
           nottomatch = [nottomatch];
         }
         debug$9(`assertBotNotResponse ${stepTag} ${meMsg ? `(${meMsg}) ` : ''}BOT: ${botresponse} != ${nottomatch} ...`);
-        const found = lodash.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 = lodash.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 (!lodash.isNil(found)) {
           if (this.caps[Capabilities.SCRIPTING_MATCHING_MODE] === 'wer') {
@@ -5676,6 +5825,22 @@ var ScriptingProvider_1 = class ScriptingProvider {
       assertConvoStep: 'assertNotConvoStep',
       assertConvoEnd: 'assertNotConvoEnd'
     };
+    const updateExceptionContext = (promise, asserter) => {
+      const updateError = err => {
+        if (err instanceof BotiumError$1) {
+          if (!err.context) {
+            err.context = {};
+          }
+          err.context.asserter = asserter.name;
+          throw err;
+        } else {
+          throw botiumErrorFromErr(lodash.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];
@@ -5699,24 +5864,36 @@ var ScriptingProvider_1 = class ScriptingProvider {
         return p(this.retryHelperAsserter, () => asserter[asserterType](params));
       }
     };
-    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
-    }));
-    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
-    })));
+    const convoAsserter = asserters.filter(a => this.asserters[a.name][asserterType]).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 => ({
+      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]) {
       return Promise.allSettled(allPromises).then(results => {
@@ -5742,7 +5919,8 @@ var ScriptingProvider_1 = class ScriptingProvider {
     if (hookType !== 'onMeStart' && hookType !== 'onMePrepare' && hookType !== 'onMeEnd' && hookType !== 'onBotStart' && hookType !== 'onBotPrepare' && hookType !== 'onBotEnd' && hookType !== 'onConvoBegin' && hookType !== 'onConvoEnd') {
       throw Error(`Unknown hookType ${hookType}`);
     }
-    const convoStepPromises = (logicHooks || []).filter(l => this.logicHooks[l.name][hookType]).map(l => p(this.retryHelperLogicHook, () => this.logicHooks[l.name][hookType]({
+    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,
       scriptingMemory,
@@ -5751,7 +5929,8 @@ var ScriptingProvider_1 = class ScriptingProvider {
       isGlobal: false,
       ...rest
     })));
-    const globalPromises = Object.values(this.globalLogicHook).filter(l => l[hookType]).map(l => p(this.retryHelperLogicHook, () => l[hookType]({
+    const globalHooks = Object.values(this.globalLogicHook).filter(l => l[hookType]);
+    const globalPromises = globalHooks.map(l => p(this.retryHelperLogicHook, () => l[hookType]({
       convo,
       convoStep,
       scriptingMemory,
@@ -5761,7 +5940,14 @@ var ScriptingProvider_1 = class ScriptingProvider {
       ...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({
@@ -5771,7 +5957,7 @@ var ScriptingProvider_1 = class ScriptingProvider {
     container,
     ...rest
   }) {
-    const convoStepPromises = (convoStep.userInputs || []).filter(ui => this.userInputs[ui.name]).map(ui => p(this.retryHelperUserInput, () => this.userInputs[ui.name].setUserInput({
+    const convoStepPromises = (convoStep?.userInputs || []).filter(ui => this.userInputs[ui.name]).map(ui => p(this.retryHelperUserInput, () => this.userInputs[ui.name].setUserInput({
       convo,
       convoStep,
       scriptingMemory,
@@ -5833,6 +6019,11 @@ var ScriptingProvider_1 = class ScriptingProvider {
       }
     };
   }
+
+  // Livechat, and crawler using logichooks too. So they need script context
+  BuildScriptContext() {
+    return this._buildScriptContext();
+  }
   Build() {
     const CompilerXlsx = CompilerXlsx_1;
     this.compilers[Constants.SCRIPTING_FORMAT_XSLX] = new CompilerXlsx(this._buildScriptContext(), this.caps);