botium-core 1.14.9 → 1.15.2

package/dist/botium-es.js

@@ -27,20 +27,20 @@ import yaml from 'yaml';
 import child_process from 'child_process';
 import socket from 'socket.io-client';
 import bottleneck from 'bottleneck';
-import request from 'request';
 import mustache from 'mustache';
 import mimeTypes from 'mime-types';
 import ioredis from 'ioredis';
+import undici from 'undici';
 import express from 'express';
 import bodyParser from 'body-parser';
 
 var name = "botium-core";
-var version$1 = "1.14.9";
+var version$1 = "1.15.2";
 var description = "The Selenium for Chatbots";
 var main = "index.js";
 var module = "dist/botium-es.js";
 var engines = {
-	node: ">=14.0.0"
+	node: ">=18.17"
 };
 var scripts = {
 	postinstall: "node ./report.js",
@@ -89,7 +89,6 @@ var dependencies = {
 	"promise-retry": "^2.0.1",
 	"promise.allsettled": "^1.0.7",
 	randomatic: "^3.1.1",
-	request: "^2.88.2",
 	rimraf: "^5.0.5",
 	"sanitize-filename": "^1.6.3",
 	slugify: "^1.6.6",
@@ -98,6 +97,8 @@ var dependencies = {
 	"socketio-auth": "^0.1.1",
 	"swagger-jsdoc": "^6.2.8",
 	"swagger-ui-express": "^5.0.0",
+	tinyglobby: "^0.2.10",
+	undici: "^6.21.0",
 	uuid: "^9.0.1",
 	"word-error-rate": "0.0.7",
 	"write-yaml": "^1.0.0",
@@ -121,7 +122,7 @@ var devDependencies = {
 	"eslint-plugin-promise": "^6.1.1",
 	"eslint-plugin-standard": "^4.1.0",
 	mocha: "^10.3.0",
-	nock: "^13.5.1",
+	nock: "^14.0.0-beta.19",
 	"npm-check-updates": "^16.14.15",
 	nyc: "^15.1.0",
 	rollup: "2.79.1",
@@ -224,6 +225,7 @@ var Capabilities = {
   SIMPLEREST_HEADERS_TEMPLATE: 'SIMPLEREST_HEADERS_TEMPLATE',
   SIMPLEREST_BODY_TEMPLATE: 'SIMPLEREST_BODY_TEMPLATE',
   SIMPLEREST_BODY_RAW: 'SIMPLEREST_BODY_RAW',
+  SIMPLEREST_BODY_FROM_JSON: 'SIMPLEREST_BODY_FROM_JSON',
   SIMPLEREST_START_HOOK: 'SIMPLEREST_START_HOOK',
   SIMPLEREST_STOP_HOOK: 'SIMPLEREST_STOP_HOOK',
   SIMPLEREST_REQUEST_HOOK: 'SIMPLEREST_REQUEST_HOOK',
@@ -301,6 +303,8 @@ var Capabilities = {
   SCRIPTING_CSV_UTTERANCE_STARTROW_HEADER: 'SCRIPTING_CSV_UTTERANCE_STARTROW_HEADER',
   SCRIPTING_CSV_UTTERANCE_STOP_ON_EMPTY: 'SCRIPTING_CSV_UTTERANCE_STOP_ON_EMPTY',
   SCRIPTING_NORMALIZE_TEXT: 'SCRIPTING_NORMALIZE_TEXT',
+  SCRIPTING_NORMALIZE_TEXT_REMOVE_CHARACTERES: 'SCRIPTING_NORMALIZE_TEXT_REMOVE_CHARACTERES',
+  SCRIPTING_NORMALIZE_TEXT_REMOVE_REGEXP: 'SCRIPTING_NORMALIZE_TEXT_REMOVE_REGEXP',
   SCRIPTING_ENABLE_MEMORY: 'SCRIPTING_ENABLE_MEMORY',
   SCRIPTING_ENABLE_MULTIPLE_ASSERT_ERRORS: 'SCRIPTING_ENABLE_MULTIPLE_ASSERT_ERRORS',
   SCRIPTING_ENABLE_SKIP_ASSERT_ERRORS: 'SCRIPTING_ENABLE_SKIP_ASSERT_ERRORS',
@@ -399,6 +403,7 @@ Capabilities.SIMPLEREST_VERB;
 Capabilities.SIMPLEREST_HEADERS_TEMPLATE;
 Capabilities.SIMPLEREST_BODY_TEMPLATE;
 Capabilities.SIMPLEREST_BODY_RAW;
+Capabilities.SIMPLEREST_BODY_FROM_JSON;
 Capabilities.SIMPLEREST_START_HOOK;
 Capabilities.SIMPLEREST_STOP_HOOK;
 Capabilities.SIMPLEREST_REQUEST_HOOK;
@@ -471,6 +476,8 @@ Capabilities.SCRIPTING_CSV_UTTERANCE_STARTROW;
 Capabilities.SCRIPTING_CSV_UTTERANCE_STARTROW_HEADER;
 Capabilities.SCRIPTING_CSV_UTTERANCE_STOP_ON_EMPTY;
 Capabilities.SCRIPTING_NORMALIZE_TEXT;
+Capabilities.SCRIPTING_NORMALIZE_TEXT_REMOVE_CHARACTERES;
+Capabilities.SCRIPTING_NORMALIZE_TEXT_REMOVE_REGEXP;
 Capabilities.SCRIPTING_ENABLE_MEMORY;
 Capabilities.SCRIPTING_ENABLE_MULTIPLE_ASSERT_ERRORS;
 Capabilities.SCRIPTING_ENABLE_SKIP_ASSERT_ERRORS;
@@ -1082,9 +1089,9 @@ var LogicHookUtils_1 = class LogicHookUtils {
     caps
   }) {
     this.asserters = {};
-    this.globalAsserters = [];
+    this.globalAsserterNames = [];
     this.logicHooks = {};
-    this.globalLogicHooks = [];
+    this.globalLogicHookNames = [];
     this.userInputs = {};
     this.buildScriptContext = buildScriptContext;
     this.caps = caps;
@@ -1117,7 +1124,7 @@ var LogicHookUtils_1 = class LogicHookUtils {
       }
       this.asserters[asserter.ref] = this._loadClass(asserter, 'asserter');
       if (asserter.global) {
-        this.globalAsserters.push(asserter.ref);
+        this.globalAsserterNames.push(asserter.ref);
       }
     });
   }
@@ -1128,7 +1135,7 @@ var LogicHookUtils_1 = class LogicHookUtils {
       }
       this.logicHooks[logicHook.ref] = this._loadClass(logicHook, 'logichook');
       if (logicHook.global) {
-        this.globalLogicHooks.push(logicHook.ref);
+        this.globalLogicHookNames.push(logicHook.ref);
       }
     });
   }
@@ -1140,11 +1147,17 @@ var LogicHookUtils_1 = class LogicHookUtils {
       this.userInputs[userInput.ref] = this._loadClass(userInput, 'userinput');
     });
   }
-  getGlobalAsserter() {
-    return this.globalAsserters.map(name => this.asserters[name]);
+  getGlobalAsserters() {
+    return this.globalAsserterNames.reduce((agg, name) => ({
+      ...agg,
+      [name]: this.asserters[name]
+    }), {});
   }
-  getGlobalLogicHook() {
-    return this.globalLogicHooks.map(name => this.logicHooks[name]);
+  getGlobalLogicHooks() {
+    return this.globalLogicHookNames.reduce((agg, name) => ({
+      ...agg,
+      [name]: this.logicHooks[name]
+    }), {});
   }
   _loadClass({
     src,
@@ -1537,7 +1550,31 @@ const {
   E_SCRIPTING_MEMORY_COLUMN_MODE: E_SCRIPTING_MEMORY_COLUMN_MODE$1
 } = Enums;
 const WHITE_SPACES_EXCEPT_SPACE_CHAR_AT_THE_END = /[\n\t\r]+$/;
-const normalizeText$1 = (str, doCleanup) => {
+const normalizeText$1 = (str, doCleanupOrCaps) => {
+  // TODO testlog
+  debug$m('yxc1', doCleanupOrCaps);
+  let basic;
+  let charactersRemove = false;
+  let regexpRemove = false;
+  if (lodash.isBoolean(doCleanupOrCaps) || lodash.isNil(doCleanupOrCaps)) {
+    debug$m('Normalize text: backward compatibility mode. Use caps instead of boolean flag');
+    basic = !!doCleanupOrCaps;
+  } else {
+    const caps = doCleanupOrCaps;
+    basic = !!caps[Capabilities.SCRIPTING_NORMALIZE_TEXT];
+    if (caps[Capabilities.SCRIPTING_NORMALIZE_TEXT_REMOVE_CHARACTERES]) {
+      charactersRemove = caps[Capabilities.SCRIPTING_NORMALIZE_TEXT_REMOVE_CHARACTERES];
+      if (lodash.isString(charactersRemove)) {
+        const splitted = charactersRemove.split(/(?<!\/),/).map(e => e.trim()).map(e => e.split('/,').join(',').split('//').join('/')).filter(c => c.length > 0);
+        charactersRemove = splitted.length ? splitted : [charactersRemove];
+      } else if (!lodash.isArray(charactersRemove)) {
+        charactersRemove = false;
+      }
+    }
+    if (caps[Capabilities.SCRIPTING_NORMALIZE_TEXT_REMOVE_REGEXP]) {
+      regexpRemove = new RegExp(caps[Capabilities.SCRIPTING_NORMALIZE_TEXT_REMOVE_REGEXP], 'ug');
+    }
+  }
   if (str && lodash.isArray(str)) {
     str = str.join(' ');
   } else if (str && !lodash.isString(str)) {
@@ -1547,21 +1584,31 @@ const normalizeText$1 = (str, doCleanup) => {
       str = `${str}`;
     }
   }
-  if (str && doCleanup) {
-    // remove html tags
-    str = str.replace(/<p[^>]*>/g, ' ');
-    str = str.replace(/<\/p>/g, ' ');
-    str = str.replace(/<br[^>]*>/g, ' ');
-    str = str.replace(/<[^>]*>/g, '');
-    /* eslint-disable no-control-regex */
-    // remove not printable characters
-    str = str.replace(/[\x00-\x1F\x7F]/g, ' ');
-    /* eslint-enable no-control-regex */
-    // replace html entities
-    str = str.replace(/&amp;/g, '&').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&#39;/g, '\'').replace(/&quot;/g, '"');
-    // replace two spaces with one
-    str = str.replace(/\s+/g, ' ');
-    str = str.split('\n').map(s => s.trim()).join('\n').trim();
+  if (str) {
+    if (basic) {
+      // remove html tags
+      str = str.replace(/<p[^>]*>/g, ' ');
+      str = str.replace(/<\/p>/g, ' ');
+      str = str.replace(/<br[^>]*>/g, ' ');
+      str = str.replace(/<[^>]*>/g, '');
+      /* eslint-disable no-control-regex */
+      // remove not printable characters
+      str = str.replace(/[\x00-\x1F\x7F]/g, ' ');
+      /* eslint-enable no-control-regex */
+      // replace html entities
+      str = str.replace(/&amp;/g, '&').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&#39;/g, '\'').replace(/&quot;/g, '"');
+      // replace two spaces with one
+      str = str.replace(/\s+/g, ' ');
+      str = str.split('\n').map(s => s.trim()).join('\n').trim();
+    }
+    if (charactersRemove) {
+      for (const character of charactersRemove) {
+        str = str.split(character).join('');
+      }
+    }
+    if (regexpRemove) {
+      str = str.replace(regexpRemove, '');
+    }
   }
   return str;
 };
@@ -2934,6 +2981,10 @@ class Convo$6 {
       let skipTranscriptStep = false;
       let conditionalGroupId = null;
       let conditionMetInGroup = false;
+      let skipOptionalStep = false;
+      // If there are optional step(s) in the conversation, and the message from the bot fails on each optional bot step(s) and/or mandatory bot step, then we have an unexpected message.
+      // So in this case an unexpected error should be shown instead of the latest assertion error.
+      let optionalStepAssertionError = false;
       let globalConvoStepParameters = container.caps[Capabilities.SCRIPTING_CONVO_STEP_PARAMETERS] || {};
       let retryBotMessageTimeoutEnd = null;
       let retryBotMessageConvoId = null;
@@ -2941,6 +2992,13 @@ class Convo$6 {
       for (let i = 0; i < this.conversation.length; i = retryBotMessageDropBotResponse ? i : i + 1) {
         retryBotMessageDropBotResponse = false;
         const convoStep = this.conversation[i];
+        if (!convoStep.optional) {
+          skipOptionalStep = false;
+        }
+        if (convoStep.optional && skipOptionalStep) {
+          // If there are multiple optional steps, and the previous optional step was timeout, then the next optional step should be skipped to prevent too long convo run with multiple timeout.
+          continue;
+        }
         const rawConvoStepParameters = convoStep.logicHooks.find(lh => lh.name === 'CONVO_STEP_PARAMETERS')?.args;
         let convoStepParameters = {};
         if (rawConvoStepParameters && rawConvoStepParameters.length) {
@@ -3125,7 +3183,8 @@ class Convo$6 {
               debug$k(`${this.header.name}: bot says (cleaned by binary and base64 data and sourceData) ${JSON.stringify(coreMsg, null, 2)}`);
             } catch (err) {
               transcriptStep.botEnd = new Date();
-              if (convoStep.optional) {
+              if (!(err.message.indexOf('Bot did not respond within') < 0) && convoStep.optional) {
+                skipOptionalStep = true;
                 continue;
               }
               const failErr = botiumErrorFromErr$1(`${this.header.name}/${convoStep.stepTag}: error waiting for bot - ${err.message}`, err);
@@ -3209,6 +3268,7 @@ class Convo$6 {
                 }
                 waitForBotSays = false;
                 skipTranscriptStep = true;
+                optionalStepAssertionError = true;
                 return true;
               } else if (retryOn) {
                 if (!retryBotMessageTimeoutEnd || retryBotMessageConvoId !== convoStep.stepTag) {
@@ -3226,9 +3286,18 @@ class Convo$6 {
                 }
               }
               if (container.caps[Capabilities.SCRIPTING_ENABLE_MULTIPLE_ASSERT_ERRORS]) {
-                assertErrors.push(err);
+                if (optionalStepAssertionError) {
+                  optionalStepAssertionError = false;
+                  assertErrors.push(new BotiumError$2(`${this.header.name}: Unexpected message.`));
+                } else {
+                  assertErrors.push(err);
+                }
                 return false;
               } else {
+                if (optionalStepAssertionError) {
+                  optionalStepAssertionError = false;
+                  throw new BotiumError$2(`${this.header.name}: Unexpected message.`);
+                }
                 throw err;
               }
             };
@@ -3242,6 +3311,7 @@ class Convo$6 {
               if (convoStep.not) {
                 try {
                   this.scriptingEvents.assertBotNotResponse(response, tomatch, `${this.header.name}/${convoStep.stepTag}`, lastMeConvoStep, convoStepParameters);
+                  optionalStepAssertionError = false;
                 } catch (err) {
                   if (isErrorHandledWithOptionConvoStep(err)) {
                     continue;
@@ -3250,6 +3320,7 @@ class Convo$6 {
               } else {
                 try {
                   this.scriptingEvents.assertBotResponse(response, tomatch, `${this.header.name}/${convoStep.stepTag}`, lastMeConvoStep, convoStepParameters);
+                  optionalStepAssertionError = false;
                 } catch (err) {
                   if (isErrorHandledWithOptionConvoStep(err)) {
                     continue;
@@ -3259,6 +3330,7 @@ class Convo$6 {
             } else if (convoStep.sourceData) {
               try {
                 this._compareObject(container, scriptingMemory, convoStep, botMsg.sourceData, convoStep.sourceData, botMsg, convoStepParameters);
+                optionalStepAssertionError = false;
               } catch (err) {
                 if (isErrorHandledWithOptionConvoStep(err)) {
                   continue;
@@ -3285,11 +3357,13 @@ class Convo$6 {
                 transcript,
                 transcriptStep
               });
+              optionalStepAssertionError = false;
             } catch (err) {
               const nextConvoStep = this.conversation[i + 1];
               if (convoStep.optional && nextConvoStep && nextConvoStep.sender === 'bot') {
                 waitForBotSays = false;
                 skipTranscriptStep = true;
+                optionalStepAssertionError = true;
                 continue;
               }
               const errors = err.toArray ? err.toArray() : [];
@@ -3318,8 +3392,17 @@ class Convo$6 {
                   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);
+                  if (optionalStepAssertionError) {
+                    optionalStepAssertionError = false;
+                    assertErrors.push(new BotiumError$2(`${this.header.name}: Unexpected message.`));
+                  } else {
+                    assertErrors.push(err);
+                  }
                 } else {
+                  if (optionalStepAssertionError) {
+                    optionalStepAssertionError = false;
+                    throw new BotiumError$2(`${this.header.name}: Unexpected message.`);
+                  }
                   throw failErr;
                 }
               }
@@ -3489,7 +3572,7 @@ class Convo$6 {
     return tomatch;
   }
   _checkNormalizeText(container, str) {
-    return normalizeText(str, !!container.caps[Capabilities.SCRIPTING_NORMALIZE_TEXT]);
+    return normalizeText(str, container.caps);
   }
   expandPartialConvos() {
     const _getIncludeLogicHookNames = convoStep => {
@@ -5520,9 +5603,9 @@ var ScriptingProvider_1 = class ScriptingProvider {
     this.utterances = {};
     this.matchFn = null;
     this.asserters = {};
-    this.globalAsserter = {};
+    this.globalAsserters = {};
     this.logicHooks = {};
-    this.globalLogicHook = {};
+    this.globalLogicHooks = {};
     this.userInputs = {};
     this.partialConvos = {};
     this.scriptingMemories = [];
@@ -5891,7 +5974,8 @@ var ScriptingProvider_1 = class ScriptingProvider {
         return p(this.retryHelperAsserter, () => asserter[asserterType](params));
       }
     };
-    const convoAsserter = asserters.filter(a => this.asserters[a.name][asserterType]).map(a => ({
+    const localAsserters = (asserters || []).filter(a => this.asserters[a.name][asserterType]);
+    const convoStepPromises = localAsserters.map(a => ({
       asserter: a,
       promise: callAsserter(a, this.asserters[a.name], {
         convo,
@@ -5906,7 +5990,8 @@ var ScriptingProvider_1 = class ScriptingProvider {
       promise,
       asserter
     }) => updateExceptionContext(promise, asserter));
-    const globalAsserter = Object.values(this.globalAsserter).filter(a => a[asserterType]).map(a => ({
+    const globalAsserters = Object.keys(this.globalAsserters).filter(name => localAsserters.map(a => a.name).indexOf(name) < 0).reduce((agg, name) => [...agg, this.globalAsserters[name]], []).filter(a => a[asserterType]);
+    const globalPromises = globalAsserters.map(a => ({
       asserter: a,
       promise: p(this.retryHelperAsserter, () => a[asserterType]({
         convo,
@@ -5921,7 +6006,7 @@ var ScriptingProvider_1 = class ScriptingProvider {
       promise,
       asserter
     }) => updateExceptionContext(promise, asserter));
-    const allPromises = [...convoAsserter, ...globalAsserter];
+    const allPromises = [...convoStepPromises, ...globalPromises];
     if (this.caps[Capabilities.SCRIPTING_ENABLE_MULTIPLE_ASSERT_ERRORS]) {
       return Promise.allSettled(allPromises).then(results => {
         const rejected = results.filter(result => result.status === 'rejected').map(result => result.reason);
@@ -5956,7 +6041,7 @@ var ScriptingProvider_1 = class ScriptingProvider {
       isGlobal: false,
       ...rest
     })));
-    const globalHooks = Object.values(this.globalLogicHook).filter(l => l[hookType]);
+    const globalHooks = Object.keys(this.globalLogicHooks).filter(name => localHooks.map(l => l.name).indexOf(name) < 0).reduce((agg, name) => [...agg, this.globalLogicHooks[name]], []).filter(l => l[hookType]);
     const globalPromises = globalHooks.map(l => p(this.retryHelperLogicHook, () => l[hookType]({
       convo,
       convoStep,
@@ -6076,9 +6161,9 @@ var ScriptingProvider_1 = class ScriptingProvider {
       caps: this.caps
     });
     this.asserters = logicHookUtils.asserters;
-    this.globalAsserter = logicHookUtils.getGlobalAsserter();
+    this.globalAsserters = logicHookUtils.getGlobalAsserters();
     this.logicHooks = logicHookUtils.logicHooks;
-    this.globalLogicHook = logicHookUtils.getGlobalLogicHook();
+    this.globalLogicHooks = logicHookUtils.getGlobalLogicHooks();
     this.userInputs = logicHookUtils.userInputs;
   }
   IsAsserterValid(name) {
@@ -7550,7 +7635,7 @@ var BaseContainer_1 = class BaseContainer {
     try {
       await executeHook$1(this.caps, hook, Object.assign({
         container: this,
-        request
+        fetch
       }, args));
     } catch (err) {
       debug$7(`_RunCustomHook ${name} finished with error: ${err.message || util.inspect(err)}`);
@@ -7837,6 +7922,10 @@ const {
   v4: uuidv4
 } = uuid;
 const debug$4 = debug$o('botium-connector-simplerest');
+const {
+  ProxyAgent,
+  Agent
+} = undici;
 const {
   startProxy
 } = proxy;
@@ -7913,6 +8002,16 @@ var SimpleRestContainer_1 = class SimpleRestContainer {
     }
   }
   Build() {
+    const agentOptions = {
+      connect: {
+        rejectUnauthorized: !!this.caps[Capabilities.SIMPLEREST_STRICT_SSL] // Equivalent to strictSSL of request module
+      }
+    };
+    if (this.caps[Capabilities.SIMPLEREST_PROXY_URL]) {
+      this.dispatcher = new ProxyAgent(this.caps[Capabilities.SIMPLEREST_PROXY_URL], agentOptions);
+    } else {
+      this.dispatcher = new Agent(agentOptions);
+    }
     return this._buildInbound();
   }
   Start() {
@@ -8053,6 +8152,27 @@ var SimpleRestContainer_1 = class SimpleRestContainer {
   Clean() {
     return this._cleanInbound();
   }
+  _fetchify(requestOptions) {
+    requestOptions.signal = AbortSignal.timeout(requestOptions.timeout);
+    delete requestOptions.timeout;
+    if (requestOptions.body && !lodash.isString(requestOptions.body)) {
+      requestOptions.body = JSON.stringify(requestOptions.body);
+      if (!requestOptions.headers) requestOptions.headers = {};
+      if (!requestOptions.headers['Content-Type'] && !requestOptions.headers['content-type']) {
+        requestOptions.headers['Content-Type'] = 'application/json';
+      }
+    }
+    if (requestOptions.form) {
+      if (requestOptions.body) {
+        debug$4('Request.form and request.body are mutually exclusive');
+      }
+      requestOptions.body = new URLSearchParams(requestOptions.form).toString();
+      // it is set automatically by fetch
+      // requestOptions.headers['Content-Type'] = 'application/x-www-form-urlencoded'
+      delete requestOptions.form;
+    }
+    return requestOptions;
+  }
 
   // Separated just for better module testing
   async _processBodyAsync(body, headers, isFromUser, updateContext) {
@@ -8323,12 +8443,25 @@ var SimpleRestContainer_1 = class SimpleRestContainer {
       msg.sourceData = msg.sourceData || {};
       msg.sourceData.requestOptions = requestOptions;
       this.waitProcessQueue = [];
-      request(requestOptions, async (err, response, body) => {
-        if (err) {
-          return reject(new Error(`rest request failed: ${err.message}`));
-        } else {
-          if (response.statusCode >= 400) {
-            debug$4(`got error response: ${response.statusCode}/${response.statusMessage}`);
+      try {
+        fetch(requestOptions.uri, requestOptions).then(async bodyRaw => {
+          let body;
+          try {
+            if (bodyRaw.headers.get('content-type').includes('application/json')) {
+              try {
+                body = await bodyRaw.json();
+              } catch (err) {
+                body = await bodyRaw.text();
+                debug$4(`failed to parse body as text, using text instead: ${body}`);
+              }
+            } else {
+              body = await bodyRaw.text();
+            }
+          } catch (err) {
+            return reject(new Error(`cant parse body: ${err.message}`));
+          }
+          if (!bodyRaw.ok) {
+            debug$4(`got error response: ${bodyRaw.status}/${bodyRaw.statusText}`);
             if (debug$4.enabled && body) {
               debug$4(Utils.shortenJsonString(body));
             }
@@ -8336,38 +8469,42 @@ var SimpleRestContainer_1 = class SimpleRestContainer {
               const jsonBody = Utils.toJsonWeak(body);
               const errKey = Object.keys(jsonBody).find(k => k.startsWith('err') || k.startsWith('fail'));
               if (errKey) {
-                return reject(new BotiumError(`got error response: ${response.statusCode}/${response.statusMessage} - ${jsonBody[errKey]}`, {
+                return reject(new BotiumError(`got error response: ${bodyRaw.status}/${bodyRaw.statusText} - ${jsonBody[errKey]}`, {
                   message: Utils.shortenJsonString(body)
                 }));
               }
             }
-            return reject(new Error(`got error response: ${response.statusCode}/${response.statusMessage}`));
+            return reject(new Error(`got error response: ${bodyRaw.status}/${bodyRaw.statusText}`));
           }
           if (body) {
-            debug$4(`got response code: ${response.statusCode}, body: ${Utils.shortenJsonString(body)}, headers: ${Utils.shortenJsonString(response.headers)}`);
-            this._storeCookiesFromResponse(response);
-            try {
-              body = await this._parseResponseBody(body);
-            } catch (err) {
+            debug$4(`got response code: ${bodyRaw.status}/${bodyRaw.statusText}, body: ${Utils.shortenJsonString(body)}, headers: ${Utils.shortenJsonString(bodyRaw.headers)}`);
+            this._storeCookiesFromResponse(bodyRaw);
+            this._parseResponseBody(body).then(parsedBody => {
+              body = parsedBody;
+              if (body) {
+                this._processBodyAsync(body, bodyRaw.headers, isFromUser, updateContext).then(() => resolve(this)).then(() => this._emptyWaitProcessQueue());
+              } else {
+                debug$4('ignoring response body (no string and no JSON object)');
+                resolve(this);
+                this._emptyWaitProcessQueue();
+              }
+            }).catch(err => {
               debug$4(`ignoring not JSON formatted response body: ${err.message}`);
               resolve(this);
               this._emptyWaitProcessQueue();
-              return;
-            }
-            if (body) {
-              this._processBodyAsync(body, response.headers, isFromUser, updateContext).then(() => resolve(this)).then(() => this._emptyWaitProcessQueue());
-            } else {
-              debug$4('ignoring response body (no string and no JSON object)');
-              resolve(this);
-              this._emptyWaitProcessQueue();
-            }
+            });
           } else {
-            debug$4(`got response code: ${response.statusCode}, empty body`);
+            debug$4(`got response code: ${bodyRaw.status}/${bodyRaw.statusText}, empty body`);
             resolve(this);
             this._emptyWaitProcessQueue();
           }
-        }
-      });
+        }).catch(err => {
+          // rest request failed: fetch failed - Cause code: ECONNREFUSED - Cause message: connect ECONNREFUSED 127.0.0.1:3006
+          return reject(new Error(`rest request failed: ${err.message}${err.cause && err.cause.code ? ' - Cause code: ' + err.cause.code : ''}${err.cause && err.cause.message ? ' - Cause message: ' + err.cause.message : ''}`));
+        });
+      } catch (err) {
+        return reject(new Error(`rest request failed: ${err.message}`));
+      }
     }));
   }
   async _buildRequest(msg) {
@@ -8384,7 +8521,6 @@ var SimpleRestContainer_1 = class SimpleRestContainer {
     const requestOptions = {
       uri,
       method: this._getCapValue(Capabilities.SIMPLEREST_VERB) || this._getCapValue(Capabilities.SIMPLEREST_METHOD),
-      followAllRedirects: true,
       timeout
     };
     if (this.caps[Capabilities.SIMPLEREST_HEADERS_TEMPLATE]) {
@@ -8395,7 +8531,14 @@ var SimpleRestContainer_1 = class SimpleRestContainer {
         throw new Error(`composing headers from SIMPLEREST_HEADERS_TEMPLATE failed (${err.message})`);
       }
     }
-    if (this.caps[Capabilities.SIMPLEREST_BODY_TEMPLATE]) {
+    // It is possible to mix json, and non-json request messages. So it can happen that both
+    // SIMPLEREST_BODY_FROM_JSON and SIMPLEREST_BODY_TEMPLATE are set
+    if (this.caps[Capabilities.SIMPLEREST_BODY_FROM_JSON] && msg.sourceData && Object.keys(msg.sourceData).length > 0) {
+      requestOptions.body = msg.sourceData;
+      requestOptions.json = true;
+      if (!requestOptions.headers) requestOptions.headers = {};
+      requestOptions.headers['Content-Type'] = 'application/json';
+    } else if (this.caps[Capabilities.SIMPLEREST_BODY_TEMPLATE]) {
       const bodyRaw = this._getCapValue(Capabilities.SIMPLEREST_BODY_RAW);
       if (bodyRaw) {
         this.view.msg.messageText = nonEncodedMessage;
@@ -8408,6 +8551,10 @@ var SimpleRestContainer_1 = class SimpleRestContainer {
         if (requestOptions.json && (!requestOptions.body || Object.keys(requestOptions.body).length === 0)) {
           debug$4(`warning: requestOptions.body content seems to be empty - ${requestOptions.body} - capability: "${this.caps[Capabilities.SIMPLEREST_BODY_TEMPLATE]}"`);
         }
+        if (!bodyRaw) {
+          if (!requestOptions.headers) requestOptions.headers = {};
+          requestOptions.headers['Content-Type'] = 'application/json';
+        }
       } catch (err) {
         throw new Error(`composing body from SIMPLEREST_BODY_TEMPLATE failed (${err.message})`);
       }
@@ -8441,56 +8588,53 @@ var SimpleRestContainer_1 = class SimpleRestContainer {
       }
     }
     this._addRequestOptions(requestOptions);
+    this._fetchify(requestOptions);
     await executeHook(this.caps, this.requestHook, Object.assign({
       requestOptions
     }, this.view));
     this._addRequestCookies(requestOptions);
     return requestOptions;
   }
-  async _waitForUrlResponse(pingConfig, retries) {
+  async _waitForUrlResponse(httpConfig, retries) {
     const timeout = ms => new Promise(resolve => setTimeout(resolve, ms));
     let tries = 0;
     while (true) {
-      debug$4(`_waitForUrlResponse checking url ${pingConfig.uri} before proceed`);
+      debug$4(`_waitForUrlResponse checking url ${httpConfig.uri} before proceed`);
       if (tries > retries) {
         throw new Error(`Failed to ping bot after ${retries} retries`);
       }
       tries++;
-      const {
-        err,
-        response,
-        body
-      } = await this.bottleneck(() => new Promise(resolve => {
-        request(pingConfig, (err, response, body) => {
-          resolve({
-            err,
-            response,
-            body
-          });
-        });
-      }));
+      let bodyRaw;
+      let body;
+      let err;
+      try {
+        bodyRaw = await this.bottleneck(() => fetch(httpConfig.uri, httpConfig));
+        body = await (httpConfig.json ? bodyRaw.json() : bodyRaw.text());
+      } catch (e) {
+        err = e;
+      }
       if (err) {
-        debug$4(`_waitForUrlResponse error on url check ${pingConfig.uri}: ${err}`);
+        debug$4(`_waitForUrlResponse error on url check ${httpConfig.uri}: ${err}`);
         if (tries <= retries) {
-          await timeout(pingConfig.timeout);
+          await timeout(httpConfig.timeout);
         }
-      } else if (response.statusCode >= 400) {
-        debug$4(`_waitForUrlResponse on url check ${pingConfig.uri} got error response: ${response.statusCode}/${response.statusMessage}`);
+      } else if (!bodyRaw.ok) {
+        debug$4(`_waitForUrlResponse on url check ${httpConfig.uri} got error response: ${bodyRaw.status}/${bodyRaw.statusText}`);
         if (debug$4.enabled && body) {
           debug$4(Utils.shortenJsonString(body));
         }
         if (tries <= retries) {
-          await timeout(pingConfig.timeout);
+          await timeout(httpConfig.timeout);
         }
       } else {
-        debug$4(`_waitForUrlResponse success on url check ${pingConfig.uri}: ${response.statusCode}/${response.statusMessage}`);
-        this._storeCookiesFromResponse(response);
+        debug$4(`_waitForUrlResponse success on url check ${httpConfig.uri}: ${bodyRaw.status}/${bodyRaw.statusText}`);
+        this._storeCookiesFromResponse(bodyRaw);
         if (debug$4.enabled && body) {
-          debug$4(`body: ${Utils.shortenJsonString(body)}, headers: ${Utils.shortenJsonString(response.headers)}`);
+          debug$4(`body: ${Utils.shortenJsonString(body)}, headers: ${Utils.shortenJsonString(bodyRaw.headers)}`);
         }
         return {
           body,
-          headers: response.headers
+          headers: bodyRaw.headers
         };
       }
     }
@@ -8642,7 +8786,6 @@ var SimpleRestContainer_1 = class SimpleRestContainer {
       const pollConfig = {
         method: verb,
         uri,
-        followAllRedirects: true,
         timeout
       };
       if (this.caps[Capabilities.SIMPLEREST_POLL_HEADERS]) {
@@ -8658,12 +8801,17 @@ var SimpleRestContainer_1 = class SimpleRestContainer {
         try {
           pollConfig.body = this._getMustachedCap(Capabilities.SIMPLEREST_POLL_BODY, !bodyRaw);
           pollConfig.json = !bodyRaw;
+          if (!bodyRaw) {
+            if (!pollConfig.headers) pollConfig.headers = {};
+            pollConfig.headers['Content-Type'] = 'application/json';
+          }
         } catch (err) {
           debug$4(`_runPolling: composing body from SIMPLEREST_POLL_BODY failed (${err.message})`);
           return;
         }
       }
       this._addRequestOptions(pollConfig);
+      this._fetchify(pollConfig);
       try {
         await executeHook(this.caps, this.pollRequestHook, Object.assign({
           requestOptions: pollConfig
@@ -8673,34 +8821,34 @@ var SimpleRestContainer_1 = class SimpleRestContainer {
         return;
       }
       this._addRequestCookies(pollConfig);
-      request(pollConfig, async (err, response, body) => {
-        if (err) {
-          debug$4(`_runPolling: rest request failed: ${err.message}, request: ${JSON.stringify(pollConfig)}`);
-        } else {
-          if (response.statusCode >= 400) {
-            debug$4(`_runPolling: got error response: ${response.statusCode}/${response.statusMessage}, request: ${JSON.stringify(pollConfig)}`);
-            if (debug$4.enabled && body) {
-              debug$4(Utils.shortenJsonString(body));
-            }
-          } else if (body) {
-            debug$4(`_runPolling: got response code: ${response.statusCode}, body: ${Utils.shortenJsonString(body)}, headers: ${Utils.shortenJsonString(response.headers)}`);
-            this._storeCookiesFromResponse(response);
-            try {
-              body = await this._parseResponseBody(body);
-            } catch (err) {
-              debug$4(`_runPolling: ignoring not JSON formatted response body: ${err.message}`);
-              return;
-            }
-            if (body) {
-              setTimeout(() => this._processBodyAsync(body, response.headers, true, !!this.caps[Capabilities.SIMPLEREST_POLL_UPDATE_CONTEXT]), 0);
-            } else {
-              debug$4('_runPolling: ignoring response body (no string and no JSON object)');
-            }
+      try {
+        const bodyRaw = await fetch(pollConfig.uri, pollConfig);
+        let body = await (pollConfig.json ? bodyRaw.json() : bodyRaw.text());
+        if (!bodyRaw.ok) {
+          debug$4(`_runPolling: got error response: ${bodyRaw.status}/${bodyRaw.statusText}, request: ${JSON.stringify(pollConfig)}`);
+          if (debug$4.enabled && body) {
+            debug$4(Utils.shortenJsonString(body));
+          }
+        } else if (body) {
+          debug$4(`_runPolling: got response code: ${bodyRaw.status}/${bodyRaw.statusText}, body: ${Utils.shortenJsonString(body)}, headers: ${Utils.shortenJsonString(bodyRaw.headers)}`);
+          this._storeCookiesFromResponse(bodyRaw);
+          try {
+            body = await this._parseResponseBody(body);
+          } catch (err) {
+            debug$4(`_runPolling: ignoring not JSON formatted response body: ${err.message}`);
+            return;
+          }
+          if (body) {
+            setTimeout(() => this._processBodyAsync(body, bodyRaw.headers, true, !!this.caps[Capabilities.SIMPLEREST_POLL_UPDATE_CONTEXT]), 0);
           } else {
-            debug$4(`_runPolling: got response code: ${response.statusCode}, empty body`);
+            debug$4('_runPolling: ignoring response body (no string and no JSON object)');
           }
+        } else {
+          debug$4(`_runPolling: got response code: ${bodyRaw.status}/${bodyRaw.statusText}, empty body`);
         }
-      });
+      } catch (err) {
+        debug$4(`_runPolling: rest request failed: ${err.message}, request: ${JSON.stringify(pollConfig)}`);
+      }
     }
   }
   async _startPolling() {
@@ -8723,7 +8871,6 @@ var SimpleRestContainer_1 = class SimpleRestContainer {
     const httpConfig = {
       method: verb,
       uri,
-      followAllRedirects: true,
       timeout
     };
     if (this.caps[`${capPrefix}_HEADERS`]) {
@@ -8743,6 +8890,7 @@ var SimpleRestContainer_1 = class SimpleRestContainer {
       }
     }
     this._addRequestOptions(httpConfig);
+    this._fetchify(httpConfig);
     await executeHook(this.caps, this.requestHooks[capPrefix], Object.assign({
       requestOptions: httpConfig
     }, this.view));
@@ -8753,9 +8901,8 @@ var SimpleRestContainer_1 = class SimpleRestContainer {
     return response;
   }
   _addRequestOptions(httpConfig) {
-    httpConfig.strictSSL = !!this.caps[Capabilities.SIMPLEREST_STRICT_SSL];
-    if (this.caps[Capabilities.SIMPLEREST_PROXY_URL]) {
-      httpConfig.proxy = this.caps[Capabilities.SIMPLEREST_PROXY_URL];
+    if (this.dispatcher) {
+      httpConfig.dispatcher = this.dispatcher;
     }
     if (this.caps[Capabilities.SIMPLEREST_EXTRA_OPTIONS]) {
       lodash.merge(httpConfig, this.caps[Capabilities.SIMPLEREST_EXTRA_OPTIONS]);
@@ -8769,23 +8916,21 @@ var SimpleRestContainer_1 = class SimpleRestContainer {
     if (!requestOptions.headers) {
       requestOptions.headers = {};
     }
-    requestOptions.headers.Cookie = requestOptions.headers.Cookie ? `${requestOptions.headers.Cookie}; ${this.cookies[url.host]}` : this.cookies[url.host];
+    if (this.cookies[url.host]) {
+      requestOptions.headers.Cookie = requestOptions.headers.Cookie ? `${requestOptions.headers.Cookie}; ${this.cookies[url.host]}` : this.cookies[url.host];
+    }
   }
   _storeCookiesFromResponse(response) {
     if (!this.caps[Capabilities.SIMPLEREST_COOKIE_REPLICATION] || !response) {
       return;
     }
-    const responseCookies = response.headers['set-cookie'];
+    const responseCookies = response.headers.get('set-cookie');
     if (!responseCookies) {
       return;
     }
-    const host = lodash.get(response, 'request.uri.host');
-    let cookie;
-    responseCookies.forEach(cookieString => {
-      cookie = cookie ? `${cookie}; ${cookieString}` : cookieString;
-    });
-    if (cookie) {
-      this.cookies[host] = cookie;
+    const host = response?.url ? new URL(response.url).host : null;
+    if (host) {
+      this.cookies[host] = responseCookies;
     }
   }
 };