agent.libx.js 0.92.5 → 0.92.7

package/dist/cli.js

@@ -3552,12 +3552,14 @@ ${recent}` : brief;
         report.output(chunk);
       }
     } : base;
+    const workerHost = o.host?.ask ? { ask: (q2) => o.host.ask(q2) } : void 0;
     const worker = new Agent({
       ai: o.ai,
       fs: o.fs,
       model: o.workerModel,
       ...o.workerOptions,
       // may override ai/fs/model/tools/… —
+      ...workerHost ? { host: workerHost } : {},
       ...hooks ? { hooks } : {},
       signal: controller.signal
       // …but never the per-task cancellation signal
@@ -3805,6 +3807,18 @@ var VoiceEngineOptions = class {
   /** heuristic (non-AEC) energy barge-in tuning */
   bargeRmsMult = 2;
   bargeRmsFloor = 500;
+  /** Overlap turn-taking (AEC tier, needs player.pause/resume) — human phone-call model:
+   *  onset → PAUSE (exact-sample hold, nothing lost); sustained overlap → cede (interrupt; the LLM
+   *  re-enters). Brief overlaps that die out (backchannels — "mm-hm", decided by DURATION, not
+   *  vocabulary) resume from the precise sample and are dropped. false disables. */
+  overlapPause = true;
+  /** sustained overlap ≥ this → cede the turn */
+  overlapSustainMs = 350;
+  /** quiet for this long while paused → resume, drop the interjection */
+  overlapResumeMs = 700;
+  /** energy floor for "overlap candidate" — must sit ABOVE typical room ambient (~110 rms measured;
+   *  ungated ambient re-arming the resume timer forever was a live wedge). User speech ≫ 300. */
+  overlapRms = 300;
 };
 var VoiceEngine = class {
   options;
@@ -3835,6 +3849,13 @@ var VoiceEngine = class {
   // endpointed text held for the merge window
   pendingTimer = null;
   lastInterrupted = null;
+  // overlap (pause) tier state — AEC + pause-capable sinks only
+  pausedAt = 0;
+  overlapLoud = 0;
+  // loud chunks since pause (sustain must be real sound, not two clicks)
+  overlapLastLoudAt = 0;
+  // continuity guard: a gap re-arms the onset (sparse noise ≠ sustained speech)
+  resumeTimer = null;
   constructor(options) {
     this.options = { ...new VoiceEngineOptions(), ...options };
     const o = this.options;
@@ -3882,6 +3903,7 @@ var VoiceEngine = class {
       this.drainTimer = null;
     }
     this.interrupted = false;
+    this.resetOverlap(true);
     if (!this.speaking) this.player.markTurn();
     this.speaking = true;
     this.ctxOpen = true;
@@ -3916,6 +3938,10 @@ var VoiceEngine = class {
         this.drainTimer = null;
         return;
       }
+      if (this.pausedAt) {
+        this.drainTimer = setTimeout(settle, 250);
+        return;
+      }
       this.drainTimer = null;
       this.speaking = false;
       this.echoUntil = now() + 2500;
@@ -3947,6 +3973,7 @@ var VoiceEngine = class {
       clearTimeout(this.drainTimer);
       this.drainTimer = null;
     }
+    this.resetOverlap(false);
     const heardChars = Math.round(Math.max(0, this.player.playedMs()) / 1e3 * 15);
     if (this.reply) this.lastInterrupted = { full: this.reply, heard: this.reply.slice(0, heardChars) };
     this.speaking = false;
@@ -3961,6 +3988,7 @@ var VoiceEngine = class {
     this.setState("listening");
   }
   stop() {
+    if (this.resumeTimer) clearTimeout(this.resumeTimer);
     if (this.pendingTimer) clearTimeout(this.pendingTimer);
     if (this.drainTimer) clearTimeout(this.drainTimer);
     this.stt.stop();
@@ -3978,9 +4006,19 @@ var VoiceEngine = class {
   echoActive() {
     return this.speaking || now() < this.echoUntil;
   }
+  /** Genuine user speech vs our own bleed (AEC tier): novel words must DOMINATE, not merely exist.
+   *  Degraded AEC + an STT mis-hearing manufactures a single novel word out of pure echo (a name or
+   *  rare word in our own reply comes back transcribed slightly differently — 1 novel / N words).
+   *  A real interjection is mostly novel ("stop", "wait what") — short utterances pass on ratio,
+   *  longer ones on count. */
+  genuine(text) {
+    const total = this.words(text).length;
+    const novel = this.novelWords(text).length;
+    return novel > 0 && novel / Math.max(1, total) > 0.5;
+  }
   handlePartial(text) {
     if (this.speaking) {
-      const barge = this.novelWords(text).length >= (this.usingAec ? 1 : this.suspectUntil ? 1 : 2);
+      const barge = this.overlapCapable ? false : this.usingAec ? this.genuine(text) : this.novelWords(text).length >= (this.suspectUntil ? 1 : 2);
       if (barge) {
         const phase = this.ctxOpen ? "speaking" : "drain";
         this.interrupt();
@@ -3994,10 +4032,14 @@ var VoiceEngine = class {
         this.pendingTimer = null;
       }
     }
-    if (!this.echoActive() || this.novelWords(text).length >= 1) this.options.onPartial(text);
+    if (!this.echoActive() || (this.usingAec ? this.genuine(text) : this.novelWords(text).length >= 1)) this.options.onPartial(text);
   }
   handleUtterance(text) {
-    if (this.echoActive() && this.novelWords(text).length < (this.usingAec ? 1 : 2)) {
+    if (this.speaking && this.ctxOpen && this.overlapCapable) {
+      this.stt.reset();
+      return;
+    }
+    if (this.echoActive() && (this.usingAec ? !this.genuine(text) : this.novelWords(text).length < 2)) {
       this.stt.reset();
       return;
     }
@@ -4020,9 +4062,62 @@ var VoiceEngine = class {
     this.pendingUtt = "";
     if (text) this.options.onUtterance(text);
   }
+  get overlapCapable() {
+    return this.usingAec && this.options.overlapPause && !!this.player.pause && !!this.player.resume;
+  }
+  /** Overlap turn-taking (AEC tier): onset → pause (exact-sample hold); sustained → cede; died out
+   *  → resume. No vocabulary anywhere — duration and persistence decide (backchannels are short
+   *  and stop). Nothing is lost across a pause, so a false positive costs only a brief hold. */
+  handleOverlap(rms) {
+    const o = this.options;
+    if (!this.speaking || !this.overlapCapable) return;
+    if (rms < o.overlapRms) return;
+    const t = now();
+    if (!this.pausedAt) {
+      this.pausedAt = t;
+      this.overlapLoud = 1;
+      this.overlapLastLoudAt = t;
+      this.player.pause();
+      this.armResume();
+      return;
+    }
+    if (t - this.overlapLastLoudAt > 300) {
+      this.pausedAt = t;
+      this.overlapLoud = 1;
+      this.overlapLastLoudAt = t;
+      this.armResume();
+      return;
+    }
+    this.overlapLastLoudAt = t;
+    this.overlapLoud++;
+    if (t - this.pausedAt >= o.overlapSustainMs && this.overlapLoud >= 4) {
+      const phase = this.ctxOpen ? "speaking" : "drain";
+      this.interrupt();
+      this.options.onBargeIn(phase);
+      return;
+    }
+    this.armResume();
+  }
+  armResume() {
+    if (this.resumeTimer) clearTimeout(this.resumeTimer);
+    this.resumeTimer = setTimeout(() => {
+      this.resumeTimer = null;
+      if (!this.pausedAt) return;
+      this.resetOverlap(true);
+    }, this.options.overlapResumeMs);
+  }
+  resetOverlap(resume) {
+    if (this.resumeTimer) {
+      clearTimeout(this.resumeTimer);
+      this.resumeTimer = null;
+    }
+    if (this.pausedAt && resume) this.player.resume?.();
+    this.pausedAt = 0;
+    this.overlapLoud = 0;
+  }
   /** energy two-stage barge-in (heuristic tier only): spike over echo baseline → pause + confirm via STT */
   handleLevel(rms) {
-    if (this.usingAec) return;
+    if (this.usingAec) return this.handleOverlap(rms);
     if (!this.speaking) {
       this.baseline = 0;
       this.hot = 0;
@@ -4972,6 +5067,102 @@ var NodeMicSource = class {
     }, 500).unref?.();
   }
 };
+var AecDuplexAudio = class {
+  constructor(bin) {
+    this.bin = bin;
+  }
+  bin;
+  aec = true;
+  proc = null;
+  stopped = false;
+  bytesWritten = 0;
+  startedAt = 0;
+  // --- AudioSource ---
+  start(onChunk) {
+    this.proc = spawn2(this.bin, [], { stdio: ["pipe", "pipe", "ignore"] });
+    this.proc.stdin.on("error", () => {
+    });
+    this.proc.on("exit", (c) => {
+      if (c && !this.stopped) log12.error(`aec duplex audio exited (${c}) \u2014 check mic permission / MIC_AEC=0`);
+    });
+    this.proc.stdout.on("data", (chunk) => onChunk(chunk));
+  }
+  stop() {
+    this.stopped = true;
+    const p = this.proc;
+    this.proc = null;
+    if (!p) return;
+    p.kill("SIGTERM");
+    setTimeout(() => {
+      try {
+        p.kill("SIGKILL");
+      } catch {
+      }
+    }, 500).unref?.();
+  }
+  // --- AudioSink (frame writer; same played/drain byte-math as the ffplay Player) ---
+  frame(payload) {
+    const stdin = this.proc?.stdin;
+    if (!stdin || stdin.destroyed) return;
+    const hdr = Buffer.alloc(4);
+    hdr.writeUInt32LE(payload ? payload.length : 0);
+    stdin.write(hdr);
+    if (payload?.length) stdin.write(payload);
+  }
+  markTurn() {
+    this.frame(null);
+    this.bytesWritten = 0;
+    this.startedAt = 0;
+    this.pausedSince = 0;
+    this.pausedAccum = 0;
+  }
+  write(chunk) {
+    if (!this.startedAt) this.startedAt = now4();
+    this.bytesWritten += chunk.length;
+    this.frame(chunk);
+  }
+  playedMs() {
+    return this.startedAt ? now4() - this.startedAt - this.pausedMs() : 0;
+  }
+  drainMs() {
+    if (!this.startedAt) return 0;
+    const queuedMs = this.bytesWritten / (TTS_SAMPLE_RATE * 2) * 1e3;
+    return Math.max(0, queuedMs - (now4() - this.startedAt - this.pausedMs()));
+  }
+  /** barge-in: silence NOW (in-band flush) — the capture side keeps running */
+  kill() {
+    this.frame(null);
+    this.bytesWritten = 0;
+    this.startedAt = 0;
+    this.pausedSince = 0;
+    this.pausedAccum = 0;
+  }
+  /** overlap trail-off: exact-sample PAUSE (len==0xFFFFFFFF) / RESUME (len==0xFFFFFFFE) frames */
+  pausedSince = 0;
+  pausedAccum = 0;
+  ctl(code) {
+    const stdin = this.proc?.stdin;
+    if (!stdin || stdin.destroyed) return;
+    const f = Buffer.alloc(4);
+    f.writeUInt32LE(code, 0);
+    stdin.write(f);
+  }
+  pause() {
+    if (this.pausedSince) return;
+    this.pausedSince = now4();
+    this.ctl(4294967295);
+  }
+  resume() {
+    if (!this.pausedSince) return;
+    this.pausedAccum += now4() - this.pausedSince;
+    this.pausedSince = 0;
+    this.ctl(4294967294);
+  }
+  /** total paused time this turn — excluded from played/drain math (the tape held still) */
+  pausedMs() {
+    return this.pausedAccum + (this.pausedSince ? now4() - this.pausedSince : 0);
+  }
+};
 var VoiceIOOptions = class extends VoiceEngineOptions {
   sonioxApiKey = process.env.SONIOX_API_KEY ?? "";
   cartesiaApiKey = process.env.CARTESIA_API_KEY ?? "";
@@ -4980,11 +5171,13 @@ var VoiceIOOptions = class extends VoiceEngineOptions {
 var VoiceIO = class extends VoiceEngine {
   constructor(options) {
     const o = { ...new VoiceIOOptions(), ...options };
+    const bin = !o.stt || !o.player ? resolveAecBinary() : null;
+    const duplex = bin ? new AecDuplexAudio(bin) : null;
     super({
       ...o,
-      stt: o.stt ?? new SonioxSTT({ auth: o.sonioxApiKey, source: new NodeMicSource() }),
+      stt: o.stt ?? new SonioxSTT({ auth: o.sonioxApiKey, source: duplex ?? new NodeMicSource() }),
       tts: o.tts ?? new CartesiaTTS({ auth: o.cartesiaApiKey, voiceId: o.cartesiaVoiceId }),
-      player: o.player ?? new Player(),
+      player: o.player ?? duplex ?? new Player(),
       bargeRmsMult: Number(process.env.BARGE_RMS_MULT || o.bargeRmsMult),
       bargeRmsFloor: Number(process.env.BARGE_RMS_FLOOR || o.bargeRmsFloor)
     });