@livx.cc/agentx 0.96.16 → 0.96.18

package/dist/cli.js

@@ -5500,6 +5500,11 @@ var VoiceEngineOptions = class {
    *  as a barge and abort the fresh turn (live: mid-sentence self-interruption + steps=1→steps=0 double
    *  abort). Short enough that a genuine immediate barge ("no wait—") still lands right after. */
   bargeGraceMs = 600;
+  /** Barge-in (talk over the assistant to interrupt). true = full-duplex (needs echo cancellation, or
+   *  the assistant's own TTS bleeds back and self-interrupts). false = HALF-DUPLEX: the engine is deaf
+   *  while audible (speaking + drain tail), so echo can never become a phantom turn — the right mode
+   *  when there's no AEC (e.g. the non-VPIO mic fallback) and no headphones. Cost: can't interrupt. */
+  bargeIn = true;
   /** Filler phrase spoken when holding for an incomplete utterance ('' disables). */
   holdFiller = "";
   /** Called when the engine holds an incomplete utterance (host can render a visual cue). */
@@ -5593,6 +5598,10 @@ var VoiceEngine = class _VoiceEngine {
   get usingAec() {
     return this.stt.usingAec;
   }
+  /** Flip barge-in at runtime (e.g. the mic fell back to non-VPIO → go half-duplex so echo can't leak). */
+  setBargeIn(on) {
+    this.options.bargeIn = on;
+  }
   idleWaiters = [];
   setState(s) {
     if (this.state === s) return;
@@ -5744,6 +5753,7 @@ var VoiceEngine = class _VoiceEngine {
   }
   handlePartial(text) {
     if (this.speaking) {
+      if (!this.options.bargeIn) return;
       if (now() < this.bargeGraceUntil) {
         if (!this.echoActive() || (this.usingAec ? this.genuine(text) : this.novelWords(text).length >= 1)) this.options.onPartial(text);
         return;
@@ -5819,7 +5829,7 @@ var VoiceEngine = class _VoiceEngine {
       this.stt.reset();
       return;
     }
-    if (this.echoActive() && (this.usingAec ? !this.genuine(text) : this.novelWords(text).length < 2)) {
+    if (this.echoActive() && (!this.options.bargeIn || (this.usingAec ? !this.genuine(text) : this.novelWords(text).length < 2))) {
       this.stt.reset();
       return;
     }
@@ -7267,22 +7277,55 @@ var AecDuplexAudio = class {
     this.bin = bin;
   }
   bin;
-  aec = true;
+  /** Mutable: starts true (VPIO/AEC). Flips false if we fall back to non-VPIO capture (heuristic tier). */
+  _aec = true;
+  get aec() {
+    return this._aec;
+  }
   onFatal;
+  /** Fired once when capture degrades to the non-VPIO (no-AEC) fallback — the host switches to
+   *  half-duplex so the assistant's own TTS can't bleed back as a phantom turn. */
+  onDegrade;
   proc = null;
   stopped = false;
   micDenied = false;
+  noVpio = false;
+  // currently running the non-VPIO fallback
+  triedFallback = false;
+  // one-shot guard
+  gotChunk = false;
+  // any mic audio since (re)spawn?
+  onChunk = () => {
+  };
+  fallbackTimer = null;
   bytesWritten = 0;
   startedAt = 0;
   // --- AudioSource ---
   start(onChunk) {
-    this.proc = spawn2(this.bin, [], { stdio: ["pipe", "pipe", "pipe"] });
+    this.onChunk = onChunk;
+    if (process.env.MIC_NO_VPIO === "1") {
+      this.noVpio = true;
+      this.triedFallback = true;
+      this._aec = false;
+      this.onDegrade?.();
+    }
+    this.spawnHelper();
+  }
+  /** (Re)spawn the helper. On the first spawn, arm a fast watchdog: if VPIO delivers NO audio within
+   *  ~2.5s, the VP input tap is dead on this machine (seen on macOS 26.5.x) — respawn once with
+   *  MIC_NO_VPIO=1 (plain capture, heuristic echo) so the mic actually works instead of starving STT. */
+  spawnHelper() {
+    const env = this.noVpio ? { ...process.env, MIC_NO_VPIO: "1" } : process.env;
+    this.proc = spawn2(this.bin, [], { stdio: ["pipe", "pipe", "pipe"], env });
     this.proc.stdin.on("error", () => {
     });
     this.proc.on("exit", (c) => {
       if (c && !this.stopped) log16.error(`aec duplex audio exited (${c}) \u2014 check mic permission / MIC_AEC=0`);
     });
-    this.proc.stdout.on("data", (chunk) => onChunk(chunk));
+    this.proc.stdout.on("data", (chunk) => {
+      this.gotChunk = true;
+      this.onChunk(chunk);
+    });
     this.proc.stderr.on("data", (d) => {
       for (const ln of String(d).split("\n")) {
         const s = ln.trim();
@@ -7296,9 +7339,22 @@ var AecDuplexAudio = class {
         } else log16.debug(`mic-aec: ${s}`);
       }
     });
-  }
-  stop() {
-    this.stopped = true;
+    if (!this.noVpio && !this.triedFallback) {
+      this.fallbackTimer = setTimeout(() => {
+        if (this.stopped || this.gotChunk) return;
+        this.triedFallback = true;
+        this.noVpio = true;
+        this._aec = false;
+        log16.warn("mic-aec: VPIO delivered no audio in 2.5s \u2014 falling back to non-VPIO capture (no AEC \u2192 half-duplex, no barge-in)");
+        this.onDegrade?.();
+        this.killProc();
+        this.spawnHelper();
+      }, 2500);
+      this.fallbackTimer.unref?.();
+    }
+  }
+  /** Kill the current child WITHOUT marking the whole source stopped (used for the fallback respawn). */
+  killProc() {
     const p = this.proc;
     this.proc = null;
     if (!p) return;
@@ -7310,6 +7366,11 @@ var AecDuplexAudio = class {
       }
     }, 500).unref?.();
   }
+  stop() {
+    this.stopped = true;
+    if (this.fallbackTimer) clearTimeout(this.fallbackTimer);
+    this.killProc();
+  }
   // --- AudioSink (frame writer; same played/drain byte-math as the ffplay Player) ---
   frame(payload) {
     const stdin = this.proc?.stdin;
@@ -7410,6 +7471,7 @@ var VoiceIO = class extends VoiceEngine {
       // textless residue pre-pause: opt-in (hiccup source)
     });
     this.duplexSource = duplex;
+    if (duplex) duplex.onDegrade = () => this.setBargeIn(false);
   }
   /** Host hook for an unrecoverable audio failure — mic permission denied (duplex source) or no mic
    *  audio at all (STT watchdog). Routed to whichever can detect it. */