@qwen-code/qwen-code 0.19.3 → 0.19.4

package/chunks/chunk-5P5XGNYH.js

@@ -0,0 +1,93 @@
+// 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/wrappy/wrappy.js
+var require_wrappy = __commonJS({
+  "node_modules/wrappy/wrappy.js"(exports, module) {
+    init_esbuild_shims();
+    module.exports = wrappy;
+    function wrappy(fn, cb) {
+      if (fn && cb) return wrappy(fn)(cb);
+      if (typeof fn !== "function")
+        throw new TypeError("need wrapper function");
+      Object.keys(fn).forEach(function(k) {
+        wrapper[k] = fn[k];
+      });
+      return wrapper;
+      function wrapper() {
+        var args = new Array(arguments.length);
+        for (var i = 0; i < args.length; i++) {
+          args[i] = arguments[i];
+        }
+        var ret = fn.apply(this, args);
+        var cb2 = args[args.length - 1];
+        if (typeof ret === "function" && ret !== cb2) {
+          Object.keys(cb2).forEach(function(k) {
+            ret[k] = cb2[k];
+          });
+        }
+        return ret;
+      }
+      __name(wrapper, "wrapper");
+    }
+    __name(wrappy, "wrappy");
+  }
+});
+
+// node_modules/once/once.js
+var require_once = __commonJS({
+  "node_modules/once/once.js"(exports, module) {
+    init_esbuild_shims();
+    var wrappy = require_wrappy();
+    module.exports = wrappy(once);
+    module.exports.strict = wrappy(onceStrict);
+    once.proto = once(function() {
+      Object.defineProperty(Function.prototype, "once", {
+        value: /* @__PURE__ */ __name(function() {
+          return once(this);
+        }, "value"),
+        configurable: true
+      });
+      Object.defineProperty(Function.prototype, "onceStrict", {
+        value: /* @__PURE__ */ __name(function() {
+          return onceStrict(this);
+        }, "value"),
+        configurable: true
+      });
+    });
+    function once(fn) {
+      var f = /* @__PURE__ */ __name(function() {
+        if (f.called) return f.value;
+        f.called = true;
+        return f.value = fn.apply(this, arguments);
+      }, "f");
+      f.called = false;
+      return f;
+    }
+    __name(once, "once");
+    function onceStrict(fn) {
+      var f = /* @__PURE__ */ __name(function() {
+        if (f.called)
+          throw new Error(f.onceError);
+        f.called = true;
+        return f.value = fn.apply(this, arguments);
+      }, "f");
+      var name = fn.name || "Function wrapped with `once`";
+      f.onceError = name + " shouldn't be called more than once";
+      f.called = false;
+      return f;
+    }
+    __name(onceStrict, "onceStrict");
+  }
+});
+
+export {
+  require_once
+};

package/chunks/{chunk-QWFNTRH4.js → chunk-6AQR7732.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   runExitCleanup
-} from "./chunk-I2LYBGNI.js";
+} from "./chunk-FYKX6XOT.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-HZT4UCFB.js → chunk-6CIIP6OE.js}

@@ -3,18 +3,18 @@
 import {
   getGitVersion,
   getNpmVersion
-} from "./chunk-MNF6S5PR.js";
+} from "./chunk-W2ZOAX7F.js";
 import {
   STATUS_SCHEMA_VERSION,
   mapDomainErrorToErrorKind
-} from "./chunk-L7OKCI7T.js";
+} from "./chunk-GICCHL2Q.js";
 import {
   canUseRipgrep
-} from "./chunk-YAINVQ3Q.js";
+} from "./chunk-BFG6OZN7.js";
 import {
   detectRuntime,
   redactProxyCredentials
-} from "./chunk-U3KSMM7G.js";
+} from "./chunk-D5KISTLW.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-ADCIHOQZ.js → chunk-6TLY5W3B.js}

@@ -4,10 +4,10 @@ import {
   OpenAIContentConverter,
   TaggedThinkingParser,
   openaiRequestCaptureContext
-} from "./chunk-QNKBEJO2.js";
+} from "./chunk-HJDF3ZVU.js";
 import {
   RequestTokenizer
-} from "./chunk-VVLOGDB6.js";
+} from "./chunk-DX3TKXNT.js";
 import {
   DASHSCOPE_PROXY_BASE_URL,
   DEFAULT_DASHSCOPE_BASE_URL,
@@ -16,26 +16,28 @@ import {
   DEFAULT_TIMEOUT,
   MAX_STREAM_IDLE_TIMEOUT_MS,
   QWEN_STREAM_IDLE_TIMEOUT_MS_ENV,
-  buildRuntimeFetchOptions,
   hasExplicitOutputLimit,
   parsePositiveIntegerEnvValue,
-  redactProxyError,
   tokenLimit
-} from "./chunk-U3KSMM7G.js";
+} from "./chunk-YTFBURQD.js";
 import {
   runtimeDiagnostics,
   safeJsonParse
-} from "./chunk-BKXBARJZ.js";
+} from "./chunk-YPCPZSZB.js";
 import {
   GenerateContentResponse
 } from "./chunk-55ZMG67I.js";
 import {
   createChildAbortController
 } from "./chunk-64WXLC72.js";
+import {
+  buildRuntimeFetchOptions,
+  redactProxyError
+} from "./chunk-D5KISTLW.js";
 import {
   createDebugLogger,
   isAbortError
-} from "./chunk-UX4SGCGN.js";
+} from "./chunk-AVQDCKNF.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -7230,6 +7232,12 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
   getDefaultGenerationConfig() {
     return {};
   }
+  getResponseParsingOptions(model) {
+    if (this.isGlmModel(model ?? this.contentGeneratorConfig.model)) {
+      return { taggedThinkingTags: true };
+    }
+    return {};
+  }
   /**
    * Add cache control flag to specified message(s) for DashScope providers
    */
@@ -8430,7 +8438,7 @@ var ContentGenerationPipeline = class {
     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 responseParsingOptions = this.config.provider.getResponseParsingOptions?.(effectiveModel);
     const taggedThinkingParser = isStreaming && responseParsingOptions?.taggedThinkingTags ? new TaggedThinkingParser() : void 0;
     return {
       model: effectiveModel,

package/chunks/{chunk-BXSHL2SF.js → chunk-73H73ASU.js}

@@ -6,7 +6,7 @@ import {
   getNestedProperty,
   getPersistScopeForModelSelection,
   restoreSettingsFromBackup
-} from "./chunk-FKAVULLM.js";
+} from "./chunk-MKHC4BYZ.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-3TV3HUWZ.js → chunk-75X2VLSH.js}

@@ -7,28 +7,28 @@ import {
   require_jsx_runtime,
   use_stdin_default,
   use_stdout_default
-} from "./chunk-T4T2FNV4.js";
+} from "./chunk-2X2JUE47.js";
 import {
   require_react
 } from "./chunk-KYMBIKIW.js";
 import {
   sanitizeFilenameForDisplay
-} from "./chunk-JJXWTVSK.js";
+} from "./chunk-HRZB5CSC.js";
 import {
   t
-} from "./chunk-R5OP2ATH.js";
+} from "./chunk-UQYOMM6J.js";
 import {
   fetchGitDiff,
   findProviderByCredentials,
   resolveMetadataKey
-} from "./chunk-YAINVQ3Q.js";
+} from "./chunk-BFG6OZN7.js";
 import {
   KittySequenceOverflowEvent,
   logKittySequenceOverflow
-} from "./chunk-QNKBEJO2.js";
+} from "./chunk-HJDF3ZVU.js";
 import {
   createDebugLogger
-} from "./chunk-UX4SGCGN.js";
+} from "./chunk-AVQDCKNF.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -48,6 +48,7 @@ init_esbuild_shims();
 var ESC = "\x1B";
 var SGR_EVENT_PREFIX = `${ESC}[<`;
 var X11_EVENT_PREFIX = `${ESC}[M`;
+var MAX_SGR_MOUSE_SEQUENCE_LENGTH = 50;
 var SGR_MOUSE_REGEX = /^\x1b\[<(\d+);(\d+);(\d+)([mM])/;
 function getEventName(buttonCode, isRelease) {
   const isMove = (buttonCode & 32) !== 0;
@@ -107,14 +108,20 @@ function parseSGRMouseEvent(buffer) {
   };
 }
 __name(parseSGRMouseEvent, "parseSGRMouseEvent");
-var ENABLE_SGR_MOUSE = "\x1B[?1002h\x1B[?1006h";
-var DISABLE_SGR_MOUSE = "\x1B[?1006l\x1B[?1002l";
-function enableMouseEvents(stdout) {
-  stdout.write(ENABLE_SGR_MOUSE);
+var ENABLE_SGR_MOUSE = {
+  button: "\x1B[?1002h\x1B[?1006h",
+  any: "\x1B[?1003h\x1B[?1006h"
+};
+var DISABLE_SGR_MOUSE = {
+  button: "\x1B[?1006l\x1B[?1002l",
+  any: "\x1B[?1006l\x1B[?1003l"
+};
+function enableMouseEvents(stdout, tracking = "button") {
+  stdout.write(ENABLE_SGR_MOUSE[tracking]);
 }
 __name(enableMouseEvents, "enableMouseEvents");
-function disableMouseEvents(stdout) {
-  stdout.write(DISABLE_SGR_MOUSE);
+function disableMouseEvents(stdout, tracking = "button") {
+  stdout.write(DISABLE_SGR_MOUSE[tracking]);
 }
 __name(disableMouseEvents, "disableMouseEvents");
 
@@ -866,6 +873,14 @@ function KeypressProvider({
     let swallowingSgrMouse = false;
     let sgrMouseBuffer = "";
     let sgrMouseTimeout = null;
+    const resetSgrMouse = /* @__PURE__ */ __name(() => {
+      swallowingSgrMouse = false;
+      sgrMouseBuffer = "";
+      if (sgrMouseTimeout) {
+        clearTimeout(sgrMouseTimeout);
+        sgrMouseTimeout = null;
+      }
+    }, "resetSgrMouse");
     const updateKittyBuffer = /* @__PURE__ */ __name((value) => {
       kittySequenceBufferRef.current = value;
     }, "updateKittyBuffer");
@@ -1237,14 +1252,13 @@ function KeypressProvider({
       if (key.sequence === FOCUS_IN || key.sequence === FOCUS_OUT) {
         return;
       }
-      if (swallowingSgrMouse) {
+      if (isPaste) {
+        resetSgrMouse();
+      } else if (swallowingSgrMouse) {
         if (key.ctrl && key.name === "c") {
-          swallowingSgrMouse = false;
-          sgrMouseBuffer = "";
-          if (sgrMouseTimeout) {
-            clearTimeout(sgrMouseTimeout);
-            sgrMouseTimeout = null;
-          }
+          resetSgrMouse();
+        } else if (key.name === "paste-start") {
+          resetSgrMouse();
         } else {
           sgrMouseBuffer += key.sequence;
           if (key.name === "m" || key.sequence === "M") {
@@ -1260,11 +1274,13 @@ function KeypressProvider({
               }
             }
             sgrMouseBuffer = "";
+          } else if (sgrMouseBuffer.length >= MAX_SGR_MOUSE_SEQUENCE_LENGTH) {
+            resetSgrMouse();
           }
           return;
         }
       }
-      if (key.sequence === `${ESC3}[<`) {
+      if (!isPaste && key.sequence === `${ESC3}[<`) {
         swallowingSgrMouse = true;
         sgrMouseBuffer = `${ESC3}[<`;
         if (sgrMouseTimeout) {
@@ -1665,12 +1681,7 @@ function KeypressProvider({
       }
       clearKittyBufferAndTimeout();
       clearPasteIdleTimeout();
-      if (sgrMouseTimeout) {
-        clearTimeout(sgrMouseTimeout);
-        sgrMouseTimeout = null;
-      }
-      swallowingSgrMouse = false;
-      sgrMouseBuffer = "";
+      resetSgrMouse();
       if (rawFlushTimeout) {
         clearTimeout(rawFlushTimeout);
         rawFlushTimeout = null;
@@ -2157,14 +2168,33 @@ function expandCollapsedHistory(items) {
   return items.filter((item) => item.display?.kind !== "collapse-summary").map(stripSuppressOnRestore);
 }
 __name(expandCollapsedHistory, "expandCollapsedHistory");
-function applyCollapsePolicyAndSummary(rawItems, collapseOnResume) {
+function applyCollapsePolicyAndSummary(rawItems, collapseOnResume, collapsePreviewCount = 0) {
   if (!collapseOnResume) return rawItems;
-  const uiHistoryItems = applyResumeDisplayPolicy(rawItems);
-  if (rawItems.length > 0) {
+  if (collapsePreviewCount === -1) return rawItems;
+  let boundary = rawItems.length;
+  if (collapsePreviewCount > 0) {
+    let userTurnCount = 0;
+    for (let i = rawItems.length - 1; i >= 0; i--) {
+      if (rawItems[i].type === "user" /* USER */) {
+        userTurnCount++;
+        if (userTurnCount === collapsePreviewCount) {
+          boundary = i;
+          break;
+        }
+      }
+    }
+    if (userTurnCount < collapsePreviewCount) {
+      boundary = 0;
+    }
+  }
+  const hiddenItems = applyResumeDisplayPolicy(rawItems.slice(0, boundary));
+  const visibleItems = rawItems.slice(boundary);
+  const uiHistoryItems = [...hiddenItems, ...visibleItems];
+  if (boundary > 0) {
     const nextId = rawItems[rawItems.length - 1].id + 1;
     return [
       ...uiHistoryItems,
-      { id: nextId, ...createHistoryCollapseSummaryItem(rawItems.length) }
+      { id: nextId, ...createHistoryCollapseSummaryItem(boundary) }
     ];
   }
   return uiHistoryItems;

package/chunks/{chunk-6V4NZFUS.js → chunk-7KPI4LAI.js}

@@ -3,24 +3,24 @@
 import {
   AUTO_THEME_NAME,
   themeManager
-} from "./chunk-I4H7PRWQ.js";
+} from "./chunk-HTWHAN44.js";
 import {
   initializeI18n,
   resolveLanguageSetting,
   t
-} from "./chunk-R5OP2ATH.js";
+} from "./chunk-UQYOMM6J.js";
 import {
   IdeClient
-} from "./chunk-YAINVQ3Q.js";
+} from "./chunk-BFG6OZN7.js";
 import {
   AuthEvent,
   IdeConnectionEvent,
   logAuth,
   logIdeConnection
-} from "./chunk-QNKBEJO2.js";
+} from "./chunk-HJDF3ZVU.js";
 import {
   getErrorMessage
-} from "./chunk-UX4SGCGN.js";
+} from "./chunk-AVQDCKNF.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-PDE7CSDS.js → chunk-7VPC7D7O.js}

@@ -2,10 +2,10 @@
 "use strict";
 import {
   functionResponsePartsToString
-} from "./chunk-RRFZXMYP.js";
+} from "./chunk-ZXCVPMIK.js";
 import {
   parseAndFormatApiError
-} from "./chunk-YAINVQ3Q.js";
+} from "./chunk-BFG6OZN7.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/chunk-AHNXYU4O.js

@@ -0,0 +1,24 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/commands/channel/cli-entry-path.ts
+init_esbuild_shims();
+import * as path from "node:path";
+function findCliEntryPath() {
+  const mainModule = process.argv[1];
+  if (mainModule) {
+    return path.resolve(mainModule);
+  }
+  throw new Error("Cannot determine CLI entry path");
+}
+__name(findCliEntryPath, "findCliEntryPath");
+
+export {
+  findCliEntryPath
+};

package/chunks/{chunk-UX4SGCGN.js → chunk-AVQDCKNF.js}

@@ -14,6 +14,7 @@ import {
 
 // packages/core/src/utils/errors.ts
 init_esbuild_shims();
+var MAX_STRINGIFIED_ERROR_MESSAGE_LENGTH = 1e3;
 function isNodeError(error) {
   return error instanceof Error && "code" in error;
 }
@@ -52,22 +53,53 @@ function describeSingleError(err) {
     }
     return msg || codeStr || (err.name !== "Error" ? err.name : void 0);
   }
-  if (err && typeof err === "object" && "code" in err) {
-    const code = err.code;
-    if (typeof code === "string" && code) return code;
+  if (err && typeof err === "object" && !Array.isArray(err)) {
+    const rec = err;
+    const code = rec["code"];
+    const codeStr = typeof code === "string" && code ? code : typeof code === "number" ? String(code) : void 0;
+    const message = rec["message"];
+    const msg = typeof message === "string" && message.trim() ? message.trim() : void 0;
+    if (msg && codeStr && !msg.includes(codeStr)) {
+      return `${codeStr}: ${msg}`;
+    }
+    return msg || codeStr;
   }
   const str = String(err);
   return str && str !== "[object Object]" ? str : void 0;
 }
 __name(describeSingleError, "describeSingleError");
+function truncateStringifiedErrorMessage(message) {
+  if (message.length <= MAX_STRINGIFIED_ERROR_MESSAGE_LENGTH) {
+    return message;
+  }
+  return `${message.slice(0, MAX_STRINGIFIED_ERROR_MESSAGE_LENGTH - 3)}...`;
+}
+__name(truncateStringifiedErrorMessage, "truncateStringifiedErrorMessage");
 function getErrorMessage(error) {
   if (error instanceof Error) {
     const detail = describeErrorCause(error.cause);
     if (detail && detail !== error.message) {
-      return `${error.message} (cause: ${detail})`;
+      return truncateStringifiedErrorMessage(
+        `${error.message} (cause: ${detail})`
+      );
     }
     return error.message;
   }
+  if (error !== null && typeof error === "object" && !Array.isArray(error)) {
+    const { message, cause } = error;
+    if (typeof message === "string" && message.trim()) {
+      const detail = describeErrorCause(cause);
+      const result = detail && detail !== message ? `${message} (cause: ${detail})` : message;
+      return truncateStringifiedErrorMessage(result);
+    }
+    try {
+      const serialized = JSON.stringify(error);
+      return serialized ? truncateStringifiedErrorMessage(serialized) : String(error);
+    } catch {
+      const detail = describeSingleError(error);
+      return detail ? truncateStringifiedErrorMessage(detail) : String(error);
+    }
+  }
   try {
     return String(error);
   } catch {
@@ -249,27 +281,73 @@ var UNESCAPE_REGEX = (() => {
   return new RegExp(`\\\\([${inner}])`, "g");
 })();
 function tildeifyPath(filePath) {
-  const homeDir = os.homedir();
-  if (filePath === homeDir) {
+  const rawHomeDir = os.homedir();
+  if (!rawHomeDir) {
+    return filePath;
+  }
+  const homeDir = path.normalize(rawHomeDir);
+  const normalizedPath = path.normalize(filePath);
+  if (normalizedPath === homeDir) {
     return "~";
   }
-  if (filePath.startsWith(`${homeDir}${path.sep}`)) {
-    return filePath.replace(homeDir, "~");
+  if (normalizedPath.startsWith(`${homeDir}${path.sep}`)) {
+    return normalizedPath.replace(homeDir, "~");
   }
   return filePath;
 }
 __name(tildeifyPath, "tildeifyPath");
+function expandTilde(p) {
+  if (!p) {
+    return "";
+  }
+  if (p === "~") {
+    return os.homedir();
+  }
+  if (p === "~/" || p === "~\\") {
+    return os.homedir() + path.sep;
+  }
+  if (p.startsWith("~/")) {
+    return path.join(os.homedir(), p.substring(2));
+  }
+  if (p.startsWith("~\\")) {
+    const rest = p.substring(2);
+    const hasTrailingSep = rest.endsWith("/") || rest.endsWith("\\");
+    const expandedPath = path.join(
+      os.homedir(),
+      ...rest.split(/[/\\]+/).filter(Boolean)
+    );
+    return hasTrailingSep ? expandedPath + path.sep : expandedPath;
+  }
+  return p;
+}
+__name(expandTilde, "expandTilde");
 function expandHomeDir(p) {
   if (!p) {
     return "";
   }
-  let expandedPath = p;
-  if (p.toLowerCase().startsWith("%userprofile%")) {
-    expandedPath = os.homedir() + p.substring("%userprofile%".length);
-  } else if (p === "~" || p.startsWith("~/")) {
-    expandedPath = os.homedir() + p.substring(1);
+  const userProfilePrefix = "%userprofile%";
+  const lowerPath = p.toLowerCase();
+  if (lowerPath === userProfilePrefix) {
+    return path.normalize(os.homedir());
+  }
+  if (lowerPath === `${userProfilePrefix}/` || lowerPath === `${userProfilePrefix}\\`) {
+    return path.normalize(os.homedir() + path.sep);
+  }
+  if (lowerPath.startsWith(`${userProfilePrefix}/`) || lowerPath.startsWith(`${userProfilePrefix}\\`)) {
+    const rest = p.substring(userProfilePrefix.length + 1);
+    const hasTrailingSep = rest.endsWith("/") || rest.endsWith("\\");
+    const expandedPath = path.join(
+      os.homedir(),
+      ...rest.split(/[/\\]+/).filter(Boolean)
+    );
+    return path.normalize(
+      hasTrailingSep ? expandedPath + path.sep : expandedPath
+    );
+  }
+  if (lowerPath.startsWith(userProfilePrefix)) {
+    return path.normalize(os.homedir() + p.substring(userProfilePrefix.length));
   }
-  return path.normalize(expandedPath);
+  return path.normalize(expandTilde(p));
 }
 __name(expandHomeDir, "expandHomeDir");
 function shortenPath(filePath, maxLen = 80) {
@@ -386,15 +464,11 @@ function isSubpaths(parentPath, childPath) {
 }
 __name(isSubpaths, "isSubpaths");
 function resolvePath(baseDir = process.cwd(), relativePath) {
-  const homeDir = os.homedir();
-  if (relativePath === "~") {
-    return homeDir;
-  } else if (relativePath.startsWith("~/")) {
-    return path.join(homeDir, relativePath.slice(2));
-  } else if (path.isAbsolute(relativePath)) {
-    return relativePath;
+  const expandedPath = expandTilde(relativePath);
+  if (path.isAbsolute(expandedPath)) {
+    return expandedPath;
   } else {
-    return path.resolve(baseDir, relativePath);
+    return path.resolve(baseDir, expandedPath);
   }
 }
 __name(resolvePath, "resolvePath");

package/chunks/{chunk-HYCC3XM3.js → chunk-B236XPGF.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   createDebugLogger
-} from "./chunk-UX4SGCGN.js";
+} from "./chunk-AVQDCKNF.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";