@goodandready/dsh-tts 0.4.27 → 0.4.29

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,49 +111,61 @@ 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([
-      { provider: 'edge', model: '', voice: 'ru-RU-SvetlanaNeural' },
+      { provider: 'edge', model: '', voice: 'en-US-JennyNeural' },
       { provider: 'piper', model: '', voice: '' },
-      { provider: 'espeak', model: '', voice: 'ru' },
+      { provider: 'espeak', model: '', voice: 'en' },
     ])
     .description('Fallback chain. Order is the order of attempts. A provider without a key is skipped.'),
   openaiKeyEnv: z.string().volatile().default('OPENAI_API_KEY'),
@@ -182,31 +194,94 @@ 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),
 })
 
+export function extractRevision(desc, targetNs = NS) {
+  if (!desc) return undefined
+  if (typeof desc.revision === 'number' || typeof desc.revision === 'string') {
+    return desc.revision
+  }
+  let list = null
+  if (Array.isArray(desc)) {
+    list = desc
+  } else if (Array.isArray(desc.namespaces)) {
+    list = desc.namespaces
+  } else if (Array.isArray(desc.entries)) {
+    list = desc.entries
+  }
+  if (list) {
+    const match = list.find((item) => {
+      if (!item || typeof item !== 'object') return false
+      const name = item.name || item.id || item.ns || item.namespace || item.key
+      return name === targetNs || name === 'goodandready/dsh-tts' || name === 'dsh-tts' || name === '@goodandready/dsh-tts'
+    })
+    if (match && (typeof match.revision === 'number' || typeof match.revision === 'string')) {
+      return match.revision
+    }
+    if (list.length === 1 && (typeof list[0].revision === 'number' || typeof list[0].revision === 'string')) {
+      return list[0].revision
+    }
+  }
+  if (typeof desc === 'object') {
+    for (const k of [targetNs, 'goodandready/dsh-tts', 'dsh-tts', '@goodandready/dsh-tts']) {
+      if (desc[k] && (typeof desc[k].revision === 'number' || typeof desc[k].revision === 'string')) {
+        return desc[k].revision
+      }
+    }
+  }
+  return undefined
+}
+
 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)
+  const live = () => {
+    const fromBoxes = plainConfig(config)
+    return plainConfig(Config(fromBoxes))
+  }
 
   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
-        if (typeof svc.replace === 'function') {
-          await svc.replace(NS, plain, rev)
-        } else if (typeof svc.update === 'function') {
-          await svc.update(NS, plain, rev)
+      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)
+          rev = extractRevision(desc, NS)
+        } catch (_err) {
+          // ignore describe error
+        }
+      }
+      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')
+      }
+
+      // Mutate volatile boxes directly so runtime dynamically reflects new settings (#152)
+      if (config && typeof config === 'object') {
+        for (const [k, v] of Object.entries(plain)) {
+          if (config[k] && typeof config[k] === 'object') {
+            const sym = Object.getOwnPropertySymbols(config[k]).find((s) => String(s).includes('volatile.write'))
+            if (sym && typeof config[k][sym] === 'function') {
+              try { config[k][sym](v) } catch (_wErr) { /* best effort */ }
+            } else if ('value' in config[k]) {
+              config[k].value = v
+            }
+          } else if (config[k] !== undefined) {
+            config[k] = v
+          }
         }
       }
       return plain
@@ -228,7 +303,7 @@ export function apply(ctx, config) {
     try {
       const resolved = await ctx.credentials.resolve(credentialRef(ref))
       if (resolved && resolved.value) return resolved.value
-    } catch { /* fall through to env */ }
+    } catch (_err) { /* fall through to env */ }
     return process.env[ref] || ''
   }
 
@@ -248,7 +323,7 @@ export function apply(ctx, config) {
       }
       const resolved = await ctx.credentials.resolve(credentialRef(ref))
       return { provider, ref, configured: !!(resolved && resolved.value), writable: true }
-    } catch {
+    } catch (_err) {
       return base
     }
   }
@@ -290,10 +365,21 @@ export function apply(ctx, config) {
   }
 
   async function configResponse() {
+    let revision = null
+    const svc = ctx?.get?.('settings') ?? ctx?.settings ?? ctx?.get?.('settingsForms') ?? ctx?.settingsForms
+    if (svc && typeof svc.describe === 'function') {
+      try {
+        const desc = await svc.describe(NS)
+        revision = extractRevision(desc, NS) ?? null
+      } catch (_err) {
+        // best effort describe
+      }
+    }
     return {
       ok: true,
       config: publicConfig(live()),
       credentials: await credentialsView(),
+      revision,
     }
   }
 
@@ -321,15 +407,62 @@ 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 (_err) { /* quiet fallback to truncation */ }
+      }
+      return text.slice(0, maxChars)
+    }
+    return text
+  }
+
+  function synthesisFingerprint(text, provider, model, voice, role, ssmlStyle, cfg, lang) {
+    const credRef = needsApiKey(provider) ? (keyEnvName(cfg, provider) || '') : ''
+    const parts = [text, provider, model || '', voice || '', role || '', ssmlStyle || '', lang || '', credRef]
+    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 credRef = needsApiKey(p) ? (keyEnvName(cfg, 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] || ''}:${credRef}:${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 +486,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 +511,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 +522,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 +531,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 +558,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 +571,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 +670,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 +701,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 (_abortErr) { /* ignore aborted controller */ }
+          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 (_abortErr) { /* ignore aborted controller */ }
+          clearTimeout(resv.timer)
+          activeReservations.delete(dropped.id)
+        }
       }
     }
     if (live().streamingEnabled && item.kind === 'chime') {
+      item._streamEmitted = true
       broadcastStream('chime', item)
     }
   }
@@ -512,13 +740,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 +771,10 @@ 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' || session.source === 'messenger')
+    if (isMessenger && !cfg.messengerTtsEnabled) return
+    const isVoice = session && (session.kind === 'voice' || session.channel === 'voice' || session.type === 'voice' || session.mode === 'voice')
+    if (isVoice && !cfg.voiceDuplexEnabled) return
     // The agent is waiting for human approval — worth speaking aloud
     // so the user notices without watching the screen.
     if (event.type === 'approval/asked') {
@@ -541,20 +790,25 @@ export function apply(ctx, config) {
     }
 
     if (event.type === 'assistant/message') {
-      const text = assistantText(event.data && event.data.message)
+      const text = assistantText(event.data && (event.data.message ?? event.data.text ?? event.data))
       const agentName = (event.data && (
         event.data.subagent ||
         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)
-        for (const piece of splitSentences(ready, cfg.sentenceChars)) speakPiece(sid, piece, cfg, activeRole)
+        prepareSpeechText(text, cfg).then((ready) => {
+          if (!ready) return
+          for (const piece of splitSentences(ready, cfg.sentenceChars)) speakPiece(sid, piece, cfg, activeRole)
+        }).catch((_err) => {
+          // best-effort speech fallback
+        })
         return
       }
       const cur = collectors.get(sid) || { parts: [], role: activeRole }
@@ -569,13 +823,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 +842,7 @@ export function apply(ctx, config) {
     stats,
     speechCache,
     cleanText,
+    prepareSpeechText,
     synthesize,
     credentialsView,
     configResponse,
@@ -617,6 +873,7 @@ export function apply(ctx, config) {
           additionalProperties: false,
           properties: {
             ok: { type: 'boolean' },
+            id: { type: 'string' },
             provider: { type: 'string' },
             mime: { type: 'string' },
             bytes: { type: 'number' },
@@ -633,16 +890,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 })