gsd-pi 2.34.0-dev.ed0bfbf → 2.35.0-dev.55dcc60

package/packages/pi-coding-agent/dist/core/extensions/runner.js

@@ -363,245 +363,152 @@ export class ExtensionRunner {
             event.type === "session_before_compact" ||
             event.type === "session_before_tree");
     }
-    async emit(event) {
+    /**
+     * Shared handler invocation loop.
+     *
+     * Iterates every handler registered for `eventType` across all extensions,
+     * calling each inside a try/catch that emits an ExtensionError on failure.
+     *
+     * `getEvent` builds the event object for each handler call — callers that
+     * mutate state between calls (e.g. context, before_provider_request) supply
+     * a function; callers with a fixed event can pass a constant.
+     *
+     * `processResult` receives each handler's return value and the owning
+     * extension's path. It returns `{ done: true }` to short-circuit
+     * or `{ done: false }` to keep iterating.
+     */
+    async invokeHandlers(eventType, getEvent, processResult) {
         const ctx = this.createContext();
-        let result;
         for (const ext of this.extensions) {
-            const handlers = ext.handlers.get(event.type);
+            const handlers = ext.handlers.get(eventType);
             if (!handlers || handlers.length === 0)
                 continue;
             for (const handler of handlers) {
                 try {
+                    const event = getEvent();
                     const handlerResult = await handler(event, ctx);
-                    if (this.isSessionBeforeEvent(event) && handlerResult) {
-                        result = handlerResult;
-                        if (result.cancel) {
-                            return result;
-                        }
-                    }
+                    const action = processResult(handlerResult, ext.path);
+                    if (action.done)
+                        return;
                 }
                 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,
+                        event: eventType,
                         error: message,
                         stack,
                     });
                 }
             }
         }
+    }
+    async emit(event) {
+        let result;
+        const isSessionBefore = this.isSessionBeforeEvent(event);
+        await this.invokeHandlers(event.type, () => event, (handlerResult) => {
+            if (isSessionBefore && handlerResult) {
+                result = handlerResult;
+                if (result.cancel)
+                    return { done: true };
+            }
+            return { done: false };
+        });
         return result;
     }
     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,
-                    });
-                }
+        await this.invokeHandlers("tool_result", () => currentEvent, (handlerResult) => {
+            const r = handlerResult;
+            if (!r)
+                return { done: false };
+            if (r.content !== undefined) {
+                currentEvent.content = r.content;
+                modified = true;
             }
-        }
-        if (!modified) {
+            if (r.details !== undefined) {
+                currentEvent.details = r.details;
+                modified = true;
+            }
+            if (r.isError !== undefined) {
+                currentEvent.isError = r.isError;
+                modified = true;
+            }
+            return { done: false };
+        });
+        if (!modified)
             return undefined;
-        }
-        return {
-            content: currentEvent.content,
-            details: currentEvent.details,
-            isError: currentEvent.isError,
-        };
+        return { content: currentEvent.content, details: currentEvent.details, isError: currentEvent.isError };
     }
     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) {
-                try {
-                    const handlerResult = await handler(event, ctx);
-                    if (handlerResult) {
-                        result = handlerResult;
-                        if (result.block) {
-                            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: "tool_call",
-                        error: message,
-                        stack,
-                    });
-                }
+        await this.invokeHandlers("tool_call", () => event, (handlerResult) => {
+            if (handlerResult) {
+                result = handlerResult;
+                if (result.block)
+                    return { done: true };
             }
-        }
+            return { done: false };
+        });
         return result;
     }
     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,
-                    });
-                }
+        let result;
+        await this.invokeHandlers("user_bash", () => event, (handlerResult) => {
+            if (handlerResult) {
+                result = handlerResult;
+                return { done: true };
             }
-        }
-        return undefined;
+            return { done: false };
+        });
+        return result;
     }
     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,
-                    });
-                }
+        await this.invokeHandlers("context", () => ({ type: "context", messages: currentMessages }), (handlerResult) => {
+            if (handlerResult && handlerResult.messages) {
+                currentMessages = handlerResult.messages;
             }
-        }
+            return { done: false };
+        });
         return currentMessages;
     }
     async emitBeforeProviderRequest(payload, model) {
-        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,
-                        model,
-                    };
-                    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,
-                    });
-                }
-            }
-        }
+        await this.invokeHandlers("before_provider_request", () => ({
+            type: "before_provider_request",
+            payload: currentPayload,
+            model,
+        }), (handlerResult) => {
+            if (handlerResult !== undefined)
+                currentPayload = handlerResult;
+            return { done: false };
+        });
         return currentPayload;
     }
     async emitBeforeAgentStart(prompt, images, systemPrompt) {
-        const ctx = this.createContext();
         const messages = [];
         let currentSystemPrompt = systemPrompt;
         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,
-                    };
-                    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,
-                    });
+        await this.invokeHandlers("before_agent_start", () => ({
+            type: "before_agent_start",
+            prompt,
+            images,
+            systemPrompt: currentSystemPrompt,
+        }), (handlerResult) => {
+            if (handlerResult) {
+                const r = handlerResult;
+                if (r.message)
+                    messages.push(r.message);
+                if (r.systemPrompt !== undefined) {
+                    currentSystemPrompt = r.systemPrompt;
+                    systemPromptModified = true;
                 }
             }
-        }
+            return { done: false };
+        });
         if (messages.length > 0 || systemPromptModified) {
             return {
                 messages: messages.length > 0 ? messages : undefined,
@@ -611,70 +518,49 @@ export class ExtensionRunner {
         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,
-                    });
-                }
-            }
-        }
+        await this.invokeHandlers("resources_discover", () => ({
+            type: "resources_discover",
+            cwd,
+            reason,
+        }), (handlerResult, extensionPath) => {
+            const r = handlerResult;
+            if (r?.skillPaths?.length)
+                skillPaths.push(...r.skillPaths.map((path) => ({ path, extensionPath })));
+            if (r?.promptPaths?.length)
+                promptPaths.push(...r.promptPaths.map((path) => ({ path, extensionPath })));
+            if (r?.themePaths?.length)
+                themePaths.push(...r.themePaths.map((path) => ({ path, extensionPath })));
+            return { done: false };
+        });
         return { skillPaths, promptPaths, themePaths };
     }
     /** Emit input event. Transforms chain, "handled" short-circuits. */
     async emitInput(text, images, source) {
-        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 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,
-                    });
-                }
+        let handled;
+        await this.invokeHandlers("input", () => ({
+            type: "input",
+            text: currentText,
+            images: currentImages,
+            source,
+        }), (handlerResult) => {
+            const r = handlerResult;
+            if (r?.action === "handled") {
+                handled = r;
+                return { done: true };
             }
-        }
+            if (r?.action === "transform") {
+                currentText = r.text;
+                currentImages = r.images ?? currentImages;
+            }
+            return { done: false };
+        });
+        if (handled)
+            return handled;
         return currentText !== text || currentImages !== images
             ? { action: "transform", text: currentText, images: currentImages }
             : { action: "continue" };