pi-ui-extend 1.0.41 → 1.0.45

package/dist/app/popup/menu-items-controller.js

@@ -37,8 +37,11 @@ export class AppMenuItemsController {
     modelRef(model) {
         return `${model.provider}/${model.id}`;
     }
-    getModelMenuItems(query) {
-        const models = [...this.getModelMenuModels()].sort((left, right) => {
+    getModelMenuItems(query, includeHidden = false) {
+        const visibleModels = this.host.visibleModels();
+        const models = [...this.getModelMenuModels()]
+            .filter((model) => includeHidden || this.isVisibleModel(model, visibleModels))
+            .sort((left, right) => {
             const leftCurrent = this.isCurrentModel(left);
             const rightCurrent = this.isCurrentModel(right);
             if (leftCurrent && !rightCurrent)
@@ -51,8 +54,9 @@ export class AppMenuItemsController {
         const items = models.map((model) => {
             const ref = this.modelRef(model);
             const current = this.isCurrentModel(model);
+            const visible = current || visibleModels === undefined || visibleModels.includes(ref);
             return {
-                value: { model, ref, current },
+                value: { model, ref, current, visible },
                 label: ref,
                 aliases: [model.id, model.name, model.provider],
                 keywords: [model.name, `${model.provider} ${model.id}`],
@@ -67,7 +71,7 @@ export class AppMenuItemsController {
     }
     getThinkingMenuItems(query) {
         const session = this.host.runtime()?.session;
-        const currentLevel = session?.thinkingLevel ?? "off";
+        const currentLevel = session?.thinkingLevel ?? this.host.draftModelState?.()?.thinkingLevel ?? "off";
         const levels = session ? normalizeAvailableThinkingLevels(session.getAvailableThinkingLevels()) : [...THINKING_LEVELS];
         const items = levels.map((level) => ({
             value: { level, current: level === currentLevel },
@@ -134,29 +138,38 @@ export class AppMenuItemsController {
             { value: "send-now", label: "Send immediately", description: "Send now and keep the rest queued" },
         ];
     }
-    getResumeMenuItems(query, limit) {
+    getResumeMenuItems(query, limit, options = {}) {
         const sessionFile = this.host.runtime()?.session.sessionFile;
-        const currentSessionFile = sessionFile ? resolve(sessionFile) : undefined;
-        const loader = this.getResumeMenuItemsLoader(currentSessionFile, query);
+        const currentSessionFile = options.draft ? undefined : sessionFile ? resolve(sessionFile) : undefined;
+        const excludedSessionPaths = options.draft
+            ? this.host.getOpenSessionPaths?.().map((path) => resolve(path)) ?? []
+            : [];
+        const excluded = new Set(excludedSessionPaths);
+        const sessions = excluded.size === 0
+            ? this.host.getResumeSessions()
+            : this.host.getResumeSessions().filter((session) => !excluded.has(resolve(session.path)));
+        const loader = this.getResumeMenuItemsLoader(sessions, currentSessionFile, query, [...excluded].sort().join("\0"));
         return [
-            { value: { kind: "new" }, label: "new", description: "Create a new session" },
+            ...(options.draft
+                ? [{ value: { kind: "new" }, label: "New session", description: "Start typing in the composer" }]
+                : [{ value: { kind: "new" }, label: "new", description: "Create a new session" }]),
             ...loader.items(limit).map((item) => ({
                 ...item,
                 value: { kind: "session", session: item.value },
             })),
         ];
     }
-    getResumeMenuItemsLoader(currentSessionFile, query) {
-        const sessions = this.host.getResumeSessions();
+    getResumeMenuItemsLoader(sessions, currentSessionFile, query, excludedSessionPathsKey) {
         const cache = this.resumeMenuLoaderCache;
         if (cache &&
             cache.sessions === sessions &&
             cache.currentSessionFile === currentSessionFile &&
-            cache.query === query) {
+            cache.query === query &&
+            cache.excludedSessionPathsKey === excludedSessionPathsKey) {
             return cache.loader;
         }
         const loader = createSessionInfoMenuItemsLoader(sessions, currentSessionFile, query);
-        this.resumeMenuLoaderCache = { sessions, currentSessionFile, query, loader };
+        this.resumeMenuLoaderCache = { sessions, currentSessionFile, query, excludedSessionPathsKey, loader };
         return loader;
     }
     getAllSlashCommands() {
@@ -164,21 +177,24 @@ export class AppMenuItemsController {
     }
     isCurrentModel(model) {
         const current = this.host.runtime()?.session.model;
-        return current?.provider === model.provider && current.id === model.id;
+        if (current)
+            return current.provider === model.provider && current.id === model.id;
+        return this.host.draftModelState?.()?.modelRef === this.modelRef(model);
+    }
+    isVisibleModel(model, visibleModels) {
+        return this.isCurrentModel(model) || visibleModels === undefined || visibleModels.includes(this.modelRef(model));
     }
     getModelMenuModels() {
         const runtime = this.host.runtime();
         if (!runtime)
-            return [];
-        const { session } = runtime;
+            return [...(this.host.draftModelState?.()?.models ?? [])];
         const modelRuntime = runtime.services.modelRuntime;
-        if (!session.scopedModels.length) {
-            return [...modelRuntime.getAvailableSnapshot()];
+        const models = [...modelRuntime.getAvailableSnapshot()];
+        const current = runtime.session.model;
+        if (current && !models.some((model) => model.provider === current.provider && model.id === current.id)) {
+            models.push(current);
         }
-        return session.scopedModels.map((scoped) => {
-            const refreshed = modelRuntime.getModel(scoped.model.provider, scoped.model.id);
-            return (refreshed ?? scoped.model);
-        });
+        return models;
     }
     thinkingLevelDescription(level, _availableLevels) {
         switch (level) {

package/dist/app/popup/popup-action-controller.d.ts

@@ -3,10 +3,14 @@ import type { AppCommandController } from "../commands/command-controller.js";
 import type { AppMenuItemsController } from "./menu-items-controller.js";
 import type { AppPopupMenuController } from "./popup-menu-controller.js";
 import type { AppQueuedMessageController } from "../session/queued-message-controller.js";
-import type { Entry, SlashCommand, UserMessageJumpMenuValue } from "../types.js";
+import type { Entry, SessionModel, SlashCommand, ThinkingLevel, UserMessageJumpMenuValue } from "../types.js";
 import type { AppWorkspaceActionsController } from "../workspace/workspace-actions-controller.js";
 export type AppPopupActionControllerHost = {
     runtime(): AgentSessionRuntime | undefined;
+    inputScopeKey?(): string | undefined;
+    isDraftTabActive?(): boolean;
+    materializeDraftSession?(): Promise<AgentSessionRuntime | undefined>;
+    selectDraftModel?(model: SessionModel, thinkingLevel: ThinkingLevel): void;
     awaitCurrentSessionExtensions(runtime?: AgentSessionRuntime): Promise<void>;
     getBuiltinSlashCommands(): readonly SlashCommand[];
     isRunning(): boolean;
@@ -15,8 +19,12 @@ export type AppPopupActionControllerHost = {
     setStatus(status: string): void;
     setSessionStatus(session: AgentSession | undefined): void;
     showToast(message: string, kind: "success" | "error" | "warning" | "info"): void;
+    visibleModels(): readonly string[] | undefined;
+    saveVisibleModels(modelRefs: readonly string[]): readonly string[];
+    saveThinkingLevelForModel(modelRef: string, thinkingLevel: ThinkingLevel): void;
     render(): void;
     afterSessionReplacement(message?: string): void;
+    openSessionInActiveDraftTab?(sessionPath: string): Promise<boolean>;
     scrollToConversationEntry(entryId: string): boolean;
     scrollToUserMessageJumpTarget(target: UserMessageJumpMenuValue): Promise<boolean>;
 };
@@ -32,7 +40,9 @@ export declare class AppPopupActionController {
     submitSlashCommand(text: string): Promise<void>;
     private submitSelectedSlashCommand;
     private submitSelectedModel;
-    private submitSelectedThinking;
+    private persistThinkingPreference;
+    private toggleSelectedModelVisibility;
+    clearVisibleModels(): boolean;
     private submitSelectedUserMessageAction;
     private submitSelectedUserMessageJump;
     private submitSelectedQueueMessageAction;

package/dist/app/popup/popup-action-controller.js

@@ -29,8 +29,6 @@ export class AppPopupActionController {
             return await this.submitSelectedResume();
         if (active === "model")
             return await this.submitSelectedModel();
-        if (active === "thinking")
-            return await this.submitSelectedThinking();
         if (active === "sdk-menu")
             return this.popupMenus.submitSelectedSdkMenu();
         if (active === "slash")
@@ -38,7 +36,7 @@ export class AppPopupActionController {
         return false;
     }
     async submitSlashCommand(text) {
-        const scope = this.captureScope();
+        let scope = this.captureScope();
         const parsed = this.menuItems.parseSlashInput(text);
         if (!parsed)
             return;
@@ -61,6 +59,12 @@ export class AppPopupActionController {
             this.host.render();
             return;
         }
+        if (command.kind === "resource" && !scope.runtime && this.host.isDraftTabActive?.()) {
+            const runtime = await this.host.materializeDraftSession?.();
+            if (!runtime || (this.host.inputScopeKey && this.host.inputScopeKey() !== scope.inputScopeKey))
+                return;
+            scope = this.captureScope();
+        }
         this.host.setInput("");
         if (!command.suppressCommandEcho) {
             this.host.addEntry({ id: createId("system"), kind: "system", text: `command: ${this.formatSlashCommandLine(command.name, parsed.arguments)}` });
@@ -100,53 +104,91 @@ export class AppPopupActionController {
         return true;
     }
     async submitSelectedModel() {
+        if (this.popupMenus.modelVisibilityModeActive())
+            return this.toggleSelectedModelVisibility();
         const scope = this.captureScope();
-        const selected = this.popupMenus.selectedModel();
+        const selected = this.popupMenus.selectedModelThinking();
         if (!selected)
             return false;
         this.popupMenus.closeModelSelection();
+        if (!scope.runtime && this.host.isDraftTabActive?.()) {
+            this.host.selectDraftModel?.(selected.value.model, selected.thinkingLevel);
+            this.persistThinkingPreference(selected.value.ref, selected.thinkingLevel);
+            this.host.render();
+            return true;
+        }
         if (!selected.direct) {
             this.host.setInput("");
-            this.host.addEntry({ id: createId("system"), kind: "system", text: `command: /model ${selected.value.ref}` });
+            this.host.addEntry({
+                id: createId("system"),
+                kind: "system",
+                text: `command: /model ${selected.value.ref}:${selected.thinkingLevel}`,
+            });
         }
         this.host.render();
         try {
-            await this.commandController.runModelCommand(selected.value.model);
+            await this.commandController.runModelThinkingCommand(selected.value.model, selected.thinkingLevel);
+            this.persistThinkingPreference(selected.value.ref, selected.thinkingLevel);
         }
         catch (error) {
             if (!this.isScopeActive(scope))
                 return true;
             this.host.addEntry({ id: createId("error"), kind: "error", text: stringifyUnknown(error) });
-            this.host.showToast("/model failed", "error");
+            this.host.showToast("Model selection failed", "error");
             this.host.setSessionStatus(this.host.runtime()?.session);
         }
         if (this.isScopeActive(scope))
             this.host.render();
         return true;
     }
-    async submitSelectedThinking() {
-        const scope = this.captureScope();
-        const selected = this.popupMenus.selectedThinking();
+    persistThinkingPreference(modelRef, thinkingLevel) {
+        try {
+            this.host.saveThinkingLevelForModel(modelRef, thinkingLevel);
+        }
+        catch (error) {
+            this.host.showToast(`Model changed, but thinking preference could not be saved: ${stringifyUnknown(error)}`, "warning");
+        }
+    }
+    toggleSelectedModelVisibility() {
+        const selected = this.popupMenus.selectedModel();
         if (!selected)
             return false;
-        this.popupMenus.closeThinkingSelection();
-        if (!selected.direct) {
-            this.host.setInput("");
-            this.host.addEntry({ id: createId("system"), kind: "system", text: `command: /thinking ${selected.value.level}` });
+        if (selected.value.current) {
+            this.host.showToast("The current model must remain visible", "warning");
+            return true;
+        }
+        const allAvailableRefs = this.menuItems.getModelMenuItems("", true).map((item) => item.value.ref);
+        const configured = this.host.visibleModels();
+        const visible = new Set(configured === undefined ? allAvailableRefs : configured);
+        const wasVisible = visible.has(selected.value.ref);
+        if (wasVisible)
+            visible.delete(selected.value.ref);
+        else
+            visible.add(selected.value.ref);
+        const currentModel = this.host.runtime()?.session.model;
+        if (currentModel)
+            visible.add(this.menuItems.modelRef(currentModel));
+        try {
+            this.host.saveVisibleModels([...visible]);
+            this.host.showToast(`${selected.value.ref} ${wasVisible ? "hidden from" : "shown in"} model pickers`, "info");
+        }
+        catch (error) {
+            this.host.showToast(`Failed to save model visibility: ${stringifyUnknown(error)}`, "error");
         }
         this.host.render();
+        return true;
+    }
+    clearVisibleModels() {
+        if (!this.popupMenus.modelVisibilityModeActive())
+            return false;
         try {
-            await this.commandController.runThinkingCommand(selected.value.level);
+            this.host.saveVisibleModels([]);
+            this.host.showToast("Cleared model picker visibility", "info");
         }
         catch (error) {
-            if (!this.isScopeActive(scope))
-                return true;
-            this.host.addEntry({ id: createId("error"), kind: "error", text: stringifyUnknown(error) });
-            this.host.showToast("/thinking failed", "error");
-            this.host.setSessionStatus(this.host.runtime()?.session);
+            this.host.showToast(`Failed to clear model visibility: ${stringifyUnknown(error)}`, "error");
         }
-        if (this.isScopeActive(scope))
-            this.host.render();
+        this.host.render();
         return true;
     }
     async submitSelectedUserMessageAction() {
@@ -231,10 +273,18 @@ export class AppPopupActionController {
         const selected = this.popupMenus.selectedResume();
         if (!selected)
             return false;
+        const draftSelector = this.popupMenus.draftSessionSelectorActive();
         this.popupMenus.setDirectMenu(undefined);
         this.popupMenus.setDirectPreserveStatus(false);
         this.popupMenus.setDirectQuery("");
         this.popupMenus.closeResumeMenu();
+        this.popupMenus.setResumeMenuMode("resume");
+        if (draftSelector) {
+            if (selected.kind !== "session")
+                return true;
+            await this.host.openSessionInActiveDraftTab?.(selected.session.path);
+            return true;
+        }
         if (selected.kind === "new") {
             await this.submitSlashCommand("/new");
             return true;
@@ -283,10 +333,13 @@ export class AppPopupActionController {
     }
     captureScope() {
         const runtime = this.host.runtime();
-        return { runtime, session: runtime?.session };
+        return { runtime, session: runtime?.session, inputScopeKey: this.host.inputScopeKey?.() };
     }
     isScopeActive(scope) {
-        return this.host.isRunning() && this.host.runtime() === scope.runtime && scope.runtime?.session === scope.session;
+        return this.host.isRunning()
+            && this.host.runtime() === scope.runtime
+            && scope.runtime?.session === scope.session
+            && (this.host.inputScopeKey === undefined || this.host.inputScopeKey() === scope.inputScopeKey);
     }
     isRuntimeActive(runtime) {
         return this.host.isRunning() && this.host.runtime() === runtime;

package/dist/app/popup/popup-menu-controller.d.ts

@@ -1,9 +1,8 @@
 import { PopupMenu, type PopupMenuItem } from "../../ui.js";
-import type { ActivePopupMenu, Entry, ModelMenuValue, ParsedSlashInput, PixMenuController, PixMenuItem, PixMenuOptions, PixMenuSelectOptions, PopupMenuPlacement, QueueMessageMenuValue, RenderedLine, ResumeMenuValue, SlashCommand, ThinkingMenuValue, UserMessageJumpMenuValue, UserMessageMenuValue } from "../types.js";
+import type { ActivePopupMenu, Entry, ModelMenuValue, ModelThinkingMenuState, ParsedSlashInput, PixMenuController, PixMenuItem, PixMenuOptions, PixMenuSelectOptions, PopupMenuPlacement, QueueMessageMenuValue, RenderedLine, ResumeMenuValue, SlashCommand, ThinkingLevel, ThinkingMenuValue, UserMessageJumpMenuValue, UserMessageMenuValue } from "../types.js";
 import type { AgentSession, SessionInfo } from "@earendil-works/pi-coding-agent";
 type SlashCommandMenuValue = SlashCommand;
 type ModelPopupMenuValue = ModelMenuValue;
-type ThinkingPopupMenuValue = ThinkingMenuValue;
 type ResumePopupMenuValue = ResumeMenuValue;
 type UserMessagePopupMenuValue = UserMessageMenuValue;
 type UserMessageJumpPopupMenuValue = UserMessageJumpMenuValue;
@@ -17,12 +16,12 @@ type PopupMenuRendererPort = {
     overlayPlainText(line: RenderedLine, width: number): string;
     renderUserMessageMenu(width: number, menu: PopupMenu<UserMessagePopupMenuValue>): RenderedLine[];
     renderSlashCommandMenu(width: number, menu: PopupMenu<SlashCommandMenuValue>): RenderedLine[];
-    renderModelMenu(width: number, menu: PopupMenu<ModelPopupMenuValue>): RenderedLine[];
-    renderThinkingMenu(width: number, menu: PopupMenu<ThinkingPopupMenuValue>): RenderedLine[];
+    renderModelMenu(width: number, menu: PopupMenu<ModelPopupMenuValue>, state: ModelThinkingMenuState): RenderedLine[];
     renderResumeMenu(width: number, menu: PopupMenu<ResumePopupMenuValue>, state: {
         directQuery: string;
         allSessionsLoaded: boolean;
         loadedSessionCount: number;
+        draft: boolean;
     }): RenderedLine[];
     renderUserMessageJumpMenu(width: number, menu: PopupMenu<UserMessageJumpPopupMenuValue>, directQuery: string): RenderedLine[];
     renderQueueMessageMenu(width: number, menu: PopupMenu<QueueMessagePopupMenuValue>): RenderedLine[];
@@ -34,6 +33,8 @@ export type DirectPopupMenu = Exclude<ActivePopupMenu, "slash">;
 export type AppPopupMenuControllerHost = {
     readonly entries: readonly Entry[];
     readonly session: AgentSession | undefined;
+    currentThinkingLevel?(): ThinkingLevel | undefined;
+    rememberedThinkingLevel?(modelRef: string): ThinkingLevel | undefined;
     readonly resumeLoading: boolean;
     readonly resumeSessionCount: number;
     isRunning(): boolean;
@@ -41,9 +42,11 @@ export type AppPopupMenuControllerHost = {
     setInput(value: string): void;
     parseSlashInput(text: string): ParsedSlashInput | undefined;
     getSlashCommandMenuItems(query: string): PopupMenuItem<SlashCommand>[];
-    getModelMenuItems(query: string): PopupMenuItem<ModelMenuValue>[];
+    getModelMenuItems(query: string, includeHidden?: boolean): PopupMenuItem<ModelMenuValue>[];
     getThinkingMenuItems(query: string): PopupMenuItem<ThinkingMenuValue>[];
-    getResumeMenuItems(query: string, limit?: number): PopupMenuItem<ResumeMenuValue>[];
+    getResumeMenuItems(query: string, limit?: number, options?: {
+        draft?: boolean;
+    }): PopupMenuItem<ResumeMenuValue>[];
     getUserMessageMenuItems(): PopupMenuItem<UserMessageMenuValue>[];
     getUserMessageJumpMenuItems(query: string): PopupMenuItem<UserMessageJumpMenuValue>[];
     getQueueMessageMenuItems(): PopupMenuItem<QueueMessageMenuValue>[];
@@ -59,7 +62,6 @@ export declare class AppPopupMenuController {
     readonly menuController: PixMenuController;
     private readonly slashCommandMenu;
     private readonly modelMenu;
-    private readonly thinkingMenu;
     private readonly resumeMenu;
     private readonly userMessageMenu;
     private readonly userMessageJumpMenu;
@@ -70,8 +72,13 @@ export declare class AppPopupMenuController {
     private dismissedSlashCommandMenuInput;
     private modelMenuQuery;
     private dismissedModelMenuInput;
-    private thinkingMenuQuery;
+    private modelThinkingInputQuery;
     private dismissedThinkingMenuInput;
+    private modelThinkingLevel;
+    private modelThinkingSelectedRef;
+    private readonly stagedThinkingByModel;
+    private modelThinkingSource;
+    private modelVisibilityMode;
     private directPopupMenu;
     private directPopupMenuPreserveStatus;
     private directPopupMenuPlacement;
@@ -79,11 +86,15 @@ export declare class AppPopupMenuController {
     private resumeMenuQuery;
     private resumeMenuSessionLimit;
     private resumeMenuAllSessionsLoaded;
+    private resumeMenuMode;
     private activeUserMessageEntryId;
     private activeQueuedMessageEntryId;
     constructor(host: AppPopupMenuControllerHost, renderer: PopupMenuRendererPort);
     get directMenu(): DirectPopupMenu | undefined;
     get directQuery(): string;
+    draftSessionSelectorActive(): boolean;
+    closeDraftSessionSelectorForTabLifecycle(): void;
+    setResumeMenuMode(mode: "resume" | "draft"): void;
     setDirectMenu(menu: DirectPopupMenu | undefined): void;
     setDirectPreserveStatus(preserveStatus: boolean): void;
     setDirectQuery(query: string): void;
@@ -96,7 +107,11 @@ export declare class AppPopupMenuController {
     }): void;
     getActivePopupMenu(active: ActivePopupMenu): PopupMenu<unknown>;
     moveActivePopupMenuSelection(delta: number): boolean;
+    moveActiveModelThinkingLevel(delta: number): boolean;
+    toggleModelVisibilityMode(): boolean;
+    modelVisibilityModeActive(): boolean;
     scrollActivePopupMenu(delta: number): boolean;
+    selectActivePopupMenuIndex(index: number): ActivePopupMenu | undefined;
     handleDirectPopupInput(char: string): boolean;
     openDirectPopupMenu(menu: DirectPopupMenu, options?: {
         preserveStatus?: boolean;
@@ -112,21 +127,21 @@ export declare class AppPopupMenuController {
     closeQueueMessageMenu(): void;
     resetConversationMenuState(): void;
     closeModelSelection(): void;
-    closeThinkingSelection(): void;
     closeSlashCommandSelection(): void;
     closeMenusForTabSwitch(): void;
     cancelActivePopupMenu(): void;
     autocompleteSlashCommand(): void;
     autocompleteModel(): boolean;
-    autocompleteThinking(): boolean;
     selectedSlashCommand(): SlashCommand | undefined;
     selectedModel(): {
         value: ModelMenuValue;
         direct: boolean;
     } | undefined;
-    selectedThinking(): {
-        value: ThinkingMenuValue;
+    selectedModelThinking(): {
+        value: ModelMenuValue;
+        thinkingLevel: ThinkingLevel;
         direct: boolean;
+        source: "model" | "thinking";
     } | undefined;
     selectedResume(): ResumeMenuValue | undefined;
     selectedUserMessageAction(): {
@@ -164,7 +179,14 @@ export declare class AppPopupMenuController {
     private updateResumeMenuLoadedState;
     private resumeMenuLoadedSessionCount;
     private syncModelMenu;
-    private syncThinkingMenu;
+    private modelThinkingQuery;
+    private stageThinkingFromQuery;
+    private modelThinkingMenuState;
+    private syncModelThinkingToSelectedModel;
+    private rememberStagedThinking;
+    private selectedModelThinkingLevels;
+    private clampThinkingLevel;
+    private resetModelThinkingState;
     private syncResumeMenu;
     private syncUserMessageMenu;
     private syncUserMessageJumpMenu;
@@ -189,4 +211,4 @@ export type UserMessageJumpSourceItem = {
 };
 export declare function buildUserMessageJumpItems(entries: readonly Entry[] | readonly UserMessageJumpSourceItem[]): PopupMenuItem<UserMessageJumpMenuValue>[];
 export declare function filterUserMessageJumpItems(items: readonly PopupMenuItem<UserMessageJumpMenuValue>[], query: string): PopupMenuItem<UserMessageJumpMenuValue>[];
-export type { ModelPopupMenuValue, QueueMessagePopupMenuValue, ResumePopupMenuValue, SlashCommandMenuValue, ThinkingPopupMenuValue, UserMessageJumpPopupMenuValue, UserMessagePopupMenuValue, };
+export type { ModelPopupMenuValue, QueueMessagePopupMenuValue, ResumePopupMenuValue, SlashCommandMenuValue, UserMessageJumpPopupMenuValue, UserMessagePopupMenuValue, };