config.listen now supports mixType

.github/workflows/build.yml

@@ -1,6 +1,7 @@
 name: CI
 
-on: [push, pull_request]
+on:
+  push:
 
 jobs:
   build:

Dockerfile

@@ -1,4 +1,4 @@
-FROM --platform=linux/amd64 node:18.14.1-alpine3.16 as base
+FROM --platform=linux/amd64 node:18.12.1-alpine3.16 as base
 
 RUN apk --update --no-cache add --virtual .builds-deps build-base python3
 

README.md

@@ -20,7 +20,6 @@ Configuration is provided via environment variables:
 |ENABLE_METRICS| if 1, metrics will be generated|no|
 |GOOGLE_APPLICATION_CREDENTIALS| path to gcp service key file|yes|
 |HTTP_PORT| tcp port to listen on for API requests from jambonz-api-server|yes|
-|JAMBONES_GATHER_EARLY_HINTS_MATCH| if true and hints are provided, gather will opportunistically review interim transcripts if possible to reduce ASR latency |no|
 |JAMBONES_FREESWITCH| IP:port:secret for Freeswitch server (e.g. '127.0.0.1:8021:JambonzR0ck$'|yes|
 |JAMBONES_LOGLEVEL| log level for application, 'info' or 'debug'|no|
 |JAMBONES_MYSQL_HOST| mysql host|yes|

app.js

@@ -106,25 +106,16 @@ const disconnect = () => {
   });
 };
 
+process.on('SIGUSR2', handle);
 process.on('SIGTERM', handle);
 
 function handle(signal) {
   const {removeFromSet} = srf.locals.dbHelpers;
-  srf.locals.disabled = true;
-  logger.info(`got signal ${signal}`);
   const setName = `${(process.env.JAMBONES_CLUSTER_ID || 'default')}:active-fs`;
-  if (setName && srf.locals.localSipAddress) {
-    logger.info(`got signal ${signal}, removing ${srf.locals.localSipAddress} from set ${setName}`);
-    removeFromSet(setName, srf.locals.localSipAddress);
-  }
+  logger.info(`got signal ${signal}, removing ${srf.locals.localSipAddress} from set ${setName}`);
+  removeFromSet(setName, srf.locals.localSipAddress);
   removeFromSet(FS_UUID_SET_NAME, srf.locals.fsUUID);
-  if (process.env.K8S) {
-    srf.locals.lifecycleEmitter.operationalState = LifeCycleEvents.ScaleIn;
-  }
-  if (getCount() === 0) {
-    logger.info('no calls in progress, exiting');
-    process.exit(0);
-  }
+  srf.locals.disabled = true;
 }
 
 if (process.env.JAMBONZ_CLEANUP_INTERVAL_MINS) {

lib/http-routes/api/create-message.js

@@ -2,7 +2,7 @@ const router = require('express').Router();
 const CallInfo = require('../../session/call-info');
 const {CallDirection} = require('../../utils/constants');
 const SmsSession = require('../../session/sms-call-session');
-const { normalizeJambones } = require('@jambonz/verb-specifications');
+const normalizeJambones = require('../../utils/normalize-jambones');
 const makeTask = require('../../tasks/make_task');
 
 router.post('/:sid', async(req, res) => {

lib/http-routes/api/messaging.js

@@ -4,7 +4,7 @@ const WsRequestor = require('../../utils/ws-requestor');
 const CallInfo = require('../../session/call-info');
 const {CallDirection} = require('../../utils/constants');
 const SmsSession = require('../../session/sms-call-session');
-const { normalizeJambones } = require('@jambonz/verb-specifications');
+const normalizeJambones = require('../../utils/normalize-jambones');
 const {TaskPreconditions} = require('../../utils/constants');
 const makeTask = require('../../tasks/make_task');
 

lib/middleware.js

@@ -6,7 +6,7 @@ const HttpRequestor = require('./utils/http-requestor');
 const WsRequestor = require('./utils/ws-requestor');
 const makeTask = require('./tasks/make_task');
 const parseUri = require('drachtio-srf').parseUri;
-const { normalizeJambones }  = require('@jambonz/verb-specifications');
+const normalizeJambones = require('./utils/normalize-jambones');
 const dbUtils = require('./utils/db-utils');
 const RootSpan = require('./utils/call-tracer');
 const listTaskNames = require('./utils/summarize-tasks');

lib/session/call-session.js

@@ -13,7 +13,7 @@ const moment = require('moment');
 const assert = require('assert');
 const sessionTracker = require('./session-tracker');
 const makeTask = require('../tasks/make_task');
-const { normalizeJambones } = require('@jambonz/verb-specifications');
+const normalizeJambones = require('../utils/normalize-jambones');
 const listTaskNames = require('../utils/summarize-tasks');
 const HttpRequestor = require('../utils/http-requestor');
 const WsRequestor = require('../utils/ws-requestor');
@@ -645,12 +645,6 @@ class CallSession extends Emitter {
             api_key: credential.api_key
           };
         }
-        else if ('soniox' === vendor) {
-          return {
-            speech_credential_sid: credential.speech_credential_sid,
-            api_key: credential.api_key
-          };
-        }
         else if ('ibm' === vendor) {
           return {
             speech_credential_sid: credential.speech_credential_sid,
@@ -1456,15 +1450,9 @@ class CallSession extends Emitter {
   async _onReinvite(req, res) {
     try {
       if (this.ep) {
-        if (this.isSipRecCallSession) {
-          this.logger.info('handling reINVITE for siprec call');
-          res.send(200, {body: this.ep.local.sdp});
-        }
-        else {
-          const newSdp = await this.ep.modify(req.body);
-          res.send(200, {body: newSdp});
-          this.logger.info({offer: req.body, answer: newSdp}, 'handling reINVITE');
-        }
+        const newSdp = await this.ep.modify(req.body);
+        res.send(200, {body: newSdp});
+        this.logger.info({offer: req.body, answer: newSdp}, 'handling reINVITE');
       }
       else if (this.currentTask && this.currentTask.name === TaskName.Dial) {
         this.logger.info('handling reINVITE after media has been released');
@@ -1682,7 +1670,7 @@ class CallSession extends Emitter {
    * @param {number} sipStatus - current sip status
    * @param {number} [duration] - duration of a completed call, in seconds
    */
-  async _notifyCallStatusChange({callStatus, sipStatus, sipReason, duration}) {
+  _notifyCallStatusChange({callStatus, sipStatus, sipReason, duration}) {
     if (this.callMoved) return;
 
     /* race condition: we hang up at the same time as the caller */
@@ -1702,7 +1690,7 @@ class CallSession extends Emitter {
     try {
       const b3 = this.b3;
       const httpHeaders = b3 && {b3};
-      await this.notifier.request('call:status', this.call_status_hook, this.callInfo.toJSON(), httpHeaders);
+      this.notifier.request('call:status', this.call_status_hook, this.callInfo.toJSON(), httpHeaders);
       span.end();
     } catch (err) {
       span.end();

lib/tasks/conference.js

@@ -2,7 +2,7 @@ const Task = require('./task');
 const Emitter = require('events');
 const ConfirmCallSession = require('../session/confirm-call-session');
 const {TaskName, TaskPreconditions, BONG_TONE} = require('../utils/constants');
-const { normalizeJambones } = require('@jambonz/verb-specifications');
+const normalizeJambones = require('../utils/normalize-jambones');
 const makeTask = require('./make_task');
 const bent = require('bent');
 const assert = require('assert');

lib/tasks/dialogflow/index.js

@@ -3,7 +3,7 @@ const {TaskName, TaskPreconditions} = require('../../utils/constants');
 const Intent = require('./intent');
 const DigitBuffer = require('./digit-buffer');
 const Transcription = require('./transcription');
-const { normalizeJambones } = require('@jambonz/verb-specifications');
+const normalizeJambones = require('../../utils/normalize-jambones');
 
 class Dialogflow extends Task {
   constructor(logger, opts) {

lib/tasks/enqueue.js

@@ -1,7 +1,7 @@
 const Task = require('./task');
 const Emitter = require('events');
 const ConfirmCallSession = require('../session/confirm-call-session');
-const { normalizeJambones } = require('@jambonz/verb-specifications');
+const normalizeJambones = require('../utils/normalize-jambones');
 const makeTask = require('./make_task');
 const {TaskName, TaskPreconditions, QueueResults, KillReason} = require('../utils/constants');
 const bent = require('bent');

lib/tasks/gather.js

@@ -7,9 +7,7 @@ const {
   AwsTranscriptionEvents,
   AzureTranscriptionEvents,
   DeepgramTranscriptionEvents,
-  SonioxTranscriptionEvents,
-  IbmTranscriptionEvents,
-  NvidiaTranscriptionEvents
+  IbmTranscriptionEvents
 } = require('../utils/constants');
 
 const makeTask = require('./make_task');
@@ -34,13 +32,11 @@ class TaskGather extends Task {
       setChannelVarsForStt,
       normalizeTranscription,
       removeSpeechListeners,
-      setSpeechCredentialsAtRuntime,
-      compileSonioxTranscripts
+      setSpeechCredentialsAtRuntime
     } = require('../utils/transcription-utils')(logger);
     this.setChannelVarsForStt = setChannelVarsForStt;
     this.normalizeTranscription = normalizeTranscription;
     this.removeSpeechListeners = removeSpeechListeners;
-    this.compileSonioxTranscripts = compileSonioxTranscripts;
 
     [
       'finishOnKey', 'input', 'numDigits', 'minDigits', 'maxDigits',
@@ -55,7 +51,7 @@ class TaskGather extends Task {
     this.timeout = this.timeout === 0 ? 0 : (this.timeout || 15) * 1000;
     this.interim = !!this.partialResultHook || this.bargein;
     this.listenDuringPrompt = this.data.listenDuringPrompt === false ? false : true;
-    this.minBargeinWordCount = this.data.minBargeinWordCount || 1;
+    this.minBargeinWordCount = this.data.minBargeinWordCount || 0;
     if (this.data.recognizer) {
       const recognizer = this.data.recognizer;
       this.vendor = recognizer.vendor;
@@ -88,9 +84,6 @@ class TaskGather extends Task {
     /* buffer speech for continuous asr */
     this._bufferedTranscripts = [];
 
-    /* buffer for soniox transcripts */
-    this._sonioxTranscripts = [];
-
     this.parentTask = parentTask;
   }
 
@@ -148,8 +141,7 @@ class TaskGather extends Task {
         asrDtmfTerminationDigit: this.asrDtmfTerminationDigit
       }, 'Gather:exec - enabling continuous ASR since it is turned on for the session');
     }
-    const {JAMBONZ_GATHER_EARLY_HINTS_MATCH, JAMBONES_GATHER_EARLY_HINTS_MATCH} = process.env;
-    if ((JAMBONZ_GATHER_EARLY_HINTS_MATCH || JAMBONES_GATHER_EARLY_HINTS_MATCH) && this.needsStt &&
+    if (process.env.JAMBONZ_GATHER_EARLY_HINTS_MATCH && this.needsStt &&
       !this.isContinuousAsr &&
       this.data.recognizer?.hints?.length > 0 && this.data.recognizer?.hints?.length <= 10) {
       this.earlyHintsMatch = true;
@@ -179,10 +171,7 @@ class TaskGather extends Task {
         vendor: this.vendor
       }).catch((err) => this.logger.info({err}, 'Error generating alert for no stt'));
       // Notify application that STT vender is wrong.
-      this.notifyError({
-        msg: 'ASR error',
-        details: `No speech-to-text service credentials for ${this.vendor} have been configured`
-      });
+      this.notifyError(`No speech-to-text service credentials for ${this.vendor} have been configured`);
       this.notifyTaskDone();
       throw new Error(`No speech-to-text service credentials for ${this.vendor} have been configured`);
     }
@@ -294,7 +283,6 @@ class TaskGather extends Task {
     this._killAudio(cs);
     this.ep.removeAllListeners('dtmf');
     clearTimeout(this.interDigitTimer);
-    this._clearAsrTimer();
     this.playTask?.span.end();
     this.sayTask?.span.end();
     this._resolve('killed');
@@ -396,13 +384,6 @@ class TaskGather extends Task {
           this._onDeepGramConnectFailure.bind(this, cs, ep));
         break;
 
-      case 'soniox':
-        this.bugname = 'soniox_transcribe';
-        ep.addCustomEventListener(SonioxTranscriptionEvents.Transcription, this._onTranscription.bind(this, cs, ep));
-        ep.addCustomEventListener(SonioxTranscriptionEvents.Error,
-          this._onSonioxError.bind(this, cs, ep));
-        break;
-
       case 'ibm':
         this.bugname = 'ibm_transcribe';
         ep.addCustomEventListener(IbmTranscriptionEvents.Transcription, this._onTranscription.bind(this, cs, ep));
@@ -413,27 +394,8 @@ class TaskGather extends Task {
           this._onIbmError.bind(this, cs, ep));
         break;
 
-      case 'nvidia':
-        this.bugname = 'nvidia_transcribe';
-        ep.addCustomEventListener(NvidiaTranscriptionEvents.Transcription,
-          this._onTranscription.bind(this, cs, ep));
-        ep.addCustomEventListener(NvidiaTranscriptionEvents.StartOfSpeech,
-          this._onStartOfSpeech.bind(this, cs, ep));
-        ep.addCustomEventListener(NvidiaTranscriptionEvents.TranscriptionComplete,
-          this._onTranscriptionComplete.bind(this, cs, ep));
-        ep.addCustomEventListener(NvidiaTranscriptionEvents.VadDetected,
-          this._onVadDetected.bind(this, cs, ep));
-        ep.addCustomEventListener(NvidiaTranscriptionEvents.Error,
-          this._onNvidiaError.bind(this, cs, ep));
-
-        /* I think nvidia has this (??) - stall timers until prompt finishes playing */
-        if ((this.sayTask || this.playTask) && this.listenDuringPrompt) {
-          opts.NVIDIA_STALL_TIMERS = 1;
-        }
-        break;
-
       default:
-        this.notifyError({ msg: 'ASR error', details:`Invalid vendor ${this.vendor}`});
+        this.notifyError(`Invalid vendor ${this.vendor}`);
         this.notifyTaskDone();
         throw new Error(`Invalid vendor ${this.vendor}`);
     }
@@ -537,7 +499,7 @@ class TaskGather extends Task {
     // make sure this is not a transcript from answering machine detection
     const bugname = fsEvent.getHeader('media-bugname');
     const finished = fsEvent.getHeader('transcription-session-finished');
-    this.logger.debug({evt, bugname, finished}, `Gather:_onTranscription for vendor ${this.vendor}`);
+    this.logger.debug({evt, bugname, finished}, 'Gather:_onTranscription');
     if (bugname && this.bugname !== bugname) return;
 
     if (this.vendor === 'ibm') {
@@ -546,20 +508,11 @@ class TaskGather extends Task {
 
     evt = this.normalizeTranscription(evt, this.vendor, 1, this.language);
 
-    if (this.earlyHintsMatch && evt.is_final === false) {
-      const transcript = evt.alternatives[0].transcript?.toLowerCase();
-      const hints = this.data.recognizer?.hints || [];
-      if (hints.find((h) => h.toLowerCase() === transcript)) {
-        this.logger.debug({evt}, 'Gather:_onTranscription: early hint match');
-        this._resolve('speech', evt);
-        return;
-      }
-    }
-
     /* count words for bargein feature */
     const words = evt.alternatives[0]?.transcript.split(' ').length;
-    const bufferedWords = this._sonioxTranscripts.length +
-      this._bufferedTranscripts.reduce((count, e) => count + e.alternatives[0]?.transcript.split(' ').length, 0);
+    const bufferedWords = this._bufferedTranscripts.reduce((count, e) => {
+      return count + e.alternatives[0]?.transcript.split(' ').length;
+    }, 0);
 
     if (evt.is_final) {
       if (evt.alternatives[0].transcript === '' && !this.callSession.callGone && !this.killed) {
@@ -568,6 +521,7 @@ class TaskGather extends Task {
         }
         else {
           this.logger.info({evt}, 'TaskGather:_onTranscription - got empty transcript, continue listening');
+          //this._startTranscribing(ep);
         }
         return;
       }
@@ -591,9 +545,7 @@ class TaskGather extends Task {
           return this._resolve(this._bufferedTranscripts.length > 0 ? 'speech' : 'timeout');
         }
         this._startAsrTimer();
-
-        /* some STT engines will keep listening after a final response, so no need to restart */
-        if (!['soniox', 'aws', 'microsoft', 'deepgram'].includes(this.vendor)) this._startTranscribing(ep);
+        return this._startTranscribing(ep);
       }
       else {
         if (this.bargein && (words + bufferedWords) < this.minBargeinWordCount) {
@@ -604,12 +556,6 @@ class TaskGather extends Task {
           return;
         }
         else {
-          if (this.vendor === 'soniox') {
-            /* compile transcripts into one */
-            this._sonioxTranscripts.push(evt.vendor.finalWords);
-            evt = this.compileSonioxTranscripts(this._sonioxTranscripts, 1, this.language);
-            this._sonioxTranscripts = [];
-          }
           this._resolve('speech', evt);
         }
       }
@@ -633,13 +579,6 @@ class TaskGather extends Task {
         this.cs.requestor.request('verb:hook', this.partialResultHook,  Object.assign({speech: evt},
           this.cs.callInfo, httpHeaders));
       }
-      if (this.vendor === 'soniox') {
-        this._clearTimer();
-        if (evt.vendor.finalWords.length) {
-          this.logger.debug({evt}, 'TaskGather:_onTranscription - buffering soniox transcript');
-          this._sonioxTranscripts.push(evt.vendor.finalWords);
-        }
-      }
     }
   }
   _onEndOfUtterance(cs, ep) {
@@ -655,9 +594,6 @@ class TaskGather extends Task {
 
   _onStartOfSpeech(cs, ep) {
     this.logger.debug('TaskGather:_onStartOfSpeech');
-    if (this.bargein) {
-      this._killAudio(cs);
-    }
   }
   _onTranscriptionComplete(cs, ep) {
     this.logger.debug('TaskGather:_onTranscriptionComplete');
@@ -673,12 +609,6 @@ class TaskGather extends Task {
       return this._resolve('timeout');
     }
   }
-  _onSonioxError(cs, ep, evt) {
-    this.logger.info({evt}, 'TaskGather:_onSonioxError');
-  }
-  _onNvidiaError(cs, ep, evt) {
-    this.logger.info({evt}, 'TaskGather:_onNvidiaError');
-  }
   _onDeepgramConnect(_cs, _ep) {
     this.logger.debug('TaskGather:_onDeepgramConnect');
   }
@@ -693,7 +623,7 @@ class TaskGather extends Task {
       message: `Failed connecting to Deepgram speech recognizer: ${reason}`,
       vendor: 'deepgram',
     }).catch((err) => this.logger.info({err}, 'Error generating alert for deepgram connection failure'));
-    this.notifyError({msg: 'ASR error', details:`Failed connecting to speech vendor deepgram: ${reason}`});
+    this.notifyError(`Failed connecting to speech vendor deepgram: ${reason}`);
     this.notifyTaskDone();
   }
 
@@ -711,7 +641,7 @@ class TaskGather extends Task {
       message: `Failed connecting to IBM watson speech recognizer: ${reason}`,
       vendor: 'ibm',
     }).catch((err) => this.logger.info({err}, 'Error generating alert for IBM connection failure'));
-    this.notifyError({msg: 'ASR error', details:`Failed connecting to speech vendor IBM: ${reason}`});
+    this.notifyError(`Failed connecting to speech vendor IBM: ${reason}`);
     this.notifyTaskDone();
   }
 

lib/tasks/lex.js

@@ -1,6 +1,6 @@
 const Task = require('./task');
 const {TaskName, TaskPreconditions} = require('../utils/constants');
-const { normalizeJambones } = require('@jambonz/verb-specifications');
+const normalizeJambones = require('../utils/normalize-jambones');
 
 class Lex extends Task {
   constructor(logger, opts) {

lib/tasks/make_task.js

@@ -1,4 +1,4 @@
-const { validateVerb } = require('@jambonz/verb-specifications');
+const Task = require('./task');
 const {TaskName} = require('../utils/constants');
 const errBadInstruction = new Error('malformed jambonz application payload');
 
@@ -12,7 +12,7 @@ function makeTask(logger, obj, parent) {
   if (typeof data !== 'object') {
     throw errBadInstruction;
   }
-  validateVerb(name, data, logger);
+  Task.validate(name, data);
   switch (name) {
     case TaskName.SipDecline:
       const TaskSipDecline = require('./sip_decline');

lib/tasks/play.js

@@ -37,7 +37,6 @@ class TaskPlay extends Task {
       }, this.timeoutSecs * 1000);
     }
     try {
-      this.notifyStatus({event: 'start-playback'});
       while (!this.killed && (this.loop === 'forever' || this.loop--) && this.ep.connected) {
         if (cs.isInConference) {
           const {memberId, confName, confUuid} = cs;
@@ -81,8 +80,7 @@ class TaskPlay extends Task {
         this.killPlayToConfMember(this.ep, memberId, confName);
       }
       else {
-        this.notifyStatus({event: 'kill-playback'});
-        this.ep.api('uuid_break', this.ep.uuid).catch((err) => this.logger.info(err, 'Error killing audio'));
+        await this.ep.api('uuid_break', this.ep.uuid).catch((err) => this.logger.info(err, 'Error killing audio'));
       }
     }
   }

lib/tasks/rest_dial.js

@@ -1,7 +1,7 @@
 const Task = require('./task');
 const {TaskName} = require('../utils/constants');
 const makeTask = require('./make_task');
-const { normalizeJambones } = require('@jambonz/verb-specifications');
+const normalizeJambones = require('../utils/normalize-jambones');
 
 /**
  * Manages an outdial made via REST API
@@ -27,7 +27,7 @@ class TaskRestDial extends Task {
   */
   async exec(cs) {
     await super.exec(cs);
-    this.canCancel = true;
+    this.req = cs.req;
 
     this._setCallTimer();
     await this.awaitTaskDone();
@@ -36,15 +36,15 @@ class TaskRestDial extends Task {
   kill(cs) {
     super.kill(cs);
     this._clearCallTimer();
-    if (this.canCancel && cs?.req) {
-      this.canCancel = false;
-      cs.req.cancel();
+    if (this.req) {
+      this.req.cancel();
+      this.req = null;
     }
     this.notifyTaskDone();
   }
 
   async _onConnect(dlg) {
-    this.canCancel = false;
+    this.req = null;
     const cs = this.callSession;
     cs.setDialog(dlg);
 
@@ -79,7 +79,7 @@ class TaskRestDial extends Task {
   _onCallStatus(status) {
     this.logger.debug(`CallStatus: ${status}`);
     if (status >= 200) {
-      this.canCancel = false;
+      this.req = null;
       this._clearCallTimer();
       if (status !== 200) this.notifyTaskDone();
     }

lib/tasks/specs.json

@@ -0,0 +1,777 @@
+{
+  "sip:decline": {
+    "properties": {
+      "id": "string",
+      "status": "number",
+      "reason": "string",
+      "headers": "object"
+    },
+    "required": [
+      "status"
+    ]
+  },
+  "sip:request": {
+    "properties": {
+      "id": "string",
+      "method": "string",
+      "body": "string",
+      "headers": "object",
+      "actionHook": "object|string"
+    },
+    "required": [
+      "method"
+    ]
+  },
+  "sip:refer": {
+    "properties": {
+      "id": "string",
+      "referTo": "string",
+      "referredBy": "string",
+      "headers": "object",
+      "actionHook": "object|string",
+      "eventHook": "object|string"
+    },
+    "required": [
+      "referTo"
+    ]
+  },
+  "config": {
+    "properties": {
+      "id": "string",
+      "synthesizer": "#synthesizer",
+      "recognizer": "#recognizer",
+      "bargeIn": "#bargeIn",
+      "record": "#recordOptions",
+      "listen": "#listenOptions",
+      "amd": "#amd",
+      "notifyEvents": "boolean"
+    },
+    "required": []
+  },
+  "listenOptions": {
+    "properties": {
+      "enable": "boolean",
+      "url": "string",
+      "sampleRate": "number",
+      "wsAuth": "#auth",
+      "metadata": "object",
+      "mixType": {
+        "type": "string",
+        "enum": ["mono", "stereo", "mixed"]
+      }
+    },
+    "required": [
+      "enable"
+    ]
+  },
+  "bargeIn": {
+    "properties": {
+      "enable": "boolean",
+      "sticky": "boolean",
+      "actionHook": "object|string",
+      "input": "array",
+      "finishOnKey": "string",
+      "numDigits": "number",
+      "minDigits": "number",
+      "maxDigits": "number",
+      "interDigitTimeout": "number",
+      "dtmfBargein": "boolean",
+      "minBargeinWordCount": "number"
+    },
+    "required": [
+      "enable"
+    ]
+  },
+  "dequeue": {
+    "properties": {
+      "id": "string",
+      "name": "string",
+      "actionHook": "object|string",
+      "timeout": "number",
+      "beep": "boolean"
+    },
+    "required": [
+      "name"
+    ]
+  },
+  "enqueue": {
+    "properties": {
+      "id": "string",
+      "name": "string",
+      "actionHook": "object|string",
+      "waitHook": "object|string",
+      "_": "object"
+    },
+    "required": [
+      "name"
+    ]
+  },
+  "leave": {
+    "properties": {
+      "id": "string"
+    }
+  },
+  "hangup": {
+    "properties": {
+      "id": "string",
+      "headers": "object"
+    },
+    "required": [
+    ]
+  },
+  "play": {
+    "properties": {
+      "id": "string",
+      "url": "string|array",
+      "loop": "number|string",
+      "earlyMedia": "boolean",
+      "seekOffset": "number|string",
+      "timeoutSecs": "number|string",
+      "actionHook": "object|string"
+    },
+    "required": [
+      "url"
+    ]
+  },
+  "say": {
+    "properties": {
+      "id": "string",
+      "text": "string|array",
+      "loop": "number|string",
+      "synthesizer": "#synthesizer",
+      "earlyMedia": "boolean",
+      "disableTtsCache": "boolean"
+    },
+    "required": [
+      "text"
+    ]
+  },
+  "gather": {
+    "properties": {
+      "id": "string",
+      "actionHook": "object|string",
+      "finishOnKey": "string",
+      "input": "array",
+      "numDigits": "number",
+      "minDigits": "number",
+      "maxDigits": "number",
+      "interDigitTimeout": "number",
+      "partialResultHook": "object|string",
+      "speechTimeout": "number",
+      "listenDuringPrompt": "boolean",
+      "dtmfBargein": "boolean",
+      "bargein": "boolean",
+      "minBargeinWordCount": "number",
+      "timeout": "number",
+      "recognizer": "#recognizer",
+      "play": "#play",
+      "say": "#say"
+    },
+    "required": [
+    ]
+  },
+  "conference": {
+    "properties": {
+      "id": "string",
+      "name": "string",
+      "beep": "boolean",
+      "startConferenceOnEnter": "boolean",
+      "endConferenceOnExit": "boolean",
+      "maxParticipants": "number",
+      "joinMuted": "boolean",
+      "actionHook": "object|string",
+      "waitHook": "object|string",
+      "statusEvents": "array",
+      "statusHook": "object|string",
+      "enterHook": "object|string",
+      "record": "#record"
+    },
+    "required": [
+      "name"
+    ]
+  },
+  "dial": {
+    "properties": {
+      "id": "string",
+      "actionHook": "object|string",
+      "answerOnBridge": "boolean",
+      "callerId": "string",
+      "confirmHook": "object|string",
+      "referHook": "object|string",
+      "dialMusic": "string",
+      "dtmfCapture": "object",
+      "dtmfHook": "object|string",
+      "headers": "object",
+      "listen": "#listen",
+      "target": ["#target"],
+      "timeLimit": "number",
+      "timeout": "number",
+      "proxy": "string",
+      "transcribe": "#transcribe",
+      "amd": "#amd"
+    },
+    "required": [
+      "target"
+    ]
+  },
+  "dialogflow": {
+    "properties": {
+      "id": "string",
+      "credentials": "object|string",
+      "project": "string",
+      "environment": "string",
+      "region": {
+        "type": "string",
+        "enum": ["europe-west1", "europe-west2", "australia-southeast1", "asia-northeast1"]
+      },
+      "lang": "string",
+      "actionHook": "object|string",
+      "eventHook": "object|string",
+      "events": "[string]",
+      "welcomeEvent": "string",
+      "welcomeEventParams": "object",
+      "noInputTimeout": "number",
+      "noInputEvent": "string",
+      "passDtmfAsTextInput": "boolean",
+      "thinkingMusic": "string",
+      "tts": "#synthesizer",
+      "bargein": "boolean"
+    },
+    "required": [
+      "project",
+      "credentials",
+      "lang"
+    ]
+  },
+  "dtmf": {
+    "properties": {
+      "id": "string",
+      "dtmf": "string",
+      "duration": "number"
+    },
+    "required": [
+      "dtmf"
+    ]
+  },
+  "lex": {
+    "properties": {
+      "id": "string",
+      "botId": "string",
+      "botAlias": "string",
+      "credentials": "object",
+      "region": "string",
+      "locale": "string",
+      "intent": "#lexIntent",
+      "welcomeMessage": "string",
+      "metadata": "object",
+      "bargein": "boolean",
+      "passDtmf": "boolean",
+      "actionHook": "object|string",
+      "eventHook": "object|string",
+      "noInputTimeout": "number",
+      "tts": "#synthesizer"
+    },
+    "required": [
+      "botId",
+      "botAlias",
+      "region",
+      "credentials"
+    ]
+  },
+  "listen": {
+    "properties": {
+      "id": "string",
+      "actionHook": "object|string",
+      "auth": "#auth",
+      "finishOnKey": "string",
+      "maxLength": "number",
+      "metadata": "object",
+      "mixType": {
+        "type": "string",
+        "enum": ["mono", "stereo", "mixed"]
+      },
+      "passDtmf": "boolean",
+      "playBeep": "boolean",
+      "disableBidirectionalAudio": "boolean",
+      "sampleRate": "number",
+      "timeout": "number",
+      "transcribe": "#transcribe",
+      "url": "string",
+      "wsAuth": "#auth",
+      "earlyMedia": "boolean"
+    },
+    "required": [
+      "url"
+    ]
+  },
+  "message": {
+    "properties": {
+      "id": "string",
+      "carrier": "string",
+      "account_sid": "string",
+      "message_sid": "string",
+      "to": "string",
+      "from": "string",
+      "text": "string",
+      "media": "string|array",
+      "actionHook": "object|string"
+    },
+    "required": [
+      "to",
+      "from"
+    ]
+  },
+  "pause": {
+    "properties": {
+      "id": "string",
+      "length": "number"
+    },
+    "required": [
+      "length"
+    ]
+  },
+  "rasa": {
+    "properties": {
+      "id": "string",
+      "url": "string",
+      "recognizer": "#recognizer",
+      "tts": "#synthesizer",
+      "prompt": "string",
+      "actionHook": "object|string",
+      "eventHook": "object|string"
+    },
+    "required": [
+      "url"
+    ]
+  },
+  "record": {
+    "properties": {
+      "path": "string"
+    },
+    "required": [
+      "path"
+    ]
+  },
+  "recordOptions": {
+    "properties": {
+      "action": {
+        "type": "string",
+        "enum": ["startCallRecording", "stopCallRecording", "pauseCallRecording", "resumeCallRecording"]
+      },
+      "recordingID": "string",
+      "siprecServerURL": "string"
+    },
+    "required": [
+      "action"
+    ]
+  },
+  "redirect": {
+    "properties": {
+      "id": "string",
+      "actionHook": "object|string"
+    },
+    "required": [
+      "actionHook"
+    ]
+  },
+  "rest:dial": {
+    "properties": {
+      "id": "string",
+      "account_sid": "string",
+      "application_sid": "string",
+      "call_hook": "object|string",
+      "call_status_hook": "object|string",
+      "from": "string",
+      "fromHost": "string",
+      "speech_synthesis_vendor": "string",
+      "speech_synthesis_voice": "string",
+      "speech_synthesis_language": "string",
+      "speech_recognizer_vendor": "string",
+      "speech_recognizer_language": "string",
+      "tag": "object",
+      "to": "#target",
+      "headers": "object",
+      "timeout": "number"
+    },
+    "required": [
+      "call_hook",
+      "from",
+      "to"
+    ]
+  },
+  "tag": {
+    "properties": {
+      "id": "string",
+      "data": "object"
+    },
+    "required": [
+      "data"
+    ]
+  },
+  "transcribe": {
+    "properties": {
+      "id": "string",
+      "transcriptionHook": "string",
+      "recognizer": "#recognizer",
+      "earlyMedia": "boolean"
+    },
+    "required": [
+      "recognizer"
+    ]
+  },
+  "target": {
+    "properties": {
+      "type": {
+        "type": "string",
+        "enum": ["phone", "sip", "user", "teams"]
+      },
+      "confirmHook": "object|string",
+      "method": {
+        "type": "string",
+        "enum": ["GET", "POST"]
+      },
+      "headers": "object",
+      "from": "#dialFrom",
+      "name": "string",
+      "number": "string",
+      "sipUri": "string",
+      "auth": "#auth",
+      "vmail": "boolean",
+      "tenant": "string",
+      "trunk": "string",
+      "overrideTo": "string"
+    },
+    "required": [
+      "type"
+    ]
+  },
+  "dialFrom": {
+    "properties": {
+      "user": "string",
+      "host": "string"
+    },
+    "required": [
+    ]
+  },
+  "auth": {
+    "properties": {
+      "username": "string",
+      "password": "string"
+    },
+    "required": [
+      "username",
+      "password"
+    ]
+  },
+  "synthesizer": {
+    "properties": {
+      "vendor": {
+        "type": "string",
+        "enum": ["google", "aws", "polly", "microsoft", "nuance", "ibm", "default"]
+      },
+      "language": "string",
+      "voice": "string",
+      "engine": {
+        "type": "string",
+        "enum": ["standard", "neural"]
+      },
+      "gender": {
+        "type": "string",
+        "enum": ["MALE", "FEMALE", "NEUTRAL"]
+      }
+    },
+    "required": [
+      "vendor"
+    ]
+  },
+  "recognizer": {
+    "properties": {
+      "vendor": {
+        "type": "string",
+        "enum": ["google", "aws", "microsoft", "nuance", "deepgram", "ibm", "default"]
+      },
+      "language": "string",
+      "vad": "#vad",
+      "hints": "array",
+      "hintsBoost": "number",
+      "altLanguages": "array",
+      "profanityFilter": "boolean",
+      "interim": "boolean",
+      "singleUtterance": "boolean",
+      "dualChannel": "boolean",
+      "separateRecognitionPerChannel": "boolean",
+      "punctuation": "boolean",
+      "enhancedModel": "boolean",
+      "words": "boolean",
+      "diarization": "boolean",
+      "diarizationMinSpeakers": "number",
+      "diarizationMaxSpeakers": "number",
+      "interactionType": {
+        "type": "string",
+        "enum": [
+          "unspecified",
+          "discussion",
+          "presentation",
+          "phone_call",
+          "voicemail",
+          "voice_search",
+          "voice_command",
+          "dictation"
+        ]
+      },
+      "naicsCode": "number",
+      "identifyChannels": "boolean",
+      "vocabularyName": "string",
+      "vocabularyFilterName": "string",
+      "filterMethod": {
+        "type": "string",
+        "enum": [
+          "remove",
+          "mask",
+          "tag"
+        ]
+      },
+      "model": "string",
+      "outputFormat": {
+        "type": "string",
+        "enum": [
+          "simple",
+          "detailed"
+        ]
+      },
+      "profanityOption": {
+        "type": "string",
+        "enum": [
+          "masked",
+          "removed",
+          "raw"
+        ]
+      },
+      "requestSnr": "boolean",
+      "initialSpeechTimeoutMs": "number",
+      "azureServiceEndpoint": "string",
+      "azureSttEndpointId": "string",
+      "asrDtmfTerminationDigit": "string",
+      "asrTimeout": "number",
+      "nuanceOptions": "#nuanceOptions",
+      "deepgramOptions": "#deepgramOptions",
+      "ibmOptions": "#ibmOptions"
+    },
+    "required": [
+      "vendor"
+    ]
+  },
+  "ibmOptions": {
+    "properties": {
+      "sttApiKey": "string",
+      "sttRegion": "string",
+      "ttsApiKey": "string",
+      "ttsRegion": "string",
+      "instanceId": "string",
+      "model": "string",
+      "languageCustomizationId": "string",
+      "acousticCustomizationId": "string",
+      "baseModelVersion": "string",
+      "watsonMetadata": "string",
+      "watsonLearningOptOut": "boolean"
+    },
+    "required": [
+    ]
+  },
+  "deepgramOptions": {
+    "properties": {
+      "apiKey": "string",
+      "tier": {
+        "type": "string",
+        "enum": [
+          "enhanced",
+          "base"
+        ]
+      },
+      "model": {
+        "type": "string",
+        "enum": [
+          "general",
+          "meeting",
+          "phonecall",
+          "voicemail",
+          "finance",
+          "conversationalai",
+          "video",
+          "custom"
+        ]
+      },
+      "customModel": "string",
+      "version": "string",
+      "punctuate": "boolean",
+      "profanityFilter": "boolean",
+      "redact": {
+        "type": "string",
+        "enum": [
+          "pci",
+          "numbers",
+          "true",
+          "ssn"
+        ]
+      },
+      "diarize": "boolean",
+      "diarizeVersion": "string",
+      "ner": "boolean",
+      "multichannel": "boolean",
+      "alternatives": "number",
+      "numerals": "boolean",
+      "search": "array",
+      "replace": "array",
+      "keywords": "array",
+      "endpointing": "boolean",
+      "vadTurnoff": "number",
+      "tag": "string"
+    }
+  },
+  "nuanceOptions": {
+    "properties": {
+      "clientId": "string",
+      "secret": "string",
+      "kryptonEndpoint": "string",
+      "topic": "string",
+      "utteranceDetectionMode": {
+        "type": "string",
+        "enum": [
+          "single",
+          "multiple",
+          "disabled"
+        ]
+      },
+      "punctuation": "boolean",
+      "profanityFilter": "boolean",
+      "includeTokenization": "boolean",
+      "discardSpeakerAdaptation": "boolean",
+      "suppressCallRecording": "boolean",
+      "maskLoadFailures": "boolean",
+      "suppressInitialCapitalization": "boolean",
+      "allowZeroBaseLmWeight": "boolean",
+      "filterWakeupWord": "boolean",
+      "resultType": {
+        "type": "string",
+        "enum": [
+          "final",
+          "partial",
+          "immutable_partial"
+        ]
+      },
+      "noInputTimeoutMs": "number",
+      "recognitionTimeoutMs": "number",
+      "utteranceEndSilenceMs": "number",
+      "maxHypotheses": "number",
+      "speechDomain": "string",
+      "formatting": "#formatting",
+      "clientData": "object",
+      "userId": "string",
+      "speechDetectionSensitivity": "number",
+      "resources": ["#resource"]
+    },
+    "required": [
+    ]
+  },
+  "resource": {
+    "properties": {
+      "externalReference": "#resourceReference",
+      "inlineWordset": "string",
+      "builtin": "string",
+      "inlineGrammar": "string",
+      "wakeupWord": "[string]",
+      "weightName": {
+        "type": "string",
+        "enum": [
+          "defaultWeight",
+          "lowest",
+          "low",
+          "medium",
+          "high",
+          "highest"
+        ]
+      },
+      "weightValue": "number",
+      "reuse": {
+        "type": "string",
+        "enum": [
+          "undefined_reuse",
+          "low_reuse",
+          "high_reuse"
+        ]
+      }
+    },
+    "required": [
+    ]
+  },
+  "resourceReference": {
+    "properties": {
+      "type": {
+        "type": "string",
+        "enum": [
+          "undefined_resource_type",
+          "wordset",
+          "compiled_wordset",
+          "domain_lm",
+          "speaker_profile",
+          "grammar",
+          "settings"
+        ]
+      },
+      "uri": "string",
+      "maxLoadFailures": "boolean",
+      "requestTimeoutMs": "number",
+      "headers": "object"
+    },
+    "required": [
+    ]
+  },
+  "formatting": {
+    "properties": {
+      "scheme": "string",
+      "options": "object"
+    },
+    "required": [
+      "scheme",
+      "options"
+    ]
+  },
+  "lexIntent": {
+    "properties": {
+      "name": "string",
+      "slots": "object"
+    },
+    "required": [
+      "name"
+    ]
+  },
+  "vad": {
+    "properties": {
+      "enable": "boolean",
+      "voiceMs": "number",
+      "mode": "number"
+    },
+    "required": [
+      "enable"
+    ]
+  },
+  "amd": {
+    "properties": {
+      "actionHook": "object|string",
+      "thresholdWordCount": "number",
+      "timers": "#amdTimers",
+      "recognizer": "#recognizer"
+    },
+    "required": [
+      "actionHook"
+    ]
+  },
+  "amdTimers": {
+    "properties": {
+      "noSpeechTimeoutMs": "number",
+      "decisionTimeoutMs": "number",
+      "toneTimeoutMs": "number",
+      "greetingCompletionTimeoutMs": "number"
+    }
+  }
+}

lib/tasks/task.js

@@ -1,10 +1,15 @@
 const Emitter = require('events');
 const uuidv4 = require('uuid-random');
+const debug = require('debug')('jambonz:feature-server');
+const assert = require('assert');
 const {TaskPreconditions} = require('../utils/constants');
-const { normalizeJambones } = require('@jambonz/verb-specifications');
+const normalizeJambones = require('../utils/normalize-jambones');
 const WsRequestor = require('../utils/ws-requestor');
 const {TaskName} = require('../utils/constants');
 const {trace} = require('@opentelemetry/api');
+const specs = new Map();
+const _specData = require('./specs');
+for (const key in _specData) {specs.set(key, _specData[key]);}
 
 /**
  * @classdesc Represents a jambonz verb. This is a superclass that is extended
@@ -282,6 +287,77 @@ class Task extends Emitter {
       this.logger.error(err, 'Task:_doRefer error');
     }
   }
+
+  /**
+   * validate that the JSON task description is valid
+   * @param {string} name - verb name
+   * @param {object} data - verb properties
+   */
+  static validate(name, data) {
+    debug(`validating ${name} with data ${JSON.stringify(data)}`);
+    // validate the instruction is supported
+    if (!specs.has(name)) throw new Error(`invalid instruction: ${name}`);
+
+    // check type of each element and make sure required elements are present
+    const specData = specs.get(name);
+    let required = specData.required || [];
+    for (const dKey in data) {
+      if (dKey in specData.properties) {
+        const dVal = data[dKey];
+        const dSpec = specData.properties[dKey];
+        debug(`Task:validate validating property ${dKey} with value ${JSON.stringify(dVal)}`);
+
+        if (typeof dSpec === 'string' && dSpec === 'array') {
+          if (!Array.isArray(dVal)) throw new Error(`${name}: property ${dKey} is not an array`);
+        }
+        else if (typeof dSpec === 'string' && dSpec.includes('|')) {
+          const types = dSpec.split('|').map((t) => t.trim());
+          if (!types.includes(typeof dVal) && !(types.includes('array') && Array.isArray(dVal))) {
+            throw new Error(`${name}: property ${dKey} has invalid data type, must be one of ${types}`);
+          }
+        }
+        else if (typeof dSpec === 'string' && ['number', 'string', 'object', 'boolean'].includes(dSpec)) {
+          // simple types
+          if (typeof dVal !== specData.properties[dKey]) {
+            throw new Error(`${name}: property ${dKey} has invalid data type`);
+          }
+        }
+        else if (Array.isArray(dSpec) && dSpec[0].startsWith('#')) {
+          const name = dSpec[0].slice(1);
+          for (const item of dVal) {
+            Task.validate(name, item);
+          }
+        }
+        else if (typeof dSpec === 'object') {
+          // complex types
+          const type = dSpec.type;
+          assert.ok(['number', 'string', 'object', 'boolean'].includes(type),
+            `invalid or missing type in spec ${JSON.stringify(dSpec)}`);
+          if (type === 'string' && dSpec.enum) {
+            assert.ok(Array.isArray(dSpec.enum), `enum must be an array ${JSON.stringify(dSpec.enum)}`);
+            if (!dSpec.enum.includes(dVal)) throw new Error(`invalid value ${dVal} must be one of ${dSpec.enum}`);
+          }
+        }
+        else if (typeof dSpec === 'string' && dSpec.startsWith('#')) {
+          // reference to another datatype (i.e. nested type)
+          const name = dSpec.slice(1);
+          //const obj = {};
+          //obj[name] = dVal;
+          Task.validate(name, dVal);
+        }
+        else {
+          assert.ok(0, `invalid spec ${JSON.stringify(dSpec)}`);
+        }
+        required = required.filter((item) => item !== dKey);
+      }
+      else if (dKey === '_') {
+        /* no op: allow arbitrary info to be carried here, used by conference e.g in transfer */
+      }
+      else throw new Error(`${name}: unknown property ${dKey}`);
+    }
+    if (required.length > 0) throw new Error(`${name}: missing value for ${required}`);
+  }
+
 }
 
 module.exports = Task;

lib/tasks/transcribe.js

@@ -3,15 +3,13 @@ const {
   TaskName,
   TaskPreconditions,
   GoogleTranscriptionEvents,
-  NuanceTranscriptionEvents,
-  AwsTranscriptionEvents,
   AzureTranscriptionEvents,
+  AwsTranscriptionEvents,
+  NuanceTranscriptionEvents,
   DeepgramTranscriptionEvents,
-  SonioxTranscriptionEvents,
-  IbmTranscriptionEvents,
-  NvidiaTranscriptionEvents
+  IbmTranscriptionEvents
 } = require('../utils/constants');
-const { normalizeJambones } = require('@jambonz/verb-specifications');
+const normalizeJambones = require('../utils/normalize-jambones');
 
 class TaskTranscribe extends Task {
   constructor(logger, opts, parentTask) {
@@ -196,12 +194,7 @@ class TaskTranscribe extends Task {
         ep.addCustomEventListener(DeepgramTranscriptionEvents.ConnectFailure,
           this._onDeepGramConnectFailure.bind(this, cs, ep, channel));
         break;
-      case 'soniox':
-        this.bugname = 'soniox_transcribe';
-        ep.addCustomEventListener(SonioxTranscriptionEvents.Transcription, this._onTranscription.bind(this, cs, ep));
-        ep.addCustomEventListener(SonioxTranscriptionEvents.Error,
-          this._onSonioxError.bind(this, cs, ep));
-        break;
+
       case 'ibm':
         this.bugname = 'ibm_transcribe';
         ep.addCustomEventListener(IbmTranscriptionEvents.Transcription,
@@ -214,20 +207,6 @@ class TaskTranscribe extends Task {
           this._onIbmError.bind(this, cs, ep, channel));
         break;
 
-      case 'nvidia':
-        this.bugname = 'nvidia_transcribe';
-        ep.addCustomEventListener(NvidiaTranscriptionEvents.Transcription,
-          this._onTranscription.bind(this, cs, ep));
-        ep.addCustomEventListener(NvidiaTranscriptionEvents.StartOfSpeech,
-          this._onStartOfSpeech.bind(this, cs, ep));
-        ep.addCustomEventListener(NvidiaTranscriptionEvents.TranscriptionComplete,
-          this._onTranscriptionComplete.bind(this, cs, ep));
-        ep.addCustomEventListener(NvidiaTranscriptionEvents.VadDetected,
-          this._onVadDetected.bind(this, cs, ep));
-        ep.addCustomEventListener(NvidiaTranscriptionEvents.Error,
-          this._onNvidiaError.bind(this, cs, ep));
-        break;
-
       default:
         throw new Error(`Invalid vendor ${this.vendor}`);
     }
@@ -332,12 +311,6 @@ class TaskTranscribe extends Task {
       return this._resolve('timeout');
     }
   }
-  _onSonioxError(cs, ep, evt) {
-    this.logger.info({evt}, 'TaskTranscribe:_onSonioxError');
-  }
-  _onNvidiaError(cs, ep, evt) {
-    this.logger.info({evt}, 'TaskTranscribe:_onNvidiaError');
-  }
   _onDeepgramConnect(_cs, _ep) {
     this.logger.debug('TaskTranscribe:_onDeepgramConnect');
   }
@@ -374,7 +347,7 @@ class TaskTranscribe extends Task {
     this.notifyTaskDone();
   }
   _onIbmError(cs, _ep, _channel, evt) {
-    this.logger.info({evt}, 'TaskTranscribe:_onIbmError');
+    this.logger.info({evt}, 'TaskGather:_onIbmError');
   }
 
 

lib/utils/constants.json

@@ -74,22 +74,11 @@
     "Error": "nuance_transcribe::error",
     "VadDetected": "nuance_transcribe::vad_detected"
   },
-  "NvidiaTranscriptionEvents": {
-    "Transcription": "nvidia_transcribe::transcription",
-    "StartOfSpeech": "nvidia_transcribe::start_of_speech",
-    "TranscriptionComplete": "nvidia_transcribe::end_of_transcription",
-    "Error": "nvidia_transcribe::error",
-    "VadDetected": "nvidia_transcribe::vad_detected"
-  },
   "DeepgramTranscriptionEvents": {
     "Transcription": "deepgram_transcribe::transcription",
     "ConnectFailure": "deepgram_transcribe::connect_failed",
     "Connect": "deepgram_transcribe::connect"
   },
-  "SonioxTranscriptionEvents": {
-    "Transcription": "soniox_transcribe::transcription",
-    "Error": "soniox_transcribe::error"
-  },
   "IbmTranscriptionEvents": {
     "Transcription": "ibm_transcribe::transcription",
     "ConnectFailure": "ibm_transcribe::connect_failed",
@@ -151,7 +140,6 @@
     "queue:status",
     "dial:confirm",
     "verb:hook",
-    "verb:status",
     "jambonz:error"
   ],
   "RecordState": {

lib/utils/db-utils.js

@@ -62,10 +62,6 @@ const speechMapper = (cred) => {
       const o = JSON.parse(decrypt(credential));
       obj.api_key = o.api_key;
     }
-    else if ('soniox' === obj.vendor) {
-      const o = JSON.parse(decrypt(credential));
-      obj.api_key = o.api_key;
-    }
   } catch (err) {
     console.log(err);
   }
@@ -90,10 +86,8 @@ module.exports = (logger, srf) => {
     const haveWellsaid = speech.find((s) => s.vendor === 'wellsaid');
     const haveNuance = speech.find((s) => s.vendor === 'nuance');
     const haveDeepgram = speech.find((s) => s.vendor === 'deepgram');
-    const haveSoniox = speech.find((s) => s.vendor === 'soniox');
     const haveIbm = speech.find((s) => s.vendor === 'ibm');
-    if (!haveGoogle || !haveAws || !haveMicrosoft || !haveWellsaid ||
-      !haveNuance || !haveIbm || !haveDeepgram || !haveSoniox) {
+    if (!haveGoogle || !haveAws || !haveMicrosoft || !haveWellsaid || !haveNuance || !haveIbm || !haveDeepgram) {
       const [r3] = await pp.query(sqlSpeechCredentialsForSP, account_sid);
       if (r3.length) {
         if (!haveGoogle) {
@@ -120,10 +114,6 @@ module.exports = (logger, srf) => {
           const deepgram = r3.find((s) => s.vendor === 'deepgram');
           if (deepgram) speech.push(speechMapper(deepgram));
         }
-        if (!haveSoniox) {
-          const soniox = r3.find((s) => s.vendor === 'soniox');
-          if (soniox) speech.push(speechMapper(soniox));
-        }
         if (!haveIbm) {
           const ibm = r3.find((s) => s.vendor === 'ibm');
           if (ibm) speech.push(speechMapper(ibm));

lib/utils/http-requestor.js

@@ -2,6 +2,7 @@ const {Client, Pool} = require('undici');
 const parseUrl = require('parse-url');
 const assert = require('assert');
 const BaseRequestor = require('./base-requestor');
+const WsRequestor = require('./ws-requestor');
 const {HookMsgTypes} = require('./constants.json');
 const snakeCaseKeys = require('./snakecase-keys');
 const pools = new Map();
@@ -93,7 +94,6 @@ class HttpRequestor extends BaseRequestor {
 
     /* if we have an absolute url, and it is ws then do a websocket connection */
     if (this._isAbsoluteUrl(url) && url.startsWith('ws')) {
-      const WsRequestor = require('./ws-requestor');
       this.logger.debug({hook}, 'HttpRequestor: switching to websocket connection');
       const h = typeof hook === 'object' ? hook : {url: hook};
       const requestor = new WsRequestor(this.logger, this.account_sid, h, this.secret);

lib/utils/normalize-jambones.js

@@ -0,0 +1,31 @@
+function normalizeJambones(logger, obj) {
+  if (!Array.isArray(obj)) throw new Error('malformed jambonz payload: must be array');
+  const document = [];
+  for (const tdata of obj) {
+    if (typeof tdata !== 'object') throw new Error('malformed jambonz payload: must be array of objects');
+    if ('verb' in tdata) {
+      // {verb: 'say', text: 'foo..bar'..}
+      const name = tdata.verb;
+      const o = {};
+      Object.keys(tdata)
+        .filter((k) => k !== 'verb')
+        .forEach((k) => o[k] = tdata[k]);
+      const o2 = {};
+      o2[name] = o;
+      document.push(o2);
+    }
+    else if (Object.keys(tdata).length === 1) {
+      // {'say': {..}}
+      document.push(tdata);
+    }
+    else {
+      logger.info(tdata, 'malformed jambonz payload: missing verb property');
+      throw new Error('malformed jambonz payload: missing verb property');
+    }
+  }
+  logger.debug({document}, `normalizeJambones: returning document with ${document.length} tasks`);
+  return document;
+}
+
+module.exports = normalizeJambones;
+

lib/utils/place-outdial.js

@@ -4,7 +4,7 @@ const SipError = require('drachtio-srf').SipError;
 const {TaskPreconditions, CallDirection} = require('../utils/constants');
 const CallInfo = require('../session/call-info');
 const assert = require('assert');
-const { normalizeJambones } = require('@jambonz/verb-specifications');
+const normalizeJambones = require('../utils/normalize-jambones');
 const makeTask = require('../tasks/make_task');
 const ConfirmCallSession = require('../session/confirm-call-session');
 const AdultingCallSession = require('../session/adulting-call-session');

lib/utils/sbc-pinger.js

@@ -75,10 +75,6 @@ module.exports = (logger) => {
       }
     })();
   }
-  else if (process.env.K8S) {
-    lifecycleEmitter.scaleIn = () => process.exit(0);
-  }
-
 
   async function pingProxies(srf) {
     if (process.env.NODE_ENV === 'test') return;

lib/utils/transcription-utils.js

@@ -5,8 +5,6 @@ const {
   AwsTranscriptionEvents,
   NuanceTranscriptionEvents,
   DeepgramTranscriptionEvents,
-  SonioxTranscriptionEvents,
-  NvidiaTranscriptionEvents
 } = require('./constants');
 
 const stickyVars = {
@@ -86,73 +84,9 @@ const stickyVars = {
     'IBM_SPEECH_BASE_MODEL_VERSION',
     'IBM_SPEECH_WATSON_METADATA',
     'IBM_SPEECH_WATSON_LEARNING_OPT_OUT'
-  ],
-  nvidia: [
-    'NVIDIA_HINTS'
-  ],
-  soniox: [
-    'SONIOX_PROFANITY_FILTER',
-    'SONIOX_MODEL'
   ]
 };
 
-const compileSonioxTranscripts = (finalWordChunks, channel, language) => {
-  const words = finalWordChunks.flat();
-  const transcript = words.reduce((acc, word) => {
-    if (word.text === '<end>') return acc;
-    if ([',', '.', '?', '!'].includes(word.text)) return `${acc}${word.text}`;
-    return `${acc} ${word.text}`;
-  }, '').trim();
-  const realWords = words.filter((word) => ![',.!?;'].includes(word.text) && word.text !== '<end>');
-  const confidence = realWords.reduce((acc, word) => acc + word.confidence, 0) / realWords.length;
-  const alternatives = [{transcript, confidence}];
-  return {
-    language_code: language,
-    channel_tag: channel,
-    is_final: true,
-    alternatives,
-    vendor: {
-      name: 'soniox',
-      evt: words
-    }
-  };
-};
-
-const normalizeSoniox = (evt, channel, language) => {
-  const copy = JSON.parse(JSON.stringify(evt));
-
-  /* an <end> token indicates the end of an utterance */
-  const endTokenPos = evt.words.map((w) => w.text).indexOf('<end>');
-  const endpointReached = endTokenPos !== -1;
-  const words = endpointReached ? evt.words.slice(0, endTokenPos) : evt.words;
-
-  /* note: we can safely ignore words after the <end> token as they will be returned again */
-  const finalWords = words.filter((word) => word.is_final);
-  const nonFinalWords = words.filter((word) => !word.is_final);
-
-  const is_final = endpointReached && finalWords.length > 0;
-  const transcript = words.reduce((acc, word) => {
-    if ([',', '.', '?', '!'].includes(word.text)) return `${acc}${word.text}`;
-    else return `${acc} ${word.text}`;
-  }, '').trim();
-  const realWords = words.filter((word) => ![',.!?;'].includes(word.text) && word.text !== '<end>');
-  const confidence = realWords.reduce((acc, word) => acc + word.confidence, 0) / realWords.length;
-  const alternatives = [{transcript, confidence}];
-  return {
-    language_code: language,
-    channel_tag: channel,
-    is_final,
-    alternatives,
-    vendor: {
-      name: 'soniox',
-      endpointReached,
-      evt: copy,
-      finalWords,
-      nonFinalWords
-    }
-  };
-};
-
 const normalizeDeepgram = (evt, channel, language) => {
   const copy = JSON.parse(JSON.stringify(evt));
   const alternatives = (evt.channel?.alternatives || [])
@@ -173,25 +107,6 @@ const normalizeDeepgram = (evt, channel, language) => {
   };
 };
 
-const normalizeNvidia = (evt, channel, language) => {
-  const copy = JSON.parse(JSON.stringify(evt));
-  const alternatives = (evt.alternatives || [])
-    .map((alt) => ({
-      confidence: alt.confidence,
-      transcript: alt.transcript,
-    }));
-  return {
-    language_code: language,
-    channel_tag: channel,
-    is_final: evt.is_final,
-    alternatives,
-    vendor: {
-      name: 'nvidia',
-      evt: copy
-    }
-  };
-};
-
 const normalizeIbm = (evt, channel, language) => {
   const copy = JSON.parse(JSON.stringify(evt));
   //const idx = evt.result_index;
@@ -283,7 +198,7 @@ const normalizeAws = (evt, channel, language) => {
 module.exports = (logger) => {
   const normalizeTranscription = (evt, vendor, channel, language) => {
 
-    //logger.debug({ evt, vendor, channel, language }, 'normalizeTranscription');
+    logger.debug({ evt, vendor, channel, language }, 'normalizeTranscription');
     switch (vendor) {
       case 'deepgram':
         return normalizeDeepgram(evt, channel, language);
@@ -297,10 +212,6 @@ module.exports = (logger) => {
         return normalizeNuance(evt, channel, language);
       case 'ibm':
         return normalizeIbm(evt, channel, language);
-      case 'nvidia':
-        return normalizeNvidia(evt, channel, language);
-      case 'soniox':
-        return normalizeSoniox(evt, channel, language);
       default:
         logger.error(`Unknown vendor ${vendor}`);
         return evt;
@@ -426,7 +337,7 @@ module.exports = (logger) => {
           {NUANCE_TOPIC: nuanceOptions.topic},
         ...(nuanceOptions.utteranceDetectionMode) &&
           {NUANCE_UTTERANCE_DETECTION_MODE: nuanceOptions.utteranceDetectionMode},
-        ...(nuanceOptions.punctuation || rOpts.punctuation) && {NUANCE_PUNCTUATION: nuanceOptions.punctuation},
+        ...(nuanceOptions.punctuation) && {NUANCE_PUNCTUATION: nuanceOptions.punctuation},
         ...(nuanceOptions.profanityFilter) &&
           {NUANCE_FILTER_PROFANITY: nuanceOptions.profanityFilter},
         ...(nuanceOptions.includeTokenization) &&
@@ -505,29 +416,6 @@ module.exports = (logger) => {
           {DEEPGRAM_SPEECH_TAG: deepgramOptions.tag}
       };
     }
-    else if ('soniox' === rOpts.vendor) {
-      const {sonioxOptions = {}} = rOpts;
-      const {storage = {}} = sonioxOptions;
-      opts = {
-        ...opts,
-        ...(sttCredentials.api_key) &&
-          {SONIOX_API_KEY: sttCredentials.api_key},
-        ...(rOpts.hints.length > 0 && typeof rOpts.hints[0] === 'string' &&
-          {SONIOX_HINTS: rOpts.hints.join(',')}),
-        ...(rOpts.hints.length > 0 && typeof rOpts.hints[0] === 'object' &&
-          {SONIOX_HINTS: JSON.stringify(rOpts.hints)}),
-        ...(typeof rOpts.hintsBoost === 'number' &&
-          {SONIOX_HINTS_BOOST: rOpts.hintsBoost}),
-        ...(sonioxOptions.model) &&
-          {SONIOX_MODEL: sonioxOptions.model},
-        ...((sonioxOptions.profanityFilter || rOpts.profanityFilter) && {SONIOX_PROFANITY_FILTER: 1}),
-        ...(storage?.id && {SONIOX_STORAGE_ID: storage.id}),
-        ...(storage?.id && storage?.title && {SONIOX_STORAGE_TITLE: storage.title}),
-        ...(storage?.id && storage?.disableStoreAudio && {SONIOX_STORAGE_DISABLE_AUDIO: 1}),
-        ...(storage?.id && storage?.disableStoreTranscript && {SONIOX_STORAGE_DISABLE_TRANSCRIPT: 1}),
-        ...(storage?.id && storage?.disableSearch && {SONIOX_STORAGE_DISABLE_SEARCH: 1})
-      };
-    }
     else if ('ibm' === rOpts.vendor) {
       const {ibmOptions = {}} = rOpts;
       opts = {
@@ -552,40 +440,10 @@ module.exports = (logger) => {
           {IBM_SPEECH_WATSON_LEARNING_OPT_OUT: ibmOptions.watsonLearningOptOut}
       };
     }
-    else if ('nvidia' === rOpts.vendor) {
-      const {nvidiaOptions = {}} = rOpts;
-      opts = {
-        ...opts,
-        ...((nvidiaOptions.profanityFilter || rOpts.profanityFilter) && {NVIDIA_PROFANITY_FILTER: 1}),
-        ...(!(nvidiaOptions.profanityFilter || rOpts.profanityFilter) && {NVIDIA_PROFANITY_FILTER: 0}),
-        ...((nvidiaOptions.punctuation || rOpts.punctuation) && {NVIDIA_PUNCTUATION: 1}),
-        ...(!(nvidiaOptions.punctuation || rOpts.punctuation) && {NVIDIA_PUNCTUATION: 0}),
-        ...((rOpts.words || nvidiaOptions.wordTimeOffsets) && {NVIDIA_WORD_TIME_OFFSETS: 1}),
-        ...(!(rOpts.words || nvidiaOptions.wordTimeOffsets) && {NVIDIA_WORD_TIME_OFFSETS: 0}),
-        ...(nvidiaOptions.maxAlternatives && {NVIDIA_MAX_ALTERNATIVES: nvidiaOptions.maxAlternatives}),
-        ...(!nvidiaOptions.maxAlternatives && {NVIDIA_MAX_ALTERNATIVES: 1}),
-        ...(rOpts.model && {NVIDIA_MODEL: rOpts.model}),
-        ...(nvidiaOptions.rivaUri && {NVIDIA_RIVA_URI: nvidiaOptions.rivaUri}),
-        ...(nvidiaOptions.verbatimTranscripts && {NVIDIA_VERBATIM_TRANSCRIPTS: 1}),
-        ...(rOpts.diarization && {NVIDIA_SPEAKER_DIARIZATION: 1}),
-        ...(rOpts.diarization && rOpts.diarizationMaxSpeakers > 0 &&
-          {NVIDIA_DIARIZATION_SPEAKER_COUNT: rOpts.diarizationMaxSpeakers}),
-        ...(rOpts.separateRecognitionPerChannel && {NVIDIA_SEPARATE_RECOGNITION_PER_CHANNEL: 1}),
-        ...(rOpts.hints.length > 0 && typeof rOpts.hints[0] === 'string' &&
-          {NVIDIA_HINTS: rOpts.hints.join(',')}),
-        ...(rOpts.hints.length > 0 && typeof rOpts.hints[0] === 'object' &&
-          {NVIDIA_HINTS: JSON.stringify(rOpts.hints)}),
-        ...(typeof rOpts.hintsBoost === 'number' &&
-          {NVIDIA_HINTS_BOOST: rOpts.hintsBoost}),
-        ...(nvidiaOptions.customConfiguration &&
-          {NVIDIA_CUSTOM_CONFIGURATION: JSON.stringify(nvidiaOptions.customConfiguration)}),
-      };
-    }
-
     stickyVars[rOpts.vendor].forEach((key) => {
       if (!opts[key]) opts[key] = '';
     });
-    //logger.debug({opts}, 'recognizer channel vars');
+    logger.debug({opts}, 'recognizer channel vars');
     return opts;
   };
 
@@ -610,36 +468,18 @@ module.exports = (logger) => {
     ep.removeCustomEventListener(DeepgramTranscriptionEvents.Transcription);
     ep.removeCustomEventListener(DeepgramTranscriptionEvents.Connect);
     ep.removeCustomEventListener(DeepgramTranscriptionEvents.ConnectFailure);
-
-    ep.removeCustomEventListener(SonioxTranscriptionEvents.Transcription);
-    ep.removeCustomEventListener(SonioxTranscriptionEvents.Error);
-
-    ep.removeCustomEventListener(NvidiaTranscriptionEvents.Transcription);
-    ep.removeCustomEventListener(NvidiaTranscriptionEvents.TranscriptionComplete);
-    ep.removeCustomEventListener(NvidiaTranscriptionEvents.StartOfSpeech);
-    ep.removeCustomEventListener(NvidiaTranscriptionEvents.Error);
-    ep.removeCustomEventListener(NvidiaTranscriptionEvents.VadDetected);
   };
 
   const setSpeechCredentialsAtRuntime = (recognizer) => {
     if (!recognizer) return;
     if (recognizer.vendor === 'nuance') {
-      const {clientId, secret, kryptonEndpoint} = recognizer.nuanceOptions || {};
+      const {clientId, secret} = recognizer.nuanceOptions || {};
       if (clientId && secret) return {client_id: clientId, secret};
-      if (kryptonEndpoint) return {krypton_endpoint: kryptonEndpoint};
-    }
-    else if (recognizer.vendor === 'nvidia') {
-      const {rivaUri} = recognizer.nvidiaOptions || {};
-      if (rivaUri) return {riva_uri: rivaUri};
     }
     else if (recognizer.vendor === 'deepgram') {
       const {apiKey} = recognizer.deepgramOptions || {};
       if (apiKey) return {api_key: apiKey};
     }
-    else if (recognizer.vendor === 'soniox') {
-      const {apiKey} = recognizer.sonioxOptions || {};
-      if (apiKey) return {api_key: apiKey};
-    }
     else if (recognizer.vendor === 'ibm') {
       const {ttsApiKey, ttsRegion, sttApiKey, sttRegion, instanceId} = recognizer.ibmOptions || {};
       if (ttsApiKey || sttApiKey) return {
@@ -656,7 +496,6 @@ module.exports = (logger) => {
     normalizeTranscription,
     setChannelVarsForStt,
     removeSpeechListeners,
-    setSpeechCredentialsAtRuntime,
-    compileSonioxTranscripts
+    setSpeechCredentialsAtRuntime
   };
 };

lib/utils/ws-requestor.js

@@ -4,6 +4,7 @@ const short = require('short-uuid');
 const {HookMsgTypes} = require('./constants.json');
 const Websocket = require('ws');
 const snakeCaseKeys = require('./snakecase-keys');
+const HttpRequestor = require('./http-requestor');
 const MAX_RECONNECTS = 5;
 const RESPONSE_TIMEOUT_MS = process.env.JAMBONES_WS_API_MSG_RESPONSE_TIMEOUT || 5000;
 
@@ -44,7 +45,7 @@ class WsRequestor extends BaseRequestor {
       return;
     }
     if (this.closedGracefully) {
-      this.logger.debug(`WsRequestor:request - discarding ${type} because socket was closed gracefully`);
+      this.logger.debug(`WsRequestor:request - discarding ${type} because we closed the socket`);
       return;
     }
 
@@ -52,7 +53,6 @@ class WsRequestor extends BaseRequestor {
 
     /* if we have an absolute url, and it is http then do a standard webhook */
     if (this._isAbsoluteUrl(url) && url.startsWith('http')) {
-      const HttpRequestor = require('./http-requestor');
       this.logger.debug({hook}, 'WsRequestor: sending a webhook (HTTP)');
       const h = typeof hook === 'object' ? hook : {url: hook};
       const requestor = new HttpRequestor(this.logger, this.account_sid, h, this.secret);
@@ -96,9 +96,6 @@ class WsRequestor extends BaseRequestor {
     assert.ok(url, 'WsRequestor:request url was not provided');
 
     const msgid = short.generate();
-    // save initial msgid in case we need to reconnect during initial session:new
-    if (type === 'session:new') this._initMsgId = msgid;
-
     const b3 = httpHeaders?.b3 ? {b3: httpHeaders.b3} : {};
     const obj = {
       type,
@@ -121,18 +118,8 @@ class WsRequestor extends BaseRequestor {
 
     //this.logger.debug({obj}, `websocket: sending (${url})`);
 
-    /* special case: reconnecting before we received ack to session:new */
-    let reconnectingWithoutAck = false;
-    if (type === 'session:reconnect' && this._initMsgId) {
-      reconnectingWithoutAck = true;
-      const obj = this.messagesInFlight.get(this._initMsgId);
-      this.messagesInFlight.delete(this._initMsgId);
-      this.messagesInFlight.set(msgid, obj);
-      this._initMsgId = msgid;
-    }
-
     /* simple notifications */
-    if (['call:status', 'verb:status', 'jambonz:error'].includes(type) || reconnectingWithoutAck) {
+    if (['call:status', 'jambonz:error', 'session:reconnect'].includes(type)) {
       this.ws.send(JSON.stringify(obj), () => {
         this.logger.debug({obj}, `WsRequestor:request websocket: sent (${url})`);
         sendQueuedMsgs();
@@ -144,7 +131,7 @@ class WsRequestor extends BaseRequestor {
     return new Promise((resolve, reject) => {
       /* give the far end a reasonable amount of time to ack our message */
       const timer = setTimeout(() => {
-        const {failure} = this.messagesInFlight.get(msgid) || {};
+        const {failure} = this.messagesInFlight.get(msgid);
         failure && failure(`timeout from far end for msgid ${msgid}`);
         this.messagesInFlight.delete(msgid);
       }, RESPONSE_TIMEOUT_MS);
@@ -183,7 +170,14 @@ class WsRequestor extends BaseRequestor {
         this.ws.removeAllListeners();
         this.ws = null;
       }
-      this._clearPendingMessages();
+
+      for (const [msgid, obj] of this.messagesInFlight) {
+        const {timer} = obj;
+        clearTimeout(timer);
+        obj.failure(`abandoning msgid ${msgid} since we have closed the socket`);
+      }
+      this.messagesInFlight.clear();
+
     } catch (err) {
       this.logger.info({err}, 'WsRequestor: Error closing socket');
     }
@@ -228,15 +222,6 @@ class WsRequestor extends BaseRequestor {
       .on('error', this._onError.bind(this));
   }
 
-  _clearPendingMessages() {
-    for (const [msgid, obj] of this.messagesInFlight) {
-      const {timer} = obj;
-      clearTimeout(timer);
-      if (!this._initMsgId) obj.failure(`abandoning msgid ${msgid} since socket is closed`);
-    }
-    this.messagesInFlight.clear();
-  }
-
   _onError(err) {
     if (this.connections > 0) {
       this.logger.info({url: this.url, err}, 'WsRequestor:_onError');
@@ -280,7 +265,6 @@ class WsRequestor extends BaseRequestor {
     this.ws = null;
     this.emit('connection-dropped');
     if (this.connections > 0 && this.connections < MAX_RECONNECTS && !this.closedGracefully) {
-      if (!this._initMsgId) this._clearPendingMessages();
       this.logger.debug(`WsRequestor:_onSocketClosed waiting ${this.backoffMs} to reconnect`);
       setTimeout(() => {
         this.logger.debug(
@@ -332,7 +316,6 @@ class WsRequestor extends BaseRequestor {
   }
 
   _recvAck(msgid, data) {
-    this._initMsgId = null;
     const obj = this.messagesInFlight.get(msgid);
     if (!obj) {
       this.logger.info({url: this.url}, `WsRequestor:_recvAck - ack to unknown msgid ${msgid}, discarding`);

package.json

@@ -1,6 +1,6 @@
 {
   "name": "jambonz-feature-server",
-  "version": "v0.8.1",
+  "version": "v0.7.8",
   "main": "app.js",
   "engines": {
     "node": ">= 10.16.0"
@@ -24,12 +24,11 @@
     "jslint": "eslint app.js lib"
   },
   "dependencies": {
-    "@jambonz/db-helpers": "^0.7.4",
+    "@jambonz/db-helpers": "^0.7.3",
     "@jambonz/http-health-check": "^0.0.1",
-    "@jambonz/realtimedb-helpers": "^0.6.5",
+    "@jambonz/realtimedb-helpers": "^0.6.3",
     "@jambonz/stats-collector": "^0.1.6",
     "@jambonz/time-series": "^0.2.5",
-    "@jambonz/verb-specifications": "^0.0.11",
     "@opentelemetry/api": "^1.4.0",
     "@opentelemetry/exporter-jaeger": "^1.9.0",
     "@opentelemetry/exporter-trace-otlp-http": "^0.35.0",
@@ -39,28 +38,26 @@
     "@opentelemetry/sdk-trace-base": "^1.9.0",
     "@opentelemetry/sdk-trace-node": "^1.9.0",
     "@opentelemetry/semantic-conventions": "^1.9.0",
-    "aws-sdk": "^2.1313.0",
+    "aws-sdk": "^2.1304.0",
     "bent": "^7.3.12",
     "debug": "^4.3.4",
     "deepcopy": "^2.1.0",
-    "drachtio-fsmrf": "^3.0.19",
-    "drachtio-srf": "^4.5.23",
+    "drachtio-fsmrf": "^3.0.16",
+    "drachtio-srf": "^4.5.23  ",
     "express": "^4.18.2",
     "ip": "^1.1.8",
     "moment": "^2.29.4",
     "parse-url": "^8.1.0",
     "pino": "^8.8.0",
-    "polly-ssml-split": "^0.1.0",
-    "proxyquire": "^2.1.3",
     "sdp-transform": "^2.14.1",
     "short-uuid": "^4.2.2",
-    "sinon": "^15.0.1",
     "to-snake-case": "^1.0.0",
-    "undici": "^5.19.1",
+    "undici": "^5.16.0",
     "uuid-random": "^1.3.2",
     "verify-aws-sns-signature": "^0.1.0",
     "ws": "^8.9.0",
-    "xml2js": "^0.4.23"
+    "xml2js": "^0.4.23",
+    "polly-ssml-split": "^0.1.0"
   },
   "devDependencies": {
     "clear-module": "^4.1.2",

test/gather-tests.js

@@ -206,49 +206,7 @@ test('\'gather\' test - deepgram', async(t) => {
     let obj = await getJSON(`http://127.0.0.1:3100/lastRequest/${from}_actionHook`);
     //console.log(JSON.stringify(obj));
     t.ok(obj.body.speech.alternatives[0].transcript.toLowerCase().startsWith('i\'d like to speak to customer support'),
-      'gather: succeeds when using deepgram credentials');
-    disconnect();
-  } catch (err) {
-    console.log(`error received: ${err}`);
-    disconnect();
-    t.error(err);
-  }
-});
-
-test('\'gather\' test - soniox', async(t) => {
-  if (!process.env.SONIOX_API_KEY ) {
-    t.pass('skipping soniox tests');
-    return t.end();
-  }
-  clearModule.all();
-  const {srf, disconnect} = require('../app');
-
-  try {
-    await connect(srf);
-    // GIVEN
-    let verbs = [
-      {
-        "verb": "gather",
-        "input": ["speech"],
-        "recognizer": {
-          "vendor": "deepgram",
-          "hints": ["customer support", "sales", "human resources", "HR"],
-          "deepgramOptions": {
-            "apiKey": process.env.SONIOX_API_KEY
-          }
-        },
-        "timeout": 10,
-        "actionHook": "/actionHook"
-      }
-    ];
-    let from = "gather_success";
-    provisionCallHook(from, verbs);
-    // THEN
-    await sippUac('uac-gather-account-creds-success.xml', '172.38.0.10', from);
-    let obj = await getJSON(`http://127.0.0.1:3100/lastRequest/${from}_actionHook`);
-    console.log(JSON.stringify(obj));
-    t.ok(obj.body.speech.alternatives[0].transcript.toLowerCase().startsWith('i\'d like to speak to customer support'),
-      'gather: succeeds when using soniox credentials');
+      'gather: succeeds when using  deepgram credentials');
 
     disconnect();
   } catch (err) {

test/index.js

@@ -1,4 +1,3 @@
-require('./ws-requestor-unit-test');
 require('./unit-tests');
 require('./docker_start');
 require('./create-test-db');

test/transcribe-tests.js

@@ -143,7 +143,7 @@ test('\'transcribe\' test - deepgram', async(t) => {
       {
         "verb": "transcribe",
         "recognizer": {
-          "vendor": "deepgram",
+          "vendor": "aws",
           "hints": ["customer support", "sales", "human resources", "HR"],
           "deepgramOptions": {
             "apiKey": process.env.DEEPGRAM_API_KEY
@@ -160,47 +160,6 @@ test('\'transcribe\' test - deepgram', async(t) => {
     t.ok(obj.body.speech.alternatives[0].transcript.toLowerCase().startsWith('i\'d like to speak to customer support'),
       'transcribe: succeeds when using deepgram credentials');
 
-    disconnect();
-  } catch (err) {
-    console.log(`error received: ${err}`);
-    disconnect();
-    t.error(err);
-  }
-});
-
-test('\'transcribe\' test - soniox', async(t) => {
-  if (!process.env.SONIOX_API_KEY ) {
-    t.pass('skipping soniox tests');
-    return t.end();
-  }
-  clearModule.all();
-  const {srf, disconnect} = require('../app');
-
-  try {
-    await connect(srf);
-    // GIVEN
-    let verbs = [
-      {
-        "verb": "transcribe",
-        "recognizer": {
-          "vendor": "soniox",
-          "hints": ["customer support", "sales", "human resources", "HR"],
-          "deepgramOptions": {
-            "apiKey": process.env.SONIOX_API_KEY
-          }
-        },
-        "transcriptionHook": "/transcriptionHook"
-      }
-    ];
-    let from = "gather_success";
-    provisionCallHook(from, verbs);
-    // THEN
-    await sippUac('uac-gather-account-creds-success.xml', '172.38.0.10', from);
-    let obj = await getJSON(`http://127.0.0.1:3100/lastRequest/${from}_actionHook`);
-    console.log(JSON.stringify(obj));
-    t.ok(obj.body.speech.alternatives[0].transcript.toLowerCase().startsWith('i\'d like to speak to customer support'),
-      'transcribe: succeeds when using soniox credentials');
-
     disconnect();
   } catch (err) {
     console.log(`error received: ${err}`);

test/unit-tests.js

@@ -61,8 +61,8 @@ test('unit tests', (t) => {
 
   
   const alt = require('./data/good/alternate-syntax');
-  const { normalizeJambones } = require('@jambonz/verb-specifications');
-  normalizeJambones(logger, alt).forEach((t) => {
+  const normalize = require('../lib/utils/normalize-jambones');
+  normalize(logger, alt).forEach((t) => {
     const task = makeTask(logger, t);
   });
   t.pass('alternate syntax works');
@@ -77,4 +77,4 @@ const errMissingProperty = () => makeTask(logger, require('./data/bad/missing-re
 const errInvalidType = () => makeTask(logger, require('./data/bad/invalid-type'));
 const errBadEnum = () => makeTask(logger, require('./data/bad/bad-enum'));
 const errBadPayload = () => makeTask(logger, require('./data/bad/bad-payload'));
-const errBadPayload2 = () => makeTask(logger, require('./data/bad/bad-payload2'));
+const errBadPayload2 = () => makeTask(logger, require('./data/bad/bad-payload2'));

test/ws-mock.js

@@ -1,97 +0,0 @@
-class MockWebsocket {
-    static eventResponses = new Map();
-    static actionLoops = new Map();
-    eventListeners = new Map();
-
-    constructor(url, protocols, options) {
-        this.u = url;
-        this.pros = protocols;
-        this.opts = options;
-        setTimeout(() => {
-            this.open();
-        }, 500)
-    }
-
-    static addJsonMapping(key, value) {
-        MockWebsocket.eventResponses.set(key, value);
-    }
-
-    static getAndIncreaseActionLoops(key) {
-        const ret = MockWebsocket.actionLoops.has(key) ? MockWebsocket.actionLoops.get(key) : 0;
-        MockWebsocket.actionLoops.set(key, ret + 1);
-        return ret;
-    }
-
-    once(event, listener) {
-        // Websocket.ws = this;
-        this.eventListeners.set(event, listener);
-        return this;
-    }
-
-    on(event, listener) {
-        // Websocket.ws = this;
-        this.eventListeners.set(event, listener);
-        return this;
-    }
-
-    open() {
-        if (this.eventListeners.has('open')) {
-            this.eventListeners.get('open')();
-        }
-    }
-
-    removeAllListeners() {
-        this.eventListeners.clear();
-    }
-
-    send(data, callback) {
-        const json = JSON.parse(data);
-        console.log({json}, 'got message from ws-requestor');
-        if (MockWebsocket.eventResponses.has(json.call_sid)) {
-
-            const resp_data = MockWebsocket.eventResponses.get(json.call_sid);
-            const action = resp_data.action[MockWebsocket.getAndIncreaseActionLoops(json.call_sid)];
-            if (action === 'connect') {
-                setTimeout(()=> {
-                    const msg = {
-                        type: 'ack',
-                        msgid: json.msgid,
-                        command: 'command',
-                        call_sid: json.call_sid,
-                        queueCommand: false, 
-                        data: resp_data.body}
-                    console.log({msg}, 'sending ack to ws-requestor');
-                    this.mockOnMessage(JSON.stringify(msg));
-                }, 100);
-            } else if (action === 'close') {
-                if (this.eventListeners.has('close')) {
-                    this.eventListeners.get('close')(500);
-                }
-            } else if (action === 'terminate') {
-                if (this.eventListeners.has('close')) {
-                    this.eventListeners.get('close')(1000);
-                }
-            } else if (action === 'error') {
-                if (this.eventListeners.has('error')) {
-                    this.eventListeners.get('error')();
-                }
-            } else if (action === 'unexpected-response') {
-                if (this.eventListeners.has('unexpected-response')) {
-                    this.eventListeners.get('unexpected-response')();
-                }
-            }
-            
-        }
-        if (callback) {
-            callback();
-        }
-    }
-
-    mockOnMessage(message, isBinary=false) {
-        if (this.eventListeners.has('message')) {
-            this.eventListeners.get('message')(message, isBinary);
-        }
-    }
-}
-
-module.exports = MockWebsocket;

test/ws-requestor-unit-test.js

@@ -1,198 +0,0 @@
-const test = require('tape');
-const sinon = require('sinon');
-const proxyquire = require("proxyquire");
-proxyquire.noCallThru();
-const MockWebsocket = require('./ws-mock')
-const logger = require('pino')({level: process.env.JAMBONES_LOGLEVEL || 'error'});
-
-const BaseRequestor = proxyquire(
-  "../lib/utils/base-requestor",
-  {
-    "../../": {
-      srf: {
-        locals: {
-          stats: {
-            histogram: () => {}
-          }
-        }
-      }
-    },
-    "@jambonz/time-series": sinon.stub()
-  }
- );
-
- const WsRequestor = proxyquire(
-  "../lib/utils/ws-requestor",
-  {
-    "./base-requestor": BaseRequestor,
-    "ws": MockWebsocket
-  }
- );
-
-test('ws success', async (t) => {
-  // GIVEN
-
-  const json = '[{\"verb\": \"play\",\"url\": \"silence_stream://5000\"}]';
-  const ws_response = {
-    action: ['connect'],
-    body: json
-  }
-  const call_sid = 'ws_success';
-
-  MockWebsocket.addJsonMapping(call_sid, ws_response);
-
-  const hook = {
-    url: 'ws://localhost:3000',
-    username: 'username',
-    password: 'password'
-  }
-
-  const params = {
-    callSid: call_sid
-  }
-
-  // WHEN
-  
-  const requestor = new WsRequestor(logger, "account_sid", hook, "webhook_secret");
-  const result = await requestor.request('session:new',hook, params, {});
-
-  // THEN
-  t.ok(result == json,'ws successfully sent session:new and got initial jambonz app');
-
-  t.end();
-});
-
-test('ws close success reconnect', async (t) => {
-  // GIVEN
-
-  const call_sid = 'ws_closed'
-  const json = '[{\"verb\": \"play\",\"url\": \"silence_stream://5000\"}]';
-  const ws_response = {
-    action: ['close', 'connect'],
-    body: json
-  }
-  MockWebsocket.addJsonMapping(call_sid, ws_response);
-
-  const hook = {
-    url: 'ws://localhost:3000',
-    username: 'username',
-    password: 'password'
-  }
-
-  const params = {
-    callSid: call_sid
-  }
-
-  // WHEN
-  
-  const requestor = new WsRequestor(logger, "account_sid", hook, "webhook_secret");
-  const result = await requestor.request('session:new',hook, params, {});
-
-  // THEN
-  t.ok(result == json,'ws successfully reconnect after close from far end');
-
-  t.end();
-});
-
-
-test('ws response error 1000', async (t) => {
-  // GIVEN
-
-  const call_sid = 'ws_terminated'
-  const json = '[{\"verb\": \"play\",\"url\": \"silence_stream://5000\"}]';
-  const ws_response = {
-    action: ['terminate'],
-    body: json
-  }
-  MockWebsocket.addJsonMapping(call_sid, ws_response);
-
-  const hook = {
-    url: 'ws://localhost:3000',
-    username: 'username',
-    password: 'password'
-  }
-
-  const params = {
-    callSid: call_sid
-  }
-
-  // WHEN
-  
-  const requestor = new WsRequestor(logger, "account_sid", hook, "webhook_secret");
-  try {
-    await requestor.request('session:new',hook, params, {});
-  }
-  catch (err) {
-    // THEN
-    t.ok(err.startsWith('timeout from far end for msgid'), 'ws does not reconnect if far end closes gracefully');
-    t.end();
-  }
-});
-
-test('ws response error', async (t) => {
-  // GIVEN
-
-  const call_sid = 'ws_error'
-  const json = '[{\"verb\": \"play\",\"url\": \"silence_stream://5000\"}]';
-  const ws_response = {
-    action: ['error'],
-    body: json
-  }
-  MockWebsocket.addJsonMapping(call_sid, ws_response);
-
-  const hook = {
-    url: 'ws://localhost:3000',
-    username: 'username',
-    password: 'password'
-  }
-
-  const params = {
-    callSid: call_sid
-  }
-
-  // WHEN
-  
-  const requestor = new WsRequestor(logger, "account_sid", hook, "webhook_secret");
-  try {
-    await requestor.request('session:new',hook, params, {});
-  }
-  catch (err) {
-    // THEN
-    t.ok(err.startsWith('timeout from far end for msgid'), 'ws does not reconnect if far end closes gracefully');
-    t.end();
-  }
-});
-
-test('ws unexpected-response', async (t) => {
-  // GIVEN
-
-  const call_sid = 'ws_unexpected-response'
-  const json = '[{\"verb\": \"play\",\"url\": \"silence_stream://5000\"}]';
-  const ws_response = {
-    action: ['unexpected-response'],
-    body: json
-  }
-  MockWebsocket.addJsonMapping(call_sid, ws_response);
-
-  const hook = {
-    url: 'ws://localhost:3000',
-    username: 'username',
-    password: 'password'
-  }
-
-  const params = {
-    callSid: call_sid
-  }
-
-  // WHEN
-  
-  const requestor = new WsRequestor(logger, "account_sid", hook, "webhook_secret");
-  try {
-    await requestor.request('session:new',hook, params, {});
-  }
-  catch (err) {
-    // THEN
-    t.ok(err.code = 'ERR_ASSERTION', 'ws does not reconnect if far end closes gracefully');
-    t.end();
-  }
-});