@livx.cc/agentx 0.99.16 → 0.99.18

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { a as AgentOptions, H as Hooks, h as RunResult, A as Agent } from './Agent-CvLBalJE.js';
-export { C as ChatFragment, D as DEFAULT_MUTATING, b as Decision, P as PermissionOptions, c as PermissionPolicy, d as PermissionRule, e as PreToolUseDecision, R as ReasoningEffort, f as RecordingHooks, g as RecordingLifecycle, T as ToolUse, i as ToolUseMeta, j as composeHooks, p as planMode, r as reasoningToChatFragment } from './Agent-CvLBalJE.js';
+import { a as AgentOptions, H as Hooks, h as RunResult, A as Agent } from './Agent-Cn9BxS8h.js';
+export { C as ChatFragment, D as DEFAULT_MUTATING, b as Decision, P as PermissionOptions, c as PermissionPolicy, d as PermissionRule, e as PreToolUseDecision, R as ReasoningEffort, f as RecordingHooks, g as RecordingLifecycle, T as ToolUse, i as ToolUseMeta, j as composeHooks, p as planMode, r as reasoningToChatFragment } from './Agent-Cn9BxS8h.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

@@ -3181,6 +3181,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. */
@@ -3383,6 +3387,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;
@@ -3587,17 +3607,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 (err) {
+                throw stall.reclassify(err);
+              } 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;
@@ -3607,16 +3635,21 @@ var Agent = class _Agent {
             const sc = err?.statusCode;
             const serverSide = sc >= 500 || sc === 408 || /Service Unavailable|overloaded|Internal server error|Bad gateway|Gateway time/i.test(String(err?.message ?? ""));
             const network = !sc && /ECONNRESET|ECONNREFUSED|ETIMEDOUT|ENOTFOUND|EAI_AGAIN|EPIPE|socket hang up|fetch failed|network|terminated|UND_ERR/i.test(String(err?.message ?? err?.code ?? err));
-            const transient = !o.signal?.aborted && !isAbortError(err) && attempt < 2 && (network || serverSide);
+            const stalled = err?.code === "stall";
+            const transient = !o.signal?.aborted && !isAbortError(err) && attempt < 2 && (network || serverSide || stalled);
             if (!transient) throw err;
             const waitMs = 1e3 * (attempt + 1);
-            log4.warn(`network drop mid-step (${err?.message ?? err}) \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 (${err?.message ?? err}) \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 (err) {
         if (err?.code === "budget") return kill("budget");
+        if (err?.code === "stall") {
+          log4.warn(`model stalled out after retries: ${err?.message ?? err}`);
+          return kill("timeout");
+        }
         if (o.signal?.aborted || isAbortError(err)) return kill("aborted");
         const body = err?.body ?? err?.response?.data ?? err?.error;
         let bodyStr;
@@ -3687,12 +3720,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: (err) => {
+        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 err;
+      }
+    };
+  }
+  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) {