@qwen-code/qwen-code 0.18.0 → 0.18.1

package/chunks/{chunk-3DHXZ6EV.js → chunk-SFRV6BGY.js}

@@ -1,17 +1,19 @@
 // Force strict mode and setup for ESM
 "use strict";
 import {
-  Mutex,
   getInboxesDir,
   require_proper_lockfile
-} from "./chunk-J5MDQKJL.js";
+} from "./chunk-WPTCDQN6.js";
+import {
+  Mutex
+} from "./chunk-OMX7CUOE.js";
 import {
   atomicWriteJSON
-} from "./chunk-B7HXHOHU.js";
+} from "./chunk-LXYWINWF.js";
 import {
   createDebugLogger,
   isNodeError
-} from "./chunk-HR7SV7AY.js";
+} from "./chunk-HA2UEYZP.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-7BCMOPIM.js → chunk-WJ3SND6W.js}

@@ -2,19 +2,19 @@
 "use strict";
 import {
   RequestTokenizer
-} from "./chunk-ZTZ4DDQE.js";
+} from "./chunk-3NRO6NHX.js";
 import {
   OpenAIContentConverter,
   TaggedThinkingParser,
   openaiRequestCaptureContext
-} from "./chunk-6YIUGZTC.js";
+} from "./chunk-RON7LFNH.js";
 import {
   createChildAbortController
 } from "./chunk-64WXLC72.js";
 import {
   buildRuntimeFetchOptions,
   redactProxyError
-} from "./chunk-EYENRK4D.js";
+} from "./chunk-NNIYWQIS.js";
 import {
   CAPPED_DEFAULT_MAX_TOKENS,
   DASHSCOPE_PROXY_BASE_URL,
@@ -25,14 +25,14 @@ import {
   runtimeDiagnostics,
   safeJsonParse,
   tokenLimit
-} from "./chunk-M6VTDSVR.js";
+} from "./chunk-LYSND7KR.js";
 import {
   GenerateContentResponse
 } from "./chunk-55ZMG67I.js";
 import {
   createDebugLogger,
   isAbortError
-} from "./chunk-HR7SV7AY.js";
+} from "./chunk-HA2UEYZP.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -7608,6 +7608,7 @@ init_esbuild_shims();
 
 // packages/core/src/core/openaiContentGenerator/streamingToolCallParser.ts
 init_esbuild_shims();
+var debugLogger2 = createDebugLogger("STREAMING_TOOL_CALL_PARSER");
 var StreamingToolCallParser = class {
   static {
     __name(this, "StreamingToolCallParser");
@@ -7644,6 +7645,7 @@ var StreamingToolCallParser = class {
    */
   addChunk(index, chunk, id, name) {
     let actualIndex = index;
+    const isKnownId = Boolean(id && this.idToIndexMap.has(id));
     if (id) {
       if (this.idToIndexMap.has(id)) {
         actualIndex = this.idToIndexMap.get(id);
@@ -7685,11 +7687,21 @@ var StreamingToolCallParser = class {
       this.escapes.set(actualIndex, false);
       this.toolCallMeta.set(actualIndex, {});
     }
+    const currentBuffer = this.buffers.get(actualIndex);
+    const currentDepth = this.depths.get(actualIndex);
+    if (isKnownId && currentBuffer.trim() && currentDepth === 0) {
+      try {
+        JSON.parse(currentBuffer);
+        debugLogger2.debug(
+          `Ignoring replay chunk for completed toolCall id=${id}`
+        );
+        return { complete: false };
+      } catch {
+      }
+    }
     const meta = this.toolCallMeta.get(actualIndex);
     if (id) meta.id = id;
     if (name) meta.name = name;
-    const currentBuffer = this.buffers.get(actualIndex);
-    const currentDepth = this.depths.get(actualIndex);
     const currentInString = this.inStrings.get(actualIndex);
     const currentEscape = this.escapes.get(actualIndex);
     const newBuffer = currentBuffer + chunk;
@@ -7758,9 +7770,16 @@ var StreamingToolCallParser = class {
    */
   getCompletedToolCalls() {
     const completed = [];
+    const emittedIds = /* @__PURE__ */ new Set();
     for (const [index, buffer] of this.buffers.entries()) {
       const meta = this.toolCallMeta.get(index);
       if (meta?.name && buffer.trim()) {
+        if (meta.id) {
+          if (emittedIds.has(meta.id)) {
+            continue;
+          }
+          emittedIds.add(meta.id);
+        }
         let args = {};
         try {
           args = JSON.parse(buffer);
@@ -8269,7 +8288,7 @@ var ContentGenerationPipeline = class {
 
 // packages/core/src/core/openaiContentGenerator/errorHandler.ts
 init_esbuild_shims();
-var debugLogger2 = createDebugLogger("OPENAI_ERROR");
+var debugLogger3 = createDebugLogger("OPENAI_ERROR");
 var EnhancedErrorHandler = class {
   constructor(shouldSuppressLogging = () => false) {
     this.shouldSuppressLogging = shouldSuppressLogging;
@@ -8286,7 +8305,7 @@ var EnhancedErrorHandler = class {
       isTimeoutError
     );
     if (!this.shouldSuppressErrorLogging(redactedError, request)) {
-      debugLogger2.error("OpenAI API Error:", errorMessage);
+      debugLogger3.error("OpenAI API Error:", errorMessage);
     }
     if (isTimeoutError) {
       throw new Error(
@@ -8326,7 +8345,7 @@ ${tips.join("\n")}`;
 };
 
 // packages/core/src/core/openaiContentGenerator/openaiContentGenerator.ts
-var debugLogger3 = createDebugLogger("OPENAI");
+var debugLogger4 = createDebugLogger("OPENAI");
 var OpenAIContentGenerator = class {
   static {
     __name(this, "OpenAIContentGenerator");
@@ -8369,7 +8388,7 @@ var OpenAIContentGenerator = class {
         totalTokens: result.totalTokens
       };
     } catch (error) {
-      debugLogger3.warn(
+      debugLogger4.warn(
         "Failed to calculate tokens with new tokenizer, falling back to simple method:",
         error
       );
@@ -8416,7 +8435,7 @@ var OpenAIContentGenerator = class {
       };
     } catch (error) {
       const redactedError = redactProxyError(error);
-      debugLogger3.error("OpenAI API Embedding Error:", redactedError);
+      debugLogger4.error("OpenAI API Embedding Error:", redactedError);
       throw new Error(
         `OpenAI API error: ${redactedError instanceof Error ? redactedError.message : String(redactedError)}`
       );

package/chunks/{chunk-J5MDQKJL.js → chunk-WPTCDQN6.js}

@@ -10,11 +10,11 @@ import {
 } from "./chunk-LD2XBG6Z.js";
 import {
   atomicWriteJSON
-} from "./chunk-B7HXHOHU.js";
+} from "./chunk-LXYWINWF.js";
 import {
   Storage,
   isNodeError
-} from "./chunk-HR7SV7AY.js";
+} from "./chunk-HA2UEYZP.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -1854,352 +1854,7 @@ async function listTeamNames() {
 }
 __name(listTeamNames, "listTeamNames");
 
-// node_modules/async-mutex/index.mjs
-init_esbuild_shims();
-var E_TIMEOUT = new Error("timeout while waiting for mutex to become available");
-var E_ALREADY_LOCKED = new Error("mutex already locked");
-var E_CANCELED = new Error("request for lock canceled");
-var __awaiter$2 = function(thisArg, _arguments, P, generator) {
-  function adopt(value) {
-    return value instanceof P ? value : new P(function(resolve) {
-      resolve(value);
-    });
-  }
-  __name(adopt, "adopt");
-  return new (P || (P = Promise))(function(resolve, reject) {
-    function fulfilled(value) {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    }
-    __name(fulfilled, "fulfilled");
-    function rejected(value) {
-      try {
-        step(generator["throw"](value));
-      } catch (e) {
-        reject(e);
-      }
-    }
-    __name(rejected, "rejected");
-    function step(result) {
-      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
-    }
-    __name(step, "step");
-    step((generator = generator.apply(thisArg, _arguments || [])).next());
-  });
-};
-var Semaphore = class {
-  static {
-    __name(this, "Semaphore");
-  }
-  constructor(_value, _cancelError = E_CANCELED) {
-    this._value = _value;
-    this._cancelError = _cancelError;
-    this._queue = [];
-    this._weightedWaiters = [];
-  }
-  acquire(weight = 1, priority = 0) {
-    if (weight <= 0)
-      throw new Error(`invalid weight ${weight}: must be positive`);
-    return new Promise((resolve, reject) => {
-      const task = { resolve, reject, weight, priority };
-      const i = findIndexFromEnd(this._queue, (other) => priority <= other.priority);
-      if (i === -1 && weight <= this._value) {
-        this._dispatchItem(task);
-      } else {
-        this._queue.splice(i + 1, 0, task);
-      }
-    });
-  }
-  runExclusive(callback_1) {
-    return __awaiter$2(this, arguments, void 0, function* (callback, weight = 1, priority = 0) {
-      const [value, release] = yield this.acquire(weight, priority);
-      try {
-        return yield callback(value);
-      } finally {
-        release();
-      }
-    });
-  }
-  waitForUnlock(weight = 1, priority = 0) {
-    if (weight <= 0)
-      throw new Error(`invalid weight ${weight}: must be positive`);
-    if (this._couldLockImmediately(weight, priority)) {
-      return Promise.resolve();
-    } else {
-      return new Promise((resolve) => {
-        if (!this._weightedWaiters[weight - 1])
-          this._weightedWaiters[weight - 1] = [];
-        insertSorted(this._weightedWaiters[weight - 1], { resolve, priority });
-      });
-    }
-  }
-  isLocked() {
-    return this._value <= 0;
-  }
-  getValue() {
-    return this._value;
-  }
-  setValue(value) {
-    this._value = value;
-    this._dispatchQueue();
-  }
-  release(weight = 1) {
-    if (weight <= 0)
-      throw new Error(`invalid weight ${weight}: must be positive`);
-    this._value += weight;
-    this._dispatchQueue();
-  }
-  cancel() {
-    this._queue.forEach((entry) => entry.reject(this._cancelError));
-    this._queue = [];
-  }
-  _dispatchQueue() {
-    this._drainUnlockWaiters();
-    while (this._queue.length > 0 && this._queue[0].weight <= this._value) {
-      this._dispatchItem(this._queue.shift());
-      this._drainUnlockWaiters();
-    }
-  }
-  _dispatchItem(item) {
-    const previousValue = this._value;
-    this._value -= item.weight;
-    item.resolve([previousValue, this._newReleaser(item.weight)]);
-  }
-  _newReleaser(weight) {
-    let called = false;
-    return () => {
-      if (called)
-        return;
-      called = true;
-      this.release(weight);
-    };
-  }
-  _drainUnlockWaiters() {
-    if (this._queue.length === 0) {
-      for (let weight = this._value; weight > 0; weight--) {
-        const waiters = this._weightedWaiters[weight - 1];
-        if (!waiters)
-          continue;
-        waiters.forEach((waiter) => waiter.resolve());
-        this._weightedWaiters[weight - 1] = [];
-      }
-    } else {
-      const queuedPriority = this._queue[0].priority;
-      for (let weight = this._value; weight > 0; weight--) {
-        const waiters = this._weightedWaiters[weight - 1];
-        if (!waiters)
-          continue;
-        const i = waiters.findIndex((waiter) => waiter.priority <= queuedPriority);
-        (i === -1 ? waiters : waiters.splice(0, i)).forEach((waiter) => waiter.resolve());
-      }
-    }
-  }
-  _couldLockImmediately(weight, priority) {
-    return (this._queue.length === 0 || this._queue[0].priority < priority) && weight <= this._value;
-  }
-};
-function insertSorted(a, v) {
-  const i = findIndexFromEnd(a, (other) => v.priority <= other.priority);
-  a.splice(i + 1, 0, v);
-}
-__name(insertSorted, "insertSorted");
-function findIndexFromEnd(a, predicate) {
-  for (let i = a.length - 1; i >= 0; i--) {
-    if (predicate(a[i])) {
-      return i;
-    }
-  }
-  return -1;
-}
-__name(findIndexFromEnd, "findIndexFromEnd");
-var __awaiter$1 = function(thisArg, _arguments, P, generator) {
-  function adopt(value) {
-    return value instanceof P ? value : new P(function(resolve) {
-      resolve(value);
-    });
-  }
-  __name(adopt, "adopt");
-  return new (P || (P = Promise))(function(resolve, reject) {
-    function fulfilled(value) {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    }
-    __name(fulfilled, "fulfilled");
-    function rejected(value) {
-      try {
-        step(generator["throw"](value));
-      } catch (e) {
-        reject(e);
-      }
-    }
-    __name(rejected, "rejected");
-    function step(result) {
-      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
-    }
-    __name(step, "step");
-    step((generator = generator.apply(thisArg, _arguments || [])).next());
-  });
-};
-var Mutex = class {
-  static {
-    __name(this, "Mutex");
-  }
-  constructor(cancelError) {
-    this._semaphore = new Semaphore(1, cancelError);
-  }
-  acquire() {
-    return __awaiter$1(this, arguments, void 0, function* (priority = 0) {
-      const [, releaser] = yield this._semaphore.acquire(1, priority);
-      return releaser;
-    });
-  }
-  runExclusive(callback, priority = 0) {
-    return this._semaphore.runExclusive(() => callback(), 1, priority);
-  }
-  isLocked() {
-    return this._semaphore.isLocked();
-  }
-  waitForUnlock(priority = 0) {
-    return this._semaphore.waitForUnlock(1, priority);
-  }
-  release() {
-    if (this._semaphore.isLocked())
-      this._semaphore.release();
-  }
-  cancel() {
-    return this._semaphore.cancel();
-  }
-};
-var __awaiter = function(thisArg, _arguments, P, generator) {
-  function adopt(value) {
-    return value instanceof P ? value : new P(function(resolve) {
-      resolve(value);
-    });
-  }
-  __name(adopt, "adopt");
-  return new (P || (P = Promise))(function(resolve, reject) {
-    function fulfilled(value) {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    }
-    __name(fulfilled, "fulfilled");
-    function rejected(value) {
-      try {
-        step(generator["throw"](value));
-      } catch (e) {
-        reject(e);
-      }
-    }
-    __name(rejected, "rejected");
-    function step(result) {
-      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
-    }
-    __name(step, "step");
-    step((generator = generator.apply(thisArg, _arguments || [])).next());
-  });
-};
-function withTimeout(sync, timeout, timeoutError = E_TIMEOUT) {
-  return {
-    acquire: /* @__PURE__ */ __name((weightOrPriority, priority) => {
-      let weight;
-      if (isSemaphore(sync)) {
-        weight = weightOrPriority;
-      } else {
-        weight = void 0;
-        priority = weightOrPriority;
-      }
-      if (weight !== void 0 && weight <= 0) {
-        throw new Error(`invalid weight ${weight}: must be positive`);
-      }
-      return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-        let isTimeout = false;
-        const handle = setTimeout(() => {
-          isTimeout = true;
-          reject(timeoutError);
-        }, timeout);
-        try {
-          const ticket = yield isSemaphore(sync) ? sync.acquire(weight, priority) : sync.acquire(priority);
-          if (isTimeout) {
-            const release = Array.isArray(ticket) ? ticket[1] : ticket;
-            release();
-          } else {
-            clearTimeout(handle);
-            resolve(ticket);
-          }
-        } catch (e) {
-          if (!isTimeout) {
-            clearTimeout(handle);
-            reject(e);
-          }
-        }
-      }));
-    }, "acquire"),
-    runExclusive(callback, weight, priority) {
-      return __awaiter(this, void 0, void 0, function* () {
-        let release = /* @__PURE__ */ __name(() => void 0, "release");
-        try {
-          const ticket = yield this.acquire(weight, priority);
-          if (Array.isArray(ticket)) {
-            release = ticket[1];
-            return yield callback(ticket[0]);
-          } else {
-            release = ticket;
-            return yield callback();
-          }
-        } finally {
-          release();
-        }
-      });
-    },
-    release(weight) {
-      sync.release(weight);
-    },
-    cancel() {
-      return sync.cancel();
-    },
-    waitForUnlock: /* @__PURE__ */ __name((weightOrPriority, priority) => {
-      let weight;
-      if (isSemaphore(sync)) {
-        weight = weightOrPriority;
-      } else {
-        weight = void 0;
-        priority = weightOrPriority;
-      }
-      if (weight !== void 0 && weight <= 0) {
-        throw new Error(`invalid weight ${weight}: must be positive`);
-      }
-      return new Promise((resolve, reject) => {
-        const handle = setTimeout(() => reject(timeoutError), timeout);
-        (isSemaphore(sync) ? sync.waitForUnlock(weight, priority) : sync.waitForUnlock(priority)).then(() => {
-          clearTimeout(handle);
-          resolve();
-        });
-      });
-    }, "waitForUnlock"),
-    isLocked: /* @__PURE__ */ __name(() => sync.isLocked(), "isLocked"),
-    getValue: /* @__PURE__ */ __name(() => sync.getValue(), "getValue"),
-    setValue: /* @__PURE__ */ __name((value) => sync.setValue(value), "setValue")
-  };
-}
-__name(withTimeout, "withTimeout");
-function isSemaphore(sync) {
-  return sync.getValue !== void 0;
-}
-__name(isSemaphore, "isSemaphore");
-
 export {
-  E_TIMEOUT,
-  Mutex,
-  withTimeout,
   getTeamsRootDir,
   getTeamDir,
   getTeamFilePath,

package/chunks/{chunk-PL3MVCWD.js → chunk-XZTNBSMW.js}

@@ -2,10 +2,10 @@
 "use strict";
 import {
   resolveBundleDir
-} from "./chunk-IWAYOW5Q.js";
+} from "./chunk-6T7Y7USE.js";
 import {
   Storage
-} from "./chunk-HR7SV7AY.js";
+} from "./chunk-HA2UEYZP.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -169,15 +169,15 @@ init_esbuild_shims();
 
 // import("./locales/**/*.js") in packages/cli/src/i18n/index.ts
 var globImport_locales_js = __glob({
-  "./locales/ca.js": () => import("./ca-BARBRL6N.js"),
-  "./locales/de.js": () => import("./de-YGKK2BC4.js"),
-  "./locales/en.js": () => import("./en-DHGYHIHX.js"),
-  "./locales/fr.js": () => import("./fr-JXBKPJKQ.js"),
-  "./locales/ja.js": () => import("./ja-TGPZSP2B.js"),
-  "./locales/pt.js": () => import("./pt-TIBG6BIO.js"),
-  "./locales/ru.js": () => import("./ru-JBCHCK4L.js"),
-  "./locales/zh-TW.js": () => import("./zh-TW-P4IDHD3M.js"),
-  "./locales/zh.js": () => import("./zh-7H5OQC4I.js")
+  "./locales/ca.js": () => import("./ca-RK4QPLIX.js"),
+  "./locales/de.js": () => import("./de-FGPM4KW5.js"),
+  "./locales/en.js": () => import("./en-VP6XPGEC.js"),
+  "./locales/fr.js": () => import("./fr-ATYBVCLT.js"),
+  "./locales/ja.js": () => import("./ja-W2QEA2OI.js"),
+  "./locales/pt.js": () => import("./pt-ZKEWJFBW.js"),
+  "./locales/ru.js": () => import("./ru-VEKTPJ74.js"),
+  "./locales/zh-TW.js": () => import("./zh-TW-6YFNCKTA.js"),
+  "./locales/zh.js": () => import("./zh-OIXDDQHB.js")
 });
 
 // packages/cli/src/i18n/index.ts

package/chunks/{chunk-72LDN5PP.js → chunk-Y7KMDUEP.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   getGlobalQwenDir
-} from "./chunk-JTQAQBTV.js";
+} from "./chunk-HED55F43.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-SNGELLWX.js → chunk-ZMIBJS45.js}

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

package/chunks/{chunk-XBY7E2FX.js → chunk-ZOFNJQNJ.js}

@@ -1,17 +1,19 @@
 // Force strict mode and setup for ESM
 "use strict";
 import {
-  Mutex,
   getTasksDir,
   require_proper_lockfile
-} from "./chunk-J5MDQKJL.js";
+} from "./chunk-WPTCDQN6.js";
+import {
+  Mutex
+} from "./chunk-OMX7CUOE.js";
 import {
   atomicWriteJSON
-} from "./chunk-B7HXHOHU.js";
+} from "./chunk-LXYWINWF.js";
 import {
   createDebugLogger,
   isNodeError
-} from "./chunk-HR7SV7AY.js";
+} from "./chunk-HA2UEYZP.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";