@livx.cc/agentx 0.99.146 → 0.99.148
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +1 -1
- package/dist/cli.js +1195 -200
- package/dist/cli.js.map +1 -1
- package/dist/index.d.ts +50 -6
- package/dist/index.js +1019 -101
- package/dist/index.js.map +1 -1
- package/package.json +2 -2
package/dist/index.js
CHANGED
|
@@ -5503,7 +5503,7 @@ var Agent = class _Agent {
|
|
|
5503
5503
|
let lastProgressAt = start;
|
|
5504
5504
|
const turnUser = this.transcript[this.transcript.length - 1];
|
|
5505
5505
|
const kill = (finishReason) => {
|
|
5506
|
-
log9
|
|
5506
|
+
log9[finishReason === "aborted" ? "debug" : "warn"](`kill-switch: ${finishReason} (steps=${steps}, tokens=${usage.totalTokens}, budgetTokens=${Math.round(spent)}, ms=${Date.now() - start - this.parkedMs}${finishReason === "timeout" ? `, idle=${Date.now() - lastProgressAt - this.parkedMs}ms` : ""}${this.parkedMs ? ` +${this.parkedMs} parked` : ""})`);
|
|
5507
5507
|
this.jobs.killAll(`run ended: ${finishReason}`, true);
|
|
5508
5508
|
const claims = this.survivingClaims();
|
|
5509
5509
|
return { text: lastAssistantText(this.transcript, turnUser), steps, finishReason, messages: this.transcript, usage, usageEstimated, ...finishReason === "budget" ? { budget: { spent: Math.round(spent), limit: o.maxTokens, stepPrompt } } : {}, ...claims.length ? { fabricatedToolClaims: claims } : {} };
|
|
@@ -7231,6 +7231,117 @@ init_llm();
|
|
|
7231
7231
|
init_logging();
|
|
7232
7232
|
init_models();
|
|
7233
7233
|
|
|
7234
|
+
// node_modules/@bod.ee/voice/src/core/types.ts
|
|
7235
|
+
var STT_SAMPLE_RATE = 16e3;
|
|
7236
|
+
var TTS_SAMPLE_RATE = 44100;
|
|
7237
|
+
async function resolveAuth(auth) {
|
|
7238
|
+
return typeof auth === "function" ? await auth() : auth;
|
|
7239
|
+
}
|
|
7240
|
+
|
|
7241
|
+
// node_modules/@bod.ee/voice/src/core/splice-sink.ts
|
|
7242
|
+
var BYTES_PER_MS = TTS_SAMPLE_RATE * 2 / 1e3;
|
|
7243
|
+
var toBytes = (ms) => Math.max(0, Math.round(ms * TTS_SAMPLE_RATE / 1e3)) * 2;
|
|
7244
|
+
var SpliceSinkOptions = class {
|
|
7245
|
+
/** The rest resumes this much before the pause point — a human re-enters a little before where they stopped. */
|
|
7246
|
+
backoffMs = 150;
|
|
7247
|
+
/** Tape kept behind the playhead (older audio is dropped; a splice only needs the unplayed rest + the backoff). */
|
|
7248
|
+
keepMs = 5e3;
|
|
7249
|
+
};
|
|
7250
|
+
var SpliceSink = class {
|
|
7251
|
+
constructor(sink, options) {
|
|
7252
|
+
this.sink = sink;
|
|
7253
|
+
this.options = { ...new SpliceSinkOptions(), ...options };
|
|
7254
|
+
}
|
|
7255
|
+
sink;
|
|
7256
|
+
options;
|
|
7257
|
+
tape = [];
|
|
7258
|
+
tapeStart = 0;
|
|
7259
|
+
// content bytes dropped from the head of `tape`
|
|
7260
|
+
/** Active splice: the sink's raw timeline = clip (clipMs) then the content from `fromMs`. */
|
|
7261
|
+
clipMs = 0;
|
|
7262
|
+
fromMs = 0;
|
|
7263
|
+
spliced = false;
|
|
7264
|
+
markTurn() {
|
|
7265
|
+
this.reset();
|
|
7266
|
+
this.sink.markTurn();
|
|
7267
|
+
}
|
|
7268
|
+
kill() {
|
|
7269
|
+
this.reset();
|
|
7270
|
+
this.sink.kill();
|
|
7271
|
+
}
|
|
7272
|
+
pause() {
|
|
7273
|
+
this.sink.pause?.();
|
|
7274
|
+
}
|
|
7275
|
+
resume() {
|
|
7276
|
+
this.sink.resume?.();
|
|
7277
|
+
}
|
|
7278
|
+
get canPause() {
|
|
7279
|
+
return !!this.sink.pause && !!this.sink.resume;
|
|
7280
|
+
}
|
|
7281
|
+
write(pcm) {
|
|
7282
|
+
this.tape.push(pcm);
|
|
7283
|
+
this.trim();
|
|
7284
|
+
this.sink.write(pcm);
|
|
7285
|
+
}
|
|
7286
|
+
drainMs() {
|
|
7287
|
+
return this.sink.drainMs();
|
|
7288
|
+
}
|
|
7289
|
+
/** Reply-content ms played: holds at the splice point while the clip plays. */
|
|
7290
|
+
playedMs() {
|
|
7291
|
+
const raw = this.sink.playedMs();
|
|
7292
|
+
return this.spliced ? Math.max(this.fromMs, raw - this.clipMs + this.fromMs) : raw;
|
|
7293
|
+
}
|
|
7294
|
+
/** Reply-content ms written so far (played + still queued) — exact even mid-clip (anchors a new sub-turn). */
|
|
7295
|
+
endMs() {
|
|
7296
|
+
const raw = Math.max(0, this.sink.playedMs() + this.sink.drainMs());
|
|
7297
|
+
return this.spliced ? Math.max(0, raw - this.clipMs + this.fromMs) : raw;
|
|
7298
|
+
}
|
|
7299
|
+
/** Play `clip` (s16le mono at TTS_SAMPLE_RATE) now, then the reply from where it was (less backoffMs). Unpauses a
|
|
7300
|
+
* paused sink (the flush does). Returns the content ms the rest resumes from. */
|
|
7301
|
+
splice(clip2) {
|
|
7302
|
+
const at = Math.max(0, this.playedMs() - this.options.backoffMs);
|
|
7303
|
+
const from = Math.max(at, this.tapeStart / BYTES_PER_MS);
|
|
7304
|
+
const rest = this.slice(toBytes(from));
|
|
7305
|
+
this.sink.kill();
|
|
7306
|
+
this.sink.write(clip2);
|
|
7307
|
+
if (rest.length) this.sink.write(rest);
|
|
7308
|
+
this.spliced = true;
|
|
7309
|
+
this.clipMs = clip2.length / BYTES_PER_MS;
|
|
7310
|
+
this.fromMs = from;
|
|
7311
|
+
return from;
|
|
7312
|
+
}
|
|
7313
|
+
slice(fromByte) {
|
|
7314
|
+
let off = this.tapeStart;
|
|
7315
|
+
const parts = [];
|
|
7316
|
+
for (const c of this.tape) {
|
|
7317
|
+
const end = off + c.length;
|
|
7318
|
+
if (end > fromByte) parts.push(off >= fromByte ? c : c.subarray(fromByte - off));
|
|
7319
|
+
off = end;
|
|
7320
|
+
}
|
|
7321
|
+
const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
|
|
7322
|
+
let i = 0;
|
|
7323
|
+
for (const p of parts) {
|
|
7324
|
+
out.set(p, i);
|
|
7325
|
+
i += p.length;
|
|
7326
|
+
}
|
|
7327
|
+
return out;
|
|
7328
|
+
}
|
|
7329
|
+
trim() {
|
|
7330
|
+
const keepFrom = toBytes(this.playedMs() - this.options.keepMs);
|
|
7331
|
+
while (this.tape.length > 1 && this.tapeStart + this.tape[0].length <= keepFrom) {
|
|
7332
|
+
const c = this.tape.shift();
|
|
7333
|
+
this.tapeStart += c.length;
|
|
7334
|
+
}
|
|
7335
|
+
}
|
|
7336
|
+
reset() {
|
|
7337
|
+
this.tape = [];
|
|
7338
|
+
this.tapeStart = 0;
|
|
7339
|
+
this.spliced = false;
|
|
7340
|
+
this.clipMs = 0;
|
|
7341
|
+
this.fromMs = 0;
|
|
7342
|
+
}
|
|
7343
|
+
};
|
|
7344
|
+
|
|
7234
7345
|
// node_modules/@bod.ee/voice/src/core/logging.ts
|
|
7235
7346
|
function consoleForComponent(name) {
|
|
7236
7347
|
const debugEnv = typeof process !== "undefined" && process.env?.DEBUG || typeof localStorage !== "undefined" && localStorage.getItem("DEBUG") || "";
|
|
@@ -7365,7 +7476,11 @@ var ALIASES = {
|
|
|
7365
7476
|
comedic: "joking"
|
|
7366
7477
|
// Cartesia lists "joking/comedic" as one — canonicalize to joking
|
|
7367
7478
|
};
|
|
7368
|
-
var
|
|
7479
|
+
var LAUGH = "[laughter]";
|
|
7480
|
+
var BREATH = '<emotion value="scared"/>Hhh!';
|
|
7481
|
+
var NONVERBAL = { laughter: LAUGH, laughs: LAUGH, laugh: LAUGH, laughing: LAUGH, gasp: BREATH, gasps: BREATH, gasping: BREATH };
|
|
7482
|
+
var QUIET = '<volume ratio="0.5"/><speed ratio="0.8"/>';
|
|
7483
|
+
var DELIVERY = { quiet: QUIET, quietly: QUIET, soft: QUIET, softly: QUIET, whispers: QUIET };
|
|
7369
7484
|
function normalizeEmotion(raw) {
|
|
7370
7485
|
const k = raw.trim().toLowerCase();
|
|
7371
7486
|
if (VALID.has(k)) return k;
|
|
@@ -7374,19 +7489,32 @@ function normalizeEmotion(raw) {
|
|
|
7374
7489
|
function resolveTag(raw) {
|
|
7375
7490
|
const k = raw.trim().toLowerCase();
|
|
7376
7491
|
if (NONVERBAL[k]) return { kind: "nonverbal", value: NONVERBAL[k] };
|
|
7492
|
+
if (DELIVERY[k]) return { kind: "delivery", value: DELIVERY[k] };
|
|
7377
7493
|
const e = normalizeEmotion(k);
|
|
7378
7494
|
return e ? { kind: "emotion", value: e } : null;
|
|
7379
7495
|
}
|
|
7380
7496
|
var TAG_RE = /\[([a-zA-Z][a-zA-Z ]{0,24})\]/g;
|
|
7381
7497
|
var PARTIAL_RE = /\[[a-zA-Z ]*$/;
|
|
7382
|
-
var cartesiaTag = (t) => t.kind === "
|
|
7498
|
+
var cartesiaTag = (t) => t.kind === "emotion" ? `<emotion value="${t.value}"/>` : t.value;
|
|
7499
|
+
function renderEmotions(text, opts = { show: true }) {
|
|
7500
|
+
const s = new EmotionStream(opts.show), a = s.feed(text), b = s.flush();
|
|
7501
|
+
return { speech: a.speech + b.speech, display: a.display + b.display, prose: a.prose + b.prose };
|
|
7502
|
+
}
|
|
7383
7503
|
var EmotionStream = class {
|
|
7504
|
+
// that tag, due on the next words after a gasp; an emotion tag in between replaces it
|
|
7384
7505
|
constructor(show = true) {
|
|
7385
7506
|
this.show = show;
|
|
7386
7507
|
}
|
|
7387
7508
|
show;
|
|
7388
7509
|
buf = "";
|
|
7389
|
-
pending =
|
|
7510
|
+
pending = "";
|
|
7511
|
+
emotion = "neutral";
|
|
7512
|
+
// the last emotion tag: what the words after a gasp's `scared` go back to
|
|
7513
|
+
restore = "";
|
|
7514
|
+
/** A new TTS context opens mid-reply: an emotion tag ended with the old one, so the next words carry it again. */
|
|
7515
|
+
resume() {
|
|
7516
|
+
if (this.emotion !== "neutral") this.restore = cartesiaTag({ kind: "emotion", value: this.emotion });
|
|
7517
|
+
}
|
|
7390
7518
|
feed(delta) {
|
|
7391
7519
|
this.buf += delta;
|
|
7392
7520
|
return this.drain(false);
|
|
@@ -7413,7 +7541,17 @@ var EmotionStream = class {
|
|
|
7413
7541
|
});
|
|
7414
7542
|
const tag = resolveTag(m[1]);
|
|
7415
7543
|
if (tag) {
|
|
7416
|
-
|
|
7544
|
+
if (tag.kind === "nonverbal") {
|
|
7545
|
+
speech += this.pending + tag.value;
|
|
7546
|
+
this.pending = "";
|
|
7547
|
+
if (tag.value === BREATH) this.restore = cartesiaTag({ kind: "emotion", value: this.emotion });
|
|
7548
|
+
} else {
|
|
7549
|
+
if (tag.kind === "emotion") {
|
|
7550
|
+
this.emotion = tag.value;
|
|
7551
|
+
this.restore = "";
|
|
7552
|
+
}
|
|
7553
|
+
this.pending += cartesiaTag(tag);
|
|
7554
|
+
}
|
|
7417
7555
|
if (this.show) display += m[0];
|
|
7418
7556
|
} else log14.debug(`dropping unknown emotion tag ${m[0]}`);
|
|
7419
7557
|
last = m.index + m[0].length;
|
|
@@ -7429,9 +7567,9 @@ var EmotionStream = class {
|
|
|
7429
7567
|
emit(text, sink) {
|
|
7430
7568
|
if (!text) return;
|
|
7431
7569
|
let speech = text;
|
|
7432
|
-
if (this.pending && /[\p{L}\p{N}]/u.test(text)) {
|
|
7433
|
-
speech =
|
|
7434
|
-
this.pending =
|
|
7570
|
+
if ((this.pending || this.restore) && /[\p{L}\p{N}]/u.test(text)) {
|
|
7571
|
+
speech = this.restore + this.pending + text;
|
|
7572
|
+
this.pending = this.restore = "";
|
|
7435
7573
|
}
|
|
7436
7574
|
sink(speech, text, text);
|
|
7437
7575
|
}
|
|
@@ -7561,8 +7699,66 @@ function computeHoldMs(ctx) {
|
|
|
7561
7699
|
return Math.max(floor, Math.min(MAX_HOLD_MS, ms));
|
|
7562
7700
|
}
|
|
7563
7701
|
|
|
7702
|
+
// node_modules/@bod.ee/voice/src/core/speakers.ts
|
|
7703
|
+
function sonioxWords(toks) {
|
|
7704
|
+
const out = [];
|
|
7705
|
+
let cur = null;
|
|
7706
|
+
for (const t of toks) {
|
|
7707
|
+
if (/^\s/.test(t.text) || !cur) {
|
|
7708
|
+
if (cur) out.push(cur);
|
|
7709
|
+
cur = { w: "", t0: t.start_ms / 1e3, t1: t.end_ms / 1e3, conf: t.confidence ?? 1, ...t.speaker != null ? { spk: String(t.speaker) } : {}, ...t.language ? { lang: String(t.language) } : {} };
|
|
7710
|
+
}
|
|
7711
|
+
cur.w += t.text;
|
|
7712
|
+
cur.t1 = t.end_ms / 1e3;
|
|
7713
|
+
cur.conf = Math.min(cur.conf, t.confidence ?? 1);
|
|
7714
|
+
}
|
|
7715
|
+
if (cur) out.push(cur);
|
|
7716
|
+
return out.map((w) => ({ ...w, w: w.w.trim() })).filter((w) => w.w);
|
|
7717
|
+
}
|
|
7718
|
+
var SpeakerRunsOptions = class {
|
|
7719
|
+
/** A run shorter than this (a diarization flap) joins its neighbour — the previous run, or the next for a leading one. */
|
|
7720
|
+
minRunWords = 2;
|
|
7721
|
+
};
|
|
7722
|
+
function speakerRuns(words3, options) {
|
|
7723
|
+
const { minRunWords } = { ...new SpeakerRunsOptions(), ...options };
|
|
7724
|
+
let runs = [];
|
|
7725
|
+
for (const w of words3) {
|
|
7726
|
+
const last = runs[runs.length - 1];
|
|
7727
|
+
const spk = w.spk ?? last?.spk ?? words3.find((x) => x.spk != null)?.spk ?? "";
|
|
7728
|
+
if (last?.spk === spk) last.words.push(w);
|
|
7729
|
+
else runs.push({ spk, words: [w] });
|
|
7730
|
+
}
|
|
7731
|
+
while (runs.length > 1) {
|
|
7732
|
+
const i = runs.findIndex((r) => r.words.length < minRunWords);
|
|
7733
|
+
if (i < 0) break;
|
|
7734
|
+
const into = i === 0 ? runs[1] : runs[i - 1];
|
|
7735
|
+
if (i === 0) into.words.unshift(...runs[0].words);
|
|
7736
|
+
else into.words.push(...runs[i].words);
|
|
7737
|
+
runs.splice(i, 1);
|
|
7738
|
+
runs = runs.reduce((acc, r) => {
|
|
7739
|
+
const p = acc[acc.length - 1];
|
|
7740
|
+
if (p?.spk === r.spk) p.words.push(...r.words);
|
|
7741
|
+
else acc.push(r);
|
|
7742
|
+
return acc;
|
|
7743
|
+
}, []);
|
|
7744
|
+
}
|
|
7745
|
+
return runs.map((r) => ({
|
|
7746
|
+
speaker: r.spk,
|
|
7747
|
+
text: r.words.map((w) => w.w).join(" "),
|
|
7748
|
+
startMs: Math.round(r.words[0].t0 * 1e3),
|
|
7749
|
+
endMs: Math.round(r.words[r.words.length - 1].t1 * 1e3)
|
|
7750
|
+
}));
|
|
7751
|
+
}
|
|
7752
|
+
function formatTurns(turns, name = (t) => `Speaker ${t.speaker}`) {
|
|
7753
|
+
return turns.map((t) => `${name(t)}: ${t.text}`).join("\n");
|
|
7754
|
+
}
|
|
7755
|
+
|
|
7564
7756
|
// node_modules/@bod.ee/voice/src/core/engine.ts
|
|
7565
7757
|
var log15 = forComponent2("VoiceEngine");
|
|
7758
|
+
var addLangs = (to, from) => {
|
|
7759
|
+
for (const k in from) to[k] = (to[k] || 0) + from[k];
|
|
7760
|
+
};
|
|
7761
|
+
var dominantLang = (l) => Object.keys(l).sort((a, b) => l[b] - l[a])[0];
|
|
7566
7762
|
var realClock = {
|
|
7567
7763
|
now: () => performance.now(),
|
|
7568
7764
|
setTimeout: (fn, ms) => setTimeout(fn, ms),
|
|
@@ -7595,6 +7791,17 @@ function heardPrefix(text, spoken, lookahead = 4) {
|
|
|
7595
7791
|
}
|
|
7596
7792
|
return at;
|
|
7597
7793
|
}
|
|
7794
|
+
var NumberedSpeakers = class {
|
|
7795
|
+
ids = /* @__PURE__ */ new Map();
|
|
7796
|
+
name(label) {
|
|
7797
|
+
let n = this.ids.get(label);
|
|
7798
|
+
if (!n) this.ids.set(label, n = `Speaker ${this.ids.size + 1}`);
|
|
7799
|
+
return n;
|
|
7800
|
+
}
|
|
7801
|
+
reset() {
|
|
7802
|
+
this.ids.clear();
|
|
7803
|
+
}
|
|
7804
|
+
};
|
|
7598
7805
|
var VoiceEngineOptions = class {
|
|
7599
7806
|
stt;
|
|
7600
7807
|
tts;
|
|
@@ -7603,6 +7810,15 @@ var VoiceEngineOptions = class {
|
|
|
7603
7810
|
* re-finalization of the utterance dispatched just before it: replace that turn, don't add one. */
|
|
7604
7811
|
onUtterance = () => {
|
|
7605
7812
|
};
|
|
7813
|
+
/** Label multi-speaker utterances (`Speaker 1: …\nSpeaker 2: …`) from the STT's diarized turns. Sticky: off until
|
|
7814
|
+
* the session hears ≥2 speakers with ≥3 words each, then every turn is labelled; solo use is unchanged. */
|
|
7815
|
+
speakerLabels = false;
|
|
7816
|
+
/** Maps raw speaker ids to display names (default `Speaker N` by first appearance). */
|
|
7817
|
+
speakerResolver = new NumberedSpeakers();
|
|
7818
|
+
/** Only the speakers `speakerResolver.keep` accepts are heard (a one-person call in a busy room): another speaker's
|
|
7819
|
+
* turns are cut from each utterance (all of them → no utterance), and a partial that is only theirs is ignored — no
|
|
7820
|
+
* interim, no barge-in. Needs a diarized STT; without speaker tags every word counts. */
|
|
7821
|
+
speakerFilter = false;
|
|
7606
7822
|
/** live partial transcript while listening (host renders the 🎤 line) */
|
|
7607
7823
|
onPartial = () => {
|
|
7608
7824
|
};
|
|
@@ -7660,11 +7876,19 @@ var VoiceEngineOptions = class {
|
|
|
7660
7876
|
* it now fires on every tier-2/3 hold, not only on `looksIncomplete` (`holdFiller` stays tier-1
|
|
7661
7877
|
* only). See core/endpointing.ts. */
|
|
7662
7878
|
adaptiveEndpointing = false;
|
|
7879
|
+
/** Flush the TTS at the reply's first clause (the first , . ; : ! ? … — cut there, never mid-phrase) so its speech starts there, not at the
|
|
7880
|
+
* provider's buffer limit (Cartesia: a sentence end or max_buffer_delay_ms) — a reply streamed word by word otherwise
|
|
7881
|
+
* starts speaking only once its whole first sentence is in. Needs a TTS with flush(). */
|
|
7882
|
+
flushFirstClause = false;
|
|
7663
7883
|
/** Grace window (ms) after an utterance dispatches, during which the user's own trailing audio cannot
|
|
7664
7884
|
* barge the reply it requested. Soniox keeps finalizing partials past <end>; without this they read
|
|
7665
7885
|
* as a barge and abort the fresh turn (live: mid-sentence self-interruption + steps=1→steps=0 double
|
|
7666
7886
|
* abort). Short enough that a genuine immediate barge ("no wait—") still lands right after. */
|
|
7667
7887
|
bargeGraceMs = 600;
|
|
7888
|
+
/** A new final within this window of the last dispatch, while that dispatch is still unanswered (no reply beyond an
|
|
7889
|
+
* ack), is merged into it and dispatched as ONE line superseding it (meta.supersedes) — never a second queued turn.
|
|
7890
|
+
* 0 = off. */
|
|
7891
|
+
pendingMergeMs = 3e3;
|
|
7668
7892
|
/** Barge-in (talk over the assistant to interrupt). true = full-duplex (needs echo cancellation, or
|
|
7669
7893
|
* the assistant's own TTS bleeds back and self-interrupts). false = HALF-DUPLEX: the engine is deaf
|
|
7670
7894
|
* while audible (speaking + drain tail), so echo can never become a phantom turn — the right mode
|
|
@@ -7711,6 +7935,12 @@ var VoiceEngineOptions = class {
|
|
|
7711
7935
|
overlapDecideMs = 0;
|
|
7712
7936
|
/** Longest overlap (words) the host decides; also how far an overlap the host kept may grow before it cedes. */
|
|
7713
7937
|
overlapDecideMaxWords = 4;
|
|
7938
|
+
/** A second TTS for ASIDES (decideOverlap's `aside`: a short line said over a kept overlap — "oh yeah, definitely"
|
|
7939
|
+
* — while the reply is held, then the SAME reply resumes from its pause point). Its own client: the reply's
|
|
7940
|
+
* context may still be streaming, and one client has one live context. Absent → asides are skipped (resume only). */
|
|
7941
|
+
asideTts = null;
|
|
7942
|
+
/** An aside not synthesized within this long is dropped and the reply resumes (never a long held silence). */
|
|
7943
|
+
asideMaxMs = 1500;
|
|
7714
7944
|
/** Speculative ENERGY pre-pause while speaking (AEC tier): two residue gate-passes within 350ms →
|
|
7715
7945
|
* pause ~300ms before the STT tokens land. But energy CANNOT separate residue bursts from speech
|
|
7716
7946
|
* (the documented whack-a-mole) — so a residue spike during loud playback false-pauses with NO user
|
|
@@ -7784,7 +8014,16 @@ var VoiceEngine = class _VoiceEngine {
|
|
|
7784
8014
|
state = "idle";
|
|
7785
8015
|
stt;
|
|
7786
8016
|
tts;
|
|
7787
|
-
|
|
8017
|
+
sink;
|
|
8018
|
+
/** The playback sink, always behind a SpliceSink (asides play ahead of a held reply); assigning one wraps it. */
|
|
8019
|
+
get player() {
|
|
8020
|
+
return this.sink;
|
|
8021
|
+
}
|
|
8022
|
+
set player(p) {
|
|
8023
|
+
this.sink = p instanceof SpliceSink ? p : new SpliceSink(p);
|
|
8024
|
+
}
|
|
8025
|
+
asideEpoch = 0;
|
|
8026
|
+
// bumps on every aside start/cancel — a late aside of a dead hold never plays
|
|
7788
8027
|
speaking = false;
|
|
7789
8028
|
// audible (deltas flowing OR audio draining)
|
|
7790
8029
|
ctxOpen = false;
|
|
@@ -7861,6 +8100,15 @@ var VoiceEngine = class _VoiceEngine {
|
|
|
7861
8100
|
lastDispatchFlat = "";
|
|
7862
8101
|
lastDispatchWords = [];
|
|
7863
8102
|
lastDispatchText = "";
|
|
8103
|
+
lastDispatchLangs = {};
|
|
8104
|
+
// chars per language of lastDispatchText (a pending-reply continuation re-sends it)
|
|
8105
|
+
lastDispatchTurns = [];
|
|
8106
|
+
// speaker turns of lastDispatchText (same reason)
|
|
8107
|
+
lastDispatchOut = "";
|
|
8108
|
+
// the text the host actually received (labelled) — what `supersedes` names
|
|
8109
|
+
speakerWords = /* @__PURE__ */ new Map();
|
|
8110
|
+
// words dispatched per raw speaker id (sticky labelling)
|
|
8111
|
+
labelling = false;
|
|
7864
8112
|
lastDispatchAt = 0;
|
|
7865
8113
|
repliedSinceDispatch = false;
|
|
7866
8114
|
dispatchReply = "";
|
|
@@ -7925,6 +8173,9 @@ var VoiceEngine = class _VoiceEngine {
|
|
|
7925
8173
|
this.clock = o.clock;
|
|
7926
8174
|
}
|
|
7927
8175
|
async start() {
|
|
8176
|
+
this.speakerWords.clear();
|
|
8177
|
+
this.labelling = false;
|
|
8178
|
+
this.options.speakerResolver.reset?.();
|
|
7928
8179
|
this.tts.onAudio = (c) => {
|
|
7929
8180
|
if (!this.speaking && !this.bcActive) return;
|
|
7930
8181
|
if (this.wordAnchorPending && this.speaking) this.anchorSubturn();
|
|
@@ -7943,11 +8194,34 @@ var VoiceEngine = class _VoiceEngine {
|
|
|
7943
8194
|
});
|
|
7944
8195
|
};
|
|
7945
8196
|
}
|
|
7946
|
-
this.stt.onPartial = (text) =>
|
|
7947
|
-
|
|
8197
|
+
this.stt.onPartial = (text, turns) => {
|
|
8198
|
+
const k = this.keptTurns(text, turns);
|
|
8199
|
+
if (k) this.handlePartial(k.text);
|
|
8200
|
+
};
|
|
8201
|
+
this.stt.onUtterance = (text, _at, language, turns, ago) => {
|
|
8202
|
+
this.lastWordAt = ago === void 0 ? 0 : this.clock.now() - ago;
|
|
8203
|
+
if (turns?.length && (this.options.speakerLabels || this.options.speakerFilter)) {
|
|
8204
|
+
try {
|
|
8205
|
+
this.options.speakerResolver.observe?.(turns);
|
|
8206
|
+
} catch (e) {
|
|
8207
|
+
log15.warn(`speakerResolver.observe threw: ${e instanceof Error ? e.message : e}`);
|
|
8208
|
+
}
|
|
8209
|
+
}
|
|
8210
|
+
const k = this.keptTurns(text, turns);
|
|
8211
|
+
if (!k) {
|
|
8212
|
+
this.diag("speaker_dropped", { text });
|
|
8213
|
+
return;
|
|
8214
|
+
}
|
|
8215
|
+
this.handleUtterance(k.text, language ? { [language]: k.text.length } : void 0, k.turns);
|
|
8216
|
+
};
|
|
7948
8217
|
this.stt.onLevel = (rms) => this.handleLevel(rms);
|
|
7949
|
-
await Promise.all([
|
|
8218
|
+
await Promise.all([
|
|
8219
|
+
this.tts.connect(),
|
|
8220
|
+
this.stt.start(),
|
|
8221
|
+
Promise.resolve(this.options.asideTts?.connect()).catch((e) => log15.warn(`aside TTS connect failed \u2014 asides off until it reconnects: ${e instanceof Error ? e.message : e}`))
|
|
8222
|
+
]);
|
|
7950
8223
|
this.tts.warmup?.();
|
|
8224
|
+
this.options.asideTts?.warmup?.();
|
|
7951
8225
|
this.setState("listening");
|
|
7952
8226
|
if (this.options.bargeInMode === "aec" && !this.stt.usingAec)
|
|
7953
8227
|
log15.warn("bargeInMode=aec but mic does not report echoCancellation applied \u2014 STT may transcribe the assistant");
|
|
@@ -7980,6 +8254,10 @@ var VoiceEngine = class _VoiceEngine {
|
|
|
7980
8254
|
}
|
|
7981
8255
|
}
|
|
7982
8256
|
idleWaiters = [];
|
|
8257
|
+
/** When (engine clock) the last STT final's last word ended — UtteranceMeta.lastWordAgoMs. */
|
|
8258
|
+
lastWordAt = 0;
|
|
8259
|
+
/** '' until the open context's first clause is flushed (flushFirstClause); null = flushed. */
|
|
8260
|
+
clause = "";
|
|
7983
8261
|
setState(s) {
|
|
7984
8262
|
if (this.state === s) return;
|
|
7985
8263
|
this.diag("state", { from: this.state, to: s });
|
|
@@ -8040,6 +8318,7 @@ var VoiceEngine = class _VoiceEngine {
|
|
|
8040
8318
|
this.emo = this.options.emotions ? new EmotionStream(this.options.showEmotions) : null;
|
|
8041
8319
|
this.echoWords = new Set(this.words(this.prevReply));
|
|
8042
8320
|
this.tts.newContext();
|
|
8321
|
+
this.clause = "";
|
|
8043
8322
|
this.clearAckTimer("new_turn");
|
|
8044
8323
|
if (ack && this.options.ackPhrase) {
|
|
8045
8324
|
this.diag("ack_fired", { phrase: this.options.ackPhrase, adaptive: false });
|
|
@@ -8114,7 +8393,15 @@ var VoiceEngine = class _VoiceEngine {
|
|
|
8114
8393
|
this.dispatchReply += prose;
|
|
8115
8394
|
}
|
|
8116
8395
|
for (const w of this.words(this.reply)) this.echoWords.add(w);
|
|
8117
|
-
this.tts.
|
|
8396
|
+
const cut = this.options.flushFirstClause && this.clause !== null && this.tts.flush ? speech.search(/[,.;:!?…](?=\s|$)/) : -1;
|
|
8397
|
+
if (cut < 0) this.tts.speak(forSpeech(speech), true);
|
|
8398
|
+
else {
|
|
8399
|
+
this.tts.speak(forSpeech(speech.slice(0, cut + 1)), true);
|
|
8400
|
+
this.clause = null;
|
|
8401
|
+
this.tts.flush();
|
|
8402
|
+
this.diag("tts_first_clause_flush", {});
|
|
8403
|
+
if (speech.slice(cut + 1)) this.tts.speak(forSpeech(speech.slice(cut + 1)), true);
|
|
8404
|
+
}
|
|
8118
8405
|
if (!this.spokeDeltas && this.turnStartAt) log15.debug(`ttft: ${Math.round(this.clock.now() - this.turnStartAt)}ms`);
|
|
8119
8406
|
this.spokeDeltas = true;
|
|
8120
8407
|
this.setState("speaking");
|
|
@@ -8139,6 +8426,8 @@ var VoiceEngine = class _VoiceEngine {
|
|
|
8139
8426
|
this.diag("tts_subturn_boundary", { playedMs: Math.round(Math.max(0, this.player.playedMs())) });
|
|
8140
8427
|
this.tts.end();
|
|
8141
8428
|
this.tts.newContext();
|
|
8429
|
+
this.clause = "";
|
|
8430
|
+
this.emo?.resume();
|
|
8142
8431
|
this.wordAnchorPending = true;
|
|
8143
8432
|
this.wordPending = [];
|
|
8144
8433
|
}
|
|
@@ -8147,7 +8436,7 @@ var VoiceEngine = class _VoiceEngine {
|
|
|
8147
8436
|
* content; fully drained, drainMs is 0 and playedMs has reached the scheduled total). */
|
|
8148
8437
|
anchorSubturn() {
|
|
8149
8438
|
this.wordAnchorPending = false;
|
|
8150
|
-
this.wordOrigin =
|
|
8439
|
+
this.wordOrigin = this.player.endMs() / 1e3;
|
|
8151
8440
|
this.diag("reveal_anchor", { originSec: Number(this.wordOrigin.toFixed(3)), held: this.wordPending.length });
|
|
8152
8441
|
for (const [w, s] of this.wordPending) {
|
|
8153
8442
|
this.wordStarts.push(this.wordOrigin + s);
|
|
@@ -8230,7 +8519,7 @@ var VoiceEngine = class _VoiceEngine {
|
|
|
8230
8519
|
this.stopWordReveal(true);
|
|
8231
8520
|
if (this.turnStartAt) log15.debug(`turn: ${Math.round(this.clock.now() - this.turnStartAt)}ms (incl. playback)`);
|
|
8232
8521
|
this.echoUntil = this.clock.now() + 2500;
|
|
8233
|
-
if (!this.usingAec) this.
|
|
8522
|
+
if (!this.usingAec) this.echoHead = true;
|
|
8234
8523
|
try {
|
|
8235
8524
|
this.options.onSpeechEnd();
|
|
8236
8525
|
} catch (e) {
|
|
@@ -8371,6 +8660,12 @@ var VoiceEngine = class _VoiceEngine {
|
|
|
8371
8660
|
return phrase;
|
|
8372
8661
|
}
|
|
8373
8662
|
lastDispatchWasQuestion = false;
|
|
8663
|
+
/** Chars per STT language of the text that joined the pending turn / the overlap-held final — the dispatch takes the dominant. */
|
|
8664
|
+
pendingLangs = {};
|
|
8665
|
+
decideHeldLangs = {};
|
|
8666
|
+
/** Speaker turns riding with the pending / overlap-held text (like the langs). */
|
|
8667
|
+
pendingTurns = [];
|
|
8668
|
+
decideHeldTurns = [];
|
|
8374
8669
|
dispatchRefinal = false;
|
|
8375
8670
|
// the last dispatch re-finalized (superseded) the one before it — same logical turn
|
|
8376
8671
|
ackSpent = false;
|
|
@@ -8412,6 +8707,7 @@ var VoiceEngine = class _VoiceEngine {
|
|
|
8412
8707
|
this.drainTimer = null;
|
|
8413
8708
|
}
|
|
8414
8709
|
this.resetOverlap(false);
|
|
8710
|
+
this.cancelAside("interrupt");
|
|
8415
8711
|
this.lastResumeAt = 0;
|
|
8416
8712
|
const { heard, exact } = this.heardCut();
|
|
8417
8713
|
if (this.reply || droppedQueued) this.lastInterrupted = { full: this.reply, heard, exact, queued, queuedTurn: this.queuedTurn };
|
|
@@ -8423,7 +8719,7 @@ var VoiceEngine = class _VoiceEngine {
|
|
|
8423
8719
|
this.echoUntil = this.clock.now() + Math.max(2500, this.player.drainMs() + 3e3);
|
|
8424
8720
|
this.tts.cancel();
|
|
8425
8721
|
this.player.kill();
|
|
8426
|
-
if (!this.usingAec) this.
|
|
8722
|
+
if (!this.usingAec) this.echoHead = true;
|
|
8427
8723
|
if (this.reply) this.prevReply = this.reply;
|
|
8428
8724
|
this.setState("listening");
|
|
8429
8725
|
}
|
|
@@ -8450,9 +8746,11 @@ var VoiceEngine = class _VoiceEngine {
|
|
|
8450
8746
|
if (this.drainTimer) this.clock.clearTimeout(this.drainTimer);
|
|
8451
8747
|
if (this.specTimer) this.clock.clearTimeout(this.specTimer);
|
|
8452
8748
|
this.bcSupersede();
|
|
8749
|
+
this.cancelAside("stop");
|
|
8453
8750
|
this.stt.stop();
|
|
8454
8751
|
this.player.kill();
|
|
8455
8752
|
this.tts.close();
|
|
8753
|
+
this.options.asideTts?.close();
|
|
8456
8754
|
this.setState("idle");
|
|
8457
8755
|
}
|
|
8458
8756
|
// --- listening side (STT-driven) ---
|
|
@@ -8491,6 +8789,22 @@ var VoiceEngine = class _VoiceEngine {
|
|
|
8491
8789
|
"twenty"
|
|
8492
8790
|
].map((w, i) => [w, String(i)])
|
|
8493
8791
|
);
|
|
8792
|
+
/** The next final may open with our own echo (a heuristic barge/settle kept the STT buffer, not reset it). */
|
|
8793
|
+
echoHead = false;
|
|
8794
|
+
/** `text` without its leading run of our own words (echoWords); all echo → unchanged (the echo gates judge it whole). */
|
|
8795
|
+
dropEchoHead(text) {
|
|
8796
|
+
const toks = text.trim().split(/\s+/);
|
|
8797
|
+
let i = 0;
|
|
8798
|
+
for (let k = 0; k < toks.length; k++) {
|
|
8799
|
+
const w = this.words(toks[k]);
|
|
8800
|
+
if (!w.length) continue;
|
|
8801
|
+
if (!w.every((x) => this.echoWords.has(x))) break;
|
|
8802
|
+
i = k + 1;
|
|
8803
|
+
}
|
|
8804
|
+
if (!i || i === toks.length) return text;
|
|
8805
|
+
this.diag("echo_head", { dropped: toks.slice(0, i).join(" ").slice(0, 60) });
|
|
8806
|
+
return toks.slice(i).join(" ");
|
|
8807
|
+
}
|
|
8494
8808
|
novelWords(text) {
|
|
8495
8809
|
return this.words(text).filter((w) => !this.echoWords.has(w));
|
|
8496
8810
|
}
|
|
@@ -8523,6 +8837,22 @@ var VoiceEngine = class _VoiceEngine {
|
|
|
8523
8837
|
for (let i = 1; i < w.length; i++) if (pairs.has(`${w[i - 1]} ${w[i]}`)) inRun[i - 1] = inRun[i] = true;
|
|
8524
8838
|
return inRun.filter(Boolean).length * 2 >= w.length;
|
|
8525
8839
|
}
|
|
8840
|
+
/** Display a partial — unless it's echo-shaped during/after our own speech (degraded-AEC bleed), or the STT's trailing
|
|
8841
|
+
* re-emit of the line just dispatched (Soniox emits partials after <end>): the host types partials into its input box,
|
|
8842
|
+
* so that tail would sit there after the line was sent (bare-browser #837). */
|
|
8843
|
+
showPartial(text) {
|
|
8844
|
+
if (this.echoActive() && !(this.usingAec ? this.genuine(text) : this.novelWords(text).length >= 1)) return;
|
|
8845
|
+
if (this.echoesDispatch(text, true) || this.tailWordOfDispatch(text)) {
|
|
8846
|
+
this.diag("dup_partial_hidden", { text: text.slice(0, 60) });
|
|
8847
|
+
return;
|
|
8848
|
+
}
|
|
8849
|
+
this.options.onPartial(text);
|
|
8850
|
+
}
|
|
8851
|
+
/** A lone word that is the just-dispatched line's last word (echoesDispatch needs ≥2): display-only filter. */
|
|
8852
|
+
tailWordOfDispatch(text) {
|
|
8853
|
+
const w = text.trim().split(/\s+/).map(normWord).filter(Boolean), d = this.lastDispatchWords.map(normWord).filter(Boolean);
|
|
8854
|
+
return w.length === 1 && d.length > 0 && this.clock.now() - this.lastDispatchAt < _VoiceEngine.DUP_FINAL_MS && d[d.length - 1].startsWith(w[0]);
|
|
8855
|
+
}
|
|
8526
8856
|
handlePartial(text) {
|
|
8527
8857
|
if (this.speaking) {
|
|
8528
8858
|
if (!this.options.bargeIn) return;
|
|
@@ -8531,7 +8861,7 @@ var VoiceEngine = class _VoiceEngine {
|
|
|
8531
8861
|
this.lastGraceDiag = this.bargeGraceUntil;
|
|
8532
8862
|
this.diag("grace_suppress", { text: text.slice(0, 60) });
|
|
8533
8863
|
}
|
|
8534
|
-
|
|
8864
|
+
this.showPartial(text);
|
|
8535
8865
|
return;
|
|
8536
8866
|
}
|
|
8537
8867
|
if (this.echoesDispatch(text, true)) {
|
|
@@ -8596,7 +8926,7 @@ var VoiceEngine = class _VoiceEngine {
|
|
|
8596
8926
|
}
|
|
8597
8927
|
this.trackSpeculation(text);
|
|
8598
8928
|
this.trackBackchannel(text);
|
|
8599
|
-
|
|
8929
|
+
this.showPartial(text);
|
|
8600
8930
|
}
|
|
8601
8931
|
/** Speculative-reflex trigger (listening side only — the speaking branch returns before this): a
|
|
8602
8932
|
* partial that hasn't CHANGED for speculativeMs and has ≥ speculativeMinWords is stable → fire
|
|
@@ -8639,6 +8969,8 @@ var VoiceEngine = class _VoiceEngine {
|
|
|
8639
8969
|
* 'Okay.'/'Right.' are fine here (unlike ACKS_NEUTRAL's no-Okay rule): a standalone user "Okay."
|
|
8640
8970
|
* right after OUR blip is overwhelmingly the blip's echo — the squash guard eating it is the point. */
|
|
8641
8971
|
static BACKCHANNELS = ["Mm-hm.", "Uh-huh.", "Right.", "Okay."];
|
|
8972
|
+
/** fireBackchannel renders inline tags (a host's bundle may predate it: it spoke them raw). */
|
|
8973
|
+
static TAGGED_BLIPS = true;
|
|
8642
8974
|
/** Backchannel trigger (listening side only — the speaking branch returns before this): a partial
|
|
8643
8975
|
* that reached a clause boundary and then stayed UNCHANGED for backchannelMs (a micro-pause, still
|
|
8644
8976
|
* BEFORE the silence endpoint) fires a blip — if long enough (≥ backchannelMinWords), predominantly
|
|
@@ -8675,8 +9007,10 @@ var VoiceEngine = class _VoiceEngine {
|
|
|
8675
9007
|
fireBackchannel() {
|
|
8676
9008
|
const fresh = _VoiceEngine.BACKCHANNELS.filter((x) => !this.recentBc.includes(x));
|
|
8677
9009
|
const pool = fresh.length ? fresh : _VoiceEngine.BACKCHANNELS;
|
|
8678
|
-
const
|
|
8679
|
-
this.
|
|
9010
|
+
const line = pool[Math.floor(Math.random() * pool.length)];
|
|
9011
|
+
const r = this.options.emotions ? renderEmotions(line, { show: false }) : { speech: line, prose: line };
|
|
9012
|
+
const phrase = r.prose.trim() || line;
|
|
9013
|
+
this.recentBc.push(line);
|
|
8680
9014
|
if (this.recentBc.length > 2) this.recentBc.shift();
|
|
8681
9015
|
const now3 = this.clock.now();
|
|
8682
9016
|
for (const w of this.words(phrase)) this.echoWords.add(w);
|
|
@@ -8695,7 +9029,7 @@ var VoiceEngine = class _VoiceEngine {
|
|
|
8695
9029
|
this.bcActive = false;
|
|
8696
9030
|
};
|
|
8697
9031
|
this.tts.newContext();
|
|
8698
|
-
this.tts.speak(
|
|
9032
|
+
this.tts.speak(r.speech, false);
|
|
8699
9033
|
log15.debug(`backchannel: "${phrase}"`);
|
|
8700
9034
|
this.diag("backchannel", { phrase });
|
|
8701
9035
|
this.options.onBackchannel(phrase);
|
|
@@ -8750,10 +9084,29 @@ var VoiceEngine = class _VoiceEngine {
|
|
|
8750
9084
|
}
|
|
8751
9085
|
if (pfx && norm4(nw[pw.length - 1]).startsWith(norm4(pw[pw.length - 1]))) return next;
|
|
8752
9086
|
}
|
|
9087
|
+
let common = 0;
|
|
9088
|
+
while (common < pw.length && common < nw.length && norm4(pw[common]) === norm4(nw[common])) common++;
|
|
9089
|
+
if (common === nw.length && common >= 4 && common >= 0.75 * pw.length) {
|
|
9090
|
+
this.diag("merge_restated", { dropped: prev.slice(0, 60), revised: true });
|
|
9091
|
+
return next;
|
|
9092
|
+
}
|
|
8753
9093
|
if (_VoiceEngine.restates(prev, next)) {
|
|
8754
9094
|
this.diag("merge_restated", { dropped: prev.slice(0, 60) });
|
|
8755
9095
|
return next;
|
|
8756
9096
|
}
|
|
9097
|
+
const head = norm4(nw[0] ?? "");
|
|
9098
|
+
if (head.length >= 2 && nw.length >= 4) {
|
|
9099
|
+
for (let s = pw.length - 4; s >= 0; s--) {
|
|
9100
|
+
const w = norm4(pw[s]);
|
|
9101
|
+
if (w.length <= head.length || !w.endsWith(head)) continue;
|
|
9102
|
+
let ok = true;
|
|
9103
|
+
for (let x = 1; x <= 3 && ok; x++) ok = s + x < pw.length && norm4(pw[s + x]) === norm4(nw[x]);
|
|
9104
|
+
if (ok) {
|
|
9105
|
+
this.diag("merge_restated", { dropped: pw.slice(s + 1).join(" ").slice(0, 60), clipped: true });
|
|
9106
|
+
return [...pw.slice(0, s + 1), ...nw.slice(1)].join(" ");
|
|
9107
|
+
}
|
|
9108
|
+
}
|
|
9109
|
+
}
|
|
8757
9110
|
const max = Math.min(pw.length, nw.length);
|
|
8758
9111
|
for (let k = max; k > 0; k--) {
|
|
8759
9112
|
let match = true;
|
|
@@ -8762,6 +9115,14 @@ var VoiceEngine = class _VoiceEngine {
|
|
|
8762
9115
|
break;
|
|
8763
9116
|
}
|
|
8764
9117
|
if (match) return [...pw, ...nw.slice(k)].join(" ");
|
|
9118
|
+
if (k >= 3) {
|
|
9119
|
+
let grown = norm4(nw[k - 1]).startsWith(norm4(pw[pw.length - 1])) && norm4(pw[pw.length - 1]).length > 0;
|
|
9120
|
+
for (let i = 0; grown && i < k - 1; i++) if (norm4(pw[pw.length - k + i]) !== norm4(nw[i])) grown = false;
|
|
9121
|
+
if (grown) {
|
|
9122
|
+
this.diag("merge_restated", { dropped: pw.slice(-k).join(" ").slice(0, 60), grown: true });
|
|
9123
|
+
return [...pw.slice(0, pw.length - k), ...nw].join(" ");
|
|
9124
|
+
}
|
|
9125
|
+
}
|
|
8765
9126
|
}
|
|
8766
9127
|
return `${prev} ${next}`;
|
|
8767
9128
|
}
|
|
@@ -8839,7 +9200,13 @@ var VoiceEngine = class _VoiceEngine {
|
|
|
8839
9200
|
}
|
|
8840
9201
|
lastDupPartial = "";
|
|
8841
9202
|
// dup_partial diag once per distinct partial
|
|
8842
|
-
|
|
9203
|
+
/** A trailing clause comma ("…survive the crash,") or a function word / open wh-word ("…is how") ends no thought. The
|
|
9204
|
+
* comma used to sit inside the word alternation, so it matched only after a space — "crash," dispatched at once (live
|
|
9205
|
+
* duplex 2026-10-14: the reflex answered "So let's say they did survive the crash," then answered again). */
|
|
9206
|
+
static TRAIL_RE = /(?:[,;:–—-]|(?:^|\s)(?:and|but|or|so|because|then|than|to|the|a|an|my|your|our|their|this|of|in|for|with|at|by|as|that|if|when|how|what|why|where|which|who|uh|um|like|about|from|into|on|is|are|was|were))$/i;
|
|
9207
|
+
/** A hypothetical set up without its consequence: "So let's say they survived." / "Suppose it fails" — the question
|
|
9208
|
+
* comes next. A comma inside ("If it fails, restart it.") or a question mark means the consequence is there. */
|
|
9209
|
+
static SETUP_RE = /^(?:(?:so|and|but|okay|ok|well|now)[,\s]+)*(?:let'?s say|let us say|suppose|supposing|imagine|assuming|if|what if)\b[^,;?]*[.…]?$/i;
|
|
8843
9210
|
/** The user's line right after a barge cut our speech (or a re-final growing it), with no terminal punctuation:
|
|
8844
9211
|
* they took the floor mid-thought — Soniox closes on the pause, not the thought (live 20260923-192543: "But isn't it"
|
|
8845
9212
|
* → "…can be done" → "…with boxing" → "…or semantic?" dispatched 4 times). Held like an incomplete utterance. */
|
|
@@ -8851,9 +9218,69 @@ var VoiceEngine = class _VoiceEngine {
|
|
|
8851
9218
|
static CONTROL_RE = ((w) => new RegExp(`^${w}(?:[\\s,]+${w})*[.!?\u2026]*$`, "i"))("(?:stop|wait|yes|yeah|yep|no|nope|okay|ok|go on|continue|never ?mind)");
|
|
8852
9219
|
/** The utterance sounds like the user paused mid-thought (trailing conjunction/filler/comma). */
|
|
8853
9220
|
looksIncomplete(text) {
|
|
8854
|
-
|
|
8855
|
-
|
|
8856
|
-
|
|
9221
|
+
const t = text.trim();
|
|
9222
|
+
return (_VoiceEngine.TRAIL_RE.test(t) || _VoiceEngine.SETUP_RE.test(t)) && !_VoiceEngine.CONTROL_RE.test(t);
|
|
9223
|
+
}
|
|
9224
|
+
/** Diarized turns worth keeping: none unless labelling is on; while we are audible, a run with <2 novel words is our
|
|
9225
|
+
* own echo diarized as another speaker — dropped from the text too (only when another run remains). */
|
|
9226
|
+
acceptTurns(text, turns) {
|
|
9227
|
+
if (!this.options.speakerLabels || !turns?.length || turns.every((t) => !t.speaker)) return [text, []];
|
|
9228
|
+
if (turns.length >= 2 && this.echoActive()) {
|
|
9229
|
+
const kept = turns.filter((t) => this.novelWords(t.text).length >= 2);
|
|
9230
|
+
if (kept.length && kept.length < turns.length) {
|
|
9231
|
+
this.diag("echo_swallow", { guard: "echo_run", text: turns.filter((t) => !kept.includes(t)).map((t) => t.text).join(" ").slice(0, 60) });
|
|
9232
|
+
return [kept.map((t) => t.text).join(" "), kept];
|
|
9233
|
+
}
|
|
9234
|
+
}
|
|
9235
|
+
return [text, turns];
|
|
9236
|
+
}
|
|
9237
|
+
/** speakerFilter: the text of the turns `keep` accepts (unchanged when all are kept or there are no speaker tags);
|
|
9238
|
+
* null when no turn is kept. */
|
|
9239
|
+
keptTurns(text, turns) {
|
|
9240
|
+
const keep = this.options.speakerResolver.keep;
|
|
9241
|
+
if (!this.options.speakerFilter || !keep || !turns?.length || turns.every((t) => !t.speaker)) return { text, turns };
|
|
9242
|
+
const kept = turns.filter((t) => {
|
|
9243
|
+
try {
|
|
9244
|
+
return keep.call(this.options.speakerResolver, t.speaker, t);
|
|
9245
|
+
} catch {
|
|
9246
|
+
return true;
|
|
9247
|
+
}
|
|
9248
|
+
});
|
|
9249
|
+
if (kept.length === turns.length) return { text, turns };
|
|
9250
|
+
if (!kept.length) return null;
|
|
9251
|
+
return { text: kept.map((t) => t.text).join(" "), turns: kept };
|
|
9252
|
+
}
|
|
9253
|
+
/** Same-speaker neighbours (across merged finals) join into one run. */
|
|
9254
|
+
static joinRuns(turns) {
|
|
9255
|
+
return turns.reduce((acc, t) => {
|
|
9256
|
+
const p = acc[acc.length - 1];
|
|
9257
|
+
if (p?.speaker === t.speaker) acc[acc.length - 1] = { ...p, text: `${p.text} ${t.text}`, endMs: t.endMs };
|
|
9258
|
+
else acc.push({ ...t });
|
|
9259
|
+
return acc;
|
|
9260
|
+
}, []);
|
|
9261
|
+
}
|
|
9262
|
+
/** The dispatched text, labelled once the session is multi-speaker. Words never change: when the turns' words no longer
|
|
9263
|
+
* match the (merged/stripped) text, the whole text goes under the speaker with the most words. */
|
|
9264
|
+
labelTurns(text, turns) {
|
|
9265
|
+
if (!turns.length) return { out: text };
|
|
9266
|
+
const runs = _VoiceEngine.joinRuns(turns);
|
|
9267
|
+
for (const t of runs) this.speakerWords.set(t.speaker, (this.speakerWords.get(t.speaker) ?? 0) + this.words(t.text).length);
|
|
9268
|
+
if (!this.labelling && [...this.speakerWords.values()].filter((n) => n >= 3).length >= 2) {
|
|
9269
|
+
this.labelling = true;
|
|
9270
|
+
this.diag("speaker_labels", { on: true });
|
|
9271
|
+
}
|
|
9272
|
+
if (!this.labelling) return { out: text };
|
|
9273
|
+
const lines = normWord(runs.map((t) => t.text).join(" ")) === normWord(text) ? runs : [{ ...runs.reduce((a, b) => this.words(b.text).length > this.words(a.text).length ? b : a), text }];
|
|
9274
|
+
const names = lines.map((t) => this.options.speakerResolver.name(t.speaker, t));
|
|
9275
|
+
return { out: formatTurns(lines, (t) => names[lines.indexOf(t)]), speakers: [...new Set(names)] };
|
|
9276
|
+
}
|
|
9277
|
+
handleUtterance(text, langs, rawTurns) {
|
|
9278
|
+
let turns;
|
|
9279
|
+
if (this.echoHead) {
|
|
9280
|
+
this.echoHead = false;
|
|
9281
|
+
text = this.dropEchoHead(text);
|
|
9282
|
+
}
|
|
9283
|
+
[text, turns] = this.acceptTurns(text, rawTurns);
|
|
8857
9284
|
if (this.speaking && this.echoesDispatch(text)) {
|
|
8858
9285
|
this.diag("utterance_drop", { reason: "dup_final", text: text.slice(0, 60) });
|
|
8859
9286
|
if (this.pausedAt) {
|
|
@@ -8864,6 +9291,8 @@ var VoiceEngine = class _VoiceEngine {
|
|
|
8864
9291
|
}
|
|
8865
9292
|
if (this.decideTimer) {
|
|
8866
9293
|
this.decideHeldFinal = this.mergeUtterance(this.decideHeldFinal, text);
|
|
9294
|
+
addLangs(this.decideHeldLangs, langs);
|
|
9295
|
+
this.decideHeldTurns.push(...turns);
|
|
8867
9296
|
this.diag("utterance_held", { reason: "overlap_decide", text: text.slice(0, 60) });
|
|
8868
9297
|
return;
|
|
8869
9298
|
}
|
|
@@ -8894,6 +9323,8 @@ var VoiceEngine = class _VoiceEngine {
|
|
|
8894
9323
|
}
|
|
8895
9324
|
if (this.pendingUtt) this.mergePath = "merged";
|
|
8896
9325
|
this.pendingUtt = this.mergeUtterance(this.pendingUtt, text);
|
|
9326
|
+
addLangs(this.pendingLangs, langs);
|
|
9327
|
+
this.pendingTurns.push(...turns);
|
|
8897
9328
|
if (this.pendingTimer) this.clock.clearTimeout(this.pendingTimer);
|
|
8898
9329
|
if (this.options.adaptiveEndpointing) {
|
|
8899
9330
|
const holdMs = computeHoldMs({
|
|
@@ -8943,8 +9374,12 @@ var VoiceEngine = class _VoiceEngine {
|
|
|
8943
9374
|
}
|
|
8944
9375
|
this.bcCount = 0;
|
|
8945
9376
|
this.bcPartial = "";
|
|
8946
|
-
|
|
9377
|
+
let text = this.stripBackchannelEcho(this.pendingUtt);
|
|
8947
9378
|
this.pendingUtt = "";
|
|
9379
|
+
const langs = this.pendingLangs;
|
|
9380
|
+
this.pendingLangs = {};
|
|
9381
|
+
let turns = this.pendingTurns;
|
|
9382
|
+
this.pendingTurns = [];
|
|
8948
9383
|
const path = this.mergePath;
|
|
8949
9384
|
this.mergePath = "direct";
|
|
8950
9385
|
const heldTier = this.holdTier;
|
|
@@ -8967,7 +9402,27 @@ var VoiceEngine = class _VoiceEngine {
|
|
|
8967
9402
|
this.lastDispatchText = text;
|
|
8968
9403
|
return;
|
|
8969
9404
|
}
|
|
8970
|
-
const
|
|
9405
|
+
const cont = !refinal && !answered && !!this.lastDispatchText && this.clock.now() - this.lastDispatchAt < this.options.pendingMergeMs;
|
|
9406
|
+
if (cont) {
|
|
9407
|
+
if (this.speaking) this.interrupt();
|
|
9408
|
+
text = this.mergeUtterance(this.lastDispatchText, text);
|
|
9409
|
+
addLangs(langs, this.lastDispatchLangs);
|
|
9410
|
+
turns = [...this.lastDispatchTurns, ...turns];
|
|
9411
|
+
this.diag("utterance_merge", { reason: "pending_reply", text: text.slice(0, 60) });
|
|
9412
|
+
}
|
|
9413
|
+
const sup = refinal || cont;
|
|
9414
|
+
const lang = dominantLang(langs);
|
|
9415
|
+
this.lastDispatchLangs = langs;
|
|
9416
|
+
this.lastDispatchTurns = turns;
|
|
9417
|
+
const { out, speakers } = this.labelTurns(text, turns);
|
|
9418
|
+
const heardAgo = this.lastWordAt ? Math.max(0, Math.round(this.clock.now() - this.lastWordAt)) : void 0;
|
|
9419
|
+
const meta = sup || lang || speakers || heardAgo !== void 0 ? {
|
|
9420
|
+
...sup ? { supersedes: this.lastDispatchOut } : {},
|
|
9421
|
+
...lang ? { language: lang } : {},
|
|
9422
|
+
...speakers ? { speakers, plain: text } : {},
|
|
9423
|
+
...heardAgo !== void 0 ? { lastWordAgoMs: heardAgo } : {}
|
|
9424
|
+
} : void 0;
|
|
9425
|
+
this.lastDispatchOut = out;
|
|
8971
9426
|
this.lastDispatchFlat = flat;
|
|
8972
9427
|
this.lastDispatchWords = text.trim().split(/\s+/);
|
|
8973
9428
|
this.lastDispatchText = text;
|
|
@@ -8975,18 +9430,28 @@ var VoiceEngine = class _VoiceEngine {
|
|
|
8975
9430
|
this.repliedSinceDispatch = false;
|
|
8976
9431
|
this.dispatchReply = "";
|
|
8977
9432
|
this.lastDispatchWasQuestion = /\?\s*$/.test(text);
|
|
8978
|
-
this.bargedBeforeDispatch =
|
|
9433
|
+
this.bargedBeforeDispatch = sup ? this.bargedBeforeDispatch || this.bargedSinceDispatch : this.bargedSinceDispatch;
|
|
8979
9434
|
this.bargedSinceDispatch = false;
|
|
8980
|
-
this.dispatchRefinal =
|
|
8981
|
-
if (!
|
|
9435
|
+
this.dispatchRefinal = sup;
|
|
9436
|
+
if (!sup) this.ackSpent = false;
|
|
8982
9437
|
this.turnStartAt = this.clock.now();
|
|
8983
9438
|
this.bargeGraceUntil = this.clock.now() + this.options.bargeGraceMs;
|
|
8984
|
-
this.diag("dispatch", { text, path: refinal ? "refinalized" : path, heldTier, question: this.lastDispatchWasQuestion, ...this.bargedBeforeDispatch ? { barged: true } : {} });
|
|
8985
|
-
this.options.onUtterance(
|
|
9439
|
+
this.diag("dispatch", { text, path: refinal ? "refinalized" : cont ? "merged_pending" : path, heldTier, question: this.lastDispatchWasQuestion, ...this.bargedBeforeDispatch ? { barged: true } : {} });
|
|
9440
|
+
this.options.onUtterance(out, meta);
|
|
8986
9441
|
}
|
|
8987
9442
|
}
|
|
9443
|
+
takeHeldLangs() {
|
|
9444
|
+
const l = this.decideHeldLangs;
|
|
9445
|
+
this.decideHeldLangs = {};
|
|
9446
|
+
return l;
|
|
9447
|
+
}
|
|
9448
|
+
takeHeldTurns() {
|
|
9449
|
+
const t = this.decideHeldTurns;
|
|
9450
|
+
this.decideHeldTurns = [];
|
|
9451
|
+
return t;
|
|
9452
|
+
}
|
|
8988
9453
|
get overlapCapable() {
|
|
8989
|
-
return this.usingAec && this.options.overlapPause &&
|
|
9454
|
+
return this.usingAec && this.options.overlapPause && this.player.canPause;
|
|
8990
9455
|
}
|
|
8991
9456
|
/** Stop/question words that make an overlap an obvious barge — never held for a host decision. */
|
|
8992
9457
|
static OVERLAP_CEDE_WORDS = /* @__PURE__ */ new Set([
|
|
@@ -9016,12 +9481,12 @@ var VoiceEngine = class _VoiceEngine {
|
|
|
9016
9481
|
/** Cede the floor to an overlap: interrupt, tell the host, then dispatch a final that was held while deciding. */
|
|
9017
9482
|
cedeOverlap(trigger, txt) {
|
|
9018
9483
|
const phase = this.ctxOpen ? "speaking" : "drain";
|
|
9019
|
-
const held = this.decideHeldFinal;
|
|
9484
|
+
const held = this.decideHeldFinal, heldLangs = this.takeHeldLangs(), heldTurns = this.takeHeldTurns();
|
|
9020
9485
|
this.decideHeldFinal = "";
|
|
9021
9486
|
this.diag("barge_in", { phase, trigger, novel: this.novelWords(txt).length, total: this.words(txt).length });
|
|
9022
9487
|
this.interrupt();
|
|
9023
9488
|
this.options.onBargeIn(phase);
|
|
9024
|
-
if (held) this.handleUtterance(held);
|
|
9489
|
+
if (held) this.handleUtterance(held, heldLangs, heldTurns);
|
|
9025
9490
|
}
|
|
9026
9491
|
/** Wait (bounded) for the host's verdict. `fresh` = a re-decision on grown text: it gets its own window — the host
|
|
9027
9492
|
* was only just asked about it (live: "Oh," → "Oh, that" → "Oh, that— that's new" outgrew every verdict, and the
|
|
@@ -9053,7 +9518,7 @@ var VoiceEngine = class _VoiceEngine {
|
|
|
9053
9518
|
* is dropped. Words beyond `heard` are a new overlap, decided afresh: if the partial/final has already grown past
|
|
9054
9519
|
* it, the hold stays and `overlap_pause` is re-emitted for a new verdict (bounded by overlapDecideMs, else it
|
|
9055
9520
|
* cedes; a re-decision gets its own window, the whole hold capped at 3× it) and this returns false. Also false when no overlap hold is live (the engine already decided). */
|
|
9056
|
-
decideOverlap(choice, heard) {
|
|
9521
|
+
decideOverlap(choice, heard, aside) {
|
|
9057
9522
|
if (!this.pausedAt || !this.speaking) return false;
|
|
9058
9523
|
if (choice === "yield") {
|
|
9059
9524
|
this.cedeOverlap("host_yield", this.lastOverlapPartial);
|
|
@@ -9072,13 +9537,84 @@ var VoiceEngine = class _VoiceEngine {
|
|
|
9072
9537
|
}
|
|
9073
9538
|
const held = this.decideHeldFinal;
|
|
9074
9539
|
this.decideHeldFinal = "";
|
|
9540
|
+
this.decideHeldLangs = {};
|
|
9541
|
+
this.decideHeldTurns = [];
|
|
9075
9542
|
this.diag("overlap_resume", { heldMs: Math.round(this.clock.now() - this.pausedAt), reason: "host_keep" });
|
|
9076
9543
|
if (held) this.diag("utterance_drop", { reason: "overlap_kept", text: held.slice(0, 60) });
|
|
9077
9544
|
this.overlapKeptUntil = held ? 0 : this.clock.now() + 4e3;
|
|
9078
|
-
this.
|
|
9545
|
+
const asided = !!aside?.trim() && this.startAside(aside.trim());
|
|
9546
|
+
this.resetOverlap(!asided);
|
|
9079
9547
|
this.lastResumeAt = 0;
|
|
9080
9548
|
return true;
|
|
9081
9549
|
}
|
|
9550
|
+
/** Aside (decideOverlap's 3rd arg): synthesize it on the aside TTS while the reply stays HELD, then play it ahead of
|
|
9551
|
+
* the reply, which resumes from its pause point (SpliceSink). Its words are pre-seeded as our own (echo) like a
|
|
9552
|
+
* blip — its mic echo never reads as the user. false = no aside TTS: the caller resumes as usual. */
|
|
9553
|
+
startAside(text) {
|
|
9554
|
+
const t = this.options.asideTts;
|
|
9555
|
+
if (!t || !/[\p{L}\p{N}]/u.test(text)) {
|
|
9556
|
+
this.diag("aside_skipped", { reason: t ? "empty" : "no_tts", text: text.slice(0, 40) });
|
|
9557
|
+
return false;
|
|
9558
|
+
}
|
|
9559
|
+
const epoch = ++this.asideEpoch, chunks = [], t0 = this.clock.now();
|
|
9560
|
+
const live = () => epoch === this.asideEpoch;
|
|
9561
|
+
const give = (reason) => {
|
|
9562
|
+
if (!live()) return;
|
|
9563
|
+
this.asideEpoch++;
|
|
9564
|
+
this.diag("aside_skipped", { reason, text: text.slice(0, 40) });
|
|
9565
|
+
try {
|
|
9566
|
+
t.cancel();
|
|
9567
|
+
} catch {
|
|
9568
|
+
}
|
|
9569
|
+
if (this.speaking && !this.pausedAt) this.player.resume();
|
|
9570
|
+
};
|
|
9571
|
+
const timer = this.clock.setTimeout(() => give("late"), this.options.asideMaxMs);
|
|
9572
|
+
for (const w of this.words(text)) this.echoWords.add(w);
|
|
9573
|
+
this.ackAt = t0;
|
|
9574
|
+
this.lastAck = text;
|
|
9575
|
+
this.echoUntil = Math.max(this.echoUntil, t0 + 2500 + this.options.asideMaxMs);
|
|
9576
|
+
t.onAudio = (c) => {
|
|
9577
|
+
if (live()) chunks.push(c);
|
|
9578
|
+
};
|
|
9579
|
+
t.onDone = () => {
|
|
9580
|
+
if (!live()) return;
|
|
9581
|
+
this.clock.clearTimeout(timer);
|
|
9582
|
+
const n = chunks.reduce((a, c) => a + c.length, 0);
|
|
9583
|
+
if (!n || !this.speaking || this.pausedAt) return give(!n ? "no_audio" : this.pausedAt ? "held_again" : "turn_over");
|
|
9584
|
+
this.asideEpoch++;
|
|
9585
|
+
const clip2 = new Uint8Array(n);
|
|
9586
|
+
let i = 0;
|
|
9587
|
+
for (const c of chunks) {
|
|
9588
|
+
clip2.set(c, i);
|
|
9589
|
+
i += c.length;
|
|
9590
|
+
}
|
|
9591
|
+
const from = this.player.splice(clip2);
|
|
9592
|
+
const now3 = this.clock.now();
|
|
9593
|
+
this.overlapKeptUntil = Math.max(this.overlapKeptUntil, now3 + 4e3);
|
|
9594
|
+
this.echoUntil = Math.max(this.echoUntil, now3 + 2500 + this.player.drainMs());
|
|
9595
|
+
this.diag("aside", { text: text.slice(0, 40), fromMs: Math.round(from), clipMs: Math.round(n / (TTS_SAMPLE_RATE * 2) * 1e3), synthMs: Math.round(now3 - t0) });
|
|
9596
|
+
};
|
|
9597
|
+
try {
|
|
9598
|
+
const lang = this.tts.options?.language, ao = t.options;
|
|
9599
|
+
if (lang && ao) ao.language = lang;
|
|
9600
|
+
t.newContext();
|
|
9601
|
+
t.speak(text, false);
|
|
9602
|
+
} catch (e) {
|
|
9603
|
+
this.clock.clearTimeout(timer);
|
|
9604
|
+
give(`error: ${e instanceof Error ? e.message : e}`);
|
|
9605
|
+
return true;
|
|
9606
|
+
}
|
|
9607
|
+
return true;
|
|
9608
|
+
}
|
|
9609
|
+
cancelAside(reason) {
|
|
9610
|
+
if (!this.options.asideTts) return;
|
|
9611
|
+
this.asideEpoch++;
|
|
9612
|
+
try {
|
|
9613
|
+
this.options.asideTts.cancel();
|
|
9614
|
+
} catch (e) {
|
|
9615
|
+
log15.debug(`aside cancel (${reason}): ${e instanceof Error ? e.message : e}`);
|
|
9616
|
+
}
|
|
9617
|
+
}
|
|
9082
9618
|
armResume() {
|
|
9083
9619
|
if (this.resumeTimer) this.clock.clearTimeout(this.resumeTimer);
|
|
9084
9620
|
this.resumeTimer = this.clock.setTimeout(() => {
|
|
@@ -9099,11 +9635,13 @@ var VoiceEngine = class _VoiceEngine {
|
|
|
9099
9635
|
this.decideTimer = null;
|
|
9100
9636
|
}
|
|
9101
9637
|
this.decideSince = 0;
|
|
9102
|
-
const held = this.decideHeldFinal;
|
|
9638
|
+
const held = this.decideHeldFinal, heldLangs = this.takeHeldLangs(), heldTurns = this.takeHeldTurns();
|
|
9103
9639
|
this.decideHeldFinal = "";
|
|
9104
9640
|
if (held) {
|
|
9105
9641
|
this.diag("utterance_release", { reason: "overlap_hold_exit", text: held.slice(0, 60) });
|
|
9106
9642
|
this.pendingUtt = this.mergeUtterance(this.pendingUtt, held);
|
|
9643
|
+
addLangs(this.pendingLangs, heldLangs);
|
|
9644
|
+
this.pendingTurns.push(...heldTurns);
|
|
9107
9645
|
if (this.pendingTimer) this.clock.clearTimeout(this.pendingTimer);
|
|
9108
9646
|
this.pendingTimer = this.clock.setTimeout(() => this.flushUtterance(), 0);
|
|
9109
9647
|
}
|
|
@@ -9153,13 +9691,6 @@ var VoiceEngine = class _VoiceEngine {
|
|
|
9153
9691
|
}
|
|
9154
9692
|
};
|
|
9155
9693
|
|
|
9156
|
-
// node_modules/@bod.ee/voice/src/core/types.ts
|
|
9157
|
-
var STT_SAMPLE_RATE = 16e3;
|
|
9158
|
-
var TTS_SAMPLE_RATE = 44100;
|
|
9159
|
-
async function resolveAuth(auth) {
|
|
9160
|
-
return typeof auth === "function" ? await auth() : auth;
|
|
9161
|
-
}
|
|
9162
|
-
|
|
9163
9694
|
// node_modules/@bod.ee/voice/src/core/spokenSplitter.ts
|
|
9164
9695
|
var OPEN = "<spoken>";
|
|
9165
9696
|
var CLOSE = "</spoken>";
|
|
@@ -9238,6 +9769,52 @@ var SpokenSplitter = class {
|
|
|
9238
9769
|
}
|
|
9239
9770
|
};
|
|
9240
9771
|
|
|
9772
|
+
// node_modules/@bod.ee/voice/src/core/pronounce.ts
|
|
9773
|
+
var PRONOUNCE = {
|
|
9774
|
+
TODO: "to-do",
|
|
9775
|
+
TODOs: "to-dos",
|
|
9776
|
+
ToDo: "to-do",
|
|
9777
|
+
Todo: "to-do",
|
|
9778
|
+
todo: "to-do",
|
|
9779
|
+
todos: "to-dos",
|
|
9780
|
+
DOING: "doing",
|
|
9781
|
+
BACKLOG: "backlog",
|
|
9782
|
+
DONE: "done",
|
|
9783
|
+
PARKED: "parked",
|
|
9784
|
+
BLOCKED: "blocked",
|
|
9785
|
+
FIXME: "fix-me",
|
|
9786
|
+
WIP: "work-in-progress"
|
|
9787
|
+
};
|
|
9788
|
+
var WORD = /[\p{L}\p{N}_]+/gu;
|
|
9789
|
+
var Pronouncer = class {
|
|
9790
|
+
constructor(map = PRONOUNCE) {
|
|
9791
|
+
this.map = map;
|
|
9792
|
+
this.prefixes = new Set(Object.keys(map).flatMap((k) => [...k].map((_, i) => k.slice(0, i + 1))));
|
|
9793
|
+
}
|
|
9794
|
+
map;
|
|
9795
|
+
tail = "";
|
|
9796
|
+
prefixes;
|
|
9797
|
+
/** Replace whole-word keys in a complete text (no hold). */
|
|
9798
|
+
apply(t) {
|
|
9799
|
+
return t.replace(WORD, (w) => Object.hasOwn(this.map, w) ? this.map[w] : w);
|
|
9800
|
+
}
|
|
9801
|
+
feed(delta) {
|
|
9802
|
+
const t = this.tail + delta;
|
|
9803
|
+
const last = /[\p{L}\p{N}_]+$/u.exec(t);
|
|
9804
|
+
const hold = last && this.prefixes.has(last[0]) ? last[0] : "";
|
|
9805
|
+
this.tail = hold;
|
|
9806
|
+
return this.apply(hold ? t.slice(0, -hold.length) : t);
|
|
9807
|
+
}
|
|
9808
|
+
flush() {
|
|
9809
|
+
const t = this.apply(this.tail);
|
|
9810
|
+
this.tail = "";
|
|
9811
|
+
return t;
|
|
9812
|
+
}
|
|
9813
|
+
reset() {
|
|
9814
|
+
this.tail = "";
|
|
9815
|
+
}
|
|
9816
|
+
};
|
|
9817
|
+
|
|
9241
9818
|
// node_modules/@bod.ee/voice/src/adapters/soniox.ts
|
|
9242
9819
|
var log16 = forComponent2("SonioxSTT");
|
|
9243
9820
|
var now = () => performance.now();
|
|
@@ -9250,6 +9827,23 @@ var SonioxSTTOptions = class {
|
|
|
9250
9827
|
* `stt-rt-v5` is live today (verified against GET https://api.soniox.com/v1/models). */
|
|
9251
9828
|
model = "stt-rt-v5";
|
|
9252
9829
|
languageHints = ["en"];
|
|
9830
|
+
/** Opt-in Soniox language identification (`enable_language_identification`): every token is tagged with a
|
|
9831
|
+
* `language` code, and onUtterance's 3rd arg reports the utterance's dominant one (by characters). */
|
|
9832
|
+
languageIdentification = false;
|
|
9833
|
+
/** Restrict recognition to `languageHints` (Soniox `language_hints_strict`, best-effort) AND drop any token written in a
|
|
9834
|
+
* script none of the hinted languages use (Latin always passes: names, brands). A he+en call heard Punjabi
|
|
9835
|
+
* ("ਹਾਂ ਜੀ।") in noise and the junk reached the turn + chat title (bare-browser #938). */
|
|
9836
|
+
languageHintsStrict = false;
|
|
9837
|
+
/** Drop words written in a script that is neither a hinted language's, Latin, nor the utterance's own main script —
|
|
9838
|
+
* stray noise transcribed in a third script ('ਹਾਂ ਜੀ। בסדר…' → 'בסדר…'). Unlike languageHintsStrict it never drops
|
|
9839
|
+
* the language the user actually speaks, hinted or not (a Hebrew speaker on an en-US phone). */
|
|
9840
|
+
dropStrayScripts = false;
|
|
9841
|
+
/** Opt-in Soniox speaker diarization (`enable_speaker_diarization`): onUtterance's 4th arg carries the
|
|
9842
|
+
* utterance split into per-speaker turns (raw Soniox speaker ids; flaps merged by speakerRuns). */
|
|
9843
|
+
diarization = false;
|
|
9844
|
+
/** Custom vocabulary (Soniox `context.terms`): rare words the model should prefer — names, brands,
|
|
9845
|
+
* projects ("Livshitz", not "Lead Sheets"). Empty = no context sent. Soniox caps context at ~8k tokens. */
|
|
9846
|
+
terms = [];
|
|
9253
9847
|
/** Client-side endpoint: finalized text + no new tokens for this long = utterance (don't wait for
|
|
9254
9848
|
* Soniox's semantic <end>, which adds 0.5-1.5s — the difference between ping-pong and lag). */
|
|
9255
9849
|
silenceEndpointMs = 500;
|
|
@@ -9264,11 +9858,19 @@ var SonioxSTT = class {
|
|
|
9264
9858
|
sourceStarted = false;
|
|
9265
9859
|
onPartial = () => {
|
|
9266
9860
|
};
|
|
9861
|
+
/** `language` = dominant spoken language of the utterance (only with `languageIdentification`). */
|
|
9267
9862
|
onUtterance = () => {
|
|
9268
9863
|
};
|
|
9269
9864
|
/** mic energy (RMS) per chunk — drives the energy-based heuristic barge-in tier */
|
|
9270
9865
|
onLevel = () => {
|
|
9271
9866
|
};
|
|
9867
|
+
/** Audio tap on the Soniox clock: each chunk sent to the current connection, with `streamMs` = where it starts in that
|
|
9868
|
+
* connection's stream — the timeline token `start_ms`/`end_ms` (and so SpeakerTurn.startMs/endMs) refer to. A
|
|
9869
|
+
* reconnect starts a new stream at 0. Chunks dropped while disconnected are not reported. A throwing handler is
|
|
9870
|
+
* disabled (logged) — never affects transcription. */
|
|
9871
|
+
onAudio = null;
|
|
9872
|
+
sentBytes = 0;
|
|
9873
|
+
// s16le bytes sent on the current connection
|
|
9272
9874
|
/** Unrecoverable: the mic source stopped delivering audio (Soniox starves → idle-timeout reconnect
|
|
9273
9875
|
* loop). The host tears voice down instead of spinning forever. */
|
|
9274
9876
|
onFatal = () => {
|
|
@@ -9299,6 +9901,14 @@ var SonioxSTT = class {
|
|
|
9299
9901
|
endpointTimer = null;
|
|
9300
9902
|
firstTokenAt = 0;
|
|
9301
9903
|
// first speech token in current utterance
|
|
9904
|
+
lastWordEndMs = 0;
|
|
9905
|
+
// end_ms (Soniox stream clock) of the current utterance's last spoken token
|
|
9906
|
+
finalLangChars = {};
|
|
9907
|
+
// language → chars of finalized tokens (current utterance)
|
|
9908
|
+
partialLangChars = {};
|
|
9909
|
+
finalToks = [];
|
|
9910
|
+
// diarization only: finalized tokens of the current utterance
|
|
9911
|
+
partialToks = [];
|
|
9302
9912
|
constructor(options) {
|
|
9303
9913
|
this.options = { ...new SonioxSTTOptions(), ...options };
|
|
9304
9914
|
}
|
|
@@ -9308,6 +9918,8 @@ var SonioxSTT = class {
|
|
|
9308
9918
|
async connectWs() {
|
|
9309
9919
|
const apiKey = await resolveAuth(this.options.auth);
|
|
9310
9920
|
this.ws = new WebSocket("wss://stt-rt.soniox.com/transcribe-websocket");
|
|
9921
|
+
this.sentBytes = 0;
|
|
9922
|
+
this.lastWordEndMs = 0;
|
|
9311
9923
|
await new Promise((res, rej) => {
|
|
9312
9924
|
this.ws.onopen = () => res();
|
|
9313
9925
|
this.ws.onerror = (e) => rej(new Error(`soniox ws: ${e.message || "connect failed"}`));
|
|
@@ -9320,7 +9932,11 @@ var SonioxSTT = class {
|
|
|
9320
9932
|
sample_rate: STT_SAMPLE_RATE,
|
|
9321
9933
|
num_channels: 1,
|
|
9322
9934
|
language_hints: this.options.languageHints,
|
|
9323
|
-
enable_endpoint_detection: true
|
|
9935
|
+
enable_endpoint_detection: true,
|
|
9936
|
+
...this.options.languageHintsStrict ? { language_hints_strict: true } : {},
|
|
9937
|
+
...this.options.languageIdentification ? { enable_language_identification: true } : {},
|
|
9938
|
+
...this.options.diarization ? { enable_speaker_diarization: true } : {},
|
|
9939
|
+
...this.options.terms?.length ? { context: { terms: this.options.terms } } : {}
|
|
9324
9940
|
})
|
|
9325
9941
|
);
|
|
9326
9942
|
this.ws.onmessage = (ev) => this.handle(JSON.parse(String(ev.data)));
|
|
@@ -9343,8 +9959,10 @@ var SonioxSTT = class {
|
|
|
9343
9959
|
const combined = (this.finalText + this.partialText).trim();
|
|
9344
9960
|
if (!combined || now() - this.lastChangeAt < this.options.silenceEndpointMs) return;
|
|
9345
9961
|
if (this.firstTokenAt) log16.debug(`stt: ${Math.round(now() - this.firstTokenAt)}ms first-token\u2192silence-endpoint, "${combined.slice(0, 60)}"`);
|
|
9962
|
+
const language = this.language(true);
|
|
9963
|
+
const turns = this.turns(true), ago = this.lastWordAgoMs();
|
|
9346
9964
|
this.reset();
|
|
9347
|
-
this.onUtterance(combined, now());
|
|
9965
|
+
this.onUtterance(this.stray(combined), now(), language, turns, ago);
|
|
9348
9966
|
}, 120);
|
|
9349
9967
|
this.endpointTimer.unref?.();
|
|
9350
9968
|
this.startedChunksAt = now();
|
|
@@ -9371,7 +9989,19 @@ var SonioxSTT = class {
|
|
|
9371
9989
|
sum += v * v;
|
|
9372
9990
|
}
|
|
9373
9991
|
this.onLevel(Math.sqrt(sum / (chunk.byteLength / 2)));
|
|
9374
|
-
if (this.ws.readyState === WebSocket.OPEN)
|
|
9992
|
+
if (this.ws.readyState === WebSocket.OPEN) {
|
|
9993
|
+
this.ws.send(chunk);
|
|
9994
|
+
const at = this.sentBytes / 2 / STT_SAMPLE_RATE * 1e3;
|
|
9995
|
+
this.sentBytes += chunk.byteLength;
|
|
9996
|
+
if (this.onAudio) {
|
|
9997
|
+
try {
|
|
9998
|
+
this.onAudio(chunk, at);
|
|
9999
|
+
} catch (e) {
|
|
10000
|
+
this.onAudio = null;
|
|
10001
|
+
log16.warn(`onAudio threw \u2014 audio tap disabled: ${e instanceof Error ? e.message : e}`);
|
|
10002
|
+
}
|
|
10003
|
+
}
|
|
10004
|
+
}
|
|
9375
10005
|
});
|
|
9376
10006
|
}
|
|
9377
10007
|
handle(m) {
|
|
@@ -9380,30 +10010,78 @@ var SonioxSTT = class {
|
|
|
9380
10010
|
return log16.error(`soniox: ${m.error_message}`);
|
|
9381
10011
|
}
|
|
9382
10012
|
let endpoint = false;
|
|
10013
|
+
const foreign = this.options.languageHintsStrict ? foreignScript(this.options.languageHints) : null;
|
|
10014
|
+
if (foreign && m.tokens?.length) m = { ...m, tokens: m.tokens.filter((t) => t.text === "<end>" || !foreign(t.text)) };
|
|
9383
10015
|
for (const t of m.tokens ?? []) {
|
|
10016
|
+
if (t.text !== "<end>" && typeof t.end_ms === "number" && String(t.text).trim() && t.end_ms > this.lastWordEndMs) this.lastWordEndMs = t.end_ms;
|
|
9384
10017
|
if (t.text === "<end>") endpoint = true;
|
|
9385
|
-
else if (t.is_final)
|
|
10018
|
+
else if (t.is_final) {
|
|
10019
|
+
this.finalText += t.text;
|
|
10020
|
+
this.countLang(this.finalLangChars, t);
|
|
10021
|
+
if (this.options.diarization) this.finalToks.push(t);
|
|
10022
|
+
}
|
|
9386
10023
|
}
|
|
9387
|
-
|
|
10024
|
+
const partials = (m.tokens ?? []).filter((t) => !t.is_final && t.text !== "<end>");
|
|
10025
|
+
this.partialText = partials.map((t) => t.text).join("");
|
|
10026
|
+
this.partialLangChars = {};
|
|
10027
|
+
for (const t of partials) this.countLang(this.partialLangChars, t);
|
|
10028
|
+
if (this.options.diarization) this.partialToks = partials;
|
|
9388
10029
|
const combined = this.finalText + this.partialText;
|
|
9389
10030
|
if (combined !== this.lastCombined) {
|
|
9390
10031
|
this.lastCombined = combined;
|
|
9391
10032
|
this.lastChangeAt = now();
|
|
9392
10033
|
if (!this.firstTokenAt && combined.trim()) this.firstTokenAt = now();
|
|
9393
10034
|
}
|
|
9394
|
-
this.onPartial(combined);
|
|
10035
|
+
this.onPartial(this.stray(combined), this.turns(true));
|
|
9395
10036
|
if (endpoint && this.finalText.trim()) {
|
|
9396
10037
|
const utterance = this.finalText.trim();
|
|
9397
10038
|
if (this.firstTokenAt) log16.debug(`stt: ${Math.round(now() - this.firstTokenAt)}ms first-token\u2192endpoint, "${utterance.slice(0, 60)}"`);
|
|
10039
|
+
const language = this.language(false);
|
|
10040
|
+
const turns = this.turns(false), ago = this.lastWordAgoMs();
|
|
9398
10041
|
this.reset();
|
|
9399
|
-
this.onUtterance(utterance, now());
|
|
10042
|
+
this.onUtterance(this.stray(utterance), now(), language, turns, ago);
|
|
9400
10043
|
}
|
|
9401
10044
|
}
|
|
10045
|
+
/** How long ago (ms, now) the utterance's last spoken word ended: the audio sent so far minus that token's end_ms on
|
|
10046
|
+
* Soniox's stream clock — the user's real last word, before Soniox's latency and the silence endpoint. */
|
|
10047
|
+
lastWordAgoMs() {
|
|
10048
|
+
if (!this.lastWordEndMs) return void 0;
|
|
10049
|
+
return Math.max(0, Math.round(this.sentBytes / 2 / STT_SAMPLE_RATE * 1e3 - this.lastWordEndMs));
|
|
10050
|
+
}
|
|
10051
|
+
stray(text) {
|
|
10052
|
+
return this.options.dropStrayScripts ? dropStrayScripts(text, this.options.languageHints) : text;
|
|
10053
|
+
}
|
|
10054
|
+
countLang(acc, t) {
|
|
10055
|
+
if (typeof t.language === "string" && t.language && String(t.text).trim()) acc[t.language] = (acc[t.language] ?? 0) + String(t.text).trim().length;
|
|
10056
|
+
}
|
|
10057
|
+
/** Dominant language (most characters) of the current utterance; undefined when Soniox tagged none. */
|
|
10058
|
+
language(withPartials) {
|
|
10059
|
+
const acc = { ...this.finalLangChars };
|
|
10060
|
+
if (withPartials) for (const [l, n] of Object.entries(this.partialLangChars)) acc[l] = (acc[l] ?? 0) + n;
|
|
10061
|
+
let best;
|
|
10062
|
+
let max = 0;
|
|
10063
|
+
for (const [l, n] of Object.entries(acc)) if (n > max) {
|
|
10064
|
+
best = l;
|
|
10065
|
+
max = n;
|
|
10066
|
+
}
|
|
10067
|
+
return best;
|
|
10068
|
+
}
|
|
10069
|
+
/** Per-speaker turns of the current utterance (diarization only; undefined otherwise or when Soniox tagged no speaker). */
|
|
10070
|
+
turns(withPartials) {
|
|
10071
|
+
if (!this.options.diarization) return void 0;
|
|
10072
|
+
const words3 = sonioxWords(withPartials ? [...this.finalToks, ...this.partialToks] : this.finalToks);
|
|
10073
|
+
return words3.some((w) => w.spk != null) ? speakerRuns(words3) : void 0;
|
|
10074
|
+
}
|
|
9402
10075
|
reset() {
|
|
10076
|
+
this.finalToks = [];
|
|
10077
|
+
this.partialToks = [];
|
|
10078
|
+
this.finalLangChars = {};
|
|
10079
|
+
this.partialLangChars = {};
|
|
9403
10080
|
this.finalText = "";
|
|
9404
10081
|
this.partialText = "";
|
|
9405
10082
|
this.lastCombined = "";
|
|
9406
10083
|
this.firstTokenAt = 0;
|
|
10084
|
+
this.lastWordEndMs = 0;
|
|
9407
10085
|
}
|
|
9408
10086
|
stop() {
|
|
9409
10087
|
this.stopped = true;
|
|
@@ -9414,6 +10092,65 @@ var SonioxSTT = class {
|
|
|
9414
10092
|
this.ws?.close();
|
|
9415
10093
|
}
|
|
9416
10094
|
};
|
|
10095
|
+
var SCRIPTS = {
|
|
10096
|
+
he: ["Hebrew"],
|
|
10097
|
+
yi: ["Hebrew"],
|
|
10098
|
+
ar: ["Arabic"],
|
|
10099
|
+
fa: ["Arabic"],
|
|
10100
|
+
ur: ["Arabic"],
|
|
10101
|
+
ru: ["Cyrillic"],
|
|
10102
|
+
uk: ["Cyrillic"],
|
|
10103
|
+
bg: ["Cyrillic"],
|
|
10104
|
+
sr: ["Cyrillic"],
|
|
10105
|
+
el: ["Greek"],
|
|
10106
|
+
hi: ["Devanagari"],
|
|
10107
|
+
mr: ["Devanagari"],
|
|
10108
|
+
ne: ["Devanagari"],
|
|
10109
|
+
bn: ["Bengali"],
|
|
10110
|
+
pa: ["Gurmukhi"],
|
|
10111
|
+
gu: ["Gujarati"],
|
|
10112
|
+
ta: ["Tamil"],
|
|
10113
|
+
te: ["Telugu"],
|
|
10114
|
+
th: ["Thai"],
|
|
10115
|
+
ja: ["Hiragana", "Katakana", "Han"],
|
|
10116
|
+
zh: ["Han"],
|
|
10117
|
+
ko: ["Hangul"],
|
|
10118
|
+
ka: ["Georgian"],
|
|
10119
|
+
hy: ["Armenian"],
|
|
10120
|
+
am: ["Ethiopic"]
|
|
10121
|
+
};
|
|
10122
|
+
var SCRIPT_RES = [.../* @__PURE__ */ new Set(["Latin", ...Object.values(SCRIPTS).flat(), "Gurmukhi", "Devanagari"])].map((sc) => [sc, new RegExp(`\\p{Script=${sc}}`, "u")]);
|
|
10123
|
+
var LETTER = new RegExp("\\p{L}", "u");
|
|
10124
|
+
function mainScript(text) {
|
|
10125
|
+
const n = {};
|
|
10126
|
+
for (const ch of text) {
|
|
10127
|
+
if (!LETTER.test(ch)) continue;
|
|
10128
|
+
const sc = SCRIPT_RES.find(([, re]) => re.test(ch))?.[0] ?? "Other";
|
|
10129
|
+
n[sc] = (n[sc] ?? 0) + 1;
|
|
10130
|
+
}
|
|
10131
|
+
return Object.entries(n).sort((a, b) => b[1] - a[1])[0]?.[0] ?? "";
|
|
10132
|
+
}
|
|
10133
|
+
function dropStrayScripts(text, hints) {
|
|
10134
|
+
const main = mainScript(text), foreign = foreignScript(hints, main && main !== "Other" ? [main] : []);
|
|
10135
|
+
if (!/\S/.test(text)) return text;
|
|
10136
|
+
const lead2 = /^\s/.test(text) ? " " : "", trail = /\s$/.test(text) ? " " : "";
|
|
10137
|
+
const kept = text.split(/\s+/).filter((w) => w && !foreign(w));
|
|
10138
|
+
return kept.length ? lead2 + kept.join(" ") + trail : "";
|
|
10139
|
+
}
|
|
10140
|
+
var foreignTests = /* @__PURE__ */ new Map();
|
|
10141
|
+
function foreignScript(hints, also = []) {
|
|
10142
|
+
const key = [...hints, "|", ...also].join(",");
|
|
10143
|
+
let f = foreignTests.get(key);
|
|
10144
|
+
if (f) return f;
|
|
10145
|
+
const scripts = [.../* @__PURE__ */ new Set(["Common", "Inherited", "Latin", ...also, ...hints.flatMap((h) => SCRIPTS[h.slice(0, 2).toLowerCase()] ?? [])])];
|
|
10146
|
+
const ok = new RegExp(`^[${scripts.map((sc) => `\\p{Script_Extensions=${sc}}`).join("")}]$`, "u");
|
|
10147
|
+
f = (text) => {
|
|
10148
|
+
for (const ch of text) if (!ok.test(ch)) return true;
|
|
10149
|
+
return false;
|
|
10150
|
+
};
|
|
10151
|
+
foreignTests.set(key, f);
|
|
10152
|
+
return f;
|
|
10153
|
+
}
|
|
9417
10154
|
|
|
9418
10155
|
// node_modules/@bod.ee/voice/src/adapters/cartesia.ts
|
|
9419
10156
|
var log17 = forComponent2("CartesiaTTS");
|
|
@@ -9424,12 +10161,34 @@ var CartesiaTTSOptions = class {
|
|
|
9424
10161
|
model = "sonic-3.5";
|
|
9425
10162
|
/** 'apiKey' (server/CLI) → `api_key=` URL param; 'token' (browser, BE-minted) → `access_token=`. */
|
|
9426
10163
|
authMode = "apiKey";
|
|
10164
|
+
/** Cartesia `language` code ('en', 'he', …). Unset → field omitted (provider default). Mutable:
|
|
10165
|
+
* set `tts.options.language` before `newContext()` to switch per context (mixed-language docs) —
|
|
10166
|
+
* it is latched there, so every frame of one context carries the same language. The model must
|
|
10167
|
+
* support it (sonic-3/3.5: 42 languages incl. 'he'; sonic-2/turbo: no Hebrew). */
|
|
10168
|
+
language;
|
|
10169
|
+
/** Cartesia `max_buffer_delay_ms` (integer, 0-5000; provider default 3000): the longest Cartesia
|
|
10170
|
+
* holds `continue: true` text waiting for more before it starts generating. Unset → field omitted
|
|
10171
|
+
* (provider default). Cartesia buffers so tiny inputs (single words/tokens) don't come out choppy
|
|
10172
|
+
* or with unnatural prosody; its guidance is to lower it (0 = generate each frame at once) only
|
|
10173
|
+
* when the caller does its own buffering, i.e. feeds phrase/sentence-sized chunks. Measured: an
|
|
10174
|
+
* unflushed continue frame reaches first audio in ~3 s at the default vs ~0.2 s at 0. A
|
|
10175
|
+
* `continue: false` frame / `end()` flushes regardless. Mutable like `language`: set
|
|
10176
|
+
* `tts.options.maxBufferDelayMs` before `newContext()` — latched there, one value per context. */
|
|
10177
|
+
maxBufferDelayMs;
|
|
10178
|
+
/** Sonic generation_config.emotion ('excited', 'content', 'sad', …). Mutable: the next frame carries it. */
|
|
10179
|
+
emotion;
|
|
10180
|
+
/** Written token → spoken form, swapped before synthesis (whole word, case-sensitive; core/pronounce.ts).
|
|
10181
|
+
* Read at construction. `{}` = off. */
|
|
10182
|
+
pronounce = PRONOUNCE;
|
|
9427
10183
|
};
|
|
9428
10184
|
var CartesiaTTS = class _CartesiaTTS {
|
|
9429
10185
|
options;
|
|
9430
10186
|
ws;
|
|
9431
10187
|
ctxSeq = 0;
|
|
9432
10188
|
ctxId = "";
|
|
10189
|
+
ctxLanguage;
|
|
10190
|
+
ctxMaxBufferDelayMs;
|
|
10191
|
+
say;
|
|
9433
10192
|
onAudio = () => {
|
|
9434
10193
|
};
|
|
9435
10194
|
onDone = () => {
|
|
@@ -9469,6 +10228,9 @@ var CartesiaTTS = class _CartesiaTTS {
|
|
|
9469
10228
|
static CB_PROBE_MS = 3e4;
|
|
9470
10229
|
constructor(options) {
|
|
9471
10230
|
this.options = { ...new CartesiaTTSOptions(), ...options };
|
|
10231
|
+
this.say = new Pronouncer(this.options.pronounce);
|
|
10232
|
+
this.ctxLanguage = this.options.language;
|
|
10233
|
+
this.ctxMaxBufferDelayMs = this.options.maxBufferDelayMs;
|
|
9472
10234
|
}
|
|
9473
10235
|
closed = false;
|
|
9474
10236
|
connecting = null;
|
|
@@ -9558,6 +10320,8 @@ var CartesiaTTS = class _CartesiaTTS {
|
|
|
9558
10320
|
newContext() {
|
|
9559
10321
|
this.ctxId = `ctx-${++this.ctxSeq}`;
|
|
9560
10322
|
this.firstAudioAt = 0;
|
|
10323
|
+
this.ctxLanguage = this.options.language;
|
|
10324
|
+
this.ctxMaxBufferDelayMs = this.options.maxBufferDelayMs;
|
|
9561
10325
|
return this.ctxId;
|
|
9562
10326
|
}
|
|
9563
10327
|
frame(transcript, cont) {
|
|
@@ -9565,26 +10329,42 @@ var CartesiaTTS = class _CartesiaTTS {
|
|
|
9565
10329
|
model_id: this.options.model,
|
|
9566
10330
|
transcript,
|
|
9567
10331
|
voice: { mode: "id", id: this.options.voiceId },
|
|
10332
|
+
...this.ctxLanguage ? { language: this.ctxLanguage } : {},
|
|
9568
10333
|
output_format: { container: "raw", encoding: "pcm_s16le", sample_rate: TTS_SAMPLE_RATE },
|
|
9569
10334
|
context_id: this.ctxId,
|
|
9570
10335
|
continue: cont,
|
|
9571
|
-
...this.
|
|
10336
|
+
...this.ctxMaxBufferDelayMs != null ? { max_buffer_delay_ms: this.ctxMaxBufferDelayMs } : {},
|
|
10337
|
+
// != null: 0 must be sent
|
|
10338
|
+
...this.wantTimestamps ? { add_timestamps: true } : {},
|
|
10339
|
+
...this.options.emotion ? { generation_config: { emotion: this.options.emotion } } : {}
|
|
9572
10340
|
});
|
|
9573
10341
|
}
|
|
9574
10342
|
speak(text, cont) {
|
|
9575
10343
|
if (this.down) return;
|
|
10344
|
+
text = cont ? this.say.feed(text) : this.say.feed(text) + this.say.flush();
|
|
9576
10345
|
if (cont && !text) return;
|
|
9577
10346
|
if (this.ws?.readyState === WebSocket.OPEN) this.ws.send(this.frame(text, cont));
|
|
9578
10347
|
else void this.ensureConnected().then(() => this.ws?.readyState === WebSocket.OPEN && this.ws.send(this.frame(text, cont)));
|
|
9579
10348
|
}
|
|
10349
|
+
/** Generate what this context has buffered NOW (a `flush: true` frame) — the context stays open and later
|
|
10350
|
+
* continuations keep its prosody. A host streaming word-sized deltas flushes the reply's first clause, so speech
|
|
10351
|
+
* starts there instead of waiting for Cartesia's buffer (a sentence end, or max_buffer_delay_ms). */
|
|
10352
|
+
flush() {
|
|
10353
|
+
if (this.down || !this.ctxId || this.ws?.readyState !== WebSocket.OPEN) return;
|
|
10354
|
+
const held = this.say.flush();
|
|
10355
|
+
if (held) this.ws.send(this.frame(held, true));
|
|
10356
|
+
this.ws.send(JSON.stringify({ ...JSON.parse(this.frame("", true)), flush: true }));
|
|
10357
|
+
}
|
|
9580
10358
|
end() {
|
|
10359
|
+
const held = this.say.flush();
|
|
9581
10360
|
if (this.down) {
|
|
9582
10361
|
this.onDone();
|
|
9583
10362
|
return;
|
|
9584
10363
|
}
|
|
9585
|
-
if (this.ws?.readyState === WebSocket.OPEN) this.ws.send(this.frame(
|
|
10364
|
+
if (this.ws?.readyState === WebSocket.OPEN) this.ws.send(this.frame(held, false));
|
|
9586
10365
|
}
|
|
9587
10366
|
cancel() {
|
|
10367
|
+
this.say.reset();
|
|
9588
10368
|
if (this.ws?.readyState === WebSocket.OPEN) this.ws.send(JSON.stringify({ context_id: this.ctxId, cancel: true }));
|
|
9589
10369
|
}
|
|
9590
10370
|
startProbe() {
|
|
@@ -10069,7 +10849,7 @@ function pendingQuestion(text, lastWords = 6) {
|
|
|
10069
10849
|
const t = sentence.slice(-lastWords).join(" ");
|
|
10070
10850
|
return /\b(can|could|would|will|do|does|did|is|are|should)\s+(you|we|i|it|there|they|he|she)\b/.test(t) || /(^|\s)(האם|אתה יכול|את יכולה)(\s|$)/u.test(t) || /\b(what|why|how|where|when|who|which)\s+(do|does|did|is|are|should|would|can|could|will)\s+(you|we|i|it|they|he|she)\b/.test(sentence.slice(-4 * lastWords).join(" "));
|
|
10071
10851
|
}
|
|
10072
|
-
var
|
|
10852
|
+
var SCRIPTS2 = [
|
|
10073
10853
|
[new RegExp("\\p{Script=Hebrew}", "gu"), "he"],
|
|
10074
10854
|
[new RegExp("\\p{Script=Arabic}", "gu"), "ar"],
|
|
10075
10855
|
[new RegExp("\\p{Script=Cyrillic}", "gu"), "ru"],
|
|
@@ -10091,7 +10871,7 @@ var STOP3 = Object.fromEntries(Object.entries({
|
|
|
10091
10871
|
pt: "ol\xE1 oi sim obrigado obrigada o a os as que \xE9 e de em um uma n\xE3o para com mas meu eu voc\xEA",
|
|
10092
10872
|
nl: "hoi dank de het een en is ik je niet van dat met voor maar mijn wat"
|
|
10093
10873
|
}).map(([k, v]) => [k, new Set(v.split(" "))]));
|
|
10094
|
-
var scriptOf = (w) =>
|
|
10874
|
+
var scriptOf = (w) => SCRIPTS2.find(([re]) => {
|
|
10095
10875
|
re.lastIndex = 0;
|
|
10096
10876
|
return re.test(w);
|
|
10097
10877
|
})?.[1] ?? null;
|
|
@@ -10118,7 +10898,7 @@ var languageName = (lang) => {
|
|
|
10118
10898
|
}
|
|
10119
10899
|
};
|
|
10120
10900
|
function fitsLanguage(line, lang) {
|
|
10121
|
-
const own =
|
|
10901
|
+
const own = SCRIPTS2.find(([, l]) => l === lang)?.[0];
|
|
10122
10902
|
if (own) return (line.match(own)?.length ?? 0) > 0 && !new RegExp("\\p{Script=Latin}{2,}", "u").test(line);
|
|
10123
10903
|
if (/[^\p{Script=Latin}\p{M}\p{P}\p{Z}\p{N}\p{S}]/u.test(line)) return false;
|
|
10124
10904
|
const mine = STOP3[lang];
|
|
@@ -10390,7 +11170,7 @@ var TurnGate = class {
|
|
|
10390
11170
|
}
|
|
10391
11171
|
/** An STT final. */
|
|
10392
11172
|
final(text, sttId) {
|
|
10393
|
-
let t = text.trim();
|
|
11173
|
+
let t = text.trim(), replaces;
|
|
10394
11174
|
if (!t) return this.o.onDrop(text, "empty");
|
|
10395
11175
|
if (this.held) {
|
|
10396
11176
|
const h = this.held;
|
|
@@ -10398,6 +11178,7 @@ var TurnGate = class {
|
|
|
10398
11178
|
this.held = void 0;
|
|
10399
11179
|
if (!(norm3(t) + " ").startsWith(norm3(h.text) + " ")) t = `${h.text} ${t}`;
|
|
10400
11180
|
sttId ??= h.sttId;
|
|
11181
|
+
replaces = h.replaces;
|
|
10401
11182
|
}
|
|
10402
11183
|
const key = norm3(t), now3 = this.o.now(), last = this.last;
|
|
10403
11184
|
if (last) {
|
|
@@ -10411,10 +11192,18 @@ var TurnGate = class {
|
|
|
10411
11192
|
const mid = endsMidPhrase(t);
|
|
10412
11193
|
if (mid || this.o.settleMs && !/\?["')\]]*$/.test(t)) {
|
|
10413
11194
|
const ms = mid ? this.o.holdMs : this.o.settleMs;
|
|
10414
|
-
this.held = { text: t, sttId, ms, timer: setTimeout(() => this.flush(), ms) };
|
|
11195
|
+
this.held = { text: t, sttId, ms, replaces, timer: setTimeout(() => this.flush(), ms) };
|
|
10415
11196
|
return this.o.onHold(t);
|
|
10416
11197
|
}
|
|
10417
|
-
this.send(t, key, sttId, "new");
|
|
11198
|
+
this.send(t, key, sttId, "new", replaces);
|
|
11199
|
+
}
|
|
11200
|
+
/** The user kept talking after turn `id` went out and before its reply made a sound: it was not over. Its words go back
|
|
11201
|
+
* to being held — the rest merges in and one whole turn replaces it; silence sends them again as they were. */
|
|
11202
|
+
reopen(id) {
|
|
11203
|
+
const l = this.last;
|
|
11204
|
+
if (l?.id !== id || this.held) return;
|
|
11205
|
+
this.last = void 0;
|
|
11206
|
+
this.held = { text: l.text, sttId: l.sttId, ms: this.o.holdMs, replaces: id, timer: setTimeout(() => this.flush(), this.o.holdMs) };
|
|
10418
11207
|
}
|
|
10419
11208
|
/** The user is speaking again (a partial): a held fragment waits for the rest. */
|
|
10420
11209
|
speaking() {
|
|
@@ -10433,7 +11222,7 @@ var TurnGate = class {
|
|
|
10433
11222
|
clearTimeout(h.timer);
|
|
10434
11223
|
this.held = void 0;
|
|
10435
11224
|
if (this.closed && isClosing(h.text)) return this.o.onDrop(h.text, "goodbye");
|
|
10436
|
-
this.send(h.text, norm3(h.text), h.sttId, "new");
|
|
11225
|
+
this.send(h.text, norm3(h.text), h.sttId, "new", h.replaces);
|
|
10437
11226
|
}
|
|
10438
11227
|
end() {
|
|
10439
11228
|
if (this.held) {
|
|
@@ -12938,9 +13727,6 @@ init_logging();
|
|
|
12938
13727
|
init_logging();
|
|
12939
13728
|
init_models();
|
|
12940
13729
|
|
|
12941
|
-
// src/voice/progress.ts
|
|
12942
|
-
init_logging();
|
|
12943
|
-
|
|
12944
13730
|
// src/voice/convoTree.ts
|
|
12945
13731
|
init_logging();
|
|
12946
13732
|
|
|
@@ -13070,10 +13856,13 @@ var ConvoTree = class {
|
|
|
13070
13856
|
};
|
|
13071
13857
|
|
|
13072
13858
|
// src/voice/progress.ts
|
|
13859
|
+
init_logging();
|
|
13073
13860
|
var log29 = forComponent("Progress");
|
|
13074
13861
|
var HE_RESULT_CLAIM = /(?:^|\s)(?:מצאתי|סיימתי|בוצע|הנה|אין)(?=\s|$|[.,!…])/u;
|
|
13862
|
+
var PLUMBING = /toolsearch|^mcp__.*__(list_commands|call_info)$/;
|
|
13863
|
+
var isPlumbing = (tool) => PLUMBING.test(tool.toLowerCase());
|
|
13075
13864
|
var TOPICS = [
|
|
13076
|
-
[
|
|
13865
|
+
[PLUMBING, null],
|
|
13077
13866
|
// tool plumbing — no line (and no generated one)
|
|
13078
13867
|
[/kanban|board|card|\bkb\b|list_cards/, "board"],
|
|
13079
13868
|
[/mail|gmail|inbox/, "mail"],
|
|
@@ -13173,6 +13962,7 @@ var Progress = class {
|
|
|
13173
13962
|
said = /* @__PURE__ */ new Set();
|
|
13174
13963
|
lastAt = -Infinity;
|
|
13175
13964
|
streamed = false;
|
|
13965
|
+
lines = [];
|
|
13176
13966
|
get o() {
|
|
13177
13967
|
return this.options;
|
|
13178
13968
|
}
|
|
@@ -13180,20 +13970,33 @@ var Progress = class {
|
|
|
13180
13970
|
turn() {
|
|
13181
13971
|
this.streamed = false;
|
|
13182
13972
|
}
|
|
13183
|
-
/** MAIN's text streamed this turn: no more progress lines
|
|
13973
|
+
/** MAIN's text streamed this turn: no more progress lines, until a tool runs again. */
|
|
13184
13974
|
text() {
|
|
13185
13975
|
this.streamed = true;
|
|
13186
13976
|
}
|
|
13187
|
-
/**
|
|
13188
|
-
|
|
13977
|
+
/** A tool started: MAIN is working again. */
|
|
13978
|
+
tool() {
|
|
13979
|
+
this.streamed = false;
|
|
13980
|
+
}
|
|
13981
|
+
/** May a line play now, or `leadMs` from now? (the caller passes when the user last heard anything) */
|
|
13982
|
+
due(lastAudibleAt, leadMs = 0) {
|
|
13189
13983
|
const now3 = this.o.now();
|
|
13190
|
-
return !this.streamed && now3 - lastAudibleAt >= this.o.silenceMs && now3 - this.lastAt >= this.o.gapMs;
|
|
13984
|
+
return !this.streamed && now3 - lastAudibleAt >= this.o.silenceMs - leadMs && now3 - this.lastAt >= this.o.gapMs - leadMs;
|
|
13191
13985
|
}
|
|
13192
13986
|
/** Mark `line` spoken. */
|
|
13193
13987
|
spoke(line) {
|
|
13194
|
-
this.
|
|
13988
|
+
this.note(line);
|
|
13195
13989
|
this.lastAt = this.o.now();
|
|
13196
13990
|
}
|
|
13991
|
+
/** A line the user heard from elsewhere (an aside): progress never repeats it. */
|
|
13992
|
+
note(line) {
|
|
13993
|
+
this.said.add(norm3(line));
|
|
13994
|
+
this.lines = [...this.lines, line].slice(-6);
|
|
13995
|
+
}
|
|
13996
|
+
/** The last lines heard, for a writer to avoid. */
|
|
13997
|
+
get recent() {
|
|
13998
|
+
return [...this.lines];
|
|
13999
|
+
}
|
|
13197
14000
|
/** `about`: the user's request, for a generated line. The line for this tool call in `lang`, or '' (no template and no/late/invalid generation, a repeat, a result claim). */
|
|
13198
14001
|
async line(tool, args, lang, about = "") {
|
|
13199
14002
|
if (this.streamed) return "";
|
|
@@ -13214,7 +14017,7 @@ var Progress = class {
|
|
|
13214
14017
|
r(null);
|
|
13215
14018
|
}, this.o.generateBudgetMs);
|
|
13216
14019
|
});
|
|
13217
|
-
const raw = await Promise.race([this.o.generate(tool, [about.slice(-80), argsHint(args)].filter(Boolean).join("; "), lang, ac.signal).catch((e) => {
|
|
14020
|
+
const raw = await Promise.race([this.o.generate(tool, [about.slice(-80), argsHint(args)].filter(Boolean).join("; "), lang, ac.signal, this.lines).catch((e) => {
|
|
13218
14021
|
log29.warn(`progress line failed: ${e?.message ?? e}`);
|
|
13219
14022
|
return null;
|
|
13220
14023
|
}), late]).finally(() => clearTimeout(t));
|
|
@@ -13224,13 +14027,17 @@ var Progress = class {
|
|
|
13224
14027
|
}
|
|
13225
14028
|
};
|
|
13226
14029
|
function fastProgressGenerator(ai, model, gender) {
|
|
13227
|
-
return async (tool, hint, lang, signal) => {
|
|
13228
|
-
const prompt = `An assistant on a live voice call is running the tool "${tool}"${hint ? ` (about: "${hint}")` : ""}. Write ONE spoken line of 2-5 words, in ${languageName(lang)}, saying what it is doing right now (like "checking the board\u2026"). ${hint ? "Use the words of what it is about. " : ""}Never state a result or a finding. ${personaHint(gender)} Output only the line.`;
|
|
14030
|
+
return async (tool, hint, lang, signal, avoid = []) => {
|
|
14031
|
+
const prompt = `An assistant on a live voice call is running the tool "${tool}"${hint ? ` (about: "${hint}")` : ""}. Write ONE spoken line of 2-5 words, in ${languageName(lang)}, saying what it is doing right now (like "checking the board\u2026"). ${hint ? "Use the words of what it is about. " : ""}${avoid.length ? `It already said ${avoid.map((a) => `"${a}"`).join(", ")}: say something new, a different angle on the same work. ` : ""}Never state a result or a finding. ${personaHint(gender)} Output only the line.`;
|
|
13229
14032
|
const reasoning = /gpt-oss/.test(model) ? { providerOptions: { reasoning_effort: "low" } } : {};
|
|
13230
14033
|
const r = await ai.chat({ model, messages: [{ role: "user", content: prompt }], stream: false, signal, maxTokens: 150, ...reasoning });
|
|
13231
14034
|
return r.content ?? "";
|
|
13232
14035
|
};
|
|
13233
14036
|
}
|
|
14037
|
+
function cleanWorkReply(raw, lang) {
|
|
14038
|
+
const l = cleanLine(raw.replace(/^\s*(?:stop|work)\s*:/i, ""), lang, 8);
|
|
14039
|
+
return RESULT_CLAIM_RE.test(l) || HE_RESULT_CLAIM.test(l) ? "" : l;
|
|
14040
|
+
}
|
|
13234
14041
|
|
|
13235
14042
|
// src/voice/secondChannel.ts
|
|
13236
14043
|
init_logging();
|
|
@@ -13734,6 +14541,7 @@ var SecondChannel = class {
|
|
|
13734
14541
|
bridgeBlock() {
|
|
13735
14542
|
const w = words2(this.heard), intent = turnIntent(this.heard);
|
|
13736
14543
|
if (!this.lang) return "language unknown";
|
|
14544
|
+
if (this.ownWords) return this.blocked("bridge");
|
|
13737
14545
|
if (intent === "closer") return "no answer due";
|
|
13738
14546
|
if (this.late) return this.blocked("bridge");
|
|
13739
14547
|
const why = intent === "ask" ? w.length <= 6 && isPhatic(this.heard, this.bank) ? "phatic" : "" : this.shortTurn(w.length);
|
|
@@ -13758,7 +14566,7 @@ var SecondChannel = class {
|
|
|
13758
14566
|
if (!this.lang) return "silence";
|
|
13759
14567
|
if (trigger === "working") return this.bridgeBlock() ? "silence" : "bridge";
|
|
13760
14568
|
if (w.length <= this.o.shortTurnWords || w.length <= 6 && isPhatic(this.heard, this.bank)) return "silence";
|
|
13761
|
-
const k = trigger === "interim" ? this.backchannelMoment(w.length, breath) && (!this.o.anticipate || !this.plan || !silentTurn(this.plan) && (!!cue || !this.o.cueOnly && this.plan.density !== "low")) ? "backchannel" : null : trigger === "pause" ? pauseMs >= this.o.fillerPauseMs && w.length >= this.o.fillerMinWords ? "filler" : null : null;
|
|
14569
|
+
const k = trigger === "interim" ? this.backchannelMoment(w.length, breath) && (!this.o.anticipate || !this.plan || !silentTurn(this.plan) && (!!cue || !this.o.cueOnly && this.plan.density !== "low")) ? "backchannel" : null : trigger === "pause" ? pauseMs >= this.o.fillerPauseMs && w.length >= this.o.fillerMinWords && !(this.ownWords && /[.!?…]$/.test(this.heard)) ? "filler" : null : null;
|
|
13762
14570
|
return k && this.allowed(k) ? k : "silence";
|
|
13763
14571
|
}
|
|
13764
14572
|
/** Plan (or, with `heard`, revise) the backchannels of the user's turn — async, never on the hot path. */
|
|
@@ -13821,7 +14629,7 @@ var SecondChannel = class {
|
|
|
13821
14629
|
this.breathTimer = setTimeout(() => {
|
|
13822
14630
|
this.breathTimer = null;
|
|
13823
14631
|
const n = words2(t).length, tree = this.tree;
|
|
13824
|
-
if (n
|
|
14632
|
+
if (!this.backchannelMoment(n, true) || this.heard !== t || this.leafTimer || this.picking || tree.empty || this.leafGated()) return;
|
|
13825
14633
|
this.picking = true;
|
|
13826
14634
|
const ac = new AbortController(), nodes = tree.nodes.filter((x) => x.moment !== "ask"), lines = nodes.map((x, i) => ({ i, line: x.line, when: x.when }));
|
|
13827
14635
|
void withBudget(this.o.pickLeaf(t, lines, ac.signal), this.o.pickBudgetMs, "breath pick", ac).then((i) => {
|
|
@@ -13883,6 +14691,7 @@ var SecondChannel = class {
|
|
|
13883
14691
|
* sentence end only deep into a story — a short request's end is the end of their turn (replay: "mm-hm" right after
|
|
13884
14692
|
* "Check hacker news for recent news.", just before the final). */
|
|
13885
14693
|
backchannelMoment(n, breath) {
|
|
14694
|
+
if (!cueWords(this.heard).some(isContent)) return false;
|
|
13886
14695
|
if (/\?$/.test(this.heard) || pendingQuestion(this.heard)) return false;
|
|
13887
14696
|
if (this.carried) n += this.carried;
|
|
13888
14697
|
else if (n < this.o.requestHoldWords && requestOpener(this.heard)) return false;
|
|
@@ -13954,7 +14763,7 @@ var SecondChannel = class {
|
|
|
13954
14763
|
this.bridgeDraft = null;
|
|
13955
14764
|
this.askLeaf = null;
|
|
13956
14765
|
this.bridgeReady = Promise.resolve();
|
|
13957
|
-
if (!this.o.generate || !(this.ownWords || this.o.generateFor.includes("bridge")) || !this.lang || !this.heard
|
|
14766
|
+
if (!this.o.generate || !(this.ownWords || this.o.generateFor.includes("bridge")) || !this.lang || !this.heard) return;
|
|
13958
14767
|
const gen = this.gen, ac = new AbortController(), own = this.ownWords, heard = this.heard;
|
|
13959
14768
|
const ctx = { kind: "bridge", heard: this.tail(), state: this.main, avoid: [...this.recent], lang: this.lang, ...own ? { ask: true } : {} };
|
|
13960
14769
|
this.bridgeReady = withBudget(this.o.generate(ctx, ac.signal), own ? this.o.bridgeBudgetMs : Math.max(this.o.generateBudgetMs, this.o.bridgeDelayMs), "bridge generate", ac).then((raw) => {
|
|
@@ -14087,6 +14896,10 @@ function closedQuestion(reply) {
|
|
|
14087
14896
|
|
|
14088
14897
|
// src/voice/call.ts
|
|
14089
14898
|
var log31 = forComponent("VoiceCall");
|
|
14899
|
+
function newWords(text, turn) {
|
|
14900
|
+
const said = new Set(norm3(turn).split(" "));
|
|
14901
|
+
return norm3(text).split(" ").filter((w) => w && !said.has(w)).length;
|
|
14902
|
+
}
|
|
14090
14903
|
var VoiceCallOptions = class {
|
|
14091
14904
|
/** Host runs MAIN with exactly `text` (a replace: roll the `replaces` turn back first). */
|
|
14092
14905
|
sendTurn = () => {
|
|
@@ -14094,6 +14907,14 @@ var VoiceCallOptions = class {
|
|
|
14094
14907
|
/** Host aborts a running MAIN turn (barge-in). */
|
|
14095
14908
|
abortTurn = () => {
|
|
14096
14909
|
};
|
|
14910
|
+
/** Host keeps `note` for MAIN's next turn. With it (and `workReply`), what the user says while MAIN works is answered at
|
|
14911
|
+
* once by the fast model and MAIN is not aborted or restarted: a remark reaches MAIN as this note, a change or addition
|
|
14912
|
+
* runs as MAIN's next turn. Not injected mid-run: that makes MAIN run again just to hear a remark. Absent: such a line
|
|
14913
|
+
* barges in as before. */
|
|
14914
|
+
noteTurn;
|
|
14915
|
+
/** Writes that immediate answer (fastWorkReply). */
|
|
14916
|
+
workReply;
|
|
14917
|
+
workReplyBudgetMs = 1500;
|
|
14097
14918
|
/** Host TTS (fill lane): resolves when played; `false` = could not play. */
|
|
14098
14919
|
speak = () => false;
|
|
14099
14920
|
/** Stop the in-flight fill line now (barge-in only). */
|
|
@@ -14126,6 +14947,13 @@ var VoiceCallOptions = class {
|
|
|
14126
14947
|
now = () => performance.now();
|
|
14127
14948
|
/** An aside (aside()) needs this long since the last one — a cue answered every time sounds scripted. */
|
|
14128
14949
|
asideGapMs = 8e3;
|
|
14950
|
+
/** After a turn went out, new words this soon are the same turn going on (it gives way to the fuller one), if MAIN has
|
|
14951
|
+
* not started. Later ones are a new thing said over the work. */
|
|
14952
|
+
resumeMs = 3e3;
|
|
14953
|
+
/** Progress waits while the user spoke this recently. */
|
|
14954
|
+
userQuietMs = 800;
|
|
14955
|
+
/** A progress line starts being written this long before it is due. */
|
|
14956
|
+
progressLeadMs = 1e3;
|
|
14129
14957
|
};
|
|
14130
14958
|
var VoiceCall = class {
|
|
14131
14959
|
constructor(options) {
|
|
@@ -14161,7 +14989,7 @@ var VoiceCall = class {
|
|
|
14161
14989
|
cancel: () => o.cancel(),
|
|
14162
14990
|
now: o.now
|
|
14163
14991
|
});
|
|
14164
|
-
this.progress = new Progress({ ...o.mode === "live" ? { templates: {}, generateBudgetMs: 1500 } : {}, ...ai ? { generate: fastProgressGenerator(ai, o.fastModel, o.gender) } : {}, gender: o.gender, now: o.now, ...o.progress });
|
|
14992
|
+
this.progress = new Progress({ ...o.mode === "live" ? { templates: {}, generateBudgetMs: 1500, gapMs: 5e3 } : {}, ...ai ? { generate: fastProgressGenerator(ai, o.fastModel, o.gender) } : {}, gender: o.gender, now: o.now, ...o.progress });
|
|
14165
14993
|
this.judge = new OverlapJudge({ ...ai ? { model: overlapModelFor(ai) } : {}, now: o.now });
|
|
14166
14994
|
this.gate = new TurnGate({
|
|
14167
14995
|
now: o.now,
|
|
@@ -14188,6 +15016,7 @@ var VoiceCall = class {
|
|
|
14188
15016
|
earlyHeard = null;
|
|
14189
15017
|
// a fill line heard while that turn was still held
|
|
14190
15018
|
progressTimer = null;
|
|
15019
|
+
lastUserAt = -Infinity;
|
|
14191
15020
|
ended = false;
|
|
14192
15021
|
get o() {
|
|
14193
15022
|
return this.options;
|
|
@@ -14200,6 +15029,11 @@ var VoiceCall = class {
|
|
|
14200
15029
|
get turn() {
|
|
14201
15030
|
return this.cur && { id: this.cur.id, text: this.cur.text, running: this.cur.running };
|
|
14202
15031
|
}
|
|
15032
|
+
/** MAIN is on this turn and has the floor to itself: nothing the user says now stops it, unless they ask it to. */
|
|
15033
|
+
get working() {
|
|
15034
|
+
const c = this.cur;
|
|
15035
|
+
return !!c && c.running && !c.closed && (!c.worded || c.open > 0);
|
|
15036
|
+
}
|
|
14203
15037
|
/** The host STT's language (BCP-47): the current language until the user's words say otherwise. */
|
|
14204
15038
|
setLanguage(tag) {
|
|
14205
15039
|
const l = primaryLang(tag);
|
|
@@ -14212,12 +15046,16 @@ var VoiceCall = class {
|
|
|
14212
15046
|
if (this.ended || !text.trim()) return;
|
|
14213
15047
|
if (typeof aec === "boolean") this.fill.options.aec = aec;
|
|
14214
15048
|
this.gate.speaking();
|
|
14215
|
-
|
|
14216
|
-
|
|
15049
|
+
this.lastUserAt = this.o.now();
|
|
15050
|
+
const c = this.cur, steers = !!this.o.noteTurn && this.working;
|
|
15051
|
+
const resumed = !steers || c.marks.mainFirst === void 0 && this.o.now() - c.at < this.o.resumeMs;
|
|
15052
|
+
if (this.o.mode === "live" && c?.running && !c.worded && resumed && newWords(text, c.text) >= 2) {
|
|
14217
15053
|
log31.debug("user resumed before the reply \u2014 yielded");
|
|
14218
|
-
this.
|
|
15054
|
+
this.giveWay(c);
|
|
15055
|
+
this.gate.reopen(c.id);
|
|
14219
15056
|
}
|
|
14220
15057
|
this.follow(text);
|
|
15058
|
+
if (this.o.noteTurn && this.working) return;
|
|
14221
15059
|
this.fill.onInterim(text);
|
|
14222
15060
|
}
|
|
14223
15061
|
/** STT final → TurnGate. `lastWordAgoMs`: how long ago the user's last word of it ended (the STT's word clock,
|
|
@@ -14276,6 +15114,8 @@ var VoiceCall = class {
|
|
|
14276
15114
|
if (!c.streamed) {
|
|
14277
15115
|
c.streamed = true;
|
|
14278
15116
|
this.gate.replyStarted(c.id);
|
|
15117
|
+
}
|
|
15118
|
+
if (c.open <= 0) {
|
|
14279
15119
|
this.progress.text();
|
|
14280
15120
|
this.clearProgress();
|
|
14281
15121
|
}
|
|
@@ -14284,9 +15124,17 @@ var VoiceCall = class {
|
|
|
14284
15124
|
case "tool":
|
|
14285
15125
|
c.marks.mainFirst ??= this.o.now();
|
|
14286
15126
|
this.gate.replyStarted(c.id);
|
|
14287
|
-
|
|
15127
|
+
c.open++;
|
|
15128
|
+
c.streamed = false;
|
|
15129
|
+
if (ev.name && !isPlumbing(ev.name)) {
|
|
15130
|
+
c.tool = ev.name;
|
|
15131
|
+
c.args = ev.args;
|
|
15132
|
+
}
|
|
15133
|
+
this.progress.tool();
|
|
15134
|
+
this.beat(c);
|
|
14288
15135
|
return;
|
|
14289
15136
|
case "tool_done":
|
|
15137
|
+
c.open = Math.max(0, c.open - 1);
|
|
14290
15138
|
return;
|
|
14291
15139
|
case "audio": {
|
|
14292
15140
|
const at = this.o.now() + Math.max(0, inMs);
|
|
@@ -14308,11 +15156,28 @@ var VoiceCall = class {
|
|
|
14308
15156
|
this.clearProgress();
|
|
14309
15157
|
this.fill.onAgentState("idle");
|
|
14310
15158
|
if (c.worded) this.close(c, "answered");
|
|
15159
|
+
if (c.next) {
|
|
15160
|
+
const next = c.next;
|
|
15161
|
+
c.next = void 0;
|
|
15162
|
+
this.onTurn(next);
|
|
15163
|
+
}
|
|
14311
15164
|
return;
|
|
14312
15165
|
}
|
|
14313
15166
|
}
|
|
14314
15167
|
/** The user barged in (hard): cut fill + MAIN audio (the host cuts its own), abort a running MAIN turn. */
|
|
14315
15168
|
barge() {
|
|
15169
|
+
if (this.o.noteTurn && this.working) {
|
|
15170
|
+
this.fill.onBargeIn();
|
|
15171
|
+
try {
|
|
15172
|
+
this.o.cancel();
|
|
15173
|
+
} catch (e) {
|
|
15174
|
+
log31.warn(`cancel threw: ${e.message}`);
|
|
15175
|
+
}
|
|
15176
|
+
return;
|
|
15177
|
+
}
|
|
15178
|
+
this.giveWay();
|
|
15179
|
+
}
|
|
15180
|
+
giveWay(c = this.cur) {
|
|
14316
15181
|
this.fill.onBargeIn();
|
|
14317
15182
|
this.clearProgress();
|
|
14318
15183
|
try {
|
|
@@ -14320,11 +15185,11 @@ var VoiceCall = class {
|
|
|
14320
15185
|
} catch (e) {
|
|
14321
15186
|
log31.warn(`cancel threw: ${e.message}`);
|
|
14322
15187
|
}
|
|
14323
|
-
if (
|
|
14324
|
-
|
|
14325
|
-
this.o.abortTurn(
|
|
15188
|
+
if (c?.running) {
|
|
15189
|
+
c.running = false;
|
|
15190
|
+
this.o.abortTurn(c.id);
|
|
14326
15191
|
}
|
|
14327
|
-
if (
|
|
15192
|
+
if (c && !c.worded) c.end ??= "cut";
|
|
14328
15193
|
}
|
|
14329
15194
|
/** Soft barge-in: keep (a listener cue — no turn) or cut (→ barge()). */
|
|
14330
15195
|
async overlap(text) {
|
|
@@ -14370,6 +15235,7 @@ var VoiceCall = class {
|
|
|
14370
15235
|
if (l) this.fill.setLanguage(l, true);
|
|
14371
15236
|
}
|
|
14372
15237
|
onTurn(t) {
|
|
15238
|
+
if (this.o.noteTurn && this.o.workReply && t.kind !== "replace" && this.working && !isClosing(t.text)) return void this.overWork(this.cur, t);
|
|
14373
15239
|
const now3 = this.o.now(), lastWord = this.lastWordAt !== null;
|
|
14374
15240
|
const at = this.lastWordAt ?? this.firstFinalAt ?? now3;
|
|
14375
15241
|
const finalAt = this.finalAt || now3;
|
|
@@ -14378,7 +15244,7 @@ var VoiceCall = class {
|
|
|
14378
15244
|
if (this.cur) this.close(this.cur, t.replaces === this.cur.id ? "replaced" : void 0);
|
|
14379
15245
|
this.follow(t.text);
|
|
14380
15246
|
this.clearProgress();
|
|
14381
|
-
this.cur = { id: t.id, text: t.text, at, finalAt, lastWord, running: true, streamed: false, sounded: false, worded: false, done: false, marks: { sent: now3 }, closed: false, due: turnIntent(t.text) !== "closer" };
|
|
15247
|
+
this.cur = { id: t.id, text: t.text, at, finalAt, lastWord, running: true, streamed: false, sounded: false, worded: false, done: false, marks: { sent: now3 }, closed: false, due: turnIntent(t.text) !== "closer", open: 0, tool: "", draft: "", drafting: false, draftAt: -Infinity };
|
|
14382
15248
|
const early = this.earlyHeard;
|
|
14383
15249
|
this.earlyHeard = null;
|
|
14384
15250
|
if (early && early.at >= at) {
|
|
@@ -14416,6 +15282,7 @@ var VoiceCall = class {
|
|
|
14416
15282
|
c.marks.fill = this.o.now();
|
|
14417
15283
|
c.fillKind = kind;
|
|
14418
15284
|
}
|
|
15285
|
+
if (c && kind === "bridge" && this.o.mode === "live" && echoesHeard(text, c.text)) this.beat(c);
|
|
14419
15286
|
if (this.o.hostAudio) return r;
|
|
14420
15287
|
this.lastAudibleAt = this.o.now();
|
|
14421
15288
|
if (c && forTurn) {
|
|
@@ -14453,27 +15320,78 @@ var VoiceCall = class {
|
|
|
14453
15320
|
for (const k of Object.keys(tl)) if (tl[k] === void 0) delete tl[k];
|
|
14454
15321
|
this.o.onMetric({ name: "timeline", id: c.id, text: c.text, timeline: tl });
|
|
14455
15322
|
}
|
|
14456
|
-
|
|
14457
|
-
|
|
14458
|
-
|
|
14459
|
-
|
|
14460
|
-
|
|
14461
|
-
|
|
15323
|
+
/** The user spoke while MAIN works: the fast model answers now, the words reach MAIN as a note, MAIN keeps going. */
|
|
15324
|
+
async overWork(c, t) {
|
|
15325
|
+
const at = this.o.now();
|
|
15326
|
+
this.firstFinalAt = null;
|
|
15327
|
+
this.lastWordAt = null;
|
|
15328
|
+
this.follow(t.text);
|
|
15329
|
+
queueMicrotask(() => this.gate.replyStarted(t.id));
|
|
15330
|
+
this.o.onMetric({ name: "turn", id: t.id, kind: "aside", text: t.text });
|
|
15331
|
+
const ac = new AbortController(), late = setTimeout(() => ac.abort(), this.o.workReplyBudgetMs), lang = this.lang;
|
|
15332
|
+
const raw = lang ? await this.o.workReply({ request: c.text, heard: t.text, tool: c.tool, hint: argsHint(c.args), lang, avoid: this.progress.recent }, ac.signal).catch((e) => {
|
|
15333
|
+
log31.warn(`work reply failed \u2014 MAIN only: ${e?.message ?? e}`);
|
|
15334
|
+
return "";
|
|
15335
|
+
}).finally(() => clearTimeout(late)) : "";
|
|
15336
|
+
const line = cleanWorkReply(raw, lang ?? ""), stop = /^\s*stop\s*:/i.test(raw), change = !line || /^\s*work\s*:/i.test(raw);
|
|
15337
|
+
const noted = `[The user said this on the call while you worked: "${t.text}".${line ? ` You answered aloud: "${line}".` : ""}${stop ? " That stopped the work." : ""} Take it into account; do not answer it again.]`;
|
|
15338
|
+
if (line && !this.ended) {
|
|
15339
|
+
for (let i = 0; i < 8 && this.say(line, "aside") === false; i++) {
|
|
15340
|
+
if (i === 7) {
|
|
15341
|
+
this.o.onMetric({ name: "drop", id: t.id, kind: "aside unplayed", text: line });
|
|
15342
|
+
break;
|
|
15343
|
+
}
|
|
15344
|
+
await new Promise((r) => setTimeout(r, 250));
|
|
15345
|
+
}
|
|
15346
|
+
if (this.lastAudibleAt >= at) {
|
|
15347
|
+
this.progress.note(line);
|
|
15348
|
+
this.o.show(line, "aside");
|
|
15349
|
+
}
|
|
15350
|
+
} else if (!line) this.o.onMetric({ name: "drop", id: t.id, kind: "no aside line" });
|
|
15351
|
+
if (stop) {
|
|
15352
|
+
this.o.noteTurn(noted);
|
|
15353
|
+
c.next = void 0;
|
|
15354
|
+
if (this.working && this.cur === c) this.giveWay(c);
|
|
15355
|
+
return;
|
|
15356
|
+
}
|
|
15357
|
+
if (change && this.cur === c && c.running) {
|
|
15358
|
+
c.next = c.next ? { ...c.next, text: `${c.next.text} ${t.text}` } : { ...t, kind: "new" };
|
|
15359
|
+
return;
|
|
15360
|
+
}
|
|
15361
|
+
if (change) return this.onTurn({ ...t, kind: "new" });
|
|
15362
|
+
this.o.noteTurn(noted);
|
|
15363
|
+
}
|
|
15364
|
+
/** While MAIN's tools run: a progress line once nothing was heard for `silenceMs`, then every `gapMs`, written just ahead
|
|
15365
|
+
* so it plays on time. Ticks are local (no network) and stop with the turn. */
|
|
15366
|
+
beat(c) {
|
|
14462
15367
|
this.clearProgress();
|
|
14463
|
-
const
|
|
15368
|
+
const tick = () => {
|
|
14464
15369
|
this.progressTimer = null;
|
|
14465
|
-
if (this.ended || this.cur !== c || c.
|
|
14466
|
-
|
|
14467
|
-
|
|
14468
|
-
|
|
15370
|
+
if (this.ended || this.cur !== c || !c.running || c.streamed && c.open <= 0) return;
|
|
15371
|
+
const lang = this.lang, now3 = this.o.now();
|
|
15372
|
+
if (lang && !c.draft && !c.drafting && now3 - c.draftAt >= 1e3 && this.progress.due(this.lastAudibleAt, this.o.progressLeadMs)) {
|
|
15373
|
+
c.drafting = true;
|
|
15374
|
+
void this.progress.line(c.tool, c.args, lang, this.o.mode === "live" ? c.text : "").then((l) => {
|
|
15375
|
+
c.drafting = false;
|
|
15376
|
+
c.draft = l;
|
|
15377
|
+
if (!l) c.draftAt = this.o.now();
|
|
15378
|
+
if (!l && this.o.mode === "live") this.o.onMetric({ name: "drop", id: c.id, kind: `no progress line: ${c.tool}` });
|
|
15379
|
+
else sayDraft();
|
|
15380
|
+
});
|
|
14469
15381
|
}
|
|
14470
|
-
|
|
14471
|
-
|
|
15382
|
+
sayDraft();
|
|
15383
|
+
this.progressTimer = setTimeout(tick, 250);
|
|
15384
|
+
};
|
|
15385
|
+
const sayDraft = () => {
|
|
15386
|
+
if (!c.draft || this.ended || this.cur !== c || !c.running || c.streamed && c.open <= 0 || this.o.now() - this.lastUserAt < this.o.userQuietMs || !this.progress.due(this.lastAudibleAt)) return;
|
|
15387
|
+
if (this.say(c.draft, "progress") !== false) {
|
|
15388
|
+
this.progress.spoke(c.draft);
|
|
14472
15389
|
this.fill.covered();
|
|
14473
|
-
this.o.show(
|
|
15390
|
+
this.o.show(c.draft, "progress");
|
|
15391
|
+
c.draft = "";
|
|
14474
15392
|
}
|
|
14475
15393
|
};
|
|
14476
|
-
|
|
15394
|
+
tick();
|
|
14477
15395
|
}
|
|
14478
15396
|
clearProgress() {
|
|
14479
15397
|
if (this.progressTimer) {
|