@goodandready/dsh-voice 0.3.0 → 0.4.0

package/README.md

@@ -39,15 +39,56 @@ Keys are read through the DSH credentials service (Settings → Credentials, or
 `$DSH_HOME/.credentials.yaml`), falling back to the process environment. A
 provider without a key is skipped, not fatal.
 
+### Your own providers
+
+Any OpenAI-compatible API can be added as a provider and used in the chains
+next to the built-in ones. Two templates, because those APIs disagree on how
+audio is sent:
+
+| Template | Endpoint | Request | Transcript read from |
+|---|---|---|---|
+| `openai-transcriptions` | `{baseURL}/audio/transcriptions` | multipart: file, model, language | `text` |
+| `openai-chat-audio` | `{baseURL}/chat/completions` | JSON with `input_audio`: base64 and format | `choices[0].message.content` |
+
+OpenRouter has no `/audio/transcriptions` endpoint at all — use the chat
+template there:
+
+```yaml
+- id: dsh-voice
+  config:
+    customProviders:
+      - key: openrouter
+        template: openai-chat-audio
+        baseURL: https://openrouter.ai/api/v1
+        model: google/gemini-2.5-flash
+        keyEnv: OPENROUTER_API_KEY
+    message:
+      chain:
+        - provider: openrouter
+        - provider: local-whisper
+```
+
+Fields: `key` is the name the chains refer to (it cannot shadow a built-in
+one), `keyEnv` names the credential holding the API key (empty means no
+authorization header), and `prompt` overrides the instruction sent with the
+audio in the chat template. A row in a chain may still override `model`.
+
+The chat template accepts WAV and MP3 only, while the browser records
+webm/opus — the plugin converts with ffmpeg, the same way the local whisper
+provider does, so **ffmpeg is required for `openai-chat-audio`**.
+
 ## Configure (Web GUI)
 
-Settings → **Голос** (Voice) has three blocks:
+Settings → **Голос** (Voice) has four blocks:
 
 - **Dictation** — fallback chain (provider + optional model per row, order is
   the order of attempts), language, and the silence threshold that ends a
   phrase (`vadSilenceMs`, default 700 ms).
 - **Voice message** — its own independent chain, language, and the cancel
   window before the message is sent (`autoSendMs`, default 4000 ms).
+- **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.
 
 Speed matters for dictation and accuracy for messages, which is why the chains

package/lib/client.js

@@ -403,7 +403,8 @@ window.__ModuleLoader__.load({
     }
 
     // ------------------------------------------------------- settings page
-    const PROVIDERS = ['deepgram', 'groq', 'hf', 'local-whisper']
+    const BUILTIN = ['deepgram', 'groq', 'hf', 'local-whisper']
+    const TEMPLATES = ['openai-transcriptions', 'openai-chat-audio']
     const MODEL_HINT = {
       deepgram: 'nova-2', groq: 'whisper-large-v3-turbo',
       hf: 'openai/whisper-large-v3', 'local-whisper': 'задаётся при запуске сервера',
@@ -422,6 +423,8 @@ window.__ModuleLoader__.load({
       '.dvs-field input,.dvs-field select{background:var(--dsw-alias-bg-layer-1);border:1px solid var(--dsw-alias-border-l1);color:var(--dsw-alias-label-primary);border-radius:6px;padding:6px 8px;font-size:13px}' +
       '.dvs-mini{border:1px solid var(--dsw-alias-border-l2);background:transparent;color:var(--dsw-alias-label-primary);border-radius:6px;width:28px;height:28px;cursor:pointer;flex:none}' +
       '.dvs-save{background:var(--dsw-alias-brand-primary);color:#fff;border:none;border-radius:6px;padding:7px 14px;font-size:13px;cursor:pointer}' +
+      '.dvs-card{display:flex;flex-direction:column;gap:6px;border:1px solid var(--dsw-alias-border-l2);border-radius:8px;padding:10px}' +
+      '.dvs-card input,.dvs-card select{background:var(--dsw-alias-bg-layer-1);border:1px solid var(--dsw-alias-border-l1);color:var(--dsw-alias-label-primary);border-radius:6px;padding:6px 8px;font-size:13px}' +
       '.dvs-ok{font-size:12px;color:var(--dsw-alias-state-success-primary)}' +
       '.dvs-bad{font-size:12px;color:var(--dsw-alias-state-error-primary)}'
     const setCssId = 'dsh-voice/settings.module.css'
@@ -449,13 +452,15 @@ window.__ModuleLoader__.load({
       }
       const remove = (i) => props.onChange(rows.filter((_, k) => k !== i))
       const add = () => props.onChange(rows.concat([{ provider: 'local-whisper', model: '' }]))
+      const options = Array.isArray(props.options) && props.options.length ? props.options : BUILTIN
 
       return React.createElement('div', { className: 'dvs-block' },
         rows.map((row, i) => React.createElement('div', { className: 'dvs-row', key: i },
           React.createElement('select', {
             value: row.provider, disabled: !props.writable,
             onChange: (e) => change(i, { provider: e.target.value }),
-          }, PROVIDERS.map((p) => React.createElement('option', { key: p, value: p }, p))),
+          }, (options.indexOf(row.provider) < 0 ? options.concat([row.provider]) : options)
+            .map((p) => React.createElement('option', { key: p, value: p }, p))),
           React.createElement('input', {
             className: 'dvs-model', value: row.model || '', disabled: !props.writable,
             placeholder: MODEL_HINT[row.provider] || '', onChange: (e) => change(i, { model: e.target.value }),
@@ -471,6 +476,55 @@ window.__ModuleLoader__.load({
       )
     }
 
+    // Свои провайдеры: имя, шаблон API, куда ходить и чем авторизоваться.
+    function CustomEditor(props) {
+      const rows = Array.isArray(props.value) ? props.value : []
+      const change = (i, patch) => props.onChange(rows.map((r, k) => (k === i ? Object.assign({}, r, patch) : r)))
+      const remove = (i) => props.onChange(rows.filter((_, k) => k !== i))
+      const add = () => props.onChange(rows.concat([
+        { key: '', template: 'openai-transcriptions', baseURL: '', model: '', keyEnv: '', prompt: '' },
+      ]))
+      const field = (i, row, name, placeholder, wide) => React.createElement('input', {
+        className: wide ? 'dvs-model' : '', value: row[name] || '', placeholder: placeholder,
+        disabled: !props.writable, onChange: (e) => change(i, { [name]: e.target.value }),
+      })
+
+      return React.createElement('div', { className: 'dvs-block' },
+        rows.map((row, i) => React.createElement('div', { className: 'dvs-card', key: i },
+          React.createElement('div', { className: 'dvs-row' },
+            field(i, row, 'key', 'имя для цепочки'),
+            React.createElement('select', {
+              value: row.template || 'openai-transcriptions', disabled: !props.writable,
+              onChange: (e) => change(i, { template: e.target.value }),
+            }, TEMPLATES.map((t) => React.createElement('option', { key: t, value: t }, t))),
+            React.createElement('button', {
+              type: 'button', className: 'dvs-mini', title: 'Убрать',
+              disabled: !props.writable, onClick: () => remove(i),
+            }, '\u00d7'),
+          ),
+          React.createElement('div', { className: 'dvs-row' },
+            field(i, row, 'baseURL', 'https://openrouter.ai/api/v1', true),
+          ),
+          React.createElement('div', { className: 'dvs-row' },
+            field(i, row, 'model', 'модель', true),
+            field(i, row, 'keyEnv', 'имя ключа'),
+          ),
+          row.template === 'openai-chat-audio'
+            ? React.createElement('div', { className: 'dvs-row' },
+              field(i, row, 'prompt', 'указание модели (пусто — встроенное)', true))
+            : null,
+        )),
+        React.createElement('div', { className: 'dvs-row' },
+          React.createElement('button', {
+            type: 'button', className: 'dvs-mini', title: 'Добавить своего провайдера',
+            disabled: !props.writable, onClick: add,
+          }, '+'),
+          React.createElement('span', { className: 'dvs-sub' },
+            'У OpenRouter нет /audio/transcriptions \u2014 там нужен шаблон openai-chat-audio'),
+        ),
+      )
+    }
+
     function VoiceSection(props) {
       const ctx = props.ctx
       const scope = ctx.settingsScope.bind({ namespace: NS })
@@ -527,6 +581,14 @@ window.__ModuleLoader__.load({
         return m && m[key] !== undefined ? m[key] : fallback
       }
 
+      // Имена своих провайдеров берём из черновика, чтобы только что
+      // добавленный сразу появлялся в списках цепочек.
+      const chainOptions = BUILTIN.concat(
+        (draft && Array.isArray(draft.customProviders) ? draft.customProviders : [])
+          .map((c) => String(c && c.key || '').trim())
+          .filter((k) => k && BUILTIN.indexOf(k) < 0),
+      )
+
       const langField = (mode) => React.createElement('label', { className: 'dvs-field' }, 'Язык',
         React.createElement('select', {
           value: modeVal(mode, 'language', 'ru'), disabled: !writable,
@@ -553,6 +615,7 @@ window.__ModuleLoader__.load({
           React.createElement('div', { className: 'dvs-sub' }, 'Речь режется по паузам, текст дописывается в строку ввода.'),
           React.createElement(ChainEditor, {
             value: draft && draft.dictation ? draft.dictation.chain : [], writable: writable,
+            options: chainOptions,
             onChange: (v) => setIn('dictation', 'chain', v),
           }),
           langField('dictation'),
@@ -563,11 +626,21 @@ window.__ModuleLoader__.load({
           React.createElement('div', { className: 'dvs-sub' }, 'Одна запись целиком, после распознавания уходит агенту.'),
           React.createElement(ChainEditor, {
             value: draft && draft.message ? draft.message.chain : [], writable: writable,
+            options: chainOptions,
             onChange: (v) => setIn('message', 'chain', v),
           }),
           langField('message'),
           numField('message', 'autoSendMs', 'Окно отмены, мс', 'Сколько времени можно отменить автоматическую отправку'),
         ),
+        React.createElement('div', { className: 'dvs-block' },
+          React.createElement('div', { className: 'dvs-h' }, 'Свои провайдеры'),
+          React.createElement('div', { className: 'dvs-sub' },
+            'Любой OpenAI-совместимый API. Имя становится доступным в цепочках выше.'),
+          React.createElement(CustomEditor, {
+            value: draft && draft.customProviders ? draft.customProviders : [], writable: writable,
+            onChange: (v) => setTop('customProviders', v),
+          }),
+        ),
         React.createElement('div', { className: 'dvs-block' },
           React.createElement('div', { className: 'dvs-h' }, 'Общее'),
           textField('whisperUrl', 'Локальный whisper: endpoint', 'POST /inference сервера whisper.cpp'),

package/lib/index.js

@@ -18,19 +18,37 @@ import { credentialRef } from '@deepseek-ai/dsh-credentials'
 import { readFile, stat } from 'node:fs/promises'
 import path from 'node:path'
 import { runChain } from './chain.js'
-import { makeProviders, PROVIDER_KEYS, DEFAULT_MODELS } from './providers.js'
+import { makeProviders, PROVIDER_KEYS, DEFAULT_MODELS, CUSTOM_TEMPLATES } from './providers.js'
 import { toWav16k } from './wav.js'
 
 export const name = 'dsh-voice'
-export const inject = ['tools', 'credentials', 'webServer', 'shell']
+export const inject = ['tools', 'credentials', 'webServer', 'shell', 'settings']
 
 const ChainEntry = z.object({
   provider: z.string().default('local-whisper')
-    .description(`Provider key. One of: ${PROVIDER_KEYS.join(', ')}.`),
+    .description(`Provider key: one of ${PROVIDER_KEYS.join(', ')}, `
+      + 'or the name of an entry from customProviders.'),
   model: z.string().default('')
     .description('Model override. Empty means the provider default.'),
 })
 
+// Свой провайдер: всё, что нужно, чтобы сходить в чужой OpenAI-совместимый API.
+const CustomProvider = z.object({
+  key: z.string().default('')
+    .description('Name used in the chains above. Must differ from the built-in keys.'),
+  template: z.string().default('openai-transcriptions')
+    .description(`API shape: ${CUSTOM_TEMPLATES.join(' or ')}. `
+      + 'OpenRouter has no /audio/transcriptions, use openai-chat-audio there.'),
+  baseURL: z.string().default('')
+    .description('API root without a trailing slash, e.g. https://openrouter.ai/api/v1'),
+  model: z.string().default(''),
+  keyEnv: z.string().default('')
+    .description('Credential name holding the API key. Empty means no authorization header.'),
+  prompt: z.string().default('')
+    .description('openai-chat-audio only: instruction sent along with the audio. '
+      + 'Empty means the built-in one.'),
+})
+
 export const Config = z.object({
   dictation: z.object({
     chain: z.array(ChainEntry)
@@ -48,6 +66,8 @@ export const Config = z.object({
     autoSendMs: z.number().default(4000)
       .description('Cancel window before the recognized text is sent to the agent.'),
   }).default({}),
+  customProviders: z.array(CustomProvider).default([])
+    .description('Own recognition providers, usable in both chains next to the built-in ones.'),
   deepgramKeyEnv: z.string().default('DEEPGRAM_API_KEY'),
   groqKeyEnv: z.string().default('GROQ_API_KEY'),
   hfTokenEnv: z.string().default('HF_TOKEN'),
@@ -92,9 +112,23 @@ function readBody(req, maxBytes) {
   })
 }
 
-export function apply(ctx, config) {
+export function apply(ctx, baseConfig) {
   let child = null
 
+  // Карточка настроек правит namespace с именем плагина. Пока хост его не
+  // объявил через settings.register, снимок приходит пустым и нередактируемым:
+  // поля серые, цепочки пустые, сохранять некуда. Чтение через live() заодно
+  // означает, что правка применяется к следующему запросу, а не после
+  // перезапуска процесса.
+  let getConfig = () => baseConfig
+  const live = () => Config(structuredClone(getConfig() ?? {})) ?? baseConfig
+
+  ctx.inject(['settings'], (sctx) => {
+    const scope = sctx.settings.register(name, Config, { base: baseConfig })
+    getConfig = () => scope.get() ?? baseConfig
+    sctx.effect(() => () => { getConfig = () => baseConfig })
+  })
+
   async function resolveKey(ref) {
     try {
       const resolved = await ctx.credentials.resolve(credentialRef(ref))
@@ -107,22 +141,23 @@ export function apply(ctx, config) {
     try {
       const controller = new AbortController()
       const t = setTimeout(() => controller.abort(), 2000)
-      const res = await fetch(config.whisperUrl.split('/inference')[0] + '/', { signal: controller.signal })
+      const res = await fetch(live().whisperUrl.split('/inference')[0] + '/', { signal: controller.signal })
       clearTimeout(t)
       return res.ok
     } catch { return false }
   }
 
   async function startWhisper() {
-    if (!config.autoStart) return false
+    const cfg = live()
+    if (!cfg.autoStart) return false
     // Без пути к модели запускать нечего: пакет не знает, где она лежит у
     // конкретного пользователя, и молча стартовать чужой бинарь не должен.
-    if (!config.whisperModel) return false
+    if (!cfg.whisperModel) return false
     if (await whisperAlive()) return true
     try {
       const spec = ctx.shell.resolve({
-        command: `${JSON.stringify(config.whisperBin)} -m ${JSON.stringify(config.whisperModel)}`
-          + ` --host 127.0.0.1 --port 8001 -t 8 -p 1 -l ${config.dictation.language}`,
+        command: `${JSON.stringify(cfg.whisperBin)} -m ${JSON.stringify(cfg.whisperModel)}`
+          + ` --host 127.0.0.1 --port 8001 -t 8 -p 1 -l ${cfg.dictation.language}`,
         timeoutMs: 0,
         stdoutMaxBytes: 4 * 1024 * 1024,
       })
@@ -139,15 +174,21 @@ export function apply(ctx, config) {
 
   // Общий путь распознавания: собрать провайдеров по цепочке режима и пройти её.
   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)
     const models = {}
     const order = []
     for (const entry of Array.isArray(modeCfg.chain) ? modeCfg.chain : []) {
-      if (!PROVIDER_KEYS.includes(entry.provider)) continue
+      if (!PROVIDER_KEYS.includes(entry.provider) && !customKeys.includes(entry.provider)) continue
       order.push(entry.provider)
-      models[entry.provider] = entry.model || DEFAULT_MODELS[entry.provider]
+      // Для своего провайдера модель по умолчанию живёт в его описании,
+      // подставит makeProviders — здесь пусто означает «бери оттуда».
+      models[entry.provider] = entry.model || DEFAULT_MODELS[entry.provider] || ''
     }
     const providers = makeProviders(
-      { resolveKey, fetchImpl: fetch, cfg: config, toWav: (b) => toWav16k(b, config.ffmpegBin) },
+      { resolveKey, fetchImpl: fetch, cfg, toWav: (b) => toWav16k(b, cfg.ffmpegBin) },
       { bytes, mime, lang: modeCfg.language, signal, models },
     )
     return runChain(order, providers)
@@ -158,12 +199,17 @@ export function apply(ctx, config) {
     path: '/dsh-voice/status',
     handler: async (req, res) => {
       if (req.method !== 'GET') { writeJson(res, 405, { ok: false, error: { code: 'method', message: 'GET only' } }); return }
+      const cfg = live()
       writeJson(res, 200, {
         ok: true,
         whisperRunning: await whisperAlive(),
+        providers: PROVIDER_KEYS.concat(
+          (Array.isArray(cfg.customProviders) ? cfg.customProviders : [])
+            .map((c) => String(c && c.key || '').trim()).filter(Boolean),
+        ),
         modes: {
-          dictation: { chain: config.dictation.chain, language: config.dictation.language, vadSilenceMs: config.dictation.vadSilenceMs },
-          message: { chain: config.message.chain, language: config.message.language, autoSendMs: config.message.autoSendMs },
+          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 },
         },
       })
     },
@@ -174,9 +220,10 @@ export function apply(ctx, config) {
     path: '/dsh-voice/transcribe',
     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, config.maxFileBytes + 1024 * 1024)
+        raw = await readBody(req, cfg.maxFileBytes + 1024 * 1024)
       } catch (e) {
         writeJson(res, 400, { ok: false, error: { code: 'body', message: e.message } }); return
       }
@@ -186,15 +233,15 @@ export function apply(ctx, config) {
       const dataBase64 = typeof payload.dataBase64 === 'string' ? payload.dataBase64 : ''
       if (!dataBase64) { writeJson(res, 400, { ok: false, error: { code: 'no-audio', message: 'no audio data' } }); return }
       const mime = typeof payload.mimeType === 'string' && payload.mimeType ? payload.mimeType : 'audio/webm'
-      const modeCfg = payload.mode === 'message' ? config.message : config.dictation
+      const modeCfg = payload.mode === 'message' ? cfg.message : cfg.dictation
 
       let bytes
       try { bytes = Buffer.from(dataBase64, 'base64') } catch { bytes = null }
       if (!bytes || bytes.length === 0) {
         writeJson(res, 400, { ok: false, error: { code: 'decode', message: 'failed to decode audio' } }); return
       }
-      if (bytes.length > config.maxFileBytes) {
-        writeJson(res, 413, { ok: false, error: { code: 'too-large', message: `audio is ${bytes.length} bytes, max ${config.maxFileBytes}` } }); return
+      if (bytes.length > cfg.maxFileBytes) {
+        writeJson(res, 413, { ok: false, error: { code: 'too-large', message: `audio is ${bytes.length} bytes, max ${cfg.maxFileBytes}` } }); return
       }
 
       // Локальный whisper в цепочке — поднимаем сервер заранее, иначе первый
@@ -204,7 +251,7 @@ export function apply(ctx, config) {
       }
 
       const controller = new AbortController()
-      const timer = setTimeout(() => controller.abort(), config.timeoutMs)
+      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 })
@@ -226,7 +273,7 @@ export function apply(ctx, config) {
         + 'Use for voice messages, recordings, interviews.',
       parameters: {
         file_path: { type: 'string', required: true, description: 'Absolute path to the audio file (wav, mp3, m4a, ogg, flac, webm).' },
-        language: { type: 'string', description: `Recognition language code. Default: ${config.message.language}.` },
+        language: { type: 'string', description: `Recognition language code. Default: ${baseConfig.message.language}.` },
       },
       output: {
         schema: {
@@ -242,19 +289,20 @@ export function apply(ctx, config) {
         },
       },
       isConcurrencySafe: () => false,
-      timeoutMs: config.timeoutMs * 3 + 5000,
+      timeoutMs: baseConfig.timeoutMs * 3 + 5000,
       async execute(args, exec) {
+        const cfg = live()
         const filePath = String(args.file_path || '').trim()
         if (!filePath) throw new Error('transcribe_audio: file_path is required')
         const info = await stat(filePath).catch(() => null)
         if (!info) throw new Error(`transcribe_audio: file not found: ${filePath}`)
-        if (info.size > config.maxFileBytes) {
-          throw new Error(`transcribe_audio: file too large (${info.size} bytes, max ${config.maxFileBytes})`)
+        if (info.size > cfg.maxFileBytes) {
+          throw new Error(`transcribe_audio: file too large (${info.size} bytes, max ${cfg.maxFileBytes})`)
         }
         if (info.size < 100) throw new Error('transcribe_audio: file is empty or too small')
         const mime = MIME_BY_EXT[path.extname(filePath).toLowerCase()] || 'audio/wav'
         const bytes = await readFile(filePath)
-        const modeCfg = { ...config.message, language: String(args.language || config.message.language) }
+        const modeCfg = { ...cfg.message, language: String(args.language || cfg.message.language) }
         return transcribe(modeCfg, bytes, mime, exec.signal)
       },
     }),

package/lib/providers.js

@@ -1,9 +1,26 @@
-// Четыре провайдера распознавания речи. Чистые функции: сеть приходит
-// параметром (fetchImpl), ключи — через resolveKey, поэтому всё проверяется
-// без реальных запросов.
+// Провайдеры распознавания речи: четыре встроенных плюс любые свои, объявленные
+// в настройках. Чистые функции: сеть приходит параметром (fetchImpl), ключи —
+// через resolveKey, поэтому всё проверяется без реальных запросов.
 
 export const PROVIDER_KEYS = ['deepgram', 'groq', 'hf', 'local-whisper']
 
+// Свой провайдер описывается одним из двух шаблонов, потому что
+// OpenAI-совместимые API разошлись: у OpenRouter, например, нет
+// /audio/transcriptions вовсе, и распознавание там идёт через чат.
+export const CUSTOM_TEMPLATES = ['openai-transcriptions', 'openai-chat-audio']
+
+const CHAT_AUDIO_PROMPT =
+  'Transcribe the audio verbatim. Reply with the transcript text only, '
+  + 'without comments, quotes or formatting.'
+
+// Форматы, которые чат-шаблон принимает в input_audio. Всё остальное —
+// включая webm/opus, который пишет браузер, — сначала перегоняем в WAV.
+function chatAudioFormat(mime) {
+  if (mime.includes('wav')) return 'wav'
+  if (mime.includes('mpeg') || mime.includes('mp3')) return 'mp3'
+  return ''
+}
+
 export const DEFAULT_MODELS = {
   deepgram: 'nova-2',
   groq: 'whisper-large-v3-turbo',
@@ -114,5 +131,92 @@ export function makeProviders(deps, req) {
     return { ok: text.length > 0, provider: 'local-whisper', text, reason: text ? '' : 'empty transcript' }
   }
 
-  return { deepgram, groq, hf, 'local-whisper': localWhisper }
+  // Свой провайдер. Ключ в цепочке — его имя, поэтому в остальном коде он
+  // ничем не отличается от встроенного.
+  function customProvider(spec) {
+    const label = spec.key
+    const base = String(spec.baseURL || '').replace(/\/+$/, '')
+    const model = pickModel(models, label) || spec.model
+
+    async function auth() {
+      if (!spec.keyEnv) return {}
+      const key = await resolveKey(spec.keyEnv)
+      if (!key) return null
+      return { authorization: `Bearer ${key}` }
+    }
+
+    async function viaTranscriptions(headers) {
+      const form = new FormData()
+      form.append('file', new Blob([bytes], { type: mime }), fileName(mime))
+      form.append('model', model)
+      if (lang && lang !== 'auto') form.append('language', lang)
+      form.append('response_format', 'json')
+      const res = await fetchImpl(`${base}/audio/transcriptions`, {
+        method: 'POST', headers, body: form, signal,
+      })
+      if (!res.ok) throw new Error(`${label} HTTP ${res.status}`)
+      const data = await res.json()
+      return (data?.text || '').trim()
+    }
+
+    async function viaChatAudio(headers) {
+      let sendBytes = bytes
+      let format = chatAudioFormat(mime)
+      if (!format) {
+        if (typeof deps.toWav !== 'function') {
+          throw new Error(`${label} needs wav or mp3, no converter configured`)
+        }
+        sendBytes = await deps.toWav(bytes)
+        format = 'wav'
+      }
+      const ask = (spec.prompt || CHAT_AUDIO_PROMPT)
+        + (lang && lang !== 'auto' ? ` The audio language is ${lang}.` : '')
+      const res = await fetchImpl(`${base}/chat/completions`, {
+        method: 'POST',
+        headers: { ...headers, 'content-type': 'application/json' },
+        body: JSON.stringify({
+          model,
+          messages: [{
+            role: 'user',
+            content: [
+              { type: 'text', text: ask },
+              { type: 'input_audio', input_audio: { data: Buffer.from(sendBytes).toString('base64'), format } },
+            ],
+          }],
+        }),
+        signal,
+      })
+      if (!res.ok) throw new Error(`${label} HTTP ${res.status}`)
+      const data = await res.json()
+      return String(data?.choices?.[0]?.message?.content || '').trim()
+    }
+
+    return async function run() {
+      if (!base) return { ok: false, provider: label, reason: `${label}: no baseURL` }
+      if (!model) return { ok: false, provider: label, reason: `${label}: no model` }
+      const headers = await auth()
+      if (headers === null) return { ok: false, provider: label, reason: `no ${spec.keyEnv}` }
+      let text
+      try {
+        text = spec.template === 'openai-chat-audio'
+          ? await viaChatAudio(headers)
+          : await viaTranscriptions(headers)
+      } catch (e) {
+        // Отказ одного провайдера не должен ронять цепочку — она сама решит,
+        // идти дальше или сдаться.
+        return { ok: false, provider: label, reason: `${label}: ${String(e && e.message || e)}` }
+      }
+      return { ok: text.length > 0, provider: label, text, reason: text ? '' : 'empty transcript' }
+    }
+  }
+
+  const out = { deepgram, groq, hf, 'local-whisper': localWhisper }
+  for (const spec of Array.isArray(cfg.customProviders) ? cfg.customProviders : []) {
+    const key = String(spec && spec.key || '').trim()
+    // Встроенные не перекрываем: иначе опечатка в имени тихо подменит рабочего
+    // провайдера в чужой цепочке.
+    if (!key || out[key]) continue
+    out[key] = customProvider({ ...spec, key })
+  }
+  return out
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@goodandready/dsh-voice",
-  "version": "0.3.0",
-  "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).",
+  "version": "0.4.0",
+  "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",
   "main": "./lib/index.js",
@@ -26,7 +26,9 @@
     "dictation",
     "whisper",
     "deepgram",
-    "groq"
+    "groq",
+    "openrouter",
+    "openai-compatible"
   ],
   "repository": {
     "type": "git",