@chatpanel/gateway 0.6.51 → 0.6.52

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatpanel/gateway",
-  "version": "0.6.51",
+  "version": "0.6.52",
   "description": "Local privacy gateway — redacts PII out of OpenAI/Anthropic API traffic before it reaches a model, then restores it in the reply. Point opencode, codex, aider, Claude Code, etc. at it.",
   "type": "module",
   "bin": {

package/src/server.js

@@ -52,7 +52,7 @@ import * as openai from './openai.js';
 import * as responses from './responses.js';
 import * as anthropic from './anthropic.js';
 
-export const VERSION = '0.6.51';
+export const VERSION = '0.6.52';
 
 // WARM search tier — SQLite + FTS5 record store (falls back to an encrypted-JSON
 // store if SQLite can't load), fed by the extension's ingest sync + backup-ingest.
@@ -981,8 +981,13 @@ export function createGateway(cfg = loadConfig()) {
           progress: ttsEngine.progress(),
           available,
           voice: cfg.tts?.voice || DEFAULT_TTS_VOICE,
-          // Each voice is a separate ~500 KB style bank, so `installed` is per-voice.
-          voices: TTS_VOICES.map((v) => ({ ...v, installed: ttsEngine.voiceOnDisk(v.id, active) })),
+          // Architecture decides whether voices mean anything: Kokoro picks one from
+          // a style bank, VITS/MMS is single-speaker. An empty list tells the UI to
+          // hide the picker rather than offer choices that cannot take effect.
+          arch: ttsEngine.arch(),
+          supportsVoices: ttsEngine.supportsVoices(),
+          sampleRate: ttsEngine.sampleRate(),
+          voices: ttsEngine.arch() === 'vits' ? [] : TTS_VOICES.map((v) => ({ ...v, installed: ttsEngine.voiceOnDisk(v.id, active) })),
           dtype: cfg.tts?.dtype || 'auto',
           loadedDtype: ttsEngine.health().dtype,
           runtime: ttsEngine.health().runtime,
@@ -1069,12 +1074,15 @@ export function createGateway(cfg = loadConfig()) {
         });
         if (!ok) return sendJson(res, 503, { error: { message: ttsEngine.health().error || 'tts model not ready', type: 'tts_unavailable' } });
         const pcm = await ttsEngine.synth(text, { voice, speed });
-        const out = fmt === 'pcm' ? Buffer.from(new Float32Array(pcm).buffer) : ttsEngine.toWav(pcm);
+        // The ACTIVE model's rate, not the constant: a VITS/MMS model emits 16 kHz
+        // and writing it into a 24 kHz header plays it fast and chipmunked.
+        const rate = ttsEngine.sampleRate();
+        const out = fmt === 'pcm' ? Buffer.from(new Float32Array(pcm).buffer) : ttsEngine.toWav(pcm, rate);
         res.writeHead(200, {
           'Content-Type': fmt === 'pcm' ? 'application/octet-stream' : 'audio/wav',
           'Content-Length': String(out.length),
           'Cache-Control': 'no-store',
-          'X-Tts-Sample-Rate': String(ttsEngine.SAMPLE_RATE),
+          'X-Tts-Sample-Rate': String(rate),
         });
         return res.end(out);
       } catch (e) {

package/src/tts-engine.js

@@ -27,7 +27,11 @@ import {
   ttsModelDtype, isKnownTtsModel, isValidVoiceId, voiceLang,
 } from './tts-models.js';
 
-export const SAMPLE_RATE = 24000; // Kokoro's output rate — fixed by the model
+// Kokoro's rate. Kept as a named export because it is the default and several
+// callers want a number before anything is loaded — but it is NOT universal: a
+// VITS/MMS model outputs 16 kHz, and writing its samples into a 24 kHz WAV header
+// plays it back fast and chipmunked. Use sampleRate() once a model is active.
+export const SAMPLE_RATE = 24000;
 
 let _state = 'off';       // 'off' | 'loading' | 'downloading' | 'ready' | 'error'
 let _model = null;
@@ -37,14 +41,27 @@ let _dtype = null;
 let _err = null;
 let _progress = null;
 let _initPromise = null;
+let _arch = null;         // 'style-tts2' (Kokoro) | 'vits' (MMS et al)
+let _rate = SAMPLE_RATE;  // the ACTIVE model's output rate
 const _voices = new Map(); // voice id → Float32Array style bank
 
+// The architectures this engine can actually drive. Anything else is refused at
+// load with a message naming what it is, rather than failing later inside a
+// forward pass with a shape error nobody can act on.
+export const SUPPORTED_ARCH = { style_text_to_speech_2: 'style-tts2', vits: 'vits' };
+
+export function arch() { return _arch; }
+export function sampleRate() { return _rate; }
+// Kokoro picks a voice from a style bank; VITS is single-speaker and has none, so
+// the UI must not offer a voice list that cannot do anything.
+export function supportsVoices() { return _arch === 'style-tts2'; }
+
 export function state() { return _state; }
 export function isReady() { return _state === 'ready' && !!_net; }
 export function progress() { return _progress; }
 
 export function health() {
-  return { configured: _state !== 'off', ok: isReady(), state: _state, model: _model, dtype: _dtype, runtime: runtimeName(), error: _err };
+  return { configured: _state !== 'off', ok: isReady(), state: _state, model: _model, dtype: _dtype, runtime: runtimeName(), error: _err, arch: _arch, sampleRate: _rate, voices: supportsVoices() };
 }
 
 export function modelDir(modelId) {
@@ -119,18 +136,32 @@ async function loadModel(modelId, { log = () => {}, allowDownload = true, dtype:
     // this is the SAME transformers instance ensureLib already configured (env,
     // cacheDir, wasm paths) — importing it here keeps ner-engine free of TTS.
     const tf = await import('@huggingface/transformers');
+
+    // Which architecture is this? Read the config BEFORE choosing a class, so an
+    // unsupported model is refused by name instead of exploding inside a forward
+    // pass with a tensor-shape error.
+    let modelType = '';
+    try {
+      const conf = await tf.AutoConfig.from_pretrained(modelId);
+      modelType = String(conf?.model_type || '').toLowerCase();
+    } catch { /* no config we can read — fall through to the Kokoro default */ }
+    const kind = SUPPORTED_ARCH[modelType] || (modelType ? null : 'style-tts2');
+    if (!kind) throw new Error(`unsupported TTS architecture "${modelType}" — this engine drives Kokoro (style_text_to_speech_2) and VITS/MMS`);
+
+    const onProgress = (p) => {
+      if (p?.status === 'progress' && p.file) _progress = { model: modelId, file: p.file, pct: Math.round(p.progress || 0) };
+    };
+    const Klass = kind === 'vits' ? tf.VitsModel : tf.StyleTextToSpeech2Model;
     const [net, tok] = await Promise.all([
-      tf.StyleTextToSpeech2Model.from_pretrained(modelId, {
-        dtype,
-        progress_callback: (p) => {
-          if (p?.status === 'progress' && p.file) _progress = { model: modelId, file: p.file, pct: Math.round(p.progress || 0) };
-        },
-      }),
+      Klass.from_pretrained(modelId, { dtype, progress_callback: onProgress }),
       tf.AutoTokenizer.from_pretrained(modelId),
     ]);
-    _net = net; _tok = tok; _model = modelId; _dtype = dtype;
+    _net = net; _tok = tok; _model = modelId; _dtype = dtype; _arch = kind;
+    // VITS/MMS emit 16 kHz; Kokoro 24 kHz. Take it from the model's own config
+    // where it says so, because guessing wrong plays the voice at the wrong pitch.
+    _rate = Number(net?.config?.sampling_rate) || (kind === 'vits' ? 16000 : SAMPLE_RATE);
     _state = 'ready'; _err = null; _progress = null;
-    log(`[tts] ready — model ${modelId} @ ${dtype} (${runtimeName()}, offline) — local speech active`);
+    log(`[tts] ready — model ${modelId} @ ${dtype} (${kind}, ${_rate} Hz, ${runtimeName()}, offline) — local speech active`);
     return true;
   } catch (e) {
     // A failed SWITCH keeps the previous working model, same as ner/stt.
@@ -231,9 +262,19 @@ export function splitSentences(text, maxChars = 300) {
  */
 export async function synthChunk(text, { voice = DEFAULT_TTS_VOICE, speed = 1 } = {}) {
   if (!isReady()) throw new Error('tts model not ready');
-  const { phonemize } = await import('phonemizer');
   const tf = await import('@huggingface/transformers');
 
+  // VITS/MMS: single-speaker, tokenizes GRAPHEMES directly — no phonemizer, no
+  // style bank, no speed input. One language per model, which is the trade for
+  // ~40 MB and a thousand of them.
+  if (_arch === 'vits') {
+    const inputs = _tok(String(text));
+    const out = await _net(inputs);
+    return out.waveform.data;
+  }
+
+  const { phonemize } = await import('phonemizer');
+
   // G2P follows the VOICE, not the request — an American voice reading British
   // phonemes is audibly wrong.
   const phonemes = (await phonemize(String(text), voiceLang(voice))).join(' ');
@@ -296,5 +337,6 @@ export function toWav(pcm, sampleRate = SAMPLE_RATE) {
 
 export function _reset() {
   _state = 'off'; _model = null; _net = null; _tok = null; _dtype = null;
-  _err = null; _progress = null; _initPromise = null; _voices.clear();
+  _err = null; _progress = null; _initPromise = null; _arch = null; _rate = SAMPLE_RATE;
+  _voices.clear();
 }

package/src/tts-models.js

@@ -40,8 +40,37 @@ export const TTS_MODEL_CATALOG = [
     approxMB: 330,  // fp32 on WASM; ~90 on native q8
     ramMB: 600,
     sampleRate: 24000,
+    voices: true,
     note: 'Apache-2.0, 82M params. Natural voices at ~5× realtime on CPU. The default.',
   },
+  {
+    id: 'onnx-community/Kokoro-82M-v1.1-zh-ONNX',
+    label: 'Kokoro 82M (v1.1, Chinese)',
+    lang: 'Chinese + English',
+    tier: 'balanced',
+    arch: 'style-tts2',
+    approxMB: 330,
+    ramMB: 600,
+    sampleRate: 24000,
+    voices: true,
+    note: 'The Mandarin-tuned Kokoro. Same engine and voice mechanism as v1.0.',
+  },
+  {
+    // One MMS entry so the second architecture is DISCOVERABLE from the list rather
+    // than only findable by search. The rest of the family (~1000 languages) is
+    // exactly what the search box is for — listing them all here would be a menu,
+    // not a catalog.
+    id: 'Xenova/mms-tts-hin',
+    label: 'MMS TTS — Hindi',
+    lang: 'Hindi (हिन्दी)',
+    tier: 'light',
+    arch: 'vits',
+    approxMB: 40,
+    ramMB: 200,
+    sampleRate: 16000,
+    voices: false,
+    note: 'Tiny single-speaker VITS. Meta\u2019s MMS covers ~1000 languages — search "mms-tts" for yours.',
+  },
 ];
 
 // Voice prefix → the language phonemizer must use for G2P. First letter = language,
@@ -84,7 +113,14 @@ export const TTS_VOICES = [
 // THIRD-PARTY re-export of a gated checkpoint. That is a parakeet-engine-sized
 // piece of work, not a catalog entry — so the seam is here and the engine is not.
 export function ttsModelEngine(id) {
-  return ttsModel(id)?.engine || 'style-tts2';
+  return ttsModel(id)?.arch || 'style-tts2';
+}
+
+// Does this catalog entry have selectable voices? Kokoro picks one from a style
+// bank; VITS/MMS is single-speaker. Unknown (a searched model) resolves at load.
+export function ttsModelHasVoices(id) {
+  const m = ttsModel(id);
+  return m ? m.voices !== false : true;
 }
 
 export function ttsModel(id) {