@qwen-code/qwen-code 0.21.0 → 0.21.1-nightly.20260731.702932cc7

package/chunks/{chunk-UDX5OBWR.js → chunk-E2FN6SM7.js}

@@ -1,12 +1,21 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  CLIENT_MCP_OVER_WS_CONFIG_FLAG
+} from "./chunk-CPZAH673.js";
+import {
+  SessionNotFoundError
+} from "./chunk-B4AJNNOL.js";
 import {
   ChannelWorkerStartupError
-} from "./chunk-5NBDS5S6.js";
+} from "./chunk-FCYYAB4S.js";
 import {
   ChannelDeliveryError,
   ChannelWebhookEnqueueError
-} from "./chunk-LK7CHLVP.js";
+} from "./chunk-U4VTUMMK.js";
+import {
+  CHANNEL_LOOP_MCP_SERVER_NAME
+} from "./chunk-JCJ7LKNA.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -122,6 +131,75 @@ function createChannelWorkerGroup(opts) {
       ...opts.shared.restartPolicy ? { restartPolicy: opts.shared.restartPolicy } : {},
       ...opts.shared.startupTimeoutMs !== void 0 ? { startupTimeoutMs: opts.shared.startupTimeoutMs } : {},
       ...opts.shared.heartbeatTimeoutMs !== void 0 ? { heartbeatTimeoutMs: opts.shared.heartbeatTimeoutMs } : {},
+      registerChannelLoopMcp: /* @__PURE__ */ __name(async ({ sessionId, ownerId, sendMessage }) => {
+        runtime.clientMcpSenderRegistry.setSession(
+          CHANNEL_LOOP_MCP_SERVER_NAME,
+          sessionId,
+          sendMessage,
+          ownerId
+        );
+        try {
+          const config = {
+            type: "sdk",
+            [CLIENT_MCP_OVER_WS_CONFIG_FLAG]: true
+          };
+          const result = await runtime.bridge.addSessionRuntimeMcpServer(
+            sessionId,
+            CHANNEL_LOOP_MCP_SERVER_NAME,
+            config,
+            ownerId
+          );
+          if (result.skipped) {
+            throw new Error(
+              `runtime MCP add skipped: ${result.reason ?? "unknown"}`
+            );
+          }
+          if (result.shadowedSettings) {
+            throw new Error(
+              `channel loop MCP server conflicts with a configured MCP server`
+            );
+          }
+          if (!runtime.clientMcpSenderRegistry.ownsSession(
+            CHANNEL_LOOP_MCP_SERVER_NAME,
+            sessionId,
+            ownerId
+          )) {
+            throw new Error("Channel loop MCP registration was superseded.");
+          }
+        } catch (error) {
+          if (runtime.clientMcpSenderRegistry.deleteSession(
+            CHANNEL_LOOP_MCP_SERVER_NAME,
+            sessionId,
+            ownerId
+          )) {
+            await runtime.bridge.removeSessionRuntimeMcpServer(
+              sessionId,
+              CHANNEL_LOOP_MCP_SERVER_NAME,
+              ownerId
+            ).catch(() => {
+            });
+          }
+          throw error;
+        }
+      }, "registerChannelLoopMcp"),
+      unregisterChannelLoopMcp: /* @__PURE__ */ __name(async (sessionId, ownerId) => {
+        if (!runtime.clientMcpSenderRegistry.deleteSession(
+          CHANNEL_LOOP_MCP_SERVER_NAME,
+          sessionId,
+          ownerId
+        )) {
+          return;
+        }
+        try {
+          await runtime.bridge.removeSessionRuntimeMcpServer(
+            sessionId,
+            CHANNEL_LOOP_MCP_SERVER_NAME,
+            ownerId
+          );
+        } catch (error) {
+          if (!(error instanceof SessionNotFoundError)) throw error;
+        }
+      }, "unregisterChannelLoopMcp"),
       ...opts.onReady ? {
         onReady: /* @__PURE__ */ __name((snapshot) => {
           if (entries.get(runtime.workspaceCwd)?.generation === entryGeneration) {
@@ -544,7 +622,13 @@ function createChannelWorkerGroup(opts) {
     async deliverChannelMessage(request, workspaceCwd) {
       const entry = routeEntry(request.channelName, workspaceCwd);
       const deliver = entry?.supervisor.deliverChannelMessage;
-      if (!entry || drainingWorkspaces.has(entry.workspaceCwd) || !deliver) {
+      if (entry && drainingWorkspaces.has(entry.workspaceCwd)) {
+        throw new ChannelDeliveryError(
+          "channel_worker_unavailable",
+          `Channel worker for channel "${request.channelName}" is unavailable while its workspace is draining.`
+        );
+      }
+      if (!entry || !deliver) {
         const hint = workspaceCwd ? `No channel worker for the selected workspace owns channel "${request.channelName}".` : `No channel worker owns channel "${request.channelName}".`;
         throw new ChannelDeliveryError("channel_worker_unavailable", hint);
       }
@@ -552,7 +636,13 @@ function createChannelWorkerGroup(opts) {
     },
     async enqueueWebhookTask(task) {
       const entry = routeEntry(task.channelName);
-      if (!entry || drainingWorkspaces.has(entry.workspaceCwd)) {
+      if (entry && drainingWorkspaces.has(entry.workspaceCwd)) {
+        throw new ChannelWebhookEnqueueError(
+          "channel_worker_unavailable",
+          `Channel worker for channel "${task.channelName}" is unavailable while its workspace is draining.`
+        );
+      }
+      if (!entry) {
         throw new ChannelWebhookEnqueueError(
           "channel_worker_unavailable",
           `No channel worker owns channel "${task.channelName}".`

package/chunks/{chunk-USTWD7QV.js → chunk-E6CJ2SMM.js}

@@ -4,17 +4,19 @@ import {
   retryContext
 } from "./chunk-P3QQPMQA.js";
 import {
+  formatQuotaExhaustedMessage,
   getRateLimitErrorDetails,
   getRetryAfterDelayMs,
   getRetryDelayMs,
+  isQuotaExhaustedError,
   isQwenQuotaExceededError,
   isRateLimitError
-} from "./chunk-6FGBXPWM.js";
+} from "./chunk-XQK4XXTN.js";
 import {
   createDebugLogger,
   getErrorStatus,
   isAbortError
-} from "./chunk-NL7LTRLR.js";
+} from "./chunk-E2BHWIDT.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -138,20 +140,18 @@ function isRetryAbortError(error) {
   return error instanceof Error && error.name === "CanceledError";
 }
 __name(isRetryAbortError, "isRetryAbortError");
+var MAX_TRANSPORT_CAUSE_DEPTH = 4;
 function getTransportCode(error) {
-  if (typeof error !== "object" || error === null) {
-    return void 0;
-  }
-  const directCode = error.code;
-  if (typeof directCode === "string" && isTransportCode(directCode)) {
-    return directCode;
-  }
-  const cause = error instanceof Error ? error.cause : void 0;
-  if (typeof cause === "object" && cause !== null) {
-    const causeCode = cause.code;
-    if (typeof causeCode === "string" && isTransportCode(causeCode)) {
-      return causeCode;
+  let current = error;
+  for (let depth = 0; depth <= MAX_TRANSPORT_CAUSE_DEPTH; depth++) {
+    if (typeof current !== "object" || current === null) {
+      return void 0;
     }
+    const code = current.code;
+    if (typeof code === "string" && isTransportCode(code)) {
+      return code;
+    }
+    current = current instanceof Error ? current.cause : void 0;
   }
   return void 0;
 }
@@ -216,7 +216,10 @@ var DEFAULT_RETRY_OPTIONS = {
 };
 function defaultShouldRetry(error, extraRetryErrorCodes) {
   const status = getErrorStatus(error);
-  return isRateLimitError(error, extraRetryErrorCodes) || status !== void 0 && status >= 500 && status < 600;
+  if (isRateLimitError(error, extraRetryErrorCodes) || status !== void 0 && status >= 500 && status < 600) {
+    return true;
+  }
+  return classifyRetryError(error, { extraRetryErrorCodes }).kind === "transport";
 }
 __name(defaultShouldRetry, "defaultShouldRetry");
 function hasRetryAfterStatus(status) {
@@ -371,6 +374,14 @@ To continue using Qwen Code, try one of these alternatives:
 After setting up your API key, run /auth to configure your provider.`
         );
       }
+      if (isQuotaExhaustedError(error)) {
+        debugLogger.error(
+          "Quota exhausted, fast-failing",
+          retryDiagnostics,
+          error
+        );
+        throw new Error(formatQuotaExhaustedMessage(error), { cause: error });
+      }
       const isTransient = isTransientCapacityError(error);
       const callerAllowsRetry = hasCustomShouldRetryOnError ? shouldRetryOnError(error) : defaultShouldRetry(error, extraRetryErrorCodes);
       const isFailFast = retryDiagnostics.diagnosis === "fail-fast";
@@ -498,7 +509,6 @@ __name(logRetryAtStatusLevel, "logRetryAtStatusLevel");
 export {
   classifyRetryError,
   isFallbackEligible,
-  isTransientCapacityError,
   isUnattendedMode,
   delay,
   retryWithBackoff

package/chunks/{chunk-KMQ33DO4.js → chunk-EDB7A72S.js}

@@ -3,21 +3,21 @@
 import {
   resolveModelConfig,
   resolveProviderProtocol
-} from "./chunk-PHOF65IG.js";
+} from "./chunk-FRXG4ARO.js";
 import {
   external_exports
 } from "./chunk-H6XPXXMH.js";
 import {
   stripRuntimeSnapshotPrefix
-} from "./chunk-MZAXJAUM.js";
+} from "./chunk-26JK4RPD.js";
 import {
   REASONING_EFFORT_TIERS,
   normalizeReasoningEffort
-} from "./chunk-XVNQMZ2I.js";
+} from "./chunk-DGEIYUC3.js";
 import {
   AuthType,
   MODEL_GENERATION_CONFIG_FIELDS
-} from "./chunk-IKCX4CCL.js";
+} from "./chunk-DKPJUF5F.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-7ZCNENPP.js → chunk-FANRZEAJ.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   resolvePath
-} from "./chunk-RWTEFFPU.js";
+} from "./chunk-JCJ7LKNA.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-WBL3FJEU.js → chunk-FC4KQFCS.js}

@@ -4,7 +4,7 @@ import {
   require_call_bind_apply_helpers,
   require_get_intrinsic,
   require_type
-} from "./chunk-T2NCM2ET.js";
+} from "./chunk-T3CHYWJZ.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-5NBDS5S6.js → chunk-FCYYAB4S.js}

@@ -1,5 +1,12 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  CHANNEL_LOOP_MCP_IPC_TIMEOUT_MS,
+  MAX_CHANNEL_LOOP_MCP_IN_FLIGHT,
+  createChannelLoopMcpRequest,
+  isChannelLoopMcpControlMessage,
+  isChannelLoopMcpResultMessage
+} from "./chunk-FYJ7W2PI.js";
 import {
   CHANNEL_DAEMON_WORKER_SENTINEL,
   CHANNEL_DELIVERY_IPC_TIMEOUT_MS,
@@ -18,26 +25,28 @@ import {
   QWEN_SERVER_TOKEN_ENV,
   createChannelDeliveryMessage,
   createChannelWebhookTaskMessage,
-  createWorkerDiagnosticRedactor,
   isChannelDeliveryResultMessage,
   isChannelStartupReportMessage,
   isChannelStartupReportType,
   isChannelWebhookEnqueueErrorCode,
-  isChannelWebhookTaskResultMessage,
+  isChannelWebhookTaskResultMessage
+} from "./chunk-U4VTUMMK.js";
+import {
+  createWorkerDiagnosticRedactor,
   normalizeWorkerDiagnostic,
   sanitizeWorkerDiagnostic
-} from "./chunk-LK7CHLVP.js";
+} from "./chunk-6MPDY6ZG.js";
 import {
   channelSelectionNames
-} from "./chunk-JLU636DO.js";
-import {
-  sanitizeLogText
-} from "./chunk-RWTEFFPU.js";
+} from "./chunk-ALMR3E6Q.js";
 import {
   CHANNEL_WORKER_KILL_GRACE_MS,
   CHANNEL_WORKER_STARTUP_TIMEOUT_MS,
   CHANNEL_WORKER_STOP_GRACE_MS
 } from "./chunk-5HBA2Z7V.js";
+import {
+  sanitizeLogText
+} from "./chunk-JCJ7LKNA.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -269,6 +278,8 @@ function createChannelWorkerSupervisor(opts) {
   let restartAttemptTimes = [];
   const pendingWebhookTasks = /* @__PURE__ */ new Map();
   const pendingChannelDeliveries = /* @__PURE__ */ new Map();
+  const pendingChannelLoopMcpMessages = /* @__PURE__ */ new Map();
+  let cleanupChannelLoopMcpRegistrations;
   let restarting;
   let disposed = false;
   const snapshotCopy = /* @__PURE__ */ __name(() => ({
@@ -365,6 +376,28 @@ function createChannelWorkerSupervisor(opts) {
     }
     return true;
   }, "settleChannelDelivery");
+  const rejectPendingChannelLoopMcpMessages = /* @__PURE__ */ __name((message) => {
+    for (const pending of pendingChannelLoopMcpMessages.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error(message));
+    }
+    pendingChannelLoopMcpMessages.clear();
+  }, "rejectPendingChannelLoopMcpMessages");
+  const settleChannelLoopMcpMessage = /* @__PURE__ */ __name((message) => {
+    if (!isChannelLoopMcpResultMessage(message)) return false;
+    const pending = pendingChannelLoopMcpMessages.get(message.id);
+    if (!pending) return true;
+    pendingChannelLoopMcpMessages.delete(message.id);
+    clearTimeout(pending.timer);
+    if (message.ok) {
+      pending.resolve(message.payload ?? {});
+    } else {
+      pending.reject(
+        new Error(message.error ?? "Channel loop MCP request failed.")
+      );
+    }
+    return true;
+  }, "settleChannelLoopMcpMessage");
   const pruneRestartAttempts = /* @__PURE__ */ __name((nowMs) => {
     restartAttemptTimes = restartAttemptTimes.filter(
       (attemptMs) => nowMs - attemptMs < restartPolicy.windowMs
@@ -527,6 +560,57 @@ function createChannelWorkerSupervisor(opts) {
     if (startedChild.pid !== void 0) {
       snapshot = { ...snapshot, pid: startedChild.pid };
     }
+    const channelLoopMcpOwnerId = `channel-worker:${randomUUID()}`;
+    const registeredChannelLoopMcpSessions = /* @__PURE__ */ new Set();
+    const activeChannelLoopMcpControls = /* @__PURE__ */ new Set();
+    const sendToStartedChild = /* @__PURE__ */ __name((message, callback) => {
+      if (child !== startedChild || !startedChild.send) {
+        throw new Error("Channel worker IPC is unavailable.");
+      }
+      return callback ? startedChild.send.call(startedChild, message, callback) : startedChild.send.call(startedChild, message);
+    }, "sendToStartedChild");
+    const sendChannelLoopMcpMessage = /* @__PURE__ */ __name((sessionId, payload) => {
+      if (pendingChannelLoopMcpMessages.size >= MAX_CHANNEL_LOOP_MCP_IN_FLIGHT) {
+        return Promise.reject(new Error("Channel loop MCP IPC queue is full."));
+      }
+      const message = createChannelLoopMcpRequest(sessionId, payload);
+      return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          pendingChannelLoopMcpMessages.delete(message.id);
+          reject(new Error("Channel loop MCP IPC timed out."));
+        }, CHANNEL_LOOP_MCP_IPC_TIMEOUT_MS);
+        timer.unref();
+        pendingChannelLoopMcpMessages.set(message.id, {
+          resolve,
+          reject,
+          timer
+        });
+        try {
+          sendToStartedChild(message, (error) => {
+            if (!error) return;
+            const pending = pendingChannelLoopMcpMessages.get(message.id);
+            if (!pending) return;
+            pendingChannelLoopMcpMessages.delete(message.id);
+            clearTimeout(pending.timer);
+            pending.reject(new Error("Channel loop MCP IPC send failed."));
+          });
+        } catch {
+          const pending = pendingChannelLoopMcpMessages.get(message.id);
+          if (!pending) return;
+          pendingChannelLoopMcpMessages.delete(message.id);
+          clearTimeout(pending.timer);
+          pending.reject(new Error("Channel loop MCP IPC send failed."));
+        }
+      });
+    }, "sendChannelLoopMcpMessage");
+    const cleanupLaunchChannelLoopMcpRegistrations = /* @__PURE__ */ __name(() => {
+      for (const sessionId of registeredChannelLoopMcpSessions) {
+        void opts.unregisterChannelLoopMcp?.(sessionId, channelLoopMcpOwnerId).catch(() => {
+        });
+      }
+      registeredChannelLoopMcpSessions.clear();
+    }, "cleanupLaunchChannelLoopMcpRegistrations");
+    cleanupChannelLoopMcpRegistrations = cleanupLaunchChannelLoopMcpRegistrations;
     await new Promise((resolve, reject) => {
       let settled = false;
       let ready = false;
@@ -723,6 +807,61 @@ function createChannelWorkerSupervisor(opts) {
         };
         armStaleHeartbeatTimer(startedChild);
       }, "handleHeartbeat");
+      const sendChannelLoopMcpControlResult = /* @__PURE__ */ __name((id, result) => {
+        try {
+          sendToStartedChild({
+            type: "channel_loop_mcp_control_result",
+            id,
+            ...result
+          });
+        } catch {
+        }
+      }, "sendChannelLoopMcpControlResult");
+      const handleChannelLoopMcpControl = /* @__PURE__ */ __name((message) => {
+        if (activeChannelLoopMcpControls.size >= MAX_CHANNEL_LOOP_MCP_IN_FLIGHT) {
+          sendChannelLoopMcpControlResult(message.id, {
+            ok: false,
+            error: "Channel loop MCP IPC queue is full."
+          });
+          return;
+        }
+        activeChannelLoopMcpControls.add(message.id);
+        const operation = message.type === "channel_loop_mcp_register" ? opts.registerChannelLoopMcp?.({
+          sessionId: message.sessionId,
+          ownerId: channelLoopMcpOwnerId,
+          sendMessage: /* @__PURE__ */ __name((payload) => sendChannelLoopMcpMessage(message.sessionId, payload), "sendMessage")
+        }).then(async () => {
+          if (child !== startedChild) {
+            await opts.unregisterChannelLoopMcp?.(
+              message.sessionId,
+              channelLoopMcpOwnerId
+            );
+            throw new Error("Channel worker exited during MCP setup.");
+          }
+          registeredChannelLoopMcpSessions.add(message.sessionId);
+        }) ?? Promise.reject(
+          new Error("Channel loop MCP registration is unavailable.")
+        ) : opts.unregisterChannelLoopMcp?.(
+          message.sessionId,
+          channelLoopMcpOwnerId
+        ).then(() => {
+          registeredChannelLoopMcpSessions.delete(message.sessionId);
+        }) ?? Promise.resolve();
+        void operation.then(() => {
+          sendChannelLoopMcpControlResult(message.id, { ok: true });
+        }).catch((error) => {
+          sendChannelLoopMcpControlResult(message.id, {
+            ok: false,
+            error: sanitizeWorkerDiagnostic(
+              error instanceof Error ? error.message : String(error),
+              512,
+              redaction
+            ) || "Channel loop MCP operation failed."
+          });
+        }).finally(() => {
+          activeChannelLoopMcpControls.delete(message.id);
+        });
+      }, "handleChannelLoopMcpControl");
       function handleMessage(message) {
         if (child !== startedChild) return;
         if (settleChannelDelivery(message)) {
@@ -731,6 +870,13 @@ function createChannelWorkerSupervisor(opts) {
         if (settleWebhookTask(message)) {
           return;
         }
+        if (settleChannelLoopMcpMessage(message)) {
+          return;
+        }
+        if (isChannelLoopMcpControlMessage(message)) {
+          handleChannelLoopMcpControl(message);
+          return;
+        }
         if (!ready && isChannelStartupReportType(message)) {
           handleStartupReport(message);
         } else if (!ready && isReadyMessage(message)) {
@@ -760,6 +906,11 @@ function createChannelWorkerSupervisor(opts) {
           "channel_worker_unavailable",
           "Channel worker exited."
         );
+        rejectPendingChannelLoopMcpMessages("Channel worker exited.");
+        cleanupLaunchChannelLoopMcpRegistrations();
+        if (cleanupChannelLoopMcpRegistrations === cleanupLaunchChannelLoopMcpRegistrations) {
+          cleanupChannelLoopMcpRegistrations = void 0;
+        }
         child = void 0;
         if ((ready || kind === "restart") && !stopping) {
           scheduleRestart();
@@ -839,6 +990,7 @@ function createChannelWorkerSupervisor(opts) {
         "channel_worker_unavailable",
         "Channel worker stopped."
       );
+      rejectPendingChannelLoopMcpMessages("Channel worker stopped.");
       if (!child || snapshot.state === "exited" || snapshot.state === "failed" && hasObservedExit(snapshot) || snapshot.state === "stopped") {
         child = void 0;
         snapshot = { ...snapshot, state: "stopped" };
@@ -887,6 +1039,9 @@ function createChannelWorkerSupervisor(opts) {
         "channel_worker_unavailable",
         "Channel worker stopped."
       );
+      rejectPendingChannelLoopMcpMessages("Channel worker stopped.");
+      cleanupChannelLoopMcpRegistrations?.();
+      cleanupChannelLoopMcpRegistrations = void 0;
       if (!child || snapshot.state === "exited" || snapshot.state === "failed" && hasObservedExit(snapshot) || snapshot.state === "stopped") {
         clearRestartTimer();
         clearStaleHeartbeatTimer();

package/chunks/{chunk-OKY7HXPG.js → chunk-FJ5WUMUQ.js}

@@ -2,13 +2,13 @@
 "use strict";
 import {
   isSupportedImageMimeType
-} from "./chunk-FODK6UMO.js";
+} from "./chunk-MPHPFVKK.js";
 import {
   TextTokenizer
 } from "./chunk-46UV252V.js";
 import {
   createDebugLogger
-} from "./chunk-NL7LTRLR.js";
+} from "./chunk-E2BHWIDT.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";