update to latest speech-utils

* support playht3.0 languages

* update speech utils version

.github/workflows/ci.yml

@@ -7,11 +7,21 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
+      - 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
       - uses: actions/setup-node@v3
         with:
           node-version: lts/*
       - run: npm install
       - 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: npm test
 
  

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

app.js

@@ -46,12 +46,15 @@ const {
   addKey,
   retrieveKey,
   deleteKey,
-  incrKey
+  incrKey,
+  listConferences
 } = require('./lib/helpers/realtimedb-helpers');
 const {
   getTtsVoices,
   getTtsSize,
   purgeTtsCache,
+  getAwsAuthToken,
+  getVerbioAccessToken,
   synthAudio
 } = require('@jambonz/speech-utils')({}, logger);
 const {
@@ -87,6 +90,7 @@ app.locals = {
   deleteCall,
   listCalls,
   listSortedSets,
+  listConferences,
   purgeCalls,
   retrieveSet,
   addKey,
@@ -95,6 +99,8 @@ app.locals = {
   deleteKey,
   getTtsVoices,
   getTtsSize,
+  getAwsAuthToken,
+  getVerbioAccessToken,
   purgeTtsCache,
   synthAudio,
   lookupAppBySid,

db/jambones-sql.sql

@@ -358,7 +358,9 @@ CREATE TABLE system_information
 (
 domain_name VARCHAR(255),
 sip_domain_name VARCHAR(255),
-monitoring_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
@@ -459,6 +461,7 @@ outbound BOOLEAN NOT NULL COMMENT 'if true, include in least-cost routing when p
 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)
@@ -551,6 +554,7 @@ 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';
 

db/upgrade-jambonz-db.js

@@ -196,6 +196,12 @@ const sql = {
     'ALTER TABLE sip_gateways ADD COLUMN send_options_ping BOOLEAN NOT NULL DEFAULT 0',
     'ALTER TABLE applications MODIFY COLUMN speech_synthesis_voice VARCHAR(256)',
     'ALTER TABLE applications MODIFY COLUMN fallback_speech_synthesis_voice VARCHAR(256)',
+    'ALTER TABLE sip_gateways ADD COLUMN use_sips_scheme BOOLEAN NOT NULL DEFAULT 0',
+  ],
+  9002: [
+    'ALTER TABLE system_information ADD COLUMN private_network_cidr VARCHAR(8192)',
+    'ALTER TABLE system_information ADD COLUMN log_level ENUM(\'info\', \'debug\') NOT NULL DEFAULT \'info\'',
+    'ALTER TABLE accounts ADD COLUMN enable_debug_log BOOLEAN NOT NULL DEFAULT false',
   ]
 };
 
@@ -229,6 +235,7 @@ const doIt = async() => {
         if (val < 8004) upgrades.push(...sql['8004']);
         if (val < 8005) upgrades.push(...sql['8005']);
         if (val < 9000) upgrades.push(...sql['9000']);
+        if (val < 9002) upgrades.push(...sql['9002']);
 
         // perform all upgrades
         logger.info({upgrades}, 'applying schema upgrades..');

lib/helpers/realtimedb-helpers.js

@@ -13,6 +13,7 @@ const {
   deleteKey,
   incrKey,
   client: redisClient,
+  listConferences
 } = require('@jambonz/realtimedb-helpers')({}, logger);
 
 module.exports = {
@@ -27,5 +28,6 @@ module.exports = {
   retrieveKey,
   deleteKey,
   redisClient,
-  incrKey
+  incrKey,
+  listConferences
 };

lib/models/speech-credential.js

@@ -23,10 +23,11 @@ class SpeechCredential extends Model {
   static async getSpeechCredentialsByVendorAndLabel(service_provider_sid, account_sid, vendor, label) {
     let sql;
     if (account_sid) {
-      sql = `SELECT * FROM speech_credentials WHERE account_sid = ? AND vendor = ? ${label ? 'AND label = ?' : ''}`;
+      sql = `SELECT * FROM speech_credentials WHERE account_sid = ? AND vendor = ?
+        AND label ${label ? '= ?' : 'is NULL'}`;
     } else {
       sql = `SELECT * FROM speech_credentials WHERE service_provider_sid = ? AND vendor = ?
-        ${label ? 'AND label = ?' : ''}`;
+        AND label ${label ? '= ?' : 'is NULL'}`;
     }
     const [rows] = await promisePool.query(sql, [account_sid ? account_sid : service_provider_sid, vendor, label]);
     return rows;

lib/models/system-information.js

@@ -33,6 +33,10 @@ SystemInformation.fields = [
     name: 'monitoring_domain_name',
     type: 'string',
   },
+  {
+    name: 'private_network_cidr',
+    type: 'string',
+  },
 ];
 
 module.exports = SystemInformation;

lib/record/s3-multipart-upload-stream.js

@@ -16,7 +16,7 @@ class S3MultipartUploadStream extends Writable {
     this.partNumber = 1;
     this.multipartETags = [];
     this.buffer = Buffer.alloc(0);
-    this.minPartSize = 2 * 1024 * 1024; // 5 MB
+    this.minPartSize = 5 * 1024 * 1024; // 5 MB
     this.s3 = new S3Client(opts.bucketCredential);
     this.metadata = opts.metadata;
   }

lib/record/upload.js

@@ -3,6 +3,7 @@ const Websocket = require('ws');
 const PCMToMP3Encoder = require('./encoder');
 const wav = require('wav');
 const { getUploader } = require('./utils');
+const { pipeline } = require('stream');
 
 async function upload(logger, socket) {
   socket._recvInitialMetadata = false;
@@ -60,22 +61,19 @@ async function upload(logger, socket) {
               bitrate: 128
             }, logger);
           }
-          const handleError = (err, streamType) => {
-            logger.error(
-              { err },
-              `Error while streaming for vendor: ${obj.vendor}, pipe: ${streamType}: ${err.message}`
-            );
-          };
 
           /* start streaming data */
-          const duplex = Websocket.createWebSocketStream(socket);
-          duplex
-            .on('error', (err) => handleError(err, 'duplex'))
-            .pipe(encoder)
-            .on('error', (err) => handleError(err, 'encoder'))
-            .pipe(uploadStream)
-            .on('error', (err) => handleError(err, 'uploadStream'));
-
+          pipeline(
+            Websocket.createWebSocketStream(socket),
+            encoder,
+            uploadStream,
+            (error) => {
+              if (error) {
+                logger.error({ error }, 'pipeline error, cannot upload data to storage');
+                socket.close();
+              }
+            }
+          );
         } else {
           logger.info(`account ${accountSid} does not have any bucket credential, close the socket`);
           socket.close();

lib/routes/api/accounts.js

@@ -265,7 +265,8 @@ function validateUpdateCall(opts) {
     'sip_request',
     'record',
     'tag',
-    'dtmf'
+    'dtmf',
+    'conferenceParticipantAction'
   ]
     .reduce((acc, prop) => (opts[prop] ? ++acc : acc), 0);
 
@@ -316,6 +317,19 @@ function validateUpdateCall(opts) {
   if (opts.tag && (typeof opts.tag !== 'object' || Array.isArray(opts.tag) || opts.tag === null)) {
     throw new DbErrorBadRequest('invalid tag data');
   }
+  if (opts.conferenceParticipantAction) {
+    if (!['tag', 'untag', 'coach', 'uncoach', 'mute', 'unmute', 'hold', 'unhold']
+      .includes(opts.conferenceParticipantAction.action)) {
+      throw new DbErrorBadRequest(
+        `conferenceParticipantAction invalid action property ${opts.conferenceParticipantAction.action}`);
+    }
+    if ('tag' == opts.conferenceParticipantAction.action && !opts.conferenceParticipantAction.tag) {
+      throw new DbErrorBadRequest('conferenceParticipantAction requires tag property when action is \'tag\'');
+    }
+    if ('coach' == opts.conferenceParticipantAction.action && !opts.conferenceParticipantAction.tag) {
+      throw new DbErrorBadRequest('conferenceParticipantAction requires tag property when action is \'coach\'');
+    }
+  }
 }
 
 function validateTo(to) {
@@ -1089,5 +1103,21 @@ router.get('/:sid/Queues', async(req, res) => {
   }
 });
 
+/**
+ * retrieve info for a list of conferences under an account
+ */
+router.get('/:sid/Conferences', async(req, res) => {
+  const {logger, listConferences} = req.app.locals;
+  try {
+    const accountSid = parseAccountSid(req);
+    await validateRequest(req, accountSid);
+    const conferences = await listConferences(accountSid);
+    logger.debug(`retrieved ${conferences.length} queues for account sid ${accountSid}`);
+    res.status(200).json(conferences.map((c) => c.split(':').pop()));
+    updateLastUsed(logger, accountSid, req).catch((err) => {});
+  } catch (err) {
+    sysError(logger, res, err);
+  }
+});
 
 module.exports = router;

lib/routes/api/sip-gateways.js

@@ -41,6 +41,7 @@ const checkUserScope = async(req, voip_carrier_sid) => {
 
 const validate = async(req, sid) => {
   const {lookupSipGatewayBySid} = req.app.locals;
+  const {netmask} = req.body;
   let voip_carrier_sid;
 
   if (sid) {
@@ -52,6 +53,12 @@ const validate = async(req, sid) => {
     voip_carrier_sid = req.body.voip_carrier_sid;
     if (!voip_carrier_sid) throw new DbErrorBadRequest('missing voip_carrier_sid');
   }
+  if (netmask &&
+    process.env.JAMBONZ_MIN_GATEWAY_NETMASK &&
+    parseInt(netmask) < process.env.JAMBONZ_MIN_GATEWAY_NETMASK) {
+    throw new DbErrorBadRequest(
+      `netmask required to have value equal or greater than ${process.env.JAMBONZ_MIN_GATEWAY_NETMASK}`);
+  }
   await checkUserScope(req, voip_carrier_sid);
 };
 

lib/routes/api/sip-realm.js

@@ -31,6 +31,7 @@ router.post('/:sip_realm', async(req, res) => {
       const [sbcs] = await promisePool.query('SELECT ipv4 from sbc_addresses');
       if (sbcs.length === 0) throw new Error('no SBC addresses provisioned in the database!');
       const ips = sbcs.map((s) => s.ipv4);
+      const uniqueIps = [...new Set(ips)];
 
       /* retrieve existing dns records */
       const [old_recs] = await promisePool.query('SELECT record_id from dns_records WHERE account_sid = ?',
@@ -48,7 +49,7 @@ router.post('/:sip_realm', async(req, res) => {
       }
 
       /* add the dns records */
-      const records = await createDnsRecords(logger, domain, subdomain, ips);
+      const records = await createDnsRecords(logger, domain, subdomain, uniqueIps);
       if (!records) throw new Error(`failure updating dns records for ${sip_realm}`);
       const values = records.map((r) => {
         return `('${uuid()}', '${account_sid}', '${r.type}', ${r.id})`;

lib/routes/api/speech-credentials.js

@@ -7,7 +7,11 @@ const {decrypt, encrypt} = require('../../utils/encrypt-decrypt');
 const {parseAccountSid, parseServiceProviderSid, parseSpeechCredentialSid} = require('./utils');
 const {decryptCredential, testWhisper, testDeepgramTTS,
   getLanguagesAndVoicesForVendor,
-  testPlayHT} = require('../../utils/speech-utils');
+  testPlayHT,
+  testRimelabs,
+  testVerbioTts,
+  testVerbioStt,
+  testSpeechmaticsStt} = require('../../utils/speech-utils');
 const {DbErrorUnprocessableRequest, DbErrorForbidden, DbErrorBadRequest} = require('../../utils/errors');
 const {
   testGoogleTts,
@@ -112,13 +116,17 @@ const encryptCredential = (obj) => {
     secret_access_key,
     aws_region,
     api_key,
+    role_arn,
     region,
     client_id,
+    client_secret,
     secret,
     nuance_tts_uri,
     nuance_stt_uri,
+    speechmatics_stt_uri,
     deepgram_stt_uri,
     deepgram_stt_use_tls,
+    deepgram_tts_uri,
     use_custom_tts,
     custom_tts_endpoint,
     custom_tts_endpoint_url,
@@ -138,6 +146,7 @@ const encryptCredential = (obj) => {
     model_id,
     user_id,
     voice_engine,
+    engine_version,
     options
   } = obj;
 
@@ -154,10 +163,17 @@ const encryptCredential = (obj) => {
       return encrypt(service_key);
 
     case 'aws':
-      assert(access_key_id, 'invalid aws speech credential: access_key_id is required');
-      assert(secret_access_key, 'invalid aws speech credential: secret_access_key is required');
-      assert(aws_region, 'invalid aws speech credential: aws_region is required');
-      const awsData = JSON.stringify({aws_region, access_key_id, secret_access_key});
+      // AWS polly can work for 3 types of credentials:
+      // 1/ access_key_id and secret_access_key
+      // 2/ RoleArn Assume role
+      // 3/ RoleArn assigned to instance profile where will run this application
+      const awsData = JSON.stringify(
+        {
+          aws_region,
+          ...(access_key_id && {access_key_id}),
+          ...(secret_access_key && {secret_access_key}),
+          ...(role_arn && {role_arn}),
+        });
       return encrypt(awsData);
 
     case 'microsoft':
@@ -191,10 +207,10 @@ const encryptCredential = (obj) => {
 
     case 'deepgram':
       // API key is optional if onprem
-      if (!deepgram_stt_uri) {
+      if (!deepgram_stt_uri || !deepgram_tts_uri) {
         assert(api_key, 'invalid deepgram speech credential: api_key is required');
       }
-      const deepgramData = JSON.stringify({api_key, deepgram_stt_uri, deepgram_stt_use_tls});
+      const deepgramData = JSON.stringify({api_key, deepgram_stt_uri, deepgram_stt_use_tls, deepgram_tts_uri});
       return encrypt(deepgramData);
 
     case 'ibm':
@@ -222,6 +238,12 @@ const encryptCredential = (obj) => {
       const elevenlabsData = JSON.stringify({api_key, model_id, options});
       return encrypt(elevenlabsData);
 
+    case 'speechmatics':
+      assert(api_key, 'invalid speechmatics speech credential: api_key is required');
+      assert(speechmatics_stt_uri, 'invalid speechmatics speech credential: speechmatics_stt_uri is required');
+      const speechmaticsData = JSON.stringify({api_key, speechmatics_stt_uri, options});
+      return encrypt(speechmaticsData);
+
     case 'playht':
       assert(api_key, 'invalid playht speech credential: api_key is required');
       assert(user_id, 'invalid playht speech credential: user_id is required');
@@ -229,6 +251,12 @@ const encryptCredential = (obj) => {
       const playhtData = JSON.stringify({api_key, user_id, voice_engine, options});
       return encrypt(playhtData);
 
+    case 'rimelabs':
+      assert(api_key, 'invalid rimelabs speech credential: api_key is required');
+      assert(model_id, 'invalid rimelabs speech credential: model_id is required');
+      const rimelabsData = JSON.stringify({api_key, model_id, options});
+      return encrypt(rimelabsData);
+
     case 'assemblyai':
       assert(api_key, 'invalid assemblyai speech credential: api_key is required');
       const assemblyaiData = JSON.stringify({api_key});
@@ -240,6 +268,13 @@ const encryptCredential = (obj) => {
       const whisperData = JSON.stringify({api_key, model_id});
       return encrypt(whisperData);
 
+    case 'verbio':
+      assert(engine_version, 'invalid verbio speech credential: client_id is required');
+      assert(client_id, 'invalid verbio speech credential: client_id is required');
+      assert(client_secret, 'invalid verbio speech credential: secret is required');
+      const verbioData = JSON.stringify({client_id, client_secret, engine_version});
+      return encrypt(verbioData);
+
     default:
       if (vendor.startsWith('custom:')) {
         const customData = JSON.stringify({auth_token, custom_stt_url, custom_tts_url});
@@ -432,6 +467,8 @@ router.put('/:sid', async(req, res) => {
           options,
           deepgram_stt_uri,
           deepgram_stt_use_tls,
+          deepgram_tts_uri,
+          engine_version
         } = req.body;
 
         const newCred = {
@@ -458,6 +495,8 @@ router.put('/:sid', async(req, res) => {
           options,
           deepgram_stt_uri,
           deepgram_stt_use_tls,
+          deepgram_tts_uri,
+          engine_version
         };
         logger.info({o, newCred}, 'updating speech credential with this new credential');
         obj.credential = encryptCredential(newCred);
@@ -486,7 +525,7 @@ router.put('/:sid', async(req, res) => {
  * Test a credential
  */
 router.get('/:sid/test', async(req, res) => {
-  const {logger, synthAudio} = req.app.locals;
+  const {logger, synthAudio, getVerbioAccessToken} = req.app.locals;
   try {
     const sid = parseSpeechCredentialSid(req);
     const creds = await SpeechCredential.retrieve(sid);
@@ -534,12 +573,13 @@ router.get('/:sid/test', async(req, res) => {
       }
     }
     else if (cred.vendor === 'aws') {
+      const {getTtsVoices, getAwsAuthToken} = req.app.locals;
       if (cred.use_for_tts) {
-        const {getTtsVoices} = req.app.locals;
         try {
           await testAwsTts(logger, getTtsVoices, {
             accessKeyId: credential.access_key_id,
             secretAccessKey: credential.secret_access_key,
+            roleArn: credential.role_arn,
             region: credential.aws_region || process.env.AWS_REGION
           });
           results.tts.status = 'ok';
@@ -551,9 +591,10 @@ router.get('/:sid/test', async(req, res) => {
       }
       if (cred.use_for_stt) {
         try {
-          await testAwsStt(logger, {
+          await testAwsStt(logger, getAwsAuthToken, {
             accessKeyId: credential.access_key_id,
             secretAccessKey: credential.secret_access_key,
+            roleArn: credential.role_arn,
             region: credential.aws_region || process.env.AWS_REGION
           });
           results.stt.status = 'ok';
@@ -596,7 +637,7 @@ router.get('/:sid/test', async(req, res) => {
       }
       if (cred.use_for_stt) {
         try {
-          await testMicrosoftStt(logger, {api_key, region});
+          await testMicrosoftStt(logger, {api_key, region, use_custom_stt, custom_stt_endpoint_url});
           results.stt.status = 'ok';
           SpeechCredential.sttTestResult(sid, true);
         } catch (err) {
@@ -655,8 +696,7 @@ router.get('/:sid/test', async(req, res) => {
           SpeechCredential.sttTestResult(sid, false);
         }
       }
-    }
-    else if (cred.vendor === 'deepgram') {
+    } else if (cred.vendor === 'deepgram') {
       const {api_key} = credential;
       if (cred.use_for_tts) {
         try {
@@ -736,12 +776,40 @@ router.get('/:sid/test', async(req, res) => {
           SpeechCredential.ttsTestResult(sid, false);
         }
       }
+    } else if (cred.vendor === 'speechmatics') {
+      const {api_key} = credential;
+      if (cred.use_for_stt) {
+        try {
+          await testSpeechmaticsStt(logger, {api_key});
+          results.stt.status = 'ok';
+          SpeechCredential.ttsTestResult(sid, true);
+        } catch (err) {
+          results.stt = {status: 'fail', reason: err.message};
+          SpeechCredential.ttsTestResult(sid, false);
+        }
+      }
     } else if (cred.vendor === 'playht') {
       if (cred.use_for_tts) {
         try {
           await testPlayHT(logger, synthAudio, credential);
           results.tts.status = 'ok';
           SpeechCredential.ttsTestResult(sid, true);
+        } catch (err) {
+          let reason = err.message;
+          // if error is from bent, let get the body
+          try {
+            reason = await err.text();
+          } catch {}
+          results.tts = {status: 'fail', reason};
+          SpeechCredential.ttsTestResult(sid, false);
+        }
+      }
+    } else if (cred.vendor === 'rimelabs') {
+      if (cred.use_for_tts) {
+        try {
+          await testRimelabs(logger, synthAudio, credential);
+          results.tts.status = 'ok';
+          SpeechCredential.ttsTestResult(sid, true);
         } catch (err) {
           results.tts = {status: 'fail', reason: err.message};
           SpeechCredential.ttsTestResult(sid, false);
@@ -770,6 +838,27 @@ router.get('/:sid/test', async(req, res) => {
           SpeechCredential.ttsTestResult(sid, false);
         }
       }
+    } else if (cred.vendor === 'verbio') {
+      if (cred.use_for_tts) {
+        try {
+          await testVerbioTts(logger, synthAudio, credential);
+          results.tts.status = 'ok';
+          SpeechCredential.ttsTestResult(sid, true);
+        } catch (err) {
+          results.tts = {status: 'fail', reason: err.message};
+          SpeechCredential.ttsTestResult(sid, false);
+        }
+      }
+      if (cred.use_for_stt) {
+        try {
+          await testVerbioStt(logger, getVerbioAccessToken, credential);
+          results.stt.status = 'ok';
+          SpeechCredential.sttTestResult(sid, true);
+        } catch (err) {
+          results.stt = {status: 'fail', reason: err.message};
+          SpeechCredential.sttTestResult(sid, false);
+        }
+      }
     }
 
     res.status(200).json(results);
@@ -786,7 +875,7 @@ router.get('/:sid/test', async(req, res) => {
 router.get('/speech/supportedLanguagesAndVoices', async(req, res) => {
   const {logger, getTtsVoices} = req.app.locals;
   try {
-    const {vendor, label} = req.query;
+    const {vendor, label, create_new} = req.query;
     if (!vendor) {
       throw new DbErrorBadRequest('vendor is required');
     }
@@ -794,7 +883,7 @@ router.get('/speech/supportedLanguagesAndVoices', async(req, res) => {
     const service_provider_sid = req.user.service_provider_sid ||
       req.body.service_provider_sid || parseServiceProviderSid(req);
 
-    const credentials = await SpeechCredential.getSpeechCredentialsByVendorAndLabel(
+    const credentials = create_new ? null : await SpeechCredential.getSpeechCredentialsByVendorAndLabel(
       service_provider_sid, account_sid, vendor, label);
     const tmp = credentials && credentials.length > 0 ? credentials[0] : null;
     const cred = tmp ? JSON.parse(decrypt(tmp.credential)) : null;

lib/routes/api/tts-cache.js

@@ -10,6 +10,7 @@ const Account = require('../../models/account');
 const sysError = require('../error');
 const { getSpeechCredential, decryptCredential } = require('../../utils/speech-utils');
 const PCMToMP3Encoder = require('../../record/encoder');
+const { pipeline } = require('stream');
 
 router.delete('/', async(req, res) => {
   const {purgeTtsCache} = req.app.locals;
@@ -69,6 +70,8 @@ router.post('/Synthesize', async(req, res) => {
         voice = arr[1];
         model = arr[2];
       }
+    }  else if (cred.vendor === 'deepgram') {
+      model = voice;
     }
     const stats = {
       histogram: () => {},
@@ -84,7 +87,8 @@ router.post('/Synthesize', async(req, res) => {
       model,
       salt,
       credentials: cred,
-      disableTtsCache: false
+      disableTtsCache: false,
+      disableTtsStreaming: true
     });
 
     let contentType = 'audio/mpeg';
@@ -110,10 +114,17 @@ router.post('/Synthesize', async(req, res) => {
     res.writeHead(200, {
       'Content-Type': contentType,
     });
-    readStream.pipe(res);
-    readStream.on('end', () => {
-      fs.unlink(filePath, (err) => {
-        if (err) throw err;
+
+    pipeline(readStream, res, (err) => {
+      if (err) {
+        logger.error('ttscache/Synthesize failed:', err);
+        if (!res.headersSent) {
+          res.status(500).end('Server error');
+        }
+      }
+
+      fs.unlink(filePath, (unlinkErr) => {
+        if (unlinkErr) throw unlinkErr;
         logger.info(`${filePath} was deleted`);
       });
     });

lib/swagger/swagger.yaml

@@ -3882,6 +3882,34 @@ paths:
                 $ref: '#/components/schemas/GeneralError'
         
   
+  /Accounts/{AccountSid}/Conferences:
+    get:
+      tags:
+       - Conferences
+      summary: list conferences
+      operationId: listConferences
+      parameters:
+      - name: AccountSid
+        in: path
+        required: true
+        schema:
+          type: string
+      responses:
+        200:
+          description: list of conferences for a specified account
+          content:
+            application/json:
+              schema:
+                type: array
+                items:
+                  type: string
+        500:
+          description: system error
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/GeneralError'
+  
   /Accounts/{AccountSid}/Calls:
     post:
       tags:
@@ -4152,6 +4180,22 @@ paths:
                       type: string 
                     siprecServerURL:
                       type: string
+                conferenceParticipantAction:
+                  type: object
+                  properties:
+                    action:
+                      type: string
+                      enum:
+                        - tag
+                        - untag
+                        - coach
+                        - uncoach
+                        - mute
+                        - unmute
+                        - hold
+                        - unhold
+                    tag:
+                      type: string
       responses:
         200:
           description: Accepted

lib/utils/speech-data/stt-speechmatics.js

@@ -0,0 +1,218 @@
+module.exports = [
+  {
+    name: 'Automatic',
+    value: 'auto',
+  },
+  {
+    name: 'Arabic',
+    value: 'ar',
+  },
+  {
+    name: 'Bashkir',
+    value: 'ba',
+  },
+  {
+    name: 'Basque',
+    value: 'eu',
+  },
+  {
+    name: 'Belarusian',
+    value: 'be',
+  },
+  {
+    name: 'Bulgarian',
+    value: 'bg',
+  },
+  {
+    name: 'Cantonese',
+    value: 'yue',
+  },
+  {
+    name: 'Catalan',
+    value: 'ca',
+  },
+  {
+    name: 'Croatian',
+    value: 'hr',
+  },
+  {
+    name: 'Czech',
+    value: 'cs',
+  },
+  {
+    name: 'Danish',
+    value: 'da',
+  },
+  {
+    name: 'Dutch',
+    value: 'nl',
+  },
+  {
+    name: 'English',
+    value: 'en',
+  },
+  {
+    name: 'Esperanto',
+    value: 'eo',
+  },
+  {
+    name: 'Estonian',
+    value: 'et',
+  },
+  {
+    name: 'Finnish',
+    value: 'fi',
+  },
+  {
+    name: 'French',
+    value: 'fr',
+  },
+  {
+    name: 'Galician',
+    value: 'gl',
+  },
+  {
+    name: 'German',
+    value: 'de',
+  },
+  {
+    name: 'Greek',
+    value: 'el',
+  },
+  {
+    name: 'Hebrew',
+    value: 'he',
+  },
+  {
+    name: 'Hindi',
+    value: 'hi',
+  },
+  {
+    name: 'Hungarian',
+    value: 'hu',
+  },
+  {
+    name: 'Irish',
+    value: 'ga',
+  },
+  {
+    name: 'Interlingua',
+    value: 'ia',
+  },
+  {
+    name: 'Italian',
+    value: 'it',
+  },
+  {
+    name: 'Indonesian',
+    value: 'id',
+  },
+  {
+    name: 'Japanese',
+    value: 'ja',
+  },
+  {
+    name: 'Korean',
+    value: 'ko',
+  },
+  {
+    name: 'Latvian',
+    value: 'lv',
+  },
+  {
+    name: 'Lithuanian',
+    value: 'lt',
+  },
+  {
+    name: 'Maltese',
+    value: 'mt',
+  },
+  {
+    name: 'Malay',
+    value: 'ms',
+  },
+  {
+    name: 'Mandarin',
+    value: 'cmn',
+  },
+  {
+    name: 'Marathi',
+    value: 'mr',
+  },
+  {
+    name: 'Mongolian',
+    value: 'mn',
+  },
+  {
+    name: 'Norwegian',
+    value: 'no',
+  },
+  {
+    name: 'Persian',
+    value: 'fa',
+  },
+  {
+    name: 'Polish',
+    value: 'pl',
+  },
+  {
+    name: 'Portuguese',
+    value: 'pt',
+  },
+  {
+    name: 'Romanian',
+    value: 'ro',
+  },
+  {
+    name: 'Russian',
+    value: 'ru',
+  },
+  {
+    name: 'Slovakian',
+    value: 'sk',
+  },
+  {
+    name: 'Slovenian',
+    value: 'sl',
+  },
+  {
+    name: 'Spanish',
+    value: 'es',
+  },
+  {
+    name: 'Spanish & English bilingual',
+    value: 'es',
+  },
+  {
+    name: 'Swedish',
+    value: 'sv',
+  },
+  {
+    name: 'Tamil',
+    value: 'ta',
+  },
+  {
+    name: 'Thai',
+    value: 'th',
+  },
+  {
+    name: 'Turkish',
+    value: 'tr',
+  },
+  {
+    name: 'Uyghur',
+    value: 'ug',
+  },
+  {
+    name: 'Ukrainian',
+    value: 'uk',
+  },
+  {
+    name: 'Vietnamese',
+    value: 'vi',
+  },
+  {
+    name: 'Welsh',
+    value: 'cy',
+  },
+];

lib/utils/speech-data/stt-verbio.js

@@ -0,0 +1,14 @@
+module.exports = [
+  { name: 'US English', value: 'en-US' },
+  { name: 'British English', value: 'en-GB' },
+  { name: 'LATAM Spanish', value: 'en-USes-419' },
+  { name: 'Spanish', value: 'es' },
+  { name: 'Catalan', value: 'ca-ES', version: 'v2' },
+  { name: 'Brazilian Portuguese', value: 'pt-BR' },
+  { name: 'French', value: 'fr', version: 'v1' },
+  { name: 'Canadian French', value: 'fr-CA', version: 'v1' },
+  { name: 'German', value: 'de', version: 'v1' },
+  { name: 'Italian', value: 'it', version: 'v1' },
+  { name: 'Turkish', value: 'tr', version: 'v1' },
+  { name: 'Japanese', value: 'ja', version: 'v1' },
+];

lib/utils/speech-data/tts-languages-playht.js

@@ -0,0 +1,152 @@
+// languages.js
+
+module.exports = [
+  {
+    name: 'English',
+    value: 'english'
+  },
+  {
+    name: 'Mandarin',
+    value: 'mandarin'
+  },
+  {
+    name: 'Hindi',
+    value: 'hindi'
+  },
+  {
+    name: 'Japanese',
+    value: 'japanese'
+  },
+  {
+    name: 'Korean',
+    value: 'korean'
+  },
+  {
+    name: 'Arabic',
+    value: 'arabic'
+  },
+  {
+    name: 'Spanish',
+    value: 'spanish'
+  },
+  {
+    name: 'French',
+    value: 'french'
+  },
+  {
+    name: 'Italian',
+    value: 'italian'
+  },
+  {
+    name: 'Portuguese',
+    value: 'portuguese'
+  },
+  {
+    name: 'German',
+    value: 'german'
+  },
+  {
+    name: 'Dutch',
+    value: 'dutch'
+  },
+  {
+    name: 'Swedish',
+    value: 'swedish'
+  },
+  {
+    name: 'Czech',
+    value: 'czech'
+  },
+  {
+    name: 'Polish',
+    value: 'polish'
+  },
+  {
+    name: 'Russian',
+    value: 'russian'
+  },
+  {
+    name: 'Bulgarian',
+    value: 'bulgarian'
+  },
+  {
+    name: 'Hebrew',
+    value: 'hebrew'
+  },
+  {
+    name: 'Greek',
+    value: 'greek'
+  },
+  {
+    name: 'Turkish',
+    value: 'turkish'
+  },
+  {
+    name: 'Afrikaans',
+    value: 'afrikaans'
+  },
+  {
+    name: 'Xhosa',
+    value: 'xhosa'
+  },
+  {
+    name: 'Tagalog',
+    value: 'tagalog'
+  },
+  {
+    name: 'Malay',
+    value: 'malay'
+  },
+  {
+    name: 'Indonesian',
+    value: 'indonesian'
+  },
+  {
+    name: 'Bengali',
+    value: 'bengali'
+  },
+  {
+    name: 'Serbian',
+    value: 'serbian'
+  },
+  {
+    name: 'Thai',
+    value: 'thai'
+  },
+  {
+    name: 'Urdu',
+    value: 'urdu'
+  },
+  {
+    name: 'Croatian',
+    value: 'croatian'
+  },
+  {
+    name: 'Hungarian',
+    value: 'hungarian'
+  },
+  {
+    name: 'Danish',
+    value: 'danish'
+  },
+  {
+    name: 'Amharic',
+    value: 'amharic'
+  },
+  {
+    name: 'Albanian',
+    value: 'albanian'
+  },
+  {
+    name: 'Catalan',
+    value: 'catalan'
+  },
+  {
+    name: 'Ukrainian',
+    value: 'ukrainian'
+  },
+  {
+    name: 'Galician',
+    value: 'galician'
+  }
+];

lib/utils/speech-data/tts-model-elevenlabs.js

@@ -1,5 +1,6 @@
 module.exports = [
   { name: 'Turbo v2', value: 'eleven_turbo_v2' },
+  { name: 'Turbo v2.5', value: 'eleven_turbo_v2_5' },
   { name: 'Multilingual v2', value: 'eleven_multilingual_v2' },
   { name: 'Multilingual v1', value: 'eleven_multilingual_v1' },
   { name: 'English v1', value: 'eleven_monolingual_v1' },

lib/utils/speech-data/tts-model-playht.js

@@ -1,4 +1,5 @@
 module.exports = [
+  { name: 'Play3.0', value: 'Play3.0' },
   { name: 'PlayHT2.0-turbo', value: 'PlayHT2.0-turbo' },
   { name: 'PlayHT2.0', value: 'PlayHT2.0' },
   { name: 'PlayHT1.0', value: 'PlayHT1.0' },

lib/utils/speech-data/tts-model-rimelabs.js

@@ -0,0 +1,5 @@
+module.exports = [
+  { name: 'Mist', value: 'mist' },
+  { name: 'V1', value: 'v1' },
+];
+

lib/utils/speech-data/tts-playht.js

@@ -0,0 +1,710 @@
+module.exports = [
+  {
+    value: 'en-US',
+    name: 'English (US)',
+    voices: [
+      {
+        value:
+          's3://mockingbird-prod/abigail_vo_6661b91f-4012-44e3-ad12-589fbdee9948/voices/speaker/manifest.json',
+        name: 'Abigail - american, female, narrative, smooth',
+      },
+      {
+        value: 'abram',
+        name: 'Abram - british, old, male, low, narrative, slow, round',
+      },
+      {
+        value: 'adolfo',
+        name: 'Adolfo - american, adult, male, neutral, narrative, fast, thick',
+      },
+      {
+        value: 'adrian',
+        name: 'Adrian - american, old, male, neutral, narrative, fast, thick',
+      },
+      {
+        value: 'ahmed',
+        name: 'Logan - british, old, male, neutral, narrative, neutral, thick',
+      },
+      {
+        value: 'alex',
+        name: 'Alex - british, adult, male, high, narrative, slow, thick',
+      },
+      {
+        value: 'alexander',
+        name: 'Alexander - british, old, male, high, narrative, fast, thick',
+      },
+      {
+        value: 'alfonso',
+        name: 'Alfonso - american, adult, male, neutral, videos, neutral, gravelly',
+      },
+      {
+        value: 'alphonso',
+        name: 'Alphonso - american, adult, female, low, videos, neutral, smooth',
+      },
+      {
+        value: 'amado',
+        name: 'Amado - american, old, male, low, narrative, fast, smooth',
+      },
+      {
+        value: 'anny',
+        name: 'Anny - american, youth, female, neutral, narrative, neutral, thick',
+      },
+      {
+        value: 'anthony',
+        name: 'Anthony - american, adult, male, neutral, training, slow, thick',
+      },
+      {
+        value: 'spencer',
+        name: 'April - british, adult, female, neutral, narrative, slow, smooth',
+      },
+      {
+        value: 'victor',
+        name: 'Ariana - american, youth, female, high, videos, fast, thick',
+      },
+      {
+        value: 'arthur',
+        name: 'Arthur - british, adult, male, neutral, narrative, neutral, smooth',
+      },
+      {
+        value: 'aubrey',
+        name: 'Aubrey - british, adult, male, neutral, videos, neutral, smooth',
+      },
+      {
+        value: 'hipolito',
+        name: 'Audrey - american, adult, female, low, narrative, slow, round',
+      },
+      {
+        value: 'aurora',
+        name: 'Aurora - british, adult, female, low, training, slow, round',
+      },
+      {
+        value: 'axel',
+        name: 'Axel - american, adult, male, neutral, narrative, fast, thick',
+      },
+      {
+        value:
+          's3://mockingbird-prod/ayla_vo_commercials_d66900d5-69f5-476f-9bd6-8eab2936dda3/voices/speaker/manifest.json',
+        name: 'Ayla (Advertising) - american, female, advertising',
+      },
+      {
+        value:
+          's3://mockingbird-prod/ayla_vo_expressive_16095e08-b9e8-429b-947c-47a75e41053b/voices/speaker/manifest.json',
+        name: 'Ayla (Expressive) - american, female, narrative',
+      },
+      {
+        value:
+          's3://mockingbird-prod/ayla_vo_meditation_d11dd9da-b5f1-4709-95a6-e6d5dc77614a/voices/speaker/manifest.json',
+        name: 'Ayla (Meditation) - american, female, meditation',
+      },
+      {
+        value:
+          's3://mockingbird-prod/ayla_vo_narrative_d8199dfd-b50f-40c7-9d99-e203ba5f4152/voices/speaker/manifest.json',
+        name: 'Ayla (Narrative) - american, female, narrative',
+      },
+      {
+        value:
+          's3://mockingbird-prod/ayla_vo_training_e6751ca5-e47c-4c4b-ad05-d3a194417600/voices/speaker/manifest.json',
+        name: 'Ayla (Training) - american, female, training',
+      },
+      {
+        value: 'benton',
+        name: 'Benton - american, old, male, high, videos, fast, smooth',
+      },
+      {
+        value: 'bertram',
+        name: 'Bertram - british, adult, male, low, narrative, neutral, gravelly',
+      },
+      {
+        value: 'bill',
+        name: 'Harper - american, adult, female, high, videos, fast, smooth',
+      },
+      {
+        // eslint-disable-next-line max-len
+        value:'s3://mockingbird-prod/nathan_drake_carmelo_pampillonio_7d540ad6-7d32-41f6-8d53-2584901aa03d/voices/speaker/manifest.json',
+        name: 'Billy - american, male, gaming',
+      },
+      {
+        value: 'blaine',
+        name: 'Blaine - british, adult, male, high, narrative, neutral, thick',
+      },
+      {
+        value: 'booker',
+        name: 'Booker - british, youth, male, neutral, narrative, neutral, round',
+      },
+      {
+        value: 'bret',
+        name: 'Bret - american, adult, female, neutral, narrative, slow, smooth',
+      },
+      {
+        value: 'bruce',
+        name: 'Bruce - british, adult, male, high, training, fast, thick',
+      },
+      {
+        value: 'bryan',
+        name: 'Bryan - american, adult, male, low, videos, fast, gravelly',
+      },
+      {
+        value: 'carlo',
+        name: 'Carlo - british, adult, male, neutral, advertising, neutral, smooth',
+      },
+      {
+        value: 'carter',
+        name: 'Carter - american, adult, male, neutral, narrative, neutral, thick',
+      },
+      {
+        value: 'charles',
+        name: 'Charles - american, adult, male, neutral, narrative, neutral, round',
+      },
+      {
+        value: 'charlotte',
+        name: 'Charlotte - canadian, adult, female, low, narrative, neutral, smooth',
+      },
+      {
+        value:
+          's3://voice-cloning-zero-shot/028a32d4-6a79-4ca3-a303-d6559843114b/chris/manifest.json',
+        name: 'Chris - american, adult, male,',
+      },
+      {
+        value: 'chuck',
+        name: 'Chuck - british, adult, male, neutral, videos, slow, round',
+      },
+      {
+        value: 'clark',
+        name: 'Clark - british, old, male, neutral, narrative, slow, smooth',
+      },
+      {
+        value: 'clifton',
+        name: 'Clifton - american, old, male, high, narrative, neutral, gravelly',
+      },
+      {
+        value: 'hayden',
+        name: 'Cooper - american, adult, male, neutral, narrative, neutral, round',
+      },
+      {
+        value: 'daisy',
+        name: 'Daisy - british, adult, female, low, narrative, neutral, gravelly',
+      },
+      {
+        value: 'dane',
+        name: 'Dane - american, adult, male, neutral, videos, neutral, round',
+      },
+      {
+        value: 'daniel',
+        name: 'Daniel - canadian, adult, male, low, narrative, neutral, smooth',
+      },
+      {
+        value: 'darnell',
+        name: 'Darnell - american, youth, male, neutral, narrative, neutral, smooth',
+      },
+      {
+        value: 'daron',
+        name: 'Daron - american, old, male, low, narrative, slow, round',
+      },
+      {
+        value: 'darrell',
+        name: 'Darrell - british, adult, male, neutral, advertising, neutral, thick',
+      },
+      {
+        value: 's3://peregrine-voices/a10/manifest.json',
+        name: 'Davis - american, adult, male,',
+      },
+      {
+        value: 'ignacio',
+        name: 'Delilah - american, adult, female, neutral, narrative, slow, smooth',
+      },
+      {
+        value: 'denis',
+        name: 'Eleanor - british, adult, female, neutral, advertising, neutral, smooth',
+      },
+      {
+        value: 'dick',
+        name: 'Dick - american, adult, male, neutral, training, fast, smooth',
+      },
+      {
+        value: 'domenic',
+        name: 'Domenic - british, adult, male, high, videos, neutral, thick',
+      },
+      {
+        value: 's3://peregrine-voices/donna_meditation_saad/manifest.json',
+        name: 'Donna (Meditation) - american, female, meditation',
+      },
+      {
+        value: 's3://peregrine-voices/donna_parrot_saad/manifest.json',
+        name: 'Donna (Narrative) - american, female, narrative',
+      },
+      {
+        value: 'donovan',
+        name: 'Donovan - american, adult, male, low, narrative, neutral, smooth',
+      },
+      {
+        value: 'dudley',
+        name: 'Dudley - american, old, male, low, narrative, fast, smooth',
+      },
+      {
+        value: 'dylan',
+        name: 'Dylan - british, old, male, high, gaming, slow, smooth',
+      },
+      {
+        value: 'earle',
+        name: 'Earle - british, adult, male, high, narrative, neutral, gravelly',
+      },
+      {
+        value: 'efren',
+        name: 'Efren - american, adult, male, neutral, training, slow, thick',
+      },
+      {
+        value: 'denis',
+        name: 'Eleanor - british, adult, female, neutral, advertising, neutral, smooth',
+      },
+      {
+        value: 'elijah',
+        name: 'Elijah - american, old, male, neutral, training, neutral, gravelly',
+      },
+      {
+        value: 'ellie',
+        name: 'Ellie - american, adult, female, low, training, slow, smooth',
+      },
+      {
+        value: 'erasmo',
+        name: 'Erasmo - american, old, male, low, training, fast, smooth',
+      },
+      {
+        value: 's3://peregrine-voices/evelyn 2 saad parrot/manifest.json',
+        name: 'Evelyn - american, adult, female, low, videos, neutral, smooth',
+      },
+      {
+        value: 'fletcher',
+        name: 'Fletcher - british, adult, male, neutral, narrative, fast, gravelly',
+      },
+      {
+        value: 'florencio',
+        name: 'Madison - british, old, female, neutral, narrative, slow, round',
+      },
+      {
+        value: 'flynn',
+        name: 'Flynn - british, adult, male, neutral, narrative, fast, round',
+      },
+      {
+        value: 'gabriel',
+        name: 'Samantha - american, old, female, neutral, narrative, neutral, thick',
+      },
+      {
+        value: 'greg',
+        name: 'Greg - british, adult, male, high, narrative, slow, round',
+      },
+      {
+        value: 'harold',
+        name: 'Harold - american, adult, male, neutral, narrative, slow, smooth',
+      },
+      {
+        value: 'bill',
+        name: 'Harper - american, adult, female, high, videos, fast, smooth',
+      },
+      {
+        value: 'harris',
+        name: 'Harris - british, adult, male, low, narrative, fast, smooth',
+      },
+      {
+        value: 'harrison',
+        name: 'Harrison - american, adult, male, neutral, narrative, fast, round',
+      },
+      {
+        value: 'hayden',
+        name: 'Cooper - american, adult, male, neutral, narrative, neutral, round',
+      },
+      {
+        value: 'hipolito',
+        name: 'Audrey - american, adult, female, low, narrative, slow, round',
+      },
+      {
+        value:
+          's3://mockingbird-prod/hook_1_chico_a3e5e83f-08ae-4a9f-825c-7e48d32d2fd8/voices/speaker/manifest.json',
+        name: 'Hook - american, male, gaming',
+      },
+      {
+        value: 's3://peregrine-voices/hudson saad parrot/manifest.json',
+        name: 'Hudson - american, adult, male, neutral, videos, neutral, thick',
+      },
+      {
+        value: 'hunter',
+        name: 'Hunter - british, old, male, high, narrative, fast, round',
+      },
+      {
+        value: 'ignacio',
+        name: 'Delilah - american, adult, female, neutral, narrative, slow, smooth',
+      },
+      {
+        value: 's3://peregrine-voices/mel28/manifest.json',
+        name: 'Jack - american, adult, male,',
+      },
+      {
+        value: 'jarrett',
+        name: 'Jarrett - american, adult, male, low, advertising, slow, smooth',
+      },
+      {
+        value:
+          's3://voice-cloning-zero-shot/801a663f-efd0-4254-98d0-5c175514c3e8/jennifer/manifest.json',
+        name: 'Jennifer - american, adult, female,',
+      },
+      {
+        value: 'jerrell',
+        name: 'Jerrell - american, adult, male, low, narrative, neutral, round',
+      },
+      {
+        value: 'jordan',
+        name: 'Jordan - american, adult, male, neutral, training, slow, round',
+      },
+      {
+        value:
+          's3://voice-cloning-zero-shot/dc23bb38-f568-4323-b6fb-7d64f685b97a/joseph/manifest.json',
+        name: 'Joseph - american, adult, male,',
+      },
+      {
+        value: 'judson',
+        name: 'Judson - american, adult, male, low, narrative, slow, smooth',
+      },
+      {
+        value: 'lance',
+        name: 'Lance - british, adult, male, low, videos, neutral, smooth',
+      },
+      {
+        value: 'larry',
+        name: 'Larry - american, adult, male, neutral, narrative, neutral, smooth',
+      },
+      {
+        value: 's3://peregrine-voices/larry_ads3_parrot_saad/manifest.json',
+        name: 'Larry (Advertising) - american, adult, male, neutral, advertising, neutral, smooth',
+      },
+      {
+        value:
+          's3://mockingbird-prod/larry_vo_narrative_4bd5c1bd-f662-4a38-b5b9-76563f7b92ec/voices/speaker/manifest.json',
+        name: 'Larry (Narrative) - american, adult, male, neutral, narrative, neutral, smooth',
+      },
+      {
+        value: 'lillian',
+        name: 'Lillian - british, old, female, neutral, training, slow, round',
+      },
+      {
+        value: 'ahmed',
+        name: 'Logan - british, old, male, neutral, narrative, neutral, thick',
+      },
+      {
+        value: 'lottie',
+        name: 'Lottie - british, adult, female, low, narrative, slow, smooth',
+      },
+      {
+        value: 'lucius',
+        name: 'Lucius - british, adult, male, low, narrative, slow, smooth',
+      },
+      {
+        value: 'mickey',
+        name: 'Madelyn - british, adult, female, neutral, videos, fast, thick',
+      },
+      {
+        value:
+          's3://voice-cloning-zero-shot/09b5c0cc-a8f4-4450-aaab-3657b9965d0b/podcaster/manifest.json',
+        name: 'Matt - american, adult, male,',
+      },
+      {
+        value: 's3://peregrine-voices/mel21/manifest.json',
+        name: 'Melissa - american, adult, female,',
+      },
+      {
+        value: 'micah',
+        name: 'Micah - british, adult, female, neutral, narrative, neutral, smooth',
+      },
+      {
+        value:
+          's3://voice-cloning-zero-shot/7c339a9d-370f-4643-adf5-4134e3ec9886/mlae02/manifest.json',
+        name: 'Michael - american, adult, male,',
+      },
+      {
+        value: 'mickey',
+        name: 'Madelyn - british, adult, female, neutral, videos, fast, thick',
+      },
+      {
+        value:
+          's3://voice-cloning-zero-shot/7c38b588-14e8-42b9-bacd-e03d1d673c3c/nicole/manifest.json',
+        name: 'Nicole - american, adult, female,',
+      },
+      {
+        value: 's3://peregrine-voices/nolan saad parrot/manifest.json',
+        name: 'Nolan - british, adult, male, high, videos, neutral, round',
+      },
+      {
+        value: 'nova',
+        name: 'Nova - american, adult, female, whisper, narrative, slow, smooth',
+      },
+      {
+        value: 'oliver',
+        name: 'Oliver - british, adult, male, high, videos, neutral, round',
+      },
+      {
+        value: 'oscar',
+        name: 'Oscar - british, adult, male, neutral, narrative, slow, smooth',
+      },
+      {
+        value: 'owen',
+        name: 'Owen - american, youth, male, high, narrative, neutral, round',
+      },
+      {
+        value: 'pedro',
+        name: 'Pedro - american, adult, male, neutral, narrative, slow, round',
+      },
+      {
+        value: 'phoebe',
+        name: 'Phoebe - british, adult, female, high, videos, fast, smooth',
+      },
+      {
+        value: 'randall',
+        name: 'Randall - british, adult, male, high, narrative, fast, thick',
+      },
+      {
+        value: 'reynaldo',
+        name: 'Reynaldo - british, old, male, low, narrative, fast, smooth',
+      },
+      {
+        value: 'rodrick',
+        name: 'Rodrick - american, adult, male, neutral, narrative, neutral, smooth',
+      },
+      {
+        value: 'gabriel',
+        name: 'Samantha - american, old, female, neutral, narrative, neutral, thick',
+      },
+      {
+        value: 'samuel',
+        name: 'Samuel - american, old, male, high, narrative, slow, gravelly',
+      },
+      {
+        value:
+          // eslint-disable-next-line max-len
+          's3://mockingbird-prod/agent_47_carmelo_pampillonio_58e796e1-0b87-4f3e-8b36-7def6d65ce66/voices/speaker/manifest.json',
+        name: 'Sarge - american, male, gaming',
+      },
+      {
+        value:
+          's3://voice-cloning-zero-shot/1f44b3e7-22ea-4c2e-87d0-b4d9c8f1d47d/sophia/manifest.json',
+        name: 'Sophia - american, adult, female,',
+      },
+      {
+        value: 'spencer',
+        name: 'April - british, adult, female, neutral, narrative, slow, smooth',
+      },
+      {
+        value: 'stella',
+        name: 'Stella - british, old, female, neutral, training, slow, round',
+      },
+      {
+        value: 'susan',
+        name: 'Susan - american, adult, female, high, videos, neutral, round',
+      },
+      {
+        value:
+          // eslint-disable-next-line max-len
+          's3://mockingbird-prod/susan_vo_commercials_0f4fa663-6eba-4582-be1e-2d5bde798f1c/voices/speaker/manifest.json',
+        name: 'Susan (Advertising) - american, adult, female, high, advertising, neutral, round',
+      },
+      {
+        value:
+          's3://mockingbird-prod/susan_vo_narrative_73051c90-460b-4e54-adab-9235f45c5e5f/voices/speaker/manifest.json',
+        name: 'Susan (Narrative) - american, adult, female, high, narrative, neutral, round',
+      },
+      {
+        value:
+          's3://mockingbird-prod/susan_vo_training_46ffcc60-d630-42f6-acfe-4affd003ae7a/voices/speaker/manifest.json',
+        name: 'Susan (Training) - american, adult, female, high, training, neutral, round',
+      },
+      {
+        value: 'theodore',
+        name: 'Theodore - american, old, male, neutral, narrative, neutral, gravelly',
+      },
+      {
+        value: 'victor',
+        name: 'Ariana - american, youth, female, high, videos, fast, thick',
+      },
+      {
+        value: 'wilbert',
+        name: 'Wilbert - british, adult, male, neutral, narrative, neutral, round',
+      },
+      {
+        value: 'wilbur',
+        name: 'Wilbur - american, youth, male, neutral, narrative, neutral, smooth',
+      },
+      {
+        value: 'wilfred',
+        name: 'Wilfred - american, old, male, low, training, slow, smooth',
+      },
+      {
+        value: 's3://peregrine-voices/mel22/manifest.json',
+        name: 'Will - american, adult, male,',
+      },
+      {
+        value: 'william',
+        name: 'William - american, adult, male, neutral, videos, neutral, round',
+      },
+      {
+        value:
+          // eslint-disable-next-line max-len
+          's3://mockingbird-prod/william_vo_narrative_0eacdff5-6243-4e26-8b3b-66e03458c1d1/voices/speaker/manifest.json',
+        name: 'William (Narrative) - american, adult, male, neutral, narrative, neutral, round',
+      },
+      {
+        value:
+          's3://mockingbird-prod/william_vo_training_1b939b71-14fa-41f0-b1db-7d94f194ad0a/voices/speaker/manifest.json',
+        name: 'William (Training) - american, adult, male, neutral, training, neutral, round',
+      },
+    ],
+  },
+  {
+    value: 'en-GB',
+    name: 'English (GB)',
+    voices: [
+      {
+        value: 's3://peregrine-voices/arthur ads parrot saad/manifest.json',
+        name: 'Arthur (Advertising) - british, adult, male, neutral, advertising, neutral, smooth',
+      },
+      {
+        value:
+          // eslint-disable-next-line max-len
+          's3://mockingbird-prod/arthur_vo_meditatoin_211f702d-b185-4115-b8b4-801f8130a38d/voices/speaker/manifest.json',
+        name: 'Arthur (Meditation) - british, adult, male, neutral, meditation, neutral, smooth',
+      },
+      {
+        value:
+          's3://mockingbird-prod/arthur_vo_narrative_a33fd610-73a9-4401-9a78-6b8219c68a9e/voices/speaker/manifest.json',
+        name: 'Arthur (Narrative) - british, adult, male, neutral, narrative, neutral, smooth',
+      },
+      {
+        value:
+          's3://mockingbird-prod/arthur_vo_training_9281c8fd-c7f0-4445-a148-466292d3d329/voices/speaker/manifest.json',
+        name: 'Arthur (Training) - british, adult, male, neutral, training, neutral, smooth',
+      },
+      {
+        value:
+          's3://mockingbird-prod/eileen_vo_5d7b2bcc-d635-4301-97e8-d97c13768514/voices/speaker/manifest.json',
+        name: 'Eileen - british, female, narrative',
+      },
+      {
+        value: 'frankie',
+        name: 'Frankie - british, old, male, neutral, training, neutral, thick',
+      },
+      {
+        value:
+          's3://voice-cloning-zero-shot/418a94fa-2395-4487-81d8-22daf107781f/george/manifest.json',
+        name: 'George - british, adult, male,',
+      },
+      {
+        value: 'julian',
+        name: 'Julian - british, adult, male, neutral, videos, neutral, round',
+      },
+      {
+        value:
+          's3://voice-cloning-zero-shot/0b5b2e4b-5103-425e-8aa0-510dd35226e2/mark/manifest.json',
+        name: 'Mark - british, adult, male,',
+      },
+      {
+        value: 's3://peregrine-voices/oliver_ads2_parrot_saad/manifest.json',
+        name: 'Oliver (Advertising) - british, adult, male, high, advertising, neutral, round',
+      },
+      {
+        value:
+          's3://peregrine-voices/oliver_narrative2_parrot_saad/manifest.json',
+        name: 'Oliver (Narrative) - british, adult, male, high, narrative, neutral, round',
+      },
+      {
+        value:
+          's3://mockingbird-prod/oliver_vo_training_6e3f604a-5605-4542-948d-347b0d7546fc/voices/speaker/manifest.json',
+        name: 'Oliver (Training) - british, adult, male, high, training, neutral, round',
+      },
+      {
+        value:
+          's3://voice-cloning-zero-shot/820da3d2-3a3b-42e7-844d-e68db835a206/sarah/manifest.json',
+        name: 'Sarah - british, adult, female,',
+      },
+    ],
+  },
+  {
+    value: 'en-AU',
+    name: 'English (AU)',
+    voices: [
+      {
+        value: 's3://peregrine-voices/barry ads parrot saad/manifest.json',
+        name: 'Barry (Advertising) - australian, male, advertising',
+      },
+      {
+        value:
+          's3://peregrine-voices/barry narrative parrot saad/manifest.json',
+        name: 'Barry (Narrative) - australian, male, narrative',
+      },
+      {
+        value: 'frederick',
+        name: 'Frederick - australian, adult, male, low, narrative, slow, thick',
+      },
+      {
+        value: 's3://peregrine-voices/russell2_parrot_saad/manifest.json',
+        name: 'Russell - australian, male,',
+      },
+    ],
+  },
+  {
+    value: 'en-CA',
+    name: 'English (CA)',
+    voices: [
+      {
+        value: 's3://peregrine-voices/charlotte ads parrot saad/manifest.json',
+        name: 'Charlotte (Advertising) - canadian, adult, female, low, advertising, neutral, smooth',
+      },
+      {
+        value:
+          's3://peregrine-voices/charlotte meditation 2 parrot saad/manifest.json',
+        name: 'Charlotte (Meditation) - canadian, adult, female, low, meditation, neutral, smooth',
+      },
+      {
+        value:
+          // eslint-disable-next-line max-len
+          's3://mockingbird-prod/charlotte_vo_narrative_9290be17-ccea-4700-a7fd-a8fe5c49fb20/voices/speaker/manifest.json',
+        name: 'Charlotte (Narrative) - canadian, adult, female, low, narrative, neutral, smooth',
+      },
+      {
+        value:
+          's3://peregrine-voices/charlotte_training_parrot_saad/manifest.json',
+        name: 'Charlotte (Training) - canadian, adult, female, low, training, neutral, smooth',
+      },
+      {
+        value:
+          // eslint-disable-next-line max-len
+          's3://mockingbird-prod/olivia_vo_commercials_6e3c384f-15d6-4fe7-b9a4-0cb1d69daeba/voices/speaker/manifest.json',
+        name: 'Olivia (Advertising) - canadian, female, advertising',
+      },
+      {
+        value: 's3://peregrine-voices/olivia_ads3_parrot_saad/manifest.json',
+        name: 'Olivia (Narrative) - canadian, female, narrative',
+      },
+      {
+        value:
+          's3://mockingbird-prod/olivia_vo_training_4376204f-a411-4e5d-a5c0-ce6cc3908052/voices/speaker/manifest.json',
+        name: 'Olivia (Training) - canadian, female, training',
+      },
+    ],
+  },
+  {
+    value: 'en-IE',
+    name: 'English (IE)',
+    voices: [
+      {
+        value: 'florencio',
+        name: 'Madison - irish, old, female, neutral, narrative, slow, round',
+      },
+    ],
+  },
+  {
+    value: 'en-NZ',
+    name: 'English (NZ)',
+    voices: [
+      {
+        value:
+          's3://voice-cloning-zero-shot/d9ff78ba-d016-47f6-b0ef-dd630f59414e/female-cs/manifest.json',
+        name: 'Ruby - australian, adult, female,',
+      },
+    ],
+  },
+];

lib/utils/speech-data/tts-verbio.js

@@ -0,0 +1,62 @@
+module.exports = [
+  {
+    value: 'en-US',
+    name: 'US English',
+    voices: [
+      {
+        value: 'tommy_en_us',
+        name: 'Tommy-Male',
+      },
+    ],
+  },
+  {
+    value: 'es-ES',
+    name: 'Castilian Spanish',
+    voices: [
+      {
+        value: 'david_es_es',
+        name: 'David-Male',
+      },
+    ],
+  },
+  {
+    value: 'es-PE',
+    name: 'Peruvian Spanish',
+    voices: [
+      {
+        value: 'miguel_es_pe',
+        name: 'Miguel-Male',
+      },
+    ],
+  },
+  {
+    value: 'es-PE',
+    name: 'Peruvian Spanish',
+    voices: [
+      {
+        value: 'luz_es_pe',
+        name: 'Luz-Female',
+      },
+    ],
+  },
+  {
+    value: 'pt-BR',
+    name: 'Brazilian Portuguese',
+    voices: [
+      {
+        value: 'bel_pt_br',
+        name: 'Bel-Female',
+      },
+    ],
+  },
+  {
+    value: 'ca-ES',
+    name: 'Catalan',
+    voices: [
+      {
+        value: 'anna_ca',
+        name: 'Anna-Female',
+      },
+    ],
+  },
+];

lib/utils/speech-utils.js

@@ -7,6 +7,7 @@ const bent = require('bent');
 const fs = require('fs');
 const { AssemblyAI } = require('assemblyai');
 const {decrypt, obscureKey} = require('./encrypt-decrypt');
+const { RealtimeSession } = require('speechmatics');
 
 const TtsGoogleLanguagesVoices = require('./speech-data/tts-google');
 const TtsAwsLanguagesVoices = require('./speech-data/tts-aws');
@@ -17,11 +18,15 @@ const TtsIbmLanguagesVoices = require('./speech-data/tts-ibm');
 const TtsNvidiaLanguagesVoices = require('./speech-data/tts-nvidia');
 const TtsElevenlabsLanguagesVoices = require('./speech-data/tts-elevenlabs');
 const TtsWhisperLanguagesVoices = require('./speech-data/tts-whisper');
+const TtsPlayHtLanguagesVoices = require('./speech-data/tts-playht');
+const TtsVerbioLanguagesVoices = require('./speech-data/tts-verbio');
 
 const TtsModelDeepgram = require('./speech-data/tts-model-deepgram');
 const TtsModelElevenLabs = require('./speech-data/tts-model-elevenlabs');
 const TtsModelWhisper = require('./speech-data/tts-model-whisper');
 const TtsModelPlayHT = require('./speech-data/tts-model-playht');
+const ttsLanguagesPlayHt = require('./speech-data/tts-languages-playht');
+const TtsModelRimelabs = require('./speech-data/tts-model-rimelabs');
 
 const SttGoogleLanguagesVoices = require('./speech-data/stt-google');
 const SttAwsLanguagesVoices = require('./speech-data/stt-aws');
@@ -32,7 +37,10 @@ const SttIbmLanguagesVoices = require('./speech-data/stt-ibm');
 const SttNvidiaLanguagesVoices = require('./speech-data/stt-nvidia');
 const SttCobaltLanguagesVoices = require('./speech-data/stt-cobalt');
 const SttSonioxLanguagesVoices = require('./speech-data/stt-soniox');
+const SttSpeechmaticsLanguagesVoices = require('./speech-data/stt-speechmatics');
 const SttAssemblyaiLanguagesVoices = require('./speech-data/stt-assemblyai');
+const SttVerbioLanguagesVoices = require('./speech-data/stt-verbio');
+
 
 const testSonioxStt = async(logger, credentials) => {
   const api_key = credentials;
@@ -50,6 +58,61 @@ const testSonioxStt = async(logger, credentials) => {
   });
 };
 
+const testSpeechmaticsStt = async(logger, credentials) => {
+  const {api_key, speechmatics_stt_uri} = credentials;
+  return new Promise(async(resolve, reject) => {
+    try {
+      const session = new RealtimeSession({ apiKey: api_key, realtimeUrl: speechmatics_stt_uri });
+      let transcription = '';
+      session.addListener('Error', (error) => {
+        reject(error);
+      });
+
+      session.addListener('AddTranscript', (message) => {
+        transcription += message.metadata.transcript;
+      });
+
+      session.addListener('EndOfTranscript', () => {
+        resolve(transcription);
+      });
+
+      session
+        .start({
+          transcription_config: {
+            language: 'en',
+            operating_point: 'enhanced',
+            enable_partials: true,
+            max_delay: 2,
+          },
+          audio_format: { type: 'file' },
+        })
+        .then(() => {
+          //prepare file stream
+          const fileStream = fs.createReadStream(`${__dirname}/../../data/test_audio.wav`);
+
+          //send it
+          fileStream.on('data', (sample) => {
+            session.sendAudio(sample);
+          });
+
+          //end the session
+          fileStream.on('end', () => {
+            session.stop();
+          });
+
+          return;
+
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    } catch (error) {
+      logger.info({error}, 'failed to get speechmatics transcript');
+      reject(error);
+    }
+  });
+};
+
 const testNuanceTts = async(logger, getTtsVoices, credentials) => {
   const voices = await getTtsVoices({vendor: 'nuance', credentials});
   return voices;
@@ -88,8 +151,8 @@ const testGoogleStt = async(logger, credentials) => {
 };
 
 const testDeepgramStt = async(logger, credentials) => {
-  const {api_key} = credentials;
-  const deepgram = new Deepgram(api_key);
+  const {api_key, deepgram_stt_uri, deepgram_stt_use_tls} = credentials;
+  const deepgram = new Deepgram(api_key, deepgram_stt_uri, deepgram_stt_uri && deepgram_stt_use_tls);
 
   const mimetype = 'audio/wav';
   const source = {
@@ -115,9 +178,10 @@ const testDeepgramStt = async(logger, credentials) => {
 };
 
 const testMicrosoftStt = async(logger, credentials) => {
-  const {api_key, region} = credentials;
-
-  const speechConfig = sdk.SpeechConfig.fromSubscription(api_key, region);
+  const {api_key, region, use_custom_stt, custom_stt_endpoint_url} = credentials;
+  const speechConfig = use_custom_stt ? sdk.SpeechConfig.fromEndpoint(
+    new URL(custom_stt_endpoint_url), api_key) :
+    sdk.SpeechConfig.fromSubscription(api_key, region);
   const audioConfig = sdk.AudioConfig.fromWavFileInput(fs.readFileSync(`${__dirname}/../../data/test_audio.wav`));
   speechConfig.speechRecognitionLanguage = 'en-US';
 
@@ -163,21 +227,34 @@ const testAwsTts = async(logger, getTtsVoices, credentials) => {
   }
 };
 
-const testAwsStt = async(logger, credentials) => {
+const testAwsStt = async(logger, getAwsAuthToken, credentials) => {
   try {
-    const {region, accessKeyId, secretAccessKey} = credentials;
-    const client = new TranscribeClient({
-      region,
-      credentials: {
-        accessKeyId,
-        secretAccessKey
-      }
-    });
+    const {region, accessKeyId, secretAccessKey, roleArn} = credentials;
+    let client = null;
+    if (accessKeyId && secretAccessKey) {
+      client = new TranscribeClient({
+        region,
+        credentials: {
+          accessKeyId,
+          secretAccessKey
+        }
+      });
+    } else if (roleArn) {
+      client = new TranscribeClient({
+        region,
+        credentials: await getAwsAuthToken({
+          region,
+          roleArn
+        }),
+      });
+    } else {
+      client = new TranscribeClient({region});
+    }
     const command = new ListVocabulariesCommand({});
     const response =  await client.send(command);
     return response;
   } catch (err) {
-    logger.info({err}, 'testMicrosoftTts - failed to list voices for region ${region}');
+    logger.info({err}, 'testAwsStt - failed to list voices for region ${region}');
     throw err;
   }
 };
@@ -190,7 +267,8 @@ const testMicrosoftTts = async(logger, synthAudio, credentials) => {
         credentials,
         language: 'en-US',
         voice: 'en-US-JennyMultilingualNeural',
-        text: 'Hi there and welcome to jambones!'
+        text: 'Hi there and welcome to jambones!',
+        renderForCaching: true
       }
     );
   } catch (err) {
@@ -251,9 +329,34 @@ const testPlayHT = async(logger, synthAudio, credentials) => {
       {
         vendor: 'playht',
         credentials,
-        language: 'en-US',
+        language: 'english',
         voice: 's3://voice-cloning-zero-shot/d9ff78ba-d016-47f6-b0ef-dd630f59414e/female-cs/manifest.json',
-        text: 'Hi there and welcome to jambones!'
+        text: 'Hi there and welcome to jambones!',
+        renderForCaching: true
+      }
+    );
+    // Test if playHT can fetch voices
+    await fetchLayHTVoices(credentials);
+  } catch (err) {
+    logger.info({err}, 'synth Playht returned error');
+    throw err;
+  }
+};
+
+const testRimelabs = async(logger, synthAudio, credentials) => {
+  try {
+    await synthAudio(
+      {
+        increment: () => {},
+        histogram: () => {}
+      },
+      {
+        vendor: 'rimelabs',
+        credentials,
+        language: 'en-US',
+        voice: 'amber',
+        text: 'Hi there and welcome to jambones!',
+        renderForCaching: true
       }
     );
   } catch (err) {
@@ -270,7 +373,8 @@ const testWhisper = async(logger, synthAudio, credentials) => {
         credentials,
         language: 'en-US',
         voice: 'alloy',
-        text: 'Hi there and welcome to jambones!'
+        text: 'Hi there and welcome to jambones!',
+        renderForCaching: true
       }
     );
   } catch (err) {
@@ -286,7 +390,8 @@ const testDeepgramTTS = async(logger, synthAudio, credentials) => {
         vendor: 'deepgram',
         credentials,
         model: 'aura-asteria-en',
-        text: 'Hi there and welcome to jambones!'
+        text: 'Hi there and welcome to jambones!',
+        renderForCaching: true
       }
     );
   } catch (err) {
@@ -329,6 +434,44 @@ const testWellSaidStt = async(logger, credentials) => {
   return true;
 };
 
+const testVerbioTts = async(logger, synthAudio, credentials) => {
+  try {
+    await synthAudio(
+      {
+        increment: () => {},
+        histogram: () => {}
+      },
+      {
+        vendor: 'verbio',
+        credentials,
+        language: 'en-US',
+        voice: 'tommy_en-us',
+        text: 'Hi there and welcome to jambones!',
+        renderForCaching: true
+      }
+    );
+  } catch (err) {
+    logger.info({err}, 'synth Verbio returned error');
+    throw err;
+  }
+};
+const testVerbioStt = async(logger, getVerbioAccessToken, credentials) => {
+  const token = await getVerbioAccessToken(credentials);
+  try {
+    const post = bent('https://us.rest.speechcenter.verbio.com', 'POST', 'json', {
+      'Authorization': `Bearer ${token.access_token}`,
+      'User-Agent': 'jambonz',
+      'Content-Type': 'audio/wav'
+    });
+    const json = await post('/api/v1/recognize?language=en-US&version=V1',
+      fs.readFileSync(`${__dirname}/../../data/test_audio.wav`));
+    logger.debug({json}, 'successfully speech to text from verbio');
+  } catch (err) {
+    logger.info({err}, 'testWellSaidTts returned error');
+    throw err;
+  }
+};
+
 const testAssemblyStt = async(logger, credentials) => {
   const {api_key} = credentials;
 
@@ -375,6 +518,7 @@ const getSpeechCredential = (credential, logger) => {
       ...credential,
       accessKeyId: credential.access_key_id,
       secretAccessKey: credential.secret_access_key,
+      roleArn: credential.role_arn,
       region: credential.aws_region || 'us-east-1'
     };
   }
@@ -396,6 +540,7 @@ function decryptCredential(obj, credential, logger, isObscureKey = true) {
   else if ('aws' === obj.vendor) {
     const o = JSON.parse(decrypt(credential));
     obj.access_key_id = o.access_key_id;
+    obj.role_arn = o.role_arn;
     obj.secret_access_key = isObscureKey ? obscureKey(o.secret_access_key) : o.secret_access_key;
     obj.aws_region = o.aws_region;
     logger.info({obj, o}, 'retrieving aws speech credential');
@@ -428,6 +573,7 @@ function decryptCredential(obj, credential, logger, isObscureKey = true) {
     obj.api_key = isObscureKey ? obscureKey(o.api_key) : o.api_key;
     obj.deepgram_stt_uri = o.deepgram_stt_uri;
     obj.deepgram_stt_use_tls = o.deepgram_stt_use_tls;
+    obj.deepgram_tts_uri = o.deepgram_tts_uri;
   }
   else if ('ibm' === obj.vendor) {
     const o = JSON.parse(decrypt(credential));
@@ -445,6 +591,10 @@ function decryptCredential(obj, credential, logger, isObscureKey = true) {
   } else if ('soniox' === obj.vendor) {
     const o = JSON.parse(decrypt(credential));
     obj.api_key = isObscureKey ? obscureKey(o.api_key) : o.api_key;
+  } else if ('speechmatics' === obj.vendor) {
+    const o = JSON.parse(decrypt(credential));
+    obj.api_key = isObscureKey ? obscureKey(o.api_key) : o.api_key;
+    obj.speechmatics_stt_uri = o.speechmatics_stt_uri;
   } else if ('elevenlabs' === obj.vendor) {
     const o = JSON.parse(decrypt(credential));
     obj.api_key = isObscureKey ? obscureKey(o.api_key) : o.api_key;
@@ -456,6 +606,11 @@ function decryptCredential(obj, credential, logger, isObscureKey = true) {
     obj.user_id = o.user_id;
     obj.voice_engine = o.voice_engine;
     obj.options = o.options;
+  } else if ('rimelabs' === obj.vendor) {
+    const o = JSON.parse(decrypt(credential));
+    obj.api_key = isObscureKey ? obscureKey(o.api_key) : o.api_key;
+    obj.model_id = o.model_id;
+    obj.options = o.options;
   } else if (obj.vendor.startsWith('custom:')) {
     const o = JSON.parse(decrypt(credential));
     obj.auth_token = isObscureKey ? obscureKey(o.auth_token) : o.auth_token;
@@ -468,6 +623,11 @@ function decryptCredential(obj, credential, logger, isObscureKey = true) {
     const o = JSON.parse(decrypt(credential));
     obj.api_key = isObscureKey ? obscureKey(o.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 = isObscureKey ? obscureKey(o.client_secret) : o.client_secret;
+    obj.engine_version = o.engine_version;
   }
 }
 
@@ -518,10 +678,16 @@ async function getLanguagesAndVoicesForVendor(logger, vendor, credential, getTts
       return await getLanguagesVoicesForElevenlabs(credential, getTtsVoices, logger);
     case 'playht':
       return await getLanguagesVoicesForPlayHT(credential, getTtsVoices, logger);
+    case 'rimelabs':
+      return await getLanguagesVoicesForRimelabs(credential, getTtsVoices, logger);
     case 'assemblyai':
       return await getLanguagesVoicesForAssemblyAI(credential, getTtsVoices, logger);
     case 'whisper':
       return await getLanguagesVoicesForWhisper(credential, getTtsVoices, logger);
+    case 'verbio':
+      return await getLanguagesVoicesForVerbio(credential, getTtsVoices, logger);
+    case 'speechmatics':
+      return await getLanguagesVoicesForSpeechmatics(credential, getTtsVoices, logger);
     default:
       logger.info(`invalid vendor ${vendor}, return empty result`);
       throw new Error(`Invalid vendor ${vendor}`);
@@ -552,6 +718,7 @@ async function getLanguagesVoicesForAws(credential, getTtsVoices, logger) {
         credentials: {
           accessKeyId: credential.access_key_id,
           secretAccessKey: credential.secret_access_key,
+          roleArn: credential.role_arn,
           region: credential.aws_region || process.env.AWS_REGION
         }
       });
@@ -633,6 +800,10 @@ async function getLanguagesVoicesForSoniox(credential) {
   return tranform(undefined, SttSonioxLanguagesVoices);
 }
 
+async function getLanguagesVoicesForSpeechmatics(credential) {
+  return tranform(undefined, SttSpeechmaticsLanguagesVoices);
+}
+
 async function getLanguagesVoicesForElevenlabs(credential) {
   if (credential) {
     const get = bent('https://api.elevenlabs.io', 'GET', 'json', {
@@ -679,7 +850,7 @@ const concat = (a) => {
   return a ? ` ${a},` : '';
 };
 
-async function getLanguagesVoicesForPlayHT(credential) {
+const fetchLayHTVoices = async(credential) => {
   if (credential) {
     const get = bent('https://api.play.ht', 'GET', 'json', {
       'AUTHORIZATION' : credential.api_key,
@@ -688,34 +859,100 @@ async function getLanguagesVoicesForPlayHT(credential) {
     });
 
     const voices = await get('/api/v2/voices');
+    let clone_voices = [];
+    try {
+      // try if the account has permission to cloned voice
+      //otherwise ignore this.
+      clone_voices = await get('/api/v2/cloned-voices');
+    } catch {}
+    return [clone_voices, voices];
+  }
+};
+
+async function getLanguagesVoicesForPlayHT(credential) {
+  if (credential) {
+    const {voice_engine} = credential;
+    const [cloned_voice, voices] = await fetchLayHTVoices(credential);
+    const list_voices = [...cloned_voice, ...voices];
 
     const buildVoice = (d) => {
-      let name = `${d.name} -${concat(d.accent)}${concat(d.age)}${concat(d.gender)}
-${concat(d.loudness)}${concat(d.style)}${concat(d.tempo)}${concat(d.texture)}` ;
-      name = name.endsWith(',') ? name.slice(0, -1) : name;
+      let name = `${d.name} -${concat(d.accent)}${concat(d.age)}${concat(d.gender)}${concat(d.loudness)}` +
+      `${concat(d.style)}${concat(d.tempo)}${concat(d.texture)}` ;
+      name = name.endsWith(',') ? name.trim().slice(0, -1) : name;
+      name += !d.language_code ? ' - Custom Voice' : '';
+
       return {
         value: `${d.id}`,
         name
       };
     };
 
-    const ttsVoices = voices.reduce((acc, voice) => {
-      const languageCode = voice.language_code;
-      const existingLanguage = acc.find((lang) => lang.value === languageCode);
-      if (existingLanguage) {
-        existingLanguage.voices.push(buildVoice(voice));
-      } else {
-        acc.push({
-          value: voice.language_code,
-          name: voice.language,
-          voices: [buildVoice(voice)]
-        });
-      }
-      return acc;
-    }, []);
-    return tranform(ttsVoices, undefined, TtsModelPlayHT);
+    const buildPlay30Payload = () => {
+      // PlayHT3.0 can play different languages with differrent voice.
+      // all voices will be added to english language by default and orther langauges will get voices from english.
+      const ttsVoices = ttsLanguagesPlayHt.map((l) => ({
+        ...l,
+        voices: l.value === 'english' ? list_voices.map((v) => buildVoice(v)) : []
+      }));
+      return tranform(ttsVoices, undefined, TtsModelPlayHT);
+    };
+
+    const buildPayload = () => {
+      const ttsVoices = list_voices.reduce((acc, voice) => {
+        if (!voice_engine.includes(voice.voice_engine)) {
+          return acc;
+        }
+        const languageCode = voice.language_code;
+        // custom voice does not have language code
+        if (!languageCode) {
+          voice.language_code = 'en';
+          voice.language = 'Custom-English';
+        }
+        const existingLanguage = acc.find((lang) => lang.value === languageCode);
+        if (existingLanguage) {
+          existingLanguage.voices.push(buildVoice(voice));
+        } else {
+          acc.push({
+            value: voice.language_code,
+            name: voice.language,
+            voices: [buildVoice(voice)]
+          });
+        }
+        return acc;
+      }, []);
+      return tranform(ttsVoices, undefined, TtsModelPlayHT);
+    };
+
+    switch (voice_engine) {
+      case 'Play3.0':
+        return buildPlay30Payload();
+
+      default:
+        return buildPayload();
+    }
   }
-  return tranform(undefined, undefined, TtsModelPlayHT);
+  return tranform(TtsPlayHtLanguagesVoices, undefined, TtsModelPlayHT);
+}
+
+async function getLanguagesVoicesForRimelabs(credential) {
+  const model_id = credential ? credential.model_id : null;
+  const get = bent('https://users.rime.ai', 'GET', 'json', {
+    'Accept': 'application/json'
+  });
+  const voices = await get('/data/voices/all.json');
+  let selectedVoices = model_id ? voices[model_id] : Object.values(voices).reduce((acc, val) => [...acc, ...val], []);
+  selectedVoices = selectedVoices.map((v) => ({
+    name: v.charAt(0).toUpperCase() + v.slice(1),
+    value: v
+  }));
+  const ttsVoices = [
+    {
+      value: 'en-US',
+      name: 'English (US)',
+      voices: selectedVoices
+    }
+  ];
+  return tranform(ttsVoices, undefined, TtsModelRimelabs);
 }
 
 async function getLanguagesVoicesForAssemblyAI(credential) {
@@ -726,6 +963,23 @@ async function getLanguagesVoicesForWhisper(credential) {
   return tranform(TtsWhisperLanguagesVoices, undefined, TtsModelWhisper);
 }
 
+async function getLanguagesVoicesForVerbio(credentials, getTtsVoices, logger) {
+  const stt = SttVerbioLanguagesVoices.reduce((acc, v) => {
+    if (!v.version || credentials.engine_version === v.version) {
+      acc.push(v);
+    }
+    return acc;
+  }, []);
+  try {
+    const data = await getTtsVoices({vendor: 'verbio', credentials});
+    const voices = parseVerbioLanguagesVoices(data);
+    return tranform(voices, stt, undefined);
+  } catch (err) {
+    logger.info({err}, 'there is error while fetching verbio speech voices');
+    return tranform(TtsVerbioLanguagesVoices, stt, undefined);
+  }
+}
+
 function tranform(tts, stt, models) {
   return {
     ...(tts && {tts}),
@@ -853,6 +1107,29 @@ function parseMicrosoftLanguagesVoices(data) {
   }, []);
 }
 
+function parseVerbioLanguagesVoices(data) {
+  return data.reduce((acc, voice) => {
+    const languageCode = voice.language;
+    const existingLanguage = acc.find((lang) => lang.value === languageCode);
+    if (existingLanguage) {
+      existingLanguage.voices.push({
+        value: voice.voice_id,
+        name: voice.name,
+      });
+    } else {
+      acc.push({
+        value: voice.language,
+        name: voice.language,
+        voices: [{
+          value: voice.voice_id,
+          name: voice.name,
+        }]
+      });
+    }
+    return acc;
+  }, []);
+}
+
 module.exports = {
   testGoogleTts,
   testGoogleStt,
@@ -870,10 +1147,14 @@ module.exports = {
   testSonioxStt,
   testElevenlabs,
   testPlayHT,
+  testRimelabs,
   testAssemblyStt,
   testDeepgramTTS,
   getSpeechCredential,
   decryptCredential,
   testWhisper,
-  getLanguagesAndVoicesForVendor
+  testVerbioTts,
+  testVerbioStt,
+  getLanguagesAndVoicesForVendor,
+  testSpeechmaticsStt
 };

package.json

@@ -1,6 +1,6 @@
 {
   "name": "jambonz-api-server",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "description": "",
   "main": "app.js",
   "scripts": {
@@ -28,10 +28,10 @@
     "@jambonz/db-helpers": "^0.9.3",
     "@jambonz/lamejs": "^1.2.2",
     "@jambonz/mw-registrar": "^0.2.7",
-    "@jambonz/realtimedb-helpers": "^0.8.8",
-    "@jambonz/speech-utils": "^0.0.50",
+    "@jambonz/realtimedb-helpers": "^0.8.10",
+    "@jambonz/speech-utils": "^0.1.20",
     "@jambonz/time-series": "^0.2.8",
-    "@jambonz/verb-specifications": "^0.0.69",
+    "@jambonz/verb-specifications": "^0.0.72",
     "@soniox/soniox-node": "^1.2.2",
     "argon2": "^0.40.1",
     "assemblyai": "^4.3.4",
@@ -46,12 +46,13 @@
     "jsonwebtoken": "^9.0.2",
     "mailgun.js": "^10.2.1",
     "microsoft-cognitiveservices-speech-sdk": "1.36.0",
-    "mysql2": "^3.9.3",
+    "mysql2": "^3.11.0",
     "nocache": "4.0.0",
     "passport": "^0.7.0",
     "passport-http-bearer": "^1.0.1",
     "pino": "^8.20.0",
     "short-uuid": "^4.2.2",
+    "speechmatics": "^4.0.0",
     "stream-buffers": "^3.0.2",
     "stripe": "^14.24.0",
     "swagger-ui-express": "^5.0.0",

test/accounts.js

@@ -14,7 +14,7 @@ const {
   createPhoneNumber, 
   deleteObjectBySid} = require('./utils');
 const logger = require('../lib/logger');
-const { addToSortedSet } = require('@jambonz/realtimedb-helpers')({
+const { addToSortedSet, createHash } = require('@jambonz/realtimedb-helpers')({
   host: process.env.JAMBONES_REDIS_HOST,
   port: process.env.JAMBONES_REDIS_PORT || 6379
 }, logger);
@@ -152,7 +152,9 @@ test('account tests', async(t) => {
       auth: authAdmin,
       json: true,
     });
+    console.log(result);
     t.ok(result.name === 'daveh' , 'successfully retrieved account by sid');
+    t.ok(result.enable_debug_log  === 0 , 'enable_debug_log default value ok');
 
     /* update account with account level token */
     result = await request.put(`/Accounts/${sid}`, {
@@ -177,8 +179,8 @@ test('account tests', async(t) => {
           name: 'recordings',
           access_key_id: 'access_key_id',
           secret_access_key: 'secret access key'
-        }
-        
+        },
+        enable_debug_log: true
       }
     });
     t.ok(result.statusCode === 204, 'successfully updated account using account level token');
@@ -194,6 +196,7 @@ test('account tests', async(t) => {
     t.ok(result.bucket_credential.access_key_id === 'access_key_id', 'bucket_access_key_id was updated');
     t.ok(result.record_all_calls === 1, 'record_all_calls was updated');
     t.ok(result.record_format === 'wav', 'record_format was updated');
+    t.ok(result.enable_debug_log, 'enable_debug_log was updated');
 
     /* verify that account level api key last_used was updated*/
     result = await request.get(`/Accounts/${sid}/ApiKeys`, {
@@ -314,6 +317,19 @@ test('account tests', async(t) => {
     });
     t.ok(result.statusCode === 200 && result.body.length === 0, 'successfully queried account queue info with for an invalid account');
 
+    // query conferences
+    await createHash(`conf:${sid}:conf1`, 'url1');
+    await createHash(`conf:${sid}:conf2`, 'url2');
+    await createHash(`conf:${sid}:conf3`, 'url3');
+    await createHash(`conf:${sid}:conf4`, 'url4');
+
+    result = await request.get(`/Accounts/${sid}/Conferences`, {
+      auth: authAdmin,
+      resolveWithFullResponse: true,
+      json: true,
+    });
+    t.ok(result.statusCode === 200 && result.body.length === 4, 'successfully queried account conferences info for an account');
+
     /* delete account */
     result = await request.delete(`/Accounts/${sid}`, {
       auth: authAdmin,

test/sip-gateways.js

@@ -17,6 +17,53 @@ test('sip gateway tests', async(t) => {
     let result;
     const voip_carrier_sid = await createVoipCarrier(request);
 
+    /* add a invalid sip gateway */
+    const STORED_JAMBONZ_MIN_GATEWAY_NETMASK = process.env.JAMBONZ_MIN_GATEWAY_NETMASK;
+    process.env.JAMBONZ_MIN_GATEWAY_NETMASK = 24;
+    
+    result = await request.post('/SipGateways', {
+      resolveWithFullResponse: true,
+      auth: authAdmin,
+      json: true,
+      simple: false,
+      body: {
+        voip_carrier_sid,
+        ipv4: '1.2.3.4',
+        netmask: 1,
+        inbound: true,
+        outbound: true,
+        protocol: 'tcp'
+      }
+    });
+    t.ok(result.statusCode === 400, 'successfully created sip gateway ');
+
+    result = await request.post('/SipGateways', {
+      resolveWithFullResponse: true,
+      auth: authAdmin,
+      json: true,
+      body: {
+        voip_carrier_sid,
+        ipv4: '1.2.3.4',
+        netmask: 24,
+        inbound: true,
+        outbound: true,
+        protocol: 'tcp'
+      }
+    });
+    t.ok(result.statusCode === 201, 'successfully created sip gateway ');
+
+    process.env.JAMBONZ_MIN_GATEWAY_NETMASK = STORED_JAMBONZ_MIN_GATEWAY_NETMASK;
+
+    /* delete sip gateways */
+    result = await request.delete(`/SipGateways/${result.body.sid}`, {
+      resolveWithFullResponse: true,
+      simple: false,
+      json: true,
+      auth: authAdmin
+    });
+    //console.log(`result: ${JSON.stringify(result)}`);
+    t.ok(result.statusCode === 204, 'successfully deleted sip gateway');
+
     /* add a sip gateway */
     result = await request.post('/SipGateways', {
       resolveWithFullResponse: true,
@@ -75,6 +122,44 @@ test('sip gateway tests', async(t) => {
     });
     //console.log(`result: ${JSON.stringify(result)}`);
     t.ok(result.statusCode === 204, 'successfully deleted sip gateway');
+
+    /* add a sip gateway */
+    result = await request.post('/SipGateways', {
+      resolveWithFullResponse: true,
+      auth: authAdmin,
+      json: true,
+      body: {
+        voip_carrier_sid,
+        ipv4: '192.168.1.2',
+        netmask: 32,
+        inbound: true,
+        outbound: true,
+        protocol: 'tls',
+        use_sips_scheme: true
+      }
+    });
+    t.ok(result.statusCode === 201, 'successfully created sip gateway ');
+    const sipsSid = result.body.sid;
+
+    /* query one sip gateway */
+    result = await request.get(`/SipGateways/${sipsSid}`, {
+      auth: authAdmin,
+      json: true,
+    });
+    //console.log(`result: ${JSON.stringify(result)}`);
+    t.ok(result.ipv4 === '192.168.1.2' , 'successfully retrieved voip carrier by sid');
+    t.ok(result.protocol === 'tls' , 'successfully retrieved voip carrier by sid');
+    t.ok(result.use_sips_scheme, 'successfully retrieved voip carrier by sid');
+
+    /* delete sip gateways */
+    result = await request.delete(`/SipGateways/${sipsSid}`, {
+      resolveWithFullResponse: true,
+      simple: false,
+      json: true,
+      auth: authAdmin
+    });
+    //console.log(`result: ${JSON.stringify(result)}`);
+    t.ok(result.statusCode === 204, 'successfully deleted sip gateway');
     
     await deleteObjectBySid(request, '/VoipCarriers', voip_carrier_sid);
 

test/speech-credentials.js

@@ -170,6 +170,20 @@ test('speech credentials tests', async(t) => {
       //console.log(JSON.stringify(result));
       t.ok(result.statusCode === 200 && result.body.tts.status === 'ok', 'successfully tested speech credential for google tts');
       t.ok(result.statusCode === 200 && result.body.stt.status === 'ok', 'successfully tested speech credential for google stt');
+
+      result = await request.post(`/Accounts/${account_sid}/TtsCache/Synthesize`, {
+        resolveWithFullResponse: true,
+        auth: authUser,
+        json: true,
+        body: {
+          speech_credential_sid: ms_sid,
+          text: "Hello How are you",
+          language: "en-US",
+          voice: "en-US-Standard-C"
+        }
+      });
+
+      t.ok(result.statusCode === 200, 'successfully google tested synthesize');
     }
 
     /* add / test a credential for microsoft */
@@ -198,6 +212,20 @@ test('speech credentials tests', async(t) => {
       //console.log(JSON.stringify(result));
       t.ok(result.statusCode === 200 && result.body.tts.status === 'ok', 'successfully tested speech credential for microsoft tts');
       t.ok(result.statusCode === 200 && result.body.stt.status === 'ok', 'successfully tested speech credential for microsoft stt');
+
+      result = await request.post(`/Accounts/${account_sid}/TtsCache/Synthesize`, {
+        resolveWithFullResponse: true,
+        auth: authUser,
+        json: true,
+        body: {
+          speech_credential_sid: ms_sid,
+          text: "Hello How are you",
+          language: "en-US",
+          voice: "en-US-AvaMultilingualNeural"
+        }
+      });
+
+      t.ok(result.statusCode === 200, 'successfully microsoft tested synthesize');
     }
 
     /* add / test a credential for AWS */
@@ -227,6 +255,20 @@ test('speech credentials tests', async(t) => {
       //console.log(JSON.stringify(result));
       t.ok(result.statusCode === 200 && result.body.tts.status === 'ok', 'successfully tested speech credential for AWS tts');
       t.ok(result.statusCode === 200 && result.body.stt.status === 'ok', 'successfully tested speech credential for AWS stt');
+
+      result = await request.post(`/Accounts/${account_sid}/TtsCache/Synthesize`, {
+        resolveWithFullResponse: true,
+        auth: authUser,
+        json: true,
+        body: {
+          speech_credential_sid: ms_sid,
+          text: "Hello How are you",
+          language: "en-US",
+          voice: "Joanna"
+        }
+      });
+
+      t.ok(result.statusCode === 200, 'successfully AWS tested synthesize');
     }
 
     /* add a credential for wellsaid */
@@ -253,6 +295,20 @@ test('speech credentials tests', async(t) => {
       //console.log(JSON.stringify(result));
       t.ok(result.statusCode === 200 && result.body.tts.status === 'ok', 'successfully tested speech credential for wellsaid');
 
+      result = await request.post(`/Accounts/${account_sid}/TtsCache/Synthesize`, {
+        resolveWithFullResponse: true,
+        auth: authUser,
+        json: true,
+        body: {
+          speech_credential_sid: ms_sid,
+          text: "Hello How are you",
+          language: "en-US",
+          voice: "3"
+        }
+      });
+
+      t.ok(result.statusCode === 200, 'successfully Wellsaid tested synthesize');
+
       /* delete the credential */
       result = await request.delete(`/Accounts/${account_sid}/SpeechCredentials/${ms_sid}`, {
         auth: authUser,
@@ -285,6 +341,20 @@ test('speech credentials tests', async(t) => {
       //console.log(JSON.stringify(result));
       t.ok(result.statusCode === 200 && result.body.stt.status === 'ok', 'successfully tested speech credential for deepgram');
 
+      result = await request.post(`/Accounts/${account_sid}/TtsCache/Synthesize`, {
+        resolveWithFullResponse: true,
+        auth: authUser,
+        json: true,
+        body: {
+          speech_credential_sid: ms_sid,
+          text: "Hello How are you",
+          language: "en-US",
+          voice: "aura-asteria-en"
+        }
+      });
+
+      t.ok(result.statusCode === 200, 'successfully deepgram tested synthesize');
+
       /* delete the credential */
       result = await request.delete(`/Accounts/${account_sid}/SpeechCredentials/${ms_sid}`, {
         auth: authUser,
@@ -301,7 +371,8 @@ test('speech credentials tests', async(t) => {
         vendor: 'deepgram',
         use_for_stt: true,
         deepgram_stt_uri: "127.0.0.1:50002",
-        deepgram_stt_use_tls: true
+        deepgram_stt_use_tls: true,
+        deepgram_tts_uri: 'https://server.com'
       }
     });
     t.ok(result.statusCode === 201, 'successfully added speech credential for deepgram');
@@ -316,6 +387,7 @@ test('speech credentials tests', async(t) => {
     t.ok(result.statusCode === 200, 'successfully get speech credential for deepgram');
     t.ok(result.body.deepgram_stt_uri === '127.0.0.1:50002', "deepgram_stt_uri is correct for deepgram");
     t.ok(result.body.deepgram_stt_use_tls === true, "deepgram_stt_use_tls is correct for deepgram");
+    t.ok(result.body.deepgram_tts_uri === 'https://server.com', "deepgram_tts_uri is correct for deepgram")
 
     result = await request.put(`/Accounts/${account_sid}/SpeechCredentials/${dg_sid}`, {
       resolveWithFullResponse: true,
@@ -325,7 +397,8 @@ test('speech credentials tests', async(t) => {
         vendor: 'deepgram',
         use_for_stt: true,
         deepgram_stt_uri: "127.0.0.2:50002",
-        deepgram_stt_use_tls: false
+        deepgram_stt_use_tls: false,
+        deepgram_tts_uri: 'https://server2.com'
       }
     });
     t.ok(result.statusCode === 204, 'successfully updated speech credential for deepgram onprem');
@@ -339,6 +412,7 @@ test('speech credentials tests', async(t) => {
     t.ok(result.statusCode === 200, 'successfully get speech credential for deepgram onprem');
     t.ok(result.body.deepgram_stt_uri === '127.0.0.2:50002', "deepgram_stt_uri is correct for deepgram onprem");
     t.ok(result.body.deepgram_stt_use_tls === false, "deepgram_stt_use_tls is correct for deepgram onprem");
+    t.ok(result.body.deepgram_tts_uri === 'https://server2.com', "deepgram_tts_uri is correct for deepgram onprem");
 
     result = await request.delete(`/Accounts/${account_sid}/SpeechCredentials/${dg_sid}`, {
       auth: authUser,
@@ -404,6 +478,20 @@ test('speech credentials tests', async(t) => {
       //console.log(JSON.stringify(result));
       t.ok(result.statusCode === 200 && result.body.stt.status === 'ok', 'successfully tested speech credential for ibm stt');
 
+      result = await request.post(`/Accounts/${account_sid}/TtsCache/Synthesize`, {
+        resolveWithFullResponse: true,
+        auth: authUser,
+        json: true,
+        body: {
+          speech_credential_sid: ms_sid,
+          text: "Hello How are you",
+          language: "en-US",
+          voice: "en-US_MichaelExpressive"
+        }
+      });
+
+      t.ok(result.statusCode === 200, 'successfully IBM tested synthesize');
+
       /* delete the credential */
       result = await request.delete(`/Accounts/${account_sid}/SpeechCredentials/${ms_sid}`, {
         auth: authUser,
@@ -444,6 +532,39 @@ test('speech credentials tests', async(t) => {
       t.ok(result.statusCode === 204, 'successfully deleted speech credential');
     }
 
+    /* add a credential for Speechmatics */
+    if (process.env.SPEECHMATICS_API_KEY) {
+      result = await request.post(`/Accounts/${account_sid}/SpeechCredentials`, {
+        resolveWithFullResponse: true,
+        auth: authUser,
+        json: true,
+        body: {
+          vendor: 'speechmatics',
+          use_for_stt: true,
+          api_key: process.env.SPEECHMATICS_API_KEY,
+          speechmatics_stt_uri: 'eu2.rt.speechmatics.com'
+        }
+      });
+      t.ok(result.statusCode === 201, 'successfully added speech credential for speechmatics');
+      const ms_sid = result.body.sid;
+
+      /* test the speech credential */
+      result = await request.get(`/Accounts/${account_sid}/SpeechCredentials/${ms_sid}/test`, {
+        resolveWithFullResponse: true,
+        auth: authUser,
+        json: true,   
+      });
+      console.log(JSON.stringify(result));
+      t.ok(result.statusCode === 200 && result.body.stt.status === 'ok', 'successfully tested speech credential for speechmatics');
+
+      /* delete the credential */
+      result = await request.delete(`/Accounts/${account_sid}/SpeechCredentials/${ms_sid}`, {
+        auth: authUser,
+        resolveWithFullResponse: true,
+      });
+      t.ok(result.statusCode === 204, 'successfully deleted speech credential');
+    }
+
     /* add a credential for nvidia */
     result = await request.post(`/Accounts/${account_sid}/SpeechCredentials`, {
       resolveWithFullResponse: true,
@@ -570,6 +691,29 @@ test('speech credentials tests', async(t) => {
     });
     t.ok(result.statusCode === 204, 'successfully deleted speech credential for playht');
 
+    /* add a credential for rimelabs */
+    result = await request.post(`/Accounts/${account_sid}/SpeechCredentials`, {
+      resolveWithFullResponse: true,
+      auth: authUser,
+      json: true,
+      body: {
+        vendor: 'rimelabs',
+        use_for_stt: false,
+        use_for_tts: true,
+        api_key: 'asdasdasdasddsadasda',
+        model_id: 'mist',
+      }
+    });
+    t.ok(result.statusCode === 201, 'successfully added speech credential for rimelabs');
+    const rimelabs_sid = result.body.sid;
+
+    /* delete the credential */
+    result = await request.delete(`/Accounts/${account_sid}/SpeechCredentials/${rimelabs_sid}`, {
+      auth: authUser,
+      resolveWithFullResponse: true,
+    });
+    t.ok(result.statusCode === 204, 'successfully deleted speech credential for rimelabs');
+
 
     /* add a credential for custom voices google */
     result = await request.post(`/Accounts/${account_sid}/SpeechCredentials`, {
@@ -636,6 +780,82 @@ test('speech credentials tests', async(t) => {
     });
     t.ok(result.statusCode === 204, 'successfully deleted speech credential');
 
+    /* add a credential for aws polly by roleArn */
+    result = await request.post(`/Accounts/${account_sid}/SpeechCredentials`, {
+      resolveWithFullResponse: true,
+      auth: authUser,
+      json: true,
+      body: {
+        vendor: 'aws',
+        label: 'aws_polly_with_arn',
+        use_for_tts: true,
+        use_for_stt: false,
+        role_arn: 'Arn::aws::role',
+        aws_region: 'us-east-1'
+      }
+    });
+    t.ok(result.statusCode === 201, 'successfully added speech credential for AWS Polly By RoleArn');
+    const awsPollySid = result.body.sid;
+
+    /* delete the credential */
+    result = await request.delete(`/Accounts/${account_sid}/SpeechCredentials/${awsPollySid}`, {
+      auth: authUser,
+      resolveWithFullResponse: true,
+    });
+    t.ok(result.statusCode === 204, 'successfully deleted speech credential');
+
+    /* add a credential for verbio */
+    result = await request.post(`/Accounts/${account_sid}/SpeechCredentials`, {
+      resolveWithFullResponse: true,
+      auth: authUser,
+      json: true,
+      body: {
+        vendor: 'verbio',
+        use_for_tts: true,
+        use_for_stt: true,
+        client_id: 'client:id',
+        client_secret: 'client:secret',
+        engine_version: 'V1'
+      }
+    });
+    t.ok(result.statusCode === 201, 'successfully added speech credential for Verbio');
+    const verbioSid = result.body.sid;
+
+    result = await request.get(`/Accounts/${account_sid}/SpeechCredentials/${verbioSid}`, {
+      resolveWithFullResponse: true,
+      simple: false,
+      auth: authAdmin,
+      json: true,
+    });
+    t.ok(result.body.engine_version === "V1", 'successfully get verbio speech credential');
+
+    result = await request.put(`/Accounts/${account_sid}/SpeechCredentials/${verbioSid}`, {
+      resolveWithFullResponse: true,
+      auth: authUser,
+      json: true,
+      body: {
+        use_for_tts: true,
+        use_for_stt: true,
+        engine_version: 'V2'
+      }
+    });
+    t.ok(result.statusCode === 204, 'successfully updated speech credential for verbio');
+
+    result = await request.get(`/Accounts/${account_sid}/SpeechCredentials/${verbioSid}`, {
+      resolveWithFullResponse: true,
+      simple: false,
+      auth: authAdmin,
+      json: true,
+    });
+    t.ok(result.body.engine_version === "V2", 'successfully Updated verbio speech credential');
+
+    /* delete the credential */
+    result = await request.delete(`/Accounts/${account_sid}/SpeechCredentials/${verbioSid}`, {
+      auth: authUser,
+      resolveWithFullResponse: true,
+    });
+    t.ok(result.statusCode === 204, 'successfully deleted speech credential');
+
     /* Check google supportedLanguagesAndVoices */
     result = await request.get(`/Accounts/${account_sid}/SpeechCredentials/speech/supportedLanguagesAndVoices?vendor=google`, {
       resolveWithFullResponse: true,

test/system-information.js

@@ -16,7 +16,9 @@ test('system information test', async(t) => {
       body: {
         domain_name: 'test.com',
         sip_domain_name: 'sip.test.com',
-        monitoring_domain_name: 'monitor.test.com'
+        monitoring_domain_name: 'monitor.test.com',
+        private_network_cidr: '192.168.1.0/24, 10.10.100.1',
+        log_level: 'info'
       }
     });
     t.ok(result.statusCode === 201, 'successfully created system information ');
@@ -24,6 +26,8 @@ test('system information test', async(t) => {
     t.ok(body.domain_name === 'test.com', 'added domain_name ok');
     t.ok(body.sip_domain_name === 'sip.test.com', 'added sip_domain_name ok');
     t.ok(body.monitoring_domain_name === 'monitor.test.com', 'added monitoring_domain_name ok');
+    t.ok(body.private_network_cidr === '192.168.1.0/24, 10.10.100.1', 'added private_network_cidr ok');
+    t.ok(body.log_level === 'info', 'added log_level ok');
 
     result = await request.get('/SystemInformation', {
       auth: authAdmin,
@@ -32,6 +36,8 @@ test('system information test', async(t) => {
     t.ok(result.domain_name === 'test.com', 'get domain_name ok');
     t.ok(result.sip_domain_name === 'sip.test.com', 'get sip_domain_name ok');
     t.ok(result.monitoring_domain_name === 'monitor.test.com', 'get monitoring_domain_name ok');
+    t.ok(result.private_network_cidr === '192.168.1.0/24, 10.10.100.1', 'get private_network_cidr ok'); 
+    t.ok(result.log_level === 'info', 'added log_level ok');
 
     result = await request.post('/SystemInformation', {
       resolveWithFullResponse: true,
@@ -40,7 +46,9 @@ test('system information test', async(t) => {
       body: {
         domain_name: 'test1.com',
         sip_domain_name: 'sip1.test.com',
-        monitoring_domain_name: 'monitor1.test.com'
+        monitoring_domain_name: 'monitor1.test.com',
+        private_network_cidr: '',
+        log_level: 'debug'
       }
     });
     t.ok(result.statusCode === 201, 'successfully updated system information ');
@@ -48,6 +56,8 @@ test('system information test', async(t) => {
     t.ok(body.domain_name === 'test1.com', 'updated domain_name ok');
     t.ok(body.sip_domain_name === 'sip1.test.com', 'updated sip_domain_name ok');
     t.ok(body.monitoring_domain_name === 'monitor1.test.com', 'updated monitoring_domain_name ok');
+    t.ok(body.private_network_cidr === '', 'updated private_network_cidr ok');
+    t.ok(body.log_level === 'debug', 'updated log_level ok');
 
     result = await request.get('/SystemInformation', {
       auth: authAdmin,
@@ -56,6 +66,7 @@ test('system information test', async(t) => {
     t.ok(result.domain_name === 'test1.com', 'get domain_name ok');
     t.ok(result.sip_domain_name === 'sip1.test.com', 'get sip_domain_name ok');
     t.ok(result.monitoring_domain_name === 'monitor1.test.com', 'get monitoring_domain_name ok');
+    t.ok(result.log_level === 'debug', 'updated log_level ok');
 
   } catch(err) {
     console.error(err);