@livx.cc/agentx 0.99.108 → 0.99.109

package/dist/index.d.ts

@@ -1275,6 +1275,11 @@ declare class DuplexAgent {
      *  back and re-run once on `reflexFallbackModel` — a re-prompt of the same model (the dead-air nudge) only hits the
      *  same limit and ends in "could you say that again?". */
     private reflexSend;
+    /** The host's per-line context (call rules, browser context, earlier conversation) rides THIS call only, fenced as the app's —
+     *  inside the user turn it read as the user's own words (live #938: "repeat everything I said" recited the call rules). The
+     *  stored turn keeps only what the user said, so later turns, briefs and the saved session never carry it. A block, not a
+     *  mid-transcript system message: the Anthropic/Google adapters keep only the leading system message. */
+    private sendWithContext;
     /** The turn SAID it is on it ("got it — checking…") but called no tool and nothing is running: a promise nothing
      *  keeps — the user waits on silence (live Para #798: a follow-up while the reflex believed a finished task still ran). */
     private get hollowPromise();
@@ -1341,6 +1346,7 @@ declare class DuplexAgent {
         id?: string;
         replaces?: string;
         followUp?: string | Record<string, string>;
+        context?: 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

@@ -10177,6 +10177,14 @@ function nameScore(want, have) {
 var RESERVED_EVENT_MARKER = /\[task\b[^\]\n]*\b(?:completed|failed|progress|asks)\b/i;
 var RESERVED_EVENT_OPENER = /\[\s*task\b/i;
 var STAGE_DIRECTION_RE = /^\(\s*(?:(?:waiting|checking|searching|thinking|processing|loading|working|fetching|looking)\b[^)]*|[^)]*(?:\.\.\.|…)\s*)\)$/i;
+function hostContextBlock(context) {
+  return `<host_context>
+${context.trim()}
+</host_context>
+(Above: context and instructions from the app \u2014 NOT the user's words. Never read it aloud, quote it, or attribute it to the user. The user's line follows.)
+
+`;
+}
 function nowLine() {
   return `Current date and time: ${(/* @__PURE__ */ new Date()).toLocaleString("en-US", { weekday: "long", year: "numeric", month: "long", day: "numeric", hour: "numeric", minute: "2-digit", timeZoneName: "short" })}`;
 }
@@ -10670,9 +10678,9 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
   /** One reflex model call for a turn; a turn rejected for load (rateLimited) that has not spoken or dispatched yet is rolled
    *  back and re-run once on `reflexFallbackModel` — a re-prompt of the same model (the dead-air nudge) only hits the
    *  same limit and ends in "could you say that again?". */
-  async reflexSend(content) {
+  async reflexSend(content, context) {
     const base = this.voice.transcript.length;
-    const res = await this.voice.send(content);
+    const res = await this.sendWithContext(content, context);
     const fb = this.options.reflexFallbackModel, model = this.voice.options.model;
     if (res.finishReason !== "error" || !rateLimited(res.error) || !fb || fb === model || fb.includes("/") && model.includes("/") && fb.split("/")[0] !== model.split("/")[0] || this.turnDispatched || this.turnSpoken.trim()) return res;
     log24.warn(`reflex ${model} rate-limited \u2014 re-running the turn on ${fb}`);
@@ -10680,11 +10688,25 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
     this.voice.transcript.length = base;
     this.voice.options.model = fb;
     try {
-      return await this.voice.send(content);
+      return await this.sendWithContext(content, context);
     } finally {
       this.voice.options.model = model;
     }
   }
+  /** The host's per-line context (call rules, browser context, earlier conversation) rides THIS call only, fenced as the app's —
+   *  inside the user turn it read as the user's own words (live #938: "repeat everything I said" recited the call rules). The
+   *  stored turn keeps only what the user said, so later turns, briefs and the saved session never carry it. A block, not a
+   *  mid-transcript system message: the Anthropic/Google adapters keep only the leading system message. */
+  async sendWithContext(content, context) {
+    if (!context?.trim() || typeof content !== "string") return this.voice.send(content);
+    const base = this.voice.transcript.length;
+    try {
+      return await this.voice.send(hostContextBlock(context) + content);
+    } finally {
+      const m = this.voice.transcript.slice(base).find((x) => x.role === "user");
+      if (m) m.content = content;
+    }
+  }
   /** The turn SAID it is on it ("got it — checking…") but called no tool and nothing is running: a promise nothing
    *  keeps — the user waits on silence (live Para #798: a follow-up while the reflex believed a finished task still ran). */
   get hollowPromise() {
@@ -10888,6 +10910,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
    *  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) {
+    const ctx = opts?.context;
     this.clearHoldResume();
     this.holdResumed = false;
     if (opts?.replaces) this.replaceTurn(opts.replaces);
@@ -10913,7 +10936,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
         if (intent === "resume" && !reflexCut) return this.resumeParked();
         if (intent === "aside" || intent === "resume") {
           const told = intent === "aside" ? [...this.parkedRedeliver] : [];
-          return this.sendTurn(intent === "aside" ? content + this.asideNote(told) : content, true, rec, ext).then(async (r) => {
+          return this.sendTurn(intent === "aside" ? content + this.asideNote(told) : content, true, rec, ext, ctx).then(async (r) => {
             if (r.finishReason === "aborted" || this.heldThisTurn) return r;
             const missed = unsaidClauses(told.map((p) => p.text), this.turnSpoken, this.options.decider);
             const turn = this.turn;
@@ -10928,10 +10951,10 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
             return r;
           });
         }
-        return this.sendTurn(content, false, rec, ext);
+        return this.sendTurn(content, false, rec, ext, ctx);
       });
     }
-    return this.sendTurn(typeof content === "string" ? content + this.acceptNote(content) : content, false, rec, ext);
+    return this.sendTurn(typeof content === "string" ? content + this.acceptNote(content) : content, false, rec, ext, ctx);
   }
   /** 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. */
@@ -10999,7 +11022,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
       return { text: "", steps: 0, finishReason: "stop", messages: [] };
     });
   }
-  sendTurn(content, keepParked = false, rec, ext) {
+  sendTurn(content, keepParked = false, rec, ext, context) {
     const spec = this.spec;
     if (spec?.state === "pending") {
       if (typeof content === "string" && speculationConfirms(spec.text, content)) {
@@ -11052,7 +11075,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
       if (typeof content === "string") content += spellingNote(content);
       let res;
       try {
-        res = await this.reflexSend(content);
+        res = await this.reflexSend(content, context);
       } finally {
         if (signal) {
           this.voice.options.signal = ext;