@chatpanel/gateway 0.6.58 → 0.6.60

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatpanel/gateway",
-  "version": "0.6.58",
+  "version": "0.6.60",
   "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

@@ -44,6 +44,7 @@ import { TTS_MODEL_CATALOG, TTS_VOICES, isKnownTtsModel, isValidCustomTtsId, isK
 import { ttsDestination, synthesizeRemote, isValidRemoteVoice } from './tts-remote.js';
 import { rawOrtAvailable } from './ort.js';
 import * as ttsVoices from './tts-voices.js';
+import { resolveTtsVoice } from './tts-voice-resolve.js';
 import { resolvePro, checkQuota, consume, usage } from './freegate.js';
 import { publicConfig, applyConfigPatch, applyNerModelSelection, persistConfig, configPath } from './configstore.js';
 import { resolveDestination, aggregateModelsAsync, listDestinations } from './router.js';
@@ -54,7 +55,7 @@ import * as openai from './openai.js';
 import * as responses from './responses.js';
 import * as anthropic from './anthropic.js';
 
-export const VERSION = '0.6.58';
+export const VERSION = '0.6.60';
 
 // 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.
@@ -1078,8 +1079,15 @@ export function createGateway(cfg = loadConfig()) {
           const curId = ttsVoices.parseCustomVoice(cfg.tts.voice || '');
           const isCustom = !!(curId && ttsVoices.getVoice(curId));
           if (wantsCustom && !isCustom) {
-            const saved = ttsVoices.listVoices();
-            cfg.tts.voice = saved.length ? `custom:${saved[0].id}` : '';
+            // Switching to a cloning model does not mean "start speaking as the user".
+            // A model with built-in speakers gets its default speaker; only SpeechT5,
+            // which has no built-ins, falls back to a saved voice.
+            if (ttsModelEngineOf(id) === 'pocket-tts') {
+              cfg.tts.voice = DEFAULT_POCKET_VOICE;
+            } else {
+              const saved = ttsVoices.listVoices();
+              cfg.tts.voice = saved.length ? `custom:${saved[0].id}` : '';
+            }
           } else if (!wantsCustom && isCustom) {
             cfg.tts.voice = DEFAULT_TTS_VOICE;
           }
@@ -1280,76 +1288,13 @@ export function createGateway(cfg = loadConfig()) {
         // SpeechT5 takes a recorded embedding, VITS takes neither. Resolving first
         // meant a `custom:` voice could reach a freshly-loaded Kokoro and fail deep
         // in the engine with "invalid voice id".
-        let useVoice = voice;
-        let speakerEmbedding = null;
-        let customId = ttsVoices.parseCustomVoice(voice);
-
-        // A Pocket built-in speaker is a NAME, not an embedding, so it has to be
-        // recognised before the custom-voice path — which would otherwise demand a
-        // recording for a model that ships eight voices of its own.
-        if (ttsEngine.isPocket() && isPocketVoice(rawVoice || useVoice)) {
-          useVoice = rawVoice || useVoice;
-          customId = null;
-        } else if (ttsEngine.supportsCustomVoices()) {
-          // This model speaks ONLY in a recorded voice. If the configured one names
-          // a built-in (switching model does not rewrite `voice`) or points at a
-          // voice since deleted, fall back to the most recent saved one — the
-          // caller asked to be spoken to, not for that exact voice. A voice named
-          // EXPLICITLY in the request still fails loudly.
-          let rec = customId ? ttsVoices.getVoice(customId) : null;
-          if (!rec && !rawVoice) {
-            const saved = ttsVoices.listVoices();
-            if (saved.length) { customId = saved[0].id; rec = ttsVoices.getVoice(customId); }
-            // Pocket can fall back to a built-in speaker; SpeechT5 has none, so for
-            // that one "no saved voice" really is the end of the road.
-            else if (ttsEngine.isPocket()) { useVoice = DEFAULT_POCKET_VOICE; customId = null; }
-          }
-          if (!rec && !customId && ttsEngine.isPocket()) {
-            // resolved to a built-in above — nothing more to look up
-          } else if (!rec) {
-            return sendJson(res, customId ? 404 : 400, {
-              error: {
-                message: customId ? 'no such saved voice' : 'this model speaks in a voice you record — add one in Settings → Text-to-speech',
-                type: 'bad_voice',
-              },
-            });
-          }
-          // Which print to hand over depends on the engine: Pocket TTS takes its
-          // Mimi conditioning, SpeechT5 the 512-d x-vector. A voice saved before
-          // the pocket bundle existed has only the latter.
-          if (ttsEngine.isPocket()) {
-            const pk = ttsVoices.getPocketVoice(customId);
-            if (!pk) {
-              return sendJson(res, 409, {
-                error: {
-                  message: 'this voice was saved without a Pocket TTS conditioning — record it again with Pocket TTS selected',
-                  type: 'voice_kind_missing',
-                },
-              });
-            }
-            speakerEmbedding = pk;
-          } else {
-            speakerEmbedding = rec.vec;
-          }
-          useVoice = `custom:${customId}`;
-        } else if (customId) {
-          // Explicitly asked for a recorded voice this model cannot use — say so.
-          // Inherited from config, though, it is just a stale setting, and refusing
-          // to speak at all is a worse answer than speaking in the default voice.
-          if (rawVoice) {
-            return sendJson(res, 409, {
-              error: { message: `the active model (${ttsEngine.arch()}) cannot use a recorded voice — switch to SpeechT5`, type: 'voice_unsupported' },
-            });
-          }
-          customId = null;
-          useVoice = DEFAULT_TTS_VOICE;
-        } else if (ttsEngine.isPocket() && !isPocketVoice(useVoice)) {
-          // Pocket has its own speaker namespace; a Kokoro voice name here means the
-          // config was carried over from another model, so fall back to its default.
-          useVoice = DEFAULT_POCKET_VOICE;
-        } else if (ttsEngine.supportsVoices() && !ttsEngine.isPocket() && !(isKnownVoice(useVoice) && isValidVoiceId(useVoice))) {
-          return sendJson(res, 400, { error: { message: 'unknown or invalid voice', type: 'bad_voice' } });
-        }
+        const picked = resolveTtsVoice({
+          requested: rawVoice, configured: voice, engine: ttsEngine, voices: ttsVoices,
+          isPocketVoice, isKnownVoice, isValidVoiceId,
+          defaultVoice: DEFAULT_TTS_VOICE, defaultPocketVoice: DEFAULT_POCKET_VOICE,
+        });
+        if (!picked.ok) return sendJson(res, picked.status, { error: { message: picked.message, type: picked.type } });
+        const { voice: useVoice, customId, speakerEmbedding } = picked;
 
         const pcm = await ttsEngine.synth(text, { voice: useVoice, speed, speakerEmbedding });
         // The ACTIVE model's rate, not the constant: a VITS/MMS model emits 16 kHz
@@ -1361,7 +1306,9 @@ export function createGateway(cfg = loadConfig()) {
           'Content-Length': String(out.length),
           'Cache-Control': 'no-store',
           'X-Tts-Sample-Rate': String(rate),
-          ...(customId ? { 'X-Tts-Voice': `custom:${customId}` } : {}),
+          // Say which voice actually spoke, so a caller (or a person debugging one)
+          // can check the setting took. Single-speaker models have nothing to say.
+          ...(customId || ttsEngine.isPocket() || ttsEngine.supportsVoices() ? { 'X-Tts-Voice': useVoice } : {}),
         });
         return res.end(out);
       } catch (e) {
@@ -1389,7 +1336,9 @@ export function createGateway(cfg = loadConfig()) {
         // same composable model as everything else: any stage, with or without).
         // `diarize: true` (+ optional `speakerLabel` to pin the mic channel to a
         // name) attaches a speaker to each final.
-        const { id } = sttEngine.createSession({ lang: body?.lang, redact: body?.redact === true, diarize: wantDiarize, speakerLabel: body?.speakerLabel });
+        // `endSilenceMs` (additive) lets a voice conversation wait longer for a
+        // sentence to finish than dictation into a text box needs to.
+        const { id } = sttEngine.createSession({ lang: body?.lang, redact: body?.redact === true, diarize: wantDiarize, speakerLabel: body?.speakerLabel, endSilenceMs: body?.endSilenceMs });
         return sendJson(res, 201, { id, state: sttEngine.state() });
       } catch (e) {
         return sendJson(res, e.code === 'too_many_sessions' ? 429 : 500, { error: { message: e.message, type: e.code || 'stt_error' } });

package/src/stt-engine.js

@@ -238,13 +238,26 @@ let _decodeChain = Promise.resolve(); // whisper is effectively single-threaded
 export function sessionCount() { return _sessions.size; }
 
 /** @param {{ lang?: string, redact?: boolean, diarize?: boolean, speakerLabel?: string }} [opts] */
-export function createSession({ lang, redact = false, diarize: diarizeOpt = false, speakerLabel = null } = {}) {
+// How long a pause commits a segment. The default suits dictation into a text box,
+// where a final just appends and a short pause costs nothing. In a VOICE
+// conversation every final is SENT as a question, so a 700ms pause mid-thought
+// ("I want to… um… go to Google") sends half a sentence. Callers may ask for more.
+const END_SILENCE_MIN_MS = 300;
+const END_SILENCE_MAX_MS = 3000;
+export function clampEndSilence(ms) {
+  const n = Number(ms);
+  if (!Number.isFinite(n)) return SILENCE_FINAL_MS;
+  return Math.min(END_SILENCE_MAX_MS, Math.max(END_SILENCE_MIN_MS, Math.round(n)));
+}
+
+export function createSession({ lang, redact = false, diarize: diarizeOpt = false, speakerLabel = null, endSilenceMs = SILENCE_FINAL_MS } = {}) {
   if (_sessions.size >= MAX_SESSIONS) {
     const e = /** @type {Error & { code?: string }} */ (new Error('too many concurrent dictation sessions'));
     e.code = 'too_many_sessions'; throw e;
   }
   const s = {
     id: randomUUID(),
+    endSilenceMs: clampEndSilence(endSilenceMs),
     lang: typeof lang === 'string' && lang ? lang.slice(0, 12) : null,
     langTried: false, // language auto-detect runs once per session (multilingual models)
     // Opaque to this engine: the server applies the redaction hop to finals when
@@ -374,7 +387,7 @@ async function decodeSession(s, { flush = false } = {}) {
   s.lastDecodeAt = Date.now();
 
   const audio = concatBuffer(s);
-  const tail = Math.round((SILENCE_FINAL_MS / 1000) * SAMPLE_RATE);
+  const tail = Math.round(((s.endSilenceMs || SILENCE_FINAL_MS) / 1000) * SAMPLE_RATE);
   const trailingQuiet = audio.length > tail && rms(audio, audio.length - tail) < SILENCE_RMS;
 
   // Nothing but room tone? Don't decode (whisper hallucinates on silence) and

package/src/tts-voice-resolve.js

@@ -0,0 +1,78 @@
+// Which voice a /tts request actually speaks in — decided in ONE place, with every
+// dependency injected so the table below can be tested without loading a model.
+//
+// The rule that shapes this: a saved clone is a CHOICE, never a default. Someone's
+// own voice print must not start speaking because the config was empty, named a
+// voice from another model, or pointed at a voice since deleted. A model with
+// built-in speakers (Pocket) falls back to one of those; only SpeechT5, which has
+// no built-ins, has nothing to fall back to but a recording.
+//
+// A voice named EXPLICITLY in the request never falls back — it succeeds or fails
+// loudly, so a caller that asked for a specific voice can trust what it got.
+//
+// Returns either { ok: true, voice, customId, speakerEmbedding }
+//             or { ok: false, status, type, message }.
+
+export function resolveTtsVoice({
+  requested = null,     // body.voice, or null when the caller left it to the config
+  configured,           // the voice the request would use absent an override
+  engine,               // { isPocket(), supportsCustomVoices(), supportsVoices(), arch() }
+  voices,               // { parseCustomVoice, getVoice, listVoices, getPocketVoice }
+  isPocketVoice,
+  isKnownVoice,
+  isValidVoiceId,
+  defaultVoice,         // Kokoro's default
+  defaultPocketVoice,   // Pocket's built-in default
+}) {
+  const voice = requested || configured;
+  const pocket = engine.isPocket();
+  let customId = voices.parseCustomVoice(voice);
+
+  // A Pocket built-in speaker is a NAME, not an embedding, so it is recognised
+  // before the custom-voice path — which would otherwise demand a recording for a
+  // model that ships eight voices of its own.
+  if (pocket && isPocketVoice(voice)) return { ok: true, voice, customId: null, speakerEmbedding: null };
+
+  if (engine.supportsCustomVoices()) {
+    let rec = customId ? voices.getVoice(customId) : null;
+    if (!rec && !requested) {
+      // Nothing valid was configured and nothing was asked for.
+      if (pocket) return { ok: true, voice: defaultPocketVoice, customId: null, speakerEmbedding: null };
+      const saved = voices.listVoices();
+      if (saved.length) { customId = saved[0].id; rec = voices.getVoice(customId); }
+    }
+    if (!rec) {
+      return customId
+        ? { ok: false, status: 404, type: 'bad_voice', message: 'no such saved voice' }
+        : { ok: false, status: 400, type: 'bad_voice', message: 'this model speaks in a voice you record — add one in Settings → Text-to-speech' };
+    }
+    // Which print to hand over depends on the engine: Pocket TTS takes its Mimi
+    // conditioning, SpeechT5 the 512-d x-vector. A voice saved before the pocket
+    // bundle existed has only the latter.
+    let speakerEmbedding;
+    if (pocket) {
+      speakerEmbedding = voices.getPocketVoice(customId);
+      if (!speakerEmbedding) {
+        return { ok: false, status: 409, type: 'voice_kind_missing', message: 'this voice was saved without a Pocket TTS conditioning — record it again with Pocket TTS selected' };
+      }
+    } else {
+      speakerEmbedding = rec.vec;
+    }
+    return { ok: true, voice: `custom:${customId}`, customId, speakerEmbedding };
+  }
+
+  if (customId) {
+    // Explicitly asked for a recorded voice this model cannot use — say so.
+    // Inherited from config, though, it is just a stale setting, and refusing to
+    // speak at all is a worse answer than speaking in the default voice.
+    if (requested) {
+      return { ok: false, status: 409, type: 'voice_unsupported', message: `the active model (${engine.arch()}) cannot use a recorded voice — switch to SpeechT5` };
+    }
+    return { ok: true, voice: defaultVoice, customId: null, speakerEmbedding: null };
+  }
+  if (pocket && !isPocketVoice(voice)) return { ok: true, voice: defaultPocketVoice, customId: null, speakerEmbedding: null };
+  if (engine.supportsVoices() && !pocket && !(isKnownVoice(voice) && isValidVoiceId(voice))) {
+    return { ok: false, status: 400, type: 'bad_voice', message: 'unknown or invalid voice' };
+  }
+  return { ok: true, voice, customId: null, speakerEmbedding: null };
+}