@qwen-code/qwen-code 0.16.0-preview.0 → 0.16.1-nightly.20260524.84f408017

package/chunks/{chunk-EDYSNFEM.js → chunk-L5E26RN6.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   ToolNames
-} from "./chunk-FZIUV27X.js";
+} from "./chunk-PVVL5Q3W.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -85,7 +85,7 @@ async function checkPriorRead(cache, filePath, verb, options = {}) {
   }
   if (status.state === "fresh" && status.entry.lastReadAt !== void 0 && !status.entry.lastReadCacheable) {
     const verbBare2 = verb === "editing" ? "edit" : "overwrite";
-    const raw2 = `File ${filePath} is a binary / image / audio / video / PDF / notebook payload that the ${ToolNames.READ_FILE} tool returns as a structured value rather than as plain text. The Edit / WriteFile tools cannot mutate that payload safely \u2014 re-reading it would not change this. Use a different mechanism (e.g. shell tool with a binary-aware writer) if you need to ${verbBare2} it.`;
+    const raw2 = `File ${filePath} is a binary / image / audio / video / PDF / notebook payload that the ${ToolNames.READ_FILE} tool returns as a structured value rather than as plain text. The Edit / WriteFile tools cannot mutate that payload safely \u2014 re-reading it would not change this. If this is a Jupyter notebook (.ipynb), use the ${ToolNames.NOTEBOOK_EDIT} tool for cell-level edits after reading it. For other non-text files, use a different mechanism (e.g. shell tool with an appropriate writer) if you need to ${verbBare2} it.`;
     return {
       ok: false,
       type: "edit_requires_prior_read" /* EDIT_REQUIRES_PRIOR_READ */,

package/chunks/{chunk-7QXHXMC6.js → chunk-LKSMYCUK.js}

@@ -2,16 +2,16 @@
 "use strict";
 import {
   RequestTokenizer
-} from "./chunk-NAID3ZWF.js";
+} from "./chunk-DMIMF3CG.js";
 import {
   buildRuntimeFetchOptions,
   redactProxyError
-} from "./chunk-VTPOO6GV.js";
+} from "./chunk-CSWBPY3P.js";
 import {
   OpenAIContentConverter,
   TaggedThinkingParser,
   openaiRequestCaptureContext
-} from "./chunk-C3LHPHN2.js";
+} from "./chunk-JUAMIT3V.js";
 import {
   CAPPED_DEFAULT_MAX_TOKENS,
   DASHSCOPE_PROXY_BASE_URL,
@@ -19,9 +19,10 @@ import {
   DEFAULT_MAX_RETRIES,
   DEFAULT_TIMEOUT,
   hasExplicitOutputLimit,
+  runtimeDiagnostics,
   safeJsonParse,
   tokenLimit
-} from "./chunk-CW44BRRA.js";
+} from "./chunk-MAY32HXD.js";
 import {
   GenerateContentResponse
 } from "./chunk-T4VD6OJ4.js";
@@ -6902,6 +6903,24 @@ OpenAI.Containers = Containers;
 init_esbuild_shims();
 
 // packages/core/src/core/openaiContentGenerator/provider/default.ts
+function shouldMirrorReasoningContentForQwen3(model) {
+  return model.toLowerCase().includes("qwen3");
+}
+__name(shouldMirrorReasoningContentForQwen3, "shouldMirrorReasoningContentForQwen3");
+function mirrorReasoningContentToReasoning(message) {
+  if (message.role !== "assistant") {
+    return message;
+  }
+  const assistant = message;
+  if (typeof assistant.reasoning_content !== "string" || assistant.reasoning_content.length === 0 || typeof assistant.reasoning === "string") {
+    return message;
+  }
+  return {
+    ...assistant,
+    reasoning: assistant.reasoning_content
+  };
+}
+__name(mirrorReasoningContentToReasoning, "mirrorReasoningContentToReasoning");
 var DefaultOpenAICompatibleProvider = class {
   static {
     __name(this, "DefaultOpenAICompatibleProvider");
@@ -6945,8 +6964,10 @@ var DefaultOpenAICompatibleProvider = class {
   buildRequest(request, _userPromptId) {
     const extraBody = this.contentGeneratorConfig.extra_body;
     const requestWithTokenLimits = this.applyOutputTokenLimit(request);
+    const messages = shouldMirrorReasoningContentForQwen3(request.model) ? requestWithTokenLimits.messages.map(mirrorReasoningContentToReasoning) : requestWithTokenLimits.messages;
     return {
       ...requestWithTokenLimits,
+      messages,
       ...extraBody ? extraBody : {}
     };
   }
@@ -7296,6 +7317,25 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
 
 // packages/core/src/core/openaiContentGenerator/provider/deepseek.ts
 init_esbuild_shims();
+
+// packages/core/src/core/openaiContentGenerator/provider/utils.ts
+init_esbuild_shims();
+function ensureReasoningContentOnAssistantMessage(message) {
+  if (message.role !== "assistant") {
+    return message;
+  }
+  const assistant = message;
+  if (typeof assistant.reasoning_content === "string") {
+    return message;
+  }
+  return {
+    ...assistant,
+    reasoning_content: ""
+  };
+}
+__name(ensureReasoningContentOnAssistantMessage, "ensureReasoningContentOnAssistantMessage");
+
+// packages/core/src/core/openaiContentGenerator/provider/deepseek.ts
 function isDeepSeekHostname(contentGeneratorConfig) {
   const baseUrl = contentGeneratorConfig.baseUrl ?? "";
   if (!baseUrl) return false;
@@ -7347,7 +7387,7 @@ var DeepSeekOpenAICompatibleProvider = class extends DefaultOpenAICompatibleProv
     }
     const messages = reshaped.messages.map((message) => {
       const flattened = flattenContentParts(message);
-      return ensureReasoningContentOnToolCalls(flattened);
+      return ensureReasoningContentOnAssistantMessage(flattened);
     });
     return {
       ...reshaped,
@@ -7409,20 +7449,6 @@ function translateReasoningEffort(request) {
   return next;
 }
 __name(translateReasoningEffort, "translateReasoningEffort");
-function ensureReasoningContentOnToolCalls(message) {
-  if (message.role !== "assistant") {
-    return message;
-  }
-  const extended = message;
-  if (typeof extended.reasoning_content === "string" && extended.reasoning_content.length > 0) {
-    return message;
-  }
-  return {
-    ...extended,
-    reasoning_content: ""
-  };
-}
-__name(ensureReasoningContentOnToolCalls, "ensureReasoningContentOnToolCalls");
 
 // packages/core/src/core/openaiContentGenerator/provider/openrouter.ts
 init_esbuild_shims();
@@ -7524,6 +7550,50 @@ function stripReasoningContent(message) {
 }
 __name(stripReasoningContent, "stripReasoningContent");
 
+// packages/core/src/core/openaiContentGenerator/provider/mimo.ts
+init_esbuild_shims();
+function isMiMoProvider(contentGeneratorConfig) {
+  const baseUrl = contentGeneratorConfig.baseUrl ?? "";
+  if (baseUrl) {
+    try {
+      const hostname = new URL(baseUrl).hostname.toLowerCase();
+      if (hostname === "xiaomimimo.com" || hostname.endsWith(".xiaomimimo.com")) {
+        return true;
+      }
+    } catch {
+    }
+  }
+  const model = contentGeneratorConfig.model ?? "";
+  return model.toLowerCase().startsWith("mimo-");
+}
+__name(isMiMoProvider, "isMiMoProvider");
+var MiMoOpenAICompatibleProvider = class extends DefaultOpenAICompatibleProvider {
+  static {
+    __name(this, "MiMoOpenAICompatibleProvider");
+  }
+  constructor(contentGeneratorConfig, cliConfig) {
+    super(contentGeneratorConfig, cliConfig);
+  }
+  static isMiMoProvider = isMiMoProvider;
+  buildRequest(request, userPromptId) {
+    const baseRequest = super.buildRequest(request, userPromptId);
+    if (!baseRequest.messages?.length) {
+      return baseRequest;
+    }
+    return {
+      ...baseRequest,
+      messages: baseRequest.messages.map(
+        ensureReasoningContentOnAssistantMessage
+      )
+    };
+  }
+  getRequestContextOverrides() {
+    return {
+      splitToolMedia: this.contentGeneratorConfig.splitToolMedia ?? true
+    };
+  }
+};
+
 // packages/core/src/core/openaiContentGenerator/pipeline.ts
 init_esbuild_shims();
 import { setMaxListeners } from "node:events";
@@ -8120,6 +8190,7 @@ var ContentGenerationPipeline = class {
         isStreaming
       );
       openaiRequestCaptureContext.getStore()?.(openaiRequest);
+      runtimeDiagnostics.recordOpenAIWireRequest(openaiRequest);
       const result = await executor(openaiRequest, context);
       return result;
     } catch (error) {
@@ -8138,6 +8209,7 @@ var ContentGenerationPipeline = class {
    */
   createRequestContext(request, isStreaming) {
     const effectiveModel = request.model || this.contentGeneratorConfig.model;
+    const providerOverrides = this.config.provider.getRequestContextOverrides?.() ?? {};
     const toolCallParser = isStreaming ? new StreamingToolCallParser() : void 0;
     const responseParsingOptions = this.config.provider.getResponseParsingOptions?.();
     const taggedThinkingParser = isStreaming && responseParsingOptions?.taggedThinkingTags ? new TaggedThinkingParser() : void 0;
@@ -8145,7 +8217,7 @@ var ContentGenerationPipeline = class {
       model: effectiveModel,
       modalities: this.contentGeneratorConfig.modalities ?? {},
       startTime: Date.now(),
-      splitToolMedia: this.contentGeneratorConfig.splitToolMedia ?? false,
+      splitToolMedia: providerOverrides.splitToolMedia ?? this.contentGeneratorConfig.splitToolMedia ?? false,
       ...toolCallParser ? { toolCallParser } : {},
       ...responseParsingOptions ? { responseParsingOptions } : {},
       ...taggedThinkingParser ? { taggedThinkingParser } : {}
@@ -8337,6 +8409,9 @@ function determineProvider(contentGeneratorConfig, cliConfig) {
       cliConfig
     );
   }
+  if (MiMoOpenAICompatibleProvider.isMiMoProvider(config)) {
+    return new MiMoOpenAICompatibleProvider(contentGeneratorConfig, cliConfig);
+  }
   if (OpenRouterOpenAICompatibleProvider.isOpenRouterProvider(config)) {
     return new OpenRouterOpenAICompatibleProvider(
       contentGeneratorConfig,
@@ -8371,6 +8446,7 @@ export {
   OpenRouterOpenAICompatibleProvider,
   MiniMaxOpenAICompatibleProvider,
   MistralOpenAICompatibleProvider,
+  MiMoOpenAICompatibleProvider,
   ContentGenerationPipeline,
   EnhancedErrorHandler,
   OpenAIContentGenerator,

package/chunks/chunk-M2TQETH7.js

@@ -0,0 +1,379 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  resolveBundleDir
+} from "./chunk-6JQC5PYU.js";
+import {
+  Storage
+} from "./chunk-XP27SJMH.js";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+import {
+  __glob,
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/utils/stdioHelpers.ts
+init_esbuild_shims();
+var writeStdoutLine = /* @__PURE__ */ __name((message) => {
+  process.stdout.write(message.endsWith("\n") ? message : `${message}
+`);
+}, "writeStdoutLine");
+var writeStderrLine = /* @__PURE__ */ __name((message) => {
+  process.stderr.write(message.endsWith("\n") ? message : `${message}
+`);
+}, "writeStderrLine");
+var clearScreen = /* @__PURE__ */ __name(() => {
+  console.clear();
+}, "clearScreen");
+
+// packages/cli/src/i18n/index.ts
+init_esbuild_shims();
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { pathToFileURL } from "node:url";
+
+// packages/cli/src/i18n/languages.ts
+init_esbuild_shims();
+var SUPPORTED_LANGUAGES = [
+  {
+    code: "en",
+    id: "en-US",
+    fullName: "English",
+    nativeName: "English"
+  },
+  {
+    code: "zh-TW",
+    id: "zh-TW",
+    fullName: "Traditional Chinese",
+    nativeName: "\u7E41\u9AD4\u4E2D\u6587",
+    strictParity: true
+  },
+  {
+    code: "zh",
+    id: "zh-CN",
+    fullName: "Chinese",
+    nativeName: "\u4E2D\u6587",
+    strictParity: true
+  },
+  {
+    code: "ru",
+    id: "ru-RU",
+    fullName: "Russian",
+    nativeName: "\u0420\u0443\u0441\u0441\u043A\u0438\u0439"
+  },
+  {
+    code: "de",
+    id: "de-DE",
+    fullName: "German",
+    nativeName: "Deutsch"
+  },
+  {
+    code: "ja",
+    id: "ja-JP",
+    fullName: "Japanese",
+    nativeName: "\u65E5\u672C\u8A9E"
+  },
+  {
+    code: "pt",
+    id: "pt-BR",
+    fullName: "Portuguese",
+    nativeName: "Portugu\xEAs"
+  },
+  {
+    code: "fr",
+    id: "fr-FR",
+    fullName: "French",
+    nativeName: "Fran\xE7ais"
+  },
+  {
+    code: "ca",
+    id: "ca-ES",
+    fullName: "Catalan",
+    nativeName: "Catal\xE0"
+  }
+];
+function normalizeLanguageCandidate(input) {
+  return input.trim().replace(/_/g, "-").toLowerCase();
+}
+__name(normalizeLanguageCandidate, "normalizeLanguageCandidate");
+function matchesLocaleToken(candidate, token) {
+  return candidate === token || candidate.startsWith(`${token}-`) || candidate.startsWith(`${token}.`) || candidate.startsWith(`${token}@`);
+}
+__name(matchesLocaleToken, "matchesLocaleToken");
+function getMatchedLocaleTokenLength(candidate, language) {
+  const code = language.code.toLowerCase();
+  const id = language.id.toLowerCase();
+  if (matchesLocaleToken(candidate, id)) {
+    return id.length;
+  }
+  if (matchesLocaleToken(candidate, code)) {
+    return code.length;
+  }
+  return void 0;
+}
+__name(getMatchedLocaleTokenLength, "getMatchedLocaleTokenLength");
+function resolveSupportedLanguage(input) {
+  const normalized = normalizeLanguageCandidate(input);
+  if (!normalized) {
+    return void 0;
+  }
+  let bestMatch;
+  for (const language of SUPPORTED_LANGUAGES) {
+    if (normalized === language.fullName.toLowerCase() || language.nativeName && normalized === language.nativeName.toLowerCase()) {
+      return language.code;
+    }
+    const tokenLength = getMatchedLocaleTokenLength(normalized, language);
+    if (tokenLength !== void 0 && (!bestMatch || tokenLength > bestMatch.tokenLength)) {
+      bestMatch = { code: language.code, tokenLength };
+    }
+  }
+  return bestMatch?.code;
+}
+__name(resolveSupportedLanguage, "resolveSupportedLanguage");
+function getLanguageNameFromLocale(locale) {
+  const resolved = resolveSupportedLanguage(locale);
+  const lang = resolved ? SUPPORTED_LANGUAGES.find((language) => language.code === resolved) : void 0;
+  return lang?.fullName || "English";
+}
+__name(getLanguageNameFromLocale, "getLanguageNameFromLocale");
+function getLanguageSettingsOptions() {
+  return [
+    { value: "auto", label: "Auto (detect from system)" },
+    ...SUPPORTED_LANGUAGES.map((l) => ({
+      value: l.code,
+      label: l.nativeName ? `${l.nativeName} (${l.fullName})` : `${l.fullName} (${l.id})`
+    }))
+  ];
+}
+__name(getLanguageSettingsOptions, "getLanguageSettingsOptions");
+function getSupportedLanguageIds(separator = "|") {
+  return SUPPORTED_LANGUAGES.map((l) => l.id).join(separator);
+}
+__name(getSupportedLanguageIds, "getSupportedLanguageIds");
+
+// packages/cli/src/i18n/translationDict.ts
+init_esbuild_shims();
+function getTranslationModuleExport(module) {
+  return Object.prototype.hasOwnProperty.call(module, "default") ? module["default"] : module;
+}
+__name(getTranslationModuleExport, "getTranslationModuleExport");
+function isTranslationDict(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length > 0;
+}
+__name(isTranslationDict, "isTranslationDict");
+
+// packages/cli/src/i18n/mustTranslateKeys.ts
+init_esbuild_shims();
+
+// import("./locales/**/*.js") in packages/cli/src/i18n/index.ts
+var globImport_locales_js = __glob({
+  "./locales/ca.js": () => import("./ca-UZ7BANMN.js"),
+  "./locales/de.js": () => import("./de-V4IE2OOZ.js"),
+  "./locales/en.js": () => import("./en-HGJ2SPLM.js"),
+  "./locales/fr.js": () => import("./fr-CJULI7ZX.js"),
+  "./locales/ja.js": () => import("./ja-L7CHRQEW.js"),
+  "./locales/pt.js": () => import("./pt-M6JULLEQ.js"),
+  "./locales/ru.js": () => import("./ru-QILM4HBC.js"),
+  "./locales/zh-TW.js": () => import("./zh-TW-S3YGWICZ.js"),
+  "./locales/zh.js": () => import("./zh-PWL2NKY3.js")
+});
+
+// packages/cli/src/i18n/index.ts
+var currentLanguage = "en";
+var translations = {};
+var translationCache = {};
+var loadingPromises = {};
+var getBuiltinLocalesDir = /* @__PURE__ */ __name(() => path.join(resolveBundleDir(import.meta.url), "locales"), "getBuiltinLocalesDir");
+var getUserLocalesDir = /* @__PURE__ */ __name(() => path.join(Storage.getGlobalQwenDir(), "locales"), "getUserLocalesDir");
+var getLocalePath = /* @__PURE__ */ __name((lang, useUserDir = false) => {
+  const baseDir = useUserDir ? getUserLocalesDir() : getBuiltinLocalesDir();
+  return path.join(baseDir, `${lang}.js`);
+}, "getLocalePath");
+function detectSystemLanguage() {
+  const envLang = process.env["QWEN_CODE_LANG"] || process.env["LANG"];
+  if (envLang) {
+    const resolved = resolveSupportedLanguage(envLang);
+    if (resolved) {
+      return resolved;
+    }
+  }
+  try {
+    const locale = Intl.DateTimeFormat().resolvedOptions().locale;
+    const resolved = resolveSupportedLanguage(locale);
+    if (resolved) {
+      return resolved;
+    }
+  } catch {
+  }
+  return "en";
+}
+__name(detectSystemLanguage, "detectSystemLanguage");
+async function tryImportTranslations(moduleSpecifier) {
+  try {
+    const module = await import(moduleSpecifier);
+    const result = getTranslationModuleExport(module);
+    if (isTranslationDict(result)) {
+      return { translations: result };
+    }
+    return {
+      error: new Error("Module loaded but result is empty or invalid")
+    };
+  } catch (error) {
+    return {
+      error: error instanceof Error ? error : new Error(String(error))
+    };
+  }
+}
+__name(tryImportTranslations, "tryImportTranslations");
+async function tryImportBundledTranslations(lang) {
+  try {
+    const module = await globImport_locales_js(`./locales/${lang}.js`);
+    const result = getTranslationModuleExport(module);
+    if (isTranslationDict(result)) {
+      return { translations: result };
+    }
+    return {
+      error: new Error("Module loaded but result is empty or invalid")
+    };
+  } catch (error) {
+    return {
+      error: error instanceof Error ? error : new Error(String(error))
+    };
+  }
+}
+__name(tryImportBundledTranslations, "tryImportBundledTranslations");
+async function loadTranslationsAsync(lang) {
+  if (translationCache[lang]) {
+    return translationCache[lang];
+  }
+  const existingPromise = loadingPromises[lang];
+  if (existingPromise) {
+    return existingPromise;
+  }
+  const loadPromise = (async () => {
+    const userJsPath = getLocalePath(lang, true);
+    if (fs.existsSync(getUserLocalesDir()) && fs.existsSync(userJsPath)) {
+      const userResult = await tryImportTranslations(
+        pathToFileURL(userJsPath).href
+      );
+      if (userResult.translations) {
+        translationCache[lang] = userResult.translations;
+        return userResult.translations;
+      }
+      writeStderrLine(
+        `Failed to load translations from user directory for ${lang}: ${userResult.error.message}`
+      );
+    }
+    const builtinJsPath = getLocalePath(lang, false);
+    const builtinModuleSpecifiers = [];
+    if (fs.existsSync(getBuiltinLocalesDir()) && fs.existsSync(builtinJsPath)) {
+      builtinModuleSpecifiers.push(pathToFileURL(builtinJsPath).href);
+    }
+    let lastBuiltinError;
+    for (const moduleSpecifier of builtinModuleSpecifiers) {
+      const builtinResult = await tryImportTranslations(moduleSpecifier);
+      if (builtinResult.translations) {
+        translationCache[lang] = builtinResult.translations;
+        return builtinResult.translations;
+      }
+      lastBuiltinError = builtinResult.error;
+    }
+    const bundledBuiltinResult = await tryImportBundledTranslations(lang);
+    if (bundledBuiltinResult.translations) {
+      translationCache[lang] = bundledBuiltinResult.translations;
+      return bundledBuiltinResult.translations;
+    }
+    lastBuiltinError = bundledBuiltinResult.error;
+    if (lastBuiltinError) {
+      writeStderrLine(
+        `Failed to load JS translations for ${lang}: ${lastBuiltinError.message}`
+      );
+    }
+    translationCache[lang] = {};
+    return {};
+  })();
+  loadingPromises[lang] = loadPromise;
+  loadPromise.finally(() => {
+    delete loadingPromises[lang];
+  });
+  return loadPromise;
+}
+__name(loadTranslationsAsync, "loadTranslationsAsync");
+function interpolate(template, params) {
+  if (!params) return template;
+  return template.replace(
+    /\{\{(\w+)\}\}/g,
+    (match, key) => params[key] ?? match
+  );
+}
+__name(interpolate, "interpolate");
+function resolveLanguage(lang) {
+  if (lang === "auto") {
+    return detectSystemLanguage();
+  }
+  return resolveSupportedLanguage(lang) ?? lang;
+}
+__name(resolveLanguage, "resolveLanguage");
+async function setLanguageAsync(lang) {
+  currentLanguage = resolveLanguage(lang);
+  translations = await loadTranslationsAsync(currentLanguage);
+}
+__name(setLanguageAsync, "setLanguageAsync");
+function getCurrentLanguage() {
+  return currentLanguage;
+}
+__name(getCurrentLanguage, "getCurrentLanguage");
+function t(key, params) {
+  const translation = translations[key] ?? key;
+  if (Array.isArray(translation)) {
+    return key;
+  }
+  return interpolate(translation, params);
+}
+__name(t, "t");
+function ta(key) {
+  const translation = translations[key];
+  if (Array.isArray(translation)) {
+    return translation;
+  }
+  return [];
+}
+__name(ta, "ta");
+async function initializeI18n(lang) {
+  await setLanguageAsync(lang ?? "auto");
+}
+__name(initializeI18n, "initializeI18n");
+
+export {
+  writeStdoutLine,
+  writeStderrLine,
+  clearScreen,
+  SUPPORTED_LANGUAGES,
+  resolveSupportedLanguage,
+  getLanguageNameFromLocale,
+  getLanguageSettingsOptions,
+  getSupportedLanguageIds,
+  detectSystemLanguage,
+  setLanguageAsync,
+  getCurrentLanguage,
+  t,
+  ta,
+  initializeI18n
+};
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2025 Qwen team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */