@goodandready/dsh-voice 0.8.6 → 0.8.8

package/README.md

@@ -149,7 +149,12 @@ The card has four blocks:
 - **Your own providers** — an OpenAI-compatible API per card: name, template,
   base URL, model, credential name. The name becomes selectable in both chains
   as soon as it is filled in.
-- **General** — local whisper endpoint, binary, model, autostart.
+- **General** — local whisper endpoint, binary, model, autostart, beep, localOnly,
+  microphone, custom vocabulary, offline polish endpoint (`polishBaseUrl`/`polishModel`/`polishKeyEnv`).
+- **Voice message** also has `polishSend` (polish the whole draft before sending) and
+  `sessionCommands` ("send", "cancel", "stop", "continue" act on the session instead of text).
+- **Dictation** also has a wake word: browser recognition starts recording when speech
+  begins with that phrase (empty disables it).
 
 Speed matters for dictation and accuracy for messages, which is why the chains
 are separate: a sensible pair is Deepgram → Groq → local for dictation and

package/lib/client.js

@@ -101,6 +101,17 @@ window.__ModuleLoader__.load({
       'streamChunkMs': 'Stream chunk (ms)',
       'vadAdapt': 'Adaptive silence',
       'vadAdaptHint': 'Auto-tune the silence threshold to the pace of your speech. 0 = fixed',
+      'wakeWord': 'Wake word',
+      'wakeWordHint': 'Browser recognition starts recording when speech begins with this phrase. Empty = off',
+      'bargeIn': 'Barge-in',
+      'polishSend': 'Polish whole draft before sending',
+      'polishSendHint': 'Run the composed draft through the model right before sending',
+      'sessionCommands': 'Voice session commands',
+      'sessionCommandsHint': '"send", "cancel", "stop", "continue" act on the session instead of becoming text',
+      'polishBaseUrl': 'Offline polish endpoint',
+      'polishBaseUrlHint': 'OpenAI-compatible /chat/completions base URL, e.g. a local Ollama. Empty = harness model',
+      'polishModel': 'Offline polish model',
+      'polishKeyEnv': 'Offline polish key credential',
       'voiceCommandsLabel': 'Voice edit commands ("new line", "paragraph")',
       'normalizeTranscriptHint': 'transcribe_audio: spoken numbers to digits, tidy punctuation',
       'messageTitle': 'Voice message',
@@ -199,6 +210,17 @@ window.__ModuleLoader__.load({
       'streamChunkMs': 'Кусок потока (мс)',
       'vadAdapt': 'Адаптивная тишина',
       'vadAdaptHint': 'Авто-подстройка порога под темп речи. 0 = фикс. поведение',
+      'wakeWord': 'Слово-активатор',
+      'wakeWordHint': 'Распознавание в браузере начинает запись, если речь начинается с этой фразы. Пусто = выкл',
+      'bargeIn': 'Перебивание',
+      'polishSend': 'Полировка всего текста перед отправкой',
+      'polishSendHint': 'Прогнать весь текст через модель перед отправкой агенту',
+      'sessionCommands': 'Голосовые команды сессии',
+      'sessionCommandsHint': '«отправь», «отмени», «стоп», «продолжи» — действия сессии, а не текст',
+      'polishBaseUrl': 'Локальный ендпоинт полировки',
+      'polishBaseUrlHint': 'OpenAI-совместимый /chat/completions базовый URL, напр. локальный Ollama. Пусто = модель харнесса',
+      'polishModel': 'Модель офлайн-полировки',
+      'polishKeyEnv': 'Ключ офлайн-полировки',
       'voiceCommandsLabel': 'Голосовые команды («с новой строки», «абзац»)',
       'normalizeTranscriptHint': 'transcribe_audio: числа словами — в цифры, аккуратная пунктуация',
       'messageTitle': 'Голосовое сообщение',
@@ -319,7 +341,8 @@ window.__ModuleLoader__.load({
       if (!res.ok || !parsed || !parsed.ok) {
         throw new Error((parsed && parsed.error && parsed.error.message) || `HTTP ${res.status}`)
       }
-      return String(parsed.text || '').trim()
+      if (parsed.command) return { command: parsed.command, text: '' }
+      return { text: String(parsed.text || '').trim(), command: null }
     }
 
     function tidyPhrase(text) {
@@ -616,7 +639,22 @@ window.__ModuleLoader__.load({
       voice.browser = startBrowserRecognition({
         lang: language,
         continuous: true,
-        onInterim: (text) => { voice.caption = text; voice.notify() },
+        onInterim: (text) => {
+          voice.caption = text; voice.notify()
+          // Wake-word (#45): если interim начинается с ключевой фразы —
+          // обрываем прослушивание browser и уходим в обычную запись.
+          const ww = String(voice.settings.wakeWord || '').trim().toLowerCase()
+          if (ww && mode === 'dictation' && !voice.rec) {
+            const t = String(text || '').trim().toLowerCase()
+            if (t.startsWith(ww)) {
+              voice.browser = null
+              voice.caption = ''
+              openMic(mode)
+                .then((rec) => { voice.rec = rec; voice.notify() })
+                .catch((err) => voice.set({ phase: 'error', error: String(err && err.message ? err.message : err), rec: null }))
+            }
+          }
+        },
         onFinal: (text) => {
           finals.push(text)
           voice.caption = ''
@@ -773,7 +811,9 @@ window.__ModuleLoader__.load({
         if (blob.size < 1200) { voice.set({ phase: 'idle' }); return }
         voice.set({ phase: 'processing' })
         try {
-          const text = await sendAudio(blob, rec.mime, mode)
+          const out = await sendAudio(blob, rec.mime, mode)
+          if (out.command) { runSessionCommand(out.command); return }
+          const text = out.text || ''
           if (!text) { voice.set({ phase: 'error', error: t('nothingHeard') }); return }
           appendDraft(text)
           if (mode === 'message') {
@@ -791,8 +831,46 @@ window.__ModuleLoader__.load({
       voice.pending = null
       voice.set({ phase: 'idle' })
       const actions = voice.inputActions
-      if (actions && typeof actions.submit === 'function') {
-        setTimeout(() => { try { actions.submit() } catch (e) { /* композер занят */ } }, 0)
+      if (!actions || typeof actions.submit !== 'function') return
+      // Полировка всего draft перед отправкой (#46). Ошибка не блокирует.
+      if (voice.settings.polishSend) {
+        const run = async () => {
+          try {
+            const draft = voice.input && typeof voice.input.draft === 'string' ? voice.input.draft : ''
+            if (draft.trim()) {
+              const res = await fetch('/dsh-voice/polish', {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify({ text: draft }),
+              })
+              const parsed = await res.json().catch(() => null)
+              if (parsed && parsed.ok && typeof parsed.text === 'string' && parsed.text.trim()) {
+                actions.setDraft(parsed.text.trim())
+              }
+            }
+          } catch (e) { /* полировка best-effort */ }
+        }
+        run().finally(() => setTimeout(() => { try { actions.submit() } catch (e) { /* занят */ } }, 0))
+        return
+      }
+      setTimeout(() => { try { actions.submit() } catch (e) { /* композер занят */ } }, 0)
+    }
+
+    // Голосовые команды сессии (#48): чистые «отправь/отмени/стоп/продолжи».
+    function runSessionCommand(cmd) {
+      const actions = voice.inputActions
+      voice.set({ phase: 'idle', pending: null })
+      switch (cmd) {
+        case 'send':
+        case 'continue':
+          if (actions && typeof actions.submit === 'function') actions.submit()
+          break
+        case 'cancel':
+        case 'stop':
+          // Сбрасываем ожидание/запись; текст draft намеренно не трогаем.
+          break
+        default:
+          break
       }
     }
 
@@ -1010,6 +1088,10 @@ window.__ModuleLoader__.load({
                 stream: !!(data && data.modes && data.modes.dictation && data.modes.dictation.stream),
                 streamChunkMs: Number(data && data.modes && data.modes.dictation && data.modes.dictation.streamChunkMs) || 1200,
                 vadAdapt: Number(data && data.modes && data.modes.dictation && data.modes.dictation.vadAdapt) || 0,
+                wakeWord: String((data && data.wakeWord) || ''),
+                bargeIn: !!(data && data.bargeIn),
+                polishSend: !!(data && data.modes && data.modes.message && data.modes.message.polishSend),
+                sessionCommands: !!(data && data.modes && data.modes.message && data.modes.message.sessionCommands),
               })
             })
             .catch(() => { /* без подсказки хоста клавиши просто не будет */ })
@@ -1221,6 +1303,14 @@ window.__ModuleLoader__.load({
         return () => { alive = false; off() }
       }, [])
 
+      const [devices, setDevices] = React.useState([])
+      React.useEffect(() => {
+        if (!navigator.mediaDevices || !navigator.mediaDevices.enumerateDevices) return
+        navigator.mediaDevices.enumerateDevices()
+          .then((list) => setDevices(list.filter((d) => d.kind === 'audioinput')))
+          .catch(() => {})
+      }, [])
+
       // Снимок приходит со статусом, и он важнее самого значения.
       //   loading      — ответа хоста ещё нет;
       //   unavailable  — хост ответил, но наш namespace ему пока неизвестен:
@@ -1267,6 +1357,11 @@ window.__ModuleLoader__.load({
           stream: !!(value && value.dictation && value.dictation.stream),
           streamChunkMs: Number(value && value.dictation && value.dictation.streamChunkMs) || 1200,
           vadAdapt: Number(value && value.dictation && value.dictation.vadAdapt) || 0,
+          wakeWord: String((snap && snap.wakeWord) || ''),
+          bargeIn: !!(snap && snap.bargeIn),
+          polishSend: !!(value && value.message && value.message.polishSend),
+          sessionCommands: !!(value && value.message && value.message.sessionCommands),
+          polishBaseUrl: String((snap && snap.polishBaseUrl) || ''),
         })
       }, [ready, value, snap])
 
@@ -1355,26 +1450,14 @@ 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'),
+      const micField = () => 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)))),
-        )
-      }
-
+              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,
@@ -1413,6 +1496,11 @@ window.__ModuleLoader__.load({
               onChange: (e) => setIn('dictation', 'polish', e.target.checked),
             })),
           React.createElement('div', { className: 'dvs-sub' }, t('polishHint')),
+          React.createElement('label', { className: 'dvs-field', title: t('wakeWordHint') }, t('wakeWord'),
+            React.createElement('input', {
+              type: 'text', value: String((snap && snap.wakeWord) || ''), disabled: !writable,
+              onChange: (e) => setTop('wakeWord', e.target.value),
+            })),
           React.createElement('label', { className: 'dvs-field', title: t('streamHint') }, t('stream'),
             React.createElement('input', {
               type: 'checkbox', checked: !!(draft && draft.dictation && draft.dictation.stream), disabled: !writable,
@@ -1441,6 +1529,16 @@ window.__ModuleLoader__.load({
               type: 'checkbox', checked: !!(draft && draft.message && draft.message.polish), disabled: !writable,
               onChange: (e) => setIn('message', 'polish', e.target.checked),
             })),
+          React.createElement('label', { className: 'dvs-field', title: t('polishSendHint') }, t('polishSend'),
+            React.createElement('input', {
+              type: 'checkbox', checked: !!(draft && draft.message && draft.message.polishSend), disabled: !writable,
+              onChange: (e) => setIn('message', 'polishSend', e.target.checked),
+            })),
+          React.createElement('label', { className: 'dvs-field', title: t('sessionCommandsHint') }, t('sessionCommands'),
+            React.createElement('input', {
+              type: 'checkbox', checked: !!(draft && draft.message && draft.message.sessionCommands), disabled: !writable,
+              onChange: (e) => setIn('message', 'sessionCommands', e.target.checked),
+            })),
         ),
         React.createElement('div', { className: 'dvs-block' },
           React.createElement('div', { className: 'dvs-h' }, t('customTitle')),
@@ -1490,6 +1588,21 @@ window.__ModuleLoader__.load({
               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('label', { className: 'dvs-field', title: t('polishBaseUrlHint') }, t('polishBaseUrl'),
+            React.createElement('input', {
+              type: 'text', value: String((snap && snap.polishBaseUrl) || ''), disabled: !writable,
+              onChange: (e) => setTop('polishBaseUrl', e.target.value),
+            })),
+          React.createElement('label', { className: 'dvs-field' }, t('polishModel'),
+            React.createElement('input', {
+              type: 'text', value: String((draft && draft.polishModel) || ''), disabled: !writable,
+              onChange: (e) => setTop('polishModel', e.target.value),
+            })),
+          React.createElement('label', { className: 'dvs-field' }, t('polishKeyEnv'),
+            React.createElement('input', {
+              type: 'text', value: String((draft && draft.polishKeyEnv) || ''), disabled: !writable,
+              onChange: (e) => setTop('polishKeyEnv', e.target.value),
+            })),
         ),
         React.createElement('div', { className: 'dvs-row' },
           React.createElement('button', { type: 'button', className: 'dvs-save', disabled: !writable, onClick: save }, t('save')),

package/lib/index.js

@@ -83,6 +83,10 @@ export const Config = z.object({
     language: z.string().default('ru'),
     autoSendMs: z.number().default(4000)
       .description('Cancel window before the recognized text is sent to the agent.'),
+    sessionCommands: z.boolean().default(false)
+      .description('Voice session commands: a clean "send", "cancel", "stop", "continue" does not become text — it drives the composer/session.'),
+    polishSend: z.boolean().default(false)
+      .description('Polish the whole composed draft through the model right before sending, not just single phrases.'),
   }).default({}),
   hotkey: z.string().default('Control')
     .description('Hold this key anywhere in the page to record a voice message; release to send, '
@@ -120,6 +124,16 @@ export const Config = z.object({
     .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.'),
+  wakeWord: z.string().default('')
+    .description('Heads-free dictation: a phrase that, when recognized by the browser leg, starts a recording. Empty disables.'),
+  bargeIn: z.boolean().default(false)
+    .description('Ongoing playback or a long turn is interrupted by detected speech (browser leg).'),
+  polishBaseUrl: z.string().default('')
+    .description('Offline polish: OpenAI-compatible /chat/completions endpoint (e.g. local Ollama). Empty uses the harness model.'),
+  polishModel: z.string().default('')
+    .description('Offline polish: model id on polishBaseUrl.'),
+  polishKeyEnv: z.string().default('')
+    .description('Offline polish: credential name for the api key. Empty means no Authorization header.'),
 })
 
 const MIME_BY_EXT = {
@@ -236,18 +250,40 @@ export function apply(ctx, baseConfig) {
     return runChain(order, providers)
   }
 
-  // Полировка транскрипта через модель харнесса (#35). Ошибка/таймаут не
-  // блокирует: возвращаем сырой текст.
+  // Полировка транскрипта (#35) с поддержкой локального LLM (#47).
+  // Ошибка/таймаут не блокирует: возвращаем сырой текст.
   async function polishText(text, modeCfg, signal) {
-    if (!modeCfg || modeCfg.polish !== true) return text
+    const enable = modeCfg && (modeCfg.polish === true || modeCfg.polishSend === true)
+    if (!enable || !text) return text
+    const cfg = live()
+    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
     try {
+      // Локальный OpenAI-совместимый эндпоинт (#47), когда задан.
+      if (cfg.polishBaseUrl) {
+        const headers = { 'content-type': 'application/json' }
+        if (cfg.polishKeyEnv) {
+          const key = await resolveKey(cfg.polishKeyEnv)
+          if (key) headers.authorization = 'Bearer ' + key
+        }
+        const res = await fetch(
+          String(cfg.polishBaseUrl).replace(/\/+$/, '') + '/chat/completions',
+          { method: 'POST', headers, signal, body: JSON.stringify({
+            model: cfg.polishModel || 'local-model',
+            messages: [{ role: 'user', content: ask }],
+          }) })
+        if (!res.ok) return text
+        const data = await res.json().catch(() => null)
+        const pick = data && data.choices && data.choices[0] && data.choices[0].message
+          && data.choices[0].message.content
+        return (pick && String(pick).trim()) || text
+      }
+      // Штатная модель харнесса.
       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))) || ''
@@ -257,6 +293,23 @@ export function apply(ctx, baseConfig) {
     } catch { return text }
   }
 
+  // Чистые голосовые команды сессии (#48). Возвращает название команды или null.
+  // Распознаются на сервере, чтобы не попадать в текст композера.
+  const SESSION_COMMANDS = [
+    { re: /^(отправь|отправить|пошли|send)\s*[.!?]*$/i, cmd: 'send' },
+    { re: /^(отмени|отмена|cancel|отменить)\s*[.!?]*$/i, cmd: 'cancel' },
+    { re: /^(стоп|stop|хватит)\s*[.!?]*$/i, cmd: 'stop' },
+    { re: /^(продолжи|continue|продолжай)\s*[.!?]*$/i, cmd: 'continue' },
+  ]
+  function sessionCommand(text) {
+    const t = String(text || '').trim().toLowerCase()
+    if (!t) return null
+    for (const { re, cmd } of SESSION_COMMANDS) {
+      if (re.test(t)) return cmd
+    }
+    return null
+  }
+
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact',
     path: '/dsh-voice/status',
@@ -283,6 +336,7 @@ export function apply(ctx, baseConfig) {
           message: {
             chain: cfg.message.chain, language: cfg.message.language,
             autoSendMs: cfg.message.autoSendMs, polish: cfg.message.polish,
+            sessionCommands: cfg.message.sessionCommands, polishSend: cfg.message.polishSend,
           },
         },
         beep: cfg.beep,
@@ -290,10 +344,36 @@ export function apply(ctx, baseConfig) {
         micDeviceId: cfg.micDeviceId,
         historyLimit: cfg.historyLimit,
         voiceCommands: cfg.voiceCommands,
+        wakeWord: String(cfg.wakeWord || ''),
+        bargeIn: !!cfg.bargeIn,
+        polishBaseUrl: String(cfg.polishBaseUrl || ''),
       })
     },
   }), 'dsh-voice: /status route')
 
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-voice/polish',
+    handler: async (req, res) => {
+      if (req.method !== 'POST') { writeJson(res, 405, { ok: false, error: { code: 'method', message: 'POST only' } }); return }
+      const cfg = live()
+      let raw
+      try { raw = await readBody(req, cfg.maxFileBytes + 1024 * 1024) } catch (e) { writeJson(res, 400, { ok: false, error: { code: 'body', message: e.message } }); return }
+      let payload = {}
+      try { payload = JSON.parse(raw.toString('utf8') || '{}') } catch { /* пусто */ }
+      const text = typeof payload.text === 'string' ? payload.text.trim() : ''
+      if (!text) { writeJson(res, 400, { ok: false, error: { code: 'empty', message: 'text required' } }); return }
+      const controller = new AbortController()
+      const timer = setTimeout(() => controller.abort(), cfg.timeoutMs)
+      try {
+        const out = await polishText(text, { polish: true }, controller.signal)
+        writeJson(res, 200, { ok: true, text: out })
+      } catch (e) {
+        writeJson(res, 502, { ok: false, error: { code: 'polish', message: String(e && e.message || e) } })
+      } finally { clearTimeout(timer) }
+    },
+  }), 'dsh-voice: /polish route')
+
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact',
     path: '/dsh-voice/transcribe',
@@ -333,6 +413,12 @@ export function apply(ctx, baseConfig) {
       const timer = setTimeout(() => controller.abort(), cfg.timeoutMs)
       try {
         const out = await transcribe(modeCfg, bytes, mime, controller.signal)
+        // Голосовые команды сессии (#48): чистые «отправь/отмени/стоп/продолжи»
+        // не становятся текстом, а возвращаются командой для браузера.
+        if (payload.mode === 'message' && modeCfg.sessionCommands === true) {
+          const cmd = sessionCommand(out.text)
+          if (cmd) { writeJson(res, 200, { ok: true, command: cmd, provider: out.provider, tookMs: out.tookMs }); return }
+        }
         const text = await polishText(out.text, modeCfg, controller.signal)
         writeJson(res, 200, { ok: true, text, provider: out.provider, tookMs: out.tookMs })
       } catch (e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-voice",
-  "version": "0.8.6",
+  "version": "0.8.8",
   "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",