open-agents-ai 0.187.373 → 0.187.375

package/dist/index.js

@@ -534479,7 +534479,14 @@ ${CONTENT_BG_SEQ}`);
             this.termWrite(`\x1B[${this.scrollRegionTop};${pos.scrollEnd}r`);
           } else {
             const absD = Math.abs(heightDelta);
-            this.termWrite(`\x1B[${this.scrollRegionTop};${pos.scrollEnd}r`);
+            const oldScrollEnd = Math.max(rows - oldFooterHeight, this.scrollRegionTop);
+            const newScrollEnd = pos.scrollEnd;
+            this.termWrite(`\x1B[${this.scrollRegionTop};${newScrollEnd}r`);
+            let wipeTransition = "";
+            for (let r2 = oldScrollEnd + 1; r2 <= newScrollEnd; r2++) {
+              wipeTransition += `\x1B[${r2};1H${CONTENT_BG_SEQ}\x1B[2K`;
+            }
+            if (wipeTransition) this.termWrite(wipeTransition);
             let scrollDown = `\x1B[${this.scrollRegionTop};1H`;
             for (let i2 = 0; i2 < absD; i2++) scrollDown += "\x1BM";
             this.termWrite(scrollDown);
@@ -558432,6 +558439,7 @@ var init_stream_renderer = __esm({
   "packages/cli/src/tui/stream-renderer.ts"() {
     "use strict";
     init_layout2();
+    init_text_selection();
     isTTY8 = process.stdout.isTTY ?? false;
     PASTEL = {
       key: 222,
@@ -558512,6 +558520,16 @@ var init_stream_renderer = __esm({
        */
       jsonBlobSize = 0;
       jsonBlobSuppressed = false;
+      /**
+       * Track cursor's current column on the bottom-of-scroll row during partial
+       * flushes so we can wrap when cumulative partials would exceed terminal
+       * width. Reset to 0 on \n, 5 when a new "  ⎿  " prefix line starts.
+       * Essential for the typing-effect: without this, successive partial
+       * writes pile up on the bottom row past the right edge and the user
+       * only sees proper placement once the stream ends and a full repaint
+       * runs. Tracked in VISIBLE chars (ANSI escapes stripped).
+       */
+      _cursorCol = 0;
       /** Called when a new model response starts streaming */
       onStreamStart() {
         this.lineBuffer = "";
@@ -558522,6 +558540,7 @@ var init_stream_renderer = __esm({
         this.inToolArgs = false;
         this.jsonBlobSize = 0;
         this.jsonBlobSuppressed = false;
+        this._cursorCol = 0;
         this.enabled = true;
         this.tokenCount = 0;
         this.startTime = Date.now();
@@ -558680,51 +558699,70 @@ var init_stream_renderer = __esm({
           }
         }
         const prefix = this.lineStarted ? "" : "  ⎿  ";
+        const maxW = Math.max(10, termCols() - 6);
         let rendered;
+        const emitWrapped = (text2, highlight, trailingNewline) => {
+          if (!text2) return;
+          if (this.lineStarted && this._cursorCol > 0) {
+            const remaining = maxW - this._cursorCol;
+            const firstChunkLen = Math.min(text2.length, Math.max(1, remaining));
+            if (remaining < 8 && text2.length > remaining) {
+              this.writeRaw("\n");
+              this.lineStarted = false;
+            } else if (text2.length > remaining) {
+              const head = text2.slice(0, firstChunkLen).replace(/\s+$/, "");
+              const tail = text2.slice(firstChunkLen).replace(/^\s+/, "");
+              this.writeRaw(highlight(head) + "\n");
+              this.lineStarted = false;
+              text2 = tail;
+              if (!text2) return;
+            }
+          }
+          const usePrefix = this.lineStarted ? "" : prefix;
+          const usableW = this.lineStarted ? maxW : Math.max(1, maxW - usePrefix.length);
+          const lines = text2.length > usableW ? this.wordWrap(text2, usableW) : [text2];
+          for (let i2 = 0; i2 < lines.length; i2++) {
+            const isFirst = i2 === 0;
+            const isLast = i2 === lines.length - 1;
+            const lp = isFirst ? usePrefix : "     ";
+            const needsNewline = !isLast || trailingNewline;
+            this.writeRaw(dimText(lp) + highlight(lines[i2]) + (needsNewline ? "\n" : ""));
+          }
+          this.lineStarted = !trailingNewline;
+        };
         switch (kind) {
           case "thinking":
-            rendered = dimItalic(raw);
-            break;
+            emitWrapped(raw, dimItalic, hasNewline);
+            return;
           case "tool_args":
             rendered = this.highlightJson(raw, true);
             break;
-          case "content":
-            {
-              const maxW = termCols() - 6;
-              if (this.inCodeBlock) {
-                const cropped = raw.length > maxW ? raw.slice(0, maxW - 3) + "..." : raw;
-                if (this.codeLang === "diff" || this.codeLang === "patch") {
-                  rendered = this.highlightDiff(cropped);
-                } else if (this.codeLang === "bash" || this.codeLang === "sh" || this.codeLang === "shell" || this.codeLang === "zsh") {
-                  rendered = this.highlightShell(cropped);
-                } else {
-                  rendered = this.highlightCode(cropped);
-                }
-              } else if (this.looksLikeJson(raw)) {
-                const cropped = raw.length > maxW ? raw.slice(0, maxW - 3) + "..." : raw;
-                rendered = this.highlightJson(cropped, false);
+          case "content": {
+            if (this.inCodeBlock) {
+              const cropped = raw.length > maxW ? raw.slice(0, maxW - 3) + "..." : raw;
+              if (this.codeLang === "diff" || this.codeLang === "patch") {
+                rendered = this.highlightDiff(cropped);
+              } else if (this.codeLang === "bash" || this.codeLang === "sh" || this.codeLang === "shell" || this.codeLang === "zsh") {
+                rendered = this.highlightShell(cropped);
               } else {
-                if (hasNewline && raw.length > maxW) {
-                  const wrapped = this.wordWrap(raw, maxW);
-                  for (let i2 = 0; i2 < wrapped.length; i2++) {
-                    const lp = i2 === 0 ? prefix : "     ";
-                    const isLast = i2 === wrapped.length - 1;
-                    this.writeRaw(
-                      dimText(lp) + this.highlightMarkdown(wrapped[i2]) + (isLast ? "\n" : "\n")
-                    );
-                  }
-                  this.lineStarted = false;
-                  return;
-                }
-                const cropped = raw.length > maxW ? raw.slice(0, maxW) : raw;
-                rendered = this.highlightMarkdown(cropped);
+                rendered = this.highlightCode(cropped);
               }
-              break;
+            } else if (this.looksLikeJson(raw)) {
+              const cropped = raw.length > maxW ? raw.slice(0, maxW - 3) + "..." : raw;
+              rendered = this.highlightJson(cropped, false);
+            } else {
+              if (raw.length > maxW || this.lineStarted && this._cursorCol + raw.length > maxW) {
+                emitWrapped(raw, (s2) => this.highlightMarkdown(s2), hasNewline);
+                return;
+              }
+              rendered = this.highlightMarkdown(raw);
             }
             break;
-          case "thinking":
-            rendered = dimItalic(raw);
-            break;
+          }
+        }
+        if (kind === "content" && this.lineStarted && this._cursorCol + raw.length > maxW) {
+          emitWrapped(raw, (s2) => this.highlightMarkdown(s2), hasNewline);
+          return;
         }
         this.writeRaw(dimText(prefix) + rendered + (hasNewline ? "\n" : ""));
         this.lineStarted = !hasNewline;
@@ -558738,13 +558776,22 @@ var init_stream_renderer = __esm({
       }
       /** Write raw ANSI text to stdout and capture for scrollback.
        *  Wraps each write in autowrap-disable (DECAWM off) to prevent the terminal
-       *  from injecting line breaks when a token fragment reaches the right edge. */
+       *  from injecting line breaks when a token fragment reaches the right edge.
+       *  Also maintains _cursorCol so emitWrapped can decide when to force a
+       *  wrap on the NEXT partial flush (avoiding bottom-row token pile-up). */
       writeRaw(text) {
         if (isTTY8) {
           process.stdout.write(`\x1B[?7l${text}\x1B[?7h`);
         } else {
           process.stdout.write(text);
         }
+        const lastNl = text.lastIndexOf("\n");
+        if (lastNl >= 0) {
+          const after = text.slice(lastNl + 1);
+          this._cursorCol = stripAnsi(after).length;
+        } else {
+          this._cursorCol += stripAnsi(text).length;
+        }
         if (this.onRenderedLine) {
           const parts = text.split("\n");
           for (let i2 = 0; i2 < parts.length - 1; i2++) {

package/package.json

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