reset variables like hints so that previous hints do not automatically carry over

.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-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
 

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}`);
-    logger.info(`got signal ${signal}, removing ${srf.locals.localSipAddress} from set ${setName}`);
+  removeFromSet(setName, srf.locals.localSipAddress);
-    removeFromSet(setName, srf.locals.localSipAddress);
-  }
   removeFromSet(FS_UUID_SET_NAME, srf.locals.fsUUID);
-  if (process.env.K8S) {
+  srf.locals.disabled = true;
-    srf.locals.lifecycleEmitter.operationalState = LifeCycleEvents.ScaleIn;
-  }
-  if (getCount() === 0) {
-    logger.info('no calls in progress, exiting');
-    process.exit(0);
-  }
 }
 
 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');
@@ -1670,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 */
@@ -1690,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,8 +7,7 @@ const {
   AwsTranscriptionEvents,
   AzureTranscriptionEvents,
   DeepgramTranscriptionEvents,
-  IbmTranscriptionEvents,
+  IbmTranscriptionEvents
-  NvidiaTranscriptionEvents
 } = require('../utils/constants');
 
 const makeTask = require('./make_task');
@@ -172,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({
+      this.notifyError(`No speech-to-text service credentials for ${this.vendor} have been configured`);
-        msg: 'ASR error',
-        details: `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`);
     }
@@ -398,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}`);
     }
@@ -632,9 +609,6 @@ class TaskGather extends Task {
       return this._resolve('timeout');
     }
   }
-  _onNvidiaError(cs, ep, evt) {
-    this.logger.info({evt}, 'TaskGather:_onNvidiaError');
-  }
   _onDeepgramConnect(_cs, _ep) {
     this.logger.debug('TaskGather:_onDeepgramConnect');
   }
@@ -649,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();
   }
 
@@ -667,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/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

lib/tasks/specs.json

@@ -0,0 +1,773 @@
+{
+  "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"
+    },
+    "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

@@ -7,10 +7,9 @@ const {
   AwsTranscriptionEvents,
   NuanceTranscriptionEvents,
   DeepgramTranscriptionEvents,
-  IbmTranscriptionEvents,
+  IbmTranscriptionEvents
-  NvidiaTranscriptionEvents
 } = require('../utils/constants');
-const { normalizeJambones } = require('@jambonz/verb-specifications');
+const normalizeJambones = require('../utils/normalize-jambones');
 
 class TaskTranscribe extends Task {
   constructor(logger, opts, parentTask) {
@@ -208,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}`);
     }
@@ -326,9 +311,6 @@ class TaskTranscribe extends Task {
       return this._resolve('timeout');
     }
   }
-  _onNvidiaError(cs, ep, evt) {
-    this.logger.info({evt}, 'TaskGather:_onNvidiaError');
-  }
   _onDeepgramConnect(_cs, _ep) {
     this.logger.debug('TaskTranscribe:_onDeepgramConnect');
   }

lib/utils/constants.json

@@ -74,13 +74,6 @@
     "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",

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,7 +5,6 @@ const {
   AwsTranscriptionEvents,
   NuanceTranscriptionEvents,
   DeepgramTranscriptionEvents,
-  NvidiaTranscriptionEvents
 } = require('./constants');
 
 const stickyVars = {
@@ -85,9 +84,6 @@ const stickyVars = {
     'IBM_SPEECH_BASE_MODEL_VERSION',
     'IBM_SPEECH_WATSON_METADATA',
     'IBM_SPEECH_WATSON_LEARNING_OPT_OUT'
-  ],
-  nvidia: [
-    'NVIDIA_HINTS'
   ]
 };
 
@@ -111,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;
@@ -235,8 +212,6 @@ module.exports = (logger) => {
         return normalizeNuance(evt, channel, language);
       case 'ibm':
         return normalizeIbm(evt, channel, language);
-      case 'nvidia':
-        return normalizeNvidia(evt, channel, language);
       default:
         logger.error(`Unknown vendor ${vendor}`);
         return evt;
@@ -362,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) &&
@@ -465,36 +440,6 @@ 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] = '';
     });
@@ -523,12 +468,6 @@ module.exports = (logger) => {
     ep.removeCustomEventListener(DeepgramTranscriptionEvents.Transcription);
     ep.removeCustomEventListener(DeepgramTranscriptionEvents.Connect);
     ep.removeCustomEventListener(DeepgramTranscriptionEvents.ConnectFailure);
-
-    ep.removeCustomEventListener(NvidiaTranscriptionEvents.Transcription);
-    ep.removeCustomEventListener(NvidiaTranscriptionEvents.TranscriptionComplete);
-    ep.removeCustomEventListener(NvidiaTranscriptionEvents.StartOfSpeech);
-    ep.removeCustomEventListener(NvidiaTranscriptionEvents.Error);
-    ep.removeCustomEventListener(NvidiaTranscriptionEvents.VadDetected);
   };
 
   const setSpeechCredentialsAtRuntime = (recognizer) => {
@@ -537,10 +476,6 @@ module.exports = (logger) => {
       const {clientId, secret} = recognizer.nuanceOptions || {};
       if (clientId && secret) return {client_id: clientId, secret};
     }
-    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};

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.0",
+  "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.3",
     "@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.18",
+    "drachtio-fsmrf": "^3.0.16",
-    "drachtio-srf": "^4.5.23",
+    "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.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/index.js

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

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');
+  const normalize = require('../lib/utils/normalize-jambones');
-  normalizeJambones(logger, alt).forEach((t) => {
+  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();
-  }
-});