@livx.cc/agentx 0.99.110 → 0.99.112

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-3IPP3Qgh.js';
+import { o as RouterState, H as Hooks, p as RunResult, R as ReasoningEffort, C as ChannelMode, A as Agent } from './secondChannel-CJMY5EbL.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';
 
@@ -375,5 +375,9 @@ declare function runTurn(agent: Agent, store: SessionStore, session: SessionData
 }>;
 /** A failed duplex turn's cause, for the host to show: the provider's message, and for a missing key what to set. */
 declare function duplexError(e: unknown, reflexModel: string): string;
+/** --keep-alive {type:'rollback'}: take back the turn that began at transcript index `start` — its user line, steers and
+ *  (partial) reply leave this session and, on claude-code/*, Claude Code's own history too (rewindClaudeCodeSession) — so
+ *  the next turn (a re-final's fuller text) runs warm, as if that one was never sent. Returns the messages dropped. */
+declare function rollbackTurn(agent: Agent, store: Pick<SessionStore, 'save'>, session: SessionData, start: number): Promise<number>;
 
-export { type PermMode, abortActiveTurn, apiKeysFromEnv, appendMemoryNote, cacheMultipliers, condenseReplay, costOf, duplexError, duplexModels, estimateTranscriptTokens, expandMentions, exportMarkdown, fmtUsd, formatHistory, formatStatus, formatTranscriptFull, jsonResult, loadBodifySecrets, loadInstallEnv, makeHost, mcpMentionResolver, mentionRefs, modelUsable, parseArgs, pastePathClassifier, readImageParts, readMultiline, resolvePermMode, runShellLine, runTurn, setMcpMentionResolver, summarizeResult, turnCost };
+export { type PermMode, abortActiveTurn, apiKeysFromEnv, appendMemoryNote, cacheMultipliers, condenseReplay, costOf, duplexError, duplexModels, estimateTranscriptTokens, expandMentions, exportMarkdown, fmtUsd, formatHistory, formatStatus, formatTranscriptFull, jsonResult, loadBodifySecrets, loadInstallEnv, makeHost, mcpMentionResolver, mentionRefs, modelUsable, parseArgs, pastePathClassifier, readImageParts, readMultiline, resolvePermMode, rollbackTurn, runShellLine, runTurn, setMcpMentionResolver, summarizeResult, turnCost };

package/dist/cli.js

@@ -3432,7 +3432,7 @@ function copyTextToClipboard(text, platform2 = process.platform) {
 
 // cli/cli.ts
 import { join as join16, resolve as resolve5, basename as basename4, extname, dirname as dirname6 } from "path";
-import { AIClient as AIClient2, listModels, listProviders, getProviderFromModel, getModelInfo, resolveModel, isModelSupported, disposeCursorSessions, disposeClaudeCodeSessions } from "ai.libx.js";
+import { AIClient as AIClient2, listModels, listProviders, getProviderFromModel, getModelInfo, resolveModel, isModelSupported, disposeCursorSessions, disposeClaudeCodeSessions, rewindClaudeCodeSession } from "ai.libx.js";
 
 // src/ccBridge.ts
 var CC_BRIDGED = /* @__PURE__ */ new Set(["Recall", "Remember", "MemorySearch", "Forget"]);
@@ -5022,6 +5022,39 @@ var Agent = class _Agent {
    *  steers over its own channel (claude-code's warm InputQueue via `providerOptions.steer`). Non-text
    *  injections (images) stay queued for the step-boundary `drainInjections()` re-open — the text-only
    *  steer channel can't carry them. Consumed DURING chat(); no overlap with drainInjections() (post-call). */
+  /** claude-code/*: the providerOptions every step adds (and prewarm, so the session it starts is the one step 1 reuses). */
+  claudeCodePo() {
+    const o = this.options;
+    if (!o.model.startsWith("claude-code/")) return void 0;
+    const po = { steer: () => this.drainPendingSteers() };
+    const bridged = (t) => o.ccBridge === "all" || CC_BRIDGED.has(t.name);
+    if (o.providerOptions?.claudeCodeSession && this.activeTools.some(bridged)) {
+      this.ccServer ??= ccToolServer("agentx", () => this.activeTools.filter(bridged), (n, a) => this.ccExec(n, a));
+      po.mcpServers = { ...o.providerOptions?.mcpServers, agentx: this.ccServer };
+    }
+    const denyTools = claudeCodeDisallowedTools(o.permissions);
+    if (denyTools.length) {
+      const prior = o.providerOptions?.disallowedTools ?? [];
+      po.disallowedTools = [.../* @__PURE__ */ new Set([...prior, ...denyTools])];
+    }
+    return po;
+  }
+  /** claude-code/* warm session: start it now (its process, MCP handshakes) so the first turn doesn't pay for it. Its
+   *  system prompt is fixed at the start, so it is prepared here (no task hint) — memoized, the turns reuse the same one.
+   *  No model call; the transcript gains only that system message. Other models: nothing to warm. */
+  async prewarm() {
+    const o = this.options;
+    if (!o.model.startsWith("claude-code/") || !o.providerOptions?.claudeCodeSession) return;
+    await this.ensureFs();
+    const systemPrompt = await this.prepare(), startCtx = await this.fireSessionStart();
+    const sys = { role: "system", content: systemPrompt + (startCtx ? "\n\n" + startCtx : "") };
+    if (this.transcript[0]?.role === "system") this.transcript[0] = sys;
+    else this.transcript.unshift(sys);
+    const po = this.claudeCodePo(), frag = reasoningToChatFragment(o.model, o.reasoning);
+    const r = await o.ai.chat({ model: o.model, messages: this.trimContext(), tools: [], stream: true, ...frag, ...o.promptCache ? { promptCache: true } : {}, providerOptions: { ...frag.providerOptions, ...o.providerOptions, ...po, prewarm: true } });
+    for await (const _ of r) {
+    }
+  }
   drainPendingSteers() {
     if (!this.pendingInjections.length) return [];
     const texts = [];
@@ -5314,18 +5347,8 @@ var Agent = class _Agent {
         }
       };
       const cursorPo = isCursorWithTools ? { toolTimeoutMs: effectiveToolTimeoutMs, toolExecutor: hostExec } : void 0;
-      const claudeSteerPo = o.model.startsWith("claude-code/") ? { steer: () => this.drainPendingSteers() } : void 0;
-      const bridged = (t) => o.ccBridge === "all" || CC_BRIDGED.has(t.name);
-      if (claudeSteerPo && o.providerOptions?.claudeCodeSession && this.activeTools.some(bridged)) {
-        this.ccServer ??= ccToolServer("agentx", () => this.activeTools.filter(bridged), (n, a) => this.ccExec(n, a));
-        claudeSteerPo.mcpServers = { ...o.providerOptions?.mcpServers, agentx: this.ccServer };
-      }
+      const claudeSteerPo = this.claudeCodePo();
       if (this.ccServer) this.ccExec = hostExec;
-      const denyTools = o.model.startsWith("claude-code/") ? claudeCodeDisallowedTools(o.permissions) : [];
-      if (denyTools.length) {
-        const prior = o.providerOptions?.disallowedTools ?? [];
-        claudeSteerPo.disallowedTools = [.../* @__PURE__ */ new Set([...prior, ...denyTools])];
-      }
       const cursorDeny = o.model.startsWith("cursor/") ? o.permissions?.denyRules(true) ?? [] : [];
       if (cursorDeny.length)
         throw new Error(`cursor/* cannot enforce --disallowedTools (${cursorDeny.join(", ")}): its native tools bypass them. Refusing to run \u2014 use a claude-code/* or API model, or drop --disallowedTools.`);
@@ -18837,7 +18860,10 @@ Flags:
                        (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
+                       per turn; it boots (and warms a claude-code/* session) before the first line arrives;
+                       {"type":"abort"} stops the running turn (the next one is still warm); {"type":"rollback"}
+                       takes the last turn back (stopping it if running) \u2014 its user line and reply leave the
+                       session, Claude Code's own history included; 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
@@ -22574,10 +22600,14 @@ async function channelServe(args, ai, cfg) {
     sendTurn: (text, o) => out({ type: "turn", id: o.id, text, ...o.replaces ? { replaces: o.replaces } : {} }),
     abortTurn: (id) => out({ type: "abort", id }),
     onMetric: (m) => {
-      if (m.name === "first_sound" || m.name === "first_word" || m.name === "drop" || m.name === "hold") out({ type: "metric", ...m });
+      if (m.name !== "lang") out({ type: "metric", ...m });
     }
+    // (turn + fill too: the host's log shows which turns formed and which fill lines played)
+  });
+  const overlap2 = overlapResponder(ai, args.channelMode, (o) => {
+    if (o.verdict === "cut") call.barge();
+    out(o);
   });
-  const overlap2 = overlapResponder(ai, args.channelMode, out);
   out({ type: "ready", model, channelMode: args.channelMode, softBarge: softBarge(args.channelMode), call: true, ...notes.length ? { notes } : {} });
   const rl = createInterface({ input: process.stdin });
   rl.on("line", (line) => {
@@ -22604,7 +22634,7 @@ async function channelServe(args, ai, cfg) {
 }
 function readStdinSteers(keepAlive = false) {
   const early = [];
-  let sink, got, closed = false;
+  let sink, got, closed = false, started = false;
   const first = new Promise((res) => {
     got = res;
   });
@@ -22620,7 +22650,17 @@ function readStdinSteers(keepAlive = false) {
       activeTurn?.abort();
       return;
     }
+    if (keepAlive && m?.type === "rollback") {
+      if (!started) return;
+      activeTurn?.abort();
+      if (got) {
+        got({ type: "rollback" });
+        got = void 0;
+      } else early.push({ type: "rollback" });
+      return;
+    }
     if (m?.type !== "user" || typeof m.text !== "string" || !m.text.trim()) return;
+    started = true;
     if (got) {
       got(m.text);
       got = void 0;
@@ -22640,9 +22680,21 @@ function readStdinSteers(keepAlive = false) {
   };
   return { first, steer: (to) => {
     sink = to;
-    early.splice(0).forEach(to);
+    while (typeof early[0] === "string") to(early.shift());
   }, next };
 }
+async function rollbackTurn(agent, store, session, start) {
+  if (start < 0 || start > agent.transcript.length) return 0;
+  const dropped = agent.transcript.length - start;
+  agent.transcript.splice(start);
+  session.messages = agent.transcript;
+  session.meta.updated = Date.now();
+  session.meta.cc = void 0;
+  const cc = agent.options.providerOptions?.claudeCodeSession;
+  if (typeof cc === "string" && agent.options.model.startsWith("claude-code/")) await rewindClaudeCodeSession(cc);
+  store.save(session);
+  return dropped;
+}
 function readAllStdin() {
   return new Promise((res) => {
     let data = "";
@@ -22677,9 +22729,11 @@ async function main() {
   }
   if (args.debug) process.env.DEBUG ||= "*";
   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) {
+  const warmBoot = !!(steers && args.keepAlive);
+  if (steers && !warmBoot) args.task = (await steers.first).trim();
+  else if (warmBoot) {
+  } else if (args.print && !args.task && !process.stdin.isTTY) args.task = (await readAllStdin()).trim();
+  if (args.print && !args.task && !warmBoot) {
     console.error(red("  -p: empty prompt (no task argument and nothing on stdin)"));
     process.exit(2);
   }
@@ -22746,8 +22800,8 @@ async function main() {
       }
     }
   });
-  if (args.task) {
-    const compactArg = /^\/compact(?:\s+([\s\S]*))?$/.exec(args.task.trim());
+  if (args.task || warmBoot) {
+    const compactArg = /^\/compact(?:\s+([\s\S]*))?$/.exec((args.task ?? "").trim());
     if (compactArg) {
       const agent2 = await makeAgent(args, ai, cfg, [], []), store2 = new SessionStore(cwd), session2 = startSession(args, store2, agent2, cwd);
       const est = (m) => estimateTranscriptTokens(m, agent2.options.keepRecentImages, agent2.options.imageInput?.(agent2.options.model) !== false);
@@ -22770,8 +22824,22 @@ async function main() {
     process.once("SIGINT", () => activeTurn?.abort());
     steers?.steer((text) => agent.inject(text));
     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()) {
+    if (warmBoot && steers) {
+      bindClaudeCodeSession(agent, session);
+      await agent.prewarm().catch((e) => err(dim(`  (prewarm failed: ${e?.message ?? e})
+`)));
+      let start = -1;
+      for (let line = await steers.first; ; line = await steers.next()) {
+        if (typeof line !== "string") {
+          const n = await rollbackTurn(agent, store, session, start);
+          start = -1;
+          err(dim(`  \u21B6 rolled back the last turn (${n} message${n === 1 ? "" : "s"})
+`));
+          continue;
+        }
+        const task = line.trim();
+        if (!task) break;
+        start = agent.transcript.length;
         steers.steer((text) => agent.inject(text));
         const { res: res2 } = await turn(task);
         const left = agent.drainPendingSteers();
@@ -22841,6 +22909,7 @@ export {
   readImageParts,
   readMultiline,
   resolvePermMode,
+  rollbackTurn,
   runShellLine,
   runTurn,
   setMcpMentionResolver,