fix(coding-agent): sync tool hooks with agent event processing closes #2113

packages/coding-agent/src/core/extensions/index.ts

@@ -163,9 +163,4 @@ export {
 	isToolCallEventType,
 	isWriteToolResult,
 } from "./types.js";
-export {
-	wrapRegisteredTool,
-	wrapRegisteredTools,
-	wrapToolsWithExtensions,
-	wrapToolWithExtensions,
-} from "./wrapper.js";
+export { wrapRegisteredTool, wrapRegisteredTools } from "./wrapper.js";

packages/coding-agent/src/core/extensions/wrapper.ts

@@ -1,10 +1,13 @@
 /**
- * Tool wrappers for extensions.
+ * Tool wrappers for extension-registered tools.
+ *
+ * These wrappers only adapt tool execution so extension tools receive the runner context.
+ * Tool call and tool result interception is handled by AgentSession via agent-core hooks.
  */
 
-import type { AgentTool, AgentToolUpdateCallback } from "@mariozechner/pi-agent-core";
+import type { AgentTool } from "@mariozechner/pi-agent-core";
 import type { ExtensionRunner } from "./runner.js";
-import type { RegisteredTool, ToolCallEventResult } from "./types.js";
+import type { RegisteredTool } from "./types.js";
 
 /**
  * Wrap a RegisteredTool into an AgentTool.
@@ -29,90 +32,3 @@ export function wrapRegisteredTool(registeredTool: RegisteredTool, runner: Exten
 export function wrapRegisteredTools(registeredTools: RegisteredTool[], runner: ExtensionRunner): AgentTool[] {
 	return registeredTools.map((rt) => wrapRegisteredTool(rt, runner));
 }
-
-/**
- * Wrap a tool with extension callbacks for interception.
- * - Emits tool_call event before execution (can block)
- * - Emits tool_result event after execution (can modify result)
- */
-export function wrapToolWithExtensions<T>(tool: AgentTool<any, T>, runner: ExtensionRunner): AgentTool<any, T> {
-	return {
-		...tool,
-		execute: async (
-			toolCallId: string,
-			params: Record<string, unknown>,
-			signal?: AbortSignal,
-			onUpdate?: AgentToolUpdateCallback<T>,
-		) => {
-			// Emit tool_call event - extensions can block execution
-			if (runner.hasHandlers("tool_call")) {
-				try {
-					const callResult = (await runner.emitToolCall({
-						type: "tool_call",
-						toolName: tool.name,
-						toolCallId,
-						input: params,
-					})) as ToolCallEventResult | undefined;
-
-					if (callResult?.block) {
-						const reason = callResult.reason || "Tool execution was blocked by an extension";
-						throw new Error(reason);
-					}
-				} catch (err) {
-					if (err instanceof Error) {
-						throw err;
-					}
-					throw new Error(`Extension failed, blocking execution: ${String(err)}`);
-				}
-			}
-
-			// Execute the actual tool
-			try {
-				const result = await tool.execute(toolCallId, params, signal, onUpdate);
-
-				// Emit tool_result event - extensions can modify the result
-				if (runner.hasHandlers("tool_result")) {
-					const resultResult = await runner.emitToolResult({
-						type: "tool_result",
-						toolName: tool.name,
-						toolCallId,
-						input: params,
-						content: result.content,
-						details: result.details,
-						isError: false,
-					});
-
-					if (resultResult) {
-						return {
-							content: resultResult.content ?? result.content,
-							details: (resultResult.details ?? result.details) as T,
-						};
-					}
-				}
-
-				return result;
-			} catch (err) {
-				// Emit tool_result event for errors
-				if (runner.hasHandlers("tool_result")) {
-					await runner.emitToolResult({
-						type: "tool_result",
-						toolName: tool.name,
-						toolCallId,
-						input: params,
-						content: [{ type: "text", text: err instanceof Error ? err.message : String(err) }],
-						details: undefined,
-						isError: true,
-					});
-				}
-				throw err;
-			}
-		},
-	};
-}
-
-/**
- * Wrap all tools with extension callbacks.
- */
-export function wrapToolsWithExtensions<T>(tools: AgentTool<any, T>[], runner: ExtensionRunner): AgentTool<any, T>[] {
-	return tools.map((tool) => wrapToolWithExtensions(tool, runner));
-}