@selesai/code 0.11.0 → 0.13.0

package/CHANGELOG.md

@@ -2,6 +2,32 @@
 
 All notable changes to `@selesai/code` will be documented in this file.
 
+## [0.13.0] - 2026-08-29
+
+### Fixed
+- **Sub-cent cost display.** Cost labels no longer round small per-call costs to `$0.000`. The footer, zentui footer, and usage popup now format costs adaptively: 3 decimals at $1+, 4 decimals at $0.01+, and 6 decimals below, so gateway-reconciled costs like `$0.000336` are visible.
+
+## [0.12.0] - 2026-08-29
+
+### Added
+- **`/tokenin usage` subcommand.** The `tokenin-onboarding` extension now queries the LiteLLM `/key/info` endpoint with the active Token-In token and shows a boxed spend/budget/remaining/reset display with a progress bar. Run `/tokenin usage` to check quota without leaving the session.
+- **Terminal capability overrides.** New `terminal.images` (`"kitty"`, `"iterm2"`, `"auto"`, or `false`), `terminal.trueColor`, and `terminal.hyperlinks` settings let you pin terminal capabilities instead of relying on auto-detection.
+- **`fullscreenCopyOnSelect` setting.** New setting (default `true`) and `/settings` toggle: automatically copy selected text in fullscreen mode; disable to copy selections with Ctrl+X.
+- **`ui_prompt_start` / `ui_prompt_end` extension events.** Extensions can now observe when the agent starts and stops waiting on a blocking user-facing UI prompt (`select`, `confirm`, `input`, `editor`, `custom`).
+- **llama.cpp router autoload.** Unloaded preset models are now selectable when the llama.cpp router has `models_autoload` enabled, so they load on first use instead of being hidden.
+- **RPC `clear_queue` command.** RPC clients can clear the pending steering/follow-up queue and get back the dropped items.
+
+### Changed
+- **Custom message ordering during streaming.** Context-only custom messages queued while the agent is streaming are now flushed at turn end (after tool results are in) instead of being appended between a tool call and its result, which some providers reject on replay.
+- **Auto-compaction before the next assistant response.** The session now checks the context threshold before preparing the next turn and compacts when needed, so long conversations stay within the model window.
+- **Persisted default model joins scoped model lists.** When a scoped model list (`--models`) is active, the persisted default model is added to the scope and to `enabledModels` so it stays reachable.
+- **Model catalog updates.** Celestial, DeepSeek, and GPT models now declare `compat.requiresReasoningContentOnAssistantMessages` where required.
+- **Windows process cleanup.** `taskkill` is invoked via the trusted System32 path instead of relying on `PATH`, and failed spawns no longer crash Node.
+
+### Fixed
+- **Footer provider count after model switch.** The interactive footer's available-provider count now refreshes immediately after switching models in the model selector.
+- **Summarization length-stop guard.** A summarization response that hits the token cap (partial text) is now treated as a failure and never persisted as a session checkpoint.
+
 ## [0.11.0] - 2026-08-29
 
 ### Added

package/dist/cli/startup-ui.js

@@ -1,4 +1,4 @@
-import { ProcessTerminal, setKeybindings, TuiMainScreen } from "@earendil-works/pi-tui";
+import { ProcessTerminal, setCapabilityOverrides, setKeybindings, TuiMainScreen, } from "@earendil-works/pi-tui";
 import { existsSync } from "fs";
 import { ENV_AGENT_DIR, getAgentDir, getFirstRunMarkerPath, markFirstRunComplete } from "../config.js";
 import { KeybindingsManager } from "../core/keybindings.js";
@@ -43,6 +43,7 @@ async function loadStartupThemes(settingsManager) {
     return loadThemes(resolvedPaths.themes);
 }
 export async function createStartupTui(settingsManager) {
+    setCapabilityOverrides(settingsManager.getTerminalCapabilityOverrides());
     setRegisteredThemes(await loadStartupThemes(settingsManager));
     const terminalTheme = detectTerminalBackgroundFromEnv().theme;
     initTheme(resolveThemeSetting(settingsManager.getThemeSetting(), terminalTheme) ?? terminalTheme);

package/dist/core/agent-session.d.ts

@@ -218,6 +218,8 @@ export declare class AgentSession {
     private _followUpMessages;
     /** Messages queued to be included with the next user prompt as context ("asides"). */
     private _pendingNextTurnMessages;
+    /** Context-only custom messages queued during a run, flushed once the current turn's tool results are in. */
+    private _pendingCustomMessages;
     private _compactionAbortController;
     private _autoCompactionAbortController;
     private _overflowRecoveryAttempted;
@@ -266,6 +268,7 @@ export declare class AgentSession {
      * happens here instead of in wrappers.
      */
     private _installAgentToolHooks;
+    private _compactBeforeNextAssistantResponse;
     private _installAgentNextTurnRefresh;
     /** Emit an event to all listeners */
     private _emit;
@@ -412,8 +415,9 @@ export declare class AgentSession {
     /**
      * Send a custom message to the session. Creates a CustomMessageEntry.
      *
-     * Handles three cases:
+     * Handles four cases:
      * - Streaming: queues message, processed when loop pulls from queue
+     * - Streaming + triggerTurn false: appended to state/session once the current turn ends
      * - Not streaming + triggerTurn: appends to state/session, starts new turn
      * - Not streaming + no trigger: appends to state/session, no turn
      *
@@ -425,6 +429,12 @@ export declare class AgentSession {
         triggerTurn?: boolean;
         deliverAs?: "steer" | "followUp" | "nextTurn";
     }): Promise<void>;
+    private _appendCustomMessage;
+    /**
+     * Append custom messages queued while the agent was running.
+     * Called once the current turn's tool results are in agent state and session history.
+     */
+    private _flushPendingCustomMessages;
     private _captionImagesForCurrentModel;
     /**
      * Build a small, text-only slice of the most recent conversation to give the
@@ -485,6 +495,7 @@ export declare class AgentSession {
      * @throws Error if no auth is configured for the model
      */
     setModel(model: Model<any>, options?: ModelMutationOptions): Promise<void>;
+    private _addPersistedDefaultToNonEmptyScope;
     /**
      * Cycle to next/previous model.
      * Uses scoped models (from --models flag) if available, otherwise all available models.

package/dist/core/agent-session.js

@@ -102,6 +102,8 @@ export class AgentSession {
     _followUpMessages = [];
     /** Messages queued to be included with the next user prompt as context ("asides"). */
     _pendingNextTurnMessages = [];
+    /** Context-only custom messages queued during a run, flushed once the current turn's tool results are in. */
+    _pendingCustomMessages = [];
     // Compaction state
     _compactionAbortController = undefined;
     _autoCompactionAbortController = undefined;
@@ -269,18 +271,33 @@ export class AgentSession {
             };
         };
     }
+    async _compactBeforeNextAssistantResponse(context) {
+        const model = this.model;
+        const settings = this.settingsManager.getCompactionSettings();
+        if (!model ||
+            model.contextWindow <= 0 ||
+            !shouldCompact(estimateContextTokens(context.messages).tokens, model.contextWindow, settings)) {
+            return context;
+        }
+        await this._runAutoCompaction("threshold", false);
+        return {
+            ...context,
+            messages: this.agent.state.messages.slice(),
+        };
+    }
     _installAgentNextTurnRefresh() {
         const previousPrepareNextTurnWithContext = this.agent.prepareNextTurnWithContext ??
             (this.agent.prepareNextTurn
                 ? async (_turn, signal) => await this.agent.prepareNextTurn?.(signal)
                 : undefined);
         this.agent.prepareNextTurnWithContext = async (turn, signal) => {
-            const previousSnapshot = await previousPrepareNextTurnWithContext?.(turn, signal);
-            const previousContext = previousSnapshot?.context ?? turn.context;
+            const context = await this._compactBeforeNextAssistantResponse(turn.context);
+            const previousSnapshot = await previousPrepareNextTurnWithContext?.({ ...turn, context }, signal);
+            const nextContext = previousSnapshot?.context ?? context;
             return {
                 ...previousSnapshot,
                 context: {
-                    ...previousContext,
+                    ...nextContext,
                     systemPrompt: this._systemPromptOverride ?? this._baseSystemPrompt,
                     tools: this.agent.state.tools.slice(),
                 },
@@ -436,6 +453,14 @@ export class AgentSession {
                 }
             }
         }
+        // A turn ends after its assistant message and every tool result has been appended,
+        // so this is the first point in the run where a context-only custom message can be
+        // inserted without landing between a tool call and its result. Flushing after the
+        // extension and listener dispatch above also picks up messages that turn_end
+        // handlers queued.
+        if (event.type === "turn_end") {
+            this._flushPendingCustomMessages();
+        }
     };
     _willRetryAfterAgentEnd(event) {
         const settings = this.settingsManager.getRetrySettings();
@@ -813,6 +838,7 @@ export class AgentSession {
         finally {
             this._systemPromptOverride = undefined;
             this._flushPendingBashMessages();
+            this._flushPendingCustomMessages();
             await this._emitAgentSettled();
         }
     }
@@ -908,8 +934,9 @@ export class AgentSession {
                 preflightResult?.(true);
                 return;
             }
-            // Flush any pending bash messages before the new prompt
+            // Flush any pending bash and custom messages before the new prompt
             this._flushPendingBashMessages();
+            this._flushPendingCustomMessages();
             // Validate model
             if (!this.model) {
                 throw new Error(formatNoModelSelectedMessage());
@@ -1138,8 +1165,9 @@ export class AgentSession {
     /**
      * Send a custom message to the session. Creates a CustomMessageEntry.
      *
-     * Handles three cases:
+     * Handles four cases:
      * - Streaming: queues message, processed when loop pulls from queue
+     * - Streaming + triggerTurn false: appended to state/session once the current turn ends
      * - Not streaming + triggerTurn: appends to state/session, starts new turn
      * - Not streaming + no trigger: appends to state/session, no turn
      *
@@ -1171,11 +1199,34 @@ export class AgentSession {
         else if (options?.triggerTurn) {
             await this._runAgentPrompt(appMessage);
         }
+        else if (this.isStreaming) {
+            // Appending now would put the message between an assistant tool call and its
+            // result, which providers that validate message order reject on replay. Defer
+            // to the end of the turn. Nothing is emitted yet: message events must not
+            // describe messages the session tree does not contain.
+            this._pendingCustomMessages.push(appMessage);
+        }
         else {
-            this.agent.state.messages.push(appMessage);
-            this.sessionManager.appendCustomMessageEntry(message.customType, message.content, message.display, message.details);
-            this._emit({ type: "message_start", message: appMessage });
-            this._emit({ type: "message_end", message: appMessage });
+            this._appendCustomMessage(appMessage);
+        }
+    }
+    _appendCustomMessage(appMessage) {
+        this.agent.state.messages.push(appMessage);
+        this.sessionManager.appendCustomMessageEntry(appMessage.customType, appMessage.content, appMessage.display, appMessage.details);
+        this._emit({ type: "message_start", message: appMessage });
+        this._emit({ type: "message_end", message: appMessage });
+    }
+    /**
+     * Append custom messages queued while the agent was running.
+     * Called once the current turn's tool results are in agent state and session history.
+     */
+    _flushPendingCustomMessages() {
+        if (this._pendingCustomMessages.length === 0)
+            return;
+        const pending = this._pendingCustomMessages;
+        this._pendingCustomMessages = [];
+        for (const appMessage of pending) {
+            this._appendCustomMessage(appMessage);
         }
     }
     /**
@@ -1448,10 +1499,25 @@ export class AgentSession {
         this.sessionManager.appendModelChange(model.provider, model.id);
         if (options.persist) {
             this.settingsManager.setDefaultModelAndProvider(model.provider, model.id);
+            this._addPersistedDefaultToNonEmptyScope(model);
         }
         this.setThinkingLevel(thinkingLevel);
         await this._emitModelSelect(model, previousModel, "set");
     }
+    _addPersistedDefaultToNonEmptyScope(model) {
+        if (this._scopedModels.length === 0)
+            return;
+        if (this._scopedModels.some((scoped) => modelsAreEqual(scoped.model, model)))
+            return;
+        this._scopedModels = [...this._scopedModels, { model }];
+        const enabledModels = this.settingsManager.getEnabledModels();
+        if (!enabledModels?.length)
+            return;
+        const modelReference = `${model.provider}/${model.id}`;
+        if (enabledModels.some((pattern) => pattern.toLowerCase() === modelReference.toLowerCase()))
+            return;
+        this.settingsManager.setEnabledModels([...enabledModels, modelReference]);
+    }
     /**
      * Cycle to next/previous model.
      * Uses scoped models (from --models flag) if available, otherwise all available models.
@@ -1485,6 +1551,7 @@ export class AgentSession {
         this.sessionManager.appendModelChange(next.model.provider, next.model.id);
         if (options.persist) {
             this.settingsManager.setDefaultModelAndProvider(next.model.provider, next.model.id);
+            this._addPersistedDefaultToNonEmptyScope(next.model);
         }
         // Apply thinking level.
         // - Explicit scoped model thinking level overrides current session level
@@ -1510,6 +1577,7 @@ export class AgentSession {
         this.sessionManager.appendModelChange(nextModel.provider, nextModel.id);
         if (options.persist) {
             this.settingsManager.setDefaultModelAndProvider(nextModel.provider, nextModel.id);
+            this._addPersistedDefaultToNonEmptyScope(nextModel);
         }
         // Re-clamp thinking level for new model's capabilities
         this.setThinkingLevel(thinkingLevel);

package/dist/core/compaction/branch-summarization.js

@@ -6,7 +6,7 @@
  */
 import { contentText } from "@earendil-works/pi-ai";
 import { convertToLlm, createBranchSummaryMessage, createCompactionSummaryMessage, createCustomMessage, } from "../messages.js";
-import { completeSummarization, estimateTokens } from "./compaction.js";
+import { completeSummarization, estimateTokens, getSummarizationFailure } from "./compaction.js";
 import { computeFileLists, createFileOps, extractFileOpsFromMessage, formatFileOperations, SUMMARIZATION_SYSTEM_PROMPT, serializeConversation, } from "./utils.js";
 // ============================================================================
 // Entry Collection
@@ -227,8 +227,9 @@ export async function generateBranchSummary(entries, options) {
     if (response.stopReason === "aborted") {
         return { aborted: true };
     }
-    if (response.stopReason === "error") {
-        return { error: response.errorMessage || "Summarization failed" };
+    const failure = getSummarizationFailure(response, "Branch summarization");
+    if (failure) {
+        return { error: failure };
     }
     let summary = contentText(response.content);
     // Prepend preamble to provide context about the branch summary

package/dist/core/compaction/compaction.d.ts

@@ -90,6 +90,11 @@ export interface CutPointResult {
  * Only considers entries between `startIndex` and `endIndex` (exclusive).
  */
 export declare function findCutPoint(entries: SessionEntry[], startIndex: number, endIndex: number, keepRecentTokens: number): CutPointResult;
+/**
+ * Returns an error message when a summarization response cannot safely be persisted.
+ * A length stop contains partial text and must not become a session checkpoint.
+ */
+export declare function getSummarizationFailure(response: AssistantMessage, label: string): string | undefined;
 /**
  * Shared choke point for every compaction/branch-summary summarization call. Wraps the
  * single LLM call in {@link retryAssistantCall} so transient stream drops (e.g.

package/dist/core/compaction/compaction.js

@@ -423,6 +423,19 @@ Use this EXACT format:
 - [Preserve important context, add new if needed]
 
 Keep each section concise. Preserve exact file paths, function names, and error messages.`;
+/**
+ * Returns an error message when a summarization response cannot safely be persisted.
+ * A length stop contains partial text and must not become a session checkpoint.
+ */
+export function getSummarizationFailure(response, label) {
+    if (response.stopReason === "error") {
+        return `${label} failed: ${response.errorMessage || "Unknown error"}`;
+    }
+    if (response.stopReason === "length") {
+        return `${label} failed: generation hit the token cap and the summary is incomplete`;
+    }
+    return undefined;
+}
 function createSummarizationOptions(model, maxTokens, apiKey, headers, env, signal, thinkingLevel) {
     const options = { maxTokens, signal, apiKey, headers, env };
     if (model.reasoning && thinkingLevel && thinkingLevel !== "off") {
@@ -483,8 +496,9 @@ export async function generateSummaryWithUsage(currentMessages, model, reserveTo
     ];
     const completionOptions = createSummarizationOptions(model, maxTokens, apiKey, headers, env, signal, thinkingLevel);
     const response = await completeSummarization(model, { systemPrompt: SUMMARIZATION_SYSTEM_PROMPT, messages: summarizationMessages }, completionOptions, streamFn, retry, callbacks);
-    if (response.stopReason === "error") {
-        throw new Error(`Summarization failed: ${response.errorMessage || "Unknown error"}`);
+    const failure = getSummarizationFailure(response, "Summarization");
+    if (failure) {
+        throw new Error(failure);
     }
     const textContent = contentText(response.content);
     return { text: textContent, usage: response.usage };
@@ -634,8 +648,9 @@ async function generateTurnPrefixSummary(messages, model, reserveTokens, apiKey,
         },
     ];
     const response = await completeSummarization(model, { systemPrompt: SUMMARIZATION_SYSTEM_PROMPT, messages: summarizationMessages }, createSummarizationOptions(model, maxTokens, apiKey, headers, env, signal, thinkingLevel), streamFn, retry, callbacks);
-    if (response.stopReason === "error") {
-        throw new Error(`Turn prefix summarization failed: ${response.errorMessage || "Unknown error"}`);
+    const failure = getSummarizationFailure(response, "Turn prefix summarization");
+    if (failure) {
+        throw new Error(failure);
     }
     return {
         text: contentText(response.content),

package/dist/core/extensions/index.d.ts

@@ -6,6 +6,6 @@ export type { SourceInfo } from "../source-info.ts";
 export { createExtensionRuntime, discoverAndLoadExtensions, loadExtensionFromFactory, loadExtensions, } from "./loader.ts";
 export type { ExtensionErrorListener, ForkHandler, NavigateTreeHandler, NewSessionHandler, ShutdownHandler, SwitchSessionHandler, } from "./runner.ts";
 export { ExtensionRunner } from "./runner.ts";
-export type { AfterProviderResponseEvent, AgentEndEvent, AgentSettledEvent, AgentStartEvent, AgentToolResult, AgentToolUpdateCallback, AppendEntryHandler, AppKeybinding, AutocompleteProviderFactory, BashToolCallEvent, BashToolResultEvent, BeforeAgentStartEvent, BeforeAgentStartEventResult, BeforeProviderHeadersEvent, BeforeProviderRequestEvent, BeforeProviderRequestEventResult, BuildSystemPromptOptions, CompactOptions, ContextEvent, ContextEventResult, ContextUsage, CustomToolCallEvent, CustomToolResultEvent, EditorFactory, EditToolCallEvent, EditToolResultEvent, EntryRenderer, EntryRenderOptions, ExecOptions, ExecResult, Extension, ExtensionActions, ExtensionAPI, ExtensionCommandContext, ExtensionCommandContextActions, ExtensionContext, ExtensionContextActions, ExtensionError, ExtensionEvent, ExtensionFactory, ExtensionFlag, ExtensionHandler, ExtensionMode, ExtensionRuntime, ExtensionShortcut, ExtensionUIContext, ExtensionUIDialogOptions, ExtensionWidgetOptions, FindToolCallEvent, FindToolResultEvent, GetActiveToolsHandler, GetAllToolsHandler, GetCommandsHandler, GetThinkingLevelHandler, GrepToolCallEvent, GrepToolResultEvent, InlineExtension, InputEvent, InputEventResult, InputSource, KeybindingsManager, LoadExtensionsResult, LsToolCallEvent, LsToolResultEvent, MessageEndEvent, MessageRenderer, MessageRenderOptions, MessageStartEvent, MessageUpdateEvent, ModelSelectEvent, ModelSelectSource, ProjectTrustContext, ProjectTrustEvent, ProjectTrustEventDecision, ProjectTrustEventResult, ProjectTrustHandler, ProviderConfig, ProviderModelConfig, ReadToolCallEvent, ReadToolResultEvent, RegisteredCommand, RegisteredTool, ReplacedSessionContext, ResolvedCommand, ResourcesDiscoverEvent, ResourcesDiscoverResult, SendMessageHandler, SendUserMessageHandler, SessionBeforeCompactEvent, SessionBeforeCompactResult, SessionBeforeForkEvent, SessionBeforeForkResult, SessionBeforeSwitchEvent, SessionBeforeSwitchResult, SessionBeforeTreeEvent, SessionBeforeTreeResult, SessionCompactEvent, SessionEvent, SessionInfoChangedEvent, SessionShutdownEvent, SessionStartEvent, SessionTreeEvent, SetActiveToolsHandler, SetLabelHandler, SetModelHandler, SetThinkingLevelHandler, TerminalInputHandler, ToolCallEvent, ToolCallEventResult, ToolDefinition, ToolExecutionEndEvent, ToolExecutionMode, ToolExecutionStartEvent, ToolExecutionUpdateEvent, ToolInfo, ToolRenderResultOptions, ToolResultEvent, ToolResultEventResult, TreePreparation, TurnEndEvent, TurnStartEvent, UserBashEvent, UserBashEventResult, WidgetPlacement, WorkingIndicatorOptions, WriteToolCallEvent, WriteToolResultEvent, } from "./types.ts";
+export type { AfterProviderResponseEvent, AgentEndEvent, AgentSettledEvent, AgentStartEvent, AgentToolResult, AgentToolUpdateCallback, AppendEntryHandler, AppKeybinding, AutocompleteProviderFactory, BashToolCallEvent, BashToolResultEvent, BeforeAgentStartEvent, BeforeAgentStartEventResult, BeforeProviderHeadersEvent, BeforeProviderRequestEvent, BeforeProviderRequestEventResult, BuildSystemPromptOptions, CompactOptions, ContextEvent, ContextEventResult, ContextUsage, CustomToolCallEvent, CustomToolResultEvent, EditorFactory, EditToolCallEvent, EditToolResultEvent, EntryRenderer, EntryRenderOptions, ExecOptions, ExecResult, Extension, ExtensionActions, ExtensionAPI, ExtensionCommandContext, ExtensionCommandContextActions, ExtensionContext, ExtensionContextActions, ExtensionError, ExtensionEvent, ExtensionFactory, ExtensionFlag, ExtensionHandler, ExtensionMode, ExtensionRuntime, ExtensionShortcut, ExtensionUIContext, ExtensionUIDialogOptions, ExtensionWidgetOptions, FindToolCallEvent, FindToolResultEvent, GetActiveToolsHandler, GetAllToolsHandler, GetCommandsHandler, GetThinkingLevelHandler, GrepToolCallEvent, GrepToolResultEvent, InlineExtension, InputEvent, InputEventResult, InputSource, KeybindingsManager, LoadExtensionsResult, LsToolCallEvent, LsToolResultEvent, MessageEndEvent, MessageRenderer, MessageRenderOptions, MessageStartEvent, MessageUpdateEvent, ModelSelectEvent, ModelSelectSource, ProjectTrustContext, ProjectTrustEvent, ProjectTrustEventDecision, ProjectTrustEventResult, ProjectTrustHandler, ProviderConfig, ProviderModelConfig, ReadToolCallEvent, ReadToolResultEvent, RegisteredCommand, RegisteredTool, ReplacedSessionContext, ResolvedCommand, ResourcesDiscoverEvent, ResourcesDiscoverResult, SendMessageHandler, SendUserMessageHandler, SessionBeforeCompactEvent, SessionBeforeCompactResult, SessionBeforeForkEvent, SessionBeforeForkResult, SessionBeforeSwitchEvent, SessionBeforeSwitchResult, SessionBeforeTreeEvent, SessionBeforeTreeResult, SessionCompactEvent, SessionEvent, SessionInfoChangedEvent, SessionShutdownEvent, SessionStartEvent, SessionTreeEvent, SetActiveToolsHandler, SetLabelHandler, SetModelHandler, SetThinkingLevelHandler, TerminalInputHandler, ToolCallEvent, ToolCallEventResult, ToolDefinition, ToolExecutionEndEvent, ToolExecutionMode, ToolExecutionStartEvent, ToolExecutionUpdateEvent, ToolInfo, ToolRenderResultOptions, ToolResultEvent, ToolResultEventResult, TreePreparation, TurnEndEvent, TurnStartEvent, UIPromptEndEvent, UIPromptKind, UIPromptStartEvent, UserBashEvent, UserBashEventResult, WidgetPlacement, WorkingIndicatorOptions, WriteToolCallEvent, WriteToolResultEvent, } from "./types.ts";
 export { defineTool, isBashToolResult, isEditToolResult, isFindToolResult, isGrepToolResult, isLsToolResult, isReadToolResult, isToolCallEventType, isWriteToolResult, } from "./types.ts";
 export { wrapRegisteredTool, wrapRegisteredTools } from "./wrapper.ts";

package/dist/core/extensions/runner.d.ts

@@ -72,6 +72,8 @@ export declare class ExtensionRunner {
     private runtime;
     private uiContext;
     private mode;
+    private uiPromptDepth;
+    private activeUIPrompt;
     private cwd;
     private sessionManager;
     private modelRegistry;
@@ -105,6 +107,9 @@ export declare class ExtensionRunner {
     }): void;
     bindCommandContext(actions?: ExtensionCommandContextActions): void;
     setUIContext(uiContext?: ExtensionUIContext, mode?: ExtensionMode): void;
+    private wrapUIPromptContext;
+    private withUIPrompt;
+    private emitUIPromptEvent;
     getUIContext(): ExtensionUIContext;
     hasUI(): boolean;
     getExtensionPaths(): string[];

package/dist/core/extensions/runner.js

@@ -122,6 +122,8 @@ export class ExtensionRunner {
     runtime;
     uiContext;
     mode = "print";
+    uiPromptDepth = 0;
+    activeUIPrompt;
     cwd;
     sessionManager;
     modelRegistry;
@@ -265,9 +267,54 @@ export class ExtensionRunner {
         this.reloadHandler = async () => { };
     }
     setUIContext(uiContext, mode = "print") {
-        this.uiContext = uiContext ?? noOpUIContext;
+        this.uiContext = uiContext ? this.wrapUIPromptContext(uiContext) : noOpUIContext;
         this.mode = mode;
     }
+    wrapUIPromptContext(ui) {
+        return {
+            ...ui,
+            select: (title, options, opts) => this.withUIPrompt("select", title, () => ui.select(title, options, opts)),
+            multiselect: ui.multiselect
+                ? (title, options, opts) => this.withUIPrompt("select", title, () => ui.multiselect(title, options, opts))
+                : undefined,
+            confirm: (title, message, opts) => this.withUIPrompt("confirm", title, () => ui.confirm(title, message, opts)),
+            input: (title, placeholder, opts) => this.withUIPrompt("input", title, () => ui.input(title, placeholder, opts)),
+            editor: (title, prefill) => this.withUIPrompt("editor", title, () => ui.editor(title, prefill)),
+            custom: (factory, options) => this.withUIPrompt("custom", undefined, () => ui.custom(factory, options)),
+        };
+    }
+    withUIPrompt(kind, title, run) {
+        const outerPrompt = this.uiPromptDepth++ === 0;
+        if (outerPrompt) {
+            this.activeUIPrompt = { kind, title };
+            this.emitUIPromptEvent({ type: "ui_prompt_start", reason: "ui_prompt", kind, ...(title ? { title } : {}) });
+        }
+        const finish = () => {
+            if (--this.uiPromptDepth > 0)
+                return;
+            this.uiPromptDepth = 0;
+            const prompt = this.activeUIPrompt ?? { kind, title };
+            this.activeUIPrompt = undefined;
+            this.emitUIPromptEvent({
+                type: "ui_prompt_end",
+                reason: "ui_prompt",
+                kind: prompt.kind,
+                ...(prompt.title ? { title: prompt.title } : {}),
+            });
+        };
+        try {
+            return run().finally(finish);
+        }
+        catch (err) {
+            finish();
+            throw err;
+        }
+    }
+    emitUIPromptEvent(event) {
+        queueMicrotask(() => {
+            void this.emit(event);
+        });
+    }
     getUIContext() {
         return this.uiContext;
     }

package/dist/core/extensions/types.d.ts

@@ -563,6 +563,21 @@ export interface AgentEndEvent {
 export interface AgentSettledEvent {
     type: "agent_settled";
 }
+export type UIPromptKind = "select" | "confirm" | "input" | "editor" | "custom";
+/** Fired when Pi starts waiting on a blocking user-facing extension UI prompt. */
+export interface UIPromptStartEvent {
+    type: "ui_prompt_start";
+    reason: "ui_prompt";
+    kind: UIPromptKind;
+    title?: string;
+}
+/** Fired when Pi is no longer waiting on a blocking user-facing extension UI prompt. */
+export interface UIPromptEndEvent {
+    type: "ui_prompt_end";
+    reason: "ui_prompt";
+    kind: UIPromptKind;
+    title?: string;
+}
 /** Fired at the start of each turn */
 export interface TurnStartEvent {
     type: "turn_start";
@@ -788,7 +803,7 @@ export declare function isToolCallEventType<TName extends string, TInput extends
     input: TInput;
 };
 /** Union of all event types */
-export type ExtensionEvent = ProjectTrustEvent | ResourcesDiscoverEvent | SessionEvent | ContextEvent | BeforeProviderRequestEvent | BeforeProviderHeadersEvent | AfterProviderResponseEvent | BeforeAgentStartEvent | AgentStartEvent | AgentEndEvent | AgentSettledEvent | TurnStartEvent | TurnEndEvent | MessageStartEvent | MessageUpdateEvent | MessageEndEvent | ToolExecutionStartEvent | ToolExecutionUpdateEvent | ToolExecutionEndEvent | ModelSelectEvent | ThinkingLevelSelectEvent | UserBashEvent | InputEvent | ToolCallEvent | ToolResultEvent;
+export type ExtensionEvent = ProjectTrustEvent | ResourcesDiscoverEvent | SessionEvent | ContextEvent | BeforeProviderRequestEvent | BeforeProviderHeadersEvent | AfterProviderResponseEvent | BeforeAgentStartEvent | AgentStartEvent | AgentEndEvent | AgentSettledEvent | UIPromptStartEvent | UIPromptEndEvent | TurnStartEvent | TurnEndEvent | MessageStartEvent | MessageUpdateEvent | MessageEndEvent | ToolExecutionStartEvent | ToolExecutionUpdateEvent | ToolExecutionEndEvent | ModelSelectEvent | ThinkingLevelSelectEvent | UserBashEvent | InputEvent | ToolCallEvent | ToolResultEvent;
 export interface ContextEventResult {
     messages?: AgentMessage[];
 }
@@ -894,6 +909,8 @@ export interface ExtensionAPI {
     on(event: "agent_start", handler: ExtensionHandler<AgentStartEvent>): void;
     on(event: "agent_end", handler: ExtensionHandler<AgentEndEvent>): void;
     on(event: "agent_settled", handler: ExtensionHandler<AgentSettledEvent>): void;
+    on(event: "ui_prompt_start", handler: ExtensionHandler<UIPromptStartEvent>): void;
+    on(event: "ui_prompt_end", handler: ExtensionHandler<UIPromptEndEvent>): void;
     on(event: "turn_start", handler: ExtensionHandler<TurnStartEvent>): void;
     on(event: "turn_end", handler: ExtensionHandler<TurnEndEvent>): void;
     on(event: "message_start", handler: ExtensionHandler<MessageStartEvent>): void;

package/dist/core/llama/client.d.ts

@@ -28,6 +28,9 @@ export interface LlamaModelsResponse {
     data: LlamaModelInfo[];
     object?: string;
 }
+export interface LlamaServerProps {
+    models_autoload?: boolean;
+}
 export interface LlamaModelEvent {
     model: string;
     event: string;
@@ -50,6 +53,9 @@ export declare class LlamaClient {
         reload?: boolean;
         signal?: AbortSignal;
     }): Promise<LlamaModelInfo[]>;
+    props(options?: {
+        signal?: AbortSignal;
+    }): Promise<LlamaServerProps>;
     load(model: string, signal?: AbortSignal): Promise<void>;
     unload(model: string, signal?: AbortSignal): Promise<void>;
     unloadAndWait(model: string, signal?: AbortSignal): Promise<void>;

package/dist/core/llama/client.js

@@ -150,6 +150,13 @@ export class LlamaClient {
             throw new Error("Server is not running in llama.cpp router mode");
         return data;
     }
+    async props(options = {}) {
+        const payload = await this.request("/props", { signal: options.signal });
+        if (typeof payload !== "object" || payload === null)
+            return {};
+        const { models_autoload: modelsAutoload } = payload;
+        return typeof modelsAutoload === "boolean" ? { models_autoload: modelsAutoload } : {};
+    }
     async load(model, signal) {
         await this.request("/models/load", { method: "POST", body: JSON.stringify({ model }), signal });
     }

package/dist/core/llama/provider.d.ts

@@ -4,6 +4,8 @@ export declare const LLAMA_PROVIDER_ID = "llama.cpp";
 export declare const DEFAULT_LLAMA_SERVER_URL = "http://127.0.0.1:8080";
 export interface LlamaProviderController {
     provider: Provider<"openai-completions">;
-    setCatalog(models: readonly LlamaModelInfo[], serverUrl: string): void;
+    setCatalog(models: readonly LlamaModelInfo[], serverUrl: string, options?: {
+        routerAutoload?: boolean;
+    }): void;
 }
 export declare function createLlamaProvider(): LlamaProviderController;

package/dist/core/llama/provider.js

@@ -10,6 +10,22 @@ async function resolveServerUrl(ctx, credential) {
     const configured = credentialServerUrl(credential) ?? (await ctx.env("LLAMA_BASE_URL"))?.trim();
     return configured ? normalizeLlamaServerUrl(configured) : undefined;
 }
+function modelIsSelectable(model, routerAutoload) {
+    if (model.status.value === "loaded")
+        return true;
+    // Unloaded presets are routable only when llama.cpp router autoload can load them on first use.
+    return routerAutoload && model.status.value === "unloaded" && !model.status.failed && model.source === "preset";
+}
+async function routerAutoloadEnabled(client, catalog, signal) {
+    if (!catalog.some((model) => model.status.value === "unloaded" && model.source === "preset"))
+        return false;
+    try {
+        return (await client.props({ signal })).models_autoload === true;
+    }
+    catch {
+        return false;
+    }
+}
 function toPiModel(model, serverUrl) {
     const reportedContextWindow = model.meta?.n_ctx ?? model.meta?.n_ctx_train;
     const contextWindow = reportedContextWindow && reportedContextWindow > 0 ? reportedContextWindow : 128000;
@@ -36,8 +52,10 @@ function toPiModel(model, serverUrl) {
 }
 export function createLlamaProvider() {
     let models = [];
-    const setCatalog = (catalog, serverUrl) => {
-        models = catalog.filter((model) => model.status.value === "loaded").map((model) => toPiModel(model, serverUrl));
+    const setCatalog = (catalog, serverUrl, options = {}) => {
+        models = catalog
+            .filter((model) => modelIsSelectable(model, options.routerAutoload === true))
+            .map((model) => toPiModel(model, serverUrl));
     };
     const provider = {
         id: LLAMA_PROVIDER_ID,
@@ -101,12 +119,16 @@ export function createLlamaProvider() {
             const serverUrl = credentialServerUrl(context.credential);
             if (!serverUrl)
                 return;
-            const catalog = await new LlamaClient(serverUrl, context.credential.key).list({ signal: context.signal });
-            const refreshed = catalog
-                .filter((model) => model.status.value === "loaded")
-                .map((model) => toPiModel(model, serverUrl));
+            const client = new LlamaClient(serverUrl, context.credential.key);
+            const catalog = await client.list({ signal: context.signal });
             if (context.signal.aborted)
                 return;
+            const routerAutoload = await routerAutoloadEnabled(client, catalog, context.signal);
+            if (context.signal.aborted)
+                return;
+            const refreshed = catalog
+                .filter((model) => modelIsSelectable(model, routerAutoload))
+                .map((model) => toPiModel(model, serverUrl));
             await context.publish({
                 persist: { models: refreshed, checkedAt: Date.now() },
                 update: () => {

package/dist/core/session-manager.js

@@ -279,11 +279,11 @@ export function loadEntriesFromFile(filePath) {
     if (!existsSync(resolvedFilePath))
         return [];
     const entries = [];
+    let pending = "";
     const fd = openSync(resolvedFilePath, "r");
     try {
         const decoder = new StringDecoder("utf8");
         const buffer = Buffer.allocUnsafe(SESSION_READ_BUFFER_SIZE);
-        let pending = "";
         while (true) {
             const bytesRead = readSync(fd, buffer, 0, buffer.length, null);
             if (bytesRead === 0)
@@ -308,13 +308,15 @@ export function loadEntriesFromFile(filePath) {
     finally {
         closeSync(fd);
     }
-    // Validate session header
+    // Validate session header before repairing the file.
     if (entries.length === 0)
         return entries;
     const header = entries[0];
     if (header.type !== "session" || typeof header.id !== "string") {
         return [];
     }
+    if (pending)
+        appendFileSync(resolvedFilePath, "\n");
     return entries;
 }
 /**