@goodandready/dsh-voice 0.8.4 → 0.8.5

package/lib/client.js

@@ -83,6 +83,20 @@ window.__ModuleLoader__.load({
       'speaking': 'You are speaking…',
       'silence': 'Pause…',
       'normalizeTranscript': 'Normalize file transcripts',
+      'undo': 'Undo last insert',
+      'undone': 'Insert undone',
+      'nothingToUndo': 'Nothing to undo',
+      'beep': 'Beep on start/stop',
+      'localOnly': 'Local whisper only',
+      'localOnlyHint': 'Restrict both chains to the local whisper.cpp server: fully offline.',
+      'sendDelay': 'Dictation send delay (ms)',
+      'sendDelayHint': 'Wait before appending a dictated phrase, with a cancel window. 0 = off',
+      'mic': 'Microphone',
+      'micDefault': 'System default',
+      'vocabulary': 'Custom vocabulary (one word per line)',
+      'polish': 'Polish transcript with model',
+      'polishHint': 'Fix punctuation and fillers via the harness model before inserting',
+      'voiceCommandsLabel': 'Voice edit commands ("new line", "paragraph")',
       'normalizeTranscriptHint': 'transcribe_audio: spoken numbers to digits, tidy punctuation',
       'messageTitle': 'Voice message',
       'messageHint': 'One whole recording, sent to the agent once it is transcribed.',
@@ -162,6 +176,20 @@ window.__ModuleLoader__.load({
       'speaking': 'Вы говорите…',
       'silence': 'Пауза…',
       'normalizeTranscript': 'Нормализация расшифровок',
+      'undo': 'Отменить вставку',
+      'undone': 'Вставка отменена',
+      'nothingToUndo': 'Отменять нечего',
+      'beep': 'Звук старта/стопа',
+      'localOnly': 'Только локальный whisper',
+      'localOnlyHint': 'Обе цепочки — только локальный сервер whisper.cpp: полностью офлайн.',
+      'sendDelay': 'Задержка вставки диктовки (мс)',
+      'sendDelayHint': 'Пауза перед вставкой фразы с окном отмены. 0 — выкл',
+      'mic': 'Микрофон',
+      'micDefault': 'Системной по умолчанию',
+      'vocabulary': 'Свой словарь (одно слово в строке)',
+      'polish': 'Полировка текста моделью',
+      'polishHint': 'Пунктуация и слова-паразиты через модель харнесса перед вставкой',
+      'voiceCommandsLabel': 'Голосовые команды («с новой строки», «абзац»)',
       'normalizeTranscriptHint': 'transcribe_audio: числа словами — в цифры, аккуратная пунктуация',
       'messageTitle': 'Голосовое сообщение',
       'messageHint': 'Одна запись целиком, после распознавания уходит агенту.',
@@ -292,16 +320,56 @@ window.__ModuleLoader__.load({
       return s
     }
 
+    // Голосовые команды редактирования (#37): «с новой строки» -> \n и т.п.
+    // Применяются до нормализации, только когда включены в настройках.
+    const VOICE_COMMANDS = [
+      [/(^|[\s,.!?])с новой строки([\s,.!?]|$)/gi, '$1\n$2'],
+      [/(^|[\s,.!?])новая строка([\s,.!?]|$)/gi, '$1\n$2'],
+      [/(^|[\s,.!?])абзац([\s,.!?]|$)/gi, '$1\n\n$2'],
+      [/(^|\s)тире(\s|$)/gi, '$1—$2'],
+    ]
+
+    function applyVoiceCommands(text) {
+      let s = text
+      for (const [re, to] of VOICE_COMMANDS) s = s.replace(re, to)
+      return s.replace(/[ \t]+/g, ' ').trim()
+    }
+
+    // История вставок для undo (#29-9). Хранится только в браузере.
+    const insertHistory = []
+
+    async function undoLastInsert() {
+      const last = insertHistory.pop()
+      if (!last) return t('nothingToUndo')
+      const actions = voice.inputActions
+      if (!actions || typeof actions.setDraft !== 'function') return t('composerUnavailable')
+      const draft = voice.input && typeof voice.input.draft === 'string' ? voice.input.draft : ''
+      if (draft === last.after) actions.setDraft(last.before)
+      else {
+        // Текст уже менялся руками — вырезаем последнюю вставку как подстроку.
+        const i = draft.lastIndexOf(last.added)
+        if (i < 0) { insertHistory.push(last); return t('nothingToUndo') }
+        actions.setDraft((draft.slice(0, i) + draft.slice(i + last.added.length)).replace(/\s+$/, ''))
+      }
+      return t('undone')
+    }
+
     function appendDraft(text) {
       const actions = voice.inputActions
       if (!actions || typeof actions.setDraft !== 'function') {
         voice.set({ phase: 'error', error: t('composerUnavailable') })
         return
       }
-      const clean = tidyPhrase(text)
+      let clean = voice.settings.voiceCommands ? applyVoiceCommands(text) : tidyPhrase(text)
       if (!clean) return
       const draft = voice.input && typeof voice.input.draft === 'string' ? voice.input.draft : ''
+      const before = draft
       actions.setDraft(draft ? draft + ' ' + clean : clean)
+      const limit = Number(voice.settings.historyLimit)
+      if (limit > 0) {
+        insertHistory.push({ before, added: draft ? ' ' + clean : clean, after: draft ? draft + ' ' + clean : clean })
+        while (insertHistory.length > limit) insertHistory.shift()
+      }
     }
 
     // Как клавиша называется на человеческом языке.
@@ -335,6 +403,26 @@ window.__ModuleLoader__.load({
       try {
         window.dispatchEvent(new CustomEvent('dsh-voice:speaking', { detail: { phase } }))
       } catch (noEvents) { /* окна нет — значит и слушать некому */ }
+      if (voice.settings.beep) playBeep(phase === 'start' ? 880 : 660)
+    }
+
+    // Короткий пик через WebAudio: слышно без взгляда на экран (#29-6).
+    function playBeep(freq) {
+      try {
+        const AC = typeof AudioContext !== 'undefined' ? AudioContext
+          : (typeof webkitAudioContext !== 'undefined' ? webkitAudioContext : null)
+        if (!AC) return
+        const ac = new AC()
+        const osc = ac.createOscillator()
+        const gain = ac.createGain()
+        osc.frequency.value = freq
+        osc.type = 'sine'
+        gain.gain.setValueAtTime(0.12, ac.currentTime)
+        gain.gain.exponentialRampToValueAtTime(0.001, ac.currentTime + 0.09)
+        osc.connect(gain); gain.connect(ac.destination)
+        osc.start(); osc.stop(ac.currentTime + 0.1)
+        osc.onended = () => { try { ac.close() } catch (e) { /* уже закрыт */ } }
+      } catch (noAudio) { /* без звука — не критично */ }
     }
 
     // ------------------------------------------------- распознавание в браузере
@@ -434,9 +522,9 @@ window.__ModuleLoader__.load({
         throw new Error(t('micUnavailable'))
       }
       if (typeof MediaRecorder === 'undefined') throw new Error(t('noRecorder'))
-      const stream = await navigator.mediaDevices.getUserMedia({
-        audio: { channelCount: 1, echoCancellation: true, noiseSuppression: true },
-      })
+      const audio = { channelCount: 1, echoCancellation: true, noiseSuppression: true }
+      if (voice.settings.micDeviceId) audio.deviceId = { exact: voice.settings.micDeviceId }
+      const stream = await navigator.mediaDevices.getUserMedia({ audio })
       let mimeType = 'audio/webm;codecs=opus'
       if (!MediaRecorder.isTypeSupported(mimeType)) mimeType = ''
       const recorder = mimeType ? new MediaRecorder(stream, { mimeType }) : new MediaRecorder(stream)
@@ -492,6 +580,14 @@ window.__ModuleLoader__.load({
         if (blob.size < 1200) return       // слишком короткий кусок — это не речь
         try {
           const text = await sendAudio(blob, rec.mime, 'dictation')
+          const delay = Number(voice.settings.sendDelayMs) || 0
+          if (text && delay > 0 && !voice.holding) {
+            // Отложенная вставка с окном отмены (#29-5): текст уже вставлен,
+            // окно позволяет его отменить.
+            appendDraft(text)
+            voice.set({ phase: 'pending', pending: { text, undoOnly: true, leftMs: delay } })
+            return
+          }
           if (text) appendDraft(text)
         } catch (e) {
           voice.set({ error: String(e && e.message ? e.message : e) })
@@ -779,6 +875,14 @@ window.__ModuleLoader__.load({
         const dispose = ctx.interval(() => {
           const p = voice.pending
           if (!p) return
+          if (p.undoOnly) {
+            // Режим «только отмена вставки» (#29-5): по истечении окна просто
+            // прячем панель; текст либо остался, либо уже откатили руками.
+            p.leftMs -= tick
+            if (p.leftMs <= 0) voice.set({ phase: 'idle' })
+            else voice.notify()
+            return
+          }
           p.leftMs -= tick
           if (p.leftMs <= 0) { submitPending(); return }
           voice.notify()
@@ -819,6 +923,19 @@ window.__ModuleLoader__.load({
 
       if (v.phase === 'pending') {
         const left = Math.max(0, Math.ceil((voice.pending ? voice.pending.leftMs : 0) / 1000))
+        if (voice.pending && voice.pending.undoOnly) {
+          // Окно отмены отложенной вставки диктовки (#29-5).
+          return React.createElement('div', { className: 'dvo-pill' },
+            React.createElement('span', { className: 'dvo-status' }, t('undo'), ': ', left, t('secondsShort')),
+            React.createElement('button', {
+              type: 'button', className: 'dvo-pbtn', title: t('undo'),
+              onClick: async () => {
+                const msg = await undoLastInsert()
+                voice.set({ phase: 'idle', error: msg === t('undone') ? '' : msg })
+              },
+            }, xIcon()),
+          )
+        }
         return React.createElement('div', { className: 'dvo-pill' },
           React.createElement('span', { className: 'dvo-status' }, t('sendingIn')),
           React.createElement('span', { className: 'dvo-count' }, left + t('secondsShort')),
@@ -849,6 +966,14 @@ window.__ModuleLoader__.load({
               dispose = () => {}
               const key = data && data.hotkey
               if (key) dispose = installHotkey(ctx, key, 'message')
+              // Новые настройки композеру нужны без открытия карточки.
+              Object.assign(voice.settings, {
+                beep: !!(data && data.beep),
+                micDeviceId: String((data && data.micDeviceId) || ''),
+                historyLimit: Number(data && data.historyLimit),
+                voiceCommands: !!(data && data.voiceCommands),
+                sendDelayMs: Number(data && data.modes && data.modes.dictation && data.modes.dictation.sendDelayMs) || 0,
+              })
             })
             .catch(() => { /* без подсказки хоста клавиши просто не будет */ })
         }
@@ -1094,11 +1219,16 @@ window.__ModuleLoader__.load({
       // Клиент должен знать порог VAD и окно отмены — они живут в тех же настройках.
       React.useEffect(() => {
         if (!ready) return
-        voice.settings = {
+        voice.settings = Object.assign({}, voice.settings, {
           vadSilenceMs: Number(value && value.dictation && value.dictation.vadSilenceMs) || 700,
           autoSendMs: Number(value && value.message && value.message.autoSendMs) || 4000,
-        }
-      }, [ready, value])
+          beep: !!(snap && snap.beep),
+          micDeviceId: String((snap && snap.micDeviceId) || ''),
+          historyLimit: Number(snap && snap.historyLimit),
+          voiceCommands: !!(snap && snap.voiceCommands),
+          sendDelayMs: Number(value && value.dictation && value.dictation.sendDelayMs) || 0,
+        })
+      }, [ready, value, snap])
 
       if (!ready) {
         const waiting = !snap || snap.status === 'loading'
@@ -1136,10 +1266,15 @@ window.__ModuleLoader__.load({
           }
         }
 
-        voice.settings = {
+        Object.assign(voice.settings, {
           vadSilenceMs: Number(draft.dictation && draft.dictation.vadSilenceMs) || 700,
           autoSendMs: Number(draft.message && draft.message.autoSendMs) || 4000,
-        }
+          beep: !!draft.beep,
+          micDeviceId: String(draft.micDeviceId || ''),
+          historyLimit: Number(draft.historyLimit),
+          voiceCommands: !!draft.voiceCommands,
+          sendDelayMs: Number(draft.dictation && draft.dictation.sendDelayMs) || 0,
+        })
         // Композер держит обработчик клавиши: пусть перечитает настройку,
         // иначе новая клавиша заработает только после перезагрузки страницы.
         try { window.dispatchEvent(new CustomEvent('dsh-voice:settings-saved')) } catch (noEvents) { /* некому */ }
@@ -1177,6 +1312,26 @@ window.__ModuleLoader__.load({
           t('hotkeyHint1')
           + t('hotkeyHint2')))
 
+      const micField = () => {
+        const devices = React.useState([])[0]
+        const setDevices = React.useState([])[1]
+        React.useEffect(() => {
+          if (!navigator.mediaDevices || !navigator.mediaDevices.enumerateDevices) return
+          navigator.mediaDevices.enumerateDevices()
+            .then((list) => setDevices(list.filter((d) => d.kind === 'audioinput')))
+            .catch(() => {})
+        }, [])
+        return React.createElement('label', { className: 'dvs-field' }, t('mic'),
+          React.createElement('select', {
+            value: String((snap && snap.micDeviceId) || ''), disabled: !writable,
+            onChange: (e) => setTop('micDeviceId', e.target.value),
+          },
+            React.createElement('option', { value: '' }, t('micDefault')),
+            devices.map((d) => React.createElement('option', { key: d.deviceId, value: d.deviceId },
+              d.label || d.deviceId.slice(0, 12)))),
+        )
+      }
+
       const langField = (mode) => React.createElement('label', { className: 'dvs-field' }, t('language'),
         React.createElement('select', {
           value: modeVal(mode, 'language', 'ru'), disabled: !writable,
@@ -1208,6 +1363,13 @@ window.__ModuleLoader__.load({
           }),
           langField('dictation'),
           numField('dictation', 'vadSilenceMs', t('pauseMs'), t('pauseHint')),
+          numField('dictation', 'sendDelayMs', t('sendDelay'), t('sendDelayHint')),
+          React.createElement('label', { className: 'dvs-field' }, t('polish'),
+            React.createElement('input', {
+              type: 'checkbox', checked: !!(draft && draft.dictation && draft.dictation.polish), disabled: !writable,
+              onChange: (e) => setIn('dictation', 'polish', e.target.checked),
+            })),
+          React.createElement('div', { className: 'dvs-sub' }, t('polishHint')),
         ),
         React.createElement('div', { className: 'dvs-block' },
           React.createElement('div', { className: 'dvs-h' }, t('messageTitle')),
@@ -1219,6 +1381,11 @@ window.__ModuleLoader__.load({
           }),
           langField('message'),
           numField('message', 'autoSendMs', t('undoMs'), t('undoHint')),
+          React.createElement('label', { className: 'dvs-field' }, t('polish'),
+            React.createElement('input', {
+              type: 'checkbox', checked: !!(draft && draft.message && draft.message.polish), disabled: !writable,
+              onChange: (e) => setIn('message', 'polish', e.target.checked),
+            })),
         ),
         React.createElement('div', { className: 'dvs-block' },
           React.createElement('div', { className: 'dvs-h' }, t('customTitle')),
@@ -1246,6 +1413,28 @@ window.__ModuleLoader__.load({
               type: 'checkbox', checked: !!(draft && draft.normalizeTranscript), disabled: !writable,
               onChange: (e) => setTop('normalizeTranscript', e.target.checked),
             })),
+          React.createElement('label', { className: 'dvs-field' }, t('beep'),
+            React.createElement('input', {
+              type: 'checkbox', checked: !!(draft && draft.beep), disabled: !writable,
+              onChange: (e) => setTop('beep', e.target.checked),
+            })),
+          React.createElement('label', { className: 'dvs-field', title: t('localOnlyHint') }, t('localOnly'),
+            React.createElement('input', {
+              type: 'checkbox', checked: !!(draft && draft.localOnly), disabled: !writable,
+              onChange: (e) => setTop('localOnly', e.target.checked),
+            })),
+          React.createElement('label', { className: 'dvs-field' }, t('voiceCommandsLabel'),
+            React.createElement('input', {
+              type: 'checkbox', checked: !!(draft && draft.voiceCommands), disabled: !writable,
+              onChange: (e) => setTop('voiceCommands', e.target.checked),
+            })),
+          micField(),
+          React.createElement('label', { className: 'dvs-field' }, t('vocabulary'),
+            React.createElement('textarea', {
+              rows: 3, disabled: !writable,
+              value: Array.isArray(draft && draft.vocabulary) ? draft.vocabulary.join('\n') : '',
+              onChange: (e) => setTop('vocabulary', e.target.value.split('\n').map((x) => x.trim()).filter(Boolean)),
+            })),
         ),
         React.createElement('div', { className: 'dvs-row' },
           React.createElement('button', { type: 'button', className: 'dvs-save', disabled: !writable, onClick: save }, t('save')),

package/lib/index.js

@@ -27,7 +27,7 @@ function isAutoLang(lang) {
 }
 
 export const name = 'dsh-voice'
-export const inject = ['tools', 'credentials', 'webServer', 'shell', 'settings']
+export const inject = ['tools', 'credentials', 'webServer', 'shell', 'settings', 'llm']
 
 const ChainEntry = z.object({
   provider: z.string().default('local-whisper')
@@ -65,6 +65,10 @@ export const Config = z.object({
     language: z.string().default('ru'),
     vadSilenceMs: z.number().default(700)
       .description('Silence longer than this ends a phrase and sends the chunk.'),
+    sendDelayMs: z.number().default(0)
+      .description('Dictation: wait this many ms after a phrase before appending it, with a cancel window. 0 disables the delay.'),
+    polish: z.boolean().default(false)
+      .description('Polish the transcript through the harness model before inserting: punctuation, paragraphs, filler-word removal.'),
   }).default({}),
   message: z.object({
     chain: z.array(ChainEntry)
@@ -98,6 +102,18 @@ export const Config = z.object({
   maxFileBytes: z.number().default(25 * 1024 * 1024),
   normalizeTranscript: z.boolean().default(false)
     .description('transcribe_audio: convert spoken numbers to digits and tidy punctuation.'),
+  beep: z.boolean().default(false)
+    .description('Play a short beep when recording starts and stops.'),
+  localOnly: z.boolean().default(false)
+    .description('Restrict both chains to local-whisper only: fully offline, no cloud providers.'),
+  micDeviceId: z.string().default('')
+    .description('Microphone device id for recording. Empty means the system default.'),
+  historyLimit: z.number().default(20)
+    .description('How many recent dictation inserts to keep for undo in the browser. 0 disables history.'),
+  vocabulary: z.array(z.string()).default([])
+    .description('Custom words (names, terms) hinted to providers so they recognize them correctly.'),
+  voiceCommands: z.boolean().default(false)
+    .description('During dictation, spoken edit commands ("new line", "paragraph") become real line breaks instead of words.'),
 })
 
 const MIME_BY_EXT = {
@@ -190,24 +206,51 @@ export function apply(ctx, baseConfig) {
   async function transcribe(modeCfg, bytes, mime, signal) {
     const cfg = live()
     const customKeys = (Array.isArray(cfg.customProviders) ? cfg.customProviders : [])
-      .map((c) => String(c && c.key || '').trim())
-      .filter(Boolean)
+      .map((c) => String(c && c.key || '').trim()).filter(Boolean)
+    // Режим «только локальный whisper»: цепочка обрезается до него.
+    const chain = cfg.localOnly
+      ? (modeCfg.chain || []).filter((e) => e.provider === 'local-whisper')
+      : (modeCfg.chain || [])
     const models = {}
     const order = []
-    for (const entry of Array.isArray(modeCfg.chain) ? modeCfg.chain : []) {
+    for (const entry of chain) {
       if (!KNOWN_KEYS.includes(entry.provider) && !customKeys.includes(entry.provider)) continue
       order.push(entry.provider)
       // Для своего провайдера модель по умолчанию живёт в его описании,
       // подставит makeProviders — здесь пусто означает «бери оттуда».
       models[entry.provider] = entry.model || DEFAULT_MODELS[entry.provider] || ''
     }
+    if (cfg.localOnly && order.length === 0) {
+      throw new Error('localOnly mode is on, but local-whisper is not in the chain')
+    }
     const providers = makeProviders(
       { resolveKey, fetchImpl: fetch, cfg, toWav: (b) => toWav16k(b, cfg.ffmpegBin) },
-      { bytes, mime, lang: modeCfg.language, signal, models },
+      { bytes, mime, lang: modeCfg.language, signal, models, vocabulary: cfg.vocabulary },
     )
     return runChain(order, providers)
   }
 
+  // Полировка транскрипта через модель харнесса (#35). Ошибка/таймаут не
+  // блокирует: возвращаем сырой текст.
+  async function polishText(text, modeCfg, signal) {
+    if (!modeCfg || modeCfg.polish !== true) return text
+    try {
+      const llm = ctx.llm
+      if (!llm || typeof llm.stream !== 'function') return text
+      const ask =
+        'Fix the punctuation and spelling of this dictated text and split it into '
+        + 'paragraphs where the speaker changes topic. Remove filler words ("um", "uh", '
+        + '"ээ", "ну", "как бы"). Keep the original language, wording and meaning. '
+        + 'Reply with the polished text only:\n\n' + text
+      let acc = ''
+      for await (const chunk of llm.stream({ messages: [{ role: 'user', content: ask }], signal })) {
+        acc += (chunk && (chunk.text || (chunk.delta && chunk.delta.text))) || ''
+      }
+      const clean = acc.trim()
+      return clean || text
+    } catch { return text }
+  }
+
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact',
     path: '/dsh-voice/status',
@@ -224,9 +267,21 @@ export function apply(ctx, baseConfig) {
             .map((c) => String(c && c.key || '').trim()).filter(Boolean),
         ),
         modes: {
-          dictation: { chain: cfg.dictation.chain, language: cfg.dictation.language, vadSilenceMs: cfg.dictation.vadSilenceMs },
-          message: { chain: cfg.message.chain, language: cfg.message.language, autoSendMs: cfg.message.autoSendMs },
+          dictation: {
+            chain: cfg.dictation.chain, language: cfg.dictation.language,
+            vadSilenceMs: cfg.dictation.vadSilenceMs,
+            sendDelayMs: cfg.dictation.sendDelayMs, polish: cfg.dictation.polish,
+          },
+          message: {
+            chain: cfg.message.chain, language: cfg.message.language,
+            autoSendMs: cfg.message.autoSendMs, polish: cfg.message.polish,
+          },
         },
+        beep: cfg.beep,
+        localOnly: cfg.localOnly,
+        micDeviceId: cfg.micDeviceId,
+        historyLimit: cfg.historyLimit,
+        voiceCommands: cfg.voiceCommands,
       })
     },
   }), 'dsh-voice: /status route')
@@ -270,7 +325,8 @@ export function apply(ctx, baseConfig) {
       const timer = setTimeout(() => controller.abort(), cfg.timeoutMs)
       try {
         const out = await transcribe(modeCfg, bytes, mime, controller.signal)
-        writeJson(res, 200, { ok: true, text: out.text, provider: out.provider, tookMs: out.tookMs })
+        const text = await polishText(out.text, modeCfg, controller.signal)
+        writeJson(res, 200, { ok: true, text, provider: out.provider, tookMs: out.tookMs })
       } catch (e) {
         writeJson(res, 502, { ok: false, error: { code: 'chain', message: String(e && e.message || e) } })
       } finally {
@@ -319,7 +375,9 @@ export function apply(ctx, baseConfig) {
         const mime = MIME_BY_EXT[path.extname(filePath).toLowerCase()] || 'audio/wav'
         const bytes = await readFile(filePath)
         const modeCfg = { ...cfg.message, language: String(args.language || cfg.message.language) }
-        const out = await transcribe(modeCfg, bytes, mime, exec.signal)
+        let raw = await transcribe(modeCfg, bytes, mime, exec.signal)
+        if (raw && raw.text) raw = { ...raw, text: await polishText(raw.text, modeCfg, exec.signal) }
+        const out = raw
         if (cfg.normalizeTranscript && out && out.text) {
           out.text = normalizePhrase(out.text, {
             digits: true, capSentences: true, commaSpacing: true, trailingPeriod: true,

package/lib/providers.js

@@ -107,6 +107,9 @@ function isAutoLang(lang) {
 export function makeProviders(deps, req) {
   const { resolveKey, fetchImpl, cfg } = deps
   const { bytes, mime, lang, signal, models } = req
+  const vocab = Array.isArray(req.vocabulary)
+    ? req.vocabulary.map((w) => String(w || '').trim()).filter(Boolean).join(', ')
+    : ''
 
   async function deepgram() {
     const key = await resolveKey(cfg.deepgramKeyEnv)
@@ -181,6 +184,7 @@ export function makeProviders(deps, req) {
     const form = new FormData()
     form.append('file', new Blob([sendBytes], { type: sendMime }), fileName(sendMime))
     if (!isAutoLang(lang)) form.append('language', lang)
+    if (vocab) form.append('prompt', vocab)
     form.append('response_format', 'json')
     const res = await fetchImpl(cfg.whisperUrl, { method: 'POST', body: form, signal })
     // whisper.cpp отвечает 400 с JSON-телом на внутренних сбоях (например, не
@@ -234,6 +238,7 @@ export function makeProviders(deps, req) {
         format = 'wav'
       }
       const ask = (spec.prompt || CHAT_AUDIO_PROMPT)
+        + (vocab ? ` Vocabulary hints (spell these correctly): ${vocab}.` : '')
         + (lang && lang !== 'auto' ? ` The audio language is ${lang}.` : '')
       const res = await fetchImpl(`${base}/chat/completions`, {
         method: 'POST',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-voice",
-  "version": "0.8.4",
+  "version": "0.8.5",
   "description": "Voice input for DeepSeek Harness: dictation chunked by pauses and voice messages, each with its own provider fallback chain (Deepgram, Groq, HuggingFace, local whisper.cpp, plus any OpenAI-compatible API of your own).",
   "license": "MIT",
   "type": "module",