botium-connector-voip 0.0.20 → 0.0.22

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

@@ -8,7 +8,6 @@ var axios = require('axios');
 var http = require('http');
 var https = require('https');
 var debug$4 = require('debug');
-var path = require('path');
 var musicMetadata = require('music-metadata');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
@@ -19,10 +18,21 @@ var axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
 var http__default = /*#__PURE__*/_interopDefaultLegacy(http);
 var https__default = /*#__PURE__*/_interopDefaultLegacy(https);
 var debug__default = /*#__PURE__*/_interopDefaultLegacy(debug$4);
-var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
 var musicMetadata__default = /*#__PURE__*/_interopDefaultLegacy(musicMetadata);
 
 const debug$3 = debug__default["default"]('botium-connector-voip');
+
+// Logging policy: info = rare, business-relevant lifecycle events (always visible).
+// debug = high-frequency diagnostics (DEBUG=botium-connector-voip). warn = degraded but continuing.
+// error = abort/failure. No secrets in info; STT text only as length or truncated in info.
+
+const _info = (event, data) => {
+  const parts = Object.entries({
+    event,
+    ...data
+  }).filter(([, v]) => v != null && v !== '').map(([k, v]) => `${k}=${typeof v === 'string' && v.length > 80 ? `"${v.substring(0, 77)}..."` : JSON.stringify(v)}`);
+  console.info(`[botium-connector-voip] ${parts.join(' ')}`);
+};
 const Capabilities = {
   VOIP_STT_URL_STREAM: 'VOIP_STT_URL_STREAM',
   VOIP_STT_PARAMS_STREAM: 'VOIP_STT_PARAMS_STREAM',
@@ -70,7 +80,8 @@ const Capabilities = {
   VOIP_SILENCE_DURATION_TIMEOUT_START_ENABLE: 'VOIP_SILENCE_DURATION_TIMEOUT_START_ENABLE',
   VOIP_SILENCE_DURATION_TIMEOUT_START: 'VOIP_SILENCE_DURATION_TIMEOUT_START',
   VOIP_STT_CONFIDENCE_THRESHOLD: 'VOIP_STT_CONFIDENCE_THRESHOLD',
-  VOIP_USE_GLOBAL_VOIP_WORKER: 'VOIP_USE_GLOBAL_VOIP_WORKER'
+  VOIP_USE_GLOBAL_VOIP_WORKER: 'VOIP_USE_GLOBAL_VOIP_WORKER',
+  VOIP_USER_INPUT_PREFER_VOICE: 'VOIP_USER_INPUT_PREFER_VOICE'
 };
 const Defaults = {
   VOIP_STT_METHOD: 'POST',
@@ -92,7 +103,8 @@ const Defaults = {
   VOIP_SILENCE_DURATION_TIMEOUT_START_ENABLE: false,
   VOIP_STT_CONFIDENCE_THRESHOLD: 0.5,
   VOIP_USE_GLOBAL_VOIP_WORKER: false,
-  VOIP_SIP_PROTOCOL: 'TCP'
+  VOIP_SIP_PROTOCOL: 'TCP',
+  VOIP_USER_INPUT_PREFER_VOICE: true
 };
 const TTS_HTTP_AGENT = new http__default["default"].Agent({
   keepAlive: true
@@ -179,12 +191,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__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;
+      const firstStart = lodash__default["default"].get(botMsgs, '[0].sourceData.data.start', null);
+      const lastEnd = lodash__default["default"].get(botMsgs, `[${botMsgs.length - 1}].sourceData.data.end`, null);
+      const prevEnd = lodash__default["default"].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__default["default"].isFinite(firstStart) && lodash__default["default"].isFinite(lastEnd)) {
+        botMsg.sourceData[0].silenceDuration = lodash__default["default"].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__default["default"].isFinite(firstStart) ? firstStart : null;
+        botMsg.sourceData[0].voiceDuration = lodash__default["default"].isFinite(firstStart) && lodash__default["default"].isFinite(lastEnd) ? lastEnd - firstStart : null;
       }
       return botMsg;
     };
@@ -210,15 +227,18 @@ class BotiumConnectorVoip {
     };
     let data = null;
     let headers = null;
-    const connect = async retryIndex => {
+    let httpInitRetries = 0;
+    const connectHttp = 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__default["default"]({
           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__default["default"].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;
@@ -229,17 +249,24 @@ class BotiumConnectorVoip {
         if (retryIndex === this.caps[Capabilities.VOIP_WEBSOCKET_CONNECT_MAXRETRIES]) {
           throw new Error(`Connecting to VOIP Worker failed: ${err.message || 'Not reachable'}`);
         }
+        httpInitRetries = retryIndex + 1;
         // Retry after the defined timeout
         await new Promise(resolve => setTimeout(resolve, this.caps[Capabilities.VOIP_WEBSOCKET_CONNECT_TIMEOUT]));
 
         // Retry the connection
-        await connect(retryIndex + 1);
+        await connectHttp(retryIndex + 1);
       }
     };
-    await connect();
+    await connectHttp();
+    if (httpInitRetries > 0) {
+      _info('connected_after_retries', {
+        phase: 'initCall',
+        retries: httpInitRetries
+      });
+    }
     return new Promise((resolve, reject) => {
       const wsEndpoint = `${this.caps[Capabilities.VOIP_USE_GLOBAL_VOIP_WORKER] ? process.env.BOTIUM_VOIP_WORKER_URL : this.caps[Capabilities.VOIP_WORKER_URL]}/ws/${data.port}`;
-      const connect = retryIndex => {
+      const connectWs = retryIndex => {
         retryIndex = retryIndex || 0;
         return new Promise((resolve, reject) => {
           if ('set-cookie' in headers) {
@@ -252,17 +279,23 @@ class BotiumConnectorVoip {
             this.ws = new ws__default["default"](wsEndpoint);
           }
           this.ws.on('open', () => {
-            resolve();
+            resolve(retryIndex);
           });
           this.ws.on('error', () => {
             if (retryIndex === this.caps[Capabilities.VOIP_WEBSOCKET_CONNECT_MAXRETRIES]) {
               reject(new Error(`Websocket connection failed to ${wsEndpoint}`));
             }
-            setTimeout(() => connect(retryIndex + 1).then(resolve).catch(reject), this.caps[Capabilities.VOIP_WEBSOCKET_CONNECT_TIMEOUT]);
+            setTimeout(() => connectWs(retryIndex + 1).then(resolve).catch(reject), this.caps[Capabilities.VOIP_WEBSOCKET_CONNECT_TIMEOUT]);
           });
         });
       };
-      connect().then(() => {
+      connectWs().then(wsRetries => {
+        if (wsRetries > 0) {
+          _info('connected_after_retries', {
+            phase: 'websocket',
+            retries: wsRetries
+          });
+        }
         if (!lodash__default["default"].isArray(this.caps[Capabilities.VOIP_ICE_STUN_SERVERS])) {
           if (lodash__default["default"].isEmpty(this.caps[Capabilities.VOIP_ICE_STUN_SERVERS])) {
             this.caps[Capabilities.VOIP_ICE_STUN_SERVERS] = [];
@@ -304,6 +337,7 @@ class BotiumConnectorVoip {
         });
         this.silence = null;
         this.msgCount = 0;
+        this.sttPartialCount = 0;
         this.firstMsg = true;
         this.firstSttInfoReceived = false;
         this.silenceTimeout = null;
@@ -364,11 +398,94 @@ 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__default["default"].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;
+            _info('callinfo_initialized', {
+              sessionId: this.sessionId,
+              sttHandling: this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING]
+            });
           }
 
           // if sessionId is not the same as the one in the callinfo, return
@@ -383,9 +500,17 @@ class BotiumConnectorVoip {
             reject(new Error('Error: Sip Registration failed'));
           }
           if (parsedData && parsedData.type === 'callinfo' && parsedData.status === 'connected') {
+            _info('callinfo_connected', {
+              sessionId: this.sessionId
+            });
             resolve();
           }
           if (parsedData && parsedData.type === 'callinfo' && parsedData.status === 'disconnected') {
+            _info('callinfo_disconnected', {
+              sessionId: this.sessionId,
+              connectDurationSec: parsedData.connectDuration || null,
+              sttPartialCount: this.sttPartialCount
+            });
             const apiKey = this._extractApiKey(this._getBody(Capabilities.VOIP_STT_BODY));
             if (parsedData.connectDuration && parsedData.connectDuration > 0) {
               this.eventEmitter.emit('CONSUMPTION_METADATA', this, {
@@ -402,6 +527,28 @@ 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;
+            const base64Len = (this.fullRecord || tail || '').length;
+            emitFullRecordAttachment(this.fullRecord || tail);
+            _info('recording_attached', {
+              sessionId: this.sessionId,
+              source: 'fullRecordEnd',
+              base64Len
+            });
+            this.end = true;
+          }
           if (parsedData && parsedData.type === 'silence') {
             if (lodash__default["default"].isNil(this._getIgnoreSilenceDurationAsserterLogicHook(this.convoStep))) {
               if (lodash__default["default"].isNil(this._getJoinLogicHook(this.convoStep)) && parsedData.data.silence.length > 0) {
@@ -411,14 +558,18 @@ 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
+            const base64 = _extractFullRecordBase64(parsedData);
+            emitFullRecordAttachment(base64);
+            _info('recording_attached', {
+              sessionId: this.sessionId,
+              source: 'fullRecord',
+              base64Len: (base64 || '').length
             });
             this.end = true;
           }
           if (parsedData && parsedData.data && parsedData.data.final === false) {
+            this.sttPartialCount++;
             if (this.silenceTimeout) {
               clearTimeout(this.silenceTimeout);
             }
@@ -429,7 +580,7 @@ class BotiumConnectorVoip {
               }
             }
             this.firstSttInfoReceived = true;
-            if (this.prevData) {
+            if (this.prevData && this.prevData.data && !lodash__default["default"].isNil(this.prevData.data.end)) {
               if (!lodash__default["default"].isNil(parsedData.data.start)) {
                 const silenceDuration = parsedData.data.start - this.prevData.data.end;
                 const joinLogicHook = this._getJoinLogicHook(this.convoStep);
@@ -465,7 +616,18 @@ class BotiumConnectorVoip {
           if (parsedData && parsedData.data && parsedData.data.type === 'stt' && parsedData.data.final) {
             const confidenceThreshold = this._getConfidenceScoreLogicHook(this.convoStep) && this._getConfidenceScoreLogicHook(this.convoStep).args[0] || this.caps[Capabilities.VOIP_STT_CONFIDENCE_THRESHOLD];
             const successfulConfidenceScore = this._getConfidenceScore(parsedData) >= confidenceThreshold;
+            const msgText = parsedData.data.message || '';
+            const msgLen = typeof msgText === 'string' ? msgText.length : 0;
+            const msgPreview = typeof msgText === 'string' ? msgText.trim().substring(0, 80) : '';
             debug$3(`Message: ${parsedData.data.message} / Confidence Score: ${this._getConfidenceScore(parsedData)} (Threshold: ${confidenceThreshold})`);
+            _info('stt_final', {
+              sessionId: this.sessionId,
+              message: msgPreview,
+              messageLength: msgLen,
+              confidence: this._getConfidenceScore(parsedData),
+              threshold: confidenceThreshold,
+              accepted: successfulConfidenceScore
+            });
             // ORIGINAL: emit final message immediately, unless join hooks are active.
             if (this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING] === 'ORIGINAL' && lodash__default["default"].isNil(this._getJoinLogicHook(this.convoStep))) {
               let botMsg = {
@@ -481,7 +643,9 @@ class BotiumConnectorVoip {
                 this.firstMsg = false;
               } else {
                 const sourceData = parsedData;
-                sourceData.silenceDuration = parsedData.data.start - this.prevData.data.end;
+                const start = lodash__default["default"].get(parsedData, 'data.start', null);
+                const prevEnd = lodash__default["default"].get(this.prevData, 'data.end', null);
+                sourceData.silenceDuration = lodash__default["default"].isFinite(start) && lodash__default["default"].isFinite(prevEnd) ? start - prevEnd : lodash__default["default"].isFinite(start) ? start : null;
                 sourceData.voiceDuration = parsedData.data.end - parsedData.data.start;
                 botMsg = Object.assign({}, botMsg, {
                   sourceData
@@ -508,7 +672,9 @@ class BotiumConnectorVoip {
                 this.firstMsg = false;
               } else {
                 const sourceData = parsedData;
-                sourceData.silenceDuration = parsedData.data.start - this.prevData.data.end;
+                const start = lodash__default["default"].get(parsedData, 'data.start', null);
+                const prevEnd = lodash__default["default"].get(this.prevData, 'data.end', null);
+                sourceData.silenceDuration = lodash__default["default"].isFinite(start) && lodash__default["default"].isFinite(prevEnd) ? start - prevEnd : lodash__default["default"].isFinite(start) ? start : null;
                 sourceData.voiceDuration = parsedData.data.end - parsedData.data.start;
                 botMsg = Object.assign({}, botMsg, {
                   sourceData
@@ -562,13 +728,47 @@ class BotiumConnectorVoip {
   }
   async UserSays(msg) {
     debug$3('UserSays called');
-    debug$3(msg);
+    const hasText = !!(msg && msg.messageText);
+    const hasVoiceMedia = !!(msg && msg.media && msg.media.length > 0 && msg.media[0].buffer);
+    const hasDtmf = !!(msg && msg.buttons && msg.buttons.length > 0);
+    const dtmfMatch = msg && msg.messageText && msg.messageText.match(/<DTMF>([^<]+)<\/DTMF>/i);
+    const inputType = hasDtmf || dtmfMatch ? 'dtmf' : hasText && hasVoiceMedia ? 'mixed' : hasText ? 'text' : hasVoiceMedia ? 'media' : 'unknown';
+    const msgPreview = hasText && msg.messageText ? String(msg.messageText).trim().substring(0, 80) : '';
+    _info('user_says', {
+      sessionId: this.sessionId,
+      inputType,
+      message: msgPreview || undefined,
+      messageLength: hasText && msg.messageText ? msg.messageText.length : undefined,
+      mediaSize: hasVoiceMedia && msg.media[0] && Buffer.isBuffer(msg.media[0].buffer) ? msg.media[0].buffer.length : undefined
+    });
+    // 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 = [];
     }
     return new Promise((resolve, reject) => {
       setTimeout(async () => {
         let duration = 0;
+        const preferVoiceCapRaw = this.caps[Capabilities.VOIP_USER_INPUT_PREFER_VOICE];
+        const preferVoice = !!preferVoiceCapRaw;
+        const skipTtsForMixedInput = preferVoice && hasText && hasVoiceMedia;
+        debug$3(`UserSays routing: hasText=${hasText} hasVoiceMedia=${hasVoiceMedia} preferVoice=${preferVoice} preferVoiceRaw=${JSON.stringify(preferVoiceCapRaw)} skipTtsForMixedInput=${skipTtsForMixedInput}`);
         if (msg && msg.buttons && msg.buttons.length > 0) {
           const request = JSON.stringify({
             METHOD: 'sendDtmf',
@@ -590,55 +790,61 @@ class BotiumConnectorVoip {
             this.ws.send(request);
             return resolve();
           }
-          if (!this.axiosTtsParams) {
-            if (!(msg.media && msg.media.length > 0 && msg.media[0].buffer)) {
-              return reject(new Error('TTS not configured, only audio input supported'));
-            }
-          } else {
-            const ttsRequest = this._buildTtsRequest(msg.messageText);
-            if (!ttsRequest) return reject(new Error('TTS not configured, only audio input supported'));
-            msg.sourceData = ttsRequest;
-            let ttsResult = null;
-            try {
-              ttsResult = await this._getTtsAudio(ttsRequest, msg.messageText);
-            } catch (err) {
-              return reject(new Error(`TTS "${msg.messageText}" failed - ${this._getAxiosErrOutput(err)}`));
-            }
-            if (msg && msg.messageText && msg.messageText.length > 0) {
-              const apiKey = this._extractApiKey(this._getBody(Capabilities.VOIP_TTS_BODY));
-              this.eventEmitter.emit('CONSUMPTION_METADATA', this.container, {
-                type: lodash__default["default"].isNil(apiKey) ? 'INBUILT' : 'THIRD_PARTY',
-                metricName: 'consumption.e2e.voip.tts.characters',
-                transactions: msg.messageText.length,
-                apiKey
-              });
-            }
-            if (ttsResult && Buffer.isBuffer(ttsResult.buffer)) {
-              duration = parseFloat(ttsResult.duration) || 0;
-              const b64Buffer = ttsResult.buffer.toString('base64');
-              const request = JSON.stringify({
-                METHOD: 'sendAudio',
-                PESQ: false,
-                sessionId: this.sessionId,
-                b64_buffer: b64Buffer
-              });
-              if (this._lastBotSaysQueuedAt) {
-                const latencyMs = Date.now() - this._lastBotSaysQueuedAt;
-                const botText = this._lastBotSaysText ? this._lastBotSaysText.substring(0, 120) : '<unknown>';
-                debug$3(`Latency (bot says -> sendAudio/TTS): ${latencyMs} ms (last bot: ${botText})`);
+          if (!skipTtsForMixedInput) {
+            if (!this.axiosTtsParams) {
+              if (!(msg.media && msg.media.length > 0 && msg.media[0].buffer)) {
+                return reject(new Error('TTS not configured, only audio input supported'));
               }
-              msg.attachments.push({
-                name: 'tts.wav',
-                mimeType: 'audio/wav',
-                base64: b64Buffer
-              });
-              this.ws.send(request);
             } else {
-              return reject(new Error('TTS failed, response is empty'));
+              debug$3('UserSays routing: executing TTS branch');
+              const ttsRequest = this._buildTtsRequest(msg.messageText);
+              if (!ttsRequest) return reject(new Error('TTS not configured, only audio input supported'));
+              msg.sourceData = ttsRequest;
+              let ttsResult = null;
+              try {
+                ttsResult = await this._getTtsAudio(ttsRequest, msg.messageText);
+              } catch (err) {
+                return reject(new Error(`TTS "${msg.messageText}" failed - ${this._getAxiosErrOutput(err)}`));
+              }
+              if (msg && msg.messageText && msg.messageText.length > 0) {
+                const apiKey = this._extractApiKey(this._getBody(Capabilities.VOIP_TTS_BODY));
+                this.eventEmitter.emit('CONSUMPTION_METADATA', this.container, {
+                  type: lodash__default["default"].isNil(apiKey) ? 'INBUILT' : 'THIRD_PARTY',
+                  metricName: 'consumption.e2e.voip.tts.characters',
+                  transactions: msg.messageText.length,
+                  apiKey
+                });
+              }
+              if (ttsResult && Buffer.isBuffer(ttsResult.buffer)) {
+                duration = parseFloat(ttsResult.duration) || 0;
+                const b64Buffer = ttsResult.buffer.toString('base64');
+                const request = JSON.stringify({
+                  METHOD: 'sendAudio',
+                  PESQ: false,
+                  sessionId: this.sessionId,
+                  b64_buffer: b64Buffer
+                });
+                if (this._lastBotSaysQueuedAt) {
+                  const latencyMs = Date.now() - this._lastBotSaysQueuedAt;
+                  const botText = this._lastBotSaysText ? this._lastBotSaysText.substring(0, 120) : '<unknown>';
+                  debug$3(`Latency (bot says -> sendAudio/TTS): ${latencyMs} ms (last bot: ${botText})`);
+                }
+                msg.attachments.push({
+                  name: 'tts.wav',
+                  mimeType: 'audio/wav',
+                  base64: b64Buffer
+                });
+                this.ws.send(request);
+              } else {
+                return reject(new Error('TTS failed, response is empty'));
+              }
             }
+          } else {
+            debug$3('UserSays routing: skipping TTS for mixed input because VOIP_USER_INPUT_PREFER_VOICE is enabled');
           }
         }
         if (msg && msg.media && msg.media.length > 0 && msg.media[0].buffer) {
+          debug$3('UserSays routing: executing MEDIA branch');
           const request = JSON.stringify({
             METHOD: 'sendAudio',
             sessionId: this.sessionId,
@@ -673,6 +879,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__default["default"].CLOSED) {
       const request = JSON.stringify({
         METHOD: 'stopCall',
@@ -680,9 +891,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;
@@ -949,6 +1163,12 @@ var botiumConnectorVoip = {
       label: 'Speech Synthesis Profile',
       type: 'speechsynthesisprofile',
       required: true
+    }, {
+      name: 'VOIP_USER_INPUT_PREFER_VOICE',
+      label: 'Prefer voice media when both text and voice present',
+      type: 'boolean',
+      required: false,
+      advanced: true
     }]
   },
   PluginLogicHooks: {