0.2.8

support rimelabs arcana

.eslintignore

@@ -1 +0,0 @@
-test/*

.eslintrc.json

@@ -1,126 +0,0 @@
-{
-  "env": {
-    "node": true,
-    "es6": true  
-  },
-  "parserOptions": {
-    "ecmaFeatures": {
-      "jsx": false,
-      "modules": false
-    },
-    "ecmaVersion": 2020
-  },
-  "plugins": ["promise"],
-  "rules": {
-    "promise/always-return": "error",
-    "promise/no-return-wrap": "error",
-    "promise/param-names": "error",
-    "promise/catch-or-return": "error",
-    "promise/no-native": "off",
-    "promise/no-nesting": "warn",
-    "promise/no-promise-in-callback": "warn",
-    "promise/no-callback-in-promise": "warn",
-    "promise/no-return-in-finally": "warn",
-
-    // Possible Errors
-    // http://eslint.org/docs/rules/#possible-errors
-    "comma-dangle": [2, "only-multiline"],
-    "no-control-regex": 2,
-    "no-debugger": 2,
-    "no-dupe-args": 2,
-    "no-dupe-keys": 2,
-    "no-duplicate-case": 2,
-    "no-empty-character-class": 2,
-    "no-ex-assign": 2,
-    "no-extra-boolean-cast" : 2,
-    "no-extra-parens": [2, "functions"],
-    "no-extra-semi": 2,
-    "no-func-assign": 2,
-    "no-invalid-regexp": 2,
-    "no-irregular-whitespace": 2,
-    "no-negated-in-lhs": 2,
-    "no-obj-calls": 2,
-    "no-proto": 2,
-    "no-unexpected-multiline": 2,
-    "no-unreachable": 2,
-    "use-isnan": 2,
-    "valid-typeof": 2,
-
-    // Best Practices
-    // http://eslint.org/docs/rules/#best-practices
-    "no-fallthrough": 2,
-    "no-octal": 2,
-    "no-redeclare": 2,
-    "no-self-assign": 2,
-    "no-unused-labels": 2,
-
-    // Strict Mode
-    // http://eslint.org/docs/rules/#strict-mode
-    "strict": [2, "never"],
-
-    // Variables
-    // http://eslint.org/docs/rules/#variables
-    "no-delete-var": 2,
-    "no-undef": 2,
-    "no-unused-vars": [2, {"args": "none"}],
-
-    // Node.js and CommonJS
-    // http://eslint.org/docs/rules/#nodejs-and-commonjs
-    "no-mixed-requires": 2,
-    "no-new-require": 2,
-    "no-path-concat": 2,
-    "no-restricted-modules": [2, "sys", "_linklist"],
-
-    // Stylistic Issues
-    // http://eslint.org/docs/rules/#stylistic-issues
-    "comma-spacing": 2,
-    "eol-last": 2,
-    "indent": [2, 2, {"SwitchCase": 1}],
-    "keyword-spacing": 2,
-    "max-len": [2, 120, 2],
-    "new-parens": 2,
-    "no-mixed-spaces-and-tabs": 2,
-    "no-multiple-empty-lines": [2, {"max": 2}],
-    "no-trailing-spaces": [2, {"skipBlankLines": false }],
-    "quotes": [2, "single", "avoid-escape"],
-    "semi": 2,
-    "space-before-blocks": [2, "always"],
-    "space-before-function-paren": [2, "never"],
-    "space-in-parens": [2, "never"],
-    "space-infix-ops": 2,
-    "space-unary-ops": 2,
-
-    // ECMAScript 6
-    // http://eslint.org/docs/rules/#ecmascript-6
-    "arrow-parens": [2, "always"],
-    "arrow-spacing": [2, {"before": true, "after": true}],
-    "constructor-super": 2,
-    "no-class-assign": 2,
-    "no-confusing-arrow": 2,
-    "no-const-assign": 2,
-    "no-dupe-class-members": 2,
-    "no-new-symbol": 2,
-    "no-this-before-super": 2,
-    "prefer-const": 2
-  },
-  "globals": {
-    "DTRACE_HTTP_CLIENT_REQUEST"           : false,
-    "LTTNG_HTTP_CLIENT_REQUEST"            : false,
-    "COUNTER_HTTP_CLIENT_REQUEST"          : false,
-    "DTRACE_HTTP_CLIENT_RESPONSE"          : false,
-    "LTTNG_HTTP_CLIENT_RESPONSE"           : false,
-    "COUNTER_HTTP_CLIENT_RESPONSE"         : false,
-    "DTRACE_HTTP_SERVER_REQUEST"           : false,
-    "LTTNG_HTTP_SERVER_REQUEST"            : false,
-    "COUNTER_HTTP_SERVER_REQUEST"          : false,
-    "DTRACE_HTTP_SERVER_RESPONSE"          : false,
-    "LTTNG_HTTP_SERVER_RESPONSE"           : false,
-    "COUNTER_HTTP_SERVER_RESPONSE"         : false,
-    "DTRACE_NET_STREAM_END"                : false,
-    "LTTNG_NET_STREAM_END"                 : false,
-    "COUNTER_NET_SERVER_CONNECTION_CLOSE"  : false,
-    "DTRACE_NET_SERVER_CONNECTION"         : false,
-    "LTTNG_NET_SERVER_CONNECTION"          : false,
-    "COUNTER_NET_SERVER_CONNECTION"        : false  
-  }
-}

.github/workflows/ci.yml

@@ -8,12 +8,20 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
         with:
           node-version: lts/*
       - run: npm install
+      - 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 run jslint
+      - run: sudo apt update && sudo apt install -y squid
+      - run: sudo cp test/squid.conf /etc/squid/squid.conf
+      - run: sudo systemctl start squid
       - run: npm test
         env:
           AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
@@ -24,4 +32,12 @@ jobs:
           IBM_TTS_API_KEY: ${{ secrets.IBM_TTS_API_KEY }}
           IBM_TTS_REGION: ${{ secrets.IBM_TTS_REGION }}
           MICROSOFT_API_KEY: ${{ secrets.MICROSOFT_API_KEY }}
-          MICROSOFT_REGION: ${{ secrets.MICROSOFT_REGION }}
+          MICROSOFT_REGION: ${{ secrets.MICROSOFT_REGION }}
+          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+          ELEVENLABS_API_KEY: ${{ secrets.ELEVENLABS_API_KEY }}
+          ELEVENLABS_VOICE_ID: ${{ secrets.ELEVENLABS_VOICE_ID }}
+          ELEVENLABS_MODEL_ID: ${{ secrets.ELEVENLABS_MODEL_ID }}
+          PLAYHT_USER_ID: ${{ secrets.PLAYHT_USER_ID }}
+          PLAYHT_API_KEY: ${{ secrets.PLAYHT_API_KEY }}
+          JAMBONES_HTTP_PROXY_IP: 127.0.0.1
+          JAMBONES_HTTP_PROXY_PORT: 3128

.gitignore

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

.husky/pre-commit

@@ -0,0 +1,3 @@
+#npm audit
+npm run jslint:fix || true
+npm test

README.md

@@ -1,2 +1,3 @@
-# speech-utils
-TTS-related speech utilities for jambonz
+# speech-utils ![CI](https://github.com/jambonz/speech-utils/workflows/CI/badge.svg)
+TTS-related speech utilities for jambonz.
+

config/test.json

@@ -8,6 +8,8 @@
   },
   "redis-auth": {
     "host": "127.0.0.1",
-    "port": 3380
+    "port": 3380,
+    "username": "daveh",
+    "password": "foobarbazzle"
   }
 }

eslint.config.js

@@ -0,0 +1,140 @@
+const promise = require('eslint-plugin-promise');
+const globals = require('globals');
+
+
+module.exports = [
+  {
+    files: ['**/*.js', '*.js'],
+    languageOptions: {
+
+      ecmaVersion: 2020,
+      parserOptions: {
+        'node': true,
+        'es6': true,
+        ecmaFeatures: {
+          jsx: false,
+          modules: false,
+        }
+      },
+      sourceType: 'module',
+      globals: {
+        ...globals.node,
+        'DTRACE_HTTP_CLIENT_REQUEST': false,
+        'LTTNG_HTTP_CLIENT_REQUEST': false,
+        'COUNTER_HTTP_CLIENT_REQUEST': false,
+        'DTRACE_HTTP_CLIENT_RESPONSE': false,
+        'LTTNG_HTTP_CLIENT_RESPONSE': false,
+        'COUNTER_HTTP_CLIENT_RESPONSE': false,
+        'DTRACE_HTTP_SERVER_REQUEST': false,
+        'LTTNG_HTTP_SERVER_REQUEST': false,
+        'COUNTER_HTTP_SERVER_REQUEST': false,
+        'DTRACE_HTTP_SERVER_RESPONSE': false,
+        'LTTNG_HTTP_SERVER_RESPONSE': false,
+        'COUNTER_HTTP_SERVER_RESPONSE': false,
+        'DTRACE_NET_STREAM_END': false,
+        'LTTNG_NET_STREAM_END': false,
+        'COUNTER_NET_SERVER_CONNECTION_CLOSE': false,
+        'DTRACE_NET_SERVER_CONNECTION': false,
+        'LTTNG_NET_SERVER_CONNECTION': false,
+        'COUNTER_NET_SERVER_CONNECTION': false
+      },
+
+    },
+    'plugins': {
+      promise
+    },
+    'rules': {
+      'promise/always-return': 'error',
+      'promise/no-return-wrap': 'error',
+      'promise/param-names': 'error',
+      'promise/catch-or-return': 'error',
+      'promise/no-native': 'off',
+      'promise/no-nesting': 'warn',
+      'promise/no-promise-in-callback': 'warn',
+      'promise/no-callback-in-promise': 'warn',
+      'promise/no-return-in-finally': 'warn',
+
+      // Possible Errors
+      // http://eslint.org/docs/rules/#possible-errors
+      'comma-dangle': [2, 'only-multiline'],
+      'no-control-regex': 2,
+      'no-debugger': 2,
+      'no-dupe-args': 2,
+      'no-dupe-keys': 2,
+      'no-duplicate-case': 2,
+      'no-empty-character-class': 2,
+      'no-ex-assign': 2,
+      'no-extra-boolean-cast': 2,
+      'no-extra-parens': [2, 'functions'],
+      'no-extra-semi': 2,
+      'no-func-assign': 2,
+      'no-invalid-regexp': 2,
+      'no-irregular-whitespace': 2,
+      'no-negated-in-lhs': 2,
+      'no-obj-calls': 2,
+      'no-proto': 2,
+      'no-unexpected-multiline': 2,
+      'no-unreachable': 2,
+      'use-isnan': 2,
+      'valid-typeof': 2,
+
+      // Best Practices
+      // http://eslint.org/docs/rules/#best-practices
+      'no-fallthrough': 2,
+      'no-octal': 2,
+      'no-redeclare': 2,
+      'no-self-assign': 2,
+      'no-unused-labels': 2,
+
+      // Strict Mode
+      // http://eslint.org/docs/rules/#strict-mode
+      'strict': [2, 'never'],
+
+      // Variables
+      // http://eslint.org/docs/rules/#variables
+      'no-delete-var': 2,
+      'no-undef': 2,
+      'no-unused-vars': [2, { 'args': 'none' }],
+
+      // Node.js and CommonJS
+      // http://eslint.org/docs/rules/#nodejs-and-commonjs
+      'no-mixed-requires': 2,
+      'no-new-require': 2,
+      'no-path-concat': 2,
+      'no-restricted-modules': [2, 'sys', '_linklist'],
+
+      // Stylistic Issues
+      // http://eslint.org/docs/rules/#stylistic-issues
+      'comma-spacing': 2,
+      'eol-last': 2,
+      'indent': [2, 2, { 'SwitchCase': 1 }],
+      'keyword-spacing': 2,
+      'max-len': [2, 120, 2],
+      'new-parens': 2,
+      'no-mixed-spaces-and-tabs': 2,
+      'no-multiple-empty-lines': [2, { 'max': 2 }],
+      'no-trailing-spaces': [2, { 'skipBlankLines': false }],
+      'quotes': [2, 'single', 'avoid-escape'],
+      'semi': 2,
+      'space-before-blocks': [2, 'always'],
+      'space-before-function-paren': [2, 'never'],
+      'space-in-parens': [2, 'never'],
+      'space-infix-ops': 2,
+      'space-unary-ops': 2,
+
+      // ECMAScript 6
+      // http://eslint.org/docs/rules/#ecmascript-6
+      'arrow-parens': [2, 'always'],
+      'arrow-spacing': [2, { 'before': true, 'after': true }],
+      'constructor-super': 2,
+      'no-class-assign': 2,
+      'no-confusing-arrow': 2,
+      'no-const-assign': 2,
+      'no-dupe-class-members': 2,
+      'no-new-symbol': 2,
+      'no-this-before-super': 2,
+      'prefer-const': 2
+    },
+    'ignores': []
+  }
+];

index.js

@@ -1,32 +1,23 @@
 const {noopLogger} = require('./lib/utils');
-const promisify = require('@jambonz/promisify-redis');
-const redis = promisify(require('redis'));
 
 module.exports = (opts, logger) => {
-  const {host = '127.0.0.1', port = 6379, tls = false} = opts;
   logger = logger || noopLogger;
-
-  const url = process.env.JAMBONES_REDIS_USERNAME && process.env.JAMBONES_REDIS_PASSWORD ?
-    `${process.env.JAMBONES_REDIS_USERNAME}:${process.env.JAMBONES_REDIS_PASSWORD}@${host}:${port}` :
-    `${host}:${port}`;
-  const client = redis.createClient(tls ? `rediss://${url}` : `redis://${url}`);
-  ['ready', 'connect', 'reconnecting', 'error', 'end', 'warning']
-    .forEach((event) => {
-      client.on(event, (...args) => {
-        if ('error' === event) {
-          if (process.env.NODE_ENV === 'test' && args[0]?.code === 'ECONNREFUSED') return;
-          logger.error({...args}, '@jambonz/realtimedb-helpers - redis error');
-        }
-        else logger.debug({args}, `redis event ${event}`);
-      });
-    });
+  const {
+    client,
+    createHash,
+    retrieveHash
+  } = require('@jambonz/realtimedb-helpers')(opts, logger);
 
   return {
     client,
+    getTtsSize: require('./lib/get-tts-size').bind(null, client, logger),
     purgeTtsCache: require('./lib/purge-tts-cache').bind(null, client, logger),
-    synthAudio: require('./lib/synth-audio').bind(null, client, logger),
+    addFileToCache: require('./lib/add-file-to-cache').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),
-    getTtsVoices: require('./lib/get-tts-voices').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, createHash, retrieveHash, logger),
   };
 };

lib/add-file-to-cache.js

@@ -0,0 +1,60 @@
+const fs = require('fs/promises');
+const {noopLogger, makeSynthKey} = require('./utils');
+const {JAMBONES_TTS_CACHE_DURATION_MINS} = require('./config');
+const EXPIRES = JAMBONES_TTS_CACHE_DURATION_MINS;
+
+function getExtensionAndSampleRate(path) {
+  const match = path.match(/\.([^.]*)$/);
+  if (!match) {
+    //default should be wav file.
+    return ['wav', 8000];
+  }
+
+  const extension = match[1];
+  const sampleRateMap = {
+    r8: 8000,
+    r16: 16000,
+    r24: 24000,
+    r44: 44100,
+    r48: 48000,
+    r96: 96000,
+  };
+
+  const sampleRate = sampleRateMap[extension] || 8000;
+  return [extension, sampleRate];
+}
+
+async function addFileToCache(client, logger, path,
+  {account_sid, vendor, language, voice, deploymentId, engine, model, text}) {
+  let key;
+  logger = logger || noopLogger;
+
+  try {
+    key = makeSynthKey({
+      account_sid,
+      vendor,
+      language: language || '',
+      voice: voice || deploymentId,
+      engine,
+      model,
+      text,
+    });
+    const [extension, sampleRate] = getExtensionAndSampleRate(path);
+    const audioBuffer = await fs.readFile(path);
+    await client.setex(key, EXPIRES, JSON.stringify(
+      {
+        audioContent: audioBuffer.toString('base64'),
+        extension,
+        sampleRate
+      }
+    ));
+  } catch (err) {
+    logger.error(err, 'addFileToCache: Error');
+    return;
+  }
+
+  logger.debug(`addFileToCache: added ${path} to cache with key ${key}`);
+  return key;
+}
+
+module.exports = addFileToCache;

lib/config.js

@@ -0,0 +1,25 @@
+const JAMBONES_TTS_TRIM_SILENCE = process.env.JAMBONES_TTS_TRIM_SILENCE;
+const JAMBONES_DISABLE_TTS_STREAMING = process.env.JAMBONES_DISABLE_TTS_STREAMING;
+const JAMBONES_DISABLE_AZURE_TTS_STREAMING = process.env.JAMBONES_DISABLE_AZURE_TTS_STREAMING;
+const JAMBONES_EAGERLY_PRE_CACHE_AUDIO = process.env.JAMBONES_EAGERLY_PRE_CACHE_AUDIO;
+
+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_DISABLE_AZURE_TTS_STREAMING,
+  JAMBONES_HTTP_PROXY_IP,
+  JAMBONES_HTTP_PROXY_PORT,
+  JAMBONES_TTS_CACHE_DURATION_MINS,
+  JAMBONES_EAGERLY_PRE_CACHE_AUDIO,
+  TMP_FOLDER,
+  HTTP_TIMEOUT
+};

lib/get-aws-sts-token.js

@@ -0,0 +1,78 @@
+const { STSClient, GetSessionTokenCommand, AssumeRoleCommand } = require('@aws-sdk/client-sts');
+const {makeAwsKey, noopLogger} = require('./utils');
+const debug = require('debug')('jambonz:speech-utils');
+const EXPIRY = process.env.AWS_STS_SESSION_DURATION || 3600;
+// by default reset aws session before expiry time 10 mins
+const CACHE_EXPIRY = process.env.AWS_STS_SESSION_RESET_EXPIRY || (EXPIRY - 600);
+
+async function getAwsAuthToken(
+  logger, createHash, retrieveHash,
+  {speech_credential_sid, accessKeyId, secretAccessKey, region, roleArn}) {
+  logger = logger || noopLogger;
+  try {
+    // if incase instance profile is used, speech_credential_sid will be used as key to lookup cache
+    const key = makeAwsKey(roleArn || accessKeyId || speech_credential_sid);
+    const obj = await retrieveHash(key);
+    if (obj) return {...obj, servedFromCache: true};
+    /* access token not found in cache, so generate it using STS */
+    let data;
+    let expiry = CACHE_EXPIRY;
+    if (roleArn) {
+      const stsClient = new STSClient({ region });
+      const roleToAssume = { RoleArn: roleArn, RoleSessionName: 'Jambonz_Speech', DurationSeconds: EXPIRY};
+      const command = new AssumeRoleCommand(roleToAssume);
+
+      data = await stsClient.send(command);
+    } else if (accessKeyId) {
+      const stsClient = new STSClient({
+        region,
+        credentials: {
+          accessKeyId,
+          secretAccessKey,
+        }
+      });
+      const command = new GetSessionTokenCommand({DurationSeconds: EXPIRY});
+      data = await stsClient.send(command);
+    } else {
+      // instance profile is used.
+      const stsClient = new STSClient({ region });
+      const cred = await stsClient.config.credentials();
+      // method in the AWS SDK automatically fetches credentials using the default credential
+      // provider chain. If the credentials come from an instance profile or an environment
+      // variable, their expiration is controlled by AWS and not explicitly by our code.
+      if (cred && cred.expiration) {
+        const currentTime = new Date();
+        const expiryTime = new Date(cred.expiration);
+        const remainingTimeInSeconds = Math.round((expiryTime - currentTime) / 1000);
+        expiry = remainingTimeInSeconds;
+      }
+      data = {
+        Credentials: {
+          AccessKeyId: cred.accessKeyId,
+          SecretAccessKey: cred.secretAccessKey,
+          SessionToken: cred.sessionToken
+        }
+      };
+    }
+
+    const credentials = {
+      accessKeyId: data.Credentials.AccessKeyId,
+      secretAccessKey: data.Credentials.SecretAccessKey,
+      sessionToken: data.Credentials.SessionToken,
+      securityToken: data.Credentials.SessionToken
+    };
+    // Only cache if expiry is good
+    if (expiry > 0) {
+      createHash(key, credentials, expiry)
+        .catch((err) => logger.error(err, `Error saving hash for key ${key}`));
+    }
+
+    return {...credentials, servedFromCache: false};
+  } catch (err) {
+    debug(err, 'getAwsAuthToken: Error retrieving AWS auth token');
+    logger.error(err, 'getAwsAuthToken: Error retrieving AWS auth token');
+    throw err;
+  }
+}
+
+module.exports = getAwsAuthToken;

lib/get-ibm-access-token.js

@@ -2,14 +2,14 @@ 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;
   try {
     const key = makeIbmKey(apiKey);
-    const access_token = await client.getAsync(key);
+    const access_token = await client.get(key);
     if (access_token) return {access_token, servedFromCache: true};
 
     /* access token not found in cache, so fetch it from Ibm */

lib/get-nuance-access-token.js

@@ -2,14 +2,14 @@ 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;
   try {
     const key = makeNuanceKey(clientId, secret, scope);
-    const access_token = await client.getAsync(key);
+    const access_token = await client.get(key);
     if (access_token) return {access_token, servedFromCache: true};
 
     /* access token not found in cache, so fetch it from Nuance */

lib/get-tts-size.js

@@ -0,0 +1,11 @@
+async function getTtsSize(client, logger, pattern = null) {
+  let keys;
+  if (pattern) {
+    keys = await client.keys(pattern);
+  } else {
+    keys = await client.keys('tts:*');
+  }
+  return keys.length;
+}
+
+module.exports = getTtsSize;

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,17 +92,32 @@ 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 command = new DescribeVoicesCommand({LanguageCode: 'en-US'});
+    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,
+          {
+            region,
+            roleArn
+          }),
+      });
+    } else {
+      client = new PollyClient({region});
+    }
+    const command = new DescribeVoicesCommand({});
     const response = await client.send(command);
     return response;
   } catch (err) {
@@ -106,6 +126,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 +162,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 +177,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/purge-tts-cache.js

@@ -12,19 +12,19 @@ const debug = require('debug')('jambonz:realtimedb-helpers');
  * @returns {object} result - {error, purgedCount}
  */
 async function purgeTtsCache(client, logger, {all, account_sid, vendor,
-  language, voice, deploymentId, engine, text} = {all: true}) {
+  language, voice, deploymentId, engine, model, text} = {all: true}) {
   logger = logger || noopLogger;
 
   let purgedCount = 0, error;
 
   try {
     if (all) {
-      const keys = await client.keysAsync('tts:*');
-      purgedCount = await client.delAsync(keys);
+      const keys = await client.keys('tts:*');
+      purgedCount = await client.del(keys);
 
     } else if (account_sid && !vendor && !language && !voice && !engine && !text) {
-      const keys = await client.keysAsync(`tts:${account_sid}:*`);
-      purgedCount = await client.delAsync(keys);
+      const keys = await client.keys(`tts:${account_sid}:*`);
+      purgedCount = await client.del(keys);
     }
     else {
       const key = makeSynthKey({
@@ -33,9 +33,10 @@ async function purgeTtsCache(client, logger, {all, account_sid, vendor,
         language: language || '',
         voice: voice || deploymentId,
         engine,
+        model,
         text,
       });
-      purgedCount = await client.delAsync(key);
+      purgedCount = await client.del(key);
       if (purgedCount === 0) error = 'Specified item not found';
     }
 

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 { TMP_FOLDER, HTTP_TIMEOUT } = require('./config');
 
 const debug = require('debug')('jambonz:realtimedb-helpers');
 /**
@@ -16,12 +16,28 @@ const debug = require('debug')('jambonz:realtimedb-helpers');
  */
 //const nuanceClientMap = new Map();
 
-function makeSynthKey({account_sid = '', vendor, language, voice, engine = '', text}) {
+function makeSynthKey({
+  account_sid = '',
+  vendor,
+  language,
+  voice,
+  engine = '',
+  model = '',
+  text
+}) {
   const hash = crypto.createHash('sha1');
-  hash.update(`${language}:${vendor}:${voice}:${engine}:${text}`);
-  return `tts${account_sid ? (':' + account_sid) : ''}:${hash.digest('hex')}`;
+  hash.update(`${language}:${vendor}:${voice}:${engine}:${model}:${text}`);
+  const hexHashKey = hash.digest('hex');
+  const accountKey = account_sid ? `:${account_sid}` : '';
+  const key = `tts${accountKey}:${hexHashKey}`;
+  return key;
 }
 
+function makeFilePath({key, salt = '', extension}) {
+  return `${TMP_FOLDER}/${key.replace('tts:', `tts-${salt}`)}.${extension}`;
+}
+
+
 const noopLogger = {
   info: () => {},
   debug: () => {},
@@ -43,6 +59,23 @@ function makeIbmKey(apiKey) {
   return `ibm:${hash.digest('hex')}`;
 }
 
+function makeAwsKey(awsAccessKeyId) {
+  const hash = crypto.createHash('sha1');
+  hash.update(awsAccessKeyId);
+  return `aws:${hash.digest('hex')}`;
+}
+
+function makePlayhtKey(apiKey) {
+  const hash = crypto.createHash('sha1');
+  hash.update(apiKey);
+  return `playht:${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}`);
@@ -106,16 +139,19 @@ const createRivaClient = async(rivaUri) => {
   return client;
 };
 
-
 module.exports = {
   makeSynthKey,
   makeNuanceKey,
   makeIbmKey,
+  makePlayhtKey,
+  makeAwsKey,
+  makeVerbioKey,
   getNuanceAccessToken,
   createNuanceClient,
   createKryptonClient,
   createRivaClient,
   makeBasicAuthHeader,
   NUANCE_AUTH_ENDPOINT,
-  noopLogger
+  noopLogger,
+  makeFilePath
 };

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jambonz/speech-utils",
-  "version": "0.0.12",
+  "version": "0.2.8",
   "description": "TTS-related speech utilities for jambonz",
   "main": "index.js",
   "author": "Dave Horton",
@@ -9,10 +9,12 @@
     "test": "test"
   },
   "scripts": {
-    "test": "NODE_ENV=test JAMBONES_REDIS_USERNAME=daveh JAMBONES_REDIS_PASSWORD=foobarbazzle node test/ ",
+    "test": "NODE_ENV=test node test/ ",
     "coverage": "nyc --reporter html --report-dir ./coverage npm run test",
     "jslint": "eslint index.js lib",
-    "build": "./build_stubs.sh"
+    "jslint:fix": "npm run jslint --fix",
+    "build": "./build_stubs.sh",
+    "prepare": "husky"
   },
   "repository": {
     "type": "git",
@@ -24,25 +26,28 @@
   },
   "homepage": "https://github.com/jambonz/speech-utils#readme",
   "dependencies": {
-    "@aws-sdk/client-polly": "^3.303.0",
-    "@google-cloud/text-to-speech": "^4.2.1",
-    "@grpc/grpc-js": "^1.8.13",
-    "@jambonz/promisify-redis": "^0.0.6",
+    "@aws-sdk/client-polly": "^3.496.0",
+    "@aws-sdk/client-sts": "^3.496.0",
+    "@cartesia/cartesia-js": "^2.1.0",
+    "@google-cloud/text-to-speech": "^5.5.0",
+    "@grpc/grpc-js": "^1.9.14",
+    "@jambonz/realtimedb-helpers": "^0.8.7",
     "bent": "^7.3.12",
     "debug": "^4.3.4",
-    "form-urlencoded": "^6.1.0",
+    "form-urlencoded": "^6.1.4",
     "google-protobuf": "^3.21.2",
     "ibm-watson": "^8.0.0",
-    "microsoft-cognitiveservices-speech-sdk": "^1.26.0",
-    "redis": "^3.1.2",
-    "undici": "^5.21.0"
+    "microsoft-cognitiveservices-speech-sdk": "1.38.0",
+    "openai": "^4.25.0",
+    "undici": "^7.5.0"
   },
   "devDependencies": {
-    "config": "^3.3.9",
-    "eslint": "^8.33.0",
-    "eslint-plugin-promise": "^6.1.1",
+    "config": "^3.3.11",
+    "eslint": "^9.3.0",
+    "eslint-plugin-promise": "^6.2.0",
+    "husky": "^9.0.11",
     "nyc": "^15.1.0",
-    "pino": "^7.2.0",
-    "tape": "^5.1.1"
+    "pino": "^9.1.0",
+    "tape": "^5.7.5"
   }
 }

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/aws.js

@@ -0,0 +1,48 @@
+const test = require('tape').test ;
+const config = require('config');
+const opts = config.get('redis');
+const logger = require('pino')({level: 'error'});
+process.on('unhandledRejection', (reason, p) => {
+  console.log('Unhandled Rejection at: Promise', p, 'reason:', reason);
+});
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+test('AWS - create and cache auth token', async(t) => {
+  const fn = require('..');
+  const {client, getAwsAuthToken} = fn(opts, logger);
+
+  if (!process.env.AWS_ACCESS_KEY_ID || !process.env.AWS_SECRET_ACCESS_KEY || !process.env.AWS_REGION) {
+      t.pass('skipping AWS auth token tests since no AWS credentials provided');
+      t.end();
+      client.quit();
+      return;
+  }
+  try {
+    let obj = await getAwsAuthToken({
+      accessKeyId: process.env.AWS_ACCESS_KEY_ID, 
+      secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+      region: process.env.AWS_REGION
+    });
+    //console.log({obj}, 'received auth token from AWS');
+    t.ok(obj.securityToken && !obj.servedFromCache, 'successfullY generated auth token from AWS');
+
+    await sleep(250);
+    obj = await getAwsAuthToken({
+      accessKeyId: process.env.AWS_ACCESS_KEY_ID, 
+      secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+      region: process.env.AWS_REGION
+    });
+    //console.log({obj}, 'received auth token from AWS - second request');
+    t.ok(obj.securityToken && obj.servedFromCache, 'successfully received access token from cache');
+ 
+    await client.flushall();
+    t.end();
+  }
+  catch (err) {
+    console.error(err);
+    t.end(err);
+  }
+  client.quit();
+});
+

test/ibm.js

@@ -31,7 +31,7 @@ test('IBM - create access key', async(t) => {
     //console.log({obj}, 'received access token from IBM - second request');
     t.ok(obj.access_token && obj.servedFromCache, 'successfully received access token from cache');
  
-    await client.flushallAsync();
+    await client.flushall();
     t.end();
   }
   catch (err) {
@@ -65,7 +65,7 @@ test('IBM - retrieve tts voices test', async(t) => {
     t.ok(voices.length > 0 && voices[0].language, 
       `GetVoices: successfully retrieved ${voices.length} voices from IBM`);
  
-    await client.flushallAsync();
+    await client.flushall();
 
     t.end();
 

test/index.js

@@ -1,4 +1,7 @@
 require('./docker_start');
 require('./synth');
 require('./list-voices');
+require('./aws');
+require('./ibm');
+require('./nuance');
 require('./docker_stop');

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);
@@ -31,7 +57,7 @@ test('IBM - create access key', async(t) => {
     //console.log({obj}, 'received access token from IBM - second request');
     t.ok(obj.access_token && obj.servedFromCache, 'successfully received access token from cache');
  
-    await client.flushallAsync();
+    await client.flushall();
     t.end();
   }
   catch (err) {
@@ -65,7 +91,7 @@ test('IBM - retrieve tts voices test', async(t) => {
     t.ok(voices.length > 0 && voices[0].language, 
       `GetVoices: successfully retrieved ${voices.length} voices from IBM`);
  
-    await client.flushallAsync();
+    await client.flushall();
 
     t.end();
 
@@ -99,7 +125,7 @@ test('Nuance hosted tests', async(t) => {
     t.ok(voices.length > 0 && voices[0].language, 
       `GetVoices: successfully retrieved ${voices.length} voices from Nuance`);
 
-    await client.flushallAsync();
+    await client.flushall();
 
     t.end();
 
@@ -132,7 +158,7 @@ test('Nuance on-prem tests', async(t) => {
     t.ok(voices.length > 0 && voices[0].language, 
       `GetVoices: successfully retrieved ${voices.length} voices from Nuance`);
 
-    await client.flushallAsync();
+    await client.flushall();
 
     t.end();
 
@@ -162,7 +188,7 @@ test('Google tests', async(t) => {
     let result = await getTtsVoices(opts);
     t.ok(result[0].voices.length > 0, `GetVoices: successfully retrieved ${result[0].voices.length} voices from Google`);
 
-    await client.flushallAsync();
+    await client.flushall();
 
     t.end();
   }
@@ -193,7 +219,7 @@ test('AWS tests', async(t) => {
     let result = await getTtsVoices(opts);
     t.ok(result?.Voices?.length > 0, `GetVoices: successfully retrieved ${result.Voices.length} voices from AWS`);
 
-    await client.flushallAsync();
+    await client.flushall();
 
     t.end();
   }

test/nuance.js

@@ -34,7 +34,7 @@ test('Nuance hosted tests', async(t) => {
     t.ok(voices.length > 0 && voices[0].language, 
       `GetVoices: successfully retrieved ${voices.length} voices from Nuance`);
 
-    await client.flushallAsync();
+    await client.flushall();
 
     t.end();
 
@@ -67,7 +67,7 @@ test('Nuance on-prem tests', async(t) => {
     t.ok(voices.length > 0 && voices[0].language, 
       `GetVoices: successfully retrieved ${voices.length} voices from Nuance`);
 
-    await client.flushallAsync();
+    await client.flushall();
 
     t.end();
 

test/squid.conf

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

test/synth.js

@@ -5,7 +5,7 @@ const fs = require('fs');
 const {makeSynthKey} = require('../lib/utils');
 const logger = require('pino')();
 const bent = require('bent');
-const getJSON = bent('json')
+const getJSON = bent('json');
 
 process.on('unhandledRejection', (reason, p) => {
   console.log('Unhandled Rejection at: Promise', p, 'reason:', reason);
@@ -20,7 +20,7 @@ const stats = {
 
 test('Google speech synth tests', async(t) => {
   const fn = require('..');
-  const {synthAudio, client} = fn(opts, logger);
+  const {synthAudio, addFileToCache, client} = fn(opts, logger);
 
   if (!process.env.GCP_FILE && !process.env.GCP_JSON_KEY) {
     t.pass('skipping google speech synth tests since neither GCP_FILE nor GCP_JSON_KEY provided');
@@ -38,7 +38,7 @@ test('Google speech synth tests', async(t) => {
         },
       },
       language: 'en-GB',
-      gender: 'MALE',
+      gender: 'FEMALE',
       text: 'This is a test.  This is only a test',
       salt: 'foo.bar',
     });
@@ -53,11 +53,19 @@ test('Google speech synth tests', async(t) => {
         },
       },
       language: 'en-GB',
-      gender: 'MALE',
+      gender: 'FEMALE',
       text: 'This is a test.  This is only a test',
     });
     t.ok(opts.servedFromCache, `successfully retrieved cached google audio from ${opts.filePath}`);
 
+    const success = await addFileToCache(opts.filePath, {
+      vendor: 'google',
+      language: 'en-GB',
+      gender: 'FEMALE',
+      text: 'This is a test.  This is only a test'
+    });
+    t.ok(success, `successfully added ${opts.filePath} to cache`);
+
     opts = await synthAudio(stats, {
       vendor: 'google',
       credentials: {
@@ -68,7 +76,7 @@ test('Google speech synth tests', async(t) => {
       },
       disableTtsCache: true,
       language: 'en-GB',
-      gender: 'MALE',
+      gender: 'FEMALE',
       text: 'This is a test.  This is only a test',
     });
     t.ok(!opts.servedFromCache, `successfully synthesized google audio regardless of current cache to ${opts.filePath}`);
@@ -79,6 +87,85 @@ test('Google speech synth tests', async(t) => {
   client.quit();
 });
 
+test('Google speech Custom voice synth tests', async(t) => {
+  const fn = require('..');
+  const {synthAudio, client} = fn(opts, logger);
+
+  if (!process.env.GCP_CUSTOM_VOICE_FILE &&
+    !process.env.GCP_CUSTOM_VOICE_JSON_KEY ||
+    !process.env.GCP_CUSTOM_VOICE_MODEL) {
+    t.pass(`skipping google speech synth tests since neither 
+GCP_CUSTOM_VOICE_FILE nor GCP_CUSTOM_VOICE_JSON_KEY provided, GCP_CUSTOM_VOICE_MODEL is not provided`);
+    return t.end();
+  }
+  try {
+    const str = process.env.GCP_CUSTOM_VOICE_JSON_KEY || fs.readFileSync(process.env.GCP_CUSTOM_VOICE_FILE);
+    const creds = JSON.parse(str);
+    const opts = await synthAudio(stats, {
+      vendor: 'google',
+      credentials: {
+        credentials: {
+          client_email: creds.client_email,
+          private_key: creds.private_key,
+        },
+      },
+      language: 'en-AU',
+      text: 'This is a test.  This is only a test',
+      voice: {
+        reportedUsage: 'REALTIME',
+        model: process.env.GCP_CUSTOM_VOICE_MODEL
+      }
+    });
+    t.ok(!opts.servedFromCache, `successfully synthesized google custom voice audio to ${opts.filePath}`);
+  } catch (err) {
+    console.error(err);
+    t.end(err);
+  }
+  client.quit();
+});
+
+test('Google speech voice cloning synth tests', async(t) => {
+  const fn = require('..');
+  const {synthAudio, client} = fn(opts, logger);
+
+  if (!process.env.GCP_CUSTOM_VOICE_FILE &&
+    !process.env.GCP_CUSTOM_VOICE_JSON_KEY ||
+    !process.env.GCP_VOICE_CLONING_FILE &&
+    !process.env.GCP_VOICE_CLONING_JSON_KEY) {
+    t.pass(`skipping google speech synth tests since neither 
+GCP_CUSTOM_VOICE_FILE nor GCP_CUSTOM_VOICE_JSON_KEY provided,
+GCP_VOICE_CLONING_FILE nor GCP_VOICE_CLONING_JSON_KEY is not provided`);
+    return t.end();
+  }
+  try {
+    const googleKey = process.env.GCP_CUSTOM_VOICE_JSON_KEY ||
+      fs.readFileSync(process.env.GCP_CUSTOM_VOICE_FILE);
+    const voice_cloning_key = process.env.GCP_VOICE_CLONING_JSON_KEY ||
+      fs.readFileSync(process.env.GCP_VOICE_CLONING_FILE).toString();
+    const creds = JSON.parse(googleKey);
+    const opts = await synthAudio(stats, {
+      vendor: 'google',
+      credentials: {
+        credentials: {
+          client_email: creds.client_email,
+          private_key: creds.private_key,
+          project_id: creds.project_id
+        },
+      },
+      language: 'en-US',
+      text: 'This is a test. This is only a test. This is a test. This is only a test. This is a test. This is only a test',
+      voice: {
+        voice_cloning_key
+      }
+    });
+    t.ok(!opts.servedFromCache, `successfully synthesized google voice cloning audio to ${opts.filePath}`);
+  } catch (err) {
+    console.error(err);
+    t.end(err);
+  }
+  client.quit();
+});
+
 test('AWS speech synth tests', async(t) => {
   const fn = require('..');
   const {synthAudio, client} = fn(opts, logger);
@@ -120,6 +207,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);
@@ -146,9 +260,12 @@ test('Azure speech synth tests', async(t) => {
       language: 'en-US',
       voice: 'en-US-ChristopherNeural',
       text: longText,
+      renderForCaching: true
     });
     t.ok(!opts.servedFromCache, `successfully synthesized microsoft audio to ${opts.filePath}`);
-
+    if (process.env.JAMBONES_HTTP_PROXY_IP && process.env.JAMBONES_HTTP_PROXY_PORT) {
+      t.pass('successfully used proxy to reach microsoft tts service');
+    }
 
     opts = await synthAudio(stats, {
       vendor: 'microsoft',
@@ -159,6 +276,7 @@ test('Azure speech synth tests', async(t) => {
       language: 'en-US',
       voice: 'en-US-ChristopherNeural',
       text: longText,
+      renderForCaching: true
     });
     t.ok(opts.servedFromCache, `successfully retrieved microsoft audio from cache ${opts.filePath}`);
   } catch (err) {
@@ -168,6 +286,58 @@ test('Azure speech synth tests', async(t) => {
   client.quit();
 });
 
+test('Azure SSML tests', async(t) => {
+  const fn = require('..');
+  const {synthAudio, client} = fn(opts, logger);
+
+  if (!process.env.MICROSOFT_API_KEY || !process.env.MICROSOFT_REGION) {
+    t.pass('skipping Microsoft speech synth tests since MICROSOFT_API_KEY or MICROSOFT_REGION not provided');
+    return t.end();
+  }
+  try {
+    const text = `<speak version="1.0" xmlns="http://www.w3.org/2001/10/synthesis" xmlns:mstts="https://www.w3.org/2001/mstts" xml:lang="en-US">
+    <voice name="en-US-JennyMultilingualNeural">
+    <mstts:express-as style="cheerful" styledegree="2">That'd be just amazing!
+    </mstts:express-as>
+    </voice>
+    </speak>`;
+
+    let opts = await synthAudio(stats, {
+      vendor: 'microsoft',
+      credentials: {
+        api_key: process.env.MICROSOFT_API_KEY,
+        region: process.env.MICROSOFT_REGION,
+      },
+      language: 'en-US',
+      voice: 'en-US-ChristopherNeural',
+      text,
+      renderForCaching: true
+    });
+    t.ok(!opts.servedFromCache, `successfully synthesized microsoft audio to ${opts.filePath}`);
+    if (process.env.JAMBONES_HTTP_PROXY_IP && process.env.JAMBONES_HTTP_PROXY_PORT) {
+      t.pass('successfully used proxy to reach microsoft tts service');
+    }
+
+    opts = await synthAudio(stats, {
+      vendor: 'microsoft',
+      credentials: {
+        api_key: process.env.MICROSOFT_API_KEY,
+        region: process.env.MICROSOFT_REGION,
+      },
+      language: 'en-US',
+      voice: 'en-US-ChristopherNeural',
+      text,
+      renderForCaching: true
+    });
+    t.ok(opts.servedFromCache, `successfully retrieved microsoft audio from cache ${opts.filePath}`);
+  } catch (err) {
+    console.error(err);
+    t.end(err);
+  }
+  client.quit();
+});
+
+
 test('Azure custom voice speech synth tests', async(t) => {
   const fn = require('..');
   const {synthAudio, client} = fn(opts, logger);
@@ -189,6 +359,7 @@ test('Azure custom voice speech synth tests', async(t) => {
       language: 'en-US',
       voice: process.env.MICROSOFT_CUSTOM_VOICE,
       text,
+      renderForCaching: true
     });
     t.ok(!opts.servedFromCache, `successfully synthesized microsoft audio to ${opts.filePath}`);
 
@@ -203,6 +374,7 @@ test('Azure custom voice speech synth tests', async(t) => {
       language: 'en-US',
       voice: process.env.MICROSOFT_CUSTOM_VOICE,
       text,
+      renderForCaching: true
     });
     t.ok(opts.servedFromCache, `successfully retrieved microsoft custom voice audio from cache ${opts.filePath}`);
   } catch (err) {
@@ -300,7 +472,7 @@ test('Nvidia speech synth tests', async(t) => {
     let opts = await synthAudio(stats, {
       vendor: 'nvidia',
       credentials: {
-        riva_uri: process.env.RIVA_URI,
+        riva_server_uri: process.env.RIVA_URI,
       },
       language: 'en-US',
       voice: 'English-US.Female-1',
@@ -311,7 +483,7 @@ test('Nvidia speech synth tests', async(t) => {
     opts = await synthAudio(stats, {
       vendor: 'nvidia',
       credentials: {
-        riva_uri: process.env.RIVA_URI,
+        riva_server_uri: process.env.RIVA_URI,
       },
       language: 'en-US',
       voice: 'English-US.Female-1',
@@ -382,6 +554,7 @@ test('Custom Vendor speech synth tests', async(t) => {
       text: 'This is a test.  This is only a test',
     });
     t.ok(!opts.servedFromCache, `successfully synthesized custom vendor audio to ${opts.filePath}`);
+    t.ok(opts.filePath.endsWith('wav'), 'audio is cached as wav file');
     let obj = await getJSON(`http://127.0.0.1:3100/lastRequest/somethingnew`);
     t.ok(obj.headers.Authorization == 'Bearer some_jwt_token', 'Custom Vendor Authentication Header is correct');
     t.ok(obj.body.language == 'en-US', 'Custom Vendor Language is correct');
@@ -389,6 +562,21 @@ test('Custom Vendor speech synth tests', async(t) => {
     t.ok(obj.body.type == 'text', 'Custom Vendor type is correct');
     t.ok(obj.body.text == 'This is a test.  This is only a test', 'Custom Vendor text is correct');
 
+    // Checking if cache is stored with wav format
+    opts = await synthAudio(stats, {
+      vendor: 'custom:somethingnew',
+      credentials: {
+        use_for_tts: 1,
+        custom_tts_url: "http://127.0.0.1:3100/somethingnew",
+        auth_token: 'some_jwt_token'
+      },
+      language: 'en-US',
+      voice: 'English-US.Female-1',
+      text: 'This is a test.  This is only a test',
+    });
+    t.ok(opts.servedFromCache, `successfully get custom vendor cached audio to ${opts.filePath}`);
+    t.ok(opts.filePath.endsWith('wav'), 'audio is cached as wav file');
+
     opts = await synthAudio(stats, {
       vendor: 'custom:somethingnew2',
       credentials: {
@@ -411,20 +599,303 @@ test('Custom Vendor speech synth tests', async(t) => {
   client.quit();
 });
 
+test('Elevenlabs speech synth tests', async(t) => {
+  const fn = require('..');
+  const {synthAudio, client} = fn(opts, logger);
+
+  if (!process.env.ELEVENLABS_API_KEY || !process.env.ELEVENLABS_VOICE_ID || !process.env.ELEVENLABS_MODEL_ID) {
+    t.pass('skipping ElevenLabs speech synth tests since ELEVENLABS_API_KEY or ELEVENLABS_VOICE_ID or ELEVENLABS_MODEL_ID not provided');
+    return t.end();
+  }
+  const text = 'Hi there and welcome to jambones!';
+  try {
+    let opts = await synthAudio(stats, {
+      vendor: 'elevenlabs',
+      credentials: {
+        api_key: process.env.ELEVENLABS_API_KEY,
+        model_id: process.env.ELEVENLABS_MODEL_ID,
+        options: JSON.stringify({
+          optimize_streaming_latency: 1,
+          voice_settings: {
+            similarity_boost: 1,
+            stability: 0.8,
+            style: 1,
+            use_speaker_boost: true
+          }
+        })
+      },
+      language: 'en-US',
+      voice: process.env.ELEVENLABS_VOICE_ID,
+      text,
+    });
+    t.ok(!opts.servedFromCache, `successfully synthesized eleven audio to ${opts.filePath}`);
+
+  } catch (err) {
+    console.error(JSON.stringify(err));
+    t.end(err);
+  }
+  client.quit();
+});
+
+const testPlayHT = async(t, voice_engine) => {
+  const fn = require('..');
+  const {synthAudio, client} = fn(opts, logger);
+
+  if (!process.env.PLAYHT_API_KEY || !process.env.PLAYHT_USER_ID) {
+    t.pass('skipping PlayHT speech synth tests since PLAYHT_API_KEY or PLAYHT_USER_ID is/are not provided');
+    return t.end();
+  }
+  const text = 'Hi there and welcome to jambones! ' + Date.now();
+  try {
+    const opts = await synthAudio(stats, {
+      vendor: 'playht',
+      credentials: {
+        api_key: process.env.PLAYHT_API_KEY,
+        user_id: process.env.PLAYHT_USER_ID,
+        voice_engine,
+        options: JSON.stringify({
+          quality: 'medium',
+          speed: 1,
+          seed: 1,
+          temperature: 1,
+          emotion: 'female_happy',
+          voice_guidance: 3,
+          style_guidance: 20,
+          text_guidance: 1,
+        })
+      },
+      language: 'english',
+      voice: 's3://voice-cloning-zero-shot/d9ff78ba-d016-47f6-b0ef-dd630f59414e/female-cs/manifest.json',
+      text,
+      renderForCaching: true
+    });
+    t.ok(!opts.servedFromCache, `successfully playht eleven audio to ${opts.filePath}`);
+
+  } catch (err) {
+    console.error(JSON.stringify(err));
+    t.end(err);
+  }
+  client.quit();
+};
+
+test('PlayHT speech synth tests', async(t) => {
+  await testPlayHT(t, 'PlayHT2.0-turbo');
+});
+
+test('PlayHT3.0 speech synth tests', async(t) => {
+  await testPlayHT(t, 'Play3.0');
+});
+
+test('Cartesia speech synth tests', async(t) => {
+  const fn = require('..');
+  const {synthAudio, client} = fn(opts, logger);
+
+  if (!process.env.CARTESIA_API_KEY) {
+    t.pass('skipping Cartesia speech synth tests since CARTESIA_API_KEY is not provided');
+    return t.end();
+  }
+  const text = 'Hi there and welcome to jambones! ' + Date.now();
+  try {
+    const opts = await synthAudio(stats, {
+      vendor: 'cartesia',
+      credentials: {
+        api_key: process.env.CARTESIA_API_KEY,
+        model_id: 'sonic-english',
+        options: JSON.stringify({
+          speed: 1,
+          emotion: 'female_happy',
+        })
+      },
+      language: 'en',
+      voice: '694f9389-aac1-45b6-b726-9d9369183238',
+      text,
+      renderForCaching: true
+    });
+    t.ok(!opts.servedFromCache, `successfully playht eleven audio to ${opts.filePath}`);
+
+  } catch (err) {
+    console.error(JSON.stringify(err));
+    t.end(err);
+  }
+  client.quit();
+});
+
+test('rimelabs speech synth tests mist', async(t) => {
+  const fn = require('..');
+  const {synthAudio, client} = fn(opts, logger);
+
+  if (!process.env.RIMELABS_API_KEY) {
+    t.pass('skipping rimelabs speech synth tests since RIMELABS_API_KEY is not provided');
+    return t.end();
+  }
+  const text = 'Hi there and welcome to jambones!';
+  try {
+    const opts = await synthAudio(stats, {
+      vendor: 'rimelabs',
+      credentials: {
+        api_key: process.env.RIMELABS_API_KEY,
+        model_id: 'mist',
+        options: JSON.stringify({
+          speedAlpha: 1.0,
+          reduceLatency: false
+        })
+      },
+      language: 'eng',
+      voice: 'amber',
+      text,
+      renderForCaching: true
+    });
+    t.ok(!opts.servedFromCache, `successfully synthesized rimelabs audio to ${opts.filePath}`);
+
+  } catch (err) {
+    console.error(JSON.stringify(err));
+    t.end(err);
+  }
+  client.quit();
+});
+
+test('rimelabs speech synth tests mistv2', async(t) => {
+  const fn = require('..');
+  const {synthAudio, client} = fn(opts, logger);
+
+  if (!process.env.RIMELABS_API_KEY) {
+    t.pass('skipping rimelabs speech synth tests since RIMELABS_API_KEY is not provided');
+    return t.end();
+  }
+  const text = 'Hi there and welcome to jambones!';
+  try {
+    const opts = await synthAudio(stats, {
+      vendor: 'rimelabs',
+      credentials: {
+        api_key: process.env.RIMELABS_API_KEY,
+        model_id: 'mistv2',
+        options: JSON.stringify({
+          speedAlpha: 1.0,
+          reduceLatency: false
+        })
+      },
+      language: 'spa',
+      voice: 'pablo',
+      text,
+      renderForCaching: true
+    });
+    t.ok(!opts.servedFromCache, `successfully synthesized rimelabs mistv2 audio to ${opts.filePath}`);
+
+  } catch (err) {
+    console.error(JSON.stringify(err));
+    t.end(err);
+  }
+  client.quit();
+});
+
+test('whisper speech synth tests', async(t) => {
+  const fn = require('..');
+  const {synthAudio, client} = fn(opts, logger);
+
+  if (!process.env.OPENAI_API_KEY) {
+    t.pass('skipping OPENAI speech synth tests since OPENAI_API_KEY not provided');
+    return t.end();
+  }
+  const text = 'Hi there and welcome to jambones!';
+  try {
+    let opts = await synthAudio(stats, {
+      vendor: 'whisper',
+      credentials: {
+        api_key: process.env.OPENAI_API_KEY,
+        model_id: 'tts-1'
+      },
+      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}`);
+
+  } catch (err) {
+    console.error(JSON.stringify(err));
+    t.end(err);
+  }
+  client.quit();
+})
+
+test('Deepgram speech synth tests', async(t) => {
+  const fn = require('..');
+  const {synthAudio, client} = fn(opts, logger);
+
+  if (!process.env.DEEPGRAM_API_KEY) {
+    t.pass('skipping Deepgram speech synth tests since DEEPGRAM_API_KEY');
+    return t.end();
+  }
+  const text = 'Hi there and welcome to jambones!';
+  try {
+    let opts = await synthAudio(stats, {
+      vendor: 'deepgram',
+      credentials: {
+        api_key: process.env.DEEPGRAM_API_KEY
+      },
+      model: 'aura-asteria-en',
+      text,
+      renderForCaching: true
+    });
+    t.ok(!opts.servedFromCache, `successfully synthesized deepgram audio to ${opts.filePath}`);
+
+  } catch (err) {
+    console.error(JSON.stringify(err));
+    t.end(err);
+  }
+  client.quit();
+})
+
 test('TTS Cache tests', async(t) => {
   const fn = require('..');
-  const {purgeTtsCache, client} = fn(opts, logger);
+  const {purgeTtsCache, getTtsSize, client} = fn(opts, logger);
 
   try {
     // save some random tts keys to cache
     const minRecords = 8;
     for (const i in Array(minRecords).fill(0)) {
-      await client.setAsync(makeSynthKey({vendor: i, language: i, voice: i, engine: i, text: i}), i);
+      await client.set(makeSynthKey({vendor: i, language: i, voice: i, engine: i, model: i, text: i}), i);
     }
+    const count = await getTtsSize();
+    t.ok(count >= minRecords, 'getTtsSize worked.');
+
     const {purgedCount} = await purgeTtsCache();
     t.ok(purgedCount >= minRecords, `successfully purged at least ${minRecords} tts records from cache`);
 
-    const cached = (await client.keysAsync('tts:*')).length;
+    const cached = (await client.keys('tts:*')).length;
     t.equal(cached, 0, `successfully purged all tts records from cache`);
 
   } catch (err) {
@@ -435,11 +906,11 @@ test('TTS Cache tests', async(t) => {
   try {
     // save some random tts keys to cache
     for (const i in Array(10).fill(0)) {
-      await client.setAsync(makeSynthKey({vendor: i, language: i, voice: i, engine: i, text: i}), i);
+      await client.set(makeSynthKey({vendor: i, language: i, voice: i, engine: i, text: i}), i);
     }
     // save a specific key to tts cache
     const opts = {vendor: 'aws', language: 'en-US', voice: 'MALE', engine: 'Engine', text: 'Hello World!'};
-    await client.setAsync(makeSynthKey(opts), opts.text);
+    await client.set(makeSynthKey(opts), opts.text);
 
     const {purgedCount} = await purgeTtsCache({all: false, ...opts});
     t.ok(purgedCount === 1, `successfully purged one specific tts record from cache`);
@@ -451,13 +922,15 @@ test('TTS Cache tests', async(t) => {
       language: 'non-existing',
       voice: 'non-existing',
     });
-    t.ok(purgedCountWhenErrored === 0, `purged no records when specified key was not found`);
-    t.ok(error, `error returned when specified key was not found`);
+    t.ok(purgedCountWhenErrored === 0, 'purged no records when specified key was not found');
+    t.ok(error, 'error returned when specified key was not found');
 
     // make sure other tts keys are still there
-    const cached = (await client.keysAsync('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');
 
+    process.env.VG_TRIM_TTS_SILENCE = 'true';
+    await client.set(makeSynthKey({ vendor: 'azure' }), 'value');
   } catch (err) {
     console.error(JSON.stringify(err));
     t.end(err);
@@ -471,21 +944,21 @@ test('TTS Cache tests', async(t) => {
     const account_sid = "12412512_cabc_5aff"
     const account_sid2 = "22412512_cabc_5aff"
     for (const i in Array(minRecords).fill(0)) {
-      await client.setAsync(makeSynthKey({account_sid, vendor: i, language: i, voice: i, engine: i, text: i}), i);
+      await client.set(makeSynthKey({account_sid, vendor: i, language: i, voice: i, engine: i, text: i}), i);
     }
     for (const i in Array(minRecords).fill(0)) {
-      await client.setAsync(makeSynthKey({account_sid: account_sid2, vendor: i, language: i, voice: i, engine: i, text: i}), i);
+      await client.set(makeSynthKey({account_sid: account_sid2, vendor: i, language: i, voice: i, engine: i, text: i}), i);
     }
     const {purgedCount} = await purgeTtsCache({account_sid});
     t.equal(purgedCount, minRecords, `successfully purged at least ${minRecords} tts records from cache for account_sid:${account_sid}`);
 
-    let cached = (await client.keysAsync('tts:*')).length;
+    let cached = (await client.keys('tts:*')).length;
     t.equal(cached, minRecords, `successfully purged all tts records from cache for account_sid:${account_sid}`);
 
     const {purgedCount: purgedCount2} = await purgeTtsCache({account_sid: account_sid2});
     t.equal(purgedCount2, minRecords, `successfully purged at least ${minRecords} tts records from cache for account_sid:${account_sid2}`);
 
-    cached = (await client.keysAsync('tts:*')).length;
+    cached = (await client.keys('tts:*')).length;
     t.equal(cached, 0, `successfully purged all tts records from cache`);
 
   } catch (err) {