@oh-my-pi/pi-coding-agent 4.1.0 → 4.2.1

package/src/modes/interactive/theme/theme.ts

@@ -2008,11 +2008,11 @@ export function getThemeExportColors(themeName?: string): {
 		const resolve = (value: string | number | undefined): string | undefined => {
 			if (value === undefined) return undefined;
 			if (typeof value === "number") return ansi256ToHex(value);
-			if (value.startsWith("$")) {
-				const resolved = vars[value];
-				if (resolved === undefined) return undefined;
-				if (typeof resolved === "number") return ansi256ToHex(resolved);
-				return resolved;
+			if (value === "" || value.startsWith("#")) return value;
+			const varName = value.startsWith("$") ? value.slice(1) : value;
+			if (varName in vars) {
+				const resolved = resolveVarRefs(varName, vars);
+				return typeof resolved === "number" ? ansi256ToHex(resolved) : resolved;
 			}
 			return value;
 		};

package/src/modes/interactive/types.ts

@@ -0,0 +1,189 @@
+import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import type { AssistantMessage, ImageContent, Message } from "@oh-my-pi/pi-ai";
+import type { Component, Container, Loader, Spacer, Text, TUI } from "@oh-my-pi/pi-tui";
+import type { AgentSession, AgentSessionEvent } from "../../core/agent-session";
+import type { ExtensionUIContext } from "../../core/extensions/index";
+import type { HistoryStorage } from "../../core/history-storage";
+import type { KeybindingsManager } from "../../core/keybindings";
+import type { SessionContext, SessionManager } from "../../core/session-manager";
+import type { SettingsManager } from "../../core/settings-manager";
+import type { VoiceSupervisor } from "../../core/voice-supervisor";
+import type { AssistantMessageComponent } from "./components/assistant-message";
+import type { BashExecutionComponent } from "./components/bash-execution";
+import type { CustomEditor } from "./components/custom-editor";
+import type { HookEditorComponent } from "./components/hook-editor";
+import type { HookInputComponent } from "./components/hook-input";
+import type { HookSelectorComponent } from "./components/hook-selector";
+import type { StatusLineComponent } from "./components/status-line";
+import type { ToolExecutionComponent } from "./components/tool-execution";
+import type { Theme } from "./theme/theme";
+
+export type CompactionQueuedMessage = {
+	text: string;
+	mode: "steer" | "followUp";
+};
+
+export interface InteractiveModeContext {
+	// UI access
+	ui: TUI;
+	chatContainer: Container;
+	pendingMessagesContainer: Container;
+	statusContainer: Container;
+	editor: CustomEditor;
+	editorContainer: Container;
+	statusLine: StatusLineComponent;
+
+	// Session access
+	session: AgentSession;
+	sessionManager: SessionManager;
+	settingsManager: SettingsManager;
+	agent: AgentSession["agent"];
+	voiceSupervisor: VoiceSupervisor;
+	historyStorage?: HistoryStorage;
+
+	// State
+	isInitialized: boolean;
+	isBackgrounded: boolean;
+	isBashMode: boolean;
+	toolOutputExpanded: boolean;
+	hideThinkingBlock: boolean;
+	pendingImages: ImageContent[];
+	compactionQueuedMessages: CompactionQueuedMessage[];
+	pendingTools: Map<string, ToolExecutionComponent>;
+	pendingBashComponents: BashExecutionComponent[];
+	bashComponent: BashExecutionComponent | undefined;
+	streamingComponent: AssistantMessageComponent | undefined;
+	streamingMessage: AssistantMessage | undefined;
+	loadingAnimation: Loader | undefined;
+	autoCompactionLoader: Loader | undefined;
+	retryLoader: Loader | undefined;
+	autoCompactionEscapeHandler?: () => void;
+	retryEscapeHandler?: () => void;
+	unsubscribe?: () => void;
+	onInputCallback?: (input: { text: string; images?: ImageContent[] }) => void;
+	lastSigintTime: number;
+	lastEscapeTime: number;
+	lastVoiceInterruptAt: number;
+	voiceAutoModeEnabled: boolean;
+	voiceProgressTimer: ReturnType<typeof setTimeout> | undefined;
+	voiceProgressSpoken: boolean;
+	voiceProgressLastLength: number;
+	hookSelector: HookSelectorComponent | undefined;
+	hookInput: HookInputComponent | undefined;
+	hookEditor: HookEditorComponent | undefined;
+	lastStatusSpacer: Spacer | undefined;
+	lastStatusText: Text | undefined;
+	fileSlashCommands: Set<string>;
+
+	// Lifecycle
+	init(): Promise<void>;
+	shutdown(): Promise<void>;
+
+	// Extension UI integration
+	setToolUIContext(uiContext: ExtensionUIContext, hasUI: boolean): void;
+	initializeHookRunner(uiContext: ExtensionUIContext, hasUI: boolean): void;
+	createBackgroundUiContext(): ExtensionUIContext;
+
+	// Event handling
+	handleBackgroundEvent(event: AgentSessionEvent): Promise<void>;
+
+	// UI helpers
+	showStatus(message: string, options?: { dim?: boolean }): void;
+	showError(message: string): void;
+	showWarning(message: string): void;
+	showNewVersionNotification(newVersion: string): void;
+	clearEditor(): void;
+	updatePendingMessagesDisplay(): void;
+	queueCompactionMessage(text: string, mode: "steer" | "followUp"): void;
+	flushCompactionQueue(options?: { willRetry?: boolean }): Promise<void>;
+	flushPendingBashComponents(): void;
+	isKnownSlashCommand(text: string): boolean;
+	addMessageToChat(message: AgentMessage, options?: { populateHistory?: boolean }): void;
+	renderSessionContext(
+		sessionContext: SessionContext,
+		options?: { updateFooter?: boolean; populateHistory?: boolean },
+	): void;
+	renderInitialMessages(): void;
+	getUserMessageText(message: Message): string;
+	findLastAssistantMessage(): AssistantMessage | undefined;
+	extractAssistantText(message: AssistantMessage): string;
+	updateEditorTopBorder(): void;
+	updateEditorBorderColor(): void;
+	rebuildChatFromMessages(): void;
+
+	// Command handling
+	handleExportCommand(text: string): Promise<void>;
+	handleShareCommand(): Promise<void>;
+	handleCopyCommand(): Promise<void>;
+	handleSessionCommand(): void;
+	handleChangelogCommand(): void;
+	handleHotkeysCommand(): void;
+	handleDumpCommand(): Promise<void>;
+	handleClearCommand(): Promise<void>;
+	handleDebugCommand(): void;
+	handleArminSaysHi(): void;
+	handleBashCommand(command: string, excludeFromContext?: boolean): Promise<void>;
+	handleCompactCommand(customInstructions?: string): Promise<void>;
+	executeCompaction(customInstructions?: string, isAuto?: boolean): Promise<void>;
+	openInBrowser(urlOrPath: string): void;
+
+	// Selector handling
+	showSettingsSelector(): void;
+	showHistorySearch(): void;
+	showExtensionsDashboard(): void;
+	showModelSelector(options?: { temporaryOnly?: boolean }): void;
+	showUserMessageSelector(): void;
+	showTreeSelector(): void;
+	showSessionSelector(): void;
+	handleResumeSession(sessionPath: string): Promise<void>;
+	showOAuthSelector(mode: "login" | "logout"): Promise<void>;
+	showHookConfirm(title: string, message: string): Promise<boolean>;
+
+	// Input handling
+	handleCtrlC(): void;
+	handleCtrlD(): void;
+	handleCtrlZ(): void;
+	handleDequeue(): void;
+	handleBackgroundCommand(): void;
+	handleImagePaste(): Promise<boolean>;
+	cycleThinkingLevel(): void;
+	cycleRoleModel(options?: { temporary?: boolean }): Promise<void>;
+	toggleToolOutputExpansion(): void;
+	toggleThinkingBlockVisibility(): void;
+	openExternalEditor(): void;
+	registerExtensionShortcuts(): void;
+
+	// Voice handling
+	setVoiceStatus(text: string | undefined): void;
+	handleVoiceInterrupt(reason?: string): Promise<void>;
+	startVoiceProgressTimer(): void;
+	stopVoiceProgressTimer(): void;
+	maybeSpeakProgress(): Promise<void>;
+	submitVoiceText(text: string): Promise<void>;
+
+	// Hook UI methods
+	initHooksAndCustomTools(): Promise<void>;
+	emitCustomToolSessionEvent(
+		reason: "start" | "switch" | "branch" | "tree" | "shutdown",
+		previousSessionFile?: string,
+	): Promise<void>;
+	setHookWidget(key: string, content: unknown): void;
+	setHookStatus(key: string, text: string | undefined): void;
+	showHookSelector(title: string, options: string[]): Promise<string | undefined>;
+	hideHookSelector(): void;
+	showHookInput(title: string, placeholder?: string): Promise<string | undefined>;
+	hideHookInput(): void;
+	showHookEditor(title: string, prefill?: string): Promise<string | undefined>;
+	hideHookEditor(): void;
+	showHookNotify(message: string, type?: "info" | "warning" | "error"): void;
+	showHookCustom<T>(
+		factory: (
+			tui: TUI,
+			theme: Theme,
+			keybindings: KeybindingsManager,
+			done: (result: T) => void,
+		) => (Component & { dispose?(): void }) | Promise<Component & { dispose?(): void }>,
+	): Promise<T>;
+	showExtensionError(extensionPath: string, error: string): void;
+	showToolError(toolName: string, error: string): void;
+}

package/src/modes/interactive/utils/ui-helpers.ts

@@ -0,0 +1,449 @@
+import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import type { AssistantMessage, Message } from "@oh-my-pi/pi-ai";
+import { Spacer, Text, TruncatedText } from "@oh-my-pi/pi-tui";
+import type { CustomMessage } from "../../../core/messages";
+import type { SessionContext } from "../../../core/session-manager";
+import type { TruncationResult } from "../../../core/tools/truncate";
+import { AssistantMessageComponent } from "../components/assistant-message";
+import { BashExecutionComponent } from "../components/bash-execution";
+import { BranchSummaryMessageComponent } from "../components/branch-summary-message";
+import { CompactionSummaryMessageComponent } from "../components/compaction-summary-message";
+import { CustomMessageComponent } from "../components/custom-message";
+import { DynamicBorder } from "../components/dynamic-border";
+import { ToolExecutionComponent } from "../components/tool-execution";
+import { UserMessageComponent } from "../components/user-message";
+import { theme } from "../theme/theme";
+import type { CompactionQueuedMessage, InteractiveModeContext } from "../types";
+
+type TextBlock = { type: "text"; text: string };
+
+type QueuedMessages = {
+	steering: string[];
+	followUp: string[];
+};
+
+export class UiHelpers {
+	constructor(private ctx: InteractiveModeContext) {}
+
+	/** Extract text content from a user message */
+	getUserMessageText(message: Message): string {
+		if (message.role !== "user") return "";
+		const textBlocks =
+			typeof message.content === "string"
+				? [{ type: "text", text: message.content }]
+				: message.content.filter((content): content is TextBlock => content.type === "text");
+		return textBlocks.map((block) => block.text).join("");
+	}
+
+	/**
+	 * Show a status message in the chat.
+	 *
+	 * If multiple status messages are emitted back-to-back (without anything else being added to the chat),
+	 * we update the previous status line instead of appending new ones to avoid log spam.
+	 */
+	showStatus(message: string, options?: { dim?: boolean }): void {
+		if (this.ctx.isBackgrounded) {
+			return;
+		}
+		const children = this.ctx.chatContainer.children;
+		const last = children.length > 0 ? children[children.length - 1] : undefined;
+		const secondLast = children.length > 1 ? children[children.length - 2] : undefined;
+		const useDim = options?.dim ?? true;
+		const rendered = useDim ? theme.fg("dim", message) : message;
+
+		if (last && secondLast && last === this.ctx.lastStatusText && secondLast === this.ctx.lastStatusSpacer) {
+			this.ctx.lastStatusText.setText(rendered);
+			this.ctx.ui.requestRender();
+			return;
+		}
+
+		const spacer = new Spacer(1);
+		const text = new Text(rendered, 1, 0);
+		this.ctx.chatContainer.addChild(spacer);
+		this.ctx.chatContainer.addChild(text);
+		this.ctx.lastStatusSpacer = spacer;
+		this.ctx.lastStatusText = text;
+		this.ctx.ui.requestRender();
+	}
+
+	addMessageToChat(message: AgentMessage, options?: { populateHistory?: boolean }): void {
+		switch (message.role) {
+			case "bashExecution": {
+				const component = new BashExecutionComponent(message.command, this.ctx.ui, message.excludeFromContext);
+				if (message.output) {
+					component.appendOutput(message.output);
+				}
+				component.setComplete(
+					message.exitCode,
+					message.cancelled,
+					message.truncated ? ({ truncated: true } as TruncationResult) : undefined,
+					message.fullOutputPath,
+				);
+				this.ctx.chatContainer.addChild(component);
+				break;
+			}
+			case "hookMessage":
+			case "custom": {
+				if (message.display) {
+					const renderer = this.ctx.session.extensionRunner?.getMessageRenderer(message.customType);
+					// Both HookMessage and CustomMessage have the same structure, cast for compatibility
+					this.ctx.chatContainer.addChild(new CustomMessageComponent(message as CustomMessage<unknown>, renderer));
+				}
+				break;
+			}
+			case "compactionSummary": {
+				this.ctx.chatContainer.addChild(new Spacer(1));
+				const component = new CompactionSummaryMessageComponent(message);
+				component.setExpanded(this.ctx.toolOutputExpanded);
+				this.ctx.chatContainer.addChild(component);
+				break;
+			}
+			case "branchSummary": {
+				this.ctx.chatContainer.addChild(new Spacer(1));
+				const component = new BranchSummaryMessageComponent(message);
+				component.setExpanded(this.ctx.toolOutputExpanded);
+				this.ctx.chatContainer.addChild(component);
+				break;
+			}
+			case "fileMention": {
+				// Render compact file mention display
+				for (const file of message.files) {
+					const text = `${theme.fg("dim", `${theme.tree.last} `)}${theme.fg("muted", "Read")} ${theme.fg(
+						"accent",
+						file.path,
+					)} ${theme.fg("dim", `(${file.lineCount} lines)`)}`;
+					this.ctx.chatContainer.addChild(new Text(text, 0, 0));
+				}
+				break;
+			}
+			case "user": {
+				const textContent = this.ctx.getUserMessageText(message);
+				if (textContent) {
+					const userComponent = new UserMessageComponent(textContent);
+					this.ctx.chatContainer.addChild(userComponent);
+					if (options?.populateHistory) {
+						this.ctx.editor.addToHistory(textContent);
+					}
+				}
+				break;
+			}
+			case "assistant": {
+				const assistantComponent = new AssistantMessageComponent(message, this.ctx.hideThinkingBlock);
+				this.ctx.chatContainer.addChild(assistantComponent);
+				break;
+			}
+			case "toolResult": {
+				// Tool results are rendered inline with tool calls, handled separately
+				break;
+			}
+			default: {
+				const _exhaustive: never = message;
+			}
+		}
+	}
+
+	/**
+	 * Render session context to chat. Used for initial load and rebuild after compaction.
+	 * @param sessionContext Session context to render
+	 * @param options.updateFooter Update footer state
+	 * @param options.populateHistory Add user messages to editor history
+	 */
+	renderSessionContext(
+		sessionContext: SessionContext,
+		options: { updateFooter?: boolean; populateHistory?: boolean } = {},
+	): void {
+		this.ctx.pendingTools.clear();
+
+		if (options.updateFooter) {
+			this.ctx.statusLine.invalidate();
+			this.ctx.updateEditorBorderColor();
+		}
+
+		for (const message of sessionContext.messages) {
+			// Assistant messages need special handling for tool calls
+			if (message.role === "assistant") {
+				this.ctx.addMessageToChat(message);
+				// Render tool call components
+				for (const content of message.content) {
+					if (content.type === "toolCall") {
+						const tool = this.ctx.session.getToolByName(content.name);
+						const component = new ToolExecutionComponent(
+							content.name,
+							content.arguments,
+							{ showImages: this.ctx.settingsManager.getShowImages() },
+							tool,
+							this.ctx.ui,
+							this.ctx.sessionManager.getCwd(),
+						);
+						component.setExpanded(this.ctx.toolOutputExpanded);
+						this.ctx.chatContainer.addChild(component);
+
+						if (message.stopReason === "aborted" || message.stopReason === "error") {
+							let errorMessage: string;
+							if (message.stopReason === "aborted") {
+								const retryAttempt = this.ctx.session.retryAttempt;
+								errorMessage =
+									retryAttempt > 0
+										? `Aborted after ${retryAttempt} retry attempt${retryAttempt > 1 ? "s" : ""}`
+										: "Operation aborted";
+							} else {
+								errorMessage = message.errorMessage || "Error";
+							}
+							component.updateResult({ content: [{ type: "text", text: errorMessage }], isError: true });
+						} else {
+							this.ctx.pendingTools.set(content.id, component);
+						}
+					}
+				}
+			} else if (message.role === "toolResult") {
+				// Match tool results to pending tool components
+				const component = this.ctx.pendingTools.get(message.toolCallId);
+				if (component) {
+					component.updateResult(message);
+					this.ctx.pendingTools.delete(message.toolCallId);
+				}
+			} else {
+				// All other messages use standard rendering
+				this.ctx.addMessageToChat(message, options);
+			}
+		}
+
+		this.ctx.pendingTools.clear();
+		this.ctx.ui.requestRender();
+	}
+
+	renderInitialMessages(): void {
+		// Get aligned messages and entries from session context
+		const context = this.ctx.sessionManager.buildSessionContext();
+		this.ctx.renderSessionContext(context, {
+			updateFooter: true,
+			populateHistory: true,
+		});
+
+		// Show compaction info if session was compacted
+		const allEntries = this.ctx.sessionManager.getEntries();
+		let compactionCount = 0;
+		for (const entry of allEntries) {
+			if (entry.type === "compaction") {
+				compactionCount++;
+			}
+		}
+		if (compactionCount > 0) {
+			const times = compactionCount === 1 ? "1 time" : `${compactionCount} times`;
+			this.ctx.showStatus(`Session compacted ${times}`);
+		}
+	}
+
+	clearEditor(): void {
+		if (this.ctx.isBackgrounded) {
+			return;
+		}
+		this.ctx.editor.setText("");
+		this.ctx.pendingImages = [];
+		this.ctx.ui.requestRender();
+	}
+
+	showError(errorMessage: string): void {
+		if (this.ctx.isBackgrounded) {
+			process.stderr.write(`Error: ${errorMessage}\n`);
+			return;
+		}
+		this.ctx.chatContainer.addChild(new Spacer(1));
+		this.ctx.chatContainer.addChild(new Text(theme.fg("error", `Error: ${errorMessage}`), 1, 0));
+		this.ctx.ui.requestRender();
+	}
+
+	showWarning(warningMessage: string): void {
+		if (this.ctx.isBackgrounded) {
+			process.stderr.write(`Warning: ${warningMessage}\n`);
+			return;
+		}
+		this.ctx.chatContainer.addChild(new Spacer(1));
+		this.ctx.chatContainer.addChild(new Text(theme.fg("warning", `Warning: ${warningMessage}`), 1, 0));
+		this.ctx.ui.requestRender();
+	}
+
+	showNewVersionNotification(newVersion: string): void {
+		this.ctx.chatContainer.addChild(new Spacer(1));
+		this.ctx.chatContainer.addChild(new DynamicBorder((text) => theme.fg("warning", text)));
+		this.ctx.chatContainer.addChild(
+			new Text(
+				theme.bold(theme.fg("warning", "Update Available")) +
+					"\n" +
+					theme.fg("muted", `New version ${newVersion} is available. Run: `) +
+					theme.fg("accent", "omp update"),
+				1,
+				0,
+			),
+		);
+		this.ctx.chatContainer.addChild(new DynamicBorder((text) => theme.fg("warning", text)));
+		this.ctx.ui.requestRender();
+	}
+
+	updatePendingMessagesDisplay(): void {
+		this.ctx.pendingMessagesContainer.clear();
+		const queuedMessages = this.ctx.session.getQueuedMessages() as QueuedMessages;
+
+		const steeringMessages: Array<{ message: string; label: string }> = [];
+		for (const message of queuedMessages.steering) {
+			steeringMessages.push({ message, label: "Steer" });
+		}
+		for (const entry of this.ctx.compactionQueuedMessages as CompactionQueuedMessage[]) {
+			if (entry.mode === "steer") {
+				steeringMessages.push({ message: entry.text, label: "Steer" });
+			}
+		}
+
+		const followUpMessages: Array<{ message: string; label: string }> = [];
+		for (const message of queuedMessages.followUp) {
+			followUpMessages.push({ message, label: "Follow-up" });
+		}
+		for (const entry of this.ctx.compactionQueuedMessages as CompactionQueuedMessage[]) {
+			if (entry.mode === "followUp") {
+				followUpMessages.push({ message: entry.text, label: "Follow-up" });
+			}
+		}
+
+		const allMessages = [...steeringMessages, ...followUpMessages];
+		if (allMessages.length > 0) {
+			this.ctx.pendingMessagesContainer.addChild(new Spacer(1));
+			for (const entry of allMessages) {
+				const queuedText = theme.fg("dim", `${entry.label}: ${entry.message}`);
+				this.ctx.pendingMessagesContainer.addChild(new TruncatedText(queuedText, 1, 0));
+			}
+		}
+	}
+
+	queueCompactionMessage(text: string, mode: "steer" | "followUp"): void {
+		this.ctx.compactionQueuedMessages.push({ text, mode } as CompactionQueuedMessage);
+		this.ctx.editor.addToHistory(text);
+		this.ctx.editor.setText("");
+		this.ctx.updatePendingMessagesDisplay();
+		this.ctx.showStatus("Queued message for after compaction");
+	}
+
+	isKnownSlashCommand(text: string): boolean {
+		if (!text.startsWith("/")) return false;
+		const spaceIndex = text.indexOf(" ");
+		const commandName = spaceIndex === -1 ? text.slice(1) : text.slice(1, spaceIndex);
+		if (!commandName) return false;
+
+		if (this.ctx.session.extensionRunner?.getCommand(commandName)) {
+			return true;
+		}
+
+		for (const command of this.ctx.session.customCommands) {
+			if (command.command.name === commandName) {
+				return true;
+			}
+		}
+
+		return this.ctx.fileSlashCommands.has(commandName);
+	}
+
+	async flushCompactionQueue(options?: { willRetry?: boolean }): Promise<void> {
+		if (this.ctx.compactionQueuedMessages.length === 0) {
+			return;
+		}
+
+		const queuedMessages = [...(this.ctx.compactionQueuedMessages as CompactionQueuedMessage[])];
+		this.ctx.compactionQueuedMessages = [] as CompactionQueuedMessage[];
+		this.ctx.updatePendingMessagesDisplay();
+
+		const restoreQueue = (error: unknown) => {
+			this.ctx.session.clearQueue();
+			this.ctx.compactionQueuedMessages = queuedMessages;
+			this.ctx.updatePendingMessagesDisplay();
+			this.ctx.showError(
+				`Failed to send queued message${queuedMessages.length > 1 ? "s" : ""}: ${
+					error instanceof Error ? error.message : String(error)
+				}`,
+			);
+		};
+
+		try {
+			if (options?.willRetry) {
+				for (const message of queuedMessages) {
+					if (this.ctx.isKnownSlashCommand(message.text)) {
+						await this.ctx.session.prompt(message.text);
+					} else if (message.mode === "followUp") {
+						await this.ctx.session.followUp(message.text);
+					} else {
+						await this.ctx.session.steer(message.text);
+					}
+				}
+				this.ctx.updatePendingMessagesDisplay();
+				return;
+			}
+
+			let firstPromptIndex = -1;
+			for (let i = 0; i < queuedMessages.length; i++) {
+				if (!this.ctx.isKnownSlashCommand(queuedMessages[i].text)) {
+					firstPromptIndex = i;
+					break;
+				}
+			}
+			if (firstPromptIndex === -1) {
+				for (const message of queuedMessages) {
+					await this.ctx.session.prompt(message.text);
+				}
+				return;
+			}
+
+			const preCommands = queuedMessages.slice(0, firstPromptIndex);
+			const firstPrompt = queuedMessages[firstPromptIndex];
+			const rest = queuedMessages.slice(firstPromptIndex + 1);
+
+			for (const message of preCommands) {
+				await this.ctx.session.prompt(message.text);
+			}
+
+			const promptPromise = this.ctx.session.prompt(firstPrompt.text).catch((error: unknown) => {
+				restoreQueue(error);
+			});
+
+			for (const message of rest) {
+				if (this.ctx.isKnownSlashCommand(message.text)) {
+					await this.ctx.session.prompt(message.text);
+				} else if (message.mode === "followUp") {
+					await this.ctx.session.followUp(message.text);
+				} else {
+					await this.ctx.session.steer(message.text);
+				}
+			}
+			this.ctx.updatePendingMessagesDisplay();
+			void promptPromise;
+		} catch (error) {
+			restoreQueue(error);
+		}
+	}
+
+	/** Move pending bash components from pending area to chat */
+	flushPendingBashComponents(): void {
+		for (const component of this.ctx.pendingBashComponents) {
+			this.ctx.pendingMessagesContainer.removeChild(component);
+			this.ctx.chatContainer.addChild(component);
+		}
+		this.ctx.pendingBashComponents = [];
+	}
+
+	findLastAssistantMessage(): AssistantMessage | undefined {
+		for (let i = this.ctx.session.messages.length - 1; i >= 0; i--) {
+			const message = this.ctx.session.messages[i];
+			if (message?.role === "assistant") {
+				return message as AssistantMessage;
+			}
+		}
+		return undefined;
+	}
+
+	extractAssistantText(message: AssistantMessage): string {
+		let text = "";
+		for (const content of message.content) {
+			if (content.type === "text") {
+				text += content.text;
+			}
+		}
+		return text.trim();
+	}
+}