botium-connector-voip 0.0.18 → 0.0.20

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

@@ -5,6 +5,8 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var ws = require('ws');
 var lodash = require('lodash');
 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');
@@ -14,6 +16,8 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 var ws__default = /*#__PURE__*/_interopDefaultLegacy(ws);
 var lodash__default = /*#__PURE__*/_interopDefaultLegacy(lodash);
 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);
@@ -37,6 +41,9 @@ const Capabilities = {
   VOIP_TTS_BODY: 'VOIP_TTS_BODY',
   VOIP_TTS_HEADERS: 'VOIP_TTS_HEADERS',
   VOIP_TTS_TIMEOUT: 'VOIP_TTS_TIMEOUT',
+  VOIP_TTS_CACHE_ENABLE: 'VOIP_TTS_CACHE_ENABLE',
+  VOIP_TTS_CACHE_SIZE: 'VOIP_TTS_CACHE_SIZE',
+  VOIP_TTS_PREFETCH_ENABLE: 'VOIP_TTS_PREFETCH_ENABLE',
   VOIP_WORKER_URL: 'VOIP_WORKER_URL',
   VOIP_WORKER_APIKEY: 'VOIP_WORKER_APIKEY',
   VOIP_SIP_POOL_CALLER_ENABLE: 'VOIP_SIP_POOL_CALLER_ENABLE',
@@ -70,6 +77,9 @@ const Defaults = {
   VOIP_STT_TIMEOUT: 10000,
   VOIP_TTS_METHOD: 'GET',
   VOIP_TTS_TIMEOUT: 10000,
+  VOIP_TTS_CACHE_ENABLE: true,
+  VOIP_TTS_CACHE_SIZE: 50,
+  VOIP_TTS_PREFETCH_ENABLE: true,
   VOIP_STT_MESSAGE_HANDLING: 'ORIGINAL',
   VOIP_STT_MESSAGE_HANDLING_TIMEOUT: 2500,
   VOIP_STT_MESSAGE_HANDLING_DELIMITER: '. ',
@@ -84,6 +94,12 @@ const Defaults = {
   VOIP_USE_GLOBAL_VOIP_WORKER: false,
   VOIP_SIP_PROTOCOL: 'TCP'
 };
+const TTS_HTTP_AGENT = new http__default["default"].Agent({
+  keepAlive: true
+});
+const TTS_HTTPS_AGENT = new https__default["default"].Agent({
+  keepAlive: true
+});
 class BotiumConnectorVoip {
   constructor({
     queueBotSays,
@@ -97,9 +113,18 @@ class BotiumConnectorVoip {
     this.sentencesBuilding = 0;
     this.sentencesFinal = 0;
     this.sentenceBuilding = false;
+    this.ttsCache = new Map();
+    this.ttsCacheEnabled = false;
+    this.ttsCacheMaxEntries = 0;
+    this.ttsPrefetchEnabled = false;
+
+    // For debugging latency between incoming STT (bot says) and outgoing audio (sendAudio)
+    this._lastBotSaysQueuedAt = null;
+    this._lastBotSaysText = null;
   }
   async Validate() {
     debug$3('Validate called');
+    this.caps = Object.assign({}, Defaults, this.caps);
     debug$3(this.caps.VOIP_STT_MESSAGE_HANDLING);
     if (this.caps.VOIP_TTS_URL) {
       this.axiosTtsParams = {
@@ -107,7 +132,9 @@ class BotiumConnectorVoip {
         params: this._getParams(Capabilities.VOIP_TTS_PARAMS),
         method: this.caps.VOIP_TTS_METHOD,
         timeout: this.caps.VOIP_TTS_TIMEOUT,
-        headers: this._getHeaders(Capabilities.VOIP_TTS_HEADERS)
+        headers: this._getHeaders(Capabilities.VOIP_TTS_HEADERS),
+        httpAgent: TTS_HTTP_AGENT,
+        httpsAgent: TTS_HTTPS_AGENT
       };
       try {
         const {
@@ -125,7 +152,10 @@ class BotiumConnectorVoip {
         throw new Error(`Checking TTS Status failed - ${this._getAxiosErrOutput(err)}`);
       }
     }
-    this.caps = Object.assign({}, Defaults, this.caps);
+    const cacheSize = parseInt(this.caps[Capabilities.VOIP_TTS_CACHE_SIZE], 10);
+    this.ttsCacheEnabled = !!this.caps[Capabilities.VOIP_TTS_CACHE_ENABLE];
+    this.ttsCacheMaxEntries = lodash__default["default"].isFinite(cacheSize) && cacheSize > 0 ? cacheSize : 0;
+    this.ttsPrefetchEnabled = !!this.caps[Capabilities.VOIP_TTS_PREFETCH_ENABLE];
   }
   async Start() {
     debug$3('Start called');
@@ -135,7 +165,14 @@ class BotiumConnectorVoip {
     this.end = false;
     this.connected = false;
     this.convoStep = null;
+    this._lastBotSaysQueuedAt = null;
+    this._lastBotSaysText = null;
+    if (this.ttsCache) {
+      this.ttsCache.clear();
+    }
     const sendBotMsg = botMsg => {
+      this._lastBotSaysQueuedAt = Date.now();
+      this._lastBotSaysText = botMsg && botMsg.messageText ? String(botMsg.messageText) : null;
       setTimeout(() => this.queueBotSays(botMsg), 0);
     };
     const joinBotMsg = (botMsgs, joinLastPrevMsg) => {
@@ -235,6 +272,35 @@ class BotiumConnectorVoip {
         }
         this.eventEmitter.on('CONVO_STEP_NEXT', (container, convoStep) => {
           this.convoStep = convoStep;
+          this._maybePrefetchTts(convoStep);
+          // For PSST: send join silence duration per step to VOIP worker (controls PSST silence trigger)
+          try {
+            if (this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING] === 'PSST' && this.ws && this.ws.readyState === ws__default["default"].OPEN) {
+              const joinLogicHook = this._getJoinLogicHook(convoStep);
+              let silenceMs = null;
+              if (joinLogicHook && joinLogicHook.args && joinLogicHook.args.length > 0) {
+                silenceMs = parseInt(joinLogicHook.args[0], 10);
+              }
+              // Fallback to global timeout if no per-step hook is set
+              if (!lodash__default["default"].isFinite(silenceMs) || silenceMs <= 0) {
+                silenceMs = parseInt(this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING_TIMEOUT], 10);
+              }
+              // PSST: treat like JOIN, but subtract 500ms from timeout
+              if (lodash__default["default"].isFinite(silenceMs) && silenceMs > 0) {
+                silenceMs = Math.max(0, silenceMs - 500);
+              }
+              if (lodash__default["default"].isFinite(silenceMs) && silenceMs > 0 && this.sessionId) {
+                debug$3(`PSST: sending silenceDurationMs=${silenceMs} for sessionId=${this.sessionId}`);
+                this.ws.send(JSON.stringify({
+                  METHOD: 'setSttSilenceDuration',
+                  sessionId: this.sessionId,
+                  silenceDurationMs: silenceMs
+                }));
+              }
+            }
+          } catch (err) {
+            debug$3(`Failed sending PSST silence duration to VOIP worker: ${err.message || err}`);
+          }
         });
         this.silence = null;
         this.msgCount = 0;
@@ -243,6 +309,18 @@ class BotiumConnectorVoip {
         this.silenceTimeout = null;
         this.wsOpened = true;
         debug$3(`Websocket connection to ${wsEndpoint} opened.`);
+        const sttHandling = this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING];
+        const isPsst = sttHandling === 'PSST';
+        const sttLegacy = true;
+        let sttUrl = this.caps[Capabilities.VOIP_STT_URL_STREAM];
+        if (isPsst && lodash__default["default"].isString(sttUrl)) {
+          const replaced = sttUrl.replace('/api/sttstream/', '/api/stt/');
+          if (replaced !== sttUrl) {
+            sttUrl = replaced;
+          } else {
+            debug$3(`PSST: Could not derive /api/stt url from ${sttUrl}, using as-is`);
+          }
+        }
         const request = {
           METHOD: 'initCall',
           SIP_CALLER_AUTO: this.caps[Capabilities.VOIP_SIP_POOL_CALLER_ENABLE],
@@ -263,8 +341,9 @@ class BotiumConnectorVoip {
           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_LEGACY: sttLegacy,
           STT_CONFIG: {
-            stt_url: this.caps[Capabilities.VOIP_STT_URL_STREAM],
+            stt_url: sttUrl,
             stt_params: this.caps[Capabilities.VOIP_STT_PARAMS_STREAM],
             stt_body: this.caps[Capabilities.VOIP_STT_BODY_STREAM] || null
           },
@@ -287,12 +366,16 @@ class BotiumConnectorVoip {
           const parsedData = JSON.parse(data);
           const parsedDataLog = lodash__default["default"].cloneDeep(parsedData);
           parsedDataLog.fullRecord = '<full_record_buffer>';
-
-          // debug(JSON.stringify(parsedDataLog, null, 2))
-
+          debug$3(JSON.stringify(parsedDataLog, null, 2));
           if (parsedData && parsedData.type === 'callinfo' && parsedData.status === 'initialized') {
             this.sessionId = parsedData.voipConfig.sessionId;
           }
+
+          // if sessionId is not the same as the one in the callinfo, return
+          if (parsedData && parsedData.voipConfig && parsedData.voipConfig.sessionId && parsedData.voipConfig.sessionId !== this.sessionId) {
+            debug$3('sessionId mismatch, returning');
+            return;
+          }
           if (parsedData && parsedData.type === 'callinfo' && parsedData.status === 'unauthorized') {
             reject(new Error('Error: Cannot open a call: SIP Authorization failed'));
           }
@@ -350,12 +433,25 @@ class BotiumConnectorVoip {
               if (!lodash__default["default"].isNil(parsedData.data.start)) {
                 const silenceDuration = parsedData.data.start - this.prevData.data.end;
                 const joinLogicHook = this._getJoinLogicHook(this.convoStep);
-                const isJoinMethod = this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING] === 'JOIN';
+                const sttHandling = this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING];
+                const isPsst = sttHandling === 'PSST';
+                const isJoinMethod = sttHandling === 'JOIN' || isPsst;
+                const toJoinTimeoutMs = ms => {
+                  const parsed = parseInt(ms, 10);
+                  if (!lodash__default["default"].isFinite(parsed) || parsed <= 0) return null;
+                  return isPsst ? Math.max(0, parsed - 500) : parsed;
+                };
                 let matched = false;
-                if ((!lodash__default["default"].isNil(joinLogicHook) && isJoinMethod && silenceDuration > parseInt(joinLogicHook.args[0])) / 1000) {
-                  matched = true;
-                } else if (lodash__default["default"].isNil(joinLogicHook) && isJoinMethod && silenceDuration > parseInt(this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING_TIMEOUT]) / 1000) {
-                  matched = true;
+                if (!lodash__default["default"].isNil(joinLogicHook) && isJoinMethod) {
+                  const joinTimeoutMs = toJoinTimeoutMs(joinLogicHook && joinLogicHook.args && joinLogicHook.args[0]);
+                  if (lodash__default["default"].isFinite(joinTimeoutMs) && joinTimeoutMs > 0 && silenceDuration > joinTimeoutMs / 1000) {
+                    matched = true;
+                  }
+                } else if (lodash__default["default"].isNil(joinLogicHook) && isJoinMethod) {
+                  const joinTimeoutMs = toJoinTimeoutMs(this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING_TIMEOUT]);
+                  if (lodash__default["default"].isFinite(joinTimeoutMs) && joinTimeoutMs > 0 && silenceDuration > joinTimeoutMs / 1000) {
+                    matched = true;
+                  }
                 }
                 if (matched && this.botMsgs.length > 0) {
                   sendBotMsg(joinBotMsg(this.botMsgs, this.joinLastPrevMsg));
@@ -370,6 +466,7 @@ class BotiumConnectorVoip {
             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;
             debug$3(`Message: ${parsedData.data.message} / Confidence Score: ${this._getConfidenceScore(parsedData)} (Threshold: ${confidenceThreshold})`);
+            // 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 = {
                 messageText: parsedData.data.message
@@ -425,7 +522,7 @@ class BotiumConnectorVoip {
               }
               this.botMsgs = [];
             }
-            if (this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING] === 'JOIN' || this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING] === 'CONCAT' || !lodash__default["default"].isNil(this._getJoinLogicHook(this.convoStep))) {
+            if (this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING] === 'JOIN' || this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING] === 'PSST' || this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING] === 'CONCAT' || !lodash__default["default"].isNil(this._getJoinLogicHook(this.convoStep))) {
               const botMsg = {
                 messageText: parsedData.data.message,
                 sourceData: parsedData
@@ -433,15 +530,27 @@ class BotiumConnectorVoip {
               this.prevData = parsedData;
               if (successfulConfidenceScore) {
                 this.botMsgs.push(botMsg);
+                const sttHandling = this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING];
+                const isPsst = sttHandling === 'PSST';
+                const toJoinTimeoutMs = ms => {
+                  const parsed = parseInt(ms, 10);
+                  if (!lodash__default["default"].isFinite(parsed) || parsed <= 0) return null;
+                  return isPsst ? Math.max(0, parsed - 500) : parsed;
+                };
+                const joinLogicHook = this._getJoinLogicHook(this.convoStep);
+                let joinTimeoutMs = toJoinTimeoutMs(lodash__default["default"].get(joinLogicHook, 'args[0]'));
+                if (!lodash__default["default"].isFinite(joinTimeoutMs) || joinTimeoutMs <= 0) {
+                  joinTimeoutMs = toJoinTimeoutMs(this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING_TIMEOUT]);
+                }
                 this.silenceTimeout = setTimeout(() => {
                   if (this.botMsgs.length > 0) {
-                    debug$3('Silence Duration Timeout (PSST):', this._getJoinLogicHook(this.convoStep) && parseInt(this._getJoinLogicHook(this.convoStep).args[0]) || this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING_TIMEOUT], 'ms');
+                    debug$3('Silence Duration Timeout (JOIN/PSST):', joinTimeoutMs, 'ms');
                     sendBotMsg(joinBotMsg(this.botMsgs, this.joinLastPrevMsg));
                     this.firstMsg = false;
                     this.joinLastPrevMsg = this.botMsgs[this.botMsgs.length - 1];
                     this.botMsgs = [];
                   }
-                }, this._getJoinLogicHook(this.convoStep) && parseInt(this._getJoinLogicHook(this.convoStep).args[0]) || this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING_TIMEOUT]);
+                }, joinTimeoutMs || 0);
               }
             }
           }
@@ -468,23 +577,32 @@ class BotiumConnectorVoip {
           });
           this.ws.send(request);
         } else if (msg && msg.messageText) {
-          if (!this.axiosTtsParams) reject(new Error('TTS not configured, only audio input supported'));
-          if (this.axiosTtsParams) {
-            const ttsRequest = {
-              ...this.axiosTtsParams,
-              params: {
-                ...(this.axiosTtsParams.params || {}),
-                text: msg.messageText
-              },
-              data: this._getBody(Capabilities.VOIP_TTS_BODY),
-              responseType: 'arraybuffer'
-            };
+          // Check for DTMF tag in messageText: <DTMF>1234</DTMF>
+          const dtmfMatch = msg.messageText.match(/<DTMF>([^<]+)<\/DTMF>/i);
+          if (dtmfMatch && dtmfMatch[1]) {
+            const digits = dtmfMatch[1];
+            debug$3(`Sending DTMF from messageText: ${digits}`);
+            const request = JSON.stringify({
+              METHOD: 'sendDtmf',
+              digits,
+              sessionId: this.sessionId
+            });
+            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 ttsResponse = null;
+            let ttsResult = null;
             try {
-              ttsResponse = await axios__default["default"](ttsRequest);
+              ttsResult = await this._getTtsAudio(ttsRequest, msg.messageText);
             } catch (err) {
-              reject(new Error(`TTS "${msg.messageText}" failed - ${this._getAxiosErrOutput(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));
@@ -495,22 +613,28 @@ class BotiumConnectorVoip {
                 apiKey
               });
             }
-            if (Buffer.isBuffer(ttsResponse.data)) {
-              duration = ttsResponse.headers['content-duration'];
+            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: ttsResponse.data.toString('base64')
+                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: ttsResponse.data.toString('base64')
+                base64: b64Buffer
               });
               this.ws.send(request);
             } else {
-              reject(new Error(`TTS failed, response is: ${this._getAxiosShortenedOutput(ttsResponse.data)}`));
+              return reject(new Error('TTS failed, response is empty'));
             }
           }
         }
@@ -520,6 +644,11 @@ class BotiumConnectorVoip {
             sessionId: this.sessionId,
             b64_buffer: msg.media[0].buffer.toString('base64')
           });
+          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/MEDIA): ${latencyMs} ms (last bot: ${botText})`);
+          }
           this.ws.send(request);
           msg.attachments.push({
             name: msg.media[0].mediaUri,
@@ -571,6 +700,126 @@ class BotiumConnectorVoip {
       this.firstSttInfoReceived = false;
     }
   }
+  _isTtsCacheEnabled() {
+    return this.ttsCacheEnabled && this.ttsCacheMaxEntries > 0;
+  }
+  _touchTtsCache(cacheKey, entry) {
+    if (!this._isTtsCacheEnabled()) return;
+    this.ttsCache.delete(cacheKey);
+    this.ttsCache.set(cacheKey, entry);
+  }
+  _setTtsCacheEntry(cacheKey, entry) {
+    if (!this._isTtsCacheEnabled()) return;
+    this.ttsCache.set(cacheKey, entry);
+    this._trimTtsCache();
+  }
+  _deleteTtsCacheEntry(cacheKey) {
+    if (this.ttsCache) {
+      this.ttsCache.delete(cacheKey);
+    }
+  }
+  _trimTtsCache() {
+    if (!this._isTtsCacheEnabled()) return;
+    while (this.ttsCache.size > this.ttsCacheMaxEntries) {
+      const oldestKey = this.ttsCache.keys().next().value;
+      this.ttsCache.delete(oldestKey);
+    }
+  }
+  _shouldPrefetchTtsText(text) {
+    if (!lodash__default["default"].isString(text)) return false;
+    if (!text.trim()) return false;
+    return !/\$[A-Za-z]\w*/.test(text);
+  }
+  _maybePrefetchTts(convoStep) {
+    if (!this.ttsPrefetchEnabled || !this._isTtsCacheEnabled()) return;
+    if (!convoStep || convoStep.sender !== 'me') return;
+    if (!this._shouldPrefetchTtsText(convoStep.messageText)) return;
+    const ttsRequest = this._buildTtsRequest(convoStep.messageText);
+    if (!ttsRequest) return;
+    this._getTtsAudio(ttsRequest, convoStep.messageText).catch(err => {
+      debug$3(`TTS prefetch failed - ${this._getAxiosErrOutput(err)}`);
+    });
+  }
+  _buildTtsRequest(text) {
+    if (!this.axiosTtsParams) return null;
+    return {
+      ...this.axiosTtsParams,
+      params: {
+        ...(this.axiosTtsParams.params || {}),
+        text
+      },
+      data: this._getBody(Capabilities.VOIP_TTS_BODY),
+      responseType: 'arraybuffer'
+    };
+  }
+  _getTtsCacheKey(ttsRequest) {
+    const cacheKeyObj = {
+      url: ttsRequest.url,
+      method: ttsRequest.method,
+      params: ttsRequest.params,
+      data: ttsRequest.data
+    };
+    try {
+      return JSON.stringify(cacheKeyObj);
+    } catch (err) {
+      return `${ttsRequest.url}|${ttsRequest.method}|${lodash__default["default"].get(ttsRequest, 'params.text', '')}`;
+    }
+  }
+  async _fetchTts(ttsRequest, text) {
+    const ttsStart = Date.now();
+    const ttsResponse = await axios__default["default"](ttsRequest);
+    const ttsMs = Date.now() - ttsStart;
+    const textLen = lodash__default["default"].isString(text) ? text.length : 0;
+    debug$3(`TTS response ${ttsMs} ms (chars: ${textLen})`);
+    if (!ttsResponse || !Buffer.isBuffer(ttsResponse.data)) {
+      throw new Error(`TTS failed, response is: ${this._getAxiosShortenedOutput(ttsResponse && ttsResponse.data)}`);
+    }
+    const durationHeader = ttsResponse.headers && ttsResponse.headers['content-duration'];
+    return {
+      buffer: ttsResponse.data,
+      duration: durationHeader
+    };
+  }
+  async _getTtsAudio(ttsRequest, text) {
+    if (!ttsRequest) throw new Error('TTS request not configured');
+    const cacheKey = this._getTtsCacheKey(ttsRequest);
+    if (this._isTtsCacheEnabled()) {
+      const cached = this.ttsCache.get(cacheKey);
+      if (cached) {
+        if (cached.state === 'ready') {
+          this._touchTtsCache(cacheKey, cached);
+          debug$3(`TTS cache hit (chars: ${lodash__default["default"].isString(text) ? text.length : 0})`);
+          return {
+            buffer: cached.buffer,
+            duration: cached.duration
+          };
+        }
+        if (cached.state === 'pending') {
+          return cached.promise;
+        }
+      }
+    }
+    const fetchPromise = this._fetchTts(ttsRequest, text).then(result => {
+      if (this._isTtsCacheEnabled()) {
+        this._setTtsCacheEntry(cacheKey, {
+          state: 'ready',
+          buffer: result.buffer,
+          duration: result.duration
+        });
+      }
+      return result;
+    }).catch(err => {
+      this._deleteTtsCacheEntry(cacheKey);
+      throw err;
+    });
+    if (this._isTtsCacheEnabled()) {
+      this._setTtsCacheEntry(cacheKey, {
+        state: 'pending',
+        promise: fetchPromise
+      });
+    }
+    return fetchPromise;
+  }
   _getParams(capParams) {
     if (this.caps[capParams]) {
       if (lodash__default["default"].isString(this.caps[capParams])) return JSON.parse(this.caps[capParams]);else return this.caps[capParams];