wave-agent-sdk 0.6.4 → 0.7.0

package/src/managers/aiManager.ts

@@ -1,17 +1,9 @@
-import {
-  callAgent,
-  compressMessages,
-  type CallAgentOptions,
-} from "../services/aiService.js";
+import { type CallAgentOptions } from "../services/aiService.js";
+import * as aiService from "../services/aiService.js";
 import { convertMessagesForAPI } from "../utils/convertMessagesForAPI.js";
 import { calculateComprehensiveTotalTokens } from "../utils/tokenCalculation.js";
 import * as fs from "node:fs/promises";
-import type {
-  Logger,
-  GatewayConfig,
-  ModelConfig,
-  Usage,
-} from "../types/index.js";
+import type { 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";
@@ -20,7 +12,12 @@ import { ChatCompletionMessageFunctionToolCall } from "openai/resources.js";
 import type { HookManager } from "./hookManager.js";
 import type { ExtendedHookExecutionContext } from "../types/hooks.js";
 import type { PermissionManager } from "./permissionManager.js";
+import type { SubagentManager } from "./subagentManager.js";
+import type { SkillManager } from "./skillManager.js";
 import { buildSystemPrompt } from "../prompts/index.js";
+import { Container } from "../utils/container.js";
+
+import { logger } from "../utils/globalLogger.js";
 
 export interface AIManagerCallbacks {
   onCompressionStateChange?: (isCompressing: boolean) => void;
@@ -28,18 +25,10 @@ export interface AIManagerCallbacks {
 }
 
 export interface AIManagerOptions {
-  messageManager: MessageManager;
-  toolManager: ToolManager;
-  taskManager: import("../services/taskManager.js").TaskManager;
-  logger?: Logger;
-  backgroundTaskManager?: BackgroundTaskManager;
-  hookManager?: HookManager;
-  permissionManager?: PermissionManager;
   callbacks?: AIManagerCallbacks;
   workdir: string;
   systemPrompt?: string;
   subagentType?: string; // Optional subagent type for hook context
-  reversionManager?: import("./reversionManager.js").ReversionManager;
   /**Whether to use streaming mode for AI responses - defaults to true */
   stream?: boolean;
   // Dynamic configuration getters
@@ -54,14 +43,6 @@ export class AIManager {
   public isLoading: boolean = false;
   private abortController: AbortController | null = null;
   private toolAbortController: AbortController | null = null;
-  private logger?: Logger;
-  private toolManager: ToolManager;
-  private messageManager: MessageManager;
-  private taskManager: import("../services/taskManager.js").TaskManager;
-  private backgroundTaskManager?: BackgroundTaskManager;
-  private hookManager?: HookManager;
-  private reversionManager?: import("./reversionManager.js").ReversionManager;
-  private permissionManager?: PermissionManager;
   private workdir: string;
   private systemPrompt?: string;
   private subagentType?: string; // Store subagent type for hook context
@@ -74,15 +55,11 @@ export class AIManager {
   private getLanguageFn: () => string | undefined;
   private getEnvironmentVarsFn?: () => Record<string, string>;
 
-  constructor(options: AIManagerOptions) {
-    this.messageManager = options.messageManager;
-    this.toolManager = options.toolManager;
-    this.taskManager = options.taskManager;
-    this.backgroundTaskManager = options.backgroundTaskManager;
-    this.hookManager = options.hookManager;
-    this.reversionManager = options.reversionManager;
-    this.permissionManager = options.permissionManager;
-    this.logger = options.logger;
+  // Service overrides
+  constructor(
+    private container: Container,
+    options: AIManagerOptions,
+  ) {
     this.workdir = options.workdir;
     this.systemPrompt = options.systemPrompt;
     this.subagentType = options.subagentType; // Store subagent type
@@ -97,6 +74,40 @@ export class AIManager {
     this.getEnvironmentVarsFn = options.getEnvironmentVars;
   }
 
+  private get toolManager(): ToolManager {
+    return this.container.get<ToolManager>("ToolManager")!;
+  }
+
+  private get messageManager(): MessageManager {
+    return this.container.get<MessageManager>("MessageManager")!;
+  }
+
+  private get taskManager(): import("../services/taskManager.js").TaskManager {
+    return this.container.get<import("../services/taskManager.js").TaskManager>(
+      "TaskManager",
+    )!;
+  }
+
+  private get backgroundTaskManager(): BackgroundTaskManager | undefined {
+    return this.container.get<BackgroundTaskManager>("BackgroundTaskManager");
+  }
+
+  private get hookManager(): HookManager | undefined {
+    return this.container.get<HookManager>("HookManager");
+  }
+
+  private get reversionManager():
+    | import("./reversionManager.js").ReversionManager
+    | undefined {
+    return this.container.get<import("./reversionManager.js").ReversionManager>(
+      "ReversionManager",
+    );
+  }
+
+  private get permissionManager(): PermissionManager | undefined {
+    return this.container.get<PermissionManager>("PermissionManager");
+  }
+
   // Getter methods for accessing dynamic configuration
   public getGatewayConfig(): GatewayConfig {
     return this.getGatewayConfigFn();
@@ -142,7 +153,7 @@ export class AIManager {
       try {
         this.abortController.abort();
       } catch (error) {
-        this.logger?.error("Failed to abort AI service:", error);
+        logger?.error("Failed to abort AI service:", error);
       }
     }
 
@@ -151,7 +162,7 @@ export class AIManager {
       try {
         this.toolAbortController.abort();
       } catch (error) {
-        this.logger?.error("Failed to abort tool execution:", error);
+        logger?.error("Failed to abort tool execution:", error);
       }
     }
 
@@ -175,7 +186,7 @@ export class AIManager {
         return toolPlugin.formatCompactParams(toolArgs, context);
       }
     } catch (error) {
-      this.logger?.warn("Failed to generate compactParams", error);
+      logger?.warn("Failed to generate compactParams", error);
     }
     return "";
   }
@@ -199,7 +210,7 @@ export class AIManager {
         (usage.cache_creation_input_tokens || 0) >
       this.getMaxInputTokens()
     ) {
-      this.logger?.debug(
+      logger?.debug(
         `Token usage exceeded ${this.getMaxInputTokens()}, compressing messages...`,
       );
 
@@ -215,7 +226,7 @@ export class AIManager {
 
         this.setIsCompressing(true);
         try {
-          const compressionResult = await compressMessages({
+          const compressionResult = await aiService.compressMessages({
             gatewayConfig: this.getGatewayConfig(),
             modelConfig: this.getModelConfig(),
             messages: recentChatMessages,
@@ -246,11 +257,11 @@ export class AIManager {
             this.callbacks.onUsageAdded(compressionUsage);
           }
 
-          this.logger?.debug(
+          logger?.debug(
             `Successfully compressed ${messagesToCompress.length} messages and updated session`,
           );
         } catch (compressError) {
-          this.logger?.error("Failed to compress messages:", compressError);
+          logger?.error("Failed to compress messages:", compressError);
         } finally {
           this.setIsCompressing(false);
         }
@@ -269,6 +280,14 @@ export class AIManager {
     }
   }
 
+  private get subagentManager(): SubagentManager | undefined {
+    return this.container.get<SubagentManager>("SubagentManager");
+  }
+
+  private get skillManager(): SkillManager | undefined {
+    return this.container.get<SkillManager>("SkillManager");
+  }
+
   public async sendAIMessage(
     options: {
       recursionDepth?: number;
@@ -334,7 +353,7 @@ export class AIManager {
       // Track if assistant message has been created
       let assistantMessageCreated = false;
 
-      this.logger?.debug("modelConfig in sendAIMessage", this.getModelConfig());
+      logger?.debug("modelConfig in sendAIMessage", this.getModelConfig());
 
       // Get current permission mode and plan file path
       const currentMode = this.permissionManager?.getCurrentEffectiveMode(
@@ -364,6 +383,10 @@ export class AIManager {
         }
       }
 
+      // Get available subagents and skills for dynamic prompts
+      const availableSubagents = this.subagentManager?.getConfigurations();
+      const availableSkills = this.skillManager?.getAvailableSkills();
+
       // Call AI service with streaming callbacks if enabled
       const callAgentOptions: CallAgentOptions = {
         gatewayConfig: this.getGatewayConfig(),
@@ -383,6 +406,8 @@ export class AIManager {
             language: this.getLanguage(),
             isSubagent: !!this.subagentType,
             planMode: planModeOptions,
+            availableSubagents,
+            availableSkills,
           },
         ), // Pass custom system prompt
         maxTokens: maxTokens, // Pass max tokens override
@@ -428,7 +453,7 @@ export class AIManager {
         };
       }
 
-      const result = await callAgent(callAgentOptions);
+      const result = await aiService.callAgent(callAgentOptions);
       const createdByStreaming = assistantMessageCreated;
 
       // For non-streaming mode, create assistant message after callAgent returns
@@ -446,7 +471,7 @@ export class AIManager {
       if (result.finish_reason) {
         // Log warning headers when finish reason is length
         if (result.finish_reason === "length") {
-          this.logger?.warn(
+          logger?.warn(
             "AI response truncated due to length limit. Response headers:",
             result.response_headers,
           );
@@ -456,7 +481,7 @@ export class AIManager {
         result.response_headers &&
         Object.keys(result.response_headers).length > 0
       ) {
-        this.logger?.debug("AI response headers:", result.response_headers);
+        logger?.debug("AI response headers:", result.response_headers);
       }
 
       if (
@@ -566,7 +591,7 @@ export class AIManager {
                   errorMessage +=
                     " (output truncated, please reduce your output)";
                 }
-                this.logger?.error(errorMessage, parseError);
+                logger?.error(errorMessage, parseError);
                 this.messageManager.updateToolBlock({
                   id: toolId,
                   parameters: argsString,
@@ -606,7 +631,7 @@ export class AIManager {
 
               // If PreToolUse hooks blocked execution, skip tool execution
               if (!shouldExecuteTool) {
-                this.logger?.info(
+                logger?.info(
                   `Tool ${toolName} execution blocked by PreToolUse hooks`,
                 );
                 return; // Skip this tool and return from this map function
@@ -720,7 +745,7 @@ export class AIManager {
           toolBlocks.some((block) => block.isManuallyBackgrounded);
 
         if (hasBackgrounded) {
-          this.logger?.info(
+          logger?.info(
             "Some tools were manually backgrounded, stopping recursion.",
           );
         } else if (!isCurrentlyAborted) {
@@ -772,7 +797,7 @@ export class AIManager {
           // If Stop/SubagentStop hooks indicate we should continue (due to blocking errors),
           // restart the AI conversation cycle
           if (shouldContinue) {
-            this.logger?.info(
+            logger?.info(
               `${this.subagentType ? "SubagentStop" : "Stop"} hooks indicate issues need fixing, continuing conversation...`,
             );
 
@@ -828,7 +853,7 @@ export class AIManager {
 
         // If hook processing indicates we should block (exit code 2), continue conversation
         if (processResult.shouldBlock) {
-          this.logger?.info(
+          logger?.info(
             `${hookName} hook blocked stopping with error:`,
             processResult.errorMessage,
           );
@@ -838,7 +863,7 @@ export class AIManager {
 
       // Log hook execution results for debugging
       if (results.length > 0) {
-        this.logger?.debug(
+        logger?.debug(
           `Executed ${results.length} ${hookName} hook(s):`,
           results.map((r) => ({
             success: r.success,
@@ -853,7 +878,7 @@ export class AIManager {
       return shouldContinue;
     } catch (error) {
       // Hook execution errors should not interrupt the main workflow
-      this.logger?.error(
+      logger?.error(
         `${this.subagentType ? "SubagentStop" : "Stop"} hook execution failed:`,
         error,
       );
@@ -906,7 +931,7 @@ export class AIManager {
 
       // Log hook execution results for debugging
       if (results.length > 0) {
-        this.logger?.debug(
+        logger?.debug(
           `Executed ${results.length} PreToolUse hook(s) for ${toolName}:`,
           results.map((r) => ({
             success: r.success,
@@ -921,7 +946,7 @@ export class AIManager {
       return shouldContinue;
     } catch (error) {
       // Hook execution errors should not interrupt the main workflow
-      this.logger?.error("PreToolUse hook execution failed:", error);
+      logger?.error("PreToolUse hook execution failed:", error);
       return true; // Allow tool execution on hook errors
     }
   }
@@ -969,7 +994,7 @@ export class AIManager {
 
       // Log hook execution results for debugging
       if (results.length > 0) {
-        this.logger?.debug(
+        logger?.debug(
           `Executed ${results.length} PostToolUse hook(s) for ${toolName}:`,
           results.map((r) => ({
             success: r.success,
@@ -982,7 +1007,7 @@ export class AIManager {
       }
     } catch (error) {
       // Hook execution errors should not interrupt the main workflow
-      this.logger?.error("PostToolUse hook execution failed:", error);
+      logger?.error("PostToolUse hook execution failed:", error);
     }
   }
 }

package/src/managers/backgroundTaskManager.ts

@@ -2,6 +2,7 @@ import { spawn, type ChildProcess } from "child_process";
 import { BackgroundTask, BackgroundShell } from "../types/processes.js";
 import { stripAnsiColors } from "../utils/stringUtils.js";
 import { logger } from "../utils/globalLogger.js";
+import { Container } from "../utils/container.js";
 
 export interface BackgroundTaskManagerCallbacks {
   onTasksChange?: (tasks: BackgroundTask[]) => void;
@@ -18,7 +19,10 @@ export class BackgroundTaskManager {
   private callbacks: BackgroundTaskManagerCallbacks;
   private workdir: string;
 
-  constructor(options: BackgroundTaskManagerOptions) {
+  constructor(
+    private container: Container,
+    options: BackgroundTaskManagerOptions,
+  ) {
     this.callbacks = options.callbacks || {};
     this.workdir = options.workdir;
   }

package/src/managers/bashManager.ts

@@ -1,8 +1,8 @@
 import { spawn, type ChildProcess } from "child_process";
 import type { MessageManager } from "./messageManager.js";
+import { Container } from "../utils/container.js";
 
 export interface BashManagerOptions {
-  messageManager: MessageManager;
   workdir: string;
 }
 
@@ -13,13 +13,18 @@ export interface CommandExecutionResult {
 
 export class BashManager {
   private workdir: string;
-  private messageManager: MessageManager;
   public isCommandRunning = false;
   private currentProcess: ChildProcess | null = null;
 
-  constructor(options: BashManagerOptions) {
+  constructor(
+    private container: Container,
+    options: BashManagerOptions,
+  ) {
     this.workdir = options.workdir;
-    this.messageManager = options.messageManager;
+  }
+
+  private get messageManager(): MessageManager {
+    return this.container.get<MessageManager>("MessageManager")!;
   }
 
   private setCommandRunning(isRunning: boolean): void {

package/src/managers/foregroundTaskManager.ts

@@ -1,8 +1,11 @@
 import { ForegroundTask, IForegroundTaskManager } from "../types/processes.js";
+import { Container } from "../utils/container.js";
 
 export class ForegroundTaskManager implements IForegroundTaskManager {
   private activeForegroundTasks: ForegroundTask[] = [];
 
+  constructor(private container: Container) {}
+
   public registerForegroundTask(task: ForegroundTask): void {
     this.activeForegroundTasks.push(task);
   }

package/src/managers/hookManager.ts

@@ -22,24 +22,24 @@ import type {
 } from "../types/configuration.js";
 import { HookMatcher } from "../utils/hookMatcher.js";
 import { executeCommand, isCommandSafe } from "../services/hook.js";
-import type { Logger } from "../types/index.js";
 import { MessageSource } from "../types/index.js";
 import type { MessageManager } from "./messageManager.js";
+import { Container } from "../utils/container.js";
+
+import { logger } from "../utils/globalLogger.js";
 
 export class HookManager {
   private configuration: PartialHookConfiguration | undefined;
   private readonly matcher: HookMatcher;
-  private readonly logger?: Logger;
   private readonly workdir: string;
 
   constructor(
+    private container: Container,
     workdir: string,
     matcher: HookMatcher = new HookMatcher(),
-    logger?: Logger,
   ) {
     this.workdir = workdir;
     this.matcher = matcher;
-    this.logger = logger;
   }
 
   /**
@@ -80,7 +80,7 @@ export class HookManager {
    */
   loadConfigurationFromWaveConfig(waveConfig: WaveConfiguration | null): void {
     try {
-      this.logger?.debug(
+      logger?.debug(
         `[HookManager] Loading hooks configuration from pre-loaded config...`,
       );
 
@@ -97,7 +97,7 @@ export class HookManager {
         }
       }
 
-      this.logger?.debug(
+      logger?.debug(
         `[HookManager] Hooks configuration loaded successfully with ${Object.keys(waveConfig?.hooks || {}).length} event types`,
       );
     } catch (error) {
@@ -108,7 +108,7 @@ export class HookManager {
       if (error instanceof HookConfigurationError) {
         throw error;
       } else {
-        this.logger?.warn(
+        logger?.warn(
           `[HookManager] Failed to load configuration, continuing with no hooks: ${(error as Error).message}`,
         );
       }
@@ -125,7 +125,7 @@ export class HookManager {
     // Validate execution context
     const contextValidation = this.validateExecutionContext(event, context);
     if (!contextValidation.valid) {
-      this.logger?.error(
+      logger?.error(
         `[HookManager] Invalid execution context for ${event}: ${contextValidation.errors.join(", ")}`,
       );
       return [
@@ -139,7 +139,7 @@ export class HookManager {
     }
 
     if (!this.configuration) {
-      this.logger?.debug(
+      logger?.debug(
         `[HookManager] No configuration loaded, skipping ${event} hooks`,
       );
       return [];
@@ -147,13 +147,11 @@ export class HookManager {
 
     const eventConfigs = this.configuration[event];
     if (!eventConfigs || eventConfigs.length === 0) {
-      this.logger?.debug(
-        `[HookManager] No hooks configured for ${event} event`,
-      );
+      logger?.debug(`[HookManager] No hooks configured for ${event} event`);
       return [];
     }
 
-    this.logger?.debug(
+    logger?.debug(
       `[HookManager] Starting ${event} hook execution with ${eventConfigs.length} configurations`,
     );
 
@@ -169,13 +167,13 @@ export class HookManager {
 
       // Check if this config applies to the current context
       if (!this.configApplies(config, event, context.toolName)) {
-        this.logger?.debug(
+        logger?.debug(
           `[HookManager] Skipping configuration ${configIndex + 1}: matcher '${config.matcher}' does not match tool '${context.toolName}'`,
         );
         continue;
       }
 
-      this.logger?.debug(
+      logger?.debug(
         `[HookManager] Executing configuration ${configIndex + 1} with ${config.hooks.length} commands (matcher: ${config.matcher || "any"})`,
       );
 
@@ -188,7 +186,7 @@ export class HookManager {
         const hookCommand = config.hooks[commandIndex];
 
         try {
-          this.logger?.debug(
+          logger?.debug(
             `[HookManager] Executing command ${commandIndex + 1}/${config.hooks.length} in configuration ${configIndex + 1}`,
           );
 
@@ -201,11 +199,11 @@ export class HookManager {
 
           // Report individual command result
           if (result.success) {
-            this.logger?.debug(
+            logger?.debug(
               `[HookManager] Command ${commandIndex + 1} completed successfully in ${result.duration}ms`,
             );
           } else {
-            this.logger?.debug(
+            logger?.debug(
               `[HookManager] Command ${commandIndex + 1} failed in ${result.duration}ms (exit code: ${result.exitCode}, timed out: ${result.timedOut})`,
             );
           }
@@ -216,7 +214,7 @@ export class HookManager {
           // This should be rare as executor handles most errors
           const errorMessage =
             error instanceof Error ? error.message : "Unknown execution error";
-          this.logger?.error(
+          logger?.error(
             `[HookManager] Unexpected error in command ${commandIndex + 1}: ${errorMessage}`,
           );
 
@@ -237,7 +235,7 @@ export class HookManager {
       results,
       totalDuration,
     );
-    this.logger?.debug(`[HookManager] ${event} execution summary: ${summary}`);
+    logger?.debug(`[HookManager] ${event} execution summary: ${summary}`);
 
     return results;
   }
@@ -552,7 +550,7 @@ export class HookManager {
 
     // Warn about event mismatch but don't fail validation
     if (context.event !== event) {
-      this.logger?.warn(
+      logger?.warn(
         `[HookManager] Context event '${context.event}' does not match requested event '${event}'`,
       );
     }
@@ -582,7 +580,7 @@ export class HookManager {
         event === "SubagentStop") &&
       context.toolName !== undefined
     ) {
-      this.logger?.warn(
+      logger?.warn(
         `[HookManager] ${event} event has unexpected toolName in context: ${context.toolName}`,
       );
     }
@@ -790,7 +788,7 @@ export class HookManager {
 
     this.mergeHooksConfiguration(this.configuration, hooks);
 
-    this.logger?.debug(
+    logger?.debug(
       `Registered plugin hooks. Total event types: ${Object.keys(this.configuration).length}`,
     );
   }