adding log for issue freshdesk 1600

lib/session/call-session.js

@@ -78,7 +78,7 @@ class CallSession extends Emitter {
     this.callGone = false;
     this.notifiedComplete = false;
     this.rootSpan = rootSpan;
-    this.stickyEventEmitter = new StickyEventEmitter();
+    this.stickyEventEmitter = new StickyEventEmitter(logger);
     this.stickyEventEmitter.onSuccess = () => {
       this.taskInProgress = null;
       this.stickyEventEmitter.destroy();
@@ -950,14 +950,6 @@ class CallSession extends Emitter {
     this.ttsStreamingBuffer?.start();
   }
 
-  stopTtsStream() {
-    if (this.appIsUsingWebsockets) {
-      this.requestor?.request('tts:streaming-event', '/streaming-event', {event_type: 'stream_closed'})
-        .catch((err) => this.logger.info({err}, 'CallSession:clearTtsStream - Error sending user_interruption'));
-      this.ttsStreamingBuffer?.stop();
-    }
-  }
-
   async enableBotMode(gather, autoEnable) {
     try {
       let task;
@@ -981,7 +973,7 @@ class CallSession extends Emitter {
       task.sticky = autoEnable;
       // listen to the bargein-done from background manager
       this.backgroundTaskManager.on('bargeIn-done', () => {
-        if (this.appIsUsingWebsockets) {
+        if (this.requestor instanceof WsRequestor) {
           try {
             this.kill(true);
           } catch (err) {}
@@ -1280,7 +1272,6 @@ class CallSession extends Emitter {
       this.ttsStreamingBuffer.on(TtsStreamingEvents.Pause, this._onTtsStreamingPause.bind(this));
       this.ttsStreamingBuffer.on(TtsStreamingEvents.Resume, this._onTtsStreamingResume.bind(this));
       this.ttsStreamingBuffer.on(TtsStreamingEvents.ConnectFailure, this._onTtsStreamingConnectFailure.bind(this));
-      this.ttsStreamingBuffer.on(TtsStreamingEvents.Connected, this._onTtsStreamingConnected.bind(this));
     }
     else {
       this.logger.info(`CallSession:exec - not a normal call session: ${this.constructor.name}`);
@@ -1339,7 +1330,7 @@ class CallSession extends Emitter {
       }
 
       if (0 === this.tasks.length &&
-        this.appIsUsingWebsockets &&
+        this.requestor instanceof WsRequestor &&
         !this.requestor.closedGracefully &&
         !this.callGone &&
         !this.isConfirmCallSession
@@ -2565,7 +2556,7 @@ Duration=${duration} `
     this.backgroundTaskManager.stopAll();
     this.clearOrRestoreActionHookDelayProcessor().catch((err) => {});
 
-    this.stopTtsStream();
+    this.ttsStreamingBuffer?.stop();
 
     this.sttLatencyCalculator?.stop();
   }
@@ -3025,14 +3016,14 @@ Duration=${duration} `
    */
 
   _notifyTaskError(obj) {
-    if (this.appIsUsingWebsockets) {
+    if (this.requestor instanceof WsRequestor) {
       this.requestor.request('jambonz:error', '/error', obj)
         .catch((err) => this.logger.debug({err}, 'CallSession:_notifyTaskError - Error sending'));
     }
   }
 
   _notifyTaskStatus(task, evt) {
-    if (this.notifyEvents && this.appIsUsingWebsockets) {
+    if (this.notifyEvents && this.requestor instanceof WsRequestor) {
       const obj = {...evt, id: task.id, name: task.name};
       this.requestor.request('verb:status', '/status', obj)
         .catch((err) => this.logger.debug({err}, 'CallSession:_notifyTaskStatus - Error sending'));
@@ -3084,7 +3075,7 @@ Duration=${duration} `
   }
 
   _clearTasks(backgroundGather, evt) {
-    if (this.appIsUsingWebsockets && !backgroundGather.cleared) {
+    if (this.requestor instanceof WsRequestor && !backgroundGather.cleared) {
       this.logger.debug({evt}, 'CallSession:_clearTasks on event from background gather');
       try {
         backgroundGather.cleared = true;
@@ -3112,11 +3103,6 @@ Duration=${duration} `
     }
   }
 
-  _onTtsStreamingConnected() {
-    this.requestor?.request('tts:streaming-event', '/streaming-event', {event_type: 'stream_open'})
-      .catch((err) => this.logger.info({err}, 'CallSession:_onTtsStreamingConnected - Error sending'));
-  }
-
   _onTtsStreamingEmpty() {
     const task = this.currentTask;
     if (task && TaskName.Say === task.name) {

lib/tasks/dial.js

@@ -21,7 +21,7 @@ const {parseUri} = require('drachtio-srf');
 const {ANCHOR_MEDIA_ALWAYS,
   JAMBONZ_DIAL_PAI_HEADER,
   JAMBONES_DIAL_SBC_FOR_REGISTERED_USER} = require('../config');
-const { isOnhold, isOpusFirst, getLeadingCodec } = require('../utils/sdp-utils');
+const { isOnhold, isOpusFirst } = require('../utils/sdp-utils');
 const { normalizeJambones } = require('@jambonz/verb-specifications');
 const { selectHostPort } = require('../utils/network');
 const { sleepFor } = require('../utils/helpers');
@@ -158,7 +158,6 @@ class TaskDial extends Task {
 
   get canReleaseMedia() {
     const keepAnchor = this.data.anchorMedia ||
-      this.weAreTranscoding ||
       this.cs.isBackGroundListen ||
       this.cs.onHoldMusic ||
       ANCHOR_MEDIA_ALWAYS ||
@@ -930,13 +929,7 @@ class TaskDial extends Task {
         this.logger.info({err}, 'Dial:_selectSingleDial - Error boosting audio signal');
       }
     }
-    /* basic determination to see if call is being transcoded */
-    const codecA = getLeadingCodec(this.epOther.local.sdp);
-    const codecB = getLeadingCodec(this.ep.remote.sdp);
-    this.weAreTranscoding = (codecA !== codecB);
-    if (this.weAreTranscoding) {
-      this.logger.info(`Dial:_selectSingleDial - transcoding from ${codecA} (A leg) to ${codecB} (B leg)`);
-    }
+
     /* if we can release the media back to the SBC, do so now */
     if (this.canReleaseMedia || this.shouldExitMediaPathEntirely) {
       setTimeout(this._releaseMedia.bind(this, cs, sd, this.shouldExitMediaPathEntirely), 200);

lib/tasks/gather.js

@@ -258,7 +258,7 @@ class TaskGather extends SttTask {
             startDtmfListener();
           }
           this._stopVad();
-          if (!this.killed && !this.resolved) {
+          if (!this.killed) {
             startListening(cs, ep);
             if (this.input.includes('speech') && this.vendor === 'nuance' && this.listenDuringPrompt) {
               this.logger.debug('Gather:exec - starting transcription timers after say completes');
@@ -296,7 +296,7 @@ class TaskGather extends SttTask {
             startDtmfListener();
           }
           this._stopVad();
-          if (!this.killed && !this.resolved) {
+          if (!this.killed) {
             startListening(cs, ep);
             if (this.input.includes('speech') && this.vendor === 'nuance' && this.listenDuringPrompt) {
               this.logger.debug('Gather:exec - starting transcription timers after play completes');
@@ -1161,7 +1161,7 @@ class TaskGather extends SttTask {
   }
 
   async _startFallback(cs, ep, evt) {
-    if (this.canFallback()) {
+    if (this.canFallback) {
       this._stopTranscribing(ep);
       try {
         this.logger.debug('gather:_startFallback');

lib/tasks/play.js

@@ -67,6 +67,9 @@ class TaskPlay extends Task {
               this.logger.debug(`Play got kill-playback, executing uuid_break, taskId: ${t?.taskId}`);
               this.ep.api('uuid_break', this.ep.uuid).catch((err) => this.logger.info(err, 'Error killing audio'));
               this.notifyStatus({event: 'kill-playback'});
+            } else {
+              this.logger.debug(
+                `Play received uuid_break for different taskId: ${t?.taskId}, current taskId: ${this.taskId}`);
             }
           });
         });

lib/tasks/say.js

@@ -2,9 +2,8 @@ const assert = require('assert');
 const TtsTask = require('./tts-task');
 const {TaskName, TaskPreconditions} = require('../utils/constants');
 const pollySSMLSplit = require('polly-ssml-split');
-const { SpeechCredentialError, NonFatalTaskError } = require('../utils/error');
+const { SpeechCredentialError } = require('../utils/error');
 const { sleepFor } = require('../utils/helpers');
-const { NON_FANTAL_ERRORS } = require('../utils/constants.json');
 
 /**
  * Discard unmatching responses:
@@ -146,6 +145,9 @@ class TaskSay extends TtsTask {
 
       await cs.startTtsStream();
 
+      cs.requestor?.request('tts:streaming-event', '/streaming-event', {event_type: 'stream_open'})
+        .catch((err) => this.logger.info({err}, 'TaskSay:handlingStreaming - Error sending'));
+
       if (this.text.length !== 0) {
         this.logger.info('TaskSay:handlingStreaming - sending text to TTS stream');
         for (const t of this.text) {
@@ -403,19 +405,11 @@ class TaskSay extends TtsTask {
             this._playResolve = resolve;
             this._playReject = reject;
           });
-          try {
-            const r = await ep.play(filename);
-            this.logger.debug({r}, 'Say:exec play result');
-            if (r.playbackSeconds == null && r.playbackMilliseconds == null && r.playbackLastOffsetPos == null) {
-              this._playReject(new Error('Playback failed to start'));
-            }
-          } catch (err) {
-            if (NON_FANTAL_ERRORS.includes(err.message)) {
-              throw new NonFatalTaskError(err.message);
-            }
-            throw err;
+          const r = await ep.play(filename);
+          this.logger.debug({r}, 'Say:exec play result');
+          if (r.playbackSeconds == null && r.playbackMilliseconds == null && r.playbackLastOffsetPos == null) {
+            this._playReject(new Error('Playback failed to start'));
           }
-
           try {
             // wait for playback-stop event received to confirm if the playback is successful
             await this._playPromise;
@@ -453,8 +447,8 @@ class TaskSay extends TtsTask {
         const {memberId, confName} = cs;
         this.killPlayToConfMember(this.ep, memberId, confName);
       } else if (this.isStreamingTts) {
-        this.logger.debug('TaskSay:kill - stopping TTS stream for streaming audio');
-        cs.stopTtsStream();
+        this.logger.debug('TaskSay:kill - clearing TTS stream for streaming audio');
+        cs.clearTtsStream();
       } else {
         if (!this.notifiedPlayBackStop) {
           this.notifyStatus({event: 'stop-playback'});

lib/tasks/stt-task.js

@@ -171,7 +171,7 @@ class SttTask extends Task {
       try {
         this.sttCredentials = await this._initSpeechCredentials(this.cs, this.vendor, this.label);
       } catch (error) {
-        if (this.canFallback()) {
+        if (this.canFallback) {
           this.notifyError(
             {
               msg: 'ASR error', details:`Invalid vendor ${this.vendor}, Error: ${error}`,
@@ -260,19 +260,8 @@ class SttTask extends Task {
     ep.addCustomEventListener(event, handler);
   }
 
-  removeCustomEventListeners(ep) {
-    if (ep) {
-      // for specific endpoint
-      this.eventHandlers.filter((h) => h.ep === ep).forEach((h) => {
-        h.ep.removeCustomEventListener(h.event, h.handler);
-      });
-      this.eventHandlers = this.eventHandlers.filter((h) => h.ep !== ep);
-      return;
-    } else {
-      // for all endpoints
-      this.eventHandlers.forEach((h) => h.ep.removeCustomEventListener(h.event, h.handler));
-      this.eventHandlers = [];
-    }
+  removeCustomEventListeners() {
+    this.eventHandlers.forEach((h) => h.ep.removeCustomEventListener(h.event, h.handler));
   }
 
   async _initSpeechCredentials(cs, vendor, label) {
@@ -340,13 +329,11 @@ class SttTask extends Task {
     return credentials;
   }
 
-  canFallback() {
+  get canFallback() {
     return this.fallbackVendor && this.isHandledByPrimaryProvider && !this.cs.hasFallbackAsr;
   }
 
-  // ep is optional for gather or any verb that have single ep,
-  // but transcribe does need as it might has 2 eps
-  async _initFallback(ep) {
+  async _initFallback() {
     assert(this.fallbackVendor, 'fallback failed without fallbackVendor configuration');
     this.logger.info(`Failed to use primary STT provider, fallback to ${this.fallbackVendor}`);
     this.isHandledByPrimaryProvider = false;
@@ -359,7 +346,7 @@ class SttTask extends Task {
     this.data.recognizer.label = this.label;
     this.sttCredentials = await this._initSpeechCredentials(this.cs, this.vendor, this.label);
     // cleanup previous listener from previous vendor
-    this.removeCustomEventListeners(ep);
+    this.removeCustomEventListeners();
   }
 
   async compileHintsForCobalt(ep, hostport, model, token, hints) {

lib/tasks/transcribe.js

@@ -70,9 +70,6 @@ class TaskTranscribe extends SttTask {
     this._bufferedTranscripts = [ [], [] ];  // for channel 1 and 2
     this.bugname_prefix = 'transcribe_';
     this.paused = false;
-    // fallback flags
-    this.isHandledByPrimaryProviderForEp1 = true;
-    this.isHandledByPrimaryProviderForEp2 = true;
   }
 
   get name() { return TaskName.Transcribe; }
@@ -779,7 +776,7 @@ class TaskTranscribe extends SttTask {
   }
 
   async _startFallback(cs, _ep, evt) {
-    if (this.canFallback(_ep)) {
+    if (this.canFallback) {
       _ep.stopTranscription({
         vendor: this.vendor,
         bugname: this.bugname,
@@ -789,7 +786,7 @@ class TaskTranscribe extends SttTask {
       try {
         this.notifyError({ msg: 'ASR error',
           details:`STT Vendor ${this.vendor} error: ${evt.error || evt.reason}`, failover: 'in progress'});
-        await this._initFallback(_ep);
+        await this._initFallback();
         let channel = 1;
         if (this.ep !== _ep) {
           channel = 2;
@@ -898,41 +895,6 @@ class TaskTranscribe extends SttTask {
     if (this._asrTimer) clearTimeout(this._asrTimer);
     this._asrTimer = null;
   }
-
-  // We need to keep track the fallback is happened for each endpoint
-  // override the canFallback and _initFallback methods to make sure that
-  // we only fallback once per endpoint
-  // we want to keep track this on task level instead of endpoint level
-  // because the endpoint instance is used across multiple tasks.
-  canFallback(ep) {
-    let isHandledByPrimaryProvider = this.isHandledByPrimaryProvider;
-    if (ep === this.ep) {
-      isHandledByPrimaryProvider = this.isHandledByPrimaryProviderForEp1;
-    } else if (ep === this.ep2) {
-      isHandledByPrimaryProvider = this.isHandledByPrimaryProviderForEp2;
-    }
-
-    const isOneOfEndpointAlreadyFallenBack = !!this.ep && !!this.ep2 &&
-      this.isHandledByPrimaryProviderForEp1 !== this.isHandledByPrimaryProviderForEp2;
-
-    // fallback is configured
-    return this.fallbackVendor &&
-      // has this endpoint already fallen back
-      isHandledByPrimaryProvider &&
-      // in global level, is there any fallback is already happened
-      // one fallen endpoint will mark cs.hasFallbackAsr to true,
-      // so if one endpoint was fallen, the other endpoint would be able to fallback.
-      (isOneOfEndpointAlreadyFallenBack || !this.cs.hasFallbackAsr);
-  }
-
-  _initFallback(ep) {
-    if (ep === this.ep) {
-      this.isHandledByPrimaryProviderForEp1 = false;
-    } else if (ep === this.ep2) {
-      this.isHandledByPrimaryProviderForEp2 = false;
-    }
-    return super._initFallback(ep);
-  }
 }
 
 module.exports = TaskTranscribe;

lib/tasks/tts-task.js

@@ -85,66 +85,55 @@ class TtsTask extends Task {
   }
 
   async setTtsStreamingChannelVars(vendor, language, voice, credentials, ep) {
-    const {api_key, model_id, api_uri, custom_tts_streaming_url, auth_token, options} = credentials;
-    // api_key, model_id, api_uri, custom_tts_streaming_url, and auth_token are encoded in the credentials
-    // allow them to be overriden via config, using options
-    // give preference to options passed in via config
-    const local_options = {...JSON.parse(options), ...this.options};
-    const local_voice_settings = {...JSON.parse(options).voice_settings, ...this.options.voice_settings};
-    const local_api_key =  local_options.api_key ?? api_key;
-    const local_model_id = local_options.model_id ?? model_id;
-    const local_api_uri = local_options.api_uri ?? api_uri;
-    const local_custom_tts_streaming_url = local_options.custom_tts_streaming_url ?? custom_tts_streaming_url;
-    const local_auth_token = local_options.auth_token ?? auth_token;
-
-
+    const {api_key, model_id, api_uri, custom_tts_streaming_url, auth_token} = credentials;
     let obj;
 
+    this.logger.debug(`setTtsStreamingChannelVars: vendor: ${vendor}, language: ${language}, voice: ${voice}`);
+
     switch (vendor) {
       case 'deepgram':
         obj = {
-          DEEPGRAM_API_KEY: local_api_key,
+          DEEPGRAM_API_KEY: api_key,
           DEEPGRAM_TTS_STREAMING_MODEL: voice
         };
         break;
       case 'cartesia':
         obj = {
-          CARTESIA_API_KEY: local_api_key,
-          CARTESIA_TTS_STREAMING_MODEL_ID: local_model_id,
+          CARTESIA_API_KEY: api_key,
+          CARTESIA_TTS_STREAMING_MODEL_ID: model_id,
           CARTESIA_TTS_STREAMING_VOICE_ID: voice,
           CARTESIA_TTS_STREAMING_LANGUAGE: language || 'en',
         };
         break;
       case 'elevenlabs':
-        // eslint-disable-next-line max-len
-        const {stability, similarity_boost, use_speaker_boost, style, speed} = local_voice_settings || {};
+        const {stability, similarity_boost, use_speaker_boost, style, speed} = this.options.voice_settings || {};
         obj = {
-          ELEVENLABS_API_KEY: local_api_key,
-          ...(api_uri && {ELEVENLABS_API_URI: local_api_uri}),
-          ELEVENLABS_TTS_STREAMING_MODEL_ID: local_model_id,
+          ELEVENLABS_API_KEY: api_key,
+          ...(api_uri && {ELEVENLABS_API_URI: api_uri}),
+          ELEVENLABS_TTS_STREAMING_MODEL_ID: model_id,
           ELEVENLABS_TTS_STREAMING_VOICE_ID: voice,
           // 20/12/2024 - only eleven_turbo_v2_5 support multiple language
-          ...(['eleven_turbo_v2_5'].includes(local_model_id) && {ELEVENLABS_TTS_STREAMING_LANGUAGE: language}),
+          ...(['eleven_turbo_v2_5'].includes(model_id) && {ELEVENLABS_TTS_STREAMING_LANGUAGE: language}),
           ...(stability && {ELEVENLABS_TTS_STREAMING_VOICE_SETTINGS_STABILITY: stability}),
           ...(similarity_boost && {ELEVENLABS_TTS_STREAMING_VOICE_SETTINGS_SIMILARITY_BOOST: similarity_boost}),
           ...(use_speaker_boost && {ELEVENLABS_TTS_STREAMING_VOICE_SETTINGS_USE_SPEAKER_BOOST: use_speaker_boost}),
           ...(style && {ELEVENLABS_TTS_STREAMING_VOICE_SETTINGS_STYLE: style}),
           // speed has value 0.7 to 1.2, 1.0 is default, make sure we send the value event it's 0
           ...(speed !== null && speed !== undefined && {ELEVENLABS_TTS_STREAMING_VOICE_SETTINGS_SPEED: `${speed}`}),
-          ...(local_options.pronunciation_dictionary_locators &&
-            Array.isArray(local_options.pronunciation_dictionary_locators) && {
+          ...(this.options.pronunciation_dictionary_locators &&
+            Array.isArray(this.options.pronunciation_dictionary_locators) && {
             ELEVENLABS_TTS_STREAMING_PRONUNCIATION_DICTIONARY_LOCATORS:
-            JSON.stringify(local_options.pronunciation_dictionary_locators)
+            JSON.stringify(this.options.pronunciation_dictionary_locators)
           }),
         };
         break;
       case 'rimelabs':
         const {
           pauseBetweenBrackets, phonemizeBetweenBrackets, inlineSpeedAlpha, speedAlpha, reduceLatency
-        } = local_options;
+        } = this.options;
         obj = {
-          RIMELABS_API_KEY: local_api_key,
-          RIMELABS_TTS_STREAMING_MODEL_ID: local_model_id,
+          RIMELABS_API_KEY: api_key,
+          RIMELABS_TTS_STREAMING_MODEL_ID: model_id,
           RIMELABS_TTS_STREAMING_VOICE_ID: voice,
           RIMELABS_TTS_STREAMING_LANGUAGE: language || 'en',
           ...(pauseBetweenBrackets && {RIMELABS_TTS_STREAMING_PAUSE_BETWEEN_BRACKETS: pauseBetweenBrackets}),
@@ -159,8 +148,8 @@ class TtsTask extends Task {
         if (vendor.startsWith('custom:')) {
           const use_tls = custom_tts_streaming_url.startsWith('wss://');
           obj = {
-            CUSTOM_TTS_STREAMING_HOST: local_custom_tts_streaming_url.replace(/^(ws|wss):\/\//, ''),
-            CUSTOM_TTS_STREAMING_API_KEY: local_auth_token,
+            CUSTOM_TTS_STREAMING_HOST: custom_tts_streaming_url.replace(/^(ws|wss):\/\//, ''),
+            CUSTOM_TTS_STREAMING_API_KEY: auth_token,
             CUSTOM_TTS_STREAMING_VOICE_ID: voice,
             CUSTOM_TTS_STREAMING_LANGUAGE: language || 'en',
             CUSTOM_TTS_STREAMING_USE_TLS: use_tls
@@ -279,9 +268,9 @@ class TtsTask extends Task {
       }
 
       /* produce an audio segment from the provided text */
-      const generateAudio = async(text, index) => {
-        if (this.killed) return {index, filePath: null};
-        if (text.startsWith('silence_stream://')) return {index, filePath: text};
+      const generateAudio = async(text) => {
+        if (this.killed) return;
+        if (text.startsWith('silence_stream://')) return text;
 
         /* otel: trace time for tts */
         if (!preCache && !this._disableTracing)  {
@@ -310,6 +299,7 @@ class TtsTask extends Task {
             renderForCaching: preCache
           });
           if (!filePath.startsWith('say:')) {
+            this.playbackIds.push(null);
             this.logger.debug(`Say: file ${filePath}, served from cache ${servedFromCache}`);
             if (filePath) cs.trackTmpFile(filePath);
             if (this.otelSpan) {
@@ -337,11 +327,10 @@ class TtsTask extends Task {
                 'id': this.id
               });
             }
-            return {index, filePath, playbackId: null};
           }
           else {
-            const playbackId = extractPlaybackId(filePath);
-            this.logger.debug('Say: a streaming tts api will be used');
+            this.playbackIds.push(extractPlaybackId(filePath));
+            this.logger.debug({playbackIds: this.playbackIds}, 'Say: a streaming tts api will be used');
             const modifiedPath = filePath.replace('say:{', `say:{session-uuid=${ep.uuid},`);
             this.notifyStatus({
               event: 'synthesized-audio',
@@ -350,8 +339,9 @@ class TtsTask extends Task {
               servedFromCache,
               'id': this.id
             });
-            return {index, filePath: modifiedPath, playbackId};
+            return modifiedPath;
           }
+          return filePath;
         } catch (err) {
           this.logger.info({err}, 'Error synthesizing tts');
           if (this.otelSpan) this.otelSpan.end();
@@ -366,20 +356,8 @@ class TtsTask extends Task {
         }
       };
 
-      // process all text segments in parallel will cause ordering issue
-      // so we attach index to each promise result and sort them later
-
-      const arr = this.text.map((t, index) => (this._validateURL(t) ?
-        Promise.resolve({index, filePath: t, playbackId: null}) : generateAudio(t, index)));
-      const results = await Promise.all(arr);
-      const sorted = results.sort((a, b) => a.index - b.index);
-
-      return sorted
-        .filter((fp) => fp.filePath && fp.filePath.length)
-        .map((r) => {
-          this.playbackIds.push(r.playbackId);
-          return r.filePath;
-        });
+      const arr = this.text.map((t) => (this._validateURL(t) ? t : generateAudio(t)));
+      return (await Promise.all(arr)).filter((fp) => fp && fp.length);
     } catch (err) {
       this.logger.info(err, 'TaskSay:exec error');
       throw err;

lib/utils/constants.json

@@ -335,8 +335,7 @@
     "Empty": "tts_streaming::empty",
     "Pause": "tts_streaming::pause",
     "Resume": "tts_streaming::resume",
-    "ConnectFailure": "tts_streaming::connect_failed",
-    "Connected": "tts_streaming::connected"
+    "ConnectFailure": "tts_streaming::connect_failed"
   },
   "TtsStreamingConnectionStatus": {
     "NotConnected": "not_connected",
@@ -356,8 +355,5 @@
   "WS_CLOSE_CODES": {
     "NormalClosure": 1000,
     "GoingAway": 1001
-  },
-  "NON_FANTAL_ERRORS": [
-    "File Not Found"
-  ]
+  }
 }

lib/utils/sdp-utils.js

@@ -55,28 +55,11 @@ const extractSdpMedia = (sdp) => {
   }
 };
 
-const getLeadingCodec = (sdp) => {
-  if (!sdp) {
-    return null;
-  }
-
-  const parsed = sdpTransform.parse(sdp);
-  const audio = parsed.media?.find((m) => m.type === 'audio');
-
-  if (!audio) {
-    return null;
-  }
-
-  return audio.rtp?.[0]?.codec || null;
-};
-
-
 module.exports = {
   isOnhold,
   mergeSdpMedia,
   extractSdpMedia,
   isOpusFirst,
   makeOpusFirst,
-  removeVideoSdp,
-  getLeadingCodec
+  removeVideoSdp
 };

lib/utils/sticky-event-emitter.js

@@ -13,10 +13,11 @@ const EventEmitter = require('events');
  * - Maintains compatibility with Node's EventEmitter interface
  */
 class StickyEventEmitter extends EventEmitter {
-  constructor() {
+  constructor(logger) {
     super();
     this._eventCache = new Map();
     this._onceListeners = new Map(); // For storing once listeners if needed
+    this.logger = logger;
   }
   destroy() {
     this._eventCache.clear();
@@ -28,12 +29,14 @@ class StickyEventEmitter extends EventEmitter {
     this._eventCache.set(event, args);
 
     // If there are any 'once' listeners waiting, call them
+    this.logger.debug(`StickyEventEmitter emitting event: ${event} with args: ${JSON.stringify(args)}`);
     if (this._onceListeners.has(event)) {
       const listeners = this._onceListeners.get(event);
       for (const listener of listeners) {
         listener(...args);
       }
       if (this.onSuccess) {
+        this.logger.debug(`StickyEventEmitter calling onSuccess for event: ${event}`);
         this.onSuccess();
       }
       this._onceListeners.delete(event);

lib/utils/tts-streaming-buffer.js

@@ -80,7 +80,7 @@ class TtsStreamingBuffer extends Emitter {
     clearTimeout(this.timer);
     this.removeCustomEventListeners();
     if (this.ep) {
-      this._api(this.ep, [this.ep.uuid, 'stop'])
+      this._api(this.ep, [this.ep.uuid, 'close'])
         .catch((err) =>
           this.logger.info({ err }, 'TtsStreamingBuffer:stop Error closing TTS streaming')
         );
@@ -362,7 +362,6 @@ class TtsStreamingBuffer extends Emitter {
     if (this.queue.length > 0) {
       await this._feedQueue();
     }
-    this.emit(TtsStreamingEvents.Connected, { vendor });
   }
 
   _onConnectFailure(vendor) {
@@ -413,7 +412,6 @@ class TtsStreamingBuffer extends Emitter {
 
   removeCustomEventListeners() {
     this.eventHandlers.forEach((h) => h.ep.removeCustomEventListener(h.event, h.handler));
-    this.eventHandlers.length = 0;
   }
 
   _initHandlers(ep) {

package-lock.json

@@ -6183,10 +6183,9 @@
       "license": "MIT"
     },
     "node_modules/js-yaml": {
-      "version": "3.14.2",
-      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.2.tgz",
-      "integrity": "sha512-PMSmkqxr106Xa156c2M265Z+FTrPl+oxd/rgOQy2tijQeK5TxQ43psO1ZCwhVOSdnn+RzkzlRz/eY4BgJBYVpg==",
+      "version": "3.14.1",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
         "argparse": "^1.0.7",
         "esprima": "^4.0.0"

test/webhooks-tests.js

@@ -83,8 +83,7 @@ test('invalid jambonz json create alert tests', async(t) => {
       {account_sid: 'bb845d4b-83a9-4cde-a6e9-50f3743bab3f', page: 1, page_size: 25, days: 7});
     let checked = false;
     for (let i = 0; i < data.total; i++) {
-      checked = data.data[i].message === 'malformed jambonz payload: must be array';
-      if (checked) break;
+      checked = data.data[i].message === 'malformed jambonz payload: must be array'
     }
     t.ok(checked, 'alert is raised as expected');
     disconnect();