pi-ui-extend 0.1.32 → 0.1.34

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

@@ -1,19 +1,28 @@
 import { createId } from "../id.js";
 import { stringifyUnknown, submittedUserDisplayText } from "../rendering/message-content.js";
-import { deferredQueuedMessageEntries, queuedMessageEntries } from "./queued-message-entries.js";
+import { autoQueuedMessageEntries, deferredQueuedMessageEntries, queuedMessageEntries } from "./queued-message-entries.js";
 export class AppQueuedMessageController {
     host;
+    autoUserMessages = [];
     deferredUserMessages = [];
-    promptSubmissionInFlight = false;
-    flushingDeferredUserMessages = false;
+    promptSubmissionInFlightSession;
     immediateSendInProgress = false;
     constructor(host) {
         this.host = host;
     }
     reset() {
+        this.autoUserMessages.length = 0;
         this.deferredUserMessages.length = 0;
-        this.promptSubmissionInFlight = false;
-        this.flushingDeferredUserMessages = false;
+        this.promptSubmissionInFlightSession = undefined;
+    }
+    captureAutoUserMessages() {
+        return this.autoUserMessages.map((message) => this.cloneSubmittedUserMessage(message));
+    }
+    restoreAutoUserMessages(messages) {
+        this.autoUserMessages.length = 0;
+        this.autoUserMessages.push(...messages.map((message) => this.cloneSubmittedUserMessage(message)));
+        this.updateQueuedMessageStatus();
+        void this.flushAutoUserMessages();
     }
     captureDeferredUserMessages() {
         return this.deferredUserMessages.map((message) => this.cloneSubmittedUserMessage(message));
@@ -37,8 +46,8 @@ export class AppQueuedMessageController {
             await this.sendUserMessageToSession(message, { streamingBehavior: "steer" });
             return;
         }
-        if (this.shouldDeferUserMessage(session)) {
-            this.deferUserMessage(message);
+        if (this.shouldQueueUserMessageAsSteering(session)) {
+            await this.queueUserMessageAsSteering(message);
             return;
         }
         await this.sendUserMessageToSession(message);
@@ -47,7 +56,7 @@ export class AppQueuedMessageController {
         const session = this.host.requireRuntime().session;
         const markInFlight = !session.isStreaming;
         if (markInFlight)
-            this.promptSubmissionInFlight = true;
+            this.promptSubmissionInFlightSession = session;
         this.host.setSessionActivity("running");
         try {
             const opts = {};
@@ -58,8 +67,8 @@ export class AppQueuedMessageController {
             await session.prompt(message.promptText, Object.keys(opts).length > 0 ? opts : undefined);
         }
         finally {
-            if (markInFlight)
-                this.promptSubmissionInFlight = false;
+            if (markInFlight && this.promptSubmissionInFlightSession === session)
+                this.promptSubmissionInFlightSession = undefined;
             const runtime = this.host.runtime();
             if (runtime) {
                 const activeSession = runtime.session;
@@ -68,47 +77,30 @@ export class AppQueuedMessageController {
             }
             if (this.totalQueuedMessageCount() > 0)
                 this.updateQueuedMessageStatus();
+            void this.flushAutoUserMessages();
         }
     }
-    async flushDeferredUserMessages() {
-        if (this.immediateSendInProgress || this.flushingDeferredUserMessages || this.deferredUserMessages.length === 0)
+    async flushAutoUserMessages() {
+        if (this.immediateSendInProgress || this.autoUserMessages.length === 0)
             return;
         const session = this.host.runtime()?.session;
-        if (!session || session.isCompacting)
+        if (!session || session.isStreaming || session.isCompacting || this.promptSubmissionInFlightSession === session)
             return;
-        if (!session.isStreaming && this.promptSubmissionInFlight)
+        const message = this.autoUserMessages.shift();
+        if (!message)
             return;
-        this.flushingDeferredUserMessages = true;
+        this.notifyAutoUserMessagesChanged();
+        this.updateQueuedMessageStatus();
+        if (this.host.isRunning())
+            this.host.render();
         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.notifyDeferredUserMessagesChanged();
-                this.updateQueuedMessageStatus();
-                try {
-                    await this.sendUserMessageToSession(message);
-                }
-                catch (error) {
-                    this.deferredUserMessages.unshift(message);
-                    this.notifyDeferredUserMessagesChanged();
-                    this.updateQueuedMessageStatus();
-                    this.host.addEntry({ id: createId("error"), kind: "error", text: `Queued message failed: ${stringifyUnknown(error)}` });
-                    break;
-                }
-            }
+            await this.sendUserMessageToSession(message);
         }
-        finally {
-            this.flushingDeferredUserMessages = false;
-            if (this.totalQueuedMessageCount() > 0)
-                this.updateQueuedMessageStatus();
+        catch (error) {
+            this.autoUserMessages.unshift(message);
+            this.notifyAutoUserMessagesChanged();
+            this.updateQueuedMessageStatus();
+            this.host.addEntry({ id: createId("error"), kind: "error", text: `Queued message failed: ${stringifyUnknown(error)}` });
             if (this.host.isRunning())
                 this.host.render();
         }
@@ -116,7 +108,7 @@ export class AppQueuedMessageController {
     queuedMessageCounts() {
         const session = this.host.runtime()?.session;
         return {
-            steering: (session?.getSteeringMessages().length ?? 0) + this.deferredUserMessages.length,
+            steering: (session?.getSteeringMessages().length ?? 0) + this.autoUserMessages.length + this.deferredUserMessages.length,
             followUp: session?.getFollowUpMessages().length ?? 0,
         };
     }
@@ -131,18 +123,20 @@ export class AppQueuedMessageController {
     restoreQueuedMessagesToEditorForAbort() {
         const session = this.host.runtime()?.session;
         const sdkQueued = session?.clearQueue() ?? { steering: [], followUp: [] };
+        const auto = this.autoUserMessages.splice(0);
         const deferred = this.deferredUserMessages.splice(0);
         if (deferred.length > 0)
             this.notifyDeferredUserMessagesChanged();
         const restoredTexts = [
             ...sdkQueued.steering,
+            ...auto.map((message) => this.restorableSubmittedMessageText(message)),
             ...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;
+        const images = [...auto, ...deferred].flatMap((message) => message.images);
+        const restoredCount = sdkQueued.steering.length + sdkQueued.followUp.length + auto.length + deferred.length;
         if (restoredTexts.length > 0 || images.length > 0) {
             const currentText = this.host.inputText().trimEnd();
             const combinedText = [...restoredTexts, currentText]
@@ -234,19 +228,31 @@ export class AppQueuedMessageController {
         return entry?.kind === "queued" ? entry : undefined;
     }
     queuedEntries() {
-        return queuedMessageEntries(this.host.runtime()?.session, this.deferredUserMessages);
+        return queuedMessageEntries(this.host.runtime()?.session, this.autoUserMessages, this.deferredUserMessages);
+    }
+    autoQueuedEntries() {
+        return autoQueuedMessageEntries(this.autoUserMessages);
     }
     deferredQueuedEntries() {
         return deferredQueuedMessageEntries(this.deferredUserMessages);
     }
-    shouldDeferUserMessage(session) {
-        return session.isCompacting || this.promptSubmissionInFlight;
+    shouldQueueUserMessageAsSteering(session) {
+        return session.isCompacting || this.promptSubmissionInFlightSession === session;
+    }
+    async queueUserMessageAsSteering(message) {
+        this.autoUserMessages.push(message);
+        this.notifyAutoUserMessagesChanged();
+        this.updateQueuedMessageStatus();
+        this.host.setSessionStatus(this.host.runtime()?.session);
+        this.host.showToast("Message queued for the next agent turn", "info");
+        this.host.render();
+        void this.flushAutoUserMessages();
     }
     deferUserMessage(message) {
         this.deferredUserMessages.push(message);
         this.notifyDeferredUserMessagesChanged();
         this.updateQueuedMessageStatus();
-        this.host.showToast("Message queued; send it from the queue menu or status button", "info");
+        this.host.showToast("Message paused; send it from the queue menu or status button", "info");
         this.host.render();
     }
     async rewriteSdkQueuedMessages(update) {
@@ -286,12 +292,14 @@ export class AppQueuedMessageController {
             steering: [...session.getSteeringMessages()],
             followUp: [...session.getFollowUpMessages()],
         };
-        if (entry.queueSource === "deferred") {
-            const [message] = this.deferredUserMessages.splice(entry.queueIndex, 1);
+        if (entry.queueSource === "auto" || entry.queueSource === "deferred") {
+            const source = entry.queueSource === "auto" ? this.autoUserMessages : this.deferredUserMessages;
+            const [message] = source.splice(entry.queueIndex, 1);
             if (!message)
                 throw new Error("Queued message is no longer available");
             session.clearQueue();
-            this.notifyDeferredUserMessagesChanged();
+            if (entry.queueSource === "deferred")
+                this.notifyDeferredUserMessagesChanged();
             return { removed: message, sdkMessagesToRestore: sdkMessages };
         }
         const messages = entry.queueSource === "sdk-steering" ? sdkMessages.steering : sdkMessages.followUp;
@@ -340,11 +348,13 @@ export class AppQueuedMessageController {
         return session?.isStreaming || session?.isCompacting ? "running" : "idle";
     }
     async removeQueuedEntry(entry) {
-        if (entry.queueSource === "deferred") {
-            const [message] = this.deferredUserMessages.splice(entry.queueIndex, 1);
+        if (entry.queueSource === "auto" || entry.queueSource === "deferred") {
+            const source = entry.queueSource === "auto" ? this.autoUserMessages : this.deferredUserMessages;
+            const [message] = source.splice(entry.queueIndex, 1);
             if (!message)
                 throw new Error("Queued message is no longer available");
-            this.notifyDeferredUserMessagesChanged();
+            if (entry.queueSource === "deferred")
+                this.notifyDeferredUserMessagesChanged();
             return message;
         }
         const removed = await this.rewriteSdkQueuedMessages((steering, followUp) => {
@@ -357,11 +367,13 @@ export class AppQueuedMessageController {
         return removed;
     }
     async requeueRemovedEntry(entry, removed) {
-        if (entry.queueSource === "deferred") {
+        if (entry.queueSource === "auto" || entry.queueSource === "deferred") {
             if (typeof removed === "string")
                 return;
-            this.deferredUserMessages.splice(Math.min(entry.queueIndex, this.deferredUserMessages.length), 0, removed);
-            this.notifyDeferredUserMessagesChanged();
+            const source = entry.queueSource === "auto" ? this.autoUserMessages : this.deferredUserMessages;
+            source.splice(Math.min(entry.queueIndex, source.length), 0, removed);
+            if (entry.queueSource === "deferred")
+                this.notifyDeferredUserMessagesChanged();
             return;
         }
         if (typeof removed !== "string")
@@ -397,4 +409,7 @@ export class AppQueuedMessageController {
     notifyDeferredUserMessagesChanged() {
         this.host.onDeferredUserMessagesChanged?.();
     }
+    notifyAutoUserMessagesChanged() {
+        this.host.onDeferredUserMessagesChanged?.();
+    }
 }

package/dist/app/session/queued-message-entries.d.ts

@@ -5,4 +5,5 @@ export type QueuedEntry = Extract<Entry, {
 }>;
 export declare function sdkQueuedMessageEntries(session: AgentSession | undefined): QueuedEntry[];
 export declare function deferredQueuedMessageEntries(messages: readonly SubmittedUserMessage[]): QueuedEntry[];
-export declare function queuedMessageEntries(session: AgentSession | undefined, deferredUserMessages: readonly SubmittedUserMessage[]): QueuedEntry[];
+export declare function autoQueuedMessageEntries(messages: readonly SubmittedUserMessage[]): QueuedEntry[];
+export declare function queuedMessageEntries(session: AgentSession | undefined, autoUserMessages: readonly SubmittedUserMessage[], deferredUserMessages: readonly SubmittedUserMessage[]): QueuedEntry[];

package/dist/app/session/queued-message-entries.js

@@ -33,9 +33,20 @@ export function deferredQueuedMessageEntries(messages) {
         queueIndex: index,
     }));
 }
-export function queuedMessageEntries(session, deferredUserMessages) {
+export function autoQueuedMessageEntries(messages) {
+    return messages.map((message, index) => ({
+        id: `${message.id}-auto-${index}`,
+        kind: "queued",
+        mode: "steering",
+        text: message.displayText,
+        queueSource: "auto",
+        queueIndex: index,
+    }));
+}
+export function queuedMessageEntries(session, autoUserMessages, deferredUserMessages) {
     return [
         ...sdkQueuedMessageEntries(session),
+        ...autoQueuedMessageEntries(autoUserMessages),
         ...deferredQueuedMessageEntries(deferredUserMessages),
     ];
 }

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

@@ -5,6 +5,7 @@ import type { Entry, SessionActivity } from "../types.js";
 import type { WorkspaceMutation, WorkspaceMutationPreparation } from "../workspace/workspace-undo.js";
 export type AppSessionEventControllerState = {
     toolEntryIdsByCallId: Map<string, string>;
+    pendingToolCallIdsByContentIndex: Map<number, string>;
     toolMutationPreparationsByCallId: Map<string, {
         userEntryId: string;
         args: unknown;
@@ -13,9 +14,16 @@ export type AppSessionEventControllerState = {
     olderHistoryLoader: SessionHistoryOlderLoader | undefined;
     currentUserEntryId: string | undefined;
     currentAssistantEntryId: string | undefined;
+    currentAssistantTextBlockEntryId: string | undefined;
+    currentAssistantTextBlockStartLength: number | undefined;
+    currentAssistantTextBlockContentIndex: number | undefined;
+    assistantTextBlocksByContentIndex: Map<number, string>;
     currentThinkingEntryId: string | undefined;
+    assistantMessageClosed: boolean;
     assistantTextBuffer: string;
     entryRenderVersions: Map<string, number>;
+    historyEntries: Entry[];
+    historyWindowStart: number;
 };
 export type AppSessionEventControllerHost = {
     readonly entries: Entry[];
@@ -31,6 +39,7 @@ export type AppSessionEventControllerHost = {
     setSessionStatus(session: AgentSessionRuntime["session"] | undefined): void;
     setSessionActivity(activity: SessionActivity): void;
     updateQueuedMessageStatus(): void;
+    flushAutoUserMessages(): void;
     prepareWorkspaceMutation(toolName: string, args: unknown): WorkspaceMutationPreparation | undefined;
     recordWorkspaceMutationForUserEntry(entryId: string, mutation: WorkspaceMutation): void;
     workspaceMutationFromToolExecution(input: {
@@ -52,11 +61,20 @@ export declare class AppSessionEventController {
     private readonly host;
     readonly entryRenderVersions: Map<string, number>;
     private readonly toolEntryIdsByCallId;
+    private readonly pendingToolCallIdsByContentIndex;
     private readonly toolMutationPreparationsByCallId;
     private olderHistoryLoader;
     private currentUserEntryId;
     private currentAssistantEntryId;
+    private currentAssistantTextBlockEntryId;
+    private currentAssistantTextBlockStartLength;
+    private currentAssistantTextBlockContentIndex;
+    private readonly assistantTextBlocksByContentIndex;
+    private readonly finalizedToolCallContentIndexes;
+    private historyEntries;
+    private historyWindowStart;
     private currentThinkingEntryId;
+    private assistantMessageClosed;
     private assistantTextBuffer;
     constructor(host: AppSessionEventControllerHost);
     snapshotState(): AppSessionEventControllerState;
@@ -71,6 +89,11 @@ export declare class AppSessionEventController {
     hasOlderSessionHistory(): boolean;
     isLoadingOlderSessionHistory(): boolean;
     loadOlderSessionHistory(options?: LoadOlderSessionHistoryOptions): Promise<boolean>;
+    hasNewerSessionHistory(): boolean;
+    isLoadingNewerSessionHistory(): boolean;
+    loadNewerSessionHistory(options?: {
+        render?: boolean;
+    }): Promise<boolean>;
     handleSessionEvent(event: AgentSessionEvent): void;
     addCustomMessageEntry(message: Record<string, unknown>): void;
     findEntry(id: string): Entry | undefined;
@@ -79,22 +102,40 @@ export declare class AppSessionEventController {
     }> | undefined;
     touchEntry(entry: Entry): void;
     addEntry(entry: Entry): void;
-    private prependEntries;
+    prependEntries(entries: readonly Entry[]): void;
+    private shiftHistoryWindow;
+    private setHistoryWindowStart;
+    private historyWindowSize;
+    private maxHistoryWindowStart;
+    private registerEntry;
     private pruneHistoryWindow;
     private measuredLineCountForEntries;
     private forgetEntry;
+    private removeToolEntryOrphan;
     addSessionAbortedEntry(): void;
+    private finalizeAbandonedToolEntries;
     private handleMessageStart;
     private handleMessageEnd;
     private prepareToolWorkspaceMutation;
+    private finalizeToolResultMessage;
     private recordToolWorkspaceMutation;
     private handleMessageUpdate;
+    private handleToolCallStreamUpdate;
     private appendAssistantText;
     private flushAssistantTextBuffer;
+    private reconcileAssistantTextBlock;
+    private ensureAssistantTextBlockStarted;
+    private finishCurrentAssistantTextBlock;
+    private hasVisibleTextBeforeCurrentAssistantBlock;
     private drainAssistantTextBuffer;
     private hasVisibleAssistantText;
+    private hasStartedCurrentAssistantText;
     private appendThinkingText;
     private finishCurrentThinkingEntry;
+    private reconcileThinkingText;
+    private currentThinkingLevel;
+    private renderAssistantToolCallsFromMessage;
+    private upsertPendingToolCall;
     private upsertToolEntry;
     private clearCurrentAssistantState;
 }