wave-agent-sdk 0.0.8 → 0.0.11

package/src/index.ts

@@ -4,14 +4,17 @@ export * from "./services/memory.js";
 export * from "./services/session.js";
 export * from "./services/hook.js";
 export * from "./services/jsonlHandler.js";
+export * from "./services/configurationService.js"; // New configuration management service
 
 // Export main agent
 export * from "./agent.js";
 
 // Export all utilities
 export * from "./utils/bashHistory.js";
+export * from "./utils/bashParser.js";
 export * from "./utils/convertMessagesForAPI.js";
 export * from "./utils/fileFilter.js";
+export * from "./utils/fileSearch.js";
 export * from "./utils/globalLogger.js";
 export * from "./utils/mcpUtils.js";
 export * from "./utils/messageOperations.js";

package/src/managers/aiManager.ts

@@ -1,4 +1,8 @@
-import { callAgent, compressMessages } from "../services/aiService.js";
+import {
+  callAgent,
+  compressMessages,
+  type CallAgentOptions,
+} from "../services/aiService.js";
 import { getMessagesToCompress } from "../utils/messageOperations.js";
 import { convertMessagesForAPI } from "../utils/convertMessagesForAPI.js";
 import { calculateComprehensiveTotalTokens } from "../utils/tokenCalculation.js";
@@ -32,10 +36,13 @@ export interface AIManagerOptions {
   workdir: string;
   systemPrompt?: string;
   subagentType?: string; // Optional subagent type for hook context
-  // Resolved configuration
-  gatewayConfig: GatewayConfig;
-  modelConfig: ModelConfig;
-  tokenLimit: number;
+  /**Whether to use streaming mode for AI responses - defaults to true */
+  stream?: boolean;
+  // Dynamic configuration getters
+  getGatewayConfig: () => GatewayConfig;
+  getModelConfig: () => ModelConfig;
+  getTokenLimit: () => number;
+  getEnvironmentVars?: () => Record<string, string>; // Get configuration environment variables for hooks
 }
 
 export class AIManager {
@@ -50,11 +57,13 @@ export class AIManager {
   private workdir: string;
   private systemPrompt?: string;
   private subagentType?: string; // Store subagent type for hook context
+  private stream: boolean; // Streaming mode flag
 
-  // Configuration properties
-  private gatewayConfig: GatewayConfig;
-  private modelConfig: ModelConfig;
-  private tokenLimit: number;
+  // Configuration properties (replaced with getter function storage)
+  private getGatewayConfigFn: () => GatewayConfig;
+  private getModelConfigFn: () => ModelConfig;
+  private getTokenLimitFn: () => number;
+  private getEnvironmentVarsFn?: () => Record<string, string>;
 
   constructor(options: AIManagerOptions) {
     this.messageManager = options.messageManager;
@@ -65,84 +74,31 @@ export class AIManager {
     this.workdir = options.workdir;
     this.systemPrompt = options.systemPrompt;
     this.subagentType = options.subagentType; // Store subagent type
+    this.stream = options.stream ?? true; // Default to true if not specified
     this.callbacks = options.callbacks ?? {};
 
-    // Store resolved configuration
-    this.gatewayConfig = options.gatewayConfig;
-    this.modelConfig = options.modelConfig;
-    this.tokenLimit = options.tokenLimit;
+    // Store configuration getter functions for dynamic resolution
+    this.getGatewayConfigFn = options.getGatewayConfig;
+    this.getModelConfigFn = options.getModelConfig;
+    this.getTokenLimitFn = options.getTokenLimit;
+    this.getEnvironmentVarsFn = options.getEnvironmentVars;
   }
 
-  private isCompressing: boolean = false;
-  private callbacks: AIManagerCallbacks;
-
-  /**
-   * Update gateway configuration at runtime for live config reload
-   * @param newConfig - New gateway configuration
-   */
-  updateGatewayConfig(newConfig: GatewayConfig): void {
-    this.logger?.info(
-      `Live Config: Updating AIManager gateway config - baseURL: ${newConfig.baseURL}`,
-    );
-    this.gatewayConfig = newConfig;
+  // Getter methods for accessing dynamic configuration
+  public getGatewayConfig(): GatewayConfig {
+    return this.getGatewayConfigFn();
   }
 
-  /**
-   * Update model configuration at runtime for live config reload
-   * @param newConfig - New model configuration
-   */
-  updateModelConfig(newConfig: ModelConfig): void {
-    this.logger?.info(
-      `Live Config: Updating AIManager model config - agent: ${newConfig.agentModel}, fast: ${newConfig.fastModel}`,
-    );
-    this.modelConfig = newConfig;
-  }
-
-  /**
-   * Update token limit at runtime for live config reload
-   * @param newLimit - New token limit
-   */
-  updateTokenLimit(newLimit: number): void {
-    this.logger?.info(
-      `Live Config: Updating AIManager token limit: ${newLimit}`,
-    );
-    this.tokenLimit = newLimit;
+  public getModelConfig(): ModelConfig {
+    return this.getModelConfigFn();
   }
 
-  /**
-   * Update all configurations at once for live config reload
-   * @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 all AIManager configuration");
-    this.gatewayConfig = newGatewayConfig;
-    this.modelConfig = newModelConfig;
-    this.tokenLimit = newTokenLimit;
-    this.logger?.info(
-      `Live Config: Configuration updated - model: ${newModelConfig.agentModel}, tokenLimit: ${newTokenLimit}`,
-    );
+  public getTokenLimit(): number {
+    return this.getTokenLimitFn();
   }
 
-  /**
-   * Get current configuration for debugging
-   */
-  getCurrentConfiguration(): {
-    gatewayConfig: GatewayConfig;
-    modelConfig: ModelConfig;
-    tokenLimit: number;
-  } {
-    return {
-      gatewayConfig: { ...this.gatewayConfig },
-      modelConfig: { ...this.modelConfig },
-      tokenLimit: this.tokenLimit,
-    };
-  }
+  private isCompressing: boolean = false;
+  private callbacks: AIManagerCallbacks;
 
   /**
    * Get filtered tool configuration
@@ -222,10 +178,10 @@ export class AIManager {
       usage.total_tokens +
         (usage.cache_read_input_tokens || 0) +
         (usage.cache_creation_input_tokens || 0) >
-      this.tokenLimit
+      this.getTokenLimit()
     ) {
       this.logger?.debug(
-        `Token usage exceeded ${this.tokenLimit}, compressing messages...`,
+        `Token usage exceeded ${this.getTokenLimit()}, compressing messages...`,
       );
 
       // Check if messages need compression
@@ -244,8 +200,8 @@ export class AIManager {
         this.setIsCompressing(true);
         try {
           const compressionResult = await compressMessages({
-            gatewayConfig: this.gatewayConfig,
-            modelConfig: this.modelConfig,
+            gatewayConfig: this.getGatewayConfig(),
+            modelConfig: this.getModelConfig(),
             messages: recentChatMessages,
             abortSignal: abortController.signal,
           });
@@ -257,7 +213,7 @@ export class AIManager {
               prompt_tokens: compressionResult.usage.prompt_tokens,
               completion_tokens: compressionResult.usage.completion_tokens,
               total_tokens: compressionResult.usage.total_tokens,
-              model: this.modelConfig.fastModel,
+              model: this.getModelConfig().fastModel,
               operation_type: "compress",
             };
           }
@@ -348,13 +304,15 @@ export class AIManager {
         this.workdir,
       );
 
-      // Add assistant message first (for streaming updates)
-      this.messageManager.addAssistantMessage();
+      // Track if assistant message has been created
+      let assistantMessageCreated = false;
+
+      this.logger?.debug("modelConfig in sendAIMessage", this.getModelConfig());
 
-      // Call AI service with streaming callbacks
-      const result = await callAgent({
-        gatewayConfig: this.gatewayConfig,
-        modelConfig: this.modelConfig,
+      // Call AI service with streaming callbacks if enabled
+      const callAgentOptions: CallAgentOptions = {
+        gatewayConfig: this.getGatewayConfig(),
+        modelConfig: this.getModelConfig(),
         messages: recentMessages,
         sessionId: this.messageManager.getSessionId(),
         abortSignal: abortController.signal,
@@ -363,14 +321,27 @@ export class AIManager {
         tools: this.getFilteredToolsConfig(allowedTools), // Pass filtered tool configuration
         model: model, // Use passed model
         systemPrompt: this.systemPrompt, // Pass custom system prompt
-        // Streaming callbacks
-        onContentUpdate: (content: string) => {
+      };
+
+      // Add streaming callbacks only if streaming is enabled
+      if (this.stream) {
+        callAgentOptions.onContentUpdate = (content: string) => {
+          // Create assistant message on first chunk if not already created
+          if (!assistantMessageCreated) {
+            this.messageManager.addAssistantMessage();
+            assistantMessageCreated = true;
+          }
           this.messageManager.updateCurrentMessageContent(content);
-        },
-        onToolUpdate: (toolCall) => {
+        };
+        callAgentOptions.onToolUpdate = (toolCall) => {
+          // Create assistant message on first tool update if not already created
+          if (!assistantMessageCreated) {
+            this.messageManager.addAssistantMessage();
+            assistantMessageCreated = true;
+          }
+
           // Use parametersChunk as compact param for better performance
           // No need to extract params or generate compact params during streaming
-          this.logger?.debug("Tool streaming update:", toolCall);
 
           // Update tool block with streaming parameters using parametersChunk as compact param
           this.messageManager.updateToolBlock({
@@ -381,8 +352,30 @@ export class AIManager {
             compactParams: toolCall.parameters?.split("\n").pop()?.slice(-30),
             stage: toolCall.stage || "streaming", // Default to streaming if stage not provided
           });
-        },
-      });
+        };
+        callAgentOptions.onReasoningUpdate = (reasoning: string) => {
+          // Create assistant message on first reasoning update if not already created
+          if (!assistantMessageCreated) {
+            this.messageManager.addAssistantMessage();
+            assistantMessageCreated = true;
+          }
+          this.messageManager.updateCurrentMessageReasoning(reasoning);
+        };
+      }
+
+      const result = await callAgent(callAgentOptions);
+      const createdByStreaming = assistantMessageCreated;
+
+      // For non-streaming mode, create assistant message after callAgent returns
+      // Also create if streaming mode but no streaming callbacks were called (e.g., when content comes directly in result)
+      if (
+        !this.stream ||
+        (!assistantMessageCreated &&
+          (result.content || result.tool_calls || result.reasoning_content))
+      ) {
+        this.messageManager.addAssistantMessage();
+        assistantMessageCreated = true;
+      }
 
       // Log finish reason and response headers if available
       if (result.finish_reason) {
@@ -397,12 +390,24 @@ export class AIManager {
         this.logger?.debug("AI response headers:", result.response_headers);
       }
 
-      if (result.metadata && Object.keys(result.metadata).length > 0) {
-        this.messageManager.mergeAssistantMetadata(result.metadata);
+      if (
+        result.additionalFields &&
+        Object.keys(result.additionalFields).length > 0
+      ) {
+        this.messageManager.mergeAssistantAdditionalFields(
+          result.additionalFields,
+        );
+      }
+
+      // Handle result reasoning content from non-streaming mode
+      if (result.reasoning_content && !createdByStreaming) {
+        this.messageManager.updateCurrentMessageReasoning(
+          result.reasoning_content,
+        );
       }
 
       // Handle result content from non-streaming mode
-      if (result.content) {
+      if (result.content && !createdByStreaming) {
         this.messageManager.updateCurrentMessageContent(result.content);
       }
 
@@ -413,7 +418,7 @@ export class AIManager {
           prompt_tokens: result.usage.prompt_tokens,
           completion_tokens: result.usage.completion_tokens,
           total_tokens: result.usage.total_tokens,
-          model: model || this.modelConfig.agentModel,
+          model: model || this.getModelConfig().agentModel,
           operation_type: "agent",
           // Preserve cache fields if present
           ...(result.usage.cache_read_input_tokens !== undefined && {
@@ -557,18 +562,6 @@ export class AIManager {
                 shortResult: toolResult.shortResult,
               });
 
-              // 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,
@@ -682,6 +675,7 @@ export class AIManager {
         cwd: this.workdir,
         subagentType: this.subagentType, // Include subagent type in hook context
         // Stop hooks don't need toolName, toolInput, toolResponse, or userPrompt
+        env: this.getEnvironmentVarsFn?.() || {}, // Include configuration environment variables
       };
 
       const results = await this.hookManager.executeHooks(hookName, context);
@@ -752,6 +746,7 @@ export class AIManager {
         cwd: this.workdir,
         toolInput,
         subagentType: this.subagentType, // Include subagent type in hook context
+        env: this.getEnvironmentVarsFn?.() || {}, // Include configuration environment variables
       };
 
       const results = await this.hookManager.executeHooks(
@@ -817,6 +812,7 @@ export class AIManager {
         toolInput,
         toolResponse,
         subagentType: this.subagentType, // Include subagent type in hook context
+        env: this.getEnvironmentVarsFn?.() || {}, // Include configuration environment variables
       };
 
       const results = await this.hookManager.executeHooks(

package/src/managers/backgroundBashManager.ts

@@ -1,5 +1,6 @@
 import { spawn } from "child_process";
 import { logger } from "../utils/globalLogger.js";
+import { stripAnsiColors } from "../utils/stringUtils.js";
 import type { BackgroundShell } from "../types/index.js";
 
 export interface BackgroundBashManagerCallbacks {
@@ -63,12 +64,12 @@ export class BackgroundBashManager {
     }
 
     child.stdout?.on("data", (data) => {
-      shell.stdout += data.toString();
+      shell.stdout += stripAnsiColors(data.toString());
       this.notifyShellsChange();
     });
 
     child.stderr?.on("data", (data) => {
-      shell.stderr += data.toString();
+      shell.stderr += stripAnsiColors(data.toString());
       this.notifyShellsChange();
     });
 
@@ -87,7 +88,7 @@ export class BackgroundBashManager {
         clearTimeout(timeoutHandle);
       }
       shell.status = "completed";
-      shell.stderr += `\nProcess error: ${error.message}`;
+      shell.stderr += `\nProcess error: ${stripAnsiColors(error.message)}`;
       shell.exitCode = 1;
       shell.runtime = Date.now() - startTime;
       this.notifyShellsChange();

package/src/managers/hookManager.ts

@@ -19,18 +19,13 @@ import {
   isValidHookEventConfig,
 } from "../types/hooks.js";
 import { HookMatcher } from "../utils/hookMatcher.js";
-import {
-  executeCommand,
-  isCommandSafe,
-  loadMergedWaveConfig,
-} from "../services/hook.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";
 
 export class HookManager {
   private configuration: PartialHookConfiguration | undefined;
-  private environmentVars: Record<string, string> | undefined;
   private readonly matcher: HookMatcher;
   private readonly logger?: Logger;
   private readonly workdir: string;
@@ -78,49 +73,41 @@ export class HookManager {
   }
 
   /**
-   * Load configuration from filesystem settings
-   * Automatically loads and merges user and project Wave configuration (hooks + environment)
+   * Load hooks configuration from a pre-loaded WaveConfiguration
+   * Configuration loading is now handled by ConfigurationService
    */
-  loadConfigurationFromSettings(): void {
+  loadConfigurationFromWaveConfig(waveConfig: WaveConfiguration | null): void {
     try {
-      this.logger?.debug(`[HookManager] Loading configuration...`);
-      const mergedWaveConfig = loadMergedWaveConfig(this.workdir);
       this.logger?.debug(
-        `[HookManager] Merged config result:`,
-        mergedWaveConfig,
+        `[HookManager] Loading hooks configuration from pre-loaded config...`,
       );
 
-      this.configuration = mergedWaveConfig?.hooks || undefined;
-      this.environmentVars = mergedWaveConfig?.env || undefined;
+      this.configuration = waveConfig?.hooks || undefined;
 
       // Validate the loaded configuration if it exists
-      if (mergedWaveConfig?.hooks) {
-        const validation = this.validatePartialConfiguration(
-          mergedWaveConfig.hooks,
-        );
+      if (waveConfig?.hooks) {
+        const validation = this.validatePartialConfiguration(waveConfig.hooks);
         if (!validation.valid) {
           throw new HookConfigurationError(
-            "filesystem settings",
+            "provided configuration",
             validation.errors,
           );
         }
       }
 
       this.logger?.debug(
-        `[HookManager] Configuration loaded successfully with ${Object.keys(mergedWaveConfig?.hooks || {}).length} event types and ${Object.keys(this.environmentVars || {}).length} environment variables`,
+        `[HookManager] Hooks configuration loaded successfully with ${Object.keys(waveConfig?.hooks || {}).length} event types`,
       );
     } catch (error) {
       // If loading fails, start with undefined configuration (no hooks)
       this.configuration = undefined;
-      this.environmentVars = undefined;
 
-      // Re-throw configuration errors, but handle file system errors gracefully
+      // Re-throw configuration errors, but handle other errors gracefully
       if (error instanceof HookConfigurationError) {
         throw error;
       } else {
         this.logger?.warn(
-          "Failed to load hooks configuration from settings:",
-          error,
+          `[HookManager] Failed to load configuration, continuing with no hooks: ${(error as Error).message}`,
         );
       }
     }
@@ -207,7 +194,6 @@ export class HookManager {
             hookCommand.command,
             context,
             undefined,
-            this.environmentVars,
           );
           results.push(result);
 
@@ -379,6 +365,19 @@ export class HookManager {
         });
         return { shouldBlock: true, errorMessage };
 
+      case "Notification":
+        // For notification hooks with exit code 2, only show stderr in error block
+        messageManager.addErrorBlock(errorMessage);
+        return { shouldBlock: false };
+
+      case "SubagentStop":
+        // Similar to Stop, show error and allow blocking
+        messageManager.addUserMessage({
+          content: errorMessage,
+          source: MessageSource.HOOK,
+        });
+        return { shouldBlock: true, errorMessage };
+
       default:
         return { shouldBlock: false };
     }
@@ -528,16 +527,6 @@ export class HookManager {
     return JSON.parse(JSON.stringify(this.configuration));
   }
 
-  /**
-   * Get current environment variables
-   */
-  getEnvironmentVars(): Record<string, string> | undefined {
-    if (!this.environmentVars) return undefined;
-
-    // Deep clone to prevent external modification
-    return JSON.parse(JSON.stringify(this.environmentVars));
-  }
-
   /**
    * Clear current configuration
    */
@@ -585,7 +574,10 @@ export class HookManager {
 
     // Validate non-tool events don't have unexpected tool names
     if (
-      (event === "UserPromptSubmit" || event === "Stop") &&
+      (event === "UserPromptSubmit" ||
+        event === "Stop" ||
+        event === "Notification" ||
+        event === "SubagentStop") &&
       context.toolName !== undefined
     ) {
       this.logger?.warn(
@@ -657,7 +649,12 @@ export class HookManager {
     toolName?: string,
   ): boolean {
     // For events that don't use matchers, config always applies
-    if (event === "UserPromptSubmit" || event === "Stop") {
+    if (
+      event === "UserPromptSubmit" ||
+      event === "Stop" ||
+      event === "Notification" ||
+      event === "SubagentStop"
+    ) {
       return true;
     }
 
@@ -703,7 +700,13 @@ export class HookManager {
     }
 
     // Validate that non-tool events don't have matchers
-    if ((event === "UserPromptSubmit" || event === "Stop") && config.matcher) {
+    if (
+      (event === "UserPromptSubmit" ||
+        event === "Stop" ||
+        event === "Notification" ||
+        event === "SubagentStop") &&
+      config.matcher
+    ) {
       errors.push(`${prefix}: Event ${event} should not have a matcher`);
     }
 
@@ -739,6 +742,7 @@ export class HookManager {
           UserPromptSubmit: 0,
           Stop: 0,
           SubagentStop: 0,
+          Notification: 0,
         },
       };
     }
@@ -749,6 +753,7 @@ export class HookManager {
       UserPromptSubmit: 0,
       Stop: 0,
       SubagentStop: 0,
+      Notification: 0,
     };
 
     let totalConfigs = 0;