@protolabsai/proto 0.26.12 → 0.26.13

package/README.md

@@ -174,11 +174,23 @@ proto auto-discovers Claude Code plugins installed at `~/.claude/plugins/`. Any
 
 ### Environment variable overrides
 
-| Variable                        | Default | Description                                                                                     |
-| ------------------------------- | ------- | ----------------------------------------------------------------------------------------------- |
-| `PROTO_STREAM_STALL_TIMEOUT_MS` | `90000` | Max ms to wait between streaming chunks before declaring the connection stalled (then retrying) |
-| `PROTO_SYSTEM_DEFAULTS_PATH`    | —       | Override path to the system defaults settings file                                              |
-| `PROTO_SYSTEM_SETTINGS_PATH`    | —       | Override path to the system settings override file                                              |
+| Variable                            | Default | Description                                                                                                                                                                        |
+| ----------------------------------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `PROTO_STREAM_STALL_TIMEOUT_MS`     | `90000` | Max ms to wait between streaming chunks before declaring the connection stalled (then retrying)                                                                                    |
+| `PROTO_SYSTEM_DEFAULTS_PATH`        | —       | Override path to the system defaults settings file                                                                                                                                 |
+| `PROTO_SYSTEM_SETTINGS_PATH`        | —       | Override path to the system settings override file                                                                                                                                 |
+| `PROTO_LEGACY_ERASE_LINES`          | —       | Set to `1` to disable the cursor-collapse optimizer that prevents Ink scrollback bouncing during streaming renders. Only set this if it interferes with your terminal.             |
+| `PROTO_FORCE_SYNCHRONIZED_OUTPUT`   | —       | Set to `1` to force-enable BSU/ESU atomic-frame escape codes regardless of terminal auto-detect (useful if your terminal supports DEC mode 2026 but isn't on the allowlist below). |
+| `PROTO_DISABLE_SYNCHRONIZED_OUTPUT` | —       | Set to `1` to opt out of synchronized output even on supported terminals.                                                                                                          |
+
+### TUI flicker mitigation
+
+proto installs two stdout interventions to reduce flicker during streaming renders:
+
+1. **Cursor-collapse optimizer** — collapses Ink's per-line `{ERASE_LINE, CURSOR_UP_ONE}` sequences into a single bounded erase. Universal; bypass via `PROTO_LEGACY_ERASE_LINES=1`.
+2. **Synchronized output** — wraps each render frame in BSU/ESU escape codes (DEC mode 2026) on terminals that support it. Auto-detected for: **Alacritty (≥0.14), Ghostty, Kitty, WezTerm, iTerm2**. For other DEC-2026-capable terminals, set `PROTO_FORCE_SYNCHRONIZED_OUTPUT=1`.
+
+Both no-op outside a TTY, in screen-reader mode, or under tmux/SSH.
 
 ## Observability
 

package/cli.js

@@ -171128,7 +171128,7 @@ __export(geminiContentGenerator_exports, {
   createGeminiContentGenerator: () => createGeminiContentGenerator
 });
 function createGeminiContentGenerator(config2, gcConfig) {
-  const version2 = "0.26.12";
+  const version2 = "0.26.13";
   const userAgent2 = config2.userAgent || `QwenCode/${version2} (${process.platform}; ${process.arch})`;
   const baseHeaders = {
     "User-Agent": userAgent2
@@ -183136,7 +183136,21 @@ var require_xterm_headless = __commonJS({
 });
 
 // packages/core/dist/src/utils/terminalSerializer.js
-function serializeTerminalToObject(terminal, scrollOffset = 0) {
+function serializeTerminalToText(terminal) {
+  const buffer = terminal.buffer.active;
+  const lines = [];
+  for (let i4 = 0; i4 < buffer.length; i4++) {
+    const line = buffer.getLine(i4);
+    const lineContent = line ? line.translateToString(true) : "";
+    if (line?.isWrapped && lines.length > 0) {
+      lines[lines.length - 1] += lineContent;
+      continue;
+    }
+    lines.push(lineContent);
+  }
+  return lines.join("\n").trimEnd();
+}
+function serializeTerminalToObject(terminal, scrollOffset = 0, options2 = {}) {
   const buffer = terminal.buffer.active;
   const defaultFg = "";
   const defaultBg = "";
@@ -183189,7 +183203,11 @@ function serializeTerminalToObject(terminal, scrollOffset = 0) {
       };
       currentLine.push(token2);
     }
-    result.push(currentLine);
+    if (options2.unwrapWrappedLines && line.isWrapped && result.length > 0) {
+      appendAnsiLineTokens(result[result.length - 1], currentLine);
+    } else {
+      result.push(currentLine);
+    }
   }
   return result;
 }
@@ -183205,11 +183223,23 @@ function convertColorToHex(color, colorMode, defaultColor) {
   }
   return defaultColor;
 }
-var Attribute, ColorMode, Cell, ANSI_COLORS;
+var canMergeAnsiTokens, appendAnsiLineTokens, Attribute, ColorMode, Cell, ANSI_COLORS;
 var init_terminalSerializer = __esm({
   "packages/core/dist/src/utils/terminalSerializer.js"() {
     "use strict";
     init_esbuild_shims();
+    canMergeAnsiTokens = /* @__PURE__ */ __name((left3, right3) => left3.bold === right3.bold && left3.italic === right3.italic && left3.underline === right3.underline && left3.dim === right3.dim && left3.inverse === right3.inverse && left3.fg === right3.fg && left3.bg === right3.bg, "canMergeAnsiTokens");
+    appendAnsiLineTokens = /* @__PURE__ */ __name((target, source2) => {
+      for (const token2 of source2) {
+        const previous = target[target.length - 1];
+        if (previous && canMergeAnsiTokens(previous, token2)) {
+          previous.text += token2.text;
+        } else {
+          target.push({ ...token2 });
+        }
+      }
+    }, "appendAnsiLineTokens");
+    __name(serializeTerminalToText, "serializeTerminalToText");
     (function(Attribute2) {
       Attribute2[Attribute2["inverse"] = 1] = "inverse";
       Attribute2[Attribute2["bold"] = 2] = "bold";
@@ -183626,7 +183656,7 @@ function applyPowerShellUtf8Prefix(command2, shell2) {
   }
   return command2;
 }
-var import_headless, Terminal, SIGKILL_TIMEOUT_MS, WINDOWS_PATH_DELIMITER, cachedWindowsPathFingerprint, cachedMergedWindowsPath, getErrnoCode, getErrorMessage2, isExpectedPtyReadExitError, isExpectedPtyExitRaceError, getFullBufferText, replayTerminalOutput, windowsStrategy, posixStrategy, getCleanupStrategy, ShellExecutionService;
+var import_headless, Terminal, SIGKILL_TIMEOUT_MS, WINDOWS_PATH_DELIMITER, cachedWindowsPathFingerprint, cachedMergedWindowsPath, getErrnoCode, getErrorMessage2, isExpectedPtyReadExitError, isExpectedPtyExitRaceError, replayTerminalOutput, getLastNonEmptyAnsiLineIndex, trimTrailingEmptyAnsiLines, areAnsiOutputsEqual, createPlainAnsiLine, serializePlainViewportToAnsiOutput, windowsStrategy, posixStrategy, getCleanupStrategy, ShellExecutionService;
 var init_shellExecutionService = __esm({
   "packages/core/dist/src/services/shellExecutionService.js"() {
     "use strict";
@@ -183669,16 +183699,6 @@ var init_shellExecutionService = __esm({
       const message = getErrorMessage2(error40);
       return message.includes("ioctl(2) failed, EBADF") || message.includes("Cannot resize a pty that has already exited");
     }, "isExpectedPtyExitRaceError");
-    getFullBufferText = /* @__PURE__ */ __name((terminal) => {
-      const buffer = terminal.buffer.active;
-      const lines = [];
-      for (let i4 = 0; i4 < buffer.length; i4++) {
-        const line = buffer.getLine(i4);
-        const lineContent = line ? line.translateToString(true) : "";
-        lines.push(lineContent);
-      }
-      return lines.join("\n").trimEnd();
-    }, "getFullBufferText");
     replayTerminalOutput = /* @__PURE__ */ __name(async (output, cols, rows) => {
       const replayTerminal = new Terminal({
         allowProposedApi: true,
@@ -183690,8 +183710,59 @@ var init_shellExecutionService = __esm({
       await new Promise((resolve38) => {
         replayTerminal.write(output, () => resolve38());
       });
-      return getFullBufferText(replayTerminal);
+      return serializeTerminalToText(replayTerminal);
     }, "replayTerminalOutput");
+    getLastNonEmptyAnsiLineIndex = /* @__PURE__ */ __name((output) => {
+      for (let i4 = output.length - 1; i4 >= 0; i4--) {
+        const line = output[i4];
+        if (line.map((segment) => segment.text).join("").trim().length > 0) {
+          return i4;
+        }
+      }
+      return -1;
+    }, "getLastNonEmptyAnsiLineIndex");
+    trimTrailingEmptyAnsiLines = /* @__PURE__ */ __name((output) => output.slice(0, getLastNonEmptyAnsiLineIndex(output) + 1), "trimTrailingEmptyAnsiLines");
+    areAnsiOutputsEqual = /* @__PURE__ */ __name((left3, right3) => {
+      if (!left3 || left3.length !== right3.length) {
+        return false;
+      }
+      return left3.every((leftLine, lineIndex) => {
+        const rightLine = right3[lineIndex];
+        if (leftLine.length !== rightLine.length) {
+          return false;
+        }
+        return leftLine.every((leftToken, tokenIndex) => {
+          const rightToken = rightLine[tokenIndex];
+          return leftToken.text === rightToken.text && leftToken.bold === rightToken.bold && leftToken.italic === rightToken.italic && leftToken.underline === rightToken.underline && leftToken.dim === rightToken.dim && leftToken.inverse === rightToken.inverse && leftToken.fg === rightToken.fg && leftToken.bg === rightToken.bg;
+        });
+      });
+    }, "areAnsiOutputsEqual");
+    createPlainAnsiLine = /* @__PURE__ */ __name((text) => [
+      {
+        text,
+        bold: false,
+        italic: false,
+        underline: false,
+        dim: false,
+        inverse: false,
+        fg: "",
+        bg: ""
+      }
+    ], "createPlainAnsiLine");
+    serializePlainViewportToAnsiOutput = /* @__PURE__ */ __name((terminal, unwrapWrappedLines = false) => {
+      const buffer = terminal.buffer.active;
+      const lines = [];
+      for (let y2 = 0; y2 < terminal.rows; y2++) {
+        const line = buffer.getLine(buffer.viewportY + y2);
+        const lineContent = line ? line.translateToString(true) : "";
+        if (unwrapWrappedLines && line?.isWrapped && lines.length > 0) {
+          lines[lines.length - 1][0].text += lineContent;
+        } else {
+          lines.push(createPlainAnsiLine(lineContent));
+        }
+      }
+      return lines;
+    }, "serializePlainViewportToAnsiOutput");
     windowsStrategy = {
       killPty: /* @__PURE__ */ __name((_pid, pty) => {
         pty.ptyProcess.kill();
@@ -183954,7 +184025,7 @@ var init_shellExecutionService = __esm({
             this.activePtys.set(ptyProcess.pid, { ptyProcess, headlessTerminal });
             let processingChain = Promise.resolve();
             let decoder = null;
-            let output = null;
+            let outputComparison = null;
             const outputChunks = [];
             const error40 = null;
             let exited = false;
@@ -183972,7 +184043,7 @@ var init_shellExecutionService = __esm({
               }
               if (!shellExecutionConfig.disableDynamicLineTrimming) {
                 if (!hasStartedOutput) {
-                  const bufferText = getFullBufferText(headlessTerminal);
+                  const bufferText = serializeTerminalToText(headlessTerminal);
                   if (bufferText.trim().length === 0) {
                     return;
                   }
@@ -183980,41 +184051,20 @@ var init_shellExecutionService = __esm({
                 }
               }
               let newOutput;
+              let newOutputComparison;
               if (shellExecutionConfig.showColor) {
                 newOutput = serializeTerminalToObject(headlessTerminal);
+                newOutputComparison = serializeTerminalToObject(headlessTerminal, 0, { unwrapWrappedLines: true });
               } else {
-                const buffer = headlessTerminal.buffer.active;
-                const lines = [];
-                for (let y2 = 0; y2 < headlessTerminal.rows; y2++) {
-                  const line = buffer.getLine(buffer.viewportY + y2);
-                  const lineContent = line ? line.translateToString(true) : "";
-                  lines.push([
-                    {
-                      text: lineContent,
-                      bold: false,
-                      italic: false,
-                      underline: false,
-                      dim: false,
-                      inverse: false,
-                      fg: "",
-                      bg: ""
-                    }
-                  ]);
-                }
-                newOutput = lines;
+                newOutput = serializePlainViewportToAnsiOutput(headlessTerminal);
+                newOutputComparison = serializePlainViewportToAnsiOutput(headlessTerminal, true);
               }
-              let lastNonEmptyLine = -1;
-              for (let i4 = newOutput.length - 1; i4 >= 0; i4--) {
-                const line = newOutput[i4];
-                if (line.map((segment) => segment.text).join("").trim().length > 0) {
-                  lastNonEmptyLine = i4;
-                  break;
-                }
-              }
-              const trimmedOutput = newOutput.slice(0, lastNonEmptyLine + 1);
+              const trimmedOutput = trimTrailingEmptyAnsiLines(newOutput);
+              const trimmedOutputComparison = trimTrailingEmptyAnsiLines(newOutputComparison);
               const finalOutput = shellExecutionConfig.disableDynamicLineTrimming ? newOutput : trimmedOutput;
-              if (JSON.stringify(output) !== JSON.stringify(finalOutput)) {
-                output = finalOutput;
+              const finalOutputComparison = shellExecutionConfig.disableDynamicLineTrimming ? newOutputComparison : trimmedOutputComparison;
+              if (!areAnsiOutputsEqual(outputComparison, finalOutputComparison)) {
+                outputComparison = finalOutputComparison;
                 onOutputEvent({
                   type: "data",
                   chunk: finalOutput
@@ -184115,11 +184165,11 @@ var init_shellExecutionService = __esm({
                     const decodedOutput = new TextDecoder2(finalEncoding).decode(finalBuffer);
                     fullOutput = await replayTerminalOutput(decodedOutput, cols, rows);
                   } else {
-                    fullOutput = getFullBufferText(headlessTerminal);
+                    fullOutput = serializeTerminalToText(headlessTerminal);
                   }
                 } catch {
                   try {
-                    fullOutput = getFullBufferText(headlessTerminal);
+                    fullOutput = serializeTerminalToText(headlessTerminal);
                   } catch {
                   }
                 }
@@ -290139,6 +290189,7 @@ __export(dist_exports, {
   scanMemoryHeaders: () => scanMemoryHeaders,
   serializeMemoryFile: () => serializeMemoryFile,
   serializeTerminalToObject: () => serializeTerminalToObject,
+  serializeTerminalToText: () => serializeTerminalToText,
   sessionScopeLock: () => sessionScopeLock,
   setDebugLogSession: () => setDebugLogSession,
   setGeminiMdFilename: () => setGeminiMdFilename,
@@ -416326,7 +416377,7 @@ __name(getPackageJson, "getPackageJson");
 // packages/cli/src/utils/version.ts
 async function getCliVersion() {
   const pkgJson = await getPackageJson();
-  return "0.26.12";
+  return "0.26.13";
 }
 __name(getCliVersion, "getCliVersion");
 
@@ -424098,7 +424149,7 @@ var formatDuration = /* @__PURE__ */ __name((milliseconds) => {
 
 // packages/cli/src/generated/git-commit.ts
 init_esbuild_shims();
-var GIT_COMMIT_INFO = "90b666636";
+var GIT_COMMIT_INFO = "1cbd798c9";
 
 // packages/cli/src/utils/systemInfo.ts
 async function getNpmVersion() {
@@ -460758,6 +460809,52 @@ var RESERVED_LINE_COUNT = 5;
 var STATUS_INDICATOR_WIDTH = 3;
 var MIN_LINES_SHOWN = 2;
 var MAXIMUM_RESULT_DISPLAY_CHARACTERS = 1e6;
+function sliceTextForMaxHeight(text, maxHeight, maxWidth) {
+  if (maxHeight === void 0) {
+    return { text, hiddenLinesCount: 0 };
+  }
+  const targetMaxHeight = Math.max(Math.round(maxHeight), MINIMUM_MAX_HEIGHT);
+  const visibleContentHeight = targetMaxHeight - 1;
+  const visualWidth = Math.max(1, Math.floor(maxWidth));
+  const visibleLines = [];
+  let visualLineCount = 0;
+  let currentLine = "";
+  let currentLineWidth = 0;
+  const appendVisibleLine = /* @__PURE__ */ __name((line) => {
+    visualLineCount += 1;
+    visibleLines.push(line);
+    if (visibleLines.length > visibleContentHeight) {
+      visibleLines.shift();
+    }
+  }, "appendVisibleLine");
+  const flushCurrentLine = /* @__PURE__ */ __name(() => {
+    appendVisibleLine(currentLine);
+    currentLine = "";
+    currentLineWidth = 0;
+  }, "flushCurrentLine");
+  for (const char of toCodePoints(text)) {
+    if (char === "\n") {
+      flushCurrentLine();
+      continue;
+    }
+    const charWidth = Math.max(getCachedStringWidth(char), 1);
+    if (currentLineWidth > 0 && currentLineWidth + charWidth > visualWidth) {
+      flushCurrentLine();
+    }
+    currentLine += char;
+    currentLineWidth += charWidth;
+  }
+  flushCurrentLine();
+  if (visualLineCount <= targetMaxHeight) {
+    return { text, hiddenLinesCount: 0 };
+  }
+  const hiddenLinesCount = visualLineCount - visibleContentHeight;
+  return {
+    text: visibleLines.join("\n"),
+    hiddenLinesCount
+  };
+}
+__name(sliceTextForMaxHeight, "sliceTextForMaxHeight");
 var useResultDisplayRenderer = /* @__PURE__ */ __name((resultDisplay) => import_react64.default.useMemo(() => {
   if (!resultDisplay) {
     return { type: "none" };
@@ -460845,7 +460942,20 @@ var StringResultRenderer = /* @__PURE__ */ __name(({ data, renderAsMarkdown, ava
       }
     ) });
   }
-  return /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(MaxSizedBox, { maxHeight: availableHeight, maxWidth: childWidth, children: /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(Box_default, { children: /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(Text3, { wrap: "wrap", color: theme.text.primary, children: displayData }) }) });
+  const sliced = sliceTextForMaxHeight(
+    displayData,
+    availableHeight,
+    childWidth
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(
+    MaxSizedBox,
+    {
+      maxHeight: availableHeight,
+      maxWidth: childWidth,
+      additionalHiddenLinesCount: sliced.hiddenLinesCount,
+      children: /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(Box_default, { children: /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(Text3, { wrap: "wrap", color: theme.text.primary, children: sliced.text }) })
+    }
+  );
 }, "StringResultRenderer");
 var DiffResultRenderer = /* @__PURE__ */ __name(({ data, availableHeight, childWidth, settings: settings2 }) => /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(
   DiffRenderer,
@@ -479899,6 +480009,7 @@ function checkImageFormatsSupport(parts2) {
 }
 __name(checkImageFormatsSupport, "checkImageFormatsSupport");
 var EDIT_TOOL_NAMES = /* @__PURE__ */ new Set(["replace", "write_file"]);
+var STREAM_UPDATE_THROTTLE_MS = 60;
 function showCitations(settings2) {
   const enabled = settings2?.merged?.ui?.showCitations;
   if (enabled !== void 0) {
@@ -479910,6 +480021,7 @@ __name(showCitations, "showCitations");
 var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, config2, settings2, onDebugMessage, handleSlashCommand2, shellModeActive, getPreferredEditor, onAuthError, performMemoryRefresh, modelSwitchedFromQuotaError, setModelSwitchedFromQuotaError, onEditorClose, onCancelSubmit, setShellInputFocused, terminalWidth, terminalHeight, drainQueuedMessages) => {
   const [initError, setInitError] = (0, import_react148.useState)(null);
   const abortControllerRef = (0, import_react148.useRef)(null);
+  const flushBufferedStreamEventsRef = (0, import_react148.useRef)(/* @__PURE__ */ new Set());
   const turnCancelledRef = (0, import_react148.useRef)(false);
   const queryGuardRef = (0, import_react148.useRef)(new QueryGuard());
   const lastPromptRef = (0, import_react148.useRef)(null);
@@ -480107,6 +480219,9 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
     if (turnCancelledRef.current) {
       return;
     }
+    for (const flushBufferedStreamEvents of flushBufferedStreamEventsRef.current) {
+      flushBufferedStreamEvents();
+    }
     turnCancelledRef.current = true;
     queryGuardRef.current.forceEnd();
     abortControllerRef.current?.abort();
@@ -480550,81 +480665,158 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
       let geminiMessageBuffer = "";
       let thoughtBuffer = "";
       const toolCallRequests = [];
-      for await (const event of stream2) {
-        switch (event.type) {
-          case GeminiEventType.Thought:
-            if (event.value.subject) {
-              setThought(event.value);
-            } else {
-              thoughtBuffer = handleThoughtEvent(
-                event.value,
-                thoughtBuffer,
-                userMessageTimestamp
-              );
+      const bufferedEvents = [];
+      let flushTimer = null;
+      const discardBufferedStreamEvents = /* @__PURE__ */ __name(() => {
+        if (flushTimer) {
+          clearTimeout(flushTimer);
+          flushTimer = null;
+        }
+        bufferedEvents.length = 0;
+      }, "discardBufferedStreamEvents");
+      const flushBufferedStreamEvents = /* @__PURE__ */ __name(() => {
+        if (flushTimer) {
+          clearTimeout(flushTimer);
+          flushTimer = null;
+        }
+        if (bufferedEvents.length === 0) {
+          return;
+        }
+        while (bufferedEvents.length > 0) {
+          const nextEvent = bufferedEvents.shift();
+          if (nextEvent.kind === "content") {
+            let mergedContent = nextEvent.value;
+            while (bufferedEvents[0]?.kind === "content") {
+              const queuedContent = bufferedEvents.shift();
+              if (queuedContent?.kind !== "content") {
+                break;
+              }
+              mergedContent += queuedContent.value;
             }
-            break;
-          case GeminiEventType.Content:
             geminiMessageBuffer = handleContentEvent(
-              event.value,
+              mergedContent,
               geminiMessageBuffer,
               userMessageTimestamp
             );
-            break;
-          case GeminiEventType.ToolCallRequest:
-            toolCallRequests.push(event.value);
-            break;
-          case GeminiEventType.UserCancelled:
-            handleUserCancelledEvent(userMessageTimestamp);
-            break;
-          case GeminiEventType.Error:
-            handleErrorEvent(event.value, userMessageTimestamp);
-            break;
-          case GeminiEventType.ChatCompressed:
-            handleChatCompressionEvent(event.value, userMessageTimestamp);
-            break;
-          case GeminiEventType.ToolCallConfirmation:
-          case GeminiEventType.ToolCallResponse:
-            break;
-          case GeminiEventType.MaxSessionTurns:
-            handleMaxSessionTurnsEvent();
-            break;
-          case GeminiEventType.SessionTokenLimitExceeded:
-            handleSessionTokenLimitExceededEvent(event.value);
-            break;
-          case GeminiEventType.Finished:
-            handleFinishedEvent(
-              event,
-              userMessageTimestamp
-            );
-            break;
-          case GeminiEventType.Citation:
-            handleCitationEvent(event.value, userMessageTimestamp);
-            break;
-          case GeminiEventType.LoopDetected:
-            loopDetectedRef.current = true;
-            break;
-          case GeminiEventType.Retry:
-            if (pendingHistoryItemRef.current) {
-              setPendingHistoryItem(null);
+            continue;
+          }
+          let mergedThought = nextEvent.value;
+          while (bufferedEvents[0]?.kind === "thought") {
+            const queuedThought = bufferedEvents.shift();
+            if (queuedThought?.kind !== "thought") {
+              break;
             }
-            if (event.retryInfo) {
-              startRetryCountdown(event.retryInfo);
-            } else {
-              clearRetryCountdown();
+            mergedThought = {
+              subject: queuedThought.value.subject || mergedThought.subject,
+              description: `${mergedThought.description ?? ""}${queuedThought.value.description ?? ""}`
+            };
+          }
+          thoughtBuffer = handleThoughtEvent(
+            mergedThought,
+            thoughtBuffer,
+            userMessageTimestamp
+          );
+        }
+      }, "flushBufferedStreamEvents");
+      const scheduleBufferedStreamFlush = /* @__PURE__ */ __name(() => {
+        if (flushTimer) {
+          return;
+        }
+        flushTimer = setTimeout(() => {
+          flushBufferedStreamEvents();
+        }, STREAM_UPDATE_THROTTLE_MS);
+      }, "scheduleBufferedStreamFlush");
+      flushBufferedStreamEventsRef.current.add(flushBufferedStreamEvents);
+      try {
+        for await (const event of stream2) {
+          switch (event.type) {
+            case GeminiEventType.Thought:
+              if (event.value.subject) {
+                flushBufferedStreamEvents();
+                setThought(event.value);
+              } else {
+                bufferedEvents.push({ kind: "thought", value: event.value });
+                scheduleBufferedStreamFlush();
+              }
+              break;
+            case GeminiEventType.Content:
+              bufferedEvents.push({ kind: "content", value: event.value });
+              scheduleBufferedStreamFlush();
+              break;
+            case GeminiEventType.ToolCallRequest:
+              flushBufferedStreamEvents();
+              toolCallRequests.push(event.value);
+              break;
+            case GeminiEventType.UserCancelled:
+              flushBufferedStreamEvents();
+              handleUserCancelledEvent(userMessageTimestamp);
+              break;
+            case GeminiEventType.Error:
+              flushBufferedStreamEvents();
+              handleErrorEvent(event.value, userMessageTimestamp);
+              break;
+            case GeminiEventType.ChatCompressed:
+              flushBufferedStreamEvents();
+              handleChatCompressionEvent(event.value, userMessageTimestamp);
+              break;
+            case GeminiEventType.ToolCallConfirmation:
+            case GeminiEventType.ToolCallResponse:
+              flushBufferedStreamEvents();
+              break;
+            case GeminiEventType.MaxSessionTurns:
+              flushBufferedStreamEvents();
+              handleMaxSessionTurnsEvent();
+              break;
+            case GeminiEventType.SessionTokenLimitExceeded:
+              flushBufferedStreamEvents();
+              handleSessionTokenLimitExceededEvent(event.value);
+              break;
+            case GeminiEventType.Finished:
+              flushBufferedStreamEvents();
+              handleFinishedEvent(
+                event,
+                userMessageTimestamp
+              );
+              break;
+            case GeminiEventType.Citation:
+              flushBufferedStreamEvents();
+              handleCitationEvent(event.value, userMessageTimestamp);
+              break;
+            case GeminiEventType.LoopDetected:
+              flushBufferedStreamEvents();
+              loopDetectedRef.current = true;
+              break;
+            case GeminiEventType.Retry:
+              discardBufferedStreamEvents();
+              if (pendingHistoryItemRef.current) {
+                setPendingHistoryItem(null);
+              }
+              geminiMessageBuffer = "";
+              thoughtBuffer = "";
+              if (event.retryInfo) {
+                startRetryCountdown(event.retryInfo);
+              } else {
+                clearRetryCountdown();
+              }
+              break;
+            case GeminiEventType.HookSystemMessage:
+              flushBufferedStreamEvents();
+              geminiMessageBuffer = handleContentEvent(
+                event.value + "\n",
+                geminiMessageBuffer,
+                userMessageTimestamp
+              );
+              break;
+            default: {
+              const unreachable = event;
+              return unreachable;
             }
-            break;
-          case GeminiEventType.HookSystemMessage:
-            geminiMessageBuffer = handleContentEvent(
-              event.value + "\n",
-              geminiMessageBuffer,
-              userMessageTimestamp
-            );
-            break;
-          default: {
-            const unreachable = event;
-            return unreachable;
           }
         }
+      } finally {
+        flushBufferedStreamEvents();
+        discardBufferedStreamEvents();
+        flushBufferedStreamEventsRef.current.delete(flushBufferedStreamEvents);
       }
       if (toolCallRequests.length > 0) {
         scheduleToolCalls(toolCallRequests, signal);
@@ -491821,7 +492013,7 @@ var QwenAgent = class {
   async initialize(args2) {
     this.clientCapabilities = args2.clientCapabilities;
     const authMethods = buildAuthMethods();
-    const version2 = "0.26.12";
+    const version2 = "0.26.13";
     return {
       protocolVersion: PROTOCOL_VERSION,
       agentInfo: {
@@ -492332,11 +492524,23 @@ function terminalSupportsSynchronizedOutput(env5 = process.env) {
     return false;
   }
   const termProgram = env5["TERM_PROGRAM"];
-  if (termProgram === "WezTerm" || termProgram === "iTerm.app") {
+  if (termProgram === "WezTerm" || termProgram === "iTerm.app" || termProgram === "ghostty") {
+    return true;
+  }
+  if (env5["ALACRITTY_WINDOW_ID"]) {
     return true;
   }
   const term = env5["TERM"];
-  return Boolean(env5["KITTY_WINDOW_ID"] || term?.includes("kitty"));
+  if (env5["KITTY_WINDOW_ID"] || term?.includes("kitty")) {
+    return true;
+  }
+  if (term?.startsWith("alacritty")) {
+    return true;
+  }
+  if (env5["GHOSTTY_RESOURCES_DIR"]) {
+    return true;
+  }
+  return false;
 }
 __name(terminalSupportsSynchronizedOutput, "terminalSupportsSynchronizedOutput");
 function installSynchronizedOutput(stdout3 = process.stdout, env5 = process.env) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@protolabsai/proto",
-  "version": "0.26.12",
+  "version": "0.26.13",
   "description": "proto - AI-powered coding agent",
   "repository": {
     "type": "git",
@@ -21,7 +21,7 @@
     "bundled"
   ],
   "config": {
-    "sandboxImageUri": "ghcr.io/qwenlm/qwen-code:0.26.12"
+    "sandboxImageUri": "ghcr.io/qwenlm/qwen-code:0.26.13"
   },
   "dependencies": {},
   "optionalDependencies": {