pi-ui-extend 1.0.41 → 1.0.45

package/dist/app/commands/command-navigation-actions.js

@@ -277,14 +277,15 @@ export class NavigationCommandActions {
     async runResumeCommand(queryOrOptions = "") {
         const preserveStatus = typeof queryOrOptions === "object" && queryOrOptions.preserveStatus === true;
         const placement = typeof queryOrOptions === "object" ? queryOrOptions.placement : undefined;
+        const draft = typeof queryOrOptions === "object" && queryOrOptions.draft === true;
         const initialQuery = typeof queryOrOptions === "string" ? queryOrOptions : "";
-        const runtime = preserveStatus ? this.host.runtime() : getIdleRuntime(this.host, "resume");
-        if (!runtime) {
+        const runtime = draft ? this.host.runtime() : preserveStatus ? this.host.runtime() : getIdleRuntime(this.host, "resume");
+        if (!runtime && !draft) {
             if (!preserveStatus)
                 this.host.render();
             return;
         }
-        if (runtime.session.isStreaming) {
+        if (runtime?.session.isStreaming) {
             if (!preserveStatus) {
                 this.host.toast.warning("/resume is unavailable while the agent is running");
                 this.host.render();
@@ -292,6 +293,12 @@ export class NavigationCommandActions {
             return;
         }
         if (this.host.getResumeLoading()) {
+            if (draft) {
+                this.host.setResumeMenuMode?.("draft");
+                this.host.openDirectPopupMenu("resume", { preserveStatus: true, ...(placement === undefined ? {} : { placement }) });
+                this.host.setDirectPopupMenuQuery(initialQuery);
+                this.host.openResumeMenuWithQuery(initialQuery);
+            }
             if (!preserveStatus)
                 this.host.setStatus("loading sessions…");
             this.host.render();
@@ -300,6 +307,7 @@ export class NavigationCommandActions {
         this.host.setResumeLoading(true);
         if (!preserveStatus)
             this.host.setStatus("loading sessions…");
+        this.host.setResumeMenuMode?.(draft ? "draft" : "resume");
         this.host.openDirectPopupMenu("resume", { preserveStatus, ...(placement === undefined ? {} : { placement }) });
         this.host.setDirectPopupMenuQuery(initialQuery);
         if (this.host.getResumeSessions().length > 0) {
@@ -344,6 +352,11 @@ export class NavigationCommandActions {
                 this.host.setSessionStatus(options.scope.session);
             this.host.render();
         }
+        finally {
+            if (options.loadId === this.resumeLoadId && !isCommandScopeActive(this.host, options.scope)) {
+                this.host.setResumeLoading(false);
+            }
+        }
     }
     formatSessionTree(runtime) {
         const tree = runtime.session.sessionManager.getTree();

package/dist/app/commands/command-registry.d.ts

@@ -10,6 +10,8 @@ export type CommandRegistryActions = {
     runThinkingSlashCommand(argumentsText: string): Promise<void>;
     runDefaultThinkingSlashCommand(argumentsText: string): Promise<void>;
     runEnhanceCommand(): Promise<void>;
+    runCodeReviewCommand(): Promise<void>;
+    runCommitMessageCommand(): Promise<void>;
     runExportCommand(argumentsText: string): Promise<void>;
     runImportCommand(argumentsText: string): Promise<void>;
     runShareCommand(): Promise<void>;

package/dist/app/commands/command-registry.js

@@ -71,6 +71,20 @@ export function createSlashCommands(actions, host) {
             keywords: ["prompt", "rewrite", "improve", "kilocode"],
             run: () => actions.runEnhanceCommand(),
         },
+        {
+            name: "code-review",
+            description: "Review staged, unstaged, and untracked Git changes",
+            kind: "builtin",
+            keywords: ["git", "review", "diff", "changes"],
+            run: () => actions.runCodeReviewCommand(),
+        },
+        {
+            name: "commit-message",
+            description: "Generate a message for staged changes and commit after confirmation",
+            kind: "builtin",
+            keywords: ["git", "commit", "message", "staged"],
+            run: () => actions.runCommitMessageCommand(),
+        },
         {
             name: "export",
             description: "Export session (HTML default, or .jsonl path)",
@@ -217,7 +231,7 @@ export function createSlashCommands(actions, host) {
         },
         {
             name: "reload",
-            description: "Reload keybindings, extensions, skills, prompts, and themes",
+            description: "Reload resources and show model-available skills, tools, and agents",
             kind: "builtin",
             keywords: ["restart", "refresh", "resources", "extensions", "skills", "prompts"],
             run: () => actions.runReloadCommand(),

package/dist/app/commands/command-session-actions.js

@@ -11,6 +11,7 @@ import { copyTextToClipboard } from "../screen/clipboard.js";
 import { formatAccountUsageReport, queryAccountUsageReport } from "../model/model-usage-status.js";
 import { checkGlobalPiInstall, checkPixUpdate, formatGlobalPiCheck, formatPixUpdateCheck, parsePixUpdateArgs, pixUpdateUsage, } from "../cli/update.js";
 import { createStartupInfoMessage } from "../cli/startup-info.js";
+import { createReloadContextInventory, formatReloadContextInventory } from "./reload-context-inventory.js";
 import { getCompleteSessionStats } from "../session/session-stats.js";
 import { loadSessionTitleConfig } from "../../bundled-extensions/session-title/config.js";
 import { fallbackSessionTitleFromInput, firstUserMessageText, generateSessionTitleWithRuntime, sessionTitleModelRefs, } from "../../bundled-extensions/session-title/title-generation.js";
@@ -309,7 +310,8 @@ export class SessionCommandActions {
             if (!isCommandScopeActive(this.host, scope))
                 return;
             this.host.setSessionStatus(runtime.session);
-            this.host.addEntry({ id: createId("system"), kind: "system", text: "Reloaded keybindings, extensions, skills, prompts, themes" });
+            const inventory = createReloadContextInventory(runtime, this.host.subagentTypes?.(runtime));
+            this.host.addEntry({ id: createId("system"), kind: "system", text: formatReloadContextInventory(inventory) });
             this.host.toast.success("Reloaded resources");
         }
         catch (error) {
@@ -391,7 +393,7 @@ export class SessionCommandActions {
             this.host.addEntry({
                 id: createId("system"),
                 kind: "system",
-                text: `Deleted session ${targetSessionId}. Started a new session. cwd=${runtime.cwd}`,
+                text: formatReloadContextInventory(createReloadContextInventory(runtime, this.host.subagentTypes?.(runtime)), `Deleted session ${targetSessionId}. Started a new session. cwd=${runtime.cwd}`),
             });
             if (runtime.modelFallbackMessage)
                 this.host.addEntry({ id: createId("system"), kind: "system", text: runtime.modelFallbackMessage });
@@ -427,7 +429,11 @@ export class SessionCommandActions {
             return;
         }
         this.host.resetSessionView();
-        this.host.addEntry({ id: createId("system"), kind: "system", text: `Started a new session. cwd=${runtime.cwd}` });
+        this.host.addEntry({
+            id: createId("system"),
+            kind: "system",
+            text: formatReloadContextInventory(createReloadContextInventory(runtime, this.host.subagentTypes?.(runtime)), `Started a new session. cwd=${runtime.cwd}`),
+        });
         if (runtime.modelFallbackMessage)
             this.host.addEntry({ id: createId("system"), kind: "system", text: runtime.modelFallbackMessage });
         for (const diag of runtime.diagnostics ?? []) {

package/dist/app/commands/reload-context-inventory.d.ts

@@ -0,0 +1,11 @@
+import type { AgentSessionRuntime } from "@earendil-works/pi-coding-agent";
+export interface ReloadContextInventory {
+    readonly model: string;
+    readonly skills: readonly string[];
+    readonly tools: readonly string[];
+    readonly agents: readonly string[] | undefined;
+    readonly skillsReadable: boolean;
+    readonly subagentsActive: boolean;
+}
+export declare function createReloadContextInventory(runtime: AgentSessionRuntime, agentTypes: readonly string[] | undefined): ReloadContextInventory;
+export declare function formatReloadContextInventory(inventory: ReloadContextInventory, heading?: string): string;

package/dist/app/commands/reload-context-inventory.js

@@ -0,0 +1,70 @@
+export function createReloadContextInventory(runtime, agentTypes) {
+    const session = runtime.session;
+    const tools = unique(session.getActiveToolNames());
+    const skillsReadable = tools.some(isSkillFileAccessTool);
+    const subagentsActive = tools.includes("subagents");
+    const skills = skillsReadable
+        ? unique(session.resourceLoader.getSkills().skills.map((skill) => skill.name)).sort(compareText)
+        : [];
+    const agents = subagentsActive && agentTypes !== undefined
+        ? unique(agentTypes).sort(compareText)
+        : subagentsActive
+            ? undefined
+            : [];
+    return {
+        model: currentModelLabel(runtime),
+        skills,
+        tools,
+        agents,
+        skillsReadable,
+        subagentsActive,
+    };
+}
+function isSkillFileAccessTool(toolName) {
+    switch (toolName.trim().toLowerCase()) {
+        case "read":
+        case "bash":
+        case "shell":
+        case "shell_command":
+            return true;
+        default:
+            return false;
+    }
+}
+export function formatReloadContextInventory(inventory, heading = "Reloaded keybindings, extensions, skills, prompts, themes") {
+    return [
+        heading,
+        "",
+        `Model: ${inventory.model}`,
+        "",
+        `Skills (in context): ${inventory.skillsReadable ? listOrNone(inventory.skills) : "(none; read/bash inactive)"}`,
+        "",
+        `Tools (active): ${listOrNone(inventory.tools)}`,
+        "",
+        `Agents (available): ${formatAgents(inventory)}`,
+    ].join("\n");
+}
+function currentModelLabel(runtime) {
+    const model = runtime.session.model;
+    if (!model)
+        return "unavailable";
+    const thinking = runtime.session.thinkingLevel;
+    const modelRef = `${model.provider}/${model.id}`;
+    return !thinking || thinking === "off" ? modelRef : `${modelRef}:${thinking}`;
+}
+function formatAgents(inventory) {
+    if (!inventory.subagentsActive)
+        return "(none; subagents tool inactive)";
+    if (inventory.agents === undefined)
+        return "(catalog unavailable)";
+    return listOrNone(inventory.agents);
+}
+function listOrNone(values) {
+    return values.length > 0 ? values.join(", ") : "(none)";
+}
+function unique(values) {
+    return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+}
+function compareText(left, right) {
+    return left.localeCompare(right);
+}

package/dist/app/extensions/extension-actions-controller.d.ts

@@ -4,6 +4,7 @@ import type { Entry } from "../types.js";
 export type AppExtensionActionsHost = {
     isRunning(): boolean;
     runtime(): AgentSessionRuntime | undefined;
+    subagentTypes?(runtime: AgentSessionRuntime): readonly string[] | undefined;
     getInput(): string;
     setInput(value: string): void;
     awaitCurrentSessionExtensions(runtime?: AgentSessionRuntime): Promise<void>;

package/dist/app/extensions/extension-actions-controller.js

@@ -1,6 +1,7 @@
 import { basename } from "node:path";
 import { createId } from "../id.js";
 import { logPixEvent } from "../logger.js";
+import { createReloadContextInventory, formatReloadContextInventory } from "../commands/reload-context-inventory.js";
 export class AppExtensionActionsController {
     host;
     logExtensionError;
@@ -60,6 +61,11 @@ export class AppExtensionActionsController {
                 if (!this.isSessionActive(runtime, session))
                     return;
                 this.host.setSessionStatus(session);
+                this.host.addEntry({
+                    id: createId("system"),
+                    kind: "system",
+                    text: formatReloadContextInventory(createReloadContextInventory(runtime, this.host.subagentTypes?.(runtime)), "Reloaded resources"),
+                });
                 this.host.showToast("Reloaded resources", "success");
                 this.host.render();
             },

package/dist/app/extensions/subagent-catalog-state.d.ts

@@ -0,0 +1,9 @@
+export declare const SUBAGENTS_CATALOG_STATE_EVENT = "pi-tools-suite:async-subagents:catalog";
+export interface SubagentCatalogState {
+    readonly version: 1;
+    readonly sessionId?: string;
+    readonly sessionFile?: string;
+    readonly model?: string;
+    readonly types: readonly string[];
+}
+export declare function parseSubagentCatalogState(value: unknown): SubagentCatalogState | undefined;

package/dist/app/extensions/subagent-catalog-state.js

@@ -0,0 +1,23 @@
+export const SUBAGENTS_CATALOG_STATE_EVENT = "pi-tools-suite:async-subagents:catalog";
+export function parseSubagentCatalogState(value) {
+    if (!isRecord(value) || value.version !== 1 || !Array.isArray(value.types))
+        return undefined;
+    if (!value.types.every((type) => typeof type === "string" && type.trim().length > 0))
+        return undefined;
+    if (value.sessionId !== undefined && typeof value.sessionId !== "string")
+        return undefined;
+    if (value.sessionFile !== undefined && typeof value.sessionFile !== "string")
+        return undefined;
+    if (value.model !== undefined && typeof value.model !== "string")
+        return undefined;
+    return {
+        version: 1,
+        ...(value.sessionId ? { sessionId: value.sessionId } : {}),
+        ...(value.sessionFile ? { sessionFile: value.sessionFile } : {}),
+        ...(value.model ? { model: value.model } : {}),
+        types: [...new Set(value.types.map((type) => type.trim()))],
+    };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/app/input/autocomplete-controller.js

@@ -138,57 +138,84 @@ export class AppAutocompleteController {
     }
 }
 export async function completeInputWithPi(runtime, draft, config, signal) {
-    const parsedModel = parseModelRef(config.modelRef);
     const modelRuntime = runtime.services.modelRuntime;
-    let model = modelRuntime.getModel(parsedModel.provider, parsedModel.modelId);
-    if (!model) {
-        await modelRuntime.refresh();
-        model = modelRuntime.getModel(parsedModel.provider, parsedModel.modelId);
-    }
-    if (!model)
-        throw new Error(`Model not found: ${parsedModel.provider}/${parsedModel.modelId}`);
     const timeoutMs = numberInRange(config.timeoutMs, AUTOCOMPLETE_TIMEOUT_MS, 250, 10_000);
     const maxTokens = numberInRange(config.maxTokens, AUTOCOMPLETE_MAX_TOKENS, 8, 256);
     const maxPromptTokens = numberInRange(config.maxPromptTokens, AUTOCOMPLETE_MAX_PROMPT_TOKENS, 256, 16_000);
     const requestSignal = createTimeoutSignal(signal, timeoutMs);
-    const requestMaxTokens = model.maxTokens > 0 ? Math.min(model.maxTokens, maxTokens) : maxTokens;
-    const requestModel = { ...model, maxTokens: requestMaxTokens };
     const includeRecentMessages = numberInRange(config.includeRecentMessages, AUTOCOMPLETE_INCLUDE_RECENT_MESSAGES, 0, 20);
     const history = includeRecentMessages > 0 ? autocompleteHistoryFromMessages(runtime.session.messages, includeRecentMessages) : [];
     const prompt = buildAutocompletePrompt({ cwd: runtime.cwd, draft, history, maxPromptTokens });
     if (!prompt)
         return "";
-    let output = "";
-    let streamError;
     try {
-        const stream = modelRuntime.streamSimple(requestModel, {
-            systemPrompt: AUTOCOMPLETE_SYSTEM_PROMPT,
-            messages: [{ role: "user", content: prompt, timestamp: Date.now() }],
-        }, {
-            cacheRetention: "none",
-            maxRetryDelayMs: 0,
-            maxRetries: 0,
-            maxTokens: requestModel.maxTokens,
-            ...(parsedModel.thinkingLevel && parsedModel.thinkingLevel !== "off" ? { reasoning: parsedModel.thinkingLevel } : {}),
-            signal: requestSignal.signal,
-            timeoutMs,
-        });
-        for await (const event of stream) {
-            if (event.type === "text_delta")
-                output += event.delta;
-            else if (event.type === "done" && !output)
-                output = assistantMessageText(event.message);
-            else if (event.type === "error")
-                streamError = event.error.errorMessage ?? event.reason;
+        let refreshed = false;
+        let lastError;
+        for (const modelRef of modelRefChain(config.modelRef, config.fallbackModels)) {
+            if (requestSignal.signal.aborted)
+                throw requestSignal.signal.reason ?? new Error("Autocomplete request aborted");
+            let parsedModel;
+            try {
+                parsedModel = parseModelRef(modelRef);
+            }
+            catch (error) {
+                lastError = error;
+                continue;
+            }
+            let model = modelRuntime.getModel(parsedModel.provider, parsedModel.modelId);
+            if (!model && !refreshed) {
+                await modelRuntime.refresh();
+                refreshed = true;
+                model = modelRuntime.getModel(parsedModel.provider, parsedModel.modelId);
+            }
+            if (!model) {
+                lastError = new Error(`Model not found: ${parsedModel.provider}/${parsedModel.modelId}`);
+                continue;
+            }
+            try {
+                const requestMaxTokens = model.maxTokens > 0 ? Math.min(model.maxTokens, maxTokens) : maxTokens;
+                const requestModel = { ...model, maxTokens: requestMaxTokens };
+                let output = "";
+                let streamError;
+                const stream = modelRuntime.streamSimple(requestModel, {
+                    systemPrompt: AUTOCOMPLETE_SYSTEM_PROMPT,
+                    messages: [{ role: "user", content: prompt, timestamp: Date.now() }],
+                }, {
+                    cacheRetention: "none",
+                    maxRetryDelayMs: 0,
+                    maxRetries: 0,
+                    maxTokens: requestModel.maxTokens,
+                    ...(parsedModel.thinkingLevel && parsedModel.thinkingLevel !== "off" ? { reasoning: parsedModel.thinkingLevel } : {}),
+                    signal: requestSignal.signal,
+                    timeoutMs,
+                });
+                for await (const event of stream) {
+                    if (event.type === "text_delta")
+                        output += event.delta;
+                    else if (event.type === "done" && !output)
+                        output = assistantMessageText(event.message);
+                    else if (event.type === "error")
+                        streamError = event.error.errorMessage ?? event.reason;
+                }
+                if (streamError)
+                    throw new Error(streamError);
+                return output;
+            }
+            catch (error) {
+                if (requestSignal.signal.aborted)
+                    throw requestSignal.signal.reason ?? error;
+                lastError = error;
+            }
         }
-        if (streamError)
-            throw new Error(streamError);
-        return output;
+        throw lastError ?? new Error("No autocomplete models are configured");
     }
     finally {
         requestSignal.dispose();
     }
 }
+function modelRefChain(primary, fallbacks) {
+    return [...new Set([primary, ...(fallbacks ?? [])].map((ref) => ref.trim()).filter(Boolean))];
+}
 export function autocompleteHistoryFromMessages(messages, includeRecentMessages) {
     const limit = numberInRange(includeRecentMessages, AUTOCOMPLETE_INCLUDE_RECENT_MESSAGES, 0, 20);
     if (limit <= 0)

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

@@ -9,6 +9,8 @@ import type { Entry, SessionActivity } from "../types.js";
 export type AppInputActionControllerHost = {
     runtime(): AgentSessionRuntime | undefined;
     inputScopeKey?(): string | undefined;
+    isDraftTabActive?(): boolean;
+    materializeDraftSession?(): Promise<AgentSessionRuntime | undefined>;
     isRunning(): boolean;
     isSessionSwitching(): boolean;
     inputEditor(): InputEditor;

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

@@ -149,7 +149,6 @@ export class AppInputActionController {
         await this.host.stopVoiceInput();
         if (this.host.inputScopeKey && this.host.inputScopeKey() !== inputScopeKey)
             return;
-        const runtime = this.host.runtime();
         const inputEditor = this.host.inputEditor();
         const rawPromptText = inputEditor.promptText;
         const rawDisplayText = inputEditor.expandedText;
@@ -176,6 +175,14 @@ export class AppInputActionController {
             await this.popupActions.submitSlashCommand(promptText);
             return;
         }
+        let runtime = this.host.runtime();
+        if (!runtime && this.host.isDraftTabActive?.()) {
+            runtime = await this.host.materializeDraftSession?.();
+            if (this.host.inputScopeKey && this.host.inputScopeKey() !== inputScopeKey)
+                return;
+            if (!runtime)
+                return;
+        }
         const message = this.queuedMessages.createSubmittedUserMessage(promptText, displayText, images);
         this.host.requestHistory().add(message.displayText);
         inputEditor.clear();

package/dist/app/input/input-controller.d.ts

@@ -16,6 +16,7 @@ export type InputControllerHost = {
     resetInputMenuDismissals(): void;
     render(): void;
     moveActivePopupMenuSelection(delta: number): boolean;
+    moveActiveModelThinkingLevel(delta: number): boolean;
     navigateRequestHistory(delta: number): boolean;
     scrollByLines(delta: number): void;
     scrollByPage(delta: number): void;
@@ -24,8 +25,8 @@ export type InputControllerHost = {
     handleInterrupt(): Promise<void>;
     handleEscape(): Promise<void>;
     handleDirectPopupInput(char: string): boolean;
+    toggleModelVisibilityMode(): boolean;
     autocompleteModel(): boolean;
-    autocompleteThinking(): boolean;
     acceptAutocompleteSuggestion(): boolean;
     autocompleteSlashCommand(): void;
     toggleVoiceRecording(): void;

package/dist/app/input/input-controller.js

@@ -229,6 +229,9 @@ export class AppInputController {
     getEscapeSequences() {
         return [
             ...SHIFT_ENTER_ESCAPE_SEQUENCES.map((sequence) => [sequence, () => this.insertInputNewline()]),
+            ["\x1b[Z", () => { this.host.toggleModelVisibilityMode(); }],
+            ["\x1b[9;2u", () => { this.host.toggleModelVisibilityMode(); }],
+            ["\x1b[27;2;9~", () => { this.host.toggleModelVisibilityMode(); }],
             ["\x1b[13u", () => this.host.handleEnter()],
             ["\x1b[13;1u", () => this.host.handleEnter()],
             ["\x1b[5~", () => this.host.scrollByPage(-1)],
@@ -460,6 +463,8 @@ export class AppInputController {
         this.host.scrollByLines(1);
     }
     handleArrowLeft() {
+        if (this.host.moveActiveModelThinkingLevel(-1))
+            return;
         if (this.host.inputEditor.hasSelection) {
             const [start] = this.orderedEditorSelection();
             this.host.inputEditor.clearSelection();
@@ -473,6 +478,8 @@ export class AppInputController {
         }
     }
     handleArrowRight() {
+        if (this.host.moveActiveModelThinkingLevel(1))
+            return;
         if (this.host.inputEditor.hasSelection) {
             const [, end] = this.orderedEditorSelection();
             this.host.inputEditor.clearSelection();
@@ -554,8 +561,6 @@ export class AppInputController {
                 return;
             if (this.host.autocompleteModel())
                 return;
-            if (this.host.autocompleteThinking())
-                return;
             this.host.autocompleteSlashCommand();
             return;
         }

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

@@ -129,7 +129,6 @@ 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 promptEnhancerPiDeps.createAgentSessionServices({
         cwd: runtime.cwd,
         agentDir: runtime.services.agentDir,
@@ -145,41 +144,60 @@ async function enhancePromptWithPi(runtime, draft, config) {
         },
     });
     await services.modelRuntime.refresh();
-    const model = services.modelRuntime.getModel(parsedModel.provider, parsedModel.modelId);
-    if (!model) {
-        throw new Error(modelNotFoundMessage(parsedModel.provider, parsedModel.modelId, services.modelRuntime.getModels()));
-    }
-    const { session } = await promptEnhancerPiDeps.createAgentSessionFromServices({
-        services,
-        sessionManager: promptEnhancerPiDeps.sessionManagerInMemory(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();
+    let lastError;
+    for (const modelRef of modelRefChain(config.modelRef, config.fallbackModels)) {
+        let parsedModel;
+        try {
+            parsedModel = parseModelRef(modelRef);
+        }
+        catch (error) {
+            lastError = error;
+            continue;
+        }
+        const model = services.modelRuntime.getModel(parsedModel.provider, parsedModel.modelId);
+        if (!model) {
+            lastError = new Error(modelNotFoundMessage(parsedModel.provider, parsedModel.modelId, services.modelRuntime.getModels()));
+            continue;
+        }
+        const { session } = await promptEnhancerPiDeps.createAgentSessionFromServices({
+            services,
+            sessionManager: promptEnhancerPiDeps.sessionManagerInMemory(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;
+        }
+        catch (error) {
+            lastError = error;
+        }
+        finally {
+            unsubscribe();
+            session.dispose();
+        }
     }
+    throw lastError ?? new Error("No prompt enhancer models are configured");
+}
+function modelRefChain(primary, fallbacks) {
+    return [...new Set([primary, ...(fallbacks ?? [])].map((ref) => ref.trim()).filter(Boolean))];
 }
 function buildEnhancerPrompt(draft) {
     return [