@chatpanel/gateway 0.6.57 → 0.6.59

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatpanel/gateway",
-  "version": "0.6.57",
+  "version": "0.6.59",
   "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/ort.js

@@ -40,8 +40,9 @@ export function getOrt() {
       const mod = await import('onnxruntime-node');
       return mod.InferenceSession ? mod : (mod.default || mod);
     }
-    // Say what is actually wrong. The alternative is ORT's own message, which
-    // describes a failed fetch and sends people looking for a corrupt download.
+
+    // Say what is actually wrong. ORT's own message describes a failed fetch and
+    // sends people looking for a corrupt download.
     throw new Error(
       'this model needs the native onnxruntime, which the standalone binary does not carry — '
       + 'install the npm gateway instead (npm i -g @chatpanel/gateway), or pick a model that runs on the bundled runtime',

package/src/server.js

@@ -54,7 +54,7 @@ import * as openai from './openai.js';
 import * as responses from './responses.js';
 import * as anthropic from './anthropic.js';
 
-export const VERSION = '0.6.57';
+export const VERSION = '0.6.59';
 
 // 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.
@@ -1117,7 +1117,26 @@ export function createGateway(cfg = loadConfig()) {
         try { body = JSON.parse((await readBody(req, cfg.maxBodyBytes)).toString('utf8')); } catch { body = null; }
         const name = body && typeof body.name === 'string' ? body.name.trim() : '';
         const pcm = body && Array.isArray(body.pcm) ? body.pcm : null;
-        if (!name) return sendJson(res, 400, { error: { message: 'a name is required', type: 'bad_request' } });
+        // An `id` means UPDATE an existing voice rather than create one. The id is
+        // preserved either way, because `custom:<id>` is what the config and every
+        // client hold — a rename or a re-record must not orphan those.
+        const editId = body && typeof body.id === 'string' ? body.id.trim() : '';
+        if (editId) {
+          if (!ttsVoices.getVoice(editId)) return sendJson(res, 404, { error: { message: 'no such saved voice', type: 'bad_voice' } });
+          // Rename only — no new audio, so the prints are left exactly as they are.
+          if (!pcm) {
+            if (!name) return sendJson(res, 400, { error: { message: 'a name is required', type: 'bad_request' } });
+            try {
+              return sendJson(res, 200, { ...ttsVoices.renameVoice(editId, name), usable: ttsEngine.supportsCustomVoices() });
+            } catch (e) { return sendJson(res, 400, { error: { message: e.message, type: 'rename_failed' } }); }
+          }
+          // Re-record: same rules as a fresh take, then swap the prints in place.
+          if (pcm.length < 16000) {
+            return sendJson(res, 400, { error: { message: 'need at least 1 second of 16 kHz mono audio', type: 'sample_too_short' } });
+          }
+        } else if (!name) {
+          return sendJson(res, 400, { error: { message: 'a name is required', type: 'bad_request' } });
+        }
         if (!pcm || pcm.length < 16000) {
           // Under a second of audio produces an embedding dominated by whatever
           // noise happened to be in it, and the resulting voice is arbitrary.
@@ -1166,9 +1185,13 @@ export function createGateway(cfg = loadConfig()) {
             console.log(`[tts] pocket conditioning unavailable for this voice (${e.message})`);
           }
 
-          const saved = ttsVoices.saveVoice({ name, vec, pocket });
-          console.log(`[tts] saved custom voice "${saved.name}" (${saved.kinds.join(' + ')}, sample discarded)`);
-          return sendJson(res, 201, { ...saved, usable: ttsEngine.supportsCustomVoices() });
+          const saved = editId
+            ? ttsVoices.replaceVoice(editId, { vec, pocket })
+            : ttsVoices.saveVoice({ name, vec, pocket });
+          // A rename may ride along with a re-record, so apply it after the swap.
+          const final = editId && name && name !== saved.name ? ttsVoices.renameVoice(editId, name) : saved;
+          console.log(`[tts] ${editId ? 're-recorded' : 'saved'} custom voice "${final.name}" (${(saved.kinds || []).join(' + ')}, sample discarded)`);
+          return sendJson(res, editId ? 200 : 201, { ...saved, ...final, usable: ttsEngine.supportsCustomVoices() });
         } catch (e) {
           return sendJson(res, 400, { error: { message: e.message, type: 'save_failed' } });
         }
@@ -1366,7 +1389,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-voices.js

@@ -75,7 +75,7 @@ export function listVoices() {
       // in a settings page's JSON.
       if (v?.id && v?.name) {
         out.push({
-          id: v.id, name: v.name, createdAt: v.createdAt || 0, dim: v.vec?.length || 0,
+          id: v.id, name: v.name, createdAt: v.createdAt || 0, updatedAt: v.updatedAt || 0, dim: v.vec?.length || 0,
           kinds: v.pocketShape ? [KIND_SPEECHT5, KIND_POCKET] : [KIND_SPEECHT5],
         });
       }
@@ -133,6 +133,53 @@ export function saveVoice({ name, vec, pocket = null }) {
   return { id: rec.id, name: rec.name, createdAt: rec.createdAt, dim: rec.vec.length, kinds: rec.pocketShape ? [KIND_SPEECHT5, KIND_POCKET] : [KIND_SPEECHT5] };
 }
 
+/**
+ * Rename in place. The id is untouched on purpose: `custom:<id>` is what the
+ * gateway config and every client store, so a rename must not invalidate them.
+ */
+export function renameVoice(id, name) {
+  const rec = getVoice(id);
+  if (!rec) return null;
+  const clean = String(name || '').trim().slice(0, MAX_NAME);
+  if (!clean) throw new Error('a name is required');
+  rec.name = clean;
+  rec.updatedAt = Date.now();
+  writeFileSync(fileFor(id), JSON.stringify(rec));
+  return { id, name: rec.name, createdAt: rec.createdAt || 0, updatedAt: rec.updatedAt, dim: rec.vec?.length || 0 };
+}
+
+/**
+ * Re-record: swap in prints derived from a NEW sample, keeping the id and name.
+ *
+ * Keeping the id is the whole point. A first take is often poor — too quiet, a
+ * cough, the wrong room — and the fix should be "record that again", not "delete
+ * it, record a new one, and go re-select it everywhere". Anything already pointing
+ * at this voice keeps working and simply sounds different.
+ */
+export function replaceVoice(id, { vec, pocket = null }) {
+  const rec = getVoice(id);
+  if (!rec) return null;
+  if (!vec || vec.length !== EMBED_DIM) throw new Error(`expected a ${EMBED_DIM}-value embedding, got ${vec?.length || 0}`);
+  rec.vec = Array.from(vec, (x) => Number(x) || 0);
+  rec.updatedAt = Date.now();
+  if (pocket?.data?.length && Array.isArray(pocket.shape)) {
+    rec.pocketShape = pocket.shape;
+    const f32 = pocket.data instanceof Float32Array ? pocket.data : Float32Array.from(pocket.data);
+    writeFileSync(pocketFileFor(id), Buffer.from(f32.buffer, f32.byteOffset, f32.byteLength));
+  } else if (rec.pocketShape) {
+    // The new take produced no Pocket conditioning (its bundle is missing), so the
+    // OLD one must go — leaving it would pair a stale voice with a fresh print and
+    // the voice would change depending on which engine spoke.
+    delete rec.pocketShape;
+    rmSync(pocketFileFor(id), { force: true });
+  }
+  writeFileSync(fileFor(id), JSON.stringify(rec));
+  return {
+    id, name: rec.name, createdAt: rec.createdAt || 0, updatedAt: rec.updatedAt,
+    dim: rec.vec.length, kinds: rec.pocketShape ? [KIND_SPEECHT5, KIND_POCKET] : [KIND_SPEECHT5],
+  };
+}
+
 /** Remove one permanently. Returns whether there was anything to remove. */
 export function deleteVoice(id) {
   if (!isValidVoiceRef(id)) return false;