@goodandready/dsh-tts 0.3.16 → 0.3.20

package/lib/engines/manager.js

@@ -0,0 +1,235 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+
+export const MODEL_SPECS = {
+  kokoro: {
+    id: 'kokoro',
+    name: 'Kokoro-82M (CPU)',
+    approxMb: 350,
+    requiresGpu: false,
+    files: [
+      {
+        name: 'kokoro-v0_19.onnx',
+        url: 'https://huggingface.co/hexgrad/Kokoro-82M/resolve/main/kokoro-v0_19.onnx',
+      },
+      {
+        name: 'voices.json',
+        url: 'https://huggingface.co/hexgrad/Kokoro-82M/resolve/main/voices.json',
+      },
+    ],
+  },
+  f5: {
+    id: 'f5',
+    name: 'F5-TTS (GPU)',
+    approxMb: 2100,
+    requiresGpu: true,
+    files: [
+      {
+        name: 'model_1200000.safetensors',
+        url: 'https://huggingface.co/SWivid/F5-TTS/resolve/main/F5TTS_Base/model_1200000.safetensors',
+      },
+    ],
+  },
+}
+
+export function createModelManager({ root = process.env.DSH_HOME || path.join(os.homedir(), '.dsh'), fetchImpl = fetch } = {}) {
+  const baseDir = path.join(String(root), 'data', 'dsh-tts', 'models')
+  const activeDownloads = new Map()
+
+  function getModelPath(engineId) {
+    return path.join(baseDir, engineId)
+  }
+
+  async function checkFileExists(filePath) {
+    try {
+      const st = await fs.promises.stat(filePath)
+      return st.isFile() && st.size > 0
+    } catch {
+      return false
+    }
+  }
+
+  async function getDirSize(dirPath) {
+    try {
+      let total = 0
+      const entries = await fs.promises.readdir(dirPath, { withFileTypes: true })
+      for (const entry of entries) {
+        const full = path.join(dirPath, entry.name)
+        if (entry.isFile()) {
+          const st = await fs.promises.stat(full)
+          total += st.size
+        }
+      }
+      return total
+    } catch {
+      return 0
+    }
+  }
+
+  async function getStatus(engineId) {
+    const spec = MODEL_SPECS[engineId]
+    if (!spec) {
+      return { id: engineId, installed: false, error: 'unknown engine' }
+    }
+
+    const dir = getModelPath(engineId)
+    const active = activeDownloads.get(engineId)
+
+    if (active) {
+      return {
+        id: engineId,
+        name: spec.name,
+        approxMb: spec.approxMb,
+        requiresGpu: spec.requiresGpu,
+        installed: false,
+        downloading: true,
+        progress: active.progress || 0,
+        downloadedBytes: active.downloadedBytes || 0,
+        totalBytes: active.totalBytes || 0,
+        path: dir,
+      }
+    }
+
+    let allFilesExist = true
+    for (const f of spec.files) {
+      const p = path.join(dir, f.name)
+      if (!(await checkFileExists(p))) {
+        allFilesExist = false
+        break
+      }
+    }
+
+    const sizeBytes = allFilesExist ? await getDirSize(dir) : 0
+
+    return {
+      id: engineId,
+      name: spec.name,
+      approxMb: spec.approxMb,
+      requiresGpu: spec.requiresGpu,
+      installed: allFilesExist,
+      downloading: false,
+      progress: allFilesExist ? 100 : 0,
+      sizeBytes,
+      path: dir,
+    }
+  }
+
+  async function listStatus() {
+    const out = {}
+    for (const id of Object.keys(MODEL_SPECS)) {
+      out[id] = await getStatus(id)
+    }
+    return out
+  }
+
+  async function installModel(engineId, options = {}) {
+    const spec = MODEL_SPECS[engineId]
+    if (!spec) throw new Error(`Unknown engine: ${engineId}`)
+
+    if (activeDownloads.has(engineId)) {
+      throw new Error(`Download already in progress for ${engineId}`)
+    }
+
+    const customFetch = options.fetchImpl || fetchImpl
+    const dir = getModelPath(engineId)
+    await fs.promises.mkdir(dir, { recursive: true })
+
+    const controller = new AbortController()
+    const downloadState = {
+      progress: 0,
+      downloadedBytes: 0,
+      totalBytes: spec.approxMb * 1024 * 1024,
+      controller,
+    }
+    activeDownloads.set(engineId, downloadState)
+
+    try {
+      for (const f of spec.files) {
+        if (options.signal?.aborted || controller.signal.aborted) {
+          throw new Error('Download aborted')
+        }
+
+        const targetFile = path.join(dir, f.name)
+        const tmpFile = path.join(dir, `${f.name}.tmp`)
+
+        const res = await customFetch(f.url, { signal: controller.signal })
+        if (!res.ok) {
+          throw new Error(`Failed to download ${f.name}: HTTP ${res.status}`)
+        }
+
+        const contentLength = Number(res.headers?.get?.('content-length') || 0)
+        if (contentLength > 0) {
+          downloadState.totalBytes = contentLength
+        }
+
+        if (res.body && typeof res.body.getReader === 'function') {
+          const reader = res.body.getReader()
+          const chunks = []
+          let loaded = 0
+
+          while (true) {
+            const { done, value } = await reader.read()
+            if (done) break
+            chunks.push(value)
+            loaded += value.length
+            downloadState.downloadedBytes = loaded
+            downloadState.progress = Math.min(100, Math.round((loaded / (downloadState.totalBytes || 1)) * 100))
+            if (typeof options.onProgress === 'function') {
+              options.onProgress(downloadState)
+            }
+          }
+          await fs.promises.writeFile(tmpFile, Buffer.concat(chunks))
+        } else if (res.arrayBuffer) {
+          const buf = Buffer.from(await res.arrayBuffer())
+          downloadState.downloadedBytes = buf.length
+          downloadState.progress = 100
+          await fs.promises.writeFile(tmpFile, buf)
+        } else if (typeof res.text === 'function') {
+          const txt = await res.text()
+          await fs.promises.writeFile(tmpFile, Buffer.from(txt, 'utf8'))
+        }
+
+        await fs.promises.rename(tmpFile, targetFile)
+      }
+
+      activeDownloads.delete(engineId)
+      return await getStatus(engineId)
+    } catch (err) {
+      // Clean up tmp files
+      for (const f of spec.files) {
+        const tmpFile = path.join(dir, `${f.name}.tmp`)
+        await fs.promises.rm(tmpFile, { force: true }).catch(() => {})
+      }
+      throw err
+    } finally {
+      activeDownloads.delete(engineId)
+    }
+  }
+
+  async function cancelDownload(engineId) {
+    const active = activeDownloads.get(engineId)
+    if (active && active.controller) {
+      active.controller.abort()
+      activeDownloads.delete(engineId)
+      return true
+    }
+    return false
+  }
+
+  async function deleteModel(engineId) {
+    await cancelDownload(engineId)
+    const dir = getModelPath(engineId)
+    await fs.promises.rm(dir, { recursive: true, force: true }).catch(() => {})
+    return await getStatus(engineId)
+  }
+
+  return {
+    getModelPath,
+    getStatus,
+    listStatus,
+    installModel,
+    cancelDownload,
+    deleteModel,
+  }
+}

package/lib/engines/types.js

@@ -1,4 +1,49 @@
+import { execSync } from 'node:child_process'
+
+export function detectGPU() {
+  try {
+    const out = execSync('nvidia-smi --query-gpu=name --format=csv,noheader', {
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: 2000,
+      encoding: 'utf8',
+    })
+    return !!(out && out.trim())
+  } catch {
+    return false
+  }
+}
+
 export class EngineRegistry {
-  constructor({gpu, installed}) { this.gpu=gpu; this.installed=installed }
-  list(){ return this.installed.map(id=>({id, supports:()=>true})) }
+  constructor({ gpu, installed, manager } = {}) {
+    this.gpu = typeof gpu === 'boolean' ? gpu : detectGPU()
+    this.installed = Array.isArray(installed) ? installed : []
+    this.manager = manager || null
+  }
+
+  isInstalled(engineId) {
+    return this.installed.includes(engineId)
+  }
+
+  list() {
+    const list = []
+    // Kokoro works on CPU everywhere
+    if (this.installed.includes('kokoro')) {
+      list.push({
+        id: 'kokoro',
+        name: 'Kokoro-82M',
+        type: 'local-cpu',
+        supports: (lang) => !lang || ['en', 'ru', 'ja', 'zh'].includes(String(lang).slice(0, 2).toLowerCase()),
+      })
+    }
+    // F5-TTS requires GPU
+    if (this.gpu && this.installed.includes('f5')) {
+      list.push({
+        id: 'f5',
+        name: 'F5-TTS',
+        type: 'local-gpu',
+        supports: () => true,
+      })
+    }
+    return list
+  }
 }

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,
+    )
   }
 
   // Пересказ быстрой моделью. Любая неудача — пустая строка, вызывающая
@@ -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,
@@ -430,6 +466,9 @@ export function apply(ctx, config) {
     pending.push(item)
     const max = live().maxQueue || 8
     while (pending.length > max) pending.shift()
+    if (live().streamingEnabled && item.kind === 'chime') {
+      broadcastStream('chime', item)
+    }
   }
 
   // Место в очереди занимается до синтеза, чтобы порядок фраз совпадал с
@@ -442,6 +481,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 +507,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 +535,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 +565,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 +580,155 @@ 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(() => 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 rootExt = path.resolve('B:/Project/DEV/dhsplugins/dsh-voice')
+          if (fs.existsSync(rootDev) || fs.existsSync(rootExt)) {
+            voiceInstalled = true
+          }
+        } catch {}
+      }
+
+      if (!messengerInstalled) {
+        try {
+          const rootDev = path.join(process.cwd(), '..', 'dsh-messenger-gateway')
+          const rootExt = path.resolve('B:/Project/DEV/dhsplugins/dsh-messenger-gateway')
+          if (fs.existsSync(rootDev) || fs.existsSync(rootExt)) {
+            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',

package/lib/text.js

@@ -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.20",
   "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",
@@ -47,8 +47,8 @@
     "client": {
       "platform": "web",
       "inject": [
-        "@deepseek-ai/dsh-client-locale",
-        "@deepseek-ai/dsh-client-connection"
+        "@deepseek-ai/dsh-client-runtime",
+        "@deepseek-ai/dsh-client-ui-slots"
       ]
     }
   },
@@ -63,4 +63,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}