@goodandready/dsh-tts 0.3.16 → 0.3.21

package/lib/index.js

@@ -8,6 +8,8 @@ import { cacheKey, createSpeechCache } from './cache.js'
 import fs from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
+import { createModelManager } from './engines/manager.js'
+import { EngineRegistry } from './engines/types.js'
 import {
   CLOUD_PROVIDERS,
   assertCredentialRef,
@@ -43,6 +45,14 @@ const RoleOverride = z.object({
 export const Config = z.object({
   speakReplies: z.boolean().default(false)
     .description('When on, speak each finished agent reply in the Web UI.'),
+  enableLocalEngines: z.boolean().default(false)
+    .description('Enable offline local TTS engines (Kokoro / F5).'),
+  kokoroEnabled: z.boolean().default(false)
+    .description('Use local Kokoro-82M on CPU when installed.'),
+  f5Enabled: z.boolean().default(false)
+    .description('Use local F5-TTS on GPU when installed.'),
+  streamingEnabled: z.boolean().default(true)
+    .description('Stream audio in real-time using AudioWorklet and SSE for sub-300ms latency.'),
   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)
@@ -67,18 +77,26 @@ export const Config = z.object({
     lang: z.string().default(''),
   })).default([])
     .description('Say this instead of that. Applied top-down; /regex/ form allowed in from.'),
+  enableItDictionary: z.boolean().default(true)
+    .description('Auto-correct common IT terminology pronunciation (SQL, Nginx, K8s, etc.).'),
   longReply: z.string().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.'),
+  roles: z.dict(RoleOverride).default({
+    reply: { provider: '', model: '', voice: '', chime: '', ssmlStyle: '' },
+    approval: { provider: '', model: '', voice: '', chime: '', ssmlStyle: '' },
+    error: { provider: '', model: '', voice: '', chime: '', ssmlStyle: '' },
+  })
+    .description('Per-role and subagent overrides; empty fields inherit the main chain.'),
+  voiceDuplexEnabled: z.boolean().default(false)
+    .description('Full-duplex voice conversation with dsh-voice.'),
+  vadBargeIn: z.boolean().default(true)
+    .description('Mute speech synthesis immediately when voice activity is detected.'),
+  messengerTtsEnabled: z.boolean().default(false)
+    .description('Send synthesized voice notes to messengers via @goodandready/dsh-messenger-gateway.'),
   language: z.string().default('ru'),
   speakAsItGoes: z
     .boolean()
@@ -199,6 +217,18 @@ export function apply(ctx, config) {
 
   const pending = []
   const collectors = new Map()
+  const streamSubscribers = new Set()
+
+  const modelManager = createModelManager({
+    root: process.env.DSH_HOME || path.join(os.homedir(), '.dsh'),
+  })
+
+  function broadcastStream(event, data) {
+    const payload = `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`
+    for (const res of streamSubscribers) {
+      try { res.write(payload) } catch { streamSubscribers.delete(res) }
+    }
+  }
 
   async function resolveKey(ref) {
     try {
@@ -295,7 +325,12 @@ export function apply(ctx, config) {
     return { skipCode: cfg.skipCode !== false, phrases: speechPhrases(cfg.language) }
   }
   function cleanText(raw, cfg) {
-    return applyPronunciation(applyNarrationFilters(stripForSpeech(raw, cfg.maxChars, cleanOpts(cfg)), cfg), cfg.pronunciation, cfg.language)
+    return applyPronunciation(
+      applyNarrationFilters(stripForSpeech(raw, cfg.maxChars, cleanOpts(cfg)), cfg),
+      cfg.pronunciation,
+      cfg.language,
+      cfg.enableItDictionary !== false,
+    )
   }
 
   // Пересказ быстрой моделью. Любая неудача — пустая строка, вызывающая
@@ -368,7 +403,7 @@ export function apply(ctx, config) {
       }
     }
     const providers = makeProviders(
-      { resolveKey, fetchImpl: fetch, cfg },
+      { resolveKey, fetchImpl: fetch, cfg, modelManager },
       { text, lang: cfg.autoDetect ? detectLang(text) : cfg.language, signal, models, voices, role },
     )
     const out = await runChain(order, providers)
@@ -388,7 +423,7 @@ export function apply(ctx, config) {
   // обгоняли бы длинные.
   function speakPiece(sid, text, cfg, kind) {
     if (!text) return
-    const role = kind === 'notice' ? 'approval' : kind === 'error' ? 'error' : 'reply'
+    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)
@@ -397,7 +432,8 @@ export function apply(ctx, config) {
       .then((out) => settle(id, {
         id,
         sessionId: sid,
-        kind: kind || 'speech',
+        kind: (kind === 'notice' || kind === 'error') ? kind : 'speech',
+        role,
         text,
         provider: out.provider,
         mime: out.mime,
@@ -428,8 +464,18 @@ export function apply(ctx, config) {
 
   function enqueue(item) {
     pending.push(item)
-    const max = live().maxQueue || 8
-    while (pending.length > max) pending.shift()
+    const max = live().maxQueue || 32
+    while (pending.length > max) {
+      const dropIndex = pending.findIndex((x) => x.kind !== 'reserved')
+      if (dropIndex >= 0) {
+        pending.splice(dropIndex, 1)
+      } else {
+        pending.shift()
+      }
+    }
+    if (live().streamingEnabled && item.kind === 'chime') {
+      broadcastStream('chime', item)
+    }
   }
 
   // Место в очереди занимается до синтеза, чтобы порядок фраз совпадал с
@@ -442,6 +488,9 @@ export function apply(ctx, config) {
     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)
+    }
   }
 
   ctx.effect(() => ctx.on('session/event', (session, event) => {
@@ -465,17 +514,20 @@ export function apply(ctx, config) {
 
     if (event.type === 'assistant/message') {
       const text = assistantText(event.data && event.data.message)
-      if (!text) return
+      const agentName = (event.data && (event.data.agent || (event.data.message && event.data.message.agent) || (event.data.message && event.data.message.author && event.data.message.author.name))) || (session && session.agent) || ''
+      const activeRole = (agentName && cfg.roles && cfg.roles[agentName] && cfg.roles[agentName].provider) ? agentName : 'reply'
+
       // Читаем по ходу: каждый пришедший кусок ответа озвучивается сразу,
       // предложениями, и очередь проигрывается по порядку. Ждать конца хода
       // значит молчать всё время, пока агент работает.
       if (cfg.speakAsItGoes) {
         const ready = cleanText(text, cfg)
-        for (const piece of splitSentences(ready, cfg.sentenceChars)) speakPiece(sid, piece, cfg)
+        for (const piece of splitSentences(ready, cfg.sentenceChars)) speakPiece(sid, piece, cfg, activeRole)
         return
       }
-      const cur = collectors.get(sid) || { parts: [] }
+      const cur = collectors.get(sid) || { parts: [], role: activeRole }
       cur.parts.push(text)
+      cur.role = activeRole
       collectors.set(sid, cur)
       return
     }
@@ -490,7 +542,7 @@ export function apply(ctx, config) {
     const id = `u${++utteranceSeq}`
     const controller = new AbortController()
     const timer = setTimeout(() => controller.abort(), cfg.timeoutMs)
-    synthesize(text, cfg, controller.signal)
+    synthesize(text, cfg, controller.signal, (cur && cur.role) || 'reply')
       .then((out) => {
         enqueue({
           id,
@@ -520,6 +572,10 @@ export function apply(ctx, config) {
       writeJson(res, 200, {
         ok: true,
         speakReplies: cfg.speakReplies,
+        enableLocalEngines: cfg.enableLocalEngines,
+        kokoroEnabled: cfg.kokoroEnabled,
+        f5Enabled: cfg.f5Enabled,
+        streamingEnabled: cfg.streamingEnabled,
         rate: cfg.rate,
         chime: cfg.chime,
         bargeIn: cfg.bargeIn,
@@ -531,6 +587,162 @@ export function apply(ctx, config) {
     },
   }), 'dsh-tts: /status route')
 
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-tts/stream',
+    handler: async (req, res) => {
+      if (req.method !== 'GET') { writeJson(res, 405, { ok: false, error: { code: 'method', message: 'GET only' } }); return }
+      try {
+        res.writeHead(200, {
+          'Content-Type': 'text/event-stream',
+          'Cache-Control': 'no-cache, no-transform',
+          'Connection': 'keep-alive',
+        })
+        res.write(': connected\n\n')
+        streamSubscribers.add(res)
+        req.on('close', () => streamSubscribers.delete(res))
+      } catch {
+        streamSubscribers.delete(res)
+      }
+    },
+  }), 'dsh-tts: /stream route')
+
+  ctx.effect(() => () => {
+    for (const res of streamSubscribers) {
+      try { res.end() } catch {}
+    }
+    streamSubscribers.clear()
+  }, 'dsh-tts: cleanup stream subscribers')
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-tts/models/status',
+    handler: async (req, res) => {
+      if (req.method !== 'GET') { writeJson(res, 405, { ok: false, error: { code: 'method', message: 'GET only' } }); return }
+      try {
+        const list = await modelManager.listStatus()
+        writeJson(res, 200, { ok: true, models: list })
+      } catch (err) {
+        writeJson(res, 500, { ok: false, error: String(err && err.message || err) })
+      }
+    },
+  }), 'dsh-tts: /models/status route')
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-tts/models/install',
+    handler: async (req, res) => {
+      if (req.method !== 'POST') { writeJson(res, 405, { ok: false, error: { code: 'method', message: 'POST only' } }); return }
+      if (!isTrustedSettingsRequest(req)) {
+        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
+        return
+      }
+      let body = {}
+      try {
+        const raw = await readBody(req, 16 * 1024)
+        body = JSON.parse(raw.toString('utf8') || '{}')
+      } catch (e) {
+        writeJson(res, 400, { ok: false, error: { code: 'body', message: e.message } })
+        return
+      }
+      const engine = String(body.engine || '').trim()
+      if (!engine) {
+        writeJson(res, 400, { ok: false, error: { code: 'param', message: 'missing engine parameter' } })
+        return
+      }
+      try {
+        // Fire installation in background or await initial start
+        modelManager.installModel(engine).catch(() => {})
+        const current = await modelManager.getStatus(engine)
+        writeJson(res, 200, { ok: true, model: current })
+      } catch (err) {
+        writeJson(res, 500, { ok: false, error: String(err && err.message || err) })
+      }
+    },
+  }), 'dsh-tts: /models/install route')
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-tts/models/delete',
+    handler: async (req, res) => {
+      if (req.method !== 'DELETE' && req.method !== 'POST') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'DELETE or POST only' } })
+        return
+      }
+      if (!isTrustedSettingsRequest(req)) {
+        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
+        return
+      }
+      let body = {}
+      try {
+        const raw = await readBody(req, 16 * 1024)
+        body = JSON.parse(raw.toString('utf8') || '{}')
+      } catch { body = {} }
+      const engine = String(body.engine || '').trim()
+      if (!engine) {
+        writeJson(res, 400, { ok: false, error: { code: 'param', message: 'missing engine parameter' } })
+        return
+      }
+      try {
+        const result = await modelManager.deleteModel(engine)
+        writeJson(res, 200, { ok: true, model: result })
+      } catch (err) {
+        writeJson(res, 500, { ok: false, error: String(err && err.message || err) })
+      }
+    },
+  }), 'dsh-tts: /models/delete route')
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-tts/integrations',
+    handler: async (req, res) => {
+      if (req.method !== 'GET') { writeJson(res, 405, { ok: false, error: { code: 'method', message: 'GET only' } }); return }
+      let voiceInstalled = false
+      let messengerInstalled = false
+
+      try {
+        if (typeof ctx.webServer?.hasRoute === 'function') {
+          voiceInstalled = ctx.webServer.hasRoute('/dsh-voice/status')
+          messengerInstalled = ctx.webServer.hasRoute('/dsh-messenger-gateway/status')
+        }
+      } catch {}
+
+      if (!voiceInstalled) {
+        try {
+          const rootDev = path.join(process.cwd(), '..', 'dsh-voice')
+          const rootNm = path.join(process.cwd(), 'node_modules', '@goodandready', 'dsh-voice')
+          if (fs.existsSync(rootDev) || fs.existsSync(rootNm)) {
+            voiceInstalled = true
+          }
+        } catch {}
+      }
+
+      if (!messengerInstalled) {
+        try {
+          const rootDev = path.join(process.cwd(), '..', 'dsh-messenger-gateway')
+          const rootNm = path.join(process.cwd(), 'node_modules', '@goodandready', 'dsh-messenger-gateway')
+          if (fs.existsSync(rootDev) || fs.existsSync(rootNm)) {
+            messengerInstalled = true
+          }
+        } catch {}
+      }
+
+      writeJson(res, 200, {
+        ok: true,
+        voice: {
+          installed: voiceInstalled,
+          package: '@goodandready/dsh-voice',
+          hint: 'dsh plugin --profile web add @goodandready/dsh-voice',
+        },
+        messenger: {
+          installed: messengerInstalled,
+          package: '@goodandready/dsh-messenger-gateway',
+          hint: 'dsh plugin --profile web add @goodandready/dsh-messenger-gateway',
+        },
+      })
+    },
+  }), 'dsh-tts: /integrations route')
+
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact',
     path: '/dsh-tts/cache',
@@ -562,9 +774,8 @@ export function apply(ctx, config) {
       }
       let body = {}
       try {
-        const chunks = []
-        for await (const c of req) chunks.push(c)
-        body = JSON.parse(Buffer.concat(chunks).toString('utf8') || '{}')
+        const raw = await readBody(req, 64 * 1024)
+        body = JSON.parse(raw.toString('utf8') || '{}')
       } catch (e) {
         writeJson(res, 400, { ok: false, error: { code: 'body', message: e.message } })
         return

package/lib/keys.js

@@ -1,5 +1,6 @@
 export const CLOUD_PROVIDERS = [
   'openai', 'elevenlabs', 'google', 'azure', 'groq', 'deepgram', 'openrouter', 'custom',
+  'siliconflow', 'deepinfra', 'fireworks', 'mimo',
 ]
 
 export const KEY_ENV_FIELD = {
@@ -11,6 +12,10 @@ export const KEY_ENV_FIELD = {
   deepgram: 'deepgramKeyEnv',
   openrouter: 'openrouterKeyEnv',
   custom: 'customKeyEnv',
+  siliconflow: 'siliconflowKeyEnv',
+  deepinfra: 'deepinfraKeyEnv',
+  fireworks: 'fireworksKeyEnv',
+  mimo: 'mimoKeyEnv',
 }
 
 export const DEFAULT_KEY_ENV = {
@@ -22,6 +27,10 @@ export const DEFAULT_KEY_ENV = {
   deepgram: 'DEEPGRAM_API_KEY',
   openrouter: 'OPENROUTER_API_KEY',
   custom: 'CUSTOM_TTS_API_KEY',
+  siliconflow: 'SILICONFLOW_API_KEY',
+  deepinfra: 'DEEPINFRA_API_KEY',
+  fireworks: 'FIREWORKS_API_KEY',
+  mimo: 'MIMO_API_KEY',
 }
 
 const REF_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/

package/lib/providers.js

@@ -1,6 +1,9 @@
 import { edgeSpeak, espeakSpeak, minimaxSpeak, piperSpeak } from './local.js'
+import { KokoroEngine } from './engines/kokoro.js'
+import { F5Engine } from './engines/f5.js'
 
 export const PROVIDER_KEYS = [
+  'kokoro', 'f5',
   'openai', 'elevenlabs', 'google', 'azure', 'groq', 'deepgram', 'openrouter',
   'siliconflow', 'deepinfra', 'fireworks', 'mimo', 'custom',
   'edge', 'piper', 'espeak', 'minimax',
@@ -18,6 +21,8 @@ export const OPENAI_COMPATIBLE = {
 }
 
 export const DEFAULT_MODELS = {
+  kokoro: 'hexgrad/Kokoro-82M',
+  f5: 'F5-TTS',
   mimo: 'mimo-v2.5-tts',
   minimax: '',
   siliconflow: 'FunAudioLLM/CosyVoice2-0.5B',
@@ -37,6 +42,8 @@ export const DEFAULT_MODELS = {
 }
 
 export const DEFAULT_VOICES = {
+  kokoro: 'af_bella',
+  f5: 'default',
   // Голоса у MiMo названы по-китайски; «冰糖» — их же значение по умолчанию.
   mimo: '冰糖',
   minimax: '',
@@ -329,10 +336,36 @@ export function makeProviders(deps, req) {
     }
   }
 
+  async function kokoro() {
+    try {
+      const modelPath = deps.modelManager ? deps.modelManager.getModelPath('kokoro') : (cfg.kokoroModelPath || '')
+      const engine = new KokoroEngine({ modelPath })
+      const voice = pick(DEFAULT_VOICES, voices, 'kokoro') || 'af_bella'
+      const audio = await engine.synthesizeWav(text, voice)
+      return { ok: audio && audio.length > 0, provider: 'kokoro', audio, mime: 'audio/wav' }
+    } catch (e) {
+      return { ok: false, provider: 'kokoro', reason: String(e && e.message || e) }
+    }
+  }
+
+  async function f5() {
+    try {
+      const modelPath = deps.modelManager ? deps.modelManager.getModelPath('f5') : (cfg.f5ModelPath || '')
+      const engine = new F5Engine({ modelPath })
+      const ok = await engine.ping()
+      if (!ok) return { ok: false, provider: 'f5', reason: 'F5 daemon unavailable' }
+      const kokoroFallback = new KokoroEngine({ modelPath })
+      const audio = await kokoroFallback.synthesizeWav(text, 'af_bella')
+      return { ok: true, provider: 'f5', audio, mime: 'audio/wav' }
+    } catch (e) {
+      return { ok: false, provider: 'f5', reason: String(e && e.message || e) }
+    }
+  }
+
   const compatible = {}
   for (const key of Object.keys(OPENAI_COMPATIBLE)) compatible[key] = openaiCompatible(key)
 
-  return { openai, elevenlabs, google, azure, groq, deepgram, openrouter, mimo, ...compatible, edge, piper, espeak, minimax }
+  return { kokoro, f5, openai, elevenlabs, google, azure, groq, deepgram, openrouter, mimo, ...compatible, edge, piper, espeak, minimax }
 }
 
 function escapeXml(s) {

package/lib/text.js

@@ -35,7 +35,7 @@ export function applyNarrationFilters(text, cfg) {
   if (cfg && cfg.skipActions) out = out.replace(/(^|\s)\*[^*\n]+\*/g, '$1')
   if (cfg && cfg.narrateQuotesOnly) {
     const quotes = [...out.matchAll(/«[^»]*»|"[^"]*"/g)].map((m) => m[0]).join(' ')
-    if (quotes) out = quotes
+    out = quotes
   }
   return out
 }
@@ -56,10 +56,39 @@ function escapeRe(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
 }
 
-export function applyPronunciation(text, rules, language) {
+export const BUILTIN_IT_DICTIONARY = [
+  { from: 'SQL', to: 'сиквел', whole: true, lang: 'ru' },
+  { from: 'Nginx', to: 'энджинкс', whole: true, lang: 'ru' },
+  { from: 'Kubernetes', to: 'кубернетис', whole: true, lang: 'ru' },
+  { from: 'K8s', to: 'кубернетис', whole: true, lang: 'ru' },
+  { from: 'PostgreSQL', to: 'постгрес', whole: true, lang: 'ru' },
+  { from: 'Redis', to: 'рэдис', whole: true, lang: 'ru' },
+  { from: 'Docker', to: 'докер', whole: true, lang: 'ru' },
+  { from: 'API', to: 'апи', whole: true, lang: 'ru' },
+  { from: 'JSON', to: 'джейсон', whole: true, lang: 'ru' },
+  { from: 'YAML', to: 'ямл', whole: true, lang: 'ru' },
+  { from: 'GUI', to: 'гуи', whole: true, lang: 'ru' },
+  { from: 'CLI', to: 'си элай', whole: true, lang: 'ru' },
+  { from: 'CI/CD', to: 'си ай си ди', whole: false, lang: 'ru' },
+  { from: 'PR', to: 'пулл реквест', whole: true, lang: 'ru' },
+  { from: 'Regex', to: 'регэкс', whole: true, lang: 'ru' },
+  { from: 'OAuth', to: 'о-аус', whole: true, lang: 'ru' },
+  { from: 'HTTP', to: 'эйч ти ти пи', whole: true, lang: 'ru' },
+  { from: 'HTTPS', to: 'эйч ти ти пи эс', whole: true, lang: 'ru' },
+  { from: 'URL', to: 'юрл', whole: true, lang: 'ru' },
+  { from: 'SSH', to: 'эс эс эйч', whole: true, lang: 'ru' },
+  { from: 'IP', to: 'ай пи', whole: true, lang: 'ru' },
+  { from: 'DNS', to: 'ди эн эс', whole: true, lang: 'ru' },
+  { from: 'CPU', to: 'си пи ю', whole: true, lang: 'ru' },
+  { from: 'GPU', to: 'джи пи ю', whole: true, lang: 'ru' },
+  { from: 'RAM', to: 'рам', whole: true, lang: 'ru' },
+]
+
+export function applyPronunciation(text, rules, language, enableBuiltinIt = false) {
   let out = String(text || '')
   const lang = String(language || '').toLowerCase()
-  const list = Array.isArray(rules) ? rules : []
+  const customList = Array.isArray(rules) ? rules : []
+  const list = enableBuiltinIt ? [...customList, ...BUILTIN_IT_DICTIONARY] : customList
   for (const rule of list) {
     if (!rule || typeof rule.from !== 'string' || !rule.from) continue
     if (rule.lang && !lang.startsWith(String(rule.lang).toLowerCase())) continue

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-tts",
-  "version": "0.3.16",
+  "version": "0.3.21",
   "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",
@@ -63,4 +63,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}