add support for getting partial transcripts when doing background gather

* kill play task if bot responds verbs while actionHook delay is enabled (#712)

* kill play task if bot responds verbs while actionHook delay is enabled

* fix actionHook delay continues even the bot already responded verbs

* wip

* wip

* wip

* gather is hang if listenDuringPrompt = false and say/play task throw exception (#717)

* merge fix for Support ASR TTS fallback (#713)

---------

Co-authored-by: Hoan Luu Huu <110280845+xquanluu@users.noreply.github.com>

lib/session/call-session.js

@@ -193,6 +193,24 @@ class CallSession extends Emitter {
     this._synthesizer = synth;
   }
 
+  /**
+   * ASR TTS fallback
+   */
+  get hasFallbackAsr() {
+    return this._hasFallbackAsr || false;
+  }
+
+  set hasFallbackAsr(i) {
+    this._hasFallbackAsr = i;
+  }
+
+  get hasFallbackTts() {
+    return this._hasFallbackTts || false;
+  }
+
+  set hasFallbackTts(i) {
+    this._hasFallbackTts = i;
+  }
   /**
    * default vendor to use for speech synthesis if not provided in the app
    */
@@ -1598,7 +1616,23 @@ Duration=${duration} `
   }
 
   _preCacheAudio(newTasks) {
-    for (const task of newTasks) {
+    /**
+     * only precache audio for the a queued say if we have one or more non-Config verbs
+     * ahead of it in the queue.  This is because the Config verb returns immediately
+     * and would not give us enough time to generate the audio.  The point of precaching
+     * is to take advantage of getting the audio in advance of being needed, so we need
+     * to be confident we have some time before the say verb is executed, and the Config
+     * does not give us that confidence since it returns immediately.
+     */
+    const haveQueuedNonConfig = this.tasks.findIndex((t) => t.name !== TaskName.Config) !== -1;
+    let tasks = haveQueuedNonConfig ? newTasks : [];
+    if (!haveQueuedNonConfig) {
+      const idxFirstNotConfig = newTasks.findIndex((t) => t.name !== TaskName.Config);
+      if (-1 === idxFirstNotConfig) return;
+      tasks = newTasks.slice(idxFirstNotConfig + 1);
+    }
+
+    for (const task of tasks) {
       if (task.name === TaskName.Config && task.hasSynthesizer) {
         /* if they change synthesizer settings don't try to precache */
         break;
@@ -1964,6 +1998,7 @@ Duration=${duration} `
   /**
    * called when the caller has hung up.  Provided for subclasses to override
    * in order to apply logic at this point if needed.
+   * return true if success fallback, return false if not
    */
   _callerHungup() {
     assert(false, 'subclass responsibility to override this method');
@@ -2405,6 +2440,7 @@ Duration=${duration} `
 
   _startActionHookNoResponseTimer(options) {
     this._clearActionHookNoResponseTimer();
+    this._actionHookDelayResolved = false;
     if (options.noResponseTimeoutMs) {
       this.logger.debug(`CallSession:_startActionHookNoResponseTimer ${options.noResponseTimeoutMs}`);
       this._actionHookNoResponseTimer = setTimeout(() => {
@@ -2418,7 +2454,9 @@ Duration=${duration} `
         if (t.length) {
           t[0].on('playDone', (err) => {
             if (err) this.logger.error({err}, `Call-Session:exec Error delay action, play ${verb}`);
-            this._startActionHookNoResponseTimer(options);
+            if (!this._actionHookDelayResolved) {
+              this._startActionHookNoResponseTimer(options);
+            }
           });
         }
         this.tasks.push(...t);
@@ -2436,7 +2474,16 @@ Duration=${duration} `
 
   _clearActionHookNoResponseTimer() {
     if (this._actionHookNoResponseTimer) {
+      // Action Hook delay is solved.
+      this._actionHookDelayResolved = true;
       clearTimeout(this._actionHookNoResponseTimer);
+      // if delay action is enabled
+      // and bot has responded with list of new verbs
+      // Only kill current running play task.
+      //https://github.com/jambonz/jambonz-feature-server/issues/710
+      if (this.currentTask?.name === TaskName.Play) {
+        this.currentTask.kill(this);
+      }
     }
     this._actionHookNoResponseTimer = null;
   }

lib/tasks/config.js

@@ -30,7 +30,7 @@ class TaskConfig extends Task {
         input: ['speech']
       };
       [
-        'finishOnKey', 'input', 'numDigits', 'minDigits', 'maxDigits',
+        'finishOnKey', 'input', 'numDigits', 'minDigits', 'maxDigits', 'partialResultHook',
         'interDigitTimeout', 'bargein', 'dtmfBargein', 'minBargeinWordCount', 'actionHook'
       ].forEach((k) => {
         if (this.bargeIn[k]) this.gatherOpts[k] = this.bargeIn[k];
@@ -259,8 +259,7 @@ class TaskConfig extends Task {
         cs.stopBackgroundTask('transcribe');
       }
     }
-
-    if (this.actionHookDelayAction) {
+    if (Object.keys(this.actionHookDelayAction).length !== 0) {
       cs.actionHookDelayEnabled = this.actionHookDelayAction.enabled || false;
       cs.actionHookNoResponseTimeout = this.actionHookDelayAction.noResponseTimeout || 0;
       cs.actionHookNoResponseGiveUpTimeout = this.actionHookDelayAction.noResponseGiveUpTimeout || 0;

lib/tasks/gather.js

@@ -191,12 +191,7 @@ class TaskGather extends SttTask {
           this._startTranscribing(ep);
           return updateSpeechCredentialLastUsed(this.sttCredentials.speech_credential_sid);
         } catch (e) {
-          if (this.fallbackVendor && this.isHandledByPrimaryProvider) {
-            await this._fallback();
-            startListening(cs, ep);
-          } else {
-            this.logger.error({error: e}, 'error in initSpeech');
-          }
+          await this._startFallback(cs, ep, {error: e});
         }
       }
     };
@@ -204,12 +199,7 @@ class TaskGather extends SttTask {
     try {
       if (this.sayTask) {
         const {span, ctx} = this.startChildSpan(`nested:${this.sayTask.summary}`);
-        this.sayTask.span = span;
-        this.sayTask.ctx = ctx;
-        this.sayTask.exec(cs, {ep});  // kicked off, _not_ waiting for it to complete
-        this.sayTask.on('playDone', (err) => {
-          span.end();
-          if (err) this.logger.error({err}, 'Gather:exec Error playing tts');
+        const process = () => {
           this.logger.debug('Gather: nested say task completed');
           if (!this.killed) {
             startListening(cs, ep);
@@ -220,16 +210,22 @@ class TaskGather extends SttTask {
               });
             }
           }
+        };
+        this.sayTask.span = span;
+        this.sayTask.ctx = ctx;
+        this.sayTask.exec(cs, {ep})  // kicked off, _not_ waiting for it to complete
+          .catch((err) => {
+            process();
+          });
+        this.sayTask.on('playDone', (err) => {
+          span.end();
+          if (err) this.logger.error({err}, 'Gather:exec Error playing tts');
+          process();
         });
       }
       else if (this.playTask) {
         const {span, ctx} = this.startChildSpan(`nested:${this.playTask.summary}`);
-        this.playTask.span = span;
-        this.playTask.ctx = ctx;
-        this.playTask.exec(cs, {ep});  // kicked off, _not_ waiting for it to complete
-        this.playTask.on('playDone', (err) => {
-          span.end();
-          if (err) this.logger.error({err}, 'Gather:exec Error playing url');
+        const process = () => {
           this.logger.debug('Gather: nested play task completed');
           if (!this.killed) {
             startListening(cs, ep);
@@ -240,6 +236,17 @@ class TaskGather extends SttTask {
               });
             }
           }
+        };
+        this.playTask.span = span;
+        this.playTask.ctx = ctx;
+        this.playTask.exec(cs, {ep})  // kicked off, _not_ waiting for it to complete
+          .catch((err) => {
+            process();
+          });
+        this.playTask.on('playDone', (err) => {
+          span.end();
+          if (err) this.logger.error({err}, 'Gather:exec Error playing url');
+          process();
         });
       }
       else {
@@ -344,7 +351,8 @@ class TaskGather extends SttTask {
     /* some special deepgram logic */
     if (this.vendor === 'deepgram') {
       if (this.isContinuousAsr) this._doContinuousAsrWithDeepgram(this.asrTimeout);
-      if (this.data.recognizer?.deepgramOptions?.shortUtterance) this.shortUtterance = true;
+      if (this.data.recognizer?.deepgramOptions?.shortUtterance ||
+        this.data.recognizer?.deepgramOptions?.endpointing === false) this.shortUtterance = true;
     }
 
     const opts = this.setChannelVarsForStt(this, this.sttCredentials, this.language, this.data.recognizer);
@@ -932,9 +940,9 @@ class TaskGather extends SttTask {
   _onTranscriptionComplete(cs, ep) {
     this.logger.debug('TaskGather:_onTranscriptionComplete');
   }
-  async _onJambonzError(cs, ep, evt) {
-    this.logger.info({evt}, 'TaskGather:_onJambonzError');
-    if (this.isHandledByPrimaryProvider && this.fallbackVendor) {
+
+  async _startFallback(cs, ep, evt) {
+    if (this.canFallback) {
       ep.stopTranscription({
         vendor: this.vendor,
         bugname: this.bugname
@@ -942,17 +950,35 @@ class TaskGather extends SttTask {
         .catch((err) => this.logger.error({err}, `Error stopping transcription for primary vendor ${this.vendor}`));
       const {updateSpeechCredentialLastUsed} = require('../utils/db-utils')(this.logger, cs.srf);
       try {
-        await this._fallback();
-        await this._initSpeech(cs, ep);
+        this.logger.debug('gather:_startFallback');
+        this.notifyError({ msg: 'ASR error',
+          details:`STT Vendor ${this.vendor} error: ${evt.error || evt.reason}`, failover: 'in progress'});
+        await this._initFallback();
+        this._speechHandlersSet = false;
+        await this._setSpeechHandlers(cs, ep);
         this._startTranscribing(ep);
         updateSpeechCredentialLastUsed(this.sttCredentials.speech_credential_sid);
-        return;
+        return true;
       } catch (error) {
         this.logger.info({error}, `There is error while falling back to ${this.fallbackVendor}`);
+        this.notifyError({ msg: 'ASR error',
+          details:`STT Vendor ${this.vendor} error: ${evt.error || evt.reason}`, failover: 'not available'});
       }
+    } else {
+      this.logger.debug('gather:_startFallback no condition for falling back');
+      this.notifyError({ msg: 'ASR error',
+        details:`STT Vendor ${this.vendor} error: ${evt.error || evt.reason}`, failover: 'not available'});
     }
-    const {writeAlerts, AlertType} = cs.srf.locals;
+    return false;
+  }
 
+  async _onJambonzError(cs, ep, evt) {
+    if (this.vendor === 'google' && evt.error_code === 0) {
+      this.logger.info({evt}, 'TaskTranscribe:_onJambonzError - ignoring google error code 0');
+      return;
+    }
+    this.logger.info({evt}, 'TaskGather:_onJambonzError');
+    const {writeAlerts, AlertType} = cs.srf.locals;
     if (this.vendor === 'nuance') {
       const {code, error} = evt;
       if (code === 404 && error === 'No speech') return this._resolve('timeout');
@@ -965,17 +991,23 @@ class TaskGather extends SttTask {
       message: `Custom speech vendor ${this.vendor} error: ${evt.error}`,
       vendor: this.vendor,
     }).catch((err) => this.logger.info({err}, 'Error generating alert for jambonz custom connection failure'));
-    this.notifyError({msg: 'ASR error', details:`Custom speech vendor ${this.vendor} error: ${evt.error}`});
+    if (!(await this._startFallback(cs, ep, evt))) {
+      this.notifyTaskDone();
+    }
   }
 
-  _onVendorConnectFailure(cs, _ep, evt) {
+  async _onVendorConnectFailure(cs, _ep, evt) {
     super._onVendorConnectFailure(cs, _ep, evt);
-    this.notifyTaskDone();
+    if (!(await this._startFallback(cs, _ep, evt))) {
+      this.notifyTaskDone();
+    }
   }
 
-  _onVendorError(cs, _ep, evt) {
+  async _onVendorError(cs, _ep, evt) {
     super._onVendorError(cs, _ep, evt);
-    this._resolve('stt-error', evt);
+    if (!(await this._startFallback(cs, _ep, evt))) {
+      this._resolve('stt-error', evt);
+    }
   }
 
   _onVadDetected(cs, ep) {

lib/tasks/say.js

@@ -52,6 +52,151 @@ class TaskSay extends TtsTask {
     return `${this.name}{${this.text[0]}}`;
   }
 
+  _validateURL(urlString) {
+    try {
+      new URL(urlString);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  async _synthesizeWithSpecificVendor(cs, ep, {vendor, language, voice, label, preCache = false}) {
+    const {srf, accountSid:account_sid} = cs;
+    const {updateSpeechCredentialLastUsed} = require('../utils/db-utils')(this.logger, srf);
+    const {writeAlerts, AlertType, stats} = srf.locals;
+    const {synthAudio} = srf.locals.dbHelpers;
+    const engine = this.synthesizer.engine || 'standard';
+    const salt = cs.callSid;
+
+    let credentials = cs.getSpeechCredentials(vendor, 'tts', label);
+    /* parse Nuance voices into name and model */
+    let model;
+    if (vendor === 'nuance' && voice) {
+      const arr = /([A-Za-z-]*)\s+-\s+(enhanced|standard)/.exec(voice);
+      if (arr) {
+        voice = arr[1];
+        model = arr[2];
+      }
+    } else if (vendor === 'deepgram') {
+      model = voice;
+    }
+
+    /* allow for microsoft custom region voice and api_key to be specified as an override */
+    if (vendor === 'microsoft' && this.options.deploymentId) {
+      credentials = credentials || {};
+      credentials.use_custom_tts = true;
+      credentials.custom_tts_endpoint = this.options.deploymentId;
+      credentials.api_key = this.options.apiKey || credentials.apiKey;
+      credentials.region = this.options.region || credentials.region;
+      voice = this.options.voice || voice;
+    } else if (vendor === 'elevenlabs') {
+      credentials = credentials || {};
+      credentials.model_id = this.options.model_id || credentials.model_id;
+      credentials.voice_settings = this.options.voice_settings || {};
+      credentials.optimize_streaming_latency = this.options.optimize_streaming_latency
+      || credentials.optimize_streaming_latency;
+      voice = this.options.voice_id || voice;
+    }
+
+    ep.set({
+      tts_engine: vendor,
+      tts_voice: voice,
+      cache_speech_handles: 1,
+    }).catch((err) => this.logger.info({err}, 'Error setting tts_engine on endpoint'));
+
+    if (!preCache) this.logger.info({vendor, language, voice, model}, 'TaskSay:exec');
+    try {
+      if (!credentials) {
+        writeAlerts({
+          account_sid,
+          alert_type: AlertType.TTS_NOT_PROVISIONED,
+          vendor
+        }).catch((err) => this.logger.info({err}, 'Error generating alert for no tts'));
+        throw new Error('no provisioned speech credentials for TTS');
+      }
+      // synthesize all of the text elements
+      let lastUpdated = false;
+
+      /* produce an audio segment from the provided text */
+      const generateAudio = async(text) => {
+        if (this.killed) return;
+        if (text.startsWith('silence_stream://')) return text;
+
+        /* otel: trace time for tts */
+        if (!preCache)  {
+          const {span} = this.startChildSpan('tts-generation', {
+            'tts.vendor': vendor,
+            'tts.language': language,
+            'tts.voice': voice
+          });
+          this.otelSpan = span;
+        }
+        try {
+          const {filePath, servedFromCache, rtt} = await synthAudio(stats, {
+            account_sid,
+            text,
+            vendor,
+            language,
+            voice,
+            engine,
+            model,
+            salt,
+            credentials,
+            options: this.options,
+            disableTtsCache : this.disableTtsCache,
+            preCache
+          });
+          if (!filePath.startsWith('say:')) {
+            this.logger.debug(`file ${filePath}, served from cache ${servedFromCache}`);
+            if (filePath) cs.trackTmpFile(filePath);
+            if (this.otelSpan) {
+              this.otelSpan.setAttributes({'tts.cached': servedFromCache});
+              this.otelSpan.end();
+              this.otelSpan = null;
+            }
+            if (!servedFromCache && !lastUpdated) {
+              lastUpdated = true;
+              updateSpeechCredentialLastUsed(credentials.speech_credential_sid).catch(() => {/* logged error */});
+            }
+            if (!servedFromCache && rtt && !preCache) {
+              this.notifyStatus({
+                event: 'synthesized-audio',
+                vendor,
+                language,
+                characters: text.length,
+                elapsedTime: rtt
+              });
+            }
+          }
+          else {
+            this.logger.debug('a streaming tts api will be used');
+            const modifiedPath = filePath.replace('say:{', `say:{session-uuid=${ep.uuid},`);
+            return modifiedPath;
+          }
+          return filePath;
+        } catch (err) {
+          this.logger.info({err}, 'Error synthesizing tts');
+          if (this.otelSpan) this.otelSpan.end();
+          writeAlerts({
+            account_sid: cs.accountSid,
+            alert_type: AlertType.TTS_FAILURE,
+            vendor,
+            detail: err.message
+          }).catch((err) => this.logger.info({err}, 'Error generating alert for tts failure'));
+          throw err;
+        }
+      };
+
+      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;
+    }
+
+  }
+
   async exec(cs, {ep}) {
     const {srf, accountSid:account_sid} = cs;
     const {writeAlerts, AlertType} = srf.locals;
@@ -61,16 +206,16 @@ class TaskSay extends TtsTask {
     await super.exec(cs);
     this.ep = ep;
 
-    const vendor = this.synthesizer.vendor && this.synthesizer.vendor !== 'default' ?
+    let vendor = this.synthesizer.vendor && this.synthesizer.vendor !== 'default' ?
       this.synthesizer.vendor :
       cs.speechSynthesisVendor;
-    const language = this.synthesizer.language && this.synthesizer.language !== 'default' ?
+    let language = this.synthesizer.language && this.synthesizer.language !== 'default' ?
       this.synthesizer.language :
       cs.speechSynthesisLanguage ;
-    const voice =  this.synthesizer.voice && this.synthesizer.voice !== 'default' ?
+    let voice =  this.synthesizer.voice && this.synthesizer.voice !== 'default' ?
       this.synthesizer.voice :
       cs.speechSynthesisVoice;
-    const label = this.synthesizer.label && this.synthesizer.label !== 'default' ?
+    let label = this.synthesizer.label && this.synthesizer.label !== 'default' ?
       this.synthesizer.label :
       cs.speechSynthesisLabel;
 
@@ -87,12 +232,22 @@ class TaskSay extends TtsTask {
       this.synthesizer.fallbackLabel :
       cs.fallbackSpeechSynthesisLabel;
 
+    if (cs.hasFallbackTts) {
+      vendor = fallbackVendor;
+      language = fallbackLanguage;
+      voice = fallbackVoice;
+      label = fallbackLabel;
+    }
+
     let filepath;
     try {
       filepath = await this._synthesizeWithSpecificVendor(cs, ep, {vendor, language, voice, label});
     } catch (error) {
-      if (fallbackVendor && this.isHandledByPrimaryProvider) {
+      if (fallbackVendor && this.isHandledByPrimaryProvider && !cs.hasFallbackTts) {
+        this.notifyError(
+          { msg: 'TTS error', details:`TTS vendor ${vendor} error: ${error}`, failover: 'in progress'});
         this.isHandledByPrimaryProvider = false;
+        cs.hasFallbackTts = true;
         this.logger.info(`Synthesize error, fallback to ${fallbackVendor}`);
         filepath = await this._synthesizeWithSpecificVendor(cs, ep,
           {
@@ -102,6 +257,8 @@ class TaskSay extends TtsTask {
             label: fallbackLabel
           });
       } else {
+        this.notifyError(
+          { msg: 'TTS error', details:`TTS vendor ${vendor} error: ${error}`, failover: 'not available'});
         throw error;
       }
     }
@@ -187,6 +344,9 @@ class TaskSay extends TtsTask {
       if (key.startsWith('variable_tts_')) {
         let newKey = key.substring('variable_tts_'.length)
           .replace('whisper_', 'whisper.')
+          .replace('deepgram_', 'deepgram.')
+          .replace('playht_', 'playht.')
+          .replace('rimelabs_', 'rimelabs.')
           .replace('elevenlabs_', 'elevenlabs.');
         if (spanMapping[newKey]) newKey = spanMapping[newKey];
         attrs[newKey] = value;
@@ -198,6 +358,9 @@ class TaskSay extends TtsTask {
 }
 
 const spanMapping = {
+  // IMPORTANT!!! JAMBONZ WEBAPP WILL SHOW TEXT PERFECTLY IF THE SPAN NAME IS SMALLER OR EQUAL 25 CHARACTERS.
+  // EX: whisper.ratelim_reqs has length 20 <= 25 which is perfect
+  // Elevenlabs
   'elevenlabs.reported_latency_ms': 'elevenlabs.latency_ms',
   'elevenlabs.request_id': 'elevenlabs.req_id',
   'elevenlabs.history_item_id': 'elevenlabs.item_id',
@@ -205,11 +368,33 @@ const spanMapping = {
   'elevenlabs.name_lookup_time_ms': 'name_lookup_ms',
   'elevenlabs.connect_time_ms': 'connect_ms',
   'elevenlabs.final_response_time_ms': 'final_response_ms',
+  // Whisper
   'whisper.reported_latency_ms': 'whisper.latency_ms',
   'whisper.request_id': 'whisper.req_id',
+  'whisper.reported_organization': 'whisper.organization',
+  'whisper.reported_ratelimit_requests': 'whisper.ratelimit',
+  'whisper.reported_ratelimit_remaining_requests': 'whisper.ratelimit_remain',
+  'whisper.reported_ratelimit_reset_requests': 'whisper.ratelimit_reset',
   'whisper.name_lookup_time_ms': 'name_lookup_ms',
   'whisper.connect_time_ms': 'connect_ms',
   'whisper.final_response_time_ms': 'final_response_ms',
+  // Deepgram
+  'deepgram.request_id': 'deepgram.req_id',
+  'deepgram.reported_model_name': 'deepgram.model_name',
+  'deepgram.reported_model_uuid': 'deepgram.model_uuid',
+  'deepgram.reported_char_count': 'deepgram.char_count',
+  'deepgram.name_lookup_time_ms': 'name_lookup_ms',
+  'deepgram.connect_time_ms': 'connect_ms',
+  'deepgram.final_response_time_ms': 'final_response_ms',
+  // Playht
+  'playht.request_id': 'playht.req_id',
+  'playht.name_lookup_time_ms': 'name_lookup_ms',
+  'playht.connect_time_ms': 'connect_ms',
+  'playht.final_response_time_ms': 'final_response_ms',
+  // Rimelabs
+  'rimelabs.name_lookup_time_ms': 'name_lookup_ms',
+  'rimelabs.connect_time_ms': 'connect_ms',
+  'rimelabs.final_response_time_ms': 'final_response_ms',
 };
 
 module.exports = TaskSay;

lib/tasks/stt-task.js

@@ -98,6 +98,13 @@ class SttTask extends Task {
       this.fallbackLabel = cs.fallbackSpeechRecognizerLabel;
       if (this.data.recognizer) this.data.recognizer.fallbackLabel = this.fallbackLabel;
     }
+    // If call is already fallback to 2nd ASR vendor
+    // use that.
+    if (cs.hasFallbackAsr) {
+      this.vendor = this.fallbackVendor;
+      this.language = this.fallbackLanguage;
+      this.label = this.fallbackLabel;
+    }
     if (!this.data.recognizer.vendor) {
       this.data.recognizer.vendor = this.vendor;
     }
@@ -115,9 +122,11 @@ class SttTask extends Task {
       try {
         this.sttCredentials = await this._initSpeechCredentials(this.cs, this.vendor, this.label);
       } catch (error) {
-        if (this.fallbackVendor && this.isHandledByPrimaryProvider) {
-          await this._fallback();
+        if (this.canFallback) {
+          await this._initFallback();
+          this.notifyError({ msg: 'ASR error', details:`Invalid vendor ${this.vendor}`, failover: 'in progress'});
         } else {
+          this.notifyError({ msg: 'ASR error', details:`Invalid vendor ${this.vendor}`, failover: 'not available'});
           throw error;
         }
       }
@@ -186,9 +195,14 @@ class SttTask extends Task {
     return credentials;
   }
 
-  async _fallback() {
+  get canFallback() {
+    return this.fallbackVendor && this.isHandledByPrimaryProvider && !this.cs.hasFallbackAsr;
+  }
+
+  async _initFallback() {
     assert(this.fallbackVendor, 'fallback failed without fallbackVendor configuration');
     this.isHandledByPrimaryProvider = false;
+    this.cs.hasFallbackAsr = true;
     this.logger.info(`Failed to use primary STT provider, fallback to ${this.fallbackVendor}`);
     this.vendor = this.fallbackVendor;
     this.language = this.fallbackLanguage;
@@ -197,6 +211,8 @@ class SttTask extends Task {
     this.data.recognizer.language = this.language;
     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();
   }
 
   async compileHintsForCobalt(ep, hostport, model, token, hints) {
@@ -259,7 +275,6 @@ class SttTask extends Task {
       detail: evt.error,
       vendor: this.vendor,
     }).catch((err) => this.logger.info({err}, `Error generating alert for ${this.vendor} connection failure`));
-    this.notifyError({msg: 'ASR error', details:`Failed connecting to speech vendor ${this.vendor}: ${evt.error}`});
   }
 
   _onVendorConnectFailure(cs, _ep, evt) {
@@ -272,7 +287,6 @@ class SttTask extends Task {
       message: `Failed connecting to ${this.vendor} speech recognizer: ${reason}`,
       vendor: this.vendor,
     }).catch((err) => this.logger.info({err}, `Error generating alert for ${this.vendor} connection failure`));
-    this.notifyError({msg: 'ASR error', details:`Failed connecting to speech vendor ${this.vendor}: ${reason}`});
   }
 }
 

lib/tasks/transcribe.js

@@ -104,12 +104,15 @@ class TaskTranscribe extends SttTask {
 
       updateSpeechCredentialLastUsed(this.sttCredentials.speech_credential_sid)
         .catch(() => {/*already logged error */});
-
-      await this.awaitTaskDone();
     } catch (err) {
-      this.logger.info(err, 'TaskTranscribe:exec - error');
-      this.parentTask && this.parentTask.emit('error', err);
+      if (!(await this._startFallback(cs, ep, {error: err}))) {
+        this.logger.info(err, 'TaskTranscribe:exec - error');
+        this.parentTask && this.parentTask.emit('error', err);
+        this.removeCustomEventListeners();
+        return;
+      }
     }
+    await this.awaitTaskDone();
     this.removeCustomEventListeners();
   }
 
@@ -534,10 +537,8 @@ class TaskTranscribe extends SttTask {
     }
   }
 
-  async _onJambonzError(cs, _ep, evt) {
-    this.logger.info({evt}, 'TaskTranscribe:_onJambonzError');
-    if (this.paused) return;
-    if (this.isHandledByPrimaryProvider && this.fallbackVendor) {
+  async _startFallback(cs, _ep, evt) {
+    if (this.canFallback) {
       _ep.stopTranscription({
         vendor: this.vendor,
         bugname: this.bugname
@@ -545,38 +546,57 @@ class TaskTranscribe extends SttTask {
         .catch((err) => this.logger.error({err}, `Error stopping transcription for primary vendor ${this.vendor}`));
       const {updateSpeechCredentialLastUsed} = require('../utils/db-utils')(this.logger, cs.srf);
       try {
-        await this._fallback();
+        this.notifyError({ msg: 'ASR error',
+          details:`STT Vendor ${this.vendor} error: ${evt.error || evt.reason}`, failover: 'in progress'});
+        await this._initFallback();
         let channel = 1;
         if (this.ep !== _ep) {
           channel = 2;
         }
+        this[`_speechHandlersSet_${channel}`] = false;
         this._startTranscribing(cs, _ep, channel);
         updateSpeechCredentialLastUsed(this.sttCredentials.speech_credential_sid);
-        return;
+        return true;
       } catch (error) {
+        this.notifyError({ msg: 'ASR error',
+          details:`STT Vendor ${this.vendor} error: ${evt.error || evt.reason}`, failover: 'not available'});
         this.logger.info({error}, `There is error while falling back to ${this.fallbackVendor}`);
       }
     } else {
-      const {writeAlerts, AlertType} = cs.srf.locals;
+      this.logger.debug('transcribe:_startFallback no condition for falling back');
+      this.notifyError({ msg: 'ASR error',
+        details:`STT Vendor ${this.vendor} error: ${evt.error || evt.reason}`, failover: 'not available'});
+    }
+    return false;
+  }
 
-      if (this.vendor === 'nuance') {
-        const {code, error} = evt;
-        //TODO: fix below, currently _resolve does not send timeout events
-        if (code === 404 && error === 'No speech') return this._resolve('timeout');
-        if (code === 413 && error === 'Too much speech') return this._resolve('timeout');
-      }
-      this.logger.info({evt}, 'TaskTranscribe:_onJambonzError');
-      writeAlerts({
-        account_sid: cs.accountSid,
-        alert_type: AlertType.STT_FAILURE,
-        message: `Custom speech vendor ${this.vendor} error: ${evt.error}`,
-        vendor: this.vendor,
-      }).catch((err) => this.logger.info({err}, 'Error generating alert for jambonz custom connection failure'));
-      this.notifyError({msg: 'ASR error', details:`Custom speech vendor ${this.vendor} error: ${evt.error}`});
+  async _onJambonzError(cs, _ep, evt) {
+    if (this.vendor === 'google' && evt.error_code === 0) {
+      this.logger.info({evt}, 'TaskTranscribe:_onJambonzError - ignoring google error code 0');
+      return;
+    }
+    this.logger.info({evt}, 'TaskTranscribe:_onJambonzError');
+    if (this.paused) return;
+    const {writeAlerts, AlertType} = cs.srf.locals;
+
+    if (this.vendor === 'nuance') {
+      const {code, error} = evt;
+      if (code === 404 && error === 'No speech') return this._resolve('timeout');
+      if (code === 413 && error === 'Too much speech') return this._resolve('timeout');
+    }
+    this.logger.info({evt}, 'TaskTranscribe:_onJambonzError');
+    writeAlerts({
+      account_sid: cs.accountSid,
+      alert_type: AlertType.STT_FAILURE,
+      message: `Custom speech vendor ${this.vendor} error: ${evt.error}`,
+      vendor: this.vendor,
+    }).catch((err) => this.logger.info({err}, 'Error generating alert for jambonz custom connection failure'));
+    if (!(await this._startFallback(cs, _ep, evt))) {
+      this.notifyTaskDone();
     }
   }
 
-  _onVendorConnectFailure(cs, _ep, channel, evt) {
+  async _onVendorConnectFailure(cs, _ep, channel, evt) {
     super._onVendorConnectFailure(cs, _ep, evt);
     if (this.childSpan[channel - 1] && this.childSpan[channel - 1].span) {
       this.childSpan[channel - 1].span.setAttributes({
@@ -585,7 +605,9 @@ class TaskTranscribe extends SttTask {
       });
       this.childSpan[channel - 1].span.end();
     }
-    this.notifyTaskDone();
+    if (!(await this._startFallback(cs, _ep, evt))) {
+      this.notifyTaskDone();
+    }
   }
 
   _startAsrTimer(channel) {

lib/utils/transcription-utils.js

@@ -690,7 +690,9 @@ module.exports = (logger) => {
         ...(deepgramOptions.keywords) &&
           {DEEPGRAM_SPEECH_KEYWORDS: deepgramOptions.keywords.join(',')},
         ...('endpointing' in deepgramOptions) &&
-          {DEEPGRAM_SPEECH_ENDPOINTING: deepgramOptions.endpointing === false ? 'false' : deepgramOptions.endpointing},
+          {DEEPGRAM_SPEECH_ENDPOINTING: deepgramOptions.endpointing === false ? 'false' : deepgramOptions.endpointing,
+            // default DEEPGRAM_SPEECH_UTTERANCE_END_MS is 1000, will be override by user settings later if there is.
+            DEEPGRAM_SPEECH_UTTERANCE_END_MS: deepgramOptions.endpointing === false ? null : 1000},
         ...(deepgramOptions.utteranceEndMs) &&
           {DEEPGRAM_SPEECH_UTTERANCE_END_MS: deepgramOptions.utteranceEndMs},
         ...(deepgramOptions.vadTurnoff) &&

package-lock.json

@@ -18,7 +18,7 @@
         "@jambonz/speech-utils": "^0.0.51",
         "@jambonz/stats-collector": "^0.1.9",
         "@jambonz/time-series": "^0.2.8",
-        "@jambonz/verb-specifications": "^0.0.69",
+        "@jambonz/verb-specifications": "^0.0.70",
         "@opentelemetry/api": "^1.8.0",
         "@opentelemetry/exporter-jaeger": "^1.23.0",
         "@opentelemetry/exporter-trace-otlp-http": "^0.50.0",
@@ -2360,9 +2360,9 @@
       }
     },
     "node_modules/@jambonz/verb-specifications": {
-      "version": "0.0.69",
-      "resolved": "https://registry.npmjs.org/@jambonz/verb-specifications/-/verb-specifications-0.0.69.tgz",
-      "integrity": "sha512-DWnz7XRkCzpzyCVJH7NtScv+wSlUC414/EO8j/gPZs3RT4WBW1OBXwXpfjURHcSrDG7lycz+tfA+2WoUdW/W+g==",
+      "version": "0.0.70",
+      "resolved": "https://registry.npmjs.org/@jambonz/verb-specifications/-/verb-specifications-0.0.70.tgz",
+      "integrity": "sha512-WRSM7+hMnxLv4Fe5PG02m64uKX1AryRLF/yWpv/0PjHJSO4SYXN8CCAhgb1vctq27FMenMtOrSVt0haZeARObg==",
       "dependencies": {
         "debug": "^4.3.4",
         "pino": "^8.8.0"
@@ -11968,9 +11968,9 @@
       }
     },
     "@jambonz/verb-specifications": {
-      "version": "0.0.69",
-      "resolved": "https://registry.npmjs.org/@jambonz/verb-specifications/-/verb-specifications-0.0.69.tgz",
-      "integrity": "sha512-DWnz7XRkCzpzyCVJH7NtScv+wSlUC414/EO8j/gPZs3RT4WBW1OBXwXpfjURHcSrDG7lycz+tfA+2WoUdW/W+g==",
+      "version": "0.0.70",
+      "resolved": "https://registry.npmjs.org/@jambonz/verb-specifications/-/verb-specifications-0.0.70.tgz",
+      "integrity": "sha512-WRSM7+hMnxLv4Fe5PG02m64uKX1AryRLF/yWpv/0PjHJSO4SYXN8CCAhgb1vctq27FMenMtOrSVt0haZeARObg==",
       "requires": {
         "debug": "^4.3.4",
         "pino": "^8.8.0"

package.json

@@ -34,7 +34,7 @@
     "@jambonz/speech-utils": "^0.0.51",
     "@jambonz/stats-collector": "^0.1.9",
     "@jambonz/time-series": "^0.2.8",
-    "@jambonz/verb-specifications": "^0.0.69",
+    "@jambonz/verb-specifications": "^0.0.70",
     "@opentelemetry/api": "^1.8.0",
     "@opentelemetry/exporter-jaeger": "^1.23.0",
     "@opentelemetry/exporter-trace-otlp-http": "^0.50.0",