@sammorrowdrums/mcpi 0.70.9 → 0.85.0

package/dist/core/extensions/runner.js

@@ -16,6 +16,7 @@ const RESERVED_KEYBINDINGS_FOR_EXTENSION_CONFLICTS = [
     "app.tools.expand",
     "app.thinking.toggle",
     "app.editor.external",
+    "app.message.copy",
     "app.message.followUp",
     "tui.input.submit",
     "tui.select.confirm",
@@ -56,6 +57,34 @@ export async function emitSessionShutdownEvent(extensionRunner, event) {
     }
     return false;
 }
+export async function emitProjectTrustEvent(extensionsResult, event, ctx) {
+    const errors = [];
+    for (const ext of extensionsResult.extensions) {
+        // A single extension may register multiple handlers for the same event.
+        // The first project_trust handler that returns yes/no wins; undecided falls through.
+        const handlers = ext.handlers.get("project_trust");
+        if (!handlers || handlers.length === 0)
+            continue;
+        for (const handler of handlers) {
+            try {
+                const handlerResult = (await handler(event, ctx));
+                if (handlerResult.trusted === "undecided") {
+                    continue;
+                }
+                return { result: handlerResult, errors };
+            }
+            catch (error) {
+                errors.push({
+                    extensionPath: ext.path,
+                    event: event.type,
+                    error: error instanceof Error ? error.message : String(error),
+                    stack: error instanceof Error ? error.stack : undefined,
+                });
+            }
+        }
+    }
+    return { errors };
+}
 const noOpUIContext = {
     select: async () => undefined,
     confirm: async () => false,
@@ -64,6 +93,7 @@ const noOpUIContext = {
     onTerminalInput: () => () => { },
     setStatus: () => { },
     setWorkingMessage: () => { },
+    setWorkingVisible: () => { },
     setWorkingIndicator: () => { },
     setHiddenThinkingLabel: () => { },
     setWidget: () => { },
@@ -77,6 +107,7 @@ const noOpUIContext = {
     editor: async () => undefined,
     addAutocompleteProvider: () => { },
     setEditorComponent: () => { },
+    getEditorComponent: () => undefined,
     get theme() {
         return theme;
     },
@@ -90,12 +121,15 @@ export class ExtensionRunner {
     extensions;
     runtime;
     uiContext;
+    mode = "print";
     cwd;
     sessionManager;
     modelRegistry;
     errorListeners = new Set();
     getModel = () => undefined;
+    getScopedModels = () => [];
     isIdleFn = () => true;
+    isProjectTrustedFn = () => true;
     getSignalFn = () => undefined;
     waitForIdleFn = async () => { };
     abortFn = () => { };
@@ -103,6 +137,7 @@ export class ExtensionRunner {
     getContextUsageFn = () => undefined;
     compactFn = () => { };
     getSystemPromptFn = () => "";
+    getSystemPromptOptionsFn = () => ({ cwd: this.cwd });
     newSessionHandler = async () => ({ cancelled: false });
     forkHandler = async () => ({ cancelled: false });
     navigateTreeHandler = async () => ({ cancelled: false });
@@ -138,7 +173,9 @@ export class ExtensionRunner {
         this.runtime.setThinkingLevel = actions.setThinkingLevel;
         // Context actions (required)
         this.getModel = contextActions.getModel;
+        this.getScopedModels = contextActions.getScopedModels;
         this.isIdleFn = contextActions.isIdle;
+        this.isProjectTrustedFn = contextActions.isProjectTrusted;
         this.getSignalFn = contextActions.getSignal;
         this.abortFn = contextActions.abort;
         this.hasPendingMessagesFn = contextActions.hasPendingMessages;
@@ -146,6 +183,7 @@ export class ExtensionRunner {
         this.getContextUsageFn = contextActions.getContextUsage;
         this.compactFn = contextActions.compact;
         this.getSystemPromptFn = contextActions.getSystemPrompt;
+        this.getSystemPromptOptionsFn = contextActions.getSystemPromptOptions ?? (() => ({ cwd: this.cwd }));
         // Flush provider registrations queued during extension loading
         for (const { name, config, extensionPath } of this.runtime.pendingProviderRegistrations) {
             try {
@@ -166,6 +204,25 @@ export class ExtensionRunner {
             }
         }
         this.runtime.pendingProviderRegistrations = [];
+        for (const { provider, extensionPath } of this.runtime.pendingNativeProviderRegistrations) {
+            try {
+                if (providerActions?.registerNativeProvider) {
+                    providerActions.registerNativeProvider(provider);
+                }
+                else {
+                    this.modelRegistry.registerProvider(provider);
+                }
+            }
+            catch (err) {
+                this.emitError({
+                    extensionPath,
+                    event: "register_provider",
+                    error: err instanceof Error ? err.message : String(err),
+                    stack: err instanceof Error ? err.stack : undefined,
+                });
+            }
+        }
+        this.runtime.pendingNativeProviderRegistrations = [];
         // From this point on, provider registration/unregistration takes effect immediately
         // without requiring a /reload.
         this.runtime.registerProvider = (name, config) => {
@@ -175,6 +232,13 @@ export class ExtensionRunner {
             }
             this.modelRegistry.registerProvider(name, config);
         };
+        this.runtime.registerNativeProvider = (provider) => {
+            if (providerActions?.registerNativeProvider) {
+                providerActions.registerNativeProvider(provider);
+                return;
+            }
+            this.modelRegistry.registerProvider(provider);
+        };
         this.runtime.unregisterProvider = (name) => {
             if (providerActions?.unregisterProvider) {
                 providerActions.unregisterProvider(name);
@@ -200,8 +264,9 @@ export class ExtensionRunner {
         this.switchSessionHandler = async () => ({ cancelled: false });
         this.reloadHandler = async () => { };
     }
-    setUIContext(uiContext) {
+    setUIContext(uiContext, mode = "print") {
         this.uiContext = uiContext ?? noOpUIContext;
+        this.mode = mode;
     }
     getUIContext() {
         return this.uiContext;
@@ -251,8 +316,12 @@ export class ExtensionRunner {
     getFlagValues() {
         return new Map(this.runtime.flagValues);
     }
+    /**
+     * Session-scoped environment mutations set by extensions via `pi.setEnv()`.
+     * A `null` value masks a variable inherited from mcpi's own environment.
+     */
     getSessionEnv() {
-        return this.runtime.sessionEnv;
+        return new Map(this.runtime.sessionEnv);
     }
     getShortcuts(resolvedKeybindings) {
         this.shortcutDiagnostics = [];
@@ -325,6 +394,18 @@ export class ExtensionRunner {
         }
         return undefined;
     }
+    getMarkdownTransformers() {
+        return this.extensions.flatMap((ext) => (ext.markdownTransformer ? [ext.markdownTransformer] : []));
+    }
+    getEntryRenderer(customType) {
+        for (const ext of this.extensions) {
+            const renderer = ext.entryRenderers?.get(customType);
+            if (renderer) {
+                return renderer;
+            }
+        }
+        return undefined;
+    }
     resolveRegisteredCommands() {
         const commands = [];
         const counts = new Map();
@@ -354,6 +435,9 @@ export class ExtensionRunner {
             };
         });
     }
+    getModelRegistry() {
+        return this.modelRegistry;
+    }
     getRegisteredCommands() {
         this.commandDiagnostics = [];
         return this.resolveRegisteredCommands();
@@ -371,6 +455,10 @@ export class ExtensionRunner {
     shutdown() {
         this.shutdownHandler();
     }
+    getActiveTools() {
+        this.assertActive();
+        return this.runtime.getActiveTools();
+    }
     /**
      * Create an ExtensionContext for use in event handlers and tool execution.
      * Context values are resolved at call time, so changes via bindCore/bindUI are reflected.
@@ -378,11 +466,16 @@ export class ExtensionRunner {
     createContext() {
         const runner = this;
         const getModel = this.getModel;
+        const getScopedModels = this.getScopedModels;
         return {
             get ui() {
                 runner.assertActive();
                 return runner.uiContext;
             },
+            get mode() {
+                runner.assertActive();
+                return runner.mode;
+            },
             get hasUI() {
                 runner.assertActive();
                 return runner.hasUI();
@@ -403,10 +496,22 @@ export class ExtensionRunner {
                 runner.assertActive();
                 return getModel();
             },
+            get scopedModels() {
+                runner.assertActive();
+                return getScopedModels();
+            },
+            get thinkingLevel() {
+                runner.assertActive();
+                return runner.runtime.getThinkingLevel();
+            },
             isIdle: () => {
                 runner.assertActive();
                 return runner.isIdleFn();
             },
+            isProjectTrusted: () => {
+                runner.assertActive();
+                return runner.isProjectTrustedFn();
+            },
             get signal() {
                 runner.assertActive();
                 return runner.getSignalFn();
@@ -442,6 +547,10 @@ export class ExtensionRunner {
         // createContext() stay lazy. A spread would eagerly read them once and freeze the
         // old values into the returned object, bypassing stale-instance checks.
         const context = Object.defineProperties({}, Object.getOwnPropertyDescriptors(this.createContext()));
+        context.getSystemPromptOptions = () => {
+            this.assertActive();
+            return this.getSystemPromptOptionsFn();
+        };
         context.waitForIdle = () => {
             this.assertActive();
             return this.waitForIdleFn();
@@ -505,6 +614,45 @@ export class ExtensionRunner {
         }
         return result;
     }
+    async emitMessageEnd(event) {
+        const ctx = this.createContext();
+        let currentMessage = event.message;
+        let modified = false;
+        for (const ext of this.extensions) {
+            const handlers = ext.handlers.get("message_end");
+            if (!handlers || handlers.length === 0)
+                continue;
+            for (const handler of handlers) {
+                try {
+                    const currentEvent = { ...event, message: currentMessage };
+                    const handlerResult = (await handler(currentEvent, ctx));
+                    if (!handlerResult?.message)
+                        continue;
+                    if (handlerResult.message.role !== currentMessage.role) {
+                        this.emitError({
+                            extensionPath: ext.path,
+                            event: "message_end",
+                            error: "message_end handlers must return a message with the same role",
+                        });
+                        continue;
+                    }
+                    currentMessage = handlerResult.message;
+                    modified = true;
+                }
+                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: "message_end",
+                        error: message,
+                        stack,
+                    });
+                }
+            }
+        }
+        return modified ? currentMessage : undefined;
+    }
     async emitToolResult(event) {
         const ctx = this.createContext();
         const currentEvent = { ...event };
@@ -530,6 +678,10 @@ export class ExtensionRunner {
                         currentEvent.isError = handlerResult.isError;
                         modified = true;
                     }
+                    if (handlerResult.usage !== undefined) {
+                        currentEvent.usage = handlerResult.usage;
+                        modified = true;
+                    }
                 }
                 catch (err) {
                     const message = err instanceof Error ? err.message : String(err);
@@ -550,6 +702,7 @@ export class ExtensionRunner {
             content: currentEvent.content,
             details: currentEvent.details,
             isError: currentEvent.isError,
+            usage: currentEvent.usage,
         };
     }
     async emitToolCall(event) {
@@ -659,6 +812,35 @@ export class ExtensionRunner {
         }
         return currentPayload;
     }
+    async emitBeforeProviderHeaders(headers) {
+        const ctx = this.createContext();
+        for (const ext of this.extensions) {
+            const handlers = ext.handlers.get("before_provider_headers");
+            if (!handlers || handlers.length === 0)
+                continue;
+            for (const handler of handlers) {
+                try {
+                    // Handlers mutate `headers` in place; the return value is ignored.
+                    const event = {
+                        type: "before_provider_headers",
+                        headers,
+                    };
+                    await handler(event, ctx);
+                }
+                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: "before_provider_headers",
+                        error: message,
+                        stack,
+                    });
+                }
+            }
+        }
+        return headers;
+    }
     async emitBeforeAgentStart(prompt, images, systemPrompt, systemPromptOptions) {
         let currentSystemPrompt = systemPrompt;
         const ctx = Object.defineProperties({}, Object.getOwnPropertyDescriptors(this.createContext()));
@@ -752,14 +934,20 @@ export class ExtensionRunner {
         return { skillPaths, promptPaths, themePaths };
     }
     /** Emit input event. Transforms chain, "handled" short-circuits. */
-    async emitInput(text, images, source) {
+    async emitInput(text, images, source, streamingBehavior) {
         const ctx = this.createContext();
         let currentText = text;
         let currentImages = images;
         for (const ext of this.extensions) {
             for (const handler of ext.handlers.get("input") ?? []) {
                 try {
-                    const event = { type: "input", text: currentText, images: currentImages, source };
+                    const event = {
+                        type: "input",
+                        text: currentText,
+                        images: currentImages,
+                        source,
+                        streamingBehavior,
+                    };
                     const result = (await handler(event, ctx));
                     if (result?.action === "handled")
                         return result;