0.2.4

Merge pull request #107 from jambonz/update-deps
update undici
2026-10-04 07:43:59 +00:00 · 2025-03-19 21:48:31 -04:00 · 2025-03-19 21:48:02 -04:00 · 2025-03-19 21:46:21 -04:00 · 2025-02-07 07:20:12 -05:00 · 2025-02-07 07:19:47 -05:00
25 changed files with 3867 additions and 2690 deletions
@@ -1 +0,0 @@
-test/*
@@ -1,126 +0,0 @@
-{
-  "env": {
-    "node": true,
-    "es6": true  
-  },
-  "parserOptions": {
-    "ecmaFeatures": {
-      "jsx": false,
-      "modules": false
-    },
-    "ecmaVersion": 2020
-  },
-  "plugins": ["promise"],
-  "rules": {
-    "promise/always-return": "error",
-    "promise/no-return-wrap": "error",
-    "promise/param-names": "error",
-    "promise/catch-or-return": "error",
-    "promise/no-native": "off",
-    "promise/no-nesting": "warn",
-    "promise/no-promise-in-callback": "warn",
-    "promise/no-callback-in-promise": "warn",
-    "promise/no-return-in-finally": "warn",
-
-    // Possible Errors
-    // http://eslint.org/docs/rules/#possible-errors
-    "comma-dangle": [2, "only-multiline"],
-    "no-control-regex": 2,
-    "no-debugger": 2,
-    "no-dupe-args": 2,
-    "no-dupe-keys": 2,
-    "no-duplicate-case": 2,
-    "no-empty-character-class": 2,
-    "no-ex-assign": 2,
-    "no-extra-boolean-cast" : 2,
-    "no-extra-parens": [2, "functions"],
-    "no-extra-semi": 2,
-    "no-func-assign": 2,
-    "no-invalid-regexp": 2,
-    "no-irregular-whitespace": 2,
-    "no-negated-in-lhs": 2,
-    "no-obj-calls": 2,
-    "no-proto": 2,
-    "no-unexpected-multiline": 2,
-    "no-unreachable": 2,
-    "use-isnan": 2,
-    "valid-typeof": 2,
-
-    // Best Practices
-    // http://eslint.org/docs/rules/#best-practices
-    "no-fallthrough": 2,
-    "no-octal": 2,
-    "no-redeclare": 2,
-    "no-self-assign": 2,
-    "no-unused-labels": 2,
-
-    // Strict Mode
-    // http://eslint.org/docs/rules/#strict-mode
-    "strict": [2, "never"],
-
-    // Variables
-    // http://eslint.org/docs/rules/#variables
-    "no-delete-var": 2,
-    "no-undef": 2,
-    "no-unused-vars": [2, {"args": "none"}],
-
-    // Node.js and CommonJS
-    // http://eslint.org/docs/rules/#nodejs-and-commonjs
-    "no-mixed-requires": 2,
-    "no-new-require": 2,
-    "no-path-concat": 2,
-    "no-restricted-modules": [2, "sys", "_linklist"],
-
-    // Stylistic Issues
-    // http://eslint.org/docs/rules/#stylistic-issues
-    "comma-spacing": 2,
-    "eol-last": 2,
-    "indent": [2, 2, {"SwitchCase": 1}],
-    "keyword-spacing": 2,
-    "max-len": [2, 120, 2],
-    "new-parens": 2,
-    "no-mixed-spaces-and-tabs": 2,
-    "no-multiple-empty-lines": [2, {"max": 2}],
-    "no-trailing-spaces": [2, {"skipBlankLines": false }],
-    "quotes": [2, "single", "avoid-escape"],
-    "semi": 2,
-    "space-before-blocks": [2, "always"],
-    "space-before-function-paren": [2, "never"],
-    "space-in-parens": [2, "never"],
-    "space-infix-ops": 2,
-    "space-unary-ops": 2,
-
-    // ECMAScript 6
-    // http://eslint.org/docs/rules/#ecmascript-6
-    "arrow-parens": [2, "always"],
-    "arrow-spacing": [2, {"before": true, "after": true}],
-    "constructor-super": 2,
-    "no-class-assign": 2,
-    "no-confusing-arrow": 2,
-    "no-const-assign": 2,
-    "no-dupe-class-members": 2,
-    "no-new-symbol": 2,
-    "no-this-before-super": 2,
-    "prefer-const": 2
-  },
-  "globals": {
-    "DTRACE_HTTP_CLIENT_REQUEST"           : false,
-    "LTTNG_HTTP_CLIENT_REQUEST"            : false,
-    "COUNTER_HTTP_CLIENT_REQUEST"          : false,
-    "DTRACE_HTTP_CLIENT_RESPONSE"          : false,
-    "LTTNG_HTTP_CLIENT_RESPONSE"           : false,
-    "COUNTER_HTTP_CLIENT_RESPONSE"         : false,
-    "DTRACE_HTTP_SERVER_REQUEST"           : false,
-    "LTTNG_HTTP_SERVER_REQUEST"            : false,
-    "COUNTER_HTTP_SERVER_REQUEST"          : false,
-    "DTRACE_HTTP_SERVER_RESPONSE"          : false,
-    "LTTNG_HTTP_SERVER_RESPONSE"           : false,
-    "COUNTER_HTTP_SERVER_RESPONSE"         : false,
-    "DTRACE_NET_STREAM_END"                : false,
-    "LTTNG_NET_STREAM_END"                 : false,
-    "COUNTER_NET_SERVER_CONNECTION_CLOSE"  : false,
-    "DTRACE_NET_SERVER_CONNECTION"         : false,
-    "LTTNG_NET_SERVER_CONNECTION"          : false,
-    "COUNTER_NET_SERVER_CONNECTION"        : false  
-  }
-}
@@ -8,11 +8,16 @@ jobs:
  build:
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
        with:
          node-version: lts/*
      - run: npm install
+      - name: Install Docker Compose
+        run: |
+          sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
+          sudo chmod +x /usr/local/bin/docker-compose
+          docker-compose --version
      - run: npm run jslint
      - run: sudo apt update && sudo apt install -y squid
      - run: sudo cp test/squid.conf /etc/squid/squid.conf
@@ -32,5 +37,7 @@ jobs:
          ELEVENLABS_API_KEY: ${{ secrets.ELEVENLABS_API_KEY }}
          ELEVENLABS_VOICE_ID: ${{ secrets.ELEVENLABS_VOICE_ID }}
          ELEVENLABS_MODEL_ID: ${{ secrets.ELEVENLABS_MODEL_ID }}
+          PLAYHT_USER_ID: ${{ secrets.PLAYHT_USER_ID }}
+          PLAYHT_API_KEY: ${{ secrets.PLAYHT_API_KEY }}
          JAMBONES_HTTP_PROXY_IP: 127.0.0.1
          JAMBONES_HTTP_PROXY_PORT: 3128
@@ -39,3 +39,5 @@ node_modules
 examples/*

 .vscode
+
+.env
@@ -0,0 +1,3 @@
+#npm audit
+npm run jslint:fix || true
+npm test
@@ -0,0 +1,140 @@
+const promise = require('eslint-plugin-promise');
+const globals = require('globals');
+
+
+module.exports = [
+  {
+    files: ['**/*.js', '*.js'],
+    languageOptions: {
+
+      ecmaVersion: 2020,
+      parserOptions: {
+        'node': true,
+        'es6': true,
+        ecmaFeatures: {
+          jsx: false,
+          modules: false,
+        }
+      },
+      sourceType: 'module',
+      globals: {
+        ...globals.node,
+        'DTRACE_HTTP_CLIENT_REQUEST': false,
+        'LTTNG_HTTP_CLIENT_REQUEST': false,
+        'COUNTER_HTTP_CLIENT_REQUEST': false,
+        'DTRACE_HTTP_CLIENT_RESPONSE': false,
+        'LTTNG_HTTP_CLIENT_RESPONSE': false,
+        'COUNTER_HTTP_CLIENT_RESPONSE': false,
+        'DTRACE_HTTP_SERVER_REQUEST': false,
+        'LTTNG_HTTP_SERVER_REQUEST': false,
+        'COUNTER_HTTP_SERVER_REQUEST': false,
+        'DTRACE_HTTP_SERVER_RESPONSE': false,
+        'LTTNG_HTTP_SERVER_RESPONSE': false,
+        'COUNTER_HTTP_SERVER_RESPONSE': false,
+        'DTRACE_NET_STREAM_END': false,
+        'LTTNG_NET_STREAM_END': false,
+        'COUNTER_NET_SERVER_CONNECTION_CLOSE': false,
+        'DTRACE_NET_SERVER_CONNECTION': false,
+        'LTTNG_NET_SERVER_CONNECTION': false,
+        'COUNTER_NET_SERVER_CONNECTION': false
+      },
+
+    },
+    'plugins': {
+      promise
+    },
+    'rules': {
+      'promise/always-return': 'error',
+      'promise/no-return-wrap': 'error',
+      'promise/param-names': 'error',
+      'promise/catch-or-return': 'error',
+      'promise/no-native': 'off',
+      'promise/no-nesting': 'warn',
+      'promise/no-promise-in-callback': 'warn',
+      'promise/no-callback-in-promise': 'warn',
+      'promise/no-return-in-finally': 'warn',
+
+      // Possible Errors
+      // http://eslint.org/docs/rules/#possible-errors
+      'comma-dangle': [2, 'only-multiline'],
+      'no-control-regex': 2,
+      'no-debugger': 2,
+      'no-dupe-args': 2,
+      'no-dupe-keys': 2,
+      'no-duplicate-case': 2,
+      'no-empty-character-class': 2,
+      'no-ex-assign': 2,
+      'no-extra-boolean-cast': 2,
+      'no-extra-parens': [2, 'functions'],
+      'no-extra-semi': 2,
+      'no-func-assign': 2,
+      'no-invalid-regexp': 2,
+      'no-irregular-whitespace': 2,
+      'no-negated-in-lhs': 2,
+      'no-obj-calls': 2,
+      'no-proto': 2,
+      'no-unexpected-multiline': 2,
+      'no-unreachable': 2,
+      'use-isnan': 2,
+      'valid-typeof': 2,
+
+      // Best Practices
+      // http://eslint.org/docs/rules/#best-practices
+      'no-fallthrough': 2,
+      'no-octal': 2,
+      'no-redeclare': 2,
+      'no-self-assign': 2,
+      'no-unused-labels': 2,
+
+      // Strict Mode
+      // http://eslint.org/docs/rules/#strict-mode
+      'strict': [2, 'never'],
+
+      // Variables
+      // http://eslint.org/docs/rules/#variables
+      'no-delete-var': 2,
+      'no-undef': 2,
+      'no-unused-vars': [2, { 'args': 'none' }],
+
+      // Node.js and CommonJS
+      // http://eslint.org/docs/rules/#nodejs-and-commonjs
+      'no-mixed-requires': 2,
+      'no-new-require': 2,
+      'no-path-concat': 2,
+      'no-restricted-modules': [2, 'sys', '_linklist'],
+
+      // Stylistic Issues
+      // http://eslint.org/docs/rules/#stylistic-issues
+      'comma-spacing': 2,
+      'eol-last': 2,
+      'indent': [2, 2, { 'SwitchCase': 1 }],
+      'keyword-spacing': 2,
+      'max-len': [2, 120, 2],
+      'new-parens': 2,
+      'no-mixed-spaces-and-tabs': 2,
+      'no-multiple-empty-lines': [2, { 'max': 2 }],
+      'no-trailing-spaces': [2, { 'skipBlankLines': false }],
+      'quotes': [2, 'single', 'avoid-escape'],
+      'semi': 2,
+      'space-before-blocks': [2, 'always'],
+      'space-before-function-paren': [2, 'never'],
+      'space-in-parens': [2, 'never'],
+      'space-infix-ops': 2,
+      'space-unary-ops': 2,
+
+      // ECMAScript 6
+      // http://eslint.org/docs/rules/#ecmascript-6
+      'arrow-parens': [2, 'always'],
+      'arrow-spacing': [2, { 'before': true, 'after': true }],
+      'constructor-super': 2,
+      'no-class-assign': 2,
+      'no-confusing-arrow': 2,
+      'no-const-assign': 2,
+      'no-dupe-class-members': 2,
+      'no-new-symbol': 2,
+      'no-this-before-super': 2,
+      'prefer-const': 2
+    },
+    'ignores': []
+  }
+];
@@ -13,10 +13,11 @@ module.exports = (opts, logger) => {
    getTtsSize: require('./lib/get-tts-size').bind(null, client, logger),
    purgeTtsCache: require('./lib/purge-tts-cache').bind(null, client, logger),
    addFileToCache: require('./lib/add-file-to-cache').bind(null, client, logger),
-    synthAudio: require('./lib/synth-audio').bind(null, client, logger),
+    synthAudio: require('./lib/synth-audio').bind(null, client, createHash, retrieveHash, logger),
+    getVerbioAccessToken: require('./lib/get-verbio-token').bind(null, client, logger),
    getNuanceAccessToken: require('./lib/get-nuance-access-token').bind(null, client, logger),
    getIbmAccessToken: require('./lib/get-ibm-access-token').bind(null, client, logger),
    getAwsAuthToken: require('./lib/get-aws-sts-token').bind(null, logger, createHash, retrieveHash),
-    getTtsVoices: require('./lib/get-tts-voices').bind(null, client, logger),
+    getTtsVoices: require('./lib/get-tts-voices').bind(null, client, createHash, retrieveHash, logger),
  };
 };
@@ -1,9 +1,31 @@
 const fs = require('fs/promises');
 const {noopLogger, makeSynthKey} = require('./utils');
-const EXPIRES = (process.env.JAMBONES_TTS_CACHE_DURATION_MINS || 4 * 60) * 60; // cache tts for 4 hours
+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}) {
+  {account_sid, vendor, language, voice, deploymentId, engine, model, text}) {
  let key;
  logger = logger || noopLogger;

@@ -14,10 +36,18 @@ async function addFileToCache(client, logger, path,
      language: language || '',
      voice: voice || deploymentId,
      engine,
+      model,
      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;
@@ -0,0 +1,25 @@
+const JAMBONES_TTS_TRIM_SILENCE = process.env.JAMBONES_TTS_TRIM_SILENCE;
+const JAMBONES_DISABLE_TTS_STREAMING = process.env.JAMBONES_DISABLE_TTS_STREAMING;
+const JAMBONES_DISABLE_AZURE_TTS_STREAMING = process.env.JAMBONES_DISABLE_AZURE_TTS_STREAMING;
+const JAMBONES_EAGERLY_PRE_CACHE_AUDIO = process.env.JAMBONES_EAGERLY_PRE_CACHE_AUDIO;
+
+const JAMBONES_HTTP_PROXY_IP = process.env.JAMBONES_HTTP_PROXY_IP;
+const JAMBONES_HTTP_PROXY_PORT = process.env.JAMBONES_HTTP_PROXY_PORT;
+const JAMBONES_TTS_CACHE_DURATION_MINS =
+  (parseInt(process.env.JAMBONES_TTS_CACHE_DURATION_MINS) || 4 * 60) * 60; // cache tts for 4 hours
+
+const TMP_FOLDER = '/tmp';
+
+const HTTP_TIMEOUT = 5000;
+
+module.exports = {
+  JAMBONES_TTS_TRIM_SILENCE,
+  JAMBONES_DISABLE_TTS_STREAMING,
+  JAMBONES_DISABLE_AZURE_TTS_STREAMING,
+  JAMBONES_HTTP_PROXY_IP,
+  JAMBONES_HTTP_PROXY_PORT,
+  JAMBONES_TTS_CACHE_DURATION_MINS,
+  JAMBONES_EAGERLY_PRE_CACHE_AUDIO,
+  TMP_FOLDER,
+  HTTP_TIMEOUT
+};
@@ -1,38 +1,71 @@
-const { STSClient, GetSessionTokenCommand } = require('@aws-sdk/client-sts');
+const { STSClient, GetSessionTokenCommand, AssumeRoleCommand } = require('@aws-sdk/client-sts');
 const {makeAwsKey, noopLogger} = require('./utils');
 const debug = require('debug')('jambonz:speech-utils');
-const EXPIRY = 3600;
+const EXPIRY = process.env.AWS_STS_SESSION_DURATION || 3600;
+// by default reset aws session before expiry time 10 mins
+const CACHE_EXPIRY = process.env.AWS_STS_SESSION_RESET_EXPIRY || (EXPIRY - 600);

 async function getAwsAuthToken(
-  logger,
-  createHash, retrieveHash,
-  awsAccessKeyId, awsSecretAccessKey, awsRegion) {
+  logger, createHash, retrieveHash,
+  {speech_credential_sid, accessKeyId, secretAccessKey, region, roleArn}) {
  logger = logger || noopLogger;
  try {
-    const key = makeAwsKey(awsAccessKeyId);
+    // 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 */
-    const stsClient = new STSClient({
-      region: awsRegion,
-      credentials: {
-        accessKeyId: awsAccessKeyId,
-        secretAccessKey: awsSecretAccessKey,
+    let data;
+    let expiry = CACHE_EXPIRY;
+    if (roleArn) {
+      const stsClient = new STSClient({ region });
+      const roleToAssume = { RoleArn: roleArn, RoleSessionName: 'Jambonz_Speech', DurationSeconds: EXPIRY};
+      const command = new AssumeRoleCommand(roleToAssume);
+
+      data = await stsClient.send(command);
+    } else if (accessKeyId) {
+      const stsClient = new STSClient({
+        region,
+        credentials: {
+          accessKeyId,
+          secretAccessKey,
+        }
+      });
+      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;
      }
-    });
-    const command = new GetSessionTokenCommand({DurationSeconds: EXPIRY});
-    const data = await stsClient.send(command);
+      data = {
+        Credentials: {
+          AccessKeyId: cred.accessKeyId,
+          SecretAccessKey: cred.secretAccessKey,
+          SessionToken: cred.sessionToken
+        }
+      };
+    }

    const credentials = {
      accessKeyId: data.Credentials.AccessKeyId,
      secretAccessKey: data.Credentials.SecretAccessKey,
+      sessionToken: data.Credentials.SessionToken,
      securityToken: data.Credentials.SessionToken
    };
-
-    /* expire 10 minutes before the hour, so we don't lose the use of it during a call */
-    createHash(key, credentials, EXPIRY - 600)
-      .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) {
@@ -2,8 +2,8 @@ const formurlencoded = require('form-urlencoded');
 const {Pool} = require('undici');
 const pool = new Pool('https://iam.cloud.ibm.com');
 const {makeIbmKey, noopLogger} = require('./utils');
+const { HTTP_TIMEOUT } = require('./config');
 const debug = require('debug')('jambonz:realtimedb-helpers');
-const HTTP_TIMEOUT = 5000;

 async function getIbmAccessToken(client, logger, apiKey) {
  logger = logger || noopLogger;
@@ -2,8 +2,8 @@ const formurlencoded = require('form-urlencoded');
 const {Pool} = require('undici');
 const pool = new Pool('https://auth.crt.nuance.com');
 const {makeNuanceKey, makeBasicAuthHeader, noopLogger} = require('./utils');
+const { HTTP_TIMEOUT } = require('./config');
 const debug = require('debug')('jambonz:realtimedb-helpers');
-const HTTP_TIMEOUT = 5000;

 async function getNuanceAccessToken(client, logger, clientId, secret, scope) {
  logger = logger || noopLogger;
@@ -1,11 +1,16 @@
 const assert = require('assert');
 const {noopLogger, createNuanceClient, createKryptonClient} = require('./utils');
 const getNuanceAccessToken = require('./get-nuance-access-token');
+const getVerbioAccessToken = require('./get-verbio-token');
 const {GetVoicesRequest, Voice} = require('../stubs/nuance/synthesizer_pb');
 const TextToSpeechV1 = require('ibm-watson/text-to-speech/v1');
 const { IamAuthenticator } = require('ibm-watson/auth');
 const ttsGoogle = require('@google-cloud/text-to-speech');
 const { PollyClient, DescribeVoicesCommand } = require('@aws-sdk/client-polly');
+const getAwsAuthToken = require('./get-aws-sts-token');
+const {Pool} = require('undici');
+const { HTTP_TIMEOUT } = require('./config');
+const verbioVoicePool = new Pool('https://us.rest.speechcenter.verbio.com');

 const getIbmVoices = async(client, logger, credentials) => {
  const {tts_region, tts_api_key} = credentials;
@@ -87,16 +92,31 @@ const getGoogleVoices = async(_client, logger, credentials) => {
  return await client.listVoices();
 };

-const getAwsVoices = async(_client, logger, credentials) => {
+const getAwsVoices = async(_client, createHash, retrieveHash, logger, credentials) => {
  try {
-    const {region, accessKeyId, secretAccessKey} = credentials;
-    const client = new PollyClient({
-      region,
-      credentials: {
-        accessKeyId,
-        secretAccessKey
-      }
-    });
+    const {region, accessKeyId, secretAccessKey, roleArn} = credentials;
+    let client = null;
+    if (accessKeyId && secretAccessKey) {
+      client = new PollyClient({
+        region,
+        credentials: {
+          accessKeyId,
+          secretAccessKey
+        }
+      });
+    } else if (roleArn) {
+      client = new PollyClient({
+        region,
+        credentials: await getAwsAuthToken(
+          logger, createHash, retrieveHash,
+          {
+            region,
+            roleArn
+          }),
+      });
+    } else {
+      client = new PollyClient({region});
+    }
    const command = new DescribeVoicesCommand({});
    const response = await client.send(command);
    return response;
@@ -106,6 +126,26 @@ const getAwsVoices = async(_client, logger, credentials) => {
  }
 };

+const getVerbioVoices = async(client, logger, credentials) => {
+  try {
+    const access_token = await getVerbioAccessToken(client, logger, credentials);
+    const { body} =  await verbioVoicePool.request({
+      path: '/api/v1/voices',
+      method: 'GET',
+      headers: {
+        'Authorization': `Bearer ${access_token.access_token}`,
+        'User-Agent': 'jambonz'
+      },
+      timeout: HTTP_TIMEOUT,
+      followRedirects: false
+    });
+    return await body.json();
+  } catch (err) {
+    logger.info({err}, 'getVerbioVoices - failed to list voices for Verbio');
+    throw err;
+  }
+};
+
 /**
 * Synthesize speech to an mp3 file, and also cache the generated speech
 * in redis (base64 format) for 24 hours so as to avoid unnecessarily paying
@@ -122,10 +162,10 @@ const getAwsVoices = async(_client, logger, credentials) => {
 * @returns object containing filepath to an mp3 file in the /tmp folder containing
 * the synthesized audio, and a variable indicating whether it was served from cache
 */
-async function getTtsVoices(client, logger, {vendor, credentials}) {
+async function getTtsVoices(client, createHash, retrieveHash, logger, {vendor, credentials}) {
  logger = logger || noopLogger;

-  assert.ok(['nuance', 'ibm', 'google', 'aws', 'polly'].includes(vendor),
+  assert.ok(['nuance', 'ibm', 'google', 'aws', 'polly', 'verbio'].includes(vendor),
    `getTtsVoices not supported for vendor ${vendor}`);

  switch (vendor) {
@@ -137,7 +177,9 @@ async function getTtsVoices(client, logger, {vendor, credentials}) {
      return getGoogleVoices(client, logger, credentials);
    case 'aws':
    case 'polly':
-      return getAwsVoices(client, logger, credentials);
+      return getAwsVoices(client, createHash, retrieveHash, logger, credentials);
+    case 'verbio':
+      return getVerbioVoices(client, logger, credentials);
    default:
      break;
  }
@@ -0,0 +1,51 @@
+const {Pool} = require('undici');
+const { noopLogger, makeVerbioKey } = require('./utils');
+const { HTTP_TIMEOUT } = require('./config');
+const pool = new Pool('https://auth.speechcenter.verbio.com:444');
+const debug = require('debug')('jambonz:realtimedb-helpers');
+
+async function getVerbioAccessToken(client, logger, credentials) {
+  logger = logger || noopLogger;
+  const { client_id, client_secret } = credentials;
+  try {
+    const key = makeVerbioKey(client_id);
+    const access_token = await client.get(key);
+    if (access_token) {
+      return {access_token, servedFromCache: true};
+    }
+
+    const payload = {
+      client_id,
+      client_secret
+    };
+
+    const {statusCode, headers, body} =  await pool.request({
+      path: '/api/v1/token',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'User-Agent': 'jambonz'
+      },
+      body: JSON.stringify(payload),
+      timeout: HTTP_TIMEOUT,
+      followRedirects: false
+    });
+
+    if (200 !== statusCode) {
+      logger.debug({statusCode, headers, body: await body.text()}, 'error fetching access token from Verbio');
+      const err = new Error();
+      err.statusCode = statusCode;
+      throw err;
+    }
+    const json = await body.json();
+    const expiry =  Math.floor(json.expiration_time - Date.now() / 1000 - 30);
+    await client.set(key, json.access_token, 'EX', expiry);
+    return {...json, servedFromCache: false};
+  } catch (err) {
+    debug(err, `getVerbioAccessToken: Error retrieving Verbio access token for client_id ${client_id}`);
+    logger.error(err, `getVerbioAccessToken: Error retrieving Verbio access token for client_id ${client_id}`);
+    throw err;
+  }
+}
+
+module.exports = getVerbioAccessToken;
@@ -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, text} = {all: true}) {
+  language, voice, deploymentId, engine, model, text} = {all: true}) {
  logger = logger || noopLogger;

  let purgedCount = 0, error;
@@ -33,6 +33,7 @@ async function purgeTtsCache(client, logger, {all, account_sid, vendor,
        language: language || '',
        voice: voice || deploymentId,
        engine,
+        model,
        text,
      });
      purgedCount = await client.del(key);
@@ -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');
@@ -19,9 +20,12 @@ const {
  createNuanceClient,
  createKryptonClient,
  createRivaClient,
-  noopLogger
+  noopLogger,
+  makeFilePath,
+  makePlayhtKey
 } = require('./utils');
 const getNuanceAccessToken = require('./get-nuance-access-token');
+const getVerbioAccessToken = require('./get-verbio-token');
 const {
  SynthesisRequest,
  Voice,
@@ -36,9 +40,17 @@ const {
 const {SynthesizeSpeechRequest} = require('../stubs/riva/proto/riva_tts_pb');
 const {AudioEncoding} = require('../stubs/riva/proto/riva_audio_pb');
 const debug = require('debug')('jambonz:realtimedb-helpers');
-const EXPIRES = (process.env.JAMBONES_TTS_CACHE_DURATION_MINS || 4 * 60) * 60; // cache tts for 4 hours
-const TMP_FOLDER = '/tmp';
+const {
+  JAMBONES_DISABLE_TTS_STREAMING,
+  JAMBONES_DISABLE_AZURE_TTS_STREAMING,
+  JAMBONES_HTTP_PROXY_IP,
+  JAMBONES_HTTP_PROXY_PORT,
+  JAMBONES_TTS_CACHE_DURATION_MINS,
+  JAMBONES_TTS_TRIM_SILENCE,
+} = require('./config');
+const EXPIRES = JAMBONES_TTS_CACHE_DURATION_MINS;
 const OpenAI = require('openai');
+const getAwsAuthToken = require('./get-aws-sts-token');


 const trimTrailingSilence = (buffer) => {
@@ -75,19 +87,19 @@ const trimTrailingSilence = (buffer) => {
 * @returns object containing filepath to an mp3 file in the /tmp folder containing
 * the synthesized audio, and a variable indicating whether it was served from cache
 */
-async function synthAudio(client, logger, stats, { account_sid,
+async function synthAudio(client, createHash, retrieveHash, logger, stats, { account_sid,
  vendor, language, voice, gender, text, engine, salt, model, credentials, deploymentId,
-  disableTtsCache, renderForCaching, disableTtsStreaming, options
+  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'].includes(vendor) ||
+  assert.ok(['google', 'aws', 'polly', 'microsoft', 'wellsaid', 'nuance', 'nvidia', 'ibm', 'elevenlabs',
+    'whisper', 'deepgram', 'playht', 'rimelabs', 'verbio', 'cartesia'].includes(vendor) ||
  vendor.startsWith('custom'),
-  `synthAudio supported vendors are google, aws, microsoft, nuance, nvidia and wellsaid, not ${vendor}`);
+  `synthAudio supported vendors are google, aws, microsoft, nuance, nvidia and wellsaid ..etc, not ${vendor}`);
  if ('google' === vendor) {
    assert.ok(language, 'synthAudio requires language when google is used');
  }
@@ -123,35 +135,45 @@ async function synthAudio(client, logger, stats, { account_sid,
    assert.ok(voice, 'synthAudio requires voice when elevenlabs is used');
    assert.ok(credentials.api_key, 'synthAudio requires api_key when elevenlabs is used');
    assert.ok(credentials.model_id, 'synthAudio requires model_id when elevenlabs is used');
+  } else if ('playht' === vendor) {
+    assert.ok(voice, 'synthAudio requires voice when playht is used');
+    assert.ok(credentials.api_key, 'synthAudio requires api_key when playht is used');
+    assert.ok(credentials.user_id, 'synthAudio requires user_id when playht is used');
+    assert.ok(credentials.voice_engine, 'synthAudio requires voice_engine when playht is used');
+  } else if ('rimelabs' === vendor) {
+    assert.ok(voice, 'synthAudio requires voice when rimelabs is used');
+    assert.ok(credentials.api_key, 'synthAudio requires api_key when rimelabs is used');
+    assert.ok(credentials.model_id, 'synthAudio requires model_id when rimelabs is used');
  } else if ('whisper' === vendor) {
    assert.ok(voice, 'synthAudio requires voice when whisper is used');
    assert.ok(credentials.model_id, 'synthAudio requires model when whisper is used');
    assert.ok(credentials.api_key, 'synthAudio requires api_key when whisper is used');
  } else  if (vendor.startsWith('custom')) {
    assert.ok(credentials.custom_tts_url, `synthAudio requires custom_tts_url in credentials when ${vendor} is used`);
+  } else if ('verbio' === vendor) {
+    assert.ok(voice, 'synthAudio requires voice when verbio is used');
+    assert.ok(credentials.client_id, 'synthAudio requires client_id when verbio is used');
+    assert.ok(credentials.client_secret, 'synthAudio requires client_secret when verbio is used');
+  } else if ('deepgram' === vendor) {
+    if (!credentials.deepgram_tts_uri) {
+      assert.ok(credentials.api_key, 'synthAudio requires api_key when deepgram is used');
+    }
+  } 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({
    account_sid,
    vendor,
    language: language || '',
    voice: voice || deploymentId,
    engine,
+    // model or model_id is used to identify the tts cache.
+    model: model || credentials.model_id,
    text
  });
-  let filePath;
-  if (['nuance', 'nvidia'].includes(vendor) ||
-    (
-      (process.env.JAMBONES_TTS_TRIM_SILENCE || !process.env.JAMBONES_DISABLE_TTS_STREAMING) &&
-      ['microsoft', 'azure'].includes(vendor)
-    ) ||
-    (
-      !process.env.JAMBONES_DISABLE_TTS_STREAMING &&
-      ['elevenlabs', 'deepgram'].includes(vendor)
-    )
-  ) {
-    filePath = `${TMP_FOLDER}/${key.replace('tts:', `tts-${salt || ''}`)}.r8`;
-  }
-  else filePath = `${TMP_FOLDER}/${key.replace('tts:', `tts-${salt || ''}`)}.mp3`;
+
  debug(`synth key is ${key}`);
  let cached;
  if (!disableTtsCache) {
@@ -162,10 +184,11 @@ async function synthAudio(client, logger, stats, { account_sid,
    debug('result WAS found in cache');
    servedFromCache = true;
    stats.increment('tts.cache.requests', ['found:yes']);
-    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']);
@@ -173,85 +196,125 @@ async function synthAudio(client, logger, stats, { account_sid,
    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(logger, {credentials, stats, language, voice, text, engine});
+        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});
-        if (audioBuffer?.filePath) return audioBuffer;
+        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
-        });
-        if (audioBuffer?.filePath) return audioBuffer;
+        audioData = await synthElevenlabs(logger, {
+          credentials, options, stats, language, voice, text, renderForCaching, disableTtsStreaming});
+        break;
+      case 'playht':
+        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':
+        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});
-        if (audioBuffer?.filePath) return audioBuffer;
+        break;
+      case 'verbio':
+        audioData = await synthVerbio(client, logger, {
+          credentials, stats, voice, text, renderForCaching, disableTtsStreaming});
+        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});
-        if (audioBuffer?.filePath) return audioBuffer;
        break;
      case vendor.startsWith('custom') ? vendor : 'cant_match_value':
-        ({ audioBuffer, filePath } = 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 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}`);
-
-    client.setex(key, EXPIRES, audioBuffer.toString('base64'))
+    // 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});
    });
  });
 }

-const synthPolly = async(logger, {credentials, stats, language, voice, engine, text}) => {
+const synthPolly = async(createHash, retrieveHash, logger,
+  {credentials, stats, language, voice, engine, text}) => {
  try {
-    const {region, accessKeyId, secretAccessKey} = credentials;
-    const polly = new PollyClient({
-      region,
-      credentials: {
-        accessKeyId,
-        secretAccessKey
-      }
-    });
+    const {region, accessKeyId, secretAccessKey, roleArn} = credentials;
+    let polly;
+    if (accessKeyId && secretAccessKey) {
+      polly = new PollyClient({
+        region,
+        credentials: {
+          accessKeyId,
+          secretAccessKey
+        }
+      });
+    } else if (roleArn) {
+      polly = new PollyClient({
+        region,
+        credentials: await getAwsAuthToken(
+          logger, createHash, retrieveHash,
+          {
+            region,
+            roleArn
+          }),
+      });
+    } else {
+      // AWS RoleArn assigned to Instance profile
+      polly = new PollyClient({region});
+    }
    const opts = {
      Engine: engine,
      OutputFormat: 'mp3',
@@ -273,7 +336,13 @@ const synthPolly = async(logger, {credentials, stats, language, voice, engine, t
        .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');
@@ -284,6 +353,48 @@ const synthPolly = async(logger, {credentials, stats, language, voice, engine, t

 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 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;
+    }
+  }
+
  const opts = {
    voice: {
      ...(typeof voice === 'string' && {name: voice}),
@@ -298,7 +409,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');
@@ -329,7 +444,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']);
@@ -339,13 +458,11 @@ 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} = credentials;
+  const {use_custom_tts, custom_tts_endpoint_url, api_key} = credentials;
  let content = text;

  if (use_custom_tts && !content.startsWith('<speak')) {
@@ -365,14 +482,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'
+      '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;
@@ -385,7 +507,6 @@ const synthMicrosoft = async(logger, {
  language,
  voice,
  text,
-  filePath,
  renderForCaching,
  disableTtsStreaming
 }) => {
@@ -408,7 +529,8 @@ const synthMicrosoft = async(logger, {
      content = `<speak version="1.0" xmlns="http://www.w3.org/2001/10/synthesis" xmlns:mstts="https://www.w3.org/2001/mstts" xml:lang="${language}"><voice name="${voice}">${words}</voice></speak>`;
      logger.info({content}, 'synthMicrosoft');
    }
-    if (!process.env.JAMBONES_DISABLE_TTS_STREAMING && !renderForCaching && !disableTtsStreaming) {
+    if (!JAMBONES_DISABLE_TTS_STREAMING && !JAMBONES_DISABLE_AZURE_TTS_STREAMING &&
+      !renderForCaching && !disableTtsStreaming) {
      let params = '';
      params += `{api_key=${apiKey}`;
      params += `,language=${language}`;
@@ -417,8 +539,9 @@ const synthMicrosoft = async(logger, {
      params += ',write_cache_file=1';
      if (region) params += `,region=${region}`;
      if (custom_tts_endpoint) params += `,endpointId=${custom_tts_endpoint}`;
-      if (process.env.JAMBONES_HTTP_PROXY_IP) params += `,http_proxy_ip=${process.env.JAMBONES_HTTP_PROXY_IP}`;
-      if (process.env.JAMBONES_HTTP_PROXY_PORT) params += `,http_proxy_port=${process.env.JAMBONES_HTTP_PROXY_PORT}`;
+      if (custom_tts_endpoint_url) params += `,endpoint=${custom_tts_endpoint_url}`;
+      if (JAMBONES_HTTP_PROXY_IP) params += `,http_proxy_ip=${JAMBONES_HTTP_PROXY_IP}`;
+      if (JAMBONES_HTTP_PROXY_PORT) params += `,http_proxy_port=${JAMBONES_HTTP_PROXY_PORT}`;
      params += '}';
      return {
        filePath: `say:${params}${content.replace(/\n/g, ' ')}`,
@@ -426,17 +549,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;
@@ -447,10 +571,10 @@ const synthMicrosoft = async(logger, {
      SpeechSynthesisOutputFormat.Raw8Khz16BitMonoPcm :
      SpeechSynthesisOutputFormat.Audio16Khz32KBitRateMonoMp3;

-    if (process.env.JAMBONES_HTTP_PROXY_IP && process.env.JAMBONES_HTTP_PROXY_PORT) {
+    if (JAMBONES_HTTP_PROXY_IP && JAMBONES_HTTP_PROXY_PORT) {
      logger.debug(
-        `synthMicrosoft: using proxy ${process.env.JAMBONES_HTTP_PROXY_IP}:${process.env.JAMBONES_HTTP_PROXY_PORT}`);
-      speechConfig.setProxy(process.env.JAMBONES_HTTP_PROXY_IP, process.env.JAMBONES_HTTP_PROXY_PORT);
+        `synthMicrosoft: using proxy ${JAMBONES_HTTP_PROXY_IP}:${JAMBONES_HTTP_PROXY_PORT}`);
+      speechConfig.setProxy(JAMBONES_HTTP_PROXY_IP, JAMBONES_HTTP_PROXY_PORT);
    }
    const synthesizer = new SpeechSynthesizer(speechConfig);

@@ -471,7 +595,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;
@@ -501,11 +629,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;
@@ -542,8 +674,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);
@@ -567,7 +699,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
+      });
    });
  });
 };
@@ -575,12 +711,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) {
@@ -594,7 +731,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
+      });
    });
  });
 };
@@ -616,12 +757,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 [extension, sampleRate] = getFileExtFromMime(mime);
    return {
-      audioBuffer: buffer,
-      filePath: filePath.replace(regex, getFileExtFromMime(mime))
+      audioContent: buffer,
+      extension,
+      sampleRate
    };
  } catch (err) {
    logger.info({err}, `Vendor ${vendor} returned error`);
@@ -636,7 +778,7 @@ const synthElevenlabs = async(logger, {
  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 (!process.env.JAMBONES_DISABLE_TTS_STREAMING && !renderForCaching && !disableTtsStreaming) {
+  if (!JAMBONES_DISABLE_TTS_STREAMING && !renderForCaching && !disableTtsStreaming) {
    let params = '';
    params += `{api_key=${api_key}`;
    params += ',vendor=elevenlabs';
@@ -648,6 +790,8 @@ const synthElevenlabs = async(logger, {
    if (opts.voice_settings?.stability) params += `,stability=${opts.voice_settings.stability}`;
    if (opts.voice_settings?.style) params += `,style=${opts.voice_settings.style}`;
    if (opts.voice_settings?.use_speaker_boost === false) params += ',use_speaker_boost=false';
+    if (opts.previous_text) params += `,previous_text=${opts.previous_text}`;
+    if (opts.next_text) params += `,next_text=${opts.next_text}`;
    params += '}';

    return {
@@ -665,7 +809,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: {
@@ -674,7 +818,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']);
@@ -682,10 +830,202 @@ const synthElevenlabs = async(logger, {
  }
 };

+const synthPlayHT = async(client, logger, {
+  credentials, options, stats, voice, language, text, renderForCaching, disableTtsStreaming
+}) => {
+  const {api_key, user_id, voice_engine, options: credOpts} = credentials;
+  const opts = !!options && Object.keys(options).length !== 0 ? options : JSON.parse(credOpts || '{}');
+
+  let synthesizeUrl = 'https://api.play.ht/api/v2/tts/stream';
+
+  // If model is play3.0, the synthesizeUrl is got from authentication endpoint
+  if (voice_engine === 'Play3.0') {
+    try {
+      const post = bent('https://api.play.ht', 'POST', 'json', 201, {
+        'AUTHORIZATION': api_key,
+        'X-USER-ID': user_id,
+        'Accept': 'application/json'
+      });
+      const key = makePlayhtKey(api_key);
+      const url = await client.get(key);
+      if (!url) {
+        const {inference_address, expires_at_ms} = await post('/api/v3/auth');
+        synthesizeUrl = inference_address;
+        const expiry =  Math.floor((expires_at_ms - Date.now()) / 1000 - 30);
+        await client.set(key, inference_address, 'EX', expiry);
+      } else {
+        // Use cached URL
+        synthesizeUrl = url;
+      }
+    } catch (err) {
+      logger.info({err}, 'synth PlayHT returned error for authentication version 3.0');
+      stats.increment('tts.count', ['vendor:playht', 'accepted:no']);
+      throw err;
+    }
+  }
+
+  /* default to using the streaming interface, unless disabled by env var OR we want just a cache file */
+  if (!JAMBONES_DISABLE_TTS_STREAMING && !renderForCaching && !disableTtsStreaming) {
+    let params = '';
+    params += `{api_key=${api_key}`;
+    params += `,user_id=${user_id}`;
+    params += ',vendor=playht';
+    params += `,voice=${voice}`;
+    params += `,voice_engine=${voice_engine}`;
+    params += `,synthesize_url=${synthesizeUrl}`;
+    params += ',write_cache_file=1';
+    params += `,language=${language}`;
+    if (opts.quality) params += `,quality=${opts.quality}`;
+    if (opts.speed) params += `,speed=${opts.speed}`;
+    if (opts.seed) params += `,style=${opts.seed}`;
+    if (opts.temperature) params += `,temperature=${opts.temperature}`;
+    if (opts.emotion) params += `,emotion=${opts.emotion}`;
+    if (opts.voice_guidance) params += `,voice_guidance=${opts.voice_guidance}`;
+    if (opts.style_guidance) params += `,style_guidance=${opts.style_guidance}`;
+    if (opts.text_guidance) params += `,text_guidance=${opts.text_guidance}`;
+    if (opts.top_p) params += `,top_p=${opts.top_p}`;
+    if (opts.repetition_penalty) params += `,repetition_penalty=${opts.repetition_penalty}`;
+    params += '}';
+
+    return {
+      filePath: `say:${params}${text.replace(/\n/g, ' ').replace(/\r/g, ' ')}`,
+      servedFromCache: false,
+      rtt: 0
+    };
+  }
+
+  try {
+    const post = bent('POST', 'buffer', {
+      ...(voice_engine !== 'Play3.0' && {
+        'AUTHORIZATION': api_key,
+        'X-USER-ID': user_id,
+      }),
+      'Accept': 'audio/mpeg',
+      'Content-Type': 'application/json'
+    });
+
+    const audioContent = await post(synthesizeUrl, {
+      text,
+      ...(voice_engine === 'Play3.0' && { language }),
+      voice,
+      voice_engine,
+      output_format: 'mp3',
+      sample_rate: 8000,
+      ...opts
+    });
+    return {
+      audioContent,
+      extension: 'mp3',
+      sampleRate: 8000
+    };
+  } catch (err) {
+    logger.info({err}, 'synth PlayHT returned error');
+    stats.increment('tts.count', ['vendor:playht', 'accepted:no']);
+    throw err;
+  }
+};
+
+const synthRimelabs = async(logger, {
+  credentials, options, stats, language, voice, text, renderForCaching, disableTtsStreaming
+}) => {
+  const {api_key, model_id, options: credOpts} = credentials;
+  const opts = !!options && Object.keys(options).length !== 0 ? options : JSON.parse(credOpts || '{}');
+
+  /* default to using the streaming interface, unless disabled by env var OR we want just a cache file */
+  if (!JAMBONES_DISABLE_TTS_STREAMING && !renderForCaching && !disableTtsStreaming) {
+    let params = '';
+    params += `{api_key=${api_key}`;
+    params += `,model_id=${model_id}`;
+    params += ',vendor=rimelabs';
+    params += `,language=${language}`;
+    params += `,voice=${voice}`;
+    params += ',write_cache_file=1';
+    if (opts.speedAlpha) params += `,speed_alpha=${opts.speedAlpha}`;
+    if (opts.reduceLatency) params += `,reduce_latency=${opts.reduceLatency}`;
+    params += '}';
+
+    return {
+      filePath: `say:${params}${text.replace(/\n/g, ' ').replace(/\r/g, ' ')}`,
+      servedFromCache: false,
+      rtt: 0
+    };
+  }
+
+  try {
+    const post = bent('https://users.rime.ai', 'POST', 'buffer', {
+      'Authorization': `Bearer ${api_key}`,
+      'Accept': 'audio/mp3',
+      'Content-Type': 'application/json'
+    });
+    const sampleRate = 8000;
+    const audioContent = await post('/v1/rime-tts', {
+      speaker: voice,
+      text,
+      modelId: model_id,
+      samplingRate: sampleRate,
+      lang: language,
+      ...opts
+    });
+    return {
+      audioContent,
+      extension: 'mp3',
+      sampleRate
+    };
+  } catch (err) {
+    logger.info({err}, 'synth rimelabs returned error');
+    stats.increment('tts.count', ['vendor:rimelabs', 'accepted:no']);
+    throw err;
+  }
+};
+const synthVerbio = async(client, logger, {credentials, stats, voice, text, renderForCaching, disableTtsStreaming}) => {
+  //https://doc.speechcenter.verbio.com/#tag/Text-To-Speech-REST-API
+  if (text.length > 2000) {
+    throw new Error('Verbio cannot synthesize for the text length larger than 2000 characters');
+  }
+  const token = await getVerbioAccessToken(client, logger, credentials);
+  if (!process.env.JAMBONES_DISABLE_TTS_STREAMING && !renderForCaching && !disableTtsStreaming) {
+    let params = '';
+    params += `{access_token=${token.access_token}`;
+    params += ',vendor=verbio';
+    params += `,voice=${voice}`;
+    params += ',write_cache_file=1';
+    params += '}';
+
+    return {
+      filePath: `say:${params}${text.replace(/\n/g, ' ')}`,
+      servedFromCache: false,
+      rtt: 0
+    };
+  }
+
+  try {
+    const post = bent('https://us.rest.speechcenter.verbio.com', 'POST', 'buffer', {
+      'Authorization': `Bearer ${token.access_token}`,
+      'User-Agent': 'jambonz',
+      'Content-Type': 'application/json'
+    });
+    const audioContent = await post('/api/v1/synthesize', {
+      voice_id: voice,
+      output_sample_rate: '8k',
+      output_encoding: 'pcm16',
+      text
+    });
+    return {
+      audioContent,
+      extension: 'r8',
+      sampleRate: 8000
+    };
+  } catch (err) {
+    logger.info({err}, 'synth Verbio returned error');
+    stats.increment('tts.count', ['vendor:verbio', 'accepted:no']);
+    throw err;
+  }
+};
+
 const synthWhisper = async(logger, {credentials, stats, voice, text, renderForCaching, disableTtsStreaming}) => {
  const {api_key, model_id, baseURL, timeout, speed} = credentials;
  /* if the env is set to stream then bag out, unless we are specifically rendering to generate a cache file */
-  if (!process.env.JAMBONES_DISABLE_TTS_STREAMING && !renderForCaching && !disableTtsStreaming) {
+  if (!JAMBONES_DISABLE_TTS_STREAMING && !renderForCaching && !disableTtsStreaming) {
    let params = '';
    params += `{api_key=${api_key}`;
    params += `,model_id=${model_id}`;
@@ -714,7 +1054,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']);
@@ -723,13 +1067,14 @@ const synthWhisper = async(logger, {credentials, stats, voice, text, renderForCa
 };

 const synthDeepgram = async(logger, {credentials, stats, model, text, renderForCaching, disableTtsStreaming}) => {
-  const {api_key} = credentials;
-  if (!process.env.JAMBONES_DISABLE_TTS_STREAMING && !renderForCaching && !disableTtsStreaming) {
+  const {api_key, deepgram_tts_uri} = credentials;
+  if (!JAMBONES_DISABLE_TTS_STREAMING && !renderForCaching && !disableTtsStreaming) {
    let params = '';
    params += `{api_key=${api_key}`;
    params += ',vendor=deepgram';
    params += `,voice=${model}`;
    params += ',write_cache_file=1';
+    if (deepgram_tts_uri) params += `,endpoint=${deepgram_tts_uri}`;
    params += '}';

    return {
@@ -739,15 +1084,20 @@ const synthDeepgram = async(logger, {credentials, stats, model, text, renderForC
    };
  }
  try {
-    const post = bent('https://api.deepgram.com', 'POST', 'buffer', {
-      'Authorization': `Token ${api_key}`,
+    const post = bent(deepgram_tts_uri || 'https://api.deepgram.com', 'POST', 'buffer', {
+      // on-premise deepgram does not  require to have api_key
+      ...(api_key && {'Authorization': `Token ${api_key}`}),
      'Accept': 'audio/mpeg',
      'Content-Type': 'application/json'
    });
-    const mp3 = await post(`/v1/speak?model=${model}`, {
+    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']);
@@ -755,26 +1105,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];
  }
 };

@@ -3,10 +3,10 @@ const {SynthesizerClient} = require('../stubs/nuance/synthesizer_grpc_pb');
 const {RivaSpeechSynthesisClient} = require('../stubs/riva/proto/riva_tts_grpc_pb');
 const {Pool} = require('undici');
 const pool = new Pool('https://auth.crt.nuance.com');
-const HTTP_TIMEOUT = 5000;
 const NUANCE_AUTH_ENDPOINT = 'tts.api.nuance.com:443';
 const grpc = require('@grpc/grpc-js');
 const formurlencoded = require('form-urlencoded');
+const { TMP_FOLDER, HTTP_TIMEOUT } = require('./config');

 const debug = require('debug')('jambonz:realtimedb-helpers');
 /**
@@ -16,12 +16,28 @@ const debug = require('debug')('jambonz:realtimedb-helpers');
 */
 //const nuanceClientMap = new Map();

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

+function makeFilePath({key, salt = '', extension}) {
+  return `${TMP_FOLDER}/${key.replace('tts:', `tts-${salt}`)}.${extension}`;
+}
+
+
 const noopLogger = {
  info: () => {},
  debug: () => {},
@@ -49,6 +65,17 @@ function makeAwsKey(awsAccessKeyId) {
  return `aws:${hash.digest('hex')}`;
 }

+function makePlayhtKey(apiKey) {
+  const hash = crypto.createHash('sha1');
+  hash.update(apiKey);
+  return `playht:${hash.digest('hex')}`;
+}
+function makeVerbioKey(client_id) {
+  const hash = crypto.createHash('sha1');
+  hash.update(client_id);
+  return `verbio:${hash.digest('hex')}`;
+}
+
 function makeNuanceKey(clientId, secret, scope) {
  const hash = crypto.createHash('sha1');
  hash.update(`${clientId}:${secret}:${scope}`);
@@ -116,12 +143,15 @@ module.exports = {
  makeSynthKey,
  makeNuanceKey,
  makeIbmKey,
+  makePlayhtKey,
  makeAwsKey,
+  makeVerbioKey,
  getNuanceAccessToken,
  createNuanceClient,
  createKryptonClient,
  createRivaClient,
  makeBasicAuthHeader,
  NUANCE_AUTH_ENDPOINT,
-  noopLogger
+  noopLogger,
+  makeFilePath
 };
@@ -1,6 +1,6 @@
 {
  "name": "@jambonz/speech-utils",
-  "version": "0.0.48",
+  "version": "0.2.4",
  "description": "TTS-related speech utilities for jambonz",
  "main": "index.js",
  "author": "Dave Horton",
@@ -12,7 +12,9 @@
    "test": "NODE_ENV=test node test/ ",
    "coverage": "nyc --reporter html --report-dir ./coverage npm run test",
    "jslint": "eslint index.js lib",
-    "build": "./build_stubs.sh"
+    "jslint:fix": "npm run jslint --fix",
+    "build": "./build_stubs.sh",
+    "prepare": "husky"
  },
  "repository": {
    "type": "git",
@@ -26,7 +28,8 @@
  "dependencies": {
    "@aws-sdk/client-polly": "^3.496.0",
    "@aws-sdk/client-sts": "^3.496.0",
-    "@google-cloud/text-to-speech": "^5.0.2",
+    "@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",
    "bent": "^7.3.12",
@@ -34,16 +37,17 @@
    "form-urlencoded": "^6.1.4",
    "google-protobuf": "^3.21.2",
    "ibm-watson": "^8.0.0",
-    "microsoft-cognitiveservices-speech-sdk": "1.34.0",
+    "microsoft-cognitiveservices-speech-sdk": "1.38.0",
    "openai": "^4.25.0",
-    "undici": "^6.4.0"
+    "undici": "^7.5.0"
  },
  "devDependencies": {
-    "config": "^3.3.10",
-    "eslint": "^8.56.0",
-    "eslint-plugin-promise": "^6.1.1",
+    "config": "^3.3.11",
+    "eslint": "^9.3.0",
+    "eslint-plugin-promise": "^6.2.0",
+    "husky": "^9.0.11",
    "nyc": "^15.1.0",
-    "pino": "^8.17.0",
-    "tape": "^5.7.3"
+    "pino": "^9.1.0",
+    "tape": "^5.7.5"
  }
 }
@@ -62,9 +62,9 @@ function deserialize_nuance_tts_v1_UnarySynthesisResponse(buffer_arg) {

 //
 // The Synthesizer service offers these functionalities:
-// - GetVoices: Queries the list of available voices, with filters to reduce the search space.  
-// - Synthesize: Synthesizes audio from input text and parameters, and returns an audio stream. 
-// - UnarySynthesize: Synthesizes audio from input text and parameters, and returns a single audio response. 
+// - GetVoices: Queries the list of available voices, with filters to reduce the search space.
+// - Synthesize: Synthesizes audio from input text and parameters, and returns an audio stream.
+// - UnarySynthesize: Synthesizes audio from input text and parameters, and returns a single audio response.
 var SynthesizerService = exports.SynthesizerService = {
  getVoices: {
    path: '/nuance.tts.v1.Synthesizer/GetVoices',
@@ -1 +1 @@
-// GENERATED CODE -- NO SERVICES IN PROTO
+// GENERATED CODE -- NO SERVICES IN PROTO
@@ -57,7 +57,7 @@ function deserialize_nvidia_riva_tts_SynthesizeSpeechResponse(buffer_arg) {
 var RivaSpeechSynthesisService = exports.RivaSpeechSynthesisService = {
  // Used to request text-to-speech from the service. Submit a request containing the
 // desired text and configuration, and receive audio bytes in the requested format.
-synthesize: {
+  synthesize: {
    path: '/nvidia.riva.tts.RivaSpeechSynthesis/Synthesize',
    requestStream: false,
    responseStream: false,
@@ -69,9 +69,9 @@ synthesize: {
    responseDeserialize: deserialize_nvidia_riva_tts_SynthesizeSpeechResponse,
  },
  // Used to request text-to-speech returned via stream as it becomes available.
-// Submit a SynthesizeSpeechRequest with desired text and configuration,
-// and receive stream of bytes in the requested format.
-synthesizeOnline: {
+  // Submit a SynthesizeSpeechRequest with desired text and configuration,
+  // and receive stream of bytes in the requested format.
+  synthesizeOnline: {
    path: '/nvidia.riva.tts.RivaSpeechSynthesis/SynthesizeOnline',
    requestStream: false,
    responseStream: true,
@@ -83,7 +83,7 @@ synthesizeOnline: {
    responseDeserialize: deserialize_nvidia_riva_tts_SynthesizeSpeechResponse,
  },
  // Enables clients to request the configuration of the current Synthesize service, or a specific model within the service.
-getRivaSynthesisConfig: {
+  getRivaSynthesisConfig: {
    path: '/nvidia.riva.tts.RivaSpeechSynthesis/GetRivaSynthesisConfig',
    requestStream: false,
    responseStream: false,
@@ -19,12 +19,20 @@ test('AWS - create and cache auth token', async(t) => {
      return;
  }
  try {
-    let obj = await getAwsAuthToken(process.env.AWS_ACCESS_KEY_ID, process.env.AWS_SECRET_ACCESS_KEY, process.env.AWS_REGION);
+    let obj = await getAwsAuthToken({
+      accessKeyId: process.env.AWS_ACCESS_KEY_ID, 
+      secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+      region: process.env.AWS_REGION
+    });
    //console.log({obj}, 'received auth token from AWS');
    t.ok(obj.securityToken && !obj.servedFromCache, 'successfullY generated auth token from AWS');

    await sleep(250);
-    obj = await getAwsAuthToken(process.env.AWS_ACCESS_KEY_ID, process.env.AWS_SECRET_ACCESS_KEY, process.env.AWS_REGION);
+    obj = await getAwsAuthToken({
+      accessKeyId: process.env.AWS_ACCESS_KEY_ID, 
+      secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+      region: process.env.AWS_REGION
+    });
    //console.log({obj}, 'received auth token from AWS - second request');
    t.ok(obj.securityToken && obj.servedFromCache, 'successfully received access token from cache');
 
@@ -12,6 +12,32 @@ const stats = {
  histogram: () => {}
 };

+test('Verbio - get Access key and voices', async(t) => {
+  const fn = require('..');
+  const {client, getTtsVoices, getVerbioAccessToken} = fn(opts, logger);
+  if (!process.env.VERBIO_CLIENT_ID || !process.env.VERBIO_CLIENT_SECRET) {
+    t.pass('skipping Verbio test since no Verbio Keys provided');
+    t.end();
+    client.quit();
+    return;
+  }
+
+  try {
+    const credentials = {
+      client_id: process.env.VERBIO_CLIENT_ID,
+      client_secret: process.env.VERBIO_CLIENT_SECRET
+    };
+    let obj = await getVerbioAccessToken(credentials);
+    t.ok(obj.access_token , 'successfully received access token not from cache');
+    const voices = await getTtsVoices({vendor: 'verbio', credentials});
+    t.ok(voices && voices.length != 0, 'successfully received verbio voices');
+  } catch (err) {
+    console.error(err);
+    t.end(err);
+  }
+  client.quit();
+});
+
 test('IBM - create access key', async(t) => {
  const fn = require('..');
  const {client, getIbmAccessToken} = fn(opts, logger);
@@ -5,7 +5,7 @@ const fs = require('fs');
 const {makeSynthKey} = require('../lib/utils');
 const logger = require('pino')();
 const bent = require('bent');
-const getJSON = bent('json')
+const getJSON = bent('json');

 process.on('unhandledRejection', (reason, p) => {
  console.log('Unhandled Rejection at: Promise', p, 'reason:', reason);
@@ -91,14 +91,17 @@ test('Google speech Custom voice synth tests', async(t) => {
  const fn = require('..');
  const {synthAudio, client} = fn(opts, logger);

-  if (!process.env.GCP_CUSTOM_VOICE_FILE && !process.env.GCP_CUSTOM_VOICE_JSON_KEY || !process.env.GCP_CUSTOM_VOICE_MODEL) {
-    t.pass('skipping google speech synth tests since neither GCP_CUSTOM_VOICE_FILE nor GCP_CUSTOM_VOICE_JSON_KEY provided, GCP_CUSTOM_VOICE_MODEL is not provided');
+  if (!process.env.GCP_CUSTOM_VOICE_FILE &&
+    !process.env.GCP_CUSTOM_VOICE_JSON_KEY ||
+    !process.env.GCP_CUSTOM_VOICE_MODEL) {
+    t.pass(`skipping google speech synth tests since neither 
+GCP_CUSTOM_VOICE_FILE nor GCP_CUSTOM_VOICE_JSON_KEY provided, GCP_CUSTOM_VOICE_MODEL is not provided`);
    return t.end();
  }
  try {
    const str = process.env.GCP_CUSTOM_VOICE_JSON_KEY || fs.readFileSync(process.env.GCP_CUSTOM_VOICE_FILE);
    const creds = JSON.parse(str);
-    let opts = await synthAudio(stats, {
+    const opts = await synthAudio(stats, {
      vendor: 'google',
      credentials: {
        credentials: {
@@ -109,7 +112,7 @@ test('Google speech Custom voice synth tests', async(t) => {
      language: 'en-AU',
      text: 'This is a test.  This is only a test',
      voice: {
-        reportedUsage:"REALTIME",
+        reportedUsage: 'REALTIME',
        model: process.env.GCP_CUSTOM_VOICE_MODEL
      }
    });
@@ -121,6 +124,48 @@ test('Google speech Custom voice synth tests', async(t) => {
  client.quit();
 });

+test('Google speech voice cloning synth tests', async(t) => {
+  const fn = require('..');
+  const {synthAudio, client} = fn(opts, logger);
+
+  if (!process.env.GCP_CUSTOM_VOICE_FILE &&
+    !process.env.GCP_CUSTOM_VOICE_JSON_KEY ||
+    !process.env.GCP_VOICE_CLONING_FILE &&
+    !process.env.GCP_VOICE_CLONING_JSON_KEY) {
+    t.pass(`skipping google speech synth tests since neither 
+GCP_CUSTOM_VOICE_FILE nor GCP_CUSTOM_VOICE_JSON_KEY provided,
+GCP_VOICE_CLONING_FILE nor GCP_VOICE_CLONING_JSON_KEY is not provided`);
+    return t.end();
+  }
+  try {
+    const googleKey = process.env.GCP_CUSTOM_VOICE_JSON_KEY ||
+      fs.readFileSync(process.env.GCP_CUSTOM_VOICE_FILE);
+    const voice_cloning_key = process.env.GCP_VOICE_CLONING_JSON_KEY ||
+      fs.readFileSync(process.env.GCP_VOICE_CLONING_FILE).toString();
+    const creds = JSON.parse(googleKey);
+    const opts = await synthAudio(stats, {
+      vendor: 'google',
+      credentials: {
+        credentials: {
+          client_email: creds.client_email,
+          private_key: creds.private_key,
+          project_id: creds.project_id
+        },
+      },
+      language: 'en-US',
+      text: 'This is a test. This is only a test. This is a test. This is only a test. This is a test. This is only a test',
+      voice: {
+        voice_cloning_key
+      }
+    });
+    t.ok(!opts.servedFromCache, `successfully synthesized google voice cloning audio to ${opts.filePath}`);
+  } catch (err) {
+    console.error(err);
+    t.end(err);
+  }
+  client.quit();
+});
+
 test('AWS speech synth tests', async(t) => {
  const fn = require('..');
  const {synthAudio, client} = fn(opts, logger);
@@ -162,6 +207,33 @@ test('AWS speech synth tests', async(t) => {
  client.quit();
 });

+test('AWS speech synth tests by RoleArn', async(t) => {
+  const fn = require('..');
+  const {synthAudio, client} = fn(opts, logger);
+
+  if (!process.env.AWS_ROLE_ARN || !process.env.AWS_REGION) {
+    t.pass('skipping AWS speech synth tests by RoleArn since AWS_ROLE_ARN or AWS_REGION not provided');
+    return t.end();
+  }
+  try {
+    let opts = await synthAudio(stats, {
+      vendor: 'aws',
+      credentials: {
+        roleArn: process.env.AWS_ROLE_ARN,
+        region: process.env.AWS_REGION,
+      },
+      language: 'en-US',
+      voice: 'Joey',
+      text: 'This is a test.  This is only a test',
+    });
+    t.ok(!opts.servedFromCache, `successfully synthesized aws by roleArn audio to ${opts.filePath}`);
+  } catch (err) {
+    console.error(err);
+    t.end(err);
+  }
+  client.quit();
+});
+
 test('Azure speech synth tests', async(t) => {
  const fn = require('..');
  const {synthAudio, client} = fn(opts, logger);
@@ -482,6 +554,7 @@ test('Custom Vendor speech synth tests', async(t) => {
      text: 'This is a test.  This is only a test',
    });
    t.ok(!opts.servedFromCache, `successfully synthesized custom vendor audio to ${opts.filePath}`);
+    t.ok(opts.filePath.endsWith('wav'), 'audio is cached as wav file');
    let obj = await getJSON(`http://127.0.0.1:3100/lastRequest/somethingnew`);
    t.ok(obj.headers.Authorization == 'Bearer some_jwt_token', 'Custom Vendor Authentication Header is correct');
    t.ok(obj.body.language == 'en-US', 'Custom Vendor Language is correct');
@@ -489,6 +562,21 @@ test('Custom Vendor speech synth tests', async(t) => {
    t.ok(obj.body.type == 'text', 'Custom Vendor type is correct');
    t.ok(obj.body.text == 'This is a test.  This is only a test', 'Custom Vendor text is correct');

+    // Checking if cache is stored with wav format
+    opts = await synthAudio(stats, {
+      vendor: 'custom:somethingnew',
+      credentials: {
+        use_for_tts: 1,
+        custom_tts_url: "http://127.0.0.1:3100/somethingnew",
+        auth_token: 'some_jwt_token'
+      },
+      language: 'en-US',
+      voice: 'English-US.Female-1',
+      text: 'This is a test.  This is only a test',
+    });
+    t.ok(opts.servedFromCache, `successfully get custom vendor cached audio to ${opts.filePath}`);
+    t.ok(opts.filePath.endsWith('wav'), 'audio is cached as wav file');
+
    opts = await synthAudio(stats, {
      vendor: 'custom:somethingnew2',
      credentials: {
@@ -547,7 +635,158 @@ test('Elevenlabs speech synth tests', async(t) => {
    t.end(err);
  }
  client.quit();
-})
+});
+
+const testPlayHT = async(t, voice_engine) => {
+  const fn = require('..');
+  const {synthAudio, client} = fn(opts, logger);
+
+  if (!process.env.PLAYHT_API_KEY || !process.env.PLAYHT_USER_ID) {
+    t.pass('skipping PlayHT speech synth tests since PLAYHT_API_KEY or PLAYHT_USER_ID is/are not provided');
+    return t.end();
+  }
+  const text = 'Hi there and welcome to jambones! ' + Date.now();
+  try {
+    const opts = await synthAudio(stats, {
+      vendor: 'playht',
+      credentials: {
+        api_key: process.env.PLAYHT_API_KEY,
+        user_id: process.env.PLAYHT_USER_ID,
+        voice_engine,
+        options: JSON.stringify({
+          quality: 'medium',
+          speed: 1,
+          seed: 1,
+          temperature: 1,
+          emotion: 'female_happy',
+          voice_guidance: 3,
+          style_guidance: 20,
+          text_guidance: 1,
+        })
+      },
+      language: 'english',
+      voice: 's3://voice-cloning-zero-shot/d9ff78ba-d016-47f6-b0ef-dd630f59414e/female-cs/manifest.json',
+      text,
+      renderForCaching: true
+    });
+    t.ok(!opts.servedFromCache, `successfully playht eleven audio to ${opts.filePath}`);
+
+  } catch (err) {
+    console.error(JSON.stringify(err));
+    t.end(err);
+  }
+  client.quit();
+};
+
+test('PlayHT speech synth tests', async(t) => {
+  await testPlayHT(t, 'PlayHT2.0-turbo');
+});
+
+test('PlayHT3.0 speech synth tests', async(t) => {
+  await testPlayHT(t, 'Play3.0');
+});
+
+test('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 mist', async(t) => {
+  const fn = require('..');
+  const {synthAudio, client} = fn(opts, logger);
+
+  if (!process.env.RIMELABS_API_KEY) {
+    t.pass('skipping rimelabs speech synth tests since RIMELABS_API_KEY is not provided');
+    return t.end();
+  }
+  const text = 'Hi there and welcome to jambones!';
+  try {
+    const opts = await synthAudio(stats, {
+      vendor: 'rimelabs',
+      credentials: {
+        api_key: process.env.RIMELABS_API_KEY,
+        model_id: 'mist',
+        options: JSON.stringify({
+          speedAlpha: 1.0,
+          reduceLatency: false
+        })
+      },
+      language: 'eng',
+      voice: 'amber',
+      text,
+      renderForCaching: true
+    });
+    t.ok(!opts.servedFromCache, `successfully synthesized rimelabs audio to ${opts.filePath}`);
+
+  } catch (err) {
+    console.error(JSON.stringify(err));
+    t.end(err);
+  }
+  client.quit();
+});
+
+test('rimelabs speech synth tests mistv2', async(t) => {
+  const fn = require('..');
+  const {synthAudio, client} = fn(opts, logger);
+
+  if (!process.env.RIMELABS_API_KEY) {
+    t.pass('skipping rimelabs speech synth tests since RIMELABS_API_KEY is not provided');
+    return t.end();
+  }
+  const text = 'Hi there and welcome to jambones!';
+  try {
+    const opts = await synthAudio(stats, {
+      vendor: 'rimelabs',
+      credentials: {
+        api_key: process.env.RIMELABS_API_KEY,
+        model_id: 'mistv2',
+        options: JSON.stringify({
+          speedAlpha: 1.0,
+          reduceLatency: false
+        })
+      },
+      language: 'spa',
+      voice: 'pablo',
+      text,
+      renderForCaching: true
+    });
+    t.ok(!opts.servedFromCache, `successfully synthesized rimelabs mistv2 audio to ${opts.filePath}`);
+
+  } catch (err) {
+    console.error(JSON.stringify(err));
+    t.end(err);
+  }
+  client.quit();
+});

 test('whisper speech synth tests', async(t) => {
  const fn = require('..');
@@ -568,6 +807,40 @@ test('whisper speech synth tests', async(t) => {
      language: 'en-US',
      voice: 'alloy',
      text,
+      renderForCaching: true
+    });
+    t.ok(!opts.servedFromCache, `successfully synthesized whisper audio to ${opts.filePath}`);
+
+  } catch (err) {
+    console.error(JSON.stringify(err));
+    t.end(err);
+  }
+  client.quit();
+});
+
+test('Verbio speech synth tests', async(t) => {
+  const fn = require('..');
+  const {synthAudio, client} = fn(opts, logger);
+
+  if (!process.env.VERBIO_CLIENT_ID || !process.env.VERBIO_CLIENT_SECRET) {
+    t.pass('skipping Verbio Synthesize test since no Verbio Keys provided');
+    t.end();
+    client.quit();
+    return;
+  }
+
+  const text = 'Hi there and welcome to jambones!';
+  try {
+    let opts = await synthAudio(stats, {
+      vendor: 'verbio',
+      credentials: {
+        client_id: process.env.VERBIO_CLIENT_ID,
+        client_secret: process.env.VERBIO_CLIENT_SECRET
+      },
+      language: 'en-US',
+      voice: 'tommy_en-us',
+      text,
+      renderForCaching: true
    });
    t.ok(!opts.servedFromCache, `successfully synthesized whisper audio to ${opts.filePath}`);

@@ -614,11 +887,11 @@ test('TTS Cache tests', async(t) => {
    // save some random tts keys to cache
    const minRecords = 8;
    for (const i in Array(minRecords).fill(0)) {
-      await client.set(makeSynthKey({vendor: i, language: i, voice: i, engine: i, text: i}), i);
+      await client.set(makeSynthKey({vendor: i, language: i, voice: i, engine: i, model: i, text: i}), i);
    }
    const count = await getTtsSize();
    t.ok(count >= minRecords, 'getTtsSize worked.');
-    
+
    const {purgedCount} = await purgeTtsCache();
    t.ok(purgedCount >= minRecords, `successfully purged at least ${minRecords} tts records from cache`);

@@ -649,13 +922,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:*')).length;
-    t.ok(cached >= 1, `successfully kept all non-specified tts records in cache`);
+    const cached = await client.keys('tts:*');
+    t.ok(cached.length >= 1, 'successfully kept all non-specified tts records in cache');

+    process.env.VG_TRIM_TTS_SILENCE = 'true';
+    await client.set(makeSynthKey({ vendor: 'azure' }), 'value');
  } catch (err) {
    console.error(JSON.stringify(err));
    t.end(err);
Author	SHA1	Message	Date
Dave Horton	04080cc5ec	0.2.4	2025-03-19 21:48:31 -04:00
Dave Horton	3e5ab4af27	Merge pull request #107 from jambonz/update-deps update undici	2025-03-19 21:48:02 -04:00
Dave Horton	f06dddd2f7	update undici	2025-03-19 21:46:21 -04:00
Dave Horton	7b4a71f55d	0.2.3	2025-02-07 07:20:12 -05:00
Dave Horton	d552b65618	Merge pull request #106 from jambonz/feat/rimelabs_voices rimelabs support multiple model and languages	2025-02-07 07:19:47 -05:00
Quan HL	f701b50244	rimelabs support multiple model and languages	2025-02-07 14:20:52 +07:00
Dave Horton	199e502fbe	0.2.2	2025-02-03 08:14:15 -05:00
Dave Horton	6769779189	Merge pull request #105 from jambonz/fix/gh_1059 tts key should include model	2025-02-03 08:13:54 -05:00
Quan HL	4b43c3986c	wip	2025-02-02 19:03:09 +07:00
Quan HL	e1292772e6	tts key should include model	2025-02-02 18:54:16 +07:00
Dave Horton	37fb045431	0.2.1	2024-12-18 22:16:43 -05:00
Dave Horton	c328df67a2	major semver bump	2024-12-18 22:15:28 -05:00
Dave Horton	877cba7065	Merge pull request #103 from jambonz/feat/refactor_synth remove audio extension from audio key	2024-12-18 22:13:52 -05:00
Quan HL	35a178b468	remove audio extension from audio key	2024-12-18 16:58:54 +07:00
Quan HL	7327190471	remove audio extension from audio key	2024-12-18 16:46:24 +07:00
Dave Horton	e5b5e3d0c6	0.1.24	2024-12-16 07:27:18 -05:00
Dave Horton	3760be088b	update deps	2024-12-16 07:26:49 -05:00
Dave Horton	5cb52eb8ec	Merge pull request #101 from jambonz/feat/tts_cartesia support cartesia tts	2024-12-16 07:25:29 -05:00
Quan HL	8a390a8edf	support cartesia tts	2024-12-16 15:58:18 +07:00
Dave Horton	d96ab5cdf3	Merge pull request #99 from jambonz/feat/support_aws_instance_profile support aws instance profile to get key	2024-11-29 21:58:22 -05:00
Quan HL	3bf74671c6	support aws instance profile to get key	2024-11-30 08:40:26 +07:00
Dave Horton	a47ef6d7c4	0.1.22	2024-11-04 07:38:23 -05:00
Dave Horton	84089fa528	Merge pull request #98 from jambonz/fix/freshdesk_411 Fix custom tts vendor cached file can not be played	2024-11-04 07:37:49 -05:00
Quan HL	72be44eea2	adding testcase	2024-11-04 15:53:11 +07:00
Quan HL	05d6c4b32d	fixed custom vendor cache audio stores file extension	2024-11-04 15:43:44 +07:00
Dave Horton	0c7e15d0a2	0.1.21	2024-10-31 09:48:18 -04:00
Dave Horton	63efecf9d9	Merge pull request #97 from jambonz/feat/google_voice_cloning support google voice cloning	2024-10-31 09:47:12 -04:00
Quan HL	153ac3f1a4	fix review comment	2024-10-31 20:30:35 +07:00
Quan HL	115faa9f89	support google voice cloning	2024-10-31 20:23:11 +07:00
Dave Horton	f183852961	0.1.20	2024-10-18 12:23:26 -04:00
Dave Horton	34c3e01729	Merge pull request #95 from jambonz/fix/rimelabs fix rimelabs typo issue on getFileExtension function	2024-10-18 12:22:52 -04:00
Quan HL	9b2b16199e	fix rimelabs typo issue on getFileExtension function	2024-10-18 22:44:17 +07:00
Dave Horton	9112c5f0ea	0.1.19	2024-10-16 07:23:40 -04:00
Dave Horton	50783dfd0a	Merge pull request #94 from jambonz/fix/playht30_lang add language to playht3.0	2024-10-16 07:23:04 -04:00
Quan HL	ca0ef76fe1	add language to playht3.0	2024-10-16 08:14:38 +07:00
Dave Horton	7c91c537e4	0.1.18	2024-10-11 07:33:37 -04:00
Dave Horton	9747526664	Merge pull request #93 from jambonz/fix/playht_3.0 fixed playht3.0 cannot be played if credential is cached	2024-10-11 07:32:57 -04:00
Quan HL	31a0c7b02c	fixed playht3.0 cannot be played if credential is cached	2024-10-11 12:05:38 +07:00
Dave Horton	c18fbacd1b	update playht3	2024-10-09 13:29:01 -04:00
Dave Horton	b0fee6bbf1	Merge pull request #92 from jambonz/feat/playht30 support playht3.0	2024-10-09 13:26:53 -04:00
Quan HL	f6cead6e92	add top_p and repetition_penalty to playht3.0	2024-10-03 19:24:23 +07:00
Quan HL	05fc96edc0	wip	2024-09-27 18:24:03 +07:00
Quan HL	6794a0b3be	support playht3.0	2024-09-27 12:25:47 +07:00
Quan HL	1a04fd736c	support playht3.0	2024-09-27 12:08:41 +07:00
Dave Horton	1846203807	0.1.16	2024-09-16 15:53:14 -04:00
Dave Horton	75be8658c1	Merge pull request #91 from jambonz/fix/diff_playht_voice_quality fix playht has stream and cached audio differrent quality	2024-09-16 15:52:42 -04:00
Quan HL	91a5eebbaf	fixed review comment	2024-09-16 18:46:10 +07:00
Quan HL	c96f1e86ee	fix review comment	2024-09-16 18:15:45 +07:00
Quan HL	8016c0886a	fix playht has stream and cached audio differrent quality	2024-09-16 09:01:45 +07:00
Dave Horton	8f216e64d8	0.1.15	2024-08-12 09:30:09 -04:00
Dave Horton	e1f4486e01	bump version	2024-08-12 09:27:12 -04:00
Dave Horton	b0d6272974	Merge pull request #84 from jambonz/feat/precache_audio_with_tts_stream support precache audio with tts stream enabled	2024-08-12 09:26:00 -04:00
Quan HL	ef23b0807a	add comment	2024-08-12 20:16:24 +07:00
Quan HL	ab7e25243d	improve on check precache	2024-08-12 20:10:43 +07:00
Quan HL	bf0ea14423	install docker	2024-08-12 18:40:47 +07:00
Quan HL	305dabd84b	wip	2024-08-12 18:35:48 +07:00
Quan HL	b6a3fa5081	support precache audio with tts stream enabled	2024-08-12 18:29:01 +07:00
Dave Horton	73feadc4c4	0.1.13	2024-08-06 11:01:09 -04:00
Dave Horton	aad0f4d62c	Merge pull request #82 from jambonz/feat/deepgram_tts_endpoint deepgram tts support endpoint for on-premise	2024-08-06 11:00:38 -04:00
Hoan Luu Huu	602b0cc60e	Merge branch 'main' into feat/deepgram_tts_endpoint	2024-07-31 14:03:41 +07:00
Dave Horton	8511e762c8	version update	2024-07-30 07:29:25 -04:00
Dave Horton	b75d3068c9	Merge pull request #81 from jambonz/feat/gh_fs_832 allow configure STS session expiry	2024-07-30 07:14:06 -04:00
Quan HL	461178e726	wip	2024-07-29 20:56:55 +07:00
Quan HL	e0e4d47340	wip	2024-07-29 20:53:55 +07:00
Quan HL	a595faa378	deepgram tts support endpoint for on-premise	2024-07-29 19:45:13 +07:00
Quan HL	7fd1e1a3c3	allow configure STS session expiry	2024-07-29 18:18:37 +07:00
Dave Horton	7f6a3d349c	0.1.11	2024-06-14 07:37:19 -04:00
Dave Horton	50429ff535	bump version	2024-06-14 07:36:53 -04:00
Dave Horton	3bf0ef8ea3	Merge pull request #80 from jambonz/fix/aws_arnrole fix aws arnrole	2024-06-14 07:34:22 -04:00
Quan HL	e9a5e83e36	wip	2024-06-14 15:04:19 +07:00
Quan HL	86a64ac091	wip	2024-06-14 15:00:56 +07:00
Quan HL	97e06b3ab3	wip	2024-06-14 10:23:22 +07:00
Quan HL	09e833d910	wip	2024-06-14 10:19:55 +07:00
Quan HL	8c4e12e54f	wip	2024-06-14 10:18:41 +07:00
Quan HL	2642bd71a4	wip	2024-06-14 10:16:57 +07:00
Quan HL	c4feac916f	fix aws arnrole	2024-06-14 10:15:23 +07:00
Dave Horton	2ec56f564e	0.1.9	2024-06-06 12:31:13 -04:00
Dave Horton	9399ddcb58	Merge pull request #78 from jambonz/env/disable-ms-streaming Env/disable ms streaming	2024-06-06 12:30:48 -04:00
Dave Horton	aebf4eda30	lint	2024-06-06 12:25:53 -04:00
Dave Horton	6b0bdfdf2f	add env JAMBONES_DISABLE_AZURE_TTS_STREAMING to disable Microsoft TTS streaming	2024-06-06 12:25:08 -04:00
Dave Horton	d214c3184f	0.1.8	2024-06-05 06:48:09 -04:00
Dave Horton	c335a508a3	bump version	2024-06-05 06:47:01 -04:00
Dave Horton	d7797d5691	Merge pull request #77 from jambonz/feat/improve_elevenlabs support elevenlabs previous_text, next_text	2024-06-05 06:43:48 -04:00
Quan HL	b81f3313cb	support elevenlabs previous_text, next_text	2024-06-05 15:53:26 +07:00
Dave Horton	49fe64744c	0.1.6	2024-05-30 07:13:00 -04:00
Dave Horton	106238cca5	bump version	2024-05-30 07:12:37 -04:00
Dave Horton	01735ccf2f	Merge pull request #76 from jambonz/fix/verbio_cache fixed verbio tts extension	2024-05-30 07:10:50 -04:00
Quan HL	ce81cb8d24	fixed verbio tts extension	2024-05-30 16:13:05 +07:00
Dave Horton	c9d7a9046f	0.1.4	2024-05-29 07:24:07 -04:00
Dave Horton	a9ba383667	Merge pull request #75 from Catharsis68/feat/pre-commit-hook Update eslint, add pre commit hook	2024-05-29 07:23:41 -04:00
Markus Frindt	06b97bcb0f	Update eslint, add pre commit hook	2024-05-29 10:22:10 +02:00
Dave Horton	90152b36ef	0.1.3	2024-05-28 13:02:15 -04:00
Dave Horton	92484b7441	Merge pull request #74 from jambonz/fix/lint lint	2024-05-28 13:01:35 -04:00
Dave Horton	398904785b	lint	2024-05-28 12:58:37 -04:00
Dave Horton	531fa21f88	0.1.2	2024-05-28 12:55:00 -04:00
Dave Horton	904495d819	Merge pull request #73 from Catharsis68/feat/tts-cache-improvement Improve handling of TTS cache by adding the file extension to the cac…	2024-05-28 12:54:31 -04:00
Markus Frindt	f13fc84853	merge latest main into feature branch	2024-05-28 18:44:41 +02:00
Dave Horton	e099bbb58f	0.1.1	2024-05-28 09:43:24 -04:00
Dave Horton	e60a2d2ba3	Merge pull request #72 from jambonz/feat/verbio_speech add verbio tts/stt	2024-05-28 09:42:28 -04:00
Markus Frindt	39d54050cc	simplify return for streaming responses	2024-05-28 15:23:53 +02:00
Markus Frindt	7618d334db	add namespace for custom provider	2024-05-27 11:04:35 +02:00
Markus Frindt	71f20178d3	add test case	2024-05-24 14:09:07 +02:00
Markus Frindt	cb6ab2479f	Improve handling of TTS cache by adding the file extension to the cache key	2024-05-24 14:03:31 +02:00
Quan HL	2212be341b	add synthesize verbio	2024-05-20 18:11:01 +07:00
Quan HL	5d2d921f31	add verbio tts/stt	2024-05-20 17:24:06 +07:00
Dave Horton	acb2d0c7ce	Merge pull request #71 from jambonz/feat/azure_private_endpoint support tts stream private endpoint	2024-05-14 06:56:51 -04:00
Quan HL	90d6048f52	fix private azure link with credential	2024-05-14 14:01:25 +07:00
Quan HL	e5985620c0	support tts stream private endpoint	2024-05-05 14:28:11 +07:00
Dave Horton	eb57f4d290	bump version	2024-05-02 07:46:47 -04:00
Dave Horton	f0a1ab139c	Merge pull request #69 from jambonz/feat/aws_polly_rolearn support AWS Polly RoleArn credential	2024-05-02 07:44:38 -04:00
Quan HL	79289a7249	wip	2024-05-02 15:51:45 +07:00
Quan HL	5998eebdca	wip	2024-05-02 15:48:20 +07:00
Quan HL	e6a7017b55	wip	2024-05-02 14:20:24 +07:00
Quan HL	c8571af129	wip	2024-04-30 15:47:14 +07:00
Quan HL	6144a9c164	wip	2024-04-30 15:45:26 +07:00
Quan HL	68a7f2b0d4	wip	2024-04-30 15:45:10 +07:00
Quan HL	0d1cd37097	wip	2024-04-30 11:20:21 +07:00
Quan HL	3de8e5ff57	accept aws polly without credential	2024-04-22 20:02:59 +07:00
Quan HL	b4aad7991b	update get aws voices	2024-04-22 16:19:04 +07:00
Quan HL	8a5c5c1966	support mod_google_tts	2024-04-19 16:06:53 +07:00
Quan HL	08a56d1a40	support AWS Polly RoleArn credential	2024-04-19 15:30:22 +07:00
Dave Horton	ba61f20334	0.0.51	2024-04-12 07:19:56 -04:00
Dave Horton	10316d786e	Merge pull request #67 from jambonz/feat/mod_rimelabs_tts support mod_rimelabs_tts	2024-04-12 07:10:32 -04:00
Quan HL	38cdc106cc	wip	2024-04-12 17:55:55 +07:00
Quan HL	410b99ef24	support mod_rimelabs_tts	2024-04-12 15:57:02 +07:00
Dave Horton	51db63f992	Merge pull request #66 from jambonz/gh-actions add PlayHT to CI test	2024-04-08 09:49:48 -04:00
Dave Horton	c86dceadde	add PlayHT to CI test	2024-04-08 09:47:04 -04:00
Dave Horton	f56f98f40f	0.0.50	2024-04-08 09:44:17 -04:00
Dave Horton	12a36593aa	Merge pull request #65 from jambonz/feat/mod_playht_tts support mod_playht_tts	2024-04-08 09:43:00 -04:00
Quan HL	8382491477	wip	2024-04-08 20:31:56 +07:00
Quan HL	545d559e27	wip	2024-04-08 19:14:58 +07:00
Quan HL	cc8963802f	wip	2024-04-08 17:33:21 +07:00
Quan HL	282d87f922	wip	2024-04-08 17:24:15 +07:00
Quan HL	6a288c1db0	support mod_playht_tts	2024-04-08 17:20:32 +07:00
Dave Horton	8650328e64	0.0.49	2024-04-07 12:15:02 -04:00
Dave Horton	85fa6da5b5	update to azure speech sdk 1.36.0	2024-04-07 12:14:55 -04:00