@qwen-code/qwen-code 0.19.2 → 0.19.3-nightly.20260630.e00fe6a27

package/chunks/{chunk-RS4HRC75.js → chunk-QI2CFVRF.js}

@@ -2,15 +2,16 @@
 "use strict";
 import {
   resolveModelConfig,
+  resolveProviderProtocol,
   stripRuntimeSnapshotPrefix
-} from "./chunk-PXFFKNCO.js";
+} from "./chunk-RIP623NO.js";
 import {
   external_exports
 } from "./chunk-K5PGHDBN.js";
 import {
   AuthType,
   MODEL_GENERATION_CONFIG_FIELDS
-} from "./chunk-WA5OJGFL.js";
+} from "./chunk-SS6WJMQK.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -112,6 +113,68 @@ var AUTH_ENV_MODEL_VARS = {
   ["anthropic" /* USE_ANTHROPIC */]: ["ANTHROPIC_MODEL"],
   ["qwen-oauth" /* QWEN_OAUTH */]: []
 };
+function collectProviderModelsForProtocol(modelProviders, providerProtocol, protocol) {
+  if (!modelProviders) {
+    return [];
+  }
+  const out = [];
+  for (const [providerId, models] of Object.entries(modelProviders)) {
+    if (!Array.isArray(models)) {
+      continue;
+    }
+    if (resolveProviderProtocol(providerId, providerProtocol) === protocol) {
+      out.push(...models);
+    }
+  }
+  return out;
+}
+__name(collectProviderModelsForProtocol, "collectProviderModelsForProtocol");
+function findProviderIdForModel(modelProviders, providerProtocol, protocol, modelProvider) {
+  if (!modelProviders || !modelProvider) {
+    return void 0;
+  }
+  for (const [providerId, models] of Object.entries(modelProviders)) {
+    if (!Array.isArray(models)) {
+      continue;
+    }
+    if (resolveProviderProtocol(providerId, providerProtocol) !== protocol) {
+      continue;
+    }
+    if (models.includes(modelProvider)) {
+      return providerId;
+    }
+  }
+  return void 0;
+}
+__name(findProviderIdForModel, "findProviderIdForModel");
+function buildSkippedProviderWarnings(modelProviders, providerProtocol) {
+  if (!modelProviders) {
+    return [];
+  }
+  const warnings = [];
+  const known = Object.values(AuthType).join(", ");
+  for (const [providerId, models] of Object.entries(modelProviders)) {
+    if (!Array.isArray(models) || models.length === 0) {
+      continue;
+    }
+    const protocol = resolveProviderProtocol(providerId, providerProtocol);
+    if (protocol === "qwen-oauth" /* QWEN_OAUTH */ && providerId !== "qwen-oauth" /* QWEN_OAUTH */) {
+      warnings.push(
+        `Warning: modelProviders provider "${providerId}" maps to "qwen-oauth" via providerProtocol, but qwen-oauth uses hard-coded models only; its ${models.length} model(s) are ignored.`
+      );
+      continue;
+    }
+    if (protocol !== void 0) {
+      continue;
+    }
+    const mapped = providerProtocol && Object.hasOwn(providerProtocol, providerId) ? providerProtocol[providerId] : void 0;
+    warnings.push(
+      mapped !== void 0 ? `Warning: providerProtocol["${providerId}"] = "${mapped}" is not a known protocol (expected one of: ${known}); its ${models.length} model(s) are ignored.` : `Warning: modelProviders provider "${providerId}" is not a built-in protocol (${known}) and has no providerProtocol mapping; its ${models.length} model(s) are ignored. Add providerProtocol["${providerId}"] (e.g. "openai") to enable them.`
+    );
+  }
+  return warnings;
+}
+__name(buildSkippedProviderWarnings, "buildSkippedProviderWarnings");
 function getIgnoredTopLevelGenerationConfigFields(settingsGenerationConfig, modelProvider) {
   if (!settingsGenerationConfig || !modelProvider) {
     return [];
@@ -122,7 +185,7 @@ function getIgnoredTopLevelGenerationConfigFields(settingsGenerationConfig, mode
   );
 }
 __name(getIgnoredTopLevelGenerationConfigFields, "getIgnoredTopLevelGenerationConfigFields");
-function buildIgnoredTopLevelGenerationConfigWarning(authType, modelProvider, ignoredFields) {
+function buildIgnoredTopLevelGenerationConfigWarning(providerId, modelProvider, ignoredFields) {
   if (ignoredFields.length === 0) {
     return void 0;
   }
@@ -131,7 +194,7 @@ function buildIgnoredTopLevelGenerationConfigWarning(authType, modelProvider, ig
   const verb = isSingular ? "is" : "are";
   const fieldReference = isSingular ? "this field" : "these fields";
   const pronoun = isSingular ? "it" : "them";
-  return `Warning: ${fieldList} ${verb} ignored for provider model "${modelProvider.id}" from modelProviders.${authType}. Move ${fieldReference} to modelProviders.${authType}[].generationConfig for that model if you want ${pronoun} to apply.`;
+  return `Warning: ${fieldList} ${verb} ignored for provider model "${modelProvider.id}" from modelProviders.${providerId}. Move ${fieldReference} to modelProviders.${providerId}[].generationConfig for that model if you want ${pronoun} to apply.`;
 }
 __name(buildIgnoredTopLevelGenerationConfigWarning, "buildIgnoredTopLevelGenerationConfigWarning");
 function getAuthTypeFromEnv() {
@@ -177,8 +240,12 @@ function resolveCliGenerationConfig(inputs) {
   let modelProvider;
   let disambiguationWarning;
   if (resolvedModel && authType && settings.modelProviders) {
-    const providers = settings.modelProviders[authType];
-    if (providers && Array.isArray(providers)) {
+    const providers = collectProviderModelsForProtocol(
+      settings.modelProviders,
+      settings.providerProtocol,
+      authType
+    );
+    if (providers.length > 0) {
       const persistedBaseUrl = settings.model?.baseUrl;
       if (resolvedFromSettings && persistedBaseUrl) {
         const exactMatch = providers.find(
@@ -225,7 +292,12 @@ function resolveCliGenerationConfig(inputs) {
   };
   const resolved = resolveModelConfig(configSources);
   const ignoredGenerationConfigWarning = authType && modelProvider ? buildIgnoredTopLevelGenerationConfigWarning(
-    authType,
+    findProviderIdForModel(
+      settings.modelProviders,
+      settings.providerProtocol,
+      authType,
+      modelProvider
+    ) ?? authType,
     modelProvider,
     getIgnoredTopLevelGenerationConfigFields(
       settings.model?.generationConfig,
@@ -248,7 +320,11 @@ function resolveCliGenerationConfig(inputs) {
     warnings: [
       ...resolved.warnings,
       ...disambiguationWarning ? [disambiguationWarning] : [],
-      ...ignoredGenerationConfigWarning ? [ignoredGenerationConfigWarning] : []
+      ...ignoredGenerationConfigWarning ? [ignoredGenerationConfigWarning] : [],
+      ...buildSkippedProviderWarnings(
+        settings.modelProviders,
+        settings.providerProtocol
+      )
     ]
   };
 }
@@ -259,6 +335,7 @@ export {
   sanitizeProviderBaseUrl,
   parseAcpBaseModelId,
   parseAcpModelOption,
+  collectProviderModelsForProtocol,
   getAuthTypeFromEnv,
   resolveCliGenerationConfig
 };

package/chunks/{chunk-XU5P23GN.js → chunk-QLDPRILK.js}

@@ -3,17 +3,17 @@
 import {
   getTasksDir,
   require_proper_lockfile
-} from "./chunk-2BIF2NVV.js";
+} from "./chunk-BVSVIN45.js";
 import {
   Mutex
 } from "./chunk-OMX7CUOE.js";
 import {
   atomicWriteJSON
-} from "./chunk-3UALQ56H.js";
+} from "./chunk-3227DZO4.js";
 import {
   createDebugLogger,
   isNodeError
-} from "./chunk-C4K3FEQ2.js";
+} from "./chunk-UX4SGCGN.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/chunk-QYUE6W3T.js

@@ -0,0 +1,123 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+import {
+  __commonJS,
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// node_modules/strip-json-comments/index.js
+var require_strip_json_comments = __commonJS({
+  "node_modules/strip-json-comments/index.js"(exports, module) {
+    "use strict";
+    init_esbuild_shims();
+    var singleComment = Symbol("singleComment");
+    var multiComment = Symbol("multiComment");
+    var stripWithoutWhitespace = /* @__PURE__ */ __name(() => "", "stripWithoutWhitespace");
+    var stripWithWhitespace = /* @__PURE__ */ __name((string, start, end) => string.slice(start, end).replace(/\S/g, " "), "stripWithWhitespace");
+    var isEscaped = /* @__PURE__ */ __name((jsonString, quotePosition) => {
+      let index = quotePosition - 1;
+      let backslashCount = 0;
+      while (jsonString[index] === "\\") {
+        index -= 1;
+        backslashCount += 1;
+      }
+      return Boolean(backslashCount % 2);
+    }, "isEscaped");
+    module.exports = (jsonString, options = {}) => {
+      if (typeof jsonString !== "string") {
+        throw new TypeError(`Expected argument \`jsonString\` to be a \`string\`, got \`${typeof jsonString}\``);
+      }
+      const strip = options.whitespace === false ? stripWithoutWhitespace : stripWithWhitespace;
+      let insideString = false;
+      let insideComment = false;
+      let offset = 0;
+      let result = "";
+      for (let i = 0; i < jsonString.length; i++) {
+        const currentCharacter = jsonString[i];
+        const nextCharacter = jsonString[i + 1];
+        if (!insideComment && currentCharacter === '"') {
+          const escaped = isEscaped(jsonString, i);
+          if (!escaped) {
+            insideString = !insideString;
+          }
+        }
+        if (insideString) {
+          continue;
+        }
+        if (!insideComment && currentCharacter + nextCharacter === "//") {
+          result += jsonString.slice(offset, i);
+          offset = i;
+          insideComment = singleComment;
+          i++;
+        } else if (insideComment === singleComment && currentCharacter + nextCharacter === "\r\n") {
+          i++;
+          insideComment = false;
+          result += strip(jsonString, offset, i);
+          offset = i;
+          continue;
+        } else if (insideComment === singleComment && currentCharacter === "\n") {
+          insideComment = false;
+          result += strip(jsonString, offset, i);
+          offset = i;
+        } else if (!insideComment && currentCharacter + nextCharacter === "/*") {
+          result += jsonString.slice(offset, i);
+          offset = i;
+          insideComment = multiComment;
+          i++;
+          continue;
+        } else if (insideComment === multiComment && currentCharacter + nextCharacter === "*/") {
+          i++;
+          insideComment = false;
+          result += strip(jsonString, offset, i + 1);
+          offset = i + 1;
+          continue;
+        }
+      }
+      return result + (insideComment ? strip(jsonString.slice(offset)) : jsonString.slice(offset));
+    };
+  }
+});
+
+// packages/cli/src/config/path-comparison.ts
+init_esbuild_shims();
+import * as fs from "node:fs";
+import * as path from "node:path";
+function isWithinRoot(childPath, parentPath) {
+  const relativePath = path.relative(parentPath, childPath);
+  return relativePath === "" || !relativePath.startsWith(`..${path.sep}`) && relativePath !== ".." && !path.isAbsolute(relativePath);
+}
+__name(isWithinRoot, "isWithinRoot");
+function getPathComparisonVariants(rawPath) {
+  const variants = /* @__PURE__ */ new Set([path.normalize(path.resolve(rawPath))]);
+  try {
+    variants.add(path.normalize(fs.realpathSync(rawPath)));
+  } catch {
+  }
+  return variants;
+}
+__name(getPathComparisonVariants, "getPathComparisonVariants");
+function arePathsEquivalent(left, right) {
+  const rightVariants = getPathComparisonVariants(right);
+  for (const leftVariant of getPathComparisonVariants(left)) {
+    if (rightVariants.has(leftVariant)) {
+      return true;
+    }
+  }
+  return false;
+}
+__name(arePathsEquivalent, "arePathsEquivalent");
+
+export {
+  require_strip_json_comments,
+  isWithinRoot,
+  getPathComparisonVariants,
+  arePathsEquivalent
+};
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-USGMPVOY.js → chunk-R3LHDWF2.js}

@@ -6,19 +6,20 @@ import {
   parseAcpBaseModelId,
   resolveCliGenerationConfig,
   sanitizeProviderBaseUrl
-} from "./chunk-RS4HRC75.js";
-import {
-  loadSettings
-} from "./chunk-OQHQHJRK.js";
+} from "./chunk-QI2CFVRF.js";
 import {
   STATUS_SCHEMA_VERSION
-} from "./chunk-D5E5TMYH.js";
+} from "./chunk-3M4W4U5G.js";
 import {
-  ModelsConfig
-} from "./chunk-PXFFKNCO.js";
+  loadSettings
+} from "./chunk-HEVBZSXG.js";
+import {
+  ModelsConfig,
+  resolveProviderProtocol
+} from "./chunk-RIP623NO.js";
 import {
   tokenLimit
-} from "./chunk-F6XNTYNE.js";
+} from "./chunk-YTFBURQD.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -54,6 +55,7 @@ function buildWorkspaceProvidersStatus(workspaceCwd, acpChannelLive, options) {
     const modelsConfig = new ModelsConfig({
       initialAuthType: selectedAuthType,
       modelProvidersConfig: settings.modelProviders,
+      providerProtocolConfig: settings.providerProtocol,
       generationConfig: resolvedCliConfig.generationConfig,
       generationConfigSources: resolvedCliConfig.sources
     });
@@ -65,9 +67,10 @@ function buildWorkspaceProvidersStatus(workspaceCwd, acpChannelLive, options) {
     const fastModelId = typeof settings.fastModel === "string" && settings.fastModel.length > 0 ? settings.fastModel : void 0;
     const providers = /* @__PURE__ */ new Map();
     const explicitModelBaseUrls = buildExplicitModelBaseUrls(
-      settings.modelProviders
+      settings.modelProviders,
+      settings.providerProtocol
     );
-    for (const model of modelsConfig.getAllConfiguredModels()) {
+    for (const model of modelsConfig.getAllConfiguredModels().filter(isMainSelectableModel)) {
       if (model.isRuntimeModel) continue;
       const authType = String(model.authType);
       let provider = providers.get(authType);
@@ -146,6 +149,10 @@ function buildWorkspaceProvidersStatus(workspaceCwd, acpChannelLive, options) {
   }
 }
 __name(buildWorkspaceProvidersStatus, "buildWorkspaceProvidersStatus");
+function isMainSelectableModel(model) {
+  return model.fastOnly !== true && model.voiceOnly !== true;
+}
+__name(isMainSelectableModel, "isMainSelectableModel");
 function matchesCurrentModel(currentModelId, baseModelId, acpModelId) {
   return currentModelId === baseModelId || currentModelId === acpModelId;
 }
@@ -155,10 +162,12 @@ function matchesCurrentBaseUrl(currentBaseUrl, modelBaseUrl, modelHasExplicitBas
   return currentBaseUrl === modelBaseUrl;
 }
 __name(matchesCurrentBaseUrl, "matchesCurrentBaseUrl");
-function buildExplicitModelBaseUrls(modelProviders) {
+function buildExplicitModelBaseUrls(modelProviders, providerProtocol) {
   const baseUrls = /* @__PURE__ */ new Set();
   if (!modelProviders) return baseUrls;
-  for (const [authType, providerConfig] of Object.entries(modelProviders)) {
+  for (const [providerId, providerConfig] of Object.entries(modelProviders)) {
+    const authType = resolveProviderProtocol(providerId, providerProtocol);
+    if (!authType) continue;
     const models = readProviderModels(providerConfig);
     for (const model of models) {
       if (typeof model.id === "string" && typeof model.baseUrl === "string" && model.baseUrl.length > 0) {

package/chunks/{chunk-BNXANYLH.js → chunk-RD6YJJJ6.js}

@@ -5,7 +5,7 @@ import {
   Storage,
   resolvePath,
   sanitizeCwd
-} from "./chunk-C4K3FEQ2.js";
+} from "./chunk-UX4SGCGN.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -23,6 +23,7 @@ var AUTO_MEMORY_METADATA_FILENAME = "meta.json";
 var AUTO_MEMORY_EXTRACT_CURSOR_FILENAME = "extract-cursor.json";
 var AUTO_MEMORY_CONSOLIDATION_LOCK_FILENAME = "consolidation.lock";
 var USER_AUTO_MEMORY_DIRNAME = "memories";
+var TEAM_AUTO_MEMORY_DIRNAME = "team-memory";
 function findGitRoot(startPath) {
   let current = path.resolve(startPath);
   while (true) {
@@ -82,6 +83,7 @@ function getMemoryBaseDir() {
 }
 __name(getMemoryBaseDir, "getMemoryBaseDir");
 var _autoMemoryRootCache = /* @__PURE__ */ new Map();
+var _teamAutoMemoryRootCache = /* @__PURE__ */ new Map();
 function getAutoMemoryRoot(projectRoot) {
   const useLocalMemory = process.env["QWEN_CODE_MEMORY_LOCAL"] === "1";
   const memoryBaseDir = useLocalMemory ? "" : getMemoryBaseDir();
@@ -106,6 +108,7 @@ function getAutoMemoryRoot(projectRoot) {
 __name(getAutoMemoryRoot, "getAutoMemoryRoot");
 function clearAutoMemoryRootCache() {
   _autoMemoryRootCache.clear();
+  _teamAutoMemoryRootCache.clear();
 }
 __name(clearAutoMemoryRootCache, "clearAutoMemoryRootCache");
 function getAutoMemoryProjectStateDir(projectRoot) {
@@ -178,6 +181,79 @@ function isUserAutoMemPath(absolutePath) {
   return rel === "" || !rel.startsWith("..") && !path.isAbsolute(rel);
 }
 __name(isUserAutoMemPath, "isUserAutoMemPath");
+function getTeamAutoMemoryRoot(projectRoot) {
+  const cached = _teamAutoMemoryRootCache.get(projectRoot);
+  if (cached !== void 0) return cached;
+  const root = findGitRoot(projectRoot) ?? path.resolve(projectRoot);
+  const result = path.join(root, QWEN_DIR, TEAM_AUTO_MEMORY_DIRNAME);
+  _teamAutoMemoryRootCache.set(projectRoot, result);
+  return result;
+}
+__name(getTeamAutoMemoryRoot, "getTeamAutoMemoryRoot");
+function getTeamAutoMemoryIndexPath(projectRoot) {
+  return path.join(
+    getTeamAutoMemoryRoot(projectRoot),
+    AUTO_MEMORY_INDEX_FILENAME
+  );
+}
+__name(getTeamAutoMemoryIndexPath, "getTeamAutoMemoryIndexPath");
+function isTeamAutoMemPath(absolutePath, projectRoot) {
+  const normalizedPath = path.normalize(realpathNearestExisting(absolutePath));
+  const memRoot = path.normalize(
+    realpathNearestExisting(getTeamAutoMemoryRoot(projectRoot))
+  );
+  const rel = path.relative(memRoot, normalizedPath);
+  return rel === "" || !rel.startsWith("..") && !path.isAbsolute(rel);
+}
+__name(isTeamAutoMemPath, "isTeamAutoMemPath");
+function resolveLeafSymlink(inputPath) {
+  const maxHops = 40;
+  let current = path.resolve(inputPath);
+  for (let i = 0; i < maxHops; i++) {
+    let stat;
+    try {
+      stat = fs.lstatSync(current);
+    } catch {
+      return current;
+    }
+    if (!stat.isSymbolicLink()) {
+      return current;
+    }
+    const target = fs.readlinkSync(current);
+    if (path.isAbsolute(target)) {
+      current = target;
+    } else {
+      let parent;
+      try {
+        parent = fs.realpathSync(path.dirname(current));
+      } catch {
+        parent = path.dirname(current);
+      }
+      current = path.resolve(parent, target);
+    }
+  }
+  return current;
+}
+__name(resolveLeafSymlink, "resolveLeafSymlink");
+function realpathNearestExisting(inputPath) {
+  const resolved = resolveLeafSymlink(inputPath);
+  const missingSegments = [];
+  let current = resolved;
+  while (!fs.existsSync(current)) {
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return resolved;
+    }
+    missingSegments.unshift(path.basename(current));
+    current = parent;
+  }
+  try {
+    return path.join(fs.realpathSync(current), ...missingSegments);
+  } catch {
+    return resolved;
+  }
+}
+__name(realpathNearestExisting, "realpathNearestExisting");
 function isAnyAutoMemPath(absolutePath, projectRoot) {
   return isAutoMemPath(absolutePath, projectRoot) || isUserAutoMemPath(absolutePath);
 }
@@ -190,6 +266,7 @@ export {
   AUTO_MEMORY_EXTRACT_CURSOR_FILENAME,
   AUTO_MEMORY_CONSOLIDATION_LOCK_FILENAME,
   USER_AUTO_MEMORY_DIRNAME,
+  TEAM_AUTO_MEMORY_DIRNAME,
   getMemoryBaseDir,
   getAutoMemoryRoot,
   clearAutoMemoryRootCache,
@@ -206,6 +283,9 @@ export {
   getUserAutoMemoryIndexPath,
   getUserAutoMemoryTopicPath,
   isUserAutoMemPath,
+  getTeamAutoMemoryRoot,
+  getTeamAutoMemoryIndexPath,
+  isTeamAutoMemPath,
   isAnyAutoMemPath
 };
 /**