update speech utils version (#1070 )

Feat/1067 set default language if language is undefined (#1068 )
* sending recognition mode channel variable * change verb-specifications version * feat/1067 - setting default language to previously set language for the recognizer object if the vendor is default * added undefined check for fallbackVendor and fallbackLanguage
2026-01-25 02:07:56 +00:00 · 2025-02-07 08:00:33 -05:00 · 2025-02-06 08:06:56 -05:00 · 2025-02-05 08:33:35 -05:00 · 2025-02-03 08:47:44 -05:00 · 2025-02-02 22:10:51 -05:00
33 changed files with 2931 additions and 9000 deletions
--- a/2
+++ b/2
@@ -1,4 +1,4 @@
-FROM --platform=linux/amd64 node:18.15-alpine3.16 as base
+FROM --platform=linux/amd64 node:20-alpine as base

 RUN apk --update --no-cache add --virtual .builds-deps build-base python3

--- a/lib/config.js
+++ b/lib/config.js
@@ -137,6 +137,8 @@ const JAMBONES_EAGERLY_PRE_CACHE_AUDIO = parseInt(process.env.JAMBONES_EAGERLY_P

 const JAMBONES_USE_FREESWITCH_TIMER_FD = process.env.JAMBONES_USE_FREESWITCH_TIMER_FD;
 const JAMBONES_DIAL_SBC_FOR_REGISTERED_USER = process.env.JAMBONES_DIAL_SBC_FOR_REGISTERED_USER || false;
+const JAMBONES_MEDIA_TIMEOUT_MS = process.env.JAMBONES_MEDIA_TIMEOUT_MS || 0;
+const JAMBONES_MEDIA_HOLD_TIMEOUT_MS = process.env.JAMBONES_MEDIA_HOLD_TIMEOUT_MS || 0;

 module.exports = {
  JAMBONES_MYSQL_HOST,
@@ -223,5 +225,7 @@ module.exports = {
  JAMBONZ_DISABLE_DIAL_PAI_HEADER,
  JAMBONES_DISABLE_DIRECT_P2P_CALL,
  JAMBONES_USE_FREESWITCH_TIMER_FD,
-  JAMBONES_DIAL_SBC_FOR_REGISTERED_USER
+  JAMBONES_DIAL_SBC_FOR_REGISTERED_USER,
+  JAMBONES_MEDIA_TIMEOUT_MS,
+  JAMBONES_MEDIA_HOLD_TIMEOUT_MS
 };
--- a/lib/middleware.js
+++ b/lib/middleware.js
@@ -1,5 +1,5 @@
 const uuidv4 = require('uuid-random');
-const {CallDirection, AllowedSipRecVerbs} = require('./utils/constants');
+const {CallDirection, AllowedSipRecVerbs, WS_CLOSE_CODES} = require('./utils/constants');
 const {parseSiprecPayload} = require('./utils/siprec-utils');
 const CallInfo = require('./session/call-info');
 const HttpRequestor = require('./utils/http-requestor');
@@ -460,7 +460,7 @@ module.exports = function(srf, logger) {
      }).catch((err) => this.logger.info({err}, 'Error generating alert for parsing application'));
      logger.info({err}, `Error retrieving or parsing application: ${err?.message}`);
      res.send(480, {headers: {'X-Reason': err?.message || 'unknown'}});
-      app.requestor.close();
+      app.requestor.close(WS_CLOSE_CODES.GoingAway);
    }
  }

--- a/lib/session/call-session.js
+++ b/lib/session/call-session.js
@@ -9,7 +9,8 @@ const {
  KillReason,
  RecordState,
  AllowedSipRecVerbs,
-  AllowedConfirmSessionVerbs
+  AllowedConfirmSessionVerbs,
+  TtsStreamingEvents
 } = require('../utils/constants');
 const moment = require('moment');
 const assert = require('assert');
@@ -21,12 +22,15 @@ const listTaskNames = require('../utils/summarize-tasks');
 const HttpRequestor = require('../utils/http-requestor');
 const WsRequestor = require('../utils/ws-requestor');
 const ActionHookDelayProcessor = require('../utils/action-hook-delay');
+const TtsStreamingBuffer = require('../utils/tts-streaming-buffer');
 const {parseUri} = require('drachtio-srf');
 const {
  JAMBONES_INJECT_CONTENT,
  JAMBONES_EAGERLY_PRE_CACHE_AUDIO,
  AWS_REGION,
-  JAMBONES_USE_FREESWITCH_TIMER_FD
+  JAMBONES_USE_FREESWITCH_TIMER_FD,
+  JAMBONES_MEDIA_TIMEOUT_MS,
+  JAMBONES_MEDIA_HOLD_TIMEOUT_MS
 } = require('../config');
 const bent = require('bent');
 const BackgroundTaskManager = require('../utils/background-task-manager');
@@ -400,33 +404,41 @@ class CallSession extends Emitter {
    return this.application.transferredCall === true;
  }

+  /**
+   * returns true if this session is an inbound call session
+   */
+  get isInboundCallSession() {
+    return this.constructor.name === 'InboundCallSession';
+  }
+
  /**
   * returns true if this session is a ConfirmCallSession
   */
  get isAdultingCallSession() {
    return this.constructor.name === 'AdultingCallSession';
  }
-
-  /**
-   * returns true if this session is a ConfirmCallSession
-   */
  get isConfirmCallSession() {
    return this.constructor.name === 'ConfirmCallSession';
  }
-
-  /**
-   * returns true if this session is a SipRecCallSession
-   */
  get isSipRecCallSession() {
    return this.constructor.name === 'SipRecCallSession';
  }
-
-  /**
-   * returns true if this session is a SmsCallSession
-   */
  get isSmsCallSession() {
    return this.constructor.name === 'SmsCallSession';
  }
+  get isRestCallSession() {
+    return this.constructor.name === 'RestCallSession';
+  }
+  get InboundCallSession() {
+    return this.constructor.name === 'InboundCallSession';
+  }
+  get isNormalCallSession() {
+    return this.constructor.name === 'InboundCallSession' || this.constructor.name === 'RestCallSession';
+  }
+
+  get is3pccInvite() {
+    return this.isInboundCallSession && this.req?.body?.length === 0;
+  }

  get webhook_secret() {
    return this.accountInfo?.account?.webhook_secret;
@@ -440,6 +452,10 @@ class CallSession extends Emitter {
    return this.backgroundTaskManager.isTaskRunning('bargeIn');
  }

+  get isTtsStreamEnabled() {
+    return this.backgroundTaskManager.isTaskRunning('ttsStream');
+  }
+
  get isListenEnabled() {
    return this.backgroundTaskManager.isTaskRunning('listen');
  }
@@ -502,6 +518,10 @@ class CallSession extends Emitter {
    this._sipRequestWithinDialogHook = url;
  }

+  get isTtsStreamOpen() {
+    return this.currentTask?.isStreamingTts ||
+      this.backgroundTaskManager.getTask('ttsStream')?.isStreamingTts;
+  }
  // Bot Delay (actionHook delayed)
  get actionHookDelayEnabled() {
    return this._actionHookDelayEnabled;
@@ -552,7 +572,18 @@ class CallSession extends Emitter {
        this._actionHookDelayProcessor = new ActionHookDelayProcessor(this.logger, opts, this, this.ep);
        this._actionHookDelayProcessor.on('giveup', () => {
          this.logger.info('CallSession: ActionHookDelayProcessor: giveup event - hanging up call');
-          this._jambonzHangup();
+          const {writeAlerts} = this.srf.locals;
+          try {
+            writeAlerts({
+              alert_type: 'bot-action-delay-giveup',
+              account_sid: this.accountSid,
+              message: 'Call terminated due to bot action delay timeout',
+              target_sid: this.callSid
+            });
+          } catch (err) {
+            this.logger.error({err}, 'Error writing bot-action-delay-giveup alert');
+          }
+          this._jambonzHangup('bot-action-delay-giveup');
          if (this.wakeupResolver) {
            this.logger.debug('CallSession: Giveup timer expired - waking up');
            this.wakeupResolver({reason: 'noResponseGiveUp'});
@@ -576,6 +607,25 @@ class CallSession extends Emitter {
    }
  }

+  getTsStreamingVendor() {
+    let v;
+    if (this.currentTask?.isStreamingTts) {
+      const {vendor} = this.currentTask.getTtsVendorData(this);
+      v = vendor;
+    }
+    else if (this.backgroundTaskManager.getTask('ttsStream')?.isStreamingTts) {
+      const {vendor} = this.backgroundTaskManager.getTask('ttsStream').getTtsVendorData(this);
+      v = vendor;
+    }
+    return v;
+  }
+
+  get appIsUsingWebsockets() {
+    return this.requestor instanceof WsRequestor;
+  }
+
+  /* end of getters and setters */
+
  async clearOrRestoreActionHookDelayProcessor() {
    if (this._actionHookDelayProcessor) {
      await this._actionHookDelayProcessor.stop();
@@ -793,6 +843,38 @@ class CallSession extends Emitter {
    }
  }

+  async enableBackgroundTtsStream(say) {
+    try {
+      if (this.isTtsStreamEnabled) {
+        this.logger.debug('CallSession:enableBackgroundTtsStream - ttsStream currently enabled, ignoring request');
+      } else if (this.appIsUsingWebsockets && this.isNormalCallSession) {
+        await this.backgroundTaskManager.newTask('ttsStream', say);
+        this.logger.debug('CallSession:enableBackgroundTtsStream - ttsStream enabled');
+      } else {
+        this.logger.debug(
+          'CallSession:enableBackgroundTtsStream - ignoring request as call does not have required conditions');
+      }
+    }  catch (err) {
+      this.logger.info({err, say}, 'CallSession:enableBackgroundTtsStream - Error creating background tts stream task');
+    }
+  }
+
+  disableTtsStream() {
+    if (this.isTtsStreamEnabled) {
+      this.backgroundTaskManager.stop('ttsStream');
+      this.logger.debug('CallSession:disableTtsStream - ttsStream disabled');
+    }
+  }
+  clearTtsStream() {
+    this.requestor?.request('tts:streaming-event', '/streaming-event', {event_type: 'user_interruption'})
+      .catch((err) => this.logger.info({err}, 'CallSession:clearTtsStream - Error sending user_interruption'));
+    this.ttsStreamingBuffer?.clear();
+  }
+
+  startTtsStream() {
+    this.ttsStreamingBuffer?.start();
+  }
+
  async enableBotMode(gather, autoEnable) {
    try {
      let task;
@@ -981,6 +1063,14 @@ class CallSession extends Emitter {
            options: credential.options
          };
        }
+        else if ('cartesia' === vendor) {
+          return {
+            api_key: credential.api_key,
+            model_id: credential.model_id,
+            embedding: credential.embedding,
+            options: credential.options
+          };
+        }
        else if ('rimelabs' === vendor) {
          return {
            api_key: credential.api_key,
@@ -994,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,
@@ -1019,7 +1115,8 @@ class CallSession extends Emitter {
            speech_credential_sid: credential.speech_credential_sid,
            auth_token: credential.auth_token,
            custom_stt_url: credential.custom_stt_url,
-            custom_tts_url: credential.custom_tts_url
+            custom_tts_url: credential.custom_tts_url,
+            custom_tts_streaming_url: credential.custom_tts_streaming_url
          };
        }
      }
@@ -1052,6 +1149,17 @@ class CallSession extends Emitter {
      this.inbandDtmfEnabled = voipCarrier?.dtmf_type === 'tones';
    }

+    if (this.isNormalCallSession) {
+      this.ttsStreamingBuffer = new TtsStreamingBuffer(this);
+      this.ttsStreamingBuffer.on(TtsStreamingEvents.Empty, this._onTtsStreamingEmpty.bind(this));
+      this.ttsStreamingBuffer.on(TtsStreamingEvents.Pause, this._onTtsStreamingPause.bind(this));
+      this.ttsStreamingBuffer.on(TtsStreamingEvents.Resume, this._onTtsStreamingResume.bind(this));
+      this.ttsStreamingBuffer.on(TtsStreamingEvents.ConnectFailure, this._onTtsStreamingConnectFailure.bind(this));
+    }
+    else {
+      this.logger.info(`CallSession:exec - not a normal call session: ${this.constructor.name}`);
+    }
+
    while (this.tasks.length && !this.callGone) {
      const taskNum = ++this.taskIdx;
      const stackNum = this.stackIdx;
@@ -1186,6 +1294,11 @@ class CallSession extends Emitter {
      this.wakeupResolver({reason: 'session ended'});
      this.wakeupResolver = null;
    }
+
+    if (this._maxCallDurationTimer) {
+      clearTimeout(this._maxCallDurationTimer);
+      this._maxCallDurationTimer = null;
+    }
  }

  /**
@@ -1361,7 +1474,7 @@ class CallSession extends Emitter {
    if (!listenTask) {
      return this.logger.info('CallSession:_lccListenStatus - invalid listen_status: Dial does not have a listen');
    }
-    listenTask.updateListen(opts.listen_status);
+    listenTask.updateListen(opts.listen_status || opts.stream_status);
  }

  /**
@@ -1503,7 +1616,7 @@ Duration=${duration} `
    // this whole thing requires us to be in a Dial verb
    const task = this.currentTask;
    if (!task || ![TaskName.Dial, TaskName.Listen].includes(task.name)) {
-      return this.logger.info('CallSession:_lccWhisper - invalid command since we are not in a dial or listen');
+      return this.logger.info('CallSession:_lccWhisper - invalid command since we are not in a dial or stream/listen');
    }

    // allow user to provide a url object, a url string, an array of tasks, or a single task
@@ -1635,6 +1748,39 @@ Duration=${duration} `
      .catch((err) => this.logger.error(err, 'CallSession:_lccLlmUpdate'));
  }

+  async _lccTtsTokens(opts) {
+    const {id, tokens} = opts;
+
+    if (id === undefined) {
+      this.logger.info({opts}, 'CallSession:_lccTtsTokens - invalid command since id is missing');
+      return;
+    }
+    else if (tokens === undefined) {
+      this.logger.info({opts}, 'CallSession:_lccTtsTokens - invalid command since id is missing');
+      return this.requestor.request('tts:tokens-result', '/tokens-result', {
+        id,
+        status: 'failed',
+        reason: 'missing tokens'
+      }).catch((err) => this.logger.debug({err}, 'CallSession:_notifyTaskStatus - Error sending'));
+    }
+    let res;
+    try {
+      res = await this.ttsStreamingBuffer?.bufferTokens(tokens);
+      this.logger.info({id, res}, 'CallSession:_lccTtsTokens - tts:tokens-result');
+    } catch (err) {
+      this.logger.info(err, 'CallSession:_lccTtsTokens');
+    }
+    this.requestor.request('tts:tokens-result', '/tokens-result', {id, ...res})
+      .catch((err) => this.logger.debug({err}, 'CallSession:_notifyTaskStatus - Error sending'));
+  }
+
+  _lccTtsFlush(opts) {
+    this.ttsStreamingBuffer?.flush(opts);
+  }
+
+  _lccTtsClear(opts) {
+    this.ttsStreamingBuffer?.clear(opts);
+  }

  /**
   * perform call hangup by jambonz
@@ -1659,7 +1805,7 @@ Duration=${duration} `
    if (opts.call_hook || opts.child_call_hook) {
      return await this._lccCallHook(opts);
    }
-    if (opts.listen_status) {
+    if (opts.listen_status || opts.stream_status) {
      await this._lccListenStatus(opts);
    }
    if (opts.transcribe_status) {
@@ -1969,6 +2115,7 @@ Duration=${duration} `
        break;

      case 'listen:status':
+      case 'stream:status':
        this._lccListenStatus(data);
        break;

@@ -2016,6 +2163,18 @@ Duration=${duration} `
        this._lccLlmUpdate(data, call_sid);
        break;

+      case 'tts:tokens':
+        this._lccTtsTokens(data);
+        break;
+
+      case 'tts:flush':
+        this._lccTtsFlush(data);
+        break;
+
+      case 'tts:clear':
+        this._lccTtsClear(data);
+        break;
+
      default:
        this.logger.info(`CallSession:_onCommand - invalid command ${command}`);
    }
@@ -2098,7 +2257,6 @@ Duration=${duration} `
      //ep.cs = this;
      this.ep = ep;
      this.logger.info(`allocated endpoint ${ep.uuid}`);
-
      this._configMsEndpoint();

      this.ep.on('destroy', () => {
@@ -2211,6 +2369,8 @@ Duration=${duration} `
    // close all background tasks
    this.backgroundTaskManager.stopAll();
    this.clearOrRestoreActionHookDelayProcessor().catch((err) => {});
+
+    this.ttsStreamingBuffer?.stop();
  }

  /**
@@ -2260,22 +2420,43 @@ Duration=${duration} `
        },
        localSdp: this.ep.local.sdp
      });
-      this.logger.debug('answered call');
-      this.dlg.on('destroy', this._callerHungup.bind(this));
-      this.wrapDialog(this.dlg);
-      this.dlg.callSid = this.callSid;
-      this.emit('callStatusChange', {sipStatus: 200, sipReason: 'OK', callStatus: CallStatus.InProgress});

-      if (this.recordOptions && this.recordState === RecordState.RecordingOff) {
-        this.startRecording();
+      const tidyUp = () => {
+        this.dlg.on('destroy', this._callerHungup.bind(this));
+        this.wrapDialog(this.dlg);
+        this.dlg.callSid = this.callSid;
+        this.emit('callStatusChange', {sipStatus: 200, sipReason: 'OK', callStatus: CallStatus.InProgress});
+
+        if (this.recordOptions && this.recordState === RecordState.RecordingOff) {
+          this.startRecording();
+        }
+        this.dlg.on('modify', this._onReinvite.bind(this));
+        this.dlg.on('refer', this._onRefer.bind(this));
+        if (this.sipRequestWithinDialogHook) {
+          this.dlg.on('info', this._onRequestWithinDialog.bind(this));
+          this.dlg.on('message', this._onRequestWithinDialog.bind(this));
+        }
+        this.logger.debug(`CallSession:propagateAnswer - answered callSid ${this.callSid}`);
+      };
+
+      if (this.is3pccInvite) {
+        return new Promise((resolve, reject) => {
+          this.dlg.once('ack', (ackRequest) => {
+            this.logger.debug({body: ackRequest.body}, 'received ACK for 3pcc invite');
+            this.ep.modify(ackRequest.body)
+              .then(() => {
+                tidyUp();
+                return resolve();
+              })
+              .catch((err) => {
+                this.logger.info({err}, 'Error modifying endpoint with ACK');
+                reject(err);
+              });
+          });
+          this.logger.debug('this is a 3pcc invite');
+        });
      }
-      this.dlg.on('modify', this._onReinvite.bind(this));
-      this.dlg.on('refer', this._onRefer.bind(this));
-      if (this.sipRequestWithinDialogHook) {
-        this.dlg.on('info', this._onRequestWithinDialog.bind(this));
-        this.dlg.on('message', this._onRequestWithinDialog.bind(this));
-      }
-      this.logger.debug(`CallSession:propagateAnswer - answered callSid ${this.callSid}`);
+      tidyUp();
    }
    else {
      this.logger.debug('CallSession:propagateAnswer - call already answered - re-anchor media with a reinvite');
@@ -2309,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 {
@@ -2643,15 +2824,25 @@ Duration=${duration} `

  _configMsEndpoint() {
    this._enableInbandDtmfIfRequired(this.ep);
+    this.ep.once('destroy', this._handleMediaTimeout.bind(this));
    const opts = {
      ...(this.onHoldMusic && {holdMusic: `shout://${this.onHoldMusic.replace(/^https?:\/\//, '')}`}),
-      ...(JAMBONES_USE_FREESWITCH_TIMER_FD && {timer_name: 'timerfd'})
+      ...(JAMBONES_USE_FREESWITCH_TIMER_FD && {timer_name: 'timerfd'}),
+      ...(JAMBONES_MEDIA_TIMEOUT_MS && {media_timeout: JAMBONES_MEDIA_TIMEOUT_MS}),
+      ...(JAMBONES_MEDIA_HOLD_TIMEOUT_MS && {media_hold_timeout: JAMBONES_MEDIA_HOLD_TIMEOUT_MS})
    };
    if (Object.keys(opts).length > 0) {
      this.ep.set(opts);
    }
  }

+  async _handleMediaTimeout(evt) {
+    if (evt.reason === 'MEDIA_TIMEOUT' && !this.callGone) {
+      this.logger.info('CallSession:_handleMediaTimeout: received MEDIA_TIMEOUT, hangup the call');
+      this._jambonzHangup('Media Timeout');
+    }
+  }
+
  async _enableInbandDtmfIfRequired(ep) {
    if (ep.inbandDtmfEnabled) return;
    // only enable inband dtmf detection if voip carrier dtmf_type === tones
@@ -2745,6 +2936,58 @@ Duration=${duration} `
      this.verbHookSpan = null;
    }
  }
+
+  _onTtsStreamingEmpty() {
+    const task = this.currentTask;
+    if (task && TaskName.Say === task.name) {
+      task.notifyTtsStreamIsEmpty();
+    }
+  }
+
+  _onTtsStreamingPause() {
+    this.requestor?.request('tts:streaming-event', '/streaming-event', {event_type: 'stream_paused'})
+      .catch((err) => this.logger.info({err}, 'CallSession:_onTtsStreamingPause - Error sending'));
+  }
+
+  _onTtsStreamingResume() {
+    this.requestor?.request('tts:streaming-event', 'streaming-event', {event_type: 'stream_resumed'})
+      .catch((err) => this.logger.info({err}, 'CallSession:_onTtsStreamingResume - Error sending'));
+  }
+
+  async _onTtsStreamingConnectFailure(vendor) {
+    const {writeAlerts, AlertType} = this.srf.locals;
+    try {
+      await writeAlerts({
+        alert_type: AlertType.TTS_STREAMING_CONNECTION_FAILURE,
+        account_sid: this.accountSid,
+        vendor
+      });
+    } catch (error) {
+      this.logger.error({error}, 'Error writing WEBHOOK_CONNECTION_FAILURE alert');
+    }
+    this.logger.info({vendor}, 'CallSession:_onTtsStreamingConnectFailure - tts streaming connect failure');
+  }
+
+  async startMaxCallDurationTimer(timeLimit) {
+    if (!this._maxCallDurationTimer && timeLimit > 0) {
+      this.timeLimit = timeLimit;
+      this._maxCallDurationTimer = setTimeout(this._onMaxCallDuration.bind(this), timeLimit * 1000);
+      this.logger.debug(`CallSession:startMaxCallDurationTimer - started max call duration timer for ${timeLimit}s`);
+    }
+  }
+
+  /**
+   * _onMaxCallDuration - called when the call has reached the maximum duration
+   */
+  _onMaxCallDuration() {
+    this.logger.info(`callSession:_onMaxCallDuration tearing down call as it has reached ${this.timeLimit}s`);
+    if (!this.dlg) {
+      this.logger.debug('CallSession:_onMaxCallDuration - no dialog, call already gone');
+      return;
+    }
+    this._jambonzHangup('Max Call Duration');
+    this._maxCallDurationTimer = null;
+  }
 }

 module.exports = CallSession;
--- a/lib/session/inbound-call-session.js
+++ b/lib/session/inbound-call-session.js
@@ -70,8 +70,12 @@ class InboundCallSession extends CallSession {
    this._hangup('caller');
  }

-  _jambonzHangup() {
-    this.dlg?.destroy();
+  _jambonzHangup(reason) {
+    this.dlg?.destroy({
+      headers: {
+        ...(reason && {'X-Reason': reason})
+      }
+    });
    // kill current task or wakeup the call session.
    this._callReleased();
  }
--- a/lib/tasks/config.js
+++ b/lib/tasks/config.js
@@ -16,7 +16,8 @@ class TaskConfig extends Task {
      'fillerNoise',
      'actionHookDelayAction',
      'boostAudioSignal',
-      'vad'
+      'vad',
+      'ttsStream'
    ].forEach((k) => this[k] = this.data[k] || {});

    if ('notifyEvents' in this.data) {
@@ -45,6 +46,12 @@ class TaskConfig extends Task {
      };
      delete this.transcribeOpts.enable;
    }
+    if (this.ttsStream.enable) {
+      this.sayOpts = {
+        verb: 'say',
+        stream: true
+      };
+    }

    if (this.data.reset) {
      if (typeof this.data.reset === 'string') this.data.reset = [this.data.reset];
@@ -75,6 +82,7 @@ class TaskConfig extends Task {
  get hasVad() { return Object.keys(this.vad).length; }
  get hasFillerNoise() { return Object.keys(this.fillerNoise).length; }
  get hasReferHook() { return Object.keys(this.data).includes('referHook'); }
+  get hasTtsStream() { return Object.keys(this.ttsStream).length; }

  get summary() {
    const phrase = [];
@@ -106,6 +114,9 @@ class TaskConfig extends Task {
    if (this.onHoldMusic) phrase.push(`onHoldMusic: ${this.onHoldMusic}`);
    if ('boostAudioSignal' in this.data) phrase.push(`setGain ${this.data.boostAudioSignal}`);
    if (this.hasReferHook) phrase.push('set referHook');
+    if (this.hasTtsStream) {
+      phrase.push(`${this.ttsStream.enable ? 'enable' : 'disable'} ttsStream`);
+    }
    return `${this.name}{${phrase.join(',')}}`;
  }

@@ -176,18 +187,20 @@ class TaskConfig extends Task {
        : cs.speechRecognizerVendor;
      cs.speechRecognizerLabel = this.recognizer.label === 'default'
        ? cs.speechRecognizerLabel : this.recognizer.label;
-      cs.speechRecognizerLanguage = this.recognizer.language !== 'default'
+      cs.speechRecognizerLanguage = this.recognizer.language !== undefined && this.recognizer.language !== 'default'
        ? this.recognizer.language
        : cs.speechRecognizerLanguage;

      //fallback
-      cs.fallbackSpeechRecognizerVendor = this.recognizer.fallbackVendor !== 'default'
+      cs.fallbackSpeechRecognizerVendor = this.recognizer.fallbackVendor !== undefined &&
+        this.recognizer.fallbackVendor !== 'default'
        ? this.recognizer.fallbackVendor
        : cs.fallbackSpeechRecognizerVendor;
      cs.fallbackSpeechRecognizerLabel = this.recognizer.fallbackLabel === 'default' ?
        cs.fallbackSpeechRecognizerLabel :
        this.recognizer.fallbackLabel;
-      cs.fallbackSpeechRecognizerLanguage = this.recognizer.fallbackLanguage !== 'default'
+      cs.fallbackSpeechRecognizerLanguage = this.recognizer.fallbackLanguage !== undefined &&
+        this.recognizer.fallbackLanguage !== 'default'
        ? this.recognizer.fallbackLanguage
        : cs.fallbackSpeechRecognizerLanguage;

@@ -305,6 +318,22 @@ class TaskConfig extends Task {
    if (this.hasReferHook) {
      cs.referHook = this.data.referHook;
    }
+
+    if (this.ttsStream.enable && this.sayOpts) {
+      this.sayOpts.synthesizer = this.hasSynthesizer ? this.synthesizer : {
+        vendor: cs.speechSynthesisVendor,
+        language: cs.speechSynthesisLanguage,
+        voice: cs.speechSynthesisVoice,
+        ...(cs.speechSynthesisLabel && {
+          label: cs.speechSynthesisLabel
+        })
+      };
+      this.logger.info({opts: this.gatherOpts}, 'Config: enabling ttsStream');
+      cs.enableBackgroundTtsStream(this.sayOpts);
+    } else if (!this.ttsStream.enable) {
+      this.logger.info('Config: disabling ttsStream');
+      cs.disableTtsStream();
+    }
  }

  async kill(cs) {
--- a/lib/tasks/dial.js
+++ b/lib/tasks/dial.js
@@ -121,8 +121,9 @@ class TaskDial extends Task {
      }
    }

-    if (this.data.listen) {
-      this.listenTask = makeTask(logger, {'listen': this.data.listen}, this);
+    const listenData = this.data.listen || this.data.stream;
+    if (listenData) {
+      this.listenTask = makeTask(logger, {'listen': listenData }, this);
    }
    if (this.data.transcribe) {
      this.transcribeTask = makeTask(logger, {'transcribe' : this.data.transcribe}, this);
@@ -273,7 +274,9 @@ class TaskDial extends Task {
    this._removeDtmfDetection(this.dlg);
    await this._killOutdials();
    if (this.sd) {
-      this.sd.kill();
+      const byeReasonHeader = this.killReason === KillReason.MediaTimeout ? 'Media Timeout' : undefined;
+      this.sd.kill(byeReasonHeader);
+      this.sd.ep?.removeListener('destroy', this._handleMediaTimeout.bind(this));
      this.sd.removeAllListeners();
      this.sd = null;
    }
@@ -519,7 +522,7 @@ class TaskDial extends Task {
    const {req, callInfo, direction, srf} = cs;
    const {getSBC} = srf.locals;
    const {lookupTeamsByAccount, lookupAccountBySid} = srf.locals.dbHelpers;
-    const {lookupCarrier, lookupCarrierByPhoneNumber} = dbUtils(this.logger, cs.srf);
+    const {lookupCarrier, lookupCarrierByPhoneNumber, lookupVoipCarrierBySid} = dbUtils(this.logger, cs.srf);
    let sbcAddress = this.proxy || getSBC();
    const teamsInfo = {};
    let fqdn;
@@ -538,6 +541,8 @@ class TaskDial extends Task {
      ...this.headers
    };

+    // default to inband dtmf if not specified
+    this.inbandDtmfEnabled = cs.inbandDtmfEnabled;
    // get calling user from From header
    const parsedFrom = req.getParsedHeader('from');
    const fromUri = parseUri(parsedFrom.uri);
@@ -615,10 +620,17 @@ class TaskDial extends Task {
          const str = this.callerId || req.callingNumber || '';
          const callingNumber = str.startsWith('+') ? str.substring(1) : str;
          const voip_carrier_sid = await lookupCarrierByPhoneNumber(cs.accountSid, callingNumber);
+          const req_voip_carrier_sid = req.has('X-Voip-Carrier-Sid') ? req.get('X-Voip-Carrier-Sid') : null;
          if (voip_carrier_sid) {
            this.logger.info(
              `Dial:_attemptCalls: selected voip_carrier_sid ${voip_carrier_sid} for callingNumber: ${callingNumber}`);
            opts.headers['X-Requested-Carrier-Sid'] = voip_carrier_sid;
+
+            // Checking if outbound carrier is different from inbound carrier and has dtmf type tones
+            if (voip_carrier_sid !== req_voip_carrier_sid) {
+              const [voipCarrier] = await lookupVoipCarrierBySid(voip_carrier_sid);
+              this.inbandDtmfEnabled = voipCarrier?.dtmf_type === 'tones';
+            }
          }
        }

@@ -862,7 +874,7 @@ class TaskDial extends Task {
    if (cs.sipRequestWithinDialogHook) this._initSipIndialogRequestListener(cs, this.dlg);

    if (this.transcribeTask) this.transcribeTask.exec(cs, {ep: this.epOther, ep2:this.ep});
-    if (this.listenTask) this.listenTask.exec(cs, {ep: this.epOther});
+    if (this.listenTask) this.listenTask.exec(cs, {ep: this.listenTask.channel === 2 ? this.ep : this.epOther});
    if (this.startAmd) {
      try {
        this.startAmd(cs, this.ep, this, this.data.amd);
@@ -887,6 +899,14 @@ class TaskDial extends Task {
    if (this.canReleaseMedia || this.shouldExitMediaPathEntirely) {
      setTimeout(this._releaseMedia.bind(this, cs, sd, this.shouldExitMediaPathEntirely), 200);
    }
+
+    this.sd.ep.once('destroy', this._handleMediaTimeout.bind(this));
+  }
+
+  _handleMediaTimeout(evt) {
+    if (evt.reason === 'MEDIA_TIMEOUT' && this.sd && this.bridged) {
+      this.kill(this.cs, KillReason.MediaTimeout);
+    }
  }

  _bridgeEarlyMedia(sd) {
--- a/lib/tasks/gather.js
+++ b/lib/tasks/gather.js
@@ -11,6 +11,7 @@ const {
  NvidiaTranscriptionEvents,
  JambonzTranscriptionEvents,
  AssemblyAiTranscriptionEvents,
+  VoxistTranscriptionEvents,
  VadDetection,
  VerbioTranscriptionEvents,
  SpeechmaticsTranscriptionEvents
@@ -24,6 +25,7 @@ const makeTask = require('./make_task');
 const assert = require('assert');
 const SttTask = require('./stt-task');
 const { SpeechCredentialError } = require('../utils/error');
+const SPEECHMATICS_DEFAULT_ASR_TIMEOUT = 1200;

 class TaskGather extends SttTask {
  constructor(logger, opts, parentTask) {
@@ -162,6 +164,16 @@ class TaskGather extends SttTask {
      this.logger.debug({hints: this.data.recognizer.hints, hintsBoost: this.data.recognizer.hintsBoost},
        'Gather:exec - applying global sttHints');
    }
+
+    // specials case for speechmatics: they dont do endpointing so we need to enable continuous ASR
+    if (this.vendor === 'speechmatics' && !this.isContinuousAsr) {
+      const maxDelay = this.recognizer?.speechmaticsOptions?.transcription_config?.max_delay;
+      if (maxDelay) this.asrTimeout = Math.min(SPEECHMATICS_DEFAULT_ASR_TIMEOUT, maxDelay * 1000);
+      else this.asrTimeout = SPEECHMATICS_DEFAULT_ASR_TIMEOUT;
+      this.isContinuousAsr = true;
+      this.logger.debug(`Gather:exec - auto-enabling continuous ASR for speechmatics w/ timeout ${this.asrTimeout}`);
+    }
+
    if (!this.isContinuousAsr && cs.isContinuousAsr) {
      this.isContinuousAsr = true;
      this.asrTimeout = cs.asrTimeout * 1000;
@@ -513,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(
@@ -723,6 +746,7 @@ class TaskGather extends SttTask {
        this._fillerNoiseOn = false;  // in a race, if we just started audio it may sneak through here
        this.ep.api('uuid_break', this.ep.uuid)
          .catch((err) => this.logger.info(err, 'Error killing audio'));
+        cs.clearTtsStream();
      }
      return;
    }
@@ -831,7 +855,7 @@ class TaskGather extends SttTask {
        const t = evt.alternatives[0].transcript;
        if (t) {
          /* remove trailing punctuation */
-          if (/[,;:\.!\?]$/.test(t)) {
+          if (this.vendor !== 'speechmatics' && /[,;:\.!\?]$/.test(t)) {
            this.logger.debug('TaskGather:_onTranscription - removing trailing punctuation');
            evt.alternatives[0].transcript = t.slice(0, -1);
          }
@@ -1170,7 +1194,6 @@ class TaskGather extends SttTask {
    } catch (err) {  /*already logged error*/ }

    // Gather got response from hook, cancel actionHookDelay processing
-    this.logger.debug('TaskGather:_resolve - checking ahd');
    if (this.cs.actionHookDelayProcessor) {
      if (returnedVerbs) {
        this.logger.debug('TaskGather:_resolve - got response from action hook, cancelling actionHookDelay');
--- a/lib/tasks/listen.js
+++ b/lib/tasks/listen.js
@@ -17,7 +17,7 @@ class TaskListen extends Task {

    [
      'action', 'auth', 'method', 'url', 'finishOnKey', 'maxLength', 'metadata', 'mixType', 'passDtmf', 'playBeep',
-      'sampleRate', 'timeout', 'transcribe', 'wsAuth', 'disableBidirectionalAudio'
+      'sampleRate', 'timeout', 'transcribe', 'wsAuth', 'disableBidirectionalAudio', 'channel'
    ].forEach((k) => this[k] = this.data[k]);

    this.mixType = this.mixType || 'mono';
--- a/lib/tasks/llm/index.js
+++ b/lib/tasks/llm/index.js
@@ -1,6 +1,9 @@
 const Task = require('../task');
 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) {
@@ -40,10 +43,22 @@ class TaskLlm extends Task {
    switch (this.vendor) {
      case 'openai':
      case 'microsoft':
-        if (this.model.startsWith('gpt-4o-realtime')) {
-          llm = new TaskLlmOpenAI_S2S(this.logger, this.data, this);
-        }
+        llm = new TaskLlmOpenAI_S2S(this.logger, this.data, this);
        break;
+
+      case 'voiceagent':
+      case 'deepgram':
+        llm = new TaskLlmVoiceAgent_S2S(this.logger, this.data, this);
+        break;
+
+      case 'ultravox':
+        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`);
    }
--- a/lib/tasks/llm/llms/elevenlabs_s2s.js
+++ b/lib/tasks/llm/llms/elevenlabs_s2s.js
@@ -0,0 +1,302 @@
+const Task = require('../../task');
+const TaskName = 'Llm_Elevenlabs_s2s';
+const {LlmEvents_Elevenlabs} = require('../../../utils/constants');
+const {request} = require('undici');
+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; }
+
+  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];
+      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;
--- a/lib/tasks/llm/llms/openai_s2s.js
+++ b/lib/tasks/llm/llms/openai_s2s.js
@@ -59,7 +59,7 @@ class TaskLlmOpenAI_S2S extends Task {
    this.parent = parentTask;

    this.vendor = this.parent.vendor;
-    this.model = this.parent.model;
+    this.model = this.parent.model || 'gpt-4o-realtime-preview-2024-12-17';
    this.auth = this.parent.auth;
    this.connectionOptions = this.parent.connectOptions;

@@ -120,9 +120,9 @@ class TaskLlmOpenAI_S2S extends Task {

    switch (this.vendor) {
      case 'openai':
-        return 'v1/realtime?model=gpt-4o-realtime-preview-2024-10-01';
+        return `v1/realtime?model=${this.model}`;
      case 'microsoft':
-        return 'openai/realtime?api-version=2024-10-01-preview&deployment=gpt-4o-realtime-preview-1001&';
+        return `openai/realtime?api-version=2024-10-01-preview&deployment=${this.model}`;
    }
  }

--- a/lib/tasks/llm/llms/ultravox_s2s.js
+++ b/lib/tasks/llm/llms/ultravox_s2s.js
@@ -0,0 +1,245 @@
+const Task = require('../../task');
+const TaskName = 'Llm_Ultravox_s2s';
+const {request} = require('undici');
+const {LlmEvents_Ultravox} = require('../../../utils/constants');
+
+const ultravox_server_events = [
+  'pong',
+  'state',
+  'transcript',
+  'conversationText',
+  'clientToolInvocation',
+  'playbackClearBuffer',
+];
+
+const ClientEvent = 'client.event';
+
+const expandWildcards = (events) => {
+  // no-op for deepgram
+  return events;
+};
+
+const SessionDelete = 'session.delete';
+
+class TaskLlmUltravox_S2S extends Task {
+  constructor(logger, opts, parentTask) {
+    super(logger, opts, parentTask);
+    this.parent = parentTask;
+
+    this.vendor = this.parent.vendor;
+    this.model = this.parent.model || 'fixie-ai/ultravox';
+    this.auth = this.parent.auth;
+    this.connectionOptions = this.parent.connectOptions;
+
+    const {apiKey} = this.auth || {};
+    if (!apiKey) throw new Error('auth.apiKey is required for Vendor: Ultravox');
+    this.apiKey = apiKey;
+    this.actionHook = this.data.actionHook;
+    this.eventHook = this.data.eventHook;
+    this.toolHook = this.data.toolHook;
+
+    /**
+     * 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 || ultravox_server_events);
+
+    this.addCustomEventListener = parentTask.addCustomEventListener.bind(parentTask);
+    this.removeCustomEventListeners = parentTask.removeCustomEventListeners.bind(parentTask);
+  }
+
+  get name() { return TaskName; }
+
+  async _api(ep, args) {
+    const res = await ep.api('uuid_ultravox_s2s', `^^|${args.join('|')}`);
+    if (!res.body?.startsWith('+OK')) {
+      throw new Error(`Error calling uuid_ultravox_s2s: ${JSON.stringify(res.body)}`);
+    }
+  }
+
+  async createCall() {
+    const payload = {
+      ...this.data.llmOptions,
+      model: this.model,
+      medium: {
+        ...(this.data.llmOptions.medium || {}),
+        serverWebSocket: {
+          inputSampleRate: 8000,
+          outputSampleRate: 8000,
+        }
+      }
+    };
+    const {statusCode, body} = await request('https://api.ultravox.ai/api/calls', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'X-API-Key': this.apiKey
+      },
+      body: JSON.stringify(payload)
+    });
+    const data = await body.json();
+    if (statusCode !== 201 || !data?.joinUrl) {
+      this.logger.error({statusCode, data}, 'Ultravox Error registering call');
+      throw new Error(`Ultravox  Error registering call: ${data.message}`);
+    }
+    this.logger.info({joinUrl: data.joinUrl}, 'Ultravox Call registered');
+    return data.joinUrl;
+  }
+
+  _unregisterHandlers() {
+    this.removeCustomEventListeners();
+  }
+
+  _registerHandlers(ep) {
+    this.addCustomEventListener(ep, LlmEvents_Ultravox.Connect, this._onConnect.bind(this, ep));
+    this.addCustomEventListener(ep, LlmEvents_Ultravox.ConnectFailure, this._onConnectFailure.bind(this, ep));
+    this.addCustomEventListener(ep, LlmEvents_Ultravox.Disconnect, this._onDisconnect.bind(this, ep));
+    this.addCustomEventListener(ep, LlmEvents_Ultravox.ServerEvent, this._onServerEvent.bind(this, ep));
+  }
+
+  async _startListening(cs, ep) {
+    this._registerHandlers(ep);
+
+    const joinUrl = await this.createCall();
+    // split the joinUrl into host and path
+    const {host, pathname, search} = new URL(joinUrl);
+
+    try {
+      const args = [ep.uuid, 'session.create', host, pathname + search];
+      await this._api(ep, args);
+    } catch (err) {
+      this.logger.error({err}, 'TaskLlmUltraVox_S2S:_startListening');
+      this.notifyTaskDone();
+    }
+  }
+
+  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}, 'TaskLlmUltravox_S2S:kill - error deleting session'));
+
+    this.notifyTaskDone();
+  }
+
+  _onConnect(ep) {
+    this.logger.debug('TaskLlmUltravox_S2S:_onConnect');
+  }
+  _onConnectFailure(_ep, evt) {
+    this.logger.info(evt, 'TaskLlmUltravox_S2S:_onConnectFailure');
+    this.results = {completionReason: 'connection failure'};
+    this.notifyTaskDone();
+  }
+  _onDisconnect(_ep, evt) {
+    this.logger.info(evt, 'TaskLlmUltravox_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}, 'TaskLlmUltravox_S2S:_onServerEvent');
+
+    /* server errors of some sort */
+    if (type === 'error') {
+      endConversation = true;
+      this.results = {
+        completionReason: 'server error',
+        error: evt.error
+      };
+    }
+
+    /* tool calls */
+    else if (type === 'client_tool_invocation') {
+      this.logger.debug({evt}, 'TaskLlmUltravox_S2S:_onServerEvent - function_call');
+      if (!this.toolHook) {
+        this.logger.warn({evt}, 'TaskLlmUltravox_S2S:_onServerEvent - no toolHook defined!');
+      }
+      else {
+        const {toolName: name, invocationId: call_id, parameters: args} = evt;
+
+        try {
+          await this.parent.sendToolHook(call_id, {name, args});
+        } catch (err) {
+          this.logger.info({err, evt}, 'TaskLlmUltravox_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}, 'TaskLlmUltravox_S2S:_onServerEvent - error sending event hook'));
+    }
+
+    if (endConversation) {
+      this.logger.info({results: this.results},
+        'TaskLlmUltravox_S2S:_onServerEvent - ending conversation due to error');
+      this.notifyTaskDone();
+    }
+  }
+
+  async processToolOutput(ep, tool_call_id, data) {
+    try {
+      this.logger.debug({tool_call_id, data}, 'TaskLlmUltravox_S2S:processToolOutput');
+
+      if (!data.type || data.type !== 'client_tool_result') {
+        this.logger.info({data},
+          'TaskLlmUltravox_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}, 'TaskLlmUltravox_S2S:processToolOutput');
+    }
+  }
+
+  _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 = ultravox_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
+    }, 'TaskLlmUltravox_S2S:_populateEvents');
+  }
+}
+
+module.exports = TaskLlmUltravox_S2S;
--- a/lib/tasks/llm/llms/voice_agent_s2s.js
+++ b/lib/tasks/llm/llms/voice_agent_s2s.js
@@ -0,0 +1,313 @@
+const Task = require('../../task');
+const TaskName = 'Llm_VoiceAgent_s2s';
+const {LlmEvents_VoiceAgent} = require('../../../utils/constants');
+const ClientEvent = 'client.event';
+const SessionDelete = 'session.delete';
+
+const va_server_events = [
+  'Error',
+  'Welcome',
+  'SettingsApplied',
+  'ConversationText',
+  'UserStartedSpeaking',
+  'EndOfThought',
+  'AgentThinking',
+  'FunctionCallRequest',
+  'FunctionCalling',
+  'AgentStartedSpeaking',
+  'AgentAudioDone',
+];
+
+const expandWildcards = (events) => {
+  // no-op for deepgram
+  return events;
+};
+
+class TaskLlmVoiceAgent_S2S extends Task {
+  constructor(logger, opts, parentTask) {
+    super(logger, opts, parentTask);
+    this.parent = parentTask;
+
+    this.vendor = this.parent.vendor;
+    this.model = this.parent.model;
+    this.auth = this.parent.auth;
+    this.connectionOptions = this.parent.connectOptions;
+
+    const {apiKey} = this.auth || {};
+    if (!apiKey) throw new Error('auth.apiKey is required for VoiceAgent S2S');
+
+    this.apiKey = apiKey;
+    this.authType = 'bearer';
+    this.actionHook = this.data.actionHook;
+    this.eventHook = this.data.eventHook;
+    this.toolHook = this.data.toolHook;
+    const {settingsConfiguration} = this.data.llmOptions;
+
+    if (typeof settingsConfiguration !== 'object') {
+      throw new Error('llmOptions with an initial settingsConfiguration is required for VoiceAgent S2S');
+    }
+
+    // eslint-disable-next-line no-unused-vars
+    const {audio, ...rest} = settingsConfiguration;
+    const cfg = this.settingsConfiguration = rest;
+
+    if (!cfg.agent) throw new Error('llmOptions.settingsConfiguration.agent is required for VoiceAgent S2S');
+    if (!cfg.agent.think) {
+      throw new Error('llmOptions.settingsConfiguration.agent.think is required for VoiceAgent S2S');
+    }
+    if (!cfg.agent.think.model) {
+      throw new Error('llmOptions.settingsConfiguration.agent.think.model is required for VoiceAgent S2S');
+    }
+    if (!cfg.agent.think.provider?.type) {
+      throw new Error('llmOptions.settingsConfiguration.agent.think.provider.type is required for VoiceAgent S2S');
+    }
+
+    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 || va_server_events);
+
+    this.addCustomEventListener = parentTask.addCustomEventListener.bind(parentTask);
+    this.removeCustomEventListeners = parentTask.removeCustomEventListeners.bind(parentTask);
+  }
+
+  get name() { return TaskName; }
+
+  get host() {
+    const {host} = this.connectionOptions || {};
+    return host || 'agent.deepgram.com';
+  }
+
+  get path() {
+    const {path} = this.connectionOptions || {};
+    if (path) return path;
+
+    return '/agent';
+  }
+
+  async _api(ep, args) {
+    const res = await ep.api('uuid_voice_agent_s2s', `^^|${args.join('|')}`);
+    if (!res.body?.startsWith('+OK')) {
+      throw new Error(`Error calling uuid_voice_agent_s2s: ${JSON.stringify(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}, 'TaskLlmVoiceAgent_S2S:kill - error deleting session'));
+
+    this.notifyTaskDone();
+  }
+
+  /**
+   * Send function call response to the VoiceAgent server
+   */
+  async processToolOutput(ep, tool_call_id, data) {
+    try {
+      const {data:response} = data;
+      this.logger.debug({tool_call_id, response}, 'TaskLlmVoiceAgent_S2S:processToolOutput');
+
+      if (!response.type || response.type !== 'FunctionCallResponse') {
+        this.logger.info({response},
+          'TaskLlmVoiceAgent_S2S:processToolOutput - invalid tool output, must be FunctionCallResponse');
+      }
+      else {
+        await this._api(ep, [ep.uuid, ClientEvent, JSON.stringify(response)]);
+      }
+    } catch (err) {
+      this.logger.info({err}, 'TaskLlmVoiceAgent_S2S:processToolOutput');
+    }
+  }
+
+  /**
+   * Send a session.update to the VoiceAgent server
+   * Note: creating and deleting conversation items also supported as well as interrupting the assistant
+   */
+  async processLlmUpdate(ep, data, _callSid) {
+    try {
+      this.logger.debug({data, _callSid}, 'TaskLlmVoiceAgent_S2S:processLlmUpdate');
+
+      if (!data.type || ![
+        'UpdateInstructions',
+        'UpdateSpeak',
+        'InjectAgentMessage',
+      ].includes(data.type)) {
+        this.logger.info({data}, 'TaskLlmVoiceAgent_S2S:processLlmUpdate - invalid mid-call request');
+      }
+      else {
+        await this._api(ep, [ep.uuid, ClientEvent, JSON.stringify(data)]);
+      }
+    } catch (err) {
+      this.logger.info({err}, 'TaskLlmVoiceAgent_S2S:processLlmUpdate');
+    }
+  }
+
+  async _startListening(cs, ep) {
+    this._registerHandlers(ep);
+
+    try {
+      const args = [ep.uuid, 'session.create', this.host, this.path, this.authType, this.apiKey];
+      await this._api(ep, args);
+    } catch (err) {
+      this.logger.error({err}, `TaskLlmVoiceAgent_S2S:_startListening: ${JSON.stringify(err)}`);
+      this.notifyTaskDone();
+    }
+  }
+
+  async _sendClientEvent(ep, obj) {
+    let ok = true;
+    this.logger.debug({obj}, 'TaskLlmVoiceAgent_S2S:_sendClientEvent');
+    try {
+      const args = [ep.uuid, ClientEvent, JSON.stringify(obj)];
+      await this._api(ep, args);
+    } catch (err) {
+      ok = false;
+      this.logger.error({err}, 'TaskLlmVoiceAgent_S2S:_sendClientEvent - Error');
+    }
+    return ok;
+  }
+
+  async _sendInitialMessage(ep) {
+    if (!await this._sendClientEvent(ep, this.settingsConfiguration)) {
+      this.notifyTaskDone();
+    }
+  }
+
+  _registerHandlers(ep) {
+    this.addCustomEventListener(ep, LlmEvents_VoiceAgent.Connect, this._onConnect.bind(this, ep));
+    this.addCustomEventListener(ep, LlmEvents_VoiceAgent.ConnectFailure, this._onConnectFailure.bind(this, ep));
+    this.addCustomEventListener(ep, LlmEvents_VoiceAgent.Disconnect, this._onDisconnect.bind(this, ep));
+    this.addCustomEventListener(ep, LlmEvents_VoiceAgent.ServerEvent, this._onServerEvent.bind(this, ep));
+  }
+
+  _unregisterHandlers() {
+    this.removeCustomEventListeners();
+  }
+
+  _onError(_ep, evt) {
+    this.logger.info({evt}, 'TaskLlmVoiceAgent_S2S:_onError');
+    this.notifyTaskDone();
+  }
+
+  _onConnect(ep) {
+    this.logger.debug('TaskLlmVoiceAgent_S2S:_onConnect');
+    this._sendInitialMessage(ep);
+  }
+  _onConnectFailure(_ep, evt) {
+    this.logger.info(evt, 'TaskLlmVoiceAgent_S2S:_onConnectFailure');
+    this.results = {completionReason: 'connection failure'};
+    this.notifyTaskDone();
+  }
+  _onDisconnect(_ep, evt) {
+    this.logger.info(evt, 'TaskLlmVoiceAgent_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}, 'TaskLlmVoiceAgent_S2S:_onServerEvent');
+
+    /* check for failures, such as rate limit exceeded, that should terminate the conversation */
+    if (type === 'response.done' && evt.response.status === 'failed') {
+      endConversation = true;
+      this.results = {
+        completionReason: 'server failure',
+        error: evt.response.status_details?.error
+      };
+    }
+
+    /* server errors of some sort */
+    else if (type === 'error') {
+      endConversation = true;
+      this.results = {
+        completionReason: 'server error',
+        error: evt.error
+      };
+    }
+
+    /* tool calls */
+    else if (type === 'FunctionCallRequest') {
+      this.logger.debug({evt}, 'TaskLlmVoiceAgent_S2S:_onServerEvent - function_call');
+      if (!this.toolHook) {
+        this.logger.warn({evt}, 'TaskLlmVoiceAgent_S2S:_onServerEvent - no toolHook defined!');
+      }
+      else {
+        const {function_name:name, function_call_id:call_id} = evt;
+        const args = evt.input;
+
+        try {
+          await this.parent.sendToolHook(call_id, {name, args});
+        } catch (err) {
+          this.logger.info({err, evt}, 'TaskLlmVoiceAgent - 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}, 'TaskLlmVoiceAgent_S2S:_onServerEvent - error sending event hook'));
+    }
+
+    if (endConversation) {
+      this.logger.info({results: this.results},
+        'TaskLlmVoiceAgent_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 = va_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
+    }, 'TaskLlmVoiceAgent_S2S:_populateEvents');
+  }
+}
+
+module.exports = TaskLlmVoiceAgent_S2S;
--- a/lib/tasks/make_task.js
+++ b/lib/tasks/make_task.js
@@ -84,6 +84,7 @@ function makeTask(logger, obj, parent) {
      const TaskTranscribe = require('./transcribe');
      return new TaskTranscribe(logger, data, parent);
    case TaskName.Listen:
+    case TaskName.Stream:
      const TaskListen = require('./listen');
      return new TaskListen(logger, data, parent);
    case TaskName.Redirect:
--- a/lib/tasks/redirect.js
+++ b/lib/tasks/redirect.js
@@ -1,5 +1,6 @@
 const Task = require('./task');
 const {TaskName} = require('../utils/constants');
+const WsRequestor = require('../utils/ws-requestor');

 /**
 * Redirects to a new application
@@ -13,6 +14,17 @@ class TaskRedirect extends Task {

  async exec(cs) {
    await super.exec(cs);
+
+    if (cs.requestor instanceof WsRequestor && cs.application.requestor._isAbsoluteUrl(this.actionHook)) {
+      this.logger.info(`Task:performAction redirecting to ${this.actionHook}, requires new ws connection`);
+      try {
+        this.cs.requestor.close();
+        const requestor = new WsRequestor(this.logger, cs.accountSid, {url: this.actionHook}, this.webhook_secret) ;
+        this.cs.application.requestor = requestor;
+      } catch (err) {
+        this.logger.info(err, `Task:performAction error redirecting to ${this.actionHook}`);
+      }
+    }
    await this.performAction();
  }
 }
--- a/lib/tasks/rest_dial.js
+++ b/lib/tasks/rest_dial.js
@@ -12,6 +12,7 @@ class TaskRestDial extends Task {

    this.from = this.data.from;
    this.callerName = this.data.callerName;
+    this.timeLimit = this.data.timeLimit;
    this.fromHost = this.data.fromHost;
    this.to = this.data.to;
    this.call_hook = this.data.call_hook;
@@ -66,6 +67,9 @@ class TaskRestDial extends Task {
    const cs = this.callSession;
    cs.setDialog(dlg);
    cs.referHook = this.referHook;
+    if (this.timeLimit) {
+      cs.startMaxCallDurationTimer(this.timeLimit);
+    }
    this.logger.debug('TaskRestDial:_onConnect - call connected');
    if (this.sipRequestWithinDialogHook) this._initSipRequestWithinDialogHandler(cs, dlg);
    try {
--- a/lib/tasks/say.js
+++ b/lib/tasks/say.js
@@ -1,3 +1,4 @@
+const assert = require('assert');
 const TtsTask = require('./tts-task');
 const {TaskName, TaskPreconditions} = require('../utils/constants');
 const pollySSMLSplit = require('polly-ssml-split');
@@ -35,24 +36,40 @@ class TaskSay extends TtsTask {
    super(logger, opts, parentTask);
    this.preconditions = TaskPreconditions.Endpoint;

-    this.text = (Array.isArray(this.data.text) ? this.data.text : [this.data.text])
-      .map((t) => breakLengthyTextIfNeeded(this.logger, t))
-      .flat();
+    assert.ok((typeof this.data.text === 'string' || Array.isArray(this.data.text)) || this.data.stream === true,
+      'Say: either text or stream:true is required');

-    this.loop = this.data.loop || 1;
-    this.isHandledByPrimaryProvider = true;
+
+    if (this.data.stream === true) {
+      this._isStreamingTts = true;
+      this.closeOnStreamEmpty = this.data.closeOnStreamEmpty !== false;
+    }
+    else {
+      this._isStreamingTts = false;
+      this.text = (Array.isArray(this.data.text) ? this.data.text : [this.data.text])
+        .map((t) => breakLengthyTextIfNeeded(this.logger, t))
+        .flat();
+
+      this.loop = this.data.loop || 1;
+      this.isHandledByPrimaryProvider = true;
+    }
  }

  get name() { return TaskName.Say; }

  get summary() {
-    for (let i = 0; i < this.text.length; i++) {
-      if (this.text[i].startsWith('silence_stream')) continue;
-      return `${this.name}{text=${this.text[i].slice(0, 15)}${this.text[i].length > 15 ? '...' : ''}}`;
+    if (this.isStreamingTts) return `${this.name} streaming`;
+    else {
+      for (let i = 0; i < this.text.length; i++) {
+        if (this.text[i].startsWith('silence_stream')) continue;
+        return `${this.name}{text=${this.text[i].slice(0, 15)}${this.text[i].length > 15 ? '...' : ''}}`;
+      }
+      return `${this.name}{${this.text[0]}}`;
    }
-    return `${this.name}{${this.text[0]}}`;
  }

+  get isStreamingTts() { return this._isStreamingTts; }
+
  _validateURL(urlString) {
    try {
      new URL(urlString);
@@ -63,14 +80,19 @@ class TaskSay extends TtsTask {
  }

  async exec(cs, obj) {
+    if (this.isStreamingTts && !cs.appIsUsingWebsockets) {
+      throw new Error('Say: streaming say verb requires applications to use the websocket API');
+    }
+
    try {
-      await this.handling(cs, obj);
+      if (this.isStreamingTts) await this.handlingStreaming(cs, obj);
+      else await this.handling(cs, obj);
      this.emit('playDone');
    } catch (error) {
      if (error instanceof SpeechCredentialError) {
        // if say failed due to speech credentials, alarm is writtern and error notification is sent
        // finished this say to move to next task.
-        this.logger.info('Say failed due to SpeechCredentialError, finished!');
+        this.logger.info({error}, 'Say failed due to SpeechCredentialError, finished!');
        this.emit('playDone');
        return;
      }
@@ -78,6 +100,35 @@ class TaskSay extends TtsTask {
    }
  }

+  async handlingStreaming(cs, {ep}) {
+    const {vendor, language, voice, label} = this.getTtsVendorData(cs);
+    const  credentials = cs.getSpeechCredentials(vendor, 'tts', label);
+    if (!credentials) {
+      throw new SpeechCredentialError(
+        `No text-to-speech service credentials for ${vendor} with labels: ${label} have been configured`);
+    }
+
+    try {
+
+      await this.setTtsStreamingChannelVars(vendor, language, voice, credentials, ep);
+
+      await cs.startTtsStream();
+
+      cs.requestor?.request('tts:streaming-event', '/streaming-event', {event_type: 'stream_open'})
+        .catch((err) => this.logger.info({err}, 'TaskSay:handlingStreaming - Error sending'));
+    } catch (err) {
+      this.logger.info({err}, 'TaskSay:handlingStreaming - Error setting channel vars');
+      cs.requestor?.request('tts:streaming-event', '/streaming-event', {event_type: 'stream_closed'})
+        .catch((err) => this.logger.info({err}, 'TaskSay:handlingStreaming - Error sending'));
+
+      //TODO: send tts:streaming-event with error?
+      this.notifyTaskDone();
+    }
+
+    await this.awaitTaskDone();
+    this.logger.info('TaskSay:handlingStreaming - done');
+  }
+
  async handling(cs, {ep}) {
    const {srf, accountSid:account_sid, callSid:target_sid} = cs;
    const {writeAlerts, AlertType} = srf.locals;
@@ -96,7 +147,7 @@ class TaskSay extends TtsTask {
    let voice =  this.synthesizer.voice && this.synthesizer.voice !== 'default' ?
      this.synthesizer.voice :
      cs.speechSynthesisVoice;
-    let label = this.taskInlcudeSynthesizer ? this.synthesizer.label : cs.speechSynthesisLabel;
+    let label = this.taskIncludeSynthesizer ? this.synthesizer.label : cs.speechSynthesisLabel;

    const fallbackVendor = this.synthesizer.fallbackVendor && this.synthesizer.fallbackVendor !== 'default' ?
      this.synthesizer.fallbackVendor :
@@ -107,7 +158,7 @@ class TaskSay extends TtsTask {
    const fallbackVoice =  this.synthesizer.fallbackVoice && this.synthesizer.fallbackVoice !== 'default' ?
      this.synthesizer.fallbackVoice :
      cs.fallbackSpeechSynthesisVoice;
-    const fallbackLabel = this.taskInlcudeSynthesizer ?
+    const fallbackLabel = this.taskIncludeSynthesizer ?
      this.synthesizer.fallbackLabel : cs.fallbackSpeechSynthesisLabel;

    if (cs.hasFallbackTts) {
@@ -189,29 +240,13 @@ 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'));
            }

-            function extractResponseCode(evt) {
-              for (const key in evt) {
-                if (key.startsWith('variable_tts_') && key.endsWith('_response_code')) {
-                  return evt[key];
-                }
-              }
-              return 0;
-            }
-
-            const response_code = extractResponseCode(evt);
-
            if (this._playResolve) {
-              //if tts vendor return bad response code or there is variable_tts_error,
-              // say task should reject the promise.
-              ((response_code < 200 && response_code > 299) || evt.variable_tts_error) ?
-                this._playReject(
-                  new Error(evt.variable_tts_error ||
-                    `Synthesizing error, received ${evt.variable_tts_whisper_response_code} from vendor ${vendor}`)) :
-                this._playResolve();
+              evt.variable_tts_error ? this._playReject(new Error(evt.variable_tts_error)) : this._playResolve();
            }
          });
          // wait for playback-stop event received to confirm if the playback is successful
@@ -270,6 +305,7 @@ class TaskSay extends TtsTask {
        this._playResolve = null;
      }
    }
+    this.notifyTaskDone();
  }

  _addStreamingTtsAttributes(span, evt) {
@@ -280,6 +316,7 @@ class TaskSay extends TtsTask {
          .replace('whisper_', 'whisper.')
          .replace('deepgram_', 'deepgram.')
          .replace('playht_', 'playht.')
+          .replace('cartesia_', 'cartesia.')
          .replace('rimelabs_', 'rimelabs.')
          .replace('verbio_', 'verbio.')
          .replace('elevenlabs_', 'elevenlabs.');
@@ -290,6 +327,13 @@ class TaskSay extends TtsTask {
    delete attrs['cache_filename']; //no value in adding this to the span
    span.setAttributes(attrs);
  }
+
+  notifyTtsStreamIsEmpty() {
+    if (this.isStreamingTts && this.closeOnStreamEmpty) {
+      this.logger.info('TaskSay:notifyTtsStreamIsEmpty - stream is empty, killing task');
+      this.notifyTaskDone();
+    }
+  }
 }

 const spanMapping = {
@@ -326,6 +370,11 @@ const spanMapping = {
  'playht.name_lookup_time_ms': 'name_lookup_ms',
  'playht.connect_time_ms': 'connect_ms',
  'playht.final_response_time_ms': 'final_response_ms',
+  // Cartesia
+  'cartesia.request_id': 'cartesia.req_id',
+  'cartesia.name_lookup_time_ms': 'name_lookup_ms',
+  'cartesia.connect_time_ms': 'connect_ms',
+  'cartesia.final_response_time_ms': 'final_response_ms',
  // Rimelabs
  'rimelabs.name_lookup_time_ms': 'name_lookup_ms',
  'rimelabs.connect_time_ms': 'connect_ms',
--- a/lib/tasks/transcribe.js
+++ b/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(
--- a/lib/tasks/tts-task.js
+++ b/lib/tasks/tts-task.js
@@ -13,11 +13,11 @@ class TtsTask extends Task {

    this.earlyMedia = this.data.earlyMedia === true || (parentTask && parentTask.earlyMedia);
    /**
-     * Task use taskInlcudeSynthesizer to identify
-     * if taskInlcudeSynthesizer === true, use label from verb.synthesizer, even it's empty
-     * if taskInlcudeSynthesizer === false, use label from application.synthesizer
+     * Task use taskIncludeSynthesizer to identify
+     * if taskIncludeSynthesizer === true, use label from verb.synthesizer, even it's empty
+     * if taskIncludeSynthesizer === false, use label from application.synthesizer
     */
-    this.taskInlcudeSynthesizer = !!this.data.synthesizer;
+    this.taskIncludeSynthesizer = !!this.data.synthesizer;
    this.synthesizer = this.data.synthesizer || {};
    this.disableTtsCache = this.data.disableTtsCache;
    this.options = this.synthesizer.options || {};
@@ -44,6 +44,92 @@ class TtsTask extends Task {
    }
  }

+  getTtsVendorData(cs) {
+    const vendor = this.synthesizer.vendor && this.synthesizer.vendor !== 'default' ?
+      this.synthesizer.vendor :
+      cs.speechSynthesisVendor;
+    const language = this.synthesizer.language && this.synthesizer.language !== 'default' ?
+      this.synthesizer.language :
+      cs.speechSynthesisLanguage ;
+    const voice =  this.synthesizer.voice && this.synthesizer.voice !== 'default' ?
+      this.synthesizer.voice :
+      cs.speechSynthesisVoice;
+    const label = this.taskIncludeSynthesizer ? this.synthesizer.label : cs.speechSynthesisLabel;
+    return {vendor, language, voice, label};
+  }
+
+  async setTtsStreamingChannelVars(vendor, language, voice, credentials, ep) {
+    const {api_key, model_id, custom_tts_streaming_url, auth_token} = credentials;
+    const {stability, similarity_boost, use_speaker_boost, style} = this.options;
+    let obj;
+
+    this.logger.debug({credentials},
+      `setTtsStreamingChannelVars: vendor: ${vendor}, language: ${language}, voice: ${voice}`);
+
+    switch (vendor) {
+      case 'deepgram':
+        obj = {
+          DEEPGRAM_API_KEY: api_key,
+          DEEPGRAM_TTS_STREAMING_MODEL: voice
+        };
+        break;
+      case 'cartesia':
+        obj = {
+          CARTESIA_API_KEY: api_key,
+          CARTESIA_TTS_STREAMING_MODEL_ID: model_id,
+          CARTESIA_TTS_STREAMING_VOICE_ID: voice,
+          CARTESIA_TTS_STREAMING_LANGUAGE: language || 'en',
+        };
+        break;
+      case 'elevenlabs':
+        obj = {
+          ELEVENLABS_API_KEY: api_key,
+          ELEVENLABS_TTS_STREAMING_MODEL_ID: model_id,
+          ELEVENLABS_TTS_STREAMING_VOICE_ID: voice,
+          // 20/12/2024 - only eleven_turbo_v2_5 support multiple language
+          ...(['eleven_turbo_v2_5'].includes(model_id) && {ELEVENLABS_TTS_STREAMING_LANGUAGE: language}),
+          ...(stability && {ELEVENLABS_TTS_STREAMING_VOICE_SETTINGS_STABILITY: stability}),
+          ...(similarity_boost && {ELEVENLABS_TTS_STREAMING_VOICE_SETTINGS_SIMILARITY_BOOST: similarity_boost}),
+          ...(use_speaker_boost && {ELEVENLABS_TTS_STREAMING_VOICE_SETTINGS_USE_SPEAKER_BOOST: use_speaker_boost}),
+          ...(style && {ELEVENLABS_TTS_STREAMING_VOICE_SETTINGS_STYLE: style})
+        };
+        break;
+      case 'rimelabs':
+        const {
+          pauseBetweenBrackets, phonemizeBetweenBrackets, inlineSpeedAlpha, speedAlpha, reduceLatency
+        } = this.options;
+        obj = {
+          RIMELABS_API_KEY: api_key,
+          RIMELABS_TTS_STREAMING_MODEL_ID: model_id,
+          RIMELABS_TTS_STREAMING_VOICE_ID: voice,
+          RIMELABS_TTS_STREAMING_LANGUAGE: language || 'en',
+          ...(pauseBetweenBrackets && {RIMELABS_TTS_STREAMING_PAUSE_BETWEEN_BRACKETS: pauseBetweenBrackets}),
+          ...(phonemizeBetweenBrackets &&
+            {RIMELABS_TTS_STREAMING_PHONEMIZE_BETWEEN_BRACKETS: phonemizeBetweenBrackets}),
+          ...(inlineSpeedAlpha && {RIMELABS_TTS_STREAMING_INLINE_SPEED_ALPHA: inlineSpeedAlpha}),
+          ...(speedAlpha && {RIMELABS_TTS_STREAMING_SPEED_ALPHA: speedAlpha}),
+          ...(reduceLatency && {RIMELABS_TTS_STREAMING_REDUCE_LATENCY: reduceLatency})
+        };
+        break;
+      default:
+        if (vendor.startsWith('custom:')) {
+          const use_tls = custom_tts_streaming_url.startsWith('wss://');
+          obj = {
+            CUSTOM_TTS_STREAMING_HOST: custom_tts_streaming_url.replace(/^(ws|wss):\/\//, ''),
+            CUSTOM_TTS_STREAMING_API_KEY: auth_token,
+            CUSTOM_TTS_STREAMING_VOICE_ID: voice,
+            CUSTOM_TTS_STREAMING_LANGUAGE: language || 'en',
+            CUSTOM_TTS_STREAMING_USE_TLS: use_tls
+          };
+        } else {
+          throw new Error(`vendor ${vendor} is not supported for tts streaming yet`);
+        }
+    }
+    this.logger.info({vendor, credentials, obj}, 'setTtsStreamingChannelVars');
+
+    await ep.set(obj);
+  }
+
  async _synthesizeWithSpecificVendor(cs, ep, {vendor, language, voice, label, preCache = false}) {
    const {srf, accountSid:account_sid} = cs;
    const {writeAlerts, AlertType, stats} = srf.locals;
@@ -57,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) {
@@ -129,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({
@@ -164,7 +251,7 @@ class TtsTask extends Task {
            language,
            voice,
            engine,
-            model,
+            model: this.model,
            salt,
            credentials,
            options: this.options,
--- a/lib/utils/amd-utils.js
+++ b/lib/utils/amd-utils.js
@@ -153,7 +153,7 @@ class Amd extends Emitter {
      const wordCount = t.alternatives[0].transcript.split(' ').length;
      const final = t.is_final;

-      const foundHint = hints.find((h) =>  t.alternatives[0].transcript.includes(h));
+      const foundHint = hints.find((h) =>  t.alternatives[0].transcript.toLowerCase().includes(h.toLowerCase()));
      if (foundHint) {
        /* we detected a common voice mail greeting */
        this.logger.debug(`Amd:evaluateTranscription: found hint ${foundHint}`);
--- a/lib/utils/background-task-manager.js
+++ b/lib/utils/background-task-manager.js
@@ -46,6 +46,9 @@ class BackgroundTaskManager extends Emitter {
      case 'transcribe':
        task = await this._initTranscribe(opts);
        break;
+      case 'ttsStream':
+        task = await this._initTtsStream(opts);
+        break;
      default:
        break;
    }
@@ -100,6 +103,7 @@ class BackgroundTaskManager extends Emitter {
  async _initBargeIn(opts) {
    let task;
    try {
+      const copy = JSON.parse(JSON.stringify(opts));
      const t = normalizeJambones(this.logger, [opts]);
      task = makeTask(this.logger, t[0]);
      task
@@ -118,7 +122,7 @@ class BackgroundTaskManager extends Emitter {
          if (task.sticky && !this.cs.callGone && !this.cs._stopping) {
            this.logger.info('BackgroundTaskManager:_initBargeIn: restarting background bargeIn');
            this._bargeInHandled = false;
-            this.newTask('bargeIn', opts, true);
+            this.newTask('bargeIn', copy, true);
          }
          return;
        })
@@ -173,6 +177,25 @@ class BackgroundTaskManager extends Emitter {
    return task;
  }

+  // Initiate Tts Stream
+  async _initTtsStream(opts) {
+    let task;
+    try {
+      const t = normalizeJambones(this.logger, [opts]);
+      task = makeTask(this.logger, t[0]);
+      const resources = await this.cs._evaluatePreconditions(task);
+      const {span, ctx} = this.rootSpan.startChildSpan(`background-ttsStream:${task.summary}`);
+      task.span = span;
+      task.ctx = ctx;
+      task.exec(this.cs, resources)
+        .then(this._taskCompleted.bind(this, 'ttsStream', task))
+        .catch(this._taskError.bind(this, 'ttsStream', task));
+    } catch (err) {
+      this.logger.info(err, 'BackgroundTaskManager:_initTtsStream - Error creating ttsStream task');
+    }
+    return task;
+  }
+
  _taskCompleted(type, task) {
    this.logger.debug({type, task}, `BackgroundTaskManager:_taskCompleted: task completed, sticky: ${task.sticky}`);
    task.removeAllListeners();
--- a/lib/utils/constants.json
+++ b/lib/utils/constants.json
@@ -28,6 +28,7 @@
    "SipRedirect": "sip:redirect",
    "Say": "say",
    "SayLegacy": "say:legacy",
+    "Stream": "stream",
    "Tag": "tag",
    "Transcribe": "transcribe"
  },
@@ -148,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"
  },
@@ -175,6 +182,27 @@
    "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",
+    "ConnectFailure": "voice_agent_s2s::connect_failed",
+    "Disconnect": "voice_agent_s2s::disconnect",
+    "ServerEvent": "voice_agent_s2s::server_event"
+  },
+  "LlmEvents_Ultravox": {
+    "Error": "error",
+    "Connect": "ultravox_s2s::connect",
+    "ConnectFailure": "ultravox_s2s::connect_failed",
+    "Disconnect": "ultravox_s2s::disconnect",
+    "ServerEvent": "ultravox_s2s::server_event"
+  },
  "QueueResults": {
    "Bridged": "bridged",
    "Error": "error",
@@ -189,7 +217,8 @@
  },
  "KillReason": {
    "Hangup": "hangup",
-    "Replaced": "replaced"
+    "Replaced": "replaced",
+    "MediaTimeout": "media_timeout"
  },
  "HookMsgTypes": [
    "session:new",
@@ -203,6 +232,8 @@
    "verb:status",
    "llm:event",
    "llm:tool-call",
+    "tts:tokens-result",
+    "tts:streaming-event",
    "jambonz:error"
  ],
  "RecordState": {
@@ -226,6 +257,43 @@
    "PartialMedia": "partial-media",
    "FullMedia": "full-media"
  },
+  "DeepgramTtsStreamingEvents": {
+    "Empty": "deepgram_tts_streaming::empty",
+    "ConnectFailure": "deepgram_tts_streaming::connect_failed",
+    "Connect": "deepgram_tts_streaming::connect"
+  },
+  "CartesiaTtsStreamingEvents": {
+    "Empty": "cartesia_tts_streaming::empty",
+    "ConnectFailure": "cartesia_tts_streaming::connect_failed",
+    "Connect": "cartesia_tts_streaming::connect"
+  },
+  "ElevenlabsTtsStreamingEvents": {
+    "Empty": "elevenlabs_tts_streaming::empty",
+    "ConnectFailure": "elevenlabs_tts_streaming::connect_failed",
+    "Connect": "elevenlabs_tts_streaming::connect"
+  },
+  "RimelabsTtsStreamingEvents": {
+    "Empty": "rimelabs_tts_streaming::empty",
+    "ConnectFailure": "rimelabs_tts_streaming::connect_failed",
+    "Connect": "rimelabs_tts_streaming::connect"
+  },
+  "CustomTtsStreamingEvents": {
+    "Empty": "custom_tts_streaming::empty",
+    "ConnectFailure": "custom_tts_streaming::connect_failed",
+    "Connect": "custom_tts_streaming::connect"
+  },
+  "TtsStreamingEvents": {
+    "Empty": "tts_streaming::empty",
+    "Pause": "tts_streaming::pause",
+    "Resume": "tts_streaming::resume",
+    "ConnectFailure": "tts_streaming::connect_failed"
+  },
+  "TtsStreamingConnectionStatus": {
+    "NotConnected": "not_connected",
+    "Connected": "connected",
+    "Connecting": "connecting",
+    "Failed": "failed"
+  },
  "MAX_SIMRINGS": 10,
  "BONG_TONE": "tone_stream://v=-7;%(100,0,941.0,1477.0);v=-7;>=2;+=.1;%(1400,0,350,440)",
  "FS_UUID_SET_NAME": "fsUUIDs",
@@ -234,5 +302,9 @@
    "Offline": "OFFLINE",
    "GracefulShutdownInProgress":"SHUTDOWN_IN_PROGRESS"
  },
-  "FEATURE_SERVER" : "feature-server"
+  "FEATURE_SERVER" : "feature-server",
+  "WS_CLOSE_CODES": {
+    "NormalClosure": 1000,
+    "GoingAway": 1001
+  }
 }
--- a/lib/utils/db-utils.js
+++ b/lib/utils/db-utils.js
@@ -105,6 +105,13 @@ const speechMapper = (cred) => {
      obj.voice_engine = o.voice_engine;
      obj.options = o.options;
    }
+    else if ('cartesia' === obj.vendor) {
+      const o = JSON.parse(decrypt(credential));
+      obj.api_key = o.api_key;
+      obj.model_id = o.model_id;
+      obj.embedding = o.embedding;
+      obj.options = o.options;
+    }
    else if ('rimelabs' === obj.vendor) {
      const o = JSON.parse(decrypt(credential));
      obj.api_key = o.api_key;
@@ -115,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;
@@ -136,6 +147,7 @@ const speechMapper = (cred) => {
      obj.auth_token = o.auth_token;
      obj.custom_stt_url = o.custom_stt_url;
      obj.custom_tts_url = o.custom_tts_url;
+      obj.custom_tts_streaming_url = o.custom_tts_streaming_url;
    }
  } catch (err) {
    console.log(err);
--- a/lib/utils/error.js
+++ b/lib/utils/error.js
@@ -17,8 +17,17 @@ class PlayFileNotFoundError extends NonFatalTaskError {
  }
 }

+class HTTPResponseError extends Error {
+  constructor(statusCode) {
+    super('Unexpected HTTP Response');
+    delete this.stack;
+    this.statusCode = statusCode;
+  }
+}
+
 module.exports = {
  SpeechCredentialError,
  NonFatalTaskError,
-  PlayFileNotFoundError
+  PlayFileNotFoundError,
+  HTTPResponseError
 };
--- a/lib/utils/http-requestor.js
+++ b/lib/utils/http-requestor.js
@@ -16,6 +16,7 @@ const {
  NODE_ENV,
  HTTP_USER_AGENT_HEADER,
 } = require('../config');
+const {HTTPResponseError} = require('./error');

 const toBase64 = (str) => Buffer.from(str || '', 'utf8').toString('base64');

@@ -190,8 +191,7 @@ class HttpRequestor extends BaseRequestor {
        followRedirects: false
      });
      if (![200, 202, 204].includes(statusCode)) {
-        const err = new Error();
-        err.statusCode = statusCode;
+        const err = new HTTPResponseError(statusCode);
        throw err;
      }
      if (headers['content-type']?.includes('application/json')) {
--- a/lib/utils/place-outdial.js
+++ b/lib/utils/place-outdial.js
@@ -17,7 +17,9 @@ const HttpRequestor = require('./http-requestor');
 const WsRequestor = require('./ws-requestor');
 const {makeOpusFirst} = require('./sdp-utils');
 const {
-  JAMBONES_USE_FREESWITCH_TIMER_FD
+  JAMBONES_USE_FREESWITCH_TIMER_FD,
+  JAMBONES_MEDIA_TIMEOUT_MS,
+  JAMBONES_MEDIA_HOLD_TIMEOUT_MS
 } = require('../config');

 class SingleDialer extends Emitter {
@@ -317,14 +319,19 @@ class SingleDialer extends Emitter {
  /**
   * kill the call in progress or the stable dialog, whichever we have
   */
-  async kill() {
+  async kill(Reason) {
    this.killed = true;
    if (this.inviteInProgress) await this.inviteInProgress.cancel();
    else if (this.dlg && this.dlg.connected) {
      const duration = moment().diff(this.dlg.connectTime, 'seconds');
      this.logger.debug('SingleDialer:kill hanging up called party');
      this.emit('callStatusChange', {callStatus: CallStatus.Completed, duration});
-      this.dlg.destroy();
+      const headers = {
+        ...(Reason && {'X-Reason': Reason})
+      };
+      this.dlg.destroy({
+        headers
+      });
    }
    if (this.ep) {
      this.logger.debug(`SingleDialer:kill - deleting endpoint ${this.ep.uuid}`);
@@ -335,11 +342,22 @@ class SingleDialer extends Emitter {
  _configMsEndpoint() {
    const opts = {
      ...(this.onHoldMusic && {holdMusic: `shout://${this.onHoldMusic.replace(/^https?:\/\//, '')}`}),
-      ...(JAMBONES_USE_FREESWITCH_TIMER_FD && {timer_name: 'timerfd'})
+      ...(JAMBONES_USE_FREESWITCH_TIMER_FD && {timer_name: 'timerfd'}),
+      ...(JAMBONES_MEDIA_TIMEOUT_MS && {media_timeout: JAMBONES_MEDIA_TIMEOUT_MS}),
+      ...(JAMBONES_MEDIA_HOLD_TIMEOUT_MS && {media_hold_timeout: JAMBONES_MEDIA_HOLD_TIMEOUT_MS})
    };
    if (Object.keys(opts).length > 0) {
      this.ep.set(opts);
    }
+    if (this.dialTask?.inbandDtmfEnabled && !this.ep.inbandDtmfEnabled) {
+      // https://developer.signalwire.com/freeswitch/FreeSWITCH-Explained/Modules/mod-dptools/6587132/#0-about
+      try {
+        this.ep.execute('start_dtmf');
+        this.ep.inbandDtmfEnabled = true;
+      } catch (err) {
+        this.logger.info(err, 'place-outdial:_configMsEndpoint - error enable inband DTMF');
+      }
+    }
  }

  /**
--- a/lib/utils/transcription-utils.js
+++ b/lib/utils/transcription-utils.js
@@ -43,7 +43,8 @@ const stickyVars = {
    'DEEPGRAM_SPEECH_UTTERANCE_END_MS',
    'DEEPGRAM_SPEECH_VAD_TURNOFF',
    'DEEPGRAM_SPEECH_TAG',
-    'DEEPGRAM_SPEECH_MODEL_VERSION'
+    'DEEPGRAM_SPEECH_MODEL_VERSION',
+    'DEEPGRAM_SPEECH_FILLER_WORDS'
  ],
  aws: [
    'AWS_VOCABULARY_NAME',
@@ -104,6 +105,9 @@ const stickyVars = {
    'ASSEMBLYAI_API_KEY',
    'ASSEMBLYAI_WORD_BOOST'
  ],
+  voxist: [
+    'VOXIST_API_KEY',
+  ],
  speechmatics: [
    'SPEECHMATICS_API_KEY',
    'SPEECHMATICS_HOST',
@@ -208,7 +212,7 @@ const consolidateTranscripts = (bufferedTranscripts, channel, language, vendor)
    const lastChar = acc.alternatives[0].transcript.slice(-1);
    const firstChar = newTranscript.charAt(0);

-    if (lastChar.match(/\d/) && firstChar.match(/\d/)) {
+    if (vendor === 'speechmatics' || (lastChar.match(/\d/) && firstChar.match(/\d/))) {
      acc.alternatives[0].transcript += newTranscript;
    } else {
      acc.alternatives[0].transcript += ` ${newTranscript}`;
@@ -516,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';
@@ -566,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':
@@ -704,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) {
@@ -812,7 +839,9 @@ module.exports = (logger) => {
        ...(deepgramOptions.tag) &&
          {DEEPGRAM_SPEECH_TAG: deepgramOptions.tag},
        ...(deepgramOptions.version) &&
-          {DEEPGRAM_SPEECH_MODEL_VERSION: deepgramOptions.version}
+          {DEEPGRAM_SPEECH_MODEL_VERSION: deepgramOptions.version},
+        ...(deepgramOptions.fillerWords) &&
+          {DEEPGRAM_SPEECH_FILLER_WORDS: deepgramOptions.fillerWords}
      };
    }
    else if ('soniox' === vendor) {
@@ -921,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 = {
@@ -954,6 +990,36 @@ module.exports = (logger) => {
            SPEECHMATICS_TRANSLATION_PARTIALS: speechmaticsOptions.translation_config.enable_partials ? 1 : 0
          }
        ),
+        ...(speechmaticsOptions.transcription_config?.domain &&
+          {SPEECHMATICS_DOMAIN: speechmaticsOptions.transcription_config.domain}),
+        ...{SPEECHMATICS_MAX_DELAY: speechmaticsOptions.transcription_config?.max_delay || 0.7},
+        ...{SPEECHMATICS_MAX_DELAY_MODE: speechmaticsOptions.transcription_config?.max_delay_mode || 'flexible'},
+        ...(speechmaticsOptions.transcription_config?.diarization &&
+            {SPEECHMATICS_DIARIZATION: speechmaticsOptions.transcription_config.diarization}),
+        ...(speechmaticsOptions.transcription_config?.speaker_diarization_config?.speaker_sensitivity &&
+          {SPEECHMATICS_DIARIZATION_SPEAKER_SENSITIVITY:
+            speechmaticsOptions.transcription_config.speaker_diarization_config.speaker_sensitivity}),
+        ...(speechmaticsOptions.transcription_config?.speaker_diarization_config?.max_speakers &&
+          {SPEECHMATICS_DIARIZATION_MAX_SPEAKERS:
+            speechmaticsOptions.transcription_config.speaker_diarization_config.max_speakers}),
+        ...(speechmaticsOptions.transcription_config?.output_locale &&
+          {SPEECHMATICS_OUTPUT_LOCALE: speechmaticsOptions.transcription_config.output_locale}),
+        ...(speechmaticsOptions.transcription_config?.punctuation_overrides?.permitted_marks &&
+          {SPEECHMATICS_PUNCTUATION_ALLOWED:
+            speechmaticsOptions.transcription_config.punctuation_overrides.permitted_marks.join(',')}),
+        ...(speechmaticsOptions.transcription_config?.punctuation_overrides?.sensitivity &&
+          {SPEECHMATICS_PUNCTUATION_SENSITIVITY:
+            speechmaticsOptions.transcription_config?.punctuation_overrides?.sensitivity}),
+        ...(speechmaticsOptions.transcription_config?.operating_point &&
+          {SPEECHMATICS_OPERATING_POINT: speechmaticsOptions.transcription_config.operating_point}),
+        ...(speechmaticsOptions.transcription_config?.enable_entities &&
+          {SPEECHMATICS_ENABLE_ENTTIES: speechmaticsOptions.transcription_config.enable_entities}),
+        ...(speechmaticsOptions.transcription_config?.audio_filtering_config?.volume_threshold &&
+          {SPEECHMATICS_VOLUME_THRESHOLD:
+            speechmaticsOptions.transcription_config.audio_filtering_config.volume_threshold}),
+        ...(speechmaticsOptions.transcription_config?.transcript_filtering_config?.remove_disfluencies &&
+          {SPEECHMATICS_REMOVE_DISFLUENCIES:
+            speechmaticsOptions.transcription_config.transcript_filtering_config.remove_disfluencies})
      };
    }
    else if (vendor.startsWith('custom:')) {
--- a/lib/utils/tts-streaming-buffer.js
+++ b/lib/utils/tts-streaming-buffer.js
@@ -0,0 +1,327 @@
+const Emitter = require('events');
+const assert = require('assert');
+const {
+  TtsStreamingEvents,
+  TtsStreamingConnectionStatus
+} = require('../utils/constants');
+const MAX_CHUNK_SIZE = 1800;
+const HIGH_WATER_BUFFER_SIZE = 1000;
+const LOW_WATER_BUFFER_SIZE = 200;
+const TIMEOUT_RETRY_MSECS = 3000;
+
+class TtsStreamingBuffer extends Emitter {
+  constructor(cs) {
+    super();
+    this.cs = cs;
+    this.logger = cs.logger;
+
+    this.tokens = '';
+    this.eventHandlers = [];
+    this._isFull = false;
+    this._connectionStatus = TtsStreamingConnectionStatus.NotConnected;
+    this._flushPending = false;
+    this.timer = null;
+  }
+
+  get isEmpty() {
+    return this.tokens.length === 0;
+  }
+
+  get isFull() {
+    return this._isFull;
+  }
+
+  get size() {
+    return this.tokens.length;
+  }
+
+  get ep() {
+    return this.cs?.ep;
+  }
+
+  async start() {
+    assert.ok(
+      this._connectionStatus === TtsStreamingConnectionStatus.NotConnected,
+      'TtsStreamingBuffer:start already started, or has failed');
+
+    this.vendor = this.cs.getTsStreamingVendor();
+    if (!this.vendor) {
+      this.logger.info('TtsStreamingBuffer:start No TTS streaming vendor configured');
+      throw new Error('No TTS streaming vendor configured');
+    }
+
+    this.logger.info(`TtsStreamingBuffer:start Connecting to TTS streaming with vendor ${this.vendor}`);
+
+    this._connectionStatus = TtsStreamingConnectionStatus.Connecting;
+    try {
+      if (this.eventHandlers.length === 0) this._initHandlers(this.ep);
+      await  this._api(this.ep, [this.ep.uuid, 'connect']);
+    } catch (err) {
+      this.logger.info({err}, 'TtsStreamingBuffer:start Error connecting to TTS streaming');
+      this._connectionStatus = TtsStreamingConnectionStatus.Failed;
+    }
+  }
+
+  stop() {
+    clearTimeout(this.timer);
+    this.removeCustomEventListeners();
+    if (this.ep) {
+      this._api(this.ep, [this.ep.uuid, 'close'])
+        .catch((err) => this.logger.info({err}, 'TtsStreamingBuffer:kill Error closing TTS streaming'));
+    }
+    this.timer = null;
+    this.tokens = '';
+    this._connectionStatus = TtsStreamingConnectionStatus.NotConnected;
+  }
+
+  /**
+   * Add tokens to the buffer and start feeding them to the endpoint if necessary.
+   */
+  async bufferTokens(tokens) {
+
+    if (this._connectionStatus === TtsStreamingConnectionStatus.Failed) {
+      this.logger.info('TtsStreamingBuffer:bufferTokens TTS streaming connection failed, rejecting request');
+      return {status: 'failed', reason: `connection to ${this.vendor} failed`};
+    }
+
+    const displayedTokens = tokens.length <= 40 ? tokens : tokens.substring(0, 40);
+    const totalLength = tokens.length;
+
+    /* if we crossed the high water mark, reject the request */
+    if (this.tokens.length + totalLength > HIGH_WATER_BUFFER_SIZE) {
+      this.logger.info(
+        `TtsStreamingBuffer throttling: buffer is full, rejecting request to buffer ${totalLength} tokens`);
+
+      if (!this._isFull) {
+        this._isFull = true;
+        this.emit(TtsStreamingEvents.Pause);
+      }
+      return {status: 'failed', reason: 'full'};
+    }
+
+    this.logger.debug(
+      `TtsStreamingBuffer:bufferTokens "${displayedTokens}" (length: ${totalLength}), starting? ${this.isEmpty}`
+    );
+    this.tokens += (tokens || '');
+
+    await this._feedTokens();
+
+    return {status: 'ok'};
+  }
+
+  flush() {
+    this.logger.debug('TtsStreamingBuffer:flush');
+    if (this._connectionStatus === TtsStreamingConnectionStatus.Connecting) {
+      this.logger.debug('TtsStreamingBuffer:flush TTS stream is not quite ready - wait for connect');
+      this._flushPending = true;
+      return;
+    }
+    else if (this._connectionStatus === TtsStreamingConnectionStatus.Connected) {
+
+      if (this.size === 0) {
+        this._doFlush();
+      }
+      else {
+        /* we have tokens queued, so flush after they have been sent */
+        this._pendingFlush = true;
+      }
+    }
+  }
+
+  clear() {
+    this.logger.debug('TtsStreamingBuffer:clear');
+
+    if (this._connectionStatus !== TtsStreamingConnectionStatus.Connected) return;
+    clearTimeout(this.timer);
+    this._api(this.ep, [this.ep.uuid, 'clear'])
+      .catch((err) => this.logger.info({err}, 'TtsStreamingBuffer:clear Error clearing TTS streaming'));
+    this.tokens = '';
+    this.timer = null;
+    this._isFull = false;
+  }
+
+  /**
+   * Send tokens to the TTS engine in sentence chunks for best playout
+   */
+  async _feedTokens(handlingTimeout = false) {
+    this.logger.debug({tokens: this.tokens}, '_feedTokens');
+
+    try {
+
+      /* are we in a state where we can feed tokens to the TTS? */
+      if (!this.cs.isTtsStreamOpen || !this.ep || !this.tokens) {
+        this.logger.debug('TTS stream is not open or no tokens to send');
+        return this.tokens?.length || 0;
+      }
+
+      if (this._connectionStatus === TtsStreamingConnectionStatus.NotConnected ||
+        this._connectionStatus === TtsStreamingConnectionStatus.Failed) {
+        this.logger.debug('TtsStreamingBuffer:_feedTokens TTS stream is not connected');
+        return;
+      }
+
+      if (this._connectionStatus === TtsStreamingConnectionStatus.Connecting) {
+        this.logger.debug('TtsStreamingBuffer:_feedTokens TTS stream is not ready, waiting for connect');
+        return;
+      }
+
+      /* must send at least one sentence */
+      const limit = Math.min(MAX_CHUNK_SIZE, this.tokens.length);
+      let chunkEnd = findSentenceBoundary(this.tokens, limit);
+
+      if (chunkEnd <= 0) {
+        if (handlingTimeout) {
+          /* on a timeout we've left some tokens sitting around, so be more aggressive now in sending them */
+          chunkEnd = findWordBoundary(this.tokens, limit);
+          if (chunkEnd <= 0) {
+            this.logger.debug('TtsStreamingBuffer:_feedTokens: no word boundary found');
+            this._setTimerIfNeeded();
+            return;
+          }
+        }
+        else {
+          /* if we just received tokens, we wont send unless we have at least a full sentence */
+          this.logger.debug('TtsStreamingBuffer:_feedTokens: no sentence boundary found');
+          this._setTimerIfNeeded();
+          return;
+        }
+      }
+
+      const chunk = this.tokens.slice(0, chunkEnd);
+      this.tokens = this.tokens.slice(chunkEnd);
+
+      /* freeswitch looks for sequence of 2 newlines to determine end of message, so insert a space */
+      const modifiedChunk = chunk.replace(/\n\n/g, '\n \n');
+      await this._api(this.ep, [this.ep.uuid, 'send', modifiedChunk]);
+      this.logger.debug(`TtsStreamingBuffer:_feedTokens: sent ${chunk.length}, remaining: ${this.tokens.length}`);
+
+      if (this._pendingFlush) {
+        this._doFlush();
+        this._pendingFlush = false;
+      }
+
+      if (this.isFull && this.tokens.length <= LOW_WATER_BUFFER_SIZE) {
+        this.logger.info('TtsStreamingBuffer throttling: TTS streaming buffer is no longer full - resuming');
+        this._isFull = false;
+        this.emit(TtsStreamingEvents.Resume);
+      }
+    } catch (err) {
+      this.logger.info({err}, 'TtsStreamingBuffer:_feedTokens Error sending TTS chunk');
+      this.tokens = '';
+    }
+
+    return;
+  }
+
+  async _api(ep, args) {
+    const apiCmd = `uuid_${this.vendor.startsWith('custom:') ? 'custom' : this.vendor}_tts_streaming`;
+    const res = await ep.api(apiCmd, `^^|${args.join('|')}`);
+    if (!res.body?.startsWith('+OK')) {
+      this.logger.info({args}, `Error calling ${apiCmd}: ${res.body}`);
+      throw new Error(`Error calling ${apiCmd}: ${res.body}`);
+    }
+  }
+
+  _onConnectFailure(vendor) {
+    this.logger.info(`streaming tts connection failed to ${vendor}`);
+    this._connectionStatus = TtsStreamingConnectionStatus.Failed;
+    this.tokens = '';
+    this.emit(TtsStreamingEvents.ConnectFailure, {vendor});
+  }
+
+  _doFlush() {
+    this._api(this.ep, [this.ep.uuid, 'flush'])
+      .catch((err) => this.logger.info({err},
+        `TtsStreamingBuffer:_doFlush Error flushing TTS streaming: ${JSON.stringify(err)}`));
+  }
+
+  async _onConnect(vendor) {
+    this.logger.info(`streaming tts connection made to ${vendor}`);
+    this._connectionStatus = TtsStreamingConnectionStatus.Connected;
+    if (this.tokens.length > 0) {
+      await this._feedTokens();
+    }
+    if (this._flushPending) {
+      this.flush();
+      this._flushPending = false;
+    }
+  }
+
+  _setTimerIfNeeded() {
+    if (this.tokens.length > 0 && !this.timer) {
+      this.timer = setTimeout(this._onTimeout.bind(this), TIMEOUT_RETRY_MSECS);
+    }
+  }
+
+  _onTimeout() {
+    this.logger.info('TtsStreamingBuffer:_onTimeout');
+    this.timer = null;
+    this._feedTokens(true);
+  }
+
+  _onTtsEmpty(vendor) {
+    this.emit(TtsStreamingEvents.Empty, {vendor});
+  }
+
+  addCustomEventListener(ep, event, handler) {
+    this.eventHandlers.push({ep, event, handler});
+    ep.addCustomEventListener(event, handler);
+  }
+
+  removeCustomEventListeners() {
+    this.eventHandlers.forEach((h) => h.ep.removeCustomEventListener(h.event, h.handler));
+  }
+
+  _initHandlers(ep) {
+    [
+      // DH: add other vendors here as modules are added
+      'deepgram',
+      'cartesia',
+      'elevenlabs',
+      'rimelabs',
+      'custom'
+    ].forEach((vendor) => {
+      const eventClassName = `${vendor.charAt(0).toUpperCase() + vendor.slice(1)}TtsStreamingEvents`;
+      const eventClass = require('../utils/constants')[eventClassName];
+      if (!eventClass) throw new Error(`Event class for vendor ${vendor} not found`);
+
+      this.addCustomEventListener(ep, eventClass.Connect, this._onConnect.bind(this, vendor));
+      this.addCustomEventListener(ep, eventClass.ConnectFailure, this._onConnectFailure.bind(this, vendor));
+      this.addCustomEventListener(ep, eventClass.Empty, this._onTtsEmpty.bind(this, vendor));
+    });
+  }
+}
+
+const findSentenceBoundary = (text, limit) => {
+  // Match traditional sentence boundaries or double newlines
+  const sentenceEndRegex = /[.!?](?=\s|$)|\n\n/g;
+  let lastSentenceBoundary = -1;
+  let match;
+
+  while ((match = sentenceEndRegex.exec(text)) && match.index < limit) {
+    const precedingText = text.slice(0, match.index).trim(); // Extract text before the match and trim whitespace
+    if (precedingText.length > 0) { // Check if there's actual content
+      if (
+        match[0] === '\n\n' || // It's a double newline
+        (match.index === 0 || !/\d$/.test(text[match.index - 1])) // Standard punctuation rules
+      ) {
+        lastSentenceBoundary = match.index + (match[0] === '\n\n' ? 2 : 1); // Include the boundary
+      }
+    }
+  }
+
+  return lastSentenceBoundary;
+};
+
+const findWordBoundary = (text, limit) => {
+  const wordBoundaryRegex = /\s+/g;
+  let lastWordBoundary = -1;
+  let match;
+
+  while ((match = wordBoundaryRegex.exec(text)) && match.index < limit) {
+    lastWordBoundary = match.index;
+  }
+  return lastWordBoundary;
+};
+
+module.exports = TtsStreamingBuffer;
--- a/lib/utils/ws-requestor.js
+++ b/lib/utils/ws-requestor.js
@@ -1,7 +1,7 @@
 const assert = require('assert');
 const BaseRequestor = require('./base-requestor');
 const short = require('short-uuid');
-const {HookMsgTypes} = require('./constants.json');
+const {HookMsgTypes, WS_CLOSE_CODES} = require('./constants.json');
 const Websocket = require('ws');
 const snakeCaseKeys = require('./snakecase-keys');
 const {
@@ -12,6 +12,20 @@ const {
  JAMBONES_WS_MAX_PAYLOAD,
  HTTP_USER_AGENT_HEADER
 } = require('../config');
+const MTYPE_WANTS_ACK = [
+  'call:status',
+  'verb:status',
+  'jambonz:error',
+  'llm:event',
+  'llm:tool-call',
+  'tts:streaming-event',
+  'tts:tokens-result',
+];
+const MTYPE_NO_DATA = [
+  'llm:tool-output',
+  'tts:flush',
+  'tts:clear'
+];

 class WsRequestor extends BaseRequestor {
  constructor(logger, account_sid, hook, secret) {
@@ -44,7 +58,7 @@ class WsRequestor extends BaseRequestor {
  async request(type, hook, params, httpHeaders = {}) {
    assert(HookMsgTypes.includes(type));
    const url = hook.url || hook;
-    const wantsAck = !['call:status', 'verb:status', 'jambonz:error', 'llm:event', 'llm:tool-call'].includes(type);
+    const wantsAck = !MTYPE_WANTS_ACK.includes(type);

    if (this.maliciousClient) {
      this.logger.info({url: this.url}, 'WsRequestor:request - discarding msg to malicious client');
@@ -247,13 +261,13 @@ class WsRequestor extends BaseRequestor {
    }
  }

-  close() {
+  close(code = WS_CLOSE_CODES.NormalClosure) {
    this.closedGracefully = true;
-    this.logger.debug('WsRequestor:close closing socket');
+    this.logger.debug(`WsRequestor:close closing socket with code ${code}`);
    this._stopPingTimer();
    try {
      if (this.ws) {
-        this.ws.close(1000);
+        this.ws.close(code);
        this.ws.removeAllListeners();
        this.ws = null;
      }
@@ -408,7 +422,7 @@ class WsRequestor extends BaseRequestor {

        case 'command':
          assert.ok(command, 'command property not supplied');
-          assert.ok(data || command === 'llm:tool-output', 'data property not supplied');
+          assert.ok(data || MTYPE_NO_DATA.includes(command), 'data property not supplied');
          this._recvCommand(msgid, command, call_sid, queueCommand, tool_call_id, data);
          break;

--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "jambonz-feature-server",
-  "version": "0.9.2",
+  "version": "0.9.3",
  "main": "app.js",
  "engines": {
    "node": ">= 18.x"
@@ -31,10 +31,10 @@
    "@jambonz/http-health-check": "^0.0.1",
    "@jambonz/mw-registrar": "^0.2.7",
    "@jambonz/realtimedb-helpers": "^0.8.8",
-    "@jambonz/speech-utils": "^0.1.22",
+    "@jambonz/speech-utils": "^0.2.3",
    "@jambonz/stats-collector": "^0.1.10",
-    "@jambonz/time-series": "^0.2.12",
-    "@jambonz/verb-specifications": "^0.0.90",
+    "@jambonz/verb-specifications": "^0.0.95",
+    "@jambonz/time-series": "^0.2.13",
    "@opentelemetry/api": "^1.8.0",
    "@opentelemetry/exporter-jaeger": "^1.23.0",
    "@opentelemetry/exporter-trace-otlp-http": "^0.50.0",
@@ -47,8 +47,8 @@
    "bent": "^7.3.12",
    "debug": "^4.3.4",
    "deepcopy": "^2.1.0",
-    "drachtio-fsmrf": "^3.0.46",
-    "drachtio-srf": "^4.5.35",
+    "drachtio-fsmrf": "^4.0.1",
+    "drachtio-srf": "^5.0.1",
    "express": "^4.19.2",
    "express-validator": "^7.0.1",
    "moment": "^2.30.1",
@@ -56,7 +56,7 @@
    "pino": "^8.20.0",
    "polly-ssml-split": "^0.1.0",
    "proxyquire": "^2.1.3",
-    "sdp-transform": "^2.14.2",
+    "sdp-transform": "^2.15.0",
    "short-uuid": "^5.1.0",
    "sinon": "^17.0.1",
    "to-snake-case": "^1.0.0",
--- a/test/create-call-test.js
+++ b/test/create-call-test.js
@@ -222,3 +222,62 @@ test('test create-call app_json', async(t) => {
    t.error(err);
  }
 });
+
+test('test create-call timeLimit', async(t) => {
+  clearModule.all();
+  const {srf, disconnect} = require('../app');
+
+  try {
+    await connect(srf);
+
+
+    // GIVEN
+    let from = 'create-call-app-json';
+    let account_sid = 'bb845d4b-83a9-4cde-a6e9-50f3743bab3f';
+
+    // Give UAS app time to come up
+    const p = sippUac('uas.xml', '172.38.0.10', from);
+    await waitFor(1000);
+
+    const startTime = Date.now();
+
+    const app_json = `[
+      {
+        "verb": "pause",
+        "length": 7
+      }
+    ]`;
+
+    const post = bent('http://127.0.0.1:3000/', 'POST', 'json', 201);
+    post('v1/createCall', {
+      'account_sid':account_sid,
+      "call_hook": {
+        "url": "http://127.0.0.1:3100/",
+        "method": "POST",
+        "username": "username",
+        "password": "password"
+      },
+      app_json,
+      "from": from,
+      "to": {
+        "type": "phone",
+        "number": "15583084809"
+      },
+      "timeLimit": 1,
+      "speech_recognizer_vendor": "google",
+      "speech_recognizer_language": "en"
+    });
+
+    //THEN
+    await p;
+    const endTime = Date.now();
+
+    t.ok(endTime - startTime < 2000, 'create-call: timeLimit is respected');
+
+    disconnect();
+  } catch (err) {
+    console.log(`error received: ${err}`);
+    disconnect();
+    t.error(err);
+  }
+});
Author	SHA1	Message	Date
Hoan Luu Huu	f241faa871	update speech utils version (#1070 )	2025-02-07 08:00:33 -05:00
rammohan-y	65d35c893c	Feat/1067 set default language if language is undefined (#1068 ) * sending recognition mode channel variable * change verb-specifications version * feat/1067 - setting default language to previously set language for the recognizer object if the vendor is default * added undefined check for fallbackVendor and fallbackLanguage	2025-02-06 08:06:56 -05:00
Hoan Luu Huu	dbdc1cd43d	support voxist stt (#1066 ) * support voxist stt * wip	2025-02-05 08:33:35 -05:00
Hoan Luu Huu	7105453d81	support caching tts audio with model/model_id (#1062 ) * support caching tts audio with model/model_id * update speech utils version	2025-02-03 08:47:44 -05:00
Hoan Luu Huu	8487a4be68	support elevenlabs private agent (#1063 )	2025-02-02 22:10:51 -05:00
Hoan Luu Huu	2ddcd53d6b	support elevenlabs s2s (#1052 ) * support elevenlabs s2s * wip * wip * wip	2025-02-02 10:29:48 -05:00
rammohan-y	a4d07ddce0	Feat/1057 recognition mode (#1060 ) * sending recognition mode channel variable * change verb-specifications version	2025-01-28 08:06:04 -05:00
rammohan-y	16e044cabf	feat/1053: added empty check on this.currentTask (#1054 )	2025-01-22 07:16:44 -05:00
Hoan Luu Huu	ba282d775d	support rimelabs tts streaming (#1047 )	2025-01-18 08:17:33 -05:00
Dave Horton	a194ba833e	Feat/1041 (#1045 ) * initial changes for stream synonym to listen * listen on B endpoint if nested listen in dial has channel === 2	2025-01-17 08:48:39 -05:00
rammohan-y	77f3d9d7ec	feat/1034: sending socket close code when there is no response from the websocket app (#1035 )	2025-01-16 10:13:00 -05:00
Sam Machin	4dbc7df93d	new error for HTTP responses without stack trace (#1044 ) * new error for HTTP responses without stack trace * lint	2025-01-16 08:05:17 -05:00
Dave Horton	f71f0ac69a	Fix/speechmatics (#1042 ) * add speechmatics options * wip * speechmatics does not do endpointing for us so we need to flip on continuousAsr * speechmatics: continousAsr should be at least equal to max_delay, if set	2025-01-15 19:12:15 -05:00
Dave Horton	edb7e21ff9	update deps	2025-01-14 10:45:38 -05:00
Dave Horton	cafd9530a2	update drachtio-srf and fsmrf to main branch releases (#1038 )	2025-01-14 10:01:33 -05:00
Hoan Luu Huu	ca8cace284	support custom tts streaming (#1023 ) * support custom tts streaming * wip * wip * wip * wip * wip * wip * fix review comments	2025-01-14 07:24:06 -05:00
Hoan Luu Huu	499c800213	Feat/ultravox s2s (#1032 ) * support ultravox_s2s * support ultravox_s2s * support ultravox_s2s * wip * wip * wip * wip * fix ultravox toolcall * wip	2025-01-14 07:11:55 -05:00
Sam Machin	97952afb1d	add deepgram filler words (#1036 ) * add deepgram filler words * Update package.json * Update package-lock.json	2025-01-13 11:07:24 -05:00
Hoan Luu Huu	f4e68d0ea1	fix openai_s2s is using wrong model (#1031 ) * fix openai_s2s is using wrong model * wip * wip	2025-01-11 08:38:14 -05:00
Dave Horton	6bad1a22f3	fix #1025 (#1026 ) * fix #1025 * redirect verb should be able to redirect to a new websocket endpoint	2025-01-09 15:45:20 -05:00
Hoan Luu Huu	fcefa1ff31	fix inband dtmf does not work in dial verb (#1018 )	2025-01-08 18:29:43 -05:00
Hoan Luu Huu	67cd53c930	rest:dial support timeLimit (#1024 ) * rest:dial support timeLimit * wip * wip * clear maxCallDuration timer	2025-01-07 12:21:09 -05:00
Dave Horton	a59784b8ab	update base image to node:20-alpine (#1022 )	2025-01-04 16:38:25 -05:00
Dave Horton	a2581eaeb4	tts throttling and send user_interruption event (#1019 ) * tts throttling and send user_interruption event * tts streaming: if we get a flush with tokens pending, send the flush after the tokens * wip	2025-01-04 16:34:01 -05:00
Dave Horton	3706aa4d98	#1020 - fix for sticky bargein (#1021 )	2025-01-03 10:41:35 -05:00
Dave Horton	25f1e65f63	feed TTS in sentence chunks when streaming (#1013 ) * feed TTS in sentence chunks when streaming * tts streaming: treat a paragraph as a chunk of text, even it not ending with a line end character * wip	2024-12-31 15:16:25 -05:00
rammohan-y	c9f0481ca6	feat/1009, sending reason in X-Reason header when AHD processor giveup (#1014 ) * feat/1009, sending reason in X-Reason header when AHD processor giveup is executed * fixed jslint error * added an alert	2024-12-31 15:09:23 -05:00
Hoan Luu Huu	564f6c9e55	support kill dial if sd ep is media timeout (#1001 ) * support kill dial if sd ep is media timeout * support kill dial if sd ep is media timeout * support kill dial if sd ep is media timeout * add media timeout reason header to bye message * wip * wip * make configuration for freeswitch media timeout * make configuration for freeswitch media timeout * wip	2024-12-23 07:19:41 -05:00
Dave Horton	02f25f8343	fix cartesia channel vars for streaming (#1012 )	2024-12-20 16:48:20 -05:00
Hoan Luu Huu	13ef89d605	support elevenlabs tts stream (#1011 ) * support elevenlabs tts stream * wip * wip	2024-12-20 09:50:13 -05:00
Dave Horton	d05e470867	remove hardcoding of openai model	2024-12-19 18:42:57 -05:00
Hoan Luu Huu	17250f8386	support cartesia tts (#1008 ) * support cartesia tts * update speech util version * update speech utils version	2024-12-19 07:35:47 -05:00
Dave Horton	ba3f46df64	Feat/tts streaming (#994 ) * wip * add TtsStreamingBuffer class to abstract handling of streaming tokens * wip * add throttling support * support background ttsStream (#995) * wip * add TtsStreamingBuffer class to abstract handling of streaming tokens * wip * support background ttsStream * wip --------- Co-authored-by: Dave Horton <daveh@beachdognet.com> * wip * dont send if we have nothing to send * initial testing with cartesia * wip --------- Co-authored-by: Hoan Luu Huu <110280845+xquanluu@users.noreply.github.com>	2024-12-18 14:44:37 -05:00
RJ Burnham	f37e1540ee	Make voicemail hints case insensitive (#1007 )	2024-12-13 13:42:29 -05:00
Dave Horton	5e04db82bf	Feat/deepgram voice agent (#1006 ) * wip * wip * wip	2024-12-13 10:05:23 -05:00
Dave Horton	0aa37a83ae	Feat/handle 3pcc invite (#1005 ) * wip * wip * linting	2024-12-12 18:39:15 -05:00