wave-agent-sdk 0.0.6 → 0.0.8

package/dist/managers/aiManager.js

@@ -1,6 +1,7 @@
 import { callAgent, compressMessages } from "../services/aiService.js";
 import { getMessagesToCompress } from "../utils/messageOperations.js";
 import { convertMessagesForAPI } from "../utils/convertMessagesForAPI.js";
+import { calculateComprehensiveTotalTokens } from "../utils/tokenCalculation.js";
 import * as memory from "../services/memory.js";
 export class AIManager {
     constructor(options) {
@@ -15,12 +16,60 @@ export class AIManager {
         this.logger = options.logger;
         this.workdir = options.workdir;
         this.systemPrompt = options.systemPrompt;
+        this.subagentType = options.subagentType; // Store subagent type
         this.callbacks = options.callbacks ?? {};
         // Store resolved configuration
         this.gatewayConfig = options.gatewayConfig;
         this.modelConfig = options.modelConfig;
         this.tokenLimit = options.tokenLimit;
     }
+    /**
+     * Update gateway configuration at runtime for live config reload
+     * @param newConfig - New gateway configuration
+     */
+    updateGatewayConfig(newConfig) {
+        this.logger?.info(`Live Config: Updating AIManager gateway config - baseURL: ${newConfig.baseURL}`);
+        this.gatewayConfig = newConfig;
+    }
+    /**
+     * Update model configuration at runtime for live config reload
+     * @param newConfig - New model configuration
+     */
+    updateModelConfig(newConfig) {
+        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) {
+        this.logger?.info(`Live Config: Updating AIManager token limit: ${newLimit}`);
+        this.tokenLimit = newLimit;
+    }
+    /**
+     * 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, newModelConfig, newTokenLimit) {
+        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}`);
+    }
+    /**
+     * Get current configuration for debugging
+     */
+    getCurrentConfiguration() {
+        return {
+            gatewayConfig: { ...this.gatewayConfig },
+            modelConfig: { ...this.modelConfig },
+            tokenLimit: this.tokenLimit,
+        };
+    }
     /**
      * Get filtered tool configuration
      */
@@ -73,22 +122,28 @@ export class AIManager {
         catch (error) {
             this.logger?.warn("Failed to generate compactParams", error);
         }
-        return undefined;
+        return "";
     }
     // Private method to handle token statistics and message compression
     async handleTokenUsageAndCompression(usage, abortController) {
         if (!usage)
             return;
-        // Update token statistics - display latest token usage
-        this.messageManager.setlatestTotalTokens(usage.total_tokens);
+        // Update token statistics - display comprehensive token usage including cache tokens
+        const comprehensiveTotalTokens = calculateComprehensiveTotalTokens(usage);
+        this.messageManager.setlatestTotalTokens(comprehensiveTotalTokens);
         // Check if token limit exceeded - use injected configuration
-        if (usage.total_tokens > this.tokenLimit) {
+        if (usage.total_tokens +
+            (usage.cache_read_input_tokens || 0) +
+            (usage.cache_creation_input_tokens || 0) >
+            this.tokenLimit) {
             this.logger?.debug(`Token usage exceeded ${this.tokenLimit}, compressing messages...`);
             // Check if messages need compression
             const { messagesToCompress, insertIndex } = getMessagesToCompress(this.messageManager.getMessages(), 7);
             // If there are messages to compress, perform compression
             if (messagesToCompress.length > 0) {
                 const recentChatMessages = convertMessagesForAPI(messagesToCompress);
+                // Save session before compression to preserve original messages
+                await this.messageManager.saveSession();
                 this.setIsCompressing(true);
                 try {
                     const compressionResult = await compressMessages({
@@ -97,21 +152,22 @@ export class AIManager {
                         messages: recentChatMessages,
                         abortSignal: abortController.signal,
                     });
-                    // Execute message reconstruction and sessionId update after compression
-                    this.messageManager.compressMessagesAndUpdateSession(insertIndex, compressionResult.content);
                     // Handle usage tracking for compression operations
+                    let compressionUsage;
                     if (compressionResult.usage) {
-                        const usage = {
+                        compressionUsage = {
                             prompt_tokens: compressionResult.usage.prompt_tokens,
                             completion_tokens: compressionResult.usage.completion_tokens,
                             total_tokens: compressionResult.usage.total_tokens,
                             model: this.modelConfig.fastModel,
                             operation_type: "compress",
                         };
-                        // Notify Agent to add to usage tracking
-                        if (this.callbacks?.onUsageAdded) {
-                            this.callbacks.onUsageAdded(usage);
-                        }
+                    }
+                    // Execute message reconstruction and sessionId update after compression
+                    this.messageManager.compressMessagesAndUpdateSession(insertIndex, compressionResult.content, compressionUsage);
+                    // Notify Agent to add to usage tracking
+                    if (compressionUsage && this.callbacks?.onUsageAdded) {
+                        this.callbacks.onUsageAdded(compressionUsage);
                     }
                     this.logger?.debug(`Successfully compressed ${messagesToCompress.length} messages and updated session`);
                 }
@@ -139,6 +195,8 @@ export class AIManager {
         if (recursionDepth === 0 && this.isLoading) {
             return;
         }
+        // Save session in each recursion to ensure message persistence
+        await this.messageManager.saveSession();
         // Only create new AbortControllers for the initial call (recursionDepth === 0)
         // For recursive calls, reuse existing controllers to maintain abort signal
         let abortController;
@@ -164,7 +222,9 @@ export class AIManager {
         try {
             // Get combined memory content
             const combinedMemory = await memory.getCombinedMemoryContent(this.workdir);
-            // Call AI service (non-streaming)
+            // Add assistant message first (for streaming updates)
+            this.messageManager.addAssistantMessage();
+            // Call AI service with streaming callbacks
             const result = await callAgent({
                 gatewayConfig: this.gatewayConfig,
                 modelConfig: this.modelConfig,
@@ -176,16 +236,39 @@ 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) => {
+                    this.messageManager.updateCurrentMessageContent(content);
+                },
+                onToolUpdate: (toolCall) => {
+                    // 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({
+                        id: toolCall.id,
+                        name: toolCall.name,
+                        parameters: toolCall.parameters,
+                        parametersChunk: toolCall.parametersChunk,
+                        compactParams: toolCall.parameters?.split("\n").pop()?.slice(-30),
+                        stage: toolCall.stage || "streaming", // Default to streaming if stage not provided
+                    });
+                },
             });
-            // Collect content and tool calls
-            const content = result.content || "";
-            const toolCalls = [];
-            if (result.tool_calls) {
-                for (const toolCall of result.tool_calls) {
-                    if (toolCall.type === "function") {
-                        toolCalls.push(toolCall);
-                    }
-                }
+            // Log finish reason and response headers if available
+            if (result.finish_reason) {
+                this.logger?.debug(`AI response finished with reason: ${result.finish_reason}`);
+            }
+            if (result.response_headers &&
+                Object.keys(result.response_headers).length > 0) {
+                this.logger?.debug("AI response headers:", result.response_headers);
+            }
+            if (result.metadata && Object.keys(result.metadata).length > 0) {
+                this.messageManager.mergeAssistantMetadata(result.metadata);
+            }
+            // Handle result content from non-streaming mode
+            if (result.content) {
+                this.messageManager.updateCurrentMessageContent(result.content);
             }
             // Handle usage tracking for agent operations
             let usage;
@@ -196,113 +279,140 @@ export class AIManager {
                     total_tokens: result.usage.total_tokens,
                     model: model || this.modelConfig.agentModel,
                     operation_type: "agent",
+                    // Preserve cache fields if present
+                    ...(result.usage.cache_read_input_tokens !== undefined && {
+                        cache_read_input_tokens: result.usage.cache_read_input_tokens,
+                    }),
+                    ...(result.usage.cache_creation_input_tokens !== undefined && {
+                        cache_creation_input_tokens: result.usage.cache_creation_input_tokens,
+                    }),
+                    ...(result.usage.cache_creation && {
+                        cache_creation: result.usage.cache_creation,
+                    }),
                 };
             }
-            // Add assistant message at once (including content, tool calls, and usage)
-            this.messageManager.addAssistantMessage(content, toolCalls, usage);
-            // Notify Agent to add to usage tracking
+            // Set usage on the assistant message if available
             if (usage) {
+                const messages = this.messageManager.getMessages();
+                const lastMessage = messages[messages.length - 1];
+                if (lastMessage && lastMessage.role === "assistant") {
+                    lastMessage.usage = usage;
+                    this.messageManager.setMessages(messages);
+                }
+                // Notify Agent to add to usage tracking
                 if (this.callbacks?.onUsageAdded) {
                     this.callbacks.onUsageAdded(usage);
                 }
             }
+            // Collect tool calls for processing
+            const toolCalls = [];
+            if (result.tool_calls) {
+                for (const toolCall of result.tool_calls) {
+                    if (toolCall.type === "function") {
+                        toolCalls.push(toolCall);
+                    }
+                }
+            }
             if (toolCalls.length > 0) {
                 // Execute all tools in parallel using Promise.all
                 const toolExecutionPromises = toolCalls.map(async (functionToolCall) => {
                     const toolId = functionToolCall.id || "";
-                    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 = {};
-                        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);
-                            }
-                        }
-                        // 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,
-                        });
+                    // Check if already interrupted, skip tool execution if so
+                    if (abortController.signal.aborted ||
+                        toolAbortController.signal.aborted) {
+                        return;
+                    }
+                    const toolName = functionToolCall.function?.name || "";
+                    // Safely parse tool parameters, handle tools without parameters
+                    let toolArgs = {};
+                    const argsString = functionToolCall.function?.arguments?.trim();
+                    if (!argsString || argsString === "") {
+                        // Tool without parameters, use empty object
+                        toolArgs = {};
+                    }
+                    else {
                         try {
-                            // Execute PreToolUse hooks before tool execution
-                            const shouldExecuteTool = await this.executePreToolUseHooks(toolName, toolArgs, toolId);
-                            // 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 = {
-                                abortSignal: toolAbortController.signal,
-                                backgroundBashManager: this.backgroundBashManager,
-                                workdir: this.workdir,
-                            };
-                            // Execute tool
-                            const toolResult = await this.toolManager.execute(functionToolCall.function?.name || "", 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
-                                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);
+                            toolArgs = JSON.parse(argsString);
                         }
-                        catch (toolError) {
-                            const errorMessage = toolError instanceof Error
-                                ? toolError.message
-                                : String(toolError);
+                        catch (parseError) {
+                            // For non-empty but malformed JSON, still throw exception
+                            const errorMessage = `Failed to parse tool arguments, finish_reason: ${result.finish_reason}`;
+                            const fullErrorMessage = `${errorMessage}\nAI response headers:, ${JSON.stringify(result.response_headers)}`;
+                            this.logger?.error(fullErrorMessage, parseError);
                             this.messageManager.updateToolBlock({
-                                toolId,
-                                args: JSON.stringify(toolArgs, null, 2),
-                                result: `Tool execution failed: ${errorMessage}`,
+                                id: toolId,
+                                parameters: argsString,
+                                result: errorMessage,
                                 success: false,
-                                error: errorMessage,
-                                isRunning: false,
+                                error: fullErrorMessage,
+                                stage: "end",
                                 name: toolName,
-                                compactParams,
+                                compactParams: "",
                             });
+                            return;
+                        }
+                    }
+                    const compactParams = this.generateCompactParams(toolName, toolArgs);
+                    // Emit running stage for non-streaming tool calls (tool execution about to start)
+                    this.messageManager.updateToolBlock({
+                        id: toolId,
+                        stage: "running",
+                        name: toolName,
+                        compactParams,
+                        parameters: argsString,
+                        parametersChunk: "",
+                    });
+                    try {
+                        // Execute PreToolUse hooks before tool execution
+                        const shouldExecuteTool = await this.executePreToolUseHooks(toolName, toolArgs, toolId);
+                        // 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 = {
+                            abortSignal: toolAbortController.signal,
+                            backgroundBashManager: this.backgroundBashManager,
+                            workdir: this.workdir,
+                        };
+                        // Execute tool
+                        const toolResult = await this.toolManager.execute(functionToolCall.function?.name || "", toolArgs, context);
+                        // Update message state - tool execution completed
+                        this.messageManager.updateToolBlock({
+                            id: toolId,
+                            parameters: argsString,
+                            result: toolResult.content ||
+                                (toolResult.error ? `Error: ${toolResult.error}` : ""),
+                            success: toolResult.success,
+                            error: toolResult.error,
+                            stage: "end",
+                            name: toolName,
+                            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, toolName, toolArgs, toolResult);
                     }
-                    catch (parseError) {
-                        const errorMessage = parseError instanceof Error
-                            ? parseError.message
-                            : String(parseError);
-                        this.messageManager.addErrorBlock(`Failed to parse tool arguments for ${functionToolCall.function?.name}: ${errorMessage}`);
+                    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,
+                            stage: "end",
+                            name: toolName,
+                            compactParams,
+                        });
                     }
                 });
                 // Wait for all tools to complete execution in parallel
@@ -328,66 +438,70 @@ export class AIManager {
             this.messageManager.addErrorBlock(error instanceof Error ? error.message : "Unknown error occurred");
         }
         finally {
-            // Only execute Stop hooks for the initial call
+            // Only execute cleanup and hooks for the initial call
             if (recursionDepth === 0) {
-                // Execute Stop hooks only if the operation was not aborted
+                // Save session in each recursion to ensure message persistence
+                await this.messageManager.saveSession();
+                // Set loading to false first
+                this.setIsLoading(false);
+                // Clear abort controllers
+                this.abortController = null;
+                this.toolAbortController = null;
+                // Execute Stop/SubagentStop hooks only if the operation was not aborted
                 const isCurrentlyAborted = abortController.signal.aborted || toolAbortController.signal.aborted;
                 if (!isCurrentlyAborted) {
                     const shouldContinue = await this.executeStopHooks();
-                    // If Stop hooks indicate we should continue (due to blocking errors),
+                    // If Stop/SubagentStop 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...");
+                        this.logger?.info(`${this.subagentType ? "SubagentStop" : "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
+                        // Use recursionDepth = 0 to set loading false again for continuation
                         await this.sendAIMessage({
-                            recursionDepth: 1,
+                            recursionDepth: 0,
                             model,
                             allowedTools,
                         });
                     }
                 }
-                // Save session after all operations (including continuation) are complete
-                await this.messageManager.saveSession();
-                // 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
+     * Execute Stop or SubagentStop hooks when AI response cycle completes
+     * Uses "SubagentStop" hook name when triggered by a subagent, otherwise uses "Stop"
      * @returns Promise<boolean> - true if should continue conversation, false if should stop
      */
     async executeStopHooks() {
         if (!this.hookManager)
             return false;
         try {
+            // Use "SubagentStop" hook name when triggered by a subagent, otherwise use "Stop"
+            const hookName = this.subagentType ? "SubagentStop" : "Stop";
             const context = {
-                event: "Stop",
+                event: hookName,
                 projectDir: this.workdir,
                 timestamp: new Date(),
                 sessionId: this.messageManager.getSessionId(),
                 transcriptPath: this.messageManager.getTranscriptPath(),
                 cwd: this.workdir,
+                subagentType: this.subagentType, // Include subagent type in hook context
                 // Stop hooks don't need toolName, toolInput, toolResponse, or userPrompt
             };
-            const results = await this.hookManager.executeHooks("Stop", context);
+            const results = await this.hookManager.executeHooks(hookName, 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);
+                const processResult = this.hookManager.processHookResults(hookName, 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);
+                    this.logger?.info(`${hookName} hook blocked stopping with error:`, processResult.errorMessage);
                     shouldContinue = true;
                 }
             }
             // Log hook execution results for debugging
             if (results.length > 0) {
-                this.logger?.debug(`Executed ${results.length} Stop hook(s):`, results.map((r) => ({
+                this.logger?.debug(`Executed ${results.length} ${hookName} hook(s):`, results.map((r) => ({
                     success: r.success,
                     duration: r.duration,
                     exitCode: r.exitCode,
@@ -399,7 +513,7 @@ export class AIManager {
         }
         catch (error) {
             // Hook execution errors should not interrupt the main workflow
-            this.logger?.error("Stop hook execution failed:", error);
+            this.logger?.error(`${this.subagentType ? "SubagentStop" : "Stop"} hook execution failed:`, error);
             return false;
         }
     }
@@ -420,12 +534,14 @@ export class AIManager {
                 transcriptPath: this.messageManager.getTranscriptPath(),
                 cwd: this.workdir,
                 toolInput,
+                subagentType: this.subagentType, // Include subagent type in hook context
             };
             const results = await this.hookManager.executeHooks("PreToolUse", 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);
+                const processResult = this.hookManager.processHookResults("PreToolUse", results, this.messageManager, toolId, // Pass toolId for proper PreToolUse blocking error handling
+                JSON.stringify(toolInput || {}, null, 2));
                 shouldContinue = !processResult.shouldBlock;
             }
             // Log hook execution results for debugging
@@ -463,12 +579,12 @@ export class AIManager {
                 cwd: this.workdir,
                 toolInput,
                 toolResponse,
+                subagentType: this.subagentType, // Include subagent type in hook context
             };
             const results = await this.hookManager.executeHooks("PostToolUse", context);
             // Process hook results to handle exit codes and update tool results
             if (results.length > 0) {
-                const originalToolResult = toolResponse?.content || "";
-                this.hookManager.processHookResults("PostToolUse", results, this.messageManager, toolId, originalToolResult);
+                this.hookManager.processHookResults("PostToolUse", results, this.messageManager, toolId);
             }
             // Log hook execution results for debugging
             if (results.length > 0) {

package/dist/managers/backgroundBashManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"backgroundBashManager.d.ts","sourceRoot":"","sources":["../../src/managers/backgroundBashManager.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEzD,MAAM,WAAW,8BAA8B;IAC7C,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,eAAe,EAAE,KAAK,IAAI,CAAC;CACtD;AAED,MAAM,WAAW,4BAA4B;IAC3C,SAAS,CAAC,EAAE,8BAA8B,CAAC;IAC3C,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,qBAAqB;IAChC,OAAO,CAAC,MAAM,CAAsC;IACpD,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,SAAS,CAAiC;IAClD,OAAO,CAAC,OAAO,CAAS;gBAEZ,OAAO,EAAE,4BAA4B;IAKjD,OAAO,CAAC,kBAAkB;IAInB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM;IAsErD,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAIjD,YAAY,IAAI,eAAe,EAAE;IAIjC,SAAS,CACd,EAAE,EAAE,MAAM,EACV,MAAM,CAAC,EAAE,MAAM,GACd;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAiCrD,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAmD9B,OAAO,IAAI,IAAI;CAUvB"}
+{"version":3,"file":"backgroundBashManager.d.ts","sourceRoot":"","sources":["../../src/managers/backgroundBashManager.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEzD,MAAM,WAAW,8BAA8B;IAC7C,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,eAAe,EAAE,KAAK,IAAI,CAAC;CACtD;AAED,MAAM,WAAW,4BAA4B;IAC3C,SAAS,CAAC,EAAE,8BAA8B,CAAC;IAC3C,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,qBAAqB;IAChC,OAAO,CAAC,MAAM,CAAsC;IACpD,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,SAAS,CAAiC;IAClD,OAAO,CAAC,OAAO,CAAS;gBAEZ,OAAO,EAAE,4BAA4B;IAKjD,OAAO,CAAC,kBAAkB;IAInB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM;IAsErD,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAIjD,YAAY,IAAI,eAAe,EAAE;IAIjC,SAAS,CACd,EAAE,EAAE,MAAM,EACV,MAAM,CAAC,EAAE,MAAM,GACd;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAiCrD,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAmD9B,OAAO,IAAI,IAAI;CAUvB"}

package/dist/managers/backgroundBashManager.js

@@ -1,4 +1,5 @@
 import { spawn } from "child_process";
+import { logger } from "../utils/globalLogger.js";
 export class BackgroundBashManager {
     constructor(options) {
         this.shells = new Map();
@@ -95,8 +96,8 @@ export class BackgroundBashManager {
                     .filter((line) => regex.test(line))
                     .join("\n");
             }
-            catch {
-                // logger.warn(`Invalid filter regex: ${filter}`, error);
+            catch (error) {
+                logger.warn(`Invalid filter regex: ${filter}`, error);
             }
         }
         return {
@@ -122,8 +123,8 @@ export class BackgroundBashManager {
                         try {
                             process.kill(-shell.process.pid, "SIGKILL");
                         }
-                        catch {
-                            // logger.error("Failed to force kill process:", error);
+                        catch (error) {
+                            logger.error("Failed to force kill process:", error);
                         }
                     }
                 }, 1000);
@@ -147,8 +148,8 @@ export class BackgroundBashManager {
                 this.notifyShellsChange();
                 return true;
             }
-            catch {
-                // logger.error("Failed to kill child process:", directKillError);
+            catch (directKillError) {
+                logger.error("Failed to kill child process:", directKillError);
                 return false;
             }
         }