@livx.cc/agentx 0.99.45 → 0.99.46

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { a as AgentOptions, H as Hooks, i as RunResult, A as Agent } from './Agent-Bzs57-iD.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-Bzs57-iD.js';
+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';
 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

@@ -3947,6 +3947,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). */
@@ -4020,6 +4024,14 @@ 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;
+  /** 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;
@@ -4322,6 +4334,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) => {
@@ -4330,12 +4343,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;
@@ -4356,7 +4370,14 @@ 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.stallPoke?.();
+          }
         }
       } : void 0;
       const claudeSteerPo = o.model.startsWith("claude-code/") ? { steer: () => this.drainPendingSteers() } : void 0;
@@ -4477,9 +4498,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({
@@ -4488,7 +4522,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({
@@ -4502,7 +4536,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;
@@ -4566,10 +4600,12 @@ var Agent = class _Agent {
       if (!stallMs) return;
       if (timer) clearTimeout(timer);
       timer = setTimeout(() => {
+        if (this.hostToolsInFlight > 0 && Date.now() < this.hostToolHoldUntil) return poke();
         fired = true;
         ac.abort(stallError());
       }, stallMs);
     };
+    this.stallPoke = poke;
     poke();
     const stalled = () => fired && !parent?.aborted;
     return {
@@ -4578,6 +4614,7 @@ var Agent = class _Agent {
       stalled,
       clear: () => {
         if (timer) clearTimeout(timer);
+        if (this.stallPoke === poke) this.stallPoke = void 0;
         parent?.removeEventListener("abort", onParentAbort);
       },
       reclassify: (err) => stalled() ? stallError() : err
@@ -4673,8 +4710,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);
@@ -4687,7 +4725,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);
@@ -5075,6 +5114,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();
@@ -7843,6 +7887,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.