@bastani/atomic 0.8.31-alpha.5 → 0.9.0-alpha.2

package/dist/core/extensions/runner.js

@@ -1,50 +1,12 @@
 /**
  * Extension runner - executes extensions and manages their lifecycle.
  */
-import { theme } from "../../modes/interactive/theme/theme.js";
-// Extension shortcuts compete with canonical keybinding ids from keybindings.json.
-// Only editor-global shortcuts are reserved here. Picker-specific bindings are not.
-const RESERVED_KEYBINDINGS_FOR_EXTENSION_CONFLICTS = [
-    "app.interrupt",
-    "app.clear",
-    "app.exit",
-    "app.suspend",
-    "app.thinking.cycle",
-    "app.model.cycleForward",
-    "app.model.cycleBackward",
-    "app.model.select",
-    "app.tools.expand",
-    "app.thinking.toggle",
-    "app.editor.external",
-    "app.message.followUp",
-    "tui.input.submit",
-    "tui.select.confirm",
-    "tui.select.cancel",
-    "tui.input.copy",
-    "tui.editor.deleteToLineEnd",
-];
-const buildBuiltinKeybindings = (resolvedKeybindings) => {
-    const builtinKeybindings = {};
-    for (const [keybinding, keys] of Object.entries(resolvedKeybindings)) {
-        if (keys === undefined)
-            continue;
-        const keyList = Array.isArray(keys) ? keys : [keys];
-        const restrictOverride = RESERVED_KEYBINDINGS_FOR_EXTENSION_CONFLICTS.includes(keybinding);
-        for (const key of keyList) {
-            const normalizedKey = key.toLowerCase();
-            // If multiple actions bind the same key, the reserved action wins so extensions
-            // remain blocked by reserved shortcuts regardless of iteration order.
-            const existing = builtinKeybindings[normalizedKey];
-            if (existing?.restrictOverride && !restrictOverride)
-                continue;
-            builtinKeybindings[normalizedKey] = {
-                keybinding,
-                restrictOverride,
-            };
-        }
-    }
-    return builtinKeybindings;
-};
+import { createExtensionCommandContext, createExtensionContext, } from "./runner-context.js";
+import { runBeforeAgentStartHandlers, runBeforeProviderRequestHandlers, runContextHandlers, runGenericHandlers, runInputHandlers, runMessageEndHandlers, runResourcesDiscoverHandlers, runToolCallHandlers, runToolResultHandlers, runUserBashHandlers, } from "./runner-events.js";
+import { collectFlags, collectRegisteredTools, findMessageRenderer, findToolDefinition, hasExtensionHandlers, resolveRegisteredCommands, } from "./runner-registries.js";
+import { resolveExtensionShortcuts } from "./runner-shortcuts.js";
+import { noOpUIContext } from "./runner-ui.js";
+export { emitProjectTrustEvent } from "./runner-project-trust.js";
 /**
  * Helper function to emit session_shutdown event to extensions.
  * Returns true if the event was emitted, false if there were no handlers.
@@ -56,80 +18,6 @@ export async function emitSessionShutdownEvent(extensionRunner, event) {
     }
     return false;
 }
-export async function emitProjectTrustEvent(extensionsResult, event, ctx) {
-    const errors = [];
-    for (const ext of extensionsResult.extensions) {
-        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,
-    input: async () => undefined,
-    notify: () => { },
-    requestRender: () => { },
-    onTerminalInput: () => () => { },
-    setStatus: () => { },
-    setWorkingMessage: () => { },
-    setWorkingVisible: () => { },
-    setWorkingIndicator: () => { },
-    setHiddenThinkingLabel: () => { },
-    setWidget: () => { },
-    setFooter: () => { },
-    setHeader: () => { },
-    setTitle: () => { },
-    custom: async () => undefined,
-    pasteToEditor: () => { },
-    setEditorText: () => { },
-    getEditorText: () => "",
-    editor: async () => undefined,
-    addAutocompleteProvider: () => { },
-    setEditorComponent: () => { },
-    getEditorComponent: () => undefined,
-    getFooterDataProvider: () => ({
-        getGitBranch: () => null,
-        getExtensionStatuses: () => new Map(),
-        getAvailableProviderCount: () => 1,
-        onBranchChange: () => () => { },
-    }),
-    get theme() {
-        return theme;
-    },
-    getAllThemes: () => [],
-    getTheme: () => undefined,
-    setTheme: (_theme) => ({ success: false, error: "UI not available" }),
-    getToolsExpanded: () => false,
-    setToolsExpanded: () => { },
-    getChatRenderSettings: () => ({
-        hideThinkingBlock: false,
-        hiddenThinkingLabel: "Thinking...",
-        toolOutputExpanded: false,
-        showImages: false,
-        imageWidthCells: 60,
-        getToolDefinition: () => undefined,
-        getCustomMessageRenderer: () => undefined,
-    }),
-};
 export class ExtensionRunner {
     constructor(extensions, runtime, cwd, sessionManager, modelRegistry, orchestrationContext) {
         this.mode = "print";
@@ -199,12 +87,12 @@ export class ExtensionRunner {
                     this.modelRegistry.registerProvider(name, config);
                 }
             }
-            catch (err) {
+            catch (error) {
                 this.emitError({
                     extensionPath,
                     event: "register_provider",
-                    error: err instanceof Error ? err.message : String(err),
-                    stack: err instanceof Error ? err.stack : undefined,
+                    error: error instanceof Error ? error.message : String(error),
+                    stack: error instanceof Error ? error.stack : undefined,
                 });
             }
         }
@@ -254,40 +142,18 @@ export class ExtensionRunner {
         return this.uiContext !== noOpUIContext;
     }
     getExtensionPaths() {
-        return this.extensions.map((e) => e.path);
+        return this.extensions.map((extension) => extension.path);
     }
     /** Get all registered tools from all extensions (first registration per name wins). */
     getAllRegisteredTools() {
-        const toolsByName = new Map();
-        for (const ext of this.extensions) {
-            for (const tool of ext.tools.values()) {
-                if (!toolsByName.has(tool.definition.name)) {
-                    toolsByName.set(tool.definition.name, tool);
-                }
-            }
-        }
-        return Array.from(toolsByName.values());
+        return collectRegisteredTools(this.extensions);
     }
     /** Get a tool definition by name. Returns undefined if not found. */
     getToolDefinition(toolName) {
-        for (const ext of this.extensions) {
-            const tool = ext.tools.get(toolName);
-            if (tool) {
-                return tool.definition;
-            }
-        }
-        return undefined;
+        return findToolDefinition(this.extensions, toolName);
     }
     getFlags() {
-        const allFlags = new Map();
-        for (const ext of this.extensions) {
-            for (const [name, flag] of ext.flags) {
-                if (!allFlags.has(name)) {
-                    allFlags.set(name, flag);
-                }
-            }
-        }
-        return allFlags;
+        return collectFlags(this.extensions);
     }
     setFlagValue(name, value) {
         this.runtime.flagValues.set(name, value);
@@ -296,34 +162,9 @@ export class ExtensionRunner {
         return new Map(this.runtime.flagValues);
     }
     getShortcuts(resolvedKeybindings) {
-        this.shortcutDiagnostics = [];
-        const builtinKeybindings = buildBuiltinKeybindings(resolvedKeybindings);
-        const extensionShortcuts = new Map();
-        const addDiagnostic = (message, extensionPath) => {
-            this.shortcutDiagnostics.push({ type: "warning", message, path: extensionPath });
-            if (!this.hasUI()) {
-                console.warn(message);
-            }
-        };
-        for (const ext of this.extensions) {
-            for (const [key, shortcut] of ext.shortcuts) {
-                const normalizedKey = key.toLowerCase();
-                const builtInKeybinding = builtinKeybindings[normalizedKey];
-                if (builtInKeybinding?.restrictOverride === true) {
-                    addDiagnostic(`Extension shortcut '${key}' from ${shortcut.extensionPath} conflicts with built-in shortcut. Skipping.`, shortcut.extensionPath);
-                    continue;
-                }
-                if (builtInKeybinding?.restrictOverride === false) {
-                    addDiagnostic(`Extension shortcut conflict: '${key}' is built-in shortcut for ${builtInKeybinding.keybinding} and ${shortcut.extensionPath}. Using ${shortcut.extensionPath}.`, shortcut.extensionPath);
-                }
-                const existingExtensionShortcut = extensionShortcuts.get(normalizedKey);
-                if (existingExtensionShortcut) {
-                    addDiagnostic(`Extension shortcut conflict: '${key}' registered by both ${existingExtensionShortcut.extensionPath} and ${shortcut.extensionPath}. Using ${shortcut.extensionPath}.`, shortcut.extensionPath);
-                }
-                extensionShortcuts.set(normalizedKey, shortcut);
-            }
-        }
-        return extensionShortcuts;
+        const resolution = resolveExtensionShortcuts(this.extensions, resolvedKeybindings, this.hasUI());
+        this.shortcutDiagnostics = resolution.diagnostics;
+        return resolution.shortcuts;
     }
     getShortcutDiagnostics() {
         return this.shortcutDiagnostics;
@@ -349,61 +190,20 @@ export class ExtensionRunner {
         }
     }
     hasHandlers(eventType) {
-        for (const ext of this.extensions) {
-            const handlers = ext.handlers.get(eventType);
-            if (handlers && handlers.length > 0) {
-                return true;
-            }
-        }
-        return false;
+        return hasExtensionHandlers(this.extensions, eventType);
     }
     getMessageRenderer(customType) {
-        for (const ext of this.extensions) {
-            const renderer = ext.messageRenderers.get(customType);
-            if (renderer) {
-                return renderer;
-            }
-        }
-        return undefined;
-    }
-    resolveRegisteredCommands() {
-        const commands = [];
-        const counts = new Map();
-        for (const ext of this.extensions) {
-            for (const command of ext.commands.values()) {
-                commands.push(command);
-                counts.set(command.name, (counts.get(command.name) ?? 0) + 1);
-            }
-        }
-        const seen = new Map();
-        const takenInvocationNames = new Set();
-        return commands.map((command) => {
-            const occurrence = (seen.get(command.name) ?? 0) + 1;
-            seen.set(command.name, occurrence);
-            let invocationName = (counts.get(command.name) ?? 0) > 1 ? `${command.name}:${occurrence}` : command.name;
-            if (takenInvocationNames.has(invocationName)) {
-                let suffix = occurrence;
-                do {
-                    suffix++;
-                    invocationName = `${command.name}:${suffix}`;
-                } while (takenInvocationNames.has(invocationName));
-            }
-            takenInvocationNames.add(invocationName);
-            return {
-                ...command,
-                invocationName,
-            };
-        });
+        return findMessageRenderer(this.extensions, customType);
     }
     getRegisteredCommands() {
         this.commandDiagnostics = [];
-        return this.resolveRegisteredCommands();
+        return resolveRegisteredCommands(this.extensions);
     }
     getCommandDiagnostics() {
         return this.commandDiagnostics;
     }
     getCommand(name) {
-        return this.resolveRegisteredCommands().find((command) => command.invocationName === name);
+        return resolveRegisteredCommands(this.extensions).find((command) => command.invocationName === name);
     }
     /**
      * Request a graceful shutdown. Called by extension tools and event handlers.
@@ -412,477 +212,71 @@ export class ExtensionRunner {
     shutdown() {
         this.shutdownHandler();
     }
-    /**
-     * 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.
-     */
     createContext() {
-        const runner = this;
-        const getModel = this.getModel;
-        return {
-            get ui() {
-                runner.assertActive();
-                return runner.uiContext;
-            },
-            get mode() {
-                runner.assertActive();
-                return runner.mode;
-            },
-            get hasUI() {
-                runner.assertActive();
-                return runner.hasUI();
-            },
-            get cwd() {
-                runner.assertActive();
-                return runner.cwd;
-            },
-            get sessionManager() {
-                runner.assertActive();
-                return runner.sessionManager;
-            },
-            get modelRegistry() {
-                runner.assertActive();
-                return runner.modelRegistry;
-            },
-            get model() {
-                runner.assertActive();
-                return getModel();
-            },
-            get orchestrationContext() {
-                runner.assertActive();
-                return runner.orchestrationContext;
-            },
-            isIdle: () => {
-                runner.assertActive();
-                return runner.isIdleFn();
-            },
-            isProjectTrusted: () => {
-                runner.assertActive();
-                return runner.isProjectTrustedFn();
-            },
-            get signal() {
-                runner.assertActive();
-                return runner.getSignalFn();
-            },
-            abort: () => {
-                runner.assertActive();
-                runner.abortFn();
-            },
-            hasPendingMessages: () => {
-                runner.assertActive();
-                return runner.hasPendingMessagesFn();
-            },
-            shutdown: () => {
-                runner.assertActive();
-                runner.shutdownHandler();
-            },
-            getContextUsage: () => {
-                runner.assertActive();
-                return runner.getContextUsageFn();
-            },
-            compact: (options) => {
-                runner.assertActive();
-                runner.compactFn(options);
-            },
-            getSystemPrompt: () => {
-                runner.assertActive();
-                return runner.getSystemPromptFn();
-            },
-        };
+        return createExtensionContext(this.createContextSource());
     }
     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
-        // 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();
-        };
-        context.newSession = (options) => {
-            this.assertActive();
-            return this.newSessionHandler(options);
-        };
-        context.fork = (entryId, options) => {
-            this.assertActive();
-            return this.forkHandler(entryId, options);
-        };
-        context.navigateTree = (targetId, options) => {
-            this.assertActive();
-            return this.navigateTreeHandler(targetId, options);
-        };
-        context.switchSession = (sessionPath, options) => {
-            this.assertActive();
-            return this.switchSessionHandler(sessionPath, options);
-        };
-        context.reload = () => {
-            this.assertActive();
-            return this.reloadHandler();
-        };
-        return context;
+        return createExtensionCommandContext(this.createContextSource());
     }
-    isSessionBeforeEvent(event) {
-        return (event.type === "session_before_switch" ||
-            event.type === "session_before_fork" ||
-            event.type === "session_before_compact" ||
-            event.type === "session_before_tree");
+    createContextSource() {
+        return {
+            assertActive: () => this.assertActive(),
+            getUIContext: () => this.uiContext,
+            getMode: () => this.mode,
+            hasUI: () => this.hasUI(),
+            getCwd: () => this.cwd,
+            getSessionManager: () => this.sessionManager,
+            getModelRegistry: () => this.modelRegistry,
+            getModel: () => this.getModel(),
+            getOrchestrationContext: () => this.orchestrationContext,
+            isIdle: () => this.isIdleFn(),
+            isProjectTrusted: () => this.isProjectTrustedFn(),
+            getSignal: () => this.getSignalFn(),
+            abort: () => this.abortFn(),
+            hasPendingMessages: () => this.hasPendingMessagesFn(),
+            shutdown: () => this.shutdownHandler(),
+            getContextUsage: () => this.getContextUsageFn(),
+            compact: (options) => this.compactFn(options),
+            getSystemPrompt: () => this.getSystemPromptFn(),
+            getSystemPromptOptions: () => this.getSystemPromptOptionsFn(),
+            waitForIdle: () => this.waitForIdleFn(),
+            newSession: (options) => this.newSessionHandler(options),
+            fork: (entryId, options) => this.forkHandler(entryId, options),
+            navigateTree: (targetId, options) => this.navigateTreeHandler(targetId, options),
+            switchSession: (sessionPath, options) => this.switchSessionHandler(sessionPath, options),
+            reload: () => this.reloadHandler(),
+        };
     }
     async emit(event) {
-        const ctx = this.createContext();
-        let result;
-        for (const ext of this.extensions) {
-            const handlers = ext.handlers.get(event.type);
-            if (!handlers || handlers.length === 0)
-                continue;
-            for (const handler of handlers) {
-                try {
-                    const handlerResult = await handler(event, ctx);
-                    if (this.isSessionBeforeEvent(event) && handlerResult) {
-                        result = handlerResult;
-                        if (result.cancel) {
-                            return result;
-                        }
-                    }
-                }
-                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: event.type,
-                        error: message,
-                        stack,
-                    });
-                }
-            }
-        }
-        return result;
+        return runGenericHandlers(this.extensions, this.createContext(), event, (error) => this.emitError(error));
     }
     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;
+        return runMessageEndHandlers(this.extensions, this.createContext(), event, (error) => this.emitError(error));
     }
     async emitToolResult(event) {
-        const ctx = this.createContext();
-        const currentEvent = { ...event };
-        let modified = false;
-        for (const ext of this.extensions) {
-            const handlers = ext.handlers.get("tool_result");
-            if (!handlers || handlers.length === 0)
-                continue;
-            for (const handler of handlers) {
-                try {
-                    const handlerResult = (await handler(currentEvent, ctx));
-                    if (!handlerResult)
-                        continue;
-                    if (handlerResult.content !== undefined) {
-                        currentEvent.content = handlerResult.content;
-                        modified = true;
-                    }
-                    if (handlerResult.details !== undefined) {
-                        currentEvent.details = handlerResult.details;
-                        modified = true;
-                    }
-                    if (handlerResult.isError !== undefined) {
-                        currentEvent.isError = handlerResult.isError;
-                        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: "tool_result",
-                        error: message,
-                        stack,
-                    });
-                }
-            }
-        }
-        if (!modified) {
-            return undefined;
-        }
-        return {
-            content: currentEvent.content,
-            details: currentEvent.details,
-            isError: currentEvent.isError,
-        };
+        return runToolResultHandlers(this.extensions, this.createContext(), event, (error) => this.emitError(error));
     }
     async emitToolCall(event) {
-        const ctx = this.createContext();
-        let result;
-        for (const ext of this.extensions) {
-            const handlers = ext.handlers.get("tool_call");
-            if (!handlers || handlers.length === 0)
-                continue;
-            for (const handler of handlers) {
-                const handlerResult = await handler(event, ctx);
-                if (handlerResult) {
-                    result = handlerResult;
-                    if (result.block) {
-                        return result;
-                    }
-                }
-            }
-        }
-        return result;
+        return runToolCallHandlers(this.extensions, this.createContext(), event);
     }
     async emitUserBash(event) {
-        const ctx = this.createContext();
-        for (const ext of this.extensions) {
-            const handlers = ext.handlers.get("user_bash");
-            if (!handlers || handlers.length === 0)
-                continue;
-            for (const handler of handlers) {
-                try {
-                    const handlerResult = await handler(event, ctx);
-                    if (handlerResult) {
-                        return handlerResult;
-                    }
-                }
-                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: "user_bash",
-                        error: message,
-                        stack,
-                    });
-                }
-            }
-        }
-        return undefined;
+        return runUserBashHandlers(this.extensions, this.createContext(), event, (error) => this.emitError(error));
     }
     async emitContext(messages) {
-        const ctx = this.createContext();
-        let currentMessages = structuredClone(messages);
-        for (const ext of this.extensions) {
-            const handlers = ext.handlers.get("context");
-            if (!handlers || handlers.length === 0)
-                continue;
-            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;
-                    }
-                }
-                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",
-                        error: message,
-                        stack,
-                    });
-                }
-            }
-        }
-        return currentMessages;
-    }
-    async emitBeforeProviderRequest(payload) {
-        const ctx = this.createContext();
-        let currentPayload = payload;
-        for (const ext of this.extensions) {
-            const handlers = ext.handlers.get("before_provider_request");
-            if (!handlers || handlers.length === 0)
-                continue;
-            for (const handler of handlers) {
-                try {
-                    const event = {
-                        type: "before_provider_request",
-                        payload: currentPayload,
-                    };
-                    const handlerResult = await handler(event, ctx);
-                    if (handlerResult !== undefined) {
-                        currentPayload = handlerResult;
-                    }
-                }
-                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_request",
-                        error: message,
-                        stack,
-                    });
-                }
-            }
-        }
-        return currentPayload;
-    }
-    async emitBeforeAgentStart(prompt, images, systemPrompt, systemPromptOptions) {
-        let currentSystemPrompt = systemPrompt;
-        const ctx = Object.defineProperties({}, Object.getOwnPropertyDescriptors(this.createContext()));
-        ctx.getSystemPrompt = () => {
-            this.assertActive();
-            return currentSystemPrompt;
-        };
-        const messages = [];
-        let systemPromptModified = false;
-        for (const ext of this.extensions) {
-            const handlers = ext.handlers.get("before_agent_start");
-            if (!handlers || handlers.length === 0)
-                continue;
-            for (const handler of handlers) {
-                try {
-                    const event = {
-                        type: "before_agent_start",
-                        prompt,
-                        images,
-                        systemPrompt: currentSystemPrompt,
-                        systemPromptOptions,
-                    };
-                    const handlerResult = await handler(event, ctx);
-                    if (handlerResult) {
-                        const result = handlerResult;
-                        if (result.message) {
-                            messages.push(result.message);
-                        }
-                        if (result.systemPrompt !== undefined) {
-                            currentSystemPrompt = result.systemPrompt;
-                            systemPromptModified = 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: "before_agent_start",
-                        error: message,
-                        stack,
-                    });
-                }
-            }
-        }
-        if (messages.length > 0 || systemPromptModified) {
-            return {
-                messages: messages.length > 0 ? messages : undefined,
-                systemPrompt: systemPromptModified ? currentSystemPrompt : undefined,
-            };
-        }
-        return undefined;
-    }
-    async emitResourcesDiscover(cwd, reason) {
-        const ctx = this.createContext();
-        const skillPaths = [];
-        const promptPaths = [];
-        const themePaths = [];
-        for (const ext of this.extensions) {
-            const handlers = ext.handlers.get("resources_discover");
-            if (!handlers || handlers.length === 0)
-                continue;
-            for (const handler of handlers) {
-                try {
-                    const event = { type: "resources_discover", cwd, reason };
-                    const handlerResult = await handler(event, ctx);
-                    const result = handlerResult;
-                    if (result?.skillPaths?.length) {
-                        skillPaths.push(...result.skillPaths.map((path) => ({ path, extensionPath: ext.path })));
-                    }
-                    if (result?.promptPaths?.length) {
-                        promptPaths.push(...result.promptPaths.map((path) => ({ path, extensionPath: ext.path })));
-                    }
-                    if (result?.themePaths?.length) {
-                        themePaths.push(...result.themePaths.map((path) => ({ path, extensionPath: ext.path })));
-                    }
-                }
-                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: "resources_discover",
-                        error: message,
-                        stack,
-                    });
-                }
-            }
-        }
-        return { skillPaths, promptPaths, themePaths };
+        return runContextHandlers(this.extensions, this.createContext(), messages, (error) => this.emitError(error));
+    }
+    emitBeforeProviderRequest(payload) {
+        return runBeforeProviderRequestHandlers(this.extensions, this.createContext(), payload, (error) => this.emitError(error));
+    }
+    emitBeforeAgentStart(prompt, images, systemPrompt, systemPromptOptions) {
+        return runBeforeAgentStartHandlers(this.extensions, this.createContext(), () => this.assertActive(), prompt, images, systemPrompt, systemPromptOptions, (error) => this.emitError(error));
+    }
+    emitResourcesDiscover(cwd, reason) {
+        return runResourcesDiscoverHandlers(this.extensions, this.createContext(), cwd, reason, (error) => this.emitError(error));
     }
     /** Emit input event. Transforms chain, "handled" short-circuits. */
-    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,
-                        streamingBehavior,
-                    };
-                    const result = (await handler(event, ctx));
-                    if (result?.action === "handled")
-                        return result;
-                    if (result?.action === "transform") {
-                        currentText = result.text;
-                        currentImages = result.images ?? currentImages;
-                    }
-                }
-                catch (err) {
-                    this.emitError({
-                        extensionPath: ext.path,
-                        event: "input",
-                        error: err instanceof Error ? err.message : String(err),
-                        stack: err instanceof Error ? err.stack : undefined,
-                    });
-                }
-            }
-        }
-        return currentText !== text || currentImages !== images
-            ? { action: "transform", text: currentText, images: currentImages }
-            : { action: "continue" };
+    emitInput(text, images, source, streamingBehavior) {
+        return runInputHandlers(this.extensions, this.createContext(), text, images, source, streamingBehavior, (error) => this.emitError(error));
     }
 }
 //# sourceMappingURL=runner.js.map