pi-ui-extend 0.1.32 → 0.1.34

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

@@ -1,21 +1,32 @@
 import { createId } from "../id.js";
 import { extractImageContents, renderContent, renderUserMessageContent, stringifyUnknown } from "../rendering/message-content.js";
 import { customMessageEntry, loadSessionHistoryEntries, loadSessionHistoryEntriesAsync } from "./session-history.js";
-import { sessionHistoryDisplayMessages, sessionHistoryOlderMessagesReader } from "./pix-system-message.js";
+import { sessionHistoryDisplayMessages, sessionHistoryDisplayMessagesFromEntries, sessionHistoryFullBranchEntries } from "./pix-system-message.js";
+import { THINKING_TOOL_NAME } from "../constants.js";
 import { isRecord } from "../guards.js";
 const DCP_MESSAGE_REFERENCE_PREFIX = "[dcp-id]: # (m";
 const DCP_BLOCK_REFERENCE_PREFIX = "[dcp-block-id]: # (b";
 const MAX_HISTORY_WINDOW_ENTRIES = 360;
 const HISTORY_WINDOW_TARGET_ENTRIES = 300;
+const HISTORY_WINDOW_SHIFT_ENTRIES = 50;
 export class AppSessionEventController {
     host;
     entryRenderVersions = new Map();
     toolEntryIdsByCallId = new Map();
+    pendingToolCallIdsByContentIndex = new Map();
     toolMutationPreparationsByCallId = new Map();
     olderHistoryLoader;
     currentUserEntryId;
     currentAssistantEntryId;
+    currentAssistantTextBlockEntryId;
+    currentAssistantTextBlockStartLength;
+    currentAssistantTextBlockContentIndex;
+    assistantTextBlocksByContentIndex = new Map();
+    finalizedToolCallContentIndexes = new Set();
+    historyEntries = [];
+    historyWindowStart = 0;
     currentThinkingEntryId;
+    assistantMessageClosed = false;
     assistantTextBuffer = "";
     constructor(host) {
         this.host = host;
@@ -23,38 +34,67 @@ export class AppSessionEventController {
     snapshotState() {
         return {
             toolEntryIdsByCallId: new Map(this.toolEntryIdsByCallId),
+            pendingToolCallIdsByContentIndex: new Map(this.pendingToolCallIdsByContentIndex),
             toolMutationPreparationsByCallId: new Map(this.toolMutationPreparationsByCallId),
             olderHistoryLoader: this.olderHistoryLoader,
             currentUserEntryId: this.currentUserEntryId,
             currentAssistantEntryId: this.currentAssistantEntryId,
+            currentAssistantTextBlockEntryId: this.currentAssistantTextBlockEntryId,
+            currentAssistantTextBlockStartLength: this.currentAssistantTextBlockStartLength,
+            currentAssistantTextBlockContentIndex: this.currentAssistantTextBlockContentIndex,
+            assistantTextBlocksByContentIndex: new Map(this.assistantTextBlocksByContentIndex),
             currentThinkingEntryId: this.currentThinkingEntryId,
+            assistantMessageClosed: this.assistantMessageClosed,
             assistantTextBuffer: this.assistantTextBuffer,
             entryRenderVersions: new Map(this.entryRenderVersions),
+            historyEntries: [...this.historyEntries],
+            historyWindowStart: this.historyWindowStart,
         };
     }
     restoreState(state) {
         this.toolEntryIdsByCallId.clear();
         for (const [key, value] of state.toolEntryIdsByCallId)
             this.toolEntryIdsByCallId.set(key, value);
+        this.pendingToolCallIdsByContentIndex.clear();
+        for (const [key, value] of state.pendingToolCallIdsByContentIndex)
+            this.pendingToolCallIdsByContentIndex.set(key, value);
         this.toolMutationPreparationsByCallId.clear();
         for (const [key, value] of state.toolMutationPreparationsByCallId)
             this.toolMutationPreparationsByCallId.set(key, value);
         this.olderHistoryLoader = state.olderHistoryLoader;
         this.currentUserEntryId = state.currentUserEntryId;
         this.currentAssistantEntryId = state.currentAssistantEntryId;
+        this.currentAssistantTextBlockEntryId = state.currentAssistantTextBlockEntryId;
+        this.currentAssistantTextBlockStartLength = state.currentAssistantTextBlockStartLength;
+        this.currentAssistantTextBlockContentIndex = state.currentAssistantTextBlockContentIndex;
+        this.assistantTextBlocksByContentIndex.clear();
+        for (const [key, value] of state.assistantTextBlocksByContentIndex)
+            this.assistantTextBlocksByContentIndex.set(key, value);
         this.currentThinkingEntryId = state.currentThinkingEntryId;
+        this.assistantMessageClosed = state.assistantMessageClosed;
         this.assistantTextBuffer = state.assistantTextBuffer;
         this.entryRenderVersions.clear();
         for (const [key, value] of state.entryRenderVersions)
             this.entryRenderVersions.set(key, value);
+        this.historyEntries = [...state.historyEntries];
+        this.historyWindowStart = state.historyWindowStart;
     }
     reset() {
         this.toolEntryIdsByCallId.clear();
+        this.pendingToolCallIdsByContentIndex.clear();
         this.toolMutationPreparationsByCallId.clear();
         this.currentUserEntryId = undefined;
         this.entryRenderVersions.clear();
+        this.historyEntries = [];
+        this.historyWindowStart = 0;
         this.currentAssistantEntryId = undefined;
+        this.currentAssistantTextBlockEntryId = undefined;
+        this.currentAssistantTextBlockStartLength = undefined;
+        this.currentAssistantTextBlockContentIndex = undefined;
+        this.assistantTextBlocksByContentIndex.clear();
+        this.finalizedToolCallContentIndexes.clear();
         this.currentThinkingEntryId = undefined;
+        this.assistantMessageClosed = false;
         this.assistantTextBuffer = "";
         this.olderHistoryLoader = undefined;
     }
@@ -76,32 +116,53 @@ export class AppSessionEventController {
         if (!runtime)
             return !options.isCancelled();
         this.olderHistoryLoader = undefined;
-        return loadSessionHistoryEntriesAsync({
-            messages: sessionHistoryDisplayMessages(runtime.session),
-            olderMessagesReader: sessionHistoryOlderMessagesReader(runtime.session),
-            addEntry: (entry) => this.addEntry(entry),
-            prependEntries: (entries) => this.prependEntries(entries),
+        this.historyEntries = [];
+        this.historyWindowStart = 0;
+        const branchEntries = await sessionHistoryFullBranchEntries(runtime.session);
+        if (options.isCancelled())
+            return false;
+        const historyEntries = [];
+        const loaded = await loadSessionHistoryEntriesAsync({
+            messages: sessionHistoryDisplayMessagesFromEntries(branchEntries),
+            addEntry: (entry) => historyEntries.push(entry),
+            prependEntries: (entries) => historyEntries.unshift(...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,
-            lazyOlderHistory: options.lazyOlderHistory === true,
-            onOlderLoaderReady: (loader) => {
-                this.olderHistoryLoader = loader;
-            },
+            render: () => { },
+            lazyOlderHistory: false,
         });
+        if (!loaded)
+            return false;
+        this.historyEntries = historyEntries;
+        this.setHistoryWindowStart(this.maxHistoryWindowStart());
+        options.render();
+        return !options.isCancelled();
     }
     hasOlderSessionHistory() {
+        if (this.historyEntries.length > 0)
+            return this.historyWindowStart > 0;
         return this.olderHistoryLoader?.hasOlder() === true;
     }
     isLoadingOlderSessionHistory() {
         return this.olderHistoryLoader?.isLoading() === true;
     }
     async loadOlderSessionHistory(options = {}) {
+        if (this.historyEntries.length > 0)
+            return this.shiftHistoryWindow(-HISTORY_WINDOW_SHIFT_ENTRIES, options);
         return this.olderHistoryLoader?.loadOlder(options) ?? false;
     }
+    hasNewerSessionHistory() {
+        return this.historyEntries.length > 0 && this.historyWindowStart < this.maxHistoryWindowStart();
+    }
+    isLoadingNewerSessionHistory() {
+        return false;
+    }
+    async loadNewerSessionHistory(options = {}) {
+        return this.shiftHistoryWindow(HISTORY_WINDOW_SHIFT_ENTRIES, options);
+    }
     handleSessionEvent(event) {
         switch (event.type) {
             case "session_info_changed":
@@ -114,6 +175,7 @@ export class AppSessionEventController {
                 this.handleMessageEnd(event.message);
                 break;
             case "agent_start":
+                this.assistantMessageClosed = false;
                 this.host.setSessionActivity("running");
                 this.host.setSessionStatus(this.host.runtime()?.session);
                 break;
@@ -123,19 +185,22 @@ export class AppSessionEventController {
             case "agent_end":
                 this.finishCurrentThinkingEntry();
                 this.clearCurrentAssistantState();
+                this.finalizeAbandonedToolEntries();
                 this.currentUserEntryId = undefined;
                 this.host.setSessionActivity("idle");
                 this.host.setSessionStatus(this.host.runtime()?.session);
+                this.host.flushAutoUserMessages();
                 break;
             case "queue_update":
                 this.host.updateQueuedMessageStatus();
                 break;
             case "message_update":
-                this.handleMessageUpdate(event.assistantMessageEvent);
+                this.handleMessageUpdate(event);
                 break;
             case "tool_execution_start":
                 this.finishCurrentThinkingEntry();
                 this.flushAssistantTextBuffer(true);
+                this.finishCurrentAssistantTextBlock();
                 this.currentAssistantEntryId = undefined;
                 this.host.setSessionActivity("running");
                 this.prepareToolWorkspaceMutation(event.toolCallId, event.toolName, event.args);
@@ -181,6 +246,7 @@ export class AppSessionEventController {
             case "compaction_end": {
                 this.host.setSessionActivity(this.host.runtime()?.session.isStreaming ? "running" : "idle");
                 this.host.restoreSessionStatus();
+                this.host.flushAutoUserMessages();
                 const message = event.result
                     ? `Compacted ${event.result.tokensBefore} tokens`
                     : event.aborted
@@ -196,6 +262,7 @@ export class AppSessionEventController {
             case "auto_retry_end":
                 this.host.setSessionActivity(this.host.runtime()?.session.isStreaming ? "running" : "idle");
                 this.host.restoreSessionStatus();
+                this.host.flushAutoUserMessages();
                 this.host.showToast(event.success ? "Retry succeeded" : `Retry failed: ${event.finalError}`, event.success ? "success" : "error");
                 break;
             default:
@@ -209,7 +276,7 @@ export class AppSessionEventController {
             this.addEntry(entry);
     }
     findEntry(id) {
-        return this.host.entries.find((entry) => entry.id === id);
+        return this.host.entries.find((entry) => entry.id === id) ?? this.historyEntries.find((entry) => entry.id === id);
     }
     findUserEntry(id) {
         const entry = this.findEntry(id);
@@ -220,28 +287,71 @@ export class AppSessionEventController {
         this.host.conversationViewport().deleteEntry(entry.id);
     }
     addEntry(entry) {
+        if (this.historyEntries.length > 0) {
+            const wasAtBottom = !this.hasNewerSessionHistory();
+            this.historyEntries.push(entry);
+            this.registerEntry(entry);
+            if (wasAtBottom)
+                this.setHistoryWindowStart(this.maxHistoryWindowStart());
+            return;
+        }
         this.host.entries.push(entry);
-        this.entryRenderVersions.set(entry.id, 1);
-        this.host.conversationViewport().deleteEntry(entry.id);
+        this.registerEntry(entry);
         this.pruneHistoryWindow("top");
     }
     prependEntries(entries) {
         this.host.entries.unshift(...entries);
-        for (const entry of entries) {
-            this.entryRenderVersions.set(entry.id, 1);
-            this.host.conversationViewport().deleteEntry(entry.id);
-        }
+        for (const entry of entries)
+            this.registerEntry(entry);
         this.pruneHistoryWindow("bottom");
     }
+    shiftHistoryWindow(delta, options = {}) {
+        if (this.historyEntries.length === 0)
+            return false;
+        const previousStart = this.historyWindowStart;
+        const nextStart = Math.max(0, Math.min(this.maxHistoryWindowStart(), previousStart + delta));
+        if (nextStart === previousStart)
+            return true;
+        if (nextStart < previousStart)
+            options.onPrependedEntries?.(this.historyEntries.slice(nextStart, previousStart));
+        this.setHistoryWindowStart(nextStart);
+        if (options.render !== false)
+            this.host.render();
+        return true;
+    }
+    setHistoryWindowStart(start) {
+        const nextStart = Math.max(0, Math.min(this.maxHistoryWindowStart(), start));
+        this.historyWindowStart = nextStart;
+        const nextEntries = this.historyEntries.slice(nextStart, nextStart + this.historyWindowSize());
+        const nextEntryIds = new Set(nextEntries.map((entry) => entry.id));
+        for (const entry of this.host.entries) {
+            if (!nextEntryIds.has(entry.id))
+                this.host.conversationViewport().deleteEntry(entry.id);
+        }
+        this.host.entries.splice(0, this.host.entries.length, ...nextEntries);
+        for (const entry of nextEntries)
+            this.registerEntry(entry);
+    }
+    historyWindowSize() {
+        return Math.min(HISTORY_WINDOW_TARGET_ENTRIES, this.historyEntries.length);
+    }
+    maxHistoryWindowStart() {
+        return Math.max(0, this.historyEntries.length - this.historyWindowSize());
+    }
+    registerEntry(entry) {
+        this.entryRenderVersions.set(entry.id, this.entryRenderVersions.get(entry.id) ?? 1);
+        if (entry.kind === "tool")
+            this.toolEntryIdsByCallId.set(entry.toolCallId, entry.id);
+        this.host.conversationViewport().deleteEntry(entry.id);
+    }
     pruneHistoryWindow(edge) {
         const removeCount = this.host.entries.length - MAX_HISTORY_WINDOW_ENTRIES;
         if (removeCount <= 0)
             return;
         const targetRemoveCount = Math.max(removeCount, this.host.entries.length - HISTORY_WINDOW_TARGET_ENTRIES);
-        const removedEntryIds = edge === "top"
-            ? this.host.entries.slice(0, targetRemoveCount).map((entry) => entry.id)
-            : this.host.entries.slice(Math.max(0, this.host.entries.length - targetRemoveCount)).map((entry) => entry.id);
-        const removedLineCount = this.measuredLineCountForEntries(removedEntryIds);
+        const removedLineCount = edge === "top"
+            ? this.measuredLineCountForEntries(this.host.entries.slice(0, targetRemoveCount).map((entry) => entry.id))
+            : 0;
         const removed = edge === "top"
             ? this.host.entries.splice(0, targetRemoveCount)
             : this.host.entries.splice(Math.max(0, this.host.entries.length - targetRemoveCount), targetRemoveCount);
@@ -266,18 +376,50 @@ export class AppSessionEventController {
             if (entryId === entry.id)
                 this.toolEntryIdsByCallId.delete(toolCallId);
         }
+        for (const [contentIndex, toolCallId] of this.pendingToolCallIdsByContentIndex) {
+            if (this.toolEntryIdsByCallId.get(toolCallId) === undefined)
+                this.pendingToolCallIdsByContentIndex.delete(contentIndex);
+        }
+    }
+    removeToolEntryOrphan(entryId) {
+        const index = this.host.entries.findIndex((entry) => entry.id === entryId);
+        if (index === -1)
+            return;
+        const removed = this.host.entries.splice(index, 1)[0];
+        if (removed === undefined)
+            return;
+        this.forgetEntry(removed);
+        this.host.scheduleRender();
     }
     addSessionAbortedEntry() {
         this.finishCurrentThinkingEntry();
         this.clearCurrentAssistantState();
+        this.finalizeAbandonedToolEntries();
         this.addEntry({ id: createId("session-aborted"), kind: "session-aborted", text: "Session aborted." });
     }
+    // D.16: when a turn aborts (agent_end, error, or session abort) without the
+    // SDK emitting tool_execution_end for a tool that already started executing,
+    // mark any running tool entries as done so they don't render a perpetual
+    // spinner. The output is left as whatever partial was last observed.
+    finalizeAbandonedToolEntries() {
+        let touched = false;
+        for (const entry of this.host.entries) {
+            if (entry.kind === "tool" && entry.status === "running") {
+                entry.status = "done";
+                this.touchEntry(entry);
+                touched = true;
+            }
+        }
+        if (touched)
+            this.host.scheduleRender();
+    }
     handleMessageStart(message) {
         if (isRecord(message) && message.role === "custom") {
             this.addCustomMessageEntry(message);
             return;
         }
         if (isRecord(message) && message.role === "user") {
+            this.assistantMessageClosed = false;
             const text = renderUserMessageContent(message.content);
             if (!text)
                 return;
@@ -293,17 +435,25 @@ export class AppSessionEventController {
             this.currentUserEntryId = entryId;
             return;
         }
-        if (isRecord(message) && message.role === "assistant")
+        if (isRecord(message) && message.role === "assistant") {
+            this.assistantMessageClosed = false;
             this.clearCurrentAssistantState();
+        }
     }
     handleMessageEnd(message) {
         if (isRecord(message) && message.role === "user") {
             this.host.scheduleUserSessionEntryMetadataSync();
         }
+        if (isRecord(message) && message.role === "toolResult") {
+            this.finalizeToolResultMessage(message);
+            return;
+        }
         if (isRecord(message) && message.role === "assistant") {
+            this.renderAssistantToolCallsFromMessage(message);
             this.finishCurrentThinkingEntry();
             this.flushAssistantTextBuffer(true);
             this.clearCurrentAssistantState();
+            this.assistantMessageClosed = true;
         }
     }
     prepareToolWorkspaceMutation(toolCallId, toolName, args) {
@@ -317,6 +467,29 @@ export class AppSessionEventController {
             ...(preparation === undefined ? {} : { preparation }),
         });
     }
+    finalizeToolResultMessage(message) {
+        const toolCallId = typeof message.toolCallId === "string" ? message.toolCallId : undefined;
+        const toolName = typeof message.toolName === "string" ? message.toolName : undefined;
+        const content = Array.isArray(message.content) ? message.content : [];
+        const details = message.details;
+        const isError = Boolean(message.isError);
+        if (toolCallId && toolName) {
+            this.recordToolWorkspaceMutation(toolCallId, toolName, details, isError);
+            if (this.currentUserEntryId)
+                this.host.scheduleUserSessionEntryMetadataSync();
+            this.host.observeSubagentsToolResult(toolName, details);
+            this.host.observeTodoToolResult(toolName, details, isError);
+            this.upsertToolEntry(toolCallId, {
+                toolName,
+                output: renderContent(content),
+                images: extractImageContents(content),
+                details,
+                isError,
+                status: "done",
+            });
+        }
+        this.host.setSessionActivity(this.host.runtime()?.session.isStreaming ? "running" : "idle");
+    }
     recordToolWorkspaceMutation(toolCallId, toolName, details, isError) {
         const prepared = this.toolMutationPreparationsByCallId.get(toolCallId);
         if (!prepared)
@@ -333,21 +506,68 @@ export class AppSessionEventController {
             return;
         this.host.recordWorkspaceMutationForUserEntry(prepared.userEntryId, mutation);
     }
-    handleMessageUpdate(assistantEvent) {
+    handleMessageUpdate(event) {
+        const assistantEvent = event.assistantMessageEvent;
+        if (this.assistantMessageClosed && assistantEvent.type !== "done")
+            return;
+        this.assistantMessageClosed = false;
         switch (assistantEvent.type) {
+            case "text_start":
+                this.finishCurrentThinkingEntry();
+                this.flushAssistantTextBuffer(true);
+                this.finishCurrentAssistantTextBlock();
+                this.currentAssistantTextBlockEntryId = undefined;
+                this.currentAssistantTextBlockStartLength = undefined;
+                this.currentAssistantTextBlockContentIndex = assistantEvent.contentIndex;
+                break;
             case "text_delta":
                 this.finishCurrentThinkingEntry();
                 this.host.setSessionActivity("running");
-                this.appendAssistantText(assistantEvent.delta);
+                {
+                    const snapshotText = assistantTextSnapshotForContentIndex(event.message, assistantEvent.partial, assistantEvent.contentIndex);
+                    if (snapshotText === undefined)
+                        this.appendAssistantText(assistantEvent.delta, assistantEvent.contentIndex);
+                    else
+                        this.reconcileAssistantTextBlock(snapshotText, assistantEvent.contentIndex, { keepOpen: true });
+                }
+                break;
+            case "text_end":
+                this.finishCurrentThinkingEntry();
+                this.host.setSessionActivity("running");
+                this.reconcileAssistantTextBlock(assistantEvent.content, assistantEvent.contentIndex);
                 break;
             case "thinking_delta":
+                if (assistantEvent.delta.length === 0)
+                    return;
+                if (this.currentThinkingEntryId === undefined && this.hasStartedCurrentAssistantText())
+                    return;
                 this.host.setSessionActivity("thinking");
                 this.appendThinkingText(assistantEvent.delta);
                 break;
+            case "thinking_end":
+                if (this.currentThinkingEntryId === undefined && this.hasStartedCurrentAssistantText())
+                    return;
+                if (assistantEvent.content.length === 0) {
+                    this.finishCurrentThinkingEntry();
+                    return;
+                }
+                this.host.setSessionActivity("thinking");
+                this.reconcileThinkingText(assistantEvent.content);
+                this.finishCurrentThinkingEntry();
+                break;
+            case "toolcall_start":
+            case "toolcall_delta":
+                this.handleToolCallStreamUpdate(assistantEvent.contentIndex, assistantEvent.partial);
+                break;
+            case "toolcall_end":
+                this.handleToolCallStreamUpdate(assistantEvent.contentIndex, assistantEvent.partial, assistantEvent.toolCall);
+                break;
             case "done":
+                this.renderAssistantToolCallsFromMessage(assistantEvent.message);
                 this.finishCurrentThinkingEntry();
                 this.flushAssistantTextBuffer(true);
                 this.clearCurrentAssistantState();
+                this.assistantMessageClosed = true;
                 this.host.setSessionActivity(this.host.runtime()?.session.isStreaming ? "running" : "idle");
                 break;
             case "error":
@@ -360,8 +580,33 @@ export class AppSessionEventController {
                 break;
         }
     }
-    appendAssistantText(delta) {
-        this.assistantTextBuffer += delta;
+    handleToolCallStreamUpdate(contentIndex, partial, finalToolCall) {
+        // B.6: once a tool call block has been finalised by toolcall_end, a later
+        // toolcall_delta for the same contentIndex is a stale re-stream of the
+        // partial args. Applying it would clobber the final, complete args with
+        // an incomplete version. Ignore it.
+        if (finalToolCall === undefined && contentIndex !== undefined && this.finalizedToolCallContentIndexes.has(contentIndex)) {
+            return;
+        }
+        this.finishCurrentThinkingEntry();
+        this.flushAssistantTextBuffer(true);
+        this.finishCurrentAssistantTextBlock();
+        this.currentAssistantEntryId = undefined;
+        this.currentAssistantTextBlockEntryId = undefined;
+        this.currentAssistantTextBlockStartLength = undefined;
+        this.currentAssistantTextBlockContentIndex = undefined;
+        this.host.setSessionActivity("running");
+        this.upsertPendingToolCall(finalToolCall ?? partialToolCallAt(partial, contentIndex), contentIndex);
+        if (finalToolCall !== undefined && contentIndex !== undefined)
+            this.finalizedToolCallContentIndexes.add(contentIndex);
+    }
+    appendAssistantText(delta, contentIndex) {
+        if (contentIndex !== undefined)
+            this.currentAssistantTextBlockContentIndex = contentIndex;
+        // C.11: providers may emit Windows-style CRLF (\r\n) line endings. The
+        // drain logic splits on "\n", which would leave a dangling "\r" at the
+        // end of each line and corrupt width/layout calculations. Normalise to LF.
+        this.assistantTextBuffer += delta.includes("\r") ? delta.replace(/\r\n?/gu, "\n") : delta;
         this.flushAssistantTextBuffer(false);
     }
     flushAssistantTextBuffer(final) {
@@ -374,9 +619,97 @@ export class AppSessionEventController {
             this.addEntry(entry);
             this.currentAssistantEntryId = entry.id;
         }
+        this.ensureAssistantTextBlockStarted(entry);
         entry.text += visibleText;
         this.touchEntry(entry);
     }
+    reconcileAssistantTextBlock(content, contentIndex, options = {}) {
+        this.flushAssistantTextBuffer(true);
+        const hasVisibleTextBeforeBlock = this.hasVisibleTextBeforeCurrentAssistantBlock();
+        // C.11: normalise CRLF in the final block content (see appendAssistantText).
+        const normalisedContent = content.includes("\r") ? content.replace(/\r\n?/gu, "\n") : content;
+        const visibleText = assistantStreamVisibleTextForCompleteBlock(normalisedContent, hasVisibleTextBeforeBlock);
+        // B.5: a late text_end for a block that was already finished (it is not the
+        // currently-streaming block and is already recorded) must not clobber the
+        // current block or duplicate the early block's text.
+        if (contentIndex !== undefined
+            && this.currentAssistantTextBlockContentIndex !== undefined
+            && contentIndex !== this.currentAssistantTextBlockContentIndex
+            && this.assistantTextBlocksByContentIndex.has(contentIndex))
+            return;
+        if (this.currentAssistantTextBlockEntryId === undefined
+            && contentIndex !== undefined
+            && this.assistantTextBlocksByContentIndex.get(contentIndex) === visibleText)
+            return;
+        // A.1: a text_end carrying empty content (provider content-filtering /
+        // truncation quirk) must not wipe assistant text already rendered to the
+        // user. Only finalize the block state, leaving any committed text intact.
+        if (!visibleText)
+            return;
+        let entry = this.currentAssistantTextBlockEntryId ? this.findEntry(this.currentAssistantTextBlockEntryId) : undefined;
+        if (!entry || entry.kind !== "assistant") {
+            entry = this.currentAssistantEntryId ? this.findEntry(this.currentAssistantEntryId) : undefined;
+        }
+        if (!entry || entry.kind !== "assistant") {
+            if (!visibleText)
+                return;
+            entry = { id: createId("assistant"), kind: "assistant", text: "" };
+            this.addEntry(entry);
+            this.currentAssistantEntryId = entry.id;
+        }
+        const startLength = this.currentAssistantTextBlockEntryId === entry.id
+            ? Math.min(this.currentAssistantTextBlockStartLength ?? entry.text.length, entry.text.length)
+            : entry.text.length;
+        const currentBlockText = entry.text.slice(startLength);
+        // C.10: when the final block content is a strict prefix of what was
+        // already streamed to the user (provider truncation / retroactive
+        // content filtering), preserve the longer streamed text rather than
+        // silently retracting already-rendered content. Same principle as A.1.
+        const preserveStreamedText = visibleText.length < currentBlockText.length
+            && currentBlockText.startsWith(visibleText);
+        if (!preserveStreamedText && currentBlockText !== visibleText) {
+            entry.text = `${entry.text.slice(0, startLength)}${visibleText}`;
+            this.touchEntry(entry);
+        }
+        this.currentAssistantEntryId = entry.id;
+        if (contentIndex !== undefined)
+            this.assistantTextBlocksByContentIndex.set(contentIndex, visibleText);
+        if (options.keepOpen) {
+            this.currentAssistantTextBlockEntryId = entry.id;
+            this.currentAssistantTextBlockStartLength = startLength;
+            this.currentAssistantTextBlockContentIndex = contentIndex;
+        }
+        else {
+            this.currentAssistantTextBlockEntryId = undefined;
+            this.currentAssistantTextBlockStartLength = undefined;
+            this.currentAssistantTextBlockContentIndex = undefined;
+        }
+        this.assistantTextBuffer = "";
+    }
+    ensureAssistantTextBlockStarted(entry) {
+        if (this.currentAssistantTextBlockEntryId === entry.id && this.currentAssistantTextBlockStartLength !== undefined)
+            return;
+        this.currentAssistantTextBlockEntryId = entry.id;
+        this.currentAssistantTextBlockStartLength = entry.text.length;
+    }
+    finishCurrentAssistantTextBlock() {
+        if (this.currentAssistantTextBlockContentIndex !== undefined && this.currentAssistantTextBlockEntryId !== undefined) {
+            const entry = this.findEntry(this.currentAssistantTextBlockEntryId);
+            if (entry?.kind === "assistant") {
+                const startLength = Math.min(this.currentAssistantTextBlockStartLength ?? entry.text.length, entry.text.length);
+                this.assistantTextBlocksByContentIndex.set(this.currentAssistantTextBlockContentIndex, entry.text.slice(startLength));
+            }
+        }
+        this.currentAssistantTextBlockEntryId = undefined;
+        this.currentAssistantTextBlockStartLength = undefined;
+        this.currentAssistantTextBlockContentIndex = undefined;
+    }
+    hasVisibleTextBeforeCurrentAssistantBlock() {
+        const entry = this.currentAssistantTextBlockEntryId ? this.findEntry(this.currentAssistantTextBlockEntryId) : undefined;
+        if (entry?.kind !== "assistant")
+            return this.hasVisibleAssistantText("");
+        return (this.currentAssistantTextBlockStartLength ?? 0) > 0;
+    }
     drainAssistantTextBuffer(final) {
         let visibleText = "";
         for (;;) {
@@ -409,13 +742,34 @@ export class AppSessionEventController {
         const entry = this.currentAssistantEntryId ? this.findEntry(this.currentAssistantEntryId) : undefined;
         return entry?.kind === "assistant" && entry.text.length > 0;
     }
+    hasStartedCurrentAssistantText() {
+        if (this.assistantTextBuffer.length > 0)
+            return true;
+        const entry = this.currentAssistantEntryId ? this.findEntry(this.currentAssistantEntryId) : undefined;
+        return entry?.kind === "assistant" && entry.text.length > 0;
+    }
     appendThinkingText(delta) {
-        let entry = this.currentThinkingEntryId ? this.findEntry(this.currentThinkingEntryId) : undefined;
+        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" };
+            const level = this.currentThinkingLevel();
+            entry = {
+                id: createId("thinking"),
+                kind: "thinking",
+                text: "",
+                expanded: this.host.toolDefaultExpanded(THINKING_TOOL_NAME),
+                ...(level === undefined ? {} : { level }),
+                status: "running",
+            };
             this.addEntry(entry);
             this.currentThinkingEntryId = entry.id;
         }
+        const level = this.currentThinkingLevel();
+        if (level === undefined)
+            delete entry.level;
+        else
+            entry.level = level;
         entry.status = "running";
         entry.text += delta;
         this.touchEntry(entry);
@@ -428,13 +782,86 @@ export class AppSessionEventController {
         }
         this.currentThinkingEntryId = undefined;
     }
+    reconcileThinkingText(content) {
+        let entry = this.currentThinkingEntryId
+            ? this.findEntry(this.currentThinkingEntryId)
+            : undefined;
+        if (!entry || entry.kind !== "thinking") {
+            const level = this.currentThinkingLevel();
+            entry = {
+                id: createId("thinking"),
+                kind: "thinking",
+                text: "",
+                expanded: this.host.toolDefaultExpanded(THINKING_TOOL_NAME),
+                ...(level === undefined ? {} : { level }),
+                status: "running",
+            };
+            this.addEntry(entry);
+            this.currentThinkingEntryId = entry.id;
+        }
+        const level = this.currentThinkingLevel();
+        if (entry.text !== content || entry.status !== "running" || entry.level !== level) {
+            entry.text = content;
+            if (level === undefined)
+                delete entry.level;
+            else
+                entry.level = level;
+            entry.status = "running";
+            this.touchEntry(entry);
+        }
+    }
+    currentThinkingLevel() {
+        return this.host.runtime()?.session.thinkingLevel;
+    }
+    renderAssistantToolCallsFromMessage(message) {
+        if (!isRecord(message) || !Array.isArray(message.content))
+            return;
+        for (let contentIndex = 0; contentIndex < message.content.length; contentIndex += 1) {
+            const block = message.content[contentIndex];
+            if (isRecord(block) && block.type === "toolCall")
+                this.upsertPendingToolCall(block, contentIndex);
+        }
+    }
+    upsertPendingToolCall(toolCall, contentIndex) {
+        const existingCallId = contentIndex === undefined ? undefined : this.pendingToolCallIdsByContentIndex.get(contentIndex);
+        const existingEntryId = existingCallId === undefined ? undefined : this.toolEntryIdsByCallId.get(existingCallId);
+        const toolCallId = isRecord(toolCall) && typeof toolCall.id === "string" ? toolCall.id : existingCallId ?? createId("tool-call");
+        if (contentIndex !== undefined)
+            this.pendingToolCallIdsByContentIndex.set(contentIndex, toolCallId);
+        if (existingCallId !== undefined && existingCallId !== toolCallId && existingEntryId !== undefined) {
+            this.toolEntryIdsByCallId.delete(existingCallId);
+            // B.7: if tool_execution_start arrived before toolcall_end finalised the
+            // call id, an orphan tool entry may already be registered under
+            // toolCallId. Reuse the pending entry and drop the orphan so a single
+            // logical tool call renders as a single tool entry.
+            const orphanEntryId = this.toolEntryIdsByCallId.get(toolCallId);
+            this.toolEntryIdsByCallId.set(toolCallId, existingEntryId);
+            const existing = this.findEntry(existingEntryId);
+            if (existing?.kind === "tool")
+                existing.toolCallId = toolCallId;
+            if (orphanEntryId !== undefined && orphanEntryId !== existingEntryId) {
+                this.removeToolEntryOrphan(orphanEntryId);
+            }
+        }
+        const toolName = isRecord(toolCall) && typeof toolCall.name === "string" ? toolCall.name : undefined;
+        const argsText = isRecord(toolCall) && "arguments" in toolCall ? stringifyUnknown(toolCall.arguments) : undefined;
+        this.upsertToolEntry(toolCallId, {
+            ...(toolName === undefined ? {} : { toolName }),
+            ...(argsText === undefined ? {} : { argsText }),
+            status: "running",
+        });
+    }
     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;
+            // A.2: an update carrying empty output (e.g. a partial
+            // tool_execution_update with content:[]) must not erase output already
+            // shown to the user; only non-empty output replaces the existing value.
+            const nextOutput = update.output ?? existing.output;
+            existing.output = nextOutput.length > 0 ? nextOutput : (existing.output ?? "");
             if ("images" in update)
                 existing.images = update.images;
             if ("details" in update)
@@ -462,10 +889,52 @@ export class AppSessionEventController {
     }
     clearCurrentAssistantState() {
         this.currentAssistantEntryId = undefined;
+        this.currentAssistantTextBlockEntryId = undefined;
+        this.currentAssistantTextBlockStartLength = undefined;
+        this.currentAssistantTextBlockContentIndex = undefined;
         this.currentThinkingEntryId = undefined;
         this.assistantTextBuffer = "";
+        this.assistantTextBlocksByContentIndex.clear();
+        this.finalizedToolCallContentIndexes.clear();
+        this.pendingToolCallIdsByContentIndex.clear();
     }
 }
+function partialToolCallAt(partial, contentIndex) {
+    if (!isRecord(partial) || !Array.isArray(partial.content))
+        return undefined;
+    const block = partial.content[contentIndex];
+    return isRecord(block) && block.type === "toolCall" ? block : undefined;
+}
+function assistantTextSnapshotForContentIndex(message, partial, contentIndex) {
+    if (contentIndex === undefined)
+        return undefined;
+    return assistantTextContentAt(message, contentIndex) ?? assistantTextContentAt(partial, contentIndex);
+}
+function assistantTextContentAt(value, contentIndex) {
+    if (!isRecord(value) || !Array.isArray(value.content))
+        return undefined;
+    const block = value.content[contentIndex];
+    return isRecord(block) && block.type === "text" && typeof block.text === "string" ? block.text : undefined;
+}
+function assistantStreamVisibleTextForCompleteBlock(text, hasVisibleTextBeforeBlock) {
+    let buffer = text;
+    let visibleText = "";
+    for (;;) {
+        const newlineIndex = buffer.indexOf("\n");
+        if (newlineIndex === -1)
+            break;
+        const line = buffer.slice(0, newlineIndex);
+        buffer = buffer.slice(newlineIndex + 1);
+        if (shouldDropAssistantStreamLine(line, hasVisibleTextBeforeBlock || visibleText.length > 0))
+            continue;
+        visibleText += `${line}\n`;
+    }
+    if (!buffer)
+        return visibleText;
+    if (shouldHoldAssistantStreamTail(buffer, hasVisibleTextBeforeBlock || visibleText.length > 0))
+        return visibleText;
+    return visibleText + buffer;
+}
 function shouldDropAssistantStreamLine(line, hasVisibleText) {
     if (line.trim().length === 0 && !hasVisibleText)
         return true;