@qwen-code/qwen-code 0.23.2-preview.0 → 0.23.3-nightly.20260910.c46cb85cf2

package/chunks/chunk-NUQ4GK5I.js

@@ -0,0 +1,315 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/services/compactionInputSlimming.ts
+init_esbuild_shims();
+var DEFAULT_IMAGE_TOKEN_ESTIMATE = 1600;
+var TOKEN_TO_CHAR_RATIO = 4;
+var DEFAULT_MIME = "application/octet-stream";
+function sanitizeMimeForPlaceholder(mime) {
+  return mime.replace(/[\r\n\t]+/g, " ").replace(/[[\]]/g, "").trim().slice(0, 128);
+}
+__name(sanitizeMimeForPlaceholder, "sanitizeMimeForPlaceholder");
+var imagePlaceholder = /* @__PURE__ */ __name((mime) => `[image: ${sanitizeMimeForPlaceholder(mime)}]`, "imagePlaceholder");
+var documentPlaceholder = /* @__PURE__ */ __name((mime) => `[document: ${sanitizeMimeForPlaceholder(mime)}]`, "documentPlaceholder");
+function resolveSlimmingConfig(settings) {
+  return {
+    imageTokenEstimate: resolveNumber(
+      process.env["QWEN_IMAGE_TOKEN_ESTIMATE"],
+      settings?.imageTokenEstimate,
+      DEFAULT_IMAGE_TOKEN_ESTIMATE,
+      { minInclusive: 1 }
+    )
+  };
+}
+__name(resolveSlimmingConfig, "resolveSlimmingConfig");
+function resolveNumber(envValue, settingsValue, defaultValue, {
+  integer = false,
+  minInclusive
+}) {
+  const isValid = /* @__PURE__ */ __name((value) => Number.isFinite(value) && (!integer || Number.isSafeInteger(value)) && value >= minInclusive, "isValid");
+  if (envValue !== void 0 && envValue !== "") {
+    const trimmed = envValue.trim();
+    if (integer && !/^\d+$/.test(trimmed)) {
+      return settingsValue !== void 0 && isValid(settingsValue) ? settingsValue : defaultValue;
+    }
+    const parsed = Number(trimmed);
+    if (isValid(parsed)) {
+      return parsed;
+    }
+  }
+  if (settingsValue !== void 0 && isValid(settingsValue)) {
+    return settingsValue;
+  }
+  return defaultValue;
+}
+__name(resolveNumber, "resolveNumber");
+var DEFAULT_MAX_RECENT_FILES = 5;
+var DEFAULT_MAX_RECENT_IMAGES = 3;
+var DEFAULT_SCREENSHOT_TRIGGER_ENABLED = true;
+var DEFAULT_SCREENSHOT_TRIGGER_THRESHOLD = 20;
+var DEFAULT_IMAGE_PAYLOAD_THRESHOLD = 20;
+function resolveCompactionTuning(settings) {
+  return {
+    maxRecentFiles: resolveNumber(
+      process.env["QWEN_COMPACT_MAX_RECENT_FILES"],
+      settings?.maxRecentFilesToRetain,
+      DEFAULT_MAX_RECENT_FILES,
+      { integer: true, minInclusive: 0 }
+    ),
+    maxRecentImages: resolveNumber(
+      process.env["QWEN_COMPACT_MAX_RECENT_IMAGES"],
+      settings?.maxRecentImagesToRetain,
+      DEFAULT_MAX_RECENT_IMAGES,
+      { integer: true, minInclusive: 0 }
+    ),
+    enableScreenshotTrigger: resolveBoolean(
+      process.env["QWEN_COMPACT_SCREENSHOT_TRIGGER"],
+      settings?.enableScreenshotTrigger,
+      DEFAULT_SCREENSHOT_TRIGGER_ENABLED
+    ),
+    screenshotTriggerThreshold: resolveNumber(
+      process.env["QWEN_COMPACT_SCREENSHOT_THRESHOLD"],
+      settings?.screenshotTriggerThreshold,
+      DEFAULT_SCREENSHOT_TRIGGER_THRESHOLD,
+      { integer: true, minInclusive: 1 }
+    ),
+    imagePayloadThreshold: resolveNumber(
+      process.env["QWEN_IMAGE_PAYLOAD_THRESHOLD"],
+      settings?.imagePayloadThreshold,
+      DEFAULT_IMAGE_PAYLOAD_THRESHOLD,
+      { integer: true, minInclusive: 1 }
+    )
+  };
+}
+__name(resolveCompactionTuning, "resolveCompactionTuning");
+function resolveBoolean(envValue, settingsValue, defaultValue) {
+  if (envValue === "1" || envValue === "true") return true;
+  if (envValue === "0" || envValue === "false") return false;
+  if (typeof settingsValue === "boolean") return settingsValue;
+  return defaultValue;
+}
+__name(resolveBoolean, "resolveBoolean");
+function estimatePartChars(part, imageTokenEstimate) {
+  if (part.inlineData || part.fileData) {
+    return imageTokenEstimate * TOKEN_TO_CHAR_RATIO;
+  }
+  if (typeof part.text === "string") {
+    return part.text.length;
+  }
+  if (part.functionResponse) {
+    let total = 0;
+    const output = part.functionResponse.response?.["output"];
+    const error = part.functionResponse.response?.["error"];
+    if (typeof output === "string") {
+      total += output.length;
+    } else if (typeof error === "string") {
+      total += error.length;
+    }
+    const nested = getFunctionResponseParts(part);
+    if (nested) {
+      for (const inner of nested) {
+        total += estimatePartChars(inner, imageTokenEstimate);
+      }
+    }
+    return total + 64;
+  }
+  return JSON.stringify(part ?? {}).length;
+}
+__name(estimatePartChars, "estimatePartChars");
+function getFunctionResponseParts(part) {
+  const fr = part.functionResponse;
+  return Array.isArray(fr?.parts) ? fr.parts : void 0;
+}
+__name(getFunctionResponseParts, "getFunctionResponseParts");
+function estimateContentChars(content, imageTokenEstimate) {
+  if (!content.parts) return 0;
+  let total = 0;
+  for (const part of content.parts) {
+    total += estimatePartChars(part, imageTokenEstimate);
+  }
+  return total;
+}
+__name(estimateContentChars, "estimateContentChars");
+var SLIM_TEXT_TRUNCATION_MARKER = "\n[...truncated for compaction]";
+function slimCompactionInput(history, supportedModalities, options) {
+  const stats = {
+    imagesStripped: 0,
+    documentsStripped: 0,
+    textPartsTruncated: 0
+  };
+  let anyChange = false;
+  const slimmed = history.map((content) => {
+    if (!content.parts || content.parts.length === 0) return content;
+    let touched = false;
+    const newParts = content.parts.map((part) => {
+      const replacement = transformPart(
+        part,
+        stats,
+        supportedModalities,
+        options
+      );
+      if (replacement !== part) {
+        touched = true;
+        return replacement;
+      }
+      return part;
+    });
+    if (!touched) return content;
+    anyChange = true;
+    return { ...content, parts: newParts };
+  });
+  return {
+    slimmedHistory: anyChange ? slimmed : history,
+    stats
+  };
+}
+__name(slimCompactionInput, "slimCompactionInput");
+function transformPart(part, stats, supportedModalities, options) {
+  if (part.inlineData) {
+    if (supportsMimeType(part.inlineData.mimeType, supportedModalities) === true) {
+      return part;
+    }
+    return mediaPlaceholderPart(part.inlineData.mimeType, stats);
+  }
+  if (part.fileData) {
+    if (supportsMimeType(part.fileData.mimeType, supportedModalities) === true) {
+      return part;
+    }
+    return mediaPlaceholderPart(part.fileData.mimeType, stats);
+  }
+  let nextPart = part;
+  const nested = getFunctionResponseParts(part);
+  if (nested) {
+    let touched = false;
+    const newNested = nested.map((inner) => {
+      const replacement = transformPart(
+        inner,
+        stats,
+        supportedModalities,
+        options
+      );
+      if (replacement !== inner) {
+        touched = true;
+      }
+      return replacement;
+    });
+    if (touched) {
+      nextPart = {
+        ...part,
+        functionResponse: {
+          ...part.functionResponse,
+          parts: newNested
+        }
+      };
+    }
+  }
+  const maxTextChars = options?.maxTextChars;
+  const fr = nextPart.functionResponse;
+  if (maxTextChars !== void 0 && fr?.response) {
+    const response = fr.response;
+    let touched = false;
+    const newResponse = { ...response };
+    for (const key of ["output", "error"]) {
+      const value = response[key];
+      if (typeof value === "string" && value.length > maxTextChars) {
+        newResponse[key] = truncateTextForSlimming(value, maxTextChars);
+        stats.textPartsTruncated++;
+        touched = true;
+      }
+    }
+    if (touched) {
+      nextPart = {
+        ...nextPart,
+        functionResponse: {
+          ...fr,
+          response: newResponse
+        }
+      };
+    }
+  }
+  const fc = nextPart.functionCall;
+  if (maxTextChars !== void 0 && fc?.args) {
+    const args = fc.args;
+    let argsTouched = false;
+    const newArgs = { ...args };
+    for (const [key, value] of Object.entries(args)) {
+      if (typeof value === "string" && value.length > maxTextChars) {
+        newArgs[key] = truncateTextForSlimming(value, maxTextChars);
+        stats.textPartsTruncated++;
+        argsTouched = true;
+      }
+    }
+    if (argsTouched) {
+      nextPart = {
+        ...nextPart,
+        functionCall: { ...fc, args: newArgs }
+      };
+    }
+  }
+  if (maxTextChars !== void 0 && typeof nextPart.text === "string" && nextPart.text.length > maxTextChars) {
+    stats.textPartsTruncated++;
+    return {
+      ...nextPart,
+      text: truncateTextForSlimming(nextPart.text, maxTextChars)
+    };
+  }
+  return nextPart;
+}
+__name(transformPart, "transformPart");
+function truncateTextForSlimming(value, maxTextChars) {
+  let end = maxTextChars;
+  const last = value.charCodeAt(end - 1);
+  if (last >= 55296 && last <= 56319) {
+    end--;
+  }
+  return value.slice(0, end) + SLIM_TEXT_TRUNCATION_MARKER;
+}
+__name(truncateTextForSlimming, "truncateTextForSlimming");
+function supportsMimeType(mimeType, modalities) {
+  if (!modalities) return void 0;
+  const mime = mimeType ?? DEFAULT_MIME;
+  if (mime.startsWith("image/")) return modalities.image;
+  if (mime === "application/pdf") return modalities.pdf;
+  if (mime.startsWith("audio/")) return modalities.audio;
+  if (mime.startsWith("video/")) return modalities.video;
+  return false;
+}
+__name(supportsMimeType, "supportsMimeType");
+function mediaPlaceholderPart(mimeType, stats) {
+  const mime = mimeType ?? DEFAULT_MIME;
+  if (isNonImageMime(mime)) {
+    stats.documentsStripped++;
+    return { text: documentPlaceholder(mime) };
+  }
+  stats.imagesStripped++;
+  return { text: imagePlaceholder(mime) };
+}
+__name(mediaPlaceholderPart, "mediaPlaceholderPart");
+function isNonImageMime(mime) {
+  return !mime.startsWith("image/");
+}
+__name(isNonImageMime, "isNonImageMime");
+
+export {
+  DEFAULT_IMAGE_TOKEN_ESTIMATE,
+  TOKEN_TO_CHAR_RATIO,
+  sanitizeMimeForPlaceholder,
+  resolveSlimmingConfig,
+  resolveCompactionTuning,
+  estimatePartChars,
+  getFunctionResponseParts,
+  estimateContentChars,
+  slimCompactionInput
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-J3VZF2AL.js → chunk-NUQVB25K.js}

@@ -2,13 +2,13 @@
 "use strict";
 import {
   hasControlCharacter
-} from "./chunk-OWCFKIFQ.js";
+} from "./chunk-ZKYR7QS4.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-MWIO7MF6.js";
+} from "./chunk-TP6FYVQT.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-GNY7B3CA.js → chunk-NVIBH7WS.js}

@@ -5,7 +5,7 @@ import {
   isTranscribableVoiceModel,
   readVoiceLanguage,
   resolveVoiceTransport
-} from "./chunk-NB3NDQQK.js";
+} from "./chunk-Q2XLNLAV.js";
 import {
   resolvePath
 } from "./chunk-Y53DG2HA.js";

package/chunks/{chunk-M6YLOETP.js → chunk-O3MKRN2I.js}

@@ -3,17 +3,17 @@
 import {
   getGitVersion,
   getNpmVersion
-} from "./chunk-EA4NFWVG.js";
+} from "./chunk-6EOMQPTS.js";
 import {
   buildEnvStatusFromEnv,
   snapshotProcessEnv
-} from "./chunk-6RZX2HIH.js";
+} from "./chunk-TBEXLLAO.js";
 import {
   mapDomainErrorToErrorKind
-} from "./chunk-FETY36NQ.js";
+} from "./chunk-HGEUHUEV.js";
 import {
   canUseRipgrep
-} from "./chunk-TRWQQBVH.js";
+} from "./chunk-DTNV6UZY.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-ISPBBKJN.js → chunk-ONGZNOIP.js}

@@ -14,12 +14,17 @@ import {
 init_esbuild_shims();
 async function getCliVersion() {
   const pkgJson = await getPackageJson();
-  return "0.23.2-preview.0";
+  return "0.23.3-nightly.20260910.c46cb85cf2";
 }
 __name(getCliVersion, "getCliVersion");
+function formatVersionLabel(version) {
+  return /^\d/.test(version) ? `v${version}` : version;
+}
+__name(formatVersionLabel, "formatVersionLabel");
 
 export {
-  getCliVersion
+  getCliVersion,
+  formatVersionLabel
 };
 /**
  * @license

package/chunks/{chunk-Q2F43WTJ.js → chunk-OOLSYRZ7.js}

@@ -1,13 +1,18 @@
 // Force strict mode and setup for ESM
 "use strict";
-import {
-  customDeepMerge,
-  getSettingsSchema
-} from "./chunk-MWEF5MUK.js";
 import {
   DEFAULT_DARK_THEME_NAME,
   DEFAULT_LIGHT_THEME_NAME
 } from "./chunk-RKUWKYED.js";
+import {
+  customDeepMerge,
+  getSettingsSchema
+} from "./chunk-IOUBOANU.js";
+import {
+  getHomeEnvFallbackVars,
+  loadEnvironment,
+  preResolveHomeEnvOverrides
+} from "./chunk-YIU5PEAT.js";
 import {
   CONSOLIDATED_DISABLE_KEYS,
   V1_INDICATOR_KEYS,
@@ -15,30 +20,25 @@ import {
   V1_TO_V2_PRESERVE_DISABLE_MAP,
   V2_CONTAINER_KEYS
 } from "./chunk-BW4333PP.js";
+import {
+  ENV_CORRUPTED_PATH,
+  ENV_WAS_RECOVERED
+} from "./chunk-VX63RJXE.js";
 import {
   getSystemDefaultsPath,
   getSystemSettingsPath
 } from "./chunk-IDS7MSUP.js";
 import {
   t
-} from "./chunk-CRZBDVP2.js";
+} from "./chunk-74JEYK2C.js";
 import {
   SUPPORTED_LANGUAGES,
   getLanguageNameFromLocale
 } from "./chunk-5EJZE3FP.js";
-import {
-  getHomeEnvFallbackVars,
-  loadEnvironment,
-  preResolveHomeEnvOverrides
-} from "./chunk-Y6ZWXM44.js";
-import {
-  ENV_CORRUPTED_PATH,
-  ENV_WAS_RECOVERED
-} from "./chunk-QTNCGZHQ.js";
 import {
   isWorkspaceTrusted,
   updateSettingsFilePreservingFormat
-} from "./chunk-7RXOEUFF.js";
+} from "./chunk-KHIBLKNK.js";
 import {
   require_strip_json_comments
 } from "./chunk-NPQ5ZKRP.js";
@@ -47,7 +47,7 @@ import {
 } from "./chunk-65I7S4Z3.js";
 import {
   stripRuntimeSnapshotPrefix
-} from "./chunk-565U2ANU.js";
+} from "./chunk-ZTTC7T4X.js";
 import {
   FatalConfigError,
   Storage,
@@ -482,6 +482,17 @@ function settingExistsInScope(key, scopeSettings) {
   return value !== void 0;
 }
 __name(settingExistsInScope, "settingExistsInScope");
+function settingPathExists(key, settings) {
+  let current = settings;
+  for (const segment of key.split(".")) {
+    if (typeof current !== "object" || current === null || !Object.hasOwn(current, segment)) {
+      return false;
+    }
+    current = current[segment];
+  }
+  return true;
+}
+__name(settingPathExists, "settingPathExists");
 function pathHasUnsafeSegment(keys) {
   for (const key of keys) {
     if (key === "__proto__" || key === "constructor" || key === "prototype") {
@@ -584,17 +595,17 @@ __name(saveModifiedSettings, "saveModifiedSettings");
 function getDisplayValue(key, settings, _mergedSettings, modifiedSettings, pendingSettings) {
   const definition = getSettingDefinition(key);
   let value;
-  if (pendingSettings && settingExistsInScope(key, pendingSettings)) {
+  if (pendingSettings && settingPathExists(key, pendingSettings)) {
     value = getEffectiveValue(key, pendingSettings, {});
   } else if (settingExistsInScope(key, settings)) {
     value = getEffectiveValue(key, settings, {});
   } else {
     value = getDefaultValue(key);
   }
-  let valueString = String(value);
+  let valueString = value === void 0 ? t("(not set)") : String(value);
   if (key === "general.outputLanguage" && isAutoLanguage(value)) {
     valueString = t("Auto (follow user input)");
-  } else if (definition?.type === "enum" && definition.options) {
+  } else if (value !== void 0 && definition?.type === "enum" && definition.options) {
     const option = definition.options?.find((option2) => option2.value === value);
     if (option?.label) {
       valueString = t(option.label) || option.label;
@@ -614,6 +625,11 @@ function getDisplayValue(key, settings, _mergedSettings, modifiedSettings, pendi
   return valueString;
 }
 __name(getDisplayValue, "getDisplayValue");
+function nextBooleanSettingValue(currentValue, defaultValue) {
+  if (currentValue !== void 0) return !currentValue;
+  return defaultValue === void 0 ? false : !defaultValue;
+}
+__name(nextBooleanSettingValue, "nextBooleanSettingValue");
 function isDefaultValue(key, settings) {
   return !settingExistsInScope(key, settings);
 }
@@ -2061,6 +2077,7 @@ export {
   getRestartRequiredFromModified,
   saveModifiedSettings,
   getDisplayValue,
+  nextBooleanSettingValue,
   isDefaultValue,
   backupSettingsFile,
   restoreSettingsFromBackup,