@qwen-code/qwen-code 0.21.7 → 0.21.8

package/chunks/{chunk-VOARQPTA.js → chunk-B52AWKBB.js}

@@ -4,11 +4,15 @@ import {
   DEFAULT_EXCLUDED_ENV_VARS,
   HOME_ENV_BOOTSTRAP_KEYS,
   PROJECT_ENV_HARDCODED_EXCLUSIONS,
-  publishPendingCompileCache
-} from "./chunk-6PEXNQTX.js";
+  isHardcodedProjectEnvExclusion,
+  isLoaderEnvKey,
+  publishPendingCompileCache,
+  reportRejectedLoaderKeys,
+  resetLoaderKeyRejectionReportingForTesting
+} from "./chunk-UA5H3DS2.js";
 import {
   isWorkspaceTrusted
-} from "./chunk-6XU3PH66.js";
+} from "./chunk-HA3SAB64.js";
 import {
   require_main
 } from "./chunk-5M6IDOMF.js";
@@ -34,17 +38,18 @@ import * as os from "node:os";
 var SETTINGS_DIRECTORY_NAME = QWEN_DIR;
 var RELOAD_EXCLUDED_KEYS = /* @__PURE__ */ new Set([
   ...PROJECT_ENV_HARDCODED_EXCLUSIONS,
+  // The daemon auth token: the full loader never takes it from
+  // settings.env, and a mid-session .env edit must not rotate it. (The
+  // serve fast path consults only the hardcoded tier, so its documented
+  // workspace-settings.env token feature is unaffected.)
   "QWEN_SERVER_TOKEN",
-  "QWEN_CLI_ENTRY",
-  "NODE_OPTIONS",
-  "NODE_PATH",
-  "NODE_TLS_REJECT_UNAUTHORIZED",
-  "LD_PRELOAD",
-  "LD_AUDIT",
+  // Loader-class keys are rejected by the isLoaderEnvKey guard before this
+  // Set is consulted, so they are not spread here. These three keep their
+  // pre-denylist reload-only exclusion: too compatibility-heavy for the
+  // inherited-env scrub (mainstream toolchain/app conventions), but a
+  // mid-session .env edit must still not apply them.
   "LD_LIBRARY_PATH",
-  "DYLD_INSERT_LIBRARIES",
   "DYLD_LIBRARY_PATH",
-  "BASH_ENV",
   "ENV",
   "PATH",
   "HOME",
@@ -52,6 +57,13 @@ var RELOAD_EXCLUDED_KEYS = /* @__PURE__ */ new Set([
   "TMP",
   "TEMP"
 ]);
+var RELOAD_EXCLUDED_KEYS_CASEFOLDED = new Set(
+  [...RELOAD_EXCLUDED_KEYS].map((key) => key.toLowerCase())
+);
+function isReloadExcludedKey(key) {
+  return RELOAD_EXCLUDED_KEYS_CASEFOLDED.has(key.toLowerCase());
+}
+__name(isReloadExcludedKey, "isReloadExcludedKey");
 var dotEnvSourcedKeys = /* @__PURE__ */ new Set();
 var settingsEnvSourcedKeys = /* @__PURE__ */ new Set();
 var lastReloadSnapshot = /* @__PURE__ */ new Map();
@@ -101,7 +113,7 @@ function readHomeEnvInto(file) {
   }
   try {
     const parsed = dotenv.parse(fs.readFileSync(file, "utf-8"));
-    for (const key of PROJECT_ENV_HARDCODED_EXCLUSIONS) {
+    for (const key of HOME_ENV_BOOTSTRAP_KEYS) {
       if (parsed[key] && !Object.hasOwn(process.env, key)) {
         process.env[key] = parsed[key];
       }
@@ -115,6 +127,7 @@ function resetHomeEnvBootstrapForTesting() {
 }
 __name(resetHomeEnvBootstrapForTesting, "resetHomeEnvBootstrapForTesting");
 function resetEnvironmentTrackingForTesting() {
+  resetLoaderKeyRejectionReportingForTesting();
   dotEnvSourcedKeys.clear();
   settingsEnvSourcedKeys.clear();
   lastReloadSnapshot.clear();
@@ -246,6 +259,7 @@ function parseEnvFiles(envFilePaths, userLevelPaths) {
       const isHomeScopedEnvFile = userLevelPaths.has(normalizedEnvFilePath);
       const isQwenScopedEnvFile = isHomeScopedEnvFile || path.basename(path.dirname(normalizedEnvFilePath)) === QWEN_DIR;
       files.push({
+        path: envFilePath,
         parsedEnv,
         isHomeScopedEnvFile,
         isQwenScopedEnvFile
@@ -262,8 +276,9 @@ function parseEnvFiles(envFilePaths, userLevelPaths) {
 __name(parseEnvFiles, "parseEnvFiles");
 function canApplyParsedEnvKey(envFile, key, excludedVars, options = {}) {
   if (!Object.hasOwn(envFile.parsedEnv, key)) return false;
-  if (options.reload && RELOAD_EXCLUDED_KEYS.has(key)) return false;
-  if (!envFile.isHomeScopedEnvFile && PROJECT_ENV_HARDCODED_EXCLUSIONS.includes(key)) {
+  if (isLoaderEnvKey(key)) return false;
+  if (options.reload && isReloadExcludedKey(key)) return false;
+  if (!envFile.isHomeScopedEnvFile && isHardcodedProjectEnvExclusion(key)) {
     return false;
   }
   return envFile.isQwenScopedEnvFile || !excludedVars.includes(key);
@@ -301,16 +316,25 @@ function buildRuntimeEnvironment(settings, startDir = process.cwd(), baseEnv = p
       }
       setRuntimeEnvIfUnset(effectiveEnv, key, envFile.parsedEnv[key]);
     }
+    reportRejectedLoaderKeys(
+      `.env file ${envFile.path}`,
+      Object.keys(envFile.parsedEnv)
+    );
   }
   if (settings.env) {
     const excludedVars = settings?.advanced?.excludedEnvVars || DEFAULT_EXCLUDED_ENV_VARS;
     for (const [key, value] of Object.entries(settings.env)) {
-      if (RELOAD_EXCLUDED_KEYS.has(key)) continue;
-      if (PROJECT_ENV_HARDCODED_EXCLUSIONS.includes(key)) continue;
+      if (isLoaderEnvKey(key)) continue;
+      if (isReloadExcludedKey(key)) continue;
+      if (isHardcodedProjectEnvExclusion(key)) continue;
       if (excludedVars.includes(key)) continue;
       if (typeof value !== "string") continue;
       setRuntimeEnvIfUnset(effectiveEnv, key, value);
     }
+    reportRejectedLoaderKeys(
+      `settings.env (${startDir})`,
+      Object.keys(settings.env)
+    );
   }
   const overlayKeys = Object.keys(effectiveEnv).filter((key) => effectiveEnv[key] !== baseEnv[key]).sort();
   return {
@@ -343,13 +367,20 @@ function loadEnvironment(settings, startDir = process.cwd()) {
         lastReloadSnapshot.set(key, envFile.parsedEnv[key]);
       }
     }
+    reportRejectedLoaderKeys(
+      `.env file ${envFile.path}`,
+      Object.keys(envFile.parsedEnv)
+    );
   }
   if (settings.env) {
     for (const [key, value] of Object.entries(settings.env)) {
-      if (RELOAD_EXCLUDED_KEYS.has(key)) {
+      if (isLoaderEnvKey(key)) {
+        continue;
+      }
+      if (isReloadExcludedKey(key)) {
         continue;
       }
-      if (PROJECT_ENV_HARDCODED_EXCLUSIONS.includes(key)) {
+      if (isHardcodedProjectEnvExclusion(key)) {
         continue;
       }
       const existingValue = process.env[key];
@@ -362,6 +393,10 @@ function loadEnvironment(settings, startDir = process.cwd()) {
         lastReloadSnapshot.set(key, value);
       }
     }
+    reportRejectedLoaderKeys(
+      `settings.env (${startDir})`,
+      Object.keys(settings.env)
+    );
   }
   lastReloadSnapshotSeeded = true;
   publishPendingCompileCache();
@@ -392,17 +427,26 @@ function reloadEnvironment(settings, workspaceCwd, workspaceTrusted) {
         newDotEnvKeys.set(key, envFile.parsedEnv[key]);
       }
     }
+    reportRejectedLoaderKeys(
+      `.env file ${envFile.path}`,
+      Object.keys(envFile.parsedEnv)
+    );
   }
   if (settings.env) {
     for (const [key, value] of Object.entries(settings.env)) {
-      if (RELOAD_EXCLUDED_KEYS.has(key)) continue;
-      if (PROJECT_ENV_HARDCODED_EXCLUSIONS.includes(key)) continue;
+      if (isLoaderEnvKey(key)) continue;
+      if (isReloadExcludedKey(key)) continue;
+      if (isHardcodedProjectEnvExclusion(key)) continue;
       if (typeof value !== "string") continue;
       const dotEnvValue = newDotEnvKeys.get(key);
       if (dotEnvValue !== void 0 && dotEnvValue !== "") continue;
       if (dotEnvReadFailed && lastReloadSnapshot.has(key)) continue;
       newSettingsEnvKeys.set(key, value);
     }
+    reportRejectedLoaderKeys(
+      `settings.env (${workspaceCwd})`,
+      Object.keys(settings.env)
+    );
   }
   const allNewKeys = /* @__PURE__ */ new Set([
     ...newDotEnvKeys.keys(),
@@ -417,7 +461,7 @@ function reloadEnvironment(settings, workspaceCwd, workspaceTrusted) {
       ...settingsEnvSourcedKeys
     ]);
     for (const key of previouslyKnown) {
-      if (!allNewKeys.has(key) && !RELOAD_EXCLUDED_KEYS.has(key)) {
+      if (!allNewKeys.has(key) && !isReloadExcludedKey(key)) {
         delete process.env[key];
         removedKeys.push(key);
       }

package/chunks/{chunk-Y4EWSQF7.js → chunk-BF224XHL.js}

@@ -5,10 +5,10 @@ import {
 } from "./chunk-DP3IHZGG.js";
 import {
   t
-} from "./chunk-DBOFL3LQ.js";
+} from "./chunk-PG62DFWD.js";
 import {
   getNpmCliPath
-} from "./chunk-HYRDKNUY.js";
+} from "./chunk-IUQ52YJK.js";
 import {
   getPackageJson
 } from "./chunk-VJNBRRZG.js";

package/chunks/{chunk-PJOBIWUG.js → chunk-BF52U4XJ.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   registerCleanup
-} from "./chunk-EORNAQDT.js";
+} from "./chunk-6TR7CFXH.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-55LYDVPU.js → chunk-C5VWPTGT.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   t
-} from "./chunk-DBOFL3LQ.js";
+} from "./chunk-PG62DFWD.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-W7U4ESW2.js → chunk-CG3WBKJK.js}

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

package/chunks/chunk-COBO5EBO.js

@@ -0,0 +1,135 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  SchemaValidator
+} from "./chunk-PYQADEFD.js";
+import {
+  DEFAULT_QWEN_MODEL
+} from "./chunk-F6WFNA7U.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/utils/sideQuery.ts
+init_esbuild_shims();
+import { readFile } from "node:fs/promises";
+function buildDefaultPromptId(purpose) {
+  return purpose ? `side-query:${purpose}` : "side-query";
+}
+__name(buildDefaultPromptId, "buildDefaultPromptId");
+function resolveDefaultModel(config, override) {
+  return override ?? config.getFastModel?.() ?? config.getModel() ?? DEFAULT_QWEN_MODEL;
+}
+__name(resolveDefaultModel, "resolveDefaultModel");
+function applyThinkingDefault(callerConfig) {
+  const thinkingOverride = callerConfig?.thinkingConfig;
+  return {
+    ...callerConfig ?? {},
+    thinkingConfig: thinkingOverride ? { includeThoughts: false, ...thinkingOverride } : { includeThoughts: false }
+  };
+}
+__name(applyThinkingDefault, "applyThinkingDefault");
+async function getOutputLanguageInstruction(config) {
+  const outputLanguageFilePath = config.getOutputLanguageFilePath?.();
+  if (!outputLanguageFilePath) return void 0;
+  try {
+    const preference = (await readFile(outputLanguageFilePath, "utf8")).trim();
+    if (!preference) return void 0;
+    return [
+      "Follow the user-visible output language preference below for this side query.",
+      "This preference overrides any earlier language-selection rule in this system instruction.",
+      preference
+    ].join("\n\n");
+  } catch {
+    return void 0;
+  }
+}
+__name(getOutputLanguageInstruction, "getOutputLanguageInstruction");
+function appendSystemInstruction(systemInstruction, outputLanguageInstruction) {
+  if (!outputLanguageInstruction) return systemInstruction;
+  if (systemInstruction === void 0) return outputLanguageInstruction;
+  if (typeof systemInstruction === "string") {
+    return `${systemInstruction}
+
+${outputLanguageInstruction}`;
+  }
+  if (Array.isArray(systemInstruction)) {
+    return [...systemInstruction, { text: outputLanguageInstruction }];
+  }
+  if (typeof systemInstruction === "object" && "parts" in systemInstruction && Array.isArray(systemInstruction.parts)) {
+    return {
+      ...systemInstruction,
+      parts: [...systemInstruction.parts, { text: outputLanguageInstruction }]
+    };
+  }
+  return [systemInstruction, { text: outputLanguageInstruction }];
+}
+__name(appendSystemInstruction, "appendSystemInstruction");
+function isJsonOptions(options) {
+  return options.schema !== void 0 && options.schema !== null;
+}
+__name(isJsonOptions, "isJsonOptions");
+async function runSideQuery(config, options) {
+  const model = resolveDefaultModel(config, options.model);
+  const promptId = options.promptId ?? buildDefaultPromptId(options.purpose);
+  const requestConfig = applyThinkingDefault(options.config);
+  const outputLanguageInstruction = options.skipOutputLanguagePreference ? void 0 : await getOutputLanguageInstruction(config);
+  const systemInstruction = appendSystemInstruction(
+    options.systemInstruction,
+    outputLanguageInstruction
+  );
+  if (isJsonOptions(options)) {
+    const response = await config.getBaseLlmClient().generateJson({
+      contents: options.contents,
+      schema: options.schema,
+      abortSignal: options.abortSignal,
+      model,
+      systemInstruction,
+      promptId,
+      config: requestConfig,
+      ...options.maxAttempts !== void 0 && {
+        maxAttempts: options.maxAttempts
+      }
+    });
+    const schemaError = SchemaValidator.validate(options.schema, response);
+    if (schemaError) {
+      throw new Error(`Invalid side query response: ${schemaError}`);
+    }
+    const customError2 = options.validate?.(response);
+    if (customError2) {
+      throw new Error(customError2);
+    }
+    return response;
+  }
+  const result = await config.getBaseLlmClient().generateText({
+    contents: options.contents,
+    model,
+    systemInstruction,
+    abortSignal: options.abortSignal,
+    promptId,
+    config: requestConfig,
+    ...options.maxAttempts !== void 0 && {
+      maxAttempts: options.maxAttempts
+    },
+    ...options.stream !== void 0 && { stream: options.stream },
+    ...options.failClosed !== void 0 && { failClosed: options.failClosed }
+  });
+  const customError = options.validate?.(result.text);
+  if (customError) {
+    throw new Error(customError);
+  }
+  return result;
+}
+__name(runSideQuery, "runSideQuery");
+
+export {
+  runSideQuery
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/chunk-CPG6P4GG.js

@@ -0,0 +1,82 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  isTeammate
+} from "./chunk-S6LOFUVP.js";
+import {
+  isInForkExecution
+} from "./chunk-IA7TGCN2.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// 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");
+
+export {
+  runWithAgentContext,
+  runWithRuntimeContentGenerator,
+  getCurrentAgentId,
+  getCurrentAgentDepth,
+  getRuntimeContentGenerator,
+  runOutsideAgentContext,
+  isTopLevelSession,
+  childLaunchDepth,
+  spawnBlockReason
+};
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */