@qwen-code/qwen-code 0.20.2-jobbench-no-todo-write.0 → 0.21.0

package/chunks/{run-qwen-serve-QO4PT5NV.js → run-qwen-serve-FU6HEM4J.js}

@@ -4,6 +4,9 @@ import {
   DaemonMetricsRing,
   computeCpuPercent
 } from "./chunk-HGT6JR3U.js";
+import {
+  RUNTIME_STARTUP_CANCELLED_MESSAGE
+} from "./chunk-QUPXZXLV.js";
 import {
   ACCESS_LOG_CONTROLLER_LOCAL,
   CAPABILITIES_SCHEMA_VERSION,
@@ -32,62 +35,64 @@ import {
   require_express,
   resolveWebShellDir,
   setDeferredRuntimeRequestTiming
-} from "./chunk-NXE6SQIV.js";
+} from "./chunk-IJTOWOD7.js";
 import {
   isLoopbackBind
 } from "./chunk-RXFQM6FQ.js";
-import {
-  RUNTIME_STARTUP_CANCELLED_MESSAGE
-} from "./chunk-QUPXZXLV.js";
-import {
-  resolveChannelCwd
-} from "./chunk-6ZBPS62S.js";
 import {
   DEFAULT_COMPACTED_REPLAY_MAX_BYTES,
   normalizeCompactedReplayMaxBytes
 } from "./chunk-COH43MRJ.js";
 import {
   LOAD_REPLAY_META_KEY
-} from "./chunk-QR6U5QPP.js";
-import "./chunk-KQQ757OQ.js";
-import "./chunk-D7WXIW7H.js";
-import {
-  ChannelWebhookEnqueueError,
-  QWEN_SERVER_TOKEN_ENV
-} from "./chunk-QKTHJXCS.js";
-import {
-  channelSelectionNames
-} from "./chunk-TJTKSVIV.js";
-import "./chunk-M5GB774H.js";
+} from "./chunk-3SJ43L4W.js";
 import "./chunk-WBL3FJEU.js";
 import "./chunk-T2NCM2ET.js";
 import {
-  sanitizeLogText
-} from "./chunk-RVLZCXEE.js";
-import "./chunk-UDXSXLER.js";
+  resolveChannelCwd
+} from "./chunk-7ZCNENPP.js";
 import {
   loadServeFastPathSettings,
   preResolveServeFastPathHomeEnvOverrides
-} from "./chunk-QZJY47IE.js";
-import "./chunk-GOXKNSDZ.js";
-import "./chunk-QRUIS3DN.js";
+} from "./chunk-D3UEZIQH.js";
 import {
   MAX_REGISTERED_WORKSPACES,
   resolveWorkspaceInputs,
   workspaceRegistrationId
-} from "./chunk-AHX6AKPD.js";
+} from "./chunk-Q4M4MDQ4.js";
 import {
   canonicalizeWorkspace,
   translateAndCheckAbsoluteWorkspacePath
 } from "./chunk-2RFKHEXL.js";
+import "./chunk-UDX5OBWR.js";
+import "./chunk-5NBDS5S6.js";
+import {
+  ChannelDeliveryError,
+  ChannelWebhookEnqueueError,
+  QWEN_SERVER_TOKEN_ENV,
+  isChannelDeliveryError,
+  normalizeWorkerDiagnostic,
+  sanitizeWorkerDiagnostic
+} from "./chunk-LK7CHLVP.js";
+import {
+  channelSelectionNames
+} from "./chunk-JLU636DO.js";
+import "./chunk-BK2UNYWD.js";
+import "./chunk-M5GB774H.js";
+import {
+  sanitizeLogText
+} from "./chunk-RWTEFFPU.js";
+import "./chunk-UDXSXLER.js";
 import "./chunk-5HBA2Z7V.js";
+import "./chunk-GOXKNSDZ.js";
 import {
   getGlobalQwenDirLite,
   resolveConfigPathLite
 } from "./chunk-IDS7MSUP.js";
+import "./chunk-6PEXNQTX.js";
 import {
   getCliVersion
-} from "./chunk-3F2JUWCH.js";
+} from "./chunk-YX324OPW.js";
 import "./chunk-VJNBRRZG.js";
 import "./chunk-ALGGS7UH.js";
 import {
@@ -97,12 +102,12 @@ import {
   writeStderrLine,
   writeStdoutLine
 } from "./chunk-OWAK7LMW.js";
-import "./chunk-T4TZQJ7W.js";
-import "./chunk-H6XPXXMH.js";
 import "./chunk-5M6IDOMF.js";
+import "./chunk-TWPJO254.js";
+import "./chunk-H6XPXXMH.js";
 import {
   require_proper_lockfile
-} from "./chunk-E2UVIFI2.js";
+} from "./chunk-KRXPRVGL.js";
 import "./chunk-CR3C7WXL.js";
 import "./chunk-XWRJCPHC.js";
 import {
@@ -2018,6 +2023,89 @@ function asRecord(value) {
 }
 __name(asRecord, "asRecord");
 
+// packages/cli/src/serve/channel-delivery-authorization.ts
+init_esbuild_shims();
+function authorizationKey(workspaceCwd, sessionId, id) {
+  return JSON.stringify([workspaceCwd, sessionId, id]);
+}
+__name(authorizationKey, "authorizationKey");
+function targetsEqual(left, right) {
+  return left.channelName === right.channelName && left.type === right.type && left.id === right.id;
+}
+__name(targetsEqual, "targetsEqual");
+var ChannelDeliveryAuthorizationStore = class {
+  static {
+    __name(this, "ChannelDeliveryAuthorizationStore");
+  }
+  #prompts = /* @__PURE__ */ new Map();
+  #scheduledTasks = /* @__PURE__ */ new Map();
+  authorizePrompt(workspaceCwd, authorization) {
+    this.#prompts.set(
+      authorizationKey(
+        workspaceCwd,
+        authorization.sessionId,
+        authorization.deliveryId
+      ),
+      authorization.target
+    );
+  }
+  revokePrompt(workspaceCwd, sessionId, deliveryId) {
+    this.#prompts.delete(authorizationKey(workspaceCwd, sessionId, deliveryId));
+  }
+  registerScheduledTask(workspaceCwd, authorization) {
+    const key = authorizationKey(
+      workspaceCwd,
+      authorization.sessionId,
+      authorization.taskId
+    );
+    const current = this.#scheduledTasks.get(key);
+    this.#scheduledTasks.set(key, {
+      sessionId: authorization.sessionId,
+      taskId: authorization.taskId,
+      target: authorization.target,
+      recurring: authorization.recurring,
+      lastConsumedAt: current?.lastConsumedAt ?? authorization.lastFiredAt ?? 0
+    });
+  }
+  revokeScheduledTask(workspaceCwd, sessionId, taskId) {
+    this.#scheduledTasks.delete(
+      authorizationKey(workspaceCwd, sessionId, taskId)
+    );
+  }
+  consume(workspaceCwd, request) {
+    if (request.source === "prompt") {
+      if (request.promptId !== request.deliveryId) return false;
+      const key2 = authorizationKey(
+        workspaceCwd,
+        request.sessionId,
+        request.deliveryId
+      );
+      const target = this.#prompts.get(key2);
+      if (!target || !targetsEqual(target, request.target)) return false;
+      this.#prompts.delete(key2);
+      return true;
+    }
+    if (typeof request.taskId !== "string" || typeof request.firedAt !== "number" || request.deliveryId !== `${request.taskId}:${request.firedAt}`) {
+      return false;
+    }
+    const key = authorizationKey(
+      workspaceCwd,
+      request.sessionId,
+      request.taskId
+    );
+    const authorization = this.#scheduledTasks.get(key);
+    if (!authorization || request.firedAt <= authorization.lastConsumedAt || !targetsEqual(authorization.target, request.target)) {
+      return false;
+    }
+    if (authorization.recurring) {
+      authorization.lastConsumedAt = request.firedAt;
+    } else {
+      this.#scheduledTasks.delete(key);
+    }
+    return true;
+  }
+};
+
 // packages/cli/src/serve/channel-workspace-grouping.ts
 init_esbuild_shims();
 function resolveChannelOwnerCwd(rawCwd, workspaceCwd) {
@@ -2139,6 +2227,90 @@ var QWEN_SERVE_PROMPT_DEADLINE_MS_ENV = "QWEN_SERVE_PROMPT_DEADLINE_MS";
 var QWEN_SERVE_WRITER_IDLE_TIMEOUT_MS_ENV = "QWEN_SERVE_WRITER_IDLE_TIMEOUT_MS";
 var SHUTDOWN_FORCE_CLOSE_MS = 5e3;
 var DAEMON_LOG_FORCED_FLUSH_BUDGET_MS = 250;
+function channelDeliveryPublicError(code) {
+  switch (code) {
+    case "channel_worker_unavailable":
+      return "Channel worker is unavailable.";
+    case "channel_delivery_timeout":
+      return "Channel delivery timed out.";
+    case "channel_delivery_invalid":
+      return "Channel delivery is invalid.";
+    case "channel_delivery_rejected":
+      return "Channel delivery was rejected.";
+    case "channel_delivery_queue_full":
+      return "Channel delivery queue is full.";
+    case "channel_delivery_failed":
+      return "Channel delivery failed.";
+    default:
+      return "Channel delivery failed.";
+  }
+}
+__name(channelDeliveryPublicError, "channelDeliveryPublicError");
+function createBoundChannelDeliveryHandler(boundWorkspace, getManager, authorizations, daemonLog, diagnosticRedaction = {
+  workerEnv: {}
+}) {
+  return async (info) => {
+    const failed = /* @__PURE__ */ __name((code, error, diagnostic) => {
+      writeDaemonLifecycleBestEffort(() => {
+        if (!daemonLog) return;
+        let diagnosticText;
+        if (diagnostic !== void 0) {
+          const message = diagnostic instanceof Error ? diagnostic.message : String(diagnostic);
+          const sanitized = sanitizeWorkerDiagnostic(
+            message,
+            512,
+            diagnosticRedaction
+          );
+          const targetId = normalizeWorkerDiagnostic(info.target.id);
+          diagnosticText = sanitizeLogText(
+            targetId.length > 0 ? sanitized.replaceAll(targetId, "<redacted>") : sanitized,
+            512
+          );
+        }
+        daemonLog.warn("channel delivery failed", {
+          sessionId: info.sessionId,
+          deliveryId: info.deliveryId,
+          source: info.source,
+          channelName: info.target.channelName,
+          code,
+          ...diagnosticText ? { diagnostic: diagnosticText } : {}
+        });
+      });
+      return { status: "failed", code, error };
+    }, "failed");
+    if (!authorizations.consume(boundWorkspace, info)) {
+      return failed(
+        "channel_delivery_invalid",
+        "Channel delivery is not authorized."
+      );
+    }
+    if (info.text.trim().length === 0) {
+      return { status: "skipped" };
+    }
+    const manager = getManager();
+    if (!manager) {
+      return failed(
+        "channel_worker_unavailable",
+        "Channel worker is not running."
+      );
+    }
+    try {
+      await manager.deliverChannelMessage(boundWorkspace, {
+        deliveryId: info.deliveryId,
+        channelName: info.target.channelName,
+        target: { type: info.target.type, id: info.target.id },
+        text: info.text
+      });
+      return { status: "delivered" };
+    } catch (err) {
+      if (isChannelDeliveryError(err)) {
+        return failed(err.code, channelDeliveryPublicError(err.code), err);
+      }
+      return failed("channel_delivery_failed", "Channel delivery failed.", err);
+    }
+  };
+}
+__name(createBoundChannelDeliveryHandler, "createBoundChannelDeliveryHandler");
 async function flushDaemonLogBounded(daemonLog, budgetMs) {
   let timer;
   try {
@@ -2360,12 +2532,12 @@ __name(withSettingsLock, "withSettingsLock");
 var channelWorkerRuntimePromise;
 async function loadChannelWorkerRuntime() {
   channelWorkerRuntimePromise ??= Promise.all([
-    import("./channel-worker-supervisor-A3KVATD3.js"),
-    import("./pidfile-IWQWZNZV.js"),
-    import("./runtime-EOTXBUM6.js"),
+    import("./channel-worker-supervisor-V7KCFJTS.js"),
+    import("./pidfile-TFRZZZIO.js"),
+    import("./runtime-XXRRTNP6.js"),
     import("./cli-entry-path-4VJ3Y6T2.js"),
-    import("./channel-worker-group-LFBT7K64.js"),
-    import("./channel-worker-manager-3RUPERG2.js")
+    import("./channel-worker-group-2ZD7TVAT.js"),
+    import("./channel-worker-manager-4OA4BCGB.js")
   ]).then(
     ([
       supervisor,
@@ -2470,7 +2642,7 @@ function shouldPreheatBridge(deps) {
 __name(shouldPreheatBridge, "shouldPreheatBridge");
 var coreRuntimePromise;
 function loadCoreRuntime() {
-  coreRuntimePromise ??= import("./src-F3HKX47D.js");
+  coreRuntimePromise ??= import("./src-GE4TTTML.js");
   return coreRuntimePromise;
 }
 __name(loadCoreRuntime, "loadCoreRuntime");
@@ -2500,10 +2672,10 @@ __name(resolveDaemonLogBaseDirForRun, "resolveDaemonLogBaseDirForRun");
 var settingsRuntimePromise;
 function loadSettingsRuntimeModules() {
   settingsRuntimePromise ??= Promise.all([
-    import("./settings-QHXCJDSR.js"),
-    import("./environment-T3FXCDJI.js"),
-    import("./loadedSettingsAdapter-RLMZ4Z3E.js"),
-    import("./trustedFolders-4UEOIKOF.js")
+    import("./settings-CR2EWTBA.js"),
+    import("./environment-W5UFC2CH.js"),
+    import("./loadedSettingsAdapter-OT6JVQ7U.js"),
+    import("./trustedFolders-KHXHY6PY.js")
   ]).then(([settings, environment, loadedSettingsAdapter, trustedFolders]) => ({
     settings,
     environment,
@@ -2516,8 +2688,8 @@ __name(loadSettingsRuntimeModules, "loadSettingsRuntimeModules");
 var channelWebhookConfigRuntimePromise;
 function loadChannelWebhookConfigRuntime() {
   channelWebhookConfigRuntimePromise ??= Promise.all([
-    import("./runtime-EOTXBUM6.js"),
-    import("./config-utils-SQUBZEQM.js")
+    import("./runtime-XXRRTNP6.js"),
+    import("./config-utils-7V7GGIW6.js")
   ]).then(([channelRuntime, configUtils]) => ({
     loadChannelsConfig: channelRuntime.loadChannelsConfig,
     parseChannelWebhookConfig: configUtils.parseChannelWebhookConfig
@@ -2541,16 +2713,16 @@ async function loadServeRuntimeModules() {
     totalSessionAdmissionModule,
     workspaceRegistryModule
   ] = await Promise.all([
-    import("./server-CBCC3XQC.js"),
-    import("./bridge-AMC5AD7W.js"),
-    import("./spawnChannel-IUP3ZNMT.js"),
-    import("./workspace-service-7K3LF4QX.js"),
+    import("./server-4UMH7OIZ.js"),
+    import("./bridge-ZUB64FAE.js"),
+    import("./spawnChannel-RWNDBXGA.js"),
+    import("./workspace-service-JFWRUS4V.js"),
     import("./types-ML3TRJQ5.js"),
-    import("./daemon-status-provider-3IWTBWQ3.js"),
-    import("./workspace-providers-status-2U3IF4TX.js"),
-    import("./workspace-skills-status-4DOZ3DBS.js"),
-    import("./total-session-admission-PLONPNXI.js"),
-    import("./workspace-registry-DLQDDDIF.js")
+    import("./daemon-status-provider-2233Q37D.js"),
+    import("./workspace-providers-status-QSVZUETE.js"),
+    import("./workspace-skills-status-ZBBKJOI2.js"),
+    import("./total-session-admission-DLHHHLD3.js"),
+    import("./workspace-registry-UT4RBNBM.js")
   ]);
   return {
     createServeApp: serverModule.createServeApp,
@@ -2602,6 +2774,7 @@ function currentServeFeaturesForRunQwenServe(opts, sessionShellCommandEnabled, s
     sessionShellCommandEnabled,
     sessionArtifactsPersistenceAvailable,
     sessionGenerationAvailable: true,
+    workspaceGenerationAvailable: true,
     rateLimit: opts.rateLimit === true,
     reloadAvailable: true,
     channelReloadAvailable: opts.channelSelection !== void 0,
@@ -3196,6 +3369,7 @@ async function runQwenServe(optsIn, deps = {}) {
 __name(runQwenServe, "runQwenServe");
 async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
   const runStartedAt = performance2.now();
+  const channelDeliveryAuthorizations = new ChannelDeliveryAuthorizationStore();
   const shouldPreheat = !deps.bridge && shouldPreheatBridge(deps);
   const startup = {
     processStartedAt: new Date(
@@ -3211,6 +3385,10 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
   });
   const rawToken = optsIn.token ?? process.env[QWEN_SERVER_TOKEN_ENV];
   const token = typeof rawToken === "string" && rawToken.trim().length > 0 ? rawToken.trim() : void 0;
+  const channelDeliveryDiagnosticRedaction = {
+    workerEnv: daemonRuntimeBaseEnv,
+    ...token ? { daemonToken: token } : {}
+  };
   const sessionShellCommandEnabled = optsIn.enableSessionShell === true && token !== void 0;
   if (optsIn.enableSessionShell === true && token === void 0) {
     writeStderrLine(
@@ -3432,7 +3610,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
   }
   let workspaceRegistrationStore = deps.workspaceRegistrationStore;
   if (workspaceRegistrationStore === void 0 && process.env["QWEN_SERVE_NO_PERSISTENT_REGISTRATION"] !== "1") {
-    const { WorkspaceRegistrationStore } = await import("./workspace-registration-store-TYPYXIP6.js");
+    const { WorkspaceRegistrationStore } = await import("./workspace-registration-store-24JMHDGF.js");
     workspaceRegistrationStore = new WorkspaceRegistrationStore(boundWorkspace);
   }
   if (workspaceRegistrationStore) {
@@ -4305,7 +4483,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         );
       }
     }), "persistSettingsFn");
-    const { createSubSessionLauncher } = await import("./create-sub-session-EQG73FT6.js");
+    const { createSubSessionLauncher } = await import("./create-sub-session-QRJLW5BV.js");
     const subSessionLauncher = createSubSessionLauncher({
       getBridge: /* @__PURE__ */ __name(() => bridgeRef, "getBridge"),
       boundWorkspace
@@ -4315,6 +4493,13 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       // connection that hosts a named client MCP server (#5626).
       clientMcpSender: clientMcpSenderRegistry.lookup,
       onCreateSubSession: subSessionLauncher.launch,
+      onChannelDelivery: createBoundChannelDeliveryHandler(
+        boundWorkspace,
+        () => channelWorkerManager,
+        channelDeliveryAuthorizations,
+        daemonLog,
+        channelDeliveryDiagnosticRedaction
+      ),
       maxSessions: opts.maxSessions,
       freshSessionAdmission: totalSessionAdmission.admit,
       sessionLifecycle: sessionOwnerIndex.handleBridgeSessionLifecycle,
@@ -4549,6 +4734,13 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       const secondaryBridge = runtime.createAcpSessionBridge({
         clientMcpSender: secondaryClientMcpSenderRegistry.lookup,
         onCreateSubSession: secondarySubSessionLauncher.launch,
+        onChannelDelivery: createBoundChannelDeliveryHandler(
+          workspaceInput.cwd,
+          () => channelWorkerManager,
+          channelDeliveryAuthorizations,
+          daemonLog,
+          channelDeliveryDiagnosticRedaction
+        ),
         maxSessions: opts.maxSessions,
         freshSessionAdmission: totalSessionAdmission.admit,
         sessionLifecycle: sessionOwnerIndex.handleBridgeSessionLifecycle,
@@ -4815,6 +5007,13 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         wsBridge = runtime.createAcpSessionBridge({
           clientMcpSender: wsClientMcpRegistry.lookup,
           onCreateSubSession: wsSubSessionLauncher.launch,
+          onChannelDelivery: createBoundChannelDeliveryHandler(
+            cwd,
+            () => channelWorkerManager,
+            channelDeliveryAuthorizations,
+            daemonLog,
+            channelDeliveryDiagnosticRedaction
+          ),
           maxSessions: opts.maxSessions,
           freshSessionAdmission: totalSessionAdmission.admit,
           sessionLifecycle: sessionOwnerIndex.handleBridgeSessionLifecycle,
@@ -5117,6 +5316,19 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         }
         return channelWorkerManager.enqueueWebhookTask(task);
       }, "enqueueChannelWebhookTask"),
+      deliverChannelMessage: /* @__PURE__ */ __name(async (workspaceCwd, request) => {
+        if (!channelWorkerManager) {
+          throw new ChannelDeliveryError(
+            "channel_worker_unavailable",
+            "Channel worker is not running."
+          );
+        }
+        return channelWorkerManager.deliverChannelMessage(
+          workspaceCwd,
+          request
+        );
+      }, "deliverChannelMessage"),
+      channelDeliveryAuthorizations,
       reloadChannelWorker,
       getPerfSnapshot: /* @__PURE__ */ __name(() => ({
         eventLoop: currentDaemonEventLoopMonitor.snapshot(),
@@ -5308,7 +5520,8 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
     reserveChannelServicePidfile(opts.channelSelection);
   }
   return await new Promise((resolve, reject) => {
-    const onListening = /* @__PURE__ */ __name(() => {
+    const onListening = /* @__PURE__ */ __name((error) => {
+      if (error) return;
       startup.listenerReadyAt = (/* @__PURE__ */ new Date()).toISOString();
       startup.processToListenMs = Math.round(process.uptime() * 1e3);
       startup.runQwenServeToListenMs = Math.round(
@@ -5328,7 +5541,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         channelWorkspaceGroups = resolveChannelWorkspaceGroupsAtListen();
       } catch (err) {
         removeCurrentServePidfile();
-        const error = err instanceof Error ? err : new Error(String(err));
+        const error2 = err instanceof Error ? err : new Error(String(err));
         server.close((closeErr) => {
           if (closeErr) {
             daemonLog.error(
@@ -5336,7 +5549,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
               closeErr
             );
           }
-          reject(error);
+          reject(error2);
         });
         return;
       }
@@ -5406,9 +5619,9 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
           "deferred runtime: cancelled, server closed before startup"
         );
         runtimeStartupSettled = true;
-        const error = new Error(RUNTIME_STARTUP_CANCELLED_MESSAGE);
-        runtimeStartupError = error.message;
-        markRuntimeFailed(error);
+        const error2 = new Error(RUNTIME_STARTUP_CANCELLED_MESSAGE);
+        runtimeStartupError = error2.message;
+        markRuntimeFailed(error2);
       }, "cancelDeferredRuntimeStartup");
       const shutdownBridgeAfterFailedStartup = /* @__PURE__ */ __name(async (bridge) => {
         if (!bridge || deps.bridge) return;
@@ -5441,7 +5654,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         }
       }, "stopChannelWorkerAfterFailedStartup");
       const failRuntimeStartup = /* @__PURE__ */ __name(async (err, bridgeForCleanup) => {
-        const error = err instanceof Error ? err : new Error(String(err));
+        const error2 = err instanceof Error ? err : new Error(String(err));
         if (runtimeStartupSettled) {
           disposeRuntimeAppResources(runtimeApp ?? runtimeAppForCleanup);
           await shutdownBridgeAfterFailedStartup(bridgeForCleanup);
@@ -5451,15 +5664,15 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         disposeRuntimeAppResources(runtimeApp ?? runtimeAppForCleanup);
         runtimeApp = void 0;
         clearRuntimeStartupTimer();
-        const message = error.message;
+        const message = error2.message;
         runtimeStartupError = message;
         if (startup.preheat.status === "scheduled" || startup.preheat.status === "running") {
           startup.preheat.status = "failed";
           startup.preheat.error = message;
         }
         writeStderrLine(`qwen serve: runtime startup failed: ${message}`);
-        daemonLog.error("runtime startup failed", error);
-        markRuntimeFailed(error);
+        daemonLog.error("runtime startup failed", error2);
+        markRuntimeFailed(error2);
         if (closeServerAfterChannelWorkerStartupFailure && server.listening) {
           runtimeFailureListenerClose = new Promise((resolve2) => {
             server.close((closeErr) => {
@@ -6051,6 +6264,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
 __name(runQwenServeImpl, "runQwenServeImpl");
 export {
   InvalidPolicyConfigError,
+  createBoundChannelDeliveryHandler,
   createDisabledChannelWorkerSupervisor,
   createLazyBridgeProxy,
   extractContextFilename,