@livx.cc/agentx 0.99.16 → 0.99.18

package/dist/{Agent-CvLBalJE.d.ts → Agent-Cn9BxS8h.d.ts}

@@ -214,6 +214,10 @@ declare class AgentOptions {
     maxTokens: number;
     /** Wall-clock ceiling in ms for the whole run. 0 = unbounded. */
     timeoutMs: number;
+    /** Idle-stall watchdog for a SINGLE streamed model request: abort it if no chunk (text OR reasoning)
+     *  arrives for this long. The between-steps `timeoutMs` can't preempt an in-flight `chat()`, so a
+     *  provider that goes silent mid-stream would otherwise park the loop forever. 0 = off. */
+    stallMs: number;
     /** Stop if the identical tool-call batch (name+args) repeats this many times in a row. 0 = off. */
     maxRepeats: number;
     /** Cumulative cap on tool calls dispatched across the run. 0 = unbounded. */
@@ -381,6 +385,11 @@ declare class Agent {
     /** Drop any queued-but-unconsumed injections. The REPL calls this after a LOCAL command (/cmd, !bash)
      *  — which runs no send() to drain them — so a mid-command steer can't leak into the next real turn. */
     clearInjections(): void;
+    /** Pull queued injections that are plain TEXT, removing them, for a runtime that can accept mid-turn
+     *  steers over its own channel (claude-code's warm InputQueue via `providerOptions.steer`). Non-text
+     *  injections (images) stay queued for the step-boundary `drainInjections()` re-open — the text-only
+     *  steer channel can't carry them. Consumed DURING chat(); no overlap with drainInjections() (post-call). */
+    drainPendingSteers(): string[];
     /** Fold any host-injected messages into the transcript as user turns. Returns true if any landed. */
     private drainInjections;
     constructor(options?: Partial<AgentOptions>);
@@ -431,6 +440,14 @@ declare class Agent {
      * (`{kind:'text_delta'}`) and fold all chunks back into the single
      * ChatResponse the non-stream path would have returned.
      */
+    /**
+     * Idle-stall watchdog for one streamed model request. Returns a linked AbortController `signal` to
+     * hand to `chat()`, a `poke()` to reset the idle timer on each chunk, a `reclassify()` that turns a
+     * watchdog-fired abort into an Error{code:'stall'} (leaving a parent/user abort untouched), and a
+     * `clear()` to disarm. Aborts the request if no `poke()` (or completion) happens within `stallMs`.
+     * `stallMs = 0` disables the timer but still links parent-abort → child so cancellation propagates.
+     */
+    private armStallWatchdog;
     private consumeStream;
     private dispatch;
     private static readonly WRITE_CLASS;

package/dist/cli.d.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
-import { H as Hooks, h as RunResult, R as ReasoningEffort, A as Agent } from './Agent-CvLBalJE.js';
+import { H as Hooks, h as RunResult, R as ReasoningEffort, A as Agent } from './Agent-Cn9BxS8h.js';
 import { IFilesystem } from '@livx.cc/wcli/core';
 import { M as Message, H as HostBridge, c as ContentPart, e as MessageContent } from './tools-DKf3hN4M.js';
 

package/dist/cli.js

@@ -3219,6 +3219,10 @@ var AgentOptions = class {
   maxTokens = 2e5;
   /** Wall-clock ceiling in ms for the whole run. 0 = unbounded. */
   timeoutMs = 12e4;
+  /** Idle-stall watchdog for a SINGLE streamed model request: abort it if no chunk (text OR reasoning)
+   *  arrives for this long. The between-steps `timeoutMs` can't preempt an in-flight `chat()`, so a
+   *  provider that goes silent mid-stream would otherwise park the loop forever. 0 = off. */
+  stallMs = 6e4;
   /** Stop if the identical tool-call batch (name+args) repeats this many times in a row. 0 = off. */
   maxRepeats = 3;
   /** Cumulative cap on tool calls dispatched across the run. 0 = unbounded. */
@@ -3421,6 +3425,22 @@ var Agent = class _Agent {
   clearInjections() {
     this.pendingInjections.length = 0;
   }
+  /** Pull queued injections that are plain TEXT, removing them, for a runtime that can accept mid-turn
+   *  steers over its own channel (claude-code's warm InputQueue via `providerOptions.steer`). Non-text
+   *  injections (images) stay queued for the step-boundary `drainInjections()` re-open — the text-only
+   *  steer channel can't carry them. Consumed DURING chat(); no overlap with drainInjections() (post-call). */
+  drainPendingSteers() {
+    if (!this.pendingInjections.length) return [];
+    const texts = [];
+    this.pendingInjections = this.pendingInjections.filter((c) => {
+      if (typeof c === "string") {
+        texts.push(c);
+        return false;
+      }
+      return true;
+    });
+    return texts;
+  }
   /** Fold any host-injected messages into the transcript as user turns. Returns true if any landed. */
   drainInjections() {
     if (!this.pendingInjections.length) return false;
@@ -3625,17 +3645,25 @@ var Agent = class _Agent {
           return typeof raw === "string" ? raw : raw.text;
         }
       } : void 0;
+      const claudeSteerPo = o.model.startsWith("claude-code/") ? { steer: () => this.drainPendingSteers() } : void 0;
       const reasonOpts = {
         ...frag,
         ...o.promptCache ? { promptCache: true } : {},
-        ...o.providerOptions || cursorPo ? { providerOptions: { ...frag.providerOptions, ...o.providerOptions, ...cursorPo } } : {}
+        ...o.providerOptions || cursorPo || claudeSteerPo ? { providerOptions: { ...frag.providerOptions, ...o.providerOptions, ...cursorPo, ...claudeSteerPo } } : {}
       };
       try {
         for (let attempt = 0; ; attempt++) {
           try {
             if (useStream) {
-              const r = await o.ai.chat({ model: o.model, messages: sent, tools: sentTools, stream: true, signal: o.signal, ...o.toolChoice ? { toolChoice: o.toolChoice } : {}, ...reasonOpts });
-              res = await this.consumeStream(r);
+              const stall = this.armStallWatchdog(o.signal, o.stallMs);
+              try {
+                const r = await o.ai.chat({ model: o.model, messages: sent, tools: sentTools, stream: true, signal: stall.signal, ...o.toolChoice ? { toolChoice: o.toolChoice } : {}, ...reasonOpts });
+                res = await this.consumeStream(r, stall.poke);
+              } catch (err2) {
+                throw stall.reclassify(err2);
+              } finally {
+                stall.clear();
+              }
             } else {
               const r = await o.ai.chat({ model: o.model, messages: sent, tools: sentTools, stream: false, signal: o.signal, ...o.toolChoice ? { toolChoice: o.toolChoice } : {}, ...reasonOpts });
               res = r;
@@ -3645,16 +3673,21 @@ var Agent = class _Agent {
             const sc = err2?.statusCode;
             const serverSide = sc >= 500 || sc === 408 || /Service Unavailable|overloaded|Internal server error|Bad gateway|Gateway time/i.test(String(err2?.message ?? ""));
             const network = !sc && /ECONNRESET|ECONNREFUSED|ETIMEDOUT|ENOTFOUND|EAI_AGAIN|EPIPE|socket hang up|fetch failed|network|terminated|UND_ERR/i.test(String(err2?.message ?? err2?.code ?? err2));
-            const transient = !o.signal?.aborted && !isAbortError(err2) && attempt < 2 && (network || serverSide);
+            const stalled = err2?.code === "stall";
+            const transient = !o.signal?.aborted && !isAbortError(err2) && attempt < 2 && (network || serverSide || stalled);
             if (!transient) throw err2;
             const waitMs = 1e3 * (attempt + 1);
-            log4.warn(`network drop mid-step (${err2?.message ?? err2}) \u2014 retrying in ${waitMs}ms`);
-            o.host?.notify?.({ kind: "retry", message: `connection dropped \u2014 retrying step (#${attempt + 1})` });
+            log4.warn(`${stalled ? "model stall" : "network drop"} mid-step (${err2?.message ?? err2}) \u2014 retrying in ${waitMs}ms`);
+            o.host?.notify?.({ kind: "retry", message: `${stalled ? "model stalled" : "connection dropped"} \u2014 retrying step (#${attempt + 1})` });
             await new Promise((r) => setTimeout(r, waitMs));
           }
         }
       } catch (err2) {
         if (err2?.code === "budget") return kill("budget");
+        if (err2?.code === "stall") {
+          log4.warn(`model stalled out after retries: ${err2?.message ?? err2}`);
+          return kill("timeout");
+        }
         if (o.signal?.aborted || isAbortError(err2)) return kill("aborted");
         const body = err2?.body ?? err2?.response?.data ?? err2?.error;
         let bodyStr;
@@ -3725,12 +3758,54 @@ var Agent = class _Agent {
    * (`{kind:'text_delta'}`) and fold all chunks back into the single
    * ChatResponse the non-stream path would have returned.
    */
-  async consumeStream(stream) {
+  /**
+   * Idle-stall watchdog for one streamed model request. Returns a linked AbortController `signal` to
+   * hand to `chat()`, a `poke()` to reset the idle timer on each chunk, a `reclassify()` that turns a
+   * watchdog-fired abort into an Error{code:'stall'} (leaving a parent/user abort untouched), and a
+   * `clear()` to disarm. Aborts the request if no `poke()` (or completion) happens within `stallMs`.
+   * `stallMs = 0` disables the timer but still links parent-abort → child so cancellation propagates.
+   */
+  armStallWatchdog(parent, stallMs) {
+    const ac = new AbortController();
+    let fired = false;
+    const onParentAbort = () => ac.abort();
+    if (parent?.aborted) ac.abort();
+    else parent?.addEventListener("abort", onParentAbort, { once: true });
+    let timer;
+    const poke = () => {
+      if (!stallMs) return;
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(() => {
+        fired = true;
+        ac.abort();
+      }, stallMs);
+    };
+    poke();
+    return {
+      signal: ac.signal,
+      poke,
+      clear: () => {
+        if (timer) clearTimeout(timer);
+        parent?.removeEventListener("abort", onParentAbort);
+      },
+      // Distinguish OUR abort (silent provider) from a parent/user cancel, which must stay an abort.
+      reclassify: (err2) => {
+        if (fired && !parent?.aborted) {
+          const e = new Error(`model stalled: no stream output for ${stallMs >= 1e3 ? `${Math.round(stallMs / 1e3)}s` : `${stallMs}ms`}`);
+          e.code = "stall";
+          return e;
+        }
+        return err2;
+      }
+    };
+  }
+  async consumeStream(stream, poke) {
     let content = "";
     let finishReason;
     let toolCalls;
     let usage;
     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.toolActivity) {