@livx.cc/agentx 0.99.46 → 0.99.47

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

@@ -427,6 +427,14 @@ declare class Agent {
     /** 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. */
@@ -533,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-OcAg2yxA.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';
 

package/dist/cli.js

@@ -4044,6 +4044,14 @@ var Agent = class _Agent {
   /** 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. */
@@ -4374,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.`);
@@ -4390,6 +4399,7 @@ var Agent = class _Agent {
             return await this.dispatch(tc);
           } finally {
             this.hostToolsInFlight--;
+            this.toolRanThisAttempt = true;
             this.stallPoke?.();
           }
         }
@@ -4402,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);
@@ -4431,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`);
@@ -4614,7 +4628,7 @@ var Agent = class _Agent {
       if (!stallMs) return;
       if (timer) clearTimeout(timer);
       timer = setTimeout(() => {
-        if (this.hostToolsInFlight > 0 && Date.now() < this.hostToolHoldUntil) return poke();
+        if (this.toolHoldActive()) return poke();
         fired = true;
         ac.abort(stallError());
       }, stallMs);
@@ -4634,6 +4648,13 @@ var Agent = class _Agent {
       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) {
@@ -4672,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 = "";