@livx.cc/agentx 0.99.17 → 0.99.19

package/dist/{Agent-BfQS-MfB.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. */
@@ -436,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-BfQS-MfB.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. */
@@ -3651,8 +3655,15 @@ var Agent = class _Agent {
         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;
@@ -3662,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;
@@ -3742,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) {
@@ -9836,11 +9894,15 @@ function lastToken(line) {
   const m = line.match(/(\S*)$/);
   return m ? m[1] : "";
 }
+function atLineStart(line, token) {
+  return line.slice(0, line.length - token.length).trim() === "";
+}
 function completeLine(line, ctx) {
   const token = lastToken(line);
-  if (token.startsWith("/") && line.trimStart() === token) {
+  if (token.startsWith("/")) {
+    const pool = atLineStart(line, token) ? ctx.commands : ctx.agentCommands ?? ctx.commands;
     const want = token.slice(1);
-    const hits = rank(ctx.commands.filter((c) => fuzzy(want, c)), want).map((c) => "/" + c);
+    const hits = rank(pool.filter((c) => fuzzy(want, c)), want).map((c) => "/" + c);
     return [hits, token];
   }
   if (line.startsWith("!") && line.length > 1 && ctx.bangHistory?.length) {
@@ -10426,6 +10488,14 @@ var EditorState = class _EditorState {
     for (const [ph, full] of this.pastes) if (out.includes(ph)) out = out.split(ph).join(full);
     return out;
   }
+  /**
+   * A `/cmd` the REPL will DISPATCH — i.e. the line's first word. A slash token elsewhere in the
+   * prompt is prose the model reads, so it completes like an `@path`: no accept-and-run, no
+   * exact-match row. Kept in sync with the REPL's whole-line `/` dispatch via `atLineStart`.
+   */
+  get runnable() {
+    return this.token.startsWith("/") && atLineStart(this.buf.slice(0, this.cursor), this.token);
+  }
   /** Recompute suggestions from the line up to the cursor. */
   refresh() {
     const r = this.suggest(this.buf.slice(0, this.cursor));
@@ -10433,7 +10503,7 @@ var EditorState = class _EditorState {
     this.token = r.token;
     this.describe = r.describe;
     const exact = r.hits.length === 1 && r.hits[0] === r.token;
-    this.menuOpen = r.hits.length > 0 && (!exact || r.token.startsWith("/"));
+    this.menuOpen = r.hits.length > 0 && (!exact || this.runnable);
     if (this.sel >= r.hits.length) this.sel = 0;
   }
   // ── Editor undo (Ctrl-_): snapshot before every mutation, pop to restore ──
@@ -10629,13 +10699,22 @@ var EditorState = class _EditorState {
     this.hits = [];
     this.sel = 0;
   }
-  /** Replace the trailing token with the highlighted hit; re-suggest (e.g. `@src/` opens its children). */
+  /**
+   * Replace the trailing token with the highlighted hit; re-suggest (e.g. `@src/` opens its children).
+   * A finished hit gets a trailing space so the next word is typed straight away (CC/shell parity).
+   * Two exceptions: a DIRECTORY hit (`@src/`) is a waypoint, not a word — a space there would end the
+   * mention mid-path; and an existing following space isn't doubled. A spaced dir rides the quoted
+   * form (`@"my dir/"`), so the `/` test must look past a trailing quote.
+   */
   accept() {
     if (!this.menuOpen || !this.hits.length) return false;
     const hit = this.hits[this.sel] ?? this.hits[0];
     const start = this.cursor - this.token.length;
-    this.buf = this.buf.slice(0, start) + hit + this.buf.slice(this.cursor);
-    this.cursor = start + hit.length;
+    const rest = this.buf.slice(this.cursor);
+    const isDir = hit.replace(/"$/, "").endsWith("/");
+    const pad = isDir || rest.startsWith(" ") ? "" : " ";
+    this.buf = this.buf.slice(0, start) + hit + pad + rest;
+    this.cursor = start + hit.length + pad.length;
     this.refresh();
     return true;
   }
@@ -10849,9 +10928,9 @@ function applyKey(s, key, str) {
     case "return":
     case "enter":
       if (s.menuOpen) {
-        const isCmd = s.token.startsWith("/");
+        const run = s.runnable;
         s.accept();
-        return isCmd ? "submit" : "none";
+        return run ? "submit" : "none";
       }
       if (s.buf.slice(0, s.cursor).endsWith("\\")) {
         s.backspace();
@@ -14693,10 +14772,11 @@ ${task}`;
       return null;
     }
   };
-  const commandNames = () => [...Object.keys(builtins).filter((k) => k !== "quit"), ...cmds.map((c) => c.name), ...skills.map((s) => s.name)];
+  const agentCommandNames = () => [...cmds.map((c) => c.name), ...skills.map((s) => s.name)];
+  const commandNames = () => [...Object.keys(builtins).filter((k) => k !== "quit"), ...agentCommandNames()];
   const describe = (hit) => hit.startsWith("/") ? builtins[hit.slice(1)]?.desc ?? cmds.find((c) => c.name === hit.slice(1))?.description ?? skills.find((s) => s.name === hit.slice(1))?.description : void 0;
   const suggest = (lineToCursor) => {
-    const [hits, token] = completeLine(lineToCursor, { commands: commandNames(), listDir, bangHistory: history });
+    const [hits, token] = completeLine(lineToCursor, { commands: commandNames(), agentCommands: agentCommandNames(), listDir, bangHistory: history });
     return { hits, token, describe };
   };
   const editor = createLineEditor(process.stderr);