wave-agent-sdk 0.0.7 → 0.0.10

package/src/managers/aiManager.ts

@@ -1,6 +1,11 @@
-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";
 import * as memory from "../services/memory.js";
 import type {
   Logger,
@@ -30,10 +35,14 @@ export interface AIManagerOptions {
   callbacks?: AIManagerCallbacks;
   workdir: string;
   systemPrompt?: string;
-  // Resolved configuration
-  gatewayConfig: GatewayConfig;
-  modelConfig: ModelConfig;
-  tokenLimit: number;
+  subagentType?: string; // Optional subagent type for hook context
+  /**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 {
@@ -47,11 +56,14 @@ export class AIManager {
   private hookManager?: HookManager;
   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;
@@ -61,12 +73,28 @@ export class AIManager {
     this.logger = options.logger;
     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;
+  }
+
+  // Getter methods for accessing dynamic configuration
+  public getGatewayConfig(): GatewayConfig {
+    return this.getGatewayConfigFn();
+  }
+
+  public getModelConfig(): ModelConfig {
+    return this.getModelConfigFn();
+  }
+
+  public getTokenLimit(): number {
+    return this.getTokenLimitFn();
   }
 
   private isCompressing: boolean = false;
@@ -117,7 +145,7 @@ export class AIManager {
   private generateCompactParams(
     toolName: string,
     toolArgs: Record<string, unknown>,
-  ): string | undefined {
+  ): string {
     try {
       const toolPlugin = this.toolManager
         .list()
@@ -131,23 +159,29 @@ 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
   private async handleTokenUsageAndCompression(
-    usage: { total_tokens: number } | undefined,
+    usage: Usage | undefined,
     abortController: AbortController,
   ): Promise<void> {
     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.getTokenLimit()
+    ) {
       this.logger?.debug(
-        `Token usage exceeded ${this.tokenLimit}, compressing messages...`,
+        `Token usage exceeded ${this.getTokenLimit()}, compressing messages...`,
       );
 
       // Check if messages need compression
@@ -160,35 +194,40 @@ export class AIManager {
       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({
-            gatewayConfig: this.gatewayConfig,
-            modelConfig: this.modelConfig,
+            gatewayConfig: this.getGatewayConfig(),
+            modelConfig: this.getModelConfig(),
             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: Usage | undefined;
           if (compressionResult.usage) {
-            const usage: Usage = {
+            compressionUsage = {
               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",
             };
+          }
 
-            // 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(
@@ -228,6 +267,9 @@ export class AIManager {
       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: AbortController;
@@ -262,10 +304,15 @@ export class AIManager {
         this.workdir,
       );
 
-      // Call AI service (non-streaming)
-      const result = await callAgent({
-        gatewayConfig: this.gatewayConfig,
-        modelConfig: this.modelConfig,
+      // Track if assistant message has been created
+      let assistantMessageCreated = false;
+
+      this.logger?.debug("modelConfig in sendAIMessage", this.getModelConfig());
+
+      // 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,
@@ -274,19 +321,94 @@ export class AIManager {
         tools: this.getFilteredToolsConfig(allowedTools), // Pass filtered tool configuration
         model: model, // Use passed model
         systemPrompt: this.systemPrompt, // Pass custom system prompt
-      });
+      };
 
-      // Collect content and tool calls
-      const content = result.content || "";
-      const toolCalls: ChatCompletionMessageFunctionToolCall[] = [];
+      // 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);
+        };
+        callAgentOptions.onToolUpdate = (toolCall) => {
+          // Create assistant message on first tool update if not already created
+          if (!assistantMessageCreated) {
+            this.messageManager.addAssistantMessage();
+            assistantMessageCreated = true;
+          }
 
-      if (result.tool_calls) {
-        for (const toolCall of result.tool_calls) {
-          this.logger?.debug("ToolCall", toolCall);
-          if (toolCall.type === "function") {
-            toolCalls.push(toolCall);
+          // Use parametersChunk as compact param for better performance
+          // No need to extract params or generate compact params during streaming
+
+          // 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
+          });
+        };
+        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) {
+        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.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 && !createdByStreaming) {
+        this.messageManager.updateCurrentMessageContent(result.content);
       }
 
       // Handle usage tracking for agent operations
@@ -296,158 +418,173 @@ 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 && {
+            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: ChatCompletionMessageFunctionToolCall[] = [];
+      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
-              ) {
+            // 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: Record<string, unknown> = {};
+            const argsString = functionToolCall.function?.arguments?.trim();
+
+            if (!argsString || argsString === "") {
+              // Tool without parameters, use empty object
+              toolArgs = {};
+            } else {
+              try {
+                toolArgs = JSON.parse(argsString);
+              } catch (parseError) {
+                // For non-empty but malformed JSON, still throw exception
+                const errorMessage = `Failed to parse tool arguments, finish_reason: ${result.finish_reason}`;
+                const fullErrorMessage = `${errorMessage}\nAI response headers:, ${JSON.stringify(result.response_headers)}`;
+                this.logger?.error(fullErrorMessage, parseError);
+                this.messageManager.updateToolBlock({
+                  id: toolId,
+                  parameters: argsString,
+                  result: errorMessage,
+                  success: false,
+                  error: fullErrorMessage,
+                  stage: "end",
+                  name: toolName,
+                  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: "",
+            });
 
-              // Safely parse tool parameters, handle tools without parameters
-              let toolArgs: Record<string, unknown> = {};
-              const argsString = functionToolCall.function?.arguments?.trim();
-
-              if (!argsString || argsString === "") {
-                // Tool without parameters, use empty object
-                toolArgs = {};
-              } else {
-                try {
-                  toolArgs = JSON.parse(argsString);
-                } catch (parseError) {
-                  // For non-empty but malformed JSON, still throw exception
-                  const errorMessage = `Failed to parse tool arguments: ${argsString}`;
-                  this.logger?.error(errorMessage, parseError);
-                  throw new Error(errorMessage);
-                }
+            try {
+              // Execute PreToolUse hooks before tool execution
+              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
               }
 
-              // Set tool start execution state
-              const toolName = functionToolCall.function?.name || "";
-              const compactParams = this.generateCompactParams(
+              // Create tool execution context
+              const context: ToolContext = {
+                abortSignal: toolAbortController.signal,
+                backgroundBashManager: this.backgroundBashManager,
+                workdir: this.workdir,
+              };
+
+              // Execute tool
+              const toolResult = await this.toolManager.execute(
+                functionToolCall.function?.name || "",
+                toolArgs,
+                context,
+              );
+
+              // 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,
+              });
+
+              // Execute PostToolUse hooks after successful tool completion
+              await this.executePostToolUseHooks(
+                toolId,
                 toolName,
                 toolArgs,
+                toolResult,
               );
+            } catch (toolError) {
+              const errorMessage =
+                toolError instanceof Error
+                  ? toolError.message
+                  : String(toolError);
 
               this.messageManager.updateToolBlock({
                 id: toolId,
                 parameters: JSON.stringify(toolArgs, null, 2),
-                isRunning: true, // isRunning: true
+                result: `Tool execution failed: ${errorMessage}`,
+                success: false,
+                error: errorMessage,
+                stage: "end",
                 name: toolName,
                 compactParams,
               });
-
-              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: ToolContext = {
-                  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: JSON.stringify(toolArgs, null, 2),
-                  result:
-                    toolResult.content ||
-                    (toolResult.error ? `Error: ${toolResult.error}` : ""),
-                  success: toolResult.success,
-                  error: toolResult.error,
-                  isRunning: false, // isRunning: false
-                  name: toolName,
-                  shortResult: toolResult.shortResult,
-                  compactParams,
-                });
-
-                // If tool returns diff information, add diff block
-                if (
-                  toolResult.success &&
-                  toolResult.diffResult &&
-                  toolResult.filePath
-                ) {
-                  this.messageManager.addDiffBlock(
-                    toolResult.filePath,
-                    toolResult.diffResult,
-                  );
-                }
-
-                // Execute PostToolUse hooks after successful tool completion
-                await this.executePostToolUseHooks(
-                  toolId,
-                  toolName,
-                  toolArgs,
-                  toolResult,
-                );
-              } catch (toolError) {
-                const errorMessage =
-                  toolError instanceof Error
-                    ? toolError.message
-                    : String(toolError);
-
-                this.messageManager.updateToolBlock({
-                  id: toolId,
-                  parameters: JSON.stringify(toolArgs, null, 2),
-                  result: `Tool execution failed: ${errorMessage}`,
-                  success: false,
-                  error: errorMessage,
-                  isRunning: false,
-                  name: toolName,
-                  compactParams,
-                });
-              }
-            } catch (parseError) {
-              const errorMessage =
-                parseError instanceof Error
-                  ? parseError.message
-                  : String(parseError);
-              this.messageManager.addErrorBlock(
-                `Failed to parse tool arguments for ${functionToolCall.function?.name}: ${errorMessage}`,
-              );
             }
           },
         );
@@ -479,70 +616,75 @@ export class AIManager {
         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.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
    */
   private async executeStopHooks(): Promise<boolean> {
     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: ExtendedHookExecutionContext = {
-        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
+        env: this.getEnvironmentVarsFn?.() || {}, // Include configuration environment variables
       };
 
-      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",
+          hookName,
           results,
           this.messageManager,
         );
@@ -550,7 +692,7 @@ export class AIManager {
         // If hook processing indicates we should block (exit code 2), continue conversation
         if (processResult.shouldBlock) {
           this.logger?.info(
-            "Stop hook blocked stopping with error:",
+            `${hookName} hook blocked stopping with error:`,
             processResult.errorMessage,
           );
           shouldContinue = true;
@@ -560,7 +702,7 @@ export class AIManager {
       // Log hook execution results for debugging
       if (results.length > 0) {
         this.logger?.debug(
-          `Executed ${results.length} Stop hook(s):`,
+          `Executed ${results.length} ${hookName} hook(s):`,
           results.map((r) => ({
             success: r.success,
             duration: r.duration,
@@ -574,7 +716,10 @@ export class AIManager {
       return shouldContinue;
     } 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;
     }
   }
@@ -600,6 +745,8 @@ export class AIManager {
         transcriptPath: this.messageManager.getTranscriptPath(),
         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(
@@ -664,6 +811,8 @@ export class AIManager {
         cwd: this.workdir,
         toolInput,
         toolResponse,
+        subagentType: this.subagentType, // Include subagent type in hook context
+        env: this.getEnvironmentVarsFn?.() || {}, // Include configuration environment variables
       };
 
       const results = await this.hookManager.executeHooks(