pi-my-compact-ui 0.2.2 → 0.3.0

package/src/extension.ts

@@ -0,0 +1,282 @@
+/** Pi 命令与事件接入；呈现逻辑委托给各职责模块。 */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { installGrouping, ensureThinkingGroup, flushPendingTextSeal } from "./grouping.js";
+import { installNativeThinkingSuppression, removeGroupFromContainer, insertTurnDivider } from "./assistant-patches.js";
+import { installCompactionSummaryRendering } from "./compaction.js";
+import { openInspectSelectorModal, closeDetailModal, closeInspectSelectorModal } from "./modals.js";
+import { runtime } from "./state.js";
+import { isKeyRelease, matchesKey, Key } from "@earendil-works/pi-tui";
+import { isCtrlI } from "./helpers.js";
+import { rememberToolStart, clearPreparingTools, noteStreamingToolCall, loadSessionToolTimings } from "./streaming-tools.js";
+import { finalizeActiveThinking, createThinkingEntry, updateActiveThinkingTokens, refreshSealedThinkingTokens } from "./thinking.js";
+import { registerConfigCommand } from "./settings.js";
+
+export default function (pi: ExtensionAPI) {
+	installGrouping();
+	installNativeThinkingSuppression();
+	installCompactionSummaryRendering();
+
+	// Do not use pi.registerShortcut("ctrl+i") directly because pi's internal
+	// matchesKey treats "\t" as "ctrl+i", which breaks regular Tab completion.
+	// Instead, recognize Ctrl+I under extended protocols via onTerminalInput + isCtrlI.
+
+	pi.registerCommand("compact-inspect", {
+		description: "Select a tool call or thinking entry to inspect details (Shortcut: Ctrl+I)",
+		handler: async () => {
+			openInspectSelectorModal();
+		},
+	});
+
+	pi.on("session_start", async (_event, ctx) => {
+		runtime.currentTheme = ctx.ui.theme;
+		runtime.activeUIContext = ctx.ui;
+		ctx.ui.setHiddenThinkingLabel("");
+
+		ctx.ui.onTerminalInput((data: string) => {
+			if (isKeyRelease(data)) {
+				return runtime.activeModalHandle || runtime.activeSelectorHandle ? { consume: true } : undefined;
+			}
+
+			if (runtime.activeModalHandle) {
+				if (matchesKey(data, Key.escape) || data === "q" || data === "Q" || isCtrlI(data)) {
+					closeDetailModal();
+					return { consume: true };
+				}
+				return undefined;
+			}
+
+			if (runtime.activeSelectorHandle) {
+				if (matchesKey(data, Key.escape) || data === "q" || data === "Q" || isCtrlI(data)) {
+					closeInspectSelectorModal();
+					return { consume: true };
+				}
+				return undefined;
+			}
+
+			if (isCtrlI(data)) {
+				openInspectSelectorModal();
+				return { consume: true };
+			}
+
+			return undefined;
+		});
+
+		// Capture the TUI instance via setWidget's factory so the animation can
+		// call its throttled requestRender() to repaint just the changed cells.
+		ctx.ui.setWidget("compact-anim", (tui: any) => {
+			runtime.capturedTui = tui;
+			return { render: () => [] as string[], invalidate() {} };
+		});
+		installGrouping();
+		installNativeThinkingSuppression();
+		installCompactionSummaryRendering();
+
+		if ((ctx as any)?.sessionManager?.getEntries) {
+			loadSessionToolTimings((ctx as any).sessionManager.getEntries());
+		}
+
+		// Replaying history builds groups that belong to finished past turns.
+		// Seal them once history replay finishes so they do not animate or tick.
+		queueMicrotask(() => {
+			for (const g of runtime.groups) {
+				g.sealed = true;
+				for (const t of g.children as any[]) {
+					if (t.result && t._groupEndAt === undefined) {
+						t._groupEndAt = Date.now();
+					}
+				}
+				g.invalidate();
+			}
+			runtime.lastActiveGroup = null;
+			if (runtime.animTimer) {
+				clearTimeout(runtime.animTimer);
+				runtime.animTimer = null;
+			}
+			runtime.capturedTui?.requestRender?.();
+		});
+	});
+
+	pi.on("session_shutdown", async () => {
+		closeDetailModal();
+		closeInspectSelectorModal();
+	});
+
+	pi.on("tool_execution_start", async (event) => {
+		// Keep the timestamp captured when arguments started streaming.
+		rememberToolStart(event.toolCallId);
+		runtime.lastActiveGroup?.invalidate();
+		runtime.activeSelectorComponent?.refreshEntries();
+		runtime.capturedTui?.requestRender?.();
+	});
+
+	pi.on("tool_execution_end", async (event) => {
+		const end = Date.now();
+		const start = runtime.toolStarts.get(event.toolCallId);
+		if (start !== undefined && !runtime.toolDurations.has(event.toolCallId)) {
+			runtime.toolDurations.set(event.toolCallId, Math.max(0, (end - start) / 1000));
+		}
+		for (const g of runtime.groups) {
+			for (const t of g.children as any[]) {
+				if (t.toolCallId === event.toolCallId) t._groupEndAt = end;
+			}
+		}
+		runtime.lastActiveGroup?.invalidate();
+		runtime.activeSelectorComponent?.refreshEntries();
+		runtime.capturedTui?.requestRender?.();
+	});
+
+	pi.on("message_start", async (event) => {
+		const role = (event.message as any)?.role;
+		// A new user message is a hard turn boundary: seal whatever block is still
+		// open. Assistant/toolResult message boundaries do NOT seal — thinking and
+		// tool calls stay in one block until real (non-thinking) text appears.
+		if (role === "user" && runtime.lastActiveGroup && !runtime.lastActiveGroup.sealed) {
+			runtime.lastActiveGroup.sealed = true;
+			finalizeActiveThinking();
+			runtime.lastActiveGroup.invalidate();
+		}
+		if (role === "user") {
+			for (const g of [...runtime.groups]) {
+				if (!g.hasVisibleEntries()) {
+					if (runtime.lastChatContainer) removeGroupFromContainer(runtime.lastChatContainer, g);
+					runtime.groups.delete(g);
+				}
+			}
+			runtime.turnStartMs = Date.now();
+			runtime.activeThinking = null;
+			runtime.activeThinkingIndex = null;
+			runtime.activeThinkingBlocks.clear();
+			runtime.unattachedThinking.length = 0;
+			clearPreparingTools();
+			runtime.lastSealedThinkingEntry = null;
+			runtime.lastReportedReasoningTokens = 0;
+			runtime.handledTextIndexes.clear();
+			runtime.sealedThinkingIndexes.clear();
+			runtime.pendingTextSeal = false;
+			runtime.pendingTextOrdinal = null;
+			runtime.lastStreamingComp = null;
+		} else if (role === "assistant") {
+			// contentIndex values are local to one streamed assistant message. Close
+			// any run left open by the previous message; a late thinking_end for it is
+			// then rejected through sealedThinkingIndexes.
+			finalizeActiveThinking();
+			runtime.handledTextIndexes.clear();
+			runtime.sealedThinkingIndexes.clear();
+			// Reported reasoning usage belongs to one assistant message; a run sealed
+			// later must not inherit the previous message's value.
+			runtime.lastSealedThinkingEntry = null;
+			runtime.lastReportedReasoningTokens = 0;
+			runtime.pendingTextSeal = false;
+			runtime.pendingTextOrdinal = null;
+			// Do not insert early thinking beside the previous assistant message.
+			// The addChild patch fills this with the current streaming component.
+			runtime.lastStreamingComp = null;
+		}
+	});
+
+	pi.on("message_update", async (event) => {
+		const msg = event.message as any;
+		if (!msg || msg.role !== "assistant") return;
+		const content = Array.isArray(msg.content) ? msg.content : [];
+		const streamEvent = event.assistantMessageEvent as any;
+		const streamType = String(streamEvent?.type ?? "");
+
+		if (streamType.startsWith("thinking_")) {
+			// Only read the block targeted by this stream event. The surrounding
+			// message is cumulative and may still contain thinking from before a
+			// text boundary; scanning all content would resurrect that old block.
+			const contentIndex = Number(streamEvent.contentIndex);
+			const hasIndex = Number.isInteger(contentIndex);
+			// A thinking_end re-emitted after a visible text boundary already sealed
+			// this run must not create a second row for the same reasoning.
+			if (hasIndex && runtime.sealedThinkingIndexes.has(contentIndex)) return;
+			const startsRun =
+				streamType === "thinking_start" || !runtime.activeThinking || (hasIndex && runtime.activeThinkingIndex !== contentIndex);
+			if (startsRun) {
+				// Each run is its own entry: close the previous one instead of merging.
+				finalizeActiveThinking();
+				runtime.activeThinkingIndex = hasIndex ? contentIndex : null;
+				createThinkingEntry();
+			}
+			const block = hasIndex ? content[contentIndex] : undefined;
+			const blockText =
+				block?.type === "thinking"
+					? String(block.thinking ?? "")
+					: streamType === "thinking_end"
+						? String(streamEvent.content ?? "")
+						: "";
+			if (hasIndex) runtime.activeThinkingBlocks.set(contentIndex, blockText);
+			updateActiveThinkingTokens(msg);
+			// Drop the row in as soon as the run starts — even before its first delta —
+			// so the spinner reports the in-progress state.
+			ensureThinkingGroup();
+			if (streamType === "thinking_end") finalizeActiveThinking();
+		} else if (streamType.startsWith("text_")) {
+			const contentIndex = Number(streamEvent.contentIndex);
+			const block = Number.isInteger(contentIndex) ? content[contentIndex] : undefined;
+			const text = block?.type === "text" ? String(block.text ?? "").trim() : "";
+			// The first non-whitespace text is a boundary. Deduplicate by content
+			// index so every later cumulative delta extends the same text block.
+			if (text.length > 0 && !runtime.handledTextIndexes.has(contentIndex)) {
+				if (runtime.activeThinking) updateActiveThinkingTokens(msg);
+				runtime.handledTextIndexes.add(contentIndex);
+				runtime.pendingTextSeal = true;
+				runtime.pendingTextOrdinal =
+					content
+						.slice(0, Number.isInteger(contentIndex) ? contentIndex + 1 : content.length)
+						.filter((item: any) => item?.type === "text" && String(item.text ?? "").trim()).length - 1;
+				flushPendingTextSeal();
+			}
+		} else if (streamType.startsWith("toolcall_")) {
+			// Arguments are still streaming. Show the busy row before execution starts.
+			if (runtime.activeThinking) updateActiveThinkingTokens(msg);
+			noteStreamingToolCall(content, streamEvent);
+		} else if (streamType === "done" || streamType === "error") {
+			if (runtime.activeThinking) updateActiveThinkingTokens(msg);
+			finalizeActiveThinking();
+			refreshSealedThinkingTokens(msg?.usage?.reasoning);
+		}
+
+		// Refresh the active block when thinking starts/stops (event-driven only;
+		// no timer, so the transcript scroll position is never yanked around).
+		runtime.lastActiveGroup?.invalidate();
+		runtime.activeSelectorComponent?.refreshEntries();
+		runtime.capturedTui?.requestRender?.();
+	});
+
+	pi.on("agent_end", async () => {
+		// Turn finished: seal the final block so it stops spinning and shows a
+		// stable summary until the user starts the next turn.
+		clearPreparingTools();
+		if (runtime.lastActiveGroup && !runtime.lastActiveGroup.sealed) {
+			runtime.lastActiveGroup.sealed = true;
+			finalizeActiveThinking();
+			runtime.lastActiveGroup.invalidate();
+		}
+		for (const g of [...runtime.groups]) {
+			if (!g.hasVisibleEntries()) {
+				if (runtime.lastChatContainer) removeGroupFromContainer(runtime.lastChatContainer, g);
+				runtime.groups.delete(g);
+			}
+		}
+		refreshSealedThinkingTokens();
+		runtime.activeSelectorComponent?.refreshEntries();
+		runtime.capturedTui?.requestRender?.();
+		// Separate the final visible text from the preceding work with a divider
+		// that reports how long this turn ran.
+		const elapsedMs = Date.now() - runtime.turnStartMs;
+		insertTurnDivider(elapsedMs);
+		runtime.activeThinking = null;
+		runtime.activeThinkingIndex = null;
+		runtime.activeThinkingBlocks.clear();
+		runtime.unattachedThinking.length = 0;
+		runtime.lastSealedThinkingEntry = null;
+		runtime.lastReportedReasoningTokens = 0;
+		runtime.handledTextIndexes.clear();
+		runtime.sealedThinkingIndexes.clear();
+		runtime.pendingTextSeal = false;
+		runtime.pendingTextOrdinal = null;
+	});
+
+	registerConfigCommand(pi);
+}

package/src/grouping.ts

@@ -0,0 +1,327 @@
+/** 按流顺序组合思考与工具，并在可见正文边界封组。 */
+import { isToolExecution, isSpacer, isAssistantMessage, isToolGroup, isContainer } from "./guards.js";
+import { ToolGroupComponent } from "./tool-group.js";
+import { thinkingAlreadyShown, isVisibleTextMarkdown, anchorGroupBeforeCurrentText, detachGroup, noteGroupMount, removeGroupFromContainer, ensureAssistantThinkingPatched, stripAssistantPhantomPadding, restoreAssistantAnchor, releaseAssistantAnchors, getAssistantContentState } from "./assistant-patches.js";
+import { runtime } from "./state.js";
+import { estimateTextTokens } from "./helpers.js";
+import { findOpenGroup, placeGroupAfter } from "./streaming-tools.js";
+import { finalizeActiveThinking } from "./thinking.js";
+import type { ThinkingEntry, PatchState } from "./types.js";
+import { Container } from "@earendil-works/pi-tui";
+import { AssistantMessageComponent } from "@earendil-works/pi-coding-agent";
+import { PATCH_KEY, LIVE_ASSISTANT_KEY, IS_STREAMING_COMP, PARENT_KEY } from "./constants.js";
+
+export function isGroupable(value: any): boolean {
+	return isToolExecution(value);
+}
+
+export function previousGroupable(children: any[], start: number): { child: any; index: number } | undefined {
+	for (let i = start; i >= 0; i--) {
+		const child = children[i];
+		if (isSpacer(child)) continue;
+		if (isAssistantMessage(child)) continue;
+		// A sealed block is a text boundary, not a reason to ignore an earlier open group.
+		// Notices and other chat widgets between tool rounds are not boundaries either.
+		if (isToolGroup(child) && child.sealed) continue;
+		if (isToolGroup(child) || isGroupable(child)) return { child, index: i };
+	}
+	return undefined;
+}
+
+export function assistantHasVisibleText(component: any): boolean {
+	const content = component?.lastMessage?.content;
+	if (!Array.isArray(content)) return false;
+	return content.some((item: any) => item?.type === "text" && String(item.text ?? "").trim());
+}
+
+export function absorbThinkingBeforeText(group: ToolGroupComponent, message: any): void {
+	const content = message?.content;
+	if (!Array.isArray(content)) return;
+	for (const item of content) {
+		if (item?.type === "text" && String(item.text ?? "").trim()) break;
+		if (item?.type !== "thinking") continue;
+		const text = String(item.thinking ?? "").trim();
+		if (!text || thinkingAlreadyShown(text)) continue;
+		group.entries.push({
+			kind: "thinking",
+			id: runtime.thinkingEntrySeq++,
+			text,
+			tokens: estimateTextTokens(text),
+			tokensExact: false,
+			active: false,
+			owner: group,
+		});
+	}
+}
+
+export function sealOpenGroupAtAssistantText(assistant: any): void {
+	const open = findOpenGroup();
+	if (!open) return;
+	absorbThinkingBeforeText(open, assistant.lastMessage);
+	open.sealed = true;
+	finalizeActiveThinking();
+	const contentContainer = assistant.contentContainer;
+	if (isContainer(contentContainer) && contentContainer.children.some(isVisibleTextMarkdown)) {
+		const previous = runtime.lastStreamingComp;
+		runtime.lastStreamingComp = assistant;
+		anchorGroupBeforeCurrentText(open, 0);
+		runtime.lastStreamingComp = previous ?? assistant;
+	}
+	open.invalidate();
+}
+
+export function ensureThinkingGroup(): void {
+	if (runtime.unattachedThinking.length === 0) return;
+	let group = findOpenGroup();
+	if (group && runtime.lastChatContainer && runtime.lastStreamingComp) {
+		placeGroupAfter(runtime.lastChatContainer, runtime.lastStreamingComp, group);
+	}
+	if (!group) {
+		if (!runtime.lastChatContainer || !runtime.lastStreamingComp) return; // retry on the next event
+		const parent = runtime.lastChatContainer;
+		const children = parent.children;
+		if (!Array.isArray(children)) return;
+		const idx = children.indexOf(runtime.lastStreamingComp);
+		group = new ToolGroupComponent();
+		detachGroup(group);
+		children.splice(idx >= 0 ? idx + 1 : children.length, 0, group);
+		noteGroupMount(parent, group);
+		runtime.groups.add(group);
+		runtime.lastActiveGroup = group;
+		parent.invalidate?.();
+	}
+	while (runtime.unattachedThinking.length > 0) group.addThinking(runtime.unattachedThinking.shift()!);
+	group.invalidate();
+	runtime.capturedTui?.requestRender?.();
+}
+
+export function flushPendingTextSeal(): void {
+	if (!runtime.pendingTextSeal) return;
+
+	// A run still streaming when the answer starts belongs to the block being
+	// sealed, and may not have a group yet.
+	if (runtime.activeThinking || runtime.unattachedThinking.length > 0) ensureThinkingGroup();
+
+	if (runtime.lastActiveGroup && !runtime.lastActiveGroup.sealed) {
+		// The active group contains every thinking/tool event since the previous
+		// visible text. Anchor it immediately before this text block so the visual
+		// component order matches the stream order:
+		//   group -> visible text -> next group -> next visible text
+		if (runtime.lastActiveGroup.hasVisibleEntries()) {
+			if (runtime.pendingTextOrdinal !== null) {
+				anchorGroupBeforeCurrentText(runtime.lastActiveGroup, runtime.pendingTextOrdinal);
+			}
+		} else {
+			if (runtime.lastChatContainer) removeGroupFromContainer(runtime.lastChatContainer, runtime.lastActiveGroup);
+			runtime.groups.delete(runtime.lastActiveGroup);
+		}
+		runtime.lastActiveGroup.sealed = true;
+		finalizeActiveThinking();
+		runtime.lastActiveGroup.invalidate();
+		runtime.pendingTextSeal = false;
+		runtime.pendingTextOrdinal = null;
+		return;
+	}
+
+	// No thinking or tools preceded this text, so there is no compact block to
+	// seal. Do not let the boundary leak forward and close a later tool group.
+	runtime.pendingTextSeal = false;
+	runtime.pendingTextOrdinal = null;
+}
+
+export function getPrecedingAssistantThinking(children: any[], beforeIndex: number): string[] {
+	for (let i = beforeIndex; i >= 0; i--) {
+		const child = children[i];
+		if (isSpacer(child)) continue;
+		if (isAssistantMessage(child)) {
+			const content = (child as any).lastMessage?.content;
+			if (!Array.isArray(content)) return [];
+			const texts: string[] = [];
+			for (const item of content) {
+				if (item?.type === "thinking") {
+					const t = String(item.thinking ?? "").trim();
+					if (t && !thinkingAlreadyShown(t)) texts.push(t);
+				}
+			}
+			return texts;
+		}
+		break;
+	}
+	return [];
+}
+
+export function attachPrecedingThinkingToGroup(group: ToolGroupComponent, children: any[], beforeIndex: number): void {
+	const texts = getPrecedingAssistantThinking(children, beforeIndex);
+	if (texts.length === 0) return;
+	for (const text of texts) {
+		if (thinkingAlreadyShown(text)) continue;
+		const entry: ThinkingEntry = {
+			kind: "thinking",
+			id: runtime.thinkingEntrySeq++,
+			text,
+			tokens: estimateTextTokens(text),
+			tokensExact: false,
+			active: false,
+			owner: group,
+		};
+		group.entries.push(entry);
+	}
+}
+
+export function joinOpenGroup(parent: any, index: number, component: any): boolean {
+	if (!runtime.lastChatContainer || parent !== runtime.lastChatContainer) return false;
+	const open = findOpenGroup();
+	if (!open) return false;
+	const children = parent.children;
+	children.splice(index, 1);
+	if (runtime.lastStreamingComp && children.includes(runtime.lastStreamingComp)) {
+		placeGroupAfter(parent, runtime.lastStreamingComp, open);
+	} else if (!children.includes(open)) {
+		children.push(open);
+		noteGroupMount(parent, open);
+	}
+	attachPrecedingThinkingToGroup(open, children, children.indexOf(open) - 1);
+	open.addTool(component);
+	runtime.lastActiveGroup = open;
+	open.invalidate();
+	return true;
+}
+
+export function maybeGroup(parent: any, component: any): void {
+	if (!isGroupable(component) || isToolGroup(parent)) return;
+	const children = parent?.children;
+	if (!Array.isArray(children)) return;
+	const index = children.indexOf(component);
+	if (index < 0) return;
+	if (joinOpenGroup(parent, index, component)) return;
+	const prior = previousGroupable(children, index - 1);
+
+	// Previous sibling is an open (not-yet-sealed) group → join it.
+	if (isToolGroup(prior?.child) && !prior.child.sealed) {
+		attachPrecedingThinkingToGroup(prior.child, children, index - 1);
+		children.splice(index, 1);
+		prior.child.addTool(component);
+		runtime.lastActiveGroup = prior.child;
+		return;
+	}
+	// Previous sibling is a bare tool → merge both into a new group.
+	if (prior && isGroupable(prior.child)) {
+		const group = new ToolGroupComponent();
+		attachPrecedingThinkingToGroup(group, children, prior.index - 1);
+		group.addTool(prior.child);
+		attachPrecedingThinkingToGroup(group, children, index - 1);
+		group.addTool(component);
+		(parent as any).children[prior.index] = group;
+		children.splice(index, 1);
+		noteGroupMount(parent, group);
+		runtime.groups.add(group);
+		runtime.lastActiveGroup = group;
+		return;
+	}
+	// Otherwise (sealed group before, or nothing groupable) → wrap the tool in a
+	// fresh open group so it stays visible.
+	const group = new ToolGroupComponent();
+	attachPrecedingThinkingToGroup(group, children, index - 1);
+	group.addTool(component);
+	(parent as any).children[index] = group;
+	noteGroupMount(parent, group);
+	runtime.groups.add(group);
+	runtime.lastActiveGroup = group;
+}
+
+export function installGrouping(): void {
+	const host = globalThis as any;
+	const prototypes: any[] = [Container.prototype];
+	const agentContainerProto = Object.getPrototypeOf(AssistantMessageComponent.prototype);
+	if (agentContainerProto && agentContainerProto !== Object.prototype && !prototypes.includes(agentContainerProto)) {
+		prototypes.push(agentContainerProto);
+	}
+
+	const patchKey = PATCH_KEY;
+	const previous = host[patchKey] as Map<any, PatchState> | undefined;
+	const stateMap = new Map<any, PatchState>();
+
+	for (const prototype of prototypes) {
+		const prev = previous instanceof Map ? previous.get(prototype) : (previous as any as PatchState | undefined);
+		const original = {
+			addChild: prev && prototype.addChild === prev.installed.addChild ? prev.original.addChild : prototype.addChild,
+			removeChild: prev && prototype.removeChild === prev.installed.removeChild ? prev.original.removeChild : prototype.removeChild,
+			clear: prev && prototype.clear === prev.installed.clear ? prev.original.clear : prototype.clear,
+		};
+		const state: PatchState = {
+			active: true,
+			prototype,
+			original,
+			installed: undefined as any,
+		};
+		state.installed = {
+			addChild: function (this: any, component: any) {
+				const result = state.original.addChild.call(this, component);
+				if (component && typeof component === "object") {
+					// Remember where the current assistant message component lives so a
+					// thinking-only group can be inserted right after it later.
+					if (isAssistantMessage(component)) {
+						const assistant = component as any;
+						ensureAssistantThinkingPatched(assistant);
+						const streaming = assistant.isStreaming === true;
+						if (streaming) {
+							assistant[LIVE_ASSISTANT_KEY] = true;
+						}
+						runtime.lastChatContainer = this;
+						runtime.lastStreamingComp = assistant;
+						assistant[IS_STREAMING_COMP] = streaming;
+						// Keep one open block across assistant messages until visible text.
+						// A rebuilt message that already has text is that boundary.
+						if (assistantHasVisibleText(assistant)) {
+							sealOpenGroupAtAssistantText(assistant);
+						} else {
+							const open = findOpenGroup();
+							if (open) placeGroupAfter(this, assistant, open);
+						}
+						// A run that started before its message component existed can now
+						// be placed in the transcript, in front of this message's text.
+						if (runtime.unattachedThinking.length > 0) ensureThinkingGroup();
+						flushPendingTextSeal();
+					}
+					maybeGroup(this, component);
+					stripAssistantPhantomPadding(this, component);
+					restoreAssistantAnchor(this, component);
+				}
+				return result;
+			},
+			removeChild: function (this: any, component: any) {
+				const group = component?.[PARENT_KEY];
+				if (isToolGroup(group) && (group as any)[PARENT_KEY] === this) {
+					group.removeTool(component);
+					if (group.children.length === 0 && group.entries.length === 0) runtime.groups.delete(group);
+					return;
+				}
+				releaseAssistantAnchors(component);
+				return state.original.removeChild.call(this, component);
+			},
+			clear: function (this: any) {
+				if (runtime.assistantContentContainers.has(this)) {
+					// AssistantMessageComponent rebuilds this container for every
+					// cumulative stream update. Keep sealed compact groups in the
+					// anchor map; restoreAssistantAnchor() reinserts each one before
+					// its matching Markdown child as the rebuild proceeds.
+					getAssistantContentState(this).nextTextOrdinal = 0;
+					return state.original.clear.call(this);
+				}
+				for (const child of [...(this.children ?? [])]) {
+					if (isToolGroup(child)) {
+						for (const tool of [...child.children] as any[]) delete tool[PARENT_KEY];
+						runtime.groups.delete(child);
+					}
+					releaseAssistantAnchors(child);
+				}
+				return state.original.clear.call(this);
+			},
+		};
+		prototype.addChild = state.installed.addChild;
+		prototype.removeChild = state.installed.removeChild;
+		prototype.clear = state.installed.clear;
+		stateMap.set(prototype, state);
+	}
+	host[patchKey] = stateMap;
+}

package/src/guards.ts

@@ -0,0 +1,58 @@
+/** 兼容不同 Pi/TUI 模块实例的组件识别与原生工具渲染抑制。 */
+import { Container, Spacer, Markdown, Text } from "@earendil-works/pi-tui";
+import { AssistantMessageComponent, ToolExecutionComponent } from "@earendil-works/pi-coding-agent";
+import { ToolGroupComponent } from "./tool-group.js";
+import { TOOL_RENDER_PATCH_KEY, PARENT_KEY } from "./constants.js";
+
+export function isContainer(val: any): val is Container {
+	return Boolean(
+		val &&
+			(val instanceof Container ||
+				val.constructor?.name === "Container" ||
+				(Array.isArray((val as any).children) && typeof (val as any).addChild === "function")),
+	);
+}
+
+export function isAssistantMessage(val: any): val is AssistantMessageComponent {
+	return Boolean(
+		val &&
+			(val instanceof AssistantMessageComponent ||
+				val.constructor?.name === "AssistantMessageComponent"),
+	);
+}
+
+export function isToolExecution(val: any): val is ToolExecutionComponent {
+	return Boolean(
+		val &&
+			(val instanceof ToolExecutionComponent ||
+				val.constructor?.name === "ToolExecutionComponent"),
+	);
+}
+
+export function isSpacer(val: any): val is Spacer {
+	return Boolean(val && (val instanceof Spacer || val.constructor?.name === "Spacer"));
+}
+
+export function isMarkdown(val: any): val is Markdown {
+	return Boolean(val && (val instanceof Markdown || val.constructor?.name === "Markdown"));
+}
+
+export function isText(val: any): val is Text {
+	return Boolean(val && (val instanceof Text || val.constructor?.name === "Text"));
+}
+
+export function isToolGroup(val: any): val is ToolGroupComponent {
+	return Boolean(val && (val instanceof ToolGroupComponent || val.constructor?.name === "ToolGroupComponent"));
+}
+
+export function hideGroupedToolRender(tool: any): void {
+	const prototype = tool ? Object.getPrototypeOf(tool) : undefined;
+	if (!prototype || typeof prototype.render !== "function" || prototype[TOOL_RENDER_PATCH_KEY]) return;
+	const original = prototype.render as (this: any, width: number) => string[];
+	const installed = function (this: any, width: number): string[] {
+		if (this?.[PARENT_KEY]) return [];
+		return original.call(this, width);
+	};
+	prototype.render = installed;
+	prototype[TOOL_RENDER_PATCH_KEY] = { original, installed };
+}