@livx.cc/agentx 0.99.70 → 0.99.72

package/dist/index.d.ts

@@ -1207,10 +1207,15 @@ declare class DuplexAgent {
      *  `opts.id` names the turn; `opts.replaces` names an earlier one this content REPLACES — the voice engine's
      *  fuller re-finalization of an utterance whose reply had not started ("…previous" → "…previous
      *  conversation."). The replaced turn is skipped if it has not run yet, else aborted and rolled back out of
-     *  the transcript (kept only if it already dispatched work) — one reply, to the full text. */
+     *  the transcript (kept only if it already dispatched work) — one reply, to the full text. `opts.followUp` = the new words
+     *  beyond the replaced turn (a string), or beyond each earlier turn of a re-final chain ({turnId: words}): when the nearest
+     *  turn still in the transcript is KEPT, its words run instead of the merged text (which would repeat its request — a
+     *  second Act). The host gets `turn_replace` {id, replaces, rolledBack, followed?}: only a rollback drops the replaced
+     *  line; `followed` = the kept turn whose follow-up ran (absent: the merged text ran). */
     send(content: MessageContent, opts?: {
         id?: string;
         replaces?: string;
+        followUp?: string | Record<string, string>;
     }): Promise<RunResult>;
     /** Host-named user turns (send opts.id), so a later send can replace one. Bounded; a replace that arrives
      *  BEFORE its target (the host's dispatch hops can reorder) leaves a pre-superseded record behind. */

package/dist/index.js

@@ -8970,15 +8970,16 @@ var STRICT = [
 ];
 var SENTENCE_END = new RegExp(`[.!?\u2026]+["')\\]]*(?:\\s|(?=\\p{Lu}|\\[))`, "gu");
 var SENTENCE_SPLIT = new RegExp(`(?<=[.!?\u2026]+["')\\]]*)(?:\\s+|(?=\\p{Lu}|\\[))`, "u");
+var BRACKET_NOTE = /^\s*\[\s*(?:[^\]\s]+\s+){3,}[^\]]*(?:\]\s*)?$/;
 var clean2 = (s) => s.replace(/\[[a-z_ ]+\]\s*/gi, "").trim();
 function isLeakSuspect(sentence) {
   const s = clean2(sentence);
-  return SUSPECT.some((re) => re.test(s));
+  return BRACKET_NOTE.test(sentence) || SUSPECT.some((re) => re.test(s));
 }
 function isStrictLeak(sentence) {
   return sentence.split(SENTENCE_SPLIT).some((x) => {
     const s = clean2(x);
-    return STRICT.some((re) => re.test(s));
+    return BRACKET_NOTE.test(x) || STRICT.some((re) => re.test(s));
   });
 }
 var JUDGE_INSTRUCTIONS = `This sentence was produced by a voice assistant's reply stream and is about to be read aloud to the user. Is it the assistant's private scratchpad reasoning that leaked out \u2014 talking ABOUT the conversation instead of TO the listener? Leaked reasoning: refers to the listener in the third person ("the user wants\u2026", "user said\u2026"), plans its own reply ("we need to respond\u2026", "we should output\u2026", "I should answer briefly"), cites its own guidelines/instructions, or narrates its internal tool calls and task events (QuickLook, Act, Think, Hold, TaskStatus, "t2 completed") as steps it is taking. Speech: anything said TO the listener \u2014 answers, questions, offers, news, advice, explaining what it can do when asked, even if it mentions a user, an assistant, a policy, instructions, replying, or a tool.`;
@@ -9581,12 +9582,17 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
    *  `opts.id` names the turn; `opts.replaces` names an earlier one this content REPLACES — the voice engine's
    *  fuller re-finalization of an utterance whose reply had not started ("…previous" → "…previous
    *  conversation."). The replaced turn is skipped if it has not run yet, else aborted and rolled back out of
-   *  the transcript (kept only if it already dispatched work) — one reply, to the full text. */
+   *  the transcript (kept only if it already dispatched work) — one reply, to the full text. `opts.followUp` = the new words
+   *  beyond the replaced turn (a string), or beyond each earlier turn of a re-final chain ({turnId: words}): when the nearest
+   *  turn still in the transcript is KEPT, its words run instead of the merged text (which would repeat its request — a
+   *  second Act). The host gets `turn_replace` {id, replaces, rolledBack, followed?}: only a rollback drops the replaced
+   *  line; `followed` = the kept turn whose follow-up ran (absent: the merged text ran). */
   send(content, opts) {
     if (opts?.replaces) this.replaceTurn(opts.replaces);
     const cur = this.voice.options.signal;
     const ext = cur && cur === this.turnSignal?.own ? this.turnSignal.ext : cur;
     const rec = opts?.id ? this.trackTurn(opts.id) : void 0;
+    if (rec && opts?.replaces && typeof content === "string") rec.replaces = { id: opts.id, of: opts.replaces, content, followUp: typeof opts.followUp === "string" ? { [opts.replaces]: opts.followUp } : opts.followUp ?? {} };
     if (rec?.superseded) {
       this.notify("diag", "turn_replaced", { id: opts.id, ran: false });
       return Promise.resolve(_DuplexAgent.replacedResult(this.voice.transcript));
@@ -9644,6 +9650,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
     if (rec.done) {
       const drop = rec.dropped;
       rec.dropped = void 0;
+      rec.kept = !drop?.length;
       if (drop?.length) void this.enqueue(async () => {
         const t = this.voice.transcript;
         for (const m of drop) {
@@ -9665,12 +9672,13 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
    *  carries the user's full words) — unless it already dispatched work or SPOKE: the task is real, and the user
    *  heard those words, so both stay visible to the replacing turn. An aborted stream never reaches the transcript,
    *  so what was spoken is recorded as the replaced turn's reply. */
-  dropReplacedTurn() {
+  dropReplacedTurn(rec) {
     this.fabricationCut = true;
     this.reflexBuf = this.reflexBuf.slice(0, this.reflexForwarded);
     this.dropJudge();
     const spoke = this.turnSpoken.trim();
     const rolledBack = !this.turnDispatched && !spoke;
+    rec.kept = !rolledBack;
     if (rolledBack) this.voice.transcript.length = this.turnBase;
     else if (spoke) {
       const t = this.voice.transcript;
@@ -9714,6 +9722,22 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
         this.parkedRedeliver = [];
         for (const t of this.tasks.values()) if (t.deliveryParked === "barge") t.deliveryParked = "moved_on";
       }
+      if (rec?.replaces) {
+        const { id, of, content: said, followUp } = rec.replaces;
+        let base;
+        for (let t = of, n = 0; t && n < 32; n++) {
+          const r = this.userTurns.get(t);
+          if (r?.kept) {
+            base = t;
+            break;
+          }
+          t = r?.replaces?.of;
+        }
+        const fu = base !== void 0 ? followUp[base] : void 0;
+        if (fu !== void 0 && typeof content === "string" && content.startsWith(said)) content = fu + content.slice(said.length);
+        else base = void 0;
+        this.notify("turn_replace", of, { id, replaces: of, rolledBack: !this.userTurns.get(of)?.kept, ...base !== void 0 ? { followed: base } : {} });
+      }
       if (rec?.superseded) {
         this.notify("diag", "turn_replaced", { ran: false });
         return _DuplexAgent.replacedResult(this.voice.transcript);
@@ -9733,7 +9757,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
         }
         if (rec) rec.done = true;
       }
-      if (rec?.superseded) return this.dropReplacedTurn();
+      if (rec?.superseded) return this.dropReplacedTurn(rec);
       if (rec && res.finishReason === "aborted" && !this.turnDispatched && !this.turnSpoken.trim()) rec.dropped = this.voice.transcript.slice(this.turnBase);
       await this.endTurn(res);
       return res;
@@ -9803,7 +9827,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
       }
       this.spec = void 0;
       if (spec.rec) spec.rec.done = true;
-      if (spec.rec?.superseded) return this.dropReplacedTurn();
+      if (spec.rec?.superseded) return this.dropReplacedTurn(spec.rec);
       await this.endTurn(res);
       return res ?? empty;
     });