@livx.cc/agentx 0.99.45 → 0.99.47

package/dist/{Agent-Bzs57-iD.d.ts → Agent-BWbQ4Sqp.d.ts}

@@ -186,6 +186,8 @@ interface RunResult {
      *  Answer it and resume the session to continue. */
     finishReason: 'stop' | 'max_steps' | 'budget' | 'timeout' | 'loop' | 'max_tool_calls' | 'aborted' | 'error' | 'needs_input' | 'empty';
     messages: Message[];
+    /** The provider's own finish reason for the final model call (e.g. 'stop', 'end_turn', 'length'), when it gave one. */
+    providerFinishReason?: string;
     /** The parked question — present iff `finishReason === 'needs_input'`. */
     question?: UserQuestion;
     /** Accumulated token usage across all turns (non-stream path). With prompt caching,
@@ -352,6 +354,10 @@ declare class AgentOptions {
      *  not prose: a named tool with zero invocations is provable. On detection the loop nudges ONCE for a real
      *  call, and records the names in `RunResult.fabricatedToolClaims` either way. */
     catchFabricatedToolUse: boolean;
+    /** An empty model turn (no text, no tools) that ends the loop after work is re-prompted ONCE, then finishes
+     *  as `finishReason:'empty'` (a failure) instead of a phantom 'stop'. Off for layers that deliberately
+     *  allow a silent turn and repair it themselves (the duplex voice reflex). */
+    failEmptyTurns: boolean;
     /** Fold the dropped middle of an over-long transcript into a synthetic summary (edge-safe, no LLM). Off => drop-oldest. */
     compaction?: {
         maxMessages: number;
@@ -415,6 +421,22 @@ declare class Agent {
     /** Per-run ground truth: every tool name actually INVOKED this run (native dispatch + delegated
      *  runtime activity). The ledger that makes a fabricated tool claim provable. Reset per run. */
     private invokedTools;
+    /** Delegated-runtime HOST tools currently executing (cursor toolExecutor). While > 0 the provider is
+     *  not silent — it is waiting on US — so the idle-stall watchdog must not fire (see armStallWatchdog). */
+    private hostToolsInFlight;
+    /** The hold is bounded by the transport tool deadline: a host tool that never settles (the helper already gave
+     *  up on it) must not disable stall protection for the rest of the request — or this instance. */
+    private hostToolHoldUntil;
+    /** Delegated-runtime NATIVE tools (cursor's own shell/mcp/task) seen `running` but not yet `completed`/`error`,
+     *  id → hold-until. The runtime streams nothing while one runs, so it holds the watchdog like a host tool —
+     *  bounded by the same tool deadline (`toolHoldMs`) so a lost `completed` event can't disable it. */
+    private nativeToolsInFlight;
+    private toolHoldMs;
+    /** A tool (host or native) already executed in the current step attempt: a stall retry replays the step
+     *  from the pre-step transcript, which would re-run it — so such a stall is not retried. */
+    private toolRanThisAttempt;
+    /** Resets the active request's stall timer; a host tool's completion restarts the model's idle window. */
+    private stallPoke?;
     /** Advertised tools this run's text claimed to have used while the ledger showed zero calls. */
     private fabricatedClaims;
     private activeHooks?;
@@ -519,6 +541,8 @@ declare class Agent {
      * `stallMs = 0` disables the timer but still links parent-abort → child so cancellation propagates.
      */
     private armStallWatchdog;
+    /** A host or native delegated tool is running within its deadline — the provider is quiet, not stalled. */
+    private toolHoldActive;
     /** A clean-stop turn that carries no assistant text AND no tool calls (native or delegated) — a
      *  non-result the model produced by going silent. Callers retry it rather than report "done". */
     private isEmptyStop;

package/dist/cli.d.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
-import { H as Hooks, i as RunResult, R as ReasoningEffort, A as Agent } from './Agent-Bzs57-iD.js';
+import { H as Hooks, i as RunResult, R as ReasoningEffort, A as Agent } from './Agent-BWbQ4Sqp.js';
 import { IFilesystem } from '@livx.cc/wcli/core';
 import { M as Message, U as UserQuestion, H as HostBridge, c as ContentPart, g as MessageContent } from './tools-BqL8Lk4J.js';
 
@@ -277,8 +277,6 @@ declare function expandMentions(fs: IFilesystem, line: string): Promise<{
 declare function jsonResult(res: RunResult, session: SessionData): {
     error?: any;
     question?: UserQuestion | undefined;
-    ok: boolean;
-    finishReason: "error" | "budget" | "stop" | "max_steps" | "timeout" | "loop" | "max_tool_calls" | "aborted" | "needs_input" | "empty";
     text: string;
     steps: number;
     tools: number;
@@ -290,6 +288,9 @@ declare function jsonResult(res: RunResult, session: SessionData): {
         cacheReadTokens?: number;
     } | undefined;
     sessionId: string;
+    providerFinishReason?: string | undefined;
+    ok: boolean;
+    finishReason: "error" | "budget" | "stop" | "max_steps" | "timeout" | "loop" | "max_tool_calls" | "aborted" | "needs_input" | "empty";
 };
 /**
  * Read one logical input, supporting `\`-continuation for multi-line prompts: a line ending in

package/dist/cli.js

@@ -3961,6 +3961,10 @@ var AgentOptions = class {
    *  not prose: a named tool with zero invocations is provable. On detection the loop nudges ONCE for a real
    *  call, and records the names in `RunResult.fabricatedToolClaims` either way. */
   catchFabricatedToolUse = true;
+  /** An empty model turn (no text, no tools) that ends the loop after work is re-prompted ONCE, then finishes
+   *  as `finishReason:'empty'` (a failure) instead of a phantom 'stop'. Off for layers that deliberately
+   *  allow a silent turn and repair it themselves (the duplex voice reflex). */
+  failEmptyTurns = true;
   /** Fold the dropped middle of an over-long transcript into a synthetic summary (edge-safe, no LLM). Off => drop-oldest. */
   compaction;
   /** Add `Checkpoint`/`Rollback` tools (requires the fs to be an OverlayFilesystem). */
@@ -4034,6 +4038,22 @@ var Agent = class _Agent {
   /** Per-run ground truth: every tool name actually INVOKED this run (native dispatch + delegated
    *  runtime activity). The ledger that makes a fabricated tool claim provable. Reset per run. */
   invokedTools = /* @__PURE__ */ new Set();
+  /** Delegated-runtime HOST tools currently executing (cursor toolExecutor). While > 0 the provider is
+   *  not silent — it is waiting on US — so the idle-stall watchdog must not fire (see armStallWatchdog). */
+  hostToolsInFlight = 0;
+  /** The hold is bounded by the transport tool deadline: a host tool that never settles (the helper already gave
+   *  up on it) must not disable stall protection for the rest of the request — or this instance. */
+  hostToolHoldUntil = 0;
+  /** Delegated-runtime NATIVE tools (cursor's own shell/mcp/task) seen `running` but not yet `completed`/`error`,
+   *  id → hold-until. The runtime streams nothing while one runs, so it holds the watchdog like a host tool —
+   *  bounded by the same tool deadline (`toolHoldMs`) so a lost `completed` event can't disable it. */
+  nativeToolsInFlight = /* @__PURE__ */ new Map();
+  toolHoldMs = 0;
+  /** A tool (host or native) already executed in the current step attempt: a stall retry replays the step
+   *  from the pre-step transcript, which would re-run it — so such a stall is not retried. */
+  toolRanThisAttempt = false;
+  /** Resets the active request's stall timer; a host tool's completion restarts the model's idle window. */
+  stallPoke;
   /** Advertised tools this run's text claimed to have used while the ledger showed zero calls. */
   fabricatedClaims = /* @__PURE__ */ new Set();
   activeHooks;
@@ -4336,6 +4356,7 @@ var Agent = class _Agent {
     let toolCallsTotal = 0;
     let lastFp = "";
     let repeats = 0;
+    let emptyNudged = false;
     let closureNudged = false;
     let lastProgressAt = start;
     const kill = (finishReason) => {
@@ -4344,12 +4365,13 @@ var Agent = class _Agent {
       const claims = this.survivingClaims();
       return { text: lastAssistantText(this.transcript), steps, finishReason, messages: this.transcript, usage, usageEstimated, ...claims.length ? { fabricatedToolClaims: claims } : {} };
     };
+    const overBudget = () => !!o.maxTokens && usage.totalTokens - 0.9 * usage.cacheReadTokens >= o.maxTokens;
+    const canNudge = () => steps < o.maxSteps && !overBudget();
     while (true) {
       if (o.signal?.aborted) return kill("aborted");
       if (steps >= o.maxSteps) return kill("max_steps");
       if (o.timeoutMs && Date.now() - lastProgressAt - this.parkedMs >= o.timeoutMs) return kill("timeout");
-      const budgetTokens = usage.totalTokens - 0.9 * usage.cacheReadTokens;
-      if (o.maxTokens && budgetTokens >= o.maxTokens) return kill("budget");
+      if (overBudget()) return kill("budget");
       steps++;
       this.options.host?.notify?.({ kind: "turn_start", message: `step ${steps}` });
       let res;
@@ -4360,6 +4382,7 @@ var Agent = class _Agent {
       const hostToolTimeoutMs = o.providerOptions?.toolTimeoutMs;
       const derivedToolTimeoutMs = Math.max(TRANSPORT_TOOL_TIMEOUT_FLOOR_MS, ...this.activeTools.map(transportHeadroomMs));
       const effectiveToolTimeoutMs = typeof hostToolTimeoutMs === "number" ? Math.max(hostToolTimeoutMs, derivedToolTimeoutMs) : derivedToolTimeoutMs;
+      this.toolHoldMs = effectiveToolTimeoutMs;
       if (isCursorWithTools) {
         if (typeof hostToolTimeoutMs === "number" && effectiveToolTimeoutMs !== hostToolTimeoutMs) {
           log6.warn(`providerOptions.toolTimeoutMs=${hostToolTimeoutMs}ms is below what the registered tools need \u2014 RAISED to ${effectiveToolTimeoutMs}ms. ${toolTimeoutViolations(this.activeTools, hostToolTimeoutMs).length} tool(s) could outlive it, and the transport would have destroyed their results. To lower it, lower the tools' own maxDurationMs (e.g. the Shell tool's maxTimeoutMs) instead.`);
@@ -4370,7 +4393,15 @@ var Agent = class _Agent {
         toolTimeoutMs: effectiveToolTimeoutMs,
         toolExecutor: async (name, args) => {
           const tc = { id: `cursor-${Date.now()}`, type: "function", function: { name, arguments: JSON.stringify(args) } };
-          return await this.dispatch(tc);
+          this.hostToolsInFlight++;
+          this.hostToolHoldUntil = Math.max(this.hostToolHoldUntil, Date.now() + effectiveToolTimeoutMs);
+          try {
+            return await this.dispatch(tc);
+          } finally {
+            this.hostToolsInFlight--;
+            this.toolRanThisAttempt = true;
+            this.stallPoke?.();
+          }
         }
       } : void 0;
       const claudeSteerPo = o.model.startsWith("claude-code/") ? { steer: () => this.drainPendingSteers() } : void 0;
@@ -4381,6 +4412,8 @@ var Agent = class _Agent {
       };
       try {
         for (let attempt = 0; ; attempt++) {
+          this.nativeToolsInFlight.clear();
+          this.toolRanThisAttempt = false;
           try {
             if (useStream) {
               const stall = this.armStallWatchdog(o.signal, o.stallMs);
@@ -4410,7 +4443,9 @@ var Agent = class _Agent {
             const stalled = err2?.code === "stall";
             const empty = err2?.code === "empty" || err2?.code === "cursor_silent";
             const maxAttempts = empty ? Math.max(o.emptyRetries, 0) : 2;
-            const transient = !o.signal?.aborted && !isAbortError(err2) && attempt < maxAttempts && (network || serverSide || stalled || empty);
+            const replaysTool = stalled && this.toolRanThisAttempt;
+            if (replaysTool) log6.warn("model stall after tool(s) already ran this step \u2014 not retrying (a retry would replay them)");
+            const transient = !o.signal?.aborted && !isAbortError(err2) && !replaysTool && attempt < maxAttempts && (network || serverSide || stalled || empty);
             if (!transient) throw err2;
             const waitMs = (empty ? o.emptyRetryBaseMs : 1e3) * (attempt + 1);
             log6.warn(`${empty ? "empty model turn" : stalled ? "model stall" : "network drop"} mid-step (${err2?.message ?? err2}) \u2014 retrying in ${waitMs}ms`);
@@ -4491,9 +4526,22 @@ var Agent = class _Agent {
       }
       if (toolCalls.length === 0) {
         if (this.drainInjections()) continue;
+        if (emptyTurn && o.failEmptyTurns) {
+          if (!emptyNudged && canNudge()) {
+            emptyNudged = true;
+            log6.warn(`empty model turn after tool work (step ${steps}, provider finishReason=${res.finishReason ?? "n/a"}) \u2014 nudging once`);
+            this.transcript.push({ role: "user", content: "Continue \u2014 you returned nothing. Answer the user now using the tool results above, or keep working if you are not done." });
+            continue;
+          }
+          log6.warn(`model returned empty turns after tool work \u2014 surfacing as failed`);
+          const e = new Error("empty_response: model returned an empty turn (no text, no tools) after a re-prompt");
+          e.code = "empty";
+          return { text: "", steps, finishReason: "empty", ...res.finishReason ? { providerFinishReason: res.finishReason } : {}, messages: this.transcript, usage, usageEstimated, error: e };
+        }
         const fabricated = o.catchFabricatedToolUse && !closureNudged ? this.fabricatedToolNames(contentText(res.content ?? "")) : [];
         for (const n of fabricated) this.fabricatedClaims.add(n);
-        if (fabricated.length && steps < o.maxSteps) {
+        if (fabricated.length && !canNudge()) log6.warn(`fabricated tool use: text names ${fabricated.join(", ")} but no step/budget left to demand the call \u2014 finishing with the existing answer`);
+        if (fabricated.length && canNudge()) {
           closureNudged = true;
           log6.warn(`fabricated tool use: text names ${fabricated.join(", ")} but the run invoked ${this.invokedTools.size ? [...this.invokedTools].join(", ") : "nothing"} \u2014 demanding the real call`);
           this.transcript.push({
@@ -4502,7 +4550,7 @@ var Agent = class _Agent {
           });
           continue;
         }
-        if (o.closeDelegatedTurns && res.endedWithoutClosing && !closureNudged && steps < o.maxSteps) {
+        if (o.closeDelegatedTurns && res.endedWithoutClosing && !closureNudged && canNudge()) {
           closureNudged = true;
           log6.verbose("delegated turn went silent after a tool \u2014 nudging a closing answer");
           this.transcript.push({
@@ -4516,7 +4564,7 @@ var Agent = class _Agent {
         this.releaseStaleImages();
         await this.activeHooks?.onStop?.(res.content ?? "");
         const claims = this.survivingClaims();
-        return { text: res.content ?? "", steps, finishReason: "stop", messages: this.transcript, usage, usageEstimated, ...claims.length ? { fabricatedToolClaims: claims } : {} };
+        return { text: res.content ?? "", steps, finishReason: "stop", ...res.finishReason ? { providerFinishReason: res.finishReason } : {}, messages: this.transcript, usage, usageEstimated, ...claims.length ? { fabricatedToolClaims: claims } : {} };
       }
       const fp = toolCalls.map((tc) => tc.function.name + ":" + (tc.function.arguments ?? "")).join("|");
       repeats = fp === lastFp ? repeats + 1 : 1;
@@ -4580,10 +4628,12 @@ var Agent = class _Agent {
       if (!stallMs) return;
       if (timer) clearTimeout(timer);
       timer = setTimeout(() => {
+        if (this.toolHoldActive()) return poke();
         fired = true;
         ac.abort(stallError());
       }, stallMs);
     };
+    this.stallPoke = poke;
     poke();
     const stalled = () => fired && !parent?.aborted;
     return {
@@ -4592,11 +4642,19 @@ var Agent = class _Agent {
       stalled,
       clear: () => {
         if (timer) clearTimeout(timer);
+        if (this.stallPoke === poke) this.stallPoke = void 0;
         parent?.removeEventListener("abort", onParentAbort);
       },
       reclassify: (err2) => stalled() ? stallError() : err2
     };
   }
+  /** A host or native delegated tool is running within its deadline — the provider is quiet, not stalled. */
+  toolHoldActive() {
+    const now4 = Date.now();
+    if (this.hostToolsInFlight > 0 && now4 < this.hostToolHoldUntil) return true;
+    for (const until of this.nativeToolsInFlight.values()) if (now4 < until) return true;
+    return false;
+  }
   /** A clean-stop turn that carries no assistant text AND no tool calls (native or delegated) — a
    *  non-result the model produced by going silent. Callers retry it rather than report "done". */
   isEmptyStop(res) {
@@ -4635,6 +4693,12 @@ var Agent = class _Agent {
           if (a.output !== void 0) prev.output = a.output;
           prev.status = a.status;
         }
+        if (a.status === "running") {
+          if (a.id) this.nativeToolsInFlight.set(a.id, Date.now() + this.toolHoldMs);
+        } else {
+          if (a.id) this.nativeToolsInFlight.delete(a.id);
+          this.toolRanThisAttempt = true;
+        }
         sawTool = true;
         this.invokedTools.add(a.name);
         trailing = "";
@@ -4687,8 +4751,9 @@ var Agent = class _Agent {
    */
   fabricatedToolNames(text) {
     const out = [];
+    const invoked = new Set([...this.invokedTools].map(toolKey));
     for (const t of this.activeTools) {
-      if (this.invokedTools.has(t.name)) continue;
+      if (invoked.has(toolKey(t.name))) continue;
       if (t.name.length < 4 || !/[_\-A-Z]/.test(t.name)) continue;
       const re = new RegExp(`(?:^|[^\\w])${t.name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?:[^\\w]|$)`);
       if (re.test(text)) out.push(t.name);
@@ -4701,7 +4766,8 @@ var Agent = class _Agent {
    *  call that demonstrably ran. See `RunResult.fabricatedToolClaims`. */
   survivingClaims() {
     if (!this.fabricatedClaims.size) return [];
-    return [...this.fabricatedClaims].filter((n) => !this.invokedTools.has(n));
+    const invoked = new Set([...this.invokedTools].map(toolKey));
+    return [...this.fabricatedClaims].filter((n) => !invoked.has(toolKey(n)));
   }
   async dispatch(tc) {
     this.invokedTools.add(tc.function.name);
@@ -5089,6 +5155,11 @@ function lastAssistantText(messages) {
   }
   return "";
 }
+var TOOL_ALIASES = { bash: "shell" };
+function toolKey(name) {
+  const k = name.toLowerCase();
+  return TOOL_ALIASES[k] ?? k;
+}
 
 // src/index.ts
 init_NodeDiskFilesystem();
@@ -7772,6 +7843,8 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
       instructionFiles: false,
       maxSteps: 8,
       timeoutMs: 3e4,
+      failEmptyTurns: false,
+      // a silent reflex turn after a dispatch is legitimate — the voice layer repairs it
       ...o.reflexOptions,
       tools,
       // Composed AFTER the spread so the dispatch guard can't be dropped by reflexOptions.
@@ -14071,6 +14144,7 @@ function jsonResult(res, session) {
   return {
     ok: res.finishReason === "stop",
     finishReason: res.finishReason,
+    ...res.providerFinishReason ? { providerFinishReason: res.providerFinishReason } : {},
     text: res.text,
     steps: res.steps,
     tools: res.messages.slice(lastUser).filter((m) => m.role === "tool").length,
@@ -14078,7 +14152,7 @@ function jsonResult(res, session) {
     sessionId: session.meta.id,
     // The parked question, machine-readable — the caller answers it and resumes `sessionId`.
     ...res.finishReason === "needs_input" && res.question ? { question: res.question } : {},
-    ...res.finishReason === "error" && res.error ? { error: res.error?.message ?? String(res.error) } : {}
+    ...(res.finishReason === "error" || res.finishReason === "empty") && res.error ? { error: res.error?.message ?? String(res.error) } : {}
   };
 }
 async function readMultiline(readLine) {