@qwen-code/qwen-code 0.19.10 → 0.19.11-nightly.20260718.767a32484

package/chunks/{chunk-VBRRNQB7.js → chunk-OPVIKLKK.js}

@@ -3,16 +3,16 @@
 import {
   settleChatRecording,
   subscribeToHeadlessChatRecordingFailures
-} from "./chunk-CJFNEBYB.js";
+} from "./chunk-3NWYQ7FX.js";
+import {
+  handleAtCommand
+} from "./chunk-GAQOQMHY.js";
 import {
   JsonOutputAdapter
-} from "./chunk-F7NXQH4Y.js";
+} from "./chunk-6YIRYY3P.js";
 import {
   StreamJsonOutputAdapter
-} from "./chunk-LTNI523B.js";
-import {
-  handleAtCommand
-} from "./chunk-X362TMXZ.js";
+} from "./chunk-HT7L5FCZ.js";
 import {
   buildInitialSystemReminders,
   buildSystemMessage,
@@ -24,10 +24,10 @@ import {
   insertAfterFunctionResponses,
   isSlashCommand,
   normalizePartList
-} from "./chunk-YX4LLZ3D.js";
+} from "./chunk-QPRDXJIC.js";
 import {
   RunBudgetEnforcer
-} from "./chunk-CEW4HDPK.js";
+} from "./chunk-GUNTLALV.js";
 import {
   AlreadyReportedError,
   handleBudgetExceededError,
@@ -35,35 +35,39 @@ import {
   handleError,
   handleMaxTurnsExceededError,
   handleToolError
-} from "./chunk-65N2J6V2.js";
+} from "./chunk-64XGKNSI.js";
 import {
   isInlineModelOverrideAllowed
-} from "./chunk-GGJII3FM.js";
+} from "./chunk-6Z5NRZVU.js";
 import {
   buildSessionRecoveryPlanFromApiHistory,
+  canonicalToolName,
   createDuplicateProviderToolCallResponse,
   detectAutonomousSentinel,
   detectLoopSentinel,
   executeToolCall,
   findRepeatedDuplicateProviderToolCall,
   isSystemReminderContent,
+  isToolCallConcurrencySafe,
   markDuplicateProviderToolCallResponseSent,
   parseAndFormatApiError,
+  parsePositiveIntegerEnv,
+  partitionByConcurrencySafety,
   promptIdContext,
   restoreWorktreeContext
-} from "./chunk-K7CRWKOE.js";
+} from "./chunk-3YJZ6WNY.js";
 import {
   isTelemetrySdkInitialized,
   shutdownTelemetry,
   uiTelemetryService
-} from "./chunk-P6LART6G.js";
+} from "./chunk-66IT3EY2.js";
 import {
   ToolNames
-} from "./chunk-2UUAIFQO.js";
+} from "./chunk-ANRANWVE.js";
 import {
   FatalInputError,
   createDebugLogger
-} from "./chunk-7NFB7LBQ.js";
+} from "./chunk-UE5TZ55T.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -94,14 +98,14 @@ var LOOP_TYPE_LABELS = {
   ["shell_command_stagnation" /* SHELL_COMMAND_STAGNATION */]: "the model repeated similar shell inspection commands without making progress",
   ["global_tool_call_duplicate" /* GLOBAL_TOOL_CALL_DUPLICATE */]: "the model repeated the same tool call across the turn, even when not back-to-back",
   ["alternating_tool_call_pattern" /* ALTERNATING_TOOL_CALL_PATTERN */]: "the model alternated between the same two tool calls in a repeating pattern",
-  ["turn_tool_call_cap" /* TURN_TOOL_CALL_CAP */]: "the model exceeded the maximum number of tool calls allowed in a single turn",
+  ["turn_tool_call_cap" /* TURN_TOOL_CALL_CAP */]: "the turn reached the per-turn tool-call limit",
   ["invalid_tool_params_stagnation" /* INVALID_TOOL_PARAMS_STAGNATION */]: "the model repeatedly sent invalid tool parameters without correcting them"
 };
 function formatLoopDetectedMessage(loopType) {
   const reason = loopType ? LOOP_TYPE_LABELS[loopType] : void 0;
   const detail = reason ? ` (${loopType}: ${reason})` : "";
   const isAlwaysOn = loopType === "consecutive_identical_tool_calls" /* CONSECUTIVE_IDENTICAL_TOOL_CALLS */ || loopType === "shell_command_stagnation" /* SHELL_COMMAND_STAGNATION */ || loopType === "global_tool_call_duplicate" /* GLOBAL_TOOL_CALL_DUPLICATE */ || loopType === "invalid_tool_params_stagnation" /* INVALID_TOOL_PARAMS_STAGNATION */;
-  const hint = loopType === "turn_tool_call_cap" /* TURN_TOOL_CALL_CAP */ ? " Raise the `model.maxToolCallsPerTurn` setting to allow longer turns, or set it to 0 to disable the cap." : isAlwaysOn ? " This is an always-on guard and cannot be disabled via `model.skipLoopDetection`." : " Set the `model.skipLoopDetection` setting to true to disable.";
+  const hint = loopType === "turn_tool_call_cap" /* TURN_TOOL_CALL_CAP */ ? " A per-turn tool-call cap was reached. The default is adaptive (allows up to 1000 diverse calls, halting only on repeated calls); an explicitly set `model.maxToolCallsPerTurn` is a hard cap. If the model was repeating the same call, investigate the repetition; otherwise unset the value to use the adaptive default, or raise it (set 0 to disable)." : isAlwaysOn ? " This is an always-on guard and cannot be disabled via `model.skipLoopDetection`." : " Set the `model.skipLoopDetection` setting to true to disable.";
   return `Loop detection halted the run${detail}.${hint}`;
 }
 __name(formatLoopDetectedMessage, "formatLoopDetectedMessage");
@@ -155,6 +159,18 @@ async function emitNonInteractiveFinalMessage(params) {
   });
 }
 __name(emitNonInteractiveFinalMessage, "emitNonInteractiveFinalMessage");
+function partitionHeadlessToolCalls(requests, config) {
+  const registry = config.getToolRegistry();
+  return partitionByConcurrencySafety(
+    requests,
+    (request) => isToolCallConcurrencySafe(
+      request.name,
+      registry.getTool(canonicalToolName(request.name))?.kind,
+      request.args
+    )
+  );
+}
+__name(partitionHeadlessToolCalls, "partitionHeadlessToolCalls");
 async function runNonInteractive(config, settings, input, prompt_id, options = {}) {
   return promptIdContext.run(prompt_id, async () => {
     let adapter;
@@ -676,8 +692,15 @@ ${text}
         const executedRequests = new Set(
           respondedRequests
         );
-        for (const requestInfo of requestsToExecute) {
-          executedRequests.add(requestInfo);
+        const toolBatches = partitionHeadlessToolCalls(
+          requestsToExecute,
+          config
+        );
+        const isBudgetExempt = /* @__PURE__ */ __name((requestInfo) => requestInfo.name === ToolNames.STRUCTURED_OUTPUT && config.getJsonSchema?.() !== void 0, "isBudgetExempt");
+        const launchToolCall = /* @__PURE__ */ __name(async (requestInfo) => {
+          debugLogger.debug(
+            `[runNonInteractive] launching tool call ${requestInfo.callId} (${requestInfo.name})`
+          );
           const inputFormat = typeof config.getInputFormat === "function" ? config.getInputFormat() : "text" /* TEXT */;
           const toolCallUpdateCallback = inputFormat === "stream-json" /* STREAM_JSON */ && options.controlService ? options.controlService.permission.getToolCallUpdateCallback() : void 0;
           const isAgentTool = requestInfo.name === "agent";
@@ -686,12 +709,7 @@ ${text}
             requestInfo.callId,
             adapter
           ) : createToolProgressHandler(requestInfo, adapter);
-          const isStructuredOutputExempt = requestInfo.name === ToolNames.STRUCTURED_OUTPUT && config.getJsonSchema?.() !== void 0;
-          if (!isStructuredOutputExempt) {
-            budgetEnforcer.tickToolCall();
-          }
-          if (abortController.signal.aborted) await routeAbort();
-          const toolResponse = await executeToolCall(
+          const response = await executeToolCall(
             config,
             requestInfo,
             abortController.signal,
@@ -702,6 +720,12 @@ ${text}
               }
             }
           );
+          debugLogger.debug(
+            `[runNonInteractive] tool call ${requestInfo.callId} (${requestInfo.name}) settled${response.error ? " with error" : ""}`
+          );
+          return response;
+        }, "launchToolCall");
+        const finalizeToolCall = /* @__PURE__ */ __name((requestInfo, toolResponse) => {
           if (toolResponse.error) {
             handleToolError(
               requestInfo.name,
@@ -724,7 +748,70 @@ ${text}
           }
           if (requestInfo.name === ToolNames.STRUCTURED_OUTPUT && !toolResponse.error) {
             structuredSubmission = requestInfo.args;
-            break;
+            return true;
+          }
+          return false;
+        }, "finalizeToolCall");
+        const maxToolConcurrency = parsePositiveIntegerEnv(
+          process.env["QWEN_CODE_MAX_TOOL_CONCURRENCY"],
+          10
+        );
+        let sessionEnded = false;
+        for (const batch of toolBatches) {
+          if (sessionEnded) break;
+          if (batch.concurrent && batch.calls.length > 1) {
+            const launched = [];
+            const inFlight = /* @__PURE__ */ new Set();
+            for (const requestInfo of batch.calls) {
+              if (!isBudgetExempt(requestInfo)) {
+                budgetEnforcer.tickToolCall();
+              }
+              if (abortController.signal.aborted) break;
+              executedRequests.add(requestInfo);
+              const promise = launchToolCall(requestInfo);
+              launched.push({ requestInfo, promise });
+              const marker = promise.then(
+                () => {
+                },
+                () => {
+                }
+              ).finally(() => {
+                inFlight.delete(marker);
+              });
+              inFlight.add(marker);
+              if (inFlight.size >= maxToolConcurrency) {
+                await Promise.race(inFlight);
+              }
+            }
+            const settled = await Promise.allSettled(
+              launched.map((l) => l.promise)
+            );
+            for (let i = 0; i < launched.length; i++) {
+              const outcome = settled[i];
+              if (outcome.status === "rejected") {
+                throw outcome.reason;
+              }
+              if (finalizeToolCall(launched[i].requestInfo, outcome.value)) {
+                sessionEnded = true;
+                break;
+              }
+            }
+            if (!sessionEnded && abortController.signal.aborted) {
+              await routeAbort();
+            }
+          } else {
+            for (const requestInfo of batch.calls) {
+              if (!isBudgetExempt(requestInfo)) {
+                budgetEnforcer.tickToolCall();
+              }
+              if (abortController.signal.aborted) await routeAbort();
+              executedRequests.add(requestInfo);
+              const toolResponse = await launchToolCall(requestInfo);
+              if (finalizeToolCall(requestInfo, toolResponse)) {
+                sessionEnded = true;
+                break;
+              }
+            }
           }
         }
         const unexecutedCalls = executableBatchRequests.filter(

package/chunks/{chunk-2Z5UX4KI.js → chunk-OSSDHJDU.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   createDebugLogger
-} from "./chunk-7NFB7LBQ.js";
+} from "./chunk-UE5TZ55T.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";