pi-ui-extend 0.1.1

package/dist/app/prompt-enhancer-controller.d.ts

@@ -0,0 +1,40 @@
+import { type AgentSessionRuntime } from "@earendil-works/pi-coding-agent";
+import type { PromptEnhancerConfig } from "../config.js";
+import type { InputEditor } from "../input-editor.js";
+import type { ToastNotifier } from "../ui.js";
+import type { TabInputState } from "./tabs-controller.js";
+import type { SessionActivity } from "./types.js";
+export type AppPromptEnhancerControllerHost = {
+    runtime(): AgentSessionRuntime | undefined;
+    inputEditor(): InputEditor;
+    activeInputTabId(): string | undefined;
+    inputStateForTab(tabId: string | undefined): TabInputState | undefined;
+    setInputStateForTab(tabId: string | undefined, state: TabInputState): void;
+    promptEnhancerConfig(): PromptEnhancerConfig;
+    resetInputAfterProgrammaticEdit(): void;
+    setStatus(status: string): void;
+    setSessionStatus(session: AgentSessionRuntime["session"] | undefined): void;
+    setSessionActivity(activity: SessionActivity): void;
+    toast: ToastNotifier;
+    render(): void;
+};
+type PromptEnhanceRunner = typeof enhancePromptWithPi;
+type AppPromptEnhancerControllerOptions = {
+    enhancePromptWithPi?: PromptEnhanceRunner;
+};
+export declare class AppPromptEnhancerController {
+    private readonly host;
+    private enhancing;
+    private readonly enhancePromptWithPi;
+    constructor(host: AppPromptEnhancerControllerHost, options?: AppPromptEnhancerControllerOptions);
+    statusWidgetText(): string;
+    statusWidgetActive(): boolean;
+    statusWidgetEnabled(): boolean;
+    enhancePrompt(): Promise<void>;
+    private currentTarget;
+    private applyEnhancedPrompt;
+    private restoreSessionState;
+}
+export declare function promptEnhancerTextIsSufficient(text: string): boolean;
+declare function enhancePromptWithPi(runtime: AgentSessionRuntime, draft: string, config: PromptEnhancerConfig): Promise<string>;
+export {};

package/dist/app/prompt-enhancer-controller.js

@@ -0,0 +1,215 @@
+import { createAgentSessionFromServices, createAgentSessionServices, SessionManager, } from "@earendil-works/pi-coding-agent";
+import { APP_ICONS } from "./icons.js";
+import { stringifyUnknown } from "./message-content.js";
+import { parseModelRef } from "./model-ref.js";
+const PROMPT_ENHANCER_SYSTEM_PROMPT = `You improve prompts for a coding agent.
+
+Rewrite the user's draft into a clearer, more actionable prompt.
+Preserve the user's intent and language.
+Do not solve the task.
+Do not add unsupported assumptions.
+Add useful constraints, acceptance criteria, and context requests when helpful.
+Output only the improved prompt. No commentary, no markdown fences.`;
+const PROMPT_ENHANCER_MIN_TEXT_LENGTH = 3;
+export class AppPromptEnhancerController {
+    host;
+    enhancing = false;
+    enhancePromptWithPi;
+    constructor(host, options = {}) {
+        this.host = host;
+        this.enhancePromptWithPi = options.enhancePromptWithPi ?? enhancePromptWithPi;
+    }
+    statusWidgetText() {
+        return this.enhancing ? APP_ICONS.timerSand : APP_ICONS.autoFix;
+    }
+    statusWidgetActive() {
+        return this.enhancing;
+    }
+    statusWidgetEnabled() {
+        return this.enhancing || this.currentTarget() !== undefined;
+    }
+    async enhancePrompt() {
+        if (this.enhancing) {
+            this.host.toast.warning("Prompt enhancement is already running");
+            return;
+        }
+        const runtime = this.host.runtime();
+        if (!runtime) {
+            this.host.toast.error("Prompt enhancer unavailable: runtime is not initialized");
+            return;
+        }
+        const target = this.currentTarget();
+        if (!target) {
+            this.host.toast.warning(`Type at least ${PROMPT_ENHANCER_MIN_TEXT_LENGTH} characters to enhance`);
+            return;
+        }
+        this.enhancing = true;
+        this.host.setStatus("enhancing prompt");
+        this.host.setSessionActivity("thinking");
+        this.host.render();
+        try {
+            const enhanced = await this.enhancePromptWithPi(runtime, target.text, this.host.promptEnhancerConfig());
+            const currentInputState = this.host.inputStateForTab(target.tabId);
+            if (!currentInputState || currentInputState.text !== target.originalEditorText) {
+                this.host.toast.warning("Prompt was changed before enhancement completed; result was not applied");
+                return;
+            }
+            this.applyEnhancedPrompt(target, enhanced);
+            this.host.resetInputAfterProgrammaticEdit();
+            this.host.toast.success(target.kind === "selection" ? "Selection enhanced" : "Prompt enhanced");
+        }
+        catch (error) {
+            this.host.toast.error(`Prompt enhance failed: ${stringifyUnknown(error)}`);
+        }
+        finally {
+            this.enhancing = false;
+            this.restoreSessionState();
+            this.host.render();
+        }
+    }
+    currentTarget() {
+        const editor = this.host.inputEditor();
+        const tabId = this.host.activeInputTabId();
+        const originalEditorText = editor.text;
+        const selectedText = editor.getSelectedText();
+        if (selectedText !== undefined && selectedText.trim().length > 0 && editor.selection) {
+            if (!promptEnhancerTextIsSufficient(selectedText))
+                return undefined;
+            const start = Math.min(editor.selection.anchor, editor.selection.active);
+            const end = Math.max(editor.selection.anchor, editor.selection.active);
+            return {
+                kind: "selection",
+                tabId,
+                text: selectedText,
+                originalEditorText,
+                start,
+                end,
+            };
+        }
+        if (!promptEnhancerTextIsSufficient(originalEditorText))
+            return undefined;
+        return {
+            kind: "input",
+            tabId,
+            text: originalEditorText,
+            originalEditorText,
+            start: 0,
+            end: originalEditorText.length,
+        };
+    }
+    applyEnhancedPrompt(target, enhanced) {
+        const nextText = `${target.originalEditorText.slice(0, target.start)}${enhanced}${target.originalEditorText.slice(target.end)}`;
+        this.host.setInputStateForTab(target.tabId, {
+            text: nextText,
+            cursor: target.start + enhanced.length,
+        });
+    }
+    restoreSessionState() {
+        const session = this.host.runtime()?.session;
+        this.host.setSessionStatus(session);
+        this.host.setSessionActivity(session?.isStreaming || session?.isCompacting ? "running" : "idle");
+    }
+}
+export function promptEnhancerTextIsSufficient(text) {
+    return text.trim().length >= PROMPT_ENHANCER_MIN_TEXT_LENGTH;
+}
+async function enhancePromptWithPi(runtime, draft, config) {
+    const parsedModel = parseModelRef(config.modelRef);
+    const services = await createAgentSessionServices({
+        cwd: runtime.cwd,
+        agentDir: runtime.services.agentDir,
+        authStorage: runtime.services.authStorage,
+        settingsManager: runtime.services.settingsManager,
+        modelRegistry: runtime.services.modelRegistry,
+        resourceLoaderOptions: {
+            noExtensions: true,
+            noSkills: true,
+            noPromptTemplates: true,
+            noThemes: true,
+            noContextFiles: true,
+            systemPrompt: PROMPT_ENHANCER_SYSTEM_PROMPT,
+        },
+    });
+    services.modelRegistry.refresh();
+    const model = services.modelRegistry.find(parsedModel.provider, parsedModel.modelId);
+    if (!model) {
+        throw new Error(modelNotFoundMessage(parsedModel.provider, parsedModel.modelId, services.modelRegistry.getAll()));
+    }
+    const { session } = await createAgentSessionFromServices({
+        services,
+        sessionManager: SessionManager.inMemory(runtime.cwd),
+        model,
+        thinkingLevel: parsedModel.thinkingLevel ?? "minimal",
+        noTools: "all",
+    });
+    let output = "";
+    let streamError;
+    const unsubscribe = session.subscribe((event) => {
+        if (event.type !== "message_update")
+            return;
+        const assistantEvent = event.assistantMessageEvent;
+        if (assistantEvent.type === "text_delta")
+            output += assistantEvent.delta;
+        else if (assistantEvent.type === "error")
+            streamError = assistantEvent.error.errorMessage ?? assistantEvent.reason;
+    });
+    try {
+        await session.prompt(buildEnhancerPrompt(draft), { expandPromptTemplates: false });
+        if (streamError)
+            throw new Error(streamError);
+        const cleaned = cleanupEnhancedPrompt(output);
+        if (cleaned.length === 0)
+            throw new Error("model returned an empty prompt");
+        return cleaned;
+    }
+    finally {
+        unsubscribe();
+        session.dispose();
+    }
+}
+function buildEnhancerPrompt(draft) {
+    return [
+        "Rewrite this draft prompt. Output only the improved prompt.",
+        "<draft>",
+        draft,
+        "</draft>",
+    ].join("\n");
+}
+function cleanupEnhancedPrompt(output) {
+    let text = output.replace(/\r\n/gu, "\n").trim();
+    const fenced = /^```[^\n`]*\n([\s\S]*?)\n```$/u.exec(text);
+    if (fenced)
+        text = fenced[1].trim();
+    return text;
+}
+function modelNotFoundMessage(provider, modelId, models) {
+    const requested = `${provider}/${modelId}`;
+    const suggestions = suggestModelRefs(provider, modelId, models);
+    return suggestions.length > 0
+        ? `Model not found: ${requested}. Did you mean ${suggestions.join(", ")}?`
+        : `Model not found: ${requested}`;
+}
+function suggestModelRefs(provider, modelId, models) {
+    const queryTokens = tokenSet(`${provider} ${modelId}`);
+    return models
+        .map((model) => ({ ref: `${model.provider}/${model.id}`, score: modelSuggestionScore(model, provider, modelId, queryTokens) }))
+        .filter((candidate) => candidate.score > 0)
+        .sort((a, b) => b.score - a.score || a.ref.localeCompare(b.ref))
+        .slice(0, 3)
+        .map((candidate) => candidate.ref);
+}
+function modelSuggestionScore(model, provider, modelId, queryTokens) {
+    let score = 0;
+    if (model.provider === provider)
+        score += 8;
+    if (model.id === modelId)
+        score += 8;
+    for (const token of tokenSet(`${model.provider} ${model.id} ${model.name ?? ""}`)) {
+        if (queryTokens.has(token))
+            score += 1;
+    }
+    return score;
+}
+function tokenSet(value) {
+    return new Set(value.toLowerCase().split(/[^a-z0-9]+/u).filter((token) => token.length > 0));
+}

package/dist/app/queued-message-controller.d.ts

@@ -0,0 +1,62 @@
+import type { AgentSession, AgentSessionRuntime } from "@earendil-works/pi-coding-agent";
+import type { ImageContent } from "../input-editor.js";
+import type { Entry, SessionActivity, SubmittedUserMessage } from "./types.js";
+export type AppQueuedMessageControllerHost = {
+    runtime(): AgentSessionRuntime | undefined;
+    requireRuntime(): AgentSessionRuntime;
+    visibleEntries(): readonly Entry[];
+    isRunning(): boolean;
+    render(): void;
+    addEntry(entry: Entry): void;
+    addSessionAbortedEntry(): void;
+    setStatus(status: string): void;
+    setSessionStatus(session: AgentSession | undefined): void;
+    setSessionActivity(activity: SessionActivity): void;
+    showToast(message: string, kind: "success" | "error" | "warning" | "info"): void;
+    inputText(): string;
+    resetRequestHistoryNavigation(): void;
+    clearInput(): void;
+    setInput(value: string): void;
+    insertInput(value: string): void;
+    attachImage(data: string, mimeType: string): void;
+};
+export declare class AppQueuedMessageController {
+    private readonly host;
+    readonly deferredUserMessages: SubmittedUserMessage[];
+    private promptSubmissionInFlight;
+    private flushingDeferredUserMessages;
+    private immediateSendInProgress;
+    constructor(host: AppQueuedMessageControllerHost);
+    reset(): void;
+    createSubmittedUserMessage(promptText: string, displayText: string, images: ImageContent[]): SubmittedUserMessage;
+    submitUserMessage(message: SubmittedUserMessage): Promise<void>;
+    sendUserMessageToSession(message: SubmittedUserMessage, options?: {
+        streamingBehavior?: "steer" | "followUp";
+    }): Promise<void>;
+    flushDeferredUserMessages(): Promise<void>;
+    queuedMessageCounts(): {
+        steering: number;
+        followUp: number;
+    };
+    totalQueuedMessageCount(): number;
+    updateQueuedMessageStatus(): void;
+    restoreQueuedMessagesToEditorForAbort(): number;
+    cancelQueuedMessage(entryId: string): Promise<void>;
+    editQueuedMessage(entryId: string): Promise<void>;
+    sendQueuedMessageImmediately(entryId: string): Promise<void>;
+    findQueuedEntry(entryId: string): Extract<Entry, {
+        kind: "queued";
+    }> | undefined;
+    private shouldDeferUserMessage;
+    private deferUserMessage;
+    private rewriteSdkQueuedMessages;
+    private takeQueuedEntryForInterruptedSend;
+    private restoreSdkQueuedMessages;
+    private interruptSessionForImmediateSend;
+    private waitForCompactionToStop;
+    private sessionActivity;
+    private removeQueuedEntry;
+    private requeueRemovedEntry;
+    private restoreSubmittedMessageToEditor;
+    private restorableSubmittedMessageText;
+}

package/dist/app/queued-message-controller.js

@@ -0,0 +1,377 @@
+import { createId } from "./id.js";
+import { stringifyUnknown, submittedUserDisplayText } from "./message-content.js";
+export class AppQueuedMessageController {
+    host;
+    deferredUserMessages = [];
+    promptSubmissionInFlight = false;
+    flushingDeferredUserMessages = false;
+    immediateSendInProgress = false;
+    constructor(host) {
+        this.host = host;
+    }
+    reset() {
+        this.deferredUserMessages.length = 0;
+        this.promptSubmissionInFlight = false;
+        this.flushingDeferredUserMessages = false;
+    }
+    createSubmittedUserMessage(promptText, displayText, images) {
+        return {
+            id: createId("queued-user"),
+            promptText,
+            displayText: submittedUserDisplayText(displayText, promptText, images),
+            images,
+        };
+    }
+    async submitUserMessage(message) {
+        const session = this.host.requireRuntime().session;
+        if (this.shouldDeferUserMessage(session)) {
+            this.deferUserMessage(message);
+            return;
+        }
+        await this.sendUserMessageToSession(message);
+    }
+    async sendUserMessageToSession(message, options = {}) {
+        const session = this.host.requireRuntime().session;
+        const markInFlight = !session.isStreaming;
+        if (markInFlight)
+            this.promptSubmissionInFlight = true;
+        this.host.setSessionActivity("running");
+        try {
+            const opts = {};
+            if (session.isStreaming)
+                opts.streamingBehavior = options.streamingBehavior ?? "steer";
+            if (message.images.length > 0)
+                opts.images = message.images;
+            await session.prompt(message.promptText, Object.keys(opts).length > 0 ? opts : undefined);
+        }
+        finally {
+            if (markInFlight)
+                this.promptSubmissionInFlight = false;
+            const runtime = this.host.runtime();
+            if (runtime) {
+                const activeSession = runtime.session;
+                this.host.setSessionStatus(activeSession);
+                this.host.setSessionActivity(activeSession.isStreaming || activeSession.isCompacting ? "running" : "idle");
+            }
+            if (this.totalQueuedMessageCount() > 0)
+                this.updateQueuedMessageStatus();
+            if (!this.flushingDeferredUserMessages)
+                void this.flushDeferredUserMessages();
+        }
+    }
+    async flushDeferredUserMessages() {
+        if (this.immediateSendInProgress || this.flushingDeferredUserMessages || this.deferredUserMessages.length === 0)
+            return;
+        const session = this.host.runtime()?.session;
+        if (!session || session.isCompacting)
+            return;
+        if (!session.isStreaming && this.promptSubmissionInFlight)
+            return;
+        this.flushingDeferredUserMessages = true;
+        try {
+            while (this.deferredUserMessages.length > 0) {
+                if (this.immediateSendInProgress)
+                    break;
+                const activeSession = this.host.runtime()?.session;
+                if (!activeSession || activeSession.isCompacting)
+                    break;
+                if (!activeSession.isStreaming && this.promptSubmissionInFlight)
+                    break;
+                const message = this.deferredUserMessages.shift();
+                if (!message)
+                    break;
+                this.updateQueuedMessageStatus();
+                if (!activeSession.isStreaming && this.deferredUserMessages.length > 0) {
+                    void this.sendUserMessageToSession(message).catch((error) => {
+                        this.deferredUserMessages.unshift(message);
+                        this.updateQueuedMessageStatus();
+                        this.host.addEntry({ id: createId("error"), kind: "error", text: `Queued message failed: ${stringifyUnknown(error)}` });
+                        if (this.host.isRunning())
+                            this.host.render();
+                    });
+                    break;
+                }
+                try {
+                    await this.sendUserMessageToSession(message);
+                }
+                catch (error) {
+                    this.deferredUserMessages.unshift(message);
+                    this.updateQueuedMessageStatus();
+                    this.host.addEntry({ id: createId("error"), kind: "error", text: `Queued message failed: ${stringifyUnknown(error)}` });
+                    break;
+                }
+            }
+        }
+        finally {
+            const shouldRetryFlush = this.deferredUserMessages.length > 0 && Boolean(this.host.runtime()?.session) && !this.host.runtime()?.session.isCompacting;
+            this.flushingDeferredUserMessages = false;
+            if (this.totalQueuedMessageCount() > 0)
+                this.updateQueuedMessageStatus();
+            if (this.host.isRunning())
+                this.host.render();
+            if (shouldRetryFlush) {
+                queueMicrotask(() => {
+                    void this.flushDeferredUserMessages();
+                });
+            }
+        }
+    }
+    queuedMessageCounts() {
+        const session = this.host.runtime()?.session;
+        return {
+            steering: (session?.getSteeringMessages().length ?? 0) + this.deferredUserMessages.length,
+            followUp: session?.getFollowUpMessages().length ?? 0,
+        };
+    }
+    totalQueuedMessageCount() {
+        const { steering, followUp } = this.queuedMessageCounts();
+        return steering + followUp;
+    }
+    updateQueuedMessageStatus() {
+        if (this.totalQueuedMessageCount() === 0)
+            this.host.setSessionStatus(this.host.runtime()?.session);
+    }
+    restoreQueuedMessagesToEditorForAbort() {
+        const session = this.host.runtime()?.session;
+        const sdkQueued = session?.clearQueue() ?? { steering: [], followUp: [] };
+        const deferred = this.deferredUserMessages.splice(0);
+        const restoredTexts = [
+            ...sdkQueued.steering,
+            ...deferred.map((message) => this.restorableSubmittedMessageText(message)),
+            ...sdkQueued.followUp,
+        ]
+            .map((text) => text.trimEnd())
+            .filter((text) => text.trim().length > 0);
+        const images = deferred.flatMap((message) => message.images);
+        const restoredCount = sdkQueued.steering.length + sdkQueued.followUp.length + deferred.length;
+        if (restoredTexts.length > 0 || images.length > 0) {
+            const currentText = this.host.inputText().trimEnd();
+            const combinedText = [...restoredTexts, currentText]
+                .filter((text) => text.trim().length > 0)
+                .join("\n\n");
+            this.host.setInput(combinedText);
+            if (combinedText && images.length > 0)
+                this.host.insertInput("\n");
+            for (const image of images)
+                this.host.attachImage(image.data, image.mimeType);
+        }
+        this.updateQueuedMessageStatus();
+        return restoredCount;
+    }
+    async cancelQueuedMessage(entryId) {
+        const entry = this.findQueuedEntry(entryId);
+        if (!entry)
+            throw new Error("Queued message is no longer available");
+        await this.removeQueuedEntry(entry);
+        this.updateQueuedMessageStatus();
+        this.host.showToast("Queued message cancelled", "success");
+    }
+    async editQueuedMessage(entryId) {
+        const entry = this.findQueuedEntry(entryId);
+        if (!entry)
+            throw new Error("Queued message is no longer available");
+        const removed = await this.removeQueuedEntry(entry);
+        this.host.resetRequestHistoryNavigation();
+        if (typeof removed === "string") {
+            this.host.clearInput();
+            this.host.setInput(removed);
+        }
+        else {
+            this.restoreSubmittedMessageToEditor(removed);
+        }
+        this.updateQueuedMessageStatus();
+        this.host.showToast("Queued message moved to editor", "success");
+    }
+    async sendQueuedMessageImmediately(entryId) {
+        const entry = this.findQueuedEntry(entryId);
+        if (!entry)
+            throw new Error("Queued message is no longer available");
+        const session = this.host.requireRuntime().session;
+        const shouldInterrupt = session.isStreaming || session.isCompacting;
+        const taken = shouldInterrupt
+            ? this.takeQueuedEntryForInterruptedSend(entry, session)
+            : { removed: await this.removeQueuedEntry(entry), sdkMessagesToRestore: undefined };
+        this.updateQueuedMessageStatus();
+        this.host.setStatus("sending queued message");
+        this.host.render();
+        this.immediateSendInProgress = true;
+        try {
+            if (shouldInterrupt)
+                await this.interruptSessionForImmediateSend(session);
+            if (taken.sdkMessagesToRestore) {
+                await this.restoreSdkQueuedMessages(taken.sdkMessagesToRestore);
+                taken.sdkMessagesToRestore = undefined;
+            }
+            const message = typeof taken.removed === "string"
+                ? this.createSubmittedUserMessage(taken.removed, taken.removed, [])
+                : taken.removed;
+            await this.sendUserMessageToSession(message, { streamingBehavior: "steer" });
+            this.host.setSessionStatus(this.host.runtime()?.session);
+            this.host.showToast("Queued message sent", "success");
+        }
+        catch (error) {
+            if (taken.sdkMessagesToRestore) {
+                try {
+                    await this.restoreSdkQueuedMessages(taken.sdkMessagesToRestore);
+                }
+                catch { /* best-effort rollback */ }
+            }
+            await this.requeueRemovedEntry(entry, taken.removed);
+            this.updateQueuedMessageStatus();
+            throw error;
+        }
+        finally {
+            this.immediateSendInProgress = false;
+            if (this.totalQueuedMessageCount() > 0)
+                this.updateQueuedMessageStatus();
+            if (!this.flushingDeferredUserMessages)
+                void this.flushDeferredUserMessages();
+        }
+    }
+    findQueuedEntry(entryId) {
+        const entry = this.host.visibleEntries().find((candidate) => candidate.id === entryId);
+        return entry?.kind === "queued" ? entry : undefined;
+    }
+    shouldDeferUserMessage(session) {
+        return session.isCompacting || (!session.isStreaming && this.promptSubmissionInFlight);
+    }
+    deferUserMessage(message) {
+        this.deferredUserMessages.push(message);
+        this.updateQueuedMessageStatus();
+        this.host.render();
+    }
+    async rewriteSdkQueuedMessages(update) {
+        const session = this.host.requireRuntime().session;
+        const originalSteering = [...session.getSteeringMessages()];
+        const originalFollowUp = [...session.getFollowUpMessages()];
+        const steering = [...originalSteering];
+        const followUp = [...originalFollowUp];
+        const result = update(steering, followUp);
+        session.clearQueue();
+        try {
+            for (const text of steering)
+                await session.steer(text);
+            for (const text of followUp)
+                await session.followUp(text);
+        }
+        catch (error) {
+            session.clearQueue();
+            for (const text of originalSteering) {
+                try {
+                    await session.steer(text);
+                }
+                catch { /* best-effort rollback */ }
+            }
+            for (const text of originalFollowUp) {
+                try {
+                    await session.followUp(text);
+                }
+                catch { /* best-effort rollback */ }
+            }
+            throw error;
+        }
+        return result;
+    }
+    takeQueuedEntryForInterruptedSend(entry, session) {
+        const sdkMessages = {
+            steering: [...session.getSteeringMessages()],
+            followUp: [...session.getFollowUpMessages()],
+        };
+        if (entry.queueSource === "deferred") {
+            const [message] = this.deferredUserMessages.splice(entry.queueIndex, 1);
+            if (!message)
+                throw new Error("Queued message is no longer available");
+            session.clearQueue();
+            return { removed: message, sdkMessagesToRestore: sdkMessages };
+        }
+        const messages = entry.queueSource === "sdk-steering" ? sdkMessages.steering : sdkMessages.followUp;
+        const [removed] = messages.splice(entry.queueIndex, 1);
+        if (removed === undefined)
+            throw new Error("Queued message is no longer available");
+        session.clearQueue();
+        return { removed, sdkMessagesToRestore: sdkMessages };
+    }
+    async restoreSdkQueuedMessages(messages) {
+        const session = this.host.requireRuntime().session;
+        for (const text of messages.steering)
+            await session.steer(text);
+        for (const text of messages.followUp)
+            await session.followUp(text);
+    }
+    async interruptSessionForImmediateSend(session) {
+        if (session.isCompacting) {
+            this.host.setStatus("aborting compaction");
+            session.abortCompaction();
+            this.host.render();
+        }
+        if (session.isStreaming) {
+            this.host.setStatus("aborting current response");
+            this.host.addSessionAbortedEntry();
+            this.host.render();
+            await session.abort();
+        }
+        if (session.isCompacting)
+            await this.waitForCompactionToStop(session);
+        this.host.setSessionStatus(this.host.runtime()?.session);
+        this.host.setSessionActivity(this.sessionActivity(this.host.runtime()?.session));
+    }
+    async waitForCompactionToStop(session) {
+        const startedAt = Date.now();
+        while (session.isCompacting && this.host.runtime()?.session === session) {
+            if (Date.now() - startedAt > 5000)
+                throw new Error("Timed out waiting for compaction to abort");
+            await new Promise((resolve) => {
+                const timer = setTimeout(resolve, 25);
+                timer.unref?.();
+            });
+        }
+    }
+    sessionActivity(session) {
+        return session?.isStreaming || session?.isCompacting ? "running" : "idle";
+    }
+    async removeQueuedEntry(entry) {
+        if (entry.queueSource === "deferred") {
+            const [message] = this.deferredUserMessages.splice(entry.queueIndex, 1);
+            if (!message)
+                throw new Error("Queued message is no longer available");
+            return message;
+        }
+        const removed = await this.rewriteSdkQueuedMessages((steering, followUp) => {
+            const messages = entry.queueSource === "sdk-steering" ? steering : followUp;
+            const [text] = messages.splice(entry.queueIndex, 1);
+            return text;
+        });
+        if (removed === undefined)
+            throw new Error("Queued message is no longer available");
+        return removed;
+    }
+    async requeueRemovedEntry(entry, removed) {
+        if (entry.queueSource === "deferred") {
+            if (typeof removed === "string")
+                return;
+            this.deferredUserMessages.splice(Math.min(entry.queueIndex, this.deferredUserMessages.length), 0, removed);
+            return;
+        }
+        if (typeof removed !== "string")
+            return;
+        await this.rewriteSdkQueuedMessages((steering, followUp) => {
+            const messages = entry.queueSource === "sdk-steering" ? steering : followUp;
+            messages.splice(Math.min(entry.queueIndex, messages.length), 0, removed);
+        });
+    }
+    restoreSubmittedMessageToEditor(message) {
+        const text = this.restorableSubmittedMessageText(message);
+        this.host.clearInput();
+        if (text || message.images.length === 0)
+            this.host.setInput(text || message.displayText);
+        if (text && message.images.length > 0)
+            this.host.insertInput("\n");
+        for (const image of message.images)
+            this.host.attachImage(image.data, image.mimeType);
+    }
+    restorableSubmittedMessageText(message) {
+        return message.images.length > 0
+            ? message.promptText.replace(/\[Image \d+(?:: [^\]]+)?\]\s*/g, "").trimEnd()
+            : message.promptText.trimEnd();
+    }
+}