@qwen-code/qwen-code 0.21.0 → 0.21.1-nightly.20260730.1643a6c9a

package/chunks/{chunk-IKCX4CCL.js → chunk-OINT3ZNV.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   preloadRuntimeFetchModule
-} from "./chunk-2JZBVYTU.js";
+} from "./chunk-WZRWHXFE.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -13,82 +13,9 @@ import {
 // 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();
 
@@ -201,6 +128,80 @@ var MissingAnthropicBaseUrlEnvError = class extends ModelConfigError {
   }
 };
 
+// packages/core/src/models/constants.ts
+init_esbuild_shims();
+var MODEL_GENERATION_CONFIG_FIELDS = [
+  "samplingParams",
+  "timeout",
+  "maxRetries",
+  "retryInitialDelayMs",
+  "retryMaxDelayMs",
+  "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
 var AuthType = /* @__PURE__ */ ((AuthType2) => {
   AuthType2["USE_OPENAI"] = "openai";
@@ -304,14 +305,6 @@ function validateModelConfig(config, isStrictModelProvider = false) {
   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) {
@@ -344,29 +337,60 @@ var LazyContentGenerator = class {
     __name(this, "LazyContentGenerator");
   }
   generatorPromise;
+  preloadedOnly = false;
   getGenerator() {
     this.generatorPromise ??= this.loader();
     return this.generatorPromise;
   }
+  getGeneratorForUse() {
+    this.preloadedOnly = false;
+    return this.getGenerator();
+  }
+  preload() {
+    if (!this.generatorPromise) {
+      this.preloadedOnly = true;
+    }
+    return this.getGenerator();
+  }
+  resetPreload() {
+    if (!this.preloadedOnly) return;
+    this.preloadedOnly = false;
+    this.generatorPromise = void 0;
+  }
   async generateContent(request, userPromptId) {
-    return (await this.getGenerator()).generateContent(request, userPromptId);
+    return (await this.getGeneratorForUse()).generateContent(
+      request,
+      userPromptId
+    );
   }
   async generateContentStream(request, userPromptId) {
-    return (await this.getGenerator()).generateContentStream(
+    return (await this.getGeneratorForUse()).generateContentStream(
       request,
       userPromptId
     );
   }
   async countTokens(request) {
-    return (await this.getGenerator()).countTokens(request);
+    return (await this.getGeneratorForUse()).countTokens(request);
   }
   async embedContent(request) {
-    return (await this.getGenerator()).embedContent(request);
+    return (await this.getGeneratorForUse()).embedContent(request);
   }
   useSummarizedThinking() {
     return this.summarizedThinking;
   }
 };
+async function preloadContentGenerator(generator) {
+  if (generator instanceof LazyContentGenerator) {
+    await generator.preload();
+  }
+}
+__name(preloadContentGenerator, "preloadContentGenerator");
+function resetPreloadedContentGenerator(generator) {
+  if (generator instanceof LazyContentGenerator) {
+    generator.resetPreload();
+  }
+}
+__name(resetPreloadedContentGenerator, "resetPreloadedContentGenerator");
 async function createContentGenerator(generatorConfig, config, isInitialAuth) {
   const validation = validateModelConfig(generatorConfig, false);
   if (!validation.valid) {
@@ -381,18 +405,18 @@ async function createContentGenerator(generatorConfig, config, isInitialAuth) {
   try {
     if (authType === "openai" /* USE_OPENAI */) {
       loadBaseGenerator = /* @__PURE__ */ __name(async () => {
-        const { createOpenAIContentGenerator } = await import("./openaiContentGenerator-WMCU3O2H.js");
+        const { createOpenAIContentGenerator } = await import("./openaiContentGenerator-YPCMNGEZ.js");
         return createOpenAIContentGenerator(generatorConfig, config);
       }, "loadBaseGenerator");
     } else if (authType === "qwen-oauth" /* QWEN_OAUTH */) {
-      const { getQwenOAuthClient: getQwenOauthClient } = await import("./qwenOAuth2-OWLB5AKH.js");
+      const { getQwenOAuthClient: getQwenOauthClient } = await import("./qwenOAuth2-XSYKLMNR.js");
       try {
         const qwenClient = await getQwenOauthClient(
           config,
           isInitialAuth ? { requireCachedCredentials: true } : void 0
         );
         loadBaseGenerator = /* @__PURE__ */ __name(async () => {
-          const { QwenContentGenerator } = await import("./qwenContentGenerator-HHCRK4SX.js");
+          const { QwenContentGenerator } = await import("./qwenContentGenerator-M6YW4D6A.js");
           return new QwenContentGenerator(qwenClient, generatorConfig, config);
         }, "loadBaseGenerator");
       } catch (error) {
@@ -403,12 +427,12 @@ async function createContentGenerator(generatorConfig, config, isInitialAuth) {
       }
     } else if (authType === "anthropic" /* USE_ANTHROPIC */) {
       loadBaseGenerator = /* @__PURE__ */ __name(async () => {
-        const { createAnthropicContentGenerator } = await import("./anthropicContentGenerator-75BKLTSP.js");
+        const { createAnthropicContentGenerator } = await import("./anthropicContentGenerator-V2QOGVYD.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-AG4KB6CV.js");
+        const { createGeminiContentGenerator } = await import("./geminiContentGenerator-VPXAS3BM.js");
         return createGeminiContentGenerator(generatorConfig, config);
       }, "loadBaseGenerator");
     } else {
@@ -424,7 +448,7 @@ async function createContentGenerator(generatorConfig, config, isInitialAuth) {
       try {
         const [baseGenerator, { LoggingContentGenerator }] = await Promise.all([
           loadBaseGenerator(),
-          import("./loggingContentGenerator-HS3S5H3Q.js")
+          import("./loggingContentGenerator-PSFMRX7M.js")
         ]);
         return new LoggingContentGenerator(
           baseGenerator,
@@ -442,7 +466,6 @@ __name(createContentGenerator, "createContentGenerator");
 
 export {
   DEFAULT_QWEN_MODEL,
-  DEFAULT_QWEN_FLASH_MODEL,
   DEFAULT_QWEN_EMBEDDING_MODEL,
   MAINLINE_CODER_MODEL,
   MODEL_GENERATION_CONFIG_FIELDS,
@@ -453,8 +476,8 @@ export {
   QWEN_OAUTH_ALLOWED_MODELS,
   AuthType,
   resolveContentGeneratorConfigWithSources,
-  validateModelConfig,
-  createContentGeneratorConfig,
+  preloadContentGenerator,
+  resetPreloadedContentGenerator,
   createContentGenerator
 };
 /**

package/chunks/{chunk-E5TUC6CA.js → chunk-OKF7JF3R.js}

@@ -2,13 +2,13 @@
 "use strict";
 import {
   isPrivateHost
-} from "./chunk-NH6KE4JX.js";
+} from "./chunk-LW3RFMG7.js";
 import {
   loadUndici
-} from "./chunk-2JZBVYTU.js";
+} from "./chunk-WZRWHXFE.js";
 import {
   getErrorMessage
-} from "./chunk-NL7LTRLR.js";
+} from "./chunk-UHUSJ6X7.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/chunk-PEK4ARMZ.js

@@ -0,0 +1,319 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  getUserSettingsPath,
+  v1ToV2Migration
+} from "./chunk-7A4V5CJY.js";
+import {
+  getSystemDefaultsPath,
+  getSystemSettingsPath
+} from "./chunk-IDS7MSUP.js";
+import {
+  LoadedTrustedFolders,
+  TrustLevel,
+  getTrustedFoldersPath
+} from "./chunk-5IDU2UGL.js";
+import {
+  require_strip_json_comments
+} from "./chunk-ALGGS7UH.js";
+import {
+  arePathsEquivalent
+} from "./chunk-MR3PXB6E.js";
+import {
+  ideContextStore
+} from "./chunk-EYGWU66Z.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name,
+  __toESM
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/config/daemon-trust-policy.ts
+init_esbuild_shims();
+import { createHash } from "node:crypto";
+import * as fs from "node:fs/promises";
+var import_strip_json_comments = __toESM(require_strip_json_comments(), 1);
+var MAX_TRUSTED_FOLDERS_BYTES = 1024 * 1024;
+var MAX_SETTINGS_BYTES = 4 * 1024 * 1024;
+function policyError(code, filePath, error) {
+  return {
+    code,
+    path: filePath,
+    message: error instanceof Error ? error.message : String(error)
+  };
+}
+__name(policyError, "policyError");
+async function readJsonObject(filePath, maxBytes, requireRegularFile, retryMissing = false) {
+  const delays = [0, 50, 200];
+  let result = {};
+  for (const delay of delays) {
+    if (delay > 0) {
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+    result = await readJsonObjectOnce(filePath, maxBytes, requireRegularFile);
+    if (!result.error && (!result.missing || !retryMissing)) return result;
+  }
+  return result;
+}
+__name(readJsonObject, "readJsonObject");
+async function readJsonObjectOnce(filePath, maxBytes, requireRegularFile) {
+  let stat2;
+  try {
+    stat2 = await fs.lstat(filePath);
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return { value: {}, missing: true };
+    }
+    return {
+      error: policyError("trust_policy_unreadable", filePath, error)
+    };
+  }
+  if (!requireRegularFile && stat2.isSymbolicLink()) {
+    try {
+      stat2 = await fs.stat(filePath);
+    } catch (error) {
+      return {
+        error: policyError("trust_policy_unreadable", filePath, error)
+      };
+    }
+  }
+  if (requireRegularFile && stat2.isSymbolicLink() || !stat2.isFile()) {
+    return {
+      error: policyError(
+        "trust_policy_invalid",
+        filePath,
+        new Error("Trust policy input must be a regular file.")
+      )
+    };
+  }
+  if (stat2.size > maxBytes) {
+    return {
+      error: policyError(
+        "trust_policy_invalid",
+        filePath,
+        new Error(`Trust policy input exceeds ${maxBytes} bytes.`)
+      )
+    };
+  }
+  try {
+    const raw = await fs.readFile(filePath, "utf8");
+    const parsed = JSON.parse((0, import_strip_json_comments.default)(raw));
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new Error("Trust policy input must contain a JSON object.");
+    }
+    return { value: parsed };
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return { value: {}, missing: true };
+    }
+    return { error: policyError("trust_policy_invalid", filePath, error) };
+  }
+}
+__name(readJsonObjectOnce, "readJsonObjectOnce");
+function migrateFolderTrustSettings(value, scope) {
+  if (!value || !v1ToV2Migration.shouldMigrate(value)) return value;
+  return v1ToV2Migration.migrate(value, scope).settings;
+}
+__name(migrateFolderTrustSettings, "migrateFolderTrustSettings");
+function folderTrustSetting(value, filePath) {
+  if (!value || !("security" in value)) return {};
+  const security = value?.["security"];
+  if (typeof security !== "object" || security === null || Array.isArray(security)) {
+    return {
+      error: policyError(
+        "trust_policy_invalid",
+        filePath,
+        new Error("`security` must be an object.")
+      )
+    };
+  }
+  if (!("folderTrust" in security)) return {};
+  const folderTrust = security["folderTrust"];
+  if (typeof folderTrust !== "object" || folderTrust === null || Array.isArray(folderTrust)) {
+    return {
+      error: policyError(
+        "trust_policy_invalid",
+        filePath,
+        new Error("`security.folderTrust` must be an object.")
+      )
+    };
+  }
+  if (!("enabled" in folderTrust)) return {};
+  const enabled = folderTrust["enabled"];
+  if (typeof enabled === "boolean") return { value: enabled };
+  return {
+    error: policyError(
+      "trust_policy_invalid",
+      filePath,
+      new Error("`security.folderTrust.enabled` must be a boolean.")
+    )
+  };
+}
+__name(folderTrustSetting, "folderTrustSetting");
+function parseTrustedFolders(value, filePath) {
+  const config = {};
+  for (const [rulePath, rawLevel] of Object.entries(value ?? {})) {
+    if (!Object.values(TrustLevel).includes(rawLevel)) {
+      return {
+        config: {},
+        error: policyError(
+          "trust_policy_invalid",
+          filePath,
+          new Error(`Invalid trust level for ${JSON.stringify(rulePath)}.`)
+        )
+      };
+    }
+    config[rulePath] = rawLevel;
+  }
+  return { config };
+}
+__name(parseTrustedFolders, "parseTrustedFolders");
+function semanticRevision(input) {
+  const sortedRules = Object.entries(input.trustedFolders).sort(
+    ([a], [b]) => a.localeCompare(b)
+  );
+  return createHash("sha256").update(
+    JSON.stringify({
+      folderTrustEnabled: input.folderTrustEnabled,
+      ideTrust: input.ideTrust ?? null,
+      trustedFolders: sortedRules,
+      settingsError: input.settingsError?.code ?? null,
+      trustedFoldersError: input.trustedFoldersError?.code ?? null
+    })
+  ).digest("hex");
+}
+__name(semanticRevision, "semanticRevision");
+async function readDaemonTrustPolicySnapshot() {
+  const [user, system, systemDefaults] = await Promise.all([
+    readJsonObject(getUserSettingsPath(), MAX_SETTINGS_BYTES, false),
+    readJsonObject(getSystemSettingsPath(), MAX_SETTINGS_BYTES, false),
+    readJsonObject(getSystemDefaultsPath(), MAX_SETTINGS_BYTES, false)
+  ]);
+  const systemFolderTrust = folderTrustSetting(
+    migrateFolderTrustSettings(system.value, "System"),
+    getSystemSettingsPath()
+  );
+  const userFolderTrust = folderTrustSetting(
+    migrateFolderTrustSettings(user.value, "User"),
+    getUserSettingsPath()
+  );
+  const defaultsFolderTrust = folderTrustSetting(
+    migrateFolderTrustSettings(systemDefaults.value, "SystemDefaults"),
+    getSystemDefaultsPath()
+  );
+  const settingsError = system.error ?? systemFolderTrust.error ?? user.error ?? userFolderTrust.error ?? systemDefaults.error ?? defaultsFolderTrust.error;
+  const folderTrustEnabled = systemFolderTrust.value ?? userFolderTrust.value ?? defaultsFolderTrust.value ?? false;
+  const trustedFoldersFile = await readJsonObject(
+    getTrustedFoldersPath(),
+    MAX_TRUSTED_FOLDERS_BYTES,
+    true,
+    folderTrustEnabled
+  );
+  const parsedTrustedFolders = parseTrustedFolders(
+    trustedFoldersFile.value,
+    getTrustedFoldersPath()
+  );
+  const trustedFoldersError = trustedFoldersFile.error ?? parsedTrustedFolders.error;
+  const ideTrust = ideContextStore.get()?.workspaceState?.isTrusted;
+  const revision = semanticRevision({
+    folderTrustEnabled,
+    ideTrust,
+    trustedFolders: parsedTrustedFolders.config,
+    ...settingsError ? { settingsError } : {},
+    ...trustedFoldersError ? { trustedFoldersError } : {}
+  });
+  return {
+    revision,
+    folderTrustEnabled,
+    ideTrust,
+    trustedFolders: Object.freeze({ ...parsedTrustedFolders.config }),
+    ...settingsError ? { settingsError } : {},
+    ...trustedFoldersError ? { trustedFoldersError } : {}
+  };
+}
+__name(readDaemonTrustPolicySnapshot, "readDaemonTrustPolicySnapshot");
+function explicitTrustLevel(snapshot, workspaceCwd) {
+  const folders = new LoadedTrustedFolders(
+    {
+      path: getTrustedFoldersPath(),
+      config: { ...snapshot.trustedFolders }
+    },
+    []
+  );
+  const effective = folders.isPathTrusted(workspaceCwd);
+  if (effective === void 0) return null;
+  for (const [rulePath, trustLevel] of Object.entries(
+    snapshot.trustedFolders
+  )) {
+    const preview = new LoadedTrustedFolders(
+      { path: getTrustedFoldersPath(), config: { [rulePath]: trustLevel } },
+      []
+    ).isPathTrusted(workspaceCwd);
+    if (preview === effective) return trustLevel;
+  }
+  return null;
+}
+__name(explicitTrustLevel, "explicitTrustLevel");
+function evaluateDaemonWorkspaceTrust(snapshot, workspaceCwd, processCwd = process.cwd()) {
+  if (snapshot.settingsError) {
+    return {
+      state: "error",
+      targetTrusted: false,
+      source: "none",
+      explicitTrustLevel: null,
+      error: snapshot.settingsError
+    };
+  }
+  if (!snapshot.folderTrustEnabled) {
+    return {
+      state: "trusted",
+      targetTrusted: true,
+      source: "disabled",
+      explicitTrustLevel: null
+    };
+  }
+  if (snapshot.ideTrust !== void 0 && arePathsEquivalent(workspaceCwd, processCwd)) {
+    return {
+      state: snapshot.ideTrust ? "trusted" : "untrusted",
+      targetTrusted: snapshot.ideTrust,
+      source: "ide",
+      explicitTrustLevel: null
+    };
+  }
+  if (snapshot.trustedFoldersError) {
+    return {
+      state: "error",
+      targetTrusted: false,
+      source: "none",
+      explicitTrustLevel: null,
+      error: snapshot.trustedFoldersError
+    };
+  }
+  const folders = new LoadedTrustedFolders(
+    {
+      path: getTrustedFoldersPath(),
+      config: { ...snapshot.trustedFolders }
+    },
+    []
+  );
+  const trusted = folders.isPathTrusted(workspaceCwd);
+  return {
+    state: trusted === true ? "trusted" : trusted === false ? "untrusted" : "unknown",
+    targetTrusted: trusted === true,
+    source: trusted === void 0 ? "none" : "file",
+    explicitTrustLevel: explicitTrustLevel(snapshot, workspaceCwd)
+  };
+}
+__name(evaluateDaemonWorkspaceTrust, "evaluateDaemonWorkspaceTrust");
+
+export {
+  readDaemonTrustPolicySnapshot,
+  evaluateDaemonWorkspaceTrust
+};
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */