@goodandready/dsh-tts 0.3.6 → 0.3.8

package/lib/cache.js

@@ -0,0 +1,83 @@
+// Кэш синтеза на диске: ключ — хеш (текст, провайдер, модель, голос),
+// значение — ответ провайдера как есть (байты + MIME). Вытеснение самых
+// давних по времени последнего обращения; ограничение задаётся настройкой
+// cacheMaxMb и может меняться на живую, поэтому приходит функцией.
+import { createHash } from 'node:crypto'
+import fs from 'node:fs'
+import path from 'node:path'
+
+export function cacheKey(parts) {
+  return createHash('sha1').update(JSON.stringify(parts)).digest('hex')
+}
+
+const AUDIO_EXT = '.audio'
+
+export function createSpeechCache({ root, maxBytes }) {
+  const dir = path.join(String(root), 'data', 'dsh-tts', 'cache')
+  let ready = null
+  const ensure = () => {
+    if (!ready) ready = fs.promises.mkdir(dir, { recursive: true })
+    return ready
+  }
+
+  async function listEntries() {
+    await ensure()
+    const out = []
+    for (const name of await fs.promises.readdir(dir)) {
+      if (!name.endsWith(AUDIO_EXT)) continue
+      const full = path.join(dir, name)
+      const st = await fs.promises.stat(full)
+      let at = st.mtimeMs
+      try {
+        const meta = JSON.parse(await fs.promises.readFile(path.join(dir, name.slice(0, -AUDIO_EXT.length) + '.json'), 'utf8'))
+        if (meta && typeof meta.at === 'number') at = meta.at
+      } catch (noMeta) { /* старьё без меты — вытесним первым */ }
+      out.push({ full, meta: name.slice(0, -AUDIO_EXT.length) + '.json', size: st.size, at })
+    }
+    return out
+  }
+
+  async function evict() {
+    const limit = typeof maxBytes === 'function' ? maxBytes() : Number(maxBytes)
+    if (!(limit > 0)) return
+    const entries = (await listEntries()).sort((a, b) => a.at - b.at)
+    let total = entries.reduce((acc, e) => acc + e.size, 0)
+    for (const e of entries) {
+      if (total <= limit) break
+      await fs.promises.rm(e.full, { force: true })
+      await fs.promises.rm(path.join(dir, e.meta), { force: true }).catch(() => {})
+      total -= e.size
+    }
+  }
+
+  return {
+    async put(key, mime, audio) {
+      await ensure()
+      const buf = Buffer.isBuffer(audio) ? audio : Buffer.from(audio)
+      await fs.promises.writeFile(path.join(dir, key + AUDIO_EXT), buf)
+      await fs.promises.writeFile(path.join(dir, key + '.json'), JSON.stringify({ mime, at: Date.now() }))
+      await evict()
+    },
+
+    async get(key) {
+      try {
+        const meta = JSON.parse(await fs.promises.readFile(path.join(dir, key + '.json'), 'utf8'))
+        const audio = await fs.promises.readFile(path.join(dir, key + AUDIO_EXT))
+        // Последнее обращение двигаем асинхронно: чтение тормозить нельзя.
+        fs.promises.writeFile(path.join(dir, key + '.json'), JSON.stringify({ mime: meta.mime, at: Date.now() })).catch(() => {})
+        return { mime: meta.mime || 'audio/mpeg', audio }
+      } catch (miss) {
+        return null
+      }
+    },
+
+    async clear() {
+      const entries = await listEntries()
+      for (const e of entries) {
+        await fs.promises.rm(e.full, { force: true })
+        await fs.promises.rm(path.join(dir, e.meta), { force: true }).catch(() => {})
+      }
+      return entries.length
+    },
+  }
+}

package/lib/client.js

@@ -228,6 +228,7 @@ window.__ModuleLoader__.load({
         player.enabled = !!(meta && meta.speakReplies)
         if (meta && typeof meta.rate === 'number') player.rate = meta.rate
         if (meta && meta.chime) player.chime = meta.chime
+          if (meta && meta.roles) player.roles = meta.roles
         if (meta && typeof meta.bargeIn === 'boolean') player.bargeIn = meta.bargeIn
         if (!player.enabled) return
         const res = await fetch('/dsh-tts/pending?after=' + encodeURIComponent(player.after || ''), { cache: 'no-store' })
@@ -368,6 +369,29 @@ window.__ModuleLoader__.load({
       'cardHint': 'Provider chain, voices and playback options.',
       'skipCode': 'Skip code blocks',
       'skipCodeHint': 'Say a short notice instead of reading code aloud.',
+      'cache': 'Synthesis cache',
+      'cacheHint': 'Reuse synthesized audio for repeated phrases.',
+      'cacheMaxMb': 'Cache size limit, MB',
+      'cacheMaxMbHint': 'Least recently used items are evicted first.',
+      'clearCache': 'Clear cache',
+      'pronTitle': 'Pronunciation',
+      'pronHint': 'Rules run top-down. Wrap left side in /…/ for a regex; Lang filters the rule.',
+      'pronFrom': 'Replace',
+      'pronTo': 'With',
+      'pronWhole': 'Whole word',
+      'pronLang': 'Lang',
+      'addRule': 'Add rule',
+      'rolesTitle': 'Voice roles',
+      'rolesHint': 'Empty fields inherit the main chain.',
+      'roleReply': 'Reply',
+      'roleApproval': 'Approval',
+      'roleError': 'Error',
+      'longReply': 'Long replies',
+      'longReplyHint': 'truncate: cut at the limit; summarize: short retelling; full: read everything.',
+      'summaryModel': 'Summary model',
+      'summaryModelHint': 'provider/model, empty = conversation default.',
+      'summarySentences': 'Retelling length',
+      'summarySentencesHint': 'Sentences in the spoken retelling.',
     }
     const ru = {
       'general': 'Общее',
@@ -418,6 +442,29 @@ window.__ModuleLoader__.load({
       'cardHint': 'Цепочка провайдеров, голоса и параметры чтения.',
       'skipCode': 'Пропускать код',
       'skipCodeHint': 'Вместо чтения кода вслух — короткая пометка.',
+      'cache': 'Кэш синтеза',
+      'cacheHint': 'Повторяющиеся фразы не синтезируются заново.',
+      'cacheMaxMb': 'Лимит кэша, МБ',
+      'cacheMaxMbHint': 'Сначала вытесняется самое давнее по использованию.',
+      'clearCache': 'Очистить кэш',
+      'pronTitle': 'Произношение',
+      'pronHint': 'Правила работают сверху вниз; /…/ в левой части — регулярка; Язк ограничивает правило.',
+      'pronFrom': 'Заменить',
+      'pronTo': 'На',
+      'pronWhole': 'Целое слово',
+      'pronLang': 'Язк',
+      'addRule': 'Добавить правило',
+      'rolesTitle': 'Голоса ролей',
+      'rolesHint': 'Пустые поля наследуют основную цепочку.',
+      'roleReply': 'Ответ',
+      'roleApproval': 'Подтверждение',
+      'roleError': 'Ошибка',
+      'longReply': 'Длинные ответы',
+      'longReplyHint': 'truncate: обрезать; summarize: короткий пересказ; full: читать целиком.',
+      'summaryModel': 'Модель пересказа',
+      'summaryModelHint': 'provider/model, пусто — как у разговора.',
+      'summarySentences': 'Длина пересказа',
+      'summarySentencesHint': 'Предложений в озвучиваемом пересказе.',
     }
 
     function TtsSection(props) {
@@ -507,6 +554,16 @@ window.__ModuleLoader__.load({
         commitKey(provider, raw).catch((e) => setErr(String(e && e.message ? e.message : e)))
       }
 
+      const clearCacheNow = async () => {
+        setErr('')
+        const res = await fetch('/dsh-tts/cache', { method: 'DELETE' })
+        if (!res.ok) throw new Error('HTTP ' + res.status)
+        setSaved(true); setTimeout(() => setSaved(false), 2000)
+      }
+      const onClearCache = () => {
+        clearCacheNow().catch((e) => setErr(String(e && e.message ? e.message : e)))
+      }
+
       const boolField = (key, label, hint) => React.createElement('label', { className: 'dts-field' }, label,
         React.createElement('input', {
           type: 'checkbox', checked: !!(draft && draft[key]), disabled: !writable,
@@ -546,6 +603,22 @@ window.__ModuleLoader__.load({
           React.createElement('div', { className: 'dts-sub' },
             t('speakRepliesHint')),
         ),
+        React.createElement('div', { className: 'dts-block' },
+          React.createElement('div', { className: 'dts-h' }, t('pronTitle')),
+          React.createElement(PronEditor, {
+            t: t, writable: writable,
+            value: draft && draft.pronunciation ? draft.pronunciation : [],
+            onChange: (v) => setTop('pronunciation', v),
+          }),
+        ),
+        React.createElement('div', { className: 'dts-block' },
+          React.createElement('div', { className: 'dts-h' }, t('rolesTitle')),
+          React.createElement(RolesEditor, {
+            t: t, writable: writable,
+            value: draft && draft.roles ? draft.roles : {},
+            onChange: (v) => setTop('roles', v),
+          }),
+        ),
         React.createElement('div', { className: 'dts-block' },
           React.createElement('div', { className: 'dts-h' }, t('chainTitle')),
           React.createElement('div', { className: 'dts-sub' },
@@ -571,6 +644,17 @@ window.__ModuleLoader__.load({
             t('announceHint')),
           boolField('skipCode', t('skipCode'),
             t('skipCodeHint')),
+          boolField('cache', t('cache'),
+            t('cacheHint')),
+          numberField('cacheMaxMb', t('cacheMaxMb'), t('cacheMaxMbHint'), 10),
+          React.createElement('label', { className: 'dts-field' }, t('longReply'),
+            React.createElement('select', {
+              className: 'dts-input', value: (draft && draft.longReply) || 'truncate', disabled: !writable,
+              onChange: (e) => setTop('longReply', e.target.value),
+            }, ['truncate', 'summarize', 'full'].map((mode) => React.createElement('option', { key: mode, value: mode }, mode))),
+            React.createElement('span', { className: 'dts-sub' }, t('longReplyHint'))),
+          textField('summaryModel', t('summaryModel'), t('summaryModelHint')),
+          numberField('summarySentences', t('summarySentences'), t('summarySentencesHint'), 1),
           textField('approvalText', t('approvalText'), t('approvalHint')),
           textField('questionText', t('questionText'), t('questionHint')),
           textField('chime', t('chime'), t('chimeHint')),
@@ -582,6 +666,7 @@ window.__ModuleLoader__.load({
           textField('azureRegion', t('azureRegion'), t('azureHint')),
         ),
         React.createElement('div', { className: 'dts-foot' },
+          React.createElement('button', { type: 'button', className: 'dts-link', disabled: !writable, onClick: onClearCache }, t('clearCache')),
           React.createElement('button', { type: 'button', className: 'dts-save', disabled: !writable, onClick: save }, t('save')),
           saved ? React.createElement('span', { className: 'dts-ok' }, t('saved')) : null,
           err ? React.createElement('span', { className: 'dts-bad' }, err) : null,
@@ -590,6 +675,84 @@ window.__ModuleLoader__.load({
     }
 
 
+    // Редактор словаря произношения: таблица правил сверху вниз.
+    function PronEditor(props) {
+      const t = props.t || ((key) => key)
+      const rows = Array.isArray(props.value) ? props.value : []
+      const change = (i, patch) => {
+        props.onChange(rows.map((r, k) => (k === i ? Object.assign({}, r, patch) : r)))
+      }
+      const remove = (i) => props.onChange(rows.filter((_, k) => k !== i))
+      const add = () => props.onChange(rows.concat([{ from: '', to: '', whole: false, lang: '' }]))
+      return React.createElement('div', { className: 'dts-wrap-in' },
+        rows.map((rule, i) => React.createElement('div', { className: 'dts-row', key: i },
+          React.createElement('input', {
+            className: 'dts-input dts-grow', placeholder: t('pronFrom'),
+            value: rule.from || '', disabled: !props.writable,
+            onChange: (e) => change(i, { from: e.target.value }),
+          }),
+          React.createElement('input', {
+            className: 'dts-input dts-grow', placeholder: t('pronTo'),
+            value: rule.to || '', disabled: !props.writable,
+            onChange: (e) => change(i, { to: e.target.value }),
+          }),
+          React.createElement('label', { className: 'dts-sub', title: t('pronWhole') },
+            React.createElement('input', {
+              type: 'checkbox', checked: !!rule.whole, disabled: !props.writable,
+              onChange: (e) => change(i, { whole: e.target.checked }),
+            }),
+          ),
+          React.createElement('input', {
+            className: 'dts-input', style: { maxWidth: '70px' }, placeholder: t('pronLang'),
+            value: rule.lang || '', disabled: !props.writable,
+            onChange: (e) => change(i, { lang: e.target.value }),
+          }),
+          React.createElement('button', { type: 'button', className: 'dts-mini', disabled: !props.writable, onClick: () => remove(i) }, '\u00d7'),
+        )),
+        React.createElement('div', { className: 'dts-row' },
+          React.createElement('button', { type: 'button', className: 'dts-mini', disabled: !props.writable, onClick: add }, '+'),
+          React.createElement('span', { className: 'dts-sub' }, t('pronHint')),
+        ),
+      )
+    }
+
+    // Роли: переопределение провайдера/модели/голоса/сигнала, пусто — как у цепочки.
+    const ROLE_KEYS = ['reply', 'approval', 'error']
+
+    function RolesEditor(props) {
+      const t = props.t || ((key) => key)
+      const value = props.value || {}
+      const set = (r, patch) => props.onChange(Object.assign({}, value, { [r]: Object.assign({}, value[r], patch) }))
+      return React.createElement('div', { className: 'dts-block' },
+        React.createElement('span', { className: 'dts-sub' }, t('rolesHint')),
+        ROLE_KEYS.map((r) => React.createElement('div', { className: 'dts-row', key: r },
+          React.createElement('span', { className: 'dts-sub', style: { minWidth: '110px' } }, t('role_' + r)),
+          React.createElement('select', {
+            className: 'dts-input', value: (value[r] && value[r].provider) || '', disabled: !props.writable,
+            onChange: (e) => set(r, { provider: e.target.value }),
+          },
+            React.createElement('option', { value: '' }, '—'),
+            PROVIDERS.map((p) => React.createElement('option', { key: p, value: p }, p)),
+          ),
+          React.createElement('input', {
+            className: 'dts-input dts-grow', placeholder: 'model',
+            value: (value[r] && value[r].model) || '', disabled: !props.writable,
+            onChange: (e) => set(r, { model: e.target.value }),
+          }),
+          React.createElement('input', {
+            className: 'dts-input dts-grow', placeholder: 'voice',
+            value: (value[r] && value[r].voice) || '', disabled: !props.writable,
+            onChange: (e) => set(r, { voice: e.target.value }),
+          }),
+          React.createElement('input', {
+            className: 'dts-input', style: { maxWidth: '90px' }, placeholder: t('chime'),
+            value: (value[r] && value[r].chime) || '', disabled: !props.writable,
+            onChange: (e) => set(r, { chime: e.target.value }),
+          }),
+        )),
+      )
+    }
+
     // Карточка во вкладке «Настройки плагинов» — разметка и стили по
     // единому канону (issue #19): li в списке ядра, шапка со сбросом темы,
     // тело с чертой-разделителем. Шеврон — наш, ядро его не даёт.

package/lib/index.js

@@ -3,7 +3,11 @@ import { defineTool } from '@deepseek-ai/dsh-tools'
 import { credentialRef } from '@deepseek-ai/dsh-credentials'
 import { runChain } from './chain.js'
 import { makeProviders, PROVIDER_KEYS, DEFAULT_MODELS, DEFAULT_VOICES } from './providers.js'
-import { assistantText, speechPhrases, splitSentences, stripForSpeech } from './text.js'
+import { applyPronunciation, assistantText, speechPhrases, splitSentences, stripForSpeech } from './text.js'
+import { cacheKey, createSpeechCache } from './cache.js'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
 import {
   CLOUD_PROVIDERS,
   assertCredentialRef,
@@ -15,7 +19,7 @@ import {
 } from './keys.js'
 
 export const name = 'dsh-tts'
-export const inject = ['tools', 'credentials', 'webServer', 'settings']
+export const inject = ['tools', 'credentials', 'llm', 'webServer', 'settings']
 
 const NS = 'dsh-tts'
 
@@ -28,11 +32,41 @@ const ChainEntry = z.object({
     .description('Voice override. Empty means the provider default.'),
 })
 
+const RoleOverride = z.object({
+  provider: z.string().default(''),
+  model: z.string().default(''),
+  voice: z.string().default(''),
+  chime: z.string().default(''),
+})
+
 export const Config = z.object({
   speakReplies: z.boolean().default(false)
     .description('When on, speak each finished agent reply in the Web UI.'),
   skipCode: z.boolean().default(true)
     .description('Replace fenced code blocks with a short spoken notice instead of reading them aloud.'),
+  cache: z.boolean().default(true)
+    .description('Reuse synthesized audio for repeated phrases instead of paying and waiting again.'),
+  cacheMaxMb: z.number().default(100)
+    .description('Disk limit for the synthesis cache; least recently used items are evicted first.'),
+  pronunciation: z.array(z.object({
+    from: z.string().default(''),
+    to: z.string().default(''),
+    whole: z.boolean().default(false),
+    lang: z.string().default(''),
+  })).default([])
+    .description('Say this instead of that. Applied top-down; /regex/ form allowed in from.'),
+  longReply: z.enum(['truncate', 'summarize', 'full']).default('truncate')
+    .description('What to do when a reply exceeds the length limit.'),
+  summaryModel: z.string().default('')
+    .description('provider/model for the spoken retelling; empty uses the conversation default.'),
+  summarySentences: z.number().default(3)
+    .description('Sentences in the spoken retelling.'),
+  roles: z.object({
+    reply: RoleOverride.default({ provider: '', model: '', voice: '', chime: '' }),
+    approval: RoleOverride.default({ provider: '', model: '', voice: '', chime: '' }),
+    error: RoleOverride.default({ provider: '', model: '', voice: '', chime: '' }),
+  }).default({ reply: {}, approval: {}, error: {} })
+    .description('Per-role overrides; empty fields inherit the main chain.'),
   language: z.string().default('ru'),
   speakAsItGoes: z
     .boolean()
@@ -227,14 +261,66 @@ export function apply(ctx, config) {
     }
   }
 
+  const llm = ctx.llm
+
+  // Кэш синтеза живёт рядом с прочими данными харнесса.
+  const speechCache = createSpeechCache({
+    root: process.env.DSH_HOME || path.join(os.homedir(), '.dsh'),
+    maxBytes: () => {
+      const mb = Number(live().cacheMaxMb)
+      return mb > 0 ? mb * 1024 * 1024 : 100 * 1024 * 1024
+    },
+  })
+  // Порог осмысленности: уникальные длинные куски (чтение по ходу) в кэш
+  // не кладём — иначе он забьётся мусором, который никогда не повторится.
+  const CACHE_MAX_TEXT = 200
+
   // Настройки чистки текста считаем на каждый вызов: конфиг живой.
   function cleanOpts(cfg) {
     return { skipCode: cfg.skipCode !== false, phrases: speechPhrases(cfg.language) }
   }
+  function cleanText(raw, cfg) {
+    return applyPronunciation(stripForSpeech(raw, cfg.maxChars, cleanOpts(cfg)), cfg.pronunciation, cfg.language)
+  }
 
-  async function synthesize(rawText, cfg, signal) {
-    const text = stripForSpeech(rawText, cfg.maxChars, cleanOpts(cfg))
+  // Пересказ быстрой моделью. Любая неудача — пустая строка, вызывающая
+  // сторона тихо откатывается к обрезке.
+  async function summarizeReply(text, cfg, signal) {
+    const sentences = Number(cfg.summarySentences) > 0 ? Number(cfg.summarySentences) : 3
+    if (!llm || typeof llm.stream !== 'function') return ''
+    const opts = {
+      messages: [{ role: 'user', content: 'Перескажи текст в ' + sentences + ' предложениях на его языке. Только пересказ, без вступлений:\n\n' + text }],
+      signal,
+    }
+    const m = String(cfg.summaryModel || '')
+    if (m) {
+      const slash = m.indexOf('/')
+      if (slash > 0) { opts.provider = m.slice(0, slash); opts.model = m.slice(slash + 1) }
+      else opts.model = m
+    }
+    const parts = []
+    for await (const chunk of llm.stream(opts)) {
+      const piece = chunk && (chunk.text || (chunk.delta && chunk.delta.text)) || ''
+      if (piece) parts.push(piece)
+    }
+    return parts.join('').trim()
+  }
+
+  async function synthesize(rawText, cfg, signal, role = 'reply') {
+    let text = cleanText(rawText, cfg)
     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) { /* тихий откат к обрезке */ }
+      }
+      text = cut
+    }
     const models = {}
     const voices = {}
     const order = []
@@ -244,11 +330,32 @@ export function apply(ctx, config) {
       models[entry.provider] = entry.model || DEFAULT_MODELS[entry.provider]
       voices[entry.provider] = entry.voice || DEFAULT_VOICES[entry.provider]
     }
+    // Ролевые переопределения: пустые поля наследуют основную цепочку.
+    const ov = (cfg.roles && cfg.roles[role]) || {}
+    if (ov.provider && PROVIDER_KEYS.includes(ov.provider)) order.unshift(ov.provider)
+    if (order.length) {
+      if (ov.model) models[order[0]] = ov.model
+      if (ov.voice) voices[order[0]] = ov.voice
+    }
+    // Скорость воспроизведения в ключ не входит: ею управляет браузер,
+    // на синтез она не влияет.
+    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]))
+        if (hit) return { provider, mime: hit.mime, audio: hit.audio, tookMs: 0, cached: true }
+      }
+    }
     const providers = makeProviders(
       { resolveKey, fetchImpl: fetch, cfg },
       { text, lang: cfg.language, signal, models, voices },
     )
-    return runChain(order, providers)
+    const out = await runChain(order, providers)
+    if (cacheAllowed) {
+      const p = out.provider
+      speechCache.put(cacheKey([text, p, models[p], voices[p], role]), out.mime, out.audio).catch(() => {})
+    }
+    return out
   }
 
   // Синтез одной фразы с постановкой в очередь. Порядок сохраняется: номер
@@ -256,11 +363,12 @@ export function apply(ctx, config) {
   // обгоняли бы длинные.
   function speakPiece(sid, text, cfg, kind) {
     if (!text) return
+    const role = kind === 'notice' ? 'approval' : kind === 'error' ? 'error' : 'reply'
     const id = `u${++utteranceSeq}`
     const controller = new AbortController()
     const timer = setTimeout(() => controller.abort(), cfg.timeoutMs)
     reserve(id)
-    synthesize(text, cfg, controller.signal)
+    synthesize(text, cfg, controller.signal, role)
       .then((out) => settle(id, {
         id,
         sessionId: sid,
@@ -276,9 +384,15 @@ export function apply(ctx, config) {
 
   // Объявление: сначала короткий сигнал, затем фраза. Сигнал — не файл, его
   // рисует сам браузер, поэтому ничего не качается и не хранится.
+  function roleChime(cfg, role) {
+    const ov = (cfg.roles && cfg.roles[role]) || {}
+    return ov.chime || cfg.chime
+  }
+
   function announce(sid, text, cfg) {
-    if (cfg.chime && cfg.chime !== 'none') {
-      enqueue({ id: `u${++utteranceSeq}`, sessionId: sid, kind: 'chime', chime: cfg.chime })
+    const chime = roleChime(cfg, 'approval')
+    if (chime && chime !== 'none') {
+      enqueue({ id: `u${++utteranceSeq}`, sessionId: sid, kind: 'chime', chime })
     }
     speakPiece(sid, text, cfg, 'notice')
   }
@@ -327,7 +441,7 @@ export function apply(ctx, config) {
       // предложениями, и очередь проигрывается по порядку. Ждать конца хода
       // значит молчать всё время, пока агент работает.
       if (cfg.speakAsItGoes) {
-        const ready = stripForSpeech(text, cfg.maxChars, cleanOpts(cfg))
+        const ready = cleanText(text, cfg)
         for (const piece of splitSentences(ready, cfg.sentenceChars)) speakPiece(sid, piece, cfg)
         return
       }
@@ -342,7 +456,7 @@ 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 = stripForSpeech(raw, cfg.maxChars, cleanOpts(cfg))
+    const text = cleanText(raw, cfg)
     if (!text) return
     const id = `u${++utteranceSeq}`
     const controller = new AbortController()
@@ -382,11 +496,29 @@ export function apply(ctx, config) {
         bargeIn: cfg.bargeIn,
         language: cfg.language,
         chain: cfg.chain,
+        roles: cfg.roles,
         providers: PROVIDER_KEYS,
       })
     },
   }), 'dsh-tts: /status route')
 
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-tts/cache',
+    handler: async (req, res) => {
+      if (req.method !== 'DELETE') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'DELETE only' } })
+        return
+      }
+      if (!isTrustedSettingsRequest(req)) {
+        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
+        return
+      }
+      const removed = await speechCache.clear()
+      writeJson(res, 200, { ok: true, removed })
+    },
+  }), 'dsh-tts: /cache route')
+
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact',
     path: '/dsh-tts/config',
@@ -509,7 +641,7 @@ export function apply(ctx, config) {
       }
       let payload
       try { payload = JSON.parse(raw.toString('utf8') || '{}') } catch { payload = {} }
-      const text = stripForSpeech(payload.text, live().maxChars, cleanOpts(live()))
+      const text = cleanText(payload.text, live())
       if (!text) { writeJson(res, 400, { ok: false, error: { code: 'no-text', message: 'no text' } }); return }
       const cfg = live()
       const controller = new AbortController()

package/lib/text.js

@@ -14,8 +14,8 @@ export function blocksToText(content) {
 // Короткие пометки вместо выброшенной разметки. Формулировки выбираются по
 // языку озвучки из настроек; подстановки {n} заполняются числом строк.
 export const SPEECH_PHRASES = {
-  en: { codeBlock: 'code block, {n} lines', table: 'table, {n} rows' },
-  ru: { codeBlock: 'блок кода, {n} строк', table: 'таблица, {n} строк' },
+  en: { codeBlock: 'code block, {n} lines', table: 'table, {n} rows', summaryIntro: 'Summary of the reply.' },
+  ru: { codeBlock: 'блок кода, {n} строк', table: 'таблица, {n} строк', summaryIntro: 'Пересказ ответа.' },
 }
 
 export function speechPhrases(language) {
@@ -23,6 +23,34 @@ export function speechPhrases(language) {
   return lang.startsWith('ru') ? SPEECH_PHRASES.ru : SPEECH_PHRASES.en
 }
 
+// Словарь произношения: правила применяются сверху вниз, каждое по одному
+// разу ко всему тексту. Левая часть — обычный текст; запись вида /…/флаги
+// трактуется как регулярное выражение для тех, кто умеет. whole=true требует
+// совпадения целого слова (границы по буквам/цифрам Unicode).
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+export function applyPronunciation(text, rules, language) {
+  let out = String(text || '')
+  const lang = String(language || '').toLowerCase()
+  const list = Array.isArray(rules) ? rules : []
+  for (const rule of list) {
+    if (!rule || typeof rule.from !== 'string' || !rule.from) continue
+    if (rule.lang && !lang.startsWith(String(rule.lang).toLowerCase())) continue
+    const to = typeof rule.to === 'string' ? rule.to : ''
+    try {
+      const rx = /^\/(.+)\/([a-z]*)$/s.exec(rule.from)
+      let re
+      if (rx) re = new RegExp(rx[1], rx[2].includes('g') ? rx[2] : rx[2] + 'g')
+      else if (rule.whole) re = new RegExp('(?<![\\p{L}\\p{N}])' + escapeRe(rule.from) + '(?![\\p{L}\\p{N}])', 'gu')
+      else re = new RegExp(escapeRe(rule.from), 'g')
+      out = out.replace(re, to)
+    } catch (badRule) { /* кривое правило не роняет озвучку */ }
+  }
+  return out
+}
+
 function fill(template, n) {
   return String(template).replace('{n}', String(n))
 }
@@ -54,8 +82,9 @@ export function stripForSpeech(raw, maxChars, opts) {
   text = text.replace(/[#*_>]+/g, ' ')
   text = text.replace(/MEDIA:[^\s]+/g, ' ')
   text = text.replace(/\s+/g, ' ').trim()
-  const limit = Number(maxChars) > 0 ? Number(maxChars) : 4000
-  if (text.length > limit) text = text.slice(0, limit)
+  // maxChars === 0 отключает обрезку; не задан — дефолтные 4000.
+  const requested = Number(maxChars)
+  if (requested > 0 && text.length > requested) text = text.slice(0, requested)
   return text
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-tts",
-  "version": "0.3.6",
+  "version": "0.3.8",
   "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",