pi-ui-extend 0.1.1

package/dist/app/scroll-controller.js

@@ -0,0 +1,207 @@
+import { sanitizeText } from "./render-text.js";
+export class AppScrollController {
+    host;
+    scrollFromBottom = 0;
+    detachedScrollStart;
+    constructor(host) {
+        this.host = host;
+    }
+    reset() {
+        this.scrollFromBottom = 0;
+        this.detachedScrollStart = undefined;
+    }
+    conversationView(columns, bodyHeight) {
+        const metrics = this.scrollMetrics(columns, bodyHeight);
+        return {
+            lines: this.host.conversationViewport().slice(metrics.viewportColumns, metrics.start, bodyHeight),
+            metrics,
+        };
+    }
+    visibleConversationLines(columns, bodyHeight) {
+        return this.conversationView(columns, bodyHeight).lines;
+    }
+    scrollMetrics(columns, bodyHeight) {
+        const conversationViewport = this.host.conversationViewport();
+        const viewportColumns = this.viewportColumns(columns, bodyHeight);
+        const conversationLineCount = conversationViewport.lineCount(viewportColumns);
+        const maxScroll = Math.max(0, conversationLineCount - bodyHeight);
+        let start;
+        if (this.detachedScrollStart !== undefined) {
+            start = Math.max(0, Math.min(maxScroll, this.detachedScrollStart));
+            this.scrollFromBottom = Math.max(0, conversationLineCount - bodyHeight - start);
+            this.detachedScrollStart = start >= maxScroll ? undefined : start;
+        }
+        else {
+            this.scrollFromBottom = Math.min(this.scrollFromBottom, maxScroll);
+            start = Math.max(0, conversationLineCount - bodyHeight - this.scrollFromBottom);
+        }
+        return { bodyHeight, viewportColumns, conversationLineCount, maxScroll, start };
+    }
+    scrollBarForMetrics(metrics) {
+        if (metrics.bodyHeight <= 0 || metrics.maxScroll <= 0 || metrics.conversationLineCount <= metrics.bodyHeight)
+            return undefined;
+        const thumbSize = Math.max(1, Math.min(metrics.bodyHeight, Math.round((metrics.bodyHeight * metrics.bodyHeight) / metrics.conversationLineCount)));
+        const travel = Math.max(0, metrics.bodyHeight - thumbSize);
+        const thumbOffset = travel === 0 ? 0 : Math.round((metrics.start / metrics.maxScroll) * travel);
+        return {
+            thumbStartRow: thumbOffset + 1,
+            thumbEndRow: thumbOffset + thumbSize,
+        };
+    }
+    scrollBarMetrics(columns, bodyHeight) {
+        return this.scrollBarForMetrics(this.scrollMetrics(columns, bodyHeight));
+    }
+    scrollByPage(direction) {
+        const rows = this.host.terminalRows();
+        this.scrollByLines(direction * Math.max(1, editorLayoutRows(rows, this.host.tabPanelRows(rows)) - 4));
+    }
+    scrollByLines(delta, options = {}) {
+        const shouldRender = options.render ?? true;
+        const columns = this.host.terminalColumns();
+        const terminalRows = this.host.terminalRows();
+        const rows = editorLayoutRows(terminalRows, this.host.tabPanelRows(terminalRows));
+        const { bodyHeight } = this.host.editorLayoutRenderer().computeLayout(columns, rows);
+        const metrics = this.scrollMetrics(columns, bodyHeight);
+        const { conversationLineCount, maxScroll } = metrics;
+        const nextScrollFromBottom = Math.max(0, Math.min(maxScroll, this.scrollFromBottom + -delta));
+        if (nextScrollFromBottom === this.scrollFromBottom) {
+            if (nextScrollFromBottom === 0 && this.detachedScrollStart !== undefined && delta > 0) {
+                this.detachedScrollStart = undefined;
+                if (shouldRender)
+                    this.host.render();
+                return true;
+            }
+            return false;
+        }
+        this.scrollFromBottom = nextScrollFromBottom;
+        this.detachedScrollStart = nextScrollFromBottom === 0
+            ? undefined
+            : Math.max(0, conversationLineCount - bodyHeight - nextScrollFromBottom);
+        if (shouldRender)
+            this.host.render();
+        return true;
+    }
+    scrollToScrollbarPosition(bodyRow) {
+        const columns = this.host.terminalColumns();
+        const terminalRows = this.host.terminalRows();
+        const rows = editorLayoutRows(terminalRows, this.host.tabPanelRows(terminalRows));
+        const { bodyHeight } = this.host.editorLayoutRenderer().computeLayout(columns, rows);
+        const metrics = this.scrollMetrics(columns, bodyHeight);
+        if (!this.scrollBarForMetrics(metrics))
+            return false;
+        const clampedRow = Math.max(0, Math.min(Math.max(0, bodyHeight - 1), bodyRow));
+        const ratio = bodyHeight <= 1 ? 0 : clampedRow / (bodyHeight - 1);
+        const start = Math.round(metrics.maxScroll * ratio);
+        return this.scrollToStart(start, metrics);
+    }
+    scrollToConversationEntry(entryId) {
+        const columns = this.host.terminalColumns();
+        const terminalRows = this.host.terminalRows();
+        const rows = editorLayoutRows(terminalRows, this.host.tabPanelRows(terminalRows));
+        const conversationViewport = this.host.conversationViewport();
+        const { bodyHeight } = this.host.editorLayoutRenderer().computeLayout(columns, rows);
+        const metrics = this.scrollMetrics(columns, bodyHeight);
+        const position = conversationViewport.entryBlockPositions(metrics.viewportColumns).find((candidate) => candidate.entry.id === entryId);
+        if (!position)
+            return false;
+        this.setScrollStart(position.offset, metrics);
+        this.host.render();
+        return true;
+    }
+    scrollToConversationText(target) {
+        const needles = normalizeLineSearchNeedles(target.needles);
+        if (needles.length === 0)
+            return target.entryId ? this.scrollToConversationEntry(target.entryId) : false;
+        const columns = this.host.terminalColumns();
+        const terminalRows = this.host.terminalRows();
+        const rows = editorLayoutRows(terminalRows, this.host.tabPanelRows(terminalRows));
+        const conversationViewport = this.host.conversationViewport();
+        const { bodyHeight } = this.host.editorLayoutRenderer().computeLayout(columns, rows);
+        const metrics = this.scrollMetrics(columns, bodyHeight);
+        const positions = conversationViewport.entryBlockPositions(metrics.viewportColumns);
+        const targetPosition = target.entryId
+            ? positions.find((position) => position.entry.id === target.entryId)
+            : undefined;
+        const targetMatch = targetPosition ? lineMatchInPosition(targetPosition, needles) : undefined;
+        if (targetMatch) {
+            this.setScrollStart(targetMatch.start, metrics);
+            this.host.render();
+            return true;
+        }
+        if (targetPosition) {
+            this.setScrollStart(targetPosition.offset, metrics);
+            this.host.render();
+            return true;
+        }
+        const anyMatch = positions
+            .map((position) => lineMatchInPosition(position, needles))
+            .find((match) => match !== undefined);
+        if (anyMatch) {
+            this.setScrollStart(anyMatch.start, metrics);
+            this.host.render();
+            return true;
+        }
+        return false;
+    }
+    scrollToStart(start, metrics) {
+        if (!this.setScrollStart(start, metrics))
+            return false;
+        this.host.render();
+        return true;
+    }
+    setScrollStart(start, metrics) {
+        const nextStart = Math.max(0, Math.min(metrics.maxScroll, start));
+        const nextScrollFromBottom = Math.max(0, metrics.conversationLineCount - metrics.bodyHeight - nextStart);
+        const nextDetachedScrollStart = nextScrollFromBottom === 0 ? undefined : nextStart;
+        const changed = this.scrollFromBottom !== nextScrollFromBottom || this.detachedScrollStart !== nextDetachedScrollStart;
+        this.scrollFromBottom = nextScrollFromBottom;
+        this.detachedScrollStart = nextDetachedScrollStart;
+        return changed;
+    }
+    viewportColumns(columns, bodyHeight) {
+        const safeColumns = Math.max(1, columns);
+        if (safeColumns <= 1 || bodyHeight <= 0)
+            return safeColumns;
+        const lineCountWithoutScrollbar = this.host.conversationViewport().lineCount(safeColumns);
+        return lineCountWithoutScrollbar > bodyHeight ? safeColumns - 1 : safeColumns;
+    }
+}
+function editorLayoutRows(terminalRows, tabPanelRows) {
+    return Math.max(1, terminalRows - tabPanelRows);
+}
+function normalizeLineSearchNeedles(needles) {
+    const seen = new Set();
+    const normalized = [];
+    for (const needle of needles) {
+        const value = normalizeLineSearchText(needle);
+        if (!value || seen.has(value))
+            continue;
+        seen.add(value);
+        normalized.push(value);
+    }
+    return normalized;
+}
+function normalizeLineSearchText(text) {
+    return sanitizeText(text).replace(/…/gu, " ").replace(/\s+/gu, " ").trim().toLocaleLowerCase();
+}
+function lineMatchInPosition(position, needles) {
+    const lineIndex = lineIndexForNeedles(position.block.lines, needles);
+    return lineIndex === undefined ? undefined : { start: position.offset + lineIndex };
+}
+function lineIndexForNeedles(lines, needles) {
+    const normalizedLines = lines.map((line) => normalizeLineSearchText(line.text));
+    for (const needle of needles) {
+        const directIndex = normalizedLines.findIndex((line) => line.includes(needle));
+        if (directIndex >= 0)
+            return directIndex;
+        const maxWindowSize = Math.min(4, normalizedLines.length);
+        for (let windowSize = 2; windowSize <= maxWindowSize; windowSize += 1) {
+            for (let start = 0; start <= normalizedLines.length - windowSize; start += 1) {
+                const windowText = normalizedLines.slice(start, start + windowSize).join(" ").replace(/\s+/gu, " ").trim();
+                if (windowText.includes(needle))
+                    return start;
+            }
+        }
+    }
+    return undefined;
+}

package/dist/app/session-event-controller.d.ts

@@ -0,0 +1,69 @@
+import type { AgentSessionEvent, AgentSessionRuntime } from "@earendil-works/pi-coding-agent";
+import type { ConversationViewport } from "./conversation-viewport.js";
+import type { Entry, SessionActivity } from "./types.js";
+import type { WorkspaceMutation, WorkspaceMutationPreparation } from "./workspace-undo.js";
+export type AppSessionEventControllerHost = {
+    readonly entries: Entry[];
+    runtime(): AgentSessionRuntime | undefined;
+    conversationViewport(): ConversationViewport;
+    isRunning(): boolean;
+    render(): void;
+    setStatus(status: string): void;
+    restoreSessionStatus(): void;
+    setSessionStatus(session: AgentSessionRuntime["session"] | undefined): void;
+    setSessionActivity(activity: SessionActivity): void;
+    flushDeferredUserMessages(): void;
+    updateQueuedMessageStatus(): void;
+    prepareWorkspaceMutation(toolName: string, args: unknown): WorkspaceMutationPreparation | undefined;
+    recordWorkspaceMutationForUserEntry(entryId: string, mutation: WorkspaceMutation): void;
+    workspaceMutationFromToolExecution(input: {
+        toolName: string;
+        args: unknown;
+        details: unknown;
+        isError: boolean;
+        preparation?: WorkspaceMutationPreparation | undefined;
+    }): WorkspaceMutation | undefined;
+    scheduleUserSessionEntryMetadataSync(): void;
+    toolDefaultExpanded(toolName: string): boolean;
+    observeSubagentsToolResult(toolName: string, details: unknown, options?: {
+        showSnapshot?: boolean;
+    }): void;
+    observeTodoToolResult(toolName: string, details: unknown, isError?: boolean): void;
+    showToast(message: string, kind: "success" | "error" | "warning" | "info"): void;
+};
+export declare class AppSessionEventController {
+    private readonly host;
+    readonly entryRenderVersions: Map<string, number>;
+    private readonly toolEntryIdsByCallId;
+    private readonly toolMutationPreparationsByCallId;
+    private currentUserEntryId;
+    private currentAssistantEntryId;
+    private currentThinkingEntryId;
+    constructor(host: AppSessionEventControllerHost);
+    reset(): void;
+    loadSessionHistory(): void;
+    loadSessionHistoryAsync(options: {
+        isCancelled: () => boolean;
+        render: () => void;
+    }): Promise<boolean>;
+    handleSessionEvent(event: AgentSessionEvent): void;
+    addCustomMessageEntry(message: Record<string, unknown>): void;
+    findEntry(id: string): Entry | undefined;
+    findUserEntry(id: string): Extract<Entry, {
+        kind: "user";
+    }> | undefined;
+    touchEntry(entry: Entry): void;
+    addEntry(entry: Entry): void;
+    private prependEntries;
+    addSessionAbortedEntry(): void;
+    private handleMessageStart;
+    private handleMessageEnd;
+    private prepareToolWorkspaceMutation;
+    private recordToolWorkspaceMutation;
+    private handleMessageUpdate;
+    private appendAssistantText;
+    private appendThinkingText;
+    private finishCurrentThinkingEntry;
+    private upsertToolEntry;
+    private clearCurrentAssistantState;
+}

package/dist/app/session-event-controller.js

@@ -0,0 +1,338 @@
+import { createId } from "./id.js";
+import { extractImageContents, renderContent, renderUserMessageContent, stringifyUnknown } from "./message-content.js";
+import { customMessageEntry, loadSessionHistoryEntries, loadSessionHistoryEntriesAsync } from "./session-history.js";
+import { isRecord } from "./guards.js";
+export class AppSessionEventController {
+    host;
+    entryRenderVersions = new Map();
+    toolEntryIdsByCallId = new Map();
+    toolMutationPreparationsByCallId = new Map();
+    currentUserEntryId;
+    currentAssistantEntryId;
+    currentThinkingEntryId;
+    constructor(host) {
+        this.host = host;
+    }
+    reset() {
+        this.toolEntryIdsByCallId.clear();
+        this.toolMutationPreparationsByCallId.clear();
+        this.currentUserEntryId = undefined;
+        this.entryRenderVersions.clear();
+        this.currentAssistantEntryId = undefined;
+        this.currentThinkingEntryId = undefined;
+    }
+    loadSessionHistory() {
+        const runtime = this.host.runtime();
+        if (!runtime)
+            return;
+        loadSessionHistoryEntries({
+            messages: runtime.session.messages,
+            addEntry: (entry) => this.addEntry(entry),
+            setToolEntryId: (toolCallId, entryId) => this.toolEntryIdsByCallId.set(toolCallId, entryId),
+            toolDefaultExpanded: (toolName) => this.host.toolDefaultExpanded(toolName),
+            observeSubagentsToolResult: (toolName, details, options) => this.host.observeSubagentsToolResult(toolName, details, options),
+            observeTodoToolResult: (toolName, details, isError) => this.host.observeTodoToolResult(toolName, details, isError),
+        });
+    }
+    async loadSessionHistoryAsync(options) {
+        const runtime = this.host.runtime();
+        if (!runtime)
+            return !options.isCancelled();
+        return loadSessionHistoryEntriesAsync({
+            messages: runtime.session.messages,
+            addEntry: (entry) => this.addEntry(entry),
+            prependEntries: (entries) => this.prependEntries(entries),
+            setToolEntryId: (toolCallId, entryId) => this.toolEntryIdsByCallId.set(toolCallId, entryId),
+            toolDefaultExpanded: (toolName) => this.host.toolDefaultExpanded(toolName),
+            observeSubagentsToolResult: (toolName, details, options) => this.host.observeSubagentsToolResult(toolName, details, options),
+            observeTodoToolResult: (toolName, details, isError) => this.host.observeTodoToolResult(toolName, details, isError),
+            isCancelled: options.isCancelled,
+            render: options.render,
+        });
+    }
+    handleSessionEvent(event) {
+        switch (event.type) {
+            case "session_info_changed":
+                this.host.setSessionStatus(this.host.runtime()?.session);
+                break;
+            case "message_start":
+                this.handleMessageStart(event.message);
+                break;
+            case "message_end":
+                this.handleMessageEnd(event.message);
+                break;
+            case "agent_start":
+                this.host.setSessionActivity("running");
+                this.host.setSessionStatus(this.host.runtime()?.session);
+                this.host.flushDeferredUserMessages();
+                break;
+            case "thinking_level_changed":
+                this.host.setSessionStatus(this.host.runtime()?.session);
+                break;
+            case "agent_end":
+                this.finishCurrentThinkingEntry();
+                this.clearCurrentAssistantState();
+                this.currentUserEntryId = undefined;
+                this.host.setSessionActivity("idle");
+                this.host.setSessionStatus(this.host.runtime()?.session);
+                this.host.flushDeferredUserMessages();
+                break;
+            case "queue_update":
+                this.host.updateQueuedMessageStatus();
+                break;
+            case "message_update":
+                this.handleMessageUpdate(event.assistantMessageEvent);
+                break;
+            case "tool_execution_start":
+                this.finishCurrentThinkingEntry();
+                this.currentAssistantEntryId = undefined;
+                this.host.setSessionActivity("running");
+                this.prepareToolWorkspaceMutation(event.toolCallId, event.toolName, event.args);
+                this.upsertToolEntry(event.toolCallId, {
+                    toolName: event.toolName,
+                    argsText: stringifyUnknown(event.args),
+                    status: "running",
+                });
+                break;
+            case "tool_execution_update":
+                this.host.setSessionActivity("running");
+                this.host.observeSubagentsToolResult(event.toolName, isRecord(event.partialResult) ? event.partialResult.details : undefined);
+                this.host.observeTodoToolResult(event.toolName, isRecord(event.partialResult) ? event.partialResult.details : undefined);
+                this.upsertToolEntry(event.toolCallId, {
+                    toolName: event.toolName,
+                    argsText: stringifyUnknown(event.args),
+                    output: renderContent(event.partialResult.content),
+                    images: extractImageContents(event.partialResult.content),
+                    ...(isRecord(event.partialResult) && event.partialResult.details !== undefined ? { details: event.partialResult.details } : {}),
+                    status: "running",
+                });
+                break;
+            case "tool_execution_end":
+                this.host.setSessionActivity(this.host.runtime()?.session.isStreaming ? "running" : "idle");
+                this.recordToolWorkspaceMutation(event.toolCallId, event.toolName, event.result.details, event.isError);
+                this.host.observeSubagentsToolResult(event.toolName, isRecord(event.result) ? event.result.details : undefined);
+                this.host.observeTodoToolResult(event.toolName, isRecord(event.result) ? event.result.details : undefined, event.isError);
+                this.upsertToolEntry(event.toolCallId, {
+                    toolName: event.toolName,
+                    output: renderContent(event.result.content),
+                    images: extractImageContents(event.result.content),
+                    details: event.result.details,
+                    isError: event.isError,
+                    status: "done",
+                });
+                break;
+            case "compaction_start":
+                this.host.setSessionActivity("running");
+                this.host.setStatus(`compacting (${event.reason})`);
+                break;
+            case "compaction_end": {
+                this.host.setSessionActivity(this.host.runtime()?.session.isStreaming ? "running" : "idle");
+                this.host.restoreSessionStatus();
+                const message = event.result
+                    ? `Compacted ${event.result.tokensBefore} tokens`
+                    : event.aborted
+                        ? "Compaction cancelled"
+                        : event.errorMessage ?? "Compaction failed";
+                this.host.showToast(message, event.result ? "success" : event.aborted ? "info" : "error");
+                this.host.flushDeferredUserMessages();
+                break;
+            }
+            case "auto_retry_start":
+                this.host.setSessionActivity("running");
+                this.host.setStatus(`retry ${event.attempt}/${event.maxAttempts}`);
+                break;
+            case "auto_retry_end":
+                this.host.setSessionActivity(this.host.runtime()?.session.isStreaming ? "running" : "idle");
+                this.host.restoreSessionStatus();
+                this.host.showToast(event.success ? "Retry succeeded" : `Retry failed: ${event.finalError}`, event.success ? "success" : "error");
+                break;
+            default:
+                break;
+        }
+        this.host.render();
+    }
+    addCustomMessageEntry(message) {
+        const entry = customMessageEntry(message);
+        if (entry)
+            this.addEntry(entry);
+    }
+    findEntry(id) {
+        return this.host.entries.find((entry) => entry.id === id);
+    }
+    findUserEntry(id) {
+        const entry = this.findEntry(id);
+        return entry?.kind === "user" ? entry : undefined;
+    }
+    touchEntry(entry) {
+        this.entryRenderVersions.set(entry.id, (this.entryRenderVersions.get(entry.id) ?? 0) + 1);
+        this.host.conversationViewport().deleteEntry(entry.id);
+    }
+    addEntry(entry) {
+        this.host.entries.push(entry);
+        this.entryRenderVersions.set(entry.id, 1);
+        this.host.conversationViewport().deleteEntry(entry.id);
+    }
+    prependEntries(entries) {
+        this.host.entries.unshift(...entries);
+        for (const entry of entries) {
+            this.entryRenderVersions.set(entry.id, 1);
+            this.host.conversationViewport().deleteEntry(entry.id);
+        }
+    }
+    addSessionAbortedEntry() {
+        this.finishCurrentThinkingEntry();
+        this.clearCurrentAssistantState();
+        this.addEntry({ id: createId("session-aborted"), kind: "session-aborted", text: "Session aborted." });
+    }
+    handleMessageStart(message) {
+        if (isRecord(message) && message.role === "custom") {
+            this.addCustomMessageEntry(message);
+            return;
+        }
+        if (isRecord(message) && message.role === "user") {
+            const text = renderUserMessageContent(message.content);
+            if (!text)
+                return;
+            const images = extractImageContents(message.content);
+            const entryId = createId("user");
+            this.addEntry({
+                id: entryId,
+                kind: "user",
+                text,
+                workspaceMutations: [],
+                ...(images.length === 0 ? {} : { images }),
+            });
+            this.currentUserEntryId = entryId;
+            return;
+        }
+        if (isRecord(message) && message.role === "assistant")
+            this.clearCurrentAssistantState();
+    }
+    handleMessageEnd(message) {
+        if (isRecord(message) && message.role === "user") {
+            this.host.scheduleUserSessionEntryMetadataSync();
+        }
+        if (isRecord(message) && message.role === "assistant") {
+            this.finishCurrentThinkingEntry();
+            this.clearCurrentAssistantState();
+            this.currentUserEntryId = undefined;
+        }
+    }
+    prepareToolWorkspaceMutation(toolCallId, toolName, args) {
+        const userEntryId = this.currentUserEntryId;
+        if (!userEntryId)
+            return;
+        const preparation = this.host.prepareWorkspaceMutation(toolName, args);
+        this.toolMutationPreparationsByCallId.set(toolCallId, {
+            userEntryId,
+            args,
+            ...(preparation === undefined ? {} : { preparation }),
+        });
+    }
+    recordToolWorkspaceMutation(toolCallId, toolName, details, isError) {
+        const prepared = this.toolMutationPreparationsByCallId.get(toolCallId);
+        if (!prepared)
+            return;
+        this.toolMutationPreparationsByCallId.delete(toolCallId);
+        const mutation = this.host.workspaceMutationFromToolExecution({
+            toolName,
+            args: prepared.args,
+            details,
+            isError,
+            preparation: prepared.preparation,
+        });
+        if (!mutation)
+            return;
+        this.host.recordWorkspaceMutationForUserEntry(prepared.userEntryId, mutation);
+    }
+    handleMessageUpdate(assistantEvent) {
+        switch (assistantEvent.type) {
+            case "text_delta":
+                this.finishCurrentThinkingEntry();
+                this.host.setSessionActivity("running");
+                this.appendAssistantText(assistantEvent.delta);
+                break;
+            case "thinking_delta":
+                this.host.setSessionActivity("thinking");
+                this.appendThinkingText(assistantEvent.delta);
+                break;
+            case "done":
+                this.finishCurrentThinkingEntry();
+                this.clearCurrentAssistantState();
+                this.host.setSessionActivity(this.host.runtime()?.session.isStreaming ? "running" : "idle");
+                break;
+            case "error":
+                this.finishCurrentThinkingEntry();
+                this.host.setSessionActivity(this.host.runtime()?.session.isStreaming ? "running" : "idle");
+                this.addEntry({ id: createId("error"), kind: "error", text: assistantEvent.error.errorMessage ?? assistantEvent.reason });
+                break;
+            default:
+                break;
+        }
+    }
+    appendAssistantText(delta) {
+        let entry = this.currentAssistantEntryId ? this.findEntry(this.currentAssistantEntryId) : undefined;
+        if (!entry || entry.kind !== "assistant") {
+            entry = { id: createId("assistant"), kind: "assistant", text: "" };
+            this.addEntry(entry);
+            this.currentAssistantEntryId = entry.id;
+        }
+        entry.text += delta;
+        this.touchEntry(entry);
+    }
+    appendThinkingText(delta) {
+        let entry = this.currentThinkingEntryId ? this.findEntry(this.currentThinkingEntryId) : undefined;
+        if (!entry || entry.kind !== "thinking") {
+            entry = { id: createId("thinking"), kind: "thinking", text: "", expanded: false, status: "running" };
+            this.addEntry(entry);
+            this.currentThinkingEntryId = entry.id;
+        }
+        entry.status = "running";
+        entry.text += delta;
+        this.touchEntry(entry);
+    }
+    finishCurrentThinkingEntry() {
+        const entry = this.currentThinkingEntryId ? this.findEntry(this.currentThinkingEntryId) : undefined;
+        if (entry?.kind === "thinking" && entry.status !== "done") {
+            entry.status = "done";
+            this.touchEntry(entry);
+        }
+        this.currentThinkingEntryId = undefined;
+    }
+    upsertToolEntry(toolCallId, update) {
+        const existingId = this.toolEntryIdsByCallId.get(toolCallId);
+        const existing = existingId ? this.findEntry(existingId) : undefined;
+        if (existing?.kind === "tool") {
+            existing.toolName = update.toolName ?? existing.toolName;
+            existing.argsText = update.argsText ?? existing.argsText;
+            existing.output = update.output ?? existing.output;
+            if ("images" in update)
+                existing.images = update.images;
+            if ("details" in update)
+                existing.details = update.details;
+            existing.isError = update.isError ?? existing.isError;
+            existing.status = update.status ?? existing.status;
+            this.touchEntry(existing);
+            return;
+        }
+        const entry = {
+            id: createId("tool"),
+            kind: "tool",
+            toolCallId,
+            toolName: update.toolName ?? "tool",
+            argsText: update.argsText ?? "{}",
+            output: update.output ?? "",
+            ...(update.images === undefined ? {} : { images: update.images }),
+            ...("details" in update ? { details: update.details } : {}),
+            expanded: this.host.toolDefaultExpanded(update.toolName ?? "tool"),
+            isError: update.isError ?? false,
+            status: update.status ?? "running",
+        };
+        this.toolEntryIdsByCallId.set(toolCallId, entry.id);
+        this.addEntry(entry);
+    }
+    clearCurrentAssistantState() {
+        this.currentAssistantEntryId = undefined;
+        this.currentThinkingEntryId = undefined;
+    }
+}

package/dist/app/session-history.d.ts

@@ -0,0 +1,23 @@
+import type { Entry } from "./types.js";
+type SubagentsToolResultObserveOptions = {
+    showSnapshot?: boolean;
+};
+export type LoadSessionHistoryOptions = {
+    messages: readonly unknown[] | undefined;
+    addEntry: (entry: Entry) => void;
+    setToolEntryId: (toolCallId: string, entryId: string) => void;
+    toolDefaultExpanded: (toolName: string) => boolean;
+    observeSubagentsToolResult: (toolName: string, details: unknown, options?: SubagentsToolResultObserveOptions) => void;
+    observeTodoToolResult: (toolName: string, details: unknown, isError: boolean) => void;
+};
+export type LoadSessionHistoryAsyncOptions = LoadSessionHistoryOptions & {
+    prependEntries: (entries: readonly Entry[]) => void;
+    render: () => void;
+    isCancelled: () => boolean;
+    chunkSize?: number;
+    tailMessageCount?: number;
+};
+export declare function loadSessionHistoryEntries(options: LoadSessionHistoryOptions): void;
+export declare function loadSessionHistoryEntriesAsync(options: LoadSessionHistoryAsyncOptions): Promise<boolean>;
+export declare function customMessageEntry(message: Record<string, unknown>): Entry | undefined;
+export {};