@livx.cc/agentx 0.99.106 → 0.99.107

package/dist/cli.d.ts

@@ -139,6 +139,7 @@ interface Args {
     reasoning?: ReasoningEffort;
     help: boolean;
     version: boolean;
+    keepAlive?: boolean;
     duplex: boolean;
     duplexV2?: boolean;
     call?: boolean;

package/dist/cli.js

@@ -18634,7 +18634,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 +18677,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 +18765,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 +22532,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 +22546,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 +22557,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 +22606,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 +22699,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 });