@goodandready/dsh-tts 0.4.1 → 0.4.5

package/lib/index.js

@@ -11,6 +11,7 @@ import { createModelManager } from './engines/manager.js'
 import { registerHttpRoutes } from './routes.js'
 import { broadcastStream, clearStreamSubscribers } from './stream-hub.js'
 import { writeJson } from './http-util.js'
+import { createProviderBreaker } from './breaker.js'
 import {
   CLOUD_PROVIDERS,
   assertCredentialRef,
@@ -126,11 +127,11 @@ export const Config = z.object({
   approvalText: z
     .string()
     .description('What to say when an approval is asked for. The tool name is appended.')
-    .default('Требуется подтверждение'),
+    .default('Approval required'),
   questionText: z
     .string()
     .description('What to say when the agent asks a question. Empty disables it.')
-    .default('Агент задал вопрос'),
+    .default('Agent asked a question'),
   chime: z
     .string()
     .description('Short sound before an announcement: ding, beep or none.')
@@ -177,6 +178,8 @@ export const Config = z.object({
 let utteranceSeq = 0
 
 export function apply(ctx, config) {
+  const providerBreaker = createProviderBreaker()
+
   let getConfig = () => config
   const live = () => Config(structuredClone(getConfig() ?? {})) ?? config
 
@@ -338,7 +341,7 @@ export function apply(ctx, config) {
         try {
           const retold = await summarizeReply(text.slice(0, 8000), cfg, signal)
           if (retold) cut = speechPhrases(cfg.language).summaryIntro + ' ' + retold
-        } catch (llmDown) { /* тихий откат к обрезке */ }
+        } catch (llmDown) { /* quiet fallback to truncation */ }
       }
       text = cut
     }
@@ -380,10 +383,28 @@ export function apply(ctx, config) {
 
     const synthPromise = (async () => {
       try {
-        const providers = makeProviders(
+        const baseProviders = makeProviders(
           { resolveKey, fetchImpl: fetch, cfg, modelManager },
           { text, lang: cfg.autoDetect ? detectLang(text) : cfg.language, signal, models, voices, role },
         )
+        const providers = {}
+        for (const key of Object.keys(baseProviders)) {
+          const fn = baseProviders[key]
+          providers[key] = async () => {
+            if (providerBreaker.isOpen(key)) {
+              return { ok: false, provider: key, reason: 'circuit open (cooldown)' }
+            }
+            try {
+              const out = await fn()
+              if (out && out.ok) providerBreaker.recordSuccess(key)
+              else providerBreaker.recordFailure(key, out && out.reason)
+              return out
+            } catch (err) {
+              providerBreaker.recordFailure(key, err)
+              throw err
+            }
+          }
+        }
         const out = await runChain(order, providers)
         stats.total++
         const ps = stats.providers[out.provider] || (stats.providers[out.provider] = { n: 0, e: 0, ms: 0 })
@@ -549,6 +570,8 @@ export function apply(ctx, config) {
 
 
   registerHttpRoutes(ctx, {
+    breakerSnapshot: () => providerBreaker.snapshot(),
+
     live,
     modelManager,
     stats,

package/lib/local.js

@@ -83,15 +83,13 @@ export async function edgeSpeak(text, { bin, voice, timeoutMs }) {
 
 
 /**
- * MiniMax через их консольную утилиту.
+ * MiniMax via their official CLI utility.
  *
- * Прямого HTTP тут намеренно нет: у MiniMax свой протокол с отдельным
- * идентификатором группы и своей формой ответа, а официальная утилита уже
- * умеет и авторизацию, и выбор голоса. Она же хранит вход — плагину не нужно
- * знать ни ключа, ни устройства их API.
+ * There is intentionally no direct HTTP here: MiniMax uses its own protocol with a
+ * separate group id and response shape, while the official CLI already handles auth
+ * and voice selection. It also stores the login — the plugin never sees the key.
  *
- * Утилита ставится отдельно и один раз логинится; без неё провайдер честно
- * отказывает, и цепочка идёт дальше.
+ * The utility is installed separately and logs in once; without it the provider fails honestly and the chain moves on.
  */
 export async function minimaxSpeak(text, { bin, voice, model, timeoutMs }) {
   const dir = await mkdtemp(path.join(os.tmpdir(), 'dsh-tts-minimax-'))

package/lib/providers/cloud.js

@@ -0,0 +1,278 @@
+import { DEFAULT_MODELS, DEFAULT_VOICES, OPENAI_COMPATIBLE } from "./constants.js"
+
+function pick(map, models, key) {
+  const chosen = models && typeof models[key] === "string" ? models[key].trim() : ""
+  return chosen || map[key]
+}
+
+function asBuffer(body) {
+  if (Buffer.isBuffer(body)) return body
+  return Buffer.from(body)
+}
+
+function escapeXml(s) {
+  return String(s)
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+}
+
+export function makeCloudProviders(deps, req, withCloudTimeout) {
+  const { resolveKey, fetchImpl, cfg } = deps
+  const { text, lang, models, voices, role } = req
+
+  async function openai() {
+    const key = await resolveKey(cfg.openaiKeyEnv)
+    if (!key) return { ok: false, provider: 'openai', reason: `no ${cfg.openaiKeyEnv}` }
+    const { signal, cleanup } = withCloudTimeout()
+    try {
+      const res = await fetchImpl((cfg.openaiBaseUrl || 'https://api.openai.com/v1') + '/audio/speech', {
+      method: 'POST',
+      headers: { authorization: `Bearer ${key}`, 'content-type': 'application/json' },
+      body: JSON.stringify({
+        model: pick(DEFAULT_MODELS, models, 'openai'),
+        input: text,
+        voice: pick(DEFAULT_VOICES, voices, 'openai'),
+        response_format: 'mp3',
+      }),
+      signal,
+    })
+    if (!res.ok) throw new Error(`OpenAI HTTP ${res.status}`)
+    const audio = asBuffer(Buffer.from(await res.arrayBuffer()))
+    return { ok: audio.length > 0, provider: 'openai', audio, mime: 'audio/mpeg', reason: audio.length ? '' : 'empty audio' }
+    } finally {
+      cleanup()
+    }
+  }
+  function openaiCompatible(key) {
+    const spec = OPENAI_COMPATIBLE[key]
+    return async function speak() {
+      const keyEnv = (cfg[key + 'KeyEnv'] || spec.keyEnv)
+      const token = await resolveKey(keyEnv)
+      if (!token) return { ok: false, provider: key, reason: `no ${keyEnv}` }
+      const base = cfg[key + 'BaseUrl'] || spec.baseUrl
+      if (!base) return { ok: false, provider: key, reason: 'no base url configured' }
+      const { signal, cleanup } = withCloudTimeout()
+      try {
+        const res = await fetchImpl(base + '/audio/speech', {
+        method: 'POST',
+        headers: { authorization: `Bearer ${token}`, 'content-type': 'application/json' },
+        body: JSON.stringify({
+          model: pick(DEFAULT_MODELS, models, key),
+          input: text,
+          voice: pick(DEFAULT_VOICES, voices, key),
+          response_format: 'mp3',
+        }),
+        signal,
+      })
+      if (!res.ok) throw new Error(`${key} HTTP ${res.status}`)
+      const audio = asBuffer(Buffer.from(await res.arrayBuffer()))
+      return { ok: audio.length > 0, provider: key, audio, mime: 'audio/mpeg', reason: audio.length ? '' : 'empty audio' }
+      } finally {
+        cleanup()
+      }
+    }
+  }
+  async function mimo() {
+    const key = await resolveKey(cfg.mimoKeyEnv)
+    if (!key) return { ok: false, provider: 'mimo', reason: `no ${cfg.mimoKeyEnv}` }
+    const base = (cfg.mimoBaseUrl || 'https://api.xiaomimimo.com/v1').replace(/\/+$/, '')
+    const format = cfg.mimoFormat === 'wav' ? 'wav' : 'mp3'
+    const { signal, cleanup } = withCloudTimeout()
+    try {
+      const res = await fetchImpl(base + '/chat/completions', {
+      method: 'POST',
+      headers: { authorization: `Bearer ${key}`, 'content-type': 'application/json', accept: 'application/json' },
+      body: JSON.stringify({
+        model: pick(DEFAULT_MODELS, models, 'mimo'),
+        messages: [{ role: 'assistant', content: text }],
+        audio: { format, voice: pick(DEFAULT_VOICES, voices, 'mimo') },
+        stream: false,
+      }),
+      signal,
+    })
+    const data = await res.json().catch(() => ({}))
+    if (!res.ok) {
+      const detail = data && data.error && data.error.message
+      throw new Error(`MiMo HTTP ${res.status}${detail ? ': ' + detail : ''}`)
+    }
+    const encoded = data && data.choices && data.choices[0]
+      && data.choices[0].message && data.choices[0].message.audio
+      && data.choices[0].message.audio.data
+    if (typeof encoded !== 'string' || !encoded) {
+      return { ok: false, provider: 'mimo', reason: 'response missing choices[0].message.audio.data' }
+    }
+    const audio = Buffer.from(encoded, 'base64')
+    return {
+      ok: audio.length > 0,
+      provider: 'mimo',
+      audio,
+      mime: format === 'wav' ? 'audio/wav' : 'audio/mpeg',
+      reason: audio.length ? '' : 'empty audio',
+    }
+    } finally {
+      cleanup()
+    }
+  }
+  async function elevenlabs() {
+    const key = await resolveKey(cfg.elevenlabsKeyEnv)
+    if (!key) return { ok: false, provider: 'elevenlabs', reason: `no ${cfg.elevenlabsKeyEnv}` }
+    const voice = pick(DEFAULT_VOICES, voices, 'elevenlabs')
+    const { signal, cleanup } = withCloudTimeout()
+    try {
+      const res = await fetchImpl(`https://api.elevenlabs.io/v1/text-to-speech/${encodeURIComponent(voice)}`, {
+      method: 'POST',
+      headers: { 'xi-api-key': key, 'content-type': 'application/json', accept: 'audio/mpeg' },
+      body: JSON.stringify({
+        text,
+        model_id: pick(DEFAULT_MODELS, models, 'elevenlabs'),
+      }),
+      signal,
+    })
+    if (!res.ok) throw new Error(`ElevenLabs HTTP ${res.status}`)
+    const audio = asBuffer(Buffer.from(await res.arrayBuffer()))
+    return { ok: audio.length > 0, provider: 'elevenlabs', audio, mime: 'audio/mpeg', reason: audio.length ? '' : 'empty audio' }
+    } finally {
+      cleanup()
+    }
+  }
+  async function google() {
+    const key = await resolveKey(cfg.googleKeyEnv)
+    if (!key) return { ok: false, provider: 'google', reason: `no ${cfg.googleKeyEnv}` }
+    const model = pick(DEFAULT_MODELS, models, 'google')
+    const voiceName = pick(DEFAULT_VOICES, voices, 'google')
+    const { signal, cleanup } = withCloudTimeout()
+    try {
+      const res = await fetchImpl(
+      `https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(model)}:generateContent?key=${encodeURIComponent(key)}`,
+      {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({
+          contents: [{ parts: [{ text }] }],
+          generationConfig: {
+            responseModalities: ['AUDIO'],
+            speechConfig: { voiceConfig: { prebuiltVoiceConfig: { voiceName } } },
+          },
+        }),
+        signal,
+      },
+    )
+    if (!res.ok) throw new Error(`Google HTTP ${res.status}`)
+    const data = await res.json()
+    const b64 = data?.candidates?.[0]?.content?.parts?.find((p) => p.inlineData)?.inlineData?.data
+    if (!b64) return { ok: false, provider: 'google', reason: 'no inline audio' }
+    const audio = Buffer.from(b64, 'base64')
+    return { ok: audio.length > 0, provider: 'google', audio, mime: 'audio/wav', reason: audio.length ? '' : 'empty audio' }
+    } finally {
+      cleanup()
+    }
+  }
+  async function azure() {
+    const key = await resolveKey(cfg.azureKeyEnv)
+    if (!key) return { ok: false, provider: 'azure', reason: `no ${cfg.azureKeyEnv}` }
+    const region = (cfg.azureRegion || '').trim()
+    if (!region) return { ok: false, provider: 'azure', reason: 'azureRegion is empty' }
+    const voice = pick(DEFAULT_VOICES, voices, 'azure')
+    const roleCfg = req.role && cfg.roles && cfg.roles[req.role]
+    const style = roleCfg && roleCfg.ssmlStyle
+    const safeStyle = style ? String(style).replace(/["<>&]/g, '') : ''
+    const inner = safeStyle
+      ? `<mstts:express-as style="${safeStyle}">${escapeXml(text)}</mstts:express-as>`
+      : escapeXml(text)
+    const ssml = `<speak version="1.0" xml:lang="${lang || 'en-US'}">`
+      + `<voice xml:lang="${lang || 'en-US'}" name="${voice}">`
+      + `${inner}</voice></speak>`
+    const { signal, cleanup } = withCloudTimeout()
+    try {
+      const res = await fetchImpl(`https://${region}.tts.speech.microsoft.com/cognitiveservices/v1`, {
+      method: 'POST',
+      headers: {
+        'Ocp-Apim-Subscription-Key': key,
+        'Content-Type': 'application/ssml+xml',
+        'X-Microsoft-OutputFormat': 'audio-16khz-128kbitrate-mono-mp3',
+      },
+      body: ssml,
+      signal,
+    })
+    if (!res.ok) throw new Error(`Azure HTTP ${res.status}`)
+    const audio = asBuffer(Buffer.from(await res.arrayBuffer()))
+    return { ok: audio.length > 0, provider: 'azure', audio, mime: 'audio/mpeg', reason: audio.length ? '' : 'empty audio' }
+    } finally {
+      cleanup()
+    }
+  }
+  async function groq() {
+    const key = await resolveKey(cfg.groqKeyEnv)
+    if (!key) return { ok: false, provider: 'groq', reason: `no ${cfg.groqKeyEnv}` }
+    const { signal, cleanup } = withCloudTimeout()
+    try {
+      const res = await fetchImpl('https://api.groq.com/openai/v1/audio/speech', {
+      method: 'POST',
+      headers: { authorization: `Bearer ${key}`, 'content-type': 'application/json' },
+      body: JSON.stringify({
+        model: pick(DEFAULT_MODELS, models, 'groq'),
+        input: text,
+        voice: pick(DEFAULT_VOICES, voices, 'groq'),
+        response_format: 'mp3',
+      }),
+      signal,
+    })
+    if (!res.ok) throw new Error(`Groq HTTP ${res.status}`)
+    const audio = asBuffer(Buffer.from(await res.arrayBuffer()))
+    return { ok: audio.length > 0, provider: 'groq', audio, mime: 'audio/mpeg', reason: audio.length ? '' : 'empty audio' }
+    } finally {
+      cleanup()
+    }
+  }
+  async function deepgram() {
+    const key = await resolveKey(cfg.deepgramKeyEnv)
+    if (!key) return { ok: false, provider: 'deepgram', reason: `no ${cfg.deepgramKeyEnv}` }
+    const model = pick(DEFAULT_MODELS, models, 'deepgram')
+    const { signal, cleanup } = withCloudTimeout()
+    try {
+      const res = await fetchImpl(`https://api.deepgram.com/v1/speak?model=${encodeURIComponent(model)}`, {
+      method: 'POST',
+      headers: { authorization: `Token ${key}`, 'content-type': 'application/json' },
+      body: JSON.stringify({ text }),
+      signal,
+    })
+    if (!res.ok) throw new Error(`Deepgram HTTP ${res.status}`)
+    const audio = asBuffer(Buffer.from(await res.arrayBuffer()))
+    return { ok: audio.length > 0, provider: 'deepgram', audio, mime: 'audio/mpeg', reason: audio.length ? '' : 'empty audio' }
+    } finally {
+      cleanup()
+    }
+  }
+  async function openrouter() {
+    const key = await resolveKey(cfg.openrouterKeyEnv)
+    if (!key) return { ok: false, provider: 'openrouter', reason: `no ${cfg.openrouterKeyEnv}` }
+    const { signal, cleanup } = withCloudTimeout()
+    try {
+      const res = await fetchImpl('https://openrouter.ai/api/v1/audio/speech', {
+      method: 'POST',
+      headers: { authorization: `Bearer ${key}`, 'content-type': 'application/json' },
+      body: JSON.stringify({
+        model: pick(DEFAULT_MODELS, models, 'openrouter'),
+        input: text,
+        voice: pick(DEFAULT_VOICES, voices, 'openrouter'),
+        response_format: 'mp3',
+      }),
+      signal,
+    })
+    if (!res.ok) throw new Error(`OpenRouter HTTP ${res.status}`)
+    const audio = asBuffer(Buffer.from(await res.arrayBuffer()))
+    return { ok: audio.length > 0, provider: 'openrouter', audio, mime: 'audio/mpeg', reason: audio.length ? '' : 'empty audio' }
+    } finally {
+      cleanup()
+    }
+  }
+
+  const compatible = {}
+  for (const key of Object.keys(OPENAI_COMPATIBLE)) {
+    compatible[key] = openaiCompatible(key)
+  }
+
+  return { openai, elevenlabs, google, azure, groq, deepgram, openrouter, mimo, ...compatible }
+}

package/lib/providers/constants.js

@@ -0,0 +1,61 @@
+export const PROVIDER_KEYS = [
+  'kokoro', 'f5',
+  'openai', 'elevenlabs', 'google', 'azure', 'groq', 'deepgram', 'openrouter',
+  'siliconflow', 'deepinfra', 'fireworks', 'mimo', 'custom',
+  'edge', 'piper', 'espeak', 'minimax',
+]
+
+// OpenAI-compatible providers share /audio/speech; they differ by base URL,
+// model, and key name. Each URL was probed without a key and returned 401.
+export const OPENAI_COMPATIBLE = {
+  siliconflow: { baseUrl: 'https://api.siliconflow.cn/v1', keyEnv: 'SILICONFLOW_API_KEY' },
+  deepinfra: { baseUrl: 'https://api.deepinfra.com/v1/openai', keyEnv: 'DEEPINFRA_API_KEY' },
+  fireworks: { baseUrl: 'https://api.fireworks.ai/inference/v1', keyEnv: 'FIREWORKS_API_KEY' },
+  // Custom endpoint: base URL and key name come from settings.
+  custom: { baseUrl: '', keyEnv: 'CUSTOM_TTS_API_KEY' },
+}
+
+export const DEFAULT_MODELS = {
+  kokoro: 'hexgrad/Kokoro-82M',
+  f5: 'F5-TTS',
+  mimo: 'mimo-v2.5-tts',
+  minimax: '',
+  siliconflow: 'FunAudioLLM/CosyVoice2-0.5B',
+  deepinfra: 'hexgrad/Kokoro-82M',
+  fireworks: 'kokoro',
+  openai: 'gpt-4o-mini-tts',
+  elevenlabs: 'eleven_multilingual_v2',
+  google: 'gemini-2.5-flash-preview-tts',
+  azure: 'en-US-JennyNeural',
+  groq: 'playai-tts',
+  deepgram: 'aura-asteria-en',
+  openrouter: 'openai/gpt-4o-mini-tts-2025-12-15',
+  custom: '',
+  edge: 'ru-RU-SvetlanaNeural',
+  piper: '',
+  espeak: 'ru',
+}
+
+export const DEFAULT_VOICES = {
+  kokoro: 'af_bella',
+  f5: 'default',
+  // MiMo voices use Chinese names; 冰糖 is their default.
+  mimo: '冰糖',
+  minimax: '',
+  siliconflow: 'FunAudioLLM/CosyVoice2-0.5B:alex',
+  deepinfra: 'af_bella',
+  fireworks: 'af_bella',
+  openai: 'alloy',
+  elevenlabs: '21m00Tcm4TlvDq8ikWAM',
+  google: 'Kore',
+  azure: 'en-US-JennyNeural',
+  groq: 'Fritz-PlayAI',
+  deepgram: '',
+  openrouter: 'alloy',
+  custom: '',
+  edge: 'ru-RU-SvetlanaNeural',
+  piper: '',
+  espeak: 'ru',
+}
+
+

package/lib/providers/local.js

@@ -0,0 +1,99 @@
+import { edgeSpeak, espeakSpeak, minimaxSpeak, piperSpeak } from "../local.js"
+import { KokoroEngine } from "../engines/kokoro.js"
+import { F5Engine } from "../engines/f5.js"
+import { DEFAULT_MODELS, DEFAULT_VOICES } from "./constants.js"
+
+function pick(map, models, key) {
+  const chosen = models && typeof models[key] === "string" ? models[key].trim() : ""
+  return chosen || map[key]
+}
+
+export function makeLocalProviders(deps, req) {
+  const { cfg, modelManager } = deps
+  const { text, lang, models, voices } = req
+
+  async function edge() {
+    try {
+      const voice = pick(DEFAULT_VOICES, voices, 'edge') || pick(DEFAULT_MODELS, models, 'edge')
+      const out = await edgeSpeak(text, { bin: cfg.edgeBin, voice, timeoutMs: cfg.timeoutMs })
+      return { ok: true, provider: 'edge', audio: out.audio, mime: out.mime }
+    } catch (e) {
+      return { ok: false, provider: 'edge', reason: String(e && e.message || e) }
+    }
+  }
+  async function piper() {
+    try {
+      const model = pick(DEFAULT_MODELS, models, 'piper') || cfg.piperModel
+      const out = await piperSpeak(text, { bin: cfg.piperBin, model, timeoutMs: cfg.timeoutMs })
+      return { ok: true, provider: 'piper', audio: out.audio, mime: out.mime }
+    } catch (e) {
+      return { ok: false, provider: 'piper', reason: String(e && e.message || e) }
+    }
+  }
+  async function espeak() {
+    try {
+      const voice = pick(DEFAULT_VOICES, voices, 'espeak') || lang || 'ru'
+      const out = await espeakSpeak(text, { bin: cfg.espeakBin, voice, timeoutMs: cfg.timeoutMs })
+      return { ok: true, provider: 'espeak', audio: out.audio, mime: out.mime }
+    } catch (e) {
+      return { ok: false, provider: 'espeak', reason: String(e && e.message || e) }
+    }
+  }
+  async function kokoro() {
+    try {
+      const modelPath = deps.modelManager ? deps.modelManager.getModelPath('kokoro') : (cfg.kokoroModelPath || '')
+      const engine = new KokoroEngine({ modelPath })
+      if (!engine.isInstalled()) {
+        return { ok: false, provider: 'kokoro', reason: 'Kokoro ONNX model not installed. Use Edge, Piper, or eSpeak for offline TTS.' }
+      }
+      if (!engine.isRuntimeAvailable()) {
+        return {
+          ok: false,
+          provider: 'kokoro',
+          reason: 'Kokoro ONNX runtime is not bundled. Weights alone do not produce speech. Use Edge, Piper, or eSpeak for offline TTS.',
+        }
+      }
+      const voice = pick(DEFAULT_VOICES, voices, 'kokoro') || 'af_bella'
+      const audio = await engine.synthesizeWav(text, voice)
+      return { ok: audio && audio.length > 0, provider: 'kokoro', audio, mime: 'audio/wav' }
+    } catch (e) {
+      return { ok: false, provider: 'kokoro', reason: String(e && e.message || e) }
+    }
+  }
+  async function f5() {
+    try {
+      const modelPath = deps.modelManager ? deps.modelManager.getModelPath('f5') : ''
+      const engine = new F5Engine({ modelPath })
+      const ok = await engine.ping()
+      if (!ok) {
+        return { ok: false, provider: 'f5', reason: 'F5 daemon unavailable. Use Edge, Piper, or eSpeak for offline TTS.' }
+      }
+      if (!engine.isRuntimeAvailable()) {
+        return {
+          ok: false,
+          provider: 'f5',
+          reason: 'F5-TTS synthesis is not bundled. Use Edge, Piper, or eSpeak for offline TTS.',
+        }
+      }
+      const audio = await engine.synthesize(text)
+      return { ok: !!(audio && audio.length), provider: 'f5', audio, mime: 'audio/wav' }
+    } catch (e) {
+      return { ok: false, provider: 'f5', reason: String(e && e.message || e) }
+    }
+  }
+  async function minimax() {
+    try {
+      const out = await minimaxSpeak(text, {
+        bin: cfg.minimaxBin,
+        voice: pick(DEFAULT_VOICES, voices, 'minimax'),
+        model: pick(DEFAULT_MODELS, models, 'minimax'),
+        timeoutMs: cfg.timeoutMs,
+      })
+      return { ok: true, provider: 'minimax', audio: out.audio, mime: out.mime }
+    } catch (e) {
+      return { ok: false, provider: 'minimax', reason: String(e && e.message || e) }
+    }
+  }
+
+  return { kokoro, f5, edge, piper, espeak, minimax }
+}