botium-connector-voip 0.0.20 → 0.0.21

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

@@ -4,7 +4,6 @@ import axios from 'axios';
 import http from 'http';
 import https from 'https';
 import debug$4 from 'debug';
-import path from 'path';
 import musicMetadata from 'music-metadata';
 
 const debug$3 = debug$4('botium-connector-voip');
@@ -164,12 +163,17 @@ class BotiumConnectorVoip {
       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.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;
+      const firstStart = lodash.get(botMsgs, '[0].sourceData.data.start', null);
+      const lastEnd = lodash.get(botMsgs, `[${botMsgs.length - 1}].sourceData.data.end`, null);
+      const prevEnd = lodash.get(joinLastPrevMsg, 'sourceData.data.end', null);
+      // joinLastPrevMsg can be null (first joined message) OR incomplete (in case JOIN timeout fired before we got any final STT info).
+      // In those cases, fall back to "start-of-first-chunk" semantics (same as previous behaviour for nil joinLastPrevMsg).
+      if (lodash.isFinite(firstStart) && lodash.isFinite(lastEnd)) {
+        botMsg.sourceData[0].silenceDuration = lodash.isFinite(prevEnd) ? firstStart - prevEnd : firstStart;
+        botMsg.sourceData[0].voiceDuration = lastEnd - firstStart;
       } 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;
+        botMsg.sourceData[0].silenceDuration = lodash.isFinite(firstStart) ? firstStart : null;
+        botMsg.sourceData[0].voiceDuration = lodash.isFinite(firstStart) && lodash.isFinite(lastEnd) ? lastEnd - firstStart : null;
       }
       return botMsg;
     };
@@ -198,12 +202,14 @@ class BotiumConnectorVoip {
     const connect = async retryIndex => {
       retryIndex = retryIndex || 0;
       try {
+        const workerUrl = this.caps[Capabilities.VOIP_USE_GLOBAL_VOIP_WORKER] ? process.env.BOTIUM_VOIP_WORKER_URL : this.caps[Capabilities.VOIP_WORKER_URL].replace('wss', 'https').replace('ws', 'http');
+        const baseUrl = workerUrl.endsWith('/') ? workerUrl.slice(0, -1) : workerUrl;
         const res = await axios({
           method: 'post',
           data: {
             API_KEY: this.caps[Capabilities.VOIP_USE_GLOBAL_VOIP_WORKER] ? process.env.BOTIUM_VOIP_WORKER_APIKEY : this.caps[Capabilities.VOIP_WORKER_APIKEY]
           },
-          url: new URL(path.join(`${this.caps[Capabilities.VOIP_USE_GLOBAL_VOIP_WORKER] ? process.env.BOTIUM_VOIP_WORKER_URL : this.caps[Capabilities.VOIP_WORKER_URL].replace('wss', 'https').replace('ws', 'http')}`, 'initCall')).toString()
+          url: `${baseUrl}/initCall`
         });
         if (res) {
           data = res.data;
@@ -349,9 +355,88 @@ class BotiumConnectorVoip {
         });
         this.ws.on('message', async data => {
           const parsedData = JSON.parse(data);
+          // Allow fullRecord delivery even if Stop() was already called.
+          // Otherwise the recording can be dropped if the worker streams it late (common on hangup).
+          if (this.stopCalled) {
+            const allowedTypes = ['fullRecord', 'fullRecordStart', 'fullRecordChunk', 'fullRecordEnd', 'error'];
+            if (!parsedData || !parsedData.type || !allowedTypes.includes(parsedData.type)) {
+              debug$3(`${this.sessionId} - Stop already called, ignoring incoming message`);
+              return;
+            }
+          }
           const parsedDataLog = lodash.cloneDeep(parsedData);
-          parsedDataLog.fullRecord = '<full_record_buffer>';
+          // Sanitize all potential base64 fields for logging (don't dump huge buffers)
+          const sanitizeBase64Fields = (obj, prefix = '') => {
+            if (!obj || typeof obj !== 'object') return;
+            for (const key of Object.keys(obj)) {
+              const val = obj[key];
+              if (typeof val === 'string' && val.length > 500) {
+                obj[key] = `<base64:${val.length}chars>`;
+              } else if (val && typeof val === 'object' && !Array.isArray(val)) {
+                sanitizeBase64Fields(val, `${prefix}${key}.`);
+              }
+            }
+          };
+          sanitizeBase64Fields(parsedDataLog);
           debug$3(JSON.stringify(parsedDataLog, null, 2));
+          const _extractFullRecordBase64 = pd => {
+            if (!pd) return null;
+            // Different VOIP workers may put the payload in various fields - search all string fields
+            // First try known field names
+            const knownFields = [pd.fullRecord, pd.full_record, pd.data?.fullRecord, pd.data?.full_record, pd.data?.b64_buffer, pd.data?.base64, pd.data?.full_record_buffer, pd.data?.buffer, pd.buffer, pd.base64, pd.audio, pd.audioData, pd.data?.audio, pd.data?.audioData];
+            for (const val of knownFields) {
+              if (typeof val === 'string' && val.length > 100) return val;
+            }
+            // Fallback: find any large string field (likely base64)
+            const findLargeString = (obj, depth = 0) => {
+              if (!obj || typeof obj !== 'object' || depth > 3) return null;
+              for (const key of Object.keys(obj)) {
+                const val = obj[key];
+                if (typeof val === 'string' && val.length > 1000) {
+                  debug$3(`${this.sessionId} - Found base64 in field '${key}' (len=${val.length})`);
+                  return val;
+                }
+                if (val && typeof val === 'object' && !Array.isArray(val)) {
+                  const found = findLargeString(val, depth + 1);
+                  if (found) return found;
+                }
+              }
+              return null;
+            };
+            return findLargeString(pd);
+          };
+          const emitFullRecordAttachment = base64 => {
+            if (!base64 || typeof base64 !== 'string' || base64.length === 0) {
+              // Log available fields (length only) to help diagnose worker payload shape without dumping base64
+              try {
+                const candidates = {
+                  fullRecord: typeof parsedData?.fullRecord === 'string' ? parsedData.fullRecord.length : null,
+                  full_record: typeof parsedData?.full_record === 'string' ? parsedData.full_record.length : null,
+                  data_fullRecord: typeof parsedData?.data?.fullRecord === 'string' ? parsedData.data.fullRecord.length : null,
+                  data_full_record: typeof parsedData?.data?.full_record === 'string' ? parsedData.data.full_record.length : null,
+                  data_b64_buffer: typeof parsedData?.data?.b64_buffer === 'string' ? parsedData.data.b64_buffer.length : null,
+                  data_base64: typeof parsedData?.data?.base64 === 'string' ? parsedData.data.base64.length : null,
+                  data_full_record_buffer: typeof parsedData?.data?.full_record_buffer === 'string' ? parsedData.data.full_record_buffer.length : null,
+                  data_buffer: typeof parsedData?.data?.buffer === 'string' ? parsedData.data.buffer.length : null
+                };
+                debug$3(`${this.sessionId} - fullRecordEnd received but base64 is empty, skipping attachment emit. CandidateLengths=${JSON.stringify(candidates)}`);
+              } catch (err) {
+                debug$3(`${this.sessionId} - fullRecordEnd received but base64 is empty, skipping attachment emit (diag failed: ${err.message || err})`);
+              }
+              return;
+            }
+            debug$3(`${this.sessionId} - Emitting MESSAGE_ATTACHMENT full_record.wav (base64Len=${base64.length}, stopCalled=${!!this.stopCalled})`);
+            this.eventEmitter.emit('MESSAGE_ATTACHMENT', this.container, {
+              name: 'full_record.wav',
+              mimeType: 'audio/wav',
+              base64,
+              // Session context from capabilities for correlation
+              sessionContext: {
+                testSessionId: this.caps.VOIP_TEST_SESSION_ID || null,
+                testSessionJobId: this.caps.VOIP_TEST_SESSION_JOB_ID || null
+              }
+            });
+          };
           if (parsedData && parsedData.type === 'callinfo' && parsedData.status === 'initialized') {
             this.sessionId = parsedData.voipConfig.sessionId;
           }
@@ -387,6 +472,22 @@ class BotiumConnectorVoip {
             reject(new Error(`Error: ${parsedData.message}`));
             sendBotMsg(new Error(`Error: ${parsedData.message}`));
           }
+
+          // Full record streaming support:
+          // - some VOIP workers send the recording in chunks and an end marker
+          if (parsedData && parsedData.type === 'fullRecordStart') {
+            this.fullRecord = '';
+          }
+          if (parsedData && parsedData.type === 'fullRecordChunk') {
+            const chunk = _extractFullRecordBase64(parsedData);
+            if (chunk) this.fullRecord = (this.fullRecord || '') + chunk;
+          }
+          if (parsedData && parsedData.type === 'fullRecordEnd') {
+            const tail = _extractFullRecordBase64(parsedData);
+            if (tail) this.fullRecord = (this.fullRecord || '') + tail;
+            emitFullRecordAttachment(this.fullRecord || tail);
+            this.end = true;
+          }
           if (parsedData && parsedData.type === 'silence') {
             if (lodash.isNil(this._getIgnoreSilenceDurationAsserterLogicHook(this.convoStep))) {
               if (lodash.isNil(this._getJoinLogicHook(this.convoStep)) && parsedData.data.silence.length > 0) {
@@ -396,11 +497,8 @@ class BotiumConnectorVoip {
             }
           }
           if (parsedData && parsedData.type === 'fullRecord') {
-            this.eventEmitter.emit('MESSAGE_ATTACHMENT', this.container, {
-              name: 'full_record.wav',
-              mimeType: 'audio/wav',
-              base64: parsedData.fullRecord
-            });
+            // Non-chunked full record
+            emitFullRecordAttachment(_extractFullRecordBase64(parsedData));
             this.end = true;
           }
           if (parsedData && parsedData.data && parsedData.data.final === false) {
@@ -414,7 +512,7 @@ class BotiumConnectorVoip {
               }
             }
             this.firstSttInfoReceived = true;
-            if (this.prevData) {
+            if (this.prevData && this.prevData.data && !lodash.isNil(this.prevData.data.end)) {
               if (!lodash.isNil(parsedData.data.start)) {
                 const silenceDuration = parsedData.data.start - this.prevData.data.end;
                 const joinLogicHook = this._getJoinLogicHook(this.convoStep);
@@ -466,7 +564,9 @@ class BotiumConnectorVoip {
                 this.firstMsg = false;
               } else {
                 const sourceData = parsedData;
-                sourceData.silenceDuration = parsedData.data.start - this.prevData.data.end;
+                const start = lodash.get(parsedData, 'data.start', null);
+                const prevEnd = lodash.get(this.prevData, 'data.end', null);
+                sourceData.silenceDuration = lodash.isFinite(start) && lodash.isFinite(prevEnd) ? start - prevEnd : lodash.isFinite(start) ? start : null;
                 sourceData.voiceDuration = parsedData.data.end - parsedData.data.start;
                 botMsg = Object.assign({}, botMsg, {
                   sourceData
@@ -493,7 +593,9 @@ class BotiumConnectorVoip {
                 this.firstMsg = false;
               } else {
                 const sourceData = parsedData;
-                sourceData.silenceDuration = parsedData.data.start - this.prevData.data.end;
+                const start = lodash.get(parsedData, 'data.start', null);
+                const prevEnd = lodash.get(this.prevData, 'data.end', null);
+                sourceData.silenceDuration = lodash.isFinite(start) && lodash.isFinite(prevEnd) ? start - prevEnd : lodash.isFinite(start) ? start : null;
                 sourceData.voiceDuration = parsedData.data.end - parsedData.data.start;
                 botMsg = Object.assign({}, botMsg, {
                   sourceData
@@ -547,7 +649,24 @@ class BotiumConnectorVoip {
   }
   async UserSays(msg) {
     debug$3('UserSays called');
-    debug$3(msg);
+    // Avoid logging large buffers/base64 (can break job logs and overwhelm stdout)
+    try {
+      const safeLog = {
+        messageText: msg && msg.messageText ? String(msg.messageText).substring(0, 200) : undefined,
+        buttons: msg && Array.isArray(msg.buttons) ? msg.buttons.length : 0,
+        hasMedia: !!(msg && msg.media && msg.media.length > 0),
+        mediaMimeType: msg && msg.media && msg.media[0] ? msg.media[0].mimeType : undefined,
+        mediaSize: msg && msg.media && msg.media[0] && Buffer.isBuffer(msg.media[0].buffer) ? msg.media[0].buffer.length : undefined,
+        attachments: msg && Array.isArray(msg.attachments) ? msg.attachments.map(a => ({
+          name: a && (a.name || a.title),
+          mimeType: a && a.mimeType,
+          base64Len: a && a.base64 ? a.base64.length : 0
+        })) : []
+      };
+      debug$3(safeLog);
+    } catch (err) {
+      debug$3(`UserSays: failed to build safe log: ${err.message || err}`);
+    }
     if (!msg.attachments) {
       msg.attachments = [];
     }
@@ -658,6 +777,11 @@ class BotiumConnectorVoip {
   }
   async Stop() {
     debug$3(`${this.sessionId} - Stop called`);
+    this.stopCalled = true;
+    if (this.silenceTimeout) {
+      clearTimeout(this.silenceTimeout);
+      this.silenceTimeout = null;
+    }
     if (this.ws && this.ws.readyState !== ws.CLOSED) {
       const request = JSON.stringify({
         METHOD: 'stopCall',
@@ -665,9 +789,12 @@ class BotiumConnectorVoip {
       });
       this.ws.send(request);
       await new Promise(resolve => {
-        setTimeout(resolve, 100000);
-        setInterval(() => {
+        const stopTimeout = setTimeout(resolve, 100000);
+        this._stopWaitInterval = setInterval(() => {
           if (this.end) {
+            clearTimeout(stopTimeout);
+            clearInterval(this._stopWaitInterval);
+            this._stopWaitInterval = null;
             this.wsOpened = false;
             this.ws = null;
             this.end = false;