@qwen-code/qwen-code 0.21.7 → 0.21.8-nightly.20260810.55e20db328

package/chunks/chunk-E2FPSSKP.js

@@ -0,0 +1,244 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/commands/channel/channel-registry.ts
+init_esbuild_shims();
+var registry = /* @__PURE__ */ new Map();
+var builtinsPromise = null;
+var UNSAFE_OBJECT_KEYS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype"
+]);
+var FIELD_KINDS = /* @__PURE__ */ new Set([
+  "string",
+  "secret",
+  "boolean",
+  "number",
+  "enum",
+  "string-list",
+  "record",
+  "object"
+]);
+function assertManagementFields(fields, parentPath, nested = false) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const field of fields) {
+    const path = parentPath ? `${parentPath}.${field.key}` : field.key;
+    if (typeof field.key !== "string" || field.key.length === 0) {
+      throw new Error(
+        `Channel field "${path}" must declare a non-empty string key.`
+      );
+    }
+    if (seen.has(field.key)) {
+      throw new Error(`Channel field "${path}" is declared more than once.`);
+    }
+    seen.add(field.key);
+    assertManagementField(field, path, nested);
+  }
+}
+__name(assertManagementFields, "assertManagementFields");
+function assertManagementField(field, path, nested) {
+  if (!FIELD_KINDS.has(field.kind)) {
+    throw new Error(
+      `Channel field "${path}" declares an unknown kind "${field.kind}".`
+    );
+  }
+  if (UNSAFE_OBJECT_KEYS.has(field.key)) {
+    throw new Error(`Channel field "${path}" cannot use a reserved key.`);
+  }
+  if (!nested && field.key === "type") {
+    throw new Error(
+      `Channel field "${path}" cannot use the reserved key "type".`
+    );
+  }
+  if (typeof field.label !== "string" || field.label.length === 0) {
+    throw new Error(`Channel field "${path}" must declare a string label.`);
+  }
+  if (field.description !== void 0 && typeof field.description !== "string") {
+    throw new Error(
+      `Channel field "${path}" must declare a string description.`
+    );
+  }
+  if (field.default !== void 0 && typeof field.default !== "string") {
+    throw new Error(`Channel field "${path}" must declare a string default.`);
+  }
+  const envResolvable = Boolean(field.envResolvable);
+  const required = Boolean(field.required);
+  if (field.kind === "secret" && nested) {
+    throw new Error(`Channel field "${path}" cannot declare a nested secret.`);
+  }
+  if (envResolvable && (nested || field.kind !== "string" && field.kind !== "secret")) {
+    throw new Error(
+      `Channel field "${path}" cannot resolve environment references.`
+    );
+  }
+  const exclusiveMinimum = field.exclusiveMinimum;
+  if (exclusiveMinimum !== void 0) {
+    if (field.kind !== "number") {
+      throw new Error(
+        `Channel field "${path}" can only declare exclusiveMinimum on number fields.`
+      );
+    }
+    if (typeof exclusiveMinimum !== "number" || !Number.isFinite(exclusiveMinimum)) {
+      throw new Error(
+        `Channel field "${path}" must declare a finite exclusiveMinimum.`
+      );
+    }
+  }
+  if (field.kind === "enum") {
+    if (!Array.isArray(field.options) || field.options.length === 0) {
+      throw new Error(
+        `Channel field "${path}" must declare at least one option.`
+      );
+    }
+    if (field.options.some(
+      (option) => typeof option?.value !== "string" || option.value.length === 0
+    )) {
+      throw new Error(
+        `Channel field "${path}" must declare non-empty string option values.`
+      );
+    }
+    if (new Set(field.options.map((option) => option.value)).size !== field.options.length) {
+      throw new Error(
+        `Channel field "${path}" declares duplicate option values.`
+      );
+    }
+    if (field.default !== void 0 && !field.options.some((option) => option.value === field.default)) {
+      throw new Error(
+        `Channel field "${path}" declares a default that is not one of its options.`
+      );
+    }
+  }
+  if (field.kind !== "object") return;
+  if (required) {
+    throw new Error(`Channel field "${path}" cannot be a required object.`);
+  }
+  if (!Array.isArray(field.properties)) {
+    throw new Error(`Channel field "${path}" must declare a properties array.`);
+  }
+  if (field.properties.length === 0) {
+    throw new Error(
+      `Channel field "${path}" must declare at least one property.`
+    );
+  }
+  assertManagementFields(field.properties, path, true);
+}
+__name(assertManagementField, "assertManagementField");
+function assertManagementDescriptor(plugin) {
+  const management = plugin.management;
+  if (management === void 0) return;
+  if (management.validateConfig !== void 0 && (typeof management.validateConfig !== "function" || management.validateConfig.constructor.name === "AsyncFunction")) {
+    throw new Error(
+      "Channel management metadata must declare validateConfig as a synchronous function."
+    );
+  }
+  if (!Array.isArray(management.fields)) {
+    throw new Error("Channel management metadata must declare a fields array.");
+  }
+  assertManagementFields(management.fields);
+}
+__name(assertManagementDescriptor, "assertManagementDescriptor");
+function ensureBuiltins() {
+  if (!builtinsPromise) {
+    builtinsPromise = (async () => {
+      const labelled = [
+        { name: "telegram", promise: import("./dist-B2CGTW6T.js") },
+        { name: "weixin", promise: import("./dist-6BMOAE3Z.js") },
+        { name: "dingtalk", promise: import("./dist-EZE3V3Q7.js") },
+        { name: "wecom", promise: import("./dist-3NTTUAHT.js") },
+        { name: "feishu", promise: import("./dist-J47AXBZC.js") },
+        { name: "qqbot", promise: import("./dist-OTUO3AS2.js") },
+        { name: "github", promise: import("./dist-Z3CS4OVP.js") },
+        { name: "gitlab", promise: import("./dist-EWW3J4HQ.js") }
+      ];
+      const results = await Promise.allSettled(labelled.map((l) => l.promise));
+      for (let i = 0; i < results.length; i++) {
+        const result = results[i];
+        if (result.status === "fulfilled") {
+          registerWithManagementValidation(
+            result.value.plugin,
+            labelled[i].name
+          );
+        } else {
+          process.stderr.write(
+            `[channel-registry] Failed to load "${labelled[i].name}" channel: ${result.reason}
+`
+          );
+        }
+      }
+    })();
+  }
+  return builtinsPromise;
+}
+__name(ensureBuiltins, "ensureBuiltins");
+function registerPlugin(plugin) {
+  if (registry.has(plugin.channelType)) {
+    throw new Error(
+      `Channel type "${plugin.channelType}" is already registered.`
+    );
+  }
+  registerWithManagementValidation(plugin, plugin.channelType);
+}
+__name(registerPlugin, "registerPlugin");
+function registerWithManagementValidation(plugin, label) {
+  try {
+    assertManagementDescriptor(plugin);
+  } catch (error) {
+    process.stderr.write(
+      `[channel-registry] Invalid management metadata in "${label}" channel: ${error instanceof Error ? error.message : String(error)}
+`
+    );
+    const stripped = Object.assign(
+      Object.create(
+        Object.getPrototypeOf(plugin) ?? Object.prototype
+      ),
+      plugin
+    );
+    Object.defineProperty(stripped, "management", {
+      value: void 0,
+      writable: true,
+      enumerable: true,
+      configurable: true
+    });
+    registry.set(plugin.channelType, stripped);
+    return;
+  }
+  registry.set(plugin.channelType, plugin);
+}
+__name(registerWithManagementValidation, "registerWithManagementValidation");
+async function getPlugin(channelType) {
+  await ensureBuiltins();
+  return registry.get(channelType);
+}
+__name(getPlugin, "getPlugin");
+async function supportedTypes() {
+  await ensureBuiltins();
+  return [...registry.keys()];
+}
+__name(supportedTypes, "supportedTypes");
+async function supportedChannelCatalog() {
+  await ensureBuiltins();
+  return [...registry.values()].map(
+    ({ channelType, displayName, management }) => ({
+      type: channelType,
+      displayName,
+      manageable: management !== void 0,
+      fields: management?.fields ?? []
+    })
+  );
+}
+__name(supportedChannelCatalog, "supportedChannelCatalog");
+
+export {
+  UNSAFE_OBJECT_KEYS,
+  registerPlugin,
+  getPlugin,
+  supportedTypes,
+  supportedChannelCatalog
+};

package/chunks/{chunk-72LNFGUY.js → chunk-E2N554HK.js}

@@ -2,14 +2,14 @@
 "use strict";
 import {
   functionResponsePartsToString
-} from "./chunk-RUL4S3K3.js";
+} from "./chunk-ZCJBCKL5.js";
 import {
   parseAndFormatApiError
-} from "./chunk-Y7E5LNLO.js";
+} from "./chunk-47ZUMGGY.js";
 import {
   formatVisionBridgeNoticeDisplay,
   isVisionBridgeNoticeDisplay
-} from "./chunk-2U3WZGZG.js";
+} from "./chunk-YGT2AUJ7.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-6EOI4HOK.js → chunk-E2T7FLDU.js}

@@ -1,5 +1,9 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  DEFAULT_QWEN_MODEL,
+  MAINLINE_CODER_MODEL
+} from "./chunk-F6WFNA7U.js";
 import {
   preloadRuntimeFetchModule
 } from "./chunk-KKBPOU75.js";
@@ -10,12 +14,6 @@ import {
   __name
 } from "./chunk-J2S4EL5Y.js";
 
-// packages/core/src/config/models.ts
-init_esbuild_shims();
-var DEFAULT_QWEN_MODEL = "coder-model";
-var DEFAULT_QWEN_EMBEDDING_MODEL = "text-embedding-v4";
-var MAINLINE_CODER_MODEL = "qwen3.7-max";
-
 // packages/core/src/core/contentGenerator.ts
 init_esbuild_shims();
 
@@ -407,18 +405,18 @@ async function createContentGenerator(generatorConfig, config, isInitialAuth) {
   try {
     if (authType === "openai" /* USE_OPENAI */) {
       loadBaseGenerator = /* @__PURE__ */ __name(async () => {
-        const { createOpenAIContentGenerator } = await import("./openaiContentGenerator-EDQT6GTV.js");
+        const { createOpenAIContentGenerator } = await import("./openaiContentGenerator-OIGO5XNF.js");
         return createOpenAIContentGenerator(generatorConfig, config);
       }, "loadBaseGenerator");
     } else if (authType === "qwen-oauth" /* QWEN_OAUTH */) {
-      const { getQwenOAuthClient: getQwenOauthClient } = await import("./qwenOAuth2-NESCMZ47.js");
+      const { getQwenOAuthClient: getQwenOauthClient } = await import("./qwenOAuth2-7MTMS2Z5.js");
       try {
         const qwenClient = await getQwenOauthClient(
           config,
           isInitialAuth ? { requireCachedCredentials: true } : void 0
         );
         loadBaseGenerator = /* @__PURE__ */ __name(async () => {
-          const { QwenContentGenerator } = await import("./qwenContentGenerator-ODRJSUGR.js");
+          const { QwenContentGenerator } = await import("./qwenContentGenerator-HXM25BGB.js");
           return new QwenContentGenerator(qwenClient, generatorConfig, config);
         }, "loadBaseGenerator");
       } catch (error) {
@@ -429,12 +427,12 @@ async function createContentGenerator(generatorConfig, config, isInitialAuth) {
       }
     } else if (authType === "anthropic" /* USE_ANTHROPIC */) {
       loadBaseGenerator = /* @__PURE__ */ __name(async () => {
-        const { createAnthropicContentGenerator } = await import("./anthropicContentGenerator-DTMVEL5M.js");
+        const { createAnthropicContentGenerator } = await import("./anthropicContentGenerator-SSFE2753.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-V2WVLIXU.js");
+        const { createGeminiContentGenerator } = await import("./geminiContentGenerator-LVPMQUWX.js");
         return createGeminiContentGenerator(generatorConfig, config);
       }, "loadBaseGenerator");
     } else {
@@ -450,7 +448,7 @@ async function createContentGenerator(generatorConfig, config, isInitialAuth) {
       try {
         const [baseGenerator, { LoggingContentGenerator }] = await Promise.all([
           loadBaseGenerator(),
-          import("./loggingContentGenerator-OJCO75HM.js")
+          import("./loggingContentGenerator-A5I3VQUC.js")
         ]);
         return new LoggingContentGenerator(
           baseGenerator,
@@ -467,9 +465,6 @@ async function createContentGenerator(generatorConfig, config, isInitialAuth) {
 __name(createContentGenerator, "createContentGenerator");
 
 export {
-  DEFAULT_QWEN_MODEL,
-  DEFAULT_QWEN_EMBEDDING_MODEL,
-  MAINLINE_CODER_MODEL,
   MODEL_GENERATION_CONFIG_FIELDS,
   PROVIDER_SOURCED_FIELDS,
   AUTH_ENV_MAPPINGS,
@@ -484,11 +479,11 @@ export {
 };
 /**
  * @license
- * Copyright 2025 Google LLC
+ * Copyright 2025 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */
 /**
  * @license
- * Copyright 2025 Qwen Team
+ * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */

package/chunks/{chunk-EUQTXRKZ.js → chunk-EISUQQPS.js}

@@ -2,23 +2,23 @@
 "use strict";
 import {
   getExtensionManager
-} from "./chunk-OHJLEW5J.js";
+} from "./chunk-TWFFY5BP.js";
 import {
   parseChannelConfig
-} from "./chunk-ZXU5UHMI.js";
+} from "./chunk-LHEC5V6G.js";
 import {
   getPlugin,
   registerPlugin
-} from "./chunk-IUFV6FYU.js";
+} from "./chunk-E2FPSSKP.js";
 import {
   sanitizeLogText
-} from "./chunk-DIEFUBV6.js";
+} from "./chunk-DX3RGJMS.js";
 import {
   loadSettings
-} from "./chunk-PQBHU2IA.js";
+} from "./chunk-HKI3KHAO.js";
 import {
   hashDaemonWorkspace
-} from "./chunk-L4N6TIP7.js";
+} from "./chunk-4TRQPFDP.js";
 import {
   Storage
 } from "./chunk-OIVKILPI.js";

package/chunks/{chunk-H2UQ2M5Z.js → chunk-EUVOKP6Y.js}

@@ -1,12 +1,13 @@
 // Force strict mode and setup for ESM
 "use strict";
 import {
+  UNSAFE_OBJECT_KEYS,
   getPlugin
-} from "./chunk-IUFV6FYU.js";
+} from "./chunk-E2FPSSKP.js";
 import {
   loadSettings,
   saveSettings
-} from "./chunk-PQBHU2IA.js";
+} from "./chunk-HKI3KHAO.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -50,7 +51,6 @@ function invalidConfig(message) {
   return new ChannelSettingsError("channel_settings_invalid_config", message);
 }
 __name(invalidConfig, "invalidConfig");
-var UNSAFE_OBJECT_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
 function assertSafeChannelName(name) {
   if (UNSAFE_OBJECT_KEYS.has(name)) {
     throw new ChannelSettingsError(
@@ -108,7 +108,7 @@ function assertSharedField(key, value) {
   const enumValues = {
     senderPolicy: /* @__PURE__ */ new Set(["allowlist", "pairing", "open"]),
     dmPolicy: /* @__PURE__ */ new Set(["open", "disabled"]),
-    groupPolicy: /* @__PURE__ */ new Set(["disabled", "allowlist", "open"]),
+    groupPolicy: /* @__PURE__ */ new Set(["disabled", "allowlist", "pairing", "open"]),
     sessionScope: /* @__PURE__ */ new Set(["user", "thread", "single"]),
     dispatchMode: /* @__PURE__ */ new Set(["steer", "followup", "collect"]),
     blockStreaming: /* @__PURE__ */ new Set(["on", "off"])
@@ -168,40 +168,101 @@ function assertSharedField(key, value) {
   return false;
 }
 __name(assertSharedField, "assertSharedField");
-function assertDescriptorValue(field, value) {
-  const invalidEnvironment = typeof value === "string" && isEnvironmentReference(value) && field.envResolvable !== true;
+function containsUnsafeObjectKey(value) {
+  if (Array.isArray(value)) {
+    return value.some((item) => containsUnsafeObjectKey(item));
+  }
+  if (!isRecord(value)) return false;
+  return Object.entries(value).some(
+    ([key, nested]) => UNSAFE_OBJECT_KEYS.has(key) || containsUnsafeObjectKey(nested)
+  );
+}
+__name(containsUnsafeObjectKey, "containsUnsafeObjectKey");
+function assertDescriptorValue(field, value, path = field.key, previous) {
+  if (field.kind === "object") {
+    if (isDeepStrictEqual(previous, value) && !containsUnsafeObjectKey(value)) {
+      return;
+    }
+    if (!isRecord(value)) {
+      throw invalidConfig(`Channel field "${path}" has an invalid value.`);
+    }
+    const previousRecord = isRecord(previous) ? previous : {};
+    const properties = new Map(
+      field.properties.map((property) => [property.key, property])
+    );
+    for (const [key, nestedValue] of Object.entries(value)) {
+      const property = properties.get(key);
+      if (!property) {
+        assertPreservedUnknownField(path, key, nestedValue, previousRecord);
+        continue;
+      }
+      assertDescriptorValue(
+        property,
+        nestedValue,
+        `${path}.${key}`,
+        Object.hasOwn(previousRecord, key) ? previousRecord[key] : void 0
+      );
+    }
+    assertRequiredFields(field.properties, value, path);
+    return;
+  }
+  const invalidEnvironment = typeof value === "string" && isEnvironmentReference(value) && !field.envResolvable;
   if (invalidEnvironment) {
     throw invalidConfig(
-      `Channel field "${field.key}" does not support environment references.`
+      `Channel field "${path}" does not support environment references.`
     );
   }
-  const valid = (field.kind === "string" || field.kind === "secret") && typeof value === "string" && value.length > 0 || field.kind === "boolean" && typeof value === "boolean" || field.kind === "number" && typeof value === "number" && Number.isFinite(value) || field.kind === "enum" && typeof value === "string" && field.options?.some((option) => option.value === value) === true || field.kind === "string-list" && Array.isArray(value) && value.every((item) => typeof item === "string") || field.kind === "record" && isRecord(value) && Object.values(value).every((v) => typeof v === "string");
+  const valid = (field.kind === "string" || field.kind === "secret") && typeof value === "string" && value.length > 0 || field.kind === "boolean" && typeof value === "boolean" || field.kind === "number" && typeof value === "number" && Number.isFinite(value) && (field.exclusiveMinimum === void 0 || value > field.exclusiveMinimum) || field.kind === "enum" && typeof value === "string" && field.options?.some((option) => option.value === value) === true || field.kind === "string-list" && Array.isArray(value) && value.every((item) => typeof item === "string") || field.kind === "record" && isRecord(value) && Object.values(value).every((v) => typeof v === "string") && !containsUnsafeObjectKey(value);
   if (!valid) {
-    throw invalidConfig(`Channel field "${field.key}" has an invalid value.`);
+    throw invalidConfig(`Channel field "${path}" has an invalid value.`);
   }
 }
 __name(assertDescriptorValue, "assertDescriptorValue");
+function assertRequiredFields(fields, values, path) {
+  for (const field of fields) {
+    if (!field.required) continue;
+    const value = Object.hasOwn(values, field.key) ? values[field.key] : void 0;
+    if (value === void 0 || value === null || value === "") {
+      const fieldPath = path ? `${path}.${field.key}` : field.key;
+      throw invalidConfig(`Channel field "${fieldPath}" is required.`);
+    }
+  }
+}
+__name(assertRequiredFields, "assertRequiredFields");
+function assertPreservedUnknownField(path, key, value, previous) {
+  const fieldPath = path ? `${path}.${key}` : key;
+  if (UNSAFE_OBJECT_KEYS.has(key)) {
+    throw invalidConfig(`Channel field "${fieldPath}" is not manageable.`);
+  }
+  if (containsUnsafeObjectKey(value)) {
+    throw invalidConfig(
+      `Channel field "${fieldPath}" cannot use a reserved key.`
+    );
+  }
+  if (Object.hasOwn(previous, key) && isDeepStrictEqual(previous[key], value)) {
+    return;
+  }
+  throw invalidConfig(`Channel field "${fieldPath}" is not manageable.`);
+}
+__name(assertPreservedUnknownField, "assertPreservedUnknownField");
 function assertManagedConfig(config, previous, fields) {
   const descriptorFields = new Map(fields.map((field) => [field.key, field]));
   for (const [key, value] of Object.entries(config)) {
     if (key === "type") continue;
     const field = descriptorFields.get(key);
     if (field) {
-      assertDescriptorValue(field, value);
+      assertDescriptorValue(
+        field,
+        value,
+        field.key,
+        Object.hasOwn(previous, key) ? previous[key] : void 0
+      );
       continue;
     }
     if (assertSharedField(key, value)) continue;
-    if (!Object.hasOwn(previous, key) || !isDeepStrictEqual(previous[key], value)) {
-      throw invalidConfig(`Channel field "${key}" is not manageable.`);
-    }
-  }
-  for (const field of fields) {
-    if (!field.required) continue;
-    const value = config[field.key];
-    if (value === void 0 || value === null || value === "") {
-      throw invalidConfig(`Channel field "${field.key}" is required.`);
-    }
+    assertPreservedUnknownField(void 0, key, value, previous);
   }
+  assertRequiredFields(fields, config);
 }
 __name(assertManagedConfig, "assertManagedConfig");
 function validateSecretUpdate(update) {
@@ -294,9 +355,22 @@ var WorkspaceChannelSettingsStore = class {
       if (value !== void 0) nextConfig[key] = value;
     }
     assertManagedConfig(nextConfig, previous, plugin.management.fields);
-    const crossFieldError = plugin.management.validateConfig?.(nextConfig);
+    let crossFieldError;
+    try {
+      crossFieldError = plugin.management.validateConfig?.(nextConfig);
+      if (crossFieldError instanceof Promise) {
+        void crossFieldError.catch(() => {
+        });
+      }
+    } catch (error) {
+      throw invalidConfig(
+        `Channel validateConfig failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
     if (crossFieldError !== void 0) {
-      throw invalidConfig(crossFieldError);
+      throw invalidConfig(
+        typeof crossFieldError === "string" ? crossFieldError : "Channel validateConfig must return a string error message."
+      );
     }
     const channels = { ...current.channels, [name]: nextConfig };
     const workspaceFile = loadSettings(this.workspaceCwd, {

package/chunks/{chunk-RMH5OWLD.js → chunk-F3II4BTZ.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   AuthType
-} from "./chunk-6EOI4HOK.js";
+} from "./chunk-E2T7FLDU.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-P3LEG54R.js → chunk-F6TUUA2U.js}

@@ -8,14 +8,14 @@ import {
 } from "./chunk-Z4X5MTRT.js";
 import {
   STATUS_SCHEMA_VERSION
-} from "./chunk-NLREQJFK.js";
+} from "./chunk-DA4HRSBW.js";
 import {
   loadSettings
-} from "./chunk-PQBHU2IA.js";
+} from "./chunk-HKI3KHAO.js";
 import {
   SkillManager,
   isSafeModeEnv
-} from "./chunk-Y7E5LNLO.js";
+} from "./chunk-47ZUMGGY.js";
 import {
   writeStderrLine
 } from "./chunk-KGJGEEVR.js";

package/chunks/chunk-F6WFNA7U.js

@@ -0,0 +1,22 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+
+// packages/core/src/config/models.ts
+init_esbuild_shims();
+var DEFAULT_QWEN_MODEL = "coder-model";
+var DEFAULT_QWEN_EMBEDDING_MODEL = "text-embedding-v4";
+var MAINLINE_CODER_MODEL = "qwen3.7-max";
+
+export {
+  DEFAULT_QWEN_MODEL,
+  DEFAULT_QWEN_EMBEDDING_MODEL,
+  MAINLINE_CODER_MODEL
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-RZHU3ILK.js → chunk-FAD7OC7V.js}

@@ -2,18 +2,18 @@
 "use strict";
 import {
   appEvents
-} from "./chunk-KKJJB5X6.js";
+} from "./chunk-V47QNK5W.js";
 import {
   assembleMcpServers,
   getPendingGatedMcpServers,
   getPromptableMcpServers
-} from "./chunk-6HVUFDS2.js";
+} from "./chunk-PNVPFARW.js";
 import {
   getMCPServerStatus
-} from "./chunk-2U3WZGZG.js";
+} from "./chunk-YGT2AUJ7.js";
 import {
   require_fast_deep_equal
-} from "./chunk-IC4Z6LX6.js";
+} from "./chunk-PYQADEFD.js";
 import {
   createDebugLogger
 } from "./chunk-OIVKILPI.js";