wave-agent-sdk 0.0.5 → 0.0.7

package/src/managers/aiManager.ts

@@ -2,14 +2,19 @@ import { callAgent, compressMessages } from "../services/aiService.js";
 import { getMessagesToCompress } from "../utils/messageOperations.js";
 import { convertMessagesForAPI } from "../utils/convertMessagesForAPI.js";
 import * as memory from "../services/memory.js";
-import type { Logger, GatewayConfig, ModelConfig, Usage } from "../types.js";
+import type {
+  Logger,
+  GatewayConfig,
+  ModelConfig,
+  Usage,
+} from "../types/index.js";
 import type { ToolManager } from "./toolManager.js";
 import type { ToolContext, ToolResult } from "../tools/types.js";
 import type { MessageManager } from "./messageManager.js";
 import type { BackgroundBashManager } from "./backgroundBashManager.js";
 import { ChatCompletionMessageFunctionToolCall } from "openai/resources.js";
-import type { HookManager } from "../hooks/index.js";
-import type { ExtendedHookExecutionContext } from "../hooks/types.js";
+import type { HookManager } from "./hookManager.js";
+import type { ExtendedHookExecutionContext } from "../types/hooks.js";
 
 export interface AIManagerCallbacks {
   onCompressionStateChange?: (isCompressing: boolean) => void;
@@ -217,18 +222,29 @@ export class AIManager {
     } = {},
   ): Promise<void> {
     const { recursionDepth = 0, model, allowedTools } = options;
+
     // Only check isLoading for the initial call (recursionDepth === 0)
     if (recursionDepth === 0 && this.isLoading) {
       return;
     }
 
-    // Create new AbortController
-    const abortController = new AbortController();
-    this.abortController = abortController;
+    // Only create new AbortControllers for the initial call (recursionDepth === 0)
+    // For recursive calls, reuse existing controllers to maintain abort signal
+    let abortController: AbortController;
+    let toolAbortController: AbortController;
 
-    // Create separate AbortController for tool execution
-    const toolAbortController = new AbortController();
-    this.toolAbortController = toolAbortController;
+    if (recursionDepth === 0) {
+      // Create new AbortControllers for initial call
+      abortController = new AbortController();
+      this.abortController = abortController;
+
+      toolAbortController = new AbortController();
+      this.toolAbortController = toolAbortController;
+    } else {
+      // Reuse existing controllers for recursive calls
+      abortController = this.abortController!;
+      toolAbortController = this.toolAbortController!;
+    }
 
     // Only set loading state for the initial call
     if (recursionDepth === 0) {
@@ -266,6 +282,7 @@ export class AIManager {
 
       if (result.tool_calls) {
         for (const toolCall of result.tool_calls) {
+          this.logger?.debug("ToolCall", toolCall);
           if (toolCall.type === "function") {
             toolCalls.push(toolCall);
           }
@@ -295,139 +312,148 @@ export class AIManager {
       }
 
       if (toolCalls.length > 0) {
-        for (const functionToolCall of toolCalls) {
-          const toolId = functionToolCall.id || "";
-          // Execute tool
-          try {
-            // Check if already interrupted, skip tool execution if so
-            if (
-              abortController.signal.aborted ||
-              toolAbortController.signal.aborted
-            ) {
-              return;
-            }
-
-            // Safely parse tool parameters, handle tools without parameters
-            let toolArgs: Record<string, unknown> = {};
-            const argsString = functionToolCall.function?.arguments?.trim();
+        // Execute all tools in parallel using Promise.all
+        const toolExecutionPromises = toolCalls.map(
+          async (functionToolCall) => {
+            const toolId = functionToolCall.id || "";
 
-            if (!argsString || argsString === "") {
-              // Tool without parameters, use empty object
-              toolArgs = {};
-            } else {
-              try {
-                toolArgs = JSON.parse(argsString);
-              } catch (parseError) {
-                // For non-empty but malformed JSON, still throw exception
-                const errorMessage = `Failed to parse tool arguments: ${argsString}`;
-                this.logger?.error(errorMessage, parseError);
-                throw new Error(errorMessage);
+            try {
+              // Check if already interrupted, skip tool execution if so
+              if (
+                abortController.signal.aborted ||
+                toolAbortController.signal.aborted
+              ) {
+                return;
               }
-            }
 
-            // Set tool start execution state
-            const toolName = functionToolCall.function?.name || "";
-            const compactParams = this.generateCompactParams(
-              toolName,
-              toolArgs,
-            );
-
-            this.messageManager.updateToolBlock({
-              toolId,
-              args: JSON.stringify(toolArgs, null, 2),
-              isRunning: true, // isRunning: true
-              name: toolName,
-              compactParams,
-            });
+              // Safely parse tool parameters, handle tools without parameters
+              let toolArgs: Record<string, unknown> = {};
+              const argsString = functionToolCall.function?.arguments?.trim();
+
+              if (!argsString || argsString === "") {
+                // Tool without parameters, use empty object
+                toolArgs = {};
+              } else {
+                try {
+                  toolArgs = JSON.parse(argsString);
+                } catch (parseError) {
+                  // For non-empty but malformed JSON, still throw exception
+                  const errorMessage = `Failed to parse tool arguments: ${argsString}`;
+                  this.logger?.error(errorMessage, parseError);
+                  throw new Error(errorMessage);
+                }
+              }
 
-            try {
-              // Execute PreToolUse hooks before tool execution
-              await this.executePreToolUseHooks(toolName, toolArgs);
-
-              // Create tool execution context
-              const context: ToolContext = {
-                abortSignal: toolAbortController.signal,
-                backgroundBashManager: this.backgroundBashManager,
-                workdir: this.workdir,
-              };
-
-              // Execute tool
-              const toolResult = await this.toolManager.execute(
-                functionToolCall.function?.name || "",
+              // Set tool start execution state
+              const toolName = functionToolCall.function?.name || "";
+              const compactParams = this.generateCompactParams(
+                toolName,
                 toolArgs,
-                context,
               );
 
-              // Update message state - tool execution completed
               this.messageManager.updateToolBlock({
-                toolId,
-                args: JSON.stringify(toolArgs, null, 2),
-                result:
-                  toolResult.content ||
-                  (toolResult.error ? `Error: ${toolResult.error}` : ""),
-                success: toolResult.success,
-                error: toolResult.error,
-                isRunning: false, // isRunning: false
+                id: toolId,
+                parameters: JSON.stringify(toolArgs, null, 2),
+                isRunning: true, // isRunning: true
                 name: toolName,
-                shortResult: toolResult.shortResult,
                 compactParams,
               });
 
-              // If tool returns diff information, add diff block
-              if (
-                toolResult.success &&
-                toolResult.diffResult &&
-                toolResult.filePath
-              ) {
-                this.messageManager.addDiffBlock(
-                  toolResult.filePath,
-                  toolResult.diffResult,
+              try {
+                // Execute PreToolUse hooks before tool execution
+                const shouldExecuteTool = await this.executePreToolUseHooks(
+                  toolName,
+                  toolArgs,
+                  toolId,
                 );
-              }
 
-              // Execute PostToolUse hooks after successful tool completion
-              await this.executePostToolUseHooks(
-                toolName,
-                toolArgs,
-                toolResult,
-              );
-            } catch (toolError) {
-              const errorMessage =
-                toolError instanceof Error
-                  ? toolError.message
-                  : String(toolError);
+                // If PreToolUse hooks blocked execution, skip tool execution
+                if (!shouldExecuteTool) {
+                  this.logger?.info(
+                    `Tool ${toolName} execution blocked by PreToolUse hooks`,
+                  );
+                  return; // Skip this tool and return from this map function
+                }
+
+                // Create tool execution context
+                const context: ToolContext = {
+                  abortSignal: toolAbortController.signal,
+                  backgroundBashManager: this.backgroundBashManager,
+                  workdir: this.workdir,
+                };
+
+                // Execute tool
+                const toolResult = await this.toolManager.execute(
+                  functionToolCall.function?.name || "",
+                  toolArgs,
+                  context,
+                );
 
-              this.messageManager.updateToolBlock({
-                toolId,
-                args: JSON.stringify(toolArgs, null, 2),
-                result: `Tool execution failed: ${errorMessage}`,
-                success: false,
-                error: errorMessage,
-                isRunning: false,
-                name: toolName,
-                compactParams,
-              });
-            }
-          } catch (parseError) {
-            // Check if it's a parsing error due to interruption
-            const isAborted =
-              abortController.signal.aborted ||
-              toolAbortController.signal.aborted;
-
-            if (isAborted) {
-              // If interrupted, return directly without showing error
-              return;
+                // Update message state - tool execution completed
+                this.messageManager.updateToolBlock({
+                  id: toolId,
+                  parameters: JSON.stringify(toolArgs, null, 2),
+                  result:
+                    toolResult.content ||
+                    (toolResult.error ? `Error: ${toolResult.error}` : ""),
+                  success: toolResult.success,
+                  error: toolResult.error,
+                  isRunning: false, // isRunning: false
+                  name: toolName,
+                  shortResult: toolResult.shortResult,
+                  compactParams,
+                });
+
+                // If tool returns diff information, add diff block
+                if (
+                  toolResult.success &&
+                  toolResult.diffResult &&
+                  toolResult.filePath
+                ) {
+                  this.messageManager.addDiffBlock(
+                    toolResult.filePath,
+                    toolResult.diffResult,
+                  );
+                }
+
+                // Execute PostToolUse hooks after successful tool completion
+                await this.executePostToolUseHooks(
+                  toolId,
+                  toolName,
+                  toolArgs,
+                  toolResult,
+                );
+              } catch (toolError) {
+                const errorMessage =
+                  toolError instanceof Error
+                    ? toolError.message
+                    : String(toolError);
+
+                this.messageManager.updateToolBlock({
+                  id: toolId,
+                  parameters: JSON.stringify(toolArgs, null, 2),
+                  result: `Tool execution failed: ${errorMessage}`,
+                  success: false,
+                  error: errorMessage,
+                  isRunning: false,
+                  name: toolName,
+                  compactParams,
+                });
+              }
+            } catch (parseError) {
+              const errorMessage =
+                parseError instanceof Error
+                  ? parseError.message
+                  : String(parseError);
+              this.messageManager.addErrorBlock(
+                `Failed to parse tool arguments for ${functionToolCall.function?.name}: ${errorMessage}`,
+              );
             }
+          },
+        );
 
-            const errorMessage =
-              parseError instanceof Error
-                ? parseError.message
-                : String(parseError);
-            this.messageManager.addErrorBlock(
-              `Failed to parse tool arguments for ${functionToolCall.function?.name}: ${errorMessage}`,
-            );
-          }
-        }
+        // Wait for all tools to complete execution in parallel
+        await Promise.all(toolExecutionPromises);
       }
 
       // Handle token statistics and message compression
@@ -439,12 +465,6 @@ export class AIManager {
         const isCurrentlyAborted =
           abortController.signal.aborted || toolAbortController.signal.aborted;
 
-        // AI service call ends, clear abort controller
-        this.abortController = null;
-
-        // Clear tool AbortController after tool execution completes
-        this.toolAbortController = null;
-
         if (!isCurrentlyAborted) {
           // Recursively call AI service, increment recursion depth, and pass same configuration
           await this.sendAIMessage({
@@ -453,47 +473,57 @@ export class AIManager {
             allowedTools,
           });
         }
-      } else {
-        // Clear abort controller when no tool operations
-        this.abortController = null;
-        this.toolAbortController = null;
       }
     } catch (error) {
-      // Check if error is due to user interrupt operation
-      const isAborted =
-        abortController.signal.aborted ||
-        toolAbortController.signal.aborted ||
-        (error instanceof Error &&
-          (error.name === "AbortError" || error.message.includes("aborted")));
-
-      if (!isAborted) {
-        this.messageManager.addErrorBlock(
-          error instanceof Error ? error.message : "Unknown error occurred",
-        );
-      }
-
-      // Reset abort controller on error
-      this.abortController = null;
-      this.toolAbortController = null;
+      this.messageManager.addErrorBlock(
+        error instanceof Error ? error.message : "Unknown error occurred",
+      );
     } finally {
-      // Only clear loading state for the initial call
+      // Only execute Stop hooks for the initial call
       if (recursionDepth === 0) {
-        this.setIsLoading(false);
+        // Execute Stop hooks only if the operation was not aborted
+        const isCurrentlyAborted =
+          abortController.signal.aborted || toolAbortController.signal.aborted;
+
+        if (!isCurrentlyAborted) {
+          const shouldContinue = await this.executeStopHooks();
 
-        // Save session before executing Stop hooks
+          // If Stop hooks indicate we should continue (due to blocking errors),
+          // restart the AI conversation cycle
+          if (shouldContinue) {
+            this.logger?.info(
+              "Stop hooks indicate issues need fixing, continuing conversation...",
+            );
+
+            // Restart the conversation to let AI fix the issues
+            // Use recursionDepth = 1 to prevent Stop hooks from running again in continuation
+            await this.sendAIMessage({
+              recursionDepth: 1,
+              model,
+              allowedTools,
+            });
+          }
+        }
+
+        // Save session after all operations (including continuation) are complete
         await this.messageManager.saveSession();
 
-        // Execute Stop hooks when AI response cycle completes
-        await this.executeStopHooks();
+        // Clear abort controllers and loading state after all operations are complete
+        this.abortController = null;
+        this.toolAbortController = null;
+
+        // Set loading to false at the very end, after all operations including continuation
+        this.setIsLoading(false);
       }
     }
   }
 
   /**
    * Execute Stop hooks when AI response cycle completes
+   * @returns Promise<boolean> - true if should continue conversation, false if should stop
    */
-  private async executeStopHooks(): Promise<void> {
-    if (!this.hookManager) return;
+  private async executeStopHooks(): Promise<boolean> {
+    if (!this.hookManager) return false;
 
     try {
       const context: ExtendedHookExecutionContext = {
@@ -508,6 +538,25 @@ export class AIManager {
 
       const results = await this.hookManager.executeHooks("Stop", context);
 
+      // Process hook results to handle exit codes and appropriate responses
+      let shouldContinue = false;
+      if (results.length > 0) {
+        const processResult = this.hookManager.processHookResults(
+          "Stop",
+          results,
+          this.messageManager,
+        );
+
+        // If hook processing indicates we should block (exit code 2), continue conversation
+        if (processResult.shouldBlock) {
+          this.logger?.info(
+            "Stop hook blocked stopping with error:",
+            processResult.errorMessage,
+          );
+          shouldContinue = true;
+        }
+      }
+
       // Log hook execution results for debugging
       if (results.length > 0) {
         this.logger?.debug(
@@ -521,20 +570,25 @@ export class AIManager {
           })),
         );
       }
+
+      return shouldContinue;
     } catch (error) {
       // Hook execution errors should not interrupt the main workflow
       this.logger?.error("Stop hook execution failed:", error);
+      return false;
     }
   }
 
   /**
    * Execute PreToolUse hooks before tool execution
+   * Returns true if hooks allow tool execution, false if blocked
    */
   private async executePreToolUseHooks(
     toolName: string,
     toolInput?: Record<string, unknown>,
-  ): Promise<void> {
-    if (!this.hookManager) return;
+    toolId?: string,
+  ): Promise<boolean> {
+    if (!this.hookManager) return true;
 
     try {
       const context: ExtendedHookExecutionContext = {
@@ -553,6 +607,19 @@ export class AIManager {
         context,
       );
 
+      // Process hook results to handle exit codes and determine if tool should be blocked
+      let shouldContinue = true;
+      if (results.length > 0) {
+        const processResult = this.hookManager.processHookResults(
+          "PreToolUse",
+          results,
+          this.messageManager,
+          toolId, // Pass toolId for proper PreToolUse blocking error handling
+          JSON.stringify(toolInput || {}, null, 2), // Pass serialized tool parameters
+        );
+        shouldContinue = !processResult.shouldBlock;
+      }
+
       // Log hook execution results for debugging
       if (results.length > 0) {
         this.logger?.debug(
@@ -566,9 +633,12 @@ export class AIManager {
           })),
         );
       }
+
+      return shouldContinue;
     } catch (error) {
       // Hook execution errors should not interrupt the main workflow
       this.logger?.error("PreToolUse hook execution failed:", error);
+      return true; // Allow tool execution on hook errors
     }
   }
 
@@ -576,6 +646,7 @@ export class AIManager {
    * Execute PostToolUse hooks after tool completion
    */
   private async executePostToolUseHooks(
+    toolId: string,
     toolName: string,
     toolInput?: Record<string, unknown>,
     toolResponse?: ToolResult,
@@ -600,6 +671,16 @@ export class AIManager {
         context,
       );
 
+      // Process hook results to handle exit codes and update tool results
+      if (results.length > 0) {
+        this.hookManager.processHookResults(
+          "PostToolUse",
+          results,
+          this.messageManager,
+          toolId,
+        );
+      }
+
       // Log hook execution results for debugging
       if (results.length > 0) {
         this.logger?.debug(

package/src/managers/backgroundBashManager.ts

@@ -1,5 +1,5 @@
 import { spawn } from "child_process";
-import type { BackgroundShell } from "../types.js";
+import type { BackgroundShell } from "../types/index.js";
 
 export interface BackgroundBashManagerCallbacks {
   onShellsChange?: (shells: BackgroundShell[]) => void;