@jambonz/speech-utils 1.0.3 → 1.0.6

package/.github/workflows/publish.yml

@@ -12,8 +12,8 @@ jobs:
     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/*
           registry-url: 'https://registry.npmjs.org'

package/index.js

@@ -14,8 +14,6 @@ module.exports = (opts, 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, createHash, retrieveHash, logger),
-    getVerbioAccessToken: require('./lib/get-verbio-token').bind(null, client, logger),
-    getNuanceAccessToken: require('./lib/get-nuance-access-token').bind(null, client, logger),
 
     getAwsAuthToken: require('./lib/get-aws-sts-token').bind(null, logger, createHash, retrieveHash),
     getTtsVoices: require('./lib/get-tts-voices').bind(null, client, createHash, retrieveHash, logger),

package/lib/get-tts-voices.js

@@ -1,74 +1,8 @@
 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 {noopLogger} = require('./utils');
 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 getNuanceVoices = async(client, logger, credentials) => {
-  const {client_id: clientId, secret: secret, nuance_tts_uri} = credentials;
-
-  return new Promise(async(resolve, reject) => {
-    /* get a nuance access token */
-    let token, nuanceClient;
-    try {
-      if (nuance_tts_uri) {
-        nuanceClient = await createKryptonClient(nuance_tts_uri);
-      }
-      else {
-        const access_token = await getNuanceAccessToken(client, logger, clientId, secret, 'tts');
-        token = access_token.access_token;
-        nuanceClient = await createNuanceClient(token);
-      }
-    } catch (err) {
-      logger.error({err}, 'getTtsVoices: error retrieving access token');
-      return reject(err);
-    }
-    /* retrieve all voices */
-    const v = new Voice();
-    const request = new GetVoicesRequest();
-    request.setVoice(v);
-
-    nuanceClient.getVoices(request, (err, response) => {
-      if (err) {
-        logger.error({err, clientId, secret, token}, 'getTtsVoices: error retrieving voices');
-        return reject(err);
-      }
-
-      /* return all the voices that are not restricted and eliminate duplicates */
-      const voices = response.getVoicesList()
-        .map((v) => {
-          return {
-            language: v.getLanguage(),
-            name: v.getName(),
-            model: v.getModel(),
-            gender: v.getGender() === 1 ? 'male' : 'female',
-            restricted: v.getRestricted()
-          };
-        });
-      const v = voices
-        .filter((v) => v.restricted === false)
-        .map((v) => {
-          delete v.restricted;
-          return v;
-        })
-        .sort((a, b) => {
-          if (a.language < b.language) return -1;
-          if (a.language > b.language) return 1;
-          if (a.name < b.name) return -1;
-          return 1;
-        });
-      const arr = [...new Set(v.map((v) => JSON.stringify(v)))]
-        .map((v) => JSON.parse(v));
-      resolve(arr);
-    });
-  });
-};
 
 const getGoogleVoices = async(_client, logger, credentials) => {
   const client = new ttsGoogle.TextToSpeechClient({credentials});
@@ -109,26 +43,6 @@ const getAwsVoices = async(_client, createHash, retrieveHash, logger, credential
   }
 };
 
-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
@@ -148,19 +62,15 @@ const getVerbioVoices = async(client, logger, credentials) => {
 async function getTtsVoices(client, createHash, retrieveHash, logger, {vendor, credentials}) {
   logger = logger || noopLogger;
 
-  assert.ok(['nuance', 'google', 'aws', 'polly', 'verbio'].includes(vendor),
+  assert.ok(['google', 'aws', 'polly'].includes(vendor),
     `getTtsVoices not supported for vendor ${vendor}`);
 
   switch (vendor) {
-    case 'nuance':
-      return getNuanceVoices(client, logger, credentials);
     case 'google':
       return getGoogleVoices(client, logger, credentials);
     case 'aws':
     case 'polly':
       return getAwsVoices(client, createHash, retrieveHash, logger, credentials);
-    case 'verbio':
-      return getVerbioVoices(client, logger, credentials);
     default:
       break;
   }

package/lib/synth-audio.js

@@ -16,26 +16,10 @@ const {
 } = sdk;
 const {
   makeSynthKey,
-  createNuanceClient,
-  createKryptonClient,
   createRivaClient,
   noopLogger,
-  makeFilePath,
-  makePlayhtKey
+  makeFilePath
 } = require('./utils');
-const getNuanceAccessToken = require('./get-nuance-access-token');
-const getVerbioAccessToken = require('./get-verbio-token');
-const {
-  SynthesisRequest,
-  Voice,
-  AudioFormat,
-  AudioParameters,
-  PCM,
-  Input,
-  Text,
-  SSML,
-  EventParameters
-} = require('../stubs/nuance/synthesizer_pb');
 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');
@@ -95,10 +79,10 @@ async function synthAudio(client, createHash, retrieveHash, logger, stats, { acc
   let rtt;
   logger = logger || noopLogger;
 
-  assert.ok(['google', 'aws', 'polly', 'microsoft', 'wellsaid', 'nuance', 'nvidia', 'elevenlabs',
-    'whisper', 'deepgram', 'playht', 'rimelabs', 'verbio', 'cartesia', 'inworld', 'resemble'].includes(vendor) ||
+  assert.ok(['google', 'aws', 'polly', 'microsoft', 'wellsaid', 'nvidia', 'elevenlabs',
+    'whisper', 'deepgram', 'rimelabs', 'cartesia', 'inworld', 'resemble'].includes(vendor) ||
   vendor.startsWith('custom'),
-  `synthAudio supported vendors are google, aws, microsoft, nuance, nvidia and wellsaid ..etc, not ${vendor}`);
+  `synthAudio supported vendors are google, aws, microsoft, nvidia and wellsaid ..etc, not ${vendor}`);
   if ('google' === vendor) {
     assert.ok(language, 'synthAudio requires language when google is used');
   }
@@ -109,13 +93,6 @@ async function synthAudio(client, createHash, retrieveHash, logger, stats, { acc
     assert.ok(language || deploymentId, 'synthAudio requires language when microsoft is used');
     assert.ok(voice || deploymentId, 'synthAudio requires voice when microsoft is used');
   }
-  else if ('nuance' === vendor) {
-    assert.ok(voice, 'synthAudio requires voice when nuance is used');
-    if (!credentials.nuance_tts_uri) {
-      assert.ok(credentials.client_id, 'synthAudio requires client_id in credentials when nuance is used');
-      assert.ok(credentials.secret, 'synthAudio requires client_id in credentials when nuance is used');
-    }
-  }
   else if ('nvidia' === vendor) {
     assert.ok(voice, 'synthAudio requires voice when nvidia is used');
     assert.ok(language, 'synthAudio requires language when nvidia is used');
@@ -129,11 +106,6 @@ async function synthAudio(client, createHash, retrieveHash, logger, stats, { acc
     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 ('inworld' === vendor) {
     assert.ok(voice, 'synthAudio requires voice when inworld is used');
     assert.ok(credentials.api_key, 'synthAudio requires api_key when inworld is used');
@@ -148,10 +120,6 @@ async function synthAudio(client, createHash, retrieveHash, logger, stats, { acc
     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');
@@ -216,10 +184,6 @@ async function synthAudio(client, createHash, retrieveHash, logger, stats, { acc
         audioData = await synthMicrosoft(logger, {credentials, stats, language, voice, key, text, deploymentId,
           renderForCaching, disableTtsStreaming, disableTtsCache});
         break;
-      case 'nuance':
-        model = model || 'enhanced';
-        audioData = await synthNuance(client, logger, {credentials, stats, voice, model, key, text});
-        break;
       case 'nvidia':
         audioData = await synthNvidia(client, logger, {credentials, stats, language, voice, model, key, text,
           renderForCaching, disableTtsStreaming, disableTtsCache});
@@ -232,11 +196,6 @@ async function synthAudio(client, createHash, retrieveHash, logger, stats, { acc
           credentials, options, stats, language, voice, key, text, renderForCaching, disableTtsStreaming,
           disableTtsCache});
         break;
-      case 'playht':
-        audioData = await synthPlayHT(client, logger, {
-          credentials, options, stats, language, voice, key, text, renderForCaching, disableTtsStreaming,
-          disableTtsCache});
-        break;
       case 'cartesia':
         audioData = await synthCartesia(logger, {
           credentials, options, stats, language, voice, key, text, renderForCaching, disableTtsStreaming,
@@ -257,11 +216,6 @@ async function synthAudio(client, createHash, retrieveHash, logger, stats, { acc
           credentials, stats, voice, key, text, instructions, renderForCaching, disableTtsStreaming,
           disableTtsCache});
         break;
-      case 'verbio':
-        audioData = await synthVerbio(client, logger, {
-          credentials, stats, voice, key, text, renderForCaching, disableTtsStreaming, disableTtsCache});
-        if (audioData?.filePath) return audioData;
-        break;
       case 'deepgram':
         audioData = await synthDeepgram(logger, {credentials, stats, model, key, text,
           renderForCaching, disableTtsStreaming, disableTtsCache});
@@ -316,6 +270,7 @@ const synthPolly = async(createHash, retrieveHash, logger,
     params += `,playback_id=${key}`;
     params += `,write_cache_file=${disableTtsCache ? 0 : 1}`;
     params += ',vendor=aws';
+    params += `,voice=${voice}`;
     if (accessKeyId && secretAccessKey) {
       if (accessKeyId) params += `,accessKeyId=${accessKeyId}`;
       if (secretAccessKey) params += `,secretAccessKey=${secretAccessKey}`;
@@ -724,70 +679,6 @@ const synthWellSaid = async(logger, {credentials, stats, language, voice, gender
   }
 };
 
-const synthNuance = async(client, logger, {credentials, stats, voice, model, text}) => {
-  let nuanceClient;
-  const {client_id, secret, nuance_tts_uri} = credentials;
-  if (nuance_tts_uri) {
-    nuanceClient = await createKryptonClient(nuance_tts_uri);
-  }
-  else {
-    /* get a nuance access token */
-    const {access_token} = await getNuanceAccessToken(client, logger, client_id, secret, 'tts');
-    nuanceClient = await createNuanceClient(access_token);
-  }
-
-  const v = new Voice();
-  const p = new AudioParameters();
-  const f = new AudioFormat();
-  const pcm = new PCM();
-  const params  = new EventParameters();
-  const request = new SynthesisRequest();
-  const input = new Input();
-
-  if (text.startsWith('<speak')) {
-    const ssml = new SSML();
-    ssml.setText(text);
-    input.setSsml(ssml);
-  }
-  else {
-    const t = new Text();
-    t.setText(text);
-    input.setText(t);
-  }
-  const sampleRate = 8000;
-  pcm.setSampleRateHz(sampleRate);
-  f.setPcm(pcm);
-  p.setAudioFormat(f);
-  v.setName(voice);
-  v.setModel(model);
-  request.setVoice(v);
-  request.setAudioParams(p);
-  request.setInput(input);
-  request.setEventParams(params);
-  request.setUserId('jambonz');
-
-  return new Promise((resolve, reject) => {
-    nuanceClient.unarySynthesize(request, (err, response) => {
-      if (err) {
-        console.error(err);
-        return reject(err);
-      }
-      const status = response.getStatus();
-      const code = status.getCode();
-      if (code !== 200) {
-        const message = status.getMessage();
-        const details = status.getDetails();
-        return reject({code, message, details});
-      }
-      resolve({
-        audioContent: Buffer.from(response.getAudio()),
-        extension: 'r8',
-        sampleRate
-      });
-    });
-  });
-};
-
 const synthNvidia = async(client, logger, {
   credentials, stats, language,  voice, model, key, text, renderForCaching, disableTtsStreaming, disableTtsCache
 }) => {
@@ -953,101 +844,6 @@ const synthElevenlabs = async(logger, {
   }
 };
 
-const synthPlayHT = async(client, logger, {
-  credentials, options, stats, voice, language, key, text, renderForCaching, disableTtsStreaming, disableTtsCache
-}) => {
-  const {api_key, user_id, voice_engine, playht_tts_uri, options: credOpts} = credentials;
-  const opts = !!options && Object.keys(options).length !== 0 ? options : JSON.parse(credOpts || '{}');
-
-  let synthesizeUrl = playht_tts_uri ? `${playht_tts_uri}/api/v2/tts/stream` : 'https://api.play.ht/api/v2/tts/stream';
-  // If model is play3.0, the synthesizeUrl is got from authentication endpoint
-  if (voice_engine === 'Play3.0') {
-    try {
-      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 += `,playback_id=${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=${disableTtsCache ? 0 : 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 synthInworld = async(logger, {
   credentials, options, stats, voice, key, text, renderForCaching, disableTtsStreaming, disableTtsCache
 }) => {
@@ -1173,54 +969,6 @@ const synthRimelabs = async(logger, {
     throw err;
   }
 };
-const synthVerbio = async(client, logger, {
-  credentials, stats, voice, key, text, renderForCaching, disableTtsStreaming, disableTtsCache
-}) => {
-  //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 += `,playback_id=${key}`;
-    params += ',vendor=verbio';
-    params += `,voice=${voice}`;
-    params += `,write_cache_file=${disableTtsCache ? 0 : 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, key, text, instructions,
   renderForCaching, disableTtsStreaming, disableTtsCache}) => {
   const {api_key, model_id, baseURL, timeout, speed} = credentials;
@@ -1343,6 +1091,18 @@ const synthCartesia = async(logger, {
   try {
     const client = new CartesiaClient({ apiKey: api_key });
     const sampleRate = 48000;
+
+    // omit a control unless explicitly provided (0 is a valid value, so test for nullish only)
+    const has = (v) => v !== null && v !== undefined;
+    /* Voice controls are model-family specific:
+       - sonic-2 takes `experimentalControls` (emotion is an array, no volume).
+       - sonic-3 family (sonic-3, sonic-3.5, pinned sonic-3.x snapshots) takes
+         `generationConfig` (emotion is a string, volume supported). Match the same
+         "starts with sonic-3" predicate the freeswitch streaming module uses
+         (mod_cartesia_tts_streaming: strncmp(model_id, "sonic-3", ...)), so cached
+         and streamed synthesis behave identically.
+       Older models (sonic, sonic-english, sonic-multilingual, sonic-2024-*) take neither. */
+    const isSonic3 = model_id?.startsWith('sonic-3');
     const mp3Stream = await client.tts.bytes({
       modelId: model_id,
       transcript: text,
@@ -1358,16 +1118,16 @@ const synthCartesia = async(logger, {
         ),
         ...(model_id === 'sonic-2' && (opts.speed || opts.emotion) && {
           experimentalControls: {
-            ...(opts.speed !== null && opts.speed !== undefined && {speed: opts.speed}),
+            ...(has(opts.speed) && {speed: opts.speed}),
             ...(opts.emotion && {emotion: [opts.emotion]}),
           }
         }),
       },
-      ...(model_id === 'sonic-3' && (opts.speed || opts.emotion || opts.volume) && {
+      ...(isSonic3 && (has(opts.speed) || has(opts.emotion) || has(opts.volume)) && {
         generationConfig: {
-          ...(opts.volume !== null && opts.volume !== undefined && {volume: opts.volume}),
-          ...(opts.speed !== null && opts.speed !== undefined && {speed: opts.speed}),
-          ...(opts.emotion !== null && opts.emotion !== undefined && {emotion: opts.emotion}),
+          ...(has(opts.volume) && {volume: opts.volume}),
+          ...(has(opts.speed) && {speed: opts.speed}),
+          ...(has(opts.emotion) && {emotion: opts.emotion}),
         }
       }),
       language: language,
@@ -1391,6 +1151,32 @@ const synthCartesia = async(logger, {
       sampleRate
     };
   } catch (err) {
+    /* Cartesia's tts.bytes() uses a streaming response, so on an HTTP error the SDK
+       throws a CartesiaError whose `body` is an unconsumed stream-wrapper object
+       (async-iterable, yielding Uint8Array chunks) rather than the parsed error
+       JSON. Read it so callers get a meaningful message instead of a serialized
+       stream object. */
+    if (err && err.body && typeof err.body !== 'string' && typeof err.body[Symbol.asyncIterator] === 'function') {
+      try {
+        const chunks = [];
+        for await (const chunk of err.body) {
+          chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        }
+        const text = Buffer.concat(chunks).toString('utf8');
+        if (text) {
+          let parsed;
+          try {
+            parsed = JSON.parse(text);
+          } catch {
+            parsed = null;
+          }
+          err.message = (parsed && (parsed.error || parsed.message)) || text;
+          err.body = parsed || text;
+        }
+      } catch (readErr) {
+        logger.info({readErr}, 'synth Cartesia: failed to read error response body');
+      }
+    }
     logger.info({err}, 'synth Cartesia returned error');
     stats.increment('tts.count', ['vendor:cartesia', 'accepted:no']);
     throw err;