major refactor and simplification of actionHookDelay feature (#771)

* major refactor and simplification of actionHookDelay feature

* wip for #765

* wip

* testing

* wip

* added validity checks for actionHookDelay properties

* wip

* wip

* wip

* wip

* wip

* wip

* wip

* wip

* wip

* wip

* wip

* wip

* wip

* wip

* wip

* fix bug where config happens before endpoint is established

* wip

* hangup and clear ws connection if nogiveuptimer expires

* wip

* wip

* wip

lib/tasks/config.js

@@ -262,11 +262,7 @@ class TaskConfig extends Task {
       }
     }
     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;
-      cs.actionHookDelayRetries = this.actionHookDelayAction.retries || 1;
-      cs.actionHookDelayActions = this.actionHookDelayAction.actions || [];
+      cs.actionHookDelayProperties = this.actionHookDelayAction;
     }
     if (this.data.sipRequestWithinDialogHook) {
       cs.sipRequestWithinDialogHook = this.data.sipRequestWithinDialogHook;

lib/tasks/gather.js

@@ -117,6 +117,7 @@ class TaskGather extends SttTask {
     }
     if (this.sayTask) s += ',with nested say task';
     if (this.playTask) s += ',with nested play task';
+    if (this.actionHookDelayAction) s += ',with actionHookDelayAction';
     s += '}';
     return s;
   }
@@ -163,28 +164,15 @@ class TaskGather extends SttTask {
       this.interim = true;
       this.logger.debug('Gather:exec - early hints match enabled');
     }
-    // actionHook delay
-    this._hookDelayEn = cs.actionHookDelayEnabled || !!this.actionHookDelayAction;
 
-    this._hookDelayActions = this.actionHookDelayAction?.actions || cs.actionHookDelayActions || [];
-
-    // Only enable NoResponseTimeout if there is _hookDelayActions
-    this._hookNoResponseTimeout = (this._hookDelayActions?.length ?
-      (this.actionHookDelayAction?.noResponseTimeout || cs.actionHookNoResponseTimeout || 0)
-      : 0) * 1000;
-
-    this._hookNoResponseGiveUpTimeout = (this.actionHookDelayAction?.noResponseGiveUpTimeout ||
-      cs.actionHookNoResponseGiveUpTimeout || 0) * 1000;
-
-    this._hookDelayRetries = this.actionHookDelayAction?.retries || cs.actionHookDelayRetries || 1;
-    this._hookDelayRetryCount = 0;
-    this.hookDelayActionOpts = {
-      enabled: this._hookDelayEn,
-      actions: this._hookDelayActions,
-      noResponseTimeoutMs: this._hookNoResponseTimeout,
-      noResponseGiveUpTimeoutMs: this._hookNoResponseGiveUpTimeout,
-      retries: this._hookDelayRetries
-    };
+    // if we have actionHook delay, and the session does as well, stash the session config
+    if (this.actionHookDelayAction) {
+      if (cs.actionHookDelayProcessor) {
+        this.logger.debug('Gather:exec - stashing session-level ahd proprerties');
+        cs.stashActionHookDelayProperties();
+      }
+      cs.actionHookDelayProperties = this.actionHookDelayAction;
+    }
 
     this._startVad();
 
@@ -296,7 +284,6 @@ class TaskGather extends SttTask {
   kill(cs) {
     super.kill(cs);
     this._killAudio(cs);
-    this._killActionHookDelayAction();
     this._clearFillerNoiseTimer();
     this.ep.removeAllListeners('dtmf');
     clearTimeout(this.interDigitTimer);
@@ -592,98 +579,6 @@ class TaskGather extends SttTask {
     this.cs.hangup();
   }
 
-  _actionHookDelaySayAction(verb) {
-    delete verb.verb;
-    this.logger.debug(`_actionHookDelaySayAction ${verb}`);
-    this._actionHookDelaySayTask = makeTask(this.logger, {say: verb}, this);
-    const {span, ctx} = this.startChildSpan(`actionHookDelayAction:${this._actionHookDelaySayTask.summary}`);
-    this._actionHookDelaySayTask.span = span;
-    this._actionHookDelaySayTask.ctx = ctx;
-    this._actionHookDelaySayTask.exec(this.cs, {ep: this.ep});
-    this._actionHookDelaySayTask.on('playDone', (err) => {
-      this._actionHookDelaySayTask = null;
-      span.end();
-      if (err) this.logger.error({err}, 'Gather:actionHookDelay Error playing tts');
-    });
-  }
-
-  _killActionHookDelayAction() {
-    if (this._actionHookDelaySayTask && !this._actionHookDelaySayTask.killed) {
-      this._actionHookDelaySayTask.removeAllListeners('playDone');
-      this._actionHookDelaySayTask.kill(this.cs);
-      this._actionHookDelaySayTask.span.end();
-      this._actionHookDelaySayTask = null;
-    }
-
-    if (this._actionHookDelayPlayTask && !this._actionHookDelayPlayTask.killed) {
-      this._actionHookDelayPlayTask.removeAllListeners('playDone');
-      this._actionHookDelayPlayTask.kill(this.cs);
-      this._actionHookDelayPlayTask.span.end();
-      this._actionHookDelayPlayTask = null;
-    }
-  }
-
-  _actionHookDelayPlayAction(verb) {
-    delete verb.verb;
-    this.logger.debug(`_actionHookDelayPlayAction ${verb}`);
-    this._actionHookDelayPlayTask = makeTask(this.logger, {play: verb}, this);
-    const {span, ctx} = this.startChildSpan(`actionHookDelayAction:${this._actionHookDelayPlayTask.summary}`);
-    this._actionHookDelayPlayTask.span = span;
-    this._actionHookDelayPlayTask.ctx = ctx;
-    this._actionHookDelayPlayTask.exec(this.cs, {ep: this.ep});
-    this._actionHookDelayPlayTask.on('playDone', (err) => {
-      this._actionHookDelayPlayTask = null;
-      span.end();
-      if (err) this.logger.error({err}, 'Gather:actionHookDelay Error playing tts');
-    });
-
-  }
-
-  _startActionHookNoResponseTimer() {
-    assert(this._hookNoResponseTimeout > 0);
-    this._clearActionHookNoResponseTimer();
-    this.logger.debug('startActionHookNoResponseTimer');
-    this._actionHookNoResponseTimer = setTimeout(() => {
-      if (this._hookDelayRetryCount >= this._hookDelayRetries) {
-        this._hangupCall();
-        return;
-      }
-      const verb = this._hookDelayActions[this._hookDelayRetryCount % this._hookDelayActions.length];
-      if (verb.verb === 'say') {
-        this._actionHookDelaySayAction(verb);
-      } else if (verb.verb === 'play') {
-        this._actionHookDelayPlayAction(verb);
-      }
-      this._hookDelayRetryCount++;
-      this._startActionHookNoResponseTimer();
-
-    }, this._hookNoResponseTimeout);
-
-  }
-
-  _clearActionHookNoResponseTimer() {
-    if (this._actionHookNoResponseTimer) {
-      clearTimeout(this._actionHookNoResponseTimer);
-    }
-    this._actionHookNoResponseTimer = null;
-  }
-
-  _startActionHookNoResponseGiveUpTimer() {
-    assert(this._hookNoResponseGiveUpTimeout > 0);
-    this._clearActionHookNoResponseGiveUpTimer();
-    this.logger.debug('startActionHookNoResponseGiveUpTimer');
-    this._actionHookNoResponseGiveUpTimer = setTimeout(() => {
-      this._hangupCall();
-    }, this._hookNoResponseGiveUpTimeout);
-  }
-
-  _clearActionHookNoResponseGiveUpTimer() {
-    if (this._actionHookNoResponseGiveUpTimer) {
-      clearTimeout(this._actionHookNoResponseGiveUpTimer);
-    }
-    this._actionHookNoResponseGiveUpTimer = null;
-  }
-
   _startFastRecognitionTimer(evt) {
     assert(this.fastRecognitionTimeout > 0);
     this._clearFastRecognitionTimer();
@@ -1101,7 +996,10 @@ class TaskGather extends SttTask {
           this.logger.error({err}, 'Error stopping transcription');
         });
     }
-    if (this.resolved) return;
+    if (this.resolved) {
+      this.logger.debug('TaskGather:_resolve - already resolved');
+      return;
+    }
 
     this.resolved = true;
     // If bargin is false and ws application return ack to verb:hook
@@ -1125,15 +1023,13 @@ class TaskGather extends SttTask {
       return;
     }
 
-    // Enabled action Hook delay timer to applied actions
-    if (this._hookNoResponseTimeout > 0) {
-      this._startActionHookNoResponseTimer();
-    }
-
-    if (this._hookNoResponseGiveUpTimeout > 0) {
-      this._startActionHookNoResponseGiveUpTimer();
+    // action hook delay
+    if (this.cs.actionHookDelayProcessor) {
+      this.logger.debug('TaskGather:_resolve - actionHookDelayProcessor exists - starting it');
+      this.cs.actionHookDelayProcessor.start();
     }
 
+    // TODO: remove and implement as actionHookDelay
     if (this.hasFillerNoise && (reason.startsWith('dtmf') || reason.startsWith('speech'))) {
       if (this.fillerNoiseStartDelaySecs > 0) {
         this._startFillerNoiseTimer();
@@ -1144,40 +1040,57 @@ class TaskGather extends SttTask {
       }
     }
 
+    let returnedVerbs = false;
     try {
       if (reason.startsWith('dtmf')) {
         if (this.parentTask) this.parentTask.emit('dtmf', evt);
         else {
           this.emit('dtmf', evt);
-          await this.performAction({digits: this.digitBuffer, reason: 'dtmfDetected'});
+          returnedVerbs = await this.performAction({digits: this.digitBuffer, reason: 'dtmfDetected'});
         }
       }
       else if (reason.startsWith('speech')) {
         if (this.parentTask) this.parentTask.emit('transcription', evt);
         else {
           this.emit('transcription', evt);
-          await this.performAction({speech: evt, reason: 'speechDetected'});
+          this.logger.debug('TaskGather:_resolve - invoking performAction');
+          returnedVerbs = await this.performAction({speech: evt, reason: 'speechDetected'});
+          this.logger.debug({returnedVerbs}, 'TaskGather:_resolve - back from performAction');
         }
       }
       else if (reason.startsWith('timeout')) {
         if (this.parentTask) this.parentTask.emit('timeout', evt);
         else {
           this.emit('timeout', evt);
-          await this.performAction({reason: 'timeout'});
+          returnedVerbs = await this.performAction({reason: 'timeout'});
         }
       }
       else if (reason.startsWith('stt-error')) {
         if (this.parentTask) this.parentTask.emit('stt-error', evt);
         else {
           this.emit('stt-error', evt);
-          await this.performAction({reason: 'error', details: evt.error});
+          returnedVerbs = await this.performAction({reason: 'error', details: evt.error});
         }
       }
     } catch (err) {  /*already logged error*/ }
 
-    // Gather got response from hook, cancel all delay timers if there is any
-    this._clearActionHookNoResponseTimer();
-    this._clearActionHookNoResponseGiveUpTimer();
+    // Gather got response from hook, cancel actionHookDelay processing
+    this.logger.debug('TaskGather:_resolve - checking ahd');
+    if (this.cs.actionHookDelayProcessor) {
+      if (returnedVerbs) {
+        this.logger.debug('TaskGather:_resolve - got response from action hook, cancelling actionHookDelay');
+        await this.cs.actionHookDelayProcessor.stop();
+        if (this.actionHookDelayAction && !this.cs.popActionHookDelayProperties()) {
+          // no session level ahd was running when this task started, so clear it
+          this.cs.clearActionHookDelayProcessor();
+          this.logger.debug('TaskGather:_resolve - clear ahd');
+        }
+      }
+      else {
+        this.logger.debug('TaskGather:_resolve - no response from action hook, continue actionHookDelay');
+      }
+    }
+
     this._clearFillerNoiseTimer();
 
     this.notifyTaskDone();

lib/tasks/say.js

@@ -108,7 +108,7 @@ class TaskSay extends TtsTask {
     // If vendor is changed from the previous one, then reset the cache_speech_handles flag
     cs.currentTtsVendor = vendor;
 
-    if (!preCache) this.logger.info({vendor, language, voice, model}, 'TaskSay:exec');
+    if (!preCache && !this._disableTracing) this.logger.info({vendor, language, voice, model}, 'TaskSay:exec');
     try {
       if (!credentials) {
         writeAlerts({
@@ -127,7 +127,7 @@ class TaskSay extends TtsTask {
         if (text.startsWith('silence_stream://')) return text;
 
         /* otel: trace time for tts */
-        if (!preCache)  {
+        if (!preCache && !this._disableTracing)  {
           const {span} = this.startChildSpan('tts-generation', {
             'tts.vendor': vendor,
             'tts.language': language,
@@ -162,7 +162,7 @@ class TaskSay extends TtsTask {
               lastUpdated = true;
               updateSpeechCredentialLastUsed(credentials.speech_credential_sid).catch(() => {/* logged error */});
             }
-            if (!servedFromCache && rtt && !preCache) {
+            if (!servedFromCache && rtt && !preCache  && !this._disableTracing) {
               this.notifyStatus({
                 event: 'synthesized-audio',
                 vendor,

lib/tasks/task.js

@@ -45,6 +45,10 @@ class Task extends Emitter {
     return this.name;
   }
 
+  set disableTracing(val) {
+    this._disableTracing = val;
+  }
+
   toJSON() {
     return this.data;
   }
@@ -177,15 +181,16 @@ class Task extends Emitter {
           // If actionHook delay action is configured, and ws application have not responded yet any verb for actionHook
           // We have to transfer the task to call-session to await on next ws command verbs, and also run action Hook
           // delay actions
-          if (this.hookDelayActionOpts) {
-            this.emit('ActionHookDelayActionOptions', this.hookDelayActionOpts);
-          }
+          //if (this.hookDelayActionOpts) {
+          //  this.emit('ActionHookDelayActionOptions', this.hookDelayActionOpts);
+          //}
         }
         if (expectResponse && json && Array.isArray(json)) {
           const makeTask = require('./make_task');
           const tasks = normalizeJambones(this.logger, json).map((tdata) => makeTask(this.logger, tdata));
           if (tasks && tasks.length > 0) {
             this.callSession.replaceApplication(tasks);
+            return true;
           }
         }
       } catch (err) {
@@ -193,6 +198,7 @@ class Task extends Emitter {
         span.end();
         throw err;
       }
+      return false;
     }
   }