@selesai/code 0.13.39 → 0.14.0

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

@@ -2,7 +2,7 @@
  * Extension runner - executes extensions and manages their lifecycle.
  */
 import type { AgentMessage } from "@earendil-works/pi-agent-core";
-import type { ImageContent, Provider, ProviderHeaders } from "@earendil-works/pi-ai";
+import { type ImageContent, type Provider, type ProviderHeaders } from "@earendil-works/pi-ai";
 import type { KeyId } from "@earendil-works/pi-tui";
 import type { CacheWarmingAction } from "../cache-warmer.ts";
 import type { ResourceDiagnostic } from "../diagnostics.ts";
@@ -10,7 +10,8 @@ import type { KeybindingsConfig } from "../keybindings.ts";
 import type { ModelRegistry } from "../model-registry.ts";
 import type { SessionManager } from "../session-manager.ts";
 import { type BuildSystemPromptOptions, type NormalizedBuildSystemPromptOptions } from "../system-prompt.ts";
-import type { BeforeAgentStartEvent, BeforeAgentStartEventResult, BeforeProviderHeadersEvent, BeforeProviderRequestEvent, CacheWarmingDecisionEvent, ContextEvent, EntryRenderer, Extension, ExtensionActions, ExtensionCommandContext, ExtensionCommandContextActions, ExtensionContext, ExtensionContextActions, ExtensionError, ExtensionEvent, ExtensionFlag, ExtensionMode, ExtensionRuntime, ExtensionShortcut, ExtensionUIContext, InputEvent, InputEventResult, InputSource, LoadExtensionsResult, MessageEndEvent, MessageRenderer, ProjectTrustContext, ProjectTrustEvent, ProjectTrustEventResult, ProviderConfig, RegisteredTool, ReplacedSessionContext, ResolvedCommand, ResourcesDiscoverEvent, SessionBeforeCompactResult, SessionBeforeForkResult, SessionBeforeSwitchResult, SessionBeforeTreeResult, SessionShutdownEvent, ToolCallEvent, ToolCallEventResult, ToolResultEvent, ToolResultEventResult, UserBashEvent, UserBashEventResult } from "./types.ts";
+import type { VirtualModelDefinition } from "../virtual-models.ts";
+import type { AgentBeforeSettleEvent, BeforeAgentStartEvent, BeforeAgentStartEventResult, BeforeProviderHeadersEvent, BeforeProviderRequestEvent, BoundaryContextPreview, CacheWarmingDecisionEvent, ContextEvent, ContextWithSystemEvent, EntryRenderer, Extension, ExtensionActions, ExtensionCommandContext, ExtensionCommandContextActions, ExtensionContext, ExtensionContextActions, ExtensionError, ExtensionEvent, ExtensionFlag, ExtensionMode, ExtensionRuntime, ExtensionShortcut, ExtensionToolContext, ExtensionUIContext, InputEvent, InputEventResult, InputSource, LoadExtensionsResult, MarkdownTransformer, MessageEndEvent, MessageRenderer, ProjectTrustContext, ProjectTrustEvent, ProjectTrustEventResult, ProviderConfig, RegisteredTool, ReplacedSessionContext, ResolvedCommand, ResourcesDiscoverEvent, SessionBeforeCompactResult, SessionBeforeForkResult, SessionBeforeSwitchResult, SessionBeforeTreeResult, SessionBoundaryDraft, SessionShutdownEvent, ToolCallEvent, ToolCallEventResult, ToolRenderers, ToolResultEvent, ToolResultEventResult, TurnEndEvent, UserBashEvent, UserBashEventResult } from "./types.ts";
 /** Combined result from all before_agent_start handlers. */
 interface BeforeAgentStartCombinedResult {
     messages: NonNullable<BeforeAgentStartEventResult["message"]>[];
@@ -20,7 +21,7 @@ interface BeforeAgentStartCombinedResult {
  * Events handled by the generic emit() method.
  * Events with dedicated emitXxx() methods are excluded for stronger type safety.
  */
-type RunnerEmitEvent = Exclude<ExtensionEvent, ToolCallEvent | ProjectTrustEvent | ToolResultEvent | UserBashEvent | ContextEvent | CacheWarmingDecisionEvent | BeforeProviderRequestEvent | BeforeProviderHeadersEvent | BeforeAgentStartEvent | MessageEndEvent | ResourcesDiscoverEvent | InputEvent>;
+type RunnerEmitEvent = Exclude<ExtensionEvent, ToolCallEvent | ProjectTrustEvent | ToolResultEvent | UserBashEvent | ContextEvent | ContextWithSystemEvent | CacheWarmingDecisionEvent | BeforeProviderRequestEvent | BeforeProviderHeadersEvent | BeforeAgentStartEvent | MessageEndEvent | ResourcesDiscoverEvent | InputEvent | TurnEndEvent | AgentBeforeSettleEvent>;
 type RunnerEmitResult<TEvent extends RunnerEmitEvent> = TEvent extends {
     type: "session_before_switch";
 } ? SessionBeforeSwitchResult | undefined : TEvent extends {
@@ -31,6 +32,13 @@ type RunnerEmitResult<TEvent extends RunnerEmitEvent> = TEvent extends {
     type: "session_before_tree";
 } ? SessionBeforeTreeResult | undefined : undefined;
 export type ExtensionErrorListener = (error: ExtensionError) => void;
+type BoundaryBaseEvent = Omit<TurnEndEvent, "entries" | "continue" | "context"> | Omit<AgentBeforeSettleEvent, "entries" | "continue" | "context">;
+interface BoundaryDispatchResult {
+    entries: SessionBoundaryDraft[];
+    continue: boolean;
+    context: BoundaryContextPreview;
+    valid: boolean;
+}
 export type NewSessionHandler = (options?: {
     parentSession?: string;
     setup?: (sessionManager: SessionManager) => Promise<void>;
@@ -73,8 +81,6 @@ export declare class ExtensionRunner {
     private runtime;
     private uiContext;
     private mode;
-    private uiPromptDepth;
-    private activeUIPrompt;
     private cwd;
     private sessionManager;
     private modelRegistry;
@@ -91,6 +97,10 @@ export declare class ExtensionRunner {
     private compactFn;
     private getSystemPromptFn;
     private getSystemPromptOptionsFn;
+    private executeToolFn;
+    private getCallableToolsFn;
+    /** Registered MCP servers already reported as unhandled. */
+    private readonly reportedMcpServers;
     private newSessionHandler;
     private forkHandler;
     private navigateTreeHandler;
@@ -100,11 +110,15 @@ export declare class ExtensionRunner {
     private shortcutDiagnostics;
     private commandDiagnostics;
     private staleMessage;
+    private uiPromptDepth;
+    private activeUIPrompt;
     constructor(extensions: Extension[], runtime: ExtensionRuntime, cwd: string, sessionManager: SessionManager, modelRegistry: ModelRegistry);
     bindCore(actions: ExtensionActions, contextActions: ExtensionContextActions, providerActions?: {
         registerProvider?: (name: string, config: ProviderConfig) => void;
         registerNativeProvider?: (provider: Provider) => void;
         unregisterProvider?: (name: string) => void;
+        registerVirtualModel?: (definition: VirtualModelDefinition) => void;
+        unregisterVirtualModel?: (provider: string, id: string) => void;
     }): void;
     bindCommandContext(actions?: ExtensionCommandContextActions): void;
     setUIContext(uiContext?: ExtensionUIContext, mode?: ExtensionMode): void;
@@ -127,8 +141,16 @@ export declare class ExtensionRunner {
     private assertActive;
     onError(listener: ExtensionErrorListener): () => void;
     emitError(error: ExtensionError): void;
+    /**
+     * Report registered MCP servers when no extension handles `mcp_servers_change`, which means
+     * nothing connects them (for example when another MCP extension replaced the built-in one).
+     */
+    reportUnhandledMcpServers(): void;
     hasHandlers(eventType: string): boolean;
     getMessageRenderer(customType: string): MessageRenderer | undefined;
+    getMarkdownTransformers(): MarkdownTransformer[];
+    /** Renderers of calls to `toolName`: extension resolvers in load order, then `base`. */
+    resolveToolRenderers(toolName: string, base: () => ToolRenderers | undefined): ToolRenderers | undefined;
     getEntryRenderer(customType: string): EntryRenderer | undefined;
     private resolveRegisteredCommands;
     getModelRegistry(): ModelRegistry;
@@ -146,7 +168,13 @@ export declare class ExtensionRunner {
      * Context values are resolved at call time, so changes via bindCore/bindUI are reflected.
      */
     createContext(): ExtensionContext;
+    /**
+     * Create the context for executing the tool call `toolCallId`: the extension context plus
+     * `tools` and `executeTool()`. `signal` is the default signal of nested calls.
+     */
+    createToolContext(toolCallId: string, signal: AbortSignal | undefined): ExtensionToolContext;
     createCommandContext(): ExtensionCommandContext;
+    emitBoundary(baseEvent: BoundaryBaseEvent, buildContext: (entries: SessionBoundaryDraft[]) => BoundaryContextPreview | Promise<BoundaryContextPreview>): Promise<BoundaryDispatchResult>;
     private isSessionBeforeEvent;
     emit<TEvent extends RunnerEmitEvent>(event: TEvent): Promise<RunnerEmitResult<TEvent>>;
     /** Returns the event's own action unless a handler overrides it; the last override wins. */
@@ -155,6 +183,11 @@ export declare class ExtensionRunner {
     emitToolResult(event: ToolResultEvent): Promise<ToolResultEventResult | undefined>;
     emitToolCall(event: ToolCallEvent): Promise<ToolCallEventResult | undefined>;
     emitUserBash(event: UserBashEvent): Promise<UserBashEventResult | undefined>;
+    /**
+     * Run the request-time transforms in two phases. `context` handlers see the conversation
+     * only and Pi restores the prompt and tool state after each; `context_with_system`
+     * handlers then see the full transcript and their output is used as returned.
+     */
     emitContext(messages: AgentMessage[]): Promise<AgentMessage[]>;
     emitBeforeProviderRequest(payload: unknown): Promise<unknown>;
     emitBeforeProviderHeaders(headers: ProviderHeaders): Promise<ProviderHeaders>;

package/dist/core/extensions/runner.js

@@ -1,6 +1,7 @@
 /**
  * Extension runner - executes extensions and manages their lifecycle.
  */
+import { getCurrentSystemMessage, } from "@earendil-works/pi-ai";
 import { theme } from "../../modes/interactive/theme/theme.js";
 import { buildSystemPrompt, normalizeBuildSystemPromptOptions, } from "../system-prompt.js";
 // Extension shortcuts compete with canonical keybinding ids from keybindings.json.
@@ -86,6 +87,23 @@ export async function emitSessionShutdownEvent(extensionRunner, event) {
 function snapshotEventHandlers(extensions, event) {
     return extensions.map((ext) => ({ ext, handlers: ext.handlers.get(event)?.slice() ?? [] }));
 }
+function sameMessages(left, right) {
+    return left.length === right.length && left.every((message, index) => message === right[index]);
+}
+/**
+ * Re-attach the prompt and tool state after a `context` handler. Handlers only see the
+ * conversation; the system messages belong to Pi. An unchanged conversation keeps every
+ * system message in place, so models with mid-conversation support keep their cached
+ * prefix. A changed one gets the replayed prompt sections and tool declarations as one
+ * leading system message, so pruning, windowing, or slicing from a compaction summary
+ * cannot drop them.
+ */
+function restoreSystemMessages(current, visible, returned) {
+    if (sameMessages(returned, visible))
+        return current;
+    const head = getCurrentSystemMessage(current);
+    return head ? [head, ...returned] : returned;
+}
 export async function emitProjectTrustEvent(extensionsResult, event, ctx) {
     const errors = [];
     for (const { ext, handlers } of snapshotEventHandlers(extensionsResult.extensions, "project_trust")) {
@@ -148,8 +166,6 @@ export class ExtensionRunner {
     runtime;
     uiContext;
     mode = "print";
-    uiPromptDepth = 0;
-    activeUIPrompt;
     cwd;
     sessionManager;
     modelRegistry;
@@ -166,6 +182,10 @@ export class ExtensionRunner {
     compactFn = () => { };
     getSystemPromptFn = () => "";
     getSystemPromptOptionsFn = () => normalizeBuildSystemPromptOptions({ cwd: this.cwd });
+    executeToolFn;
+    getCallableToolsFn = () => [];
+    /** Registered MCP servers already reported as unhandled. */
+    reportedMcpServers = new Set();
     newSessionHandler = async () => ({ cancelled: false });
     forkHandler = async () => ({ cancelled: false });
     navigateTreeHandler = async () => ({ cancelled: false });
@@ -175,6 +195,8 @@ export class ExtensionRunner {
     shortcutDiagnostics = [];
     commandDiagnostics = [];
     staleMessage;
+    uiPromptDepth = 0;
+    activeUIPrompt;
     constructor(extensions, runtime, cwd, sessionManager, modelRegistry) {
         this.extensions = extensions;
         this.runtime = runtime;
@@ -193,6 +215,7 @@ export class ExtensionRunner {
         this.runtime.setLabel = actions.setLabel;
         this.runtime.getActiveTools = actions.getActiveTools;
         this.runtime.getAllTools = actions.getAllTools;
+        this.runtime.getSettings = actions.getSettings;
         this.runtime.setActiveTools = actions.setActiveTools;
         this.runtime.getResolvedSkills = actions.getResolvedSkills;
         this.runtime.setSkillsIndexFilter = actions.setSkillsIndexFilter;
@@ -201,6 +224,7 @@ export class ExtensionRunner {
         this.runtime.setModel = actions.setModel;
         this.runtime.getThinkingLevel = actions.getThinkingLevel;
         this.runtime.setThinkingLevel = actions.setThinkingLevel;
+        this.runtime.createContext = () => this.createContext();
         // Context actions (required)
         this.getModel = contextActions.getModel;
         this.getScopedModels = contextActions.getScopedModels;
@@ -215,6 +239,14 @@ export class ExtensionRunner {
         this.getSystemPromptFn = contextActions.getSystemPrompt;
         this.getSystemPromptOptionsFn =
             contextActions.getSystemPromptOptions ?? (() => normalizeBuildSystemPromptOptions({ cwd: this.cwd }));
+        this.executeToolFn = contextActions.executeTool;
+        this.getCallableToolsFn = contextActions.getCallableTools ?? (() => []);
+        // Servers registered from now on reach the extension that connects them right away. Servers
+        // registered during loading are read on session_start.
+        this.runtime.mcpServers.setChangeListener(() => {
+            void this.emit({ type: "mcp_servers_change", servers: this.runtime.mcpServers.list() });
+            this.reportUnhandledMcpServers();
+        });
         // Flush provider registrations queued during extension loading
         for (const { name, config, extensionPath } of this.runtime.pendingProviderRegistrations) {
             try {
@@ -254,6 +286,26 @@ export class ExtensionRunner {
             }
         }
         this.runtime.pendingNativeProviderRegistrations = [];
+        const registerVirtualModel = (definition) => {
+            if (providerActions?.registerVirtualModel)
+                providerActions.registerVirtualModel(definition);
+            else
+                this.modelRegistry.registerVirtualModel(definition);
+        };
+        for (const { definition, extensionPath } of this.runtime.pendingVirtualModelRegistrations) {
+            try {
+                registerVirtualModel(definition);
+            }
+            catch (err) {
+                this.emitError({
+                    extensionPath,
+                    event: "register_virtual_model",
+                    error: err instanceof Error ? err.message : String(err),
+                    stack: err instanceof Error ? err.stack : undefined,
+                });
+            }
+        }
+        this.runtime.pendingVirtualModelRegistrations = [];
         // From this point on, provider registration/unregistration takes effect immediately
         // without requiring a /reload.
         this.runtime.registerProvider = (name, config) => {
@@ -277,6 +329,13 @@ export class ExtensionRunner {
             }
             this.modelRegistry.unregisterProvider(name);
         };
+        this.runtime.registerVirtualModel = registerVirtualModel;
+        this.runtime.unregisterVirtualModel = (provider, id) => {
+            if (providerActions?.unregisterVirtualModel)
+                providerActions.unregisterVirtualModel(provider, id);
+            else
+                this.modelRegistry.unregisterVirtualModel(provider, id);
+        };
     }
     bindCommandContext(actions) {
         if (actions) {
@@ -445,6 +504,24 @@ export class ExtensionRunner {
             listener(error);
         }
     }
+    /**
+     * Report registered MCP servers when no extension handles `mcp_servers_change`, which means
+     * nothing connects them (for example when another MCP extension replaced the built-in one).
+     */
+    reportUnhandledMcpServers() {
+        if (this.hasHandlers("mcp_servers_change"))
+            return;
+        for (const server of this.runtime.mcpServers.list()) {
+            if (this.reportedMcpServers.has(server.name))
+                continue;
+            this.reportedMcpServers.add(server.name);
+            this.emitError({
+                extensionPath: server.extensionPath,
+                event: "register_mcp_server",
+                error: `MCP server "${server.name}" is registered, but no loaded extension connects MCP servers; another extension may have replaced the built-in MCP support`,
+            });
+        }
+    }
     hasHandlers(eventType) {
         for (const ext of this.extensions) {
             const handlers = ext.handlers.get(eventType);
@@ -463,6 +540,15 @@ export class ExtensionRunner {
         }
         return undefined;
     }
+    getMarkdownTransformers() {
+        return this.extensions.flatMap((ext) => (ext.markdownTransformer ? [ext.markdownTransformer] : []));
+    }
+    /** Renderers of calls to `toolName`: extension resolvers in load order, then `base`. */
+    resolveToolRenderers(toolName, base) {
+        const resolvers = this.extensions.flatMap((ext) => ext.toolRenderers ?? []);
+        const resolve = (index) => index < resolvers.length ? resolvers[index](toolName, () => resolve(index + 1)) : base();
+        return resolve(0);
+    }
     getEntryRenderer(customType) {
         for (const ext of this.extensions) {
             const renderer = ext.entryRenderers?.get(customType);
@@ -608,6 +694,38 @@ export class ExtensionRunner {
             },
         };
     }
+    /**
+     * Create the context for executing the tool call `toolCallId`: the extension context plus
+     * `tools` and `executeTool()`. `signal` is the default signal of nested calls.
+     */
+    createToolContext(toolCallId, signal) {
+        const runner = this;
+        // createContext() returns a fresh object, so adding properties does not affect other contexts.
+        return Object.defineProperties(this.createContext(), {
+            tools: {
+                get() {
+                    runner.assertActive();
+                    return runner.getCallableToolsFn();
+                },
+            },
+            executeTool: {
+                value: async (name, args, options = {}) => {
+                    runner.assertActive();
+                    if (!runner.executeToolFn) {
+                        return {
+                            toolCall: { type: "toolCall", id: `${toolCallId}/0`, name, arguments: {} },
+                            result: {
+                                content: [{ type: "text", text: "Nested tool calls are not available in this context" }],
+                                details: {},
+                            },
+                            isError: true,
+                        };
+                    }
+                    return runner.executeToolFn(toolCallId, name, args, { ...options, signal: options.signal ?? signal });
+                },
+            },
+        });
+    }
     createCommandContext() {
         // Use property descriptors instead of object spread so the guarded getters from
         // createContext() stay lazy. A spread would eagerly read them once and freeze the
@@ -643,6 +761,54 @@ export class ExtensionRunner {
         };
         return context;
     }
+    async emitBoundary(baseEvent, buildContext) {
+        const ctx = this.createContext();
+        let entries = [];
+        let shouldContinue = false;
+        let context = await buildContext(entries);
+        let valid = true;
+        for (const { ext, handlers } of snapshotEventHandlers(this.extensions, baseEvent.type)) {
+            for (const handler of handlers) {
+                const event = {
+                    ...baseEvent,
+                    entries,
+                    continue: shouldContinue,
+                    context,
+                };
+                try {
+                    const handlerResult = (await handler(event, ctx));
+                    if (handlerResult?.entries !== undefined)
+                        entries = handlerResult.entries;
+                    if (handlerResult?.continue !== undefined)
+                        shouldContinue = handlerResult.continue;
+                }
+                catch (err) {
+                    this.emitError({
+                        extensionPath: ext.path,
+                        event: baseEvent.type,
+                        error: err instanceof Error ? err.message : String(err),
+                        stack: err instanceof Error ? err.stack : undefined,
+                    });
+                }
+                try {
+                    context = await buildContext(entries);
+                    valid = true;
+                }
+                catch (err) {
+                    valid = false;
+                    this.emitError({
+                        extensionPath: ext.path,
+                        event: baseEvent.type,
+                        error: `Invalid boundary entries: ${err instanceof Error ? err.message : String(err)}`,
+                        stack: err instanceof Error ? err.stack : undefined,
+                    });
+                }
+            }
+        }
+        return valid
+            ? { entries, continue: shouldContinue, context, valid: true }
+            : { entries: [], continue: false, context, valid: false };
+    }
     isSessionBeforeEvent(event) {
         return (event.type === "session_before_switch" ||
             event.type === "session_before_fork" ||
@@ -749,12 +915,19 @@ export class ExtensionRunner {
                         continue;
                     if (handlerResult.content !== undefined) {
                         currentEvent.content = handlerResult.content;
+                        // Structured content that is not replaced along with the content may no longer match it.
+                        if (handlerResult.structuredContent === undefined)
+                            delete currentEvent.structuredContent;
                         modified = true;
                     }
                     if (handlerResult.details !== undefined) {
                         currentEvent.details = handlerResult.details;
                         modified = true;
                     }
+                    if (handlerResult.structuredContent !== undefined) {
+                        currentEvent.structuredContent = handlerResult.structuredContent;
+                        modified = true;
+                    }
                     if (handlerResult.isError !== undefined) {
                         currentEvent.isError = handlerResult.isError;
                         modified = true;
@@ -786,6 +959,7 @@ export class ExtensionRunner {
         return {
             content: currentEvent.content,
             details: currentEvent.details,
+            structuredContent: currentEvent.structuredContent,
             isError: currentEvent.isError,
             usage: currentEvent.usage,
             terminate,
@@ -835,17 +1009,27 @@ export class ExtensionRunner {
         }
         return undefined;
     }
+    /**
+     * Run the request-time transforms in two phases. `context` handlers see the conversation
+     * only and Pi restores the prompt and tool state after each; `context_with_system`
+     * handlers then see the full transcript and their output is used as returned.
+     */
     async emitContext(messages) {
         const ctx = this.createContext();
         let currentMessages = structuredClone(messages);
         for (const { ext, handlers } of snapshotEventHandlers(this.extensions, "context")) {
             for (const handler of handlers) {
                 try {
-                    const event = { type: "context", messages: currentMessages };
-                    const handlerResult = await handler(event, ctx);
-                    if (handlerResult && handlerResult.messages) {
-                        currentMessages = handlerResult.messages;
-                    }
+                    const visibleMessages = currentMessages.filter((message) => message.role !== "system");
+                    const visibleSnapshot = visibleMessages.slice();
+                    const event = { type: "context", messages: visibleMessages };
+                    const handlerResult = (await handler(event, ctx));
+                    // Handlers may return a new list or edit event.messages in place.
+                    const returned = handlerResult?.messages ??
+                        (sameMessages(visibleMessages, visibleSnapshot) ? undefined : visibleMessages);
+                    if (!returned)
+                        continue;
+                    currentMessages = restoreSystemMessages(currentMessages, visibleSnapshot, returned);
                 }
                 catch (err) {
                     const message = err instanceof Error ? err.message : String(err);
@@ -859,6 +1043,35 @@ export class ExtensionRunner {
                 }
             }
         }
+        for (const { ext, handlers } of snapshotEventHandlers(this.extensions, "context_with_system")) {
+            for (const handler of handlers) {
+                try {
+                    const hadLeadingSystemMessage = currentMessages[0]?.role === "system";
+                    const event = { type: "context_with_system", messages: currentMessages };
+                    const handlerResult = (await handler(event, ctx));
+                    currentMessages = handlerResult?.messages ?? currentMessages;
+                    // Providers read the prompt and initial tools from the leading system message.
+                    // Losing it is never intended; report it but honor the handler's output.
+                    if (hadLeadingSystemMessage && currentMessages[0]?.role !== "system") {
+                        this.emitError({
+                            extensionPath: ext.path,
+                            event: "context_with_system",
+                            error: "Handler removed the leading system message; the request has no prompt or initial tool declarations. Keep it at index 0 or replace a dropped prefix with getCurrentSystemMessage().",
+                        });
+                    }
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    const stack = err instanceof Error ? err.stack : undefined;
+                    this.emitError({
+                        extensionPath: ext.path,
+                        event: "context_with_system",
+                        error: message,
+                        stack,
+                    });
+                }
+            }
+        }
         return currentMessages;
     }
     async emitBeforeProviderRequest(payload) {