0.1.3

lint

.gitignore

@@ -39,3 +39,5 @@ node_modules
 examples/*
 
 .vscode
+
+.env

index.js

@@ -13,10 +13,11 @@ module.exports = (opts, logger) => {
     getTtsSize: require('./lib/get-tts-size').bind(null, client, logger),
     purgeTtsCache: require('./lib/purge-tts-cache').bind(null, client, logger),
     addFileToCache: require('./lib/add-file-to-cache').bind(null, client, logger),
-    synthAudio: require('./lib/synth-audio').bind(null, client, logger),
+    synthAudio: require('./lib/synth-audio').bind(null, client, createHash, retrieveHash, logger),
+    getVerbioAccessToken: require('./lib/get-verbio-token').bind(null, client, logger),
     getNuanceAccessToken: require('./lib/get-nuance-access-token').bind(null, client, logger),
     getIbmAccessToken: require('./lib/get-ibm-access-token').bind(null, client, logger),
     getAwsAuthToken: require('./lib/get-aws-sts-token').bind(null, logger, createHash, retrieveHash),
-    getTtsVoices: require('./lib/get-tts-voices').bind(null, client, logger),
+    getTtsVoices: require('./lib/get-tts-voices').bind(null, client, createHash, retrieveHash, logger),
   };
 };

lib/add-file-to-cache.js

@@ -1,6 +1,7 @@
 const fs = require('fs/promises');
 const {noopLogger, makeSynthKey} = require('./utils');
-const EXPIRES = (process.env.JAMBONES_TTS_CACHE_DURATION_MINS || 4 * 60) * 60; // cache tts for 4 hours
+const {JAMBONES_TTS_CACHE_DURATION_MINS} = require('./config');
+const EXPIRES = JAMBONES_TTS_CACHE_DURATION_MINS;
 
 async function addFileToCache(client, logger, path,
   {account_sid, vendor, language, voice, deploymentId, engine, text}) {

lib/config.js

@@ -0,0 +1,21 @@
+const JAMBONES_TTS_TRIM_SILENCE = process.env.JAMBONES_TTS_TRIM_SILENCE;
+const JAMBONES_DISABLE_TTS_STREAMING = process.env.JAMBONES_DISABLE_TTS_STREAMING;
+
+const JAMBONES_HTTP_PROXY_IP = process.env.JAMBONES_HTTP_PROXY_IP;
+const JAMBONES_HTTP_PROXY_PORT = process.env.JAMBONES_HTTP_PROXY_PORT;
+const JAMBONES_TTS_CACHE_DURATION_MINS =
+  (parseInt(process.env.JAMBONES_TTS_CACHE_DURATION_MINS) || 4 * 60) * 60; // cache tts for 4 hours
+
+const TMP_FOLDER = '/tmp';
+
+const HTTP_TIMEOUT = 5000;
+
+module.exports = {
+  JAMBONES_TTS_TRIM_SILENCE,
+  JAMBONES_DISABLE_TTS_STREAMING,
+  JAMBONES_HTTP_PROXY_IP,
+  JAMBONES_HTTP_PROXY_PORT,
+  JAMBONES_TTS_CACHE_DURATION_MINS,
+  TMP_FOLDER,
+  HTTP_TIMEOUT
+};

lib/get-aws-sts-token.js

@@ -1,32 +1,41 @@
-const { STSClient, GetSessionTokenCommand } = require('@aws-sdk/client-sts');
+const { STSClient, GetSessionTokenCommand, AssumeRoleCommand } = require('@aws-sdk/client-sts');
 const {makeAwsKey, noopLogger} = require('./utils');
 const debug = require('debug')('jambonz:speech-utils');
 const EXPIRY = 3600;
 
 async function getAwsAuthToken(
-  logger,
-  createHash, retrieveHash,
-  awsAccessKeyId, awsSecretAccessKey, awsRegion) {
+  logger, createHash, retrieveHash,
+  awsAccessKeyId, awsSecretAccessKey, awsRegion, roleArn = null) {
   logger = logger || noopLogger;
   try {
-    const key = makeAwsKey(awsAccessKeyId);
+    const key = makeAwsKey(roleArn || awsAccessKeyId);
     const obj = await retrieveHash(key);
     if (obj) return {...obj, servedFromCache: true};
 
-    /* access token not found in cache, so generate it using STS */
-    const stsClient = new STSClient({
-      region: awsRegion,
-      credentials: {
-        accessKeyId: awsAccessKeyId,
-        secretAccessKey: awsSecretAccessKey,
-      }
-    });
-    const command = new GetSessionTokenCommand({DurationSeconds: EXPIRY});
-    const data = await stsClient.send(command);
+    let data;
+    if (roleArn) {
+      const stsClient = new STSClient({ region: awsRegion});
+      const roleToAssume = { RoleArn: roleArn, RoleSessionName: 'Jambonz_Speech', DurationSeconds: EXPIRY};
+      const command = new AssumeRoleCommand(roleToAssume);
+
+      data = await stsClient.send(command);
+    } else {
+      /* access token not found in cache, so generate it using STS */
+      const stsClient = new STSClient({
+        region: awsRegion,
+        credentials: {
+          accessKeyId: awsAccessKeyId,
+          secretAccessKey: awsSecretAccessKey,
+        }
+      });
+      const command = new GetSessionTokenCommand({DurationSeconds: EXPIRY});
+      data = await stsClient.send(command);
+    }
 
     const credentials = {
       accessKeyId: data.Credentials.AccessKeyId,
       secretAccessKey: data.Credentials.SecretAccessKey,
+      sessionToken: data.Credentials.SessionToken,
       securityToken: data.Credentials.SessionToken
     };
 

lib/get-ibm-access-token.js

@@ -2,8 +2,8 @@ const formurlencoded = require('form-urlencoded');
 const {Pool} = require('undici');
 const pool = new Pool('https://iam.cloud.ibm.com');
 const {makeIbmKey, noopLogger} = require('./utils');
+const { HTTP_TIMEOUT } = require('./config');
 const debug = require('debug')('jambonz:realtimedb-helpers');
-const HTTP_TIMEOUT = 5000;
 
 async function getIbmAccessToken(client, logger, apiKey) {
   logger = logger || noopLogger;

lib/get-nuance-access-token.js

@@ -2,8 +2,8 @@ const formurlencoded = require('form-urlencoded');
 const {Pool} = require('undici');
 const pool = new Pool('https://auth.crt.nuance.com');
 const {makeNuanceKey, makeBasicAuthHeader, noopLogger} = require('./utils');
+const { HTTP_TIMEOUT } = require('./config');
 const debug = require('debug')('jambonz:realtimedb-helpers');
-const HTTP_TIMEOUT = 5000;
 
 async function getNuanceAccessToken(client, logger, clientId, secret, scope) {
   logger = logger || noopLogger;

lib/get-tts-voices.js

@@ -1,11 +1,16 @@
 const assert = require('assert');
 const {noopLogger, createNuanceClient, createKryptonClient} = require('./utils');
 const getNuanceAccessToken = require('./get-nuance-access-token');
+const getVerbioAccessToken = require('./get-verbio-token');
 const {GetVoicesRequest, Voice} = require('../stubs/nuance/synthesizer_pb');
 const TextToSpeechV1 = require('ibm-watson/text-to-speech/v1');
 const { IamAuthenticator } = require('ibm-watson/auth');
 const ttsGoogle = require('@google-cloud/text-to-speech');
 const { PollyClient, DescribeVoicesCommand } = require('@aws-sdk/client-polly');
+const getAwsAuthToken = require('./get-aws-sts-token');
+const {Pool} = require('undici');
+const { HTTP_TIMEOUT } = require('./config');
+const verbioVoicePool = new Pool('https://us.rest.speechcenter.verbio.com');
 
 const getIbmVoices = async(client, logger, credentials) => {
   const {tts_region, tts_api_key} = credentials;
@@ -87,16 +92,26 @@ const getGoogleVoices = async(_client, logger, credentials) => {
   return await client.listVoices();
 };
 
-const getAwsVoices = async(_client, logger, credentials) => {
+const getAwsVoices = async(_client, createHash, retrieveHash, logger, credentials) => {
   try {
-    const {region, accessKeyId, secretAccessKey} = credentials;
-    const client = new PollyClient({
-      region,
-      credentials: {
-        accessKeyId,
-        secretAccessKey
-      }
-    });
+    const {region, accessKeyId, secretAccessKey, roleArn} = credentials;
+    let client = null;
+    if (accessKeyId && secretAccessKey) {
+      client = new PollyClient({
+        region,
+        credentials: {
+          accessKeyId,
+          secretAccessKey
+        }
+      });
+    } else if (roleArn) {
+      client = new PollyClient({
+        region,
+        credentials: await getAwsAuthToken(logger, createHash, retrieveHash, null, null, region, roleArn),
+      });
+    } else {
+      client = new PollyClient({region});
+    }
     const command = new DescribeVoicesCommand({});
     const response = await client.send(command);
     return response;
@@ -106,6 +121,26 @@ const getAwsVoices = async(_client, logger, credentials) => {
   }
 };
 
+const getVerbioVoices = async(client, logger, credentials) => {
+  try {
+    const access_token = await getVerbioAccessToken(client, logger, credentials);
+    const { body} =  await verbioVoicePool.request({
+      path: '/api/v1/voices',
+      method: 'GET',
+      headers: {
+        'Authorization': `Bearer ${access_token.access_token}`,
+        'User-Agent': 'jambonz'
+      },
+      timeout: HTTP_TIMEOUT,
+      followRedirects: false
+    });
+    return await body.json();
+  } catch (err) {
+    logger.info({err}, 'getVerbioVoices - failed to list voices for Verbio');
+    throw err;
+  }
+};
+
 /**
  * Synthesize speech to an mp3 file, and also cache the generated speech
  * in redis (base64 format) for 24 hours so as to avoid unnecessarily paying
@@ -122,10 +157,10 @@ const getAwsVoices = async(_client, logger, credentials) => {
  * @returns object containing filepath to an mp3 file in the /tmp folder containing
  * the synthesized audio, and a variable indicating whether it was served from cache
  */
-async function getTtsVoices(client, logger, {vendor, credentials}) {
+async function getTtsVoices(client, createHash, retrieveHash, logger, {vendor, credentials}) {
   logger = logger || noopLogger;
 
-  assert.ok(['nuance', 'ibm', 'google', 'aws', 'polly'].includes(vendor),
+  assert.ok(['nuance', 'ibm', 'google', 'aws', 'polly', 'verbio'].includes(vendor),
     `getTtsVoices not supported for vendor ${vendor}`);
 
   switch (vendor) {
@@ -137,7 +172,9 @@ async function getTtsVoices(client, logger, {vendor, credentials}) {
       return getGoogleVoices(client, logger, credentials);
     case 'aws':
     case 'polly':
-      return getAwsVoices(client, logger, credentials);
+      return getAwsVoices(client, createHash, retrieveHash, logger, credentials);
+    case 'verbio':
+      return getVerbioVoices(client, logger, credentials);
     default:
       break;
   }

lib/get-verbio-token.js

@@ -0,0 +1,51 @@
+const {Pool} = require('undici');
+const { noopLogger, makeVerbioKey } = require('./utils');
+const { HTTP_TIMEOUT } = require('./config');
+const pool = new Pool('https://auth.speechcenter.verbio.com:444');
+const debug = require('debug')('jambonz:realtimedb-helpers');
+
+async function getVerbioAccessToken(client, logger, credentials) {
+  logger = logger || noopLogger;
+  const { client_id, client_secret } = credentials;
+  try {
+    const key = makeVerbioKey(client_id);
+    const access_token = await client.get(key);
+    if (access_token) {
+      return {access_token, servedFromCache: true};
+    }
+
+    const payload = {
+      client_id,
+      client_secret
+    };
+
+    const {statusCode, headers, body} =  await pool.request({
+      path: '/api/v1/token',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'User-Agent': 'jambonz'
+      },
+      body: JSON.stringify(payload),
+      timeout: HTTP_TIMEOUT,
+      followRedirects: false
+    });
+
+    if (200 !== statusCode) {
+      logger.debug({statusCode, headers, body: await body.text()}, 'error fetching access token from Verbio');
+      const err = new Error();
+      err.statusCode = statusCode;
+      throw err;
+    }
+    const json = await body.json();
+    const expiry =  Math.floor(json.expiration_time - Date.now() / 1000 - 30);
+    await client.set(key, json.access_token, 'EX', expiry);
+    return {...json, servedFromCache: false};
+  } catch (err) {
+    debug(err, `getVerbioAccessToken: Error retrieving Verbio access token for client_id ${client_id}`);
+    logger.error(err, `getVerbioAccessToken: Error retrieving Verbio access token for client_id ${client_id}`);
+    throw err;
+  }
+}
+
+module.exports = getVerbioAccessToken;

lib/synth-audio.js

@@ -19,9 +19,11 @@ const {
   createNuanceClient,
   createKryptonClient,
   createRivaClient,
-  noopLogger
+  noopLogger,
+  makeFilePath
 } = require('./utils');
 const getNuanceAccessToken = require('./get-nuance-access-token');
+const getVerbioAccessToken = require('./get-verbio-token');
 const {
   SynthesisRequest,
   Voice,
@@ -36,9 +38,15 @@ const {
 const {SynthesizeSpeechRequest} = require('../stubs/riva/proto/riva_tts_pb');
 const {AudioEncoding} = require('../stubs/riva/proto/riva_audio_pb');
 const debug = require('debug')('jambonz:realtimedb-helpers');
-const EXPIRES = (process.env.JAMBONES_TTS_CACHE_DURATION_MINS || 4 * 60) * 60; // cache tts for 4 hours
-const TMP_FOLDER = '/tmp';
+const {
+  JAMBONES_DISABLE_TTS_STREAMING,
+  JAMBONES_HTTP_PROXY_IP,
+  JAMBONES_HTTP_PROXY_PORT,
+  JAMBONES_TTS_CACHE_DURATION_MINS,
+} = require('./config');
+const EXPIRES = JAMBONES_TTS_CACHE_DURATION_MINS;
 const OpenAI = require('openai');
+const getAwsAuthToken = require('./get-aws-sts-token');
 
 
 const trimTrailingSilence = (buffer) => {
@@ -75,7 +83,7 @@ const trimTrailingSilence = (buffer) => {
  * @returns object containing filepath to an mp3 file in the /tmp folder containing
  * the synthesized audio, and a variable indicating whether it was served from cache
  */
-async function synthAudio(client, logger, stats, { account_sid,
+async function synthAudio(client, createHash, retrieveHash, logger, stats, { account_sid,
   vendor, language, voice, gender, text, engine, salt, model, credentials, deploymentId,
   disableTtsCache, renderForCaching, disableTtsStreaming, options
 }) {
@@ -85,7 +93,7 @@ async function synthAudio(client, logger, stats, { account_sid,
   logger = logger || noopLogger;
 
   assert.ok(['google', 'aws', 'polly', 'microsoft', 'wellsaid', 'nuance', 'nvidia', 'ibm', 'elevenlabs',
-    'whisper', 'deepgram', 'playht', 'rimelabs'].includes(vendor) ||
+    'whisper', 'deepgram', 'playht', 'rimelabs', 'verbio'].includes(vendor) ||
   vendor.startsWith('custom'),
   `synthAudio supported vendors are google, aws, microsoft, nuance, nvidia and wellsaid ..etc, not ${vendor}`);
   if ('google' === vendor) {
@@ -138,6 +146,10 @@ async function synthAudio(client, logger, stats, { account_sid,
     assert.ok(credentials.api_key, 'synthAudio requires api_key when whisper is used');
   } else  if (vendor.startsWith('custom')) {
     assert.ok(credentials.custom_tts_url, `synthAudio requires custom_tts_url in credentials when ${vendor} is used`);
+  } else if ('verbio' === vendor) {
+    assert.ok(voice, 'synthAudio requires voice when verbio is used');
+    assert.ok(credentials.client_id, 'synthAudio requires client_id when verbio is used');
+    assert.ok(credentials.client_secret, 'synthAudio requires client_secret when verbio is used');
   }
   const key = makeSynthKey({
     account_sid,
@@ -148,19 +160,7 @@ async function synthAudio(client, logger, stats, { account_sid,
     text
   });
   let filePath;
-  if (['nuance', 'nvidia'].includes(vendor) ||
-    (
-      (process.env.JAMBONES_TTS_TRIM_SILENCE || !process.env.JAMBONES_DISABLE_TTS_STREAMING) &&
-      ['microsoft', 'azure'].includes(vendor)
-    ) ||
-    (
-      !process.env.JAMBONES_DISABLE_TTS_STREAMING &&
-      ['elevenlabs', 'deepgram', 'rimelabs'].includes(vendor)
-    )
-  ) {
-    filePath = `${TMP_FOLDER}/${key.replace('tts:', `tts-${salt || ''}`)}.r8`;
-  }
-  else filePath = `${TMP_FOLDER}/${key.replace('tts:', `tts-${salt || ''}`)}.mp3`;
+  filePath = makeFilePath(vendor, key, salt);
   debug(`synth key is ${key}`);
   let cached;
   if (!disableTtsCache) {
@@ -187,14 +187,14 @@ async function synthAudio(client, logger, stats, { account_sid,
       case 'aws':
       case 'polly':
         vendorLabel = 'aws';
-        audioBuffer = await synthPolly(logger, {credentials, stats, language, voice, text, engine});
+        audioBuffer = await synthPolly(createHash, retrieveHash, logger,
+          {credentials, stats, language, voice, text, engine});
         break;
       case 'azure':
       case 'microsoft':
         vendorLabel = 'microsoft';
         audioBuffer = await synthMicrosoft(logger, {credentials, stats, language, voice, text, deploymentId,
           filePath, renderForCaching, disableTtsStreaming});
-        if (audioBuffer?.filePath) return audioBuffer;
         break;
       case 'nuance':
         model = model || 'enhanced';
@@ -213,29 +213,29 @@ async function synthAudio(client, logger, stats, { account_sid,
         audioBuffer = await synthElevenlabs(logger, {
           credentials, options, stats, language, voice, text, renderForCaching, disableTtsStreaming, filePath
         });
-        if (audioBuffer?.filePath) return audioBuffer;
         break;
       case 'playht':
         audioBuffer = await synthPlayHT(logger, {
           credentials, options, stats, language, voice, text, renderForCaching, disableTtsStreaming, filePath
         });
-        if (audioBuffer?.filePath) return audioBuffer;
         break;
       case 'rimelabs':
         audioBuffer = await synthRimelabs(logger, {
           credentials, options, stats, language, voice, text, renderForCaching, disableTtsStreaming, filePath
         });
-        if (audioBuffer?.filePath) return audioBuffer;
         break;
       case 'whisper':
         audioBuffer = await synthWhisper(logger, {
           credentials, stats, voice, text, renderForCaching, disableTtsStreaming});
+        break;
+      case 'verbio':
+        audioBuffer = await synthVerbio(client, logger, {
+          credentials, stats, voice, text, renderForCaching, disableTtsStreaming});
         if (audioBuffer?.filePath) return audioBuffer;
         break;
       case 'deepgram':
         audioBuffer = await synthDeepgram(logger, {credentials, stats, model, text,
           renderForCaching, disableTtsStreaming});
-        if (audioBuffer?.filePath) return audioBuffer;
         break;
       case vendor.startsWith('custom') ? vendor : 'cant_match_value':
         ({ audioBuffer, filePath } = await synthCustomVendor(logger,
@@ -244,6 +244,7 @@ async function synthAudio(client, logger, stats, { account_sid,
       default:
         assert(`synthAudio: unsupported speech vendor ${vendor}`);
     }
+    if ('filePath' in audioBuffer) return audioBuffer;
     const diff = process.hrtime(startAt);
     const time = diff[0] * 1e3 + diff[1] * 1e-6;
     rtt = time.toFixed(0);
@@ -263,16 +264,28 @@ async function synthAudio(client, logger, stats, { account_sid,
   });
 }
 
-const synthPolly = async(logger, {credentials, stats, language, voice, engine, text}) => {
+const synthPolly = async(createHash, retrieveHash, logger,
+  {credentials, stats, language, voice, engine, text}) => {
   try {
-    const {region, accessKeyId, secretAccessKey} = credentials;
-    const polly = new PollyClient({
-      region,
-      credentials: {
-        accessKeyId,
-        secretAccessKey
-      }
-    });
+    const {region, accessKeyId, secretAccessKey, roleArn} = credentials;
+    let polly;
+    if (accessKeyId && secretAccessKey) {
+      polly = new PollyClient({
+        region,
+        credentials: {
+          accessKeyId,
+          secretAccessKey
+        }
+      });
+    } else if (roleArn) {
+      polly = new PollyClient({
+        region,
+        credentials: await getAwsAuthToken(logger, createHash, retrieveHash, null, null, region, roleArn),
+      });
+    } else {
+      // AWS RoleArn assigned to Instance profile
+      polly = new PollyClient({region});
+    }
     const opts = {
       Engine: engine,
       OutputFormat: 'mp3',
@@ -366,7 +379,7 @@ async function _synthOnPremMicrosoft(logger, {
   text,
   filePath
 }) {
-  const {use_custom_tts, custom_tts_endpoint_url} = credentials;
+  const {use_custom_tts, custom_tts_endpoint_url, api_key} = credentials;
   let content = text;
 
   if (use_custom_tts && !content.startsWith('<speak')) {
@@ -390,7 +403,8 @@ async function _synthOnPremMicrosoft(logger, {
     const post = bent('POST', 'buffer', {
       'X-Microsoft-OutputFormat': trimSilence ? 'raw-8khz-16bit-mono-pcm' : 'audio-16khz-32kbitrate-mono-mp3',
       'Content-Type': 'application/ssml+xml',
-      'User-Agent': 'Jambonz'
+      'User-Agent': 'Jambonz',
+      ...(api_key && {'Ocp-Apim-Subscription-Key': api_key})
     });
     const mp3 = await post(custom_tts_endpoint_url, content);
     return mp3;
@@ -429,7 +443,7 @@ const synthMicrosoft = async(logger, {
       content = `<speak version="1.0" xmlns="http://www.w3.org/2001/10/synthesis" xmlns:mstts="https://www.w3.org/2001/mstts" xml:lang="${language}"><voice name="${voice}">${words}</voice></speak>`;
       logger.info({content}, 'synthMicrosoft');
     }
-    if (!process.env.JAMBONES_DISABLE_TTS_STREAMING && !renderForCaching && !disableTtsStreaming) {
+    if (!JAMBONES_DISABLE_TTS_STREAMING && !renderForCaching && !disableTtsStreaming) {
       let params = '';
       params += `{api_key=${apiKey}`;
       params += `,language=${language}`;
@@ -438,8 +452,9 @@ const synthMicrosoft = async(logger, {
       params += ',write_cache_file=1';
       if (region) params += `,region=${region}`;
       if (custom_tts_endpoint) params += `,endpointId=${custom_tts_endpoint}`;
-      if (process.env.JAMBONES_HTTP_PROXY_IP) params += `,http_proxy_ip=${process.env.JAMBONES_HTTP_PROXY_IP}`;
-      if (process.env.JAMBONES_HTTP_PROXY_PORT) params += `,http_proxy_port=${process.env.JAMBONES_HTTP_PROXY_PORT}`;
+      if (custom_tts_endpoint_url) params += `,endpoint=${custom_tts_endpoint_url}`;
+      if (JAMBONES_HTTP_PROXY_IP) params += `,http_proxy_ip=${JAMBONES_HTTP_PROXY_IP}`;
+      if (JAMBONES_HTTP_PROXY_PORT) params += `,http_proxy_port=${JAMBONES_HTTP_PROXY_PORT}`;
       params += '}';
       return {
         filePath: `say:${params}${content.replace(/\n/g, ' ')}`,
@@ -468,10 +483,10 @@ const synthMicrosoft = async(logger, {
       SpeechSynthesisOutputFormat.Raw8Khz16BitMonoPcm :
       SpeechSynthesisOutputFormat.Audio16Khz32KBitRateMonoMp3;
 
-    if (process.env.JAMBONES_HTTP_PROXY_IP && process.env.JAMBONES_HTTP_PROXY_PORT) {
+    if (JAMBONES_HTTP_PROXY_IP && JAMBONES_HTTP_PROXY_PORT) {
       logger.debug(
-        `synthMicrosoft: using proxy ${process.env.JAMBONES_HTTP_PROXY_IP}:${process.env.JAMBONES_HTTP_PROXY_PORT}`);
-      speechConfig.setProxy(process.env.JAMBONES_HTTP_PROXY_IP, process.env.JAMBONES_HTTP_PROXY_PORT);
+        `synthMicrosoft: using proxy ${JAMBONES_HTTP_PROXY_IP}:${JAMBONES_HTTP_PROXY_PORT}`);
+      speechConfig.setProxy(JAMBONES_HTTP_PROXY_IP, JAMBONES_HTTP_PROXY_PORT);
     }
     const synthesizer = new SpeechSynthesizer(speechConfig);
 
@@ -657,7 +672,7 @@ const synthElevenlabs = async(logger, {
   const opts = !!options && Object.keys(options).length !== 0 ? options : JSON.parse(credOpts || '{}');
 
   /* default to using the streaming interface, unless disabled by env var OR we want just a cache file */
-  if (!process.env.JAMBONES_DISABLE_TTS_STREAMING && !renderForCaching && !disableTtsStreaming) {
+  if (!JAMBONES_DISABLE_TTS_STREAMING && !renderForCaching && !disableTtsStreaming) {
     let params = '';
     params += `{api_key=${api_key}`;
     params += ',vendor=elevenlabs';
@@ -710,7 +725,7 @@ const synthPlayHT = async(logger, {
   const opts = !!options && Object.keys(options).length !== 0 ? options : JSON.parse(credOpts || '{}');
 
   /* default to using the streaming interface, unless disabled by env var OR we want just a cache file */
-  if (!process.env.JAMBONES_DISABLE_TTS_STREAMING && !renderForCaching && !disableTtsStreaming) {
+  if (!JAMBONES_DISABLE_TTS_STREAMING && !renderForCaching && !disableTtsStreaming) {
     let params = '';
     params += `{api_key=${api_key}`;
     params += `,user_id=${user_id}`;
@@ -765,7 +780,7 @@ const synthRimelabs = async(logger, {
   const opts = !!options && Object.keys(options).length !== 0 ? options : JSON.parse(credOpts || '{}');
 
   /* default to using the streaming interface, unless disabled by env var OR we want just a cache file */
-  if (!process.env.JAMBONES_DISABLE_TTS_STREAMING && !renderForCaching && !disableTtsStreaming) {
+  if (!JAMBONES_DISABLE_TTS_STREAMING && !renderForCaching && !disableTtsStreaming) {
     let params = '';
     params += `{api_key=${api_key}`;
     params += `,model_id=${model_id}`;
@@ -803,11 +818,51 @@ const synthRimelabs = async(logger, {
     throw err;
   }
 };
+const synthVerbio = async(client, logger, {credentials, stats, voice, text, renderForCaching, disableTtsStreaming}) => {
+  //https://doc.speechcenter.verbio.com/#tag/Text-To-Speech-REST-API
+  if (text.length > 2000) {
+    throw new Error('Verbio cannot synthesize for the text length larger than 2000 characters');
+  }
+  const token = await getVerbioAccessToken(client, logger, credentials);
+  if (!process.env.JAMBONES_DISABLE_TTS_STREAMING && !renderForCaching && !disableTtsStreaming) {
+    let params = '';
+    params += `{access_token=${token.access_token}`;
+    params += ',vendor=verbio';
+    params += `,voice=${voice}`;
+    params += ',write_cache_file=1';
+    params += '}';
+
+    return {
+      filePath: `say:${params}${text.replace(/\n/g, ' ')}`,
+      servedFromCache: false,
+      rtt: 0
+    };
+  }
+
+  try {
+    const post = bent('https://us.rest.speechcenter.verbio.com', 'POST', 'buffer', {
+      'Authorization': `Bearer ${token.access_token}`,
+      'User-Agent': 'jambonz',
+      'Content-Type': 'application/json'
+    });
+    const r8 = await post('/api/v1/synthesize', {
+      voice_id: voice,
+      output_sample_rate: '8k',
+      output_encoding: 'pcm16',
+      text
+    });
+    return r8;
+  } catch (err) {
+    logger.info({err}, 'synth Verbio returned error');
+    stats.increment('tts.count', ['vendor:verbio', 'accepted:no']);
+    throw err;
+  }
+};
 
 const synthWhisper = async(logger, {credentials, stats, voice, text, renderForCaching, disableTtsStreaming}) => {
   const {api_key, model_id, baseURL, timeout, speed} = credentials;
   /* if the env is set to stream then bag out, unless we are specifically rendering to generate a cache file */
-  if (!process.env.JAMBONES_DISABLE_TTS_STREAMING && !renderForCaching && !disableTtsStreaming) {
+  if (!JAMBONES_DISABLE_TTS_STREAMING && !renderForCaching && !disableTtsStreaming) {
     let params = '';
     params += `{api_key=${api_key}`;
     params += `,model_id=${model_id}`;
@@ -846,7 +901,7 @@ const synthWhisper = async(logger, {credentials, stats, voice, text, renderForCa
 
 const synthDeepgram = async(logger, {credentials, stats, model, text, renderForCaching, disableTtsStreaming}) => {
   const {api_key} = credentials;
-  if (!process.env.JAMBONES_DISABLE_TTS_STREAMING && !renderForCaching && !disableTtsStreaming) {
+  if (!JAMBONES_DISABLE_TTS_STREAMING && !renderForCaching && !disableTtsStreaming) {
     let params = '';
     params += `{api_key=${api_key}`;
     params += ',vendor=deepgram';

lib/utils.js

@@ -3,10 +3,10 @@ const {SynthesizerClient} = require('../stubs/nuance/synthesizer_grpc_pb');
 const {RivaSpeechSynthesisClient} = require('../stubs/riva/proto/riva_tts_grpc_pb');
 const {Pool} = require('undici');
 const pool = new Pool('https://auth.crt.nuance.com');
-const HTTP_TIMEOUT = 5000;
 const NUANCE_AUTH_ENDPOINT = 'tts.api.nuance.com:443';
 const grpc = require('@grpc/grpc-js');
 const formurlencoded = require('form-urlencoded');
+const { JAMBONES_DISABLE_TTS_STREAMING, JAMBONES_TTS_TRIM_SILENCE, TMP_FOLDER, HTTP_TIMEOUT } = require('./config');
 
 const debug = require('debug')('jambonz:realtimedb-helpers');
 /**
@@ -19,7 +19,44 @@ const debug = require('debug')('jambonz:realtimedb-helpers');
 function makeSynthKey({account_sid = '', vendor, language, voice, engine = '', text}) {
   const hash = crypto.createHash('sha1');
   hash.update(`${language}:${vendor}:${voice}:${engine}:${text}`);
-  return `tts${account_sid ? (':' + account_sid) : ''}:${hash.digest('hex')}`;
+  const hexHashKey = hash.digest('hex');
+  const accountKey = account_sid ? `:${account_sid}` : '';
+  const namespace = vendor.startsWith('custom') ? vendor : getFileExtension(vendor);
+  const key = `tts${accountKey}:${namespace}:${hexHashKey}`;
+  return key;
+}
+
+function makeFilePath(vendor, key, salt = '') {
+  const extension = getFileExtension(vendor);
+  return `${TMP_FOLDER}/${key.replace('tts:', `tts-${salt}`)}.${extension}`;
+}
+
+function getFileExtension(vendor) {
+  const mp3Extension = 'mp3';
+  const r8Extension = 'r8';
+
+  switch (vendor) {
+    case 'azure':
+    case 'microsoft':
+      if (!JAMBONES_DISABLE_TTS_STREAMING || JAMBONES_TTS_TRIM_SILENCE) {
+        return r8Extension;
+      } else {
+        return mp3Extension;
+      }
+    case 'deepgram':
+    case 'elevenlabs':
+    case 'rimlabs':
+      if (!JAMBONES_DISABLE_TTS_STREAMING) {
+        return r8Extension;
+      } else {
+        return mp3Extension;
+      }
+    case 'nuance':
+    case 'nvidia':
+      return r8Extension;
+    default:
+      return mp3Extension;
+  }
 }
 
 const noopLogger = {
@@ -49,6 +86,12 @@ function makeAwsKey(awsAccessKeyId) {
   return `aws:${hash.digest('hex')}`;
 }
 
+function makeVerbioKey(client_id) {
+  const hash = crypto.createHash('sha1');
+  hash.update(client_id);
+  return `verbio:${hash.digest('hex')}`;
+}
+
 function makeNuanceKey(clientId, secret, scope) {
   const hash = crypto.createHash('sha1');
   hash.update(`${clientId}:${secret}:${scope}`);
@@ -117,11 +160,13 @@ module.exports = {
   makeNuanceKey,
   makeIbmKey,
   makeAwsKey,
+  makeVerbioKey,
   getNuanceAccessToken,
   createNuanceClient,
   createKryptonClient,
   createRivaClient,
   makeBasicAuthHeader,
   NUANCE_AUTH_ENDPOINT,
-  noopLogger
+  noopLogger,
+  makeFilePath
 };

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@jambonz/speech-utils",
-  "version": "0.0.51",
+  "version": "0.1.3",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@jambonz/speech-utils",
-      "version": "0.0.51",
+      "version": "0.1.3",
       "license": "MIT",
       "dependencies": {
         "@aws-sdk/client-polly": "^3.496.0",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jambonz/speech-utils",
-  "version": "0.0.51",
+  "version": "0.1.3",
   "description": "TTS-related speech utilities for jambonz",
   "main": "index.js",
   "author": "Dave Horton",
@@ -12,6 +12,7 @@
     "test": "NODE_ENV=test node test/ ",
     "coverage": "nyc --reporter html --report-dir ./coverage npm run test",
     "jslint": "eslint index.js lib",
+    "jslint:fix": "eslint --fix '**/*.js'",
     "build": "./build_stubs.sh"
   },
   "repository": {

stubs/nuance/synthesizer_grpc_pb.js

@@ -62,9 +62,9 @@ function deserialize_nuance_tts_v1_UnarySynthesisResponse(buffer_arg) {
 
 //
 // The Synthesizer service offers these functionalities:
-// - GetVoices: Queries the list of available voices, with filters to reduce the search space.  
-// - Synthesize: Synthesizes audio from input text and parameters, and returns an audio stream. 
-// - UnarySynthesize: Synthesizes audio from input text and parameters, and returns a single audio response. 
+// - GetVoices: Queries the list of available voices, with filters to reduce the search space.
+// - Synthesize: Synthesizes audio from input text and parameters, and returns an audio stream.
+// - UnarySynthesize: Synthesizes audio from input text and parameters, and returns a single audio response.
 var SynthesizerService = exports.SynthesizerService = {
   getVoices: {
     path: '/nuance.tts.v1.Synthesizer/GetVoices',

stubs/riva/proto/riva_audio_grpc_pb.js

@@ -1 +1 @@
-// GENERATED CODE -- NO SERVICES IN PROTO
+// GENERATED CODE -- NO SERVICES IN PROTO

stubs/riva/proto/riva_tts_grpc_pb.js

@@ -57,7 +57,7 @@ function deserialize_nvidia_riva_tts_SynthesizeSpeechResponse(buffer_arg) {
 var RivaSpeechSynthesisService = exports.RivaSpeechSynthesisService = {
   // Used to request text-to-speech from the service. Submit a request containing the
 // desired text and configuration, and receive audio bytes in the requested format.
-synthesize: {
+  synthesize: {
     path: '/nvidia.riva.tts.RivaSpeechSynthesis/Synthesize',
     requestStream: false,
     responseStream: false,
@@ -69,9 +69,9 @@ synthesize: {
     responseDeserialize: deserialize_nvidia_riva_tts_SynthesizeSpeechResponse,
   },
   // Used to request text-to-speech returned via stream as it becomes available.
-// Submit a SynthesizeSpeechRequest with desired text and configuration,
-// and receive stream of bytes in the requested format.
-synthesizeOnline: {
+  // Submit a SynthesizeSpeechRequest with desired text and configuration,
+  // and receive stream of bytes in the requested format.
+  synthesizeOnline: {
     path: '/nvidia.riva.tts.RivaSpeechSynthesis/SynthesizeOnline',
     requestStream: false,
     responseStream: true,
@@ -83,7 +83,7 @@ synthesizeOnline: {
     responseDeserialize: deserialize_nvidia_riva_tts_SynthesizeSpeechResponse,
   },
   // Enables clients to request the configuration of the current Synthesize service, or a specific model within the service.
-getRivaSynthesisConfig: {
+  getRivaSynthesisConfig: {
     path: '/nvidia.riva.tts.RivaSpeechSynthesis/GetRivaSynthesisConfig',
     requestStream: false,
     responseStream: false,

test/list-voices.js

@@ -12,6 +12,32 @@ const stats = {
   histogram: () => {}
 };
 
+test('Verbio - get Access key and voices', async(t) => {
+  const fn = require('..');
+  const {client, getTtsVoices, getVerbioAccessToken} = fn(opts, logger);
+  if (!process.env.VERBIO_CLIENT_ID || !process.env.VERBIO_CLIENT_SECRET) {
+    t.pass('skipping Verbio test since no Verbio Keys provided');
+    t.end();
+    client.quit();
+    return;
+  }
+
+  try {
+    const credentials = {
+      client_id: process.env.VERBIO_CLIENT_ID,
+      client_secret: process.env.VERBIO_CLIENT_SECRET
+    };
+    let obj = await getVerbioAccessToken(credentials);
+    t.ok(obj.access_token , 'successfully received access token not from cache');
+    const voices = await getTtsVoices({vendor: 'verbio', credentials});
+    t.ok(voices && voices.length != 0, 'successfully received verbio voices');
+  } catch (err) {
+    console.error(err);
+    t.end(err);
+  }
+  client.quit();
+});
+
 test('IBM - create access key', async(t) => {
   const fn = require('..');
   const {client, getIbmAccessToken} = fn(opts, logger);

test/synth.js

@@ -162,6 +162,33 @@ test('AWS speech synth tests', async(t) => {
   client.quit();
 });
 
+test('AWS speech synth tests by RoleArn', async(t) => {
+  const fn = require('..');
+  const {synthAudio, client} = fn(opts, logger);
+
+  if (!process.env.AWS_ROLE_ARN || !process.env.AWS_REGION) {
+    t.pass('skipping AWS speech synth tests by RoleArn since AWS_ROLE_ARN or AWS_REGION not provided');
+    return t.end();
+  }
+  try {
+    let opts = await synthAudio(stats, {
+      vendor: 'aws',
+      credentials: {
+        roleArn: process.env.AWS_ROLE_ARN,
+        region: process.env.AWS_REGION,
+      },
+      language: 'en-US',
+      voice: 'Joey',
+      text: 'This is a test.  This is only a test',
+    });
+    t.ok(!opts.servedFromCache, `successfully synthesized aws by roleArn audio to ${opts.filePath}`);
+  } catch (err) {
+    console.error(err);
+    t.end(err);
+  }
+  client.quit();
+});
+
 test('Azure speech synth tests', async(t) => {
   const fn = require('..');
   const {synthAudio, client} = fn(opts, logger);
@@ -643,6 +670,40 @@ test('whisper speech synth tests', async(t) => {
       language: 'en-US',
       voice: 'alloy',
       text,
+      renderForCaching: true
+    });
+    t.ok(!opts.servedFromCache, `successfully synthesized whisper audio to ${opts.filePath}`);
+
+  } catch (err) {
+    console.error(JSON.stringify(err));
+    t.end(err);
+  }
+  client.quit();
+});
+
+test('Verbio speech synth tests', async(t) => {
+  const fn = require('..');
+  const {synthAudio, client} = fn(opts, logger);
+
+  if (!process.env.VERBIO_CLIENT_ID || !process.env.VERBIO_CLIENT_SECRET) {
+    t.pass('skipping Verbio Synthesize test since no Verbio Keys provided');
+    t.end();
+    client.quit();
+    return;
+  }
+
+  const text = 'Hi there and welcome to jambones!';
+  try {
+    let opts = await synthAudio(stats, {
+      vendor: 'verbio',
+      credentials: {
+        client_id: process.env.VERBIO_CLIENT_ID,
+        client_secret: process.env.VERBIO_CLIENT_SECRET
+      },
+      language: 'en-US',
+      voice: 'tommy_en-us',
+      text,
+      renderForCaching: true
     });
     t.ok(!opts.servedFromCache, `successfully synthesized whisper audio to ${opts.filePath}`);
 
@@ -728,8 +789,19 @@ test('TTS Cache tests', async(t) => {
     t.ok(error, `error returned when specified key was not found`);
 
     // make sure other tts keys are still there
-    const cached = (await client.keys('tts:*')).length;
-    t.ok(cached >= 1, `successfully kept all non-specified tts records in cache`);
+    const cached = await client.keys('tts:*')
+    t.ok(cached.length >= 1, `successfully kept all non-specified tts records in cache`);
+
+    // retrieve keys from cache and check the key contains the file extension    
+    let key = cached[0];
+    t.ok(key.includes('mp3'), `tts cache extension shoult be part of the key and equal mp3`);
+
+    process.env.VG_TRIM_TTS_SILENCE = 'true';    
+    await client.set(makeSynthKey({ vendor: 'azure' }), 'value');
+
+    const r8Keys = await client.keys('tts:r8*');
+    key = r8Keys[0];
+    t.ok(key.includes('r8'), `tts cache extension shoult be part of the key and equal r8`);
 
   } catch (err) {
     console.error(JSON.stringify(err));