plugsuits 1.0.0

package/dist/interaction/pi-tui-stream-renderer.js

@@ -0,0 +1,1509 @@
+import { Container, Markdown, Spacer, Text, truncateToWidth, visibleWidth, } from "@mariozechner/pi-tui";
+import { parsePartialJson } from "ai";
+const addChatComponent = (chatContainer, component, options = {}) => {
+    if (options.addLeadingSpacer ?? true) {
+        chatContainer.addChild(new Spacer(1));
+    }
+    chatContainer.addChild(component);
+};
+const safeStringify = (value) => {
+    if (typeof value === "string") {
+        return value;
+    }
+    try {
+        return JSON.stringify(value, null, 2);
+    }
+    catch {
+        return String(value);
+    }
+};
+const isPlainEmptyObject = (value) => {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    if (Array.isArray(value)) {
+        return false;
+    }
+    return Object.keys(value).length === 0;
+};
+const renderCodeBlock = (language, value) => {
+    const text = safeStringify(value).replace(TRAILING_NEWLINES, "");
+    const longestFenceRun = Array.from(text.matchAll(BACKTICK_FENCE_PATTERN)).reduce((max, match) => Math.max(max, match[0].length), 2);
+    const fence = "`".repeat(longestFenceRun + 1);
+    return `${fence}${language}\n${text}\n${fence}`;
+};
+const READ_FILE_SUCCESS_PREFIX = "OK - read file";
+const GLOB_SUCCESS_PREFIX = "OK - glob";
+const GREP_SUCCESS_PREFIX = "OK - grep";
+const SHELL_EXECUTE_TOOL_NAMES = new Set(["shell_execute", "bash"]);
+const SHELL_TOOL_NAMES = new Set(["shell_execute", "bash", "shell_interact"]);
+const UNKNOWN_TOOL_NAME = "tool";
+const READ_FILE_BLOCK_PREFIX = "======== ";
+const READ_FILE_BLOCK_SUFFIX = " ========";
+const READ_FILE_BLOCK_END = "======== end ========";
+const BACKTICK_FENCE_PATTERN = /`{3,}/g;
+const READ_FILE_LINE_SPLIT_PATTERN = /^(\s*\d+(?:#[^\s|]+)?\s*\|\s*)(.*)$/;
+const READ_FILE_LINES_WITH_RETURNED_PATTERN = /^(\d+)\s+\(returned:\s*(\d+)\)$/;
+const READ_FILE_MARKDOWN_FENCE_PATTERN = /^(?:`{3,}|~{3,}).*$/;
+const SURROUNDED_BY_DOUBLE_QUOTES_PATTERN = /^"(.*)"$/;
+const TAB_PATTERN = /\t/g;
+const MAX_READ_PREVIEW_LINES = 10;
+const MAX_WRITE_FILE_PREVIEW_LINES = 200;
+const MAX_WRITE_FILE_PREVIEW_CHARS = 100_000;
+const TOOL_PENDING_MESSAGE = "Executing..";
+const TOOL_PENDING_MARKER = "__tool_pending_status__";
+const TOOL_PENDING_SPINNER_FRAMES = ["-", "\\", "|", "/"];
+const HASHLINE_TAG_ONLY_PATTERN = /^(.*\d+#[ZPMQVRWSNKTXJBYH]{2})\s*$/;
+const HASHLINE_PIPE_ONLY_PATTERN = /^\|\s*(.*)$/;
+const HASHLINE_TAG_PIPE_ONLY_PATTERN = /^(.*\d+#[ZPMQVRWSNKTXJBYH]{2})\s*\|\s*$/;
+const HASHLINE_COMPACT_LINE_PATTERN = /^\s*\d+#[ZPMQVRWSNKTXJBYH]{2}\|.*$/;
+const isTruthyEnvFlag = (value) => {
+    if (!value) {
+        return false;
+    }
+    const normalized = value.trim().toLowerCase();
+    return (normalized === "1" ||
+        normalized === "true" ||
+        normalized === "yes" ||
+        normalized === "on");
+};
+const isRawToolIoEnabledByEnv = () => {
+    return isTruthyEnvFlag(process.env.DEBUG_SHOW_RAW_TOOL_IO);
+};
+const extractStringField = (input, field) => {
+    if (typeof input !== "object" || input === null) {
+        return null;
+    }
+    const record = input;
+    return typeof record[field] === "string" ? record[field] : null;
+};
+const extractNumberField = (input, field) => {
+    if (typeof input !== "object" || input === null) {
+        return null;
+    }
+    const record = input;
+    const value = record[field];
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+};
+const extractBooleanField = (input, field) => {
+    if (typeof input !== "object" || input === null) {
+        return null;
+    }
+    const record = input;
+    return typeof record[field] === "boolean" ? record[field] : null;
+};
+const buildTextPreviewLines = (text, emptyText = "(empty)", maxPreviewLines = MAX_READ_PREVIEW_LINES) => {
+    const normalized = text.replaceAll("\r\n", "\n").trimEnd();
+    if (normalized.length === 0) {
+        return [emptyText];
+    }
+    const allLines = normalized.split("\n");
+    const omittedLines = Math.max(0, allLines.length - maxPreviewLines);
+    const visibleLines = omittedLines > 0 ? allLines.slice(0, maxPreviewLines) : allLines;
+    const preview = [...visibleLines];
+    if (omittedLines > 0) {
+        const lineLabel = `line${omittedLines === 1 ? "" : "s"}`;
+        preview.push("");
+        preview.push(`... (${omittedLines} more ${lineLabel})`);
+    }
+    return preview;
+};
+const buildPrettyHeader = (title, target) => {
+    return `**${title}** \`${target}\``;
+};
+const normalizeHashlineBreakArtifacts = (lines) => {
+    const normalized = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const current = lines[index].replaceAll("\r", "");
+        const next = lines[index + 1]?.replaceAll("\r", "");
+        const nextNext = lines[index + 2]?.replaceAll("\r", "");
+        const currentTagOnly = current.match(HASHLINE_TAG_ONLY_PATTERN);
+        const nextPipeOnly = next?.match(HASHLINE_PIPE_ONLY_PATTERN);
+        const nextLooksLikeHashline = next !== undefined && HASHLINE_COMPACT_LINE_PATTERN.test(next);
+        const nextNextLooksLikeHashline = nextNext !== undefined && HASHLINE_COMPACT_LINE_PATTERN.test(nextNext);
+        if (currentTagOnly && nextPipeOnly) {
+            const pipedContent = nextPipeOnly[1].trim();
+            if (pipedContent.length > 0) {
+                normalized.push(`${currentTagOnly[1]}|${pipedContent}`);
+                index += 1;
+                continue;
+            }
+            if (nextNext !== undefined && !nextNextLooksLikeHashline) {
+                normalized.push(`${currentTagOnly[1]}|${nextNext.trimStart()}`);
+                index += 2;
+                continue;
+            }
+        }
+        const currentTagPipeOnly = current.match(HASHLINE_TAG_PIPE_ONLY_PATTERN);
+        if (currentTagPipeOnly && next !== undefined && !nextLooksLikeHashline) {
+            normalized.push(`${currentTagPipeOnly[1]}|${next.trimStart()}`);
+            index += 1;
+            continue;
+        }
+        normalized.push(current);
+    }
+    return normalized;
+};
+const shouldIncludeReadFilePreviewLine = (line) => {
+    const match = line.match(READ_FILE_LINE_SPLIT_PATTERN);
+    const content = (match?.[2] ?? line).trim();
+    return !READ_FILE_MARKDOWN_FENCE_PATTERN.test(content);
+};
+const stripSurroundedDoubleQuotes = (value) => {
+    const trimmed = value.trim();
+    const matched = trimmed.match(SURROUNDED_BY_DOUBLE_QUOTES_PATTERN);
+    return matched?.[1] ?? trimmed;
+};
+const parseReadFileMetadataLine = (line) => {
+    const separatorIndex = line.indexOf(":");
+    if (separatorIndex <= 0) {
+        return null;
+    }
+    const key = line.slice(0, separatorIndex).trim();
+    if (key.length === 0) {
+        return null;
+    }
+    return {
+        key,
+        value: line.slice(separatorIndex + 1).trim(),
+    };
+};
+const parseNumberedBlockToolOutput = (output, successPrefix) => {
+    const normalized = output.replaceAll("\r\n", "\n");
+    if (!normalized.startsWith(successPrefix)) {
+        return null;
+    }
+    const lines = normalized.split("\n");
+    const metadata = new Map();
+    let blockStartIndex = -1;
+    for (let index = 1; index < lines.length; index += 1) {
+        const line = lines[index];
+        if (line.startsWith(READ_FILE_BLOCK_PREFIX) &&
+            line.endsWith(READ_FILE_BLOCK_SUFFIX) &&
+            line !== READ_FILE_BLOCK_END) {
+            blockStartIndex = index;
+            break;
+        }
+        if (line.trim().length === 0) {
+            continue;
+        }
+        const parsed = parseReadFileMetadataLine(line);
+        if (!parsed) {
+            return null;
+        }
+        metadata.set(parsed.key, parsed.value);
+    }
+    if (blockStartIndex < 0) {
+        return null;
+    }
+    const blockEndIndex = lines.findIndex((line, index) => index > blockStartIndex && line === READ_FILE_BLOCK_END);
+    if (blockEndIndex < 0) {
+        return null;
+    }
+    const blockTitle = lines[blockStartIndex]
+        .slice(READ_FILE_BLOCK_PREFIX.length, -READ_FILE_BLOCK_SUFFIX.length)
+        .trim();
+    const blockBody = lines.slice(blockStartIndex + 1, blockEndIndex).join("\n");
+    return {
+        metadata,
+        blockTitle,
+        blockBody,
+    };
+};
+const parseReadFileOutput = (output) => {
+    return parseNumberedBlockToolOutput(output, READ_FILE_SUCCESS_PREFIX);
+};
+const parseGlobOutput = (output) => {
+    return parseNumberedBlockToolOutput(output, GLOB_SUCCESS_PREFIX);
+};
+const parseGrepOutput = (output) => {
+    return parseNumberedBlockToolOutput(output, GREP_SUCCESS_PREFIX);
+};
+const resolveReadPath = (parsed) => {
+    const pathValue = parsed.metadata.get("path") ?? "";
+    return pathValue.trim() || parsed.blockTitle || "(unknown)";
+};
+const getToolOmittedLineCount = (metadata) => {
+    const linesMetadata = metadata.get("lines");
+    if (!linesMetadata) {
+        return 0;
+    }
+    const matchedCounts = linesMetadata.match(READ_FILE_LINES_WITH_RETURNED_PATTERN);
+    if (!matchedCounts) {
+        return 0;
+    }
+    const totalLines = Number.parseInt(matchedCounts[1], 10);
+    const returnedLines = Number.parseInt(matchedCounts[2], 10);
+    if (!(Number.isFinite(totalLines) && Number.isFinite(returnedLines))) {
+        return 0;
+    }
+    const isTruncated = metadata.get("truncated")?.toLowerCase() === "true";
+    if (!isTruncated) {
+        return 0;
+    }
+    return Math.max(0, totalLines - returnedLines);
+};
+const buildReadPreviewLines = (visibleLines, totalOmitted, isModelTruncated) => {
+    const previewLines = visibleLines.length > 0 && visibleLines.some((line) => line.length > 0)
+        ? [...visibleLines]
+        : ["(empty)"];
+    if (totalOmitted <= 0) {
+        return previewLines;
+    }
+    const lineLabel = `line${totalOmitted === 1 ? "" : "s"}`;
+    previewLines.push("");
+    previewLines.push(isModelTruncated
+        ? `... (${totalOmitted} more ${lineLabel}, truncated)`
+        : `... (${totalOmitted} more ${lineLabel})`);
+    return previewLines;
+};
+const parseIntegerMetadataValue = (rawValue) => {
+    if (!rawValue) {
+        return null;
+    }
+    const parsed = Number.parseInt(rawValue, 10);
+    return Number.isFinite(parsed) ? parsed : null;
+};
+const buildGlobPreviewLines = (visibleLines, totalOmitted, metadata) => {
+    const previewLines = visibleLines.length > 0 && visibleLines.some((line) => line.length > 0)
+        ? [...visibleLines]
+        : ["(no matches)"];
+    if (totalOmitted <= 0) {
+        return previewLines;
+    }
+    const lineLabel = `line${totalOmitted === 1 ? "" : "s"}`;
+    previewLines.push("");
+    previewLines.push(metadata.truncated
+        ? `... (${totalOmitted} more ${lineLabel}, truncated)`
+        : `... (${totalOmitted} more ${lineLabel})`);
+    return previewLines;
+};
+const buildGrepPreviewLines = (visibleLines, totalOmitted, metadata) => {
+    const previewLines = visibleLines.length > 0 && visibleLines.some((line) => line.length > 0)
+        ? [...visibleLines]
+        : ["(no matches)"];
+    if (totalOmitted <= 0) {
+        return previewLines;
+    }
+    const lineLabel = `line${totalOmitted === 1 ? "" : "s"}`;
+    const metadataParts = [`path: ${metadata.path ?? "."}`];
+    if (metadata.matchCount) {
+        metadataParts.push(`match_count (${metadata.matchCount})`);
+    }
+    if (metadata.truncated) {
+        metadataParts.push("truncated: true");
+    }
+    previewLines.push("");
+    previewLines.push(metadata.truncated
+        ? `... (${totalOmitted} more ${lineLabel}, truncated)`
+        : `... (${totalOmitted} more ${lineLabel})`);
+    previewLines.push(metadataParts.join(", "));
+    return previewLines;
+};
+const renderReadFileOutput = (output) => {
+    const parsed = parseReadFileOutput(output);
+    if (!parsed) {
+        return null;
+    }
+    const readPath = resolveReadPath(parsed);
+    const contentBody = parsed.blockBody.trim().length > 0 ? parsed.blockBody : "(empty)";
+    const allLines = normalizeHashlineBreakArtifacts(contentBody.split("\n").filter(shouldIncludeReadFilePreviewLine));
+    const omittedFromPreview = Math.max(0, allLines.length - MAX_READ_PREVIEW_LINES);
+    const visibleLines = omittedFromPreview > 0
+        ? allLines.slice(0, MAX_READ_PREVIEW_LINES)
+        : allLines;
+    const omittedFromTool = getToolOmittedLineCount(parsed.metadata);
+    const isModelTruncated = parsed.metadata.get("truncated")?.toLowerCase() === "true";
+    const totalOmitted = omittedFromPreview + omittedFromTool;
+    const previewLines = buildReadPreviewLines(visibleLines, totalOmitted, isModelTruncated);
+    const rangeValue = parsed.metadata.get("range")?.trim() || null;
+    return {
+        path: readPath,
+        range: rangeValue,
+        body: previewLines.join("\n"),
+    };
+};
+const renderGlobOutput = (output) => {
+    const parsed = parseGlobOutput(output);
+    if (!parsed) {
+        return null;
+    }
+    const contentBody = parsed.blockBody.trim();
+    const allLines = contentBody.length > 0
+        ? contentBody.split("\n").filter((line) => line.trim().length > 0)
+        : [];
+    const omittedFromPreview = Math.max(0, allLines.length - MAX_READ_PREVIEW_LINES);
+    const visibleLines = omittedFromPreview > 0
+        ? allLines.slice(0, MAX_READ_PREVIEW_LINES)
+        : allLines;
+    const fileCountRaw = parsed.metadata.get("file_count");
+    const fileCount = parseIntegerMetadataValue(fileCountRaw);
+    const isToolTruncated = parsed.metadata.get("truncated")?.toLowerCase() === "true";
+    const omittedFromTool = isToolTruncated && fileCount !== null
+        ? Math.max(0, fileCount - allLines.length)
+        : 0;
+    const totalOmitted = omittedFromPreview + omittedFromTool;
+    const metadata = {
+        truncated: isToolTruncated,
+    };
+    const previewLines = buildGlobPreviewLines(visibleLines, totalOmitted, metadata);
+    const patternValue = stripSurroundedDoubleQuotes(parsed.metadata.get("pattern") ?? "") ||
+        parsed.blockTitle ||
+        "(unknown)";
+    return {
+        pattern: patternValue,
+        body: previewLines.join("\n"),
+    };
+};
+const renderGrepOutput = (output) => {
+    const parsed = parseGrepOutput(output);
+    if (!parsed) {
+        return null;
+    }
+    const contentBody = parsed.blockBody.trim();
+    const allLines = contentBody.length > 0
+        ? normalizeHashlineBreakArtifacts(contentBody.split("\n"))
+        : [];
+    const omittedFromPreview = Math.max(0, allLines.length - MAX_READ_PREVIEW_LINES);
+    const visibleLines = omittedFromPreview > 0
+        ? allLines.slice(0, MAX_READ_PREVIEW_LINES)
+        : allLines;
+    const matchCountRaw = parsed.metadata.get("match_count");
+    const matchCount = parseIntegerMetadataValue(matchCountRaw);
+    const isToolTruncated = parsed.metadata.get("truncated")?.toLowerCase() === "true";
+    const omittedFromTool = isToolTruncated && matchCount !== null
+        ? Math.max(0, matchCount - allLines.length)
+        : 0;
+    const totalOmitted = omittedFromPreview + omittedFromTool;
+    const metadata = {
+        path: parsed.metadata.get("path") ?? null,
+        matchCount: matchCountRaw ?? null,
+        truncated: isToolTruncated,
+    };
+    const previewLines = buildGrepPreviewLines(visibleLines, totalOmitted, metadata);
+    const patternValue = stripSurroundedDoubleQuotes(parsed.metadata.get("pattern") ?? "") ||
+        parsed.blockTitle ||
+        "(unknown)";
+    return {
+        pattern: patternValue,
+        body: previewLines.join("\n"),
+    };
+};
+const renderPendingOutput = () => {
+    return TOOL_PENDING_MARKER;
+};
+const buildPendingSpinnerText = (frame) => {
+    return `${frame} ${TOOL_PENDING_MESSAGE}`;
+};
+const renderToolOutput = (_toolName, output) => {
+    return renderCodeBlock("text", output);
+};
+const ANSI_RESET = "\x1b[0m";
+const ANSI_DIM = "\x1b[2m";
+const ANSI_ITALIC = "\x1b[3m";
+const ANSI_GRAY = "\x1b[90m";
+const ANSI_BG_GRAY = "\x1b[100m";
+const LEADING_NEWLINES = /^\n+/;
+const TRAILING_NEWLINES = /\n+$/;
+const applyReadPreviewBackground = (text) => {
+    return `${ANSI_BG_GRAY}${text}${ANSI_RESET}`;
+};
+const styleThinkingText = (text) => {
+    return `${ANSI_DIM}${ANSI_ITALIC}${ANSI_GRAY}${text}${ANSI_RESET}`;
+};
+class TrimmedMarkdown extends Markdown {
+    render(width) {
+        const lines = super.render(width);
+        let end = lines.length;
+        while (end > 0 && lines[end - 1].trim().length === 0) {
+            end -= 1;
+        }
+        return lines.slice(0, end);
+    }
+}
+class TruncatedReadBody {
+    cachedLines;
+    cachedText;
+    cachedWidth;
+    background;
+    backgroundEnabled = true;
+    paddingX;
+    text;
+    constructor(text, paddingX, background) {
+        this.text = text;
+        this.paddingX = paddingX;
+        this.background = background;
+    }
+    setText(text) {
+        this.text = text;
+        this.cachedText = undefined;
+        this.cachedWidth = undefined;
+        this.cachedLines = undefined;
+    }
+    setBackgroundEnabled(enabled) {
+        if (this.backgroundEnabled === enabled) {
+            return;
+        }
+        this.backgroundEnabled = enabled;
+        this.invalidate();
+    }
+    invalidate() {
+        this.cachedText = undefined;
+        this.cachedWidth = undefined;
+        this.cachedLines = undefined;
+    }
+    render(width) {
+        if (this.cachedLines &&
+            this.cachedText === this.text &&
+            this.cachedWidth === width) {
+            return this.cachedLines;
+        }
+        if (!this.text || this.text.trim().length === 0) {
+            this.cachedText = this.text;
+            this.cachedWidth = width;
+            this.cachedLines = [];
+            return [];
+        }
+        const normalizedText = this.text.replace(TAB_PATTERN, "   ");
+        const contentWidth = Math.max(1, width - this.paddingX * 2);
+        const leftMargin = " ".repeat(this.paddingX);
+        const rightMargin = " ".repeat(this.paddingX);
+        const renderedLines = normalizedText.split("\n").map((line) => {
+            const truncatedLine = truncateToWidth(line, contentWidth, "");
+            const lineWithMargins = `${leftMargin}${truncatedLine}${rightMargin}`;
+            const visibleLength = visibleWidth(lineWithMargins);
+            const paddedLine = `${lineWithMargins}${" ".repeat(Math.max(0, width - visibleLength))}`;
+            return this.background && this.backgroundEnabled
+                ? this.background(paddedLine)
+                : paddedLine;
+        });
+        this.cachedText = this.text;
+        this.cachedWidth = width;
+        this.cachedLines = renderedLines;
+        return renderedLines;
+    }
+}
+const MAX_DIFF_MATRIX_CELLS = 60_000;
+const MAX_DIFF_RENDER_LINES = 160;
+const buildSimpleDiff = (before, after) => {
+    const beforeLines = before.split("\n");
+    const afterLines = after.split("\n");
+    const lines = [];
+    const maxLength = Math.max(beforeLines.length, afterLines.length);
+    for (let index = 0; index < maxLength; index += 1) {
+        const oldLine = beforeLines[index];
+        const newLine = afterLines[index];
+        if (oldLine === undefined && newLine !== undefined) {
+            lines.push({ type: "add", text: newLine });
+            continue;
+        }
+        if (newLine === undefined && oldLine !== undefined) {
+            lines.push({ type: "delete", text: oldLine });
+            continue;
+        }
+        if (oldLine === newLine && oldLine !== undefined) {
+            lines.push({ type: "context", text: oldLine });
+            continue;
+        }
+        if (oldLine !== undefined) {
+            lines.push({ type: "delete", text: oldLine });
+        }
+        if (newLine !== undefined) {
+            lines.push({ type: "add", text: newLine });
+        }
+    }
+    return lines;
+};
+const buildLcsDiff = (before, after) => {
+    const beforeLines = before.split("\n");
+    const afterLines = after.split("\n");
+    if (beforeLines.length === 0 && afterLines.length === 0) {
+        return [];
+    }
+    const matrixCells = (beforeLines.length + 1) * (afterLines.length + 1);
+    if (matrixCells > MAX_DIFF_MATRIX_CELLS) {
+        return buildSimpleDiff(before, after);
+    }
+    const lcs = new Array(beforeLines.length + 1)
+        .fill(undefined)
+        .map(() => new Array(afterLines.length + 1).fill(0));
+    for (let i = beforeLines.length - 1; i >= 0; i -= 1) {
+        for (let j = afterLines.length - 1; j >= 0; j -= 1) {
+            if (beforeLines[i] === afterLines[j]) {
+                lcs[i][j] = lcs[i + 1][j + 1] + 1;
+            }
+            else {
+                lcs[i][j] = Math.max(lcs[i + 1][j], lcs[i][j + 1]);
+            }
+        }
+    }
+    const lines = [];
+    let i = 0;
+    let j = 0;
+    while (i < beforeLines.length && j < afterLines.length) {
+        if (beforeLines[i] === afterLines[j]) {
+            lines.push({ type: "context", text: beforeLines[i] });
+            i += 1;
+            j += 1;
+            continue;
+        }
+        if (lcs[i + 1][j] >= lcs[i][j + 1]) {
+            lines.push({ type: "delete", text: beforeLines[i] });
+            i += 1;
+            continue;
+        }
+        lines.push({ type: "add", text: afterLines[j] });
+        j += 1;
+    }
+    while (i < beforeLines.length) {
+        lines.push({ type: "delete", text: beforeLines[i] });
+        i += 1;
+    }
+    while (j < afterLines.length) {
+        lines.push({ type: "add", text: afterLines[j] });
+        j += 1;
+    }
+    return lines;
+};
+const renderDiffBlock = (before, after) => {
+    const diffLines = buildLcsDiff(before, after);
+    const rendered = ["```diff"];
+    for (let index = 0; index < diffLines.length; index += 1) {
+        if (index >= MAX_DIFF_RENDER_LINES) {
+            rendered.push("... diff truncated ...");
+            break;
+        }
+        const line = diffLines[index];
+        if (line.type === "add") {
+            rendered.push(`+${line.text}`);
+        }
+        else if (line.type === "delete") {
+            rendered.push(`-${line.text}`);
+        }
+        else {
+            rendered.push(` ${line.text}`);
+        }
+    }
+    rendered.push("```");
+    return rendered.join("\n");
+};
+const tryExtractEditPayload = (toolName, input) => {
+    if (toolName !== "edit_file") {
+        return null;
+    }
+    if (typeof input !== "object" || input === null) {
+        return null;
+    }
+    const record = input;
+    const oldStr = record.old_str;
+    const newStr = record.new_str;
+    const path = record.path;
+    if (typeof oldStr !== "string" || typeof newStr !== "string") {
+        return null;
+    }
+    return {
+        oldStr,
+        newStr,
+        path: typeof path === "string" ? path : undefined,
+    };
+};
+class AssistantStreamView extends Container {
+    markdownTheme;
+    segments = [];
+    constructor(markdownTheme) {
+        super();
+        this.markdownTheme = markdownTheme;
+        this.refresh();
+    }
+    appendReasoning(delta) {
+        this.appendSegment("reasoning", delta);
+    }
+    appendText(delta) {
+        this.appendSegment("text", delta);
+    }
+    appendSegment(type, delta) {
+        if (delta.length === 0) {
+            return;
+        }
+        const lastSegment = this.segments.at(-1);
+        if (lastSegment && lastSegment.type === type) {
+            lastSegment.content += delta;
+        }
+        else {
+            this.segments.push({
+                type,
+                content: delta,
+            });
+        }
+        this.refresh();
+    }
+    refresh() {
+        this.clear();
+        const visibleSegments = this.segments
+            .map((segment) => {
+            const normalizedContent = segment.type === "reasoning"
+                ? segment.content.replace(LEADING_NEWLINES, "").trimEnd()
+                : segment.content.trim();
+            return {
+                ...segment,
+                content: normalizedContent,
+            };
+        })
+            .filter((segment) => segment.content.trim().length > 0);
+        if (visibleSegments.length === 0) {
+            return;
+        }
+        for (let index = 0; index < visibleSegments.length; index += 1) {
+            const segment = visibleSegments[index];
+            const text = segment.content;
+            if (segment.type === "text") {
+                this.addChild(new Markdown(text, 1, 0, this.markdownTheme));
+            }
+            else {
+                this.addChild(new Markdown(text, 1, 0, this.markdownTheme, {
+                    color: styleThinkingText,
+                    italic: true,
+                }));
+            }
+            if (index < visibleSegments.length - 1) {
+                this.addChild(new Spacer(1));
+            }
+        }
+    }
+}
+class ToolCallView extends Container {
+    callId;
+    content;
+    readBlock;
+    readBody;
+    readHeader;
+    requestRender;
+    showRawToolIo;
+    error;
+    finalInput;
+    inputBuffer = "";
+    output;
+    outputDenied = false;
+    pendingSpinnerFrameIndex = 0;
+    pendingSpinnerInterval = null;
+    pendingTemplate = null;
+    parsedInput;
+    readMode = false;
+    toolName;
+    constructor(callId, toolName, markdownTheme, requestRender, showRawToolIo) {
+        super();
+        this.callId = callId;
+        this.toolName = toolName;
+        this.requestRender = requestRender;
+        this.showRawToolIo = showRawToolIo;
+        this.content = new TrimmedMarkdown("", 1, 0, markdownTheme);
+        this.readHeader = new TrimmedMarkdown("", 1, 0, markdownTheme);
+        this.readBody = new TruncatedReadBody("", 1, applyReadPreviewBackground);
+        this.readBlock = new Container();
+        this.readBlock.addChild(this.readHeader);
+        this.readBlock.addChild(new Spacer(1));
+        this.readBlock.addChild(this.readBody);
+        this.addChild(this.content);
+        this.refresh();
+    }
+    dispose() {
+        this.stopPendingSpinner();
+    }
+    setReadMode(enabled) {
+        if (this.readMode === enabled) {
+            return;
+        }
+        this.readMode = enabled;
+        this.clear();
+        this.addChild(enabled ? this.readBlock : this.content);
+    }
+    stopPendingSpinner() {
+        this.pendingTemplate = null;
+        if (!this.pendingSpinnerInterval) {
+            return;
+        }
+        clearInterval(this.pendingSpinnerInterval);
+        this.pendingSpinnerInterval = null;
+    }
+    applyPendingSpinnerFrame() {
+        if (!this.pendingTemplate) {
+            return;
+        }
+        const frame = TOOL_PENDING_SPINNER_FRAMES[this.pendingSpinnerFrameIndex];
+        this.readBody.setText(this.pendingTemplate.replaceAll(TOOL_PENDING_MARKER, buildPendingSpinnerText(frame)));
+    }
+    startPendingSpinner(template) {
+        this.pendingTemplate = template;
+        this.pendingSpinnerFrameIndex = 0;
+        this.applyPendingSpinnerFrame();
+        if (this.pendingSpinnerInterval) {
+            return;
+        }
+        this.pendingSpinnerInterval = setInterval(() => {
+            this.pendingSpinnerFrameIndex =
+                (this.pendingSpinnerFrameIndex + 1) %
+                    TOOL_PENDING_SPINNER_FRAMES.length;
+            this.applyPendingSpinnerFrame();
+            this.requestRender();
+        }, 80);
+    }
+    async appendInputChunk(chunk) {
+        this.inputBuffer += chunk;
+        const { value, state } = await parsePartialJson(this.inputBuffer);
+        const shouldSuppressTransientEmptyObject = state !== "successful-parse" && isPlainEmptyObject(value);
+        if (!shouldSuppressTransientEmptyObject) {
+            this.parsedInput = value;
+        }
+        this.refresh();
+    }
+    setError(error) {
+        this.error = error;
+        this.refresh();
+    }
+    setFinalInput(input) {
+        this.finalInput = input;
+        this.refresh();
+    }
+    setOutput(output) {
+        this.output = output;
+        this.refresh();
+    }
+    setOutputDenied() {
+        this.outputDenied = true;
+        this.refresh();
+    }
+    setToolName(toolName) {
+        this.toolName = toolName;
+        this.refresh();
+    }
+    resolveBestInput() {
+        if (this.finalInput !== undefined) {
+            return this.finalInput;
+        }
+        if (this.parsedInput !== undefined) {
+            return this.parsedInput;
+        }
+        if (this.inputBuffer.length > 0) {
+            return this.inputBuffer;
+        }
+        return undefined;
+    }
+    canRenderPrettyTool(toolName) {
+        if (this.error !== undefined || this.outputDenied) {
+            return false;
+        }
+        if (typeof toolName === "string") {
+            return this.toolName === toolName;
+        }
+        return toolName.has(this.toolName);
+    }
+    resolveInputStringField(field) {
+        const bestInput = this.resolveBestInput();
+        const fromObject = extractStringField(bestInput, field);
+        if (fromObject) {
+            return fromObject;
+        }
+        return null;
+    }
+    resolveInputNumberField(field) {
+        const bestInput = this.resolveBestInput();
+        const fromObject = extractNumberField(bestInput, field);
+        if (fromObject !== null) {
+            return fromObject;
+        }
+        return null;
+    }
+    setPrettyBlock(header, body, options) {
+        this.setReadMode(true);
+        this.readBody.setBackgroundEnabled(options?.useBackground ?? true);
+        this.readHeader.setText(header);
+        if (options?.isPending) {
+            this.startPendingSpinner(body);
+            return;
+        }
+        this.stopPendingSpinner();
+        this.readBody.setText(body);
+    }
+    renderOutputPreviewBody(output, emptyText = "(no output)") {
+        if (typeof output === "string") {
+            return buildTextPreviewLines(output, emptyText).join("\n");
+        }
+        return buildTextPreviewLines(safeStringify(output), emptyText).join("\n");
+    }
+    tryRenderReadFileMode() {
+        if (this.toolName !== "read_file" ||
+            this.error !== undefined ||
+            this.outputDenied) {
+            return false;
+        }
+        const readPath = this.resolveInputStringField("path");
+        if (typeof this.output === "string") {
+            const renderedReadFile = renderReadFileOutput(this.output);
+            if (renderedReadFile) {
+                const pathWithRange = renderedReadFile.range
+                    ? `${renderedReadFile.path} ${renderedReadFile.range}`
+                    : renderedReadFile.path;
+                this.setPrettyBlock(`**Read** \`${pathWithRange}\``, renderedReadFile.body, {
+                    useBackground: true,
+                });
+            }
+            else {
+                const fallbackPath = readPath ?? "(unknown)";
+                this.setPrettyBlock(`**Read** \`${fallbackPath}\``, safeStringify(this.output), {
+                    useBackground: true,
+                });
+            }
+            return true;
+        }
+        if (!readPath) {
+            return false;
+        }
+        this.setPrettyBlock(`**Read** \`${readPath}\``, renderPendingOutput(), {
+            useBackground: false,
+            isPending: true,
+        });
+        return true;
+    }
+    tryRenderGlobMode() {
+        if (this.toolName !== "glob_files" ||
+            this.error !== undefined ||
+            this.outputDenied) {
+            return false;
+        }
+        const globPattern = this.resolveInputStringField("pattern");
+        if (typeof this.output === "string") {
+            const renderedGlob = renderGlobOutput(this.output);
+            if (renderedGlob) {
+                this.setPrettyBlock(`**Glob** \`${renderedGlob.pattern}\``, renderedGlob.body, {
+                    useBackground: true,
+                });
+            }
+            else {
+                const fallbackPattern = globPattern ?? "(unknown)";
+                this.setPrettyBlock(`**Glob** \`${fallbackPattern}\``, safeStringify(this.output), {
+                    useBackground: true,
+                });
+            }
+            return true;
+        }
+        if (!globPattern) {
+            return false;
+        }
+        this.setPrettyBlock(`**Glob** \`${globPattern}\``, renderPendingOutput(), {
+            useBackground: false,
+            isPending: true,
+        });
+        return true;
+    }
+    tryRenderGrepMode() {
+        if (this.toolName !== "grep_files" ||
+            this.error !== undefined ||
+            this.outputDenied) {
+            return false;
+        }
+        const grepPattern = this.resolveInputStringField("pattern");
+        if (typeof this.output === "string") {
+            const renderedGrep = renderGrepOutput(this.output);
+            if (renderedGrep) {
+                this.setPrettyBlock(`**Grep** \`${renderedGrep.pattern}\``, renderedGrep.body, {
+                    useBackground: true,
+                });
+            }
+            else {
+                const fallbackPattern = grepPattern ?? "(unknown)";
+                this.setPrettyBlock(`**Grep** \`${fallbackPattern}\``, safeStringify(this.output), {
+                    useBackground: true,
+                });
+            }
+            return true;
+        }
+        if (!grepPattern) {
+            return false;
+        }
+        this.setPrettyBlock(`**Grep** \`${grepPattern}\``, renderPendingOutput(), {
+            useBackground: false,
+            isPending: true,
+        });
+        return true;
+    }
+    tryRenderShellExecuteMode() {
+        if (!this.canRenderPrettyTool(SHELL_EXECUTE_TOOL_NAMES)) {
+            return false;
+        }
+        const command = this.resolveInputStringField("command") ?? "(command)";
+        const header = buildPrettyHeader("Shell", command);
+        if (this.output === undefined) {
+            this.setPrettyBlock(header, renderPendingOutput(), {
+                isPending: true,
+                useBackground: false,
+            });
+            return true;
+        }
+        const exitCode = extractNumberField(this.output, "exit_code");
+        const shellOutput = extractStringField(this.output, "output");
+        const workdir = this.resolveInputStringField("workdir");
+        const timeoutMs = this.resolveInputNumberField("timeout_ms");
+        const bodyLines = [];
+        if (exitCode !== null) {
+            bodyLines.push(`exit_code: ${exitCode}`);
+        }
+        if (workdir) {
+            bodyLines.push(`workdir: ${workdir}`);
+        }
+        if (timeoutMs !== null) {
+            bodyLines.push(`timeout_ms: ${timeoutMs}`);
+        }
+        if (bodyLines.length > 0) {
+            bodyLines.push("");
+        }
+        bodyLines.push(...buildTextPreviewLines(shellOutput ?? safeStringify(this.output), "(no output)"));
+        this.setPrettyBlock(header, bodyLines.join("\n"));
+        return true;
+    }
+    tryRenderShellInteractMode() {
+        if (!this.canRenderPrettyTool("shell_interact")) {
+            return false;
+        }
+        const keystrokes = this.resolveInputStringField("keystrokes") ?? "(keystrokes)";
+        const header = buildPrettyHeader("Interact", keystrokes);
+        if (this.output === undefined) {
+            this.setPrettyBlock(header, renderPendingOutput(), {
+                isPending: true,
+                useBackground: false,
+            });
+            return true;
+        }
+        const success = extractBooleanField(this.output, "success");
+        const interactOutput = extractStringField(this.output, "output");
+        const bodyLines = [];
+        if (success !== null) {
+            bodyLines.push(`success: ${success}`);
+            bodyLines.push("");
+        }
+        bodyLines.push(...buildTextPreviewLines(interactOutput ?? safeStringify(this.output), "(no output)"));
+        this.setPrettyBlock(header, bodyLines.join("\n"));
+        return true;
+    }
+    tryRenderWriteFileMode() {
+        if (!this.canRenderPrettyTool("write_file")) {
+            return false;
+        }
+        const bestInput = this.resolveBestInput();
+        const path = extractStringField(bestInput, "path") ?? "(unknown)";
+        const fileContent = extractStringField(bestInput, "content");
+        const header = buildPrettyHeader("Write", path);
+        const hasVisibleFileContent = fileContent !== null && fileContent.trim().length > 0;
+        if (hasVisibleFileContent) {
+            const boundedContent = fileContent.length > MAX_WRITE_FILE_PREVIEW_CHARS
+                ? fileContent.slice(0, MAX_WRITE_FILE_PREVIEW_CHARS)
+                : fileContent;
+            const previewBody = buildTextPreviewLines(boundedContent, "(empty)", MAX_WRITE_FILE_PREVIEW_LINES).join("\n");
+            this.setPrettyBlock(header, previewBody, {
+                useBackground: true,
+            });
+            return true;
+        }
+        if (this.output === undefined) {
+            this.setPrettyBlock(header, renderPendingOutput(), {
+                isPending: true,
+                useBackground: false,
+            });
+            return true;
+        }
+        this.setPrettyBlock(header, this.renderOutputPreviewBody(this.output));
+        return true;
+    }
+    tryRenderEditFileMode() {
+        if (!this.canRenderPrettyTool("edit_file")) {
+            return false;
+        }
+        const bestInput = this.resolveBestInput();
+        const path = this.resolveInputStringField("path") ?? "(unknown)";
+        const header = buildPrettyHeader("Edit", path);
+        const bodyLines = [];
+        if (typeof bestInput === "object" && bestInput !== null) {
+            const record = bestInput;
+            if (Array.isArray(record.edits)) {
+                bodyLines.push(`edits: ${record.edits.length}`);
+            }
+        }
+        if (this.output === undefined) {
+            if (bodyLines.length > 0) {
+                bodyLines.push("");
+            }
+            bodyLines.push(renderPendingOutput());
+        }
+        else {
+            if (bodyLines.length > 0) {
+                bodyLines.push("");
+            }
+            bodyLines.push(...buildTextPreviewLines(safeStringify(this.output)));
+        }
+        const editPayload = tryExtractEditPayload(this.toolName, bestInput);
+        if (editPayload) {
+            bodyLines.push("");
+            bodyLines.push("Live diff preview:");
+            bodyLines.push(renderDiffBlock(editPayload.oldStr, editPayload.newStr));
+        }
+        this.setPrettyBlock(header, bodyLines.join("\n"), {
+            isPending: this.output === undefined,
+            useBackground: this.output !== undefined,
+        });
+        return true;
+    }
+    tryRenderDeleteFileMode() {
+        if (!this.canRenderPrettyTool("delete_file")) {
+            return false;
+        }
+        const path = this.resolveInputStringField("path") ?? "(unknown)";
+        const header = buildPrettyHeader("Delete", path);
+        if (this.output === undefined) {
+            this.setPrettyBlock(header, renderPendingOutput(), {
+                isPending: true,
+                useBackground: false,
+            });
+            return true;
+        }
+        this.setPrettyBlock(header, this.renderOutputPreviewBody(this.output));
+        return true;
+    }
+    tryRenderLoadSkillMode() {
+        if (!this.canRenderPrettyTool("load_skill")) {
+            return false;
+        }
+        const skillName = this.resolveInputStringField("skillName") ?? "(unknown)";
+        const relativePath = this.resolveInputStringField("relativePath");
+        const target = relativePath ? `${skillName}/${relativePath}` : skillName;
+        const header = buildPrettyHeader("Skill", target);
+        if (this.output === undefined) {
+            this.setPrettyBlock(header, renderPendingOutput(), {
+                isPending: true,
+                useBackground: false,
+            });
+            return true;
+        }
+        this.setPrettyBlock(header, this.renderOutputPreviewBody(this.output));
+        return true;
+    }
+    tryRenderTodoWriteMode() {
+        if (!this.canRenderPrettyTool("todo_write")) {
+            return false;
+        }
+        const bestInput = this.resolveBestInput();
+        const todoItems = typeof bestInput === "object" && bestInput !== null
+            ? bestInput.todos
+            : undefined;
+        const todos = Array.isArray(todoItems)
+            ? todoItems.filter((item) => {
+                return typeof item === "object" && item !== null;
+            })
+            : [];
+        const totalTodos = todos.length;
+        const headerTarget = `${totalTodos} task${totalTodos === 1 ? "" : "s"}`;
+        const header = buildPrettyHeader("Todo", headerTarget);
+        if (this.output === undefined) {
+            this.setPrettyBlock(header, renderPendingOutput(), {
+                isPending: true,
+                useBackground: false,
+            });
+            return true;
+        }
+        const counts = {
+            completed: 0,
+            inProgress: 0,
+            pending: 0,
+            cancelled: 0,
+        };
+        for (const todo of todos) {
+            const status = typeof todo.status === "string" ? todo.status.toLowerCase() : "";
+            if (status === "completed") {
+                counts.completed += 1;
+            }
+            else if (status === "in_progress") {
+                counts.inProgress += 1;
+            }
+            else if (status === "pending") {
+                counts.pending += 1;
+            }
+            else if (status === "cancelled") {
+                counts.cancelled += 1;
+            }
+        }
+        const bodyLines = [
+            `total: ${totalTodos}`,
+            `completed: ${counts.completed}`,
+            `in_progress: ${counts.inProgress}`,
+            `pending: ${counts.pending}`,
+            `cancelled: ${counts.cancelled}`,
+            "",
+            ...buildTextPreviewLines(safeStringify(this.output)),
+        ];
+        this.setPrettyBlock(header, bodyLines.join("\n"));
+        return true;
+    }
+    tryRenderPrettyMode() {
+        return (this.tryRenderReadFileMode() ||
+            this.tryRenderGlobMode() ||
+            this.tryRenderGrepMode() ||
+            this.tryRenderShellExecuteMode() ||
+            this.tryRenderShellInteractMode() ||
+            this.tryRenderWriteFileMode() ||
+            this.tryRenderEditFileMode() ||
+            this.tryRenderDeleteFileMode() ||
+            this.tryRenderLoadSkillMode() ||
+            this.tryRenderTodoWriteMode());
+    }
+    shouldSuppressRawFallback() {
+        if (this.showRawToolIo) {
+            return false;
+        }
+        return (this.finalInput === undefined &&
+            this.output === undefined &&
+            this.error === undefined &&
+            !this.outputDenied &&
+            this.inputBuffer.length > 0);
+    }
+    refresh() {
+        if (!this.showRawToolIo && this.tryRenderPrettyMode()) {
+            return;
+        }
+        this.stopPendingSpinner();
+        if (this.shouldSuppressRawFallback()) {
+            return;
+        }
+        this.setReadMode(false);
+        const includeCallIdInRawHeader = !SHELL_TOOL_NAMES.has(this.toolName);
+        const rawHeader = includeCallIdInRawHeader
+            ? `**Tool** \`${this.toolName}\` (\`${this.callId}\`)`
+            : `**Tool** \`${this.toolName}\``;
+        const blocks = [rawHeader];
+        const bestInput = this.resolveBestInput();
+        if (bestInput !== undefined) {
+            blocks.push(`**Input**\n\n${renderCodeBlock("json", bestInput)}`);
+            const editPayload = tryExtractEditPayload(this.toolName, bestInput);
+            if (editPayload) {
+                const heading = editPayload.path
+                    ? `**Live diff preview** (\`${editPayload.path}\`)`
+                    : "**Live diff preview**";
+                blocks.push(`${heading}\n\n${renderDiffBlock(editPayload.oldStr, editPayload.newStr)}`);
+            }
+        }
+        if (this.output !== undefined) {
+            blocks.push(`**Output**\n\n${renderToolOutput(this.toolName, this.output)}`);
+        }
+        if (this.error !== undefined) {
+            blocks.push(`**Error**\n\n${renderCodeBlock("text", this.error)}`);
+        }
+        if (this.outputDenied) {
+            blocks.push("**Output** denied by model/policy");
+        }
+        this.content.setText(blocks.join("\n\n"));
+    }
+}
+const getToolInputId = (part) => {
+    return part.id ?? part.toolCallId;
+};
+const getToolInputChunk = (part) => {
+    if (typeof part.delta === "string") {
+        return part.delta;
+    }
+    if (typeof part.inputTextDelta === "string") {
+        return part.inputTextDelta;
+    }
+    return null;
+};
+const createToolInputState = (toolName) => {
+    return {
+        toolName,
+        hasContent: false,
+        inputBuffer: "",
+        renderedInputLength: 0,
+    };
+};
+const syncToolInputToView = async (state, toolCallId, toolState) => {
+    const hasKnownToolName = toolState.toolName !== UNKNOWN_TOOL_NAME;
+    if (!(state.flags.showRawToolIo || hasKnownToolName)) {
+        return;
+    }
+    const existingView = state.getToolView(toolCallId);
+    const pendingInput = toolState.inputBuffer.slice(toolState.renderedInputLength);
+    if (!existingView && pendingInput.length === 0) {
+        return;
+    }
+    state.resetAssistantView(true);
+    const toolView = existingView ?? state.ensureToolView(toolCallId, toolState.toolName);
+    if (pendingInput.length === 0) {
+        return;
+    }
+    await toolView.appendInputChunk(pendingInput);
+    toolState.renderedInputLength = toolState.inputBuffer.length;
+};
+const createInfoMessage = (title, value) => {
+    return new Text(`${title}\n${safeStringify(value)}`, 1, 0);
+};
+const handleTextStart = (_part, state) => {
+    state.ensureAssistantView();
+};
+const handleTextDelta = (part, state) => {
+    const textPart = part;
+    state.ensureAssistantView().appendText(textPart.text);
+};
+const handleReasoningStart = (_part, state) => {
+    if (state.flags.showReasoning) {
+        state.ensureAssistantView();
+    }
+};
+const handleReasoningDelta = (part, state) => {
+    if (!state.flags.showReasoning) {
+        return;
+    }
+    const reasoningPart = part;
+    state.ensureAssistantView().appendReasoning(reasoningPart.text);
+};
+const handleToolInputStart = async (part, state) => {
+    const toolInputStartPart = part;
+    const toolCallId = getToolInputId(toolInputStartPart);
+    if (!toolCallId) {
+        return;
+    }
+    const existingState = state.activeToolInputs.get(toolCallId);
+    const toolState = existingState ?? createToolInputState(toolInputStartPart.toolName);
+    toolState.toolName = toolInputStartPart.toolName;
+    state.activeToolInputs.set(toolCallId, toolState);
+    state.streamedToolCallIds.add(toolCallId);
+    await syncToolInputToView(state, toolCallId, toolState);
+};
+const handleToolInputDelta = async (part, state) => {
+    const toolInputDeltaPart = part;
+    const toolCallId = getToolInputId(toolInputDeltaPart);
+    if (!toolCallId) {
+        return;
+    }
+    if (!state.activeToolInputs.has(toolCallId)) {
+        state.activeToolInputs.set(toolCallId, createToolInputState(UNKNOWN_TOOL_NAME));
+    }
+    const toolState = state.activeToolInputs.get(toolCallId);
+    const chunk = getToolInputChunk(toolInputDeltaPart);
+    if (chunk && toolState) {
+        toolState.inputBuffer += chunk;
+        toolState.hasContent = true;
+        await syncToolInputToView(state, toolCallId, toolState);
+    }
+    state.streamedToolCallIds.add(toolCallId);
+};
+const handleToolInputEnd = (part, state) => {
+    const toolInputEndPart = part;
+    const toolCallId = getToolInputId(toolInputEndPart);
+    if (toolCallId) {
+        state.streamedToolCallIds.add(toolCallId);
+    }
+};
+const handleToolCall = (part, state) => {
+    const toolCallPart = part;
+    const inputState = state.activeToolInputs.get(toolCallPart.toolCallId);
+    const shouldSkipToolCallRender = state.streamedToolCallIds.has(toolCallPart.toolCallId) &&
+        inputState?.hasContent === true;
+    state.activeToolInputs.delete(toolCallPart.toolCallId);
+    state.streamedToolCallIds.delete(toolCallPart.toolCallId);
+    state.resetAssistantView(true);
+    const view = state.ensureToolView(toolCallPart.toolCallId, toolCallPart.toolName);
+    view.setFinalInput(toolCallPart.input);
+    if (!shouldSkipToolCallRender) {
+        view.setToolName(toolCallPart.toolName);
+    }
+};
+const handleToolResult = (part, state) => {
+    if (!state.flags.showToolResults) {
+        return;
+    }
+    const toolResultPart = part;
+    state.resetAssistantView(true);
+    const view = state.ensureToolView(toolResultPart.toolCallId, toolResultPart.toolName);
+    view.setOutput(toolResultPart.output);
+};
+const handleToolError = (part, state) => {
+    const toolErrorPart = part;
+    state.resetAssistantView(true);
+    const view = state.ensureToolView(toolErrorPart.toolCallId, toolErrorPart.toolName);
+    view.setError(toolErrorPart.error);
+};
+const handleToolOutputDenied = (part, state) => {
+    const deniedPart = part;
+    state.resetAssistantView(true);
+    const view = state.ensureToolView(deniedPart.toolCallId, deniedPart.toolName);
+    view.setOutputDenied();
+};
+const handleStartStep = (_part, state) => {
+    if (!state.flags.showSteps) {
+        return;
+    }
+    state.resetAssistantView();
+    addChatComponent(state.chatContainer, createInfoMessage("[step start]", ""));
+};
+const handleFinishStep = (part, state) => {
+    if (!state.flags.showSteps) {
+        return;
+    }
+    const finishStepPart = part;
+    state.resetAssistantView();
+    addChatComponent(state.chatContainer, createInfoMessage("[step finish]", finishStepPart.finishReason));
+};
+const handleSource = (part, state) => {
+    if (!state.flags.showSources) {
+        return;
+    }
+    state.resetAssistantView();
+    addChatComponent(state.chatContainer, createInfoMessage("[source]", part));
+};
+const handleFile = (part, state) => {
+    if (!state.flags.showFiles) {
+        return;
+    }
+    const filePart = part;
+    state.resetAssistantView();
+    addChatComponent(state.chatContainer, createInfoMessage("[file]", filePart.file));
+};
+const handleFinish = (part, state) => {
+    if (!state.flags.showFinishReason) {
+        return;
+    }
+    const finishPart = part;
+    state.resetAssistantView();
+    addChatComponent(state.chatContainer, createInfoMessage("[finish]", finishPart.finishReason ?? "unknown"));
+};
+const STREAM_HANDLERS = {
+    "text-start": handleTextStart,
+    "text-delta": handleTextDelta,
+    "reasoning-start": handleReasoningStart,
+    "reasoning-delta": handleReasoningDelta,
+    "tool-input-start": handleToolInputStart,
+    "tool-input-delta": handleToolInputDelta,
+    "tool-input-end": handleToolInputEnd,
+    "tool-call": handleToolCall,
+    "tool-result": handleToolResult,
+    "tool-error": handleToolError,
+    "tool-output-denied": handleToolOutputDenied,
+    "start-step": handleStartStep,
+    "finish-step": handleFinishStep,
+    source: handleSource,
+    file: handleFile,
+    finish: handleFinish,
+};
+const IGNORE_PART_TYPES = new Set([
+    "abort",
+    "text-end",
+    "reasoning-end",
+    "start",
+    "tool-approval-request",
+]);
+const isVisibleStreamPart = (part, flags) => {
+    switch (part.type) {
+        case "abort":
+        case "text-end":
+        case "reasoning-end":
+        case "start":
+        case "tool-approval-request":
+        case "text-start":
+        case "reasoning-start":
+        case "tool-input-end":
+            return false;
+        case "reasoning-delta":
+            return flags.showReasoning;
+        case "tool-result":
+            return flags.showToolResults;
+        case "start-step":
+        case "finish-step":
+            return flags.showSteps;
+        case "source":
+            return flags.showSources;
+        case "file":
+            return flags.showFiles;
+        case "finish":
+            return flags.showFinishReason;
+        default:
+            return true;
+    }
+};
+const handleStreamPart = async (part, state) => {
+    const handler = STREAM_HANDLERS[part.type];
+    if (handler) {
+        await handler(part, state);
+        return;
+    }
+    if (IGNORE_PART_TYPES.has(part.type)) {
+        return;
+    }
+    state.resetAssistantView();
+    addChatComponent(state.chatContainer, createInfoMessage("[unknown part]", part));
+};
+export const renderFullStreamWithPiTui = async (stream, options) => {
+    const flags = {
+        showReasoning: options.showReasoning ?? true,
+        showSteps: options.showSteps ?? false,
+        showFinishReason: options.showFinishReason ?? false,
+        showRawToolIo: options.showRawToolIo ?? isRawToolIoEnabledByEnv(),
+        showToolResults: options.showToolResults ?? true,
+        showSources: options.showSources ?? false,
+        showFiles: options.showFiles ?? false,
+    };
+    const activeToolInputs = new Map();
+    const streamedToolCallIds = new Set();
+    const toolViews = new Map();
+    let assistantView = null;
+    let suppressAssistantLeadingSpacer = false;
+    let firstVisiblePartSeen = false;
+    const resetAssistantView = (suppressLeadingSpacer = false) => {
+        if (suppressLeadingSpacer) {
+            suppressAssistantLeadingSpacer = true;
+        }
+        assistantView = null;
+    };
+    const ensureAssistantView = () => {
+        if (!assistantView) {
+            assistantView = new AssistantStreamView(options.markdownTheme);
+            addChatComponent(options.chatContainer, assistantView, {
+                addLeadingSpacer: !suppressAssistantLeadingSpacer,
+            });
+            suppressAssistantLeadingSpacer = false;
+        }
+        return assistantView;
+    };
+    const ensureToolView = (toolCallId, toolName) => {
+        const existing = toolViews.get(toolCallId);
+        if (existing) {
+            existing.setToolName(toolName);
+            return existing;
+        }
+        const view = new ToolCallView(toolCallId, toolName, options.markdownTheme, () => options.ui.requestRender(), flags.showRawToolIo);
+        toolViews.set(toolCallId, view);
+        addChatComponent(options.chatContainer, view);
+        return view;
+    };
+    const state = {
+        flags,
+        activeToolInputs,
+        streamedToolCallIds,
+        resetAssistantView,
+        ensureAssistantView,
+        ensureToolView,
+        getToolView: (toolCallId) => toolViews.get(toolCallId),
+        chatContainer: options.chatContainer,
+    };
+    try {
+        for await (const rawPart of stream) {
+            const part = rawPart;
+            if (!firstVisiblePartSeen && isVisibleStreamPart(part, flags)) {
+                firstVisiblePartSeen = true;
+                options.onFirstVisiblePart?.();
+            }
+            await handleStreamPart(part, state);
+            options.ui.requestRender();
+        }
+    }
+    finally {
+        for (const view of toolViews.values()) {
+            view.dispose();
+        }
+    }
+};
+//# sourceMappingURL=pi-tui-stream-renderer.js.map