@livx.cc/agentx 0.99.44 → 0.99.46

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

@@ -1,5 +1,5 @@
 import { IFilesystem } from '@livx.cc/wcli/core';
-import { M as Message, H as HostBridge, A as AgentTool, C as ChatLike, g as MessageContent, U as UserQuestion } from './tools-S-ArIR3o.js';
+import { M as Message, H as HostBridge, A as AgentTool, C as ChatLike, g as MessageContent, U as UserQuestion } from './tools-BqL8Lk4J.js';
 
 /**
  * Hooks — deterministic interception points around tool execution, run by the
@@ -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,14 @@ 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;
+    /** 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?;

package/dist/cli.d.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
-import { H as Hooks, i as RunResult, R as ReasoningEffort, A as Agent } from './Agent-f4um2q8E.js';
+import { H as Hooks, i as RunResult, R as ReasoningEffort, A as Agent } from './Agent-OcAg2yxA.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-S-ArIR3o.js';
+import { M as Message, U as UserQuestion, H as HostBridge, c as ContentPart, g as MessageContent } from './tools-BqL8Lk4J.js';
 
 /**
  * On-disk session store for the CLI: each conversation is one JSON file at
@@ -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

@@ -23,6 +23,9 @@ var init_logging = __esm({
 import { readFileSync, statSync as statSync2, realpathSync } from "fs";
 import { resolve, sep } from "path";
 import { randomBytes } from "crypto";
+function passesBackReasoning(model) {
+  return !!model && /^(deepseek|moonshot)\//.test(model);
+}
 function contentText(content) {
   if (content == null) return "";
   if (typeof content === "string") return content;
@@ -203,7 +206,7 @@ function sendBytes(messages, keepRecent = 1, stub = IMAGE_ELIDE_STUB) {
 }
 function sendBytesPer(messages, keepRecent = 1, stub = IMAGE_ELIDE_STUB) {
   const keep = messages.some(bearsImage) ? imageWindows(messages, keepRecent) : null;
-  return messages.map((m, i) => wireBytes(m.content, keep == null || keep.has(i), stub) + (m.tool_calls ? JSON.stringify(m.tool_calls).length : 0));
+  return messages.map((m, i) => wireBytes(m.content, keep == null || keep.has(i), stub) + (m.tool_calls ? JSON.stringify(m.tool_calls).length : 0) + (m.reasoning_content?.length ?? 0));
 }
 function wireBytes(content, kept, stub) {
   const tool = toolImageRef(content);
@@ -3958,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). */
@@ -4031,6 +4038,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;
@@ -4333,6 +4348,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) => {
@@ -4341,12 +4357,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;
@@ -4367,7 +4384,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;
@@ -4482,14 +4506,28 @@ var Agent = class _Agent {
         this.transcript.push({
           role: "assistant",
           content: res.content ?? "",
-          ...toolCalls.length ? { tool_calls: toolCalls } : {}
+          ...toolCalls.length ? { tool_calls: toolCalls } : {},
+          ...res.reasoningContent && passesBackReasoning(o.model) ? { reasoning_content: res.reasoningContent } : {}
         });
       }
       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({
@@ -4498,7 +4536,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({
@@ -4512,7 +4550,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;
@@ -4576,10 +4614,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 {
@@ -4588,6 +4628,7 @@ 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
@@ -4608,10 +4649,14 @@ var Agent = class _Agent {
     const delegatedOrder = [];
     let sawTool = false;
     let trailing = "";
+    let reasoning = "";
     for await (const chunk of stream) {
       poke?.();
       if (this.options.signal?.aborted) break;
-      if (chunk.reasoningContent) this.options.host.notify({ kind: "thinking_delta", message: chunk.reasoningContent });
+      if (chunk.reasoningContent) {
+        reasoning += chunk.reasoningContent;
+        this.options.host.notify({ kind: "thinking_delta", message: chunk.reasoningContent });
+      }
       if (chunk.toolActivity) {
         const a = chunk.toolActivity;
         const verb = a.status === "error" ? "\u2717" : a.status === "completed" ? "\u2713" : "\u2192";
@@ -4642,7 +4687,7 @@ var Agent = class _Agent {
     }
     const delegatedTools = delegatedOrder.map((k) => delegated.get(k));
     const endedWithoutClosing = sawTool && (!trailing.trim() || endsOnAnnouncedAction(trailing));
-    return { content, ...finishReason ? { finishReason } : {}, ...toolCalls ? { toolCalls } : {}, ...usage ? { usage } : {}, ...delegatedTools.length ? { delegatedTools } : {}, ...endedWithoutClosing ? { endedWithoutClosing: true } : {} };
+    return { content, ...reasoning ? { reasoningContent: reasoning } : {}, ...finishReason ? { finishReason } : {}, ...toolCalls ? { toolCalls } : {}, ...usage ? { usage } : {}, ...delegatedTools.length ? { delegatedTools } : {}, ...endedWithoutClosing ? { endedWithoutClosing: true } : {} };
   }
   /**
    * FABRICATED TOOL USE — the failure no call-reactive layer can see, because there IS no call.
@@ -4679,8 +4724,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);
@@ -4693,7 +4739,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);
@@ -5081,6 +5128,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();
@@ -7764,6 +7816,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.
@@ -14063,6 +14117,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,
@@ -14070,7 +14125,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) {