0.2.22

use synth key as playback id

lib/add-file-to-cache.js

@@ -25,7 +25,7 @@ function getExtensionAndSampleRate(path) {
 }
 
 async function addFileToCache(client, logger, path,
-  {account_sid, vendor, language, voice, deploymentId, engine, model, text}) {
+  {account_sid, vendor, language, voice, deploymentId, engine, model, text, instructions}) {
   let key;
   logger = logger || noopLogger;
 
@@ -38,6 +38,7 @@ async function addFileToCache(client, logger, path,
       engine,
       model,
       text,
+      instructions
     });
     const [extension, sampleRate] = getExtensionAndSampleRate(path);
     const audioBuffer = await fs.readFile(path);

lib/config.js

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

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

lib/synth-audio.js

@@ -47,12 +47,12 @@ const {
   JAMBONES_HTTP_PROXY_PORT,
   JAMBONES_TTS_CACHE_DURATION_MINS,
   JAMBONES_TTS_TRIM_SILENCE,
+  JAMBONES_AZURE_ENABLE_SSML
 } = require('./config');
 const EXPIRES = JAMBONES_TTS_CACHE_DURATION_MINS;
 const OpenAI = require('openai');
 const getAwsAuthToken = require('./get-aws-sts-token');
 
-
 const trimTrailingSilence = (buffer) => {
   assert.ok(buffer instanceof Buffer, 'trimTrailingSilence - argument is not a Buffer');
 
@@ -89,7 +89,7 @@ const trimTrailingSilence = (buffer) => {
  */
 async function synthAudio(client, createHash, retrieveHash, logger, stats, { account_sid,
   vendor, language, voice, gender, text, engine, salt, model, credentials, deploymentId,
-  disableTtsCache, renderForCaching = false, disableTtsStreaming, options
+  disableTtsCache, renderForCaching = false, disableTtsStreaming, options, instructions
 }) {
   let audioData;
   let servedFromCache = false;
@@ -97,7 +97,7 @@ async function synthAudio(client, createHash, retrieveHash, logger, stats, { acc
   logger = logger || noopLogger;
 
   assert.ok(['google', 'aws', 'polly', 'microsoft', 'wellsaid', 'nuance', 'nvidia', 'ibm', 'elevenlabs',
-    'whisper', 'deepgram', 'playht', 'rimelabs', 'verbio', 'cartesia'].includes(vendor) ||
+    '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}`);
   if ('google' === vendor) {
@@ -140,6 +140,10 @@ async function synthAudio(client, createHash, retrieveHash, logger, stats, { acc
     assert.ok(credentials.api_key, 'synthAudio requires api_key when playht is used');
     assert.ok(credentials.user_id, 'synthAudio requires user_id when playht is used');
     assert.ok(credentials.voice_engine, 'synthAudio requires voice_engine when playht is used');
+  } else if ('inworld' === vendor) {
+    assert.ok(voice, 'synthAudio requires voice when inworld is used');
+    assert.ok(credentials.api_key, 'synthAudio requires api_key when inworld is used');
+    assert.ok(credentials.model_id, 'synthAudio requires model_id when inworld is used');
   } else if ('rimelabs' === vendor) {
     assert.ok(voice, 'synthAudio requires voice when rimelabs is used');
     assert.ok(credentials.api_key, 'synthAudio requires api_key when rimelabs is used');
@@ -161,6 +165,9 @@ async function synthAudio(client, createHash, retrieveHash, logger, stats, { acc
   } else if ('cartesia' === vendor) {
     assert.ok(credentials.api_key, 'synthAudio requires api_key when cartesia is used');
     assert.ok(credentials.model_id, 'synthAudio requires model_id when cartesia is used');
+  } else if (vendor === 'resemble') {
+    assert.ok(voice, 'synthAudio requires voice when resemble is used');
+    assert.ok(credentials.api_key, 'synthAudio requires api_key when resemble is used');
   }
 
   const key = makeSynthKey({
@@ -171,7 +178,8 @@ async function synthAudio(client, createHash, retrieveHash, logger, stats, { acc
     engine,
     // model or model_id is used to identify the tts cache.
     model: model || credentials.model_id,
-    text
+    text,
+    instructions
   });
 
   debug(`synth key is ${key}`);
@@ -196,66 +204,74 @@ 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, text});
+        audioData = await synthGoogle(logger, {credentials, stats, language, voice, gender, key, text});
         break;
       case 'aws':
       case 'polly':
         vendorLabel = 'aws';
         audioData = await synthPolly(createHash, retrieveHash, logger,
-          {credentials, stats, language, voice, text, engine});
+          {credentials, stats, language, voice, key, text, engine, renderForCaching, disableTtsStreaming});
         break;
       case 'azure':
       case 'microsoft':
         vendorLabel = 'microsoft';
-        audioData = await synthMicrosoft(logger, {credentials, stats, language, voice, text, deploymentId,
+        audioData = await synthMicrosoft(logger, {credentials, stats, language, voice, key, text, deploymentId,
           renderForCaching, disableTtsStreaming});
         break;
       case 'nuance':
         model = model || 'enhanced';
-        audioData = await synthNuance(client, logger, {credentials, stats, voice, model, text});
+        audioData = await synthNuance(client, logger, {credentials, stats, voice, model, key, text});
         break;
       case 'nvidia':
-        audioData = await synthNvidia(client, logger, {credentials, stats, language, voice, model, text,
+        audioData = await synthNvidia(client, logger, {credentials, stats, language, voice, model, key, text,
           renderForCaching, disableTtsStreaming});
         break;
       case 'ibm':
-        audioData = await synthIbm(logger, {credentials, stats, voice, text});
+        audioData = await synthIbm(logger, {credentials, stats, voice, key, text});
         break;
       case 'wellsaid':
-        audioData = await synthWellSaid(logger, {credentials, stats, language, voice, text});
+        audioData = await synthWellSaid(logger, {credentials, stats, language, voice, key, text});
         break;
       case 'elevenlabs':
         audioData = await synthElevenlabs(logger, {
-          credentials, options, stats, language, voice, text, renderForCaching, disableTtsStreaming});
+          credentials, options, stats, language, voice, key, text, renderForCaching, disableTtsStreaming});
         break;
       case 'playht':
         audioData = await synthPlayHT(client, logger, {
-          credentials, options, stats, language, voice, text, renderForCaching, disableTtsStreaming});
+          credentials, options, stats, language, voice, key, text, renderForCaching, disableTtsStreaming});
         break;
       case 'cartesia':
         audioData = await synthCartesia(logger, {
-          credentials, options, stats, language, voice, text, renderForCaching, disableTtsStreaming});
+          credentials, options, stats, language, voice, key, text, renderForCaching, disableTtsStreaming});
+        break;
+      case 'inworld':
+        audioData = await synthInworld(logger, {
+          credentials, options, stats, language, voice, key, text, renderForCaching, disableTtsStreaming});
         break;
       case 'rimelabs':
         audioData = await synthRimelabs(logger, {
-          credentials, options, stats, language, voice, text, renderForCaching, disableTtsStreaming});
+          credentials, options, stats, language, voice, key, text, renderForCaching, disableTtsStreaming});
         break;
       case 'whisper':
         audioData = await synthWhisper(logger, {
-          credentials, stats, voice, text, renderForCaching, disableTtsStreaming});
+          credentials, stats, voice, key, text, instructions, renderForCaching, disableTtsStreaming});
         break;
       case 'verbio':
         audioData = await synthVerbio(client, logger, {
-          credentials, stats, voice, text, renderForCaching, disableTtsStreaming});
+          credentials, stats, voice, key, text, renderForCaching, disableTtsStreaming});
         if (audioData?.filePath) return audioData;
         break;
       case 'deepgram':
-        audioData = await synthDeepgram(logger, {credentials, stats, model, text,
+        audioData = await synthDeepgram(logger, {credentials, stats, model, key, text,
           renderForCaching, disableTtsStreaming});
         break;
+      case 'resemble':
+        audioData = await synthResemble(logger, {
+          credentials, stats, voice, key, text, options, renderForCaching, disableTtsStreaming});
+        break;
       case vendor.startsWith('custom') ? vendor : 'cant_match_value':
         audioData = await synthCustomVendor(logger,
-          {credentials, stats, language, voice, text});
+          {credentials, stats, language, voice, key, text});
         break;
       default:
         assert(`synthAudio: unsupported speech vendor ${vendor}`);
@@ -290,9 +306,43 @@ async function synthAudio(client, createHash, retrieveHash, logger, stats, { acc
 }
 
 const synthPolly = async(createHash, retrieveHash, logger,
-  {credentials, stats, language, voice, engine, text}) => {
+  {credentials, stats, language, voice, engine, key, text, renderForCaching, disableTtsStreaming}) => {
+  const {region, accessKeyId, secretAccessKey, roleArn} = credentials;
+  if (!JAMBONES_DISABLE_TTS_STREAMING && !renderForCaching && !disableTtsStreaming) {
+
+    let params = '{';
+    params += `language=${language}`;
+    params += `,playback_id=${key}`;
+    params += ',write_cache_file=1';
+    params += ',vendor=aws';
+    if (accessKeyId && secretAccessKey) {
+      if (accessKeyId) params += `,accessKeyId=${accessKeyId}`;
+      if (secretAccessKey) params += `,secretAccessKey=${secretAccessKey}`;
+    } else if (roleArn) {
+      const cred = await getAwsAuthToken(
+        logger, createHash, retrieveHash,
+        {
+          region,
+          roleArn
+        });
+
+      if (cred) {
+        params += `,accessKeyId=${cred.accessKeyId}`;
+        params += `,secretAccessKey=${cred.secretAccessKey}`;
+        params += `,sessionToken=${cred.sessionToken}`;
+      }
+    }
+    if (region) params += `,region=${region}`;
+    if (engine) params += `,engine=${engine}`;
+    params += '}';
+
+    return {
+      filePath: `say:${params}${text.replace(/\n/g, ' ').replace(/\r/g, ' ')}`,
+      servedFromCache: false,
+      rtt: 0
+    };
+  }
   try {
-    const {region, accessKeyId, secretAccessKey, roleArn} = credentials;
     let polly;
     if (accessKeyId && secretAccessKey) {
       polly = new PollyClient({
@@ -465,7 +515,6 @@ async function _synthOnPremMicrosoft(logger, {
 }) {
   const {use_custom_tts, custom_tts_endpoint_url, api_key} = credentials;
   let content = text;
-
   if (use_custom_tts && !content.startsWith('<speak')) {
     /**
      * Note: it seems that to use custom voice ssml is required with the voice attribute
@@ -481,6 +530,10 @@ async function _synthOnPremMicrosoft(logger, {
     content = `<speak version="1.0" xmlns="http://www.w3.org/2001/10/synthesis" xmlns:mstts="https://www.w3.org/2001/mstts" xml:lang="${language}"><voice name="${voice}">${words}</voice></speak>`;
     logger.info({content}, 'synthMicrosoft');
   }
+  else if (JAMBONES_AZURE_ENABLE_SSML && !content.startsWith('<speak')) {
+    // eslint-disable-next-line max-len
+    content = `<speak version="1.0" xmlns="http://www.w3.org/2001/10/synthesis" xmlns:mstts="https://www.w3.org/2001/mstts" xml:lang="${language}"><voice name="${voice}"><lang xml:lang="${language}">${text}</lang></voice></speak>`;
+  }
 
   try {
     const trimSilence = JAMBONES_TTS_TRIM_SILENCE;
@@ -507,6 +560,7 @@ const synthMicrosoft = async(logger, {
   stats,
   language,
   voice,
+  key,
   text,
   renderForCaching,
   disableTtsStreaming
@@ -517,23 +571,28 @@ const synthMicrosoft = async(logger, {
     let content = text;
     if (use_custom_tts && !content.startsWith('<speak')) {
       /**
-       * Note: it seems that to use custom voice ssml is required with the voice attribute
-       * Otherwise sending plain text we get "Voice does not match"
-       */
+     * Note: it seems that to use custom voice ssml is required with the voice attribute
+     * Otherwise sending plain text we get "Voice does not match"
+     */
       content = `<speak>${text}</speak>`;
     }
 
     if (content.startsWith('<speak>')) {
-      /* microsoft enforces some properties and uses voice xml element so if the user did not supply do it for them */
+    /* microsoft enforces some properties and uses voice xml element so if the user did not supply do it for them */
       const words = content.slice(7, -8).trim().replace(/(\r\n|\n|\r)/gm, ' ');
       // eslint-disable-next-line max-len
       content = `<speak version="1.0" xmlns="http://www.w3.org/2001/10/synthesis" xmlns:mstts="https://www.w3.org/2001/mstts" xml:lang="${language}"><voice name="${voice}">${words}</voice></speak>`;
       logger.info({content}, 'synthMicrosoft');
     }
+    else if (JAMBONES_AZURE_ENABLE_SSML && !content.startsWith('<speak')) {
+      // eslint-disable-next-line max-len
+      content = `<speak version="1.0" xmlns="http://www.w3.org/2001/10/synthesis" xmlns:mstts="https://www.w3.org/2001/mstts" xml:lang="${language}"><voice name="${voice}"><lang xml:lang="${language}">${text}</lang></voice></speak>`;
+    }
     if (!JAMBONES_DISABLE_TTS_STREAMING && !JAMBONES_DISABLE_AZURE_TTS_STREAMING &&
       !renderForCaching && !disableTtsStreaming) {
-      let params = '';
-      params += `{api_key=${apiKey}`;
+      let params = '{';
+      params += `api_key=${apiKey}`;
+      params += `,playback_id=${key}`;
       params += `,language=${language}`;
       params += ',vendor=microsoft';
       params += `,voice=${voice}`;
@@ -710,12 +769,13 @@ const synthNuance = async(client, logger, {credentials, stats, voice, model, tex
 };
 
 const synthNvidia = async(client, logger, {
-  credentials, stats, language,  voice, model, text, renderForCaching, disableTtsStreaming
+  credentials, stats, language,  voice, model, key, text, renderForCaching, disableTtsStreaming
 }) => {
   const {riva_server_uri} = credentials;
   if (!JAMBONES_DISABLE_TTS_STREAMING && !renderForCaching && !disableTtsStreaming) {
     let params = '';
     params += `{riva_server_uri=${riva_server_uri}`;
+    params += `,playback_id=${key}`;
     params += `,voice=${voice}`;
     params += `,language=${language}`;
     params += ',write_cache_file=1';
@@ -789,15 +849,16 @@ const synthCustomVendor = async(logger, {credentials, stats, language, voice, te
 };
 
 const synthElevenlabs = async(logger, {
-  credentials, options, stats, voice, text, renderForCaching, disableTtsStreaming
+  credentials, options, stats, voice, key, text, renderForCaching, disableTtsStreaming
 }) => {
   const {api_key, model_id, options: credOpts} = credentials;
   const opts = !!options && Object.keys(options).length !== 0 ? options : JSON.parse(credOpts || '{}');
 
   /* default to using the streaming interface, unless disabled by env var OR we want just a cache file */
   if (!JAMBONES_DISABLE_TTS_STREAMING && !renderForCaching && !disableTtsStreaming) {
-    let params = '';
-    params += `{api_key=${api_key}`;
+    let params = '{';
+    params += `api_key=${api_key}`;
+    params += `,playback_id=${key}`;
     params += ',vendor=elevenlabs';
     params += `,voice=${voice}`;
     params += `,model_id=${model_id}`;
@@ -852,13 +913,12 @@ const synthElevenlabs = async(logger, {
 };
 
 const synthPlayHT = async(client, logger, {
-  credentials, options, stats, voice, language, text, renderForCaching, disableTtsStreaming
+  credentials, options, stats, voice, language, key, text, renderForCaching, disableTtsStreaming
 }) => {
-  const {api_key, user_id, voice_engine, options: credOpts} = credentials;
+  const {api_key, user_id, voice_engine, playht_tts_uri, options: credOpts} = credentials;
   const opts = !!options && Object.keys(options).length !== 0 ? options : JSON.parse(credOpts || '{}');
 
-  let synthesizeUrl = 'https://api.play.ht/api/v2/tts/stream';
-
+  let synthesizeUrl = playht_tts_uri ? `${playht_tts_uri}/api/v2/tts/stream` : 'https://api.play.ht/api/v2/tts/stream';
   // If model is play3.0, the synthesizeUrl is got from authentication endpoint
   if (voice_engine === 'Play3.0') {
     try {
@@ -887,8 +947,9 @@ const synthPlayHT = async(client, logger, {
 
   /* default to using the streaming interface, unless disabled by env var OR we want just a cache file */
   if (!JAMBONES_DISABLE_TTS_STREAMING && !renderForCaching && !disableTtsStreaming) {
-    let params = '';
-    params += `{api_key=${api_key}`;
+    let params = '{';
+    params += `api_key=${api_key}`;
+    params += `,playback_id=${key}`;
     params += `,user_id=${user_id}`;
     params += ',vendor=playht';
     params += `,voice=${voice}`;
@@ -946,16 +1007,82 @@ const synthPlayHT = async(client, logger, {
   }
 };
 
-const synthRimelabs = async(logger, {
-  credentials, options, stats, language, voice, text, renderForCaching, disableTtsStreaming
+const synthInworld = async(logger, {
+  credentials, options, stats, voice, key, text, renderForCaching, disableTtsStreaming
 }) => {
   const {api_key, model_id, options: credOpts} = credentials;
   const opts = !!options && Object.keys(options).length !== 0 ? options : JSON.parse(credOpts || '{}');
 
   /* default to using the streaming interface, unless disabled by env var OR we want just a cache file */
   if (!JAMBONES_DISABLE_TTS_STREAMING && !renderForCaching && !disableTtsStreaming) {
-    let params = '';
-    params += `{api_key=${api_key}`;
+    let params = '{';
+    params += `api_key=${api_key}`;
+    params += `,playback_id=${key}`;
+    params += `,model_id=${model_id}`;
+    params += ',vendor=inworld';
+    params += `,voice=${voice}`;
+    params += ',write_cache_file=1';
+    if (opts.temperature) params += `,temperature=${opts.temperature}`;
+    if (opts.audioConfig?.pitch) params += `,pitch=${opts.pitch}`;
+    if (opts.audioConfig?.speakingRate) params += `,speakingRate=${opts.speakingRate}`;
+    params += '}';
+
+    return {
+      filePath: `say:${params}${text.replace(/\n/g, ' ').replace(/\r/g, ' ')}`,
+      servedFromCache: false,
+      rtt: 0
+    };
+  }
+
+  try {
+    const url = 'https://api.inworld.ai/tts/v1/voice';
+    const sampleRate = 8000;
+    const options = {
+      method: 'POST',
+      headers: {
+        'Authorization': `Basic ${api_key}`,
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify({
+        text,
+        voiceId: voice,
+        modelId: model_id,
+        audioConfig: {
+          ...(opts.audioConfig || {}),
+          audioEncoding: 'MP3',
+        }
+      })
+    };
+
+    const response = await fetch(url, options);
+
+    if (!response.ok) {
+      throw new Error(await response.text());
+    }
+    const json = await response.json();
+    return {
+      audioContent: Buffer.from(json.audioContent, 'base64'),
+      extension: 'mp3',
+      sampleRate
+    };
+  } catch (err) {
+    logger.info({err}, 'synth inworld returned error');
+    stats.increment('tts.count', ['vendor:inworld', 'accepted:no']);
+    throw err;
+  }
+};
+
+const synthRimelabs = async(logger, {
+  credentials, options, stats, language, voice, key, text, renderForCaching, disableTtsStreaming
+}) => {
+  const {api_key, model_id, options: credOpts} = credentials;
+  const opts = !!options && Object.keys(options).length !== 0 ? options : JSON.parse(credOpts || '{}');
+
+  /* default to using the streaming interface, unless disabled by env var OR we want just a cache file */
+  if (!JAMBONES_DISABLE_TTS_STREAMING && !renderForCaching && !disableTtsStreaming) {
+    let params = '{';
+    params += `api_key=${api_key}`;
+    params += `,playback_id=${key}`;
     params += `,model_id=${model_id}`;
     params += ',vendor=rimelabs';
     params += `,language=${language}`;
@@ -963,6 +1090,11 @@ const synthRimelabs = async(logger, {
     params += ',write_cache_file=1';
     if (opts.speedAlpha) params += `,speed_alpha=${opts.speedAlpha}`;
     if (opts.reduceLatency) params += `,reduce_latency=${opts.reduceLatency}`;
+    // Arcana model parameters
+    if (opts.temperature) params += `,temperature=${opts.temperature}`;
+    if (opts.repetition_penalty) params += `,repetition_penalty=${opts.repetition_penalty}`;
+    if (opts.top_p) params += `,top_p=${opts.top_p}`;
+    if (opts.max_tokens) params += `,max_tokens=${opts.max_tokens}`;
     params += '}';
 
     return {
@@ -998,15 +1130,18 @@ const synthRimelabs = async(logger, {
     throw err;
   }
 };
-const synthVerbio = async(client, logger, {credentials, stats, voice, text, renderForCaching, disableTtsStreaming}) => {
+const synthVerbio = async(client, logger, {
+  credentials, stats, voice, key, text, renderForCaching, disableTtsStreaming
+}) => {
   //https://doc.speechcenter.verbio.com/#tag/Text-To-Speech-REST-API
   if (text.length > 2000) {
     throw new Error('Verbio cannot synthesize for the text length larger than 2000 characters');
   }
   const token = await getVerbioAccessToken(client, logger, credentials);
   if (!process.env.JAMBONES_DISABLE_TTS_STREAMING && !renderForCaching && !disableTtsStreaming) {
-    let params = '';
-    params += `{access_token=${token.access_token}`;
+    let params = '{';
+    params += `access_token=${token.access_token}`;
+    params += `,playback_id=${key}`;
     params += ',vendor=verbio';
     params += `,voice=${voice}`;
     params += ',write_cache_file=1';
@@ -1043,17 +1178,21 @@ const synthVerbio = async(client, logger, {credentials, stats, voice, text, rend
   }
 };
 
-const synthWhisper = async(logger, {credentials, stats, voice, text, renderForCaching, disableTtsStreaming}) => {
+const synthWhisper = async(logger, {credentials, stats, voice, key, text, instructions,
+  renderForCaching, disableTtsStreaming}) => {
   const {api_key, model_id, baseURL, timeout, speed} = credentials;
   /* if the env is set to stream then bag out, unless we are specifically rendering to generate a cache file */
   if (!JAMBONES_DISABLE_TTS_STREAMING && !renderForCaching && !disableTtsStreaming) {
-    let params = '';
-    params += `{api_key=${api_key}`;
+    let params = '{';
+    params += `api_key=${api_key}`;
+    params += `,playback_id=${key}`;
     params += `,model_id=${model_id}`;
     params += ',vendor=whisper';
     params += `,voice=${voice}`;
     params += ',write_cache_file=1';
     if (speed) params += `,speed=${speed}`;
+    // comma is used to separated parameters in freeswitch tts module
+    if (instructions) params += `,instructions=${instructions.replace(/\n/g, ' ').replace(/,/g, ';')}`;
     params += '}';
 
     return {
@@ -1073,6 +1212,7 @@ const synthWhisper = async(logger, {credentials, stats, voice, text, renderForCa
       model: model_id,
       voice,
       input: text,
+      ...(instructions && {instructions}),
       response_format: 'mp3'
     });
     return {
@@ -1087,11 +1227,12 @@ const synthWhisper = async(logger, {credentials, stats, voice, text, renderForCa
   }
 };
 
-const synthDeepgram = async(logger, {credentials, stats, model, text, renderForCaching, disableTtsStreaming}) => {
+const synthDeepgram = async(logger, {credentials, stats, model, key, text, renderForCaching, disableTtsStreaming}) => {
   const {api_key, deepgram_tts_uri} = credentials;
   if (!JAMBONES_DISABLE_TTS_STREAMING && !renderForCaching && !disableTtsStreaming) {
-    let params = '';
-    params += `{api_key=${api_key}`;
+    let params = '{';
+    params += `api_key=${api_key}`;
+    params += `,playback_id=${key}`;
     params += ',vendor=deepgram';
     params += `,voice=${model}`;
     params += ',write_cache_file=1';
@@ -1127,14 +1268,15 @@ const synthDeepgram = async(logger, {credentials, stats, model, text, renderForC
 };
 
 const synthCartesia = async(logger, {
-  credentials, options, stats, voice, language, text, renderForCaching, disableTtsStreaming
+  credentials, options, stats, voice, language, key, text, renderForCaching, disableTtsStreaming
 }) => {
   const {api_key, model_id, embedding, options: credOpts} = credentials;
   const opts = !!options && Object.keys(options).length !== 0 ? options : JSON.parse(credOpts || '{}');
 
   if (!JAMBONES_DISABLE_TTS_STREAMING && !renderForCaching && !disableTtsStreaming) {
-    let params = '';
-    params += `{api_key=${api_key}`;
+    let params = '{';
+    params += `api_key=${api_key}`;
+    params += `,playback_id=${key}`;
     params += `,model_id=${model_id}`;
     params += ',vendor=cartesia';
     params += `,voice=${voice}`;
@@ -1196,6 +1338,63 @@ const synthCartesia = async(logger, {
 
 };
 
+const synthResemble = async(logger, {
+  credentials, options, stats, voice, key, text, renderForCaching, disableTtsStreaming
+}) => {
+  const {api_key, resemble_tts_uri, resemble_tts_use_tls} = credentials;
+  const {project_uuid, use_hd} = options || {};
+
+  /* default to using the streaming interface, unless disabled by env var OR we want just a cache file */
+  if (!JAMBONES_DISABLE_TTS_STREAMING && !renderForCaching && !disableTtsStreaming) {
+    let params = '{';
+    params += `api_key=${api_key}`;
+    params += `,playback_id=${key}`;
+    params += ',vendor=resemble';
+    params += `,voice=${voice}`;
+    params += ',write_cache_file=1';
+    if (project_uuid) params += `,project_uuid=${project_uuid}`;
+    if (use_hd) params += `,use_hd=${use_hd}`;
+    if (resemble_tts_uri) params += `,endpoint=${resemble_tts_uri}`;
+    if (resemble_tts_use_tls) params += `,use_tls=${resemble_tts_use_tls}`;
+
+    params += '}';
+
+    return {
+      filePath: `say:${params}${text.replace(/\n/g, ' ').replace(/\r/g, ' ')}`,
+      servedFromCache: false,
+      rtt: 0
+    };
+  }
+
+  try {
+    const baseUrl = resemble_tts_uri || 'https://f.cluster.resemble.ai';
+    const post = bent(baseUrl, 'POST', 'buffer', {
+      'Authorization': `Bearer ${api_key}`,
+      'Content-Type': 'application/json'
+    });
+    const response = await post('/synthesize', {
+      voice_uuid: voice,
+      data: text,
+      sample_rate: 8000,
+      output_format: 'mp3',
+      ...(project_uuid && {project_uuid}),
+      ...(use_hd && {use_hd}),
+    });
+
+    const json = JSON.parse(response.toString('utf8'));
+    const audioContent = Buffer.from(json.audio_content, 'base64');
+    return {
+      audioContent,
+      extension: 'mp3',
+      sampleRate: 8000
+    };
+  } catch (err) {
+    logger.info({err}, 'synth Elevenlabs returned error');
+    stats.increment('tts.count', ['vendor:elevenlabs', 'accepted:no']);
+    throw err;
+  }
+};
+
 const getFileExtFromMime = (mime) => {
   switch (mime) {
     case 'audio/wav':

lib/utils.js

@@ -23,10 +23,11 @@ function makeSynthKey({
   voice,
   engine = '',
   model = '',
-  text
+  text,
+  instructions = '',
 }) {
   const hash = crypto.createHash('sha1');
-  hash.update(`${language}:${vendor}:${voice}:${engine}:${model}:${text}`);
+  hash.update(`${language}:${vendor}:${voice}:${engine}:${model}:${text}:${instructions}`);
   const hexHashKey = hash.digest('hex');
   const accountKey = account_sid ? `:${account_sid}` : '';
   const key = `tts${accountKey}:${hexHashKey}`;

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jambonz/speech-utils",
-  "version": "0.2.6",
+  "version": "0.2.22",
   "description": "TTS-related speech utilities for jambonz",
   "main": "index.js",
   "author": "Dave Horton",
@@ -26,6 +26,7 @@
   },
   "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.1.0",
@@ -36,9 +37,9 @@
     "debug": "^4.3.4",
     "form-urlencoded": "^6.1.4",
     "google-protobuf": "^3.21.2",
-    "ibm-watson": "^8.0.0",
+    "ibm-watson": "^11.0.0",
     "microsoft-cognitiveservices-speech-sdk": "1.38.0",
-    "openai": "^4.25.0",
+    "openai": "^4.98.0",
     "undici": "^7.5.0"
   },
   "devDependencies": {

test/synth.js

@@ -185,6 +185,7 @@ 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}`);
 
@@ -198,6 +199,7 @@ 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) {
@@ -720,6 +722,65 @@ test('Cartesia speech synth tests', async(t) => {
   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) => {
   const fn = require('..');
   const {synthAudio, client} = fn(opts, logger);
@@ -887,7 +948,8 @@ 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}), i);
+      await client.set(makeSynthKey({vendor: i, language: i, voice: i, engine: i, model: i, text: i,
+        instructions: i}), i);
     }
     const count = await getTtsSize();
     t.ok(count >= minRecords, 'getTtsSize worked.');
@@ -906,7 +968,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}), i);
+      await client.set(makeSynthKey({vendor: i, language: i, voice: i, engine: i, text: i, instructions: i}), i);
     }
     // save a specific key to tts cache
     const opts = {vendor: 'aws', language: 'en-US', voice: 'MALE', engine: 'Engine', text: 'Hello World!'};
@@ -944,10 +1006,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}), i);
+      await client.set(makeSynthKey({account_sid, vendor: i, language: i, voice: i, engine: i, text: i, instructions: 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}), i);
+      await client.set(makeSynthKey({account_sid: account_sid2, vendor: i, language: i, voice: i, engine: i, text: i, instructions: 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}`);