fix: upgrade openai from 4.25.0 to 4.53.2

Snyk has created this PR to upgrade openai from 4.25.0 to 4.53.2.

See this package in npm:
openai

See this project in Snyk:
https://app.snyk.io/org/davehorton/project/6f41db32-9ff7-45b4-83ae-9512305f387b?utm_source=github&utm_medium=referral&page=upgrade-pr

.github/workflows/ci.yml

@@ -11,8 +11,13 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions/setup-node@v4
         with:
-          node-version: '20'
+          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
@@ -23,7 +28,9 @@ jobs:
           AWS_REGION: ${{ secrets.AWS_REGION }}
           AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
           GCP_JSON_KEY: ${{ secrets.GCP_JSON_KEY }}
-
+          IBM_API_KEY: ${{ secrets.IBM_API_KEY }}
+          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 }}
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}

.github/workflows/publish.yml

@@ -12,8 +12,8 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
         with:
           node-version: lts/*
           registry-url: 'https://registry.npmjs.org'

index.js

@@ -16,7 +16,7 @@ module.exports = (opts, 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, createHash, retrieveHash, logger),
   };

lib/add-file-to-cache.js

@@ -3,29 +3,8 @@ 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, instructions}) {
+  {account_sid, vendor, language, voice, deploymentId, engine, text}) {
   let key;
   logger = logger || noopLogger;
 
@@ -36,19 +15,10 @@ async function addFileToCache(client, logger, path,
       language: language || '',
       voice: voice || deploymentId,
       engine,
-      model,
       text,
-      instructions
     });
-    const [extension, sampleRate] = getExtensionAndSampleRate(path);
     const audioBuffer = await fs.readFile(path);
-    await client.setex(key, EXPIRES, JSON.stringify(
-      {
-        audioContent: audioBuffer.toString('base64'),
-        extension,
-        sampleRate
-      }
-    ));
+    await client.setex(key, EXPIRES, audioBuffer.toString('base64'));
   } catch (err) {
     logger.error(err, 'addFileToCache: Error');
     return;

lib/config.js

@@ -2,14 +2,13 @@ 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_AZURE_ENABLE_SSML = process.env.JAMBONES_AZURE_ENABLE_SSML;
 
 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 = process.env.JAMBONES_TMP_FOLDER || '/tmp';
+const TMP_FOLDER = '/tmp';
 
 const HTTP_TIMEOUT = 5000;
 
@@ -22,6 +21,5 @@ module.exports = {
   JAMBONES_TTS_CACHE_DURATION_MINS,
   JAMBONES_EAGERLY_PRE_CACHE_AUDIO,
   TMP_FOLDER,
-  HTTP_TIMEOUT,
-  JAMBONES_AZURE_ENABLE_SSML
+  HTTP_TIMEOUT
 };

lib/get-aws-sts-token.js

@@ -7,23 +7,22 @@ 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}) {
+  {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 key = makeAwsKey(roleArn || accessKeyId);
     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) {
+    } else {
+      /* access token not found in cache, so generate it using STS */
       const stsClient = new STSClient({
         region,
         credentials: {
@@ -33,26 +32,6 @@ async function getAwsAuthToken(
       });
       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 = {
@@ -61,11 +40,9 @@ async function getAwsAuthToken(
       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}`));
-    }
+
+    createHash(key, credentials, CACHE_EXPIRY)
+      .catch((err) => logger.error(err, `Error saving hash for key ${key}`));
 
     return {...credentials, servedFromCache: false};
   } catch (err) {

lib/get-ibm-access-token.js

@@ -0,0 +1,48 @@
+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');
+
+async function getIbmAccessToken(client, logger, apiKey) {
+  logger = logger || noopLogger;
+  try {
+    const key = makeIbmKey(apiKey);
+    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 */
+    const payload = {
+      grant_type: 'urn:ibm:params:oauth:grant-type:apikey',
+      apikey: apiKey
+    };
+    const {statusCode, headers, body} =  await pool.request({
+      path: '/identity/token',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded'
+      },
+      body: formurlencoded(payload),
+      timeout: HTTP_TIMEOUT,
+      followRedirects: false
+    });
+
+    if (200 !== statusCode) {
+      const json = await body.json();
+      logger.debug({statusCode, headers, body: json}, 'error fetching access token from Ibm');
+      const err = new Error();
+      err.statusCode = statusCode;
+      throw err;
+    }
+    const json = await body.json();
+    await client.set(key, json.access_token, 'EX', json.expires_in - 30);
+    return {...json, servedFromCache: false};
+  } catch (err) {
+    debug(err, 'getIbmAccessToken: Error retrieving Ibm access token');
+    logger.error(err, 'getIbmAccessToken: Error retrieving Ibm access token for client_id ${clientId}');
+    throw err;
+  }
+}
+
+module.exports = getIbmAccessToken;

lib/get-tts-voices.js

@@ -3,6 +3,8 @@ 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');
@@ -10,6 +12,21 @@ 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;
+  console.log(`region: ${tts_region}, api_key: ${tts_api_key}`);
+
+  const textToSpeech = new TextToSpeechV1({
+    authenticator: new IamAuthenticator({
+      apikey: tts_api_key,
+    }),
+    serviceUrl: `https://api.${tts_region}.text-to-speech.watson.cloud.ibm.com`
+  });
+
+  const voices = await textToSpeech.listVoices();
+  return voices;
+};
+
 const getNuanceVoices = async(client, logger, credentials) => {
   const {client_id: clientId, secret: secret, nuance_tts_uri} = credentials;
 
@@ -148,12 +165,14 @@ const getVerbioVoices = async(client, logger, credentials) => {
 async function getTtsVoices(client, createHash, retrieveHash, logger, {vendor, credentials}) {
   logger = logger || noopLogger;
 
-  assert.ok(['nuance', 'google', 'aws', 'polly', 'verbio'].includes(vendor),
+  assert.ok(['nuance', 'ibm', 'google', 'aws', 'polly', 'verbio'].includes(vendor),
     `getTtsVoices not supported for vendor ${vendor}`);
 
   switch (vendor) {
     case 'nuance':
       return getNuanceVoices(client, logger, credentials);
+    case 'ibm':
+      return getIbmVoices(client, logger, credentials);
     case 'google':
       return getGoogleVoices(client, logger, credentials);
     case 'aws':

lib/purge-tts-cache.js

@@ -12,7 +12,7 @@ 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, model, text, instructions} = {all: true}) {
+  language, voice, deploymentId, engine, text} = {all: true}) {
   logger = logger || noopLogger;
 
   let purgedCount = 0, error;
@@ -33,9 +33,7 @@ async function purgeTtsCache(client, logger, {all, account_sid, vendor,
         language: language || '',
         voice: voice || deploymentId,
         engine,
-        model,
         text,
-        instructions
       });
       purgedCount = await client.del(key);
       if (purgedCount === 0) error = 'Specified item not found';

lib/utils.js

@@ -6,7 +6,7 @@ const pool = new Pool('https://auth.crt.nuance.com');
 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 { JAMBONES_DISABLE_TTS_STREAMING, JAMBONES_TTS_TRIM_SILENCE, TMP_FOLDER, HTTP_TIMEOUT } = require('./config');
 
 const debug = require('debug')('jambonz:realtimedb-helpers');
 /**
@@ -17,27 +17,50 @@ const debug = require('debug')('jambonz:realtimedb-helpers');
 //const nuanceClientMap = new Map();
 
 function makeSynthKey({
-  account_sid = '',
-  vendor,
-  language,
-  voice,
-  engine = '',
-  model = '',
-  text,
-  instructions = '',
-}) {
+  account_sid = '', vendor, language, voice, engine = '', text,
+  renderForCaching = false}) {
   const hash = crypto.createHash('sha1');
-  hash.update(`${language}:${vendor}:${voice}:${engine}:${model}:${text}:${instructions}`);
+  hash.update(`${language}:${vendor}:${voice}:${engine}:${text}`);
   const hexHashKey = hash.digest('hex');
   const accountKey = account_sid ? `:${account_sid}` : '';
-  const key = `tts${accountKey}:${hexHashKey}`;
+  const namespace = vendor.startsWith('custom') ? vendor : getFileExtension({vendor, renderForCaching});
+  const key = `tts${accountKey}:${namespace}:${hexHashKey}`;
   return key;
 }
 
-function makeFilePath({key, salt = '', extension}) {
+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':
+      if (!renderForCaching && !JAMBONES_DISABLE_TTS_STREAMING) {
+        return r8Extension;
+      } else {
+        return mp3Extension;
+      }
+    case 'nuance':
+    case 'nvidia':
+    case 'verbio':
+      return r8Extension;
+    default:
+      return mp3Extension;
+  }
+}
 
 const noopLogger = {
   info: () => {},
@@ -54,17 +77,18 @@ function makeBasicAuthHeader(username, password) {
   return {Authorization: header};
 }
 
+function makeIbmKey(apiKey) {
+  const hash = crypto.createHash('sha1');
+  hash.update(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);
@@ -137,8 +161,7 @@ const createRivaClient = async(rivaUri) => {
 module.exports = {
   makeSynthKey,
   makeNuanceKey,
-
-  makePlayhtKey,
+  makeIbmKey,
   makeAwsKey,
   makeVerbioKey,
   getNuanceAccessToken,

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jambonz/speech-utils",
-  "version": "1.0.4",
+  "version": "0.1.15",
   "description": "TTS-related speech utilities for jambonz",
   "main": "index.js",
   "author": "Dave Horton",
@@ -26,23 +26,22 @@
   },
   "homepage": "https://github.com/jambonz/speech-utils#readme",
   "dependencies": {
-    "23": "^0.0.0",
     "@aws-sdk/client-polly": "^3.496.0",
     "@aws-sdk/client-sts": "^3.496.0",
-    "@cartesia/cartesia-js": "^2.2.7",
-    "@google-cloud/text-to-speech": "^6.4.0",
+    "@google-cloud/text-to-speech": "^5.0.2",
     "@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",
     "google-protobuf": "^3.21.2",
+    "ibm-watson": "^8.0.0",
     "microsoft-cognitiveservices-speech-sdk": "1.38.0",
-    "openai": "^4.98.0",
-    "undici": "^7.5.0"
+    "openai": "^4.53.2",
+    "undici": "^6.4.0"
   },
   "devDependencies": {
-    "config": "^4.2.0",
+    "config": "^3.3.11",
     "eslint": "^9.3.0",
     "eslint-plugin-promise": "^6.2.0",
     "husky": "^9.0.11",

test/docker_start.js

@@ -2,7 +2,7 @@ const test = require('tape').test ;
 const exec = require('child_process').exec ;
 
 test('starting docker network..', (t) => {
-  exec(`docker compose -f ${__dirname}/docker-compose-testbed.yaml up -d`, (err, stdout, stderr) => {
+  exec(`docker-compose -f ${__dirname}/docker-compose-testbed.yaml up -d`, (err, stdout, stderr) => {
     setTimeout(() => {
       t.end(err);
     }, 2000);

test/docker_stop.js

@@ -3,7 +3,7 @@ const exec = require('child_process').exec ;
 
 test('stopping docker network..', (t) => {
   t.timeoutAfter(10000);
-  exec(`docker compose -f ${__dirname}/docker-compose-testbed.yaml down`, (err, stdout, stderr) => {
+  exec(`docker-compose -f ${__dirname}/docker-compose-testbed.yaml down`, (err, stdout, stderr) => {
     //console.log(`stderr: ${stderr}`);
     process.exit(0);
   });

test/ibm.js

@@ -0,0 +1,78 @@
+const test = require('tape').test ;
+const config = require('config');
+const opts = config.get('redis');
+const fs = require('fs');
+const logger = require('pino')({level: 'error'});
+process.on('unhandledRejection', (reason, p) => {
+  console.log('Unhandled Rejection at: Promise', p, 'reason:', reason);
+});
+
+const stats = {
+  increment: () => {},
+  histogram: () => {}
+};
+
+test('IBM - create access key', async(t) => {
+  const fn = require('..');
+  const {client, getIbmAccessToken} = fn(opts, logger);
+
+  if (!process.env.IBM_API_KEY ) {
+      t.pass('skipping IBM test since no IBM api_key provided');
+      t.end();
+      client.quit();
+      return;
+  }
+  try {
+    let obj = await getIbmAccessToken(process.env.IBM_API_KEY);
+    //console.log({obj}, 'received access token from IBM');
+    t.ok(obj.access_token && !obj.servedFromCache, 'successfull received access token from IBM');
+
+    obj = await getIbmAccessToken(process.env.IBM_API_KEY);
+    //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.flushall();
+    t.end();
+  }
+  catch (err) {
+    console.error(err);
+    t.end(err);
+  }
+  client.quit();
+});
+
+test('IBM - retrieve tts voices test', async(t) => {
+  const fn = require('..');
+  const {client, getTtsVoices} = fn(opts, logger);
+
+  if (!process.env.IBM_TTS_API_KEY || !process.env.IBM_TTS_REGION) {
+      t.pass('skipping IBM test since no IBM api_key and/or region provided');
+      t.end();
+      client.quit();
+      return;
+  }
+  try {
+    const opts = {
+      vendor: 'ibm',
+      credentials: {
+        tts_api_key: process.env.IBM_TTS_API_KEY,
+        tts_region: process.env.IBM_TTS_REGION
+      }
+    };
+    const obj = await getTtsVoices(opts);
+    const {voices} = obj.result;
+    //console.log(JSON.stringify(voices));
+    t.ok(voices.length > 0 && voices[0].language, 
+      `GetVoices: successfully retrieved ${voices.length} voices from IBM`);
+ 
+    await client.flushall();
+
+    t.end();
+
+  }
+  catch (err) {
+    console.error(err);
+    t.end(err);
+  }
+  client.quit();
+});

test/index.js

@@ -2,6 +2,6 @@ require('./docker_start');
 require('./synth');
 require('./list-voices');
 require('./aws');
-
+require('./ibm');
 require('./nuance');
 require('./docker_stop');

test/list-voices.js

@@ -38,6 +38,71 @@ test('Verbio - get Access key and voices', async(t) => {
   client.quit();
 });
 
+test('IBM - create access key', async(t) => {
+  const fn = require('..');
+  const {client, getIbmAccessToken} = fn(opts, logger);
+
+  if (!process.env.IBM_API_KEY ) {
+      t.pass('skipping IBM test since no IBM api_key provided');
+      t.end();
+      client.quit();
+      return;
+  }
+  try {
+    let obj = await getIbmAccessToken(process.env.IBM_API_KEY);
+    //console.log({obj}, 'received access token from IBM');
+    t.ok(obj.access_token && !obj.servedFromCache, 'successfull received access token from IBM');
+
+    obj = await getIbmAccessToken(process.env.IBM_API_KEY);
+    //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.flushall();
+    t.end();
+  }
+  catch (err) {
+    console.error(err);
+    t.end(err);
+  }
+  client.quit();
+});
+
+test('IBM - retrieve tts voices test', async(t) => {
+  const fn = require('..');
+  const {client, getTtsVoices} = fn(opts, logger);
+
+  if (!process.env.IBM_TTS_API_KEY || !process.env.IBM_TTS_REGION) {
+      t.pass('skipping IBM test since no IBM api_key and/or region provided');
+      t.end();
+      client.quit();
+      return;
+  }
+  try {
+    const opts = {
+      vendor: 'ibm',
+      credentials: {
+        tts_api_key: process.env.IBM_TTS_API_KEY,
+        tts_region: process.env.IBM_TTS_REGION
+      }
+    };
+    const obj = await getTtsVoices(opts);
+    const {voices} = obj.result;
+    //console.log(JSON.stringify(voices));
+    t.ok(voices.length > 0 && voices[0].language, 
+      `GetVoices: successfully retrieved ${voices.length} voices from IBM`);
+ 
+    await client.flushall();
+
+    t.end();
+
+  }
+  catch (err) {
+    console.error(err);
+    t.end(err);
+  }
+  client.quit();
+});
+
 test('Nuance hosted tests', async(t) => {
   const fn = require('..');
   const {client, getTtsVoices} = fn(opts, logger);

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);
@@ -41,7 +41,6 @@ test('Google speech synth tests', async(t) => {
       gender: 'FEMALE',
       text: 'This is a test.  This is only a test',
       salt: 'foo.bar',
-      renderForCaching: true,
     });
     t.ok(!opts.servedFromCache, `successfully synthesized google audio to ${opts.filePath}`);
 
@@ -56,7 +55,6 @@ test('Google speech synth tests', async(t) => {
       language: 'en-GB',
       gender: 'FEMALE',
       text: 'This is a test.  This is only a test',
-      renderForCaching: true,
     });
     t.ok(opts.servedFromCache, `successfully retrieved cached google audio from ${opts.filePath}`);
 
@@ -80,7 +78,6 @@ test('Google speech synth tests', async(t) => {
       language: 'en-GB',
       gender: 'FEMALE',
       text: 'This is a test.  This is only a test',
-      renderForCaching: true,
     });
     t.ok(!opts.servedFromCache, `successfully synthesized google audio regardless of current cache to ${opts.filePath}`);
   } catch (err) {
@@ -94,17 +91,14 @@ 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`);
+  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, {
+    let opts = await synthAudio(stats, {
       vendor: 'google',
       credentials: {
         credentials: {
@@ -115,10 +109,9 @@ GCP_CUSTOM_VOICE_FILE nor GCP_CUSTOM_VOICE_JSON_KEY provided, GCP_CUSTOM_VOICE_M
       language: 'en-AU',
       text: 'This is a test.  This is only a test',
       voice: {
-        reportedUsage: 'REALTIME',
+        reportedUsage:"REALTIME",
         model: process.env.GCP_CUSTOM_VOICE_MODEL
-      },
-      renderForCaching: true,
+      }
     });
     t.ok(!opts.servedFromCache, `successfully synthesized google custom voice audio to ${opts.filePath}`);
   } catch (err) {
@@ -128,417 +121,6 @@ GCP_CUSTOM_VOICE_FILE nor GCP_CUSTOM_VOICE_JSON_KEY provided, GCP_CUSTOM_VOICE_M
   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
-      },
-      renderForCaching: true,
-    });
-    t.ok(!opts.servedFromCache, `successfully synthesized google voice cloning audio to ${opts.filePath}`);
-  } catch (err) {
-    console.error(err);
-    t.end(err);
-  }
-  client.quit();
-});
-
-test('Google Gemini TTS synth tests', async(t) => {
-  const fn = require('..');
-  const {synthAudio, client} = fn(opts, logger);
-
-  if (!process.env.GCP_FILE && !process.env.GCP_JSON_KEY) {
-    t.pass('skipping Google Gemini TTS synth tests since neither GCP_FILE nor GCP_JSON_KEY provided');
-    return t.end();
-  }
-  try {
-    const str = process.env.GCP_JSON_KEY || fs.readFileSync(process.env.GCP_FILE);
-    const creds = JSON.parse(str);
-    const geminiModel = process.env.GCP_GEMINI_TTS_MODEL || 'gemini-2.5-flash-tts';
-
-    // Test Gemini TTS with model and instructions (both required for Gemini)
-    let result = await synthAudio(stats, {
-      vendor: 'google',
-      credentials: {
-        credentials: {
-          client_email: creds.client_email,
-          private_key: creds.private_key,
-        },
-      },
-      language: 'en-US',
-      voice: 'Kore',
-      model: geminiModel,
-      text: 'Hello, this is a test of Google Gemini text to speech.',
-      instructions: 'Speak clearly and naturally.',
-      renderForCaching: true,
-    });
-    t.ok(!result.servedFromCache, `successfully synthesized Google Gemini TTS audio to ${result.filePath}`);
-    t.ok(result.filePath.endsWith('.mp3'), 'Gemini TTS audio file has correct extension');
-
-    // Test Gemini TTS with different voice and instructions
-    result = await synthAudio(stats, {
-      vendor: 'google',
-      credentials: {
-        credentials: {
-          client_email: creds.client_email,
-          private_key: creds.private_key,
-        },
-      },
-      language: 'en-US',
-      voice: 'Charon',
-      model: geminiModel,
-      text: 'Welcome to our service. How can I help you today?',
-      instructions: 'Speak in a warm, friendly and professional tone.',
-      renderForCaching: true,
-    });
-    t.ok(!result.servedFromCache, `successfully synthesized Gemini TTS with instructions to ${result.filePath}`);
-
-    // Test cache retrieval
-    result = await synthAudio(stats, {
-      vendor: 'google',
-      credentials: {
-        credentials: {
-          client_email: creds.client_email,
-          private_key: creds.private_key,
-        },
-      },
-      language: 'en-US',
-      voice: 'Kore',
-      model: geminiModel,
-      text: 'Hello, this is a test of Google Gemini text to speech.',
-      instructions: 'Speak clearly and naturally.',
-      renderForCaching: true,
-    });
-    t.ok(result.servedFromCache, `successfully retrieved Gemini TTS audio from cache ${result.filePath}`);
-
-    // Test SSML stripping (Gemini doesn't support SSML)
-    result = await synthAudio(stats, {
-      vendor: 'google',
-      credentials: {
-        credentials: {
-          client_email: creds.client_email,
-          private_key: creds.private_key,
-        },
-      },
-      language: 'en-US',
-      voice: 'Leda',
-      model: geminiModel,
-      text: '<speak>This SSML should be stripped for Gemini TTS.</speak>',
-      instructions: 'Speak naturally.',
-      disableTtsCache: true,
-      renderForCaching: true,
-    });
-    t.ok(!result.servedFromCache, `successfully synthesized Gemini TTS with SSML stripped to ${result.filePath}`);
-
-  } catch (err) {
-    console.error(err);
-    t.end(err);
-  }
-  client.quit();
-});
-
-test('Google TTS streaming tests (!JAMBONES_DISABLE_TTS_STREAMING)', async(t) => {
-  // Ensure streaming is enabled (default behavior)
-  delete process.env.JAMBONES_DISABLE_TTS_STREAMING;
-
-  // Clear require cache to reload config with new env var
-  delete require.cache[require.resolve('../lib/config')];
-  delete require.cache[require.resolve('../lib/synth-audio')];
-  delete require.cache[require.resolve('..')];
-
-  const fn = require('..');
-  const {synthAudio, client} = fn(opts, logger);
-
-  if (!process.env.GCP_FILE && !process.env.GCP_JSON_KEY) {
-    t.pass('skipping Google TTS streaming tests since neither GCP_FILE nor GCP_JSON_KEY provided');
-    return t.end();
-  }
-
-  try {
-    const str = process.env.GCP_JSON_KEY || fs.readFileSync(process.env.GCP_FILE);
-    const creds = JSON.parse(str);
-    const geminiModel = process.env.GCP_GEMINI_TTS_MODEL || 'gemini-2.5-flash-tts';
-
-    // Test 1: Standard voice streaming (use_live_api=0)
-    let result = await synthAudio(stats, {
-      vendor: 'google',
-      credentials: {
-        credentials: {
-          client_email: creds.client_email,
-          private_key: creds.private_key,
-        },
-      },
-      language: 'en-US',
-      voice: 'en-US-Wavenet-D',
-      gender: 'MALE',
-      text: 'This is a test of standard voice streaming.',
-      disableTtsCache: true
-    });
-    t.ok(result.filePath.startsWith('say:'), 'Standard voice returns streaming say: path');
-    t.ok(result.filePath.includes('vendor=google'), 'Standard voice streaming path contains vendor=google');
-    t.ok(result.filePath.includes('api_mode=tts'), 'Standard voice uses api_mode=tts');
-    t.ok(result.filePath.includes('voice=en-US-Wavenet-D'), 'Standard voice streaming path contains voice');
-    // Verify credentials are base64 encoded (no raw JSON braces that would break FreeSWitch parsing)
-    t.ok(result.filePath.includes('credentials='), 'Standard voice streaming path contains credentials');
-    t.ok(!result.filePath.includes('credentials={'), 'Credentials are not raw JSON (base64 encoded)');
-
-    // Test 2: HD voice streaming (api_mode=live)
-    result = await synthAudio(stats, {
-      vendor: 'google',
-      credentials: {
-        credentials: {
-          client_email: creds.client_email,
-          private_key: creds.private_key,
-        },
-      },
-      language: 'en-US',
-      voice: 'en-US-Chirp3-HD-Charon',
-      text: 'This is a test of HD voice streaming.',
-      disableTtsCache: true
-    });
-    t.ok(result.filePath.startsWith('say:'), 'HD voice returns streaming say: path');
-    t.ok(result.filePath.includes('vendor=google'), 'HD voice streaming path contains vendor=google');
-    t.ok(result.filePath.includes('api_mode=live'), 'HD voice uses api_mode=live');
-    t.ok(result.filePath.includes('voice=en-US-Chirp3-HD-Charon'), 'HD voice streaming path contains voice');
-
-    // Test 3: Gemini TTS streaming (api_mode=gemini)
-    result = await synthAudio(stats, {
-      vendor: 'google',
-      credentials: {
-        credentials: {
-          client_email: creds.client_email,
-          private_key: creds.private_key,
-        },
-      },
-      language: 'en-US',
-      voice: 'Kore',
-      model: geminiModel,
-      text: 'This is a test of Gemini TTS streaming.',
-      instructions: 'Speak naturally.',
-      disableTtsCache: true
-    });
-    t.ok(result.filePath.startsWith('say:'), 'Gemini TTS returns streaming say: path');
-    t.ok(result.filePath.includes('vendor=google'), 'Gemini TTS streaming path contains vendor=google');
-    t.ok(result.filePath.includes('api_mode=gemini'), 'Gemini TTS uses api_mode=gemini');
-    t.ok(result.filePath.includes(`model_name=${geminiModel}`), 'Gemini TTS streaming path contains model_name');
-    t.ok(result.filePath.includes('prompt=Speak naturally.'), 'Gemini TTS streaming path contains prompt');
-
-    // Test 4: Gemini TTS with SSML stripping in streaming mode
-    result = await synthAudio(stats, {
-      vendor: 'google',
-      credentials: {
-        credentials: {
-          client_email: creds.client_email,
-          private_key: creds.private_key,
-        },
-      },
-      language: 'en-US',
-      voice: 'Leda',
-      model: geminiModel,
-      text: '<speak>This SSML should be stripped.</speak>',
-      instructions: 'Speak naturally.',
-      disableTtsCache: true
-    });
-    t.ok(result.filePath.startsWith('say:'), 'Gemini TTS with SSML returns streaming say: path');
-    t.ok(!result.filePath.includes('<speak>'), 'SSML tags are stripped from streaming path');
-    t.ok(result.filePath.includes('This SSML should be stripped.'), 'Text content is preserved after SSML stripping');
-
-    // Test 5: Gemini TTS with prompt containing special characters
-    result = await synthAudio(stats, {
-      vendor: 'google',
-      credentials: {
-        credentials: {
-          client_email: creds.client_email,
-          private_key: creds.private_key,
-        },
-      },
-      language: 'en-US',
-      voice: 'Kore',
-      model: geminiModel,
-      text: 'Testing special characters in prompt.',
-      options: { prompt: 'Speak in a warm, friendly tone' },
-      disableTtsCache: true
-    });
-    t.ok(result.filePath.startsWith('say:'), 'Gemini TTS with special chars returns streaming say: path');
-    // Commas in prompt should be replaced with semicolons
-    t.ok(result.filePath.includes('prompt=Speak in a warm; friendly tone'), 'Commas in prompt are escaped to semicolons');
-
-    // Test 6: options.apiMode override (force live on standard voice)
-    result = await synthAudio(stats, {
-      vendor: 'google',
-      credentials: {
-        credentials: {
-          client_email: creds.client_email,
-          private_key: creds.private_key,
-        },
-      },
-      language: 'en-US',
-      voice: 'en-US-Wavenet-D',
-      text: 'Testing apiMode option override to live.',
-      options: { apiMode: 'live' },
-      disableTtsCache: true
-    });
-    t.ok(result.filePath.includes('api_mode=live'), 'options.apiMode=live overrides default for standard voice');
-
-    // Test 7: options.apiMode override (force gemini without model)
-    result = await synthAudio(stats, {
-      vendor: 'google',
-      credentials: {
-        credentials: {
-          client_email: creds.client_email,
-          private_key: creds.private_key,
-        },
-      },
-      language: 'en-US',
-      voice: 'Kore',
-      text: 'Testing apiMode option override to gemini.',
-      options: { apiMode: 'gemini' },
-      disableTtsCache: true
-    });
-    t.ok(result.filePath.includes('api_mode=gemini'), 'options.apiMode=gemini overrides default');
-
-    // Test 8: options.apiMode override (force tts on HD voice)
-    result = await synthAudio(stats, {
-      vendor: 'google',
-      credentials: {
-        credentials: {
-          client_email: creds.client_email,
-          private_key: creds.private_key,
-        },
-      },
-      language: 'en-US',
-      voice: 'en-US-Chirp3-HD-Charon',
-      text: 'Testing apiMode option override to tts on HD voice.',
-      options: { apiMode: 'tts' },
-      disableTtsCache: true
-    });
-    t.ok(result.filePath.includes('api_mode=tts'), 'options.apiMode=tts overrides HD voice default');
-
-  } catch (err) {
-    console.error(err);
-    t.end(err);
-  }
-  client.quit();
-});
-
-test('Google TTS non-streaming tests (JAMBONES_DISABLE_TTS_STREAMING=true)', async(t) => {
-  // Enable streaming disable flag
-  process.env.JAMBONES_DISABLE_TTS_STREAMING = 'true';
-
-  // Clear require cache to reload config with new env var
-  delete require.cache[require.resolve('../lib/config')];
-  delete require.cache[require.resolve('../lib/synth-audio')];
-  delete require.cache[require.resolve('..')];
-
-  const fn = require('..');
-  const {synthAudio, client} = fn(opts, logger);
-
-  if (!process.env.GCP_FILE && !process.env.GCP_JSON_KEY) {
-    t.pass('skipping Google TTS non-streaming tests since neither GCP_FILE nor GCP_JSON_KEY provided');
-    delete process.env.JAMBONES_DISABLE_TTS_STREAMING;
-    return t.end();
-  }
-
-  try {
-    const str = process.env.GCP_JSON_KEY || fs.readFileSync(process.env.GCP_FILE);
-    const creds = JSON.parse(str);
-    const geminiModel = process.env.GCP_GEMINI_TTS_MODEL || 'gemini-2.5-flash-tts';
-
-    // Test 1: Standard voice falls back to non-streaming API
-    let result = await synthAudio(stats, {
-      vendor: 'google',
-      credentials: {
-        credentials: {
-          client_email: creds.client_email,
-          private_key: creds.private_key,
-        },
-      },
-      language: 'en-US',
-      voice: 'en-US-Wavenet-D',
-      gender: 'MALE',
-      text: 'This is a test with streaming disabled.',
-      disableTtsCache: true
-    });
-    t.ok(!result.filePath.startsWith('say:'), 'Standard voice does NOT return streaming say: path when disabled');
-    t.ok(result.filePath.endsWith('.mp3'), 'Standard voice returns mp3 file path');
-
-    // Test 2: HD voice falls back to non-streaming API
-    result = await synthAudio(stats, {
-      vendor: 'google',
-      credentials: {
-        credentials: {
-          client_email: creds.client_email,
-          private_key: creds.private_key,
-        },
-      },
-      language: 'en-US',
-      voice: 'en-US-Chirp3-HD-Charon',
-      text: 'This is a test of HD voice with streaming disabled.',
-      disableTtsCache: true
-    });
-    t.ok(!result.filePath.startsWith('say:'), 'HD voice does NOT return streaming say: path when disabled');
-    t.ok(result.filePath.endsWith('.mp3'), 'HD voice returns mp3 file path');
-
-    // Test 3: Gemini TTS falls back to non-streaming API
-    result = await synthAudio(stats, {
-      vendor: 'google',
-      credentials: {
-        credentials: {
-          client_email: creds.client_email,
-          private_key: creds.private_key,
-        },
-      },
-      language: 'en-US',
-      voice: 'Kore',
-      model: geminiModel,
-      text: 'This is a test of Gemini TTS with streaming disabled.',
-      instructions: 'Speak naturally.',
-      disableTtsCache: true
-    });
-    t.ok(!result.filePath.startsWith('say:'), 'Gemini TTS does NOT return streaming say: path when disabled');
-    t.ok(result.filePath.endsWith('.mp3'), 'Gemini TTS returns mp3 file path');
-
-  } catch (err) {
-    console.error(err);
-    t.end(err);
-  } finally {
-    // Clean up: restore default behavior
-    delete process.env.JAMBONES_DISABLE_TTS_STREAMING;
-    delete require.cache[require.resolve('../lib/config')];
-    delete require.cache[require.resolve('../lib/synth-audio')];
-    delete require.cache[require.resolve('..')];
-  }
-  client.quit();
-});
-
 test('AWS speech synth tests', async(t) => {
   const fn = require('..');
   const {synthAudio, client} = fn(opts, logger);
@@ -558,7 +140,6 @@ test('AWS speech synth tests', async(t) => {
       language: 'en-US',
       voice: 'Joey',
       text: 'This is a test.  This is only a test',
-      renderForCaching: true,
     });
     t.ok(!opts.servedFromCache, `successfully synthesized aws audio to ${opts.filePath}`);
 
@@ -572,7 +153,6 @@ test('AWS speech synth tests', async(t) => {
       language: 'en-US',
       voice: 'Joey',
       text: 'This is a test.  This is only a test',
-      renderForCaching: true,
     });
     t.ok(opts.servedFromCache, `successfully retrieved aws audio from cache ${opts.filePath}`);
   } catch (err) {
@@ -872,6 +452,46 @@ test('Nvidia speech synth tests', async(t) => {
   client.quit();
 });
 
+test('IBM watson speech synth tests', async(t) => {
+  const fn = require('..');
+  const {synthAudio, client} = fn(opts, logger);
+
+  if (!process.env.IBM_TTS_API_KEY || !process.env.IBM_TTS_REGION) {
+    t.pass('skipping IBM Watson speech synth tests since IBM_TTS_API_KEY or IBM_TTS_API_KEY not provided');
+    return t.end();
+  }
+  const text = `<speak> Hi there and welcome to jambones! jambones is the <sub alias="seapass">CPaaS</sub> designed with the needs of communication service providers in mind. This is an example of simple text-to-speech, but there is so much more you can do. Try us out!</speak>`;
+  try {
+    let opts = await synthAudio(stats, {
+      vendor: 'ibm',
+      credentials: {
+        tts_api_key: process.env.IBM_TTS_API_KEY,
+        tts_region: process.env.IBM_TTS_REGION,
+      },
+      language: 'en-US',
+      voice: 'en-US_AllisonV2Voice',
+      text,
+    });
+    t.ok(!opts.servedFromCache, `successfully synthesized ibm audio to ${opts.filePath}`);
+
+    opts = await synthAudio(stats, {
+      vendor: 'ibm',
+      credentials: {
+        tts_api_key: process.env.IBM_TTS_API_KEY,
+        tts_region: process.env.IBM_TTS_REGION,
+      },
+      language: 'en-US',
+      voice: 'en-US_AllisonV2Voice',
+      text,
+    });
+    t.ok(opts.servedFromCache, `successfully retrieved ibm audio from cache ${opts.filePath}`);
+  } catch (err) {
+    console.error(JSON.stringify(err));
+    t.end(err);
+  }
+  client.quit();
+});
+
 test('Custom Vendor speech synth tests', async(t) => {
   const fn = require('..');
   const {synthAudio, client} = fn(opts, logger);
@@ -887,10 +507,8 @@ test('Custom Vendor speech synth tests', async(t) => {
       language: 'en-US',
       voice: 'English-US.Female-1',
       text: 'This is a test.  This is only a test',
-      renderForCaching: true
     });
     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');
@@ -898,22 +516,6 @@ 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',
-      renderForCaching: true
-    });
-    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: {
@@ -924,7 +526,6 @@ test('Custom Vendor speech synth tests', async(t) => {
       language: 'en-US',
       voice: 'English-US.Female-1',
       text: '<speak>This is a test.  This is only a test</speak>',
-      renderForCaching: true
     });
     t.ok(!opts.servedFromCache, `successfully synthesized Custom Vendor audio to ${opts.filePath}`);
     obj = await getJSON(`http://127.0.0.1:3100/lastRequest/somethingnew2`);
@@ -973,9 +574,9 @@ test('Elevenlabs speech synth tests', async(t) => {
     t.end(err);
   }
   client.quit();
-});
+})
 
-const testPlayHT = async(t, voice_engine) => {
+test('PlayHT speech synth tests', async(t) => {
   const fn = require('..');
   const {synthAudio, client} = fn(opts, logger);
 
@@ -983,26 +584,26 @@ const testPlayHT = async(t, voice_engine) => {
     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();
+  const text = 'Hi there and welcome to jambones!';
   try {
-    const opts = await synthAudio(stats, {
+    let opts = await synthAudio(stats, {
       vendor: 'playht',
       credentials: {
         api_key: process.env.PLAYHT_API_KEY,
         user_id: process.env.PLAYHT_USER_ID,
-        voice_engine,
+        voice_engine: 'PlayHT2.0-turbo',
         options: JSON.stringify({
-          quality: 'medium',
+          quality: "medium",
           speed: 1,
           seed: 1,
           temperature: 1,
-          emotion: 'female_happy',
+          emotion: "female_happy",
           voice_guidance: 3,
           style_guidance: 20,
           text_guidance: 1,
         })
       },
-      language: 'english',
+      language: 'en-US',
       voice: 's3://voice-cloning-zero-shot/d9ff78ba-d016-47f6-b0ef-dd630f59414e/female-cs/manifest.json',
       text,
       renderForCaching: true
@@ -1014,110 +615,9 @@ const testPlayHT = async(t, voice_engine) => {
     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 cartesia eleven audio to ${opts.filePath}`);
-
-  } catch (err) {
-    console.error(JSON.stringify(err));
-    t.end(err);
-  }
-  client.quit();
-});
-
-test('inworld speech synth', async(t) => {
-  const fn = require('..');
-  const {synthAudio, client} = fn(opts, logger);
-
-  if (!process.env.INWORLD_API_KEY) {
-    t.pass('skipping inworld speech synth tests since INWORLD_API_KEY is not provided');
-    return t.end();
-  }
-  const text = 'Hi there and welcome to jambones!';
-  try {
-    const opts = await synthAudio(stats, {
-      vendor: 'inworld',
-      credentials: {
-        api_key: process.env.INWORLD_API_KEY,
-        model_id: 'inworld-tts-1'
-      },
-      language: 'en',
-      voice: 'Ashley',
-      text,
-      renderForCaching: true
-    });
-    t.ok(!opts.servedFromCache, `successfully synthesized inworld audio to ${opts.filePath}`);
-
-  } catch (err) {
-    console.error(JSON.stringify(err));
-    t.end(err);
-  }
-  client.quit();
-});
-
-test('resemble speech synth', async(t) => {
-  const fn = require('..');
-  const {synthAudio, client} = fn(opts, logger);
-
-  if (!process.env.RESEMBLE_API_KEY) {
-    t.pass('skipping resemble speech synth tests since RESEMBLE_API_KEY is not provided');
-    return t.end();
-  }
-  const text = '<speak prompt="Speak in an excited, upbeat tone">Hello from Resemble!</speak>';
-  try {
-    const opts = await synthAudio(stats, {
-      vendor: 'resemble',
-      credentials: {
-        api_key: process.env.RESEMBLE_API_KEY,
-      },
-      language: 'en',
-      voice: '3f5fb9f1',
-      text,
-      renderForCaching: true
-    });
-    t.ok(!opts.servedFromCache, `successfully synthesized resemble audio to ${opts.filePath}`);
-
-  } catch (err) {
-    console.error(JSON.stringify(err));
-    t.end(err);
-  }
-  client.quit();
-});
-
-test('rimelabs speech synth tests mist', async(t) => {
+test('rimelabs speech synth tests', async(t) => {
   const fn = require('..');
   const {synthAudio, client} = fn(opts, logger);
 
@@ -1127,7 +627,7 @@ test('rimelabs speech synth tests mist', async(t) => {
   }
   const text = 'Hi there and welcome to jambones!';
   try {
-    const opts = await synthAudio(stats, {
+    let opts = await synthAudio(stats, {
       vendor: 'rimelabs',
       credentials: {
         api_key: process.env.RIMELABS_API_KEY,
@@ -1137,7 +637,7 @@ test('rimelabs speech synth tests mist', async(t) => {
           reduceLatency: false
         })
       },
-      language: 'eng',
+      language: 'en-US',
       voice: 'amber',
       text,
       renderForCaching: true
@@ -1151,40 +651,6 @@ test('rimelabs speech synth tests mist', async(t) => {
   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);
@@ -1284,12 +750,11 @@ test('TTS Cache tests', async(t) => {
     // save some random tts keys to cache
     const minRecords = 8;
     for (const i in Array(minRecords).fill(0)) {
-      await client.set(makeSynthKey({vendor: i, language: i, voice: i, engine: i, model: i, text: i,
-        instructions: i}), i);
+      await client.set(makeSynthKey({vendor: i, language: i, voice: i, engine: 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`);
 
@@ -1304,7 +769,7 @@ test('TTS Cache tests', async(t) => {
   try {
     // save some random tts keys to cache
     for (const i in Array(10).fill(0)) {
-      await client.set(makeSynthKey({vendor: i, language: i, voice: i, engine: i, text: i, instructions: 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!'};
@@ -1320,15 +785,24 @@ 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.keys('tts:*');
-    t.ok(cached.length >= 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';
+    // 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));
     t.end(err);
@@ -1342,10 +816,10 @@ 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.set(makeSynthKey({account_sid, vendor: i, language: i, voice: i, engine: i, text: i, instructions: 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.set(makeSynthKey({account_sid: account_sid2, vendor: i, language: i, voice: i, engine: i, text: i, instructions: 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}`);