if call is transferred from another FS then always answer

Currently if the call being transferred was originally an outbound call then the direction thats retrieved from redis is outbound and the invite of the refer from the other FS is never answered, However a transferredCall will always need to be answered regardless of CallDirection
2026-03-28 11:00:50 +00:00 · 2025-10-07 11:24:08 +01:00
38 changed files with 2280 additions and 5530 deletions
--- a/4
+++ b/4
@@ -1,10 +1,10 @@
-FROM --platform=linux/amd64 node:24-alpine AS base
+FROM --platform=linux/amd64 node:20-alpine as base

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

 WORKDIR /opt/app/

-FROM base AS build
+FROM base as build

 COPY package.json package-lock.json ./

--- a/lib/config.js
+++ b/lib/config.js
@@ -119,7 +119,7 @@ const ENCRYPTION_SECRET = process.env.ENCRYPTION_SECRET;
 const HTTP_POOL = process.env.HTTP_POOL && parseInt(process.env.HTTP_POOL);
 const HTTP_POOLSIZE = parseInt(process.env.HTTP_POOLSIZE, 10) || 10;
 const HTTP_PIPELINING = parseInt(process.env.HTTP_PIPELINING, 10) || 1;
-const HTTP_TIMEOUT = parseInt(process.env.JAMBONES_HTTP_TIMEOUT, 10) || 10000;
+const HTTP_TIMEOUT = 10000;
 const HTTP_PROXY_IP = process.env.JAMBONES_HTTP_PROXY_IP;
 const HTTP_PROXY_PORT = process.env.JAMBONES_HTTP_PROXY_PORT;
 const HTTP_PROXY_PROTOCOL = process.env.JAMBONES_HTTP_PROXY_PROTOCOL || 'http';
@@ -139,11 +139,6 @@ const JAMBONES_USE_FREESWITCH_TIMER_FD = process.env.JAMBONES_USE_FREESWITCH_TIM
 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;
-const JAMBONES_WEBHOOK_ERROR_RETURN = parseInt(process.env.JAMBONES_WEBHOOK_ERROR_RETURN, 10) || 480;
-
-/* say / tts */
-const JAMBONES_SAY_CHUNK_SIZE = parseInt(process.env.JAMBONES_SAY_CHUNK_SIZE, 10) || 900;
-
 // jambonz
 const JAMBONES_TRANSCRIBE_EP_DESTROY_DELAY_MS =
  process.env.JAMBONES_TRANSCRIBE_EP_DESTROY_DELAY_MS;
@@ -236,7 +231,5 @@ module.exports = {
  JAMBONES_DIAL_SBC_FOR_REGISTERED_USER,
  JAMBONES_MEDIA_TIMEOUT_MS,
  JAMBONES_MEDIA_HOLD_TIMEOUT_MS,
-  JAMBONES_SAY_CHUNK_SIZE,
  JAMBONES_TRANSCRIBE_EP_DESTROY_DELAY_MS,
-  JAMBONES_WEBHOOK_ERROR_RETURN
 };
--- a/lib/http-routes/api/create-call.js
+++ b/lib/http-routes/api/create-call.js
@@ -18,7 +18,6 @@ const { createCallSchema, customSanitizeFunction } = require('../schemas/create-
 const { selectHostPort } = require('../../utils/network');
 const { JAMBONES_DIAL_SBC_FOR_REGISTERED_USER } = require('../../config');
 const { createMediaEndpoint } = require('../../utils/media-endpoint');
-const { DbErrorBadRequest } = require('../utils/errors');

 const removeNullProperties = (obj) => (Object.keys(obj).forEach((key) => obj[key] === null && delete obj[key]), obj);
 const removeNulls = (req, res, next) => {
@@ -123,16 +122,8 @@ router.post('/',
          }
          break;
        case 'user':
-          let targetName = target.name;
-          if (!targetName.includes('@')) {
-            if (!account.sip_realm) {
-              throw new DbErrorBadRequest('no sip realm configured for account');
-            }
-            logger.debug(`appending sip realm ${account.sip_realm} to target name ${targetName}`);
-            targetName = `${targetName}@${account.sip_realm}`;
-          }
-          uri = `sip:${targetName}`;
-          to = targetName;
+          uri = `sip:${target.name}`;
+          to = target.name;
          if (target.overrideTo) {
            Object.assign(opts.headers, {
              'X-Override-To': target.overrideTo
@@ -300,7 +291,7 @@ router.post('/',
            }, {
              ...(account.enable_debug_log && {level: 'debug'})
            });
-            app.requestor.logger = app.notifier.logger = restDial.logger = sipLogger;
+            app.requestor.logger = app.notifier.logger = sipLogger;
            const callInfo = new CallInfo({
              direction: CallDirection.Outbound,
              req: inviteReq,
@@ -340,12 +331,6 @@ router.post('/',
          }
        });
        connectStream(dlg.remote.sdp);
-
-        /* ensure sbcCallid is set even if no provisional response was received */
-        if (!cs.callInfo.sbcCallid && dlg.res.has('X-CID')) {
-          cs.callInfo.sbcCallid = dlg.res.get('X-CID');
-        }
-
        cs.emit('callStatusChange', {
          callStatus: CallStatus.InProgress,
          sipStatus: 200,
--- a/lib/http-routes/api/error.js
+++ b/lib/http-routes/api/error.js
@@ -6,8 +6,8 @@ function sysError(logger, res, err) {
    return res.status(400).json({msg: err.message});
  }
  if (err instanceof DbErrorUnprocessableRequest) {
-    logger.info({message: err.message}, 'unprocessable request');
-    return res.status(422).send(err.message);
+    logger.info(err, 'unprocessable request');
+    return res.status(422).json({msg: err.message});
  }
  if (err.code === 'ER_DUP_ENTRY') {
    logger.info(err, 'duplicate entry on insert');
--- a/lib/middleware.js
+++ b/lib/middleware.js
@@ -12,8 +12,7 @@ const RootSpan = require('./utils/call-tracer');
 const listTaskNames = require('./utils/summarize-tasks');
 const {
  JAMBONES_MYSQL_REFRESH_TTL,
-  JAMBONES_DISABLE_DIRECT_P2P_CALL,
-  JAMBONES_WEBHOOK_ERROR_RETURN
+  JAMBONES_DISABLE_DIRECT_P2P_CALL
 } = require('./config');
 const { createJambonzApp } = require('./dynamic-apps');
 const { decrypt } = require('./utils/encrypt-decrypt');
@@ -28,7 +27,6 @@ module.exports = function(srf, logger) {
    registrar,
    lookupClientByAccountAndUsername
  }  = srf.locals.dbHelpers;
-  const {addKey} = srf.locals.dbHelpers;
  const {
    writeAlerts,
    AlertType
@@ -114,14 +112,6 @@ module.exports = function(srf, logger) {
        req.locals.callingNumber = sipURIs[1];
      }
    }
-
-    // Feature server INVITE request pipelines taking time to finish,
-    // while connecting and fetch application from db and invoking webhook.
-    // call can be canceled without any handling, so we add a listener here
-    req.once('cancel', (sipMsg) => {
-      logger.info(`${callId} got CANCEL request`);
-      req.locals.canceled = true;
-    });
    next();
  }

@@ -143,14 +133,6 @@ module.exports = function(srf, logger) {
      rootSpan
    };

-    /* write a short-lived Redis key mapping the original Call-ID (X-CID) to the traceId,
-       so sbc-inbound can look it up for CDRs even when a CANCEL is sent to sbc-inbound */
-    const externalCallId = req.get('X-CID');
-    if (externalCallId) {
-      addKey(`callid:${externalCallId}`, traceId, 300)
-        .catch((err) => logger.error(err, 'createRootSpan: error writing traceId to Redis'));
-    }
-
    /**
     * end the span on final failure or cancel from caller;
     * otherwise it will be closed when sip dialog is destroyed
@@ -220,9 +202,7 @@ module.exports = function(srf, logger) {
      if (account?.enable_debug_log) {
        req.locals.logger.level = 'debug';
      }
-      // eslint-disable-next-line no-unused-vars
-      const {bucket_credential, ...safeAccount} = req.locals?.accountInfo?.account || {};
-      logger.debug({accountInfo: safeAccount}, `retrieved account info for ${account_sid}`);
+      logger.debug({accountInfo: req.locals?.accountInfo?.account}, `retrieved account info for ${account_sid}`);
      next();
    } catch (err) {
      span.end();
@@ -382,14 +362,13 @@ module.exports = function(srf, logger) {
      });
      // if transferred call contains callInfo, let update original data to newly created callInfo in this instance.
      if (app.transferredCall && app.callInfo) {
-        const {direction, callerName, from, to, originatingSipIp, originatingSipTrunkName, customerData} = app.callInfo;
+        const {direction, callerName, from, to, originatingSipIp, originatingSipTrunkName} = app.callInfo;
        req.locals.callInfo.direction = direction;
        req.locals.callInfo.callerName = callerName;
        req.locals.callInfo.from = from;
        req.locals.callInfo.to = to;
        req.locals.callInfo.originatingSipIp = originatingSipIp;
        req.locals.callInfo.originatingSipTrunkName = originatingSipTrunkName;
-        if (customerData) req.locals.callInfo.customerData = customerData;
        delete app.callInfo;
      }
      next();
@@ -492,7 +471,7 @@ module.exports = function(srf, logger) {
        message: `${err?.message}`.trim()
      }).catch((err) => this.logger.info({err}, 'Error generating alert for parsing application'));
      logger.info({err}, `Error retrieving or parsing application: ${err?.message}`);
-      res.send(JAMBONES_WEBHOOK_ERROR_RETURN, {headers: {'X-Reason': err?.message || 'unknown'}});
+      res.send(480, {headers: {'X-Reason': err?.message || 'unknown'}});
      app.requestor.close(WS_CLOSE_CODES.GoingAway);
    }
  }
--- a/lib/session/call-info.js
+++ b/lib/session/call-info.js
@@ -12,7 +12,6 @@ class CallInfo {
    let srf;
    this.direction = opts.direction;
    this.traceId = opts.traceId;
-    this.hasRecording = false;
    this.callTerminationBy = undefined;
    if (opts.req) {
      const u = opts.req.getParsedHeader('from');
--- a/lib/session/call-session.js
+++ b/lib/session/call-session.js
@@ -200,10 +200,6 @@ class CallSession extends Emitter {
    return this.backgroundTaskManager.isTaskRunning('listen');
  }

-  get isBackGroundRecord() {
-    return this.backgroundTaskManager.isTaskRunning('record');
-  }
-
  /**
   * SIP call-id for the call
   */
@@ -508,12 +504,7 @@ class CallSession extends Emitter {
  }

  get isTtsStreamEnabled() {
-    // 1st background tts stream
-    return this.backgroundTaskManager.isTaskRunning('ttsStream') ||
-    // 2nd current task streaming tts
-    TaskName.Say === this.currentTask?.name && this.currentTask?.isStreamingTts ||
-    // 3rd nested verb is streaming tts
-    TaskName.Gather === this.currentTask?.name && this.currentTask.sayTask?.isStreamingTts;
+    return this.backgroundTaskManager.isTaskRunning('ttsStream');
  }

  get isListenEnabled() {
@@ -667,15 +658,6 @@ class CallSession extends Emitter {
    }
  }

-  // disableTtsCache
-  get disableTtsCache() {
-    return this._disableTtsCache || false;
-  }
-
-  set disableTtsCache(d) {
-    this._disableTtsCache = d;
-  }
-
  getTsStreamingVendor() {
    let v;
    if (this.currentTask?.isStreamingTts) {
@@ -760,101 +742,69 @@ class CallSession extends Emitter {
    return this._fillerNoise;
  }

+  async pauseOrResumeBackgroundListenIfRequired(action, silence = false) {
+    if ((action == 'pauseCallRecording' || action == 'resumeCallRecording') &&
+    this.backgroundTaskManager.isTaskRunning('record')) {
+      this.logger.debug({action, silence}, 'CallSession:pauseOrResumeBackgroundListenIfRequired');
+      const backgroundListenTask = this.backgroundTaskManager.getTask('record');
+      const status = action === 'pauseCallRecording' ? ListenStatus.Pause : ListenStatus.Resume;
+      backgroundListenTask.updateListen(
+        status,
+        silence
+      );
+    }
+  }

  async notifyRecordOptions(opts) {
-    const {action, silence = false, type = 'siprec'} = opts;
+    const {action, silence} = opts;
    this.logger.debug({opts}, 'CallSession:notifyRecordOptions');

-    if (type == 'cloud') {
-      switch (action) {
-        case 'pauseCallRecording':
-          if (this.backgroundTaskManager.isTaskRunning('record')) {
-            this.logger.debug({action, silence, type}, 'CallSession:cloudRecording');
-            const backgroundListenTask = this.backgroundTaskManager.getTask('record');
-            backgroundListenTask.updateListen(
-              ListenStatus.Pause,
-              silence
-            );
-            return true;
-          } else { return false; }
-        case 'resumeCallRecording':
-          if (this.backgroundTaskManager.isTaskRunning('record')) {
-            this.logger.debug({action, silence, type}, 'CallSession:cloudRecording');
-            const backgroundListenTask = this.backgroundTaskManager.getTask('record');
-            backgroundListenTask.updateListen(
-              ListenStatus.Resume,
-              silence
-            );
-            return true;
-          } else { return false; }
-        case 'startCallRecording':
-          if (!this.backgroundTaskManager.isTaskRunning('record')) {
-            this.logger.debug({action, silence, type}, 'CallSession:cloudRecording');
-            this.callInfo.hasRecording = true;
-            this.updateCallStatus(Object.assign({}, this.callInfo.toJSON()), this.serviceUrl)
-              .catch((err) => this.logger.error(err, 'redis error'));
-            if (!this.dlg) {
-              // Call not yet answered so set flag to record on status change
-              this.application.record_all_calls = true;
-            } else {
-              this.backgroundTaskManager.newTask('record');
-            }
-            return true;
-          } else { return false; }
-        case 'stopCallRecording':
-          if (this.backgroundTaskManager.isTaskRunning('record')) {
-            this.logger.debug({action, silence, type}, 'CallSession:cloudRecording');
-            this.backgroundTaskManager.stop('record');
-            return true;
-          } else { return false; }
-      }
-    } else {
-      // SIPREC
-      /* if we have not answered yet, just save the details for later */
-      if (!this.dlg) {
-        if (action === 'startCallRecording') {
-          this.recordOptions = opts;
-          return true;
-        }
-        return false;
-      }
+    this.pauseOrResumeBackgroundListenIfRequired(action, silence);

-      /* check validity of request */
-      if (action == 'startCallRecording' && this.recordState !== RecordState.RecordingOff) {
-        this.logger.info({recordState: this.recordState},
-          'CallSession:notifyRecordOptions: recording is already started, ignoring request');
-        return false;
-      }
-      if (action == 'stopCallRecording' && this.recordState === RecordState.RecordingOff) {
-        this.logger.info({recordState: this.recordState},
-          'CallSession:notifyRecordOptions: recording is already stopped, ignoring request');
-        return false;
-      }
-      if (action == 'pauseCallRecording' && this.recordState !== RecordState.RecordingOn) {
-        this.logger.info({recordState: this.recordState},
-          'CallSession:notifyRecordOptions: cannot pause recording, ignoring request ');
-        return false;
-      }
-      if (action == 'resumeCallRecording' && this.recordState !== RecordState.RecordingPaused) {
-        this.logger.info({recordState: this.recordState},
-          'CallSession:notifyRecordOptions: cannot resume recording, ignoring request ');
-        return false;
+    /* if we have not answered yet, just save the details for later */
+    if (!this.dlg) {
+      if (action === 'startCallRecording') {
+        this.recordOptions = opts;
+        return true;
      }
+      return false;
+    }

-      this.recordOptions = opts;
+    /* check validity of request */
+    if (action == 'startCallRecording' && this.recordState !== RecordState.RecordingOff) {
+      this.logger.info({recordState: this.recordState},
+        'CallSession:notifyRecordOptions: recording is already started, ignoring request');
+      return false;
+    }
+    if (action == 'stopCallRecording' && this.recordState === RecordState.RecordingOff) {
+      this.logger.info({recordState: this.recordState},
+        'CallSession:notifyRecordOptions: recording is already stopped, ignoring request');
+      return false;
+    }
+    if (action == 'pauseCallRecording' && this.recordState !== RecordState.RecordingOn) {
+      this.logger.info({recordState: this.recordState},
+        'CallSession:notifyRecordOptions: cannot pause recording, ignoring request ');
+      return false;
+    }
+    if (action == 'resumeCallRecording' && this.recordState !== RecordState.RecordingPaused) {
+      this.logger.info({recordState: this.recordState},
+        'CallSession:notifyRecordOptions: cannot resume recording, ignoring request ');
+      return false;
+    }

-      switch (action) {
-        case 'startCallRecording':
-          return await this.startRecording();
-        case 'stopCallRecording':
-          return await this.stopRecording();
-        case 'pauseCallRecording':
-          return await this.pauseRecording();
-        case 'resumeCallRecording':
-          return await this.resumeRecording();
-        default:
-          throw new Error(`invalid record action ${action}`);
-      }
+    this.recordOptions = opts;
+
+    switch (action) {
+      case 'startCallRecording':
+        return await this.startRecording();
+      case 'stopCallRecording':
+        return await this.stopRecording();
+      case 'pauseCallRecording':
+        return await this.pauseRecording();
+      case 'resumeCallRecording':
+        return await this.resumeRecording();
+      default:
+        throw new Error(`invalid record action ${action}`);
    }
  }

@@ -968,7 +918,7 @@ class CallSession extends Emitter {
        this.logger.debug('CallSession:enableBackgroundTtsStream - ttsStream enabled');
      } else {
        this.logger.debug(
-          'CallSession:enableBackgroundTtsStream - ignoring request; conditions not met (probably not using ws api)');
+          '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');
@@ -982,25 +932,15 @@ class CallSession extends Emitter {
    }
  }
  clearTtsStream() {
-    if (this.isTtsStreamEnabled) {
-      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();
-    }
+    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();
  }

-  stopTtsStream() {
-    if (this.isTtsStreamEnabled) {
-      this.requestor?.request('tts:streaming-event', '/streaming-event', {event_type: 'stream_closed'})
-        .catch((err) => this.logger.info({err}, 'CallSession:clearTtsStream - Error sending user_interruption'));
-      this.ttsStreamingBuffer?.stop();
-    }
-  }
-
  async enableBotMode(gather, autoEnable) {
    try {
      let task;
@@ -1024,7 +964,7 @@ class CallSession extends Emitter {
      task.sticky = autoEnable;
      // listen to the bargein-done from background manager
      this.backgroundTaskManager.on('bargeIn-done', () => {
-        if (this.appIsUsingWebsockets) {
+        if (this.requestor instanceof WsRequestor) {
          try {
            this.kill(true);
          } catch (err) {}
@@ -1086,7 +1026,7 @@ class CallSession extends Emitter {
            const cred = JSON.parse(credential.service_key.replace(/\n/g, '\\n'));
            return {
              speech_credential_sid: credential.speech_credential_sid,
-              credentials: cred,
+              credentials: cred
            };
          } catch (err) {
            const sid = this.accountInfo.account.account_sid;
@@ -1146,13 +1086,6 @@ class CallSession extends Emitter {
            deepgram_stt_use_tls: credential.deepgram_stt_use_tls
          };
        }
-        else if ('gladia' === vendor) {
-          return {
-            speech_credential_sid: credential.speech_credential_sid,
-            api_key: credential.api_key,
-            region: credential.region,
-          };
-        }
        else if ('soniox' === vendor) {
          return {
            speech_credential_sid: credential.speech_credential_sid,
@@ -1184,7 +1117,6 @@ class CallSession extends Emitter {
          return {
            api_key: credential.api_key,
            model_id: credential.model_id,
-            api_uri: credential.api_uri,
            options: credential.options
          };
        }
@@ -1233,15 +1165,6 @@ class CallSession extends Emitter {
            service_version: credential.service_version
          };
        }
-        else if ('houndify' === vendor) {
-          return {
-            speech_credential_sid: credential.speech_credential_sid,
-            client_id: credential.client_id,
-            client_key: credential.client_key,
-            user_id: credential.user_id,
-            houndify_server_uri: credential.houndify_server_uri
-          };
-        }
        else if ('deepgramflux' === vendor) {
          return {
            speech_credential_sid: credential.speech_credential_sid,
@@ -1291,10 +1214,9 @@ class CallSession extends Emitter {
      }
      else {
        writeAlerts({
-          alert_type: type === 'tts' ? AlertType.TTS_NOT_PROVISIONED : AlertType.STT_NOT_PROVISIONED,
+          alert_type: AlertType.STT_NOT_PROVISIONED,
          account_sid: this.accountSid,
          vendor,
-          label,
          target_sid: this.callSid
        }).catch((err) => this.logger.error({err}, 'Error writing tts alert'));
      }
@@ -1325,7 +1247,6 @@ class CallSession extends Emitter {
      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));
-      this.ttsStreamingBuffer.on(TtsStreamingEvents.Connected, this._onTtsStreamingConnected.bind(this));
    }
    else {
      this.logger.info(`CallSession:exec - not a normal call session: ${this.constructor.name}`);
@@ -1384,7 +1305,7 @@ class CallSession extends Emitter {
      }

      if (0 === this.tasks.length &&
-        this.appIsUsingWebsockets &&
+        this.requestor instanceof WsRequestor &&
        !this.requestor.closedGracefully &&
        !this.callGone &&
        !this.isConfirmCallSession
@@ -1488,12 +1409,7 @@ class CallSession extends Emitter {
    else if (opts.call_status === CallStatus.NoAnswer) {
      if (this.direction === CallDirection.Inbound) {
        if (this.res && !this.res.finalResponseSent) {
-          const traceId = this.req?.locals?.traceId;
-          this.res.send(503, {
-            headers: {
-              ...(traceId && {'X-Trace-ID': traceId})
-            }
-          });
+          this.res.send(503);
          this._callReleased();
        }
      }
@@ -2037,7 +1953,7 @@ Duration=${duration} `
        return this._lccDub(opts.dub, callSid);
      }
      else if (opts.boostAudioSignal) {
-        return this._lccBoostAudioSignal(opts.boostAudioSignal, callSid);
+        return this._lccBoostAudioSignal(opts, callSid);
      }
      else if (opts.media_path) {
        return this._lccMediaPath(opts.media_path, callSid);
@@ -2320,8 +2236,7 @@ Duration=${duration} `
        break;

      case 'mute:status':
-        const status = typeof (data) === 'string' ? data : data.mute_status;
-        this._lccMuteStatus(status === 'mute', call_sid);
+        this._lccMuteStatus(data, call_sid);
        break;

      case 'conf:mute-status':
@@ -2510,38 +2425,6 @@ Duration=${duration} `
      }
      else {
        this.logger.error(err, `Error attempting to allocate endpoint for for task ${task.name}`);
-        // Check for SipError type (e.g., 488 codec incompatibility)
-        const isSipError = err.name === 'SipError';
-        if (isSipError && err.status) {
-          // Extract Reason header from SIP response if available (e.g., Q.850;cause=88;text="INCOMPATIBLE_DESTINATION")
-          const sipReasonHeader = err.res?.msg?.headers?.reason;
-          this._endpointAllocationError = {
-            status: err.status,
-            reason: err.reason || 'Endpoint Allocation Failed',
-            sipReasonHeader
-          };
-          this.logger.info({endpointAllocationError: this._endpointAllocationError},
-            'Captured SipError for propagation to SBC');
-
-          // Send SIP error response immediately for inbound calls
-          if (this.res && !this.res.finalResponseSent) {
-            this.logger.info(`Sending ${err.status} response to SBC due to SipError`);
-            const traceId = this.req?.locals?.traceId;
-            this.res.send(err.status, {
-              headers: {
-                'X-Reason': `endpoint allocation failure: ${err.reason || 'Endpoint Allocation Failed'}`,
-                ...(sipReasonHeader && {'Reason': sipReasonHeader}),
-                ...(traceId && {'X-Trace-ID': traceId})
-              }
-            });
-            this._notifyCallStatusChange({
-              callStatus: CallStatus.Failed,
-              sipStatus: err.status,
-              sipReason: err.reason || 'Endpoint Allocation Failed'
-            });
-            this._callReleased();
-          }
-        }
        throw new Error(`${BADPRECONDITIONS}: unable to allocate endpoint`);
      }
    }
@@ -2648,7 +2531,7 @@ Duration=${duration} `
    this.backgroundTaskManager.stopAll();
    this.clearOrRestoreActionHookDelayProcessor().catch((err) => {});

-    this.stopTtsStream();
+    this.ttsStreamingBuffer?.stop();

    this.sttLatencyCalculator?.stop();
  }
@@ -2792,7 +2675,6 @@ Duration=${duration} `
      }
    } catch (err) {
      this.logger.error(err, 'Error handling reinvite');
-      res.send(err.status || 500);
    }
  }

@@ -3055,7 +2937,8 @@ Duration=${duration} `

    // manage record all call.
    if (callStatus === CallStatus.InProgress) {
-      if (this.accountInfo.account.record_all_calls || this.application.record_all_calls) {
+      if (this.accountInfo.account.record_all_calls ||
+        this.application.record_all_calls) {
        this.backgroundTaskManager.newTask('record');
      }
    } else if (callStatus == CallStatus.Completed) {
@@ -3108,14 +2991,14 @@ Duration=${duration} `
   */

  _notifyTaskError(obj) {
-    if (this.appIsUsingWebsockets) {
+    if (this.requestor instanceof WsRequestor) {
      this.requestor.request('jambonz:error', '/error', obj)
        .catch((err) => this.logger.debug({err}, 'CallSession:_notifyTaskError - Error sending'));
    }
  }

  _notifyTaskStatus(task, evt) {
-    if (this.notifyEvents && this.appIsUsingWebsockets) {
+    if (this.notifyEvents && this.requestor instanceof WsRequestor) {
      const obj = {...evt, id: task.id, name: task.name};
      this.requestor.request('verb:status', '/status', obj)
        .catch((err) => this.logger.debug({err}, 'CallSession:_notifyTaskStatus - Error sending'));
@@ -3167,7 +3050,7 @@ Duration=${duration} `
  }

  _clearTasks(backgroundGather, evt) {
-    if (this.appIsUsingWebsockets && !backgroundGather.cleared) {
+    if (this.requestor instanceof WsRequestor && !backgroundGather.cleared) {
      this.logger.debug({evt}, 'CallSession:_clearTasks on event from background gather');
      try {
        backgroundGather.cleared = true;
@@ -3195,11 +3078,6 @@ Duration=${duration} `
    }
  }

-  _onTtsStreamingConnected() {
-    this.requestor?.request('tts:streaming-event', '/streaming-event', {event_type: 'stream_open'})
-      .catch((err) => this.logger.info({err}, 'CallSession:_onTtsStreamingConnected - Error sending'));
-  }
-
  _onTtsStreamingEmpty() {
    const task = this.currentTask;
    if (task && TaskName.Say === task.name) {
--- a/lib/session/inbound-call-session.js
+++ b/lib/session/inbound-call-session.js
@@ -22,12 +22,6 @@ class InboundCallSession extends CallSession {
    this.req = req;
    this.res = res;

-    // if the call was canceled before we got here, handle it
-    if (this.req.locals.canceled) {
-      req.locals.logger.info('InboundCallSession: constructor - call was already canceled');
-      this._onCancel();
-    }
-
    req.once('cancel', this._onCancel.bind(this));

    this.on('callStatusChange', this._notifyCallStatusChange.bind(this));
@@ -51,39 +45,19 @@ class InboundCallSession extends CallSession {

  _onTasksDone() {
    if (!this.res.finalResponseSent) {
-      const traceId = this.req.locals.traceId;
      if (this._mediaServerFailure) {
        this.rootSpan.setAttributes({'call.termination': 'media server failure'});
        this.logger.info('InboundCallSession:_onTasksDone generating 480 due to media server failure');
        this.res.send(480, {
          headers: {
-            'X-Reason': 'crankback: media server failure',
-            ...(traceId && {'X-Trace-ID': traceId})
-          }
-        });
-      }
-      else if (this._endpointAllocationError) {
-        // Propagate SIP error from endpoint allocation failure back to the client
-        const {status, reason, sipReasonHeader} = this._endpointAllocationError;
-        this.rootSpan.setAttributes({'call.termination': `endpoint allocation SIP error ${status}`});
-        this.logger.info({endpointAllocationError: this._endpointAllocationError},
-          `InboundCallSession:_onTasksDone generating ${status} due to endpoint allocation failure`);
-        this.res.send(status, {
-          headers: {
-            'X-Reason': `endpoint allocation failure: ${reason}`,
-            ...(sipReasonHeader && {'Reason': sipReasonHeader}),
-            ...(traceId && {'X-Trace-ID': traceId})
+            'X-Reason': 'crankback: media server failure'
          }
        });
      }
      else {
        this.rootSpan.setAttributes({'call.termination': 'tasks completed without answering call'});
        this.logger.info('InboundCallSession:_onTasksDone auto-generating non-success response to invite');
-        this.res.send(603, {
-          headers: {
-            ...(traceId && {'X-Trace-ID': traceId})
-          }
-        });
+        this.res.send(603);
      }
    }
    this.req.removeAllListeners('cancel');
--- a/lib/tasks/conference.js
+++ b/lib/tasks/conference.js
@@ -49,8 +49,7 @@ class Conference extends Task {
    this.confName = this.data.name;
    [
      'beep', 'startConferenceOnEnter', 'endConferenceOnExit', 'joinMuted',
-      'maxParticipants', 'waitHook', 'statusHook', 'endHook', 'enterHook',
-      'endConferenceDuration', 'distributeDtmf'
+      'maxParticipants', 'waitHook', 'statusHook', 'endHook', 'enterHook', 'endConferenceDuration'
    ].forEach((attr) => this[attr] = this.data[attr]);
    this.record = this.data.record || {};
    this.statusEvents = [];
@@ -357,7 +356,6 @@ class Conference extends Task {
        //https://developer.signalwire.com/freeswitch/FreeSWITCH-Explained/Modules/mod_conference_3965534/
        // mute |	Enter conference muted
        ...((this.joinMuted || this.speakOnlyTo) && {mute: true}),
-        ...(this.distributeDtmf && {'dist-dtmf': true})
      }});

      /**
@@ -469,7 +467,6 @@ class Conference extends Task {
    assert (cs.isInConference);

    const mute = opts.conf_mute_status === 'mute';
-    this.logger.info(`Conference:doConferenceMute ${mute ? 'muting' : 'unmuting'} member`);
    this.ep.api(`conference ${this.confName} ${mute ? 'mute' : 'unmute'} ${this.memberId}`)
      .catch((err) => this.logger.info({err}, 'Error muting or unmuting participant'));
  }
@@ -571,8 +568,8 @@ class Conference extends Task {
  /**
   * mute or unmute side of the call
   */
-  async mute(callSid, doMute) {
-    this.doConferenceMute(this.callSession, {conf_mute_status: doMute ? 'mute' : 'unmute'});
+  mute(callSid, doMute) {
+    this.doConferenceMute(this.callSession, {conf_mute_status: doMute});
  }

  /**
--- a/lib/tasks/config.js
+++ b/lib/tasks/config.js
@@ -18,8 +18,7 @@ class TaskConfig extends Task {
      'boostAudioSignal',
      'vad',
      'ttsStream',
-      'autoStreamTts',
-      'disableTtsCache'
+      'autoStreamTts'
    ].forEach((k) => this[k] = this.data[k] || {});

    if ('notifyEvents' in this.data) {
@@ -89,7 +88,6 @@ class TaskConfig extends Task {
  get hasReferHook() { return Object.keys(this.data).includes('referHook'); }
  get hasNotifySttLatency() { return Object.keys(this.data).includes('notifySttLatency'); }
  get hasTtsStream() { return Object.keys(this.ttsStream).length; }
-  get hasDisableTtsCache() { return Object.keys(this.data).includes('disableTtsCache'); }

  get summary() {
    const phrase = [];
@@ -127,7 +125,6 @@ class TaskConfig extends Task {
      phrase.push(`${this.ttsStream.enable ? 'enable' : 'disable'} ttsStream`);
    }
    if ('autoStreamTts' in this.data) phrase.push(`enable Say.stream value ${this.data.autoStreamTts ? 'on' : 'off'}`);
-    if (this.hasDisableTtsCache) phrase.push(`disableTtsCache ${this.data.disableTtsCache ? 'on' : 'off'}`);
    return `${this.name}{${phrase.join(',')}}`;
  }

@@ -360,11 +357,6 @@ class TaskConfig extends Task {
      this.logger.info('Config: disabling ttsStream');
      cs.disableTtsStream();
    }
-
-    if (this.hasDisableTtsCache) {
-      this.logger.info(`set disableTtsCache = ${this.disableTtsCache}`);
-      cs.disableTtsCache = this.data.disableTtsCache;
-    }
  }

  async kill(cs) {
--- a/lib/tasks/dial.js
+++ b/lib/tasks/dial.js
@@ -21,7 +21,7 @@ const {parseUri} = require('drachtio-srf');
 const {ANCHOR_MEDIA_ALWAYS,
  JAMBONZ_DIAL_PAI_HEADER,
  JAMBONES_DIAL_SBC_FOR_REGISTERED_USER} = require('../config');
-const { isOnhold, isOpusFirst, getLeadingCodec } = require('../utils/sdp-utils');
+const { isOnhold, isOpusFirst } = require('../utils/sdp-utils');
 const { normalizeJambones } = require('@jambonz/verb-specifications');
 const { selectHostPort } = require('../utils/network');
 const { sleepFor } = require('../utils/helpers');
@@ -158,9 +158,7 @@ class TaskDial extends Task {

  get canReleaseMedia() {
    const keepAnchor = this.data.anchorMedia ||
-      this.isTranscoding ||
      this.cs.isBackGroundListen ||
-      this.cs.isBackGroundRecord ||
      this.cs.onHoldMusic ||
      ANCHOR_MEDIA_ALWAYS ||
      this.listenTask ||
@@ -196,9 +194,6 @@ class TaskDial extends Task {
  async exec(cs) {
    await super.exec(cs);

-    /* capture whether A leg was already answered before this dial task started */
-    this._aLegAlreadyAnswered = !!cs.dlg;
-
    if (this.data.anchorMedia && this.data.exitMediaPath) {
      this.logger.info('Dial:exec - incompatible anchorMedia and exitMediaPath are both set, will obey anchorMedia');
      delete this.data.exitMediaPath;
@@ -554,7 +549,7 @@ class TaskDial extends Task {
    let sbcAddress = this.proxy || getSBC();
    const teamsInfo = {};
    let fqdn;
-    const forwardPAI = this.forwardPAI ?? !JAMBONZ_DIAL_PAI_HEADER; // dial verb overides env var
+    const forwardPAI = this.forwardPAI ?? JAMBONZ_DIAL_PAI_HEADER; // dial verb overides env var
    this.logger.debug(forwardPAI, 'forwardPAI value');
    if (!sbcAddress) throw new Error('no SBC found for outbound call');
    this.headers = {
@@ -580,7 +575,7 @@ class TaskDial extends Task {
      proxy: `sip:${sbcAddress}`,
      callingNumber: this.callerId || fromUri.user,
      ...(this.callerName && {callingName: this.callerName}),
-      opusFirst: isOpusFirst(this.cs.ep.local.sdp),
+      opusFirst: isOpusFirst(this.cs.ep.remote.sdp),
      isVideoCall: this.cs.ep.remote.sdp.includes('m=video')
    };

@@ -777,15 +772,6 @@ class TaskDial extends Task {
  }

  async _connectSingleDial(cs, sd) {
-    // start connect with dialed leg, this is the soonest we can identify transcoding
-    if (this.epOther && sd.ep) {
-      const codecA = getLeadingCodec(this.epOther.local.sdp);
-      const codecB = getLeadingCodec(sd.ep.remote.sdp);
-      this.isTranscoding = (codecA !== codecB);
-      if (this.isTranscoding) {
-        this.logger.info(`Dial:_connectSingleDial - transcoding from ${codecA} (A leg) to ${codecB} (B leg)`);
-      }
-    }
    if (!this.bridged && !this.canReleaseMedia) {
      this.logger.debug('Dial:_connectSingleDial bridging endpoints');
      if (this.epOther) {
@@ -876,12 +862,8 @@ class TaskDial extends Task {
    this.sd = sd;
    this.callSid = sd.callSid;
    if (this.earlyMedia) {
-      if (this._aLegAlreadyAnswered) {
-        debug('Dial:_selectSingleDial A leg was already answered, skipping propagateAnswer');
-      } else {
-        debug('Dial:_selectSingleDial propagating answer supervision on A leg now that B is connected');
-        await cs.propagateAnswer();
-      }
+      debug('Dial:_selectSingleDial propagating answer supervision on A leg now that B is connected');
+      await cs.propagateAnswer();
    }
    if (this.timeLimit) {
      this.timerMaxCallDuration = setTimeout(this._onMaxCallDuration.bind(this, cs), this.timeLimit * 1000);
@@ -947,6 +929,7 @@ class TaskDial extends Task {
        this.logger.info({err}, 'Dial:_selectSingleDial - Error boosting audio signal');
      }
    }
+
    /* if we can release the media back to the SBC, do so now */
    if (this.canReleaseMedia || this.shouldExitMediaPathEntirely) {
      setTimeout(this._releaseMedia.bind(this, cs, sd, this.shouldExitMediaPathEntirely), 200);
--- a/lib/tasks/dialogflow/index.js
+++ b/lib/tasks/dialogflow/index.js
@@ -1,4 +1,3 @@
-const assert = require('assert');
 const Task = require('../task');
 const {TaskName, TaskPreconditions} = require('../../utils/constants');
 const Intent = require('./intent');
@@ -11,27 +10,19 @@ class Dialogflow extends Task {
    super(logger, opts);
    this.preconditions = TaskPreconditions.Endpoint;
    this.credentials = this.data.credentials;
-    this.project = this.data.project;
-    this.agent = this.data.agent;
-    this.region = this.data.region || 'us-central1';
-    this.model = this.data.model || 'es';

-    assert(this.agent || !this.isCX, 'agent is required for dialogflow cx');
-    assert(this.credentials, 'dialogflow credentials are required');
-
-    if (this.isCX) {
-      this.environment = this.data.environment || 'none';
+    /* set project id with environment and region (optionally) */
+    if (this.data.environment && this.data.region) {
+      this.project = `${this.data.project}:${this.data.environment}:${this.data.region}`;
+    }
+    else if (this.data.environment) {
+      this.project = `${this.data.project}:${this.data.environment}`;
+    }
+    else if (this.data.region) {
+      this.project = `${this.data.project}::${this.data.region}`;
    }
    else {
-      if (this.data.environment && this.data.region) {
-        this.project = `${this.data.project}:${this.data.environment}:${this.data.region}`;
-      }
-      else if (this.data.environment) {
-        this.project = `${this.data.project}:${this.data.environment}`;
-      }
-      else if (this.data.region) {
-        this.project = `${this.data.project}::${this.data.region}`;
-      }
+      this.project = this.data.project;
    }

    this.lang = this.data.lang || 'en-US';
@@ -48,6 +39,7 @@ class Dialogflow extends Task {
      this.events = this.data.events;
    }
    else if (this.eventHook) {
+      // send all events by default - except interim transcripts
      this.events = [
        'intent',
        'transcription',
@@ -68,33 +60,38 @@ class Dialogflow extends Task {
      this.voice = this.data.tts.voice || 'default';
      this.speechSynthesisLabel = this.data.tts.label;

+      // fallback tts
      this.fallbackVendor = this.data.tts.fallbackVendor || 'default';
      this.fallbackLanguage = this.data.tts.fallbackLanguage || 'default';
-      this.fallbackVoice = this.data.tts.fallbackVoice || 'default';
+      this.fallbackVoice = this.data.tts.fallbackLanguage || 'default';
      this.fallbackLabel = this.data.tts.fallbackLabel;
    }
    this.bargein = this.data.bargein;
-
-    this.cmd = this.isCX ? 'dialogflow_cx_start' : 'dialogflow_start';
-    this.cmdStop = this.isCX ? 'dialogflow_cx_stop' : 'dialogflow_stop';
-
-    // CX-specific state
-    this._suppressNextCXAudio = false;
-    this._cxAudioHandled = false;
  }

  get name() { return TaskName.Dialogflow; }

-  get isCX() { return this.model === 'cx'; }
-
-  get isES() { return !this.isCX; }
-
  async exec(cs, {ep}) {
    await super.exec(cs);

    try {
      await this.init(cs, ep);
-      await this.startBot('default');
+
+      this.logger.debug(`starting dialogflow bot ${this.project}`);
+
+      // kick it off
+      const baseArgs = `${this.ep.uuid} ${this.project} ${this.lang} ${this.welcomeEvent}`;
+      if (this.welcomeEventParams) {
+        this.ep.api('dialogflow_start', `${baseArgs} '${JSON.stringify(this.welcomeEventParams)}'`);
+      }
+      else if (this.welcomeEvent.length) {
+        this.ep.api('dialogflow_start', baseArgs);
+      }
+      else {
+        this.ep.api('dialogflow_start', `${this.ep.uuid} ${this.project} ${this.lang}`);
+      }
+      this.logger.debug(`started dialogflow bot ${this.project}`);
+
      await this.awaitTaskDone();
    } catch (err) {
      this.logger.error({err}, 'Dialogflow:exec error');
@@ -111,12 +108,6 @@ class Dialogflow extends Task {
      this.ep.removeCustomEventListener('dialogflow::end_of_utterance');
      this.ep.removeCustomEventListener('dialogflow::error');

-      this.ep.removeCustomEventListener('dialogflow_cx::intent');
-      this.ep.removeCustomEventListener('dialogflow_cx::transcription');
-      this.ep.removeCustomEventListener('dialogflow_cx::audio_provided');
-      this.ep.removeCustomEventListener('dialogflow_cx::end_of_utterance');
-      this.ep.removeCustomEventListener('dialogflow_cx::error');
-
      this._clearNoinputTimer();

      if (!this.reportedFinalAction) this.performAction({dialogflowResult: 'caller hungup'})
@@ -150,12 +141,6 @@ class Dialogflow extends Task {
      this.ep.addCustomEventListener('dialogflow::end_of_utterance', this._onEndOfUtterance.bind(this, ep, cs));
      this.ep.addCustomEventListener('dialogflow::error', this._onError.bind(this, ep, cs));

-      this.ep.addCustomEventListener('dialogflow_cx::intent', this._onIntent.bind(this, ep, cs));
-      this.ep.addCustomEventListener('dialogflow_cx::transcription', this._onTranscription.bind(this, ep, cs));
-      this.ep.addCustomEventListener('dialogflow_cx::audio_provided', this._onAudioProvided.bind(this, ep, cs));
-      this.ep.addCustomEventListener('dialogflow_cx::end_of_utterance', this._onEndOfUtterance.bind(this, ep, cs));
-      this.ep.addCustomEventListener('dialogflow_cx::error', this._onError.bind(this, ep, cs));
-
      const obj = typeof this.credentials === 'string' ? JSON.parse(this.credentials) : this.credentials;
      const creds = JSON.stringify(obj);
      await this.ep.set('GOOGLE_APPLICATION_CREDENTIALS', creds);
@@ -166,102 +151,41 @@ class Dialogflow extends Task {
    }
  }

-  async startBot(intent) {
-    if (this.isCX) {
-      const event = this.welcomeEvent || intent;
-      const args = this._buildStartArgs({
-        event: event && event !== 'default' ? event : undefined
-      });
-      this.logger.info({args}, 'starting dialogflow CX bot');
-      await this.ep.api(this.cmd, args);
-    }
-    else {
-      await this._startBotES();
-    }
-  }
-
-  async _startBotES() {
-    this.logger.info('starting dialogflow ES bot');
-    const baseArgs = `${this.ep.uuid} ${this.project} ${this.lang} ${this.welcomeEvent}`;
-    if (this.welcomeEventParams) {
-      await this.ep.api(this.cmd, `${baseArgs} '${JSON.stringify(this.welcomeEventParams)}'`);
-    }
-    else if (this.welcomeEvent.length) {
-      await this.ep.api(this.cmd, baseArgs);
-    }
-    else {
-      await this.ep.api(this.cmd, `${this.ep.uuid} ${this.project} ${this.lang}`);
-    }
-  }
-
-  /**
-   * Build the start command args string for either ES or CX.
-   * @param {object} opts - options
-   * @param {string} opts.event - optional event to send
-   * @param {string} opts.text - optional text to send
-   * @param {number} opts.singleUtterance - 1 or 0 (CX only, default 1)
-   * @returns {string} command args string
-   */
-  _buildStartArgs({event, text, singleUtterance = 1} = {}) {
-    if (this.isCX) {
-      const args = [
-        this.ep.uuid,
-        this.project,
-        this.region,
-        this.agent,
-        this.environment || 'none',
-        this.lang,
-        event || 'none',
-        text ? `'${text}'` : 'none',
-        singleUtterance ? '1' : '0',
-      ];
-      return args.join(' ');
-    }
-    // ES
-    const args = [this.ep.uuid, this.project, this.lang];
-    if (event) {
-      args.push(event);
-    }
-    if (text) {
-      if (!event) args.push('none');
-      args.push(`'${text}'`);
-    }
-    return args.join(' ');
-  }
-
  /**
   * An intent has been returned.  Since we are using SINGLE_UTTERANCE on the dialogflow side,
   * we may get an empty intent, signified by the lack of a 'response_id' attribute.
   * In such a case, we just start another StreamingIntentDetectionRequest.
   * @param {*} ep -  media server endpoint
-   * @param {*} cs - call session
   * @param {*} evt - event data
   */
  async _onIntent(ep, cs, evt) {
    const intent = new Intent(this.logger, evt);

    if (intent.isEmpty) {
+      /**
+       * An empty intent is returned in 3 conditions:
+       * 1. Our no-input timer fired
+       * 2. We collected dtmf that needs to be fed to dialogflow
+       * 3. A normal dialogflow timeout
+       */
      if (this.noinput && this.greetingPlayed) {
        this.logger.info('no input timer fired, reprompting..');
        this.noinput = false;
-        ep.api(this.cmd, this._buildStartArgs({event: this.noInputEvent}));
+        ep.api('dialogflow_start', `${ep.uuid} ${this.project} ${this.lang} ${this.noInputEvent}`);
      }
      else if (this.dtmfEntry && this.greetingPlayed) {
        this.logger.info('dtmf detected, reprompting..');
-        ep.api(this.cmd, this._buildStartArgs({text: this.dtmfEntry}));
+        ep.api('dialogflow_start', `${ep.uuid} ${this.project} ${this.lang} none \'${this.dtmfEntry}\'`);
        this.dtmfEntry = null;
      }
-      else {
-        this.logger.info('got empty intent, restarting');
-        ep.api(this.cmd, this._buildStartArgs());
+      else if (this.greetingPlayed) {
+        this.logger.info('starting another intent');
+        ep.api('dialogflow_start', `${ep.uuid} ${this.project} ${this.lang}`);
+      }
+      else {
+        this.logger.info('got empty intent');
+        ep.api('dialogflow_start', `${ep.uuid} ${this.project} ${this.lang}`);
      }
-      return;
-    }
-
-    // For CX: suppress NO_INPUT "I didn't get that" audio and silently restart
-    if (this.isCX && intent.isNoInput && this.greetingPlayed) {
-      this.logger.info('CX returned NO_INPUT after greeting, suppressing and restarting');
-      this._suppressNextCXAudio = true;
      return;
    }

@@ -269,10 +193,14 @@ class Dialogflow extends Task {
      this._performHook(cs, this.eventHook, {event: 'intent', data: evt});
    }

+    // clear the no-input timer and the digit buffer
    this._clearNoinputTimer();
    if (this.digitBuffer) this.digitBuffer.flush();

+    /* hang up (or tranfer call) after playing next audio file? */
    if (intent.saysEndInteraction) {
+      //  if 'end_interaction' is true, end the dialog after playing the final prompt
+      //  (or in 1 second if there is no final prompt)
      this.hangupAfterPlayDone = true;
      this.waitingForPlayStart = true;
      setTimeout(() => {
@@ -283,6 +211,8 @@ class Dialogflow extends Task {
        }
      }, 1000);
    }
+
+    /* collect digits? */
    else if (intent.saysCollectDtmf || this.enableDtmfAlways) {
      const opts = Object.assign({
        idt: this.opts.interDigitTimeout
@@ -291,44 +221,68 @@ class Dialogflow extends Task {
      this.digitBuffer.once('fulfilled', this._onDtmfEntryComplete.bind(this, ep));
    }

-    // If we have a TTS vendor and fulfillment text, synthesize and play
+    /* if we are using tts and a message was provided, play it out */
    if (this.vendor && intent.fulfillmentText && intent.fulfillmentText.length > 0) {
+      const {srf} = cs;
+      const {stats} = srf.locals;
+      const {synthAudio} = srf.locals.dbHelpers;
      this.waitingForPlayStart = false;

-      // ES: start a new intent during playback so we continue to listen
-      if (!this.hangupAfterPlayDone && this.isES) {
-        ep.api(this.cmd, this._buildStartArgs());
+      // start a new intent, (we want to continue to listen during the audio playback)
+      // _unless_ we are transferring or ending the session
+      if (!this.hangupAfterPlayDone) {
+        ep.api('dialogflow_start', `${ep.uuid} ${this.project} ${this.lang}`);
      }

      try {
-        const {srf} = cs;
-        const {stats} = srf.locals;
-        const {synthAudio} = srf.locals.dbHelpers;
        const {filePath} = await this._fallbackSynthAudio(cs, intent, stats, synthAudio);
        if (filePath) cs.trackTmpFile(filePath);
-        await this._playAndHandlePostPlay(ep, cs, filePath);
+
+        if (this.playInProgress) {
+          await ep.api('uuid_break', ep.uuid).catch((err) => this.logger.info(err, 'Error killing audio'));
+        }
+        this.playInProgress = true;
+        this.curentAudioFile = filePath;
+
+        this.logger.debug(`starting to play tts ${filePath}`);
+
+        if (this.events.includes('start-play')) {
+          this._performHook(cs, this.eventHook, {event: 'start-play', data: {path: filePath}});
+        }
+        await ep.play(filePath);
+        if (this.events.includes('stop-play')) {
+          this._performHook(cs, this.eventHook, {event: 'stop-play', data: {path: filePath}});
+        }
+        this.logger.debug(`finished ${filePath}`);
+
+        if (this.curentAudioFile === filePath) {
+          this.playInProgress = false;
+          if (this.queuedTasks) {
+            this.logger.debug('finished playing audio and we have queued tasks');
+            this._redirect(cs, this.queuedTasks);
+            return;
+          }
+        }
+        this.greetingPlayed = true;
+
+        if (this.hangupAfterPlayDone) {
+          this.logger.info('hanging up since intent was marked end interaction and we completed final prompt');
+          this.performAction({dialogflowResult: 'completed'});
+          this.notifyTaskDone();
+        }
+        else {
+          // every time we finish playing a prompt, start the no-input timer
+          this._startNoinputTimer(ep, cs);
+        }
      } catch (err) {
        this.logger.error({err}, 'Dialogflow:_onIntent - error playing tts');
      }
    }
-    else if (this.isCX && !this.hangupAfterPlayDone) {
-      // CX intent with no TTS — _onAudioProvided may handle playback.
-      // If not, restart CX after a short delay.
-      this.greetingPlayed = true;
-      this._cxAudioHandled = false;
-      setTimeout(() => {
-        if (!this._cxAudioHandled && !this.playInProgress) {
-          this.logger.info('CX: no TTS and no audio provided, restarting to listen');
-          ep.api(this.cmd, this._buildStartArgs());
-          this._startNoinputTimer(ep, cs);
-        }
-      }, 500);
-    }
  }

  async _fallbackSynthAudio(cs, intent, stats, synthAudio) {
    try {
-      return await synthAudio(stats, {
+      const obj = {
        account_sid: cs.accountSid,
        text: intent.fulfillmentText,
        vendor: this.vendor,
@@ -336,13 +290,17 @@ class Dialogflow extends Task {
        voice: this.voice,
        salt: cs.callSid,
        credentials: this.ttsCredentials
-      });
+      };
+      this.logger.debug({obj}, 'Dialogflow:_onIntent - playing message via tts');
+
+      return await synthAudio(stats, obj);
    } catch (error) {
      this.logger.info({error}, 'Failed to synthesize audio from primary vendor');
-      if (this.fallbackVendor) {
-        try {
+
+      try {
+        if (this.fallbackVendor) {
          const credentials = cs.getSpeechCredentials(this.fallbackVendor, 'tts', this.fallbackLabel);
-          return await synthAudio(stats, {
+          const obj = {
            account_sid: cs.accountSid,
            text: intent.fulfillmentText,
            vendor: this.fallbackVendor,
@@ -350,20 +308,24 @@ class Dialogflow extends Task {
            voice: this.fallbackVoice,
            salt: cs.callSid,
            credentials
-          });
-        } catch (err) {
-          this.logger.info({err}, 'Failed to synthesize audio from fallback vendor');
-          throw err;
+          };
+          this.logger.debug({obj}, 'Dialogflow:_onIntent - playing message via fallback tts');
+          return await synthAudio(stats, obj);
        }
+      } catch (err) {
+        this.logger.info({err}, 'Failed to synthesize audio from falllback vendor');
+        throw err;
      }
      throw error;
    }
  }

  /**
-   * A transcription has been returned.
-   * @param {*} ep -  media server endpoint
-   * @param {*} cs - call session
+   * A transcription - either interim or final - has been returned.
+   * If we are doing barge-in based on hotword detection, check for the hotword or phrase.
+   * If we are playing a filler sound, like typing, during the fullfillment phase, start that
+   * if this is a final transcript.
+   * @param {*} ep  -  media server endpoint
   * @param {*} evt - event data
   */
  async _onTranscription(ep, cs, evt) {
@@ -376,11 +338,13 @@ class Dialogflow extends Task {
      this._performHook(cs, this.eventHook, {event: 'transcription', data: evt});
    }

+    // if a final transcription, start a typing sound
    if (this.thinkingMusic && !transcription.isEmpty && transcription.isFinal &&
      transcription.confidence > 0.8) {
      ep.play(this.data.thinkingMusic).catch((err) => this.logger.info(err, 'Error playing typing sound'));
    }

+    // interrupt playback on speaking if bargein = true
    if (this.bargein && this.playInProgress) {
      this.logger.debug('terminating playback due to speech bargein');
      this.playInProgress = false;
@@ -389,21 +353,17 @@ class Dialogflow extends Task {
  }

  /**
-   * The caller has just finished speaking.
-   * @param {*} ep -  media server endpoint
-   * @param {*} cs - call session
+   * The caller has just finished speaking.  No action currently taken.
   * @param {*} evt - event data
   */
-  _onEndOfUtterance(ep, cs, evt) {
+  _onEndOfUtterance(cs, evt) {
    if (this.events.includes('end-utterance')) {
      this._performHook(cs, this.eventHook, {event: 'end-utterance'});
    }
  }

  /**
-   * Dialogflow has returned an error.
-   * @param {*} ep -  media server endpoint
-   * @param {*} cs - call session
+   * Dialogflow has returned an error of some kind.
   * @param {*} evt - event data
   */
  _onError(ep, cs, evt) {
@@ -412,87 +372,70 @@ class Dialogflow extends Task {

  /**
   * Audio has been received from dialogflow and written to a temporary disk file.
-   * Play the audio, then restart or hang up as appropriate.
+   * Start playing the audio, after killing any filler sound that might be playing.
+   * When the audio completes, start the no-input timer.
   * @param {*} ep -  media server endpoint
-   * @param {*} cs - call session
   * @param {*} evt - event data
   */
  async _onAudioProvided(ep, cs, evt) {
-    // For CX: suppress NO_INPUT reprompt audio and silently restart
-    if (this._suppressNextCXAudio) {
-      this._suppressNextCXAudio = false;
-      ep.api(this.cmd, this._buildStartArgs());
-      return;
-    }

-    if (this.vendor) {
-      if (this.isCX && !this.playInProgress) {
-        // CX audio arrived but TTS didn't play — fall through to use CX audio
-        this.logger.info('CX audio provided, TTS vendor did not play - using CX audio');
-      } else {
-        return;
-      }
-    }
+    if (this.vendor) return;

-    this._cxAudioHandled = true;
    this.waitingForPlayStart = false;

+    // kill filler audio
    await ep.api('uuid_break', ep.uuid);

-    // ES: start a new intent during playback so we continue to listen
-    if (!this.hangupAfterPlayDone && this.isES) {
-      ep.api(this.cmd, this._buildStartArgs());
+    // start a new intent, (we want to continue to listen during the audio playback)
+    // _unless_ we are transferring or ending the session
+    if (/*this.greetingPlayed &&*/ !this.hangupAfterPlayDone) {
+      ep.api('dialogflow_start', `${ep.uuid} ${this.project} ${this.lang}`);
    }

-    await this._playAndHandlePostPlay(ep, cs, evt.path);
-  }
-
-  /**
-   * Shared post-play logic for both TTS (_onIntent) and CX audio (_onAudioProvided).
-   * Plays audio, then either hangs up, redirects, or restarts the dialog.
-   */
-  async _playAndHandlePostPlay(ep, cs, filePath) {
-    if (this.playInProgress) {
-      await ep.api('uuid_break', ep.uuid).catch((err) => this.logger.info(err, 'Error killing audio'));
-    }
    this.playInProgress = true;
-    this.curentAudioFile = filePath;
+    this.curentAudioFile = evt.path;

+    this.logger.info(`starting to play ${evt.path}`);
    if (this.events.includes('start-play')) {
-      this._performHook(cs, this.eventHook, {event: 'start-play', data: {path: filePath}});
+      this._performHook(cs, this.eventHook, {event: 'start-play', data: {path: evt.path}});
    }
-    await ep.play(filePath);
+    await ep.play(evt.path);
    if (this.events.includes('stop-play')) {
-      this._performHook(cs, this.eventHook, {event: 'stop-play', data: {path: filePath}});
+      this._performHook(cs, this.eventHook, {event: 'stop-play', data: {path: evt.path}});
    }
+    this.logger.info(`finished ${evt.path}, queued tasks: ${(this.queuedTasks || []).length}`);

-    if (this.curentAudioFile === filePath) {
+    if (this.curentAudioFile === evt.path) {
      this.playInProgress = false;
      if (this.queuedTasks) {
+        this.logger.debug('finished playing audio and we have queued tasks');
        this._redirect(cs, this.queuedTasks);
-        this.queuedTasks = null;
+        this.queuedTasks.length = 0;
        return;
      }
    }
-
+    /*
+    if (!this.inbound && !this.greetingPlayed) {
+      this.logger.info('finished greeting on outbound call, starting new intent');
+      this.ep.api('dialogflow_start', `${ep.uuid} ${this.project} ${this.lang}`);
+    }
+    */
    this.greetingPlayed = true;

    if (this.hangupAfterPlayDone) {
-      this.logger.info('hanging up after end interaction prompt');
+      this.logger.info('hanging up since intent was marked end interaction and we completed final prompt');
      this.performAction({dialogflowResult: 'completed'});
      this.notifyTaskDone();
    }
    else {
-      // CX: restart to listen for the next utterance
-      if (this.isCX) {
-        ep.api(this.cmd, this._buildStartArgs());
-      }
+      // every time we finish playing a prompt, start the no-input timer
      this._startNoinputTimer(ep, cs);
    }
  }

  /**
-   * Receive a DTMF entry from the caller.
+   * receive a dmtf entry from the caller.
+   * If we have active dtmf instructions, collect and process accordingly.
   */
  _onDtmf(ep, cs, evt) {
    if (this.digitBuffer) this.digitBuffer.process(evt.dtmf);
@@ -501,48 +444,41 @@ class Dialogflow extends Task {
    }
  }

-  async _onDtmfEntryComplete(ep, dtmfEntry) {
+  _onDtmfEntryComplete(ep, dtmfEntry) {
    this.logger.info(`collected dtmf entry: ${dtmfEntry}`);
+    this.dtmfEntry = dtmfEntry;
    this.digitBuffer = null;
+    // if a final transcription, start a typing sound
    if (this.thinkingMusic) {
      ep.play(this.thinkingMusic).catch((err) => this.logger.info(err, 'Error playing typing sound'));
    }

-    if (this.isCX) {
-      try {
-        await ep.api(this.cmdStop, ep.uuid);
-      } catch (err) {
-        this.logger.info(err, 'dialogflow_cx_stop failed');
-      }
-      ep.api(this.cmd, this._buildStartArgs({text: dtmfEntry}));
-    } else {
-      this.dtmfEntry = dtmfEntry;
-      ep.api(this.cmdStop, `${ep.uuid}`)
-        .catch((err) => this.logger.info(`dialogflow_stop failed: ${err.message}`));
-    }
+    // kill the current dialogflow, which will result in us getting an immediate intent
+    ep.api('dialogflow_stop', `${ep.uuid}`)
+      .catch((err) => this.logger.info(`dialogflow_stop failed: ${err.message}`));
  }

-  async _onNoInput(ep, cs) {
-    this.logger.info('no-input timer fired');
+  /**
+   * The user has not provided any input for some time.
+   * Set the 'noinput' member to true and kill the current dialogflow.
+   * This will result in us re-prompting with an event indicating no input.
+   * @param {*} ep
+   */
+  _onNoInput(ep, cs) {
+    this.noinput = true;

    if (this.events.includes('no-input')) {
-      this._performHook(cs, this.eventHook, {event: 'no-input'});
+      this._performHook(cs, this.eventHook,  {event: 'no-input'});
    }

-    if (this.isCX) {
-      try {
-        await ep.api(this.cmdStop, ep.uuid);
-      } catch (err) {
-        this.logger.info(err, 'dialogflow_cx_stop failed');
-      }
-      ep.api(this.cmd, this._buildStartArgs({event: this.noInputEvent}));
-    } else {
-      this.noinput = true;
-      ep.api(this.cmdStop, `${ep.uuid}`)
-        .catch((err) => this.logger.info(`dialogflow_stop failed: ${err.message}`));
-    }
+    // kill the current dialogflow, which will result in us getting an immediate intent
+    ep.api('dialogflow_stop', `${ep.uuid}`)
+      .catch((err) => this.logger.info(`dialogflow_stop failed: ${err.message}`));
  }

+  /**
+   * Stop the no-input timer, if it is running
+   */
  _clearNoinputTimer() {
    if (this.noinputTimer) {
      clearTimeout(this.noinputTimer);
@@ -550,6 +486,10 @@ class Dialogflow extends Task {
    }
  }

+  /**
+   * Start the no-input timer.  The duration is set in the configuration file.
+   * @param {*} ep
+   */
  _startNoinputTimer(ep, cs) {
    if (!this.noInputTimeout) return;
    this._clearNoinputTimer();
@@ -567,7 +507,7 @@ class Dialogflow extends Task {
      if (tasks && tasks.length > 0) {
        if (this.playInProgress) {
          this.queuedTasks = tasks;
-          this.logger.info({tasks},
+          this.logger.info({tasks: tasks},
            `${this.name} replacing application with ${tasks.length} tasks after play completes`);
          return;
        }
@@ -577,7 +517,7 @@ class Dialogflow extends Task {
  }

  _redirect(cs, tasks) {
-    this.logger.info({tasks}, `${this.name} replacing application with ${tasks.length} tasks`);
+    this.logger.info({tasks: tasks}, `${this.name} replacing application with ${tasks.length} tasks`);
    this.performAction({dialogflowResult: 'redirect'}, false);
    this.reportedFinalAction = true;
    cs.replaceApplication(tasks);
--- a/lib/tasks/dialogflow/intent.js
+++ b/lib/tasks/dialogflow/intent.js
@@ -3,44 +3,20 @@ class Intent {
    this.logger = logger;
    this.evt = evt;

-    this.qr = this.isCX ? evt.detect_intent_response.query_result : evt.query_result;
-    this.dtmfRequest = this._checkIntentForDtmfEntry();
-  }
-
-  get response_id() {
-    return this.isCX ? this.evt.detect_intent_response.response_id : this.evt.response_id;
+    this.logger.debug({evt}, 'intent');
+    this.dtmfRequest = checkIntentForDtmfEntry(logger, evt);
  }

  get isEmpty() {
-    return !(this.response_id?.length > 0);
+    return this.evt.response_id.length === 0;
  }

  get fulfillmentText() {
-    if (this.isCX) {
-      if (this.qr && this.qr.response_messages) {
-        for (const msg of this.qr.response_messages) {
-          if (msg.text && msg.text.text && msg.text.text.length > 0) {
-            return msg.text.text.join('\n');
-          }
-          if (msg.output_audio_text) {
-            if (msg.output_audio_text.text) return msg.output_audio_text.text;
-            if (msg.output_audio_text.ssml) return msg.output_audio_text.ssml;
-          }
-        }
-      }
-      return undefined;
-    }
-    return this.qr.fulfillment_text;
+    return this.evt.query_result.fulfillment_text;
  }

  get saysEndInteraction() {
-    if (this.isCX) {
-      if (!this.qr || !this.qr.response_messages) return false;
-      const end_interaction = this.qr.response_messages
-        .find((m) => typeof m === 'object' && 'end_interaction' in m)?.end_interaction;
-      return end_interaction && Object.keys(end_interaction).length > 0;
-    }
-    return this.qr.intent.end_interaction;
+    return this.evt.query_result.intent.end_interaction ;
  }

  get saysCollectDtmf() {
@@ -52,23 +28,7 @@ class Intent {
  }

  get name() {
-    if (!this.isEmpty) {
-      if (this.isCX) {
-        return this.qr.match?.intent?.display_name;
-      }
-      return this.qr.intent.display_name;
-    }
-  }
-
-  get isCX() {
-    return typeof this.evt.detect_intent_response === 'object';
-  }
-
-  get isNoInput() {
-    if (this.isCX && this.qr && this.qr.match) {
-      return this.qr.match.match_type === 'NO_INPUT';
-    }
-    return false;
+    if (!this.isEmpty) return this.evt.query_result.intent.display_name;
  }

  toJSON() {
@@ -78,48 +38,52 @@ class Intent {
    };
  }

-  /**
-   * Parse a returned intent for DTMF entry information (ES only).
-   * CX does not use fulfillment_messages or output_contexts.
-   *
-   * allow-dtmf-x-y-z
-   * x = min number of digits
-   * y = optional, max number of digits
-   * z = optional, terminating character
-   */
-  _checkIntentForDtmfEntry() {
-    if (this.isCX) return;
-
-    const qr = this.qr;
-    if (!qr || !qr.fulfillment_messages || !qr.output_contexts) {
-      return;
-    }
-
-    // check for custom payloads with a gather verb
-    const custom = qr.fulfillment_messages.find((f) => f.payload && f.payload.verb === 'gather');
-    if (custom) {
-      this.logger.info({custom}, 'found dtmf custom payload');
-      return {
-        max: custom.payload.numDigits,
-        term: custom.payload.finishOnKey,
-        template: custom.payload.responseTemplate
-      };
-    }
-
-    // check for an output context with a specific naming convention
-    const context = qr.output_contexts.find((oc) => oc.name.includes('/contexts/allow-dtmf-'));
-    if (context) {
-      const arr = /allow-dtmf-(\d+)(?:-(\d+))?(?:-(.*))?/.exec(context.name);
-      if (arr) {
-        this.logger.info('found dtmf output context');
-        return {
-          min: parseInt(arr[1]),
-          max: arr.length > 2 ? parseInt(arr[2]) : null,
-          term: arr.length > 3 ? arr[3] : null
-        };
-      }
-    }
-  }
 }

 module.exports = Intent;
+
+/**
+ * Parse a returned intent for DTMF entry information
+ * i.e.
+ * allow-dtmf-x-y-z
+ * x = min number of digits
+ * y = optional, max number of digits
+ * z = optional, terminating character
+ * e.g.
+ * allow-dtmf-5 :     collect 5 digits
+ * allow-dtmf-1-4 :   collect between 1 to 4 (inclusive) digits
+ * allow-dtmf-1-4-# : collect 1-4 digits, terminating if '#' is entered
+ * @param {*} intent - dialogflow intent
+ */
+const checkIntentForDtmfEntry = (logger, intent) => {
+  const qr = intent.query_result;
+  if (!qr || !qr.fulfillment_messages || !qr.output_contexts) {
+    logger.info({f: qr.fulfillment_messages, o: qr.output_contexts}, 'no dtmfs');
+    return;
+  }
+
+  // check for custom payloads with a gather verb
+  const custom = qr.fulfillment_messages.find((f) => f.payload && f.payload.verb === 'gather');
+  if (custom && custom.payload && custom.payload.verb === 'gather') {
+    logger.info({custom}, 'found dtmf custom payload');
+    return {
+      max: custom.payload.numDigits,
+      term: custom.payload.finishOnKey,
+      template: custom.payload.responseTemplate
+    };
+  }
+
+  // check for an output context with a specific naming convention
+  const context = qr.output_contexts.find((oc) => oc.name.includes('/contexts/allow-dtmf-'));
+  if (context) {
+    const arr = /allow-dtmf-(\d+)(?:-(\d+))?(?:-(.*))?/.exec(context.name);
+    if (arr) {
+      logger.info({custom}, 'found dtmf output context');
+      return {
+        min: parseInt(arr[1]),
+        max: arr.length > 2 ? parseInt(arr[2]) : null,
+        term: arr.length > 3 ? arr[3] : null
+      };
+    }
+  }
+};
--- a/lib/tasks/gather.js
+++ b/lib/tasks/gather.js
@@ -5,14 +5,12 @@ const {
  AwsTranscriptionEvents,
  AzureTranscriptionEvents,
  DeepgramTranscriptionEvents,
-  GladiaTranscriptionEvents,
  SonioxTranscriptionEvents,
  CobaltTranscriptionEvents,
  IbmTranscriptionEvents,
  NvidiaTranscriptionEvents,
  JambonzTranscriptionEvents,
  AssemblyAiTranscriptionEvents,
-  HoundifyTranscriptionEvents,
  DeepgramfluxTranscriptionEvents,
  VoxistTranscriptionEvents,
  CartesiaTranscriptionEvents,
@@ -95,8 +93,6 @@ class TaskGather extends SttTask {

  get needsStt() { return this.input.includes('speech'); }

-  get isBackgroundGather() { return this.bugname_prefix === 'background_bargeIn_'; }
-
  get wantsSingleUtterance() {
    return this.data.recognizer?.singleUtterance === true;
  }
@@ -231,9 +227,7 @@ class TaskGather extends SttTask {

    const startListening = async(cs, ep) => {
      this._startTimer();
-      if (this.isContinuousAsr && 0 === this.timeout && !this.isBackgroundGather) {
-        this._startAsrTimer();
-      }
+      if (this.isContinuousAsr && 0 === this.timeout) this._startAsrTimer();
      if (this.input.includes('speech') && !this.listenDuringPrompt) {
        try {
          await this._setSpeechHandlers(cs, ep);
@@ -258,7 +252,7 @@ class TaskGather extends SttTask {
            startDtmfListener();
          }
          this._stopVad();
-          if (!this.killed && !this.resolved) {
+          if (!this.killed) {
            startListening(cs, ep);
            if (this.input.includes('speech') && this.vendor === 'nuance' && this.listenDuringPrompt) {
              this.logger.debug('Gather:exec - starting transcription timers after say completes');
@@ -270,21 +264,19 @@ class TaskGather extends SttTask {
        };
        this.sayTask.span = span;
        this.sayTask.ctx = ctx;
-        this.sayTask
-          .exec(cs, {ep})  // kicked off, _not_ waiting for it to complete
-          .then(() => {
-            if (this.sayTask.isStreamingTts) return;
-            this.logger.debug('Gather:exec - nested say task completed');
-            span.end();
-            process();
-            return;
-          })
+        this.sayTask.exec(cs, {ep})  // kicked off, _not_ waiting for it to complete
          .catch((err) => {
            process();
          });
        if (this.sayTask.isStreamingTts && !this.sayTask.closeOnStreamEmpty) {
          // if streaming tts, we do not wait for it to complete if it is not closing the stream automatically
          process();
+        } else {
+          this.sayTask.on('playDone', (err) => {
+            span.end();
+            if (err) this.logger.error({err}, 'Gather:exec Error playing tts');
+            process();
+          });
        }
      }
      else if (this.playTask) {
@@ -296,7 +288,7 @@ class TaskGather extends SttTask {
            startDtmfListener();
          }
          this._stopVad();
-          if (!this.killed && !this.resolved) {
+          if (!this.killed) {
            startListening(cs, ep);
            if (this.input.includes('speech') && this.vendor === 'nuance' && this.listenDuringPrompt) {
              this.logger.debug('Gather:exec - starting transcription timers after play completes');
@@ -308,17 +300,15 @@ class TaskGather extends SttTask {
        };
        this.playTask.span = span;
        this.playTask.ctx = ctx;
-        this.playTask
-          .exec(cs, {ep})  // kicked off, _not_ waiting for it to complete
-          .then(() => {
-            this.logger.debug('Gather:exec - nested play task completed');
-            span.end();
-            process();
-            return;
-          })
+        this.playTask.exec(cs, {ep})  // kicked off, _not_ waiting for it to complete
          .catch((err) => {
            process();
          });
+        this.playTask.on('playDone', (err) => {
+          span.end();
+          if (err) this.logger.error({err}, 'Gather:exec Error playing url');
+          process();
+        });
      }
      else {
        if (this.killed) {
@@ -492,20 +482,6 @@ class TaskGather extends SttTask {
        this.addCustomEventListener(ep, DeepgramfluxTranscriptionEvents.Error, this._onVendorError.bind(this, cs, ep));
        break;

-      case 'gladia':
-        this.bugname = `${this.bugname_prefix}gladia_transcribe`;
-        this.addCustomEventListener(
-          ep, GladiaTranscriptionEvents.Transcription, this._onTranscription.bind(this, cs, ep));
-        this.addCustomEventListener(ep, GladiaTranscriptionEvents.Connect, this._onVendorConnect.bind(this, cs, ep));
-        this.addCustomEventListener(ep, GladiaTranscriptionEvents.ConnectFailure,
-          this._onVendorConnectFailure.bind(this, cs, ep));
-        this.addCustomEventListener(ep, GladiaTranscriptionEvents.Error, this._onVendorError.bind(this, cs, ep));
-        // gladia require unique url for each session
-        const {host, path} = await this.createGladiaLiveSession();
-        opts.GLADIA_SPEECH_HOST = host;
-        opts.GLADIA_SPEECH_PATH = path;
-        break;
-
      case 'soniox':
        this.bugname = `${this.bugname_prefix}soniox_transcribe`;
        this.addCustomEventListener(
@@ -583,18 +559,6 @@ class TaskGather extends SttTask {
          this._onVendorConnectFailure.bind(this, cs, ep));
        break;

-      case 'houndify':
-        this.bugname = `${this.bugname_prefix}houndify_transcribe`;
-        this.addCustomEventListener(ep, HoundifyTranscriptionEvents.Transcription,
-          this._onTranscription.bind(this, cs, ep));
-        this.addCustomEventListener(ep, HoundifyTranscriptionEvents.Error,
-          this._onVendorError.bind(this, cs, ep));
-        this.addCustomEventListener(ep, HoundifyTranscriptionEvents.ConnectFailure,
-          this._onVendorConnectFailure.bind(this, cs, ep));
-        this.addCustomEventListener(ep, HoundifyTranscriptionEvents.Connect,
-          this._onVendorConnect.bind(this, cs, ep));
-        break;
-
      case 'voxist':
        this.bugname = `${this.bugname_prefix}voxist_transcribe`;
        this.addCustomEventListener(ep, VoxistTranscriptionEvents.Transcription,
@@ -885,15 +849,17 @@ 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'));
-        if (cs.isTtsStreamEnabled) cs.clearTtsStream();
+        cs.clearTtsStream();
      }
      return;
    }
    if (this.sayTask && !this.sayTask.killed) {
+      this.sayTask.removeAllListeners('playDone');
      this.sayTask.kill(cs);
      this.sayTask = null;
    }
    if (this.playTask && !this.playTask.killed) {
+      this.playTask.removeAllListeners('playDone');
      this.playTask.kill(cs);
      this.playTask = null;
    }
@@ -1165,7 +1131,7 @@ class TaskGather extends SttTask {
  }

  async _startFallback(cs, ep, evt) {
-    if (this.canFallback()) {
+    if (this.canFallback) {
      this._stopTranscribing(ep);
      try {
        this.logger.debug('gather:_startFallback');
@@ -1322,8 +1288,6 @@ class TaskGather extends SttTask {
    }

    this.resolved = true;
-    // gather is resolved, prevent any further transcription events while resolve in progress
-    this.removeCustomEventListeners();
    // If bargin is false and ws application return ack to verb:hook
    // the gather should not play any audio
    this._killAudio(this.cs);
@@ -1424,26 +1388,7 @@ class TaskGather extends SttTask {
          returnedVerbs = await this.performAction({speech:evt, reason: 'stt-low-confidence', ...latencies});
        }
      }
-    } catch (err) {
-      this.logger.info({err}, 'TaskGather:_resolve - error performing action');
-      this.notifyError({msg: 'invalid actionHook response', details: err.message});
-      const {writeAlerts, AlertType} = this.cs.srf.locals;
-      writeAlerts({
-        account_sid: this.cs.accountSid,
-        alert_type: AlertType.INVALID_APP_PAYLOAD,
-        target_sid: this.cs.callSid,
-        message: `actionHook returned invalid verb syntax: ${err.message}`
-      }).catch((err) => this.logger.info({err}, 'TaskGather:_resolve - error generating alert'));
-      try {
-        const obj = Object.assign({}, this.cs.callInfo.toJSON(), {
-          error: 'invalid actionHook response',
-          reason: err.message
-        });
-        await this.cs.notifier.request('call:status', this.cs.call_status_hook, obj);
-      } catch (statusErr) {
-        this.logger.info({statusErr}, 'TaskGather:_resolve - error sending statusHook');
-      }
-    }
+    } catch (err) {  /*already logged error*/ }

    // Gather got response from hook, cancel actionHookDelay processing
    if (this.cs.actionHookDelayProcessor) {
--- a/lib/tasks/listen.js
+++ b/lib/tasks/listen.js
@@ -5,17 +5,6 @@ const moment = require('moment');
 const MAX_PLAY_AUDIO_QUEUE_SIZE = 10;
 const DTMF_SPAN_NAME = 'dtmf';

-function escapeString(str) {
-  return str
-    .replace(/\\/g, '\\\\')   // Escape backslashes
-    .replace(/"/g, '\\"')     // Escape double quotes
-    .replace(/[\b]/g, '\\b')  // Escape backspace (NOTE: [\b] not \b)
-    .replace(/\f/g, '\\f')    // Escape formfeed
-    .replace(/\n/g, '\\n')    // Escape newlines
-    .replace(/\r/g, '\\r')    // Escape carriage returns
-    .replace(/\t/g, '\\t');   // Escape tabs
-}
-
 class TaskListen extends Task {
  constructor(logger, opts, parentTask) {
    super(logger, opts);
@@ -27,21 +16,10 @@ class TaskListen extends Task {
    this.preconditions = TaskPreconditions.Endpoint;

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

-    //Escape JSON special characters in metadata
-    if (this.data.metadata) {
-      this.metadata = {};
-      for (const key in this.data.metadata) {
-        if (this.data.metadata.hasOwnProperty(key)) {
-          const value = this.data.metadata[key];
-          this.metadata[key] = typeof value === 'string' ? escapeString(value) : value;
-        }
-      }
-    }
-
    this.mixType = this.mixType || 'mono';
    this.sampleRate = this.sampleRate || 8000;
    this.earlyMedia = this.data.earlyMedia === true;
@@ -152,17 +130,9 @@ class TaskListen extends Task {

  async _startListening(cs, ep) {
    this._initListeners(ep);
-    const tempci = this.nested ? this.parentTask.sd.callInfo : cs.callInfo.toJSON();
-    const ci = structuredClone(tempci);
+    const ci = this.nested ? this.parentTask.sd.callInfo : cs.callInfo.toJSON();
    if (this._ignoreCustomerData) {
      delete ci.customerData;
-    } else {
-      for (const key in ci.customerData) {
-        if (ci.customerData.hasOwnProperty(key)) {
-          const value = ci.customerData[key];
-          ci.customerData[key] = typeof value === 'string' ? escapeString(value) : value;
-        }
-      }
    }
    const metadata = Object.assign(
      {sampleRate: this.sampleRate, mixType: this.mixType},
--- a/lib/tasks/llm/llms/google_s2s.js
+++ b/lib/tasks/llm/llms/google_s2s.js
@@ -36,9 +36,6 @@ class TaskLlmGoogle_S2S extends Task {
    this.model = this.parent.model || 'models/gemini-2.0-flash-live-001';
    this.auth = this.parent.auth;
    this.connectionOptions = this.parent.connectOptions;
-    const {host, version} = this.connectionOptions || {};
-    this.host = host;
-    this.version = version;

    const {apiKey} = this.auth || {};
    if (!apiKey) throw new Error('auth.apiKey is required for Google S2S');
@@ -49,7 +46,7 @@ class TaskLlmGoogle_S2S extends Task {
    this.eventHook = this.data.eventHook;
    this.toolHook = this.data.toolHook;

-    const {setup, sessionResumption} = this.data.llmOptions;
+    const {setup} = this.data.llmOptions;

    if (typeof setup !== 'object') {
      throw new Error('llmOptions with an initial setup is required for Google S2S');
@@ -57,7 +54,6 @@ class TaskLlmGoogle_S2S extends Task {
    this.setup = {
      ...setup,
      model: this.model,
-      ...(sessionResumption && {sessionResumption}),
      // make sure output is always audio
      generationConfig: {
        ...(setup.generationConfig || {}),
@@ -142,10 +138,6 @@ class TaskLlmGoogle_S2S extends Task {

    try {
      const args = [ep.uuid, 'session.create', this.apiKey];
-      if (this.host) {
-        args.push(this.host);
-        if (this.version) args.push(this.version);
-      }
      await this._api(ep, args);
    } catch (err) {
      this.logger.error({err}, 'TaskLlmGoogle_S2S:_startListening');
--- a/lib/tasks/llm/llms/ultravox_s2s.js
+++ b/lib/tasks/llm/llms/ultravox_s2s.js
@@ -146,9 +146,8 @@ class TaskLlmUltravox_S2S extends Task {
    return data;
  }

-  _unregisterHandlers(ep) {
+  _unregisterHandlers() {
    this.removeCustomEventListeners();
-    ep.removeAllListeners('dtmf');
  }

  _registerHandlers(ep) {
@@ -156,7 +155,6 @@ class TaskLlmUltravox_S2S extends Task {
    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));
-    ep.on('dtmf', this._onDtmf.bind(this, ep));
  }

  async _startListening(cs, ep) {
@@ -191,7 +189,7 @@ class TaskLlmUltravox_S2S extends Task {
    /* note: the parent llm verb started the span, which is why this is necessary */
    await this.parent.performAction(this.results);

-    this._unregisterHandlers(ep);
+    this._unregisterHandlers();
  }

  async kill(cs) {
@@ -348,18 +346,6 @@ class TaskLlmUltravox_S2S extends Task {
      excludeEvents: this.excludeEvents
    }, 'TaskLlmUltravox_S2S:_populateEvents');
  }
-
-  _onDtmf(ep, evt) {
-    this.logger.info({evt}, 'TaskLlmUltravox_S2S:_onDtmf - DTMF received');
-    const {dtmf} = evt;
-    const data = {
-      type: 'user_text_message',
-      text: `DTMF received: ${dtmf}`,
-      urgency: 'immediate'
-    };
-    this._api(ep, [ep.uuid, ClientEvent, JSON.stringify(data)])
-      .catch((err) => this.logger.info({err, evt}, 'TaskLlmUltravox_S2S:_onDtmf - Error sending DTMF as text message'));
-  }
 }

 module.exports = TaskLlmUltravox_S2S;
--- a/lib/tasks/play.js
+++ b/lib/tasks/play.js
@@ -6,21 +6,9 @@ class TaskPlay extends Task {
    super(logger, opts);
    this.preconditions = TaskPreconditions.Endpoint;

-    //Cleanup URLs that contain a querystring with a . unless that querystring is the filename
-    // see https://github.com/jambonz/jambonz-feature-server/pull/1293
-    // and https://github.com/jambonz/jambonz-feature-server/issues/1394 for background
-    if (this.data.url.includes('?')) {
-      if (['.mp3', '.wav'].includes(this.data.url.slice(-4))) {
-        this.url = this.data.url;
-      }
-      else {
-        this.url =  this.data.url.split('?')[0] + '?' + this.data.url.split('?')[1].replaceAll('.', '%2E');
-      }
-    }
-    else {
-      this.url = this.data.url;
-    }
-
+    this.url = this.data.url.includes('?')
+      ? this.data.url.split('?')[0] + '?' + this.data.url.split('?')[1].replaceAll('.', '%2E')
+      : this.data.url;
    this.seekOffset = this.data.seekOffset || -1;
    this.timeoutSecs = this.data.timeoutSecs || -1;
    this.loop = this.data.loop || 1;
--- a/lib/tasks/redirect.js
+++ b/lib/tasks/redirect.js
@@ -1,6 +1,7 @@
 const Task = require('./task');
 const {TaskName} = require('../utils/constants');
 const WsRequestor = require('../utils/ws-requestor');
+const URL = require('url');
 const HttpRequestor = require('../utils/http-requestor');

 /**
@@ -9,7 +10,6 @@ const HttpRequestor = require('../utils/http-requestor');
 class TaskRedirect extends Task {
  constructor(logger, opts) {
    super(logger, opts);
-    this.statusHook = opts.statusHook || false;
  }

  get name() { return TaskName.Redirect; }
@@ -33,7 +33,7 @@ class TaskRedirect extends Task {
      }
      else {
        const baseUrl =  this.cs.application.requestor.baseUrl;
-        const newUrl = new URL(this.actionHook);
+        const newUrl = URL.parse(this.actionHook);
        const newBaseUrl = newUrl.protocol + '//' + newUrl.host;
        if (baseUrl != newBaseUrl) {
          try {
@@ -47,30 +47,6 @@ class TaskRedirect extends Task {
        }
      }
    }
-
-    /* update the notifier if a new statusHook was provided */
-    if (this.statusHook) {
-      this.logger.info(`TaskRedirect updating statusHook to ${this.statusHook}`);
-      try {
-        const oldNotifier = cs.application.notifier;
-        const isStatusHookAbsolute = cs.notifier?._isAbsoluteUrl(this.statusHook);
-        if (isStatusHookAbsolute) {
-          if (cs.notifier instanceof WsRequestor) {
-            cs.application.notifier = new WsRequestor(this.logger, cs.accountSid, {url: this.statusHook},
-              cs.accountInfo.account.webhook_secret);
-          } else {
-            cs.application.notifier = new HttpRequestor(this.logger, cs.accountSid, {url: this.statusHook},
-              cs.accountInfo.account.webhook_secret);
-          }
-          if (oldNotifier?.close) oldNotifier.close();
-        }
-        /* update the call_status_hook URL that gets passed to the notifier */
-        cs.application.call_status_hook = this.statusHook;
-      } catch (err) {
-        this.logger.info(err, `TaskRedirect error updating statusHook to ${this.statusHook}`);
-      }
-    }
-
    await this.performAction();
  }
 }
--- a/lib/tasks/say.js
+++ b/lib/tasks/say.js
@@ -1,11 +1,9 @@
 const assert = require('assert');
 const TtsTask = require('./tts-task');
 const {TaskName, TaskPreconditions} = require('../utils/constants');
-const {JAMBONES_SAY_CHUNK_SIZE} = require('../config');
 const pollySSMLSplit = require('polly-ssml-split');
-const { SpeechCredentialError, NonFatalTaskError } = require('../utils/error');
+const { SpeechCredentialError } = require('../utils/error');
 const { sleepFor } = require('../utils/helpers');
-const { NON_FANTAL_ERRORS } = require('../utils/constants.json');

 /**
 * Discard unmatching responses:
@@ -32,7 +30,7 @@ const isMatchingEvent = (logger, filename, playbackId, evt) => {
 const breakLengthyTextIfNeeded = (logger, text) => {
  // As The text can be used for tts streaming, we need to break lengthy text into smaller chunks
 // HIGH_WATER_BUFFER_SIZE defined in tts-streaming-buffer.js
-  const chunkSize = JAMBONES_SAY_CHUNK_SIZE;
+  const chunkSize = 900;
  const isSSML = text.startsWith('<speak>');
  const options = {
    softLimit: 100,
@@ -122,11 +120,13 @@ class TaskSay extends TtsTask {
      }
      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({error}, 'Say failed due to SpeechCredentialError, finished!');
+        this.emit('playDone');
        return;
      }
      throw error;
@@ -147,6 +147,9 @@ class TaskSay extends TtsTask {

      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'));
+
      if (this.text.length !== 0) {
        this.logger.info('TaskSay:handlingStreaming - sending text to TTS stream');
        for (const t of this.text) {
@@ -404,19 +407,11 @@ class TaskSay extends TtsTask {
            this._playResolve = resolve;
            this._playReject = reject;
          });
-          try {
-            const r = await ep.play(filename);
-            this.logger.debug({r}, 'Say:exec play result');
-            if (r.playbackSeconds == null && r.playbackMilliseconds == null && r.playbackLastOffsetPos == null) {
-              this._playReject(new Error('Playback failed to start'));
-            }
-          } catch (err) {
-            if (NON_FANTAL_ERRORS.includes(err.message)) {
-              throw new NonFatalTaskError(err.message);
-            }
-            throw err;
+          const r = await ep.play(filename);
+          this.logger.debug({r}, 'Say:exec play result');
+          if (r.playbackSeconds == null && r.playbackMilliseconds == null && r.playbackLastOffsetPos == null) {
+            this._playReject(new Error('Playback failed to start'));
          }
-
          try {
            // wait for playback-stop event received to confirm if the playback is successful
            await this._playPromise;
@@ -454,8 +449,8 @@ class TaskSay extends TtsTask {
        const {memberId, confName} = cs;
        this.killPlayToConfMember(this.ep, memberId, confName);
      } else if (this.isStreamingTts) {
-        this.logger.debug('TaskSay:kill - stopping TTS stream for streaming audio');
-        cs.stopTtsStream();
+        this.logger.debug('TaskSay:kill - clearing TTS stream for streaming audio');
+        cs.clearTtsStream();
      } else {
        if (!this.notifiedPlayBackStop) {
          this.notifyStatus({event: 'stop-playback'});
--- a/lib/tasks/stt-task.js
+++ b/lib/tasks/stt-task.js
@@ -171,7 +171,7 @@ class SttTask extends Task {
      try {
        this.sttCredentials = await this._initSpeechCredentials(this.cs, this.vendor, this.label);
      } catch (error) {
-        if (this.canFallback()) {
+        if (this.canFallback) {
          this.notifyError(
            {
              msg: 'ASR error', details:`Invalid vendor ${this.vendor}, Error: ${error}`,
@@ -205,64 +205,13 @@ class SttTask extends Task {
    }
  }

-
-  async createGladiaLiveSession() {
-    const { api_key, region = 'us-west' } = this.sttCredentials;
-    const model = this.data.recognizer.model || 'solaria-1';
-    const options = this.data.recognizer.gladiaOptions || {};
-
-    const url = `https://api.gladia.io/v2/live?region=${region}`;
-    const response = await fetch(url, {
-      method: 'POST',
-      headers: {
-        'x-gladia-key': api_key,
-        'Content-Type': 'application/json'
-      },
-      body: JSON.stringify({
-        encoding: 'wav/pcm',
-        bit_depth: 16,
-        sample_rate: 8000,
-        channels: 1,
-        model,
-        ...options,
-        messages_config: {
-          receive_final_transcripts: true,
-          receive_speech_events: true,
-          receive_errors: true,
-        }
-      })
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      this.logger.error({url, status: response.status, error}, 'Error creating Gladia live session');
-      throw new Error(`Error creating Gladia live session: ${response.status} ${error}`);
-    }
-
-    const data = await response.json();
-    this.logger.debug({url: data.url}, 'Gladia Call registered');
-
-    const {host, pathname, search} = new URL(data.url);
-    return {host, path: `${pathname}${search}`};
-  }
-
  addCustomEventListener(ep, event, handler) {
    this.eventHandlers.push({ep, event, handler});
    ep.addCustomEventListener(event, handler);
  }

-  removeCustomEventListeners(ep) {
-    if (ep) {
-      // for specific endpoint
-      this.eventHandlers.filter((h) => h.ep === ep).forEach((h) => {
-        h.ep.removeCustomEventListener(h.event, h.handler);
-      });
-      this.eventHandlers = this.eventHandlers.filter((h) => h.ep !== ep);
-      return;
-    } else {
-      // for all endpoints
-      this.eventHandlers.forEach((h) => h.ep.removeCustomEventListener(h.event, h.handler));
-      this.eventHandlers = [];
-    }
+  removeCustomEventListeners() {
+    this.eventHandlers.forEach((h) => h.ep.removeCustomEventListener(h.event, h.handler));
  }

  async _initSpeechCredentials(cs, vendor, label) {
@@ -276,7 +225,6 @@ class SttTask extends Task {
        account_sid: cs.accountSid,
        alert_type: AlertType.STT_NOT_PROVISIONED,
        vendor,
-        label,
        target_sid: cs.callSid
      }).catch((err) => this.logger.info({err}, 'Error generating alert for no stt'));
      // the ASR might have fallback configuration, should not done task here.
@@ -331,13 +279,11 @@ class SttTask extends Task {
    return credentials;
  }

-  canFallback() {
+  get canFallback() {
    return this.fallbackVendor && this.isHandledByPrimaryProvider && !this.cs.hasFallbackAsr;
  }

-  // ep is optional for gather or any verb that have single ep,
-  // but transcribe does need as it might has 2 eps
-  async _initFallback(ep) {
+  async _initFallback() {
    assert(this.fallbackVendor, 'fallback failed without fallbackVendor configuration');
    this.logger.info(`Failed to use primary STT provider, fallback to ${this.fallbackVendor}`);
    this.isHandledByPrimaryProvider = false;
@@ -350,7 +296,7 @@ class SttTask extends Task {
    this.data.recognizer.label = this.label;
    this.sttCredentials = await this._initSpeechCredentials(this.cs, this.vendor, this.label);
    // cleanup previous listener from previous vendor
-    this.removeCustomEventListeners(ep);
+    this.removeCustomEventListeners();
  }

  async compileHintsForCobalt(ep, hostport, model, token, hints) {
@@ -477,7 +423,6 @@ class SttTask extends Task {
      message: 'STT failure reported by vendor',
      detail: evt.error,
      vendor: this.vendor,
-      label: this.label,
      target_sid: cs.callSid
    }).catch((err) => this.logger.info({err}, `Error generating alert for ${this.vendor} connection failure`));
  }
@@ -491,7 +436,6 @@ class SttTask extends Task {
      alert_type: AlertType.STT_FAILURE,
      message: `Failed connecting to ${this.vendor} speech recognizer: ${reason}`,
      vendor: this.vendor,
-      label: this.label,
      target_sid: cs.callSid
    }).catch((err) => this.logger.info({err}, `Error generating alert for ${this.vendor} connection failure`));
  }
--- a/lib/tasks/transcribe.js
+++ b/lib/tasks/transcribe.js
@@ -6,7 +6,6 @@ const {
  AwsTranscriptionEvents,
  AzureTranscriptionEvents,
  DeepgramTranscriptionEvents,
-  GladiaTranscriptionEvents,
  DeepgramfluxTranscriptionEvents,
  SonioxTranscriptionEvents,
  CobaltTranscriptionEvents,
@@ -15,7 +14,6 @@ const {
  JambonzTranscriptionEvents,
  TranscribeStatus,
  AssemblyAiTranscriptionEvents,
-  HoundifyTranscriptionEvents,
  VoxistTranscriptionEvents,
  CartesiaTranscriptionEvents,
  OpenAITranscriptionEvents,
@@ -70,9 +68,6 @@ class TaskTranscribe extends SttTask {
    this._bufferedTranscripts = [ [], [] ];  // for channel 1 and 2
    this.bugname_prefix = 'transcribe_';
    this.paused = false;
-    // fallback flags
-    this.isHandledByPrimaryProviderForEp1 = true;
-    this.isHandledByPrimaryProviderForEp2 = true;
  }

  get name() { return TaskName.Transcribe; }
@@ -259,18 +254,6 @@ class TaskTranscribe extends SttTask {
          this._onVendorConnectFailure.bind(this, cs, ep, channel));
        this.addCustomEventListener(ep, DeepgramfluxTranscriptionEvents.Error, this._onVendorError.bind(this, cs, ep));

-        break;
-
-      case 'gladia':
-        this.bugname = `${this.bugname_prefix}gladia_transcribe`;
-        this.addCustomEventListener(ep, GladiaTranscriptionEvents.Transcription,
-          this._onTranscription.bind(this, cs, ep, channel));
-        this.addCustomEventListener(ep, GladiaTranscriptionEvents.Connect,
-          this._onVendorConnect.bind(this, cs, ep));
-        this.addCustomEventListener(ep, GladiaTranscriptionEvents.ConnectFailure,
-          this._onVendorConnectFailure.bind(this, cs, ep, channel));
-        this.addCustomEventListener(ep, GladiaTranscriptionEvents.Error, this._onVendorError.bind(this, cs, ep));
-
        break;
      case 'soniox':
        this.bugname = `${this.bugname_prefix}soniox_transcribe`;
@@ -341,18 +324,6 @@ class TaskTranscribe extends SttTask {
          this._onVendorConnectFailure.bind(this, cs, ep, channel));
        break;

-      case 'houndify':
-        this.bugname = `${this.bugname_prefix}houndify_transcribe`;
-        this.addCustomEventListener(ep, HoundifyTranscriptionEvents.Transcription,
-          this._onTranscription.bind(this, cs, ep, channel));
-        this.addCustomEventListener(ep, HoundifyTranscriptionEvents.Error,
-          this._onVendorError.bind(this, cs, ep));
-        this.addCustomEventListener(ep, HoundifyTranscriptionEvents.ConnectFailure,
-          this._onVendorConnectFailure.bind(this, cs, ep, channel));
-        this.addCustomEventListener(ep, HoundifyTranscriptionEvents.Connect,
-          this._onVendorConnect.bind(this, cs, ep));
-        break;
-
      case 'voxist':
        this.bugname = `${this.bugname_prefix}voxist_transcribe`;
        this.addCustomEventListener(ep, VoxistTranscriptionEvents.Transcription,
@@ -459,14 +430,6 @@ class TaskTranscribe extends SttTask {
      else if (this.data.recognizer?.hints?.length > 0) {
        prompt = this.data.recognizer?.hints.join(', ');
      }
-    } else if (this.vendor === 'gladia') {
-      // gladia require unique url for each session
-      const {host, path} = await this.createGladiaLiveSession();
-      await ep.set({
-        GLADIA_SPEECH_HOST: host,
-        GLADIA_SPEECH_PATH: path,
-      })
-        .catch((err) => this.logger.info(err, 'Error setting channel variables'));
    }

    await ep.startTranscription({
@@ -787,7 +750,7 @@ class TaskTranscribe extends SttTask {
  }

  async _startFallback(cs, _ep, evt) {
-    if (this.canFallback(_ep)) {
+    if (this.canFallback) {
      _ep.stopTranscription({
        vendor: this.vendor,
        bugname: this.bugname,
@@ -797,7 +760,7 @@ class TaskTranscribe extends SttTask {
      try {
        this.notifyError({ msg: 'ASR error',
          details:`STT Vendor ${this.vendor} error: ${evt.error || evt.reason}`, failover: 'in progress'});
-        await this._initFallback(_ep);
+        await this._initFallback();
        let channel = 1;
        if (this.ep !== _ep) {
          channel = 2;
@@ -906,41 +869,6 @@ class TaskTranscribe extends SttTask {
    if (this._asrTimer) clearTimeout(this._asrTimer);
    this._asrTimer = null;
  }
-
-  // We need to keep track the fallback is happened for each endpoint
-  // override the canFallback and _initFallback methods to make sure that
-  // we only fallback once per endpoint
-  // we want to keep track this on task level instead of endpoint level
-  // because the endpoint instance is used across multiple tasks.
-  canFallback(ep) {
-    let isHandledByPrimaryProvider = this.isHandledByPrimaryProvider;
-    if (ep === this.ep) {
-      isHandledByPrimaryProvider = this.isHandledByPrimaryProviderForEp1;
-    } else if (ep === this.ep2) {
-      isHandledByPrimaryProvider = this.isHandledByPrimaryProviderForEp2;
-    }
-
-    const isOneOfEndpointAlreadyFallenBack = !!this.ep && !!this.ep2 &&
-      this.isHandledByPrimaryProviderForEp1 !== this.isHandledByPrimaryProviderForEp2;
-
-    // fallback is configured
-    return this.fallbackVendor &&
-      // has this endpoint already fallen back
-      isHandledByPrimaryProvider &&
-      // in global level, is there any fallback is already happened
-      // one fallen endpoint will mark cs.hasFallbackAsr to true,
-      // so if one endpoint was fallen, the other endpoint would be able to fallback.
-      (isOneOfEndpointAlreadyFallenBack || !this.cs.hasFallbackAsr);
-  }
-
-  _initFallback(ep) {
-    if (ep === this.ep) {
-      this.isHandledByPrimaryProviderForEp1 = false;
-    } else if (ep === this.ep2) {
-      this.isHandledByPrimaryProviderForEp2 = false;
-    }
-    return super._initFallback(ep);
-  }
 }

 module.exports = TaskTranscribe;
--- a/lib/tasks/tts-task.js
+++ b/lib/tasks/tts-task.js
@@ -31,9 +31,8 @@ class TtsTask extends Task {
    this.synthesizer = this.data.synthesizer || {};
    this.disableTtsCache = this.data.disableTtsCache;
    this.options = this.synthesizer.options || {};
-    this.instructions = this.data.instructions || this.options.instructions;
+    this.instructions = this.data.instructions;
    this.playbackIds = [];
-    this.useGeminiTts = this.options.useGeminiTts;
  }

  getPlaybackId(offset) {
@@ -42,10 +41,6 @@ class TtsTask extends Task {

  async exec(cs) {
    super.exec(cs);
-    // update disableTtsCache from call session if not set in task
-    if (this.data.disableTtsCache == null) {
-      this.disableTtsCache = cs.disableTtsCache;
-    }
    if (cs.synthesizer) {
      this.options = {...cs.synthesizer.options, ...this.options};
      this.data.synthesizer = this.data.synthesizer || {};
@@ -86,67 +81,54 @@ class TtsTask extends Task {
  }

  async setTtsStreamingChannelVars(vendor, language, voice, credentials, ep) {
-    const {api_key, model_id, api_uri, custom_tts_streaming_url, auth_token, options} = credentials;
-    // api_key, model_id, api_uri, custom_tts_streaming_url, and auth_token are encoded in the credentials
-    // allow them to be overriden via config, using options
-    // give preference to options passed in via config
-    const parsed_options = options ? JSON.parse(options) : {};
-    const local_options = {...parsed_options, ...this.options};
-    const local_voice_settings = {...(parsed_options.voice_settings || {}), ...(this.options.voice_settings || {})};
-    const local_api_key =  local_options.api_key ?? api_key;
-    const local_model_id = local_options.model_id ?? model_id;
-    const local_api_uri = local_options.api_uri ?? api_uri;
-    const local_custom_tts_streaming_url = local_options.custom_tts_streaming_url ?? custom_tts_streaming_url;
-    const local_auth_token = local_options.auth_token ?? auth_token;
-
-
+    const {api_key, model_id, custom_tts_streaming_url, auth_token} = credentials;
    let obj;

+    this.logger.debug(`setTtsStreamingChannelVars: vendor: ${vendor}, language: ${language}, voice: ${voice}`);
+
    switch (vendor) {
      case 'deepgram':
        obj = {
-          DEEPGRAM_API_KEY: local_api_key,
+          DEEPGRAM_API_KEY: api_key,
          DEEPGRAM_TTS_STREAMING_MODEL: voice
        };
        break;
      case 'cartesia':
        obj = {
-          CARTESIA_API_KEY: local_api_key,
-          CARTESIA_TTS_STREAMING_MODEL_ID: local_model_id,
+          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':
-        // eslint-disable-next-line max-len
-        const {stability, similarity_boost, use_speaker_boost, style, speed} = local_voice_settings || {};
+        const {stability, similarity_boost, use_speaker_boost, style, speed} = this.options.voice_settings || {};
        obj = {
-          ELEVENLABS_API_KEY: local_api_key,
-          ...(api_uri && {ELEVENLABS_API_URI: local_api_uri}),
-          ELEVENLABS_TTS_STREAMING_MODEL_ID: local_model_id,
+          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(local_model_id) && {ELEVENLABS_TTS_STREAMING_LANGUAGE: 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}),
          // speed has value 0.7 to 1.2, 1.0 is default, make sure we send the value event it's 0
          ...(speed !== null && speed !== undefined && {ELEVENLABS_TTS_STREAMING_VOICE_SETTINGS_SPEED: `${speed}`}),
-          ...(local_options.pronunciation_dictionary_locators &&
-            Array.isArray(local_options.pronunciation_dictionary_locators) && {
+          ...(this.options.pronunciation_dictionary_locators &&
+            Array.isArray(this.options.pronunciation_dictionary_locators) && {
            ELEVENLABS_TTS_STREAMING_PRONUNCIATION_DICTIONARY_LOCATORS:
-            JSON.stringify(local_options.pronunciation_dictionary_locators)
+            JSON.stringify(this.options.pronunciation_dictionary_locators)
          }),
        };
        break;
      case 'rimelabs':
        const {
          pauseBetweenBrackets, phonemizeBetweenBrackets, inlineSpeedAlpha, speedAlpha, reduceLatency
-        } = local_options;
+        } = this.options;
        obj = {
-          RIMELABS_API_KEY: local_api_key,
-          RIMELABS_TTS_STREAMING_MODEL_ID: local_model_id,
+          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}),
@@ -157,19 +139,12 @@ class TtsTask extends Task {
          ...(reduceLatency && {RIMELABS_TTS_STREAMING_REDUCE_LATENCY: reduceLatency})
        };
        break;
-      case 'google':
-        obj = {
-          GOOGLE_TTS_LANGUAGE_CODE: language,
-          GOOGLE_TTS_VOICE_NAME: voice,
-          GOOGLE_APPLICATION_CREDENTIALS: JSON.stringify(credentials.credentials)
-        };
-        break;
      default:
        if (vendor.startsWith('custom:')) {
          const use_tls = custom_tts_streaming_url.startsWith('wss://');
          obj = {
-            CUSTOM_TTS_STREAMING_HOST: local_custom_tts_streaming_url.replace(/^(ws|wss):\/\//, ''),
-            CUSTOM_TTS_STREAMING_API_KEY: local_auth_token,
+            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
@@ -250,8 +225,6 @@ class TtsTask extends Task {
      }
    } else if (vendor === 'cartesia') {
      credentials.model_id = this.options.model_id || credentials.model_id;
-    } else if (vendor === 'google') {
-      this.model = this.options.model || credentials.credentials.model_id;
    }

    this.model_id = credentials.model_id;
@@ -284,16 +257,15 @@ class TtsTask extends Task {
          account_sid,
          alert_type: AlertType.TTS_NOT_PROVISIONED,
          vendor,
-          label,
          target_sid: cs.callSid
        }).catch((err) => this.logger.info({err}, 'Error generating alert for no tts'));
        throw new SpeechCredentialError('no provisioned speech credentials for TTS');
      }

      /* produce an audio segment from the provided text */
-      const generateAudio = async(text, index) => {
-        if (this.killed) return {index, filePath: null};
-        if (text.startsWith('silence_stream://')) return {index, filePath: text};
+      const generateAudio = async(text) => {
+        if (this.killed) return;
+        if (text.startsWith('silence_stream://')) return text;

        /* otel: trace time for tts */
        if (!preCache && !this._disableTracing)  {
@@ -322,6 +294,7 @@ class TtsTask extends Task {
            renderForCaching: preCache
          });
          if (!filePath.startsWith('say:')) {
+            this.playbackIds.push(null);
            this.logger.debug(`Say: file ${filePath}, served from cache ${servedFromCache}`);
            if (filePath) cs.trackTmpFile(filePath);
            if (this.otelSpan) {
@@ -349,11 +322,10 @@ class TtsTask extends Task {
                'id': this.id
              });
            }
-            return {index, filePath, playbackId: null};
          }
          else {
-            const playbackId = extractPlaybackId(filePath);
-            this.logger.debug('Say: a streaming tts api will be used');
+            this.playbackIds.push(extractPlaybackId(filePath));
+            this.logger.debug({playbackIds: this.playbackIds}, 'Say: a streaming tts api will be used');
            const modifiedPath = filePath.replace('say:{', `say:{session-uuid=${ep.uuid},`);
            this.notifyStatus({
              event: 'synthesized-audio',
@@ -362,8 +334,9 @@ class TtsTask extends Task {
              servedFromCache,
              'id': this.id
            });
-            return {index, filePath: modifiedPath, playbackId};
+            return modifiedPath;
          }
+          return filePath;
        } catch (err) {
          this.logger.info({err}, 'Error synthesizing tts');
          if (this.otelSpan) this.otelSpan.end();
@@ -371,7 +344,6 @@ class TtsTask extends Task {
            account_sid: cs.accountSid,
            alert_type: AlertType.TTS_FAILURE,
            vendor,
-            label,
            detail: err.message,
            target_sid: cs.callSid
          }).catch((err) => this.logger.info({err}, 'Error generating alert for tts failure'));
@@ -379,20 +351,8 @@ class TtsTask extends Task {
        }
      };

-      // process all text segments in parallel will cause ordering issue
-      // so we attach index to each promise result and sort them later
-
-      const arr = this.text.map((t, index) => (this._validateURL(t) ?
-        Promise.resolve({index, filePath: t, playbackId: null}) : generateAudio(t, index)));
-      const results = await Promise.all(arr);
-      const sorted = results.sort((a, b) => a.index - b.index);
-
-      return sorted
-        .filter((fp) => fp.filePath && fp.filePath.length)
-        .map((r) => {
-          this.playbackIds.push(r.playbackId);
-          return r.filePath;
-        });
+      const arr = this.text.map((t) => (this._validateURL(t) ? t : generateAudio(t)));
+      return (await Promise.all(arr)).filter((fp) => fp && fp.length);
    } catch (err) {
      this.logger.info(err, 'TaskSay:exec error');
      throw err;
--- a/lib/utils/action-hook-delay.js
+++ b/lib/utils/action-hook-delay.js
@@ -118,13 +118,6 @@ class ActionHookDelayProcessor extends Emitter {
    this.logger.debug('ActionHookDelayProcessor#_onNoResponseTimer');
    this._noResponseTimer = null;

-    /* check if endpoint is still available (call may have ended) */
-    if (!this.ep) {
-      this.logger.debug('ActionHookDelayProcessor#_onNoResponseTimer: endpoint is null, call may have ended');
-      this._active = false;
-      return;
-    }
-
    /* get the next play or say action */
    const verb = this.actions[this._retryCount % this.actions.length];

@@ -136,8 +129,8 @@ class ActionHookDelayProcessor extends Emitter {
      this._taskInProgress.exec(this.cs, {ep: this.ep}).catch((err) => {
        this.logger.info(`ActionHookDelayProcessor#_onNoResponseTimer: error playing file: ${err.message}`);
        this._taskInProgress = null;
-        this.ep?.removeAllListeners('playback-start');
-        this.ep?.removeAllListeners('playback-stop');
+        this.ep.removeAllListeners('playback-start');
+        this.ep.removeAllListeners('playback-stop');
      });
    } catch (err) {
      this.logger.info(err, 'ActionHookDelayProcessor#_onNoResponseTimer: error starting action');
--- a/lib/utils/amd-utils.js
+++ b/lib/utils/amd-utils.js
@@ -405,21 +405,19 @@ module.exports = (logger) => {
    if (ep.amd) {
      vendor = ep.amd.vendor;
      ep.amd.stopAllTimers();
-      try {
-        ep.removeListener(GoogleTranscriptionEvents.Transcription, ep.amd.transcriptionHandler);
-        ep.removeListener(GoogleTranscriptionEvents.EndOfUtterance, ep.amd.EndOfUtteranceHandler);
-        ep.removeListener(AwsTranscriptionEvents.Transcription, ep.amd.transcriptionHandler);
-        ep.removeListener(AzureTranscriptionEvents.Transcription, ep.amd.transcriptionHandler);
-        ep.removeListener(AzureTranscriptionEvents.NoSpeechDetected, ep.amd.noSpeechHandler);
-        ep.removeListener(NuanceTranscriptionEvents.Transcription, ep.amd.transcriptionHandler);
-        ep.removeListener(DeepgramTranscriptionEvents.Transcription, ep.amd.transcriptionHandler);
-        ep.removeListener(SonioxTranscriptionEvents.Transcription, ep.amd.transcriptionHandler);
-        ep.removeListener(IbmTranscriptionEvents.Transcription, ep.amd.transcriptionHandler);
-        ep.removeListener(NvidiaTranscriptionEvents.Transcription, ep.amd.transcriptionHandler);
-        ep.removeListener(JambonzTranscriptionEvents.Transcription, ep.amd.transcriptionHandler);
-      } catch (error) {
-        logger.error('Unable to Remove AMD Listener', error);
-      }
+
+      ep.removeListener(GoogleTranscriptionEvents.Transcription, ep.amd.transcriptionHandler);
+      ep.removeListener(GoogleTranscriptionEvents.EndOfUtterance, ep.amd.EndOfUtteranceHandler);
+      ep.removeListener(AwsTranscriptionEvents.Transcription, ep.amd.transcriptionHandler);
+      ep.removeListener(AzureTranscriptionEvents.Transcription, ep.amd.transcriptionHandler);
+      ep.removeListener(AzureTranscriptionEvents.NoSpeechDetected, ep.amd.noSpeechHandler);
+      ep.removeListener(NuanceTranscriptionEvents.Transcription, ep.amd.transcriptionHandler);
+      ep.removeListener(DeepgramTranscriptionEvents.Transcription, ep.amd.transcriptionHandler);
+      ep.removeListener(SonioxTranscriptionEvents.Transcription, ep.amd.transcriptionHandler);
+      ep.removeListener(IbmTranscriptionEvents.Transcription, ep.amd.transcriptionHandler);
+      ep.removeListener(NvidiaTranscriptionEvents.Transcription, ep.amd.transcriptionHandler);
+      ep.removeListener(JambonzTranscriptionEvents.Transcription, ep.amd.transcriptionHandler);
+
      ep.amd = null;
    }

--- a/lib/utils/background-task-manager.js
+++ b/lib/utils/background-task-manager.js
@@ -135,24 +135,26 @@ class BackgroundTaskManager extends Emitter {

  // Initiate Record
  async _initRecord() {
-    if (!JAMBONZ_RECORD_WS_BASE_URL || !this.cs.accountInfo.account.bucket_credential) {
-      this.logger.error('_initRecord: invalid cfg - missing JAMBONZ_RECORD_WS_BASE_URL or bucket config');
-      return undefined;
-    }
-    const listenOpts = {
-      url: `${JAMBONZ_RECORD_WS_BASE_URL}/record/${this.cs.accountInfo.account.bucket_credential.vendor}`,
-      disableBidirectionalAudio: true,
-      mixType : 'stereo',
-      passDtmf: true
-    };
-    if (JAMBONZ_RECORD_WS_USERNAME && JAMBONZ_RECORD_WS_PASSWORD) {
-      listenOpts.wsAuth = {
-        username: JAMBONZ_RECORD_WS_USERNAME,
-        password: JAMBONZ_RECORD_WS_PASSWORD
+    if (this.cs.accountInfo.account.record_all_calls || this.cs.application.record_all_calls) {
+      if (!JAMBONZ_RECORD_WS_BASE_URL || !this.cs.accountInfo.account.bucket_credential) {
+        this.logger.error('_initRecord: invalid cfg - missing JAMBONZ_RECORD_WS_BASE_URL or bucket config');
+        return undefined;
+      }
+      const listenOpts = {
+        url: `${JAMBONZ_RECORD_WS_BASE_URL}/record/${this.cs.accountInfo.account.bucket_credential.vendor}`,
+        disableBidirectionalAudio: true,
+        mixType : 'stereo',
+        passDtmf: true
      };
+      if (JAMBONZ_RECORD_WS_USERNAME && JAMBONZ_RECORD_WS_PASSWORD) {
+        listenOpts.wsAuth = {
+          username: JAMBONZ_RECORD_WS_USERNAME,
+          password: JAMBONZ_RECORD_WS_PASSWORD
+        };
+      }
+      this.logger.debug({listenOpts}, '_initRecord: enabling listen');
+      return await this._initListen({verb: 'listen', ...listenOpts}, 'jambonz-session-record', true, 'record');
    }
-    this.logger.debug({listenOpts}, '_initRecord: enabling listen');
-    return await this._initListen({verb: 'listen', ...listenOpts}, 'jambonz-session-record', true, 'record');
  }

  // Initiate Transcribe
--- a/lib/utils/constants.json
+++ b/lib/utils/constants.json
@@ -103,12 +103,6 @@
    "Connect": "deepgramflux_transcribe::connect",
    "Error": "deepgramflux_transcribe::error"
  },
-  "GladiaTranscriptionEvents": {
-    "Transcription": "gladia_transcribe::transcription",
-    "ConnectFailure": "gladia_transcribe::connect_failed",
-    "Connect": "gladia_transcribe::connect",
-    "Error": "gladia_transcribe::error"
-  },
  "SonioxTranscriptionEvents": {
    "Transcription": "soniox_transcribe::transcription",
    "Error": "soniox_transcribe::error"
@@ -175,12 +169,6 @@
    "ConnectFailure": "assemblyai_transcribe::connect_failed",
    "Connect": "assemblyai_transcribe::connect"
  },
-  "HoundifyTranscriptionEvents": {
-    "Transcription": "houndify_transcribe::transcription",
-    "Error": "houndify_transcribe::error",
-    "ConnectFailure": "houndify_transcribe::connect_failed",
-    "Connect": "houndify_transcribe::connect"
-  },
  "VoxistTranscriptionEvents": {
    "Transcription": "voxist_transcribe::transcription",
    "Error": "voxist_transcribe::error",
@@ -311,11 +299,6 @@
    "ConnectFailure": "deepgram_tts_streaming::connect_failed",
    "Connect": "deepgram_tts_streaming::connect"
  },
-  "GoogleTtsStreamingEvents": {
-    "Empty": "google_tts_streaming::empty",
-    "ConnectFailure": "google_tts_streaming::connect_failed",
-    "Connect": "google_tts_streaming::connect"
-  },
  "CartesiaTtsStreamingEvents": {
    "Empty": "cartesia_tts_streaming::empty",
    "ConnectFailure": "cartesia_tts_streaming::connect_failed",
@@ -340,8 +323,7 @@
    "Empty": "tts_streaming::empty",
    "Pause": "tts_streaming::pause",
    "Resume": "tts_streaming::resume",
-    "ConnectFailure": "tts_streaming::connect_failed",
-    "Connected": "tts_streaming::connected"
+    "ConnectFailure": "tts_streaming::connect_failed"
  },
  "TtsStreamingConnectionStatus": {
    "NotConnected": "not_connected",
@@ -361,8 +343,5 @@
  "WS_CLOSE_CODES": {
    "NormalClosure": 1000,
    "GoingAway": 1001
-  },
-  "NON_FANTAL_ERRORS": [
-    "File Not Found"
-  ]
+  }
 }
--- a/lib/utils/db-utils.js
+++ b/lib/utils/db-utils.js
@@ -81,11 +81,6 @@ const speechMapper = (cred) => {
      obj.deepgram_tts_uri = o.deepgram_tts_uri;
      obj.deepgram_stt_use_tls = o.deepgram_stt_use_tls;
    }
-    else if ('gladia' === obj.vendor) {
-      const o = JSON.parse(decrypt(credential));
-      obj.api_key = o.api_key;
-      obj.region = o.region;
-    }
    else if ('deepgramflux' === obj.vendor) {
      const o = JSON.parse(decrypt(credential));
      obj.api_key = o.api_key;
@@ -106,7 +101,6 @@ const speechMapper = (cred) => {
      const o = JSON.parse(decrypt(credential));
      obj.api_key = o.api_key;
      obj.model_id = o.model_id;
-      obj.api_uri = o.api_uri;
      obj.options = o.options;
    }
    else if ('playht' === obj.vendor) {
@@ -147,13 +141,6 @@ const speechMapper = (cred) => {
      obj.api_key = o.api_key;
      obj.service_version = o.service_version;
    }
-    else if ('houndify' === obj.vendor) {
-      const o = JSON.parse(decrypt(credential));
-      obj.client_id = o.client_id;
-      obj.client_key = o.client_key;
-      obj.user_id = o.user_id;
-      obj.houndify_server_uri = o.houndify_server_uri;
-    }
    else if ('voxist' === obj.vendor) {
      const o = JSON.parse(decrypt(credential));
      obj.api_key = o.api_key;
--- a/lib/utils/http-requestor.js
+++ b/lib/utils/http-requestor.js
@@ -191,7 +191,7 @@ class HttpRequestor extends BaseRequestor {
        method,
        headers: hdrs,
        ...('POST' === method && {body: JSON.stringify(payload)}),
-        headersTimeout: HTTP_TIMEOUT,
+        timeout: HTTP_TIMEOUT,
        followRedirects: false
      };

--- a/lib/utils/place-outdial.js
+++ b/lib/utils/place-outdial.js
@@ -234,11 +234,6 @@ class SingleDialer extends Emitter {
      await connectStream(this.dlg.remote.sdp, opts.isVideoCall);
      this.dlg.callSid = this.callSid;
      this.inviteInProgress = null;
-
-      /* ensure sbcCallid is set even if no provisional response was received */
-      if (!this.callInfo.sbcCallid && this.dlg.res.has('X-CID')) {
-        this.callInfo.sbcCallid = this.dlg.res.get('X-CID');
-      }
      this.emit('callStatusChange', {
        sipStatus: 200,
        sipReason: 'OK',
@@ -295,7 +290,6 @@ class SingleDialer extends Emitter {
            }
          } catch (err) {
            this.logger.error(err, 'Error handling reinvite');
-            res.send(err.status || 500);
          }
        })
        .on('refer', (req, res) => {
--- a/lib/utils/sbc-pinger.js
+++ b/lib/utils/sbc-pinger.js
@@ -100,30 +100,6 @@ module.exports = (logger) => {
  else if (K8S) {
    lifecycleEmitter.scaleIn = () => process.exit(0);
  }
-  else {
-    process.on('SIGUSR1', () => {
-      logger.info('received SIGUSR1: begin drying up calls for scale-in');
-      dryUpCalls = true;
-
-      const {srf} = require('../..');
-      const {writeSystemAlerts} = srf.locals;
-      if (writeSystemAlerts) {
-        const {SystemState, FEATURE_SERVER} = require('./constants');
-        writeSystemAlerts({
-          system_component: FEATURE_SERVER,
-          state : SystemState.GracefulShutdownInProgress,
-          fields : {
-            detail: `feature-server with process_id ${process.pid} shutdown in progress`,
-            host: srf.locals?.ipv4
-          }
-        });
-      }
-      pingProxies(srf);
-
-      // Note: in response to SIGUSR1 we start drying up but do not exit when calls reach zero.
-      // This is to allow external scripts that sent the signal to manage the lifecycle.
-    });
-  }


  async function pingProxies(srf) {
--- a/lib/utils/sdp-utils.js
+++ b/lib/utils/sdp-utils.js
@@ -55,28 +55,11 @@ const extractSdpMedia = (sdp) => {
  }
 };

-const getLeadingCodec = (sdp) => {
-  if (!sdp) {
-    return null;
-  }
-
-  const parsed = sdpTransform.parse(sdp);
-  const audio = parsed.media?.find((m) => m.type === 'audio');
-
-  if (!audio) {
-    return null;
-  }
-
-  return audio.rtp?.[0]?.codec || null;
-};
-
-
 module.exports = {
  isOnhold,
  mergeSdpMedia,
  extractSdpMedia,
  isOpusFirst,
  makeOpusFirst,
-  removeVideoSdp,
-  getLeadingCodec
+  removeVideoSdp
 };
--- a/lib/utils/stt-latency-calculator.js
+++ b/lib/utils/stt-latency-calculator.js
@@ -127,6 +127,7 @@ class SttLatencyCalculator extends Emitter {

  calculateLatency() {
    if (!this.isRunning) {
+      this.logger.debug('Latency calculator is not running, cannot calculate latency, returning default values');
      return null;
    }

--- a/lib/utils/transcription-utils.js
+++ b/lib/utils/transcription-utils.js
@@ -131,43 +131,6 @@ const stickyVars = {
    'OPENAI_TURN_DETECTION_PREFIX_PADDING_MS',
    'OPENAI_TURN_DETECTION_SILENCE_DURATION_MS',
  ],
-  houndify: [
-    'HOUNDIFY_CLIENT_ID',
-    'HOUNDIFY_CLIENT_KEY',
-    'HOUNDIFY_USER_ID',
-    'HOUNDIFY_MAX_SILENCE_SECONDS',
-    'HOUNDIFY_MAX_SILENCE_AFTER_FULL_QUERY_SECONDS',
-    'HOUNDIFY_MAX_SILENCE_AFTER_PARTIAL_QUERY_SECONDS',
-    'HOUNDIFY_VAD_SENSITIVITY',
-    'HOUNDIFY_VAD_TIMEOUT',
-    'HOUNDIFY_VAD_MODE',
-    'HOUNDIFY_VAD_VOICE_MS',
-    'HOUNDIFY_VAD_SILENCE_MS',
-    'HOUNDIFY_VAD_DEBUG',
-    'HOUNDIFY_AUDIO_FORMAT',
-    'HOUNDIFY_ENABLE_NOISE_REDUCTION',
-    'HOUNDIFY_AUDIO_ENDPOINT',
-    'HOUNDIFY_ENABLE_PROFANITY_FILTER',
-    'HOUNDIFY_ENABLE_PUNCTUATION',
-    'HOUNDIFY_ENABLE_CAPITALIZATION',
-    'HOUNDIFY_CONFIDENCE_THRESHOLD',
-    'HOUNDIFY_ENABLE_DISFLUENCY_FILTER',
-    'HOUNDIFY_MAX_RESULTS',
-    'HOUNDIFY_ENABLE_WORD_TIMESTAMPS',
-    'HOUNDIFY_MAX_ALTERNATIVES',
-    'HOUNDIFY_PARTIAL_TRANSCRIPT_INTERVAL',
-    'HOUNDIFY_SESSION_TIMEOUT',
-    'HOUNDIFY_CONNECTION_TIMEOUT',
-    'HOUNDIFY_LATITUDE',
-    'HOUNDIFY_LONGITUDE',
-    'HOUNDIFY_CITY',
-    'HOUNDIFY_STATE',
-    'HOUNDIFY_COUNTRY',
-    'HOUNDIFY_TIMEZONE',
-    'HOUNDIFY_DOMAIN',
-    'HOUNDIFY_CUSTOM_VOCABULARY',
-    'HOUNDIFY_LANGUAGE_MODEL'
-  ],
 };

 /**
@@ -376,30 +339,6 @@ const normalizeDeepgram = (evt, channel, language, shortUtterance) => {
  };
 };

-const normalizeGladia = (evt, channel, language, shortUtterance) => {
-  const copy = JSON.parse(JSON.stringify(evt));
-
-  // Handle Gladia transcript format
-  if (evt.type === 'transcript' && evt.data && evt.data.utterance) {
-    const utterance = evt.data.utterance;
-    const alternatives = [{
-      confidence: utterance.confidence || 0,
-      transcript: utterance.text || '',
-    }];
-
-    return {
-      language_code: utterance.language || language,
-      channel_tag: channel,
-      is_final: evt.data.is_final || false,
-      alternatives,
-      vendor: {
-        name: 'gladia',
-        evt: copy
-      }
-    };
-  }
-};
-
 const normalizeDeepgramFlux = (evt, channel, language) => {
  const copy = JSON.parse(JSON.stringify(evt));

@@ -643,30 +582,6 @@ const normalizeAssemblyAi = (evt, channel, language) => {
  };
 };

-const normalizeHoundify = (evt, channel, language) => {
-  const copy = JSON.parse(JSON.stringify(evt));
-  const alternatives = [];
-  const is_final = evt.ResultsAreFinal && evt.ResultsAreFinal[0] === true;
-  if (evt.Disambiguation && evt.Disambiguation.ChoiceData && evt.Disambiguation.ChoiceData.length > 0) {
-    // Handle Houndify Voice Search Result format
-    const choiceData = evt.Disambiguation.ChoiceData[0];
-    alternatives.push({
-      confidence: choiceData.ConfidenceScore || choiceData.ASRConfidence || 0.0,
-      transcript: choiceData.FormattedTranscription || choiceData.Transcription || '',
-    });
-  }
-  return {
-    language_code: language,
-    channel_tag: channel,
-    is_final,
-    alternatives,
-    vendor: {
-      name: 'houndify',
-      evt: copy
-    }
-  };
-};
-
 const normalizeVoxist = (evt, channel, language) => {
  const copy = JSON.parse(JSON.stringify(evt));
  return {
@@ -766,8 +681,6 @@ module.exports = (logger) => {
    switch (vendor) {
      case 'deepgram':
        return normalizeDeepgram(evt, channel, language, shortUtterance);
-      case 'gladia':
-        return normalizeGladia(evt, channel, language, shortUtterance);
      case 'deepgramflux':
        return normalizeDeepgramFlux(evt, channel, language, shortUtterance);
      case 'microsoft':
@@ -788,8 +701,6 @@ module.exports = (logger) => {
        return normalizeCobalt(evt, channel, language);
      case 'assemblyai':
        return normalizeAssemblyAi(evt, channel, language, shortUtterance);
-      case 'houndify':
-        return normalizeHoundify(evt, channel, language, shortUtterance);
      case 'voxist':
        return normalizeVoxist(evt, channel, language);
      case 'cartesia':
@@ -920,7 +831,7 @@ module.exports = (logger) => {
        ...(rOpts.initialSpeechTimeoutMs > 0 &&
          {AZURE_INITIAL_SPEECH_TIMEOUT_MS: rOpts.initialSpeechTimeoutMs}),
        ...(rOpts.requestSnr && {AZURE_REQUEST_SNR: 1}),
-        ...(azureOptions.audioLogging && {AZURE_AUDIO_LOGGING: 1}),
+        ...(rOpts.audioLogging && {AZURE_AUDIO_LOGGING: 1}),
        ...{AZURE_USE_OUTPUT_FORMAT_DETAILED: 1},
        ...(azureOptions.speechSegmentationSilenceTimeoutMs &&
          {AZURE_SPEECH_SEGMENTATION_SILENCE_TIMEOUT_MS: azureOptions.speechSegmentationSilenceTimeoutMs}),
@@ -1211,61 +1122,6 @@ module.exports = (logger) => {
          {ASSEMBLYAI_WORD_BOOST: JSON.stringify(rOpts.hints)})
      };
    }
-    else if ('houndify' === vendor) {
-      const {
-        latitude, longitude, city, state, country, timeZone, domain, audioEndpoint,
-        maxSilenceSeconds, maxSilenceAfterFullQuerySeconds, maxSilenceAfterPartialQuerySeconds,
-        vadSensitivity, vadTimeout, vadMode, vadVoiceMs, vadSilenceMs, vadDebug,
-        audioFormat, enableNoiseReduction, enableProfanityFilter, enablePunctuation,
-        enableCapitalization, confidenceThreshold, enableDisfluencyFilter,
-        maxResults, enableWordTimestamps, maxAlternatives, partialTranscriptInterval,
-        sessionTimeout, connectionTimeout, customVocabulary, languageModel,
-        requestInfo, sampleRate
-      } = rOpts.houndifyOptions || {};
-      const audioEndpointUri = audioEndpoint || sttCredentials.houndify_server_uri;
-
-      opts = {
-        ...opts,
-        HOUNDIFY_CLIENT_ID: sttCredentials.client_id,
-        HOUNDIFY_CLIENT_KEY: sttCredentials.client_key,
-        HOUNDIFY_USER_ID: sttCredentials.user_id,
-        HOUNDIFY_MAX_SILENCE_SECONDS: maxSilenceSeconds || 5,
-        HOUNDIFY_MAX_SILENCE_AFTER_FULL_QUERY_SECONDS: maxSilenceAfterFullQuerySeconds || 1,
-        HOUNDIFY_MAX_SILENCE_AFTER_PARTIAL_QUERY_SECONDS: maxSilenceAfterPartialQuerySeconds || 1.5,
-        ...(vadSensitivity && {HOUNDIFY_VAD_SENSITIVITY: vadSensitivity}),
-        ...(vadTimeout && {HOUNDIFY_VAD_TIMEOUT: vadTimeout}),
-        ...(vadMode && {HOUNDIFY_VAD_MODE: vadMode}),
-        ...(vadVoiceMs && {HOUNDIFY_VAD_VOICE_MS: vadVoiceMs}),
-        ...(vadSilenceMs && {HOUNDIFY_VAD_SILENCE_MS: vadSilenceMs}),
-        ...(vadDebug && {HOUNDIFY_VAD_DEBUG: vadDebug}),
-        ...(audioFormat && {HOUNDIFY_AUDIO_FORMAT: audioFormat}),
-        ...(enableNoiseReduction && {HOUNDIFY_ENABLE_NOISE_REDUCTION: enableNoiseReduction}),
-        ...(enableProfanityFilter && {HOUNDIFY_ENABLE_PROFANITY_FILTER: enableProfanityFilter}),
-        ...(enablePunctuation && {HOUNDIFY_ENABLE_PUNCTUATION: enablePunctuation}),
-        ...(enableCapitalization && {HOUNDIFY_ENABLE_CAPITALIZATION: enableCapitalization}),
-        ...(confidenceThreshold && {HOUNDIFY_CONFIDENCE_THRESHOLD: confidenceThreshold}),
-        ...(enableDisfluencyFilter && {HOUNDIFY_ENABLE_DISFLUENCY_FILTER: enableDisfluencyFilter}),
-        ...(maxResults && {HOUNDIFY_MAX_RESULTS: maxResults}),
-        ...(enableWordTimestamps && {HOUNDIFY_ENABLE_WORD_TIMESTAMPS: enableWordTimestamps}),
-        ...(maxAlternatives && {HOUNDIFY_MAX_ALTERNATIVES: maxAlternatives}),
-        ...(partialTranscriptInterval && {HOUNDIFY_PARTIAL_TRANSCRIPT_INTERVAL: partialTranscriptInterval}),
-        ...(sessionTimeout && {HOUNDIFY_SESSION_TIMEOUT: sessionTimeout}),
-        ...(connectionTimeout && {HOUNDIFY_CONNECTION_TIMEOUT: connectionTimeout}),
-        ...(latitude && {HOUNDIFY_LATITUDE: latitude}),
-        ...(longitude && {HOUNDIFY_LONGITUDE: longitude}),
-        ...(city && {HOUNDIFY_CITY: city}),
-        ...(state && {HOUNDIFY_STATE: state}),
-        ...(country && {HOUNDIFY_COUNTRY: country}),
-        ...(timeZone && {HOUNDIFY_TIMEZONE: timeZone}),
-        ...(domain && {HOUNDIFY_DOMAIN: domain}),
-        ...(audioEndpointUri && {HOUNDIFY_AUDIO_ENDPOINT: audioEndpointUri}),
-        ...(customVocabulary && {HOUNDIFY_CUSTOM_VOCABULARY:
-          Array.isArray(customVocabulary) ? customVocabulary.join(',') : customVocabulary}),
-        ...(languageModel && {HOUNDIFY_LANGUAGE_MODEL: languageModel}),
-        ...(requestInfo && {HOUNDIFY_REQUEST_INFO: JSON.stringify(requestInfo)}),
-        ...(sampleRate && {HOUNDIFY_SAMPLING_RATE: sampleRate}),
-      };
-    }
    else if ('voxist' === vendor) {
      opts = {
        ...opts,
@@ -1310,9 +1166,6 @@ module.exports = (logger) => {
          ...(openaiOptions.turn_detection.silence_duration_ms && {
            OPENAI_TURN_DETECTION_SILENCE_DURATION_MS: openaiOptions.turn_detection.silence_duration_ms
          }),
-          ...(openaiOptions.turn_detection.eagerness && {
-            OPENAI_TURN_DETECTION_EAGERNESS: openaiOptions.turn_detection.eagerness
-          })
        };
      }
    }
@@ -1378,9 +1231,7 @@ module.exports = (logger) => {
            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}),
-        SPEECHMATICS_END_OF_UTTERANCE_SILENCE_TRIGGER:
-          speechmaticsOptions.transcription_config?.conversation_config?.end_of_utterance_silence_trigger || 0.5
+            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
@@ -80,7 +80,7 @@ class TtsStreamingBuffer extends Emitter {
    clearTimeout(this.timer);
    this.removeCustomEventListeners();
    if (this.ep) {
-      this._api(this.ep, [this.ep.uuid, 'stop'])
+      this._api(this.ep, [this.ep.uuid, 'close'])
        .catch((err) =>
          this.logger.info({ err }, 'TtsStreamingBuffer:stop Error closing TTS streaming')
        );
@@ -163,6 +163,7 @@ class TtsStreamingBuffer extends Emitter {
  }

  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) =>
@@ -192,7 +193,10 @@ class TtsStreamingBuffer extends Emitter {
        this.logger.debug('TtsStreamingBuffer:_feedQueue TTS stream is not open or no endpoint available');
        return;
      }
-      if (this._connectionStatus !== TtsStreamingConnectionStatus.Connected) {
+      if (
+        this._connectionStatus === TtsStreamingConnectionStatus.NotConnected ||
+        this._connectionStatus === TtsStreamingConnectionStatus.Failed
+      ) {
        this.logger.debug('TtsStreamingBuffer:_feedQueue TTS stream is not connected');
        return;
      }
@@ -274,14 +278,6 @@ class TtsStreamingBuffer extends Emitter {
      }
      const chunk = combinedText.slice(0, chunkEnd);

-      // Check if the chunk is only whitespace before processing the queue
-      // If so, wait for more meaningful text
-      if (isWhitespace(chunk)) {
-        this.logger.debug('TtsStreamingBuffer:_feedQueue chunk is only whitespace, waiting for more text');
-        this._setTimerIfNeeded();
-        return;
-      }
-
      // Now we iterate over the queue items
      // and deduct their lengths until we've accounted for chunkEnd characters.
      let remaining = chunkEnd;
@@ -305,14 +301,6 @@ class TtsStreamingBuffer extends Emitter {
      this.bufferedLength -= chunkEnd;

      const modifiedChunk = chunk.replace(/\n\n/g, '\n \n');
-
-      if (isWhitespace(modifiedChunk)) {
-        this.logger.debug('TtsStreamingBuffer:_feedQueue modified chunk is only whitespace, restoring queue');
-        this.queue.unshift({ type: 'text', value: chunk });
-        this.bufferedLength += chunkEnd;
-        this._setTimerIfNeeded();
-        return;
-      }
      this.logger.debug(`TtsStreamingBuffer:_feedQueue sending chunk to tts: ${modifiedChunk}`);

      try {
@@ -361,7 +349,6 @@ class TtsStreamingBuffer extends Emitter {
    if (this.queue.length > 0) {
      await this._feedQueue();
    }
-    this.emit(TtsStreamingEvents.Connected, { vendor });
  }

  _onConnectFailure(vendor) {
@@ -412,7 +399,6 @@ class TtsStreamingBuffer extends Emitter {

  removeCustomEventListeners() {
    this.eventHandlers.forEach((h) => h.ep.removeCustomEventListener(h.event, h.handler));
-    this.eventHandlers.length = 0;
  }

  _initHandlers(ep) {
@@ -421,7 +407,6 @@ class TtsStreamingBuffer extends Emitter {
      'cartesia',
      'elevenlabs',
      'rimelabs',
-      'google',
      'custom'
    ].forEach((vendor) => {
      const eventClassName = `${vendor.charAt(0).toUpperCase() + vendor.slice(1)}TtsStreamingEvents`;
@@ -437,15 +422,7 @@ class TtsStreamingBuffer extends Emitter {

 const findSentenceBoundary = (text, limit) => {
  // Look for punctuation or double newline that signals sentence end.
-  // Includes:
-  //   - ASCII: . ! ?
-  //   - Arabic: ؟ (question mark), ۔ (full stop)
-  //   - Japanese: 。 (full stop), ！, ？ (full-width exclamation/question)
-  //
-  // For languages that use spaces between sentences, we still require
-  // whitespace or end-of-string after the mark. For Japanese (no spaces),
-  // we treat the punctuation itself as a boundary regardless of following char.
-  const sentenceEndRegex = /[.!?؟۔](?=\s|$)|[。！？]|\n\n/g;
+  const sentenceEndRegex = /[.!?](?=\s|$)|\n\n/g;
  let lastSentenceBoundary = -1;
  let match;
  while ((match = sentenceEndRegex.exec(text)) && match.index < limit) {
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@@ -3,7 +3,7 @@
  "version": "0.9.5",
  "main": "app.js",
  "engines": {
-    "node": ">= 20.x"
+    "node": ">= 18.x"
  },
  "keywords": [
    "sip",
@@ -27,14 +27,14 @@
  "dependencies": {
    "@aws-sdk/client-auto-scaling": "^3.549.0",
    "@aws-sdk/client-sns": "^3.549.0",
-    "@jambonz/db-helpers": "^0.9.18",
+    "@jambonz/db-helpers": "^0.9.17",
    "@jambonz/http-health-check": "^0.0.1",
    "@jambonz/mw-registrar": "^0.2.7",
    "@jambonz/realtimedb-helpers": "^0.8.15",
-    "@jambonz/speech-utils": "^0.2.30",
+    "@jambonz/speech-utils": "^0.2.24",
    "@jambonz/stats-collector": "^0.1.10",
-    "@jambonz/time-series": "^0.2.15",
-    "@jambonz/verb-specifications": "^0.0.125",
+    "@jambonz/time-series": "^0.2.14",
+    "@jambonz/verb-specifications": "^0.0.116",
    "@modelcontextprotocol/sdk": "^1.9.0",
    "@opentelemetry/api": "^1.8.0",
    "@opentelemetry/exporter-jaeger": "^1.23.0",
@@ -46,21 +46,21 @@
    "@opentelemetry/sdk-trace-node": "^1.23.0",
    "@opentelemetry/semantic-conventions": "^1.23.0",
    "bent": "^7.3.12",
-    "debug": "^4.4.3",
+    "debug": "^4.3.4",
    "deepcopy": "^2.1.0",
    "drachtio-fsmrf": "^4.1.2",
-    "drachtio-srf": "^5.0.20",
-    "express": "^4.22.1",
+    "drachtio-srf": "^5.0.11",
+    "express": "^4.19.2",
    "express-validator": "^7.0.1",
    "moment": "^2.30.1",
    "parse-url": "^9.2.0",
-    "pino": "^10.3.1",
+    "pino": "^8.20.0",
    "polly-ssml-split": "^0.1.0",
    "sdp-transform": "^2.15.0",
    "short-uuid": "^5.1.0",
    "sinon": "^17.0.1",
    "to-snake-case": "^1.0.0",
-    "undici": "^7.24.5",
+    "undici": "^7.5.0",
    "verify-aws-sns-signature": "^0.1.0",
    "ws": "^8.18.0",
    "xml2js": "^0.6.2"
--- a/test/webhooks-tests.js
+++ b/test/webhooks-tests.js
@@ -83,8 +83,7 @@ test('invalid jambonz json create alert tests', async(t) => {
      {account_sid: 'bb845d4b-83a9-4cde-a6e9-50f3743bab3f', page: 1, page_size: 25, days: 7});
    let checked = false;
    for (let i = 0; i < data.total; i++) {
-      checked = data.data[i].message === 'malformed jambonz payload: must be array';
-      if (checked) break;
+      checked = data.data[i].message === 'malformed jambonz payload: must be array'
    }
    t.ok(checked, 'alert is raised as expected');
    disconnect();