wave-agent-sdk 0.0.8 → 0.0.10

package/src/managers/subagentManager.ts

@@ -16,6 +16,10 @@ import {
   UserMessageParams,
   type AgentToolBlockUpdateParams,
 } from "../utils/messageOperations.js";
+import {
+  addConsolidatedAbortListener,
+  createAbortPromise,
+} from "../utils/abortUtils.js";
 
 export interface SubagentManagerCallbacks {
   // Granular subagent message callbacks (015-subagent-message-callbacks)
@@ -32,6 +36,12 @@ export interface SubagentManagerCallbacks {
     chunk: string,
     accumulated: string,
   ) => void;
+  /** Triggered during subagent reasoning streaming updates */
+  onSubagentAssistantReasoningUpdated?: (
+    subagentId: string,
+    chunk: string,
+    accumulated: string,
+  ) => void;
   /** Triggered when subagent tool block is updated */
   onSubagentToolBlockUpdated?: (
     subagentId: string,
@@ -58,9 +68,9 @@ export interface SubagentManagerOptions {
   parentMessageManager: MessageManager;
   callbacks?: SubagentManagerCallbacks; // Use SubagentManagerCallbacks instead of parentCallbacks
   logger?: Logger;
-  gatewayConfig: GatewayConfig;
-  modelConfig: ModelConfig;
-  tokenLimit: number;
+  getGatewayConfig: () => GatewayConfig;
+  getModelConfig: () => ModelConfig;
+  getTokenLimit: () => number;
   hookManager?: HookManager;
   onUsageAdded?: (usage: Usage) => void;
 }
@@ -74,9 +84,9 @@ export class SubagentManager {
   private parentMessageManager: MessageManager;
   private callbacks?: SubagentManagerCallbacks; // Use SubagentManagerCallbacks instead of parentCallbacks
   private logger?: Logger;
-  private gatewayConfig: GatewayConfig;
-  private modelConfig: ModelConfig;
-  private tokenLimit: number;
+  private getGatewayConfig: () => GatewayConfig;
+  private getModelConfig: () => ModelConfig;
+  private getTokenLimit: () => number;
   private hookManager?: HookManager;
   private onUsageAdded?: (usage: Usage) => void;
 
@@ -86,9 +96,9 @@ export class SubagentManager {
     this.parentMessageManager = options.parentMessageManager;
     this.callbacks = options.callbacks; // Store SubagentManagerCallbacks
     this.logger = options.logger;
-    this.gatewayConfig = options.gatewayConfig;
-    this.modelConfig = options.modelConfig;
-    this.tokenLimit = options.tokenLimit;
+    this.getGatewayConfig = options.getGatewayConfig;
+    this.getModelConfig = options.getModelConfig;
+    this.getTokenLimit = options.getTokenLimit;
     this.hookManager = options.hookManager;
     this.onUsageAdded = options.onUsageAdded;
   }
@@ -146,12 +156,7 @@ export class SubagentManager {
       subagent_type: string;
     },
   ): Promise<SubagentInstance> {
-    if (
-      !this.parentToolManager ||
-      !this.gatewayConfig ||
-      !this.modelConfig ||
-      !this.tokenLimit
-    ) {
+    if (!this.parentToolManager) {
       throw new Error(
         "SubagentManager not properly initialized - call initialize() first",
       );
@@ -167,19 +172,12 @@ export class SubagentManager {
       workdir: this.workdir,
       logger: this.logger,
       sessionType: "subagent",
-      parentSessionId: this.parentMessageManager.getSessionId(),
       subagentType: parameters.subagent_type,
     });
 
     // Use the parent tool manager directly - tool restrictions will be handled by allowedTools parameter
     const toolManager = this.parentToolManager;
 
-    // Determine model to use
-    const modelToUse =
-      configuration.model && configuration.model !== "inherit"
-        ? configuration.model
-        : this.modelConfig.agentModel;
-
     // Create isolated AIManager for the subagent
     const aiManager = new AIManager({
       messageManager,
@@ -189,12 +187,29 @@ export class SubagentManager {
       systemPrompt: configuration.systemPrompt,
       subagentType: parameters.subagent_type, // Pass subagent type for hook context
       hookManager: this.hookManager,
-      gatewayConfig: this.gatewayConfig,
-      modelConfig: {
-        ...this.modelConfig,
-        agentModel: modelToUse,
+      getGatewayConfig: this.getGatewayConfig,
+      getModelConfig: () => {
+        // Determine model dynamically each time
+        const parentModelConfig = this.getModelConfig();
+        let modelToUse: string;
+
+        if (!configuration.model || configuration.model === "inherit") {
+          // Use parent's agentModel for "inherit" or undefined
+          modelToUse = parentModelConfig.agentModel;
+        } else if (configuration.model === "fastModel") {
+          // Use parent's fastModel for special "fastModel" value
+          modelToUse = parentModelConfig.fastModel;
+        } else {
+          // Use specific model name
+          modelToUse = configuration.model;
+        }
+
+        return {
+          ...parentModelConfig,
+          agentModel: modelToUse,
+        };
       },
-      tokenLimit: this.tokenLimit,
+      getTokenLimit: this.getTokenLimit,
       callbacks: {
         onUsageAdded: this.onUsageAdded,
       },
@@ -249,14 +264,22 @@ export class SubagentManager {
         status: "active",
       });
 
-      // Set up abort handler
+      // Set up consolidated abort handler to prevent listener accumulation
+      let abortCleanup: (() => void) | undefined;
       if (abortSignal) {
-        abortSignal.addEventListener("abort", () => {
-          this.updateInstanceStatus(instance.subagentId, "aborted");
-          this.parentMessageManager.updateSubagentBlock(instance.subagentId, {
-            status: "aborted",
-          });
-        });
+        abortCleanup = addConsolidatedAbortListener(abortSignal, [
+          () => {
+            // Update status to aborted
+            this.updateInstanceStatus(instance.subagentId, "aborted");
+            this.parentMessageManager.updateSubagentBlock(instance.subagentId, {
+              status: "aborted",
+            });
+          },
+          () => {
+            // Abort the AI execution
+            instance.aiManager.abortAIMessage();
+          },
+        ]);
       }
 
       // Add the user's prompt as a message
@@ -276,32 +299,43 @@ export class SubagentManager {
 
       // Execute the AI request with tool restrictions
       // The AIManager will handle abort signals through its own abort controllers
-      // We need to abort the AI execution if the external abort signal is triggered
+      // Resolve model name for sendAIMessage
+      let resolvedModel: string | undefined;
+      if (
+        instance.configuration.model &&
+        instance.configuration.model !== "inherit"
+      ) {
+        if (instance.configuration.model === "fastModel") {
+          // Use parent's fastModel for special "fastModel" value
+          const parentModelConfig = this.getModelConfig();
+          resolvedModel = parentModelConfig.fastModel;
+        } else {
+          // Use specific model name
+          resolvedModel = instance.configuration.model;
+        }
+      }
+      // For "inherit" or undefined, resolvedModel remains undefined (uses AIManager default)
+
       const executeAI = instance.aiManager.sendAIMessage({
         allowedTools,
-        model:
-          instance.configuration.model !== "inherit"
-            ? instance.configuration.model
-            : undefined,
+        model: resolvedModel,
       });
 
-      // If we have an abort signal, race against it
-      if (abortSignal) {
-        await Promise.race([
-          executeAI,
-          new Promise<never>((_, reject) => {
-            if (abortSignal.aborted) {
-              reject(new Error("Task was aborted"));
-            }
-            abortSignal.addEventListener("abort", () => {
-              // Abort the AI execution
-              instance.aiManager.abortAIMessage();
-              reject(new Error("Task was aborted"));
-            });
-          }),
-        ]);
-      } else {
-        await executeAI;
+      try {
+        // If we have an abort signal, race against it using utilities to prevent listener accumulation
+        if (abortSignal) {
+          await Promise.race([
+            executeAI,
+            createAbortPromise(abortSignal, "Task was aborted"),
+          ]);
+        } else {
+          await executeAI;
+        }
+      } finally {
+        // Clean up abort listeners to prevent memory leaks
+        if (abortCleanup) {
+          abortCleanup();
+        }
       }
 
       // Get the latest messages to extract the response
@@ -422,7 +456,6 @@ export class SubagentManager {
           workdir: this.workdir,
           logger: this.logger,
           sessionType: "subagent",
-          parentSessionId: this.parentMessageManager.getSessionId(),
           subagentType: configuration.name, // Use configuration name for restored sessions
         });
 
@@ -430,10 +463,16 @@ export class SubagentManager {
         const toolManager = this.parentToolManager;
 
         // Determine model to use
-        const modelToUse =
-          configuration.model && configuration.model !== "inherit"
-            ? configuration.model
-            : this.modelConfig.agentModel;
+        let modelToUse: string;
+        const parentModelConfig = this.getModelConfig();
+
+        if (!configuration.model || configuration.model === "inherit") {
+          modelToUse = parentModelConfig.agentModel;
+        } else if (configuration.model === "fastModel") {
+          modelToUse = parentModelConfig.fastModel;
+        } else {
+          modelToUse = configuration.model;
+        }
 
         // Create AIManager for the restored subagent
         const aiManager = new AIManager({
@@ -444,12 +483,12 @@ export class SubagentManager {
           systemPrompt: configuration.systemPrompt,
           subagentType: configuration.name, // Use configuration name as subagent type for restored instances
           hookManager: this.hookManager,
-          gatewayConfig: this.gatewayConfig,
-          modelConfig: {
-            ...this.modelConfig,
+          getGatewayConfig: this.getGatewayConfig,
+          getModelConfig: () => ({
+            ...parentModelConfig,
             agentModel: modelToUse,
-          },
-          tokenLimit: this.tokenLimit,
+          }),
+          getTokenLimit: this.getTokenLimit,
           callbacks: {
             onUsageAdded: this.onUsageAdded,
           },
@@ -471,19 +510,7 @@ export class SubagentManager {
         // This ensures the callback can find the instance
         this.instances.set(subagentId, instance);
 
-        // Now restore the session data including sessionId, which will trigger the callback chain
-        const sessionDataObj = {
-          id: sessionData.id,
-          messages: sessionData.messages,
-          version: "1.0.0",
-          metadata: {
-            workdir: this.workdir,
-            startedAt: new Date().toISOString(),
-            lastActiveAt: new Date().toISOString(),
-            latestTotalTokens: 0,
-          },
-        };
-        messageManager.initializeFromSession(sessionDataObj);
+        messageManager.initializeFromSession(sessionData);
       } catch (error) {
         this.logger?.warn(
           `Failed to restore subagent session ${subagentId}:`,
@@ -524,6 +551,16 @@ export class SubagentManager {
           );
         }
       },
+      onAssistantReasoningUpdated: (chunk: string, accumulated: string) => {
+        // Forward assistant reasoning updates to parent via SubagentManager callbacks
+        if (this.callbacks?.onSubagentAssistantReasoningUpdated) {
+          this.callbacks.onSubagentAssistantReasoningUpdated(
+            subagentId,
+            chunk,
+            accumulated,
+          );
+        }
+      },
 
       onToolBlockUpdated: (params: AgentToolBlockUpdateParams) => {
         // Forward tool block updates to parent via SubagentManager callbacks
@@ -552,84 +589,4 @@ export class SubagentManager {
       },
     };
   }
-
-  /**
-   * Update configuration for SubagentManager and all active subagents
-   * This method updates configuration for live config reload support
-   * @param newGatewayConfig - New gateway configuration
-   * @param newModelConfig - New model configuration
-   * @param newTokenLimit - New token limit
-   */
-  updateConfiguration(
-    newGatewayConfig: GatewayConfig,
-    newModelConfig: ModelConfig,
-    newTokenLimit: number,
-  ): void {
-    this.logger?.info("Live Config: Updating SubagentManager configuration");
-
-    // Update stored configuration
-    this.gatewayConfig = newGatewayConfig;
-    this.modelConfig = newModelConfig;
-    this.tokenLimit = newTokenLimit;
-
-    // Update all active subagent AIManager instances
-    let updatedCount = 0;
-    for (const [subagentId, instance] of this.instances.entries()) {
-      if (instance.status === "active" || instance.status === "initializing") {
-        try {
-          // For subagents, we need to preserve their model if it was explicitly set
-          const subagentModelConfig = {
-            ...newModelConfig,
-            // If subagent has its own model configured, preserve it
-            agentModel:
-              instance.configuration.model &&
-              instance.configuration.model !== "inherit"
-                ? instance.configuration.model
-                : newModelConfig.agentModel,
-          };
-
-          instance.aiManager.updateConfiguration(
-            newGatewayConfig,
-            subagentModelConfig,
-            newTokenLimit,
-          );
-          updatedCount++;
-
-          this.logger?.debug(
-            `Live Config: Updated configuration for subagent ${subagentId}`,
-          );
-        } catch (error) {
-          this.logger?.error(
-            `Live Config: Failed to update configuration for subagent ${subagentId}: ${(error as Error).message}`,
-          );
-        }
-      }
-    }
-
-    this.logger?.info(
-      `Live Config: SubagentManager configuration updated - ${updatedCount} active subagents updated`,
-    );
-  }
-
-  /**
-   * Get current configuration for debugging
-   */
-  getCurrentConfiguration(): {
-    gatewayConfig: GatewayConfig;
-    modelConfig: ModelConfig;
-    tokenLimit: number;
-    activeSubagents: number;
-  } {
-    const activeSubagents = Array.from(this.instances.values()).filter(
-      (instance) =>
-        instance.status === "active" || instance.status === "initializing",
-    ).length;
-
-    return {
-      gatewayConfig: { ...this.gatewayConfig },
-      modelConfig: { ...this.modelConfig },
-      tokenLimit: this.tokenLimit,
-      activeSubagents,
-    };
-  }
 }

package/src/managers/toolManager.ts

@@ -10,30 +10,56 @@ import { grepTool } from "../tools/grepTool.js";
 import { lsTool } from "../tools/lsTool.js";
 import { readTool } from "../tools/readTool.js";
 import { todoWriteTool } from "../tools/todoWriteTool.js";
+import { lspTool } from "../tools/lspTool.js";
 import { createTaskTool } from "../tools/taskTool.js";
 import { createSkillTool } from "../tools/skillTool.js";
 import { McpManager } from "./mcpManager.js";
+import { PermissionManager } from "./permissionManager.js";
 import { ChatCompletionFunctionTool } from "openai/resources.js";
-import type { Logger } from "../types/index.js";
+import type {
+  Logger,
+  PermissionMode,
+  PermissionCallback,
+  ILspManager,
+} from "../types/index.js";
 import type { SubagentManager } from "./subagentManager.js";
 import type { SkillManager } from "./skillManager.js";
 
 export interface ToolManagerOptions {
   mcpManager: McpManager;
+  lspManager?: ILspManager;
   logger?: Logger;
+  /** Optional permission manager for handling tool permission checks */
+  permissionManager?: PermissionManager;
+  /** Permission mode for tool execution (defaults to "default") */
+  permissionMode?: PermissionMode;
+  /** Custom permission callback for tool usage */
+  canUseToolCallback?: PermissionCallback;
 }
 
 /**
  * Tool Manager
+ *
+ * Manages tool registration and execution with optional permission system integration.
+ * Supports both built-in tools and MCP (Model Context Protocol) tools.
  */
 class ToolManager {
   private tools = new Map<string, ToolPlugin>();
   private mcpManager: McpManager;
+  private lspManager?: ILspManager;
   private logger?: Logger;
+  private permissionManager?: PermissionManager;
+  private permissionMode?: PermissionMode;
+  private canUseToolCallback?: PermissionCallback;
 
   constructor(options: ToolManagerOptions) {
     this.mcpManager = options.mcpManager;
+    this.lspManager = options.lspManager;
     this.logger = options.logger;
+    this.permissionManager = options.permissionManager;
+    // Store CLI permission mode, let PermissionManager resolve effective mode
+    this.permissionMode = options.permissionMode;
+    this.canUseToolCallback = options.canUseToolCallback;
   }
 
   /**
@@ -83,6 +109,7 @@ class ToolManager {
       lsTool,
       readTool,
       todoWriteTool,
+      lspTool,
     ];
 
     for (const tool of builtInTools) {
@@ -101,22 +128,66 @@ class ToolManager {
     }
   }
 
+  /**
+   * Execute a tool by name with the provided arguments and context
+   *
+   * Enhances the context with permission-related fields before execution:
+   * - permissionMode: The current permission mode (default or bypassPermissions)
+   * - canUseToolCallback: Custom permission callback if provided
+   * - permissionManager: The PermissionManager instance for permission checks
+   *
+   * @param name - Name of the tool to execute
+   * @param args - Arguments to pass to the tool
+   * @param context - Execution context for the tool
+   * @returns Promise resolving to the tool execution result
+   */
   async execute(
     name: string,
     args: Record<string, unknown>,
     context: ToolContext,
   ): Promise<ToolResult> {
+    // Resolve effective permission mode (CLI override > configuration > default)
+    const effectivePermissionMode = this.permissionManager
+      ? this.permissionManager.getCurrentEffectiveMode(this.permissionMode)
+      : this.permissionMode || "default";
+
+    // Enhance context with permission-related fields
+    const enhancedContext: ToolContext = {
+      ...context,
+      permissionMode: effectivePermissionMode,
+      canUseToolCallback: this.canUseToolCallback,
+      permissionManager: this.permissionManager,
+      mcpManager: this.mcpManager,
+      lspManager: this.lspManager,
+    };
+
+    this.logger?.debug("Executing tool with enhanced context", {
+      toolName: name,
+      cliPermissionMode: this.permissionMode,
+      effectivePermissionMode,
+      hasPermissionManager: !!this.permissionManager,
+      hasPermissionCallback: !!this.canUseToolCallback,
+    });
+
     // Check if it's an MCP tool first
     if (this.mcpManager.isMcpTool(name)) {
-      return this.mcpManager.executeMcpToolByRegistry(name, args, context);
+      return this.mcpManager.executeMcpToolByRegistry(
+        name,
+        args,
+        enhancedContext,
+      );
     }
 
     // Check built-in tools
     const plugin = this.tools.get(name);
     if (plugin) {
       try {
-        return await plugin.execute(args, context);
+        return await plugin.execute(args, enhancedContext);
       } catch (error) {
+        this.logger?.error("Tool execution failed", {
+          toolName: name,
+          error: error instanceof Error ? error.message : String(error),
+        });
         return {
           success: false,
           content: "",
@@ -125,6 +196,7 @@ class ToolManager {
       }
     }
 
+    this.logger?.warn("Tool not found", { toolName: name });
     return {
       success: false,
       content: "",
@@ -145,6 +217,26 @@ class ToolManager {
     const mcpToolsConfig = this.mcpManager.getMcpToolsConfig();
     return [...builtInToolsConfig, ...mcpToolsConfig];
   }
+
+  /**
+   * Get the current permission mode
+   */
+  public getPermissionMode(): PermissionMode {
+    if (this.permissionManager) {
+      return this.permissionManager.getCurrentEffectiveMode(
+        this.permissionMode,
+      );
+    }
+    return this.permissionMode || "default";
+  }
+
+  /**
+   * Set the permission mode
+   * @param mode - The new permission mode
+   */
+  public setPermissionMode(mode: PermissionMode): void {
+    this.permissionMode = mode;
+  }
 }
 
 // Export tool registry class and types