@qwen-code/qwen-code 0.19.10 → 0.19.11-nightly.20260717.f8e6e8931

package/chunks/{chunk-EQY6POVO.js → chunk-GLEJW7T2.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   isGitRepository
-} from "./chunk-K7CRWKOE.js";
+} from "./chunk-R6AO7HBQ.js";
 import {
   createDebugLogger
 } from "./chunk-7NFB7LBQ.js";

package/chunks/{chunk-FXMC7SL2.js → chunk-I6NOSIVF.js}

@@ -5,7 +5,7 @@ import {
   isTranscribableVoiceModel,
   readVoiceLanguage,
   resolveVoiceTransport
-} from "./chunk-DPFBNG72.js";
+} from "./chunk-4UBEB74N.js";
 import {
   resolvePath
 } from "./chunk-FSA7ERJ2.js";

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

@@ -3,16 +3,16 @@
 import {
   settleChatRecording,
   subscribeToHeadlessChatRecordingFailures
-} from "./chunk-CJFNEBYB.js";
+} from "./chunk-VFEZWI6F.js";
+import {
+  handleAtCommand
+} from "./chunk-XQDPCQ3A.js";
 import {
   JsonOutputAdapter
-} from "./chunk-F7NXQH4Y.js";
+} from "./chunk-IIXEI2VE.js";
 import {
   StreamJsonOutputAdapter
-} from "./chunk-LTNI523B.js";
-import {
-  handleAtCommand
-} from "./chunk-X362TMXZ.js";
+} from "./chunk-T7CZYIAU.js";
 import {
   buildInitialSystemReminders,
   buildSystemMessage,
@@ -24,10 +24,10 @@ import {
   insertAfterFunctionResponses,
   isSlashCommand,
   normalizePartList
-} from "./chunk-YX4LLZ3D.js";
+} from "./chunk-NABT4VOY.js";
 import {
   RunBudgetEnforcer
-} from "./chunk-CEW4HDPK.js";
+} from "./chunk-ZK4AMPKI.js";
 import {
   AlreadyReportedError,
   handleBudgetExceededError,
@@ -35,31 +35,35 @@ import {
   handleError,
   handleMaxTurnsExceededError,
   handleToolError
-} from "./chunk-65N2J6V2.js";
+} from "./chunk-6ANLV27M.js";
 import {
   isInlineModelOverrideAllowed
-} from "./chunk-GGJII3FM.js";
+} from "./chunk-WZJELXEU.js";
 import {
   buildSessionRecoveryPlanFromApiHistory,
+  canonicalToolName,
   createDuplicateProviderToolCallResponse,
   detectAutonomousSentinel,
   detectLoopSentinel,
   executeToolCall,
   findRepeatedDuplicateProviderToolCall,
   isSystemReminderContent,
+  isToolCallConcurrencySafe,
   markDuplicateProviderToolCallResponseSent,
   parseAndFormatApiError,
+  parsePositiveIntegerEnv,
+  partitionByConcurrencySafety,
   promptIdContext,
   restoreWorktreeContext
-} from "./chunk-K7CRWKOE.js";
+} from "./chunk-R6AO7HBQ.js";
 import {
   isTelemetrySdkInitialized,
   shutdownTelemetry,
   uiTelemetryService
-} from "./chunk-P6LART6G.js";
+} from "./chunk-BTSE2DUP.js";
 import {
   ToolNames
-} from "./chunk-2UUAIFQO.js";
+} from "./chunk-JGUT3LWZ.js";
 import {
   FatalInputError,
   createDebugLogger
@@ -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-F7NXQH4Y.js → chunk-IIXEI2VE.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   BaseJsonOutputAdapter
-} from "./chunk-LTNI523B.js";
+} from "./chunk-T7CZYIAU.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-2UUAIFQO.js → chunk-JGUT3LWZ.js}

@@ -15562,6 +15562,10 @@ function hasCycleInSchema(schema) {
   return traverse(schema, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set());
 }
 __name(hasCycleInSchema, "hasCycleInSchema");
+function isShellProgressData(display) {
+  return typeof display === "object" && display !== null && "type" in display && display.type === "shell_progress";
+}
+__name(isShellProgressData, "isShellProgressData");
 var ToolConfirmationOutcome = /* @__PURE__ */ ((ToolConfirmationOutcome2) => {
   ToolConfirmationOutcome2["ProceedOnce"] = "proceed_once";
   ToolConfirmationOutcome2["ProceedAlways"] = "proceed_always";
@@ -15723,6 +15727,7 @@ export {
   BaseDeclarativeTool,
   isTool,
   hasCycleInSchema,
+  isShellProgressData,
   ToolConfirmationOutcome,
   Kind,
   MUTATOR_KINDS,

package/chunks/{chunk-5EBKKSBX.js → chunk-JY74T7PW.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-QRUIS3DN.js";
 import {
   isWorkspaceTrusted
-} from "./chunk-4YWLED2A.js";
+} from "./chunk-PNCWEDF6.js";
 import {
   require_main
 } from "./chunk-5M6IDOMF.js";

package/chunks/chunk-KSZKSE23.js

@@ -0,0 +1,226 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  redactLogCredentials
+} from "./chunk-M5GB774H.js";
+import {
+  sanitizeLogText
+} from "./chunk-ZQIYGQCG.js";
+import {
+  stripAnsi
+} from "./chunk-T4TZQJ7W.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/serve/channel-worker-env.ts
+init_esbuild_shims();
+var CHANNEL_DAEMON_WORKER_SENTINEL = "QWEN_CHANNEL_DAEMON_WORKER";
+var CHANNEL_WORKER_HEARTBEAT_INTERVAL_MS = 15e3;
+var QWEN_DAEMON_TOKEN_ENV = "QWEN_DAEMON_TOKEN";
+var QWEN_DAEMON_URL_ENV = "QWEN_DAEMON_URL";
+var QWEN_DAEMON_WORKSPACE_ENV = "QWEN_DAEMON_WORKSPACE";
+var QWEN_SERVER_TOKEN_ENV = "QWEN_SERVER_TOKEN";
+
+// packages/cli/src/serve/channel-webhook-ipc.ts
+init_esbuild_shims();
+import { randomUUID } from "node:crypto";
+var CHANNEL_WEBHOOK_ENQUEUE_ERROR_CODES = /* @__PURE__ */ new Set([
+  "channel_worker_unavailable",
+  "channel_webhook_enqueue_timeout",
+  "channel_webhook_queue_full",
+  "channel_webhook_target_unavailable",
+  "channel_webhook_invalid_task",
+  "channel_webhook_enqueue_failed"
+]);
+var ChannelWebhookEnqueueError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "ChannelWebhookEnqueueError";
+  }
+  static {
+    __name(this, "ChannelWebhookEnqueueError");
+  }
+};
+function isChannelWebhookEnqueueErrorCode(value) {
+  return typeof value === "string" && CHANNEL_WEBHOOK_ENQUEUE_ERROR_CODES.has(value);
+}
+__name(isChannelWebhookEnqueueErrorCode, "isChannelWebhookEnqueueErrorCode");
+function isChannelWebhookEnqueueError(value) {
+  return value instanceof ChannelWebhookEnqueueError || typeof value === "object" && value !== null && isChannelWebhookEnqueueErrorCode(value.code) && typeof value.message === "string";
+}
+__name(isChannelWebhookEnqueueError, "isChannelWebhookEnqueueError");
+var CHANNEL_WEBHOOK_TASK_IPC_TIMEOUT_MS = 3e4;
+function createChannelWebhookTaskMessage(task) {
+  return {
+    type: "webhook_task",
+    id: randomUUID(),
+    expiresAt: Date.now() + CHANNEL_WEBHOOK_TASK_IPC_TIMEOUT_MS,
+    task
+  };
+}
+__name(createChannelWebhookTaskMessage, "createChannelWebhookTaskMessage");
+function isChannelWebhookTaskMessage(value) {
+  return typeof value === "object" && value !== null && value.type === "webhook_task" && typeof value.id === "string" && typeof value.expiresAt === "number" && typeof value.task === "object" && value.task !== null;
+}
+__name(isChannelWebhookTaskMessage, "isChannelWebhookTaskMessage");
+function isChannelWebhookTaskResultMessage(value) {
+  return typeof value === "object" && value !== null && value.type === "webhook_task_result" && typeof value.id === "string" && typeof value.ok === "boolean";
+}
+__name(isChannelWebhookTaskResultMessage, "isChannelWebhookTaskResultMessage");
+
+// packages/cli/src/serve/channel-worker-diagnostics.ts
+init_esbuild_shims();
+var WORKER_LOG_INVISIBLE_RE = new RegExp("[\\p{Cf}\\u2028\\u2029]|\\p{Variation_Selector}", "gu");
+var WORKER_LOG_CONTROL_RE = /[\x00-\x1f\x7f-\x9f]/g;
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+__name(escapeRegExp, "escapeRegExp");
+function sensitiveEnvValues(env) {
+  const sensitiveKey = /(^|_)(TOKEN|SECRET|API_KEY|ACCESS_KEY|PRIVATE_KEY|CREDENTIAL|PASSWORD|PASSWD|PASSPHRASE|BASIC_AUTH|AUTH_TOKEN|AUTHORIZATION|SESSION_SECRET|SESSION_TOKEN|SESSION_KEY|SESSION_COOKIE|DSN|CONNECTION_STRING)($|_)/i;
+  return Object.entries(env).filter(([key, value]) => sensitiveKey.test(key) && value !== void 0).flatMap(([, value]) => {
+    const lines = value.split("\n").filter((line) => line.length >= 4);
+    return lines.length > 0 ? [value, ...lines] : [value];
+  }).filter((value) => value.length >= 4);
+}
+__name(sensitiveEnvValues, "sensitiveEnvValues");
+function normalizeWorkerDiagnostic(value) {
+  return stripAnsi(value).replace(WORKER_LOG_INVISIBLE_RE, "").replace(WORKER_LOG_CONTROL_RE, "");
+}
+__name(normalizeWorkerDiagnostic, "normalizeWorkerDiagnostic");
+function createWorkerDiagnosticRedactor(opts) {
+  const secretPatterns = [
+    ...new Set(
+      [
+        ...opts.daemonToken ? [opts.daemonToken] : [],
+        ...sensitiveEnvValues(opts.workerEnv)
+      ].flatMap((secret) => [
+        normalizeWorkerDiagnostic(secret),
+        normalizeWorkerDiagnostic(secret.replace(/\t/gu, " "))
+      ]).filter((secret) => secret.length >= 4)
+    )
+  ].sort((left, right) => right.length - left.length).map((secret) => new RegExp(escapeRegExp(secret), "g"));
+  return (value) => {
+    let redacted = value;
+    for (const secretPattern of secretPatterns) {
+      redacted = redacted.replace(secretPattern, "<redacted>");
+    }
+    return redactLogCredentials(redacted);
+  };
+}
+__name(createWorkerDiagnosticRedactor, "createWorkerDiagnosticRedactor");
+function sanitizeWorkerDiagnostic(value, maxLength, opts) {
+  const normalized = normalizeWorkerDiagnostic(value);
+  const redacted = createWorkerDiagnosticRedactor(opts)(normalized);
+  return sanitizeLogText(redacted, maxLength);
+}
+__name(sanitizeWorkerDiagnostic, "sanitizeWorkerDiagnostic");
+
+// packages/cli/src/serve/channel-worker-startup-ipc.ts
+init_esbuild_shims();
+var MAX_CHANNEL_STARTUP_FAILURES = 64;
+var MAX_CHANNEL_STARTUP_FAILURE_CHANNEL_LENGTH = 128;
+var MAX_CHANNEL_STARTUP_FAILURE_CODE_LENGTH = 64;
+var MAX_CHANNEL_STARTUP_FAILURE_MESSAGE_LENGTH = 512;
+function isBoundedNonEmptyString(value, maxLength) {
+  if (typeof value !== "string" || value.length === 0) return false;
+  let length = 0;
+  for (const _codePoint of value) {
+    length += 1;
+    if (length > maxLength) return false;
+  }
+  return true;
+}
+__name(isBoundedNonEmptyString, "isBoundedNonEmptyString");
+function isChannelStartupFailure(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  try {
+    const failure = value;
+    return isBoundedNonEmptyString(
+      failure["channel"],
+      MAX_CHANNEL_STARTUP_FAILURE_CHANNEL_LENGTH
+    ) && failure["phase"] === "connect" && (failure["code"] === void 0 || isBoundedNonEmptyString(
+      failure["code"],
+      MAX_CHANNEL_STARTUP_FAILURE_CODE_LENGTH
+    )) && isBoundedNonEmptyString(
+      failure["message"],
+      MAX_CHANNEL_STARTUP_FAILURE_MESSAGE_LENGTH
+    );
+  } catch {
+    return false;
+  }
+}
+__name(isChannelStartupFailure, "isChannelStartupFailure");
+function isChannelStartupReportMessage(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  try {
+    const message = value;
+    if (message["type"] === "channel_startup_failures_truncated") {
+      return true;
+    }
+    return message["type"] === "channel_startup_failure" && isChannelStartupFailure(message["failure"]);
+  } catch {
+    return false;
+  }
+}
+__name(isChannelStartupReportMessage, "isChannelStartupReportMessage");
+function isChannelStartupReportAckMessage(value) {
+  try {
+    return typeof value === "object" && value !== null && !Array.isArray(value) && value.type === "channel_startup_report_ack";
+  } catch {
+    return false;
+  }
+}
+__name(isChannelStartupReportAckMessage, "isChannelStartupReportAckMessage");
+function isChannelStartupReportType(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  try {
+    const type = value.type;
+    return type === "channel_startup_failure" || type === "channel_startup_failures_truncated";
+  } catch {
+    return false;
+  }
+}
+__name(isChannelStartupReportType, "isChannelStartupReportType");
+
+export {
+  CHANNEL_DAEMON_WORKER_SENTINEL,
+  CHANNEL_WORKER_HEARTBEAT_INTERVAL_MS,
+  QWEN_DAEMON_TOKEN_ENV,
+  QWEN_DAEMON_URL_ENV,
+  QWEN_DAEMON_WORKSPACE_ENV,
+  QWEN_SERVER_TOKEN_ENV,
+  ChannelWebhookEnqueueError,
+  isChannelWebhookEnqueueErrorCode,
+  isChannelWebhookEnqueueError,
+  CHANNEL_WEBHOOK_TASK_IPC_TIMEOUT_MS,
+  createChannelWebhookTaskMessage,
+  isChannelWebhookTaskMessage,
+  isChannelWebhookTaskResultMessage,
+  normalizeWorkerDiagnostic,
+  createWorkerDiagnosticRedactor,
+  sanitizeWorkerDiagnostic,
+  MAX_CHANNEL_STARTUP_FAILURES,
+  MAX_CHANNEL_STARTUP_FAILURE_CHANNEL_LENGTH,
+  MAX_CHANNEL_STARTUP_FAILURE_CODE_LENGTH,
+  MAX_CHANNEL_STARTUP_FAILURE_MESSAGE_LENGTH,
+  isChannelStartupReportMessage,
+  isChannelStartupReportAckMessage,
+  isChannelStartupReportType
+};
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-MO7O5722.js → chunk-KW46DBFM.js}

@@ -16213,6 +16213,13 @@ var PathMutexRegistry = class {
   }
 };
 
+// packages/cli/src/serve/health-query.ts
+init_esbuild_shims();
+function isDeepHealthQuery(raw) {
+  return raw === "1" || raw === "true" || raw === "";
+}
+__name(isDeepHealthQuery, "isDeepHealthQuery");
+
 // packages/cli/src/serve/web-shell-resolver.ts
 init_esbuild_shims();
 import { existsSync } from "node:fs";
@@ -16528,6 +16535,7 @@ var SERVE_CAPABILITY_REGISTRY = {
   // the underlying ACP method from unstable_resumeSession to resumeSession.
   unstable_session_resume: { since: "v1" },
   session_list: { since: "v1" },
+  session_source_metadata: { since: "v1" },
   session_prompt: { since: "v1" },
   session_cancel: { since: "v1" },
   session_events: { since: "v1" },
@@ -16676,6 +16684,9 @@ var SERVE_CAPABILITY_REGISTRY = {
   // may be `null` for too-short histories or transient model failures
   // (best-effort, never throws). SDK helper: `DaemonClient.recapSession`.
   session_recap: { since: "v1" },
+  // `POST /session/:id/generate` streams a stateless, tool-free model call.
+  // The ACP child prefers fastModel and falls back to the main session model.
+  session_generation: { since: "v1" },
   // Side question (/btw) against the session's conversation context.
   // Single-turn, tool-free LLM call via runForkedAgent (cache path).
   session_btw: { since: "v1" },
@@ -16758,8 +16769,8 @@ var SERVE_CAPABILITY_REGISTRY = {
   // Runtime GET/PUT/DELETE control for daemon-managed channel selection.
   // The route exists even when no selection was supplied at daemon boot.
   channel_control: { since: "v1" },
-  // Multi-workspace sessions closed loop (issue #6378 Phase 2a). Advertised
-  // only when one daemon hosts more than one registered workspace runtime.
+  // Multi-workspace session routing. Advertised only when one daemon hosts
+  // more than one registered workspace runtime.
   multi_workspace_sessions: { since: "v1" },
   // Singular session rewind routes resolve the owning live workspace runtime.
   multi_workspace_session_rewind: { since: "v1" },
@@ -16793,6 +16804,10 @@ var SERVE_CAPABILITY_REGISTRY = {
   // This is separate from `session_export` so clients do not infer the plural
   // route from the legacy primary-workspace export capability.
   workspace_session_export: { since: "v1" },
+  // Workspace-qualified full session export from archived persisted storage.
+  // This remains independent from active export so older daemons cannot ignore
+  // archive intent and return an active transcript with the same session id.
+  workspace_archived_session_export: { since: "v1" },
   // Workspace-qualified ACP transport (issue #6378 Phase 4):
   // `/workspaces/:workspace/acp` mounts a per-runtime ACP dispatcher (HTTP +
   // WebSocket) for each registered workspace, with per-runtime device-flow and
@@ -16859,6 +16874,10 @@ var CONDITIONAL_SERVE_FEATURES = /* @__PURE__ */ new Map([
     "session_artifacts_persistence",
     (toggles) => toggles.sessionArtifactsPersistenceAvailable === true
   ],
+  [
+    "session_generation",
+    (toggles) => toggles.sessionGenerationAvailable === true
+  ],
   ["rate_limit", (toggles) => toggles.rateLimit === true],
   ["workspace_reload", (toggles) => toggles.reloadAvailable === true],
   ["channel_reload", (toggles) => toggles.channelReloadAvailable === true],
@@ -16972,6 +16991,17 @@ var MAX_SKILL_NAME_LENGTH = 256;
 var MAX_SERVER_NAME_LENGTH = 256;
 var CLIENT_ID_RE = /^[A-Za-z0-9._:-]+$/;
 var INVALID_PERMISSION_OUTCOME_ERROR = '`outcome` must be `{ outcome: "cancelled" }` or `{ outcome: "selected", optionId: string }`';
+var deferredRuntimeTimingKey = Symbol(
+  "deferredRuntimeRequestTiming"
+);
+function setDeferredRuntimeRequestTiming(req, timing) {
+  req[deferredRuntimeTimingKey] = timing;
+}
+__name(setDeferredRuntimeRequestTiming, "setDeferredRuntimeRequestTiming");
+function getDeferredRuntimeRequestTiming(req) {
+  return req[deferredRuntimeTimingKey];
+}
+__name(getDeferredRuntimeRequestTiming, "getDeferredRuntimeRequestTiming");
 function safeBody(req) {
   const raw = req.body;
   if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
@@ -18222,6 +18252,7 @@ export {
   DeviceFlowRegistry,
   createBridgeFileSystemAdapter,
   PathMutexRegistry,
+  isDeepHealthQuery,
   resolveWebShellDir,
   denyBrowserOriginCors,
   parseAllowOriginPatterns,
@@ -18242,6 +18273,8 @@ export {
   MAX_SKILL_NAME_LENGTH,
   MAX_SERVER_NAME_LENGTH,
   CLIENT_ID_RE,
+  setDeferredRuntimeRequestTiming,
+  getDeferredRuntimeRequestTiming,
   safeBody,
   parseOptionalWorkspaceCwd,
   requireSessionId,

package/chunks/{chunk-TISZXPAX.js → chunk-L263ROM6.js}

@@ -60,7 +60,7 @@ async function runExitCleanup(options = {}) {
 }
 __name(runExitCleanup, "runExitCleanup");
 async function cleanupCheckpoints() {
-  const { Storage } = await import("./src-USZKPUOC.js");
+  const { Storage } = await import("./src-6OJFUPTL.js");
   const storage = new Storage(process.cwd());
   const tempDir = storage.getProjectTempDir();
   const checkpointsDir = join(tempDir, "checkpoints");

package/chunks/chunk-LXXMOYPL.js

@@ -0,0 +1,22 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+
+// packages/acp-bridge/src/index.ts
+init_esbuild_shims();
+
+// packages/acp-bridge/src/inMemoryChannel.ts
+init_esbuild_shims();
+
+// packages/acp-bridge/src/channel.ts
+init_esbuild_shims();
+
+// packages/acp-bridge/src/bridgeFileSystem.ts
+init_esbuild_shims();
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */