@goodandready/dsh-tts 0.4.35 → 0.4.36

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 0.4.36 (2026-10-23)
+
+### Fixed
+- **Edge TTS Transient Error Retry** (#212, GitHub #4):
+  - Retries transient `edge_tts.exceptions.NoAudioReceived` errors and empty audio payloads (`< 32` bytes) up to 3 times before failing or tripping circuit breaker.
+  - Automatically cleans up corrupt/empty audio artifacts between retry attempts.
+  - Honors `req.signal` (AbortSignal) cancellation during backoff delays without hanging.
+  - Fails fast on `ENOENT` / missing binary without wasting retry cycles.
+
 ## 0.4.35 (2026-10-20)
 
 ### Fixed

package/lib/local.js

@@ -3,23 +3,47 @@ import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
 import os from 'node:os'
 import path from 'node:path'
 
-function spawnCollect(bin, args, { stdinText, timeoutMs } = {}) {
+function spawnCollect(bin, args, { stdinText, timeoutMs, signal, spawnImpl = spawn } = {}) {
   return new Promise((resolve, reject) => {
-    const proc = spawn(bin, args, { stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true })
+    if (signal?.aborted) {
+      reject(signal.reason instanceof Error ? signal.reason : new Error('aborted'))
+      return
+    }
+    const proc = spawnImpl === spawn
+      ? spawn(bin, args, { stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true })
+      : spawnImpl(bin, args, { stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true })
     const out = []
     const err = []
     const timer = setTimeout(() => {
-      try { proc.kill('SIGKILL') } catch { /* gone */ }
+      try { proc.kill('SIGKILL') } catch (_err) { /* process already exited */ }
       reject(new Error(`${bin} timed out`))
     }, timeoutMs || 60000)
-    proc.stdout.on('data', (c) => out.push(c))
-    proc.stderr.on('data', (c) => err.push(c))
-    proc.on('error', (e) => {
+
+    let onAbort = null
+    if (signal) {
+      onAbort = () => {
+        clearTimeout(timer)
+        try { proc.kill('SIGKILL') } catch (_err) { /* process already exited */ }
+        reject(signal.reason instanceof Error ? signal.reason : new Error('aborted'))
+      }
+      signal.addEventListener('abort', onAbort, { once: true })
+    }
+
+    const cleanup = () => {
       clearTimeout(timer)
+      if (signal && onAbort) {
+        try { signal.removeEventListener('abort', onAbort) } catch (_err) { /* abort listener already removed */ }
+      }
+    }
+
+    proc.stdout?.on('data', (c) => out.push(c))
+    proc.stderr?.on('data', (c) => err.push(c))
+    proc.on('error', (e) => {
+      cleanup()
       reject(new Error(`${bin} unavailable: ${e.message}`))
     })
     proc.on('close', (code) => {
-      clearTimeout(timer)
+      cleanup()
       const stdout = Buffer.concat(out)
       const stderr = Buffer.concat(err).toString('utf8').slice(0, 240)
       if (code !== 0) {
@@ -29,10 +53,10 @@ function spawnCollect(bin, args, { stdinText, timeoutMs } = {}) {
       resolve(stdout)
     })
     if (stdinText != null) {
-      proc.stdin.on('error', () => {})
-      proc.stdin.end(Buffer.from(String(stdinText), 'utf8'))
+      proc.stdin?.on('error', () => {})
+      proc.stdin?.end(Buffer.from(String(stdinText), 'utf8'))
     } else {
-      proc.stdin.end()
+      proc.stdin?.end?.()
     }
   })
 }
@@ -64,24 +88,82 @@ export async function piperSpeak(text, { bin, model, timeoutMs }) {
   }
 }
 
-export async function edgeSpeak(text, { bin, voice, timeoutMs }) {
+export async function edgeSpeak(text, options = {}) {
+  const {
+    bin,
+    voice,
+    timeoutMs,
+    retries = 3,
+    retryDelayMs = 350,
+    signal,
+    spawnImpl = spawn,
+  } = options
+
+  const maxAttempts = Math.max(1, Number(retries) || 1)
   const dir = await mkdtemp(path.join(os.tmpdir(), 'dsh-tts-edge-'))
   const outFile = path.join(dir, 'out.mp3')
+  let lastError = null
+
   try {
-    await spawnCollect(bin || 'edge-tts', [
-      '--voice', voice || 'ru-RU-SvetlanaNeural',
-      '--text', text,
-      '--write-media', outFile,
-    ], { timeoutMs })
-    const bytes = await readFile(outFile)
-    if (!bytes || bytes.length < 32) throw new Error('edge-tts produced empty audio')
-    return { audio: bytes, mime: 'audio/mpeg' }
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+      if (signal?.aborted) {
+        throw signal.reason instanceof Error ? signal.reason : new Error('aborted')
+      }
+      try {
+        await rm(outFile, { force: true })
+      } catch (_err) { /* ignore cleanup error */ }
+
+      try {
+        await spawnCollect(bin || 'edge-tts', [
+          '--voice', voice || 'ru-RU-SvetlanaNeural',
+          '--text', text,
+          '--write-media', outFile,
+        ], { timeoutMs, signal, spawnImpl })
+
+        let bytes = null
+        try {
+          bytes = await readFile(outFile)
+        } catch (_readErr) {
+          throw new Error('edge-tts produced no output file')
+        }
+
+        if (!bytes || bytes.length < 32) {
+          throw new Error('edge-tts produced empty audio')
+        }
+
+        return { audio: bytes, mime: 'audio/mpeg' }
+      } catch (err) {
+        lastError = err
+        if (signal?.aborted) throw err
+
+        const errMsg = String((err && err.message) || err)
+        if (/ENOENT|not found/i.test(errMsg)) {
+          throw err
+        }
+
+        if (attempt < maxAttempts) {
+          const delay = typeof retryDelayMs === 'number' ? retryDelayMs * attempt : 350
+          if (delay > 0) {
+            await new Promise((resolve, reject) => {
+              const timer = setTimeout(resolve, delay)
+              if (signal) {
+                const onAbort = () => {
+                  clearTimeout(timer)
+                  reject(signal.reason instanceof Error ? signal.reason : new Error('aborted'))
+                }
+                signal.addEventListener('abort', onAbort, { once: true })
+              }
+            })
+          }
+        }
+      }
+    }
+    throw lastError || new Error('edge-tts failed after retries')
   } finally {
     await rm(dir, { recursive: true, force: true })
   }
 }
 
-
 /**
  * MiniMax via their official CLI utility.
  *
@@ -105,4 +187,4 @@ export async function minimaxSpeak(text, { bin, voice, model, timeoutMs }) {
   } finally {
     await rm(dir, { recursive: true, force: true })
   }
-}
+}

package/lib/providers/local.js

@@ -12,10 +12,21 @@ export function makeLocalProviders(deps, req) {
   const { cfg, modelManager } = deps
   const { text, lang, models, voices } = req
 
-  async function edge() {
+  async function edge(extraOptions = {}) {
     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 })
+      const retries = typeof extraOptions.retries === 'number'
+        ? extraOptions.retries
+        : (typeof cfg.edgeRetries === 'number' ? cfg.edgeRetries : 3)
+      const out = await edgeSpeak(text, {
+        bin: cfg.edgeBin,
+        voice,
+        timeoutMs: cfg.timeoutMs,
+        retries,
+        retryDelayMs: extraOptions.retryDelayMs,
+        signal: req.signal,
+        spawnImpl: extraOptions.spawnImpl || req.edgeSpawnImpl,
+      })
       return { ok: true, provider: 'edge', audio: out.audio, mime: out.mime }
     } catch (e) {
       return { ok: false, provider: 'edge', reason: String(e && e.message || e) }
@@ -96,4 +107,4 @@ export function makeLocalProviders(deps, req) {
   }
 
   return { kokoro, f5, edge, piper, espeak, minimax }
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-tts",
-  "version": "0.4.35",
+  "version": "0.4.36",
   "description": "Text-to-speech for DeepSeek Harness: speak agent replies in the Web UI with a provider fallback chain (OpenAI, ElevenLabs, Google, Azure, Groq, Deepgram, OpenRouter, Edge, Piper, eSpeak).",
   "license": "MIT",
   "type": "module",