@qwen-code/qwen-code 0.13.0-preview.4 → 0.13.0-preview.6

package/cli.js

@@ -171203,7 +171203,7 @@ __export(geminiContentGenerator_exports, {
   createGeminiContentGenerator: () => createGeminiContentGenerator
 });
 function createGeminiContentGenerator(config2, gcConfig) {
-  const version2 = "0.13.0-preview.4";
+  const version2 = "0.13.0-preview.6";
   const userAgent2 = config2.userAgent || `QwenCode/${version2} (${process.platform}; ${process.arch})`;
   const baseHeaders = {
     "User-Agent": userAgent2
@@ -174648,7 +174648,7 @@ var init_chatCompressionService = __esm({
       static {
         __name(this, "ChatCompressionService");
       }
-      async compress(chat, promptId, force, model, config2, hasFailedCompressionAttempt) {
+      async compress(chat, promptId, force, model, config2, hasFailedCompressionAttempt, signal) {
         const curatedHistory = chat.getHistory(true);
         const threshold = config2.getChatCompression()?.contextPercentageThreshold ?? COMPRESSION_TOKEN_THRESHOLD;
         if (curatedHistory.length === 0 || threshold <= 0 || hasFailedCompressionAttempt && !force) {
@@ -174679,7 +174679,7 @@ var init_chatCompressionService = __esm({
         if (hookSystem) {
           const trigger = force ? PreCompactTrigger.Manual : PreCompactTrigger.Auto;
           try {
-            await hookSystem.firePreCompactEvent(trigger, "");
+            await hookSystem.firePreCompactEvent(trigger, "", signal);
           } catch (err2) {
             config2.getDebugLogger().warn(`PreCompact hook failed: ${err2}`);
           }
@@ -174778,7 +174778,8 @@ var init_chatCompressionService = __esm({
         } else {
           uiTelemetryService.setLastPromptTokenCount(newTokenCount);
           try {
-            await config2.getHookSystem()?.fireSessionStartEvent(SessionStartSource.Compact, model ?? "");
+            const permissionMode = String(config2.getApprovalMode());
+            await config2.getHookSystem()?.fireSessionStartEvent(SessionStartSource.Compact, model ?? "", permissionMode, void 0, signal);
           } catch (err2) {
             config2.getDebugLogger().warn(`SessionStart hook failed: ${err2}`);
           }
@@ -175075,7 +175076,7 @@ var init_types7 = __esm({
 function generateToolUseId() {
   return `toolu_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
 }
-async function firePreToolUseHook(messageBus, toolName, toolInput, toolUseId, permissionMode) {
+async function firePreToolUseHook(messageBus, toolName, toolInput, toolUseId, permissionMode, signal) {
   if (!messageBus) {
     return { shouldProceed: true };
   }
@@ -175088,7 +175089,8 @@ async function firePreToolUseHook(messageBus, toolName, toolInput, toolUseId, pe
         tool_name: toolName,
         tool_input: toolInput,
         tool_use_id: toolUseId
-      }
+      },
+      signal
     }, MessageBusType.HOOK_EXECUTION_RESPONSE);
     if (!response.success || !response.output) {
       return { shouldProceed: true };
@@ -175125,7 +175127,7 @@ async function firePreToolUseHook(messageBus, toolName, toolInput, toolUseId, pe
     return { shouldProceed: true };
   }
 }
-async function firePostToolUseHook(messageBus, toolName, toolInput, toolResponse, toolUseId, permissionMode) {
+async function firePostToolUseHook(messageBus, toolName, toolInput, toolResponse, toolUseId, permissionMode, signal) {
   if (!messageBus) {
     return { shouldStop: false };
   }
@@ -175139,7 +175141,8 @@ async function firePostToolUseHook(messageBus, toolName, toolInput, toolResponse
         tool_input: toolInput,
         tool_response: toolResponse,
         tool_use_id: toolUseId
-      }
+      },
+      signal
     }, MessageBusType.HOOK_EXECUTION_RESPONSE);
     if (!response.success || !response.output) {
       return { shouldStop: false };
@@ -175161,7 +175164,7 @@ async function firePostToolUseHook(messageBus, toolName, toolInput, toolResponse
     return { shouldStop: false };
   }
 }
-async function firePostToolUseFailureHook(messageBus, toolUseId, toolName, toolInput, errorMessage, isInterrupt, permissionMode) {
+async function firePostToolUseFailureHook(messageBus, toolUseId, toolName, toolInput, errorMessage, isInterrupt, permissionMode, signal) {
   if (!messageBus) {
     return {};
   }
@@ -175176,7 +175179,8 @@ async function firePostToolUseFailureHook(messageBus, toolUseId, toolName, toolI
         tool_input: toolInput,
         error: errorMessage,
         is_interrupt: isInterrupt
-      }
+      },
+      signal
     }, MessageBusType.HOOK_EXECUTION_RESPONSE);
     if (!response.success || !response.output) {
       return {};
@@ -175191,7 +175195,7 @@ async function firePostToolUseFailureHook(messageBus, toolUseId, toolName, toolI
     return {};
   }
 }
-async function fireNotificationHook(messageBus, message, notificationType, title) {
+async function fireNotificationHook(messageBus, message, notificationType, title, signal) {
   if (!messageBus) {
     return {};
   }
@@ -175203,7 +175207,8 @@ async function fireNotificationHook(messageBus, message, notificationType, title
         message,
         notification_type: notificationType,
         title
-      }
+      },
+      signal
     }, MessageBusType.HOOK_EXECUTION_RESPONSE);
     if (!response.success || !response.output) {
       return {};
@@ -175218,7 +175223,7 @@ async function fireNotificationHook(messageBus, message, notificationType, title
     return {};
   }
 }
-async function firePermissionRequestHook(messageBus, toolName, toolInput, permissionMode, permissionSuggestions) {
+async function firePermissionRequestHook(messageBus, toolName, toolInput, permissionMode, permissionSuggestions, signal) {
   if (!messageBus) {
     return { hasDecision: false };
   }
@@ -175231,7 +175236,8 @@ async function firePermissionRequestHook(messageBus, toolName, toolInput, permis
         tool_input: toolInput,
         permission_mode: permissionMode,
         permission_suggestions: permissionSuggestions
-      }
+      },
+      signal
     }, MessageBusType.HOOK_EXECUTION_RESPONSE);
     if (!response.success || !response.output) {
       return { hasDecision: false };
@@ -190439,7 +190445,7 @@ assistant: "I'm going to use the ${ToolNames.AGENT} tool to launch the greeting-
           const agentType = this.params.subagent_type;
           if (hookSystem) {
             try {
-              const startHookOutput = await hookSystem.fireSubagentStartEvent(agentId, agentType, PermissionMode.Default);
+              const startHookOutput = await hookSystem.fireSubagentStartEvent(agentId, agentType, PermissionMode.Default, signal);
               const additionalContext = startHookOutput?.getAdditionalContext();
               if (additionalContext) {
                 contextState.set("hook_context", additionalContext);
@@ -190463,7 +190469,7 @@ assistant: "I'm going to use the ${ToolNames.AGENT} tool to launch the greeting-
                 break;
               }
               try {
-                const stopHookOutput = await hookSystem.fireSubagentStopEvent(agentId, agentType, transcriptPath, subagent.getFinalText(), stopHookActive, PermissionMode.Default);
+                const stopHookOutput = await hookSystem.fireSubagentStopEvent(agentId, agentType, transcriptPath, subagent.getFinalText(), stopHookActive, PermissionMode.Default, signal);
                 const typedStopOutput = stopHookOutput;
                 if (typedStopOutput?.isBlockingDecision() || typedStopOutput?.shouldStopExecution()) {
                   const continueReason = typedStopOutput.getEffectiveReason();
@@ -195982,7 +195988,7 @@ var init_client2 = __esm({
         if (!boundedTurns) {
           return new Turn(this.getChat(), prompt_id);
         }
-        const compressed = await this.tryCompressChat(prompt_id, false);
+        const compressed = await this.tryCompressChat(prompt_id, false, signal);
         if (compressed.compressionStatus === CompressionStatus.COMPRESSED) {
           yield { type: GeminiEventType.ChatCompressed, value: compressed };
         }
@@ -196070,7 +196076,7 @@ var init_client2 = __esm({
             return turn;
           }
         }
-        if (hooksEnabled && messageBus && !turn.pendingToolCalls.length) {
+        if (hooksEnabled && messageBus && !turn.pendingToolCalls.length && signal && !signal.aborted) {
           const history2 = this.getHistory();
           const lastModelMessage = history2.filter((msg) => msg.role === "model").pop();
           const responseText = lastModelMessage?.parts?.filter((p2) => "text" in p2).map((p2) => p2.text).join("") || "[no response text]";
@@ -196080,16 +196086,23 @@ var init_client2 = __esm({
             input: {
               stop_hook_active: true,
               last_assistant_message: responseText
-            }
+            },
+            signal
           }, MessageBusType.HOOK_EXECUTION_RESPONSE);
+          if (signal.aborted) {
+            return turn;
+          }
           const hookOutput = response.output ? createHookOutput("Stop", response.output) : void 0;
           const stopOutput = hookOutput;
+          if (stopOutput?.systemMessage) {
+            yield {
+              type: GeminiEventType.HookSystemMessage,
+              value: stopOutput.systemMessage
+            };
+          }
           if (stopOutput?.isBlockingDecision() || stopOutput?.shouldStopExecution()) {
-            if (stopOutput.systemMessage) {
-              yield {
-                type: GeminiEventType.HookSystemMessage,
-                value: stopOutput.systemMessage
-              };
+            if (signal.aborted) {
+              return turn;
             }
             const continueReason = stopOutput.getEffectiveReason();
             const continueRequest = [{ text: continueReason }];
@@ -196151,9 +196164,9 @@ var init_client2 = __esm({
           throw new Error(`Failed to generate content with model ${currentAttemptModel}: ${getErrorMessage(error40)}`);
         }
       }
-      async tryCompressChat(prompt_id, force = false) {
+      async tryCompressChat(prompt_id, force = false, signal) {
         const compressionService = new ChatCompressionService();
-        const { newHistory, info: info2 } = await compressionService.compress(this.getChat(), prompt_id, force, this.config.getModel(), this.config, this.hasFailedCompressionAttempt);
+        const { newHistory, info: info2 } = await compressionService.compress(this.getChat(), prompt_id, force, this.config.getModel(), this.config, this.hasFailedCompressionAttempt, signal);
         if (info2.compressionStatus === CompressionStatus.COMPRESSED) {
           if (newHistory) {
             const chatRecordingService = this.config.getChatRecordingService();
@@ -264533,11 +264546,25 @@ var init_hookRunner = __esm({
       }
       /**
        * Execute a single hook
+       * @param hookConfig Hook configuration
+       * @param eventName Event name
+       * @param input Hook input
+       * @param signal Optional AbortSignal to cancel hook execution
        */
-      async executeHook(hookConfig, eventName, input) {
+      async executeHook(hookConfig, eventName, input, signal) {
         const startTime = Date.now();
+        if (signal?.aborted) {
+          const hookId = hookConfig.name || hookConfig.command || "unknown";
+          return {
+            hookConfig,
+            eventName,
+            success: false,
+            error: new Error(`Hook execution cancelled (aborted): ${hookId}`),
+            duration: 0
+          };
+        }
         try {
-          return await this.executeCommandHook(hookConfig, eventName, input, startTime);
+          return await this.executeCommandHook(hookConfig, eventName, input, startTime, signal);
         } catch (error40) {
           const duration3 = Date.now() - startTime;
           const hookId = hookConfig.name || hookConfig.command || "unknown";
@@ -264554,11 +264581,12 @@ var init_hookRunner = __esm({
       }
       /**
        * Execute multiple hooks in parallel
+       * @param signal Optional AbortSignal to cancel hook execution
        */
-      async executeHooksParallel(hookConfigs, eventName, input, onHookStart, onHookEnd) {
+      async executeHooksParallel(hookConfigs, eventName, input, onHookStart, onHookEnd, signal) {
         const promises8 = hookConfigs.map(async (config2, index) => {
           onHookStart?.(config2, index);
-          const result = await this.executeHook(config2, eventName, input);
+          const result = await this.executeHook(config2, eventName, input, signal);
           onHookEnd?.(config2, result);
           return result;
         });
@@ -264566,14 +264594,18 @@ var init_hookRunner = __esm({
       }
       /**
        * Execute multiple hooks sequentially
+       * @param signal Optional AbortSignal to cancel hook execution
        */
-      async executeHooksSequential(hookConfigs, eventName, input, onHookStart, onHookEnd) {
+      async executeHooksSequential(hookConfigs, eventName, input, onHookStart, onHookEnd, signal) {
         const results = [];
         let currentInput = input;
         for (let i4 = 0; i4 < hookConfigs.length; i4++) {
+          if (signal?.aborted) {
+            break;
+          }
           const config2 = hookConfigs[i4];
           onHookStart?.(config2, i4);
-          const result = await this.executeHook(config2, eventName, currentInput);
+          const result = await this.executeHook(config2, eventName, currentInput, signal);
           onHookEnd?.(config2, result);
           results.push(result);
           if (result.success && result.output) {
@@ -264616,8 +264648,13 @@ var init_hookRunner = __esm({
       }
       /**
        * Execute a command hook
+       * @param hookConfig Hook configuration
+       * @param eventName Event name
+       * @param input Hook input
+       * @param startTime Start time for duration calculation
+       * @param signal Optional AbortSignal to cancel hook execution
        */
-      async executeCommandHook(hookConfig, eventName, input, startTime) {
+      async executeCommandHook(hookConfig, eventName, input, startTime, signal) {
         const timeout2 = hookConfig.timeout ?? DEFAULT_HOOK_TIMEOUT;
         return new Promise((resolve35) => {
           if (!hookConfig.command) {
@@ -264635,6 +264672,7 @@ var init_hookRunner = __esm({
           let stdout2 = "";
           let stderr = "";
           let timedOut = false;
+          let aborted2 = false;
           const shellConfig = getShellConfiguration();
           const command2 = this.expandCommand(hookConfig.command, input, shellConfig.shell);
           const env6 = {
@@ -264652,15 +264690,28 @@ var init_hookRunner = __esm({
             stdio: ["pipe", "pipe", "pipe"],
             shell: false
           });
+          const killChild = /* @__PURE__ */ __name(() => {
+            if (!child.killed) {
+              child.kill("SIGTERM");
+              setTimeout(() => {
+                if (!child.killed) {
+                  child.kill("SIGKILL");
+                }
+              }, 2e3);
+            }
+          }, "killChild");
           const timeoutHandle = setTimeout(() => {
             timedOut = true;
-            child.kill("SIGTERM");
-            setTimeout(() => {
-              if (!child.killed) {
-                child.kill("SIGKILL");
-              }
-            }, 5e3);
+            killChild();
           }, timeout2);
+          const abortHandler = /* @__PURE__ */ __name(() => {
+            aborted2 = true;
+            clearTimeout(timeoutHandle);
+            killChild();
+          }, "abortHandler");
+          if (signal) {
+            signal.addEventListener("abort", abortHandler);
+          }
           if (child.stdin) {
             child.stdin.on("error", (err2) => {
               if (err2.code !== "EPIPE") {
@@ -264696,7 +264747,22 @@ var init_hookRunner = __esm({
           });
           child.on("close", (exitCode) => {
             clearTimeout(timeoutHandle);
+            if (signal) {
+              signal.removeEventListener("abort", abortHandler);
+            }
             const duration3 = Date.now() - startTime;
+            if (aborted2) {
+              resolve35({
+                hookConfig,
+                eventName,
+                success: false,
+                error: new Error("Hook execution cancelled (aborted)"),
+                stdout: stdout2,
+                stderr,
+                duration: duration3
+              });
+              return;
+            }
             if (timedOut) {
               resolve35({
                 hookConfig,
@@ -265231,30 +265297,30 @@ var init_hookEventHandler = __esm({
        * Fire a UserPromptSubmit event
        * Called by handleHookExecutionRequest - executes hooks directly
        */
-      async fireUserPromptSubmitEvent(prompt) {
+      async fireUserPromptSubmitEvent(prompt, signal) {
         const input = {
           ...this.createBaseInput(HookEventName.UserPromptSubmit),
           prompt
         };
-        return this.executeHooks(HookEventName.UserPromptSubmit, input);
+        return this.executeHooks(HookEventName.UserPromptSubmit, input, void 0, signal);
       }
       /**
        * Fire a Stop event
        * Called by handleHookExecutionRequest - executes hooks directly
        */
-      async fireStopEvent(stopHookActive = false, lastAssistantMessage = "") {
+      async fireStopEvent(stopHookActive = false, lastAssistantMessage = "", signal) {
         const input = {
           ...this.createBaseInput(HookEventName.Stop),
           stop_hook_active: stopHookActive,
           last_assistant_message: lastAssistantMessage
         };
-        return this.executeHooks(HookEventName.Stop, input);
+        return this.executeHooks(HookEventName.Stop, input, void 0, signal);
       }
       /**
        * Fire a SessionStart event
        * Called when a new session starts or resumes
        */
-      async fireSessionStartEvent(source2, model, permissionMode, agentType) {
+      async fireSessionStartEvent(source2, model, permissionMode, agentType, signal) {
         const input = {
           ...this.createBaseInput(HookEventName.SessionStart),
           permission_mode: permissionMode ?? PermissionMode.Default,
@@ -265264,26 +265330,26 @@ var init_hookEventHandler = __esm({
         };
         return this.executeHooks(HookEventName.SessionStart, input, {
           trigger: source2
-        });
+        }, signal);
       }
       /**
        * Fire a SessionEnd event
        * Called when a session ends
        */
-      async fireSessionEndEvent(reason) {
+      async fireSessionEndEvent(reason, signal) {
         const input = {
           ...this.createBaseInput(HookEventName.SessionEnd),
           reason
         };
         return this.executeHooks(HookEventName.SessionEnd, input, {
           trigger: reason
-        });
+        }, signal);
       }
       /**
        * Fire a PreToolUse event
        * Called before tool execution begins
        */
-      async firePreToolUseEvent(toolName, toolInput, toolUseId, permissionMode) {
+      async firePreToolUseEvent(toolName, toolInput, toolUseId, permissionMode, signal) {
         const input = {
           ...this.createBaseInput(HookEventName.PreToolUse),
           permission_mode: permissionMode,
@@ -265293,13 +265359,13 @@ var init_hookEventHandler = __esm({
         };
         return this.executeHooks(HookEventName.PreToolUse, input, {
           toolName
-        });
+        }, signal);
       }
       /**
        * Fire a PostToolUse event
        * Called after successful tool execution
        */
-      async firePostToolUseEvent(toolName, toolInput, toolResponse, toolUseId, permissionMode) {
+      async firePostToolUseEvent(toolName, toolInput, toolResponse, toolUseId, permissionMode, signal) {
         const input = {
           ...this.createBaseInput(HookEventName.PostToolUse),
           permission_mode: permissionMode,
@@ -265310,13 +265376,13 @@ var init_hookEventHandler = __esm({
         };
         return this.executeHooks(HookEventName.PostToolUse, input, {
           toolName
-        });
+        }, signal);
       }
       /**
        * Fire a PostToolUseFailure event
        * Called when tool execution fails
        */
-      async firePostToolUseFailureEvent(toolUseId, toolName, toolInput, errorMessage, isInterrupt, permissionMode) {
+      async firePostToolUseFailureEvent(toolUseId, toolName, toolInput, errorMessage, isInterrupt, permissionMode, signal) {
         const input = {
           ...this.createBaseInput(HookEventName.PostToolUseFailure),
           permission_mode: permissionMode ?? PermissionMode.Default,
@@ -265328,13 +265394,13 @@ var init_hookEventHandler = __esm({
         };
         return this.executeHooks(HookEventName.PostToolUseFailure, input, {
           toolName
-        });
+        }, signal);
       }
       /**
        * Fire a PreCompact event
        * Called before conversation compaction begins
        */
-      async firePreCompactEvent(trigger, customInstructions = "") {
+      async firePreCompactEvent(trigger, customInstructions = "", signal) {
         const input = {
           ...this.createBaseInput(HookEventName.PreCompact),
           trigger,
@@ -265342,12 +265408,12 @@ var init_hookEventHandler = __esm({
         };
         return this.executeHooks(HookEventName.PreCompact, input, {
           trigger
-        });
+        }, signal);
       }
       /**
        * Fire a Notification event
        */
-      async fireNotificationEvent(message, notificationType, title) {
+      async fireNotificationEvent(message, notificationType, title, signal) {
         const input = {
           ...this.createBaseInput(HookEventName.Notification),
           message,
@@ -265356,13 +265422,13 @@ var init_hookEventHandler = __esm({
         };
         return this.executeHooks(HookEventName.Notification, input, {
           notificationType
-        });
+        }, signal);
       }
       /**
        * Fire a PermissionRequest event
        * Called when a permission dialog is about to be shown to the user
        */
-      async firePermissionRequestEvent(toolName, toolInput, permissionMode, permissionSuggestions) {
+      async firePermissionRequestEvent(toolName, toolInput, permissionMode, permissionSuggestions, signal) {
         const input = {
           ...this.createBaseInput(HookEventName.PermissionRequest),
           permission_mode: permissionMode,
@@ -265372,13 +265438,13 @@ var init_hookEventHandler = __esm({
         };
         return this.executeHooks(HookEventName.PermissionRequest, input, {
           toolName
-        });
+        }, signal);
       }
       /**
        * Fire a SubagentStart event
        * Called when a subagent is spawned via the Agent tool
        */
-      async fireSubagentStartEvent(agentId, agentType, permissionMode) {
+      async fireSubagentStartEvent(agentId, agentType, permissionMode, signal) {
         const input = {
           ...this.createBaseInput(HookEventName.SubagentStart),
           permission_mode: permissionMode,
@@ -265387,13 +265453,13 @@ var init_hookEventHandler = __esm({
         };
         return this.executeHooks(HookEventName.SubagentStart, input, {
           agentType: String(agentType)
-        });
+        }, signal);
       }
       /**
        * Fire a SubagentStop event
        * Called when a subagent has finished responding
        */
-      async fireSubagentStopEvent(agentId, agentType, agentTranscriptPath, lastAssistantMessage, stopHookActive, permissionMode) {
+      async fireSubagentStopEvent(agentId, agentType, agentTranscriptPath, lastAssistantMessage, stopHookActive, permissionMode, signal) {
         const input = {
           ...this.createBaseInput(HookEventName.SubagentStop),
           permission_mode: permissionMode,
@@ -265405,13 +265471,13 @@ var init_hookEventHandler = __esm({
         };
         return this.executeHooks(HookEventName.SubagentStop, input, {
           agentType: String(agentType)
-        });
+        }, signal);
       }
       /**
        * Execute hooks for a specific event (direct execution without MessageBus)
        * Used as fallback when MessageBus is not available
        */
-      async executeHooks(eventName, input, context2) {
+      async executeHooks(eventName, input, context2, signal) {
         try {
           const plan = this.hookPlanner.createExecutionPlan(eventName, context2);
           if (!plan || plan.hookConfigs.length === 0) {
@@ -265426,7 +265492,7 @@ var init_hookEventHandler = __esm({
           }, "onHookStart");
           const onHookEnd = /* @__PURE__ */ __name((_config, _result) => {
           }, "onHookEnd");
-          const results = plan.sequential ? await this.hookRunner.executeHooksSequential(plan.hookConfigs, eventName, input, onHookStart, onHookEnd) : await this.hookRunner.executeHooksParallel(plan.hookConfigs, eventName, input, onHookStart, onHookEnd);
+          const results = plan.sequential ? await this.hookRunner.executeHooksSequential(plan.hookConfigs, eventName, input, onHookStart, onHookEnd, signal) : await this.hookRunner.executeHooksParallel(plan.hookConfigs, eventName, input, onHookStart, onHookEnd, signal);
           const aggregated = this.hookAggregator.aggregateResults(results, eventName);
           this.processCommonHookOutputFields(aggregated);
           return aggregated;
@@ -265534,76 +265600,76 @@ var init_hookSystem = __esm({
       getAllHooks() {
         return this.hookRegistry.getAllHooks();
       }
-      async fireUserPromptSubmitEvent(prompt) {
-        const result = await this.hookEventHandler.fireUserPromptSubmitEvent(prompt);
+      async fireUserPromptSubmitEvent(prompt, signal) {
+        const result = await this.hookEventHandler.fireUserPromptSubmitEvent(prompt, signal);
         return result.finalOutput ? createHookOutput("UserPromptSubmit", result.finalOutput) : void 0;
       }
-      async fireStopEvent(stopHookActive = false, lastAssistantMessage = "") {
-        const result = await this.hookEventHandler.fireStopEvent(stopHookActive, lastAssistantMessage);
+      async fireStopEvent(stopHookActive = false, lastAssistantMessage = "", signal) {
+        const result = await this.hookEventHandler.fireStopEvent(stopHookActive, lastAssistantMessage, signal);
         return result.finalOutput ? createHookOutput("Stop", result.finalOutput) : void 0;
       }
-      async fireSessionStartEvent(source2, model, permissionMode, agentType) {
-        const result = await this.hookEventHandler.fireSessionStartEvent(source2, model, permissionMode, agentType);
+      async fireSessionStartEvent(source2, model, permissionMode, agentType, signal) {
+        const result = await this.hookEventHandler.fireSessionStartEvent(source2, model, permissionMode, agentType, signal);
         return result.finalOutput ? createHookOutput("SessionStart", result.finalOutput) : void 0;
       }
-      async fireSessionEndEvent(reason) {
-        const result = await this.hookEventHandler.fireSessionEndEvent(reason);
+      async fireSessionEndEvent(reason, signal) {
+        const result = await this.hookEventHandler.fireSessionEndEvent(reason, signal);
         return result.finalOutput ? createHookOutput("SessionEnd", result.finalOutput) : void 0;
       }
       /**
        * Fire a PreToolUse event - called before tool execution
        */
-      async firePreToolUseEvent(toolName, toolInput, toolUseId, permissionMode) {
-        const result = await this.hookEventHandler.firePreToolUseEvent(toolName, toolInput, toolUseId, permissionMode);
+      async firePreToolUseEvent(toolName, toolInput, toolUseId, permissionMode, signal) {
+        const result = await this.hookEventHandler.firePreToolUseEvent(toolName, toolInput, toolUseId, permissionMode, signal);
         return result.finalOutput ? createHookOutput("PreToolUse", result.finalOutput) : void 0;
       }
       /**
        * Fire a PostToolUse event - called after successful tool execution
        */
-      async firePostToolUseEvent(toolName, toolInput, toolResponse, toolUseId, permissionMode) {
-        const result = await this.hookEventHandler.firePostToolUseEvent(toolName, toolInput, toolResponse, toolUseId, permissionMode);
+      async firePostToolUseEvent(toolName, toolInput, toolResponse, toolUseId, permissionMode, signal) {
+        const result = await this.hookEventHandler.firePostToolUseEvent(toolName, toolInput, toolResponse, toolUseId, permissionMode, signal);
         return result.finalOutput ? createHookOutput("PostToolUse", result.finalOutput) : void 0;
       }
       /**
        * Fire a PostToolUseFailure event - called when tool execution fails
        */
-      async firePostToolUseFailureEvent(toolUseId, toolName, toolInput, errorMessage, isInterrupt, permissionMode) {
-        const result = await this.hookEventHandler.firePostToolUseFailureEvent(toolUseId, toolName, toolInput, errorMessage, isInterrupt, permissionMode);
+      async firePostToolUseFailureEvent(toolUseId, toolName, toolInput, errorMessage, isInterrupt, permissionMode, signal) {
+        const result = await this.hookEventHandler.firePostToolUseFailureEvent(toolUseId, toolName, toolInput, errorMessage, isInterrupt, permissionMode, signal);
         return result.finalOutput ? createHookOutput("PostToolUseFailure", result.finalOutput) : void 0;
       }
       /**
        * Fire a PreCompact event - called before conversation compaction
        */
-      async firePreCompactEvent(trigger, customInstructions = "") {
-        const result = await this.hookEventHandler.firePreCompactEvent(trigger, customInstructions);
+      async firePreCompactEvent(trigger, customInstructions = "", signal) {
+        const result = await this.hookEventHandler.firePreCompactEvent(trigger, customInstructions, signal);
         return result.finalOutput ? createHookOutput("PreCompact", result.finalOutput) : void 0;
       }
       /**
        * Fire a Notification event
        */
-      async fireNotificationEvent(message, notificationType, title) {
-        const result = await this.hookEventHandler.fireNotificationEvent(message, notificationType, title);
+      async fireNotificationEvent(message, notificationType, title, signal) {
+        const result = await this.hookEventHandler.fireNotificationEvent(message, notificationType, title, signal);
         return result.finalOutput ? createHookOutput("Notification", result.finalOutput) : void 0;
       }
       /**
        * Fire a SubagentStart event - called when a subagent is spawned
        */
-      async fireSubagentStartEvent(agentId, agentType, permissionMode) {
-        const result = await this.hookEventHandler.fireSubagentStartEvent(agentId, agentType, permissionMode);
+      async fireSubagentStartEvent(agentId, agentType, permissionMode, signal) {
+        const result = await this.hookEventHandler.fireSubagentStartEvent(agentId, agentType, permissionMode, signal);
         return result.finalOutput ? createHookOutput("SubagentStart", result.finalOutput) : void 0;
       }
       /**
        * Fire a SubagentStop event - called when a subagent finishes
        */
-      async fireSubagentStopEvent(agentId, agentType, agentTranscriptPath, lastAssistantMessage, stopHookActive, permissionMode) {
-        const result = await this.hookEventHandler.fireSubagentStopEvent(agentId, agentType, agentTranscriptPath, lastAssistantMessage, stopHookActive, permissionMode);
+      async fireSubagentStopEvent(agentId, agentType, agentTranscriptPath, lastAssistantMessage, stopHookActive, permissionMode, signal) {
+        const result = await this.hookEventHandler.fireSubagentStopEvent(agentId, agentType, agentTranscriptPath, lastAssistantMessage, stopHookActive, permissionMode, signal);
         return result.finalOutput ? createHookOutput("SubagentStop", result.finalOutput) : void 0;
       }
       /**
        * Fire a PermissionRequest event
        */
-      async firePermissionRequestEvent(toolName, toolInput, permissionMode, permissionSuggestions) {
-        const result = await this.hookEventHandler.firePermissionRequestEvent(toolName, toolInput, permissionMode, permissionSuggestions);
+      async firePermissionRequestEvent(toolName, toolInput, permissionMode, permissionSuggestions, signal) {
+        const result = await this.hookEventHandler.firePermissionRequestEvent(toolName, toolInput, permissionMode, permissionSuggestions, signal);
         return result.finalOutput ? createHookOutput("PermissionRequest", result.finalOutput) : void 0;
       }
     };
@@ -265694,9 +265760,13 @@ var init_message_bus = __esm({
        * This enables synchronous-style communication over the async MessageBus
        * The correlation ID is generated internally and added to the request
        */
-      async request(request4, responseType, timeoutMs = 6e4) {
+      async request(request4, responseType, timeoutMs = 6e4, signal) {
         const correlationId = randomUUID5();
         return new Promise((resolve35, reject) => {
+          if (signal?.aborted) {
+            reject(new Error("Request aborted"));
+            return;
+          }
           const timeoutId = setTimeout(() => {
             cleanup();
             reject(new Error(`Request timed out waiting for ${responseType}`));
@@ -265704,7 +265774,17 @@ var init_message_bus = __esm({
           const cleanup = /* @__PURE__ */ __name(() => {
             clearTimeout(timeoutId);
             this.unsubscribe(responseType, responseHandler);
+            if (signal) {
+              signal.removeEventListener("abort", abortHandler);
+            }
           }, "cleanup");
+          const abortHandler = /* @__PURE__ */ __name(() => {
+            cleanup();
+            reject(new Error("Request aborted"));
+          }, "abortHandler");
+          if (signal) {
+            signal.addEventListener("abort", abortHandler);
+          }
           const responseHandler = /* @__PURE__ */ __name((response) => {
             if ("correlationId" in response && response.correlationId === correlationId) {
               cleanup();
@@ -269236,36 +269316,46 @@ var init_config3 = __esm({
                 });
                 return;
               }
+              if (request4.signal?.aborted) {
+                this.messageBus?.publish({
+                  type: MessageBusType.HOOK_EXECUTION_RESPONSE,
+                  correlationId: request4.correlationId,
+                  success: false,
+                  error: new Error("Hook execution cancelled (aborted)")
+                });
+                return;
+              }
               let result;
               const input = request4.input || {};
+              const signal = request4.signal;
               switch (request4.eventName) {
                 case "UserPromptSubmit":
-                  result = await hookSystem.fireUserPromptSubmitEvent(input["prompt"] || "");
+                  result = await hookSystem.fireUserPromptSubmitEvent(input["prompt"] || "", signal);
                   break;
                 case "Stop":
-                  result = await hookSystem.fireStopEvent(input["stop_hook_active"] || false, input["last_assistant_message"] || "");
+                  result = await hookSystem.fireStopEvent(input["stop_hook_active"] || false, input["last_assistant_message"] || "", signal);
                   break;
                 case "PreToolUse": {
-                  result = await hookSystem.firePreToolUseEvent(input["tool_name"] || "", input["tool_input"] || {}, input["tool_use_id"] || "", input["permission_mode"] ?? PermissionMode.Default);
+                  result = await hookSystem.firePreToolUseEvent(input["tool_name"] || "", input["tool_input"] || {}, input["tool_use_id"] || "", input["permission_mode"] ?? PermissionMode.Default, signal);
                   break;
                 }
                 case "PostToolUse":
-                  result = await hookSystem.firePostToolUseEvent(input["tool_name"] || "", input["tool_input"] || {}, input["tool_response"] || {}, input["tool_use_id"] || "", input["permission_mode"] || "default");
+                  result = await hookSystem.firePostToolUseEvent(input["tool_name"] || "", input["tool_input"] || {}, input["tool_response"] || {}, input["tool_use_id"] || "", input["permission_mode"] || "default", signal);
                   break;
                 case "PostToolUseFailure":
-                  result = await hookSystem.firePostToolUseFailureEvent(input["tool_use_id"] || "", input["tool_name"] || "", input["tool_input"] || {}, input["error"] || "", input["is_interrupt"], input["permission_mode"] || "default");
+                  result = await hookSystem.firePostToolUseFailureEvent(input["tool_use_id"] || "", input["tool_name"] || "", input["tool_input"] || {}, input["error"] || "", input["is_interrupt"], input["permission_mode"] || "default", signal);
                   break;
                 case "Notification":
-                  result = await hookSystem.fireNotificationEvent(input["message"] || "", input["notification_type"] || "permission_prompt", input["title"] || void 0);
+                  result = await hookSystem.fireNotificationEvent(input["message"] || "", input["notification_type"] || "permission_prompt", input["title"] || void 0, signal);
                   break;
                 case "PermissionRequest":
-                  result = await hookSystem.firePermissionRequestEvent(input["tool_name"] || "", input["tool_input"] || {}, input["permission_mode"] || PermissionMode.Default, input["permission_suggestions"] || void 0);
+                  result = await hookSystem.firePermissionRequestEvent(input["tool_name"] || "", input["tool_input"] || {}, input["permission_mode"] || PermissionMode.Default, input["permission_suggestions"] || void 0, signal);
                   break;
                 case "SubagentStart":
-                  result = await hookSystem.fireSubagentStartEvent(input["agent_id"] || "", input["agent_type"] || "", input["permission_mode"] || PermissionMode.Default);
+                  result = await hookSystem.fireSubagentStartEvent(input["agent_id"] || "", input["agent_type"] || "", input["permission_mode"] || PermissionMode.Default, signal);
                   break;
                 case "SubagentStop":
-                  result = await hookSystem.fireSubagentStopEvent(input["agent_id"] || "", input["agent_type"] || "", input["agent_transcript_path"] || "", input["last_assistant_message"] || "", input["stop_hook_active"] || false, input["permission_mode"] || PermissionMode.Default);
+                  result = await hookSystem.fireSubagentStopEvent(input["agent_id"] || "", input["agent_type"] || "", input["agent_transcript_path"] || "", input["last_assistant_message"] || "", input["stop_hook_active"] || false, input["permission_mode"] || PermissionMode.Default, signal);
                   break;
                 default:
                   this.debugLogger.warn(`Unknown hook event: ${request4.eventName}`);
@@ -405793,7 +405883,7 @@ __name(getPackageJson, "getPackageJson");
 // packages/cli/src/utils/version.ts
 async function getCliVersion() {
   const pkgJson = await getPackageJson();
-  return "0.13.0-preview.4";
+  return "0.13.0-preview.6";
 }
 __name(getCliVersion, "getCliVersion");
 
@@ -413423,7 +413513,7 @@ var formatDuration = /* @__PURE__ */ __name((milliseconds) => {
 
 // packages/cli/src/generated/git-commit.ts
 init_esbuild_shims();
-var GIT_COMMIT_INFO = "49cf030d1";
+var GIT_COMMIT_INFO = "dc4760129";
 
 // packages/cli/src/utils/systemInfo.ts
 async function getNpmVersion() {
@@ -414441,7 +414531,8 @@ var clearCommand = {
       try {
         await config2.getHookSystem()?.fireSessionStartEvent(
           SessionStartSource.Clear,
-          config2.getModel() ?? ""
+          config2.getModel() ?? "",
+          String(config2.getApprovalMode())
         );
       } catch (err2) {
         config2.getDebugLogger().warn(`SessionStart hook failed: ${err2}`);
@@ -464004,7 +464095,8 @@ function useResumeCommand(options2) {
       try {
         await config2.getHookSystem()?.fireSessionStartEvent(
           SessionStartSource.Resume,
-          config2.getModel() ?? ""
+          config2.getModel() ?? "",
+          String(config2.getApprovalMode())
         );
       } catch (err2) {
         config2.getDebugLogger().warn(`SessionStart hook failed: ${err2}`);
@@ -471791,7 +471883,11 @@ var AppContainer = /* @__PURE__ */ __name((props) => {
       const sessionStartSource = resumedSessionData ? SessionStartSource.Resume : SessionStartSource.Startup;
       const hookSystem = config2.getHookSystem();
       if (hookSystem) {
-        hookSystem.fireSessionStartEvent(sessionStartSource, config2.getModel() ?? "").then(() => {
+        hookSystem.fireSessionStartEvent(
+          sessionStartSource,
+          config2.getModel() ?? "",
+          String(config2.getApprovalMode())
+        ).then(() => {
           debugLogger145.debug("SessionStart event completed successfully");
         }).catch((err2) => {
           debugLogger145.warn(`SessionStart hook failed: ${err2}`);
@@ -476793,7 +476889,7 @@ var QwenAgent = class {
   async initialize(args2) {
     this.clientCapabilities = args2.clientCapabilities;
     const authMethods = buildAuthMethods();
-    const version2 = "0.13.0-preview.4";
+    const version2 = "0.13.0-preview.6";
     return {
       protocolVersion: PROTOCOL_VERSION,
       agentInfo: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qwen-code/qwen-code",
-  "version": "0.13.0-preview.4",
+  "version": "0.13.0-preview.6",
   "description": "Qwen Code - AI-powered coding assistant",
   "repository": {
     "type": "git",
@@ -21,7 +21,7 @@
     "bundled"
   ],
   "config": {
-    "sandboxImageUri": "ghcr.io/qwenlm/qwen-code:0.13.0-preview.4"
+    "sandboxImageUri": "ghcr.io/qwenlm/qwen-code:0.13.0-preview.6"
   },
   "dependencies": {},
   "optionalDependencies": {