@livx.cc/agentx 0.99.106 → 0.99.108

package/dist/cli.d.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
-import { o as RouterState, H as Hooks, p as RunResult, R as ReasoningEffort, C as ChannelMode, A as Agent } from './secondChannel-BYW5qPAJ.js';
+import { o as RouterState, H as Hooks, p as RunResult, R as ReasoningEffort, C as ChannelMode, A as Agent } from './secondChannel-3IPP3Qgh.js';
 import { IFilesystem } from '@livx.cc/wcli/core';
 import { M as Message, U as UserQuestion, H as HostBridge, c as ContentPart, o as MessageContent } from './tools-DZHZIyxh.js';
 
@@ -139,6 +139,7 @@ interface Args {
     reasoning?: ReasoningEffort;
     help: boolean;
     version: boolean;
+    keepAlive?: boolean;
     duplex: boolean;
     duplexV2?: boolean;
     call?: boolean;

package/dist/cli.js

@@ -13022,6 +13022,9 @@ var SecondChannelOptions = class {
   /** A bridge waits this long after the user's turn is dispatched, and plays only if channel-1 has said nothing yet
    *  (a fast reply/ack needs no bridge — one before it reads as the agent starting a different sentence). 0 = at once. */
   bridgeDelayMs = 1200;
+  /** Duplex v3 (§3 first sound): a bridge skips the decider (the veto stays for backchannels/fillers) and speaks a
+   *  canned line at once; a generated one is started at dispatch and used only if it already landed. */
+  instantBridge = false;
   /** No new interim for this long → a pause (hosts may also call onPause). */
   fillerPauseMs = 700;
   fillerMinWords = 4;
@@ -13093,6 +13096,8 @@ var SecondChannel = class {
   // the line the last barge actually cut (spoke())
   bridged = false;
   // one bridge per main turn
+  bridgeDraft = null;
+  // a bridge generated ahead, used only if ready in time
   recent = [];
   picks = /* @__PURE__ */ new Map();
   inflight = null;
@@ -13228,6 +13233,7 @@ var SecondChannel = class {
         if (this[k]) clearTimeout(this[k]);
         this[k] = null;
       }
+      if (this.o.instantBridge) this.prefetchBridge();
       const wait = Math.max(this.o.bridgeDelayMs, this.o.minGapMs - (this.o.now() - this.lastAt));
       if (wait > 0) this.bridgeTimer = setTimeout(() => {
         this.bridgeTimer = null;
@@ -13360,7 +13366,7 @@ var SecondChannel = class {
     try {
       let kind = rule;
       let choice;
-      if (this.o.decide && !cue) {
+      if (this.o.decide && !cue && !(rule === "bridge" && this.o.instantBridge)) {
         const ac = new AbortController();
         const d = await withBudget(this.o.decide(this.tail(), { ...this.state(pauseMs), rule }, ac.signal), this.o.decisionBudgetMs, "channel decision", ac);
         choice = d?.choice;
@@ -13394,7 +13400,24 @@ var SecondChannel = class {
       call_ms: Math.round(now4 - this.startedAt)
     };
   }
+  /** Start writing this turn's bridge now, so it may be ready by bridgeDelayMs. The bridge never waits for it. */
+  prefetchBridge() {
+    this.bridgeDraft = null;
+    if (!this.o.generate || !this.o.generateFor.includes("bridge") || !this.lang || !this.heard) return;
+    const gen = this.gen, ac = new AbortController();
+    const ctx = { kind: "bridge", heard: this.tail(), state: this.main, avoid: [...this.recent], lang: this.lang };
+    void withBudget(this.o.generate(ctx, ac.signal), Math.max(this.o.generateBudgetMs, this.o.bridgeDelayMs), "bridge generate", ac).then((raw) => {
+      const text = cleanLine(raw ?? "", ctx.lang);
+      if (text && gen === this.gen) this.bridgeDraft = { gen, text };
+    }).catch((e) => log27.debug(`bridge prefetch failed: ${e?.message ?? e}`));
+  }
   async line(kind, react = true) {
+    if (kind === "bridge" && this.o.instantBridge) {
+      const d = this.bridgeDraft?.gen === this.gen ? this.bridgeDraft.text : "";
+      this.bridgeDraft = null;
+      if (d && !this.recent.some((r) => norm3(r) === norm3(d))) return d;
+      return this.pick(kind);
+    }
     if (this.o.generate && this.o.generateFor.includes(kind) && (kind !== "backchannel" || react)) {
       const ac = new AbortController();
       const ctx = { kind, heard: this.tail(), state: this.main, avoid: [...this.recent], lang: this.lang, ...kind === "backchannel" && this.o.reactionGapMs ? { react: true } : {} };
@@ -13544,6 +13567,9 @@ var VoiceCall = class {
       } : {},
       mode: o.mode,
       aec: o.aec,
+      bridgeDelayMs: 700,
+      instantBridge: true,
+      // v3 §3: first sound <1.2s p50 — a bridge at 700ms if MAIN is still silent, no veto, no wait
       ...this.lang ? { lang: this.lang } : {},
       ...o.channel,
       speak: (text, kind) => this.say(text, kind),
@@ -18634,7 +18660,8 @@ function parseArgs(argv) {
     } else if (x === "--call") {
       a.call = true;
       a.duplex = true;
-    } else if (x === "--channel-only") a.channelOnly = true;
+    } else if (x === "--keep-alive") a.keepAlive = true;
+    else if (x === "--channel-only") a.channelOnly = true;
     else if (x === "--channel-mode") a.channelMode = parseChannelMode(val(++i, x));
     else if (x === "--conversational" || x === "--convo" || x === "--voice") {
       a.voice = true;
@@ -18676,6 +18703,7 @@ function parseArgs(argv) {
   if (a.worktree && (a.vfs || a.boddb)) throw new Error("--worktree is a real-disk concept \u2014 incompatible with --vfs/--boddb");
   if (a.duplex && (a.task || a.print)) throw new Error("--duplex is interactive-only (a conversational mode) \u2014 drop the task/-p");
   if (a.inputFormat && (!a.duplex && !a.print && !a.channelOnly || a.outputFormat !== "stream-json")) throw new Error("--input-format stream-json needs --output-format stream-json and --duplex (or --voice), --channel-only or -p");
+  if (a.keepAlive && (!a.print || !a.inputFormat)) throw new Error("--keep-alive needs -p --input-format stream-json --output-format stream-json");
   if (a.channelOnly && !a.inputFormat) throw new Error("--channel-only needs --input-format stream-json --output-format stream-json");
   if (a.duplex && a.plan) throw new Error("--plan is not supported in --duplex (workers are non-interactive; a plan could never be approved)");
   if (a.voiceSystemPrompt && !a.duplex) throw new Error("--voice-system-prompt only applies with --duplex");
@@ -18763,6 +18791,9 @@ Flags:
                        (NDJSON turns/barge-ins on stdin, reflex text + worker speech + task events on stdout)
                        with -p: the first {"type":"user","text"} line is the prompt; later ones STEER the running turn
                        (unconsumed steers come back as the result's \`unsteered\`)
+  --keep-alive         with -p --input-format stream-json: stay up after a turn \u2014 each {"type":"user"} line while idle
+                       is the NEXT turn (warm: same session, model connection and MCP servers), one {type:result}
+                       per turn; {"type":"abort"} stops the running turn; stdin EOF exits
   --output-format <f>  headless output: text (default) | json (one result object) | stream-json (NDJSON events: {type:text|thinking}\u2026 then {type:result})
   -v, --version        print version and exit
   -h, --help
@@ -22527,9 +22558,9 @@ async function channelServe(args, ai, cfg) {
   await new Promise((r) => rl.on("close", () => r()));
   call.end();
 }
-function readStdinSteers() {
+function readStdinSteers(keepAlive = false) {
   const early = [];
-  let sink, got;
+  let sink, got, closed = false;
   const first = new Promise((res) => {
     got = res;
   });
@@ -22541,6 +22572,10 @@ function readStdinSteers() {
     } catch {
       return;
     }
+    if (keepAlive && m?.type === "abort") {
+      activeTurn?.abort();
+      return;
+    }
     if (m?.type !== "user" || typeof m.text !== "string" || !m.text.trim()) return;
     if (got) {
       got(m.text);
@@ -22548,11 +22583,21 @@ function readStdinSteers() {
     } else if (sink) sink(m.text);
     else early.push(m.text);
   });
-  rl.on("close", () => got?.(""));
+  rl.on("close", () => {
+    closed = true;
+    got?.("");
+    got = void 0;
+  });
+  const next = () => {
+    sink = void 0;
+    return early.length ? Promise.resolve(early.shift()) : closed ? Promise.resolve("") : new Promise((res) => {
+      got = res;
+    });
+  };
   return { first, steer: (to) => {
     sink = to;
     early.splice(0).forEach(to);
-  } };
+  }, next };
 }
 function readAllStdin() {
   return new Promise((res) => {
@@ -22587,7 +22632,7 @@ async function main() {
     process.exit(installUpdate() ? 0 : 1);
   }
   if (args.debug) process.env.DEBUG ||= "*";
-  const steers = args.print && args.inputFormat && !args.task ? readStdinSteers() : void 0;
+  const steers = args.print && args.inputFormat && !args.task ? readStdinSteers(args.keepAlive) : void 0;
   if (steers) args.task = (await steers.first).trim();
   else if (args.print && !args.task && !process.stdin.isTTY) args.task = (await readAllStdin()).trim();
   if (args.print && !args.task) {
@@ -22680,7 +22725,19 @@ async function main() {
     const session = startSession(args, store, agent, cwd);
     process.once("SIGINT", () => activeTurn?.abort());
     steers?.steer((text) => agent.inject(text));
-    const { ok, res } = await runTurn(agent, store, session, args.task, void 0, cwd, autoRouteSend(args, agent, () => session, (m) => providerOptionsFor(m, cwd, cfg.mcpServers, mounted.map((x) => x.name))));
+    const turn = (task) => runTurn(agent, store, session, task, void 0, cwd, autoRouteSend(args, agent, () => session, (m) => providerOptionsFor(m, cwd, cfg.mcpServers, mounted.map((x) => x.name))));
+    if (args.keepAlive && steers) {
+      for (let task = args.task; task.trim(); task = (await steers.next()).trim()) {
+        steers.steer((text) => agent.inject(text));
+        const { res: res2 } = await turn(task);
+        const left = agent.drainPendingSteers();
+        process.stdout.write(JSON.stringify({ type: "result", ...res2 ? jsonResult(res2, session) : { ok: false, finishReason: "error", sessionId: session.meta.id }, ...left.length ? { unsteered: left } : {} }) + "\n");
+      }
+      await closeMcp(mounted);
+      worktreeCleanup?.();
+      process.exit(0);
+    }
+    const { ok, res } = await turn(args.task);
     if (cfg.reflectOnFailure && !ok && res?.finishReason !== "needs_input" && res && agent.options.memoryDir) {
       const _fsBase = agent.options.fs.getCwd() === "/" ? "" : agent.options.fs.getCwd();
       const slug2 = await reflectOnRun({ ai, model: agent.options.model, fs: agent.options.fs, dir: primaryMemDir(agent.options.memoryDir, `${_fsBase}/.agent/memory`), result: res });