1.0.1

google tts support api_mode

.github/workflows/ci.yml

@@ -13,11 +13,6 @@ jobs:
         with:
           node-version: '20'
       - 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
@@ -28,9 +23,7 @@ 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 }}

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/get-ibm-access-token.js

@@ -1,48 +0,0 @@
-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,8 +3,6 @@ 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');
@@ -12,21 +10,6 @@ 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;
 
@@ -165,14 +148,12 @@ const getVerbioVoices = async(client, logger, credentials) => {
 async function getTtsVoices(client, createHash, retrieveHash, logger, {vendor, credentials}) {
   logger = logger || noopLogger;
 
-  assert.ok(['nuance', 'ibm', 'google', 'aws', 'polly', 'verbio'].includes(vendor),
+  assert.ok(['nuance', '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/synth-audio.js

@@ -6,8 +6,7 @@ const { PollyClient, SynthesizeSpeechCommand } = require('@aws-sdk/client-polly'
 const { CartesiaClient } = require('@cartesia/cartesia-js');
 
 const sdk = require('microsoft-cognitiveservices-speech-sdk');
-const TextToSpeechV1 = require('ibm-watson/text-to-speech/v1');
-const { IamAuthenticator } = require('ibm-watson/auth');
+
 const {
   ResultReason,
   SpeechConfig,
@@ -96,7 +95,7 @@ async function synthAudio(client, createHash, retrieveHash, logger, stats, { acc
   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', 'elevenlabs',
     'whisper', 'deepgram', 'playht', 'rimelabs', 'verbio', 'cartesia', 'inworld', 'resemble'].includes(vendor) ||
   vendor.startsWith('custom'),
   `synthAudio supported vendors are google, aws, microsoft, nuance, nvidia and wellsaid ..etc, not ${vendor}`);
@@ -122,11 +121,6 @@ async function synthAudio(client, createHash, retrieveHash, logger, stats, { acc
     assert.ok(language, 'synthAudio requires language when nvidia is used');
     assert.ok(credentials.riva_server_uri, 'synthAudio requires riva_server_uri in credentials when nvidia is used');
   }
-  else if ('ibm' === vendor) {
-    assert.ok(voice, 'synthAudio requires voice when ibm is used');
-    assert.ok(credentials.tts_region, 'synthAudio requires tts_region in credentials when ibm watson is used');
-    assert.ok(credentials.tts_api_key, 'synthAudio requires tts_api_key in credentials when nuance is used');
-  }
   else if ('wellsaid' === vendor) {
     language = 'en-US'; // WellSaid only supports English atm
     assert.ok(voice, 'synthAudio requires voice when wellsaid is used');
@@ -204,7 +198,10 @@ async function synthAudio(client, createHash, retrieveHash, logger, stats, { acc
     const startAt = process.hrtime();
     switch (vendor) {
       case 'google':
-        audioData = await synthGoogle(logger, {credentials, stats, language, voice, gender, key, text});
+        audioData = await synthGoogle(logger, {
+          credentials, stats, language, voice, gender, key, text, model, options, instructions,
+          renderForCaching, disableTtsStreaming, disableTtsCache
+        });
         break;
       case 'aws':
       case 'polly':
@@ -227,9 +224,6 @@ async function synthAudio(client, createHash, retrieveHash, logger, stats, { acc
         audioData = await synthNvidia(client, logger, {credentials, stats, language, voice, model, key, text,
           renderForCaching, disableTtsStreaming, disableTtsCache});
         break;
-      case 'ibm':
-        audioData = await synthIbm(logger, {credentials, stats, voice, key, text});
-        break;
       case 'wellsaid':
         audioData = await synthWellSaid(logger, {credentials, stats, language, voice, key, text});
         break;
@@ -409,111 +403,129 @@ const synthPolly = async(createHash, retrieveHash, logger,
   }
 };
 
-const synthGoogle = async(logger, {credentials, stats, language, voice, gender, text}) => {
-  const client = new ttsGoogle.TextToSpeechClient(credentials);
-  // If google custom voice cloning is used.
-  // At this time 31 Oct 2024, google node sdk has not support voice cloning yet.
-  if (typeof voice === 'object' && voice.voice_cloning_key) {
-    try {
-      const accessToken = await client.auth.getAccessToken();
-      const projectId = await client.getProjectId();
 
-      const post = bent('https://texttospeech.googleapis.com', 'POST', 'json', {
-        'Authorization': `Bearer ${accessToken}`,
-        'x-goog-user-project': projectId,
-        'Content-Type': 'application/json; charset=utf-8'
-      });
+const synthGoogle = async(logger, {
+  credentials, stats, language, voice, gender, key, text, model, options, instructions,
+  renderForCaching, disableTtsStreaming, disableTtsCache
+}) => {
+  const isGemini = !!model;
+  const isVoiceCloning = typeof voice === 'object' && voice.voice_cloning_key;
+  // HD voices have pattern like en-US-Chirp3-HD-Charon
+  const isHDVoice = typeof voice === 'string' && voice.includes('-HD-');
 
-      const payload = {
-        input: {
-          text
-        },
-        voice: {
-          language_code: language,
-          voice_clone: {
-            voice_cloning_key: voice.voice_cloning_key
-          }
-        },
-        audioConfig: {
-          // Cloning voice at this time still in v1 beta version, and it support LINEAR16 in Wav format, 24.000Hz
-          audioEncoding: 'LINEAR16',
-          sample_rate_hertz: 24000
-        }
-      };
-
-      const wav = await post('/v1beta1/text:synthesize', payload);
-      return {
-        audioContent: Buffer.from(wav.audioContent, 'base64'),
-        extension: 'wav',
-        sampleRate: 24000
-      };
-    } catch (err) {
-      logger.info({err: await err.text()}, 'synthGoogle returned error');
-      throw err;
+  // Streaming support for Google TTS (Gemini, HD voices, and standard voices)
+  // Voice cloning does not support streaming
+  if (!isVoiceCloning && !JAMBONES_DISABLE_TTS_STREAMING && !renderForCaching && !disableTtsStreaming) {
+    // Strip SSML tags for Gemini TTS (it doesn't support SSML)
+    let inputText = text;
+    if (isGemini && text.startsWith('<speak>')) {
+      inputText = text.replace(/<[^>]*>/g, '').trim();
+      logger.info('synthGoogle: Gemini TTS does not support SSML, stripped tags from input');
     }
+
+    let params = '{';
+    params += `credentials=${Buffer.from(JSON.stringify(credentials.credentials)).toString('base64')}`;
+    params += `,playback_id=${key}`;
+    params += ',vendor=google';
+    params += `,voice=${voice}`;
+    params += `,language_code=${language || 'en-US'}`;
+    params += `,write_cache_file=${disableTtsCache ? 0 : 1}`;
+    // api_mode: tts (standard), live (HD voices), gemini (Gemini TTS)
+    const apiMode = options?.apiMode || (isGemini ? 'gemini' : (isHDVoice ? 'live' : 'tts'));
+    params += `,api_mode=${apiMode}`;
+    if (model) params += `,model_name=${model}`;
+    if (gender) params += `,gender=${gender}`;
+    // comma is used to separate parameters in freeswitch tts module
+    const prompt = options?.prompt || instructions;
+    if (prompt) params += `,prompt=${prompt.replace(/\n/g, ' ').replace(/,/g, ';')}`;
+    params += '}';
+
+    return {
+      filePath: `say:${params}${(isGemini ? inputText : text).replace(/\n/g, ' ')}`,
+      servedFromCache: false,
+      rtt: 0
+    };
   }
 
-  const opts = {
-    voice: {
-      ...(typeof voice === 'string' && {name: voice}),
-      ...(typeof voice === 'object' && {customVoice: voice}),
+  const client = new ttsGoogle.TextToSpeechClient(credentials);
+
+  // Build input based on voice type
+  let input;
+  if (isGemini) {
+    // Gemini TTS does not support SSML - strip tags if present
+    let inputText = text;
+    if (text.startsWith('<speak>')) {
+      inputText = text.replace(/<[^>]*>/g, '').trim();
+      logger.info('synthGoogle: Gemini TTS does not support SSML, stripped tags from input');
+    }
+    // Use instructions as prompt for Gemini TTS style control, options.prompt can override
+    const prompt = options?.prompt || instructions;
+    input = {
+      text: inputText,
+      ...(prompt && { prompt })
+    };
+  } else {
+    input = text.startsWith('<speak>') ? { ssml: text } : { text };
+  }
+
+  // Build voice selection params based on voice type
+  let voiceParams;
+  if (isGemini) {
+    voiceParams = {
+      languageCode: language || 'en-US',
+      name: voice,
+      modelName: model
+    };
+  } else if (isVoiceCloning) {
+    voiceParams = {
+      languageCode: language,
+      voiceClone: {
+        voiceCloningKey: voice.voice_cloning_key
+      }
+    };
+  } else {
+    voiceParams = {
+      ...(typeof voice === 'string' && { name: voice }),
+      ...(typeof voice === 'object' && { customVoice: voice }),
       languageCode: language,
       ssmlGender: gender || 'SSML_VOICE_GENDER_UNSPECIFIED'
-    },
-    audioConfig: {audioEncoding: 'MP3'}
-  };
-  Object.assign(opts, {input: text.startsWith('<speak>') ? {ssml: text} : {text}});
+    };
+  }
+
+  // Build audio config based on voice type
+  let audioConfig;
+  let extension;
+  let sampleRate;
+  if (isVoiceCloning) {
+    audioConfig = { audioEncoding: 'LINEAR16', sampleRateHertz: 24000 };
+    extension = 'wav';
+    sampleRate = 24000;
+  } else {
+    audioConfig = { audioEncoding: 'MP3' };
+    extension = 'mp3';
+    sampleRate = 8000;
+  }
+
+  const opts = { input, voice: voiceParams, audioConfig };
+
   try {
-    const responses = await client.synthesizeSpeech(opts);
+    logger.debug({ opts }, 'synthGoogle: request');
+    const [response] = await client.synthesizeSpeech(opts);
     stats.increment('tts.count', ['vendor:google', 'accepted:yes']);
     client.close();
     return {
-      audioContent: responses[0].audioContent,
-      extension: 'mp3',
-      sampleRate: 8000
+      audioContent: response.audioContent,
+      extension,
+      sampleRate
     };
   } catch (err) {
-    console.error(err);
-    logger.info({err, opts}, 'synthAudio: Error synthesizing speech using google');
+    logger.info({ err, opts }, 'synthAudio: Error synthesizing speech using google');
     stats.increment('tts.count', ['vendor:google', 'accepted:no']);
     client && client.close();
     throw err;
   }
 };
 
-const synthIbm = async(logger, {credentials, stats, voice, text}) => {
-  const {tts_api_key, tts_region} = credentials;
-  const params = {
-    text,
-    voice,
-    accept: 'audio/mp3'
-  };
-
-  try {
-    const textToSpeech = new TextToSpeechV1({
-      authenticator: new IamAuthenticator({
-        apikey: tts_api_key,
-      }),
-      serviceUrl: `https://api.${tts_region}.text-to-speech.watson.cloud.ibm.com`
-    });
-
-    const r = await textToSpeech.synthesize(params);
-    const chunks = [];
-    for await (const chunk of r.result) {
-      chunks.push(chunk);
-    }
-    return {
-      audioContent: Buffer.concat(chunks),
-      extension: 'mp3',
-      sampleRate: 8000
-    };
-  } catch (err) {
-    logger.info({err, params}, 'synthAudio: Error synthesizing speech using ibm');
-    stats.increment('tts.count', ['vendor:ibm', 'accepted:no']);
-    throw new Error(err.statusText || err.message);
-  }
-};
-
 async function _synthOnPremMicrosoft(logger, {
   credentials,
   language,
@@ -915,7 +927,7 @@ const synthElevenlabs = async(logger, {
   const optimize_streaming_latency = opts.optimize_streaming_latency ?
     `?optimize_streaming_latency=${opts.optimize_streaming_latency}` : '';
   try {
-    const post = bent(`https://${api_uri}`, 'POST', 'buffer', {
+    const post = bent(`https://${api_uri || 'api.elevenlabs.io'}`, 'POST', 'buffer', {
       'xi-api-key': api_key,
       'Accept': 'audio/mpeg',
       'Content-Type': 'application/json'

lib/utils.js

@@ -54,12 +54,6 @@ 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);
@@ -143,7 +137,7 @@ const createRivaClient = async(rivaUri) => {
 module.exports = {
   makeSynthKey,
   makeNuanceKey,
-  makeIbmKey,
+
   makePlayhtKey,
   makeAwsKey,
   makeVerbioKey,

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jambonz/speech-utils",
-  "version": "0.2.27",
+  "version": "1.0.1",
   "description": "TTS-related speech utilities for jambonz",
   "main": "index.js",
   "author": "Dave Horton",
@@ -30,20 +30,19 @@
     "@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": "^5.5.0",
+    "@google-cloud/text-to-speech": "^6.4.0",
     "@grpc/grpc-js": "^1.9.14",
     "@jambonz/realtimedb-helpers": "^0.8.7",
     "bent": "^7.3.12",
     "debug": "^4.3.4",
     "form-urlencoded": "^6.1.4",
     "google-protobuf": "^3.21.2",
-    "ibm-watson": "^11.0.0",
     "microsoft-cognitiveservices-speech-sdk": "1.38.0",
     "openai": "^4.98.0",
     "undici": "^7.5.0"
   },
   "devDependencies": {
-    "config": "^3.3.11",
+    "config": "^4.2.0",
     "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

@@ -1,78 +0,0 @@
-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,71 +38,6 @@ 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

@@ -41,6 +41,7 @@ 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}`);
 
@@ -55,6 +56,7 @@ 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}`);
 
@@ -78,6 +80,7 @@ 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) {
@@ -114,7 +117,8 @@ GCP_CUSTOM_VOICE_FILE nor GCP_CUSTOM_VOICE_JSON_KEY provided, GCP_CUSTOM_VOICE_M
       voice: {
         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) {
@@ -132,7 +136,7 @@ test('Google speech voice cloning synth tests', async(t) => {
     !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 
+    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();
@@ -156,7 +160,8 @@ GCP_VOICE_CLONING_FILE nor GCP_VOICE_CLONING_JSON_KEY is not provided`);
       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) {
@@ -166,6 +171,374 @@ GCP_VOICE_CLONING_FILE nor GCP_VOICE_CLONING_JSON_KEY is not provided`);
   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);
@@ -499,46 +872,6 @@ 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);