@qwen-code/qwen-code 0.20.0 → 0.20.1-nightly.20260724.7d17c44a3

package/chunks/{chunk-4EP2PYYL.js → chunk-2G6QIHYL.js}

@@ -2,14 +2,14 @@
 "use strict";
 import {
   functionResponsePartsToString
-} from "./chunk-PBWEWI4N.js";
+} from "./chunk-BW5Z5NOG.js";
 import {
   parseAndFormatApiError
-} from "./chunk-KX6UK4VJ.js";
+} from "./chunk-LI4I37W4.js";
 import {
   formatVisionBridgeNoticeDisplay,
   isVisionBridgeNoticeDisplay
-} from "./chunk-ZFKNWQGQ.js";
+} from "./chunk-IFG6TYJ2.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -742,7 +742,7 @@ ${event.value}`, null);
    * Emits a `can_use_tool` permission control_request so an external consumer
    * can approve or deny the tool call. Pairs with {@link emitControlResponse}.
    */
-  emitPermissionRequest(requestId, toolName, toolUseId, input, blockedPath = null) {
+  emitPermissionRequest(requestId, toolName, toolUseId, input, blockedPath = null, permissionSuggestions = null) {
     const message = {
       type: "control_request",
       request_id: requestId,
@@ -751,7 +751,7 @@ ${event.value}`, null);
         tool_name: toolName,
         tool_use_id: toolUseId,
         input,
-        permission_suggestions: null,
+        permission_suggestions: permissionSuggestions,
         blocked_path: blockedPath
       }
     };

package/chunks/{chunk-H2XVO6NE.js → chunk-2MIN6GRR.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-QHTIBUWB.js";
 import {
   stripAnsi
-} from "./chunk-T4TZQJ7W.js";
+} from "./chunk-TWPJO254.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/chunk-2RFKHEXL.js

@@ -0,0 +1,74 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/acp-bridge/src/workspacePaths.ts
+init_esbuild_shims();
+import { existsSync, realpathSync } from "node:fs";
+import * as path from "node:path";
+var WINDOWS_ABSOLUTE_PATH_RE = /^([A-Za-z]):[\\/](.*)$/;
+var sandboxMountExistsOverrideForTest;
+function translateWindowsWorkspaceForPosixSandbox(p, opts = {}) {
+  const platform = opts.platform ?? process.platform;
+  const sandboxEnv = "sandboxEnv" in opts ? opts.sandboxEnv : process.env["SANDBOX"];
+  const exists = opts.exists ?? sandboxMountExistsOverrideForTest ?? existsSync;
+  if (platform === "win32" || !sandboxEnv || sandboxEnv === "sandbox-exec") {
+    return p;
+  }
+  const match = WINDOWS_ABSOLUTE_PATH_RE.exec(p);
+  if (!match) return p;
+  const translated = `/${match[1].toLowerCase()}/${match[2].replace(/\\/g, "/")}`;
+  const resolvedTranslated = path.resolve(translated);
+  if (resolvedTranslated !== `/${match[1].toLowerCase()}` && !resolvedTranslated.startsWith(`/${match[1].toLowerCase()}/`)) {
+    return p;
+  }
+  return exists(resolvedTranslated) ? translated : p;
+}
+__name(translateWindowsWorkspaceForPosixSandbox, "translateWindowsWorkspaceForPosixSandbox");
+function translateAndCheckAbsoluteWorkspacePath(raw) {
+  const translated = translateWindowsWorkspaceForPosixSandbox(raw);
+  return path.isAbsolute(translated) ? translated : null;
+}
+__name(translateAndCheckAbsoluteWorkspacePath, "translateAndCheckAbsoluteWorkspacePath");
+function canonicalizeWorkspace(p) {
+  const resolved = path.resolve(translateWindowsWorkspaceForPosixSandbox(p));
+  try {
+    return realpathSync.native(resolved);
+  } catch (err) {
+    if (err && typeof err === "object" && err.code === "ENOENT") {
+      return resolved;
+    }
+    throw err;
+  }
+}
+__name(canonicalizeWorkspace, "canonicalizeWorkspace");
+function canonicalizeWorkspaces(paths) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const p of paths) {
+    const canonical = canonicalizeWorkspace(p);
+    if (seen.has(canonical)) continue;
+    seen.add(canonical);
+    out.push(canonical);
+  }
+  return out;
+}
+__name(canonicalizeWorkspaces, "canonicalizeWorkspaces");
+var MAX_WORKSPACE_PATH_LENGTH = 4096;
+
+export {
+  translateAndCheckAbsoluteWorkspacePath,
+  canonicalizeWorkspace,
+  canonicalizeWorkspaces,
+  MAX_WORKSPACE_PATH_LENGTH
+};
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-7SXZC7ID.js → chunk-2WTVWAKT.js}

@@ -2,13 +2,13 @@
 "use strict";
 import {
   loadSettings
-} from "./chunk-33XUAINQ.js";
+} from "./chunk-J5UKQEFG.js";
 import {
   getCurrentLanguage
-} from "./chunk-TKLLK6XQ.js";
+} from "./chunk-ZT4POVWC.js";
 import {
   isWorkspaceTrusted
-} from "./chunk-I2PYAYFM.js";
+} from "./chunk-CXUFILV3.js";
 import {
   require_strip_json_comments
 } from "./chunk-ALGGS7UH.js";
@@ -26,14 +26,14 @@ import {
   hashMcpServerConfig,
   isGatedMcpScope,
   normalizeClaudeMcpServer
-} from "./chunk-KX6UK4VJ.js";
+} from "./chunk-LI4I37W4.js";
 import {
   atomicWriteFile
-} from "./chunk-BDBMYST4.js";
+} from "./chunk-6X4GWOPW.js";
 import {
   Storage,
   getErrorMessage
-} from "./chunk-C27BYUX6.js";
+} from "./chunk-OQB4EXO4.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -724,6 +724,7 @@ async function createMinimalConfig() {
     targetDir: cwd,
     cwd,
     debugMode: false,
+    chatRecording: false,
     mcpServers,
     pendingMcpServers: getPendingGatedMcpServers(mcpServers, cwd),
     fileDiscoveryService: fileService,

package/chunks/{chunk-TIH2ZTOC.js → chunk-32A4PI3E.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-QRUIS3DN.js";
 import {
   isWorkspaceTrusted
-} from "./chunk-I2PYAYFM.js";
+} from "./chunk-CXUFILV3.js";
 import {
   require_main
 } from "./chunk-5M6IDOMF.js";
@@ -15,7 +15,7 @@ import {
   QWEN_DIR,
   Storage,
   getErrorMessage
-} from "./chunk-C27BYUX6.js";
+} from "./chunk-OQB4EXO4.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/chunk-36HSVBBU.js

@@ -0,0 +1,469 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  preloadRuntimeFetchModule
+} from "./chunk-NBQDBANR.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/config/models.ts
+init_esbuild_shims();
+var DEFAULT_QWEN_MODEL = "coder-model";
+var DEFAULT_QWEN_FLASH_MODEL = "coder-model";
+var DEFAULT_QWEN_EMBEDDING_MODEL = "text-embedding-v4";
+var MAINLINE_CODER_MODEL = "qwen3.7-max";
+
+// packages/core/src/models/constants.ts
+init_esbuild_shims();
+var MODEL_GENERATION_CONFIG_FIELDS = [
+  "samplingParams",
+  "timeout",
+  "maxRetries",
+  "retryErrorCodes",
+  "enableCacheControl",
+  "forceGlobalCacheScope",
+  "schemaCompliance",
+  "reasoning",
+  "contextWindowSize",
+  "customHeaders",
+  "extra_body",
+  "thinkingMandatory",
+  "modalities",
+  "splitToolMedia",
+  "toolResultContentFormat"
+];
+var CREDENTIAL_FIELDS = [
+  "model",
+  "apiKey",
+  "apiKeyEnvKey",
+  "baseUrl"
+];
+var PROVIDER_SOURCED_FIELDS = [
+  ...CREDENTIAL_FIELDS,
+  ...MODEL_GENERATION_CONFIG_FIELDS
+];
+var AUTH_ENV_MAPPINGS = {
+  openai: {
+    apiKey: ["OPENAI_API_KEY"],
+    baseUrl: ["OPENAI_BASE_URL"],
+    model: ["OPENAI_MODEL", "QWEN_MODEL"]
+  },
+  anthropic: {
+    apiKey: ["ANTHROPIC_API_KEY"],
+    baseUrl: ["ANTHROPIC_BASE_URL"],
+    model: ["ANTHROPIC_MODEL"]
+  },
+  gemini: {
+    apiKey: ["GEMINI_API_KEY"],
+    baseUrl: [],
+    model: ["GEMINI_MODEL"]
+  },
+  "vertex-ai": {
+    apiKey: ["GOOGLE_API_KEY"],
+    baseUrl: [],
+    model: ["GOOGLE_MODEL"]
+  },
+  "qwen-oauth": {
+    apiKey: [],
+    baseUrl: [],
+    model: []
+  }
+};
+var DEFAULT_MODELS = {
+  openai: MAINLINE_CODER_MODEL,
+  "qwen-oauth": DEFAULT_QWEN_MODEL
+};
+var QWEN_OAUTH_MODELS = [
+  {
+    id: "coder-model",
+    name: "coder-model",
+    description: "Qwen 3.7 Max \u2014 efficient hybrid model with leading coding performance",
+    capabilities: { vision: true }
+  }
+];
+var QWEN_OAUTH_ALLOWED_MODELS = QWEN_OAUTH_MODELS.map(
+  (model) => model.id
+);
+
+// packages/core/src/core/contentGenerator.ts
+init_esbuild_shims();
+
+// packages/core/src/models/modelConfigErrors.ts
+init_esbuild_shims();
+function getDefaultApiKeyEnvVar(authType) {
+  switch (authType) {
+    case "openai":
+      return "OPENAI_API_KEY";
+    case "anthropic":
+      return "ANTHROPIC_API_KEY";
+    case "gemini":
+      return "GEMINI_API_KEY";
+    case "vertex-ai":
+      return "GOOGLE_API_KEY";
+    default:
+      return "API_KEY";
+  }
+}
+__name(getDefaultApiKeyEnvVar, "getDefaultApiKeyEnvVar");
+function getDefaultModelEnvVar(authType) {
+  switch (authType) {
+    case "openai":
+      return "OPENAI_MODEL";
+    case "anthropic":
+      return "ANTHROPIC_MODEL";
+    case "gemini":
+      return "GEMINI_MODEL";
+    case "vertex-ai":
+      return "GOOGLE_MODEL";
+    default:
+      return "MODEL";
+  }
+}
+__name(getDefaultModelEnvVar, "getDefaultModelEnvVar");
+var ModelConfigError = class extends Error {
+  static {
+    __name(this, "ModelConfigError");
+  }
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var StrictMissingCredentialsError = class extends ModelConfigError {
+  static {
+    __name(this, "StrictMissingCredentialsError");
+  }
+  code = "STRICT_MISSING_CREDENTIALS";
+  constructor(authType, model, envKey) {
+    const providerKey = authType || "(unknown)";
+    const modelName = model || "(unknown)";
+    super(
+      `Missing credentials for modelProviders model '${modelName}'. ` + (envKey ? `Current configured envKey: '${envKey}'. Set that environment variable, or update modelProviders.${providerKey}[].envKey.` : `Configure modelProviders.${providerKey}[].envKey and set that environment variable.`)
+    );
+  }
+};
+var StrictMissingModelIdError = class extends ModelConfigError {
+  static {
+    __name(this, "StrictMissingModelIdError");
+  }
+  code = "STRICT_MISSING_MODEL_ID";
+  constructor(authType) {
+    super(
+      `Missing model id for strict modelProviders resolution (authType: ${authType}).`
+    );
+  }
+};
+var MissingApiKeyError = class extends ModelConfigError {
+  static {
+    __name(this, "MissingApiKeyError");
+  }
+  code = "MISSING_API_KEY";
+  constructor(params) {
+    super(
+      `Missing API key for ${params.authType} auth. Current model: '${params.model || "(unknown)"}', baseUrl: '${params.baseUrl || "(default)"}'. Provide an API key via settings (security.auth.apiKey), or set the environment variable '${params.envKey}'.`
+    );
+  }
+};
+var MissingModelError = class extends ModelConfigError {
+  static {
+    __name(this, "MissingModelError");
+  }
+  code = "MISSING_MODEL";
+  constructor(params) {
+    super(
+      `Missing model for ${params.authType} auth. Set the environment variable '${params.envKey}'.`
+    );
+  }
+};
+var MissingBaseUrlError = class extends ModelConfigError {
+  static {
+    __name(this, "MissingBaseUrlError");
+  }
+  code = "MISSING_BASE_URL";
+  constructor(params) {
+    super(
+      `Missing baseUrl for modelProviders model '${params.model || "(unknown)"}'. Configure modelProviders.${params.authType || "(unknown)"}[].baseUrl.`
+    );
+  }
+};
+var MissingAnthropicBaseUrlEnvError = class extends ModelConfigError {
+  static {
+    __name(this, "MissingAnthropicBaseUrlEnvError");
+  }
+  code = "MISSING_ANTHROPIC_BASE_URL_ENV";
+  constructor() {
+    super("ANTHROPIC_BASE_URL environment variable not found.");
+  }
+};
+
+// packages/core/src/core/contentGenerator.ts
+var AuthType = /* @__PURE__ */ ((AuthType2) => {
+  AuthType2["USE_OPENAI"] = "openai";
+  AuthType2["QWEN_OAUTH"] = "qwen-oauth";
+  AuthType2["USE_GEMINI"] = "gemini";
+  AuthType2["USE_VERTEX_AI"] = "vertex-ai";
+  AuthType2["USE_ANTHROPIC"] = "anthropic";
+  return AuthType2;
+})(AuthType || {});
+function setSource(sources, path, source) {
+  sources[path] = source;
+}
+__name(setSource, "setSource");
+function getSeedSource(seed, path) {
+  return seed?.[path];
+}
+__name(getSeedSource, "getSeedSource");
+function resolveContentGeneratorConfigWithSources(config, authType, generationConfig, seedSources, options) {
+  const sources = { ...seedSources || {} };
+  const strictModelProvider = options?.strictModelProvider === true;
+  const newContentGeneratorConfig = {
+    ...generationConfig || {},
+    authType,
+    proxy: config?.getProxy()
+  };
+  setSource(sources, "authType", {
+    kind: "computed",
+    detail: "provided by caller"
+  });
+  if (config?.getProxy()) {
+    setSource(sources, "proxy", {
+      kind: "computed",
+      detail: "Config.getProxy()"
+    });
+  }
+  const seedOrUnknown = /* @__PURE__ */ __name((path) => getSeedSource(seedSources, path) ?? { kind: "unknown" }, "seedOrUnknown");
+  for (const field of PROVIDER_SOURCED_FIELDS) {
+    if (generationConfig && field in generationConfig && !sources[field]) {
+      setSource(sources, field, seedOrUnknown(field));
+    }
+  }
+  const validation = validateModelConfig(
+    newContentGeneratorConfig,
+    strictModelProvider
+  );
+  if (!validation.valid) {
+    throw new Error(validation.errors.map((e) => e.message).join("\n"));
+  }
+  return {
+    config: newContentGeneratorConfig,
+    sources
+  };
+}
+__name(resolveContentGeneratorConfigWithSources, "resolveContentGeneratorConfigWithSources");
+function validateModelConfig(config, isStrictModelProvider = false) {
+  const errors = [];
+  if (config.authType === "qwen-oauth" /* QWEN_OAUTH */) {
+    return { valid: true, errors: [] };
+  }
+  if (!config.apiKey) {
+    if (isStrictModelProvider) {
+      errors.push(
+        new StrictMissingCredentialsError(
+          config.authType,
+          config.model,
+          config.apiKeyEnvKey
+        )
+      );
+    } else {
+      const envKey = config.apiKeyEnvKey || getDefaultApiKeyEnvVar(config.authType);
+      errors.push(
+        new MissingApiKeyError({
+          authType: config.authType,
+          model: config.model,
+          baseUrl: config.baseUrl,
+          envKey
+        })
+      );
+    }
+  }
+  if (!config.model) {
+    if (isStrictModelProvider) {
+      errors.push(new StrictMissingModelIdError(config.authType));
+    } else {
+      const envKey = getDefaultModelEnvVar(config.authType);
+      errors.push(new MissingModelError({ authType: config.authType, envKey }));
+    }
+  }
+  if (config.authType === "anthropic" /* USE_ANTHROPIC */ && !config.baseUrl) {
+    if (isStrictModelProvider) {
+      errors.push(
+        new MissingBaseUrlError({
+          authType: config.authType,
+          model: config.model
+        })
+      );
+    } else if (config.authType === "anthropic" /* USE_ANTHROPIC */) {
+      errors.push(new MissingAnthropicBaseUrlEnvError());
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+__name(validateModelConfig, "validateModelConfig");
+function createContentGeneratorConfig(config, authType, generationConfig) {
+  return resolveContentGeneratorConfigWithSources(
+    config,
+    authType,
+    generationConfig
+  ).config;
+}
+__name(createContentGeneratorConfig, "createContentGeneratorConfig");
+function getModuleNotFoundError(error) {
+  let current = error;
+  while (current instanceof Error) {
+    if ("code" in current && current.code === "ERR_MODULE_NOT_FOUND") {
+      return current;
+    }
+    current = current.cause;
+  }
+  return void 0;
+}
+__name(getModuleNotFoundError, "getModuleNotFoundError");
+function wrapProviderLoadError(error, authType) {
+  const moduleNotFoundError = getModuleNotFoundError(error);
+  if (!moduleNotFoundError) {
+    return error;
+  }
+  return new Error(
+    `Qwen Code was updated in the background and needs to be restarted.
+Please exit and restart Qwen Code to use the '${authType}' provider.`,
+    { cause: moduleNotFoundError }
+  );
+}
+__name(wrapProviderLoadError, "wrapProviderLoadError");
+var LazyContentGenerator = class {
+  constructor(loader, summarizedThinking) {
+    this.loader = loader;
+    this.summarizedThinking = summarizedThinking;
+  }
+  static {
+    __name(this, "LazyContentGenerator");
+  }
+  generatorPromise;
+  getGenerator() {
+    this.generatorPromise ??= this.loader();
+    return this.generatorPromise;
+  }
+  async generateContent(request, userPromptId) {
+    return (await this.getGenerator()).generateContent(request, userPromptId);
+  }
+  async generateContentStream(request, userPromptId) {
+    return (await this.getGenerator()).generateContentStream(
+      request,
+      userPromptId
+    );
+  }
+  async countTokens(request) {
+    return (await this.getGenerator()).countTokens(request);
+  }
+  async embedContent(request) {
+    return (await this.getGenerator()).embedContent(request);
+  }
+  useSummarizedThinking() {
+    return this.summarizedThinking;
+  }
+};
+async function createContentGenerator(generatorConfig, config, isInitialAuth) {
+  const validation = validateModelConfig(generatorConfig, false);
+  if (!validation.valid) {
+    throw new Error(validation.errors.map((e) => e.message).join("\n"));
+  }
+  const authType = generatorConfig.authType;
+  if (!authType) {
+    throw new Error("ContentGeneratorConfig must have an authType");
+  }
+  await preloadRuntimeFetchModule();
+  let loadBaseGenerator;
+  try {
+    if (authType === "openai" /* USE_OPENAI */) {
+      loadBaseGenerator = /* @__PURE__ */ __name(async () => {
+        const { createOpenAIContentGenerator } = await import("./openaiContentGenerator-IXJS6C2U.js");
+        return createOpenAIContentGenerator(generatorConfig, config);
+      }, "loadBaseGenerator");
+    } else if (authType === "qwen-oauth" /* QWEN_OAUTH */) {
+      const { getQwenOAuthClient: getQwenOauthClient } = await import("./qwenOAuth2-HTROHKXO.js");
+      try {
+        const qwenClient = await getQwenOauthClient(
+          config,
+          isInitialAuth ? { requireCachedCredentials: true } : void 0
+        );
+        loadBaseGenerator = /* @__PURE__ */ __name(async () => {
+          const { QwenContentGenerator } = await import("./qwenContentGenerator-H6WZPJKC.js");
+          return new QwenContentGenerator(qwenClient, generatorConfig, config);
+        }, "loadBaseGenerator");
+      } catch (error) {
+        if (getModuleNotFoundError(error)) {
+          throw error;
+        }
+        throw new Error(error instanceof Error ? error.message : String(error));
+      }
+    } else if (authType === "anthropic" /* USE_ANTHROPIC */) {
+      loadBaseGenerator = /* @__PURE__ */ __name(async () => {
+        const { createAnthropicContentGenerator } = await import("./anthropicContentGenerator-ZLQ3X2HI.js");
+        return createAnthropicContentGenerator(generatorConfig, config);
+      }, "loadBaseGenerator");
+    } else if (authType === "gemini" /* USE_GEMINI */ || authType === "vertex-ai" /* USE_VERTEX_AI */) {
+      loadBaseGenerator = /* @__PURE__ */ __name(async () => {
+        const { createGeminiContentGenerator } = await import("./geminiContentGenerator-UDIH3YI6.js");
+        return createGeminiContentGenerator(generatorConfig, config);
+      }, "loadBaseGenerator");
+    } else {
+      throw new Error(
+        `Error creating contentGenerator: Unsupported authType: ${authType}`
+      );
+    }
+  } catch (error) {
+    throw wrapProviderLoadError(error, authType);
+  }
+  return new LazyContentGenerator(
+    async () => {
+      try {
+        const [baseGenerator, { LoggingContentGenerator }] = await Promise.all([
+          loadBaseGenerator(),
+          import("./loggingContentGenerator-7WDTTE6G.js")
+        ]);
+        return new LoggingContentGenerator(
+          baseGenerator,
+          config,
+          generatorConfig
+        );
+      } catch (error) {
+        throw wrapProviderLoadError(error, authType);
+      }
+    },
+    authType === "gemini" /* USE_GEMINI */ || authType === "vertex-ai" /* USE_VERTEX_AI */
+  );
+}
+__name(createContentGenerator, "createContentGenerator");
+
+export {
+  DEFAULT_QWEN_MODEL,
+  DEFAULT_QWEN_FLASH_MODEL,
+  DEFAULT_QWEN_EMBEDDING_MODEL,
+  MAINLINE_CODER_MODEL,
+  MODEL_GENERATION_CONFIG_FIELDS,
+  PROVIDER_SOURCED_FIELDS,
+  AUTH_ENV_MAPPINGS,
+  DEFAULT_MODELS,
+  QWEN_OAUTH_MODELS,
+  QWEN_OAUTH_ALLOWED_MODELS,
+  AuthType,
+  resolveContentGeneratorConfigWithSources,
+  validateModelConfig,
+  createContentGeneratorConfig,
+  createContentGenerator
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-IR46U7RB.js → chunk-3FB2Y2OE.js}

@@ -5,14 +5,14 @@ import {
   isTranscribableVoiceModel,
   readVoiceLanguage,
   resolveVoiceTransport
-} from "./chunk-S2PD3EZD.js";
+} from "./chunk-KJEMJWNH.js";
 import {
   resolvePath
-} from "./chunk-BVLROR2T.js";
+} from "./chunk-QLJUC7TG.js";
 import {
   createDebugLogger,
   isSubpath
-} from "./chunk-C27BYUX6.js";
+} from "./chunk-OQB4EXO4.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-QR6U5QPP.js → chunk-3SJ43L4W.js}

@@ -13,8 +13,10 @@ var LOAD_REPLAY_BULK_MODE = "bulk";
 var LOAD_REPLAY_VERSION = 1;
 var CHANNEL_STARTUP_PROFILE_META_KEY = "qwen.daemon.channelStartupProfile";
 var CHANNEL_STARTUP_PROFILE_VERSION = 1;
+var DAEMON_CHANNEL_DELIVERY_META_KEY = "qwen.daemon.channelDelivery";
 var MID_TURN_QUEUE_DRAIN_METHOD = "craft/drainMidTurnQueue";
 var TODO_STOP_GUARD_QUEUE_RELEASE_METHOD = "craft/todoStopGuardQueueReleased";
+var PROMPT_CANCEL_METHOD = "craft/cancelPendingPrompt";
 var CLIENT_MCP_OVER_WS_CONFIG_FLAG = "__clientMcpOverWs";
 
 export {
@@ -25,8 +27,10 @@ export {
   LOAD_REPLAY_VERSION,
   CHANNEL_STARTUP_PROFILE_META_KEY,
   CHANNEL_STARTUP_PROFILE_VERSION,
+  DAEMON_CHANNEL_DELIVERY_META_KEY,
   MID_TURN_QUEUE_DRAIN_METHOD,
   TODO_STOP_GUARD_QUEUE_RELEASE_METHOD,
+  PROMPT_CANCEL_METHOD,
   CLIENT_MCP_OVER_WS_CONFIG_FLAG
 };
 /**