@qwen-code/qwen-code 0.21.2 → 0.21.3-nightly.20260803.e1e5b42ce

package/chunks/chunk-LLMGP5IC.js

@@ -0,0 +1,222 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  getTeammateContext,
+  isTeammate
+} from "./chunk-S6LOFUVP.js";
+import {
+  isInForkExecution
+} from "./chunk-7UXI6P72.js";
+import {
+  ToolNames
+} from "./chunk-CFDR3GNL.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/config/approval-mode.ts
+init_esbuild_shims();
+var ApprovalMode = /* @__PURE__ */ ((ApprovalMode2) => {
+  ApprovalMode2["PLAN"] = "plan";
+  ApprovalMode2["DEFAULT"] = "default";
+  ApprovalMode2["AUTO_EDIT"] = "auto-edit";
+  ApprovalMode2["AUTO"] = "auto";
+  ApprovalMode2["YOLO"] = "yolo";
+  return ApprovalMode2;
+})(ApprovalMode || {});
+var APPROVAL_MODES = Object.values(ApprovalMode);
+
+// packages/core/src/agents/runtime/agent-context.ts
+init_esbuild_shims();
+import { AsyncLocalStorage } from "node:async_hooks";
+var storage = new AsyncLocalStorage();
+function runWithAgentContext(agentId, fn, depthOverride) {
+  const current = storage.getStore() ?? {};
+  const depth = depthOverride ?? (current.depth ?? -1) + 1;
+  return storage.run({ ...current, agentId, depth }, fn);
+}
+__name(runWithAgentContext, "runWithAgentContext");
+function runWithRuntimeContentGenerator(view, fn) {
+  const current = storage.getStore() ?? {};
+  return storage.run({ ...current, runtimeView: view }, fn);
+}
+__name(runWithRuntimeContentGenerator, "runWithRuntimeContentGenerator");
+function getCurrentAgentId() {
+  return storage.getStore()?.agentId ?? null;
+}
+__name(getCurrentAgentId, "getCurrentAgentId");
+function getCurrentAgentDepth() {
+  return storage.getStore()?.depth ?? 0;
+}
+__name(getCurrentAgentDepth, "getCurrentAgentDepth");
+function getRuntimeContentGenerator() {
+  return storage.getStore()?.runtimeView;
+}
+__name(getRuntimeContentGenerator, "getRuntimeContentGenerator");
+function runOutsideAgentContext(fn) {
+  return storage.exit(fn);
+}
+__name(runOutsideAgentContext, "runOutsideAgentContext");
+function isTopLevelSession() {
+  return getCurrentAgentId() === null;
+}
+__name(isTopLevelSession, "isTopLevelSession");
+function childLaunchDepth() {
+  return getCurrentAgentId() !== null ? getCurrentAgentDepth() + 1 : 0;
+}
+__name(childLaunchDepth, "childLaunchDepth");
+function canSpawnNestedAgent(maxDepth) {
+  return childLaunchDepth() + 1 <= maxDepth;
+}
+__name(canSpawnNestedAgent, "canSpawnNestedAgent");
+function spawnBlockReason(maxDepth) {
+  if (!canSpawnNestedAgent(maxDepth)) return "depth";
+  if (isTeammate()) return "teammate";
+  if (isInForkExecution()) return "fork";
+  return null;
+}
+__name(spawnBlockReason, "spawnBlockReason");
+
+// packages/core/src/agents/runtime/subagent-plan-tool-policy.ts
+init_esbuild_shims();
+var SUBAGENT_PLAN_LIFECYCLE_TOOLS = /* @__PURE__ */ new Set([
+  ToolNames.ENTER_PLAN_MODE,
+  ToolNames.EXIT_PLAN_MODE
+]);
+var PLAN_REQUIRED_TEAMMATE_PRE_APPROVAL_TOOLS = /* @__PURE__ */ new Set([
+  ToolNames.EXIT_PLAN_MODE,
+  ToolNames.READ_FILE,
+  ToolNames.GREP,
+  ToolNames.GLOB,
+  ToolNames.LS,
+  ToolNames.LSP,
+  ToolNames.TASK_LIST,
+  ToolNames.TOOL_SEARCH,
+  ToolNames.READ_MCP_RESOURCE
+]);
+var PRE_APPROVAL_TASK_CLAIM_KEYS = /* @__PURE__ */ new Set([
+  "taskId",
+  "status",
+  "owner",
+  "addBlocks",
+  "addBlockedBy"
+]);
+function isSubagentLikeExecutionContext() {
+  return getCurrentAgentId() !== null || isTeammate();
+}
+__name(isSubagentLikeExecutionContext, "isSubagentLikeExecutionContext");
+function isPlanRequiredTeammateContext() {
+  return getTeammateContext()?.planModeRequired === true;
+}
+__name(isPlanRequiredTeammateContext, "isPlanRequiredTeammateContext");
+function isPlanRequiredTeammateAwaitingApproval(config) {
+  return isPlanRequiredTeammateContext() && config.getApprovalMode() === "plan" /* PLAN */;
+}
+__name(isPlanRequiredTeammateAwaitingApproval, "isPlanRequiredTeammateAwaitingApproval");
+function isPlanLifecycleToolUnavailableInSubagent(toolName) {
+  if (!isSubagentLikeExecutionContext()) return false;
+  if (toolName === ToolNames.ENTER_PLAN_MODE) return true;
+  if (toolName === ToolNames.EXIT_PLAN_MODE) {
+    return !isPlanRequiredTeammateContext();
+  }
+  return false;
+}
+__name(isPlanLifecycleToolUnavailableInSubagent, "isPlanLifecycleToolUnavailableInSubagent");
+function shouldUsePlanOnlyReminderInSubagentContext() {
+  return isSubagentLikeExecutionContext() && !isPlanRequiredTeammateContext();
+}
+__name(shouldUsePlanOnlyReminderInSubagentContext, "shouldUsePlanOnlyReminderInSubagentContext");
+function isLeaderOnlyToolUnavailableInSubagent(toolName) {
+  return isSubagentLikeExecutionContext() && toolName === ToolNames.TEAM_PLAN_APPROVAL;
+}
+__name(isLeaderOnlyToolUnavailableInSubagent, "isLeaderOnlyToolUnavailableInSubagent");
+function getLeaderOnlyToolUnavailableMessage(toolName) {
+  return `${toolName} is only available to the team leader. Subagents and teammates cannot approve teammate plans.`;
+}
+__name(getLeaderOnlyToolUnavailableMessage, "getLeaderOnlyToolUnavailableMessage");
+function getPlanRequiredTeammatePreApprovalMessage(toolName) {
+  return `${toolName} is not available while this plan-required teammate is waiting for leader approval. Finish investigation, call exit_plan_mode with the proposed plan, and wait for the leader to approve it before taking execution actions.`;
+}
+__name(getPlanRequiredTeammatePreApprovalMessage, "getPlanRequiredTeammatePreApprovalMessage");
+function isPlanRequiredTeammatePreApprovalAllowedTool(toolName, params) {
+  if (PLAN_REQUIRED_TEAMMATE_PRE_APPROVAL_TOOLS.has(toolName)) {
+    return true;
+  }
+  if (toolName !== ToolNames.TASK_UPDATE) {
+    return false;
+  }
+  return isPreApprovalClaimOnlyTaskUpdate(params);
+}
+__name(isPlanRequiredTeammatePreApprovalAllowedTool, "isPlanRequiredTeammatePreApprovalAllowedTool");
+function isPreApprovalClaimOnlyTaskUpdate(params) {
+  if (typeof params !== "object" || params === null || Array.isArray(params)) {
+    return false;
+  }
+  const taskParams = params;
+  for (const key of Object.keys(taskParams)) {
+    if (!PRE_APPROVAL_TASK_CLAIM_KEYS.has(key)) {
+      return false;
+    }
+  }
+  const agentName = getTeammateContext()?.agentName;
+  return typeof taskParams["taskId"] === "string" && taskParams["status"] === "in_progress" && (taskParams["owner"] === void 0 || taskParams["owner"] === agentName) && isAbsentOrEmptyArray(taskParams["addBlocks"]) && isAbsentOrEmptyArray(taskParams["addBlockedBy"]);
+}
+__name(isPreApprovalClaimOnlyTaskUpdate, "isPreApprovalClaimOnlyTaskUpdate");
+function isAbsentOrEmptyArray(value) {
+  return value === void 0 || Array.isArray(value) && value.length === 0;
+}
+__name(isAbsentOrEmptyArray, "isAbsentOrEmptyArray");
+function getSubagentPlanToolUnavailableMessage(toolName) {
+  return `${toolName} is not available inside subagents or team agents. Plan mode is owned by the caller/main session; return your plan, findings, or constraints to the caller in your normal response instead of entering or exiting plan mode.`;
+}
+__name(getSubagentPlanToolUnavailableMessage, "getSubagentPlanToolUnavailableMessage");
+function buildSubagentPlanToolBlockedResult(toolName, logTag, logger) {
+  const message = getSubagentPlanToolUnavailableMessage(toolName);
+  logger.warn(
+    `[${logTag}] Blocked plan lifecycle tool call from subagent: ${toolName}`
+  );
+  return {
+    llmContent: message,
+    returnDisplay: message,
+    error: { message }
+  };
+}
+__name(buildSubagentPlanToolBlockedResult, "buildSubagentPlanToolBlockedResult");
+
+export {
+  APPROVAL_MODES,
+  runWithAgentContext,
+  runWithRuntimeContentGenerator,
+  getCurrentAgentId,
+  getCurrentAgentDepth,
+  getRuntimeContentGenerator,
+  runOutsideAgentContext,
+  isTopLevelSession,
+  childLaunchDepth,
+  spawnBlockReason,
+  SUBAGENT_PLAN_LIFECYCLE_TOOLS,
+  isSubagentLikeExecutionContext,
+  isPlanRequiredTeammateContext,
+  isPlanRequiredTeammateAwaitingApproval,
+  isPlanLifecycleToolUnavailableInSubagent,
+  shouldUsePlanOnlyReminderInSubagentContext,
+  isLeaderOnlyToolUnavailableInSubagent,
+  getLeaderOnlyToolUnavailableMessage,
+  getPlanRequiredTeammatePreApprovalMessage,
+  isPlanRequiredTeammatePreApprovalAllowedTool,
+  getSubagentPlanToolUnavailableMessage,
+  buildSubagentPlanToolBlockedResult
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-44F4LBWZ.js → chunk-LVW7BHTW.js}

@@ -17,7 +17,7 @@ import {
 } from "./chunk-OCPBI7J5.js";
 import {
   defaultSpawnChannelFactory
-} from "./chunk-XUGZYLDH.js";
+} from "./chunk-UWSXFI6E.js";
 import {
   BridgeChannelClosedError,
   BridgeTimeoutError,
@@ -26,7 +26,7 @@ import {
   STATUS_SCHEMA_VERSION,
   createIdleWorkspaceExtensionsStatus,
   createIdleWorkspaceHooksStatus
-} from "./chunk-GURGAJTX.js";
+} from "./chunk-PDDYAXL2.js";
 import {
   CHANNEL_STARTUP_PROFILE_META_KEY,
   CHANNEL_STARTUP_PROFILE_VERSION,
@@ -39,10 +39,11 @@ import {
   LOAD_REPLAY_VERSION,
   MID_TURN_QUEUE_DRAIN_METHOD,
   PROMPT_CANCEL_METHOD,
+  REQUESTED_SESSION_ID_META_KEY,
   TODO_STOP_GUARD_CONTINUATION_CLAIM_METHOD,
   TODO_STOP_GUARD_QUEUE_RELEASE_METHOD,
   WORKTREE_MCP_DEFER_META_KEY
-} from "./chunk-CPZAH673.js";
+} from "./chunk-UKZEXS6K.js";
 import {
   BranchWhilePromptActiveError,
   CancelSentinelCollisionError,
@@ -63,11 +64,11 @@ import {
   SessionShellDisabledError,
   WorkspaceMismatchError,
   isNotCurrentlyGeneratingCancelError
-} from "./chunk-B4AJNNOL.js";
+} from "./chunk-J26HHFI5.js";
 import {
   canonicalizeWorkspace,
   translateAndCheckAbsoluteWorkspacePath
-} from "./chunk-2RFKHEXL.js";
+} from "./chunk-6PLDPT2C.js";
 import {
   CHANNEL_DELIVERY_ERROR_CODES,
   MAX_SUB_SESSION_NAME_CHARS,
@@ -89,16 +90,16 @@ import {
   metadataBudgetBytes,
   normalizeSnapshotPayload,
   stableSessionArtifactId
-} from "./chunk-54YCNSK5.js";
+} from "./chunk-MVMBE5EH.js";
 import {
   DAEMON_TRACEPARENT_META_KEY,
   DAEMON_TRACESTATE_META_KEY
-} from "./chunk-Z3S5EMOW.js";
+} from "./chunk-RPYYTL7E.js";
 import {
   INVOCATION_CONTEXT_META_KEY,
   PRIVATE_ACP_CAPABILITY_ENV,
   PRIVATE_PARENT_CAPABILITY_META_KEY
-} from "./chunk-DUNI4EBW.js";
+} from "./chunk-KZXSAQYV.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -2126,14 +2127,19 @@ var BridgeClient = class {
       const byOriginator = /* @__PURE__ */ new Map();
       for (const item of drained) {
         const group = byOriginator.get(item.originatorClientId);
-        if (group) group.push(item.text);
-        else byOriginator.set(item.originatorClientId, [item.text]);
+        if (group) group.push(item);
+        else byOriginator.set(item.originatorClientId, [item]);
       }
-      for (const [originatorClientId, texts] of byOriginator) {
+      for (const [originatorClientId, items] of byOriginator) {
+        const texts = items.map((item) => item.text);
         const published = entry.events.publish({
           type: MID_TURN_MESSAGE_INJECTED_EVENT,
           ...entry.activePromptId ? { promptId: entry.activePromptId } : {},
-          data: { sessionId: entry.sessionId, messages: texts },
+          data: {
+            sessionId: entry.sessionId,
+            messages: texts,
+            messageIds: items.map((item) => item.messageId)
+          },
           ...originatorClientId ? { originatorClientId } : {}
         });
         writeStderrLine(
@@ -5905,7 +5911,7 @@ var SESSION_TRANSCRIPT_TIMEOUT_MS = 6e4;
 var SHELL_COMMAND_TIMEOUT_MS = 12e4;
 var MAX_SHELL_OUTPUT_FOR_HISTORY = 1e4;
 var MAX_MID_TURN_QUEUE_DEPTH = 20;
-var DEFAULT_MAX_SESSIONS = 20;
+var DEFAULT_MAX_SESSIONS = 32;
 var DEFAULT_MAX_PENDING_PROMPTS_PER_SESSION = 5;
 var MAX_EVENT_RING_SIZE = 1e6;
 var DEFAULT_PERMISSION_TIMEOUT_MS = 5 * 60 * 1e3;
@@ -6656,7 +6662,7 @@ function createAcpSessionBridge(opts) {
     }
   }
   __name(ensureChannel, "ensureChannel");
-  async function doSpawn(modelServiceId, effectiveScope, approvalMode, requestedClientId, onSessionRegistered, parentSessionId, sourceType, sourceId, worktree, branch) {
+  async function doSpawn(modelServiceId, effectiveScope, approvalMode, requestedClientId, onSessionRegistered, parentSessionId, sourceType, sourceId, worktree, branch, requestedSessionId) {
     const channelPath = channelInfo && !channelInfo.isDying ? "reused" : inFlightChannelSpawn ? "joined" : "spawned_on_request";
     const ci = await telemetry.withSpan(
       "channel.wait",
@@ -6685,7 +6691,14 @@ function createAcpSessionBridge(opts) {
             const request = telemetry.injectPromptContext({
               cwd: boundWorkspace,
               mcpServers: [],
-              ...sourceType ? { _meta: sessionSourceRequestMeta(sourceType, sourceId) } : {}
+              ...requestedSessionId || sourceType ? {
+                _meta: {
+                  ...sessionSourceRequestMeta(sourceType, sourceId),
+                  ...requestedSessionId ? {
+                    [REQUESTED_SESSION_ID_META_KEY]: requestedSessionId
+                  } : {}
+                }
+              } : {}
             });
             const response = await withTimeout(
               ci.connection.newSession(
@@ -8450,7 +8463,8 @@ function createAcpSessionBridge(opts) {
         source.sourceType,
         source.sourceId,
         req.worktree,
-        req.branch
+        req.branch,
+        req.sessionId
       );
       const tracker = effectiveScope === "single" ? workspaceKey : `${workspaceKey}#${randomUUID2()}`;
       inFlightSpawns.set(tracker, promise);
@@ -10113,8 +10127,32 @@ function createAcpSessionBridge(opts) {
         );
         return { accepted: false };
       }
-      entry.midTurnMessageQueue.push({ text: trimmed, originatorClientId });
-      return { accepted: true };
+      const messageId = randomUUID2();
+      entry.midTurnMessageQueue.push({
+        messageId,
+        text: trimmed,
+        originatorClientId
+      });
+      return { accepted: true, messageId };
+    },
+    removeMidTurnMessage(sessionId, messageId, context) {
+      const entry = byId.get(sessionId);
+      if (!entry) throw new SessionNotFoundError(sessionId);
+      const originatorClientId = resolveTrustedClientId(
+        entry,
+        context?.clientId
+      );
+      const index = entry.midTurnMessageQueue.findIndex(
+        (message) => message.messageId === messageId && message.originatorClientId === originatorClientId
+      );
+      if (index === -1) {
+        writeStderrLine(
+          `[mid-turn] session=${JSON.stringify(entry.sessionId)} remove missed messageId=${JSON.stringify(messageId)} (already drained or originator mismatch)`
+        );
+        return { removed: false };
+      }
+      entry.midTurnMessageQueue.splice(index, 1);
+      return { removed: true };
     },
     async generateSessionBtw(sessionId, question, signal, _context) {
       const entry = byId.get(sessionId);

package/chunks/{chunk-YGE3IXJP.js → chunk-M744OFVE.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   CHANNEL_STARTUP_PROFILE_VERSION
-} from "./chunk-CPZAH673.js";
+} from "./chunk-UKZEXS6K.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";