@chatpanel/gateway 0.6.22 → 0.6.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatpanel/gateway",
-  "version": "0.6.22",
+  "version": "0.6.24",
   "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/diarize-engine.js

@@ -43,6 +43,7 @@ export function modelOnDisk(modelId = DIARIZE_MODEL, dtype = runtimeDtype()) {
   catch { return false; }
 }
 
+/** @param {{ log?: (m: string) => void, allowDownload?: boolean }} [opts] */
 async function load({ log = () => {}, allowDownload = true } = {}) {
   let lib;
   try { lib = await ensureLib(); }
@@ -79,12 +80,25 @@ async function load({ log = () => {}, allowDownload = true } = {}) {
 }
 
 export function init(cfg = {}) {
-  if (_initPromise) return _initPromise;
+  // Retry after a FAILED attempt (single-flight only while loading/ready) — else a
+  // transient failure (e.g. downloads were disabled, or the model wasn't on disk
+  // yet) would be cached forever and never self-heal once the model is present.
+  if (_initPromise && _state !== 'error') return _initPromise;
   _state = 'loading';
   _initPromise = load({ log: cfg.onLog, allowDownload: cfg.allowDownload !== false });
   return _initPromise;
 }
 
+// Explicit download (the Gateway-tab "Download" button): force the fetch even if
+// the config disabled auto-downloads, and clear any cached failure so it retries.
+/** @param {{ onLog?: (m: string) => void }} [opts] */
+export function download({ onLog } = {}) {
+  _initPromise = null;
+  _state = 'loading';
+  _initPromise = load({ log: onLog, allowDownload: true });
+  return _initPromise;
+}
+
 // Embed a mono 16 kHz Float32 segment → Float32Array x-vector, or null if not ready.
 export async function embed(audio) {
   if (!isReady() || !(audio instanceof Float32Array) || !audio.length) return null;
@@ -108,10 +122,13 @@ function cosine(a, b) {
   return denom ? d / denom : 0;
 }
 
-// A per-session speaker tracker. `threshold` = min cosine to be the SAME speaker;
-// lower → fewer speakers (merges more), higher → more speakers (splits more).
+// A per-session speaker tracker. NOT limited to 2 speakers — this is embedding +
+// online clustering, so it scales to N (a 10-person meeting is fine; accuracy just
+// softens as more voices sound alike). `threshold` = min cosine to be the SAME
+// speaker (lower → fewer speakers/more merging, higher → more speakers/more
+// splitting); `maxSpeakers` caps the roster (extra turns fold into the nearest).
 export class Diarizer {
-  constructor({ threshold = 0.75, maxSpeakers = 8 } = {}) {
+  constructor({ threshold = 0.75, maxSpeakers = 12 } = {}) {
     this.threshold = threshold;
     this.maxSpeakers = maxSpeakers;
     this.centroids = []; // { id, label, vec: Float32Array, n }

package/src/server.js

@@ -43,7 +43,7 @@ import * as openai from './openai.js';
 import * as responses from './responses.js';
 import * as anthropic from './anthropic.js';
 
-export const VERSION = '0.6.22';
+export const VERSION = '0.6.24';
 
 // 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.
@@ -698,6 +698,24 @@ export function createGateway(cfg = loadConfig()) {
         return sendJson(res, 202, { accepted: true, active: id, state: sttEngine.state(), progress: sttEngine.progress() });
       }
     }
+    // Speaker (diarization) model manager — the "who said what" x-vector model.
+    // GET → status + install state; POST → force-download it (ignores the
+    // allowDownload config flag; explicit user action from the Gateway tab).
+    if (pathname === '/diarize/model') {
+      if (req.method === 'GET') {
+        const h = diarizeEngine.health();
+        return sendJson(res, 200, {
+          active: diarizeEngine.DIARIZE_MODEL,
+          state: h.state,
+          progress: diarizeEngine.progress(),
+          available: [{ id: diarizeEngine.DIARIZE_MODEL, label: 'Speaker embeddings (wavlm)', lang: 'any', approxMB: 100, note: 'Tells voices apart for meeting transcription (who said what).', installed: diarizeEngine.modelOnDisk() }],
+        });
+      }
+      if (req.method === 'POST') {
+        diarizeEngine.download({ onLog: (m) => console.log(m) });
+        return sendJson(res, 202, { accepted: true, active: diarizeEngine.DIARIZE_MODEL, state: diarizeEngine.state(), progress: diarizeEngine.progress() });
+      }
+    }
     if (pathname === '/stt/sessions' && req.method === 'POST') {
       if (cfg.stt?.enabled === false) return sendJson(res, 403, { error: { message: 'STT disabled in gateway config', type: 'stt_disabled' } });
       let body = null;
@@ -760,9 +778,15 @@ export function createGateway(cfg = loadConfig()) {
           send({ type: 'state', state: sttEngine.state() });
           const progressTimer = setInterval(() => {
             const st = sttEngine.state();
-            if (st === 'downloading' || st === 'loading') send({ type: 'progress', state: st, ...(sttEngine.progress() || {}) });
-            else if (st === 'error') { send({ type: 'error', code: 'model_failed', message: sttEngine.health().error || 'model failed to load', fatal: true }); clearInterval(progressTimer); }
-            else { send({ type: 'state', state: st }); clearInterval(progressTimer); }
+            if (st === 'downloading' || st === 'loading') { send({ type: 'progress', state: st, ...(sttEngine.progress() || {}) }); return; }
+            if (st === 'error') { send({ type: 'error', code: 'model_failed', message: sttEngine.health().error || 'model failed to load', fatal: true }); clearInterval(progressTimer); return; }
+            // STT ready — if diarization is on, surface ITS one-time download too, so
+            // "who said what" doesn't silently lag while the speaker model fetches.
+            if (sess.diarize) {
+              const ds = diarizeEngine.state();
+              if (ds === 'downloading' || ds === 'loading') { send({ type: 'diarize-progress', state: ds, ...(diarizeEngine.progress() || {}) }); return; }
+            }
+            send({ type: 'state', state: st }); clearInterval(progressTimer);
           }, 500);
           progressTimer.unref?.();
           // Redaction is async — chain events so finals can't overtake interims.