0.0.19

.eslintignore

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

.eslintrc.json

@@ -0,0 +1,126 @@
+{
+  "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,20 +8,12 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
-      - uses: actions/setup-node@v4
+      - uses: actions/setup-node@v3
         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 }}
@@ -32,12 +24,4 @@ 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,5 +39,3 @@ node_modules
 examples/*
 
 .vscode
-
-.env

.husky/pre-commit

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

README.md

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

eslint.config.js

@@ -1,140 +0,0 @@
-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,23 +1,41 @@
 const {noopLogger} = require('./lib/utils');
+const Redis = require('ioredis');
 
 module.exports = (opts, logger) => {
   logger = logger || noopLogger;
-  const {
+  const connectionOpts = {...opts};
-    client,
+  // Support legacy app
-    createHash,
+  if (process.env.JAMBONES_REDIS_USERNAME && process.env.JAMBONES_REDIS_PASSWORD) {
-    retrieveHash
+    if (Array.isArray(connectionOpts)) {
-  } = require('@jambonz/realtimedb-helpers')(opts, logger);
+      for (const o of opts) {
+        o.username = process.env.JAMBONES_REDIS_USERNAME;
+        o.password = process.env.JAMBONES_REDIS_PASSWORD;
+      }
+    } else {
+      connectionOpts.username = process.env.JAMBONES_REDIS_USERNAME;
+      connectionOpts.password = process.env.JAMBONES_REDIS_PASSWORD;
+    }
+  }
+
+  const client = new Redis(connectionOpts);
+  ['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}`);
+      });
+    });
 
   return {
     client,
     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,31 +0,0 @@
-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;
-
-async function addFileToCache(client, logger, path,
-  {account_sid, vendor, language, voice, deploymentId, engine, text}) {
-  let key;
-  logger = logger || noopLogger;
-
-  try {
-    key = makeSynthKey({
-      account_sid,
-      vendor,
-      language: language || '',
-      voice: voice || deploymentId,
-      engine,
-      text,
-    });
-    const audioBuffer = await fs.readFile(path);
-    await client.setex(key, EXPIRES, audioBuffer.toString('base64'));
-  } 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

@@ -1,25 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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,
-  {accessKeyId, secretAccessKey, region, roleArn}) {
-  logger = logger || noopLogger;
-  try {
-    const key = makeAwsKey(roleArn || accessKeyId);
-    const obj = await retrieveHash(key);
-    if (obj) return {...obj, servedFromCache: true};
-
-    let data;
-    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 {
-      /* access token not found in cache, so generate it using STS */
-      const stsClient = new STSClient({
-        region,
-        credentials: {
-          accessKeyId,
-          secretAccessKey,
-        }
-      });
-      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
-    };
-
-    createHash(key, credentials, CACHE_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,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,16 +1,11 @@
 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;
@@ -92,32 +87,17 @@ const getGoogleVoices = async(_client, logger, credentials) => {
   return await client.listVoices();
 };
 
-const getAwsVoices = async(_client, createHash, retrieveHash, logger, credentials) => {
+const getAwsVoices = async(_client, logger, credentials) => {
   try {
-    const {region, accessKeyId, secretAccessKey, roleArn} = credentials;
+    const {region, accessKeyId, secretAccessKey} = credentials;
-    let client = null;
+    const client = new PollyClient({
-    if (accessKeyId && secretAccessKey) {
+      region,
-      client = new PollyClient({
+      credentials: {
-        region,
+        accessKeyId,
-        credentials: {
+        secretAccessKey
-          accessKeyId,
+      }
-          secretAccessKey
+    });
-        }
+    const command = new DescribeVoicesCommand({LanguageCode: 'en-US'});
-      });
-    } 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) {
@@ -126,26 +106,6 @@ const getAwsVoices = async(_client, createHash, retrieveHash, logger, credential
   }
 };
 
-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
@@ -162,10 +122,10 @@ const getVerbioVoices = 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, createHash, retrieveHash, logger, {vendor, credentials}) {
+async function getTtsVoices(client, logger, {vendor, credentials}) {
   logger = logger || noopLogger;
 
-  assert.ok(['nuance', 'ibm', 'google', 'aws', 'polly', 'verbio'].includes(vendor),
+  assert.ok(['nuance', 'ibm', 'google', 'aws', 'polly'].includes(vendor),
     `getTtsVoices not supported for vendor ${vendor}`);
 
   switch (vendor) {
@@ -177,9 +137,7 @@ async function getTtsVoices(client, createHash, retrieveHash, logger, {vendor, c
       return getGoogleVoices(client, logger, credentials);
     case 'aws':
     case 'polly':
-      return getAwsVoices(client, createHash, retrieveHash, logger, credentials);
+      return getAwsVoices(client, logger, credentials);
-    case 'verbio':
-      return getVerbioVoices(client, logger, credentials);
     default:
       break;
   }

lib/get-verbio-token.js

@@ -1,51 +0,0 @@
-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

@@ -14,17 +14,8 @@ const {
   CancellationDetails,
   SpeechSynthesisOutputFormat
 } = sdk;
-const {
+const {makeSynthKey, createNuanceClient, createKryptonClient, createRivaClient, noopLogger} = require('./utils');
-  makeSynthKey,
-  createNuanceClient,
-  createKryptonClient,
-  createRivaClient,
-  noopLogger,
-  makeFilePath,
-  makePlayhtKey
-} = require('./utils');
 const getNuanceAccessToken = require('./get-nuance-access-token');
-const getVerbioAccessToken = require('./get-verbio-token');
 const {
   SynthesisRequest,
   Voice,
@@ -39,17 +30,8 @@ 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 {
+const EXPIRES = (process.env.JAMBONES_TTS_CACHE_DURATION_MINS || 4 * 60) * 60; // cache tts for 4 hours
-  JAMBONES_DISABLE_TTS_STREAMING,
+const TMP_FOLDER = '/tmp';
-  JAMBONES_DISABLE_AZURE_TTS_STREAMING,
-  JAMBONES_HTTP_PROXY_IP,
-  JAMBONES_HTTP_PROXY_PORT,
-  JAMBONES_TTS_CACHE_DURATION_MINS,
-  JAMBONES_EAGERLY_PRE_CACHE_AUDIO,
-} = require('./config');
-const EXPIRES = JAMBONES_TTS_CACHE_DURATION_MINS;
-const OpenAI = require('openai');
-const getAwsAuthToken = require('./get-aws-sts-token');
 
 
 const trimTrailingSilence = (buffer) => {
@@ -86,19 +68,17 @@ 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, createHash, retrieveHash, logger, stats, { account_sid,
+async function synthAudio(client, logger, stats, { account_sid,
-  vendor, language, voice, gender, text, engine, salt, model, credentials, deploymentId,
+  vendor, language, voice, gender, text, engine, salt, model, credentials, deploymentId, disableTtsCache
-  disableTtsCache, renderForCaching = false, disableTtsStreaming, options
 }) {
   let audioBuffer;
   let servedFromCache = false;
   let rtt;
   logger = logger || noopLogger;
 
-  assert.ok(['google', 'aws', 'polly', 'microsoft', 'wellsaid', 'nuance', 'nvidia', 'ibm', 'elevenlabs',
+  assert.ok(['google', 'aws', 'polly', 'microsoft', 'wellsaid', 'nuance', 'nvidia', 'ibm'].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}`);
+  `synthAudio supported vendors are google, aws, microsoft, nuance, nvidia and wellsaid, not ${vendor}`);
   if ('google' === vendor) {
     assert.ok(language, 'synthAudio requires language when google is used');
   }
@@ -130,71 +110,31 @@ async function synthAudio(client, createHash, retrieveHash, logger, stats, { acc
     language = 'en-US'; // WellSaid only supports English atm
     assert.ok(voice, 'synthAudio requires voice when wellsaid is used');
     assert.ok(!text.startsWith('<speak'), 'wellsaid does not support SSML tags');
-  } else if ('elevenlabs' === vendor) {
-    assert.ok(voice, 'synthAudio requires voice when elevenlabs is used');
-    assert.ok(credentials.api_key, 'synthAudio requires api_key when elevenlabs is used');
-    assert.ok(credentials.model_id, 'synthAudio requires model_id when elevenlabs is used');
-  } else if ('playht' === vendor) {
-    assert.ok(voice, 'synthAudio requires voice when playht is used');
-    assert.ok(credentials.api_key, 'synthAudio requires api_key when playht is used');
-    assert.ok(credentials.user_id, 'synthAudio requires user_id when playht is used');
-    assert.ok(credentials.voice_engine, 'synthAudio requires voice_engine when playht is used');
-  } else if ('rimelabs' === vendor) {
-    assert.ok(voice, 'synthAudio requires voice when rimelabs is used');
-    assert.ok(credentials.api_key, 'synthAudio requires api_key when rimelabs is used');
-    assert.ok(credentials.model_id, 'synthAudio requires model_id when rimelabs is used');
-  } else if ('whisper' === vendor) {
-    assert.ok(voice, 'synthAudio requires voice when whisper is used');
-    assert.ok(credentials.model_id, 'synthAudio requires model when whisper is used');
-    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');
-  } else if ('deepgram' === vendor) {
-    if (!credentials.deepgram_tts_uri) {
-      assert.ok(credentials.api_key, 'synthAudio requires api_key when deepgram is used');
-    }
-
   }
-
   const key = makeSynthKey({
     account_sid,
     vendor,
     language: language || '',
     voice: voice || deploymentId,
     engine,
-    text,
+    text
-    renderForCaching
   });
   let filePath;
-  filePath = makeFilePath({vendor, key, salt, renderForCaching});
+  if (['nuance', 'nvidia'].includes(vendor) ||
+    (
+      process.env.JAMBONES_TTS_TRIM_SILENCE &&
+      ['microsoft', 'azure'].includes(vendor)
+    )
+  ) {
+    filePath = `${TMP_FOLDER}/${key.replace('tts:', `tts-${salt || ''}`)}.r8`;
+  }
+  else filePath = `${TMP_FOLDER}/${key.replace('tts:', `tts-${salt || ''}`)}.mp3`;
   debug(`synth key is ${key}`);
   let cached;
   if (!disableTtsCache) {
     cached = await client.get(key);
-    /**
-    *  If we are using tts streaming and also precaching audio, audio could have been cached by streaming (r8)
-    * or here in speech-utils due to precaching (mp3), so we need to check for both keys.
-    */
-    if (!cached && JAMBONES_EAGERLY_PRE_CACHE_AUDIO) {
-      const preCachekey = makeSynthKey({
-        account_sid,
-        vendor,
-        language: language || '',
-        voice: voice || deploymentId,
-        engine,
-        text,
-        renderForCaching: true
-      });
-      cached = await client.get(preCachekey);
-      if (cached) {
-        // Precache audio is available update filpath with precache file extension.
-        filePath = makeFilePath({vendor, key, salt, renderForCaching: true});
-      }
-    }
   }
   if (cached) {
     // found in cache - extend the expiry and use it
@@ -217,14 +157,12 @@ async function synthAudio(client, createHash, retrieveHash, logger, stats, { acc
       case 'aws':
       case 'polly':
         vendorLabel = 'aws';
-        audioBuffer = await synthPolly(createHash, retrieveHash, logger,
+        audioBuffer = await synthPolly(logger, {credentials, stats, language, voice, text, engine});
-          {credentials, stats, language, voice, text, engine});
         break;
       case 'azure':
       case 'microsoft':
         vendorLabel = 'microsoft';
-        audioBuffer = await synthMicrosoft(logger, {credentials, stats, language, voice, text, deploymentId,
+        audioBuffer = await synthMicrosoft(logger, {credentials, stats, language, voice, text, deploymentId, filePath});
-          filePath, renderForCaching, disableTtsStreaming});
         break;
       case 'nuance':
         model = model || 'enhanced';
@@ -239,34 +177,6 @@ async function synthAudio(client, createHash, retrieveHash, logger, stats, { acc
       case 'wellsaid':
         audioBuffer = await synthWellSaid(logger, {credentials, stats, language, voice, text, filePath});
         break;
-      case 'elevenlabs':
-        audioBuffer = await synthElevenlabs(logger, {
-          credentials, options, stats, language, voice, text, renderForCaching, disableTtsStreaming, filePath
-        });
-        break;
-      case 'playht':
-        audioBuffer = await synthPlayHT(client, logger, {
-          credentials, options, stats, language, voice, text, renderForCaching, disableTtsStreaming, filePath
-        });
-        break;
-      case 'rimelabs':
-        audioBuffer = await synthRimelabs(logger, {
-          credentials, options, stats, language, voice, text, renderForCaching, disableTtsStreaming, filePath
-        });
-        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});
-        break;
       case vendor.startsWith('custom') ? vendor : 'cant_match_value':
         ({ audioBuffer, filePath } = await synthCustomVendor(logger,
           {credentials, stats, language, voice, text, filePath}));
@@ -274,7 +184,6 @@ async function synthAudio(client, createHash, retrieveHash, logger, stats, { acc
       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);
@@ -294,33 +203,16 @@ async function synthAudio(client, createHash, retrieveHash, logger, stats, { acc
   });
 }
 
-const synthPolly = async(createHash, retrieveHash, logger,
+const synthPolly = async(logger, {credentials, stats, language, voice, engine, text}) => {
-  {credentials, stats, language, voice, engine, text}) => {
   try {
-    const {region, accessKeyId, secretAccessKey, roleArn} = credentials;
+    const {region, accessKeyId, secretAccessKey} = credentials;
-    let polly;
+    const polly = new PollyClient({
-    if (accessKeyId && secretAccessKey) {
+      region,
-      polly = new PollyClient({
+      credentials: {
-        region,
+        accessKeyId,
-        credentials: {
+        secretAccessKey
-          accessKeyId,
+      }
-          secretAccessKey
+    });
-        }
-      });
-    } else if (roleArn) {
-      polly = new PollyClient({
-        region,
-        credentials: await getAwsAuthToken(
-          logger, createHash, retrieveHash,
-          {
-            region,
-            roleArn
-          }),
-      });
-    } else {
-      // AWS RoleArn assigned to Instance profile
-      polly = new PollyClient({region});
-    }
     const opts = {
       Engine: engine,
       OutputFormat: 'mp3',
@@ -355,8 +247,7 @@ const synthGoogle = async(logger, {credentials, stats, language, voice, gender,
   const client = new ttsGoogle.TextToSpeechClient(credentials);
   const opts = {
     voice: {
-      ...(typeof voice === 'string' && {name: voice}),
+      name: voice,
-      ...(typeof voice === 'object' && {customVoice: voice}),
       languageCode: language,
       ssmlGender: gender || 'SSML_VOICE_GENDER_UNSPECIFIED'
     },
@@ -406,70 +297,34 @@ const synthIbm = async(logger, {credentials, stats, voice, text}) => {
   }
 };
 
-async function _synthOnPremMicrosoft(logger, {
-  credentials,
-  stats,
-  language,
-  voice,
-  text,
-  filePath
-}) {
-  const {use_custom_tts, custom_tts_endpoint_url, api_key} = credentials;
-  let content = text;
-
-  if (use_custom_tts && !content.startsWith('<speak')) {
-    /**
-     * Note: it seems that to use custom voice ssml is required with the voice attribute
-     * Otherwise sending plain text we get "Voice does not match"
-     */
-    content = `<speak>${text}</speak>`;
-  }
-
-  if (content.startsWith('<speak>')) {
-    /* microsoft enforces some properties and uses voice xml element so if the user did not supply do it for them */
-    const words = content.slice(7, -8).trim().replace(/(\r\n|\n|\r)/gm, ' ');
-    // eslint-disable-next-line max-len
-    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');
-  }
-
-  try {
-    const trimSilence = filePath.endsWith('.r8');
-    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',
-      ...(api_key && {'Ocp-Apim-Subscription-Key': api_key})
-    });
-    const mp3 = await post(custom_tts_endpoint_url, content);
-    return mp3;
-  } catch (err) {
-    logger.info({err}, '_synthMicrosoftByHttp returned error');
-    throw err;
-  }
-}
-
 const synthMicrosoft = async(logger, {
   credentials,
   stats,
   language,
   voice,
   text,
-  filePath,
+  filePath
-  renderForCaching,
-  disableTtsStreaming
 }) => {
   try {
-    const {api_key: apiKey, region, use_custom_tts, custom_tts_endpoint, custom_tts_endpoint_url} = credentials;
+    const {api_key: apiKey, region, use_custom_tts, custom_tts_endpoint} = credentials;
-    // let clean up the text
+    const trimSilence = filePath.endsWith('.r8');
     let content = text;
-    if (use_custom_tts && !content.startsWith('<speak')) {
+    const speechConfig = SpeechConfig.fromSubscription(apiKey, region);
+    speechConfig.speechSynthesisLanguage = language;
+    speechConfig.speechSynthesisVoiceName = voice;
+    if (use_custom_tts && custom_tts_endpoint) {
+      speechConfig.endpointId = custom_tts_endpoint;
+
       /**
        * Note: it seems that to use custom voice ssml is required with the voice attribute
        * Otherwise sending plain text we get "Voice does not match"
        */
-      content = `<speak>${text}</speak>`;
+      if (!content.startsWith('<speak')) content = `<speak>${text}</speak>`;
     }
+    speechConfig.speechSynthesisOutputFormat = trimSilence ?
+      SpeechSynthesisOutputFormat.Raw8Khz16BitMonoPcm :
+      SpeechSynthesisOutputFormat.Audio16Khz32KBitRateMonoMp3;
+    const synthesizer = new SpeechSynthesizer(speechConfig);
 
     if (content.startsWith('<speak>')) {
       /* microsoft enforces some properties and uses voice xml element so if the user did not supply do it for them */
@@ -478,53 +333,6 @@ 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 (!JAMBONES_DISABLE_TTS_STREAMING && !JAMBONES_DISABLE_AZURE_TTS_STREAMING &&
-      !renderForCaching && !disableTtsStreaming) {
-      let params = '';
-      params += `{api_key=${apiKey}`;
-      params += `,language=${language}`;
-      params += ',vendor=microsoft';
-      params += `,voice=${voice}`;
-      params += ',write_cache_file=1';
-      if (region) params += `,region=${region}`;
-      if (custom_tts_endpoint) params += `,endpointId=${custom_tts_endpoint}`;
-      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, ' ')}`,
-        servedFromCache: false,
-        rtt: 0
-      };
-    }
-    if (use_custom_tts && custom_tts_endpoint_url) {
-      return await _synthOnPremMicrosoft(logger, {
-        credentials,
-        stats,
-        language,
-        voice,
-        text,
-        filePath
-      });
-    }
-    const trimSilence = filePath.endsWith('.r8');
-    const speechConfig = SpeechConfig.fromSubscription(apiKey, region);
-    speechConfig.speechSynthesisLanguage = language;
-    speechConfig.speechSynthesisVoiceName = voice;
-    if (use_custom_tts && custom_tts_endpoint) {
-      speechConfig.endpointId = custom_tts_endpoint;
-    }
-    speechConfig.speechSynthesisOutputFormat = trimSilence ?
-      SpeechSynthesisOutputFormat.Raw8Khz16BitMonoPcm :
-      SpeechSynthesisOutputFormat.Audio16Khz32KBitRateMonoMp3;
-
-    if (JAMBONES_HTTP_PROXY_IP && JAMBONES_HTTP_PROXY_PORT) {
-      logger.debug(
-        `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);
 
     return new Promise((resolve, reject) => {
       const speakAsync = content.startsWith('<speak') ?
@@ -701,313 +509,6 @@ const synthCustomVendor = async(logger, {credentials, stats, language, voice, te
   }
 };
 
-const synthElevenlabs = async(logger, {
-  credentials, options, stats, voice, text, renderForCaching, disableTtsStreaming
-}) => {
-  const {api_key, model_id, options: credOpts} = credentials;
-  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 (!JAMBONES_DISABLE_TTS_STREAMING && !renderForCaching && !disableTtsStreaming) {
-    let params = '';
-    params += `{api_key=${api_key}`;
-    params += ',vendor=elevenlabs';
-    params += `,voice=${voice}`;
-    params += `,model_id=${model_id}`;
-    params += `,optimize_streaming_latency=${opts.optimize_streaming_latency || 2}`;
-    params += ',write_cache_file=1';
-    if (opts.voice_settings?.similarity_boost) params += `,similarity_boost=${opts.voice_settings.similarity_boost}`;
-    if (opts.voice_settings?.stability) params += `,stability=${opts.voice_settings.stability}`;
-    if (opts.voice_settings?.style) params += `,style=${opts.voice_settings.style}`;
-    if (opts.voice_settings?.use_speaker_boost === false) params += ',use_speaker_boost=false';
-    if (opts.previous_text) params += `,previous_text=${opts.previous_text}`;
-    if (opts.next_text) params += `,next_text=${opts.next_text}`;
-    params += '}';
-
-    return {
-      filePath: `say:${params}${text.replace(/\n/g, ' ').replace(/\r/g, ' ')}`,
-      servedFromCache: false,
-      rtt: 0
-    };
-  }
-
-  const optimize_streaming_latency = opts.optimize_streaming_latency ?
-    `?optimize_streaming_latency=${opts.optimize_streaming_latency}` : '';
-  try {
-    const post = bent('https://api.elevenlabs.io', 'POST', 'buffer', {
-      'xi-api-key': api_key,
-      'Accept': 'audio/mpeg',
-      'Content-Type': 'application/json'
-    });
-    const mp3 = await post(`/v1/text-to-speech/${voice}${optimize_streaming_latency}`, {
-      text,
-      model_id,
-      voice_settings: {
-        stability: 0.5,
-        similarity_boost: 0.5
-      },
-      ...opts
-    });
-    return mp3;
-  } catch (err) {
-    logger.info({err}, 'synth Elevenlabs returned error');
-    stats.increment('tts.count', ['vendor:elevenlabs', 'accepted:no']);
-    throw err;
-  }
-};
-
-const synthPlayHT = async(client, logger, {
-  credentials, options, stats, voice, language, text, renderForCaching, disableTtsStreaming
-}) => {
-  const {api_key, user_id, voice_engine, options: credOpts} = credentials;
-  const opts = !!options && Object.keys(options).length !== 0 ? options : JSON.parse(credOpts || '{}');
-
-  let synthesizeUrl = 'https://api.play.ht/api/v2/tts/stream';
-
-  // If model is play3.0, the synthesizeUrl is got from authentication endpoint
-  if (voice_engine === 'Play3.0') {
-    try {
-      const post = bent('https://api.play.ht', 'POST', 'json', 201, {
-        'AUTHORIZATION': api_key,
-        'X-USER-ID': user_id,
-        'Accept': 'application/json'
-      });
-      const key = makePlayhtKey(api_key);
-      const url = await client.get(key);
-      if (!url) {
-        const {inference_address, expires_at_ms} = await post('/api/v3/auth');
-        synthesizeUrl = inference_address;
-        const expiry =  Math.floor((expires_at_ms - Date.now()) / 1000 - 30);
-        await client.set(key, inference_address, 'EX', expiry);
-      } else {
-        // Use cached URL
-        synthesizeUrl = url;
-      }
-    } catch (err) {
-      logger.info({err}, 'synth PlayHT returned error for authentication version 3.0');
-      stats.increment('tts.count', ['vendor:playht', 'accepted:no']);
-      throw err;
-    }
-  }
-
-  /* default to using the streaming interface, unless disabled by env var OR we want just a cache file */
-  if (!JAMBONES_DISABLE_TTS_STREAMING && !renderForCaching && !disableTtsStreaming) {
-    let params = '';
-    params += `{api_key=${api_key}`;
-    params += `,user_id=${user_id}`;
-    params += ',vendor=playht';
-    params += `,voice=${voice}`;
-    params += `,voice_engine=${voice_engine}`;
-    params += `,synthesize_url=${synthesizeUrl}`;
-    params += ',write_cache_file=1';
-    params += `,language=${language}`;
-    if (opts.quality) params += `,quality=${opts.quality}`;
-    if (opts.speed) params += `,speed=${opts.speed}`;
-    if (opts.seed) params += `,style=${opts.seed}`;
-    if (opts.temperature) params += `,temperature=${opts.temperature}`;
-    if (opts.emotion) params += `,emotion=${opts.emotion}`;
-    if (opts.voice_guidance) params += `,voice_guidance=${opts.voice_guidance}`;
-    if (opts.style_guidance) params += `,style_guidance=${opts.style_guidance}`;
-    if (opts.text_guidance) params += `,text_guidance=${opts.text_guidance}`;
-    if (opts.top_p) params += `,top_p=${opts.top_p}`;
-    if (opts.repetition_penalty) params += `,repetition_penalty=${opts.repetition_penalty}`;
-    params += '}';
-
-    return {
-      filePath: `say:${params}${text.replace(/\n/g, ' ').replace(/\r/g, ' ')}`,
-      servedFromCache: false,
-      rtt: 0
-    };
-  }
-
-  try {
-    const post = bent('POST', 'buffer', {
-      ...(voice_engine !== 'Play3.0' && {
-        'AUTHORIZATION': api_key,
-        'X-USER-ID': user_id,
-      }),
-      'Accept': 'audio/mpeg',
-      'Content-Type': 'application/json'
-    });
-
-    const mp3 = await post(synthesizeUrl, {
-      text,
-      ...(voice_engine === 'Play3.0' && { language }),
-      voice,
-      voice_engine,
-      output_format: 'mp3',
-      sample_rate: 8000,
-      ...opts
-    });
-    return mp3;
-  } catch (err) {
-    logger.info({err}, 'synth PlayHT returned error');
-    stats.increment('tts.count', ['vendor:playht', 'accepted:no']);
-    throw err;
-  }
-};
-
-const synthRimelabs = async(logger, {
-  credentials, options, stats, voice, text, renderForCaching, disableTtsStreaming
-}) => {
-  const {api_key, model_id, options: credOpts} = credentials;
-  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 (!JAMBONES_DISABLE_TTS_STREAMING && !renderForCaching && !disableTtsStreaming) {
-    let params = '';
-    params += `{api_key=${api_key}`;
-    params += `,model_id=${model_id}`;
-    params += ',vendor=rimelabs';
-    params += `,voice=${voice}`;
-    params += ',write_cache_file=1';
-    if (opts.speedAlpha) params += `,speed_alpha=${opts.speedAlpha}`;
-    if (opts.reduceLatency) params += `,reduce_latency=${opts.reduceLatency}`;
-    params += '}';
-
-    return {
-      filePath: `say:${params}${text.replace(/\n/g, ' ').replace(/\r/g, ' ')}`,
-      servedFromCache: false,
-      rtt: 0
-    };
-  }
-
-  try {
-    const post = bent('https://users.rime.ai', 'POST', 'buffer', {
-      'Authorization': `Bearer ${api_key}`,
-      'Accept': 'audio/mp3',
-      'Content-Type': 'application/json'
-    });
-    const mp3 = await post('/v1/rime-tts', {
-      speaker: voice,
-      text,
-      modelId: model_id,
-      samplingRate: 8000,
-      ...opts
-    });
-    return mp3;
-  } catch (err) {
-    logger.info({err}, 'synth rimelabs returned error');
-    stats.increment('tts.count', ['vendor:rimelabs', 'accepted:no']);
-    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 (!JAMBONES_DISABLE_TTS_STREAMING && !renderForCaching && !disableTtsStreaming) {
-    let params = '';
-    params += `{api_key=${api_key}`;
-    params += `,model_id=${model_id}`;
-    params += ',vendor=whisper';
-    params += `,voice=${voice}`;
-    params += ',write_cache_file=1';
-    if (speed) params += `,speed=${speed}`;
-    params += '}';
-
-    return {
-      filePath: `say:${params}${text.replace(/\n/g, ' ')}`,
-      servedFromCache: false,
-      rtt: 0
-    };
-  }
-  try {
-    const openai = new OpenAI.OpenAI({
-      apiKey: api_key,
-      timeout: timeout || 5000,
-      ...(baseURL && {baseURL})
-    });
-
-    const mp3 = await openai.audio.speech.create({
-      model: model_id,
-      voice,
-      input: text,
-      response_format: 'mp3'
-    });
-    return Buffer.from(await mp3.arrayBuffer());
-  } catch (err) {
-    logger.info({err}, 'synth whisper returned error');
-    stats.increment('tts.count', ['vendor:openai', 'accepted:no']);
-    throw err;
-  }
-};
-
-const synthDeepgram = async(logger, {credentials, stats, model, text, renderForCaching, disableTtsStreaming}) => {
-  const {api_key, deepgram_tts_uri} = credentials;
-  if (!JAMBONES_DISABLE_TTS_STREAMING && !renderForCaching && !disableTtsStreaming) {
-    let params = '';
-    params += `{api_key=${api_key}`;
-    params += ',vendor=deepgram';
-    params += `,voice=${model}`;
-    params += ',write_cache_file=1';
-    if (deepgram_tts_uri) params += `,endpoint=${deepgram_tts_uri}`;
-    params += '}';
-
-    return {
-      filePath: `say:${params}${text.replace(/\n/g, ' ')}`,
-      servedFromCache: false,
-      rtt: 0
-    };
-  }
-  try {
-    const post = bent(deepgram_tts_uri || 'https://api.deepgram.com', 'POST', 'buffer', {
-      // on-premise deepgram does not  require to have api_key
-      ...(api_key && {'Authorization': `Token ${api_key}`}),
-      'Accept': 'audio/mpeg',
-      'Content-Type': 'application/json'
-    });
-    const mp3 = await post(`/v1/speak?model=${model}`, {
-      text
-    });
-    return mp3;
-  } catch (err) {
-    logger.info({err}, 'synth Deepgram returned error');
-    stats.increment('tts.count', ['vendor:deepgram', 'accepted:no']);
-    throw err;
-  }
-};
-
 const getFileExtFromMime = (mime) => {
   switch (mime) {
     case 'audio/wav':

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');
 /**
@@ -16,59 +16,10 @@ const debug = require('debug')('jambonz:realtimedb-helpers');
  */
 //const nuanceClientMap = new Map();
 
-function makeSynthKey({
+function makeSynthKey({account_sid = '', vendor, language, voice, engine = '', text}) {
-  account_sid = '', vendor, language, voice, engine = '', text,
-  renderForCaching = false}) {
   const hash = crypto.createHash('sha1');
   hash.update(`${language}:${vendor}:${voice}:${engine}:${text}`);
-  const hexHashKey = hash.digest('hex');
+  return `tts${account_sid ? (':' + account_sid) : ''}:${hash.digest('hex')}`;
-  const accountKey = account_sid ? `:${account_sid}` : '';
-  const namespace = vendor.startsWith('custom') ? vendor : getFileExtension({vendor, renderForCaching});
-  const key = `tts${accountKey}:${namespace}:${hexHashKey}`;
-  return key;
-}
-
-function makeFilePath({vendor, key, salt = '', renderForCaching = false}) {
-  const extension = getFileExtension({vendor, renderForCaching});
-  return `${TMP_FOLDER}/${key.replace('tts:', `tts-${salt}`)}.${extension}`;
-}
-
-function getFileExtension({vendor, renderForCaching = false}) {
-  const mp3Extension = 'mp3';
-  const r8Extension = 'r8';
-
-  switch (vendor) {
-    case 'azure':
-    case 'microsoft':
-      if (!renderForCaching && !JAMBONES_DISABLE_TTS_STREAMING || JAMBONES_TTS_TRIM_SILENCE) {
-        return r8Extension;
-      } else {
-        return mp3Extension;
-      }
-    case 'deepgram':
-    case 'elevenlabs':
-    case 'rimlabs':
-    case 'playht':
-      if (renderForCaching || JAMBONES_DISABLE_TTS_STREAMING) {
-        return mp3Extension;
-      } else {
-        return r8Extension;
-      }
-    case 'nuance':
-    case 'nvidia':
-    case 'verbio':
-      return r8Extension;
-    default:
-      // If vendor is custom
-      if (vendor.startsWith('custom')) {
-        if (renderForCaching || JAMBONES_DISABLE_TTS_STREAMING) {
-          return mp3Extension;
-        } else {
-          return r8Extension;
-        }
-      }
-      return mp3Extension;
-  }
 }
 
 const noopLogger = {
@@ -92,23 +43,6 @@ 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}`);
@@ -172,19 +106,16 @@ 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.1.19",
+  "version": "0.0.19",
   "description": "TTS-related speech utilities for jambonz",
   "main": "index.js",
   "author": "Dave Horton",
@@ -12,9 +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": "npm run jslint --fix",
+    "build": "./build_stubs.sh"
-    "build": "./build_stubs.sh",
-    "prepare": "husky"
   },
   "repository": {
     "type": "git",
@@ -26,27 +24,24 @@
   },
   "homepage": "https://github.com/jambonz/speech-utils#readme",
   "dependencies": {
-    "@aws-sdk/client-polly": "^3.496.0",
+    "@aws-sdk/client-polly": "^3.359.0",
-    "@aws-sdk/client-sts": "^3.496.0",
+    "@google-cloud/text-to-speech": "^4.2.1",
-    "@google-cloud/text-to-speech": "^5.0.2",
+    "@grpc/grpc-js": "^1.8.13",
-    "@grpc/grpc-js": "^1.9.14",
-    "@jambonz/realtimedb-helpers": "^0.8.7",
     "bent": "^7.3.12",
     "debug": "^4.3.4",
-    "form-urlencoded": "^6.1.4",
+    "form-urlencoded": "^6.1.0",
     "google-protobuf": "^3.21.2",
     "ibm-watson": "^8.0.0",
-    "microsoft-cognitiveservices-speech-sdk": "1.38.0",
+    "microsoft-cognitiveservices-speech-sdk": "^1.26.0",
-    "openai": "^4.25.0",
+    "ioredis": "^5.3.2",
-    "undici": "^6.4.0"
+    "undici": "^5.21.0"
   },
   "devDependencies": {
-    "config": "^3.3.11",
+    "config": "^3.3.9",
-    "eslint": "^9.3.0",
+    "eslint": "^8.33.0",
-    "eslint-plugin-promise": "^6.2.0",
+    "eslint-plugin-promise": "^6.1.1",
-    "husky": "^9.0.11",
     "nyc": "^15.1.0",
-    "pino": "^9.1.0",
+    "pino": "^7.2.0",
-    "tape": "^5.7.5"
+    "tape": "^5.1.1"
   }
 }

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.
+// - 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.
+// - 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.
+// - 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 @@ var RivaSpeechSynthesisService = exports.RivaSpeechSynthesisService = {
     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,
+// Submit a SynthesizeSpeechRequest with desired text and configuration,
-  // and receive stream of bytes in the requested format.
+// and receive stream of bytes in the requested format.
-  synthesizeOnline: {
+synthesizeOnline: {
     path: '/nvidia.riva.tts.RivaSpeechSynthesis/SynthesizeOnline',
     requestStream: false,
     responseStream: true,
@@ -83,7 +83,7 @@ var RivaSpeechSynthesisService = exports.RivaSpeechSynthesisService = {
     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

@@ -1,48 +0,0 @@
-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/index.js

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

test/list-voices.js

@@ -12,32 +12,6 @@ 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/squid.conf

@@ -1,85 +0,0 @@
-#
-# 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

@@ -20,7 +20,7 @@ const stats = {
 
 test('Google speech synth tests', async(t) => {
   const fn = require('..');
-  const {synthAudio, addFileToCache, client} = fn(opts, logger);
+  const {synthAudio, 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: 'FEMALE',
+      gender: 'MALE',
       text: 'This is a test.  This is only a test',
       salt: 'foo.bar',
     });
@@ -53,19 +53,11 @@ test('Google speech synth tests', async(t) => {
         },
       },
       language: 'en-GB',
-      gender: 'FEMALE',
+      gender: 'MALE',
       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: {
@@ -76,7 +68,7 @@ test('Google speech synth tests', async(t) => {
       },
       disableTtsCache: true,
       language: 'en-GB',
-      gender: 'FEMALE',
+      gender: 'MALE',
       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}`);
@@ -87,40 +79,6 @@ 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);
-    let 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('AWS speech synth tests', async(t) => {
   const fn = require('..');
   const {synthAudio, client} = fn(opts, logger);
@@ -162,33 +120,6 @@ 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);
@@ -215,12 +146,9 @@ 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',
@@ -231,7 +159,6 @@ 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) {
@@ -241,58 +168,6 @@ 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);
@@ -314,7 +189,6 @@ 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}`);
 
@@ -329,7 +203,6 @@ 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) {
@@ -538,218 +411,6 @@ 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('rimelabs speech synth tests', 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 {
-    let 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: 'en-US',
-      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('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, getTtsSize, client} = fn(opts, logger);
@@ -797,19 +458,8 @@ 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:*')
+    const cached = (await client.keys('tts:*')).length;
-    t.ok(cached.length >= 1, `successfully kept all non-specified tts records in cache`);
+    t.ok(cached >= 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));