botium-core 1.14.10 → 1.15.3

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "botium-core",
-  "version": "1.14.10",
+  "version": "1.15.3",
   "description": "The Selenium for Chatbots",
   "main": "index.js",
   "module": "dist/botium-es.js",
   "engines": {
-    "node": ">=14.0.0"
+    "node": ">=18.17"
   },
   "scripts": {
     "postinstall": "node ./report.js",
@@ -54,7 +54,6 @@
     "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",
@@ -64,6 +63,7 @@
     "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",
@@ -87,7 +87,7 @@
     "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",

package/samples/connectors/simplerest-async/jokebot.js

@@ -1,4 +1,3 @@
-const request = require('request')
 const express = require('express')
 const bodyParser = require('body-parser')
 const _ = require('lodash')
@@ -13,32 +12,39 @@ const jokes = [
   'A blonde was bragging about her knowledge of state capitals. She proudly says, Go ahead, ask me, I know all of them. A friend says, OK, what\'s the capital of Wisconsin? The blonde replies, Oh, that\'s easy: W.'
 ]
 
-sendAsyncText = async (req, res, text) => {
+const sendAsyncText = async (req, res, text) => {
   const callbackUri = req.body.callbackUri
 
-  return new Promise((resolve, reject) => {
-    request({
+  try {
+    const response = await fetch(callbackUri, {
       method: 'POST',
-      uri: callbackUri,
-      body: {
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify({
         conversationId: req.body.conversationId,
         responses: [
           {
             text
           }
         ]
-      },
-      json: true
-    }, (err, response, body) => {
-      if (err) {
-        console.log('failed async response: ' + err)
-        reject(err)
-      } else {
-        console.log('async response got response ' + response.statusCode)
-        resolve()
-      }
+      })
     })
-  })
+
+    if (!response.ok) {
+      const error = `Failed async response: ${response.status} ${response.statusText}`
+      console.log(error)
+      // just backward compatibility. Currently I get 401 error, but the chat itself is working.
+      // If I activate this, then the chat will not work at all.
+      // I suppose api key is not good,
+      // throw new Error(error);
+    } else {
+      console.log('Async response got response ' + response.status)
+    }
+  } catch (err) {
+    console.error('Error in sendAsyncText:', err.message)
+    throw err
+  }
 }
 
 app.post('/joke', async (req, res) => {
@@ -55,7 +61,7 @@ app.post('/joke', async (req, res) => {
     responses: [
       {
         text: 'ok, not funny'
-      },
+      }
     ]
   })
 })

package/src/Capabilities.js

@@ -56,6 +56,7 @@ module.exports = {
   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',
@@ -133,6 +134,8 @@ module.exports = {
   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',

package/src/containers/BaseContainer.js

@@ -3,7 +3,6 @@ const async = require('async')
 const rimraf = require('rimraf')
 const Bottleneck = require('bottleneck')
 const _ = require('lodash')
-const request = require('request')
 const debug = require('debug')('botium-connector-BaseContainer')
 
 const Events = require('../Events')
@@ -239,7 +238,7 @@ module.exports = class BaseContainer {
 
   async _RunCustomHook (name, hook, args) {
     try {
-      await executeHook(this.caps, hook, Object.assign({ container: this, request }, args))
+      await executeHook(this.caps, hook, Object.assign({ container: this, fetch }, args))
     } catch (err) {
       debug(`_RunCustomHook ${name} finished with error: ${err.message || util.inspect(err)}`)
     }

package/src/containers/plugins/SimpleRestContainer.js

@@ -1,6 +1,5 @@
 const util = require('util')
 const async = require('async')
-const request = require('request')
 const Mustache = require('mustache')
 const jp = require('jsonpath')
 const mime = require('mime-types')
@@ -8,6 +7,7 @@ const { v4: uuidv4 } = require('uuid')
 const Redis = require('ioredis')
 const _ = require('lodash')
 const debug = require('debug')('botium-connector-simplerest')
+const { ProxyAgent, Agent } = require('undici')
 
 const { startProxy } = require('../../grid/inbound/proxy')
 const botiumUtils = require('../../helpers/Utils')
@@ -77,6 +77,17 @@ module.exports = 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()
   }
 
@@ -235,6 +246,31 @@ module.exports = class SimpleRestContainer {
     return this._cleanInbound()
   }
 
+  _fetchify (requestOptions) {
+    requestOptions.signal = AbortSignal.timeout(requestOptions.timeout)
+    delete requestOptions.timeout
+
+    if (requestOptions.body && !_.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('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) {
     const p = async () => {
@@ -511,12 +547,25 @@ module.exports = class SimpleRestContainer {
 
         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(`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(`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(`got error response: ${bodyRaw.status}/${bodyRaw.statusText}`)
               if (debug.enabled && body) {
                 debug(botiumUtils.shortenJsonString(body))
               }
@@ -524,40 +573,45 @@ module.exports = class SimpleRestContainer {
                 const jsonBody = botiumUtils.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: botiumUtils.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(`got response code: ${response.statusCode}, body: ${botiumUtils.shortenJsonString(body)}, headers: ${botiumUtils.shortenJsonString(response.headers)}`)
-              this._storeCookiesFromResponse(response)
-              try {
-                body = await this._parseResponseBody(body)
-              } catch (err) {
-                debug(`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('ignoring response body (no string and no JSON object)')
-                resolve(this)
-                this._emptyWaitProcessQueue()
-              }
+              debug(`got response code: ${bodyRaw.status}/${bodyRaw.statusText}, body: ${botiumUtils.shortenJsonString(body)}, headers: ${botiumUtils.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('ignoring response body (no string and no JSON object)')
+                    resolve(this)
+                    this._emptyWaitProcessQueue()
+                  }
+                })
+                .catch((err) => {
+                  debug(`ignoring not JSON formatted response body: ${err.message}`)
+                  resolve(this)
+                  this._emptyWaitProcessQueue()
+                })
             } else {
-              debug(`got response code: ${response.statusCode}, empty body`)
+              debug(`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}`))
+        }
       }))
   }
 
@@ -580,7 +634,6 @@ module.exports = class SimpleRestContainer {
     const requestOptions = {
       uri,
       method: this._getCapValue(Capabilities.SIMPLEREST_VERB) || this._getCapValue(Capabilities.SIMPLEREST_METHOD),
-      followAllRedirects: true,
       timeout
     }
 
@@ -592,7 +645,14 @@ module.exports = 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
@@ -605,6 +665,10 @@ module.exports = class SimpleRestContainer {
         if (requestOptions.json && (!requestOptions.body || Object.keys(requestOptions.body).length === 0)) {
           debug(`warning: requestOptions.body content seems to be empty - ${requestOptions.body} - capability: "${this.caps[Capabilities.SIMPLEREST_BODY_TEMPLATE]}"`)
         }
+        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})`)
       }
@@ -646,48 +710,53 @@ module.exports = 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(`_waitForUrlResponse checking url ${pingConfig.uri} before proceed`)
+      debug(`_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(`_waitForUrlResponse error on url check ${pingConfig.uri}: ${err}`)
+        debug(`_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(`_waitForUrlResponse on url check ${pingConfig.uri} got error response: ${response.statusCode}/${response.statusMessage}`)
+      } else if (!bodyRaw.ok) {
+        debug(`_waitForUrlResponse on url check ${httpConfig.uri} got error response: ${bodyRaw.status}/${bodyRaw.statusText}`)
         if (debug.enabled && body) {
           debug(botiumUtils.shortenJsonString(body))
         }
         if (tries <= retries) {
-          await timeout(pingConfig.timeout)
+          await timeout(httpConfig.timeout)
         }
       } else {
-        debug(`_waitForUrlResponse success on url check ${pingConfig.uri}: ${response.statusCode}/${response.statusMessage}`)
-        this._storeCookiesFromResponse(response)
+        debug(`_waitForUrlResponse success on url check ${httpConfig.uri}: ${bodyRaw.status}/${bodyRaw.statusText}`)
+        this._storeCookiesFromResponse(bodyRaw)
         if (debug.enabled && body) {
-          debug(`body: ${botiumUtils.shortenJsonString(body)}, headers: ${botiumUtils.shortenJsonString(response.headers)}`)
+          debug(`body: ${botiumUtils.shortenJsonString(body)}, headers: ${botiumUtils.shortenJsonString(bodyRaw.headers)}`)
         }
-        return { body, headers: response.headers }
+        return { body, headers: bodyRaw.headers }
       }
     }
   }
@@ -848,7 +917,6 @@ module.exports = class SimpleRestContainer {
       const pollConfig = {
         method: verb,
         uri,
-        followAllRedirects: true,
         timeout
       }
       if (this.caps[Capabilities.SIMPLEREST_POLL_HEADERS]) {
@@ -864,13 +932,17 @@ module.exports = 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(`_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 }, this.view))
       } catch (err) {
@@ -879,34 +951,34 @@ module.exports = class SimpleRestContainer {
       }
       this._addRequestCookies(pollConfig)
 
-      request(pollConfig, async (err, response, body) => {
-        if (err) {
-          debug(`_runPolling: rest request failed: ${err.message}, request: ${JSON.stringify(pollConfig)}`)
-        } else {
-          if (response.statusCode >= 400) {
-            debug(`_runPolling: got error response: ${response.statusCode}/${response.statusMessage}, request: ${JSON.stringify(pollConfig)}`)
-            if (debug.enabled && body) {
-              debug(botiumUtils.shortenJsonString(body))
-            }
-          } else if (body) {
-            debug(`_runPolling: got response code: ${response.statusCode}, body: ${botiumUtils.shortenJsonString(body)}, headers: ${botiumUtils.shortenJsonString(response.headers)}`)
-            this._storeCookiesFromResponse(response)
-            try {
-              body = await this._parseResponseBody(body)
-            } catch (err) {
-              debug(`_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('_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(`_runPolling: got error response: ${bodyRaw.status}/${bodyRaw.statusText}, request: ${JSON.stringify(pollConfig)}`)
+          if (debug.enabled && body) {
+            debug(botiumUtils.shortenJsonString(body))
+          }
+        } else if (body) {
+          debug(`_runPolling: got response code: ${bodyRaw.status}/${bodyRaw.statusText}, body: ${botiumUtils.shortenJsonString(body)}, headers: ${botiumUtils.shortenJsonString(bodyRaw.headers)}`)
+          this._storeCookiesFromResponse(bodyRaw)
+          try {
+            body = await this._parseResponseBody(body)
+          } catch (err) {
+            debug(`_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(`_runPolling: got response code: ${response.statusCode}, empty body`)
+            debug('_runPolling: ignoring response body (no string and no JSON object)')
           }
+        } else {
+          debug(`_runPolling: got response code: ${bodyRaw.status}/${bodyRaw.statusText}, empty body`)
         }
-      })
+      } catch (err) {
+        debug(`_runPolling: rest request failed: ${err.message}, request: ${JSON.stringify(pollConfig)}`)
+      }
     }
   }
 
@@ -932,7 +1004,6 @@ module.exports = class SimpleRestContainer {
     const httpConfig = {
       method: verb,
       uri,
-      followAllRedirects: true,
       timeout
     }
     if (this.caps[`${capPrefix}_HEADERS`]) {
@@ -952,6 +1023,7 @@ module.exports = class SimpleRestContainer {
       }
     }
     this._addRequestOptions(httpConfig)
+    this._fetchify(httpConfig)
     await executeHook(this.caps, this.requestHooks[capPrefix], Object.assign({ requestOptions: httpConfig }, this.view))
     this._addRequestCookies(httpConfig)
 
@@ -962,9 +1034,8 @@ module.exports = class SimpleRestContainer {
   }
 
   _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]) {
       _.merge(httpConfig, this.caps[Capabilities.SIMPLEREST_EXTRA_OPTIONS])
@@ -979,25 +1050,23 @@ module.exports = 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 = _.get(response, 'request.uri.host')
-    let cookie
-    responseCookies.forEach(cookieString => {
-      cookie = cookie ? `${cookie}; ${cookieString}` : cookieString
-    })
+    const host = response?.url ? new URL(response.url).host : null
 
-    if (cookie) {
-      this.cookies[host] = cookie
+    if (host) {
+      this.cookies[host] = responseCookies
     }
   }
 }

package/src/scripting/Convo.js

@@ -597,7 +597,7 @@ class Convo {
             }
             Object.assign(scriptingMemory, scriptingMemoryUpdate)
             try {
-              await this.scriptingEvents.assertConvoStep({ convo: this, convoStep, container, scriptingMemory, botMsg, transcript, transcriptStep })
+              await this.scriptingEvents.assertConvoStep({ convo: this, convoStep, container, scriptingMemory, botMsg, transcript, transcriptStep, transcriptSteps })
               await this.scriptingEvents.onBotEnd({ convo: this, convoStep, container, scriptingMemory, botMsg, transcript, transcriptStep })
               optionalStepAssertionError = false
             } catch (err) {
@@ -825,7 +825,7 @@ class Convo {
   }
 
   _checkNormalizeText (container, str) {
-    return normalizeText(str, !!container.caps[Capabilities.SCRIPTING_NORMALIZE_TEXT])
+    return normalizeText(str, container.caps)
   }
 
   expandPartialConvos () {