reanchor media for A leg

* wip, create outbound dial from webhook ws

* wip, create outbound dial from webhook ws

* clean

lib/config.js

@@ -132,6 +132,8 @@ const JAMBONES_DISABLE_DIRECT_P2P_CALL = process.env.JAMBONES_DISABLE_DIRECT_P2P
 
 const JAMBONES_EAGERLY_PRE_CACHE_AUDIO = process.env.JAMBONES_EAGERLY_PRE_CACHE_AUDIO;
 
+const JAMBONES_USE_FREESWITCH_TIMER_FD = process.env.JAMBONES_USE_FREESWITCH_TIMER_FD;
+
 module.exports = {
   JAMBONES_MYSQL_HOST,
   JAMBONES_MYSQL_USER,
@@ -213,5 +215,6 @@ module.exports = {
   JAMBONZ_RECORD_WS_USERNAME,
   JAMBONZ_RECORD_WS_PASSWORD,
   JAMBONZ_DISABLE_DIAL_PAI_HEADER,
-  JAMBONES_DISABLE_DIRECT_P2P_CALL
+  JAMBONES_DISABLE_DIRECT_P2P_CALL,
+  JAMBONES_USE_FREESWITCH_TIMER_FD
 };

lib/middleware.js

@@ -97,7 +97,7 @@ module.exports = function(srf, logger) {
     if (req.has('X-MS-Teams-Tenant-FQDN')) req.locals.msTeamsTenant = req.get('X-MS-Teams-Tenant-FQDN');
     if (req.has('X-Cisco-Recording-Participant')) {
       const ciscoParticipants = req.get('X-Cisco-Recording-Participant');
-      const regex = /sip:[\d]+@[\d]+\.[\d]+\.[\d]+\.[\d]+/g;
+      const regex = /sip:[a-zA-Z0-9]+@[a-zA-Z0-9.-_]+/g;
       const sipURIs = ciscoParticipants.match(regex);
       logger.info(`X-Cisco-Recording-Participant : ${sipURIs} `);
       if (sipURIs && sipURIs.length > 0) {

lib/session/call-session.js

@@ -21,7 +21,9 @@ const {
   JAMBONES_INJECT_CONTENT,
   JAMBONES_EAGERLY_PRE_CACHE_AUDIO,
   AWS_REGION,
+  JAMBONES_USE_FREESWITCH_TIMER_FD
 } = require('../config');
+const bent = require('bent');
 const BackgroundTaskManager = require('../utils/background-task-manager');
 const BADPRECONDITIONS = 'preconditions not met';
 const CALLER_CANCELLED_ERR_MSG = 'Response not sent due to unknown transaction';
@@ -689,7 +691,7 @@ class CallSession extends Emitter {
         (type === 'stt' && credential.use_for_stt)
       )) {
         this.logger.info(
-          `Speech vendor: ${credential.vendor} ${credential.label ? `, label: ${credential.label}` : ''} selected`);
+          `${type}: ${credential.vendor} ${credential.label ? `, label: ${credential.label}` : ''}  `);
         if ('google' === vendor) {
           if (type === 'tts' && !credential.tts_tested_ok ||
             type === 'stt' && !credential.stt_tested_ok) {
@@ -750,7 +752,9 @@ class CallSession extends Emitter {
         else if ('deepgram' === vendor) {
           return {
             speech_credential_sid: credential.speech_credential_sid,
-            api_key: credential.api_key
+            api_key: credential.api_key,
+            deepgram_stt_uri: credential.deepgram_stt_uri,
+            deepgram_stt_use_tls: credential.deepgram_stt_use_tls
           };
         }
         else if ('soniox' === vendor) {
@@ -974,6 +978,64 @@ class CallSession extends Emitter {
     }
   }
 
+  /**
+   * perform live call control - create rest:dial
+   * @param {obj} opts create call options
+   */
+  async _lccCallDial(opts) {
+    try {
+      const restDialUrl = `${this.srf.locals.serviceUrl}/v1/createCall`;
+      await this.transformInputIfRequired(opts);
+      const resp = bent('POST', 'json', 201)(restDialUrl, opts);
+      this.logger.info(resp.body, 'successfully create outbound call');
+      return resp.body;
+    } catch (err) {
+      if (err.json) {
+        err.body = await err.json();
+      }
+      this.logger.error(err, 'failed to create outbound call from ' + this.callSid);
+      this._notifyTaskError(err.body);
+    }
+  }
+
+  async transformInputIfRequired(opts) {
+    const {
+      lookupAppBySid
+    }  = this.srf.locals.dbHelpers;
+    opts.account_sid = this.accountSid;
+
+    if (opts.application_sid) {
+      this.logger.debug(`Callsession:_validateCreateCall retrieving application ${opts.application_sid}`);
+      const application = await lookupAppBySid(opts.application_sid);
+      Object.assign(opts, {
+        call_hook: application.call_hook,
+        app_json: application.app_json,
+        call_status_hook: application.call_status_hook,
+        speech_synthesis_vendor: application.speech_synthesis_vendor,
+        speech_synthesis_language: application.speech_synthesis_language,
+        speech_synthesis_voice: application.speech_synthesis_voice,
+        speech_recognizer_vendor: application.speech_recognizer_vendor,
+        speech_recognizer_language: application.speech_recognizer_language
+      });
+      this.logger.debug({opts, application}, 'Callsession:_validateCreateCall augmented with application settings');
+    }
+
+    if (typeof opts.call_hook === 'string') {
+      const url = opts.call_hook;
+      opts.call_hook = {
+        url,
+        method: 'POST'
+      };
+    }
+    if (typeof opts.call_status_hook === 'string') {
+      const url = opts.call_status_hook;
+      opts.call_status_hook = {
+        url,
+        method: 'POST'
+      };
+    }
+  }
+
   /**
    * perform live call control -- set a new call_hook
    * @param {object} opts
@@ -981,30 +1043,22 @@ class CallSession extends Emitter {
    * @param {object} [opts.call_hook] - new call_status_hook
    */
   async _lccCallHook(opts) {
-    const webhooks = [];
     let sd, tasks, childTasks;
     const b3 = this.b3;
     const httpHeaders = b3 && {b3};
 
     if (opts.call_hook || opts.child_call_hook) {
       if (opts.call_hook) {
-        webhooks.push(this.requestor.request('session:redirect', opts.call_hook, this.callInfo.toJSON(), httpHeaders));
+        tasks = await this.requestor.request('session:redirect', opts.call_hook, this.callInfo.toJSON(), httpHeaders);
       }
       if (opts.child_call_hook) {
         /* child call hook only allowed from a connected Dial state */
         const task = this.currentTask;
         sd = task.sd;
         if (task && TaskName.Dial === task.name && sd) {
-          webhooks.push(this.requestor.request(
-            'session:redirect', opts.child_call_hook, sd.callInfo.toJSON(), httpHeaders));
+          childTasks = [];
         }
       }
-      const [tasks1, tasks2] = await Promise.all(webhooks);
-      if (opts.call_hook) {
-        tasks = tasks1;
-        if (opts.child_call_hook) childTasks = tasks2;
-      }
-      else childTasks = tasks1;
     }
     else if (opts.parent_call || opts.child_call) {
       const {parent_call, child_call} = opts;
@@ -1024,16 +1078,25 @@ class CallSession extends Emitter {
       const cs = await sd.doAdulting({
         logger: childLogger,
         application: this.application,
-        tasks: t
+        tasks: t,
+        call_hook_url: opts.child_call_hook
       });
 
       /* need to update the callSid of the child with its own (new) AdultingCallSession */
       sessionTracker.add(cs.callSid, cs);
     }
     if (tasks) {
+      if (!this.ep) {
+        await this.reAnchorMedia();
+      }
       const t = normalizeJambones(this.logger, tasks).map((tdata) => makeTask(this.logger, tdata));
       this.logger.info({tasks: listTaskNames(t)}, 'CallSession:_lccCallHook new task list');
       this.replaceApplication(t);
+      if (this.wakeupResolver) {
+        //this.logger.debug({resolution}, 'CallSession:_onCommand - got commands, waking up..');
+        this.wakeupResolver({reason: 'lcc: new tasks'});
+        this.wakeupResolver = null;
+      }
     }
     else {
       /* we started a new app on the child leg, but nothing given for parent so hang him up */
@@ -1065,6 +1128,9 @@ class CallSession extends Emitter {
    * @param {string} opts.transcribe_status - 'pause' or 'resume'
   */
   async _lccTranscribeStatus(opts) {
+    if (this.backgroundTaskManager.isTaskRunning('transcribe')) {
+      this.backgroundTaskManager.getTask('transcribe').updateTranscribe(opts.transcribe_status);
+    }
     const task = this.currentTask;
     if (!task || ![TaskName.Dial, TaskName.Transcribe].includes(task.name)) {
       return this.logger.info(`CallSession:_lccTranscribeStatus - invalid transcribe_status in task ${task.name}`);
@@ -1412,7 +1478,7 @@ Duration=${duration} `
 
   _onCommand({msgid, command, call_sid, queueCommand, data}) {
     this.logger.info({msgid, command, queueCommand, data}, 'CallSession:_onCommand - received command');
-    const resolution = {reason: 'received command', queue: queueCommand, command};
+    let resolution;
     switch (command) {
       case 'redirect':
         if (Array.isArray(data)) {
@@ -1433,6 +1499,7 @@ Duration=${duration} `
             this.tasks.push(...t);
             this.logger.info({tasks: listTaskNames(this.tasks)}, 'CallSession:_onCommand - updated task list');
           }
+          resolution = {reason: 'received command, new tasks', queue: queueCommand, command};
           resolution.command = listTaskNames(t);
         }
         else this._lccCallHook(data);
@@ -1442,6 +1509,14 @@ Duration=${duration} `
         this._lccCallStatus(data);
         break;
 
+      case 'dial':
+        this._lccCallDial(data);
+        break;
+
+      case 'record':
+        this.notifyRecordOptions(data);
+        break;
+
       case 'mute:status':
         this._lccMuteStatus(call_sid, data);
         break;
@@ -1483,7 +1558,7 @@ Duration=${duration} `
       default:
         this.logger.info(`CallSession:_onCommand - invalid command ${command}`);
     }
-    if (this.wakeupResolver) {
+    if (this.wakeupResolver && resolution) {
       //this.logger.debug({resolution}, 'CallSession:_onCommand - got commands, waking up..');
       this.wakeupResolver(resolution);
       this.wakeupResolver = null;
@@ -2027,8 +2102,12 @@ Duration=${duration} `
   }
 
   _configMsEndpoint() {
-    if (this.onHoldMusic) {
-      this.ep.set({hold_music: `shout://${this.onHoldMusic.replace(/^https?:\/\//, '')}`});
+    const opts = {
+      ...(this.onHoldMusic && {holdMusic: `shout://${this.onHoldMusic.replace(/^https?:\/\//, '')}`}),
+      ...(JAMBONES_USE_FREESWITCH_TIMER_FD && {timer_name: 'timerfd'})
+    };
+    if (Object.keys(opts).length > 0) {
+      this.ep.set(opts);
     }
   }
 

lib/tasks/dequeue.js

@@ -73,7 +73,8 @@ class TaskDequeue extends Task {
         try {
           let url;
           if (this.callSid) {
-            url = await retrieveByPatternSortedSet(this.queueName, `*${this.callSid}`);
+            const r = await retrieveByPatternSortedSet(this.queueName, `*${this.callSid}`);
+            url = r[0];
           } else {
             url = await retrieveFromSortedSet(this.queueName);
           }

lib/tasks/dial.js

@@ -100,6 +100,7 @@ class TaskDial extends Task {
     this.referHook = this.data.referHook;
     this.dtmfHook = this.data.dtmfHook;
     this.proxy = this.data.proxy;
+    this.tag = this.data.tag;
 
     if (this.dtmfHook) {
       const {parentDtmfCollector, childDtmfCollector} = parseDtmfOptions(logger, this.data.dtmfCapture || {});

lib/tasks/gather.js

@@ -30,6 +30,10 @@ class TaskGather extends SttTask {
       'speechTimeout', 'timeout', 'say', 'play'
     ].forEach((k) => this[k] = this.data[k]);
 
+    // gather default input is digits
+    if (!this.input) {
+      this.input = ['digits'];
+    }
     /* when collecting dtmf, bargein on dtmf is true unless explicitly set to false */
     if (this.dtmfBargein !== false  && this.input.includes('digits')) this.dtmfBargein = true;
 
@@ -351,9 +355,6 @@ class TaskGather extends SttTask {
         this.addCustomEventListener(ep, DeepgramTranscriptionEvents.Connect, this._onVendorConnect.bind(this, cs, ep));
         this.addCustomEventListener(ep, DeepgramTranscriptionEvents.ConnectFailure,
           this._onVendorConnectFailure.bind(this, cs, ep));
-
-        /* if app sets deepgramOptions.utteranceEndMs they essentially want continuous asr */
-        if (opts.DEEPGRAM_SPEECH_UTTERANCE_END_MS) this.isContinuousAsr = true;
         break;
 
       case 'soniox':
@@ -487,9 +488,8 @@ class TaskGather extends SttTask {
     this._clearTimer();
     this._timeoutTimer = setTimeout(() => {
       if (this.isContinuousAsr) this._startAsrTimer();
-      else if (this.interDigitTimeout <= 0 ||
-        this.digitBuffer.length < this.minDigits ||
-        this.needsStt && this.digitBuffer.length === 0) {
+      if (this.interDigitTimer) return; // let the inter-digit timer complete
+      else {
         this._resolve(this.digitBuffer.length >= this.minDigits ? 'dtmf-num-digits' : 'timeout');
       }
     }, this.timeout);
@@ -499,7 +499,9 @@ class TaskGather extends SttTask {
     if (this._timeoutTimer) {
       clearTimeout(this._timeoutTimer);
       this._timeoutTimer = null;
+      return true;
     }
+    return false;
   }
 
   _startAsrTimer() {
@@ -622,7 +624,9 @@ class TaskGather extends SttTask {
     if (evt.is_final) {
       if (evt.alternatives[0].transcript === '' && !this.callSession.callGone && !this.killed) {
         emptyTranscript = true;
-        if (finished === 'true' && ['microsoft', 'deepgram'].includes(this.vendor)) {
+        if (finished === 'true' &&
+          ['microsoft', 'deepgram'].includes(this.vendor) &&
+          this._bufferedTranscripts.length === 0) {
           this.logger.debug({evt}, 'TaskGather:_onTranscription - got empty transcript from old gather, disregarding');
           return;
         }
@@ -669,7 +673,7 @@ class TaskGather extends SttTask {
           this.logger.debug({evt, words, bufferedWords},
             'TaskGather:_onTranscription - final transcript but < min barge words');
           this._bufferedTranscripts.push(evt);
-          this._startTranscribing(ep);
+          if (!['soniox', 'aws', 'microsoft', 'deepgram'].includes(this.vendor)) this._startTranscribing(ep);
           return;
         }
         else {
@@ -682,17 +686,11 @@ class TaskGather extends SttTask {
           else if (this.vendor === 'deepgram') {
             /* compile transcripts into one */
             if (!emptyTranscript) this._bufferedTranscripts.push(evt);
-            if (this.data.recognizer?.deepgramOptions?.utteranceEndMs) {
-              this.logger.debug('TaskGather:_onTranscription - got speech_final waiting for UtteranceEnd event');
-              return;
-            }
 
             /* deepgram can send an empty and final transcript; only if we have any buffered should we resolve */
             if (this._bufferedTranscripts.length === 0) return;
-            this.logger.debug({evt}, 'TaskGather:_onTranscription - compiling deepgram transcripts');
             evt = this.consolidateTranscripts(this._bufferedTranscripts, 1, this.language);
             this._bufferedTranscripts = [];
-            this.logger.debug({evt}, 'TaskGather:_onTranscription - compiled deepgram transcripts');
           }
 
           /* here is where we return a final transcript */
@@ -701,8 +699,7 @@ class TaskGather extends SttTask {
       }
     }
     else {
-      this._clearTimer();
-      this._startTimer();
+      if (this._clearTimer()) this._startTimer();
       if (this.bargein && (words + bufferedWords) >= this.minBargeinWordCount) {
         if (!this.playComplete) {
           this.logger.debug({transcript: evt.alternatives[0].transcript}, 'killing audio due to speech');
@@ -838,6 +835,9 @@ class TaskGather extends SttTask {
     if (this.resolved) return;
 
     this.resolved = true;
+    // If bargin is false and ws application return ack to verb:hook
+    // the gather should not play any audio
+    this._killAudio(this.cs);
     // Clear dtmf event
     if (this.dtmfBargein) {
       this.ep.removeAllListeners('dtmf');

lib/tasks/listen.js

@@ -123,8 +123,6 @@ class TaskListen extends Task {
       ci,
       this.metadata);
     if (this.hook.auth) {
-      this.logger.debug({username: this.hook.auth.username, password: this.hook.auth.password},
-        'TaskListen:_startListening basic auth');
       await this.ep.set({
         'MOD_AUDIO_BASIC_AUTH_USERNAME': this.hook.auth.username,
         'MOD_AUDIO_BASIC_AUTH_PASSWORD': this.hook.auth.password

lib/tasks/say.js

@@ -23,6 +23,12 @@ const breakLengthyTextIfNeeded = (logger,  text) => {
   }
 };
 
+const parseTextFromSayString = (text) => {
+  const closingBraceIndex = text.indexOf('}');
+  if (closingBraceIndex === -1) return text;
+  return text.slice(closingBraceIndex + 1);
+};
+
 class TaskSay extends Task {
   constructor(logger, opts, parentTask) {
     super(logger, opts);
@@ -60,7 +66,7 @@ class TaskSay extends Task {
   }
 
   async _synthesizeWithSpecificVendor(cs, ep, {vendor, language, voice, label, preCache = false}) {
-    const {srf} = cs;
+    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;
@@ -97,11 +103,17 @@ class TaskSay extends Task {
       voice = this.options.voice_id || voice;
     }
 
+    this.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: cs.accountSid,
+          account_sid,
           alert_type: AlertType.TTS_NOT_PROVISIONED,
           vendor
         }).catch((err) => this.logger.info({err}, 'Error generating alert for no tts'));
@@ -120,18 +132,17 @@ class TaskSay extends Task {
         if (text.startsWith('silence_stream://')) return text;
 
         /* otel: trace time for tts */
-        let otelSpan;
         if (!preCache)  {
           const {span} = this.startChildSpan('tts-generation', {
             'tts.vendor': vendor,
             'tts.language': language,
             'tts.voice': voice
           });
-          otelSpan = span;
+          this.otelSpan = span;
         }
         try {
           const {filePath, servedFromCache, rtt} = await synthAudio(stats, {
-            account_sid: cs.accountSid,
+            account_sid,
             text,
             vendor,
             language,
@@ -141,30 +152,40 @@ class TaskSay extends Task {
             salt,
             credentials,
             options: this.options,
-            disableTtsCache : this.disableTtsCache
+            disableTtsCache : this.disableTtsCache,
+            preCache
           });
-          this.logger.debug(`file ${filePath}, served from cache ${servedFromCache}`);
-          if (filePath) cs.trackTmpFile(filePath);
-          if (!servedFromCache && !lastUpdated) {
-            lastUpdated = true;
-            updateSpeechCredentialLastUsed(credentials.speech_credential_sid)
-              .catch(() => {/*already logged error */});
+          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
+              });
+            }
           }
-          if (otelSpan) otelSpan.setAttributes({'tts.cached': servedFromCache});
-          if (otelSpan) otelSpan.end();
-          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=${this.ep.uuid},`);
+            return modifiedPath;
           }
           return filePath;
         } catch (err) {
           this.logger.info({err}, 'Error synthesizing tts');
-          if (otelSpan) otelSpan.end();
+          if (this.otelSpan) this.otelSpan.end();
           writeAlerts({
             account_sid: cs.accountSid,
             alert_type: AlertType.TTS_FAILURE,
@@ -186,6 +207,11 @@ class TaskSay extends Task {
   }
 
   async exec(cs, {ep}) {
+    const {srf, accountSid:account_sid} = cs;
+    const {writeAlerts, AlertType} = srf.locals;
+    const {addFileToCache} = srf.locals.dbHelpers;
+    const engine = this.synthesizer.engine || 'standard';
+
     await super.exec(cs);
     this.ep = ep;
 
@@ -243,8 +269,48 @@ class TaskSay extends Task {
           await this.playToConfMember(this.ep, memberId, confName, confUuid, filepath[segment]);
         }
         else {
-          this.logger.debug(`Say:exec sending command to play file ${filepath[segment]}`);
+          if (filepath[segment].startsWith('say:{')) {
+            const arr = /^say:\{.*\}\s*(.*)$/.exec(filepath[segment]);
+            if (arr) this.logger.debug(`Say:exec sending streaming tts request: ${arr[1].substring(0, 64)}..`);
+          }
+          else this.logger.debug(`Say:exec sending  ${filepath[segment].substring(0, 64)}`);
+          this.ep.once('playback-start', (evt) => {
+            this.logger.debug({evt}, 'got playback-start');
+            if (this.otelSpan) {
+              this.logger.debug({evt}, 'got playback-start');
+              this._addStreamingTtsAttributes(this.otelSpan, evt);
+              this.otelSpan.end();
+              this.otelSpan = null;
+              if (evt.variable_tts_cache_filename) cs.trackTmpFile(evt.variable_tts_cache_filename);
+            }
+          });
+          this.ep.once('playback-stop', (evt) => {
+            this.logger.debug({evt}, 'got playback-stop');
+            if (evt.variable_tts_error) {
+              writeAlerts({
+                account_sid,
+                alert_type: AlertType.TTS_FAILURE,
+                vendor,
+                detail: evt.variable_tts_error
+              }).catch((err) => this.logger.info({err}, 'Error generating alert for no tts'));
+            }
+            if (evt.variable_tts_cache_filename) {
+              const text = parseTextFromSayString(this.text[segment]);
+              addFileToCache(evt.variable_tts_cache_filename, {
+                account_sid,
+                vendor,
+                language,
+                voice,
+                engine,
+                text
+              }).catch((err) => this.logger.info({err}, 'Error adding file to cache'));
+            }
+          });
           await ep.play(filepath[segment]);
+          if (filepath[segment].startsWith('say:{')) {
+            const arr = /^say:\{.*\}\s*(.*)$/.exec(filepath[segment]);
+            if (arr) this.logger.debug(`Say:exec complete playing streaming tts request: ${arr[1].substring(0, 64)}..`);
+          }
           this.logger.debug(`Say:exec completed play file ${filepath[segment]}`);
         }
         segment++;
@@ -265,8 +331,30 @@ class TaskSay extends Task {
         this.notifyStatus({event: 'kill-playback'});
         this.ep.api('uuid_break', this.ep.uuid);
       }
+      this.ep.removeAllListeners('playback-start');
+      this.ep.removeAllListeners('playback-stop');
     }
   }
+
+  _addStreamingTtsAttributes(span, evt) {
+    const attrs = {'tts.cached': false};
+    for (const [key, value] of Object.entries(evt)) {
+      if (key.startsWith('variable_tts_')) {
+        let newKey = key.substring('variable_tts_'.length)
+          .replace('elevenlabs_', 'elevenlabs.');
+        if (spanMapping[newKey]) newKey = spanMapping[newKey];
+        attrs[newKey] = value;
+      }
+    }
+    span.setAttributes(attrs);
+  }
 }
 
+const spanMapping = {
+  'elevenlabs.reported_latency_ms': 'elevenlabs.latency_ms',
+  'elevenlabs.request_id': 'elevenlabs.req_id',
+  'elevenlabs.history_item_id': 'elevenlabs.item_id',
+  'elevenlabs.optimize_streaming_latency': 'elevenlabs.optimization',
+};
+
 module.exports = TaskSay;

lib/tasks/stt-task.js

@@ -110,7 +110,12 @@ class SttTask extends Task {
       this.data.recognizer.model = cs.speechRecognizerLanguage;
     }
 
-    if (!this.sttCredentials) {
+    if (
+      // not gather task, such as transcribe
+      (!this.input ||
+      // gather task with speech
+        this.input.includes('speech')) &&
+      !this.sttCredentials) {
       try {
         this.sttCredentials = await this._initSpeechCredentials(this.cs, this.vendor, this.label);
       } catch (error) {

lib/tasks/task.js

@@ -160,6 +160,7 @@ class Task extends Emitter {
       const httpHeaders = b3 && {b3};
       span.setAttributes({'http.body': JSON.stringify(params)});
       try {
+        if (this.id) params.verb_id = this.id;
         const json = await this.cs.requestor.request(type, this.actionHook, params, httpHeaders);
         span.setAttributes({'http.statusCode': 200});
         const isWsConnection = this.cs.requestor instanceof WsRequestor;
@@ -177,7 +178,6 @@ class Task extends Emitter {
           const makeTask = require('./make_task');
           const tasks = normalizeJambones(this.logger, json).map((tdata) => makeTask(this.logger, tdata));
           if (tasks && tasks.length > 0) {
-            this.logger.info({tasks: tasks}, `${this.name} replacing application with ${tasks.length} tasks`);
             this.callSession.replaceApplication(tasks);
           }
         }

lib/tasks/transcribe.js

@@ -41,6 +41,7 @@ class TaskTranscribe extends SttTask {
     /* buffer speech for continuous asr */
     this._bufferedTranscripts = [];
     this.bugname_prefix = 'transcribe_';
+    this.paused = false;
   }
 
   get name() { return TaskName.Transcribe; }
@@ -95,7 +96,7 @@ class TaskTranscribe extends SttTask {
     }
     if (this.separateRecognitionPerChannel && this.ep2 && this.ep2.connected) {
       stopTranscription = true;
-      this.ep2.stopTranscription({vendor: this.vendor})
+      this.ep2.stopTranscription({vendor: this.vendor, bugname: this.bugname})
         .catch((err) => this.logger.info(err, 'Error TaskTranscribe:kill'));
     }
 
@@ -117,9 +118,11 @@ class TaskTranscribe extends SttTask {
       this.logger.info(`TaskTranscribe:updateTranscribe status ${status}`);
       switch (status) {
         case TranscribeStatus.Pause:
+          this.paused = true;
           await this._stopTranscription();
           break;
         case TranscribeStatus.Resume:
+          this.paused = false;
           await this._startTranscribing(this.cs, this.ep, 1);
           if (this.separateRecognitionPerChannel && this.ep2) {
             await this._startTranscribing(this.cs, this.ep2, 2);
@@ -296,6 +299,10 @@ class TaskTranscribe extends SttTask {
     // make sure this is not a transcript from answering machine detection
     const bugname = fsEvent.getHeader('media-bugname');
     if (bugname && this.bugname !== bugname) return;
+    if (this.paused) {
+      this.logger.debug({evt}, 'TaskTranscribe:_onTranscription - paused, ignoring transcript');
+    }
+
 
     if (this.vendor === 'ibm' && evt?.state === 'listening') return;
 
@@ -399,7 +406,8 @@ class TaskTranscribe extends SttTask {
   }
 
   _onNoAudio(cs, ep, channel) {
-    this.logger.debug(`TaskTranscribe:_onNoAudio restarting transcription on channel ${channel}`);
+    this.logger.debug(`TaskTranscribe:_onNoAudio on channel ${channel}`);
+    if (this.paused) return;
     if (this.childSpan[channel - 1] && this.childSpan[channel - 1].span) {
       this.childSpan[channel - 1].span.setAttributes({
         channel,
@@ -415,7 +423,8 @@ class TaskTranscribe extends SttTask {
   }
 
   _onMaxDurationExceeded(cs, ep, channel) {
-    this.logger.debug(`TaskTranscribe:_onMaxDurationExceeded restarting transcription on channel ${channel}`);
+    this.logger.debug(`TaskTranscribe:_onMaxDurationExceeded on channel ${channel}`);
+    if (this.paused) return;
     if (this.childSpan[channel - 1] && this.childSpan[channel - 1].span) {
       this.childSpan[channel - 1].span.setAttributes({
         channel,
@@ -440,6 +449,7 @@ class TaskTranscribe extends SttTask {
 
   async _onJambonzError(cs, _ep, evt) {
     this.logger.info({evt}, 'TaskTranscribe:_onJambonzError');
+    if (this.paused) return;
     if (this.isHandledByPrimaryProvider && this.fallbackVendor) {
       _ep.stopTranscription({
         vendor: this.vendor,

lib/utils/background-task-manager.js

@@ -65,18 +65,17 @@ class BackgroundTaskManager extends Emitter {
       // Remove task from managed List
       this.tasks.delete(type);
     } else {
-      this.logger.info(`stopping background task, ${type} is not running, skipped`);
+      this.logger.debug(`stopping background task, ${type} is not running, skipped`);
     }
   }
 
   stopAll() {
-    this.logger.info('BackgroundTaskManager:stopAll');
+    this.logger.debug('BackgroundTaskManager:stopAll');
     for (const key of this.tasks.keys()) {
       this.stop(key);
     }
   }
 
-  // Initiate Task
   // Initiate Listen
   async _initListen(opts, bugname = 'jambonz-background-listen', ignoreCustomerData = false, type = 'listen') {
     let task;
@@ -176,7 +175,7 @@ class BackgroundTaskManager extends Emitter {
   }
 
   _taskCompleted(type, task) {
-    this.logger.info({type, task}, 'BackgroundTaskManager:_taskCompleted: task completed');
+    this.logger.debug({type, task}, 'BackgroundTaskManager:_taskCompleted: task completed');
     task.removeAllListeners();
     task.span.end();
     this.tasks.delete(type);
@@ -189,7 +188,7 @@ class BackgroundTaskManager extends Emitter {
   }
 
   _bargeInTaskCompleted(evt) {
-    this.logger.info({evt}, 'BackgroundTaskManager:_bargeInTaskCompleted on event from background bargeIn');
+    this.logger.debug({evt}, 'BackgroundTaskManager:_bargeInTaskCompleted on event from background bargeIn');
     this.emit('bargeIn-done', evt);
   }
 }

lib/utils/db-utils.js

@@ -75,6 +75,8 @@ const speechMapper = (cred) => {
     else if ('deepgram' === obj.vendor) {
       const o = JSON.parse(decrypt(credential));
       obj.api_key = o.api_key;
+      obj.deepgram_stt_uri = o.deepgram_stt_uri;
+      obj.deepgram_stt_use_tls = o.deepgram_stt_use_tls;
     }
     else if ('soniox' === obj.vendor) {
       const o = JSON.parse(decrypt(credential));

lib/utils/install-srf-locals.js

@@ -176,6 +176,7 @@ function installSrfLocals(srf, logger) {
   const registrar = new Registrar(logger, client);
   const {
     synthAudio,
+    addFileToCache,
     getNuanceAccessToken,
     getIbmAccessToken,
   } = require('@jambonz/speech-utils')({}, logger);
@@ -215,6 +216,7 @@ function installSrfLocals(srf, logger) {
       listCalls,
       deleteCall,
       synthAudio,
+      addFileToCache,
       createHash,
       retrieveHash,
       deleteKey,

lib/utils/place-outdial.js

@@ -16,6 +16,10 @@ const uuidv4 = require('uuid-random');
 const HttpRequestor = require('./http-requestor');
 const WsRequestor = require('./ws-requestor');
 const {makeOpusFirst} = require('./sdp-utils');
+const listTaskNames = require('./summarize-tasks');
+const {
+  JAMBONES_USE_FREESWITCH_TIMER_FD
+} = require('../config');
 
 class SingleDialer extends Emitter {
   constructor({logger, sbcAddress, target, opts, application, callInfo, accountInfo, rootSpan, startSpan, dialTask,
@@ -192,6 +196,10 @@ class SingleDialer extends Emitter {
             callSid: this.callSid,
             traceId: this.rootSpan.traceId
           });
+          if (this.dialTask && this.dialTask.tag !== null &&
+            typeof this.dialTask.tag === 'object' && !Array.isArray(this.dialTask.tag)) {
+            this.callInfo.customerData = this.dialTask.tag;
+          }
           this.logger = srf.locals.parentLogger.child({
             callSid: this.callSid,
             parentCallSid: this.parentCallInfo.callSid,
@@ -324,8 +332,12 @@ class SingleDialer extends Emitter {
   }
 
   _configMsEndpoint() {
-    if (this.onHoldMusic) {
-      this.ep.set({hold_music: `shout://${this.onHoldMusic.replace(/^https?:\/\//, '')}`});
+    const opts = {
+      ...(this.onHoldMusic && {holdMusic: `shout://${this.onHoldMusic.replace(/^https?:\/\//, '')}`}),
+      ...(JAMBONES_USE_FREESWITCH_TIMER_FD && {timer_name: 'timerfd'})
+    };
+    if (Object.keys(opts).length > 0) {
+      this.ep.set(opts);
     }
   }
 
@@ -380,7 +392,7 @@ class SingleDialer extends Emitter {
     }
   }
 
-  async doAdulting({logger, tasks, application}) {
+  async doAdulting({logger, tasks, application, call_hook_url}) {
     this.adulting = true;
     this.emit('adulting');
     if (this.ep) {
@@ -399,6 +411,9 @@ class SingleDialer extends Emitter {
     //clone application from parent call with new requestor
     //parrent application will be closed in case the parent hangup
     const app = {...application};
+    if (call_hook_url) {
+      app.call_hook.url = call_hook_url;
+    }
     if ('WS' === app.call_hook?.method ||
       app.call_hook?.url.startsWith('ws://') || app.call_hook?.url.startsWith('wss://')) {
       const requestor = new WsRequestor(logger, this.accountInfo.account.account_sid,
@@ -415,6 +430,18 @@ class SingleDialer extends Emitter {
         this.accountInfo.account.webhook_secret);
       else app.notifier = {request: () => {}, close: () => {}};
     }
+    // Time to open session:new for adulting call
+    // If ws is used, open session:new to control the call later.
+    if (!tasks || tasks.length === 0 || app.requestor instanceof WsRequestor) {
+      const b3 = rootSpan?.getTracingPropagation();
+      const httpHeaders = b3 && {b3};
+      const newTask = await app.requestor.request(
+        'session:new', call_hook_url, this.callInfo.toJSON(), httpHeaders);
+      tasks = normalizeJambones(newLogger, newTask).map((tdata) => makeTask(newLogger, tdata));
+      newLogger.info({tasks: listTaskNames(tasks)}, 'SingleDialer:doAdulting new task list for adulting call');
+    }
+    // Replace old application with new application.
+    this.application = app;
     const cs = new AdultingCallSession({
       logger: newLogger,
       singleDialer: this,

lib/utils/transcription-utils.js

@@ -102,41 +102,44 @@ const stickyVars = {
   ]
 };
 
+/**
+ * @see https://developers.deepgram.com/docs/models-languages-overview
+ */
 const optimalDeepramModels = {
   zh: ['base', 'base'],
   'zh-CN':['base', 'base'],
   'zh-TW': ['base', 'base'],
   da: ['enhanced', 'enhanced'],
-  en: ['nova-2-conversationalai', 'nova-2'],
-  'en-US': ['nova-2-conversationalai', 'nova-2'],
-  'en-AU': ['nova-2-conversationalai', 'nova-2'],
-  'en-GB': ['nova-2-conversationalai', 'nova-2'],
-  'en-IN': ['nova-2-conversationalai', 'nova-2'],
-  'en-NZ': ['nova-2-conversationalai', 'nova-2'],
-  nl: ['nova-2-conversationalai', 'nova-2'],
-  fr: ['nova-2-conversationalai', 'nova-2'],
-  'fr-CA': ['nova-2-conversationalai', 'nova-2'],
-  de: ['nova-2-conversationalai', 'nova-2'],
-  hi: ['nova-2-conversationalai', 'nova-2'],
-  'hi-Latn': ['nova-2-conversationalai', 'nova-2'],
+  en: ['nova-2-phonecall', 'nova-2'],
+  'en-US': ['nova-2-phonecall', 'nova-2'],
+  'en-AU': ['nova-2', 'nova-2'],
+  'en-GB': ['nova-2', 'nova-2'],
+  'en-IN': ['nova-2', 'nova-2'],
+  'en-NZ': ['nova-2', 'nova-2'],
+  nl: ['nova-2', 'nova-2'],
+  fr: ['nova-2', 'nova-2'],
+  'fr-CA': ['nova-2', 'nova-2'],
+  de: ['nova-2', 'nova-2'],
+  hi: ['nova-2', 'nova-2'],
+  'hi-Latn': ['nova-2', 'nova-2'],
   id: ['base', 'base'],
-  it: ['enhanced', 'enhanced'],
+  it: ['nova-2', 'nova-2'],
   ja: ['enhanced', 'enhanced'],
-  ko: ['enhanced', 'enhanced'],
-  no: ['enhanced', 'enhanced'],
-  pl: ['enhanced', 'enhanced'],
-  pt: ['nova-2-conversationalai', 'nova-2'],
-  'pt-BR': ['nova-2-conversationalai', 'nova-2'],
-  'pt-PT': ['base', 'base'],
-  ru: ['base', 'base'],
-  es: ['nova-2-conversationalai', 'nova-2'],
-  'es-419': ['nova-2-conversationalai', 'nova-2'],
+  ko: ['nova-2', 'nova-2'],
+  no: ['nova-2', 'nova-2'],
+  pl: ['nova-2', 'nova-2'],
+  pt: ['nova-2', 'nova-2'],
+  'pt-BR': ['nova-2', 'nova-2'],
+  'pt-PT': ['nova-2', 'nova-2'],
+  ru: ['nova-2', 'nova-2'],
+  es: ['nova-2', 'nova-2'],
+  'es-419': ['nova-2', 'nova-2'],
   'es-LATAM': ['enhanced', 'enhanced'],
-  sv: ['enhanced', 'enhanced'],
+  sv: ['nova-2', 'nova-2'],
   ta: ['enhanced', 'enhanced'],
   taq: ['enhanced', 'enhanced'],
-  tr: ['base', 'base'],
-  uk: ['base', 'base']
+  tr: ['nova-2', 'nova-2'],
+  uk: ['nova-2', 'nova-2']
 };
 
 const selectDefaultDeepgramModel = (task, language) => {
@@ -144,6 +147,7 @@ const selectDefaultDeepgramModel = (task, language) => {
     const [gather, transcribe] = optimalDeepramModels[language];
     return task.name === TaskName.Gather ? gather : transcribe;
   }
+  return 'base';
 };
 
 const consolidateTranscripts = (bufferedTranscripts, channel, language) => {
@@ -614,18 +618,24 @@ module.exports = (logger) => {
       };
     }
     else if ('deepgram' === vendor) {
+      let {model} = rOpts;
       const {deepgramOptions = {}} = rOpts;
-      if (!deepgramOptions.model) {
-        deepgramOptions.model = selectDefaultDeepgramModel(task, language);
+      const deepgramUri = deepgramOptions.deepgramSttUri || sttCredentials.deepgram_stt_uri;
+      const useTls = deepgramOptions.deepgramSttUseTls || sttCredentials.deepgram_stt_use_tls;
+
+      /* default to a sensible model if not supplied */
+      if (!model) {
+        model = selectDefaultDeepgramModel(task, language);
       }
       opts = {
         ...opts,
+        DEEPGRAM_SPEECH_MODEL: model,
+        ...(deepgramUri && {DEEPGRAM_URI: deepgramUri}),
+        ...(deepgramUri && useTls && {DEEPGRAM_USE_TLS: 1}),
         ...(sttCredentials.api_key) &&
           {DEEPGRAM_API_KEY: sttCredentials.api_key},
         ...(deepgramOptions.tier) &&
           {DEEPGRAM_SPEECH_TIER: deepgramOptions.tier},
-        ...(deepgramOptions.model) &&
-          {DEEPGRAM_SPEECH_MODEL: deepgramOptions.model},
         ...(deepgramOptions.punctuate) &&
           {DEEPGRAM_SPEECH_ENABLE_AUTOMATIC_PUNCTUATION: 1},
         ...(deepgramOptions.smartFormatting) &&

lib/utils/ws-requestor.js

@@ -326,7 +326,9 @@ class WsRequestor extends BaseRequestor {
           'WsRequestor:_onSocketClosed time to reconnect');
         if (!this.ws && !this.connectInProgress) {
           this.connectInProgress = true;
-          this._connect().catch((err) => this.connectInProgress = false);
+          return this._connect()
+            .catch((err) => this.logger.error('WsRequestor:_onSocketClosed There is error while reconnect', err))
+            .finally(() => this.connectInProgress = false);
         }
       }, this.backoffMs);
       this.backoffMs = this.backoffMs < 2000 ? this.backoffMs * 2 : (this.backoffMs + 2000);

package.json

@@ -1,9 +1,9 @@
 {
   "name": "jambonz-feature-server",
-  "version": "0.8.5",
+  "version": "0.8.6",
   "main": "app.js",
   "engines": {
-    "node": ">= 10.16.0"
+    "node": ">= 18.x"
   },
   "keywords": [
     "sip",
@@ -31,10 +31,10 @@
     "@jambonz/http-health-check": "^0.0.1",
     "@jambonz/mw-registrar": "^0.2.4",
     "@jambonz/realtimedb-helpers": "^0.8.7",
-    "@jambonz/speech-utils": "^0.0.33",
+    "@jambonz/speech-utils": "^0.0.41",
     "@jambonz/stats-collector": "^0.1.9",
     "@jambonz/time-series": "^0.2.8",
-    "@jambonz/verb-specifications": "^0.0.50",
+    "@jambonz/verb-specifications": "^0.0.53",
     "@opentelemetry/api": "^1.4.0",
     "@opentelemetry/exporter-jaeger": "^1.9.0",
     "@opentelemetry/exporter-trace-otlp-http": "^0.35.0",
@@ -47,7 +47,7 @@
     "bent": "^7.3.12",
     "debug": "^4.3.4",
     "deepcopy": "^2.1.0",
-    "drachtio-fsmrf": "^3.0.33",
+    "drachtio-fsmrf": "^3.0.37",
     "drachtio-srf": "^4.5.31",
     "express": "^4.18.2",
     "express-validator": "^7.0.1",

test/transcribe-tests.js

@@ -347,8 +347,7 @@ test('\'transcribe\' test - deepgram config options altLanguages', async(t) => {
             "en-US"
           ],
           "deepgramOptions": {
-            "model": "2-ea",
-            "tier": "nova",
+            "model": "nova-2",
             "numerals": true,
             "ner": true,
             "vadTurnoff": 10,
@@ -408,8 +407,7 @@ test('\'transcribe\' test - deepgram config options altLanguages', async(t) => {
             "en-US"
           ],
           "deepgramOptions": {
-            "model": "2-ea",
-            "tier": "nova",
+            "model": "nova-2",
             "numerals": true,
             "ner": true,
             "vadTurnoff": 10,