@livx.cc/agentx 0.99.46 → 0.99.47

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { a as AgentOptions, H as Hooks, i as RunResult, A as Agent } from './Agent-OcAg2yxA.js';
-export { C as ChatFragment, b as CompactResult, D as DEFAULT_MUTATING, c as Decision, P as PermissionOptions, d as PermissionPolicy, e as PermissionRule, f as PreToolUseDecision, R as ReasoningEffort, g as RecordingHooks, h as RecordingLifecycle, T as ToolUse, j as ToolUseMeta, k as composeHooks, l as estimateTokens, p as planMode, r as reasoningToChatFragment } from './Agent-OcAg2yxA.js';
+import { a as AgentOptions, H as Hooks, i as RunResult, A as Agent } from './Agent-BWbQ4Sqp.js';
+export { C as ChatFragment, b as CompactResult, D as DEFAULT_MUTATING, c as Decision, P as PermissionOptions, d as PermissionPolicy, e as PermissionRule, f as PreToolUseDecision, R as ReasoningEffort, g as RecordingHooks, h as RecordingLifecycle, T as ToolUse, j as ToolUseMeta, k as composeHooks, l as estimateTokens, p as planMode, r as reasoningToChatFragment } from './Agent-BWbQ4Sqp.js';
 export { MODEL_ALIASES, ModelSwitch, ResolveModelSwitchOpts, modelShortLabel, resolveModelAlias, resolveModelSwitch } from './models.js';
 import { IFilesystem, FileMetadata } from '@livx.cc/wcli/core';
 export { CommandExecutor, FileMetadata, IFilesystem, IndexedDbFilesystem, MemFilesystem, registerHeadlessCommands } from '@livx.cc/wcli/core';

package/dist/index.js

@@ -4030,6 +4030,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. */
@@ -4360,6 +4368,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.`);
@@ -4376,6 +4385,7 @@ var Agent = class _Agent {
             return await this.dispatch(tc);
           } finally {
             this.hostToolsInFlight--;
+            this.toolRanThisAttempt = true;
             this.stallPoke?.();
           }
         }
@@ -4388,6 +4398,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);
@@ -4417,7 +4429,9 @@ var Agent = class _Agent {
             const stalled = err?.code === "stall";
             const empty = err?.code === "empty" || err?.code === "cursor_silent";
             const maxAttempts = empty ? Math.max(o.emptyRetries, 0) : 2;
-            const transient = !o.signal?.aborted && !isAbortError(err) && 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(err) && !replaysTool && attempt < maxAttempts && (network || serverSide || stalled || empty);
             if (!transient) throw err;
             const waitMs = (empty ? o.emptyRetryBaseMs : 1e3) * (attempt + 1);
             log6.warn(`${empty ? "empty model turn" : stalled ? "model stall" : "network drop"} mid-step (${err?.message ?? err}) \u2014 retrying in ${waitMs}ms`);
@@ -4600,7 +4614,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);
@@ -4620,6 +4634,13 @@ var Agent = class _Agent {
       reclassify: (err) => stalled() ? stallError() : err
     };
   }
+  /** A host or native delegated tool is running within its deadline — the provider is quiet, not stalled. */
+  toolHoldActive() {
+    const now3 = Date.now();
+    if (this.hostToolsInFlight > 0 && now3 < this.hostToolHoldUntil) return true;
+    for (const until of this.nativeToolsInFlight.values()) if (now3 < 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) {
@@ -4658,6 +4679,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 = "";