open-agents-ai 0.103.83 → 0.103.85

package/dist/index.js

@@ -4713,6 +4713,24 @@ Process error: ${err.message}`;
         entry.finishedAt = Date.now();
         return true;
       }
+      /** Kill ALL running tasks immediately (for /stop and /quit authority) */
+      stopAll() {
+        let killed = 0;
+        for (const [, entry] of this.tasks) {
+          if (entry.status !== "running")
+            continue;
+          if (entry.child) {
+            try {
+              entry.child.kill("SIGKILL");
+            } catch {
+            }
+          }
+          entry.status = "stopped";
+          entry.finishedAt = Date.now();
+          killed++;
+        }
+        return killed;
+      }
       list() {
         return Array.from(this.tasks.values()).map(toInfo);
       }
@@ -12442,8 +12460,8 @@ async function handleCmd(cmd) {
           // succeeds in <1s. Racing them eliminates the wait.
           dlog('remote_infer: invoking ' + riCapName + ' on peer ' + riTargetPeer.slice(0, 20) + ' (libp2p' + (_natsConn ? ' + NATS parallel' : '') + ')');
           try {
-            var RI_TIMEOUT = 300000;
-            var riInvokeP = nexus.invokeCapability(riTargetPeer, riCapName, riData, { stream: false, maxDurationMs: 240000 });
+            var RI_TIMEOUT = 60000;  // 60s outer timeout \u2014 fail fast for interactive use
+            var riInvokeP = nexus.invokeCapability(riTargetPeer, riCapName, riData, { stream: false, maxDurationMs: 45000 });
             var riTimeoutP = new Promise(function(_, reject) { setTimeout(function() { reject(new Error('remote_infer timed out after ' + (RI_TIMEOUT / 1000) + 's')); }, RI_TIMEOUT); });
 
             // Build race candidates \u2014 libp2p + timeout always present
@@ -12454,7 +12472,7 @@ async function handleCmd(cmd) {
               var _riNatsRaceP = (async function() {
                 var _rSubject = 'nexus.invoke.' + riTargetPeer;
                 var _rPayload = JSON.stringify({ capability: riCapName, input: riData, from: nexus.peerId || '' });
-                var _rResp = await _natsConn.request(_rSubject, _natsCodec.encode(_rPayload), { timeout: 240000 });
+                var _rResp = await _natsConn.request(_rSubject, _natsCodec.encode(_rPayload), { timeout: 45000 });
                 var _rResult = JSON.parse(_natsCodec.decode(_rResp.data));
                 if (_rResult && _rResult.error) throw new Error('NATS: ' + _rResult.error);
                 dlog('remote_infer: NATS won the race');
@@ -12493,8 +12511,8 @@ async function handleCmd(cmd) {
               var rPid = riCandidates[ri];
               dlog('remote_infer: trying peer ' + rPid.slice(0, 20) + '...');
               try {
-                var PEER_INVOKE_TIMEOUT = 180000; // 3 min per peer \u2014 remote API inference can be slow
-                var specInvoke = nexus.invokeCapability(rPid, riCapName, riData, { stream: false, maxDurationMs: 150000 });
+                var PEER_INVOKE_TIMEOUT = 30000;  // 30s per peer in discovery \u2014 fail fast, try next
+                var specInvoke = nexus.invokeCapability(rPid, riCapName, riData, { stream: false, maxDurationMs: 25000 });
                 var specTimeout = new Promise(function(_, reject) {
                   setTimeout(function() { reject(new Error('peer invoke timeout')); }, PEER_INVOKE_TIMEOUT);
                 });
@@ -12523,7 +12541,7 @@ async function handleCmd(cmd) {
                   try {
                     var _dpSubject = 'nexus.invoke.' + _dpPid;
                     var _dpPayload = JSON.stringify({ capability: riCapName, input: riData, from: nexus.peerId || '' });
-                    var _dpResp = await _natsConn.request(_dpSubject, _natsCodec.encode(_dpPayload), { timeout: 180000 });
+                    var _dpResp = await _natsConn.request(_dpSubject, _natsCodec.encode(_dpPayload), { timeout: 30000 });
                     var _dpResult = JSON.parse(_natsCodec.decode(_dpResp.data));
                     if (_dpResult && !_dpResult.error) {
                       riResult = _dpResult;
@@ -18848,6 +18866,13 @@ ${this.options.dynamicContext}`,
       injectUserMessage(content) {
         this.pendingUserMessages.push(content);
       }
+      /** Retract the last pending user message (Esc cancel).
+       *  Returns the retracted text, or null if queue is empty or already consumed. */
+      retractLastPendingMessage() {
+        if (this.pendingUserMessages.length === 0)
+          return null;
+        return this.pendingUserMessages.pop();
+      }
       /** Abort the current task run — cancels in-flight requests and kills child processes */
       abort() {
         this.aborted = true;
@@ -19126,6 +19151,10 @@ If you're stuck, try a completely different approach. Do NOT repeat what failed
           try {
             response = this.options.streamEnabled && this.hasStreamingSupport() ? await this.streamingRequest(chatRequest, turn) : await this.backend.chatCompletion(chatRequest);
           } catch (reqErr) {
+            if (reqErr instanceof Error && reqErr.fatal) {
+              this.emit({ type: "error", content: `Backend error: ${reqErr.message}`, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+              break;
+            }
             const recovered = await this.retryOnTransient(reqErr, chatRequest, turn);
             if (!recovered) {
               const errMsg = reqErr instanceof Error ? reqErr.message : String(reqErr);
@@ -20886,6 +20915,8 @@ ${transcript}`
       // -------------------------------------------------------------------------
       /** Detect whether an error is transient (worth retrying) */
       isTransientError(err) {
+        if (err instanceof Error && err.fatal)
+          return false;
         const msg = err instanceof Error ? err.message : String(err);
         if (/Backend HTTP (502|503|504)/i.test(msg))
           return true;
@@ -20895,6 +20926,10 @@ ${transcript}`
           return true;
         if (/model is loading|server busy|overloaded/i.test(msg))
           return true;
+        if (/multiaddrs failed|all multiaddrs failed|dial to peer failed|stream was reset|Cannot reach peer/i.test(msg))
+          return true;
+        if (/NATS.*timeout|relay.*timeout|invoke.*timeout/i.test(msg))
+          return true;
         return false;
       }
       /**
@@ -21222,6 +21257,15 @@ var init_nexusBackend = __esm({
         this.authKey = authKey || "";
         this.thinking = thinking ?? true;
       }
+      /** Reset the consecutive failure counter (called on endpoint switch / reconnect) */
+      resetFailures() {
+        this.consecutiveFailures = 0;
+      }
+      /** Update target peer (allows switching peers without recreating the backend) */
+      setTargetPeer(peerId) {
+        this.targetPeer = peerId;
+        this.consecutiveFailures = 0;
+      }
       async chatCompletion(request) {
         if (this.consecutiveFailures >= _NexusAgenticBackend.MAX_CONSECUTIVE_FAILURES) {
           const err = new Error(`Remote peer unreachable after ${this.consecutiveFailures} attempts. Use /endpoint to switch to a local model or reconnect.`);
@@ -21258,7 +21302,10 @@ var init_nexusBackend = __esm({
         }
         if (parsed.success === false) {
           this.consecutiveFailures++;
-          throw new Error(`Remote inference failed: ${parsed.output || rawResult}`);
+          const output = String(parsed.output || rawResult);
+          const isDialErr = /multiaddrs failed|Cannot reach peer|dial to peer|timeout|ECONNREFUSED/i.test(output);
+          const hint = isDialErr ? ` (${this.consecutiveFailures}/${_NexusAgenticBackend.MAX_CONSECUTIVE_FAILURES} failures \u2014 will stop after ${_NexusAgenticBackend.MAX_CONSECUTIVE_FAILURES})` : "";
+          throw new Error(`Remote inference failed: ${output}${hint}`);
         }
         this.consecutiveFailures = 0;
         const invokeResult = parsed.result;
@@ -45592,8 +45639,11 @@ var init_status_bar = __esm({
       active = false;
       scrollRegionTop = 1;
       stdinHooked = false;
-      /** Track previous terminal rows to clear ghost separators on resize */
+      /** Track previous terminal dimensions to clear ghost separators on resize */
       _prevTermRows = 0;
+      _prevTermCols = 0;
+      /** Debounce timer for resize events — prevents separator stacking during drag */
+      _resizeTimer = null;
       /**
        * Depth-counted content write guard.  Incremented by beginContentWrite(),
        * decremented by endContentWrite().  Footer is only redrawn and cursor
@@ -46040,6 +46090,7 @@ var init_status_bar = __esm({
         this.scrollRegionTop = scrollRegionTop ?? 1;
         this.active = true;
         this._prevTermRows = process.stdout.rows ?? 24;
+        this._prevTermCols = process.stdout.columns ?? 80;
         this.applyScrollRegion();
         this.renderFooterAndPositionInput();
         this.hookStdin();
@@ -46077,24 +46128,42 @@ var init_status_bar = __esm({
       get reservedRows() {
         return this._currentFooterHeight;
       }
-      /** Handle terminal resize — reapply scroll region and redraw footer */
+      /** Handle terminal resize — debounced to prevent separator stacking during drag */
       handleResize() {
         if (!this.active)
           return;
+        if (this._resizeTimer)
+          clearTimeout(this._resizeTimer);
+        this._resizeTimer = setTimeout(() => {
+          this._resizeTimer = null;
+          this._handleResizeImmediate();
+        }, 50);
+      }
+      /** Actual resize handler — called after debounce settles */
+      _handleResizeImmediate() {
+        if (!this.active)
+          return;
+        const prevRows = this._prevTermRows;
+        const prevCols = this._prevTermCols;
         this.updateFooterHeight();
         const rows = process.stdout.rows ?? 24;
-        const prevRows = this._prevTermRows;
+        const cols = process.stdout.columns ?? 80;
         this._prevTermRows = rows;
+        this._prevTermCols = cols;
         const pos = this.rowPositions(rows);
         const w = getTermWidth();
         const sep = c2.dim("\u2500".repeat(w));
-        let clearGhosts = "";
-        if (prevRows > 0 && rows < prevRows) {
-          clearGhosts = "\x1B[1;" + rows + `r\x1B[${pos.bufferRow};1H\x1B[J`;
+        let clearBuf = "";
+        if (prevRows > 0 && (rows !== prevRows || cols !== prevCols)) {
+          const wrapFactor = cols > 0 ? Math.ceil(prevCols / cols) : 1;
+          const extraWrappedRows = Math.max(0, (wrapFactor - 1) * 3);
+          const safetyMargin = extraWrappedRows + 2;
+          const clearFrom = Math.max(1, pos.bufferRow - safetyMargin);
+          clearBuf = "\x1B[1;" + rows + `r\x1B[${clearFrom};1H\x1B[J`;
         }
         if (this.writeDepth > 0) {
           const inputWrap = this.wrapInput(w);
-          let buf = clearGhosts + `\x1B[${this.scrollRegionTop};${pos.scrollEnd}r\x1B[?25l\x1B[?7l\x1B[${pos.bufferRow};1H\x1B[2K${this.buildBufferContent(w)}\x1B[${pos.topSepRow};1H\x1B[2K${sep}`;
+          let buf = clearBuf + `\x1B[${this.scrollRegionTop};${pos.scrollEnd}r\x1B[?25l\x1B[?7l\x1B[${pos.bufferRow};1H\x1B[2K${this.buildBufferContent(w)}\x1B[${pos.topSepRow};1H\x1B[2K${sep}`;
           for (let i = 0; i < inputWrap.lines.length; i++) {
             const row = pos.inputStartRow + i;
             const prefix = i === 0 ? this.promptText : " ".repeat(this.promptWidth);
@@ -46103,8 +46172,8 @@ var init_status_bar = __esm({
           buf += `\x1B[${pos.bottomSepRow};1H\x1B[2K${sep}\x1B[${pos.metricsRow};1H\x1B[2K${this.buildMetricsLine()}\x1B[?7h\x1B[${pos.scrollEnd};1H`;
           process.stdout.write(buf);
         } else {
-          if (clearGhosts)
-            process.stdout.write(clearGhosts);
+          if (clearBuf)
+            process.stdout.write(clearBuf);
           this.applyScrollRegion();
           this.renderFooterAndPositionInput();
         }
@@ -47956,8 +48025,9 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
   let currentTaskType;
   let sessionFilesTouched = [];
   let sessionToolCallCount = 0;
+  let lastSteeringInput = "";
+  let lastSteeringRetracted = false;
   let restoredSessionContext = null;
-  let pendingSessionRestore = false;
   let sessionSudoPassword = null;
   let sudoPromptPending = false;
   const idlePrompt = `${c2.bold(c2.white("\u276F "))}`;
@@ -49217,7 +49287,8 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
       if (!activeTask)
         return false;
       activeTask.runner.abort();
-      writeContent(() => renderInfo("Task aborted."));
+      const bgKilled = taskManager.stopAll();
+      writeContent(() => renderInfo(`Task aborted.${bgKilled > 0 ? ` ${bgKilled} background task(s) killed.` : ""}`));
       return true;
     },
     pauseTask() {
@@ -49309,28 +49380,40 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
       const lastTime = lastEntry.savedAt ? new Date(lastEntry.savedAt) : null;
       const timeAgo = lastTime ? formatTimeAgo(lastTime) : "unknown";
       const lastTask = lastEntry.task?.slice(0, 80) || "unknown";
-      setTimeout(() => {
+      setTimeout(async () => {
         writeContent(() => {
           renderInfo(`Previous session found (${savedCtx.entries.length} entries, last active ${timeAgo})`);
           renderInfo(`Last task: ${lastTask}${lastEntry.task && lastEntry.task.length > 80 ? "..." : ""}`);
-          renderInfo(`Restore previous context? (y/n) [auto-restores in 15s]`);
         });
-        showPrompt();
-        pendingSessionRestore = true;
-        setTimeout(() => {
-          if (pendingSessionRestore) {
-            pendingSessionRestore = false;
-            const prompt = buildContextRestorePrompt(repoRoot);
-            if (prompt) {
-              restoredSessionContext = prompt;
-              const info = loadSessionContext(repoRoot);
-              writeContent(() => renderInfo(`Context auto-restored from ${info?.entries.length ?? 0} session(s).`));
-            } else {
-              writeContent(() => renderInfo("No context to restore. Starting fresh."));
-            }
-            showPrompt();
-          }
+        let autoRestoreTimer = setTimeout(() => {
+          autoRestoreTimer = null;
         }, 15e3);
+        const result = await tuiSelect({
+          items: [
+            { key: "restore", label: "Restore previous context" },
+            { key: "fresh", label: "Start fresh" }
+          ],
+          activeKey: "restore",
+          title: "Restore previous session context?",
+          rl
+        });
+        if (autoRestoreTimer)
+          clearTimeout(autoRestoreTimer);
+        if (result.confirmed && result.key === "restore" || !result.confirmed && !autoRestoreTimer) {
+          const prompt = buildContextRestorePrompt(repoRoot);
+          if (prompt) {
+            restoredSessionContext = prompt;
+            const info = loadSessionContext(repoRoot);
+            writeContent(() => renderInfo(`Context restored from ${info?.entries.length ?? 0} session(s).`));
+          } else {
+            writeContent(() => renderInfo("No context to restore. Starting fresh."));
+          }
+        } else if (result.confirmed && result.key === "fresh") {
+          writeContent(() => renderInfo("Starting fresh."));
+        } else {
+          writeContent(() => renderInfo("Starting fresh."));
+        }
+        showPrompt();
       }, 150);
     }
   }
@@ -49453,22 +49536,6 @@ ${result.content.slice(0, 2e3)}${result.content.length > 2e3 ? "\n[truncated]" :
   rl.on("line", (line) => {
     persistHistoryLine(line);
     const input = line.trim();
-    if (pendingSessionRestore) {
-      pendingSessionRestore = false;
-      const answer = input.toLowerCase();
-      if (answer === "y" || answer === "yes") {
-        const prompt = buildContextRestorePrompt(repoRoot);
-        if (prompt) {
-          restoredSessionContext = prompt;
-          const info = loadSessionContext(repoRoot);
-          writeContent(() => renderInfo(`Context restored from ${info?.entries.length ?? 0} session(s). Will be injected into your next task.`));
-        }
-      } else {
-        writeContent(() => renderInfo("Starting fresh."));
-      }
-      showPrompt();
-      return;
-    }
     if (!input) {
       if (pasteBuffer.length > 0) {
         flushPasteBuffer();
@@ -49523,6 +49590,7 @@ ${result.content.slice(0, 2e3)}${result.content.length > 2e3 ? "\n[truncated]" :
         if (activeTask) {
           activeTask.runner.abort();
         }
+        taskManager.stopAll();
         if (blessEngine?.isActive)
           blessEngine.stop();
         if (telegramBridge?.isActive)
@@ -49592,6 +49660,10 @@ Execute this skill now. Follow the behavioral guidance above.`;
     const isImage = isImagePath(cleanPath) && existsSync40(resolve28(repoRoot, cleanPath));
     const isMedia = !isImage && isTranscribablePath(cleanPath) && existsSync40(resolve28(repoRoot, cleanPath));
     if (activeTask) {
+      if (activeTask.runner.isPaused) {
+        activeTask.runner.resume();
+        statusBar.setProcessing(true);
+      }
       if (isImage) {
         try {
           const imgPath = resolve28(repoRoot, cleanPath);
@@ -49619,8 +49691,16 @@ ${result.text}`;
           writeContent(() => renderUserInterrupt(`[Media: ${cleanPath}]`));
         }
       } else {
+        const isReplacement = lastSteeringRetracted;
+        lastSteeringInput = input;
+        lastSteeringRetracted = false;
         const lineCount = input.split("\n").length;
-        if (lineCount > 1) {
+        if (isReplacement) {
+          const displayText2 = lineCount > 1 ? `[pasted ${lineCount} lines]` : input;
+          writeContent(() => process.stdout.write(`
+  ${c2.green("\u21BB")} ${c2.bold("Context replaced:")} ${displayText2}
+`));
+        } else if (lineCount > 1) {
           writeContent(() => renderUserInterrupt(`[pasted ${lineCount} lines]`));
         } else {
           writeContent(() => renderUserInterrupt(input));
@@ -49991,6 +50071,7 @@ ${c2.dim("(paste cancelled)")}
     }
     if (activeTask) {
       activeTask.runner.abort();
+      taskManager.stopAll();
       writeContent(() => renderTaskAborted());
     } else {
       writeContent(() => process.stdout.write(`
@@ -49999,6 +50080,42 @@ ${c2.dim("(Use /quit to exit)")}
     }
     showPrompt();
   });
+  if (process.stdin.isTTY) {
+    readline2.emitKeypressEvents(process.stdin, rl);
+    process.stdin.on("keypress", (_str, key) => {
+      if (!key)
+        return;
+      if (key.name === "escape" && activeTask) {
+        if (!activeTask.runner.isPaused) {
+          activeTask.runner.pause();
+          statusBar.setProcessing(false);
+        }
+        const retracted = activeTask.runner.retractLastPendingMessage();
+        if (retracted) {
+          lastSteeringInput = retracted;
+          lastSteeringRetracted = true;
+          writeContent(() => process.stdout.write(`  ${c2.yellow("\u23F8")} ${c2.dim("\x1B[9m" + retracted.slice(0, 120) + "\x1B[29m")} ${c2.dim("\u2190 retracted, edit below and press Enter")}
+`));
+          rl.line = retracted;
+          rl.cursor = retracted.length;
+          if (statusBar.isActive)
+            statusBar.renderFooterPreserveCursor?.();
+        } else if (lastSteeringInput) {
+          lastSteeringRetracted = true;
+          writeContent(() => process.stdout.write(`  ${c2.yellow("\u23F8")} ${c2.dim("\x1B[9m" + lastSteeringInput.slice(0, 120) + "\x1B[29m")} ${c2.dim("\u2190 already sent, re-type below to override")}
+`));
+          rl.line = lastSteeringInput;
+          rl.cursor = lastSteeringInput.length;
+          if (statusBar.isActive)
+            statusBar.renderFooterPreserveCursor?.();
+        } else {
+          writeContent(() => process.stdout.write(`  ${c2.yellow("\u23F8")} ${c2.dim("Paused. /resume to continue, /stop to kill.")}
+`));
+        }
+        showPrompt();
+      }
+    });
+  }
 }
 async function runWithTUI(task, config, repoPath) {
   const repoRoot = resolve28(repoPath ?? cwd());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.103.83",
+  "version": "0.103.85",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",