@ai-sdk/tui 0.0.0 → 1.0.0-beta.12

package/dist/index.js

@@ -0,0 +1,1924 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// src/tui/terminal-text.ts
+var ansiEscape = String.fromCharCode(27);
+var ansiPattern = new RegExp(`${ansiEscape}\\[[0-?]*[ -/]*[@-~]`, "g");
+var ansiPrefixPattern = new RegExp(
+  `^${ansiEscape}\\[[0-?]*[ -/]*[@-~]`
+);
+function visibleLength(input) {
+  let width = 0;
+  let index = 0;
+  while (index < input.length) {
+    const ansiMatch = input.slice(index).match(ansiPrefixPattern);
+    if (ansiMatch) {
+      index += ansiMatch[0].length;
+      continue;
+    }
+    const codePoint = input.codePointAt(index);
+    if (codePoint == null) {
+      break;
+    }
+    const character = String.fromCodePoint(codePoint);
+    width += codePointWidth(codePoint);
+    index += character.length;
+  }
+  return width;
+}
+function sliceVisible(input, width) {
+  if (width <= 0) {
+    return "";
+  }
+  let output = "";
+  let visible = 0;
+  let index = 0;
+  while (index < input.length && visible < width) {
+    const ansiMatch = input.slice(index).match(ansiPrefixPattern);
+    if (ansiMatch) {
+      output += ansiMatch[0];
+      index += ansiMatch[0].length;
+      continue;
+    }
+    const codePoint = input.codePointAt(index);
+    if (codePoint == null) {
+      break;
+    }
+    const character = String.fromCodePoint(codePoint);
+    const characterWidth = codePointWidth(codePoint);
+    if (characterWidth > 0 && visible + characterWidth > width) {
+      break;
+    }
+    output += character;
+    index += character.length;
+    visible += characterWidth;
+  }
+  while (index < input.length) {
+    const ansiMatch = input.slice(index).match(ansiPrefixPattern);
+    if (!ansiMatch) {
+      break;
+    }
+    output += ansiMatch[0];
+    index += ansiMatch[0].length;
+  }
+  return output;
+}
+function codePointWidth(codePoint) {
+  if (codePoint === 9) {
+    return 4;
+  }
+  if (codePoint < 32 || codePoint >= 127 && codePoint < 160) {
+    return 0;
+  }
+  if (isZeroWidthCodePoint(codePoint)) {
+    return 0;
+  }
+  return isWideCodePoint(codePoint) ? 2 : 1;
+}
+function isZeroWidthCodePoint(codePoint) {
+  return codePoint >= 768 && codePoint <= 879 || codePoint >= 1155 && codePoint <= 1161 || codePoint >= 1425 && codePoint <= 1469 || codePoint === 1471 || codePoint >= 1473 && codePoint <= 1474 || codePoint >= 1476 && codePoint <= 1477 || codePoint === 1479 || codePoint >= 1552 && codePoint <= 1562 || codePoint >= 1611 && codePoint <= 1631 || codePoint === 1648 || codePoint >= 1750 && codePoint <= 1756 || codePoint >= 1759 && codePoint <= 1764 || codePoint >= 1767 && codePoint <= 1768 || codePoint >= 1770 && codePoint <= 1773 || codePoint === 1809 || codePoint >= 1840 && codePoint <= 1866 || codePoint >= 1958 && codePoint <= 1968 || codePoint >= 2027 && codePoint <= 2035 || codePoint >= 2070 && codePoint <= 2073 || codePoint >= 2075 && codePoint <= 2083 || codePoint >= 2085 && codePoint <= 2087 || codePoint >= 2089 && codePoint <= 2093 || codePoint >= 2137 && codePoint <= 2139 || codePoint >= 2259 && codePoint <= 2306 || codePoint === 2362 || codePoint === 2364 || codePoint >= 2369 && codePoint <= 2376 || codePoint === 2381 || codePoint >= 2385 && codePoint <= 2391 || codePoint === 8205 || codePoint >= 65024 && codePoint <= 65039 || codePoint >= 917760 && codePoint <= 917999;
+}
+function isWideCodePoint(codePoint) {
+  return codePoint >= 4352 && (codePoint <= 4447 || codePoint === 9001 || codePoint === 9002 || codePoint >= 11904 && codePoint <= 42191 && codePoint !== 12351 || codePoint >= 44032 && codePoint <= 55203 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 65040 && codePoint <= 65049 || codePoint >= 65072 && codePoint <= 65135 || codePoint >= 65280 && codePoint <= 65376 || codePoint >= 65504 && codePoint <= 65510 || codePoint >= 127744 && codePoint <= 128591 || codePoint >= 129280 && codePoint <= 129535 || codePoint >= 131072 && codePoint <= 262141);
+}
+
+// src/tui/markdown.ts
+var ansi = {
+  bold: "\x1B[1m",
+  boldOff: "\x1B[22m",
+  italic: "\x1B[3m",
+  italicOff: "\x1B[23m"
+};
+var tableSeparator = "\u2500";
+function renderMarkdown(input) {
+  var _a;
+  const lines = input.split("\n");
+  const output = [];
+  for (let index = 0; index < lines.length; index += 1) {
+    const table = parseTable(lines, index);
+    if (table != null) {
+      output.push(...renderTable(table));
+      index = table.endIndex - 1;
+      continue;
+    }
+    output.push(renderMarkdownLine((_a = lines[index]) != null ? _a : ""));
+  }
+  return output.join("\n");
+}
+function renderMarkdownLine(line) {
+  if (line.startsWith("### ")) {
+    return renderInlineMarkdown(`\u25B6 ${line.slice(4)}`);
+  }
+  if (line.startsWith("## ")) {
+    return renderInlineMarkdown(`\u25A0 ${line.slice(3)}`);
+  }
+  if (line.startsWith("# ")) {
+    return renderInlineMarkdown(`\u2588 ${line.slice(2)}`);
+  }
+  const unorderedListItem = line.match(/^(\s*)[-+*]\s+(.*)$/);
+  if (unorderedListItem) {
+    const [, indentation, text = ""] = unorderedListItem;
+    return renderInlineMarkdown(
+      `${indentation}\u2022${text.length > 0 ? ` ${text}` : ""}`
+    );
+  }
+  if (/^\d+\. /.test(line)) {
+    return renderInlineMarkdown(line.replace(/^(\d+)\. /, "$1. "));
+  }
+  if (line.startsWith("> ")) {
+    return renderInlineMarkdown(`\u2502 ${line.slice(2)}`);
+  }
+  return renderInlineMarkdown(line);
+}
+function renderInlineMarkdown(input) {
+  return input.replace(/`([^`]+)`/g, "$1").replace(/\*\*([^*\n]+)\*\*/g, `${ansi.bold}$1${ansi.boldOff}`).replace(/__([^_\n]+)__/g, `${ansi.bold}$1${ansi.boldOff}`).replace(/\*([^*\n]+)\*/g, `${ansi.italic}$1${ansi.italicOff}`).replace(/_([^_\n]+)_/g, `${ansi.italic}$1${ansi.italicOff}`);
+}
+function parseTable(lines, startIndex) {
+  var _a, _b, _c;
+  const header = parseTableCells((_a = lines[startIndex]) != null ? _a : "");
+  if (header == null || header.length < 2) {
+    return void 0;
+  }
+  const separatorCells = parseTableCells((_b = lines[startIndex + 1]) != null ? _b : "");
+  if (separatorCells == null || separatorCells.length !== header.length) {
+    return void 0;
+  }
+  const alignments = parseTableAlignments(separatorCells);
+  if (alignments == null) {
+    return void 0;
+  }
+  const rows = [];
+  let endIndex = startIndex + 2;
+  while (endIndex < lines.length) {
+    const row = parseTableCells((_c = lines[endIndex]) != null ? _c : "");
+    if (row == null) {
+      break;
+    }
+    rows.push(normalizeTableRow(row, header.length));
+    endIndex += 1;
+  }
+  return {
+    alignments,
+    endIndex,
+    header,
+    rows
+  };
+}
+function parseTableCells(line) {
+  if (!line.includes("|")) {
+    return void 0;
+  }
+  let tableLine = line.trim();
+  if (tableLine.startsWith("|")) {
+    tableLine = tableLine.slice(1);
+  }
+  if (tableLine.endsWith("|") && !tableLine.endsWith("\\|")) {
+    tableLine = tableLine.slice(0, -1);
+  }
+  const cells = [];
+  let cell = "";
+  for (let index = 0; index < tableLine.length; index += 1) {
+    const character = tableLine[index];
+    const nextCharacter = tableLine[index + 1];
+    if (character === "\\" && nextCharacter === "|") {
+      cell += "|";
+      index += 1;
+      continue;
+    }
+    if (character === "|") {
+      cells.push(cell.trim());
+      cell = "";
+      continue;
+    }
+    cell += character;
+  }
+  cells.push(cell.trim());
+  return cells;
+}
+function parseTableAlignments(cells) {
+  const alignments = [];
+  for (const cell of cells) {
+    const match = cell.match(/^(:)?-{3,}(:)?$/);
+    if (match == null) {
+      return void 0;
+    }
+    const [, left, right] = match;
+    alignments.push(
+      left != null && right != null ? "center" : right != null ? "right" : "left"
+    );
+  }
+  return alignments;
+}
+function normalizeTableRow(row, length) {
+  return Array.from({ length }, (_, index) => {
+    var _a;
+    return (_a = row[index]) != null ? _a : "";
+  });
+}
+function renderTable(table) {
+  const header = table.header.map(
+    (cell) => `${ansi.bold}${renderInlineMarkdown(cell)}${ansi.boldOff}`
+  );
+  const rows = table.rows.map((row) => row.map(renderInlineMarkdown));
+  const tableRows = [header, ...rows];
+  const widths = table.alignments.map(
+    (_, columnIndex) => Math.max(3, ...tableRows.map((row) => {
+      var _a;
+      return visibleLength((_a = row[columnIndex]) != null ? _a : "");
+    }))
+  );
+  return [
+    formatTableRow(header, widths, table.alignments),
+    widths.map((width) => tableSeparator.repeat(width)).join("  "),
+    ...rows.map((row) => formatTableRow(row, widths, table.alignments))
+  ];
+}
+function formatTableRow(row, widths, alignments) {
+  return row.map(
+    (cell, index) => {
+      var _a, _b;
+      return alignTableCell(cell, (_a = widths[index]) != null ? _a : 0, (_b = alignments[index]) != null ? _b : "left");
+    }
+  ).join("  ");
+}
+function alignTableCell(cell, width, alignment) {
+  const paddingWidth = Math.max(0, width - visibleLength(cell));
+  if (alignment === "right") {
+    return `${" ".repeat(paddingWidth)}${cell}`;
+  }
+  if (alignment === "center") {
+    const leftPadding = Math.floor(paddingWidth / 2);
+    const rightPadding = paddingWidth - leftPadding;
+    return `${" ".repeat(leftPadding)}${cell}${" ".repeat(rightPadding)}`;
+  }
+  return `${cell}${" ".repeat(paddingWidth)}`;
+}
+
+// src/tui/layout.ts
+var horizontal = "\u2500";
+function renderScreenViewport(state) {
+  var _a;
+  const width = Math.max(20, state.width);
+  const height = Math.max(8, state.height);
+  const inputHeight = 3;
+  const bodyHeight = height - inputHeight;
+  const bodyContentHeight = bodyHeight - 2;
+  const visibleBody = state.visibleBodyLines.slice(0, bodyContentHeight);
+  while (visibleBody.length < bodyContentHeight) {
+    visibleBody.push("");
+  }
+  const lines = [
+    topBorder(width, state.title, state.rightTitle),
+    ...visibleBody.map((line) => boxLine(line, width)),
+    bottomBorder(width),
+    topBorder(width, state.inputActive ? "Input" : "Status"),
+    boxLine(
+      state.inputActive ? `> ${state.input}${state.inputCursorVisible === false ? " " : "\u2588"}` : (_a = state.status) != null ? _a : "Streaming... \u2191/\u2193 scroll \xB7 Ctrl+C quit",
+      width
+    ),
+    bottomBorder(width)
+  ];
+  return lines.join("\n");
+}
+function topBorder(width, title, rightTitle) {
+  const contentWidth = Math.max(0, width - 2);
+  const label = title ? sliceVisible(` ${title} `, contentWidth) : "";
+  const rightLabel = rightTitle ? sliceVisible(
+    ` ${rightTitle} `,
+    Math.max(0, contentWidth - visibleLength(label))
+  ) : "";
+  const remaining = Math.max(
+    0,
+    contentWidth - visibleLength(label) - visibleLength(rightLabel)
+  );
+  return `\u250C${label}${horizontal.repeat(remaining)}${rightLabel}\u2510`;
+}
+function bottomBorder(width) {
+  return `\u2514${horizontal.repeat(width - 2)}\u2518`;
+}
+function boxLine(line, width) {
+  const contentWidth = width - 4;
+  const visible = sliceVisible(line, contentWidth);
+  const padding = " ".repeat(
+    Math.max(0, contentWidth - visibleLength(visible))
+  );
+  return `\u2502 ${visible}${padding} \u2502`;
+}
+
+// src/tui/terminal-frame-buffer.ts
+var escape = "\x1B";
+var cursorHome = `${escape}[H`;
+var clearScreen = `${escape}[2J`;
+var clearLine = `${escape}[2K`;
+var synchronizeStart = `${escape}[?2026h`;
+var synchronizeEnd = `${escape}[?2026l`;
+var _useSynchronizedUpdates, _originalWrite, _previousFrame, _isWritingFrame, _externalWriteSinceLastFrame, _TerminalFrameBuffer_instances, writeUpdate_fn;
+var TerminalFrameBuffer = class {
+  constructor(output, options) {
+    __privateAdd(this, _TerminalFrameBuffer_instances);
+    __privateAdd(this, _useSynchronizedUpdates);
+    __privateAdd(this, _originalWrite);
+    __privateAdd(this, _previousFrame);
+    __privateAdd(this, _isWritingFrame, false);
+    __privateAdd(this, _externalWriteSinceLastFrame, false);
+    var _a;
+    __privateSet(this, _originalWrite, output.write.bind(output));
+    __privateSet(this, _useSynchronizedUpdates, (_a = options == null ? void 0 : options.useSynchronizedUpdates) != null ? _a : true);
+    output.write = ((chunk, encodingOrCallback, callback) => {
+      if (!__privateGet(this, _isWritingFrame)) {
+        __privateSet(this, _externalWriteSinceLastFrame, true);
+      }
+      return __privateGet(this, _originalWrite).call(this, chunk, encodingOrCallback, callback);
+    });
+  }
+  present(frame) {
+    const nextFrame = snapshotFrame(frame);
+    const update = __privateGet(this, _previousFrame) && !__privateGet(this, _externalWriteSinceLastFrame) ? diffFrame(__privateGet(this, _previousFrame), nextFrame) : `${cursorHome}${clearScreen}${frame}`;
+    __privateSet(this, _previousFrame, nextFrame);
+    __privateSet(this, _externalWriteSinceLastFrame, false);
+    if (update.length === 0) {
+      return;
+    }
+    __privateMethod(this, _TerminalFrameBuffer_instances, writeUpdate_fn).call(this, update);
+  }
+  reset() {
+    __privateSet(this, _previousFrame, void 0);
+  }
+};
+_useSynchronizedUpdates = new WeakMap();
+_originalWrite = new WeakMap();
+_previousFrame = new WeakMap();
+_isWritingFrame = new WeakMap();
+_externalWriteSinceLastFrame = new WeakMap();
+_TerminalFrameBuffer_instances = new WeakSet();
+writeUpdate_fn = function(update) {
+  __privateSet(this, _isWritingFrame, true);
+  try {
+    if (!__privateGet(this, _useSynchronizedUpdates)) {
+      __privateGet(this, _originalWrite).call(this, update);
+      return;
+    }
+    __privateGet(this, _originalWrite).call(this, `${synchronizeStart}${update}${synchronizeEnd}`);
+  } finally {
+    __privateSet(this, _isWritingFrame, false);
+  }
+};
+function snapshotFrame(frame) {
+  return { lines: frame.split("\n") };
+}
+function diffFrame(previousFrame, nextFrame) {
+  let output = "";
+  const lineCount = Math.max(
+    previousFrame.lines.length,
+    nextFrame.lines.length
+  );
+  for (let index = 0; index < lineCount; index++) {
+    const line = nextFrame.lines[index];
+    if (previousFrame.lines[index] === line) {
+      continue;
+    }
+    output += `${escape}[${index + 1};1H${clearLine}${line != null ? line : ""}`;
+  }
+  return output;
+}
+
+// src/tui/terminal-renderer.ts
+import {
+  getToolName,
+  isToolUIPart,
+  readUIMessageStream
+} from "ai";
+var defaultResponseStatistics = "outputTokensPerSecond";
+var colors = {
+  reset: "\x1B[0m",
+  dim: "\x1B[2m",
+  user: "\x1B[96m",
+  assistant: "\x1B[92m",
+  reasoning: "\x1B[94m",
+  tool: "\x1B[95m",
+  error: "\x1B[91m"
+};
+var sectionStyles = {
+  user: { color: colors.user, border: "\u2500" },
+  assistant: { color: colors.assistant, border: "\u2500" },
+  reasoning: { color: colors.reasoning, border: "\xB7" },
+  tool: { color: colors.tool, border: "\u2500" },
+  error: { color: colors.error, border: "\u2500" }
+};
+var inputCursorBlinkMs = 500;
+var activeControls = "\u2191/\u2193 \xB7 PgUp/PgDn \xB7 Esc/Ctrl+C";
+var doneControls = "\u2191/\u2193 \xB7 PgUp/PgDn \xB7 q/Esc/Ctrl+C";
+var processingStatus = `Processing input... ${activeControls}`;
+var processingToolResultsStatus = `Processing tool results... ${activeControls}`;
+var streamingStatus = `Streaming... ${activeControls}`;
+var executingToolsStatus = `Executing tools... ${activeControls}`;
+var _input, _output, _frameBuffer, _tools, _reasoning, _responseStatistics, _defaultContextSize, _sections, _inputText, _inputActive, _scrollOffset, _title, _status, _isInteractive, _interrupted, _totalTokens, _contextSize, _assistantOutputTokens, _assistantOutputTokensPerSecond, _inputCursorVisible, _inputCursorTimer, _onData, _onResize, _resolveStreamInterrupt, _TerminalRenderer_instances, start_fn, stop_fn, attachInput_fn, detachInput_fn, handleStreamingKey_fn, handleScroll_fn, handlePageScroll_fn, startInputCursorBlink_fn, stopInputCursorBlink_fn, showInputCursor_fn, addSubmittedPrompt_fn, addUserSection_fn, renderAssistantMessage_fn, upsertSection_fn, removeStaleAssistantSections_fn, observeUIMessageStream_fn, addErrorSection_fn, paintAfterBodyChange_fn, paint_fn, repaint_fn, visibleBodyLines_fn, clampScrollOffset_fn, bodyLineCount_fn, bodyContentHeight_fn, width_fn, height_fn, waitForExit_fn;
+var TerminalRenderer = class {
+  constructor(options) {
+    __privateAdd(this, _TerminalRenderer_instances);
+    __privateAdd(this, _input);
+    __privateAdd(this, _output);
+    __privateAdd(this, _frameBuffer);
+    __privateAdd(this, _tools);
+    __privateAdd(this, _reasoning);
+    __privateAdd(this, _responseStatistics);
+    __privateAdd(this, _defaultContextSize);
+    __privateAdd(this, _sections, []);
+    __privateAdd(this, _inputText, "");
+    __privateAdd(this, _inputActive, false);
+    __privateAdd(this, _scrollOffset, 0);
+    __privateAdd(this, _title, "");
+    __privateAdd(this, _status, streamingStatus);
+    __privateAdd(this, _isInteractive, false);
+    __privateAdd(this, _interrupted, false);
+    __privateAdd(this, _totalTokens);
+    __privateAdd(this, _contextSize);
+    __privateAdd(this, _assistantOutputTokens);
+    __privateAdd(this, _assistantOutputTokensPerSecond);
+    __privateAdd(this, _inputCursorVisible, true);
+    __privateAdd(this, _inputCursorTimer);
+    __privateAdd(this, _onData);
+    __privateAdd(this, _onResize);
+    __privateAdd(this, _resolveStreamInterrupt);
+    var _a, _b, _c, _d, _e, _f;
+    __privateSet(this, _input, (_a = options == null ? void 0 : options.input) != null ? _a : process.stdin);
+    __privateSet(this, _output, (_b = options == null ? void 0 : options.output) != null ? _b : process.stdout);
+    __privateSet(this, _frameBuffer, (_c = options == null ? void 0 : options.frameBuffer) != null ? _c : new TerminalFrameBuffer(__privateGet(this, _output)));
+    __privateSet(this, _tools, (_d = options == null ? void 0 : options.tools) != null ? _d : "auto-collapsed");
+    __privateSet(this, _reasoning, (_e = options == null ? void 0 : options.reasoning) != null ? _e : "auto-collapsed");
+    __privateSet(this, _responseStatistics, (_f = options == null ? void 0 : options.responseStatistics) != null ? _f : defaultResponseStatistics);
+    __privateSet(this, _defaultContextSize, options == null ? void 0 : options.contextSize);
+    __privateSet(this, _contextSize, options == null ? void 0 : options.contextSize);
+  }
+  async readPrompt(options) {
+    var _a;
+    __privateMethod(this, _TerminalRenderer_instances, start_fn).call(this, options);
+    __privateSet(this, _inputActive, true);
+    __privateSet(this, _inputText, (_a = options == null ? void 0 : options.initialPrompt) != null ? _a : "");
+    __privateSet(this, _status, `Type a prompt and press Enter \xB7 ${activeControls}`);
+    __privateMethod(this, _TerminalRenderer_instances, startInputCursorBlink_fn).call(this);
+    __privateMethod(this, _TerminalRenderer_instances, paint_fn).call(this);
+    return await new Promise((resolve, reject) => {
+      __privateSet(this, _onData, (chunk) => {
+        const key = parseKey(chunk);
+        switch (key.type) {
+          case "character":
+            __privateSet(this, _inputText, __privateGet(this, _inputText) + key.value);
+            __privateMethod(this, _TerminalRenderer_instances, showInputCursor_fn).call(this);
+            __privateMethod(this, _TerminalRenderer_instances, paint_fn).call(this);
+            break;
+          case "backspace":
+            __privateSet(this, _inputText, __privateGet(this, _inputText).slice(0, -1));
+            __privateMethod(this, _TerminalRenderer_instances, showInputCursor_fn).call(this);
+            __privateMethod(this, _TerminalRenderer_instances, paint_fn).call(this);
+            break;
+          case "enter": {
+            const prompt = __privateGet(this, _inputText);
+            __privateSet(this, _inputActive, false);
+            __privateMethod(this, _TerminalRenderer_instances, stopInputCursorBlink_fn).call(this);
+            __privateSet(this, _status, processingStatus);
+            __privateMethod(this, _TerminalRenderer_instances, addUserSection_fn).call(this, prompt);
+            __privateSet(this, _inputText, "");
+            __privateMethod(this, _TerminalRenderer_instances, paint_fn).call(this);
+            __privateMethod(this, _TerminalRenderer_instances, detachInput_fn).call(this);
+            resolve(prompt);
+            break;
+          }
+          case "up":
+          case "down":
+            __privateMethod(this, _TerminalRenderer_instances, handleScroll_fn).call(this, key.type);
+            break;
+          case "page-up":
+          case "page-down":
+            __privateMethod(this, _TerminalRenderer_instances, handlePageScroll_fn).call(this, key.type);
+            break;
+          case "ctrl-l":
+            __privateMethod(this, _TerminalRenderer_instances, repaint_fn).call(this);
+            break;
+          case "escape":
+          case "ctrl-c":
+            __privateMethod(this, _TerminalRenderer_instances, stopInputCursorBlink_fn).call(this);
+            __privateMethod(this, _TerminalRenderer_instances, stop_fn).call(this);
+            reject(interruptedError());
+            break;
+          case "ignore":
+            break;
+        }
+      });
+      __privateMethod(this, _TerminalRenderer_instances, attachInput_fn).call(this);
+    });
+  }
+  async renderStream(result, options) {
+    var _a, _b, _c, _d;
+    __privateMethod(this, _TerminalRenderer_instances, start_fn).call(this, options);
+    __privateSet(this, _inputActive, false);
+    __privateSet(this, _status, processingStatus);
+    __privateMethod(this, _TerminalRenderer_instances, addSubmittedPrompt_fn).call(this, options == null ? void 0 : options.submittedPrompt);
+    __privateSet(this, _interrupted, false);
+    __privateSet(this, _totalTokens, void 0);
+    __privateSet(this, _assistantOutputTokens, void 0);
+    __privateSet(this, _assistantOutputTokensPerSecond, void 0);
+    const displayModes = {
+      tools: (_a = options == null ? void 0 : options.tools) != null ? _a : __privateGet(this, _tools),
+      reasoning: (_b = options == null ? void 0 : options.reasoning) != null ? _b : __privateGet(this, _reasoning),
+      responseStatistics: (_c = options == null ? void 0 : options.responseStatistics) != null ? _c : __privateGet(this, _responseStatistics)
+    };
+    __privateMethod(this, _TerminalRenderer_instances, paint_fn).call(this);
+    const streamInterrupted = new Promise((resolve) => {
+      __privateSet(this, _resolveStreamInterrupt, resolve);
+    });
+    __privateSet(this, _onData, (chunk) => __privateMethod(this, _TerminalRenderer_instances, handleStreamingKey_fn).call(this, chunk));
+    __privateMethod(this, _TerminalRenderer_instances, attachInput_fn).call(this);
+    let responseMessage;
+    const stream = toReadableStream(
+      __privateMethod(this, _TerminalRenderer_instances, observeUIMessageStream_fn).call(this, result.uiMessageStream)
+    );
+    try {
+      const messages = readUIMessageStream({
+        message: result.message,
+        stream,
+        onError: (error) => __privateMethod(this, _TerminalRenderer_instances, addErrorSection_fn).call(this, "Error", formatStreamError(error))
+      });
+      for await (const message of takeUntil(messages, streamInterrupted)) {
+        if (__privateGet(this, _interrupted)) {
+          break;
+        }
+        responseMessage = message;
+        __privateMethod(this, _TerminalRenderer_instances, renderAssistantMessage_fn).call(this, message, displayModes);
+      }
+      if (!__privateGet(this, _interrupted) && responseMessage && __privateGet(this, _assistantOutputTokens) != null) {
+        __privateMethod(this, _TerminalRenderer_instances, renderAssistantMessage_fn).call(this, responseMessage, displayModes);
+      }
+    } finally {
+      __privateSet(this, _resolveStreamInterrupt, void 0);
+      if (__privateGet(this, _interrupted)) {
+        (_d = result.abort) == null ? void 0 : _d.call(result);
+      }
+      __privateMethod(this, _TerminalRenderer_instances, detachInput_fn).call(this);
+      __privateSet(this, _status, __privateGet(this, _interrupted) ? "Interrupted" : (options == null ? void 0 : options.continueSession) ? `Done \xB7 Enter another prompt \xB7 ${activeControls}` : `Done \xB7 ${doneControls}`);
+      __privateMethod(this, _TerminalRenderer_instances, paint_fn).call(this);
+      await __privateMethod(this, _TerminalRenderer_instances, waitForExit_fn).call(this, options);
+      if (__privateGet(this, _interrupted) || !(options == null ? void 0 : options.continueSession)) {
+        __privateMethod(this, _TerminalRenderer_instances, stop_fn).call(this);
+      }
+    }
+    if (__privateGet(this, _interrupted)) {
+      throw interruptedError();
+    }
+    return responseMessage;
+  }
+  async readToolApproval(request, options) {
+    __privateMethod(this, _TerminalRenderer_instances, start_fn).call(this, options);
+    __privateSet(this, _inputActive, false);
+    __privateSet(this, _status, `Approve ${formatToolApprovalTitle(request)}? y/n \xB7 ${activeControls}`);
+    __privateSet(this, _interrupted, false);
+    __privateMethod(this, _TerminalRenderer_instances, paint_fn).call(this);
+    return await new Promise((resolve, reject) => {
+      __privateSet(this, _onData, (chunk) => {
+        const key = parseKey(chunk);
+        switch (key.type) {
+          case "character": {
+            const value = key.value.toLowerCase();
+            if (value === "y") {
+              __privateSet(this, _status, `Approved \xB7 ${processingStatus}`);
+              __privateMethod(this, _TerminalRenderer_instances, detachInput_fn).call(this);
+              __privateMethod(this, _TerminalRenderer_instances, paint_fn).call(this);
+              resolve({ approved: true });
+            } else if (value === "n") {
+              __privateSet(this, _status, `Denied \xB7 ${processingStatus}`);
+              __privateMethod(this, _TerminalRenderer_instances, detachInput_fn).call(this);
+              __privateMethod(this, _TerminalRenderer_instances, paint_fn).call(this);
+              resolve({ approved: false, reason: "Denied by user." });
+            }
+            break;
+          }
+          case "up":
+          case "down":
+            __privateMethod(this, _TerminalRenderer_instances, handleScroll_fn).call(this, key.type);
+            break;
+          case "page-up":
+          case "page-down":
+            __privateMethod(this, _TerminalRenderer_instances, handlePageScroll_fn).call(this, key.type);
+            break;
+          case "ctrl-l":
+            __privateMethod(this, _TerminalRenderer_instances, repaint_fn).call(this);
+            break;
+          case "escape":
+          case "ctrl-c":
+            __privateSet(this, _interrupted, true);
+            __privateMethod(this, _TerminalRenderer_instances, stop_fn).call(this);
+            reject(interruptedError());
+            break;
+          default:
+            break;
+        }
+      });
+      __privateMethod(this, _TerminalRenderer_instances, attachInput_fn).call(this);
+    });
+  }
+};
+_input = new WeakMap();
+_output = new WeakMap();
+_frameBuffer = new WeakMap();
+_tools = new WeakMap();
+_reasoning = new WeakMap();
+_responseStatistics = new WeakMap();
+_defaultContextSize = new WeakMap();
+_sections = new WeakMap();
+_inputText = new WeakMap();
+_inputActive = new WeakMap();
+_scrollOffset = new WeakMap();
+_title = new WeakMap();
+_status = new WeakMap();
+_isInteractive = new WeakMap();
+_interrupted = new WeakMap();
+_totalTokens = new WeakMap();
+_contextSize = new WeakMap();
+_assistantOutputTokens = new WeakMap();
+_assistantOutputTokensPerSecond = new WeakMap();
+_inputCursorVisible = new WeakMap();
+_inputCursorTimer = new WeakMap();
+_onData = new WeakMap();
+_onResize = new WeakMap();
+_resolveStreamInterrupt = new WeakMap();
+_TerminalRenderer_instances = new WeakSet();
+start_fn = function(options) {
+  var _a, _b, _c, _d;
+  __privateSet(this, _title, (_a = options == null ? void 0 : options.title) != null ? _a : __privateGet(this, _title));
+  __privateSet(this, _contextSize, (_b = options == null ? void 0 : options.contextSize) != null ? _b : __privateGet(this, _defaultContextSize));
+  if (__privateGet(this, _isInteractive)) {
+    return;
+  }
+  __privateSet(this, _isInteractive, true);
+  __privateGet(this, _frameBuffer).reset();
+  __privateGet(this, _output).write("\x1B[?1049h\x1B[?25l");
+  if (__privateGet(this, _input).isTTY) {
+    (_d = (_c = __privateGet(this, _input)).setRawMode) == null ? void 0 : _d.call(_c, true);
+    __privateGet(this, _input).resume();
+  }
+  __privateSet(this, _onResize, () => __privateMethod(this, _TerminalRenderer_instances, repaint_fn).call(this));
+  __privateGet(this, _output).on("resize", __privateGet(this, _onResize));
+};
+stop_fn = function() {
+  var _a, _b;
+  __privateMethod(this, _TerminalRenderer_instances, detachInput_fn).call(this);
+  __privateMethod(this, _TerminalRenderer_instances, stopInputCursorBlink_fn).call(this);
+  if (!__privateGet(this, _isInteractive)) {
+    return;
+  }
+  if (__privateGet(this, _input).isTTY) {
+    (_b = (_a = __privateGet(this, _input)).setRawMode) == null ? void 0 : _b.call(_a, false);
+    __privateGet(this, _input).pause();
+  }
+  if (__privateGet(this, _onResize)) {
+    __privateGet(this, _output).off("resize", __privateGet(this, _onResize));
+    __privateSet(this, _onResize, void 0);
+  }
+  __privateGet(this, _output).write("\x1B[?25h\x1B[?1049l");
+  __privateGet(this, _frameBuffer).reset();
+  __privateSet(this, _isInteractive, false);
+};
+attachInput_fn = function() {
+  if (__privateGet(this, _onData)) {
+    __privateGet(this, _input).on("data", __privateGet(this, _onData));
+  }
+};
+detachInput_fn = function() {
+  if (__privateGet(this, _onData)) {
+    __privateGet(this, _input).off("data", __privateGet(this, _onData));
+    __privateSet(this, _onData, void 0);
+  }
+};
+handleStreamingKey_fn = function(chunk) {
+  var _a;
+  const key = parseKey(chunk);
+  switch (key.type) {
+    case "up":
+    case "down":
+      __privateMethod(this, _TerminalRenderer_instances, handleScroll_fn).call(this, key.type);
+      break;
+    case "page-up":
+    case "page-down":
+      __privateMethod(this, _TerminalRenderer_instances, handlePageScroll_fn).call(this, key.type);
+      break;
+    case "ctrl-l":
+      __privateMethod(this, _TerminalRenderer_instances, repaint_fn).call(this);
+      break;
+    case "escape":
+    case "ctrl-c":
+      __privateSet(this, _interrupted, true);
+      (_a = __privateGet(this, _resolveStreamInterrupt)) == null ? void 0 : _a.call(this);
+      break;
+    default:
+      break;
+  }
+};
+handleScroll_fn = function(direction, lines = 1) {
+  const delta = direction === "up" ? lines : -lines;
+  __privateSet(this, _scrollOffset, __privateMethod(this, _TerminalRenderer_instances, clampScrollOffset_fn).call(this, __privateGet(this, _scrollOffset) + delta));
+  __privateMethod(this, _TerminalRenderer_instances, paint_fn).call(this);
+};
+handlePageScroll_fn = function(direction) {
+  __privateMethod(this, _TerminalRenderer_instances, handleScroll_fn).call(this, direction === "page-up" ? "up" : "down", __privateMethod(this, _TerminalRenderer_instances, bodyContentHeight_fn).call(this));
+};
+startInputCursorBlink_fn = function() {
+  var _a, _b;
+  __privateMethod(this, _TerminalRenderer_instances, stopInputCursorBlink_fn).call(this);
+  __privateMethod(this, _TerminalRenderer_instances, showInputCursor_fn).call(this);
+  __privateSet(this, _inputCursorTimer, setInterval(() => {
+    __privateSet(this, _inputCursorVisible, !__privateGet(this, _inputCursorVisible));
+    __privateMethod(this, _TerminalRenderer_instances, paint_fn).call(this);
+  }, inputCursorBlinkMs));
+  (_b = (_a = __privateGet(this, _inputCursorTimer)).unref) == null ? void 0 : _b.call(_a);
+};
+stopInputCursorBlink_fn = function() {
+  if (__privateGet(this, _inputCursorTimer)) {
+    clearInterval(__privateGet(this, _inputCursorTimer));
+    __privateSet(this, _inputCursorTimer, void 0);
+  }
+  __privateSet(this, _inputCursorVisible, true);
+};
+showInputCursor_fn = function() {
+  __privateSet(this, _inputCursorVisible, true);
+};
+addSubmittedPrompt_fn = function(prompt) {
+  if (prompt == null) {
+    return;
+  }
+  const section = __privateGet(this, _sections).at(-1);
+  if ((section == null ? void 0 : section.kind) === "user" && section.content === prompt) {
+    return;
+  }
+  __privateMethod(this, _TerminalRenderer_instances, addUserSection_fn).call(this, prompt);
+};
+addUserSection_fn = function(prompt) {
+  const previousBodyLineCount = __privateMethod(this, _TerminalRenderer_instances, bodyLineCount_fn).call(this);
+  __privateGet(this, _sections).push({ kind: "user", title: "User", content: prompt });
+  __privateMethod(this, _TerminalRenderer_instances, paintAfterBodyChange_fn).call(this, previousBodyLineCount);
+};
+renderAssistantMessage_fn = function(message, displayModes) {
+  var _a, _b, _c;
+  const previousBodyLineCount = __privateMethod(this, _TerminalRenderer_instances, bodyLineCount_fn).call(this);
+  const activeSectionIds = /* @__PURE__ */ new Set();
+  const metadataStats = extractResponseStatisticsFromMetadata(
+    message.metadata
+  );
+  __privateSet(this, _totalTokens, (_a = metadataStats.totalTokens) != null ? _a : __privateGet(this, _totalTokens));
+  __privateSet(this, _assistantOutputTokens, (_b = metadataStats.outputTokens) != null ? _b : __privateGet(this, _assistantOutputTokens));
+  __privateSet(this, _assistantOutputTokensPerSecond, (_c = metadataStats.outputTokensPerSecond) != null ? _c : __privateGet(this, _assistantOutputTokensPerSecond));
+  for (const [index, part] of message.parts.entries()) {
+    const id = sectionId(message.id, index);
+    switch (part.type) {
+      case "text": {
+        const content = part.text.trim();
+        if (content.length === 0) {
+          break;
+        }
+        activeSectionIds.add(id);
+        __privateMethod(this, _TerminalRenderer_instances, upsertSection_fn).call(this, {
+          id,
+          kind: "assistant",
+          title: "Assistant",
+          rightTitle: formatResponseStatistics(
+            {
+              totalTokens: __privateGet(this, _totalTokens),
+              outputTokens: __privateGet(this, _assistantOutputTokens),
+              outputTokensPerSecond: __privateGet(this, _assistantOutputTokensPerSecond)
+            },
+            displayModes.responseStatistics
+          ),
+          content
+        });
+        break;
+      }
+      case "reasoning": {
+        const content = part.text.trim();
+        if (displayModes.reasoning === "hidden" || content.length === 0) {
+          break;
+        }
+        activeSectionIds.add(id);
+        __privateMethod(this, _TerminalRenderer_instances, upsertSection_fn).call(this, {
+          id,
+          kind: "reasoning",
+          title: "Reasoning",
+          content,
+          collapsed: shouldCollapsePart(
+            message,
+            index,
+            displayModes.reasoning,
+            displayModes
+          )
+        });
+        break;
+      }
+      default:
+        if (isToolUIPart(part)) {
+          if (displayModes.tools === "hidden") {
+            break;
+          }
+          activeSectionIds.add(id);
+          __privateMethod(this, _TerminalRenderer_instances, upsertSection_fn).call(this, {
+            id,
+            ...renderToolInvocation(part, {
+              mode: displayModes.tools,
+              collapsed: shouldCollapsePart(
+                message,
+                index,
+                displayModes.tools,
+                displayModes
+              )
+            })
+          });
+        }
+        break;
+    }
+  }
+  __privateMethod(this, _TerminalRenderer_instances, removeStaleAssistantSections_fn).call(this, message.id, activeSectionIds);
+  __privateMethod(this, _TerminalRenderer_instances, paintAfterBodyChange_fn).call(this, previousBodyLineCount);
+};
+upsertSection_fn = function(section) {
+  const existingSection = section.id ? __privateGet(this, _sections).find((candidate) => candidate.id === section.id) : void 0;
+  if (existingSection) {
+    const cache = existingSection.cache;
+    existingSection.kind = section.kind;
+    existingSection.title = section.title;
+    existingSection.rightTitle = section.rightTitle;
+    existingSection.content = section.content;
+    existingSection.collapsed = section.collapsed;
+    existingSection.cache = cache && sectionMatchesCache(section, cache) ? cache : void 0;
+    return;
+  }
+  __privateGet(this, _sections).push(section);
+};
+removeStaleAssistantSections_fn = function(messageId, activeSectionIds) {
+  const prefix = `${messageId}:`;
+  __privateSet(this, _sections, __privateGet(this, _sections).filter(
+    (section) => section.id == null || !section.id.startsWith(prefix) || activeSectionIds.has(section.id)
+  ));
+};
+observeUIMessageStream_fn = async function* (stream) {
+  let hasPendingToolResults = false;
+  for await (const chunk of iterateUIMessageStream(stream)) {
+    const nextStatus = statusForStreamChunk(chunk, { hasPendingToolResults });
+    if (chunk.type === "start-step") {
+      hasPendingToolResults = false;
+    } else if (finishesToolExecution(chunk)) {
+      hasPendingToolResults = true;
+    }
+    if (nextStatus && __privateGet(this, _status) !== nextStatus) {
+      __privateSet(this, _status, nextStatus);
+      __privateMethod(this, _TerminalRenderer_instances, paint_fn).call(this);
+    } else if (startsVisibleAssistantStream(chunk) && __privateGet(this, _status) !== streamingStatus) {
+      __privateSet(this, _status, streamingStatus);
+      __privateMethod(this, _TerminalRenderer_instances, paint_fn).call(this);
+    }
+    if (chunk.type === "error") {
+      __privateMethod(this, _TerminalRenderer_instances, addErrorSection_fn).call(this, "Error", chunk.errorText);
+    }
+    if (chunk.type === "finish") {
+      const stats = extractResponseStatistics(chunk);
+      __privateSet(this, _totalTokens, stats.totalTokens);
+      __privateSet(this, _assistantOutputTokens, stats.outputTokens);
+      __privateSet(this, _assistantOutputTokensPerSecond, stats.outputTokensPerSecond);
+    }
+    yield chunk;
+  }
+};
+addErrorSection_fn = function(title, content) {
+  const previousBodyLineCount = __privateMethod(this, _TerminalRenderer_instances, bodyLineCount_fn).call(this);
+  __privateGet(this, _sections).push({ kind: "error", title, content });
+  __privateMethod(this, _TerminalRenderer_instances, paintAfterBodyChange_fn).call(this, previousBodyLineCount);
+};
+paintAfterBodyChange_fn = function(previousBodyLineCount) {
+  if (__privateGet(this, _scrollOffset) !== 0) {
+    const bodyLineDelta = __privateMethod(this, _TerminalRenderer_instances, bodyLineCount_fn).call(this) - previousBodyLineCount;
+    __privateSet(this, _scrollOffset, __privateMethod(this, _TerminalRenderer_instances, clampScrollOffset_fn).call(this, __privateGet(this, _scrollOffset) + bodyLineDelta));
+  }
+  __privateMethod(this, _TerminalRenderer_instances, paint_fn).call(this);
+};
+paint_fn = function() {
+  const frame = renderScreenViewport({
+    width: __privateMethod(this, _TerminalRenderer_instances, width_fn).call(this),
+    height: __privateMethod(this, _TerminalRenderer_instances, height_fn).call(this),
+    title: __privateGet(this, _title),
+    rightTitle: formatTokenCount(__privateGet(this, _totalTokens), __privateGet(this, _contextSize)),
+    visibleBodyLines: __privateMethod(this, _TerminalRenderer_instances, visibleBodyLines_fn).call(this),
+    input: __privateGet(this, _inputText),
+    inputActive: __privateGet(this, _inputActive),
+    inputCursorVisible: __privateGet(this, _inputCursorVisible),
+    status: __privateGet(this, _status)
+  });
+  __privateGet(this, _frameBuffer).present(frame);
+};
+repaint_fn = function() {
+  __privateGet(this, _frameBuffer).reset();
+  __privateMethod(this, _TerminalRenderer_instances, paint_fn).call(this);
+};
+visibleBodyLines_fn = function() {
+  if (__privateGet(this, _sections).length === 0) {
+    return ["Waiting for input..."];
+  }
+  const bodyContentHeight = __privateMethod(this, _TerminalRenderer_instances, bodyContentHeight_fn).call(this);
+  const totalLineCount = __privateMethod(this, _TerminalRenderer_instances, bodyLineCount_fn).call(this);
+  const start = Math.max(
+    0,
+    totalLineCount - bodyContentHeight - __privateGet(this, _scrollOffset)
+  );
+  const end = start + bodyContentHeight;
+  const visibleLines = [];
+  let sectionStart = 0;
+  for (const section of __privateGet(this, _sections)) {
+    const sectionLines = renderSectionLines(section, __privateMethod(this, _TerminalRenderer_instances, width_fn).call(this) - 4);
+    const sectionEnd = sectionStart + sectionLines.length;
+    if (sectionEnd > start && sectionStart < end) {
+      visibleLines.push(
+        ...sectionLines.slice(
+          Math.max(0, start - sectionStart),
+          end - sectionStart
+        )
+      );
+    }
+    if (visibleLines.length >= bodyContentHeight) {
+      break;
+    }
+    sectionStart = sectionEnd;
+  }
+  return visibleLines;
+};
+clampScrollOffset_fn = function(scrollOffset) {
+  const maxScrollOffset = Math.max(
+    0,
+    __privateMethod(this, _TerminalRenderer_instances, bodyLineCount_fn).call(this) - __privateMethod(this, _TerminalRenderer_instances, bodyContentHeight_fn).call(this)
+  );
+  return Math.min(Math.max(0, scrollOffset), maxScrollOffset);
+};
+bodyLineCount_fn = function() {
+  if (__privateGet(this, _sections).length === 0) {
+    return 1;
+  }
+  let count = 0;
+  for (const section of __privateGet(this, _sections)) {
+    count += renderSectionLines(section, __privateMethod(this, _TerminalRenderer_instances, width_fn).call(this) - 4).length;
+  }
+  return count;
+};
+bodyContentHeight_fn = function() {
+  return Math.max(1, __privateMethod(this, _TerminalRenderer_instances, height_fn).call(this) - 5);
+};
+width_fn = function() {
+  var _a;
+  return Math.max(20, (_a = __privateGet(this, _output).columns) != null ? _a : 80);
+};
+height_fn = function() {
+  var _a;
+  return Math.max(8, (_a = __privateGet(this, _output).rows) != null ? _a : 24);
+};
+waitForExit_fn = async function(options) {
+  if ((options == null ? void 0 : options.waitForExit) === false || !__privateGet(this, _input).isTTY || __privateGet(this, _interrupted)) {
+    return;
+  }
+  await new Promise((resolve) => {
+    __privateSet(this, _onData, (chunk) => {
+      const key = parseKey(chunk);
+      switch (key.type) {
+        case "up":
+        case "down":
+          __privateMethod(this, _TerminalRenderer_instances, handleScroll_fn).call(this, key.type);
+          break;
+        case "page-up":
+        case "page-down":
+          __privateMethod(this, _TerminalRenderer_instances, handlePageScroll_fn).call(this, key.type);
+          break;
+        case "ctrl-l":
+          __privateMethod(this, _TerminalRenderer_instances, repaint_fn).call(this);
+          break;
+        case "escape":
+          __privateMethod(this, _TerminalRenderer_instances, detachInput_fn).call(this);
+          resolve();
+          break;
+        case "character":
+          if (key.value === "q") {
+            __privateMethod(this, _TerminalRenderer_instances, detachInput_fn).call(this);
+            resolve();
+          }
+          break;
+        case "ctrl-c":
+          __privateMethod(this, _TerminalRenderer_instances, detachInput_fn).call(this);
+          process.exitCode = 130;
+          resolve();
+          break;
+        default:
+          break;
+      }
+    });
+    __privateMethod(this, _TerminalRenderer_instances, attachInput_fn).call(this);
+  });
+};
+function interruptedError() {
+  return new Error("Interrupted");
+}
+async function* takeUntil(source, stop) {
+  const iterator = source[Symbol.asyncIterator]();
+  const stopped = stop.then(
+    () => ({ done: true, value: void 0 })
+  );
+  while (true) {
+    const nextValue = await Promise.race([iterator.next(), stopped]);
+    if (nextValue.done) {
+      break;
+    }
+    yield nextValue.value;
+  }
+}
+function formatStreamError(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  return JSON.stringify(error);
+}
+function renderToolInvocation(part, options) {
+  var _a, _b, _c, _d;
+  const toolName = getToolName(part);
+  const title = `Tool \xB7 ${(_a = part.title) != null ? _a : toolName}`;
+  const input = "input" in part ? part.input : void 0;
+  const inputText = input === void 0 ? "Input: (streaming...)" : `Input:
+${formatValue(input)}`;
+  const status = toolStatus(part);
+  if (options.collapsed) {
+    return {
+      kind: "tool",
+      title,
+      rightTitle: status,
+      content: "",
+      collapsed: true
+    };
+  }
+  switch (part.state) {
+    case "input-streaming":
+      return {
+        kind: "tool",
+        title,
+        rightTitle: status,
+        content: inputText
+      };
+    case "input-available":
+      return {
+        kind: "tool",
+        title,
+        rightTitle: status,
+        content: inputText
+      };
+    case "approval-requested":
+      return {
+        kind: "tool",
+        title,
+        rightTitle: status,
+        content: inputText
+      };
+    case "approval-responded":
+      return {
+        kind: "tool",
+        title,
+        rightTitle: status,
+        content: inputText
+      };
+    case "output-available":
+      return {
+        kind: "tool",
+        title,
+        rightTitle: status,
+        content: `${inputText}
+
+Output:
+${formatValue(part.output)}`
+      };
+    case "output-error":
+      return {
+        kind: "error",
+        title: `Tool Error \xB7 ${(_b = part.title) != null ? _b : toolName}`,
+        rightTitle: status,
+        content: `${inputText}
+
+Error:
+${part.errorText}`
+      };
+    case "output-denied":
+      return {
+        kind: "error",
+        title: `Tool Denied \xB7 ${(_c = part.title) != null ? _c : toolName}`,
+        rightTitle: status,
+        content: `${inputText}
+
+Reason: ${(_d = part.approval.reason) != null ? _d : "denied"}`
+      };
+  }
+}
+function shouldCollapsePart(message, partIndex, mode, displayModes) {
+  switch (mode) {
+    case "collapsed":
+      return true;
+    case "auto-collapsed":
+      return message.parts.slice(partIndex + 1).some((part) => isVisibleAssistantPart(part, displayModes));
+    case "full":
+    case "hidden":
+      return false;
+  }
+}
+function isVisibleAssistantPart(part, displayModes) {
+  switch (part.type) {
+    case "text":
+      return part.text.trim().length > 0;
+    case "reasoning":
+      return displayModes.reasoning !== "hidden" && part.text.trim().length > 0;
+    default:
+      return isToolUIPart(part) && displayModes.tools !== "hidden";
+  }
+}
+function startsVisibleAssistantStream(chunk) {
+  switch (chunk.type) {
+    case "text-start":
+    case "text-delta":
+    case "reasoning-start":
+    case "reasoning-delta":
+    case "tool-input-start":
+    case "tool-input-delta":
+      return true;
+    default:
+      return false;
+  }
+}
+function statusForStreamChunk(chunk, { hasPendingToolResults }) {
+  switch (chunk.type) {
+    case "start-step":
+      return hasPendingToolResults ? processingToolResultsStatus : processingStatus;
+    case "tool-output-available":
+    case "tool-output-error":
+    case "tool-output-denied":
+      return processingToolResultsStatus;
+    case "tool-input-available":
+      return executingToolsStatus;
+    case "tool-approval-response":
+      return chunk.approved ? executingToolsStatus : void 0;
+    default:
+      return void 0;
+  }
+}
+function finishesToolExecution(chunk) {
+  switch (chunk.type) {
+    case "tool-output-available":
+    case "tool-output-error":
+    case "tool-output-denied":
+      return true;
+    default:
+      return false;
+  }
+}
+function toolStatus(part) {
+  switch (part.state) {
+    case "input-streaming":
+      return "waiting";
+    case "approval-requested":
+      return "approval requested";
+    case "input-available":
+      return "executing";
+    case "approval-responded":
+      return part.approval.approved ? "executing" : "denied";
+    case "output-available":
+    case "output-error":
+      return "done";
+    case "output-denied":
+      return "denied";
+  }
+}
+function formatValue(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  return JSON.stringify(value, null, 2);
+}
+function formatToolApprovalTitle(request) {
+  var _a;
+  return `tool ${(_a = request.title) != null ? _a : request.toolName}`;
+}
+function sectionId(messageId, partIndex) {
+  return `${messageId}:${partIndex}`;
+}
+function toReadableStream(stream) {
+  if (stream instanceof ReadableStream) {
+    return stream;
+  }
+  return new ReadableStream({
+    async start(controller) {
+      try {
+        for await (const chunk of stream) {
+          controller.enqueue(chunk);
+        }
+        controller.close();
+      } catch (error) {
+        controller.error(error);
+      }
+    }
+  });
+}
+async function* iterateUIMessageStream(stream) {
+  if (stream instanceof ReadableStream) {
+    const reader = stream.getReader();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          return;
+        }
+        yield value;
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    return;
+  }
+  yield* stream;
+}
+function renderSectionLines(section, width) {
+  if (section.cache && sectionMatchesCache(section, section.cache, width)) {
+    return section.cache.lines;
+  }
+  const lines = createSectionLines(section, width);
+  section.cache = {
+    width,
+    kind: section.kind,
+    title: section.title,
+    rightTitle: section.rightTitle,
+    content: section.content,
+    collapsed: section.collapsed === true,
+    lines
+  };
+  return lines;
+}
+function sectionMatchesCache(section, cache, width = cache.width) {
+  return cache.width === width && cache.kind === section.kind && cache.title === section.title && cache.rightTitle === section.rightTitle && cache.content === section.content && cache.collapsed === (section.collapsed === true);
+}
+function createSectionLines(section, width) {
+  const style = sectionStyles[section.kind];
+  const contentWidth = Math.max(1, width - 4);
+  const title = ` ${section.title} `;
+  const rightTitle = section.rightTitle ? ` ${section.rightTitle} ` : "";
+  if (section.collapsed) {
+    const borderWidth2 = Math.max(
+      0,
+      width - 2 - title.length - rightTitle.length
+    );
+    const top2 = `${style.color}\u256D${title}${style.border.repeat(borderWidth2)}${rightTitle}\u256E${colors.reset}`;
+    const bottom2 = `${style.color}\u2570${style.border.repeat(Math.max(0, width - 2))}\u256F${colors.reset}`;
+    return [top2, bottom2];
+  }
+  const borderWidth = Math.max(0, width - 2 - title.length - rightTitle.length);
+  const top = `${style.color}\u256D${title}${style.border.repeat(borderWidth)}${rightTitle}\u256E${colors.reset}`;
+  const bottom = `${style.color}\u2570${style.border.repeat(Math.max(0, width - 2))}\u256F${colors.reset}`;
+  const content = section.content.length > 0 ? renderMarkdown(section.content) : colors.dim + "(streaming...)" + colors.reset;
+  const lines = content.split("\n").flatMap((line) => wrapVisibleLine(line, contentWidth));
+  return [
+    top,
+    ...lines.map((line) => sectionLine(line, contentWidth, style.color)),
+    bottom
+  ];
+}
+function sectionLine(line, contentWidth, color) {
+  const visible = sliceVisible(line, contentWidth);
+  const padding = " ".repeat(
+    Math.max(0, contentWidth - visibleLength(visible))
+  );
+  return `${color}\u2502${colors.reset} ${visible}${padding} ${color}\u2502${colors.reset}`;
+}
+function wrapVisibleLine(line, width) {
+  if (line.length === 0) {
+    return [""];
+  }
+  const lines = [];
+  let remaining = line;
+  while (visibleLength(remaining) > width) {
+    const breakAt = findVisibleBreakPoint(remaining, width);
+    lines.push(remaining.slice(0, breakAt).trimEnd());
+    remaining = remaining.slice(breakAt).trimStart();
+  }
+  lines.push(remaining);
+  return lines;
+}
+function findVisibleBreakPoint(input, width) {
+  const slice = sliceVisible(input, width + 1);
+  const lastSpace = slice.lastIndexOf(" ");
+  if (lastSpace > 0) {
+    return lastSpace;
+  }
+  return sliceVisible(input, width).length;
+}
+function extractResponseStatistics(chunk) {
+  var _a, _b;
+  const usage = "usage" in chunk ? chunk.usage : void 0;
+  const metadataUsage = "messageMetadata" in chunk ? (_a = chunk.messageMetadata) == null ? void 0 : _a.usage : void 0;
+  const metadataPerformance = "messageMetadata" in chunk ? (_b = chunk.messageMetadata) == null ? void 0 : _b.performance : void 0;
+  return {
+    totalTokens: extractTotalTokenCountFromUsage(usage != null ? usage : metadataUsage),
+    outputTokens: extractOutputTokenCountFromUsage(usage != null ? usage : metadataUsage),
+    outputTokensPerSecond: metadataPerformance == null ? void 0 : metadataPerformance.outputTokensPerSecond
+  };
+}
+function extractResponseStatisticsFromMetadata(metadata) {
+  var _a;
+  const stats = metadata;
+  return {
+    totalTokens: extractTotalTokenCountFromUsage(stats == null ? void 0 : stats.usage),
+    outputTokens: extractOutputTokenCountFromUsage(stats == null ? void 0 : stats.usage),
+    outputTokensPerSecond: (_a = stats == null ? void 0 : stats.performance) == null ? void 0 : _a.outputTokensPerSecond
+  };
+}
+function extractTotalTokenCountFromUsage(usage) {
+  const totalTokens = usage == null ? void 0 : usage.totalTokens;
+  if (typeof totalTokens === "number") {
+    return totalTokens;
+  }
+  if (typeof (totalTokens == null ? void 0 : totalTokens.total) === "number") {
+    return totalTokens.total;
+  }
+  const inputTokens = extractInputTokenCountFromUsage(usage);
+  const outputTokens = extractOutputTokenCountFromUsage(usage);
+  if (inputTokens != null && outputTokens != null) {
+    return inputTokens + outputTokens;
+  }
+  return void 0;
+}
+function extractInputTokenCountFromUsage(usage) {
+  const inputTokens = usage == null ? void 0 : usage.inputTokens;
+  if (typeof inputTokens === "number") {
+    return inputTokens;
+  }
+  if (typeof (inputTokens == null ? void 0 : inputTokens.total) === "number") {
+    return inputTokens.total;
+  }
+  return usage == null ? void 0 : usage.promptTokens;
+}
+function extractOutputTokenCountFromUsage(usage) {
+  const outputTokens = usage == null ? void 0 : usage.outputTokens;
+  if (typeof outputTokens === "number") {
+    return outputTokens;
+  }
+  if (typeof (outputTokens == null ? void 0 : outputTokens.total) === "number") {
+    return outputTokens.total;
+  }
+  return usage == null ? void 0 : usage.completionTokens;
+}
+function formatTokenCount(tokens, contextSize) {
+  if (tokens == null) {
+    return void 0;
+  }
+  const tokenCount = `${tokens.toLocaleString()} ${tokens === 1 ? "token" : "tokens"}`;
+  const contextPercentage = formatContextPercentage(tokens, contextSize);
+  return contextPercentage == null ? tokenCount : `${tokenCount} ${contextPercentage}`;
+}
+function formatContextPercentage(tokens, contextSize) {
+  if (contextSize == null || contextSize <= 0 || !Number.isFinite(contextSize)) {
+    return void 0;
+  }
+  return `${Math.round(tokens / contextSize * 100).toLocaleString()}%`;
+}
+function formatResponseStatistics(stats, mode) {
+  if (mode === "outputTokensPerSecond") {
+    return formatOutputTokensPerSecond(stats.outputTokensPerSecond);
+  }
+  return formatTokenCount(stats.outputTokens);
+}
+function formatOutputTokensPerSecond(outputTokensPerSecond) {
+  if (outputTokensPerSecond == null) {
+    return void 0;
+  }
+  return `${formatNumber(outputTokensPerSecond)} tok/s`;
+}
+function formatNumber(value) {
+  return Number.isInteger(value) ? value.toLocaleString() : value.toLocaleString(void 0, { maximumFractionDigits: 1 });
+}
+function parseKey(chunk) {
+  const value = chunk.toString("utf8");
+  switch (value) {
+    case "\f":
+      return { type: "ctrl-l" };
+    case "":
+      return { type: "ctrl-c" };
+    case "\x1B":
+      return { type: "escape" };
+    case "\r":
+    case "\n":
+      return { type: "enter" };
+    case "\x7F":
+    case "\b":
+      return { type: "backspace" };
+    case "\x1B[A":
+      return { type: "up" };
+    case "\x1B[B":
+      return { type: "down" };
+    case "\x1B[5~":
+      return { type: "page-up" };
+    case "\x1B[6~":
+      return { type: "page-down" };
+    default:
+      if (value >= " " && value !== "\x7F") {
+        return { type: "character", value };
+      }
+      return { type: "ignore" };
+  }
+}
+
+// src/agent-tui-runner.ts
+import {
+  convertToModelMessages,
+  getToolName as getToolName2,
+  isToolUIPart as isToolUIPart2
+} from "ai";
+var defaultResponseStatistics2 = "outputTokensPerSecond";
+var AgentTUIRunner = class {
+  constructor(options) {
+    var _a, _b, _c, _d;
+    this.agent = options.agent;
+    this.renderer = (_a = createRenderer(options)) != null ? _a : createDefaultRenderer(options);
+    this.title = options.title;
+    this.tools = (_b = options.tools) != null ? _b : "auto-collapsed";
+    this.reasoning = (_c = options.reasoning) != null ? _c : "auto-collapsed";
+    this.responseStatistics = (_d = options.responseStatistics) != null ? _d : defaultResponseStatistics2;
+    this.contextSize = options.contextSize;
+  }
+  async run() {
+    const title = this.title;
+    const messages = [];
+    let nextMessageIndex = 0;
+    const generateMessageId = () => `message-${++nextMessageIndex}`;
+    let prompt;
+    let hasRunTurn = false;
+    let streamWithoutPrompt = false;
+    while (true) {
+      if (!streamWithoutPrompt) {
+        if (prompt == null) {
+          if (!this.renderer.readPrompt) {
+            if (hasRunTurn) {
+              return;
+            }
+            throw new Error(
+              "No prompt was provided and the renderer does not support prompt input."
+            );
+          }
+          try {
+            prompt = await this.renderer.readPrompt({ title });
+          } catch (error) {
+            if (isInterruptedError(error)) {
+              return;
+            }
+            throw error;
+          }
+          if (prompt == null) {
+            return;
+          }
+        }
+        messages.push(createUserMessage(generateMessageId(), prompt));
+        hasRunTurn = true;
+      }
+      const result = await this.streamMessages(
+        [...messages],
+        generateMessageId
+      );
+      try {
+        const responseMessage = await this.renderer.renderStream(result, {
+          title,
+          submittedPrompt: prompt,
+          continueSession: Boolean(this.renderer.readPrompt),
+          tools: this.tools,
+          reasoning: this.reasoning,
+          responseStatistics: this.responseStatistics,
+          contextSize: this.contextSize,
+          waitForExit: false
+        });
+        if (responseMessage && responseMessage.parts.length > 0) {
+          const approvalRequests = findPendingToolApprovalRequests(responseMessage);
+          if (approvalRequests.length > 0) {
+            if (!this.renderer.readToolApproval) {
+              throw new Error(
+                "Tool approval was requested, but the renderer does not support tool approval input."
+              );
+            }
+            for (const request of approvalRequests) {
+              const response = await this.renderer.readToolApproval(request, {
+                title
+              });
+              applyToolApprovalResponse(responseMessage, request, response);
+            }
+            upsertResponseMessage(
+              messages,
+              responseMessage,
+              streamWithoutPrompt
+            );
+            streamWithoutPrompt = true;
+            prompt = void 0;
+            continue;
+          }
+          upsertResponseMessage(messages, responseMessage, streamWithoutPrompt);
+        }
+      } catch (error) {
+        if (isInterruptedError(error)) {
+          return;
+        }
+        throw error;
+      }
+      streamWithoutPrompt = false;
+      prompt = void 0;
+    }
+  }
+  async streamMessages(messages, generateMessageId) {
+    const abortController = new AbortController();
+    const result = await this.agent.stream({
+      prompt: await convertToModelMessages(messages, {
+        tools: this.agent.tools
+      }),
+      abortSignal: abortController.signal,
+      options: void 0
+    });
+    return {
+      uiMessageStream: textStreamToUIMessageStream(
+        result.fullStream,
+        generateMessageId,
+        messages
+      ),
+      message: lastAssistantMessage(messages),
+      abort: () => abortController.abort()
+    };
+  }
+};
+function createDefaultRenderer(options) {
+  return options.tools === void 0 && options.reasoning === void 0 && options.responseStatistics === void 0 && options.contextSize === void 0 ? new TerminalRenderer() : new TerminalRenderer({
+    tools: options.tools,
+    reasoning: options.reasoning,
+    responseStatistics: options.responseStatistics,
+    contextSize: options.contextSize
+  });
+}
+function createRenderer(options) {
+  if (options.renderer) {
+    return options.renderer;
+  }
+  if (!options.screen && !options.userInput) {
+    return void 0;
+  }
+  return new TerminalRenderer({
+    tools: options.tools,
+    reasoning: options.reasoning,
+    responseStatistics: options.responseStatistics,
+    contextSize: options.contextSize,
+    input: options.userInput,
+    output: options.screen
+  });
+}
+async function* textStreamToUIMessageStream(stream, generateMessageId, originalMessages = []) {
+  var _a, _b;
+  const openTextParts = /* @__PURE__ */ new Set();
+  const openReasoningParts = /* @__PURE__ */ new Set();
+  const openToolCalls = /* @__PURE__ */ new Set();
+  let latestStepUsage;
+  let latestPerformance;
+  let sentFinish = false;
+  yield {
+    type: "start",
+    messageId: (_b = (_a = lastAssistantMessage(originalMessages)) == null ? void 0 : _a.id) != null ? _b : generateMessageId()
+  };
+  for await (const part of stream) {
+    switch (part.type) {
+      case "text-start":
+        openTextParts.add(part.id);
+        yield {
+          type: "text-start",
+          id: part.id,
+          providerMetadata: part.providerMetadata
+        };
+        break;
+      case "text-delta":
+        if (!openTextParts.has(part.id)) {
+          openTextParts.add(part.id);
+          yield {
+            type: "text-start",
+            id: part.id,
+            providerMetadata: part.providerMetadata
+          };
+        }
+        yield {
+          type: "text-delta",
+          id: part.id,
+          delta: part.text,
+          providerMetadata: part.providerMetadata
+        };
+        break;
+      case "text-end":
+        openTextParts.delete(part.id);
+        yield {
+          type: "text-end",
+          id: part.id,
+          providerMetadata: part.providerMetadata
+        };
+        break;
+      case "reasoning-start":
+        openReasoningParts.add(part.id);
+        yield {
+          type: "reasoning-start",
+          id: part.id,
+          providerMetadata: part.providerMetadata
+        };
+        break;
+      case "reasoning-delta":
+        if (!openReasoningParts.has(part.id)) {
+          openReasoningParts.add(part.id);
+          yield {
+            type: "reasoning-start",
+            id: part.id,
+            providerMetadata: part.providerMetadata
+          };
+        }
+        yield {
+          type: "reasoning-delta",
+          id: part.id,
+          delta: part.text,
+          providerMetadata: part.providerMetadata
+        };
+        break;
+      case "reasoning-end":
+        openReasoningParts.delete(part.id);
+        yield {
+          type: "reasoning-end",
+          id: part.id,
+          providerMetadata: part.providerMetadata
+        };
+        break;
+      case "tool-input-start":
+        yield {
+          type: "tool-input-start",
+          toolCallId: part.id,
+          toolName: part.toolName,
+          providerExecuted: part.providerExecuted,
+          providerMetadata: part.providerMetadata,
+          toolMetadata: part.toolMetadata,
+          dynamic: part.dynamic,
+          title: part.title
+        };
+        break;
+      case "tool-input-delta":
+        yield {
+          type: "tool-input-delta",
+          toolCallId: part.id,
+          inputTextDelta: part.delta
+        };
+        break;
+      case "tool-call":
+        openToolCalls.add(part.toolCallId);
+        yield {
+          type: "tool-input-available",
+          toolCallId: part.toolCallId,
+          toolName: part.toolName,
+          input: part.input,
+          providerExecuted: part.providerExecuted,
+          providerMetadata: part.providerMetadata,
+          toolMetadata: part.toolMetadata,
+          dynamic: part.dynamic,
+          title: part.title
+        };
+        break;
+      case "tool-approval-request":
+        if (!openToolCalls.has(part.toolCall.toolCallId)) {
+          openToolCalls.add(part.toolCall.toolCallId);
+          yield {
+            type: "tool-input-available",
+            toolCallId: part.toolCall.toolCallId,
+            toolName: part.toolCall.toolName,
+            input: part.toolCall.input,
+            providerExecuted: part.toolCall.providerExecuted,
+            providerMetadata: part.toolCall.providerMetadata,
+            toolMetadata: part.toolCall.toolMetadata,
+            dynamic: part.toolCall.dynamic,
+            title: part.toolCall.title
+          };
+        }
+        yield {
+          type: "tool-approval-request",
+          approvalId: part.approvalId,
+          toolCallId: part.toolCall.toolCallId,
+          isAutomatic: part.isAutomatic
+        };
+        break;
+      case "tool-approval-response":
+        yield {
+          type: "tool-approval-response",
+          approvalId: part.approvalId,
+          approved: part.approved,
+          reason: part.reason,
+          providerExecuted: part.providerExecuted
+        };
+        break;
+      case "tool-result":
+        yield {
+          type: "tool-output-available",
+          toolCallId: part.toolCallId,
+          output: part.output,
+          providerExecuted: part.providerExecuted,
+          providerMetadata: part.providerMetadata,
+          toolMetadata: part.toolMetadata,
+          dynamic: part.dynamic,
+          preliminary: part.preliminary
+        };
+        break;
+      case "tool-error":
+        yield {
+          type: "tool-output-error",
+          toolCallId: part.toolCallId,
+          errorText: formatStreamError2(part.error),
+          providerExecuted: part.providerExecuted,
+          providerMetadata: part.providerMetadata,
+          toolMetadata: part.toolMetadata,
+          dynamic: part.dynamic
+        };
+        break;
+      case "tool-output-denied":
+        yield { type: "tool-output-denied", toolCallId: part.toolCallId };
+        break;
+      case "source":
+        if (part.sourceType === "url") {
+          yield {
+            type: "source-url",
+            sourceId: part.id,
+            url: part.url,
+            title: part.title,
+            providerMetadata: part.providerMetadata
+          };
+        } else {
+          yield {
+            type: "source-document",
+            sourceId: part.id,
+            mediaType: part.mediaType,
+            title: part.title,
+            filename: part.filename,
+            providerMetadata: part.providerMetadata
+          };
+        }
+        break;
+      case "file":
+        yield {
+          type: "file",
+          url: fileToDataUrl(part.file.mediaType, part.file.base64),
+          mediaType: part.file.mediaType,
+          providerMetadata: part.providerMetadata
+        };
+        break;
+      case "reasoning-file":
+        yield {
+          type: "reasoning-file",
+          url: fileToDataUrl(part.file.mediaType, part.file.base64),
+          mediaType: part.file.mediaType,
+          providerMetadata: part.providerMetadata
+        };
+        break;
+      case "start-step":
+        yield { type: "start-step" };
+        break;
+      case "finish-step":
+        latestStepUsage = part.usage;
+        latestPerformance = part.performance;
+        yield { type: "finish-step" };
+        break;
+      case "finish":
+        yield* closeOpenParts(openTextParts, openReasoningParts);
+        sentFinish = true;
+        yield {
+          type: "finish",
+          finishReason: part.finishReason,
+          messageMetadata: createResponseMetadata(
+            latestStepUsage != null ? latestStepUsage : part.totalUsage,
+            latestPerformance
+          )
+        };
+        break;
+      case "abort":
+        yield { type: "abort", reason: part.reason };
+        break;
+      case "error":
+        yield { type: "error", errorText: formatStreamError2(part.error) };
+        break;
+    }
+  }
+  if (!sentFinish) {
+    yield* closeOpenParts(openTextParts, openReasoningParts);
+    yield { type: "finish" };
+  }
+}
+function createResponseMetadata(usage, performance) {
+  if ((usage == null ? void 0 : usage.totalTokens) == null && (usage == null ? void 0 : usage.outputTokens) == null && (performance == null ? void 0 : performance.outputTokensPerSecond) == null) {
+    return void 0;
+  }
+  return {
+    ...(usage == null ? void 0 : usage.totalTokens) == null && (usage == null ? void 0 : usage.outputTokens) == null ? {} : {
+      usage: {
+        ...usage.totalTokens == null ? {} : { totalTokens: usage.totalTokens },
+        ...usage.outputTokens == null ? {} : { outputTokens: usage.outputTokens }
+      }
+    },
+    ...(performance == null ? void 0 : performance.outputTokensPerSecond) == null ? {} : {
+      performance: {
+        outputTokensPerSecond: performance.outputTokensPerSecond
+      }
+    }
+  };
+}
+function* closeOpenParts(textPartIds, reasoningPartIds) {
+  for (const id of textPartIds) {
+    yield { type: "text-end", id };
+  }
+  textPartIds.clear();
+  for (const id of reasoningPartIds) {
+    yield { type: "reasoning-end", id };
+  }
+  reasoningPartIds.clear();
+}
+function createUserMessage(id, text) {
+  return {
+    id,
+    role: "user",
+    parts: [{ type: "text", text }]
+  };
+}
+function upsertResponseMessage(messages, responseMessage, replaceLast) {
+  var _a;
+  if (replaceLast && ((_a = messages.at(-1)) == null ? void 0 : _a.role) === "assistant") {
+    messages[messages.length - 1] = responseMessage;
+    return;
+  }
+  messages.push(responseMessage);
+}
+function lastAssistantMessage(messages) {
+  const message = messages.at(-1);
+  return (message == null ? void 0 : message.role) === "assistant" ? message : void 0;
+}
+function findPendingToolApprovalRequests(message) {
+  const requests = [];
+  for (const [index, part] of message.parts.entries()) {
+    if (!isToolUIPart2(part) || part.state !== "approval-requested" || part.approval.isAutomatic === true) {
+      continue;
+    }
+    requests.push({
+      approvalId: part.approval.id,
+      toolCallId: part.toolCallId,
+      toolName: getToolName2(part),
+      title: part.title,
+      input: part.input,
+      providerExecuted: part.providerExecuted,
+      messageId: message.id,
+      partIndex: index
+    });
+  }
+  return requests;
+}
+function applyToolApprovalResponse(message, request, response) {
+  const part = message.parts[request.partIndex];
+  if (!part || !isToolUIPart2(part) || part.toolCallId !== request.toolCallId) {
+    throw new Error(
+      `Could not find tool approval request ${request.approvalId}.`
+    );
+  }
+  part.state = "approval-responded";
+  part.approval = {
+    id: request.approvalId,
+    approved: response.approved,
+    ...response.reason ? { reason: response.reason } : {}
+  };
+}
+function formatStreamError2(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  return JSON.stringify(error);
+}
+function fileToDataUrl(mediaType, base64) {
+  return `data:${mediaType};base64,${base64}`;
+}
+function isInterruptedError(error) {
+  return error instanceof Error && error.message === "Interrupted";
+}
+
+// src/run-agent-tui.ts
+async function runAgentTUI(options) {
+  await new AgentTUIRunner(options).run();
+}
+export {
+  runAgentTUI
+};
+//# sourceMappingURL=index.js.map