Merge branch 'main' into feat/dial_translate

* support voxist stt

* wip

lib/session/call-session.js

@@ -1084,6 +1084,12 @@ class CallSession extends Emitter {
             api_key: credential.api_key
           };
         }
+        else if ('voxist' === vendor) {
+          return {
+            speech_credential_sid: credential.speech_credential_sid,
+            api_key: credential.api_key
+          };
+        }
         else if ('whisper' === vendor) {
           return {
             api_key: credential.api_key,
@@ -2484,7 +2490,7 @@ Duration=${duration} `
           res.send(200, {body: this.ep.local.sdp});
         }
         else {
-          if (this.currentTask.name === TaskName.Dial && this.currentTask.isOnHoldEnabled) {
+          if (this.currentTask && this.currentTask.name === TaskName.Dial && this.currentTask.isOnHoldEnabled) {
             this.logger.info('onholdMusic reINVITE after media has been released');
             await this.currentTask.handleReinviteAfterMediaReleased(req, res);
           } else {

lib/tasks/dial.js

@@ -110,6 +110,7 @@ class TaskDial extends Task {
     this.tag = this.data.tag;
     this.boostAudioSignal = this.data.boostAudioSignal;
     this._mediaPath = MediaPath.FullMedia;
+    this.translate = this.data.translate;
 
     if (this.dtmfHook) {
       const {parentDtmfCollector, childDtmfCollector} = parseDtmfOptions(logger, this.data.dtmfCapture || {});
@@ -158,6 +159,7 @@ class TaskDial extends Task {
 
   get canReleaseMedia() {
     const keepAnchor = this.data.anchorMedia ||
+      this.data.translate ||
       this.cs.isBackGroundListen ||
       this.cs.onHoldMusic ||
       ANCHOR_MEDIA_ALWAYS ||
@@ -291,6 +293,17 @@ class TaskDial extends Task {
       this.transcribeTask.span.end();
       this.transcribeTask = null;
     }
+    if (this.llmTask) {
+      await this.llmTask.kill(cs);
+      this.llmTask.span.end();
+      this.llmTask = null;
+    }
+
+    if (this.sdLlmTask) {
+      await this.sdLlmTask.kill(cs);
+      this.sdLlmTask.span.end();
+      this.sdLlmTask = null;
+    }
     this.notifyTaskDone();
   }
 
@@ -705,6 +718,7 @@ class TaskDial extends Task {
             clearTimeout(this.timerRing);
             try {
               await this._connectSingleDial(cs, sd);
+              await this._startTranslate(cs, sd);
             } catch (err) {
               this.logger.info({err}, 'Dial:_attemptCalls - Error calling _connectSingleDial ');
               sd.removeAllListeners();
@@ -758,6 +772,30 @@ class TaskDial extends Task {
     this._killOutdials();       // NB: order is important
   }
 
+  async _startTranslate(cs, sd) {
+    if (this.translate) {
+      const {callerLanguage, calleeLanguage, gain} = this.translate;
+      assert(this.translate.llm, 'Dial:_startTranslate - missing llm in translate');
+      this.logger.debug('Dial:_startTranslate start llm services');
+      // setup caller LLM task
+      this.llmTask = makeTask(this.logger, {'llm': this.translate.llm});
+      this.llmTask.configureDialTranslate({
+        language: callerLanguage,
+        gain,
+      });
+
+      // setup callee LLM task
+      this.sdLlmTask = makeTask(this.logger, {'llm': this.translate.llm});
+      this.sdLlmTask.configureDialTranslate({
+        language: calleeLanguage,
+        gain,
+      });
+
+      this.llmTask.exec(cs, {ep: this.ep});
+      this.sdLlmTask.exec(cs, {ep: sd.ep});
+    }
+  }
+
   async _onReinvite(req, res) {
     try {
       let isHandled = false;

lib/tasks/gather.js

@@ -11,6 +11,7 @@ const {
   NvidiaTranscriptionEvents,
   JambonzTranscriptionEvents,
   AssemblyAiTranscriptionEvents,
+  VoxistTranscriptionEvents,
   VadDetection,
   VerbioTranscriptionEvents,
   SpeechmaticsTranscriptionEvents
@@ -524,6 +525,17 @@ class TaskGather extends SttTask {
           this._onVendorConnectFailure.bind(this, cs, ep));
         break;
 
+      case 'voxist':
+        this.bugname = `${this.bugname_prefix}voxist_transcribe`;
+        this.addCustomEventListener(ep, VoxistTranscriptionEvents.Transcription,
+          this._onTranscription.bind(this, cs, ep));
+        this.addCustomEventListener(
+          ep, VoxistTranscriptionEvents.Connect, this._onVendorConnect.bind(this, cs, ep));
+        this.addCustomEventListener(ep, VoxistTranscriptionEvents.Error, this._onVendorError.bind(this, cs, ep));
+        this.addCustomEventListener(ep, VoxistTranscriptionEvents.ConnectFailure,
+          this._onVendorConnectFailure.bind(this, cs, ep));
+        break;
+
       case 'speechmatics':
         this.bugname = `${this.bugname_prefix}speechmatics_transcribe`;
         this.addCustomEventListener(

lib/tasks/llm/index.js

@@ -3,6 +3,7 @@ const {TaskPreconditions} = require('../../utils/constants');
 const TaskLlmOpenAI_S2S = require('./llms/openai_s2s');
 const TaskLlmVoiceAgent_S2S = require('./llms/voice_agent_s2s');
 const TaskLlmUltravox_S2S = require('./llms/ultravox_s2s');
+const TaskLlmElevenlabs_S2S = require('./llms/elevenlabs_s2s');
 
 class TaskLlm extends Task {
   constructor(logger, opts) {
@@ -27,6 +28,12 @@ class TaskLlm extends Task {
 
   get ep() { return this.cs.ep; }
 
+
+  configureDialTranslate(opts) {
+    this.logger.debug(opts, 'TaskLlm:configureDialTranslate');
+    this.llm.configureDialTranslate(opts);
+  }
+
   async exec(cs, {ep}) {
     await super.exec(cs, {ep});
     await this.llm.exec(cs, {ep});
@@ -54,6 +61,10 @@ class TaskLlm extends Task {
         llm = new TaskLlmUltravox_S2S(this.logger, this.data, this);
         break;
 
+      case 'elevenlabs':
+        llm = new TaskLlmElevenlabs_S2S(this.logger, this.data, this);
+        break;
+
       default:
         throw new Error(`Unsupported vendor ${this.vendor} for LLM`);
     }

lib/tasks/llm/llms/elevenlabs_s2s.js

@@ -0,0 +1,326 @@
+const Task = require('../../task');
+const TaskName = 'Llm_Elevenlabs_s2s';
+const {LlmEvents_Elevenlabs} = require('../../../utils/constants');
+const {request} = require('undici');
+const { parseDecibels } = require('drachtio-fsmrf/lib/utils');
+const ClientEvent = 'client.event';
+const SessionDelete = 'session.delete';
+
+const elevenlabs_server_events = [
+  'conversation_initiation_metadata',
+  'user_transcript',
+  'agent_response',
+  'client_tool_call'
+];
+
+const expandWildcards = (events) => {
+  const expandedEvents = [];
+
+  events.forEach((evt) => {
+    if (evt.endsWith('.*')) {
+      const prefix = evt.slice(0, -2); // Remove the wildcard ".*"
+      const matchingEvents = elevenlabs_server_events.filter((e) => e.startsWith(prefix));
+      expandedEvents.push(...matchingEvents);
+    } else {
+      expandedEvents.push(evt);
+    }
+  });
+
+  return expandedEvents;
+};
+
+class TaskLlmElevenlabs_S2S extends Task {
+  constructor(logger, opts, parentTask) {
+    super(logger, opts, parentTask);
+    this.parent = parentTask;
+
+    this.vendor = this.parent.vendor;
+    this.auth = this.parent.auth;
+
+    const {agent_id, api_key} = this.auth || {};
+    if (!agent_id) throw new Error('auth.agent_id is required for Elevenlabs S2S');
+
+    this.agent_id = agent_id;
+    this.api_key = api_key;
+    this.actionHook = this.data.actionHook;
+    this.eventHook = this.data.eventHook;
+    this.toolHook = this.data.toolHook;
+    const {
+      conversation_initiation_client_data,
+      input_sample_rate = 16000,
+      output_sample_rate = 16000
+    } = this.data.llmOptions;
+    this.conversation_initiation_client_data = conversation_initiation_client_data;
+    this.input_sample_rate = input_sample_rate;
+    this.output_sample_rate = output_sample_rate;
+    this.results = {
+      completionReason: 'normal conversation end'
+    };
+
+    /**
+     * only one of these will have items,
+     * if includeEvents, then these are the events to include
+     * if excludeEvents, then these are the events to exclude
+     */
+    this.includeEvents = [];
+    this.excludeEvents = [];
+
+    /* default to all events if user did not specify */
+    this._populateEvents(this.data.events || elevenlabs_server_events);
+
+    this.addCustomEventListener = parentTask.addCustomEventListener.bind(parentTask);
+    this.removeCustomEventListeners = parentTask.removeCustomEventListeners.bind(parentTask);
+  }
+
+  get name() { return TaskName; }
+
+  configureDialTranslate(opts) {
+    const {language, gain} = opts;
+    const {naturalVoice, translatedVoice} = gain;
+    this.replace_read = true;
+    this.audio_in_gain = parseDecibels(naturalVoice);
+    this.audio_injection_gain = parseDecibels(translatedVoice);
+
+    // override the agent prompt to ask for a translation
+    this.conversation_initiation_client_data = {
+      ...(this.conversation_initiation_client_data || {}),
+      conversation_config_override: {
+        ...(this.conversation_initiation_client_data?.conversation_config_override || {}),
+        agent: {
+          prompt: {
+            prompt: `Please translate the text to ${language}.
+            Your response should only include the ${language} translation, without any additional words:\n\n`
+          }
+        }
+      }
+    };
+  }
+
+  async getSignedUrl() {
+    if (!this.api_key) {
+      return {
+        host: 'api.elevenlabs.io',
+        path: `/v1/convai/conversation?agent_id=${this.agent_id}`,
+      };
+    }
+
+    const {statusCode, body} = await request(
+      `https://api.elevenlabs.io/v1/convai/conversation/get_signed_url?agent_id=${this.agent_id}`, {
+        method: 'GET',
+        headers: {
+          'xi-api-key': this.api_key
+        },
+      }
+    );
+    const data = await body.json();
+    if (statusCode !== 200 || !data?.signed_url) {
+      this.logger.error({statusCode, data}, 'Elevenlabs Error registering call');
+      throw new Error(`Elevenlabs  Error registering call: ${data.message}`);
+    }
+
+    const url = new URL(data.signed_url);
+    return {
+      host: url.hostname,
+      path: url.pathname + url.search,
+    };
+  }
+
+  async _api(ep, args) {
+    const res = await ep.api('uuid_elevenlabs_s2s', `^^|${args.join('|')}`);
+    if (!res.body?.startsWith('+OK')) {
+      throw new Error({args}, `Error calling uuid_elevenlabs_s2s: ${res.body}`);
+    }
+  }
+
+  async exec(cs, {ep}) {
+    await super.exec(cs);
+    await this._startListening(cs, ep);
+
+    await this.awaitTaskDone();
+
+    /* note: the parent llm verb started the span, which is why this is necessary */
+    await this.parent.performAction(this.results);
+
+    this._unregisterHandlers();
+  }
+
+  async kill(cs) {
+    super.kill(cs);
+
+    this._api(cs.ep, [cs.ep.uuid, SessionDelete])
+      .catch((err) => this.logger.info({err}, 'TaskLlmElevenlabs_S2S:kill - error deleting session'));
+
+    this.notifyTaskDone();
+  }
+
+  /**
+   * Send function call output to the Elevenlabs server in the form of conversation.item.create
+   * per https://elevenlabs.io/docs/conversational-ai/api-reference/conversational-ai/websocket
+   */
+  async processToolOutput(ep, tool_call_id, rawData) {
+    try {
+      const {data} = rawData;
+      this.logger.debug({tool_call_id, data}, 'TaskLlmElevenlabs_S2S:processToolOutput');
+
+      if (!data.type || data.type !== 'client_tool_result') {
+        this.logger.info({data},
+          'TaskLlmElevenlabs_S2S:processToolOutput - invalid tool output, must be client_tool_result');
+      }
+      else {
+        await this._api(ep, [ep.uuid, ClientEvent, JSON.stringify(data)]);
+      }
+    } catch (err) {
+      this.logger.info({err}, 'TaskLlmElevenlabs_S2S:processToolOutput');
+    }
+  }
+
+  /**
+   * Send a session.update to the Elevenlabs server
+   * Note: creating and deleting conversation items also supported as well as interrupting the assistant
+   */
+  async processLlmUpdate(ep, data, _callSid) {
+    this.logger.debug({data, _callSid}, 'TaskLlmElevenlabs_S2S:processLlmUpdate, ignored');
+  }
+
+  async _startListening(cs, ep) {
+    this._registerHandlers(ep);
+
+    try {
+      const {host, path} = await this.getSignedUrl();
+      const args = [ep.uuid, 'session.create', this.input_sample_rate, this.output_sample_rate, host, path,
+        ...(this.replace_read ? ['replace_read', this.audio_in_gain, this.audio_injection_gain] : [])];
+      await this._api(ep, args);
+    } catch (err) {
+      this.logger.error({err}, 'TaskLlmElevenlabs_S2S:_startListening');
+      this.notifyTaskDone();
+    }
+  }
+
+  async _sendClientEvent(ep, obj) {
+    let ok = true;
+    this.logger.debug({obj}, 'TaskLlmElevenlabs_S2S:_sendClientEvent');
+    try {
+      const args = [ep.uuid, ClientEvent, JSON.stringify(obj)];
+      await this._api(ep, args);
+    } catch (err) {
+      ok = false;
+      this.logger.error({err}, 'TaskLlmElevenlabs_S2S:_sendClientEvent - Error');
+    }
+    return ok;
+  }
+
+  async _sendInitialMessage(ep) {
+    if (this.conversation_initiation_client_data) {
+      if (!await this._sendClientEvent(ep, {
+        type: 'conversation_initiation_client_data',
+        conversation_initiation_client_data: this.conversation_initiation_client_data
+      })) {
+        this.notifyTaskDone();
+      }
+    }
+  }
+
+  _registerHandlers(ep) {
+    this.addCustomEventListener(ep, LlmEvents_Elevenlabs.Connect, this._onConnect.bind(this, ep));
+    this.addCustomEventListener(ep, LlmEvents_Elevenlabs.ConnectFailure, this._onConnectFailure.bind(this, ep));
+    this.addCustomEventListener(ep, LlmEvents_Elevenlabs.Disconnect, this._onDisconnect.bind(this, ep));
+    this.addCustomEventListener(ep, LlmEvents_Elevenlabs.ServerEvent, this._onServerEvent.bind(this, ep));
+  }
+
+  _unregisterHandlers() {
+    this.removeCustomEventListeners();
+  }
+
+  _onError(ep, evt) {
+    this.logger.info({evt}, 'TaskLlmElevenlabs_S2S:_onError');
+    this.notifyTaskDone();
+  }
+
+  _onConnect(ep) {
+    this.logger.debug('TaskLlmElevenlabs_S2S:_onConnect');
+    this._sendInitialMessage(ep);
+  }
+  _onConnectFailure(_ep, evt) {
+    this.logger.info(evt, 'TaskLlmElevenlabs_S2S:_onConnectFailure');
+    this.results = {completionReason: 'connection failure'};
+    this.notifyTaskDone();
+  }
+  _onDisconnect(_ep, evt) {
+    this.logger.info(evt, 'TaskLlmElevenlabs_S2S:_onConnectFailure');
+    this.results = {completionReason: 'disconnect from remote end'};
+    this.notifyTaskDone();
+  }
+  async _onServerEvent(ep, evt) {
+    let endConversation = false;
+    const type = evt.type;
+    this.logger.info({evt}, 'TaskLlmElevenlabs_S2S:_onServerEvent');
+
+    if (type === 'error') {
+      endConversation = true;
+      this.results = {
+        completionReason: 'server error',
+        error: evt.error
+      };
+    }
+
+    /* tool calls */
+    else if (type === 'client_tool_call') {
+      this.logger.debug({evt}, 'TaskLlmElevenlabs_S2S:_onServerEvent - function_call');
+      if (!this.toolHook) {
+        this.logger.warn({evt}, 'TaskLlmElevenlabs_S2S:_onServerEvent - no toolHook defined!');
+      }
+      else {
+        const {client_tool_call} = evt;
+        const {tool_name: name, tool_call_id: call_id, parameters: args} = client_tool_call;
+
+        try {
+          await this.parent.sendToolHook(call_id, {name, args});
+        } catch (err) {
+          this.logger.info({err, evt}, 'TaskLlmElevenlabs_S2S - error calling function');
+          this.results = {
+            completionReason: 'client error calling function',
+            error: err
+          };
+          endConversation = true;
+        }
+      }
+    }
+
+    /* check whether we should notify on this event */
+    if (this.includeEvents.length > 0 ? this.includeEvents.includes(type) : !this.excludeEvents.includes(type)) {
+      this.parent.sendEventHook(evt)
+        .catch((err) => this.logger.info({err},
+          'TaskLlmElevenlabs_S2S:_onServerEvent - error sending event hook'));
+    }
+
+    if (endConversation) {
+      this.logger.info({results: this.results},
+        'TaskLlmElevenlabs_S2S:_onServerEvent - ending conversation due to error');
+      this.notifyTaskDone();
+    }
+  }
+
+  _populateEvents(events) {
+    if (events.includes('all')) {
+      /* work by excluding specific events */
+      const exclude = events
+        .filter((evt) => evt.startsWith('-'))
+        .map((evt) => evt.slice(1));
+      if (exclude.length === 0) this.includeEvents = elevenlabs_server_events;
+      else this.excludeEvents = expandWildcards(exclude);
+    }
+    else {
+      /* work by including specific events */
+      const include = events
+        .filter((evt) => !evt.startsWith('-'));
+      this.includeEvents = expandWildcards(include);
+    }
+
+    this.logger.debug({
+      includeEvents: this.includeEvents,
+      excludeEvents: this.excludeEvents
+    }, 'TaskLlmElevenlabs_S2S:_populateEvents');
+  }
+}
+
+module.exports = TaskLlmElevenlabs_S2S;

lib/tasks/say.js

@@ -240,6 +240,7 @@ class TaskSay extends TtsTask {
                 language,
                 voice,
                 engine,
+                model: this.model || this.model_id,
                 text
               }).catch((err) => this.logger.info({err}, 'Error adding file to cache'));
             }

lib/tasks/transcribe.js

@@ -13,6 +13,7 @@ const {
   JambonzTranscriptionEvents,
   TranscribeStatus,
   AssemblyAiTranscriptionEvents,
+  VoxistTranscriptionEvents,
   VerbioTranscriptionEvents,
   SpeechmaticsTranscriptionEvents
 } = require('../utils/constants.json');
@@ -300,6 +301,17 @@ class TaskTranscribe extends SttTask {
           this._onVendorConnectFailure.bind(this, cs, ep, channel));
         break;
 
+      case 'voxist':
+        this.bugname = `${this.bugname_prefix}voxist_transcribe`;
+        this.addCustomEventListener(ep, VoxistTranscriptionEvents.Transcription,
+          this._onTranscription.bind(this, cs, ep, channel));
+        this.addCustomEventListener(ep,
+          VoxistTranscriptionEvents.Connect, this._onVendorConnect.bind(this, cs, ep));
+        this.addCustomEventListener(ep, VoxistTranscriptionEvents.Error, this._onVendorError.bind(this, cs, ep));
+        this.addCustomEventListener(ep, VoxistTranscriptionEvents.ConnectFailure,
+          this._onVendorConnectFailure.bind(this, cs, ep, channel));
+        break;
+
       case 'speechmatics':
         this.bugname = `${this.bugname_prefix}speechmatics_transcribe`;
         this.addCustomEventListener(

lib/tasks/tts-task.js

@@ -143,16 +143,16 @@ class TtsTask extends Task {
         `No text-to-speech service credentials for ${vendor} with labels: ${label} have been configured`);
     }
     /* parse Nuance voices into name and model */
-    let model;
     if (vendor === 'nuance' && voice) {
       const arr = /([A-Za-z-]*)\s+-\s+(enhanced|standard)/.exec(voice);
       if (arr) {
         voice = arr[1];
-        model = arr[2];
+        this.model = arr[2];
       }
     } else if (vendor === 'deepgram') {
-      model = voice;
+      this.model = voice;
     }
+    this.model_id = credentials.model_id;
 
     /* allow for microsoft custom region voice and api_key to be specified as an override */
     if (vendor === 'microsoft' && this.options.deploymentId) {
@@ -215,7 +215,8 @@ class TtsTask extends Task {
     // If vendor is changed from the previous one, then reset the cache_speech_handles flag
     //cs.currentTtsVendor = vendor;
 
-    if (!preCache && !this._disableTracing) this.logger.info({vendor, language, voice, model}, 'TaskSay:exec');
+    if (!preCache && !this._disableTracing)
+      this.logger.info({vendor, language, voice, model: this.model}, 'TaskSay:exec');
     try {
       if (!credentials) {
         writeAlerts({
@@ -250,7 +251,7 @@ class TtsTask extends Task {
             language,
             voice,
             engine,
-            model,
+            model: this.model,
             salt,
             credentials,
             options: this.options,

lib/utils/background-task-manager.js

@@ -79,7 +79,7 @@ class BackgroundTaskManager extends Emitter {
   }
 
   // Initiate Listen
-  async _initListen(opts, bugname = 'jambonz-background-listen', ignoreCustomerData = true, type = 'listen') {
+  async _initListen(opts, bugname = 'jambonz-background-listen', ignoreCustomerData = false, type = 'listen') {
     let task;
     try {
       const t = normalizeJambones(this.logger, [opts]);

lib/utils/constants.json

@@ -149,6 +149,12 @@
     "ConnectFailure": "assemblyai_transcribe::connect_failed",
     "Connect": "assemblyai_transcribe::connect"
   },
+  "VoxistTranscriptionEvents": {
+    "Transcription": "voxist_transcribe::transcription",
+    "Error": "voxist_transcribe::error",
+    "ConnectFailure": "voxist_transcribe::connect_failed",
+    "Connect": "voxist_transcribe::connect"
+  },
   "VadDetection": {
     "Detection": "vad_detect:detection"
   },
@@ -176,6 +182,13 @@
     "Disconnect": "openai_s2s::disconnect",
     "ServerEvent": "openai_s2s::server_event"
   },
+  "LlmEvents_Elevenlabs": {
+    "Error": "error",
+    "Connect": "elevenlabs_s2s::connect",
+    "ConnectFailure": "elevenlabs_s2s::connect_failed",
+    "Disconnect": "elevenlabs_s2s::disconnect",
+    "ServerEvent": "elevenlabs_s2s::server_event"
+  },
   "LlmEvents_VoiceAgent": {
     "Error": "error",
     "Connect": "voice_agent_s2s::connect",

lib/utils/db-utils.js

@@ -122,6 +122,10 @@ const speechMapper = (cred) => {
       const o = JSON.parse(decrypt(credential));
       obj.api_key = o.api_key;
     }
+    else if ('voxist' === obj.vendor) {
+      const o = JSON.parse(decrypt(credential));
+      obj.api_key = o.api_key;
+    }
     else if ('whisper' === obj.vendor) {
       const o = JSON.parse(decrypt(credential));
       obj.api_key = o.api_key;

lib/utils/transcription-utils.js

@@ -105,6 +105,9 @@ const stickyVars = {
     'ASSEMBLYAI_API_KEY',
     'ASSEMBLYAI_WORD_BOOST'
   ],
+  voxist: [
+    'VOXIST_API_KEY',
+  ],
   speechmatics: [
     'SPEECHMATICS_API_KEY',
     'SPEECHMATICS_HOST',
@@ -517,6 +520,25 @@ const normalizeAssemblyAi = (evt, channel, language) => {
   };
 };
 
+const normalizeVoxist = (evt, channel, language) => {
+  const copy = JSON.parse(JSON.stringify(evt));
+  return {
+    language_code: language,
+    channel_tag: channel,
+    is_final: evt.type === 'final',
+    alternatives: [
+      {
+        confidence: 1.00,
+        transcript: evt.text,
+      }
+    ],
+    vendor: {
+      name: 'voxist',
+      evt: copy
+    }
+  };
+};
+
 const normalizeSpeechmatics = (evt, channel, language) => {
   const copy = JSON.parse(JSON.stringify(evt));
   const is_final = evt.message === 'AddTranscript';
@@ -567,6 +589,8 @@ module.exports = (logger) => {
         return normalizeCobalt(evt, channel, language);
       case 'assemblyai':
         return normalizeAssemblyAi(evt, channel, language, shortUtterance);
+      case 'voxist':
+        return normalizeVoxist(evt, channel, language);
       case 'verbio':
         return normalizeVerbio(evt, channel, language);
       case 'speechmatics':
@@ -705,6 +729,8 @@ module.exports = (logger) => {
         //azureSttEndpointId overrides sttCredentials.custom_stt_endpoint
         ...(rOpts.azureSttEndpointId &&
           {AZURE_SERVICE_ENDPOINT_ID: rOpts.azureSttEndpointId}),
+        ...(azureOptions.speechRecognitionMode &&
+          {AZURE_RECOGNITION_MODE: azureOptions.speechRecognitionMode}),
       };
     }
     else if ('nuance' === vendor) {
@@ -924,6 +950,13 @@ module.exports = (logger) => {
           {ASSEMBLYAI_WORD_BOOST: JSON.stringify(rOpts.hints)})
       };
     }
+    else if ('voxist' === vendor) {
+      opts = {
+        ...opts,
+        ...(sttCredentials.api_key) &&
+          {VOXIST_API_KEY: sttCredentials.api_key},
+      };
+    }
     else if ('verbio' === vendor) {
       const {verbioOptions = {}} = rOpts;
       opts = {

package.json

@@ -31,9 +31,9 @@
     "@jambonz/http-health-check": "^0.0.1",
     "@jambonz/mw-registrar": "^0.2.7",
     "@jambonz/realtimedb-helpers": "^0.8.8",
-    "@jambonz/speech-utils": "^0.2.1",
+    "@jambonz/speech-utils": "^0.2.2",
     "@jambonz/stats-collector": "^0.1.10",
-    "@jambonz/verb-specifications": "^0.0.94",
+    "@jambonz/verb-specifications": "^0.0.95",
     "@jambonz/time-series": "^0.2.13",
     "@opentelemetry/api": "^1.8.0",
     "@opentelemetry/exporter-jaeger": "^1.23.0",