verbalcoding 0.2.12 → 0.2.13

package/app-node/tts_player.test.mjs

@@ -0,0 +1,202 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createTtsPlayer } from './tts_player.mjs';
+import { createBridge } from './bridge_context.mjs';
+
+function makeDeps(overrides = {}) {
+  const bridge = createBridge();
+  bridge.ttsBackend = {
+    name: 'fake',
+    synthesize: async () => '/tmp/fake.wav',
+  };
+  return {
+    bridge,
+    settings: { tts: { maxChars: 200, volume: 1 } },
+    log: () => {},
+    warn: () => {},
+    sleep: async () => {},
+    sendText: async () => {},
+    refreshTtsRuntimeConfig: async () => {},
+    waitEvent: async () => {},
+    isAbortError: () => false,
+    STREAMING_TTS_ENABLED: true,
+    ...overrides,
+  };
+}
+
+test('createTtsPlayer exposes the expected functions', () => {
+  const player = createTtsPlayer(makeDeps());
+  for (const name of ['synthTTS', 'playAudio', 'speakText', 'beginStreamingTurn', 'endStreamingTurn', 'stopPlaybackForBargeIn']) {
+    assert.equal(typeof player[name], 'function', `${name} is exposed`);
+  }
+});
+
+test('stopPlaybackForBargeIn is a no-op when nothing is speaking', () => {
+  const deps = makeDeps();
+  const { stopPlaybackForBargeIn } = createTtsPlayer(deps);
+  assert.equal(deps.bridge.speaking, false);
+  assert.equal(stopPlaybackForBargeIn('user-1', 'manual'), false);
+  assert.equal(deps.bridge.speechPlaybackGeneration, 0);
+});
+
+test('stopPlaybackForBargeIn stops the active player and increments generation', () => {
+  let stopped = false;
+  const deps = makeDeps();
+  deps.bridge.speaking = true;
+  deps.bridge.player = { stop: () => { stopped = true; } };
+  const { stopPlaybackForBargeIn } = createTtsPlayer(deps);
+  const out = stopPlaybackForBargeIn('user-1', 'live-barge-in');
+  assert.equal(out, true);
+  assert.equal(stopped, true);
+  assert.equal(deps.bridge.speaking, false);
+  assert.equal(deps.bridge.speechPlaybackGeneration, 1);
+});
+
+test('playAudio is a no-op when no voice connection', async () => {
+  const deps = makeDeps();
+  deps.bridge.connection = null;
+  const { playAudio } = createTtsPlayer(deps);
+  await playAudio('/tmp/fake.wav', { deleteAfter: false });
+  // No throw and no state mutation expected.
+  assert.equal(deps.bridge.speaking, false);
+});
+
+test('beginStreamingTurn returns false when streaming disabled', () => {
+  const deps = makeDeps({ STREAMING_TTS_ENABLED: false });
+  deps.bridge.connection = { subscribe: () => {} };
+  const { beginStreamingTurn } = createTtsPlayer(deps);
+  assert.equal(beginStreamingTurn(new AbortController().signal), false);
+  assert.equal(deps.bridge.activeSentencer, null);
+  assert.equal(deps.bridge.activeStreamingQueue, null);
+});
+
+test('beginStreamingTurn returns false when no voice connection', () => {
+  const deps = makeDeps();
+  deps.bridge.connection = null;
+  const { beginStreamingTurn } = createTtsPlayer(deps);
+  assert.equal(beginStreamingTurn(new AbortController().signal), false);
+});
+
+test('synthTTS retries on transient failure and surfaces the final error', async () => {
+  let calls = 0;
+  const deps = makeDeps();
+  deps.bridge.ttsBackend = {
+    name: 'flaky',
+    synthesize: async () => {
+      calls++;
+      const e = new Error('boom');
+      throw e;
+    },
+  };
+  const { synthTTS } = createTtsPlayer(deps);
+  await assert.rejects(() => synthTTS('hi', null), /boom/);
+  assert.equal(calls, 3);
+});
+
+test('synthTTS aborts immediately on signal abort', async () => {
+  let calls = 0;
+  const deps = makeDeps({ isAbortError: e => e.name === 'AbortError' });
+  deps.bridge.ttsBackend = {
+    name: 'aborty',
+    synthesize: async () => {
+      calls++;
+      const e = new Error('aborted');
+      e.name = 'AbortError';
+      throw e;
+    },
+  };
+  const { synthTTS } = createTtsPlayer(deps);
+  await assert.rejects(() => synthTTS('hi', null), /aborted/);
+  assert.equal(calls, 1, 'no retries after AbortError');
+});
+
+// --- speakText full chunked synth/play flow ------------------------------
+//
+// synthTTS internally calls fs.statSync on the file the backend returns,
+// so these tests create a real temp file the fake synthesize() can return.
+
+import fsReal from 'node:fs';
+import osReal from 'node:os';
+import pathReal from 'node:path';
+
+const __tempRoots = [];
+test.after(() => {
+  for (const root of __tempRoots) try { fsReal.rmSync(root, { recursive: true, force: true }); } catch {}
+});
+
+function makeFakeWav() {
+  const dir = fsReal.mkdtempSync(pathReal.join(osReal.tmpdir(), 'vc-tts-test-'));
+  __tempRoots.push(dir);
+  const file = pathReal.join(dir, 'fake.wav');
+  fsReal.writeFileSync(file, Buffer.from('RIFF....fake-wav-bytes'));
+  return file;
+}
+
+test('speakText mirrors text to channel, then synths + plays each chunk in order', async () => {
+  const fakePath = makeFakeWav();
+  const synthCalls = [];
+  const sentTexts = [];
+  const stages = {};
+  const deps = makeDeps({
+    sendText: async t => { sentTexts.push(t); },
+  });
+  deps.bridge.connection = { subscribe: () => {} };
+  deps.bridge.player = { play: () => {}, stop: () => {}, on: () => {} };
+  deps.bridge.ttsBackend = {
+    name: 'fake',
+    synthesize: async text => { synthCalls.push(text); return fakePath; },
+  };
+  deps.waitEvent = async () => {};
+
+  const { speakText } = createTtsPlayer(deps);
+  const metricsTurn = { stage: (label, ms, extra) => { stages[label] = { ms, extra }; } };
+  await speakText('hello world', null, metricsTurn, { mirrorText: true });
+
+  assert.equal(synthCalls.length, 1, 'one synth call for one chunk');
+  assert.equal(synthCalls[0], 'hello world');
+  assert.ok(sentTexts.some(t => /hello world/.test(t)), 'mirror text sent to channel');
+  assert.ok(stages.tts_synth, 'tts_synth stage recorded');
+  assert.ok(stages.tts_play, 'tts_play stage recorded');
+  assert.ok(stages.tts_total, 'tts_total stage recorded');
+  assert.equal(stages.tts_synth.extra.ttsChunks, 1, 'extra carries chunk count');
+});
+
+test('speakText with mirrorText:false does NOT echo to the text channel', async () => {
+  const fakePath = makeFakeWav();
+  const sentTexts = [];
+  const deps = makeDeps({ sendText: async t => { sentTexts.push(t); } });
+  deps.bridge.connection = { subscribe: () => {} };
+  deps.bridge.player = { play: () => {}, stop: () => {}, on: () => {} };
+  deps.bridge.ttsBackend = { name: 'fake', synthesize: async () => fakePath };
+  deps.waitEvent = async () => {};
+
+  const { speakText } = createTtsPlayer(deps);
+  await speakText('quiet', null, null, { mirrorText: false });
+  assert.equal(sentTexts.length, 0, 'no mirror when mirrorText:false');
+});
+
+test('speakText skips play when speechPlaybackGeneration changes mid-flight', async () => {
+  const fakePath = makeFakeWav();
+  let synthCalls = 0;
+  let playCalls = 0;
+  const deps = makeDeps();
+  deps.bridge.connection = { subscribe: () => {} };
+  deps.bridge.player = { play: () => { playCalls++; }, stop: () => {}, on: () => {} };
+  const beforeGen = deps.bridge.speechPlaybackGeneration;
+  // Bump the generation during synth — when playChunkedTTSWithPrefetch's
+  // play wrapper checks playbackStopped(), it'll see the mismatch and skip.
+  deps.bridge.ttsBackend = {
+    name: 'fake',
+    synthesize: async () => {
+      synthCalls++;
+      deps.bridge.speechPlaybackGeneration = beforeGen + 1;
+      return fakePath;
+    },
+  };
+  deps.waitEvent = async () => {};
+
+  const { speakText } = createTtsPlayer(deps);
+  await speakText('hello world', null, null, { mirrorText: false });
+  assert.equal(synthCalls, 1, 'synth runs once');
+  assert.equal(playCalls, 0, 'play is skipped because generation changed');
+});

package/app-node/tts_runtime.mjs

@@ -0,0 +1,134 @@
+// TTS runtime helpers: on-demand backend installation and binary lookup.
+//
+// Phase 5c extraction from main.mjs.
+//   - ensureSelectedTtsBackendInstalled triggers per-backend install scripts
+//     (mlxaudio, fireredtts2, mossttsnano) when their python venv / binary
+//     is missing, then persists the resolved env paths.
+//   - commandIsInstalled walks PATH (with Windows PATHEXT support) and
+//     caches results on bridge.installedBinaryCache.
+//
+// refreshTtsRuntimeConfig deliberately stays in main.mjs because it
+// references ttsFallbackNotice (also in main.mjs) which itself references
+// speakText from ttsPlayer — moving it here would force a thunk dance.
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+export function createTtsRuntime(deps) {
+  const {
+    bridge,
+    ROOT,
+    execFileAsync,
+    speakText,
+    warn,
+    persistEnvValues,
+  } = deps;
+
+  async function ensureSelectedTtsBackendInstalled(selection, signal) {
+    if (selection.backend === 'mlxaudio') {
+      const mlxPython = process.env.MLXAUDIO_PYTHON || './.venv-mlxaudio/bin/python';
+      const mlxPath = path.isAbsolute(mlxPython) ? mlxPython : path.resolve(ROOT, mlxPython);
+      if (fs.existsSync(mlxPath)) return { ok: true, installed: false };
+      await speakText('MLX Audio가 아직 설치 안 돼 있어서 지금 설치할게. 처음엔 모델 다운로드가 걸릴 수 있어.', signal, null, { mirrorText: true });
+      try {
+        await execFileAsync('bash', [path.join(ROOT, 'scripts', 'install_mlxaudio.sh'), '--yes'], {
+          cwd: ROOT,
+          timeout: Number(process.env.MLXAUDIO_INSTALL_TIMEOUT_MS || '1800000'),
+          maxBuffer: 1024 * 1024,
+        });
+        process.env.MLXAUDIO_PYTHON = './.venv-mlxaudio/bin/python';
+        persistEnvValues({ MLXAUDIO_PYTHON: './.venv-mlxaudio/bin/python' });
+        return { ok: true, installed: true };
+      } catch (error) {
+        const tail = String(error?.stderr || error?.stdout || error?.message || error).slice(-900);
+        warn('MLX Audio auto-install failed', tail);
+        await speakText(`MLX Audio 자동 설치가 실패했어. Edge fallback은 유지할게. 로그 꼬리: ${tail}`, signal, null, { mirrorText: true });
+        return { ok: false, installed: false, error };
+      }
+    }
+    if (selection.backend === 'fireredtts2') {
+      const fireCommand = process.env.FIREREDTTS2_COMMAND || './.local/bin/fireredtts2';
+      const firePath = path.isAbsolute(fireCommand) ? fireCommand : path.resolve(ROOT, fireCommand);
+      const fireModel = path.resolve(ROOT, process.env.FIREREDTTS2_PRETRAINED_DIR || 'pretrained_models/FireRedTTS2');
+      if (fs.existsSync(firePath) && fs.existsSync(fireModel)) return { ok: true, installed: false };
+      await speakText('FireRedTTS-2가 아직 설치 안 돼 있어서 지금 설치할게. 모델 다운로드 때문에 오래 걸릴 수 있어.', signal, null, { mirrorText: true });
+      try {
+        await execFileAsync('bash', [path.join(ROOT, 'scripts', 'install_fireredtts2.sh'), '--yes'], {
+          cwd: ROOT,
+          timeout: Number(process.env.FIREREDTTS2_INSTALL_TIMEOUT_MS || '3600000'),
+          maxBuffer: 1024 * 1024,
+        });
+        process.env.FIREREDTTS2_COMMAND = './.local/bin/fireredtts2';
+        process.env.FIREREDTTS2_PRETRAINED_DIR = 'pretrained_models/FireRedTTS2';
+        persistEnvValues({
+          FIREREDTTS2_COMMAND: './.local/bin/fireredtts2',
+          FIREREDTTS2_PRETRAINED_DIR: 'pretrained_models/FireRedTTS2',
+        });
+        return { ok: true, installed: true };
+      } catch (error) {
+        const tail = String(error?.stderr || error?.stdout || error?.message || error).slice(-900);
+        warn('FireRedTTS-2 auto-install failed', tail);
+        await speakText(`FireRedTTS-2 자동 설치가 실패했어. Edge fallback은 유지할게. 로그 꼬리: ${tail}`, signal, null, { mirrorText: true });
+        return { ok: false, installed: false, error };
+      }
+    }
+    if (selection.backend === 'mossttsnano') {
+      const mossCommand = process.env.MOSSTTSNANO_COMMAND || './.local/bin/mossttsnano';
+      const mossPath = path.isAbsolute(mossCommand) ? mossCommand : path.resolve(ROOT, mossCommand);
+      const mossScript = path.resolve(ROOT, process.env.MOSSTTSNANO_SCRIPT || 'vendor/MOSS-TTS-Nano/infer.py');
+      if (fs.existsSync(mossPath) && fs.existsSync(mossScript)) return { ok: true, installed: false };
+      await speakText('MOSS-TTS-Nano가 아직 설치 안 돼 있어서 지금 설치할게. 처음엔 모델 다운로드가 걸릴 수 있어.', signal, null, { mirrorText: true });
+      try {
+        await execFileAsync('bash', [path.join(ROOT, 'scripts', 'install_mossttsnano.sh'), '--yes'], {
+          cwd: ROOT,
+          timeout: Number(process.env.MOSSTTSNANO_INSTALL_TIMEOUT_MS || '1800000'),
+          maxBuffer: 1024 * 1024,
+        });
+        process.env.MOSSTTSNANO_COMMAND = './.venv-mossttsnano/bin/python';
+        process.env.MOSSTTSNANO_SCRIPT = 'vendor/MOSS-TTS-Nano/infer.py';
+        persistEnvValues({
+          MOSSTTSNANO_COMMAND: './.venv-mossttsnano/bin/python',
+          MOSSTTSNANO_SCRIPT: 'vendor/MOSS-TTS-Nano/infer.py',
+        });
+        return { ok: true, installed: true };
+      } catch (error) {
+        const tail = String(error?.stderr || error?.stdout || error?.message || error).slice(-900);
+        warn('MOSS-TTS-Nano auto-install failed', tail);
+        await speakText(`MOSS-TTS-Nano 자동 설치가 실패했어. Edge fallback은 유지할게. 로그 꼬리: ${tail}`, signal, null, { mirrorText: true });
+        return { ok: false, installed: false, error };
+      }
+    }
+    return { ok: true, installed: false };
+  }
+
+  function commandIsInstalled(binary, { cwd = process.cwd() } = {}) {
+    if (!binary) return false;
+    const isWindows = process.platform === 'win32';
+    const exts = isWindows
+      ? String(process.env.PATHEXT || '.COM;.EXE;.BAT;.CMD').split(';').filter(Boolean)
+      : [''];
+    function existsExecutable(candidate) {
+      try { fs.accessSync(candidate, fs.constants.X_OK); return true; } catch { return false; }
+    }
+    function existsAnyExt(candidate) {
+      if (existsExecutable(candidate)) return true;
+      if (isWindows && !/\.[^\\/.]+$/.test(candidate)) {
+        return exts.some(ext => existsExecutable(candidate + ext));
+      }
+      return false;
+    }
+    if (path.isAbsolute(binary)) return existsAnyExt(binary);
+    const hasPathSep = binary.includes('/') || (isWindows && binary.includes('\\'));
+    if (hasPathSep) return existsAnyExt(path.resolve(cwd, binary));
+    if (bridge.installedBinaryCache.has(binary)) return bridge.installedBinaryCache.get(binary);
+    const pathEntries = String(process.env.PATH || '').split(path.delimiter).filter(Boolean);
+    const found = pathEntries.some(dir => existsAnyExt(path.join(dir, binary)));
+    bridge.installedBinaryCache.set(binary, found);
+    return found;
+  }
+
+  return {
+    ensureSelectedTtsBackendInstalled,
+    commandIsInstalled,
+  };
+}

package/app-node/tts_runtime.test.mjs

@@ -0,0 +1,89 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createTtsRuntime } from './tts_runtime.mjs';
+import { createBridge } from './bridge_context.mjs';
+
+function makeDeps(overrides = {}) {
+  return {
+    bridge: createBridge(),
+    ROOT: '/tmp/vc-root',
+    execFileAsync: async () => ({ stdout: '', stderr: '' }),
+    speakText: async () => {},
+    warn: () => {},
+    persistEnvValues: () => {},
+    ...overrides,
+  };
+}
+
+test('createTtsRuntime exposes the expected functions', () => {
+  const rt = createTtsRuntime(makeDeps());
+  for (const name of ['ensureSelectedTtsBackendInstalled', 'commandIsInstalled']) {
+    assert.equal(typeof rt[name], 'function', `${name} is exposed`);
+  }
+});
+
+test('ensureSelectedTtsBackendInstalled is a no-op for built-in backends', async () => {
+  const { ensureSelectedTtsBackendInstalled } = createTtsRuntime(makeDeps());
+  const result = await ensureSelectedTtsBackendInstalled({ backend: 'edge' }, null);
+  assert.deepEqual(result, { ok: true, installed: false });
+});
+
+test('ensureSelectedTtsBackendInstalled triggers install when mlxaudio binary missing', async () => {
+  const calls = [];
+  const speakCalls = [];
+  const persisted = [];
+  const deps = makeDeps({
+    execFileAsync: async (...args) => { calls.push(args); return { stdout: '', stderr: '' }; },
+    speakText: async msg => { speakCalls.push(msg); },
+    persistEnvValues: v => persisted.push(v),
+  });
+  const prev = process.env.MLXAUDIO_PYTHON;
+  process.env.MLXAUDIO_PYTHON = '/path/that/does/not/exist/mlxaudio';
+  try {
+    const { ensureSelectedTtsBackendInstalled } = createTtsRuntime(deps);
+    const result = await ensureSelectedTtsBackendInstalled({ backend: 'mlxaudio' }, null);
+    assert.equal(result.ok, true);
+    assert.equal(result.installed, true);
+    assert.equal(calls.length, 1, 'bash install script invoked once');
+    assert.match(calls[0][0], /bash/);
+    assert.ok(calls[0][1][0].endsWith('install_mlxaudio.sh'));
+    assert.equal(persisted.length, 1);
+    assert.equal(persisted[0].MLXAUDIO_PYTHON, './.venv-mlxaudio/bin/python');
+  } finally {
+    if (prev === undefined) delete process.env.MLXAUDIO_PYTHON;
+    else process.env.MLXAUDIO_PYTHON = prev;
+  }
+});
+
+test('ensureSelectedTtsBackendInstalled reports install failure', async () => {
+  const deps = makeDeps({
+    execFileAsync: async () => { const e = new Error('install boom'); e.stderr = 'boom'; throw e; },
+  });
+  const prev = process.env.MLXAUDIO_PYTHON;
+  process.env.MLXAUDIO_PYTHON = '/path/that/does/not/exist/mlxaudio';
+  try {
+    const { ensureSelectedTtsBackendInstalled } = createTtsRuntime(deps);
+    const result = await ensureSelectedTtsBackendInstalled({ backend: 'mlxaudio' }, null);
+    assert.equal(result.ok, false);
+    assert.equal(result.installed, false);
+    assert.ok(result.error);
+  } finally {
+    if (prev === undefined) delete process.env.MLXAUDIO_PYTHON;
+    else process.env.MLXAUDIO_PYTHON = prev;
+  }
+});
+
+test('commandIsInstalled returns false for empty input', () => {
+  const { commandIsInstalled } = createTtsRuntime(makeDeps());
+  assert.equal(commandIsInstalled(''), false);
+  assert.equal(commandIsInstalled(null), false);
+});
+
+test('commandIsInstalled caches results per binary on bridge', () => {
+  const deps = makeDeps();
+  const { commandIsInstalled } = createTtsRuntime(deps);
+  // Probe with a binary name extremely unlikely to exist
+  commandIsInstalled('vc-test-no-such-binary-xyz123');
+  assert.ok(deps.bridge.installedBinaryCache.has('vc-test-no-such-binary-xyz123'));
+  assert.equal(deps.bridge.installedBinaryCache.get('vc-test-no-such-binary-xyz123'), false);
+});

package/app-node/tts_settings.mjs

@@ -1,5 +1,56 @@
 import path from 'node:path';
 
+export const SUPPORTED_TTS_BACKENDS = [
+  'edge',
+  'openvoice',
+  'speechswift',
+  'supertonic',
+  'omnivoice',
+  'qwen3tts',
+  'mlxaudio',
+  'fireredtts2',
+  'mossttsnano',
+  'mossttsnano_mlx',
+  'neuttsair',
+];
+
+export const TTS_BACKEND_ALIASES = new Map([
+  ['q3', 'qwen3tts'],
+  ['qwen3', 'qwen3tts'],
+  ['qwen3-tts', 'qwen3tts'],
+  ['qtts', 'qwen3tts'],
+  ['mlx', 'mlxaudio'],
+  ['mlx-audio', 'mlxaudio'],
+  ['qwen3-mlx', 'mlxaudio'],
+  ['neutts', 'neuttsair'],
+  ['neutts-air', 'neuttsair'],
+  ['neutts air', 'neuttsair'],
+  ['neuttsair', 'neuttsair'],
+  ['neu-tts-air', 'neuttsair'],
+  ['neu tts air', 'neuttsair'],
+  ['neutts-air-backend', 'neuttsair'],
+  ['firered', 'fireredtts2'],
+  ['fireredtts', 'fireredtts2'],
+  ['firered-tts-2', 'fireredtts2'],
+  ['fireredtts-2', 'fireredtts2'],
+  ['moss', 'mossttsnano'],
+  ['moss-tts', 'mossttsnano'],
+  ['mossnano', 'mossttsnano'],
+  ['moss-tts-nano', 'mossttsnano'],
+  ['openmoss', 'mossttsnano'],
+  ['moss-mlx', 'mossttsnano_mlx'],
+  ['moss mlx', 'mossttsnano_mlx'],
+  ['mossttsnano-mlx', 'mossttsnano_mlx'],
+  ['mossttsnano_mlx', 'mossttsnano_mlx'],
+  ['openmoss-mlx', 'mossttsnano_mlx'],
+]);
+
+export function normalizeTtsBackendName(value, fallback = 'edge') {
+  const requested = String(value || '').trim().toLowerCase();
+  const normalized = TTS_BACKEND_ALIASES.get(requested) || requested;
+  return SUPPORTED_TTS_BACKENDS.includes(normalized) ? normalized : fallback;
+}
+
 function boolEnv(value, fallback = false) {
   if (value == null || value === '') return fallback;
   return ['1', 'true', 'yes', 'on'].includes(String(value).toLowerCase());
@@ -16,9 +67,7 @@ function resolveUnderRoot(root, value, fallback) {
 }
 
 export function buildTtsSettings(env = process.env, root = process.cwd()) {
-  const requestedBackend = String(env.TTS_BACKEND || 'edge').trim().toLowerCase();
-  const supportedBackends = new Set(['edge', 'openvoice', 'speechswift', 'supertonic']);
-  const backend = supportedBackends.has(requestedBackend) ? requestedBackend : 'edge';
+  const backend = normalizeTtsBackendName(env.TTS_BACKEND || 'edge');
   return {
     backend,
     maxChars: positiveNumber(env.TTS_MAX_CHARS, 495),
@@ -68,5 +117,103 @@ export function buildTtsSettings(env = process.env, root = process.cwd()) {
       intraOpThreads: env.SUPERTONIC_INTRA_OP_THREADS || '',
       interOpThreads: env.SUPERTONIC_INTER_OP_THREADS || '',
     },
+    omnivoice: {
+      python: resolveUnderRoot(root, env.OMNIVOICE_PYTHON, path.join('.venv-omnivoice', 'bin', 'python')),
+      model: env.OMNIVOICE_MODEL || 'k2-fsa/OmniVoice',
+      device: env.OMNIVOICE_DEVICE || 'mps',
+      dtype: env.OMNIVOICE_DTYPE || 'float16',
+      refAudio: resolveUnderRoot(root, env.OMNIVOICE_REF_AUDIO || env.OPENVOICE_REF_AUDIO, path.join('voice-samples', 'user-reference.wav')),
+      refText: env.OMNIVOICE_REF_TEXT || '',
+      language: env.OMNIVOICE_LANGUAGE || env.VOICE_LANGUAGE || 'ko',
+      speaker: env.OMNIVOICE_SPEAKER || '',
+      timeoutMs: positiveNumber(env.OMNIVOICE_TIMEOUT_MS, 180000),
+      useForProgress: boolEnv(env.OMNIVOICE_PROGRESS, false),
+    },
+    qwen3tts: {
+      command: env.QWEN3TTS_COMMAND || env.QTTS_COMMAND || 'audio',
+      mode: env.QWEN3TTS_MODE || 'custom',
+      model: env.QWEN3TTS_MODEL || '',
+      language: env.QWEN3TTS_LANGUAGE || env.VOICE_LANGUAGE || 'korean',
+      speaker: env.QWEN3TTS_SPEAKER || 'sohee',
+      instruct: env.QWEN3TTS_INSTRUCT || '',
+      refAudio: env.QWEN3TTS_REF_AUDIO ? resolveUnderRoot(root, env.QWEN3TTS_REF_AUDIO, '') : '',
+      refText: env.QWEN3TTS_REF_TEXT || '',
+      stream: boolEnv(env.QWEN3TTS_STREAM, true),
+      timeoutMs: positiveNumber(env.QWEN3TTS_TIMEOUT_MS, 120000),
+      useForProgress: boolEnv(env.QWEN3TTS_PROGRESS, false),
+    },
+    mlxaudio: {
+      python: resolveUnderRoot(root, env.MLXAUDIO_PYTHON, path.join('.venv-mlxaudio', 'bin', 'python')),
+      model: env.MLXAUDIO_MODEL || 'mlx-community/Qwen3-TTS-12Hz-1.7B-Base-8bit',
+      voice: env.MLXAUDIO_VOICE || 'Chelsie',
+      langCode: env.MLXAUDIO_LANG_CODE || env.VOICE_LANGUAGE || 'ko',
+      stream: boolEnv(env.MLXAUDIO_STREAM, false),
+      timeoutMs: positiveNumber(env.MLXAUDIO_TIMEOUT_MS, 180000),
+      useForProgress: boolEnv(env.MLXAUDIO_PROGRESS, false),
+    },
+    neuttsair: {
+      python: resolveUnderRoot(root, env.NEUTTSAIR_PYTHON || env.NEUTTS_AIR_PYTHON, path.join('.venv-neuttsair', 'bin', 'python')),
+      script: resolveUnderRoot(root, env.NEUTTSAIR_SCRIPT || env.NEUTTS_AIR_SCRIPT, path.join('integrations', 'neuttsair', 'synth.py')),
+      backboneRepo: env.NEUTTSAIR_BACKBONE_REPO || env.NEUTTS_AIR_BACKBONE_REPO || env.NEUTTSAIR_BACKBONE || 'neuphonic/neutts-air-q4-gguf',
+      backboneDevice: env.NEUTTSAIR_BACKBONE_DEVICE || env.NEUTTS_AIR_BACKBONE_DEVICE || env.NEUTTSAIR_DEVICE || 'mps',
+      codecRepo: env.NEUTTSAIR_CODEC_REPO || env.NEUTTS_AIR_CODEC_REPO || env.NEUTTSAIR_CODEC || 'neuphonic/neucodec',
+      codecDevice: env.NEUTTSAIR_CODEC_DEVICE || env.NEUTTS_AIR_CODEC_DEVICE || env.NEUTTSAIR_DEVICE || 'mps',
+      refAudio: resolveUnderRoot(root, env.NEUTTSAIR_REF_AUDIO || env.NEUTTS_AIR_REF_AUDIO || env.OPENVOICE_REF_AUDIO, path.join('voice-samples', 'user-reference.wav')),
+      refText: env.NEUTTSAIR_REF_TEXT || env.NEUTTS_AIR_REF_TEXT || '',
+      refTextFile: (env.NEUTTSAIR_REF_TEXT_FILE || env.NEUTTS_AIR_REF_TEXT_FILE) ? resolveUnderRoot(root, env.NEUTTSAIR_REF_TEXT_FILE || env.NEUTTS_AIR_REF_TEXT_FILE, '') : '',
+      language: env.NEUTTSAIR_LANGUAGE || env.NEUTTS_AIR_LANGUAGE || env.VOICE_LANGUAGE || 'en',
+      sampleRate: positiveNumber(env.NEUTTSAIR_SAMPLE_RATE || env.NEUTTS_AIR_SAMPLE_RATE, 24000),
+      cacheRef: boolEnv(env.NEUTTSAIR_CACHE_REF || env.NEUTTS_AIR_CACHE_REF, true),
+      timeoutMs: positiveNumber(env.NEUTTSAIR_TIMEOUT_MS || env.NEUTTS_AIR_TIMEOUT_MS, 120000),
+      useForProgress: boolEnv(env.NEUTTSAIR_PROGRESS || env.NEUTTS_AIR_PROGRESS, false),
+    },
+    fireredtts2: {
+      command: env.FIREREDTTS2_COMMAND || './.local/bin/fireredtts2',
+      pretrainedDir: resolveUnderRoot(root, env.FIREREDTTS2_PRETRAINED_DIR, path.join('pretrained_models', 'FireRedTTS2')),
+      device: env.FIREREDTTS2_DEVICE || 'auto',
+      genType: env.FIREREDTTS2_GEN_TYPE || 'monologue',
+      speaker: env.FIREREDTTS2_SPEAKER || 'S1',
+      promptAudio: env.FIREREDTTS2_PROMPT_AUDIO ? resolveUnderRoot(root, env.FIREREDTTS2_PROMPT_AUDIO, '') : '',
+      promptText: env.FIREREDTTS2_PROMPT_TEXT || '',
+      useBf16: boolEnv(env.FIREREDTTS2_BF16, false),
+      timeoutMs: positiveNumber(env.FIREREDTTS2_TIMEOUT_MS, 180000),
+      useForProgress: boolEnv(env.FIREREDTTS2_PROGRESS, false),
+    },
+    mossttsnano: {
+      command: env.MOSSTTSNANO_COMMAND || './.venv-mossttsnano/bin/python',
+      script: resolveUnderRoot(root, env.MOSSTTSNANO_SCRIPT, path.join('vendor', 'MOSS-TTS-Nano', 'infer.py')),
+      checkpoint: env.MOSSTTSNANO_CHECKPOINT || env.MOSS_TTS_NANO_CHECKPOINT || 'OpenMOSS-Team/MOSS-TTS-Nano',
+      audioTokenizer: env.MOSSTTSNANO_AUDIO_TOKENIZER || env.MOSS_TTS_NANO_AUDIO_TOKENIZER || '',
+      mode: env.MOSSTTSNANO_MODE || 'continuation',
+      language: env.MOSSTTSNANO_LANGUAGE || env.VOICE_LANGUAGE || 'ko',
+      device: env.MOSSTTSNANO_DEVICE || 'auto',
+      dtype: env.MOSSTTSNANO_DTYPE || 'auto',
+      promptAudio: env.MOSSTTSNANO_PROMPT_AUDIO ? resolveUnderRoot(root, env.MOSSTTSNANO_PROMPT_AUDIO, '') : '',
+      promptText: env.MOSSTTSNANO_PROMPT_TEXT || '',
+      maxNewFrames: positiveNumber(env.MOSSTTSNANO_MAX_NEW_FRAMES, 375),
+      seed: env.MOSSTTSNANO_SEED || '',
+      timeoutMs: positiveNumber(env.MOSSTTSNANO_TIMEOUT_MS, 120000),
+      useForProgress: boolEnv(env.MOSSTTSNANO_PROGRESS, false),
+    },
+    mossttsnano_mlx: {
+      python: env.MOSSTTSNANO_MLX_PYTHON || env.MOSSTTSNANO_COMMAND || './.venv-mossttsnano/bin/python',
+      script: resolveUnderRoot(root, env.MOSSTTSNANO_MLX_SCRIPT, path.join('integrations', 'mossttsnano_mlx', 'synth.py')),
+      workerScript: resolveUnderRoot(root, env.MOSSTTSNANO_MLX_WORKER_SCRIPT, path.join('integrations', 'mossttsnano_mlx', 'worker.py')),
+      workerEnabled: boolEnv(env.MOSSTTSNANO_MLX_WORKER, false),
+      workerStartupTimeoutMs: positiveNumber(env.MOSSTTSNANO_MLX_WORKER_STARTUP_TIMEOUT_MS, 120000),
+      torchInferScript: resolveUnderRoot(root, env.MOSSTTSNANO_SCRIPT, path.join('vendor', 'MOSS-TTS-Nano', 'infer.py')),
+      checkpoint: env.MOSSTTSNANO_CHECKPOINT || env.MOSS_TTS_NANO_CHECKPOINT || 'OpenMOSS-Team/MOSS-TTS-Nano',
+      audioTokenizer: env.MOSSTTSNANO_AUDIO_TOKENIZER || env.MOSS_TTS_NANO_AUDIO_TOKENIZER || 'OpenMOSS-Team/MOSS-Audio-Tokenizer-Nano',
+      mode: env.MOSSTTSNANO_MODE || 'voice_clone',
+      language: env.MOSSTTSNANO_LANGUAGE || env.VOICE_LANGUAGE || 'ko',
+      torchDevice: env.MOSSTTSNANO_TORCH_DEVICE || env.MOSSTTSNANO_DEVICE || 'cpu',
+      torchDtype: env.MOSSTTSNANO_TORCH_DTYPE || env.MOSSTTSNANO_DTYPE || 'float32',
+      promptAudio: env.MOSSTTSNANO_PROMPT_AUDIO ? resolveUnderRoot(root, env.MOSSTTSNANO_PROMPT_AUDIO, '') : '',
+      promptText: env.MOSSTTSNANO_PROMPT_TEXT || '',
+      maxNewFrames: positiveNumber(env.MOSSTTSNANO_MAX_NEW_FRAMES, 120),
+      seed: env.MOSSTTSNANO_SEED || '',
+      timeoutMs: positiveNumber(env.MOSSTTSNANO_MLX_TIMEOUT_MS || env.MOSSTTSNANO_TIMEOUT_MS, 180000),
+      useForProgress: boolEnv(env.MOSSTTSNANO_MLX_PROGRESS || env.MOSSTTSNANO_PROGRESS, false),
+    },
   };
 }