botium-connector-voip 0.0.6 → 0.0.7

package/dist/botium-connector-voip-cjs.js

@@ -57,7 +57,13 @@ const Capabilities = {
   VOIP_ICE_TURN_SERVER: 'VOIP_ICE_TURN_SERVER',
   VOIP_ICE_TURN_USER: 'VOIP_ICE_TURN_USER',
   VOIP_ICE_TURN_PASSWORD: 'VOIP_ICE_TURN_PASSWORD',
-  VOIP_ICE_TURN_PROTOCOL: 'VOIP_ICE_TURN_PROTOCOL'
+  VOIP_ICE_TURN_PROTOCOL: 'VOIP_ICE_TURN_PROTOCOL',
+  VOIP_WEBSOCKET_CONNECT_MAXRETRIES: 'VOIP_WEBSOCKET_CONNECT_MAXRETRIES',
+  VOIP_WEBSOCKET_CONNECT_TIMEOUT: 'VOIP_WEBSOCKET_CONNECT_TIMEOUT',
+  VOIP_SILENCE_DURATION_TIMEOUT_ENABLE: 'VOIP_SILENCE_DURATION_TIMEOUT_ENABLE',
+  VOIP_SILENCE_DURATION_TIMEOUT: 'VOIP_SILENCE_DURATION_TIMEOUT',
+  VOIP_SILENCE_DURATION_TIMEOUT_START_ENABLE: 'VOIP_SILENCE_DURATION_TIMEOUT_START_ENABLE',
+  VOIP_SILENCE_DURATION_TIMEOUT_START: 'VOIP_SILENCE_DURATION_TIMEOUT_START'
 };
 const Defaults = {
   VOIP_STT_METHOD: 'POST',
@@ -65,9 +71,15 @@ const Defaults = {
   VOIP_TTS_METHOD: 'GET',
   VOIP_TTS_TIMEOUT: 10000,
   VOIP_STT_MESSAGE_HANDLING: 'ORIGINAL',
-  VOIP_STT_MESSAGE_HANDLING_TIMEOUT: 5000,
+  VOIP_STT_MESSAGE_HANDLING_TIMEOUT: 500,
   VOIP_STT_MESSAGE_HANDLING_DELIMITER: '. ',
-  VOIP_STT_MESSAGE_HANDLING_PUNCTUATION: '.!?'
+  VOIP_STT_MESSAGE_HANDLING_PUNCTUATION: '.!?',
+  VOIP_WEBSOCKET_CONNECT_TIMEOUT: 4000,
+  VOIP_WEBSOCKET_CONNECT_MAXRETRIES: 20,
+  VOIP_SILENCE_DURATION_TIMEOUT: 2500,
+  VOIP_SILENCE_DURATION_TIMEOUT_ENABLE: false,
+  VOIP_SILENCE_DURATION_TIMEOUT_START: 1000,
+  VOIP_SILENCE_DURATION_TIMEOUT_START_ENABLE: false
 };
 
 class BotiumConnectorVoip {
@@ -133,20 +145,29 @@ class BotiumConnectorVoip {
     this.stopCalled = false;
     this.fullRecord = '';
     this.end = false;
+    this.connected = false;
 
     const sendBotMsg = botMsg => {
       setTimeout(() => this.queueBotSays(botMsg), 0);
     };
 
-    const buildBotMsg = botMsgs => {
-      if (botMsgs.length === 1) return botMsgs[0];
+    const joinBotMsg = (botMsgs, joinLastPrevMsg) => {
       const botMsg = {};
       botMsg.messageText = botMsgs.map(m => m.messageText).join(this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING_DELIMITER]);
       botMsg.sourceData = botMsgs.map(m => m.sourceData);
+
+      if (lodash__default["default"].isNil(joinLastPrevMsg)) {
+        botMsg.sourceData[0].silenceDuration = botMsgs[0].sourceData.data.start;
+        botMsg.sourceData[0].voiceDuration = botMsgs[botMsgs.length - 1].sourceData.data.end - botMsgs[0].sourceData.data.start;
+      } else {
+        botMsg.sourceData[0].silenceDuration = botMsgs[0].sourceData.data.start - joinLastPrevMsg.sourceData.data.end;
+        botMsg.sourceData[0].voiceDuration = botMsgs[botMsgs.length - 1].sourceData.data.end - botMsgs[0].sourceData.data.start;
+      }
+
       return botMsg;
     };
 
-    const expandBotMsgs = botMsgs => {
+    const splitBotMsgs = botMsgs => {
       const splitSentences = s => s.match(new RegExp(`[^${this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING_PUNCTUATION]}]+[${this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING_PUNCTUATION]}]+`, 'g'));
 
       const botMsgsFinal = [];
@@ -157,11 +178,14 @@ class BotiumConnectorVoip {
         if (lodash__default["default"].isNil(sentences)) {
           botMsgsFinal.push(botMsg);
         } else {
+          let botMsgCount = 0;
+
           for (const sentence of sentences) {
             botMsgsFinal.push({
               messageText: sentence,
-              sourceData: botMsg.sourceData
+              sourceData: botMsgCount === 0 ? botMsg.sourceData : lodash__default["default"].omit(botMsg.sourceData, ['silenceDuration'])
             });
+            botMsgCount++;
           }
         }
       }
@@ -169,37 +193,66 @@ class BotiumConnectorVoip {
       return botMsgsFinal;
     };
 
-    const {
-      data
-    } = await axios__default["default"]({
-      method: 'post',
-      data: {
-        API_KEY: this.caps[Capabilities.VOIP_WORKER_APIKEY]
-      },
-      url: new URL(path__default["default"].join(`${this.caps[Capabilities.VOIP_WORKER_URL].replace('wss', 'https').replace('ws', 'http')}`, 'initCall')).toString()
-    });
-    await new Promise(resolve => {
-      setTimeout(resolve, 2000);
-    });
+    let data = null;
+    let headers = null;
+
+    try {
+      const res = await axios__default["default"]({
+        method: 'post',
+        data: {
+          API_KEY: this.caps[Capabilities.VOIP_WORKER_APIKEY]
+        },
+        url: new URL(path__default["default"].join(`${this.caps[Capabilities.VOIP_WORKER_URL].replace('wss', 'https').replace('ws', 'http')}`, 'initCall')).toString()
+      });
+      data = res.data;
+      headers = res.headers;
+    } catch (err) {
+      return Promise.reject(new Error(`Connecting to VOIP Worker failed: ${err.response.data.message || 'Not reachable'}`));
+    }
+
     return new Promise((resolve, reject) => {
-      if (data.status === 'error') {
-        reject(new Error(`Error connecting to VOIP Worker: ${data.message}`));
-      }
+      const wsEndpoint = `${this.caps[Capabilities.VOIP_WORKER_URL]}/ws/${data.port}`;
+
+      const connect = retryIndex => {
+        retryIndex = retryIndex || 0;
+        return new Promise((resolve, reject) => {
+          if ('set-cookie' in headers) {
+            this.ws = new ws__default["default"](wsEndpoint, {
+              headers: {
+                Cookie: headers['set-cookie']
+              }
+            });
+          } else {
+            this.ws = new ws__default["default"](wsEndpoint);
+          }
 
-      this.ws = new ws__default["default"](this.caps[Capabilities.VOIP_WORKER_URL].replace('8765', data.port));
+          this.ws.on('open', () => {
+            resolve();
+          });
+          this.ws.on('error', () => {
+            if (retryIndex === this.caps[Capabilities.VOIP_WEBSOCKET_CONNECT_MAXRETRIES]) {
+              reject(new Error(`Websocket connection failed to ${wsEndpoint}`));
+            }
 
-      if (!lodash__default["default"].isArray(this.caps[Capabilities.VOIP_ICE_STUN_SERVERS])) {
-        if (this.caps[Capabilities.VOIP_ICE_STUN_SERVERS] === '') {
-          this.caps[Capabilities.VOIP_ICE_STUN_SERVERS] = [];
-        } else {
-          this.caps[Capabilities.VOIP_ICE_STUN_SERVERS] = this.caps[Capabilities.VOIP_ICE_STUN_SERVERS].split(',');
+            setTimeout(() => connect(retryIndex + 1).then(resolve).catch(reject), this.caps[Capabilities.VOIP_WEBSOCKET_CONNECT_TIMEOUT]);
+          });
+        });
+      };
+
+      connect().then(() => {
+        if (!lodash__default["default"].isArray(this.caps[Capabilities.VOIP_ICE_STUN_SERVERS])) {
+          if (this.caps[Capabilities.VOIP_ICE_STUN_SERVERS] === '') {
+            this.caps[Capabilities.VOIP_ICE_STUN_SERVERS] = [];
+          } else {
+            this.caps[Capabilities.VOIP_ICE_STUN_SERVERS] = this.caps[Capabilities.VOIP_ICE_STUN_SERVERS].split(',');
+          }
         }
-      }
 
-      this.wsOpened = false;
-      this.ws.on('open', () => {
+        this.silence = null;
+        this.msgCount = 0;
+        this.firstMsg = true;
         this.wsOpened = true;
-        debug(`Websocket connection to ${this.caps[Capabilities.VOIP_WORKER_ENDPOINT]} opened.`);
+        debug(`Websocket connection to ${wsEndpoint} opened.`);
         const request = {
           METHOD: 'initCall',
           SIP_CALLER_AUTO: this.caps[Capabilities.VOIP_SIP_POOL_CALLER_ENABLE],
@@ -218,6 +271,7 @@ class BotiumConnectorVoip {
           ICE_TURN_USERNAME: this.caps[Capabilities.VOIP_ICE_TURN_USER],
           ICE_TURN_PASSWORD: this.caps[Capabilities.VOIP_ICE_TURN_PASSWORD],
           ICE_TURN_PROTOCOL: this.caps[Capabilities.VOIP_ICE_TURN_PROTOCOL] || 'TCP',
+          MIN_SILENCE_DURATION: this.caps[Capabilities.VOIP_SILENCE_DURATION_TIMEOUT_ENABLE] ? this.caps[Capabilities.VOIP_SILENCE_DURATION_TIMEOUT] : null,
           STT_CONFIG: {
             stt_url: this.caps[Capabilities.VOIP_STT_URL_STREAM],
             stt_params: this.caps[Capabilities.VOIP_STT_PARAMS_STREAM],
@@ -231,110 +285,162 @@ class BotiumConnectorVoip {
         };
         debug(JSON.stringify(request, null, 2));
         this.ws.send(JSON.stringify(request));
-      });
-      this.ws.on('close', async () => {
-        debug(`${this.sessionId} - Websocket connection to ${this.caps[Capabilities.VOIP_WORKER_URL]} closed.`);
-      });
-      this.ws.on('error', err => {
-        debug(err);
+        this.ws.on('error', err => {
+          debug(err);
 
-        if (!this.wsOpened) {
-          this.end = true;
-          reject(new Error(`${this.sessionId} - Websocket connection to ${this.caps[Capabilities.VOIP_WORKER_URL]} error: ${err.message || err}`));
-        }
-      });
-      this.ws.on('message', async data => {
-        const parsedData = JSON.parse(data);
+          if (!this.wsOpened) {
+            this.end = true;
+            reject(new Error(`${this.sessionId} - Websocket connection to ${wsEndpoint} error: ${err.message || err}`));
+          }
+        });
+        this.ws.on('message', async data => {
+          const parsedData = JSON.parse(data);
 
-        const parsedDataLog = lodash__default["default"].cloneDeep(parsedData);
+          const parsedDataLog = lodash__default["default"].cloneDeep(parsedData);
 
-        parsedDataLog.fullRecord = '<full_record_buffer>';
-        debug(JSON.stringify(parsedDataLog, null, 2));
+          parsedDataLog.fullRecord = '<full_record_buffer>';
+          debug(JSON.stringify(parsedDataLog, null, 2));
 
-        if (parsedData && parsedData.type === 'callinfo' && parsedData.status === 'initialized') {
-          this.sessionId = parsedData.voipConfig.sessionId;
-        }
+          if (parsedData && parsedData.type === 'callinfo' && parsedData.status === 'initialized') {
+            this.sessionId = parsedData.voipConfig.sessionId;
+          }
 
-        if (parsedData && parsedData.type === 'callinfo' && parsedData.status === 'unauthorized') {
-          reject(new Error('Error: Cannot open a call: SIP Authorization failed'));
-        }
+          if (parsedData && parsedData.type === 'callinfo' && parsedData.status === 'unauthorized') {
+            reject(new Error('Error: Cannot open a call: SIP Authorization failed'));
+          }
 
-        if (parsedData && parsedData.type === 'callinfo' && parsedData.status === 'forbidden' && parsedData.event === 'onCallRegState') {
-          reject(new Error('Error: Sip Registration failed'));
-        }
+          if (parsedData && parsedData.type === 'callinfo' && parsedData.status === 'forbidden' && parsedData.event === 'onCallRegState') {
+            reject(new Error('Error: Sip Registration failed'));
+          }
 
-        if (parsedData && parsedData.type === 'callinfo' && parsedData.status === 'connected') {
-          resolve();
-        }
+          if (parsedData && parsedData.type === 'callinfo' && parsedData.status === 'connected') {
+            resolve();
+          }
 
-        if (parsedData && parsedData.type === 'callinfo' && parsedData.status === 'disconnected') {
-          const apiKey = this._extractApiKey(this._getBody(Capabilities.VOIP_STT_BODY));
+          if (parsedData && parsedData.type === 'callinfo' && parsedData.status === 'disconnected') {
+            const apiKey = this._extractApiKey(this._getBody(Capabilities.VOIP_STT_BODY));
 
-          if (parsedData.connectDuration && parsedData.connectDuration > 0) {
-            this.eventEmitter.emit('CONSUMPTION_METADATA', this.container, {
-              type: lodash__default["default"].isNil(apiKey) ? 'INBUILT' : 'THIRD_PARTY',
-              metricName: 'consumption.e2e.voip.stt.seconds',
-              credits: parsedData.connectDuration,
-              apiKey
-            });
+            if (parsedData.connectDuration && parsedData.connectDuration > 0) {
+              this.eventEmitter.emit('CONSUMPTION_METADATA', this, {
+                type: lodash__default["default"].isNil(apiKey) ? 'INBUILT' : 'THIRD_PARTY',
+                metricName: 'consumption.e2e.voip.stt.seconds',
+                credits: parsedData.connectDuration,
+                apiKey
+              });
+            }
           }
-        }
 
-        if (parsedData && parsedData.type === 'error') {
-          this.end = true;
-          this.Stop();
-          reject(new Error(`Error: ${parsedData.message}`));
-        }
+          if (parsedData && parsedData.type === 'error') {
+            this.end = true;
+            reject(new Error(`Error: ${parsedData.message}`));
+            sendBotMsg(new Error(`Error: ${parsedData.message}`));
+          }
 
-        if (parsedData && parsedData.type === 'fullRecord') {
-          this.end = true;
-          this.eventEmitter.emit('MESSAGE_ATTACHMENT', this.container, {
-            name: 'full_record.wav',
-            mimeType: 'audio/wav',
-            base64: parsedData.fullRecord
-          });
-          this.Stop();
-        }
+          if (parsedData && parsedData.type === 'silence') {
+            this.end = true;
 
-        if (parsedData && parsedData.data && parsedData.data.final === false) {
-          if (!this.sentenceBuilding) {
-            this.sentenceBuilding = true;
-            this.sentencesBuilding++;
+            if (parsedData.data.silence.length > 0) {
+              sendBotMsg(new Error(`Silence Duration of ${parsedData.data.silence[0][2].toFixed(2)}s exceeded General Silence Duration Timeout of ${this.caps[Capabilities.VOIP_SILENCE_DURATION_TIMEOUT] / 1000}s`));
+              this.Stop();
+            }
           }
-        }
 
-        if (parsedData && parsedData.data && parsedData.data.final) {
-          const botMsg = {
-            messageText: parsedData.data.message,
-            sourceData: parsedData
-          };
-          this.botMsgs.push(botMsg);
-
-          if (this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING] === 'ORIGINAL') {
-            this.botMsgs.forEach(botMsg => sendBotMsg(botMsg));
-            this.botMsgs = [];
+          if (parsedData && parsedData.type === 'fullRecord') {
+            this.eventEmitter.emit('MESSAGE_ATTACHMENT', this.container, {
+              name: 'full_record.wav',
+              mimeType: 'audio/wav',
+              base64: parsedData.fullRecord
+            });
           }
 
-          if (this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING] === 'EXPAND') {
-            const botMsgsExpanded = expandBotMsgs(this.botMsgs);
-            botMsgsExpanded.forEach(botMsg => sendBotMsg(botMsg));
-            this.botMsgs = [];
+          if (parsedData && parsedData.data && parsedData.data.final === false) {
+            if (this.caps[Capabilities.VOIP_SILENCE_DURATION_TIMEOUT_START_ENABLE] && parsedData.data.start && parsedData.data.start * 1000 > this.caps[Capabilities.VOIP_SILENCE_DURATION_TIMEOUT_START]) {
+              sendBotMsg(new Error(`Silence Duration of ${parsedData.data.start}s exceeded Start Silence Duration Timeout of ${this.caps[Capabilities.VOIP_SILENCE_DURATION_TIMEOUT_START] / 1000}s`));
+              this.Stop();
+            }
+
+            if (this.prevData) {
+              if (!lodash__default["default"].isNil(parsedData.data.start) && parsedData.data.start - this.prevData.data.end > parseInt(this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING_TIMEOUT]) / 1000) {
+                if (this.botMsgs.length > 0) {
+                  sendBotMsg(joinBotMsg(this.botMsgs, this.joinLastPrevMsg));
+                  this.firstMsg = false;
+                  this.joinLastPrevMsg = this.botMsgs[this.botMsgs.length - 1];
+                  this.botMsgs = [];
+                }
+              }
+            }
           }
 
-          if (this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING] === 'CONCAT') {
-            this.sentenceBuilding = false;
-            this.sentencesFinal++;
-            clearTimeout(this.sendMessageTimeout);
-            this.sendMessageTimeout = setTimeout(() => {
-              if (this.sentenceBuilding === false && this.sentencesBuilding === this.sentencesFinal) {
-                sendBotMsg(buildBotMsg(this.botMsgs));
-                this.botMsgs = [];
-                this.sentencesBuilding = 0;
-                this.sentencesFinal = 0;
+          if (parsedData && parsedData.data && parsedData.data.type === 'stt' && parsedData.data.final) {
+            if (this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING] === 'ORIGINAL') {
+              let botMsg = {
+                messageText: parsedData.data.message
+              };
+
+              if (this.firstMsg) {
+                const sourceData = parsedData;
+                sourceData.silenceDuration = parsedData.data.start;
+                sourceData.voiceDuration = parsedData.data.end - parsedData.data.start;
+                botMsg = Object.assign({}, botMsg, {
+                  sourceData
+                });
+                this.firstMsg = false;
+              } else {
+                const sourceData = parsedData;
+                sourceData.silenceDuration = parsedData.data.start - this.prevData.data.end;
+                sourceData.voiceDuration = parsedData.data.end - parsedData.data.start;
+                botMsg = Object.assign({}, botMsg, {
+                  sourceData
+                });
+              }
+
+              this.prevData = parsedData;
+              this.botMsgs.push(botMsg);
+              this.botMsgs.forEach(botMsg => sendBotMsg(botMsg));
+              this.botMsgs = [];
+            }
+
+            if (this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING] === 'SPLIT' || this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING] === 'EXPAND') {
+              let botMsg = {
+                messageText: parsedData.data.message
+              };
+
+              if (this.firstMsg) {
+                const sourceData = parsedData;
+                sourceData.silenceDuration = parsedData.data.start;
+                sourceData.voiceDuration = parsedData.data.end - parsedData.data.start;
+                botMsg = Object.assign({}, botMsg, {
+                  sourceData
+                });
+                this.firstMsg = false;
+              } else {
+                const sourceData = parsedData;
+                sourceData.silenceDuration = parsedData.data.start - this.prevData.data.end;
+                sourceData.voiceDuration = parsedData.data.end - parsedData.data.start;
+                botMsg = Object.assign({}, botMsg, {
+                  sourceData
+                });
               }
-            }, this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING_TIMEOUT]);
+
+              this.prevData = parsedData;
+              this.botMsgs.push(botMsg);
+              const botMsgsExpanded = splitBotMsgs(this.botMsgs);
+              botMsgsExpanded.forEach(botMsg => sendBotMsg(botMsg));
+              this.botMsgs = [];
+            }
+
+            if (this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING] === 'JOIN' || this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING] === 'CONCAT') {
+              const botMsg = {
+                messageText: parsedData.data.message,
+                sourceData: parsedData
+              };
+              this.botMsgs.push(botMsg);
+              this.prevData = parsedData;
+            }
           }
-        }
+        });
+      }).catch(err => {
+        reject(new Error('Error: ' + err));
       });
     });
   }
@@ -447,35 +553,29 @@ class BotiumConnectorVoip {
   }
 
   async Stop() {
-    if (!this.stopCalled) {
-      this.stopCalled = true;
-      debug(`${this.sessionId} - Stop called`);
-
-      if (this.ws && this.ws.readyState !== ws__default["default"].CLOSED) {
-        const request = JSON.stringify({
-          METHOD: 'stopCall',
-          sessionId: this.sessionId
-        });
-        this.ws.send(request);
-        await new Promise(resolve => {
-          setTimeout(resolve, 50000);
-          setInterval(() => {
-            if (this.end) {
-              this.wsOpened = false;
-              this.ws = null;
-              this.view = {};
-              resolve();
-            }
-          }, 1000);
-        });
-        /* if (this.ws && this.ws.readyState !== WebSocket.CLOSED) {
-          this.ws.close()
-        } */
-      } else {
-        this.wsOpened = false;
-        this.ws = null;
-        this.view = {};
-      }
+    debug(`${this.sessionId} - Stop called`);
+
+    if (this.ws && this.ws.readyState !== ws__default["default"].CLOSED) {
+      const request = JSON.stringify({
+        METHOD: 'stopCall',
+        sessionId: this.sessionId
+      });
+      this.ws.send(request);
+      await new Promise(resolve => {
+        setTimeout(resolve, 10000);
+        setInterval(() => {
+          if (this.end) {
+            this.wsOpened = false;
+            this.ws = null;
+            this.view = {};
+            resolve();
+          }
+        }, 1000);
+      });
+    } else {
+      this.wsOpened = false;
+      this.ws = null;
+      this.view = {};
     }
   }