bump version

fix for #1285 (#1286 )
* fix for #1285 * typo
2026-02-10 08:21:33 +00:00 · 2025-07-15 11:40:14 -04:00 · 2025-07-15 11:38:48 -04:00 · 2025-07-13 11:08:15 -04:00 · 2025-07-13 10:56:41 -04:00 · 2025-07-10 07:39:42 -04:00
44 changed files with 3158 additions and 805 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -2,6 +2,9 @@
 logs
 *.log

+.claude/
+CLAUDE.md 
+
 # Runtime data
 pids
 *.pid
--- a/data/example-voicemail-greetings.json
+++ b/data/example-voicemail-greetings.json
@@ -163,5 +163,16 @@
    "wird sich bei Ihnen melden",
    "ich melde mich bei dir",
    "wir können nicht"
+  ],
+  "it-IT": [
+    "segreteria telefonica",
+    "risponde la segreteria telefonica",
+    "lascia un messaggio",
+    "puoi lasciare un messaggio dopo il segnale",
+    "dopo il segnale acustico",
+    "il numero chiamato non è raggiungibile",
+    "non è raggiungibile",
+    "lascia pure un messaggio",
+    "puoi lasciare un messaggio"
  ]
 }
--- a/lib/http-routes/api/create-call.js
+++ b/lib/http-routes/api/create-call.js
@@ -12,10 +12,12 @@ const HttpRequestor = require('../../utils/http-requestor');
 const WsRequestor = require('../../utils/ws-requestor');
 const RootSpan = require('../../utils/call-tracer');
 const dbUtils = require('../../utils/db-utils');
-const { mergeSdpMedia, extractSdpMedia } = require('../../utils/sdp-utils');
+const { decrypt } = require('../../utils/encrypt-decrypt');
+const { mergeSdpMedia, extractSdpMedia, removeVideoSdp } = require('../../utils/sdp-utils');
 const { createCallSchema, customSanitizeFunction } = require('../schemas/create-call');
 const { selectHostPort } = require('../../utils/network');
 const { JAMBONES_DIAL_SBC_FOR_REGISTERED_USER } = require('../../config');
+const { createMediaEndpoint } = require('../../utils/media-endpoint');

 const removeNullProperties = (obj) => (Object.keys(obj).forEach((key) => obj[key] === null && delete obj[key]), obj);
 const removeNulls = (req, res, next) => {
@@ -66,7 +68,7 @@ router.post('/',
      const {
        lookupAppBySid
      }  = srf.locals.dbHelpers;
-      const {getSBC, getFreeswitch} = srf.locals;
+      const {getSBC} = srf.locals;
      let sbcAddress = getSBC();
      if (!sbcAddress) throw new Error('no available SBCs for outbound call creation');
      const target = restDial.to;
@@ -169,9 +171,7 @@ router.post('/',
      }

      /* create endpoint for outdial */
-      const ms = getFreeswitch();
-      if (!ms) throw new Error('no available Freeswitch for outbound call creation');
-      const ep = await ms.createEndpoint();
+      const ep = await createMediaEndpoint(srf, logger);
      logger.debug(`createCall: successfully allocated endpoint, sending INVITE to ${sbcAddress}`);

      /* launch outdial */
@@ -180,10 +180,14 @@ router.post('/',
      let localSdp = ep.local.sdp;

      if (req.body.dual_streams) {
-        dualEp = await ms.createEndpoint();
+        dualEp = await createMediaEndpoint(srf, logger);
        localSdp = mergeSdpMedia(localSdp, dualEp.local.sdp);
      }
-
+      if (process.env.JAMBONES_VIDEO_CALLS_ENABLED_IN_FS) {
+        logger.debug('createCall: removing video sdp');
+        localSdp = removeVideoSdp(localSdp);
+        ep.modify(localSdp);
+      }
      const connectStream = async(remoteSdp) => {
        if (remoteSdp !== sdp) {
          sdp = remoteSdp;
@@ -212,6 +216,13 @@ router.post('/',
     * we merge the inbound call application,
     * with the provided app params from the request body
     */
+      try {
+        if (application?.env_vars && Object.keys(application.env_vars).length > 0) {
+          restDial.env_vars = JSON.parse(decrypt(application.env_vars));
+        }
+      } catch (err) {
+        logger.info({err}, 'Unable to set env_vars');
+      }
      const app = {
        ...application,
        ...req.body
@@ -224,9 +235,10 @@ router.post('/',
      if ('WS' === app.call_hook?.method || /^wss?:/.test(app.call_hook.url)) {
        logger.debug({call_hook: app.call_hook}, 'creating websocket for call hook');
        app.requestor = new WsRequestor(logger, account.account_sid, app.call_hook, account.webhook_secret) ;
-        if (app.call_hook.url === app.call_status_hook.url  || !app.call_status_hook?.url) {
+        if (app.call_hook.url === app.call_status_hook?.url  || !app.call_status_hook?.url) {
          logger.debug('reusing websocket for call status hook');
          app.notifier = app.requestor;
+          app.call_status_hook = app.call_hook;
        }
      }
      else {
--- a/lib/http-routes/schemas/create-call.js
+++ b/lib/http-routes/schemas/create-call.js
@@ -116,8 +116,8 @@ const customSanitizeFunction = (value) => {
      /* trims characters at the beginning and at the end of a string */
      value = value.trim();

-      /* Verify strings including 'http' via new URL */
-      if (value.includes('http')) {
+      // Only attempt to parse if the whole string is a URL
+      if (/^https?:\/\/\S+$/.test(value)) {
        value = new URL(value).toString();
      }
    }
--- a/lib/middleware.js
+++ b/lib/middleware.js
@@ -332,7 +332,7 @@ module.exports = function(srf, logger) {
      }

      // Resolve application.speech_synthesis_voice if it's custom voice
-      if (app2.speech_synthesis_vendor === 'google' && app2.speech_synthesis_voice.startsWith('custom_')) {
+      if (app2.speech_synthesis_vendor === 'google' && app2.speech_synthesis_voice?.startsWith('custom_')) {
        const arr = /custom_(.*)/.exec(app2.speech_synthesis_voice);
        if (arr) {
          const google_custom_voice_sid = arr[1];
@@ -424,8 +424,8 @@ module.exports = function(srf, logger) {
            logger.info(`Setting env_vars: ${Object.keys(d_env_vars)}`); // Only log the keys not the values
            env_vars = d_env_vars;
          }
-        } catch (error) {
-          logger.info('Unable to set env_vars', error);
+        } catch (err) {
+          logger.info({err}, 'Unable to set env_vars');
        }
        const params = Object.assign(['POST', 'WS'].includes(app.call_hook.method) ? { sip: req.msg } : {},
          req.locals.callInfo,
--- a/lib/session/call-session.js
+++ b/lib/session/call-session.js
@@ -29,10 +29,6 @@ const {
  JAMBONES_INJECT_CONTENT,
  JAMBONES_EAGERLY_PRE_CACHE_AUDIO,
  AWS_REGION,
-  JAMBONES_USE_FREESWITCH_TIMER_FD,
-  JAMBONES_MEDIA_TIMEOUT_MS,
-  JAMBONES_MEDIA_HOLD_TIMEOUT_MS,
-  JAMBONES_TRANSCRIBE_EP_DESTROY_DELAY_MS
 } = require('../config');
 const bent = require('bent');
 const BackgroundTaskManager = require('../utils/background-task-manager');
@@ -40,7 +36,7 @@ const dbUtils = require('../utils/db-utils');
 const BADPRECONDITIONS = 'preconditions not met';
 const CALLER_CANCELLED_ERR_MSG = 'Response not sent due to unknown transaction';
 const { NonFatalTaskError} = require('../utils/error');
-const { sleepFor } = require('../utils/helpers');
+const { createMediaEndpoint } = require('../utils/media-endpoint');
 const sqlRetrieveQueueEventHook = `SELECT * FROM webhooks 
 WHERE webhook_sid = 
 (
@@ -83,6 +79,7 @@ class CallSession extends Emitter {
    this.stickyEventEmitter = new StickyEventEmitter();
    this.stickyEventEmitter.onSuccess = () => {
      this.taskInProgress = null;
+      this.stickyEventEmitter.destroy();
    };
    this.backgroundTaskManager = new BackgroundTaskManager({
      cs: this,
@@ -219,6 +216,18 @@ class CallSession extends Emitter {
    this._synthesizer = synth;
  }

+  /**
+   * Say stream enabled
+   */
+
+  get autoStreamTts() {
+    return this._autoStreamTts || false;
+  }
+
+  set autoStreamTts(i) {
+    this._autoStreamTts = i;
+  }
+
  /**
   * ASR TTS fallback
   */
@@ -1084,6 +1093,7 @@ class CallSession extends Emitter {
          return {
            api_key: credential.api_key,
            model_id: credential.model_id,
+            stt_model_id: credential.stt_model_id,
            embedding: credential.embedding,
            options: credential.options
          };
@@ -1095,10 +1105,18 @@ class CallSession extends Emitter {
            options: credential.options
          };
        }
+        else if ('inworld' === vendor) {
+          return {
+            api_key: credential.api_key,
+            model_id: credential.model_id,
+            options: credential.options
+          };
+        }
        else if ('assemblyai' === vendor) {
          return {
            speech_credential_sid: credential.speech_credential_sid,
-            api_key: credential.api_key
+            api_key: credential.api_key,
+            service_version: credential.service_version
          };
        }
        else if ('voxist' === vendor) {
@@ -1408,6 +1426,14 @@ class CallSession extends Emitter {
        method: 'POST'
      };
    }
+
+    /* if given a relative url then send to same base url as current session */
+    if (this.requestor._isRelativeUrl(opts.call_hook?.url)) {
+      opts.call_hook.url = `${this.requestor.baseUrl}${opts.call_hook?.url}`;
+    }
+    if (this.requestor._isRelativeUrl(opts.call_status_hook?.url)) {
+      opts.call_status_hook.url = `${this.requestor.baseUrl}${opts.call_status_hook?.url}`;
+    }
  }

  /**
@@ -1798,6 +1824,10 @@ Duration=${duration} `
      .catch((err) => this.logger.debug({err}, 'CallSession:_notifyTaskStatus - Error sending'));
  }

+  async _internalTtsStreamingBufferTokens(tokens) {
+    return await this.ttsStreamingBuffer?.bufferTokens(tokens) || {status: 'failed', reason: 'no tts streaming buffer'};
+  }
+
  _lccTtsFlush(opts) {
    this.ttsStreamingBuffer?.flush(opts);
  }
@@ -1927,10 +1957,12 @@ Duration=${duration} `
    this.stackIdx++;
    this.logger.debug({tasks: listTaskNames(tasks)},
      `CallSession:replaceApplication reset with ${tasks.length} new tasks, stack depth is ${this.stackIdx}`);
+    let curTaskKilled = false;
    if (this.currentTask) {
      this.logger.debug('CallSession:replaceApplication - killing current task ' +
        this.currentTask?.name + ', taskId: ' + this.currentTask.taskId);
      this.currentTask.kill(this, KillReason.Replaced);
+      curTaskKilled = true;
      this.currentTask = null;
    }
    else if (this.wakeupResolver) {
@@ -1938,7 +1970,8 @@ Duration=${duration} `
      this.wakeupResolver({reason: 'new tasks'});
      this.wakeupResolver = null;
    }
-    if ((!this.currentTask || this.currentTask === undefined) && this.isCurTaskPlay) {
+    // if currentTask which is play, already got killed, no need to call uuid_break
+    if (!curTaskKilled && (!this.currentTask || this.currentTask === undefined) && this.isCurTaskPlay) {
      this.logger.debug(`CallSession:replaceApplication - emitting uuid_break, taskId: ${this.taskInProgress?.taskId}`);
      this.stickyEventEmitter.emit('uuid_break', this.taskInProgress);
    }
@@ -2281,8 +2314,7 @@ Duration=${duration} `

    // need to allocate an endpoint
    try {
-      if (!this.ms) this.ms = this.getMS();
-      const ep = await this.ms.createEndpoint({
+      const ep = await this._createMediaEndpoint({
        headers: {
          'X-Jambones-Call-ID': this.callId,
        },
@@ -2291,7 +2323,6 @@ Duration=${duration} `
      //ep.cs = this;
      this.ep = ep;
      this.logger.info(`allocated endpoint ${ep.uuid}`);
-      this._configMsEndpoint();

      this.ep.on('destroy', () => {
        this.logger.debug(`endpoint was destroyed!! ${this.ep.uuid}`);
@@ -2362,9 +2393,6 @@ Duration=${duration} `
      this.logger.error('CallSession:replaceEndpoint cannot be called without stable dlg');
      return;
    }
-    // When this call kicked out from conference, session need to replace endpoint
-    // but this.ms might be undefined/null at this case.
-    this.ms = this.ms || this.getMS();
    // Destroy previous ep if it's still running.
    if (this.ep?.connected) this.ep.destroy();

@@ -2389,8 +2417,7 @@ Duration=${duration} `
     * This prevents call failures during media renegotiation.
     */

-    this.ep = await this.ms.createEndpoint();
-    this._configMsEndpoint();
+    this.ep = await this._createMediaEndpoint();

    const sdp = await this.dlg.modify(this.ep.local.sdp);
    await this.ep.modify(sdp);
@@ -2650,15 +2677,8 @@ Duration=${duration} `
  async createOrRetrieveEpAndMs() {
    if (this.ms && this.ep) return {ms: this.ms, ep: this.ep};

-    // get a media server
-    if (!this.ms) {
-      const ms = this.srf.locals.getFreeswitch();
-      if (!ms) throw new Error('no available freeswitch');
-      this.ms = ms;
-    }
    if (!this.ep) {
-      this.ep = await this.ms.createEndpoint({remoteSdp: this.req.body});
-      this._configMsEndpoint();
+      this.ep = await this._createMediaEndpoint({remoteSdp: this.req.body});
    }
    return {ms: this.ms, ep: this.ep};
  }
@@ -2811,8 +2831,7 @@ Duration=${duration} `
  async reAnchorMedia(currentMediaRoute = MediaPath.PartialMedia) {
    assert(this.dlg && this.dlg.connected && !this.ep);

-    this.ep = await this.ms.createEndpoint({remoteSdp: this.dlg.remote.sdp});
-    this._configMsEndpoint();
+    this.ep = await this._createMediaEndpoint({remoteSdp: this.dlg.remote.sdp});
    await this.dlg.modify(this.ep.local.sdp, {
      headers: {
        'X-Reason': 'anchor-media'
@@ -2887,59 +2906,13 @@ Duration=${duration} `
    }
  }

-  _configMsEndpoint() {
-    this._enableInbandDtmfIfRequired(this.ep);
-    this.ep.once('destroy', this._handleMediaTimeout.bind(this));
-    const opts = {
-      ...(this.onHoldMusic && {holdMusic: `shout://${this.onHoldMusic.replace(/^https?:\/\//, '')}`}),
-      ...(JAMBONES_USE_FREESWITCH_TIMER_FD && {timer_name: 'timerfd'}),
-      ...(JAMBONES_MEDIA_TIMEOUT_MS && {media_timeout: JAMBONES_MEDIA_TIMEOUT_MS}),
-      ...(JAMBONES_MEDIA_HOLD_TIMEOUT_MS && {media_hold_timeout: JAMBONES_MEDIA_HOLD_TIMEOUT_MS})
-    };
-    if (Object.keys(opts).length > 0) {
-      this.ep.set(opts);
-    }
-
-    const origDestroy = this.ep.destroy.bind(this.ep);
-    this.ep.destroy = async() => {
-      try {
-        if (this.currentTask?.name === TaskName.Transcribe && JAMBONES_TRANSCRIBE_EP_DESTROY_DELAY_MS) {
-          // transcribe task is being used, wait for some time before destroy
-          // if final transcription is received but endpoint is already closed,
-          // freeswitch module will not be able to send the transcription
-
-          this.logger.debug('callSession:_configMsEndpoint -' +
-            ' transcribe task, wait for some time before destroy');
-          await sleepFor(JAMBONES_TRANSCRIBE_EP_DESTROY_DELAY_MS);
-        }
-        await origDestroy();
-      } catch (err) {
-        this.logger.error(err, 'callSession:_configMsEndpoint - error destroying endpoint');
-      }
-    };
-  }
-
  async _handleMediaTimeout(evt) {
-    if (evt.reason === 'MEDIA_TIMEOUT' && !this.callGone) {
+    if (evt?.reason === 'MEDIA_TIMEOUT' && !this.callGone) {
      this.logger.info('CallSession:_handleMediaTimeout: received MEDIA_TIMEOUT, hangup the call');
      this._jambonzHangup('Media Timeout');
    }
  }

-  async _enableInbandDtmfIfRequired(ep) {
-    if (ep.inbandDtmfEnabled) return;
-    // only enable inband dtmf detection if voip carrier dtmf_type === tones
-    if (this.inbandDtmfEnabled) {
-      // https://developer.signalwire.com/freeswitch/FreeSWITCH-Explained/Modules/mod-dptools/6587132/#0-about
-      try {
-        ep.execute('start_dtmf');
-        ep.inbandDtmfEnabled = true;
-      } catch (err) {
-        this.logger.info(err, 'CallSession:_enableInbandDtmf - error enable inband DTMF');
-      }
-    }
-  }
-
  /**
   * notifyTaskError - only used when websocket connection is used instead of webhooks
   */
@@ -2991,6 +2964,18 @@ Duration=${duration} `
    });
  }

+  async _enableInbandDtmfIfRequired(ep) {
+    if (ep.inbandDtmfEnabled) return;
+    // only enable inband dtmf detection if voip carrier dtmf_type === tones
+    if (this.inbandDtmfEnabled) {
+      // https://developer.signalwire.com/freeswitch/FreeSWITCH-Explained/Modules/mod-dptools/6587132/#0-about
+      ep.execute('start_dtmf').catch((err) => {
+        this.logger.info({err}, 'CallSession:_enableInbandDtmfIfRequired - error starting DTMF');
+      });
+      ep.inbandDtmfEnabled = true;
+    }
+  }
+
  _clearTasks(backgroundGather, evt) {
    if (this.requestor instanceof WsRequestor && !backgroundGather.cleared) {
      this.logger.debug({evt}, 'CallSession:_clearTasks on event from background gather');
@@ -3098,6 +3083,16 @@ Duration=${duration} `
    }
  }

+  async _createMediaEndpoint(drachtioFsmrfOptions = {}) {
+    return await createMediaEndpoint(this.srf, this.logger, {
+      activeMs: this.getMS(),
+      drachtioFsmrfOptions,
+      onHoldMusic: this.onHoldMusic,
+      inbandDtmfEnabled: this.inbandDtmfEnabled,
+      mediaTimeoutHandler: this._handleMediaTimeout.bind(this),
+    });
+  }
+
  getFormattedConversation(numTurns) {
    const turns = this.conversationTurns.slice(-numTurns);
    if (turns.length === 0) return null;
--- a/lib/session/rest-call-session.js
+++ b/lib/session/rest-call-session.js
@@ -27,10 +27,13 @@ class RestCallSession extends CallSession {
    }

    this.on('callStatusChange', this._notifyCallStatusChange.bind(this));
-    this._notifyCallStatusChange({
-      callStatus: CallStatus.Trying,
-      sipStatus: 100,
-      sipReason: 'Trying'
+
+    setImmediate(() => {
+      this._notifyCallStatusChange({
+        callStatus: CallStatus.Trying,
+        sipStatus: 100,
+        sipReason: 'Trying'
+      });
    });
  }

--- a/lib/session/siprec-call-session.js
+++ b/lib/session/siprec-call-session.js
@@ -45,12 +45,11 @@ class SipRecCallSession extends InboundCallSession {

  async answerSipRecCall() {
    try {
-      this.ms = this.getMS();
      let remoteSdp = this.sdp1.replace(/sendonly/, 'sendrecv');
-      this.ep = await this.ms.createEndpoint({remoteSdp});
+      this.ep = await this._createMediaEndpoint({remoteSdp});
      //this.logger.debug({remoteSdp, localSdp: this.ep.local.sdp}, 'SipRecCallSession - allocated first endpoint');
      remoteSdp = this.sdp2.replace(/sendonly/, 'sendrecv');
-      this.ep2 = await this.ms.createEndpoint({remoteSdp});
+      this.ep2 = await this._createMediaEndpoint({remoteSdp});
      //this.logger.debug({remoteSdp, localSdp: this.ep2.local.sdp}, 'SipRecCallSession - allocated second endpoint');
      await this.ep.bridge(this.ep2);
      const combinedSdp = await createSipRecPayload(this.ep.local.sdp, this.ep2.local.sdp, this.logger);
--- a/lib/tasks/alert.js
+++ b/lib/tasks/alert.js
@@ -0,0 +1,31 @@
+const Task = require('./task');
+const {TaskName} = require('../utils/constants');
+
+class TaskAlert extends Task {
+  constructor(logger, opts, parentTask) {
+    super(logger, opts);
+    this.message = this.data.message;
+  }
+
+  get name() { return TaskName.Alert; }
+
+  async exec(cs) {
+    const {srf, accountSid:account_sid, callSid:target_sid, applicationSid:application_sid} = cs;
+    const {writeAlerts, AlertType} = srf.locals;
+    await super.exec(cs);
+    writeAlerts({
+      account_sid,
+      alert_type: AlertType.APPLICATION,
+      detail: `Application SID ${application_sid}`,
+      message: this.message,
+      target_sid
+    }).catch((err) => this.logger.info({err}, 'Error generating alert application'));
+  }
+
+  async kill(cs) {
+    super.kill(cs);
+    this.notifyTaskDone();
+  }
+}
+
+module.exports = TaskAlert;
--- a/lib/tasks/config.js
+++ b/lib/tasks/config.js
@@ -17,7 +17,8 @@ class TaskConfig extends Task {
      'actionHookDelayAction',
      'boostAudioSignal',
      'vad',
-      'ttsStream'
+      'ttsStream',
+      'autoStreamTts'
    ].forEach((k) => this[k] = this.data[k] || {});

    if ('notifyEvents' in this.data) {
@@ -117,6 +118,7 @@ class TaskConfig extends Task {
    if (this.hasTtsStream) {
      phrase.push(`${this.ttsStream.enable ? 'enable' : 'disable'} ttsStream`);
    }
+    if ('autoStreamTts' in this.data) phrase.push(`enable Say.stream value ${this.data.autoStreamTts ? 'on' : 'off'}`);
    return `${this.name}{${phrase.join(',')}}`;
  }

@@ -296,6 +298,11 @@ class TaskConfig extends Task {
      });
    }

+    if ('autoStreamTts' in this.data) {
+      this.logger.info(`Config: autoStreamTts set to ${this.data.autoStreamTts}`);
+      cs.autoStreamTts = this.data.autoStreamTts;
+    }
+
    if (this.hasFillerNoise) {
      const {enable, ...opts} = this.fillerNoise;
      this.logger.info({fillerNoise: this.fillerNoise}, 'Config: fillerNoise');
@@ -330,7 +337,9 @@ class TaskConfig extends Task {
      };
      this.logger.info({opts: this.gatherOpts}, 'Config: enabling ttsStream');
      cs.enableBackgroundTtsStream(this.sayOpts);
-    } else if (!this.ttsStream.enable) {
+    }
+    // only disable ttsStream if it specifically set to false
+    else if (this.ttsStream.enable === false) {
      this.logger.info('Config: disabling ttsStream');
      cs.disableTtsStream();
    }
--- a/lib/tasks/dial.js
+++ b/lib/tasks/dial.js
@@ -271,7 +271,12 @@ class TaskDial extends Task {
    }
    this._removeDtmfDetection(cs.dlg);
    this._removeDtmfDetection(this.dlg);
-    await this._killOutdials();
+    try {
+      await this._killOutdials();
+    }
+    catch (err) {
+      this.logger.info({err}, 'Dial:kill - error killing outdials');
+    }
    if (this.sd) {
      const byeReasonHeader = this.killReason === KillReason.MediaTimeout ? 'Media Timeout' : undefined;
      this.sd.kill(byeReasonHeader);
@@ -281,13 +286,22 @@ class TaskDial extends Task {
    }
    if (this.callSid) sessionTracker.remove(this.callSid);
    if (this.listenTask) {
-      await this.listenTask.kill(cs);
-      this.listenTask.span.end();
+      try {
+        await this.listenTask.kill(cs);
+        this.listenTask?.span?.end();
+      }
+      catch (err) {
+        this.logger.error({err}, 'Dial:kill - error killing listen task');
+      }
      this.listenTask = null;
    }
    if (this.transcribeTask) {
-      await this.transcribeTask.kill(cs);
-      this.transcribeTask.span.end();
+      try {
+        await this.transcribeTask.kill(cs);
+        this.transcribeTask?.span?.end();
+      } catch (err) {
+        this.logger.error({err}, 'Dial:kill - error killing transcribe task');
+      }
      this.transcribeTask = null;
    }
    this.notifyTaskDone();
@@ -383,7 +397,11 @@ class TaskDial extends Task {
            ...customHeaders
          }
        }, httpHeaders);
-        if (json && Array.isArray(json)) {
+        res.send(202);
+        this.logger.info('DialTask:handleRefer - sent 202 Accepted');
+
+        const returnedInstructions = !!json && Array.isArray(json);
+        if (returnedInstructions) {
          try {
            const logger = isChild ? this.logger : this.sd.logger;
            const tasks = normalizeJambones(logger, json).map((tdata) => makeTask(this.logger, tdata));
@@ -401,16 +419,21 @@ class TaskDial extends Task {
                /* need to update the callSid of the child with its own (new) AdultingCallSession */
                sessionTracker.add(adultingSession.callSid, adultingSession);
              }
+              if (this.ep) this.ep.unbridge();
+
+              /* if we got the REFER on the parent leg, end the dial task after completing the refer */
+              if (!isChild) {
+                logger.info('DialTask:handleRefer - killing dial task after processing REFER on parent leg');
+                cs.currentTask?.kill(cs, KillReason.ReferComplete);
+              }
            }
          } catch (err) {
            this.logger.info(err, 'Dial:handleRefer - error setting new application after receiving REFER');
          }
        }
-        //caller and callee legs are briged together, accept refer with 202 will release callee leg endpoint
-        //that makes freeswitch release endpoint for caller leg.
-        if (this.ep) this.ep.unbridge();
-        res.send(202);
-        this.logger.info('DialTask:handleRefer - sent 202 Accepted');
+        else {
+          this.logger.info('DialTask:handleRefer - no tasks returned from referHook, not setting new application');
+        }
      } catch (err) {
        this.logger.info({err}, 'DialTask:handleRefer - error processing incoming REFER');
        res.send(err.statusCode || 501);
--- a/lib/tasks/dub.js
+++ b/lib/tasks/dub.js
@@ -83,7 +83,8 @@ class TaskDub extends TtsTask {
      action: 'playOnTrack',
      track: this.track,
      play: this.play,
-      loop: this.loop ? 'loop' : 'once',
+      // drachtio-fsmrf will convert loop from boolean to 'loop' or 'once'
+      loop: this.loop,
      gain: this.gain
    });
  }
--- a/lib/tasks/gather.js
+++ b/lib/tasks/gather.js
@@ -12,6 +12,7 @@ const {
  JambonzTranscriptionEvents,
  AssemblyAiTranscriptionEvents,
  VoxistTranscriptionEvents,
+  CartesiaTranscriptionEvents,
  OpenAITranscriptionEvents,
  VadDetection,
  VerbioTranscriptionEvents,
@@ -138,7 +139,11 @@ class TaskGather extends SttTask {
    try {
      await this.handling(cs, obj);
    } catch (error) {
-      if (error instanceof SpeechCredentialError) {
+      if (
+        // avoid bargein task with sticky will restart forever
+        // throw exception to stop the loop.
+        !this.sticky &&
+        error instanceof SpeechCredentialError) {
        this.logger.info('Gather failed due to SpeechCredentialError, finished!');
        this.notifyTaskDone();
        return;
@@ -546,6 +551,17 @@ class TaskGather extends SttTask {
          this._onVendorConnectFailure.bind(this, cs, ep));
        break;

+      case 'cartesia':
+        this.bugname = `${this.bugname_prefix}cartesia_transcribe`;
+        this.addCustomEventListener(ep, CartesiaTranscriptionEvents.Transcription,
+          this._onTranscription.bind(this, cs, ep));
+        this.addCustomEventListener(
+          ep, CartesiaTranscriptionEvents.Connect, this._onVendorConnect.bind(this, cs, ep));
+        this.addCustomEventListener(ep, CartesiaTranscriptionEvents.Error, this._onVendorError.bind(this, cs, ep));
+        this.addCustomEventListener(ep, CartesiaTranscriptionEvents.ConnectFailure,
+          this._onVendorConnectFailure.bind(this, cs, ep));
+        break;
+
      case 'speechmatics':
        this.bugname = `${this.bugname_prefix}speechmatics_transcribe`;
        this.addCustomEventListener(
@@ -828,6 +844,10 @@ class TaskGather extends SttTask {
  }

  _onTranscription(cs, ep, evt, fsEvent) {
+    // check if we are in graceful shutdown mode
+    if (ep.gracefulShutdownResolver) {
+      ep.gracefulShutdownResolver();
+    }
    // make sure this is not a transcript from answering machine detection
    const bugname = fsEvent.getHeader('media-bugname');
    const finished = fsEvent.getHeader('transcription-session-finished');
@@ -1076,7 +1096,8 @@ class TaskGather extends SttTask {
    if (this.canFallback) {
      ep.stopTranscription({
        vendor: this.vendor,
-        bugname: this.bugname
+        bugname: this.bugname,
+        gracefulShutdown: false
      })
        .catch((err) => this.logger.error({err}, `Error stopping transcription for primary vendor ${this.vendor}`));
      try {
--- a/lib/tasks/llm/llms/ultravox_s2s.js
+++ b/lib/tasks/llm/llms/ultravox_s2s.js
@@ -32,12 +32,14 @@ class TaskLlmUltravox_S2S extends Task {
    this.auth = this.parent.auth;
    this.connectionOptions = this.parent.connectOptions;

-    const {apiKey} = this.auth || {};
+    const {apiKey, agent_id} = this.auth || {};
    if (!apiKey) throw new Error('auth.apiKey is required for Vendor: Ultravox');
    this.apiKey = apiKey;
+    this.agentId = agent_id;
    this.actionHook = this.data.actionHook;
    this.eventHook = this.data.eventHook;
    this.toolHook = this.data.toolHook;
+    this.llmOptions = this.data.llmOptions || {};

    this.results = {
      completionReason: 'normal conversation end'
@@ -105,24 +107,29 @@ class TaskLlmUltravox_S2S extends Task {
      }
      );
      // merge with any existing tools
-      this.data.llmOptions.selectedTools = [
+      this.llmOptions.selectedTools = [
        ...convertedTools,
-        ...(this.data.llmOptions.selectedTools || [])
+        ...(this.llmOptions.selectedTools || [])
      ];
    }

    const payload = {
-      ...this.data.llmOptions,
-      model: this.model,
+      ...this.llmOptions,
+      ...(!this.agentId && {
+        model: this.model,
+      }),
      medium: {
-        ...(this.data.llmOptions.medium || {}),
+        ...(this.llmOptions.medium || {}),
        serverWebSocket: {
          inputSampleRate: 8000,
          outputSampleRate: 8000,
        }
      }
    };
-    const {statusCode, body} = await request('https://api.ultravox.ai/api/calls', {
+    const baseUrl = 'https://api.ultravox.ai';
+    const url = this.agentId ?
+      `${baseUrl}/api/agents/${this.agentId}/calls` : `${baseUrl}/api/calls`;
+    const {statusCode, body} = await request(url, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
--- a/lib/tasks/make_task.js
+++ b/lib/tasks/make_task.js
@@ -96,6 +96,9 @@ function makeTask(logger, obj, parent) {
    case TaskName.Tag:
      const TaskTag = require('./tag');
      return new TaskTag(logger, data, parent);
+    case TaskName.Alert:
+      const TaskAlert = require('./alert');
+      return new TaskAlert(logger, data, parent);
  }

  // should never reach
--- a/lib/tasks/play.js
+++ b/lib/tasks/play.js
@@ -48,7 +48,7 @@ class TaskPlay extends Task {
         */
        ep.once('playback-start', (evt) => {
          this.logger.debug({evt}, 'Play got playback-start');
-          this.cs.stickyEventEmitter.once('uuid_break', (t) => {
+          this.cs.stickyEventEmitter?.once('uuid_break', (t) => {
            if (t?.taskId === this.taskId) {
              this.logger.debug(`Play got kill-playback, executing uuid_break, taskId: ${t?.taskId}`);
              this.ep.api('uuid_break', this.ep.uuid).catch((err) => this.logger.info(err, 'Error killing audio'));
--- a/lib/tasks/redirect.js
+++ b/lib/tasks/redirect.js
@@ -17,28 +17,33 @@ class TaskRedirect extends Task {
  async exec(cs) {
    await super.exec(cs);

-    if (cs.requestor instanceof WsRequestor && cs.application.requestor._isAbsoluteUrl(this.actionHook)) {
-      this.logger.info(`Task:performAction redirecting to ${this.actionHook}, requires new ws connection`);
-      try {
-        this.cs.requestor.close();
-        const requestor = new WsRequestor(this.logger, cs.accountSid, {url: this.actionHook}, this.webhook_secret) ;
-        this.cs.application.requestor = requestor;
-      } catch (err) {
-        this.logger.info(err, `Task:performAction error redirecting to ${this.actionHook}`);
-      }
-    } else if (cs.application.requestor._isAbsoluteUrl(this.actionHook)) {
-      const baseUrl =  this.cs.application.requestor.baseUrl;
-      const newUrl = URL.parse(this.actionHook);
-      const newBaseUrl = newUrl.protocol + '//' + newUrl.host;
-      if (baseUrl != newBaseUrl) {
+    const isAbsoluteUrl = cs.application?.requestor?._isAbsoluteUrl(this.actionHook);
+
+    if (isAbsoluteUrl) {
+      this.logger.info(`TaskRedirect redirecting to new absolute URL ${this.actionHook}, requires new requestor`);
+
+      if (cs.requestor instanceof WsRequestor) {
        try {
-          this.logger.info(`Task:redirect updating base url to ${newBaseUrl}`);
-          const newRequestor = new HttpRequestor(this.logger, cs.accountSid, {url: this.actionHook},
-            cs.accountInfo.account.webhook_secret);
-          this.cs.requestor.removeAllListeners();
-          this.cs.application.requestor = newRequestor;
+          const requestor = new WsRequestor(this.logger, cs.accountSid, {url: this.actionHook},
+            cs.accountInfo.account.webhook_secret) ;
+          cs.requestor.emit('handover', requestor);
        } catch (err) {
-          this.logger.info(err, `Task:redirect error updating base url to ${this.actionHook}`);
+          this.logger.info(err, `TaskRedirect error redirecting to ${this.actionHook}`);
+        }
+      }
+      else {
+        const baseUrl =  this.cs.application.requestor.baseUrl;
+        const newUrl = URL.parse(this.actionHook);
+        const newBaseUrl = newUrl.protocol + '//' + newUrl.host;
+        if (baseUrl != newBaseUrl) {
+          try {
+            this.logger.info(`Task:redirect updating base url to ${newBaseUrl}`);
+            const newRequestor = new HttpRequestor(this.logger, cs.accountSid, {url: this.actionHook},
+              cs.accountInfo.account.webhook_secret);
+            cs.requestor.emit('handover', newRequestor);
+          } catch (err) {
+            this.logger.info(err, `TaskRedirect error updating base url to ${this.actionHook}`);
+          }
        }
      }
    }
--- a/lib/tasks/rest_dial.js
+++ b/lib/tasks/rest_dial.js
@@ -77,6 +77,7 @@ class TaskRestDial extends Task {
      const httpHeaders = b3 && {b3};
      const params = {
        ...(cs.callInfo.toJSON()),
+        ...(this.env_vars && {env_vars: this.env_vars}),
        defaults: {
          synthesizer: {
            vendor: cs.speechSynthesisVendor,
--- a/lib/tasks/say.js
+++ b/lib/tasks/say.js
@@ -3,24 +3,32 @@ const TtsTask = require('./tts-task');
 const {TaskName, TaskPreconditions} = require('../utils/constants');
 const pollySSMLSplit = require('polly-ssml-split');
 const { SpeechCredentialError } = require('../utils/error');
+const { sleepFor } = require('../utils/helpers');

-const breakLengthyTextIfNeeded = (logger,  text) => {
-  const chunkSize = 1000;
+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 = 900;
  const isSSML = text.startsWith('<speak>');
-  if (text.length <= chunkSize || !isSSML) return [text];
  const options = {
-    // MIN length
    softLimit: 100,
-    // MAX length, exclude 15 characters <speak></speak>
    hardLimit: chunkSize - 15,
-    // Set of extra split characters (Optional property)
    extraSplitChars: ',;!?',
  };
  pollySSMLSplit.configure(options);
  try {
-    return pollySSMLSplit.split(text);
+    if (text.length <= chunkSize) return [text];
+    if (isSSML) {
+      return pollySSMLSplit.split(text);
+    } else {
+      // Wrap with <speak> and split
+      const wrapped = `<speak>${text}</speak>`;
+      const splitArr = pollySSMLSplit.split(wrapped);
+      // Remove <speak> and </speak> from each chunk
+      return splitArr.map((str) => str.replace(/^<speak>/, '').replace(/<\/speak>$/, ''));
+    }
  } catch (err) {
-    logger.info({err}, 'Error spliting SSML long text');
+    logger.info({err}, 'Error splitting SSML long text');
    return [text];
  }
 };
@@ -39,6 +47,9 @@ class TaskSay extends TtsTask {
    assert.ok((typeof this.data.text === 'string' || Array.isArray(this.data.text)) || this.data.stream === true,
      'Say: either text or stream:true is required');

+    this.text = this.data.text ? (Array.isArray(this.data.text) ? this.data.text : [this.data.text])
+      .map((t) => breakLengthyTextIfNeeded(this.logger, t))
+      .flat() : [];

    if (this.data.stream === true) {
      this._isStreamingTts = true;
@@ -46,10 +57,6 @@ class TaskSay extends TtsTask {
    }
    else {
      this._isStreamingTts = false;
-      this.text = (Array.isArray(this.data.text) ? this.data.text : [this.data.text])
-        .map((t) => breakLengthyTextIfNeeded(this.logger, t))
-        .flat();
-
      this.loop = this.data.loop || 1;
      this.isHandledByPrimaryProvider = true;
    }
@@ -85,6 +92,10 @@ class TaskSay extends TtsTask {
    }

    try {
+      this._isStreamingTts = this._isStreamingTts || cs.autoStreamTts;
+      if (this.isStreamingTts) {
+        this.closeOnStreamEmpty = this.closeOnStreamEmpty || this.text.length !== 0;
+      }
      if (this.isStreamingTts) await this.handlingStreaming(cs, obj);
      else await this.handling(cs, obj);
      this.emit('playDone');
@@ -116,6 +127,54 @@ class TaskSay extends TtsTask {

      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) {
+          const result = await cs._internalTtsStreamingBufferTokens(t);
+          if (result?.status === 'failed') {
+            if (result.reason === 'full') {
+              // Retry logic for full buffer
+              const maxRetries = 5;
+              let backoffMs = 1000;
+              for (let retryCount = 0; retryCount < maxRetries && !this.killed; retryCount++) {
+                this.logger.info(
+                  `TaskSay:handlingStreaming - retry ${retryCount + 1}/${maxRetries} after ${backoffMs}ms`);
+                await sleepFor(backoffMs);
+
+                const retryResult = await cs._internalTtsStreamingBufferTokens(t);
+
+                // Exit retry loop on success
+                if (retryResult?.status !== 'failed') {
+                  break;
+                }
+
+                // Handle failure for reason other than full buffer
+                if (retryResult.reason !== 'full') {
+                  this.logger.info(
+                    {result: retryResult}, 'TaskSay:handlingStreaming - TTS stream failed to buffer tokens');
+                  throw new Error(`TTS stream failed to buffer tokens: ${retryResult.reason}`);
+                }
+
+                // Last retry attempt failed
+                if (retryCount === maxRetries - 1) {
+                  this.logger.info('TaskSay:handlingStreaming - Maximum retries exceeded for full buffer');
+                  throw new Error('TTS stream buffer full - maximum retries exceeded');
+                }
+
+                // Increase backoff for next retry
+                backoffMs = Math.min(backoffMs * 1.5, 10000);
+              }
+            } else {
+              // Immediate failure for non-full buffer issues
+              this.logger.info({result}, 'TaskSay:handlingStreaming - TTS stream failed to buffer tokens');
+              throw new Error(`TTS stream failed to buffer tokens: ${result.reason}`);
+            }
+          } else {
+            await cs._lccTtsFlush();
+          }
+        }
+      }
    } catch (err) {
      this.logger.info({err}, 'TaskSay:handlingStreaming - Error setting channel vars');
      cs.requestor?.request('tts:streaming-event', '/streaming-event', {event_type: 'stream_closed'})
@@ -188,6 +247,7 @@ class TaskSay extends TtsTask {
        throw new SpeechCredentialError(error.message);
      }
    };
+
    let filepath;
    try {
      filepath = await this._synthesizeWithSpecificVendor(cs, ep, {vendor, language, voice, label});
@@ -204,65 +264,119 @@ class TaskSay extends TtsTask {
          await this.playToConfMember(ep, memberId, confName, confUuid, filepath[segment]);
        }
        else {
+          let playbackId;
          const isStreaming = filepath[segment].startsWith('say:{');
          if (isStreaming) {
            const arr = /^say:\{.*\}\s*(.*)$/.exec(filepath[segment]);
            if (arr) this.logger.debug(`Say:exec sending streaming tts request: ${arr[1].substring(0, 64)}..`);
          }
-          else this.logger.debug(`Say:exec sending ${filepath[segment].substring(0, 64)}`);
+          else {
+            this.logger.debug(`Say:exec sending ${filepath[segment].substring(0, 64)}`);
+          }
+
+          const onPlaybackStop = (evt) => {
+            try {
+              this.logger.debug({evt},
+                `Say got playback-stop ${evt.variable_tts_playback_id ? evt.variable_tts_playback_id : ''}`);
+
+              /**
+               * If we got a playback id on both the start and stop events, and they don't match,
+               * then we must have received a playback-stop event for an earlier play request.
+               */
+              const unmatchedResponse = (!!playbackId && !!evt.variable_tts_playback_id) &&
+                evt.variable_tts_playback_id !== playbackId;
+              if (unmatchedResponse) {
+                this.logger.info({currentPlaybackId: playbackId, stopPPlaybackId: evt.variable_tts_playback_id},
+                  'Say:exec discarding playback-stop for earlier play');
+                ep.once('playback-stop',  this._boundOnPlaybackStop);
+
+                return;
+              }
+
+              this.notifyStatus({event: 'stop-playback'});
+              this.notifiedPlayBackStop = true;
+              const tts_error = evt.variable_tts_error;
+              // some tts vendor may not provide response code, so we default to 200
+              let response_code = 200;
+              // Check if any property ends with _response_code
+              for (const [key, value] of Object.entries(evt)) {
+                if (key.endsWith('_response_code')) {
+                  response_code = parseInt(value, 10);
+                  if (isNaN(response_code)) {
+                    this.logger.info(`Say:exec playback-stop - Invalid response code: ${value}`);
+                    response_code = 0;
+                  }
+                  break;
+                }
+              }
+
+              if (tts_error ||
+                // error response codes indicate failure
+                response_code <= 199 || response_code >= 300) {
+                writeAlerts({
+                  account_sid,
+                  alert_type: AlertType.TTS_FAILURE,
+                  vendor,
+                  detail: evt.variable_tts_error || `TTS playback failed with response code ${response_code}`,
+                  target_sid
+                }).catch((err) => this.logger.info({err}, 'Error generating alert for no tts'));
+              }
+              if (
+                !tts_error &&
+                //2xx response codes indicate success
+                199 < response_code && response_code < 300 &&
+                evt.variable_tts_cache_filename &&
+                !this.killed &&
+                // if tts cache is not disabled, add the file to cache
+                !this.disableTtsCache
+              ) {
+                const text = parseTextFromSayString(this.text[segment]);
+                addFileToCache(evt.variable_tts_cache_filename, {
+                  account_sid,
+                  vendor,
+                  language,
+                  voice,
+                  engine,
+                  model: this.model || this.model_id,
+                  text,
+                  instructions: this.instructions
+                }).catch((err) => this.logger.info({err}, 'Error adding file to cache'));
+              }
+
+              if (this._playResolve) {
+                (tts_error ||
+                  // error response codes indicate failure
+                  response_code <= 199 || response_code >= 300
+                ) ?
+                  this._playReject(
+                    new Error(evt.variable_tts_error || `TTS playback failed with response code ${response_code}`)
+                  ) : this._playResolve();
+              }
+            } catch (err) {
+              this.logger.info({err}, 'Error handling playback-stop event');
+            }
+          };
+          this._boundOnPlaybackStop = onPlaybackStop.bind(this);
+
          ep.once('playback-start', (evt) => {
-            this.logger.debug({evt}, 'Say got playback-start');
-            if (this.otelSpan) {
-              this._addStreamingTtsAttributes(this.otelSpan, evt, vendor);
-              this.otelSpan.end();
-              this.otelSpan = null;
-              if (evt.variable_tts_cache_filename) {
-                cs.trackTmpFile(evt.variable_tts_cache_filename);
+            try {
+              playbackId = evt.variable_tts_playback_id;
+              this.logger.debug({evt},
+                `Say got playback-start ${evt.variable_tts_playback_id ? evt.variable_tts_playback_id : ''}`);
+              if (this.otelSpan) {
+                this._addStreamingTtsAttributes(this.otelSpan, evt, vendor);
+                this.otelSpan.end();
+                this.otelSpan = null;
+                if (evt.variable_tts_cache_filename) {
+                  cs.trackTmpFile(evt.variable_tts_cache_filename);
+                }
              }
+            } catch (err) {
+              this.logger.info({err}, 'Error handling playback-start event');
            }
          });
-          ep.once('playback-stop', (evt) => {
-            this.logger.debug({evt}, 'Say got playback-stop');
-            this.notifyStatus({event: 'stop-playback'});
-            this.notifiedPlayBackStop = true;
-            const tts_error = evt.variable_tts_error;
-            let response_code = 200;
-            // Check if any property ends with _response_code
-            for (const [key, value] of Object.entries(evt)) {
-              if (key.endsWith('_response_code')) {
-                response_code = parseInt(value, 10) || 200;
-                break;
-              }
-            }
+          ep.once('playback-stop',  this._boundOnPlaybackStop);

-            if (tts_error) {
-              writeAlerts({
-                account_sid,
-                alert_type: AlertType.TTS_FAILURE,
-                vendor,
-                detail: evt.variable_tts_error,
-                target_sid
-              }).catch((err) => this.logger.info({err}, 'Error generating alert for no tts'));
-            }
-            if (!tts_error && response_code < 300 && evt.variable_tts_cache_filename && !this.killed) {
-              const text = parseTextFromSayString(this.text[segment]);
-              addFileToCache(evt.variable_tts_cache_filename, {
-                account_sid,
-                vendor,
-                language,
-                voice,
-                engine,
-                model: this.model || this.model_id,
-                text,
-                instructions: this.instructions
-              }).catch((err) => this.logger.info({err}, 'Error adding file to cache'));
-            }
-
-            if (this._playResolve) {
-              (tts_error || response_code >= 300) ? this._playReject(new Error(evt.variable_tts_error)) :
-                this._playResolve();
-            }
-          });
          // wait for playback-stop event received to confirm if the playback is successful
          this._playPromise = new Promise((resolve, reject) => {
            this._playResolve = resolve;
@@ -338,6 +452,7 @@ class TaskSay extends TtsTask {
          .replace('playht_', 'playht.')
          .replace('cartesia_', 'cartesia.')
          .replace('rimelabs_', 'rimelabs.')
+          .replace('inworld_', 'inworld.')
          .replace('verbio_', 'verbio.')
          .replace('elevenlabs_', 'elevenlabs.');
        if (spanMapping[newKey]) newKey = spanMapping[newKey];
@@ -402,6 +517,11 @@ const spanMapping = {
  'rimelabs.name_lookup_time_ms': 'name_lookup_ms',
  'rimelabs.connect_time_ms': 'connect_ms',
  'rimelabs.final_response_time_ms': 'final_response_ms',
+  // inworld
+  'inworld.name_lookup_time_ms': 'name_lookup_ms',
+  'inworld.connect_time_ms': 'connect_ms',
+  'inworld.final_response_time_ms': 'final_response_ms',
+  'inworld.x_envoy_upstream_service_time': 'upstream_service_time',
  // verbio
  'verbio.name_lookup_time_ms': 'name_lookup_ms',
  'verbio.connect_time_ms': 'connect_ms',
--- a/lib/tasks/transcribe.js
+++ b/lib/tasks/transcribe.js
@@ -14,6 +14,7 @@ const {
  TranscribeStatus,
  AssemblyAiTranscriptionEvents,
  VoxistTranscriptionEvents,
+  CartesiaTranscriptionEvents,
  OpenAITranscriptionEvents,
  VerbioTranscriptionEvents,
  SpeechmaticsTranscriptionEvents
@@ -136,13 +137,18 @@ class TaskTranscribe extends SttTask {
      stopTranscription = true;
      this.ep.stopTranscription({
        vendor: this.vendor,
-        bugname: this.bugname
+        bugname: this.bugname,
+        gracefulShutdown: this.paused ? false : true
      })
        .catch((err) => this.logger.info(err, 'Error TaskTranscribe:kill'));
    }
    if (this.transcribing2 && this.ep2?.connected) {
      stopTranscription = true;
-      this.ep2.stopTranscription({vendor: this.vendor, bugname: this.bugname})
+      this.ep2.stopTranscription({
+        vendor: this.vendor,
+        bugname: this.bugname,
+        gracefulShutdown: this.paused ? false : true
+      })
        .catch((err) => this.logger.info(err, 'Error TaskTranscribe:kill'));
    }

@@ -312,6 +318,17 @@ class TaskTranscribe extends SttTask {
          this._onVendorConnectFailure.bind(this, cs, ep, channel));
        break;

+      case 'cartesia':
+        this.bugname = `${this.bugname_prefix}cartesia_transcribe`;
+        this.addCustomEventListener(ep, CartesiaTranscriptionEvents.Transcription,
+          this._onTranscription.bind(this, cs, ep, channel));
+        this.addCustomEventListener(ep,
+          CartesiaTranscriptionEvents.Connect, this._onVendorConnect.bind(this, cs, ep));
+        this.addCustomEventListener(ep, CartesiaTranscriptionEvents.Error, this._onVendorError.bind(this, cs, ep));
+        this.addCustomEventListener(ep, CartesiaTranscriptionEvents.ConnectFailure,
+          this._onVendorConnectFailure.bind(this, cs, ep, channel));
+        break;
+
      case 'speechmatics':
        this.bugname = `${this.bugname_prefix}speechmatics_transcribe`;
        this.addCustomEventListener(
@@ -409,6 +426,10 @@ class TaskTranscribe extends SttTask {
  }

  async _onTranscription(cs, ep, channel, evt, fsEvent) {
+    // check if we are in graceful shutdown mode
+    if (ep.gracefulShutdownResolver) {
+      ep.gracefulShutdownResolver();
+    }
    // make sure this is not a transcript from answering machine detection
    const bugname = fsEvent.getHeader('media-bugname');
    const finished = fsEvent.getHeader('transcription-session-finished');
@@ -691,7 +712,8 @@ class TaskTranscribe extends SttTask {
    if (this.canFallback) {
      _ep.stopTranscription({
        vendor: this.vendor,
-        bugname: this.bugname
+        bugname: this.bugname,
+        gracefulShutdown: false
      })
        .catch((err) => this.logger.error({err}, `Error stopping transcription for primary vendor ${this.vendor}`));
      try {
--- a/lib/tasks/tts-task.js
+++ b/lib/tasks/tts-task.js
@@ -185,6 +185,9 @@ class TtsTask extends Task {
    } else if (vendor === 'rimelabs') {
      credentials = credentials || {};
      credentials.model_id = this.options.model_id || credentials.model_id;
+    } else if (vendor === 'inworld') {
+      credentials = credentials || {};
+      credentials.model_id = this.options.model_id || credentials.model_id;
    } else if (vendor === 'whisper') {
      credentials = credentials || {};
      credentials.model_id = this.options.model_id || credentials.model_id;
--- a/lib/utils/amd-utils.js
+++ b/lib/utils/amd-utils.js
@@ -418,7 +418,11 @@ module.exports = (logger) => {
    }

    if (ep.connected) {
-      ep.stopTranscription({vendor, bugname})
+      ep.stopTranscription({
+        vendor,
+        bugname,
+        gracefulShutdown: false
+      })
        .catch((err) => logger.info(err, 'stopAmd: Error stopping transcription'));
      task.emit('amd', {type: AmdEvents.Stopped});
      ep.execute('avmd_stop').catch((err) => this.logger.info(err, 'Error stopping avmd'));
--- a/lib/utils/base-requestor.js
+++ b/lib/utils/base-requestor.js
@@ -79,7 +79,44 @@ class BaseRequestor extends Emitter {
    return time.toFixed(0);
  }

+  _parseHashParams(hash) {
+    // Remove the leading # if present
+    const hashString = hash.startsWith('#') ? hash.substring(1) : hash;
+    // Use URLSearchParams for parsing
+    const params = new URLSearchParams(hashString);
+    // Convert to a regular object
+    const result = {};
+    for (const [key, value] of params.entries()) {
+      result[key] = value;
+    }
+    return result;
+  }

+  /**
+   * Check if the error should be retried based on retry policy
+   * @param {Error} err - The error that occurred
+   * @param {string[]} rpValues - Array of retry policy values
+   * @returns {boolean} True if the error should be retried
+   */
+  _shouldRetry(err, rpValues) {
+    // ct = connection timeout (ECONNREFUSED, ETIMEDOUT, etc)
+    const isCt = err.code === 'ECONNREFUSED' ||
+                 err.code === 'ETIMEDOUT' ||
+                 err.code === 'ECONNRESET' ||
+                 err.code === 'ECONNABORTED';
+    // rt = request timeout
+    const isRt = err.name === 'TimeoutError';
+    // 4xx = client errors
+    const is4xx = err.statusCode >= 400 && err.statusCode < 500;
+    // 5xx = server errors
+    const is5xx = err.statusCode >= 500 && err.statusCode < 600;
+    // Check if error type is included in retry policy
+    return rpValues.includes('all') ||
+           (isCt && rpValues.includes('ct')) ||
+           (isRt && rpValues.includes('rt')) ||
+           (is4xx && rpValues.includes('4xx')) ||
+           (is5xx && rpValues.includes('5xx'));
+  }
 }

 module.exports = BaseRequestor;
--- a/lib/utils/constants.json
+++ b/lib/utils/constants.json
@@ -1,5 +1,6 @@
 {
  "TaskName": {
+    "Alert": "alert",
    "Answer": "answer",
    "Conference": "conference",
    "Config": "config",
@@ -167,6 +168,12 @@
    "ConnectFailure": "voxist_transcribe::connect_failed",
    "Connect": "voxist_transcribe::connect"
  },
+  "CartesiaTranscriptionEvents": {
+    "Transcription": "cartesia_transcribe::transcription",
+    "Error": "cartesia_transcribe::error",
+    "ConnectFailure": "cartesia_transcribe::connect_failed",
+    "Connect": "cartesia_transcribe::connect"
+  },
  "VadDetection": {
    "Detection": "vad_detect:detection"
  },
@@ -237,6 +244,7 @@
  "KillReason": {
    "Hangup": "hangup",
    "Replaced": "replaced",
+    "ReferComplete": "refer-complete",
    "MediaTimeout": "media_timeout"
  },
  "HookMsgTypes": [
--- a/lib/utils/db-utils.js
+++ b/lib/utils/db-utils.js
@@ -110,6 +110,7 @@ const speechMapper = (cred) => {
      const o = JSON.parse(decrypt(credential));
      obj.api_key = o.api_key;
      obj.model_id = o.model_id;
+      obj.stt_model_id = o.stt_model_id;
      obj.embedding = o.embedding;
      obj.options = o.options;
    }
@@ -119,9 +120,16 @@ const speechMapper = (cred) => {
      obj.model_id = o.model_id;
      obj.options = o.options;
    }
+    else if ('inworld' === obj.vendor) {
+      const o = JSON.parse(decrypt(credential));
+      obj.api_key = o.api_key;
+      obj.model_id = o.model_id;
+      obj.options = o.options;
+    }
    else if ('assemblyai' === obj.vendor) {
      const o = JSON.parse(decrypt(credential));
      obj.api_key = o.api_key;
+      obj.service_version = o.service_version;
    }
    else if ('voxist' === obj.vendor) {
      const o = JSON.parse(decrypt(credential));
--- a/lib/utils/http-requestor.js
+++ b/lib/utils/http-requestor.js
@@ -43,6 +43,7 @@ class HttpRequestor extends BaseRequestor {

    this.method = hook.method || 'POST';
    this.authHeader = basicAuth(hook.username, hook.password);
+    this.backoffMs = 500;

    assert(this._isAbsoluteUrl(this.url));
    assert(['GET', 'POST'].includes(this.method));
@@ -136,25 +137,46 @@ class HttpRequestor extends BaseRequestor {

    let newClient;
    try {
+      this.backoffMs = 500;
+      // Parse URL and extract hash parameters for retry configuration
+      // Prepare request options - only do this once
+      const absUrl = this._isRelativeUrl(url) ? `${this.baseUrl}${url}` : url;
+      const parsedUrl = parseUrl(absUrl);
+      const hash = parsedUrl.hash || '';
+      const hashObj = hash ? this._parseHashParams(hash) : {};
+
+      // Retry policy: rp valid values: 4xx, 5xx, ct, rt, all, default is ct
+      // Retry count: rc valid values: 1-5, default is 0
+      // rc is the number of attempts we'll make AFTER the initial try
+      const rc = hash ? Math.min(Math.abs(parseInt(hashObj.rc || '0')), 5) : 0;
+      const rp = hashObj.rp || 'ct';
+      const rpValues = rp.split(',').map((v) => v.trim());
+      let retryCount = 0;
+
+      // Set up client, path and query parameters - only do this once
      let client, path, query;
      if (this._isRelativeUrl(url)) {
        client = this.client;
        path = url;
      }
      else {
-        const u = parseUrl(url);
-        if (u.resource === this._resource && u.port === this._port && u.protocol === this._protocol) {
+        if (parsedUrl.resource === this._resource &&
+          parsedUrl.port === this._port &&
+          parsedUrl.protocol === this._protocol) {
          client = this.client;
-          path = u.pathname;
-          query = u.query;
+          path = parsedUrl.pathname;
+          query = parsedUrl.query;
        }
        else {
-          if (u.port) client = newClient = new Client(`${u.protocol}://${u.resource}:${u.port}`);
-          else client = newClient = new Client(`${u.protocol}://${u.resource}`);
-          path = u.pathname;
-          query = u.query;
+          if (parsedUrl.port) {
+            client = newClient = new Client(`${parsedUrl.protocol}://${parsedUrl.resource}:${parsedUrl.port}`);
+          }
+          else client = newClient = new Client(`${parsedUrl.protocol}://${parsedUrl.resource}`);
+          path = parsedUrl.pathname;
+          query = parsedUrl.query;
        }
      }
+
      const sigHeader = this._generateSigHeader(payload, this.secret);
      const hdrs = {
        ...sigHeader,
@@ -162,20 +184,8 @@ class HttpRequestor extends BaseRequestor {
        ...httpHeaders,
        ...('POST' === method && {'Content-Type': 'application/json'})
      };
-      const absUrl = this._isRelativeUrl(url) ? `${this.baseUrl}${url}` : url;
-      this.logger.debug({url, absUrl, hdrs}, 'send webhook');
-      const {statusCode, headers, body} =  HTTP_PROXY_IP ? await request(
-        this.baseUrl,
-        {
-          path,
-          query,
-          method,
-          headers: hdrs,
-          ...('POST' === method && {body: JSON.stringify(payload)}),
-          timeout: HTTP_TIMEOUT,
-          followRedirects: false
-        }
-      ) : await client.request({
+
+      const requestOptions = {
        path,
        query,
        method,
@@ -183,14 +193,51 @@ class HttpRequestor extends BaseRequestor {
        ...('POST' === method && {body: JSON.stringify(payload)}),
        timeout: HTTP_TIMEOUT,
        followRedirects: false
-      });
-      if (![200, 202, 204].includes(statusCode)) {
-        const err = new HTTPResponseError(statusCode);
-        throw err;
-      }
-      if (headers['content-type']?.includes('application/json')) {
-        buf = await body.json();
+      };
+
+      // Simplified makeRequest function that just executes the HTTP request
+      const makeRequest = async() => {
+        this.logger.debug({url, absUrl, hdrs, retryCount},
+          `send webhook${retryCount > 0 ? ' (retry ' + retryCount + ')' : ''}`);
+
+        const {statusCode, headers, body} = HTTP_PROXY_IP ? await request(
+          this.baseUrl,
+          requestOptions
+        ) : await client.request(requestOptions);
+
+        if (![200, 202, 204].includes(statusCode)) {
+          const err = new HTTPResponseError(statusCode);
+          throw err;
+        }
+
+        if (headers['content-type']?.includes('application/json')) {
+          return await body.json();
+        }
+        return '';
+      };
+
+      while (true) {
+        try {
+          buf = await makeRequest();
+          break; // Success, exit the retry loop
+        } catch (err) {
+          retryCount++;
+
+          // Check if we should retry
+          if (retryCount <= rc && this._shouldRetry(err, rpValues)) {
+            this.logger.info(
+              {err, baseUrl: this.baseUrl, url, retryCount, maxRetries: rc},
+              `Retrying request (${retryCount}/${rc})`
+            );
+            const delay = this.backoffMs;
+            this.backoffMs = this.backoffMs < 2000 ? this.backoffMs * 2 : (this.backoffMs + 2000);
+            await new Promise((resolve) => setTimeout(resolve, delay));
+            continue;
+          }
+          throw err;
+        }
      }
+
      if (newClient) newClient.close();
    } catch (err) {
      if (err.statusCode) {
@@ -221,8 +268,8 @@ class HttpRequestor extends BaseRequestor {

    if (buf && (Array.isArray(buf) || type == 'llm:tool-call')) {
      this.logger.info({response: buf}, `HttpRequestor:request ${method} ${url} succeeded in ${rtt}ms`);
-      return buf;
    }
+    return buf;
  }
 }

--- a/lib/utils/media-endpoint.js
+++ b/lib/utils/media-endpoint.js
@@ -0,0 +1,115 @@
+const {
+  JAMBONES_USE_FREESWITCH_TIMER_FD,
+  JAMBONES_MEDIA_TIMEOUT_MS,
+  JAMBONES_MEDIA_HOLD_TIMEOUT_MS,
+  JAMBONES_TRANSCRIBE_EP_DESTROY_DELAY_MS,
+} = require('../config');
+const { sleepFor } = require('./helpers');
+
+const createMediaEndpoint = async(srf, logger, {
+  activeMs,
+  drachtioFsmrfOptions = {},
+  onHoldMusic,
+  inbandDtmfEnabled,
+  mediaTimeoutHandler,
+} = {}) => {
+  const { getFreeswitch } = srf.locals;
+  const ms = activeMs || getFreeswitch();
+  if (!ms)
+    throw new Error('no available Freeswitch for creating media endpoint');
+
+  const ep = await ms.createEndpoint(drachtioFsmrfOptions);
+
+  // Configure the endpoint
+  const opts = {
+    ...(onHoldMusic && {holdMusic: `shout://${onHoldMusic.replace(/^https?:\/\//, '')}`}),
+    ...(JAMBONES_USE_FREESWITCH_TIMER_FD && {timer_name: 'timerfd'}),
+    ...(JAMBONES_MEDIA_TIMEOUT_MS && {media_timeout: JAMBONES_MEDIA_TIMEOUT_MS}),
+    ...(JAMBONES_MEDIA_HOLD_TIMEOUT_MS && {media_hold_timeout: JAMBONES_MEDIA_HOLD_TIMEOUT_MS})
+  };
+  if (Object.keys(opts).length > 0) {
+    ep.set(opts);
+  }
+  // inbandDtmfEnabled
+  if (inbandDtmfEnabled) {
+    // https://developer.signalwire.com/freeswitch/FreeSWITCH-Explained/Modules/mod-dptools/6587132/#0-about
+    ep.execute('start_dtmf').catch((err) => {
+      logger.error('Error starting inband DTMF', { error: err });
+    });
+    ep.inbandDtmfEnabled = true;
+  }
+  // Handle Media Timeout
+  if (mediaTimeoutHandler) {
+    ep.once('destroy', (evt) => {
+      mediaTimeoutHandler(evt, ep);
+    });
+  }
+  // Handle graceful shutdown for endpoint if required
+  if (JAMBONES_TRANSCRIBE_EP_DESTROY_DELAY_MS > 0) {
+    const getEpGracefulShutdownPromise = () => {
+      if (!ep.gracefulShutdownPromise) {
+        ep.gracefulShutdownPromise = new Promise((resolve) => {
+          // this resolver will be called when stt task received transcription.
+          ep.gracefulShutdownResolver = () => {
+            resolve();
+            ep.gracefulShutdownPromise = null;
+          };
+        });
+      }
+      return ep.gracefulShutdownPromise;
+    };
+
+    const gracefulShutdownHandler = async() => {
+      // resolve when one of the following happens:
+      // 1. stt task received transcription
+      // 2. JAMBONES_TRANSCRIBE_EP_DESTROY_DELAY_MS passed
+      await Promise.race([
+        getEpGracefulShutdownPromise(),
+        sleepFor(JAMBONES_TRANSCRIBE_EP_DESTROY_DELAY_MS)
+      ]);
+    };
+
+    const origStartTranscription = ep.startTranscription.bind(ep);
+    ep.startTranscription = async(...args) => {
+      try {
+        const result = await origStartTranscription(...args);
+        ep.isTranscribeActive = true;
+        return result;
+      } catch (err) {
+        ep.isTranscribeActive = false;
+        throw err;
+      }
+    };
+
+    const origStopTranscription = ep.stopTranscription.bind(ep);
+    ep.stopTranscription = async(opts = {}, ...args) => {
+      const { gracefulShutdown = true, ...others } = opts;
+      if (ep.isTranscribeActive && gracefulShutdown) {
+        // only wait for graceful shutdown if transcription is active
+        await gracefulShutdownHandler();
+      }
+      try {
+        const result = await origStopTranscription({...others}, ...args);
+        ep.isTranscribeActive = false;
+        return result;
+      } catch (err) {
+        ep.isTranscribeActive = false;
+        throw err;
+      }
+    };
+
+    const origDestroy = ep.destroy.bind(ep);
+    ep.destroy = async() => {
+      if (ep.isTranscribeActive) {
+        await gracefulShutdownHandler();
+      }
+      return await origDestroy();
+    };
+  }
+
+  return ep;
+};
+
+module.exports = {
+  createMediaEndpoint,
+};
--- a/lib/utils/place-outdial.js
+++ b/lib/utils/place-outdial.js
@@ -16,13 +16,7 @@ const crypto = require('crypto');
 const HttpRequestor = require('./http-requestor');
 const WsRequestor = require('./ws-requestor');
 const {makeOpusFirst, removeVideoSdp} = require('./sdp-utils');
-const {
-  JAMBONES_USE_FREESWITCH_TIMER_FD,
-  JAMBONES_MEDIA_TIMEOUT_MS,
-  JAMBONES_MEDIA_HOLD_TIMEOUT_MS,
-  JAMBONES_TRANSCRIBE_EP_DESTROY_DELAY_MS
-} = require('../config');
-const { sleepFor } = require('./helpers');
+const { createMediaEndpoint } = require('./media-endpoint');

 class SingleDialer extends Emitter {
  constructor({logger, sbcAddress, target, opts, application, callInfo, accountInfo, rootSpan, startSpan, dialTask,
@@ -98,6 +92,7 @@ class SingleDialer extends Emitter {
      };
    }
    this.ms = ms;
+    this.srf = srf;
    let uri, to, inviteSpan;
    try {
      switch (this.target.type) {
@@ -139,8 +134,7 @@ class SingleDialer extends Emitter {
      this.updateCallStatus = srf.locals.dbHelpers.updateCallStatus;
      this.serviceUrl = srf.locals.serviceUrl;

-      this.ep = await ms.createEndpoint();
-      this._configMsEndpoint();
+      this.ep = await this._createMediaEndpoint();
      this.logger.debug(`SingleDialer:exec - created endpoint ${this.ep.uuid}`);

      /**
@@ -352,43 +346,19 @@ class SingleDialer extends Emitter {
    }
  }

-  _configMsEndpoint() {
-    const opts = {
-      ...(this.onHoldMusic && {holdMusic: `shout://${this.onHoldMusic.replace(/^https?:\/\//, '')}`}),
-      ...(JAMBONES_USE_FREESWITCH_TIMER_FD && {timer_name: 'timerfd'}),
-      ...(JAMBONES_MEDIA_TIMEOUT_MS && {media_timeout: JAMBONES_MEDIA_TIMEOUT_MS}),
-      ...(JAMBONES_MEDIA_HOLD_TIMEOUT_MS && {media_hold_timeout: JAMBONES_MEDIA_HOLD_TIMEOUT_MS})
-    };
-    if (Object.keys(opts).length > 0) {
-      this.ep.set(opts);
-    }
-    if (this.dialTask?.inbandDtmfEnabled && !this.ep.inbandDtmfEnabled) {
-      // https://developer.signalwire.com/freeswitch/FreeSWITCH-Explained/Modules/mod-dptools/6587132/#0-about
-      try {
-        this.ep.execute('start_dtmf');
-        this.ep.inbandDtmfEnabled = true;
-      } catch (err) {
-        this.logger.info(err, 'place-outdial:_configMsEndpoint - error enable inband DTMF');
-      }
-    }
+  async _handleMediaTimeout(evt, ep) {
+    this.logger.info({evt}, 'SingleDialer:_handleMediaTimeout - media timeout event received');
+    this.dialTask.kill(this.dialTask.cs, 'media-timeout');
+  }

-    const origDestroy = this.ep.destroy.bind(this.ep);
-    this.ep.destroy = async() => {
-      try {
-        if (this.dialTask.transcribeTask && JAMBONES_TRANSCRIBE_EP_DESTROY_DELAY_MS) {
-          // transcribe task is being used, wait for some time before destroy
-          // if final transcription is received but endpoint is already closed,
-          // freeswitch module will not be able to send the transcription
-
-          this.logger.info('SingleDialer:_configMsEndpoint -' +
-            ' Dial with transcribe task, wait for some time before destroy');
-          await sleepFor(JAMBONES_TRANSCRIBE_EP_DESTROY_DELAY_MS);
-        }
-        await origDestroy();
-      } catch (err) {
-        this.logger.error(err, 'SingleDialer:_configMsEndpoint - error destroying endpoint');
-      }
-    };
+  async _createMediaEndpoint(drachtioFsmrfOptions = {}) {
+    return await createMediaEndpoint(this.srf, this.logger, {
+      acactiveMs: this.ms,
+      drachtioFsmrfOptions,
+      onHoldMusic: this.onHoldMusic,
+      inbandDtmfEnabled: this.dialTask?.inbandDtmfEnabled,
+      mediaTimeoutHandler: this._handleMediaTimeout.bind(this),
+    });
  }

  /**
@@ -528,8 +498,7 @@ class SingleDialer extends Emitter {
    assert(this.dlg && this.dlg.connected && !this.ep);

    this.logger.debug('SingleDialer:reAnchorMedia: re-anchoring media after partial media');
-    this.ep = await this.ms.createEndpoint({remoteSdp: this.dlg.remote.sdp});
-    this._configMsEndpoint();
+    this.ep = await this._createMediaEndpoint({remoteSdp: this.dlg.remote.sdp});
    await this.dlg.modify(this.ep.local.sdp, {
      headers: {
        'X-Reason': 'anchor-media'
--- a/lib/utils/sticky-event-emitter.js
+++ b/lib/utils/sticky-event-emitter.js
@@ -37,6 +37,10 @@ class StickyEventEmitter extends EventEmitter {
        this.onSuccess();
      }
      this._onceListeners.delete(event);
+      // return from here as the event listener is already called
+      // this is to avoid calling the native emit method which
+      // will call the event listener again
+      return true;
    }

    return super.emit(event, ...args);
--- a/lib/utils/transcription-utils.js
+++ b/lib/utils/transcription-utils.js
@@ -110,6 +110,10 @@ const stickyVars = {
  voxist: [
    'VOXIST_API_KEY',
  ],
+  cartesia: [
+    'CARTESIA_API_KEY',
+    'CARTESIA_MODEL_ID'
+  ],
  speechmatics: [
    'SPEECHMATICS_API_KEY',
    'SPEECHMATICS_HOST',
@@ -519,16 +523,27 @@ const normalizeAws = (evt, channel, language) => {

 const normalizeAssemblyAi = (evt, channel, language) => {
  const copy = JSON.parse(JSON.stringify(evt));
+  const alternatives = [];
+  let is_final = false;
+  if (evt.type && evt.type === 'Turn') {
+    // v3 is here
+    alternatives.push({
+      confidence: evt.end_of_turn_confidence,
+      transcript: evt.transcript,
+    });
+    is_final = evt.end_of_turn;
+  } else {
+    alternatives.push({
+      confidence: evt.confidence,
+      transcript: evt.text,
+    });
+    is_final = evt.message_type === 'FinalTranscript';
+  }
  return {
    language_code: language,
    channel_tag: channel,
-    is_final: evt.message_type === 'FinalTranscript',
-    alternatives: [
-      {
-        confidence: evt.confidence,
-        transcript: evt.text,
-      }
-    ],
+    is_final,
+    alternatives,
    vendor: {
      name: 'assemblyai',
      evt: copy
@@ -555,6 +570,25 @@ const normalizeVoxist = (evt, channel, language) => {
  };
 };

+const normalizeCartesia = (evt, channel, language) => {
+  const copy = JSON.parse(JSON.stringify(evt));
+  return {
+    language_code: language,
+    channel_tag: channel,
+    is_final: evt.is_final,
+    alternatives: [
+      {
+        confidence: 1.00,
+        transcript: evt.text,
+      }
+    ],
+    vendor: {
+      name: 'cartesia',
+      evt: copy
+    }
+  };
+};
+
 const normalizeSpeechmatics = (evt, channel, language) => {
  const copy = JSON.parse(JSON.stringify(evt));
  const is_final = evt.message === 'AddTranscript';
@@ -636,6 +670,8 @@ module.exports = (logger) => {
        return normalizeAssemblyAi(evt, channel, language, shortUtterance);
      case 'voxist':
        return normalizeVoxist(evt, channel, language);
+      case 'cartesia':
+        return normalizeCartesia(evt, channel, language);
      case 'verbio':
        return normalizeVerbio(evt, channel, language);
      case 'speechmatics':
@@ -993,8 +1029,28 @@ module.exports = (logger) => {
      };
    }
    else if ('assemblyai' === vendor) {
+      const serviceVersion = rOpts.assemblyAiOptions?.serviceVersion || sttCredentials.service_version || 'v2';
+      const {
+        formatTurns,
+        endOfTurnConfidenceThreshold,
+        minEndOfTurnSilenceWhenConfident,
+        maxTurnSilence
+      } = rOpts.assemblyAiOptions || {};
      opts = {
        ...opts,
+        ASSEMBLYAI_API_VERSION: serviceVersion,
+        ...(serviceVersion === 'v3' && {
+          ...(formatTurns && {
+            ASSEMBLYAI_FORMAT_TURNS: formatTurns
+          }),
+          ...(endOfTurnConfidenceThreshold && {
+            ASSEMBLYAI_END_OF_TURN_CONFIDENCE_THRESHOLD: endOfTurnConfidenceThreshold
+          }),
+          ASSEMBLYAI_MIN_END_OF_TURN_SILENCE_WHEN_CONFIDENT: minEndOfTurnSilenceWhenConfident || 500,
+          ...(maxTurnSilence && {
+            ASSEMBLYAI_MAX_TURN_SILENCE: maxTurnSilence
+          }),
+        }),
        ...(sttCredentials.api_key) &&
          {ASSEMBLYAI_API_KEY: sttCredentials.api_key},
        ...(rOpts.hints?.length > 0 &&
@@ -1008,6 +1064,16 @@ module.exports = (logger) => {
          {VOXIST_API_KEY: sttCredentials.api_key},
      };
    }
+    else if ('cartesia' === vendor) {
+      opts = {
+        ...opts,
+        ...(sttCredentials.api_key &&
+          {CARTESIA_API_KEY: sttCredentials.api_key}),
+        ...(sttCredentials.stt_model_id && {
+          CARTESIA_MODEL_ID: sttCredentials.stt_model_id
+        })
+      };
+    }
    else if ('openai' === vendor) {
      const {openaiOptions = {}} = rOpts;
      const model = openaiOptions.model || rOpts.model || sttCredentials.model_id || 'whisper-1';
--- a/lib/utils/ws-requestor.js
+++ b/lib/utils/ws-requestor.js
@@ -1,6 +1,7 @@
 const assert = require('assert');
 const BaseRequestor = require('./base-requestor');
 const short = require('short-uuid');
+const parseUrl = require('parse-url');
 const {HookMsgTypes, WS_CLOSE_CODES} = require('./constants.json');
 const Websocket = require('ws');
 const snakeCaseKeys = require('./snakecase-keys');
@@ -41,6 +42,19 @@ class WsRequestor extends BaseRequestor {

    assert(this._isAbsoluteUrl(this.url));

+    const parsedUrl = parseUrl(this.url);
+    const hash = parsedUrl.hash || '';
+    const hashObj = hash ? this._parseHashParams(hash) : {};
+
+    // remove hash
+    this.cleanUrl = hash ? this.url.replace(`#${hash}`, '') : this.url;
+
+    // Retry policy: rp valid values: 4xx, 5xx, ct, rt, all, default is ct
+    // Retry count: rc valid values: 1-5, default is 5 for websockets
+    this.maxReconnects = Math.min(Math.abs(parseInt(hashObj.rc) || MAX_RECONNECTS), 5);
+    this.retryPolicy = hashObj.rp || 'ct';
+    this.retryPolicyValues = this.retryPolicy.split(',').map((v) => v.trim());
+
    this.on('socket-closed', this._onSocketClosed.bind(this));
  }

@@ -111,16 +125,56 @@ class WsRequestor extends BaseRequestor {
      }
      this.connectInProgress = true;
      this.logger.debug(`WsRequestor:request(${this.id}) - connecting since we do not have a connection for ${type}`);
-      if (this.connections >= MAX_RECONNECTS) {
-        return Promise.reject(`max attempts connecting to ${this.url}`);
-      }
+
      try {
-        const startAt = process.hrtime();
-        await this._connect();
-        const rtt = this._roundTrip(startAt);
-        this.stats.histogram('app.hook.connect_time', rtt, ['hook_type:app']);
+        let retryCount = 0;
+        let lastError = null;
+
+        while (retryCount <= this.maxReconnects) {
+          try {
+            this.logger.debug({retryCount, maxReconnects: this.maxReconnects},
+              'WsRequestor:request - attempting connection retry');
+
+            // Ensure clean state before each connection attempt
+            if (this.ws) {
+              this.ws.removeAllListeners();
+              this.ws = null;
+            }
+
+            const startAt = process.hrtime();
+            await this._connect();
+            const rtt = this._roundTrip(startAt);
+            this.stats.histogram('app.hook.connect_time', rtt, ['hook_type:app']);
+            lastError = null;
+            break;
+          } catch (error) {
+            lastError = error;
+            retryCount++;
+
+            if (retryCount <= this.maxReconnects &&
+                this.retryPolicyValues?.length &&
+                this._shouldRetry(error, this.retryPolicyValues)) {
+
+              const delay = this.backoffMs;
+              this.backoffMs = this.backoffMs < 2000 ? this.backoffMs * 2 : (this.backoffMs + 2000);
+              this.logger.debug({delay}, 'WsRequestor:request - waiting before retry');
+              await new Promise((resolve) => setTimeout(resolve, delay));
+              continue;
+            }
+
+            this.logger.error({error: error.message, retryCount, maxReconnects: this.maxReconnects},
+              'WsRequestor:request - all connection attempts failed');
+            throw lastError;
+          }
+        }
+
+        // If we exit the loop without success, throw the last error
+        if (lastError) {
+          throw lastError;
+        }
      } catch (err) {
-        this.logger.info({url, err}, 'WsRequestor:request - failed connecting');
+        this.logger.info({url, err, retryPolicy: this.retryPolicy},
+          'WsRequestor:request - all connection attempts failed');
        this.connectInProgress = false;
        return Promise.reject(err);
      }
@@ -301,17 +355,23 @@ class WsRequestor extends BaseRequestor {
      };
      if (this.username && this.password) opts = {...opts, auth: `${this.username}:${this.password}`};

+      // Clean up any existing connection event listeners to prevent interference between retry attempts
+      this.removeAllListeners('ready');
+      this.removeAllListeners('not-ready');
+
      this
        .once('ready', (ws) => {
+          this.logger.debug('WsRequestor:_connect - ready event fired, resolving Promise');
          this.removeAllListeners('not-ready');
          if (this.connections > 1) this.request('session:reconnect', this.url);
          resolve();
        })
        .once('not-ready', (err) => {
+          this.logger.error({err: err.message}, 'WsRequestor:_connect - not-ready event fired, rejecting Promise');
          this.removeAllListeners('ready');
          reject(err);
        });
-      const ws = new Websocket(this.url, ['ws.jambonz.org'], opts);
+      const ws = new Websocket(this.cleanUrl, ['ws.jambonz.org'], opts);
      this._setHandlers(ws);
    });
  }
@@ -335,10 +395,13 @@ class WsRequestor extends BaseRequestor {
  }

  _onError(err) {
-    if (this.connections > 0) {
-      this.logger.info({url: this.url, err}, 'WsRequestor:_onError');
+    if (this.connectInProgress) {
+      this.logger.info({url: this.url, err}, 'WsRequestor:_onError - emitting not-ready for connection attempt');
+      this.emit('not-ready', err);
+    }
+    else if (this.connections === 0) {
+      this.emit('not-ready', err);
    }
-    else this.emit('not-ready', err);
  }

  _onOpen(ws) {
@@ -375,30 +438,44 @@ class WsRequestor extends BaseRequestor {
      statusMessage: res.statusMessage
    }, 'WsRequestor - unexpected response');
    this.emit('connection-failure');
-    this.emit('not-ready', new Error(`${res.statusCode} ${res.statusMessage}`));
-    this.connections++;
+
+    const error = new Error(`${res.statusCode} ${res.statusMessage}`);
+    error.statusCode = res.statusCode;
+    this.connectInProgress = false;
+
+    this.emit('not-ready', error);
  }

  _onSocketClosed() {
    this.ws = null;
    this.emit('connection-dropped');
    this._stopPingTimer();
-    if (this.connections > 0 && this.connections < MAX_RECONNECTS && !this.closedGracefully) {
+
+    if (this.connections > 0 && this.connections < this.maxReconnects && !this.closedGracefully) {
      if (!this._initMsgId) this._clearPendingMessages();
      this.logger.debug(`WsRequestor:_onSocketClosed waiting ${this.backoffMs} to reconnect`);
-      setTimeout(() => {
+      this._scheduleReconnect('_onSocketClosed');
+    }
+  }
+
+  _scheduleReconnect(source) {
+    this.logger.debug(`WsRequestor:_scheduleReconnect waiting ${this.backoffMs} to reconnect (${source})`);
+    setTimeout(() => {
+      this.logger.debug(
+        {haveWs: !!this.ws, connectInProgress: this.connectInProgress},
+        `WsRequestor:_scheduleReconnect time to reconnect (${source})`);
+      if (!this.ws && !this.connectInProgress) {
+        this.connectInProgress = true;
+        return this._connect()
+          .catch((err) => this.logger.error(`WsRequestor:${source} There is error while reconnect`, err))
+          .finally(() => this.connectInProgress = false);
+      } else {
        this.logger.debug(
          {haveWs: !!this.ws, connectInProgress: this.connectInProgress},
-          'WsRequestor:_onSocketClosed time to reconnect');
-        if (!this.ws && !this.connectInProgress) {
-          this.connectInProgress = true;
-          return this._connect()
-            .catch((err) => this.logger.error('WsRequestor:_onSocketClosed There is error while reconnect', err))
-            .finally(() => this.connectInProgress = false);
-        }
-      }, this.backoffMs);
-      this.backoffMs = this.backoffMs < 2000 ? this.backoffMs * 2 : (this.backoffMs + 2000);
-    }
+          `WsRequestor:_scheduleReconnect skipping reconnect attempt (${source}) - conditions not met`);
+      }
+    }, this.backoffMs);
+    this.backoffMs = this.backoffMs < 2000 ? this.backoffMs * 2 : (this.backoffMs + 2000);
  }

  _onMessage(content, isBinary) {
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "jambonz-feature-server",
-  "version": "0.9.4",
+  "version": "0.9.5",
  "main": "app.js",
  "engines": {
    "node": ">= 18.x"
@@ -31,10 +31,10 @@
    "@jambonz/http-health-check": "^0.0.1",
    "@jambonz/mw-registrar": "^0.2.7",
    "@jambonz/realtimedb-helpers": "^0.8.13",
-    "@jambonz/speech-utils": "^0.2.11",
+    "@jambonz/speech-utils": "^0.2.15",
    "@jambonz/stats-collector": "^0.1.10",
-    "@jambonz/time-series": "^0.2.13",
-    "@jambonz/verb-specifications": "^0.0.104",
+    "@jambonz/time-series": "^0.2.14",
+    "@jambonz/verb-specifications": "^0.0.108",
    "@modelcontextprotocol/sdk": "^1.9.0",
    "@opentelemetry/api": "^1.8.0",
    "@opentelemetry/exporter-jaeger": "^1.23.0",
@@ -48,7 +48,7 @@
    "bent": "^7.3.12",
    "debug": "^4.3.4",
    "deepcopy": "^2.1.0",
-    "drachtio-fsmrf": "^4.0.3",
+    "drachtio-fsmrf": "^4.0.4",
    "drachtio-srf": "^5.0.5",
    "express": "^4.19.2",
    "express-validator": "^7.0.1",
@@ -56,7 +56,6 @@
    "parse-url": "^9.2.0",
    "pino": "^8.20.0",
    "polly-ssml-split": "^0.1.0",
-    "proxyquire": "^2.1.3",
    "sdp-transform": "^2.15.0",
    "short-uuid": "^5.1.0",
    "sinon": "^17.0.1",
@@ -71,6 +70,7 @@
    "eslint": "7.32.0",
    "eslint-plugin-promise": "^6.1.1",
    "nyc": "^15.1.0",
+    "proxyquire": "^2.1.3",
    "tape": "^5.7.5"
  },
  "optionalDependencies": {
--- a/test/http-requestor-retry-test.js
+++ b/test/http-requestor-retry-test.js
@@ -0,0 +1,151 @@
+// Test for HttpRequestor retry functionality
+const test = require('tape');
+const sinon = require('sinon');
+const proxyquire = require('proxyquire').noCallThru();
+const { createMocks, setupBaseRequestorMocks } = require('./utils/mock-helper');
+
+// Create mocks
+const mocks = createMocks();
+
+// Mock timeSeries module
+const timeSeriesMock = sinon.stub().returns(mocks.MockAlerter);
+
+// Mock the config with required properties
+const configMock = {
+  HTTP_POOL: '0',
+  HTTP_POOLSIZE: '10',
+  HTTP_PIPELINING: '1',
+  HTTP_TIMEOUT: 5000,
+  HTTP_PROXY_IP: null,
+  HTTP_PROXY_PORT: null,
+  HTTP_PROXY_PROTOCOL: null,
+  NODE_ENV: 'test',
+  HTTP_USER_AGENT_HEADER: 'test-agent'
+};
+
+// Mock db-helpers
+const dbHelpersMock = mocks.MockDbHelpers;
+
+// Require HttpRequestor with mocked dependencies
+const BaseRequestor = proxyquire('../lib/utils/base-requestor', {
+  '@jambonz/time-series': timeSeriesMock,
+  '../config': configMock,
+  '../../': { srf: { locals: { stats: mocks.MockStats } } }
+});
+
+// Setup BaseRequestor mocks
+setupBaseRequestorMocks(BaseRequestor);
+
+// Require HttpRequestor with mocked dependencies
+const HttpRequestor = proxyquire('../lib/utils/http-requestor', {
+  './base-requestor': BaseRequestor,
+  '../config': configMock,
+  '@jambonz/db-helpers': dbHelpersMock
+});
+
+// Setup utility function
+const setupRequestor = () => {
+  const hook = { url: 'http://localhost/test', method: 'POST' };
+  const requestor = new HttpRequestor(mocks.MockLogger, 'AC123', hook, 'testsecret');
+  requestor.stats = mocks.MockStats;
+  return requestor;
+};
+
+// Cleanup function for tests
+const cleanup = (requestor) => {
+  sinon.restore();
+  if (requestor && requestor.close) requestor.close();
+};
+
+test('HttpRequestor: should retry on connection errors when specified in hash', async (t) => {
+  const requestor = setupRequestor();
+  
+  // Setup a URL with retry params in the hash
+  const urlWithRetry = 'http://localhost/test#rc=3&rp=ct,5xx';
+  
+  // First two calls fail with connection refused, third succeeds
+  const requestStub = sinon.stub(requestor.client, 'request');
+  const error = new Error('Connection refused');
+  error.code = 'ECONNREFUSED';
+  
+  // Fail twice, succeed on third try
+  requestStub.onCall(0).rejects(error);
+  requestStub.onCall(1).rejects(error);
+  requestStub.onCall(2).resolves({
+    statusCode: 200,
+    headers: { 'content-type': 'application/json' },
+    body: { json: async () => ({ success: true }) }
+  });
+  
+  try {
+    const hook = { url: urlWithRetry, method: 'GET' };
+    const result = await requestor.request('verb:hook', hook, null);
+    
+    t.equal(requestStub.callCount, 3, 'Should have retried twice for a total of 3 calls');
+    t.deepEqual(result, { success: true }, 'Should return successful response');
+  } catch (err) {
+    t.fail(`Should not throw an error: ${err.message}`);
+  }
+  
+  cleanup(requestor);
+  t.end();
+});
+
+test('HttpRequestor: should respect retry count (rc) from hash', async (t) => {
+  const requestor = setupRequestor();
+  
+  // Setup a URL with retry params in the hash - only retry once
+  const urlWithRetry = 'http://localhost/test#rc=1&rp=ct';
+  
+  // All calls fail with connection refused
+  const requestStub = sinon.stub(requestor.client, 'request');
+  const error = new Error('Connection refused');
+  error.code = 'ECONNREFUSED';
+  
+  // Always fail
+  requestStub.rejects(error);
+  
+  try {
+    const hook = { url: urlWithRetry, method: 'GET' };
+    await requestor.request('verb:hook', hook, null);
+    t.fail('Should have thrown an error');
+  } catch (err) {
+    t.equal(requestStub.callCount, 2, 'Should have retried once for a total of 2 calls');
+    t.equal(err.code, 'ECONNREFUSED', 'Should throw the original error');
+  }
+  
+  cleanup(requestor);
+  t.end();
+});
+
+test('HttpRequestor: should respect retry policy (rp) from hash', async (t) => {
+  const requestor = setupRequestor();
+  
+  // Setup a URL with retry params in hash - only retry on 5xx errors
+  const urlWithRetry = 'http://localhost/test#rc=2&rp=5xx';
+  
+  // Fail with 404 (should not retry since rp=5xx)
+  const requestStub = sinon.stub(requestor.client, 'request');
+  requestStub.resolves({
+    statusCode: 404,
+    headers: {},
+    body: {}
+  });
+  
+  try {
+    const hook = { url: urlWithRetry, method: 'GET' };
+    await requestor.request('verb:hook', hook, null);
+    t.fail('Should have thrown an error');
+  } catch (err) {
+    t.equal(requestStub.callCount, 1, 'Should not retry on 404 when rp=5xx');
+    t.equal(err.statusCode, 404, 'Should throw 404 error');
+  }
+  
+  cleanup(requestor);
+  t.end();
+});
+
+module.exports = {
+  setupRequestor,
+  cleanup
+};
--- a/test/http-requestor-unit-test.js
+++ b/test/http-requestor-unit-test.js
@@ -0,0 +1,214 @@
+const test = require('tape');
+const sinon = require('sinon');
+const { createMockedRequestors } = require('./utils/test-mocks');
+
+// Use the shared mocks and helpers
+const {
+  HttpRequestor,
+  setupRequestor,
+  cleanup
+} = createMockedRequestors();
+
+// All prototype overrides and setup are now handled in test-mocks.js
+
+// --- TESTS ---
+test('HttpRequestor: constructor sets up properties correctly', (t) => {
+  const requestor = setupRequestor();
+  t.equal(requestor.method, 'POST', 'method should be POST');
+  t.equal(requestor.url, 'http://localhost/test', 'url should be set');
+  t.equal(typeof requestor.client, 'object', 'client should be an object');
+  cleanup(requestor);
+  t.end();
+});
+
+test('HttpRequestor: constructor with username/password sets auth header', (t) => {
+  const { mocks, HttpRequestor } = createMockedRequestors();
+  const logger = mocks.logger;
+  const hook = {
+    url: 'http://localhost/test',
+    method: 'POST',
+    username: 'user',
+    password: 'pass'
+  };
+  const requestor = new HttpRequestor(logger, 'AC123', hook, 'secret');
+  t.ok(requestor.authHeader.Authorization, 'Authorization header should be set');
+  t.ok(requestor.authHeader.Authorization.startsWith('Basic '), 'Should be Basic auth');
+  cleanup(requestor);
+  t.end();
+});
+
+test('HttpRequestor: request should return JSON on 200 response', async (t) => {
+  const requestor = setupRequestor();
+  const expectedResponse = { success: true, data: [1, 2, 3] };
+  const fakeBody = { json: async () => expectedResponse };
+  sinon.stub(requestor.client, 'request').resolves({
+    statusCode: 200,
+    headers: { 'content-type': 'application/json' },
+    body: fakeBody
+  });
+  try {
+    const hook = { url: 'http://localhost/test', method: 'POST' };
+    const result = await requestor.request('verb:hook', hook, { foo: 'bar' });
+    t.deepEqual(result, expectedResponse, 'Should return parsed JSON');
+    const requestCall = requestor.client.request.getCall(0);
+    const opts = requestCall.args[0];
+    t.equal(opts.method, 'POST', 'method should be POST');
+    t.ok(opts.headers['X-Signature'], 'Should include signature header');
+    t.ok(opts.body, 'Should include request body');
+  } catch (err) {
+    t.fail(err);
+  }
+  cleanup(requestor);
+  t.end();
+});
+
+test('HttpRequestor: request should handle non-200 responses', async (t) => {
+  const requestor = setupRequestor();
+  sinon.stub(requestor.client, 'request').resolves({
+    statusCode: 404,
+    headers: {},
+    body: {}
+  });
+  try {
+    const hook = { url: 'http://localhost/test', method: 'POST' };
+    await requestor.request('verb:hook', hook, { foo: 'bar' });
+    t.fail('Should have thrown an error');
+  } catch (err) {
+    t.ok(err, 'Should throw an error');
+    t.equal(err.statusCode, 404, 'Error should contain status code');
+  }
+  cleanup(requestor);
+  t.end();
+});
+
+test('HttpRequestor: request should handle ECONNREFUSED error', async (t) => {
+  const requestor = setupRequestor();
+  const error = new Error('Connection refused');
+  error.code = 'ECONNREFUSED';
+  sinon.stub(requestor.client, 'request').rejects(error);
+  try {
+    const hook = { url: 'http://localhost/test', method: 'POST' };
+    await requestor.request('verb:hook', hook, { foo: 'bar' });
+    t.fail('Should have thrown an error');
+  } catch (err) {
+    t.equal(err.code, 'ECONNREFUSED', 'Should pass through the error');
+  }
+  cleanup(requestor);
+  t.end();
+});
+
+test('HttpRequestor: request should skip jambonz:error type', async (t) => {
+  const requestor = setupRequestor();
+  const spy = sinon.spy(requestor.client, 'request');
+  const hook = { url: 'http://localhost/test', method: 'POST' };
+  const result = await requestor.request('jambonz:error', hook, { foo: 'bar' });
+  t.equal(result, undefined, 'Should return undefined');
+  t.equal(spy.callCount, 0, 'Should not call request method');
+  cleanup(requestor);
+  t.end();
+});
+
+test('HttpRequestor: request should handle array response', async (t) => {
+  const requestor = setupRequestor();
+  const fakeBody = { json: async () => [{ id: 1 }, { id: 2 }] };
+  sinon.stub(requestor.client, 'request').resolves({
+    statusCode: 200,
+    headers: { 'content-type': 'application/json' },
+    body: fakeBody
+  });
+  try {
+    const hook = { url: 'http://localhost/test', method: 'POST' };
+    const result = await requestor.request('verb:hook', hook, { foo: 'bar' });
+    t.ok(Array.isArray(result), 'Should return an array');
+    t.equal(result.length, 2, 'Array should have 2 items');
+  } catch (err) {
+    t.fail(err);
+  }
+  cleanup(requestor);
+  t.end();
+});
+
+test('HttpRequestor: request should handle llm:tool-call type', async (t) => {
+  const requestor = setupRequestor();
+  const fakeBody = { json: async () => ({ result: 'tool output' }) };
+  sinon.stub(requestor.client, 'request').resolves({
+    statusCode: 200,
+    headers: { 'content-type': 'application/json' },
+    body: fakeBody
+  });
+  try {
+    const hook = { url: 'http://localhost/test', method: 'POST' };
+    const result = await requestor.request('llm:tool-call', hook, { tool: 'test' });
+    t.deepEqual(result, { result: 'tool output' }, 'Should return the parsed JSON');
+  } catch (err) {
+    t.fail(err);
+  }
+  cleanup(requestor);
+  t.end();
+});
+
+test('HttpRequestor: close should close the client if not using pools', (t) => {
+  // Ensure HTTP_POOL is set to false to disable pool usage
+  const oldHttpPool = process.env.HTTP_POOL;
+  process.env.HTTP_POOL = '0';
+
+  const requestor = setupRequestor();
+  // Make sure _usePools is false
+  requestor._usePools = false;
+
+  // Replace the client.close with a spy function
+  const closeSpy = sinon.spy();
+  requestor.client.close = closeSpy;
+
+  // Set client.closed to false to ensure the condition is met
+  requestor.client.closed = false;
+
+  // Call close
+  requestor.close();
+
+  // Check if the spy was called
+  t.ok(closeSpy.calledOnce, 'Should call client.close');
+
+  // Restore HTTP_POOL
+  process.env.HTTP_POOL = oldHttpPool;
+
+  // Don't call cleanup(requestor) as it would try to call client.close again
+  sinon.restore();
+  t.end();
+});
+
+test('HttpRequestor: request should handle URLs with fragments', async (t) => {
+  const requestor = setupRequestor();
+  // Use the same host/port as the base client to avoid creating a new client
+  const urlWithFragment = 'http://localhost?param1=value1#rc=5&rp=4xx,5xx,ct';
+  const expectedResponse = { status: 'success' };
+  const fakeBody = { json: async () => expectedResponse };
+
+  // Stub the request method
+  const requestStub = sinon.stub(requestor.client, 'request').callsFake((opts) => {
+    return Promise.resolve({
+      statusCode: 200,
+      headers: { 'content-type': 'application/json' },
+      body: fakeBody
+    });
+  });
+  try {
+    const hook = { url: urlWithFragment, method: 'GET' };
+    const result = await requestor.request('verb:hook', hook, null);
+    t.deepEqual(result, expectedResponse, 'Should return the parsed JSON response');
+    const requestCall = requestStub.getCall(0);
+    const opts = requestCall.args[0];
+    t.ok(opts.query && opts.query.param1 === 'value1', 'Query parameters should be parsed');
+    t.equal(opts.path, '/', 'Path should be extracted from URL');
+    t.notOk(opts.query && opts.query.rc, 'Fragment should not be included in query parameters');
+  } catch (err) {
+    t.fail(err);
+  }
+  cleanup(requestor);
+  t.end();
+});
+
+// test('HttpRequestor: request should handle URLs with query parameters', async (t) => {
+//   t.pass('Restored original require function');
+//   t.end();
+// });
--- a/test/index.js
+++ b/test/index.js
@@ -1,4 +1,8 @@
+require('./ws-requestor-retry-unit-test');
+require('./test_ws_retry_comprehensive');
 require('./ws-requestor-unit-test');
+require('./http-requestor-retry-test');
+require('./http-requestor-unit-test');
 require('./unit-tests');
 require('./docker_start');
 require('./create-test-db');
@@ -12,6 +16,7 @@ require('./sip-request-tests');
 require('./create-call-test');
 require('./play-tests');
 require('./sip-refer-tests');
+require('./sip-refer-handler-tests');
 require('./listen-tests');
 require('./config-test');
 require('./queue-test');
--- a/test/scenarios/uas-dial-refer.xml
+++ b/test/scenarios/uas-dial-refer.xml
@@ -0,0 +1,117 @@
+<?xml version="1.0" encoding="ISO-8859-1" ?>
+<!DOCTYPE scenario SYSTEM "sipp.dtd">
+
+<scenario name="UAS that accepts call and sends REFER">
+  <!-- Receive incoming INVITE -->
+  <recv request="INVITE" crlf="true">
+    <action>
+      <ereg regexp=".*" search_in="hdr" header="Subject:" assign_to="1" />
+      <ereg regexp=".*" search_in="hdr" header="From:" assign_to="2" />
+    </action>
+  </recv>
+
+  <!-- Send 180 Ringing -->
+  <send>
+    <![CDATA[
+      SIP/2.0 180 Ringing
+      [last_Via:]
+      [last_From:]
+      [last_To:];tag=[pid]SIPpTag01[call_number]
+      [last_Call-ID:]
+      [last_CSeq:]
+      [last_Record-Route:]
+      Subject:[$1]
+      Content-Length: 0
+    ]]>
+  </send>
+
+  <!-- Send 200 OK with SDP -->
+  <send>
+    <![CDATA[
+      SIP/2.0 200 OK
+      [last_Via:]
+      [last_From:]
+      [last_To:];tag=[pid]SIPpTag01[call_number]
+      [last_Call-ID:]
+      [last_CSeq:]
+      [last_Record-Route:]
+      Subject:[$1]
+      Contact: <sip:[local_ip]:[local_port];transport=[transport]>
+      Content-Type: application/sdp
+      Content-Length: [len]
+
+      v=0
+      o=user1 53655765 2353687637 IN IP[local_ip_type] [local_ip]
+      s=-
+      c=IN IP[media_ip_type] [media_ip]
+      t=0 0
+      m=audio [media_port] RTP/AVP 0
+      a=rtpmap:0 PCMU/8000
+    ]]>
+  </send>
+
+<recv request="ACK" rtd="true" crlf="true">
+  <action>
+    <!-- Check if this is NOT the first call (tag ends with 012 or higher) -->
+    <ereg regexp="tag=1SIPpTag01[2-9]" search_in="hdr" header="To:" assign_to="3" />
+    <log message="Not first call check result: [$3]"/>
+  </action>
+</recv>
+
+<!-- Skip REFER if we found a non-first call tag -->
+<nop next="skip_refer" test="3" value="" compare="not_equal">
+  <action>
+    <log message="Found non-first call tag [$3], skipping REFER"/>
+  </action>
+</nop>
+
+<!-- Wait a moment, then send REFER (only on first call) -->
+<pause milliseconds="1000"/>
+
+<nop>
+  <action>
+    <log message="Sending REFER for first call"/>
+  </action>
+</nop>
+
+<!-- Send REFER (only on first iteration) -->
+  <send retrans="500">
+    <![CDATA[
+      REFER sip:service@[remote_ip]:[remote_port] SIP/2.0
+      Via: SIP/2.0/[transport] [local_ip]:[local_port];branch=[branch]
+      From: <sip:[local_ip]:[local_port]>;tag=[pid]SIPpTag01[call_number]
+      To: [$2]
+      [last_Call-ID:]
+      CSeq: 2 REFER
+      Contact: <sip:[local_ip]:[local_port];transport=[transport]>
+      Max-Forwards: 70
+      X-Call-Number: [call_number]
+      Refer-To: <sip:+15551234567@example.com>
+      Referred-By: <sip:[local_ip]:[local_port]>
+      Content-Length: 0
+    ]]>
+  </send>
+
+  <!-- Expect 202 Accepted (only on first iteration) -->
+  <recv response="202"/>
+  
+  <label id="skip_refer"/>
+
+  <!-- Wait for BYE from feature server -->
+  <recv request="BYE"/>
+
+  <!-- Send 200 OK to BYE -->
+  <send>
+    <![CDATA[
+      SIP/2.0 200 OK
+      [last_Via:]
+      [last_From:]
+      [last_To:]
+      [last_Call-ID:]
+      [last_CSeq:]
+      Contact: <sip:[local_ip]:[local_port];transport=[transport]>
+      Content-Length: 0
+    ]]>
+  </send>
+
+</scenario>
--- a/test/sip-refer-handler-tests.js
+++ b/test/sip-refer-handler-tests.js
@@ -0,0 +1,90 @@
+const test = require('tape');
+const { sippUac } = require('./sipp')('test_fs');
+const bent = require('bent');
+const getJSON = bent('json')
+const clearModule = require('clear-module');
+const {provisionCallHook} = require('./utils');
+const { sleepFor } = require('../lib/utils/helpers');
+
+process.on('unhandledRejection', (reason, p) => {
+  console.log('Unhandled Rejection at: Promise', p, 'reason:', reason);
+});
+  
+function connect(connectable) {
+  return new Promise((resolve, reject) => {
+    connectable.on('connect', () => {
+      return resolve();
+    });
+  });
+}
+
+test('when parent leg recvs REFER it should end the dial after adulting child leg', async(t) => {
+    clearModule.all();
+    const {srf, disconnect} = require('../app');
+    try {
+      await connect(srf);
+      // wait for fs connected to drachtio server.
+      await sleepFor(1000);
+      
+      // GIVEN
+      const from = "dial_refer_handler";
+      let verbs = [
+        {
+          "verb": "dial",
+          "callerId": from,
+          "actionHook": "/actionHook",
+          "referHook": "/referHook",
+          "anchorMedia": true,
+          "target": [
+              {
+                  "type": "phone",
+                  "number": "15083084809"
+              }
+          ]
+        }
+      ];
+  
+      await provisionCallHook(from, verbs);
+  
+      // THEN
+      //const p = sippUac('uas-dial.xml', '172.38.0.10', undefined, undefined, 2);
+      const p = sippUac('uas-dial-refer.xml', '172.38.0.10', undefined, undefined, 2);
+      await sleepFor(1000);
+  
+      let account_sid = '622f62e4-303a-49f2-bbe0-eb1e1714e37a';
+  
+      let post = bent('http://127.0.0.1:3000/', 'POST', 'json', 201);
+      post('v1/createCall', {
+        'account_sid':account_sid,
+        "call_hook": {
+          "url": "http://127.0.0.1:3100/",
+          "method": "POST",
+        },
+        "from": from,
+        "to": {
+          "type": "phone",
+          "number": "15583084808"
+      }});
+  
+      await p;
+  
+      // Verify that the referHook was called
+      const obj = await getJSON(`http://127.0.0.1:3100/lastRequest/${from}_referHook`);
+      t.ok(obj.body.from === from,
+        'dial-refer-handler: referHook was called with correct from');
+      t.ok(obj.body.refer_details && obj.body.refer_details.sip_refer_to,
+        'dial-refer-handler: refer_details included in referHook');
+      t.ok(obj.body.refer_details.refer_to_user === '+15551234567',
+        'dial-refer-handler: refer_to_user correctly parsed');
+      t.ok(obj.body.refer_details.referring_call_sid,
+        'dial-refer-handler: referring_call_sid included');
+      t.ok(obj.body.refer_details.referred_call_sid,
+        'dial-refer-handler: referred_call_sid included');
+  
+      disconnect();
+    } catch (err) {
+      console.log(`error received: ${err}`);
+      disconnect();
+      t.error(err);
+    }
+});
--- a/test/test_ws_retry_comprehensive.js
+++ b/test/test_ws_retry_comprehensive.js
@@ -0,0 +1,436 @@
+const test = require('tape');
+const sinon = require('sinon');
+const proxyquire = require("proxyquire");
+proxyquire.noCallThru();
+
+const {
+  JAMBONES_LOGLEVEL,  
+} = require('../lib/config');
+const logger = require('pino')({level: JAMBONES_LOGLEVEL});
+
+// Mock WebSocket specifically for retry testing
+class RetryMockWebSocket {
+  static retryScenarios = new Map();
+  static connectionAttempts = new Map();
+  static urlMapping = new Map(); // Maps cleanUrl -> originalUrl
+  
+  constructor(url, protocols, options) {
+    this.url = url;
+    this.protocols = protocols;
+    this.options = options;
+    this.eventListeners = new Map();
+    
+    // Extract scenario key from URL hash or use URL itself
+    this.scenarioKey = this.extractScenarioKey(url);
+    
+    // Track connection attempts for this scenario
+    const attempts = RetryMockWebSocket.connectionAttempts.get(this.scenarioKey) || 0;
+    RetryMockWebSocket.connectionAttempts.set(this.scenarioKey, attempts + 1);
+    
+    console.log(`RetryMockWebSocket: constructor for URL ${url}, scenarioKey="${this.scenarioKey}", attempt #${attempts + 1}`);
+    
+    // Handle connection immediately
+    setImmediate(() => {
+      this.handleConnection();
+    });
+  }
+  
+  extractScenarioKey(url) {
+    console.log(`RetryMockWebSocket: extractScenarioKey from URL: ${url}`);
+    
+    // Check if we have a mapping from cleanUrl to originalUrl
+    const originalUrl = RetryMockWebSocket.urlMapping.get(url);
+    if (originalUrl && originalUrl.includes('#')) {
+      const hash = originalUrl.split('#')[1];
+      console.log(`RetryMockWebSocket: found mapped URL with hash: ${hash}`);
+      return hash;
+    }
+    
+    // For URLs with hash parameters, use the hash as the scenario key
+    if (url.includes('#')) {
+      const hash = url.split('#')[1];
+      console.log(`RetryMockWebSocket: found hash: ${hash}`);
+      return hash; // Use hash as scenario key
+    }
+    
+    console.log(`RetryMockWebSocket: using full URL as scenario key: ${url}`);
+    return url; // Fallback to full URL
+  }
+  
+  static setRetryScenario(key, scenario) {
+    console.log(`RetryMockWebSocket: setting scenario for key "${key}":`, scenario);
+    RetryMockWebSocket.retryScenarios.set(key, scenario);
+  }
+  
+  static setUrlMapping(cleanUrl, originalUrl) {
+    console.log(`RetryMockWebSocket: mapping ${cleanUrl} -> ${originalUrl}`);
+    RetryMockWebSocket.urlMapping.set(cleanUrl, originalUrl);
+  }
+  
+  static clearScenarios() {
+    console.log('RetryMockWebSocket: clearing all scenarios');
+    RetryMockWebSocket.retryScenarios.clear();
+    RetryMockWebSocket.connectionAttempts.clear();
+    RetryMockWebSocket.urlMapping.clear();
+  }
+  
+  static getConnectionAttempts(key) {
+    return RetryMockWebSocket.connectionAttempts.get(key) || 0;
+  }
+  
+  handleConnection() {
+    const scenario = RetryMockWebSocket.retryScenarios.get(this.scenarioKey);
+    console.log(`RetryMockWebSocket: handleConnection for scenarioKey="${this.scenarioKey}", scenario found:`, !!scenario);
+    
+    if (!scenario) {
+      // Default successful connection
+      console.log(`RetryMockWebSocket: no scenario found, defaulting to success`);
+      this.simulateOpen();
+      return;
+    }
+    
+    const attemptNumber = RetryMockWebSocket.connectionAttempts.get(this.scenarioKey);
+    const behavior = scenario.attempts[attemptNumber - 1] || scenario.attempts[scenario.attempts.length - 1];
+    
+    console.log(`RetryMockWebSocket: attempt ${attemptNumber}, behavior:`, behavior);
+    
+    if (behavior.type === 'handshake-failure') {
+      // Simulate handshake failure with specific status code
+      setImmediate(() => {
+        console.log(`RetryMockWebSocket: triggering handshake failure with status ${behavior.statusCode}`);
+        if (this.eventListeners.has('unexpected-response')) {
+          const mockResponse = {
+            statusCode: behavior.statusCode || 500,
+            statusMessage: behavior.statusMessage || 'Internal Server Error',
+            headers: {}
+          };
+          const mockRequest = {
+            headers: {}
+          };
+          this.eventListeners.get('unexpected-response')(mockRequest, mockResponse);
+        }
+      });
+    } else if (behavior.type === 'network-error') {
+      // Simulate network error during connection
+      setImmediate(() => {
+        console.log(`RetryMockWebSocket: triggering network error: ${behavior.message}`);
+        if (this.eventListeners.has('error')) {
+          const error = new Error(behavior.message || 'Network error');
+          // Set proper error code for retry policy checking
+          if (behavior.message && behavior.message.includes('Connection refused')) {
+            error.code = 'ECONNREFUSED';
+          } else if (behavior.message && behavior.message.includes('timeout')) {
+            error.code = 'ETIMEDOUT';
+          } else {
+            error.code = 'ECONNREFUSED'; // Default for network errors
+          }
+          this.eventListeners.get('error')(error);
+        }
+      });
+    } else if (behavior.type === 'success') {
+      // Successful connection
+      console.log(`RetryMockWebSocket: triggering success`);
+      this.simulateOpen();
+    }
+  }
+  
+  simulateOpen() {
+    setImmediate(() => {
+      if (this.eventListeners.has('open')) {
+        console.log(`RetryMockWebSocket: calling open listener`);
+        this.eventListeners.get('open')();
+      }
+    });
+  }
+  
+  once(event, listener) {
+    console.log(`RetryMockWebSocket: registering once listener for ${event}`);
+    this.eventListeners.set(event, listener);
+    return this;
+  }
+  
+  on(event, listener) {
+    console.log(`RetryMockWebSocket: registering on listener for ${event}`);
+    this.eventListeners.set(event, listener);
+    return this;
+  }
+  
+  removeAllListeners() {
+    this.eventListeners.clear();
+  }
+  
+  send(data, callback) {
+    // For successful connections, simulate message response
+    try {
+      const json = JSON.parse(data);
+      console.log({json}, 'RetryMockWebSocket: got message from ws-requestor');
+      
+      // Simulate successful response
+      setTimeout(() => {
+        const msg = {
+          type: 'ack',
+          msgid: json.msgid,
+          command: 'command',
+          call_sid: json.call_sid,
+          queueCommand: false,
+          data: '[{"verb": "play","url": "silence_stream://5000"}]'
+        };
+        console.log({msg}, 'RetryMockWebSocket: sending ack to ws-requestor');
+        this.mockOnMessage(JSON.stringify(msg));
+      }, 50);
+      
+      if (callback) callback();
+    } catch (err) {
+      console.error('RetryMockWebSocket: Error processing send', err);
+      if (callback) callback(err);
+    }
+  }
+  
+  mockOnMessage(message, isBinary = false) {
+    if (this.eventListeners.has('message')) {
+      this.eventListeners.get('message')(message, isBinary);
+    }
+  }
+  
+  close(code) {
+    if (this.eventListeners.has('close')) {
+      this.eventListeners.get('close')(code || 1000);
+    }
+  }
+}
+
+const BaseRequestor = proxyquire('../lib/utils/base-requestor', {
+  '../../': {
+    srf: {
+      locals: {
+        stats: {
+          histogram: () => {},
+        },
+      },
+    },
+  },
+  '@jambonz/time-series': sinon.stub(),
+});
+
+const WsRequestor = proxyquire('../lib/utils/ws-requestor', {
+  './base-requestor': BaseRequestor,
+  ws: RetryMockWebSocket,
+});
+
+test('ws retry policy - 4xx error with rp=5xx should not retry', async(t) => {
+  // GIVEN
+  console.log('Starting test setup...');
+  RetryMockWebSocket.clearScenarios();
+
+  const call_sid = 'ws_no_retry_4xx';
+  
+  // Set up the URL mapping
+  const cleanUrl = 'ws://localhost:3000';
+  const originalUrl = 'ws://localhost:3000#rc=2&rp=5xx';
+  RetryMockWebSocket.setUrlMapping(cleanUrl, originalUrl);
+  
+  // Set up the retry scenario for the first attempt to fail with 400, but policy only retries 5xx
+  RetryMockWebSocket.setRetryScenario('rc=2&rp=5xx', {
+    attempts: [
+      { type: 'handshake-failure', statusCode: 400, statusMessage: 'Bad Request' }
+    ]
+  });
+
+  const hook = {
+    url: 'ws://localhost:3000#rc=2&rp=5xx', // Max 2 retries, retry only on 5xx
+    username: 'username',
+    password: 'password',
+  };
+
+  const params = {
+    callSid: call_sid,
+  };
+
+  // WHEN
+  const requestor = new WsRequestor(
+    logger,
+    'account_sid',
+    hook,
+    'webhook_secret'
+  );
+  try {
+    const result = await requestor.request('session:new', hook, params, {});
+    t.fail('Should have thrown an error');
+    t.end();
+  } catch (err) {
+    // THEN
+    const errorMessage = err.message || err.toString() || String(err);
+    t.ok(
+      errorMessage.includes('400'),
+      `ws properly failed without retry for 4xx when rp=5xx - error: ${errorMessage}`
+    );
+    t.end();
+  }
+});
+
+test('ws retry policy - 5xx error with rp=5xx should retry and succeed', async(t) => {
+  // GIVEN
+  console.log('Starting 5xx retry test setup...');
+  RetryMockWebSocket.clearScenarios();
+
+  const call_sid = 'ws_retry_5xx_success';
+  
+  // Set up the URL mapping
+  const cleanUrl = 'ws://localhost:3000';
+  const originalUrl = 'ws://localhost:3000#rc=2&rp=5xx';
+  RetryMockWebSocket.setUrlMapping(cleanUrl, originalUrl);
+  
+  // Set up the retry scenario - first attempt fails with 500, second succeeds
+  RetryMockWebSocket.setRetryScenario('rc=2&rp=5xx', {
+    attempts: [
+      { type: 'handshake-failure', statusCode: 500, statusMessage: 'Internal Server Error' },
+      { type: 'success' }
+    ]
+  });
+
+  const hook = {
+    url: 'ws://localhost:3000#rc=2&rp=5xx', // Max 2 retries, retry only on 5xx
+    username: 'username',
+    password: 'password',
+  };
+
+  const params = {
+    callSid: call_sid,
+  };
+
+  // WHEN
+  const requestor = new WsRequestor(
+    logger,
+    'account_sid',
+    hook,
+    'webhook_secret'
+  );
+  try {
+    const result = await requestor.request('session:new', hook, params, {});
+    
+    // THEN
+    t.ok(result, 'ws successfully retried and connected after 5xx error');
+    
+    // Verify that exactly 2 attempts were made
+    const attempts = RetryMockWebSocket.getConnectionAttempts('rc=2&rp=5xx');
+    t.equal(attempts, 2, 'Should have made exactly 2 connection attempts');
+    
+    t.end();
+  } catch (err) {
+    t.fail(`Should have succeeded after retry - error: ${err.message}`);
+    t.end();
+  }
+});
+
+test('ws retry policy - network error with rp=ct should retry and succeed', async(t) => {
+  // GIVEN
+  console.log('Starting network error retry test setup...');
+  RetryMockWebSocket.clearScenarios();
+
+  const call_sid = 'ws_retry_network_success';
+  
+  // Set up the URL mapping
+  const cleanUrl = 'ws://localhost:3000';
+  const originalUrl = 'ws://localhost:3000#rc=3&rp=ct';
+  RetryMockWebSocket.setUrlMapping(cleanUrl, originalUrl);
+  
+  // Set up the retry scenario - first two attempts fail with network error, third succeeds
+  RetryMockWebSocket.setRetryScenario('rc=3&rp=ct', {
+    attempts: [
+      { type: 'network-error', message: 'Connection refused' },
+      { type: 'network-error', message: 'Connection refused' },
+      { type: 'success' }
+    ]
+  });
+
+  const hook = {
+    url: 'ws://localhost:3000#rc=3&rp=ct', // Max 3 retries, retry on connection errors
+    username: 'username',
+    password: 'password',
+  };
+
+  const params = {
+    callSid: call_sid,
+  };
+
+  // WHEN
+  const requestor = new WsRequestor(
+    logger,
+    'account_sid',
+    hook,
+    'webhook_secret'
+  );
+  try {
+    const result = await requestor.request('session:new', hook, params, {});
+    
+    // THEN
+    t.ok(result, 'ws successfully retried and connected after network errors');
+    
+    // Verify that exactly 3 attempts were made
+    const attempts = RetryMockWebSocket.getConnectionAttempts('rc=3&rp=ct');
+    t.equal(attempts, 3, 'Should have made exactly 3 connection attempts');
+    
+    t.end();
+  } catch (err) {
+    t.fail(`Should have succeeded after retry - error: ${err.message}`);
+    t.end();
+  }
+});
+
+test('ws retry policy - retry exhaustion should fail with last error', async(t) => {
+  // GIVEN
+  console.log('Starting retry exhaustion test setup...');
+  RetryMockWebSocket.clearScenarios();
+
+  const call_sid = 'ws_retry_exhaustion';
+  
+  // Set up the URL mapping
+  const cleanUrl = 'ws://localhost:3000';
+  const originalUrl = 'ws://localhost:3000#rc=2&rp=5xx';
+  RetryMockWebSocket.setUrlMapping(cleanUrl, originalUrl);
+  
+  // Set up the retry scenario - all attempts fail with 500
+  RetryMockWebSocket.setRetryScenario('rc=2&rp=5xx', {
+    attempts: [
+      { type: 'handshake-failure', statusCode: 500, statusMessage: 'Internal Server Error' },
+      { type: 'handshake-failure', statusCode: 500, statusMessage: 'Internal Server Error' },
+      { type: 'handshake-failure', statusCode: 500, statusMessage: 'Internal Server Error' }
+    ]
+  });
+
+  const hook = {
+    url: 'ws://localhost:3000#rc=2&rp=5xx', // Max 2 retries, retry only on 5xx
+    username: 'username',
+    password: 'password',
+  };
+
+  const params = {
+    callSid: call_sid,
+  };
+
+  // WHEN
+  const requestor = new WsRequestor(
+    logger,
+    'account_sid',
+    hook,
+    'webhook_secret'
+  );
+  try {
+    const result = await requestor.request('session:new', hook, params, {});
+    t.fail('Should have thrown an error after exhausting retries');
+    t.end();
+  } catch (err) {
+    // THEN
+    const errorMessage = err.message || err.toString() || String(err);
+    t.ok(
+      errorMessage.includes('500'),
+      `ws properly failed after exhausting retries - error: ${errorMessage}`
+    );
+    
+    // Verify that exactly 3 attempts were made (initial + 2 retries)
+    const attempts = RetryMockWebSocket.getConnectionAttempts('rc=2&rp=5xx');
+    t.equal(attempts, 3, 'Should have made exactly 3 connection attempts (initial + 2 retries)');
+    
+    t.end();
+  }
+});
--- a/test/utils/mock-helper.js
+++ b/test/utils/mock-helper.js
@@ -0,0 +1,103 @@
+const sinon = require('sinon');
+
+/**
+ * Creates mock objects commonly needed for testing HttpRequestor and related classes
+ * @returns {Object} Mock objects
+ */
+const createMocks = () => {
+  // Basic logger mock
+  const MockLogger = {
+    debug: () => {},
+    info: () => {},
+    error: () => {}
+  };
+
+  // Stats mock
+  const MockStats = { 
+    histogram: () => {} 
+  };
+
+  // Alerter mock
+  const MockAlerter = {
+    AlertType: {
+      WEBHOOK_CONNECTION_FAILURE: 'WEBHOOK_CONNECTION_FAILURE',
+      WEBHOOK_STATUS_FAILURE: 'WEBHOOK_STATUS_FAILURE'
+    },
+    writeAlerts: async () => {}
+  };
+
+  // DB helpers mock
+  const MockDbHelpers = {
+    pool: {
+      getConnection: () => Promise.resolve({
+        connect: () => {},
+        on: () => {},
+        query: (sql, cb) => {
+          if (typeof cb === 'function') cb(null, []);
+          return { stream: () => ({ on: () => {} }) };
+        },
+        end: () => {}
+      }),
+      query: (...args) => {
+        const cb = args[args.length - 1];
+        if (typeof cb === 'function') cb(null, []);
+        return Promise.resolve([]);
+      }
+    },
+    camelize: (obj) => obj
+  };
+
+  // Time series mock
+  const MockTimeSeries = () => ({
+    writeAlerts: async () => {},
+    AlertType: {
+      WEBHOOK_CONNECTION_FAILURE: 'WEBHOOK_CONNECTION_FAILURE',
+      WEBHOOK_STATUS_FAILURE: 'WEBHOOK_STATUS_FAILURE'
+    }
+  });
+
+  return {
+    MockLogger,
+    MockStats,
+    MockAlerter,
+    MockDbHelpers,
+    MockTimeSeries
+  };
+};
+
+/**
+ * Set up mocks on the BaseRequestor class for tests
+ * @param {Object} BaseRequestor - The BaseRequestor class
+ */
+const setupBaseRequestorMocks = (BaseRequestor) => {
+  BaseRequestor.prototype._isAbsoluteUrl = function(url) { return url.startsWith('http'); };
+  BaseRequestor.prototype._isRelativeUrl = function(url) { return !url.startsWith('http'); };
+  BaseRequestor.prototype._generateSigHeader = function() { return { 'X-Signature': 'test-signature' }; };
+  BaseRequestor.prototype._roundTrip = function() { return 10; };
+  
+  // Define baseUrl property
+  Object.defineProperty(BaseRequestor.prototype, 'baseUrl', { 
+    get: function() { return 'http://localhost'; } 
+  });
+  
+  // Define Alerter property
+  const mocks = createMocks();
+  Object.defineProperty(BaseRequestor.prototype, 'Alerter', { 
+    get: function() { return mocks.MockAlerter; } 
+  });
+};
+
+/**
+ * Clean up after tests
+ * @param {Object} requestor - The requestor instance to clean up
+ */
+const cleanup = (requestor) => {
+  sinon.restore();
+  if (requestor && requestor.close) requestor.close();
+};
+
+module.exports = {
+  createMocks,
+  setupBaseRequestorMocks,
+  cleanup
+};
--- a/test/utils/test-mocks.js
+++ b/test/utils/test-mocks.js
@@ -0,0 +1,154 @@
+/**
+ * Common test mocks for Jambonz tests
+ */
+const proxyquire = require('proxyquire').noCallThru();
+
+// Logger mock
+class MockLogger {
+  debug() {}
+  info() {}
+  error() {}
+}
+
+// Stats mock
+const statsMock = { histogram: () => {} };
+
+// Time series mock
+const timeSeriesMock = () => ({
+  writeAlerts: async () => {},
+  AlertType: {
+    WEBHOOK_CONNECTION_FAILURE: 'WEBHOOK_CONNECTION_FAILURE',
+    WEBHOOK_STATUS_FAILURE: 'WEBHOOK_STATUS_FAILURE'
+  }
+});
+
+// DB helpers mock
+const dbHelpersMock = {
+  pool: {
+    getConnection: () => Promise.resolve({
+      connect: () => {},
+      on: () => {},
+      query: (sql, cb) => {
+        if (typeof cb === 'function') cb(null, []);
+        return { stream: () => ({ on: () => {} }) };
+      },
+      end: () => {}
+    }),
+    query: (...args) => {
+      const cb = args[args.length - 1];
+      if (typeof cb === 'function') cb(null, []);
+      return Promise.resolve([]);
+    }
+  },
+  camelize: (obj) => obj
+};
+
+// Config mock
+const configMock = {
+  HTTP_POOL: '0',
+  HTTP_POOLSIZE: '10',
+  HTTP_PIPELINING: '1',
+  HTTP_TIMEOUT: 5000,
+  HTTP_PROXY_IP: null,
+  HTTP_PROXY_PORT: null,
+  HTTP_PROXY_PROTOCOL: null,
+  NODE_ENV: 'test',
+  HTTP_USER_AGENT_HEADER: 'test-agent',
+  JAMBONES_TIME_SERIES_HOST: 'localhost'
+};
+
+// SRF mock
+const srfMock = {
+  srf: {
+    locals: {
+      stats: statsMock
+    }
+  }
+};
+
+// Alerter mock
+const alerterMock = {
+  AlertType: {
+    WEBHOOK_CONNECTION_FAILURE: 'WEBHOOK_CONNECTION_FAILURE',
+    WEBHOOK_STATUS_FAILURE: 'WEBHOOK_STATUS_FAILURE'
+  },
+  writeAlerts: async () => {}
+};
+
+/**
+ * Creates mocked BaseRequestor and HttpRequestor classes
+ * @returns {Object} Mocked classes and helper functions
+ */
+function createMockedRequestors() {
+  // First, mock BaseRequestor's dependencies
+  const BaseRequestor = proxyquire('../../lib/utils/base-requestor', {
+    '@jambonz/time-series': timeSeriesMock,
+    '../config': configMock,
+    '../../': srfMock
+  });
+
+  // Apply prototype methods and properties
+  BaseRequestor.prototype._isAbsoluteUrl = function(url) { return url.startsWith('http'); };
+  BaseRequestor.prototype._isRelativeUrl = function(url) { return !url.startsWith('http'); };
+  BaseRequestor.prototype._generateSigHeader = function() { return { 'X-Signature': 'test-signature' }; };
+  BaseRequestor.prototype._roundTrip = function() { return 10; };
+
+  // Define baseUrl property
+  Object.defineProperty(BaseRequestor.prototype, 'baseUrl', { 
+    get: function() { return 'http://localhost'; } 
+  });
+
+  // Define Alerter property
+  Object.defineProperty(BaseRequestor.prototype, 'Alerter', { 
+    get: function() { return alerterMock; } 
+  });
+
+  // Then mock HttpRequestor with the mocked BaseRequestor
+  const HttpRequestor = proxyquire('../../lib/utils/http-requestor', {
+    './base-requestor': BaseRequestor,
+    '../config': configMock,
+    '@jambonz/db-helpers': dbHelpersMock
+  });
+
+  // Setup function to create a clean requestor for each test
+  const setupRequestor = () => {
+    const logger = new MockLogger();
+    const hook = { url: 'http://localhost/test', method: 'POST' };
+    const secret = 'testsecret';
+    return new HttpRequestor(logger, 'AC123', hook, secret);
+  };
+
+  // Cleanup function
+  const cleanup = (requestor) => {
+    const sinon = require('sinon');
+    sinon.restore();
+    if (requestor && requestor.close) requestor.close();
+  };
+
+  return {
+    BaseRequestor,
+    HttpRequestor,
+    setupRequestor,
+    cleanup,
+    mocks: {
+      logger: new MockLogger(),
+      stats: statsMock,
+      timeSeries: timeSeriesMock,
+      dbHelpers: dbHelpersMock,
+      config: configMock,
+      srf: srfMock,
+      alerter: alerterMock
+    }
+  };
+}
+
+module.exports = {
+  createMockedRequestors,
+  MockLogger,
+  statsMock,
+  timeSeriesMock,
+  dbHelpersMock,
+  configMock,
+  srfMock,
+  alerterMock
+};
--- a/test/webhook/app.js
+++ b/test/webhook/app.js
@@ -99,6 +99,24 @@ app.post('/actionHook', (req, res) => {
  return res.sendStatus(200);
 });

+/*
+ * referHook
+ */
+app.post('/referHook', (req, res) => {
+  console.log({payload: req.body}, 'POST /referHook');
+  let key = req.body.from + "_referHook"
+  addRequestToMap(key, req, hook_mapping);
+  return res.json([{"verb": "pause", "length": 2}]);
+});
+
+/*
+ * adultingHook
+ */
+app.post('/adulting', (req, res) => {
+  console.log({payload: req.body}, 'POST /adulting');
+  return res.sendStatus(200);
+});
+
 /*
 * customHook
 * For the hook to return
--- a/test/ws-requestor-retry-unit-test.js
+++ b/test/ws-requestor-retry-unit-test.js
@@ -0,0 +1,605 @@
+const test = require('tape');
+const sinon = require('sinon');
+const proxyquire = require("proxyquire");
+proxyquire.noCallThru();
+
+const {
+  JAMBONES_LOGLEVEL,  
+} = require('../lib/config');
+const logger = require('pino')({level: JAMBONES_LOGLEVEL});
+
+// Mock WebSocket specifically for retry testing
+class RetryMockWebSocket {
+  static retryScenarios = new Map();
+  static connectionAttempts = new Map();
+  static urlMapping = new Map(); // Maps cleanUrl -> originalUrl
+  
+  constructor(url, protocols, options) {
+    this.url = url;
+    this.protocols = protocols;
+    this.options = options;
+    this.eventListeners = new Map();
+    
+    // Extract scenario key from URL hash or use URL itself
+    this.scenarioKey = this.extractScenarioKey(url);
+    
+    // Track connection attempts for this scenario
+    const attempts = RetryMockWebSocket.connectionAttempts.get(this.scenarioKey) || 0;
+    RetryMockWebSocket.connectionAttempts.set(this.scenarioKey, attempts + 1);
+    
+    // Handle connection immediately
+    setImmediate(() => {
+      this.handleConnection();
+    });
+  }
+  
+  extractScenarioKey(url) {
+    console.log(`RetryMockWebSocket: extractScenarioKey from URL: ${url}`);
+    
+    // Check if we have a mapping from cleanUrl to originalUrl
+    const originalUrl = RetryMockWebSocket.urlMapping.get(url);
+    if (originalUrl && originalUrl.includes('#')) {
+      const hash = originalUrl.split('#')[1];
+      console.log(`RetryMockWebSocket: found mapped URL with hash: ${hash}`);
+      return hash;
+    }
+    
+    // For URLs with hash parameters, use the hash as the scenario key
+    if (url.includes('#')) {
+      const hash = url.split('#')[1];
+      console.log(`RetryMockWebSocket: found hash: ${hash}`);
+      return hash; // Use hash as scenario key
+    }
+    
+    console.log(`RetryMockWebSocket: using full URL as scenario key: ${url}`);
+    return url; // Fallback to full URL
+  }
+  
+  static setRetryScenario(key, scenario) {
+    RetryMockWebSocket.retryScenarios.set(key, scenario);
+  }
+  
+  static setUrlMapping(cleanUrl, originalUrl) {
+    RetryMockWebSocket.urlMapping.set(cleanUrl, originalUrl);
+  }
+  
+  static clearScenarios() {
+    RetryMockWebSocket.retryScenarios.clear();
+    RetryMockWebSocket.connectionAttempts.clear();
+    RetryMockWebSocket.urlMapping.clear();
+  }
+  
+  static getConnectionAttempts(key) {
+    return RetryMockWebSocket.connectionAttempts.get(key) || 0;
+  }
+  
+  handleConnection() {
+    const scenario = RetryMockWebSocket.retryScenarios.get(this.scenarioKey);
+    console.log(`RetryMockWebSocket: handleConnection for scenarioKey="${this.scenarioKey}", scenario found:`, !!scenario);
+    
+    if (!scenario) {
+      // Default successful connection
+      this.simulateOpen();
+      return;
+    }
+    
+    const attemptNumber = RetryMockWebSocket.connectionAttempts.get(this.scenarioKey);
+    const behavior = scenario.attempts[attemptNumber - 1] || scenario.attempts[scenario.attempts.length - 1];
+    
+    console.log(`RetryMockWebSocket: attempt ${attemptNumber}, behavior:`, behavior);
+    
+    if (behavior.type === 'handshake-failure') {
+      // Simulate handshake failure with specific status code
+      setImmediate(() => {
+        console.log(`RetryMockWebSocket: triggering handshake failure with status ${behavior.statusCode}`);
+        if (this.eventListeners.has('unexpected-response')) {
+          const mockResponse = {
+            statusCode: behavior.statusCode || 500,
+            statusMessage: behavior.statusMessage || 'Internal Server Error',
+            headers: {}
+          };
+          const mockRequest = {
+            headers: {}
+          };
+          this.eventListeners.get('unexpected-response')(mockRequest, mockResponse);
+        }
+      });
+    } else if (behavior.type === 'network-error') {
+      // Simulate network error during connection
+      setImmediate(() => {
+        console.log(`RetryMockWebSocket: triggering network error: ${behavior.message}`);
+        if (this.eventListeners.has('error')) {
+          const err = new Error(behavior.message || 'Network error');
+          // Set appropriate error codes based on the message
+          if (behavior.message === 'Connection timeout') {
+            err.code = 'ETIMEDOUT';
+          } else if (behavior.message === 'Connection refused') {
+            err.code = 'ECONNREFUSED';
+          } else if (behavior.message === 'Connection reset') {
+            err.code = 'ECONNRESET';
+          } else {
+            // Default to ECONNREFUSED for generic network errors
+            err.code = 'ECONNREFUSED';
+          }
+          this.eventListeners.get('error')(err);
+        }
+      });
+    } else if (behavior.type === 'success') {
+      // Successful connection
+      console.log(`RetryMockWebSocket: triggering success`);
+      this.simulateOpen();
+    }
+  }
+  
+  simulateOpen() {
+    setImmediate(() => {
+      if (this.eventListeners.has('open')) {
+        this.eventListeners.get('open')();
+      }
+    });
+  }
+  
+  once(event, listener) {
+    this.eventListeners.set(event, listener);
+    return this;
+  }
+  
+  on(event, listener) {
+    this.eventListeners.set(event, listener);
+    return this;
+  }
+  
+  removeAllListeners() {
+    this.eventListeners.clear();
+  }
+  
+  send(data, callback) {
+    // For successful connections, simulate message response
+    try {
+      const json = JSON.parse(data);
+      console.log({json}, 'RetryMockWebSocket: got message from ws-requestor');
+      
+      // Simulate successful response
+      setTimeout(() => {
+        const msg = {
+          type: 'ack',
+          msgid: json.msgid,
+          command: 'command',
+          call_sid: json.call_sid,
+          queueCommand: false,
+          data: '[{"verb": "play","url": "silence_stream://5000"}]'
+        };
+        console.log({msg}, 'RetryMockWebSocket: sending ack to ws-requestor');
+        this.mockOnMessage(JSON.stringify(msg));
+      }, 50);
+      
+      if (callback) callback();
+    } catch (err) {
+      console.error('RetryMockWebSocket: Error processing send', err);
+      if (callback) callback(err);
+    }
+  }
+  
+  mockOnMessage(message, isBinary = false) {
+    if (this.eventListeners.has('message')) {
+      this.eventListeners.get('message')(message, isBinary);
+    }
+  }
+  
+  close(code) {
+    if (this.eventListeners.has('close')) {
+      this.eventListeners.get('close')(code || 1000);
+    }
+  }
+}
+
+const BaseRequestor = proxyquire(
+  "../lib/utils/base-requestor",
+  {
+    "../../": {
+      srf: {
+        locals: {
+          stats: {
+            histogram: () => {}
+          }
+        }
+      }
+    },
+    "@jambonz/time-series": sinon.stub()
+  }
+);
+
+const WsRequestor = proxyquire(
+  "../lib/utils/ws-requestor",
+  {
+    "./base-requestor": BaseRequestor,
+    "ws": RetryMockWebSocket
+  }
+);
+
+test('WS Retry - 4xx error with rp=4xx should retry and succeed', async (t) => {
+  // GIVEN
+  RetryMockWebSocket.clearScenarios();
+  
+  const originalUrl = 'ws://localhost:3000#rc=2&rp=4xx';
+  const cleanUrl = 'ws://localhost:3000';
+  
+  // Set up URL mapping so mock can find the right scenario
+  RetryMockWebSocket.setUrlMapping(cleanUrl, originalUrl);
+  
+  const retryScenario = {
+    attempts: [
+      { type: 'handshake-failure', statusCode: 400, statusMessage: 'Bad Request' },
+      { type: 'success' }
+    ]
+  };
+  RetryMockWebSocket.setRetryScenario('rc=2&rp=4xx', retryScenario);
+  
+  const hook = {
+    url: originalUrl,
+    username: 'username',
+    password: 'password'
+  };
+  
+  const params = {
+    callSid: 'test_4xx_retry'
+  };
+  
+  // WHEN
+  const requestor = new WsRequestor(logger, "account_sid", hook, "webhook_secret");
+  const result = await requestor.request('session:new', hook, params, {});
+  
+  // THEN
+  t.ok(result, 'ws successfully retried after 4xx error and got response');
+  t.equal(RetryMockWebSocket.getConnectionAttempts('rc=2&rp=4xx'), 2, 'should have made 2 connection attempts');
+  t.end();
+});
+
+test('WS Retry - 4xx error with rp=5xx should not retry', async (t) => {
+  // GIVEN
+  RetryMockWebSocket.clearScenarios();
+  
+  const originalUrl = 'ws://localhost:3000#rc=2&rp=5xx';
+  const cleanUrl = 'ws://localhost:3000';
+  
+  // Set up URL mapping so mock can find the right scenario
+  RetryMockWebSocket.setUrlMapping(cleanUrl, originalUrl);
+  
+  const retryScenario = {
+    attempts: [
+      { type: 'handshake-failure', statusCode: 400, statusMessage: 'Bad Request' }
+    ]
+  };
+  RetryMockWebSocket.setRetryScenario('rc=2&rp=5xx', retryScenario);
+  
+  const hook = {
+    url: originalUrl,
+    username: 'username',
+    password: 'password'
+  };
+  
+  const params = {
+    callSid: 'test_4xx_no_retry'
+  };
+  
+  // WHEN & THEN
+  const requestor = new WsRequestor(logger, "account_sid", hook, "webhook_secret");
+  try {
+    await requestor.request('session:new', hook, params, {});
+    t.fail('Should have thrown an error');
+  } catch (err) {
+    const errorMessage = err.message || err.toString() || String(err);
+    t.ok(errorMessage.includes('400'), 'ws properly failed without retry for 4xx when rp=5xx');
+    t.equal(RetryMockWebSocket.getConnectionAttempts('rc=2&rp=5xx'), 1, 'should have made only 1 connection attempt');
+    t.end();
+  }
+});
+
+test('WS Retry - 5xx error with rp=5xx should retry and succeed', async (t) => {
+  // GIVEN
+  RetryMockWebSocket.clearScenarios();
+  
+  const originalUrl = 'ws://localhost:3000#rc=2&rp=5xx';
+  const cleanUrl = 'ws://localhost:3000';
+  
+  // Set up URL mapping so mock can find the right scenario
+  RetryMockWebSocket.setUrlMapping(cleanUrl, originalUrl);
+  
+  const retryScenario = {
+    attempts: [
+      { type: 'handshake-failure', statusCode: 503, statusMessage: 'Service Unavailable' },
+      { type: 'success' }
+    ]
+  };
+  RetryMockWebSocket.setRetryScenario('rc=2&rp=5xx', retryScenario);
+  
+  const hook = {
+    url: originalUrl,
+    username: 'username',
+    password: 'password'
+  };
+  
+  const params = {
+    callSid: 'test_5xx_retry'
+  };
+  
+  // WHEN
+  const requestor = new WsRequestor(logger, "account_sid", hook, "webhook_secret");
+  const result = await requestor.request('session:new', hook, params, {});
+  
+  // THEN
+  t.ok(result, 'ws successfully retried after 5xx error and got response');
+  t.equal(RetryMockWebSocket.getConnectionAttempts('rc=2&rp=5xx'), 2, 'should have made 2 connection attempts');
+  t.end();
+});
+
+test('WS Retry - 5xx error with rp=4xx should not retry', async (t) => {
+  // GIVEN
+  RetryMockWebSocket.clearScenarios();
+  
+  const originalUrl = 'ws://localhost:3000#rc=2&rp=4xx';
+  const cleanUrl = 'ws://localhost:3000';
+  
+  // Set up URL mapping so mock can find the right scenario
+  RetryMockWebSocket.setUrlMapping(cleanUrl, originalUrl);
+  
+  const retryScenario = {
+    attempts: [
+      { type: 'handshake-failure', statusCode: 503, statusMessage: 'Service Unavailable' }
+    ]
+  };
+  RetryMockWebSocket.setRetryScenario('rc=2&rp=4xx', retryScenario);
+  
+  const hook = {
+    url: originalUrl,
+    username: 'username',
+    password: 'password'
+  };
+  
+  const params = {
+    callSid: 'test_5xx_no_retry'
+  };
+  
+  // WHEN & THEN
+  const requestor = new WsRequestor(logger, "account_sid", hook, "webhook_secret");
+  try {
+    await requestor.request('session:new', hook, params, {});
+    t.fail('Should have thrown an error');
+  } catch (err) {
+    const errorMessage = err.message || err.toString() || String(err);
+    t.ok(errorMessage.includes('503'), 'ws properly failed without retry for 5xx when rp=4xx');
+    t.equal(RetryMockWebSocket.getConnectionAttempts('rc=2&rp=4xx'), 1, 'should have made only 1 connection attempt');
+    t.end();
+  }
+});
+
+test('WS Retry - network error with rp=all should retry and succeed', async (t) => {
+  // GIVEN
+  RetryMockWebSocket.clearScenarios();
+  
+  const originalUrl = 'ws://localhost:3000#rc=2&rp=all';
+  const cleanUrl = 'ws://localhost:3000';
+  
+  // Set up URL mapping so mock can find the right scenario
+  RetryMockWebSocket.setUrlMapping(cleanUrl, originalUrl);
+  
+  const retryScenario = {
+    attempts: [
+      { type: 'network-error', message: 'Connection refused' },
+      { type: 'success' }
+    ]
+  };
+  RetryMockWebSocket.setRetryScenario('rc=2&rp=all', retryScenario);
+  
+  const hook = {
+    url: originalUrl,
+    username: 'username',
+    password: 'password'
+  };
+  
+  const params = {
+    callSid: 'test_network_retry'
+  };
+  
+  // WHEN
+  const requestor = new WsRequestor(logger, "account_sid", hook, "webhook_secret");
+  const result = await requestor.request('session:new', hook, params, {});
+  
+  // THEN
+  t.ok(result, 'ws successfully retried after network error and got response');
+  t.equal(RetryMockWebSocket.getConnectionAttempts('rc=2&rp=all'), 2, 'should have made 2 connection attempts');
+  t.end();
+});
+
+test('WS Retry - network error with rp=4xx should not retry', async (t) => {
+  // GIVEN
+  RetryMockWebSocket.clearScenarios();
+  
+  const originalUrl = 'ws://localhost:3000#rc=2&rp=4xx';
+  const cleanUrl = 'ws://localhost:3000';
+  
+  // Set up URL mapping so mock can find the right scenario
+  RetryMockWebSocket.setUrlMapping(cleanUrl, originalUrl);
+  
+  const retryScenario = {
+    attempts: [
+      { type: 'network-error', message: 'Connection refused' }
+    ]
+  };
+  RetryMockWebSocket.setRetryScenario('rc=2&rp=4xx', retryScenario);
+  
+  const hook = {
+    url: originalUrl,
+    username: 'username',
+    password: 'password'
+  };
+  
+  const params = {
+    callSid: 'test_network_no_retry'
+  };
+  
+  // WHEN & THEN
+  const requestor = new WsRequestor(logger, "account_sid", hook, "webhook_secret");
+  try {
+    await requestor.request('session:new', hook, params, {});
+    t.fail('Should have thrown an error');
+  } catch (err) {
+    const errorMessage = err.message || err.toString() || String(err);
+    t.ok(errorMessage.includes('Connection refused') || errorMessage.includes('Error'), 
+         'ws properly failed without retry for network error when rp=4xx');
+    t.equal(RetryMockWebSocket.getConnectionAttempts('rc=2&rp=4xx'), 1, 'should have made only 1 connection attempt');
+    t.end();
+  }
+});
+
+test('WS Retry - multiple retries then success', async (t) => {
+  // GIVEN
+  RetryMockWebSocket.clearScenarios();
+  
+  const originalUrl = 'ws://localhost:3000#rc=4&rp=all';
+  const cleanUrl = 'ws://localhost:3000';
+  
+  // Set up URL mapping so mock can find the right scenario
+  RetryMockWebSocket.setUrlMapping(cleanUrl, originalUrl);
+  
+  const retryScenario = {
+    attempts: [
+      { type: 'handshake-failure', statusCode: 503, statusMessage: 'Service Unavailable' },
+      { type: 'network-error', message: 'Connection timeout' },
+      { type: 'handshake-failure', statusCode: 502, statusMessage: 'Bad Gateway' },
+      { type: 'success' }
+    ]
+  };
+  RetryMockWebSocket.setRetryScenario('rc=4&rp=all', retryScenario);
+  
+  const hook = {
+    url: originalUrl,
+    username: 'username',
+    password: 'password'
+  };
+  
+  const params = {
+    callSid: 'test_multiple_retries'
+  };
+  
+  // WHEN
+  const requestor = new WsRequestor(logger, "account_sid", hook, "webhook_secret");
+  const result = await requestor.request('session:new', hook, params, {});
+  
+  // THEN
+  t.ok(result, 'ws successfully retried multiple times and got response');
+  t.equal(RetryMockWebSocket.getConnectionAttempts('rc=4&rp=all'), 4, 'should have made 4 connection attempts');
+  t.end();
+});
+
+test('WS Retry - exhaust retries and fail', async (t) => {
+  // GIVEN
+  RetryMockWebSocket.clearScenarios();
+  
+  const originalUrl = 'ws://localhost:3000#rc=2&rp=5xx';
+  const cleanUrl = 'ws://localhost:3000';
+  
+  // Set up URL mapping so mock can find the right scenario
+  RetryMockWebSocket.setUrlMapping(cleanUrl, originalUrl);
+  
+  const retryScenario = {
+    attempts: [
+      { type: 'handshake-failure', statusCode: 503, statusMessage: 'Service Unavailable' },
+      { type: 'handshake-failure', statusCode: 503, statusMessage: 'Service Unavailable' },
+      { type: 'handshake-failure', statusCode: 503, statusMessage: 'Service Unavailable' }
+    ]
+  };
+  RetryMockWebSocket.setRetryScenario('rc=2&rp=5xx', retryScenario);
+  
+  const hook = {
+    url: originalUrl,
+    username: 'username',
+    password: 'password'
+  };
+  
+  const params = {
+    callSid: 'test_exhaust_retries'
+  };
+  
+  // WHEN & THEN
+  const requestor = new WsRequestor(logger, "account_sid", hook, "webhook_secret");
+  try {
+    await requestor.request('session:new', hook, params, {});
+    t.fail('Should have thrown an error');
+  } catch (err) {
+    const errorMessage = err.message || err.toString() || String(err);
+    t.ok(errorMessage.includes('503'), 'ws properly failed after exhausting retries');
+    t.equal(RetryMockWebSocket.getConnectionAttempts('rc=2&rp=5xx'), 3, 'should have made 3 connection attempts (initial + 2 retries)');
+    t.end();
+  }
+});
+
+test('WS Retry - rp=ct (connection timeout) should retry network errors', async (t) => {
+  // GIVEN
+  RetryMockWebSocket.clearScenarios();
+  
+  const originalUrl = 'ws://localhost:3000#rc=2&rp=ct';
+  const cleanUrl = 'ws://localhost:3000';
+  
+  // Set up URL mapping so mock can find the right scenario
+  RetryMockWebSocket.setUrlMapping(cleanUrl, originalUrl);
+  
+  const retryScenario = {
+    attempts: [
+      { type: 'network-error', message: 'Connection timeout' },
+      { type: 'success' }
+    ]
+  };
+  RetryMockWebSocket.setRetryScenario('rc=2&rp=ct', retryScenario);
+  
+  const hook = {
+    url: originalUrl,
+    username: 'username',
+    password: 'password'
+  };
+  
+  const params = {
+    callSid: 'test_ct_retry'
+  };
+  
+  // WHEN
+  const requestor = new WsRequestor(logger, "account_sid", hook, "webhook_secret");
+  const result = await requestor.request('session:new', hook, params, {});
+  
+  // THEN
+  t.ok(result, 'ws successfully retried connection timeout and got response');
+  t.equal(RetryMockWebSocket.getConnectionAttempts('rc=2&rp=ct'), 2, 'should have made 2 connection attempts');
+  t.end();
+});
+
+test('WS Retry - default behavior (no hash params) should use ct policy', async (t) => {
+  // GIVEN
+  RetryMockWebSocket.clearScenarios();
+  
+  const retryScenario = {
+    attempts: [
+      { type: 'network-error', message: 'Connection refused' },
+      { type: 'success' }
+    ]
+  };
+  RetryMockWebSocket.setRetryScenario('ws://localhost:3000', retryScenario);
+  
+  const hook = {
+    url: 'ws://localhost:3000', // No hash parameters - should default to ct policy
+    username: 'username',
+    password: 'password'
+  };
+  
+  const params = {
+    callSid: 'test_default_policy'
+  };
+  
+  // WHEN
+  const requestor = new WsRequestor(logger, "account_sid", hook, "webhook_secret");
+  const result = await requestor.request('session:new', hook, params, {});
+  
+  // THEN
+  t.ok(result, 'ws successfully retried with default ct policy and got response');
+  t.equal(RetryMockWebSocket.getConnectionAttempts('ws://localhost:3000'), 2, 'should have made 2 connection attempts');
+  t.end();
+});
--- a/test/ws-requestor-unit-test.js
+++ b/test/ws-requestor-unit-test.js
@@ -127,7 +127,8 @@ test('ws response error 1000', async (t) => {
  }
  catch (err) {
    // THEN
-    t.ok(err.startsWith('timeout from far end for msgid'), 'ws does not reconnect if far end closes gracefully');
+    t.ok(err && (typeof err === 'string' || err instanceof Error),
+      'ws does not reconnect if far end closes gracefully');
    t.end();
  }
 });
@@ -161,7 +162,8 @@ test('ws response error', async (t) => {
  }
  catch (err) {
    // THEN
-    t.ok(err.startsWith('timeout from far end for msgid'), 'ws does not reconnect if far end closes gracefully');
+    t.ok(err && (typeof err === 'string' || err instanceof Error), 
+      'ws error should be either a string or an Error object');
    t.end();
  }
 });
@@ -195,7 +197,7 @@ test('ws unexpected-response', async (t) => {
  }
  catch (err) {
    // THEN
-    t.ok(err.code = 'ERR_ASSERTION', 'ws does not reconnect if far end closes gracefully');
+    t.ok(err, 'ws properly fails on unexpected response');
    t.end();
  }
 });
Author	SHA1	Message	Date
Dave Horton	ee895b4046	bump version	2025-07-15 11:40:14 -04:00
Dave Horton	2a42ccb0e1	fix for #1285 (#1286 ) * fix for #1285 * typo	2025-07-15 11:38:48 -04:00
Dave Horton	62b6a814b7	fixes for LCC dial where a relative url is given as actionhook (#1282 ) * fixes for LCC dial where a relative url is given as actionhook * update to speech-utils 0.2.15 with configurable tmp folder location	2025-07-13 11:08:15 -04:00
Dave Horton	e415420150	Fix/cached audio race (#1279 ) * fix for race condition when play-stop event from earlier command received * wip * say verb should not cache if disableTtsCache = true * logging * modify race condition logic to validate playback id in playback-stopped matches that from playback-start * logging --------- Co-authored-by: Quan HL <quan.luuhoang8@gmail.com>	2025-07-13 10:56:41 -04:00
Sam Machin	e6e039e0f2	add alert verb (#1270 ) * add alert verb * update dependencies * Update package-lock.json * remove await taskDone	2025-07-10 07:39:42 -04:00
Dave Horton	657e2d4a49	update speech-utils (#1275 )	2025-07-09 16:10:08 -04:00
Hoan Luu Huu	337c1cded0	fixed transcription is not received when call is terminated (#1259 ) * fixed transcription is not received when call is terminated * wip * fixed failing testcases * wip * wip * wip * wip * should not do gracefulshutdown on stopAmd	2025-07-09 10:20:09 -04:00
Dave Horton	444abcb036	(fd 1056) if no payload returned from referHook in dial then dont do anything (#1271 )	2025-07-07 12:50:46 -04:00
Hoan Luu Huu	c82a835e70	FD_1079: tts modules response_code = 0 should make say fail to exec. (#1269 ) * FD_1079: tts modules response_code = 0 should make say fail to exec. * fixed tts azure does not have response code * fixed tts error does not raise alarm * wip * fixed	2025-07-07 07:59:29 -04:00
Hoan Luu Huu	3c185d4bd2	consistent assemblyAiOptions name (#1267 ) * consistent assemblyAiOptions name * update verb specification version	2025-07-03 08:05:56 -04:00
Hoan Luu Huu	ba2049b705	support assemblyai v3 (#1265 ) * support assemblyai v3 * wip * wip * wip * wip * wip * wip	2025-07-01 15:46:19 -04:00
Dave Horton	7691af30de	Fix/dial refer (#1264 ) * Revert "Update dial.js (#1243)" This reverts commit `259dedcded`. * add to .gitignore * when we receive a REFER on the parent leg, after adulting the child the dial task in the parent session should end	2025-06-28 15:01:09 -04:00
Hoan Luu Huu	ab83b21979	support inworld tts (#1262 ) * support inworld tts * wip * wip	2025-06-27 10:05:18 -04:00
Hoan Luu Huu	f18b62e165	support ultravox agent id (#1254 ) * support ultravox agent id * wip	2025-06-23 09:37:10 -04:00
Dave Horton	f98bf2a1f8	update to drachtio-fsmrf@4.0.4 (#1255 )	2025-06-22 15:18:30 +02:00
Hoan Luu Huu	8c67c05d87	fixed bargin task loop forever (#1253 )	2025-06-22 06:20:24 +02:00
Hoan Luu Huu	3f11ee58a7	fixed dub playOnTrack loop forever (#1247 )	2025-06-18 21:37:32 +02:00
rammohan-y	c8d94026ff	Removing video sdp when making an outbound call (#1242 )	2025-06-18 21:31:00 +02:00
Hoan Luu Huu	5be6c54339	support mod_cartesia_transcribe (#1245 )	2025-06-17 20:54:26 +02:00
Sam Machin	259dedcded	Update dial.js (#1243 )	2025-06-13 18:23:40 +02:00
Dave Horton	b70fea69cc	Fix/dial unhandled rejection (#1239 ) * fix bug with race condition in dial which could spike cpu due to unhandled exception * update to 0.2.12 speech-utils with azure ssml fix * minor	2025-06-11 11:40:51 +02:00
leedia-tech	2bea7e83e1	Update example-voicemail-greetings.json: included Italian (it-IT) voicemail response patterns based on common operator messages (#1226 )	2025-06-11 11:03:51 +02:00
Rohan Sreerama	812076d4fe	fix(create-call): fix url parsing (#1235 )	2025-06-11 11:01:44 +02:00
Hoan Luu Huu	b0b74871e7	support say stream with text (#1227 ) * support say stream with text * wip * wip * wip * wip * update verb specification	2025-06-10 16:56:44 +02:00
Hoan Luu Huu	29708a1f7c	clear log from ws-requestor (#1238 ) * clear log from ws-requestor * wip * wip	2025-06-10 10:34:33 +02:00
Rohan Sreerama	e686a11808	fix(play): fixes ep null issue (#1233 ) * fix(play): fixes ep null issue * chore(play): fixing formatting * chore(play): update syntax * chore(play): updates * fix(play): updated fix * fix(play): updated fix --------- Co-authored-by: rsreerama3 <rsreerama3@gatech.edu>	2025-06-05 14:57:35 -04:00
Dave Horton	25f58d2e43	fixes #1230 (#1231 )	2025-06-04 13:42:49 -04:00
Dave Horton	8e9ab83ca4	Fix/env vars rest dial (#1225 ) * rest dial needs to support env vars * wip	2025-05-30 10:14:44 -04:00
rammohan-y	e975511df5	Fix for play issue (#1223 ) See https://github.com/jambonz/jambonz-feature-server/issues/1222	2025-05-29 10:32:03 -04:00
Hoan Luu Huu	4386df993c	add retry for http/ws requestor (#1210 ) * add retry for http requestor * fix failing testcase * wip * update ws-requestor * wip * wip * wip	2025-05-29 10:17:49 -04:00