@jambonz/speech-utils 0.1.22 → 0.2.1

package/lib/add-file-to-cache.js

@@ -3,6 +3,27 @@ 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, text}) {
   let key;
@@ -17,8 +38,15 @@ async function addFileToCache(client, logger, path,
       engine,
       text,
     });
+    const [extension, sampleRate] = getExtensionAndSampleRate(path);
     const audioBuffer = await fs.readFile(path);
-    await client.setex(key, EXPIRES, audioBuffer.toString('base64'));
+    await client.setex(key, EXPIRES, JSON.stringify(
+      {
+        audioContent: audioBuffer.toString('base64'),
+        extension,
+        sampleRate
+      }
+    ));
   } catch (err) {
     logger.error(err, 'addFileToCache: Error');
     return;

package/lib/get-aws-sts-token.js

@@ -7,22 +7,23 @@ const CACHE_EXPIRY = process.env.AWS_STS_SESSION_RESET_EXPIRY || (EXPIRY - 600);
 
 async function getAwsAuthToken(
   logger, createHash, retrieveHash,
-  {accessKeyId, secretAccessKey, region, roleArn}) {
+  {speech_credential_sid, accessKeyId, secretAccessKey, region, roleArn}) {
   logger = logger || noopLogger;
   try {
-    const key = makeAwsKey(roleArn || accessKeyId);
+    // if incase instance profile is used, speech_credential_sid will be used as key to lookup cache
+    const key = makeAwsKey(roleArn || accessKeyId || speech_credential_sid);
     const obj = await retrieveHash(key);
     if (obj) return {...obj, servedFromCache: true};
-
+    /* access token not found in cache, so generate it using STS */
     let data;
+    let expiry = CACHE_EXPIRY;
     if (roleArn) {
       const stsClient = new STSClient({ region });
       const roleToAssume = { RoleArn: roleArn, RoleSessionName: 'Jambonz_Speech', DurationSeconds: EXPIRY};
       const command = new AssumeRoleCommand(roleToAssume);
 
       data = await stsClient.send(command);
-    } else {
-      /* access token not found in cache, so generate it using STS */
+    } else if (accessKeyId) {
       const stsClient = new STSClient({
         region,
         credentials: {
@@ -32,6 +33,26 @@ 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 = {
@@ -40,9 +61,11 @@ async function getAwsAuthToken(
       sessionToken: data.Credentials.SessionToken,
       securityToken: data.Credentials.SessionToken
     };
-
-    createHash(key, credentials, CACHE_EXPIRY)
-      .catch((err) => logger.error(err, `Error saving hash for key ${key}`));
+    // Only cache if expiry is good
+    if (expiry > 0) {
+      createHash(key, credentials, expiry)
+        .catch((err) => logger.error(err, `Error saving hash for key ${key}`));
+    }
 
     return {...credentials, servedFromCache: false};
   } catch (err) {

package/lib/synth-audio.js

@@ -3,6 +3,7 @@ const fs = require('fs');
 const bent = require('bent');
 const ttsGoogle = require('@google-cloud/text-to-speech');
 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');
@@ -45,7 +46,7 @@ const {
   JAMBONES_HTTP_PROXY_IP,
   JAMBONES_HTTP_PROXY_PORT,
   JAMBONES_TTS_CACHE_DURATION_MINS,
-  JAMBONES_EAGERLY_PRE_CACHE_AUDIO,
+  JAMBONES_TTS_TRIM_SILENCE,
 } = require('./config');
 const EXPIRES = JAMBONES_TTS_CACHE_DURATION_MINS;
 const OpenAI = require('openai');
@@ -90,13 +91,13 @@ async function synthAudio(client, createHash, retrieveHash, logger, stats, { acc
   vendor, language, voice, gender, text, engine, salt, model, credentials, deploymentId,
   disableTtsCache, renderForCaching = false, disableTtsStreaming, options
 }) {
-  let audioBuffer;
+  let audioData;
   let servedFromCache = false;
   let rtt;
   logger = logger || noopLogger;
 
   assert.ok(['google', 'aws', 'polly', 'microsoft', 'wellsaid', 'nuance', 'nvidia', 'ibm', 'elevenlabs',
-    'whisper', 'deepgram', 'playht', 'rimelabs', 'verbio'].includes(vendor) ||
+    'whisper', 'deepgram', 'playht', 'rimelabs', 'verbio', 'cartesia'].includes(vendor) ||
   vendor.startsWith('custom'),
   `synthAudio supported vendors are google, aws, microsoft, nuance, nvidia and wellsaid ..etc, not ${vendor}`);
   if ('google' === vendor) {
@@ -157,7 +158,9 @@ async function synthAudio(client, createHash, retrieveHash, logger, stats, { acc
     if (!credentials.deepgram_tts_uri) {
       assert.ok(credentials.api_key, 'synthAudio requires api_key when deepgram is used');
     }
-
+  } 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');
   }
 
   const key = makeSynthKey({
@@ -166,57 +169,24 @@ async function synthAudio(client, createHash, retrieveHash, logger, stats, { acc
     language: language || '',
     voice: voice || deploymentId,
     engine,
-    text,
-    renderForCaching
+    text
   });
-  let filePath;
-  // used only for custom vendor
-  let fileExtension;
-  filePath = makeFilePath({vendor, voice, key, salt, renderForCaching});
+
   debug(`synth key is ${key}`);
   let cached;
   if (!disableTtsCache) {
     cached = await client.get(key);
-    /**
-    *  If we are using tts streaming and also precaching audio, audio could have been cached by streaming (r8)
-    * or here in speech-utils due to precaching (mp3), so we need to check for both keys.
-    */
-    if (!cached && JAMBONES_EAGERLY_PRE_CACHE_AUDIO) {
-      const preCachekey = makeSynthKey({
-        account_sid,
-        vendor,
-        language: language || '',
-        voice: voice || deploymentId,
-        engine,
-        text,
-        renderForCaching: true
-      });
-      cached = await client.get(preCachekey);
-      if (cached) {
-        // Precache audio is available update filpath with precache file extension.
-        filePath = makeFilePath({vendor, voice, key, salt, renderForCaching: true});
-      }
-    }
   }
   if (cached) {
     // found in cache - extend the expiry and use it
     debug('result WAS found in cache');
     servedFromCache = true;
     stats.increment('tts.cache.requests', ['found:yes']);
-    if (vendor.startsWith('custom')) {
-      // custom vendors support multiple mime types such as: mp3, wav, r8, r16 ...etc,
-      // mime type/file extension is available when http response has header Content-type.
-      // In cache, file extension is store together with audiBuffer in a json.
-      // Normal cache audio will be base64 string
-      const payload = JSON.parse(cached);
-      filePath = filePath.replace(/\.[^\.]*$/g, payload.fileExtension);
-      audioBuffer = Buffer.from(payload.audioBuffer, 'base64');
-    } else {
-      audioBuffer = Buffer.from(cached, 'base64');
-    }
+    audioData = JSON.parse(cached);
+    // convert base64 audio to buffer
+    audioData.audioContent = Buffer.from(audioData.audioContent, 'base64');
     client.expire(key, EXPIRES).catch((err) => logger.info(err, 'Error setting expires'));
-  }
-  if (!cached) {
+  } else {
     // not found in cache - go get it from speech vendor and add to cache
     debug('result was NOT found in cache');
     stats.increment('tts.cache.requests', ['found:no']);
@@ -224,89 +194,92 @@ async function synthAudio(client, createHash, retrieveHash, logger, stats, { acc
     const startAt = process.hrtime();
     switch (vendor) {
       case 'google':
-        audioBuffer = await synthGoogle(logger, {credentials, stats, language, voice, gender, text});
+        audioData = await synthGoogle(logger, {credentials, stats, language, voice, gender, text});
         break;
       case 'aws':
       case 'polly':
         vendorLabel = 'aws';
-        audioBuffer = await synthPolly(createHash, retrieveHash, logger,
+        audioData = await synthPolly(createHash, retrieveHash, logger,
           {credentials, stats, language, voice, text, engine});
         break;
       case 'azure':
       case 'microsoft':
         vendorLabel = 'microsoft';
-        audioBuffer = await synthMicrosoft(logger, {credentials, stats, language, voice, text, deploymentId,
-          filePath, renderForCaching, disableTtsStreaming});
+        audioData = await synthMicrosoft(logger, {credentials, stats, language, voice, text, deploymentId,
+          renderForCaching, disableTtsStreaming});
         break;
       case 'nuance':
         model = model || 'enhanced';
-        audioBuffer = await synthNuance(client, logger, {credentials, stats, voice, model, text});
+        audioData = await synthNuance(client, logger, {credentials, stats, voice, model, text});
         break;
       case 'nvidia':
-        audioBuffer = await synthNvidia(client, logger, {credentials, stats, language, voice, model, text});
+        audioData = await synthNvidia(client, logger, {credentials, stats, language, voice, model, text});
         break;
       case 'ibm':
-        audioBuffer = await synthIbm(logger, {credentials, stats, voice, text});
+        audioData = await synthIbm(logger, {credentials, stats, voice, text});
         break;
       case 'wellsaid':
-        audioBuffer = await synthWellSaid(logger, {credentials, stats, language, voice, text, filePath});
+        audioData = await synthWellSaid(logger, {credentials, stats, language, voice, text});
         break;
       case 'elevenlabs':
-        audioBuffer = await synthElevenlabs(logger, {
-          credentials, options, stats, language, voice, text, renderForCaching, disableTtsStreaming, filePath
-        });
+        audioData = await synthElevenlabs(logger, {
+          credentials, options, stats, language, voice, text, renderForCaching, disableTtsStreaming});
         break;
       case 'playht':
-        audioBuffer = await synthPlayHT(client, logger, {
-          credentials, options, stats, language, voice, text, renderForCaching, disableTtsStreaming, filePath
-        });
+        audioData = await synthPlayHT(client, logger, {
+          credentials, options, stats, language, voice, text, renderForCaching, disableTtsStreaming});
+        break;
+      case 'cartesia':
+        audioData = await synthCartesia(logger, {
+          credentials, options, stats, language, voice, text, renderForCaching, disableTtsStreaming});
         break;
       case 'rimelabs':
-        audioBuffer = await synthRimelabs(logger, {
-          credentials, options, stats, language, voice, text, renderForCaching, disableTtsStreaming, filePath
-        });
+        audioData = await synthRimelabs(logger, {
+          credentials, options, stats, language, voice, text, renderForCaching, disableTtsStreaming});
         break;
       case 'whisper':
-        audioBuffer = await synthWhisper(logger, {
+        audioData = await synthWhisper(logger, {
           credentials, stats, voice, text, renderForCaching, disableTtsStreaming});
         break;
       case 'verbio':
-        audioBuffer = await synthVerbio(client, logger, {
+        audioData = await synthVerbio(client, logger, {
           credentials, stats, voice, text, renderForCaching, disableTtsStreaming});
-        if (audioBuffer?.filePath) return audioBuffer;
+        if (audioData?.filePath) return audioData;
         break;
       case 'deepgram':
-        audioBuffer = await synthDeepgram(logger, {credentials, stats, model, text,
+        audioData = await synthDeepgram(logger, {credentials, stats, model, text,
           renderForCaching, disableTtsStreaming});
         break;
       case vendor.startsWith('custom') ? vendor : 'cant_match_value':
-        ({ audioBuffer, filePath, fileExtension } = await synthCustomVendor(logger,
-          {credentials, stats, language, voice, text, filePath}));
+        audioData = await synthCustomVendor(logger,
+          {credentials, stats, language, voice, text});
         break;
       default:
         assert(`synthAudio: unsupported speech vendor ${vendor}`);
     }
-    if ('filePath' in audioBuffer) return audioBuffer;
+    if ('filePath' in audioData) return audioData;
     const diff = process.hrtime(startAt);
     const time = diff[0] * 1e3 + diff[1] * 1e-6;
     rtt = time.toFixed(0);
     stats.histogram('tts.response_time', rtt, [`vendor:${vendorLabel}`]);
     debug(`tts rtt time for ${text.length} chars on ${vendorLabel}: ${rtt}`);
     logger.info(`tts rtt time for ${text.length} chars on ${vendorLabel}: ${rtt}`);
-
-    const base64Audio = audioBuffer.toString('base64');
-    const cacheContent = vendor.startsWith('custom') ?
-      JSON.stringify({
-        audioBuffer: base64Audio,
-        fileExtension
-      }) : base64Audio;
-
-    client.setex(key, EXPIRES, cacheContent)
+    // Save audio json to cache
+    client.setex(key, EXPIRES, JSON.stringify({
+      ...audioData,
+      audioContent: audioData.audioContent?.toString('base64')
+    }))
       .catch((err) => logger.error(err, `error calling setex on key ${key}`));
   }
 
   return new Promise((resolve, reject) => {
-    fs.writeFile(filePath, audioBuffer, (err) => {
+    const { audioContent, extension } = audioData;
+    const filePath = makeFilePath({
+      key,
+      salt,
+      extension
+    });
+    fs.writeFile(filePath, audioContent, (err) => {
       if (err) return reject(err);
       resolve({filePath, servedFromCache, rtt});
     });
@@ -361,7 +334,13 @@ const synthPolly = async(createHash, retrieveHash, logger,
         .on('data', (chunk) => {
           chunks.push(chunk);
         })
-        .on('end', () => resolve(Buffer.concat(chunks)));
+        .on('end', () => resolve(
+          {
+            audioContent: Buffer.concat(chunks),
+            extension: 'mp3',
+            sampleRate: 8000
+          }
+        ));
     });
   } catch (err) {
     logger.info({err}, 'synthAudio: Error synthesizing speech using aws polly');
@@ -403,7 +382,11 @@ const synthGoogle = async(logger, {credentials, stats, language, voice, gender,
       };
 
       const wav = await post('/v1beta1/text:synthesize', payload);
-      return Buffer.from(wav.audioContent, 'base64');
+      return {
+        audioContent: Buffer.from(wav.audioContent, 'base64'),
+        extension: 'wav',
+        sampleRate: 24000
+      };
     } catch (err) {
       logger.info({err: await err.text()}, 'synthGoogle returned error');
       throw err;
@@ -424,7 +407,11 @@ const synthGoogle = async(logger, {credentials, stats, language, voice, gender,
     const responses = await client.synthesizeSpeech(opts);
     stats.increment('tts.count', ['vendor:google', 'accepted:yes']);
     client.close();
-    return responses[0].audioContent;
+    return {
+      audioContent: responses[0].audioContent,
+      extension: 'mp3',
+      sampleRate: 8000
+    };
   } catch (err) {
     console.error(err);
     logger.info({err, opts}, 'synthAudio: Error synthesizing speech using google');
@@ -455,7 +442,11 @@ const synthIbm = async(logger, {credentials, stats, voice, text}) => {
     for await (const chunk of r.result) {
       chunks.push(chunk);
     }
-    return Buffer.concat(chunks);
+    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']);
@@ -465,11 +456,9 @@ const synthIbm = async(logger, {credentials, stats, voice, text}) => {
 
 async function _synthOnPremMicrosoft(logger, {
   credentials,
-  stats,
   language,
   voice,
-  text,
-  filePath
+  text
 }) {
   const {use_custom_tts, custom_tts_endpoint_url, api_key} = credentials;
   let content = text;
@@ -491,15 +480,19 @@ async function _synthOnPremMicrosoft(logger, {
   }
 
   try {
-    const trimSilence = filePath.endsWith('.r8');
+    const trimSilence = JAMBONES_TTS_TRIM_SILENCE;
     const post = bent('POST', 'buffer', {
       'X-Microsoft-OutputFormat': trimSilence ? 'raw-8khz-16bit-mono-pcm' : 'audio-16khz-32kbitrate-mono-mp3',
       'Content-Type': 'application/ssml+xml',
       'User-Agent': 'Jambonz',
       ...(api_key && {'Ocp-Apim-Subscription-Key': api_key})
     });
-    const mp3 = await post(custom_tts_endpoint_url, content);
-    return mp3;
+    const audioContent = await post(custom_tts_endpoint_url, content);
+    return {
+      audioContent,
+      extension: trimSilence ? 'r8' : 'mp3',
+      sampleRate: 8000
+    };
   } catch (err) {
     logger.info({err}, '_synthMicrosoftByHttp returned error');
     throw err;
@@ -512,7 +505,6 @@ const synthMicrosoft = async(logger, {
   language,
   voice,
   text,
-  filePath,
   renderForCaching,
   disableTtsStreaming
 }) => {
@@ -555,17 +547,18 @@ const synthMicrosoft = async(logger, {
         rtt: 0
       };
     }
+    // Azure Onprem
     if (use_custom_tts && custom_tts_endpoint_url) {
       return await _synthOnPremMicrosoft(logger, {
         credentials,
         stats,
         language,
         voice,
-        text,
-        filePath
+        text
       });
     }
-    const trimSilence = filePath.endsWith('.r8');
+    // Azure hosted service
+    const trimSilence = JAMBONES_TTS_TRIM_SILENCE;
     const speechConfig = SpeechConfig.fromSubscription(apiKey, region);
     speechConfig.speechSynthesisLanguage = language;
     speechConfig.speechSynthesisVoiceName = voice;
@@ -600,7 +593,11 @@ const synthMicrosoft = async(logger, {
             case ResultReason.SynthesizingAudioCompleted:
               let buffer = Buffer.from(result.audioData);
               if (trimSilence) buffer = trimTrailingSilence(buffer);
-              resolve(buffer);
+              resolve({
+                audioContent: buffer,
+                extension: trimSilence ? 'r8' : 'mp3',
+                sampleRate: 8000
+              });
               synthesizer.close();
               stats.increment('tts.count', ['vendor:microsoft', 'accepted:yes']);
               break;
@@ -630,11 +627,15 @@ const synthWellSaid = async(logger, {credentials, stats, language, voice, gender
       'Accept': 'audio/mpeg',
       'Content-Type': 'application/json'
     });
-    const mp3 = await post('/v1/tts/stream', {
+    const audioContent = await post('/v1/tts/stream', {
       text,
       speaker_id: voice
     });
-    return mp3;
+    return {
+      audioContent,
+      extension: 'mp3',
+      sampleRate: 8000
+    };
   } catch (err) {
     logger.info({err}, 'testWellSaidTts returned error');
     throw err;
@@ -671,8 +672,8 @@ const synthNuance = async(client, logger, {credentials, stats, voice, model, tex
     t.setText(text);
     input.setText(t);
   }
-
-  pcm.setSampleRateHz(8000);
+  const sampleRate = 8000;
+  pcm.setSampleRateHz(sampleRate);
   f.setPcm(pcm);
   p.setAudioFormat(f);
   v.setName(voice);
@@ -696,7 +697,11 @@ const synthNuance = async(client, logger, {credentials, stats, voice, model, tex
         const details = status.getDetails();
         return reject({code, message, details});
       }
-      resolve(Buffer.from(response.getAudio()));
+      resolve({
+        audioContent: Buffer.from(response.getAudio()),
+        extension: 'r8',
+        sampleRate
+      });
     });
   });
 };
@@ -704,12 +709,13 @@ const synthNuance = async(client, logger, {credentials, stats, voice, model, tex
 const synthNvidia = async(client, logger, {credentials, stats, language,  voice, model, text}) => {
   const {riva_server_uri} = credentials;
   let rivaClient, request;
+  const sampleRate = 8000;
   try {
     rivaClient = await createRivaClient(riva_server_uri);
     request = new SynthesizeSpeechRequest();
     request.setVoiceName(voice);
     request.setLanguageCode(language);
-    request.setSampleRateHz(8000);
+    request.setSampleRateHz(sampleRate);
     request.setEncoding(AudioEncoding.LINEAR_PCM);
     request.setText(text);
   } catch (err) {
@@ -723,7 +729,11 @@ const synthNvidia = async(client, logger, {credentials, stats, language,  voice,
         logger.info({err, voice, language}, 'error synthesizing speech using Nvidia');
         return reject(err);
       }
-      resolve(Buffer.from(response.getAudio()));
+      resolve({
+        audioContent: Buffer.from(response.getAudio()),
+        extension: 'r8',
+        sampleRate
+      });
     });
   });
 };
@@ -745,14 +755,13 @@ const synthCustomVendor = async(logger, {credentials, stats, language, voice, te
       text
     });
 
-    const regex = /\.[^\.]*$/g;
     const mime = response.headers['content-type'];
     const buffer = await response.arrayBuffer();
-    const fileExtension = getFileExtFromMime(mime);
+    const [extension, sampleRate] = getFileExtFromMime(mime);
     return {
-      audioBuffer: buffer,
-      filePath: filePath.replace(regex, fileExtension),
-      fileExtension
+      audioContent: buffer,
+      extension,
+      sampleRate
     };
   } catch (err) {
     logger.info({err}, `Vendor ${vendor} returned error`);
@@ -798,7 +807,7 @@ const synthElevenlabs = async(logger, {
       'Accept': 'audio/mpeg',
       'Content-Type': 'application/json'
     });
-    const mp3 = await post(`/v1/text-to-speech/${voice}${optimize_streaming_latency}`, {
+    const audioContent = await post(`/v1/text-to-speech/${voice}${optimize_streaming_latency}`, {
       text,
       model_id,
       voice_settings: {
@@ -807,7 +816,11 @@ const synthElevenlabs = async(logger, {
       },
       ...opts
     });
-    return mp3;
+    return {
+      audioContent,
+      extension: 'mp3',
+      sampleRate: 8000
+    };
   } catch (err) {
     logger.info({err}, 'synth Elevenlabs returned error');
     stats.increment('tts.count', ['vendor:elevenlabs', 'accepted:no']);
@@ -889,7 +902,7 @@ const synthPlayHT = async(client, logger, {
       'Content-Type': 'application/json'
     });
 
-    const mp3 = await post(synthesizeUrl, {
+    const audioContent = await post(synthesizeUrl, {
       text,
       ...(voice_engine === 'Play3.0' && { language }),
       voice,
@@ -898,7 +911,11 @@ const synthPlayHT = async(client, logger, {
       sample_rate: 8000,
       ...opts
     });
-    return mp3;
+    return {
+      audioContent,
+      extension: 'mp3',
+      sampleRate: 8000
+    };
   } catch (err) {
     logger.info({err}, 'synth PlayHT returned error');
     stats.increment('tts.count', ['vendor:playht', 'accepted:no']);
@@ -937,14 +954,19 @@ const synthRimelabs = async(logger, {
       'Accept': 'audio/mp3',
       'Content-Type': 'application/json'
     });
-    const mp3 = await post('/v1/rime-tts', {
+    const sampleRate = 8000;
+    const audioContent = await post('/v1/rime-tts', {
       speaker: voice,
       text,
       modelId: model_id,
-      samplingRate: 8000,
+      samplingRate: sampleRate,
       ...opts
     });
-    return mp3;
+    return {
+      audioContent,
+      extension: 'mp3',
+      sampleRate
+    };
   } catch (err) {
     logger.info({err}, 'synth rimelabs returned error');
     stats.increment('tts.count', ['vendor:rimelabs', 'accepted:no']);
@@ -978,13 +1000,17 @@ const synthVerbio = async(client, logger, {credentials, stats, voice, text, rend
       'User-Agent': 'jambonz',
       'Content-Type': 'application/json'
     });
-    const r8 = await post('/api/v1/synthesize', {
+    const audioContent = await post('/api/v1/synthesize', {
       voice_id: voice,
       output_sample_rate: '8k',
       output_encoding: 'pcm16',
       text
     });
-    return r8;
+    return {
+      audioContent,
+      extension: 'r8',
+      sampleRate: 8000
+    };
   } catch (err) {
     logger.info({err}, 'synth Verbio returned error');
     stats.increment('tts.count', ['vendor:verbio', 'accepted:no']);
@@ -1024,7 +1050,11 @@ const synthWhisper = async(logger, {credentials, stats, voice, text, renderForCa
       input: text,
       response_format: 'mp3'
     });
-    return Buffer.from(await mp3.arrayBuffer());
+    return {
+      audioContent: Buffer.from(await mp3.arrayBuffer()),
+      extension: 'mp3',
+      sampleRate: 8000
+    };
   } catch (err) {
     logger.info({err}, 'synth whisper returned error');
     stats.increment('tts.count', ['vendor:openai', 'accepted:no']);
@@ -1056,10 +1086,14 @@ const synthDeepgram = async(logger, {credentials, stats, model, text, renderForC
       'Accept': 'audio/mpeg',
       'Content-Type': 'application/json'
     });
-    const mp3 = await post(`/v1/speak?model=${model}`, {
+    const audioContent = await post(`/v1/speak?model=${model}`, {
       text
     });
-    return mp3;
+    return {
+      audioContent,
+      extension: 'mp3',
+      sampleRate: 8000
+    };
   } catch (err) {
     logger.info({err}, 'synth Deepgram returned error');
     stats.increment('tts.count', ['vendor:deepgram', 'accepted:no']);
@@ -1067,26 +1101,96 @@ const synthDeepgram = async(logger, {credentials, stats, model, text, renderForC
   }
 };
 
+const synthCartesia = async(logger, {
+  credentials, options, stats, voice, language, 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}`;
+    params += `,model_id=${model_id}`;
+    params += ',vendor=cartesia';
+    params += `,voice=${voice}`;
+    params += ',write_cache_file=1';
+    params += `,language=${language}`;
+    params += `,voice_mode=${embedding ? 'embedding' : 'id'}`;
+    if (embedding) params += `,embedding=${embedding}`;
+    if (opts.speed) params += `,speed=${opts.speed}`;
+    if (opts.emotion) params += `,emotion=${opts.emotion}`;
+    params += '}';
+
+    return {
+      filePath: `say:${params}${text.replace(/\n/g, ' ').replace(/\r/g, ' ')}`,
+      servedFromCache: false,
+      rtt: 0
+    };
+  }
+
+  try {
+    const client = new CartesiaClient({ apiKey: api_key });
+    const sampleRate = 48000;
+    const mp3 = await client.tts.bytes({
+      modelId: model_id,
+      transcript: text,
+      voice: {
+        mode: embedding ? 'embedding' : 'id',
+        ...(embedding ?
+          {
+            embedding: embedding.split(',').map(Number)
+          } :
+          {
+            id: voice
+          }
+        ),
+        ...(opts.speed || opts.emotion && {
+          experimentalControls: {
+            ...(opts.speed !== null && opts.speed !== undefined && {speed: opts.speed}),
+            ...(opts.emotion && {emotion: opts.emotion}),
+          }
+        })
+      },
+      language: language,
+      outputFormat: {
+        container: 'mp3',
+        bitRate: 128000,
+        sampleRate
+      },
+    });
+    return {
+      audioContent: Buffer.from(mp3),
+      extension: 'mp3',
+      sampleRate
+    };
+  } catch (err) {
+    logger.info({err}, 'synth Cartesia returned error');
+    stats.increment('tts.count', ['vendor:cartesia', 'accepted:no']);
+    throw err;
+  }
+
+};
+
 const getFileExtFromMime = (mime) => {
   switch (mime) {
     case 'audio/wav':
     case 'audio/x-wav':
-      return '.wav';
+      return ['wav', 8000];
     case /audio\/l16.*rate=8000/.test(mime) ? mime : 'cant match value':
-      return '.r8';
+      return ['r8', 8000];
     case /audio\/l16.*rate=16000/.test(mime) ? mime : 'cant match value':
-      return '.r16';
+      return ['r16', 16000];
     case /audio\/l16.*rate=24000/.test(mime) ? mime : 'cant match value':
-      return '.r24';
+      return ['r24', 24000];
     case /audio\/l16.*rate=32000/.test(mime) ? mime : 'cant match value':
-      return '.r32';
+      return ['r32', 32000];
     case /audio\/l16.*rate=48000/.test(mime) ? mime : 'cant match value':
-      return '.r48';
+      return ['r48', 48000];
     case 'audio/mpeg':
     case 'audio/mp3':
-      return '.mp3';
+      return ['mp3', 8000];
     default:
-      return '.wav';
+      return ['wav', 8000];
   }
 };
 

package/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 { JAMBONES_DISABLE_TTS_STREAMING, JAMBONES_TTS_TRIM_SILENCE, TMP_FOLDER, HTTP_TIMEOUT } = require('./config');
+const { TMP_FOLDER, HTTP_TIMEOUT } = require('./config');
 
 const debug = require('debug')('jambonz:realtimedb-helpers');
 /**
@@ -17,67 +17,19 @@ const debug = require('debug')('jambonz:realtimedb-helpers');
 //const nuanceClientMap = new Map();
 
 function makeSynthKey({
-  account_sid = '', vendor, language, voice, engine = '', text,
-  renderForCaching = false}) {
+  account_sid = '', vendor, language, voice, engine = '', text}) {
   const hash = crypto.createHash('sha1');
   hash.update(`${language}:${vendor}:${voice}:${engine}:${text}`);
   const hexHashKey = hash.digest('hex');
   const accountKey = account_sid ? `:${account_sid}` : '';
-  const namespace = vendor.startsWith('custom') ? vendor : getFileExtension({vendor, voice, renderForCaching});
-  const key = `tts${accountKey}:${namespace}:${hexHashKey}`;
+  const key = `tts${accountKey}:${hexHashKey}`;
   return key;
 }
 
-function makeFilePath({vendor, voice, key, salt = '', renderForCaching = false}) {
-  const extension = getFileExtension({vendor, renderForCaching, voice});
+function makeFilePath({key, salt = '', extension}) {
   return `${TMP_FOLDER}/${key.replace('tts:', `tts-${salt}`)}.${extension}`;
 }
 
-function getFileExtension({vendor, voice, renderForCaching = false}) {
-  const mp3Extension = 'mp3';
-  const r8Extension = 'r8';
-  const wavExtension = 'wav';
-
-  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 'rimelabs':
-    case 'playht':
-      if (renderForCaching || JAMBONES_DISABLE_TTS_STREAMING) {
-        return mp3Extension;
-      } else {
-        return r8Extension;
-      }
-    case 'nuance':
-    case 'nvidia':
-    case 'verbio':
-      return r8Extension;
-    case 'google':
-      // google voice cloning just support wav.
-      if (typeof voice === 'object' && voice.voice_cloning_key) {
-        return wavExtension;
-      } else {
-        return mp3Extension;
-      }
-    default:
-      // If vendor is custom
-      if (vendor.startsWith('custom')) {
-        if (renderForCaching || JAMBONES_DISABLE_TTS_STREAMING) {
-          return mp3Extension;
-        } else {
-          return r8Extension;
-        }
-      }
-      return mp3Extension;
-  }
-}
 
 const noopLogger = {
   info: () => {},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jambonz/speech-utils",
-  "version": "0.1.22",
+  "version": "0.2.1",
   "description": "TTS-related speech utilities for jambonz",
   "main": "index.js",
   "author": "Dave Horton",
@@ -28,6 +28,7 @@
   "dependencies": {
     "@aws-sdk/client-polly": "^3.496.0",
     "@aws-sdk/client-sts": "^3.496.0",
+    "@cartesia/cartesia-js": "^2.1.0",
     "@google-cloud/text-to-speech": "^5.5.0",
     "@grpc/grpc-js": "^1.9.14",
     "@jambonz/realtimedb-helpers": "^0.8.7",

package/test/synth.js

@@ -686,6 +686,40 @@ test('PlayHT3.0 speech synth tests', async(t) => {
   await testPlayHT(t, 'Play3.0');
 });
 
+test('Cartesia speech synth tests', async(t) => {
+  const fn = require('..');
+  const {synthAudio, client} = fn(opts, logger);
+
+  if (!process.env.CARTESIA_API_KEY) {
+    t.pass('skipping Cartesia speech synth tests since CARTESIA_API_KEY is not provided');
+    return t.end();
+  }
+  const text = 'Hi there and welcome to jambones! ' + Date.now();
+  try {
+    const opts = await synthAudio(stats, {
+      vendor: 'cartesia',
+      credentials: {
+        api_key: process.env.CARTESIA_API_KEY,
+        model_id: 'sonic-english',
+        options: JSON.stringify({
+          speed: 1,
+          emotion: 'female_happy',
+        })
+      },
+      language: 'en',
+      voice: '694f9389-aac1-45b6-b726-9d9369183238',
+      text,
+      renderForCaching: true
+    });
+    t.ok(!opts.servedFromCache, `successfully playht eleven audio to ${opts.filePath}`);
+
+  } catch (err) {
+    console.error(JSON.stringify(err));
+    t.end(err);
+  }
+  client.quit();
+});
+
 test('rimelabs speech synth tests', async(t) => {
   const fn = require('..');
   const {synthAudio, client} = fn(opts, logger);
@@ -854,24 +888,15 @@ test('TTS Cache tests', async(t) => {
       language: 'non-existing',
       voice: 'non-existing',
     });
-    t.ok(purgedCountWhenErrored === 0, `purged no records when specified key was not found`);
-    t.ok(error, `error returned when specified key was not found`);
+    t.ok(purgedCountWhenErrored === 0, 'purged no records when specified key was not found');
+    t.ok(error, 'error returned when specified key was not found');
 
     // make sure other tts keys are still there
-    const cached = await client.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');
 
-    // 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';    
+    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);