add startup logging

* Sending synthesized-audio notification for servedFromCache as well
https://github.com/jambonz/jambonz-feature-server/issues/1319

* Sending back the id that was set, to track the synthesized-audio
e.g if we send a say verb having 100, it's synthesized-audio event will return 100 in the data to correleate the say verb and synthesized-audio event

.github/workflows/build.yml

@@ -1,18 +1,22 @@
 name: CI
 
-on:
-  push:
+on: [push, pull_request]
 
 jobs:
   build:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v1
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
         with:
-          node-version: 16
+          node-version: 20
       - run: npm ci
       - run: npm run jslint
+      - name: Install Docker Compose
+        run: |
+          sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
+          sudo chmod +x /usr/local/bin/docker-compose
+          docker-compose --version
       - run: docker pull drachtio/sipp
       - run: npm test
         env:
@@ -20,3 +24,5 @@ jobs:
           AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
           AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
           AWS_REGION: ${{ secrets.AWS_REGION }}
+          MICROSOFT_REGION: ${{ secrets.MICROSOFT_REGION }}
+          MICROSOFT_API_KEY: ${{ secrets.MICROSOFT_API_KEY }}

.github/workflows/docker-publish.yml

@@ -2,16 +2,10 @@ name: Docker
 
 on:
   push:
-    # Publish `main` as Docker `latest` image.
     branches:
       - main
-
-    # Publish `v1.2.3` tags as releases.
     tags:
-      - v*
-
-env:
-  IMAGE_NAME: feature-server
+      - '*'
 
 jobs:
   push:
@@ -20,32 +14,41 @@ jobs:
     if: github.event_name == 'push'
 
     steps:
-      - uses: actions/checkout@v2
+      - name: Checkout code
+        uses: actions/checkout@v3
 
-      - name: Build image
-        run: docker build . --file Dockerfile --tag $IMAGE_NAME
-
-      - name: Log into registry
-        run: echo "${{ secrets.GITHUB_TOKEN }}" | docker login ghcr.io -u ${{ github.actor }} --password-stdin
-
-      - name: Push image
+      - name: prepare tag 
+        id: prepare_tag
         run: |
-          IMAGE_ID=ghcr.io/${{ github.repository_owner }}/$IMAGE_NAME
+            IMAGE_ID=jambonz/feature-server
 
-          # Change all uppercase to lowercase
-          IMAGE_ID=$(echo $IMAGE_ID | tr '[A-Z]' '[a-z]')
+            # Strip git ref prefix from version
+            VERSION=$(echo "${{ github.ref }}" | sed -e 's,.*/\(.*\),\1,')
 
-          # Strip git ref prefix from version
-          VERSION=$(echo "${{ github.ref }}" | sed -e 's,.*/\(.*\),\1,')
+            # Strip "v" prefix from tag name
+            [[ "${{ github.ref }}" == "refs/tags/"* ]] && VERSION=$(echo $VERSION | sed -e 's/^v//')
 
-          # Strip "v" prefix from tag name
-          [[ "${{ github.ref }}" == "refs/tags/"* ]] && VERSION=$(echo $VERSION | sed -e 's/^v//')
+            # Use Docker `latest` tag convention
+            [ "$VERSION" == "main" ] && VERSION=latest
 
-          # Use Docker `latest` tag convention
-          [ "$VERSION" == "main" ] && VERSION=latest
+            echo IMAGE_ID=$IMAGE_ID
+            echo VERSION=$VERSION
 
-          echo IMAGE_ID=$IMAGE_ID
-          echo VERSION=$VERSION
+            echo "image_id=$IMAGE_ID" >> $GITHUB_OUTPUT
+            echo "version=$VERSION" >> $GITHUB_OUTPUT
 
-          docker tag $IMAGE_NAME $IMAGE_ID:$VERSION
-          docker push $IMAGE_ID:$VERSION
+      - name: Login to Docker Hub 
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Build and push Docker image
+        uses: docker/build-push-action@v4
+        with:
+          context: .
+          push: true
+          tags: ${{ steps.prepare_tag.outputs.image_id }}:${{ steps.prepare_tag.outputs.version }}
+          build-args: |
+            GITHUB_REPOSITORY=$GITHUB_REPOSITORY
+            GITHUB_REF=$GITHUB_REF

.gitignore

@@ -2,6 +2,9 @@
 logs
 *.log
 
+.claude/
+CLAUDE.md 
+
 # Runtime data
 pids
 *.pid
@@ -40,4 +43,7 @@ examples/*
 ecosystem.config.js
 .vscode
 test/credentials/*.json
-run-tests.sh
+run-tests.sh
+run-coverage.sh
+.vscode
+.env

.vscode/launch.json

@@ -1,17 +0,0 @@
-{
-  // Use IntelliSense to learn about possible attributes.
-  // Hover to view descriptions of existing attributes.
-  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
-  "version": "0.2.0",
-  "configurations": [
-    {
-      "type": "node",
-      "request": "launch",
-      "name": "Launch Program",
-      "program": "${workspaceFolder}/test/index.js",
-      "env": {
-        "NODE_ENV": "test"
-      }
-    }
-  ]
-}

Dockerfile

@@ -1,4 +1,4 @@
-FROM --platform=linux/amd64 node:18.9.0-alpine3.16 as base
+FROM --platform=linux/amd64 node:20-alpine as base
 
 RUN apk --update --no-cache add --virtual .builds-deps build-base python3
 

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2021 Drachtio Communications Services, LLC
+Copyright (c) 2018-2024 FirstFive8, Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1,4 +1,4 @@
-# jambones-feature-server ![Build Status](https://github.com/jambonz/jambonz-feature-server/workflows/CI/badge.svg)
+# jambonz-feature-server [![CI](https://github.com/jambonz/jambonz-feature-server/actions/workflows/build.yml/badge.svg)](https://github.com/jambonz/jambonz-feature-server/actions/workflows/build.yml)
 
 This application implements the core feature server of the jambones platform.
 
@@ -13,13 +13,16 @@ Configuration is provided via environment variables:
 |AWS_ACCESS_KEY_ID| aws access key id, used for TTS/STT as well SNS notifications|no|
 |AWS_REGION| aws region| no|
 |AWS_SECRET_ACCESS_KEY| aws secret access key, used per above|no|
-|AWS_SNS_TOPIC_ARM| aws sns topic arn that scale-in lifecycle notifications will be published to|no|
+|AWS_SNS_TOPIC_ARN| aws sns topic arn that scale-in lifecycle notifications will be published to|no|
 |DRACHTIO_HOST| ip address of drachtio server (typically '127.0.0.1')|yes|
 |DRACHTIO_PORT| listening port of drachtio server for control connections (typically 9022)|yes|
 |DRACHTIO_SECRET| shared secret|yes|
 |ENABLE_METRICS| if 1, metrics will be generated|no|
+|ENCRYPTION_SECRET| secret for credential encryption(JWT_SECRET is deprecated) |yes|
 |GOOGLE_APPLICATION_CREDENTIALS| path to gcp service key file|yes|
 |HTTP_PORT| tcp port to listen on for API requests from jambonz-api-server|yes|
+|HTTP_IP| IP Address for API requests from jambonz-api-server |no|
+|JAMBONES_GATHER_EARLY_HINTS_MATCH| if true and hints are provided, gather will opportunistically review interim transcripts if possible to reduce ASR latency |no|
 |JAMBONES_FREESWITCH| IP:port:secret for Freeswitch server (e.g. '127.0.0.1:8021:JambonzR0ck$'|yes|
 |JAMBONES_LOGLEVEL| log level for application, 'info' or 'debug'|no|
 |JAMBONES_MYSQL_HOST| mysql host|yes|
@@ -35,6 +38,11 @@ Configuration is provided via environment variables:
 |STATS_PORT| listening port for metrics host|no|
 |STATS_PROTOCOL| 'tcp' or 'udp'|no|
 |STATS_TELEGRAF| if 1, metrics will be generated in telegraf format|no|
+|JAMBONZ_RECORD_WS_BASE_URL| recording websocket URL to send the recording audio|no|
+|JAMBONZ_RECORD_WS_USERNAME| recording websocket username|no|
+|JAMBONZ_RECORD_WS_PASSWORD| recording websocket password|no|
+|ANCHOR_MEDIA_ALWAYS| keep media on media server|no|
+|JAMBONZ_DISABLE_DIAL_PAI_HEADER| control P-Asserted-Identity header on B-Leg|no|
 
 ### running under pm2
 Typically, this application runs under [pm2](https://pm2.io) using an [ecosystem.config.js](https://pm2.keymetrics.io/docs/usage/application-declaration/) file similar to this:
@@ -64,7 +72,7 @@ module.exports = {
       STATS_PORT: 8125,
       STATS_PROTOCOL: 'tcp',
       STATS_TELEGRAF: 1,
-      AWS_SNS_TOPIC_ARM: 'arn:aws:sns:us-west-1:xxxxxxxxxxx:terraform-20201107200347128600000002',
+      AWS_SNS_TOPIC_ARN: 'arn:aws:sns:us-west-1:xxxxxxxxxxx:terraform-20201107200347128600000002',
       JAMBONES_NETWORK_CIDR: '172.31.0.0/16',
       JAMBONES_MYSQL_HOST: 'aurora-cluster-jambonz.cluster-yyyyyyyyyyy.us-west-1.rds.amazonaws.com',
       JAMBONES_MYSQL_USER: 'admin',
@@ -87,4 +95,4 @@ module.exports = {
 
 #### Running the test suite
 
-Please [see this]](./docs/contributing.md#run-the-regression-test-suite).
+Please [see this](./docs/contributing.md#run-the-regression-test-suite).

app.js

@@ -1,26 +1,104 @@
-const assert = require('assert');
-assert.ok(process.env.JAMBONES_MYSQL_HOST &&
-  process.env.JAMBONES_MYSQL_USER &&
-  process.env.JAMBONES_MYSQL_PASSWORD &&
-  process.env.JAMBONES_MYSQL_DATABASE, 'missing JAMBONES_MYSQL_XXX env vars');
-assert.ok(process.env.DRACHTIO_PORT || process.env.DRACHTIO_HOST, 'missing DRACHTIO_PORT env var');
-assert.ok(process.env.DRACHTIO_SECRET, 'missing DRACHTIO_SECRET env var');
-assert.ok(process.env.JAMBONES_FREESWITCH, 'missing JAMBONES_FREESWITCH env var');
-assert.ok(process.env.JAMBONES_REDIS_HOST, 'missing JAMBONES_REDIS_HOST env var');
-assert.ok(process.env.JAMBONES_NETWORK_CIDR || process.env.K8S, 'missing JAMBONES_SUBNET env var');
+const {
+  DRACHTIO_PORT,
+  DRACHTIO_HOST,
+  DRACHTIO_SECRET,
+  JAMBONES_OTEL_SERVICE_NAME,
+  JAMBONES_LOGLEVEL,
+  JAMBONES_CLUSTER_ID,
+  JAMBONZ_CLEANUP_INTERVAL_MINS,
+  getCleanupIntervalMins,
+  K8S,
+  NODE_ENV,
+  checkEnvs,
+} = require('./lib/config');
+
+checkEnvs();
 
 const Srf = require('drachtio-srf');
 const srf = new Srf();
-const tracer = require('./tracer')(process.env.JAMBONES_OTEL_SERVICE_NAME || 'jambonz-feature-server');
+const tracer = require('./tracer')(JAMBONES_OTEL_SERVICE_NAME);
 const api = require('@opentelemetry/api');
 srf.locals = {...srf.locals, otel: {tracer, api}};
 
-const opts = {level: process.env.JAMBONES_LOGLEVEL || 'info'};
+const opts = {
+  level: JAMBONES_LOGLEVEL
+};
 const pino = require('pino');
 const logger = pino(opts, pino.destination({sync: false}));
-const {LifeCycleEvents, FS_UUID_SET_NAME} = require('./lib/utils/constants');
+const {LifeCycleEvents, FS_UUID_SET_NAME, SystemState, FEATURE_SERVER} = require('./lib/utils/constants');
 const installSrfLocals = require('./lib/utils/install-srf-locals');
-installSrfLocals(srf, logger);
+const createHttpListener = require('./lib/utils/http-listener');
+const healthCheck = require('@jambonz/http-health-check');
+const ProcessMonitor = require('./lib/utils/process-monitor');
+const monitor = new ProcessMonitor(logger);
+
+// Log startup
+monitor.logStartup();
+monitor.setupSignalHandlers();
+
+logger.on('level-change', (lvl, _val, prevLvl, _prevVal, instance) => {
+  if (logger !== instance) {
+    return;
+  }
+  logger.info('system log level %s was changed to %s', prevLvl, lvl);
+});
+
+// Install the srf locals
+installSrfLocals(srf, logger, {
+  onFreeswitchConnect: (wraper) => {
+    // Only connect to drachtio if freeswitch is connected
+    logger.info(`connected to freeswitch at ${wraper.ms.address}, start drachtio server`);
+    if (DRACHTIO_HOST) {
+      srf.connect({host: DRACHTIO_HOST, port: DRACHTIO_PORT, secret: DRACHTIO_SECRET });
+      srf.on('connect', (err, hp) => {
+        const arr = /^(.*)\/(.*)$/.exec(hp.split(',').pop());
+        srf.locals.localSipAddress = `${arr[2]}`;
+        logger.info(`connected to drachtio listening on ${hp}, local sip address is ${srf.locals.localSipAddress}`);
+      });
+    }
+    else {
+      logger.info(`listening for drachtio requests on port ${DRACHTIO_PORT}`);
+      srf.listen({port: DRACHTIO_PORT, secret: DRACHTIO_SECRET});
+    }
+    // Start Http server
+    createHttpListener(logger, srf)
+      .then(({server, app}) => {
+        httpServer = server;
+        healthCheck({app, logger, path: '/', fn: getCount});
+        return {server, app};
+      })
+      .catch((err) => {
+        logger.error(err, 'Error creating http listener');
+      });
+  },
+  onFreeswitchDisconnect: (wraper) => {
+    // check if all freeswitch connections are lost, disconnect drachtio server
+    logger.info(`lost connection to freeswitch at ${wraper.ms.address}`);
+    const ms = srf.locals.getFreeswitch();
+    if (!ms) {
+      logger.info('no freeswitch connections, stopping drachtio server');
+      disconnect();
+    }
+  }
+});
+if (NODE_ENV === 'test') {
+  srf.on('error', (err) => {
+    logger.info(err, 'Error connecting to drachtio');
+  });
+}
+
+// Init services
+const writeSystemAlerts = srf.locals?.writeSystemAlerts;
+if (writeSystemAlerts) {
+  writeSystemAlerts({
+    system_component: FEATURE_SERVER,
+    state : SystemState.Online,
+    fields : {
+      detail: `feature-server with process_id ${process.pid} started`,
+      host: srf.locals?.ipv4
+    }
+  });
+}
 
 const {
   initLocals,
@@ -35,24 +113,6 @@ const {
 const InboundCallSession = require('./lib/session/inbound-call-session');
 const SipRecCallSession = require('./lib/session/siprec-call-session');
 
-if (process.env.DRACHTIO_HOST) {
-  srf.connect({host: process.env.DRACHTIO_HOST, port: process.env.DRACHTIO_PORT, secret: process.env.DRACHTIO_SECRET });
-  srf.on('connect', (err, hp) => {
-    const arr = /^(.*)\/(.*)$/.exec(hp.split(',').pop());
-    srf.locals.localSipAddress = `${arr[2]}`;
-    logger.info(`connected to drachtio listening on ${hp}, local sip address is ${srf.locals.localSipAddress}`);
-  });
-}
-else {
-  logger.info(`listening for drachtio requests on port ${process.env.DRACHTIO_PORT}`);
-  srf.listen({port: process.env.DRACHTIO_PORT, secret: process.env.DRACHTIO_SECRET});
-}
-if (process.env.NODE_ENV === 'test') {
-  srf.on('error', (err) => {
-    logger.info(err, 'Error connecting to drachtio');
-  });
-}
-
 srf.use('invite', [
   initLocals,
   createRootSpan,
@@ -78,23 +138,28 @@ sessionTracker.on('idle', () => {
   }
 });
 const getCount = () => sessionTracker.count;
-const healthCheck = require('@jambonz/http-health-check');
+
 let httpServer;
 
-const createHttpListener = require('./lib/utils/http-listener');
-createHttpListener(logger, srf)
-  .then(({server, app}) => {
-    httpServer = server;
-    healthCheck({app, logger, path: '/', fn: getCount});
-    return {server, app};
-  })
-  .catch((err) => {
-    logger.error(err, 'Error creating http listener');
-  });
-
-
-setInterval(() => {
+const monInterval = setInterval(async() => {
   srf.locals.stats.gauge('fs.sip.calls.count', sessionTracker.count);
+  try {
+    const systemInformation = await srf.locals.dbHelpers.lookupSystemInformation();
+    if (systemInformation && systemInformation.log_level) {
+      const envLogLevel = logger.levels.values[JAMBONES_LOGLEVEL.toLowerCase()];
+      const dbLogLevel = logger.levels.values[systemInformation.log_level];
+      const appliedLogLevel = Math.min(envLogLevel, dbLogLevel);
+      if (logger.levelVal !== appliedLogLevel) {
+        logger.level = logger.levels.labels[Math.min(envLogLevel, dbLogLevel)];
+      }
+    }
+  } catch (err) {
+    if (process.env.NODE_ENV === 'test') {
+      clearInterval(monInterval);
+      logger.error('all tests complete');
+    }
+    else logger.error({err}, 'Error checking system log level in database');
+  }
 }, 20000);
 
 const disconnect = () => {
@@ -102,23 +167,50 @@ const disconnect = () => {
     httpServer?.on('close', resolve);
     httpServer?.close();
     srf.disconnect();
-    srf.locals.mediaservers.forEach((ms) => ms.disconnect());
+    srf.removeAllListeners();
+    srf.locals.mediaservers?.forEach((ms) => ms.disconnect());
   });
 };
-
-process.on('SIGUSR2', handle);
 process.on('SIGTERM', handle);
+process.on('SIGINT', handle);
 
-function handle(signal) {
+async function handle(signal) {
   const {removeFromSet} = srf.locals.dbHelpers;
-  const setName = `${(process.env.JAMBONES_CLUSTER_ID || 'default')}:active-fs`;
-  logger.info(`got signal ${signal}, removing ${srf.locals.localSipAddress} from set ${setName}`);
-  removeFromSet(setName, srf.locals.localSipAddress);
-  removeFromSet(FS_UUID_SET_NAME, srf.locals.fsUUID);
   srf.locals.disabled = true;
+  logger.info(`got signal ${signal}`);
+  const writeSystemAlerts = srf.locals?.writeSystemAlerts;
+  if (writeSystemAlerts) {
+    // it has to be synchronous call, or else by the time system saves the app terminates
+    await writeSystemAlerts({
+      system_component: FEATURE_SERVER,
+      state : SystemState.Offline,
+      fields : {
+        detail: `feature-server with process_id ${process.pid} stopped, signal ${signal}`,
+        host: srf.locals?.ipv4
+      }
+    });
+  }
+  const setName = `${(JAMBONES_CLUSTER_ID || 'default')}:active-fs`;
+  const fsServiceUrlSetName = `${(JAMBONES_CLUSTER_ID || 'default')}:fs-service-url`;
+  if (setName && srf.locals.localSipAddress) {
+    logger.info(`got signal ${signal}, removing ${srf.locals.localSipAddress} from set ${setName}`);
+    removeFromSet(setName, srf.locals.localSipAddress);
+  }
+  if (fsServiceUrlSetName && srf.locals.serviceUrl) {
+    logger.info(`got signal ${signal}, removing ${srf.locals.serviceUrl} from set ${fsServiceUrlSetName}`);
+    removeFromSet(fsServiceUrlSetName, srf.locals.serviceUrl);
+  }
+  removeFromSet(FS_UUID_SET_NAME, srf.locals.fsUUID);
+  if (K8S) {
+    srf.locals.lifecycleEmitter.operationalState = LifeCycleEvents.ScaleIn;
+  }
+  if (getCount() === 0) {
+    logger.info('no calls in progress, exiting');
+    process.exit(0);
+  }
 }
 
-if (process.env.JAMBONZ_CLEANUP_INTERVAL_MINS) {
+if (JAMBONZ_CLEANUP_INTERVAL_MINS) {
   const {clearFiles} = require('./lib/utils/cron-jobs');
 
   /* cleanup orphaned files or channels every so often */
@@ -128,7 +220,7 @@ if (process.env.JAMBONZ_CLEANUP_INTERVAL_MINS) {
     } catch (err) {
       logger.error({err}, 'app.js: error clearing files');
     }
-  }, 1000 * 60 * (process.env.JAMBONZ_CLEANUP_INTERVAL_MINS || 60));
+  }, getCleanupIntervalMins());
 }
 
 module.exports = {srf, logger, disconnect};

bin/k8s-pre-stop-hook.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 const bent = require('bent');
 const getJSON = bent('json');
-const PORT = process.env.HTTP_PORT || 3000;
+const {PORT} = require('../lib/config')
 
 const sleep = (ms) => {
   return new Promise((resolve) => setTimeout(resolve, ms));

data/example-voicemail-greetings.json

@@ -5,14 +5,116 @@
     "at the tone",
     "leave a message",
     "leave me a message",
-    "not available right now",
-    "not available to take your call",
+    "not available",
     "can't take your call",
-    "I will get back to you",
+    "will get back to you",
     "I'll get back to you",
-    "we will get back to you",
     "we are unable",
-    "we are not available"
+    "Unable to take your call now",
+    "I'll reply soon",
+    "I'll call back",
+    "I'll reach out to you as soon as possible",
+    "Leave a message",
+    "Away from phone",
+    "Not available now",
+    "I'll return call",
+    "On another call",
+    "Currently on another call",
+    "I will return call later",
+    "Busy please leave message",
+    "Message will be returned promptly",
+    "Currently unavailable to answer",
+    "Planning to return your call soon",
+    "Apologies for missing your call",
+    "Not by the phone at the moment",
+    "Expecting to return your call",
+    "Currently not accessible",
+    "Intend to call back",
+    "Appreciate your patience!",
+    "Engaged in another conversation",
+    "I Will respond promptly",
+    "Kindly leave a message",
+    "Currently occupied leave a message",
+    "Unfortunately unable to answer right now",
+    "Occupied at the moment",
+    "Not present leave a message",
+    "Regrettably unavailable kindly leave a message",
+    "Will ensure a prompt response to your message",
+    "Currently engaged",
+    "Will return your call at the earliest opportunity",
+    "Your message will receive my prompt attention",
+    "I'll respond as soon as I can",
+    "Your message is important please leave it after the beep",
+    "Away from the phone at the moment",
+    "Unable to answer right now",
+    "Engaged in another task",
+    "Not by the phone presently",
+    "I'll respond at my earliest convenience",
+    "Away from the phone momentarily",
+    "I'll return your call shortly",
+    "Currently not able to answer",
+    "Your message is important please leave it after the tone",
+    "I'm unable to take your call right now",
+    "Please leave your message for me",
+    "I'll get back to you soon",
+    "Your call has been missed",
+    "Please leave a detailed message for me to respond to",
+    "Leave a message I'll make sure to respond",
+    "Feel free to leave a message",
+    "Your call is important to me",
+    "I'll get back to you shortly",
+    "Your message will be attended to promptly",
+    "Not available at the moment",
+    "I'll be sure to get back to you",
+    "I'll call you back soon",
+    "I'll ensure a prompt response",
+    "Sorry for the inconvenience",
+    "I'll return your call",
+    "I'll make sure to get back to you",
+    "I'll call you back shortly",
+    "I'll return your call as soon as possible",
+    "Apologies for the inconvenience leave your message",
+    "Your call is appreciated",
+    "I'm unavailable to answer",
+    "I'm currently away",
+    "I'll return your call as soon as I can",
+    "I'm away from the phone",
+    "I'm currently unavailable to take your call",
+    "Sorry for missing your call",
+    "I'll ensure it receives my immediate attention",
+    "I'm away from the phone momentarily",
+    "I'll reach out to you shortly",
+    "Apologies for the inconvenience",
+    "Currently occupied",
+    "Unable to answer your call at the moment",
+    "I'll make sure to follow up with you",
+    "Sorry for not being available",
+    "I'll reach out to you as soon as I can",
+    "I'm currently engaged",
+    "I'm currently busy",
+    "I'm currently unavailable",
+    "I'll respond to you at my earliest convenience",
+    "Your message is appreciated",
+    "I'll get back to you promptly",
+    "I'll get back to you without delay",
+    "Currently away from the phone",
+    "I'll return your call at my earliest opportunity",
+    "Sorry for the missed call",
+    "I'll make sure to address your concerns",
+    "Please provide your details for a callback",
+    "I'll make every effort to respond promptly",
+    "I'll ensure it's attended to promptly",
+    "Away from the phone temporarily",
+    "I'll get back to you as soon as I return",
+    "Currently not in a position to answer your call",
+    "Your call cannot be answered at the moment",
+    "I'll ensure to respond as soon as I'm able",
+    "Your call is important please leave a message",
+    "Unable to answer right now please leave your message",
+    "Currently not accessible intending to return your call",
+    "I'll respond promptly to your message",
+    "leave a memo",
+    "please leave a memo"
   ],
   "es-ES": [
     "le pasamos la llamada",
@@ -48,5 +150,29 @@
     "ens posarem en contacto",
     "ara no estem disponibles",
     "no hi som"
+  ],
+  "de-DE": [
+    "nicht erreichbar",
+    "nnruf wurde weitergeleitet",
+    "beim piepsen",
+    "am ton",
+    "eine nachricht hinterlassen",
+    "hinterlasse mir eine Nachricht",
+    "nicht verfügbar",
+    "kann ihren anruf nicht entgegennehmen",
+    "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"
   ]
 }

docs/contributing.md

@@ -45,7 +45,7 @@ The GCP credential is the JSON service key in stringified format.
 
 #### Install Docker
 
-The test suite ralso equires [Docker](https://www.docker.com/) and docker-compose to be installed on your laptop.  Docker is used to set up a network with all of the elements required to test the jambonz-feature-server in a black-box type of fashion.
+The test suite also requires [Docker](https://www.docker.com/) and docker-compose to be installed on your laptop.  Docker is used to set up a network with all of the elements required to test the jambonz-feature-server in a black-box type of fashion.
 
 Once you have docker installed, you can optionally make sure everything Docker-wise is working properly by running this command from the project folder:
 

lib/config.js

@@ -0,0 +1,235 @@
+const assert = require('assert');
+
+const checkEnvs = () => {
+  assert.ok(process.env.JAMBONES_MYSQL_HOST &&
+		process.env.JAMBONES_MYSQL_USER &&
+		process.env.JAMBONES_MYSQL_PASSWORD &&
+		process.env.JAMBONES_MYSQL_DATABASE, 'missing JAMBONES_MYSQL_XXX env vars');
+  assert.ok(process.env.DRACHTIO_PORT || process.env.DRACHTIO_HOST, 'missing DRACHTIO_PORT env var');
+  assert.ok(process.env.DRACHTIO_SECRET, 'missing DRACHTIO_SECRET env var');
+  assert.ok(process.env.JAMBONES_FREESWITCH, 'missing JAMBONES_FREESWITCH env var');
+  if (process.env.JAMBONES_REDIS_SENTINELS) {
+    assert.ok(process.env.JAMBONES_REDIS_SENTINEL_MASTER_NAME,
+      'missing JAMBONES_REDIS_SENTINEL_MASTER_NAME env var, JAMBONES_REDIS_SENTINEL_PASSWORD env var is optional');
+  } else {
+    assert.ok(process.env.JAMBONES_REDIS_HOST, 'missing JAMBONES_REDIS_HOST env var');
+  }
+  assert.ok(process.env.JAMBONES_NETWORK_CIDR || process.env.K8S, 'missing JAMBONES_SUBNET env var');
+};
+
+const NODE_ENV = process.env.NODE_ENV;
+
+/* database mySQL */
+const JAMBONES_MYSQL_HOST = process.env.JAMBONES_MYSQL_HOST;
+const JAMBONES_MYSQL_USER = process.env.JAMBONES_MYSQL_USER;
+const JAMBONES_MYSQL_PASSWORD = process.env.JAMBONES_MYSQL_PASSWORD;
+const JAMBONES_MYSQL_DATABASE = process.env.JAMBONES_MYSQL_DATABASE;
+const JAMBONES_MYSQL_PORT = parseInt(process.env.JAMBONES_MYSQL_PORT, 10) || 3306;
+const JAMBONES_MYSQL_REFRESH_TTL = parseInt(process.env.JAMBONES_MYSQL_REFRESH_TTL, 10) || 0;
+const JAMBONES_MYSQL_CONNECTION_LIMIT = parseInt(process.env.JAMBONES_MYSQL_CONNECTION_LIMIT, 10) || 10;
+
+/* gather and hints */
+const JAMBONES_GATHER_EARLY_HINTS_MATCH = process.env.JAMBONES_GATHER_EARLY_HINTS_MATCH;
+const JAMBONZ_GATHER_EARLY_HINTS_MATCH = process.env.JAMBONZ_GATHER_EARLY_HINTS_MATCH;
+const JAMBONES_GATHER_CLEAR_GLOBAL_HINTS_ON_EMPTY_HINTS = process.env.JAMBONES_GATHER_CLEAR_GLOBAL_HINTS_ON_EMPTY_HINTS;
+
+const SMPP_URL = process.env.SMPP_URL;
+
+/* drachtio */
+const DRACHTIO_PORT = process.env.DRACHTIO_PORT;
+const DRACHTIO_HOST = process.env.DRACHTIO_HOST;
+const DRACHTIO_SECRET = process.env.DRACHTIO_SECRET;
+
+/* freeswitch */
+const JAMBONES_API_BASE_URL = process.env.JAMBONES_API_BASE_URL;
+const JAMBONES_FREESWITCH = process.env.JAMBONES_FREESWITCH;
+const JAMBONES_FREESWITCH_MAX_CALL_DURATION_MINS = parseInt(process.env.JAMBONES_FREESWITCH_MAX_CALL_DURATION_MINS, 10)
+	|| 180;
+
+
+const JAMBONES_SBCS = process.env.JAMBONES_SBCS;
+
+/* websockets */
+const JAMBONES_WS_HANDSHAKE_TIMEOUT_MS = parseInt(process.env.JAMBONES_WS_HANDSHAKE_TIMEOUT_MS, 10) || 1500;
+const JAMBONES_WS_MAX_PAYLOAD = parseInt(process.env.JAMBONES_WS_MAX_PAYLOAD, 10) || 24 * 1024;
+const JAMBONES_WS_PING_INTERVAL_MS = parseInt(process.env.JAMBONES_WS_PING_INTERVAL_MS, 10) || 0;
+const MAX_RECONNECTS = 5;
+const RESPONSE_TIMEOUT_MS = parseInt(process.env.JAMBONES_WS_API_MSG_RESPONSE_TIMEOUT, 10) || 5000;
+
+const JAMBONES_NETWORK_CIDR = process.env.JAMBONES_NETWORK_CIDR;
+const JAMBONES_TIME_SERIES_HOST = process.env.JAMBONES_TIME_SERIES_HOST;
+const JAMBONES_CLUSTER_ID = process.env.JAMBONES_CLUSTER_ID || 'default';
+const JAMBONES_ESL_LISTEN_ADDRESS = process.env.JAMBONES_ESL_LISTEN_ADDRESS;
+
+/* tracing */
+const JAMBONES_OTEL_ENABLED = process.env.JAMBONES_OTEL_ENABLED;
+const JAMBONES_OTEL_SERVICE_NAME = process.env.JAMBONES_OTEL_SERVICE_NAME || 'jambonz-feature-server';
+const OTEL_EXPORTER_JAEGER_AGENT_HOST = process.env.OTEL_EXPORTER_JAEGER_AGENT_HOST;
+const OTEL_EXPORTER_JAEGER_ENDPOINT = process.env.OTEL_EXPORTER_JAEGER_ENDPOINT;
+const OTEL_EXPORTER_ZIPKIN_URL = process.env.OTEL_EXPORTER_ZIPKIN_URL;
+const OTEL_EXPORTER_COLLECTOR_URL = process.env.OTEL_EXPORTER_COLLECTOR_URL;
+
+const JAMBONES_LOGLEVEL = process.env.JAMBONES_LOGLEVEL || 'info';
+const JAMBONES_INJECT_CONTENT = process.env.JAMBONES_INJECT_CONTENT;
+
+const PORT = parseInt(process.env.HTTP_PORT, 10) || 3000;
+const HTTP_IP = process.env.HTTP_IP;
+const HTTP_PORT_MAX = parseInt(process.env.HTTP_PORT_MAX, 10);
+
+const K8S = process.env.K8S;
+const K8S_SBC_SIP_SERVICE_NAME = process.env.K8S_SBC_SIP_SERVICE_NAME;
+
+const JAMBONES_SUBNET = process.env.JAMBONES_SUBNET;
+
+/* clean up */
+const JAMBONZ_CLEANUP_INTERVAL_MINS = process.env.JAMBONZ_CLEANUP_INTERVAL_MINS;
+const getCleanupIntervalMins = () => {
+  const interval = parseInt(JAMBONZ_CLEANUP_INTERVAL_MINS, 10) || 60;
+  return 1000 * 60 * interval;
+};
+
+/* speech vendors */
+const AWS_REGION = process.env.AWS_REGION;
+const AWS_ACCESS_KEY_ID = process.env.AWS_ACCESS_KEY_ID;
+const AWS_SECRET_ACCESS_KEY = process.env.AWS_SECRET_ACCESS_KEY;
+const AWS_SNS_PORT = parseInt(process.env.AWS_SNS_PORT, 10) || 3001;
+const AWS_SNS_TOPIC_ARN = process.env.AWS_SNS_TOPIC_ARN;
+const AWS_SNS_PORT_MAX = parseInt(process.env.AWS_SNS_PORT_MAX, 10) || 3005;
+
+const GCP_JSON_KEY = process.env.GCP_JSON_KEY;
+
+const MICROSOFT_REGION = process.env.MICROSOFT_REGION;
+const MICROSOFT_API_KEY = process.env.MICROSOFT_API_KEY;
+
+const SONIOX_API_KEY = process.env.SONIOX_API_KEY;
+
+const DEEPGRAM_API_KEY = process.env.DEEPGRAM_API_KEY;
+
+const ANCHOR_MEDIA_ALWAYS = process.env.ANCHOR_MEDIA_ALWAYS;
+const VMD_HINTS_FILE = process.env.VMD_HINTS_FILE;
+
+const JAMBONES_AWS_TRANSCRIBE_USE_GRPC = process.env.JAMBONES_AWS_TRANSCRIBE_USE_GRPC;
+
+/* security, secrets */
+const LEGACY_CRYPTO = !!process.env.LEGACY_CRYPTO;
+const JWT_SECRET = process.env.JWT_SECRET;
+const ENCRYPTION_SECRET = process.env.ENCRYPTION_SECRET;
+
+/* HTTP/1 pool dispatcher */
+const HTTP_POOL = process.env.HTTP_POOL && parseInt(process.env.HTTP_POOL);
+const HTTP_POOLSIZE = parseInt(process.env.HTTP_POOLSIZE, 10) || 10;
+const HTTP_PIPELINING = parseInt(process.env.HTTP_PIPELINING, 10) || 1;
+const HTTP_TIMEOUT = 10000;
+const HTTP_PROXY_IP = process.env.JAMBONES_HTTP_PROXY_IP;
+const HTTP_PROXY_PORT = process.env.JAMBONES_HTTP_PROXY_PORT;
+const HTTP_PROXY_PROTOCOL = process.env.JAMBONES_HTTP_PROXY_PROTOCOL || 'http';
+const HTTP_USER_AGENT_HEADER = process.env.JAMBONES_HTTP_USER_AGENT_HEADER || 'jambonz';
+
+const OPTIONS_PING_INTERVAL = parseInt(process.env.OPTIONS_PING_INTERVAL, 10) || 30000;
+
+const JAMBONZ_RECORD_WS_BASE_URL = process.env.JAMBONZ_RECORD_WS_BASE_URL || process.env.JAMBONES_RECORD_WS_BASE_URL;
+const JAMBONZ_RECORD_WS_USERNAME = process.env.JAMBONZ_RECORD_WS_USERNAME || process.env.JAMBONES_RECORD_WS_USERNAME;
+const JAMBONZ_RECORD_WS_PASSWORD = process.env.JAMBONZ_RECORD_WS_PASSWORD || process.env.JAMBONES_RECORD_WS_PASSWORD;
+const JAMBONZ_DIAL_PAI_HEADER = process.env.JAMBONZ_DIAL_PAI_HEADER || false;
+const JAMBONES_DISABLE_DIRECT_P2P_CALL = process.env.JAMBONES_DISABLE_DIRECT_P2P_CALL || false;
+
+const JAMBONES_EAGERLY_PRE_CACHE_AUDIO = parseInt(process.env.JAMBONES_EAGERLY_PRE_CACHE_AUDIO, 10) || 0;
+
+const JAMBONES_USE_FREESWITCH_TIMER_FD = process.env.JAMBONES_USE_FREESWITCH_TIMER_FD;
+const JAMBONES_DIAL_SBC_FOR_REGISTERED_USER = process.env.JAMBONES_DIAL_SBC_FOR_REGISTERED_USER || false;
+const JAMBONES_MEDIA_TIMEOUT_MS = process.env.JAMBONES_MEDIA_TIMEOUT_MS || 0;
+const JAMBONES_MEDIA_HOLD_TIMEOUT_MS = process.env.JAMBONES_MEDIA_HOLD_TIMEOUT_MS || 0;
+// jambonz
+const JAMBONES_TRANSCRIBE_EP_DESTROY_DELAY_MS =
+  process.env.JAMBONES_TRANSCRIBE_EP_DESTROY_DELAY_MS;
+
+module.exports = {
+  JAMBONES_MYSQL_HOST,
+  JAMBONES_MYSQL_USER,
+  JAMBONES_MYSQL_PASSWORD,
+  JAMBONES_MYSQL_DATABASE,
+  JAMBONES_MYSQL_REFRESH_TTL,
+  JAMBONES_MYSQL_CONNECTION_LIMIT,
+  JAMBONES_MYSQL_PORT,
+
+  DRACHTIO_PORT,
+  DRACHTIO_HOST,
+  DRACHTIO_SECRET,
+
+  JAMBONES_GATHER_EARLY_HINTS_MATCH,
+  JAMBONZ_GATHER_EARLY_HINTS_MATCH,
+  JAMBONES_GATHER_CLEAR_GLOBAL_HINTS_ON_EMPTY_HINTS,
+  JAMBONES_FREESWITCH,
+  SMPP_URL,
+  JAMBONES_NETWORK_CIDR,
+  JAMBONES_API_BASE_URL,
+  JAMBONES_TIME_SERIES_HOST,
+  JAMBONES_INJECT_CONTENT,
+  JAMBONES_EAGERLY_PRE_CACHE_AUDIO,
+  JAMBONES_ESL_LISTEN_ADDRESS,
+  JAMBONES_SBCS,
+  JAMBONES_OTEL_ENABLED,
+  JAMBONES_OTEL_SERVICE_NAME,
+  OTEL_EXPORTER_JAEGER_AGENT_HOST,
+  OTEL_EXPORTER_JAEGER_ENDPOINT,
+  OTEL_EXPORTER_ZIPKIN_URL,
+  OTEL_EXPORTER_COLLECTOR_URL,
+
+  JAMBONES_LOGLEVEL,
+  JAMBONES_CLUSTER_ID,
+  PORT,
+  HTTP_PORT_MAX,
+  HTTP_IP,
+  K8S,
+  K8S_SBC_SIP_SERVICE_NAME,
+  JAMBONES_SUBNET,
+  NODE_ENV,
+  JAMBONZ_CLEANUP_INTERVAL_MINS,
+  getCleanupIntervalMins,
+  checkEnvs,
+
+  AWS_REGION,
+  AWS_ACCESS_KEY_ID,
+  AWS_SECRET_ACCESS_KEY,
+  AWS_SNS_PORT,
+  AWS_SNS_TOPIC_ARN,
+  AWS_SNS_PORT_MAX,
+
+  ANCHOR_MEDIA_ALWAYS,
+  VMD_HINTS_FILE,
+  JAMBONES_FREESWITCH_MAX_CALL_DURATION_MINS,
+  JAMBONES_AWS_TRANSCRIBE_USE_GRPC,
+
+  LEGACY_CRYPTO,
+  JWT_SECRET,
+  ENCRYPTION_SECRET,
+  HTTP_POOL,
+  HTTP_POOLSIZE,
+  HTTP_PIPELINING,
+  HTTP_TIMEOUT,
+  HTTP_PROXY_IP,
+  HTTP_PROXY_PORT,
+  HTTP_PROXY_PROTOCOL,
+  HTTP_USER_AGENT_HEADER,
+  OPTIONS_PING_INTERVAL,
+  RESPONSE_TIMEOUT_MS,
+  JAMBONES_WS_HANDSHAKE_TIMEOUT_MS,
+  JAMBONES_WS_MAX_PAYLOAD,
+  JAMBONES_WS_PING_INTERVAL_MS,
+  MAX_RECONNECTS,
+  GCP_JSON_KEY,
+  MICROSOFT_REGION,
+  MICROSOFT_API_KEY,
+  SONIOX_API_KEY,
+  DEEPGRAM_API_KEY,
+  JAMBONZ_RECORD_WS_BASE_URL,
+  JAMBONZ_RECORD_WS_USERNAME,
+  JAMBONZ_RECORD_WS_PASSWORD,
+  JAMBONZ_DIAL_PAI_HEADER,
+  JAMBONES_DISABLE_DIRECT_P2P_CALL,
+  JAMBONES_USE_FREESWITCH_TIMER_FD,
+  JAMBONES_DIAL_SBC_FOR_REGISTERED_USER,
+  JAMBONES_MEDIA_TIMEOUT_MS,
+  JAMBONES_MEDIA_HOLD_TIMEOUT_MS,
+  JAMBONES_TRANSCRIBE_EP_DESTROY_DELAY_MS,
+};

lib/dynamic-apps.js

@@ -0,0 +1,69 @@
+const appsMap = {
+  queue: {
+    // Dummy hook to follow later feature server logic.
+    call_hook: {
+      url: 'https://jambonz.org',
+      method: 'GET'
+    },
+    account_sid: '',
+    app_json: [{
+      verb: 'dequeue',
+      name: '',
+      timeout: 5
+    }]
+  },
+  user: {
+    // Dummy hook to follow later feature server logic.
+    call_hook: {
+      url: 'https://jambonz.org',
+      method: 'GET'
+    },
+    account_sid: '',
+    app_json: [{
+      verb: 'dial',
+      callerId: '',
+      answerOnBridge: true,
+      target: [
+        {
+          type: 'user',
+          name: ''
+        }
+      ]
+    }]
+  },
+  conference: {
+    // Dummy hook to follow later feature server logic.
+    call_hook: {
+      url: 'https://jambonz.org',
+      method: 'GET'
+    },
+    account_sid: '',
+    app_json: [{
+      verb: 'conference',
+      name: '',
+      beep: false,
+      startConferenceOnEnter: true
+    }]
+  }
+};
+
+const createJambonzApp = (type, {account_sid, name, caller_id}) => {
+  const app = {...appsMap[type]};
+  app.account_sid = account_sid;
+  switch (type) {
+    case 'queue':
+    case 'conference':
+      app.app_json[0].name = name;
+      break;
+    case 'user':
+      app.app_json[0].callerId = caller_id;
+      app.app_json[0].target[0].name = name;
+      break;
+  }
+  app.app_json = JSON.stringify(app.app_json);
+  return app;
+};
+
+module.exports = {
+  createJambonzApp
+};

lib/http-routes/api/create-call.js

@@ -3,249 +3,372 @@ const makeTask = require('../../tasks/make_task');
 const RestCallSession = require('../../session/rest-call-session');
 const CallInfo = require('../../session/call-info');
 const {CallDirection, CallStatus} = require('../../utils/constants');
-const { v4: uuidv4 } = require('uuid');
+const crypto = require('crypto');
 const SipError = require('drachtio-srf').SipError;
+const { validationResult, body } = require('express-validator');
+const { validate } = require('@jambonz/verb-specifications');
 const sysError = require('./error');
 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 { 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');
 
-router.post('/', async(req, res) => {
-  const {logger} = req.app.locals;
-  const accountSid = req.body.account_sid;
-  const {srf} = require('../../..');
+const removeNullProperties = (obj) => (Object.keys(obj).forEach((key) => obj[key] === null && delete obj[key]), obj);
+const removeNulls = (req, res, next) => {
+  req.body = removeNullProperties(req.body);
+  next();
+};
 
-  logger.debug({body: req.body}, 'got createCall request');
-  try {
-    let uri, cs, to;
-    const restDial = makeTask(logger, {'rest:dial': req.body});
-    const {lookupAccountDetails} = dbUtils(logger, srf);
-    const {getSBC, getFreeswitch} = srf.locals;
-    const sbcAddress = getSBC();
-    if (!sbcAddress) throw new Error('no available SBCs for outbound call creation');
-    const target = restDial.to;
-    const opts = {
-      callingNumber: restDial.from,
-      headers: req.body.headers || {}
-    };
+router.post('/',
+  removeNulls,
+  createCallSchema,
+  body('tag').custom((value) => {
+    if (value) {
+      customSanitizeFunction(value);
+    }
+    return true;
+  }),
+  async(req, res) => {
+    const {logger} = req.app.locals;
+    const errors = validationResult(req);
+    if (!errors.isEmpty()) {
+      logger.info({errors: errors.array()}, 'POST /Calls: validation errors');
+      return res.status(400).json({ errors: errors.array() });
+    }
+    const accountSid = req.body.account_sid;
+    const {srf} = require('../../..');
 
-
-    const {lookupTeamsByAccount, lookupAccountBySid} = srf.locals.dbHelpers;
-    const account = await lookupAccountBySid(req.body.account_sid);
-    const accountInfo = await lookupAccountDetails(req.body.account_sid);
-    const callSid = uuidv4();
-
-    opts.headers = {
-      ...opts.headers,
-      'X-Jambonz-Routing': target.type,
-      'X-Jambonz-FS-UUID': srf.locals.fsUUID,
-      'X-Call-Sid': callSid,
-      'X-Account-Sid': accountSid,
-      ...(restDial.fromHost && {'X-Preferred-From-Host': restDial.fromHost})
-    };
-
-    switch (target.type) {
-      case 'phone':
-      case 'teams':
-        uri = `sip:${target.number}@${sbcAddress}`;
-        to = target.number;
-        if ('teams' === target.type) {
-          const obj = await lookupTeamsByAccount(accountSid);
-          if (!obj) throw new Error('dial to ms teams not allowed; account must first be configured with teams info');
-          Object.assign(opts.headers, {
-            'X-MS-Teams-FQDN': obj.ms_teams_fqdn,
-            'X-MS-Teams-Tenant-FQDN': target.tenant || obj.tenant_fqdn
-          });
-          if (target.vmail === true) uri = `${uri};opaque=app:voicemail`;
-        }
-        break;
-      case 'user':
-        uri = `sip:${target.name}`;
-        to = target.name;
-        if (target.overrideTo) {
-          Object.assign(opts.headers, {
-            'X-Override-To': target.overrideTo
-          });
-        }
-        break;
-      case 'sip':
-        uri = target.sipUri;
-        to = uri;
-        break;
+    const app_json = req.body['app_json'];
+    try {
+    // app_json is created only by api-server.
+      if (app_json) {
+        // if available, delete from req before creating task
+        delete req.body.app_json;
+        // validate possible app_json via verb-specifications
+        validate(logger, JSON.parse(app_json));
+      }
+    } catch (err) {
+      logger.debug({ err }, `invalid app_json: ${err.message}`);
     }
 
-    if (target.type === 'phone' && target.trunk) {
-      const {lookupCarrier} = dbUtils(this.logger, srf);
-      const voip_carrier_sid = await lookupCarrier(req.body.account_sid, target.trunk);
-      logger.info(
-        `createCall: selected ${voip_carrier_sid} for requested carrier: ${target.trunk || 'unspecified'})`);
-      if (voip_carrier_sid) {
-        opts.headers['X-Requested-Carrier-Sid'] = voip_carrier_sid;
+    logger.debug({body: req.body}, 'got createCall request');
+    try {
+      let uri, cs, to;
+
+      const restDial = makeTask(logger, { 'rest:dial': req.body });
+      restDial.appJson = app_json;
+
+      const {lookupAccountDetails, lookupCarrierByPhoneNumber, lookupCarrier} = dbUtils(logger, srf);
+      const {
+        lookupAppBySid
+      }  = srf.locals.dbHelpers;
+      const {getSBC} = srf.locals;
+      let sbcAddress = getSBC();
+      if (!sbcAddress) throw new Error('no available SBCs for outbound call creation');
+      const target = restDial.to;
+      const opts = {
+        callingNumber: restDial.from,
+        ...(restDial.callerName && {callingName: restDial.callerName}),
+        headers: req.body.headers || {}
+      };
+
+
+      const {lookupTeamsByAccount, lookupAccountBySid} = srf.locals.dbHelpers;
+      const account = await lookupAccountBySid(req.body.account_sid);
+      const accountInfo = await lookupAccountDetails(req.body.account_sid);
+      const callSid = crypto.randomUUID();
+      const application = req.body.application_sid ? await lookupAppBySid(req.body.application_sid) : null;
+      const record_all_calls = account.record_all_calls || (application && application.record_all_calls);
+      const recordOutputFormat = account.record_format || 'mp3';
+      const rootSpan = new RootSpan('rest-call', {
+        callSid,
+        accountSid,
+        ...(req.body?.application_sid && {'X-Application-Sid': req.body.application_sid})
+      });
+
+      opts.headers = {
+        ...opts.headers,
+        'X-Jambonz-Routing': target.type,
+        'X-Jambonz-FS-UUID': srf.locals.fsUUID,
+        'X-Call-Sid': callSid,
+        'X-Account-Sid': accountSid,
+        'X-Trace-ID': rootSpan.traceId,
+        ...(req.body?.application_sid && {'X-Application-Sid': req.body.application_sid}),
+        ...(restDial.fromHost && {'X-Preferred-From-Host': restDial.fromHost}),
+        ...(record_all_calls && {'X-Record-All-Calls': recordOutputFormat}),
+        ...(target.proxy && {'X-SIP-Proxy': target.proxy}),
+        ...target.headers
+      };
+
+      switch (target.type) {
+        case 'phone':
+        case 'teams':
+          uri = `sip:${target.number}@${sbcAddress}`;
+          to = target.number;
+          if ('teams' === target.type) {
+            const obj = await lookupTeamsByAccount(accountSid);
+            if (!obj) throw new Error('dial to ms teams not allowed; account must first be configured with teams info');
+            Object.assign(opts.headers, {
+              'X-MS-Teams-FQDN': obj.ms_teams_fqdn,
+              'X-MS-Teams-Tenant-FQDN': target.tenant || obj.tenant_fqdn
+            });
+            if (target.vmail === true) uri = `${uri};opaque=app:voicemail`;
+          }
+          break;
+        case 'user':
+          uri = `sip:${target.name}`;
+          to = target.name;
+          if (target.overrideTo) {
+            Object.assign(opts.headers, {
+              'X-Override-To': target.overrideTo
+            });
+          }
+          break;
+        case 'sip':
+          uri = target.sipUri;
+          to = uri;
+          break;
       }
-    }
 
-    /* create endpoint for outdial */
-    const ms = getFreeswitch();
-    if (!ms) throw new Error('no available Freeswitch for outbound call creation');
-    const ep = await ms.createEndpoint();
-    logger.debug(`createCall: successfully allocated endpoint, sending INVITE to ${sbcAddress}`);
-
-    /* launch outdial */
-    let sdp, sipLogger;
-    const connectStream = async(remoteSdp) => {
-      if (remoteSdp !== sdp) {
-        ep.modify(sdp = remoteSdp);
-        return true;
+      if (target.type === 'phone' && target.trunk) {
+        const voip_carrier_sid = await lookupCarrier(req.body.account_sid, target.trunk);
+        logger.info(
+          `createCall: selected ${voip_carrier_sid} for requested carrier: ${target.trunk || 'unspecified'})`);
+        if (voip_carrier_sid) {
+          opts.headers['X-Requested-Carrier-Sid'] = voip_carrier_sid;
+        }
       }
-      return false;
-    };
-    Object.assign(opts, {
-      proxy: `sip:${sbcAddress}`,
-      localSdp: ep.local.sdp
-    });
-    if (target.auth) opts.auth = this.target.auth;
+
+      // find handling sbc sip for called user
+      if (JAMBONES_DIAL_SBC_FOR_REGISTERED_USER && target.type === 'user') {
+        const { registrar }  = srf.locals.dbHelpers;
+        const reg = await registrar.query(target.name);
+        if (reg) {
+          sbcAddress = selectHostPort(logger, reg.sbcAddress, 'tcp')[1];
+        }
+        //sbc outbound return 404 Notfound to handle case called user is not reigstered.
+      }
+
+      /**
+     * trunk isn't specified,
+     * check if from-number matches any existing numbers on Jambonz
+     *  */
+      if (target.type === 'phone' && !target.trunk) {
+        const str = restDial.from || '';
+        const callingNumber = str.startsWith('+') ? str.substring(1) : str;
+        const voip_carrier_sid = await lookupCarrierByPhoneNumber(req.body.account_sid, callingNumber);
+        logger.info(
+          `createCall: selected ${voip_carrier_sid} for requested phone number: ${callingNumber || 'unspecified'})`);
+        if (voip_carrier_sid) {
+          opts.headers['X-Requested-Carrier-Sid'] = voip_carrier_sid;
+        }
+      }
+
+      /* create endpoint for outdial */
+      const ep = await createMediaEndpoint(srf, logger);
+      logger.debug(`createCall: successfully allocated endpoint, sending INVITE to ${sbcAddress}`);
+
+      /* launch outdial */
+      let sdp, sipLogger;
+      let dualEp;
+      let localSdp = ep.local.sdp;
+
+      if (req.body.dual_streams) {
+        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;
+          if (req.body.dual_streams) {
+            const [sdpLegA, sdpLebB] = extractSdpMedia(remoteSdp);
+
+            await ep.modify(sdpLegA);
+            await dualEp.modify(sdpLebB);
+            await ep.bridge(dualEp);
+          } else {
+            ep.modify(sdp);
+          }
+          return true;
+        }
+        return false;
+      };
+      Object.assign(opts, {
+        proxy: `sip:${sbcAddress}`,
+        localSdp
+      });
+      if (target.auth) opts.auth = target.auth;
 
 
-    /**
+      /**
      * create our application object -
-     * not from the database as per an inbound call,
-     * but from the provided params in the request
+     * we merge the inbound call application,
+     * with the provided app params from the request body
      */
-    const app = req.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
+      };
 
-    /**
+      /**
      * attach our requestor and notifier objects
      * these will be used for all http requests we make during this call
      */
-    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) {
-        logger.debug('reusing websocket for call status hook');
-        app.notifier = app.requestor;
+      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) {
+          logger.debug('reusing websocket for call status hook');
+          app.notifier = app.requestor;
+          app.call_status_hook = app.call_hook;
+        }
+      }
+      else {
+        logger.debug({call_hook: app.call_hook}, 'creating http client for call hook');
+        app.requestor = new HttpRequestor(logger, account.account_sid, app.call_hook, account.webhook_secret);
+      }
+      if (!app.notifier && app.call_status_hook) {
+        app.notifier = new HttpRequestor(logger, account.account_sid, app.call_status_hook, account.webhook_secret);
+        logger.debug({call_status_hook: app.call_status_hook}, 'creating http client for call status hook');
+      }
+      else if (!app.notifier) {
+        logger.debug('creating null call status hook');
+        app.notifier = {request: () => {}, close: () => {}};
       }
-    }
-    else {
-      logger.debug({call_hook: app.call_hook}, 'creating http client for call hook');
-      app.requestor = new HttpRequestor(logger, account.account_sid, app.call_hook, account.webhook_secret);
-    }
-    if (!app.notifier && app.call_status_hook) {
-      app.notifier = new HttpRequestor(logger, account.account_sid, app.call_status_hook, account.webhook_secret);
-      logger.debug({call_hook: app.call_hook}, 'creating http client for call status hook');
-    }
-    else if (!app.notifier) {
-      logger.debug('creating null call status hook');
-      app.notifier = {request: () => {}};
-    }
 
-    /* now launch the outdial */
-    try {
-      const dlg = await srf.createUAC(uri, {...opts,  followRedirects: true, keepUriOnRedirect: true}, {
-        cbRequest: (err, inviteReq) => {
+      /* now launch the outdial */
+      try {
+        const dlg = await srf.createUAC(uri, {...opts,  followRedirects: true, keepUriOnRedirect: true}, {
+          cbRequest: (err, inviteReq) => {
           /* in case of 302 redirect, this gets called twice, ignore the second
               except to update the req so that it can later be canceled if need be
           */
-          if (res.headersSent) {
-            logger.info(`create-call: got redirect, updating request to new call-id ${req.get('Call-ID')}`);
-            if (cs) cs.req = inviteReq;
-            return;
+            if (res.headersSent) {
+              logger.info(`create-call: got redirect, updating request to new call-id ${req.get('Call-ID')}`);
+              if (cs) cs.req = inviteReq;
+              return;
+            }
+
+            if (err) {
+              logger.error(err, 'createCall Error creating call');
+              res.status(500).send('Call Failure');
+              return;
+            }
+            inviteReq.srf = srf;
+            inviteReq.locals = {
+              ...(inviteReq || {}),
+              callSid,
+              application_sid: app.application_sid
+            };
+            /* ok our outbound INVITE is in flight */
+
+            const tasks = [restDial];
+            sipLogger = logger.child({
+              callSid,
+              callId: inviteReq.get('Call-ID'),
+              accountSid,
+              traceId: rootSpan.traceId
+            }, {
+              ...(account.enable_debug_log && {level: 'debug'})
+            });
+            app.requestor.logger = app.notifier.logger = sipLogger;
+            const callInfo = new CallInfo({
+              direction: CallDirection.Outbound,
+              req: inviteReq,
+              to,
+              tag: app.tag,
+              callSid,
+              accountSid: req.body.account_sid,
+              applicationSid: app.application_sid,
+              traceId: rootSpan.traceId
+            });
+            cs = new RestCallSession({
+              logger: sipLogger,
+              application: app,
+              srf,
+              req: inviteReq,
+              ep,
+              ep2: dualEp,
+              tasks,
+              callInfo,
+              accountInfo,
+              rootSpan
+            });
+            cs.exec(req);
+
+            res.status(201).json({sid: cs.callSid, callId: inviteReq.get('Call-ID')});
+
+            sipLogger.info({sid: cs.callSid, callId: inviteReq.get('Call-ID')},
+              `outbound REST call attempt to ${JSON.stringify(target)} has been sent`);
+          },
+          cbProvisional: (prov) => {
+            const callStatus = prov.body ? CallStatus.EarlyMedia : CallStatus.Ringing;
+            // Update call-id for sbc outbound INVITE
+            cs.callInfo.sbcCallid = prov.get('X-CID');
+            if ([180, 183].includes(prov.status) && prov.body) connectStream(prov.body);
+            restDial.emit('callStatus', prov.status, !!prov.body);
+            cs.emit('callStatusChange', {callStatus, sipStatus: prov.status});
           }
-
-          if (err) {
-            logger.error(err, 'createCall Error creating call');
-            res.status(500).send('Call Failure');
-            return;
-          }
-          inviteReq.srf = srf;
-          inviteReq.locals = {
-            ...(inviteReq || {}),
-            callSid,
-            application_sid: app.application_sid
-          };
-          /* ok our outbound INVITE is in flight */
-
-          const tasks = [restDial];
-          const rootSpan = new RootSpan('rest-call', inviteReq);
-          sipLogger = logger.child({
-            callSid,
-            callId: inviteReq.get('Call-ID'),
-            accountSid,
-            traceId: rootSpan.traceId
+        });
+        connectStream(dlg.remote.sdp);
+        cs.emit('callStatusChange', {
+          callStatus: CallStatus.InProgress,
+          sipStatus: 200,
+          sipReason: 'OK'
+        });
+        restDial.emit('callStatus', 200);
+        restDial.emit('connect', dlg);
+      }
+      catch (err) {
+        let callStatus = CallStatus.Failed;
+        if (err instanceof SipError) {
+          if ([486, 603].includes(err.status)) callStatus = CallStatus.Busy;
+          else if (487 === err.status) callStatus = CallStatus.NoAnswer;
+          if (sipLogger) sipLogger.info(`REST outdial failed with ${err.status}`);
+          else console.log(`REST outdial failed with ${err.status}`);
+          if (cs) cs.emit('callStatusChange', {
+            callStatus,
+            sipStatus: err.status,
+            sipReason: err.reason
           });
-          app.requestor.logger = app.notifier.logger = sipLogger;
-          const callInfo = new CallInfo({
-            direction: CallDirection.Outbound,
-            req: inviteReq,
-            to,
-            tag: app.tag,
-            callSid,
-            accountSid: req.body.account_sid,
-            applicationSid: app.application_sid,
-            traceId: rootSpan.traceId
-          });
-          cs = new RestCallSession({
-            logger: sipLogger,
-            application: app,
-            srf,
-            req: inviteReq,
-            ep,
-            tasks,
-            callInfo,
-            accountInfo,
-            rootSpan
-          });
-          cs.exec(req);
-
-          res.status(201).json({sid: cs.callSid, callId: inviteReq.get('Call-ID')});
-
-          sipLogger.info({sid: cs.callSid, callId: inviteReq.get('Call-ID')},
-            `outbound REST call attempt to ${JSON.stringify(target)} has been sent`);
-        },
-        cbProvisional: (prov) => {
-          const callStatus = prov.body ? CallStatus.EarlyMedia : CallStatus.Ringing;
-          if ([180, 183].includes(prov.status) && prov.body) connectStream(prov.body);
-          restDial.emit('callStatus', prov.status, !!prov.body);
-          cs.emit('callStatusChange', {callStatus, sipStatus: prov.status});
+          cs.callGone = true;
         }
-      });
-      connectStream(dlg.remote.sdp);
-      cs.emit('callStatusChange', {
-        callStatus: CallStatus.InProgress,
-        sipStatus: 200,
-        sipReason: 'OK'
-      });
-      restDial.emit('callStatus', 200);
-      restDial.emit('connect', dlg);
-    }
-    catch (err) {
-      let callStatus = CallStatus.Failed;
-      if (err instanceof SipError) {
-        if ([486, 603].includes(err.status)) callStatus = CallStatus.Busy;
-        else if (487 === err.status) callStatus = CallStatus.NoAnswer;
-        if (sipLogger) sipLogger.info(`REST outdial failed with ${err.status}`);
-        else console.log(`REST outdial failed with ${err.status}`);
-        if (cs) cs.emit('callStatusChange', {
-          callStatus,
-          sipStatus: err.status,
-          sipReason: err.reason
-        });
+        else {
+          if (cs) cs.emit('callStatusChange', {
+            callStatus,
+            sipStatus: 500,
+            sipReason: 'Internal Server Error'
+          });
+          if (sipLogger) sipLogger.error({err}, 'REST outdial failed');
+          else console.error(err);
+        }
+        ep.destroy();
+        if (dualEp) {
+          dualEp.destroy();
+        }
+        setTimeout(restDial.kill.bind(restDial, cs), 5000);
       }
-      else {
-        if (cs) cs.emit('callStatusChange', {
-          callStatus,
-          sipStatus: 500,
-          sipReason: 'Internal Server Error'
-        });
-        if (sipLogger) sipLogger.error({err}, 'REST outdial failed');
-        else console.error(err);
-      }
-      ep.destroy();
-      setTimeout(restDial.kill.bind(restDial), 5000);
+    } catch (err) {
+      sysError(logger, res, err);
     }
-  } catch (err) {
-    sysError(logger, res, err);
-  }
-});
+  });
 
 module.exports = router;

lib/http-routes/api/create-message.js

@@ -2,7 +2,7 @@ const router = require('express').Router();
 const CallInfo = require('../../session/call-info');
 const {CallDirection} = require('../../utils/constants');
 const SmsSession = require('../../session/sms-call-session');
-const normalizeJambones = require('../../utils/normalize-jambones');
+const { normalizeJambones } = require('@jambonz/verb-specifications');
 const makeTask = require('../../tasks/make_task');
 
 router.post('/:sid', async(req, res) => {

lib/http-routes/api/messaging.js

@@ -4,7 +4,7 @@ const WsRequestor = require('../../utils/ws-requestor');
 const CallInfo = require('../../session/call-info');
 const {CallDirection} = require('../../utils/constants');
 const SmsSession = require('../../session/sms-call-session');
-const normalizeJambones = require('../../utils/normalize-jambones');
+const { normalizeJambones } = require('@jambonz/verb-specifications');
 const {TaskPreconditions} = require('../../utils/constants');
 const makeTask = require('../../tasks/make_task');
 
@@ -34,6 +34,7 @@ router.post('/:partner', async(req, res) => {
     carrier: req.params.partner,
     messageSid: app.messageSid,
     accountSid: app.accountSid,
+    serviceProviderSid: account.service_provider_sid,
     applicationSid: app.applicationSid,
     from: req.body.from,
     to: req.body.to,

lib/http-routes/api/update-call.js

@@ -9,25 +9,29 @@ const {CallStatus, CallDirection} = require('../../utils/constants');
  */
 function retrieveCallSession(callSid, opts) {
   if (opts.call_status_hook && !opts.call_hook) {
-    throw new DbErrorBadRequest('call_status_hook can be updated only when call_hook is also being updated');
+    throw new DbErrorBadRequest(
+      `call_status_hook can be updated only when call_hook is also being updated for call_sid ${callSid}`);
   }
   const cs = sessionTracker.get(callSid);
   if (!cs) {
-    throw new DbErrorUnprocessableRequest('call session is gone');
+    throw new DbErrorUnprocessableRequest(`call session is gone for call_sid ${callSid}`);
   }
 
   if (opts.call_status === CallStatus.Completed && !cs.hasStableDialog) {
-    throw new DbErrorUnprocessableRequest('current call state is incompatible with requested action');
+    throw new DbErrorUnprocessableRequest(
+      `current call state is incompatible with requested action for call_sid ${callSid}`);
   }
   else if (opts.call_status === CallStatus.NoAnswer) {
     if (cs.direction === CallDirection.Outbound) {
       if (!cs.isOutboundCallRinging) {
-        throw new DbErrorUnprocessableRequest('current call state is incompatible with requested action');
+        throw new DbErrorUnprocessableRequest(
+          `current call state is incompatible with requested action for call_sid ${callSid}`);
       }
     }
     else {
       if (cs.isInboundCallAnswered) {
-        throw new DbErrorUnprocessableRequest('current call state is incompatible with requested action');
+        throw new DbErrorUnprocessableRequest(
+          `current call state is incompatible with requested action for call_sid ${callSid}`);
       }
     }
   }
@@ -41,7 +45,7 @@ function retrieveCallSession(callSid, opts) {
 router.post('/:callSid', async(req, res) => {
   const logger = req.app.locals.logger;
   const callSid = req.params.callSid;
-  logger.debug({body: req.body}, 'got upateCall request');
+  logger.debug({body: req.body}, 'got updateCall request');
   try {
     const cs = retrieveCallSession(callSid, req.body);
     if (!cs) {

lib/http-routes/schemas/create-call.js

@@ -0,0 +1,134 @@
+const { checkSchema } = require('express-validator');
+
+/**
+ * @path api-server {{base_url}}/v1/Accounts/:account_sid/Calls
+ * @see https://api.jambonz.org/#243a2edd-7999-41db-bd0d-08082bbab401
+ */
+const createCallSchema = checkSchema({
+  application_sid: {
+    isString: true,
+    optional: true,
+    isLength: { options: { min: 36, max: 36 } },
+    errorMessage: 'Invalid application_sid',
+  },
+  answerOnBridge: {
+    isBoolean: true,
+    optional: true,
+    errorMessage: 'Invalid answerOnBridge',
+  },
+  from: {
+    errorMessage: 'Invalid from',
+    isString: true,
+    isLength: {
+      options: { min: 1, max: 256 },
+    },
+  },
+  fromHost: {
+    isString: true,
+    optional: true,
+    errorMessage: 'Invalid fromHost',
+  },
+  to: {
+    errorMessage: 'Invalid to',
+    isObject: true,
+  },
+  callerName: {
+    isString: true,
+    optional: true,
+    errorMessage: 'Invalid callerName',
+  },
+  amd: {
+    isObject: true,
+    optional: true,
+  },
+  tag: {
+    isObject: true,
+    optional: true,
+    errorMessage: 'Invalid tag',
+  },
+  app_json: {
+    isString: true,
+    optional: true,
+    errorMessage: 'Invalid app_json',
+  },
+  account_sid: {
+    isString: true,
+    optional: true,
+    errorMessage: 'Invalid account_sid',
+    isLength: { options: { min: 36, max: 36 } },
+  },
+  timeout: {
+    isInt: true,
+    optional: true,
+    errorMessage: 'Invalid timeout',
+  },
+  timeLimit: {
+    isInt: true,
+    optional: true,
+    errorMessage: 'Invalid timeLimit',
+  },
+  call_hook: {
+    isObject: true,
+    optional: true,
+    errorMessage: 'Invalid call_hook',
+  },
+  call_status_hook: {
+    isObject: true,
+    optional: true,
+    errorMessage: 'Invalid call_status_hook',
+  },
+  speech_synthesis_vendor: {
+    isString: true,
+    optional: true,
+    errorMessage: 'Invalid speech_synthesis_vendor',
+  },
+  speech_synthesis_language: {
+    isString: true,
+    optional: true,
+    errorMessage: 'Invalid speech_synthesis_language',
+  },
+  speech_synthesis_voice: {
+    isString: true,
+    optional: true,
+    errorMessage: 'Invalid speech_synthesis_voice',
+  },
+  speech_recognizer_vendor: {
+    isString: true,
+    optional: true,
+    errorMessage: 'Invalid speech_recognizer_vendor',
+  },
+  speech_recognizer_language: {
+    isString: true,
+    optional: true,
+    errorMessage: 'Invalid speech_recognizer_language',
+  }
+}, ['body']);
+
+const customSanitizeFunction = (value) => {
+  try {
+    if (Array.isArray(value)) {
+      value = value.map((item) => customSanitizeFunction(item));
+    } else if (typeof value === 'object') {
+      Object.keys(value).forEach((key) => {
+        value[key] = customSanitizeFunction(value[key]);
+      });
+    } else if (typeof value === 'string') {
+      /* trims characters at the beginning and at the end of a string */
+      value = value.trim();
+
+      // Only attempt to parse if the whole string is a URL
+      if (/^https?:\/\/\S+$/.test(value)) {
+        value = new URL(value).toString();
+      }
+    }
+  } catch (error) {
+    value = `Error: ${error.message}`;
+  }
+
+  return value;
+};
+
+module.exports = {
+  createCallSchema,
+  customSanitizeFunction
+};

lib/middleware.js

@@ -1,15 +1,21 @@
-const { v4: uuidv4 } = require('uuid');
-const {CallDirection, AllowedSipRecVerbs} = require('./utils/constants');
+const crypto = require('crypto');
+const {CallDirection, AllowedSipRecVerbs, WS_CLOSE_CODES} = require('./utils/constants');
 const {parseSiprecPayload} = require('./utils/siprec-utils');
 const CallInfo = require('./session/call-info');
 const HttpRequestor = require('./utils/http-requestor');
 const WsRequestor = require('./utils/ws-requestor');
 const makeTask = require('./tasks/make_task');
 const parseUri = require('drachtio-srf').parseUri;
-const normalizeJambones = require('./utils/normalize-jambones');
+const { normalizeJambones }  = require('@jambonz/verb-specifications');
 const dbUtils = require('./utils/db-utils');
 const RootSpan = require('./utils/call-tracer');
 const listTaskNames = require('./utils/summarize-tasks');
+const {
+  JAMBONES_MYSQL_REFRESH_TTL,
+  JAMBONES_DISABLE_DIRECT_P2P_CALL
+} = require('./config');
+const { createJambonzApp } = require('./dynamic-apps');
+const { decrypt } = require('./utils/encrypt-decrypt');
 
 module.exports = function(srf, logger) {
   const {
@@ -17,32 +23,95 @@ module.exports = function(srf, logger) {
     lookupAppByRegex,
     lookupAppBySid,
     lookupAppByRealm,
-    lookupAppByTeamsTenant
+    lookupAppByTeamsTenant,
+    registrar,
+    lookupClientByAccountAndUsername
   }  = srf.locals.dbHelpers;
   const {
     writeAlerts,
     AlertType
   } = srf.locals;
-  const {lookupAccountDetails} = dbUtils(logger, srf);
+  const {lookupAccountDetails, lookupGoogleCustomVoice} = dbUtils(logger, srf);
 
-  function initLocals(req, res, next) {
+  async function initLocals(req, res, next) {
     const callId = req.get('Call-ID');
-    logger.info({callId}, 'new incoming call');
+    const uri = parseUri(req.uri);
+    logger.info({
+      uri,
+      callId,
+      callingNumber: req.callingNumber,
+      calledNumber: req.calledNumber
+    }, 'new incoming call');
     if (!req.has('X-Account-Sid')) {
       logger.info('getAccountDetails - rejecting call due to missing X-Account-Sid header');
       return res.send(500);
     }
-    const callSid = req.has('X-Retain-Call-Sid') ? req.get('X-Retain-Call-Sid') : uuidv4();
+    const callSid = req.has('X-Retain-Call-Sid') ? req.get('X-Retain-Call-Sid') : crypto.randomUUID();
     const account_sid = req.get('X-Account-Sid');
     req.locals = {callSid, account_sid, callId};
-    if (req.has('X-Application-Sid')) {
+
+    let clientDb = null;
+    if (req.has('X-Authenticated-User')) {
+      req.locals.originatingUser = req.get('X-Authenticated-User');
+      let clientSettings;
+      const arr = /^(.*)@(.*)/.exec(req.locals.originatingUser);
+      if (arr) {
+        [clientSettings] = await lookupClientByAccountAndUsername(account_sid, arr[1]);
+      }
+      clientDb = await registrar.query(req.locals.originatingUser);
+      clientDb = {
+        ...clientDb,
+        ...clientSettings,
+      };
+    }
+
+    // check for call to application
+    if (uri.user?.startsWith('app-') && req.locals.originatingUser && clientDb?.allow_direct_app_calling) {
+      const application_sid = uri.user.match(/app-(.*)/)[1];
+      logger.debug(`got application from Request URI header: ${application_sid}`);
+      req.locals.application_sid = application_sid;
+    } else if (req.has('X-Application-Sid')) {
       const application_sid = req.get('X-Application-Sid');
       logger.debug(`got application from X-Application-Sid header: ${application_sid}`);
       req.locals.application_sid = application_sid;
     }
-    if (req.has('X-Authenticated-User')) req.locals.originatingUser = req.get('X-Authenticated-User');
-    if (req.has('X-MS-Teams-Tenant-FQDN')) req.locals.msTeamsTenant = req.get('X-MS-Teams-Tenant-FQDN');
+    // check for call to queue
+    else if (uri.user?.startsWith('queue-') && req.locals.originatingUser && clientDb?.allow_direct_queue_calling) {
+      const queue_name = uri.user.match(/queue-(.*)/)[1];
+      logger.debug(`got Queue from Request URI header: ${queue_name}`);
+      req.locals.queue_name = queue_name;
+    }
+    // check for call to conference
+    else if (uri.user?.startsWith('conference-') && req.locals.originatingUser && clientDb?.allow_direct_app_calling) {
+      const conference_id = uri.user.match(/conference-(.*)/)[1];
+      logger.debug(`got Conference from Request URI header: ${conference_id}`);
+      req.locals.conference_id = conference_id;
+    }
+    // check for call to registered user
+    else if (!JAMBONES_DISABLE_DIRECT_P2P_CALL && req.locals.originatingUser && clientDb?.allow_direct_user_calling) {
+      const arr = /^(.*)@(.*)/.exec(req.locals.originatingUser);
+      if (arr) {
+        const sipRealm = arr[2];
+        const called_user = `${req.calledNumber}@${sipRealm}`;
+        const reg = await registrar.query(called_user);
+        if (reg) {
+          logger.debug(`got called Number is a registered user: ${called_user}`);
+          req.locals.called_user = called_user;
+        }
+      }
+    }
 
+    if (req.has('X-MS-Teams-Tenant-FQDN')) req.locals.msTeamsTenant = req.get('X-MS-Teams-Tenant-FQDN');
+    if (req.has('X-Cisco-Recording-Participant')) {
+      const ciscoParticipants = req.get('X-Cisco-Recording-Participant');
+      const regex = /sip:[a-zA-Z0-9]+@[a-zA-Z0-9.-_]+/g;
+      const sipURIs = ciscoParticipants.match(regex);
+      logger.info(`X-Cisco-Recording-Participant : ${sipURIs} `);
+      if (sipURIs && sipURIs.length > 0) {
+        req.locals.calledNumber = sipURIs[0];
+        req.locals.callingNumber = sipURIs[1];
+      }
+    }
     next();
   }
 
@@ -90,8 +159,10 @@ module.exports = function(srf, logger) {
           .find((p) => p.type === 'application/sdp')
           .content;
         const {sdp1, sdp2, ...metadata} = await parseSiprecPayload(req, logger);
-        req.locals.calledNumber = metadata.caller.number;
-        req.locals.callingNumber = metadata.callee.number;
+        if (!req.locals.calledNumber && !req.locals.calledNumber) {
+          req.locals.calledNumber = metadata.caller.number;
+          req.locals.callingNumber = metadata.callee.number;
+        }
         req.locals = {
           ...req.locals,
           siprec: {
@@ -102,7 +173,7 @@ module.exports = function(srf, logger) {
         };
         logger.info({callId, metadata, sdp}, 'successfully parsed SIPREC payload');
       } catch (err) {
-        logger.info({callId}, 'Error parsing multipart payload');
+        logger.info({err, callId}, 'Error parsing multipart payload');
         return res.send(503);
       }
     }
@@ -117,13 +188,20 @@ module.exports = function(srf, logger) {
 
     const {span} = rootSpan.startChildSpan('lookupAccountDetails');
     try {
-      req.locals.accountInfo = await lookupAccountDetails(account_sid);
+      const accountDetail = await lookupAccountDetails(account_sid);
+      const account = accountDetail?.account;
+      req.locals.accountInfo = accountDetail;
+      req.locals.service_provider_sid = account?.service_provider_sid;
       span.end();
-      if (!req.locals.accountInfo.account.is_active) {
+      if (!account?.is_active) {
         logger.info(`Account is inactive or suspended ${account_sid}`);
         // TODO: alert
         return res.send(503, {headers: {'X-Reason': 'Account exists but is inactive'}});
       }
+      // Change the default log level to debug
+      if (account?.enable_debug_log) {
+        req.locals.logger.level = 'debug';
+      }
       logger.debug({accountInfo: req.locals?.accountInfo?.account}, `retrieved account info for ${account_sid}`);
       next();
     } catch (err) {
@@ -165,15 +243,27 @@ module.exports = function(srf, logger) {
     const {span} = rootSpan.startChildSpan('lookupApplication');
     try {
       let app;
-      if (req.locals.application_sid) app = await lookupAppBySid(req.locals.application_sid);
-      else if (req.locals.originatingUser) {
+      if (req.locals.queue_name) {
+        logger.debug(`calling to queue ${req.locals.queue_name}, generating queue app`);
+        app = createJambonzApp('queue', {account_sid, name: req.locals.queue_name});
+      } else if (req.locals.called_user) {
+        logger.debug(`calling to registered user ${req.locals.called_user}, generating dial app`);
+        app = createJambonzApp('user',
+          {account_sid, name: req.locals.called_user, caller_id: req.locals.callingNumber});
+      } else if (req.locals.conference_id) {
+        logger.debug(`calling to conference ${req.locals.conference_id}, generating conference app`);
+        app = createJambonzApp('conference', {account_sid, name: req.locals.conference_id});
+      } else if (req.locals.application_sid) {
+        app = await lookupAppBySid(req.locals.application_sid);
+      } else if (req.locals.originatingUser) {
         const arr = /^(.*)@(.*)/.exec(req.locals.originatingUser);
         if (arr) {
           const sipRealm = arr[2];
           logger.debug(`looking for device calling app for realm ${sipRealm}`);
           app = await lookupAppByRealm(sipRealm);
-          if (app) logger.debug({app}, `retrieved device calling app for realm ${sipRealm}`);
-
+          if (app) {
+            logger.debug({app}, `retrieved device calling app for realm ${sipRealm}`);
+          }
         }
       }
       else if (req.locals.msTeamsTenant) {
@@ -224,32 +314,63 @@ module.exports = function(srf, logger) {
       * create a requestor that we will use for all http requests we make during the call.
       * also create a notifier for call status events (if not needed, its a no-op).
       */
+
+      /* allow for caching data - when caching treat retrieved data as immutable */
+      const app2 = JAMBONES_MYSQL_REFRESH_TTL ? JSON.parse(JSON.stringify(app)) : app;
       if ('WS' === app.call_hook?.method ||
         app.call_hook?.url.startsWith('ws://') || app.call_hook?.url.startsWith('wss://')) {
-        app.requestor = new WsRequestor(logger, account_sid, app.call_hook, accountInfo.account.webhook_secret) ;
-        app.notifier = app.requestor;
-        app.call_hook.method = 'WS';
+        const requestor = new WsRequestor(logger, account_sid, app.call_hook, accountInfo.account.webhook_secret) ;
+        app2.requestor = requestor;
+        app2.notifier = requestor;
+        app2.call_hook.method = 'WS';
       }
       else {
-        app.requestor = new HttpRequestor(logger, account_sid, app.call_hook, accountInfo.account.webhook_secret);
-        if (app.call_status_hook) app.notifier = new HttpRequestor(logger, account_sid, app.call_status_hook,
+        app2.requestor = new HttpRequestor(logger, account_sid, app.call_hook, accountInfo.account.webhook_secret);
+        if (app.call_status_hook) app2.notifier = new HttpRequestor(logger, account_sid, app.call_status_hook,
           accountInfo.account.webhook_secret);
-        else app.notifier = {request: () => {}};
+        else app2.notifier = {request: () => {}, close: () => {}};
       }
 
-      req.locals.application = app;
-      const obj = Object.assign({}, app);
-      delete obj.requestor;
-      delete obj.notifier;
+      // Resolve application.speech_synthesis_voice if it's custom voice
+      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];
+          const [custom_voice] = await lookupGoogleCustomVoice(google_custom_voice_sid);
+          //google voice cloning key has size 200kb, jambonz should not resolve the voice here that the app's calling
+          //webhook will receive big payload, tts-task should resolve the voice later.
+          if (!custom_voice.use_voice_cloning_key) {
+            app2.speech_synthesis_voice = {
+              reportedUsage: custom_voice.reported_usage,
+              model: custom_voice.model
+            };
+          }
+        }
+      }
+
+      req.locals.application = app2;
       // eslint-disable-next-line no-unused-vars
-      const {call_hook, call_status_hook, ...appInfo} = obj;  // mask sensitive data like user/pass on webhook
-      logger.info({app: appInfo}, `retrieved application for incoming call to ${req.locals.calledNumber}`);
+      const {call_hook, call_status_hook, ...appInfo} = app;  // mask sensitive data like user/pass on webhook
+      // eslint-disable-next-line no-unused-vars
+      const {requestor, notifier, env_vars, ...loggable} = appInfo;
+      logger.info({app: loggable}, `retrieved application for incoming call to ${req.locals.calledNumber}`);
       req.locals.callInfo = new CallInfo({
         req,
-        app,
+        app: app2,
         direction: CallDirection.Inbound,
         traceId: rootSpan.traceId
       });
+      // if transferred call contains callInfo, let update original data to newly created callInfo in this instance.
+      if (app.transferredCall && app.callInfo) {
+        const {direction, callerName, from, to, originatingSipIp, originatingSipTrunkName} = app.callInfo;
+        req.locals.callInfo.direction = direction;
+        req.locals.callInfo.callerName = callerName;
+        req.locals.callInfo.from = from;
+        req.locals.callInfo.to = to;
+        req.locals.callInfo.originatingSipIp = originatingSipIp;
+        req.locals.callInfo.originatingSipTrunkName = originatingSipTrunkName;
+        delete app.callInfo;
+      }
       next();
     } catch (err) {
       span.end();
@@ -266,38 +387,66 @@ module.exports = function(srf, logger) {
     const {rootSpan, siprec, application:app} = req.locals;
     let span;
     try {
-      if (app.tasks && !process.env.JAMBONES_MYSQL_REFRESH_TTL) {
+      if (app.tasks && app.tasks?.length > 0 && !JAMBONES_MYSQL_REFRESH_TTL) {
         app.tasks = normalizeJambones(logger, app.tasks).map((tdata) => makeTask(logger, tdata));
         if (0 === app.tasks.length) throw new Error('no application provided');
         return next();
       }
       /* retrieve the application to execute for this inbound call */
-      const params = Object.assign(['POST', 'WS'].includes(app.call_hook.method) ? {sip: req.msg} : {},
-        req.locals.callInfo, {
-          defaults: {
-            synthesizer: {
-              vendor: app.speech_synthesis_vendor,
-              language: app.speech_synthesis_language,
-              voice: app.speech_synthesis_voice
-            },
-            recognizer: {
-              vendor: app.speech_recognizer_vendor,
-              language: app.speech_recognizer_language
-            }
+      let json;
+      if (app.app_json) {
+        json = JSON.parse(app.app_json);
+      } else {
+        const defaults = {
+          synthesizer: {
+            vendor: app.speech_synthesis_vendor,
+            ...(app.speech_synthesis_label && {label: app.speech_synthesis_label}),
+            language: app.speech_synthesis_language,
+            voice: app.speech_synthesis_voice,
+            ...(app.fallback_speech_synthesis_vendor && {fallback_vendor: app.fallback_speech_synthesis_vendor}),
+            ...(app.fallback_speech_synthesis_label && {fallback_label: app.fallback_speech_synthesis_label}),
+            ...(app.fallback_speech_synthesis_language && {fallback_language: app.fallback_speech_synthesis_language}),
+            ...(app.fallback_speech_synthesis_voice && {fallback_voice: app.fallback_speech_synthesis_voice})
+          },
+          recognizer: {
+            vendor: app.speech_recognizer_vendor,
+            ...(app.speech_recognizer_label && {label: app.speech_recognizer_label}),
+            language: app.speech_recognizer_language,
+            ...(app.fallback_speech_recognizer_vendor && {fallback_vendor: app.fallback_speech_recognizer_vendor}),
+            ...(app.fallback_speech_recognizer_label && {fallback_label: app.fallback_speech_recognizer_label}),
+            ...(app.fallback_speech_recognizer_language && {fallback_language: app.fallback_speech_recognizer_language})
           }
-        });
-      logger.debug({params}, 'sending initial webhook');
-      const obj = rootSpan.startChildSpan('performAppWebhook');
-      span = obj.span;
-      const b3 = rootSpan.getTracingPropagation();
-      const httpHeaders = b3 && {b3};
-      const json = await app.requestor.request('session:new', app.call_hook, params, httpHeaders);
+        };
+        let env_vars;
+        try {
+          if (app.env_vars) {
+            const d_env_vars = JSON.parse(decrypt(app.env_vars));
+            logger.info(`Setting env_vars: ${Object.keys(d_env_vars)}`); // Only log the keys not the values
+            env_vars = d_env_vars;
+          }
+        } 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,
+          { service_provider_sid: req.locals.service_provider_sid },
+          { defaults },
+          { env_vars }
+        );
+        logger.debug({ params }, 'sending initial webhook');
+        const obj = rootSpan.startChildSpan('performAppWebhook');
+        span = obj.span;
+        const b3 = rootSpan.getTracingPropagation();
+        const httpHeaders = b3 && { b3 };
+        json = await app.requestor.request('session:new', app.call_hook, params, httpHeaders, span);
+      }
+
       app.tasks = normalizeJambones(logger, json).map((tdata) => makeTask(logger, tdata));
-      span.setAttributes({
+      span?.setAttributes({
         'http.statusCode': 200,
         'app.tasks': listTaskNames(app.tasks)
       });
-      span.end();
+      span?.end();
       if (0 === app.tasks.length) throw new Error('no application provided');
 
       if (siprec) {
@@ -323,7 +472,7 @@ module.exports = function(srf, logger) {
       }).catch((err) => this.logger.info({err}, 'Error generating alert for parsing application'));
       logger.info({err}, `Error retrieving or parsing application: ${err?.message}`);
       res.send(480, {headers: {'X-Reason': err?.message || 'unknown'}});
-      app.requestor.close();
+      app.requestor.close(WS_CLOSE_CODES.GoingAway);
     }
   }
 

lib/session/adulting-call-session.js

@@ -1,4 +1,6 @@
 const CallSession = require('./call-session');
+const {CallStatus} = require('../utils/constants');
+const moment = require('moment');
 
 /**
  * @classdesc Subclass of CallSession.  Represents a CallSession
@@ -19,12 +21,14 @@ class AdultingCallSession extends CallSession {
       rootSpan
     });
     this.sd = singleDialer;
+    this.req = callInfo.req;
 
     this.sd.dlg.on('destroy', () => {
       this.logger.info('AdultingCallSession: called party hung up');
       this._callReleased();
     });
     this.sd.emit('adulting');
+    this.on('callStatusChange', this._notifyCallStatusChange.bind(this));
   }
 
   get dlg() {
@@ -41,14 +45,36 @@ class AdultingCallSession extends CallSession {
     return this.sd.ep;
   }
 
-  /* see note above */
-  set ep(newEp) {}
+  // When adulting session kicked from conference, replaceEndpoint is a must
+  set ep(newEp) {
+    this.sd.ep = newEp;
+  }
 
   get callSid() {
     return this.callInfo.callSid;
   }
 
   _callerHungup() {
+    this._hangup('caller');
+  }
+
+  _jambonzHangup() {
+    this._hangup();
+  }
+
+  _hangup(terminatedBy = 'jambonz') {
+    if (this.dlg.connectTime) {
+      const duration = moment().diff(this.dlg.connectTime, 'seconds');
+      this.rootSpan.setAttributes({'call.termination': `hangup by ${terminatedBy}`});
+      this.callInfo.callTerminationBy = terminatedBy;
+      this.emit('callStatusChange', {
+        callStatus: CallStatus.Completed,
+        duration
+      });
+    }
+    this.logger.info(`InboundCallSession: ${terminatedBy} hung up`);
+    this._callReleased();
+    this.req.removeAllListeners('cancel');
   }
 }
 

lib/session/call-info.js

@@ -1,6 +1,7 @@
 const {CallDirection, CallStatus} = require('../utils/constants');
 const parseUri = require('drachtio-srf').parseUri;
-const { v4: uuidv4 } = require('uuid');
+const crypto = require('crypto');
+const {JAMBONES_API_BASE_URL} = require('../config');
 /**
  * @classdesc Represents the common information for all calls
  * that is provided in call status webhooks
@@ -31,14 +32,32 @@ class CallInfo {
       this.sipStatus = 100;
       this.sipReason = 'Trying';
       this.callStatus = CallStatus.Trying;
+      this.sbcCallid = req.get('X-CID');
       this.originatingSipIp = req.get('X-Forwarded-For');
       this.originatingSipTrunkName = req.get('X-Originating-Carrier');
+      const {siprec} = req.locals;
+      if (siprec) {
+        const caller = parseUri(req.locals.callingNumber);
+        const callee = parseUri(req.locals.calledNumber);
+        this.participants = [
+          {
+            participant: 'caller',
+            uriUser: caller?.user,
+            uriHost: caller?.host
+          },
+          {
+            participant: 'callee',
+            uriUser: callee?.user,
+            uriHost: callee?.host
+          }
+        ];
+      }
     }
     else if (opts.parentCallInfo) {
       // outbound call that is a child of an existing call
       const {req, parentCallInfo, to, callSid} = opts;
       srf = req.srf;
-      this.callSid = callSid || uuidv4();
+      this.callSid = callSid || crypto.randomUUID();
       this.parentCallSid = parentCallInfo.callSid;
       this.accountSid = parentCallInfo.accountSid;
       this.applicationSid = parentCallInfo.applicationSid;
@@ -111,6 +130,7 @@ class CallInfo {
       from: this.from,
       to: this.to,
       callId: this.callId,
+      sbcCallid: this.sbcCallid,
       sipStatus: this.sipStatus,
       sipReason: this.sipReason,
       callStatus: this.callStatus,
@@ -129,8 +149,8 @@ class CallInfo {
       Object.assign(obj, {customerData: this._customerData});
     }
 
-    if (process.env.JAMBONES_API_BASE_URL) {
-      Object.assign(obj, {apiBaseUrl: process.env.JAMBONES_API_BASE_URL});
+    if (JAMBONES_API_BASE_URL) {
+      Object.assign(obj, {apiBaseUrl: JAMBONES_API_BASE_URL});
     }
     if (this.publicIp) {
       Object.assign(obj, {fsPublicIp: this.publicIp});

lib/session/confirm-call-session.js

@@ -8,7 +8,8 @@ const CallSession = require('./call-session');
 
  */
 class ConfirmCallSession extends CallSession {
-  constructor({logger, application, dlg, ep, tasks, callInfo, accountInfo, memberId, confName, rootSpan}) {
+  // eslint-disable-next-line max-len
+  constructor({logger, application, dlg, ep, tasks, callInfo, accountInfo, memberId, confName, rootSpan, req, tmpFiles}) {
     super({
       logger,
       application,
@@ -23,6 +24,8 @@ class ConfirmCallSession extends CallSession {
     });
     this.dlg = dlg;
     this.ep = ep;
+    this.req = req;
+    this.tmpFiles = tmpFiles;
   }
 
   /**
@@ -34,6 +37,9 @@ class ConfirmCallSession extends CallSession {
   _callerHungup() {
   }
 
+  _jambonzHangup() {
+  }
+
 
 }
 

lib/session/inbound-call-session.js

@@ -67,15 +67,33 @@ class InboundCallSession extends CallSession {
    * This is invoked when the caller hangs up, in order to calculate the call duration.
    */
   _callerHungup() {
+    this._hangup('caller');
+  }
+
+  _jambonzHangup(reason) {
+    this.dlg?.destroy({
+      headers: {
+        ...(reason && {'X-Reason': reason})
+      }
+    });
+    // kill current task or wakeup the call session.
+    this._callReleased();
+  }
+
+  _hangup(terminatedBy = 'jambonz') {
+    if (this.dlg === null) {
+      this.logger.info('InboundCallSession:_hangup - race condition, dlg cleared by app hangup');
+      return;
+    }
+    this.logger.info(`InboundCallSession: ${terminatedBy} hung up`);
     assert(this.dlg.connectTime);
     const duration = moment().diff(this.dlg.connectTime, 'seconds');
-    this.rootSpan.setAttributes({'call.termination': 'hangup by caller'});
-    this.callInfo.callTerminationBy = 'caller';
+    this.rootSpan.setAttributes({'call.termination': `hangup by ${terminatedBy}`});
+    this.callInfo.callTerminationBy = terminatedBy;
     this.emit('callStatusChange', {
       callStatus: CallStatus.Completed,
       duration
     });
-    this.logger.info('InboundCallSession: caller hung up');
     this._callReleased();
     this.req.removeAllListeners('cancel');
   }

lib/session/rest-call-session.js

@@ -1,14 +1,13 @@
 const CallSession = require('./call-session');
 const {CallStatus} = require('../utils/constants');
 const moment = require('moment');
-
 /**
  * @classdesc Subclass of CallSession.  This represents a CallSession that is
  * created for an outbound call that is initiated via the REST API.
  * @extends CallSession
  */
 class RestCallSession extends CallSession {
-  constructor({logger, application, srf, req, ep, tasks, callInfo, accountInfo, rootSpan}) {
+  constructor({logger, application, srf, req, ep, ep2, tasks, callInfo, accountInfo, rootSpan}) {
     super({
       logger,
       application,
@@ -21,12 +20,20 @@ class RestCallSession extends CallSession {
     });
     this.req = req;
     this.ep = ep;
+    this.ep2 = ep2;
+    // keep restDialTask reference for closing AMD
+    if (tasks.length) {
+      this.restDialTask = tasks[0];
+    }
 
     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'
+      });
     });
   }
 
@@ -37,17 +44,29 @@ class RestCallSession extends CallSession {
   setDialog(dlg) {
     this.dlg = dlg;
     dlg.on('destroy', this._callerHungup.bind(this));
+    dlg.on('refer', this._onRefer.bind(this));
+    dlg.on('modify', this._onReinvite.bind(this));
     this.wrapDialog(dlg);
   }
-
   /**
    * This is invoked when the called party hangs up, in order to calculate the call duration.
    */
   _callerHungup() {
-    this.callInfo.callTerminationBy = 'caller';
+    this._hangup('caller');
+  }
+
+  _jambonzHangup() {
+    this._hangup();
+  }
+
+  _hangup(terminatedBy = 'jambonz') {
+    if (this.restDialTask) {
+      this.restDialTask.turnOffAmd();
+    }
+    this.callInfo.callTerminationBy = terminatedBy;
     const duration = moment().diff(this.dlg.connectTime, 'seconds');
     this.emit('callStatusChange', {callStatus: CallStatus.Completed, duration});
-    this.logger.debug('RestCallSession: called party hung up');
+    this.logger.info(`RestCallSession: called party hung up by ${terminatedBy}`);
     this._callReleased();
   }
 

lib/session/siprec-call-session.js

@@ -1,6 +1,7 @@
 const InboundCallSession = require('./inbound-call-session');
 const {createSipRecPayload} = require('../utils/siprec-utils');
 const {CallStatus} = require('../utils/constants');
+const {parseSiprecPayload} = require('../utils/siprec-utils');
 /**
  * @classdesc Subclass of InboundCallSession.  This represents a CallSession that is
  * established for an inbound SIPREC call.
@@ -16,14 +17,39 @@ class SipRecCallSession extends InboundCallSession {
     this.metadata = metadata;
   }
 
+  async _onReinvite(req, res) {
+    try {
+      this.logger.info(req.payload, 'SipRec Re-INVITE payload');
+      const {sdp1: reSdp1, sdp2: reSdp2, metadata: reMetadata} = await parseSiprecPayload(req, this.logger);
+      this.sdp1 = reSdp1;
+      this.sdp2 = reSdp2;
+      this.metadata = reMetadata;
+
+      if (this.ep && this.ep2) {
+        let remoteSdp = this.sdp1.replace(/sendonly/, 'sendrecv');
+        const newSdp1 = await this.ep.modify(remoteSdp);
+        remoteSdp = this.sdp2.replace(/sendonly/, 'sendrecv');
+        const newSdp2 = await this.ep2.modify(remoteSdp);
+        const combinedSdp = await createSipRecPayload(newSdp1, newSdp2, this.logger);
+        res.send(200, {body: combinedSdp});
+        this.logger.info({offer: req.body, answer: combinedSdp}, 'SipRec handling reINVITE');
+      }
+      else {
+        this.logger.info('got SipRec reINVITE but no endpoint and media has not been released');
+        res.send(488);
+      }
+    } catch (err) {
+      this.logger.error(err, 'Error handling reinvite');
+    }
+  }
+
   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);

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;

lib/tasks/answer.js

@@ -0,0 +1,22 @@
+const Task = require('./task');
+const {TaskName, TaskPreconditions} = require('../utils/constants');
+
+/**
+ * Answer the call.
+ * Note: This is rarely used, as the call is typically answered automatically when required by the app,
+ * but it can be useful to force an answer before a pause in some cases
+ */
+class TaskAnswer extends Task {
+  constructor(logger, opts) {
+    super(logger, opts);
+    this.preconditions = TaskPreconditions.Endpoint;
+  }
+
+  get name() { return TaskName.Answer; }
+
+  async exec(cs) {
+    super.exec(cs);
+  }
+}
+
+module.exports = TaskAnswer;

lib/tasks/conference.js

@@ -2,10 +2,11 @@ const Task = require('./task');
 const Emitter = require('events');
 const ConfirmCallSession = require('../session/confirm-call-session');
 const {TaskName, TaskPreconditions, BONG_TONE} = require('../utils/constants');
-const normalizeJambones = require('../utils/normalize-jambones');
+const { normalizeJambones } = require('@jambonz/verb-specifications');
 const makeTask = require('./make_task');
 const bent = require('bent');
 const assert = require('assert');
+const HttpRequestor = require('../utils/http-requestor');
 const WAIT = 'wait';
 const JOIN = 'join';
 const START = 'start';
@@ -48,7 +49,7 @@ class Conference extends Task {
     this.confName = this.data.name;
     [
       'beep', 'startConferenceOnEnter', 'endConferenceOnExit', 'joinMuted',
-      'maxParticipants', 'waitHook', 'statusHook', 'endHook', 'enterHook'
+      'maxParticipants', 'waitHook', 'statusHook', 'endHook', 'enterHook', 'endConferenceDuration'
     ].forEach((attr) => this[attr] = this.data[attr]);
     this.record = this.data.record || {};
     this.statusEvents = [];
@@ -60,6 +61,8 @@ class Conference extends Task {
 
     this.emitter = new Emitter();
     this.results = {};
+    this.coaching = [];
+    this.speakOnlyTo = this.data.speakOnlyTo;
 
     // transferred from another server in order to bridge to a local caller?
     if (this.data._ && this.data._.connectTime) {
@@ -80,7 +83,11 @@ class Conference extends Task {
     // reset answer time if we were transferred from another feature server
     if (this.connectTime) dlg.connectTime = this.connectTime;
 
-
+    if (cs.sipRequestWithinDialogHook) {
+      /* remove any existing listener to escape from duplicating events */
+      this._removeSipIndialogRequestListener(this.dlg);
+      this._initSipIndialogRequestListener(cs, dlg);
+    }
     this.ep.on('destroy', this._kicked.bind(this, cs, dlg));
 
     try {
@@ -100,6 +107,7 @@ class Conference extends Task {
 
       this.logger.debug(`Conference:exec - conference ${this.confName} is over`);
       if (this.callMoved !== false) await this.performAction(this.results);
+      this._removeSipIndialogRequestListener(dlg);
     } catch (err) {
       this.logger.info(err, `TaskConference:exec - error in conference ${this.confName}`);
     }
@@ -108,9 +116,20 @@ class Conference extends Task {
   async kill(cs) {
     super.kill(cs);
     this.logger.info(`Conference:kill ${this.confName}`);
+    if (this._playSession) {
+      this._playSession.kill();
+      this._playSession = null;
+    }
     this.emitter.emit('kill');
     await this._doFinalMemberCheck(cs);
-    if (this.ep && this.ep.connected) this.ep.conn.removeAllListeners('esl::event::CUSTOM::*') ;
+    if (this.ep && this.ep.connected) {
+      // drachtio-fsmrf override esl::event::CUSTOM to conference join listerner, After finish the conference
+      // the application need to reset the esl::event::CUSTOM for another use on the same endpoint
+      this.ep.resetEslCustomEvent();
+      this.ep.api(`conference ${this.confName} kick ${this.memberId}`)
+        .catch((err) => this.logger.info({err}, 'Error kicking participant'));
+    }
+    cs.clearConferenceDetails();
     this.notifyTaskDone();
   }
 
@@ -123,15 +142,10 @@ class Conference extends Task {
    * @param {SipDialog} dlg
    */
   async _init(cs, dlg) {
-    const friendlyName = this.confName;
     const {createHash, retrieveHash} = cs.srf.locals.dbHelpers;
+    this.friendlyName = this.confName;
     this.confName = `conf:${cs.accountSid}:${this.confName}`;
 
-    this.statusParams = Object.assign({
-      conferenceSid: this.confName,
-      friendlyName
-    }, cs.callInfo);
-
     // check if conference is in progress
     const obj = await retrieveHash(this.confName);
     if (obj) {
@@ -335,16 +349,33 @@ class Conference extends Task {
     }
 
     const opts = {};
-    if (this.endConferenceOnExit) Object.assign(opts, {flags: {endconf: true}});
-    if (this.startConferenceOnEnter) Object.assign(opts, {flags: {moderator: true}});
-    if (this.joinMuted) Object.assign(opts, {flags: {mute: true}});
+    if (this.endConferenceOnExit || this.startConferenceOnEnter || this.joinMuted) {
+      Object.assign(opts, {flags: {
+        ...(this.endConferenceOnExit && {endconf: true}),
+        ...(this.startConferenceOnEnter && {moderator: true}),
+        //https://developer.signalwire.com/freeswitch/FreeSWITCH-Explained/Modules/mod_conference_3965534/
+        // mute |	Enter conference muted
+        ...((this.joinMuted || this.speakOnlyTo) && {mute: true}),
+      }});
+
+      /**
+       * Note on the above: if we are joining in "coaching" mode (ie only going to heard by a subset of participants)
+       * then we join muted temporarily, and then unmute ourselves once we have identified the subset of participants
+       * to whom we will be speaking.
+       */
+    }
 
     try {
       const {memberId, confUuid} = await this.ep.join(this.confName, opts);
       this.logger.debug({memberId, confUuid}, `Conference:_joinConference: successfully joined ${this.confName}`);
-      this.memberId = memberId;
+      this.memberId = parseInt(memberId, 10);
       this.confUuid = confUuid;
 
+      // set a tag for this member, if provided
+      if (this.data.memberTag) {
+        this.setMemberTag(this.data.memberTag);
+      }
+
       cs.setConferenceDetails(memberId, this.confName, confUuid);
       const response = await this.ep.api('conference', [this.confName, 'get', 'count']);
       if (response.body && /\d+/.test(response.body)) this.participantCount = parseInt(response.body);
@@ -371,6 +402,9 @@ class Conference extends Task {
           .catch((err) => {});
       }
 
+      if (this.speakOnlyTo) {
+        this.setCoachMode(this.speakOnlyTo);
+      }
     } catch (err) {
       this.logger.error(err, `Failed to join conference ${this.confName}`);
       throw err;
@@ -380,6 +414,25 @@ class Conference extends Task {
       this.ep.api('conference', `${this.confName} set max_members ${this.maxParticipants}`)
         .catch((err) => this.logger.error(err, `Error setting max participants to ${this.maxParticipants}`));
     }
+
+    if (typeof this.endConferenceDuration === 'number' && this.endConferenceDuration >= 0) {
+      this.ep.api('conference', `${this.confName} set endconference_grace_time ${this.endConferenceDuration}`)
+        .catch((err) => this.logger.error(err, `Error setting end conference time to ${this.endConferenceDuration}`));
+    }
+  }
+
+  _initSipIndialogRequestListener(cs, dlg) {
+    dlg.on('info', this._onRequestWithinDialog.bind(this, cs));
+    dlg.on('message', this._onRequestWithinDialog.bind(this, cs));
+  }
+
+  _removeSipIndialogRequestListener(dlg) {
+    dlg && dlg.removeAllListeners('message');
+    dlg && dlg.removeAllListeners('info');
+  }
+
+  _onRequestWithinDialog(cs, req, res) {
+    cs._onRequestWithinDialog(req, res);
   }
 
   /**
@@ -410,7 +463,15 @@ class Conference extends Task {
     }
   }
 
-  async doConferenceHold(cs, opts) {
+  doConferenceMute(cs, opts) {
+    assert (cs.isInConference);
+
+    const mute = opts.conf_mute_status === 'mute';
+    this.ep.api(`conference ${this.confName} ${mute ? 'mute' : 'unmute'} ${this.memberId}`)
+      .catch((err) => this.logger.info({err}, 'Error muting or unmuting participant'));
+  }
+
+  doConferenceHold(cs, opts) {
     assert (cs.isInConference);
 
     const {conf_hold_status, wait_hook} = opts;
@@ -427,13 +488,19 @@ class Conference extends Task {
         .catch((err) => this.logger.info({err}, 'Error deafing or undeafing participant'));
     }
 
+    if (wait_hook) {
+      if (this.wait_hook)
+        delete this.wait_hook.url;
+      this.wait_hook = {url: wait_hook};
+    }
+
     if (hookOnly && this._playSession) {
       this._playSession.kill();
       this._playSession = null;
     }
-    if (wait_hook && this.conf_hold_status === 'hold') {
+    if (this.wait_hook?.url && this.conf_hold_status === 'hold') {
       const {dlg} = cs;
-      this._doWaitHookWhileOnHold(cs, dlg, wait_hook);
+      this._doWaitHookWhileOnHold(cs, dlg, this.wait_hook);
     }
     else if (this.conf_hold_status !== 'hold' && this._playSession) {
       this._playSession.kill();
@@ -441,10 +508,52 @@ class Conference extends Task {
     }
   }
 
+  async doConferenceParticipantAction(cs, opts) {
+    const {action, tag, wait_hook } = opts;
+
+    switch (action) {
+      case 'tag':
+        await this.setMemberTag(tag);
+        break;
+      case 'untag':
+        await this.clearMemberTag();
+        break;
+      case 'coach':
+        await this.setCoachMode(tag);
+        break;
+      case 'uncoach':
+        await this.clearCoachMode();
+        break;
+      case 'hold':
+        this.doConferenceHold(cs, {
+          conf_hold_status: 'hold',
+          ...(wait_hook && {wait_hook})
+        });
+        break;
+      case 'unhold':
+        this.doConferenceHold(cs, {conf_hold_status: 'unhold'});
+        break;
+      case 'mute':
+        this.doConferenceMute(cs, {conf_mute_status: 'mute'});
+        break;
+      case 'unmute':
+        this.doConferenceMute(cs, {conf_mute_status: 'unmute'});
+        break;
+      case 'kick':
+        this.kickMember(cs);
+        break;
+      default:
+        this.logger.info(`Conference:doConferenceParticipantAction - unhandled action ${action}`);
+        break;
+    }
+  }
+
   async _doWaitHookWhileOnHold(cs, dlg, wait_hook) {
     do {
       try {
-        const tasks = await this._playHook(cs, dlg, wait_hook);
+        let tasks = [];
+        if (wait_hook.url)
+          tasks = await this._playHook(cs, dlg, wait_hook.url);
         if (0 === tasks.length) break;
       } catch (err) {
         if (!this.killed) {
@@ -456,6 +565,13 @@ class Conference extends Task {
     } while (!this.killed && this.conf_hold_status === 'hold');
   }
 
+  /**
+   * mute or unmute side of the call
+   */
+  mute(callSid, doMute) {
+    this.doConferenceMute(this.callSession, {conf_mute_status: doMute});
+  }
+
   /**
    * Add ourselves to the waitlist of sessions to be notified once
    * the conference starts
@@ -485,7 +601,7 @@ class Conference extends Task {
   _normalizeHook(cs, hook) {
     if (typeof hook === 'object') return hook;
     const url = hook.startsWith('/') ?
-      `${cs.application.requestor.baseUrl}${hook}` :
+      `${cs.application.requestor instanceof HttpRequestor ? cs.application.requestor.baseUrl : ''}${hook}` :
       hook;
 
     return { url } ;
@@ -504,7 +620,7 @@ class Conference extends Task {
       const response = await this.ep.api('conference', [this.confName, 'get', 'count']);
       if (response.body && confNoMatch(response.body)) this.participantCount = 0;
       else if (response.body && /^\d+$/.test(response.body)) this.participantCount = parseInt(response.body) - 1;
-      this.logger.debug({response}, `Conference:_doFinalMemberCheck conference count ${this.participantCount}`);
+      this.logger.debug(`Conference:_doFinalMemberCheck conference count ${this.participantCount}`);
     } catch (err) {
       this.logger.info({err}, 'Conference:_doFinalMemberCheck error retrieving count (we were probably kicked');
     }
@@ -514,7 +630,7 @@ class Conference extends Task {
      * when we hang up as the last member, the current member count = 1
      * when we are kicked out of the call when the moderator leaves, the member count = 0
      */
-    if (this.participantCount === 0) {
+    if (this.participantCount === 0 || this.endConferenceOnExit) {
       const {deleteKey} = cs.srf.locals.dbHelpers;
       try {
         this._notifyConferenceEvent(cs, 'end');
@@ -522,7 +638,8 @@ class Conference extends Task {
         this.logger.info(`conf ${this.confName} deprovisioned: ${removed ? 'success' : 'failure'}`);
       }
       catch (err) {
-        this.logger.error(err, `Error deprovisioning conference ${this.confName}`);
+        this.logger.error(err, `Error deprovisioning conference ${this.confName},
+          might be the conference already cleaned by another moderator`);
       }
     }
   }
@@ -555,7 +672,9 @@ class Conference extends Task {
         memberId: this.memberId,
         confName: this.confName,
         tasks,
-        rootSpan: cs.rootSpan
+        rootSpan: cs.rootSpan,
+        req: cs.req,
+        tmpFiles: cs.tmpFiles,
       });
       await this._playSession.exec();
       this._playSession = null;
@@ -571,6 +690,10 @@ class Conference extends Task {
    */
   _kicked(cs, dlg) {
     this.logger.info(`Conference:kicked - I was dropped from conference ${this.confName}, task is complete`);
+    if (this._playSession) {
+      this._playSession.kill();
+      this._playSession = null;
+    }
     this.replaceEndpointAndEnd(cs);
   }
 
@@ -595,8 +718,24 @@ class Conference extends Task {
       if (!params.time) params.time = (new Date()).toISOString();
       if (!params.members && typeof this.participantCount === 'number') params.members = this.participantCount;
       cs.application.requestor
-        .request('verb:hook', this.statusHook, Object.assign(params, this.statusParams, httpHeaders))
-        .catch((err) => this.logger.info(err, 'Conference:notifyConferenceEvent - error'));
+        .request(
+          'verb:hook',
+          this.statusHook,
+          Object.assign(
+            params,
+            Object.assign(
+              {
+                conferenceSid: this.confName,
+                friendlyName: this.friendlyName,
+              },
+              cs.callInfo.toJSON()
+            ),
+            httpHeaders
+          )
+        )
+        .catch((err) =>
+          this.logger.info(err, 'Conference:notifyConferenceEvent - error')
+        );
     }
   }
 
@@ -612,11 +751,19 @@ class Conference extends Task {
   }
 
   // conference event handlers
+  _onAddMember(logger, cs, evt) {
+    const memberId = parseInt(evt.getHeader('Member-ID')) ;
+    if (this.speakOnlyTo) {
+      logger.debug(`Conference:_onAddMember - member ${memberId} added to ${this.confName}, updating coaching mode`);
+      this.setCoachMode(this.speakOnlyTo).catch(() => {});
+    }
+    else logger.debug(`Conference:_onAddMember - member ${memberId} added to conference ${this.confName}`);
+  }
   _onDelMember(logger, cs, evt) {
     const memberId = parseInt(evt.getHeader('Member-ID')) ;
     this.participantCount = parseInt(evt.getHeader('Conference-Size'));
     if (memberId === this.memberId) {
-      this.logger.info(`Conference:_onDelMember - I was dropped from conference ${this.confName}, task is complete`);
+      logger.info(`Conference:_onDelMember - I was dropped from conference ${this.confName}, task is complete`);
       this.replaceEndpointAndEnd(cs);
     }
   }
@@ -645,6 +792,99 @@ class Conference extends Task {
     }
   }
 
+  _onTag(logger, cs, evt) {
+    const memberId = parseInt(evt.getHeader('Member-ID')) ;
+    const tag = evt.getHeader('Tag') || '';
+    if (memberId !== this.memberId && this.speakOnlyTo) {
+      logger.info(`Conference:_onTag - member ${memberId} set tag to '${tag }'; updating coach mode accordingly`);
+      this.setCoachMode(this.speakOnlyTo).catch(() => {});
+    }
+  }
+
+  /**
+   * Set the conference to "coaching" mode, where the audio of the participant is only heard
+   * by a subset of the participants in the conference.
+   * We do this by first getting all of the members who do *not* have this tag, and then
+   * we configure this members audio to not be sent to them.
+   * @param {string} speakOnlyTo - tag of the members who should receive our audio
+   *
+   * N.B.: this feature requires jambonz patches to freeswitch mod_conference
+   */
+  async setCoachMode(speakOnlyTo) {
+    this.speakOnlyTo = speakOnlyTo;
+    if (!this.memberId) {
+      this.logger.info('Conference:_setCoachMode: no member id yet');
+      return;
+    }
+    try {
+      const members = (await this.ep.getNonMatchingConfParticipants(this.confName, speakOnlyTo))
+        .filter((m) => m !== this.memberId);
+      if (members.length === 0) {
+        this.logger.info({members}, 'Conference:_setCoachMode: all participants have the tag, so all will hear me');
+        if (this.coaching.length) {
+          await this.ep.api('conference', [this.confName, 'relate', this.memberId, this.coaching.join(','), 'clear']);
+          this.coaching = [];
+        }
+      }
+      else {
+        const memberList = members.join(',');
+        this.logger.info(`Conference:_setCoachMode: my audio will NOT be sent to ${memberList}`);
+        await this.ep.api('conference', [this.confName, 'relate', this.memberId, memberList, 'nospeak']);
+        this.coaching = members;
+      }
+    } catch (err) {
+      this.logger.error({err, speakOnlyTo}, '_setCoachMode: Error');
+    }
+  }
+
+  async clearCoachMode() {
+    if (!this.memberId) return;
+    try {
+      if (this.coaching.length === 0) {
+        this.logger.info('Conference:_clearCoachMode: no coaching mode to clear');
+      }
+      else {
+        const memberList = this.coaching.join(',');
+        this.logger.info(`Conference:_clearCoachMode: now sending my audio to all, including ${memberList}`);
+        await this.ep.api('conference', [this.confName, 'relate', this.memberId, memberList, 'clear']);
+      }
+      this.speakOnlyTo = null;
+      this.coaching = [];
+    } catch (err) {
+      this.logger.error({err}, '_clearCoachMode: Error');
+    }
+  }
+
+  async setMemberTag(tag) {
+    try {
+      await this.ep.api('conference', [this.confName, 'tag', this.memberId, tag]);
+      this.logger.info(`Conference:setMemberTag: set tag for ${this.memberId} to ${tag}`);
+      this.memberTag = tag;
+    } catch (err) {
+      this.logger.error({err}, `Error setting tag for ${this.memberId} to ${tag}`);
+    }
+  }
+
+  async clearMemberTag() {
+    try {
+      await this.ep.api('conference', [this.confName, 'tag', this.memberId]);
+      this.logger.info(`Conference:setMemberTag: clearing tag for ${this.memberId}`);
+      this.memberTag = null;
+    } catch (err) {
+      this.logger.error({err}, `Error clearing tag for ${this.memberId}`);
+    }
+  }
+
+  async kickMember(cs) {
+    assert(cs.isInConference);
+    try {
+      await this.ep.api('conference', [this.confName, 'kick', this.memberId]);
+      this.logger.info(`Conference:kickMember: kick ${this.memberId} out of conference ${this.confName}`);
+    } catch (err) {
+      this.logger.error({err}, `Error kicking member out of conference for ${this.memberId}`);
+    }
+  }
+
 }
 
 module.exports = Conference;

lib/tasks/config.js

@@ -1,16 +1,33 @@
 const Task = require('./task');
 const {TaskName, TaskPreconditions} = require('../utils/constants');
+const parseDecibels = require('../utils/parse-decibels');
 
 class TaskConfig extends Task {
   constructor(logger, opts) {
     super(logger, opts);
+
     [
       'synthesizer',
       'recognizer',
       'bargeIn',
-      'record'
+      'record',
+      'listen',
+      'transcribe',
+      'fillerNoise',
+      'actionHookDelayAction',
+      'boostAudioSignal',
+      'vad',
+      'ttsStream',
+      'autoStreamTts'
     ].forEach((k) => this[k] = this.data[k] || {});
 
+    if ('notifyEvents' in this.data) {
+      this.notifyEvents = !!this.data.notifyEvents;
+    }
+    if (this.hasNotifySttLatency) {
+      this.notifySttLatency = !!this.data.notifySttLatency;
+    }
+
     if (this.bargeIn.enable) {
       this.gatherOpts = {
         verb: 'gather',
@@ -22,41 +39,112 @@ class TaskConfig extends Task {
         'finishOnKey', 'input', 'numDigits', 'minDigits', 'maxDigits',
         'interDigitTimeout', 'bargein', 'dtmfBargein', 'minBargeinWordCount', 'actionHook'
       ].forEach((k) => {
-        if (this.bargeIn[k]) this.gatherOpts[k] = this.bargeIn[k];
+        const val = this.bargeIn[k];
+        if (val !== undefined && val !== null) this.gatherOpts[k] = val;
       });
     }
+    if (this.transcribe?.enable) {
+      this.transcribeOpts = {
+        verb: 'transcribe',
+        ...this.transcribe
+      };
+      delete this.transcribeOpts.enable;
+    }
+    if (this.ttsStream.enable) {
+      this.sayOpts = {
+        verb: 'say',
+        stream: true
+      };
+    }
+
+    if (this.data.reset) {
+      if (typeof this.data.reset === 'string') this.data.reset = [this.data.reset];
+    }
+    else this.data.reset = [];
+
     if (this.bargeIn.sticky) this.autoEnable = true;
-    this.preconditions = (this.bargeIn.enable || this.record?.action || this.data.amd) ?
+    this.preconditions = (this.bargeIn.enable ||
+      this.record?.action ||
+      this.listen?.url ||
+      this.data.amd ||
+      'boostAudioSignal' in this.data ||
+      this.transcribe?.enable) ?
       TaskPreconditions.Endpoint :
       TaskPreconditions.None;
+
+    this.onHoldMusic = this.data.onHoldMusic;
   }
 
   get name() { return TaskName.Config; }
 
   get hasSynthesizer() { return Object.keys(this.synthesizer).length; }
-
   get hasRecognizer() { return Object.keys(this.recognizer).length; }
+  get hasRecording() { return Object.keys(this.record).length; }
+  get hasListen() { return Object.keys(this.listen).length; }
+  get hasTranscribe() { return Object.keys(this.transcribe).length; }
+  get hasDub() { return Object.keys(this.dub).length; }
+  get hasVad() { return Object.keys(this.vad).length; }
+  get hasFillerNoise() { return Object.keys(this.fillerNoise).length; }
+  get hasReferHook() { return Object.keys(this.data).includes('referHook'); }
+  get hasNotifySttLatency() { return Object.keys(this.data).includes('notifySttLatency'); }
+  get hasTtsStream() { return Object.keys(this.ttsStream).length; }
 
   get summary() {
     const phrase = [];
+
+    /* reset recognizer and/or synthesizer to default values? */
+    if (this.data.reset.length) phrase.push(`reset ${this.data.reset.join(',')}`);
+
     if (this.bargeIn.enable) phrase.push('enable barge-in');
     if (this.hasSynthesizer) {
-      const {vendor:v, language:l, voice} = this.synthesizer;
-      const s = `{${v},${l},${voice}}`;
+      const {vendor:v, language:l, voice, label} = this.synthesizer;
+      const s = `{${v},${l},${voice},${label || 'None'}}`;
       phrase.push(`set synthesizer${s}`);
     }
     if (this.hasRecognizer) {
-      const {vendor:v, language:l} = this.recognizer;
-      const s = `{${v},${l}}`;
+      const {vendor:v, language:l, label} = this.recognizer;
+      const s = `{${v},${l},${label || 'None'}}`;
       phrase.push(`set recognizer${s}`);
     }
+    if (this.hasRecording) phrase.push(this.record.action);
+    if (this.hasListen) {
+      phrase.push(this.listen.enable ? `listen ${this.listen.url}` : 'stop listen');
+    }
+    if (this.hasTranscribe) {
+      phrase.push(this.transcribe.enable ? `transcribe ${this.transcribe.transcriptionHook}` : 'stop transcribe');
+    }
+    if (this.hasFillerNoise) phrase.push(`fillerNoise ${this.fillerNoise.enable ? 'on' : 'off'}`);
     if (this.data.amd) phrase.push('enable amd');
-    return  `${this.name}{${phrase.join(',')}`;
+    if (this.notifyEvents) phrase.push(`event notification ${this.notifyEvents ? 'on' : 'off'}`);
+    if (this.hasNotifySttLatency) phrase.push(
+      `notifySttLatency ${this.notifySttLatency ? 'on' : 'off'}`);
+    if (this.onHoldMusic) phrase.push(`onHoldMusic: ${this.onHoldMusic}`);
+    if ('boostAudioSignal' in this.data) phrase.push(`setGain ${this.data.boostAudioSignal}`);
+    if (this.hasReferHook) phrase.push('set referHook');
+    if (this.hasTtsStream) {
+      phrase.push(`${this.ttsStream.enable ? 'enable' : 'disable'} ttsStream`);
+    }
+    if ('autoStreamTts' in this.data) phrase.push(`enable Say.stream value ${this.data.autoStreamTts ? 'on' : 'off'}`);
+    return `${this.name}{${phrase.join(',')}}`;
   }
 
   async exec(cs, {ep} = {}) {
     await super.exec(cs);
 
+    if (this.notifyEvents) {
+      this.logger.debug(`turning event notification ${this.notifyEvents ? 'on' : 'off'}`);
+      cs.notifyEvents = !!this.data.notifyEvents;
+    }
+
+    if (this.hasNotifySttLatency) {
+      this.logger.debug(`turning notifySttLatency ${this.notifySttLatency ? 'on' : 'off'}`);
+      cs.notifySttLatencyEnabled = this.notifySttLatency;
+    }
+
+    if (this.onHoldMusic) {
+      cs.onHoldMusic = this.onHoldMusic;
+    }
+
     if (this.data.amd) {
       this.startAmd = cs.startAmd;
       this.stopAmd = cs.stopAmd;
@@ -64,31 +152,71 @@ class TaskConfig extends Task {
 
       try {
         this.ep = ep;
-        this.startAmd(cs, ep, this, this.data.amd);
+        await this.startAmd(cs, ep, this, this.data.amd);
       } catch (err) {
         this.logger.info({err}, 'Config:exec - Error calling startAmd');
       }
     }
 
+    this.data.reset.forEach((k) => {
+      if (k === 'synthesizer') cs.resetSynthesizer();
+      else if (k === 'recognizer') cs.resetRecognizer();
+    });
+
     if (this.hasSynthesizer) {
+      cs.synthesizer = this.synthesizer;
       cs.speechSynthesisVendor = this.synthesizer.vendor !== 'default'
         ? this.synthesizer.vendor
         : cs.speechSynthesisVendor;
+      cs.speechSynthesisLabel = this.synthesizer.label === 'default'
+        ? cs.speechSynthesisLabel : this.synthesizer.label;
       cs.speechSynthesisLanguage = this.synthesizer.language !== 'default'
         ?  this.synthesizer.language
         : cs.speechSynthesisLanguage;
       cs.speechSynthesisVoice = this.synthesizer.voice !== 'default'
         ? this.synthesizer.voice
         : cs.speechSynthesisVoice;
+
+      // fallback vendor
+      cs.fallbackSpeechSynthesisVendor = this.synthesizer.fallbackVendor !== 'default'
+        ? this.synthesizer.fallbackVendor
+        : cs.fallbackSpeechSynthesisVendor;
+      cs.fallbackSpeechSynthesisLabel = this.synthesizer.fallbackLabel === 'default'
+        ? cs.fallbackSpeechSynthesisLabel : this.synthesizer.fallbackLabel;
+      cs.fallbackSpeechSynthesisLanguage = this.synthesizer.fallbackLanguage !== 'default'
+        ?  this.synthesizer.fallbackLanguage
+        : cs.fallbackSpeechSynthesisLanguage;
+      cs.fallbackSpeechSynthesisVoice = this.synthesizer.fallbackVoice !== 'default'
+        ? this.synthesizer.fallbackVoice
+        : cs.fallbackSpeechSynthesisVoice;
+      // new vendor is set, reset fallback vendor
+      cs.hasFallbackTts = false;
       this.logger.info({synthesizer: this.synthesizer}, 'Config: updated synthesizer');
     }
     if (this.hasRecognizer) {
+      cs.recognizer = this.recognizer;
       cs.speechRecognizerVendor = this.recognizer.vendor !== 'default'
         ? this.recognizer.vendor
         : cs.speechRecognizerVendor;
-      cs.speechRecognizerLanguage = this.recognizer.language !== 'default'
+      cs.speechRecognizerLabel = this.recognizer.label === 'default'
+        ? cs.speechRecognizerLabel : this.recognizer.label;
+      cs.speechRecognizerLanguage = this.recognizer.language !== undefined && this.recognizer.language !== 'default'
         ? this.recognizer.language
         : cs.speechRecognizerLanguage;
+
+      //fallback
+      cs.fallbackSpeechRecognizerVendor = this.recognizer.fallbackVendor !== undefined &&
+        this.recognizer.fallbackVendor !== 'default'
+        ? this.recognizer.fallbackVendor
+        : cs.fallbackSpeechRecognizerVendor;
+      cs.fallbackSpeechRecognizerLabel = this.recognizer.fallbackLabel === 'default' ?
+        cs.fallbackSpeechRecognizerLabel :
+        this.recognizer.fallbackLabel;
+      cs.fallbackSpeechRecognizerLanguage = this.recognizer.fallbackLanguage !== undefined &&
+        this.recognizer.fallbackLanguage !== 'default'
+        ? this.recognizer.fallbackLanguage
+        : cs.fallbackSpeechRecognizerLanguage;
+
       cs.isContinuousAsr = typeof this.recognizer.asrTimeout === 'number' ? true : false;
       if (cs.isContinuousAsr) {
         cs.asrTimeout = this.recognizer.asrTimeout;
@@ -108,6 +236,8 @@ class TaskConfig extends Task {
       if ('punctuation' in this.recognizer) {
         cs.globalSttPunctuation = this.recognizer.punctuation;
       }
+      // new vendor is set, reset fallback vendor
+      cs.hasFallbackAsr = false;
       this.logger.info({
         recognizer: this.recognizer,
         isContinuousAsr: cs.isContinuousAsr
@@ -136,17 +266,112 @@ class TaskConfig extends Task {
         this.logger.info({err}, 'Config: error starting recording');
       }
     }
+    if (this.hasListen) {
+      const {enable, ...opts} = this.listen;
+      if (enable) {
+        this.logger.debug({opts}, 'Config: enabling listen');
+        cs.startBackgroundTask('listen', {verb: 'listen', ...opts});
+      } else {
+        this.logger.info('Config: disabling listen');
+        cs.stopBackgroundTask('listen');
+      }
+    }
+    if (this.hasTranscribe) {
+      if (this.transcribe.enable) {
+        if (!this.transcribeOpts.recognizer) {
+          this.transcribeOpts.recognizer = this.hasRecognizer ?
+            this.recognizer :
+            {
+              vendor: cs.speechRecognizerVendor,
+              language: cs.speechRecognizerLanguage
+            };
+        }
+        this.logger.debug(this.transcribeOpts, 'Config: enabling transcribe');
+        cs.startBackgroundTask('transcribe', this.transcribeOpts);
+      } else {
+        this.logger.info('Config: disabling transcribe');
+        cs.stopBackgroundTask('transcribe');
+      }
+    }
+    if (Object.keys(this.actionHookDelayAction).length !== 0) {
+      cs.actionHookDelayProperties = this.actionHookDelayAction;
+    }
+    if (this.data.sipRequestWithinDialogHook) {
+      cs.sipRequestWithinDialogHook = this.data.sipRequestWithinDialogHook;
+    }
+
+    if ('boostAudioSignal' in this.data) {
+      const db = parseDecibels(this.data.boostAudioSignal);
+      this.logger.info(`Config: boosting audio signal by ${db} dB`);
+      const args = [ep.uuid, 'setGain', db];
+      ep.api('uuid_dub', args).catch((err) => {
+        this.logger.error(err, 'Error boosting audio signal');
+      });
+    }
+
+    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');
+      if (!enable) cs.disableFillerNoise();
+      else {
+        cs.enableFillerNoise(opts);
+      }
+    }
+
+    if (this.hasVad) {
+      cs.vad = {
+        enable: this.vad.enable || false,
+        voiceMs: this.vad.voiceMs || 250,
+        silenceMs: this.vad.silenceMs || 150,
+        strategy: this.vad.strategy || 'one-shot',
+        mode: (this.vad.mode !== undefined && this.vad.mode !== null) ? this.vad.mode : 2,
+        vendor: this.vad.vendor || 'silero',
+        threshold: this.vad.threshold || 0.5,
+        speechPadMs: this.vad.speechPadMs || 30,
+      };
+    }
+
+    if (this.hasReferHook) {
+      cs.referHook = this.data.referHook;
+    }
+
+    if (this.ttsStream.enable && this.sayOpts) {
+      this.sayOpts.synthesizer = this.hasSynthesizer ? this.synthesizer : {
+        vendor: cs.speechSynthesisVendor,
+        language: cs.speechSynthesisLanguage,
+        voice: cs.speechSynthesisVoice,
+        ...(cs.speechSynthesisLabel && {
+          label: cs.speechSynthesisLabel
+        })
+      };
+      this.logger.info({opts: this.gatherOpts}, 'Config: enabling ttsStream');
+      cs.enableBackgroundTtsStream(this.sayOpts);
+    }
+    // only disable ttsStream if it specifically set to false
+    else if (this.ttsStream.enable === false) {
+      this.logger.info('Config: disabling ttsStream');
+      cs.disableTtsStream();
+    }
   }
 
   async kill(cs) {
     super.kill(cs);
-    if (this.ep && this.stopAmd) this.stopAmd(this.ep, this);
+    //if (this.ep && this.stopAmd) this.stopAmd(this.ep, this);
   }
 
   _onAmdEvent(cs, evt) {
     this.logger.info({evt}, 'Config:_onAmdEvent');
     const {actionHook} = this.data.amd;
-    this.performHook(cs, actionHook, evt);
+    this.performHook(cs, actionHook, evt)
+      .catch((err) => {
+        this.logger.error({err}, 'Config:_onAmdEvent - error calling actionHook');
+      });
+
   }
 }
 

lib/tasks/dequeue.js

@@ -3,8 +3,7 @@ const {TaskName, TaskPreconditions, DequeueResults, BONG_TONE} = require('../uti
 const Emitter = require('events');
 const bent = require('bent');
 const assert = require('assert');
-
-const sleepFor = (ms) => new Promise((resolve) => setTimeout(() => resolve(), ms));
+const { sleepFor } = require('../utils/helpers');
 
 const getUrl = (cs) => `${cs.srf.locals.serviceUrl}/v1/dequeue/${cs.callSid}`;
 
@@ -16,6 +15,7 @@ class TaskDequeue extends Task {
     this.queueName = this.data.name;
     this.timeout = this.data.timeout || 0;
     this.beep = this.data.beep === true;
+    this.callSid = this.data.callSid;
 
     this.emitter = new Emitter();
     this.state = DequeueResults.Timeout;
@@ -53,7 +53,7 @@ class TaskDequeue extends Task {
   }
 
   _getMemberFromQueue(cs) {
-    const {popFront} = cs.srf.locals.dbHelpers;
+    const {retrieveFromSortedSet, retrieveByPatternSortedSet} = cs.srf.locals.dbHelpers;
 
     return new Promise(async(resolve) => {
       let timer;
@@ -70,7 +70,13 @@ class TaskDequeue extends Task {
 
       do {
         try {
-          const url = await popFront(this.queueName);
+          let url;
+          if (this.callSid) {
+            const r = await retrieveByPatternSortedSet(this.queueName, `*${this.callSid}`);
+            url = r[0];
+          } else {
+            url = await retrieveFromSortedSet(this.queueName);
+          }
           if (url) {
             found = true;
             clearTimeout(timer);
@@ -78,7 +84,7 @@ class TaskDequeue extends Task {
             resolve(url);
           }
         } catch (err) {
-          this.logger.debug({err}, 'TaskDequeue:_getMemberFromQueue error popFront');
+          this.logger.debug({err}, 'TaskDequeue:_getMemberFromQueue error Sorted Set');
         }
         await sleepFor(5000);
       } while (!this.killed && !timedout && !found);

lib/tasks/dial.js

@@ -6,15 +6,25 @@ const {
   TaskName,
   TaskPreconditions,
   MAX_SIMRINGS,
+  MediaPath,
   KillReason
 } = require('../utils/constants');
 const assert = require('assert');
 const placeCall = require('../utils/place-outdial');
 const sessionTracker = require('../session/session-tracker');
 const DtmfCollector = require('../utils/dtmf-collector');
+const ConfirmCallSession = require('../session/confirm-call-session');
 const dbUtils = require('../utils/db-utils');
+const parseDecibels = require('../utils/parse-decibels');
 const debug = require('debug')('jambonz:feature-server');
 const {parseUri} = require('drachtio-srf');
+const {ANCHOR_MEDIA_ALWAYS,
+  JAMBONZ_DIAL_PAI_HEADER,
+  JAMBONES_DIAL_SBC_FOR_REGISTERED_USER} = require('../config');
+const { isOnhold, isOpusFirst } = require('../utils/sdp-utils');
+const { normalizeJambones } = require('@jambonz/verb-specifications');
+const { selectHostPort } = require('../utils/network');
+const { sleepFor } = require('../utils/helpers');
 
 function parseDtmfOptions(logger, dtmfCapture) {
   let parentDtmfCollector, childDtmfCollector;
@@ -84,6 +94,7 @@ class TaskDial extends Task {
 
     this.earlyMedia = this.data.answerOnBridge === true;
     this.callerId = this.data.callerId;
+    this.callerName = this.data.callerName;
     this.dialMusic = this.data.dialMusic;
     this.headers = this.data.headers || {};
     this.method = this.data.method || 'POST';
@@ -95,6 +106,10 @@ class TaskDial extends Task {
     this.referHook = this.data.referHook;
     this.dtmfHook = this.data.dtmfHook;
     this.proxy = this.data.proxy;
+    this.tag = this.data.tag;
+    this.boostAudioSignal = this.data.boostAudioSignal;
+    this._mediaPath = MediaPath.FullMedia;
+    this.forwardPAI = this.data.forwardPAI;
 
     if (this.dtmfHook) {
       const {parentDtmfCollector, childDtmfCollector} = parseDtmfOptions(logger, this.data.dtmfCapture || {});
@@ -106,12 +121,16 @@ class TaskDial extends Task {
       }
     }
 
-    if (this.data.listen) {
-      this.listenTask = makeTask(logger, {'listen': this.data.listen}, this);
+    const listenData = this.data.listen || this.data.stream;
+    if (listenData) {
+      this.listenTask = makeTask(logger, {'listen': listenData }, this);
     }
     if (this.data.transcribe) {
       this.transcribeTask = makeTask(logger, {'transcribe' : this.data.transcribe}, this);
     }
+    if (this.data.dub && Array.isArray(this.data.dub) && this.data.dub.length > 0) {
+      this.dubTasks = this.data.dub.map((d) => makeTask(logger, {'dub': d}, this));
+    }
 
     this.results = {};
     this.bridged = false;
@@ -133,11 +152,25 @@ class TaskDial extends Task {
 
   get name() { return TaskName.Dial; }
 
+  get isOnHoldEnabled() {
+    return !!this.data.onHoldHook;
+  }
+
   get canReleaseMedia() {
-    return !process.env.ANCHOR_MEDIA_ALWAYS &&
-      !this.listenTask &&
-      !this.transcribeTask &&
-      !this.startAmd;
+    const keepAnchor = this.data.anchorMedia ||
+      this.cs.isBackGroundListen ||
+      this.cs.onHoldMusic ||
+      ANCHOR_MEDIA_ALWAYS ||
+      this.listenTask ||
+      this.dubTasks ||
+      this.transcribeTask ||
+      this.startAmd;
+
+    return !keepAnchor;
+  }
+
+  get shouldExitMediaPathEntirely() {
+    return this.data.exitMediaPath;
   }
 
   get summary() {
@@ -160,7 +193,27 @@ class TaskDial extends Task {
 
   async exec(cs) {
     await super.exec(cs);
+
+    if (this.data.anchorMedia && this.data.exitMediaPath) {
+      this.logger.info('Dial:exec - incompatible anchorMedia and exitMediaPath are both set, will obey anchorMedia');
+      delete this.data.exitMediaPath;
+    }
+    if (!this.canReleaseMedia && this.data.exitMediaPath) {
+      this.logger.info(
+        'Dial:exec - exitMediaPath is set so features such as transcribe and record will not work on this call');
+    }
+
     try {
+      if (this.listenTask) {
+        const {span, ctx} = this.startChildSpan(`nested:${this.listenTask.summary}`);
+        this.listenTask.span = span;
+        this.listenTask.ctx = ctx;
+      }
+      if (this.transcribeTask) {
+        const {span, ctx} = this.startChildSpan(`nested:${this.transcribeTask.summary}`);
+        this.transcribeTask.span = span;
+        this.transcribeTask.ctx = ctx;
+      }
       if (this.data.amd) {
         this.startAmd = cs.startAmd;
         this.stopAmd = cs.stopAmd;
@@ -172,7 +225,16 @@ class TaskDial extends Task {
       else {
         this.epOther = cs.ep;
         if (this.dialMusic && this.epOther && this.epOther.connected) {
-          this.epOther.play(this.dialMusic).catch((err) => {});
+          (async() => {
+            do {
+              try {
+                await this.epOther.play(this.dialMusic);
+              } catch (err) {
+                this.logger.error(err, `TaskDial:exec error playing dialMusic ${this.dialMusic}`);
+                await sleepFor(1000);
+              }
+            } while (!this.killed && !this.bridged && this._mediaPath === MediaPath.FullMedia);
+          })();
         }
       }
       if (!this.killed) await this._attemptCalls(cs);
@@ -181,6 +243,7 @@ class TaskDial extends Task {
       await this.performAction(this.results, this.killReason !== KillReason.Replaced);
       this._removeDtmfDetection(cs.dlg);
       this._removeDtmfDetection(this.dlg);
+      this._removeSipIndialogRequestListener(this.dlg);
     } catch (err) {
       this.logger.error({err}, 'TaskDial:exec terminating with error');
       this.kill(cs);
@@ -209,19 +272,37 @@ class TaskDial extends Task {
     }
     this._removeDtmfDetection(cs.dlg);
     this._removeDtmfDetection(this.dlg);
-    this._killOutdials();
+    try {
+      await this._killOutdials();
+    }
+    catch (err) {
+      this.logger.info({err}, 'Dial:kill - error killing outdials');
+    }
     if (this.sd) {
-      this.sd.kill();
+      const byeReasonHeader = this.killReason === KillReason.MediaTimeout ? 'Media Timeout' : undefined;
+      this.sd.kill(byeReasonHeader);
+      this.sd.ep?.removeListener('destroy', this._handleMediaTimeout.bind(this));
       this.sd.removeAllListeners();
       this.sd = null;
     }
     if (this.callSid) sessionTracker.remove(this.callSid);
     if (this.listenTask) {
-      await this.listenTask.kill(cs);
+      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);
+      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();
@@ -255,7 +336,7 @@ class TaskDial extends Task {
       if (!cs.callGone && this.epOther) {
 
         /* if we can release the media back to the SBC, do so now */
-        if (this.canReleaseMedia) this._releaseMedia(cs, this.sd);
+        if (this.canReleaseMedia) this._releaseMedia(cs, this.sd, this.shouldExitMediaPathEntirely);
         else this.epOther.bridge(this.ep);
       }
     } catch (err) {
@@ -295,22 +376,67 @@ class TaskDial extends Task {
 
         const to = parseUri(req.getParsedHeader('Refer-To').uri);
         const by = parseUri(req.getParsedHeader('Referred-By').uri);
+        const referredBy = req.get('Referred-By');
+        const userAgent = req.get('User-Agent');
+        const customHeaders = Object.keys(req.headers)
+          .filter((h) => h.toLowerCase().startsWith('x-'))
+          .reduce((acc, h) => {
+            acc[h] = req.get(h);
+            return acc;
+          }, {});
         this.logger.info({to}, 'refer to parsed');
-        await cs.requestor.request('verb:hook', this.referHook, {
-          ...callInfo,
+        const json = await cs.requestor.request('verb:hook', this.referHook, {
+          ...(callInfo.toJSON()),
           refer_details: {
             sip_refer_to: req.get('Refer-To'),
-            sip_referred_by: req.get('Referred-By'),
-            sip_user_agent: req.get('User-Agent'),
-            refer_to_user: to.user,
-            referred_by_user: by.user,
+            refer_to_user: to.scheme === 'tel' ? to.number : to.user,
+            ...(referredBy && {sip_referred_by: referredBy}),
+            ...(userAgent && {sip_user_agent: userAgent}),
+            ...(by && {referred_by_user: by.scheme === 'tel' ? by.number : by.user}),
             referring_call_sid,
-            referred_call_sid
+            referred_call_sid,
+            ...customHeaders
           }
         }, httpHeaders);
         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));
+            if (tasks && tasks.length > 0) {
+              const legs = isChild ? ['child', 'parent'] : ['parent', 'child'];
+              logger.info(`Dial:handleRefer received REFER on ${legs[0]} leg, setting new app on ${legs[1]} leg`);
+              if (isChild) this.redirect(cs, tasks);
+              else {
+                logger.info({tasks: json}, 'Dial:handleRefer - new application for for child leg');
+                const adultingSession = await this.sd.doAdulting({
+                  logger,
+                  application: cs.application,
+                  tasks
+                });
+                /* 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');
+          }
+        }
+        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);
       }
     }
@@ -328,11 +454,16 @@ class TaskDial extends Task {
     sd.removeAllListeners('callCreateFail');
   }
 
-  _killOutdials() {
+  async _killOutdials() {
     for (const [callSid, sd] of Array.from(this.dials)) {
       this.logger.debug(`Dial:_killOutdials killing callSid ${callSid}`);
-      sd.kill().catch((err) => this.logger.info(err, `Dial:_killOutdials Error killing ${callSid}`));
+      try {
+        await sd.kill();
+      } catch (err) {
+        this.logger.info(err, `Dial:_killOutdials Error killing ${callSid}`);
+      }
       this._removeHandlers(sd);
+      this.logger.debug(`Dial:_killOutdials killed callSid ${callSid}`);
     }
     this.dials.clear();
   }
@@ -345,8 +476,14 @@ class TaskDial extends Task {
   }
 
   _onInfo(cs, dlg, req, res) {
+    // SIP Indialog will be handled by another handler
+    if (cs.sipRequestWithinDialogHook) {
+      return;
+    }
     res.send(200);
-    if (req.get('Content-Type') !== 'application/dtmf-relay') return;
+    if (req.get('Content-Type') !== 'application/dtmf-relay') {
+      return;
+    }
 
     const dtmfDetector = dlg === cs.dlg ? this.parentDtmfCollector : this.childDtmfCollector;
     if (!dtmfDetector) return;
@@ -375,6 +512,20 @@ class TaskDial extends Task {
     }
   }
 
+  _initSipIndialogRequestListener(cs, dlg) {
+    dlg.on('info', this._onRequestWithinDialog.bind(this, cs));
+    dlg.on('message', this._onRequestWithinDialog.bind(this, cs));
+  }
+
+  _removeSipIndialogRequestListener(dlg) {
+    dlg && dlg.removeAllListeners('message');
+    dlg && dlg.removeAllListeners('info');
+  }
+
+  _onRequestWithinDialog(cs, req, res) {
+    cs._onRequestWithinDialog(req, res);
+  }
+
   async _initializeInbound(cs) {
     const {ep} = await cs._evalEndpointPrecondition(this);
     this.epOther = ep;
@@ -391,23 +542,41 @@ class TaskDial extends Task {
   }
 
   async _attemptCalls(cs) {
-    const {req, srf} = cs;
+    const {req, callInfo, direction, srf} = cs;
     const {getSBC} = srf.locals;
     const {lookupTeamsByAccount, lookupAccountBySid} = srf.locals.dbHelpers;
-    const {lookupCarrier} = dbUtils(this.logger, cs.srf);
-    const sbcAddress = this.proxy || getSBC();
+    const {lookupCarrier, lookupCarrierByPhoneNumber, lookupVoipCarrierBySid} = dbUtils(this.logger, cs.srf);
+    let sbcAddress = this.proxy || getSBC();
     const teamsInfo = {};
     let fqdn;
-
+    const forwardPAI = this.forwardPAI ?? JAMBONZ_DIAL_PAI_HEADER; // dial verb overides env var
+    this.logger.debug(forwardPAI, 'forwardPAI value');
     if (!sbcAddress) throw new Error('no SBC found for outbound call');
-    const opts = {
-      headers: req && req.has('X-CID') ? Object.assign(this.headers, {'X-CID': req.get('X-CID')}) : this.headers,
-      proxy: `sip:${sbcAddress}`,
-      callingNumber: this.callerId || req.callingNumber
+    this.headers = {
+      'X-Account-Sid': cs.accountSid,
+      ...(req && req.has('X-CID') && {'X-CID': req.get('X-CID')}),
+      ...(direction === 'outbound' && callInfo.sbcCallid && {'X-CID': callInfo.sbcCallid}),
+      ...(req && forwardPAI && {
+        ...(req.has('P-Asserted-Identity') && {'P-Asserted-Identity': req.get('P-Asserted-Identity')}),
+        ...(req.has('Privacy') && {'Privacy': req.get('Privacy')}),
+      }),
+      ...(req && req.has('X-Voip-Carrier-Sid') && {'X-Voip-Carrier-Sid': req.get('X-Voip-Carrier-Sid')}),
+      // Put headers at the end to make sure opt.headers override all default behavior.
+      ...this.headers
     };
-    opts.headers = {
-      ...opts.headers,
-      'X-Account-Sid': cs.accountSid
+
+    // default to inband dtmf if not specified
+    this.inbandDtmfEnabled = cs.inbandDtmfEnabled;
+    // get calling user from From header
+    const parsedFrom = req.getParsedHeader('from');
+    const fromUri = parseUri(parsedFrom.uri);
+    const opts = {
+      headers: this.headers,
+      proxy: `sip:${sbcAddress}`,
+      callingNumber: this.callerId || fromUri.user,
+      ...(this.callerName && {callingName: this.callerName}),
+      opusFirst: isOpusFirst(this.cs.ep.remote.sdp),
+      isVideoCall: this.cs.ep.remote.sdp.includes('m=video')
     };
 
     const t = this.target.find((t) => t.type === 'teams');
@@ -418,10 +587,14 @@ class TaskDial extends Task {
     }
 
     const ms = await cs.getMS();
-    this.timerRing = setTimeout(() => {
+    this.timerRing = setTimeout(async() => {
       this.logger.info(`Dial:_attemptCall: ring no answer timer ${this.timeout}s exceeded`);
       this.timerRing = null;
-      this._killOutdials();
+      try {
+        await this._killOutdials();
+      } catch (err) {
+        this.logger.info(err, 'Dial:_attemptCall - error killing outdials');
+      }
       this.result = {
         dialCallStatus: CallStatus.NoAnswer,
         dialSipStatus: 487
@@ -447,14 +620,45 @@ class TaskDial extends Task {
             this.logger.error({err}, 'Error looking up account by sid');
           }
         }
+        // find handling sbc sip for called user
+        if (JAMBONES_DIAL_SBC_FOR_REGISTERED_USER && t.type === 'user') {
+          const { registrar }  = srf.locals.dbHelpers;
+          const reg = await registrar.query(t.name);
+          if (reg) {
+            sbcAddress = selectHostPort(this.logger, reg.sbcAddress, 'tcp')[1];
+          }
+          //sbc outbound return 404 Notfound to handle case called user is not reigstered.
+        }
         if (t.type === 'phone' && t.trunk) {
           const voip_carrier_sid = await lookupCarrier(cs.accountSid, t.trunk);
-          this.logger.info(`Dial:_attemptCalls: selected ${voip_carrier_sid} for requested carrier: ${t.trunk})`);
+          this.logger.info(`Dial:_attemptCalls: selected ${voip_carrier_sid} for requested carrier: ${t.trunk}`);
           if (voip_carrier_sid) {
             opts.headers['X-Requested-Carrier-Sid'] = voip_carrier_sid;
           }
         }
 
+        /**
+         * trunk isn't specified,
+         * check if number matches any existing numbers
+         *  */
+        if (t.type === 'phone' && !t.trunk) {
+          const str = this.callerId || req.callingNumber || '';
+          const callingNumber = str.startsWith('+') ? str.substring(1) : str;
+          const voip_carrier_sid = await lookupCarrierByPhoneNumber(cs.accountSid, callingNumber);
+          const req_voip_carrier_sid = req.has('X-Voip-Carrier-Sid') ? req.get('X-Voip-Carrier-Sid') : null;
+          if (voip_carrier_sid) {
+            this.logger.info(
+              `Dial:_attemptCalls: selected voip_carrier_sid ${voip_carrier_sid} for callingNumber: ${callingNumber}`);
+            opts.headers['X-Requested-Carrier-Sid'] = voip_carrier_sid;
+
+            // Checking if outbound carrier is different from inbound carrier and has dtmf type tones
+            if (voip_carrier_sid !== req_voip_carrier_sid) {
+              const [voipCarrier] = await lookupVoipCarrierBySid(voip_carrier_sid);
+              this.inbandDtmfEnabled = voipCarrier?.dtmf_type === 'tones';
+            }
+          }
+        }
+
         if (this.killed) return;
 
         const sd = placeCall({
@@ -468,7 +672,9 @@ class TaskDial extends Task {
           callInfo: cs.callInfo,
           accountInfo: cs.accountInfo,
           rootSpan: cs.rootSpan,
-          startSpan: this.startSpan.bind(this)
+          startSpan: this.startSpan.bind(this),
+          dialTask: this,
+          onHoldMusic: this.cs.onHoldMusic
         });
         this.dials.set(sd.callSid, sd);
 
@@ -484,11 +690,13 @@ class TaskDial extends Task {
             }
           })
           .on('callStatusChange', (obj) => {
-            if (this.results.dialCallStatus !== CallStatus.Completed) {
+            if (this.results.dialCallStatus !== CallStatus.Completed &&
+              this.results.dialCallStatus !== CallStatus.NoAnswer) {
               Object.assign(this.results, {
                 dialCallStatus: obj.callStatus,
                 dialSipStatus: obj.sipStatus,
                 dialCallSid: sd.callSid,
+                dialSbcCallid: sd.callInfo.sbcCallid
               });
             }
             switch (obj.callStatus) {
@@ -524,6 +732,8 @@ class TaskDial extends Task {
               await this._connectSingleDial(cs, sd);
             } catch (err) {
               this.logger.info({err}, 'Dial:_attemptCalls - Error calling _connectSingleDial ');
+              sd.removeAllListeners();
+              this.kill(cs);
             }
           })
           .on('decline', () => {
@@ -537,11 +747,7 @@ class TaskDial extends Task {
             }
           })
           .on('reinvite', (req, res) => {
-            try {
-              cs.handleReinviteAfterMediaReleased(req, res);
-            } catch (err) {
-              this.logger.error(err, 'Error in dial einvite from B leg');
-            }
+            this._onReinvite(req, res);
           })
           .on('refer', (callInfo, req, res) => {
 
@@ -577,6 +783,56 @@ class TaskDial extends Task {
     this._killOutdials();       // NB: order is important
   }
 
+  async _onReinvite(req, res) {
+    try {
+      let isHandled = false;
+      if (this.isOnHoldEnabled) {
+        if (isOnhold(req.body)) {
+          this.logger.debug('Dial: _onReinvite receive hold Request');
+          if (!this.epOther && !this.ep) {
+            this.logger.debug(`Dial: _onReinvite receive hold Request,
+ media already released, reconnect media server`);
+            // update caller leg for new SDP from callee.
+            await this.cs.handleReinviteAfterMediaReleased(req, res);
+            // Freeswitch media is released, reconnect
+            await this.reAnchorMedia(this.cs, this.sd);
+            this.isOutgoingLegHold = true;
+          } else {
+            this.logger.debug('Dial: _onReinvite receive hold Request, update SDP');
+            const newSdp = await this.ep.modify(req.body);
+            res.send(200, {body: newSdp});
+          }
+          isHandled = true;
+          // Media already connected, ask for onHoldHook
+          this._onHoldHook(req);
+        } else if (!isOnhold(req.body)) {
+          this.logger.debug('Dial: _onReinvite receive unhold Request');
+          if (this.epOther && this.ep && this.isOutgoingLegHold && this.canReleaseMedia) {
+            this.logger.debug('Dial: _onReinvite receive unhold Request, release media');
+            // Offhold, time to release media
+            const newSdp = await this.ep.modify(req.body);
+            await res.send(200, {body: newSdp});
+            await this._releaseMedia(this.cs, this.sd, this.shouldExitMediaPathEntirely);
+            this.isOutgoingLegHold = false;
+          } else {
+            this.logger.debug('Dial: _onReinvite receive unhold Request, update media server');
+            const newSdp = await this.ep.modify(req.body);
+            res.send(200, {body: newSdp});
+          }
+          if (this._onHoldSession) {
+            this._onHoldSession.kill();
+          }
+          isHandled = true;
+        }
+      }
+      if (!isHandled) {
+        this.cs.handleReinviteAfterMediaReleased(req, res);
+      }
+    } catch (err) {
+      this.logger.error(err, 'Error in dial einvite from B leg');
+    }
+  }
+
   _onMaxCallDuration(cs) {
     this.logger.info(`Dial:_onMaxCallDuration tearing down call as it has reached ${this.timeLimit}s`);
     this.ep && this.ep.unbridge();
@@ -627,11 +883,27 @@ class TaskDial extends Task {
       dialCallSid: sd.callSid,
     });
 
+    if (this.dubTasks) {
+      for (const dub of this.dubTasks) {
+        try {
+          await dub.exec(cs, {ep: sd.ep});
+        }
+        catch (err) {
+          this.logger.error({err}, 'Dial:_selectSingleDial - error executing dubTask');
+        }
+      }
+    }
+
     if (this.parentDtmfCollector) this._installDtmfDetection(cs, cs.dlg);
     if (this.childDtmfCollector) this._installDtmfDetection(cs, this.dlg);
+    if (cs.sipRequestWithinDialogHook) {
+      /* remove any existing listener to escape from duplicating events */
+      this._removeSipIndialogRequestListener(this.dlg);
+      this._initSipIndialogRequestListener(cs, this.dlg);
+    }
 
-    if (this.transcribeTask) this.transcribeTask.exec(cs, {ep2: this.epOther, ep:this.ep});
-    if (this.listenTask) this.listenTask.exec(cs, {ep: this.epOther});
+    if (this.transcribeTask) this.transcribeTask.exec(cs, {ep: this.epOther, ep2:this.ep});
+    if (this.listenTask) this.listenTask.exec(cs, {ep: this.listenTask.channel === 2 ? this.ep : this.epOther});
     if (this.startAmd) {
       try {
         this.startAmd(cs, this.ep, this, this.data.amd);
@@ -640,8 +912,30 @@ class TaskDial extends Task {
       }
     }
 
+    /* boost audio signal if requested */
+    if (this.boostAudioSignal) {
+      try {
+        const db = parseDecibels(this.boostAudioSignal);
+        this.logger.info(`Dial: boosting audio signal by ${db} dB`);
+        const args = [this.ep.uuid, 'setGain', db];
+        await this.ep.api('uuid_dub', args);
+      } catch (err) {
+        this.logger.info({err}, 'Dial:_selectSingleDial - Error boosting audio signal');
+      }
+    }
+
     /* if we can release the media back to the SBC, do so now */
-    if (this.canReleaseMedia) setTimeout(this._releaseMedia.bind(this, cs, sd), 200);
+    if (this.canReleaseMedia || this.shouldExitMediaPathEntirely) {
+      setTimeout(this._releaseMedia.bind(this, cs, sd, this.shouldExitMediaPathEntirely), 200);
+    }
+
+    this.sd.ep.once('destroy', this._handleMediaTimeout.bind(this));
+  }
+
+  _handleMediaTimeout(evt) {
+    if (evt?.reason === 'MEDIA_TIMEOUT' && this.sd && this.bridged) {
+      this.kill(this.cs, KillReason.MediaTimeout);
+    }
   }
 
   _bridgeEarlyMedia(sd) {
@@ -653,20 +947,57 @@ class TaskDial extends Task {
     }
   }
 
+  /* public api */
+  async updateMediaPath(desiredPath) {
+    this.logger.info(`Dial:updateMediaPath - ${this._mediaPath} => ${desiredPath}`);
+    switch (desiredPath) {
+      case MediaPath.NoMedia:
+        assert(this._mediaPath !== MediaPath.NoMedia, 'updateMediaPath: already no-media');
+        await this._releaseMedia(this.cs, this.sd, true);
+        break;
+
+      case MediaPath.PartialMedia:
+        assert(this._mediaPath !== MediaPath.PartialMedia, 'updateMediaPath: already partial-media');
+        if (this._mediaPath === MediaPath.FullMedia) {
+          await this._releaseMedia(this.cs, this.sd, false);
+        }
+        else {
+          // to go from no-media to partial-media we need to go through full-media first
+          await this.reAnchorMedia(this.cs, this.sd);
+          await this._releaseMedia(this.cs, this.sd, false);
+        }
+        assert(!this.epOther, 'updateMediaPath: epOther should be null');
+        assert(!this.ep, 'updateMediaPath: ep should be null');
+
+        break;
+      case MediaPath.FullMedia:
+        assert(this._mediaPath !== MediaPath.FullMedia, 'updateMediaPath: already full-media');
+        await this.reAnchorMedia(this.cs, this.sd);
+        break;
+
+      default:
+        assert(false, `updateMediaPath: invalid path request ${desiredPath}`);
+    }
+  }
+
   /**
    * Release the media from freeswitch
    * @param {*} cs
    * @param {*} sd
    */
-  async _releaseMedia(cs, sd) {
+  async _releaseMedia(cs, sd, releaseEntirely = false) {
     assert(cs.ep && sd.ep);
 
     try {
+      // Wait until we got new SDP from B leg to ofter to A Leg
       const aLegSdp = cs.ep.remote.sdp;
+      await sd.releaseMediaToSBC(aLegSdp, cs.ep.local.sdp, releaseEntirely);
       const bLegSdp = sd.dlg.remote.sdp;
-      await Promise.all[sd.releaseMediaToSBC(aLegSdp, cs.ep.local.sdp), cs.releaseMediaToSBC(bLegSdp)];
+      await cs.releaseMediaToSBC(bLegSdp, releaseEntirely);
       this.epOther = null;
-      this.logger.info('Dial:_releaseMedia - successfully released media from freewitch');
+      this._mediaPath = releaseEntirely ? MediaPath.NoMedia : MediaPath.PartialMedia;
+      this.logger.info(
+        `Dial:_releaseMedia - successfully released media from freeswitch, media path is now ${this._mediaPath}`);
     } catch (err) {
       this.logger.info({err}, 'Dial:_releaseMedia error');
     }
@@ -675,21 +1006,112 @@ class TaskDial extends Task {
   async reAnchorMedia(cs, sd) {
     if (cs.ep && sd.ep) return;
 
-    this.logger.info('Dial:reAnchorMedia - re-anchoring media to freewitch');
-    await Promise.all([sd.reAnchorMedia(), cs.reAnchorMedia()]);
+    this.logger.info('Dial:reAnchorMedia - re-anchoring media to freeswitch');
+    await Promise.all([sd.reAnchorMedia(this._mediaPath), cs.reAnchorMedia(this._mediaPath)]);
     this.epOther = cs.ep;
+
+    this.epOther.bridge(this.ep);
+
+    this._mediaPath = MediaPath.FullMedia;
+    this.logger.info(
+      `Dial:_releaseMedia - successfully re-anchored media to freeswitch, media path is now ${this._mediaPath}`);
   }
 
+  // Handle RE-INVITE hold from caller leg.
   async handleReinviteAfterMediaReleased(req, res) {
-    const sdp = await this.dlg.modify(req.body);
-    this.logger.info({sdp}, 'Dial:handleReinviteAfterMediaReleased - sent reinvite to B leg');
-    res.send(200, {body: sdp});
+    let isHandled = false;
+    if (this.isOnHoldEnabled) {
+      if (isOnhold(req.body)) {
+        if (!this.epOther && !this.ep) {
+          // update callee leg for new SDP from caller.
+          const sdp = await this.dlg.modify(req.body);
+          res.send(200, {body: sdp});
+          // Onhold but media is already released, reconnect
+          await this.reAnchorMedia(this.cs, this.sd);
+          isHandled = true;
+          this.isIncomingLegHold = true;
+        }
+        this._onHoldHook(req);
+      } else if (!isOnhold(req.body)) {
+        if (this.epOther && this.ep && this.isIncomingLegHold &&
+          (this.canReleaseMedia || this.shouldExitMediaPathEntirely)) {
+          // Offhold, time to release media
+          const newSdp = await this.epOther.modify(req.body);
+          await res.send(200, {body: newSdp});
+          await this._releaseMedia(this.cs, this.sd, this.shouldExitMediaPathEntirely);
+          isHandled = true;
+        }
+        this.isIncomingLegHold = false;
+        if (this._onHoldSession) {
+          this._onHoldSession.kill();
+        }
+      }
+    }
+
+    if (!isHandled) {
+      const sdp = await this.dlg.modify(req.body);
+      this.logger.info({sdp}, 'Dial:handleReinviteAfterMediaReleased - sent reinvite to B leg');
+      res.send(200, {body: sdp});
+    }
   }
 
   _onAmdEvent(cs, evt) {
     this.logger.info({evt}, 'Dial:_onAmdEvent');
     const {actionHook} = this.data.amd;
-    this.performHook(cs, actionHook, evt);
+    this.performHook(cs, actionHook, evt)
+      .catch((err) => {
+        this.logger.error({err}, 'Dial:_onAmdEvent - error calling actionHook');
+      });
+  }
+
+  async _onHoldHook(req, allowed = [TaskName.Play, TaskName.Say, TaskName.Pause]) {
+    if (this.data.onHoldHook) {
+      // send silence for keep Voice quality
+      await this.epOther.play('silence_stream://500');
+      let allowedTasks;
+      do {
+        try {
+          const b3 = this.getTracingPropagation();
+          const httpHeaders = b3 && {b3};
+          const json = await this.cs.application.requestor.
+            request('verb:hook', this.data.onHoldHook, {
+              ...this.cs.callInfo.toJSON(),
+              hold_detail: {
+                from: req.get('From'),
+                to: req.get('To')
+              }
+            }, httpHeaders);
+          const tasks = normalizeJambones(this.logger, json).map((tdata) => makeTask(this.logger, tdata));
+          allowedTasks = tasks.filter((t) => allowed.includes(t.name));
+          if (tasks.length !== allowedTasks.length) {
+            this.logger.debug({tasks, allowedTasks}, 'unsupported task');
+            throw new Error(`unsupported verb in enqueue waitHook: only ${JSON.stringify(allowed)}`);
+          }
+          this.logger.debug(`DialTask:_onHoldHook: executing ${tasks.length} tasks`);
+          if (tasks.length) {
+            this._onHoldSession = new ConfirmCallSession({
+              logger: this.logger,
+              application: this.cs.application,
+              dlg: this.isIncomingLegHold ? this.dlg : this.cs.dlg,
+              ep: this.isIncomingLegHold ? this.ep : this.cs.ep,
+              callInfo: this.cs.callInfo,
+              accountInfo: this.cs.accountInfo,
+              tasks,
+              rootSpan: this.cs.rootSpan,
+              req: this.cs.req,
+              tmpFiles: this.cs.tmpFiles,
+            });
+            await this._onHoldSession.exec();
+            this._onHoldSession = null;
+          }
+        } catch (error) {
+          this.logger.info(error, 'DialTask:_onHoldHook: failed retrieving waitHook');
+          this._onHoldSession = null;
+          break;
+        }
+      } while (allowedTasks && allowedTasks.length > 0 && !this.killed && this.isOnHold);
+      this.logger.info('Finish onHoldHook');
+    }
   }
 }
 

lib/tasks/dialogflow/index.js

@@ -3,7 +3,7 @@ const {TaskName, TaskPreconditions} = require('../../utils/constants');
 const Intent = require('./intent');
 const DigitBuffer = require('./digit-buffer');
 const Transcription = require('./transcription');
-const normalizeJambones = require('../../utils/normalize-jambones');
+const { normalizeJambones } = require('@jambonz/verb-specifications');
 
 class Dialogflow extends Task {
   constructor(logger, opts) {
@@ -58,6 +58,13 @@ class Dialogflow extends Task {
       this.vendor = this.data.tts.vendor || 'default';
       this.language = this.data.tts.language || 'default';
       this.voice = this.data.tts.voice || 'default';
+      this.speechSynthesisLabel = this.data.tts.label;
+
+      // fallback tts
+      this.fallbackVendor = this.data.tts.fallbackVendor || 'default';
+      this.fallbackLanguage = this.data.tts.fallbackLanguage || 'default';
+      this.fallbackVoice = this.data.tts.fallbackLanguage || 'default';
+      this.fallbackLabel = this.data.tts.fallbackLabel;
     }
     this.bargein = this.data.bargein;
   }
@@ -118,8 +125,15 @@ class Dialogflow extends Task {
         this.vendor = cs.speechSynthesisVendor;
         this.language = cs.speechSynthesisLanguage;
         this.voice = cs.speechSynthesisVoice;
+        this.speechSynthesisLabel = cs.speechSynthesisLabel;
       }
-      this.ttsCredentials = cs.getSpeechCredentials(this.vendor, 'tts');
+      if (this.fallbackVendor === 'default') {
+        this.fallbackVendor = cs.fallbackSpeechSynthesisVendor;
+        this.fallbackLanguage = cs.fallbackSpeechSynthesisLanguage;
+        this.fallbackVoice = cs.fallbackSpeechSynthesisVoice;
+        this.fallbackLabel = cs.fallbackSpeechSynthesisLabel;
+      }
+      this.ttsCredentials = cs.getSpeechCredentials(this.vendor, 'tts', this.speechSynthesisLabel);
 
       this.ep.addCustomEventListener('dialogflow::intent', this._onIntent.bind(this, ep, cs));
       this.ep.addCustomEventListener('dialogflow::transcription', this._onTranscription.bind(this, ep, cs));
@@ -221,18 +235,8 @@ class Dialogflow extends Task {
       }
 
       try {
-        const obj = {
-          text: intent.fulfillmentText,
-          vendor: this.vendor,
-          language: this.language,
-          voice: this.voice,
-          salt: cs.callSid,
-          credentials: this.ttsCredentials
-        };
-        this.logger.debug({obj}, 'Dialogflow:_onIntent - playing message via tts');
-        const {filePath, servedFromCache} = await synthAudio(stats, obj);
+        const {filePath} = await this._fallbackSynthAudio(cs, intent, stats, synthAudio);
         if (filePath) cs.trackTmpFile(filePath);
-        if (!this.ttsCredentials && !servedFromCache) cs.billForTts(intent.fulfillmentText.length);
 
         if (this.playInProgress) {
           await ep.api('uuid_break', ep.uuid).catch((err) => this.logger.info(err, 'Error killing audio'));
@@ -276,6 +280,46 @@ class Dialogflow extends Task {
     }
   }
 
+  async _fallbackSynthAudio(cs, intent, stats, synthAudio) {
+    try {
+      const obj = {
+        account_sid: cs.accountSid,
+        text: intent.fulfillmentText,
+        vendor: this.vendor,
+        language: this.language,
+        voice: this.voice,
+        salt: cs.callSid,
+        credentials: this.ttsCredentials
+      };
+      this.logger.debug({obj}, 'Dialogflow:_onIntent - playing message via tts');
+
+      return await synthAudio(stats, obj);
+    } catch (error) {
+      this.logger.info({error}, 'Failed to synthesize audio from primary vendor');
+
+      try {
+        if (this.fallbackVendor) {
+          const credentials = cs.getSpeechCredentials(this.fallbackVendor, 'tts', this.fallbackLabel);
+          const obj = {
+            account_sid: cs.accountSid,
+            text: intent.fulfillmentText,
+            vendor: this.fallbackVendor,
+            language: this.fallbackLanguage,
+            voice: this.fallbackVoice,
+            salt: cs.callSid,
+            credentials
+          };
+          this.logger.debug({obj}, 'Dialogflow:_onIntent - playing message via fallback tts');
+          return await synthAudio(stats, obj);
+        }
+      } catch (err) {
+        this.logger.info({err}, 'Failed to synthesize audio from falllback vendor');
+        throw err;
+      }
+      throw error;
+    }
+  }
+
   /**
    * A transcription - either interim or final - has been returned.
    * If we are doing barge-in based on hotword detection, check for the hotword or phrase.

lib/tasks/dub.js

@@ -0,0 +1,145 @@
+const {TaskName} = require('../utils/constants');
+const TtsTask = require('./tts-task');
+const assert = require('assert');
+const parseDecibels = require('../utils/parse-decibels');
+
+/**
+ * Dub task: add or remove additional audio tracks into the call
+ */
+class TaskDub extends TtsTask {
+  constructor(logger, opts, parentTask) {
+    super(logger, opts, parentTask);
+
+    this.logger.debug({opts: this.data}, 'TaskDub constructor');
+    ['action', 'track', 'play', 'say', 'loop'].forEach((prop) => {
+      this[prop] = this.data[prop];
+    });
+    this.gain = parseDecibels(this.data.gain);
+
+    assert.ok(this.action, 'TaskDub: action is required');
+    assert.ok(this.track, 'TaskDub: track is required');
+  }
+
+  get name() { return TaskName.Dub; }
+
+  async exec(cs, {ep}) {
+    super.exec(cs);
+
+    try {
+      switch (this.action) {
+        case 'addTrack':
+          await this._addTrack(cs, ep);
+          break;
+        case 'removeTrack':
+          await this._removeTrack(cs, ep);
+          break;
+        case 'silenceTrack':
+          await this._silenceTrack(cs, ep);
+          break;
+        case 'playOnTrack':
+          await this._playOnTrack(cs, ep);
+          break;
+        case 'sayOnTrack':
+          await this._sayOnTrack(cs, ep);
+          break;
+        default:
+          throw new Error(`TaskDub: unsupported action ${this.action}`);
+      }
+    } catch (err) {
+      this.logger.error(err, 'Error executing dub task');
+    }
+  }
+
+  async _addTrack(cs, ep) {
+    this.logger.info(`adding track: ${this.track}`);
+    await ep.dub({
+      action: 'addTrack',
+      track: this.track
+    });
+
+    if (this.play) await this._playOnTrack(cs, ep);
+    else if (this.say) await this._sayOnTrack(cs, ep);
+  }
+
+  async _removeTrack(_cs, ep) {
+    this.logger.info(`removing track: ${this.track}`);
+    await ep.dub({
+      action: 'removeTrack',
+      track: this.track
+    });
+  }
+
+  async _silenceTrack(_cs, ep) {
+    this.logger.info(`silencing track: ${this.track}`);
+    await ep.dub({
+      action: 'silenceTrack',
+      track: this.track
+    });
+  }
+
+  async _playOnTrack(_cs, ep) {
+    this.logger.info(`playing on track: ${this.track}`);
+    await ep.dub({
+      action: 'playOnTrack',
+      track: this.track,
+      play: this.play,
+      // drachtio-fsmrf will convert loop from boolean to 'loop' or 'once'
+      loop: this.loop,
+      gain: this.gain
+    });
+  }
+
+  async _sayOnTrack(cs, ep) {
+    const text = this.say.text || this.say;
+    this.synthesizer = this.say.synthesizer || {};
+
+    if (Object.keys(this.synthesizer).length) {
+      this.logger.info({synthesizer: this.synthesizer},
+        `saying on track ${this.track}: ${text} with synthesizer options`);
+    }
+    else {
+      this.logger.info(`saying on track ${this.track}: ${text}`);
+    }
+    this.synthesizer = this.synthesizer || {};
+
+    this.text = [text];
+
+    const vendor = this.synthesizer.vendor && this.synthesizer.vendor !== 'default' ?
+      this.synthesizer.vendor :
+      cs.speechSynthesisVendor;
+    const language = this.synthesizer.language && this.synthesizer.language !== 'default' ?
+      this.synthesizer.language :
+      cs.speechSynthesisLanguage ;
+    const voice =  this.synthesizer.voice && this.synthesizer.voice !== 'default' ?
+      this.synthesizer.voice :
+      cs.speechSynthesisVoice;
+    const label = this.synthesizer.label && this.synthesizer.label !== 'default' ?
+      this.synthesizer.label :
+      cs.speechSynthesisLabel;
+
+    const disableTtsStreaming = false;
+    const filepath = await this._synthesizeWithSpecificVendor(cs, ep, {
+      vendor, language, voice, label, disableTtsStreaming
+    });
+    assert.ok(filepath.length === 1, 'TaskDub: no filepath returned from synthesizer');
+
+    const path = filepath[0];
+    if (!path.startsWith('say:{')) {
+      /* we have a local file of mp3 or r8 of synthesized speech audio to play */
+      this.logger.info(`playing synthesized speech from file on track ${this.track}: ${path}`);
+      this.play = path;
+      await this._playOnTrack(cs, ep);
+    }
+    else {
+      this.logger.info(`doing actual text to speech file on track ${this.track}: ${path}`);
+      await ep.dub({
+        action: 'sayOnTrack',
+        track: this.track,
+        say: path,
+        gain: this.gain
+      });
+    }
+  }
+}
+
+module.exports = TaskDub;

lib/tasks/enqueue.js

@@ -1,7 +1,7 @@
 const Task = require('./task');
 const Emitter = require('events');
 const ConfirmCallSession = require('../session/confirm-call-session');
-const normalizeJambones = require('../utils/normalize-jambones');
+const { normalizeJambones } = require('@jambonz/verb-specifications');
 const makeTask = require('./make_task');
 const {TaskName, TaskPreconditions, QueueResults, KillReason} = require('../utils/constants');
 const bent = require('bent');
@@ -18,6 +18,7 @@ class TaskEnqueue extends Task {
     this.preconditions = TaskPreconditions.Endpoint;
 
     this.queueName = this.data.name;
+    this.priority = this.data.priority;
     this.waitHook = this.data.waitHook;
 
     this.emitter = new Emitter();
@@ -70,12 +71,22 @@ class TaskEnqueue extends Task {
   }
 
   async _addToQueue(cs, dlg) {
-    const {pushBack} = cs.srf.locals.dbHelpers;
+    const {addToSortedSet, sortedSetLength} = cs.srf.locals.dbHelpers;
     const url = getUrl(cs);
     this.waitStartTime = Date.now();
     this.logger.debug({queue: this.queueName, url}, 'pushing url onto queue');
-    const members = await pushBack(this.queueName, url);
-    this.logger.info(`TaskEnqueue:_addToQueue: added to queue, length now ${members}`);
+    if (this.priority < 0) {
+      this.logger.warn(`priority ${this.priority} is invalid, need to be non-negative integer,
+      999 will be used for priority`);
+    }
+    let members = await addToSortedSet(this.queueName, url, this.priority);
+    if (members === 1) {
+      this.logger.info('TaskEnqueue:_addToQueue: added to queue');
+    } else {
+      this.logger.info('TaskEnqueue:_addToQueue: failed to add to queue');
+    }
+    members = await sortedSetLength(this.queueName);
+
     this.notifyUrl = url;
 
     /* invoke account-level webhook for queue event notifications */
@@ -90,9 +101,9 @@ class TaskEnqueue extends Task {
   }
 
   async _removeFromQueue(cs) {
-    const {removeFromList, lengthOfList} = cs.srf.locals.dbHelpers;
-    await removeFromList(this.queueName, getUrl(cs));
-    return await lengthOfList(this.queueName);
+    const {retrieveByPatternSortedSet, sortedSetLength} = cs.srf.locals.dbHelpers;
+    await retrieveByPatternSortedSet(this.queueName, `*${getUrl(cs)}`);
+    return await sortedSetLength(this.queueName);
   }
 
   async performAction() {
@@ -279,13 +290,13 @@ class TaskEnqueue extends Task {
       this.emitter.emit('dequeue', opts);
 
       try {
-        const {lengthOfList} = cs.srf.locals.dbHelpers;
-        const members = await lengthOfList(this.queueName);
+        const {sortedSetLength} = cs.srf.locals.dbHelpers;
+        const members = await sortedSetLength(this.queueName);
         this.dequeued = true;
         cs.performQueueWebhook({
           event: 'leave',
           queue: this.data.name,
-          length: Math.max(members - 1, 0),
+          length: Math.max(members, 0),
           leaveReason: 'dequeued',
           leaveTime: Date.now(),
           dequeuer: opts.dequeuer
@@ -300,8 +311,9 @@ class TaskEnqueue extends Task {
     }
   }
 
-  async _playHook(cs, dlg, hook, allowed = [TaskName.Play, TaskName.Say, TaskName.Pause, TaskName.Leave]) {
-    const {lengthOfList, getListPosition} = cs.srf.locals.dbHelpers;
+  async _playHook(cs, dlg, hook,
+    allowed = [TaskName.Play, TaskName.Say, TaskName.Pause, TaskName.Leave, TaskName.Tag]) {
+    const {sortedSetLength, sortedSetPositionByPattern} = cs.srf.locals.dbHelpers;
     const b3 = this.getTracingPropagation();
     const httpHeaders = b3 && {b3};
 
@@ -313,13 +325,20 @@ class TaskEnqueue extends Task {
       queueTime: getElapsedTime(this.waitStartTime)
     };
     try {
-      const queueSize = await lengthOfList(this.queueName);
-      const queuePosition = await getListPosition(this.queueName, this.notifyUrl);
-      Object.assign(params, {queueSize, queuePosition});
+      const queueSize = await sortedSetLength(this.queueName);
+      const queuePosition = await sortedSetPositionByPattern(this.queueName, `*${this.notifyUrl}`);
+      Object.assign(params, {
+        queueSize,
+        queuePosition: queuePosition.length ? queuePosition[0] : 0,
+        callSid: this.cs.callSid,
+        callId: this.cs.callId,
+        customerData: this.cs.callInfo.customerData
+      });
     } catch (err) {
       this.logger.error({err}, `TaskEnqueue:_playHook error retrieving list info for queue ${this.queueName}`);
     }
     const json = await cs.application.requestor.request('verb:hook', hook, params, httpHeaders);
+    this.logger.debug({json}, 'TaskEnqueue:_playHook: received response from waitHook');
     const tasks = normalizeJambones(this.logger, json).map((tdata) => makeTask(this.logger, tdata));
 
     const allowedTasks = tasks.filter((t) => allowed.includes(t.name));
@@ -350,7 +369,9 @@ class TaskEnqueue extends Task {
         callInfo: cs.callInfo,
         accountInfo: cs.accountInfo,
         tasks: tasksToRun,
-        rootSpan: cs.rootSpan
+        rootSpan: cs.rootSpan,
+        req: cs.req,
+        tmpFiles: cs.tmpFiles,
       });
       await this._playSession.exec();
       this._playSession = null;

lib/tasks/hangup.js

@@ -18,6 +18,7 @@ class TaskHangup extends Task {
     await super.exec(cs);
     try {
       await dlg.destroy({headers: this.headers});
+      cs._callReleased();
     } catch (err) {
       this.logger.error(err, 'TaskHangup:exec - Error hanging up call');
     }

lib/tasks/lex.js

@@ -1,6 +1,6 @@
 const Task = require('./task');
 const {TaskName, TaskPreconditions} = require('../utils/constants');
-const normalizeJambones = require('../utils/normalize-jambones');
+const { normalizeJambones } = require('@jambonz/verb-specifications');
 
 class Lex extends Task {
   constructor(logger, opts) {
@@ -25,6 +25,13 @@ class Lex extends Task {
       this.vendor = this.data.tts.vendor || 'default';
       this.language = this.data.tts.language || 'default';
       this.voice = this.data.tts.voice || 'default';
+      this.speechCredentialLabel = this.data.tts.label || 'default';
+
+      // fallback tts
+      this.fallbackVendor = this.data.tts.fallbackVendor || 'default';
+      this.fallbackLanguage = this.data.tts.fallbackLanguage || 'default';
+      this.fallbackVoice = this.data.tts.fallbackLanguage || 'default';
+      this.fallbackLabel = this.data.tts.fallbackLabel || 'default';
     }
 
     this.botName = `${this.bot}:${this.alias}:${this.region}`;
@@ -102,8 +109,16 @@ class Lex extends Task {
         this.vendor = cs.speechSynthesisVendor;
         this.language = cs.speechSynthesisLanguage;
         this.voice = cs.speechSynthesisVoice;
+        this.speechCredentialLabel = cs.speechSynthesisLabel;
       }
-      this.ttsCredentials = cs.getSpeechCredentials(this.vendor, 'tts');
+      if (this.fallbackVendor === 'default') {
+        this.fallbackVendor = cs.fallbackSpeechSynthesisVendor;
+        this.fallbackLanguage = cs.fallbackSpeechSynthesisLanguage;
+        this.fallbackVoice = cs.fallbackSpeechSynthesisVoice;
+        this.fallbackLabel = cs.fallbackSpeechSynthesisLabel;
+      }
+
+      this.ttsCredentials = cs.getSpeechCredentials(this.vendor, 'tts', this.speechCredentialLabel);
 
       this.ep.addCustomEventListener('lex::intent', this._onIntent.bind(this, ep, cs));
       this.ep.addCustomEventListener('lex::transcription', this._onTranscription.bind(this, ep, cs));
@@ -168,6 +183,41 @@ class Lex extends Task {
     }
   }
 
+  async _fallbackSynthAudio(cs, msg, stats, synthAudio) {
+    try {
+      const {filePath} = await synthAudio(stats, {
+        account_sid: cs.accountSid,
+        text: msg,
+        vendor: this.vendor,
+        language: this.language,
+        voice: this.voice,
+        salt: cs.callSid,
+        credentials: this.ttsCredentials
+      });
+
+      return filePath;
+    } catch (error) {
+      this.logger.info({error}, 'failed to synth audio from primary vendor');
+      if (this.fallbackVendor) {
+        try {
+          const credential = cs.getSpeechCredentials(this.fallbackVendor, 'tts', this.fallbackLabel);
+          const {filePath} = await synthAudio(stats, {
+            account_sid: cs.accountSid,
+            text: msg,
+            vendor: this.fallbackVendor,
+            language: this.fallbackLanguage,
+            voice: this.fallbackVoice,
+            salt: cs.callSid,
+            credentials: credential
+          });
+          return filePath;
+        } catch (err) {
+          this.logger.info({err}, 'failed to synth audio from fallback vendor');
+        }
+      }
+    }
+  }
+
   /**
    * @param {*} evt - event data
    */
@@ -187,15 +237,7 @@ class Lex extends Task {
 
         try {
           this.logger.debug(`tts with ${this.vendor} ${this.voice}`);
-          // eslint-disable-next-line no-unused-vars
-          const {filePath, servedFromCache} = await synthAudio(stats, {
-            text: msg,
-            vendor: this.vendor,
-            language: this.language,
-            voice: this.voice,
-            salt: cs.callSid,
-            credentials: this.ttsCredentials
-          });
+          const filePath = await this._fallbackSynthAudio(cs, msg, stats, synthAudio);
           if (filePath) cs.trackTmpFile(filePath);
 
           if (this.events.includes('start-play')) {

lib/tasks/listen.js

@@ -1,16 +1,23 @@
 const Task = require('./task');
-const {TaskName, TaskPreconditions, ListenEvents, ListenStatus} = require('../utils/constants');
+const {TaskName, TaskPreconditions, ListenEvents, ListenStatus} = require('../utils/constants.json');
 const makeTask = require('./make_task');
 const moment = require('moment');
+const MAX_PLAY_AUDIO_QUEUE_SIZE = 10;
+const DTMF_SPAN_NAME = 'dtmf';
 
 class TaskListen extends Task {
   constructor(logger, opts, parentTask) {
     super(logger, opts);
+    /**
+     * @deprecated
+     * use bidirectionalAudio.enabled
+     */
+    this.disableBidirectionalAudio = opts.disableBidirectionalAudio;
     this.preconditions = TaskPreconditions.Endpoint;
 
     [
       'action', 'auth', 'method', 'url', 'finishOnKey', 'maxLength', 'metadata', 'mixType', 'passDtmf', 'playBeep',
-      'sampleRate', 'timeout', 'transcribe', 'wsAuth'
+      'sampleRate', 'timeout', 'transcribe', 'wsAuth', 'disableBidirectionalAudio', 'channel'
     ].forEach((k) => this[k] = this.data[k]);
 
     this.mixType = this.mixType || 'mono';
@@ -20,12 +27,27 @@ class TaskListen extends Task {
     this.nested = parentTask instanceof Task;
 
     this.results = {};
+    this.playAudioQueue = [];
+    this.isPlayingAudioFromQueue = false;
+    this.bidirectionalAudio = {
+      enabled: this.disableBidirectionalAudio === true ? false : true,
+      ...(this.data['bidirectionalAudio']),
+    };
+
+    // From drachtio-version 3.0.40, forkAudioStart will send empty bugname, metadata together with
+    // bidirectionalAudio params that cause old version of freeswitch missunderstand between bugname and
+    // bidirectionalAudio params
+    this._bugname = 'audio_fork';
 
     if (this.transcribe) this.transcribeTask = makeTask(logger, {'transcribe': opts.transcribe}, this);
   }
 
   get name() { return TaskName.Listen; }
 
+  set bugname(name) { this._bugname = name; }
+
+  set ignoreCustomerData(val) { this._ignoreCustomerData = val; }
+
   async exec(cs, {ep}) {
     await super.exec(cs);
     this.ep = ep;
@@ -50,7 +72,7 @@ class TaskListen extends Task {
     } catch (err) {
       this.logger.info(err, `TaskListen:exec - error ${this.url}`);
     }
-    if (this.transcribeTask) this.transcribeTask.kill();
+    if (this.transcribeTask) this.transcribeTask.kill(cs);
     this._removeListeners(ep);
   }
 
@@ -58,10 +80,12 @@ class TaskListen extends Task {
     super.kill(cs);
     this.logger.debug(`TaskListen:kill endpoint connected? ${this.ep && this.ep.connected}`);
     this._clearTimer();
+    this.playAudioQueue = [];
     if (this.ep && this.ep.connected) {
       this.logger.debug('TaskListen:kill closing websocket');
       try {
-        await this.ep.forkAudioStop();
+        const args = this._bugname ? [this._bugname] : [];
+        await this.ep.forkAudioStop(...args);
         this.logger.debug('TaskListen:kill successfully closed websocket');
       } catch (err) {
         this.logger.info(err, 'TaskListen:kill');
@@ -79,15 +103,21 @@ class TaskListen extends Task {
     this.notifyTaskDone();
   }
 
-  async updateListen(status) {
+  async updateListen(status, silence = false) {
     if (!this.killed && this.ep && this.ep.connected) {
+      const args = [
+        ...(this._bugname ? [this._bugname] : []),
+        ...(status === ListenStatus.Pause ? ([silence]) : []),
+      ];
       this.logger.info(`TaskListen:updateListen status ${status}`);
       switch (status) {
         case ListenStatus.Pause:
-          await this.ep.forkAudioPause().catch((err) => this.logger.info(err, 'TaskListen: error pausing audio'));
+          await this.ep.forkAudioPause(...args)
+            .catch((err) => this.logger.info(err, 'TaskListen: error pausing audio'));
           break;
         case ListenStatus.Resume:
-          await this.ep.forkAudioResume().catch((err) => this.logger.info(err, 'TaskListen: error resuming audio'));
+          await this.ep.forkAudioResume(...args)
+            .catch((err) => this.logger.info(err, 'TaskListen: error resuming audio'));
           break;
       }
     }
@@ -100,13 +130,15 @@ class TaskListen extends Task {
 
   async _startListening(cs, ep) {
     this._initListeners(ep);
+    const ci = this.nested ? this.parentTask.sd.callInfo : cs.callInfo.toJSON();
+    if (this._ignoreCustomerData) {
+      delete ci.customerData;
+    }
     const metadata = Object.assign(
       {sampleRate: this.sampleRate, mixType: this.mixType},
-      this.nested ? this.parentTask.sd.callInfo : cs.callInfo.toJSON(),
+      ci,
       this.metadata);
     if (this.hook.auth) {
-      this.logger.debug({username: this.hook.auth.username, password: this.hook.auth.password},
-        'TaskListen:_startListening basic auth');
       await this.ep.set({
         'MOD_AUDIO_BASIC_AUTH_USERNAME': this.hook.auth.username,
         'MOD_AUDIO_BASIC_AUTH_PASSWORD': this.hook.auth.password
@@ -116,7 +148,9 @@ class TaskListen extends Task {
       wsUrl: this.hook.url,
       mixType: this.mixType,
       sampling: this.sampleRate,
-      metadata
+      ...(this._bugname && {bugname: this._bugname}),
+      metadata,
+      bidirectionalAudio: this.bidirectionalAudio || {}
     });
     this.recordStartTime = moment();
     if (this.maxLength) {
@@ -136,7 +170,9 @@ class TaskListen extends Task {
     }
 
     /* support bi-directional audio */
-    ep.addCustomEventListener(ListenEvents.PlayAudio, this._onPlayAudio.bind(this, ep));
+    if (this.bidirectionalAudio.enabled) {
+      ep.addCustomEventListener(ListenEvents.PlayAudio, this._onPlayAudio.bind(this, ep));
+    }
     ep.addCustomEventListener(ListenEvents.KillAudio, this._onKillAudio.bind(this, ep));
     ep.addCustomEventListener(ListenEvents.Disconnect, this._onDisconnect.bind(this, ep));
   }
@@ -155,12 +191,25 @@ class TaskListen extends Task {
   }
 
   _onDtmf(ep, evt) {
-    this.logger.debug({evt}, `TaskListen:_onDtmf received dtmf ${evt.dtmf}`);
+    const {dtmf, duration} = evt;
+    this.logger.debug({evt}, `TaskListen:_onDtmf received dtmf ${dtmf}`);
     if (this.passDtmf && this.ep?.connected) {
-      const obj = {event: 'dtmf', dtmf: evt.dtmf, duration: evt.duration};
-      this.ep.forkAudioSendText(obj)
+      const obj = {event: 'dtmf', dtmf, duration};
+      const args = this._bugname ? [this._bugname, obj] : [obj];
+      this.ep.forkAudioSendText(...args)
         .catch((err) => this.logger.info({err}, 'TaskListen:_onDtmf error sending dtmf'));
     }
+
+    /* add a child span for the dtmf event */
+    const msDuration = Math.floor((duration / 8000) * 1000);
+    const {span} = this.startChildSpan(`${DTMF_SPAN_NAME}:${dtmf}`);
+    span.setAttributes({
+      channel: 1,
+      dtmf,
+      duration: `${msDuration}ms`
+    });
+    span.end();
+
     if (evt.dtmf === this.finishOnKey) {
       this.logger.info(`TaskListen:_onDtmf terminating task due to dtmf ${evt.dtmf}`);
       this.results.digits = evt.dtmf;
@@ -175,23 +224,51 @@ class TaskListen extends Task {
     }
   }
   _onConnect(ep) {
-    this.logger.debug('TaskListen:_onConnect');
+    this.logger.info('TaskListen:_onConnect');
   }
   _onConnectFailure(ep, evt) {
     this.logger.info(evt, 'TaskListen:_onConnectFailure');
     this.notifyTaskDone();
   }
 
-  async _onPlayAudio(ep, evt) {
-    this.logger.info(`received play_audio event: ${JSON.stringify(evt)}`);
+  async _playAudio(ep, evt, logger) {
     try {
       const results = await ep.play(evt.file);
-      this.logger.debug(`Finished playing file, result: ${JSON.stringify(results)}`);
-      ep.forkAudioSendText({type: 'playDone', data: Object.assign({id: evt.id}, results)});
+      logger.debug(`Finished playing file, result: ${JSON.stringify(results)}`);
+      const obj = {
+        type: 'playDone',
+        data: {
+          id: evt.id,
+          ...results
+        }
+      };
+      const args = this._bugname ? [this._bugname, obj] : [obj];
+      ep.forkAudioSendText(...args);
+    } catch (err) {
+      logger.error({err}, 'Error playing file');
     }
-    catch (err) {
-      this.logger.error({err}, 'Error playing file');
+  }
+
+  async _onPlayAudio(ep, evt) {
+    this.logger.info(`received play_audio event: ${JSON.stringify(evt)}`);
+    if (!evt.queuePlay) {
+      this.playAudioQueue = [];
+      this._playAudio(ep, evt, this.logger);
+      this.isPlayingAudioFromQueue = false;
+      return;
     }
+
+    if (this.playAudioQueue.length <= MAX_PLAY_AUDIO_QUEUE_SIZE) {
+      this.playAudioQueue.push(evt);
+    }
+
+    if (this.isPlayingAudioFromQueue) return;
+
+    this.isPlayingAudioFromQueue = true;
+    while (this.playAudioQueue.length > 0) {
+      await this._playAudio(ep, this.playAudioQueue.shift(), this.logger);
+    }
+    this.isPlayingAudioFromQueue = false;
   }
 
   _onKillAudio(ep) {

lib/tasks/llm/index.js

@@ -0,0 +1,144 @@
+const Task = require('../task');
+const {TaskPreconditions} = require('../../utils/constants');
+const TaskLlmOpenAI_S2S = require('./llms/openai_s2s');
+const TaskLlmVoiceAgent_S2S = require('./llms/voice_agent_s2s');
+const TaskLlmUltravox_S2S = require('./llms/ultravox_s2s');
+const TaskLlmElevenlabs_S2S = require('./llms/elevenlabs_s2s');
+const TaskLlmGoogle_S2S = require('./llms/google_s2s');
+const LlmMcpService = require('../../utils/llm-mcp');
+
+class TaskLlm extends Task {
+  constructor(logger, opts) {
+    super(logger, opts);
+    this.preconditions = TaskPreconditions.Endpoint;
+
+    ['vendor', 'model', 'auth', 'connectOptions'].forEach((prop) => {
+      this[prop] = this.data[prop];
+    });
+
+    this.eventHandlers = [];
+
+    // delegate to the specific llm model
+    this.llm = this.createSpecificLlm();
+    // MCP
+    this.mcpServers = this.data.mcpServers || [];
+  }
+
+  get name() { return this.llm.name ; }
+
+  get toolHook() { return this.llm?.toolHook; }
+
+  get eventHook() { return this.llm?.eventHook; }
+
+  get ep() { return this.cs.ep; }
+
+  get mcpService() {
+    return this.llmMcpService;
+  }
+
+  get isMcpEnabled() {
+    return this.mcpServers.length > 0;
+  }
+
+  async exec(cs, {ep}) {
+    await super.exec(cs, {ep});
+
+    // create the MCP service if we have MCP servers
+    if (this.isMcpEnabled) {
+      this.llmMcpService = new LlmMcpService(this.logger, this.mcpServers);
+      await this.llmMcpService.init();
+    }
+    await this.llm.exec(cs, {ep});
+  }
+
+  async kill(cs) {
+    super.kill(cs);
+    await this.llm.kill(cs);
+    // clean up MCP clients
+    if (this.isMcpEnabled) {
+      await this.mcpService.close();
+    }
+  }
+
+  createSpecificLlm() {
+    let llm;
+    switch (this.vendor) {
+      case 'openai':
+      case 'microsoft':
+        llm = new TaskLlmOpenAI_S2S(this.logger, this.data, this);
+        break;
+
+      case 'voiceagent':
+      case 'deepgram':
+        llm = new TaskLlmVoiceAgent_S2S(this.logger, this.data, this);
+        break;
+
+      case 'ultravox':
+        llm = new TaskLlmUltravox_S2S(this.logger, this.data, this);
+        break;
+
+      case 'elevenlabs':
+        llm = new TaskLlmElevenlabs_S2S(this.logger, this.data, this);
+        break;
+
+      case 'google':
+        llm = new TaskLlmGoogle_S2S(this.logger, this.data, this);
+        break;
+
+      default:
+        throw new Error(`Unsupported vendor ${this.vendor} for LLM`);
+    }
+
+    if (!llm) {
+      throw new Error(`Unsupported vendor:model ${this.vendor}:${this.model}`);
+    }
+    return llm;
+  }
+
+  addCustomEventListener(ep, event, handler) {
+    this.eventHandlers.push({ep, event, handler});
+    ep.addCustomEventListener(event, handler);
+  }
+
+  removeCustomEventListeners() {
+    this.eventHandlers.forEach((h) => h.ep.removeCustomEventListener(h.event, h.handler));
+  }
+
+  async sendEventHook(data) {
+    await this.cs?.requestor.request('llm:event', this.eventHook, data);
+  }
+
+
+  async sendToolHook(tool_call_id, data) {
+    const tool_response = await this.cs?.requestor.request('llm:tool-call', this.toolHook, {tool_call_id, ...data});
+    // if the toolHook was a websocket it will return undefined, otherwise it should return an object
+    if (typeof tool_response != 'undefined') {
+      tool_response.type = 'client_tool_result';
+      tool_response.invocation_id = tool_call_id;
+      this.processToolOutput(tool_call_id, tool_response);
+    }
+  }
+
+  async processToolOutput(tool_call_id, data) {
+    if (!this.ep.connected) {
+      this.logger.info('TaskLlm:processToolOutput - no connected endpoint');
+      return;
+    }
+    this.llm.processToolOutput(this.ep, tool_call_id, data);
+  }
+
+  async processLlmUpdate(data, callSid) {
+    if (this.ep.connected) {
+      if (typeof this.llm.processLlmUpdate === 'function') {
+        this.llm.processLlmUpdate(this.ep, data, callSid);
+      }
+      else {
+        const {vendor, model} = this.llm;
+        this.logger.info({data, callSid},
+          `TaskLlm:_processLlmUpdate: LLM ${vendor}:${model} does not support llm:update`);
+      }
+    }
+  }
+}
+
+module.exports = TaskLlm;

lib/tasks/llm/llms/elevenlabs_s2s.js

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

lib/tasks/llm/llms/google_s2s.js

@@ -0,0 +1,319 @@
+const Task = require('../../task');
+const TaskName = 'Llm_Google_s2s';
+const {LlmEvents_Google} = require('../../../utils/constants');
+const ClientEvent = 'client.event';
+const SessionDelete = 'session.delete';
+
+const google_server_events = [
+  'error',
+  'session.created',
+  'session.updated',
+];
+
+const expandWildcards = (events) => {
+  const expandedEvents = [];
+
+  events.forEach((evt) => {
+    if (evt.endsWith('.*')) {
+      const prefix = evt.slice(0, -2); // Remove the wildcard ".*"
+      const matchingEvents = google_server_events.filter((e) => e.startsWith(prefix));
+      expandedEvents.push(...matchingEvents);
+    } else {
+      expandedEvents.push(evt);
+    }
+  });
+
+  return expandedEvents;
+};
+
+class TaskLlmGoogle_S2S extends Task {
+  constructor(logger, opts, parentTask) {
+    super(logger, opts, parentTask);
+    this.parent = parentTask;
+
+    this.vendor = this.parent.vendor;
+    this.vendor = this.parent.vendor;
+    this.model = this.parent.model || 'models/gemini-2.0-flash-live-001';
+    this.auth = this.parent.auth;
+    this.connectionOptions = this.parent.connectOptions;
+
+    const {apiKey} = this.auth || {};
+    if (!apiKey) throw new Error('auth.apiKey is required for Google S2S');
+
+    this.apiKey = apiKey;
+
+    this.actionHook = this.data.actionHook;
+    this.eventHook = this.data.eventHook;
+    this.toolHook = this.data.toolHook;
+
+    const {setup} = this.data.llmOptions;
+
+    if (typeof setup !== 'object') {
+      throw new Error('llmOptions with an initial setup is required for Google S2S');
+    }
+    this.setup = {
+      ...setup,
+      model: this.model,
+      // make sure output is always audio
+      generationConfig: {
+        ...(setup.generationConfig || {}),
+        responseModalities: 'audio'
+      }
+    };
+
+    this.results = {
+      completionReason: 'normal conversation end'
+    };
+
+    /**
+     * only one of these will have items,
+     * if includeEvents, then these are the events to include
+     * if excludeEvents, then these are the events to exclude
+     */
+    this.includeEvents = [];
+    this.excludeEvents = [];
+
+    /* default to all events if user did not specify */
+    this._populateEvents(this.data.events || google_server_events);
+
+    this.addCustomEventListener = parentTask.addCustomEventListener.bind(parentTask);
+    this.removeCustomEventListeners = parentTask.removeCustomEventListeners.bind(parentTask);
+  }
+
+  get name() { return TaskName; }
+
+  async _api(ep, args) {
+    const res = await ep.api('uuid_google_s2s', `^^|${args.join('|')}`);
+    if (!res.body?.startsWith('+OK')) {
+      throw new Error({args}, `Error calling uuid_openai_s2s: ${res.body}`);
+    }
+  }
+
+  async exec(cs, {ep}) {
+    await super.exec(cs);
+
+    await this._startListening(cs, ep);
+
+    await this.awaitTaskDone();
+
+    /* note: the parent llm verb started the span, which is why this is necessary */
+    await this.parent.performAction(this.results);
+
+    this._unregisterHandlers();
+  }
+
+  async kill(cs) {
+    super.kill(cs);
+
+    this._api(cs.ep, [cs.ep.uuid, SessionDelete])
+      .catch((err) => this.logger.info({err}, 'TaskLlmGoogle_S2S:kill - error deleting session'));
+
+    this.notifyTaskDone();
+  }
+
+  _populateEvents(events) {
+    if (events.includes('all')) {
+      /* work by excluding specific events */
+      const exclude = events
+        .filter((evt) => evt.startsWith('-'))
+        .map((evt) => evt.slice(1));
+      if (exclude.length === 0) this.includeEvents = google_server_events;
+      else this.excludeEvents = expandWildcards(exclude);
+    }
+    else {
+      /* work by including specific events */
+      const include = events
+        .filter((evt) => !evt.startsWith('-'));
+      this.includeEvents = expandWildcards(include);
+    }
+
+    this.logger.debug({
+      includeEvents: this.includeEvents,
+      excludeEvents: this.excludeEvents
+    }, 'TaskLlmGoogle_S2S:_populateEvents');
+  }
+
+  async _startListening(cs, ep) {
+    this._registerHandlers(ep);
+
+    try {
+      const args = [ep.uuid, 'session.create', this.apiKey];
+      await this._api(ep, args);
+    } catch (err) {
+      this.logger.error({err}, 'TaskLlmGoogle_S2S:_startListening');
+      this.notifyTaskDone();
+    }
+  }
+
+  async _sendClientEvent(ep, obj) {
+    let ok = true;
+    this.logger.debug({obj}, 'TaskLlmGoogle_S2S:_sendClientEvent');
+    try {
+      const args = [ep.uuid, ClientEvent, JSON.stringify(obj)];
+      await this._api(ep, args);
+    } catch (err) {
+      ok = false;
+      this.logger.error({err}, 'TaskLlmGoogle_S2S:_sendClientEvent - Error');
+    }
+    return ok;
+  }
+
+  async _sendInitialMessage(ep) {
+    const setup = this.setup;
+    const mcpTools = this.parent.isMcpEnabled ? await this.parent.mcpService.getAvailableMcpTools() : [];
+    if (mcpTools && mcpTools.length > 0) {
+      const convertedTools = [
+        {
+          functionDeclarations: mcpTools.map((tool) => {
+            if (tool.inputSchema) {
+              delete tool.inputSchema.additionalProperties;
+              delete tool.inputSchema['$schema'];
+            }
+            return {
+              name: tool.name,
+              description: tool.description,
+              parameters: tool.inputSchema,
+            };
+          })
+        }
+      ];
+      // merge with any existing tools
+      setup.tools = [...convertedTools, ...(this.setup.tools || [])];
+    }
+    if (!await this._sendClientEvent(ep, {
+      setup,
+    })) {
+      this.logger.debug(this.setup, 'TaskLlmGoogle_S2S:_sendInitialMessage - sending session.update');
+      this.notifyTaskDone();
+    }
+  }
+
+  _registerHandlers(ep) {
+    this.addCustomEventListener(ep, LlmEvents_Google.Connect, this._onConnect.bind(this, ep));
+    this.addCustomEventListener(ep, LlmEvents_Google.ConnectFailure, this._onConnectFailure.bind(this, ep));
+    this.addCustomEventListener(ep, LlmEvents_Google.Disconnect, this._onDisconnect.bind(this, ep));
+    this.addCustomEventListener(ep, LlmEvents_Google.ServerEvent, this._onServerEvent.bind(this, ep));
+  }
+
+  _unregisterHandlers() {
+    this.removeCustomEventListeners();
+  }
+
+  _onError(ep, evt) {
+    this.logger.info({evt}, 'TaskLlmGoogle_S2S:_onError');
+    this.notifyTaskDone();
+  }
+
+  _onConnect(ep) {
+    this.logger.debug('TaskLlmGoogle_S2S:_onConnect');
+    this._sendInitialMessage(ep);
+  }
+  _onConnectFailure(_ep, evt) {
+    this.logger.info(evt, 'TaskLlmGoogle_S2S:_onConnectFailure');
+    this.results = {completionReason: 'connection failure'};
+    this.notifyTaskDone();
+  }
+  _onDisconnect(_ep, evt) {
+    this.logger.info(evt, 'TaskLlmGoogle_S2S:_onConnectFailure');
+    this.results = {completionReason: 'disconnect from remote end'};
+    this.notifyTaskDone();
+  }
+
+  async _onServerEvent(ep, evt) {
+    let endConversation = false;
+    this.logger.debug({evt}, 'TaskLlmGoogle_S2S:_onServerEvent');
+    const {toolCall /**toolCallCancellation*/}  = evt;
+
+    if (toolCall) {
+      this.logger.debug({toolCall}, 'TaskLlmGoogle_S2S:_onServerEvent - toolCall');
+      if (!this.toolHook) {
+        this.logger.info({evt}, 'TaskLlmGoogle_S2S:_onServerEvent - no toolHook defined!');
+      }
+      else {
+        const {functionCalls} = toolCall;
+        const mcpTools = this.parent.isMcpEnabled ? await this.parent.mcpService.getAvailableMcpTools() : [];
+        const functionResponses = [];
+        if (mcpTools && mcpTools.length > 0) {
+          for (const functionCall of functionCalls) {
+            const {name, args, id} = functionCall;
+            const tool = mcpTools.find((tool) => tool.name === name);
+            if (tool) {
+              const response = await this.parent.mcpService.callMcpTool(name, args);
+              functionResponses.push({
+                response: {
+                  output: response,
+                },
+                id
+              });
+            }
+          }
+        }
+
+        if (functionResponses && functionResponses.length > 0) {
+          this.logger.debug({functionResponses}, 'TaskLlmGoogle_S2S:_onServerEvent - function_call - mcp result');
+          this.processToolOutput(ep, 'tool_call_id', {
+            toolResponse: {
+              functionResponses
+            }
+          });
+        } else {
+          try {
+            await this.parent.sendToolHook('function_call_id', {type: 'toolCall', functionCalls});
+          } catch (err) {
+            this.logger.info({err, evt}, 'TaskLlmGoogle_S2S - error calling function');
+            this.results = {
+              completionReason: 'client error calling function',
+              error: err
+            };
+            endConversation = true;
+          }
+        }
+      }
+    }
+
+    this._sendLlmEvent('llm_event', evt);
+
+    if (endConversation) {
+      this.logger.info({results: this.results},
+        'TaskLlmGoogle_S2S:_onServerEvent - ending conversation due to error');
+      this.notifyTaskDone();
+    }
+  }
+
+  _sendLlmEvent(type, evt) {
+    /* check whether we should notify on this event */
+    if (this.includeEvents.length > 0 ? this.includeEvents.includes(type) : !this.excludeEvents.includes(type)) {
+      this.parent.sendEventHook(evt)
+        .catch((err) => this.logger.info({err}, 'TaskLlmGoogle_S2S:_onServerEvent - error sending event hook'));
+    }
+  }
+
+  async processLlmUpdate(ep, data, _callSid) {
+    try {
+      this.logger.debug({data, _callSid}, 'TaskLlmGoogle_S2S:processLlmUpdate');
+
+      await this._api(ep, [ep.uuid, ClientEvent, JSON.stringify(data)]);
+    } catch (err) {
+      this.logger.info({err, data}, 'TaskLlmGoogle_S2S:processLlmUpdate - Error processing LLM update');
+    }
+  }
+
+  async processToolOutput(ep, tool_call_id, data) {
+    try {
+      this.logger.debug({tool_call_id, data}, 'TaskLlmGoogle_S2S:processToolOutput');
+      const {toolResponse} = data;
+
+      if (!toolResponse) {
+        this.logger.info({data},
+          'TaskLlmGoogle_S2S:processToolOutput - invalid tool output, must be functionResponses');
+      }
+      else {
+        await this._api(ep, [ep.uuid, ClientEvent, JSON.stringify(data)]);
+      }
+    } catch (err) {
+      this.logger.info({err, data}, 'TaskLlmGoogle_S2S:processToolOutput - Error processing tool output');
+    }
+  }
+}
+
+module.exports = TaskLlmGoogle_S2S;

lib/tasks/llm/llms/openai_s2s.js

@@ -0,0 +1,398 @@
+const Task = require('../../task');
+const TaskName = 'Llm_OpenAI_s2s';
+const {LlmEvents_OpenAI} = require('../../../utils/constants');
+const ClientEvent = 'client.event';
+const SessionDelete = 'session.delete';
+
+const openai_server_events = [
+  'error',
+  'session.created',
+  'session.updated',
+  'conversation.created',
+  'input_audio_buffer.committed',
+  'input_audio_buffer.cleared',
+  'input_audio_buffer.speech_started',
+  'input_audio_buffer.speech_stopped',
+  'conversation.item.created',
+  'conversation.item.input_audio_transcription.completed',
+  'conversation.item.input_audio_transcription.failed',
+  'conversation.item.truncated',
+  'conversation.item.deleted',
+  'response.created',
+  'response.done',
+  'response.output_item.added',
+  'response.output_item.done',
+  'response.content_part.added',
+  'response.content_part.done',
+  'response.text.delta',
+  'response.text.done',
+  'response.audio_transcript.delta',
+  'response.audio_transcript.done',
+  'response.audio.delta',
+  'response.audio.done',
+  'response.function_call_arguments.delta',
+  'response.function_call_arguments.done',
+  'rate_limits.updated',
+  'output_audio.playback_started',
+  'output_audio.playback_stopped',
+];
+
+const expandWildcards = (events) => {
+  const expandedEvents = [];
+
+  events.forEach((evt) => {
+    if (evt.endsWith('.*')) {
+      const prefix = evt.slice(0, -2); // Remove the wildcard ".*"
+      const matchingEvents = openai_server_events.filter((e) => e.startsWith(prefix));
+      expandedEvents.push(...matchingEvents);
+    } else {
+      expandedEvents.push(evt);
+    }
+  });
+
+  return expandedEvents;
+};
+
+class TaskLlmOpenAI_S2S extends Task {
+  constructor(logger, opts, parentTask) {
+    super(logger, opts, parentTask);
+    this.parent = parentTask;
+
+    this.vendor = this.parent.vendor;
+    this.model = this.parent.model || 'gpt-4o-realtime-preview-2024-12-17';
+    this.auth = this.parent.auth;
+    this.connectionOptions = this.parent.connectOptions;
+
+    const {apiKey} = this.auth || {};
+    if (!apiKey) throw new Error('auth.apiKey is required for OpenAI S2S');
+
+    if (['openai', 'microsoft'].indexOf(this.vendor) === -1) {
+      throw new Error(`Invalid vendor ${this.vendor} for OpenAI S2S`);
+    }
+
+    if ('microsoft' === this.vendor && !this.connectionOptions?.host) {
+      throw new Error('connectionOptions.host is required for Microsoft OpenAI S2S');
+    }
+
+    this.apiKey = apiKey;
+    this.authType = 'microsoft' === this.vendor ? 'query' : 'bearer';
+    this.actionHook = this.data.actionHook;
+    this.eventHook = this.data.eventHook;
+    this.toolHook = this.data.toolHook;
+    const {response_create, session_update} = this.data.llmOptions;
+
+    if (typeof response_create !== 'object') {
+      throw new Error('llmOptions with an initial response.create is required for OpenAI S2S');
+    }
+
+    this.response_create = response_create;
+    this.session_update = session_update;
+
+    this.results = {
+      completionReason: 'normal conversation end'
+    };
+
+    /**
+     * only one of these will have items,
+     * if includeEvents, then these are the events to include
+     * if excludeEvents, then these are the events to exclude
+     */
+    this.includeEvents = [];
+    this.excludeEvents = [];
+
+    /* default to all events if user did not specify */
+    this._populateEvents(this.data.events || openai_server_events);
+
+    this.addCustomEventListener = parentTask.addCustomEventListener.bind(parentTask);
+    this.removeCustomEventListeners = parentTask.removeCustomEventListeners.bind(parentTask);
+  }
+
+  get name() { return TaskName; }
+
+  get host() {
+    const {host} = this.connectionOptions || {};
+    return host || (this.vendor === 'openai' ? 'api.openai.com' : void 0);
+  }
+
+  get path() {
+    const {path} = this.connectionOptions || {};
+    if (path) return path;
+
+    switch (this.vendor) {
+      case 'openai':
+        return `v1/realtime?model=${this.model}`;
+      case 'microsoft':
+        return `openai/realtime?api-version=2024-10-01-preview&deployment=${this.model}`;
+    }
+  }
+
+  async _api(ep, args) {
+    const res = await ep.api('uuid_openai_s2s', `^^|${args.join('|')}`);
+    if (!res.body?.startsWith('+OK')) {
+      throw new Error({args}, `Error calling uuid_openai_s2s: ${res.body}`);
+    }
+  }
+
+  async exec(cs, {ep}) {
+    await super.exec(cs);
+
+    await this._startListening(cs, ep);
+
+    await this.awaitTaskDone();
+
+    /* note: the parent llm verb started the span, which is why this is necessary */
+    await this.parent.performAction(this.results);
+
+    this._unregisterHandlers();
+  }
+
+  async kill(cs) {
+    super.kill(cs);
+
+    this._api(cs.ep, [cs.ep.uuid, SessionDelete])
+      .catch((err) => this.logger.info({err}, 'TaskLlmOpenAI_S2S:kill - error deleting session'));
+
+    this.notifyTaskDone();
+  }
+
+  /**
+   * Send function call output to the OpenAI server in the form of conversation.item.create
+   * per https://platform.openai.com/docs/guides/realtime/function-calls
+   */
+  async processToolOutput(ep, tool_call_id, data) {
+    try {
+      this.logger.debug({tool_call_id, data}, 'TaskLlmOpenAI_S2S:processToolOutput');
+
+      if (!data.type || data.type !== 'conversation.item.create') {
+        this.logger.info({data},
+          'TaskLlmOpenAI_S2S:processToolOutput - invalid tool output, must be conversation.item.create');
+      }
+      else {
+        await this._api(ep, [ep.uuid, ClientEvent, JSON.stringify(data)]);
+
+        // spec also recommends to send immediate response.create
+        await this._api(ep, [ep.uuid, ClientEvent, JSON.stringify({type: 'response.create'})]);
+      }
+    } catch (err) {
+      this.logger.info({err}, 'TaskLlmOpenAI_S2S:processToolOutput');
+    }
+  }
+
+  /**
+   * Send a session.update to the OpenAI server
+   * Note: creating and deleting conversation items also supported as well as interrupting the assistant
+   */
+  async processLlmUpdate(ep, data, _callSid) {
+    try {
+      this.logger.debug({data, _callSid}, 'TaskLlmOpenAI_S2S:processLlmUpdate');
+
+      if (!data.type || ![
+        'session.update',
+        'conversation.item.create',
+        'conversation.item.delete',
+        'response.cancel'
+      ].includes(data.type)) {
+        this.logger.info({data}, 'TaskLlmOpenAI_S2S:processLlmUpdate - invalid mid-call request');
+      }
+      else {
+        await this._api(ep, [ep.uuid, ClientEvent, JSON.stringify(data)]);
+      }
+    } catch (err) {
+      this.logger.info({err}, 'TaskLlmOpenAI_S2S:processLlmUpdate');
+    }
+  }
+
+  async _startListening(cs, ep) {
+    this._registerHandlers(ep);
+
+    try {
+      const args = [ep.uuid, 'session.create', this.host, this.path, this.authType, this.apiKey];
+      await this._api(ep, args);
+    } catch (err) {
+      this.logger.error({err}, 'TaskLlmOpenAI_S2S:_startListening');
+      this.notifyTaskDone();
+    }
+  }
+
+  async _sendClientEvent(ep, obj) {
+    let ok = true;
+    this.logger.debug({obj}, 'TaskLlmOpenAI_S2S:_sendClientEvent');
+    try {
+      const args = [ep.uuid, ClientEvent, JSON.stringify(obj)];
+      await this._api(ep, args);
+    } catch (err) {
+      ok = false;
+      this.logger.error({err}, 'TaskLlmOpenAI_S2S:_sendClientEvent - Error');
+    }
+    return ok;
+  }
+
+  async _sendInitialMessage(ep) {
+    let obj = {type: 'response.create', response: this.response_create};
+    if (!await this._sendClientEvent(ep, obj)) {
+      this.notifyTaskDone();
+    }
+
+    /* send immediate session.update if present */
+    else if (this.session_update) {
+      if (this.parent.isMcpEnabled) {
+        this.logger.debug('TaskLlmOpenAI_S2S:_sendInitialMessage - mcp enabled');
+        const tools = await this.parent.mcpService.getAvailableMcpTools();
+        if (tools && tools.length > 0 && this.session_update) {
+          const convertedTools = tools.map((tool) => ({
+            name: tool.name,
+            type: 'function',
+            description: tool.description,
+            parameters: tool.inputSchema
+          }));
+
+          this.session_update.tools = [
+            ...convertedTools,
+            ...(this.session_update.tools || [])
+          ];
+        }
+      }
+      obj = {type: 'session.update', session: this.session_update};
+      this.logger.debug({obj}, 'TaskLlmOpenAI_S2S:_sendInitialMessage - sending session.update');
+      if (!await this._sendClientEvent(ep, obj)) {
+        this.notifyTaskDone();
+      }
+    }
+  }
+
+  _registerHandlers(ep) {
+    this.addCustomEventListener(ep, LlmEvents_OpenAI.Connect, this._onConnect.bind(this, ep));
+    this.addCustomEventListener(ep, LlmEvents_OpenAI.ConnectFailure, this._onConnectFailure.bind(this, ep));
+    this.addCustomEventListener(ep, LlmEvents_OpenAI.Disconnect, this._onDisconnect.bind(this, ep));
+    this.addCustomEventListener(ep, LlmEvents_OpenAI.ServerEvent, this._onServerEvent.bind(this, ep));
+  }
+
+  _unregisterHandlers() {
+    this.removeCustomEventListeners();
+  }
+
+  _onError(ep, evt) {
+    this.logger.info({evt}, 'TaskLlmOpenAI_S2S:_onError');
+    this.notifyTaskDone();
+  }
+
+  _onConnect(ep) {
+    this.logger.debug('TaskLlmOpenAI_S2S:_onConnect');
+    this._sendInitialMessage(ep);
+  }
+  _onConnectFailure(_ep, evt) {
+    this.logger.info(evt, 'TaskLlmOpenAI_S2S:_onConnectFailure');
+    this.results = {completionReason: 'connection failure'};
+    this.notifyTaskDone();
+  }
+  _onDisconnect(_ep, evt) {
+    this.logger.info(evt, 'TaskLlmOpenAI_S2S:_onConnectFailure');
+    this.results = {completionReason: 'disconnect from remote end'};
+    this.notifyTaskDone();
+  }
+  async _onServerEvent(ep, evt) {
+    let endConversation = false;
+    const type = evt.type;
+    this.logger.info({evt}, 'TaskLlmOpenAI_S2S:_onServerEvent');
+
+    /* check for failures, such as rate limit exceeded, that should terminate the conversation */
+    if (type === 'response.done' && evt.response.status === 'failed') {
+      endConversation = true;
+      this.results = {
+        completionReason: 'server failure',
+        error: evt.response.status_details?.error
+      };
+    }
+
+    /* server errors of some sort */
+    else if (type === 'error') {
+      endConversation = true;
+      this.results = {
+        completionReason: 'server error',
+        error: evt.error
+      };
+    }
+
+    /* tool calls */
+    else if (type === 'response.output_item.done' && evt.item?.type === 'function_call') {
+      this.logger.debug({evt}, 'TaskLlmOpenAI_S2S:_onServerEvent - function_call');
+      const {name, call_id} = evt.item;
+      const args = JSON.parse(evt.item.arguments);
+
+      const mcpTools = this.parent.isMcpEnabled ? await this.parent.mcpService.getAvailableMcpTools() : [];
+      if (mcpTools.some((tool) => tool.name === name)) {
+        this.logger.debug({call_id, name, args}, 'TaskLlmOpenAI_S2S:_onServerEvent - calling mcp tool');
+        try {
+          const res = await this.parent.mcpService.callMcpTool(name, args);
+          this.logger.debug({res}, 'TaskLlmOpenAI_S2S:_onServerEvent - function_call - mcp result');
+          this.processToolOutput(ep, call_id, {
+            type: 'conversation.item.create',
+            item: {
+              type: 'function_call_output',
+              call_id,
+              output: res.content[0]?.text || 'There is no output from the function call',
+            }
+          });
+          return;
+        } catch (err) {
+          this.logger.info({err, evt}, 'TaskLlmOpenAI_S2S - error calling function');
+          this.results = {
+            completionReason: 'client error calling mcp function',
+            error: err
+          };
+          endConversation = true;
+        }
+      }
+      else if (!this.toolHook) {
+        this.logger.warn({evt}, 'TaskLlmOpenAI_S2S:_onServerEvent - no toolHook defined!');
+      }
+      else {
+        try {
+          await this.parent.sendToolHook(call_id, {name, args});
+        } catch (err) {
+          this.logger.info({err, evt}, 'TaskLlmOpenAI - error calling function');
+          this.results = {
+            completionReason: 'client error calling function',
+            error: err
+          };
+          endConversation = true;
+        }
+      }
+    }
+
+    /* check whether we should notify on this event */
+    if (this.includeEvents.length > 0 ? this.includeEvents.includes(type) : !this.excludeEvents.includes(type)) {
+      this.parent.sendEventHook(evt)
+        .catch((err) => this.logger.info({err}, 'TaskLlmOpenAI_S2S:_onServerEvent - error sending event hook'));
+    }
+
+    if (endConversation) {
+      this.logger.info({results: this.results}, 'TaskLlmOpenAI_S2S:_onServerEvent - ending conversation due to error');
+      this.notifyTaskDone();
+    }
+  }
+
+  _populateEvents(events) {
+    if (events.includes('all')) {
+      /* work by excluding specific events */
+      const exclude = events
+        .filter((evt) => evt.startsWith('-'))
+        .map((evt) => evt.slice(1));
+      if (exclude.length === 0) this.includeEvents = openai_server_events;
+      else this.excludeEvents = expandWildcards(exclude);
+    }
+    else {
+      /* work by including specific events */
+      const include = events
+        .filter((evt) => !evt.startsWith('-'));
+      this.includeEvents = expandWildcards(include);
+    }
+
+    this.logger.debug({
+      includeEvents: this.includeEvents,
+      excludeEvents: this.excludeEvents
+    }, 'TaskLlmOpenAI_S2S:_populateEvents');
+  }
+}
+
+module.exports = TaskLlmOpenAI_S2S;

lib/tasks/llm/llms/ultravox_s2s.js

@@ -0,0 +1,351 @@
+const Task = require('../../task');
+const TaskName = 'Llm_Ultravox_s2s';
+const {request} = require('undici');
+const {LlmEvents_Ultravox} = require('../../../utils/constants');
+
+const ultravox_server_events = [
+  'createCall',
+  'pong',
+  'state',
+  'transcript',
+  'conversationText',
+  'clientToolInvocation',
+  'playbackClearBuffer',
+];
+
+const ClientEvent = 'client.event';
+
+const expandWildcards = (events) => {
+  // no-op for deepgram
+  return events;
+};
+
+const SessionDelete = 'session.delete';
+
+class TaskLlmUltravox_S2S extends Task {
+  constructor(logger, opts, parentTask) {
+    super(logger, opts, parentTask);
+    this.parent = parentTask;
+
+    this.vendor = this.parent.vendor;
+    this.model = this.parent.model || 'fixie-ai/ultravox';
+    this.auth = this.parent.auth;
+    this.connectionOptions = this.parent.connectOptions;
+
+    const {apiKey, 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'
+    };
+
+    /**
+     * only one of these will have items,
+     * if includeEvents, then these are the events to include
+     * if excludeEvents, then these are the events to exclude
+     */
+    this.includeEvents = [];
+    this.excludeEvents = [];
+
+    /* default to all events if user did not specify */
+    this._populateEvents(this.data.events || ultravox_server_events);
+
+    this.addCustomEventListener = parentTask.addCustomEventListener.bind(parentTask);
+    this.removeCustomEventListeners = parentTask.removeCustomEventListeners.bind(parentTask);
+  }
+
+  get name() { return TaskName; }
+
+  async _api(ep, args) {
+    const res = await ep.api('uuid_ultravox_s2s', `^^|${args.join('|')}`);
+    if (!res.body?.startsWith('+OK')) {
+      throw new Error(`Error calling uuid_ultravox_s2s: ${JSON.stringify(res.body)}`);
+    }
+  }
+
+  /**
+   * Converts a JSON Schema to the dynamic parameters format used in the Ultravox API
+   * @param {Object} jsonSchema - A JSON Schema object defining parameters
+   * @param {string} locationDefault - Default location value for parameters (default: 'PARAMETER_LOCATION_BODY')
+   * @returns {Array} Array of dynamic parameters objects
+   */
+  transformSchemaToParameters(jsonSchema, locationDefault = 'PARAMETER_LOCATION_BODY') {
+    if (jsonSchema.properties) {
+      const required = jsonSchema.required || [];
+
+      return Object.entries(jsonSchema.properties).map(([name]) => {
+        return {
+          name,
+          location: locationDefault,
+          required: required.includes(name)
+        };
+      });
+    }
+
+    return [];
+  }
+
+  async createCall() {
+    const mcpTools = this.parent.isMcpEnabled ? await this.parent.mcpService.getAvailableMcpTools() : [];
+    if (mcpTools && mcpTools.length > 0) {
+      const convertedTools = mcpTools.map((tool) => {
+        return {
+          temporaryTool: {
+            modelToolName: tool.name,
+            description: tool.description,
+            dynamicParameters: this.transformSchemaToParameters(tool.inputSchema),
+            // use client tool that ultravox call tool via freeswitch module.
+            client: {}
+          }
+        };
+      }
+      );
+      // merge with any existing tools
+      this.llmOptions.selectedTools = [
+        ...convertedTools,
+        ...(this.llmOptions.selectedTools || [])
+      ];
+    }
+
+    const payload = {
+      ...this.llmOptions,
+      ...(!this.agentId && {
+        model: this.model,
+      }),
+      medium: {
+        ...(this.llmOptions.medium || {}),
+        serverWebSocket: {
+          inputSampleRate: 8000,
+          outputSampleRate: 8000,
+        }
+      }
+    };
+    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',
+        'X-API-Key': this.apiKey
+      },
+      body: JSON.stringify(payload)
+    });
+    const data = await body.json();
+    if (statusCode !== 201 || !data?.joinUrl) {
+      this.logger.info({statusCode, data}, 'Ultravox Error registering call');
+      throw new Error(`Ultravox Error registering call:${statusCode} - ${data.detail}`);
+    }
+    this.logger.debug({joinUrl: data.joinUrl}, 'Ultravox Call registered');
+    return data;
+  }
+
+  _unregisterHandlers() {
+    this.removeCustomEventListeners();
+  }
+
+  _registerHandlers(ep) {
+    this.addCustomEventListener(ep, LlmEvents_Ultravox.Connect, this._onConnect.bind(this, ep));
+    this.addCustomEventListener(ep, LlmEvents_Ultravox.ConnectFailure, this._onConnectFailure.bind(this, ep));
+    this.addCustomEventListener(ep, LlmEvents_Ultravox.Disconnect, this._onDisconnect.bind(this, ep));
+    this.addCustomEventListener(ep, LlmEvents_Ultravox.ServerEvent, this._onServerEvent.bind(this, ep));
+  }
+
+  async _startListening(cs, ep) {
+    this._registerHandlers(ep);
+
+    try {
+      const data = await this.createCall();
+      const {joinUrl} = data;
+      // split the joinUrl into host and path
+      const {host, pathname, search} = new URL(joinUrl);
+      const args = [ep.uuid, 'session.create', host, pathname + search];
+      await this._api(ep, args);
+      // Notify the application that the session has been created with detail information
+      this._sendLlmEvent('createCall', {
+        type: 'createCall',
+        ...data
+      });
+    } catch (err) {
+      this.logger.info({err}, 'TaskLlmUltraVox_S2S:_startListening - Error sending createCall');
+      this.results = {completionReason: `connection failure - ${err}`};
+      this.notifyTaskDone();
+    }
+  }
+
+  async exec(cs, {ep}) {
+    await super.exec(cs);
+
+    await this._startListening(cs, ep);
+
+    await this.awaitTaskDone();
+
+    /* note: the parent llm verb started the span, which is why this is necessary */
+    await this.parent.performAction(this.results);
+
+    this._unregisterHandlers();
+  }
+
+  async kill(cs) {
+    super.kill(cs);
+
+    this._api(cs.ep, [cs.ep.uuid, SessionDelete])
+      .catch((err) => this.logger.info({err}, 'TaskLlmUltravox_S2S:kill - error deleting session'));
+
+    this.notifyTaskDone();
+  }
+
+  _onConnect(ep) {
+    this.logger.info('TaskLlmUltravox_S2S:_onConnect');
+  }
+  _onConnectFailure(_ep, evt) {
+    this.logger.info(evt, 'TaskLlmUltravox_S2S:_onConnectFailure');
+    this.results = {completionReason: 'connection failure'};
+    this.notifyTaskDone();
+  }
+  _onDisconnect(_ep, evt) {
+    this.logger.info(evt, 'TaskLlmUltravox_S2S:_onConnectFailure');
+    this.results = {completionReason: 'disconnect from remote end'};
+    this.notifyTaskDone();
+  }
+
+  async _onServerEvent(_ep, evt) {
+    let endConversation = false;
+    const type = evt.type;
+    //this.logger.debug({evt}, 'TaskLlmUltravox_S2S:_onServerEvent');
+
+    /* server errors of some sort */
+    if (type === 'error') {
+      endConversation = true;
+      this.results = {
+        completionReason: 'server error',
+        error: evt.error
+      };
+    }
+
+    /* tool calls */
+    else if (type === 'client_tool_invocation') {
+      this.logger.debug({evt}, 'TaskLlmUltravox_S2S:_onServerEvent - function_call');
+      const {toolName: name, invocationId: call_id, parameters: args} = evt;
+
+      const mcpTools = this.parent.isMcpEnabled ? await this.parent.mcpService.getAvailableMcpTools() : [];
+      if (mcpTools.some((tool) => tool.name === name)) {
+        this.logger.debug({
+          name,
+          input: args
+        }, 'TaskLlmUltravox_S2S:_onServerEvent - function_call - mcp tool');
+        try {
+          const res = await this.parent.mcpService.callMcpTool(name, args);
+          this.logger.debug({res}, 'TaskLlmUltravox_S2S:_onServerEvent - function_call - mcp result');
+          this.processToolOutput(_ep, call_id, {
+            type: 'client_tool_result',
+            invocation_id: call_id,
+            result: res.content
+          });
+          return;
+        } catch (err) {
+          this.logger.info({err, evt}, 'TaskLlmUltravox_S2S - error calling mcp tool');
+          this.results = {
+            completionReason: 'client error calling mcp function',
+            error: err
+          };
+          endConversation = true;
+        }
+      } else if (!this.toolHook) {
+        this.logger.info({evt}, 'TaskLlmUltravox_S2S:_onServerEvent - no toolHook defined!');
+      }
+      else {
+        try {
+          await this.parent.sendToolHook(call_id, {name, args});
+        } catch (err) {
+          this.logger.info({err, evt}, 'TaskLlmUltravox_S2S - error calling function');
+          this.results = {
+            completionReason: 'client error calling function',
+            error: err
+          };
+          endConversation = true;
+        }
+      }
+    }
+
+    this._sendLlmEvent(type, evt);
+
+    if (endConversation) {
+      this.logger.info({results: this.results},
+        'TaskLlmUltravox_S2S:_onServerEvent - ending conversation due to error');
+      this.notifyTaskDone();
+    }
+  }
+
+  _sendLlmEvent(type, evt) {
+    /* check whether we should notify on this event */
+    if (this.includeEvents.length > 0 ? this.includeEvents.includes(type) : !this.excludeEvents.includes(type)) {
+      this.parent.sendEventHook(evt)
+        .catch((err) => this.logger.info({err}, 'TaskLlmUltravox_S2S:_onServerEvent - error sending event hook'));
+    }
+  }
+
+  async processLlmUpdate(ep, data, _callSid) {
+    try {
+      this.logger.debug({data, _callSid}, 'TaskLlmUltravox_S2S:processLlmUpdate');
+
+      if (!data.type || ![
+        'input_text_message'
+      ].includes(data.type)) {
+        this.logger.info({data},
+          'TaskLlmUltravox_S2S:processLlmUpdate - invalid mid-call request, only input_text_message supported');
+      }
+      else {
+        await this._api(ep, [ep.uuid, ClientEvent, JSON.stringify(data)]);
+      }
+    } catch (err) {
+      this.logger.info({err, data}, 'TaskLlmUltravox_S2S:processLlmUpdate - Error processing LLM update');
+    }
+  }
+
+  async processToolOutput(ep, tool_call_id, data) {
+    try {
+      this.logger.debug({tool_call_id, data}, 'TaskLlmUltravox_S2S:processToolOutput');
+
+      if (!data.type || data.type !== 'client_tool_result') {
+        this.logger.info({data},
+          'TaskLlmUltravox_S2S:processToolOutput - invalid tool output, must be client_tool_result');
+      }
+      else {
+        await this._api(ep, [ep.uuid, ClientEvent, JSON.stringify(data)]);
+      }
+    } catch (err) {
+      this.logger.info({err, data}, 'TaskLlmUltravox_S2S:processToolOutput - Error processing tool output');
+    }
+  }
+
+  _populateEvents(events) {
+    if (events.includes('all')) {
+      /* work by excluding specific events */
+      const exclude = events
+        .filter((evt) => evt.startsWith('-'))
+        .map((evt) => evt.slice(1));
+      if (exclude.length === 0) this.includeEvents = ultravox_server_events;
+      else this.excludeEvents = expandWildcards(exclude);
+    }
+    else {
+      /* work by including specific events */
+      const include = events
+        .filter((evt) => !evt.startsWith('-'));
+      this.includeEvents = expandWildcards(include);
+    }
+
+    this.logger.debug({
+      includeEvents: this.includeEvents,
+      excludeEvents: this.excludeEvents
+    }, 'TaskLlmUltravox_S2S:_populateEvents');
+  }
+}
+
+module.exports = TaskLlmUltravox_S2S;

lib/tasks/llm/llms/voice_agent_s2s.js

@@ -0,0 +1,352 @@
+const Task = require('../../task');
+const TaskName = 'Llm_VoiceAgent_s2s';
+const {LlmEvents_VoiceAgent} = require('../../../utils/constants');
+const ClientEvent = 'client.event';
+const SessionDelete = 'session.delete';
+
+const va_server_events = [
+  'Error',
+  'Welcome',
+  'SettingsApplied',
+  'ConversationText',
+  'UserStartedSpeaking',
+  'EndOfThought',
+  'AgentThinking',
+  'FunctionCallRequest',
+  'FunctionCalling',
+  'AgentStartedSpeaking',
+  'AgentAudioDone',
+];
+
+const expandWildcards = (events) => {
+  // no-op for deepgram
+  return events;
+};
+
+class TaskLlmVoiceAgent_S2S extends Task {
+  constructor(logger, opts, parentTask) {
+    super(logger, opts, parentTask);
+    this.parent = parentTask;
+
+    this.vendor = this.parent.vendor;
+    this.model = this.parent.model || 'voice-agent';
+    this.auth = this.parent.auth;
+    this.connectionOptions = this.parent.connectOptions;
+
+    const {apiKey} = this.auth || {};
+    if (!apiKey) throw new Error('auth.apiKey is required for VoiceAgent S2S');
+
+    this.apiKey = apiKey;
+    this.authType = 'bearer';
+    this.actionHook = this.data.actionHook;
+    this.eventHook = this.data.eventHook;
+    this.toolHook = this.data.toolHook;
+    const {Settings} = this.data.llmOptions;
+
+    if (typeof Settings !== 'object') {
+      throw new Error('llmOptions with an initial Settings is required for VoiceAgent S2S');
+    }
+
+    // eslint-disable-next-line no-unused-vars
+    const {audio, ...rest} = Settings;
+    const cfg = this.Settings = rest;
+
+    if (!cfg.agent) throw new Error('llmOptions.Settings.agent is required for VoiceAgent S2S');
+    if (!cfg.agent.think) {
+      throw new Error('llmOptions.Settings.agent.think is required for VoiceAgent S2S');
+    }
+    if (!cfg.agent.think.provider?.model) {
+      throw new Error('llmOptions.Settings.agent.think.provider.model is required for VoiceAgent S2S');
+    }
+    if (!cfg.agent.think.provider?.type) {
+      throw new Error('llmOptions.Settings.agent.think.provider.type is required for VoiceAgent S2S');
+    }
+
+    this.results = {
+      completionReason: 'normal conversation end'
+    };
+
+    /**
+     * only one of these will have items,
+     * if includeEvents, then these are the events to include
+     * if excludeEvents, then these are the events to exclude
+     */
+    this.includeEvents = [];
+    this.excludeEvents = [];
+
+    /* default to all events if user did not specify */
+    this._populateEvents(this.data.events || va_server_events);
+
+    this.addCustomEventListener = parentTask.addCustomEventListener.bind(parentTask);
+    this.removeCustomEventListeners = parentTask.removeCustomEventListeners.bind(parentTask);
+  }
+
+  get name() { return TaskName; }
+
+  get host() {
+    const {host} = this.connectionOptions || {};
+    return host || 'agent.deepgram.com';
+  }
+
+  get path() {
+    const {path} = this.connectionOptions || {};
+    if (path) return path;
+
+    return '/v1/agent/converse';
+  }
+
+  async _api(ep, args) {
+    const res = await ep.api('uuid_voice_agent_s2s', `^^|${args.join('|')}`);
+    if (!res.body?.startsWith('+OK')) {
+      throw new Error(`Error calling uuid_voice_agent_s2s: ${JSON.stringify(res.body)}`);
+    }
+  }
+
+  async exec(cs, {ep}) {
+    await super.exec(cs);
+
+    await this._startListening(cs, ep);
+
+    await this.awaitTaskDone();
+
+    /* note: the parent llm verb started the span, which is why this is necessary */
+    await this.parent.performAction(this.results);
+
+    this._unregisterHandlers();
+  }
+
+  async kill(cs) {
+    super.kill(cs);
+
+    this._api(cs.ep, [cs.ep.uuid, SessionDelete])
+      .catch((err) => this.logger.info({err}, 'TaskLlmVoiceAgent_S2S:kill - error deleting session'));
+
+    this.notifyTaskDone();
+  }
+
+  /**
+   * Send function call response to the VoiceAgent server
+   */
+  async processToolOutput(ep, tool_call_id, data) {
+    try {
+      const {data:response} = data;
+      this.logger.debug({tool_call_id, response}, 'TaskLlmVoiceAgent_S2S:processToolOutput');
+
+      if (!response.type || response.type !== 'FunctionCallResponse') {
+        this.logger.info({response},
+          'TaskLlmVoiceAgent_S2S:processToolOutput - invalid tool output, must be FunctionCallResponse');
+      }
+      else {
+        await this._api(ep, [ep.uuid, ClientEvent, JSON.stringify(response)]);
+      }
+    } catch (err) {
+      this.logger.info({err}, 'TaskLlmVoiceAgent_S2S:processToolOutput');
+    }
+  }
+
+  /**
+   * Send a session.update to the VoiceAgent server
+   * Note: creating and deleting conversation items also supported as well as interrupting the assistant
+   */
+  async processLlmUpdate(ep, data, _callSid) {
+    try {
+      this.logger.debug({data, _callSid}, 'TaskLlmVoiceAgent_S2S:processLlmUpdate');
+
+      if (!data.type || ![
+        'UpdateInstructions',
+        'UpdateSpeak',
+        'InjectAgentMessage',
+      ].includes(data.type)) {
+        this.logger.info({data}, 'TaskLlmVoiceAgent_S2S:processLlmUpdate - invalid mid-call request');
+      }
+      else {
+        await this._api(ep, [ep.uuid, ClientEvent, JSON.stringify(data)]);
+      }
+    } catch (err) {
+      this.logger.info({err}, 'TaskLlmVoiceAgent_S2S:processLlmUpdate');
+    }
+  }
+
+  async _startListening(cs, ep) {
+    this._registerHandlers(ep);
+
+    try {
+      const args = [ep.uuid, 'session.create', this.host, this.path, this.authType, this.apiKey];
+      await this._api(ep, args);
+    } catch (err) {
+      this.logger.error({err}, `TaskLlmVoiceAgent_S2S:_startListening: ${JSON.stringify(err)}`);
+      this.notifyTaskDone();
+    }
+  }
+
+  async _sendClientEvent(ep, obj) {
+    let ok = true;
+    this.logger.debug({obj}, 'TaskLlmVoiceAgent_S2S:_sendClientEvent');
+    try {
+      const args = [ep.uuid, ClientEvent, JSON.stringify(obj)];
+      await this._api(ep, args);
+    } catch (err) {
+      ok = false;
+      this.logger.error({err}, 'TaskLlmVoiceAgent_S2S:_sendClientEvent - Error');
+    }
+    return ok;
+  }
+
+  async _sendInitialMessage(ep) {
+    const mcpTools = this.parent.isMcpEnabled ? await this.parent.mcpService.getAvailableMcpTools() : [];
+    if (mcpTools && mcpTools.length > 0 && this.Settings.agent?.think) {
+      const convertedTools = mcpTools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.inputSchema
+      }));
+
+      this.Settings.agent.think.functions = [
+        ...convertedTools,
+        ...(this.Settings.agent.think?.functions || [])
+      ];
+    }
+    if (!await this._sendClientEvent(ep, this.Settings)) {
+      this.notifyTaskDone();
+    }
+  }
+
+  _registerHandlers(ep) {
+    this.addCustomEventListener(ep, LlmEvents_VoiceAgent.Connect, this._onConnect.bind(this, ep));
+    this.addCustomEventListener(ep, LlmEvents_VoiceAgent.ConnectFailure, this._onConnectFailure.bind(this, ep));
+    this.addCustomEventListener(ep, LlmEvents_VoiceAgent.Disconnect, this._onDisconnect.bind(this, ep));
+    this.addCustomEventListener(ep, LlmEvents_VoiceAgent.ServerEvent, this._onServerEvent.bind(this, ep));
+  }
+
+  _unregisterHandlers() {
+    this.removeCustomEventListeners();
+  }
+
+  _onError(_ep, evt) {
+    this.logger.info({evt}, 'TaskLlmVoiceAgent_S2S:_onError');
+    this.notifyTaskDone();
+  }
+
+  _onConnect(ep) {
+    this.logger.debug('TaskLlmVoiceAgent_S2S:_onConnect');
+    this._sendInitialMessage(ep);
+  }
+  _onConnectFailure(_ep, evt) {
+    this.logger.info(evt, 'TaskLlmVoiceAgent_S2S:_onConnectFailure');
+    this.results = {completionReason: 'connection failure'};
+    this.notifyTaskDone();
+  }
+  _onDisconnect(_ep, evt) {
+    this.logger.info(evt, 'TaskLlmVoiceAgent_S2S:_onConnectFailure');
+    this.results = {completionReason: 'disconnect from remote end'};
+    this.notifyTaskDone();
+  }
+  async _onServerEvent(_ep, evt) {
+    let endConversation = false;
+    const type = evt.type;
+    this.logger.info({evt}, 'TaskLlmVoiceAgent_S2S:_onServerEvent');
+
+    /* check for failures, such as rate limit exceeded, that should terminate the conversation */
+    if (type === 'response.done' && evt.response.status === 'failed') {
+      endConversation = true;
+      this.results = {
+        completionReason: 'server failure',
+        error: evt.response.status_details?.error
+      };
+    }
+
+    /* server errors of some sort */
+    else if (type === 'error') {
+      endConversation = true;
+      this.results = {
+        completionReason: 'server error',
+        error: evt.error
+      };
+    }
+
+    /* tool calls */
+    else if (type === 'FunctionCallRequest') {
+      this.logger.debug({evt}, 'TaskLlmVoiceAgent_S2S:_onServerEvent - function_call');
+
+      const mcpTools = this.parent.isMcpEnabled ? await this.parent.mcpService.getAvailableMcpTools() : [];
+      if (!this.toolHook && mcpTools.length === 0) {
+        this.logger.warn({evt}, 'TaskLlmVoiceAgent_S2S:_onServerEvent - no toolHook defined!');
+      } else {
+        const {functions} = evt;
+        const handledFunctions = [];
+
+        try {
+          if (mcpTools && mcpTools.length > 0) {
+            for (const func of functions) {
+              const {name, arguments: args, id} = func;
+              const tool = mcpTools.find((tool) => tool.name === name);
+              if (tool) {
+                handledFunctions.push(name);
+                const response = await this.parent.mcpService.callMcpTool(name, JSON.parse(args));
+                this.logger.debug({response}, 'TaskLlmVoiceAgent_S2S:_onServerEvent - function_call - mcp result');
+                this.processToolOutput(_ep, id, {
+                  data: {
+                    type: 'FunctionCallResponse',
+                    id,
+                    name,
+                    content: response.length > 0 ? response[0].text : 'There is no output from the function call'
+                  }
+                });
+              }
+            }
+          }
+
+          for (const func of functions) {
+            const {name, arguments: args, id} = func;
+            if (!handledFunctions.includes(name)) {
+              await this.parent.sendToolHook(id, {name, args: JSON.parse(args)});
+            }
+          }
+        } catch (err) {
+          this.logger.info({err, evt}, 'TaskLlmVoiceAgent_S2S:_onServerEvent - error calling function');
+          this.results = {
+            completionReason: 'client error calling function',
+            error: err
+          };
+          endConversation = true;
+        }
+      }
+    }
+
+    /* check whether we should notify on this event */
+    if (this.includeEvents.length > 0 ? this.includeEvents.includes(type) : !this.excludeEvents.includes(type)) {
+      this.parent.sendEventHook(evt)
+        .catch((err) => this.logger.info({err}, 'TaskLlmVoiceAgent_S2S:_onServerEvent - error sending event hook'));
+    }
+
+    if (endConversation) {
+      this.logger.info({results: this.results},
+        'TaskLlmVoiceAgent_S2S:_onServerEvent - ending conversation due to error');
+      this.notifyTaskDone();
+    }
+  }
+
+  _populateEvents(events) {
+    if (events.includes('all')) {
+      /* work by excluding specific events */
+      const exclude = events
+        .filter((evt) => evt.startsWith('-'))
+        .map((evt) => evt.slice(1));
+      if (exclude.length === 0) this.includeEvents = va_server_events;
+      else this.excludeEvents = expandWildcards(exclude);
+    }
+    else {
+      /* work by including specific events */
+      const include = events
+        .filter((evt) => !evt.startsWith('-'));
+      this.includeEvents = expandWildcards(include);
+    }
+
+    this.logger.debug({
+      includeEvents: this.includeEvents,
+      excludeEvents: this.excludeEvents
+    }, 'TaskLlmVoiceAgent_S2S:_populateEvents');
+  }
+}
+
+module.exports = TaskLlmVoiceAgent_S2S;

lib/tasks/make_task.js

@@ -1,4 +1,4 @@
-const Task = require('./task');
+const { validateVerb } = require('@jambonz/verb-specifications');
 const {TaskName} = require('../utils/constants');
 const errBadInstruction = new Error('malformed jambonz application payload');
 
@@ -12,8 +12,11 @@ function makeTask(logger, obj, parent) {
   if (typeof data !== 'object') {
     throw errBadInstruction;
   }
-  Task.validate(name, data);
+  validateVerb(name, data, logger);
   switch (name) {
+    case TaskName.Answer:
+      const TaskAnswer = require('./answer');
+      return new TaskAnswer(logger, data, parent);
     case TaskName.SipDecline:
       const TaskSipDecline = require('./sip_decline');
       return new TaskSipDecline(logger, data, parent);
@@ -41,6 +44,9 @@ function makeTask(logger, obj, parent) {
     case TaskName.Dtmf:
       const TaskDtmf = require('./dtmf');
       return new TaskDtmf(logger, data, parent);
+    case TaskName.Dub:
+      const TaskDub = require('./dub');
+      return new TaskDub(logger, data, parent);
     case TaskName.Enqueue:
       const TaskEnqueue = require('./enqueue');
       return new TaskEnqueue(logger, data, parent);
@@ -56,6 +62,9 @@ function makeTask(logger, obj, parent) {
     case TaskName.Message:
       const TaskMessage = require('./message');
       return new TaskMessage(logger, data, parent);
+    case TaskName.Llm:
+      const TaskLlm = require('./llm');
+      return new TaskLlm(logger, data, parent);
     case TaskName.Rasa:
       const TaskRasa = require('./rasa');
       return new TaskRasa(logger, data, parent);
@@ -75,6 +84,7 @@ function makeTask(logger, obj, parent) {
       const TaskTranscribe = require('./transcribe');
       return new TaskTranscribe(logger, data, parent);
     case TaskName.Listen:
+    case TaskName.Stream:
       const TaskListen = require('./listen');
       return new TaskListen(logger, data, parent);
     case TaskName.Redirect:
@@ -86,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

lib/tasks/message.js

@@ -1,15 +1,15 @@
 const Task = require('./task');
 const {TaskName, TaskPreconditions} = require('../utils/constants');
 const bent = require('bent');
-const { v4: uuidv4 } = require('uuid');
-
+const crypto = require('crypto');
+const {K8S} = require('../config');
 class TaskMessage extends Task {
   constructor(logger, opts) {
     super(logger, opts);
     this.preconditions = TaskPreconditions.None;
 
     this.payload = {
-      message_sid: this.data.message_sid || uuidv4(),
+      message_sid: this.data.message_sid || crypto.randomUUID(),
       carrier: this.data.carrier,
       to: this.data.to,
       from: this.data.from,
@@ -42,7 +42,7 @@ class TaskMessage extends Task {
       }
       if (gw) {
         this.logger.info({gw, accountSid}, 'Message:exec - using smpp to send message');
-        url = process.env.K8S ? 'http://smpp' : getSmpp();
+        url = K8S ? 'http://smpp' : getSmpp();
         relativeUrl = '/sms';
         payload = {
           ...payload,

lib/tasks/play.js

@@ -1,12 +1,14 @@
 const Task = require('./task');
 const {TaskName, TaskPreconditions} = require('../utils/constants');
-
+const { PlayFileNotFoundError } = require('../utils/error');
 class TaskPlay extends Task {
   constructor(logger, opts) {
     super(logger, opts);
     this.preconditions = TaskPreconditions.Endpoint;
 
-    this.url = this.data.url;
+    this.url = this.data.url.includes('?')
+      ? this.data.url.split('?')[0] + '?' + this.data.url.split('?')[1].replaceAll('.', '%2E')
+      : this.data.url;
     this.seekOffset = this.data.seekOffset || -1;
     this.timeoutSecs = this.data.timeoutSecs || -1;
     this.loop = this.data.loop || 1;
@@ -22,8 +24,40 @@ class TaskPlay extends Task {
   async exec(cs, {ep}) {
     await super.exec(cs);
     this.ep = ep;
+    let timeout;
+    let playbackSeconds = 0;
+    let playbackMilliseconds = 0;
+    let completed = !(this.timeoutSecs > 0 || this.loop);
+    cs.playingAudio = true;
+    if (this.timeoutSecs > 0) {
+      timeout = setTimeout(async() => {
+        completed = true;
+        try {
+          await this.kill(cs);
+        } catch (err) {
+          this.logger.info(err, 'Error killing audio on timeoutSecs');
+        }
+      }, this.timeoutSecs * 1000);
+    }
     try {
+      this.notifyStatus({event: 'start-playback'});
       while (!this.killed && (this.loop === 'forever' || this.loop--) && this.ep.connected) {
+        /* Listen for playback-start event and set up a one-time listener for uuid_break
+         * that will kill the audio playback if the taskIds match. This ensures that
+         * we only kill the currently playing audio and not audio from other tasks.
+         * As we are using stickyEventEmitter, even if the event is emitted before the listener is registered,
+         * the listener will receive the most recent event.
+         */
+        ep.once('playback-start', (evt) => {
+          this.logger.debug({evt}, 'Play got playback-start');
+          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'));
+              this.notifyStatus({event: 'kill-playback'});
+            }
+          });
+        });
         if (cs.isInConference) {
           const {memberId, confName, confUuid} = cs;
           if (Array.isArray(this.url)) {
@@ -34,29 +68,52 @@ class TaskPlay extends Task {
             await this.playToConfMember(this.ep, memberId, confName, confUuid, this.url);
           }
         } else {
-          const file = (this.timeoutSecs >= 0 || this.seekOffset >= 0) ?
-            {file: this.url, seekOffset: this.seekOffset, timeoutSecs: this.timeoutSecs} : this.url;
+          let file = this.url;
+          if (this.seekOffset >= 0) {
+            file = {file: this.url, seekOffset: this.seekOffset};
+            this.seekOffset = -1;
+          }
           const result = await ep.play(file);
-          await this.performAction(Object.assign(result, {reason: 'playCompleted'}),
-            !(this.parentTask || cs.isConfirmCallSession));
+          playbackSeconds += parseInt(result.playbackSeconds);
+          playbackMilliseconds += parseInt(result.playbackMilliseconds);
+          if (this.killed || !this.loop || completed) {
+            if (timeout) clearTimeout(timeout);
+            await this.performAction(
+              Object.assign(result, {reason: 'playCompleted', playbackSeconds, playbackMilliseconds}),
+              !(this.parentTask || cs.isConfirmCallSession));
+          }
         }
       }
     } catch (err) {
-      this.logger.info(err, `TaskPlay:exec - error playing ${this.url}`);
+      this.logger.info(`TaskPlay:exec - error playing ${this.url}: ${err.message}`);
+      this.playComplete = true;
+      if (err.message === 'File Not Found') {
+        const {writeAlerts, AlertType} = cs.srf.locals;
+        await this.performAction({status: 'fail', reason: 'playFailed'}, !(this.parentTask || cs.isConfirmCallSession));
+        this.emit('playDone');
+        writeAlerts({
+          account_sid: cs.accountSid,
+          alert_type: AlertType.PLAY_FILENOTFOUND,
+          url: this.url,
+          target_sid: cs.callSid
+        });
+        throw new PlayFileNotFoundError(this.url);
+      }
     }
     this.emit('playDone');
   }
 
   async kill(cs) {
     super.kill(cs);
-    if (this.ep.connected && !this.playComplete) {
+    if (this.ep?.connected && !this.playComplete) {
       this.logger.debug('TaskPlay:kill - killing audio');
       if (cs.isInConference) {
         const {memberId, confName} = cs;
         this.killPlayToConfMember(this.ep, memberId, confName);
       }
       else {
-        await this.ep.api('uuid_break', this.ep.uuid).catch((err) => this.logger.info(err, 'Error killing audio'));
+        //this.ep.api('uuid_break', this.ep.uuid).catch((err) => this.logger.info(err, 'Error killing audio'));
+        cs.stickyEventEmitter.emit('uuid_break', this);
       }
     }
   }

lib/tasks/redirect.js

@@ -1,5 +1,8 @@
 const Task = require('./task');
 const {TaskName} = require('../utils/constants');
+const WsRequestor = require('../utils/ws-requestor');
+const URL = require('url');
+const HttpRequestor = require('../utils/http-requestor');
 
 /**
  * Redirects to a new application
@@ -13,6 +16,37 @@ class TaskRedirect extends Task {
 
   async exec(cs) {
     await super.exec(cs);
+
+    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 {
+          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, `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}`);
+          }
+        }
+      }
+    }
     await this.performAction();
   }
 }

lib/tasks/rest_dial.js

@@ -1,7 +1,7 @@
 const Task = require('./task');
 const {TaskName} = require('../utils/constants');
 const makeTask = require('./make_task');
-const normalizeJambones = require('../utils/normalize-jambones');
+const { normalizeJambones } = require('@jambonz/verb-specifications');
 
 /**
  * Manages an outdial made via REST API
@@ -11,10 +11,14 @@ class TaskRestDial extends Task {
     super(logger, opts);
 
     this.from = this.data.from;
+    this.callerName = this.data.callerName;
+    this.timeLimit = this.data.timeLimit;
     this.fromHost = this.data.fromHost;
     this.to = this.data.to;
     this.call_hook = this.data.call_hook;
     this.timeout = this.data.timeout || 60;
+    this.sipRequestWithinDialogHook = this.data.sipRequestWithinDialogHook;
+    this.referHook = this.data.referHook;
 
     this.on('connect', this._onConnect.bind(this));
     this.on('callStatus', this._onCallStatus.bind(this));
@@ -22,50 +26,87 @@ class TaskRestDial extends Task {
 
   get name() { return TaskName.RestDial; }
 
+  set appJson(app_json) {
+    this.app_json = app_json;
+  }
+
   /**
    * INVITE has just been sent at this point
   */
   async exec(cs) {
     await super.exec(cs);
-    this.req = cs.req;
+    this.cs = cs;
+    this.canCancel = true;
+
+    if (this.data.amd) {
+      this.startAmd = cs.startAmd;
+      this.on('amd', this._onAmdEvent.bind(this, cs));
+    }
+    this.stopAmd = cs.stopAmd;
 
     this._setCallTimer();
     await this.awaitTaskDone();
   }
 
+  turnOffAmd() {
+    if (this.callSession.ep && this.callSession.ep.amd) this.stopAmd(this.callSession.ep, this);
+  }
+
   kill(cs) {
     super.kill(cs);
     this._clearCallTimer();
-    if (this.req) {
-      this.req.cancel();
-      this.req = null;
+    if (this.canCancel) {
+      this.canCancel = false;
+      cs?.req?.cancel();
     }
     this.notifyTaskDone();
   }
 
   async _onConnect(dlg) {
-    this.req = null;
+    this.canCancel = false;
     const cs = this.callSession;
     cs.setDialog(dlg);
-
+    cs.referHook = this.referHook;
+    if (this.timeLimit) {
+      cs.startMaxCallDurationTimer(this.timeLimit);
+    }
+    this.logger.debug('TaskRestDial:_onConnect - call connected');
+    if (this.sipRequestWithinDialogHook) this._initSipRequestWithinDialogHandler(cs, dlg);
     try {
       const b3 = this.getTracingPropagation();
       const httpHeaders = b3 && {b3};
       const params = {
-        ...cs.callInfo,
+        ...(cs.callInfo.toJSON()),
+        ...(this.env_vars && {env_vars: this.env_vars}),
         defaults: {
           synthesizer: {
             vendor: cs.speechSynthesisVendor,
             language: cs.speechSynthesisLanguage,
-            voice: cs.speechSynthesisVoice
+            voice: cs.speechSynthesisVoice,
+            label: cs.speechSynthesisLabel,
           },
           recognizer: {
             vendor:  cs.speechRecognizerVendor,
-            language: cs.speechRecognizerLanguage
+            language: cs.speechRecognizerLanguage,
+            label: cs.speechRecognizerLabel,
           }
         }
       };
-      const tasks = await cs.requestor.request('session:new', this.call_hook, params, httpHeaders);
+      if (this.startAmd) {
+        try {
+          this.startAmd(this.callSession, this.callSession.ep, this, this.data.amd);
+        } catch (err) {
+          this.logger.info({err}, 'Rest:dial:Call established - Error calling startAmd');
+        }
+      }
+      let tasks;
+      if (this.app_json) {
+        this.logger.debug('TaskRestDial: using app_json from task data');
+        tasks = JSON.parse(this.app_json);
+      } else {
+        this.logger.debug({call_hook: this.call_hook}, 'TaskRestDial: retrieving application');
+        tasks = await cs.requestor.request('session:new', this.call_hook, params, httpHeaders);
+      }
       if (tasks && Array.isArray(tasks)) {
         this.logger.debug({tasks: tasks}, `TaskRestDial: replacing application with ${tasks.length} tasks`);
         cs.replaceApplication(normalizeJambones(this.logger, tasks).map((tdata) => makeTask(this.logger, tdata)));
@@ -79,7 +120,7 @@ class TaskRestDial extends Task {
   _onCallStatus(status) {
     this.logger.debug(`CallStatus: ${status}`);
     if (status >= 200) {
-      this.req = null;
+      this.canCancel = false;
       this._clearCallTimer();
       if (status !== 200) this.notifyTaskDone();
     }
@@ -97,7 +138,29 @@ class TaskRestDial extends Task {
   _onCallTimeout() {
     this.logger.debug('TaskRestDial: timeout expired without answer, killing task');
     this.timer = null;
-    this.kill();
+    if (this.canCancel) {
+      this.canCancel = false;
+      this.cs?.req?.cancel();
+    }
+  }
+
+  _onAmdEvent(cs, evt) {
+    this.logger.info({evt}, 'Rest:dial:_onAmdEvent');
+    const {actionHook} = this.data.amd;
+    this.performHook(cs, actionHook, evt)
+      .catch((err) => {
+        this.logger.error({err}, 'Rest:dial:_onAmdEvent - error calling actionHook');
+      });
+  }
+
+  _initSipRequestWithinDialogHandler(cs, dlg) {
+    cs.sipRequestWithinDialogHook = this.sipRequestWithinDialogHook;
+    dlg.on('info', this._onRequestWithinDialog.bind(this, cs));
+    dlg.on('message', this._onRequestWithinDialog.bind(this, cs));
+  }
+
+  async _onRequestWithinDialog(cs, req, res) {
+    cs._onRequestWithinDialog(req, res);
   }
 }
 

lib/tasks/say.js

@@ -1,240 +1,544 @@
-const Task = require('./task');
+const assert = require('assert');
+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;
-  if (text.length <= chunkSize) return [text];
-
-  const result = [];
+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>');
-  let startPos = 0;
-  let charPos = isSSML ? 7 : 0;  // skip <speak>
-  let tag;
-  //logger.debug({isSSML}, `breakLengthyTextIfNeeded: handling text of length ${text.length}`);
-  while (startPos + charPos < text.length) {
-    if (isSSML && !tag && text[startPos + charPos] === '<') {
-      const tagStartPos = ++charPos;
-      while (startPos + charPos < text.length) {
-        if (text[startPos + charPos] === '>') {
-          if (text[startPos + charPos - 1] === '\\') tag = null;
-          else if (!tag) tag = text.substring(startPos + tagStartPos, startPos + charPos - 1);
-          break;
-        }
-        if (!tag) {
-          const c = text[startPos + charPos];
-          if (c === ' ') {
-            tag = text.substring(startPos + tagStartPos, startPos + charPos);
-            //logger.debug(`breakLengthyTextIfNeeded: enter tag ${tag} (space)`);
-            break;
-          }
-        }
-        charPos++;
-      }
-      if (tag) {
-        //search for end of tag
-        //logger.debug(`breakLengthyTextIfNeeded: searching forward for </${tag}>`);
-        const e1 = text.indexOf(`</${tag}>`, startPos + charPos);
-        const e2 = text.indexOf('/>', startPos + charPos);
-        const tagEndPos = e1 === -1 ? e2 : e2 === -1 ? e1 : Math.min(e1, e2);
-        if (tagEndPos === -1) {
-          //logger.debug(`breakLengthyTextIfNeeded: exit tag ${tag} not found, exiting`);
-        } else {
-          //logger.debug(`breakLengthyTextIfNeeded: exit tag ${tag} found at ${tagEndPos}`);
-          charPos = tagEndPos + 1;
-        }
-        tag = null;
-      }
-      continue;
-    }
-
-    if (charPos < chunkSize) {
-      charPos++;
-      continue;
-    }
-
-    // start looking for a good break point
-    let chunkIt = false;
-    const a = text[startPos + charPos];
-    const b = text[startPos + charPos + 1];
-    if (/[\.!\?]/.test(a) && /\s/.test(b)) {
-      //logger.debug('breakLengthyTextIfNeeded: breaking at sentence end');
-      chunkIt = true;
-    }
-    if (chunkIt) {
-      charPos++;
-      const chunk = text.substr(startPos, charPos);
-      if (isSSML) {
-        result.push(0 === startPos ? `${chunk}</speak>` : `<speak>${chunk}</speak>`);
-      }
-      else result.push(chunk);
-      charPos = 0;
-      startPos += chunk.length;
-
-      //logger.debug({chunk: result[result.length - 1]},
-      //  `breakLengthyTextIfNeeded: chunked; new starting pos ${startPos}`);
-
-    }
-    else charPos++;
-  }
-
-  // final chunk
-  if (startPos < text.length) {
-    const chunk = text.substr(startPos);
+  const options = {
+    softLimit: 100,
+    hardLimit: chunkSize - 15,
+    extraSplitChars: ',;!?',
+  };
+  pollySSMLSplit.configure(options);
+  try {
+    if (text.length <= chunkSize) return [text];
     if (isSSML) {
-      result.push(0 === startPos ? `${chunk}</speak>` : `<speak>${chunk}`);
+      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>$/, ''));
     }
-    else result.push(chunk);
-
-    //logger.debug({chunk: result[result.length - 1]},
-    //  `breakLengthyTextIfNeeded: final chunk; starting pos ${startPos} length ${chunk.length}`);
-
+  } catch (err) {
+    logger.info({err}, 'Error splitting SSML long text');
+    return [text];
   }
-
-  return result;
 };
 
-class TaskSay extends Task {
+const parseTextFromSayString = (text) => {
+  const closingBraceIndex = text.indexOf('}');
+  if (closingBraceIndex === -1) return text;
+  return text.slice(closingBraceIndex + 1);
+};
+
+class TaskSay extends TtsTask {
   constructor(logger, opts, parentTask) {
-    super(logger, opts);
+    super(logger, opts, parentTask);
     this.preconditions = TaskPreconditions.Endpoint;
 
-    this.text = (Array.isArray(this.data.text) ? this.data.text : [this.data.text])
-      .map((t) => breakLengthyTextIfNeeded(this.logger, t))
-      .flat();
+    assert.ok((typeof this.data.text === 'string' || Array.isArray(this.data.text)) || this.data.stream === true,
+      'Say: either text or stream:true is required');
 
-    this.loop = this.data.loop || 1;
-    this.earlyMedia = this.data.earlyMedia === true || (parentTask && parentTask.earlyMedia);
-    this.synthesizer = this.data.synthesizer || {};
+    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;
+      this.closeOnStreamEmpty = this.data.closeOnStreamEmpty !== false;
+    }
+    else {
+      this._isStreamingTts = false;
+      this.loop = this.data.loop || 1;
+      this.isHandledByPrimaryProvider = true;
+    }
   }
 
   get name() { return TaskName.Say; }
 
   get summary() {
-    for (let i = 0; i < this.text.length; i++) {
-      if (this.text[i].startsWith('silence_stream')) continue;
-      return `${this.name}{text=${this.text[i].slice(0, 15)}${this.text[i].length > 15 ? '...' : ''}}`;
+    if (this.isStreamingTts) return `${this.name} streaming`;
+    else {
+      for (let i = 0; i < this.text.length; i++) {
+        if (this.text[i].startsWith('silence_stream')) continue;
+        return `${this.name}{text=${this.text[i].slice(0, 15)}${this.text[i].length > 15 ? '...' : ''}}`;
+      }
+      return `${this.name}{${this.text[0]}}`;
     }
-    return `${this.name}{${this.text[0]}}`;
   }
 
-  async exec(cs, {ep}) {
-    await super.exec(cs);
+  get isStreamingTts() { return this._isStreamingTts; }
 
-    const {srf} = cs;
-    const {updateSpeechCredentialLastUsed} = require('../utils/db-utils')(this.logger, srf);
-    const {writeAlerts, AlertType, stats} = srf.locals;
-    const {synthAudio} = srf.locals.dbHelpers;
-    const vendor = this.synthesizer.vendor && this.synthesizer.vendor !== 'default' ?
-      this.synthesizer.vendor :
-      cs.speechSynthesisVendor;
-    const language = this.synthesizer.language && this.synthesizer.language !== 'default' ?
-      this.synthesizer.language :
-      cs.speechSynthesisLanguage ;
-    const voice =  this.synthesizer.voice && this.synthesizer.voice !== 'default' ?
-      this.synthesizer.voice :
-      cs.speechSynthesisVoice;
-    const engine = this.synthesizer.engine || 'standard';
-    const salt = cs.callSid;
-    const credentials = cs.getSpeechCredentials(vendor, 'tts');
+  _validateURL(urlString) {
+    try {
+      new URL(urlString);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
 
-    this.logger.info({vendor, language, voice}, 'TaskSay:exec');
+  async exec(cs, obj) {
+    if (this.isStreamingTts && !cs.appIsUsingWebsockets) {
+      throw new Error('Say: streaming say verb requires applications to use the websocket API');
+    }
+
+    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');
+    } catch (error) {
+      if (error instanceof SpeechCredentialError) {
+        // if say failed due to speech credentials, alarm is writtern and error notification is sent
+        // finished this say to move to next task.
+        this.logger.info({error}, 'Say failed due to SpeechCredentialError, finished!');
+        this.emit('playDone');
+        return;
+      }
+      throw error;
+    }
+  }
+
+  async handlingStreaming(cs, {ep}) {
+    const {vendor, language, voice, label} = this.getTtsVendorData(cs);
+    const  credentials = cs.getSpeechCredentials(vendor, 'tts', label);
+    if (!credentials) {
+      throw new SpeechCredentialError(
+        `No text-to-speech service credentials for ${vendor} with labels: ${label} have been configured`);
+    }
     this.ep = ep;
     try {
-      if (!credentials) {
-        writeAlerts({
-          account_sid: cs.accountSid,
-          alert_type: AlertType.TTS_NOT_PROVISIONED,
-          vendor
-        }).catch((err) => this.logger.info({err}, 'Error generating alert for no tts'));
-        this.notifyError(`No speech credentials have been provisioned for ${vendor}`);
-        throw new Error('no provisioned speech credentials for TTS');
-      }
-      // synthesize all of the text elements
-      let lastUpdated = false;
 
-      /* produce an audio segment from the provided text */
-      const generateAudio = async(text) => {
-        if (this.killed) return;
-        if (text.startsWith('silence_stream://')) return text;
+      await this.setTtsStreamingChannelVars(vendor, language, voice, credentials, ep);
 
-        /* otel: trace time for tts */
-        const {span} = this.startChildSpan('tts-generation', {
-          'tts.vendor': vendor,
-          'tts.language': language,
-          'tts.voice': voice
-        });
-        try {
-          const {filePath, servedFromCache} = await synthAudio(stats, {
-            text,
-            vendor,
-            language,
-            voice,
-            engine,
-            salt,
-            credentials
-          });
-          this.logger.debug(`file ${filePath}, served from cache ${servedFromCache}`);
-          if (filePath) cs.trackTmpFile(filePath);
-          if (!servedFromCache && !lastUpdated) {
-            lastUpdated = true;
-            updateSpeechCredentialLastUsed(credentials.speech_credential_sid)
-              .catch(() => {/*already logged error */});
+      await cs.startTtsStream();
+
+      cs.requestor?.request('tts:streaming-event', '/streaming-event', {event_type: 'stream_open'})
+        .catch((err) => this.logger.info({err}, 'TaskSay:handlingStreaming - Error sending'));
+
+      if (this.text.length !== 0) {
+        this.logger.info('TaskSay:handlingStreaming - sending text to TTS stream');
+        for (const t of this.text) {
+          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();
           }
-          span.setAttributes({'tts.cached': servedFromCache});
-          span.end();
-          return filePath;
-        } catch (err) {
-          this.logger.info({err}, 'Error synthesizing tts');
-          span.end();
-          writeAlerts({
-            account_sid: cs.accountSid,
-            alert_type: AlertType.TTS_NOT_PROVISIONED,
-            vendor,
-            detail: err.message
-          }).catch((err) => this.logger.info({err}, 'Error generating alert for tts failure'));
-          this.notifyError(err.message || err);
-          return;
-        }
-      };
-
-      const arr = this.text.map((t) => generateAudio(t));
-      const filepath = (await Promise.all(arr)).filter((fp) => fp && fp.length);
-      this.logger.debug({filepath}, 'synthesized files for tts');
-
-      while (!this.killed && (this.loop === 'forever' || this.loop--) && this.ep?.connected) {
-        let segment = 0;
-        while (!this.killed && segment < filepath.length) {
-          if (cs.isInConference) {
-            const {memberId, confName, confUuid} = cs;
-            await this.playToConfMember(this.ep, memberId, confName, confUuid, filepath[segment]);
-          }
-          else {
-            this.logger.debug(`Say:exec sending command to play file ${filepath[segment]}`);
-            await ep.play(filepath[segment]);
-            this.logger.debug(`Say:exec completed play file ${filepath[segment]}`);
-          }
-          segment++;
         }
       }
     } catch (err) {
-      this.logger.info(err, 'TaskSay:exec error');
+      this.logger.info({err}, 'TaskSay:handlingStreaming - Error setting channel vars');
+      cs.requestor?.request('tts:streaming-event', '/streaming-event', {event_type: 'stream_closed'})
+        .catch((err) => this.logger.info({err}, 'TaskSay:handlingStreaming - Error sending'));
+
+      //TODO: send tts:streaming-event with error?
+      this.notifyTaskDone();
+    }
+
+    await this.awaitTaskDone();
+    this.logger.info('TaskSay:handlingStreaming - done');
+  }
+
+  async handling(cs, {ep}) {
+    const {srf, accountSid:account_sid, callSid:target_sid} = cs;
+    const {writeAlerts, AlertType} = srf.locals;
+    const {addFileToCache} = srf.locals.dbHelpers;
+    const engine = this.synthesizer.engine || cs.synthesizer?.engine || 'neural';
+
+    await super.exec(cs);
+    this.ep = ep;
+
+    let vendor = this.synthesizer.vendor && this.synthesizer.vendor !== 'default' ?
+      this.synthesizer.vendor :
+      cs.speechSynthesisVendor;
+    let language = this.synthesizer.language && this.synthesizer.language !== 'default' ?
+      this.synthesizer.language :
+      cs.speechSynthesisLanguage ;
+    let voice =  this.synthesizer.voice && this.synthesizer.voice !== 'default' ?
+      this.synthesizer.voice :
+      cs.speechSynthesisVoice;
+    let label = this.taskIncludeSynthesizer ? this.synthesizer.label : cs.speechSynthesisLabel;
+
+    const fallbackVendor = this.synthesizer.fallbackVendor && this.synthesizer.fallbackVendor !== 'default' ?
+      this.synthesizer.fallbackVendor :
+      cs.fallbackSpeechSynthesisVendor;
+    const fallbackLanguage = this.synthesizer.fallbackLanguage && this.synthesizer.fallbackLanguage !== 'default' ?
+      this.synthesizer.fallbackLanguage :
+      cs.fallbackSpeechSynthesisLanguage ;
+    const fallbackVoice =  this.synthesizer.fallbackVoice && this.synthesizer.fallbackVoice !== 'default' ?
+      this.synthesizer.fallbackVoice :
+      cs.fallbackSpeechSynthesisVoice;
+    const fallbackLabel = this.taskIncludeSynthesizer ?
+      this.synthesizer.fallbackLabel : cs.fallbackSpeechSynthesisLabel;
+
+    if (cs.hasFallbackTts) {
+      vendor = fallbackVendor;
+      language = fallbackLanguage;
+      voice = fallbackVoice;
+      label = fallbackLabel;
+    }
+
+    const startFallback = async(error) => {
+      if (fallbackVendor && this.isHandledByPrimaryProvider && !cs.hasFallbackTts) {
+        this.notifyError(
+          { msg: 'TTS error', details:`TTS vendor ${vendor} error: ${error}`, failover: 'in progress'});
+        this.isHandledByPrimaryProvider = false;
+        cs.hasFallbackTts = true;
+        this.logger.info(`Synthesize error, fallback to ${fallbackVendor}`);
+        filepath = await this._synthesizeWithSpecificVendor(cs, ep,
+          {
+            vendor: fallbackVendor,
+            language: fallbackLanguage,
+            voice: fallbackVoice,
+            label: fallbackLabel
+          });
+      } else {
+        this.notifyError(
+          { msg: 'TTS error', details:`TTS vendor ${vendor} error: ${error}`, failover: 'not available'});
+        throw new SpeechCredentialError(error.message);
+      }
+    };
+
+    let filepath;
+    try {
+      filepath = await this._synthesizeWithSpecificVendor(cs, ep, {vendor, language, voice, label});
+    } catch (error) {
+      await startFallback(error);
+    }
+    this.notifyStatus({event: 'start-playback'});
+
+    while (!this.killed && (this.loop === 'forever' || this.loop--) && ep?.connected) {
+      let segment = 0;
+      while (!this.killed && segment < filepath.length) {
+        if (cs.isInConference) {
+          const {memberId, confName, confUuid} = cs;
+          await this.playToConfMember(ep, memberId, confName, confUuid, filepath[segment]);
+        }
+        else {
+          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)}`);
+          }
+
+          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 playbackId = this.getPlaybackId(segment);
+              // eslint-disable-next-line max-len
+              const unmatchedResponse = (!!playbackId && !!evt.variable_tts_playback_id) && evt.variable_tts_playback_id !== playbackId;
+              if (unmatchedResponse) {
+                this.logger.info({currentPlaybackId: playbackId, stopPlaybackId: 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);
+
+          const onPlaybackStart = (evt) => {
+            try {
+              const playbackId = this.getPlaybackId(segment);
+              // eslint-disable-next-line max-len
+              const unmatchedResponse = (!!playbackId && !!evt.variable_tts_playback_id) && evt.variable_tts_playback_id !== playbackId;
+              if (unmatchedResponse) {
+                this.logger.info({currentPlaybackId: playbackId, stopPlaybackId: evt.variable_tts_playback_id},
+                  'Say:exec playback-start - unmatched playback_id');
+                ep.once('playback-start',  this._boundOnPlaybackStart);
+                return;
+              }
+              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');
+            }
+          };
+          this._boundOnPlaybackStart = onPlaybackStart.bind(this);
+
+          ep.once('playback-stop',  this._boundOnPlaybackStop);
+          ep.once('playback-start',  this._boundOnPlaybackStart);
+
+          // wait for playback-stop event received to confirm if the playback is successful
+          this._playPromise = new Promise((resolve, reject) => {
+            this._playResolve = resolve;
+            this._playReject = reject;
+          });
+          const r = await ep.play(filepath[segment]);
+          this.logger.debug({r}, 'Say:exec play result');
+          try {
+            // wait for playback-stop event received to confirm if the playback is successful
+            await this._playPromise;
+          } catch (err) {
+            try {
+              await startFallback(err);
+              continue;
+            } catch (err) {
+              this.logger.info({err}, 'Error waiting for playback-stop event');
+              throw err;
+            }
+          } finally {
+            this._playPromise = null;
+            this._playResolve = null;
+            this._playReject = null;
+          }
+          if (filepath[segment].startsWith('say:{')) {
+            const arr = /^say:\{.*\}\s*(.*)$/.exec(filepath[segment]);
+            if (arr) this.logger.debug(`Say:exec complete playing streaming tts request: ${arr[1].substring(0, 64)}..`);
+          } else {
+            // This log will print spech credentials in say command for tts stream mode
+            this.logger.debug(`Say:exec completed play file ${filepath[segment]}`);
+          }
+        }
+        segment++;
+      }
     }
-    this.emit('playDone');
   }
 
   async kill(cs) {
     super.kill(cs);
-    if (this.ep.connected) {
+    if (this.ep?.connected) {
       this.logger.debug('TaskSay:kill - killing audio');
       if (cs.isInConference) {
         const {memberId, confName} = cs;
         this.killPlayToConfMember(this.ep, memberId, confName);
-      }
-      else {
+      } else if (this.isStreamingTts) {
+        this.logger.debug('TaskSay:kill - clearing TTS stream for streaming audio');
+        cs.clearTtsStream();
+      } else {
+        if (!this.notifiedPlayBackStop) {
+          this.notifyStatus({event: 'stop-playback'});
+        }
+        this.notifyStatus({event: 'kill-playback'});
         this.ep.api('uuid_break', this.ep.uuid);
       }
+      this.ep.removeAllListeners('playback-start');
+      this.ep.removeAllListeners('playback-stop');
+      // if we are waiting for playback-stop event, resolve the promise
+      if (this._playResolve) {
+        this._playResolve();
+        this._playResolve = null;
+      }
+    }
+    this.notifyTaskDone();
+  }
+
+  _addStreamingTtsAttributes(span, evt, vendor) {
+    const attrs = {'tts.cached': false};
+    for (const [key, value] of Object.entries(evt)) {
+      if (key.startsWith('variable_tts_')) {
+        let newKey = key.substring('variable_tts_'.length)
+          .replace('whisper_', 'whisper.')
+          .replace('nvidia_', 'nvidia.')
+          .replace('deepgram_', 'deepgram.')
+          .replace('playht_', 'playht.')
+          .replace('cartesia_', 'cartesia.')
+          .replace('rimelabs_', 'rimelabs.')
+          .replace('resemble_', 'resemble.')
+          .replace('inworld_', 'inworld.')
+          .replace('verbio_', 'verbio.')
+          .replace('elevenlabs_', 'elevenlabs.');
+        if (spanMapping[newKey]) newKey = spanMapping[newKey];
+        attrs[newKey] = value;
+        if (key === 'variable_tts_time_to_first_byte_ms' && value) {
+          this.cs.srf.locals.stats.histogram('tts.response_time', value, [`vendor:${vendor}`]);
+        }
+      }
+    }
+    delete attrs['cache_filename']; //no value in adding this to the span
+    span.setAttributes(attrs);
+  }
+
+  notifyTtsStreamIsEmpty() {
+    if (this.isStreamingTts && this.closeOnStreamEmpty) {
+      this.logger.info('TaskSay:notifyTtsStreamIsEmpty - stream is empty, killing task');
+      this.notifyTaskDone();
     }
   }
 }
 
+const spanMapping = {
+  // IMPORTANT!!! JAMBONZ WEBAPP WILL SHOW TEXT PERFECTLY IF THE SPAN NAME IS SMALLER OR EQUAL 25 CHARACTERS.
+  // EX: whisper.ratelim_reqs has length 20 <= 25 which is perfect
+  // Elevenlabs
+  'elevenlabs.reported_latency_ms': 'elevenlabs.latency_ms',
+  'elevenlabs.request_id': 'elevenlabs.req_id',
+  'elevenlabs.history_item_id': 'elevenlabs.item_id',
+  'elevenlabs.optimize_streaming_latency': 'elevenlabs.optimization',
+  'elevenlabs.name_lookup_time_ms': 'name_lookup_ms',
+  'elevenlabs.connect_time_ms': 'connect_ms',
+  'elevenlabs.final_response_time_ms': 'final_response_ms',
+  // Whisper
+  'whisper.reported_latency_ms': 'whisper.latency_ms',
+  'whisper.request_id': 'whisper.req_id',
+  'whisper.reported_organization': 'whisper.organization',
+  'whisper.reported_ratelimit_requests': 'whisper.ratelimit',
+  'whisper.reported_ratelimit_remaining_requests': 'whisper.ratelimit_remain',
+  'whisper.reported_ratelimit_reset_requests': 'whisper.ratelimit_reset',
+  'whisper.name_lookup_time_ms': 'name_lookup_ms',
+  'whisper.connect_time_ms': 'connect_ms',
+  'whisper.final_response_time_ms': 'final_response_ms',
+  // Deepgram
+  'deepgram.request_id': 'deepgram.req_id',
+  'deepgram.reported_model_name': 'deepgram.model_name',
+  'deepgram.reported_model_uuid': 'deepgram.model_uuid',
+  'deepgram.reported_char_count': 'deepgram.char_count',
+  'deepgram.name_lookup_time_ms': 'name_lookup_ms',
+  'deepgram.connect_time_ms': 'connect_ms',
+  'deepgram.final_response_time_ms': 'final_response_ms',
+  // Playht
+  'playht.request_id': 'playht.req_id',
+  'playht.name_lookup_time_ms': 'name_lookup_ms',
+  'playht.connect_time_ms': 'connect_ms',
+  'playht.final_response_time_ms': 'final_response_ms',
+  // Cartesia
+  'cartesia.request_id': 'cartesia.req_id',
+  'cartesia.name_lookup_time_ms': 'name_lookup_ms',
+  'cartesia.connect_time_ms': 'connect_ms',
+  'cartesia.final_response_time_ms': 'final_response_ms',
+  // Rimelabs
+  'rimelabs.name_lookup_time_ms': 'name_lookup_ms',
+  'rimelabs.connect_time_ms': 'connect_ms',
+  'rimelabs.final_response_time_ms': 'final_response_ms',
+  // Resemble
+  'resemble.connect_time_ms': 'connect_ms',
+  'resemble.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',
+  'verbio.final_response_time_ms': 'final_response_ms',
+};
+
 module.exports = TaskSay;

lib/tasks/sip_decline.js

@@ -18,6 +18,11 @@ class TaskSipDecline extends Task {
     super.exec(cs);
     res.send(this.data.status, this.data.reason, {
       headers: this.headers
+    }, (err) => {
+      if (!err) {
+        // Call was successfully declined
+        cs._callReleased();
+      }
     });
     cs.emit('callStatusChange', {
       callStatus: CallStatus.Failed,

lib/tasks/sip_refer.js

@@ -12,6 +12,7 @@ class TaskSipRefer extends Task {
 
     this.referTo = this.data.referTo;
     this.referredBy = this.data.referredBy;
+    this.referredByDisplayName = this.data.referredByDisplayName;
     this.headers = this.data.headers || {};
     this.eventHook = this.data.eventHook;
   }
@@ -36,6 +37,7 @@ class TaskSipRefer extends Task {
         method: 'REFER',
         headers: {
           ...this.headers,
+          ...(this.referToIsUri && {'X-Refer-To-Leave-Untouched': true}),
           'Refer-To': referTo,
           'Referred-By': referredBy
         }
@@ -46,7 +48,17 @@ class TaskSipRefer extends Task {
 
       /* if we fail, fall through to next verb.  If success, we should get BYE from far end */
       if (this.referStatus === 202) {
+        this._notifyTimer = setTimeout(() => {
+          this.logger.info('TaskSipRefer:exec - no NOTIFY received in 15 secs, exiting');
+          this.performAction({refer_status: this.referStatus})
+            .catch((err) => this.logger.error(err, 'TaskSipRefer:exec - error performing action'));
+          this.notifyTaskDone();
+        }, 15000);
         await this.awaitTaskDone();
+        if (this._notifyTimer) {
+          clearTimeout(this._notifyTimer);
+          this._notifyTimer = null;
+        }
       }
       else {
         await this.performAction({refer_status: this.referStatus});
@@ -70,10 +82,10 @@ class TaskSipRefer extends Task {
     const contentType = req.get('Content-Type');
     this.logger.debug({body: req.body}, `TaskSipRefer:_handleNotify got ${contentType}`);
 
-    if (contentType === 'message/sipfrag') {
+    if (contentType?.includes('message/sipfrag')) {
       const arr = /SIP\/2\.0\s+(\d+)/.exec(req.body);
       if (arr) {
-        const status = arr[1];
+        const status = typeof arr[1] === 'string' ? parseInt(arr[1], 10) : arr[1];
         this.logger.debug(`TaskSipRefer:_handleNotify: call got status ${status}`);
         if (this.eventHook) {
           const b3 = this.getTracingPropagation();
@@ -83,7 +95,10 @@ class TaskSipRefer extends Task {
         }
         if (status >= 200) {
           this.referSpan.setAttributes({'refer.finalNotify': status});
-          await this.performAction({refer_status: 202, final_referred_call_status: status});
+          await this.performAction({refer_status: 202, final_referred_call_status: status})
+            .catch((err) => {
+              this.logger.error(err, 'TaskSipRefer:exec - error performing action finalNotify');
+            });
           this.notifyTaskDone();
         }
       }
@@ -91,23 +106,37 @@ class TaskSipRefer extends Task {
   }
 
   _normalizeReferHeaders(cs, dlg) {
-    let {referTo, referredBy} = this;
+    let {referTo, referredBy, referredByDisplayName} = this;
 
     /* get IP address of the SBC to use as hostname if needed */
     const {host} = parseUri(dlg.remote.uri);
 
-    if (!referTo.startsWith('<') && !referTo.startsWith('sip') && !referTo.startsWith('"')) {
+    if (
+      !referTo.startsWith('<') &&
+      !referTo.startsWith('sip:') &&
+      !referTo.startsWith('"') &&
+      !referTo.startsWith('tel:')
+    ) {
       /* they may have only provided a phone number/user */
       referTo = `sip:${referTo}@${host}`;
     }
+    else this.referToIsUri = true;
     if (!referredBy) {
       /* default */
       referredBy = cs.req?.callingNumber || dlg.local.uri;
       this.logger.info({referredBy}, 'setting referredby');
     }
-    if (!referredBy.startsWith('<') && !referredBy.startsWith('sip') && !referredBy.startsWith('"')) {
+    if (!referredByDisplayName) {
+      referredByDisplayName = cs.req?.callingName;
+    }
+    if (
+      !referredBy.startsWith('<') &&
+      !referredBy.startsWith('sip:') &&
+      !referredBy.startsWith('"') &&
+      !referredBy.startsWith('tel:')
+    ) {
       /* they may have only provided a phone number/user */
-      referredBy = `sip:${referredBy}@${host}`;
+      referredBy = `${referredByDisplayName ? `"${referredByDisplayName}"` : ''}<sip:${referredBy}@${host}>`;
     }
     return {referTo, referredBy};
   }

lib/tasks/specs.json

@@ -1,556 +0,0 @@
-{
-  "sip:decline": {
-    "properties": {
-      "status": "number",
-      "reason": "string",
-      "headers": "object"
-    },
-    "required": [
-      "status"
-    ]
-  },
-  "sip:request": {
-    "properties": {
-      "method": "string",
-      "body": "string",
-      "headers": "object",
-      "actionHook": "object|string"
-    },
-    "required": [
-      "method"
-    ]
-  },
-  "sip:refer": {
-    "properties": {
-      "referTo": "string",
-      "referredBy": "string",
-      "headers": "object",
-      "actionHook": "object|string",
-      "eventHook": "object|string"
-    },
-    "required": [
-      "referTo"
-    ]
-  },
-  "config": {
-    "properties": {
-      "synthesizer": "#synthesizer",
-      "recognizer": "#recognizer",
-      "bargeIn": "#bargeIn",
-      "record": "#recordOptions",
-      "amd": "#amd"
-    },
-    "required": []
-  },
-  "bargeIn": {
-    "properties": {
-      "enable": "boolean",
-      "sticky": "boolean",
-      "actionHook": "object|string",
-      "input": "array",
-      "finishOnKey": "string",
-      "numDigits": "number",
-      "minDigits": "number",
-      "maxDigits": "number",
-      "interDigitTimeout": "number",
-      "dtmfBargein": "boolean",
-      "minBargeinWordCount": "number"
-    },
-    "required": [
-      "enable"
-    ]
-  },
-  "dequeue": {
-    "properties": {
-      "name": "string",
-      "actionHook": "object|string",
-      "timeout": "number",
-      "beep": "boolean"
-    },
-    "required": [
-      "name"
-    ]
-  },
-  "enqueue": {
-    "properties": {
-      "name": "string",
-      "actionHook": "object|string",
-      "waitHook": "object|string",
-      "_": "object"
-    },
-    "required": [
-      "name"
-    ]
-  },
-  "leave": {
-    "properties": {
-
-    }
-  },
-  "hangup": {
-    "properties": {
-      "headers": "object"
-    },
-    "required": [
-    ]
-  },
-  "play": {
-    "properties": {
-      "url": "string|array",
-      "loop": "number|string",
-      "earlyMedia": "boolean",
-      "seekOffset": "number|string",
-      "timeoutSecs": "number|string",
-      "actionHook": "object|string"
-    },
-    "required": [
-      "url"
-    ]
-  },
-  "say": {
-    "properties": {
-      "text": "string|array",
-      "loop": "number|string",
-      "synthesizer": "#synthesizer",
-      "earlyMedia": "boolean"
-    },
-    "required": [
-      "text"
-    ]
-  },
-  "gather": {
-    "properties": {
-      "actionHook": "object|string",
-      "finishOnKey": "string",
-      "input": "array",
-      "numDigits": "number",
-      "minDigits": "number",
-      "maxDigits": "number",
-      "interDigitTimeout": "number",
-      "partialResultHook": "object|string",
-      "speechTimeout": "number",
-      "listenDuringPrompt": "boolean",
-      "dtmfBargein": "boolean",
-      "bargein": "boolean",
-      "minBargeinWordCount": "number",
-      "timeout": "number",
-      "recognizer": "#recognizer",
-      "play": "#play",
-      "say": "#say"
-    },
-    "required": [
-    ]
-  },
-  "conference": {
-    "properties": {
-      "name": "string",
-      "beep": "boolean",
-      "startConferenceOnEnter": "boolean",
-      "endConferenceOnExit": "boolean",
-      "maxParticipants": "number",
-      "joinMuted": "boolean",
-      "actionHook": "object|string",
-      "waitHook": "object|string",
-      "statusEvents": "array",
-      "statusHook": "object|string",
-      "enterHook": "object|string",
-      "record": "#record"
-    },
-    "required": [
-      "name"
-    ]
-  },
-  "dial": {
-    "properties": {
-      "actionHook": "object|string",
-      "answerOnBridge": "boolean",
-      "callerId": "string",
-      "confirmHook": "object|string",
-      "referHook": "object|string",
-      "dialMusic": "string",
-      "dtmfCapture": "object",
-      "dtmfHook": "object|string",
-      "headers": "object",
-      "listen": "#listen",
-      "target": ["#target"],
-      "timeLimit": "number",
-      "timeout": "number",
-      "proxy": "string",
-      "transcribe": "#transcribe",
-      "amd": "#amd"
-    },
-    "required": [
-      "target"
-    ]
-  },
-  "dialogflow": {
-    "properties": {
-      "credentials": "object|string",
-      "project": "string",
-      "environment": "string",
-      "region": {
-        "type": "string",
-        "enum": ["europe-west1", "europe-west2", "australia-southeast1", "asia-northeast1"]
-      },
-      "lang": "string",
-      "actionHook": "object|string",
-      "eventHook": "object|string",
-      "events": "[string]",
-      "welcomeEvent": "string",
-      "welcomeEventParams": "object",
-      "noInputTimeout": "number",
-      "noInputEvent": "string",
-      "passDtmfAsTextInput": "boolean",
-      "thinkingMusic": "string",
-      "tts": "#synthesizer",
-      "bargein": "boolean"
-    },
-    "required": [
-      "project",
-      "credentials",
-      "lang"
-    ]
-  },
-  "dtmf": {
-    "properties": {
-      "dtmf": "string",
-      "duration": "number"
-    },
-    "required": [
-      "dtmf"
-    ]
-  },
-  "lex": {
-    "properties": {
-      "botId": "string",
-      "botAlias": "string",
-      "credentials": "object",
-      "region": "string",
-      "locale": "string",
-      "intent": "#lexIntent",
-      "welcomeMessage": "string",
-      "metadata": "object",
-      "bargein": "boolean",
-      "passDtmf": "boolean",
-      "actionHook": "object|string",
-      "eventHook": "object|string",
-      "noInputTimeout": "number",
-      "tts": "#synthesizer"
-    },
-    "required": [
-      "botId",
-      "botAlias",
-      "region",
-      "credentials"
-    ]
-  },
-  "listen": {
-    "properties": {
-      "actionHook": "object|string",
-      "auth": "#auth",
-      "finishOnKey": "string",
-      "maxLength": "number",
-      "metadata": "object",
-      "mixType": {
-        "type": "string",
-        "enum": ["mono", "stereo", "mixed"]
-      },
-      "passDtmf": "boolean",
-      "playBeep": "boolean",
-      "sampleRate": "number",
-      "timeout": "number",
-      "transcribe": "#transcribe",
-      "url": "string",
-      "wsAuth": "#auth",
-      "earlyMedia": "boolean"
-    },
-    "required": [
-      "url"
-    ]
-  },
-  "message": {
-    "properties": {
-      "carrier": "string",
-      "account_sid": "string",
-      "message_sid": "string",
-      "to": "string",
-      "from": "string",
-      "text": "string",
-      "media": "string|array",
-      "actionHook": "object|string"
-    },
-    "required": [
-      "to",
-      "from"
-    ]
-  },
-  "pause": {
-    "properties": {
-      "length": "number"
-    },
-    "required": [
-      "length"
-    ]
-  },
-  "rasa": {
-    "properties": {
-      "url": "string",
-      "recognizer": "#recognizer",
-      "tts": "#synthesizer",
-      "prompt": "string",
-      "actionHook": "object|string",
-      "eventHook": "object|string"
-    },
-    "required": [
-      "url"
-    ]
-  },
-  "record": {
-    "properties": {
-      "path": "string"
-    },
-    "required": [
-      "path"
-    ]
-  },
-  "recordOptions": {
-    "properties": {
-      "action": {
-        "type": "string",
-        "enum": ["startCallRecording", "stopCallRecording", "pauseCallRecording", "resumeCallRecording"]
-      },
-      "recordingID": "string",
-      "siprecServerURL": "string"
-    },
-    "required": [
-      "action"
-    ]
-  },
-  "redirect": {
-    "properties": {
-      "actionHook": "object|string"
-    },
-    "required": [
-      "actionHook"
-    ]
-  },
-  "rest:dial": {
-    "properties": {
-      "account_sid": "string",
-      "application_sid": "string",
-      "call_hook": "object|string",
-      "call_status_hook": "object|string",
-      "from": "string",
-      "fromHost": "string",
-      "speech_synthesis_vendor": "string",
-      "speech_synthesis_voice": "string",
-      "speech_synthesis_language": "string",
-      "speech_recognizer_vendor": "string",
-      "speech_recognizer_language": "string",
-      "tag": "object",
-      "to": "#target",
-      "headers": "object",
-      "timeout": "number"
-    },
-    "required": [
-      "call_hook",
-      "from",
-      "to"
-    ]
-  },
-  "tag": {
-    "properties": {
-      "data": "object"
-    },
-    "required": [
-      "data"
-    ]
-  },
-  "transcribe": {
-    "properties": {
-      "transcriptionHook": "string",
-      "recognizer": "#recognizer",
-      "earlyMedia": "boolean"
-    },
-    "required": [
-      "recognizer"
-    ]
-  },
-  "target": {
-    "properties": {
-      "type": {
-        "type": "string",
-        "enum": ["phone", "sip", "user", "teams"]
-      },
-      "confirmHook": "object|string",
-      "method": {
-        "type": "string",
-        "enum": ["GET", "POST"]
-      },
-      "headers": "object",
-      "from": "#dialFrom",
-      "name": "string",
-      "number": "string",
-      "sipUri": "string",
-      "auth": "#auth",
-      "vmail": "boolean",
-      "tenant": "string",
-      "trunk": "string",
-      "overrideTo": "string"
-    },
-    "required": [
-      "type"
-    ]
-  },
-  "dialFrom": {
-    "properties": {
-      "user": "string",
-      "host": "string"
-    },
-    "required": [
-    ]
-  },
-  "auth": {
-    "properties": {
-      "username": "string",
-      "password": "string"
-    },
-    "required": [
-      "username",
-      "password"
-    ]
-  },
-  "synthesizer": {
-    "properties": {
-      "vendor": {
-        "type": "string",
-        "enum": ["google", "aws", "polly", "microsoft", "default"]
-      },
-      "language": "string",
-      "voice": "string",
-      "engine": {
-        "type": "string",
-        "enum": ["standard", "neural"]
-      },
-      "gender": {
-        "type": "string",
-        "enum": ["MALE", "FEMALE", "NEUTRAL"]
-      }
-    },
-    "required": [
-      "vendor"
-    ]
-  },
-  "recognizer": {
-    "properties": {
-      "vendor": {
-        "type": "string",
-        "enum": ["google", "aws", "microsoft", "default"]
-      },
-      "language": "string",
-      "vad": "#vad",
-      "hints": "array",
-      "hintsBoost": "number",
-      "altLanguages": "array",
-      "profanityFilter": "boolean",
-      "interim": "boolean",
-      "singleUtterance": "boolean",
-      "dualChannel": "boolean",
-      "separateRecognitionPerChannel": "boolean",
-      "punctuation": "boolean",
-      "enhancedModel": "boolean",
-      "words": "boolean",
-      "diarization": "boolean",
-      "diarizationMinSpeakers": "number",
-      "diarizationMaxSpeakers": "number",
-      "interactionType": {
-        "type": "string",
-        "enum": [
-          "unspecified",
-          "discussion",
-          "presentation",
-          "phone_call",
-          "voicemail",
-          "voice_search",
-          "voice_command",
-          "dictation"
-        ]
-      },
-      "naicsCode": "number",
-      "identifyChannels": "boolean",
-      "vocabularyName": "string",
-      "vocabularyFilterName": "string",
-      "filterMethod": {
-        "type": "string",
-        "enum": [
-          "remove",
-          "mask",
-          "tag"
-        ]
-      },
-      "model": "string",
-      "outputFormat": {
-        "type": "string",
-        "enum": [
-          "simple",
-          "detailed"
-        ]
-      },
-      "profanityOption": {
-        "type": "string",
-        "enum": [
-          "masked",
-          "removed",
-          "raw"
-        ]
-      },
-      "requestSnr": "boolean",
-      "initialSpeechTimeoutMs": "number",
-      "azureServiceEndpoint": "string",
-      "azureSttEndpointId": "string",
-      "asrDtmfTerminationDigit": "string",
-      "asrTimeout": "number"
-    },
-    "required": [
-      "vendor"
-    ]
-  },
-  "lexIntent": {
-    "properties": {
-      "name": "string",
-      "slots": "object"
-    },
-    "required": [
-      "name"
-    ]
-  },
-  "vad": {
-    "properties": {
-      "enable": "boolean",
-      "voiceMs": "number",
-      "mode": "number"
-    },
-    "required": [
-      "enable"
-    ]
-  },
-  "amd": {
-    "properties": {
-      "actionHook": "object|string",
-      "thresholdWordCount": "number",
-      "timers": "#amdTimers",
-      "recognizer": "#recognizer"
-    },
-    "required": [
-      "actionHook"
-    ]
-  },
-  "amdTimers": {
-    "properties": {
-      "noSpeechTimeoutMs": "number",
-      "decisionTimeoutMs": "number",
-      "toneTimeoutMs": "number",
-      "greetingCompletionTimeoutMs": "number"
-    }
-  }
-}

lib/tasks/stt-task.js

@@ -0,0 +1,444 @@
+const Task = require('./task');
+const assert = require('assert');
+const crypto = require('crypto');
+const { TaskPreconditions, CobaltTranscriptionEvents } = require('../utils/constants');
+const { SpeechCredentialError } = require('../utils/error');
+const {JAMBONES_AWS_TRANSCRIBE_USE_GRPC} = require('../config');
+const {TaskName} = require('../utils/constants.json');
+
+/**
+ * "Please insert turns here: {{turns:4}}"
+// -> { processed: 'Please insert turns here: {{turns}}', turns: 4 }
+
+processTurnString("Please insert turns here: {{turns}}"));
+// -> { processed: 'Please insert turns here: {{turns}}', turns: null }
+ */
+const processTurnString = (input) => {
+  const regex = /\{\{turns(?::(\d+))?\}\}/;
+  const match = input.match(regex);
+
+  if (!match) {
+    return {
+      processed: input,
+      turns: null
+    };
+  }
+
+  const turns = match[1] ? parseInt(match[1], 10) : null;
+  const processed = input.replace(regex, '{{turns}}');
+
+  return { processed, turns };
+};
+
+class SttTask extends Task {
+
+  constructor(logger, data, parentTask) {
+    super(logger, data);
+    this.parentTask = parentTask;
+
+    this.preconditions = TaskPreconditions.Endpoint;
+
+    const {
+      setChannelVarsForStt,
+      normalizeTranscription,
+      setSpeechCredentialsAtRuntime,
+      compileSonioxTranscripts,
+      consolidateTranscripts,
+      updateSpeechmaticsPayload
+    } = require('../utils/transcription-utils')(logger);
+    this.setChannelVarsForStt = setChannelVarsForStt;
+    this.normalizeTranscription = normalizeTranscription;
+    this.compileSonioxTranscripts = compileSonioxTranscripts;
+    this.consolidateTranscripts = consolidateTranscripts;
+    this.updateSpeechmaticsPayload = updateSpeechmaticsPayload;
+    this.eventHandlers = [];
+    this.isHandledByPrimaryProvider = true;
+    /**
+     * Task use taskIncludeRecognizer to identify
+     * if taskIncludeRecognizer === true, use label from verb.recognizer, even it's empty
+     * if taskIncludeRecognizer === false, use label from application.recognizer
+     */
+    this.taskIncludeRecognizer = !!this.data.recognizer;
+    if (this.data.recognizer) {
+      const recognizer = this.data.recognizer;
+      this.vendor = recognizer.vendor;
+      this.language = recognizer.language;
+      this.label = recognizer.label;
+
+      //fallback
+      this.fallbackVendor = recognizer.fallbackVendor || 'default';
+      this.fallbackLanguage = recognizer.fallbackLanguage || 'default';
+      this.fallbackLabel = recognizer.fallbackLabel;
+
+      /* let credentials be supplied in the recognizer object at runtime */
+      this.sttCredentials = setSpeechCredentialsAtRuntime(recognizer);
+
+      if (!Array.isArray(this.data.recognizer.altLanguages)) {
+        this.data.recognizer.altLanguages = [];
+      }
+    } else {
+      this.data.recognizer = {hints: [], altLanguages: []};
+    }
+
+    /* buffer for soniox transcripts */
+    this._sonioxTranscripts = [];
+    /*bug name prefix */
+    this.bugname_prefix = '';
+
+    // stt latency calculator
+    this.stt_latency_ms = '';
+
+  }
+
+  async exec(cs, {ep, ep2}) {
+    super.exec(cs);
+    this.ep = ep;
+    this.ep2 = ep2;
+
+    // start vad from stt latency calculator
+    if (this.name !== TaskName.Gather ||
+      this.name === TaskName.Gather && this.needsStt) {
+      cs.startSttLatencyVad();
+    }
+
+    // use session preferences if we don't have specific verb-level settings.
+    if (cs.recognizer) {
+      for (const k in cs.recognizer) {
+        const newValue = this.data.recognizer && this.data.recognizer[k] !== undefined ?
+          this.data.recognizer[k] :
+          cs.recognizer[k];
+
+        if (Array.isArray(newValue)) {
+          this.data.recognizer[k] = [...(this.data.recognizer[k] || []), ...cs.recognizer[k]];
+        } else if (typeof newValue === 'object' && newValue !== null) {
+          this.data.recognizer[k] = { ...(this.data.recognizer[k] || {}), ...cs.recognizer[k] };
+        } else {
+          this.data.recognizer[k] = newValue;
+        }
+      }
+    }
+    if ('default' === this.vendor || !this.vendor) {
+      this.vendor = cs.speechRecognizerVendor;
+      if (this.data.recognizer) this.data.recognizer.vendor = this.vendor;
+    }
+    if ('default' === this.language || !this.language) {
+      this.language = cs.speechRecognizerLanguage;
+      if (this.data.recognizer) this.data.recognizer.language = this.language;
+    }
+    if (!this.taskIncludeRecognizer) {
+      this.label = cs.speechRecognizerLabel;
+      if (this.data.recognizer) this.data.recognizer.label = this.label;
+    }
+    // Fallback options
+    if ('default' === this.fallbackVendor || !this.fallbackVendor) {
+      this.fallbackVendor = cs.fallbackSpeechRecognizerVendor;
+      if (this.data.recognizer) this.data.recognizer.fallbackVendor = this.fallbackVendor;
+    }
+    if ('default' === this.fallbackLanguage || !this.fallbackLanguage) {
+      this.fallbackLanguage = cs.fallbackSpeechRecognizerLanguage;
+      if (this.data.recognizer) this.data.recognizer.fallbackLanguage = this.fallbackLanguage;
+    }
+    if (!this.taskIncludeRecognizer) {
+      this.fallbackLabel = cs.fallbackSpeechRecognizerLabel;
+      if (this.data.recognizer) this.data.recognizer.fallbackLabel = this.fallbackLabel;
+    }
+
+    if (cs.hasFallbackAsr) {
+      if (this.taskIncludeRecognizer) {
+        // reset fallback ASR from previous run if this verb contains data.recognizer.
+        cs.hasFallbackAsr = false;
+      } else {
+        this.logger.debug('Call session has fallback to 2nd ASR, use 2nd recognizer configuration');
+        this.vendor = this.fallbackVendor;
+        this.language = this.fallbackLanguage;
+        this.label = this.fallbackLabel;
+      }
+    }
+    if (!this.data.recognizer.vendor) {
+      this.data.recognizer.vendor = this.vendor;
+    }
+    if (this.vendor === 'cobalt' && !this.data.recognizer.model) {
+      // By default, application saves cobalt model in language
+      this.data.recognizer.model = cs.speechRecognizerLanguage;
+    }
+
+    if (
+      // not gather task, such as transcribe
+      (!this.input ||
+      // gather task with speech
+        this.input.includes('speech')) &&
+      !this.sttCredentials) {
+      try {
+        this.sttCredentials = await this._initSpeechCredentials(this.cs, this.vendor, this.label);
+      } catch (error) {
+        if (this.canFallback) {
+          this.notifyError(
+            {
+              msg: 'ASR error', details:`Invalid vendor ${this.vendor}, Error: ${error}`,
+              failover: 'in progress'
+            });
+          await this._initFallback();
+        } else {
+          this.notifyError(
+            {
+              msg: 'ASR error', details:`Invalid vendor ${this.vendor}, Error: ${error}`,
+              failover: 'not available'
+            });
+          throw error;
+        }
+      }
+    }
+
+    /* when using cobalt model is required */
+    if (this.vendor === 'cobalt' && !this.data.recognizer.model) {
+      this.notifyError({ msg: 'ASR error', details:'Cobalt requires a model to be specified'});
+      throw new Error('Cobalt requires a model to be specified');
+    }
+
+    if (cs.hasAltLanguages) {
+      this.data.recognizer.altLanguages = this.data.recognizer.altLanguages.concat(cs.altLanguages);
+      this.logger.debug({altLanguages: this.altLanguages},
+        'STT:exec - applying altLanguages');
+    }
+    if (cs.hasGlobalSttPunctuation && !this.data.recognizer.punctuation) {
+      this.data.recognizer.punctuation = cs.globalSttPunctuation;
+    }
+  }
+
+  addCustomEventListener(ep, event, handler) {
+    this.eventHandlers.push({ep, event, handler});
+    ep.addCustomEventListener(event, handler);
+  }
+
+  removeCustomEventListeners() {
+    this.eventHandlers.forEach((h) => h.ep.removeCustomEventListener(h.event, h.handler));
+  }
+
+  async _initSpeechCredentials(cs, vendor, label) {
+    const {getNuanceAccessToken, getIbmAccessToken, getAwsAuthToken, getVerbioAccessToken} = cs.srf.locals.dbHelpers;
+    let credentials = cs.getSpeechCredentials(vendor, 'stt', label);
+
+    if (!credentials) {
+      const {writeAlerts, AlertType} = cs.srf.locals;
+      this.logger.info(`ERROR stt using ${vendor} requested but creds not supplied`);
+      writeAlerts({
+        account_sid: cs.accountSid,
+        alert_type: AlertType.STT_NOT_PROVISIONED,
+        vendor,
+        target_sid: cs.callSid
+      }).catch((err) => this.logger.info({err}, 'Error generating alert for no stt'));
+      // the ASR might have fallback configuration, should not done task here.
+      throw new SpeechCredentialError(`No speech-to-text service credentials for ${vendor} have been configured`);
+    }
+
+    if (vendor === 'nuance' && credentials.client_id) {
+      /* get nuance access token */
+      const {client_id, secret} = credentials;
+      const {access_token, servedFromCache} = await getNuanceAccessToken(client_id, secret, 'asr tts');
+      this.logger.debug({client_id}, `got nuance access token ${servedFromCache ? 'from cache' : ''}`);
+      credentials = {...credentials, access_token};
+    }
+    else if (vendor == 'ibm' && credentials.stt_api_key) {
+      /* get ibm access token */
+      const {stt_api_key, stt_region} = credentials;
+      const {access_token, servedFromCache} = await getIbmAccessToken(stt_api_key);
+      this.logger.debug({stt_api_key}, `got ibm access token ${servedFromCache ? 'from cache' : ''}`);
+      credentials = {...credentials, access_token, stt_region};
+    } else if (['aws', 'polly'].includes(vendor) && credentials.roleArn) {
+      /* get aws access token */
+      const {roleArn, region} = credentials;
+      const {accessKeyId, secretAccessKey, sessionToken, servedFromCache} =
+        await getAwsAuthToken({
+          region,
+          roleArn
+        });
+      this.logger.debug({roleArn}, `(roleArn) got aws access token ${servedFromCache ? 'from cache' : ''}`);
+      // from role ARN, we will get SessionToken, but feature server use it as securityToken.
+      credentials = {...credentials, accessKeyId, secretAccessKey, securityToken: sessionToken};
+    }
+    else if (vendor === 'verbio' && credentials.client_id && credentials.client_secret) {
+      const {access_token, servedFromCache} = await getVerbioAccessToken(credentials);
+      this.logger.debug({client_id: credentials.client_id},
+        `got verbio access token ${servedFromCache ? 'from cache' : ''}`);
+      credentials.access_token = access_token;
+    }
+    else if (vendor == 'aws' && !JAMBONES_AWS_TRANSCRIBE_USE_GRPC) {
+      /* get AWS access token */
+      const {speech_credential_sid, accessKeyId, secretAccessKey, securityToken, region } = credentials;
+      if (!securityToken) {
+        const { servedFromCache, ...newCredentials} = await getAwsAuthToken({
+          speech_credential_sid,
+          accessKeyId,
+          secretAccessKey,
+          region});
+        this.logger.debug({newCredentials}, `got aws security token ${servedFromCache ? 'from cache' : ''}`);
+        credentials = {...newCredentials, region};
+      }
+    }
+
+    return credentials;
+  }
+
+  get canFallback() {
+    return this.fallbackVendor && this.isHandledByPrimaryProvider && !this.cs.hasFallbackAsr;
+  }
+
+  async _initFallback() {
+    assert(this.fallbackVendor, 'fallback failed without fallbackVendor configuration');
+    this.logger.info(`Failed to use primary STT provider, fallback to ${this.fallbackVendor}`);
+    this.isHandledByPrimaryProvider = false;
+    this.cs.hasFallbackAsr = true;
+    this.vendor = this.cs.fallbackSpeechRecognizerVendor = this.fallbackVendor;
+    this.language = this.cs.fallbackSpeechRecognizerLanguage = this.fallbackLanguage;
+    this.label = this.cs.fallbackSpeechRecognizerLabel = this.fallbackLabel;
+    this.data.recognizer.vendor = this.vendor;
+    this.data.recognizer.language = this.language;
+    this.data.recognizer.label = this.label;
+    this.sttCredentials = await this._initSpeechCredentials(this.cs, this.vendor, this.label);
+    // cleanup previous listener from previous vendor
+    this.removeCustomEventListeners();
+  }
+
+  async compileHintsForCobalt(ep, hostport, model, token, hints) {
+    const {retrieveKey} = this.cs.srf.locals.dbHelpers;
+    const hash = crypto.createHash('sha1');
+    hash.update(`${model}:${hints}`);
+    const key = `cobalt:${hash.digest('hex')}`;
+    this.context = await retrieveKey(key);
+    if (this.context) {
+      this.logger.debug({model, hints}, 'found cached cobalt context for supplied hints');
+      return this.context;
+    }
+
+    this.logger.debug({model, hints}, 'compiling cobalt context for supplied hints');
+
+    return new Promise((resolve, reject) => {
+      this.cobaltCompileResolver = resolve;
+      ep.addCustomEventListener(CobaltTranscriptionEvents.CompileContext, this._onCompileContext.bind(this, ep, key));
+      ep.api('uuid_cobalt_compile_context', [ep.uuid, hostport, model, token, hints], (err, evt) => {
+        if (err || 0 !== evt.getBody().indexOf('+OK')) {
+          ep.removeCustomEventListener(CobaltTranscriptionEvents.CompileContext);
+          return reject(err);
+        }
+      });
+    });
+  }
+
+  formatOpenAIPrompt(cs, {prompt, hintsTemplate, conversationHistoryTemplate, hints}) {
+    let conversationHistoryPrompt, hintsPrompt;
+
+    /* generate conversation history from template */
+    if (conversationHistoryTemplate) {
+      const {processed, turns} = processTurnString(conversationHistoryTemplate);
+      this.logger.debug({processed, turns}, 'SttTask: processed conversation history template');
+      conversationHistoryPrompt = cs.getFormattedConversation(turns || 4);
+      //this.logger.debug({conversationHistoryPrompt}, 'SttTask: conversation history');
+      if (conversationHistoryPrompt) {
+        conversationHistoryPrompt = processed.replace('{{turns}}', `\n${conversationHistoryPrompt}\nuser: `);
+      }
+    }
+
+    /* generate hints from template */
+    if (hintsTemplate && Array.isArray(hints) && hints.length > 0) {
+      hintsPrompt = hintsTemplate.replace('{{hints}}', hints);
+    }
+
+    /* combine into final prompt */
+    let finalPrompt = prompt || '';
+    if (hintsPrompt) {
+      finalPrompt = `${finalPrompt}\n${hintsPrompt}`;
+    }
+    if (conversationHistoryPrompt) {
+      finalPrompt = `${finalPrompt}\n${conversationHistoryPrompt}`;
+    }
+
+    this.logger.debug({
+      finalPrompt,
+      hints,
+      hintsPrompt,
+      conversationHistoryTemplate,
+      conversationHistoryPrompt
+    }, 'SttTask: formatted OpenAI prompt');
+    return finalPrompt?.trimStart();
+  }
+
+  /* some STT engines will keep listening after a final response, so no need to restart */
+  doesVendorContinueListeningAfterFinalTranscript(vendor) {
+    return (vendor.startsWith('custom:') || [
+      'soniox',
+      'aws',
+      'microsoft',
+      'deepgram',
+      'google',
+      'speechmatics',
+      'openai',
+    ].includes(vendor));
+  }
+
+  _onCompileContext(ep, key, evt) {
+    const {addKey} = this.cs.srf.locals.dbHelpers;
+    this.logger.debug({evt}, `received cobalt compile context event, will cache under ${key}`);
+
+    this.cobaltCompileResolver(evt.compiled_context);
+    ep.removeCustomEventListener(CobaltTranscriptionEvents.CompileContext);
+    this.cobaltCompileResolver = null;
+
+    //cache the compiled context
+    addKey(key, evt.compiled_context, 3600 * 12)
+      .catch((err) => this.logger.info({err}, `Error caching cobalt context for ${key}`));
+  }
+
+  _doContinuousAsrWithDeepgram(asrTimeout) {
+    /* deepgram has an utterance_end_ms property that simplifies things */
+    assert(this.vendor === 'deepgram');
+    if (asrTimeout < 1000) {
+      this.notifyError({
+        msg: 'ASR error',
+        details:`asrTimeout ${asrTimeout} is too short for deepgram; setting it to 1000ms`
+      });
+      asrTimeout = 1000;
+    }
+    else if (asrTimeout > 5000) {
+      this.notifyError({
+        msg: 'ASR error',
+        details:`asrTimeout ${asrTimeout} is too long for deepgram; setting it to 5000ms`
+      });
+      asrTimeout = 5000;
+    }
+    this.logger.debug(`_doContinuousAsrWithDeepgram - setting utterance_end_ms to ${asrTimeout}`);
+    const dgOptions = this.data.recognizer.deepgramOptions = this.data.recognizer.deepgramOptions || {};
+    dgOptions.utteranceEndMs = dgOptions.utteranceEndMs || asrTimeout;
+  }
+
+  _onVendorConnect(cs, _ep) {
+    this.logger.debug(`TaskGather:_on${this.vendor}Connect`);
+  }
+
+  _onVendorError(cs, _ep, evt) {
+    this.logger.info({evt}, `${this.name}:_on${this.vendor}Error`);
+    const {writeAlerts, AlertType} = cs.srf.locals;
+    writeAlerts({
+      account_sid: cs.accountSid,
+      alert_type: AlertType.STT_FAILURE,
+      message: 'STT failure reported by vendor',
+      detail: evt.error,
+      vendor: this.vendor,
+      target_sid: cs.callSid
+    }).catch((err) => this.logger.info({err}, `Error generating alert for ${this.vendor} connection failure`));
+  }
+
+  _onVendorConnectFailure(cs, _ep, evt) {
+    const {reason} = evt;
+    const {writeAlerts, AlertType} = cs.srf.locals;
+    this.logger.info({evt}, `${this.name}:_on${this.vendor}ConnectFailure`);
+    writeAlerts({
+      account_sid: cs.accountSid,
+      alert_type: AlertType.STT_FAILURE,
+      message: `Failed connecting to ${this.vendor} speech recognizer: ${reason}`,
+      vendor: this.vendor,
+      target_sid: cs.callSid
+    }).catch((err) => this.logger.info({err}, `Error generating alert for ${this.vendor} connection failure`));
+  }
+}
+
+module.exports = SttTask;

lib/tasks/tag.js

@@ -12,7 +12,7 @@ class TaskTag extends Task {
   async exec(cs) {
     super.exec(cs);
     cs.callInfo.customerData = this.data;
-    //this.logger.debug({callInfo: cs.callInfo.toJSON()}, 'TaskTag:exec set customer data in callInfo');
+    this.logger.debug({customerData: cs.callInfo.customerData}, 'TaskTag:exec set customer data in callInfo');
   }
 }
 

lib/tasks/task.js

@@ -1,13 +1,10 @@
 const Emitter = require('events');
-const { v4: uuidv4 } = require('uuid');
-const debug = require('debug')('jambonz:feature-server');
-const assert = require('assert');
+const crypto = require('crypto');
 const {TaskPreconditions} = require('../utils/constants');
-const normalizeJambones = require('../utils/normalize-jambones');
+const { normalizeJambones } = require('@jambonz/verb-specifications');
+const WsRequestor = require('../utils/ws-requestor');
+const {TaskName} = require('../utils/constants');
 const {trace} = require('@opentelemetry/api');
-const specs = new Map();
-const _specData = require('./specs');
-for (const key in _specData) {specs.set(key, _specData[key]);}
 
 /**
  * @classdesc Represents a jambonz verb. This is a superclass that is extended
@@ -21,6 +18,8 @@ class Task extends Emitter {
     this.logger = logger;
     this.data = data;
     this.actionHook = this.data.actionHook;
+    this.id = data.id;
+    this.taskId = crypto.randomUUID();
 
     this._killInProgress = false;
     this._completionPromise = new Promise((resolve) => this._completionResolver = resolve);
@@ -47,6 +46,10 @@ class Task extends Emitter {
     return this.name;
   }
 
+  set disableTracing(val) {
+    this._disableTracing = val;
+  }
+
   toJSON() {
     return this.data;
   }
@@ -137,29 +140,58 @@ class Task extends Emitter {
     return this.callSession.normalizeUrl(url, method, auth);
   }
 
-  notifyError(errMsg) {
-    const params = {error: errMsg, verb: this.name};
-    this.cs.requestor.request('jambonz:error', '/error', params)
-      .catch((err) => this.logger.info({err}, 'Task:notifyError error sending error'));
+  notifyError(obj) {
+    if (this.cs.requestor instanceof WsRequestor) {
+      const params = {...obj, verb: this.name, id: this.id};
+      this.cs.requestor.request('jambonz:error', '/error', params)
+        .catch((err) => this.logger.info({err}, 'Task:notifyError error sending error'));
+    }
+  }
+
+  notifyStatus(obj) {
+    if (this.cs.notifyEvents && this.cs.requestor instanceof WsRequestor) {
+      const params = {...obj, verb: this.name, id: this.id};
+      this.cs.requestor.request('verb:status', '/status', params)
+        .catch((err) => this.logger.info({err}, 'Task:notifyStatus error sending error'));
+    }
   }
 
   async performAction(results, expectResponse = true) {
     if (this.actionHook) {
+      const type = this.name === TaskName.Redirect ? 'session:redirect' : 'verb:hook';
       const params = results ? Object.assign(this.cs.callInfo.toJSON(), results) : this.cs.callInfo.toJSON();
-      const span = this.startSpan('verb:hook', {'hook.url': this.actionHook});
+      const span = this.startSpan(`${type} (${this.actionHook})`);
       const b3 = this.getTracingPropagation('b3', span);
       const httpHeaders = b3 && {b3};
       span.setAttributes({'http.body': JSON.stringify(params)});
       try {
-        const json = await this.cs.requestor.request('verb:hook', this.actionHook, params, httpHeaders);
+        if (this.id) params.verb_id = this.id;
+        const json = await this.cs.requestor.request(type, this.actionHook, params, httpHeaders, span);
         span.setAttributes({'http.statusCode': 200});
-        span.end();
+        const isWsConnection = this.cs.requestor instanceof WsRequestor;
+        if (!isWsConnection || (expectResponse && json && Array.isArray(json) && json.length)) {
+          span.end();
+        } else {
+          /** we use this span to measure application response latency,
+           * and with websocket connections we generally get the application's response
+           * in a subsequent message from the far end, so we terminate the span when the
+           * first new set of verbs arrive after sending a transcript
+           * */
+          this.emit('VerbHookSpanWaitForEnd', {span});
+
+          // If actionHook delay action is configured, and ws application have not responded yet any verb for actionHook
+          // We have to transfer the task to call-session to await on next ws command verbs, and also run action Hook
+          // delay actions
+          //if (this.hookDelayActionOpts) {
+          //  this.emit('ActionHookDelayActionOptions', this.hookDelayActionOpts);
+          //}
+        }
         if (expectResponse && json && Array.isArray(json)) {
           const makeTask = require('./make_task');
           const tasks = normalizeJambones(this.logger, json).map((tdata) => makeTask(this.logger, tdata));
           if (tasks && tasks.length > 0) {
-            this.logger.info({tasks: tasks}, `${this.name} replacing application with ${tasks.length} tasks`);
             this.callSession.replaceApplication(tasks);
+            return true;
           }
         }
       } catch (err) {
@@ -167,6 +199,7 @@ class Task extends Emitter {
         span.end();
         throw err;
       }
+      return false;
     }
   }
 
@@ -177,7 +210,7 @@ class Task extends Emitter {
     const httpHeaders = b3 && {b3};
     span.setAttributes({'http.body': JSON.stringify(params)});
     try {
-      const json = await cs.requestor.request('verb:hook', hook, params, httpHeaders);
+      const json = await cs.requestor.request('verb:hook', hook, params, httpHeaders, span);
       span.setAttributes({'http.statusCode': 200});
       span.end();
       if (json && Array.isArray(json)) {
@@ -240,12 +273,13 @@ class Task extends Emitter {
   }
 
   async transferCallToFeatureServer(cs, sipAddress, opts) {
-    const uuid = uuidv4();
+    const uuid = crypto.randomUUID();
     const {addKey} = cs.srf.locals.dbHelpers;
     const obj = Object.assign({}, cs.application);
     delete obj.requestor;
     delete obj.notifier;
     obj.tasks =  cs.getRemainingTaskData();
+    obj.callInfo = cs.callInfo.toJSON();
     if (opts && obj.tasks.length > 0) {
       const key = Object.keys(obj.tasks[0])[0];
       Object.assign(obj.tasks[0][key], {_: opts});
@@ -273,77 +307,6 @@ class Task extends Emitter {
       this.logger.error(err, 'Task:_doRefer error');
     }
   }
-
-  /**
-   * validate that the JSON task description is valid
-   * @param {string} name - verb name
-   * @param {object} data - verb properties
-   */
-  static validate(name, data) {
-    debug(`validating ${name} with data ${JSON.stringify(data)}`);
-    // validate the instruction is supported
-    if (!specs.has(name)) throw new Error(`invalid instruction: ${name}`);
-
-    // check type of each element and make sure required elements are present
-    const specData = specs.get(name);
-    let required = specData.required || [];
-    for (const dKey in data) {
-      if (dKey in specData.properties) {
-        const dVal = data[dKey];
-        const dSpec = specData.properties[dKey];
-        debug(`Task:validate validating property ${dKey} with value ${JSON.stringify(dVal)}`);
-
-        if (typeof dSpec === 'string' && dSpec === 'array') {
-          if (!Array.isArray(dVal)) throw new Error(`${name}: property ${dKey} is not an array`);
-        }
-        else if (typeof dSpec === 'string' && dSpec.includes('|')) {
-          const types = dSpec.split('|').map((t) => t.trim());
-          if (!types.includes(typeof dVal) && !(types.includes('array') && Array.isArray(dVal))) {
-            throw new Error(`${name}: property ${dKey} has invalid data type, must be one of ${types}`);
-          }
-        }
-        else if (typeof dSpec === 'string' && ['number', 'string', 'object', 'boolean'].includes(dSpec)) {
-          // simple types
-          if (typeof dVal !== specData.properties[dKey]) {
-            throw new Error(`${name}: property ${dKey} has invalid data type`);
-          }
-        }
-        else if (Array.isArray(dSpec) && dSpec[0].startsWith('#')) {
-          const name = dSpec[0].slice(1);
-          for (const item of dVal) {
-            Task.validate(name, item);
-          }
-        }
-        else if (typeof dSpec === 'object') {
-          // complex types
-          const type = dSpec.type;
-          assert.ok(['number', 'string', 'object', 'boolean'].includes(type),
-            `invalid or missing type in spec ${JSON.stringify(dSpec)}`);
-          if (type === 'string' && dSpec.enum) {
-            assert.ok(Array.isArray(dSpec.enum), `enum must be an array ${JSON.stringify(dSpec.enum)}`);
-            if (!dSpec.enum.includes(dVal)) throw new Error(`invalid value ${dVal} must be one of ${dSpec.enum}`);
-          }
-        }
-        else if (typeof dSpec === 'string' && dSpec.startsWith('#')) {
-          // reference to another datatype (i.e. nested type)
-          const name = dSpec.slice(1);
-          //const obj = {};
-          //obj[name] = dVal;
-          Task.validate(name, dVal);
-        }
-        else {
-          assert.ok(0, `invalid spec ${JSON.stringify(dSpec)}`);
-        }
-        required = required.filter((item) => item !== dKey);
-      }
-      else if (dKey === '_') {
-        /* no op: allow arbitrary info to be carried here, used by conference e.g in transfer */
-      }
-      else throw new Error(`${name}: unknown property ${dKey}`);
-    }
-    if (required.length > 0) throw new Error(`${name}: missing value for ${required}`);
-  }
-
 }
 
 module.exports = Task;

lib/tasks/tts-task.js

@@ -0,0 +1,367 @@
+const Task = require('./task');
+const { TaskPreconditions } = require('../utils/constants');
+const { SpeechCredentialError } = require('../utils/error');
+const dbUtils = require('../utils/db-utils');
+
+const extractPlaybackId = (str) => {
+  // Match say:{...} and capture the content inside braces
+  const match = str.match(/say:\{([^}]*)\}/);
+  if (!match) return null;
+
+  // Look for playback_id=value within the captured content
+  const playbackMatch = match[1].match(/playback_id=([^,]*)/);
+  return playbackMatch ? playbackMatch[1] : null;
+};
+
+class TtsTask extends Task {
+
+  constructor(logger, data, parentTask) {
+    super(logger, data);
+    this.parentTask = parentTask;
+
+    this.preconditions = TaskPreconditions.Endpoint;
+
+    this.earlyMedia = this.data.earlyMedia === true || (parentTask && parentTask.earlyMedia);
+    /**
+     * Task use taskIncludeSynthesizer to identify
+     * if taskIncludeSynthesizer === true, use label from verb.synthesizer, even it's empty
+     * if taskIncludeSynthesizer === false, use label from application.synthesizer
+     */
+    this.taskIncludeSynthesizer = !!this.data.synthesizer;
+    this.synthesizer = this.data.synthesizer || {};
+    this.disableTtsCache = this.data.disableTtsCache;
+    this.options = this.synthesizer.options || {};
+    this.instructions = this.data.instructions;
+    this.playbackIds = [];
+  }
+
+  getPlaybackId(offset) {
+    return this.playbackIds[offset];
+  }
+
+  async exec(cs) {
+    super.exec(cs);
+    if (cs.synthesizer) {
+      this.options = {...cs.synthesizer.options, ...this.options};
+      this.data.synthesizer = this.data.synthesizer || {};
+      for (const k in cs.synthesizer) {
+        const newValue = this.data.synthesizer && this.data.synthesizer[k] !== undefined ?
+          this.data.synthesizer[k] :
+          cs.synthesizer[k];
+
+        if (Array.isArray(newValue)) {
+          this.data.synthesizer[k] = [...(this.data.synthesizer[k] || []), ...cs.synthesizer[k]];
+        } else if (typeof newValue === 'object' && newValue !== null) {
+          this.data.synthesizer[k] = { ...(this.data.synthesizer[k] || {}), ...cs.synthesizer[k] };
+        } else {
+          this.data.synthesizer[k] = newValue;
+        }
+      }
+    }
+
+    const fullText = Array.isArray(this.text) ? this.text.join(' ') : this.text;
+    // in case dub verb, text might not be set.
+    if (fullText?.length > 0) {
+      cs.emit('botSaid', fullText);
+    }
+  }
+
+  getTtsVendorData(cs) {
+    const vendor = this.synthesizer.vendor && this.synthesizer.vendor !== 'default' ?
+      this.synthesizer.vendor :
+      cs.speechSynthesisVendor;
+    const language = this.synthesizer.language && this.synthesizer.language !== 'default' ?
+      this.synthesizer.language :
+      cs.speechSynthesisLanguage ;
+    const voice =  this.synthesizer.voice && this.synthesizer.voice !== 'default' ?
+      this.synthesizer.voice :
+      cs.speechSynthesisVoice;
+    const label = this.taskIncludeSynthesizer ? this.synthesizer.label : cs.speechSynthesisLabel;
+    return {vendor, language, voice, label};
+  }
+
+  async setTtsStreamingChannelVars(vendor, language, voice, credentials, ep) {
+    const {api_key, model_id, custom_tts_streaming_url, auth_token} = credentials;
+    let obj;
+
+    this.logger.debug({credentials},
+      `setTtsStreamingChannelVars: vendor: ${vendor}, language: ${language}, voice: ${voice}`);
+
+    switch (vendor) {
+      case 'deepgram':
+        obj = {
+          DEEPGRAM_API_KEY: api_key,
+          DEEPGRAM_TTS_STREAMING_MODEL: voice
+        };
+        break;
+      case 'cartesia':
+        obj = {
+          CARTESIA_API_KEY: api_key,
+          CARTESIA_TTS_STREAMING_MODEL_ID: model_id,
+          CARTESIA_TTS_STREAMING_VOICE_ID: voice,
+          CARTESIA_TTS_STREAMING_LANGUAGE: language || 'en',
+        };
+        break;
+      case 'elevenlabs':
+        const {stability, similarity_boost, use_speaker_boost, style, speed} = this.options.voice_settings || {};
+        obj = {
+          ELEVENLABS_API_KEY: api_key,
+          ELEVENLABS_TTS_STREAMING_MODEL_ID: model_id,
+          ELEVENLABS_TTS_STREAMING_VOICE_ID: voice,
+          // 20/12/2024 - only eleven_turbo_v2_5 support multiple language
+          ...(['eleven_turbo_v2_5'].includes(model_id) && {ELEVENLABS_TTS_STREAMING_LANGUAGE: language}),
+          ...(stability && {ELEVENLABS_TTS_STREAMING_VOICE_SETTINGS_STABILITY: stability}),
+          ...(similarity_boost && {ELEVENLABS_TTS_STREAMING_VOICE_SETTINGS_SIMILARITY_BOOST: similarity_boost}),
+          ...(use_speaker_boost && {ELEVENLABS_TTS_STREAMING_VOICE_SETTINGS_USE_SPEAKER_BOOST: use_speaker_boost}),
+          ...(style && {ELEVENLABS_TTS_STREAMING_VOICE_SETTINGS_STYLE: style}),
+          // speed has value 0.7 to 1.2, 1.0 is default, make sure we send the value event it's 0
+          ...(speed !== null && speed !== undefined && {ELEVENLABS_TTS_STREAMING_VOICE_SETTINGS_SPEED: `${speed}`}),
+          ...(this.options.pronunciation_dictionary_locators &&
+            Array.isArray(this.options.pronunciation_dictionary_locators) && {
+            ELEVENLABS_TTS_STREAMING_PRONUNCIATION_DICTIONARY_LOCATORS:
+            JSON.stringify(this.options.pronunciation_dictionary_locators)
+          }),
+        };
+        break;
+      case 'rimelabs':
+        const {
+          pauseBetweenBrackets, phonemizeBetweenBrackets, inlineSpeedAlpha, speedAlpha, reduceLatency
+        } = this.options;
+        obj = {
+          RIMELABS_API_KEY: api_key,
+          RIMELABS_TTS_STREAMING_MODEL_ID: model_id,
+          RIMELABS_TTS_STREAMING_VOICE_ID: voice,
+          RIMELABS_TTS_STREAMING_LANGUAGE: language || 'en',
+          ...(pauseBetweenBrackets && {RIMELABS_TTS_STREAMING_PAUSE_BETWEEN_BRACKETS: pauseBetweenBrackets}),
+          ...(phonemizeBetweenBrackets &&
+            {RIMELABS_TTS_STREAMING_PHONEMIZE_BETWEEN_BRACKETS: phonemizeBetweenBrackets}),
+          ...(inlineSpeedAlpha && {RIMELABS_TTS_STREAMING_INLINE_SPEED_ALPHA: inlineSpeedAlpha}),
+          ...(speedAlpha && {RIMELABS_TTS_STREAMING_SPEED_ALPHA: speedAlpha}),
+          ...(reduceLatency && {RIMELABS_TTS_STREAMING_REDUCE_LATENCY: reduceLatency})
+        };
+        break;
+      default:
+        if (vendor.startsWith('custom:')) {
+          const use_tls = custom_tts_streaming_url.startsWith('wss://');
+          obj = {
+            CUSTOM_TTS_STREAMING_HOST: custom_tts_streaming_url.replace(/^(ws|wss):\/\//, ''),
+            CUSTOM_TTS_STREAMING_API_KEY: auth_token,
+            CUSTOM_TTS_STREAMING_VOICE_ID: voice,
+            CUSTOM_TTS_STREAMING_LANGUAGE: language || 'en',
+            CUSTOM_TTS_STREAMING_USE_TLS: use_tls
+          };
+        } else {
+          throw new Error(`vendor ${vendor} is not supported for tts streaming yet`);
+        }
+    }
+    this.logger.debug({vendor, credentials, obj}, 'setTtsStreamingChannelVars');
+
+    await ep.set(obj);
+  }
+
+  async _synthesizeWithSpecificVendor(cs, ep, {vendor, language, voice, label, preCache = false}) {
+    const {srf, accountSid:account_sid} = cs;
+    const {writeAlerts, AlertType, stats} = srf.locals;
+    const {synthAudio} = srf.locals.dbHelpers;
+    const engine = this.synthesizer.engine || cs.synthesizer?.engine || 'neural';
+    const salt = cs.callSid;
+
+    let credentials = cs.getSpeechCredentials(vendor, 'tts', label);
+    if (!credentials) {
+      throw new SpeechCredentialError(
+        `No text-to-speech service credentials for ${vendor} with labels: ${label} have been configured`);
+    }
+    /* parse Nuance voices into name and model */
+    if (vendor === 'nuance' && voice) {
+      const arr = /([A-Za-z-]*)\s+-\s+(enhanced|standard)/.exec(voice);
+      if (arr) {
+        voice = arr[1];
+        this.model = arr[2];
+      }
+    } else if (vendor === 'deepgram') {
+      this.model = voice;
+    }
+
+    /* allow for microsoft custom region voice and api_key to be specified as an override */
+    if (vendor === 'microsoft' && this.options.deploymentId) {
+      credentials = credentials || {};
+      credentials.use_custom_tts = true;
+      credentials.custom_tts_endpoint = this.options.deploymentId;
+      credentials.api_key = this.options.apiKey || credentials.apiKey;
+      credentials.region = this.options.region || credentials.region;
+      voice = this.options.voice || voice;
+    } else if (vendor === 'elevenlabs') {
+      credentials = credentials || {};
+      credentials.model_id = this.options.model_id || credentials.model_id;
+      credentials.voice_settings = this.options.voice_settings || {};
+      credentials.optimize_streaming_latency = this.options.optimize_streaming_latency
+      || credentials.optimize_streaming_latency;
+      voice = this.options.voice_id || voice;
+    } 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;
+    } else if (vendor === 'verbio') {
+      credentials = credentials || {};
+      credentials.engine_version = this.options.engine_version || credentials.engine_version;
+    } else if (vendor === 'playht') {
+      credentials = credentials || {};
+      credentials.voice_engine = this.options.voice_engine || credentials.voice_engine;
+    } else if (vendor === 'google' && typeof voice === 'string' && voice.startsWith('custom_')) {
+      const {lookupGoogleCustomVoice} = dbUtils(this.logger, cs.srf);
+      const arr = /custom_(.*)/.exec(voice);
+      if (arr) {
+        const google_custom_voice_sid = arr[1];
+        const [custom_voice] = await lookupGoogleCustomVoice(google_custom_voice_sid);
+        if (custom_voice.use_voice_cloning_key) {
+          voice = {
+            voice_cloning_key: custom_voice.voice_cloning_key,
+          };
+        }
+      }
+    } else if (vendor === 'cartesia') {
+      credentials.model_id = this.options.model_id || credentials.model_id;
+    }
+
+    this.model_id = credentials.model_id;
+
+    /**
+     * note on cache_speech_handles.  This was found to be risky.
+     * It can cause a crash in the following sequence on a single call:
+     * 1. Stream tts on vendor A with cache_speech_handles=1, then
+     * 2. Stream tts on vendor B with cache_speech_handles=1
+     *
+     * we previously tried to track when vendors were switched and manage the flag accordingly,
+     * but it difficult to track all the scenarios and the benefit (slightly faster start to tts playout)
+     * is probably minimal.  DH.
+     */
+    ep.set({
+      tts_engine: vendor.startsWith('custom:') ? 'custom' : vendor,
+      tts_voice: voice,
+      //cache_speech_handles: !cs.currentTtsVendor || cs.currentTtsVendor === vendor ? 1 : 0,
+      cache_speech_handles: 0,
+    }).catch((err) => this.logger.info({err}, 'Error setting tts_engine on endpoint'));
+    // set the current vendor on the call session
+    // If vendor is changed from the previous one, then reset the cache_speech_handles flag
+    //cs.currentTtsVendor = vendor;
+
+    if (!preCache && !this._disableTracing)
+      this.logger.debug({vendor, language, voice, model: this.model}, 'TaskSay:exec');
+    try {
+      if (!credentials) {
+        writeAlerts({
+          account_sid,
+          alert_type: AlertType.TTS_NOT_PROVISIONED,
+          vendor,
+          target_sid: cs.callSid
+        }).catch((err) => this.logger.info({err}, 'Error generating alert for no tts'));
+        throw new SpeechCredentialError('no provisioned speech credentials for TTS');
+      }
+
+      /* produce an audio segment from the provided text */
+      const generateAudio = async(text) => {
+        if (this.killed) return;
+        if (text.startsWith('silence_stream://')) return text;
+
+        /* otel: trace time for tts */
+        if (!preCache && !this._disableTracing)  {
+          const {span} = this.startChildSpan('tts-generation', {
+            'tts.vendor': vendor,
+            'tts.language': language,
+            'tts.voice': voice,
+            'tts.label': label || 'None',
+          });
+          this.otelSpan = span;
+        }
+        try {
+          const {filePath, servedFromCache, rtt} = await synthAudio(stats, {
+            account_sid,
+            text,
+            instructions: this.instructions,
+            vendor,
+            language,
+            voice,
+            engine,
+            model: this.model,
+            salt,
+            credentials,
+            options: this.options,
+            disableTtsCache : this.disableTtsCache,
+            renderForCaching: preCache
+          });
+          if (!filePath.startsWith('say:')) {
+            this.playbackIds.push(null);
+            this.logger.debug(`Say: file ${filePath}, served from cache ${servedFromCache}`);
+            if (filePath) cs.trackTmpFile(filePath);
+            if (this.otelSpan) {
+              this.otelSpan.setAttributes({'tts.cached': servedFromCache});
+              this.otelSpan.end();
+              this.otelSpan = null;
+            }
+            if (!servedFromCache && rtt && !preCache  && !this._disableTracing) {
+              this.notifyStatus({
+                event: 'synthesized-audio',
+                vendor,
+                language,
+                characters: text.length,
+                elapsedTime: rtt,
+                servedFromCache,
+                'id': this.id
+              });
+            }
+            if (servedFromCache) {
+              this.notifyStatus({
+                event: 'synthesized-audio',
+                vendor,
+                language,
+                servedFromCache,
+                'id': this.id
+              });
+            }
+          }
+          else {
+            this.playbackIds.push(extractPlaybackId(filePath));
+            this.logger.debug({playbackIds: this.playbackIds}, 'Say: a streaming tts api will be used');
+            const modifiedPath = filePath.replace('say:{', `say:{session-uuid=${ep.uuid},`);
+            return modifiedPath;
+          }
+          return filePath;
+        } catch (err) {
+          this.logger.info({err}, 'Error synthesizing tts');
+          if (this.otelSpan) this.otelSpan.end();
+          writeAlerts({
+            account_sid: cs.accountSid,
+            alert_type: AlertType.TTS_FAILURE,
+            vendor,
+            detail: err.message,
+            target_sid: cs.callSid
+          }).catch((err) => this.logger.info({err}, 'Error generating alert for tts failure'));
+          throw err;
+        }
+      };
+
+      const arr = this.text.map((t) => (this._validateURL(t) ? t : generateAudio(t)));
+      return (await Promise.all(arr)).filter((fp) => fp && fp.length);
+    } catch (err) {
+      this.logger.info(err, 'TaskSay:exec error');
+      throw err;
+    }
+
+  }
+
+  _validateURL(urlString) {
+    try {
+      new URL(urlString);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+}
+
+module.exports = TtsTask;

lib/utils/action-hook-delay.js

@@ -0,0 +1,187 @@
+const makeTask = require('../tasks/make_task');
+const Emitter = require('events');
+const { normalizeJambones } = require('@jambonz/verb-specifications');
+const {TaskName} = require('../utils/constants');
+
+/**
+ * ActionHookDelayProcessor
+ * @extends Emitter
+ *
+ * @param {Object} logger - logger instance
+ * @param {Object} opts - options
+ * @param {Object} cs - call session
+ * @param {Object} ep - endpoint
+ *
+ * @emits {Event} 'giveup' - when associated giveup timer expires
+ *
+ * Ref:https://www.jambonz.org/docs/supporting-articles/handling-action-hook-delays/
+ */
+class ActionHookDelayProcessor extends Emitter {
+  constructor(logger, opts, cs) {
+    super();
+    this.logger = logger;
+    this.cs = cs;
+    this._active = false;
+
+    const enabled = this.init(opts);
+    if (enabled && this.noResponseTimeout &&
+          (!this.actions || !Array.isArray(this.actions) || this.actions.length === 0)) {
+      throw new Error('ActionHookDelayProcessor: no actions specified');
+    }
+    else if (enabled && this.actions &&
+          this.actions.some((a) => !a.verb || ![TaskName.Say, TaskName.Play].includes(a.verb))) {
+      throw new Error(`ActionHookDelayProcessor: invalid actions specified: ${JSON.stringify(this.actions)}`);
+    }
+  }
+
+  get properties() {
+    return {
+      actions: this.actions,
+      retries: this.retries,
+      noResponseTimeout: this.noResponseTimeout,
+      noResponseGiveUpTimeout: this.noResponseGiveUpTimeout
+    };
+  }
+
+  get ep() {
+    return this.cs.ep;
+  }
+
+  init(opts) {
+    this.logger.debug({opts}, 'ActionHookDelayProcessor#init');
+
+    this.actions = opts.actions;
+    this.retries = opts.retries || 0;
+    this.noResponseTimeout = opts.noResponseTimeout;
+    this.noResponseGiveUpTimeout = opts.noResponseGiveUpTimeout;
+    this.giveUpActions = opts.giveUpActions;
+
+    // return false if these options actually disable the ahdp
+    return ('enable' in opts && opts.enable === true) ||
+      ('enabled' in opts && opts.enabled === true) ||
+      (!('enable' in opts) && !('enabled' in opts));
+  }
+
+  start() {
+    this.logger.debug('ActionHookDelayProcessor#start');
+    if (this._active) {
+      this.logger.debug('ActionHookDelayProcessor#start: already started due to prior gather which is continuing');
+      return;
+    }
+    this._active = true;
+    this._retryCount = 0;
+    if (this.noResponseTimeout > 0) {
+      const timeoutMs =  this.noResponseTimeout * 1000;
+      this._noResponseTimer = setTimeout(this._onNoResponseTimer.bind(this), timeoutMs);
+    } else {
+      this.logger.debug(
+        'ActionHookDelayProcessor#start: noResponseTimeout is 0 or undefined hence not calling _onNoResponseTimer'
+      );
+    }
+
+    if (this.noResponseGiveUpTimeout > 0) {
+      const timeoutMs = this.noResponseGiveUpTimeout * 1000;
+      this._noResponseGiveUpTimer = setTimeout(this._onNoResponseGiveUpTimer.bind(this), timeoutMs);
+    }
+  }
+
+  async stop() {
+    this._active = false;
+
+    if (this._noResponseTimer) {
+      clearTimeout(this._noResponseTimer);
+      this._noResponseTimer = null;
+    }
+    if (this._noResponseGiveUpTimer) {
+      clearTimeout(this._noResponseGiveUpTimer);
+      this._noResponseGiveUpTimer = null;
+    }
+    if (this._taskInProgress) {
+      this.logger.debug(`ActionHookDelayProcessor#stop: stopping ${this._taskInProgress.name}`);
+
+      this._sayResolver = () => {
+        this.logger.debug('ActionHookDelayProcessor#stop: play/say is done, continue on..');
+        //this._taskInProgress.kill(this.cs);
+        this._taskInProgress = null;
+      };
+
+      /* we let Say finish, but interrupt Play */
+      if (TaskName.Play === this._taskInProgress.name) {
+        await this._taskInProgress.kill(this.cs);
+      }
+      return new Promise((resolve) => this._sayResolver = resolve);
+    }
+    this.logger.debug('ActionHookDelayProcessor#stop returning');
+  }
+
+  _onNoResponseTimer() {
+    this.logger.debug('ActionHookDelayProcessor#_onNoResponseTimer');
+    this._noResponseTimer = null;
+
+    /* get the next play or say action */
+    const verb = this.actions[this._retryCount % this.actions.length];
+
+    const t = normalizeJambones(this.logger, [verb]);
+    this.logger.debug({verb}, 'ActionHookDelayProcessor#_onNoResponseTimer: starting action');
+    try {
+      this._taskInProgress = makeTask(this.logger, t[0]);
+      this._taskInProgress.disableTracing = true;
+      this._taskInProgress.exec(this.cs, {ep: this.ep}).catch((err) => {
+        this.logger.info(`ActionHookDelayProcessor#_onNoResponseTimer: error playing file: ${err.message}`);
+        this._taskInProgress = null;
+        this.ep.removeAllListeners('playback-start');
+        this.ep.removeAllListeners('playback-stop');
+      });
+    } catch (err) {
+      this.logger.info(err, 'ActionHookDelayProcessor#_onNoResponseTimer: error starting action');
+      this._taskInProgress = null;
+      return;
+    }
+
+    this.ep.once('playback-start', (evt) => {
+      this.logger.debug({evt}, 'got playback-start');
+      if (!this._active) {
+        this.logger.info({evt}, 'ActionHookDelayProcessor#_onNoResponseTimer: killing audio immediately');
+
+        /* note: in race condition we may have just hung up and cs.ep cleared */
+        this.ep?.api('uuid_break', this.ep?.uuid)
+          .catch((err) => this.logger.info(err,
+            'ActionHookDelayProcessor#_onNoResponseTimer Error killing audio'));
+      }
+    });
+
+    this.ep.once('playback-stop', (evt) => {
+      this._taskInProgress = null;
+      if (this._sayResolver) {
+        /* we were waiting for the play to finish before continuing to next task */
+        this.logger.debug({evt}, 'ActionHookDelayProcessor#_onNoResponseTimer got playback-stop');
+        this._sayResolver();
+        this._sayResolver = null;
+      }
+      else {
+        /* possibly start the no response timer again */
+        if (this._active && this.retries > 0 && this._retryCount < this.retries && this.noResponseTimeout > 0) {
+          this.logger.debug({evt}, 'ActionHookDelayProcessor#_onNoResponseTimer: playback-stop on play/say action');
+          const timeoutMs = this.noResponseTimeout * 1000;
+          this._noResponseTimer = setTimeout(this._onNoResponseTimer.bind(this), timeoutMs);
+        }
+      }
+    });
+
+    this._retryCount++;
+  }
+
+  _onNoResponseGiveUpTimer() {
+    this._active = false;
+    if (!this.giveUpActions) {
+      this.logger.info('ActionHookDelayProcessor#_onNoResponseGiveUpTimer');
+      this.stop().catch((err) => {});
+      this.emit('giveup');
+    } else {
+      this.logger.info('ActionHookDelayProcessor#_onNoResponseGiveUpTimer - giveUpActions');
+      this.emit('giveupWithTasks', this.giveUpActions);
+    }
+  }
+}
+
+module.exports = ActionHookDelayProcessor;

lib/utils/amd-utils.js

@@ -1,14 +1,22 @@
 const Emitter = require('events');
 const {readFile} = require('fs');
 const {
+  TaskName,
   GoogleTranscriptionEvents,
   AwsTranscriptionEvents,
   AzureTranscriptionEvents,
+  NuanceTranscriptionEvents,
+  NvidiaTranscriptionEvents,
+  IbmTranscriptionEvents,
+  SonioxTranscriptionEvents,
+  CobaltTranscriptionEvents,
+  DeepgramTranscriptionEvents,
+  JambonzTranscriptionEvents,
   AmdEvents,
   AvmdEvents
 } = require('./constants');
 const bugname = 'amd_bug';
-const {VMD_HINTS_FILE} = process.env;
+const {VMD_HINTS_FILE} = require('../config');
 let voicemailHints = [];
 
 const updateHints = async(file, callback) => {
@@ -37,6 +45,7 @@ if (VMD_HINTS_FILE) {
   });
 }
 
+
 class Amd extends Emitter {
   constructor(logger, cs, opts) {
     super();
@@ -47,13 +56,21 @@ class Amd extends Emitter {
     this.language = opts.recognizer?.language || cs.speechRecognizerLanguage;
     if ('default' === this.language) this.language = cs.speechRecognizerLanguage;
 
-    this.sttCredentials = cs.getSpeechCredentials(this.vendor, 'stt');
+    this.sttCredentials = cs.getSpeechCredentials(this.vendor, 'stt',
+      opts.recognizer?.label || cs.speechRecognizerLabel);
 
     if (!this.sttCredentials) throw new Error(`No speech credentials found for vendor ${this.vendor}`);
 
     this.thresholdWordCount = opts.thresholdWordCount || 9;
     const {normalizeTranscription} = require('./transcription-utils')(logger);
     this.normalizeTranscription = normalizeTranscription;
+    const {getNuanceAccessToken, getIbmAccessToken} = cs.srf.locals.dbHelpers;
+    this.getNuanceAccessToken = getNuanceAccessToken;
+    this.getIbmAccessToken = getIbmAccessToken;
+    const {setChannelVarsForStt} = require('./transcription-utils')(logger);
+    this.setChannelVarsForStt = setChannelVarsForStt;
+    this.digitCount = opts.digitCount || 0;
+    this.numberRegEx = RegExp(`[0-9]{${this.digitCount}}`);
 
     const {
       noSpeechTimeoutMs = 5000,
@@ -139,7 +156,7 @@ class Amd extends Emitter {
       const wordCount = t.alternatives[0].transcript.split(' ').length;
       const final = t.is_final;
 
-      const foundHint = hints.find((h) =>  t.alternatives[0].transcript.includes(h));
+      const foundHint = hints.find((h) =>  t.alternatives[0].transcript.toLowerCase().includes(h.toLowerCase()));
       if (foundHint) {
         /* we detected a common voice mail greeting */
         this.logger.debug(`Amd:evaluateTranscription: found hint ${foundHint}`);
@@ -149,6 +166,14 @@ class Amd extends Emitter {
           language: t.language_code
         });
       }
+      else if (this.digitCount != 0 && this.numberRegEx.test(t.alternatives[0].transcript)) {
+        /* a string of numbers is typically a machine */
+        this.emit(this.decision = AmdEvents.MachineDetected, {
+          reason: 'digit count',
+          greeting: t.alternatives[0].transcript,
+          language: t.language_code
+        });
+      }
       else if (final && wordCount < this.thresholdWordCount) {
         /* a short greeting is typically a human */
         this.emit(this.decision = AmdEvents.HumanDetected, {
@@ -184,7 +209,7 @@ module.exports = (logger) => {
     const {vendor, language} = ep.amd;
     ep.startTranscription({
       vendor,
-      language,
+      locale: language,
       interim: true,
       bugname
     }).catch((err) => {
@@ -196,7 +221,8 @@ module.exports = (logger) => {
         account_sid: cs.accountSid,
         alert_type: AlertType.STT_FAILURE,
         vendor: vendor,
-        detail: err.message
+        detail: err.message,
+        target_sid: cs.callSid
       });
     }).catch((err) => logger.info({err}, 'Error generating alert for tts failure'));
 
@@ -229,70 +255,141 @@ module.exports = (logger) => {
 
   const startAmd = async(cs, ep, task, opts) => {
     const amd = ep.amd = new Amd(logger, cs, opts);
-    const {vendor, language, sttCredentials} = amd;
-    const sttOpts = {};
-    const hints = voicemailHints[language] || [];
+    const {vendor, language} = amd;
+    let sttCredentials = amd.sttCredentials;
+    // hints from configuration might be too long for specific language and vendor that make transcribe freeswitch
+    // modules cannot connect to the vendor. hints is used in next step to validate if the transcription
+    // matchs voice mail hints.
+    const hints = [];
+
+    if (vendor === 'nuance' && sttCredentials.client_id) {
+      /* get nuance access token */
+      const {getNuanceAccessToken} = amd;
+      const {client_id, secret} = sttCredentials;
+      const {access_token, servedFromCache} = await getNuanceAccessToken(client_id, secret, 'asr tts');
+      logger.debug({client_id}, `Gather:exec - got nuance access token ${servedFromCache ? 'from cache' : ''}`);
+      sttCredentials = {...sttCredentials, access_token};
+    }
+    else if (vendor == 'ibm' && sttCredentials.stt_api_key) {
+      /* get ibm access token */
+      const {getIbmAccessToken} = amd;
+      const {stt_api_key, stt_region} = sttCredentials;
+      const {access_token, servedFromCache} = await getIbmAccessToken(stt_api_key);
+      logger.debug({stt_api_key}, `Gather:exec - got ibm access token ${servedFromCache ? 'from cache' : ''}`);
+      sttCredentials = {...sttCredentials, access_token, stt_region};
+    }
 
     /* set stt options */
     logger.info(`starting amd for vendor ${vendor} and language ${language}`);
-    if ('google' === vendor) {
-      sttOpts.GOOGLE_APPLICATION_CREDENTIALS = JSON.stringify(sttCredentials.credentials);
-      sttOpts.GOOGLE_SPEECH_USE_ENHANCED = true;
-      sttOpts.GOOGLE_SPEECH_HINTS = hints.join(',');
-      if (opts.recognizer?.altLanguages) {
-        sttOpts.GOOGLE_SPEECH_ALTERNATIVE_LANGUAGE_CODES = opts.recognizer.altLanguages.join(',');
-      }
-      ep.addCustomEventListener(GoogleTranscriptionEvents.Transcription, onTranscription.bind(null, cs, ep, task));
-      ep.addCustomEventListener(GoogleTranscriptionEvents.EndOfUtterance, onEndOfUtterance.bind(null, cs, ep, task));
-    }
-    else if (['aws', 'polly'].includes(vendor)) {
-      Object.assign(sttOpts, {
-        AWS_ACCESS_KEY_ID: sttCredentials.accessKeyId,
-        AWS_SECRET_ACCESS_KEY: sttCredentials.secretAccessKey,
-        AWS_REGION: sttCredentials.region
-      });
-      ep.addCustomEventListener(AwsTranscriptionEvents.Transcription, onTranscription.bind(null, cs, ep, task));
-    }
-    else if ('microsoft' === vendor) {
-      Object.assign(sttOpts, {
-        'AZURE_SUBSCRIPTION_KEY': sttCredentials.api_key,
-        'AZURE_REGION': sttCredentials.region
-      });
-      sttOpts.AZURE_SPEECH_HINTS = hints.join(',');
-      if (opts.recognizer?.altLanguages) {
-        sttOpts.AZURE_SPEECH_ALTERNATIVE_LANGUAGE_CODES = opts.recognizer.altLanguages.join(',');
-      }
-      sttOpts.AZURE_INITIAL_SPEECH_TIMEOUT_MS = opts.resolveTimeoutMs || 20000;
+    /* if opts contains recognizer object use that config for stt, otherwise use defaults */
+    const rOpts = opts.recognizer ?
+      opts.recognizer :
+      {
+        vendor,
+        hints,
+        enhancedModel: true,
+        altLanguages: opts.recognizer?.altLanguages || [],
+        initialSpeechTimeoutMs: opts.resolveTimeoutMs,
+      };
+    const sttOpts = amd.setChannelVarsForStt({name: TaskName.Gather}, sttCredentials, language, rOpts);
 
-      ep.addCustomEventListener(AzureTranscriptionEvents.Transcription, onTranscription.bind(null, cs, ep, task));
-      ep.addCustomEventListener(AzureTranscriptionEvents.NoSpeechDetected, onNoSpeechDetected.bind(null, cs, ep, task));
-    }
-    logger.debug({sttOpts}, 'startAmd: setting channel vars');
     await ep.set(sttOpts).catch((err) => logger.info(err, 'Error setting channel variables'));
 
+    amd.transcriptionHandler = onTranscription.bind(null, cs, ep, task);
+    amd.EndOfUtteranceHandler = onEndOfUtterance.bind(null, cs, ep, task);
+    amd.noSpeechHandler = onNoSpeechDetected.bind(null, cs, ep, task);
+
+    switch (vendor) {
+      case 'google':
+        ep.addCustomEventListener(GoogleTranscriptionEvents.Transcription, amd.transcriptionHandler);
+        ep.addCustomEventListener(GoogleTranscriptionEvents.EndOfUtterance, amd.EndOfUtteranceHandler);
+        break;
+
+      case 'aws':
+      case 'polly':
+        ep.addCustomEventListener(AwsTranscriptionEvents.Transcription, amd.transcriptionHandler);
+        break;
+      case 'microsoft':
+        ep.addCustomEventListener(AzureTranscriptionEvents.Transcription, amd.transcriptionHandler);
+        ep.addCustomEventListener(AzureTranscriptionEvents.NoSpeechDetected, amd.noSpeechHandler);
+        break;
+      case 'nuance':
+        ep.addCustomEventListener(NuanceTranscriptionEvents.Transcription, amd.transcriptionHandler);
+        break;
+
+      case 'deepgram':
+        ep.addCustomEventListener(DeepgramTranscriptionEvents.Transcription, amd.transcriptionHandler);
+        break;
+
+      case 'soniox':
+        amd.bugname = 'soniox_amd_transcribe';
+        ep.addCustomEventListener(SonioxTranscriptionEvents.Transcription, amd.transcriptionHandler);
+        break;
+
+      case 'ibm':
+        ep.addCustomEventListener(IbmTranscriptionEvents.Transcription, amd.transcriptionHandler);
+        break;
+
+      case 'nvidia':
+        ep.addCustomEventListener(NvidiaTranscriptionEvents.Transcription, amd.transcriptionHandler);
+        break;
+
+      case 'cobalt':
+        ep.addCustomEventListener(CobaltTranscriptionEvents.Transcription, amd.transcriptionHandler);
+        break;
+
+      default:
+        if (vendor.startsWith('custom:')) {
+          ep.addCustomEventListener(JambonzTranscriptionEvents.Transcription, amd.transcriptionHandler);
+          break;
+        }
+        else {
+          throw new Error(`Invalid vendor ${this.vendor}`);
+        }
+    }
     amd
       .on(AmdEvents.NoSpeechDetected, (evt) => {
         task.emit('amd', {type: AmdEvents.NoSpeechDetected, ...evt});
-        ep.stopTranscription({vendor, bugname});
+        try {
+          stopAmd(ep, task);
+        } catch (err) {
+          logger.info({err}, 'Error stopping transcription');
+        }
       })
       .on(AmdEvents.HumanDetected, (evt) => {
         task.emit('amd', {type: AmdEvents.HumanDetected, ...evt});
-        ep.stopTranscription({vendor, bugname});
+        try {
+          stopAmd(ep, task);
+        } catch (err) {
+          logger.info({err}, 'Error stopping transcription');
+        }
       })
       .on(AmdEvents.MachineDetected, (evt) => {
         task.emit('amd', {type: AmdEvents.MachineDetected, ...evt});
       })
       .on(AmdEvents.DecisionTimeout, (evt) => {
         task.emit('amd', {type: AmdEvents.DecisionTimeout, ...evt});
-        ep.stopTranscription({vendor, bugname});
+        try {
+          stopAmd(ep, task);
+        } catch (err) {
+          logger.info({err}, 'Error stopping transcription');
+        }
       })
       .on(AmdEvents.ToneTimeout, (evt) => {
         //task.emit('amd', {type: AmdEvents.ToneTimeout, ...evt});
-        ep.execute('avmd_stop').catch((err) => logger.info(err, 'Error stopping avmd'));
+        try {
+          stopAmd(ep, task);
+        } catch (err) {
+          logger.info({err}, 'Error stopping avmd');
+        }
       })
       .on(AmdEvents.MachineStoppedSpeaking, () => {
         task.emit('amd', {type: AmdEvents.MachineStoppedSpeaking});
-        ep.stopTranscription({vendor, bugname});
+        try {
+          stopAmd(ep, task);
+        } catch (err) {
+          logger.info({err}, 'Error stopping transcription');
+        }
       });
 
     /* start transcribing, and also listening for beep */
@@ -308,11 +405,28 @@ module.exports = (logger) => {
     if (ep.amd) {
       vendor = ep.amd.vendor;
       ep.amd.stopAllTimers();
+
+      ep.removeListener(GoogleTranscriptionEvents.Transcription, ep.amd.transcriptionHandler);
+      ep.removeListener(GoogleTranscriptionEvents.EndOfUtterance, ep.amd.EndOfUtteranceHandler);
+      ep.removeListener(AwsTranscriptionEvents.Transcription, ep.amd.transcriptionHandler);
+      ep.removeListener(AzureTranscriptionEvents.Transcription, ep.amd.transcriptionHandler);
+      ep.removeListener(AzureTranscriptionEvents.NoSpeechDetected, ep.amd.noSpeechHandler);
+      ep.removeListener(NuanceTranscriptionEvents.Transcription, ep.amd.transcriptionHandler);
+      ep.removeListener(DeepgramTranscriptionEvents.Transcription, ep.amd.transcriptionHandler);
+      ep.removeListener(SonioxTranscriptionEvents.Transcription, ep.amd.transcriptionHandler);
+      ep.removeListener(IbmTranscriptionEvents.Transcription, ep.amd.transcriptionHandler);
+      ep.removeListener(NvidiaTranscriptionEvents.Transcription, ep.amd.transcriptionHandler);
+      ep.removeListener(JambonzTranscriptionEvents.Transcription, ep.amd.transcriptionHandler);
+
       ep.amd = null;
     }
 
     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'));

lib/utils/aws-sns-lifecycle.js

@@ -1,20 +1,30 @@
 const Emitter = require('events');
 const bent = require('bent');
 const assert = require('assert');
-const PORT = process.env.AWS_SNS_PORT || 3010;
+const {
+  AWS_REGION,
+  AWS_SNS_PORT: PORT,
+  AWS_SNS_TOPIC_ARN,
+  AWS_SNS_PORT_MAX,
+} = require('../config');
 const {LifeCycleEvents} = require('./constants');
 const express = require('express');
 const app = express();
 const getString = bent('string');
-const AWS = require('aws-sdk');
-const sns = new AWS.SNS({apiVersion: '2010-03-31'});
-const autoscaling = new AWS.AutoScaling({apiVersion: '2011-01-01'});
+const {
+  SNSClient,
+  SubscribeCommand,
+  UnsubscribeCommand } = require('@aws-sdk/client-sns');
+const snsClient = new SNSClient({ region: AWS_REGION, apiVersion: '2010-03-31' });
+const {
+  AutoScalingClient,
+  DescribeAutoScalingGroupsCommand,
+  CompleteLifecycleActionCommand } = require('@aws-sdk/client-auto-scaling');
+const autoScalingClient = new AutoScalingClient({ region: AWS_REGION, apiVersion: '2011-01-01' });
 const {Parser} = require('xml2js');
 const parser = new Parser();
 const {validatePayload} = require('verify-aws-sns-signature');
 
-AWS.config.update({region: process.env.AWS_REGION});
-
 class SnsNotifier extends Emitter {
   constructor(logger) {
     super();
@@ -31,12 +41,12 @@ class SnsNotifier extends Emitter {
 
   _handleErrors(logger, app, resolve, reject, e) {
     if (e.code === 'EADDRINUSE' &&
-      process.env.AWS_SNS_PORT_MAX &&
-      e.port < process.env.AWS_SNS_PORT_MAX) {
+      AWS_SNS_PORT_MAX &&
+      e.port < AWS_SNS_PORT_MAX) {
 
       logger.info(`SNS lifecycle server failed to bind port on ${e.port}, will try next port`);
       const server = this._doListen(logger, app, ++e.port, resolve);
-      server.on('error', this._handleErrors.bind(null, logger, app, resolve, reject));
+      server.on('error', this._handleErrors.bind(this, logger, app, resolve, reject));
       return;
     }
     reject(e);
@@ -45,12 +55,12 @@ class SnsNotifier extends Emitter {
   async _handlePost(req, res) {
     try {
       const parsedBody = JSON.parse(req.body);
-      this.logger.debug({headers: req.headers, body: parsedBody}, 'Received HTTP POST from AWS');
+      this.logger.info({headers: req.headers, body: parsedBody}, 'Received HTTP POST from AWS');
       if (!validatePayload(parsedBody)) {
         this.logger.info('incoming AWS SNS HTTP POST failed signature validation');
         return res.sendStatus(403);
       }
-      this.logger.debug('incoming HTTP POST passed validation');
+      this.logger.info('incoming HTTP POST passed validation');
       res.sendStatus(200);
 
       switch (parsedBody.Type) {
@@ -64,7 +74,18 @@ class SnsNotifier extends Emitter {
             subscriptionRequestId: this.subscriptionRequestId
           }, 'response from SNS SubscribeURL');
           const data = await this.describeInstance();
-          this.lifecycleState = data.AutoScalingInstances[0].LifecycleState;
+
+          const group = data.AutoScalingGroups.find((group) =>
+            group.Instances && group.Instances.some((instance) => instance.InstanceId === this.instanceId)
+          );
+          if (!group) {
+            this.logger.error('Current instance not found in any Auto Scaling group', data);
+          } else {
+            const instance = group.Instances.find((instance) => instance.InstanceId === this.instanceId);
+            this.lifecycleState = instance.LifecycleState;
+          }
+
+          //this.lifecycleState = data.AutoScalingGroups[0].Instances[0].LifecycleState;
           this.emit('SubscriptionConfirmation', {publicIp: this.publicIp});
           break;
 
@@ -84,7 +105,7 @@ class SnsNotifier extends Emitter {
               this.unsubscribe();
             }
             else {
-              this.logger.debug(`SnsNotifier - instance ${msg.EC2InstanceId} is scaling in (not us)`);
+              this.logger.info(`SnsNotifier - instance ${msg.EC2InstanceId} is scaling in (not us)`);
             }
           }
           break;
@@ -101,7 +122,7 @@ class SnsNotifier extends Emitter {
 
   async init() {
     try {
-      this.logger.debug('SnsNotifier: retrieving instance data');
+      this.logger.info('SnsNotifier: retrieving instance data');
       this.instanceId = await getString('http://169.254.169.254/latest/meta-data/instance-id');
       this.publicIp = await getString('http://169.254.169.254/latest/meta-data/public-ipv4');
       this.logger.info({
@@ -120,7 +141,7 @@ class SnsNotifier extends Emitter {
       });
       return new Promise((resolve, reject) => {
         const server = this._doListen(this.logger, app, PORT, resolve);
-        server.on('error', this._handleErrors.bind(null, this.logger, app, resolve, reject));
+        server.on('error', this._handleErrors.bind(this, this.logger, app, resolve, reject));
       });
 
     } catch (err) {
@@ -130,51 +151,56 @@ class SnsNotifier extends Emitter {
 
   async subscribe() {
     try {
-      const response = await sns.subscribe({
+      const params = {
         Protocol: 'http',
-        TopicArn: process.env.AWS_SNS_TOPIC_ARM,
+        TopicArn: AWS_SNS_TOPIC_ARN,
         Endpoint: this.snsEndpoint
-      }).promise();
-      this.logger.info({response}, `response to SNS subscribe to ${process.env.AWS_SNS_TOPIC_ARM}`);
+      };
+      const response = await snsClient.send(new SubscribeCommand(params));
+      this.logger.info({response}, `response to SNS subscribe to ${AWS_SNS_TOPIC_ARN}`);
     } catch (err) {
-      this.logger.error({err}, `Error subscribing to SNS topic arn ${process.env.AWS_SNS_TOPIC_ARM}`);
+      this.logger.error({err}, `Error subscribing to SNS topic arn ${AWS_SNS_TOPIC_ARN}`);
     }
   }
 
   async unsubscribe() {
     if (!this.subscriptionArn) throw new Error('SnsNotifier#unsubscribe called without an active subscription');
     try {
-      const response = await sns.unsubscribe({
+      const params = {
         SubscriptionArn: this.subscriptionArn
-      }).promise();
-      this.logger.info({response}, `response to SNS unsubscribe to ${process.env.AWS_SNS_TOPIC_ARM}`);
+      };
+      const response = await snsClient.send(new UnsubscribeCommand(params));
+      this.logger.info({response}, `response to SNS unsubscribe to ${AWS_SNS_TOPIC_ARN}`);
     } catch (err) {
-      this.logger.error({err}, `Error unsubscribing to SNS topic arn ${process.env.AWS_SNS_TOPIC_ARM}`);
+      this.logger.error({err}, `Error unsubscribing to SNS topic arn ${AWS_SNS_TOPIC_ARN}`);
     }
   }
 
   completeScaleIn() {
     assert(this.scaleInParams);
-    autoscaling.completeLifecycleAction(this.scaleInParams, (err, response) => {
-      if (err) return this.logger.error({err}, 'Error completing scale-in');
-      this.logger.info({response}, 'Successfully completed scale-in action');
-    });
+    autoScalingClient.send(new CompleteLifecycleActionCommand(this.scaleInParams))
+      .then((data) => {
+        return this.logger.info({data}, 'Successfully completed scale-in action');
+      })
+      .catch((err) => {
+        this.logger.error({err}, 'Error completing scale-in');
+      });
   }
 
   describeInstance() {
     return new Promise((resolve, reject) => {
       if (!this.instanceId) return reject('instance-id unknown');
-      autoscaling.describeAutoScalingInstances({
+      autoScalingClient.send(new DescribeAutoScalingGroupsCommand({
         InstanceIds: [this.instanceId]
-      }, (err, data) => {
-        if (err) {
+      }))
+        .then((data) => {
+          this.logger.info({data}, 'SnsNotifier: describeInstance');
+          return resolve(data);
+        })
+        .catch((err) => {
           this.logger.error({err}, 'Error describing instances');
           reject(err);
-        } else {
-          this.logger.info({data}, 'SnsNotifier: describeInstance');
-          resolve(data);
-        }
-      });
+        });
     });
   }
 
@@ -188,7 +214,7 @@ module.exports = async function(logger) {
   process.on('SIGHUP', async() => {
     try {
       const data = await notifier.describeInstance();
-      const state = data.AutoScalingInstances[0].LifecycleState;
+      const state = data.AutoScalingGroups[0].Instances[0].LifecycleState;
       if (state !== notifier.lifecycleState) {
         notifier.lifecycleState = state;
         switch (state) {

lib/utils/background-task-manager.js

@@ -0,0 +1,221 @@
+const { normalizeJambones } = require('@jambonz/verb-specifications');
+const makeTask = require('../tasks/make_task');
+const { JAMBONZ_RECORD_WS_BASE_URL, JAMBONZ_RECORD_WS_USERNAME, JAMBONZ_RECORD_WS_PASSWORD } = require('../config');
+const Emitter = require('events');
+
+class BackgroundTaskManager extends Emitter {
+  constructor({cs, logger, rootSpan}) {
+    super();
+    this.tasks = new Map();
+    this.cs = cs;
+    this.logger = logger;
+    this.rootSpan = rootSpan;
+  }
+
+  isTaskRunning(type) {
+    return this.tasks.has(type);
+  }
+
+  getTask(type) {
+    if (this.tasks.has(type)) {
+      return this.tasks.get(type);
+    }
+  }
+
+  count() {
+    return this.tasks.size;
+  }
+
+  async newTask(type, opts, sticky = false) {
+    this.logger.info({opts}, `initiating Background task ${type}`);
+    if (this.tasks.has(type)) {
+      this.logger.info(`Background task ${type} is running, skipped`);
+      return;
+    }
+    let task;
+    switch (type) {
+      case 'listen':
+        task = await this._initListen(opts);
+        break;
+      case 'bargeIn':
+        task = await this._initBargeIn(opts);
+        break;
+      case 'record':
+        task = await this._initRecord();
+        break;
+      case 'transcribe':
+        task = await this._initTranscribe(opts);
+        break;
+      case 'ttsStream':
+        task = await this._initTtsStream(opts);
+        break;
+      default:
+        break;
+    }
+    if (task) {
+      this.tasks.set(type, task);
+    }
+    if (task && sticky) task.sticky = true;
+    return task;
+  }
+
+  stop(type) {
+    const task = this.getTask(type);
+    if (task) {
+      this.logger.info(`stopping background task: ${type}`);
+      task.removeAllListeners();
+      task.span.end();
+      task.kill(this.cs);
+      // Remove task from managed List
+      this.tasks.delete(type);
+    }
+  }
+
+  stopAll() {
+    this.logger.debug('BackgroundTaskManager:stopAll');
+    for (const key of this.tasks.keys()) {
+      this.stop(key);
+    }
+  }
+
+  // Initiate Listen
+  async _initListen(opts, bugname = 'jambonz-background-listen', ignoreCustomerData = false, type = 'listen') {
+    let task;
+    try {
+      const t = normalizeJambones(this.logger, [opts]);
+      task = makeTask(this.logger, t[0]);
+      task.bugname = bugname;
+      task.ignoreCustomerData = ignoreCustomerData;
+      const resources = await this.cs._evaluatePreconditions(task);
+      const {span, ctx} = this.rootSpan.startChildSpan(`background-${type}:${task.summary}`);
+      task.span = span;
+      task.ctx = ctx;
+      task.exec(this.cs, resources)
+        .then(this._taskCompleted.bind(this, type, task))
+        .catch(this._taskError.bind(this, type, task));
+    } catch (err) {
+      this.logger.info({err, opts}, `BackgroundTaskManager:_initListen - Error creating ${bugname} task`);
+    }
+    return task;
+  }
+
+  // Initiate Gather
+  async _initBargeIn(opts) {
+    let task;
+    try {
+      const copy = JSON.parse(JSON.stringify(opts));
+      const t = normalizeJambones(this.logger, [opts]);
+      task = makeTask(this.logger, t[0]);
+      task
+        .once('dtmf', this._bargeInTaskCompleted.bind(this))
+        .once('vad', this._bargeInTaskCompleted.bind(this))
+        .once('transcription', this._bargeInTaskCompleted.bind(this))
+        .once('timeout', this._bargeInTaskCompleted.bind(this));
+      const resources = await this.cs._evaluatePreconditions(task);
+      const {span, ctx} = this.rootSpan.startChildSpan(`background-bargeIn:${task.summary}`);
+      task.span = span;
+      task.ctx = ctx;
+      task.bugname_prefix = 'background_bargeIn_';
+      task.exec(this.cs, resources)
+        .then(() => {
+          this._taskCompleted('bargeIn', task);
+          if (task.sticky && !this.cs.callGone && !this.cs._stopping) {
+            this.logger.info('BackgroundTaskManager:_initBargeIn: restarting background bargeIn');
+            this._bargeInHandled = false;
+            this.newTask('bargeIn', copy, true);
+          }
+          return;
+        })
+        .catch(this._taskError.bind(this, 'bargeIn', task));
+    } catch (err) {
+      this.logger.info(err, 'BackgroundTaskManager:_initGather - Error creating bargeIn task');
+    }
+    return task;
+  }
+
+  // Initiate Record
+  async _initRecord() {
+    if (this.cs.accountInfo.account.record_all_calls || this.cs.application.record_all_calls) {
+      if (!JAMBONZ_RECORD_WS_BASE_URL || !this.cs.accountInfo.account.bucket_credential) {
+        this.logger.error('_initRecord: invalid cfg - missing JAMBONZ_RECORD_WS_BASE_URL or bucket config');
+        return undefined;
+      }
+      const listenOpts = {
+        url: `${JAMBONZ_RECORD_WS_BASE_URL}/record/${this.cs.accountInfo.account.bucket_credential.vendor}`,
+        disableBidirectionalAudio: true,
+        mixType : 'stereo',
+        passDtmf: true
+      };
+      if (JAMBONZ_RECORD_WS_USERNAME && JAMBONZ_RECORD_WS_PASSWORD) {
+        listenOpts.wsAuth = {
+          username: JAMBONZ_RECORD_WS_USERNAME,
+          password: JAMBONZ_RECORD_WS_PASSWORD
+        };
+      }
+      this.logger.debug({listenOpts}, '_initRecord: enabling listen');
+      return await this._initListen({verb: 'listen', ...listenOpts}, 'jambonz-session-record', true, 'record');
+    }
+  }
+
+  // Initiate Transcribe
+  async _initTranscribe(opts) {
+    let task;
+    try {
+      const t = normalizeJambones(this.logger, [opts]);
+      task = makeTask(this.logger, t[0]);
+      const resources = await this.cs._evaluatePreconditions(task);
+      const {span, ctx} = this.rootSpan.startChildSpan(`background-transcribe:${task.summary}`);
+      task.span = span;
+      task.ctx = ctx;
+      task.bugname_prefix = 'background_transcribe_';
+      task.exec(this.cs, resources)
+        .then(this._taskCompleted.bind(this, 'transcribe', task))
+        .catch(this._taskError.bind(this, 'transcribe', task));
+    } catch (err) {
+      this.logger.info(err, 'BackgroundTaskManager:_initTranscribe - Error creating transcribe task');
+    }
+    return task;
+  }
+
+  // Initiate Tts Stream
+  async _initTtsStream(opts) {
+    let task;
+    try {
+      const t = normalizeJambones(this.logger, [opts]);
+      task = makeTask(this.logger, t[0]);
+      const resources = await this.cs._evaluatePreconditions(task);
+      const {span, ctx} = this.rootSpan.startChildSpan(`background-ttsStream:${task.summary}`);
+      task.span = span;
+      task.ctx = ctx;
+      task.exec(this.cs, resources)
+        .then(this._taskCompleted.bind(this, 'ttsStream', task))
+        .catch(this._taskError.bind(this, 'ttsStream', task));
+    } catch (err) {
+      this.logger.info(err, 'BackgroundTaskManager:_initTtsStream - Error creating ttsStream task');
+    }
+    return task;
+  }
+
+  _taskCompleted(type, task) {
+    this.logger.debug({type, task}, `BackgroundTaskManager:_taskCompleted: task completed, sticky: ${task.sticky}`);
+    task.removeAllListeners();
+    task.span.end();
+    this.tasks.delete(type);
+  }
+  _taskError(type, task, error) {
+    this.logger.info({type, task, error}, 'BackgroundTaskManager:_taskError: task Error');
+    task.removeAllListeners();
+    task.span.end();
+    this.tasks.delete(type);
+  }
+
+  _bargeInTaskCompleted(evt) {
+    if (this._bargeInHandled) return;
+    this._bargeInHandled = true;
+    this.logger.debug({evt},
+      'BackgroundTaskManager:_bargeInTaskCompleted on event from background bargeIn, emitting bargein-done event');
+    this.emit('bargeIn-done', evt);
+  }
+}
+
+module.exports = BackgroundTaskManager;

lib/utils/base-requestor.js

@@ -1,7 +1,9 @@
 const assert = require('assert');
 const Emitter = require('events');
 const crypto = require('crypto');
+const parseUrl = require('parse-url');
 const timeSeries = require('@jambonz/time-series');
+const {NODE_ENV, JAMBONES_TIME_SERIES_HOST} = require('../config');
 let alerter ;
 
 class BaseRequestor extends Emitter {
@@ -20,15 +22,23 @@ class BaseRequestor extends Emitter {
     const {stats} = require('../../').srf.locals;
     this.stats = stats;
 
+    const u = this._parsedUrl = parseUrl(this.url);
+    if (u.port) this._baseUrl = `${u.protocol}://${u.resource}:${u.port}`;
+    else this._baseUrl = `${u.protocol}://${u.resource}`;
+
     if (!alerter) {
       alerter = timeSeries(logger, {
-        host: process.env.JAMBONES_TIME_SERIES_HOST,
+        host: JAMBONES_TIME_SERIES_HOST,
         commitSize: 50,
-        commitInterval: 'test' === process.env.NODE_ENV ? 7 : 20
+        commitInterval: 'test' === NODE_ENV ? 7 : 20
       });
     }
   }
 
+  get baseUrl() {
+    return this._baseUrl;
+  }
+
   get Alerter() {
     return alerter;
   }
@@ -69,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;

lib/utils/call-tracer.js

@@ -2,17 +2,24 @@ const {context, trace} = require('@opentelemetry/api');
 const {Dialog} = require('drachtio-srf');
 class RootSpan {
   constructor(callType, req) {
-    let tracer, callSid, linkedSpanId;
+    const {srf} = require('../../');
+    const tracer = srf.locals.otel.tracer;
+    let callSid, accountSid, applicationSid, linkedSpanId;
 
     if (req instanceof Dialog) {
       const dlg = req;
-      tracer = dlg.srf.locals.otel.tracer;
       callSid = dlg.callSid;
       linkedSpanId = dlg.linkedSpanId;
     }
-    else {
-      tracer = req.srf.locals.otel.tracer;
+    else if (req.srf) {
       callSid = req.locals.callSid;
+      accountSid = req.get('X-Account-Sid'),
+      applicationSid = req.locals.application_sid;
+    }
+    else {
+      callSid = req.callSid;
+      accountSid = req.accountSid;
+      applicationSid = req.applicationSid;
     }
     this._span = tracer.startSpan(callType || 'incoming-call');
     if (req instanceof Dialog) {
@@ -22,13 +29,20 @@ class RootSpan {
         callId: dlg.sip.callId
       });
     }
+    else if (req.srf) {
+      this._span.setAttributes({
+        callSid,
+        accountSid,
+        applicationSid,
+        callId: req.get('Call-ID'),
+        externalCallId: req.get('X-CID')
+      });
+    }
     else {
       this._span.setAttributes({
         callSid,
-        accountSid: req.get('X-Account-Sid'),
-        applicationSid: req.locals.application_sid,
-        callId: req.get('Call-ID'),
-        externalCallId: req.get('X-CID')
+        accountSid,
+        applicationSid
       });
     }
 

lib/utils/constants.json

@@ -1,18 +1,21 @@
 {
   "TaskName": {
-    "Cognigy": "cognigy",
+    "Alert": "alert",
+    "Answer": "answer",
     "Conference": "conference",
     "Config": "config",
     "Dequeue": "dequeue",
     "Dial": "dial",
     "Dialogflow": "dialogflow",
     "Dtmf": "dtmf",
+    "Dub": "dub",
     "Enqueue": "enqueue",
     "Gather": "gather",
     "Hangup": "hangup",
     "Leave": "leave",
     "Lex": "lex",
     "Listen": "listen",
+    "Llm": "llm",
     "Message": "message",
     "Pause": "pause",
     "Play": "play",
@@ -26,10 +29,12 @@
     "SipRedirect": "sip:redirect",
     "Say": "say",
     "SayLegacy": "say:legacy",
+    "Stream": "stream",
     "Tag": "tag",
     "Transcribe": "transcribe"
   },
-  "AllowedSipRecVerbs": ["config", "gather", "transcribe", "listen"],
+  "AllowedSipRecVerbs": ["answer", "config", "gather", "transcribe", "listen", "tag", "hangup", "sip:decline"],
+  "AllowedConfirmSessionVerbs": ["config", "gather", "plays", "say", "tag"],
   "CallStatus": {
     "Trying": "trying",
     "Ringing": "ringing",
@@ -51,6 +56,11 @@
     "Silence": "silence",
     "Resume": "resume"
   },
+  "TranscribeStatus": {
+    "Pause": "pause",
+    "Silence": "silence",
+    "Resume": "resume"
+  },
   "TaskPreconditions": {
     "None": "none",
     "Endpoint": "endpoint",
@@ -67,6 +77,49 @@
     "MaxDurationExceeded": "google_transcribe::max_duration_exceeded",
     "VadDetected": "google_transcribe::vad_detected"
   },
+  "NuanceTranscriptionEvents": {
+    "Transcription": "nuance_transcribe::transcription",
+    "StartOfSpeech": "nuance_transcribe::start_of_speech",
+    "TranscriptionComplete": "nuance_transcribe::end_of_transcription",
+    "Error": "nuance_transcribe::error",
+    "VadDetected": "nuance_transcribe::vad_detected"
+  },
+  "NvidiaTranscriptionEvents": {
+    "Transcription": "nvidia_transcribe::transcription",
+    "StartOfSpeech": "nvidia_transcribe::start_of_speech",
+    "TranscriptionComplete": "nvidia_transcribe::end_of_transcription",
+    "Error": "nvidia_transcribe::error",
+    "VadDetected": "nvidia_transcribe::vad_detected"
+  },
+  "DeepgramTranscriptionEvents": {
+    "Transcription": "deepgram_transcribe::transcription",
+    "ConnectFailure": "deepgram_transcribe::connect_failed",
+    "Connect": "deepgram_transcribe::connect"
+  },
+  "DeepgramRiverTranscriptionEvents": {
+    "Transcription": "deepgramriver_transcribe::transcription",
+    "ConnectFailure": "deepgramriver_transcribe::connect_failed",
+    "Connect": "deepgramriver_transcribe::connect"
+  },
+  "SonioxTranscriptionEvents": {
+    "Transcription": "soniox_transcribe::transcription",
+    "Error": "soniox_transcribe::error"
+  },
+  "VerbioTranscriptionEvents": {
+    "Transcription": "verbio_transcribe::transcription",
+    "Error": "verbio_transcribe::error"
+  },
+  "CobaltTranscriptionEvents": {
+    "Transcription": "cobalt_speech::transcription",
+    "CompileContext": "cobalt_speech::compile_context_response",
+    "Error": "cobalt_speech::error"
+  },
+  "IbmTranscriptionEvents": {
+    "Transcription": "ibm_transcribe::transcription",
+    "ConnectFailure": "ibm_transcribe::connect_failed",
+    "Connect": "ibm_transcribe::connect",
+    "Error": "ibm_transcribe::error"
+  },
   "AwsTranscriptionEvents": {
     "Transcription": "aws_transcribe::transcription",
     "EndOfTranscript": "aws_transcribe::end_of_transcript",
@@ -81,6 +134,57 @@
     "NoSpeechDetected": "azure_transcribe::no_speech_detected",
     "VadDetected": "azure_transcribe::vad_detected"
   },
+  "SpeechmaticsTranscriptionEvents": {
+    "Transcription": "speechmatics_transcribe::transcription",
+    "Translation": "speechmatics_transcribe::translation",
+    "Info": "speechmatics_transcribe::info",
+    "RecognitionStarted": "speechmatics_transcribe::recognition_started",
+    "ConnectFailure": "speechmatics_transcribe::connect_failed",
+    "Connect": "speechmatics_transcribe::connect",
+    "Error": "speechmatics_transcribe::error"
+  },
+  "OpenAITranscriptionEvents": {
+    "Transcription": "openai_transcribe::transcription",
+    "Translation": "openai_transcribe::translation",
+    "SpeechStarted": "openai_transcribe::speech_started",
+    "SpeechStopped": "openai_transcribe::speech_stopped",
+    "PartialTranscript": "openai_transcribe::partial_transcript",
+    "Info": "openai_transcribe::info",
+    "RecognitionStarted": "openai_transcribe::recognition_started",
+    "ConnectFailure": "openai_transcribe::connect_failed",
+    "Connect": "openai_transcribe::connect",
+    "Error": "openai_transcribe::error"
+  },
+  "JambonzTranscriptionEvents": {
+    "Transcription": "jambonz_transcribe::transcription",
+    "ConnectFailure": "jambonz_transcribe::connect_failed",
+    "Connect": "jambonz_transcribe::connect",
+    "Error": "jambonz_transcribe::error"
+  },
+  "AssemblyAiTranscriptionEvents": {
+    "Transcription": "assemblyai_transcribe::transcription",
+    "Error": "assemblyai_transcribe::error",
+    "ConnectFailure": "assemblyai_transcribe::connect_failed",
+    "Connect": "assemblyai_transcribe::connect"
+  },
+  "VoxistTranscriptionEvents": {
+    "Transcription": "voxist_transcribe::transcription",
+    "Error": "voxist_transcribe::error",
+    "ConnectFailure": "voxist_transcribe::connect_failed",
+    "Connect": "voxist_transcribe::connect"
+  },
+  "CartesiaTranscriptionEvents": {
+    "Transcription": "cartesia_transcribe::transcription",
+    "Error": "cartesia_transcribe::error",
+    "ConnectFailure": "cartesia_transcribe::connect_failed",
+    "Connect": "cartesia_transcribe::connect"
+  },
+  "VadDetection": {
+    "Detection": "vad_detect:detection"
+  },
+  "SileroVadDetection": {
+    "Detection": "vad_silero:detect"
+  },
   "ListenEvents": {
     "Connect": "mod_audio_fork::connect",
     "ConnectFailure": "mod_audio_fork::connect_failed",
@@ -98,6 +202,41 @@
     "StandbyEnter": "standby-enter",
     "StandbyExit": "standby-exit"
   },
+  "LlmEvents_OpenAI": {
+    "Error": "error",
+    "Connect": "openai_s2s::connect",
+    "ConnectFailure": "openai_s2s::connect_failed",
+    "Disconnect": "openai_s2s::disconnect",
+    "ServerEvent": "openai_s2s::server_event"
+  },
+  "LlmEvents_Google": {
+    "Error": "error",
+    "Connect": "google_s2s::connect",
+    "ConnectFailure": "google_s2s::connect_failed",
+    "Disconnect": "google_s2s::disconnect",
+    "ServerEvent": "google_s2s::server_event"
+  },
+  "LlmEvents_Elevenlabs": {
+    "Error": "error",
+    "Connect": "elevenlabs_s2s::connect",
+    "ConnectFailure": "elevenlabs_s2s::connect_failed",
+    "Disconnect": "elevenlabs_s2s::disconnect",
+    "ServerEvent": "elevenlabs_s2s::server_event"
+  },
+  "LlmEvents_VoiceAgent": {
+    "Error": "error",
+    "Connect": "voice_agent_s2s::connect",
+    "ConnectFailure": "voice_agent_s2s::connect_failed",
+    "Disconnect": "voice_agent_s2s::disconnect",
+    "ServerEvent": "voice_agent_s2s::server_event"
+  },
+  "LlmEvents_Ultravox": {
+    "Error": "error",
+    "Connect": "ultravox_s2s::connect",
+    "ConnectFailure": "ultravox_s2s::connect_failed",
+    "Disconnect": "ultravox_s2s::disconnect",
+    "ServerEvent": "ultravox_s2s::server_event"
+  },
   "QueueResults": {
     "Bridged": "bridged",
     "Error": "error",
@@ -112,16 +251,24 @@
   },
   "KillReason": {
     "Hangup": "hangup",
-    "Replaced": "replaced"
+    "Replaced": "replaced",
+    "ReferComplete": "refer-complete",
+    "MediaTimeout": "media_timeout"
   },
   "HookMsgTypes": [
     "session:new",
     "session:reconnect",
     "session:redirect",
+    "session:adulting",
     "call:status",
     "queue:status",
     "dial:confirm",
     "verb:hook",
+    "verb:status",
+    "llm:event",
+    "llm:tool-call",
+    "tts:tokens-result",
+    "tts:streaming-event",
     "jambonz:error"
   ],
   "RecordState": {
@@ -140,7 +287,59 @@
     "ToneTimeout": "amd_tone_timeout",
     "Stopped": "amd_stopped"
   },
+  "MediaPath": {
+    "NoMedia": "no-media",
+    "PartialMedia": "partial-media",
+    "FullMedia": "full-media"
+  },
+  "DeepgramTtsStreamingEvents": {
+    "Empty": "deepgram_tts_streaming::empty",
+    "ConnectFailure": "deepgram_tts_streaming::connect_failed",
+    "Connect": "deepgram_tts_streaming::connect"
+  },
+  "CartesiaTtsStreamingEvents": {
+    "Empty": "cartesia_tts_streaming::empty",
+    "ConnectFailure": "cartesia_tts_streaming::connect_failed",
+    "Connect": "cartesia_tts_streaming::connect"
+  },
+  "ElevenlabsTtsStreamingEvents": {
+    "Empty": "elevenlabs_tts_streaming::empty",
+    "ConnectFailure": "elevenlabs_tts_streaming::connect_failed",
+    "Connect": "elevenlabs_tts_streaming::connect"
+  },
+  "RimelabsTtsStreamingEvents": {
+    "Empty": "rimelabs_tts_streaming::empty",
+    "ConnectFailure": "rimelabs_tts_streaming::connect_failed",
+    "Connect": "rimelabs_tts_streaming::connect"
+  },
+  "CustomTtsStreamingEvents": {
+    "Empty": "custom_tts_streaming::empty",
+    "ConnectFailure": "custom_tts_streaming::connect_failed",
+    "Connect": "custom_tts_streaming::connect"
+  },
+  "TtsStreamingEvents": {
+    "Empty": "tts_streaming::empty",
+    "Pause": "tts_streaming::pause",
+    "Resume": "tts_streaming::resume",
+    "ConnectFailure": "tts_streaming::connect_failed"
+  },
+  "TtsStreamingConnectionStatus": {
+    "NotConnected": "not_connected",
+    "Connected": "connected",
+    "Connecting": "connecting",
+    "Failed": "failed"
+  },
   "MAX_SIMRINGS": 10,
   "BONG_TONE": "tone_stream://v=-7;%(100,0,941.0,1477.0);v=-7;>=2;+=.1;%(1400,0,350,440)",
-  "FS_UUID_SET_NAME": "fsUUIDs"
+  "FS_UUID_SET_NAME": "fsUUIDs",
+  "SystemState" : {
+    "Online": "ONLINE",
+    "Offline": "OFFLINE",
+    "GracefulShutdownInProgress":"SHUTDOWN_IN_PROGRESS"
+  },
+  "FEATURE_SERVER" : "feature-server",
+  "WS_CLOSE_CODES": {
+    "NormalClosure": 1000,
+    "GoingAway": 1001
+  }
 }

lib/utils/cron-jobs.js

@@ -1,19 +1,24 @@
 const {execSync} = require('child_process');
+const {
+  JAMBONES_FREESWITCH,
+  NODE_ENV,
+  JAMBONES_FREESWITCH_MAX_CALL_DURATION_MINS,
+} = require('../config');
 const now = Date.now();
-const fsInventory = process.env.JAMBONES_FREESWITCH
+const fsInventory = JAMBONES_FREESWITCH
   .split(',')
   .map((fs) => {
     const arr = /^([^:]*):([^:]*):([^:]*)(?::([^:]*))?/.exec(fs);
     const opts = {address: arr[1], port: arr[2], secret: arr[3]};
     if (arr.length > 4) opts.advertisedAddress = arr[4];
-    if (process.env.NODE_ENV === 'test') opts.listenAddress = '0.0.0.0';
+    if (NODE_ENV === 'test') opts.listenAddress = '0.0.0.0';
     return opts;
   });
 
 const clearChannels = () => {
   const {logger} = require('../..');
   const pwd = fsInventory[0].secret;
-  const maxDurationMins = process.env.JAMBONES_FREESWITCH_MAX_CALL_DURATION_MINS || 180;
+  const maxDurationMins = JAMBONES_FREESWITCH_MAX_CALL_DURATION_MINS;
 
   const calls = execSync(`/usr/local/freeswitch/bin/fs_cli -p ${pwd} -x "show calls"`, {encoding: 'utf8'})
     .split('\n')

lib/utils/db-utils.js

@@ -3,13 +3,10 @@ const {decrypt} = require('./encrypt-decrypt');
 const sqlAccountDetails = `SELECT * 
 FROM accounts account 
 WHERE account.account_sid = ?`;
-const sqlSpeechCredentials = `SELECT * 
+const sqlSpeechCredentialsForAccount = `SELECT * 
 FROM speech_credentials 
-WHERE account_sid = ? `;
-const sqlSpeechCredentialsForSP = `SELECT * 
-FROM speech_credentials 
-WHERE service_provider_sid =  
-(SELECT service_provider_sid from accounts where account_sid = ?)`;
+WHERE account_sid = ? OR (account_sid is NULL AND service_provider_sid =  
+(SELECT service_provider_sid from accounts where account_sid = ?))`;
 const sqlQueryAccountCarrierByName = `SELECT voip_carrier_sid  
 FROM voip_carriers vc 
 WHERE vc.account_sid = ? 
@@ -20,6 +17,19 @@ WHERE vc.account_sid IS NULL
 AND vc.service_provider_sid = 
 (SELECT service_provider_sid from accounts where account_sid = ?) 
 AND vc.name = ?`;
+const sqlQueryAccountPhoneNumber = `SELECT voip_carrier_sid 
+FROM phone_numbers pn
+WHERE pn.account_sid = ?
+AND pn.number = ?`;
+const sqlQuerySPPhoneNumber = `SELECT voip_carrier_sid  
+FROM phone_numbers pn 
+WHERE pn.account_sid IS NULL 
+AND pn.service_provider_sid = 
+(SELECT service_provider_sid from accounts where account_sid = ?) 
+AND pn.number = ?`;
+const sqlQueryGoogleCustomVoices = `SELECT *
+FROM google_custom_voices
+WHERE google_custom_voice_sid = ?`;
 
 const speechMapper = (cred) => {
   const {credential, ...obj} = cred;
@@ -31,6 +41,7 @@ const speechMapper = (cred) => {
       const o = JSON.parse(decrypt(credential));
       obj.access_key_id = o.access_key_id;
       obj.secret_access_key = o.secret_access_key;
+      obj.role_arn = o.role_arn;
       obj.aws_region = o.aws_region;
     }
     else if ('microsoft' === obj.vendor) {
@@ -39,61 +50,163 @@ const speechMapper = (cred) => {
       obj.region = o.region;
       obj.use_custom_stt = o.use_custom_stt;
       obj.custom_stt_endpoint = o.custom_stt_endpoint;
+      obj.custom_stt_endpoint_url = o.custom_stt_endpoint_url;
+      obj.use_custom_tts = o.use_custom_tts;
+      obj.custom_tts_endpoint = o.custom_tts_endpoint;
+      obj.custom_tts_endpoint_url = o.custom_tts_endpoint_url;
     }
     else if ('wellsaid' === obj.vendor) {
       const o = JSON.parse(decrypt(credential));
       obj.api_key = o.api_key;
     }
+    else if ('nuance' === obj.vendor) {
+      const o = JSON.parse(decrypt(credential));
+      obj.client_id = o.client_id;
+      obj.secret = o.secret;
+      obj.nuance_tts_uri = o.nuance_tts_uri;
+      obj.nuance_stt_uri = o.nuance_stt_uri;
+    }
+    else if ('ibm' === obj.vendor) {
+      const o = JSON.parse(decrypt(credential));
+      obj.tts_api_key = o.tts_api_key;
+      obj.tts_region = o.tts_region;
+      obj.stt_api_key = o.stt_api_key;
+      obj.stt_region = o.stt_region;
+    }
+    else if ('deepgram' === obj.vendor) {
+      const o = JSON.parse(decrypt(credential));
+      obj.api_key = o.api_key;
+      obj.model_id = o.model_id;
+      obj.deepgram_stt_uri = o.deepgram_stt_uri;
+      obj.deepgram_tts_uri = o.deepgram_tts_uri;
+      obj.deepgram_stt_use_tls = o.deepgram_stt_use_tls;
+    }
+    else if ('deepgramriver' === obj.vendor) {
+      const o = JSON.parse(decrypt(credential));
+      obj.api_key = o.api_key;
+    }
+    else if ('soniox' === obj.vendor) {
+      const o = JSON.parse(decrypt(credential));
+      obj.api_key = o.api_key;
+    }
+    else if ('nvidia' === obj.vendor) {
+      const o = JSON.parse(decrypt(credential));
+      obj.riva_server_uri = o.riva_server_uri;
+    }
+    else if ('cobalt' === obj.vendor) {
+      const o = JSON.parse(decrypt(credential));
+      obj.cobalt_server_uri = o.cobalt_server_uri;
+    }
+    else if ('elevenlabs' === 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 ('playht' === obj.vendor) {
+      const o = JSON.parse(decrypt(credential));
+      obj.api_key = o.api_key;
+      obj.user_id = o.user_id;
+      obj.voice_engine = o.voice_engine;
+      obj.options = o.options;
+    }
+    else if ('cartesia' === obj.vendor) {
+      const o = JSON.parse(decrypt(credential));
+      obj.api_key = o.api_key;
+      obj.model_id = o.model_id;
+      obj.stt_model_id = o.stt_model_id;
+      obj.embedding = o.embedding;
+      obj.options = o.options;
+    }
+    else if ('rimelabs' === obj.vendor) {
+      const o = JSON.parse(decrypt(credential));
+      obj.api_key = o.api_key;
+      obj.model_id = o.model_id;
+      obj.options = o.options;
+    }
+    else if ('resemble' === obj.vendor) {
+      const o = JSON.parse(decrypt(credential));
+      obj.api_key = o.api_key;
+      obj.resemble_tts_use_tls = o.resemble_tts_use_tls;
+      obj.resemble_tts_uri = o.resemble_tts_uri;
+    }
+    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));
+      obj.api_key = o.api_key;
+    }
+    else if ('whisper' === obj.vendor) {
+      const o = JSON.parse(decrypt(credential));
+      obj.api_key = o.api_key;
+      obj.model_id = o.model_id;
+    }
+    else if ('verbio' === obj.vendor) {
+      const o = JSON.parse(decrypt(credential));
+      obj.client_id = o.client_id;
+      obj.client_secret = o.client_secret;
+      obj.engine_version = o.engine_version;
+    }
+    else if ('speechmatics' === obj.vendor) {
+      const o = JSON.parse(decrypt(credential));
+      obj.api_key = o.api_key;
+      obj.speechmatics_stt_uri = o.speechmatics_stt_uri;
+    }
+    else if ('openai' === obj.vendor) {
+      const o = JSON.parse(decrypt(credential));
+      obj.api_key = o.api_key;
+      obj.model_id = o.model_id;
+    }
+    else if (obj.vendor.startsWith('custom:')) {
+      const o = JSON.parse(decrypt(credential));
+      obj.auth_token = o.auth_token;
+      obj.custom_stt_url = o.custom_stt_url;
+      obj.custom_tts_url = o.custom_tts_url;
+      obj.custom_tts_streaming_url = o.custom_tts_streaming_url;
+    }
   } catch (err) {
+    console.log(err);
   }
   return obj;
 };
 
+const bucketCredentialDecrypt = (account) => {
+  const { bucket_credential } = account.account;
+  if (!bucket_credential || bucket_credential.vendor) return;
+  account.account.bucket_credential = JSON.parse(decrypt(bucket_credential));
+};
+
 module.exports = (logger, srf) => {
   const {pool}  = srf.locals.dbHelpers;
   const pp = pool.promise();
 
   const lookupAccountDetails = async(account_sid) => {
 
-    const [r] = await pp.query({sql: sqlAccountDetails, nestTables: true}, account_sid);
+    const [r] = await pp.query({sql: sqlAccountDetails, nestTables: true}, [account_sid]);
     if (0 === r.length) throw new Error(`invalid accountSid: ${account_sid}`);
-    const [r2] = await pp.query(sqlSpeechCredentials, account_sid);
+    const [r2] = await pp.query(sqlSpeechCredentialsForAccount, [account_sid, account_sid]);
     const speech = r2.map(speechMapper);
 
-    /* search at the service provider level if we don't find it at the account level */
-    const haveGoogle = speech.find((s) => s.vendor === 'google');
-    const haveAws = speech.find((s) => s.vendor === 'aws');
-    const haveMicrosoft = speech.find((s) => s.vendor === 'microsoft');
-    const haveWellsaid = speech.find((s) => s.vendor === 'wellsaid');
-    if (!haveGoogle || !haveAws || !haveMicrosoft) {
-      const [r3] = await pp.query(sqlSpeechCredentialsForSP, account_sid);
-      if (r3.length) {
-        if (!haveGoogle) {
-          const google = r3.find((s) => s.vendor === 'google');
-          if (google) speech.push(speechMapper(google));
-        }
-        if (!haveAws) {
-          const aws = r3.find((s) => s.vendor === 'aws');
-          if (aws) speech.push(speechMapper(aws));
-        }
-        if (!haveMicrosoft) {
-          const ms = r3.find((s) => s.vendor === 'microsoft');
-          if (ms) speech.push(speechMapper(ms));
-        }
-        if (!haveWellsaid) {
-          const wellsaid = r3.find((s) => s.vendor === 'wellsaid');
-          if (wellsaid) speech.push(speechMapper(wellsaid));
-        }
-      }
-    }
+    const account = r[0];
+    bucketCredentialDecrypt(account);
 
     return {
-      ...r[0],
+      ...account,
       speech
     };
   };
 
   const updateSpeechCredentialLastUsed = async(speech_credential_sid) => {
+    if (!speech_credential_sid) return;
     const pp = pool.promise();
     const sql = 'UPDATE speech_credentials SET last_used = NOW() WHERE speech_credential_sid = ?';
     try {
@@ -115,9 +228,46 @@ module.exports = (logger, srf) => {
     }
   };
 
+  const lookupCarrierByPhoneNumber = async(account_sid, phoneNumber) => {
+    const pp = pool.promise();
+    try {
+      const [r] = await pp.query(sqlQueryAccountPhoneNumber, [account_sid, phoneNumber]);
+      if (r.length) return r[0].voip_carrier_sid;
+      const [r2] = await pp.query(sqlQuerySPPhoneNumber, [account_sid, phoneNumber]);
+      if (r2.length) return r2[0].voip_carrier_sid;
+    } catch (err) {
+      logger.error({err}, `lookupPhoneNumber: Error ${account_sid}:${phoneNumber}`);
+    }
+  };
+
+  const lookupGoogleCustomVoice = async(google_custom_voice_sid) => {
+    const pp = pool.promise();
+    try {
+      const [r] = await pp.query(sqlQueryGoogleCustomVoices, [google_custom_voice_sid]);
+      return r;
+
+    } catch (err) {
+      logger.error({err}, `lookupGoogleCustomVoices: Error ${google_custom_voice_sid}`);
+    }
+  };
+
+  const lookupVoipCarrierBySid = async(sid) => {
+    const pp = pool.promise();
+    try {
+      const [r] = await pp.query('SELECT * FROM voip_carriers WHERE voip_carrier_sid = ?', [sid]);
+      return r;
+
+    } catch (err) {
+      logger.error({err}, `lookupVoipCarrierBySid: Error ${sid}`);
+    }
+  };
+
   return {
     lookupAccountDetails,
     updateSpeechCredentialLastUsed,
-    lookupCarrier
+    lookupCarrier,
+    lookupCarrierByPhoneNumber,
+    lookupGoogleCustomVoice,
+    lookupVoipCarrierBySid
   };
 };

lib/utils/encrypt-decrypt.js

@@ -1,10 +1,11 @@
 const crypto = require('crypto');
-const algorithm = process.env.LEGACY_CRYPTO ? 'aes-256-ctr' : 'aes-256-cbc';
+const {LEGACY_CRYPTO, ENCRYPTION_SECRET, JWT_SECRET} = require('../config');
+const algorithm = LEGACY_CRYPTO ? 'aes-256-ctr' : 'aes-256-cbc';
 const iv = crypto.randomBytes(16);
 const secretKey = crypto.createHash('sha256')
-  .update(String(process.env.JWT_SECRET))
+  .update(ENCRYPTION_SECRET || JWT_SECRET)
   .digest('base64')
-  .substr(0, 32);
+  .substring(0, 32);
 
 const encrypt = (text) => {
   const cipher = crypto.createCipheriv(algorithm, secretKey, iv);
@@ -25,8 +26,8 @@ const decrypt = (data) => {
     throw err;
   }
   const decipher = crypto.createDecipheriv(algorithm, secretKey, Buffer.from(hash.iv, 'hex'));
-  const decrpyted = Buffer.concat([decipher.update(Buffer.from(hash.content, 'hex')), decipher.final()]);
-  return decrpyted.toString();
+  const decrypted = Buffer.concat([decipher.update(Buffer.from(hash.content, 'hex')), decipher.final()]);
+  return decrypted.toString();
 };
 
 module.exports = {

lib/utils/error.js

@@ -0,0 +1,33 @@
+class NonFatalTaskError extends Error {
+  constructor(msg) {
+    super(msg);
+  }
+}
+
+class SpeechCredentialError extends NonFatalTaskError {
+  constructor(msg) {
+    super(msg);
+  }
+}
+
+class PlayFileNotFoundError extends NonFatalTaskError {
+  constructor(url) {
+    super('File not found');
+    this.url = url;
+  }
+}
+
+class HTTPResponseError extends Error {
+  constructor(statusCode) {
+    super('Unexpected HTTP Response');
+    delete this.stack;
+    this.statusCode = statusCode;
+  }
+}
+
+module.exports = {
+  SpeechCredentialError,
+  NonFatalTaskError,
+  PlayFileNotFoundError,
+  HTTPResponseError
+};

lib/utils/helpers.js

@@ -0,0 +1,5 @@
+
+const sleepFor = (ms) => new Promise((resolve) => setTimeout(() => resolve(), ms));
+module.exports = {
+  sleepFor
+};

lib/utils/http-listener.js

@@ -1,26 +1,28 @@
 
 const express = require('express');
 const httpRoutes = require('../http-routes');
-const PORT = process.env.HTTP_PORT || 3000;
+const {PORT, HTTP_PORT_MAX} = require('../config');
 
 const doListen = (logger, app, port, resolve) => {
   const server = app.listen(port, () => {
     const {srf} = app.locals;
-    logger.info(`listening for HTTP requests on port ${PORT}, serviceUrl is ${srf.locals.serviceUrl}`);
+    srf.locals.serviceUrl = `http://${srf.locals.ipv4}:${port}`;
+    logger.info(`listening for HTTP requests on port ${port}, serviceUrl is ${srf.locals.serviceUrl}`);
     resolve({server, app});
   });
   return server;
 };
 const handleErrors = (logger, app, resolve, reject, e) => {
   if (e.code === 'EADDRINUSE' &&
-    process.env.HTTP_PORT_MAX &&
-    e.port < process.env.HTTP_PORT_MAX) {
+    HTTP_PORT_MAX &&
+    e.port < HTTP_PORT_MAX) {
 
     logger.info(`HTTP server failed to bind port on ${e.port}, will try next port`);
     const server = doListen(logger, app, ++e.port, resolve);
     server.on('error', handleErrors.bind(null, logger, app, resolve, reject));
     return;
   }
+  logger.info({err: e, port: PORT}, 'httpListener error');
   reject(e);
 };
 
@@ -30,7 +32,7 @@ const createHttpListener = (logger, srf) => {
   app.use(express.urlencoded({ extended: true }));
   app.use(express.json());
   app.use('/', httpRoutes);
-  app.use((err, req, res, next) => {
+  app.use((err, _req, res, _next) => {
     logger.error(err, 'burped error');
     res.status(err.status || 500).json({msg: err.message});
   });

lib/utils/http-requestor.js

@@ -1,11 +1,22 @@
-const {Client, Pool} = require('undici');
+const {request, getGlobalDispatcher, setGlobalDispatcher, Dispatcher, ProxyAgent, Client, Pool} = require('undici');
 const parseUrl = require('parse-url');
 const assert = require('assert');
 const BaseRequestor = require('./base-requestor');
 const {HookMsgTypes} = require('./constants.json');
 const snakeCaseKeys = require('./snakecase-keys');
 const pools = new Map();
-const HTTP_TIMEOUT = 10000;
+const {
+  HTTP_POOL,
+  HTTP_POOLSIZE,
+  HTTP_PIPELINING,
+  HTTP_TIMEOUT,
+  HTTP_PROXY_IP,
+  HTTP_PROXY_PORT,
+  HTTP_PROXY_PROTOCOL,
+  NODE_ENV,
+  HTTP_USER_AGENT_HEADER,
+} = require('../config');
+const {HTTPResponseError} = require('./error');
 
 const toBase64 = (str) => Buffer.from(str || '', 'utf8').toString('base64');
 
@@ -16,47 +27,65 @@ function basicAuth(username, password) {
   return {Authorization: header};
 }
 
+const defaultDispatcher = HTTP_PROXY_IP ?
+  new ProxyAgent(`${HTTP_PROXY_PROTOCOL}://${HTTP_PROXY_IP}${HTTP_PROXY_PORT ? `:${HTTP_PROXY_PORT}` : ''}`) :
+  getGlobalDispatcher();
+
+setGlobalDispatcher(new class extends Dispatcher {
+  dispatch(options, handler) {
+    return defaultDispatcher.dispatch(options, handler);
+  }
+}());
 
 class HttpRequestor extends BaseRequestor {
   constructor(logger, account_sid, hook, secret) {
     super(logger, account_sid, hook, secret);
 
-    this.method = hook.method || 'POST';
+    this.method = hook.method?.toUpperCase() || 'POST';
     this.authHeader = basicAuth(hook.username, hook.password);
+    this.backoffMs = 500;
 
     assert(this._isAbsoluteUrl(this.url));
     assert(['GET', 'POST'].includes(this.method));
 
     const u = this._parsedUrl = parseUrl(this.url);
-    if (u.port) this._baseUrl = `${u.protocol}://${u.resource}:${u.port}`;
-    else this._baseUrl = `${u.protocol}://${u.resource}`;
     this._protocol = u.protocol;
+    this._resource = u.resource;
+    this._port = u.port;
     this._search = u.search;
-    this._usePools = process.env.HTTP_POOL && parseInt(process.env.HTTP_POOL);
+    this._usePools = HTTP_POOL && parseInt(HTTP_POOL);
 
     if (this._usePools) {
-      if (pools.has(this._baseUrl)) {
-        this.client = pools.get(this._baseUrl);
+      if (pools.has(this.baseUrl)) {
+        this.client = pools.get(this.baseUrl);
       }
       else {
-        const connections = process.env.HTTP_POOLSIZE ? parseInt(process.env.HTTP_POOLSIZE) : 10;
-        const pipelining = process.env.HTTP_PIPELINING ? parseInt(process.env.HTTP_PIPELINING) : 1;
-        const pool = this.client = new Pool(this._baseUrl, {
+        const connections = HTTP_POOLSIZE ? parseInt(HTTP_POOLSIZE) : 10;
+        const pipelining = HTTP_PIPELINING ? parseInt(HTTP_PIPELINING) : 1;
+        const pool = this.client = new Pool(this.baseUrl, {
           connections,
           pipelining
         });
-        pools.set(this._baseUrl, pool);
-        this.logger.debug(`HttpRequestor:created pool for ${this._baseUrl}`);
+        pools.set(this.baseUrl, pool);
+        this.logger.debug(`HttpRequestor:created pool for ${this.baseUrl}`);
       }
     }
     else {
       if (u.port) this.client = new Client(`${u.protocol}://${u.resource}:${u.port}`);
       else this.client = new Client(`${u.protocol}://${u.resource}`);
     }
-  }
 
-  get baseUrl() {
-    return this._baseUrl;
+    if (NODE_ENV == 'test' && process.env.JAMBONES_HTTP_PROXY_IP) {
+      const defDispatcher =
+        new ProxyAgent(`${process.env.JAMBONES_HTTP_PROXY_PROTOCOL}://${process.env.JAMBONES_HTTP_PROXY_IP}${
+          process.env.JAMBONES_HTTP_PROXY_PORT ? `:${process.env.JAMBONES_HTTP_PROXY_PORT}` : ''}`);
+
+      setGlobalDispatcher(new class extends Dispatcher {
+        dispatch(options, handler) {
+          return defDispatcher.dispatch(options, handler);
+        }
+      }());
+    }
   }
 
   close() {
@@ -74,42 +103,80 @@ class HttpRequestor extends BaseRequestor {
    * @param {string} [hook.password] - if basic auth is protecting the endpoint
    * @param {object} [params] - request parameters
    */
-  async request(type, hook, params, httpHeaders = {}) {
+  async request(type, hook, params, httpHeaders = {}, span) {
     /* jambonz:error only sent over ws */
     if (type === 'jambonz:error') return;
 
     assert(HookMsgTypes.includes(type));
 
-    const payload = params ? snakeCaseKeys(params, ['customerData', 'sip']) : null;
+    const payload = params ? snakeCaseKeys(params, ['customerData', 'sip', 'env_vars', 'args']) : null;
     const url = hook.url || hook;
-    const method = hook.method || 'POST';
+    const method = hook.method?.toUpperCase() || 'POST';
     let buf = '';
+    httpHeaders = {
+      ...httpHeaders,
+      ...(HTTP_USER_AGENT_HEADER && {'user-agent' : HTTP_USER_AGENT_HEADER})
+    };
 
     assert.ok(url, 'HttpRequestor:request url was not provided');
-    assert.ok, (['GET', 'POST'].includes(method), `HttpRequestor:request method must be 'GET' or 'POST' not ${method}`);
+    assert.ok(['GET', 'POST'].includes(method), `HttpRequestor:request method must be 'GET' or 'POST' not ${method}`);
     const startAt = process.hrtime();
 
+    /* if we have an absolute url, and it is ws then do a websocket connection */
+    if (this._isAbsoluteUrl(url) && url.startsWith('ws')) {
+      const WsRequestor = require('./ws-requestor');
+      this.logger.debug({hook}, 'HttpRequestor: switching to websocket connection');
+      const h = typeof hook === 'object' ? hook : {url: hook};
+      const requestor = new WsRequestor(this.logger, this.account_sid, h, this.secret);
+      if (type === 'session:redirect') {
+        this.close();
+        this.emit('handover', requestor);
+      }
+      return requestor.request('session:new', hook, params, httpHeaders, span);
+    }
+
     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.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,
@@ -117,9 +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} =  await client.request({
+
+      const requestOptions = {
         path,
         query,
         method,
@@ -127,15 +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 Error();
-        err.statusCode = 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) {
@@ -164,10 +266,10 @@ class HttpRequestor extends BaseRequestor {
     const rtt = this._roundTrip(startAt);
     if (buf) this.stats.histogram('app.hook.response_time', rtt, ['hook_type:app']);
 
-    if (buf && Array.isArray(buf)) {
+    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;
   }
 }
 

lib/utils/install-srf-locals.js

@@ -1,20 +1,56 @@
 const Mrf = require('drachtio-fsmrf');
-const ip = require('ip');
-const PORT = process.env.HTTP_PORT || 3000;
+const os = require('os');
+const {
+  JAMBONES_MYSQL_HOST,
+  JAMBONES_MYSQL_USER,
+  JAMBONES_MYSQL_PASSWORD,
+  JAMBONES_MYSQL_DATABASE,
+  JAMBONES_MYSQL_CONNECTION_LIMIT,
+  JAMBONES_MYSQL_PORT,
+  JAMBONES_FREESWITCH,
+  SMPP_URL,
+  JAMBONES_TIME_SERIES_HOST,
+  JAMBONES_ESL_LISTEN_ADDRESS,
+  PORT,
+  HTTP_IP,
+  NODE_ENV,
+} = require('../config');
+const Registrar = require('@jambonz/mw-registrar');
 const assert = require('assert');
 
-function initMS(logger, wrapper, ms) {
+function getLocalIp() {
+  const interfaces = os.networkInterfaces();
+  for (const interfaceName in interfaces) {
+    const interface = interfaces[interfaceName];
+    for (const iface of interface) {
+      if (iface.family === 'IPv4' && !iface.internal) {
+        return iface.address;
+      }
+    }
+  }
+  return '127.0.0.1'; // Fallback to localhost if no suitable interface found
+}
+
+function initMS(logger, wrapper, ms, {
+  onFreeswitchConnect,
+  onFreeswitchDisconnect
+}) {
   Object.assign(wrapper, {ms, active: true, connects: 1});
   logger.info(`connected to freeswitch at ${ms.address}`);
 
+  onFreeswitchConnect(wrapper);
+
   ms.conn
     .on('esl::end', () => {
       wrapper.active = false;
+      wrapper.connects = 0;
       logger.info(`lost connection to freeswitch at ${ms.address}`);
+      onFreeswitchDisconnect(wrapper);
+      ms.removeAllListeners();
     })
     .on('esl::ready', () => {
       if (wrapper.connects > 0) {
-        logger.info(`connected to freeswitch at ${ms.address}`);
+        logger.info(`esl::ready connected to freeswitch at ${ms.address}`);
       }
       wrapper.connects = 1;
       wrapper.active = true;
@@ -28,7 +64,10 @@ function initMS(logger, wrapper, ms) {
   });
 }
 
-function installSrfLocals(srf, logger) {
+function installSrfLocals(srf, logger, {
+  onFreeswitchConnect = () => {},
+  onFreeswitchDisconnect = () => {}
+}) {
   logger.debug('installing srf locals');
   assert(!srf.locals.dbHelpers);
   const {tracer} = srf.locals.otel;
@@ -42,18 +81,18 @@ function installSrfLocals(srf, logger) {
   let idxStart = 0;
 
   (async function() {
-    const fsInventory = process.env.JAMBONES_FREESWITCH
+    const fsInventory = JAMBONES_FREESWITCH
       .split(',')
       .map((fs) => {
         const arr = /^([^:]*):([^:]*):([^:]*)(?::([^:]*))?/.exec(fs);
-        assert.ok(arr, `Invalid syntax JAMBONES_FREESWITCH: ${process.env.JAMBONES_FREESWITCH}`);
+        assert.ok(arr, `Invalid syntax JAMBONES_FREESWITCH: ${JAMBONES_FREESWITCH}`);
         const opts = {address: arr[1], port: arr[2], secret: arr[3]};
         if (arr.length > 4) opts.advertisedAddress = arr[4];
         /* NB: originally for testing only, but for now all jambonz deployments
           have freeswitch installed locally alongside this app
         */
-        if (process.env.NODE_ENV === 'test') opts.listenAddress = '0.0.0.0';
-        else if (process.env.JAMBONES_ESL_LISTEN_ADDRESS) opts.listenAddress = process.env.JAMBONES_ESL_LISTEN_ADDRESS;
+        if (NODE_ENV === 'test') opts.listenAddress = '0.0.0.0';
+        else if (JAMBONES_ESL_LISTEN_ADDRESS) opts.listenAddress = JAMBONES_ESL_LISTEN_ADDRESS;
         return opts;
       });
     logger.info({fsInventory}, 'freeswitch inventory');
@@ -63,7 +102,10 @@ function installSrfLocals(srf, logger) {
       mediaservers.push(val);
       try {
         const ms = await mrf.connect(fs);
-        initMS(logger, val, ms);
+        initMS(logger, val, ms, {
+          onFreeswitchConnect,
+          onFreeswitchDisconnect
+        });
       }
       catch (err) {
         logger.info({err}, `failed connecting to freeswitch at ${fs.address}, will retry shortly: ${err.message}`);
@@ -74,9 +116,15 @@ function installSrfLocals(srf, logger) {
       for (const val of mediaservers) {
         if (val.connects === 0) {
           try {
+            // make sure all listeners are removed before reconnecting
+            val.ms?.disconnect();
+            val.ms = null;
             logger.info({mediaserver: val.opts}, 'Retrying initial connection to media server');
             const ms = await mrf.connect(val.opts);
-            initMS(logger, val, ms);
+            initMS(logger, val, ms, {
+              onFreeswitchConnect,
+              onFreeswitchDisconnect
+            });
           } catch (err) {
             logger.info({err}, `failed connecting to freeswitch at ${val.opts.address}, will retry shortly`);
           }
@@ -123,22 +171,23 @@ function installSrfLocals(srf, logger) {
     lookupTeamsByAccount,
     lookupAccountBySid,
     lookupAccountCapacitiesBySid,
-    lookupSmppGateways
+    lookupSmppGateways,
+    lookupClientByAccountAndUsername,
+    lookupSystemInformation
   } = require('@jambonz/db-helpers')({
-    host: process.env.JAMBONES_MYSQL_HOST,
-    user: process.env.JAMBONES_MYSQL_USER,
-    port: process.env.JAMBONES_MYSQL_PORT || 3306,
-    password: process.env.JAMBONES_MYSQL_PASSWORD,
-    database: process.env.JAMBONES_MYSQL_DATABASE,
-    connectionLimit: process.env.JAMBONES_MYSQL_CONNECTION_LIMIT || 10
-  }, logger, tracer);
+    host: JAMBONES_MYSQL_HOST,
+    user: JAMBONES_MYSQL_USER,
+    port: JAMBONES_MYSQL_PORT || 3306,
+    password: JAMBONES_MYSQL_PASSWORD,
+    database: JAMBONES_MYSQL_DATABASE,
+    connectionLimit: JAMBONES_MYSQL_CONNECTION_LIMIT || 10
+  }, logger);
   const {
     client,
     updateCallStatus,
     retrieveCall,
     listCalls,
     deleteCall,
-    synthAudio,
     createHash,
     retrieveHash,
     deleteKey,
@@ -151,24 +200,37 @@ function installSrfLocals(srf, logger) {
     pushBack,
     popFront,
     removeFromList,
+    getListPosition,
     lengthOfList,
-    getListPosition
-  } = require('@jambonz/realtimedb-helpers')({
-    host: process.env.JAMBONES_REDIS_HOST,
-    port: process.env.JAMBONES_REDIS_PORT || 6379
-  }, logger, tracer);
+    addToSortedSet,
+    retrieveFromSortedSet,
+    retrieveByPatternSortedSet,
+    sortedSetLength,
+    sortedSetPositionByPattern,
+  } = require('@jambonz/realtimedb-helpers')({}, logger, tracer);
+  const registrar = new Registrar(logger, client);
+  const {
+    synthAudio,
+    addFileToCache,
+    getNuanceAccessToken,
+    getIbmAccessToken,
+    getAwsAuthToken,
+    getVerbioAccessToken
+  } = require('@jambonz/speech-utils')({}, logger);
   const {
     writeAlerts,
-    AlertType
+    AlertType,
+    writeSystemAlerts
   } = require('@jambonz/time-series')(logger, {
-    host: process.env.JAMBONES_TIME_SERIES_HOST,
+    host: JAMBONES_TIME_SERIES_HOST,
     commitSize: 50,
-    commitInterval: 'test' === process.env.NODE_ENV ? 7 : 20
+    commitInterval: 'test' === NODE_ENV ? 7 : 20
   });
 
   let localIp;
   try {
-    localIp = ip.address();
+    // Either use the configured IP address or discover it
+    localIp = HTTP_IP || getLocalIp();
   } catch (err) {
     logger.error({err}, 'installSrfLocals - error detecting local ipv4 address');
   }
@@ -176,6 +238,7 @@ function installSrfLocals(srf, logger) {
   srf.locals = {...srf.locals,
     dbHelpers: {
       client,
+      registrar,
       pool,
       lookupAppByPhoneNumber,
       lookupAppByRegex,
@@ -186,11 +249,15 @@ function installSrfLocals(srf, logger) {
       lookupAccountBySid,
       lookupAccountCapacitiesBySid,
       lookupSmppGateways,
+      lookupClientByAccountAndUsername,
+      lookupSystemInformation,
       updateCallStatus,
       retrieveCall,
       listCalls,
       deleteCall,
       synthAudio,
+      getAwsAuthToken,
+      addFileToCache,
       createHash,
       retrieveHash,
       deleteKey,
@@ -204,18 +271,27 @@ function installSrfLocals(srf, logger) {
       popFront,
       removeFromList,
       lengthOfList,
-      getListPosition
+      getListPosition,
+      getNuanceAccessToken,
+      getIbmAccessToken,
+      addToSortedSet,
+      retrieveFromSortedSet,
+      retrieveByPatternSortedSet,
+      sortedSetLength,
+      sortedSetPositionByPattern,
+      getVerbioAccessToken
     },
     parentLogger: logger,
     getSBC,
     getSmpp: () => {
-      return process.env.SMPP_URL;
+      return SMPP_URL;
     },
     lifecycleEmitter,
     getFreeswitch,
     stats: stats,
     writeAlerts,
-    AlertType
+    AlertType,
+    writeSystemAlerts
   };
 
   if (localIp) {

lib/utils/llm-mcp.js

@@ -0,0 +1,103 @@
+const { Client } = require('@modelcontextprotocol/sdk/client/index.js');
+
+class LlmMcpService {
+
+  constructor(logger, mcpServers) {
+    this.logger = logger;
+    this.mcpServers = mcpServers || [];
+    this.mcpClients = [];
+  }
+
+  // make sure we call init() before using any of the mcp clients
+  // this is to ensure that we have a valid connection to the MCP server
+  // and that we have collected the available tools.
+  async init() {
+    if (this.mcpClients.length > 0) {
+      return;
+    }
+    const { SSEClientTransport } = await import('@modelcontextprotocol/sdk/client/sse.js');
+    for (const server of this.mcpServers) {
+      const { url } = server;
+      if (url) {
+        try {
+          const transport = new SSEClientTransport(new URL(url), {});
+          const client = new Client({ name: 'Jambonz MCP Client', version: '1.0.0' });
+          await client.connect(transport);
+          // collect available tools
+          const { tools } = await client.listTools();
+          this.mcpClients.push({
+            url,
+            client,
+            tools
+          });
+        } catch (err) {
+          this.logger.error(`LlmMcpService: Failed to connect to MCP server at ${url}: ${err.message}`);
+        }
+      }
+    }
+  }
+
+  async getAvailableMcpTools() {
+    // returns a list of available tools from all MCP clients
+    const tools = [];
+    for (const mcpClient of this.mcpClients) {
+      const {tools: availableTools} = mcpClient;
+      if (availableTools) {
+        tools.push(...availableTools);
+      }
+    }
+    return tools;
+  }
+
+  async getMcpClientByToolName(name) {
+    for (const mcpClient of this.mcpClients) {
+      const { tools } = mcpClient;
+      if (tools && tools.some((tool) => tool.name === name)) {
+        return mcpClient.client;
+      }
+    }
+    return null;
+  }
+
+  async getMcpClientByToolId(id) {
+    for (const mcpClient of this.mcpClients) {
+      const { tools } = mcpClient;
+      if (tools && tools.some((tool) => tool.id === id)) {
+        return mcpClient.client;
+      }
+    }
+    return null;
+  }
+
+  async callMcpTool(name, input) {
+    const client = await this.getMcpClientByToolName(name);
+    if (client) {
+      try {
+        const result = await client.callTool({
+          name,
+          arguments: input,
+        });
+        this.logger.debug({result}, 'LlmMcpService - result');
+        return result;
+      } catch (err) {
+        this.logger.error({err}, 'LlmMcpService - error calling tool');
+        throw err;
+      }
+    }
+  }
+
+  async close() {
+    for (const mcpClient of this.mcpClients) {
+      const { client } = mcpClient;
+      if (client) {
+        await client.close();
+        this.logger.debug({url: mcpClient.url}, 'LlmMcpService - mcp client closed');
+      }
+    }
+    this.mcpClients = [];
+  }
+
+}
+
+module.exports = LlmMcpService;
+

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,
+};

lib/utils/network.js

@@ -0,0 +1,32 @@
+
+/**
+ * Parses a list of hostport entries and selects the first one that matches the specified protocol,
+ * excluding any entries with the localhost IP address ('127.0.0.1').
+ *
+ * Each hostport entry should be in the format: 'protocol/ip:port'
+ *
+ * @param {Object} logger - A logging object with a 'debug' method for logging debug messages.
+ * @param {string} hostport - A comma-separated string containing hostport entries.
+ * @param {string} protocol - The protocol to match (e.g., 'udp', 'tcp').
+ * @returns {Array} An array containing:
+ * 0: protocol
+ * 1: ip address
+ * 2: port
+ */
+const selectHostPort = (logger, hostport, protocol) => {
+  logger.debug(`selectHostPort: ${hostport}, ${protocol}`);
+  const sel = hostport
+    .split(',')
+    .map((hp) => {
+      const arr = /(.*)\/(.*):(.*)/.exec(hp);
+      return [arr[1], arr[2], arr[3]];
+    })
+    .filter((hp) => {
+      return hp[0] === protocol && hp[1] !== '127.0.0.1';
+    });
+  return sel[0];
+};
+
+module.exports = {
+  selectHostPort
+};

lib/utils/normalize-jambones.js

@@ -1,31 +0,0 @@
-function normalizeJambones(logger, obj) {
-  if (!Array.isArray(obj)) throw new Error('malformed jambonz payload: must be array');
-  const document = [];
-  for (const tdata of obj) {
-    if (typeof tdata !== 'object') throw new Error('malformed jambonz payload: must be array of objects');
-    if ('verb' in tdata) {
-      // {verb: 'say', text: 'foo..bar'..}
-      const name = tdata.verb;
-      const o = {};
-      Object.keys(tdata)
-        .filter((k) => k !== 'verb')
-        .forEach((k) => o[k] = tdata[k]);
-      const o2 = {};
-      o2[name] = o;
-      document.push(o2);
-    }
-    else if (Object.keys(tdata).length === 1) {
-      // {'say': {..}}
-      document.push(tdata);
-    }
-    else {
-      logger.info(tdata, 'malformed jambonz payload: missing verb property');
-      throw new Error('malformed jambonz payload: missing verb property');
-    }
-  }
-  logger.debug({document}, `normalizeJambones: returning document with ${document.length} tasks`);
-  return document;
-}
-
-module.exports = normalizeJambones;
-

lib/utils/parse-decibels.js

@@ -0,0 +1,18 @@
+const parseDecibels = (db) => {
+  if (!db) return 0;
+  if (typeof db === 'number') {
+    return db;
+  }
+  else if (typeof db === 'string') {
+    const match = db.match(/([+-]?\d+(\.\d+)?)\s*db/i);
+    if (match) {
+      return Math.trunc(parseFloat(match[1]));
+    } else {
+      return 0;
+    }
+  } else {
+    return 0;
+  }
+};
+
+module.exports = parseDecibels;

lib/utils/place-outdial.js

@@ -1,10 +1,10 @@
 const Emitter = require('events');
-const {CallStatus} = require('./constants');
+const {CallStatus, MediaPath} = require('./constants');
 const SipError = require('drachtio-srf').SipError;
 const {TaskPreconditions, CallDirection} = require('../utils/constants');
 const CallInfo = require('../session/call-info');
 const assert = require('assert');
-const normalizeJambones = require('../utils/normalize-jambones');
+const { normalizeJambones } = require('@jambonz/verb-specifications');
 const makeTask = require('../tasks/make_task');
 const ConfirmCallSession = require('../session/confirm-call-session');
 const AdultingCallSession = require('../session/adulting-call-session');
@@ -12,10 +12,15 @@ const deepcopy = require('deepcopy');
 const moment = require('moment');
 const stripCodecs = require('./strip-ancillary-codecs');
 const RootSpan = require('./call-tracer');
-const { v4: uuidv4 } = require('uuid');
+const crypto = require('crypto');
+const HttpRequestor = require('./http-requestor');
+const WsRequestor = require('./ws-requestor');
+const {makeOpusFirst, removeVideoSdp} = require('./sdp-utils');
+const { createMediaEndpoint } = require('./media-endpoint');
 
 class SingleDialer extends Emitter {
-  constructor({logger, sbcAddress, target, opts, application, callInfo, accountInfo, rootSpan, startSpan}) {
+  constructor({logger, sbcAddress, target, opts, application, callInfo, accountInfo, rootSpan, startSpan, dialTask,
+    onHoldMusic}) {
     super();
     assert(target.type);
 
@@ -36,7 +41,9 @@ class SingleDialer extends Emitter {
 
     this.callGone = false;
 
-    this.callSid = uuidv4();
+    this.callSid = crypto.randomUUID();
+    this.dialTask = dialTask;
+    this.onHoldMusic = onHoldMusic;
 
     this.on('callStatusChange', this._notifyCallStatusChange.bind(this));
   }
@@ -45,6 +52,10 @@ class SingleDialer extends Emitter {
     return this.callInfo.callStatus;
   }
 
+  get applicationSid() {
+    return this.application?.application_sid || this.callInfo?.applicationSid;
+  }
+
   /**
    * can be used for all http requests within this session
    */
@@ -71,7 +82,8 @@ class SingleDialer extends Emitter {
       ...(this.from.host && {'X-Preferred-From-Host': this.from.host}),
       'X-Jambonz-Routing': this.target.type,
       'X-Call-Sid': this.callSid,
-      ...(this.applicationSid && {'X-Application-Sid': this.applicationSid})
+      ...(this.applicationSid && {'X-Application-Sid': this.applicationSid}),
+      ...(this.target.proxy && {'X-SIP-Proxy': this.target.proxy})
     };
     if (srf.locals.fsUUID) {
       opts.headers = {
@@ -80,6 +92,7 @@ class SingleDialer extends Emitter {
       };
     }
     this.ms = ms;
+    this.srf = srf;
     let uri, to, inviteSpan;
     try {
       switch (this.target.type) {
@@ -121,7 +134,7 @@ class SingleDialer extends Emitter {
       this.updateCallStatus = srf.locals.dbHelpers.updateCallStatus;
       this.serviceUrl = srf.locals.serviceUrl;
 
-      this.ep = await ms.createEndpoint();
+      this.ep = await this._createMediaEndpoint();
       this.logger.debug(`SingleDialer:exec - created endpoint ${this.ep.uuid}`);
 
       /**
@@ -135,15 +148,21 @@ class SingleDialer extends Emitter {
         return;
       }
       let lastSdp;
-      const connectStream = async(remoteSdp) => {
+      const connectStream = async(remoteSdp, isVideoCall) => {
         if (remoteSdp === lastSdp) return;
+        if (process.env.JAMBONES_VIDEO_CALLS_ENABLED_IN_FS && !isVideoCall) {
+          remoteSdp = removeVideoSdp(remoteSdp);
+        }
         lastSdp = remoteSdp;
         return this.ep.modify(remoteSdp);
       };
-
+      let localSdp = this.ep.local.sdp;
+      if (process.env.JAMBONES_VIDEO_CALLS_ENABLED_IN_FS && !opts.isVideoCall) {
+        localSdp = removeVideoSdp(localSdp);
+      }
       Object.assign(opts, {
         proxy: `sip:${this.sbcAddress}`,
-        localSdp: this.ep.local.sdp
+        localSdp: opts.opusFirst ? makeOpusFirst(localSdp) : localSdp
       });
       if (this.target.auth) opts.auth = this.target.auth;
       inviteSpan = this.startSpan('invite', {
@@ -171,6 +190,7 @@ class SingleDialer extends Emitter {
            *  (a) create a logger for this call
            */
           req.srf = srf;
+          this.req = req;
           this.callInfo = new CallInfo({
             direction: CallDirection.Outbound,
             parentCallInfo: this.parentCallInfo,
@@ -179,6 +199,10 @@ class SingleDialer extends Emitter {
             callSid: this.callSid,
             traceId: this.rootSpan.traceId
           });
+          if (this.dialTask && this.dialTask.tag !== null &&
+            typeof this.dialTask.tag === 'object' && !Array.isArray(this.dialTask.tag)) {
+            this.callInfo.customerData = this.dialTask.tag;
+          }
           this.logger = srf.locals.parentLogger.child({
             callSid: this.callSid,
             parentCallSid: this.parentCallInfo.callSid,
@@ -193,18 +217,20 @@ class SingleDialer extends Emitter {
         },
         cbProvisional: (prov) => {
           const status = {sipStatus: prov.status, sipReason: prov.reason};
+          // Update call-id for sbc outbound INVITE
+          this.callInfo.sbcCallid = prov.get('X-CID');
           if ([180, 183].includes(prov.status) && prov.body) {
             if (status.callStatus !== CallStatus.EarlyMedia) {
               status.callStatus = CallStatus.EarlyMedia;
               this.emit('earlyMedia');
             }
-            connectStream(prov.body);
+            connectStream(prov.body, opts.isVideoCall);
           }
           else status.callStatus = CallStatus.Ringing;
           this.emit('callStatusChange', status);
         }
       });
-      await connectStream(this.dlg.remote.sdp);
+      await connectStream(this.dlg.remote.sdp, opts.isVideoCall);
       this.dlg.callSid = this.callSid;
       this.inviteInProgress = null;
       this.emit('callStatusChange', {
@@ -243,9 +269,19 @@ class SingleDialer extends Emitter {
         .on('modify', async(req, res) => {
           try {
             if (this.ep) {
-              const newSdp = await this.ep.modify(req.body);
-              res.send(200, {body: newSdp});
-              this.logger.info({offer: req.body, answer: newSdp}, 'SingleDialer:exec: handling reINVITE');
+              if (this.dialTask && this.dialTask.isOnHoldEnabled) {
+                this.logger.info('dial is onhold, emit event');
+                this.emit('reinvite', req, res);
+              } else {
+                let newSdp = await this.ep.modify(req.body);
+                // in case of reINVITE if video call is enabled in FS and the call is not a video call,
+                // remove video media from the SDP
+                if (process.env.JAMBONES_VIDEO_CALLS_ENABLED_IN_FS && !this.opts?.isVideoCall) {
+                  newSdp = removeVideoSdp(newSdp);
+                }
+                res.send(200, {body: newSdp});
+                this.logger.info({offer: req.body, answer: newSdp}, 'SingleDialer:exec: handling reINVITE');
+              }
             }
             else {
               this.logger.info('SingleDialer:exec: handling reINVITE with released media, emit event');
@@ -270,17 +306,17 @@ class SingleDialer extends Emitter {
         if (err.status === 487) status.callStatus = CallStatus.NoAnswer;
         else if ([486, 600].includes(err.status)) status.callStatus = CallStatus.Busy;
         this.logger.info(`SingleDialer:exec outdial failure ${err.status}`);
-        inviteSpan.setAttributes({'invite.status_code': err.status});
-        inviteSpan.end();
+        inviteSpan?.setAttributes({'invite.status_code': err.status});
+        inviteSpan?.end();
       }
       else {
         this.logger.error(err, 'SingleDialer:exec');
         status.sipStatus = 500;
-        inviteSpan.setAttributes({
+        inviteSpan?.setAttributes({
           'invite.status_code': 500,
           'invite.err': err.message
         });
-        inviteSpan.end();
+        inviteSpan?.end();
       }
       this.emit('callStatusChange', status);
       if (this.ep) this.ep.destroy();
@@ -290,14 +326,19 @@ class SingleDialer extends Emitter {
   /**
    * kill the call in progress or the stable dialog, whichever we have
    */
-  async kill() {
+  async kill(Reason) {
     this.killed = true;
     if (this.inviteInProgress) await this.inviteInProgress.cancel();
     else if (this.dlg && this.dlg.connected) {
       const duration = moment().diff(this.dlg.connectTime, 'seconds');
       this.logger.debug('SingleDialer:kill hanging up called party');
       this.emit('callStatusChange', {callStatus: CallStatus.Completed, duration});
-      this.dlg.destroy();
+      const headers = {
+        ...(Reason && {'X-Reason': Reason})
+      };
+      this.dlg.destroy({
+        headers
+      });
     }
     if (this.ep) {
       this.logger.debug(`SingleDialer:kill - deleting endpoint ${this.ep.uuid}`);
@@ -305,6 +346,21 @@ class SingleDialer extends Emitter {
     }
   }
 
+  async _handleMediaTimeout(evt, ep) {
+    this.logger.info({evt}, 'SingleDialer:_handleMediaTimeout - media timeout event received');
+    this.dialTask.kill(this.dialTask.cs, 'media-timeout');
+  }
+
+  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),
+    });
+  }
+
   /**
    * Run an application on the call after answer, e.g. call screening.
    * Once the application completes in some fashion, emit an 'accepted' event
@@ -316,10 +372,16 @@ class SingleDialer extends Emitter {
     try {
       // retrieve set of tasks
       const json = await this.requestor.request('dial:confirm', confirmHook, this.callInfo.toJSON());
+      if (!json || (Array.isArray(json) && json.length === 0)) {
+        this.logger.info('SingleDialer:_executeApp: no tasks returned from confirm hook');
+        this.emit('accept');
+        return;
+      }
       const tasks = normalizeJambones(this.logger, json).map((tdata) => makeTask(this.logger, tdata));
       // verify it contains only allowed verbs
       const allowedTasks = tasks.filter((task) => {
         return [
+          TaskPreconditions.None,
           TaskPreconditions.StableCall,
           TaskPreconditions.Endpoint
         ].includes(task.preconditions);
@@ -338,7 +400,9 @@ class SingleDialer extends Emitter {
         callInfo: this.callInfo,
         accountInfo: this.accountInfo,
         tasks,
-        rootSpan: this.rootSpan
+        rootSpan: this.rootSpan,
+        req: this.req,
+        tmpFiles: cs.tmpFiles,
       });
       await cs.exec();
 
@@ -347,7 +411,10 @@ class SingleDialer extends Emitter {
     } catch (err) {
       this.logger.debug(err, 'SingleDialer:_executeApp: error');
       this.emit('decline');
-      if (this.dlg.connected) this.dlg.destroy();
+      if (this.dlg.connected) {
+        this.dlg.destroy();
+        this.ep.destroy();
+      }
     }
   }
 
@@ -367,40 +434,82 @@ class SingleDialer extends Emitter {
     this.dlg.linkedSpanId = this.rootSpan.traceId;
     const rootSpan = new RootSpan('outbound-call', this.dlg);
     const newLogger = logger.child({traceId: rootSpan.traceId});
+    //clone application from parent call with new requestor
+    //parrent application will be closed in case the parent hangup
+    const app = {...application};
+    if ('WS' === app.call_hook?.method ||
+      app.call_hook?.url.startsWith('ws://') || app.call_hook?.url.startsWith('wss://')) {
+      if (app.call_hook?.url) app.call_hook.url += '/adulting';
+      const requestor = new WsRequestor(logger, this.accountInfo.account.account_sid,
+        app.call_hook, this.accountInfo.account.webhook_secret);
+      app.requestor = requestor;
+      app.notifier = requestor;
+      app.call_hook.method = 'WS';
+    }
+    else {
+      app.requestor = new HttpRequestor(logger, this.accountInfo.account.account_sid,
+        app.call_hook, this.accountInfo.account.webhook_secret);
+      if (app.call_status_hook) app.notifier = new HttpRequestor(logger,
+        this.accountInfo.account.account_sid, app.call_status_hook,
+        this.accountInfo.account.webhook_secret);
+      else app.notifier = {request: () => {}, close: () => {}};
+    }
+    // Replace old application with new application.
+    this.application = app;
     const cs = new AdultingCallSession({
       logger: newLogger,
       singleDialer: this,
-      application,
+      application: app,
       callInfo: this.callInfo,
       accountInfo: this.accountInfo,
       tasks,
       rootSpan
     });
+    app.requestor.request('session:adulting', '/adulting', {
+      ...cs.callInfo.toJSON(),
+      parentCallInfo: this.parentCallInfo.toJSON()
+    }).catch((err) => {
+      newLogger.error({err}, 'doAdulting: error sending adulting request');
+    });
+
+    cs.req = this.req;
+    // fixed hangup an adulting session does not send status callback Completed
+    cs.wrapDialog(this.dlg);
     cs.exec().catch((err) => newLogger.error({err}, 'doAdulting: error executing session'));
     return cs;
   }
 
-  async releaseMediaToSBC(remoteSdp, localSdp) {
+  async releaseMediaToSBC(remoteSdp, localSdp, releaseMediaEntirely) {
     assert(this.dlg && this.dlg.connected && this.ep && typeof remoteSdp === 'string');
     const sdp = stripCodecs(this.logger, remoteSdp, localSdp) || remoteSdp;
     await this.dlg.modify(sdp, {
       headers: {
-        'X-Reason': 'release-media'
+        'X-Reason': releaseMediaEntirely ? 'release-media-entirely' : 'release-media'
       }
     });
-    this.ep.destroy()
-      .then(() => this.ep = null)
-      .catch((err) => this.logger.error({err}, 'SingleDialer:releaseMediaToSBC: Error destroying endpoint'));
+    try {
+      await this.ep.destroy();
+    } catch (err) {
+      this.logger.error({err}, 'SingleDialer:releaseMediaToSBC: Error destroying endpoint');
+    }
+    this.ep = null;
   }
 
-  async reAnchorMedia() {
+  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.logger.debug('SingleDialer:reAnchorMedia: re-anchoring media after partial media');
+    this.ep = await this._createMediaEndpoint({remoteSdp: this.dlg.remote.sdp});
     await this.dlg.modify(this.ep.local.sdp, {
       headers: {
         'X-Reason': 'anchor-media'
       }
     });
+
+    if (currentMediaRoute === MediaPath.NoMedia) {
+      this.logger.debug('SingleDialer:reAnchorMedia: repoint endpoint after no media');
+      await this.ep.modify(this.dlg.remote.sdp);
+    }
   }
 
   _notifyCallStatusChange({callStatus, sipStatus, sipReason, duration}) {
@@ -412,7 +521,7 @@ class SingleDialer extends Emitter {
       this.callInfo.updateCallStatus(callStatus, sipStatus, sipReason);
       if (typeof duration === 'number') this.callInfo.duration = duration;
       try {
-        this.requestor.request('call:status', this.application.call_status_hook, this.callInfo.toJSON());
+        this.notifier.request('call:status', this.application.call_status_hook, this.callInfo.toJSON());
       } catch (err) {
         this.logger.info(err, `SingleDialer:_notifyCallStatusChange error sending ${callStatus} ${sipStatus}`);
       }
@@ -426,11 +535,13 @@ class SingleDialer extends Emitter {
 }
 
 function placeOutdial({
-  logger, srf, ms, sbcAddress, target, opts, application, callInfo, accountInfo, rootSpan, startSpan
+  logger, srf, ms, sbcAddress, target, opts, application, callInfo, accountInfo, rootSpan, startSpan, dialTask,
+  onHoldMusic
 }) {
   const myOpts = deepcopy(opts);
   const sd = new SingleDialer({
-    logger, sbcAddress, target, myOpts, application, callInfo, accountInfo, rootSpan, startSpan
+    logger, sbcAddress, target, opts: myOpts, application, callInfo,
+    accountInfo, rootSpan, startSpan, dialTask, onHoldMusic
   });
   sd.exec(srf, ms, myOpts);
   return sd;

lib/utils/requestor.js

@@ -1,5 +1,9 @@
 const assert = require('assert');
 const timeSeries = require('@jambonz/time-series');
+const {
+  NODE_ENV,
+  JAMBONES_TIME_SERIES_HOST
+} = require('../config');
 let alerter ;
 
 function isAbsoluteUrl(u) {
@@ -28,9 +32,9 @@ class Requestor {
 
     if (!alerter) {
       alerter = timeSeries(logger, {
-        host: process.env.JAMBONES_TIME_SERIES_HOST,
+        host: JAMBONES_TIME_SERIES_HOST,
         commitSize: 50,
-        commitInterval: 'test' === process.env.NODE_ENV ? 7 : 20
+        commitInterval: 'test' === NODE_ENV ? 7 : 20
       });
     }
   }
@@ -38,9 +42,9 @@ class Requestor {
   get Alerter() {
     if (!alerter) {
       alerter = timeSeries(this.logger, {
-        host: process.env.JAMBONES_TIME_SERIES_HOST,
+        host: JAMBONES_TIME_SERIES_HOST,
         commitSize: 50,
-        commitInterval: 'test' === process.env.NODE_ENV ? 7 : 20
+        commitInterval: 'test' === NODE_ENV ? 7 : 20
       });
     }
     return alerter;

lib/utils/sbc-pinger.js

@@ -1,31 +1,41 @@
 const assert = require('assert');
-const { v4: uuidv4 } = require('uuid');
+const crypto = require('crypto');
 const {LifeCycleEvents, FS_UUID_SET_NAME} = require('./constants');
 const Emitter = require('events');
 const debug = require('debug')('jambonz:feature-server');
 const noopLogger = {info: () => {}, error: () => {}};
+const {
+  JAMBONES_SBCS,
+  K8S,
+  K8S_SBC_SIP_SERVICE_NAME,
+  AWS_SNS_TOPIC_ARN,
+  OPTIONS_PING_INTERVAL,
+  AWS_REGION,
+  NODE_ENV,
+  JAMBONES_CLUSTER_ID,
+} = require('../config');
 
 module.exports = (logger) => {
   logger = logger || noopLogger;
   let idxSbc = 0;
   let sbcs = [];
 
-  if (process.env.JAMBONES_SBCS) {
-    sbcs = process.env.JAMBONES_SBCS
+  if (JAMBONES_SBCS) {
+    sbcs = JAMBONES_SBCS
       .split(',')
       .map((sbc) => sbc.trim());
     assert.ok(sbcs.length, 'JAMBONES_SBCS env var is empty or misconfigured');
     logger.info({sbcs}, 'SBC inventory');
   }
-  else if (process.env.K8S && process.env.K8S_SBC_SIP_SERVICE_NAME) {
-    sbcs = [`${process.env.K8S_SBC_SIP_SERVICE_NAME}:5060`];
+  else if (K8S && K8S_SBC_SIP_SERVICE_NAME) {
+    sbcs = [`${K8S_SBC_SIP_SERVICE_NAME}:5060`];
     logger.info({sbcs}, 'SBC inventory');
   }
 
   // listen for SNS lifecycle changes
   let lifecycleEmitter = new Emitter();
   let dryUpCalls = false;
-  if (process.env.AWS_SNS_TOPIC_ARM && process.env.AWS_REGION) {
+  if (AWS_SNS_TOPIC_ARN && AWS_REGION) {
 
     (async function() {
       try {
@@ -36,12 +46,24 @@ module.exports = (logger) => {
             const {srf} = require('../..');
             srf.locals.publicIp = publicIp;
           })
-          .on(LifeCycleEvents.ScaleIn, () => {
+          .on(LifeCycleEvents.ScaleIn, async() => {
             logger.info('AWS scale-in notification: begin drying up calls');
             dryUpCalls = true;
             lifecycleEmitter.operationalState = LifeCycleEvents.ScaleIn;
 
             const {srf} = require('../..');
+            const {writeSystemAlerts} = srf.locals;
+            if (writeSystemAlerts) {
+              const {SystemState, FEATURE_SERVER} = require('./constants');
+              await writeSystemAlerts({
+                system_component: FEATURE_SERVER,
+                state : SystemState.GracefulShutdownInProgress,
+                fields : {
+                  detail: `feature-server with process_id ${process.pid} shutdown in progress`,
+                  host: srf.locals?.ipv4
+                }
+              });
+            }
             pingProxies(srf);
 
             // if we have zero calls, we can complete the scale-in right
@@ -75,9 +97,13 @@ module.exports = (logger) => {
       }
     })();
   }
+  else if (K8S) {
+    lifecycleEmitter.scaleIn = () => process.exit(0);
+  }
+
 
   async function pingProxies(srf) {
-    if (process.env.NODE_ENV === 'test') return;
+    if (NODE_ENV === 'test') return;
 
     for (const sbc of sbcs) {
       try {
@@ -87,7 +113,8 @@ module.exports = (logger) => {
           method: 'OPTIONS',
           headers: {
             'X-FS-Status': ms && !dryUpCalls ? 'open' : 'closed',
-            'X-FS-Calls': srf.locals.sessionTracker.count
+            'X-FS-Calls': srf.locals.sessionTracker.count,
+            'X-FS-ServiceUrl': srf.locals.serviceUrl
           }
         });
         req.on('response', (res) => {
@@ -98,12 +125,12 @@ module.exports = (logger) => {
       }
     }
   }
-  if (process.env.K8S) {
+  if (K8S) {
     setImmediate(() => {
       logger.info('disabling OPTIONS pings since we are running as a kubernetes service');
       const {srf} = require('../..');
       const {addToSet} = srf.locals.dbHelpers;
-      const uuid = srf.locals.fsUUID = uuidv4();
+      const uuid = srf.locals.fsUUID = crypto.randomUUID();
 
       /* in case redis is restarted, re-insert our key every so often */
       setInterval(() => {
@@ -119,16 +146,16 @@ module.exports = (logger) => {
     setInterval(() => {
       const {srf} = require('../..');
       pingProxies(srf);
-    }, process.env.OPTIONS_PING_INTERVAL || 30000);
+    }, OPTIONS_PING_INTERVAL);
 
     // initial ping once we are up
     setTimeout(async() => {
 
       // if SBCs are auto-scaling, monitor them as they come and go
       const {srf} = require('../..');
-      if (!process.env.JAMBONES_SBCS) {
+      if (!JAMBONES_SBCS) {
         const {monitorSet} = srf.locals.dbHelpers;
-        const setName = `${(process.env.JAMBONES_CLUSTER_ID || 'default')}:active-sip`;
+        const setName = `${(JAMBONES_CLUSTER_ID || 'default')}:active-sip`;
         await monitorSet(setName, 10, (members) => {
           sbcs = members;
           logger.info(`sbc-pinger: SBC roster has changed, list of active SBCs is now ${sbcs}`);

lib/utils/sdp-utils.js

@@ -0,0 +1,65 @@
+const sdpTransform = require('sdp-transform');
+
+const isOnhold = (sdp) => {
+  return sdp && (sdp.includes('a=sendonly') || sdp.includes('a=inactive'));
+};
+
+const mergeSdpMedia = (sdp1, sdp2) => {
+  const parsedSdp1 = sdpTransform.parse(sdp1);
+  const parsedSdp2 = sdpTransform.parse(sdp2);
+
+  parsedSdp1.media.push(...parsedSdp2.media);
+  return sdpTransform.write(parsedSdp1);
+};
+
+const getCodecPlacement = (parsedSdp, codec) => parsedSdp?.media[0]?.rtp?.findIndex((e) => e.codec === codec);
+
+const isOpusFirst = (sdp) => {
+  return getCodecPlacement(sdpTransform.parse(sdp), 'opus') === 0;
+};
+
+const makeOpusFirst = (sdp) => {
+  const parsedSdp = sdpTransform.parse(sdp);
+  // Find the index of the OPUS codec
+  const opusIndex = getCodecPlacement(parsedSdp, 'opus');
+
+  // Move OPUS codec to the beginning
+  if (opusIndex > 0) {
+    const opusEntry = parsedSdp.media[0].rtp.splice(opusIndex, 1)[0];
+    parsedSdp.media[0].rtp.unshift(opusEntry);
+
+    // Also move the corresponding payload type in the "m" line
+    const opusPayloadType = parsedSdp.media[0].payloads.split(' ')[opusIndex];
+    const otherPayloadTypes = parsedSdp.media[0].payloads.split(' ').filter((pt) => pt != opusPayloadType);
+    parsedSdp.media[0].payloads = [opusPayloadType, ...otherPayloadTypes].join(' ');
+  }
+  return sdpTransform.write(parsedSdp);
+};
+const removeVideoSdp = (sdp) => {
+  const parsedSdp = sdpTransform.parse(sdp);
+  // Filter out video media sections, keeping only non-video media
+  parsedSdp.media = parsedSdp.media.filter((media) => media.type !== 'video');
+  return sdpTransform.write(parsedSdp);
+};
+
+const extractSdpMedia = (sdp) => {
+  const parsedSdp1 = sdpTransform.parse(sdp);
+  if (parsedSdp1.media.length > 1) {
+    parsedSdp1.media = [parsedSdp1.media[0]];
+    const parsedSdp2 = sdpTransform.parse(sdp);
+    parsedSdp2.media = [parsedSdp2.media[1]];
+
+    return [sdpTransform.write(parsedSdp1), sdpTransform.write(parsedSdp2)];
+  } else {
+    return [sdp, sdp];
+  }
+};
+
+module.exports = {
+  isOnhold,
+  mergeSdpMedia,
+  extractSdpMedia,
+  isOpusFirst,
+  makeOpusFirst,
+  removeVideoSdp
+};

lib/utils/siprec-utils.js

@@ -1,5 +1,5 @@
 const xmlParser = require('xml2js').parseString;
-const { v4: uuidv4 } = require('uuid');
+const crypto = require('crypto');
 const parseUri = require('drachtio-srf').parseUri;
 const transform = require('sdp-transform');
 const debug = require('debug')('jambonz:feature-server');
@@ -47,8 +47,16 @@ const parseSiprecPayload = (req, logger) => {
       }
     }
 
-    if (!sdp || !meta) {
-      logger.info({payload: req.payload}, 'invalid SIPREC payload');
+
+    if (!meta && sdp) {
+      const arr = /^([^]+)(m=[^]+?)(m=[^]+?)$/.exec(sdp);
+      opts.sdp1 = `${arr[1]}${arr[2]}`;
+      opts.sdp2 = `${arr[1]}${arr[3]}\r\n`;
+      opts.sessionId = crypto.randomUUID();
+      logger.info({ payload: req.payload }, 'SIPREC payload with no metadata (e.g. Cisco NBR)');
+      resolve(opts);
+    } else if (!sdp || !meta) {
+      logger.info({ payload: req.payload }, 'invalid SIPREC payload');
       return reject(new Error('expected multipart SIPREC body'));
     }
 
@@ -56,7 +64,7 @@ const parseSiprecPayload = (req, logger) => {
       if (err) { throw err; }
 
       opts.recordingData = result ;
-      opts.sessionId = uuidv4() ;
+      opts.sessionId = crypto.randomUUID();
 
       const arr = /^([^]+)(m=[^]+?)(m=[^]+?)$/.exec(sdp) ;
       opts.sdp1 = `${arr[1]}${arr[2]}` ;
@@ -89,8 +97,12 @@ const parseSiprecPayload = (req, logger) => {
             obj[`${prefix}participantstreamassoc`].forEach((ps) => {
               const part = participants[ps.$.participant_id];
               if (part) {
-                part.send = ps[`${prefix}send`][0];
-                part.recv = ps[`${prefix}recv`][0];
+                if (ps.hasOwnProperty(`${prefix}send`)) {
+                  part.send = ps[`${prefix}send`][0];
+                }
+                if (ps.hasOwnProperty(`${prefix}recv`)) {
+                  part.recv = ps[`${prefix}recv`][0];
+                }
               }
             });
           }
@@ -101,9 +113,9 @@ const parseSiprecPayload = (req, logger) => {
           obj[`${prefix}stream`].forEach((s) => {
             const streamId = s.$.stream_id;
             let sender;
-            for (const [k, v] of Object.entries(participants)) {
+            for (const v of Object.values(participants)) {
               if (v.send === streamId) {
-                sender = k;
+                sender = v;
                 break;
               }
             }
@@ -113,9 +125,15 @@ const parseSiprecPayload = (req, logger) => {
 
             sender.label = s[`${prefix}label`][0];
 
-            if (-1 !== ['1', 'a_leg', 'inbound'].indexOf(sender.label)) {
-              opts.caller.aor = sender.aor ;
+            if (-1 !== ['1', 'a_leg', 'inbound', '10'].indexOf(sender.label)) {
+              opts.caller.aor = sender.aor;
               if (sender.name) opts.caller.name = sender.name;
+              // Remap the sdp stream base on sender label
+              if (!opts.sdp1.includes(`a=label:${sender.label}`)) {
+                const tmp = opts.sdp1;
+                opts.sdp1 = opts.sdp2;
+                opts.sdp2 = tmp;
+              }
             }
             else {
               opts.callee.aor = sender.aor ;
@@ -242,7 +260,8 @@ const createSipRecPayload = (sdp1, sdp2, logger) => {
     .replace(/a=sendonly\r\n/g, '')
     .replace(/a=direction:both\r\n/g, '');
   */
-  return combinedSdp;
+
+  return combinedSdp.replace(/sendrecv/g, 'recvonly');
 };
 
 module.exports = { parseSiprecPayload, createSipRecPayload } ;

lib/utils/sticky-event-emitter.js

@@ -0,0 +1,74 @@
+const EventEmitter = require('events');
+
+/**
+ * A specialized EventEmitter that caches the most recent event emissions.
+ * When new listeners are added, they immediately receive the most recent
+ * event if it was previously emitted. This is useful for handling state
+ * changes where late subscribers need to know the current state.
+ *
+ * Features:
+ * - Caches the most recent emission for each event type
+ * - New listeners immediately receive the cached event if available
+ * - Supports both regular (on) and one-time (once) listeners
+ * - Maintains compatibility with Node's EventEmitter interface
+ */
+class StickyEventEmitter extends EventEmitter {
+  constructor() {
+    super();
+    this._eventCache = new Map();
+    this._onceListeners = new Map(); // For storing once listeners if needed
+  }
+  destroy() {
+    this._eventCache.clear();
+    this._onceListeners.clear();
+    this.removeAllListeners();
+  }
+  emit(event, ...args) {
+    // Store the event and its args
+    this._eventCache.set(event, args);
+
+    // If there are any 'once' listeners waiting, call them
+    if (this._onceListeners.has(event)) {
+      const listeners = this._onceListeners.get(event);
+      for (const listener of listeners) {
+        listener(...args);
+      }
+      if (this.onSuccess) {
+        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);
+  }
+
+  on(event, listener) {
+    if (this._eventCache.has(event)) {
+      listener(...this._eventCache.get(event));
+    }
+    return super.on(event, listener);
+  }
+
+  once(event, listener) {
+    if (this._eventCache.has(event)) {
+      listener(...this._eventCache.get(event));
+      if (this.onSuccess) {
+        this.onSuccess();
+      }
+    } else {
+      // Store listener in case emit comes before
+      if (!this._onceListeners.has(event)) {
+        this._onceListeners.set(event, []);
+      }
+      this._onceListeners.get(event).push(listener);
+      super.once(event, listener); // Also attach to native once
+    }
+    return this;
+  }
+}
+
+module.exports = StickyEventEmitter;

lib/utils/stt-latency-calculator.js

@@ -0,0 +1,197 @@
+const { assert } = require('console');
+const Emitter = require('events');
+const {
+  VadDetection,
+  SileroVadDetection
+} = require('../utils/constants.json');
+
+class SttLatencyCalculator extends Emitter {
+  constructor({ logger, cs}) {
+    super();
+    this.logger = logger;
+    this.cs = cs;
+    this.isRunning = false;
+    this.isInTalkSpurt = false;
+    this.start_talking_time = 0;
+    this.talkspurts = [];
+    this.vendor = this.cs.vad?.vendor || 'silero';
+    this.stt_start_time = 0;
+    this.stt_stop_time = 0;
+    this.stt_on_transcription_time = 0;
+  }
+
+  set sttStartTime(time) {
+    this.stt_start_time = time;
+  }
+
+  get sttStartTime() {
+    return this.stt_start_time || 0;
+  }
+
+  set sttStopTime(time) {
+    this.stt_stop_time = time;
+  }
+
+  get sttStopTime() {
+    return this.stt_stop_time || 0;
+  }
+
+  set sttOnTranscriptionTime(time) {
+    this.stt_on_transcription_time = time;
+  }
+
+  get sttOnTranscriptionTime() {
+    return this.stt_on_transcription_time || 0;
+  }
+
+  _onVadDetected(_ep, _evt, fsEvent) {
+    if (fsEvent.getHeader('detected-event') === 'stop_talking') {
+      if (this.isInTalkSpurt) {
+        this.talkspurts.push({
+          start: this.start_talking_time,
+          stop: Date.now()
+        });
+      }
+
+      this.start_talking_time = 0;
+      this.isInTalkSpurt = false;
+    } else if (fsEvent.getHeader('detected-event') === 'start_talking') {
+      this.start_talking_time = Date.now();
+      this.isInTalkSpurt = true;
+    }
+  }
+
+  _startVad() {
+    assert(!this.isRunning, 'Latency calculator is already running');
+    assert(this.cs.ep, 'Callsession has no endpoint to start the latency calculator');
+    const ep = this.cs.ep;
+    if (!ep.sttLatencyVadHandler) {
+      ep.sttLatencyVadHandler = this._onVadDetected.bind(this, ep);
+      if (this.vendor === 'silero') {
+        ep.addCustomEventListener(SileroVadDetection.Detection, ep.sttLatencyVadHandler);
+      } else {
+        ep.addCustomEventListener(VadDetection.Detection, ep.sttLatencyVadHandler);
+      }
+    }
+    this.stop_talking_time = 0;
+    this.start_talking_time = 0;
+    this.vad = {
+      ...(this.cs.vad || {}),
+      strategy: 'continuous',
+      bugname: 'stt-latency-calculator-vad',
+      vendor: this.vendor
+    };
+
+    ep.startVadDetection(this.vad);
+    this.isRunning = true;
+  }
+
+  _stopVad() {
+    if (this.isRunning) {
+      this.logger.warn('Latency calculator is still running, stopping VAD detection');
+      const ep = this.cs.ep;
+      ep.stopVadDetection(this.vad);
+      if (ep.sttLatencyVadHandler) {
+        if (this.vendor === 'silero') {
+          this.ep?.removeCustomEventListener(SileroVadDetection.Detection, ep.sttLatencyVadHandler);
+        } else {
+          this.ep?.removeCustomEventListener(VadDetection.Detection, ep.sttLatencyVadHandler);
+        }
+        ep.sttLatencyVadHandler = null;
+      }
+      this.isRunning = false;
+      this.logger.info('STT Latency Calculator stopped');
+    }
+  }
+
+  start() {
+    if (this.isRunning) {
+      this.logger.warn('Latency calculator is already running');
+      return;
+    }
+    if (!this.cs.ep) {
+      this.logger.error('Callsession has no endpoint to start the latency calculator');
+      return;
+    }
+    this._startVad();
+    this.logger.debug('STT Latency Calculator started');
+  }
+
+  stop() {
+    this._stopVad();
+  }
+
+  toUnixTimestamp(date) {
+    return Math.floor(date / 1000);
+  }
+
+  calculateLatency() {
+    if (!this.isRunning) {
+      this.logger.debug('Latency calculator is not running, cannot calculate latency, returning default values');
+      return null;
+    }
+
+    const stt_stop_time = this.stt_stop_time || Date.now();
+    if (this.isInTalkSpurt) {
+      this.talkspurts.push({
+        start: this.start_talking_time,
+        stop: stt_stop_time
+      });
+      this.isInTalkSpurt = false;
+      this.start_talking_time = 0;
+    }
+    const stt_on_transcription_time = this.stt_on_transcription_time || stt_stop_time;
+    const start_talking_time = this.talkspurts[0]?.start;
+    let lastIdx = this.talkspurts.length - 1;
+    lastIdx = lastIdx < 0 ? 0 : lastIdx;
+    const stop_talking_time = this.talkspurts[lastIdx]?.stop || stt_stop_time;
+
+    return {
+      stt_start_time: this.toUnixTimestamp(this.stt_start_time),
+      stt_stop_time: this.toUnixTimestamp(stt_stop_time),
+      start_talking_time: this.toUnixTimestamp(start_talking_time),
+      stop_talking_time: this.toUnixTimestamp(stop_talking_time),
+      stt_latency: parseFloat((Math.abs(stt_on_transcription_time - stop_talking_time)) / 1000).toFixed(2),
+      stt_latency_ms: Math.abs(stt_on_transcription_time - stop_talking_time),
+      stt_usage: parseFloat((stt_stop_time - this.stt_start_time) / 1000).toFixed(2),
+      talkspurts: this.talkspurts.map((ts) =>
+        ([this.toUnixTimestamp(ts.start || 0), this.toUnixTimestamp(ts.stop || 0)]))
+    };
+  }
+
+  resetTime() {
+    if (!this.isRunning) {
+      return;
+    }
+    this.stt_start_time = Date.now();
+    this.stt_stop_time = 0;
+    this.stt_on_transcription_time = 0;
+    this.clearTalkspurts();
+    this.logger.info('STT Latency Calculator reset');
+  }
+
+  onTranscriptionReceived() {
+    if (!this.isRunning) {
+      return;
+    }
+    this.stt_on_transcription_time = Date.now();
+    this.logger.debug(`CallSession:on-transcription set to ${this.stt_on_transcription_time}`);
+  }
+
+  onTranscribeStop() {
+    if (!this.isRunning) {
+      return;
+    }
+    this.stt_stop_time = Date.now();
+    this.logger.debug(`CallSession:transcribe-stop set to ${this.stt_stop_time}`);
+  }
+
+  clearTalkspurts() {
+    this.talkspurts = [];
+    if (!this.isInTalkSpurt) {
+      this.start_talking_time = 0;
+    }
+  }
+}
+
+module.exports = SttLatencyCalculator;

lib/utils/tts-streaming-buffer.js

@@ -0,0 +1,452 @@
+const Emitter = require('events');
+const assert = require('assert');
+const {
+  TtsStreamingEvents,
+  TtsStreamingConnectionStatus
+} = require('../utils/constants');
+
+const MAX_CHUNK_SIZE = 1800;
+const HIGH_WATER_BUFFER_SIZE = 1000;
+const LOW_WATER_BUFFER_SIZE = 200;
+const TIMEOUT_RETRY_MSECS = 1000; // 1 second
+
+
+const isWhitespace = (str) => /^\s*$/.test(str);
+
+/**
+ * Each queue item is an object:
+ *   - { type: 'text', value: '…' } for text tokens.
+ *   - { type: 'flush' } for a flush command.
+ */
+class TtsStreamingBuffer extends Emitter {
+  constructor(cs) {
+    super();
+    this.cs = cs;
+    this.logger = cs.logger;
+
+    // Use an array to hold our structured items.
+    this.queue = [];
+    // Track total number of characters in text items.
+    this.bufferedLength = 0;
+    this.eventHandlers = [];
+    this._isFull = false;
+    this._connectionStatus = TtsStreamingConnectionStatus.NotConnected;
+    this.timer = null;
+    // Record the last time the text buffer was updated.
+    this.lastUpdateTime = 0;
+  }
+
+  get isEmpty() {
+    return this.queue.length === 0;
+  }
+
+  get size() {
+    return this.bufferedLength;
+  }
+
+  get isFull() {
+    return this._isFull;
+  }
+
+  get ep() {
+    return this.cs?.ep;
+  }
+
+  async start() {
+    assert.ok(
+      this._connectionStatus === TtsStreamingConnectionStatus.NotConnected,
+      'TtsStreamingBuffer:start already started, or has failed'
+    );
+
+    this.vendor = this.cs.getTsStreamingVendor();
+    if (!this.vendor) {
+      this.logger.info('TtsStreamingBuffer:start No TTS streaming vendor configured');
+      throw new Error('No TTS streaming vendor configured');
+    }
+
+    this.logger.info(`TtsStreamingBuffer:start Connecting to TTS streaming with vendor ${this.vendor}`);
+
+    this._connectionStatus = TtsStreamingConnectionStatus.Connecting;
+    try {
+      if (this.eventHandlers.length === 0) this._initHandlers(this.ep);
+      await this._api(this.ep, [this.ep.uuid, 'connect']);
+    } catch (err) {
+      this.logger.info({ err }, 'TtsStreamingBuffer:start Error connecting to TTS streaming');
+      this._connectionStatus = TtsStreamingConnectionStatus.Failed;
+    }
+  }
+
+  stop() {
+    clearTimeout(this.timer);
+    this.removeCustomEventListeners();
+    if (this.ep) {
+      this._api(this.ep, [this.ep.uuid, 'close'])
+        .catch((err) =>
+          this.logger.info({ err }, 'TtsStreamingBuffer:stop Error closing TTS streaming')
+        );
+    }
+    this.timer = null;
+    this.queue = [];
+    this.bufferedLength = 0;
+    this._connectionStatus = TtsStreamingConnectionStatus.NotConnected;
+  }
+
+  /**
+   * Buffer new text tokens.
+   */
+  async bufferTokens(tokens) {
+    if (this._connectionStatus === TtsStreamingConnectionStatus.Failed) {
+      this.logger.info('TtsStreamingBuffer:bufferTokens TTS streaming connection failed, rejecting request');
+      return { status: 'failed', reason: `connection to ${this.vendor} failed` };
+    }
+
+    if (0 === this.bufferedLength && isWhitespace(tokens)) {
+      this.logger.debug({tokens}, 'TtsStreamingBuffer:bufferTokens discarded whitespace tokens');
+      return { status: 'ok' };
+    }
+
+    const displayedTokens = tokens.length <= 40 ? tokens : tokens.substring(0, 40);
+    const totalLength = tokens.length;
+
+    if (this.bufferedLength + totalLength > HIGH_WATER_BUFFER_SIZE) {
+      this.logger.info(
+        `TtsStreamingBuffer throttling: buffer is full, rejecting request to buffer ${totalLength} tokens`
+      );
+      if (!this._isFull) {
+        this._isFull = true;
+        this.emit(TtsStreamingEvents.Pause);
+      }
+      return { status: 'failed', reason: 'full' };
+    }
+
+    this.logger.debug(
+      `TtsStreamingBuffer:bufferTokens "${displayedTokens}" (length: ${totalLength})`
+    );
+    this.queue.push({ type: 'text', value: tokens });
+    this.bufferedLength += totalLength;
+    // Update the last update time each time new text is buffered.
+    this.lastUpdateTime = Date.now();
+
+    await this._feedQueue();
+    return { status: 'ok' };
+  }
+
+  /**
+   * Insert a flush command. If no text is queued, flush immediately.
+   * Otherwise, append a flush marker so that all text preceding it will be sent
+   * (regardless of sentence boundaries) before the flush is issued.
+   */
+  flush() {
+    if (this._connectionStatus === TtsStreamingConnectionStatus.Connecting) {
+      this.logger.debug('TtsStreamingBuffer:flush TTS stream is not quite ready - wait for connect');
+      if (this.queue.length === 0 || this.queue[this.queue.length - 1].type !== 'flush') {
+        this.queue.push({ type: 'flush' });
+      }
+      return;
+    }
+    else if (this._connectionStatus === TtsStreamingConnectionStatus.Connected) {
+      if (this.isEmpty) {
+        this._doFlush();
+      }
+      else {
+        if (this.queue[this.queue.length - 1].type !== 'flush') {
+          this.queue.push({ type: 'flush' });
+          this.logger.debug('TtsStreamingBuffer:flush added flush marker to queue');
+        }
+      }
+    }
+    else {
+      this.logger.debug(
+        `TtsStreamingBuffer:flush TTS stream is not connected, status: ${this._connectionStatus}`
+      );
+    }
+  }
+
+  clear() {
+    this.logger.debug('TtsStreamingBuffer:clear');
+    if (this._connectionStatus !== TtsStreamingConnectionStatus.Connected) return;
+    clearTimeout(this.timer);
+    this._api(this.ep, [this.ep.uuid, 'clear']).catch((err) =>
+      this.logger.info({ err }, 'TtsStreamingBuffer:clear Error clearing TTS streaming')
+    );
+    this.queue = [];
+    this.bufferedLength = 0;
+    this.timer = null;
+    this._isFull = false;
+  }
+
+  /**
+   * Process the queue in two phases.
+   *
+   * Phase 1: Look for flush markers. When a flush marker is found (even if not at the very front),
+   *   send all text tokens that came before it immediately (ignoring sentence boundaries)
+   *   and then send the flush command. Repeat until there are no flush markers left.
+   *
+   * Phase 2: With the remaining queue (now containing only text items), accumulate text
+   *   up to MAX_CHUNK_SIZE and use sentence-boundary logic to determine a chunk.
+   *   Then, remove the exact tokens (or portions thereof) that were consumed.
+   */
+  async _feedQueue(handlingTimeout = false) {
+    this.logger.debug({ queue: this.queue }, 'TtsStreamingBuffer:_feedQueue');
+    try {
+      if (!this.cs.isTtsStreamOpen || !this.ep) {
+        this.logger.debug('TtsStreamingBuffer:_feedQueue TTS stream is not open or no endpoint available');
+        return;
+      }
+      if (
+        this._connectionStatus === TtsStreamingConnectionStatus.NotConnected ||
+        this._connectionStatus === TtsStreamingConnectionStatus.Failed
+      ) {
+        this.logger.debug('TtsStreamingBuffer:_feedQueue TTS stream is not connected');
+        return;
+      }
+
+      // --- Phase 1: Process flush markers ---
+      // Process any flush marker that isn’t in the very first position.
+      let flushIndex = this.queue.findIndex((item, idx) => item.type === 'flush' && idx > 0);
+      while (flushIndex !== -1) {
+        let flushText = '';
+        // Accumulate all text tokens preceding the flush marker.
+        for (let i = 0; i < flushIndex; i++) {
+          if (this.queue[i].type === 'text') {
+            flushText += this.queue[i].value;
+          }
+        }
+        // Remove those text items.
+        for (let i = 0; i < flushIndex; i++) {
+          const item = this.queue.shift();
+          if (item.type === 'text') {
+            this.bufferedLength -= item.value.length;
+          }
+        }
+        // Remove the flush marker (now at the front).
+        if (this.queue.length > 0 && this.queue[0].type === 'flush') {
+          this.queue.shift();
+        }
+        // Immediately send all accumulated text (ignoring sentence boundaries).
+        if (flushText.length > 0) {
+          const modifiedFlushText = flushText.replace(/\n\n/g, '\n \n');
+          try {
+            await this._api(this.ep, [this.ep.uuid, 'send', modifiedFlushText]);
+          } catch (err) {
+            this.logger.info({ err, flushText }, 'TtsStreamingBuffer:_feedQueue Error sending TTS chunk');
+          }
+        }
+        // Send the flush command.
+        await this._doFlush();
+
+        flushIndex = this.queue.findIndex((item, idx) => item.type === 'flush' && idx > 0);
+      }
+
+      // If a flush marker is at the very front, process it.
+      while (this.queue.length > 0 && this.queue[0].type === 'flush') {
+        this.queue.shift();
+        await this._doFlush();
+      }
+
+      // --- Phase 2: Process remaining text tokens ---
+      if (this.queue.length === 0) {
+        this._removeTimer();
+        return;
+      }
+
+      // Accumulate contiguous text tokens (from the front) up to MAX_CHUNK_SIZE.
+      let combinedText = '';
+      for (const item of this.queue) {
+        if (item.type !== 'text') break;
+        combinedText += item.value;
+        if (combinedText.length >= MAX_CHUNK_SIZE) break;
+      }
+      if (combinedText.length === 0) {
+        this._removeTimer();
+        return;
+      }
+
+      const limit = Math.min(MAX_CHUNK_SIZE, combinedText.length);
+      let chunkEnd = findSentenceBoundary(combinedText, limit);
+      if (chunkEnd <= 0) {
+        if (handlingTimeout) {
+          chunkEnd = findWordBoundary(combinedText, limit);
+          if (chunkEnd <= 0) {
+            this._setTimerIfNeeded();
+            return;
+          }
+        } else {
+          this._setTimerIfNeeded();
+          return;
+        }
+      }
+      const chunk = combinedText.slice(0, chunkEnd);
+
+      // Now we iterate over the queue items
+      // and deduct their lengths until we've accounted for chunkEnd characters.
+      let remaining = chunkEnd;
+      let tokensProcessed = 0;
+      for (let i = 0; i < this.queue.length; i++) {
+        const token = this.queue[i];
+        if (token.type !== 'text') break;
+        if (remaining >= token.value.length) {
+          remaining -= token.value.length;
+          tokensProcessed = i + 1;
+        } else {
+          // Partially consumed token: update its value to remove the consumed part.
+          token.value = token.value.slice(remaining);
+          tokensProcessed = i;
+          remaining = 0;
+          break;
+        }
+      }
+      // Remove the fully consumed tokens from the front of the queue.
+      this.queue.splice(0, tokensProcessed);
+      this.bufferedLength -= chunkEnd;
+
+      const modifiedChunk = chunk.replace(/\n\n/g, '\n \n');
+      this.logger.debug(`TtsStreamingBuffer:_feedQueue sending chunk to tts: ${modifiedChunk}`);
+
+      try {
+        await this._api(this.ep, [this.ep.uuid, 'send', modifiedChunk]);
+      } catch (err) {
+        this.logger.info({ err, chunk }, 'TtsStreamingBuffer:_feedQueue Error sending TTS chunk');
+      }
+
+      if (this._isFull && this.bufferedLength <= LOW_WATER_BUFFER_SIZE) {
+        this.logger.info('TtsStreamingBuffer throttling: buffer is no longer full - resuming');
+        this._isFull = false;
+        this.emit(TtsStreamingEvents.Resume);
+      }
+
+      return this._feedQueue();
+    } catch (err) {
+      this.logger.info({ err }, 'TtsStreamingBuffer:_feedQueue Error sending TTS chunk');
+      this.queue = [];
+      this.bufferedLength = 0;
+    }
+  }
+
+  async _api(ep, args) {
+    const apiCmd = `uuid_${this.vendor.startsWith('custom:') ? 'custom' : this.vendor}_tts_streaming`;
+    const res = await ep.api(apiCmd, `^^|${args.join('|')}`);
+    if (!res.body?.startsWith('+OK')) {
+      this.logger.info({ args }, `Error calling ${apiCmd}: ${res.body}`);
+      throw new Error(`Error calling ${apiCmd}: ${res.body}`);
+    }
+  }
+
+  _doFlush() {
+    return this._api(this.ep, [this.ep.uuid, 'flush'])
+      .then(() => this.logger.debug('TtsStreamingBuffer:_doFlush sent flush command'))
+      .catch((err) =>
+        this.logger.info(
+          { err },
+          `TtsStreamingBuffer:_doFlush Error flushing TTS streaming: ${JSON.stringify(err)}`
+        )
+      );
+  }
+
+  async _onConnect(vendor) {
+    this.logger.info(`TtsStreamingBuffer:_onConnect streaming tts connection made to ${vendor} successful`);
+    this._connectionStatus = TtsStreamingConnectionStatus.Connected;
+    if (this.queue.length > 0) {
+      await this._feedQueue();
+    }
+  }
+
+  _onConnectFailure(vendor) {
+    this.logger.info(`TtsStreamingBuffer:_onConnectFailure streaming tts connection failed to ${vendor}`);
+    this._connectionStatus = TtsStreamingConnectionStatus.Failed;
+    this.queue = [];
+    this.bufferedLength = 0;
+    this.emit(TtsStreamingEvents.ConnectFailure, { vendor });
+  }
+
+  _setTimerIfNeeded() {
+    if (this.bufferedLength > 0 && !this.timer) {
+      this.logger.debug({queue: this.queue},
+        `TtsStreamingBuffer:_setTimerIfNeeded setting timer because ${this.bufferedLength} buffered`);
+      this.timer = setTimeout(this._onTimeout.bind(this), TIMEOUT_RETRY_MSECS);
+    }
+  }
+
+  _removeTimer() {
+    if (this.timer) {
+      this.logger.debug('TtsStreamingBuffer:_removeTimer clearing timer');
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+
+  _onTimeout() {
+    this.logger.debug('TtsStreamingBuffer:_onTimeout Timeout waiting for sentence boundary');
+    this.timer = null;
+    // Check if new text has been added since the timer was set.
+    const now = Date.now();
+    if (now - this.lastUpdateTime < TIMEOUT_RETRY_MSECS) {
+      this.logger.debug('TtsStreamingBuffer:_onTimeout New text received recently; postponing flush.');
+      this._setTimerIfNeeded();
+      return;
+    }
+    this._feedQueue(true);
+  }
+
+  _onTtsEmpty(vendor) {
+    this.emit(TtsStreamingEvents.Empty, { vendor });
+  }
+
+  addCustomEventListener(ep, event, handler) {
+    this.eventHandlers.push({ ep, event, handler });
+    ep.addCustomEventListener(event, handler);
+  }
+
+  removeCustomEventListeners() {
+    this.eventHandlers.forEach((h) => h.ep.removeCustomEventListener(h.event, h.handler));
+  }
+
+  _initHandlers(ep) {
+    [
+      'deepgram',
+      'cartesia',
+      'elevenlabs',
+      'rimelabs',
+      'custom'
+    ].forEach((vendor) => {
+      const eventClassName = `${vendor.charAt(0).toUpperCase() + vendor.slice(1)}TtsStreamingEvents`;
+      const eventClass = require('../utils/constants')[eventClassName];
+      if (!eventClass) throw new Error(`Event class for vendor ${vendor} not found`);
+
+      this.addCustomEventListener(ep, eventClass.Connect, this._onConnect.bind(this, vendor));
+      this.addCustomEventListener(ep, eventClass.ConnectFailure, this._onConnectFailure.bind(this, vendor));
+      this.addCustomEventListener(ep, eventClass.Empty, this._onTtsEmpty.bind(this, vendor));
+    });
+  }
+}
+
+const findSentenceBoundary = (text, limit) => {
+  // Look for punctuation or double newline that signals sentence end.
+  const sentenceEndRegex = /[.!?](?=\s|$)|\n\n/g;
+  let lastSentenceBoundary = -1;
+  let match;
+  while ((match = sentenceEndRegex.exec(text)) && match.index < limit) {
+    const precedingText = text.slice(0, match.index).trim();
+    if (precedingText.length > 0) {
+      if (
+        match[0] === '\n\n' ||
+        (match.index === 0 || !/\d$/.test(text[match.index - 1]))
+      ) {
+        lastSentenceBoundary = match.index + (match[0] === '\n\n' ? 2 : 1);
+      }
+    }
+  }
+  return lastSentenceBoundary;
+};
+
+const findWordBoundary = (text, limit) => {
+  const wordBoundaryRegex = /\s+/g;
+  let lastWordBoundary = -1;
+  let match;
+  while ((match = wordBoundaryRegex.exec(text)) && match.index < limit) {
+    lastWordBoundary = match.index;
+  }
+  return lastWordBoundary;
+};
+
+module.exports = TtsStreamingBuffer;

lib/utils/ws-requestor.js

@@ -1,12 +1,32 @@
 const assert = require('assert');
 const BaseRequestor = require('./base-requestor');
 const short = require('short-uuid');
-const {HookMsgTypes} = require('./constants.json');
+const parseUrl = require('parse-url');
+const {HookMsgTypes, WS_CLOSE_CODES} = require('./constants.json');
 const Websocket = require('ws');
 const snakeCaseKeys = require('./snakecase-keys');
-const HttpRequestor = require('./http-requestor');
-const MAX_RECONNECTS = 5;
-const RESPONSE_TIMEOUT_MS = process.env.JAMBONES_WS_API_MSG_RESPONSE_TIMEOUT || 5000;
+const {
+  RESPONSE_TIMEOUT_MS,
+  JAMBONES_WS_PING_INTERVAL_MS,
+  MAX_RECONNECTS,
+  JAMBONES_WS_HANDSHAKE_TIMEOUT_MS,
+  JAMBONES_WS_MAX_PAYLOAD,
+  HTTP_USER_AGENT_HEADER
+} = require('../config');
+const MTYPE_WANTS_ACK = [
+  'call:status',
+  'verb:status',
+  'jambonz:error',
+  'llm:event',
+  'llm:tool-call',
+  'tts:streaming-event',
+  'tts:tokens-result',
+];
+const MTYPE_NO_DATA = [
+  'llm:tool-output',
+  'tts:flush',
+  'tts:clear'
+];
 
 class WsRequestor extends BaseRequestor {
   constructor(logger, account_sid, hook, secret) {
@@ -22,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));
   }
 
@@ -36,76 +69,170 @@ class WsRequestor extends BaseRequestor {
    * @param {string} [hook.password] - if basic auth is protecting the endpoint
    * @param {object} [params] - request parameters
    */
-  async request(type, hook, params, httpHeaders = {}) {
+  async request(type, hook, params, httpHeaders = {}, span) {
     assert(HookMsgTypes.includes(type));
     const url = hook.url || hook;
+    const wantsAck = !MTYPE_WANTS_ACK.includes(type);
 
     if (this.maliciousClient) {
       this.logger.info({url: this.url}, 'WsRequestor:request - discarding msg to malicious client');
       return;
     }
     if (this.closedGracefully) {
-      this.logger.debug(`WsRequestor:request - discarding ${type} because we closed the socket`);
+      this.logger.debug(`WsRequestor:request - discarding ${type} because socket was closed gracefully`);
       return;
     }
 
     if (type === 'session:new') this.call_sid = params.callSid;
+    if (type === 'session:reconnect') {
+      this._reconnectPromise = new Promise((resolve, reject) => {
+        this._reconnectResolve = resolve;
+        this._reconnectReject = reject;
+      });
+    }
 
     /* if we have an absolute url, and it is http then do a standard webhook */
     if (this._isAbsoluteUrl(url) && url.startsWith('http')) {
+      const HttpRequestor = require('./http-requestor');
       this.logger.debug({hook}, 'WsRequestor: sending a webhook (HTTP)');
-      const requestor = new HttpRequestor(this.logger, this.account_sid, hook, this.secret);
-      return requestor.request(type, hook, params, httpHeaders);
+      const h = typeof hook === 'object' ? hook : {url: hook};
+      const requestor = new HttpRequestor(this.logger, this.account_sid, h, this.secret);
+      if (type === 'session:redirect') {
+        this.close();
+        this.emit('handover', requestor);
+      }
+      return requestor.request(type, hook, params, httpHeaders, span);
     }
 
     /* connect if necessary */
+    const queueMsg = () => {
+      this.logger.debug(
+        `WsRequestor:request(${this.id}) - queueing ${type} message since we are connecting`);
+      if (wantsAck) {
+        const p = new Promise((resolve, reject) => {
+          this.queuedMsg.push({type, hook, params, httpHeaders, promise: {resolve, reject}});
+        });
+        return p;
+      }
+      else {
+        this.queuedMsg.push({type, hook, params, httpHeaders});
+      }
+      return;
+    };
     if (!this.ws) {
       if (this.connectInProgress) {
-        this.logger.debug(
-          `WsRequestor:request(${this.id}) - queueing ${type} message since we are connecting`);
-        this.queuedMsg.push({type, hook, params, httpHeaders});
-        return;
+        return queueMsg();
       }
       this.connectInProgress = true;
-      this.logger.debug(`WsRequestor:request(${this.id}) - connecting since we do not have a connection`);
-      if (this.connections >= MAX_RECONNECTS) {
-        throw new Error(`max attempts connecting to ${this.url}`);
-      }
+      this.logger.debug(`WsRequestor:request(${this.id}) - connecting since we do not have a connection for ${type}`);
+
       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;
-        throw err;
+        return Promise.reject(err);
       }
     }
+    // If jambonz wait for ack from reconnect, queue the msg until reconnect is acked
+    if (type !== 'session:reconnect' && this._reconnectPromise) {
+      return queueMsg();
+    }
     assert(this.ws);
 
     /* prepare and send message */
-    let payload = params ? snakeCaseKeys(params, ['customerData', 'sip']) : null;
-    if (type === 'session:new') this._sessionData = payload;
+    let payload = params ? snakeCaseKeys(params, ['customerData', 'sip', 'env_vars', 'args']) : null;
+    if (type === 'session:new' || type === 'session:adulting') this._sessionData = payload;
     if (type === 'session:reconnect') payload = this._sessionData;
     assert.ok(url, 'WsRequestor:request url was not provided');
 
     const msgid = short.generate();
+    // save initial msgid in case we need to reconnect during initial session:new
+    if (type === 'session:new') this._initMsgId = msgid;
+
     const b3 = httpHeaders?.b3 ? {b3: httpHeaders.b3} : {};
     const obj = {
       type,
       msgid,
       call_sid: this.call_sid,
-      hook: type === 'verb:hook' ? url : undefined,
+      hook: [
+        'verb:hook', 'dial:confirm', 'session:redirect', 'llm:event', 'llm:tool-call'
+      ].includes(type) ? url : undefined,
       data: {...payload},
       ...b3
     };
+    // add msgid to span attributes if it exists
+    if (span) {
+      span.setAttributes({'msgid': msgid});
+    }
 
     const sendQueuedMsgs = () => {
       if (this.queuedMsg.length > 0) {
-        for (const {type, hook, params, httpHeaders} of this.queuedMsg) {
+        for (const {type, hook, params, httpHeaders, promise} of this.queuedMsg) {
           this.logger.debug(`WsRequestor:request - preparing queued ${type} for sending`);
-          setImmediate(this.request.bind(this, type, hook, params, httpHeaders));
+          if (promise) {
+            this.request(type, hook, params, httpHeaders, span)
+              .then((res) => promise.resolve(res))
+              .catch((err) => promise.reject(err));
+          }
+          else setImmediate(this.request.bind(this, type, hook, params, httpHeaders));
+        }
+        this.queuedMsg.length = 0;
+      }
+    };
+
+    const rejectQueuedMsgs = (err) => {
+      if (this.queuedMsg.length > 0) {
+        for (const {promise} of this.queuedMsg) {
+          this.logger.debug(`WsRequestor:request - preparing queued ${type} for rejectQueuedMsgs`);
+          if (promise) {
+            promise.reject(err);
+          }
         }
         this.queuedMsg.length = 0;
       }
@@ -113,9 +240,19 @@ class WsRequestor extends BaseRequestor {
 
     //this.logger.debug({obj}, `websocket: sending (${url})`);
 
+    /* special case: reconnecting before we received ack to session:new */
+    let reconnectingWithoutAck = false;
+    if (type === 'session:reconnect' && this._initMsgId) {
+      reconnectingWithoutAck = true;
+      const obj = this.messagesInFlight.get(this._initMsgId);
+      this.messagesInFlight.delete(this._initMsgId);
+      this.messagesInFlight.set(msgid, obj);
+      this._initMsgId = msgid;
+    }
+
     /* simple notifications */
-    if (['call:status', 'jambonz:error', 'session:reconnect'].includes(type)) {
-      this.ws.send(JSON.stringify(obj), () => {
+    if (!wantsAck || reconnectingWithoutAck) {
+      this.ws?.send(JSON.stringify(obj), () => {
         this.logger.debug({obj}, `WsRequestor:request websocket: sent (${url})`);
         sendQueuedMsgs();
       });
@@ -126,7 +263,7 @@ class WsRequestor extends BaseRequestor {
     return new Promise((resolve, reject) => {
       /* give the far end a reasonable amount of time to ack our message */
       const timer = setTimeout(() => {
-        const {failure} = this.messagesInFlight.get(msgid);
+        const {failure} = this.messagesInFlight.get(msgid) || {};
         failure && failure(`timeout from far end for msgid ${msgid}`);
         this.messagesInFlight.delete(msgid);
       }, RESPONSE_TIMEOUT_MS);
@@ -141,37 +278,60 @@ class WsRequestor extends BaseRequestor {
           this.logger.debug({response}, `WsRequestor:request ${url} succeeded in ${rtt}ms`);
           this.stats.histogram('app.hook.ws_response_time', rtt, ['hook_type:app']);
           resolve(response);
+          if (this._reconnectResolve) {
+            this._reconnectResolve();
+          }
         },
         failure: (err) => {
+          if (this._reconnectReject) {
+            this._reconnectReject(err);
+          }
           clearTimeout(timer);
           reject(err);
         }
       });
 
       /* send the message */
-      this.ws.send(JSON.stringify(obj), () => {
-        this.logger.debug({obj}, `WsRequestor:request websocket: sent (${url})`);
+      this.ws.send(JSON.stringify(obj), async() => {
+        if (obj.type !== 'llm:event') this.logger.debug({obj}, `WsRequestor:request websocket: sent (${url})`);
+        // If session:reconnect is waiting for ack, hold here until ack to send queuedMsgs
+        if (this._reconnectPromise) {
+          try {
+            await this._reconnectPromise;
+          } catch (err) {
+            // bad thing happened to session:recconnect
+            rejectQueuedMsgs(err);
+            this.emit('reconnect-error');
+            return;
+          } finally {
+            this._reconnectPromise = null;
+            this._reconnectResolve = null;
+            this._reconnectReject = null;
+          }
+        }
         sendQueuedMsgs();
       });
     });
   }
 
-  close() {
+  _stopPingTimer() {
+    if (this._pingTimer) {
+      clearInterval(this._pingTimer);
+      this._pingTimer = null;
+    }
+  }
+
+  close(code = WS_CLOSE_CODES.NormalClosure) {
     this.closedGracefully = true;
-    this.logger.debug('WsRequestor:close closing socket');
+    this.logger.debug(`WsRequestor:close closing socket with code ${code}`);
+    this._stopPingTimer();
     try {
       if (this.ws) {
-        this.ws.close();
+        this.ws.close(code);
         this.ws.removeAllListeners();
+        this.ws = null;
       }
-
-      for (const [msgid, obj] of this.messagesInFlight) {
-        const {timer} = obj;
-        clearTimeout(timer);
-        obj.failure(`abandoning msgid ${msgid} since we have closed the socket`);
-      }
-      this.messagesInFlight.clear();
-
+      this._clearPendingMessages();
     } catch (err) {
       this.logger.info({err}, 'WsRequestor: Error closing socket');
     }
@@ -179,35 +339,44 @@ class WsRequestor extends BaseRequestor {
 
   _connect() {
     assert(!this.ws);
+    this._stopPingTimer();
     return new Promise((resolve, reject) => {
-      const handshakeTimeout = process.env.JAMBONES_WS_HANDSHAKE_TIMEOUT_MS ?
-        parseInt(process.env.JAMBONES_WS_HANDSHAKE_TIMEOUT_MS) :
+      const handshakeTimeout = JAMBONES_WS_HANDSHAKE_TIMEOUT_MS ?
+        parseInt(JAMBONES_WS_HANDSHAKE_TIMEOUT_MS) :
         1500;
       let opts = {
         followRedirects: true,
         maxRedirects: 2,
         handshakeTimeout,
-        maxPayload: process.env.JAMBONES_WS_MAX_PAYLOAD ? parseInt(process.env.JAMBONES_WS_MAX_PAYLOAD) : 24 * 1024,
+        maxPayload: JAMBONES_WS_MAX_PAYLOAD ? parseInt(JAMBONES_WS_MAX_PAYLOAD) : 24 * 1024,
+        headers: {
+          ...(HTTP_USER_AGENT_HEADER && {'user-agent' : HTTP_USER_AGENT_HEADER})
+        }
       };
       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);
     });
   }
 
   _setHandlers(ws) {
-    this.logger.debug('WsRequestor:_setHandlers');
     ws
       .once('open', this._onOpen.bind(this, ws))
       .once('close', this._onClose.bind(this))
@@ -216,11 +385,23 @@ class WsRequestor extends BaseRequestor {
       .on('error', this._onError.bind(this));
   }
 
-  _onError(err) {
-    if (this.connections > 0) {
-      this.logger.info({url: this.url, err}, 'WsRequestor:_onError');
+  _clearPendingMessages() {
+    for (const [msgid, obj] of this.messagesInFlight) {
+      const {timer} = obj;
+      clearTimeout(timer);
+      if (!this._initMsgId) obj.failure(`abandoning msgid ${msgid} since socket is closed`);
+    }
+    this.messagesInFlight.clear();
+  }
+
+  _onError(err) {
+    if (this.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) {
@@ -231,10 +412,15 @@ class WsRequestor extends BaseRequestor {
     this.connectInProgress = false;
     this.connections++;
     this.emit('ready', ws);
+
+    if (JAMBONES_WS_PING_INTERVAL_MS > 15000) {
+      this._pingTimer = setInterval(() => this.ws?.ping(), JAMBONES_WS_PING_INTERVAL_MS);
+    }
   }
 
   _onClose(code) {
     this.logger.info(`WsRequestor(${this.id}) - closed from far end ${code}`);
+    this._stopPingTimer();
     if (this.connections > 0 && code !== 1000) {
       this.logger.info({url: this.url}, 'WsRequestor - socket closed unexpectedly from remote side');
       this.emit('socket-closed');
@@ -252,25 +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}`));
+
+    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');
-    if (this.connections > 0 && this.connections < MAX_RECONNECTS && !this.closedGracefully) {
+    this._stopPingTimer();
+
+    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;
-          this._connect().catch((err) => 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) {
@@ -284,7 +489,10 @@ class WsRequestor extends BaseRequestor {
     /* messages must be JSON format */
     try {
       const obj = JSON.parse(content);
-      const {type, msgid, command, call_sid = this.call_sid, queueCommand = false, data} = obj;
+      this.logger.debug({obj}, 'WsRequestor:_onMessage - received message');
+      //const {type, msgid, command, call_sid = this.call_sid, queueCommand = false, data} = obj;
+      const {type, msgid, command, queueCommand = false, tool_call_id, data} = obj;
+      const call_sid = obj.callSid || this.call_sid;
 
       //this.logger.debug({obj}, 'WsRequestor:request websocket: received');
       assert.ok(type, 'type property not supplied');
@@ -297,8 +505,8 @@ class WsRequestor extends BaseRequestor {
 
         case 'command':
           assert.ok(command, 'command property not supplied');
-          assert.ok(data, 'data property not supplied');
-          this._recvCommand(msgid, command, call_sid, queueCommand, data);
+          assert.ok(data || MTYPE_NO_DATA.includes(command), 'data property not supplied');
+          this._recvCommand(msgid, command, call_sid, queueCommand, tool_call_id, data);
           break;
 
         default:
@@ -306,25 +514,41 @@ class WsRequestor extends BaseRequestor {
       }
     } catch (err) {
       this.logger.info({err, content}, 'WsRequestor:_onMessage - invalid incoming message');
+      const params = {
+        msg: 'InvalidMessage',
+        details: err.message,
+        content: Buffer.from(content).toString('utf-8')
+      };
+      const {writeAlerts, AlertType} = this.Alerter;
+      writeAlerts({
+        account_sid: this.account_sid,
+        alert_type: AlertType.INVALID_APP_PAYLOAD,
+        target_sid: this.call_sid,
+        message: err.message,
+
+      }).catch((err) => this.logger.info({err}, 'Error generating alert for invalid message'));
+      this.request('jambonz:error', '/error', params)
+        .catch((err) => this.logger.debug({err}, 'WsRequestor:_onMessage - Error sending'));
     }
   }
 
   _recvAck(msgid, data) {
+    this._initMsgId = null;
     const obj = this.messagesInFlight.get(msgid);
     if (!obj) {
       this.logger.info({url: this.url}, `WsRequestor:_recvAck - ack to unknown msgid ${msgid}, discarding`);
       return;
     }
-    this.logger.debug({url: this.url}, `WsRequestor:_recvAck - received response to ${msgid}`);
+    //this.logger.debug({url: this.url}, `WsRequestor:_recvAck - received response to ${msgid}`);
     this.messagesInFlight.delete(msgid);
     const {success} = obj;
     success && success(data);
   }
 
-  _recvCommand(msgid, command, call_sid, queueCommand, data) {
+  _recvCommand(msgid, command, call_sid, queueCommand, tool_call_id, data) {
     // TODO: validate command
     this.logger.debug({msgid, command, call_sid, queueCommand, data}, 'received command');
-    this.emit('command', {msgid, command, call_sid, queueCommand, data});
+    this.emit('command', {msgid, command, call_sid, queueCommand, tool_call_id, data});
   }
 }
 

package.json

@@ -1,9 +1,9 @@
 {
   "name": "jambonz-feature-server",
-  "version": "v0.7.7",
+  "version": "0.9.5",
   "main": "app.js",
   "engines": {
-    "node": ">= 10.16.0"
+    "node": ">= 18.x"
   },
   "keywords": [
     "sip",
@@ -19,55 +19,62 @@
   "bugs": {},
   "scripts": {
     "start": "node app",
-    "test": "NODE_ENV=test JAMBONES_HOSTING=1 HTTP_POOL=1 DRACHTIO_HOST=127.0.0.1 DRACHTIO_PORT=9060 DRACHTIO_SECRET=cymru JAMBONES_MYSQL_HOST=127.0.0.1 JAMBONES_MYSQL_PORT=3360 JAMBONES_MYSQL_USER=jambones_test JAMBONES_MYSQL_PASSWORD=jambones_test JAMBONES_MYSQL_DATABASE=jambones_test JAMBONES_REDIS_HOST=127.0.0.1 JAMBONES_REDIS_PORT=16379 JAMBONES_LOGLEVEL=error ENABLE_METRICS=0 HTTP_PORT=3000 JAMBONES_SBCS=172.38.0.10 JAMBONES_FREESWITCH=127.0.0.1:8022:ClueCon:docker-host JAMBONES_TIME_SERIES_HOST=127.0.0.1 JAMBONES_NETWORK_CIDR=172.38.0.0/16 node test/ ",
+    "test": "NODE_ENV=test JAMBONES_HOSTING=1 HTTP_POOL=1 JAMBONES_TTS_TRIM_SILENCE=1 ENCRYPTION_SECRET=foobar DRACHTIO_HOST=127.0.0.1 DRACHTIO_PORT=9060 DRACHTIO_SECRET=cymru JAMBONES_MYSQL_HOST=127.0.0.1 JAMBONES_MYSQL_PORT=3360 JAMBONES_MYSQL_USER=jambones_test JAMBONES_MYSQL_PASSWORD=jambones_test JAMBONES_MYSQL_DATABASE=jambones_test JAMBONES_REDIS_HOST=127.0.0.1 JAMBONES_REDIS_PORT=16379 JAMBONES_LOGLEVEL=error ENABLE_METRICS=0 HTTP_PORT=3000 JAMBONES_SBCS=172.38.0.10 JAMBONES_FREESWITCH=127.0.0.1:8022:JambonzR0ck$:docker-host JAMBONES_TIME_SERIES_HOST=127.0.0.1 JAMBONES_NETWORK_CIDR=172.38.0.0/16 node test/ ",
     "coverage": "./node_modules/.bin/nyc --reporter html --report-dir ./coverage npm run test",
-    "jslint": "eslint app.js lib"
+    "jslint": "eslint app.js tracer.js lib",
+    "jslint:fix": "eslint app.js tracer.js lib --fix"
   },
   "dependencies": {
+    "@aws-sdk/client-auto-scaling": "^3.549.0",
+    "@aws-sdk/client-sns": "^3.549.0",
+    "@jambonz/db-helpers": "^0.9.16",
     "@jambonz/http-health-check": "^0.0.1",
-    "@jambonz/db-helpers": "^0.6.19",
-    "@jambonz/realtimedb-helpers": "^0.4.35",
-    "@jambonz/stats-collector": "^0.1.6",
-    "@jambonz/time-series": "^0.2.5",
-    "@opentelemetry/api": "^1.1.0",
-    "@opentelemetry/exporter-jaeger": "^1.3.1",
-    "@opentelemetry/exporter-trace-otlp-http": "^0.27.0",
-    "@opentelemetry/exporter-zipkin": "^1.3.1",
-    "@opentelemetry/instrumentation": "^0.27.0",
-    "@opentelemetry/resources": "^1.3.1",
-    "@opentelemetry/sdk-trace-base": "^1.3.1",
-    "@opentelemetry/sdk-trace-node": "^1.3.1",
-    "@opentelemetry/semantic-conventions": "^1.3.1",
-    "aws-sdk": "^2.1152.0",
+    "@jambonz/mw-registrar": "^0.2.7",
+    "@jambonz/realtimedb-helpers": "^0.8.15",
+    "@jambonz/speech-utils": "^0.2.22",
+    "@jambonz/stats-collector": "^0.1.10",
+    "@jambonz/time-series": "^0.2.14",
+    "@jambonz/verb-specifications": "^0.0.113",
+    "@modelcontextprotocol/sdk": "^1.9.0",
+    "@opentelemetry/api": "^1.8.0",
+    "@opentelemetry/exporter-jaeger": "^1.23.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.50.0",
+    "@opentelemetry/exporter-zipkin": "^1.23.0",
+    "@opentelemetry/instrumentation": "^0.50.0",
+    "@opentelemetry/resources": "^1.23.0",
+    "@opentelemetry/sdk-trace-base": "^1.23.0",
+    "@opentelemetry/sdk-trace-node": "^1.23.0",
+    "@opentelemetry/semantic-conventions": "^1.23.0",
     "bent": "^7.3.12",
     "debug": "^4.3.4",
     "deepcopy": "^2.1.0",
-    "drachtio-fsmrf": "^3.0.3",
-    "drachtio-srf": "^4.5.1",
-    "express": "^4.18.1",
-    "helmet": "^5.1.0",
-    "ip": "^1.1.8",
-    "moment": "^2.29.4",
-    "parse-url": "^8.1.0",
-    "pino": "^6.14.0",
-    "sdp-transform": "^2.14.1",
-    "short-uuid": "^4.2.0",
+    "drachtio-fsmrf": "^4.1.2",
+    "drachtio-srf": "^5.0.5",
+    "express": "^4.19.2",
+    "express-validator": "^7.0.1",
+    "moment": "^2.30.1",
+    "parse-url": "^9.2.0",
+    "pino": "^8.20.0",
+    "polly-ssml-split": "^0.1.0",
+    "sdp-transform": "^2.15.0",
+    "short-uuid": "^5.1.0",
+    "sinon": "^17.0.1",
     "to-snake-case": "^1.0.0",
-    "undici": "^5.8.2",
-    "uuid": "^8.3.2",
+    "undici": "^7.5.0",
     "verify-aws-sns-signature": "^0.1.0",
-    "ws": "^8.8.0",
-    "xml2js": "^0.4.23"
+    "ws": "^8.18.0",
+    "xml2js": "^0.6.2"
   },
   "devDependencies": {
     "clear-module": "^4.1.2",
-    "eslint": "^7.32.0",
-    "eslint-plugin-promise": "^4.3.1",
+    "eslint": "7.32.0",
+    "eslint-plugin-promise": "^6.1.1",
     "nyc": "^15.1.0",
-    "tape": "^5.5.3"
+    "proxyquire": "^2.1.3",
+    "tape": "^5.7.5"
   },
   "optionalDependencies": {
-    "bufferutil": "^4.0.6",
-    "utf-8-validate": "^5.0.8"
+    "bufferutil": "^4.0.8",
+    "utf-8-validate": "^6.0.3"
   }
 }

test/config-test.js

@@ -0,0 +1,102 @@
+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')
+
+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('\'config: listen\'', async(t) => {
+  clearModule.all();
+  const {srf, disconnect} = require('../app');
+  try {
+    await connect(srf);
+
+    // GIVEN
+    const from = "config_listen_success";
+    let verbs = [
+      {
+        "verb": "config",
+        "listen": {
+          "enable": true,
+          "url": `ws://172.38.0.60:3000/${from}`
+        }
+      },
+      {
+        "verb": "pause",
+        "length": 5
+      }
+    ];
+
+    await provisionCallHook(from, verbs);
+
+    // THEN
+    await sippUac('uac-gather-account-creds-success-send-bye.xml', '172.38.0.10', from);
+    let obj = await getJSON(`http://127.0.0.1:3100/ws_packet_count/${from}`);
+    t.pass('config: successfully started background listen');
+
+    disconnect();
+  } catch (err) {
+    console.log(`error received: ${err}`);
+    disconnect();
+    t.error(err);
+  }
+});
+
+test('\'config: listen - stop\'', async(t) => {
+  clearModule.all();
+  const {srf, disconnect} = require('../app');
+  try {
+    await connect(srf);
+
+    // GIVEN
+    const from = "config_listen_success";
+    let verbs = [
+      {
+        "verb": "config",
+        "listen": {
+          "enable": true,
+          "url": `ws://172.38.0.60:3000/${from}`
+        }
+      },
+      {
+        "verb": "pause",
+        "length": 1
+      },
+      {
+        "verb": "config",
+        "listen": {
+          "enable": false
+        }
+      },
+      {
+        "verb": "pause",
+        "length": 3
+      }
+    ];
+
+    await provisionCallHook(from, verbs);
+
+    // THEN
+    await sippUac('uac-gather-account-creds-success-send-bye.xml', '172.38.0.10', from);
+    let obj = await getJSON(`http://127.0.0.1:3100/ws_packet_count/${from}`);
+    t.pass('config: successfully started then stopped background listen');
+
+    disconnect();
+  } catch (err) {
+    console.log(`error received: ${err}`);
+    disconnect();
+    t.error(err);
+  }
+});

test/configuration/squid.conf

@@ -0,0 +1,86 @@
+#
+# Recommended minimum configuration:
+#
+
+# Example rule allowing access from your local networks.
+# Adapt to list your (internal) IP networks from where browsing
+# should be allowed
+acl localnet src 0.0.0.1-0.255.255.255	# RFC 1122 "this" network (LAN)
+acl localnet src 10.0.0.0/8		# RFC 1918 local private network (LAN)
+acl localnet src 100.64.0.0/10		# RFC 6598 shared address space (CGN)
+acl localnet src 169.254.0.0/16 	# RFC 3927 link-local (directly plugged) machines
+acl localnet src 172.16.0.0/12		# RFC 1918 local private network (LAN)
+acl localnet src 172.38.0.0/12		# RFC 1918 local private network (LAN)
+acl localnet src 192.168.0.0/16		# RFC 1918 local private network (LAN)
+acl localnet src fc00::/7       	# RFC 4193 local private network range
+acl localnet src fe80::/10      	# RFC 4291 link-local (directly plugged) machines
+
+acl SSL_ports port 443
+acl Safe_ports port 80		# http
+acl Safe_ports port 21		# ftp
+acl Safe_ports port 443		# https
+acl Safe_ports port 70		# gopher
+acl Safe_ports port 210		# wais
+acl Safe_ports port 1025-65535	# unregistered ports
+acl Safe_ports port 280		# http-mgmt
+acl Safe_ports port 488		# gss-http
+acl Safe_ports port 591		# filemaker
+acl Safe_ports port 777		# multiling http
+
+#
+# Recommended minimum Access Permission configuration:
+#
+# Deny requests to certain unsafe ports
+http_access allow !Safe_ports
+
+# Deny CONNECT to other than secure SSL ports
+http_access allow CONNECT !SSL_ports
+
+# Only allow cachemgr access from localhost
+http_access allow localhost manager
+http_access allow manager
+
+# This default configuration only allows localhost requests because a more
+# permissive Squid installation could introduce new attack vectors into the
+# network by proxying external TCP connections to unprotected services.
+http_access allow localhost
+
+# The two deny rules below are unnecessary in this default configuration
+# because they are followed by a "deny all" rule. However, they may become
+# critically important when you start allowing external requests below them.
+
+# Protect web applications running on the same server as Squid. They often
+# assume that only local users can access them at "localhost" ports.
+http_access allow to_localhost
+
+# Protect cloud servers that provide local users with sensitive info about
+# their server via certain well-known link-local (a.k.a. APIPA) addresses.
+# http_access deny to_linklocal
+
+#
+# INSERT YOUR OWN RULE(S) HERE TO ALLOW ACCESS FROM YOUR CLIENTS
+#
+
+# For example, to allow access from your local networks, you may uncomment the
+# following rule (and/or add rules that match your definition of "local"):
+# http_access allow localnet
+
+# And finally deny all other access to this proxy
+http_access allow all
+
+# Squid normally listens to port 3128
+http_port 3128
+
+# Uncomment and adjust the following to add a disk cache directory.
+#cache_dir ufs /usr/local/var/cache/squid 100 16 256
+
+# Leave coredumps in the first cache dir
+coredump_dir /usr/local/var/cache/squid
+
+#
+# Add any of your own refresh_pattern entries above these.
+#
+refresh_pattern ^ftp:		1440	20%	10080
+refresh_pattern ^gopher:	1440	0%	1440
+refresh_pattern -i (/cgi-bin/|\?) 0	0%	0
+refresh_pattern .		0	20%	4320

test/create-call-test.js

@@ -37,7 +37,7 @@ test('test create-call timeout', async(t) => {
       'account_sid':account_sid,
       'timeout': 1,
       "call_hook": {
-        "url": "https://public-apps.jambonz.us/hello-world",
+        "url": "https://public-apps.jambonz.cloud/hello-world",
         "method": "POST"
       },
       "from": "15083718299",
@@ -88,17 +88,192 @@ test('test create-call call-hook basic authentication', async(t) => {
 
     let verbs = [
       {
-        "verb": "say",
-        "text": "hello"
+        "verb": "pause",
+        "length": 1
       }
     ];
-    provisionCallHook(from, verbs);
+    await provisionCallHook(from, verbs);
     //THEN
     await p;
 
     let obj = await getJSON(`http:127.0.0.1:3100/lastRequest/${from}`)
     t.ok(obj.headers.Authorization = 'Basic dXNlcm5hbWU6cGFzc3dvcmQ=',
       'create-call: call-hook contains basic authentication header');
+    t.ok(obj.headers['user-agent'] = 'jambonz',
+    'create-call: call-hook contains user-agent header');
+    disconnect();
+  } catch (err) {
+    console.log(`error received: ${err}`);
+    disconnect();
+    t.error(err);
+  }
+});
+
+test('test create-call amd', async(t) => {
+  clearModule.all();
+  const {srf, disconnect} = require('../app');
+
+  try {
+    await connect(srf);
+
+
+    // GIVEN
+    let from = 'create-call-amd';
+    let account_sid = 'bb845d4b-83a9-4cde-a6e9-50f3743bab3f';
+
+    // Give UAS app time to come up
+    const p = sippUac('uas.xml', '172.38.0.10', from);
+    await waitFor(1000);
+
+    const post = bent('http://127.0.0.1:3000/', 'POST', 'json', 201);
+    post('v1/createCall', {
+      'account_sid':account_sid,
+      "call_hook": {
+        "url": "http://127.0.0.1:3100/",
+        "method": "POST",
+        "username": "username",
+        "password": "password"
+      },
+      "from": from,
+      "to": {
+        "type": "phone",
+        "number": "15583084809"
+      },
+      "amd": {
+        "actionHook": "/actionHook"
+      },
+      "speech_recognizer_vendor": "google",
+      "speech_recognizer_language": "en"
+    });
+
+    let verbs = [
+      {
+        "verb": "pause",
+        "length": 7
+      }
+    ];
+    await provisionCallHook(from, verbs);
+    //THEN
+    await p;
+
+    let obj = await getJSON(`http:127.0.0.1:3100/lastRequest/${from}_actionHook`)
+    t.ok(obj.body.type = 'amd_no_speech_detected',
+      'create-call: AMD detected');
+    disconnect();
+  } catch (err) {
+    console.log(`error received: ${err}`);
+    disconnect();
+    t.error(err);
+  }
+});
+
+test('test create-call app_json', async(t) => {
+  clearModule.all();
+  const {srf, disconnect} = require('../app');
+
+  try {
+    await connect(srf);
+
+
+    // GIVEN
+    let from = 'create-call-app-json';
+    let account_sid = 'bb845d4b-83a9-4cde-a6e9-50f3743bab3f';
+
+    // Give UAS app time to come up
+    const p = sippUac('uas.xml', '172.38.0.10', from);
+    await waitFor(1000);
+
+    const app_json = `[
+      {
+        "verb": "pause",
+        "length": 7
+      }
+    ]`;
+
+    const post = bent('http://127.0.0.1:3000/', 'POST', 'json', 201);
+    post('v1/createCall', {
+      'account_sid':account_sid,
+      "call_hook": {
+        "url": "http://127.0.0.1:3100/",
+        "method": "POST",
+        "username": "username",
+        "password": "password"
+      },
+      app_json,
+      "from": from,
+      "to": {
+        "type": "phone",
+        "number": "15583084809"
+      },
+      "amd": {
+        "actionHook": "/actionHook"
+      },
+      "speech_recognizer_vendor": "google",
+      "speech_recognizer_language": "en"
+    });
+
+    //THEN
+    await p;
+
+    disconnect();
+  } catch (err) {
+    console.log(`error received: ${err}`);
+    disconnect();
+    t.error(err);
+  }
+});
+
+test('test create-call timeLimit', async(t) => {
+  clearModule.all();
+  const {srf, disconnect} = require('../app');
+
+  try {
+    await connect(srf);
+
+
+    // GIVEN
+    let from = 'create-call-app-json';
+    let account_sid = 'bb845d4b-83a9-4cde-a6e9-50f3743bab3f';
+
+    // Give UAS app time to come up
+    const p = sippUac('uas.xml', '172.38.0.10', from);
+    await waitFor(1000);
+
+    const startTime = Date.now();
+
+    const app_json = `[
+      {
+        "verb": "pause",
+        "length": 7
+      }
+    ]`;
+
+    const post = bent('http://127.0.0.1:3000/', 'POST', 'json', 201);
+    post('v1/createCall', {
+      'account_sid':account_sid,
+      "call_hook": {
+        "url": "http://127.0.0.1:3100/",
+        "method": "POST",
+        "username": "username",
+        "password": "password"
+      },
+      app_json,
+      "from": from,
+      "to": {
+        "type": "phone",
+        "number": "15583084809"
+      },
+      "timeLimit": 1,
+      "speech_recognizer_vendor": "google",
+      "speech_recognizer_language": "en"
+    });
+
+    //THEN
+    await p;
+    const endTime = Date.now();
+
+    t.ok(endTime - startTime < 2000, 'create-call: timeLimit is respected');
+
     disconnect();
   } catch (err) {
     console.log(`error received: ${err}`);

test/create-test-db.js

@@ -2,6 +2,14 @@ const test = require('tape') ;
 const exec = require('child_process').exec ;
 const fs = require('fs');
 const {encrypt} = require('../lib/utils/encrypt-decrypt');
+const {
+  GCP_JSON_KEY,
+  AWS_ACCESS_KEY_ID,
+  AWS_SECRET_ACCESS_KEY,
+  AWS_REGION,
+  MICROSOFT_REGION,
+  MICROSOFT_API_KEY,
+} = require('../lib/config');
 
 test('creating jambones_test database', (t) => {
   exec(`mysql -h 127.0.0.1 -u root --protocol=tcp --port=3360 < ${__dirname}/db/create_test_db.sql`, (err, stdout, stderr) => {
@@ -18,24 +26,38 @@ test('creating schema', (t) => {
     if (err) return t.end(err);
     t.pass('schema and test data successfully created');
 
-    if (process.env.GCP_JSON_KEY && process.env.AWS_ACCESS_KEY_ID && process.env.AWS_SECRET_ACCESS_KEY) {
-      const google_credential = encrypt(process.env.GCP_JSON_KEY);
+    const sql = [];
+    if (GCP_JSON_KEY) {
+      const google_credential = encrypt(GCP_JSON_KEY);
+      t.pass('adding google credentials');
+      sql.push(`UPDATE speech_credentials SET credential='${google_credential}' WHERE vendor='google';`);
+    }
+    if (AWS_ACCESS_KEY_ID && AWS_SECRET_ACCESS_KEY) {
       const aws_credential = encrypt(JSON.stringify({
-        access_key_id: process.env.AWS_ACCESS_KEY_ID,
-        secret_access_key: process.env.AWS_SECRET_ACCESS_KEY
+        access_key_id: AWS_ACCESS_KEY_ID,
+        secret_access_key: AWS_SECRET_ACCESS_KEY,
+        aws_region: AWS_REGION
       }));
-      const cmd = `
-UPDATE speech_credentials SET credential='${google_credential}' WHERE vendor='google';
-UPDATE speech_credentials SET credential='${aws_credential}' WHERE vendor='aws';
-`;
+      t.pass('adding aws credentials');
+      sql.push(`UPDATE speech_credentials SET credential='${aws_credential}' WHERE vendor='aws';`);
+    }
+    if (MICROSOFT_REGION && MICROSOFT_API_KEY) {
+      const microsoft_credential = encrypt(JSON.stringify({
+        region: MICROSOFT_REGION,
+        api_key: MICROSOFT_API_KEY
+      }));
+      t.pass('adding microsoft credentials');
+      sql.push(`UPDATE speech_credentials SET credential='${microsoft_credential}' WHERE vendor='microsoft';`);
+    }
+    if (sql.length > 0) {
       const path = `${__dirname}/.creds.sql`;
-      fs.writeFileSync(path, cmd);
+      const cmd = sql.join('\n');
+      fs.writeFileSync(path, sql.join('\n'));
       exec(`mysql -h 127.0.0.1 -u root --protocol=tcp --port=3360  -D jambones_test < ${path}`, (err, stdout, stderr) => {
         console.log(stdout);
         console.log(stderr);
         if (err) return t.end(err);
         fs.unlinkSync(path)
-        fs.writeFileSync(`${__dirname}/credentials/gcp.json`, process.env.GCP_JSON_KEY);
         t.pass('set account-level speech credentials');
         t.end();
       });

test/data/bad/bad-say-ssml.json

@@ -0,0 +1,9 @@
+{
+  "say": {
+    "text": "<speak>I already told you <emphasis level=\"strong\">I already told you I already told you I already told you I already told you! I already told you I already told you I already told you I already told you? I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you told I already told you I already told you told I already told you I already told you. I already told you <break time=\"3s\"/> I really like that person!</emphasis> this is another long text.</speak>",
+    "synthesizer": {
+      "vendor": "google",
+      "language": "en-US"
+    }
+  }
+}

test/data/good/say-ssml.json

@@ -0,0 +1,9 @@
+{
+  "say": {
+    "text": "<speak>I already told you I already told you I already told you I already told you I already told you! I already told you I already told you I already told you I already told you? I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you I already told you told I already told you I already told you told I already told you I already told you. I already told you <break time=\"3s\"/> I <emphasis level=\"strong\">really like that person!</emphasis> this is another long text.</speak>",
+    "synthesizer": {
+      "vendor": "google",
+      "language": "en-US"
+    }
+  }
+}

test/db/jambones-sql.sql

@@ -4,6 +4,8 @@ SET FOREIGN_KEY_CHECKS=0;
 
 DROP TABLE IF EXISTS account_static_ips;
 
+DROP TABLE IF EXISTS account_limits;
+
 DROP TABLE IF EXISTS account_products;
 
 DROP TABLE IF EXISTS account_subscriptions;
@@ -12,12 +14,22 @@ DROP TABLE IF EXISTS beta_invite_codes;
 
 DROP TABLE IF EXISTS call_routes;
 
+DROP TABLE IF EXISTS clients;
+
 DROP TABLE IF EXISTS dns_records;
 
+DROP TABLE IF EXISTS lcr;
+
 DROP TABLE IF EXISTS lcr_carrier_set_entry;
 
 DROP TABLE IF EXISTS lcr_routes;
 
+DROP TABLE IF EXISTS password_settings;
+
+DROP TABLE IF EXISTS user_permissions;
+
+DROP TABLE IF EXISTS permissions;
+
 DROP TABLE IF EXISTS predefined_sip_gateways;
 
 DROP TABLE IF EXISTS predefined_smpp_gateways;
@@ -36,12 +48,18 @@ DROP TABLE IF EXISTS sbc_addresses;
 
 DROP TABLE IF EXISTS ms_teams_tenants;
 
+DROP TABLE IF EXISTS service_provider_limits;
+
 DROP TABLE IF EXISTS signup_history;
 
 DROP TABLE IF EXISTS smpp_addresses;
 
+DROP TABLE IF EXISTS google_custom_voices;
+
 DROP TABLE IF EXISTS speech_credentials;
 
+DROP TABLE IF EXISTS system_information;
+
 DROP TABLE IF EXISTS users;
 
 DROP TABLE IF EXISTS smpp_gateways;
@@ -69,6 +87,15 @@ private_ipv4 VARBINARY(16) NOT NULL UNIQUE ,
 PRIMARY KEY (account_static_ip_sid)
 );
 
+CREATE TABLE account_limits
+(
+account_limits_sid CHAR(36) NOT NULL UNIQUE ,
+account_sid CHAR(36) NOT NULL,
+category ENUM('api_rate','voice_call_session', 'device','voice_call_minutes','voice_call_session_license', 'voice_call_minutes_license') NOT NULL,
+quantity INTEGER NOT NULL,
+PRIMARY KEY (account_limits_sid)
+);
+
 CREATE TABLE account_subscriptions
 (
 account_subscription_sid CHAR(36) NOT NULL UNIQUE ,
@@ -105,6 +132,19 @@ application_sid CHAR(36) NOT NULL,
 PRIMARY KEY (call_route_sid)
 ) COMMENT='a regex-based pattern match for call routing';
 
+CREATE TABLE clients
+(
+client_sid CHAR(36) NOT NULL UNIQUE ,
+account_sid CHAR(36) NOT NULL,
+is_active BOOLEAN NOT NULL DEFAULT 1,
+username VARCHAR(64),
+password VARCHAR(1024),
+allow_direct_app_calling BOOLEAN NOT NULL DEFAULT 1,
+allow_direct_queue_calling BOOLEAN NOT NULL DEFAULT 1,
+allow_direct_user_calling BOOLEAN NOT NULL DEFAULT 1,
+PRIMARY KEY (client_sid)
+);
+
 CREATE TABLE dns_records
 (
 dns_record_sid CHAR(36) NOT NULL UNIQUE ,
@@ -117,11 +157,38 @@ PRIMARY KEY (dns_record_sid)
 CREATE TABLE lcr_routes
 (
 lcr_route_sid CHAR(36),
+lcr_sid CHAR(36) NOT NULL,
 regex VARCHAR(32) NOT NULL COMMENT 'regex-based pattern match against dialed number, used for LCR routing of PSTN calls',
 description VARCHAR(1024),
-priority INTEGER NOT NULL UNIQUE  COMMENT 'lower priority routes are attempted first',
+priority INTEGER NOT NULL COMMENT 'lower priority routes are attempted first',
 PRIMARY KEY (lcr_route_sid)
-) COMMENT='Least cost routing table';
+) COMMENT='An ordered list of  digit patterns in an LCR table.  The patterns are tested in sequence until one matches';
+
+CREATE TABLE lcr
+(
+lcr_sid CHAR(36) NOT NULL UNIQUE ,
+name VARCHAR(64) COMMENT 'User-assigned name for this LCR table',
+is_active BOOLEAN NOT NULL DEFAULT 1,
+default_carrier_set_entry_sid CHAR(36) COMMENT 'default carrier/route to use when no digit match based results are found.',
+service_provider_sid CHAR(36),
+account_sid CHAR(36),
+PRIMARY KEY (lcr_sid)
+) COMMENT='An LCR (least cost routing) table that is used by a service provider or account to make decisions about routing outbound calls when multiple carriers are available.';
+
+CREATE TABLE password_settings
+(
+min_password_length INTEGER NOT NULL DEFAULT 8,
+require_digit BOOLEAN NOT NULL DEFAULT false,
+require_special_character BOOLEAN NOT NULL DEFAULT false
+);
+
+CREATE TABLE permissions
+(
+permission_sid CHAR(36) NOT NULL UNIQUE ,
+name VARCHAR(32) NOT NULL UNIQUE ,
+description VARCHAR(255),
+PRIMARY KEY (permission_sid)
+);
 
 CREATE TABLE predefined_carriers
 (
@@ -214,7 +281,10 @@ CREATE TABLE sbc_addresses
 sbc_address_sid CHAR(36) NOT NULL UNIQUE ,
 ipv4 VARCHAR(255) NOT NULL,
 port INTEGER NOT NULL DEFAULT 5060,
+tls_port INTEGER,
+wss_port INTEGER,
 service_provider_sid CHAR(36),
+last_updated DATETIME,
 PRIMARY KEY (sbc_address_sid)
 );
 
@@ -228,6 +298,15 @@ tenant_fqdn VARCHAR(255) NOT NULL UNIQUE ,
 PRIMARY KEY (ms_teams_tenant_sid)
 ) COMMENT='A Microsoft Teams customer tenant';
 
+CREATE TABLE service_provider_limits
+(
+service_provider_limits_sid CHAR(36) NOT NULL UNIQUE ,
+service_provider_sid CHAR(36) NOT NULL,
+category ENUM('api_rate','voice_call_session', 'device','voice_call_minutes','voice_call_session_license', 'voice_call_minutes_license') NOT NULL,
+quantity INTEGER NOT NULL,
+PRIMARY KEY (service_provider_limits_sid)
+);
+
 CREATE TABLE signup_history
 (
 email VARCHAR(255) NOT NULL,
@@ -261,9 +340,31 @@ last_tested DATETIME,
 tts_tested_ok BOOLEAN,
 stt_tested_ok BOOLEAN,
 created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+label VARCHAR(64),
 PRIMARY KEY (speech_credential_sid)
 );
 
+CREATE TABLE google_custom_voices
+(
+google_custom_voice_sid CHAR(36) NOT NULL UNIQUE ,
+speech_credential_sid CHAR(36) NOT NULL,
+model VARCHAR(512) NOT NULL,
+reported_usage ENUM('REPORTED_USAGE_UNSPECIFIED','REALTIME','OFFLINE') DEFAULT 'REALTIME',
+name VARCHAR(64) NOT NULL,
+voice_cloning_key MEDIUMTEXT,
+use_voice_cloning_key BOOLEAN DEFAULT false,
+PRIMARY KEY (google_custom_voice_sid)
+);
+
+CREATE TABLE system_information
+(
+domain_name VARCHAR(255),
+sip_domain_name VARCHAR(255),
+monitoring_domain_name VARCHAR(255),
+private_network_cidr VARCHAR(8192),
+log_level ENUM('info', 'debug') NOT NULL DEFAULT 'info'
+);
+
 CREATE TABLE users
 (
 user_sid CHAR(36) NOT NULL UNIQUE ,
@@ -283,6 +384,7 @@ email_activation_code VARCHAR(16),
 email_validated BOOLEAN NOT NULL DEFAULT false,
 phone_validated BOOLEAN NOT NULL DEFAULT false,
 email_content_opt_out BOOLEAN NOT NULL DEFAULT false,
+is_active BOOLEAN NOT NULL DEFAULT true,
 PRIMARY KEY (user_sid)
 );
 
@@ -310,9 +412,21 @@ smpp_password VARCHAR(64),
 smpp_enquire_link_interval INTEGER DEFAULT 0,
 smpp_inbound_system_id VARCHAR(255),
 smpp_inbound_password VARCHAR(64),
+register_from_user VARCHAR(128),
+register_from_domain VARCHAR(255),
+register_public_ip_in_contact BOOLEAN NOT NULL DEFAULT false,
+register_status VARCHAR(4096),
 PRIMARY KEY (voip_carrier_sid)
 ) COMMENT='A Carrier or customer PBX that can send or receive calls';
 
+CREATE TABLE user_permissions
+(
+user_permissions_sid CHAR(36) NOT NULL UNIQUE ,
+user_sid CHAR(36) NOT NULL,
+permission_sid CHAR(36) NOT NULL,
+PRIMARY KEY (user_permissions_sid)
+);
+
 CREATE TABLE smpp_gateways
 (
 smpp_gateway_sid CHAR(36) NOT NULL UNIQUE ,
@@ -330,7 +444,7 @@ PRIMARY KEY (smpp_gateway_sid)
 CREATE TABLE phone_numbers
 (
 phone_number_sid CHAR(36) UNIQUE ,
-number VARCHAR(32) NOT NULL UNIQUE ,
+number VARCHAR(132) NOT NULL,
 voip_carrier_sid CHAR(36),
 account_sid CHAR(36),
 application_sid CHAR(36),
@@ -343,11 +457,15 @@ CREATE TABLE sip_gateways
 sip_gateway_sid CHAR(36),
 ipv4 VARCHAR(128) NOT NULL COMMENT 'ip address or DNS name of the gateway.  For gateways providing inbound calling service, ip address is required.',
 netmask INTEGER NOT NULL DEFAULT 32,
-port INTEGER NOT NULL DEFAULT 5060 COMMENT 'sip signaling port',
+port INTEGER COMMENT 'sip signaling port',
 inbound BOOLEAN NOT NULL COMMENT 'if true, whitelist this IP to allow inbound calls from the gateway',
 outbound BOOLEAN NOT NULL COMMENT 'if true, include in least-cost routing when placing calls to the PSTN',
 voip_carrier_sid CHAR(36) NOT NULL,
 is_active BOOLEAN NOT NULL DEFAULT 1,
+send_options_ping BOOLEAN NOT NULL DEFAULT 0,
+use_sips_scheme BOOLEAN NOT NULL DEFAULT 0,
+pad_crypto BOOLEAN NOT NULL DEFAULT 0,
+protocol ENUM('udp','tcp','tls', 'tls/srtp') DEFAULT 'udp' COMMENT 'Outbound call protocol',
 PRIMARY KEY (sip_gateway_sid)
 ) COMMENT='A whitelisted sip gateway used for origination/termination';
 
@@ -380,12 +498,24 @@ account_sid CHAR(36) COMMENT 'account that this application belongs to (if null,
 call_hook_sid CHAR(36) COMMENT 'webhook to call for inbound calls ',
 call_status_hook_sid CHAR(36) COMMENT 'webhook to call for call status events',
 messaging_hook_sid CHAR(36) COMMENT 'webhook to call for inbound SMS/MMS ',
+app_json TEXT,
 speech_synthesis_vendor VARCHAR(64) NOT NULL DEFAULT 'google',
 speech_synthesis_language VARCHAR(12) NOT NULL DEFAULT 'en-US',
-speech_synthesis_voice VARCHAR(64),
+speech_synthesis_voice VARCHAR(256),
+speech_synthesis_label VARCHAR(64),
 speech_recognizer_vendor VARCHAR(64) NOT NULL DEFAULT 'google',
 speech_recognizer_language VARCHAR(64) NOT NULL DEFAULT 'en-US',
+speech_recognizer_label VARCHAR(64),
+use_for_fallback_speech BOOLEAN DEFAULT false,
+fallback_speech_synthesis_vendor VARCHAR(64),
+fallback_speech_synthesis_language VARCHAR(12),
+fallback_speech_synthesis_voice VARCHAR(256),
+fallback_speech_synthesis_label VARCHAR(64),
+fallback_speech_recognizer_vendor VARCHAR(64),
+fallback_speech_recognizer_language VARCHAR(64),
+fallback_speech_recognizer_label VARCHAR(64),
 created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+record_all_calls BOOLEAN NOT NULL DEFAULT false,
 PRIMARY KEY (application_sid)
 ) COMMENT='A defined set of behaviors to be applied to phone calls ';
 
@@ -418,6 +548,15 @@ disable_cdrs BOOLEAN NOT NULL DEFAULT 0,
 trial_end_date DATETIME,
 deactivated_reason VARCHAR(255),
 device_to_call_ratio INTEGER NOT NULL DEFAULT 5,
+subspace_client_id VARCHAR(255),
+subspace_client_secret VARCHAR(255),
+subspace_sip_teleport_id VARCHAR(255),
+subspace_sip_teleport_destinations VARCHAR(255),
+siprec_hook_sid CHAR(36),
+record_all_calls BOOLEAN NOT NULL DEFAULT false,
+record_format VARCHAR(16) NOT NULL DEFAULT 'mp3',
+bucket_credential VARCHAR(8192) COMMENT 'credential used to authenticate with storage service',
+enable_debug_log BOOLEAN NOT NULL DEFAULT false,
 PRIMARY KEY (account_sid)
 ) COMMENT='An enterprise that uses the platform for comm services';
 
@@ -425,19 +564,34 @@ CREATE INDEX account_static_ip_sid_idx ON account_static_ips (account_static_ip_
 CREATE INDEX account_sid_idx ON account_static_ips (account_sid);
 ALTER TABLE account_static_ips ADD FOREIGN KEY account_sid_idxfk (account_sid) REFERENCES accounts (account_sid);
 
+CREATE INDEX account_sid_idx ON account_limits (account_sid);
+ALTER TABLE account_limits ADD FOREIGN KEY account_sid_idxfk_1 (account_sid) REFERENCES accounts (account_sid) ON DELETE CASCADE;
+
 CREATE INDEX account_subscription_sid_idx ON account_subscriptions (account_subscription_sid);
 CREATE INDEX account_sid_idx ON account_subscriptions (account_sid);
-ALTER TABLE account_subscriptions ADD FOREIGN KEY account_sid_idxfk_1 (account_sid) REFERENCES accounts (account_sid);
+ALTER TABLE account_subscriptions ADD FOREIGN KEY account_sid_idxfk_2 (account_sid) REFERENCES accounts (account_sid);
 
 CREATE INDEX invite_code_idx ON beta_invite_codes (invite_code);
 CREATE INDEX call_route_sid_idx ON call_routes (call_route_sid);
-ALTER TABLE call_routes ADD FOREIGN KEY account_sid_idxfk_2 (account_sid) REFERENCES accounts (account_sid);
+ALTER TABLE call_routes ADD FOREIGN KEY account_sid_idxfk_3 (account_sid) REFERENCES accounts (account_sid);
 
 ALTER TABLE call_routes ADD FOREIGN KEY application_sid_idxfk (application_sid) REFERENCES applications (application_sid);
 
-CREATE INDEX dns_record_sid_idx ON dns_records (dns_record_sid);
-ALTER TABLE dns_records ADD FOREIGN KEY account_sid_idxfk_3 (account_sid) REFERENCES accounts (account_sid);
+CREATE INDEX client_sid_idx ON clients (client_sid);
+ALTER TABLE clients ADD CONSTRAINT account_sid_idxfk_13 FOREIGN KEY account_sid_idxfk_13 (account_sid) REFERENCES accounts (account_sid);
 
+CREATE INDEX dns_record_sid_idx ON dns_records (dns_record_sid);
+ALTER TABLE dns_records ADD FOREIGN KEY account_sid_idxfk_4 (account_sid) REFERENCES accounts (account_sid);
+
+CREATE INDEX lcr_sid_idx ON lcr_routes (lcr_sid);
+ALTER TABLE lcr_routes ADD FOREIGN KEY lcr_sid_idxfk (lcr_sid) REFERENCES lcr (lcr_sid);
+
+CREATE INDEX lcr_sid_idx ON lcr (lcr_sid);
+ALTER TABLE lcr ADD FOREIGN KEY default_carrier_set_entry_sid_idxfk (default_carrier_set_entry_sid) REFERENCES lcr_carrier_set_entry (lcr_carrier_set_entry_sid);
+
+CREATE INDEX service_provider_sid_idx ON lcr (service_provider_sid);
+CREATE INDEX account_sid_idx ON lcr (account_sid);
+CREATE INDEX permission_sid_idx ON permissions (permission_sid);
 CREATE INDEX predefined_carrier_sid_idx ON predefined_carriers (predefined_carrier_sid);
 CREATE INDEX predefined_sip_gateway_sid_idx ON predefined_sip_gateways (predefined_sip_gateway_sid);
 CREATE INDEX predefined_carrier_sid_idx ON predefined_sip_gateways (predefined_carrier_sid);
@@ -456,14 +610,14 @@ ALTER TABLE account_products ADD FOREIGN KEY product_sid_idxfk (product_sid) REF
 
 CREATE INDEX account_offer_sid_idx ON account_offers (account_offer_sid);
 CREATE INDEX account_sid_idx ON account_offers (account_sid);
-ALTER TABLE account_offers ADD FOREIGN KEY account_sid_idxfk_4 (account_sid) REFERENCES accounts (account_sid);
+ALTER TABLE account_offers ADD FOREIGN KEY account_sid_idxfk_5 (account_sid) REFERENCES accounts (account_sid);
 
 CREATE INDEX product_sid_idx ON account_offers (product_sid);
 ALTER TABLE account_offers ADD FOREIGN KEY product_sid_idxfk_1 (product_sid) REFERENCES products (product_sid);
 
 CREATE INDEX api_key_sid_idx ON api_keys (api_key_sid);
 CREATE INDEX account_sid_idx ON api_keys (account_sid);
-ALTER TABLE api_keys ADD FOREIGN KEY account_sid_idxfk_5 (account_sid) REFERENCES accounts (account_sid);
+ALTER TABLE api_keys ADD FOREIGN KEY account_sid_idxfk_6 (account_sid) REFERENCES accounts (account_sid);
 
 CREATE INDEX service_provider_sid_idx ON api_keys (service_provider_sid);
 ALTER TABLE api_keys ADD FOREIGN KEY service_provider_sid_idxfk (service_provider_sid) REFERENCES service_providers (service_provider_sid);
@@ -477,59 +631,72 @@ ALTER TABLE sbc_addresses ADD FOREIGN KEY service_provider_sid_idxfk_1 (service_
 CREATE INDEX ms_teams_tenant_sid_idx ON ms_teams_tenants (ms_teams_tenant_sid);
 ALTER TABLE ms_teams_tenants ADD FOREIGN KEY service_provider_sid_idxfk_2 (service_provider_sid) REFERENCES service_providers (service_provider_sid);
 
-ALTER TABLE ms_teams_tenants ADD FOREIGN KEY account_sid_idxfk_6 (account_sid) REFERENCES accounts (account_sid);
+ALTER TABLE ms_teams_tenants ADD FOREIGN KEY account_sid_idxfk_7 (account_sid) REFERENCES accounts (account_sid);
 
 ALTER TABLE ms_teams_tenants ADD FOREIGN KEY application_sid_idxfk_1 (application_sid) REFERENCES applications (application_sid);
 
 CREATE INDEX tenant_fqdn_idx ON ms_teams_tenants (tenant_fqdn);
+CREATE INDEX service_provider_sid_idx ON service_provider_limits (service_provider_sid);
+ALTER TABLE service_provider_limits ADD FOREIGN KEY service_provider_sid_idxfk_3 (service_provider_sid) REFERENCES service_providers (service_provider_sid) ON DELETE CASCADE;
+
 CREATE INDEX email_idx ON signup_history (email);
 CREATE INDEX smpp_address_sid_idx ON smpp_addresses (smpp_address_sid);
 CREATE INDEX service_provider_sid_idx ON smpp_addresses (service_provider_sid);
-ALTER TABLE smpp_addresses ADD FOREIGN KEY service_provider_sid_idxfk_3 (service_provider_sid) REFERENCES service_providers (service_provider_sid);
-
-CREATE UNIQUE INDEX speech_credentials_idx_1 ON speech_credentials (vendor,account_sid);
+ALTER TABLE smpp_addresses ADD FOREIGN KEY service_provider_sid_idxfk_4 (service_provider_sid) REFERENCES service_providers (service_provider_sid);
 
 CREATE INDEX speech_credential_sid_idx ON speech_credentials (speech_credential_sid);
 CREATE INDEX service_provider_sid_idx ON speech_credentials (service_provider_sid);
-ALTER TABLE speech_credentials ADD FOREIGN KEY service_provider_sid_idxfk_4 (service_provider_sid) REFERENCES service_providers (service_provider_sid);
+ALTER TABLE speech_credentials ADD FOREIGN KEY service_provider_sid_idxfk_5 (service_provider_sid) REFERENCES service_providers (service_provider_sid);
 
 CREATE INDEX account_sid_idx ON speech_credentials (account_sid);
-ALTER TABLE speech_credentials ADD FOREIGN KEY account_sid_idxfk_7 (account_sid) REFERENCES accounts (account_sid);
+ALTER TABLE speech_credentials ADD FOREIGN KEY account_sid_idxfk_8 (account_sid) REFERENCES accounts (account_sid);
+
+CREATE INDEX google_custom_voice_sid_idx ON google_custom_voices (google_custom_voice_sid);
+CREATE INDEX speech_credential_sid_idx ON google_custom_voices (speech_credential_sid);
+ALTER TABLE google_custom_voices ADD FOREIGN KEY speech_credential_sid_idxfk (speech_credential_sid) REFERENCES speech_credentials (speech_credential_sid) ON DELETE CASCADE;
 
 CREATE INDEX user_sid_idx ON users (user_sid);
 CREATE INDEX email_idx ON users (email);
 CREATE INDEX phone_idx ON users (phone);
 CREATE INDEX account_sid_idx ON users (account_sid);
-ALTER TABLE users ADD FOREIGN KEY account_sid_idxfk_8 (account_sid) REFERENCES accounts (account_sid);
+ALTER TABLE users ADD FOREIGN KEY account_sid_idxfk_9 (account_sid) REFERENCES accounts (account_sid);
 
 CREATE INDEX service_provider_sid_idx ON users (service_provider_sid);
-ALTER TABLE users ADD FOREIGN KEY service_provider_sid_idxfk_5 (service_provider_sid) REFERENCES service_providers (service_provider_sid);
+ALTER TABLE users ADD FOREIGN KEY service_provider_sid_idxfk_6 (service_provider_sid) REFERENCES service_providers (service_provider_sid);
 
 CREATE INDEX email_activation_code_idx ON users (email_activation_code);
 CREATE INDEX voip_carrier_sid_idx ON voip_carriers (voip_carrier_sid);
 CREATE INDEX account_sid_idx ON voip_carriers (account_sid);
-ALTER TABLE voip_carriers ADD FOREIGN KEY account_sid_idxfk_9 (account_sid) REFERENCES accounts (account_sid);
+ALTER TABLE voip_carriers ADD FOREIGN KEY account_sid_idxfk_10 (account_sid) REFERENCES accounts (account_sid);
 
 CREATE INDEX service_provider_sid_idx ON voip_carriers (service_provider_sid);
-ALTER TABLE voip_carriers ADD FOREIGN KEY service_provider_sid_idxfk_6 (service_provider_sid) REFERENCES service_providers (service_provider_sid);
+ALTER TABLE voip_carriers ADD FOREIGN KEY service_provider_sid_idxfk_7 (service_provider_sid) REFERENCES service_providers (service_provider_sid);
 
 ALTER TABLE voip_carriers ADD FOREIGN KEY application_sid_idxfk_2 (application_sid) REFERENCES applications (application_sid);
 
+CREATE INDEX user_permissions_sid_idx ON user_permissions (user_permissions_sid);
+CREATE INDEX user_sid_idx ON user_permissions (user_sid);
+ALTER TABLE user_permissions ADD FOREIGN KEY user_sid_idxfk (user_sid) REFERENCES users (user_sid) ON DELETE CASCADE;
+
+ALTER TABLE user_permissions ADD FOREIGN KEY permission_sid_idxfk (permission_sid) REFERENCES permissions (permission_sid);
+
 CREATE INDEX smpp_gateway_sid_idx ON smpp_gateways (smpp_gateway_sid);
 CREATE INDEX voip_carrier_sid_idx ON smpp_gateways (voip_carrier_sid);
 ALTER TABLE smpp_gateways ADD FOREIGN KEY voip_carrier_sid_idxfk (voip_carrier_sid) REFERENCES voip_carriers (voip_carrier_sid);
 
+CREATE UNIQUE INDEX phone_numbers_unique_idx_voip_carrier_number ON phone_numbers (number,voip_carrier_sid);
+
 CREATE INDEX phone_number_sid_idx ON phone_numbers (phone_number_sid);
 CREATE INDEX number_idx ON phone_numbers (number);
 CREATE INDEX voip_carrier_sid_idx ON phone_numbers (voip_carrier_sid);
 ALTER TABLE phone_numbers ADD FOREIGN KEY voip_carrier_sid_idxfk_1 (voip_carrier_sid) REFERENCES voip_carriers (voip_carrier_sid);
 
-ALTER TABLE phone_numbers ADD FOREIGN KEY account_sid_idxfk_10 (account_sid) REFERENCES accounts (account_sid);
+ALTER TABLE phone_numbers ADD FOREIGN KEY account_sid_idxfk_11 (account_sid) REFERENCES accounts (account_sid);
 
 ALTER TABLE phone_numbers ADD FOREIGN KEY application_sid_idxfk_3 (application_sid) REFERENCES applications (application_sid);
 
 CREATE INDEX service_provider_sid_idx ON phone_numbers (service_provider_sid);
-ALTER TABLE phone_numbers ADD FOREIGN KEY service_provider_sid_idxfk_7 (service_provider_sid) REFERENCES service_providers (service_provider_sid);
+ALTER TABLE phone_numbers ADD FOREIGN KEY service_provider_sid_idxfk_8 (service_provider_sid) REFERENCES service_providers (service_provider_sid);
 
 CREATE INDEX sip_gateway_idx_hostport ON sip_gateways (ipv4,port);
 
@@ -545,10 +712,10 @@ CREATE UNIQUE INDEX applications_idx_name ON applications (account_sid,name);
 
 CREATE INDEX application_sid_idx ON applications (application_sid);
 CREATE INDEX service_provider_sid_idx ON applications (service_provider_sid);
-ALTER TABLE applications ADD FOREIGN KEY service_provider_sid_idxfk_8 (service_provider_sid) REFERENCES service_providers (service_provider_sid);
+ALTER TABLE applications ADD FOREIGN KEY service_provider_sid_idxfk_9 (service_provider_sid) REFERENCES service_providers (service_provider_sid);
 
 CREATE INDEX account_sid_idx ON applications (account_sid);
-ALTER TABLE applications ADD FOREIGN KEY account_sid_idxfk_11 (account_sid) REFERENCES accounts (account_sid);
+ALTER TABLE applications ADD FOREIGN KEY account_sid_idxfk_12 (account_sid) REFERENCES accounts (account_sid);
 
 ALTER TABLE applications ADD FOREIGN KEY call_hook_sid_idxfk (call_hook_sid) REFERENCES webhooks (webhook_sid);
 
@@ -564,7 +731,7 @@ ALTER TABLE service_providers ADD FOREIGN KEY registration_hook_sid_idxfk (regis
 CREATE INDEX account_sid_idx ON accounts (account_sid);
 CREATE INDEX sip_realm_idx ON accounts (sip_realm);
 CREATE INDEX service_provider_sid_idx ON accounts (service_provider_sid);
-ALTER TABLE accounts ADD FOREIGN KEY service_provider_sid_idxfk_9 (service_provider_sid) REFERENCES service_providers (service_provider_sid);
+ALTER TABLE accounts ADD FOREIGN KEY service_provider_sid_idxfk_10 (service_provider_sid) REFERENCES service_providers (service_provider_sid);
 
 ALTER TABLE accounts ADD FOREIGN KEY registration_hook_sid_idxfk_1 (registration_hook_sid) REFERENCES webhooks (webhook_sid);
 
@@ -572,4 +739,6 @@ ALTER TABLE accounts ADD FOREIGN KEY queue_event_hook_sid_idxfk (queue_event_hoo
 
 ALTER TABLE accounts ADD FOREIGN KEY device_calling_application_sid_idxfk (device_calling_application_sid) REFERENCES applications (application_sid);
 
-SET FOREIGN_KEY_CHECKS=0;
+ALTER TABLE accounts ADD FOREIGN KEY siprec_hook_sid_idxfk (siprec_hook_sid) REFERENCES applications (application_sid);
+
+SET FOREIGN_KEY_CHECKS=1;