@goodandready/dsh-tts 0.4.26 → 0.4.28

package/lib/index.js

@@ -87,7 +87,7 @@ export const Config = z.object({
     to: z.string().default(''),
     whole: z.boolean().default(false),
     lang: z.string().default(''),
-  })).default([])
+  })).volatile().default([])
     .description('Say this instead of that. Applied top-down; /regex/ form allowed in from.'),
   enableItDictionary: z.boolean().volatile().default(true)
     .description('Auto-correct common IT terminology pronunciation (SQL, Nginx, K8s, etc.).'),
@@ -111,43 +111,55 @@ export const Config = z.object({
     .description('Send synthesized voice notes to messengers via @goodandready/dsh-messenger-gateway.'),
   autoDetectSubagent: z.boolean().volatile().default(true)
     .description('Auto-detect subagent roles in multi-agent sessions and route to dedicated voice profiles.'),
-  language: z.string().volatile().default('ru'),
+  language: z.string().volatile().default('en'),
   speakAsItGoes: z
     .boolean()
+    .volatile()
     .description('Speak each reply as it lands instead of waiting for the whole turn to finish. '
       + 'Long answers start sounding almost at once because they are synthesized sentence by sentence.')
     .default(true),
   sentenceChars: z
     .number()
+    .step(1)
+    .min(10)
+    .volatile()
     .description('Upper bound of one spoken piece when speaking as it goes.')
     .default(320),
   rate: z
     .number()
+    .min(0.1)
+    .max(5)
+    .volatile()
     .description('Playback speed, 0.5 to 2. Synthesis is untouched; the browser plays faster or slower.')
     .default(1),
   bargeIn: z
     .boolean()
+    .volatile()
     .description('Fall silent the moment the microphone opens. Listening to a reply and talking over it '
       + 'at the same time does not work, and the reply would be recorded along with the voice.')
     .default(true),
   announceApproval: z
     .boolean()
+    .volatile()
     .description('Say out loud when the agent stops and waits for an approval, and play a short chime. '
       + 'Useful when you walk away from a long run.')
     .default(true),
   approvalText: z
     .string()
+    .volatile()
     .description('What to say when an approval is asked for. The tool name is appended.')
     .default('Approval required'),
   questionText: z
     .string()
+    .volatile()
     .description('What to say when the agent asks a question. Empty disables it.')
     .default('Agent asked a question'),
   chime: z
     .string()
+    .volatile()
     .description('Short sound before an announcement: ding, beep or none.')
     .default('ding'),
-  maxChars: z.number().volatile().default(4000)
+  maxChars: z.number().step(1).min(0).volatile().default(4000)
     .description('Longer replies are truncated before synthesis.'),
   chain: z.array(ChainEntry).volatile()
     .default([
@@ -182,8 +194,8 @@ export const Config = z.object({
   piperModel: z.string().volatile().default('')
     .description('Path to a Piper ONNX model. The piper provider is skipped while this is empty.'),
   espeakBin: z.string().volatile().default('espeak-ng'),
-  timeoutMs: z.number().volatile().default(60000),
-  maxQueue: z.number().volatile().default(8),
+  timeoutMs: z.number().step(1).min(1000).volatile().default(60000),
+  maxQueue: z.number().step(1).min(0).volatile().default(8),
 })
 
 let utteranceSeq = 0
@@ -191,23 +203,48 @@ let utteranceSeq = 0
 export function apply(ctx, config) {
   const providerBreaker = createProviderBreaker()
 
-  let currentConfig = plainConfig(config)
-  let getConfig = () => currentConfig
-  const live = () => plainConfig(Config(structuredClone(getConfig() ?? {})) ?? config)
+  let savedConfig = null
+  const live = () => {
+    const fromBoxes = plainConfig(config)
+    const merged = savedConfig ? { ...fromBoxes, ...savedConfig } : fromBoxes
+    return plainConfig(Config(merged))
+  }
 
   const settingsApi = {
     get: () => live(),
-    replace: async (next) => {
+    replace: async (next, expectedRevision) => {
       const plain = plainConfig(next)
-      currentConfig = plain
-      const svc = ctx?.get?.('settings')
-      if (svc) {
-        const rev = svc.getSnapshot?.()?.revision ?? svc.getSnapshot?.()?.entries?.[NS]?.revision
+      const prevSaved = savedConfig
+      const svc = ctx?.get?.('settings') ?? ctx?.settings ?? ctx?.get?.('settingsForms') ?? ctx?.settingsForms
+      if (!svc) {
+        throw new Error('Settings service is unavailable')
+      }
+      let rev = expectedRevision
+      if (rev === undefined && typeof svc.describe === 'function') {
+        try {
+          const desc = await svc.describe(NS)
+          if (desc && typeof desc.revision === 'number') {
+            rev = desc.revision
+          } else if (desc && Array.isArray(desc.namespaces)) {
+            const entry = desc.namespaces.find((n) => n.ns === NS)
+            if (entry && typeof entry.revision === 'number') rev = entry.revision
+          }
+        } catch {
+          // ignore describe error
+        }
+      }
+      try {
         if (typeof svc.replace === 'function') {
           await svc.replace(NS, plain, rev)
         } else if (typeof svc.update === 'function') {
           await svc.update(NS, plain, rev)
+        } else {
+          throw new Error('Settings service does not support replace or update')
         }
+        savedConfig = plain
+      } catch (err) {
+        savedConfig = prevSaved
+        throw err
       }
       return plain
     },
@@ -321,15 +358,60 @@ export function apply(ctx, config) {
   function cleanOpts(cfg) {
     return { skipCode: cfg.skipCode !== false, phrases: speechPhrases(cfg.language) }
   }
-  function cleanText(raw, cfg) {
+  function cleanText(raw, cfg, maxChars = 0) {
     return applyPronunciation(
-      applyNarrationFilters(stripForSpeech(raw, cfg.maxChars, cleanOpts(cfg)), cfg),
+      applyNarrationFilters(stripForSpeech(raw, maxChars, cleanOpts(cfg)), cfg),
       cfg.pronunciation,
       cfg.language,
       cfg.enableItDictionary !== false,
     )
   }
 
+  // Canonical text preparation (#156, #157): clean once without premature truncation,
+  // then apply longReply strategy (full / summarize / truncate).
+  async function prepareSpeechText(raw, cfg, signal) {
+    let text = cleanText(raw, cfg, 0)
+    if (!text) return ''
+    const maxChars = Number(cfg.maxChars) > 0 ? Number(cfg.maxChars) : 0
+    const overLimit = maxChars > 0 && text.length > maxChars
+    if (overLimit && cfg.longReply !== 'full') {
+      if (cfg.longReply === 'summarize') {
+        try {
+          const retold = await summarizeReply(text.slice(0, 8000), cfg, signal)
+          if (retold) {
+            return speechPhrases(cfg.language).summaryIntro + ' ' + retold
+          }
+        } catch { /* quiet fallback to truncation */ }
+      }
+      return text.slice(0, maxChars)
+    }
+    return text
+  }
+
+  function synthesisFingerprint(text, provider, model, voice, role, ssmlStyle, cfg, lang) {
+    const parts = [text, provider, model || '', voice || '', role || '', ssmlStyle || '', lang || '']
+    if (provider === 'custom') parts.push(cfg.customBaseUrl || '')
+    else if (provider === 'openai') parts.push(cfg.openaiBaseUrl || '')
+    else if (provider === 'mimo') parts.push(cfg.mimoBaseUrl || '', cfg.mimoFormat || '')
+    else if (provider === 'azure') parts.push(cfg.azureRegion || '')
+    else if (provider === 'piper') parts.push(cfg.piperModel || '', cfg.piperBin || '')
+    else if (provider === 'edge') parts.push(cfg.edgeBin || '')
+    else if (provider === 'espeak') parts.push(cfg.espeakBin || '')
+    return cacheKey(parts)
+  }
+
+  function flightFingerprint(text, order, models, voices, role, ssmlStyle, cfg, lang) {
+    const details = order.map((p) => {
+      const extra = p === 'custom' ? (cfg.customBaseUrl || '') :
+                    p === 'openai' ? (cfg.openaiBaseUrl || '') :
+                    p === 'mimo' ? `${cfg.mimoBaseUrl || ''}:${cfg.mimoFormat || ''}` :
+                    p === 'azure' ? (cfg.azureRegion || '') :
+                    p === 'piper' ? `${cfg.piperModel || ''}:${cfg.piperBin || ''}` : ''
+      return `${p}:${models[p] || ''}:${voices[p] || ''}:${extra}`
+    }).join(';')
+    return cacheKey([text, details, role, ssmlStyle, lang])
+  }
+
   // Fast-model summary. Any failure returns an empty string and the caller
   // silently falls back to truncation.
   async function summarizeReply(text, cfg, signal) {
@@ -353,21 +435,10 @@ export function apply(ctx, config) {
     return parts.join('').trim()
   }
 
-  async function synthesize(rawText, cfg, signal, role = 'reply') {
-    let text = cleanText(rawText, cfg)
+  async function synthesize(rawText, cfg, signal, role = 'reply', { skipClean = false } = {}) {
+    let text = skipClean ? String(rawText || '') : cleanText(rawText, cfg, 0)
     if (!text) throw new Error('nothing to speak')
-    const maxChars = Number(cfg.maxChars) > 0 ? Number(cfg.maxChars) : 0
-    const overLimit = maxChars > 0 && text.length > maxChars
-    if (overLimit && cfg.longReply !== 'full') {
-      let cut = text.slice(0, maxChars)
-      if (cfg.longReply === 'summarize') {
-        try {
-          const retold = await summarizeReply(text.slice(0, 8000), cfg, signal)
-          if (retold) cut = speechPhrases(cfg.language).summaryIntro + ' ' + retold
-        } catch (llmDown) { /* quiet fallback to truncation */ }
-      }
-      text = cut
-    }
+    const effectiveLang = cfg.autoDetect ? detectLang(text) : cfg.language
     const models = {}
     const voices = {}
     const order = []
@@ -389,7 +460,8 @@ export function apply(ctx, config) {
     const cacheAllowed = cfg.cache !== false && text.length <= CACHE_MAX_TEXT
     if (cacheAllowed) {
       for (const provider of order) {
-        const hit = await speechCache.get(cacheKey([text, provider, models[provider], voices[provider], role, ov.ssmlStyle]))
+        const fp = synthesisFingerprint(text, provider, models[provider], voices[provider], role, ov.ssmlStyle, cfg, effectiveLang)
+        const hit = await speechCache.get(fp)
         if (hit) {
           stats.total++
           stats.cacheHits++
@@ -399,7 +471,7 @@ export function apply(ctx, config) {
         }
       }
     }
-    const flightKey = cacheKey([text, order.join(','), JSON.stringify(models), JSON.stringify(voices), role, ov.ssmlStyle])
+    const flightKey = flightFingerprint(text, order, models, voices, role, ov.ssmlStyle, cfg, effectiveLang)
     if (inFlightSyntheses.has(flightKey)) {
       return inFlightSyntheses.get(flightKey)
     }
@@ -408,7 +480,7 @@ export function apply(ctx, config) {
       try {
         const baseProviders = makeProviders(
           { resolveKey, fetchImpl: fetch, cfg, modelManager },
-          { text, lang: cfg.autoDetect ? detectLang(text) : cfg.language, signal, models, voices, role },
+          { text, lang: effectiveLang, signal, models, voices, role },
         )
         const providers = {}
         for (const key of Object.keys(baseProviders)) {
@@ -435,7 +507,8 @@ export function apply(ctx, config) {
         ps.ms += out.tookMs || 0
         if (cacheAllowed) {
           const p = out.provider
-          speechCache.put(cacheKey([text, p, models[p], voices[p], role, ov.ssmlStyle]), out.mime, out.audio).catch(() => {})
+          const fp = synthesisFingerprint(text, p, models[p], voices[p], role, ov.ssmlStyle, cfg, effectiveLang)
+          speechCache.put(fp, out.mime, out.audio).catch(() => {})
         }
         return out
       } finally {
@@ -447,16 +520,93 @@ export function apply(ctx, config) {
     return synthPromise
   }
 
+  // Active reservations map and concurrency throttler (#174)
+  const activeReservations = new Map() // id -> { controller, timer, dropped }
+  let activeSyntheses = 0
+  const synthesisQueue = []
+
+  function getEffectiveConcurrency(cfg) {
+    const maxQ = typeof cfg.maxQueue === 'number' && cfg.maxQueue > 0 ? cfg.maxQueue : 8
+    return Math.max(1, Math.min(maxQ, 4))
+  }
+
+  function runThrottledSynthesis(id, signal, fn) {
+    if (signal && signal.aborted) {
+      return Promise.reject(new Error('aborted'))
+    }
+    return new Promise((resolve, reject) => {
+      let isQueued = true
+      const onAbort = () => {
+        if (isQueued) {
+          const idx = synthesisQueue.findIndex((item) => item.id === id)
+          if (idx >= 0) synthesisQueue.splice(idx, 1)
+          reject(new Error('aborted'))
+        }
+      }
+      if (signal) {
+        signal.addEventListener('abort', onAbort, { once: true })
+      }
+
+      const execute = async () => {
+        isQueued = false
+        if (signal) signal.removeEventListener('abort', onAbort)
+        if (signal && signal.aborted) {
+          reject(new Error('aborted'))
+          pumpSynthesisQueue()
+          return
+        }
+        const resv = activeReservations.get(id)
+        if (resv && resv.dropped) {
+          reject(new Error('dropped from queue'))
+          pumpSynthesisQueue()
+          return
+        }
+        activeSyntheses++
+        try {
+          const result = await fn()
+          resolve(result)
+        } catch (err) {
+          reject(err)
+        } finally {
+          activeSyntheses--
+          pumpSynthesisQueue()
+        }
+      }
+
+      const maxLimit = getEffectiveConcurrency(live())
+      if (activeSyntheses < maxLimit) {
+        execute()
+      } else {
+        synthesisQueue.push({ id, run: execute })
+      }
+    })
+  }
+
+  function pumpSynthesisQueue() {
+    const maxLimit = getEffectiveConcurrency(live())
+    while (activeSyntheses < maxLimit && synthesisQueue.length > 0) {
+      const next = synthesisQueue.shift()
+      if (next) next.run()
+    }
+  }
+
   // Synthesize one phrase with queue reservation. The id is issued immediately,
   // not when the provider answers, so short phrases cannot overtake long ones.
   function speakPiece(sid, text, cfg, kind) {
     if (!text) return
+    const maxQ = Math.max(0, typeof cfg.maxQueue === 'number' ? cfg.maxQueue : 32)
+    if (maxQ === 0) return
+
     const role = kind === 'notice' ? 'approval' : kind === 'error' ? 'error' : (kind && kind !== 'speech' ? kind : 'reply')
     const id = `u${++utteranceSeq}`
     const controller = new AbortController()
     const timer = setTimeout(() => controller.abort(), cfg.timeoutMs)
+    activeReservations.set(id, { controller, timer, dropped: false })
     reserve(id)
-    synthesize(text, cfg, controller.signal, role)
+
+    runThrottledSynthesis(id, controller.signal, () =>
+      synthesize(text, cfg, controller.signal, role, { skipClean: true })
+    )
       .then((out) => settle(id, {
         id,
         sessionId: sid,
@@ -469,10 +619,18 @@ export function apply(ctx, config) {
         tookMs: out.tookMs,
       }))
       .catch((err) => {
+        const resv = activeReservations.get(id)
+        if (resv && resv.dropped) {
+          activeReservations.delete(id)
+          return
+        }
         stats.errors++
         settle(id, { id, sessionId: sid, kind: 'error', text, error: String(err && err.message || err) })
       })
-      .finally(() => clearTimeout(timer))
+      .finally(() => {
+        clearTimeout(timer)
+        activeReservations.delete(id)
+      })
   }
 
   // Announcement: short chime then phrase. The chime is drawn by the browser,
@@ -492,16 +650,35 @@ export function apply(ctx, config) {
 
   function enqueue(item) {
     pending.push(item)
-    const max = live().maxQueue || 32
-    while (pending.length > max) {
+    const max = Math.max(0, typeof live().maxQueue === 'number' ? live().maxQueue : 32)
+    if (max === 0) {
+      for (const p of pending) {
+        if (p && p.id && activeReservations.has(p.id)) {
+          const resv = activeReservations.get(p.id)
+          resv.dropped = true
+          try { resv.controller.abort() } catch {}
+          clearTimeout(resv.timer)
+          activeReservations.delete(p.id)
+        }
+      }
+      pending.length = 0
+      return
+    }
+    while (pending.length > max && pending.length > 0) {
       const dropIndex = pending.findIndex((x) => x.kind !== 'reserved')
-      if (dropIndex >= 0) {
-        pending.splice(dropIndex, 1)
-      } else {
-        pending.shift()
+      const dropped = dropIndex >= 0 ? pending.splice(dropIndex, 1)[0] : pending.shift()
+      if (dropped && dropped.id && activeReservations.has(dropped.id)) {
+        const resv = activeReservations.get(dropped.id)
+        if (resv) {
+          resv.dropped = true
+          try { resv.controller.abort() } catch {}
+          clearTimeout(resv.timer)
+          activeReservations.delete(dropped.id)
+        }
       }
     }
     if (live().streamingEnabled && item.kind === 'chime') {
+      item._streamEmitted = true
       broadcastStream('chime', item)
     }
   }
@@ -512,13 +689,30 @@ export function apply(ctx, config) {
     enqueue({ id, kind: 'reserved' })
   }
 
+  function flushReadyStream() {
+    if (!live().streamingEnabled) return
+    for (const item of pending) {
+      if (item.kind === 'reserved') {
+        break // Stop at the first unsettled reservation to preserve sequence order
+      }
+      if (!item._streamEmitted) {
+        item._streamEmitted = true
+        if (item.audioBase64) {
+          broadcastStream('utterance', item)
+        }
+      }
+    }
+  }
+
   function settle(id, item) {
+    activeReservations.delete(id)
     const at = pending.findIndex((row) => row.id === id)
-    if (at === -1) { enqueue(item); return }
-    pending[at] = item
-    if (live().streamingEnabled && item.audioBase64) {
-      broadcastStream('utterance', item)
+    if (at === -1) {
+      // Dropped reservation: do NOT re-enqueue (#174)
+      return
     }
+    pending[at] = item
+    flushReadyStream()
   }
 
   ctx.effect(() => ctx.on('session/event', (session, event) => {
@@ -526,6 +720,8 @@ export function apply(ctx, config) {
     if (!cfg.speakReplies) return
     const sid = session && session.id
     if (!sid) return
+    const isMessenger = session && (session.kind === 'im' || session.kind === 'messenger' || session.channel === 'messenger' || session.type === 'im')
+    if (isMessenger && cfg.messengerTtsEnabled === false) return
     // The agent is waiting for human approval — worth speaking aloud
     // so the user notices without watching the screen.
     if (event.type === 'approval/asked') {
@@ -547,13 +743,14 @@ export function apply(ctx, config) {
         event.data.agent ||
         (event.data.message && (event.data.message.subagent || event.data.message.agent || event.data.message.sender || (event.data.message.author && event.data.message.author.name)))
       )) || (session && (session.subagent || session.agent)) || ''
-      const activeRole = (agentName && cfg.roles && cfg.roles[agentName] && (cfg.roles[agentName].provider || cfg.roles[agentName].voice)) ? agentName : 'reply'
+      const allowSubagent = cfg.autoDetectSubagent !== false
+      const activeRole = (allowSubagent && agentName && cfg.roles && cfg.roles[agentName] && (cfg.roles[agentName].provider || cfg.roles[agentName].voice)) ? agentName : 'reply'
 
       // Speak as it goes: each incoming chunk is spoken immediately
       // in sentence pieces; waiting for turn end means silence while the agent works.
       
       if (cfg.speakAsItGoes) {
-        const ready = cleanText(text, cfg)
+        const ready = cleanText(text, cfg, 0)
         for (const piece of splitSentences(ready, cfg.sentenceChars)) speakPiece(sid, piece, cfg, activeRole)
         return
       }
@@ -569,13 +766,14 @@ export function apply(ctx, config) {
     const cur = collectors.get(sid)
     collectors.delete(sid)
     const raw = cur && Array.isArray(cur.parts) ? cur.parts.join('\n') : ''
-    const text = cleanText(raw, cfg)
-    if (!text) return
-    const pieces = splitSentences(text, cfg.sentenceChars)
     const activeRole = (cur && cur.role) || 'reply'
-    for (const piece of pieces) {
-      speakPiece(sid, piece, cfg, activeRole)
-    }
+    prepareSpeechText(raw, cfg).then((text) => {
+      if (!text) return
+      const pieces = splitSentences(text, cfg.sentenceChars)
+      for (const piece of pieces) {
+        speakPiece(sid, piece, cfg, activeRole)
+      }
+    }).catch(() => {})
   }), 'dsh-tts: speak finished replies')
 
 
@@ -587,6 +785,7 @@ export function apply(ctx, config) {
     stats,
     speechCache,
     cleanText,
+    prepareSpeechText,
     synthesize,
     credentialsView,
     configResponse,
@@ -633,16 +832,40 @@ export function apply(ctx, config) {
       },
       execute: async (args, exec) => {
         const cfg = live()
+        const rawText = String(args.text || '').trim()
+        if (!rawText) return { ok: false, error: 'empty text' }
+        const sid = exec?.session?.id || 'tool'
+        const id = `u${++utteranceSeq}`
+        reserve(id)
         try {
-          const out = await synthesize(String(args.text || ''), cfg, exec.signal)
+          const text = await prepareSpeechText(rawText, cfg, exec.signal)
+          if (!text) {
+            settle(id, { id, sessionId: sid, kind: 'error', text: rawText, error: 'nothing to speak' })
+            return { ok: false, error: 'nothing to speak' }
+          }
+          const out = await synthesize(text, cfg, exec.signal, 'reply', { skipClean: true })
+          const item = {
+            id,
+            sessionId: sid,
+            kind: 'speech',
+            role: 'reply',
+            text,
+            provider: out.provider,
+            mime: out.mime,
+            audioBase64: Buffer.from(out.audio).toString('base64'),
+            tookMs: out.tookMs,
+          }
+          settle(id, item)
           return {
             ok: true,
+            id,
             provider: out.provider,
             mime: out.mime,
             bytes: out.audio.length,
             tookMs: out.tookMs,
           }
         } catch (e) {
+          settle(id, { id, sessionId: sid, kind: 'error', text: rawText, error: String(e && e.message || e) })
           return { ok: false, error: String(e && e.message || e) }
         }
       },

package/lib/local.js

@@ -39,7 +39,7 @@ function spawnCollect(bin, args, { stdinText, timeoutMs } = {}) {
 
 export async function espeakSpeak(text, { bin, voice, timeoutMs }) {
   const bytes = await spawnCollect(bin || 'espeak-ng', [
-    '-v', voice || 'ru',
+    '-v', voice || 'en',
     '--stdout',
     '-s', '165',
   ], { stdinText: text, timeoutMs })

package/lib/providers/cloud.js

@@ -18,6 +18,29 @@ function escapeXml(s) {
     .replace(/"/g, '"')
 }
 
+function pcmToWav(pcmBuffer, sampleRate = 24000, channels = 1) {
+  if (pcmBuffer.length >= 4 && pcmBuffer.toString('ascii', 0, 4) === 'RIFF') {
+    return pcmBuffer
+  }
+  const header = Buffer.alloc(44)
+  const byteRate = sampleRate * channels * 2
+  const blockAlign = channels * 2
+  header.write('RIFF', 0)
+  header.writeUInt32LE(36 + pcmBuffer.length, 4)
+  header.write('WAVE', 8)
+  header.write('fmt ', 12)
+  header.writeUInt32LE(16, 16)
+  header.writeUInt16LE(1, 20)
+  header.writeUInt16LE(channels, 22)
+  header.writeUInt32LE(sampleRate, 24)
+  header.writeUInt32LE(byteRate, 28)
+  header.writeUInt16LE(blockAlign, 32)
+  header.writeUInt16LE(16, 34)
+  header.write('data', 36)
+  header.writeUInt32LE(pcmBuffer.length, 40)
+  return Buffer.concat([header, pcmBuffer])
+}
+
 export function makeCloudProviders(deps, req, withCloudTimeout) {
   const { resolveKey, fetchImpl, cfg } = deps
   const { text, lang, models, voices, role } = req
@@ -161,9 +184,15 @@ export function makeCloudProviders(deps, req, withCloudTimeout) {
     )
     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')
+    const inline = data?.candidates?.[0]?.content?.parts?.find((p) => p.inlineData)?.inlineData
+    if (!inline?.data) return { ok: false, provider: 'google', reason: 'no inline audio' }
+    const raw = Buffer.from(inline.data, 'base64')
+    const mimeType = String(inline.mimeType || '')
+    let sampleRate = 24000
+    const m = mimeType.match(/rate=(\d+)/i)
+    if (m) sampleRate = parseInt(m[1], 10)
+    const isWavAlready = raw.length >= 4 && raw.toString('ascii', 0, 4) === 'RIFF'
+    const audio = isWavAlready ? raw : pcmToWav(raw, sampleRate, 1)
     return { ok: audio.length > 0, provider: 'google', audio, mime: 'audio/wav', reason: audio.length ? '' : 'empty audio' }
     } finally {
       cleanup()
@@ -181,8 +210,10 @@ export function makeCloudProviders(deps, req, withCloudTimeout) {
     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}">`
+    const safeLang = escapeXml(lang || 'en-US')
+    const safeVoice = escapeXml(voice)
+    const ssml = `<speak version="1.0" xmlns="http://www.w3.org/2001/10/synthesis" xmlns:mstts="https://www.w3.org/2001/mstts" xml:lang="${safeLang}">`
+      + `<voice xml:lang="${safeLang}" name="${safeVoice}">`
       + `${inner}</voice></speak>`
     const { signal, cleanup } = withCloudTimeout()
     try {

package/lib/providers/constants.js

@@ -31,9 +31,9 @@ export const DEFAULT_MODELS = {
   deepgram: 'aura-asteria-en',
   openrouter: 'openai/gpt-4o-mini-tts-2025-12-15',
   custom: '',
-  edge: 'ru-RU-SvetlanaNeural',
+  edge: 'en-US-AriaNeural',
   piper: '',
-  espeak: 'ru',
+  espeak: 'en',
 }
 
 export const DEFAULT_VOICES = {
@@ -53,9 +53,9 @@ export const DEFAULT_VOICES = {
   deepgram: '',
   openrouter: 'alloy',
   custom: '',
-  edge: 'ru-RU-SvetlanaNeural',
+  edge: 'en-US-AriaNeural',
   piper: '',
-  espeak: 'ru',
+  espeak: 'en',
 }
 
 

package/lib/providers/local.js

@@ -32,7 +32,7 @@ export function makeLocalProviders(deps, req) {
   }
   async function espeak() {
     try {
-      const voice = pick(DEFAULT_VOICES, voices, 'espeak') || lang || 'ru'
+      const voice = pick(DEFAULT_VOICES, voices, 'espeak') || lang || 'en'
       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) {

package/lib/providers.js

@@ -16,13 +16,22 @@ export function makeProviders(deps, req) {
       timedOut = true
       controller.abort(new Error())
     }, cloudTimeoutMs)
+    let onParentAbort = null
     if (parentSignal) {
       if (parentSignal.aborted) controller.abort(parentSignal.reason)
-      else parentSignal.addEventListener('abort', () => controller.abort(parentSignal.reason), { once: true })
+      else {
+        onParentAbort = () => controller.abort(parentSignal.reason)
+        parentSignal.addEventListener('abort', onParentAbort, { once: true })
+      }
     }
     return {
       signal: controller.signal,
-      cleanup: () => clearTimeout(timer),
+      cleanup: () => {
+        clearTimeout(timer)
+        if (parentSignal && onParentAbort) {
+          try { parentSignal.removeEventListener('abort', onParentAbort) } catch {}
+        }
+      },
     }
   }